2 * Copyright 2007-8 Advanced Micro Devices, Inc.
3 * Copyright 2008 Red Hat Inc.
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:
12 * The above copyright notice and this permission notice shall be included in
13 * all copies or substantial portions of the Software.
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.
23 * Authors: Dave Airlie
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>
33 #include "radeon_audio.h"
36 #include <linux/pm_runtime.h>
37 #include <linux/vga_switcheroo.h>
39 static int radeon_dp_handle_hpd(struct drm_connector *connector)
41 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
44 ret = radeon_dp_mst_check_status(radeon_connector);
49 void radeon_connector_hotplug(struct drm_connector *connector)
51 struct drm_device *dev = connector->dev;
52 struct radeon_device *rdev = dev->dev_private;
53 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
55 if (connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort) {
56 struct radeon_connector_atom_dig *dig_connector =
57 radeon_connector->con_priv;
59 if (radeon_connector->is_mst_connector)
61 if (dig_connector->is_mst) {
62 radeon_dp_handle_hpd(connector);
66 /* bail if the connector does not have hpd pin, e.g.,
69 if (radeon_connector->hpd.hpd == RADEON_HPD_NONE)
72 radeon_hpd_set_polarity(rdev, radeon_connector->hpd.hpd);
74 /* if the connector is already off, don't turn it back on */
75 /* FIXME: This access isn't protected by any locks. */
76 if (connector->dpms != DRM_MODE_DPMS_ON)
79 /* just deal with DP (not eDP) here. */
80 if (connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort) {
81 struct radeon_connector_atom_dig *dig_connector =
82 radeon_connector->con_priv;
84 /* if existing sink type was not DP no need to retrain */
85 if (dig_connector->dp_sink_type != CONNECTOR_OBJECT_ID_DISPLAYPORT)
88 /* first get sink type as it may be reset after (un)plug */
89 dig_connector->dp_sink_type = radeon_dp_getsinktype(radeon_connector);
90 /* don't do anything if sink is not display port, i.e.,
91 * passive dp->(dvi|hdmi) adaptor
93 if (dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT &&
94 radeon_hpd_sense(rdev, radeon_connector->hpd.hpd) &&
95 radeon_dp_needs_link_train(radeon_connector)) {
96 /* Don't start link training before we have the DPCD */
97 if (!radeon_dp_getdpcd(radeon_connector))
100 /* Turn the connector off and back on immediately, which
101 * will trigger link training
103 drm_helper_connector_dpms(connector, DRM_MODE_DPMS_OFF);
104 drm_helper_connector_dpms(connector, DRM_MODE_DPMS_ON);
109 static void radeon_property_change_mode(struct drm_encoder *encoder)
111 struct drm_crtc *crtc = encoder->crtc;
113 if (crtc && crtc->enabled) {
114 drm_crtc_helper_set_mode(crtc, &crtc->mode,
115 crtc->x, crtc->y, crtc->primary->fb);
119 int radeon_get_monitor_bpc(struct drm_connector *connector)
121 struct drm_device *dev = connector->dev;
122 struct radeon_device *rdev = dev->dev_private;
123 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
124 struct radeon_connector_atom_dig *dig_connector;
126 int mode_clock, max_tmds_clock;
128 switch (connector->connector_type) {
129 case DRM_MODE_CONNECTOR_DVII:
130 case DRM_MODE_CONNECTOR_HDMIB:
131 if (radeon_connector->use_digital) {
132 if (drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
133 if (connector->display_info.bpc)
134 bpc = connector->display_info.bpc;
138 case DRM_MODE_CONNECTOR_DVID:
139 case DRM_MODE_CONNECTOR_HDMIA:
140 if (drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
141 if (connector->display_info.bpc)
142 bpc = connector->display_info.bpc;
145 case DRM_MODE_CONNECTOR_DisplayPort:
146 dig_connector = radeon_connector->con_priv;
147 if ((dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) ||
148 (dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_eDP) ||
149 drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
150 if (connector->display_info.bpc)
151 bpc = connector->display_info.bpc;
154 case DRM_MODE_CONNECTOR_eDP:
155 case DRM_MODE_CONNECTOR_LVDS:
156 if (connector->display_info.bpc)
157 bpc = connector->display_info.bpc;
158 else if (ASIC_IS_DCE41(rdev) || ASIC_IS_DCE5(rdev)) {
159 const struct drm_connector_helper_funcs *connector_funcs =
160 connector->helper_private;
161 struct drm_encoder *encoder = connector_funcs->best_encoder(connector);
162 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
163 struct radeon_encoder_atom_dig *dig = radeon_encoder->enc_priv;
165 if (dig->lcd_misc & ATOM_PANEL_MISC_V13_6BIT_PER_COLOR)
167 else if (dig->lcd_misc & ATOM_PANEL_MISC_V13_8BIT_PER_COLOR)
173 if (drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
174 /* hdmi deep color only implemented on DCE4+ */
175 if ((bpc > 8) && !ASIC_IS_DCE4(rdev)) {
176 DRM_DEBUG("%s: HDMI deep color %d bpc unsupported. Using 8 bpc.\n",
177 connector->name, bpc);
182 * Pre DCE-8 hw can't handle > 12 bpc, and more than 12 bpc doesn't make
183 * much sense without support for > 12 bpc framebuffers. RGB 4:4:4 at
184 * 12 bpc is always supported on hdmi deep color sinks, as this is
185 * required by the HDMI-1.3 spec. Clamp to a safe 12 bpc maximum.
188 DRM_DEBUG("%s: HDMI deep color %d bpc unsupported. Using 12 bpc.\n",
189 connector->name, bpc);
193 /* Any defined maximum tmds clock limit we must not exceed? */
194 if (connector->display_info.max_tmds_clock > 0) {
195 /* mode_clock is clock in kHz for mode to be modeset on this connector */
196 mode_clock = radeon_connector->pixelclock_for_modeset;
198 /* Maximum allowable input clock in kHz */
199 max_tmds_clock = connector->display_info.max_tmds_clock;
201 DRM_DEBUG("%s: hdmi mode dotclock %d kHz, max tmds input clock %d kHz.\n",
202 connector->name, mode_clock, max_tmds_clock);
204 /* Check if bpc is within clock limit. Try to degrade gracefully otherwise */
205 if ((bpc == 12) && (mode_clock * 3/2 > max_tmds_clock)) {
206 if ((connector->display_info.edid_hdmi_dc_modes & DRM_EDID_HDMI_DC_30) &&
207 (mode_clock * 5/4 <= max_tmds_clock))
212 DRM_DEBUG("%s: HDMI deep color 12 bpc exceeds max tmds clock. Using %d bpc.\n",
213 connector->name, bpc);
216 if ((bpc == 10) && (mode_clock * 5/4 > max_tmds_clock)) {
218 DRM_DEBUG("%s: HDMI deep color 10 bpc exceeds max tmds clock. Using %d bpc.\n",
219 connector->name, bpc);
223 /* max_tmds_clock missing, but hdmi spec mandates it for deep color. */
224 DRM_DEBUG("%s: Required max tmds clock for HDMI deep color missing. Using 8 bpc.\n",
230 if ((radeon_deep_color == 0) && (bpc > 8)) {
231 DRM_DEBUG("%s: Deep color disabled. Set radeon module param deep_color=1 to enable.\n",
236 DRM_DEBUG("%s: Display bpc=%d, returned bpc=%d\n",
237 connector->name, connector->display_info.bpc, bpc);
243 radeon_connector_update_scratch_regs(struct drm_connector *connector, enum drm_connector_status status)
245 struct drm_device *dev = connector->dev;
246 struct radeon_device *rdev = dev->dev_private;
247 struct drm_encoder *best_encoder;
248 struct drm_encoder *encoder;
249 const struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
253 best_encoder = connector_funcs->best_encoder(connector);
255 drm_connector_for_each_possible_encoder(connector, encoder, i) {
256 if ((encoder == best_encoder) && (status == connector_status_connected))
261 if (rdev->is_atom_bios)
262 radeon_atombios_connected_scratch_regs(connector, encoder, connected);
264 radeon_combios_connected_scratch_regs(connector, encoder, connected);
268 static struct drm_encoder *radeon_find_encoder(struct drm_connector *connector, int encoder_type)
270 struct drm_encoder *encoder;
273 drm_connector_for_each_possible_encoder(connector, encoder, i) {
274 if (encoder->encoder_type == encoder_type)
281 struct edid *radeon_connector_edid(struct drm_connector *connector)
283 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
284 struct drm_property_blob *edid_blob = connector->edid_blob_ptr;
286 if (radeon_connector->edid) {
287 return radeon_connector->edid;
288 } else if (edid_blob) {
289 struct edid *edid = kmemdup(edid_blob->data, edid_blob->length, GFP_KERNEL);
291 radeon_connector->edid = edid;
293 return radeon_connector->edid;
296 static void radeon_connector_get_edid(struct drm_connector *connector)
298 struct drm_device *dev = connector->dev;
299 struct radeon_device *rdev = dev->dev_private;
300 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
302 if (radeon_connector->edid)
305 /* on hw with routers, select right port */
306 if (radeon_connector->router.ddc_valid)
307 radeon_router_select_ddc_port(radeon_connector);
309 if ((radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
310 ENCODER_OBJECT_ID_NONE) &&
311 radeon_connector->ddc_bus->has_aux) {
312 radeon_connector->edid = drm_get_edid(connector,
313 &radeon_connector->ddc_bus->aux.ddc);
314 } else if ((connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort) ||
315 (connector->connector_type == DRM_MODE_CONNECTOR_eDP)) {
316 struct radeon_connector_atom_dig *dig = radeon_connector->con_priv;
318 if ((dig->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT ||
319 dig->dp_sink_type == CONNECTOR_OBJECT_ID_eDP) &&
320 radeon_connector->ddc_bus->has_aux)
321 radeon_connector->edid = drm_get_edid(&radeon_connector->base,
322 &radeon_connector->ddc_bus->aux.ddc);
323 else if (radeon_connector->ddc_bus)
324 radeon_connector->edid = drm_get_edid(&radeon_connector->base,
325 &radeon_connector->ddc_bus->adapter);
326 } else if (vga_switcheroo_handler_flags() & VGA_SWITCHEROO_CAN_SWITCH_DDC &&
327 connector->connector_type == DRM_MODE_CONNECTOR_LVDS &&
328 radeon_connector->ddc_bus) {
329 radeon_connector->edid = drm_get_edid_switcheroo(&radeon_connector->base,
330 &radeon_connector->ddc_bus->adapter);
331 } else if (radeon_connector->ddc_bus) {
332 radeon_connector->edid = drm_get_edid(&radeon_connector->base,
333 &radeon_connector->ddc_bus->adapter);
336 if (!radeon_connector->edid) {
337 /* don't fetch the edid from the vbios if ddc fails and runpm is
338 * enabled so we report disconnected.
340 if ((rdev->flags & RADEON_IS_PX) && (radeon_runtime_pm != 0))
343 if (rdev->is_atom_bios) {
344 /* some laptops provide a hardcoded edid in rom for LCDs */
345 if (((connector->connector_type == DRM_MODE_CONNECTOR_LVDS) ||
346 (connector->connector_type == DRM_MODE_CONNECTOR_eDP)))
347 radeon_connector->edid = radeon_bios_get_hardcoded_edid(rdev);
349 /* some servers provide a hardcoded edid in rom for KVMs */
350 radeon_connector->edid = radeon_bios_get_hardcoded_edid(rdev);
355 static void radeon_connector_free_edid(struct drm_connector *connector)
357 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
359 if (radeon_connector->edid) {
360 kfree(radeon_connector->edid);
361 radeon_connector->edid = NULL;
365 static int radeon_ddc_get_modes(struct drm_connector *connector)
367 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
370 if (radeon_connector->edid) {
371 drm_connector_update_edid_property(connector, radeon_connector->edid);
372 ret = drm_add_edid_modes(connector, radeon_connector->edid);
375 drm_connector_update_edid_property(connector, NULL);
379 static struct drm_encoder *radeon_best_single_encoder(struct drm_connector *connector)
381 struct drm_encoder *encoder;
384 /* pick the first one */
385 drm_connector_for_each_possible_encoder(connector, encoder, i)
391 static void radeon_get_native_mode(struct drm_connector *connector)
393 struct drm_encoder *encoder = radeon_best_single_encoder(connector);
394 struct radeon_encoder *radeon_encoder;
399 radeon_encoder = to_radeon_encoder(encoder);
401 if (!list_empty(&connector->probed_modes)) {
402 struct drm_display_mode *preferred_mode =
403 list_first_entry(&connector->probed_modes,
404 struct drm_display_mode, head);
406 radeon_encoder->native_mode = *preferred_mode;
408 radeon_encoder->native_mode.clock = 0;
413 * radeon_connector_analog_encoder_conflict_solve
414 * - search for other connectors sharing this encoder
415 * if priority is true, then set them disconnected if this is connected
416 * if priority is false, set us disconnected if they are connected
418 static enum drm_connector_status
419 radeon_connector_analog_encoder_conflict_solve(struct drm_connector *connector,
420 struct drm_encoder *encoder,
421 enum drm_connector_status current_status,
424 struct drm_device *dev = connector->dev;
425 struct drm_connector *conflict;
426 struct radeon_connector *radeon_conflict;
428 list_for_each_entry(conflict, &dev->mode_config.connector_list, head) {
429 struct drm_encoder *enc;
432 if (conflict == connector)
435 radeon_conflict = to_radeon_connector(conflict);
437 drm_connector_for_each_possible_encoder(conflict, enc, i) {
438 /* if the IDs match */
439 if (enc == encoder) {
440 if (conflict->status != connector_status_connected)
443 if (radeon_conflict->use_digital)
446 if (priority == true) {
447 DRM_DEBUG_KMS("1: conflicting encoders switching off %s\n",
449 DRM_DEBUG_KMS("in favor of %s\n",
451 conflict->status = connector_status_disconnected;
452 radeon_connector_update_scratch_regs(conflict, connector_status_disconnected);
454 DRM_DEBUG_KMS("2: conflicting encoders switching off %s\n",
456 DRM_DEBUG_KMS("in favor of %s\n",
458 current_status = connector_status_disconnected;
464 return current_status;
468 static struct drm_display_mode *radeon_fp_native_mode(struct drm_encoder *encoder)
470 struct drm_device *dev = encoder->dev;
471 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
472 struct drm_display_mode *mode = NULL;
473 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
475 if (native_mode->hdisplay != 0 &&
476 native_mode->vdisplay != 0 &&
477 native_mode->clock != 0) {
478 mode = drm_mode_duplicate(dev, native_mode);
479 mode->type = DRM_MODE_TYPE_PREFERRED | DRM_MODE_TYPE_DRIVER;
480 drm_mode_set_name(mode);
482 DRM_DEBUG_KMS("Adding native panel mode %s\n", mode->name);
483 } else if (native_mode->hdisplay != 0 &&
484 native_mode->vdisplay != 0) {
485 /* mac laptops without an edid */
486 /* Note that this is not necessarily the exact panel mode,
487 * but an approximation based on the cvt formula. For these
488 * systems we should ideally read the mode info out of the
489 * registers or add a mode table, but this works and is much
492 mode = drm_cvt_mode(dev, native_mode->hdisplay, native_mode->vdisplay, 60, true, false, false);
493 mode->type = DRM_MODE_TYPE_PREFERRED | DRM_MODE_TYPE_DRIVER;
494 DRM_DEBUG_KMS("Adding cvt approximation of native panel mode %s\n", mode->name);
499 static void radeon_add_common_modes(struct drm_encoder *encoder, struct drm_connector *connector)
501 struct drm_device *dev = encoder->dev;
502 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
503 struct drm_display_mode *mode = NULL;
504 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
509 } common_modes[17] = {
529 for (i = 0; i < 17; i++) {
530 if (radeon_encoder->devices & (ATOM_DEVICE_TV_SUPPORT)) {
531 if (common_modes[i].w > 1024 ||
532 common_modes[i].h > 768)
535 if (radeon_encoder->devices & (ATOM_DEVICE_LCD_SUPPORT)) {
536 if (common_modes[i].w > native_mode->hdisplay ||
537 common_modes[i].h > native_mode->vdisplay ||
538 (common_modes[i].w == native_mode->hdisplay &&
539 common_modes[i].h == native_mode->vdisplay))
542 if (common_modes[i].w < 320 || common_modes[i].h < 200)
545 mode = drm_cvt_mode(dev, common_modes[i].w, common_modes[i].h, 60, false, false, false);
546 drm_mode_probed_add(connector, mode);
550 static int radeon_connector_set_property(struct drm_connector *connector, struct drm_property *property,
553 struct drm_device *dev = connector->dev;
554 struct radeon_device *rdev = dev->dev_private;
555 struct drm_encoder *encoder;
556 struct radeon_encoder *radeon_encoder;
558 if (property == rdev->mode_info.coherent_mode_property) {
559 struct radeon_encoder_atom_dig *dig;
560 bool new_coherent_mode;
562 /* need to find digital encoder on connector */
563 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
567 radeon_encoder = to_radeon_encoder(encoder);
569 if (!radeon_encoder->enc_priv)
572 dig = radeon_encoder->enc_priv;
573 new_coherent_mode = val ? true : false;
574 if (dig->coherent_mode != new_coherent_mode) {
575 dig->coherent_mode = new_coherent_mode;
576 radeon_property_change_mode(&radeon_encoder->base);
580 if (property == rdev->mode_info.audio_property) {
581 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
582 /* need to find digital encoder on connector */
583 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
587 radeon_encoder = to_radeon_encoder(encoder);
589 if (radeon_connector->audio != val) {
590 radeon_connector->audio = val;
591 radeon_property_change_mode(&radeon_encoder->base);
595 if (property == rdev->mode_info.dither_property) {
596 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
597 /* need to find digital encoder on connector */
598 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
602 radeon_encoder = to_radeon_encoder(encoder);
604 if (radeon_connector->dither != val) {
605 radeon_connector->dither = val;
606 radeon_property_change_mode(&radeon_encoder->base);
610 if (property == rdev->mode_info.underscan_property) {
611 /* need to find digital encoder on connector */
612 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
616 radeon_encoder = to_radeon_encoder(encoder);
618 if (radeon_encoder->underscan_type != val) {
619 radeon_encoder->underscan_type = val;
620 radeon_property_change_mode(&radeon_encoder->base);
624 if (property == rdev->mode_info.underscan_hborder_property) {
625 /* need to find digital encoder on connector */
626 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
630 radeon_encoder = to_radeon_encoder(encoder);
632 if (radeon_encoder->underscan_hborder != val) {
633 radeon_encoder->underscan_hborder = val;
634 radeon_property_change_mode(&radeon_encoder->base);
638 if (property == rdev->mode_info.underscan_vborder_property) {
639 /* need to find digital encoder on connector */
640 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
644 radeon_encoder = to_radeon_encoder(encoder);
646 if (radeon_encoder->underscan_vborder != val) {
647 radeon_encoder->underscan_vborder = val;
648 radeon_property_change_mode(&radeon_encoder->base);
652 if (property == rdev->mode_info.tv_std_property) {
653 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TVDAC);
655 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_DAC);
661 radeon_encoder = to_radeon_encoder(encoder);
662 if (!radeon_encoder->enc_priv)
664 if (ASIC_IS_AVIVO(rdev) || radeon_r4xx_atom) {
665 struct radeon_encoder_atom_dac *dac_int;
666 dac_int = radeon_encoder->enc_priv;
667 dac_int->tv_std = val;
669 struct radeon_encoder_tv_dac *dac_int;
670 dac_int = radeon_encoder->enc_priv;
671 dac_int->tv_std = val;
673 radeon_property_change_mode(&radeon_encoder->base);
676 if (property == rdev->mode_info.load_detect_property) {
677 struct radeon_connector *radeon_connector =
678 to_radeon_connector(connector);
681 radeon_connector->dac_load_detect = false;
683 radeon_connector->dac_load_detect = true;
686 if (property == rdev->mode_info.tmds_pll_property) {
687 struct radeon_encoder_int_tmds *tmds = NULL;
689 /* need to find digital encoder on connector */
690 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
694 radeon_encoder = to_radeon_encoder(encoder);
696 tmds = radeon_encoder->enc_priv;
701 if (rdev->is_atom_bios)
702 ret = radeon_atombios_get_tmds_info(radeon_encoder, tmds);
704 ret = radeon_legacy_get_tmds_info_from_combios(radeon_encoder, tmds);
706 if (val == 1 || ret == false) {
707 radeon_legacy_get_tmds_info_from_table(radeon_encoder, tmds);
709 radeon_property_change_mode(&radeon_encoder->base);
712 if (property == dev->mode_config.scaling_mode_property) {
713 enum radeon_rmx_type rmx_type;
715 if (connector->encoder)
716 radeon_encoder = to_radeon_encoder(connector->encoder);
718 const struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
719 radeon_encoder = to_radeon_encoder(connector_funcs->best_encoder(connector));
724 case DRM_MODE_SCALE_NONE: rmx_type = RMX_OFF; break;
725 case DRM_MODE_SCALE_CENTER: rmx_type = RMX_CENTER; break;
726 case DRM_MODE_SCALE_ASPECT: rmx_type = RMX_ASPECT; break;
727 case DRM_MODE_SCALE_FULLSCREEN: rmx_type = RMX_FULL; break;
729 if (radeon_encoder->rmx_type == rmx_type)
732 if ((rmx_type != DRM_MODE_SCALE_NONE) &&
733 (radeon_encoder->native_mode.clock == 0))
736 radeon_encoder->rmx_type = rmx_type;
738 radeon_property_change_mode(&radeon_encoder->base);
741 if (property == rdev->mode_info.output_csc_property) {
742 if (connector->encoder)
743 radeon_encoder = to_radeon_encoder(connector->encoder);
745 const struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
746 radeon_encoder = to_radeon_encoder(connector_funcs->best_encoder(connector));
749 if (radeon_encoder->output_csc == val)
752 radeon_encoder->output_csc = val;
754 if (connector->encoder && connector->encoder->crtc) {
755 struct drm_crtc *crtc = connector->encoder->crtc;
756 struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc);
758 radeon_crtc->output_csc = radeon_encoder->output_csc;
761 * Our .gamma_set assumes the .gamma_store has been
762 * prefilled and don't care about its arguments.
764 crtc->funcs->gamma_set(crtc, NULL, NULL, NULL, 0, NULL);
771 static void radeon_fixup_lvds_native_mode(struct drm_encoder *encoder,
772 struct drm_connector *connector)
774 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
775 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
776 struct drm_display_mode *t, *mode;
778 /* If the EDID preferred mode doesn't match the native mode, use it */
779 list_for_each_entry_safe(mode, t, &connector->probed_modes, head) {
780 if (mode->type & DRM_MODE_TYPE_PREFERRED) {
781 if (mode->hdisplay != native_mode->hdisplay ||
782 mode->vdisplay != native_mode->vdisplay)
783 memcpy(native_mode, mode, sizeof(*mode));
787 /* Try to get native mode details from EDID if necessary */
788 if (!native_mode->clock) {
789 list_for_each_entry_safe(mode, t, &connector->probed_modes, head) {
790 if (mode->hdisplay == native_mode->hdisplay &&
791 mode->vdisplay == native_mode->vdisplay) {
792 *native_mode = *mode;
793 drm_mode_set_crtcinfo(native_mode, CRTC_INTERLACE_HALVE_V);
794 DRM_DEBUG_KMS("Determined LVDS native mode details from EDID\n");
800 if (!native_mode->clock) {
801 DRM_DEBUG_KMS("No LVDS native mode details, disabling RMX\n");
802 radeon_encoder->rmx_type = RMX_OFF;
806 static int radeon_lvds_get_modes(struct drm_connector *connector)
808 struct drm_encoder *encoder;
810 struct drm_display_mode *mode;
812 radeon_connector_get_edid(connector);
813 ret = radeon_ddc_get_modes(connector);
815 encoder = radeon_best_single_encoder(connector);
817 radeon_fixup_lvds_native_mode(encoder, connector);
818 /* add scaled modes */
819 radeon_add_common_modes(encoder, connector);
824 encoder = radeon_best_single_encoder(connector);
828 /* we have no EDID modes */
829 mode = radeon_fp_native_mode(encoder);
832 drm_mode_probed_add(connector, mode);
833 /* add the width/height from vbios tables if available */
834 connector->display_info.width_mm = mode->width_mm;
835 connector->display_info.height_mm = mode->height_mm;
836 /* add scaled modes */
837 radeon_add_common_modes(encoder, connector);
843 static enum drm_mode_status radeon_lvds_mode_valid(struct drm_connector *connector,
844 struct drm_display_mode *mode)
846 struct drm_encoder *encoder = radeon_best_single_encoder(connector);
848 if ((mode->hdisplay < 320) || (mode->vdisplay < 240))
852 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
853 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
855 /* AVIVO hardware supports downscaling modes larger than the panel
856 * to the panel size, but I'm not sure this is desirable.
858 if ((mode->hdisplay > native_mode->hdisplay) ||
859 (mode->vdisplay > native_mode->vdisplay))
862 /* if scaling is disabled, block non-native modes */
863 if (radeon_encoder->rmx_type == RMX_OFF) {
864 if ((mode->hdisplay != native_mode->hdisplay) ||
865 (mode->vdisplay != native_mode->vdisplay))
873 static enum drm_connector_status
874 radeon_lvds_detect(struct drm_connector *connector, bool force)
876 struct drm_device *dev = connector->dev;
877 struct radeon_device *rdev = dev->dev_private;
878 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
879 struct drm_encoder *encoder = radeon_best_single_encoder(connector);
880 enum drm_connector_status ret = connector_status_disconnected;
883 if (!drm_kms_helper_is_poll_worker()) {
884 r = pm_runtime_get_sync(connector->dev->dev);
886 pm_runtime_put_autosuspend(connector->dev->dev);
887 return connector_status_disconnected;
892 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
893 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
895 /* check if panel is valid */
896 if (native_mode->hdisplay >= 320 && native_mode->vdisplay >= 240)
897 ret = connector_status_connected;
898 /* don't fetch the edid from the vbios if ddc fails and runpm is
899 * enabled so we report disconnected.
901 if ((rdev->flags & RADEON_IS_PX) && (radeon_runtime_pm != 0))
902 ret = connector_status_disconnected;
905 /* check for edid as well */
906 radeon_connector_get_edid(connector);
907 if (radeon_connector->edid)
908 ret = connector_status_connected;
909 /* check acpi lid status ??? */
911 radeon_connector_update_scratch_regs(connector, ret);
913 if (!drm_kms_helper_is_poll_worker()) {
914 pm_runtime_mark_last_busy(connector->dev->dev);
915 pm_runtime_put_autosuspend(connector->dev->dev);
921 static void radeon_connector_unregister(struct drm_connector *connector)
923 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
925 if (radeon_connector->ddc_bus && radeon_connector->ddc_bus->has_aux) {
926 drm_dp_aux_unregister(&radeon_connector->ddc_bus->aux);
927 radeon_connector->ddc_bus->has_aux = false;
931 static void radeon_connector_destroy(struct drm_connector *connector)
933 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
935 radeon_connector_free_edid(connector);
936 kfree(radeon_connector->con_priv);
937 drm_connector_unregister(connector);
938 drm_connector_cleanup(connector);
942 static int radeon_lvds_set_property(struct drm_connector *connector,
943 struct drm_property *property,
946 struct drm_device *dev = connector->dev;
947 struct radeon_encoder *radeon_encoder;
948 enum radeon_rmx_type rmx_type;
951 if (property != dev->mode_config.scaling_mode_property)
954 if (connector->encoder)
955 radeon_encoder = to_radeon_encoder(connector->encoder);
957 const struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
958 radeon_encoder = to_radeon_encoder(connector_funcs->best_encoder(connector));
962 case DRM_MODE_SCALE_NONE: rmx_type = RMX_OFF; break;
963 case DRM_MODE_SCALE_CENTER: rmx_type = RMX_CENTER; break;
964 case DRM_MODE_SCALE_ASPECT: rmx_type = RMX_ASPECT; break;
966 case DRM_MODE_SCALE_FULLSCREEN: rmx_type = RMX_FULL; break;
968 if (radeon_encoder->rmx_type == rmx_type)
971 radeon_encoder->rmx_type = rmx_type;
973 radeon_property_change_mode(&radeon_encoder->base);
978 static const struct drm_connector_helper_funcs radeon_lvds_connector_helper_funcs = {
979 .get_modes = radeon_lvds_get_modes,
980 .mode_valid = radeon_lvds_mode_valid,
981 .best_encoder = radeon_best_single_encoder,
984 static const struct drm_connector_funcs radeon_lvds_connector_funcs = {
985 .dpms = drm_helper_connector_dpms,
986 .detect = radeon_lvds_detect,
987 .fill_modes = drm_helper_probe_single_connector_modes,
988 .early_unregister = radeon_connector_unregister,
989 .destroy = radeon_connector_destroy,
990 .set_property = radeon_lvds_set_property,
993 static int radeon_vga_get_modes(struct drm_connector *connector)
997 radeon_connector_get_edid(connector);
998 ret = radeon_ddc_get_modes(connector);
1000 radeon_get_native_mode(connector);
1005 static enum drm_mode_status radeon_vga_mode_valid(struct drm_connector *connector,
1006 struct drm_display_mode *mode)
1008 struct drm_device *dev = connector->dev;
1009 struct radeon_device *rdev = dev->dev_private;
1011 /* XXX check mode bandwidth */
1013 if ((mode->clock / 10) > rdev->clock.max_pixel_clock)
1014 return MODE_CLOCK_HIGH;
1019 static enum drm_connector_status
1020 radeon_vga_detect(struct drm_connector *connector, bool force)
1022 struct drm_device *dev = connector->dev;
1023 struct radeon_device *rdev = dev->dev_private;
1024 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1025 struct drm_encoder *encoder;
1026 const struct drm_encoder_helper_funcs *encoder_funcs;
1028 enum drm_connector_status ret = connector_status_disconnected;
1031 if (!drm_kms_helper_is_poll_worker()) {
1032 r = pm_runtime_get_sync(connector->dev->dev);
1034 pm_runtime_put_autosuspend(connector->dev->dev);
1035 return connector_status_disconnected;
1039 encoder = radeon_best_single_encoder(connector);
1041 ret = connector_status_disconnected;
1043 if (radeon_connector->ddc_bus)
1044 dret = radeon_ddc_probe(radeon_connector, false);
1046 radeon_connector->detected_by_load = false;
1047 radeon_connector_free_edid(connector);
1048 radeon_connector_get_edid(connector);
1050 if (!radeon_connector->edid) {
1051 DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
1053 ret = connector_status_connected;
1055 radeon_connector->use_digital =
1056 !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
1058 /* some oems have boards with separate digital and analog connectors
1059 * with a shared ddc line (often vga + hdmi)
1061 if (radeon_connector->use_digital && radeon_connector->shared_ddc) {
1062 radeon_connector_free_edid(connector);
1063 ret = connector_status_disconnected;
1065 ret = connector_status_connected;
1070 /* if we aren't forcing don't do destructive polling */
1072 /* only return the previous status if we last
1073 * detected a monitor via load.
1075 if (radeon_connector->detected_by_load)
1076 ret = connector->status;
1080 if (radeon_connector->dac_load_detect && encoder) {
1081 encoder_funcs = encoder->helper_private;
1082 ret = encoder_funcs->detect(encoder, connector);
1083 if (ret != connector_status_disconnected)
1084 radeon_connector->detected_by_load = true;
1088 if (ret == connector_status_connected)
1089 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
1091 /* RN50 and some RV100 asics in servers often have a hardcoded EDID in the
1092 * vbios to deal with KVMs. If we have one and are not able to detect a monitor
1093 * by other means, assume the CRT is connected and use that EDID.
1095 if ((!rdev->is_atom_bios) &&
1096 (ret == connector_status_disconnected) &&
1097 rdev->mode_info.bios_hardcoded_edid_size) {
1098 ret = connector_status_connected;
1101 radeon_connector_update_scratch_regs(connector, ret);
1104 if (!drm_kms_helper_is_poll_worker()) {
1105 pm_runtime_mark_last_busy(connector->dev->dev);
1106 pm_runtime_put_autosuspend(connector->dev->dev);
1112 static const struct drm_connector_helper_funcs radeon_vga_connector_helper_funcs = {
1113 .get_modes = radeon_vga_get_modes,
1114 .mode_valid = radeon_vga_mode_valid,
1115 .best_encoder = radeon_best_single_encoder,
1118 static const struct drm_connector_funcs radeon_vga_connector_funcs = {
1119 .dpms = drm_helper_connector_dpms,
1120 .detect = radeon_vga_detect,
1121 .fill_modes = drm_helper_probe_single_connector_modes,
1122 .early_unregister = radeon_connector_unregister,
1123 .destroy = radeon_connector_destroy,
1124 .set_property = radeon_connector_set_property,
1127 static int radeon_tv_get_modes(struct drm_connector *connector)
1129 struct drm_device *dev = connector->dev;
1130 struct radeon_device *rdev = dev->dev_private;
1131 struct drm_display_mode *tv_mode;
1132 struct drm_encoder *encoder;
1134 encoder = radeon_best_single_encoder(connector);
1138 /* avivo chips can scale any mode */
1139 if (rdev->family >= CHIP_RS600)
1140 /* add scaled modes */
1141 radeon_add_common_modes(encoder, connector);
1143 /* only 800x600 is supported right now on pre-avivo chips */
1144 tv_mode = drm_cvt_mode(dev, 800, 600, 60, false, false, false);
1145 tv_mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
1146 drm_mode_probed_add(connector, tv_mode);
1151 static enum drm_mode_status radeon_tv_mode_valid(struct drm_connector *connector,
1152 struct drm_display_mode *mode)
1154 if ((mode->hdisplay > 1024) || (mode->vdisplay > 768))
1155 return MODE_CLOCK_RANGE;
1159 static enum drm_connector_status
1160 radeon_tv_detect(struct drm_connector *connector, bool force)
1162 struct drm_encoder *encoder;
1163 const struct drm_encoder_helper_funcs *encoder_funcs;
1164 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1165 enum drm_connector_status ret = connector_status_disconnected;
1168 if (!radeon_connector->dac_load_detect)
1171 if (!drm_kms_helper_is_poll_worker()) {
1172 r = pm_runtime_get_sync(connector->dev->dev);
1174 pm_runtime_put_autosuspend(connector->dev->dev);
1175 return connector_status_disconnected;
1179 encoder = radeon_best_single_encoder(connector);
1181 ret = connector_status_disconnected;
1183 encoder_funcs = encoder->helper_private;
1184 ret = encoder_funcs->detect(encoder, connector);
1186 if (ret == connector_status_connected)
1187 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, false);
1188 radeon_connector_update_scratch_regs(connector, ret);
1190 if (!drm_kms_helper_is_poll_worker()) {
1191 pm_runtime_mark_last_busy(connector->dev->dev);
1192 pm_runtime_put_autosuspend(connector->dev->dev);
1198 static const struct drm_connector_helper_funcs radeon_tv_connector_helper_funcs = {
1199 .get_modes = radeon_tv_get_modes,
1200 .mode_valid = radeon_tv_mode_valid,
1201 .best_encoder = radeon_best_single_encoder,
1204 static const struct drm_connector_funcs radeon_tv_connector_funcs = {
1205 .dpms = drm_helper_connector_dpms,
1206 .detect = radeon_tv_detect,
1207 .fill_modes = drm_helper_probe_single_connector_modes,
1208 .early_unregister = radeon_connector_unregister,
1209 .destroy = radeon_connector_destroy,
1210 .set_property = radeon_connector_set_property,
1213 static bool radeon_check_hpd_status_unchanged(struct drm_connector *connector)
1215 struct drm_device *dev = connector->dev;
1216 struct radeon_device *rdev = dev->dev_private;
1217 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1218 enum drm_connector_status status;
1220 /* We only trust HPD on R600 and newer ASICS. */
1221 if (rdev->family >= CHIP_R600
1222 && radeon_connector->hpd.hpd != RADEON_HPD_NONE) {
1223 if (radeon_hpd_sense(rdev, radeon_connector->hpd.hpd))
1224 status = connector_status_connected;
1226 status = connector_status_disconnected;
1227 if (connector->status == status)
1235 * DVI is complicated
1236 * Do a DDC probe, if DDC probe passes, get the full EDID so
1237 * we can do analog/digital monitor detection at this point.
1238 * If the monitor is an analog monitor or we got no DDC,
1239 * we need to find the DAC encoder object for this connector.
1240 * If we got no DDC, we do load detection on the DAC encoder object.
1241 * If we got analog DDC or load detection passes on the DAC encoder
1242 * we have to check if this analog encoder is shared with anyone else (TV)
1243 * if its shared we have to set the other connector to disconnected.
1245 static enum drm_connector_status
1246 radeon_dvi_detect(struct drm_connector *connector, bool force)
1248 struct drm_device *dev = connector->dev;
1249 struct radeon_device *rdev = dev->dev_private;
1250 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1251 struct drm_encoder *encoder = NULL;
1252 const struct drm_encoder_helper_funcs *encoder_funcs;
1254 enum drm_connector_status ret = connector_status_disconnected;
1255 bool dret = false, broken_edid = false;
1257 if (!drm_kms_helper_is_poll_worker()) {
1258 r = pm_runtime_get_sync(connector->dev->dev);
1260 pm_runtime_put_autosuspend(connector->dev->dev);
1261 return connector_status_disconnected;
1265 if (radeon_connector->detected_hpd_without_ddc) {
1267 radeon_connector->detected_hpd_without_ddc = false;
1270 if (!force && radeon_check_hpd_status_unchanged(connector)) {
1271 ret = connector->status;
1275 if (radeon_connector->ddc_bus) {
1276 dret = radeon_ddc_probe(radeon_connector, false);
1278 /* Sometimes the pins required for the DDC probe on DVI
1279 * connectors don't make contact at the same time that the ones
1280 * for HPD do. If the DDC probe fails even though we had an HPD
1281 * signal, try again later */
1282 if (!dret && !force &&
1283 connector->status != connector_status_connected) {
1284 DRM_DEBUG_KMS("hpd detected without ddc, retrying in 1 second\n");
1285 radeon_connector->detected_hpd_without_ddc = true;
1286 schedule_delayed_work(&rdev->hotplug_work,
1287 msecs_to_jiffies(1000));
1292 radeon_connector->detected_by_load = false;
1293 radeon_connector_free_edid(connector);
1294 radeon_connector_get_edid(connector);
1296 if (!radeon_connector->edid) {
1297 DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
1299 /* rs690 seems to have a problem with connectors not existing and always
1300 * return a block of 0's. If we see this just stop polling on this output */
1301 if ((rdev->family == CHIP_RS690 || rdev->family == CHIP_RS740) &&
1302 radeon_connector->base.null_edid_counter) {
1303 ret = connector_status_disconnected;
1304 DRM_ERROR("%s: detected RS690 floating bus bug, stopping ddc detect\n",
1306 radeon_connector->ddc_bus = NULL;
1308 ret = connector_status_connected;
1309 broken_edid = true; /* defer use_digital to later */
1312 radeon_connector->use_digital =
1313 !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
1315 /* some oems have boards with separate digital and analog connectors
1316 * with a shared ddc line (often vga + hdmi)
1318 if ((!radeon_connector->use_digital) && radeon_connector->shared_ddc) {
1319 radeon_connector_free_edid(connector);
1320 ret = connector_status_disconnected;
1322 ret = connector_status_connected;
1324 /* This gets complicated. We have boards with VGA + HDMI with a
1325 * shared DDC line and we have boards with DVI-D + HDMI with a shared
1326 * DDC line. The latter is more complex because with DVI<->HDMI adapters
1327 * you don't really know what's connected to which port as both are digital.
1329 if (radeon_connector->shared_ddc && (ret == connector_status_connected)) {
1330 struct drm_connector *list_connector;
1331 struct radeon_connector *list_radeon_connector;
1332 list_for_each_entry(list_connector, &dev->mode_config.connector_list, head) {
1333 if (connector == list_connector)
1335 list_radeon_connector = to_radeon_connector(list_connector);
1336 if (list_radeon_connector->shared_ddc &&
1337 (list_radeon_connector->ddc_bus->rec.i2c_id ==
1338 radeon_connector->ddc_bus->rec.i2c_id)) {
1339 /* cases where both connectors are digital */
1340 if (list_connector->connector_type != DRM_MODE_CONNECTOR_VGA) {
1341 /* hpd is our only option in this case */
1342 if (!radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) {
1343 radeon_connector_free_edid(connector);
1344 ret = connector_status_disconnected;
1353 if ((ret == connector_status_connected) && (radeon_connector->use_digital == true))
1356 /* DVI-D and HDMI-A are digital only */
1357 if ((connector->connector_type == DRM_MODE_CONNECTOR_DVID) ||
1358 (connector->connector_type == DRM_MODE_CONNECTOR_HDMIA))
1361 /* if we aren't forcing don't do destructive polling */
1363 /* only return the previous status if we last
1364 * detected a monitor via load.
1366 if (radeon_connector->detected_by_load)
1367 ret = connector->status;
1371 /* find analog encoder */
1372 if (radeon_connector->dac_load_detect) {
1375 drm_connector_for_each_possible_encoder(connector, encoder, i) {
1376 if (encoder->encoder_type != DRM_MODE_ENCODER_DAC &&
1377 encoder->encoder_type != DRM_MODE_ENCODER_TVDAC)
1380 encoder_funcs = encoder->helper_private;
1381 if (encoder_funcs->detect) {
1383 if (ret != connector_status_connected) {
1384 /* deal with analog monitors without DDC */
1385 ret = encoder_funcs->detect(encoder, connector);
1386 if (ret == connector_status_connected) {
1387 radeon_connector->use_digital = false;
1389 if (ret != connector_status_disconnected)
1390 radeon_connector->detected_by_load = true;
1393 enum drm_connector_status lret;
1394 /* assume digital unless load detected otherwise */
1395 radeon_connector->use_digital = true;
1396 lret = encoder_funcs->detect(encoder, connector);
1397 DRM_DEBUG_KMS("load_detect %x returned: %x\n",encoder->encoder_type,lret);
1398 if (lret == connector_status_connected)
1399 radeon_connector->use_digital = false;
1406 if ((ret == connector_status_connected) && (radeon_connector->use_digital == false) &&
1408 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
1411 /* RN50 and some RV100 asics in servers often have a hardcoded EDID in the
1412 * vbios to deal with KVMs. If we have one and are not able to detect a monitor
1413 * by other means, assume the DFP is connected and use that EDID. In most
1414 * cases the DVI port is actually a virtual KVM port connected to the service
1418 if ((!rdev->is_atom_bios) &&
1419 (ret == connector_status_disconnected) &&
1420 rdev->mode_info.bios_hardcoded_edid_size) {
1421 radeon_connector->use_digital = true;
1422 ret = connector_status_connected;
1425 /* updated in get modes as well since we need to know if it's analog or digital */
1426 radeon_connector_update_scratch_regs(connector, ret);
1428 if ((radeon_audio != 0) && radeon_connector->use_digital) {
1429 const struct drm_connector_helper_funcs *connector_funcs =
1430 connector->helper_private;
1432 encoder = connector_funcs->best_encoder(connector);
1433 if (encoder && (encoder->encoder_type == DRM_MODE_ENCODER_TMDS)) {
1434 radeon_connector_get_edid(connector);
1435 radeon_audio_detect(connector, encoder, ret);
1440 if (!drm_kms_helper_is_poll_worker()) {
1441 pm_runtime_mark_last_busy(connector->dev->dev);
1442 pm_runtime_put_autosuspend(connector->dev->dev);
1448 /* okay need to be smart in here about which encoder to pick */
1449 static struct drm_encoder *radeon_dvi_encoder(struct drm_connector *connector)
1451 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1452 struct drm_encoder *encoder;
1455 drm_connector_for_each_possible_encoder(connector, encoder, i) {
1456 if (radeon_connector->use_digital == true) {
1457 if (encoder->encoder_type == DRM_MODE_ENCODER_TMDS)
1460 if (encoder->encoder_type == DRM_MODE_ENCODER_DAC ||
1461 encoder->encoder_type == DRM_MODE_ENCODER_TVDAC)
1466 /* see if we have a default encoder TODO */
1468 /* then check use digitial */
1469 /* pick the first one */
1470 drm_connector_for_each_possible_encoder(connector, encoder, i)
1476 static void radeon_dvi_force(struct drm_connector *connector)
1478 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1479 if (connector->force == DRM_FORCE_ON)
1480 radeon_connector->use_digital = false;
1481 if (connector->force == DRM_FORCE_ON_DIGITAL)
1482 radeon_connector->use_digital = true;
1485 static enum drm_mode_status radeon_dvi_mode_valid(struct drm_connector *connector,
1486 struct drm_display_mode *mode)
1488 struct drm_device *dev = connector->dev;
1489 struct radeon_device *rdev = dev->dev_private;
1490 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1492 /* XXX check mode bandwidth */
1494 /* clocks over 135 MHz have heat issues with DVI on RV100 */
1495 if (radeon_connector->use_digital &&
1496 (rdev->family == CHIP_RV100) &&
1497 (mode->clock > 135000))
1498 return MODE_CLOCK_HIGH;
1500 if (radeon_connector->use_digital && (mode->clock > 165000)) {
1501 if ((radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_I) ||
1502 (radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_D) ||
1503 (radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_HDMI_TYPE_B))
1505 else if (ASIC_IS_DCE6(rdev) && drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
1506 /* HDMI 1.3+ supports max clock of 340 Mhz */
1507 if (mode->clock > 340000)
1508 return MODE_CLOCK_HIGH;
1512 return MODE_CLOCK_HIGH;
1516 /* check against the max pixel clock */
1517 if ((mode->clock / 10) > rdev->clock.max_pixel_clock)
1518 return MODE_CLOCK_HIGH;
1523 static const struct drm_connector_helper_funcs radeon_dvi_connector_helper_funcs = {
1524 .get_modes = radeon_vga_get_modes,
1525 .mode_valid = radeon_dvi_mode_valid,
1526 .best_encoder = radeon_dvi_encoder,
1529 static const struct drm_connector_funcs radeon_dvi_connector_funcs = {
1530 .dpms = drm_helper_connector_dpms,
1531 .detect = radeon_dvi_detect,
1532 .fill_modes = drm_helper_probe_single_connector_modes,
1533 .set_property = radeon_connector_set_property,
1534 .early_unregister = radeon_connector_unregister,
1535 .destroy = radeon_connector_destroy,
1536 .force = radeon_dvi_force,
1539 static int radeon_dp_get_modes(struct drm_connector *connector)
1541 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1542 struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
1543 struct drm_encoder *encoder = radeon_best_single_encoder(connector);
1546 if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) ||
1547 (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
1548 struct drm_display_mode *mode;
1550 if (connector->connector_type == DRM_MODE_CONNECTOR_eDP) {
1551 if (!radeon_dig_connector->edp_on)
1552 atombios_set_edp_panel_power(connector,
1553 ATOM_TRANSMITTER_ACTION_POWER_ON);
1554 radeon_connector_get_edid(connector);
1555 ret = radeon_ddc_get_modes(connector);
1556 if (!radeon_dig_connector->edp_on)
1557 atombios_set_edp_panel_power(connector,
1558 ATOM_TRANSMITTER_ACTION_POWER_OFF);
1560 /* need to setup ddc on the bridge */
1561 if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
1562 ENCODER_OBJECT_ID_NONE) {
1564 radeon_atom_ext_encoder_setup_ddc(encoder);
1566 radeon_connector_get_edid(connector);
1567 ret = radeon_ddc_get_modes(connector);
1572 radeon_fixup_lvds_native_mode(encoder, connector);
1573 /* add scaled modes */
1574 radeon_add_common_modes(encoder, connector);
1582 /* we have no EDID modes */
1583 mode = radeon_fp_native_mode(encoder);
1586 drm_mode_probed_add(connector, mode);
1587 /* add the width/height from vbios tables if available */
1588 connector->display_info.width_mm = mode->width_mm;
1589 connector->display_info.height_mm = mode->height_mm;
1590 /* add scaled modes */
1591 radeon_add_common_modes(encoder, connector);
1594 /* need to setup ddc on the bridge */
1595 if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
1596 ENCODER_OBJECT_ID_NONE) {
1598 radeon_atom_ext_encoder_setup_ddc(encoder);
1600 radeon_connector_get_edid(connector);
1601 ret = radeon_ddc_get_modes(connector);
1603 radeon_get_native_mode(connector);
1609 u16 radeon_connector_encoder_get_dp_bridge_encoder_id(struct drm_connector *connector)
1611 struct drm_encoder *encoder;
1612 struct radeon_encoder *radeon_encoder;
1615 drm_connector_for_each_possible_encoder(connector, encoder, i) {
1616 radeon_encoder = to_radeon_encoder(encoder);
1618 switch (radeon_encoder->encoder_id) {
1619 case ENCODER_OBJECT_ID_TRAVIS:
1620 case ENCODER_OBJECT_ID_NUTMEG:
1621 return radeon_encoder->encoder_id;
1627 return ENCODER_OBJECT_ID_NONE;
1630 static bool radeon_connector_encoder_is_hbr2(struct drm_connector *connector)
1632 struct drm_encoder *encoder;
1633 struct radeon_encoder *radeon_encoder;
1637 drm_connector_for_each_possible_encoder(connector, encoder, i) {
1638 radeon_encoder = to_radeon_encoder(encoder);
1639 if (radeon_encoder->caps & ATOM_ENCODER_CAP_RECORD_HBR2)
1646 bool radeon_connector_is_dp12_capable(struct drm_connector *connector)
1648 struct drm_device *dev = connector->dev;
1649 struct radeon_device *rdev = dev->dev_private;
1651 if (ASIC_IS_DCE5(rdev) &&
1652 (rdev->clock.default_dispclk >= 53900) &&
1653 radeon_connector_encoder_is_hbr2(connector)) {
1660 static enum drm_connector_status
1661 radeon_dp_detect(struct drm_connector *connector, bool force)
1663 struct drm_device *dev = connector->dev;
1664 struct radeon_device *rdev = dev->dev_private;
1665 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1666 enum drm_connector_status ret = connector_status_disconnected;
1667 struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
1668 struct drm_encoder *encoder = radeon_best_single_encoder(connector);
1671 if (radeon_dig_connector->is_mst)
1672 return connector_status_disconnected;
1674 if (!drm_kms_helper_is_poll_worker()) {
1675 r = pm_runtime_get_sync(connector->dev->dev);
1677 pm_runtime_put_autosuspend(connector->dev->dev);
1678 return connector_status_disconnected;
1682 if (!force && radeon_check_hpd_status_unchanged(connector)) {
1683 ret = connector->status;
1687 radeon_connector_free_edid(connector);
1689 if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) ||
1690 (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
1692 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
1693 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
1695 /* check if panel is valid */
1696 if (native_mode->hdisplay >= 320 && native_mode->vdisplay >= 240)
1697 ret = connector_status_connected;
1698 /* don't fetch the edid from the vbios if ddc fails and runpm is
1699 * enabled so we report disconnected.
1701 if ((rdev->flags & RADEON_IS_PX) && (radeon_runtime_pm != 0))
1702 ret = connector_status_disconnected;
1704 /* eDP is always DP */
1705 radeon_dig_connector->dp_sink_type = CONNECTOR_OBJECT_ID_DISPLAYPORT;
1706 if (!radeon_dig_connector->edp_on)
1707 atombios_set_edp_panel_power(connector,
1708 ATOM_TRANSMITTER_ACTION_POWER_ON);
1709 if (radeon_dp_getdpcd(radeon_connector))
1710 ret = connector_status_connected;
1711 if (!radeon_dig_connector->edp_on)
1712 atombios_set_edp_panel_power(connector,
1713 ATOM_TRANSMITTER_ACTION_POWER_OFF);
1714 } else if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
1715 ENCODER_OBJECT_ID_NONE) {
1716 /* DP bridges are always DP */
1717 radeon_dig_connector->dp_sink_type = CONNECTOR_OBJECT_ID_DISPLAYPORT;
1718 /* get the DPCD from the bridge */
1719 radeon_dp_getdpcd(radeon_connector);
1722 /* setup ddc on the bridge */
1723 radeon_atom_ext_encoder_setup_ddc(encoder);
1724 /* bridge chips are always aux */
1725 if (radeon_ddc_probe(radeon_connector, true)) /* try DDC */
1726 ret = connector_status_connected;
1727 else if (radeon_connector->dac_load_detect) { /* try load detection */
1728 const struct drm_encoder_helper_funcs *encoder_funcs = encoder->helper_private;
1729 ret = encoder_funcs->detect(encoder, connector);
1733 radeon_dig_connector->dp_sink_type = radeon_dp_getsinktype(radeon_connector);
1734 if (radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) {
1735 ret = connector_status_connected;
1736 if (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) {
1737 radeon_dp_getdpcd(radeon_connector);
1738 r = radeon_dp_mst_probe(radeon_connector);
1740 ret = connector_status_disconnected;
1743 if (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) {
1744 if (radeon_dp_getdpcd(radeon_connector)) {
1745 r = radeon_dp_mst_probe(radeon_connector);
1747 ret = connector_status_disconnected;
1749 ret = connector_status_connected;
1752 /* try non-aux ddc (DP to DVI/HDMI/etc. adapter) */
1753 if (radeon_ddc_probe(radeon_connector, false))
1754 ret = connector_status_connected;
1759 radeon_connector_update_scratch_regs(connector, ret);
1761 if ((radeon_audio != 0) && encoder) {
1762 radeon_connector_get_edid(connector);
1763 radeon_audio_detect(connector, encoder, ret);
1767 if (!drm_kms_helper_is_poll_worker()) {
1768 pm_runtime_mark_last_busy(connector->dev->dev);
1769 pm_runtime_put_autosuspend(connector->dev->dev);
1775 static enum drm_mode_status radeon_dp_mode_valid(struct drm_connector *connector,
1776 struct drm_display_mode *mode)
1778 struct drm_device *dev = connector->dev;
1779 struct radeon_device *rdev = dev->dev_private;
1780 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1781 struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
1783 /* XXX check mode bandwidth */
1785 if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) ||
1786 (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
1787 struct drm_encoder *encoder = radeon_best_single_encoder(connector);
1789 if ((mode->hdisplay < 320) || (mode->vdisplay < 240))
1793 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
1794 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
1796 /* AVIVO hardware supports downscaling modes larger than the panel
1797 * to the panel size, but I'm not sure this is desirable.
1799 if ((mode->hdisplay > native_mode->hdisplay) ||
1800 (mode->vdisplay > native_mode->vdisplay))
1803 /* if scaling is disabled, block non-native modes */
1804 if (radeon_encoder->rmx_type == RMX_OFF) {
1805 if ((mode->hdisplay != native_mode->hdisplay) ||
1806 (mode->vdisplay != native_mode->vdisplay))
1811 if ((radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) ||
1812 (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_eDP)) {
1813 return radeon_dp_mode_valid_helper(connector, mode);
1815 if (ASIC_IS_DCE6(rdev) && drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
1816 /* HDMI 1.3+ supports max clock of 340 Mhz */
1817 if (mode->clock > 340000)
1818 return MODE_CLOCK_HIGH;
1820 if (mode->clock > 165000)
1821 return MODE_CLOCK_HIGH;
1829 static const struct drm_connector_helper_funcs radeon_dp_connector_helper_funcs = {
1830 .get_modes = radeon_dp_get_modes,
1831 .mode_valid = radeon_dp_mode_valid,
1832 .best_encoder = radeon_dvi_encoder,
1835 static const struct drm_connector_funcs radeon_dp_connector_funcs = {
1836 .dpms = drm_helper_connector_dpms,
1837 .detect = radeon_dp_detect,
1838 .fill_modes = drm_helper_probe_single_connector_modes,
1839 .set_property = radeon_connector_set_property,
1840 .early_unregister = radeon_connector_unregister,
1841 .destroy = radeon_connector_destroy,
1842 .force = radeon_dvi_force,
1845 static const struct drm_connector_funcs radeon_edp_connector_funcs = {
1846 .dpms = drm_helper_connector_dpms,
1847 .detect = radeon_dp_detect,
1848 .fill_modes = drm_helper_probe_single_connector_modes,
1849 .set_property = radeon_lvds_set_property,
1850 .early_unregister = radeon_connector_unregister,
1851 .destroy = radeon_connector_destroy,
1852 .force = radeon_dvi_force,
1855 static const struct drm_connector_funcs radeon_lvds_bridge_connector_funcs = {
1856 .dpms = drm_helper_connector_dpms,
1857 .detect = radeon_dp_detect,
1858 .fill_modes = drm_helper_probe_single_connector_modes,
1859 .set_property = radeon_lvds_set_property,
1860 .early_unregister = radeon_connector_unregister,
1861 .destroy = radeon_connector_destroy,
1862 .force = radeon_dvi_force,
1866 radeon_add_atom_connector(struct drm_device *dev,
1867 uint32_t connector_id,
1868 uint32_t supported_device,
1870 struct radeon_i2c_bus_rec *i2c_bus,
1871 uint32_t igp_lane_info,
1872 uint16_t connector_object_id,
1873 struct radeon_hpd *hpd,
1874 struct radeon_router *router)
1876 struct radeon_device *rdev = dev->dev_private;
1877 struct drm_connector *connector;
1878 struct radeon_connector *radeon_connector;
1879 struct radeon_connector_atom_dig *radeon_dig_connector;
1880 struct drm_encoder *encoder;
1881 struct radeon_encoder *radeon_encoder;
1882 uint32_t subpixel_order = SubPixelNone;
1883 bool shared_ddc = false;
1884 bool is_dp_bridge = false;
1885 bool has_aux = false;
1887 if (connector_type == DRM_MODE_CONNECTOR_Unknown)
1890 /* if the user selected tv=0 don't try and add the connector */
1891 if (((connector_type == DRM_MODE_CONNECTOR_SVIDEO) ||
1892 (connector_type == DRM_MODE_CONNECTOR_Composite) ||
1893 (connector_type == DRM_MODE_CONNECTOR_9PinDIN)) &&
1897 /* see if we already added it */
1898 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
1899 radeon_connector = to_radeon_connector(connector);
1900 if (radeon_connector->connector_id == connector_id) {
1901 radeon_connector->devices |= supported_device;
1904 if (radeon_connector->ddc_bus && i2c_bus->valid) {
1905 if (radeon_connector->ddc_bus->rec.i2c_id == i2c_bus->i2c_id) {
1906 radeon_connector->shared_ddc = true;
1909 if (radeon_connector->router_bus && router->ddc_valid &&
1910 (radeon_connector->router.router_id == router->router_id)) {
1911 radeon_connector->shared_ddc = false;
1917 /* check if it's a dp bridge */
1918 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
1919 radeon_encoder = to_radeon_encoder(encoder);
1920 if (radeon_encoder->devices & supported_device) {
1921 switch (radeon_encoder->encoder_id) {
1922 case ENCODER_OBJECT_ID_TRAVIS:
1923 case ENCODER_OBJECT_ID_NUTMEG:
1924 is_dp_bridge = true;
1932 radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
1933 if (!radeon_connector)
1936 connector = &radeon_connector->base;
1938 radeon_connector->connector_id = connector_id;
1939 radeon_connector->devices = supported_device;
1940 radeon_connector->shared_ddc = shared_ddc;
1941 radeon_connector->connector_object_id = connector_object_id;
1942 radeon_connector->hpd = *hpd;
1944 radeon_connector->router = *router;
1945 if (router->ddc_valid || router->cd_valid) {
1946 radeon_connector->router_bus = radeon_i2c_lookup(rdev, &router->i2c_info);
1947 if (!radeon_connector->router_bus)
1948 DRM_ERROR("Failed to assign router i2c bus! Check dmesg for i2c errors.\n");
1952 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1953 if (!radeon_dig_connector)
1955 radeon_dig_connector->igp_lane_info = igp_lane_info;
1956 radeon_connector->con_priv = radeon_dig_connector;
1957 if (i2c_bus->valid) {
1958 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1959 if (radeon_connector->ddc_bus)
1962 DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1964 switch (connector_type) {
1965 case DRM_MODE_CONNECTOR_VGA:
1966 case DRM_MODE_CONNECTOR_DVIA:
1968 drm_connector_init(dev, &radeon_connector->base,
1969 &radeon_dp_connector_funcs, connector_type);
1970 drm_connector_helper_add(&radeon_connector->base,
1971 &radeon_dp_connector_helper_funcs);
1972 connector->interlace_allowed = true;
1973 connector->doublescan_allowed = true;
1974 radeon_connector->dac_load_detect = true;
1975 drm_object_attach_property(&radeon_connector->base.base,
1976 rdev->mode_info.load_detect_property,
1978 drm_object_attach_property(&radeon_connector->base.base,
1979 dev->mode_config.scaling_mode_property,
1980 DRM_MODE_SCALE_NONE);
1981 if (ASIC_IS_DCE5(rdev))
1982 drm_object_attach_property(&radeon_connector->base.base,
1983 rdev->mode_info.output_csc_property,
1984 RADEON_OUTPUT_CSC_BYPASS);
1986 case DRM_MODE_CONNECTOR_DVII:
1987 case DRM_MODE_CONNECTOR_DVID:
1988 case DRM_MODE_CONNECTOR_HDMIA:
1989 case DRM_MODE_CONNECTOR_HDMIB:
1990 case DRM_MODE_CONNECTOR_DisplayPort:
1991 drm_connector_init(dev, &radeon_connector->base,
1992 &radeon_dp_connector_funcs, connector_type);
1993 drm_connector_helper_add(&radeon_connector->base,
1994 &radeon_dp_connector_helper_funcs);
1995 drm_object_attach_property(&radeon_connector->base.base,
1996 rdev->mode_info.underscan_property,
1998 drm_object_attach_property(&radeon_connector->base.base,
1999 rdev->mode_info.underscan_hborder_property,
2001 drm_object_attach_property(&radeon_connector->base.base,
2002 rdev->mode_info.underscan_vborder_property,
2005 drm_object_attach_property(&radeon_connector->base.base,
2006 dev->mode_config.scaling_mode_property,
2007 DRM_MODE_SCALE_NONE);
2009 drm_object_attach_property(&radeon_connector->base.base,
2010 rdev->mode_info.dither_property,
2011 RADEON_FMT_DITHER_DISABLE);
2013 if (radeon_audio != 0) {
2014 drm_object_attach_property(&radeon_connector->base.base,
2015 rdev->mode_info.audio_property,
2017 radeon_connector->audio = RADEON_AUDIO_AUTO;
2019 if (ASIC_IS_DCE5(rdev))
2020 drm_object_attach_property(&radeon_connector->base.base,
2021 rdev->mode_info.output_csc_property,
2022 RADEON_OUTPUT_CSC_BYPASS);
2024 subpixel_order = SubPixelHorizontalRGB;
2025 connector->interlace_allowed = true;
2026 if (connector_type == DRM_MODE_CONNECTOR_HDMIB)
2027 connector->doublescan_allowed = true;
2029 connector->doublescan_allowed = false;
2030 if (connector_type == DRM_MODE_CONNECTOR_DVII) {
2031 radeon_connector->dac_load_detect = true;
2032 drm_object_attach_property(&radeon_connector->base.base,
2033 rdev->mode_info.load_detect_property,
2037 case DRM_MODE_CONNECTOR_LVDS:
2038 case DRM_MODE_CONNECTOR_eDP:
2039 drm_connector_init(dev, &radeon_connector->base,
2040 &radeon_lvds_bridge_connector_funcs, connector_type);
2041 drm_connector_helper_add(&radeon_connector->base,
2042 &radeon_dp_connector_helper_funcs);
2043 drm_object_attach_property(&radeon_connector->base.base,
2044 dev->mode_config.scaling_mode_property,
2045 DRM_MODE_SCALE_FULLSCREEN);
2046 subpixel_order = SubPixelHorizontalRGB;
2047 connector->interlace_allowed = false;
2048 connector->doublescan_allowed = false;
2052 switch (connector_type) {
2053 case DRM_MODE_CONNECTOR_VGA:
2054 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
2055 drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
2056 if (i2c_bus->valid) {
2057 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2058 if (!radeon_connector->ddc_bus)
2059 DRM_ERROR("VGA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2061 radeon_connector->dac_load_detect = true;
2062 drm_object_attach_property(&radeon_connector->base.base,
2063 rdev->mode_info.load_detect_property,
2065 if (ASIC_IS_AVIVO(rdev))
2066 drm_object_attach_property(&radeon_connector->base.base,
2067 dev->mode_config.scaling_mode_property,
2068 DRM_MODE_SCALE_NONE);
2069 if (ASIC_IS_DCE5(rdev))
2070 drm_object_attach_property(&radeon_connector->base.base,
2071 rdev->mode_info.output_csc_property,
2072 RADEON_OUTPUT_CSC_BYPASS);
2073 /* no HPD on analog connectors */
2074 radeon_connector->hpd.hpd = RADEON_HPD_NONE;
2075 connector->interlace_allowed = true;
2076 connector->doublescan_allowed = true;
2078 case DRM_MODE_CONNECTOR_DVIA:
2079 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
2080 drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
2081 if (i2c_bus->valid) {
2082 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2083 if (!radeon_connector->ddc_bus)
2084 DRM_ERROR("DVIA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2086 radeon_connector->dac_load_detect = true;
2087 drm_object_attach_property(&radeon_connector->base.base,
2088 rdev->mode_info.load_detect_property,
2090 if (ASIC_IS_AVIVO(rdev))
2091 drm_object_attach_property(&radeon_connector->base.base,
2092 dev->mode_config.scaling_mode_property,
2093 DRM_MODE_SCALE_NONE);
2094 if (ASIC_IS_DCE5(rdev))
2095 drm_object_attach_property(&radeon_connector->base.base,
2096 rdev->mode_info.output_csc_property,
2097 RADEON_OUTPUT_CSC_BYPASS);
2098 /* no HPD on analog connectors */
2099 radeon_connector->hpd.hpd = RADEON_HPD_NONE;
2100 connector->interlace_allowed = true;
2101 connector->doublescan_allowed = true;
2103 case DRM_MODE_CONNECTOR_DVII:
2104 case DRM_MODE_CONNECTOR_DVID:
2105 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
2106 if (!radeon_dig_connector)
2108 radeon_dig_connector->igp_lane_info = igp_lane_info;
2109 radeon_connector->con_priv = radeon_dig_connector;
2110 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
2111 drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
2112 if (i2c_bus->valid) {
2113 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2114 if (!radeon_connector->ddc_bus)
2115 DRM_ERROR("DVI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2117 subpixel_order = SubPixelHorizontalRGB;
2118 drm_object_attach_property(&radeon_connector->base.base,
2119 rdev->mode_info.coherent_mode_property,
2121 if (ASIC_IS_AVIVO(rdev)) {
2122 drm_object_attach_property(&radeon_connector->base.base,
2123 rdev->mode_info.underscan_property,
2125 drm_object_attach_property(&radeon_connector->base.base,
2126 rdev->mode_info.underscan_hborder_property,
2128 drm_object_attach_property(&radeon_connector->base.base,
2129 rdev->mode_info.underscan_vborder_property,
2131 drm_object_attach_property(&radeon_connector->base.base,
2132 rdev->mode_info.dither_property,
2133 RADEON_FMT_DITHER_DISABLE);
2134 drm_object_attach_property(&radeon_connector->base.base,
2135 dev->mode_config.scaling_mode_property,
2136 DRM_MODE_SCALE_NONE);
2138 if (ASIC_IS_DCE2(rdev) && (radeon_audio != 0)) {
2139 drm_object_attach_property(&radeon_connector->base.base,
2140 rdev->mode_info.audio_property,
2142 radeon_connector->audio = RADEON_AUDIO_AUTO;
2144 if (connector_type == DRM_MODE_CONNECTOR_DVII) {
2145 radeon_connector->dac_load_detect = true;
2146 drm_object_attach_property(&radeon_connector->base.base,
2147 rdev->mode_info.load_detect_property,
2150 if (ASIC_IS_DCE5(rdev))
2151 drm_object_attach_property(&radeon_connector->base.base,
2152 rdev->mode_info.output_csc_property,
2153 RADEON_OUTPUT_CSC_BYPASS);
2154 connector->interlace_allowed = true;
2155 if (connector_type == DRM_MODE_CONNECTOR_DVII)
2156 connector->doublescan_allowed = true;
2158 connector->doublescan_allowed = false;
2160 case DRM_MODE_CONNECTOR_HDMIA:
2161 case DRM_MODE_CONNECTOR_HDMIB:
2162 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
2163 if (!radeon_dig_connector)
2165 radeon_dig_connector->igp_lane_info = igp_lane_info;
2166 radeon_connector->con_priv = radeon_dig_connector;
2167 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
2168 drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
2169 if (i2c_bus->valid) {
2170 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2171 if (!radeon_connector->ddc_bus)
2172 DRM_ERROR("HDMI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2174 drm_object_attach_property(&radeon_connector->base.base,
2175 rdev->mode_info.coherent_mode_property,
2177 if (ASIC_IS_AVIVO(rdev)) {
2178 drm_object_attach_property(&radeon_connector->base.base,
2179 rdev->mode_info.underscan_property,
2181 drm_object_attach_property(&radeon_connector->base.base,
2182 rdev->mode_info.underscan_hborder_property,
2184 drm_object_attach_property(&radeon_connector->base.base,
2185 rdev->mode_info.underscan_vborder_property,
2187 drm_object_attach_property(&radeon_connector->base.base,
2188 rdev->mode_info.dither_property,
2189 RADEON_FMT_DITHER_DISABLE);
2190 drm_object_attach_property(&radeon_connector->base.base,
2191 dev->mode_config.scaling_mode_property,
2192 DRM_MODE_SCALE_NONE);
2194 if (ASIC_IS_DCE2(rdev) && (radeon_audio != 0)) {
2195 drm_object_attach_property(&radeon_connector->base.base,
2196 rdev->mode_info.audio_property,
2198 radeon_connector->audio = RADEON_AUDIO_AUTO;
2200 if (ASIC_IS_DCE5(rdev))
2201 drm_object_attach_property(&radeon_connector->base.base,
2202 rdev->mode_info.output_csc_property,
2203 RADEON_OUTPUT_CSC_BYPASS);
2204 subpixel_order = SubPixelHorizontalRGB;
2205 connector->interlace_allowed = true;
2206 if (connector_type == DRM_MODE_CONNECTOR_HDMIB)
2207 connector->doublescan_allowed = true;
2209 connector->doublescan_allowed = false;
2211 case DRM_MODE_CONNECTOR_DisplayPort:
2212 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
2213 if (!radeon_dig_connector)
2215 radeon_dig_connector->igp_lane_info = igp_lane_info;
2216 radeon_connector->con_priv = radeon_dig_connector;
2217 drm_connector_init(dev, &radeon_connector->base, &radeon_dp_connector_funcs, connector_type);
2218 drm_connector_helper_add(&radeon_connector->base, &radeon_dp_connector_helper_funcs);
2219 if (i2c_bus->valid) {
2220 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2221 if (radeon_connector->ddc_bus)
2224 DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2226 subpixel_order = SubPixelHorizontalRGB;
2227 drm_object_attach_property(&radeon_connector->base.base,
2228 rdev->mode_info.coherent_mode_property,
2230 if (ASIC_IS_AVIVO(rdev)) {
2231 drm_object_attach_property(&radeon_connector->base.base,
2232 rdev->mode_info.underscan_property,
2234 drm_object_attach_property(&radeon_connector->base.base,
2235 rdev->mode_info.underscan_hborder_property,
2237 drm_object_attach_property(&radeon_connector->base.base,
2238 rdev->mode_info.underscan_vborder_property,
2240 drm_object_attach_property(&radeon_connector->base.base,
2241 rdev->mode_info.dither_property,
2242 RADEON_FMT_DITHER_DISABLE);
2243 drm_object_attach_property(&radeon_connector->base.base,
2244 dev->mode_config.scaling_mode_property,
2245 DRM_MODE_SCALE_NONE);
2247 if (ASIC_IS_DCE2(rdev) && (radeon_audio != 0)) {
2248 drm_object_attach_property(&radeon_connector->base.base,
2249 rdev->mode_info.audio_property,
2251 radeon_connector->audio = RADEON_AUDIO_AUTO;
2253 if (ASIC_IS_DCE5(rdev))
2254 drm_object_attach_property(&radeon_connector->base.base,
2255 rdev->mode_info.output_csc_property,
2256 RADEON_OUTPUT_CSC_BYPASS);
2257 connector->interlace_allowed = true;
2258 /* in theory with a DP to VGA converter... */
2259 connector->doublescan_allowed = false;
2261 case DRM_MODE_CONNECTOR_eDP:
2262 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
2263 if (!radeon_dig_connector)
2265 radeon_dig_connector->igp_lane_info = igp_lane_info;
2266 radeon_connector->con_priv = radeon_dig_connector;
2267 drm_connector_init(dev, &radeon_connector->base, &radeon_edp_connector_funcs, connector_type);
2268 drm_connector_helper_add(&radeon_connector->base, &radeon_dp_connector_helper_funcs);
2269 if (i2c_bus->valid) {
2270 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2271 if (radeon_connector->ddc_bus)
2274 DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2276 drm_object_attach_property(&radeon_connector->base.base,
2277 dev->mode_config.scaling_mode_property,
2278 DRM_MODE_SCALE_FULLSCREEN);
2279 subpixel_order = SubPixelHorizontalRGB;
2280 connector->interlace_allowed = false;
2281 connector->doublescan_allowed = false;
2283 case DRM_MODE_CONNECTOR_SVIDEO:
2284 case DRM_MODE_CONNECTOR_Composite:
2285 case DRM_MODE_CONNECTOR_9PinDIN:
2286 drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
2287 drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
2288 radeon_connector->dac_load_detect = true;
2289 drm_object_attach_property(&radeon_connector->base.base,
2290 rdev->mode_info.load_detect_property,
2292 drm_object_attach_property(&radeon_connector->base.base,
2293 rdev->mode_info.tv_std_property,
2294 radeon_atombios_get_tv_info(rdev));
2295 /* no HPD on analog connectors */
2296 radeon_connector->hpd.hpd = RADEON_HPD_NONE;
2297 connector->interlace_allowed = false;
2298 connector->doublescan_allowed = false;
2300 case DRM_MODE_CONNECTOR_LVDS:
2301 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
2302 if (!radeon_dig_connector)
2304 radeon_dig_connector->igp_lane_info = igp_lane_info;
2305 radeon_connector->con_priv = radeon_dig_connector;
2306 drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
2307 drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
2308 if (i2c_bus->valid) {
2309 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2310 if (!radeon_connector->ddc_bus)
2311 DRM_ERROR("LVDS: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2313 drm_object_attach_property(&radeon_connector->base.base,
2314 dev->mode_config.scaling_mode_property,
2315 DRM_MODE_SCALE_FULLSCREEN);
2316 subpixel_order = SubPixelHorizontalRGB;
2317 connector->interlace_allowed = false;
2318 connector->doublescan_allowed = false;
2323 if (radeon_connector->hpd.hpd == RADEON_HPD_NONE) {
2324 if (i2c_bus->valid) {
2325 connector->polled = DRM_CONNECTOR_POLL_CONNECT |
2326 DRM_CONNECTOR_POLL_DISCONNECT;
2329 connector->polled = DRM_CONNECTOR_POLL_HPD;
2331 connector->display_info.subpixel_order = subpixel_order;
2332 drm_connector_register(connector);
2335 radeon_dp_aux_init(radeon_connector);
2340 drm_connector_cleanup(connector);
2345 radeon_add_legacy_connector(struct drm_device *dev,
2346 uint32_t connector_id,
2347 uint32_t supported_device,
2349 struct radeon_i2c_bus_rec *i2c_bus,
2350 uint16_t connector_object_id,
2351 struct radeon_hpd *hpd)
2353 struct radeon_device *rdev = dev->dev_private;
2354 struct drm_connector *connector;
2355 struct radeon_connector *radeon_connector;
2356 uint32_t subpixel_order = SubPixelNone;
2358 if (connector_type == DRM_MODE_CONNECTOR_Unknown)
2361 /* if the user selected tv=0 don't try and add the connector */
2362 if (((connector_type == DRM_MODE_CONNECTOR_SVIDEO) ||
2363 (connector_type == DRM_MODE_CONNECTOR_Composite) ||
2364 (connector_type == DRM_MODE_CONNECTOR_9PinDIN)) &&
2368 /* see if we already added it */
2369 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
2370 radeon_connector = to_radeon_connector(connector);
2371 if (radeon_connector->connector_id == connector_id) {
2372 radeon_connector->devices |= supported_device;
2377 radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
2378 if (!radeon_connector)
2381 connector = &radeon_connector->base;
2383 radeon_connector->connector_id = connector_id;
2384 radeon_connector->devices = supported_device;
2385 radeon_connector->connector_object_id = connector_object_id;
2386 radeon_connector->hpd = *hpd;
2388 switch (connector_type) {
2389 case DRM_MODE_CONNECTOR_VGA:
2390 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
2391 drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
2392 if (i2c_bus->valid) {
2393 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2394 if (!radeon_connector->ddc_bus)
2395 DRM_ERROR("VGA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2397 radeon_connector->dac_load_detect = true;
2398 drm_object_attach_property(&radeon_connector->base.base,
2399 rdev->mode_info.load_detect_property,
2401 /* no HPD on analog connectors */
2402 radeon_connector->hpd.hpd = RADEON_HPD_NONE;
2403 connector->interlace_allowed = true;
2404 connector->doublescan_allowed = true;
2406 case DRM_MODE_CONNECTOR_DVIA:
2407 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
2408 drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
2409 if (i2c_bus->valid) {
2410 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2411 if (!radeon_connector->ddc_bus)
2412 DRM_ERROR("DVIA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2414 radeon_connector->dac_load_detect = true;
2415 drm_object_attach_property(&radeon_connector->base.base,
2416 rdev->mode_info.load_detect_property,
2418 /* no HPD on analog connectors */
2419 radeon_connector->hpd.hpd = RADEON_HPD_NONE;
2420 connector->interlace_allowed = true;
2421 connector->doublescan_allowed = true;
2423 case DRM_MODE_CONNECTOR_DVII:
2424 case DRM_MODE_CONNECTOR_DVID:
2425 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
2426 drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
2427 if (i2c_bus->valid) {
2428 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2429 if (!radeon_connector->ddc_bus)
2430 DRM_ERROR("DVI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2432 if (connector_type == DRM_MODE_CONNECTOR_DVII) {
2433 radeon_connector->dac_load_detect = true;
2434 drm_object_attach_property(&radeon_connector->base.base,
2435 rdev->mode_info.load_detect_property,
2438 subpixel_order = SubPixelHorizontalRGB;
2439 connector->interlace_allowed = true;
2440 if (connector_type == DRM_MODE_CONNECTOR_DVII)
2441 connector->doublescan_allowed = true;
2443 connector->doublescan_allowed = false;
2445 case DRM_MODE_CONNECTOR_SVIDEO:
2446 case DRM_MODE_CONNECTOR_Composite:
2447 case DRM_MODE_CONNECTOR_9PinDIN:
2448 drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
2449 drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
2450 radeon_connector->dac_load_detect = true;
2451 /* RS400,RC410,RS480 chipset seems to report a lot
2452 * of false positive on load detect, we haven't yet
2453 * found a way to make load detect reliable on those
2454 * chipset, thus just disable it for TV.
2456 if (rdev->family == CHIP_RS400 || rdev->family == CHIP_RS480)
2457 radeon_connector->dac_load_detect = false;
2458 drm_object_attach_property(&radeon_connector->base.base,
2459 rdev->mode_info.load_detect_property,
2460 radeon_connector->dac_load_detect);
2461 drm_object_attach_property(&radeon_connector->base.base,
2462 rdev->mode_info.tv_std_property,
2463 radeon_combios_get_tv_info(rdev));
2464 /* no HPD on analog connectors */
2465 radeon_connector->hpd.hpd = RADEON_HPD_NONE;
2466 connector->interlace_allowed = false;
2467 connector->doublescan_allowed = false;
2469 case DRM_MODE_CONNECTOR_LVDS:
2470 drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
2471 drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
2472 if (i2c_bus->valid) {
2473 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2474 if (!radeon_connector->ddc_bus)
2475 DRM_ERROR("LVDS: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2477 drm_object_attach_property(&radeon_connector->base.base,
2478 dev->mode_config.scaling_mode_property,
2479 DRM_MODE_SCALE_FULLSCREEN);
2480 subpixel_order = SubPixelHorizontalRGB;
2481 connector->interlace_allowed = false;
2482 connector->doublescan_allowed = false;
2486 if (radeon_connector->hpd.hpd == RADEON_HPD_NONE) {
2487 if (i2c_bus->valid) {
2488 connector->polled = DRM_CONNECTOR_POLL_CONNECT |
2489 DRM_CONNECTOR_POLL_DISCONNECT;
2492 connector->polled = DRM_CONNECTOR_POLL_HPD;
2494 connector->display_info.subpixel_order = subpixel_order;
2495 drm_connector_register(connector);
2498 void radeon_setup_mst_connector(struct drm_device *dev)
2500 struct radeon_device *rdev = dev->dev_private;
2501 struct drm_connector *connector;
2502 struct radeon_connector *radeon_connector;
2504 if (!ASIC_IS_DCE5(rdev))
2507 if (radeon_mst == 0)
2510 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
2513 radeon_connector = to_radeon_connector(connector);
2515 if (connector->connector_type != DRM_MODE_CONNECTOR_DisplayPort)
2518 ret = radeon_dp_mst_init(radeon_connector);