Subversion Repositories Kolibri OS

Rev

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