Subversion Repositories Kolibri OS

Rev

Rev 5271 | Rev 6321 | 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.         encoder = radeon_best_single_encoder(connector);
  1142.         if (!encoder)
  1143.                 ret = connector_status_disconnected;
  1144.         else {
  1145.                 encoder_funcs = encoder->helper_private;
  1146.                 ret = encoder_funcs->detect(encoder, connector);
  1147.         }
  1148.         if (ret == connector_status_connected)
  1149.                 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, false);
  1150.         radeon_connector_update_scratch_regs(connector, ret);
  1151.         return ret;
  1152. }
  1153.  
  1154. static const struct drm_connector_helper_funcs radeon_tv_connector_helper_funcs = {
  1155.         .get_modes = radeon_tv_get_modes,
  1156.         .mode_valid = radeon_tv_mode_valid,
  1157.         .best_encoder = radeon_best_single_encoder,
  1158. };
  1159.  
  1160. static const struct drm_connector_funcs radeon_tv_connector_funcs = {
  1161.         .dpms = drm_helper_connector_dpms,
  1162.         .detect = radeon_tv_detect,
  1163.         .fill_modes = drm_helper_probe_single_connector_modes,
  1164.         .destroy = radeon_connector_destroy,
  1165.         .set_property = radeon_connector_set_property,
  1166. };
  1167.  
  1168. static bool radeon_check_hpd_status_unchanged(struct drm_connector *connector)
  1169. {
  1170.         struct drm_device *dev = connector->dev;
  1171.         struct radeon_device *rdev = dev->dev_private;
  1172.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  1173.         enum drm_connector_status status;
  1174.  
  1175.         /* We only trust HPD on R600 and newer ASICS. */
  1176.         if (rdev->family >= CHIP_R600
  1177.           && radeon_connector->hpd.hpd != RADEON_HPD_NONE) {
  1178.                 if (radeon_hpd_sense(rdev, radeon_connector->hpd.hpd))
  1179.                         status = connector_status_connected;
  1180.                 else
  1181.                         status = connector_status_disconnected;
  1182.                 if (connector->status == status)
  1183.                         return true;
  1184.         }
  1185.  
  1186.         return false;
  1187. }
  1188.  
  1189. /*
  1190.  * DVI is complicated
  1191.  * Do a DDC probe, if DDC probe passes, get the full EDID so
  1192.  * we can do analog/digital monitor detection at this point.
  1193.  * If the monitor is an analog monitor or we got no DDC,
  1194.  * we need to find the DAC encoder object for this connector.
  1195.  * If we got no DDC, we do load detection on the DAC encoder object.
  1196.  * If we got analog DDC or load detection passes on the DAC encoder
  1197.  * we have to check if this analog encoder is shared with anyone else (TV)
  1198.  * if its shared we have to set the other connector to disconnected.
  1199.  */
  1200. static enum drm_connector_status
  1201. radeon_dvi_detect(struct drm_connector *connector, bool force)
  1202. {
  1203.         struct drm_device *dev = connector->dev;
  1204.         struct radeon_device *rdev = dev->dev_private;
  1205.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  1206.         struct drm_encoder *encoder = NULL;
  1207.         const struct drm_encoder_helper_funcs *encoder_funcs;
  1208.         int i, r;
  1209.         enum drm_connector_status ret = connector_status_disconnected;
  1210.         bool dret = false, broken_edid = false;
  1211.  
  1212.  
  1213.         if (!force && radeon_check_hpd_status_unchanged(connector)) {
  1214.                 ret = connector->status;
  1215.                 goto exit;
  1216.         }
  1217.  
  1218.         if (radeon_connector->ddc_bus) {
  1219.                 dret = radeon_ddc_probe(radeon_connector, false);
  1220.         }
  1221.         if (dret) {
  1222.                 radeon_connector->detected_by_load = false;
  1223.                 radeon_connector_free_edid(connector);
  1224.                 radeon_connector_get_edid(connector);
  1225.  
  1226.                 if (!radeon_connector->edid) {
  1227.                         DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
  1228.                                         connector->name);
  1229.                         /* rs690 seems to have a problem with connectors not existing and always
  1230.                          * return a block of 0's. If we see this just stop polling on this output */
  1231.                         if ((rdev->family == CHIP_RS690 || rdev->family == CHIP_RS740) &&
  1232.                             radeon_connector->base.null_edid_counter) {
  1233.                                 ret = connector_status_disconnected;
  1234.                                 DRM_ERROR("%s: detected RS690 floating bus bug, stopping ddc detect\n",
  1235.                                           connector->name);
  1236.                                 radeon_connector->ddc_bus = NULL;
  1237.                         } else {
  1238.                                 ret = connector_status_connected;
  1239.                                 broken_edid = true; /* defer use_digital to later */
  1240.                         }
  1241.                 } else {
  1242.                         radeon_connector->use_digital =
  1243.                                 !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
  1244.  
  1245.                         /* some oems have boards with separate digital and analog connectors
  1246.                          * with a shared ddc line (often vga + hdmi)
  1247.                          */
  1248.                         if ((!radeon_connector->use_digital) && radeon_connector->shared_ddc) {
  1249.                                 radeon_connector_free_edid(connector);
  1250.                                 ret = connector_status_disconnected;
  1251.                         } else {
  1252.                                 ret = connector_status_connected;
  1253.                         }
  1254.                         /* This gets complicated.  We have boards with VGA + HDMI with a
  1255.                          * shared DDC line and we have boards with DVI-D + HDMI with a shared
  1256.                          * DDC line.  The latter is more complex because with DVI<->HDMI adapters
  1257.                          * you don't really know what's connected to which port as both are digital.
  1258.                          */
  1259.                         if (radeon_connector->shared_ddc && (ret == connector_status_connected)) {
  1260.                                 struct drm_connector *list_connector;
  1261.                                 struct radeon_connector *list_radeon_connector;
  1262.                                 list_for_each_entry(list_connector, &dev->mode_config.connector_list, head) {
  1263.                                         if (connector == list_connector)
  1264.                                                 continue;
  1265.                                         list_radeon_connector = to_radeon_connector(list_connector);
  1266.                                         if (list_radeon_connector->shared_ddc &&
  1267.                                             (list_radeon_connector->ddc_bus->rec.i2c_id ==
  1268.                                              radeon_connector->ddc_bus->rec.i2c_id)) {
  1269.                                                 /* cases where both connectors are digital */
  1270.                                                 if (list_connector->connector_type != DRM_MODE_CONNECTOR_VGA) {
  1271.                                                         /* hpd is our only option in this case */
  1272.                                                         if (!radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) {
  1273.                                                                 radeon_connector_free_edid(connector);
  1274.                                                                 ret = connector_status_disconnected;
  1275.                                                         }
  1276.                                                 }
  1277.                                         }
  1278.                                 }
  1279.                         }
  1280.                 }
  1281.         }
  1282.  
  1283.         if ((ret == connector_status_connected) && (radeon_connector->use_digital == true))
  1284.                 goto out;
  1285.  
  1286.         /* DVI-D and HDMI-A are digital only */
  1287.         if ((connector->connector_type == DRM_MODE_CONNECTOR_DVID) ||
  1288.             (connector->connector_type == DRM_MODE_CONNECTOR_HDMIA))
  1289.                 goto out;
  1290.  
  1291.         /* if we aren't forcing don't do destructive polling */
  1292.         if (!force) {
  1293.                 /* only return the previous status if we last
  1294.                  * detected a monitor via load.
  1295.                  */
  1296.                 if (radeon_connector->detected_by_load)
  1297.                         ret = connector->status;
  1298.                 goto out;
  1299.         }
  1300.  
  1301.         /* find analog encoder */
  1302.         if (radeon_connector->dac_load_detect) {
  1303.                 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
  1304.                         if (connector->encoder_ids[i] == 0)
  1305.                                 break;
  1306.  
  1307.                         encoder = drm_encoder_find(connector->dev,
  1308.                                                    connector->encoder_ids[i]);
  1309.                         if (!encoder)
  1310.                                 continue;
  1311.  
  1312.                         if (encoder->encoder_type != DRM_MODE_ENCODER_DAC &&
  1313.                             encoder->encoder_type != DRM_MODE_ENCODER_TVDAC)
  1314.                                 continue;
  1315.  
  1316.                         encoder_funcs = encoder->helper_private;
  1317.                         if (encoder_funcs->detect) {
  1318.                                 if (!broken_edid) {
  1319.                                         if (ret != connector_status_connected) {
  1320.                                                 /* deal with analog monitors without DDC */
  1321.                                                 ret = encoder_funcs->detect(encoder, connector);
  1322.                                                 if (ret == connector_status_connected) {
  1323.                                                         radeon_connector->use_digital = false;
  1324.                                                 }
  1325.                                                 if (ret != connector_status_disconnected)
  1326.                                                         radeon_connector->detected_by_load = true;
  1327.                                         }
  1328.                                 } else {
  1329.                                         enum drm_connector_status lret;
  1330.                                         /* assume digital unless load detected otherwise */
  1331.                                         radeon_connector->use_digital = true;
  1332.                                         lret = encoder_funcs->detect(encoder, connector);
  1333.                                         DRM_DEBUG_KMS("load_detect %x returned: %x\n",encoder->encoder_type,lret);
  1334.                                         if (lret == connector_status_connected)
  1335.                                                 radeon_connector->use_digital = false;
  1336.                                 }
  1337.                                 break;
  1338.                         }
  1339.                 }
  1340.         }
  1341.  
  1342.         if ((ret == connector_status_connected) && (radeon_connector->use_digital == false) &&
  1343.             encoder) {
  1344.                 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
  1345.         }
  1346.  
  1347.         /* RN50 and some RV100 asics in servers often have a hardcoded EDID in the
  1348.          * vbios to deal with KVMs. If we have one and are not able to detect a monitor
  1349.          * by other means, assume the DFP is connected and use that EDID.  In most
  1350.          * cases the DVI port is actually a virtual KVM port connected to the service
  1351.          * processor.
  1352.          */
  1353. out:
  1354.         if ((!rdev->is_atom_bios) &&
  1355.             (ret == connector_status_disconnected) &&
  1356.             rdev->mode_info.bios_hardcoded_edid_size) {
  1357.                 radeon_connector->use_digital = true;
  1358.                 ret = connector_status_connected;
  1359.         }
  1360.  
  1361.         /* updated in get modes as well since we need to know if it's analog or digital */
  1362.         radeon_connector_update_scratch_regs(connector, ret);
  1363.  
  1364.         if ((radeon_audio != 0) && radeon_connector->use_digital) {
  1365.                 const struct drm_connector_helper_funcs *connector_funcs =
  1366.                         connector->helper_private;
  1367.  
  1368.                 encoder = connector_funcs->best_encoder(connector);
  1369.                 if (encoder && (encoder->encoder_type == DRM_MODE_ENCODER_TMDS)) {
  1370.                         radeon_connector_get_edid(connector);
  1371.                         radeon_audio_detect(connector, encoder, ret);
  1372.                 }
  1373.         }
  1374.  
  1375. exit:
  1376.         return ret;
  1377. }
  1378.  
  1379. /* okay need to be smart in here about which encoder to pick */
  1380. static struct drm_encoder *radeon_dvi_encoder(struct drm_connector *connector)
  1381. {
  1382.         int enc_id = connector->encoder_ids[0];
  1383.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  1384.         struct drm_encoder *encoder;
  1385.         int i;
  1386.         for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
  1387.                 if (connector->encoder_ids[i] == 0)
  1388.                         break;
  1389.  
  1390.                 encoder = drm_encoder_find(connector->dev, connector->encoder_ids[i]);
  1391.                 if (!encoder)
  1392.                         continue;
  1393.  
  1394.                 if (radeon_connector->use_digital == true) {
  1395.                         if (encoder->encoder_type == DRM_MODE_ENCODER_TMDS)
  1396.                                 return encoder;
  1397.                 } else {
  1398.                         if (encoder->encoder_type == DRM_MODE_ENCODER_DAC ||
  1399.                             encoder->encoder_type == DRM_MODE_ENCODER_TVDAC)
  1400.                                 return encoder;
  1401.                 }
  1402.         }
  1403.  
  1404.         /* see if we have a default encoder  TODO */
  1405.  
  1406.         /* then check use digitial */
  1407.         /* pick the first one */
  1408.         if (enc_id)
  1409.                 return drm_encoder_find(connector->dev, enc_id);
  1410.         return NULL;
  1411. }
  1412.  
  1413. static void radeon_dvi_force(struct drm_connector *connector)
  1414. {
  1415.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  1416.         if (connector->force == DRM_FORCE_ON)
  1417.                 radeon_connector->use_digital = false;
  1418.         if (connector->force == DRM_FORCE_ON_DIGITAL)
  1419.                 radeon_connector->use_digital = true;
  1420. }
  1421.  
  1422. static int radeon_dvi_mode_valid(struct drm_connector *connector,
  1423.                                   struct drm_display_mode *mode)
  1424. {
  1425.         struct drm_device *dev = connector->dev;
  1426.         struct radeon_device *rdev = dev->dev_private;
  1427.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  1428.  
  1429.         /* XXX check mode bandwidth */
  1430.  
  1431.         /* clocks over 135 MHz have heat issues with DVI on RV100 */
  1432.         if (radeon_connector->use_digital &&
  1433.             (rdev->family == CHIP_RV100) &&
  1434.             (mode->clock > 135000))
  1435.                 return MODE_CLOCK_HIGH;
  1436.  
  1437.         if (radeon_connector->use_digital && (mode->clock > 165000)) {
  1438.                 if ((radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_I) ||
  1439.                     (radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_D) ||
  1440.                     (radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_HDMI_TYPE_B))
  1441.                         return MODE_OK;
  1442.                 else if (ASIC_IS_DCE6(rdev) && drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
  1443.                         /* HDMI 1.3+ supports max clock of 340 Mhz */
  1444.                         if (mode->clock > 340000)
  1445.                                 return MODE_CLOCK_HIGH;
  1446.                         else
  1447.                                 return MODE_OK;
  1448.                 } else {
  1449.                         return MODE_CLOCK_HIGH;
  1450.                 }
  1451.         }
  1452.  
  1453.         /* check against the max pixel clock */
  1454.         if ((mode->clock / 10) > rdev->clock.max_pixel_clock)
  1455.                 return MODE_CLOCK_HIGH;
  1456.  
  1457.         return MODE_OK;
  1458. }
  1459.  
  1460. static const struct drm_connector_helper_funcs radeon_dvi_connector_helper_funcs = {
  1461.         .get_modes = radeon_vga_get_modes,
  1462.         .mode_valid = radeon_dvi_mode_valid,
  1463.         .best_encoder = radeon_dvi_encoder,
  1464. };
  1465.  
  1466. static const struct drm_connector_funcs radeon_dvi_connector_funcs = {
  1467.         .dpms = drm_helper_connector_dpms,
  1468.         .detect = radeon_dvi_detect,
  1469.         .fill_modes = drm_helper_probe_single_connector_modes,
  1470.         .set_property = radeon_connector_set_property,
  1471.         .destroy = radeon_connector_destroy,
  1472.         .force = radeon_dvi_force,
  1473. };
  1474.  
  1475. static int radeon_dp_get_modes(struct drm_connector *connector)
  1476. {
  1477.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  1478.         struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
  1479.         struct drm_encoder *encoder = radeon_best_single_encoder(connector);
  1480.         int ret;
  1481.  
  1482.         if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) ||
  1483.             (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
  1484.                 struct drm_display_mode *mode;
  1485.  
  1486.                 if (connector->connector_type == DRM_MODE_CONNECTOR_eDP) {
  1487.                         if (!radeon_dig_connector->edp_on)
  1488.                                 atombios_set_edp_panel_power(connector,
  1489.                                                              ATOM_TRANSMITTER_ACTION_POWER_ON);
  1490.                         radeon_connector_get_edid(connector);
  1491.                         ret = radeon_ddc_get_modes(connector);
  1492.                         if (!radeon_dig_connector->edp_on)
  1493.                                 atombios_set_edp_panel_power(connector,
  1494.                                                              ATOM_TRANSMITTER_ACTION_POWER_OFF);
  1495.                 } else {
  1496.                         /* need to setup ddc on the bridge */
  1497.                         if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
  1498.                             ENCODER_OBJECT_ID_NONE) {
  1499.                                 if (encoder)
  1500.                                         radeon_atom_ext_encoder_setup_ddc(encoder);
  1501.                         }
  1502.                         radeon_connector_get_edid(connector);
  1503.                         ret = radeon_ddc_get_modes(connector);
  1504.                 }
  1505.  
  1506.                 if (ret > 0) {
  1507.                         if (encoder) {
  1508.                                 radeon_fixup_lvds_native_mode(encoder, connector);
  1509.                                 /* add scaled modes */
  1510.                                 radeon_add_common_modes(encoder, connector);
  1511.                         }
  1512.                         return ret;
  1513.                 }
  1514.  
  1515.                 if (!encoder)
  1516.                         return 0;
  1517.  
  1518.                 /* we have no EDID modes */
  1519.                 mode = radeon_fp_native_mode(encoder);
  1520.                 if (mode) {
  1521.                         ret = 1;
  1522.                         drm_mode_probed_add(connector, mode);
  1523.                         /* add the width/height from vbios tables if available */
  1524.                         connector->display_info.width_mm = mode->width_mm;
  1525.                         connector->display_info.height_mm = mode->height_mm;
  1526.                         /* add scaled modes */
  1527.                         radeon_add_common_modes(encoder, connector);
  1528.                 }
  1529.         } else {
  1530.                 /* need to setup ddc on the bridge */
  1531.                 if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
  1532.                         ENCODER_OBJECT_ID_NONE) {
  1533.                         if (encoder)
  1534.                                 radeon_atom_ext_encoder_setup_ddc(encoder);
  1535.                 }
  1536.                 radeon_connector_get_edid(connector);
  1537.                 ret = radeon_ddc_get_modes(connector);
  1538.  
  1539.                 radeon_get_native_mode(connector);
  1540.         }
  1541.  
  1542.         return ret;
  1543. }
  1544.  
  1545. u16 radeon_connector_encoder_get_dp_bridge_encoder_id(struct drm_connector *connector)
  1546. {
  1547.         struct drm_encoder *encoder;
  1548.         struct radeon_encoder *radeon_encoder;
  1549.         int i;
  1550.  
  1551.         for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
  1552.                 if (connector->encoder_ids[i] == 0)
  1553.                         break;
  1554.  
  1555.                 encoder = drm_encoder_find(connector->dev, connector->encoder_ids[i]);
  1556.                 if (!encoder)
  1557.                         continue;
  1558.  
  1559.                 radeon_encoder = to_radeon_encoder(encoder);
  1560.  
  1561.                 switch (radeon_encoder->encoder_id) {
  1562.                 case ENCODER_OBJECT_ID_TRAVIS:
  1563.                 case ENCODER_OBJECT_ID_NUTMEG:
  1564.                         return radeon_encoder->encoder_id;
  1565.                 default:
  1566.                         break;
  1567.                 }
  1568.         }
  1569.  
  1570.         return ENCODER_OBJECT_ID_NONE;
  1571. }
  1572.  
  1573. static bool radeon_connector_encoder_is_hbr2(struct drm_connector *connector)
  1574. {
  1575.         struct drm_encoder *encoder;
  1576.         struct radeon_encoder *radeon_encoder;
  1577.         int i;
  1578.         bool found = false;
  1579.  
  1580.         for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
  1581.                 if (connector->encoder_ids[i] == 0)
  1582.                         break;
  1583.  
  1584.                 encoder = drm_encoder_find(connector->dev, connector->encoder_ids[i]);
  1585.                 if (!encoder)
  1586.                         continue;
  1587.  
  1588.                 radeon_encoder = to_radeon_encoder(encoder);
  1589.                 if (radeon_encoder->caps & ATOM_ENCODER_CAP_RECORD_HBR2)
  1590.                         found = true;
  1591.         }
  1592.  
  1593.         return found;
  1594. }
  1595.  
  1596. bool radeon_connector_is_dp12_capable(struct drm_connector *connector)
  1597. {
  1598.         struct drm_device *dev = connector->dev;
  1599.         struct radeon_device *rdev = dev->dev_private;
  1600.  
  1601.         if (ASIC_IS_DCE5(rdev) &&
  1602.             (rdev->clock.default_dispclk >= 53900) &&
  1603.             radeon_connector_encoder_is_hbr2(connector)) {
  1604.                 return true;
  1605.         }
  1606.  
  1607.         return false;
  1608. }
  1609.  
  1610. static enum drm_connector_status
  1611. radeon_dp_detect(struct drm_connector *connector, bool force)
  1612. {
  1613.         struct drm_device *dev = connector->dev;
  1614.         struct radeon_device *rdev = dev->dev_private;
  1615.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  1616.         enum drm_connector_status ret = connector_status_disconnected;
  1617.         struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
  1618.         struct drm_encoder *encoder = radeon_best_single_encoder(connector);
  1619.         int r;
  1620.  
  1621.         if (radeon_dig_connector->is_mst)
  1622.                 return connector_status_disconnected;
  1623.  
  1624.         if (!force && radeon_check_hpd_status_unchanged(connector)) {
  1625.                 ret = connector->status;
  1626.                 goto out;
  1627.         }
  1628.  
  1629.         radeon_connector_free_edid(connector);
  1630.  
  1631.         if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) ||
  1632.             (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
  1633.                 if (encoder) {
  1634.                         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
  1635.                         struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
  1636.  
  1637.                         /* check if panel is valid */
  1638.                         if (native_mode->hdisplay >= 320 && native_mode->vdisplay >= 240)
  1639.                                 ret = connector_status_connected;
  1640.                         /* don't fetch the edid from the vbios if ddc fails and runpm is
  1641.                          * enabled so we report disconnected.
  1642.                          */
  1643.                         if ((rdev->flags & RADEON_IS_PX) && (radeon_runtime_pm != 0))
  1644.                                 ret = connector_status_disconnected;
  1645.                 }
  1646.                 /* eDP is always DP */
  1647.                 radeon_dig_connector->dp_sink_type = CONNECTOR_OBJECT_ID_DISPLAYPORT;
  1648.                 if (!radeon_dig_connector->edp_on)
  1649.                         atombios_set_edp_panel_power(connector,
  1650.                                                      ATOM_TRANSMITTER_ACTION_POWER_ON);
  1651.                 if (radeon_dp_getdpcd(radeon_connector))
  1652.                         ret = connector_status_connected;
  1653.                 if (!radeon_dig_connector->edp_on)
  1654.                         atombios_set_edp_panel_power(connector,
  1655.                                                      ATOM_TRANSMITTER_ACTION_POWER_OFF);
  1656.         } else if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
  1657.                    ENCODER_OBJECT_ID_NONE) {
  1658.                 /* DP bridges are always DP */
  1659.                 radeon_dig_connector->dp_sink_type = CONNECTOR_OBJECT_ID_DISPLAYPORT;
  1660.                 /* get the DPCD from the bridge */
  1661.                 radeon_dp_getdpcd(radeon_connector);
  1662.  
  1663.                 if (encoder) {
  1664.                         /* setup ddc on the bridge */
  1665.                         radeon_atom_ext_encoder_setup_ddc(encoder);
  1666.                         /* bridge chips are always aux */
  1667.                         if (radeon_ddc_probe(radeon_connector, true)) /* try DDC */
  1668.                                 ret = connector_status_connected;
  1669.                         else if (radeon_connector->dac_load_detect) { /* try load detection */
  1670.                                 const struct drm_encoder_helper_funcs *encoder_funcs = encoder->helper_private;
  1671.                                 ret = encoder_funcs->detect(encoder, connector);
  1672.                         }
  1673.                 }
  1674.         } else {
  1675.                 radeon_dig_connector->dp_sink_type = radeon_dp_getsinktype(radeon_connector);
  1676.                 if (radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) {
  1677.                         ret = connector_status_connected;
  1678.                         if (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) {
  1679.                                 radeon_dp_getdpcd(radeon_connector);
  1680.                                 r = radeon_dp_mst_probe(radeon_connector);
  1681.                                 if (r == 1)
  1682.                                         ret = connector_status_disconnected;
  1683.                         }
  1684.                 } else {
  1685.                         if (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) {
  1686.                                 if (radeon_dp_getdpcd(radeon_connector)) {
  1687.                                         r = radeon_dp_mst_probe(radeon_connector);
  1688.                                         if (r == 1)
  1689.                                                 ret = connector_status_disconnected;
  1690.                                         else
  1691.                                                 ret = connector_status_connected;
  1692.                                 }
  1693.                         } else {
  1694.                                 /* try non-aux ddc (DP to DVI/HDMI/etc. adapter) */
  1695.                                 if (radeon_ddc_probe(radeon_connector, false))
  1696.                                         ret = connector_status_connected;
  1697.                         }
  1698.                 }
  1699.         }
  1700.  
  1701.         radeon_connector_update_scratch_regs(connector, ret);
  1702.  
  1703.         if ((radeon_audio != 0) && encoder) {
  1704.                 radeon_connector_get_edid(connector);
  1705.                 radeon_audio_detect(connector, encoder, ret);
  1706.         }
  1707.  
  1708. out:
  1709.         return ret;
  1710. }
  1711.  
  1712. static int radeon_dp_mode_valid(struct drm_connector *connector,
  1713.                                   struct drm_display_mode *mode)
  1714. {
  1715.         struct drm_device *dev = connector->dev;
  1716.         struct radeon_device *rdev = dev->dev_private;
  1717.         struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  1718.         struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
  1719.  
  1720.         /* XXX check mode bandwidth */
  1721.  
  1722.         if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) ||
  1723.             (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
  1724.                 struct drm_encoder *encoder = radeon_best_single_encoder(connector);
  1725.  
  1726.                 if ((mode->hdisplay < 320) || (mode->vdisplay < 240))
  1727.                         return MODE_PANEL;
  1728.  
  1729.                 if (encoder) {
  1730.                         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
  1731.                         struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
  1732.  
  1733.                         /* AVIVO hardware supports downscaling modes larger than the panel
  1734.                          * to the panel size, but I'm not sure this is desirable.
  1735.                          */
  1736.                         if ((mode->hdisplay > native_mode->hdisplay) ||
  1737.                             (mode->vdisplay > native_mode->vdisplay))
  1738.                                 return MODE_PANEL;
  1739.  
  1740.                         /* if scaling is disabled, block non-native modes */
  1741.                         if (radeon_encoder->rmx_type == RMX_OFF) {
  1742.                                 if ((mode->hdisplay != native_mode->hdisplay) ||
  1743.                                     (mode->vdisplay != native_mode->vdisplay))
  1744.                                         return MODE_PANEL;
  1745.                         }
  1746.                 }
  1747.         } else {
  1748.                 if ((radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) ||
  1749.                     (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_eDP)) {
  1750.                         return radeon_dp_mode_valid_helper(connector, mode);
  1751.                 } else {
  1752.                         if (ASIC_IS_DCE6(rdev) && drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
  1753.                                 /* HDMI 1.3+ supports max clock of 340 Mhz */
  1754.                                 if (mode->clock > 340000)
  1755.                                         return MODE_CLOCK_HIGH;
  1756.                         } else {
  1757.                                 if (mode->clock > 165000)
  1758.                                         return MODE_CLOCK_HIGH;
  1759.                         }
  1760.                 }
  1761.         }
  1762.  
  1763.         return MODE_OK;
  1764. }
  1765.  
  1766. static const struct drm_connector_helper_funcs radeon_dp_connector_helper_funcs = {
  1767.         .get_modes = radeon_dp_get_modes,
  1768.         .mode_valid = radeon_dp_mode_valid,
  1769.         .best_encoder = radeon_dvi_encoder,
  1770. };
  1771.  
  1772. static const struct drm_connector_funcs radeon_dp_connector_funcs = {
  1773.         .dpms = drm_helper_connector_dpms,
  1774.         .detect = radeon_dp_detect,
  1775.         .fill_modes = drm_helper_probe_single_connector_modes,
  1776.         .set_property = radeon_connector_set_property,
  1777.         .destroy = radeon_connector_destroy,
  1778.         .force = radeon_dvi_force,
  1779. };
  1780.  
  1781. static const struct drm_connector_funcs radeon_edp_connector_funcs = {
  1782.         .dpms = drm_helper_connector_dpms,
  1783.         .detect = radeon_dp_detect,
  1784.         .fill_modes = drm_helper_probe_single_connector_modes,
  1785.         .set_property = radeon_lvds_set_property,
  1786.         .destroy = radeon_connector_destroy,
  1787.         .force = radeon_dvi_force,
  1788. };
  1789.  
  1790. static const struct drm_connector_funcs radeon_lvds_bridge_connector_funcs = {
  1791.         .dpms = drm_helper_connector_dpms,
  1792.         .detect = radeon_dp_detect,
  1793.         .fill_modes = drm_helper_probe_single_connector_modes,
  1794.         .set_property = radeon_lvds_set_property,
  1795.         .destroy = radeon_connector_destroy,
  1796.         .force = radeon_dvi_force,
  1797. };
  1798.  
  1799. void
  1800. radeon_add_atom_connector(struct drm_device *dev,
  1801.                           uint32_t connector_id,
  1802.                           uint32_t supported_device,
  1803.                           int connector_type,
  1804.                           struct radeon_i2c_bus_rec *i2c_bus,
  1805.                           uint32_t igp_lane_info,
  1806.                           uint16_t connector_object_id,
  1807.                           struct radeon_hpd *hpd,
  1808.                           struct radeon_router *router)
  1809. {
  1810.         struct radeon_device *rdev = dev->dev_private;
  1811.         struct drm_connector *connector;
  1812.         struct radeon_connector *radeon_connector;
  1813.         struct radeon_connector_atom_dig *radeon_dig_connector;
  1814.         struct drm_encoder *encoder;
  1815.         struct radeon_encoder *radeon_encoder;
  1816.         uint32_t subpixel_order = SubPixelNone;
  1817.         bool shared_ddc = false;
  1818.         bool is_dp_bridge = false;
  1819.         bool has_aux = false;
  1820.  
  1821.         if (connector_type == DRM_MODE_CONNECTOR_Unknown)
  1822.                 return;
  1823.  
  1824.         /* if the user selected tv=0 don't try and add the connector */
  1825.         if (((connector_type == DRM_MODE_CONNECTOR_SVIDEO) ||
  1826.              (connector_type == DRM_MODE_CONNECTOR_Composite) ||
  1827.              (connector_type == DRM_MODE_CONNECTOR_9PinDIN)) &&
  1828.             (radeon_tv == 0))
  1829.                 return;
  1830.  
  1831.         /* see if we already added it */
  1832.         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
  1833.                 radeon_connector = to_radeon_connector(connector);
  1834.                 if (radeon_connector->connector_id == connector_id) {
  1835.                         radeon_connector->devices |= supported_device;
  1836.                         return;
  1837.                 }
  1838.                 if (radeon_connector->ddc_bus && i2c_bus->valid) {
  1839.                         if (radeon_connector->ddc_bus->rec.i2c_id == i2c_bus->i2c_id) {
  1840.                                 radeon_connector->shared_ddc = true;
  1841.                                 shared_ddc = true;
  1842.                         }
  1843.                         if (radeon_connector->router_bus && router->ddc_valid &&
  1844.                             (radeon_connector->router.router_id == router->router_id)) {
  1845.                                 radeon_connector->shared_ddc = false;
  1846.                                 shared_ddc = false;
  1847.                         }
  1848.                 }
  1849.         }
  1850.  
  1851.         /* check if it's a dp bridge */
  1852.         list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
  1853.                 radeon_encoder = to_radeon_encoder(encoder);
  1854.                 if (radeon_encoder->devices & supported_device) {
  1855.                         switch (radeon_encoder->encoder_id) {
  1856.                         case ENCODER_OBJECT_ID_TRAVIS:
  1857.                         case ENCODER_OBJECT_ID_NUTMEG:
  1858.                                 is_dp_bridge = true;
  1859.                                 break;
  1860.                         default:
  1861.                                 break;
  1862.                         }
  1863.                 }
  1864.         }
  1865.  
  1866.         radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
  1867.         if (!radeon_connector)
  1868.                 return;
  1869.  
  1870.         connector = &radeon_connector->base;
  1871.  
  1872.         radeon_connector->connector_id = connector_id;
  1873.         radeon_connector->devices = supported_device;
  1874.         radeon_connector->shared_ddc = shared_ddc;
  1875.         radeon_connector->connector_object_id = connector_object_id;
  1876.         radeon_connector->hpd = *hpd;
  1877.  
  1878.         radeon_connector->router = *router;
  1879.         if (router->ddc_valid || router->cd_valid) {
  1880.                 radeon_connector->router_bus = radeon_i2c_lookup(rdev, &router->i2c_info);
  1881.                 if (!radeon_connector->router_bus)
  1882.                         DRM_ERROR("Failed to assign router i2c bus! Check dmesg for i2c errors.\n");
  1883.         }
  1884.  
  1885.         if (is_dp_bridge) {
  1886.                 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
  1887.                 if (!radeon_dig_connector)
  1888.                         goto failed;
  1889.                 radeon_dig_connector->igp_lane_info = igp_lane_info;
  1890.                 radeon_connector->con_priv = radeon_dig_connector;
  1891.                 if (i2c_bus->valid) {
  1892.                         radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
  1893.                         if (radeon_connector->ddc_bus)
  1894.                                 has_aux = true;
  1895.                         else
  1896.                                 DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
  1897.                 }
  1898.                 switch (connector_type) {
  1899.                 case DRM_MODE_CONNECTOR_VGA:
  1900.                 case DRM_MODE_CONNECTOR_DVIA:
  1901.                 default:
  1902.                         drm_connector_init(dev, &radeon_connector->base,
  1903.                                            &radeon_dp_connector_funcs, connector_type);
  1904.                         drm_connector_helper_add(&radeon_connector->base,
  1905.                                                  &radeon_dp_connector_helper_funcs);
  1906.                         connector->interlace_allowed = true;
  1907.                         connector->doublescan_allowed = true;
  1908.                         radeon_connector->dac_load_detect = true;
  1909.                         drm_object_attach_property(&radeon_connector->base.base,
  1910.                                                       rdev->mode_info.load_detect_property,
  1911.                                                       1);
  1912.                         drm_object_attach_property(&radeon_connector->base.base,
  1913.                                                    dev->mode_config.scaling_mode_property,
  1914.                                                    DRM_MODE_SCALE_NONE);
  1915.                         if (ASIC_IS_DCE5(rdev))
  1916.                                 drm_object_attach_property(&radeon_connector->base.base,
  1917.                                                            rdev->mode_info.output_csc_property,
  1918.                                                            RADEON_OUTPUT_CSC_BYPASS);
  1919.                         break;
  1920.                 case DRM_MODE_CONNECTOR_DVII:
  1921.                 case DRM_MODE_CONNECTOR_DVID:
  1922.                 case DRM_MODE_CONNECTOR_HDMIA:
  1923.                 case DRM_MODE_CONNECTOR_HDMIB:
  1924.                 case DRM_MODE_CONNECTOR_DisplayPort:
  1925.                         drm_connector_init(dev, &radeon_connector->base,
  1926.                                            &radeon_dp_connector_funcs, connector_type);
  1927.                         drm_connector_helper_add(&radeon_connector->base,
  1928.                                                  &radeon_dp_connector_helper_funcs);
  1929.                         drm_object_attach_property(&radeon_connector->base.base,
  1930.                                                       rdev->mode_info.underscan_property,
  1931.                                                       UNDERSCAN_OFF);
  1932.                         drm_object_attach_property(&radeon_connector->base.base,
  1933.                                                       rdev->mode_info.underscan_hborder_property,
  1934.                                                       0);
  1935.                         drm_object_attach_property(&radeon_connector->base.base,
  1936.                                                       rdev->mode_info.underscan_vborder_property,
  1937.                                                       0);
  1938.  
  1939.                         drm_object_attach_property(&radeon_connector->base.base,
  1940.                                                       dev->mode_config.scaling_mode_property,
  1941.                                                       DRM_MODE_SCALE_NONE);
  1942.  
  1943.                         drm_object_attach_property(&radeon_connector->base.base,
  1944.                                                    rdev->mode_info.dither_property,
  1945.                                                    RADEON_FMT_DITHER_DISABLE);
  1946.  
  1947.                         if (radeon_audio != 0)
  1948.                                 drm_object_attach_property(&radeon_connector->base.base,
  1949.                                                            rdev->mode_info.audio_property,
  1950.                                                            RADEON_AUDIO_AUTO);
  1951.                         if (ASIC_IS_DCE5(rdev))
  1952.                                 drm_object_attach_property(&radeon_connector->base.base,
  1953.                                                            rdev->mode_info.output_csc_property,
  1954.                                                            RADEON_OUTPUT_CSC_BYPASS);
  1955.  
  1956.                         subpixel_order = SubPixelHorizontalRGB;
  1957.                         connector->interlace_allowed = true;
  1958.                         if (connector_type == DRM_MODE_CONNECTOR_HDMIB)
  1959.                                 connector->doublescan_allowed = true;
  1960.                         else
  1961.                                 connector->doublescan_allowed = false;
  1962.                         if (connector_type == DRM_MODE_CONNECTOR_DVII) {
  1963.                                 radeon_connector->dac_load_detect = true;
  1964.                                 drm_object_attach_property(&radeon_connector->base.base,
  1965.                                                               rdev->mode_info.load_detect_property,
  1966.                                                               1);
  1967.                         }
  1968.                         break;
  1969.                 case DRM_MODE_CONNECTOR_LVDS:
  1970.                 case DRM_MODE_CONNECTOR_eDP:
  1971.                         drm_connector_init(dev, &radeon_connector->base,
  1972.                                            &radeon_lvds_bridge_connector_funcs, connector_type);
  1973.                         drm_connector_helper_add(&radeon_connector->base,
  1974.                                                  &radeon_dp_connector_helper_funcs);
  1975.                         drm_object_attach_property(&radeon_connector->base.base,
  1976.                                                       dev->mode_config.scaling_mode_property,
  1977.                                                       DRM_MODE_SCALE_FULLSCREEN);
  1978.                         subpixel_order = SubPixelHorizontalRGB;
  1979.                         connector->interlace_allowed = false;
  1980.                         connector->doublescan_allowed = false;
  1981.                         break;
  1982.                 }
  1983.         } else {
  1984.                 switch (connector_type) {
  1985.                 case DRM_MODE_CONNECTOR_VGA:
  1986.                         drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
  1987.                         drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
  1988.                         if (i2c_bus->valid) {
  1989.                                 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
  1990.                                 if (!radeon_connector->ddc_bus)
  1991.                                         DRM_ERROR("VGA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
  1992.                         }
  1993.                         radeon_connector->dac_load_detect = true;
  1994.                         drm_object_attach_property(&radeon_connector->base.base,
  1995.                                                       rdev->mode_info.load_detect_property,
  1996.                                                       1);
  1997.                         if (ASIC_IS_AVIVO(rdev))
  1998.                                 drm_object_attach_property(&radeon_connector->base.base,
  1999.                                                            dev->mode_config.scaling_mode_property,
  2000.                                                            DRM_MODE_SCALE_NONE);
  2001.                         if (ASIC_IS_DCE5(rdev))
  2002.                                 drm_object_attach_property(&radeon_connector->base.base,
  2003.                                                            rdev->mode_info.output_csc_property,
  2004.                                                            RADEON_OUTPUT_CSC_BYPASS);
  2005.                         /* no HPD on analog connectors */
  2006.                         radeon_connector->hpd.hpd = RADEON_HPD_NONE;
  2007.                         connector->polled = DRM_CONNECTOR_POLL_CONNECT;
  2008.                         connector->interlace_allowed = true;
  2009.                         connector->doublescan_allowed = true;
  2010.                         break;
  2011.                 case DRM_MODE_CONNECTOR_DVIA:
  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("DVIA: 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->interlace_allowed = true;
  2034.                         connector->doublescan_allowed = true;
  2035.                         break;
  2036.                 case DRM_MODE_CONNECTOR_DVII:
  2037.                 case DRM_MODE_CONNECTOR_DVID:
  2038.                         radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
  2039.                         if (!radeon_dig_connector)
  2040.                                 goto failed;
  2041.                         radeon_dig_connector->igp_lane_info = igp_lane_info;
  2042.                         radeon_connector->con_priv = radeon_dig_connector;
  2043.                         drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
  2044.                         drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
  2045.                         if (i2c_bus->valid) {
  2046.                                 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
  2047.                                 if (!radeon_connector->ddc_bus)
  2048.                                         DRM_ERROR("DVI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
  2049.                         }
  2050.                         subpixel_order = SubPixelHorizontalRGB;
  2051.                         drm_object_attach_property(&radeon_connector->base.base,
  2052.                                                       rdev->mode_info.coherent_mode_property,
  2053.                                                       1);
  2054.                         if (ASIC_IS_AVIVO(rdev)) {
  2055.                                 drm_object_attach_property(&radeon_connector->base.base,
  2056.                                                               rdev->mode_info.underscan_property,
  2057.                                                               UNDERSCAN_OFF);
  2058.                                 drm_object_attach_property(&radeon_connector->base.base,
  2059.                                                               rdev->mode_info.underscan_hborder_property,
  2060.                                                               0);
  2061.                                 drm_object_attach_property(&radeon_connector->base.base,
  2062.                                                               rdev->mode_info.underscan_vborder_property,
  2063.                                                               0);
  2064.                                 drm_object_attach_property(&radeon_connector->base.base,
  2065.                                                            rdev->mode_info.dither_property,
  2066.                                                            RADEON_FMT_DITHER_DISABLE);
  2067.                                 drm_object_attach_property(&radeon_connector->base.base,
  2068.                                                            dev->mode_config.scaling_mode_property,
  2069.                                                            DRM_MODE_SCALE_NONE);
  2070.                         }
  2071.                         if (ASIC_IS_DCE2(rdev) && (radeon_audio != 0)) {
  2072.                                 drm_object_attach_property(&radeon_connector->base.base,
  2073.                                                            rdev->mode_info.audio_property,
  2074.                                                            RADEON_AUDIO_AUTO);
  2075.                         }
  2076.                         if (connector_type == DRM_MODE_CONNECTOR_DVII) {
  2077.                                 radeon_connector->dac_load_detect = true;
  2078.                                 drm_object_attach_property(&radeon_connector->base.base,
  2079.                                                               rdev->mode_info.load_detect_property,
  2080.                                                               1);
  2081.                         }
  2082.                         if (ASIC_IS_DCE5(rdev))
  2083.                                 drm_object_attach_property(&radeon_connector->base.base,
  2084.                                                            rdev->mode_info.output_csc_property,
  2085.                                                            RADEON_OUTPUT_CSC_BYPASS);
  2086.                         connector->interlace_allowed = true;
  2087.                         if (connector_type == DRM_MODE_CONNECTOR_DVII)
  2088.                                 connector->doublescan_allowed = true;
  2089.                         else
  2090.                                 connector->doublescan_allowed = false;
  2091.                         break;
  2092.                 case DRM_MODE_CONNECTOR_HDMIA:
  2093.                 case DRM_MODE_CONNECTOR_HDMIB:
  2094.                         radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
  2095.                         if (!radeon_dig_connector)
  2096.                                 goto failed;
  2097.                         radeon_dig_connector->igp_lane_info = igp_lane_info;
  2098.                         radeon_connector->con_priv = radeon_dig_connector;
  2099.                         drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
  2100.                         drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
  2101.                         if (i2c_bus->valid) {
  2102.                                 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
  2103.                                 if (!radeon_connector->ddc_bus)
  2104.                                         DRM_ERROR("HDMI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
  2105.                         }
  2106.                         drm_object_attach_property(&radeon_connector->base.base,
  2107.                                                       rdev->mode_info.coherent_mode_property,
  2108.                                                       1);
  2109.                         if (ASIC_IS_AVIVO(rdev)) {
  2110.                                 drm_object_attach_property(&radeon_connector->base.base,
  2111.                                                               rdev->mode_info.underscan_property,
  2112.                                                               UNDERSCAN_OFF);
  2113.                                 drm_object_attach_property(&radeon_connector->base.base,
  2114.                                                               rdev->mode_info.underscan_hborder_property,
  2115.                                                               0);
  2116.                                 drm_object_attach_property(&radeon_connector->base.base,
  2117.                                                               rdev->mode_info.underscan_vborder_property,
  2118.                                                               0);
  2119.                                 drm_object_attach_property(&radeon_connector->base.base,
  2120.                                                            rdev->mode_info.dither_property,
  2121.                                                            RADEON_FMT_DITHER_DISABLE);
  2122.                                 drm_object_attach_property(&radeon_connector->base.base,
  2123.                                                            dev->mode_config.scaling_mode_property,
  2124.                                                            DRM_MODE_SCALE_NONE);
  2125.                         }
  2126.                         if (ASIC_IS_DCE2(rdev) && (radeon_audio != 0)) {
  2127.                                 drm_object_attach_property(&radeon_connector->base.base,
  2128.                                                            rdev->mode_info.audio_property,
  2129.                                                            RADEON_AUDIO_AUTO);
  2130.                         }
  2131.                         if (ASIC_IS_DCE5(rdev))
  2132.                                 drm_object_attach_property(&radeon_connector->base.base,
  2133.                                                            rdev->mode_info.output_csc_property,
  2134.                                                            RADEON_OUTPUT_CSC_BYPASS);
  2135.                         subpixel_order = SubPixelHorizontalRGB;
  2136.                         connector->interlace_allowed = true;
  2137.                         if (connector_type == DRM_MODE_CONNECTOR_HDMIB)
  2138.                                 connector->doublescan_allowed = true;
  2139.                         else
  2140.                                 connector->doublescan_allowed = false;
  2141.                         break;
  2142.                 case DRM_MODE_CONNECTOR_DisplayPort:
  2143.                         radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
  2144.                         if (!radeon_dig_connector)
  2145.                                 goto failed;
  2146.                         radeon_dig_connector->igp_lane_info = igp_lane_info;
  2147.                         radeon_connector->con_priv = radeon_dig_connector;
  2148.                         drm_connector_init(dev, &radeon_connector->base, &radeon_dp_connector_funcs, connector_type);
  2149.                         drm_connector_helper_add(&radeon_connector->base, &radeon_dp_connector_helper_funcs);
  2150.                         if (i2c_bus->valid) {
  2151.                                 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
  2152.                                 if (radeon_connector->ddc_bus)
  2153.                                         has_aux = true;
  2154.                                 else
  2155.                                         DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
  2156.                         }
  2157.                         subpixel_order = SubPixelHorizontalRGB;
  2158.                         drm_object_attach_property(&radeon_connector->base.base,
  2159.                                                       rdev->mode_info.coherent_mode_property,
  2160.                                                       1);
  2161.                         if (ASIC_IS_AVIVO(rdev)) {
  2162.                                 drm_object_attach_property(&radeon_connector->base.base,
  2163.                                                               rdev->mode_info.underscan_property,
  2164.                                                               UNDERSCAN_OFF);
  2165.                                 drm_object_attach_property(&radeon_connector->base.base,
  2166.                                                               rdev->mode_info.underscan_hborder_property,
  2167.                                                               0);
  2168.                                 drm_object_attach_property(&radeon_connector->base.base,
  2169.                                                               rdev->mode_info.underscan_vborder_property,
  2170.                                                               0);
  2171.                                 drm_object_attach_property(&radeon_connector->base.base,
  2172.                                                            rdev->mode_info.dither_property,
  2173.                                                            RADEON_FMT_DITHER_DISABLE);
  2174.                                 drm_object_attach_property(&radeon_connector->base.base,
  2175.                                                            dev->mode_config.scaling_mode_property,
  2176.                                                            DRM_MODE_SCALE_NONE);
  2177.                         }
  2178.                         if (ASIC_IS_DCE2(rdev) && (radeon_audio != 0)) {
  2179.                                 drm_object_attach_property(&radeon_connector->base.base,
  2180.                                                            rdev->mode_info.audio_property,
  2181.                                                            RADEON_AUDIO_AUTO);
  2182.                         }
  2183.                         if (ASIC_IS_DCE5(rdev))
  2184.                                 drm_object_attach_property(&radeon_connector->base.base,
  2185.                                                            rdev->mode_info.output_csc_property,
  2186.                                                            RADEON_OUTPUT_CSC_BYPASS);
  2187.                         connector->interlace_allowed = true;
  2188.                         /* in theory with a DP to VGA converter... */
  2189.                         connector->doublescan_allowed = false;
  2190.                         break;
  2191.                 case DRM_MODE_CONNECTOR_eDP:
  2192.                         radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
  2193.                         if (!radeon_dig_connector)
  2194.                                 goto failed;
  2195.                         radeon_dig_connector->igp_lane_info = igp_lane_info;
  2196.                         radeon_connector->con_priv = radeon_dig_connector;
  2197.                         drm_connector_init(dev, &radeon_connector->base, &radeon_edp_connector_funcs, connector_type);
  2198.                         drm_connector_helper_add(&radeon_connector->base, &radeon_dp_connector_helper_funcs);
  2199.                         if (i2c_bus->valid) {
  2200.                                 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
  2201.                                 if (radeon_connector->ddc_bus)
  2202.                                         has_aux = true;
  2203.                                 else
  2204.                                         DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
  2205.                         }
  2206.                         drm_object_attach_property(&radeon_connector->base.base,
  2207.                                                       dev->mode_config.scaling_mode_property,
  2208.                                                       DRM_MODE_SCALE_FULLSCREEN);
  2209.                         subpixel_order = SubPixelHorizontalRGB;
  2210.                         connector->interlace_allowed = false;
  2211.                         connector->doublescan_allowed = false;
  2212.                         break;
  2213.                 case DRM_MODE_CONNECTOR_SVIDEO:
  2214.                 case DRM_MODE_CONNECTOR_Composite:
  2215.                 case DRM_MODE_CONNECTOR_9PinDIN:
  2216.                         drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
  2217.                         drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
  2218.                         radeon_connector->dac_load_detect = true;
  2219.                         drm_object_attach_property(&radeon_connector->base.base,
  2220.                                                       rdev->mode_info.load_detect_property,
  2221.                                                       1);
  2222.                         drm_object_attach_property(&radeon_connector->base.base,
  2223.                                                       rdev->mode_info.tv_std_property,
  2224.                                                       radeon_atombios_get_tv_info(rdev));
  2225.                         /* no HPD on analog connectors */
  2226.                         radeon_connector->hpd.hpd = RADEON_HPD_NONE;
  2227.                         connector->interlace_allowed = false;
  2228.                         connector->doublescan_allowed = false;
  2229.                         break;
  2230.                 case DRM_MODE_CONNECTOR_LVDS:
  2231.                         radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
  2232.                         if (!radeon_dig_connector)
  2233.                                 goto failed;
  2234.                         radeon_dig_connector->igp_lane_info = igp_lane_info;
  2235.                         radeon_connector->con_priv = radeon_dig_connector;
  2236.                         drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
  2237.                         drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
  2238.                         if (i2c_bus->valid) {
  2239.                                 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
  2240.                                 if (!radeon_connector->ddc_bus)
  2241.                                         DRM_ERROR("LVDS: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
  2242.                         }
  2243.                         drm_object_attach_property(&radeon_connector->base.base,
  2244.                                                       dev->mode_config.scaling_mode_property,
  2245.                                                       DRM_MODE_SCALE_FULLSCREEN);
  2246.                         subpixel_order = SubPixelHorizontalRGB;
  2247.                         connector->interlace_allowed = false;
  2248.                         connector->doublescan_allowed = false;
  2249.                         break;
  2250.                 }
  2251.         }
  2252.  
  2253.         if (radeon_connector->hpd.hpd == RADEON_HPD_NONE) {
  2254.                 if (i2c_bus->valid)
  2255.                         connector->polled = DRM_CONNECTOR_POLL_CONNECT;
  2256.         } else
  2257.                 connector->polled = DRM_CONNECTOR_POLL_HPD;
  2258.  
  2259.         connector->display_info.subpixel_order = subpixel_order;
  2260.         drm_connector_register(connector);
  2261.  
  2262.         if (has_aux)
  2263.                 radeon_dp_aux_init(radeon_connector);
  2264.  
  2265.         return;
  2266.  
  2267. failed:
  2268.         drm_connector_cleanup(connector);
  2269.         kfree(connector);
  2270. }
  2271.  
  2272. void
  2273. radeon_add_legacy_connector(struct drm_device *dev,
  2274.                             uint32_t connector_id,
  2275.                             uint32_t supported_device,
  2276.                             int connector_type,
  2277.                             struct radeon_i2c_bus_rec *i2c_bus,
  2278.                             uint16_t connector_object_id,
  2279.                             struct radeon_hpd *hpd)
  2280. {
  2281.         struct radeon_device *rdev = dev->dev_private;
  2282.         struct drm_connector *connector;
  2283.         struct radeon_connector *radeon_connector;
  2284.         uint32_t subpixel_order = SubPixelNone;
  2285.  
  2286.         if (connector_type == DRM_MODE_CONNECTOR_Unknown)
  2287.                 return;
  2288.  
  2289.         /* if the user selected tv=0 don't try and add the connector */
  2290.         if (((connector_type == DRM_MODE_CONNECTOR_SVIDEO) ||
  2291.              (connector_type == DRM_MODE_CONNECTOR_Composite) ||
  2292.              (connector_type == DRM_MODE_CONNECTOR_9PinDIN)) &&
  2293.             (radeon_tv == 0))
  2294.                 return;
  2295.  
  2296.         /* see if we already added it */
  2297.         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
  2298.                 radeon_connector = to_radeon_connector(connector);
  2299.                 if (radeon_connector->connector_id == connector_id) {
  2300.                         radeon_connector->devices |= supported_device;
  2301.                         return;
  2302.                 }
  2303.         }
  2304.  
  2305.         radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
  2306.         if (!radeon_connector)
  2307.                 return;
  2308.  
  2309.         connector = &radeon_connector->base;
  2310.  
  2311.         radeon_connector->connector_id = connector_id;
  2312.         radeon_connector->devices = supported_device;
  2313.         radeon_connector->connector_object_id = connector_object_id;
  2314.         radeon_connector->hpd = *hpd;
  2315.  
  2316.         switch (connector_type) {
  2317.         case DRM_MODE_CONNECTOR_VGA:
  2318.                 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
  2319.                 drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
  2320.                 if (i2c_bus->valid) {
  2321.                         radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
  2322.                         if (!radeon_connector->ddc_bus)
  2323.                                 DRM_ERROR("VGA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
  2324.                 }
  2325.                 radeon_connector->dac_load_detect = true;
  2326.                 drm_object_attach_property(&radeon_connector->base.base,
  2327.                                               rdev->mode_info.load_detect_property,
  2328.                                               1);
  2329.                 /* no HPD on analog connectors */
  2330.                 radeon_connector->hpd.hpd = RADEON_HPD_NONE;
  2331.                 connector->polled = DRM_CONNECTOR_POLL_CONNECT;
  2332.                 connector->interlace_allowed = true;
  2333.                 connector->doublescan_allowed = true;
  2334.                 break;
  2335.         case DRM_MODE_CONNECTOR_DVIA:
  2336.                 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
  2337.                 drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
  2338.                 if (i2c_bus->valid) {
  2339.                         radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
  2340.                         if (!radeon_connector->ddc_bus)
  2341.                                 DRM_ERROR("DVIA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
  2342.                 }
  2343.                 radeon_connector->dac_load_detect = true;
  2344.                 drm_object_attach_property(&radeon_connector->base.base,
  2345.                                               rdev->mode_info.load_detect_property,
  2346.                                               1);
  2347.                 /* no HPD on analog connectors */
  2348.                 radeon_connector->hpd.hpd = RADEON_HPD_NONE;
  2349.                 connector->interlace_allowed = true;
  2350.                 connector->doublescan_allowed = true;
  2351.                 break;
  2352.         case DRM_MODE_CONNECTOR_DVII:
  2353.         case DRM_MODE_CONNECTOR_DVID:
  2354.                 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
  2355.                 drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
  2356.                 if (i2c_bus->valid) {
  2357.                         radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
  2358.                         if (!radeon_connector->ddc_bus)
  2359.                                 DRM_ERROR("DVI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
  2360.                 }
  2361.                 if (connector_type == DRM_MODE_CONNECTOR_DVII) {
  2362.                         radeon_connector->dac_load_detect = true;
  2363.                         drm_object_attach_property(&radeon_connector->base.base,
  2364.                                                       rdev->mode_info.load_detect_property,
  2365.                                                       1);
  2366.                 }
  2367.                 subpixel_order = SubPixelHorizontalRGB;
  2368.                 connector->interlace_allowed = true;
  2369.                 if (connector_type == DRM_MODE_CONNECTOR_DVII)
  2370.                         connector->doublescan_allowed = true;
  2371.                 else
  2372.                         connector->doublescan_allowed = false;
  2373.                 break;
  2374.         case DRM_MODE_CONNECTOR_SVIDEO:
  2375.         case DRM_MODE_CONNECTOR_Composite:
  2376.         case DRM_MODE_CONNECTOR_9PinDIN:
  2377.                 drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
  2378.                 drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
  2379.                 radeon_connector->dac_load_detect = true;
  2380.                 /* RS400,RC410,RS480 chipset seems to report a lot
  2381.                  * of false positive on load detect, we haven't yet
  2382.                  * found a way to make load detect reliable on those
  2383.                  * chipset, thus just disable it for TV.
  2384.                  */
  2385.                 if (rdev->family == CHIP_RS400 || rdev->family == CHIP_RS480)
  2386.                         radeon_connector->dac_load_detect = false;
  2387.                 drm_object_attach_property(&radeon_connector->base.base,
  2388.                                               rdev->mode_info.load_detect_property,
  2389.                                               radeon_connector->dac_load_detect);
  2390.                 drm_object_attach_property(&radeon_connector->base.base,
  2391.                                               rdev->mode_info.tv_std_property,
  2392.                                               radeon_combios_get_tv_info(rdev));
  2393.                 /* no HPD on analog connectors */
  2394.                 radeon_connector->hpd.hpd = RADEON_HPD_NONE;
  2395.                 connector->interlace_allowed = false;
  2396.                 connector->doublescan_allowed = false;
  2397.                 break;
  2398.         case DRM_MODE_CONNECTOR_LVDS:
  2399.                 drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
  2400.                 drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
  2401.                 if (i2c_bus->valid) {
  2402.                         radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
  2403.                         if (!radeon_connector->ddc_bus)
  2404.                                 DRM_ERROR("LVDS: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
  2405.                 }
  2406.                 drm_object_attach_property(&radeon_connector->base.base,
  2407.                                               dev->mode_config.scaling_mode_property,
  2408.                                               DRM_MODE_SCALE_FULLSCREEN);
  2409.                 subpixel_order = SubPixelHorizontalRGB;
  2410.                 connector->interlace_allowed = false;
  2411.                 connector->doublescan_allowed = false;
  2412.                 break;
  2413.         }
  2414.  
  2415.         if (radeon_connector->hpd.hpd == RADEON_HPD_NONE) {
  2416.                 if (i2c_bus->valid)
  2417.                         connector->polled = DRM_CONNECTOR_POLL_CONNECT;
  2418.         } else
  2419.                 connector->polled = DRM_CONNECTOR_POLL_HPD;
  2420.         connector->display_info.subpixel_order = subpixel_order;
  2421.         drm_connector_register(connector);
  2422. }
  2423.  
  2424. void radeon_setup_mst_connector(struct drm_device *dev)
  2425. {
  2426.         struct radeon_device *rdev = dev->dev_private;
  2427.         struct drm_connector *connector;
  2428.         struct radeon_connector *radeon_connector;
  2429.  
  2430.         if (!ASIC_IS_DCE5(rdev))
  2431.                 return;
  2432.  
  2433.         if (radeon_mst == 0)
  2434.                 return;
  2435.  
  2436.         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
  2437.                 int ret;
  2438.  
  2439.                 radeon_connector = to_radeon_connector(connector);
  2440.  
  2441.                 if (connector->connector_type != DRM_MODE_CONNECTOR_DisplayPort)
  2442.                         continue;
  2443.  
  2444.                 ret = radeon_dp_mst_init(radeon_connector);
  2445.         }
  2446. }
  2447.