Subversion Repositories Kolibri OS

Rev

Rev 1404 | Rev 1430 | 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. void radeon_connector_hotplug(struct drm_connector *connector)
  44. {
  45.         struct drm_device *dev = connector->dev;
  46.         struct radeon_device *rdev = dev->dev_private;
  47.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  48.  
  49.         if (radeon_connector->hpd.hpd != RADEON_HPD_NONE)
  50.                 radeon_hpd_set_polarity(rdev, radeon_connector->hpd.hpd);
  51.  
  52.         if ((connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort) ||
  53.             (connector->connector_type == DRM_MODE_CONNECTOR_eDP)) {
  54.                 if ((radeon_dp_getsinktype(radeon_connector) == CONNECTOR_OBJECT_ID_DISPLAYPORT) ||
  55.                     (radeon_dp_getsinktype(radeon_connector) == CONNECTOR_OBJECT_ID_eDP)) {
  56.                         if (radeon_dp_needs_link_train(radeon_connector)) {
  57.                                 if (connector->encoder)
  58.                                         dp_link_train(connector->encoder, connector);
  59.                         }
  60.                 }
  61.         }
  62.  
  63. }
  64.  
  65. static void radeon_property_change_mode(struct drm_encoder *encoder)
  66. {
  67.         struct drm_crtc *crtc = encoder->crtc;
  68.  
  69.         if (crtc && crtc->enabled) {
  70.                 drm_crtc_helper_set_mode(crtc, &crtc->mode,
  71.                                          crtc->x, crtc->y, crtc->fb);
  72.         }
  73. }
  74. static void
  75. radeon_connector_update_scratch_regs(struct drm_connector *connector, enum drm_connector_status status)
  76. {
  77.         struct drm_device *dev = connector->dev;
  78.         struct radeon_device *rdev = dev->dev_private;
  79.         struct drm_encoder *best_encoder = NULL;
  80.         struct drm_encoder *encoder = NULL;
  81.         struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
  82.         struct drm_mode_object *obj;
  83.         bool connected;
  84.         int i;
  85.  
  86.         best_encoder = connector_funcs->best_encoder(connector);
  87.  
  88.         for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
  89.                 if (connector->encoder_ids[i] == 0)
  90.                         break;
  91.  
  92.                 obj = drm_mode_object_find(connector->dev,
  93.                                            connector->encoder_ids[i],
  94.                                            DRM_MODE_OBJECT_ENCODER);
  95.                 if (!obj)
  96.                         continue;
  97.  
  98.                 encoder = obj_to_encoder(obj);
  99.  
  100.                 if ((encoder == best_encoder) && (status == connector_status_connected))
  101.                         connected = true;
  102.                 else
  103.                         connected = false;
  104.  
  105.                 if (rdev->is_atom_bios)
  106.                         radeon_atombios_connected_scratch_regs(connector, encoder, connected);
  107.                 else
  108.                         radeon_combios_connected_scratch_regs(connector, encoder, connected);
  109.  
  110.         }
  111. }
  112.  
  113. struct drm_encoder *radeon_find_encoder(struct drm_connector *connector, int encoder_type)
  114. {
  115.         struct drm_mode_object *obj;
  116.         struct drm_encoder *encoder;
  117.         int i;
  118.  
  119.         for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
  120.                 if (connector->encoder_ids[i] == 0)
  121.                         break;
  122.  
  123.                 obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
  124.                 if (!obj)
  125.                         continue;
  126.  
  127.                 encoder = obj_to_encoder(obj);
  128.                 if (encoder->encoder_type == encoder_type)
  129.                         return encoder;
  130.         }
  131.         return NULL;
  132. }
  133.  
  134. struct drm_encoder *radeon_best_single_encoder(struct drm_connector *connector)
  135. {
  136.         int enc_id = connector->encoder_ids[0];
  137.         struct drm_mode_object *obj;
  138.         struct drm_encoder *encoder;
  139.  
  140.         /* pick the encoder ids */
  141.         if (enc_id) {
  142.                 obj = drm_mode_object_find(connector->dev, enc_id, DRM_MODE_OBJECT_ENCODER);
  143.                 if (!obj)
  144.                         return NULL;
  145.                 encoder = obj_to_encoder(obj);
  146.                 return encoder;
  147.         }
  148.         return NULL;
  149. }
  150.  
  151. /*
  152.  * radeon_connector_analog_encoder_conflict_solve
  153.  * - search for other connectors sharing this encoder
  154.  *   if priority is true, then set them disconnected if this is connected
  155.  *   if priority is false, set us disconnected if they are connected
  156.  */
  157. static enum drm_connector_status
  158. radeon_connector_analog_encoder_conflict_solve(struct drm_connector *connector,
  159.                                                struct drm_encoder *encoder,
  160.                                                enum drm_connector_status current_status,
  161.                                                bool priority)
  162. {
  163.         struct drm_device *dev = connector->dev;
  164.         struct drm_connector *conflict;
  165.         int i;
  166.  
  167.         list_for_each_entry(conflict, &dev->mode_config.connector_list, head) {
  168.                 if (conflict == connector)
  169.                         continue;
  170.  
  171.                 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
  172.                         if (conflict->encoder_ids[i] == 0)
  173.                                 break;
  174.  
  175.                         /* if the IDs match */
  176.                         if (conflict->encoder_ids[i] == encoder->base.id) {
  177.                                 if (conflict->status != connector_status_connected)
  178.                                         continue;
  179.  
  180.                                 if (priority == true) {
  181.                                         DRM_INFO("1: conflicting encoders switching off %s\n", drm_get_connector_name(conflict));
  182.                                         DRM_INFO("in favor of %s\n", drm_get_connector_name(connector));
  183.                                         conflict->status = connector_status_disconnected;
  184.                                         radeon_connector_update_scratch_regs(conflict, connector_status_disconnected);
  185.                                 } else {
  186.                                         DRM_INFO("2: conflicting encoders switching off %s\n", drm_get_connector_name(connector));
  187.                                         DRM_INFO("in favor of %s\n", drm_get_connector_name(conflict));
  188.                                         current_status = connector_status_disconnected;
  189.                                 }
  190.                                 break;
  191.                         }
  192.                 }
  193.         }
  194.         return current_status;
  195.  
  196. }
  197.  
  198. static struct drm_display_mode *radeon_fp_native_mode(struct drm_encoder *encoder)
  199. {
  200.         struct drm_device *dev = encoder->dev;
  201.         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
  202.         struct drm_display_mode *mode = NULL;
  203.         struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
  204.  
  205.         if (native_mode->hdisplay != 0 &&
  206.             native_mode->vdisplay != 0 &&
  207.             native_mode->clock != 0) {
  208.                 mode = drm_mode_duplicate(dev, native_mode);
  209.                 mode->type = DRM_MODE_TYPE_PREFERRED | DRM_MODE_TYPE_DRIVER;
  210.                 drm_mode_set_name(mode);
  211.  
  212.                 DRM_DEBUG("Adding native panel mode %s\n", mode->name);
  213.         } else if (native_mode->hdisplay != 0 &&
  214.                    native_mode->vdisplay != 0) {
  215.                 /* mac laptops without an edid */
  216.                 /* Note that this is not necessarily the exact panel mode,
  217.                  * but an approximation based on the cvt formula.  For these
  218.                  * systems we should ideally read the mode info out of the
  219.                  * registers or add a mode table, but this works and is much
  220.                  * simpler.
  221.                  */
  222.                 mode = drm_cvt_mode(dev, native_mode->hdisplay, native_mode->vdisplay, 60, true, false, false);
  223.                 mode->type = DRM_MODE_TYPE_PREFERRED | DRM_MODE_TYPE_DRIVER;
  224.                 DRM_DEBUG("Adding cvt approximation of native panel mode %s\n", mode->name);
  225.         }
  226.         return mode;
  227. }
  228.  
  229. static void radeon_add_common_modes(struct drm_encoder *encoder, struct drm_connector *connector)
  230. {
  231.         struct drm_device *dev = encoder->dev;
  232.         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
  233.         struct drm_display_mode *mode = NULL;
  234.         struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
  235.         int i;
  236.         struct mode_size {
  237.                 int w;
  238.                 int h;
  239.         } common_modes[17] = {
  240.                 { 640,  480},
  241.                 { 720,  480},
  242.                 { 800,  600},
  243.                 { 848,  480},
  244.                 {1024,  768},
  245.                 {1152,  768},
  246.                 {1280,  720},
  247.                 {1280,  800},
  248.                 {1280,  854},
  249.                 {1280,  960},
  250.                 {1280, 1024},
  251.                 {1440,  900},
  252.                 {1400, 1050},
  253.                 {1680, 1050},
  254.                 {1600, 1200},
  255.                 {1920, 1080},
  256.                 {1920, 1200}
  257.         };
  258.  
  259.         for (i = 0; i < 17; i++) {
  260.                 if (radeon_encoder->devices & (ATOM_DEVICE_TV_SUPPORT)) {
  261.                         if (common_modes[i].w > 1024 ||
  262.                             common_modes[i].h > 768)
  263.                                 continue;
  264.                 }
  265.                 if (radeon_encoder->devices & (ATOM_DEVICE_LCD_SUPPORT)) {
  266.                         if (common_modes[i].w > native_mode->hdisplay ||
  267.                             common_modes[i].h > native_mode->vdisplay ||
  268.                             (common_modes[i].w == native_mode->hdisplay &&
  269.                              common_modes[i].h == native_mode->vdisplay))
  270.                                 continue;
  271.                 }
  272.                 if (common_modes[i].w < 320 || common_modes[i].h < 200)
  273.                         continue;
  274.  
  275.                 mode = drm_cvt_mode(dev, common_modes[i].w, common_modes[i].h, 60, false, false, false);
  276.                 drm_mode_probed_add(connector, mode);
  277.         }
  278. }
  279.  
  280. int radeon_connector_set_property(struct drm_connector *connector, struct drm_property *property,
  281.                                   uint64_t val)
  282. {
  283.         struct drm_device *dev = connector->dev;
  284.         struct radeon_device *rdev = dev->dev_private;
  285.         struct drm_encoder *encoder;
  286.         struct radeon_encoder *radeon_encoder;
  287.  
  288.         if (property == rdev->mode_info.coherent_mode_property) {
  289.                 struct radeon_encoder_atom_dig *dig;
  290.  
  291.                 /* need to find digital encoder on connector */
  292.                 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
  293.                 if (!encoder)
  294.                         return 0;
  295.  
  296.                 radeon_encoder = to_radeon_encoder(encoder);
  297.  
  298.                 if (!radeon_encoder->enc_priv)
  299.                         return 0;
  300.  
  301.                 dig = radeon_encoder->enc_priv;
  302.                 dig->coherent_mode = val ? true : false;
  303.                 radeon_property_change_mode(&radeon_encoder->base);
  304.         }
  305.  
  306.         if (property == rdev->mode_info.tv_std_property) {
  307.                 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TVDAC);
  308.                 if (!encoder) {
  309.                         encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_DAC);
  310.                 }
  311.  
  312.                 if (!encoder)
  313.                         return 0;
  314.  
  315.                 radeon_encoder = to_radeon_encoder(encoder);
  316.                 if (!radeon_encoder->enc_priv)
  317.                         return 0;
  318.                 if (rdev->is_atom_bios) {
  319.                         struct radeon_encoder_atom_dac *dac_int;
  320.                         dac_int = radeon_encoder->enc_priv;
  321.                         dac_int->tv_std = val;
  322.                 } else {
  323.                         struct radeon_encoder_tv_dac *dac_int;
  324.                         dac_int = radeon_encoder->enc_priv;
  325.                         dac_int->tv_std = val;
  326.                 }
  327.                 radeon_property_change_mode(&radeon_encoder->base);
  328.         }
  329.  
  330.         if (property == rdev->mode_info.load_detect_property) {
  331.                 struct radeon_connector *radeon_connector =
  332.                         to_radeon_connector(connector);
  333.  
  334.                 if (val == 0)
  335.                         radeon_connector->dac_load_detect = false;
  336.                 else
  337.                         radeon_connector->dac_load_detect = true;
  338.         }
  339.  
  340.         if (property == rdev->mode_info.tmds_pll_property) {
  341.                 struct radeon_encoder_int_tmds *tmds = NULL;
  342.                 bool ret = false;
  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.                 tmds = radeon_encoder->enc_priv;
  351.                 if (!tmds)
  352.                         return 0;
  353.  
  354.                 if (val == 0) {
  355.                         if (rdev->is_atom_bios)
  356.                                 ret = radeon_atombios_get_tmds_info(radeon_encoder, tmds);
  357.                         else
  358.                                 ret = radeon_legacy_get_tmds_info_from_combios(radeon_encoder, tmds);
  359.                 }
  360.                 if (val == 1 || ret == false) {
  361.                         radeon_legacy_get_tmds_info_from_table(radeon_encoder, tmds);
  362.                 }
  363.                 radeon_property_change_mode(&radeon_encoder->base);
  364.         }
  365.  
  366.         return 0;
  367. }
  368.  
  369. static void radeon_fixup_lvds_native_mode(struct drm_encoder *encoder,
  370.                                           struct drm_connector *connector)
  371. {
  372.         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
  373.         struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
  374.  
  375.         /* Try to get native mode details from EDID if necessary */
  376.         if (!native_mode->clock) {
  377.                 struct drm_display_mode *t, *mode;
  378.  
  379.                 list_for_each_entry_safe(mode, t, &connector->probed_modes, head) {
  380.                         if (mode->hdisplay == native_mode->hdisplay &&
  381.                             mode->vdisplay == native_mode->vdisplay) {
  382.                                 *native_mode = *mode;
  383.                                 drm_mode_set_crtcinfo(native_mode, CRTC_INTERLACE_HALVE_V);
  384.                                 DRM_INFO("Determined LVDS native mode details from EDID\n");
  385.                                 break;
  386.                         }
  387.                 }
  388.         }
  389.         if (!native_mode->clock) {
  390.                 DRM_INFO("No LVDS native mode details, disabling RMX\n");
  391.                 radeon_encoder->rmx_type = RMX_OFF;
  392.         }
  393. }
  394.  
  395. static int radeon_lvds_get_modes(struct drm_connector *connector)
  396. {
  397.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  398.         struct drm_encoder *encoder;
  399.         int ret = 0;
  400.         struct drm_display_mode *mode;
  401.  
  402.         if (radeon_connector->ddc_bus) {
  403.                 ret = radeon_ddc_get_modes(radeon_connector);
  404.                 if (ret > 0) {
  405.                         encoder = radeon_best_single_encoder(connector);
  406.                         if (encoder) {
  407.                                 radeon_fixup_lvds_native_mode(encoder, connector);
  408.                                 /* add scaled modes */
  409.                                 radeon_add_common_modes(encoder, connector);
  410.                         }
  411.                         return ret;
  412.                 }
  413.         }
  414.  
  415.         encoder = radeon_best_single_encoder(connector);
  416.         if (!encoder)
  417.                 return 0;
  418.  
  419.         /* we have no EDID modes */
  420.         mode = radeon_fp_native_mode(encoder);
  421.         if (mode) {
  422.                 ret = 1;
  423.                 drm_mode_probed_add(connector, mode);
  424.                 /* add scaled modes */
  425.                 radeon_add_common_modes(encoder, connector);
  426.         }
  427.  
  428.         return ret;
  429. }
  430.  
  431. static int radeon_lvds_mode_valid(struct drm_connector *connector,
  432.                                   struct drm_display_mode *mode)
  433. {
  434.         struct drm_encoder *encoder = radeon_best_single_encoder(connector);
  435.  
  436.         if ((mode->hdisplay < 320) || (mode->vdisplay < 240))
  437.                 return MODE_PANEL;
  438.  
  439.         if (encoder) {
  440.                 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
  441.                 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
  442.  
  443.                 /* AVIVO hardware supports downscaling modes larger than the panel
  444.                  * to the panel size, but I'm not sure this is desirable.
  445.                  */
  446.                 if ((mode->hdisplay > native_mode->hdisplay) ||
  447.                     (mode->vdisplay > native_mode->vdisplay))
  448.                         return MODE_PANEL;
  449.  
  450.                 /* if scaling is disabled, block non-native modes */
  451.                 if (radeon_encoder->rmx_type == RMX_OFF) {
  452.                         if ((mode->hdisplay != native_mode->hdisplay) ||
  453.                             (mode->vdisplay != native_mode->vdisplay))
  454.                                 return MODE_PANEL;
  455.                 }
  456.         }
  457.  
  458.         return MODE_OK;
  459. }
  460.  
  461. static enum drm_connector_status radeon_lvds_detect(struct drm_connector *connector)
  462. {
  463.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  464.         struct drm_encoder *encoder = radeon_best_single_encoder(connector);
  465.         enum drm_connector_status ret = connector_status_disconnected;
  466.  
  467.         if (encoder) {
  468.                 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
  469.                 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
  470.  
  471.                 /* check if panel is valid */
  472.                 if (native_mode->hdisplay >= 320 && native_mode->vdisplay >= 240)
  473.                         ret = connector_status_connected;
  474.  
  475.         }
  476.  
  477.         /* check for edid as well */
  478.         if (radeon_connector->edid)
  479.                 ret = connector_status_connected;
  480.         else {
  481.                 if (radeon_connector->ddc_bus) {
  482.                         radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
  483.                         radeon_connector->edid = drm_get_edid(&radeon_connector->base,
  484.                                                               &radeon_connector->ddc_bus->adapter);
  485.                         radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
  486.                         if (radeon_connector->edid)
  487.                                 ret = connector_status_connected;
  488.                 }
  489.         }
  490.         /* check acpi lid status ??? */
  491.  
  492.         radeon_connector_update_scratch_regs(connector, ret);
  493.         return ret;
  494. }
  495.  
  496. static void radeon_connector_destroy(struct drm_connector *connector)
  497. {
  498.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  499.  
  500.         if (radeon_connector->ddc_bus)
  501.                 radeon_i2c_destroy(radeon_connector->ddc_bus);
  502.         if (radeon_connector->edid)
  503.                 kfree(radeon_connector->edid);
  504.         kfree(radeon_connector->con_priv);
  505.         drm_sysfs_connector_remove(connector);
  506.         drm_connector_cleanup(connector);
  507.         kfree(connector);
  508. }
  509.  
  510. static int radeon_lvds_set_property(struct drm_connector *connector,
  511.                                     struct drm_property *property,
  512.                                     uint64_t value)
  513. {
  514.         struct drm_device *dev = connector->dev;
  515.         struct radeon_encoder *radeon_encoder;
  516.         enum radeon_rmx_type rmx_type;
  517.  
  518.         DRM_DEBUG("\n");
  519.         if (property != dev->mode_config.scaling_mode_property)
  520.                 return 0;
  521.  
  522.         if (connector->encoder)
  523.                 radeon_encoder = to_radeon_encoder(connector->encoder);
  524.         else {
  525.                 struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
  526.                 radeon_encoder = to_radeon_encoder(connector_funcs->best_encoder(connector));
  527.         }
  528.  
  529.         switch (value) {
  530.         case DRM_MODE_SCALE_NONE: rmx_type = RMX_OFF; break;
  531.         case DRM_MODE_SCALE_CENTER: rmx_type = RMX_CENTER; break;
  532.         case DRM_MODE_SCALE_ASPECT: rmx_type = RMX_ASPECT; break;
  533.         default:
  534.         case DRM_MODE_SCALE_FULLSCREEN: rmx_type = RMX_FULL; break;
  535.         }
  536.         if (radeon_encoder->rmx_type == rmx_type)
  537.                 return 0;
  538.  
  539.         radeon_encoder->rmx_type = rmx_type;
  540.  
  541.         radeon_property_change_mode(&radeon_encoder->base);
  542.         return 0;
  543. }
  544.  
  545.  
  546. struct drm_connector_helper_funcs radeon_lvds_connector_helper_funcs = {
  547.         .get_modes = radeon_lvds_get_modes,
  548.         .mode_valid = radeon_lvds_mode_valid,
  549.         .best_encoder = radeon_best_single_encoder,
  550. };
  551.  
  552. struct drm_connector_funcs radeon_lvds_connector_funcs = {
  553.         .dpms = drm_helper_connector_dpms,
  554.         .detect = radeon_lvds_detect,
  555.         .fill_modes = drm_helper_probe_single_connector_modes,
  556.         .destroy = radeon_connector_destroy,
  557.         .set_property = radeon_lvds_set_property,
  558. };
  559.  
  560. static int radeon_vga_get_modes(struct drm_connector *connector)
  561. {
  562.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  563.         int ret;
  564.  
  565.         ret = radeon_ddc_get_modes(radeon_connector);
  566.  
  567.         return ret;
  568. }
  569.  
  570. static int radeon_vga_mode_valid(struct drm_connector *connector,
  571.                                   struct drm_display_mode *mode)
  572. {
  573.         /* XXX check mode bandwidth */
  574.         /* XXX verify against max DAC output frequency */
  575.         return MODE_OK;
  576. }
  577.  
  578. static enum drm_connector_status radeon_vga_detect(struct drm_connector *connector)
  579. {
  580.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  581.         struct drm_encoder *encoder;
  582.         struct drm_encoder_helper_funcs *encoder_funcs;
  583.         bool dret = false;
  584.         enum drm_connector_status ret = connector_status_disconnected;
  585.  
  586.         encoder = radeon_best_single_encoder(connector);
  587.         if (!encoder)
  588.                 ret = connector_status_disconnected;
  589.  
  590.         if (radeon_connector->ddc_bus) {
  591.             radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
  592.             dret = radeon_ddc_probe(radeon_connector);
  593.             radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
  594.         }
  595.         if (dret) {
  596.                 if (radeon_connector->edid) {
  597.                         kfree(radeon_connector->edid);
  598.                         radeon_connector->edid = NULL;
  599.                 }
  600.                 radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
  601.                 radeon_connector->edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
  602.                 radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
  603.  
  604.                 if (!radeon_connector->edid) {
  605.                         DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
  606.                                   drm_get_connector_name(connector));
  607.                         ret = connector_status_connected;
  608.                 } else {
  609.                         radeon_connector->use_digital = !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
  610.  
  611.                         /* some oems have boards with separate digital and analog connectors
  612.                          * with a shared ddc line (often vga + hdmi)
  613.                          */
  614.                         if (radeon_connector->use_digital && radeon_connector->shared_ddc) {
  615.                                 kfree(radeon_connector->edid);
  616.                                 radeon_connector->edid = NULL;
  617.                                 ret = connector_status_disconnected;
  618.                         } else
  619.                 ret = connector_status_connected;
  620.                 }
  621.         } else {
  622.                 if (radeon_connector->dac_load_detect && encoder) {
  623.                         encoder_funcs = encoder->helper_private;
  624.                         ret = encoder_funcs->detect(encoder, connector);
  625.                 }
  626.         }
  627.  
  628.         if (ret == connector_status_connected)
  629.                 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
  630.         radeon_connector_update_scratch_regs(connector, ret);
  631.         return ret;
  632. }
  633.  
  634. struct drm_connector_helper_funcs radeon_vga_connector_helper_funcs = {
  635.         .get_modes = radeon_vga_get_modes,
  636.         .mode_valid = radeon_vga_mode_valid,
  637.         .best_encoder = radeon_best_single_encoder,
  638. };
  639.  
  640. struct drm_connector_funcs radeon_vga_connector_funcs = {
  641.         .dpms = drm_helper_connector_dpms,
  642.         .detect = radeon_vga_detect,
  643.         .fill_modes = drm_helper_probe_single_connector_modes,
  644.         .destroy = radeon_connector_destroy,
  645.         .set_property = radeon_connector_set_property,
  646. };
  647.  
  648. static int radeon_tv_get_modes(struct drm_connector *connector)
  649. {
  650.         struct drm_device *dev = connector->dev;
  651.         struct radeon_device *rdev = dev->dev_private;
  652.         struct drm_display_mode *tv_mode;
  653.         struct drm_encoder *encoder;
  654.  
  655.         encoder = radeon_best_single_encoder(connector);
  656.         if (!encoder)
  657.                 return 0;
  658.  
  659.         /* avivo chips can scale any mode */
  660.         if (rdev->family >= CHIP_RS600)
  661.                 /* add scaled modes */
  662.                 radeon_add_common_modes(encoder, connector);
  663.         else {
  664.                 /* only 800x600 is supported right now on pre-avivo chips */
  665.                 tv_mode = drm_cvt_mode(dev, 800, 600, 60, false, false, false);
  666.                 tv_mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
  667.                 drm_mode_probed_add(connector, tv_mode);
  668.         }
  669.         return 1;
  670. }
  671.  
  672. static int radeon_tv_mode_valid(struct drm_connector *connector,
  673.                                 struct drm_display_mode *mode)
  674. {
  675.         if ((mode->hdisplay > 1024) || (mode->vdisplay > 768))
  676.                 return MODE_CLOCK_RANGE;
  677.         return MODE_OK;
  678. }
  679.  
  680. static enum drm_connector_status radeon_tv_detect(struct drm_connector *connector)
  681. {
  682.         struct drm_encoder *encoder;
  683.         struct drm_encoder_helper_funcs *encoder_funcs;
  684.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  685.         enum drm_connector_status ret = connector_status_disconnected;
  686.  
  687.         if (!radeon_connector->dac_load_detect)
  688.                 return ret;
  689.  
  690.         encoder = radeon_best_single_encoder(connector);
  691.         if (!encoder)
  692.                 ret = connector_status_disconnected;
  693.         else {
  694.                 encoder_funcs = encoder->helper_private;
  695.                 ret = encoder_funcs->detect(encoder, connector);
  696.         }
  697.         if (ret == connector_status_connected)
  698.                 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, false);
  699.         radeon_connector_update_scratch_regs(connector, ret);
  700.         return ret;
  701. }
  702.  
  703. struct drm_connector_helper_funcs radeon_tv_connector_helper_funcs = {
  704.         .get_modes = radeon_tv_get_modes,
  705.         .mode_valid = radeon_tv_mode_valid,
  706.         .best_encoder = radeon_best_single_encoder,
  707. };
  708.  
  709. struct drm_connector_funcs radeon_tv_connector_funcs = {
  710.         .dpms = drm_helper_connector_dpms,
  711.         .detect = radeon_tv_detect,
  712.         .fill_modes = drm_helper_probe_single_connector_modes,
  713.         .destroy = radeon_connector_destroy,
  714.         .set_property = radeon_connector_set_property,
  715. };
  716.  
  717. static int radeon_dvi_get_modes(struct drm_connector *connector)
  718. {
  719.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  720.         int ret;
  721.  
  722.         ret = radeon_ddc_get_modes(radeon_connector);
  723.         return ret;
  724. }
  725.  
  726. /*
  727.  * DVI is complicated
  728.  * Do a DDC probe, if DDC probe passes, get the full EDID so
  729.  * we can do analog/digital monitor detection at this point.
  730.  * If the monitor is an analog monitor or we got no DDC,
  731.  * we need to find the DAC encoder object for this connector.
  732.  * If we got no DDC, we do load detection on the DAC encoder object.
  733.  * If we got analog DDC or load detection passes on the DAC encoder
  734.  * we have to check if this analog encoder is shared with anyone else (TV)
  735.  * if its shared we have to set the other connector to disconnected.
  736.  */
  737. static enum drm_connector_status radeon_dvi_detect(struct drm_connector *connector)
  738. {
  739.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  740.         struct drm_encoder *encoder = NULL;
  741.         struct drm_encoder_helper_funcs *encoder_funcs;
  742.         struct drm_mode_object *obj;
  743.         int i;
  744.         enum drm_connector_status ret = connector_status_disconnected;
  745.         bool dret = false;
  746.  
  747.         if (radeon_connector->ddc_bus) {
  748.         radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
  749.         dret = radeon_ddc_probe(radeon_connector);
  750.         radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
  751.         }
  752.         if (dret) {
  753.                 if (radeon_connector->edid) {
  754.                         kfree(radeon_connector->edid);
  755.                         radeon_connector->edid = NULL;
  756.                 }
  757.                 radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
  758.                 radeon_connector->edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
  759.                 radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
  760.  
  761.                 if (!radeon_connector->edid) {
  762.                         DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
  763.                                   drm_get_connector_name(connector));
  764.                 } else {
  765.                         radeon_connector->use_digital = !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
  766.  
  767.                         /* some oems have boards with separate digital and analog connectors
  768.                          * with a shared ddc line (often vga + hdmi)
  769.                          */
  770.                         if ((!radeon_connector->use_digital) && radeon_connector->shared_ddc) {
  771.                                 kfree(radeon_connector->edid);
  772.                                 radeon_connector->edid = NULL;
  773.                                 ret = connector_status_disconnected;
  774.                         } else
  775.                 ret = connector_status_connected;
  776.  
  777.                         /* multiple connectors on the same encoder with the same ddc line
  778.                          * This tends to be HDMI and DVI on the same encoder with the
  779.                          * same ddc line.  If the edid says HDMI, consider the HDMI port
  780.                          * connected and the DVI port disconnected.  If the edid doesn't
  781.                          * say HDMI, vice versa.
  782.                          */
  783.                         if (radeon_connector->shared_ddc && (ret == connector_status_connected)) {
  784.                                 struct drm_device *dev = connector->dev;
  785.                                 struct drm_connector *list_connector;
  786.                                 struct radeon_connector *list_radeon_connector;
  787.                                 list_for_each_entry(list_connector, &dev->mode_config.connector_list, head) {
  788.                                         if (connector == list_connector)
  789.                                                 continue;
  790.                                         list_radeon_connector = to_radeon_connector(list_connector);
  791.                                         if (radeon_connector->devices == list_radeon_connector->devices) {
  792.                                                 if (drm_detect_hdmi_monitor(radeon_connector->edid)) {
  793.                                                         if (connector->connector_type == DRM_MODE_CONNECTOR_DVID) {
  794.                                                                 kfree(radeon_connector->edid);
  795.                                                                 radeon_connector->edid = NULL;
  796.                                                                 ret = connector_status_disconnected;
  797.                                                         }
  798.                                                 } else {
  799.                                                         if ((connector->connector_type == DRM_MODE_CONNECTOR_HDMIA) ||
  800.                                                             (connector->connector_type == DRM_MODE_CONNECTOR_HDMIB)) {
  801.                                                                 kfree(radeon_connector->edid);
  802.                                                                 radeon_connector->edid = NULL;
  803.                                                                 ret = connector_status_disconnected;
  804.                                                         }
  805.                                                 }
  806.                                         }
  807.                                 }
  808.                         }
  809.                 }
  810.         }
  811.  
  812.         if ((ret == connector_status_connected) && (radeon_connector->use_digital == true))
  813.                 goto out;
  814.  
  815.         /* find analog encoder */
  816.         if (radeon_connector->dac_load_detect) {
  817.                 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
  818.                         if (connector->encoder_ids[i] == 0)
  819.                                 break;
  820.  
  821.                         obj = drm_mode_object_find(connector->dev,
  822.                                                    connector->encoder_ids[i],
  823.                                                    DRM_MODE_OBJECT_ENCODER);
  824.                         if (!obj)
  825.                                 continue;
  826.  
  827.                         encoder = obj_to_encoder(obj);
  828.  
  829.                         encoder_funcs = encoder->helper_private;
  830.                         if (encoder_funcs->detect) {
  831.                                 if (ret != connector_status_connected) {
  832.                                 ret = encoder_funcs->detect(encoder, connector);
  833.                                 if (ret == connector_status_connected) {
  834.                                                 radeon_connector->use_digital = false;
  835.                                         }
  836.                                 }
  837.                                         break;
  838.                                 }
  839.                         }
  840.                 }
  841.  
  842.         if ((ret == connector_status_connected) && (radeon_connector->use_digital == false) &&
  843.             encoder) {
  844.                 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
  845.         }
  846.  
  847. out:
  848.         /* updated in get modes as well since we need to know if it's analog or digital */
  849.         radeon_connector_update_scratch_regs(connector, ret);
  850.         return ret;
  851. }
  852.  
  853. /* okay need to be smart in here about which encoder to pick */
  854. struct drm_encoder *radeon_dvi_encoder(struct drm_connector *connector)
  855. {
  856.         int enc_id = connector->encoder_ids[0];
  857.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  858.         struct drm_mode_object *obj;
  859.         struct drm_encoder *encoder;
  860.         int i;
  861.         for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
  862.                 if (connector->encoder_ids[i] == 0)
  863.                         break;
  864.  
  865.                 obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
  866.                 if (!obj)
  867.                         continue;
  868.  
  869.                 encoder = obj_to_encoder(obj);
  870.  
  871.                 if (radeon_connector->use_digital == true) {
  872.                         if (encoder->encoder_type == DRM_MODE_ENCODER_TMDS)
  873.                                 return encoder;
  874.                 } else {
  875.                         if (encoder->encoder_type == DRM_MODE_ENCODER_DAC ||
  876.                             encoder->encoder_type == DRM_MODE_ENCODER_TVDAC)
  877.                                 return encoder;
  878.                 }
  879.         }
  880.  
  881.         /* see if we have a default encoder  TODO */
  882.  
  883.         /* then check use digitial */
  884.         /* pick the first one */
  885.         if (enc_id) {
  886.                 obj = drm_mode_object_find(connector->dev, enc_id, DRM_MODE_OBJECT_ENCODER);
  887.                 if (!obj)
  888.                         return NULL;
  889.                 encoder = obj_to_encoder(obj);
  890.                 return encoder;
  891.         }
  892.         return NULL;
  893. }
  894.  
  895. static void radeon_dvi_force(struct drm_connector *connector)
  896. {
  897.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  898.         if (connector->force == DRM_FORCE_ON)
  899.                 radeon_connector->use_digital = false;
  900.         if (connector->force == DRM_FORCE_ON_DIGITAL)
  901.                 radeon_connector->use_digital = true;
  902. }
  903.  
  904. static int radeon_dvi_mode_valid(struct drm_connector *connector,
  905.                                   struct drm_display_mode *mode)
  906. {
  907.         struct drm_device *dev = connector->dev;
  908.         struct radeon_device *rdev = dev->dev_private;
  909.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  910.  
  911.         /* XXX check mode bandwidth */
  912.  
  913.         /* clocks over 135 MHz have heat issues with DVI on RV100 */
  914.         if (radeon_connector->use_digital &&
  915.             (rdev->family == CHIP_RV100) &&
  916.             (mode->clock > 135000))
  917.                 return MODE_CLOCK_HIGH;
  918.  
  919.         if (radeon_connector->use_digital && (mode->clock > 165000)) {
  920.                 if ((radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_I) ||
  921.                     (radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_D) ||
  922.                     (radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_HDMI_TYPE_B))
  923.                         return MODE_OK;
  924.                 else
  925.                         return MODE_CLOCK_HIGH;
  926.         }
  927.         return MODE_OK;
  928. }
  929.  
  930. struct drm_connector_helper_funcs radeon_dvi_connector_helper_funcs = {
  931.         .get_modes = radeon_dvi_get_modes,
  932.         .mode_valid = radeon_dvi_mode_valid,
  933.         .best_encoder = radeon_dvi_encoder,
  934. };
  935.  
  936. struct drm_connector_funcs radeon_dvi_connector_funcs = {
  937.         .dpms = drm_helper_connector_dpms,
  938.         .detect = radeon_dvi_detect,
  939.         .fill_modes = drm_helper_probe_single_connector_modes,
  940.         .set_property = radeon_connector_set_property,
  941.         .destroy = radeon_connector_destroy,
  942.         .force = radeon_dvi_force,
  943. };
  944.  
  945. static void radeon_dp_connector_destroy(struct drm_connector *connector)
  946. {
  947.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  948.         struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
  949.  
  950.         if (radeon_connector->ddc_bus)
  951.                 radeon_i2c_destroy(radeon_connector->ddc_bus);
  952.         if (radeon_connector->edid)
  953.                 kfree(radeon_connector->edid);
  954.         if (radeon_dig_connector->dp_i2c_bus)
  955.                 radeon_i2c_destroy(radeon_dig_connector->dp_i2c_bus);
  956.         kfree(radeon_connector->con_priv);
  957.         drm_sysfs_connector_remove(connector);
  958.         drm_connector_cleanup(connector);
  959.         kfree(connector);
  960. }
  961.  
  962. static int radeon_dp_get_modes(struct drm_connector *connector)
  963. {
  964.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  965.         int ret;
  966.  
  967.         ret = radeon_ddc_get_modes(radeon_connector);
  968.         return ret;
  969. }
  970.  
  971. static enum drm_connector_status radeon_dp_detect(struct drm_connector *connector)
  972. {
  973.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  974.         enum drm_connector_status ret = connector_status_disconnected;
  975.         struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
  976.         u8 sink_type;
  977.  
  978.         if (radeon_connector->edid) {
  979.                 kfree(radeon_connector->edid);
  980.                 radeon_connector->edid = NULL;
  981.         }
  982.  
  983.         sink_type = radeon_dp_getsinktype(radeon_connector);
  984.         if ((sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) ||
  985.             (sink_type == CONNECTOR_OBJECT_ID_eDP)) {
  986.                 if (radeon_dp_getdpcd(radeon_connector)) {
  987.                         radeon_dig_connector->dp_sink_type = sink_type;
  988.                         ret = connector_status_connected;
  989.                 }
  990.         } else {
  991.                 radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
  992.                 if (radeon_ddc_probe(radeon_connector)) {
  993.                         radeon_dig_connector->dp_sink_type = sink_type;
  994.                         ret = connector_status_connected;
  995.                 }
  996.                 radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
  997.         }
  998.  
  999.         return ret;
  1000. }
  1001.  
  1002. static int radeon_dp_mode_valid(struct drm_connector *connector,
  1003.                                   struct drm_display_mode *mode)
  1004. {
  1005.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  1006.         struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
  1007.  
  1008.         /* XXX check mode bandwidth */
  1009.  
  1010.         if ((radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) ||
  1011.             (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_eDP))
  1012.                 return radeon_dp_mode_valid_helper(radeon_connector, mode);
  1013.         else
  1014.                 return MODE_OK;
  1015. }
  1016.  
  1017. struct drm_connector_helper_funcs radeon_dp_connector_helper_funcs = {
  1018.         .get_modes = radeon_dp_get_modes,
  1019.         .mode_valid = radeon_dp_mode_valid,
  1020.         .best_encoder = radeon_dvi_encoder,
  1021. };
  1022.  
  1023. struct drm_connector_funcs radeon_dp_connector_funcs = {
  1024.         .dpms = drm_helper_connector_dpms,
  1025.         .detect = radeon_dp_detect,
  1026.         .fill_modes = drm_helper_probe_single_connector_modes,
  1027.         .set_property = radeon_connector_set_property,
  1028.         .destroy = radeon_dp_connector_destroy,
  1029.         .force = radeon_dvi_force,
  1030. };
  1031.  
  1032. void
  1033. radeon_add_atom_connector(struct drm_device *dev,
  1034.                           uint32_t connector_id,
  1035.                           uint32_t supported_device,
  1036.                           int connector_type,
  1037.                           struct radeon_i2c_bus_rec *i2c_bus,
  1038.                           bool linkb,
  1039.                           uint32_t igp_lane_info,
  1040.                           uint16_t connector_object_id,
  1041.                           struct radeon_hpd *hpd)
  1042. {
  1043.         struct radeon_device *rdev = dev->dev_private;
  1044.         struct drm_connector *connector;
  1045.         struct radeon_connector *radeon_connector;
  1046.         struct radeon_connector_atom_dig *radeon_dig_connector;
  1047.         uint32_t subpixel_order = SubPixelNone;
  1048.         bool shared_ddc = false;
  1049.         int ret;
  1050.  
  1051.         /* fixme - tv/cv/din */
  1052.         if (connector_type == DRM_MODE_CONNECTOR_Unknown)
  1053.                 return;
  1054.  
  1055.         /* see if we already added it */
  1056.         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
  1057.                 radeon_connector = to_radeon_connector(connector);
  1058.                 if (radeon_connector->connector_id == connector_id) {
  1059.                         radeon_connector->devices |= supported_device;
  1060.                         return;
  1061.                 }
  1062.                 if (radeon_connector->ddc_bus && i2c_bus->valid) {
  1063.                         if (radeon_connector->ddc_bus->rec.i2c_id == i2c_bus->i2c_id) {
  1064.                                 radeon_connector->shared_ddc = true;
  1065.                                 shared_ddc = true;
  1066.                         }
  1067.                 }
  1068.         }
  1069.  
  1070.         radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
  1071.         if (!radeon_connector)
  1072.                 return;
  1073.  
  1074.         connector = &radeon_connector->base;
  1075.  
  1076.         radeon_connector->connector_id = connector_id;
  1077.         radeon_connector->devices = supported_device;
  1078.         radeon_connector->shared_ddc = shared_ddc;
  1079.         radeon_connector->connector_object_id = connector_object_id;
  1080.         radeon_connector->hpd = *hpd;
  1081.         switch (connector_type) {
  1082.         case DRM_MODE_CONNECTOR_VGA:
  1083.                 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
  1084.                 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
  1085.                 if (ret)
  1086.                         goto failed;
  1087.                 if (i2c_bus->valid) {
  1088.                         radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "VGA");
  1089.                         if (!radeon_connector->ddc_bus)
  1090.                                 goto failed;
  1091.                 }
  1092.                 radeon_connector->dac_load_detect = true;
  1093.                 drm_connector_attach_property(&radeon_connector->base,
  1094.                                               rdev->mode_info.load_detect_property,
  1095.                                               1);
  1096.                 break;
  1097.         case DRM_MODE_CONNECTOR_DVIA:
  1098.                 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
  1099.                 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
  1100.                 if (ret)
  1101.                         goto failed;
  1102.                 if (i2c_bus->valid) {
  1103.                         radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
  1104.                         if (!radeon_connector->ddc_bus)
  1105.                                 goto failed;
  1106.                 }
  1107.                 radeon_connector->dac_load_detect = true;
  1108.                 drm_connector_attach_property(&radeon_connector->base,
  1109.                                               rdev->mode_info.load_detect_property,
  1110.                                               1);
  1111.                 break;
  1112.         case DRM_MODE_CONNECTOR_DVII:
  1113.         case DRM_MODE_CONNECTOR_DVID:
  1114.                 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
  1115.                 if (!radeon_dig_connector)
  1116.                         goto failed;
  1117.                 radeon_dig_connector->linkb = linkb;
  1118.                 radeon_dig_connector->igp_lane_info = igp_lane_info;
  1119.                 radeon_connector->con_priv = radeon_dig_connector;
  1120.                 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
  1121.                 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
  1122.                 if (ret)
  1123.                         goto failed;
  1124.                 if (i2c_bus->valid) {
  1125.                         radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
  1126.                         if (!radeon_connector->ddc_bus)
  1127.                                 goto failed;
  1128.                 }
  1129.                 subpixel_order = SubPixelHorizontalRGB;
  1130.                 drm_connector_attach_property(&radeon_connector->base,
  1131.                                               rdev->mode_info.coherent_mode_property,
  1132.                                               1);
  1133.                 if (connector_type == DRM_MODE_CONNECTOR_DVII) {
  1134.                 radeon_connector->dac_load_detect = true;
  1135.                 drm_connector_attach_property(&radeon_connector->base,
  1136.                                               rdev->mode_info.load_detect_property,
  1137.                                               1);
  1138.                 }
  1139.                 break;
  1140.         case DRM_MODE_CONNECTOR_HDMIA:
  1141.         case DRM_MODE_CONNECTOR_HDMIB:
  1142.                 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
  1143.                 if (!radeon_dig_connector)
  1144.                         goto failed;
  1145.                 radeon_dig_connector->linkb = linkb;
  1146.                 radeon_dig_connector->igp_lane_info = igp_lane_info;
  1147.                 radeon_connector->con_priv = radeon_dig_connector;
  1148.                 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
  1149.                 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
  1150.                 if (ret)
  1151.                         goto failed;
  1152.                 if (i2c_bus->valid) {
  1153.                         radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "HDMI");
  1154.                         if (!radeon_connector->ddc_bus)
  1155.                                 goto failed;
  1156.                 }
  1157.                 drm_connector_attach_property(&radeon_connector->base,
  1158.                                               rdev->mode_info.coherent_mode_property,
  1159.                                               1);
  1160.                 subpixel_order = SubPixelHorizontalRGB;
  1161.                 break;
  1162.         case DRM_MODE_CONNECTOR_DisplayPort:
  1163.         case DRM_MODE_CONNECTOR_eDP:
  1164.                 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
  1165.                 if (!radeon_dig_connector)
  1166.                         goto failed;
  1167.                 radeon_dig_connector->linkb = linkb;
  1168.                 radeon_dig_connector->igp_lane_info = igp_lane_info;
  1169.                 radeon_connector->con_priv = radeon_dig_connector;
  1170.                 drm_connector_init(dev, &radeon_connector->base, &radeon_dp_connector_funcs, connector_type);
  1171.                 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dp_connector_helper_funcs);
  1172.                 if (ret)
  1173.                         goto failed;
  1174.                 if (i2c_bus->valid) {
  1175.                         /* add DP i2c bus */
  1176.                         if (connector_type == DRM_MODE_CONNECTOR_eDP)
  1177.                                 radeon_dig_connector->dp_i2c_bus = radeon_i2c_create_dp(dev, i2c_bus, "eDP-auxch");
  1178.                         else
  1179.                         radeon_dig_connector->dp_i2c_bus = radeon_i2c_create_dp(dev, i2c_bus, "DP-auxch");
  1180.                         if (!radeon_dig_connector->dp_i2c_bus)
  1181.                                 goto failed;
  1182.                         if (connector_type == DRM_MODE_CONNECTOR_eDP)
  1183.                                 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "eDP");
  1184.                         else
  1185.                         radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DP");
  1186.                         if (!radeon_connector->ddc_bus)
  1187.                                 goto failed;
  1188.                 }
  1189.                 subpixel_order = SubPixelHorizontalRGB;
  1190.                 drm_connector_attach_property(&radeon_connector->base,
  1191.                                               rdev->mode_info.coherent_mode_property,
  1192.                                               1);
  1193.                 break;
  1194.         case DRM_MODE_CONNECTOR_SVIDEO:
  1195.         case DRM_MODE_CONNECTOR_Composite:
  1196.         case DRM_MODE_CONNECTOR_9PinDIN:
  1197.                 if (radeon_tv == 1) {
  1198.                         drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
  1199.                         ret = drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
  1200.                         if (ret)
  1201.                                 goto failed;
  1202.                         radeon_connector->dac_load_detect = true;
  1203.                 drm_connector_attach_property(&radeon_connector->base,
  1204.                                               rdev->mode_info.load_detect_property,
  1205.                                               1);
  1206.                         drm_connector_attach_property(&radeon_connector->base,
  1207.                                                       rdev->mode_info.tv_std_property,
  1208.                                                       radeon_atombios_get_tv_info(rdev));
  1209.                 }
  1210.                 break;
  1211.         case DRM_MODE_CONNECTOR_LVDS:
  1212.                 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
  1213.                 if (!radeon_dig_connector)
  1214.                         goto failed;
  1215.                 radeon_dig_connector->linkb = linkb;
  1216.                 radeon_dig_connector->igp_lane_info = igp_lane_info;
  1217.                 radeon_connector->con_priv = radeon_dig_connector;
  1218.                 drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
  1219.                 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
  1220.                 if (ret)
  1221.                         goto failed;
  1222.                 if (i2c_bus->valid) {
  1223.                         radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "LVDS");
  1224.                         if (!radeon_connector->ddc_bus)
  1225.                                 goto failed;
  1226.                 }
  1227.                 drm_connector_attach_property(&radeon_connector->base,
  1228.                                               dev->mode_config.scaling_mode_property,
  1229.                                               DRM_MODE_SCALE_FULLSCREEN);
  1230.                 subpixel_order = SubPixelHorizontalRGB;
  1231.                 break;
  1232.         }
  1233.  
  1234.         connector->display_info.subpixel_order = subpixel_order;
  1235.         drm_sysfs_connector_add(connector);
  1236.         return;
  1237.  
  1238. failed:
  1239.         if (radeon_connector->ddc_bus)
  1240.                 radeon_i2c_destroy(radeon_connector->ddc_bus);
  1241.         drm_connector_cleanup(connector);
  1242.         kfree(connector);
  1243. }
  1244.  
  1245. void
  1246. radeon_add_legacy_connector(struct drm_device *dev,
  1247.                             uint32_t connector_id,
  1248.                             uint32_t supported_device,
  1249.                             int connector_type,
  1250.                             struct radeon_i2c_bus_rec *i2c_bus,
  1251.                             uint16_t connector_object_id,
  1252.                             struct radeon_hpd *hpd)
  1253. {
  1254.         struct radeon_device *rdev = dev->dev_private;
  1255.         struct drm_connector *connector;
  1256.         struct radeon_connector *radeon_connector;
  1257.         uint32_t subpixel_order = SubPixelNone;
  1258.         int ret;
  1259.  
  1260.         /* fixme - tv/cv/din */
  1261.         if (connector_type == DRM_MODE_CONNECTOR_Unknown)
  1262.                 return;
  1263.  
  1264.         /* see if we already added it */
  1265.         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
  1266.                 radeon_connector = to_radeon_connector(connector);
  1267.                 if (radeon_connector->connector_id == connector_id) {
  1268.                         radeon_connector->devices |= supported_device;
  1269.                         return;
  1270.                 }
  1271.         }
  1272.  
  1273.         radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
  1274.         if (!radeon_connector)
  1275.                 return;
  1276.  
  1277.         connector = &radeon_connector->base;
  1278.  
  1279.         radeon_connector->connector_id = connector_id;
  1280.         radeon_connector->devices = supported_device;
  1281.         radeon_connector->connector_object_id = connector_object_id;
  1282.         radeon_connector->hpd = *hpd;
  1283.         switch (connector_type) {
  1284.         case DRM_MODE_CONNECTOR_VGA:
  1285.                 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
  1286.                 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
  1287.                 if (ret)
  1288.                         goto failed;
  1289.                 if (i2c_bus->valid) {
  1290.                         radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "VGA");
  1291.                         if (!radeon_connector->ddc_bus)
  1292.                                 goto failed;
  1293.                 }
  1294.                 radeon_connector->dac_load_detect = true;
  1295.                 drm_connector_attach_property(&radeon_connector->base,
  1296.                                               rdev->mode_info.load_detect_property,
  1297.                                               1);
  1298.                 break;
  1299.         case DRM_MODE_CONNECTOR_DVIA:
  1300.                 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
  1301.                 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
  1302.                 if (ret)
  1303.                         goto failed;
  1304.                 if (i2c_bus->valid) {
  1305.                         radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
  1306.                         if (!radeon_connector->ddc_bus)
  1307.                                 goto failed;
  1308.                 }
  1309.                 radeon_connector->dac_load_detect = true;
  1310.                 drm_connector_attach_property(&radeon_connector->base,
  1311.                                               rdev->mode_info.load_detect_property,
  1312.                                               1);
  1313.                 break;
  1314.         case DRM_MODE_CONNECTOR_DVII:
  1315.         case DRM_MODE_CONNECTOR_DVID:
  1316.                 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
  1317.                 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
  1318.                 if (ret)
  1319.                         goto failed;
  1320.                 if (i2c_bus->valid) {
  1321.                         radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
  1322.                         if (!radeon_connector->ddc_bus)
  1323.                                 goto failed;
  1324.                         radeon_connector->dac_load_detect = true;
  1325.                         drm_connector_attach_property(&radeon_connector->base,
  1326.                                                       rdev->mode_info.load_detect_property,
  1327.                                                       1);
  1328.                 }
  1329.                 subpixel_order = SubPixelHorizontalRGB;
  1330.                 break;
  1331.         case DRM_MODE_CONNECTOR_SVIDEO:
  1332.         case DRM_MODE_CONNECTOR_Composite:
  1333.         case DRM_MODE_CONNECTOR_9PinDIN:
  1334.                 if (radeon_tv == 1) {
  1335.                         drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
  1336.                         ret = drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
  1337.                         if (ret)
  1338.                                 goto failed;
  1339.                         radeon_connector->dac_load_detect = true;
  1340.                         /* RS400,RC410,RS480 chipset seems to report a lot
  1341.                          * of false positive on load detect, we haven't yet
  1342.                          * found a way to make load detect reliable on those
  1343.                          * chipset, thus just disable it for TV.
  1344.                          */
  1345.                         if (rdev->family == CHIP_RS400 || rdev->family == CHIP_RS480)
  1346.                                 radeon_connector->dac_load_detect = false;
  1347.                         drm_connector_attach_property(&radeon_connector->base,
  1348.                                                       rdev->mode_info.load_detect_property,
  1349.                                                       radeon_connector->dac_load_detect);
  1350.                         drm_connector_attach_property(&radeon_connector->base,
  1351.                                                       rdev->mode_info.tv_std_property,
  1352.                                                       radeon_combios_get_tv_info(rdev));
  1353.                 }
  1354.                 break;
  1355.         case DRM_MODE_CONNECTOR_LVDS:
  1356.                 drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
  1357.                 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
  1358.                 if (ret)
  1359.                         goto failed;
  1360.                 if (i2c_bus->valid) {
  1361.                         radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "LVDS");
  1362.                         if (!radeon_connector->ddc_bus)
  1363.                                 goto failed;
  1364.                 }
  1365.                 drm_connector_attach_property(&radeon_connector->base,
  1366.                                               dev->mode_config.scaling_mode_property,
  1367.                                               DRM_MODE_SCALE_FULLSCREEN);
  1368.                 subpixel_order = SubPixelHorizontalRGB;
  1369.                 break;
  1370.         }
  1371.  
  1372.         connector->display_info.subpixel_order = subpixel_order;
  1373.         drm_sysfs_connector_add(connector);
  1374.         return;
  1375.  
  1376. failed:
  1377.         if (radeon_connector->ddc_bus)
  1378.                 radeon_i2c_destroy(radeon_connector->ddc_bus);
  1379.         drm_connector_cleanup(connector);
  1380.         kfree(connector);
  1381. }
  1382.