Subversion Repositories Kolibri OS

Rev

Rev 5078 | Rev 5271 | 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 <drm/drmP.h>
  27. #include <drm/drm_crtc_helper.h>
  28. #include <drm/radeon_drm.h>
  29. #include "radeon.h"
  30. #include "atom.h"
  31.  
  32. extern void
  33. radeon_legacy_backlight_init(struct radeon_encoder *radeon_encoder,
  34.                              struct drm_connector *drm_connector);
  35. extern void
  36. radeon_atom_backlight_init(struct radeon_encoder *radeon_encoder,
  37.                            struct drm_connector *drm_connector);
  38.  
  39.  
  40. static uint32_t radeon_encoder_clones(struct drm_encoder *encoder)
  41. {
  42.         struct drm_device *dev = encoder->dev;
  43.         struct radeon_device *rdev = dev->dev_private;
  44.         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
  45.         struct drm_encoder *clone_encoder;
  46.         uint32_t index_mask = 0;
  47.         int count;
  48.  
  49.         /* DIG routing gets problematic */
  50.         if (rdev->family >= CHIP_R600)
  51.                 return index_mask;
  52.         /* LVDS/TV are too wacky */
  53.         if (radeon_encoder->devices & ATOM_DEVICE_LCD_SUPPORT)
  54.                 return index_mask;
  55.         /* DVO requires 2x ppll clocks depending on tmds chip */
  56.         if (radeon_encoder->devices & ATOM_DEVICE_DFP2_SUPPORT)
  57.                 return index_mask;
  58.  
  59.         count = -1;
  60.         list_for_each_entry(clone_encoder, &dev->mode_config.encoder_list, head) {
  61.                 struct radeon_encoder *radeon_clone = to_radeon_encoder(clone_encoder);
  62.                 count++;
  63.  
  64.                 if (clone_encoder == encoder)
  65.                         continue;
  66.                 if (radeon_clone->devices & (ATOM_DEVICE_LCD_SUPPORT))
  67.                         continue;
  68.                 if (radeon_clone->devices & ATOM_DEVICE_DFP2_SUPPORT)
  69.                         continue;
  70.                 else
  71.                         index_mask |= (1 << count);
  72.         }
  73.         return index_mask;
  74. }
  75.  
  76. void radeon_setup_encoder_clones(struct drm_device *dev)
  77. {
  78.         struct drm_encoder *encoder;
  79.  
  80.         list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
  81.                 encoder->possible_clones = radeon_encoder_clones(encoder);
  82.         }
  83. }
  84.  
  85. uint32_t
  86. radeon_get_encoder_enum(struct drm_device *dev, uint32_t supported_device, uint8_t dac)
  87. {
  88.         struct radeon_device *rdev = dev->dev_private;
  89.         uint32_t ret = 0;
  90.  
  91.         switch (supported_device) {
  92.         case ATOM_DEVICE_CRT1_SUPPORT:
  93.         case ATOM_DEVICE_TV1_SUPPORT:
  94.         case ATOM_DEVICE_TV2_SUPPORT:
  95.         case ATOM_DEVICE_CRT2_SUPPORT:
  96.         case ATOM_DEVICE_CV_SUPPORT:
  97.                 switch (dac) {
  98.                 case 1: /* dac a */
  99.                         if ((rdev->family == CHIP_RS300) ||
  100.                             (rdev->family == CHIP_RS400) ||
  101.                             (rdev->family == CHIP_RS480))
  102.                                 ret = ENCODER_INTERNAL_DAC2_ENUM_ID1;
  103.                         else if (ASIC_IS_AVIVO(rdev))
  104.                                 ret = ENCODER_INTERNAL_KLDSCP_DAC1_ENUM_ID1;
  105.                         else
  106.                                 ret = ENCODER_INTERNAL_DAC1_ENUM_ID1;
  107.                         break;
  108.                 case 2: /* dac b */
  109.                         if (ASIC_IS_AVIVO(rdev))
  110.                                 ret = ENCODER_INTERNAL_KLDSCP_DAC2_ENUM_ID1;
  111.                         else {
  112.                                 /*if (rdev->family == CHIP_R200)
  113.                                   ret = ENCODER_INTERNAL_DVO1_ENUM_ID1;
  114.                                   else*/
  115.                                 ret = ENCODER_INTERNAL_DAC2_ENUM_ID1;
  116.                         }
  117.                         break;
  118.                 case 3: /* external dac */
  119.                         if (ASIC_IS_AVIVO(rdev))
  120.                                 ret = ENCODER_INTERNAL_KLDSCP_DVO1_ENUM_ID1;
  121.                         else
  122.                                 ret = ENCODER_INTERNAL_DVO1_ENUM_ID1;
  123.                         break;
  124.                 }
  125.                 break;
  126.         case ATOM_DEVICE_LCD1_SUPPORT:
  127.                 if (ASIC_IS_AVIVO(rdev))
  128.                         ret = ENCODER_INTERNAL_LVTM1_ENUM_ID1;
  129.                 else
  130.                         ret = ENCODER_INTERNAL_LVDS_ENUM_ID1;
  131.                 break;
  132.         case ATOM_DEVICE_DFP1_SUPPORT:
  133.                 if ((rdev->family == CHIP_RS300) ||
  134.                     (rdev->family == CHIP_RS400) ||
  135.                     (rdev->family == CHIP_RS480))
  136.                         ret = ENCODER_INTERNAL_DVO1_ENUM_ID1;
  137.                 else if (ASIC_IS_AVIVO(rdev))
  138.                         ret = ENCODER_INTERNAL_KLDSCP_TMDS1_ENUM_ID1;
  139.                 else
  140.                         ret = ENCODER_INTERNAL_TMDS1_ENUM_ID1;
  141.                 break;
  142.         case ATOM_DEVICE_LCD2_SUPPORT:
  143.         case ATOM_DEVICE_DFP2_SUPPORT:
  144.                 if ((rdev->family == CHIP_RS600) ||
  145.                     (rdev->family == CHIP_RS690) ||
  146.                     (rdev->family == CHIP_RS740))
  147.                         ret = ENCODER_INTERNAL_DDI_ENUM_ID1;
  148.                 else if (ASIC_IS_AVIVO(rdev))
  149.                         ret = ENCODER_INTERNAL_KLDSCP_DVO1_ENUM_ID1;
  150.                 else
  151.                         ret = ENCODER_INTERNAL_DVO1_ENUM_ID1;
  152.                 break;
  153.         case ATOM_DEVICE_DFP3_SUPPORT:
  154.                 ret = ENCODER_INTERNAL_LVTM1_ENUM_ID1;
  155.                 break;
  156.         }
  157.  
  158.         return ret;
  159. }
  160.  
  161. static void radeon_encoder_add_backlight(struct radeon_encoder *radeon_encoder,
  162.                                          struct drm_connector *connector)
  163. {
  164.         struct drm_device *dev = radeon_encoder->base.dev;
  165.         struct radeon_device *rdev = dev->dev_private;
  166.         bool use_bl = false;
  167.  
  168.         if (!(radeon_encoder->devices & (ATOM_DEVICE_LCD_SUPPORT)))
  169.                 return;
  170.  
  171.         if (radeon_backlight == 0) {
  172.                 return;
  173.         } else if (radeon_backlight == 1) {
  174.                 use_bl = true;
  175.         } else if (radeon_backlight == -1) {
  176.                 /* Quirks */
  177.                 /* Amilo Xi 2550 only works with acpi bl */
  178.                 if ((rdev->pdev->device == 0x9583) &&
  179.                     (rdev->pdev->subsystem_vendor == 0x1734) &&
  180.                     (rdev->pdev->subsystem_device == 0x1107))
  181.                         use_bl = false;
  182.                 else
  183.                         use_bl = true;
  184.         }
  185.  
  186.         if (use_bl) {
  187.                 if (rdev->is_atom_bios)
  188.                         radeon_atom_backlight_init(radeon_encoder, connector);
  189.                 else
  190.                         radeon_legacy_backlight_init(radeon_encoder, connector);
  191.                 rdev->mode_info.bl_encoder = radeon_encoder;
  192.         }
  193. }
  194.  
  195. void
  196. radeon_link_encoder_connector(struct drm_device *dev)
  197. {
  198.         struct drm_connector *connector;
  199.         struct radeon_connector *radeon_connector;
  200.         struct drm_encoder *encoder;
  201.         struct radeon_encoder *radeon_encoder;
  202.  
  203.         /* walk the list and link encoders to connectors */
  204.         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
  205.                 radeon_connector = to_radeon_connector(connector);
  206.                 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
  207.                         radeon_encoder = to_radeon_encoder(encoder);
  208.                         if (radeon_encoder->devices & radeon_connector->devices) {
  209.                                 drm_mode_connector_attach_encoder(connector, encoder);
  210.                                 if (radeon_encoder->devices & (ATOM_DEVICE_LCD_SUPPORT))
  211.                                         radeon_encoder_add_backlight(radeon_encoder, connector);
  212.                         }
  213.                 }
  214.         }
  215. }
  216.  
  217. void radeon_encoder_set_active_device(struct drm_encoder *encoder)
  218. {
  219.         struct drm_device *dev = encoder->dev;
  220.         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
  221.         struct drm_connector *connector;
  222.  
  223.         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
  224.                 if (connector->encoder == encoder) {
  225.                         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  226.                         radeon_encoder->active_device = radeon_encoder->devices & radeon_connector->devices;
  227.                         DRM_DEBUG_KMS("setting active device to %08x from %08x %08x for encoder %d\n",
  228.                                   radeon_encoder->active_device, radeon_encoder->devices,
  229.                                   radeon_connector->devices, encoder->encoder_type);
  230.                 }
  231.         }
  232. }
  233.  
  234. struct drm_connector *
  235. radeon_get_connector_for_encoder(struct drm_encoder *encoder)
  236. {
  237.         struct drm_device *dev = encoder->dev;
  238.         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
  239.         struct drm_connector *connector;
  240.         struct radeon_connector *radeon_connector;
  241.  
  242.         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
  243.                 radeon_connector = to_radeon_connector(connector);
  244.                 if (radeon_encoder->active_device & radeon_connector->devices)
  245.                         return connector;
  246.         }
  247.         return NULL;
  248. }
  249.  
  250. struct drm_connector *
  251. radeon_get_connector_for_encoder_init(struct drm_encoder *encoder)
  252. {
  253.         struct drm_device *dev = encoder->dev;
  254.         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
  255.         struct drm_connector *connector;
  256.         struct radeon_connector *radeon_connector;
  257.  
  258.         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
  259.                 radeon_connector = to_radeon_connector(connector);
  260.                 if (radeon_encoder->devices & radeon_connector->devices)
  261.                         return connector;
  262.         }
  263.         return NULL;
  264. }
  265.  
  266. struct drm_encoder *radeon_get_external_encoder(struct drm_encoder *encoder)
  267. {
  268.         struct drm_device *dev = encoder->dev;
  269.         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
  270.         struct drm_encoder *other_encoder;
  271.         struct radeon_encoder *other_radeon_encoder;
  272.  
  273.         if (radeon_encoder->is_ext_encoder)
  274.                 return NULL;
  275.  
  276.         list_for_each_entry(other_encoder, &dev->mode_config.encoder_list, head) {
  277.                 if (other_encoder == encoder)
  278.                         continue;
  279.                 other_radeon_encoder = to_radeon_encoder(other_encoder);
  280.                 if (other_radeon_encoder->is_ext_encoder &&
  281.                     (radeon_encoder->devices & other_radeon_encoder->devices))
  282.                         return other_encoder;
  283.         }
  284.         return NULL;
  285. }
  286.  
  287. u16 radeon_encoder_get_dp_bridge_encoder_id(struct drm_encoder *encoder)
  288. {
  289.         struct drm_encoder *other_encoder = radeon_get_external_encoder(encoder);
  290.  
  291.         if (other_encoder) {
  292.                 struct radeon_encoder *radeon_encoder = to_radeon_encoder(other_encoder);
  293.  
  294.                 switch (radeon_encoder->encoder_id) {
  295.                 case ENCODER_OBJECT_ID_TRAVIS:
  296.                 case ENCODER_OBJECT_ID_NUTMEG:
  297.                         return radeon_encoder->encoder_id;
  298.                 default:
  299.                         return ENCODER_OBJECT_ID_NONE;
  300.                 }
  301.         }
  302.         return ENCODER_OBJECT_ID_NONE;
  303. }
  304.  
  305. void radeon_panel_mode_fixup(struct drm_encoder *encoder,
  306.                              struct drm_display_mode *adjusted_mode)
  307. {
  308.         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
  309.         struct drm_device *dev = encoder->dev;
  310.         struct radeon_device *rdev = dev->dev_private;
  311.         struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
  312.         unsigned hblank = native_mode->htotal - native_mode->hdisplay;
  313.         unsigned vblank = native_mode->vtotal - native_mode->vdisplay;
  314.         unsigned hover = native_mode->hsync_start - native_mode->hdisplay;
  315.         unsigned vover = native_mode->vsync_start - native_mode->vdisplay;
  316.         unsigned hsync_width = native_mode->hsync_end - native_mode->hsync_start;
  317.         unsigned vsync_width = native_mode->vsync_end - native_mode->vsync_start;
  318.  
  319.         adjusted_mode->clock = native_mode->clock;
  320.         adjusted_mode->flags = native_mode->flags;
  321.  
  322.         if (ASIC_IS_AVIVO(rdev)) {
  323.                 adjusted_mode->hdisplay = native_mode->hdisplay;
  324.                 adjusted_mode->vdisplay = native_mode->vdisplay;
  325.         }
  326.  
  327.         adjusted_mode->htotal = native_mode->hdisplay + hblank;
  328.         adjusted_mode->hsync_start = native_mode->hdisplay + hover;
  329.         adjusted_mode->hsync_end = adjusted_mode->hsync_start + hsync_width;
  330.  
  331.         adjusted_mode->vtotal = native_mode->vdisplay + vblank;
  332.         adjusted_mode->vsync_start = native_mode->vdisplay + vover;
  333.         adjusted_mode->vsync_end = adjusted_mode->vsync_start + vsync_width;
  334.  
  335.         drm_mode_set_crtcinfo(adjusted_mode, CRTC_INTERLACE_HALVE_V);
  336.  
  337.         if (ASIC_IS_AVIVO(rdev)) {
  338.                 adjusted_mode->crtc_hdisplay = native_mode->hdisplay;
  339.                 adjusted_mode->crtc_vdisplay = native_mode->vdisplay;
  340.         }
  341.  
  342.         adjusted_mode->crtc_htotal = adjusted_mode->crtc_hdisplay + hblank;
  343.         adjusted_mode->crtc_hsync_start = adjusted_mode->crtc_hdisplay + hover;
  344.         adjusted_mode->crtc_hsync_end = adjusted_mode->crtc_hsync_start + hsync_width;
  345.  
  346.         adjusted_mode->crtc_vtotal = adjusted_mode->crtc_vdisplay + vblank;
  347.         adjusted_mode->crtc_vsync_start = adjusted_mode->crtc_vdisplay + vover;
  348.         adjusted_mode->crtc_vsync_end = adjusted_mode->crtc_vsync_start + vsync_width;
  349.  
  350. }
  351.  
  352. bool radeon_dig_monitor_is_duallink(struct drm_encoder *encoder,
  353.                                     u32 pixel_clock)
  354. {
  355.         struct drm_device *dev = encoder->dev;
  356.         struct radeon_device *rdev = dev->dev_private;
  357.         struct drm_connector *connector;
  358.         struct radeon_connector *radeon_connector;
  359.         struct radeon_connector_atom_dig *dig_connector;
  360.  
  361.         connector = radeon_get_connector_for_encoder(encoder);
  362.         /* if we don't have an active device yet, just use one of
  363.          * the connectors tied to the encoder.
  364.          */
  365.         if (!connector)
  366.                 connector = radeon_get_connector_for_encoder_init(encoder);
  367.         radeon_connector = to_radeon_connector(connector);
  368.  
  369.         switch (connector->connector_type) {
  370.         case DRM_MODE_CONNECTOR_DVII:
  371.         case DRM_MODE_CONNECTOR_HDMIB:
  372.                 if (radeon_connector->use_digital) {
  373.                         /* HDMI 1.3 supports up to 340 Mhz over single link */
  374.                         if (ASIC_IS_DCE6(rdev) && drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
  375.                                 if (pixel_clock > 340000)
  376.                                         return true;
  377.                         else
  378.                                         return false;
  379.                         } else {
  380.                                 if (pixel_clock > 165000)
  381.                                         return true;
  382.                 else
  383.                                         return false;
  384.                         }
  385.                 } else
  386.                         return false;
  387.         case DRM_MODE_CONNECTOR_DVID:
  388.         case DRM_MODE_CONNECTOR_HDMIA:
  389.         case DRM_MODE_CONNECTOR_DisplayPort:
  390.                 dig_connector = radeon_connector->con_priv;
  391.                 if ((dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) ||
  392.                     (dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_eDP))
  393.                         return false;
  394.         else {
  395.                         /* HDMI 1.3 supports up to 340 Mhz over single link */
  396.                         if (ASIC_IS_DCE6(rdev) && drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
  397.                                 if (pixel_clock > 340000)
  398.                                         return true;
  399.                 else
  400.                                         return false;
  401.         } else {
  402.                                 if (pixel_clock > 165000)
  403.                                         return true;
  404.                                 else
  405.                 return false;
  406.         }
  407.                 }
  408.                 default:
  409.                         return false;
  410.                 }
  411. }
  412.  
  413.