Subversion Repositories Kolibri OS

Rev

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