Subversion Repositories Kolibri OS

Rev

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