Subversion Repositories Kolibri OS

Rev

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