Subversion Repositories Kolibri OS

Rev

Rev 6938 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. /*
  2.  * Copyright 2007-8 Advanced Micro Devices, Inc.
  3.  * Copyright 2008 Red Hat Inc.
  4.  *
  5.  * Permission is hereby granted, free of charge, to any person obtaining a
  6.  * copy of this software and associated documentation files (the "Software"),
  7.  * to deal in the Software without restriction, including without limitation
  8.  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  9.  * and/or sell copies of the Software, and to permit persons to whom the
  10.  * Software is furnished to do so, subject to the following conditions:
  11.  *
  12.  * The above copyright notice and this permission notice shall be included in
  13.  * all copies or substantial portions of the Software.
  14.  *
  15.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16.  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18.  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
  19.  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  20.  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  21.  * OTHER DEALINGS IN THE SOFTWARE.
  22.  *
  23.  * Authors: Dave Airlie
  24.  *          Alex Deucher
  25.  */
  26. #include <drm/drmP.h>
  27. #include <drm/drm_edid.h>
  28. #include <drm/drm_crtc_helper.h>
  29. #include <drm/drm_fb_helper.h>
  30. #include <drm/drm_dp_mst_helper.h>
  31. #include <drm/radeon_drm.h>
  32. #include "radeon.h"
  33. #include "radeon_audio.h"
  34. #include "atom.h"
  35.  
  36. #include <linux/pm_runtime.h>
  37. #include <linux/vga_switcheroo.h>
  38.  
  39. static int radeon_dp_handle_hpd(struct drm_connector *connector)
  40. {
  41.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  42.         int ret;
  43.  
  44.         ret = radeon_dp_mst_check_status(radeon_connector);
  45.         if (ret == -EINVAL)
  46.                 return 1;
  47.         return 0;
  48. }
  49. void radeon_connector_hotplug(struct drm_connector *connector)
  50. {
  51.         struct drm_device *dev = connector->dev;
  52.         struct radeon_device *rdev = dev->dev_private;
  53.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  54.  
  55.         if (connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort) {
  56.                 struct radeon_connector_atom_dig *dig_connector =
  57.                         radeon_connector->con_priv;
  58.  
  59.                 if (radeon_connector->is_mst_connector)
  60.                         return;
  61.                 if (dig_connector->is_mst) {
  62.                         radeon_dp_handle_hpd(connector);
  63.                         return;
  64.                 }
  65.         }
  66.         /* bail if the connector does not have hpd pin, e.g.,
  67.          * VGA, TV, etc.
  68.          */
  69.         if (radeon_connector->hpd.hpd == RADEON_HPD_NONE)
  70.                 return;
  71.  
  72.         radeon_hpd_set_polarity(rdev, radeon_connector->hpd.hpd);
  73.  
  74.         /* if the connector is already off, don't turn it back on */
  75.         /* FIXME: This access isn't protected by any locks. */
  76.         if (connector->dpms != DRM_MODE_DPMS_ON)
  77.                 return;
  78.  
  79.         /* just deal with DP (not eDP) here. */
  80.         if (connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort) {
  81.                 struct radeon_connector_atom_dig *dig_connector =
  82.                         radeon_connector->con_priv;
  83.  
  84.                 /* if existing sink type was not DP no need to retrain */
  85.                 if (dig_connector->dp_sink_type != CONNECTOR_OBJECT_ID_DISPLAYPORT)
  86.                         return;
  87.  
  88.                 /* first get sink type as it may be reset after (un)plug */
  89.                 dig_connector->dp_sink_type = radeon_dp_getsinktype(radeon_connector);
  90.                 /* don't do anything if sink is not display port, i.e.,
  91.                  * passive dp->(dvi|hdmi) adaptor
  92.                  */
  93.                 if (dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) {
  94.                         int saved_dpms = connector->dpms;
  95.                         /* Only turn off the display if it's physically disconnected */
  96.                         if (!radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) {
  97.                                 drm_helper_connector_dpms(connector, DRM_MODE_DPMS_OFF);
  98.                         } else if (radeon_dp_needs_link_train(radeon_connector)) {
  99.                                 /* Don't try to start link training before we
  100.                                  * have the dpcd */
  101.                                 if (!radeon_dp_getdpcd(radeon_connector))
  102.                                         return;
  103.  
  104.                                 /* set it to OFF so that drm_helper_connector_dpms()
  105.                                  * won't return immediately since the current state
  106.                                  * is ON at this point.
  107.                                  */
  108.                                 connector->dpms = DRM_MODE_DPMS_OFF;
  109.                                 drm_helper_connector_dpms(connector, DRM_MODE_DPMS_ON);
  110.                         }
  111.                         connector->dpms = saved_dpms;
  112.                 }
  113.         }
  114. }
  115.  
  116. static void radeon_property_change_mode(struct drm_encoder *encoder)
  117. {
  118.         struct drm_crtc *crtc = encoder->crtc;
  119.  
  120.         if (crtc && crtc->enabled) {
  121.                 drm_crtc_helper_set_mode(crtc, &crtc->mode,
  122.                                          crtc->x, crtc->y, crtc->primary->fb);
  123.         }
  124. }
  125.  
  126. int radeon_get_monitor_bpc(struct drm_connector *connector)
  127. {
  128.         struct drm_device *dev = connector->dev;
  129.         struct radeon_device *rdev = dev->dev_private;
  130.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  131.         struct radeon_connector_atom_dig *dig_connector;
  132.         int bpc = 8;
  133.         int mode_clock, max_tmds_clock;
  134.  
  135.         switch (connector->connector_type) {
  136.         case DRM_MODE_CONNECTOR_DVII:
  137.         case DRM_MODE_CONNECTOR_HDMIB:
  138.                 if (radeon_connector->use_digital) {
  139.                         if (drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
  140.                                 if (connector->display_info.bpc)
  141.                                         bpc = connector->display_info.bpc;
  142.                         }
  143.                 }
  144.                 break;
  145.         case DRM_MODE_CONNECTOR_DVID:
  146.         case DRM_MODE_CONNECTOR_HDMIA:
  147.                 if (drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
  148.                         if (connector->display_info.bpc)
  149.                                 bpc = connector->display_info.bpc;
  150.                 }
  151.                 break;
  152.         case DRM_MODE_CONNECTOR_DisplayPort:
  153.                 dig_connector = radeon_connector->con_priv;
  154.                 if ((dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) ||
  155.                     (dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_eDP) ||
  156.                     drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
  157.                         if (connector->display_info.bpc)
  158.                                 bpc = connector->display_info.bpc;
  159.                 }
  160.                 break;
  161.         case DRM_MODE_CONNECTOR_eDP:
  162.         case DRM_MODE_CONNECTOR_LVDS:
  163.                 if (connector->display_info.bpc)
  164.                         bpc = connector->display_info.bpc;
  165.                 else if (ASIC_IS_DCE41(rdev) || ASIC_IS_DCE5(rdev)) {
  166.                         const struct drm_connector_helper_funcs *connector_funcs =
  167.                                 connector->helper_private;
  168.                         struct drm_encoder *encoder = connector_funcs->best_encoder(connector);
  169.                         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
  170.                         struct radeon_encoder_atom_dig *dig = radeon_encoder->enc_priv;
  171.  
  172.                         if (dig->lcd_misc & ATOM_PANEL_MISC_V13_6BIT_PER_COLOR)
  173.                                 bpc = 6;
  174.                         else if (dig->lcd_misc & ATOM_PANEL_MISC_V13_8BIT_PER_COLOR)
  175.                                 bpc = 8;
  176.                 }
  177.                 break;
  178.         }
  179.  
  180.         if (drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
  181.                 /* hdmi deep color only implemented on DCE4+ */
  182.                 if ((bpc > 8) && !ASIC_IS_DCE4(rdev)) {
  183.                         DRM_DEBUG("%s: HDMI deep color %d bpc unsupported. Using 8 bpc.\n",
  184.                                           connector->name, bpc);
  185.                         bpc = 8;
  186.                 }
  187.  
  188.                 /*
  189.                  * Pre DCE-8 hw can't handle > 12 bpc, and more than 12 bpc doesn't make
  190.                  * much sense without support for > 12 bpc framebuffers. RGB 4:4:4 at
  191.                  * 12 bpc is always supported on hdmi deep color sinks, as this is
  192.                  * required by the HDMI-1.3 spec. Clamp to a safe 12 bpc maximum.
  193.                  */
  194.                 if (bpc > 12) {
  195.                         DRM_DEBUG("%s: HDMI deep color %d bpc unsupported. Using 12 bpc.\n",
  196.                                           connector->name, bpc);
  197.                         bpc = 12;
  198.                 }
  199.  
  200.                 /* Any defined maximum tmds clock limit we must not exceed? */
  201.                 if (connector->max_tmds_clock > 0) {
  202.                         /* mode_clock is clock in kHz for mode to be modeset on this connector */
  203.                         mode_clock = radeon_connector->pixelclock_for_modeset;
  204.  
  205.                         /* Maximum allowable input clock in kHz */
  206.                         max_tmds_clock = connector->max_tmds_clock * 1000;
  207.  
  208.                         DRM_DEBUG("%s: hdmi mode dotclock %d kHz, max tmds input clock %d kHz.\n",
  209.                                           connector->name, mode_clock, max_tmds_clock);
  210.  
  211.                         /* Check if bpc is within clock limit. Try to degrade gracefully otherwise */
  212.                         if ((bpc == 12) && (mode_clock * 3/2 > max_tmds_clock)) {
  213.                                 if ((connector->display_info.edid_hdmi_dc_modes & DRM_EDID_HDMI_DC_30) &&
  214.                                         (mode_clock * 5/4 <= max_tmds_clock))
  215.                                         bpc = 10;
  216.                                 else
  217.                                         bpc = 8;
  218.  
  219.                                 DRM_DEBUG("%s: HDMI deep color 12 bpc exceeds max tmds clock. Using %d bpc.\n",
  220.                                                   connector->name, bpc);
  221.                         }
  222.  
  223.                         if ((bpc == 10) && (mode_clock * 5/4 > max_tmds_clock)) {
  224.                                 bpc = 8;
  225.                                 DRM_DEBUG("%s: HDMI deep color 10 bpc exceeds max tmds clock. Using %d bpc.\n",
  226.                                                   connector->name, bpc);
  227.                         }
  228.                 }
  229.                 else if (bpc > 8) {
  230.                         /* max_tmds_clock missing, but hdmi spec mandates it for deep color. */
  231.                         DRM_DEBUG("%s: Required max tmds clock for HDMI deep color missing. Using 8 bpc.\n",
  232.                                           connector->name);
  233.                         bpc = 8;
  234.                 }
  235.         }
  236.  
  237.         if ((radeon_deep_color == 0) && (bpc > 8)) {
  238.                 DRM_DEBUG("%s: Deep color disabled. Set radeon module param deep_color=1 to enable.\n",
  239.                                   connector->name);
  240.                 bpc = 8;
  241.         }
  242.  
  243.         DRM_DEBUG("%s: Display bpc=%d, returned bpc=%d\n",
  244.                           connector->name, connector->display_info.bpc, bpc);
  245.  
  246.         return bpc;
  247. }
  248.  
  249. static void
  250. radeon_connector_update_scratch_regs(struct drm_connector *connector, enum drm_connector_status status)
  251. {
  252.         struct drm_device *dev = connector->dev;
  253.         struct radeon_device *rdev = dev->dev_private;
  254.         struct drm_encoder *best_encoder = NULL;
  255.         struct drm_encoder *encoder = NULL;
  256.         const struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
  257.         bool connected;
  258.         int i;
  259.  
  260.         best_encoder = connector_funcs->best_encoder(connector);
  261.  
  262.         for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
  263.                 if (connector->encoder_ids[i] == 0)
  264.                         break;
  265.  
  266.                 encoder = drm_encoder_find(connector->dev,
  267.                                            connector->encoder_ids[i]);
  268.                 if (!encoder)
  269.                         continue;
  270.  
  271.                 if ((encoder == best_encoder) && (status == connector_status_connected))
  272.                         connected = true;
  273.                 else
  274.                         connected = false;
  275.  
  276.                 if (rdev->is_atom_bios)
  277.                         radeon_atombios_connected_scratch_regs(connector, encoder, connected);
  278.                 else
  279.                         radeon_combios_connected_scratch_regs(connector, encoder, connected);
  280.  
  281.         }
  282. }
  283.  
  284. static struct drm_encoder *radeon_find_encoder(struct drm_connector *connector, int encoder_type)
  285. {
  286.         struct drm_encoder *encoder;
  287.         int i;
  288.  
  289.         for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
  290.                 if (connector->encoder_ids[i] == 0)
  291.                         break;
  292.  
  293.                 encoder = drm_encoder_find(connector->dev, connector->encoder_ids[i]);
  294.                 if (!encoder)
  295.                         continue;
  296.  
  297.                 if (encoder->encoder_type == encoder_type)
  298.                         return encoder;
  299.         }
  300.         return NULL;
  301. }
  302.  
  303. struct edid *radeon_connector_edid(struct drm_connector *connector)
  304. {
  305.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  306.         struct drm_property_blob *edid_blob = connector->edid_blob_ptr;
  307.  
  308.         if (radeon_connector->edid) {
  309.                 return radeon_connector->edid;
  310.         } else if (edid_blob) {
  311.                 struct edid *edid = kmemdup(edid_blob->data, edid_blob->length, GFP_KERNEL);
  312.                 if (edid)
  313.                         radeon_connector->edid = edid;
  314.         }
  315.         return radeon_connector->edid;
  316. }
  317.  
  318. static void radeon_connector_get_edid(struct drm_connector *connector)
  319. {
  320.         struct drm_device *dev = connector->dev;
  321.         struct radeon_device *rdev = dev->dev_private;
  322.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  323.  
  324.         if (radeon_connector->edid)
  325.                 return;
  326.  
  327.         /* on hw with routers, select right port */
  328.         if (radeon_connector->router.ddc_valid)
  329.                 radeon_router_select_ddc_port(radeon_connector);
  330.  
  331.         if ((radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
  332.              ENCODER_OBJECT_ID_NONE) &&
  333.             radeon_connector->ddc_bus->has_aux) {
  334.                 radeon_connector->edid = drm_get_edid(connector,
  335.                                                       &radeon_connector->ddc_bus->aux.ddc);
  336.         } else if ((connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort) ||
  337.                    (connector->connector_type == DRM_MODE_CONNECTOR_eDP)) {
  338.                 struct radeon_connector_atom_dig *dig = radeon_connector->con_priv;
  339.  
  340.                 if ((dig->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT ||
  341.                      dig->dp_sink_type == CONNECTOR_OBJECT_ID_eDP) &&
  342.                     radeon_connector->ddc_bus->has_aux)
  343.                         radeon_connector->edid = drm_get_edid(&radeon_connector->base,
  344.                                                               &radeon_connector->ddc_bus->aux.ddc);
  345.                 else if (radeon_connector->ddc_bus)
  346.                         radeon_connector->edid = drm_get_edid(&radeon_connector->base,
  347.                                                               &radeon_connector->ddc_bus->adapter);
  348.         } else if (vga_switcheroo_handler_flags() & VGA_SWITCHEROO_CAN_SWITCH_DDC &&
  349.                    connector->connector_type == DRM_MODE_CONNECTOR_LVDS &&
  350.                    radeon_connector->ddc_bus) {
  351.                 radeon_connector->edid = drm_get_edid_switcheroo(&radeon_connector->base,
  352.                                                                  &radeon_connector->ddc_bus->adapter);
  353.         } else if (radeon_connector->ddc_bus) {
  354.                 radeon_connector->edid = drm_get_edid(&radeon_connector->base,
  355.                                                       &radeon_connector->ddc_bus->adapter);
  356.         }
  357.  
  358.         if (!radeon_connector->edid) {
  359.                 /* don't fetch the edid from the vbios if ddc fails and runpm is
  360.                  * enabled so we report disconnected.
  361.                  */
  362.                 if ((rdev->flags & RADEON_IS_PX) && (radeon_runtime_pm != 0))
  363.                         return;
  364.  
  365.                 if (rdev->is_atom_bios) {
  366.                         /* some laptops provide a hardcoded edid in rom for LCDs */
  367.                         if (((connector->connector_type == DRM_MODE_CONNECTOR_LVDS) ||
  368.                              (connector->connector_type == DRM_MODE_CONNECTOR_eDP)))
  369.                                 radeon_connector->edid = radeon_bios_get_hardcoded_edid(rdev);
  370.                 } else {
  371.                         /* some servers provide a hardcoded edid in rom for KVMs */
  372.                         radeon_connector->edid = radeon_bios_get_hardcoded_edid(rdev);
  373.                 }
  374.         }
  375. }
  376.  
  377. static void radeon_connector_free_edid(struct drm_connector *connector)
  378. {
  379.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  380.  
  381.         if (radeon_connector->edid) {
  382.                 kfree(radeon_connector->edid);
  383.                 radeon_connector->edid = NULL;
  384.         }
  385. }
  386.  
  387. static int radeon_ddc_get_modes(struct drm_connector *connector)
  388. {
  389.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  390.         int ret;
  391.  
  392.         if (radeon_connector->edid) {
  393.                 drm_mode_connector_update_edid_property(connector, radeon_connector->edid);
  394.                 ret = drm_add_edid_modes(connector, radeon_connector->edid);
  395.                 drm_edid_to_eld(connector, radeon_connector->edid);
  396.                 return ret;
  397.         }
  398.         drm_mode_connector_update_edid_property(connector, NULL);
  399.         return 0;
  400. }
  401.  
  402. static struct drm_encoder *radeon_best_single_encoder(struct drm_connector *connector)
  403. {
  404.         int enc_id = connector->encoder_ids[0];
  405.         /* pick the encoder ids */
  406.         if (enc_id)
  407.                 return drm_encoder_find(connector->dev, enc_id);
  408.         return NULL;
  409. }
  410.  
  411. static void radeon_get_native_mode(struct drm_connector *connector)
  412. {
  413.         struct drm_encoder *encoder = radeon_best_single_encoder(connector);
  414.         struct radeon_encoder *radeon_encoder;
  415.  
  416.         if (encoder == NULL)
  417.                 return;
  418.  
  419.         radeon_encoder = to_radeon_encoder(encoder);
  420.  
  421.         if (!list_empty(&connector->probed_modes)) {
  422.                 struct drm_display_mode *preferred_mode =
  423.                         list_first_entry(&connector->probed_modes,
  424.                                          struct drm_display_mode, head);
  425.  
  426.                 radeon_encoder->native_mode = *preferred_mode;
  427.         } else {
  428.                 radeon_encoder->native_mode.clock = 0;
  429.         }
  430. }
  431.  
  432. /*
  433.  * radeon_connector_analog_encoder_conflict_solve
  434.  * - search for other connectors sharing this encoder
  435.  *   if priority is true, then set them disconnected if this is connected
  436.  *   if priority is false, set us disconnected if they are connected
  437.  */
  438. static enum drm_connector_status
  439. radeon_connector_analog_encoder_conflict_solve(struct drm_connector *connector,
  440.                                                struct drm_encoder *encoder,
  441.                                                enum drm_connector_status current_status,
  442.                                                bool priority)
  443. {
  444.         struct drm_device *dev = connector->dev;
  445.         struct drm_connector *conflict;
  446.         struct radeon_connector *radeon_conflict;
  447.         int i;
  448.  
  449.         list_for_each_entry(conflict, &dev->mode_config.connector_list, head) {
  450.                 if (conflict == connector)
  451.                         continue;
  452.  
  453.                 radeon_conflict = to_radeon_connector(conflict);
  454.                 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
  455.                         if (conflict->encoder_ids[i] == 0)
  456.                                 break;
  457.  
  458.                         /* if the IDs match */
  459.                         if (conflict->encoder_ids[i] == encoder->base.id) {
  460.                                 if (conflict->status != connector_status_connected)
  461.                                         continue;
  462.  
  463.                                 if (radeon_conflict->use_digital)
  464.                                         continue;
  465.  
  466.                                 if (priority == true) {
  467.                                         DRM_DEBUG_KMS("1: conflicting encoders switching off %s\n",
  468.                                                       conflict->name);
  469.                                         DRM_DEBUG_KMS("in favor of %s\n",
  470.                                                       connector->name);
  471.                                         conflict->status = connector_status_disconnected;
  472.                                         radeon_connector_update_scratch_regs(conflict, connector_status_disconnected);
  473.                                 } else {
  474.                                         DRM_DEBUG_KMS("2: conflicting encoders switching off %s\n",
  475.                                                       connector->name);
  476.                                         DRM_DEBUG_KMS("in favor of %s\n",
  477.                                                       conflict->name);
  478.                                         current_status = connector_status_disconnected;
  479.                                 }
  480.                                 break;
  481.                         }
  482.                 }
  483.         }
  484.         return current_status;
  485.  
  486. }
  487.  
  488. static struct drm_display_mode *radeon_fp_native_mode(struct drm_encoder *encoder)
  489. {
  490.         struct drm_device *dev = encoder->dev;
  491.         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
  492.         struct drm_display_mode *mode = NULL;
  493.         struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
  494.  
  495.         if (native_mode->hdisplay != 0 &&
  496.             native_mode->vdisplay != 0 &&
  497.             native_mode->clock != 0) {
  498.                 mode = drm_mode_duplicate(dev, native_mode);
  499.                 mode->type = DRM_MODE_TYPE_PREFERRED | DRM_MODE_TYPE_DRIVER;
  500.                 drm_mode_set_name(mode);
  501.  
  502.                 DRM_DEBUG_KMS("Adding native panel mode %s\n", mode->name);
  503.         } else if (native_mode->hdisplay != 0 &&
  504.                    native_mode->vdisplay != 0) {
  505.                 /* mac laptops without an edid */
  506.                 /* Note that this is not necessarily the exact panel mode,
  507.                  * but an approximation based on the cvt formula.  For these
  508.                  * systems we should ideally read the mode info out of the
  509.                  * registers or add a mode table, but this works and is much
  510.                  * simpler.
  511.                  */
  512.                 mode = drm_cvt_mode(dev, native_mode->hdisplay, native_mode->vdisplay, 60, true, false, false);
  513.                 mode->type = DRM_MODE_TYPE_PREFERRED | DRM_MODE_TYPE_DRIVER;
  514.                 DRM_DEBUG_KMS("Adding cvt approximation of native panel mode %s\n", mode->name);
  515.         }
  516.         return mode;
  517. }
  518.  
  519. static void radeon_add_common_modes(struct drm_encoder *encoder, struct drm_connector *connector)
  520. {
  521.         struct drm_device *dev = encoder->dev;
  522.         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
  523.         struct drm_display_mode *mode = NULL;
  524.         struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
  525.         int i;
  526.         struct mode_size {
  527.                 int w;
  528.                 int h;
  529.         } common_modes[17] = {
  530.                 { 640,  480},
  531.                 { 720,  480},
  532.                 { 800,  600},
  533.                 { 848,  480},
  534.                 {1024,  768},
  535.                 {1152,  768},
  536.                 {1280,  720},
  537.                 {1280,  800},
  538.                 {1280,  854},
  539.                 {1280,  960},
  540.                 {1280, 1024},
  541.                 {1440,  900},
  542.                 {1400, 1050},
  543.                 {1680, 1050},
  544.                 {1600, 1200},
  545.                 {1920, 1080},
  546.                 {1920, 1200}
  547.         };
  548.  
  549.         for (i = 0; i < 17; i++) {
  550.                 if (radeon_encoder->devices & (ATOM_DEVICE_TV_SUPPORT)) {
  551.                         if (common_modes[i].w > 1024 ||
  552.                             common_modes[i].h > 768)
  553.                                 continue;
  554.                 }
  555.                 if (radeon_encoder->devices & (ATOM_DEVICE_LCD_SUPPORT)) {
  556.                         if (common_modes[i].w > native_mode->hdisplay ||
  557.                             common_modes[i].h > native_mode->vdisplay ||
  558.                             (common_modes[i].w == native_mode->hdisplay &&
  559.                              common_modes[i].h == native_mode->vdisplay))
  560.                                 continue;
  561.                 }
  562.                 if (common_modes[i].w < 320 || common_modes[i].h < 200)
  563.                         continue;
  564.  
  565.                 mode = drm_cvt_mode(dev, common_modes[i].w, common_modes[i].h, 60, false, false, false);
  566.                 drm_mode_probed_add(connector, mode);
  567.         }
  568. }
  569.  
  570. static int radeon_connector_set_property(struct drm_connector *connector, struct drm_property *property,
  571.                                   uint64_t val)
  572. {
  573.         struct drm_device *dev = connector->dev;
  574.         struct radeon_device *rdev = dev->dev_private;
  575.         struct drm_encoder *encoder;
  576.         struct radeon_encoder *radeon_encoder;
  577.  
  578.         if (property == rdev->mode_info.coherent_mode_property) {
  579.                 struct radeon_encoder_atom_dig *dig;
  580.                 bool new_coherent_mode;
  581.  
  582.                 /* need to find digital encoder on connector */
  583.                 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
  584.                 if (!encoder)
  585.                         return 0;
  586.  
  587.                 radeon_encoder = to_radeon_encoder(encoder);
  588.  
  589.                 if (!radeon_encoder->enc_priv)
  590.                         return 0;
  591.  
  592.                 dig = radeon_encoder->enc_priv;
  593.                 new_coherent_mode = val ? true : false;
  594.                 if (dig->coherent_mode != new_coherent_mode) {
  595.                         dig->coherent_mode = new_coherent_mode;
  596.                         radeon_property_change_mode(&radeon_encoder->base);
  597.                 }
  598.         }
  599.  
  600.         if (property == rdev->mode_info.audio_property) {
  601.                 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  602.                 /* need to find digital encoder on connector */
  603.                 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
  604.                 if (!encoder)
  605.                         return 0;
  606.  
  607.                 radeon_encoder = to_radeon_encoder(encoder);
  608.  
  609.                 if (radeon_connector->audio != val) {
  610.                         radeon_connector->audio = val;
  611.                         radeon_property_change_mode(&radeon_encoder->base);
  612.                 }
  613.         }
  614.  
  615.         if (property == rdev->mode_info.dither_property) {
  616.                 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  617.                 /* need to find digital encoder on connector */
  618.                 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
  619.                 if (!encoder)
  620.                         return 0;
  621.  
  622.                 radeon_encoder = to_radeon_encoder(encoder);
  623.  
  624.                 if (radeon_connector->dither != val) {
  625.                         radeon_connector->dither = val;
  626.                         radeon_property_change_mode(&radeon_encoder->base);
  627.                 }
  628.         }
  629.  
  630.         if (property == rdev->mode_info.underscan_property) {
  631.                 /* need to find digital encoder on connector */
  632.                 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
  633.                 if (!encoder)
  634.                         return 0;
  635.  
  636.                 radeon_encoder = to_radeon_encoder(encoder);
  637.  
  638.                 if (radeon_encoder->underscan_type != val) {
  639.                         radeon_encoder->underscan_type = val;
  640.                         radeon_property_change_mode(&radeon_encoder->base);
  641.                 }
  642.         }
  643.  
  644.         if (property == rdev->mode_info.underscan_hborder_property) {
  645.                 /* need to find digital encoder on connector */
  646.                 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
  647.                 if (!encoder)
  648.                         return 0;
  649.  
  650.                 radeon_encoder = to_radeon_encoder(encoder);
  651.  
  652.                 if (radeon_encoder->underscan_hborder != val) {
  653.                         radeon_encoder->underscan_hborder = val;
  654.                         radeon_property_change_mode(&radeon_encoder->base);
  655.                 }
  656.         }
  657.  
  658.         if (property == rdev->mode_info.underscan_vborder_property) {
  659.                 /* need to find digital encoder on connector */
  660.                 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
  661.                 if (!encoder)
  662.                         return 0;
  663.  
  664.                 radeon_encoder = to_radeon_encoder(encoder);
  665.  
  666.                 if (radeon_encoder->underscan_vborder != val) {
  667.                         radeon_encoder->underscan_vborder = val;
  668.                         radeon_property_change_mode(&radeon_encoder->base);
  669.                 }
  670.         }
  671.  
  672.         if (property == rdev->mode_info.tv_std_property) {
  673.                 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TVDAC);
  674.                 if (!encoder) {
  675.                         encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_DAC);
  676.                 }
  677.  
  678.                 if (!encoder)
  679.                         return 0;
  680.  
  681.                 radeon_encoder = to_radeon_encoder(encoder);
  682.                 if (!radeon_encoder->enc_priv)
  683.                         return 0;
  684.                 if (ASIC_IS_AVIVO(rdev) || radeon_r4xx_atom) {
  685.                         struct radeon_encoder_atom_dac *dac_int;
  686.                         dac_int = radeon_encoder->enc_priv;
  687.                         dac_int->tv_std = val;
  688.                 } else {
  689.                         struct radeon_encoder_tv_dac *dac_int;
  690.                         dac_int = radeon_encoder->enc_priv;
  691.                         dac_int->tv_std = val;
  692.                 }
  693.                 radeon_property_change_mode(&radeon_encoder->base);
  694.         }
  695.  
  696.         if (property == rdev->mode_info.load_detect_property) {
  697.                 struct radeon_connector *radeon_connector =
  698.                         to_radeon_connector(connector);
  699.  
  700.                 if (val == 0)
  701.                         radeon_connector->dac_load_detect = false;
  702.                 else
  703.                         radeon_connector->dac_load_detect = true;
  704.         }
  705.  
  706.         if (property == rdev->mode_info.tmds_pll_property) {
  707.                 struct radeon_encoder_int_tmds *tmds = NULL;
  708.                 bool ret = false;
  709.                 /* need to find digital encoder on connector */
  710.                 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
  711.                 if (!encoder)
  712.                         return 0;
  713.  
  714.                 radeon_encoder = to_radeon_encoder(encoder);
  715.  
  716.                 tmds = radeon_encoder->enc_priv;
  717.                 if (!tmds)
  718.                         return 0;
  719.  
  720.                 if (val == 0) {
  721.                         if (rdev->is_atom_bios)
  722.                                 ret = radeon_atombios_get_tmds_info(radeon_encoder, tmds);
  723.                         else
  724.                                 ret = radeon_legacy_get_tmds_info_from_combios(radeon_encoder, tmds);
  725.                 }
  726.                 if (val == 1 || ret == false) {
  727.                         radeon_legacy_get_tmds_info_from_table(radeon_encoder, tmds);
  728.                 }
  729.                 radeon_property_change_mode(&radeon_encoder->base);
  730.         }
  731.  
  732.         if (property == dev->mode_config.scaling_mode_property) {
  733.                 enum radeon_rmx_type rmx_type;
  734.  
  735.                 if (connector->encoder)
  736.                         radeon_encoder = to_radeon_encoder(connector->encoder);
  737.                 else {
  738.                         const struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
  739.                         radeon_encoder = to_radeon_encoder(connector_funcs->best_encoder(connector));
  740.                 }
  741.  
  742.                 switch (val) {
  743.                 default:
  744.                 case DRM_MODE_SCALE_NONE: rmx_type = RMX_OFF; break;
  745.                 case DRM_MODE_SCALE_CENTER: rmx_type = RMX_CENTER; break;
  746.                 case DRM_MODE_SCALE_ASPECT: rmx_type = RMX_ASPECT; break;
  747.                 case DRM_MODE_SCALE_FULLSCREEN: rmx_type = RMX_FULL; break;
  748.                 }
  749.                 if (radeon_encoder->rmx_type == rmx_type)
  750.                         return 0;
  751.  
  752.                 if ((rmx_type != DRM_MODE_SCALE_NONE) &&
  753.                     (radeon_encoder->native_mode.clock == 0))
  754.                         return 0;
  755.  
  756.                 radeon_encoder->rmx_type = rmx_type;
  757.  
  758.                 radeon_property_change_mode(&radeon_encoder->base);
  759.         }
  760.  
  761.         if (property == rdev->mode_info.output_csc_property) {
  762.                 if (connector->encoder)
  763.                         radeon_encoder = to_radeon_encoder(connector->encoder);
  764.                 else {
  765.                         const struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
  766.                         radeon_encoder = to_radeon_encoder(connector_funcs->best_encoder(connector));
  767.                 }
  768.  
  769.                 if (radeon_encoder->output_csc == val)
  770.                         return 0;
  771.  
  772.                 radeon_encoder->output_csc = val;
  773.  
  774.                 if (connector->encoder->crtc) {
  775.                         struct drm_crtc *crtc  = connector->encoder->crtc;
  776.                         const struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
  777.                         struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc);
  778.  
  779.                         radeon_crtc->output_csc = radeon_encoder->output_csc;
  780.  
  781.                         (*crtc_funcs->load_lut)(crtc);
  782.                 }
  783.         }
  784.  
  785.         return 0;
  786. }
  787.  
  788. static void radeon_fixup_lvds_native_mode(struct drm_encoder *encoder,
  789.                                           struct drm_connector *connector)
  790. {
  791.         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
  792.         struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
  793.         struct drm_display_mode *t, *mode;
  794.  
  795.         /* If the EDID preferred mode doesn't match the native mode, use it */
  796.         list_for_each_entry_safe(mode, t, &connector->probed_modes, head) {
  797.                 if (mode->type & DRM_MODE_TYPE_PREFERRED) {
  798.                         if (mode->hdisplay != native_mode->hdisplay ||
  799.                             mode->vdisplay != native_mode->vdisplay)
  800.                                 memcpy(native_mode, mode, sizeof(*mode));
  801.                 }
  802.         }
  803.  
  804.         /* Try to get native mode details from EDID if necessary */
  805.         if (!native_mode->clock) {
  806.                 list_for_each_entry_safe(mode, t, &connector->probed_modes, head) {
  807.                         if (mode->hdisplay == native_mode->hdisplay &&
  808.                             mode->vdisplay == native_mode->vdisplay) {
  809.                                 *native_mode = *mode;
  810.                                 drm_mode_set_crtcinfo(native_mode, CRTC_INTERLACE_HALVE_V);
  811.                                 DRM_DEBUG_KMS("Determined LVDS native mode details from EDID\n");
  812.                                 break;
  813.                         }
  814.                 }
  815.         }
  816.  
  817.         if (!native_mode->clock) {
  818.                 DRM_DEBUG_KMS("No LVDS native mode details, disabling RMX\n");
  819.                 radeon_encoder->rmx_type = RMX_OFF;
  820.         }
  821. }
  822.  
  823. static int radeon_lvds_get_modes(struct drm_connector *connector)
  824. {
  825.         struct drm_encoder *encoder;
  826.         int ret = 0;
  827.         struct drm_display_mode *mode;
  828.  
  829.         radeon_connector_get_edid(connector);
  830.         ret = radeon_ddc_get_modes(connector);
  831.         if (ret > 0) {
  832.                 encoder = radeon_best_single_encoder(connector);
  833.                 if (encoder) {
  834.                         radeon_fixup_lvds_native_mode(encoder, connector);
  835.                         /* add scaled modes */
  836.                         radeon_add_common_modes(encoder, connector);
  837.                 }
  838.                 return ret;
  839.         }
  840.  
  841.         encoder = radeon_best_single_encoder(connector);
  842.         if (!encoder)
  843.                 return 0;
  844.  
  845.         /* we have no EDID modes */
  846.         mode = radeon_fp_native_mode(encoder);
  847.         if (mode) {
  848.                 ret = 1;
  849.                 drm_mode_probed_add(connector, mode);
  850.                 /* add the width/height from vbios tables if available */
  851.                 connector->display_info.width_mm = mode->width_mm;
  852.                 connector->display_info.height_mm = mode->height_mm;
  853.                 /* add scaled modes */
  854.                 radeon_add_common_modes(encoder, connector);
  855.         }
  856.  
  857.         return ret;
  858. }
  859.  
  860. static int radeon_lvds_mode_valid(struct drm_connector *connector,
  861.                                   struct drm_display_mode *mode)
  862. {
  863.         struct drm_encoder *encoder = radeon_best_single_encoder(connector);
  864.  
  865.         if ((mode->hdisplay < 320) || (mode->vdisplay < 240))
  866.                 return MODE_PANEL;
  867.  
  868.         if (encoder) {
  869.                 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
  870.                 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
  871.  
  872.                 /* AVIVO hardware supports downscaling modes larger than the panel
  873.                  * to the panel size, but I'm not sure this is desirable.
  874.                  */
  875.                 if ((mode->hdisplay > native_mode->hdisplay) ||
  876.                     (mode->vdisplay > native_mode->vdisplay))
  877.                         return MODE_PANEL;
  878.  
  879.                 /* if scaling is disabled, block non-native modes */
  880.                 if (radeon_encoder->rmx_type == RMX_OFF) {
  881.                         if ((mode->hdisplay != native_mode->hdisplay) ||
  882.                             (mode->vdisplay != native_mode->vdisplay))
  883.                                 return MODE_PANEL;
  884.                 }
  885.         }
  886.  
  887.         return MODE_OK;
  888. }
  889.  
  890. static enum drm_connector_status
  891. radeon_lvds_detect(struct drm_connector *connector, bool force)
  892. {
  893.         struct drm_device *dev = connector->dev;
  894.         struct radeon_device *rdev = dev->dev_private;
  895.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  896.         struct drm_encoder *encoder = radeon_best_single_encoder(connector);
  897.         enum drm_connector_status ret = connector_status_disconnected;
  898.  
  899.         if (encoder) {
  900.                 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
  901.                 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
  902.  
  903.                 /* check if panel is valid */
  904.                 if (native_mode->hdisplay >= 320 && native_mode->vdisplay >= 240)
  905.                         ret = connector_status_connected;
  906.                 /* don't fetch the edid from the vbios if ddc fails and runpm is
  907.                  * enabled so we report disconnected.
  908.                  */
  909.                 if ((rdev->flags & RADEON_IS_PX) && (radeon_runtime_pm != 0))
  910.                         ret = connector_status_disconnected;
  911.         }
  912.  
  913.         /* check for edid as well */
  914.         radeon_connector_get_edid(connector);
  915.         if (radeon_connector->edid)
  916.                 ret = connector_status_connected;
  917.         /* check acpi lid status ??? */
  918.  
  919.         radeon_connector_update_scratch_regs(connector, ret);
  920.         return ret;
  921. }
  922.  
  923. static void radeon_connector_destroy(struct drm_connector *connector)
  924. {
  925.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  926.  
  927.         radeon_connector_free_edid(connector);
  928.         kfree(radeon_connector->con_priv);
  929.         drm_connector_unregister(connector);
  930.         drm_connector_cleanup(connector);
  931.         kfree(connector);
  932. }
  933.  
  934. static int radeon_lvds_set_property(struct drm_connector *connector,
  935.                                     struct drm_property *property,
  936.                                     uint64_t value)
  937. {
  938.         struct drm_device *dev = connector->dev;
  939.         struct radeon_encoder *radeon_encoder;
  940.         enum radeon_rmx_type rmx_type;
  941.  
  942.         DRM_DEBUG_KMS("\n");
  943.         if (property != dev->mode_config.scaling_mode_property)
  944.                 return 0;
  945.  
  946.         if (connector->encoder)
  947.                 radeon_encoder = to_radeon_encoder(connector->encoder);
  948.         else {
  949.                 const struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
  950.                 radeon_encoder = to_radeon_encoder(connector_funcs->best_encoder(connector));
  951.         }
  952.  
  953.         switch (value) {
  954.         case DRM_MODE_SCALE_NONE: rmx_type = RMX_OFF; break;
  955.         case DRM_MODE_SCALE_CENTER: rmx_type = RMX_CENTER; break;
  956.         case DRM_MODE_SCALE_ASPECT: rmx_type = RMX_ASPECT; break;
  957.         default:
  958.         case DRM_MODE_SCALE_FULLSCREEN: rmx_type = RMX_FULL; break;
  959.         }
  960.         if (radeon_encoder->rmx_type == rmx_type)
  961.                 return 0;
  962.  
  963.         radeon_encoder->rmx_type = rmx_type;
  964.  
  965.         radeon_property_change_mode(&radeon_encoder->base);
  966.         return 0;
  967. }
  968.  
  969.  
  970. static const struct drm_connector_helper_funcs radeon_lvds_connector_helper_funcs = {
  971.         .get_modes = radeon_lvds_get_modes,
  972.         .mode_valid = radeon_lvds_mode_valid,
  973.         .best_encoder = radeon_best_single_encoder,
  974. };
  975.  
  976. static const struct drm_connector_funcs radeon_lvds_connector_funcs = {
  977.         .dpms = drm_helper_connector_dpms,
  978.         .detect = radeon_lvds_detect,
  979.         .fill_modes = drm_helper_probe_single_connector_modes,
  980.         .destroy = radeon_connector_destroy,
  981.         .set_property = radeon_lvds_set_property,
  982. };
  983.  
  984. static int radeon_vga_get_modes(struct drm_connector *connector)
  985. {
  986.         int ret;
  987.  
  988.         radeon_connector_get_edid(connector);
  989.         ret = radeon_ddc_get_modes(connector);
  990.  
  991.         radeon_get_native_mode(connector);
  992.  
  993.         return ret;
  994. }
  995.  
  996. static int radeon_vga_mode_valid(struct drm_connector *connector,
  997.                                   struct drm_display_mode *mode)
  998. {
  999.         struct drm_device *dev = connector->dev;
  1000.         struct radeon_device *rdev = dev->dev_private;
  1001.  
  1002.         /* XXX check mode bandwidth */
  1003.  
  1004.         if ((mode->clock / 10) > rdev->clock.max_pixel_clock)
  1005.                 return MODE_CLOCK_HIGH;
  1006.  
  1007.         return MODE_OK;
  1008. }
  1009.  
  1010. static enum drm_connector_status
  1011. radeon_vga_detect(struct drm_connector *connector, bool force)
  1012. {
  1013.         struct drm_device *dev = connector->dev;
  1014.         struct radeon_device *rdev = dev->dev_private;
  1015.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  1016.         struct drm_encoder *encoder;
  1017.         const struct drm_encoder_helper_funcs *encoder_funcs;
  1018.         bool dret = false;
  1019.         enum drm_connector_status ret = connector_status_disconnected;
  1020.  
  1021.         encoder = radeon_best_single_encoder(connector);
  1022.         if (!encoder)
  1023.                 ret = connector_status_disconnected;
  1024.  
  1025.         if (radeon_connector->ddc_bus)
  1026.                 dret = radeon_ddc_probe(radeon_connector, false);
  1027.         if (dret) {
  1028.                 radeon_connector->detected_by_load = false;
  1029.                 radeon_connector_free_edid(connector);
  1030.                 radeon_connector_get_edid(connector);
  1031.  
  1032.                 if (!radeon_connector->edid) {
  1033.                         DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
  1034.                                         connector->name);
  1035.                         ret = connector_status_connected;
  1036.                 } else {
  1037.                         radeon_connector->use_digital =
  1038.                                 !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
  1039.  
  1040.                         /* some oems have boards with separate digital and analog connectors
  1041.                          * with a shared ddc line (often vga + hdmi)
  1042.                          */
  1043.                         if (radeon_connector->use_digital && radeon_connector->shared_ddc) {
  1044.                                 radeon_connector_free_edid(connector);
  1045.                                 ret = connector_status_disconnected;
  1046.                         } else {
  1047.                                 ret = connector_status_connected;
  1048.                         }
  1049.                 }
  1050.         } else {
  1051.  
  1052.                 /* if we aren't forcing don't do destructive polling */
  1053.                 if (!force) {
  1054.                         /* only return the previous status if we last
  1055.                          * detected a monitor via load.
  1056.                          */
  1057.                         if (radeon_connector->detected_by_load)
  1058.                                 ret = connector->status;
  1059.                         goto out;
  1060.                 }
  1061.  
  1062.                 if (radeon_connector->dac_load_detect && encoder) {
  1063.                         encoder_funcs = encoder->helper_private;
  1064.                         ret = encoder_funcs->detect(encoder, connector);
  1065.                         if (ret != connector_status_disconnected)
  1066.                                 radeon_connector->detected_by_load = true;
  1067.                 }
  1068.         }
  1069.  
  1070.         if (ret == connector_status_connected)
  1071.                 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
  1072.  
  1073.         /* RN50 and some RV100 asics in servers often have a hardcoded EDID in the
  1074.          * vbios to deal with KVMs. If we have one and are not able to detect a monitor
  1075.          * by other means, assume the CRT is connected and use that EDID.
  1076.          */
  1077.         if ((!rdev->is_atom_bios) &&
  1078.             (ret == connector_status_disconnected) &&
  1079.             rdev->mode_info.bios_hardcoded_edid_size) {
  1080.                 ret = connector_status_connected;
  1081.         }
  1082.  
  1083.         radeon_connector_update_scratch_regs(connector, ret);
  1084.  
  1085. out:
  1086.         return ret;
  1087. }
  1088.  
  1089. static const struct drm_connector_helper_funcs radeon_vga_connector_helper_funcs = {
  1090.         .get_modes = radeon_vga_get_modes,
  1091.         .mode_valid = radeon_vga_mode_valid,
  1092.         .best_encoder = radeon_best_single_encoder,
  1093. };
  1094.  
  1095. static const struct drm_connector_funcs radeon_vga_connector_funcs = {
  1096.         .dpms = drm_helper_connector_dpms,
  1097.         .detect = radeon_vga_detect,
  1098.         .fill_modes = drm_helper_probe_single_connector_modes,
  1099.         .destroy = radeon_connector_destroy,
  1100.         .set_property = radeon_connector_set_property,
  1101. };
  1102.  
  1103. static int radeon_tv_get_modes(struct drm_connector *connector)
  1104. {
  1105.         struct drm_device *dev = connector->dev;
  1106.         struct radeon_device *rdev = dev->dev_private;
  1107.         struct drm_display_mode *tv_mode;
  1108.         struct drm_encoder *encoder;
  1109.  
  1110.         encoder = radeon_best_single_encoder(connector);
  1111.         if (!encoder)
  1112.                 return 0;
  1113.  
  1114.         /* avivo chips can scale any mode */
  1115.         if (rdev->family >= CHIP_RS600)
  1116.                 /* add scaled modes */
  1117.                 radeon_add_common_modes(encoder, connector);
  1118.         else {
  1119.                 /* only 800x600 is supported right now on pre-avivo chips */
  1120.                 tv_mode = drm_cvt_mode(dev, 800, 600, 60, false, false, false);
  1121.                 tv_mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
  1122.                 drm_mode_probed_add(connector, tv_mode);
  1123.         }
  1124.         return 1;
  1125. }
  1126.  
  1127. static int radeon_tv_mode_valid(struct drm_connector *connector,
  1128.                                 struct drm_display_mode *mode)
  1129. {
  1130.         if ((mode->hdisplay > 1024) || (mode->vdisplay > 768))
  1131.                 return MODE_CLOCK_RANGE;
  1132.         return MODE_OK;
  1133. }
  1134.  
  1135. static enum drm_connector_status
  1136. radeon_tv_detect(struct drm_connector *connector, bool force)
  1137. {
  1138.         struct drm_encoder *encoder;
  1139.         const struct drm_encoder_helper_funcs *encoder_funcs;
  1140.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  1141.         enum drm_connector_status ret = connector_status_disconnected;
  1142.         int r;
  1143.  
  1144.         if (!radeon_connector->dac_load_detect)
  1145.                 return ret;
  1146.  
  1147.         r = pm_runtime_get_sync(connector->dev->dev);
  1148.         if (r < 0)
  1149.                 return connector_status_disconnected;
  1150.  
  1151.         encoder = radeon_best_single_encoder(connector);
  1152.         if (!encoder)
  1153.                 ret = connector_status_disconnected;
  1154.         else {
  1155.                 encoder_funcs = encoder->helper_private;
  1156.                 ret = encoder_funcs->detect(encoder, connector);
  1157.         }
  1158.         if (ret == connector_status_connected)
  1159.                 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, false);
  1160.         radeon_connector_update_scratch_regs(connector, ret);
  1161.         pm_runtime_mark_last_busy(connector->dev->dev);
  1162.         pm_runtime_put_autosuspend(connector->dev->dev);
  1163.         return ret;
  1164. }
  1165.  
  1166. static const struct drm_connector_helper_funcs radeon_tv_connector_helper_funcs = {
  1167.         .get_modes = radeon_tv_get_modes,
  1168.         .mode_valid = radeon_tv_mode_valid,
  1169.         .best_encoder = radeon_best_single_encoder,
  1170. };
  1171.  
  1172. static const struct drm_connector_funcs radeon_tv_connector_funcs = {
  1173.         .dpms = drm_helper_connector_dpms,
  1174.         .detect = radeon_tv_detect,
  1175.         .fill_modes = drm_helper_probe_single_connector_modes,
  1176.         .destroy = radeon_connector_destroy,
  1177.         .set_property = radeon_connector_set_property,
  1178. };
  1179.  
  1180. static bool radeon_check_hpd_status_unchanged(struct drm_connector *connector)
  1181. {
  1182.         struct drm_device *dev = connector->dev;
  1183.         struct radeon_device *rdev = dev->dev_private;
  1184.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  1185.         enum drm_connector_status status;
  1186.  
  1187.         /* We only trust HPD on R600 and newer ASICS. */
  1188.         if (rdev->family >= CHIP_R600
  1189.           && radeon_connector->hpd.hpd != RADEON_HPD_NONE) {
  1190.                 if (radeon_hpd_sense(rdev, radeon_connector->hpd.hpd))
  1191.                         status = connector_status_connected;
  1192.                 else
  1193.                         status = connector_status_disconnected;
  1194.                 if (connector->status == status)
  1195.                         return true;
  1196.         }
  1197.  
  1198.         return false;
  1199. }
  1200.  
  1201. /*
  1202.  * DVI is complicated
  1203.  * Do a DDC probe, if DDC probe passes, get the full EDID so
  1204.  * we can do analog/digital monitor detection at this point.
  1205.  * If the monitor is an analog monitor or we got no DDC,
  1206.  * we need to find the DAC encoder object for this connector.
  1207.  * If we got no DDC, we do load detection on the DAC encoder object.
  1208.  * If we got analog DDC or load detection passes on the DAC encoder
  1209.  * we have to check if this analog encoder is shared with anyone else (TV)
  1210.  * if its shared we have to set the other connector to disconnected.
  1211.  */
  1212. static enum drm_connector_status
  1213. radeon_dvi_detect(struct drm_connector *connector, bool force)
  1214. {
  1215.         struct drm_device *dev = connector->dev;
  1216.         struct radeon_device *rdev = dev->dev_private;
  1217.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  1218.         struct drm_encoder *encoder = NULL;
  1219.         const struct drm_encoder_helper_funcs *encoder_funcs;
  1220.         int i, r;
  1221.         enum drm_connector_status ret = connector_status_disconnected;
  1222.         bool dret = false, broken_edid = false;
  1223.  
  1224.         r = pm_runtime_get_sync(connector->dev->dev);
  1225.         if (r < 0)
  1226.                 return connector_status_disconnected;
  1227.  
  1228.         if (radeon_connector->detected_hpd_without_ddc) {
  1229.                 force = true;
  1230.                 radeon_connector->detected_hpd_without_ddc = false;
  1231.         }
  1232.  
  1233.         if (!force && radeon_check_hpd_status_unchanged(connector)) {
  1234.                 ret = connector->status;
  1235.                 goto exit;
  1236.         }
  1237.  
  1238.         if (radeon_connector->ddc_bus) {
  1239.                 dret = radeon_ddc_probe(radeon_connector, false);
  1240.         }
  1241.         if (dret) {
  1242.                 radeon_connector->detected_by_load = false;
  1243.                 radeon_connector_free_edid(connector);
  1244.                 radeon_connector_get_edid(connector);
  1245.  
  1246.                 if (!radeon_connector->edid) {
  1247.                         DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
  1248.                                         connector->name);
  1249.                         /* rs690 seems to have a problem with connectors not existing and always
  1250.                          * return a block of 0's. If we see this just stop polling on this output */
  1251.                         if ((rdev->family == CHIP_RS690 || rdev->family == CHIP_RS740) &&
  1252.                             radeon_connector->base.null_edid_counter) {
  1253.                                 ret = connector_status_disconnected;
  1254.                                 DRM_ERROR("%s: detected RS690 floating bus bug, stopping ddc detect\n",
  1255.                                           connector->name);
  1256.                                 radeon_connector->ddc_bus = NULL;
  1257.                         } else {
  1258.                                 ret = connector_status_connected;
  1259.                                 broken_edid = true; /* defer use_digital to later */
  1260.                         }
  1261.                 } else {
  1262.                         radeon_connector->use_digital =
  1263.                                 !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
  1264.  
  1265.                         /* some oems have boards with separate digital and analog connectors
  1266.                          * with a shared ddc line (often vga + hdmi)
  1267.                          */
  1268.                         if ((!radeon_connector->use_digital) && radeon_connector->shared_ddc) {
  1269.                                 radeon_connector_free_edid(connector);
  1270.                                 ret = connector_status_disconnected;
  1271.                         } else {
  1272.                                 ret = connector_status_connected;
  1273.                         }
  1274.                         /* This gets complicated.  We have boards with VGA + HDMI with a
  1275.                          * shared DDC line and we have boards with DVI-D + HDMI with a shared
  1276.                          * DDC line.  The latter is more complex because with DVI<->HDMI adapters
  1277.                          * you don't really know what's connected to which port as both are digital.
  1278.                          */
  1279.                         if (radeon_connector->shared_ddc && (ret == connector_status_connected)) {
  1280.                                 struct drm_connector *list_connector;
  1281.                                 struct radeon_connector *list_radeon_connector;
  1282.                                 list_for_each_entry(list_connector, &dev->mode_config.connector_list, head) {
  1283.                                         if (connector == list_connector)
  1284.                                                 continue;
  1285.                                         list_radeon_connector = to_radeon_connector(list_connector);
  1286.                                         if (list_radeon_connector->shared_ddc &&
  1287.                                             (list_radeon_connector->ddc_bus->rec.i2c_id ==
  1288.                                              radeon_connector->ddc_bus->rec.i2c_id)) {
  1289.                                                 /* cases where both connectors are digital */
  1290.                                                 if (list_connector->connector_type != DRM_MODE_CONNECTOR_VGA) {
  1291.                                                         /* hpd is our only option in this case */
  1292.                                                         if (!radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) {
  1293.                                                                 radeon_connector_free_edid(connector);
  1294.                                                                 ret = connector_status_disconnected;
  1295.                                                         }
  1296.                                                 }
  1297.                                         }
  1298.                                 }
  1299.                         }
  1300.                 }
  1301.         }
  1302.  
  1303.         if ((ret == connector_status_connected) && (radeon_connector->use_digital == true))
  1304.                 goto out;
  1305.  
  1306.         /* DVI-D and HDMI-A are digital only */
  1307.         if ((connector->connector_type == DRM_MODE_CONNECTOR_DVID) ||
  1308.             (connector->connector_type == DRM_MODE_CONNECTOR_HDMIA))
  1309.                 goto out;
  1310.  
  1311.         /* if we aren't forcing don't do destructive polling */
  1312.         if (!force) {
  1313.                 /* only return the previous status if we last
  1314.                  * detected a monitor via load.
  1315.                  */
  1316.                 if (radeon_connector->detected_by_load)
  1317.                         ret = connector->status;
  1318.                 goto out;
  1319.         }
  1320.  
  1321.         /* find analog encoder */
  1322.         if (radeon_connector->dac_load_detect) {
  1323.                 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
  1324.                         if (connector->encoder_ids[i] == 0)
  1325.                                 break;
  1326.  
  1327.                         encoder = drm_encoder_find(connector->dev,
  1328.                                                    connector->encoder_ids[i]);
  1329.                         if (!encoder)
  1330.                                 continue;
  1331.  
  1332.                         if (encoder->encoder_type != DRM_MODE_ENCODER_DAC &&
  1333.                             encoder->encoder_type != DRM_MODE_ENCODER_TVDAC)
  1334.                                 continue;
  1335.  
  1336.                         encoder_funcs = encoder->helper_private;
  1337.                         if (encoder_funcs->detect) {
  1338.                                 if (!broken_edid) {
  1339.                                         if (ret != connector_status_connected) {
  1340.                                                 /* deal with analog monitors without DDC */
  1341.                                                 ret = encoder_funcs->detect(encoder, connector);
  1342.                                                 if (ret == connector_status_connected) {
  1343.                                                         radeon_connector->use_digital = false;
  1344.                                                 }
  1345.                                                 if (ret != connector_status_disconnected)
  1346.                                                         radeon_connector->detected_by_load = true;
  1347.                                         }
  1348.                                 } else {
  1349.                                         enum drm_connector_status lret;
  1350.                                         /* assume digital unless load detected otherwise */
  1351.                                         radeon_connector->use_digital = true;
  1352.                                         lret = encoder_funcs->detect(encoder, connector);
  1353.                                         DRM_DEBUG_KMS("load_detect %x returned: %x\n",encoder->encoder_type,lret);
  1354.                                         if (lret == connector_status_connected)
  1355.                                                 radeon_connector->use_digital = false;
  1356.                                 }
  1357.                                 break;
  1358.                         }
  1359.                 }
  1360.         }
  1361.  
  1362.         if ((ret == connector_status_connected) && (radeon_connector->use_digital == false) &&
  1363.             encoder) {
  1364.                 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
  1365.         }
  1366.  
  1367.         /* RN50 and some RV100 asics in servers often have a hardcoded EDID in the
  1368.          * vbios to deal with KVMs. If we have one and are not able to detect a monitor
  1369.          * by other means, assume the DFP is connected and use that EDID.  In most
  1370.          * cases the DVI port is actually a virtual KVM port connected to the service
  1371.          * processor.
  1372.          */
  1373. out:
  1374.         if ((!rdev->is_atom_bios) &&
  1375.             (ret == connector_status_disconnected) &&
  1376.             rdev->mode_info.bios_hardcoded_edid_size) {
  1377.                 radeon_connector->use_digital = true;
  1378.                 ret = connector_status_connected;
  1379.         }
  1380.  
  1381.         /* updated in get modes as well since we need to know if it's analog or digital */
  1382.         radeon_connector_update_scratch_regs(connector, ret);
  1383.  
  1384.         if ((radeon_audio != 0) && radeon_connector->use_digital) {
  1385.                 const struct drm_connector_helper_funcs *connector_funcs =
  1386.                         connector->helper_private;
  1387.  
  1388.                 encoder = connector_funcs->best_encoder(connector);
  1389.                 if (encoder && (encoder->encoder_type == DRM_MODE_ENCODER_TMDS)) {
  1390.                         radeon_connector_get_edid(connector);
  1391.                         radeon_audio_detect(connector, encoder, ret);
  1392.                 }
  1393.         }
  1394.  
  1395. exit:
  1396.         pm_runtime_mark_last_busy(connector->dev->dev);
  1397.         pm_runtime_put_autosuspend(connector->dev->dev);
  1398.  
  1399.         return ret;
  1400. }
  1401.  
  1402. /* okay need to be smart in here about which encoder to pick */
  1403. static struct drm_encoder *radeon_dvi_encoder(struct drm_connector *connector)
  1404. {
  1405.         int enc_id = connector->encoder_ids[0];
  1406.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  1407.         struct drm_encoder *encoder;
  1408.         int i;
  1409.         for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
  1410.                 if (connector->encoder_ids[i] == 0)
  1411.                         break;
  1412.  
  1413.                 encoder = drm_encoder_find(connector->dev, connector->encoder_ids[i]);
  1414.                 if (!encoder)
  1415.                         continue;
  1416.  
  1417.                 if (radeon_connector->use_digital == true) {
  1418.                         if (encoder->encoder_type == DRM_MODE_ENCODER_TMDS)
  1419.                                 return encoder;
  1420.                 } else {
  1421.                         if (encoder->encoder_type == DRM_MODE_ENCODER_DAC ||
  1422.                             encoder->encoder_type == DRM_MODE_ENCODER_TVDAC)
  1423.                                 return encoder;
  1424.                 }
  1425.         }
  1426.  
  1427.         /* see if we have a default encoder  TODO */
  1428.  
  1429.         /* then check use digitial */
  1430.         /* pick the first one */
  1431.         if (enc_id)
  1432.                 return drm_encoder_find(connector->dev, enc_id);
  1433.         return NULL;
  1434. }
  1435.  
  1436. static void radeon_dvi_force(struct drm_connector *connector)
  1437. {
  1438.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  1439.         if (connector->force == DRM_FORCE_ON)
  1440.                 radeon_connector->use_digital = false;
  1441.         if (connector->force == DRM_FORCE_ON_DIGITAL)
  1442.                 radeon_connector->use_digital = true;
  1443. }
  1444.  
  1445. static int radeon_dvi_mode_valid(struct drm_connector *connector,
  1446.                                   struct drm_display_mode *mode)
  1447. {
  1448.         struct drm_device *dev = connector->dev;
  1449.         struct radeon_device *rdev = dev->dev_private;
  1450.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  1451.  
  1452.         /* XXX check mode bandwidth */
  1453.  
  1454.         /* clocks over 135 MHz have heat issues with DVI on RV100 */
  1455.         if (radeon_connector->use_digital &&
  1456.             (rdev->family == CHIP_RV100) &&
  1457.             (mode->clock > 135000))
  1458.                 return MODE_CLOCK_HIGH;
  1459.  
  1460.         if (radeon_connector->use_digital && (mode->clock > 165000)) {
  1461.                 if ((radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_I) ||
  1462.                     (radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_D) ||
  1463.                     (radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_HDMI_TYPE_B))
  1464.                         return MODE_OK;
  1465.                 else if (ASIC_IS_DCE6(rdev) && drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
  1466.                         /* HDMI 1.3+ supports max clock of 340 Mhz */
  1467.                         if (mode->clock > 340000)
  1468.                                 return MODE_CLOCK_HIGH;
  1469.                         else
  1470.                                 return MODE_OK;
  1471.                 } else {
  1472.                         return MODE_CLOCK_HIGH;
  1473.                 }
  1474.         }
  1475.  
  1476.         /* check against the max pixel clock */
  1477.         if ((mode->clock / 10) > rdev->clock.max_pixel_clock)
  1478.                 return MODE_CLOCK_HIGH;
  1479.  
  1480.         return MODE_OK;
  1481. }
  1482.  
  1483. static const struct drm_connector_helper_funcs radeon_dvi_connector_helper_funcs = {
  1484.         .get_modes = radeon_vga_get_modes,
  1485.         .mode_valid = radeon_dvi_mode_valid,
  1486.         .best_encoder = radeon_dvi_encoder,
  1487. };
  1488.  
  1489. static const struct drm_connector_funcs radeon_dvi_connector_funcs = {
  1490.         .dpms = drm_helper_connector_dpms,
  1491.         .detect = radeon_dvi_detect,
  1492.         .fill_modes = drm_helper_probe_single_connector_modes,
  1493.         .set_property = radeon_connector_set_property,
  1494.         .destroy = radeon_connector_destroy,
  1495.         .force = radeon_dvi_force,
  1496. };
  1497.  
  1498. static int radeon_dp_get_modes(struct drm_connector *connector)
  1499. {
  1500.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  1501.         struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
  1502.         struct drm_encoder *encoder = radeon_best_single_encoder(connector);
  1503.         int ret;
  1504.  
  1505.         if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) ||
  1506.             (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
  1507.                 struct drm_display_mode *mode;
  1508.  
  1509.                 if (connector->connector_type == DRM_MODE_CONNECTOR_eDP) {
  1510.                         if (!radeon_dig_connector->edp_on)
  1511.                                 atombios_set_edp_panel_power(connector,
  1512.                                                              ATOM_TRANSMITTER_ACTION_POWER_ON);
  1513.                         radeon_connector_get_edid(connector);
  1514.                         ret = radeon_ddc_get_modes(connector);
  1515.                         if (!radeon_dig_connector->edp_on)
  1516.                                 atombios_set_edp_panel_power(connector,
  1517.                                                              ATOM_TRANSMITTER_ACTION_POWER_OFF);
  1518.                 } else {
  1519.                         /* need to setup ddc on the bridge */
  1520.                         if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
  1521.                             ENCODER_OBJECT_ID_NONE) {
  1522.                                 if (encoder)
  1523.                                         radeon_atom_ext_encoder_setup_ddc(encoder);
  1524.                         }
  1525.                         radeon_connector_get_edid(connector);
  1526.                         ret = radeon_ddc_get_modes(connector);
  1527.                 }
  1528.  
  1529.                 if (ret > 0) {
  1530.                         if (encoder) {
  1531.                                 radeon_fixup_lvds_native_mode(encoder, connector);
  1532.                                 /* add scaled modes */
  1533.                                 radeon_add_common_modes(encoder, connector);
  1534.                         }
  1535.                         return ret;
  1536.                 }
  1537.  
  1538.                 if (!encoder)
  1539.                         return 0;
  1540.  
  1541.                 /* we have no EDID modes */
  1542.                 mode = radeon_fp_native_mode(encoder);
  1543.                 if (mode) {
  1544.                         ret = 1;
  1545.                         drm_mode_probed_add(connector, mode);
  1546.                         /* add the width/height from vbios tables if available */
  1547.                         connector->display_info.width_mm = mode->width_mm;
  1548.                         connector->display_info.height_mm = mode->height_mm;
  1549.                         /* add scaled modes */
  1550.                         radeon_add_common_modes(encoder, connector);
  1551.                 }
  1552.         } else {
  1553.                 /* need to setup ddc on the bridge */
  1554.                 if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
  1555.                         ENCODER_OBJECT_ID_NONE) {
  1556.                         if (encoder)
  1557.                                 radeon_atom_ext_encoder_setup_ddc(encoder);
  1558.                 }
  1559.                 radeon_connector_get_edid(connector);
  1560.                 ret = radeon_ddc_get_modes(connector);
  1561.  
  1562.                 radeon_get_native_mode(connector);
  1563.         }
  1564.  
  1565.         return ret;
  1566. }
  1567.  
  1568. u16 radeon_connector_encoder_get_dp_bridge_encoder_id(struct drm_connector *connector)
  1569. {
  1570.         struct drm_encoder *encoder;
  1571.         struct radeon_encoder *radeon_encoder;
  1572.         int i;
  1573.  
  1574.         for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
  1575.                 if (connector->encoder_ids[i] == 0)
  1576.                         break;
  1577.  
  1578.                 encoder = drm_encoder_find(connector->dev, connector->encoder_ids[i]);
  1579.                 if (!encoder)
  1580.                         continue;
  1581.  
  1582.                 radeon_encoder = to_radeon_encoder(encoder);
  1583.  
  1584.                 switch (radeon_encoder->encoder_id) {
  1585.                 case ENCODER_OBJECT_ID_TRAVIS:
  1586.                 case ENCODER_OBJECT_ID_NUTMEG:
  1587.                         return radeon_encoder->encoder_id;
  1588.                 default:
  1589.                         break;
  1590.                 }
  1591.         }
  1592.  
  1593.         return ENCODER_OBJECT_ID_NONE;
  1594. }
  1595.  
  1596. static bool radeon_connector_encoder_is_hbr2(struct drm_connector *connector)
  1597. {
  1598.         struct drm_encoder *encoder;
  1599.         struct radeon_encoder *radeon_encoder;
  1600.         int i;
  1601.         bool found = false;
  1602.  
  1603.         for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
  1604.                 if (connector->encoder_ids[i] == 0)
  1605.                         break;
  1606.  
  1607.                 encoder = drm_encoder_find(connector->dev, connector->encoder_ids[i]);
  1608.                 if (!encoder)
  1609.                         continue;
  1610.  
  1611.                 radeon_encoder = to_radeon_encoder(encoder);
  1612.                 if (radeon_encoder->caps & ATOM_ENCODER_CAP_RECORD_HBR2)
  1613.                         found = true;
  1614.         }
  1615.  
  1616.         return found;
  1617. }
  1618.  
  1619. bool radeon_connector_is_dp12_capable(struct drm_connector *connector)
  1620. {
  1621.         struct drm_device *dev = connector->dev;
  1622.         struct radeon_device *rdev = dev->dev_private;
  1623.  
  1624.         if (ASIC_IS_DCE5(rdev) &&
  1625.             (rdev->clock.default_dispclk >= 53900) &&
  1626.             radeon_connector_encoder_is_hbr2(connector)) {
  1627.                 return true;
  1628.         }
  1629.  
  1630.         return false;
  1631. }
  1632.  
  1633. static enum drm_connector_status
  1634. radeon_dp_detect(struct drm_connector *connector, bool force)
  1635. {
  1636.         struct drm_device *dev = connector->dev;
  1637.         struct radeon_device *rdev = dev->dev_private;
  1638.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  1639.         enum drm_connector_status ret = connector_status_disconnected;
  1640.         struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
  1641.         struct drm_encoder *encoder = radeon_best_single_encoder(connector);
  1642.         int r;
  1643.  
  1644.         if (radeon_dig_connector->is_mst)
  1645.                 return connector_status_disconnected;
  1646.  
  1647.         r = pm_runtime_get_sync(connector->dev->dev);
  1648.         if (r < 0)
  1649.                 return connector_status_disconnected;
  1650.  
  1651.         if (!force && radeon_check_hpd_status_unchanged(connector)) {
  1652.                 ret = connector->status;
  1653.                 goto out;
  1654.         }
  1655.  
  1656.         radeon_connector_free_edid(connector);
  1657.  
  1658.         if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) ||
  1659.             (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
  1660.                 if (encoder) {
  1661.                         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
  1662.                         struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
  1663.  
  1664.                         /* check if panel is valid */
  1665.                         if (native_mode->hdisplay >= 320 && native_mode->vdisplay >= 240)
  1666.                                 ret = connector_status_connected;
  1667.                         /* don't fetch the edid from the vbios if ddc fails and runpm is
  1668.                          * enabled so we report disconnected.
  1669.                          */
  1670.                         if ((rdev->flags & RADEON_IS_PX) && (radeon_runtime_pm != 0))
  1671.                                 ret = connector_status_disconnected;
  1672.                 }
  1673.                 /* eDP is always DP */
  1674.                 radeon_dig_connector->dp_sink_type = CONNECTOR_OBJECT_ID_DISPLAYPORT;
  1675.                 if (!radeon_dig_connector->edp_on)
  1676.                         atombios_set_edp_panel_power(connector,
  1677.                                                      ATOM_TRANSMITTER_ACTION_POWER_ON);
  1678.                 if (radeon_dp_getdpcd(radeon_connector))
  1679.                         ret = connector_status_connected;
  1680.                 if (!radeon_dig_connector->edp_on)
  1681.                         atombios_set_edp_panel_power(connector,
  1682.                                                      ATOM_TRANSMITTER_ACTION_POWER_OFF);
  1683.         } else if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
  1684.                    ENCODER_OBJECT_ID_NONE) {
  1685.                 /* DP bridges are always DP */
  1686.                 radeon_dig_connector->dp_sink_type = CONNECTOR_OBJECT_ID_DISPLAYPORT;
  1687.                 /* get the DPCD from the bridge */
  1688.                 radeon_dp_getdpcd(radeon_connector);
  1689.  
  1690.                 if (encoder) {
  1691.                         /* setup ddc on the bridge */
  1692.                         radeon_atom_ext_encoder_setup_ddc(encoder);
  1693.                         /* bridge chips are always aux */
  1694.                         if (radeon_ddc_probe(radeon_connector, true)) /* try DDC */
  1695.                                 ret = connector_status_connected;
  1696.                         else if (radeon_connector->dac_load_detect) { /* try load detection */
  1697.                                 const struct drm_encoder_helper_funcs *encoder_funcs = encoder->helper_private;
  1698.                                 ret = encoder_funcs->detect(encoder, connector);
  1699.                         }
  1700.                 }
  1701.         } else {
  1702.                 radeon_dig_connector->dp_sink_type = radeon_dp_getsinktype(radeon_connector);
  1703.                 if (radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) {
  1704.                         ret = connector_status_connected;
  1705.                         if (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) {
  1706.                                 radeon_dp_getdpcd(radeon_connector);
  1707.                                 r = radeon_dp_mst_probe(radeon_connector);
  1708.                                 if (r == 1)
  1709.                                         ret = connector_status_disconnected;
  1710.                         }
  1711.                 } else {
  1712.                         if (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) {
  1713.                                 if (radeon_dp_getdpcd(radeon_connector)) {
  1714.                                         r = radeon_dp_mst_probe(radeon_connector);
  1715.                                         if (r == 1)
  1716.                                                 ret = connector_status_disconnected;
  1717.                                         else
  1718.                                                 ret = connector_status_connected;
  1719.                                 }
  1720.                         } else {
  1721.                                 /* try non-aux ddc (DP to DVI/HDMI/etc. adapter) */
  1722.                                 if (radeon_ddc_probe(radeon_connector, false))
  1723.                                         ret = connector_status_connected;
  1724.                         }
  1725.                 }
  1726.         }
  1727.  
  1728.         radeon_connector_update_scratch_regs(connector, ret);
  1729.  
  1730.         if ((radeon_audio != 0) && encoder) {
  1731.                 radeon_connector_get_edid(connector);
  1732.                 radeon_audio_detect(connector, encoder, ret);
  1733.         }
  1734.  
  1735. out:
  1736.         pm_runtime_mark_last_busy(connector->dev->dev);
  1737.         pm_runtime_put_autosuspend(connector->dev->dev);
  1738.  
  1739.         return ret;
  1740. }
  1741.  
  1742. static int radeon_dp_mode_valid(struct drm_connector *connector,
  1743.                                   struct drm_display_mode *mode)
  1744. {
  1745.         struct drm_device *dev = connector->dev;
  1746.         struct radeon_device *rdev = dev->dev_private;
  1747.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  1748.         struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
  1749.  
  1750.         /* XXX check mode bandwidth */
  1751.  
  1752.         if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) ||
  1753.             (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
  1754.                 struct drm_encoder *encoder = radeon_best_single_encoder(connector);
  1755.  
  1756.                 if ((mode->hdisplay < 320) || (mode->vdisplay < 240))
  1757.                         return MODE_PANEL;
  1758.  
  1759.                 if (encoder) {
  1760.                         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
  1761.                         struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
  1762.  
  1763.                         /* AVIVO hardware supports downscaling modes larger than the panel
  1764.                          * to the panel size, but I'm not sure this is desirable.
  1765.                          */
  1766.                         if ((mode->hdisplay > native_mode->hdisplay) ||
  1767.                             (mode->vdisplay > native_mode->vdisplay))
  1768.                                 return MODE_PANEL;
  1769.  
  1770.                         /* if scaling is disabled, block non-native modes */
  1771.                         if (radeon_encoder->rmx_type == RMX_OFF) {
  1772.                                 if ((mode->hdisplay != native_mode->hdisplay) ||
  1773.                                     (mode->vdisplay != native_mode->vdisplay))
  1774.                                         return MODE_PANEL;
  1775.                         }
  1776.                 }
  1777.         } else {
  1778.                 if ((radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) ||
  1779.                     (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_eDP)) {
  1780.                         return radeon_dp_mode_valid_helper(connector, mode);
  1781.                 } else {
  1782.                         if (ASIC_IS_DCE6(rdev) && drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
  1783.                                 /* HDMI 1.3+ supports max clock of 340 Mhz */
  1784.                                 if (mode->clock > 340000)
  1785.                                         return MODE_CLOCK_HIGH;
  1786.                         } else {
  1787.                                 if (mode->clock > 165000)
  1788.                                         return MODE_CLOCK_HIGH;
  1789.                         }
  1790.                 }
  1791.         }
  1792.  
  1793.         return MODE_OK;
  1794. }
  1795.  
  1796. static const struct drm_connector_helper_funcs radeon_dp_connector_helper_funcs = {
  1797.         .get_modes = radeon_dp_get_modes,
  1798.         .mode_valid = radeon_dp_mode_valid,
  1799.         .best_encoder = radeon_dvi_encoder,
  1800. };
  1801.  
  1802. static const struct drm_connector_funcs radeon_dp_connector_funcs = {
  1803.         .dpms = drm_helper_connector_dpms,
  1804.         .detect = radeon_dp_detect,
  1805.         .fill_modes = drm_helper_probe_single_connector_modes,
  1806.         .set_property = radeon_connector_set_property,
  1807.         .destroy = radeon_connector_destroy,
  1808.         .force = radeon_dvi_force,
  1809. };
  1810.  
  1811. static const struct drm_connector_funcs radeon_edp_connector_funcs = {
  1812.         .dpms = drm_helper_connector_dpms,
  1813.         .detect = radeon_dp_detect,
  1814.         .fill_modes = drm_helper_probe_single_connector_modes,
  1815.         .set_property = radeon_lvds_set_property,
  1816.         .destroy = radeon_connector_destroy,
  1817.         .force = radeon_dvi_force,
  1818. };
  1819.  
  1820. static const struct drm_connector_funcs radeon_lvds_bridge_connector_funcs = {
  1821.         .dpms = drm_helper_connector_dpms,
  1822.         .detect = radeon_dp_detect,
  1823.         .fill_modes = drm_helper_probe_single_connector_modes,
  1824.         .set_property = radeon_lvds_set_property,
  1825.         .destroy = radeon_connector_destroy,
  1826.         .force = radeon_dvi_force,
  1827. };
  1828.  
  1829. void
  1830. radeon_add_atom_connector(struct drm_device *dev,
  1831.                           uint32_t connector_id,
  1832.                           uint32_t supported_device,
  1833.                           int connector_type,
  1834.                           struct radeon_i2c_bus_rec *i2c_bus,
  1835.                           uint32_t igp_lane_info,
  1836.                           uint16_t connector_object_id,
  1837.                           struct radeon_hpd *hpd,
  1838.                           struct radeon_router *router)
  1839. {
  1840.         struct radeon_device *rdev = dev->dev_private;
  1841.         struct drm_connector *connector;
  1842.         struct radeon_connector *radeon_connector;
  1843.         struct radeon_connector_atom_dig *radeon_dig_connector;
  1844.         struct drm_encoder *encoder;
  1845.         struct radeon_encoder *radeon_encoder;
  1846.         uint32_t subpixel_order = SubPixelNone;
  1847.         bool shared_ddc = false;
  1848.         bool is_dp_bridge = false;
  1849.         bool has_aux = false;
  1850.  
  1851.         if (connector_type == DRM_MODE_CONNECTOR_Unknown)
  1852.                 return;
  1853.  
  1854.         /* if the user selected tv=0 don't try and add the connector */
  1855.         if (((connector_type == DRM_MODE_CONNECTOR_SVIDEO) ||
  1856.              (connector_type == DRM_MODE_CONNECTOR_Composite) ||
  1857.              (connector_type == DRM_MODE_CONNECTOR_9PinDIN)) &&
  1858.             (radeon_tv == 0))
  1859.                 return;
  1860.  
  1861.         /* see if we already added it */
  1862.         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
  1863.                 radeon_connector = to_radeon_connector(connector);
  1864.                 if (radeon_connector->connector_id == connector_id) {
  1865.                         radeon_connector->devices |= supported_device;
  1866.                         return;
  1867.                 }
  1868.                 if (radeon_connector->ddc_bus && i2c_bus->valid) {
  1869.                         if (radeon_connector->ddc_bus->rec.i2c_id == i2c_bus->i2c_id) {
  1870.                                 radeon_connector->shared_ddc = true;
  1871.                                 shared_ddc = true;
  1872.                         }
  1873.                         if (radeon_connector->router_bus && router->ddc_valid &&
  1874.                             (radeon_connector->router.router_id == router->router_id)) {
  1875.                                 radeon_connector->shared_ddc = false;
  1876.                                 shared_ddc = false;
  1877.                         }
  1878.                 }
  1879.         }
  1880.  
  1881.         /* check if it's a dp bridge */
  1882.         list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
  1883.                 radeon_encoder = to_radeon_encoder(encoder);
  1884.                 if (radeon_encoder->devices & supported_device) {
  1885.                         switch (radeon_encoder->encoder_id) {
  1886.                         case ENCODER_OBJECT_ID_TRAVIS:
  1887.                         case ENCODER_OBJECT_ID_NUTMEG:
  1888.                                 is_dp_bridge = true;
  1889.                                 break;
  1890.                         default:
  1891.                                 break;
  1892.                         }
  1893.                 }
  1894.         }
  1895.  
  1896.         radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
  1897.         if (!radeon_connector)
  1898.                 return;
  1899.  
  1900.         connector = &radeon_connector->base;
  1901.  
  1902.         radeon_connector->connector_id = connector_id;
  1903.         radeon_connector->devices = supported_device;
  1904.         radeon_connector->shared_ddc = shared_ddc;
  1905.         radeon_connector->connector_object_id = connector_object_id;
  1906.         radeon_connector->hpd = *hpd;
  1907.  
  1908.         radeon_connector->router = *router;
  1909.         if (router->ddc_valid || router->cd_valid) {
  1910.                 radeon_connector->router_bus = radeon_i2c_lookup(rdev, &router->i2c_info);
  1911.                 if (!radeon_connector->router_bus)
  1912.                         DRM_ERROR("Failed to assign router i2c bus! Check dmesg for i2c errors.\n");
  1913.         }
  1914.  
  1915.         if (is_dp_bridge) {
  1916.                 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
  1917.                 if (!radeon_dig_connector)
  1918.                         goto failed;
  1919.                 radeon_dig_connector->igp_lane_info = igp_lane_info;
  1920.                 radeon_connector->con_priv = radeon_dig_connector;
  1921.                 if (i2c_bus->valid) {
  1922.                         radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
  1923.                         if (radeon_connector->ddc_bus)
  1924.                                 has_aux = true;
  1925.                         else
  1926.                                 DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
  1927.                 }
  1928.                 switch (connector_type) {
  1929.                 case DRM_MODE_CONNECTOR_VGA:
  1930.                 case DRM_MODE_CONNECTOR_DVIA:
  1931.                 default:
  1932.                         drm_connector_init(dev, &radeon_connector->base,
  1933.                                            &radeon_dp_connector_funcs, connector_type);
  1934.                         drm_connector_helper_add(&radeon_connector->base,
  1935.                                                  &radeon_dp_connector_helper_funcs);
  1936.                         connector->interlace_allowed = true;
  1937.                         connector->doublescan_allowed = true;
  1938.                         radeon_connector->dac_load_detect = true;
  1939.                         drm_object_attach_property(&radeon_connector->base.base,
  1940.                                                       rdev->mode_info.load_detect_property,
  1941.                                                       1);
  1942.                         drm_object_attach_property(&radeon_connector->base.base,
  1943.                                                    dev->mode_config.scaling_mode_property,
  1944.                                                    DRM_MODE_SCALE_NONE);
  1945.                         if (ASIC_IS_DCE5(rdev))
  1946.                                 drm_object_attach_property(&radeon_connector->base.base,
  1947.                                                            rdev->mode_info.output_csc_property,
  1948.                                                            RADEON_OUTPUT_CSC_BYPASS);
  1949.                         break;
  1950.                 case DRM_MODE_CONNECTOR_DVII:
  1951.                 case DRM_MODE_CONNECTOR_DVID:
  1952.                 case DRM_MODE_CONNECTOR_HDMIA:
  1953.                 case DRM_MODE_CONNECTOR_HDMIB:
  1954.                 case DRM_MODE_CONNECTOR_DisplayPort:
  1955.                         drm_connector_init(dev, &radeon_connector->base,
  1956.                                            &radeon_dp_connector_funcs, connector_type);
  1957.                         drm_connector_helper_add(&radeon_connector->base,
  1958.                                                  &radeon_dp_connector_helper_funcs);
  1959.                         drm_object_attach_property(&radeon_connector->base.base,
  1960.                                                       rdev->mode_info.underscan_property,
  1961.                                                       UNDERSCAN_OFF);
  1962.                         drm_object_attach_property(&radeon_connector->base.base,
  1963.                                                       rdev->mode_info.underscan_hborder_property,
  1964.                                                       0);
  1965.                         drm_object_attach_property(&radeon_connector->base.base,
  1966.                                                       rdev->mode_info.underscan_vborder_property,
  1967.                                                       0);
  1968.  
  1969.                         drm_object_attach_property(&radeon_connector->base.base,
  1970.                                                       dev->mode_config.scaling_mode_property,
  1971.                                                       DRM_MODE_SCALE_NONE);
  1972.  
  1973.                         drm_object_attach_property(&radeon_connector->base.base,
  1974.                                                    rdev->mode_info.dither_property,
  1975.                                                    RADEON_FMT_DITHER_DISABLE);
  1976.  
  1977.                         if (radeon_audio != 0) {
  1978.                                 drm_object_attach_property(&radeon_connector->base.base,
  1979.                                                            rdev->mode_info.audio_property,
  1980.                                                            RADEON_AUDIO_AUTO);
  1981.                                 radeon_connector->audio = RADEON_AUDIO_AUTO;
  1982.                         }
  1983.                         if (ASIC_IS_DCE5(rdev))
  1984.                                 drm_object_attach_property(&radeon_connector->base.base,
  1985.                                                            rdev->mode_info.output_csc_property,
  1986.                                                            RADEON_OUTPUT_CSC_BYPASS);
  1987.  
  1988.                         subpixel_order = SubPixelHorizontalRGB;
  1989.                         connector->interlace_allowed = true;
  1990.                         if (connector_type == DRM_MODE_CONNECTOR_HDMIB)
  1991.                                 connector->doublescan_allowed = true;
  1992.                         else
  1993.                                 connector->doublescan_allowed = false;
  1994.                         if (connector_type == DRM_MODE_CONNECTOR_DVII) {
  1995.                                 radeon_connector->dac_load_detect = true;
  1996.                                 drm_object_attach_property(&radeon_connector->base.base,
  1997.                                                               rdev->mode_info.load_detect_property,
  1998.                                                               1);
  1999.                         }
  2000.                         break;
  2001.                 case DRM_MODE_CONNECTOR_LVDS:
  2002.                 case DRM_MODE_CONNECTOR_eDP:
  2003.                         drm_connector_init(dev, &radeon_connector->base,
  2004.                                            &radeon_lvds_bridge_connector_funcs, connector_type);
  2005.                         drm_connector_helper_add(&radeon_connector->base,
  2006.                                                  &radeon_dp_connector_helper_funcs);
  2007.                         drm_object_attach_property(&radeon_connector->base.base,
  2008.                                                       dev->mode_config.scaling_mode_property,
  2009.                                                       DRM_MODE_SCALE_FULLSCREEN);
  2010.                         subpixel_order = SubPixelHorizontalRGB;
  2011.                         connector->interlace_allowed = false;
  2012.                         connector->doublescan_allowed = false;
  2013.                         break;
  2014.                 }
  2015.         } else {
  2016.                 switch (connector_type) {
  2017.                 case DRM_MODE_CONNECTOR_VGA:
  2018.                         drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
  2019.                         drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
  2020.                         if (i2c_bus->valid) {
  2021.                                 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
  2022.                                 if (!radeon_connector->ddc_bus)
  2023.                                         DRM_ERROR("VGA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
  2024.                         }
  2025.                         radeon_connector->dac_load_detect = true;
  2026.                         drm_object_attach_property(&radeon_connector->base.base,
  2027.                                                       rdev->mode_info.load_detect_property,
  2028.                                                       1);
  2029.                         if (ASIC_IS_AVIVO(rdev))
  2030.                                 drm_object_attach_property(&radeon_connector->base.base,
  2031.                                                            dev->mode_config.scaling_mode_property,
  2032.                                                            DRM_MODE_SCALE_NONE);
  2033.                         if (ASIC_IS_DCE5(rdev))
  2034.                                 drm_object_attach_property(&radeon_connector->base.base,
  2035.                                                            rdev->mode_info.output_csc_property,
  2036.                                                            RADEON_OUTPUT_CSC_BYPASS);
  2037.                         /* no HPD on analog connectors */
  2038.                         radeon_connector->hpd.hpd = RADEON_HPD_NONE;
  2039.                         connector->polled = DRM_CONNECTOR_POLL_CONNECT;
  2040.                         connector->interlace_allowed = true;
  2041.                         connector->doublescan_allowed = true;
  2042.                         break;
  2043.                 case DRM_MODE_CONNECTOR_DVIA:
  2044.                         drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
  2045.                         drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
  2046.                         if (i2c_bus->valid) {
  2047.                                 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
  2048.                                 if (!radeon_connector->ddc_bus)
  2049.                                         DRM_ERROR("DVIA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
  2050.                         }
  2051.                         radeon_connector->dac_load_detect = true;
  2052.                         drm_object_attach_property(&radeon_connector->base.base,
  2053.                                                       rdev->mode_info.load_detect_property,
  2054.                                                       1);
  2055.                         if (ASIC_IS_AVIVO(rdev))
  2056.                                 drm_object_attach_property(&radeon_connector->base.base,
  2057.                                                            dev->mode_config.scaling_mode_property,
  2058.                                                            DRM_MODE_SCALE_NONE);
  2059.                         if (ASIC_IS_DCE5(rdev))
  2060.                                 drm_object_attach_property(&radeon_connector->base.base,
  2061.                                                            rdev->mode_info.output_csc_property,
  2062.                                                            RADEON_OUTPUT_CSC_BYPASS);
  2063.                         /* no HPD on analog connectors */
  2064.                         radeon_connector->hpd.hpd = RADEON_HPD_NONE;
  2065.                         connector->interlace_allowed = true;
  2066.                         connector->doublescan_allowed = true;
  2067.                         break;
  2068.                 case DRM_MODE_CONNECTOR_DVII:
  2069.                 case DRM_MODE_CONNECTOR_DVID:
  2070.                         radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
  2071.                         if (!radeon_dig_connector)
  2072.                                 goto failed;
  2073.                         radeon_dig_connector->igp_lane_info = igp_lane_info;
  2074.                         radeon_connector->con_priv = radeon_dig_connector;
  2075.                         drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
  2076.                         drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
  2077.                         if (i2c_bus->valid) {
  2078.                                 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
  2079.                                 if (!radeon_connector->ddc_bus)
  2080.                                         DRM_ERROR("DVI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
  2081.                         }
  2082.                         subpixel_order = SubPixelHorizontalRGB;
  2083.                         drm_object_attach_property(&radeon_connector->base.base,
  2084.                                                       rdev->mode_info.coherent_mode_property,
  2085.                                                       1);
  2086.                         if (ASIC_IS_AVIVO(rdev)) {
  2087.                                 drm_object_attach_property(&radeon_connector->base.base,
  2088.                                                               rdev->mode_info.underscan_property,
  2089.                                                               UNDERSCAN_OFF);
  2090.                                 drm_object_attach_property(&radeon_connector->base.base,
  2091.                                                               rdev->mode_info.underscan_hborder_property,
  2092.                                                               0);
  2093.                                 drm_object_attach_property(&radeon_connector->base.base,
  2094.                                                               rdev->mode_info.underscan_vborder_property,
  2095.                                                               0);
  2096.                                 drm_object_attach_property(&radeon_connector->base.base,
  2097.                                                            rdev->mode_info.dither_property,
  2098.                                                            RADEON_FMT_DITHER_DISABLE);
  2099.                                 drm_object_attach_property(&radeon_connector->base.base,
  2100.                                                            dev->mode_config.scaling_mode_property,
  2101.                                                            DRM_MODE_SCALE_NONE);
  2102.                         }
  2103.                         if (ASIC_IS_DCE2(rdev) && (radeon_audio != 0)) {
  2104.                                 drm_object_attach_property(&radeon_connector->base.base,
  2105.                                                            rdev->mode_info.audio_property,
  2106.                                                            RADEON_AUDIO_AUTO);
  2107.                                 radeon_connector->audio = RADEON_AUDIO_AUTO;
  2108.                         }
  2109.                         if (connector_type == DRM_MODE_CONNECTOR_DVII) {
  2110.                                 radeon_connector->dac_load_detect = true;
  2111.                                 drm_object_attach_property(&radeon_connector->base.base,
  2112.                                                               rdev->mode_info.load_detect_property,
  2113.                                                               1);
  2114.                         }
  2115.                         if (ASIC_IS_DCE5(rdev))
  2116.                                 drm_object_attach_property(&radeon_connector->base.base,
  2117.                                                            rdev->mode_info.output_csc_property,
  2118.                                                            RADEON_OUTPUT_CSC_BYPASS);
  2119.                         connector->interlace_allowed = true;
  2120.                         if (connector_type == DRM_MODE_CONNECTOR_DVII)
  2121.                                 connector->doublescan_allowed = true;
  2122.                         else
  2123.                                 connector->doublescan_allowed = false;
  2124.                         break;
  2125.                 case DRM_MODE_CONNECTOR_HDMIA:
  2126.                 case DRM_MODE_CONNECTOR_HDMIB:
  2127.                         radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
  2128.                         if (!radeon_dig_connector)
  2129.                                 goto failed;
  2130.                         radeon_dig_connector->igp_lane_info = igp_lane_info;
  2131.                         radeon_connector->con_priv = radeon_dig_connector;
  2132.                         drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
  2133.                         drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
  2134.                         if (i2c_bus->valid) {
  2135.                                 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
  2136.                                 if (!radeon_connector->ddc_bus)
  2137.                                         DRM_ERROR("HDMI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
  2138.                         }
  2139.                         drm_object_attach_property(&radeon_connector->base.base,
  2140.                                                       rdev->mode_info.coherent_mode_property,
  2141.                                                       1);
  2142.                         if (ASIC_IS_AVIVO(rdev)) {
  2143.                                 drm_object_attach_property(&radeon_connector->base.base,
  2144.                                                               rdev->mode_info.underscan_property,
  2145.                                                               UNDERSCAN_OFF);
  2146.                                 drm_object_attach_property(&radeon_connector->base.base,
  2147.                                                               rdev->mode_info.underscan_hborder_property,
  2148.                                                               0);
  2149.                                 drm_object_attach_property(&radeon_connector->base.base,
  2150.                                                               rdev->mode_info.underscan_vborder_property,
  2151.                                                               0);
  2152.                                 drm_object_attach_property(&radeon_connector->base.base,
  2153.                                                            rdev->mode_info.dither_property,
  2154.                                                            RADEON_FMT_DITHER_DISABLE);
  2155.                                 drm_object_attach_property(&radeon_connector->base.base,
  2156.                                                            dev->mode_config.scaling_mode_property,
  2157.                                                            DRM_MODE_SCALE_NONE);
  2158.                         }
  2159.                         if (ASIC_IS_DCE2(rdev) && (radeon_audio != 0)) {
  2160.                                 drm_object_attach_property(&radeon_connector->base.base,
  2161.                                                            rdev->mode_info.audio_property,
  2162.                                                            RADEON_AUDIO_AUTO);
  2163.                                 radeon_connector->audio = RADEON_AUDIO_AUTO;
  2164.                         }
  2165.                         if (ASIC_IS_DCE5(rdev))
  2166.                                 drm_object_attach_property(&radeon_connector->base.base,
  2167.                                                            rdev->mode_info.output_csc_property,
  2168.                                                            RADEON_OUTPUT_CSC_BYPASS);
  2169.                         subpixel_order = SubPixelHorizontalRGB;
  2170.                         connector->interlace_allowed = true;
  2171.                         if (connector_type == DRM_MODE_CONNECTOR_HDMIB)
  2172.                                 connector->doublescan_allowed = true;
  2173.                         else
  2174.                                 connector->doublescan_allowed = false;
  2175.                         break;
  2176.                 case DRM_MODE_CONNECTOR_DisplayPort:
  2177.                         radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
  2178.                         if (!radeon_dig_connector)
  2179.                                 goto failed;
  2180.                         radeon_dig_connector->igp_lane_info = igp_lane_info;
  2181.                         radeon_connector->con_priv = radeon_dig_connector;
  2182.                         drm_connector_init(dev, &radeon_connector->base, &radeon_dp_connector_funcs, connector_type);
  2183.                         drm_connector_helper_add(&radeon_connector->base, &radeon_dp_connector_helper_funcs);
  2184.                         if (i2c_bus->valid) {
  2185.                                 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
  2186.                                 if (radeon_connector->ddc_bus)
  2187.                                         has_aux = true;
  2188.                                 else
  2189.                                         DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
  2190.                         }
  2191.                         subpixel_order = SubPixelHorizontalRGB;
  2192.                         drm_object_attach_property(&radeon_connector->base.base,
  2193.                                                       rdev->mode_info.coherent_mode_property,
  2194.                                                       1);
  2195.                         if (ASIC_IS_AVIVO(rdev)) {
  2196.                                 drm_object_attach_property(&radeon_connector->base.base,
  2197.                                                               rdev->mode_info.underscan_property,
  2198.                                                               UNDERSCAN_OFF);
  2199.                                 drm_object_attach_property(&radeon_connector->base.base,
  2200.                                                               rdev->mode_info.underscan_hborder_property,
  2201.                                                               0);
  2202.                                 drm_object_attach_property(&radeon_connector->base.base,
  2203.                                                               rdev->mode_info.underscan_vborder_property,
  2204.                                                               0);
  2205.                                 drm_object_attach_property(&radeon_connector->base.base,
  2206.                                                            rdev->mode_info.dither_property,
  2207.                                                            RADEON_FMT_DITHER_DISABLE);
  2208.                                 drm_object_attach_property(&radeon_connector->base.base,
  2209.                                                            dev->mode_config.scaling_mode_property,
  2210.                                                            DRM_MODE_SCALE_NONE);
  2211.                         }
  2212.                         if (ASIC_IS_DCE2(rdev) && (radeon_audio != 0)) {
  2213.                                 drm_object_attach_property(&radeon_connector->base.base,
  2214.                                                            rdev->mode_info.audio_property,
  2215.                                                            RADEON_AUDIO_AUTO);
  2216.                                 radeon_connector->audio = RADEON_AUDIO_AUTO;
  2217.                         }
  2218.                         if (ASIC_IS_DCE5(rdev))
  2219.                                 drm_object_attach_property(&radeon_connector->base.base,
  2220.                                                            rdev->mode_info.output_csc_property,
  2221.                                                            RADEON_OUTPUT_CSC_BYPASS);
  2222.                         connector->interlace_allowed = true;
  2223.                         /* in theory with a DP to VGA converter... */
  2224.                         connector->doublescan_allowed = false;
  2225.                         break;
  2226.                 case DRM_MODE_CONNECTOR_eDP:
  2227.                         radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
  2228.                         if (!radeon_dig_connector)
  2229.                                 goto failed;
  2230.                         radeon_dig_connector->igp_lane_info = igp_lane_info;
  2231.                         radeon_connector->con_priv = radeon_dig_connector;
  2232.                         drm_connector_init(dev, &radeon_connector->base, &radeon_edp_connector_funcs, connector_type);
  2233.                         drm_connector_helper_add(&radeon_connector->base, &radeon_dp_connector_helper_funcs);
  2234.                         if (i2c_bus->valid) {
  2235.                                 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
  2236.                                 if (radeon_connector->ddc_bus)
  2237.                                         has_aux = true;
  2238.                                 else
  2239.                                         DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
  2240.                         }
  2241.                         drm_object_attach_property(&radeon_connector->base.base,
  2242.                                                       dev->mode_config.scaling_mode_property,
  2243.                                                       DRM_MODE_SCALE_FULLSCREEN);
  2244.                         subpixel_order = SubPixelHorizontalRGB;
  2245.                         connector->interlace_allowed = false;
  2246.                         connector->doublescan_allowed = false;
  2247.                         break;
  2248.                 case DRM_MODE_CONNECTOR_SVIDEO:
  2249.                 case DRM_MODE_CONNECTOR_Composite:
  2250.                 case DRM_MODE_CONNECTOR_9PinDIN:
  2251.                         drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
  2252.                         drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
  2253.                         radeon_connector->dac_load_detect = true;
  2254.                         drm_object_attach_property(&radeon_connector->base.base,
  2255.                                                       rdev->mode_info.load_detect_property,
  2256.                                                       1);
  2257.                         drm_object_attach_property(&radeon_connector->base.base,
  2258.                                                       rdev->mode_info.tv_std_property,
  2259.                                                       radeon_atombios_get_tv_info(rdev));
  2260.                         /* no HPD on analog connectors */
  2261.                         radeon_connector->hpd.hpd = RADEON_HPD_NONE;
  2262.                         connector->interlace_allowed = false;
  2263.                         connector->doublescan_allowed = false;
  2264.                         break;
  2265.                 case DRM_MODE_CONNECTOR_LVDS:
  2266.                         radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
  2267.                         if (!radeon_dig_connector)
  2268.                                 goto failed;
  2269.                         radeon_dig_connector->igp_lane_info = igp_lane_info;
  2270.                         radeon_connector->con_priv = radeon_dig_connector;
  2271.                         drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
  2272.                         drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
  2273.                         if (i2c_bus->valid) {
  2274.                                 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
  2275.                                 if (!radeon_connector->ddc_bus)
  2276.                                         DRM_ERROR("LVDS: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
  2277.                         }
  2278.                         drm_object_attach_property(&radeon_connector->base.base,
  2279.                                                       dev->mode_config.scaling_mode_property,
  2280.                                                       DRM_MODE_SCALE_FULLSCREEN);
  2281.                         subpixel_order = SubPixelHorizontalRGB;
  2282.                         connector->interlace_allowed = false;
  2283.                         connector->doublescan_allowed = false;
  2284.                         break;
  2285.                 }
  2286.         }
  2287.  
  2288.         if (radeon_connector->hpd.hpd == RADEON_HPD_NONE) {
  2289.                 if (i2c_bus->valid)
  2290.                         connector->polled = DRM_CONNECTOR_POLL_CONNECT;
  2291.         } else
  2292.                 connector->polled = DRM_CONNECTOR_POLL_HPD;
  2293.  
  2294.         connector->display_info.subpixel_order = subpixel_order;
  2295.         drm_connector_register(connector);
  2296.  
  2297.         if (has_aux)
  2298.                 radeon_dp_aux_init(radeon_connector);
  2299.  
  2300.         return;
  2301.  
  2302. failed:
  2303.         drm_connector_cleanup(connector);
  2304.         kfree(connector);
  2305. }
  2306.  
  2307. void
  2308. radeon_add_legacy_connector(struct drm_device *dev,
  2309.                             uint32_t connector_id,
  2310.                             uint32_t supported_device,
  2311.                             int connector_type,
  2312.                             struct radeon_i2c_bus_rec *i2c_bus,
  2313.                             uint16_t connector_object_id,
  2314.                             struct radeon_hpd *hpd)
  2315. {
  2316.         struct radeon_device *rdev = dev->dev_private;
  2317.         struct drm_connector *connector;
  2318.         struct radeon_connector *radeon_connector;
  2319.         uint32_t subpixel_order = SubPixelNone;
  2320.  
  2321.         if (connector_type == DRM_MODE_CONNECTOR_Unknown)
  2322.                 return;
  2323.  
  2324.         /* if the user selected tv=0 don't try and add the connector */
  2325.         if (((connector_type == DRM_MODE_CONNECTOR_SVIDEO) ||
  2326.              (connector_type == DRM_MODE_CONNECTOR_Composite) ||
  2327.              (connector_type == DRM_MODE_CONNECTOR_9PinDIN)) &&
  2328.             (radeon_tv == 0))
  2329.                 return;
  2330.  
  2331.         /* see if we already added it */
  2332.         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
  2333.                 radeon_connector = to_radeon_connector(connector);
  2334.                 if (radeon_connector->connector_id == connector_id) {
  2335.                         radeon_connector->devices |= supported_device;
  2336.                         return;
  2337.                 }
  2338.         }
  2339.  
  2340.         radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
  2341.         if (!radeon_connector)
  2342.                 return;
  2343.  
  2344.         connector = &radeon_connector->base;
  2345.  
  2346.         radeon_connector->connector_id = connector_id;
  2347.         radeon_connector->devices = supported_device;
  2348.         radeon_connector->connector_object_id = connector_object_id;
  2349.         radeon_connector->hpd = *hpd;
  2350.  
  2351.         switch (connector_type) {
  2352.         case DRM_MODE_CONNECTOR_VGA:
  2353.                 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
  2354.                 drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
  2355.                 if (i2c_bus->valid) {
  2356.                         radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
  2357.                         if (!radeon_connector->ddc_bus)
  2358.                                 DRM_ERROR("VGA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
  2359.                 }
  2360.                 radeon_connector->dac_load_detect = true;
  2361.                 drm_object_attach_property(&radeon_connector->base.base,
  2362.                                               rdev->mode_info.load_detect_property,
  2363.                                               1);
  2364.                 /* no HPD on analog connectors */
  2365.                 radeon_connector->hpd.hpd = RADEON_HPD_NONE;
  2366.                 connector->polled = DRM_CONNECTOR_POLL_CONNECT;
  2367.                 connector->interlace_allowed = true;
  2368.                 connector->doublescan_allowed = true;
  2369.                 break;
  2370.         case DRM_MODE_CONNECTOR_DVIA:
  2371.                 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
  2372.                 drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
  2373.                 if (i2c_bus->valid) {
  2374.                         radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
  2375.                         if (!radeon_connector->ddc_bus)
  2376.                                 DRM_ERROR("DVIA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
  2377.                 }
  2378.                 radeon_connector->dac_load_detect = true;
  2379.                 drm_object_attach_property(&radeon_connector->base.base,
  2380.                                               rdev->mode_info.load_detect_property,
  2381.                                               1);
  2382.                 /* no HPD on analog connectors */
  2383.                 radeon_connector->hpd.hpd = RADEON_HPD_NONE;
  2384.                 connector->interlace_allowed = true;
  2385.                 connector->doublescan_allowed = true;
  2386.                 break;
  2387.         case DRM_MODE_CONNECTOR_DVII:
  2388.         case DRM_MODE_CONNECTOR_DVID:
  2389.                 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
  2390.                 drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
  2391.                 if (i2c_bus->valid) {
  2392.                         radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
  2393.                         if (!radeon_connector->ddc_bus)
  2394.                                 DRM_ERROR("DVI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
  2395.                 }
  2396.                 if (connector_type == DRM_MODE_CONNECTOR_DVII) {
  2397.                         radeon_connector->dac_load_detect = true;
  2398.                         drm_object_attach_property(&radeon_connector->base.base,
  2399.                                                       rdev->mode_info.load_detect_property,
  2400.                                                       1);
  2401.                 }
  2402.                 subpixel_order = SubPixelHorizontalRGB;
  2403.                 connector->interlace_allowed = true;
  2404.                 if (connector_type == DRM_MODE_CONNECTOR_DVII)
  2405.                         connector->doublescan_allowed = true;
  2406.                 else
  2407.                         connector->doublescan_allowed = false;
  2408.                 break;
  2409.         case DRM_MODE_CONNECTOR_SVIDEO:
  2410.         case DRM_MODE_CONNECTOR_Composite:
  2411.         case DRM_MODE_CONNECTOR_9PinDIN:
  2412.                 drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
  2413.                 drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
  2414.                 radeon_connector->dac_load_detect = true;
  2415.                 /* RS400,RC410,RS480 chipset seems to report a lot
  2416.                  * of false positive on load detect, we haven't yet
  2417.                  * found a way to make load detect reliable on those
  2418.                  * chipset, thus just disable it for TV.
  2419.                  */
  2420.                 if (rdev->family == CHIP_RS400 || rdev->family == CHIP_RS480)
  2421.                         radeon_connector->dac_load_detect = false;
  2422.                 drm_object_attach_property(&radeon_connector->base.base,
  2423.                                               rdev->mode_info.load_detect_property,
  2424.                                               radeon_connector->dac_load_detect);
  2425.                 drm_object_attach_property(&radeon_connector->base.base,
  2426.                                               rdev->mode_info.tv_std_property,
  2427.                                               radeon_combios_get_tv_info(rdev));
  2428.                 /* no HPD on analog connectors */
  2429.                 radeon_connector->hpd.hpd = RADEON_HPD_NONE;
  2430.                 connector->interlace_allowed = false;
  2431.                 connector->doublescan_allowed = false;
  2432.                 break;
  2433.         case DRM_MODE_CONNECTOR_LVDS:
  2434.                 drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
  2435.                 drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
  2436.                 if (i2c_bus->valid) {
  2437.                         radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
  2438.                         if (!radeon_connector->ddc_bus)
  2439.                                 DRM_ERROR("LVDS: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
  2440.                 }
  2441.                 drm_object_attach_property(&radeon_connector->base.base,
  2442.                                               dev->mode_config.scaling_mode_property,
  2443.                                               DRM_MODE_SCALE_FULLSCREEN);
  2444.                 subpixel_order = SubPixelHorizontalRGB;
  2445.                 connector->interlace_allowed = false;
  2446.                 connector->doublescan_allowed = false;
  2447.                 break;
  2448.         }
  2449.  
  2450.         if (radeon_connector->hpd.hpd == RADEON_HPD_NONE) {
  2451.                 if (i2c_bus->valid)
  2452.                         connector->polled = DRM_CONNECTOR_POLL_CONNECT;
  2453.         } else
  2454.                 connector->polled = DRM_CONNECTOR_POLL_HPD;
  2455.         connector->display_info.subpixel_order = subpixel_order;
  2456.         drm_connector_register(connector);
  2457. }
  2458.  
  2459. void radeon_setup_mst_connector(struct drm_device *dev)
  2460. {
  2461.         struct radeon_device *rdev = dev->dev_private;
  2462.         struct drm_connector *connector;
  2463.         struct radeon_connector *radeon_connector;
  2464.  
  2465.         if (!ASIC_IS_DCE5(rdev))
  2466.                 return;
  2467.  
  2468.         if (radeon_mst == 0)
  2469.                 return;
  2470.  
  2471.         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
  2472.                 int ret;
  2473.  
  2474.                 radeon_connector = to_radeon_connector(connector);
  2475.  
  2476.                 if (connector->connector_type != DRM_MODE_CONNECTOR_DisplayPort)
  2477.                         continue;
  2478.  
  2479.                 ret = radeon_dp_mst_init(radeon_connector);
  2480.         }
  2481. }
  2482.