Subversion Repositories Kolibri OS

Rev

Rev 1179 | Rev 1233 | 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. static void radeon_property_change_mode(struct drm_encoder *encoder)
  44. {
  45.         struct drm_crtc *crtc = encoder->crtc;
  46.  
  47.         if (crtc && crtc->enabled) {
  48.                 drm_crtc_helper_set_mode(crtc, &crtc->mode,
  49.                                          crtc->x, crtc->y, crtc->fb);
  50.         }
  51. }
  52. static void
  53. radeon_connector_update_scratch_regs(struct drm_connector *connector, enum drm_connector_status status)
  54. {
  55.         struct drm_device *dev = connector->dev;
  56.         struct radeon_device *rdev = dev->dev_private;
  57.         struct drm_encoder *best_encoder = NULL;
  58.         struct drm_encoder *encoder = NULL;
  59.         struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
  60.         struct drm_mode_object *obj;
  61.         bool connected;
  62.         int i;
  63.  
  64.         best_encoder = connector_funcs->best_encoder(connector);
  65.  
  66.         for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
  67.                 if (connector->encoder_ids[i] == 0)
  68.                         break;
  69.  
  70.                 obj = drm_mode_object_find(connector->dev,
  71.                                            connector->encoder_ids[i],
  72.                                            DRM_MODE_OBJECT_ENCODER);
  73.                 if (!obj)
  74.                         continue;
  75.  
  76.                 encoder = obj_to_encoder(obj);
  77.  
  78.                 if ((encoder == best_encoder) && (status == connector_status_connected))
  79.                         connected = true;
  80.                 else
  81.                         connected = false;
  82.  
  83.                 if (rdev->is_atom_bios)
  84.                         radeon_atombios_connected_scratch_regs(connector, encoder, connected);
  85.                 else
  86.                         radeon_combios_connected_scratch_regs(connector, encoder, connected);
  87.  
  88.         }
  89. }
  90.  
  91. struct drm_encoder *radeon_find_encoder(struct drm_connector *connector, int encoder_type)
  92. {
  93.         struct drm_mode_object *obj;
  94.         struct drm_encoder *encoder;
  95.         int i;
  96.  
  97.         for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
  98.                 if (connector->encoder_ids[i] == 0)
  99.                         break;
  100.  
  101.                 obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
  102.                 if (!obj)
  103.                         continue;
  104.  
  105.                 encoder = obj_to_encoder(obj);
  106.                 if (encoder->encoder_type == encoder_type)
  107.                         return encoder;
  108.         }
  109.         return NULL;
  110. }
  111.  
  112. struct drm_encoder *radeon_best_single_encoder(struct drm_connector *connector)
  113. {
  114.         int enc_id = connector->encoder_ids[0];
  115.         struct drm_mode_object *obj;
  116.         struct drm_encoder *encoder;
  117.  
  118.         /* pick the encoder ids */
  119.         if (enc_id) {
  120.                 obj = drm_mode_object_find(connector->dev, enc_id, DRM_MODE_OBJECT_ENCODER);
  121.                 if (!obj)
  122.                         return NULL;
  123.                 encoder = obj_to_encoder(obj);
  124.                 return encoder;
  125.         }
  126.         return NULL;
  127. }
  128.  
  129. /*
  130.  * radeon_connector_analog_encoder_conflict_solve
  131.  * - search for other connectors sharing this encoder
  132.  *   if priority is true, then set them disconnected if this is connected
  133.  *   if priority is false, set us disconnected if they are connected
  134.  */
  135. static enum drm_connector_status
  136. radeon_connector_analog_encoder_conflict_solve(struct drm_connector *connector,
  137.                                                struct drm_encoder *encoder,
  138.                                                enum drm_connector_status current_status,
  139.                                                bool priority)
  140. {
  141.         struct drm_device *dev = connector->dev;
  142.         struct drm_connector *conflict;
  143.         int i;
  144.  
  145.         list_for_each_entry(conflict, &dev->mode_config.connector_list, head) {
  146.                 if (conflict == connector)
  147.                         continue;
  148.  
  149.                 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
  150.                         if (conflict->encoder_ids[i] == 0)
  151.                                 break;
  152.  
  153.                         /* if the IDs match */
  154.                         if (conflict->encoder_ids[i] == encoder->base.id) {
  155.                                 if (conflict->status != connector_status_connected)
  156.                                         continue;
  157.  
  158.                                 if (priority == true) {
  159.                                         DRM_INFO("1: conflicting encoders switching off %s\n", drm_get_connector_name(conflict));
  160.                                         DRM_INFO("in favor of %s\n", drm_get_connector_name(connector));
  161.                                         conflict->status = connector_status_disconnected;
  162.                                         radeon_connector_update_scratch_regs(conflict, connector_status_disconnected);
  163.                                 } else {
  164.                                         DRM_INFO("2: conflicting encoders switching off %s\n", drm_get_connector_name(connector));
  165.                                         DRM_INFO("in favor of %s\n", drm_get_connector_name(conflict));
  166.                                         current_status = connector_status_disconnected;
  167.                                 }
  168.                                 break;
  169.                         }
  170.                 }
  171.         }
  172.         return current_status;
  173.  
  174. }
  175.  
  176. static struct drm_display_mode *radeon_fp_native_mode(struct drm_encoder *encoder)
  177. {
  178.         struct drm_device *dev = encoder->dev;
  179.         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
  180.         struct drm_display_mode *mode = NULL;
  181.         struct radeon_native_mode *native_mode = &radeon_encoder->native_mode;
  182.  
  183.         if (native_mode->panel_xres != 0 &&
  184.             native_mode->panel_yres != 0 &&
  185.             native_mode->dotclock != 0) {
  186.                 mode = drm_mode_create(dev);
  187.  
  188.                 mode->hdisplay = native_mode->panel_xres;
  189.                 mode->vdisplay = native_mode->panel_yres;
  190.  
  191.                 mode->htotal = mode->hdisplay + native_mode->hblank;
  192.                 mode->hsync_start = mode->hdisplay + native_mode->hoverplus;
  193.                 mode->hsync_end = mode->hsync_start + native_mode->hsync_width;
  194.                 mode->vtotal = mode->vdisplay + native_mode->vblank;
  195.                 mode->vsync_start = mode->vdisplay + native_mode->voverplus;
  196.                 mode->vsync_end = mode->vsync_start + native_mode->vsync_width;
  197.                 mode->clock = native_mode->dotclock;
  198.                 mode->flags = 0;
  199.  
  200.                 mode->type = DRM_MODE_TYPE_PREFERRED | DRM_MODE_TYPE_DRIVER;
  201.                 drm_mode_set_name(mode);
  202.  
  203.                 DRM_DEBUG("Adding native panel mode %s\n", mode->name);
  204.         }
  205.         return mode;
  206. }
  207.  
  208. static void radeon_add_common_modes(struct drm_encoder *encoder, struct drm_connector *connector)
  209. {
  210.         struct drm_device *dev = encoder->dev;
  211.         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
  212.         struct drm_display_mode *mode = NULL;
  213.         struct radeon_native_mode *native_mode = &radeon_encoder->native_mode;
  214.         int i;
  215.         struct mode_size {
  216.                 int w;
  217.                 int h;
  218.         } common_modes[17] = {
  219.                 { 640,  480},
  220.                 { 720,  480},
  221.                 { 800,  600},
  222.                 { 848,  480},
  223.                 {1024,  768},
  224.                 {1152,  768},
  225.                 {1280,  720},
  226.                 {1280,  800},
  227.                 {1280,  854},
  228.                 {1280,  960},
  229.                 {1280, 1024},
  230.                 {1440,  900},
  231.                 {1400, 1050},
  232.                 {1680, 1050},
  233.                 {1600, 1200},
  234.                 {1920, 1080},
  235.                 {1920, 1200}
  236.         };
  237.  
  238.         for (i = 0; i < 17; i++) {
  239.                 if (radeon_encoder->devices & (ATOM_DEVICE_LCD_SUPPORT)) {
  240.                         if (common_modes[i].w > native_mode->panel_xres ||
  241.                             common_modes[i].h > native_mode->panel_yres ||
  242.                             (common_modes[i].w == native_mode->panel_xres &&
  243.                              common_modes[i].h == native_mode->panel_yres))
  244.                                 continue;
  245.                 }
  246.                 if (common_modes[i].w < 320 || common_modes[i].h < 200)
  247.                         continue;
  248.  
  249.                 mode = drm_cvt_mode(dev, common_modes[i].w, common_modes[i].h, 60, false, false, false);
  250.                 drm_mode_probed_add(connector, mode);
  251.         }
  252. }
  253.  
  254. int radeon_connector_set_property(struct drm_connector *connector, struct drm_property *property,
  255.                                   uint64_t val)
  256. {
  257.         struct drm_device *dev = connector->dev;
  258.         struct radeon_device *rdev = dev->dev_private;
  259.         struct drm_encoder *encoder;
  260.         struct radeon_encoder *radeon_encoder;
  261.  
  262.         if (property == rdev->mode_info.coherent_mode_property) {
  263.                 struct radeon_encoder_atom_dig *dig;
  264.  
  265.                 /* need to find digital encoder on connector */
  266.                 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
  267.                 if (!encoder)
  268.                         return 0;
  269.  
  270.                 radeon_encoder = to_radeon_encoder(encoder);
  271.  
  272.                 if (!radeon_encoder->enc_priv)
  273.                         return 0;
  274.  
  275.                 dig = radeon_encoder->enc_priv;
  276.                 dig->coherent_mode = val ? true : false;
  277.                 radeon_property_change_mode(&radeon_encoder->base);
  278.         }
  279.  
  280.         if (property == rdev->mode_info.tv_std_property) {
  281.                 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TVDAC);
  282.                 if (!encoder) {
  283.                         encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_DAC);
  284.                 }
  285.  
  286.                 if (!encoder)
  287.                         return 0;
  288.  
  289.                 radeon_encoder = to_radeon_encoder(encoder);
  290.                 if (!radeon_encoder->enc_priv)
  291.                         return 0;
  292.                 if (rdev->is_atom_bios) {
  293.                         struct radeon_encoder_atom_dac *dac_int;
  294.                         dac_int = radeon_encoder->enc_priv;
  295.                         dac_int->tv_std = val;
  296.                 } else {
  297.                         struct radeon_encoder_tv_dac *dac_int;
  298.                         dac_int = radeon_encoder->enc_priv;
  299.                         dac_int->tv_std = val;
  300.                 }
  301.                 radeon_property_change_mode(&radeon_encoder->base);
  302.         }
  303.  
  304.         if (property == rdev->mode_info.load_detect_property) {
  305.                 struct radeon_connector *radeon_connector =
  306.                         to_radeon_connector(connector);
  307.  
  308.                 if (val == 0)
  309.                         radeon_connector->dac_load_detect = false;
  310.                 else
  311.                         radeon_connector->dac_load_detect = true;
  312.         }
  313.  
  314.         if (property == rdev->mode_info.tmds_pll_property) {
  315.                 struct radeon_encoder_int_tmds *tmds = NULL;
  316.                 bool ret = false;
  317.                 /* need to find digital encoder on connector */
  318.                 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
  319.                 if (!encoder)
  320.                         return 0;
  321.  
  322.                 radeon_encoder = to_radeon_encoder(encoder);
  323.  
  324.                 tmds = radeon_encoder->enc_priv;
  325.                 if (!tmds)
  326.                         return 0;
  327.  
  328.                 if (val == 0) {
  329.                         if (rdev->is_atom_bios)
  330.                                 ret = radeon_atombios_get_tmds_info(radeon_encoder, tmds);
  331.                         else
  332.                                 ret = radeon_legacy_get_tmds_info_from_combios(radeon_encoder, tmds);
  333.                 }
  334.                 if (val == 1 || ret == false) {
  335.                         radeon_legacy_get_tmds_info_from_table(radeon_encoder, tmds);
  336.                 }
  337.                 radeon_property_change_mode(&radeon_encoder->base);
  338.         }
  339.  
  340.         return 0;
  341. }
  342.  
  343. static void radeon_fixup_lvds_native_mode(struct drm_encoder *encoder,
  344.                                           struct drm_connector *connector)
  345. {
  346.         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
  347.         struct radeon_native_mode *native_mode = &radeon_encoder->native_mode;
  348.  
  349.         /* Try to get native mode details from EDID if necessary */
  350.         if (!native_mode->dotclock) {
  351.                 struct drm_display_mode *t, *mode;
  352.  
  353.                 list_for_each_entry_safe(mode, t, &connector->probed_modes, head) {
  354.                         if (mode->hdisplay == native_mode->panel_xres &&
  355.                             mode->vdisplay == native_mode->panel_yres) {
  356.                                 native_mode->hblank = mode->htotal - mode->hdisplay;
  357.                                 native_mode->hoverplus = mode->hsync_start - mode->hdisplay;
  358.                                 native_mode->hsync_width = mode->hsync_end - mode->hsync_start;
  359.                                 native_mode->vblank = mode->vtotal - mode->vdisplay;
  360.                                 native_mode->voverplus = mode->vsync_start - mode->vdisplay;
  361.                                 native_mode->vsync_width = mode->vsync_end - mode->vsync_start;
  362.                                 native_mode->dotclock = mode->clock;
  363.                                 DRM_INFO("Determined LVDS native mode details from EDID\n");
  364.                                 break;
  365.                         }
  366.                 }
  367.         }
  368.         if (!native_mode->dotclock) {
  369.                 DRM_INFO("No LVDS native mode details, disabling RMX\n");
  370.                 radeon_encoder->rmx_type = RMX_OFF;
  371.         }
  372. }
  373.  
  374. static int radeon_lvds_get_modes(struct drm_connector *connector)
  375. {
  376.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  377.         struct drm_encoder *encoder;
  378.         int ret = 0;
  379.         struct drm_display_mode *mode;
  380.  
  381.         if (radeon_connector->ddc_bus) {
  382.                 ret = radeon_ddc_get_modes(radeon_connector);
  383.                 if (ret > 0) {
  384.                         encoder = radeon_best_single_encoder(connector);
  385.                         if (encoder) {
  386.                                 radeon_fixup_lvds_native_mode(encoder, connector);
  387.                                 /* add scaled modes */
  388.                                 radeon_add_common_modes(encoder, connector);
  389.                         }
  390.                         return ret;
  391.                 }
  392.         }
  393.  
  394.         encoder = radeon_best_single_encoder(connector);
  395.         if (!encoder)
  396.                 return 0;
  397.  
  398.         /* we have no EDID modes */
  399.         mode = radeon_fp_native_mode(encoder);
  400.         if (mode) {
  401.                 ret = 1;
  402.                 drm_mode_probed_add(connector, mode);
  403.                 /* add scaled modes */
  404.                 radeon_add_common_modes(encoder, connector);
  405.         }
  406.  
  407.         return ret;
  408. }
  409.  
  410. static int radeon_lvds_mode_valid(struct drm_connector *connector,
  411.                                   struct drm_display_mode *mode)
  412. {
  413.         return MODE_OK;
  414. }
  415.  
  416. static enum drm_connector_status radeon_lvds_detect(struct drm_connector *connector)
  417. {
  418.         enum drm_connector_status ret = connector_status_connected;
  419.         /* check acpi lid status ??? */
  420.         radeon_connector_update_scratch_regs(connector, ret);
  421.         return ret;
  422. }
  423.  
  424. static void radeon_connector_destroy(struct drm_connector *connector)
  425. {
  426.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  427.  
  428.         if (radeon_connector->ddc_bus)
  429.                 radeon_i2c_destroy(radeon_connector->ddc_bus);
  430.         kfree(radeon_connector->con_priv);
  431.   // drm_sysfs_connector_remove(connector);
  432.         drm_connector_cleanup(connector);
  433.         kfree(connector);
  434. }
  435.  
  436. static int radeon_lvds_set_property(struct drm_connector *connector,
  437.                                     struct drm_property *property,
  438.                                     uint64_t value)
  439. {
  440.         struct drm_device *dev = connector->dev;
  441.         struct radeon_encoder *radeon_encoder;
  442.         enum radeon_rmx_type rmx_type;
  443.  
  444.         DRM_DEBUG("\n");
  445.         if (property != dev->mode_config.scaling_mode_property)
  446.                 return 0;
  447.  
  448.         if (connector->encoder)
  449.                 radeon_encoder = to_radeon_encoder(connector->encoder);
  450.         else {
  451.                 struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
  452.                 radeon_encoder = to_radeon_encoder(connector_funcs->best_encoder(connector));
  453.         }
  454.  
  455.         switch (value) {
  456.         case DRM_MODE_SCALE_NONE: rmx_type = RMX_OFF; break;
  457.         case DRM_MODE_SCALE_CENTER: rmx_type = RMX_CENTER; break;
  458.         case DRM_MODE_SCALE_ASPECT: rmx_type = RMX_ASPECT; break;
  459.         default:
  460.         case DRM_MODE_SCALE_FULLSCREEN: rmx_type = RMX_FULL; break;
  461.         }
  462.         if (radeon_encoder->rmx_type == rmx_type)
  463.                 return 0;
  464.  
  465.         radeon_encoder->rmx_type = rmx_type;
  466.  
  467.         radeon_property_change_mode(&radeon_encoder->base);
  468.         return 0;
  469. }
  470.  
  471.  
  472. struct drm_connector_helper_funcs radeon_lvds_connector_helper_funcs = {
  473.         .get_modes = radeon_lvds_get_modes,
  474.         .mode_valid = radeon_lvds_mode_valid,
  475.         .best_encoder = radeon_best_single_encoder,
  476. };
  477.  
  478. struct drm_connector_funcs radeon_lvds_connector_funcs = {
  479.         .dpms = drm_helper_connector_dpms,
  480.         .detect = radeon_lvds_detect,
  481.         .fill_modes = drm_helper_probe_single_connector_modes,
  482.         .destroy = radeon_connector_destroy,
  483.         .set_property = radeon_lvds_set_property,
  484. };
  485.  
  486. static int radeon_vga_get_modes(struct drm_connector *connector)
  487. {
  488.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  489.         int ret;
  490.  
  491.         ret = radeon_ddc_get_modes(radeon_connector);
  492.  
  493.         return ret;
  494. }
  495.  
  496. static int radeon_vga_mode_valid(struct drm_connector *connector,
  497.                                   struct drm_display_mode *mode)
  498. {
  499.         return MODE_OK;
  500. }
  501.  
  502. static enum drm_connector_status radeon_vga_detect(struct drm_connector *connector)
  503. {
  504.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  505.         struct drm_encoder *encoder;
  506.         struct drm_encoder_helper_funcs *encoder_funcs;
  507.         bool dret;
  508.         enum drm_connector_status ret = connector_status_disconnected;
  509.  
  510.         encoder = radeon_best_single_encoder(connector);
  511.         if (!encoder)
  512.                 ret = connector_status_disconnected;
  513.  
  514.         radeon_i2c_do_lock(radeon_connector, 1);
  515.         dret = radeon_ddc_probe(radeon_connector);
  516.         radeon_i2c_do_lock(radeon_connector, 0);
  517.         if (dret)
  518.                 ret = connector_status_connected;
  519.         else {
  520.                 if (radeon_connector->dac_load_detect) {
  521.                         encoder_funcs = encoder->helper_private;
  522.                         ret = encoder_funcs->detect(encoder, connector);
  523.                 }
  524.         }
  525.  
  526.         if (ret == connector_status_connected)
  527.                 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
  528.         radeon_connector_update_scratch_regs(connector, ret);
  529.         return ret;
  530. }
  531.  
  532. struct drm_connector_helper_funcs radeon_vga_connector_helper_funcs = {
  533.         .get_modes = radeon_vga_get_modes,
  534.         .mode_valid = radeon_vga_mode_valid,
  535.         .best_encoder = radeon_best_single_encoder,
  536. };
  537.  
  538. struct drm_connector_funcs radeon_vga_connector_funcs = {
  539.         .dpms = drm_helper_connector_dpms,
  540.         .detect = radeon_vga_detect,
  541.         .fill_modes = drm_helper_probe_single_connector_modes,
  542.         .destroy = radeon_connector_destroy,
  543.         .set_property = radeon_connector_set_property,
  544. };
  545.  
  546. static int radeon_tv_get_modes(struct drm_connector *connector)
  547. {
  548.         struct drm_device *dev = connector->dev;
  549.         struct radeon_device *rdev = dev->dev_private;
  550.         struct drm_display_mode *tv_mode;
  551.         struct drm_encoder *encoder;
  552.  
  553.         encoder = radeon_best_single_encoder(connector);
  554.         if (!encoder)
  555.                 return 0;
  556.  
  557.         /* avivo chips can scale any mode */
  558.         if (rdev->family >= CHIP_RS600)
  559.                 /* add scaled modes */
  560.                 radeon_add_common_modes(encoder, connector);
  561.         else {
  562.                 /* only 800x600 is supported right now on pre-avivo chips */
  563.                 tv_mode = drm_cvt_mode(dev, 800, 600, 60, false, false, false);
  564.                 tv_mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
  565.                 drm_mode_probed_add(connector, tv_mode);
  566.         }
  567.         return 1;
  568. }
  569.  
  570. static int radeon_tv_mode_valid(struct drm_connector *connector,
  571.                                 struct drm_display_mode *mode)
  572. {
  573.         return MODE_OK;
  574. }
  575.  
  576. static enum drm_connector_status radeon_tv_detect(struct drm_connector *connector)
  577. {
  578.         struct drm_encoder *encoder;
  579.         struct drm_encoder_helper_funcs *encoder_funcs;
  580.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  581.         enum drm_connector_status ret = connector_status_disconnected;
  582.  
  583.         if (!radeon_connector->dac_load_detect)
  584.                 return ret;
  585.  
  586.         encoder = radeon_best_single_encoder(connector);
  587.         if (!encoder)
  588.                 ret = connector_status_disconnected;
  589.         else {
  590.                 encoder_funcs = encoder->helper_private;
  591.                 ret = encoder_funcs->detect(encoder, connector);
  592.         }
  593.         if (ret == connector_status_connected)
  594.                 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, false);
  595.         radeon_connector_update_scratch_regs(connector, ret);
  596.         return ret;
  597. }
  598.  
  599. struct drm_connector_helper_funcs radeon_tv_connector_helper_funcs = {
  600.         .get_modes = radeon_tv_get_modes,
  601.         .mode_valid = radeon_tv_mode_valid,
  602.         .best_encoder = radeon_best_single_encoder,
  603. };
  604.  
  605. struct drm_connector_funcs radeon_tv_connector_funcs = {
  606.         .dpms = drm_helper_connector_dpms,
  607.         .detect = radeon_tv_detect,
  608.         .fill_modes = drm_helper_probe_single_connector_modes,
  609.         .destroy = radeon_connector_destroy,
  610.         .set_property = radeon_connector_set_property,
  611. };
  612.  
  613. static int radeon_dvi_get_modes(struct drm_connector *connector)
  614. {
  615.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  616.         int ret;
  617.  
  618.         ret = radeon_ddc_get_modes(radeon_connector);
  619.         return ret;
  620. }
  621.  
  622. /*
  623.  * DVI is complicated
  624.  * Do a DDC probe, if DDC probe passes, get the full EDID so
  625.  * we can do analog/digital monitor detection at this point.
  626.  * If the monitor is an analog monitor or we got no DDC,
  627.  * we need to find the DAC encoder object for this connector.
  628.  * If we got no DDC, we do load detection on the DAC encoder object.
  629.  * If we got analog DDC or load detection passes on the DAC encoder
  630.  * we have to check if this analog encoder is shared with anyone else (TV)
  631.  * if its shared we have to set the other connector to disconnected.
  632.  */
  633. static enum drm_connector_status radeon_dvi_detect(struct drm_connector *connector)
  634. {
  635.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  636.         struct drm_encoder *encoder = NULL;
  637.         struct drm_encoder_helper_funcs *encoder_funcs;
  638.         struct drm_mode_object *obj;
  639.         int i;
  640.         enum drm_connector_status ret = connector_status_disconnected;
  641.         bool dret;
  642.  
  643.         radeon_i2c_do_lock(radeon_connector, 1);
  644.         dret = radeon_ddc_probe(radeon_connector);
  645.         radeon_i2c_do_lock(radeon_connector, 0);
  646.         if (dret) {
  647.                 radeon_i2c_do_lock(radeon_connector, 1);
  648.                 radeon_connector->edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
  649.                 radeon_i2c_do_lock(radeon_connector, 0);
  650.  
  651.                 if (!radeon_connector->edid) {
  652.                         DRM_ERROR("DDC responded but not EDID found for %s\n",
  653.                                   drm_get_connector_name(connector));
  654.                 } else {
  655.                         radeon_connector->use_digital = !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
  656.  
  657.                         /* if this isn't a digital monitor
  658.                            then we need to make sure we don't have any
  659.                            TV conflicts */
  660.                 ret = connector_status_connected;
  661.                 }
  662.         }
  663.  
  664.         if ((ret == connector_status_connected) && (radeon_connector->use_digital == true))
  665.                 goto out;
  666.  
  667.         /* find analog encoder */
  668.         if (radeon_connector->dac_load_detect) {
  669.                 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
  670.                         if (connector->encoder_ids[i] == 0)
  671.                                 break;
  672.  
  673.                         obj = drm_mode_object_find(connector->dev,
  674.                                                    connector->encoder_ids[i],
  675.                                                    DRM_MODE_OBJECT_ENCODER);
  676.                         if (!obj)
  677.                                 continue;
  678.  
  679.                         encoder = obj_to_encoder(obj);
  680.  
  681.                         encoder_funcs = encoder->helper_private;
  682.                         if (encoder_funcs->detect) {
  683.                                 if (ret != connector_status_connected) {
  684.                                 ret = encoder_funcs->detect(encoder, connector);
  685.                                 if (ret == connector_status_connected) {
  686.                                                 radeon_connector->use_digital = false;
  687.                                         }
  688.                                 }
  689.                                         break;
  690.                                 }
  691.                         }
  692.                 }
  693.  
  694.         if ((ret == connector_status_connected) && (radeon_connector->use_digital == false) &&
  695.             encoder) {
  696.                 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
  697.         }
  698.  
  699. out:
  700.         /* updated in get modes as well since we need to know if it's analog or digital */
  701.         radeon_connector_update_scratch_regs(connector, ret);
  702.         return ret;
  703. }
  704.  
  705. /* okay need to be smart in here about which encoder to pick */
  706. struct drm_encoder *radeon_dvi_encoder(struct drm_connector *connector)
  707. {
  708.         int enc_id = connector->encoder_ids[0];
  709.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  710.         struct drm_mode_object *obj;
  711.         struct drm_encoder *encoder;
  712.         int i;
  713.         for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
  714.                 if (connector->encoder_ids[i] == 0)
  715.                         break;
  716.  
  717.                 obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
  718.                 if (!obj)
  719.                         continue;
  720.  
  721.                 encoder = obj_to_encoder(obj);
  722.  
  723.                 if (radeon_connector->use_digital == true) {
  724.                         if (encoder->encoder_type == DRM_MODE_ENCODER_TMDS)
  725.                                 return encoder;
  726.                 } else {
  727.                         if (encoder->encoder_type == DRM_MODE_ENCODER_DAC ||
  728.                             encoder->encoder_type == DRM_MODE_ENCODER_TVDAC)
  729.                                 return encoder;
  730.                 }
  731.         }
  732.  
  733.         /* see if we have a default encoder  TODO */
  734.  
  735.         /* then check use digitial */
  736.         /* pick the first one */
  737.         if (enc_id) {
  738.                 obj = drm_mode_object_find(connector->dev, enc_id, DRM_MODE_OBJECT_ENCODER);
  739.                 if (!obj)
  740.                         return NULL;
  741.                 encoder = obj_to_encoder(obj);
  742.                 return encoder;
  743.         }
  744.         return NULL;
  745. }
  746.  
  747. static void radeon_dvi_force(struct drm_connector *connector)
  748. {
  749.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  750.         if (connector->force == DRM_FORCE_ON)
  751.                 radeon_connector->use_digital = false;
  752.         if (connector->force == DRM_FORCE_ON_DIGITAL)
  753.                 radeon_connector->use_digital = true;
  754. }
  755.  
  756. struct drm_connector_helper_funcs radeon_dvi_connector_helper_funcs = {
  757.         .get_modes = radeon_dvi_get_modes,
  758.         .mode_valid = radeon_vga_mode_valid,
  759.         .best_encoder = radeon_dvi_encoder,
  760. };
  761.  
  762. struct drm_connector_funcs radeon_dvi_connector_funcs = {
  763.         .dpms = drm_helper_connector_dpms,
  764.         .detect = radeon_dvi_detect,
  765.         .fill_modes = drm_helper_probe_single_connector_modes,
  766.         .set_property = radeon_connector_set_property,
  767.         .destroy = radeon_connector_destroy,
  768.         .force = radeon_dvi_force,
  769. };
  770.  
  771. void
  772. radeon_add_atom_connector(struct drm_device *dev,
  773.                           uint32_t connector_id,
  774.                           uint32_t supported_device,
  775.                           int connector_type,
  776.                           struct radeon_i2c_bus_rec *i2c_bus,
  777.                           bool linkb,
  778.                           uint32_t igp_lane_info)
  779. {
  780.         struct radeon_device *rdev = dev->dev_private;
  781.         struct drm_connector *connector;
  782.         struct radeon_connector *radeon_connector;
  783.         struct radeon_connector_atom_dig *radeon_dig_connector;
  784.         uint32_t subpixel_order = SubPixelNone;
  785.         int ret;
  786.  
  787.         /* fixme - tv/cv/din */
  788.         if (connector_type == DRM_MODE_CONNECTOR_Unknown)
  789.                 return;
  790.  
  791.         /* see if we already added it */
  792.         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
  793.                 radeon_connector = to_radeon_connector(connector);
  794.                 if (radeon_connector->connector_id == connector_id) {
  795.                         radeon_connector->devices |= supported_device;
  796.                         return;
  797.                 }
  798.         }
  799.  
  800.         radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
  801.         if (!radeon_connector)
  802.                 return;
  803.  
  804.         connector = &radeon_connector->base;
  805.  
  806.         radeon_connector->connector_id = connector_id;
  807.         radeon_connector->devices = supported_device;
  808.         switch (connector_type) {
  809.         case DRM_MODE_CONNECTOR_VGA:
  810.                 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
  811.                 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
  812.                 if (ret)
  813.                         goto failed;
  814.                 if (i2c_bus->valid) {
  815.                         radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "VGA");
  816.                         if (!radeon_connector->ddc_bus)
  817.                                 goto failed;
  818.                 }
  819.                 radeon_connector->dac_load_detect = true;
  820.                 drm_connector_attach_property(&radeon_connector->base,
  821.                                               rdev->mode_info.load_detect_property,
  822.                                               1);
  823.                 break;
  824.         case DRM_MODE_CONNECTOR_DVIA:
  825.                 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
  826.                 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
  827.                 if (ret)
  828.                         goto failed;
  829.                 if (i2c_bus->valid) {
  830.                         radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
  831.                         if (!radeon_connector->ddc_bus)
  832.                                 goto failed;
  833.                 }
  834.                 radeon_connector->dac_load_detect = true;
  835.                 drm_connector_attach_property(&radeon_connector->base,
  836.                                               rdev->mode_info.load_detect_property,
  837.                                               1);
  838.                 break;
  839.         case DRM_MODE_CONNECTOR_DVII:
  840.         case DRM_MODE_CONNECTOR_DVID:
  841.                 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
  842.                 if (!radeon_dig_connector)
  843.                         goto failed;
  844.                 radeon_dig_connector->linkb = linkb;
  845.                 radeon_dig_connector->igp_lane_info = igp_lane_info;
  846.                 radeon_connector->con_priv = radeon_dig_connector;
  847.                 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
  848.                 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
  849.                 if (ret)
  850.                         goto failed;
  851.                 if (i2c_bus->valid) {
  852.                         radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
  853.                         if (!radeon_connector->ddc_bus)
  854.                                 goto failed;
  855.                 }
  856.                 subpixel_order = SubPixelHorizontalRGB;
  857.                 drm_connector_attach_property(&radeon_connector->base,
  858.                                               rdev->mode_info.coherent_mode_property,
  859.                                               1);
  860.                 radeon_connector->dac_load_detect = true;
  861.                 drm_connector_attach_property(&radeon_connector->base,
  862.                                               rdev->mode_info.load_detect_property,
  863.                                               1);
  864.                 break;
  865.         case DRM_MODE_CONNECTOR_HDMIA:
  866.         case DRM_MODE_CONNECTOR_HDMIB:
  867.                 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
  868.                 if (!radeon_dig_connector)
  869.                         goto failed;
  870.                 radeon_dig_connector->linkb = linkb;
  871.                 radeon_dig_connector->igp_lane_info = igp_lane_info;
  872.                 radeon_connector->con_priv = radeon_dig_connector;
  873.                 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
  874.                 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
  875.                 if (ret)
  876.                         goto failed;
  877.                 if (i2c_bus->valid) {
  878.                         radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "HDMI");
  879.                         if (!radeon_connector->ddc_bus)
  880.                                 goto failed;
  881.                 }
  882.                 drm_connector_attach_property(&radeon_connector->base,
  883.                                               rdev->mode_info.coherent_mode_property,
  884.                                               1);
  885.                 subpixel_order = SubPixelHorizontalRGB;
  886.                 break;
  887.         case DRM_MODE_CONNECTOR_DisplayPort:
  888.                 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
  889.                 if (!radeon_dig_connector)
  890.                         goto failed;
  891.                 radeon_dig_connector->linkb = linkb;
  892.                 radeon_dig_connector->igp_lane_info = igp_lane_info;
  893.                 radeon_connector->con_priv = radeon_dig_connector;
  894.                 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
  895.                 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
  896.                 if (ret)
  897.                         goto failed;
  898.                 if (i2c_bus->valid) {
  899.                         radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DP");
  900.                         if (!radeon_connector->ddc_bus)
  901.                                 goto failed;
  902.                 }
  903.                 subpixel_order = SubPixelHorizontalRGB;
  904.                 break;
  905.         case DRM_MODE_CONNECTOR_SVIDEO:
  906.         case DRM_MODE_CONNECTOR_Composite:
  907.         case DRM_MODE_CONNECTOR_9PinDIN:
  908.                 if (radeon_tv == 1) {
  909.                         drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
  910.                         ret = drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
  911.                         if (ret)
  912.                                 goto failed;
  913.                         radeon_connector->dac_load_detect = true;
  914.                 drm_connector_attach_property(&radeon_connector->base,
  915.                                               rdev->mode_info.load_detect_property,
  916.                                               1);
  917.                 }
  918.                 break;
  919.         case DRM_MODE_CONNECTOR_LVDS:
  920.                 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
  921.                 if (!radeon_dig_connector)
  922.                         goto failed;
  923.                 radeon_dig_connector->linkb = linkb;
  924.                 radeon_dig_connector->igp_lane_info = igp_lane_info;
  925.                 radeon_connector->con_priv = radeon_dig_connector;
  926.                 drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
  927.                 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
  928.                 if (ret)
  929.                         goto failed;
  930.                 if (i2c_bus->valid) {
  931.                         radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "LVDS");
  932.                         if (!radeon_connector->ddc_bus)
  933.                                 goto failed;
  934.                 }
  935.                 drm_mode_create_scaling_mode_property(dev);
  936.                 drm_connector_attach_property(&radeon_connector->base,
  937.                                               dev->mode_config.scaling_mode_property,
  938.                                               DRM_MODE_SCALE_FULLSCREEN);
  939.                 subpixel_order = SubPixelHorizontalRGB;
  940.                 break;
  941.         }
  942.  
  943.         connector->display_info.subpixel_order = subpixel_order;
  944.  //  drm_sysfs_connector_add(connector);
  945.         return;
  946.  
  947. failed:
  948.         if (radeon_connector->ddc_bus)
  949.                 radeon_i2c_destroy(radeon_connector->ddc_bus);
  950.         drm_connector_cleanup(connector);
  951.         kfree(connector);
  952. }
  953.  
  954. void
  955. radeon_add_legacy_connector(struct drm_device *dev,
  956.                             uint32_t connector_id,
  957.                             uint32_t supported_device,
  958.                             int connector_type,
  959.                             struct radeon_i2c_bus_rec *i2c_bus)
  960. {
  961.         struct radeon_device *rdev = dev->dev_private;
  962.         struct drm_connector *connector;
  963.         struct radeon_connector *radeon_connector;
  964.         uint32_t subpixel_order = SubPixelNone;
  965.         int ret;
  966.  
  967.         /* fixme - tv/cv/din */
  968.         if (connector_type == DRM_MODE_CONNECTOR_Unknown)
  969.                 return;
  970.  
  971.         /* see if we already added it */
  972.         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
  973.                 radeon_connector = to_radeon_connector(connector);
  974.                 if (radeon_connector->connector_id == connector_id) {
  975.                         radeon_connector->devices |= supported_device;
  976.                         return;
  977.                 }
  978.         }
  979.  
  980.         radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
  981.         if (!radeon_connector)
  982.                 return;
  983.  
  984.         connector = &radeon_connector->base;
  985.  
  986.         radeon_connector->connector_id = connector_id;
  987.         radeon_connector->devices = supported_device;
  988.         switch (connector_type) {
  989.         case DRM_MODE_CONNECTOR_VGA:
  990.                 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
  991.                 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
  992.                 if (ret)
  993.                         goto failed;
  994.                 if (i2c_bus->valid) {
  995.                         radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "VGA");
  996.                         if (!radeon_connector->ddc_bus)
  997.                                 goto failed;
  998.                 }
  999.                 radeon_connector->dac_load_detect = true;
  1000.                 drm_connector_attach_property(&radeon_connector->base,
  1001.                                               rdev->mode_info.load_detect_property,
  1002.                                               1);
  1003.                 break;
  1004.         case DRM_MODE_CONNECTOR_DVIA:
  1005.                 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
  1006.                 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
  1007.                 if (ret)
  1008.                         goto failed;
  1009.                 if (i2c_bus->valid) {
  1010.                         radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
  1011.                         if (!radeon_connector->ddc_bus)
  1012.                                 goto failed;
  1013.                 }
  1014.                 radeon_connector->dac_load_detect = true;
  1015.                 drm_connector_attach_property(&radeon_connector->base,
  1016.                                               rdev->mode_info.load_detect_property,
  1017.                                               1);
  1018.                 break;
  1019.         case DRM_MODE_CONNECTOR_DVII:
  1020.         case DRM_MODE_CONNECTOR_DVID:
  1021.                 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
  1022.                 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
  1023.                 if (ret)
  1024.                         goto failed;
  1025.                 if (i2c_bus->valid) {
  1026.                         radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
  1027.                         if (!radeon_connector->ddc_bus)
  1028.                                 goto failed;
  1029.                         radeon_connector->dac_load_detect = true;
  1030.                         drm_connector_attach_property(&radeon_connector->base,
  1031.                                                       rdev->mode_info.load_detect_property,
  1032.                                                       1);
  1033.                 }
  1034.                 subpixel_order = SubPixelHorizontalRGB;
  1035.                 break;
  1036.         case DRM_MODE_CONNECTOR_SVIDEO:
  1037.         case DRM_MODE_CONNECTOR_Composite:
  1038.         case DRM_MODE_CONNECTOR_9PinDIN:
  1039.                 if (radeon_tv == 1) {
  1040.                         drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
  1041.                         ret = drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
  1042.                         if (ret)
  1043.                                 goto failed;
  1044.                         radeon_connector->dac_load_detect = true;
  1045.                         drm_connector_attach_property(&radeon_connector->base,
  1046.                                                       rdev->mode_info.load_detect_property,
  1047.                                                       1);
  1048.                 }
  1049.                 break;
  1050.         case DRM_MODE_CONNECTOR_LVDS:
  1051.                 drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
  1052.                 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
  1053.                 if (ret)
  1054.                         goto failed;
  1055.                 if (i2c_bus->valid) {
  1056.                         radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "LVDS");
  1057.                         if (!radeon_connector->ddc_bus)
  1058.                                 goto failed;
  1059.                 }
  1060.                 drm_connector_attach_property(&radeon_connector->base,
  1061.                                               dev->mode_config.scaling_mode_property,
  1062.                                               DRM_MODE_SCALE_FULLSCREEN);
  1063.                 subpixel_order = SubPixelHorizontalRGB;
  1064.                 break;
  1065.         }
  1066.  
  1067.         connector->display_info.subpixel_order = subpixel_order;
  1068.   // drm_sysfs_connector_add(connector);
  1069.         return;
  1070.  
  1071. failed:
  1072.         if (radeon_connector->ddc_bus)
  1073.                 radeon_i2c_destroy(radeon_connector->ddc_bus);
  1074.         drm_connector_cleanup(connector);
  1075.         kfree(connector);
  1076. }
  1077.