Subversion Repositories Kolibri OS

Rev

Rev 6661 | 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_edid.h>
  28. #include <drm/drm_crtc_helper.h>
  29. #include <drm/drm_fb_helper.h>
  30. #include <drm/drm_dp_mst_helper.h>
  31. #include <drm/radeon_drm.h>
  32. #include "radeon.h"
  33. #include "radeon_audio.h"
  34. #include "atom.h"
  35.  
  36. #include <linux/pm_runtime.h>
  37.  
  38. static int radeon_dp_handle_hpd(struct drm_connector *connector)
  39. {
  40.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  41.         int ret;
  42.  
  43.         ret = radeon_dp_mst_check_status(radeon_connector);
  44.         if (ret == -EINVAL)
  45.                 return 1;
  46.         return 0;
  47. }
  48. void radeon_connector_hotplug(struct drm_connector *connector)
  49. {
  50.         struct drm_device *dev = connector->dev;
  51.         struct radeon_device *rdev = dev->dev_private;
  52.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  53.  
  54.         if (connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort) {
  55.                 struct radeon_connector_atom_dig *dig_connector =
  56.                         radeon_connector->con_priv;
  57.  
  58.                 if (radeon_connector->is_mst_connector)
  59.                         return;
  60.                 if (dig_connector->is_mst) {
  61.                         radeon_dp_handle_hpd(connector);
  62.                         return;
  63.                 }
  64.         }
  65.         /* bail if the connector does not have hpd pin, e.g.,
  66.          * VGA, TV, etc.
  67.          */
  68.         if (radeon_connector->hpd.hpd == RADEON_HPD_NONE)
  69.                 return;
  70.  
  71.         radeon_hpd_set_polarity(rdev, radeon_connector->hpd.hpd);
  72.  
  73.         /* if the connector is already off, don't turn it back on */
  74.         /* FIXME: This access isn't protected by any locks. */
  75.         if (connector->dpms != DRM_MODE_DPMS_ON)
  76.                 return;
  77.  
  78.         /* just deal with DP (not eDP) here. */
  79.         if (connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort) {
  80.                 struct radeon_connector_atom_dig *dig_connector =
  81.                         radeon_connector->con_priv;
  82.  
  83.                 /* if existing sink type was not DP no need to retrain */
  84.                 if (dig_connector->dp_sink_type != CONNECTOR_OBJECT_ID_DISPLAYPORT)
  85.                         return;
  86.  
  87.                 /* first get sink type as it may be reset after (un)plug */
  88.                 dig_connector->dp_sink_type = radeon_dp_getsinktype(radeon_connector);
  89.                 /* don't do anything if sink is not display port, i.e.,
  90.                  * passive dp->(dvi|hdmi) adaptor
  91.                  */
  92.                 if (dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) {
  93.                         int saved_dpms = connector->dpms;
  94.                         /* Only turn off the display if it's physically disconnected */
  95.                         if (!radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) {
  96.                                 drm_helper_connector_dpms(connector, DRM_MODE_DPMS_OFF);
  97.                         } else if (radeon_dp_needs_link_train(radeon_connector)) {
  98.                                 /* Don't try to start link training before we
  99.                                  * have the dpcd */
  100.                                 if (!radeon_dp_getdpcd(radeon_connector))
  101.                                         return;
  102.  
  103.                                 /* set it to OFF so that drm_helper_connector_dpms()
  104.                                  * won't return immediately since the current state
  105.                                  * is ON at this point.
  106.                                  */
  107.                                 connector->dpms = DRM_MODE_DPMS_OFF;
  108.                                 drm_helper_connector_dpms(connector, DRM_MODE_DPMS_ON);
  109.                         }
  110.                         connector->dpms = saved_dpms;
  111.                 }
  112.         }
  113. }
  114.  
  115. static void radeon_property_change_mode(struct drm_encoder *encoder)
  116. {
  117.         struct drm_crtc *crtc = encoder->crtc;
  118.  
  119.         if (crtc && crtc->enabled) {
  120.                 drm_crtc_helper_set_mode(crtc, &crtc->mode,
  121.                                          crtc->x, crtc->y, crtc->primary->fb);
  122.         }
  123. }
  124.  
  125. int radeon_get_monitor_bpc(struct drm_connector *connector)
  126. {
  127.         struct drm_device *dev = connector->dev;
  128.         struct radeon_device *rdev = dev->dev_private;
  129.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  130.         struct radeon_connector_atom_dig *dig_connector;
  131.         int bpc = 8;
  132.         int mode_clock, max_tmds_clock;
  133.  
  134.         switch (connector->connector_type) {
  135.         case DRM_MODE_CONNECTOR_DVII:
  136.         case DRM_MODE_CONNECTOR_HDMIB:
  137.                 if (radeon_connector->use_digital) {
  138.                         if (drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
  139.                                 if (connector->display_info.bpc)
  140.                                         bpc = connector->display_info.bpc;
  141.                         }
  142.                 }
  143.                 break;
  144.         case DRM_MODE_CONNECTOR_DVID:
  145.         case DRM_MODE_CONNECTOR_HDMIA:
  146.                 if (drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
  147.                         if (connector->display_info.bpc)
  148.                                 bpc = connector->display_info.bpc;
  149.                 }
  150.                 break;
  151.         case DRM_MODE_CONNECTOR_DisplayPort:
  152.                 dig_connector = radeon_connector->con_priv;
  153.                 if ((dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) ||
  154.                     (dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_eDP) ||
  155.                     drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
  156.                         if (connector->display_info.bpc)
  157.                                 bpc = connector->display_info.bpc;
  158.                 }
  159.                 break;
  160.         case DRM_MODE_CONNECTOR_eDP:
  161.         case DRM_MODE_CONNECTOR_LVDS:
  162.                 if (connector->display_info.bpc)
  163.                         bpc = connector->display_info.bpc;
  164.                 else if (ASIC_IS_DCE41(rdev) || ASIC_IS_DCE5(rdev)) {
  165.                         const struct drm_connector_helper_funcs *connector_funcs =
  166.                                 connector->helper_private;
  167.                         struct drm_encoder *encoder = connector_funcs->best_encoder(connector);
  168.                         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
  169.                         struct radeon_encoder_atom_dig *dig = radeon_encoder->enc_priv;
  170.  
  171.                         if (dig->lcd_misc & ATOM_PANEL_MISC_V13_6BIT_PER_COLOR)
  172.                                 bpc = 6;
  173.                         else if (dig->lcd_misc & ATOM_PANEL_MISC_V13_8BIT_PER_COLOR)
  174.                                 bpc = 8;
  175.                 }
  176.                 break;
  177.         }
  178.  
  179.         if (drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
  180.                 /* hdmi deep color only implemented on DCE4+ */
  181.                 if ((bpc > 8) && !ASIC_IS_DCE4(rdev)) {
  182.                         DRM_DEBUG("%s: HDMI deep color %d bpc unsupported. Using 8 bpc.\n",
  183.                                           connector->name, bpc);
  184.                         bpc = 8;
  185.                 }
  186.  
  187.                 /*
  188.                  * Pre DCE-8 hw can't handle > 12 bpc, and more than 12 bpc doesn't make
  189.                  * much sense without support for > 12 bpc framebuffers. RGB 4:4:4 at
  190.                  * 12 bpc is always supported on hdmi deep color sinks, as this is
  191.                  * required by the HDMI-1.3 spec. Clamp to a safe 12 bpc maximum.
  192.                  */
  193.                 if (bpc > 12) {
  194.                         DRM_DEBUG("%s: HDMI deep color %d bpc unsupported. Using 12 bpc.\n",
  195.                                           connector->name, bpc);
  196.                         bpc = 12;
  197.                 }
  198.  
  199.                 /* Any defined maximum tmds clock limit we must not exceed? */
  200.                 if (connector->max_tmds_clock > 0) {
  201.                         /* mode_clock is clock in kHz for mode to be modeset on this connector */
  202.                         mode_clock = radeon_connector->pixelclock_for_modeset;
  203.  
  204.                         /* Maximum allowable input clock in kHz */
  205.                         max_tmds_clock = connector->max_tmds_clock * 1000;
  206.  
  207.                         DRM_DEBUG("%s: hdmi mode dotclock %d kHz, max tmds input clock %d kHz.\n",
  208.                                           connector->name, mode_clock, max_tmds_clock);
  209.  
  210.                         /* Check if bpc is within clock limit. Try to degrade gracefully otherwise */
  211.                         if ((bpc == 12) && (mode_clock * 3/2 > max_tmds_clock)) {
  212.                                 if ((connector->display_info.edid_hdmi_dc_modes & DRM_EDID_HDMI_DC_30) &&
  213.                                         (mode_clock * 5/4 <= max_tmds_clock))
  214.                                         bpc = 10;
  215.                                 else
  216.                                         bpc = 8;
  217.  
  218.                                 DRM_DEBUG("%s: HDMI deep color 12 bpc exceeds max tmds clock. Using %d bpc.\n",
  219.                                                   connector->name, bpc);
  220.                         }
  221.  
  222.                         if ((bpc == 10) && (mode_clock * 5/4 > max_tmds_clock)) {
  223.                                 bpc = 8;
  224.                                 DRM_DEBUG("%s: HDMI deep color 10 bpc exceeds max tmds clock. Using %d bpc.\n",
  225.                                                   connector->name, bpc);
  226.                         }
  227.                 }
  228.                 else if (bpc > 8) {
  229.                         /* max_tmds_clock missing, but hdmi spec mandates it for deep color. */
  230.                         DRM_DEBUG("%s: Required max tmds clock for HDMI deep color missing. Using 8 bpc.\n",
  231.                                           connector->name);
  232.                         bpc = 8;
  233.                 }
  234.         }
  235.  
  236.         if ((radeon_deep_color == 0) && (bpc > 8)) {
  237.                 DRM_DEBUG("%s: Deep color disabled. Set radeon module param deep_color=1 to enable.\n",
  238.                                   connector->name);
  239.                 bpc = 8;
  240.         }
  241.  
  242.         DRM_DEBUG("%s: Display bpc=%d, returned bpc=%d\n",
  243.                           connector->name, connector->display_info.bpc, bpc);
  244.  
  245.         return bpc;
  246. }
  247.  
  248. static void
  249. radeon_connector_update_scratch_regs(struct drm_connector *connector, enum drm_connector_status status)
  250. {
  251.         struct drm_device *dev = connector->dev;
  252.         struct radeon_device *rdev = dev->dev_private;
  253.         struct drm_encoder *best_encoder = NULL;
  254.         struct drm_encoder *encoder = NULL;
  255.         const struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
  256.         bool connected;
  257.         int i;
  258.  
  259.         best_encoder = connector_funcs->best_encoder(connector);
  260.  
  261.         for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
  262.                 if (connector->encoder_ids[i] == 0)
  263.                         break;
  264.  
  265.                 encoder = drm_encoder_find(connector->dev,
  266.                                            connector->encoder_ids[i]);
  267.                 if (!encoder)
  268.                         continue;
  269.  
  270.                 if ((encoder == best_encoder) && (status == connector_status_connected))
  271.                         connected = true;
  272.                 else
  273.                         connected = false;
  274.  
  275.                 if (rdev->is_atom_bios)
  276.                         radeon_atombios_connected_scratch_regs(connector, encoder, connected);
  277.                 else
  278.                         radeon_combios_connected_scratch_regs(connector, encoder, connected);
  279.  
  280.         }
  281. }
  282.  
  283. static struct drm_encoder *radeon_find_encoder(struct drm_connector *connector, int encoder_type)
  284. {
  285.         struct drm_encoder *encoder;
  286.         int i;
  287.  
  288.         for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
  289.                 if (connector->encoder_ids[i] == 0)
  290.                         break;
  291.  
  292.                 encoder = drm_encoder_find(connector->dev, connector->encoder_ids[i]);
  293.                 if (!encoder)
  294.                         continue;
  295.  
  296.                 if (encoder->encoder_type == encoder_type)
  297.                         return encoder;
  298.         }
  299.         return NULL;
  300. }
  301.  
  302. struct edid *radeon_connector_edid(struct drm_connector *connector)
  303. {
  304.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  305.         struct drm_property_blob *edid_blob = connector->edid_blob_ptr;
  306.  
  307.         if (radeon_connector->edid) {
  308.                 return radeon_connector->edid;
  309.         } else if (edid_blob) {
  310.                 struct edid *edid = kmemdup(edid_blob->data, edid_blob->length, GFP_KERNEL);
  311.                 if (edid)
  312.                         radeon_connector->edid = edid;
  313.         }
  314.         return radeon_connector->edid;
  315. }
  316.  
  317. static void radeon_connector_get_edid(struct drm_connector *connector)
  318. {
  319.         struct drm_device *dev = connector->dev;
  320.         struct radeon_device *rdev = dev->dev_private;
  321.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  322.  
  323.         if (radeon_connector->edid)
  324.                 return;
  325.  
  326.         /* on hw with routers, select right port */
  327.         if (radeon_connector->router.ddc_valid)
  328.                 radeon_router_select_ddc_port(radeon_connector);
  329.  
  330.         if ((radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
  331.              ENCODER_OBJECT_ID_NONE) &&
  332.             radeon_connector->ddc_bus->has_aux) {
  333.                 radeon_connector->edid = drm_get_edid(connector,
  334.                                                       &radeon_connector->ddc_bus->aux.ddc);
  335.         } else if ((connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort) ||
  336.                    (connector->connector_type == DRM_MODE_CONNECTOR_eDP)) {
  337.                 struct radeon_connector_atom_dig *dig = radeon_connector->con_priv;
  338.  
  339.                 if ((dig->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT ||
  340.                      dig->dp_sink_type == CONNECTOR_OBJECT_ID_eDP) &&
  341.                     radeon_connector->ddc_bus->has_aux)
  342.                         radeon_connector->edid = drm_get_edid(&radeon_connector->base,
  343.                                                               &radeon_connector->ddc_bus->aux.ddc);
  344.                 else if (radeon_connector->ddc_bus)
  345.                         radeon_connector->edid = drm_get_edid(&radeon_connector->base,
  346.                                                               &radeon_connector->ddc_bus->adapter);
  347.         } else if (radeon_connector->ddc_bus) {
  348.                 radeon_connector->edid = drm_get_edid(&radeon_connector->base,
  349.                                                       &radeon_connector->ddc_bus->adapter);
  350.         }
  351.  
  352.         if (!radeon_connector->edid) {
  353.                 /* don't fetch the edid from the vbios if ddc fails and runpm is
  354.                  * enabled so we report disconnected.
  355.                  */
  356.                 if ((rdev->flags & RADEON_IS_PX) && (radeon_runtime_pm != 0))
  357.                         return;
  358.  
  359.                 if (rdev->is_atom_bios) {
  360.                         /* some laptops provide a hardcoded edid in rom for LCDs */
  361.                         if (((connector->connector_type == DRM_MODE_CONNECTOR_LVDS) ||
  362.                              (connector->connector_type == DRM_MODE_CONNECTOR_eDP)))
  363.                                 radeon_connector->edid = radeon_bios_get_hardcoded_edid(rdev);
  364.                 } else {
  365.                         /* some servers provide a hardcoded edid in rom for KVMs */
  366.                         radeon_connector->edid = radeon_bios_get_hardcoded_edid(rdev);
  367.                 }
  368.         }
  369. }
  370.  
  371. static void radeon_connector_free_edid(struct drm_connector *connector)
  372. {
  373.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  374.  
  375.         if (radeon_connector->edid) {
  376.                 kfree(radeon_connector->edid);
  377.                 radeon_connector->edid = NULL;
  378.         }
  379. }
  380.  
  381. static int radeon_ddc_get_modes(struct drm_connector *connector)
  382. {
  383.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  384.         int ret;
  385.  
  386.         if (radeon_connector->edid) {
  387.                 drm_mode_connector_update_edid_property(connector, radeon_connector->edid);
  388.                 ret = drm_add_edid_modes(connector, radeon_connector->edid);
  389.                 drm_edid_to_eld(connector, radeon_connector->edid);
  390.                 return ret;
  391.         }
  392.         drm_mode_connector_update_edid_property(connector, NULL);
  393.         return 0;
  394. }
  395.  
  396. static struct drm_encoder *radeon_best_single_encoder(struct drm_connector *connector)
  397. {
  398.         int enc_id = connector->encoder_ids[0];
  399.         /* pick the encoder ids */
  400.         if (enc_id)
  401.                 return drm_encoder_find(connector->dev, enc_id);
  402.         return NULL;
  403. }
  404.  
  405. static void radeon_get_native_mode(struct drm_connector *connector)
  406. {
  407.         struct drm_encoder *encoder = radeon_best_single_encoder(connector);
  408.         struct radeon_encoder *radeon_encoder;
  409.  
  410.         if (encoder == NULL)
  411.                 return;
  412.  
  413.         radeon_encoder = to_radeon_encoder(encoder);
  414.  
  415.         if (!list_empty(&connector->probed_modes)) {
  416.                 struct drm_display_mode *preferred_mode =
  417.                         list_first_entry(&connector->probed_modes,
  418.                                          struct drm_display_mode, head);
  419.  
  420.                 radeon_encoder->native_mode = *preferred_mode;
  421.         } else {
  422.                 radeon_encoder->native_mode.clock = 0;
  423.         }
  424. }
  425.  
  426. /*
  427.  * radeon_connector_analog_encoder_conflict_solve
  428.  * - search for other connectors sharing this encoder
  429.  *   if priority is true, then set them disconnected if this is connected
  430.  *   if priority is false, set us disconnected if they are connected
  431.  */
  432. static enum drm_connector_status
  433. radeon_connector_analog_encoder_conflict_solve(struct drm_connector *connector,
  434.                                                struct drm_encoder *encoder,
  435.                                                enum drm_connector_status current_status,
  436.                                                bool priority)
  437. {
  438.         struct drm_device *dev = connector->dev;
  439.         struct drm_connector *conflict;
  440.         struct radeon_connector *radeon_conflict;
  441.         int i;
  442.  
  443.         list_for_each_entry(conflict, &dev->mode_config.connector_list, head) {
  444.                 if (conflict == connector)
  445.                         continue;
  446.  
  447.                 radeon_conflict = to_radeon_connector(conflict);
  448.                 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
  449.                         if (conflict->encoder_ids[i] == 0)
  450.                                 break;
  451.  
  452.                         /* if the IDs match */
  453.                         if (conflict->encoder_ids[i] == encoder->base.id) {
  454.                                 if (conflict->status != connector_status_connected)
  455.                                         continue;
  456.  
  457.                                 if (radeon_conflict->use_digital)
  458.                                         continue;
  459.  
  460.                                 if (priority == true) {
  461.                                         DRM_DEBUG_KMS("1: conflicting encoders switching off %s\n",
  462.                                                       conflict->name);
  463.                                         DRM_DEBUG_KMS("in favor of %s\n",
  464.                                                       connector->name);
  465.                                         conflict->status = connector_status_disconnected;
  466.                                         radeon_connector_update_scratch_regs(conflict, connector_status_disconnected);
  467.                                 } else {
  468.                                         DRM_DEBUG_KMS("2: conflicting encoders switching off %s\n",
  469.                                                       connector->name);
  470.                                         DRM_DEBUG_KMS("in favor of %s\n",
  471.                                                       conflict->name);
  472.                                         current_status = connector_status_disconnected;
  473.                                 }
  474.                                 break;
  475.                         }
  476.                 }
  477.         }
  478.         return current_status;
  479.  
  480. }
  481.  
  482. static struct drm_display_mode *radeon_fp_native_mode(struct drm_encoder *encoder)
  483. {
  484.         struct drm_device *dev = encoder->dev;
  485.         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
  486.         struct drm_display_mode *mode = NULL;
  487.         struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
  488.  
  489.         if (native_mode->hdisplay != 0 &&
  490.             native_mode->vdisplay != 0 &&
  491.             native_mode->clock != 0) {
  492.                 mode = drm_mode_duplicate(dev, native_mode);
  493.                 mode->type = DRM_MODE_TYPE_PREFERRED | DRM_MODE_TYPE_DRIVER;
  494.                 drm_mode_set_name(mode);
  495.  
  496.                 DRM_DEBUG_KMS("Adding native panel mode %s\n", mode->name);
  497.         } else if (native_mode->hdisplay != 0 &&
  498.                    native_mode->vdisplay != 0) {
  499.                 /* mac laptops without an edid */
  500.                 /* Note that this is not necessarily the exact panel mode,
  501.                  * but an approximation based on the cvt formula.  For these
  502.                  * systems we should ideally read the mode info out of the
  503.                  * registers or add a mode table, but this works and is much
  504.                  * simpler.
  505.                  */
  506.                 mode = drm_cvt_mode(dev, native_mode->hdisplay, native_mode->vdisplay, 60, true, false, false);
  507.                 mode->type = DRM_MODE_TYPE_PREFERRED | DRM_MODE_TYPE_DRIVER;
  508.                 DRM_DEBUG_KMS("Adding cvt approximation of native panel mode %s\n", mode->name);
  509.         }
  510.         return mode;
  511. }
  512.  
  513. static void radeon_add_common_modes(struct drm_encoder *encoder, struct drm_connector *connector)
  514. {
  515.         struct drm_device *dev = encoder->dev;
  516.         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
  517.         struct drm_display_mode *mode = NULL;
  518.         struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
  519.         int i;
  520.         struct mode_size {
  521.                 int w;
  522.                 int h;
  523.         } common_modes[17] = {
  524.                 { 640,  480},
  525.                 { 720,  480},
  526.                 { 800,  600},
  527.                 { 848,  480},
  528.                 {1024,  768},
  529.                 {1152,  768},
  530.                 {1280,  720},
  531.                 {1280,  800},
  532.                 {1280,  854},
  533.                 {1280,  960},
  534.                 {1280, 1024},
  535.                 {1440,  900},
  536.                 {1400, 1050},
  537.                 {1680, 1050},
  538.                 {1600, 1200},
  539.                 {1920, 1080},
  540.                 {1920, 1200}
  541.         };
  542.  
  543.         for (i = 0; i < 17; i++) {
  544.                 if (radeon_encoder->devices & (ATOM_DEVICE_TV_SUPPORT)) {
  545.                         if (common_modes[i].w > 1024 ||
  546.                             common_modes[i].h > 768)
  547.                                 continue;
  548.                 }
  549.                 if (radeon_encoder->devices & (ATOM_DEVICE_LCD_SUPPORT)) {
  550.                         if (common_modes[i].w > native_mode->hdisplay ||
  551.                             common_modes[i].h > native_mode->vdisplay ||
  552.                             (common_modes[i].w == native_mode->hdisplay &&
  553.                              common_modes[i].h == native_mode->vdisplay))
  554.                                 continue;
  555.                 }
  556.                 if (common_modes[i].w < 320 || common_modes[i].h < 200)
  557.                         continue;
  558.  
  559.                 mode = drm_cvt_mode(dev, common_modes[i].w, common_modes[i].h, 60, false, false, false);
  560.                 drm_mode_probed_add(connector, mode);
  561.         }
  562. }
  563.  
  564. static int radeon_connector_set_property(struct drm_connector *connector, struct drm_property *property,
  565.                                   uint64_t val)
  566. {
  567.         struct drm_device *dev = connector->dev;
  568.         struct radeon_device *rdev = dev->dev_private;
  569.         struct drm_encoder *encoder;
  570.         struct radeon_encoder *radeon_encoder;
  571.  
  572.         if (property == rdev->mode_info.coherent_mode_property) {
  573.                 struct radeon_encoder_atom_dig *dig;
  574.                 bool new_coherent_mode;
  575.  
  576.                 /* need to find digital encoder on connector */
  577.                 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
  578.                 if (!encoder)
  579.                         return 0;
  580.  
  581.                 radeon_encoder = to_radeon_encoder(encoder);
  582.  
  583.                 if (!radeon_encoder->enc_priv)
  584.                         return 0;
  585.  
  586.                 dig = radeon_encoder->enc_priv;
  587.                 new_coherent_mode = val ? true : false;
  588.                 if (dig->coherent_mode != new_coherent_mode) {
  589.                         dig->coherent_mode = new_coherent_mode;
  590.                         radeon_property_change_mode(&radeon_encoder->base);
  591.                 }
  592.         }
  593.  
  594.         if (property == rdev->mode_info.audio_property) {
  595.                 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  596.                 /* need to find digital encoder on connector */
  597.                 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
  598.                 if (!encoder)
  599.                         return 0;
  600.  
  601.                 radeon_encoder = to_radeon_encoder(encoder);
  602.  
  603.                 if (radeon_connector->audio != val) {
  604.                         radeon_connector->audio = val;
  605.                         radeon_property_change_mode(&radeon_encoder->base);
  606.                 }
  607.         }
  608.  
  609.         if (property == rdev->mode_info.dither_property) {
  610.                 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  611.                 /* need to find digital encoder on connector */
  612.                 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
  613.                 if (!encoder)
  614.                         return 0;
  615.  
  616.                 radeon_encoder = to_radeon_encoder(encoder);
  617.  
  618.                 if (radeon_connector->dither != val) {
  619.                         radeon_connector->dither = val;
  620.                         radeon_property_change_mode(&radeon_encoder->base);
  621.                 }
  622.         }
  623.  
  624.         if (property == rdev->mode_info.underscan_property) {
  625.                 /* need to find digital encoder on connector */
  626.                 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
  627.                 if (!encoder)
  628.                         return 0;
  629.  
  630.                 radeon_encoder = to_radeon_encoder(encoder);
  631.  
  632.                 if (radeon_encoder->underscan_type != val) {
  633.                         radeon_encoder->underscan_type = val;
  634.                         radeon_property_change_mode(&radeon_encoder->base);
  635.                 }
  636.         }
  637.  
  638.         if (property == rdev->mode_info.underscan_hborder_property) {
  639.                 /* need to find digital encoder on connector */
  640.                 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
  641.                 if (!encoder)
  642.                         return 0;
  643.  
  644.                 radeon_encoder = to_radeon_encoder(encoder);
  645.  
  646.                 if (radeon_encoder->underscan_hborder != val) {
  647.                         radeon_encoder->underscan_hborder = val;
  648.                         radeon_property_change_mode(&radeon_encoder->base);
  649.                 }
  650.         }
  651.  
  652.         if (property == rdev->mode_info.underscan_vborder_property) {
  653.                 /* need to find digital encoder on connector */
  654.                 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
  655.                 if (!encoder)
  656.                         return 0;
  657.  
  658.                 radeon_encoder = to_radeon_encoder(encoder);
  659.  
  660.                 if (radeon_encoder->underscan_vborder != val) {
  661.                         radeon_encoder->underscan_vborder = val;
  662.                         radeon_property_change_mode(&radeon_encoder->base);
  663.                 }
  664.         }
  665.  
  666.         if (property == rdev->mode_info.tv_std_property) {
  667.                 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TVDAC);
  668.                 if (!encoder) {
  669.                         encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_DAC);
  670.                 }
  671.  
  672.                 if (!encoder)
  673.                         return 0;
  674.  
  675.                 radeon_encoder = to_radeon_encoder(encoder);
  676.                 if (!radeon_encoder->enc_priv)
  677.                         return 0;
  678.                 if (ASIC_IS_AVIVO(rdev) || radeon_r4xx_atom) {
  679.                         struct radeon_encoder_atom_dac *dac_int;
  680.                         dac_int = radeon_encoder->enc_priv;
  681.                         dac_int->tv_std = val;
  682.                 } else {
  683.                         struct radeon_encoder_tv_dac *dac_int;
  684.                         dac_int = radeon_encoder->enc_priv;
  685.                         dac_int->tv_std = val;
  686.                 }
  687.                 radeon_property_change_mode(&radeon_encoder->base);
  688.         }
  689.  
  690.         if (property == rdev->mode_info.load_detect_property) {
  691.                 struct radeon_connector *radeon_connector =
  692.                         to_radeon_connector(connector);
  693.  
  694.                 if (val == 0)
  695.                         radeon_connector->dac_load_detect = false;
  696.                 else
  697.                         radeon_connector->dac_load_detect = true;
  698.         }
  699.  
  700.         if (property == rdev->mode_info.tmds_pll_property) {
  701.                 struct radeon_encoder_int_tmds *tmds = NULL;
  702.                 bool ret = false;
  703.                 /* need to find digital encoder on connector */
  704.                 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
  705.                 if (!encoder)
  706.                         return 0;
  707.  
  708.                 radeon_encoder = to_radeon_encoder(encoder);
  709.  
  710.                 tmds = radeon_encoder->enc_priv;
  711.                 if (!tmds)
  712.                         return 0;
  713.  
  714.                 if (val == 0) {
  715.                         if (rdev->is_atom_bios)
  716.                                 ret = radeon_atombios_get_tmds_info(radeon_encoder, tmds);
  717.                         else
  718.                                 ret = radeon_legacy_get_tmds_info_from_combios(radeon_encoder, tmds);
  719.                 }
  720.                 if (val == 1 || ret == false) {
  721.                         radeon_legacy_get_tmds_info_from_table(radeon_encoder, tmds);
  722.                 }
  723.                 radeon_property_change_mode(&radeon_encoder->base);
  724.         }
  725.  
  726.         if (property == dev->mode_config.scaling_mode_property) {
  727.                 enum radeon_rmx_type rmx_type;
  728.  
  729.                 if (connector->encoder)
  730.                         radeon_encoder = to_radeon_encoder(connector->encoder);
  731.                 else {
  732.                         const struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
  733.                         radeon_encoder = to_radeon_encoder(connector_funcs->best_encoder(connector));
  734.                 }
  735.  
  736.                 switch (val) {
  737.                 default:
  738.                 case DRM_MODE_SCALE_NONE: rmx_type = RMX_OFF; break;
  739.                 case DRM_MODE_SCALE_CENTER: rmx_type = RMX_CENTER; break;
  740.                 case DRM_MODE_SCALE_ASPECT: rmx_type = RMX_ASPECT; break;
  741.                 case DRM_MODE_SCALE_FULLSCREEN: rmx_type = RMX_FULL; break;
  742.                 }
  743.                 if (radeon_encoder->rmx_type == rmx_type)
  744.                         return 0;
  745.  
  746.                 if ((rmx_type != DRM_MODE_SCALE_NONE) &&
  747.                     (radeon_encoder->native_mode.clock == 0))
  748.                         return 0;
  749.  
  750.                 radeon_encoder->rmx_type = rmx_type;
  751.  
  752.                 radeon_property_change_mode(&radeon_encoder->base);
  753.         }
  754.  
  755.         if (property == rdev->mode_info.output_csc_property) {
  756.                 if (connector->encoder)
  757.                         radeon_encoder = to_radeon_encoder(connector->encoder);
  758.                 else {
  759.                         const struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
  760.                         radeon_encoder = to_radeon_encoder(connector_funcs->best_encoder(connector));
  761.                 }
  762.  
  763.                 if (radeon_encoder->output_csc == val)
  764.                         return 0;
  765.  
  766.                 radeon_encoder->output_csc = val;
  767.  
  768.                 if (connector->encoder->crtc) {
  769.                         struct drm_crtc *crtc  = connector->encoder->crtc;
  770.                         const struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
  771.                         struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc);
  772.  
  773.                         radeon_crtc->output_csc = radeon_encoder->output_csc;
  774.  
  775.                         (*crtc_funcs->load_lut)(crtc);
  776.                 }
  777.         }
  778.  
  779.         return 0;
  780. }
  781.  
  782. static void radeon_fixup_lvds_native_mode(struct drm_encoder *encoder,
  783.                                           struct drm_connector *connector)
  784. {
  785.         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
  786.         struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
  787.         struct drm_display_mode *t, *mode;
  788.  
  789.         /* If the EDID preferred mode doesn't match the native mode, use it */
  790.         list_for_each_entry_safe(mode, t, &connector->probed_modes, head) {
  791.                 if (mode->type & DRM_MODE_TYPE_PREFERRED) {
  792.                         if (mode->hdisplay != native_mode->hdisplay ||
  793.                             mode->vdisplay != native_mode->vdisplay)
  794.                                 memcpy(native_mode, mode, sizeof(*mode));
  795.                 }
  796.         }
  797.  
  798.         /* Try to get native mode details from EDID if necessary */
  799.         if (!native_mode->clock) {
  800.                 list_for_each_entry_safe(mode, t, &connector->probed_modes, head) {
  801.                         if (mode->hdisplay == native_mode->hdisplay &&
  802.                             mode->vdisplay == native_mode->vdisplay) {
  803.                                 *native_mode = *mode;
  804.                                 drm_mode_set_crtcinfo(native_mode, CRTC_INTERLACE_HALVE_V);
  805.                                 DRM_DEBUG_KMS("Determined LVDS native mode details from EDID\n");
  806.                                 break;
  807.                         }
  808.                 }
  809.         }
  810.  
  811.         if (!native_mode->clock) {
  812.                 DRM_DEBUG_KMS("No LVDS native mode details, disabling RMX\n");
  813.                 radeon_encoder->rmx_type = RMX_OFF;
  814.         }
  815. }
  816.  
  817. static int radeon_lvds_get_modes(struct drm_connector *connector)
  818. {
  819.         struct drm_encoder *encoder;
  820.         int ret = 0;
  821.         struct drm_display_mode *mode;
  822.  
  823.         radeon_connector_get_edid(connector);
  824.         ret = radeon_ddc_get_modes(connector);
  825.         if (ret > 0) {
  826.                 encoder = radeon_best_single_encoder(connector);
  827.                 if (encoder) {
  828.                         radeon_fixup_lvds_native_mode(encoder, connector);
  829.                         /* add scaled modes */
  830.                         radeon_add_common_modes(encoder, connector);
  831.                 }
  832.                 return ret;
  833.         }
  834.  
  835.         encoder = radeon_best_single_encoder(connector);
  836.         if (!encoder)
  837.                 return 0;
  838.  
  839.         /* we have no EDID modes */
  840.         mode = radeon_fp_native_mode(encoder);
  841.         if (mode) {
  842.                 ret = 1;
  843.                 drm_mode_probed_add(connector, mode);
  844.                 /* add the width/height from vbios tables if available */
  845.                 connector->display_info.width_mm = mode->width_mm;
  846.                 connector->display_info.height_mm = mode->height_mm;
  847.                 /* add scaled modes */
  848.                 radeon_add_common_modes(encoder, connector);
  849.         }
  850.  
  851.         return ret;
  852. }
  853.  
  854. static int radeon_lvds_mode_valid(struct drm_connector *connector,
  855.                                   struct drm_display_mode *mode)
  856. {
  857.         struct drm_encoder *encoder = radeon_best_single_encoder(connector);
  858.  
  859.         if ((mode->hdisplay < 320) || (mode->vdisplay < 240))
  860.                 return MODE_PANEL;
  861.  
  862.         if (encoder) {
  863.                 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
  864.                 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
  865.  
  866.                 /* AVIVO hardware supports downscaling modes larger than the panel
  867.                  * to the panel size, but I'm not sure this is desirable.
  868.                  */
  869.                 if ((mode->hdisplay > native_mode->hdisplay) ||
  870.                     (mode->vdisplay > native_mode->vdisplay))
  871.                         return MODE_PANEL;
  872.  
  873.                 /* if scaling is disabled, block non-native modes */
  874.                 if (radeon_encoder->rmx_type == RMX_OFF) {
  875.                         if ((mode->hdisplay != native_mode->hdisplay) ||
  876.                             (mode->vdisplay != native_mode->vdisplay))
  877.                                 return MODE_PANEL;
  878.                 }
  879.         }
  880.  
  881.         return MODE_OK;
  882. }
  883.  
  884. static enum drm_connector_status
  885. radeon_lvds_detect(struct drm_connector *connector, bool force)
  886. {
  887.         struct drm_device *dev = connector->dev;
  888.         struct radeon_device *rdev = dev->dev_private;
  889.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  890.         struct drm_encoder *encoder = radeon_best_single_encoder(connector);
  891.         enum drm_connector_status ret = connector_status_disconnected;
  892.  
  893.         if (encoder) {
  894.                 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
  895.                 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
  896.  
  897.                 /* check if panel is valid */
  898.                 if (native_mode->hdisplay >= 320 && native_mode->vdisplay >= 240)
  899.                         ret = connector_status_connected;
  900.                 /* don't fetch the edid from the vbios if ddc fails and runpm is
  901.                  * enabled so we report disconnected.
  902.                  */
  903.                 if ((rdev->flags & RADEON_IS_PX) && (radeon_runtime_pm != 0))
  904.                         ret = connector_status_disconnected;
  905.         }
  906.  
  907.         /* check for edid as well */
  908.         radeon_connector_get_edid(connector);
  909.         if (radeon_connector->edid)
  910.                 ret = connector_status_connected;
  911.         /* check acpi lid status ??? */
  912.  
  913.         radeon_connector_update_scratch_regs(connector, ret);
  914.         return ret;
  915. }
  916.  
  917. static void radeon_connector_destroy(struct drm_connector *connector)
  918. {
  919.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  920.  
  921.         radeon_connector_free_edid(connector);
  922.         kfree(radeon_connector->con_priv);
  923.         drm_connector_unregister(connector);
  924.         drm_connector_cleanup(connector);
  925.         kfree(connector);
  926. }
  927.  
  928. static int radeon_lvds_set_property(struct drm_connector *connector,
  929.                                     struct drm_property *property,
  930.                                     uint64_t value)
  931. {
  932.         struct drm_device *dev = connector->dev;
  933.         struct radeon_encoder *radeon_encoder;
  934.         enum radeon_rmx_type rmx_type;
  935.  
  936.         DRM_DEBUG_KMS("\n");
  937.         if (property != dev->mode_config.scaling_mode_property)
  938.                 return 0;
  939.  
  940.         if (connector->encoder)
  941.                 radeon_encoder = to_radeon_encoder(connector->encoder);
  942.         else {
  943.                 const struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
  944.                 radeon_encoder = to_radeon_encoder(connector_funcs->best_encoder(connector));
  945.         }
  946.  
  947.         switch (value) {
  948.         case DRM_MODE_SCALE_NONE: rmx_type = RMX_OFF; break;
  949.         case DRM_MODE_SCALE_CENTER: rmx_type = RMX_CENTER; break;
  950.         case DRM_MODE_SCALE_ASPECT: rmx_type = RMX_ASPECT; break;
  951.         default:
  952.         case DRM_MODE_SCALE_FULLSCREEN: rmx_type = RMX_FULL; break;
  953.         }
  954.         if (radeon_encoder->rmx_type == rmx_type)
  955.                 return 0;
  956.  
  957.         radeon_encoder->rmx_type = rmx_type;
  958.  
  959.         radeon_property_change_mode(&radeon_encoder->base);
  960.         return 0;
  961. }
  962.  
  963.  
  964. static const struct drm_connector_helper_funcs radeon_lvds_connector_helper_funcs = {
  965.         .get_modes = radeon_lvds_get_modes,
  966.         .mode_valid = radeon_lvds_mode_valid,
  967.         .best_encoder = radeon_best_single_encoder,
  968. };
  969.  
  970. static const struct drm_connector_funcs radeon_lvds_connector_funcs = {
  971.         .dpms = drm_helper_connector_dpms,
  972.         .detect = radeon_lvds_detect,
  973.         .fill_modes = drm_helper_probe_single_connector_modes,
  974.         .destroy = radeon_connector_destroy,
  975.         .set_property = radeon_lvds_set_property,
  976. };
  977.  
  978. static int radeon_vga_get_modes(struct drm_connector *connector)
  979. {
  980.         int ret;
  981.  
  982.         radeon_connector_get_edid(connector);
  983.         ret = radeon_ddc_get_modes(connector);
  984.  
  985.         radeon_get_native_mode(connector);
  986.  
  987.         return ret;
  988. }
  989.  
  990. static int radeon_vga_mode_valid(struct drm_connector *connector,
  991.                                   struct drm_display_mode *mode)
  992. {
  993.         struct drm_device *dev = connector->dev;
  994.         struct radeon_device *rdev = dev->dev_private;
  995.  
  996.         /* XXX check mode bandwidth */
  997.  
  998.         if ((mode->clock / 10) > rdev->clock.max_pixel_clock)
  999.                 return MODE_CLOCK_HIGH;
  1000.  
  1001.         return MODE_OK;
  1002. }
  1003.  
  1004. static enum drm_connector_status
  1005. radeon_vga_detect(struct drm_connector *connector, bool force)
  1006. {
  1007.         struct drm_device *dev = connector->dev;
  1008.         struct radeon_device *rdev = dev->dev_private;
  1009.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  1010.         struct drm_encoder *encoder;
  1011.         const struct drm_encoder_helper_funcs *encoder_funcs;
  1012.         bool dret = false;
  1013.         enum drm_connector_status ret = connector_status_disconnected;
  1014.  
  1015.         encoder = radeon_best_single_encoder(connector);
  1016.         if (!encoder)
  1017.                 ret = connector_status_disconnected;
  1018.  
  1019.         if (radeon_connector->ddc_bus)
  1020.                 dret = radeon_ddc_probe(radeon_connector, false);
  1021.         if (dret) {
  1022.                 radeon_connector->detected_by_load = false;
  1023.                 radeon_connector_free_edid(connector);
  1024.                 radeon_connector_get_edid(connector);
  1025.  
  1026.                 if (!radeon_connector->edid) {
  1027.                         DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
  1028.                                         connector->name);
  1029.                         ret = connector_status_connected;
  1030.                 } else {
  1031.                         radeon_connector->use_digital =
  1032.                                 !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
  1033.  
  1034.                         /* some oems have boards with separate digital and analog connectors
  1035.                          * with a shared ddc line (often vga + hdmi)
  1036.                          */
  1037.                         if (radeon_connector->use_digital && radeon_connector->shared_ddc) {
  1038.                                 radeon_connector_free_edid(connector);
  1039.                                 ret = connector_status_disconnected;
  1040.                         } else {
  1041.                                 ret = connector_status_connected;
  1042.                         }
  1043.                 }
  1044.         } else {
  1045.  
  1046.                 /* if we aren't forcing don't do destructive polling */
  1047.                 if (!force) {
  1048.                         /* only return the previous status if we last
  1049.                          * detected a monitor via load.
  1050.                          */
  1051.                         if (radeon_connector->detected_by_load)
  1052.                                 ret = connector->status;
  1053.                         goto out;
  1054.                 }
  1055.  
  1056.                 if (radeon_connector->dac_load_detect && encoder) {
  1057.                         encoder_funcs = encoder->helper_private;
  1058.                         ret = encoder_funcs->detect(encoder, connector);
  1059.                         if (ret != connector_status_disconnected)
  1060.                                 radeon_connector->detected_by_load = true;
  1061.                 }
  1062.         }
  1063.  
  1064.         if (ret == connector_status_connected)
  1065.                 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
  1066.  
  1067.         /* RN50 and some RV100 asics in servers often have a hardcoded EDID in the
  1068.          * vbios to deal with KVMs. If we have one and are not able to detect a monitor
  1069.          * by other means, assume the CRT is connected and use that EDID.
  1070.          */
  1071.         if ((!rdev->is_atom_bios) &&
  1072.             (ret == connector_status_disconnected) &&
  1073.             rdev->mode_info.bios_hardcoded_edid_size) {
  1074.                 ret = connector_status_connected;
  1075.         }
  1076.  
  1077.         radeon_connector_update_scratch_regs(connector, ret);
  1078.  
  1079. out:
  1080.         return ret;
  1081. }
  1082.  
  1083. static const struct drm_connector_helper_funcs radeon_vga_connector_helper_funcs = {
  1084.         .get_modes = radeon_vga_get_modes,
  1085.         .mode_valid = radeon_vga_mode_valid,
  1086.         .best_encoder = radeon_best_single_encoder,
  1087. };
  1088.  
  1089. static const struct drm_connector_funcs radeon_vga_connector_funcs = {
  1090.         .dpms = drm_helper_connector_dpms,
  1091.         .detect = radeon_vga_detect,
  1092.         .fill_modes = drm_helper_probe_single_connector_modes,
  1093.         .destroy = radeon_connector_destroy,
  1094.         .set_property = radeon_connector_set_property,
  1095. };
  1096.  
  1097. static int radeon_tv_get_modes(struct drm_connector *connector)
  1098. {
  1099.         struct drm_device *dev = connector->dev;
  1100.         struct radeon_device *rdev = dev->dev_private;
  1101.         struct drm_display_mode *tv_mode;
  1102.         struct drm_encoder *encoder;
  1103.  
  1104.         encoder = radeon_best_single_encoder(connector);
  1105.         if (!encoder)
  1106.                 return 0;
  1107.  
  1108.         /* avivo chips can scale any mode */
  1109.         if (rdev->family >= CHIP_RS600)
  1110.                 /* add scaled modes */
  1111.                 radeon_add_common_modes(encoder, connector);
  1112.         else {
  1113.                 /* only 800x600 is supported right now on pre-avivo chips */
  1114.                 tv_mode = drm_cvt_mode(dev, 800, 600, 60, false, false, false);
  1115.                 tv_mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
  1116.                 drm_mode_probed_add(connector, tv_mode);
  1117.         }
  1118.         return 1;
  1119. }
  1120.  
  1121. static int radeon_tv_mode_valid(struct drm_connector *connector,
  1122.                                 struct drm_display_mode *mode)
  1123. {
  1124.         if ((mode->hdisplay > 1024) || (mode->vdisplay > 768))
  1125.                 return MODE_CLOCK_RANGE;
  1126.         return MODE_OK;
  1127. }
  1128.  
  1129. static enum drm_connector_status
  1130. radeon_tv_detect(struct drm_connector *connector, bool force)
  1131. {
  1132.         struct drm_encoder *encoder;
  1133.         const struct drm_encoder_helper_funcs *encoder_funcs;
  1134.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  1135.         enum drm_connector_status ret = connector_status_disconnected;
  1136.         int r;
  1137.  
  1138.         if (!radeon_connector->dac_load_detect)
  1139.                 return ret;
  1140.  
  1141.         r = pm_runtime_get_sync(connector->dev->dev);
  1142.         if (r < 0)
  1143.                 return connector_status_disconnected;
  1144.  
  1145.         encoder = radeon_best_single_encoder(connector);
  1146.         if (!encoder)
  1147.                 ret = connector_status_disconnected;
  1148.         else {
  1149.                 encoder_funcs = encoder->helper_private;
  1150.                 ret = encoder_funcs->detect(encoder, connector);
  1151.         }
  1152.         if (ret == connector_status_connected)
  1153.                 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, false);
  1154.         radeon_connector_update_scratch_regs(connector, ret);
  1155.         pm_runtime_mark_last_busy(connector->dev->dev);
  1156.         pm_runtime_put_autosuspend(connector->dev->dev);
  1157.         return ret;
  1158. }
  1159.  
  1160. static const struct drm_connector_helper_funcs radeon_tv_connector_helper_funcs = {
  1161.         .get_modes = radeon_tv_get_modes,
  1162.         .mode_valid = radeon_tv_mode_valid,
  1163.         .best_encoder = radeon_best_single_encoder,
  1164. };
  1165.  
  1166. static const struct drm_connector_funcs radeon_tv_connector_funcs = {
  1167.         .dpms = drm_helper_connector_dpms,
  1168.         .detect = radeon_tv_detect,
  1169.         .fill_modes = drm_helper_probe_single_connector_modes,
  1170.         .destroy = radeon_connector_destroy,
  1171.         .set_property = radeon_connector_set_property,
  1172. };
  1173.  
  1174. static bool radeon_check_hpd_status_unchanged(struct drm_connector *connector)
  1175. {
  1176.         struct drm_device *dev = connector->dev;
  1177.         struct radeon_device *rdev = dev->dev_private;
  1178.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  1179.         enum drm_connector_status status;
  1180.  
  1181.         /* We only trust HPD on R600 and newer ASICS. */
  1182.         if (rdev->family >= CHIP_R600
  1183.           && radeon_connector->hpd.hpd != RADEON_HPD_NONE) {
  1184.                 if (radeon_hpd_sense(rdev, radeon_connector->hpd.hpd))
  1185.                         status = connector_status_connected;
  1186.                 else
  1187.                         status = connector_status_disconnected;
  1188.                 if (connector->status == status)
  1189.                         return true;
  1190.         }
  1191.  
  1192.         return false;
  1193. }
  1194.  
  1195. /*
  1196.  * DVI is complicated
  1197.  * Do a DDC probe, if DDC probe passes, get the full EDID so
  1198.  * we can do analog/digital monitor detection at this point.
  1199.  * If the monitor is an analog monitor or we got no DDC,
  1200.  * we need to find the DAC encoder object for this connector.
  1201.  * If we got no DDC, we do load detection on the DAC encoder object.
  1202.  * If we got analog DDC or load detection passes on the DAC encoder
  1203.  * we have to check if this analog encoder is shared with anyone else (TV)
  1204.  * if its shared we have to set the other connector to disconnected.
  1205.  */
  1206. static enum drm_connector_status
  1207. radeon_dvi_detect(struct drm_connector *connector, bool force)
  1208. {
  1209.         struct drm_device *dev = connector->dev;
  1210.         struct radeon_device *rdev = dev->dev_private;
  1211.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  1212.         struct drm_encoder *encoder = NULL;
  1213.         const struct drm_encoder_helper_funcs *encoder_funcs;
  1214.         int i, r;
  1215.         enum drm_connector_status ret = connector_status_disconnected;
  1216.         bool dret = false, broken_edid = false;
  1217.  
  1218.         r = pm_runtime_get_sync(connector->dev->dev);
  1219.         if (r < 0)
  1220.                 return connector_status_disconnected;
  1221.  
  1222.         if (radeon_connector->detected_hpd_without_ddc) {
  1223.                 force = true;
  1224.                 radeon_connector->detected_hpd_without_ddc = false;
  1225.         }
  1226.  
  1227.         if (!force && radeon_check_hpd_status_unchanged(connector)) {
  1228.                 ret = connector->status;
  1229.                 goto exit;
  1230.         }
  1231.  
  1232.         if (radeon_connector->ddc_bus) {
  1233.                 dret = radeon_ddc_probe(radeon_connector, false);
  1234.         }
  1235.         if (dret) {
  1236.                 radeon_connector->detected_by_load = false;
  1237.                 radeon_connector_free_edid(connector);
  1238.                 radeon_connector_get_edid(connector);
  1239.  
  1240.                 if (!radeon_connector->edid) {
  1241.                         DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
  1242.                                         connector->name);
  1243.                         /* rs690 seems to have a problem with connectors not existing and always
  1244.                          * return a block of 0's. If we see this just stop polling on this output */
  1245.                         if ((rdev->family == CHIP_RS690 || rdev->family == CHIP_RS740) &&
  1246.                             radeon_connector->base.null_edid_counter) {
  1247.                                 ret = connector_status_disconnected;
  1248.                                 DRM_ERROR("%s: detected RS690 floating bus bug, stopping ddc detect\n",
  1249.                                           connector->name);
  1250.                                 radeon_connector->ddc_bus = NULL;
  1251.                         } else {
  1252.                                 ret = connector_status_connected;
  1253.                                 broken_edid = true; /* defer use_digital to later */
  1254.                         }
  1255.                 } else {
  1256.                         radeon_connector->use_digital =
  1257.                                 !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
  1258.  
  1259.                         /* some oems have boards with separate digital and analog connectors
  1260.                          * with a shared ddc line (often vga + hdmi)
  1261.                          */
  1262.                         if ((!radeon_connector->use_digital) && radeon_connector->shared_ddc) {
  1263.                                 radeon_connector_free_edid(connector);
  1264.                                 ret = connector_status_disconnected;
  1265.                         } else {
  1266.                                 ret = connector_status_connected;
  1267.                         }
  1268.                         /* This gets complicated.  We have boards with VGA + HDMI with a
  1269.                          * shared DDC line and we have boards with DVI-D + HDMI with a shared
  1270.                          * DDC line.  The latter is more complex because with DVI<->HDMI adapters
  1271.                          * you don't really know what's connected to which port as both are digital.
  1272.                          */
  1273.                         if (radeon_connector->shared_ddc && (ret == connector_status_connected)) {
  1274.                                 struct drm_connector *list_connector;
  1275.                                 struct radeon_connector *list_radeon_connector;
  1276.                                 list_for_each_entry(list_connector, &dev->mode_config.connector_list, head) {
  1277.                                         if (connector == list_connector)
  1278.                                                 continue;
  1279.                                         list_radeon_connector = to_radeon_connector(list_connector);
  1280.                                         if (list_radeon_connector->shared_ddc &&
  1281.                                             (list_radeon_connector->ddc_bus->rec.i2c_id ==
  1282.                                              radeon_connector->ddc_bus->rec.i2c_id)) {
  1283.                                                 /* cases where both connectors are digital */
  1284.                                                 if (list_connector->connector_type != DRM_MODE_CONNECTOR_VGA) {
  1285.                                                         /* hpd is our only option in this case */
  1286.                                                         if (!radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) {
  1287.                                                                 radeon_connector_free_edid(connector);
  1288.                                                                 ret = connector_status_disconnected;
  1289.                                                         }
  1290.                                                 }
  1291.                                         }
  1292.                                 }
  1293.                         }
  1294.                 }
  1295.         }
  1296.  
  1297.         if ((ret == connector_status_connected) && (radeon_connector->use_digital == true))
  1298.                 goto out;
  1299.  
  1300.         /* DVI-D and HDMI-A are digital only */
  1301.         if ((connector->connector_type == DRM_MODE_CONNECTOR_DVID) ||
  1302.             (connector->connector_type == DRM_MODE_CONNECTOR_HDMIA))
  1303.                 goto out;
  1304.  
  1305.         /* if we aren't forcing don't do destructive polling */
  1306.         if (!force) {
  1307.                 /* only return the previous status if we last
  1308.                  * detected a monitor via load.
  1309.                  */
  1310.                 if (radeon_connector->detected_by_load)
  1311.                         ret = connector->status;
  1312.                 goto out;
  1313.         }
  1314.  
  1315.         /* find analog encoder */
  1316.         if (radeon_connector->dac_load_detect) {
  1317.                 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
  1318.                         if (connector->encoder_ids[i] == 0)
  1319.                                 break;
  1320.  
  1321.                         encoder = drm_encoder_find(connector->dev,
  1322.                                                    connector->encoder_ids[i]);
  1323.                         if (!encoder)
  1324.                                 continue;
  1325.  
  1326.                         if (encoder->encoder_type != DRM_MODE_ENCODER_DAC &&
  1327.                             encoder->encoder_type != DRM_MODE_ENCODER_TVDAC)
  1328.                                 continue;
  1329.  
  1330.                         encoder_funcs = encoder->helper_private;
  1331.                         if (encoder_funcs->detect) {
  1332.                                 if (!broken_edid) {
  1333.                                         if (ret != connector_status_connected) {
  1334.                                                 /* deal with analog monitors without DDC */
  1335.                                                 ret = encoder_funcs->detect(encoder, connector);
  1336.                                                 if (ret == connector_status_connected) {
  1337.                                                         radeon_connector->use_digital = false;
  1338.                                                 }
  1339.                                                 if (ret != connector_status_disconnected)
  1340.                                                         radeon_connector->detected_by_load = true;
  1341.                                         }
  1342.                                 } else {
  1343.                                         enum drm_connector_status lret;
  1344.                                         /* assume digital unless load detected otherwise */
  1345.                                         radeon_connector->use_digital = true;
  1346.                                         lret = encoder_funcs->detect(encoder, connector);
  1347.                                         DRM_DEBUG_KMS("load_detect %x returned: %x\n",encoder->encoder_type,lret);
  1348.                                         if (lret == connector_status_connected)
  1349.                                                 radeon_connector->use_digital = false;
  1350.                                 }
  1351.                                 break;
  1352.                         }
  1353.                 }
  1354.         }
  1355.  
  1356.         if ((ret == connector_status_connected) && (radeon_connector->use_digital == false) &&
  1357.             encoder) {
  1358.                 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
  1359.         }
  1360.  
  1361.         /* RN50 and some RV100 asics in servers often have a hardcoded EDID in the
  1362.          * vbios to deal with KVMs. If we have one and are not able to detect a monitor
  1363.          * by other means, assume the DFP is connected and use that EDID.  In most
  1364.          * cases the DVI port is actually a virtual KVM port connected to the service
  1365.          * processor.
  1366.          */
  1367. out:
  1368.         if ((!rdev->is_atom_bios) &&
  1369.             (ret == connector_status_disconnected) &&
  1370.             rdev->mode_info.bios_hardcoded_edid_size) {
  1371.                 radeon_connector->use_digital = true;
  1372.                 ret = connector_status_connected;
  1373.         }
  1374.  
  1375.         /* updated in get modes as well since we need to know if it's analog or digital */
  1376.         radeon_connector_update_scratch_regs(connector, ret);
  1377.  
  1378.         if ((radeon_audio != 0) && radeon_connector->use_digital) {
  1379.                 const struct drm_connector_helper_funcs *connector_funcs =
  1380.                         connector->helper_private;
  1381.  
  1382.                 encoder = connector_funcs->best_encoder(connector);
  1383.                 if (encoder && (encoder->encoder_type == DRM_MODE_ENCODER_TMDS)) {
  1384.                         radeon_connector_get_edid(connector);
  1385.                         radeon_audio_detect(connector, encoder, ret);
  1386.                 }
  1387.         }
  1388.  
  1389. exit:
  1390.         pm_runtime_mark_last_busy(connector->dev->dev);
  1391.         pm_runtime_put_autosuspend(connector->dev->dev);
  1392.  
  1393.         return ret;
  1394. }
  1395.  
  1396. /* okay need to be smart in here about which encoder to pick */
  1397. static struct drm_encoder *radeon_dvi_encoder(struct drm_connector *connector)
  1398. {
  1399.         int enc_id = connector->encoder_ids[0];
  1400.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  1401.         struct drm_encoder *encoder;
  1402.         int i;
  1403.         for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
  1404.                 if (connector->encoder_ids[i] == 0)
  1405.                         break;
  1406.  
  1407.                 encoder = drm_encoder_find(connector->dev, connector->encoder_ids[i]);
  1408.                 if (!encoder)
  1409.                         continue;
  1410.  
  1411.                 if (radeon_connector->use_digital == true) {
  1412.                         if (encoder->encoder_type == DRM_MODE_ENCODER_TMDS)
  1413.                                 return encoder;
  1414.                 } else {
  1415.                         if (encoder->encoder_type == DRM_MODE_ENCODER_DAC ||
  1416.                             encoder->encoder_type == DRM_MODE_ENCODER_TVDAC)
  1417.                                 return encoder;
  1418.                 }
  1419.         }
  1420.  
  1421.         /* see if we have a default encoder  TODO */
  1422.  
  1423.         /* then check use digitial */
  1424.         /* pick the first one */
  1425.         if (enc_id)
  1426.                 return drm_encoder_find(connector->dev, enc_id);
  1427.         return NULL;
  1428. }
  1429.  
  1430. static void radeon_dvi_force(struct drm_connector *connector)
  1431. {
  1432.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  1433.         if (connector->force == DRM_FORCE_ON)
  1434.                 radeon_connector->use_digital = false;
  1435.         if (connector->force == DRM_FORCE_ON_DIGITAL)
  1436.                 radeon_connector->use_digital = true;
  1437. }
  1438.  
  1439. static int radeon_dvi_mode_valid(struct drm_connector *connector,
  1440.                                   struct drm_display_mode *mode)
  1441. {
  1442.         struct drm_device *dev = connector->dev;
  1443.         struct radeon_device *rdev = dev->dev_private;
  1444.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  1445.  
  1446.         /* XXX check mode bandwidth */
  1447.  
  1448.         /* clocks over 135 MHz have heat issues with DVI on RV100 */
  1449.         if (radeon_connector->use_digital &&
  1450.             (rdev->family == CHIP_RV100) &&
  1451.             (mode->clock > 135000))
  1452.                 return MODE_CLOCK_HIGH;
  1453.  
  1454.         if (radeon_connector->use_digital && (mode->clock > 165000)) {
  1455.                 if ((radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_I) ||
  1456.                     (radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_D) ||
  1457.                     (radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_HDMI_TYPE_B))
  1458.                         return MODE_OK;
  1459.                 else if (ASIC_IS_DCE6(rdev) && drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
  1460.                         /* HDMI 1.3+ supports max clock of 340 Mhz */
  1461.                         if (mode->clock > 340000)
  1462.                                 return MODE_CLOCK_HIGH;
  1463.                         else
  1464.                                 return MODE_OK;
  1465.                 } else {
  1466.                         return MODE_CLOCK_HIGH;
  1467.                 }
  1468.         }
  1469.  
  1470.         /* check against the max pixel clock */
  1471.         if ((mode->clock / 10) > rdev->clock.max_pixel_clock)
  1472.                 return MODE_CLOCK_HIGH;
  1473.  
  1474.         return MODE_OK;
  1475. }
  1476.  
  1477. static const struct drm_connector_helper_funcs radeon_dvi_connector_helper_funcs = {
  1478.         .get_modes = radeon_vga_get_modes,
  1479.         .mode_valid = radeon_dvi_mode_valid,
  1480.         .best_encoder = radeon_dvi_encoder,
  1481. };
  1482.  
  1483. static const struct drm_connector_funcs radeon_dvi_connector_funcs = {
  1484.         .dpms = drm_helper_connector_dpms,
  1485.         .detect = radeon_dvi_detect,
  1486.         .fill_modes = drm_helper_probe_single_connector_modes,
  1487.         .set_property = radeon_connector_set_property,
  1488.         .destroy = radeon_connector_destroy,
  1489.         .force = radeon_dvi_force,
  1490. };
  1491.  
  1492. static int radeon_dp_get_modes(struct drm_connector *connector)
  1493. {
  1494.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  1495.         struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
  1496.         struct drm_encoder *encoder = radeon_best_single_encoder(connector);
  1497.         int ret;
  1498.  
  1499.         if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) ||
  1500.             (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
  1501.                 struct drm_display_mode *mode;
  1502.  
  1503.                 if (connector->connector_type == DRM_MODE_CONNECTOR_eDP) {
  1504.                         if (!radeon_dig_connector->edp_on)
  1505.                                 atombios_set_edp_panel_power(connector,
  1506.                                                              ATOM_TRANSMITTER_ACTION_POWER_ON);
  1507.                         radeon_connector_get_edid(connector);
  1508.                         ret = radeon_ddc_get_modes(connector);
  1509.                         if (!radeon_dig_connector->edp_on)
  1510.                                 atombios_set_edp_panel_power(connector,
  1511.                                                              ATOM_TRANSMITTER_ACTION_POWER_OFF);
  1512.                 } else {
  1513.                         /* need to setup ddc on the bridge */
  1514.                         if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
  1515.                             ENCODER_OBJECT_ID_NONE) {
  1516.                                 if (encoder)
  1517.                                         radeon_atom_ext_encoder_setup_ddc(encoder);
  1518.                         }
  1519.                         radeon_connector_get_edid(connector);
  1520.                         ret = radeon_ddc_get_modes(connector);
  1521.                 }
  1522.  
  1523.                 if (ret > 0) {
  1524.                         if (encoder) {
  1525.                                 radeon_fixup_lvds_native_mode(encoder, connector);
  1526.                                 /* add scaled modes */
  1527.                                 radeon_add_common_modes(encoder, connector);
  1528.                         }
  1529.                         return ret;
  1530.                 }
  1531.  
  1532.                 if (!encoder)
  1533.                         return 0;
  1534.  
  1535.                 /* we have no EDID modes */
  1536.                 mode = radeon_fp_native_mode(encoder);
  1537.                 if (mode) {
  1538.                         ret = 1;
  1539.                         drm_mode_probed_add(connector, mode);
  1540.                         /* add the width/height from vbios tables if available */
  1541.                         connector->display_info.width_mm = mode->width_mm;
  1542.                         connector->display_info.height_mm = mode->height_mm;
  1543.                         /* add scaled modes */
  1544.                         radeon_add_common_modes(encoder, connector);
  1545.                 }
  1546.         } else {
  1547.                 /* need to setup ddc on the bridge */
  1548.                 if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
  1549.                         ENCODER_OBJECT_ID_NONE) {
  1550.                         if (encoder)
  1551.                                 radeon_atom_ext_encoder_setup_ddc(encoder);
  1552.                 }
  1553.                 radeon_connector_get_edid(connector);
  1554.                 ret = radeon_ddc_get_modes(connector);
  1555.  
  1556.                 radeon_get_native_mode(connector);
  1557.         }
  1558.  
  1559.         return ret;
  1560. }
  1561.  
  1562. u16 radeon_connector_encoder_get_dp_bridge_encoder_id(struct drm_connector *connector)
  1563. {
  1564.         struct drm_encoder *encoder;
  1565.         struct radeon_encoder *radeon_encoder;
  1566.         int i;
  1567.  
  1568.         for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
  1569.                 if (connector->encoder_ids[i] == 0)
  1570.                         break;
  1571.  
  1572.                 encoder = drm_encoder_find(connector->dev, connector->encoder_ids[i]);
  1573.                 if (!encoder)
  1574.                         continue;
  1575.  
  1576.                 radeon_encoder = to_radeon_encoder(encoder);
  1577.  
  1578.                 switch (radeon_encoder->encoder_id) {
  1579.                 case ENCODER_OBJECT_ID_TRAVIS:
  1580.                 case ENCODER_OBJECT_ID_NUTMEG:
  1581.                         return radeon_encoder->encoder_id;
  1582.                 default:
  1583.                         break;
  1584.                 }
  1585.         }
  1586.  
  1587.         return ENCODER_OBJECT_ID_NONE;
  1588. }
  1589.  
  1590. static bool radeon_connector_encoder_is_hbr2(struct drm_connector *connector)
  1591. {
  1592.         struct drm_encoder *encoder;
  1593.         struct radeon_encoder *radeon_encoder;
  1594.         int i;
  1595.         bool found = false;
  1596.  
  1597.         for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
  1598.                 if (connector->encoder_ids[i] == 0)
  1599.                         break;
  1600.  
  1601.                 encoder = drm_encoder_find(connector->dev, connector->encoder_ids[i]);
  1602.                 if (!encoder)
  1603.                         continue;
  1604.  
  1605.                 radeon_encoder = to_radeon_encoder(encoder);
  1606.                 if (radeon_encoder->caps & ATOM_ENCODER_CAP_RECORD_HBR2)
  1607.                         found = true;
  1608.         }
  1609.  
  1610.         return found;
  1611. }
  1612.  
  1613. bool radeon_connector_is_dp12_capable(struct drm_connector *connector)
  1614. {
  1615.         struct drm_device *dev = connector->dev;
  1616.         struct radeon_device *rdev = dev->dev_private;
  1617.  
  1618.         if (ASIC_IS_DCE5(rdev) &&
  1619.             (rdev->clock.default_dispclk >= 53900) &&
  1620.             radeon_connector_encoder_is_hbr2(connector)) {
  1621.                 return true;
  1622.         }
  1623.  
  1624.         return false;
  1625. }
  1626.  
  1627. static enum drm_connector_status
  1628. radeon_dp_detect(struct drm_connector *connector, bool force)
  1629. {
  1630.         struct drm_device *dev = connector->dev;
  1631.         struct radeon_device *rdev = dev->dev_private;
  1632.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  1633.         enum drm_connector_status ret = connector_status_disconnected;
  1634.         struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
  1635.         struct drm_encoder *encoder = radeon_best_single_encoder(connector);
  1636.         int r;
  1637.  
  1638.         if (radeon_dig_connector->is_mst)
  1639.                 return connector_status_disconnected;
  1640.  
  1641.         r = pm_runtime_get_sync(connector->dev->dev);
  1642.         if (r < 0)
  1643.                 return connector_status_disconnected;
  1644.  
  1645.         if (!force && radeon_check_hpd_status_unchanged(connector)) {
  1646.                 ret = connector->status;
  1647.                 goto out;
  1648.         }
  1649.  
  1650.         radeon_connector_free_edid(connector);
  1651.  
  1652.         if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) ||
  1653.             (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
  1654.                 if (encoder) {
  1655.                         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
  1656.                         struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
  1657.  
  1658.                         /* check if panel is valid */
  1659.                         if (native_mode->hdisplay >= 320 && native_mode->vdisplay >= 240)
  1660.                                 ret = connector_status_connected;
  1661.                         /* don't fetch the edid from the vbios if ddc fails and runpm is
  1662.                          * enabled so we report disconnected.
  1663.                          */
  1664.                         if ((rdev->flags & RADEON_IS_PX) && (radeon_runtime_pm != 0))
  1665.                                 ret = connector_status_disconnected;
  1666.                 }
  1667.                 /* eDP is always DP */
  1668.                 radeon_dig_connector->dp_sink_type = CONNECTOR_OBJECT_ID_DISPLAYPORT;
  1669.                 if (!radeon_dig_connector->edp_on)
  1670.                         atombios_set_edp_panel_power(connector,
  1671.                                                      ATOM_TRANSMITTER_ACTION_POWER_ON);
  1672.                 if (radeon_dp_getdpcd(radeon_connector))
  1673.                         ret = connector_status_connected;
  1674.                 if (!radeon_dig_connector->edp_on)
  1675.                         atombios_set_edp_panel_power(connector,
  1676.                                                      ATOM_TRANSMITTER_ACTION_POWER_OFF);
  1677.         } else if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
  1678.                    ENCODER_OBJECT_ID_NONE) {
  1679.                 /* DP bridges are always DP */
  1680.                 radeon_dig_connector->dp_sink_type = CONNECTOR_OBJECT_ID_DISPLAYPORT;
  1681.                 /* get the DPCD from the bridge */
  1682.                 radeon_dp_getdpcd(radeon_connector);
  1683.  
  1684.                 if (encoder) {
  1685.                         /* setup ddc on the bridge */
  1686.                         radeon_atom_ext_encoder_setup_ddc(encoder);
  1687.                         /* bridge chips are always aux */
  1688.                         if (radeon_ddc_probe(radeon_connector, true)) /* try DDC */
  1689.                                 ret = connector_status_connected;
  1690.                         else if (radeon_connector->dac_load_detect) { /* try load detection */
  1691.                                 const struct drm_encoder_helper_funcs *encoder_funcs = encoder->helper_private;
  1692.                                 ret = encoder_funcs->detect(encoder, connector);
  1693.                         }
  1694.                 }
  1695.         } else {
  1696.                 radeon_dig_connector->dp_sink_type = radeon_dp_getsinktype(radeon_connector);
  1697.                 if (radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) {
  1698.                         ret = connector_status_connected;
  1699.                         if (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) {
  1700.                                 radeon_dp_getdpcd(radeon_connector);
  1701.                                 r = radeon_dp_mst_probe(radeon_connector);
  1702.                                 if (r == 1)
  1703.                                         ret = connector_status_disconnected;
  1704.                         }
  1705.                 } else {
  1706.                         if (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) {
  1707.                                 if (radeon_dp_getdpcd(radeon_connector)) {
  1708.                                         r = radeon_dp_mst_probe(radeon_connector);
  1709.                                         if (r == 1)
  1710.                                                 ret = connector_status_disconnected;
  1711.                                         else
  1712.                                                 ret = connector_status_connected;
  1713.                                 }
  1714.                         } else {
  1715.                                 /* try non-aux ddc (DP to DVI/HDMI/etc. adapter) */
  1716.                                 if (radeon_ddc_probe(radeon_connector, false))
  1717.                                         ret = connector_status_connected;
  1718.                         }
  1719.                 }
  1720.         }
  1721.  
  1722.         radeon_connector_update_scratch_regs(connector, ret);
  1723.  
  1724.         if ((radeon_audio != 0) && encoder) {
  1725.                 radeon_connector_get_edid(connector);
  1726.                 radeon_audio_detect(connector, encoder, ret);
  1727.         }
  1728.  
  1729. out:
  1730.         pm_runtime_mark_last_busy(connector->dev->dev);
  1731.         pm_runtime_put_autosuspend(connector->dev->dev);
  1732.  
  1733.         return ret;
  1734. }
  1735.  
  1736. static int radeon_dp_mode_valid(struct drm_connector *connector,
  1737.                                   struct drm_display_mode *mode)
  1738. {
  1739.         struct drm_device *dev = connector->dev;
  1740.         struct radeon_device *rdev = dev->dev_private;
  1741.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  1742.         struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
  1743.  
  1744.         /* XXX check mode bandwidth */
  1745.  
  1746.         if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) ||
  1747.             (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
  1748.                 struct drm_encoder *encoder = radeon_best_single_encoder(connector);
  1749.  
  1750.                 if ((mode->hdisplay < 320) || (mode->vdisplay < 240))
  1751.                         return MODE_PANEL;
  1752.  
  1753.                 if (encoder) {
  1754.                         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
  1755.                         struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
  1756.  
  1757.                         /* AVIVO hardware supports downscaling modes larger than the panel
  1758.                          * to the panel size, but I'm not sure this is desirable.
  1759.                          */
  1760.                         if ((mode->hdisplay > native_mode->hdisplay) ||
  1761.                             (mode->vdisplay > native_mode->vdisplay))
  1762.                                 return MODE_PANEL;
  1763.  
  1764.                         /* if scaling is disabled, block non-native modes */
  1765.                         if (radeon_encoder->rmx_type == RMX_OFF) {
  1766.                                 if ((mode->hdisplay != native_mode->hdisplay) ||
  1767.                                     (mode->vdisplay != native_mode->vdisplay))
  1768.                                         return MODE_PANEL;
  1769.                         }
  1770.                 }
  1771.         } else {
  1772.                 if ((radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) ||
  1773.                     (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_eDP)) {
  1774.                         return radeon_dp_mode_valid_helper(connector, mode);
  1775.                 } else {
  1776.                         if (ASIC_IS_DCE6(rdev) && drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
  1777.                                 /* HDMI 1.3+ supports max clock of 340 Mhz */
  1778.                                 if (mode->clock > 340000)
  1779.                                         return MODE_CLOCK_HIGH;
  1780.                         } else {
  1781.                                 if (mode->clock > 165000)
  1782.                                         return MODE_CLOCK_HIGH;
  1783.                         }
  1784.                 }
  1785.         }
  1786.  
  1787.         return MODE_OK;
  1788. }
  1789.  
  1790. static const struct drm_connector_helper_funcs radeon_dp_connector_helper_funcs = {
  1791.         .get_modes = radeon_dp_get_modes,
  1792.         .mode_valid = radeon_dp_mode_valid,
  1793.         .best_encoder = radeon_dvi_encoder,
  1794. };
  1795.  
  1796. static const struct drm_connector_funcs radeon_dp_connector_funcs = {
  1797.         .dpms = drm_helper_connector_dpms,
  1798.         .detect = radeon_dp_detect,
  1799.         .fill_modes = drm_helper_probe_single_connector_modes,
  1800.         .set_property = radeon_connector_set_property,
  1801.         .destroy = radeon_connector_destroy,
  1802.         .force = radeon_dvi_force,
  1803. };
  1804.  
  1805. static const struct drm_connector_funcs radeon_edp_connector_funcs = {
  1806.         .dpms = drm_helper_connector_dpms,
  1807.         .detect = radeon_dp_detect,
  1808.         .fill_modes = drm_helper_probe_single_connector_modes,
  1809.         .set_property = radeon_lvds_set_property,
  1810.         .destroy = radeon_connector_destroy,
  1811.         .force = radeon_dvi_force,
  1812. };
  1813.  
  1814. static const struct drm_connector_funcs radeon_lvds_bridge_connector_funcs = {
  1815.         .dpms = drm_helper_connector_dpms,
  1816.         .detect = radeon_dp_detect,
  1817.         .fill_modes = drm_helper_probe_single_connector_modes,
  1818.         .set_property = radeon_lvds_set_property,
  1819.         .destroy = radeon_connector_destroy,
  1820.         .force = radeon_dvi_force,
  1821. };
  1822.  
  1823. void
  1824. radeon_add_atom_connector(struct drm_device *dev,
  1825.                           uint32_t connector_id,
  1826.                           uint32_t supported_device,
  1827.                           int connector_type,
  1828.                           struct radeon_i2c_bus_rec *i2c_bus,
  1829.                           uint32_t igp_lane_info,
  1830.                           uint16_t connector_object_id,
  1831.                           struct radeon_hpd *hpd,
  1832.                           struct radeon_router *router)
  1833. {
  1834.         struct radeon_device *rdev = dev->dev_private;
  1835.         struct drm_connector *connector;
  1836.         struct radeon_connector *radeon_connector;
  1837.         struct radeon_connector_atom_dig *radeon_dig_connector;
  1838.         struct drm_encoder *encoder;
  1839.         struct radeon_encoder *radeon_encoder;
  1840.         uint32_t subpixel_order = SubPixelNone;
  1841.         bool shared_ddc = false;
  1842.         bool is_dp_bridge = false;
  1843.         bool has_aux = false;
  1844.  
  1845.         if (connector_type == DRM_MODE_CONNECTOR_Unknown)
  1846.                 return;
  1847.  
  1848.         /* if the user selected tv=0 don't try and add the connector */
  1849.         if (((connector_type == DRM_MODE_CONNECTOR_SVIDEO) ||
  1850.              (connector_type == DRM_MODE_CONNECTOR_Composite) ||
  1851.              (connector_type == DRM_MODE_CONNECTOR_9PinDIN)) &&
  1852.             (radeon_tv == 0))
  1853.                 return;
  1854.  
  1855.         /* see if we already added it */
  1856.         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
  1857.                 radeon_connector = to_radeon_connector(connector);
  1858.                 if (radeon_connector->connector_id == connector_id) {
  1859.                         radeon_connector->devices |= supported_device;
  1860.                         return;
  1861.                 }
  1862.                 if (radeon_connector->ddc_bus && i2c_bus->valid) {
  1863.                         if (radeon_connector->ddc_bus->rec.i2c_id == i2c_bus->i2c_id) {
  1864.                                 radeon_connector->shared_ddc = true;
  1865.                                 shared_ddc = true;
  1866.                         }
  1867.                         if (radeon_connector->router_bus && router->ddc_valid &&
  1868.                             (radeon_connector->router.router_id == router->router_id)) {
  1869.                                 radeon_connector->shared_ddc = false;
  1870.                                 shared_ddc = false;
  1871.                         }
  1872.                 }
  1873.         }
  1874.  
  1875.         /* check if it's a dp bridge */
  1876.         list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
  1877.                 radeon_encoder = to_radeon_encoder(encoder);
  1878.                 if (radeon_encoder->devices & supported_device) {
  1879.                         switch (radeon_encoder->encoder_id) {
  1880.                         case ENCODER_OBJECT_ID_TRAVIS:
  1881.                         case ENCODER_OBJECT_ID_NUTMEG:
  1882.                                 is_dp_bridge = true;
  1883.                                 break;
  1884.                         default:
  1885.                                 break;
  1886.                         }
  1887.                 }
  1888.         }
  1889.  
  1890.         radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
  1891.         if (!radeon_connector)
  1892.                 return;
  1893.  
  1894.         connector = &radeon_connector->base;
  1895.  
  1896.         radeon_connector->connector_id = connector_id;
  1897.         radeon_connector->devices = supported_device;
  1898.         radeon_connector->shared_ddc = shared_ddc;
  1899.         radeon_connector->connector_object_id = connector_object_id;
  1900.         radeon_connector->hpd = *hpd;
  1901.  
  1902.         radeon_connector->router = *router;
  1903.         if (router->ddc_valid || router->cd_valid) {
  1904.                 radeon_connector->router_bus = radeon_i2c_lookup(rdev, &router->i2c_info);
  1905.                 if (!radeon_connector->router_bus)
  1906.                         DRM_ERROR("Failed to assign router i2c bus! Check dmesg for i2c errors.\n");
  1907.         }
  1908.  
  1909.         if (is_dp_bridge) {
  1910.                 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
  1911.                 if (!radeon_dig_connector)
  1912.                         goto failed;
  1913.                 radeon_dig_connector->igp_lane_info = igp_lane_info;
  1914.                 radeon_connector->con_priv = radeon_dig_connector;
  1915.                 if (i2c_bus->valid) {
  1916.                         radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
  1917.                         if (radeon_connector->ddc_bus)
  1918.                                 has_aux = true;
  1919.                         else
  1920.                                 DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
  1921.                 }
  1922.                 switch (connector_type) {
  1923.                 case DRM_MODE_CONNECTOR_VGA:
  1924.                 case DRM_MODE_CONNECTOR_DVIA:
  1925.                 default:
  1926.                         drm_connector_init(dev, &radeon_connector->base,
  1927.                                            &radeon_dp_connector_funcs, connector_type);
  1928.                         drm_connector_helper_add(&radeon_connector->base,
  1929.                                                  &radeon_dp_connector_helper_funcs);
  1930.                         connector->interlace_allowed = true;
  1931.                         connector->doublescan_allowed = true;
  1932.                         radeon_connector->dac_load_detect = true;
  1933.                         drm_object_attach_property(&radeon_connector->base.base,
  1934.                                                       rdev->mode_info.load_detect_property,
  1935.                                                       1);
  1936.                         drm_object_attach_property(&radeon_connector->base.base,
  1937.                                                    dev->mode_config.scaling_mode_property,
  1938.                                                    DRM_MODE_SCALE_NONE);
  1939.                         if (ASIC_IS_DCE5(rdev))
  1940.                                 drm_object_attach_property(&radeon_connector->base.base,
  1941.                                                            rdev->mode_info.output_csc_property,
  1942.                                                            RADEON_OUTPUT_CSC_BYPASS);
  1943.                         break;
  1944.                 case DRM_MODE_CONNECTOR_DVII:
  1945.                 case DRM_MODE_CONNECTOR_DVID:
  1946.                 case DRM_MODE_CONNECTOR_HDMIA:
  1947.                 case DRM_MODE_CONNECTOR_HDMIB:
  1948.                 case DRM_MODE_CONNECTOR_DisplayPort:
  1949.                         drm_connector_init(dev, &radeon_connector->base,
  1950.                                            &radeon_dp_connector_funcs, connector_type);
  1951.                         drm_connector_helper_add(&radeon_connector->base,
  1952.                                                  &radeon_dp_connector_helper_funcs);
  1953.                         drm_object_attach_property(&radeon_connector->base.base,
  1954.                                                       rdev->mode_info.underscan_property,
  1955.                                                       UNDERSCAN_OFF);
  1956.                         drm_object_attach_property(&radeon_connector->base.base,
  1957.                                                       rdev->mode_info.underscan_hborder_property,
  1958.                                                       0);
  1959.                         drm_object_attach_property(&radeon_connector->base.base,
  1960.                                                       rdev->mode_info.underscan_vborder_property,
  1961.                                                       0);
  1962.  
  1963.                         drm_object_attach_property(&radeon_connector->base.base,
  1964.                                                       dev->mode_config.scaling_mode_property,
  1965.                                                       DRM_MODE_SCALE_NONE);
  1966.  
  1967.                         drm_object_attach_property(&radeon_connector->base.base,
  1968.                                                    rdev->mode_info.dither_property,
  1969.                                                    RADEON_FMT_DITHER_DISABLE);
  1970.  
  1971.                         if (radeon_audio != 0) {
  1972.                                 drm_object_attach_property(&radeon_connector->base.base,
  1973.                                                            rdev->mode_info.audio_property,
  1974.                                                            RADEON_AUDIO_AUTO);
  1975.                                 radeon_connector->audio = RADEON_AUDIO_AUTO;
  1976.                         }
  1977.                         if (ASIC_IS_DCE5(rdev))
  1978.                                 drm_object_attach_property(&radeon_connector->base.base,
  1979.                                                            rdev->mode_info.output_csc_property,
  1980.                                                            RADEON_OUTPUT_CSC_BYPASS);
  1981.  
  1982.                         subpixel_order = SubPixelHorizontalRGB;
  1983.                         connector->interlace_allowed = true;
  1984.                         if (connector_type == DRM_MODE_CONNECTOR_HDMIB)
  1985.                                 connector->doublescan_allowed = true;
  1986.                         else
  1987.                                 connector->doublescan_allowed = false;
  1988.                         if (connector_type == DRM_MODE_CONNECTOR_DVII) {
  1989.                                 radeon_connector->dac_load_detect = true;
  1990.                                 drm_object_attach_property(&radeon_connector->base.base,
  1991.                                                               rdev->mode_info.load_detect_property,
  1992.                                                               1);
  1993.                         }
  1994.                         break;
  1995.                 case DRM_MODE_CONNECTOR_LVDS:
  1996.                 case DRM_MODE_CONNECTOR_eDP:
  1997.                         drm_connector_init(dev, &radeon_connector->base,
  1998.                                            &radeon_lvds_bridge_connector_funcs, connector_type);
  1999.                         drm_connector_helper_add(&radeon_connector->base,
  2000.                                                  &radeon_dp_connector_helper_funcs);
  2001.                         drm_object_attach_property(&radeon_connector->base.base,
  2002.                                                       dev->mode_config.scaling_mode_property,
  2003.                                                       DRM_MODE_SCALE_FULLSCREEN);
  2004.                         subpixel_order = SubPixelHorizontalRGB;
  2005.                         connector->interlace_allowed = false;
  2006.                         connector->doublescan_allowed = false;
  2007.                         break;
  2008.                 }
  2009.         } else {
  2010.                 switch (connector_type) {
  2011.                 case DRM_MODE_CONNECTOR_VGA:
  2012.                         drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
  2013.                         drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
  2014.                         if (i2c_bus->valid) {
  2015.                                 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
  2016.                                 if (!radeon_connector->ddc_bus)
  2017.                                         DRM_ERROR("VGA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
  2018.                         }
  2019.                         radeon_connector->dac_load_detect = true;
  2020.                         drm_object_attach_property(&radeon_connector->base.base,
  2021.                                                       rdev->mode_info.load_detect_property,
  2022.                                                       1);
  2023.                         if (ASIC_IS_AVIVO(rdev))
  2024.                                 drm_object_attach_property(&radeon_connector->base.base,
  2025.                                                            dev->mode_config.scaling_mode_property,
  2026.                                                            DRM_MODE_SCALE_NONE);
  2027.                         if (ASIC_IS_DCE5(rdev))
  2028.                                 drm_object_attach_property(&radeon_connector->base.base,
  2029.                                                            rdev->mode_info.output_csc_property,
  2030.                                                            RADEON_OUTPUT_CSC_BYPASS);
  2031.                         /* no HPD on analog connectors */
  2032.                         radeon_connector->hpd.hpd = RADEON_HPD_NONE;
  2033.                         connector->polled = DRM_CONNECTOR_POLL_CONNECT;
  2034.                         connector->interlace_allowed = true;
  2035.                         connector->doublescan_allowed = true;
  2036.                         break;
  2037.                 case DRM_MODE_CONNECTOR_DVIA:
  2038.                         drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
  2039.                         drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
  2040.                         if (i2c_bus->valid) {
  2041.                                 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
  2042.                                 if (!radeon_connector->ddc_bus)
  2043.                                         DRM_ERROR("DVIA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
  2044.                         }
  2045.                         radeon_connector->dac_load_detect = true;
  2046.                         drm_object_attach_property(&radeon_connector->base.base,
  2047.                                                       rdev->mode_info.load_detect_property,
  2048.                                                       1);
  2049.                         if (ASIC_IS_AVIVO(rdev))
  2050.                                 drm_object_attach_property(&radeon_connector->base.base,
  2051.                                                            dev->mode_config.scaling_mode_property,
  2052.                                                            DRM_MODE_SCALE_NONE);
  2053.                         if (ASIC_IS_DCE5(rdev))
  2054.                                 drm_object_attach_property(&radeon_connector->base.base,
  2055.                                                            rdev->mode_info.output_csc_property,
  2056.                                                            RADEON_OUTPUT_CSC_BYPASS);
  2057.                         /* no HPD on analog connectors */
  2058.                         radeon_connector->hpd.hpd = RADEON_HPD_NONE;
  2059.                         connector->interlace_allowed = true;
  2060.                         connector->doublescan_allowed = true;
  2061.                         break;
  2062.                 case DRM_MODE_CONNECTOR_DVII:
  2063.                 case DRM_MODE_CONNECTOR_DVID:
  2064.                         radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
  2065.                         if (!radeon_dig_connector)
  2066.                                 goto failed;
  2067.                         radeon_dig_connector->igp_lane_info = igp_lane_info;
  2068.                         radeon_connector->con_priv = radeon_dig_connector;
  2069.                         drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
  2070.                         drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
  2071.                         if (i2c_bus->valid) {
  2072.                                 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
  2073.                                 if (!radeon_connector->ddc_bus)
  2074.                                         DRM_ERROR("DVI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
  2075.                         }
  2076.                         subpixel_order = SubPixelHorizontalRGB;
  2077.                         drm_object_attach_property(&radeon_connector->base.base,
  2078.                                                       rdev->mode_info.coherent_mode_property,
  2079.                                                       1);
  2080.                         if (ASIC_IS_AVIVO(rdev)) {
  2081.                                 drm_object_attach_property(&radeon_connector->base.base,
  2082.                                                               rdev->mode_info.underscan_property,
  2083.                                                               UNDERSCAN_OFF);
  2084.                                 drm_object_attach_property(&radeon_connector->base.base,
  2085.                                                               rdev->mode_info.underscan_hborder_property,
  2086.                                                               0);
  2087.                                 drm_object_attach_property(&radeon_connector->base.base,
  2088.                                                               rdev->mode_info.underscan_vborder_property,
  2089.                                                               0);
  2090.                                 drm_object_attach_property(&radeon_connector->base.base,
  2091.                                                            rdev->mode_info.dither_property,
  2092.                                                            RADEON_FMT_DITHER_DISABLE);
  2093.                                 drm_object_attach_property(&radeon_connector->base.base,
  2094.                                                            dev->mode_config.scaling_mode_property,
  2095.                                                            DRM_MODE_SCALE_NONE);
  2096.                         }
  2097.                         if (ASIC_IS_DCE2(rdev) && (radeon_audio != 0)) {
  2098.                                 drm_object_attach_property(&radeon_connector->base.base,
  2099.                                                            rdev->mode_info.audio_property,
  2100.                                                            RADEON_AUDIO_AUTO);
  2101.                                 radeon_connector->audio = RADEON_AUDIO_AUTO;
  2102.                         }
  2103.                         if (connector_type == DRM_MODE_CONNECTOR_DVII) {
  2104.                                 radeon_connector->dac_load_detect = true;
  2105.                                 drm_object_attach_property(&radeon_connector->base.base,
  2106.                                                               rdev->mode_info.load_detect_property,
  2107.                                                               1);
  2108.                         }
  2109.                         if (ASIC_IS_DCE5(rdev))
  2110.                                 drm_object_attach_property(&radeon_connector->base.base,
  2111.                                                            rdev->mode_info.output_csc_property,
  2112.                                                            RADEON_OUTPUT_CSC_BYPASS);
  2113.                         connector->interlace_allowed = true;
  2114.                         if (connector_type == DRM_MODE_CONNECTOR_DVII)
  2115.                                 connector->doublescan_allowed = true;
  2116.                         else
  2117.                                 connector->doublescan_allowed = false;
  2118.                         break;
  2119.                 case DRM_MODE_CONNECTOR_HDMIA:
  2120.                 case DRM_MODE_CONNECTOR_HDMIB:
  2121.                         radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
  2122.                         if (!radeon_dig_connector)
  2123.                                 goto failed;
  2124.                         radeon_dig_connector->igp_lane_info = igp_lane_info;
  2125.                         radeon_connector->con_priv = radeon_dig_connector;
  2126.                         drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
  2127.                         drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
  2128.                         if (i2c_bus->valid) {
  2129.                                 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
  2130.                                 if (!radeon_connector->ddc_bus)
  2131.                                         DRM_ERROR("HDMI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
  2132.                         }
  2133.                         drm_object_attach_property(&radeon_connector->base.base,
  2134.                                                       rdev->mode_info.coherent_mode_property,
  2135.                                                       1);
  2136.                         if (ASIC_IS_AVIVO(rdev)) {
  2137.                                 drm_object_attach_property(&radeon_connector->base.base,
  2138.                                                               rdev->mode_info.underscan_property,
  2139.                                                               UNDERSCAN_OFF);
  2140.                                 drm_object_attach_property(&radeon_connector->base.base,
  2141.                                                               rdev->mode_info.underscan_hborder_property,
  2142.                                                               0);
  2143.                                 drm_object_attach_property(&radeon_connector->base.base,
  2144.                                                               rdev->mode_info.underscan_vborder_property,
  2145.                                                               0);
  2146.                                 drm_object_attach_property(&radeon_connector->base.base,
  2147.                                                            rdev->mode_info.dither_property,
  2148.                                                            RADEON_FMT_DITHER_DISABLE);
  2149.                                 drm_object_attach_property(&radeon_connector->base.base,
  2150.                                                            dev->mode_config.scaling_mode_property,
  2151.                                                            DRM_MODE_SCALE_NONE);
  2152.                         }
  2153.                         if (ASIC_IS_DCE2(rdev) && (radeon_audio != 0)) {
  2154.                                 drm_object_attach_property(&radeon_connector->base.base,
  2155.                                                            rdev->mode_info.audio_property,
  2156.                                                            RADEON_AUDIO_AUTO);
  2157.                                 radeon_connector->audio = RADEON_AUDIO_AUTO;
  2158.                         }
  2159.                         if (ASIC_IS_DCE5(rdev))
  2160.                                 drm_object_attach_property(&radeon_connector->base.base,
  2161.                                                            rdev->mode_info.output_csc_property,
  2162.                                                            RADEON_OUTPUT_CSC_BYPASS);
  2163.                         subpixel_order = SubPixelHorizontalRGB;
  2164.                         connector->interlace_allowed = true;
  2165.                         if (connector_type == DRM_MODE_CONNECTOR_HDMIB)
  2166.                                 connector->doublescan_allowed = true;
  2167.                         else
  2168.                                 connector->doublescan_allowed = false;
  2169.                         break;
  2170.                 case DRM_MODE_CONNECTOR_DisplayPort:
  2171.                         radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
  2172.                         if (!radeon_dig_connector)
  2173.                                 goto failed;
  2174.                         radeon_dig_connector->igp_lane_info = igp_lane_info;
  2175.                         radeon_connector->con_priv = radeon_dig_connector;
  2176.                         drm_connector_init(dev, &radeon_connector->base, &radeon_dp_connector_funcs, connector_type);
  2177.                         drm_connector_helper_add(&radeon_connector->base, &radeon_dp_connector_helper_funcs);
  2178.                         if (i2c_bus->valid) {
  2179.                                 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
  2180.                                 if (radeon_connector->ddc_bus)
  2181.                                         has_aux = true;
  2182.                                 else
  2183.                                         DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
  2184.                         }
  2185.                         subpixel_order = SubPixelHorizontalRGB;
  2186.                         drm_object_attach_property(&radeon_connector->base.base,
  2187.                                                       rdev->mode_info.coherent_mode_property,
  2188.                                                       1);
  2189.                         if (ASIC_IS_AVIVO(rdev)) {
  2190.                                 drm_object_attach_property(&radeon_connector->base.base,
  2191.                                                               rdev->mode_info.underscan_property,
  2192.                                                               UNDERSCAN_OFF);
  2193.                                 drm_object_attach_property(&radeon_connector->base.base,
  2194.                                                               rdev->mode_info.underscan_hborder_property,
  2195.                                                               0);
  2196.                                 drm_object_attach_property(&radeon_connector->base.base,
  2197.                                                               rdev->mode_info.underscan_vborder_property,
  2198.                                                               0);
  2199.                                 drm_object_attach_property(&radeon_connector->base.base,
  2200.                                                            rdev->mode_info.dither_property,
  2201.                                                            RADEON_FMT_DITHER_DISABLE);
  2202.                                 drm_object_attach_property(&radeon_connector->base.base,
  2203.                                                            dev->mode_config.scaling_mode_property,
  2204.                                                            DRM_MODE_SCALE_NONE);
  2205.                         }
  2206.                         if (ASIC_IS_DCE2(rdev) && (radeon_audio != 0)) {
  2207.                                 drm_object_attach_property(&radeon_connector->base.base,
  2208.                                                            rdev->mode_info.audio_property,
  2209.                                                            RADEON_AUDIO_AUTO);
  2210.                                 radeon_connector->audio = RADEON_AUDIO_AUTO;
  2211.                         }
  2212.                         if (ASIC_IS_DCE5(rdev))
  2213.                                 drm_object_attach_property(&radeon_connector->base.base,
  2214.                                                            rdev->mode_info.output_csc_property,
  2215.                                                            RADEON_OUTPUT_CSC_BYPASS);
  2216.                         connector->interlace_allowed = true;
  2217.                         /* in theory with a DP to VGA converter... */
  2218.                         connector->doublescan_allowed = false;
  2219.                         break;
  2220.                 case DRM_MODE_CONNECTOR_eDP:
  2221.                         radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
  2222.                         if (!radeon_dig_connector)
  2223.                                 goto failed;
  2224.                         radeon_dig_connector->igp_lane_info = igp_lane_info;
  2225.                         radeon_connector->con_priv = radeon_dig_connector;
  2226.                         drm_connector_init(dev, &radeon_connector->base, &radeon_edp_connector_funcs, connector_type);
  2227.                         drm_connector_helper_add(&radeon_connector->base, &radeon_dp_connector_helper_funcs);
  2228.                         if (i2c_bus->valid) {
  2229.                                 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
  2230.                                 if (radeon_connector->ddc_bus)
  2231.                                         has_aux = true;
  2232.                                 else
  2233.                                         DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
  2234.                         }
  2235.                         drm_object_attach_property(&radeon_connector->base.base,
  2236.                                                       dev->mode_config.scaling_mode_property,
  2237.                                                       DRM_MODE_SCALE_FULLSCREEN);
  2238.                         subpixel_order = SubPixelHorizontalRGB;
  2239.                         connector->interlace_allowed = false;
  2240.                         connector->doublescan_allowed = false;
  2241.                         break;
  2242.                 case DRM_MODE_CONNECTOR_SVIDEO:
  2243.                 case DRM_MODE_CONNECTOR_Composite:
  2244.                 case DRM_MODE_CONNECTOR_9PinDIN:
  2245.                         drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
  2246.                         drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
  2247.                         radeon_connector->dac_load_detect = true;
  2248.                         drm_object_attach_property(&radeon_connector->base.base,
  2249.                                                       rdev->mode_info.load_detect_property,
  2250.                                                       1);
  2251.                         drm_object_attach_property(&radeon_connector->base.base,
  2252.                                                       rdev->mode_info.tv_std_property,
  2253.                                                       radeon_atombios_get_tv_info(rdev));
  2254.                         /* no HPD on analog connectors */
  2255.                         radeon_connector->hpd.hpd = RADEON_HPD_NONE;
  2256.                         connector->interlace_allowed = false;
  2257.                         connector->doublescan_allowed = false;
  2258.                         break;
  2259.                 case DRM_MODE_CONNECTOR_LVDS:
  2260.                         radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
  2261.                         if (!radeon_dig_connector)
  2262.                                 goto failed;
  2263.                         radeon_dig_connector->igp_lane_info = igp_lane_info;
  2264.                         radeon_connector->con_priv = radeon_dig_connector;
  2265.                         drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
  2266.                         drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
  2267.                         if (i2c_bus->valid) {
  2268.                                 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
  2269.                                 if (!radeon_connector->ddc_bus)
  2270.                                         DRM_ERROR("LVDS: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
  2271.                         }
  2272.                         drm_object_attach_property(&radeon_connector->base.base,
  2273.                                                       dev->mode_config.scaling_mode_property,
  2274.                                                       DRM_MODE_SCALE_FULLSCREEN);
  2275.                         subpixel_order = SubPixelHorizontalRGB;
  2276.                         connector->interlace_allowed = false;
  2277.                         connector->doublescan_allowed = false;
  2278.                         break;
  2279.                 }
  2280.         }
  2281.  
  2282.         if (radeon_connector->hpd.hpd == RADEON_HPD_NONE) {
  2283.                 if (i2c_bus->valid)
  2284.                         connector->polled = DRM_CONNECTOR_POLL_CONNECT;
  2285.         } else
  2286.                 connector->polled = DRM_CONNECTOR_POLL_HPD;
  2287.  
  2288.         connector->display_info.subpixel_order = subpixel_order;
  2289.         drm_connector_register(connector);
  2290.  
  2291.         if (has_aux)
  2292.                 radeon_dp_aux_init(radeon_connector);
  2293.  
  2294.         return;
  2295.  
  2296. failed:
  2297.         drm_connector_cleanup(connector);
  2298.         kfree(connector);
  2299. }
  2300.  
  2301. void
  2302. radeon_add_legacy_connector(struct drm_device *dev,
  2303.                             uint32_t connector_id,
  2304.                             uint32_t supported_device,
  2305.                             int connector_type,
  2306.                             struct radeon_i2c_bus_rec *i2c_bus,
  2307.                             uint16_t connector_object_id,
  2308.                             struct radeon_hpd *hpd)
  2309. {
  2310.         struct radeon_device *rdev = dev->dev_private;
  2311.         struct drm_connector *connector;
  2312.         struct radeon_connector *radeon_connector;
  2313.         uint32_t subpixel_order = SubPixelNone;
  2314.  
  2315.         if (connector_type == DRM_MODE_CONNECTOR_Unknown)
  2316.                 return;
  2317.  
  2318.         /* if the user selected tv=0 don't try and add the connector */
  2319.         if (((connector_type == DRM_MODE_CONNECTOR_SVIDEO) ||
  2320.              (connector_type == DRM_MODE_CONNECTOR_Composite) ||
  2321.              (connector_type == DRM_MODE_CONNECTOR_9PinDIN)) &&
  2322.             (radeon_tv == 0))
  2323.                 return;
  2324.  
  2325.         /* see if we already added it */
  2326.         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
  2327.                 radeon_connector = to_radeon_connector(connector);
  2328.                 if (radeon_connector->connector_id == connector_id) {
  2329.                         radeon_connector->devices |= supported_device;
  2330.                         return;
  2331.                 }
  2332.         }
  2333.  
  2334.         radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
  2335.         if (!radeon_connector)
  2336.                 return;
  2337.  
  2338.         connector = &radeon_connector->base;
  2339.  
  2340.         radeon_connector->connector_id = connector_id;
  2341.         radeon_connector->devices = supported_device;
  2342.         radeon_connector->connector_object_id = connector_object_id;
  2343.         radeon_connector->hpd = *hpd;
  2344.  
  2345.         switch (connector_type) {
  2346.         case DRM_MODE_CONNECTOR_VGA:
  2347.                 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
  2348.                 drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
  2349.                 if (i2c_bus->valid) {
  2350.                         radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
  2351.                         if (!radeon_connector->ddc_bus)
  2352.                                 DRM_ERROR("VGA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
  2353.                 }
  2354.                 radeon_connector->dac_load_detect = true;
  2355.                 drm_object_attach_property(&radeon_connector->base.base,
  2356.                                               rdev->mode_info.load_detect_property,
  2357.                                               1);
  2358.                 /* no HPD on analog connectors */
  2359.                 radeon_connector->hpd.hpd = RADEON_HPD_NONE;
  2360.                 connector->polled = DRM_CONNECTOR_POLL_CONNECT;
  2361.                 connector->interlace_allowed = true;
  2362.                 connector->doublescan_allowed = true;
  2363.                 break;
  2364.         case DRM_MODE_CONNECTOR_DVIA:
  2365.                 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
  2366.                 drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
  2367.                 if (i2c_bus->valid) {
  2368.                         radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
  2369.                         if (!radeon_connector->ddc_bus)
  2370.                                 DRM_ERROR("DVIA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
  2371.                 }
  2372.                 radeon_connector->dac_load_detect = true;
  2373.                 drm_object_attach_property(&radeon_connector->base.base,
  2374.                                               rdev->mode_info.load_detect_property,
  2375.                                               1);
  2376.                 /* no HPD on analog connectors */
  2377.                 radeon_connector->hpd.hpd = RADEON_HPD_NONE;
  2378.                 connector->interlace_allowed = true;
  2379.                 connector->doublescan_allowed = true;
  2380.                 break;
  2381.         case DRM_MODE_CONNECTOR_DVII:
  2382.         case DRM_MODE_CONNECTOR_DVID:
  2383.                 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
  2384.                 drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
  2385.                 if (i2c_bus->valid) {
  2386.                         radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
  2387.                         if (!radeon_connector->ddc_bus)
  2388.                                 DRM_ERROR("DVI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
  2389.                 }
  2390.                 if (connector_type == DRM_MODE_CONNECTOR_DVII) {
  2391.                         radeon_connector->dac_load_detect = true;
  2392.                         drm_object_attach_property(&radeon_connector->base.base,
  2393.                                                       rdev->mode_info.load_detect_property,
  2394.                                                       1);
  2395.                 }
  2396.                 subpixel_order = SubPixelHorizontalRGB;
  2397.                 connector->interlace_allowed = true;
  2398.                 if (connector_type == DRM_MODE_CONNECTOR_DVII)
  2399.                         connector->doublescan_allowed = true;
  2400.                 else
  2401.                         connector->doublescan_allowed = false;
  2402.                 break;
  2403.         case DRM_MODE_CONNECTOR_SVIDEO:
  2404.         case DRM_MODE_CONNECTOR_Composite:
  2405.         case DRM_MODE_CONNECTOR_9PinDIN:
  2406.                 drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
  2407.                 drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
  2408.                 radeon_connector->dac_load_detect = true;
  2409.                 /* RS400,RC410,RS480 chipset seems to report a lot
  2410.                  * of false positive on load detect, we haven't yet
  2411.                  * found a way to make load detect reliable on those
  2412.                  * chipset, thus just disable it for TV.
  2413.                  */
  2414.                 if (rdev->family == CHIP_RS400 || rdev->family == CHIP_RS480)
  2415.                         radeon_connector->dac_load_detect = false;
  2416.                 drm_object_attach_property(&radeon_connector->base.base,
  2417.                                               rdev->mode_info.load_detect_property,
  2418.                                               radeon_connector->dac_load_detect);
  2419.                 drm_object_attach_property(&radeon_connector->base.base,
  2420.                                               rdev->mode_info.tv_std_property,
  2421.                                               radeon_combios_get_tv_info(rdev));
  2422.                 /* no HPD on analog connectors */
  2423.                 radeon_connector->hpd.hpd = RADEON_HPD_NONE;
  2424.                 connector->interlace_allowed = false;
  2425.                 connector->doublescan_allowed = false;
  2426.                 break;
  2427.         case DRM_MODE_CONNECTOR_LVDS:
  2428.                 drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
  2429.                 drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
  2430.                 if (i2c_bus->valid) {
  2431.                         radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
  2432.                         if (!radeon_connector->ddc_bus)
  2433.                                 DRM_ERROR("LVDS: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
  2434.                 }
  2435.                 drm_object_attach_property(&radeon_connector->base.base,
  2436.                                               dev->mode_config.scaling_mode_property,
  2437.                                               DRM_MODE_SCALE_FULLSCREEN);
  2438.                 subpixel_order = SubPixelHorizontalRGB;
  2439.                 connector->interlace_allowed = false;
  2440.                 connector->doublescan_allowed = false;
  2441.                 break;
  2442.         }
  2443.  
  2444.         if (radeon_connector->hpd.hpd == RADEON_HPD_NONE) {
  2445.                 if (i2c_bus->valid)
  2446.                         connector->polled = DRM_CONNECTOR_POLL_CONNECT;
  2447.         } else
  2448.                 connector->polled = DRM_CONNECTOR_POLL_HPD;
  2449.         connector->display_info.subpixel_order = subpixel_order;
  2450.         drm_connector_register(connector);
  2451. }
  2452.  
  2453. void radeon_setup_mst_connector(struct drm_device *dev)
  2454. {
  2455.         struct radeon_device *rdev = dev->dev_private;
  2456.         struct drm_connector *connector;
  2457.         struct radeon_connector *radeon_connector;
  2458.  
  2459.         if (!ASIC_IS_DCE5(rdev))
  2460.                 return;
  2461.  
  2462.         if (radeon_mst == 0)
  2463.                 return;
  2464.  
  2465.         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
  2466.                 int ret;
  2467.  
  2468.                 radeon_connector = to_radeon_connector(connector);
  2469.  
  2470.                 if (connector->connector_type != DRM_MODE_CONNECTOR_DisplayPort)
  2471.                         continue;
  2472.  
  2473.                 ret = radeon_dp_mst_init(radeon_connector);
  2474.         }
  2475. }
  2476.