Subversion Repositories Kolibri OS

Rev

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