Subversion Repositories Kolibri OS

Rev

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