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/radeon_drm.h>
34 #include <linux/pm_runtime.h>
36 void radeon_connector_hotplug(struct drm_connector
*connector
)
38 struct drm_device
*dev
= connector
->dev
;
39 struct radeon_device
*rdev
= dev
->dev_private
;
40 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
42 /* bail if the connector does not have hpd pin, e.g.,
45 if (radeon_connector
->hpd
.hpd
== RADEON_HPD_NONE
)
48 radeon_hpd_set_polarity(rdev
, radeon_connector
->hpd
.hpd
);
50 /* if the connector is already off, don't turn it back on */
51 /* FIXME: This access isn't protected by any locks. */
52 if (connector
->dpms
!= DRM_MODE_DPMS_ON
)
55 /* just deal with DP (not eDP) here. */
56 if (connector
->connector_type
== DRM_MODE_CONNECTOR_DisplayPort
) {
57 struct radeon_connector_atom_dig
*dig_connector
=
58 radeon_connector
->con_priv
;
60 /* if existing sink type was not DP no need to retrain */
61 if (dig_connector
->dp_sink_type
!= CONNECTOR_OBJECT_ID_DISPLAYPORT
)
64 /* first get sink type as it may be reset after (un)plug */
65 dig_connector
->dp_sink_type
= radeon_dp_getsinktype(radeon_connector
);
66 /* don't do anything if sink is not display port, i.e.,
67 * passive dp->(dvi|hdmi) adaptor
69 if (dig_connector
->dp_sink_type
== CONNECTOR_OBJECT_ID_DISPLAYPORT
) {
70 int saved_dpms
= connector
->dpms
;
71 /* Only turn off the display if it's physically disconnected */
72 if (!radeon_hpd_sense(rdev
, radeon_connector
->hpd
.hpd
)) {
73 drm_helper_connector_dpms(connector
, DRM_MODE_DPMS_OFF
);
74 } else if (radeon_dp_needs_link_train(radeon_connector
)) {
75 /* set it to OFF so that drm_helper_connector_dpms()
76 * won't return immediately since the current state
77 * is ON at this point.
79 connector
->dpms
= DRM_MODE_DPMS_OFF
;
80 drm_helper_connector_dpms(connector
, DRM_MODE_DPMS_ON
);
82 connector
->dpms
= saved_dpms
;
87 static void radeon_property_change_mode(struct drm_encoder
*encoder
)
89 struct drm_crtc
*crtc
= encoder
->crtc
;
91 if (crtc
&& crtc
->enabled
) {
92 drm_crtc_helper_set_mode(crtc
, &crtc
->mode
,
93 crtc
->x
, crtc
->y
, crtc
->primary
->fb
);
97 int radeon_get_monitor_bpc(struct drm_connector
*connector
)
99 struct drm_device
*dev
= connector
->dev
;
100 struct radeon_device
*rdev
= dev
->dev_private
;
101 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
102 struct radeon_connector_atom_dig
*dig_connector
;
104 int mode_clock
, max_tmds_clock
;
106 switch (connector
->connector_type
) {
107 case DRM_MODE_CONNECTOR_DVII
:
108 case DRM_MODE_CONNECTOR_HDMIB
:
109 if (radeon_connector
->use_digital
) {
110 if (drm_detect_hdmi_monitor(radeon_connector
->edid
)) {
111 if (connector
->display_info
.bpc
)
112 bpc
= connector
->display_info
.bpc
;
116 case DRM_MODE_CONNECTOR_DVID
:
117 case DRM_MODE_CONNECTOR_HDMIA
:
118 if (drm_detect_hdmi_monitor(radeon_connector
->edid
)) {
119 if (connector
->display_info
.bpc
)
120 bpc
= connector
->display_info
.bpc
;
123 case DRM_MODE_CONNECTOR_DisplayPort
:
124 dig_connector
= radeon_connector
->con_priv
;
125 if ((dig_connector
->dp_sink_type
== CONNECTOR_OBJECT_ID_DISPLAYPORT
) ||
126 (dig_connector
->dp_sink_type
== CONNECTOR_OBJECT_ID_eDP
) ||
127 drm_detect_hdmi_monitor(radeon_connector
->edid
)) {
128 if (connector
->display_info
.bpc
)
129 bpc
= connector
->display_info
.bpc
;
132 case DRM_MODE_CONNECTOR_eDP
:
133 case DRM_MODE_CONNECTOR_LVDS
:
134 if (connector
->display_info
.bpc
)
135 bpc
= connector
->display_info
.bpc
;
136 else if (ASIC_IS_DCE41(rdev
) || ASIC_IS_DCE5(rdev
)) {
137 struct drm_connector_helper_funcs
*connector_funcs
=
138 connector
->helper_private
;
139 struct drm_encoder
*encoder
= connector_funcs
->best_encoder(connector
);
140 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
141 struct radeon_encoder_atom_dig
*dig
= radeon_encoder
->enc_priv
;
143 if (dig
->lcd_misc
& ATOM_PANEL_MISC_V13_6BIT_PER_COLOR
)
145 else if (dig
->lcd_misc
& ATOM_PANEL_MISC_V13_8BIT_PER_COLOR
)
151 if (drm_detect_hdmi_monitor(radeon_connector
->edid
)) {
152 /* hdmi deep color only implemented on DCE4+ */
153 if ((bpc
> 8) && !ASIC_IS_DCE4(rdev
)) {
154 DRM_DEBUG("%s: HDMI deep color %d bpc unsupported. Using 8 bpc.\n",
155 connector
->name
, bpc
);
160 * Pre DCE-8 hw can't handle > 12 bpc, and more than 12 bpc doesn't make
161 * much sense without support for > 12 bpc framebuffers. RGB 4:4:4 at
162 * 12 bpc is always supported on hdmi deep color sinks, as this is
163 * required by the HDMI-1.3 spec. Clamp to a safe 12 bpc maximum.
166 DRM_DEBUG("%s: HDMI deep color %d bpc unsupported. Using 12 bpc.\n",
167 connector
->name
, bpc
);
171 /* Any defined maximum tmds clock limit we must not exceed? */
172 if (connector
->max_tmds_clock
> 0) {
173 /* mode_clock is clock in kHz for mode to be modeset on this connector */
174 mode_clock
= radeon_connector
->pixelclock_for_modeset
;
176 /* Maximum allowable input clock in kHz */
177 max_tmds_clock
= connector
->max_tmds_clock
* 1000;
179 DRM_DEBUG("%s: hdmi mode dotclock %d kHz, max tmds input clock %d kHz.\n",
180 connector
->name
, mode_clock
, max_tmds_clock
);
182 /* Check if bpc is within clock limit. Try to degrade gracefully otherwise */
183 if ((bpc
== 12) && (mode_clock
* 3/2 > max_tmds_clock
)) {
184 if ((connector
->display_info
.edid_hdmi_dc_modes
& DRM_EDID_HDMI_DC_30
) &&
185 (mode_clock
* 5/4 <= max_tmds_clock
))
190 DRM_DEBUG("%s: HDMI deep color 12 bpc exceeds max tmds clock. Using %d bpc.\n",
191 connector
->name
, bpc
);
194 if ((bpc
== 10) && (mode_clock
* 5/4 > max_tmds_clock
)) {
196 DRM_DEBUG("%s: HDMI deep color 10 bpc exceeds max tmds clock. Using %d bpc.\n",
197 connector
->name
, bpc
);
202 if ((radeon_deep_color
== 0) && (bpc
> 8))
205 DRM_DEBUG("%s: Display bpc=%d, returned bpc=%d\n",
206 connector
->name
, connector
->display_info
.bpc
, bpc
);
212 radeon_connector_update_scratch_regs(struct drm_connector
*connector
, enum drm_connector_status status
)
214 struct drm_device
*dev
= connector
->dev
;
215 struct radeon_device
*rdev
= dev
->dev_private
;
216 struct drm_encoder
*best_encoder
= NULL
;
217 struct drm_encoder
*encoder
= NULL
;
218 struct drm_connector_helper_funcs
*connector_funcs
= connector
->helper_private
;
219 struct drm_mode_object
*obj
;
223 best_encoder
= connector_funcs
->best_encoder(connector
);
225 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
226 if (connector
->encoder_ids
[i
] == 0)
229 obj
= drm_mode_object_find(connector
->dev
,
230 connector
->encoder_ids
[i
],
231 DRM_MODE_OBJECT_ENCODER
);
235 encoder
= obj_to_encoder(obj
);
237 if ((encoder
== best_encoder
) && (status
== connector_status_connected
))
242 if (rdev
->is_atom_bios
)
243 radeon_atombios_connected_scratch_regs(connector
, encoder
, connected
);
245 radeon_combios_connected_scratch_regs(connector
, encoder
, connected
);
250 static struct drm_encoder
*radeon_find_encoder(struct drm_connector
*connector
, int encoder_type
)
252 struct drm_mode_object
*obj
;
253 struct drm_encoder
*encoder
;
256 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
257 if (connector
->encoder_ids
[i
] == 0)
260 obj
= drm_mode_object_find(connector
->dev
, connector
->encoder_ids
[i
], DRM_MODE_OBJECT_ENCODER
);
264 encoder
= obj_to_encoder(obj
);
265 if (encoder
->encoder_type
== encoder_type
)
271 static struct drm_encoder
*radeon_best_single_encoder(struct drm_connector
*connector
)
273 int enc_id
= connector
->encoder_ids
[0];
274 struct drm_mode_object
*obj
;
275 struct drm_encoder
*encoder
;
277 /* pick the encoder ids */
279 obj
= drm_mode_object_find(connector
->dev
, enc_id
, DRM_MODE_OBJECT_ENCODER
);
282 encoder
= obj_to_encoder(obj
);
289 * radeon_connector_analog_encoder_conflict_solve
290 * - search for other connectors sharing this encoder
291 * if priority is true, then set them disconnected if this is connected
292 * if priority is false, set us disconnected if they are connected
294 static enum drm_connector_status
295 radeon_connector_analog_encoder_conflict_solve(struct drm_connector
*connector
,
296 struct drm_encoder
*encoder
,
297 enum drm_connector_status current_status
,
300 struct drm_device
*dev
= connector
->dev
;
301 struct drm_connector
*conflict
;
302 struct radeon_connector
*radeon_conflict
;
305 list_for_each_entry(conflict
, &dev
->mode_config
.connector_list
, head
) {
306 if (conflict
== connector
)
309 radeon_conflict
= to_radeon_connector(conflict
);
310 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
311 if (conflict
->encoder_ids
[i
] == 0)
314 /* if the IDs match */
315 if (conflict
->encoder_ids
[i
] == encoder
->base
.id
) {
316 if (conflict
->status
!= connector_status_connected
)
319 if (radeon_conflict
->use_digital
)
322 if (priority
== true) {
323 DRM_DEBUG_KMS("1: conflicting encoders switching off %s\n",
325 DRM_DEBUG_KMS("in favor of %s\n",
327 conflict
->status
= connector_status_disconnected
;
328 radeon_connector_update_scratch_regs(conflict
, connector_status_disconnected
);
330 DRM_DEBUG_KMS("2: conflicting encoders switching off %s\n",
332 DRM_DEBUG_KMS("in favor of %s\n",
334 current_status
= connector_status_disconnected
;
340 return current_status
;
344 static struct drm_display_mode
*radeon_fp_native_mode(struct drm_encoder
*encoder
)
346 struct drm_device
*dev
= encoder
->dev
;
347 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
348 struct drm_display_mode
*mode
= NULL
;
349 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
351 if (native_mode
->hdisplay
!= 0 &&
352 native_mode
->vdisplay
!= 0 &&
353 native_mode
->clock
!= 0) {
354 mode
= drm_mode_duplicate(dev
, native_mode
);
355 mode
->type
= DRM_MODE_TYPE_PREFERRED
| DRM_MODE_TYPE_DRIVER
;
356 drm_mode_set_name(mode
);
358 DRM_DEBUG_KMS("Adding native panel mode %s\n", mode
->name
);
359 } else if (native_mode
->hdisplay
!= 0 &&
360 native_mode
->vdisplay
!= 0) {
361 /* mac laptops without an edid */
362 /* Note that this is not necessarily the exact panel mode,
363 * but an approximation based on the cvt formula. For these
364 * systems we should ideally read the mode info out of the
365 * registers or add a mode table, but this works and is much
368 mode
= drm_cvt_mode(dev
, native_mode
->hdisplay
, native_mode
->vdisplay
, 60, true, false, false);
369 mode
->type
= DRM_MODE_TYPE_PREFERRED
| DRM_MODE_TYPE_DRIVER
;
370 DRM_DEBUG_KMS("Adding cvt approximation of native panel mode %s\n", mode
->name
);
375 static void radeon_add_common_modes(struct drm_encoder
*encoder
, struct drm_connector
*connector
)
377 struct drm_device
*dev
= encoder
->dev
;
378 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
379 struct drm_display_mode
*mode
= NULL
;
380 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
385 } common_modes
[17] = {
405 for (i
= 0; i
< 17; i
++) {
406 if (radeon_encoder
->devices
& (ATOM_DEVICE_TV_SUPPORT
)) {
407 if (common_modes
[i
].w
> 1024 ||
408 common_modes
[i
].h
> 768)
411 if (radeon_encoder
->devices
& (ATOM_DEVICE_LCD_SUPPORT
)) {
412 if (common_modes
[i
].w
> native_mode
->hdisplay
||
413 common_modes
[i
].h
> native_mode
->vdisplay
||
414 (common_modes
[i
].w
== native_mode
->hdisplay
&&
415 common_modes
[i
].h
== native_mode
->vdisplay
))
418 if (common_modes
[i
].w
< 320 || common_modes
[i
].h
< 200)
421 mode
= drm_cvt_mode(dev
, common_modes
[i
].w
, common_modes
[i
].h
, 60, false, false, false);
422 drm_mode_probed_add(connector
, mode
);
426 static int radeon_connector_set_property(struct drm_connector
*connector
, struct drm_property
*property
,
429 struct drm_device
*dev
= connector
->dev
;
430 struct radeon_device
*rdev
= dev
->dev_private
;
431 struct drm_encoder
*encoder
;
432 struct radeon_encoder
*radeon_encoder
;
434 if (property
== rdev
->mode_info
.coherent_mode_property
) {
435 struct radeon_encoder_atom_dig
*dig
;
436 bool new_coherent_mode
;
438 /* need to find digital encoder on connector */
439 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TMDS
);
443 radeon_encoder
= to_radeon_encoder(encoder
);
445 if (!radeon_encoder
->enc_priv
)
448 dig
= radeon_encoder
->enc_priv
;
449 new_coherent_mode
= val
? true : false;
450 if (dig
->coherent_mode
!= new_coherent_mode
) {
451 dig
->coherent_mode
= new_coherent_mode
;
452 radeon_property_change_mode(&radeon_encoder
->base
);
456 if (property
== rdev
->mode_info
.audio_property
) {
457 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
458 /* need to find digital encoder on connector */
459 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TMDS
);
463 radeon_encoder
= to_radeon_encoder(encoder
);
465 if (radeon_connector
->audio
!= val
) {
466 radeon_connector
->audio
= val
;
467 radeon_property_change_mode(&radeon_encoder
->base
);
471 if (property
== rdev
->mode_info
.dither_property
) {
472 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
473 /* need to find digital encoder on connector */
474 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TMDS
);
478 radeon_encoder
= to_radeon_encoder(encoder
);
480 if (radeon_connector
->dither
!= val
) {
481 radeon_connector
->dither
= val
;
482 radeon_property_change_mode(&radeon_encoder
->base
);
486 if (property
== rdev
->mode_info
.underscan_property
) {
487 /* need to find digital encoder on connector */
488 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TMDS
);
492 radeon_encoder
= to_radeon_encoder(encoder
);
494 if (radeon_encoder
->underscan_type
!= val
) {
495 radeon_encoder
->underscan_type
= val
;
496 radeon_property_change_mode(&radeon_encoder
->base
);
500 if (property
== rdev
->mode_info
.underscan_hborder_property
) {
501 /* need to find digital encoder on connector */
502 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TMDS
);
506 radeon_encoder
= to_radeon_encoder(encoder
);
508 if (radeon_encoder
->underscan_hborder
!= val
) {
509 radeon_encoder
->underscan_hborder
= val
;
510 radeon_property_change_mode(&radeon_encoder
->base
);
514 if (property
== rdev
->mode_info
.underscan_vborder_property
) {
515 /* need to find digital encoder on connector */
516 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TMDS
);
520 radeon_encoder
= to_radeon_encoder(encoder
);
522 if (radeon_encoder
->underscan_vborder
!= val
) {
523 radeon_encoder
->underscan_vborder
= val
;
524 radeon_property_change_mode(&radeon_encoder
->base
);
528 if (property
== rdev
->mode_info
.tv_std_property
) {
529 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TVDAC
);
531 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_DAC
);
537 radeon_encoder
= to_radeon_encoder(encoder
);
538 if (!radeon_encoder
->enc_priv
)
540 if (ASIC_IS_AVIVO(rdev
) || radeon_r4xx_atom
) {
541 struct radeon_encoder_atom_dac
*dac_int
;
542 dac_int
= radeon_encoder
->enc_priv
;
543 dac_int
->tv_std
= val
;
545 struct radeon_encoder_tv_dac
*dac_int
;
546 dac_int
= radeon_encoder
->enc_priv
;
547 dac_int
->tv_std
= val
;
549 radeon_property_change_mode(&radeon_encoder
->base
);
552 if (property
== rdev
->mode_info
.load_detect_property
) {
553 struct radeon_connector
*radeon_connector
=
554 to_radeon_connector(connector
);
557 radeon_connector
->dac_load_detect
= false;
559 radeon_connector
->dac_load_detect
= true;
562 if (property
== rdev
->mode_info
.tmds_pll_property
) {
563 struct radeon_encoder_int_tmds
*tmds
= NULL
;
565 /* need to find digital encoder on connector */
566 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TMDS
);
570 radeon_encoder
= to_radeon_encoder(encoder
);
572 tmds
= radeon_encoder
->enc_priv
;
577 if (rdev
->is_atom_bios
)
578 ret
= radeon_atombios_get_tmds_info(radeon_encoder
, tmds
);
580 ret
= radeon_legacy_get_tmds_info_from_combios(radeon_encoder
, tmds
);
582 if (val
== 1 || ret
== false) {
583 radeon_legacy_get_tmds_info_from_table(radeon_encoder
, tmds
);
585 radeon_property_change_mode(&radeon_encoder
->base
);
591 static void radeon_fixup_lvds_native_mode(struct drm_encoder
*encoder
,
592 struct drm_connector
*connector
)
594 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
595 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
596 struct drm_display_mode
*t
, *mode
;
598 /* If the EDID preferred mode doesn't match the native mode, use it */
599 list_for_each_entry_safe(mode
, t
, &connector
->probed_modes
, head
) {
600 if (mode
->type
& DRM_MODE_TYPE_PREFERRED
) {
601 if (mode
->hdisplay
!= native_mode
->hdisplay
||
602 mode
->vdisplay
!= native_mode
->vdisplay
)
603 memcpy(native_mode
, mode
, sizeof(*mode
));
607 /* Try to get native mode details from EDID if necessary */
608 if (!native_mode
->clock
) {
609 list_for_each_entry_safe(mode
, t
, &connector
->probed_modes
, head
) {
610 if (mode
->hdisplay
== native_mode
->hdisplay
&&
611 mode
->vdisplay
== native_mode
->vdisplay
) {
612 *native_mode
= *mode
;
613 drm_mode_set_crtcinfo(native_mode
, CRTC_INTERLACE_HALVE_V
);
614 DRM_DEBUG_KMS("Determined LVDS native mode details from EDID\n");
620 if (!native_mode
->clock
) {
621 DRM_DEBUG_KMS("No LVDS native mode details, disabling RMX\n");
622 radeon_encoder
->rmx_type
= RMX_OFF
;
626 static int radeon_lvds_get_modes(struct drm_connector
*connector
)
628 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
629 struct drm_encoder
*encoder
;
631 struct drm_display_mode
*mode
;
633 if (radeon_connector
->ddc_bus
) {
634 ret
= radeon_ddc_get_modes(radeon_connector
);
636 encoder
= radeon_best_single_encoder(connector
);
638 radeon_fixup_lvds_native_mode(encoder
, connector
);
639 /* add scaled modes */
640 radeon_add_common_modes(encoder
, connector
);
646 encoder
= radeon_best_single_encoder(connector
);
650 /* we have no EDID modes */
651 mode
= radeon_fp_native_mode(encoder
);
654 drm_mode_probed_add(connector
, mode
);
655 /* add the width/height from vbios tables if available */
656 connector
->display_info
.width_mm
= mode
->width_mm
;
657 connector
->display_info
.height_mm
= mode
->height_mm
;
658 /* add scaled modes */
659 radeon_add_common_modes(encoder
, connector
);
665 static int radeon_lvds_mode_valid(struct drm_connector
*connector
,
666 struct drm_display_mode
*mode
)
668 struct drm_encoder
*encoder
= radeon_best_single_encoder(connector
);
670 if ((mode
->hdisplay
< 320) || (mode
->vdisplay
< 240))
674 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
675 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
677 /* AVIVO hardware supports downscaling modes larger than the panel
678 * to the panel size, but I'm not sure this is desirable.
680 if ((mode
->hdisplay
> native_mode
->hdisplay
) ||
681 (mode
->vdisplay
> native_mode
->vdisplay
))
684 /* if scaling is disabled, block non-native modes */
685 if (radeon_encoder
->rmx_type
== RMX_OFF
) {
686 if ((mode
->hdisplay
!= native_mode
->hdisplay
) ||
687 (mode
->vdisplay
!= native_mode
->vdisplay
))
695 static enum drm_connector_status
696 radeon_lvds_detect(struct drm_connector
*connector
, bool force
)
698 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
699 struct drm_encoder
*encoder
= radeon_best_single_encoder(connector
);
700 enum drm_connector_status ret
= connector_status_disconnected
;
703 r
= pm_runtime_get_sync(connector
->dev
->dev
);
705 return connector_status_disconnected
;
708 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
709 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
711 /* check if panel is valid */
712 if (native_mode
->hdisplay
>= 320 && native_mode
->vdisplay
>= 240)
713 ret
= connector_status_connected
;
717 /* check for edid as well */
718 if (radeon_connector
->edid
)
719 ret
= connector_status_connected
;
721 if (radeon_connector
->ddc_bus
) {
722 radeon_connector
->edid
= drm_get_edid(&radeon_connector
->base
,
723 &radeon_connector
->ddc_bus
->adapter
);
724 if (radeon_connector
->edid
)
725 ret
= connector_status_connected
;
728 /* check acpi lid status ??? */
730 radeon_connector_update_scratch_regs(connector
, ret
);
731 pm_runtime_mark_last_busy(connector
->dev
->dev
);
732 pm_runtime_put_autosuspend(connector
->dev
->dev
);
736 static void radeon_connector_destroy(struct drm_connector
*connector
)
738 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
740 if (radeon_connector
->edid
)
741 kfree(radeon_connector
->edid
);
742 kfree(radeon_connector
->con_priv
);
743 drm_sysfs_connector_remove(connector
);
744 drm_connector_cleanup(connector
);
748 static int radeon_lvds_set_property(struct drm_connector
*connector
,
749 struct drm_property
*property
,
752 struct drm_device
*dev
= connector
->dev
;
753 struct radeon_encoder
*radeon_encoder
;
754 enum radeon_rmx_type rmx_type
;
757 if (property
!= dev
->mode_config
.scaling_mode_property
)
760 if (connector
->encoder
)
761 radeon_encoder
= to_radeon_encoder(connector
->encoder
);
763 struct drm_connector_helper_funcs
*connector_funcs
= connector
->helper_private
;
764 radeon_encoder
= to_radeon_encoder(connector_funcs
->best_encoder(connector
));
768 case DRM_MODE_SCALE_NONE
: rmx_type
= RMX_OFF
; break;
769 case DRM_MODE_SCALE_CENTER
: rmx_type
= RMX_CENTER
; break;
770 case DRM_MODE_SCALE_ASPECT
: rmx_type
= RMX_ASPECT
; break;
772 case DRM_MODE_SCALE_FULLSCREEN
: rmx_type
= RMX_FULL
; break;
774 if (radeon_encoder
->rmx_type
== rmx_type
)
777 radeon_encoder
->rmx_type
= rmx_type
;
779 radeon_property_change_mode(&radeon_encoder
->base
);
784 static const struct drm_connector_helper_funcs radeon_lvds_connector_helper_funcs
= {
785 .get_modes
= radeon_lvds_get_modes
,
786 .mode_valid
= radeon_lvds_mode_valid
,
787 .best_encoder
= radeon_best_single_encoder
,
790 static const struct drm_connector_funcs radeon_lvds_connector_funcs
= {
791 .dpms
= drm_helper_connector_dpms
,
792 .detect
= radeon_lvds_detect
,
793 .fill_modes
= drm_helper_probe_single_connector_modes
,
794 .destroy
= radeon_connector_destroy
,
795 .set_property
= radeon_lvds_set_property
,
798 static int radeon_vga_get_modes(struct drm_connector
*connector
)
800 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
803 ret
= radeon_ddc_get_modes(radeon_connector
);
808 static int radeon_vga_mode_valid(struct drm_connector
*connector
,
809 struct drm_display_mode
*mode
)
811 struct drm_device
*dev
= connector
->dev
;
812 struct radeon_device
*rdev
= dev
->dev_private
;
814 /* XXX check mode bandwidth */
816 if ((mode
->clock
/ 10) > rdev
->clock
.max_pixel_clock
)
817 return MODE_CLOCK_HIGH
;
822 static enum drm_connector_status
823 radeon_vga_detect(struct drm_connector
*connector
, bool force
)
825 struct drm_device
*dev
= connector
->dev
;
826 struct radeon_device
*rdev
= dev
->dev_private
;
827 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
828 struct drm_encoder
*encoder
;
829 struct drm_encoder_helper_funcs
*encoder_funcs
;
831 enum drm_connector_status ret
= connector_status_disconnected
;
834 r
= pm_runtime_get_sync(connector
->dev
->dev
);
836 return connector_status_disconnected
;
838 encoder
= radeon_best_single_encoder(connector
);
840 ret
= connector_status_disconnected
;
842 if (radeon_connector
->ddc_bus
)
843 dret
= radeon_ddc_probe(radeon_connector
, false);
845 radeon_connector
->detected_by_load
= false;
846 if (radeon_connector
->edid
) {
847 kfree(radeon_connector
->edid
);
848 radeon_connector
->edid
= NULL
;
850 radeon_connector
->edid
= drm_get_edid(&radeon_connector
->base
, &radeon_connector
->ddc_bus
->adapter
);
852 if (!radeon_connector
->edid
) {
853 DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
855 ret
= connector_status_connected
;
857 radeon_connector
->use_digital
= !!(radeon_connector
->edid
->input
& DRM_EDID_INPUT_DIGITAL
);
859 /* some oems have boards with separate digital and analog connectors
860 * with a shared ddc line (often vga + hdmi)
862 if (radeon_connector
->use_digital
&& radeon_connector
->shared_ddc
) {
863 kfree(radeon_connector
->edid
);
864 radeon_connector
->edid
= NULL
;
865 ret
= connector_status_disconnected
;
867 ret
= connector_status_connected
;
871 /* if we aren't forcing don't do destructive polling */
873 /* only return the previous status if we last
874 * detected a monitor via load.
876 if (radeon_connector
->detected_by_load
)
877 ret
= connector
->status
;
881 if (radeon_connector
->dac_load_detect
&& encoder
) {
882 encoder_funcs
= encoder
->helper_private
;
883 ret
= encoder_funcs
->detect(encoder
, connector
);
884 if (ret
!= connector_status_disconnected
)
885 radeon_connector
->detected_by_load
= true;
889 if (ret
== connector_status_connected
)
890 ret
= radeon_connector_analog_encoder_conflict_solve(connector
, encoder
, ret
, true);
892 /* RN50 and some RV100 asics in servers often have a hardcoded EDID in the
893 * vbios to deal with KVMs. If we have one and are not able to detect a monitor
894 * by other means, assume the CRT is connected and use that EDID.
896 if ((!rdev
->is_atom_bios
) &&
897 (ret
== connector_status_disconnected
) &&
898 rdev
->mode_info
.bios_hardcoded_edid_size
) {
899 ret
= connector_status_connected
;
902 radeon_connector_update_scratch_regs(connector
, ret
);
905 pm_runtime_mark_last_busy(connector
->dev
->dev
);
906 pm_runtime_put_autosuspend(connector
->dev
->dev
);
911 static const struct drm_connector_helper_funcs radeon_vga_connector_helper_funcs
= {
912 .get_modes
= radeon_vga_get_modes
,
913 .mode_valid
= radeon_vga_mode_valid
,
914 .best_encoder
= radeon_best_single_encoder
,
917 static const struct drm_connector_funcs radeon_vga_connector_funcs
= {
918 .dpms
= drm_helper_connector_dpms
,
919 .detect
= radeon_vga_detect
,
920 .fill_modes
= drm_helper_probe_single_connector_modes
,
921 .destroy
= radeon_connector_destroy
,
922 .set_property
= radeon_connector_set_property
,
925 static int radeon_tv_get_modes(struct drm_connector
*connector
)
927 struct drm_device
*dev
= connector
->dev
;
928 struct radeon_device
*rdev
= dev
->dev_private
;
929 struct drm_display_mode
*tv_mode
;
930 struct drm_encoder
*encoder
;
932 encoder
= radeon_best_single_encoder(connector
);
936 /* avivo chips can scale any mode */
937 if (rdev
->family
>= CHIP_RS600
)
938 /* add scaled modes */
939 radeon_add_common_modes(encoder
, connector
);
941 /* only 800x600 is supported right now on pre-avivo chips */
942 tv_mode
= drm_cvt_mode(dev
, 800, 600, 60, false, false, false);
943 tv_mode
->type
= DRM_MODE_TYPE_DRIVER
| DRM_MODE_TYPE_PREFERRED
;
944 drm_mode_probed_add(connector
, tv_mode
);
949 static int radeon_tv_mode_valid(struct drm_connector
*connector
,
950 struct drm_display_mode
*mode
)
952 if ((mode
->hdisplay
> 1024) || (mode
->vdisplay
> 768))
953 return MODE_CLOCK_RANGE
;
957 static enum drm_connector_status
958 radeon_tv_detect(struct drm_connector
*connector
, bool force
)
960 struct drm_encoder
*encoder
;
961 struct drm_encoder_helper_funcs
*encoder_funcs
;
962 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
963 enum drm_connector_status ret
= connector_status_disconnected
;
966 if (!radeon_connector
->dac_load_detect
)
969 r
= pm_runtime_get_sync(connector
->dev
->dev
);
971 return connector_status_disconnected
;
973 encoder
= radeon_best_single_encoder(connector
);
975 ret
= connector_status_disconnected
;
977 encoder_funcs
= encoder
->helper_private
;
978 ret
= encoder_funcs
->detect(encoder
, connector
);
980 if (ret
== connector_status_connected
)
981 ret
= radeon_connector_analog_encoder_conflict_solve(connector
, encoder
, ret
, false);
982 radeon_connector_update_scratch_regs(connector
, ret
);
983 pm_runtime_mark_last_busy(connector
->dev
->dev
);
984 pm_runtime_put_autosuspend(connector
->dev
->dev
);
988 static const struct drm_connector_helper_funcs radeon_tv_connector_helper_funcs
= {
989 .get_modes
= radeon_tv_get_modes
,
990 .mode_valid
= radeon_tv_mode_valid
,
991 .best_encoder
= radeon_best_single_encoder
,
994 static const struct drm_connector_funcs radeon_tv_connector_funcs
= {
995 .dpms
= drm_helper_connector_dpms
,
996 .detect
= radeon_tv_detect
,
997 .fill_modes
= drm_helper_probe_single_connector_modes
,
998 .destroy
= radeon_connector_destroy
,
999 .set_property
= radeon_connector_set_property
,
1002 static int radeon_dvi_get_modes(struct drm_connector
*connector
)
1004 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1007 ret
= radeon_ddc_get_modes(radeon_connector
);
1011 static bool radeon_check_hpd_status_unchanged(struct drm_connector
*connector
)
1013 struct drm_device
*dev
= connector
->dev
;
1014 struct radeon_device
*rdev
= dev
->dev_private
;
1015 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1016 enum drm_connector_status status
;
1018 /* We only trust HPD on R600 and newer ASICS. */
1019 if (rdev
->family
>= CHIP_R600
1020 && radeon_connector
->hpd
.hpd
!= RADEON_HPD_NONE
) {
1021 if (radeon_hpd_sense(rdev
, radeon_connector
->hpd
.hpd
))
1022 status
= connector_status_connected
;
1024 status
= connector_status_disconnected
;
1025 if (connector
->status
== status
)
1033 * DVI is complicated
1034 * Do a DDC probe, if DDC probe passes, get the full EDID so
1035 * we can do analog/digital monitor detection at this point.
1036 * If the monitor is an analog monitor or we got no DDC,
1037 * we need to find the DAC encoder object for this connector.
1038 * If we got no DDC, we do load detection on the DAC encoder object.
1039 * If we got analog DDC or load detection passes on the DAC encoder
1040 * we have to check if this analog encoder is shared with anyone else (TV)
1041 * if its shared we have to set the other connector to disconnected.
1043 static enum drm_connector_status
1044 radeon_dvi_detect(struct drm_connector
*connector
, bool force
)
1046 struct drm_device
*dev
= connector
->dev
;
1047 struct radeon_device
*rdev
= dev
->dev_private
;
1048 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1049 struct drm_encoder
*encoder
= NULL
;
1050 struct drm_encoder_helper_funcs
*encoder_funcs
;
1051 struct drm_mode_object
*obj
;
1053 enum drm_connector_status ret
= connector_status_disconnected
;
1054 bool dret
= false, broken_edid
= false;
1056 r
= pm_runtime_get_sync(connector
->dev
->dev
);
1058 return connector_status_disconnected
;
1060 if (!force
&& radeon_check_hpd_status_unchanged(connector
)) {
1061 ret
= connector
->status
;
1065 if (radeon_connector
->ddc_bus
)
1066 dret
= radeon_ddc_probe(radeon_connector
, false);
1068 radeon_connector
->detected_by_load
= false;
1069 if (radeon_connector
->edid
) {
1070 kfree(radeon_connector
->edid
);
1071 radeon_connector
->edid
= NULL
;
1073 radeon_connector
->edid
= drm_get_edid(&radeon_connector
->base
, &radeon_connector
->ddc_bus
->adapter
);
1075 if (!radeon_connector
->edid
) {
1076 DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
1078 /* rs690 seems to have a problem with connectors not existing and always
1079 * return a block of 0's. If we see this just stop polling on this output */
1080 if ((rdev
->family
== CHIP_RS690
|| rdev
->family
== CHIP_RS740
) && radeon_connector
->base
.null_edid_counter
) {
1081 ret
= connector_status_disconnected
;
1082 DRM_ERROR("%s: detected RS690 floating bus bug, stopping ddc detect\n",
1084 radeon_connector
->ddc_bus
= NULL
;
1086 ret
= connector_status_connected
;
1087 broken_edid
= true; /* defer use_digital to later */
1090 radeon_connector
->use_digital
= !!(radeon_connector
->edid
->input
& DRM_EDID_INPUT_DIGITAL
);
1092 /* some oems have boards with separate digital and analog connectors
1093 * with a shared ddc line (often vga + hdmi)
1095 if ((!radeon_connector
->use_digital
) && radeon_connector
->shared_ddc
) {
1096 kfree(radeon_connector
->edid
);
1097 radeon_connector
->edid
= NULL
;
1098 ret
= connector_status_disconnected
;
1100 ret
= connector_status_connected
;
1102 /* This gets complicated. We have boards with VGA + HDMI with a
1103 * shared DDC line and we have boards with DVI-D + HDMI with a shared
1104 * DDC line. The latter is more complex because with DVI<->HDMI adapters
1105 * you don't really know what's connected to which port as both are digital.
1107 if (radeon_connector
->shared_ddc
&& (ret
== connector_status_connected
)) {
1108 struct drm_connector
*list_connector
;
1109 struct radeon_connector
*list_radeon_connector
;
1110 list_for_each_entry(list_connector
, &dev
->mode_config
.connector_list
, head
) {
1111 if (connector
== list_connector
)
1113 list_radeon_connector
= to_radeon_connector(list_connector
);
1114 if (list_radeon_connector
->shared_ddc
&&
1115 (list_radeon_connector
->ddc_bus
->rec
.i2c_id
==
1116 radeon_connector
->ddc_bus
->rec
.i2c_id
)) {
1117 /* cases where both connectors are digital */
1118 if (list_connector
->connector_type
!= DRM_MODE_CONNECTOR_VGA
) {
1119 /* hpd is our only option in this case */
1120 if (!radeon_hpd_sense(rdev
, radeon_connector
->hpd
.hpd
)) {
1121 kfree(radeon_connector
->edid
);
1122 radeon_connector
->edid
= NULL
;
1123 ret
= connector_status_disconnected
;
1132 if ((ret
== connector_status_connected
) && (radeon_connector
->use_digital
== true))
1135 /* DVI-D and HDMI-A are digital only */
1136 if ((connector
->connector_type
== DRM_MODE_CONNECTOR_DVID
) ||
1137 (connector
->connector_type
== DRM_MODE_CONNECTOR_HDMIA
))
1140 /* if we aren't forcing don't do destructive polling */
1142 /* only return the previous status if we last
1143 * detected a monitor via load.
1145 if (radeon_connector
->detected_by_load
)
1146 ret
= connector
->status
;
1150 /* find analog encoder */
1151 if (radeon_connector
->dac_load_detect
) {
1152 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
1153 if (connector
->encoder_ids
[i
] == 0)
1156 obj
= drm_mode_object_find(connector
->dev
,
1157 connector
->encoder_ids
[i
],
1158 DRM_MODE_OBJECT_ENCODER
);
1162 encoder
= obj_to_encoder(obj
);
1164 if (encoder
->encoder_type
!= DRM_MODE_ENCODER_DAC
&&
1165 encoder
->encoder_type
!= DRM_MODE_ENCODER_TVDAC
)
1168 encoder_funcs
= encoder
->helper_private
;
1169 if (encoder_funcs
->detect
) {
1171 if (ret
!= connector_status_connected
) {
1172 /* deal with analog monitors without DDC */
1173 ret
= encoder_funcs
->detect(encoder
, connector
);
1174 if (ret
== connector_status_connected
) {
1175 radeon_connector
->use_digital
= false;
1177 if (ret
!= connector_status_disconnected
)
1178 radeon_connector
->detected_by_load
= true;
1181 enum drm_connector_status lret
;
1182 /* assume digital unless load detected otherwise */
1183 radeon_connector
->use_digital
= true;
1184 lret
= encoder_funcs
->detect(encoder
, connector
);
1185 DRM_DEBUG_KMS("load_detect %x returned: %x\n",encoder
->encoder_type
,lret
);
1186 if (lret
== connector_status_connected
)
1187 radeon_connector
->use_digital
= false;
1194 if ((ret
== connector_status_connected
) && (radeon_connector
->use_digital
== false) &&
1196 ret
= radeon_connector_analog_encoder_conflict_solve(connector
, encoder
, ret
, true);
1199 /* RN50 and some RV100 asics in servers often have a hardcoded EDID in the
1200 * vbios to deal with KVMs. If we have one and are not able to detect a monitor
1201 * by other means, assume the DFP is connected and use that EDID. In most
1202 * cases the DVI port is actually a virtual KVM port connected to the service
1206 if ((!rdev
->is_atom_bios
) &&
1207 (ret
== connector_status_disconnected
) &&
1208 rdev
->mode_info
.bios_hardcoded_edid_size
) {
1209 radeon_connector
->use_digital
= true;
1210 ret
= connector_status_connected
;
1213 /* updated in get modes as well since we need to know if it's analog or digital */
1214 radeon_connector_update_scratch_regs(connector
, ret
);
1217 pm_runtime_mark_last_busy(connector
->dev
->dev
);
1218 pm_runtime_put_autosuspend(connector
->dev
->dev
);
1223 /* okay need to be smart in here about which encoder to pick */
1224 static struct drm_encoder
*radeon_dvi_encoder(struct drm_connector
*connector
)
1226 int enc_id
= connector
->encoder_ids
[0];
1227 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1228 struct drm_mode_object
*obj
;
1229 struct drm_encoder
*encoder
;
1231 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
1232 if (connector
->encoder_ids
[i
] == 0)
1235 obj
= drm_mode_object_find(connector
->dev
, connector
->encoder_ids
[i
], DRM_MODE_OBJECT_ENCODER
);
1239 encoder
= obj_to_encoder(obj
);
1241 if (radeon_connector
->use_digital
== true) {
1242 if (encoder
->encoder_type
== DRM_MODE_ENCODER_TMDS
)
1245 if (encoder
->encoder_type
== DRM_MODE_ENCODER_DAC
||
1246 encoder
->encoder_type
== DRM_MODE_ENCODER_TVDAC
)
1251 /* see if we have a default encoder TODO */
1253 /* then check use digitial */
1254 /* pick the first one */
1256 obj
= drm_mode_object_find(connector
->dev
, enc_id
, DRM_MODE_OBJECT_ENCODER
);
1259 encoder
= obj_to_encoder(obj
);
1265 static void radeon_dvi_force(struct drm_connector
*connector
)
1267 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1268 if (connector
->force
== DRM_FORCE_ON
)
1269 radeon_connector
->use_digital
= false;
1270 if (connector
->force
== DRM_FORCE_ON_DIGITAL
)
1271 radeon_connector
->use_digital
= true;
1274 static int radeon_dvi_mode_valid(struct drm_connector
*connector
,
1275 struct drm_display_mode
*mode
)
1277 struct drm_device
*dev
= connector
->dev
;
1278 struct radeon_device
*rdev
= dev
->dev_private
;
1279 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1281 /* XXX check mode bandwidth */
1283 /* clocks over 135 MHz have heat issues with DVI on RV100 */
1284 if (radeon_connector
->use_digital
&&
1285 (rdev
->family
== CHIP_RV100
) &&
1286 (mode
->clock
> 135000))
1287 return MODE_CLOCK_HIGH
;
1289 if (radeon_connector
->use_digital
&& (mode
->clock
> 165000)) {
1290 if ((radeon_connector
->connector_object_id
== CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_I
) ||
1291 (radeon_connector
->connector_object_id
== CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_D
) ||
1292 (radeon_connector
->connector_object_id
== CONNECTOR_OBJECT_ID_HDMI_TYPE_B
))
1294 else if (ASIC_IS_DCE6(rdev
) && drm_detect_hdmi_monitor(radeon_connector
->edid
)) {
1295 /* HDMI 1.3+ supports max clock of 340 Mhz */
1296 if (mode
->clock
> 340000)
1297 return MODE_CLOCK_HIGH
;
1301 return MODE_CLOCK_HIGH
;
1305 /* check against the max pixel clock */
1306 if ((mode
->clock
/ 10) > rdev
->clock
.max_pixel_clock
)
1307 return MODE_CLOCK_HIGH
;
1312 static const struct drm_connector_helper_funcs radeon_dvi_connector_helper_funcs
= {
1313 .get_modes
= radeon_dvi_get_modes
,
1314 .mode_valid
= radeon_dvi_mode_valid
,
1315 .best_encoder
= radeon_dvi_encoder
,
1318 static const struct drm_connector_funcs radeon_dvi_connector_funcs
= {
1319 .dpms
= drm_helper_connector_dpms
,
1320 .detect
= radeon_dvi_detect
,
1321 .fill_modes
= drm_helper_probe_single_connector_modes
,
1322 .set_property
= radeon_connector_set_property
,
1323 .destroy
= radeon_connector_destroy
,
1324 .force
= radeon_dvi_force
,
1327 static int radeon_dp_get_modes(struct drm_connector
*connector
)
1329 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1330 struct radeon_connector_atom_dig
*radeon_dig_connector
= radeon_connector
->con_priv
;
1331 struct drm_encoder
*encoder
= radeon_best_single_encoder(connector
);
1334 if ((connector
->connector_type
== DRM_MODE_CONNECTOR_eDP
) ||
1335 (connector
->connector_type
== DRM_MODE_CONNECTOR_LVDS
)) {
1336 struct drm_display_mode
*mode
;
1338 if (connector
->connector_type
== DRM_MODE_CONNECTOR_eDP
) {
1339 if (!radeon_dig_connector
->edp_on
)
1340 atombios_set_edp_panel_power(connector
,
1341 ATOM_TRANSMITTER_ACTION_POWER_ON
);
1342 ret
= radeon_ddc_get_modes(radeon_connector
);
1343 if (!radeon_dig_connector
->edp_on
)
1344 atombios_set_edp_panel_power(connector
,
1345 ATOM_TRANSMITTER_ACTION_POWER_OFF
);
1347 /* need to setup ddc on the bridge */
1348 if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector
) !=
1349 ENCODER_OBJECT_ID_NONE
) {
1351 radeon_atom_ext_encoder_setup_ddc(encoder
);
1353 ret
= radeon_ddc_get_modes(radeon_connector
);
1358 radeon_fixup_lvds_native_mode(encoder
, connector
);
1359 /* add scaled modes */
1360 radeon_add_common_modes(encoder
, connector
);
1368 /* we have no EDID modes */
1369 mode
= radeon_fp_native_mode(encoder
);
1372 drm_mode_probed_add(connector
, mode
);
1373 /* add the width/height from vbios tables if available */
1374 connector
->display_info
.width_mm
= mode
->width_mm
;
1375 connector
->display_info
.height_mm
= mode
->height_mm
;
1376 /* add scaled modes */
1377 radeon_add_common_modes(encoder
, connector
);
1380 /* need to setup ddc on the bridge */
1381 if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector
) !=
1382 ENCODER_OBJECT_ID_NONE
) {
1384 radeon_atom_ext_encoder_setup_ddc(encoder
);
1386 ret
= radeon_ddc_get_modes(radeon_connector
);
1392 u16
radeon_connector_encoder_get_dp_bridge_encoder_id(struct drm_connector
*connector
)
1394 struct drm_mode_object
*obj
;
1395 struct drm_encoder
*encoder
;
1396 struct radeon_encoder
*radeon_encoder
;
1399 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
1400 if (connector
->encoder_ids
[i
] == 0)
1403 obj
= drm_mode_object_find(connector
->dev
, connector
->encoder_ids
[i
], DRM_MODE_OBJECT_ENCODER
);
1407 encoder
= obj_to_encoder(obj
);
1408 radeon_encoder
= to_radeon_encoder(encoder
);
1410 switch (radeon_encoder
->encoder_id
) {
1411 case ENCODER_OBJECT_ID_TRAVIS
:
1412 case ENCODER_OBJECT_ID_NUTMEG
:
1413 return radeon_encoder
->encoder_id
;
1419 return ENCODER_OBJECT_ID_NONE
;
1422 bool radeon_connector_encoder_is_hbr2(struct drm_connector
*connector
)
1424 struct drm_mode_object
*obj
;
1425 struct drm_encoder
*encoder
;
1426 struct radeon_encoder
*radeon_encoder
;
1430 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
1431 if (connector
->encoder_ids
[i
] == 0)
1434 obj
= drm_mode_object_find(connector
->dev
, connector
->encoder_ids
[i
], DRM_MODE_OBJECT_ENCODER
);
1438 encoder
= obj_to_encoder(obj
);
1439 radeon_encoder
= to_radeon_encoder(encoder
);
1440 if (radeon_encoder
->caps
& ATOM_ENCODER_CAP_RECORD_HBR2
)
1447 bool radeon_connector_is_dp12_capable(struct drm_connector
*connector
)
1449 struct drm_device
*dev
= connector
->dev
;
1450 struct radeon_device
*rdev
= dev
->dev_private
;
1452 if (ASIC_IS_DCE5(rdev
) &&
1453 (rdev
->clock
.default_dispclk
>= 53900) &&
1454 radeon_connector_encoder_is_hbr2(connector
)) {
1461 static enum drm_connector_status
1462 radeon_dp_detect(struct drm_connector
*connector
, bool force
)
1464 struct drm_device
*dev
= connector
->dev
;
1465 struct radeon_device
*rdev
= dev
->dev_private
;
1466 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1467 enum drm_connector_status ret
= connector_status_disconnected
;
1468 struct radeon_connector_atom_dig
*radeon_dig_connector
= radeon_connector
->con_priv
;
1469 struct drm_encoder
*encoder
= radeon_best_single_encoder(connector
);
1472 r
= pm_runtime_get_sync(connector
->dev
->dev
);
1474 return connector_status_disconnected
;
1476 if (!force
&& radeon_check_hpd_status_unchanged(connector
)) {
1477 ret
= connector
->status
;
1481 if (radeon_connector
->edid
) {
1482 kfree(radeon_connector
->edid
);
1483 radeon_connector
->edid
= NULL
;
1486 if ((connector
->connector_type
== DRM_MODE_CONNECTOR_eDP
) ||
1487 (connector
->connector_type
== DRM_MODE_CONNECTOR_LVDS
)) {
1489 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
1490 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
1492 /* check if panel is valid */
1493 if (native_mode
->hdisplay
>= 320 && native_mode
->vdisplay
>= 240)
1494 ret
= connector_status_connected
;
1496 /* eDP is always DP */
1497 radeon_dig_connector
->dp_sink_type
= CONNECTOR_OBJECT_ID_DISPLAYPORT
;
1498 if (!radeon_dig_connector
->edp_on
)
1499 atombios_set_edp_panel_power(connector
,
1500 ATOM_TRANSMITTER_ACTION_POWER_ON
);
1501 if (radeon_dp_getdpcd(radeon_connector
))
1502 ret
= connector_status_connected
;
1503 if (!radeon_dig_connector
->edp_on
)
1504 atombios_set_edp_panel_power(connector
,
1505 ATOM_TRANSMITTER_ACTION_POWER_OFF
);
1506 } else if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector
) !=
1507 ENCODER_OBJECT_ID_NONE
) {
1508 /* DP bridges are always DP */
1509 radeon_dig_connector
->dp_sink_type
= CONNECTOR_OBJECT_ID_DISPLAYPORT
;
1510 /* get the DPCD from the bridge */
1511 radeon_dp_getdpcd(radeon_connector
);
1514 /* setup ddc on the bridge */
1515 radeon_atom_ext_encoder_setup_ddc(encoder
);
1516 /* bridge chips are always aux */
1517 if (radeon_ddc_probe(radeon_connector
, true)) /* try DDC */
1518 ret
= connector_status_connected
;
1519 else if (radeon_connector
->dac_load_detect
) { /* try load detection */
1520 struct drm_encoder_helper_funcs
*encoder_funcs
= encoder
->helper_private
;
1521 ret
= encoder_funcs
->detect(encoder
, connector
);
1525 radeon_dig_connector
->dp_sink_type
= radeon_dp_getsinktype(radeon_connector
);
1526 if (radeon_hpd_sense(rdev
, radeon_connector
->hpd
.hpd
)) {
1527 ret
= connector_status_connected
;
1528 if (radeon_dig_connector
->dp_sink_type
== CONNECTOR_OBJECT_ID_DISPLAYPORT
)
1529 radeon_dp_getdpcd(radeon_connector
);
1531 if (radeon_dig_connector
->dp_sink_type
== CONNECTOR_OBJECT_ID_DISPLAYPORT
) {
1532 if (radeon_dp_getdpcd(radeon_connector
))
1533 ret
= connector_status_connected
;
1535 /* try non-aux ddc (DP to DVI/HDMI/etc. adapter) */
1536 if (radeon_ddc_probe(radeon_connector
, false))
1537 ret
= connector_status_connected
;
1542 radeon_connector_update_scratch_regs(connector
, ret
);
1544 pm_runtime_mark_last_busy(connector
->dev
->dev
);
1545 pm_runtime_put_autosuspend(connector
->dev
->dev
);
1550 static int radeon_dp_mode_valid(struct drm_connector
*connector
,
1551 struct drm_display_mode
*mode
)
1553 struct drm_device
*dev
= connector
->dev
;
1554 struct radeon_device
*rdev
= dev
->dev_private
;
1555 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1556 struct radeon_connector_atom_dig
*radeon_dig_connector
= radeon_connector
->con_priv
;
1558 /* XXX check mode bandwidth */
1560 if ((connector
->connector_type
== DRM_MODE_CONNECTOR_eDP
) ||
1561 (connector
->connector_type
== DRM_MODE_CONNECTOR_LVDS
)) {
1562 struct drm_encoder
*encoder
= radeon_best_single_encoder(connector
);
1564 if ((mode
->hdisplay
< 320) || (mode
->vdisplay
< 240))
1568 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
1569 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
1571 /* AVIVO hardware supports downscaling modes larger than the panel
1572 * to the panel size, but I'm not sure this is desirable.
1574 if ((mode
->hdisplay
> native_mode
->hdisplay
) ||
1575 (mode
->vdisplay
> native_mode
->vdisplay
))
1578 /* if scaling is disabled, block non-native modes */
1579 if (radeon_encoder
->rmx_type
== RMX_OFF
) {
1580 if ((mode
->hdisplay
!= native_mode
->hdisplay
) ||
1581 (mode
->vdisplay
!= native_mode
->vdisplay
))
1586 if ((radeon_dig_connector
->dp_sink_type
== CONNECTOR_OBJECT_ID_DISPLAYPORT
) ||
1587 (radeon_dig_connector
->dp_sink_type
== CONNECTOR_OBJECT_ID_eDP
)) {
1588 return radeon_dp_mode_valid_helper(connector
, mode
);
1590 if (ASIC_IS_DCE6(rdev
) && drm_detect_hdmi_monitor(radeon_connector
->edid
)) {
1591 /* HDMI 1.3+ supports max clock of 340 Mhz */
1592 if (mode
->clock
> 340000)
1593 return MODE_CLOCK_HIGH
;
1595 if (mode
->clock
> 165000)
1596 return MODE_CLOCK_HIGH
;
1604 static const struct drm_connector_helper_funcs radeon_dp_connector_helper_funcs
= {
1605 .get_modes
= radeon_dp_get_modes
,
1606 .mode_valid
= radeon_dp_mode_valid
,
1607 .best_encoder
= radeon_dvi_encoder
,
1610 static const struct drm_connector_funcs radeon_dp_connector_funcs
= {
1611 .dpms
= drm_helper_connector_dpms
,
1612 .detect
= radeon_dp_detect
,
1613 .fill_modes
= drm_helper_probe_single_connector_modes
,
1614 .set_property
= radeon_connector_set_property
,
1615 .destroy
= radeon_connector_destroy
,
1616 .force
= radeon_dvi_force
,
1619 static const struct drm_connector_funcs radeon_edp_connector_funcs
= {
1620 .dpms
= drm_helper_connector_dpms
,
1621 .detect
= radeon_dp_detect
,
1622 .fill_modes
= drm_helper_probe_single_connector_modes
,
1623 .set_property
= radeon_lvds_set_property
,
1624 .destroy
= radeon_connector_destroy
,
1625 .force
= radeon_dvi_force
,
1628 static const struct drm_connector_funcs radeon_lvds_bridge_connector_funcs
= {
1629 .dpms
= drm_helper_connector_dpms
,
1630 .detect
= radeon_dp_detect
,
1631 .fill_modes
= drm_helper_probe_single_connector_modes
,
1632 .set_property
= radeon_lvds_set_property
,
1633 .destroy
= radeon_connector_destroy
,
1634 .force
= radeon_dvi_force
,
1638 radeon_add_atom_connector(struct drm_device
*dev
,
1639 uint32_t connector_id
,
1640 uint32_t supported_device
,
1642 struct radeon_i2c_bus_rec
*i2c_bus
,
1643 uint32_t igp_lane_info
,
1644 uint16_t connector_object_id
,
1645 struct radeon_hpd
*hpd
,
1646 struct radeon_router
*router
)
1648 struct radeon_device
*rdev
= dev
->dev_private
;
1649 struct drm_connector
*connector
;
1650 struct radeon_connector
*radeon_connector
;
1651 struct radeon_connector_atom_dig
*radeon_dig_connector
;
1652 struct drm_encoder
*encoder
;
1653 struct radeon_encoder
*radeon_encoder
;
1654 uint32_t subpixel_order
= SubPixelNone
;
1655 bool shared_ddc
= false;
1656 bool is_dp_bridge
= false;
1657 bool has_aux
= false;
1659 if (connector_type
== DRM_MODE_CONNECTOR_Unknown
)
1662 /* if the user selected tv=0 don't try and add the connector */
1663 if (((connector_type
== DRM_MODE_CONNECTOR_SVIDEO
) ||
1664 (connector_type
== DRM_MODE_CONNECTOR_Composite
) ||
1665 (connector_type
== DRM_MODE_CONNECTOR_9PinDIN
)) &&
1669 /* see if we already added it */
1670 list_for_each_entry(connector
, &dev
->mode_config
.connector_list
, head
) {
1671 radeon_connector
= to_radeon_connector(connector
);
1672 if (radeon_connector
->connector_id
== connector_id
) {
1673 radeon_connector
->devices
|= supported_device
;
1676 if (radeon_connector
->ddc_bus
&& i2c_bus
->valid
) {
1677 if (radeon_connector
->ddc_bus
->rec
.i2c_id
== i2c_bus
->i2c_id
) {
1678 radeon_connector
->shared_ddc
= true;
1681 if (radeon_connector
->router_bus
&& router
->ddc_valid
&&
1682 (radeon_connector
->router
.router_id
== router
->router_id
)) {
1683 radeon_connector
->shared_ddc
= false;
1689 /* check if it's a dp bridge */
1690 list_for_each_entry(encoder
, &dev
->mode_config
.encoder_list
, head
) {
1691 radeon_encoder
= to_radeon_encoder(encoder
);
1692 if (radeon_encoder
->devices
& supported_device
) {
1693 switch (radeon_encoder
->encoder_id
) {
1694 case ENCODER_OBJECT_ID_TRAVIS
:
1695 case ENCODER_OBJECT_ID_NUTMEG
:
1696 is_dp_bridge
= true;
1704 radeon_connector
= kzalloc(sizeof(struct radeon_connector
), GFP_KERNEL
);
1705 if (!radeon_connector
)
1708 connector
= &radeon_connector
->base
;
1710 radeon_connector
->connector_id
= connector_id
;
1711 radeon_connector
->devices
= supported_device
;
1712 radeon_connector
->shared_ddc
= shared_ddc
;
1713 radeon_connector
->connector_object_id
= connector_object_id
;
1714 radeon_connector
->hpd
= *hpd
;
1716 radeon_connector
->router
= *router
;
1717 if (router
->ddc_valid
|| router
->cd_valid
) {
1718 radeon_connector
->router_bus
= radeon_i2c_lookup(rdev
, &router
->i2c_info
);
1719 if (!radeon_connector
->router_bus
)
1720 DRM_ERROR("Failed to assign router i2c bus! Check dmesg for i2c errors.\n");
1724 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
1725 if (!radeon_dig_connector
)
1727 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
1728 radeon_connector
->con_priv
= radeon_dig_connector
;
1729 if (i2c_bus
->valid
) {
1730 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1731 if (radeon_connector
->ddc_bus
)
1734 DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1736 switch (connector_type
) {
1737 case DRM_MODE_CONNECTOR_VGA
:
1738 case DRM_MODE_CONNECTOR_DVIA
:
1740 drm_connector_init(dev
, &radeon_connector
->base
,
1741 &radeon_dp_connector_funcs
, connector_type
);
1742 drm_connector_helper_add(&radeon_connector
->base
,
1743 &radeon_dp_connector_helper_funcs
);
1744 connector
->interlace_allowed
= true;
1745 connector
->doublescan_allowed
= true;
1746 radeon_connector
->dac_load_detect
= true;
1747 drm_object_attach_property(&radeon_connector
->base
.base
,
1748 rdev
->mode_info
.load_detect_property
,
1751 case DRM_MODE_CONNECTOR_DVII
:
1752 case DRM_MODE_CONNECTOR_DVID
:
1753 case DRM_MODE_CONNECTOR_HDMIA
:
1754 case DRM_MODE_CONNECTOR_HDMIB
:
1755 case DRM_MODE_CONNECTOR_DisplayPort
:
1756 drm_connector_init(dev
, &radeon_connector
->base
,
1757 &radeon_dp_connector_funcs
, connector_type
);
1758 drm_connector_helper_add(&radeon_connector
->base
,
1759 &radeon_dp_connector_helper_funcs
);
1760 drm_object_attach_property(&radeon_connector
->base
.base
,
1761 rdev
->mode_info
.underscan_property
,
1763 drm_object_attach_property(&radeon_connector
->base
.base
,
1764 rdev
->mode_info
.underscan_hborder_property
,
1766 drm_object_attach_property(&radeon_connector
->base
.base
,
1767 rdev
->mode_info
.underscan_vborder_property
,
1770 drm_object_attach_property(&radeon_connector
->base
.base
,
1771 rdev
->mode_info
.dither_property
,
1772 RADEON_FMT_DITHER_DISABLE
);
1774 if (radeon_audio
!= 0)
1775 drm_object_attach_property(&radeon_connector
->base
.base
,
1776 rdev
->mode_info
.audio_property
,
1779 subpixel_order
= SubPixelHorizontalRGB
;
1780 connector
->interlace_allowed
= true;
1781 if (connector_type
== DRM_MODE_CONNECTOR_HDMIB
)
1782 connector
->doublescan_allowed
= true;
1784 connector
->doublescan_allowed
= false;
1785 if (connector_type
== DRM_MODE_CONNECTOR_DVII
) {
1786 radeon_connector
->dac_load_detect
= true;
1787 drm_object_attach_property(&radeon_connector
->base
.base
,
1788 rdev
->mode_info
.load_detect_property
,
1792 case DRM_MODE_CONNECTOR_LVDS
:
1793 case DRM_MODE_CONNECTOR_eDP
:
1794 drm_connector_init(dev
, &radeon_connector
->base
,
1795 &radeon_lvds_bridge_connector_funcs
, connector_type
);
1796 drm_connector_helper_add(&radeon_connector
->base
,
1797 &radeon_dp_connector_helper_funcs
);
1798 drm_object_attach_property(&radeon_connector
->base
.base
,
1799 dev
->mode_config
.scaling_mode_property
,
1800 DRM_MODE_SCALE_FULLSCREEN
);
1801 subpixel_order
= SubPixelHorizontalRGB
;
1802 connector
->interlace_allowed
= false;
1803 connector
->doublescan_allowed
= false;
1807 switch (connector_type
) {
1808 case DRM_MODE_CONNECTOR_VGA
:
1809 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_vga_connector_funcs
, connector_type
);
1810 drm_connector_helper_add(&radeon_connector
->base
, &radeon_vga_connector_helper_funcs
);
1811 if (i2c_bus
->valid
) {
1812 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1813 if (!radeon_connector
->ddc_bus
)
1814 DRM_ERROR("VGA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1816 radeon_connector
->dac_load_detect
= true;
1817 drm_object_attach_property(&radeon_connector
->base
.base
,
1818 rdev
->mode_info
.load_detect_property
,
1820 /* no HPD on analog connectors */
1821 radeon_connector
->hpd
.hpd
= RADEON_HPD_NONE
;
1822 connector
->polled
= DRM_CONNECTOR_POLL_CONNECT
;
1823 connector
->interlace_allowed
= true;
1824 connector
->doublescan_allowed
= true;
1826 case DRM_MODE_CONNECTOR_DVIA
:
1827 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_vga_connector_funcs
, connector_type
);
1828 drm_connector_helper_add(&radeon_connector
->base
, &radeon_vga_connector_helper_funcs
);
1829 if (i2c_bus
->valid
) {
1830 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1831 if (!radeon_connector
->ddc_bus
)
1832 DRM_ERROR("DVIA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1834 radeon_connector
->dac_load_detect
= true;
1835 drm_object_attach_property(&radeon_connector
->base
.base
,
1836 rdev
->mode_info
.load_detect_property
,
1838 /* no HPD on analog connectors */
1839 radeon_connector
->hpd
.hpd
= RADEON_HPD_NONE
;
1840 connector
->interlace_allowed
= true;
1841 connector
->doublescan_allowed
= true;
1843 case DRM_MODE_CONNECTOR_DVII
:
1844 case DRM_MODE_CONNECTOR_DVID
:
1845 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
1846 if (!radeon_dig_connector
)
1848 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
1849 radeon_connector
->con_priv
= radeon_dig_connector
;
1850 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_dvi_connector_funcs
, connector_type
);
1851 drm_connector_helper_add(&radeon_connector
->base
, &radeon_dvi_connector_helper_funcs
);
1852 if (i2c_bus
->valid
) {
1853 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1854 if (!radeon_connector
->ddc_bus
)
1855 DRM_ERROR("DVI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1857 subpixel_order
= SubPixelHorizontalRGB
;
1858 drm_object_attach_property(&radeon_connector
->base
.base
,
1859 rdev
->mode_info
.coherent_mode_property
,
1861 if (ASIC_IS_AVIVO(rdev
)) {
1862 drm_object_attach_property(&radeon_connector
->base
.base
,
1863 rdev
->mode_info
.underscan_property
,
1865 drm_object_attach_property(&radeon_connector
->base
.base
,
1866 rdev
->mode_info
.underscan_hborder_property
,
1868 drm_object_attach_property(&radeon_connector
->base
.base
,
1869 rdev
->mode_info
.underscan_vborder_property
,
1872 if (ASIC_IS_DCE2(rdev
) && (radeon_audio
!= 0)) {
1873 drm_object_attach_property(&radeon_connector
->base
.base
,
1874 rdev
->mode_info
.audio_property
,
1877 if (ASIC_IS_AVIVO(rdev
)) {
1878 drm_object_attach_property(&radeon_connector
->base
.base
,
1879 rdev
->mode_info
.dither_property
,
1880 RADEON_FMT_DITHER_DISABLE
);
1882 if (connector_type
== DRM_MODE_CONNECTOR_DVII
) {
1883 radeon_connector
->dac_load_detect
= true;
1884 drm_object_attach_property(&radeon_connector
->base
.base
,
1885 rdev
->mode_info
.load_detect_property
,
1888 connector
->interlace_allowed
= true;
1889 if (connector_type
== DRM_MODE_CONNECTOR_DVII
)
1890 connector
->doublescan_allowed
= true;
1892 connector
->doublescan_allowed
= false;
1894 case DRM_MODE_CONNECTOR_HDMIA
:
1895 case DRM_MODE_CONNECTOR_HDMIB
:
1896 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
1897 if (!radeon_dig_connector
)
1899 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
1900 radeon_connector
->con_priv
= radeon_dig_connector
;
1901 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_dvi_connector_funcs
, connector_type
);
1902 drm_connector_helper_add(&radeon_connector
->base
, &radeon_dvi_connector_helper_funcs
);
1903 if (i2c_bus
->valid
) {
1904 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1905 if (!radeon_connector
->ddc_bus
)
1906 DRM_ERROR("HDMI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1908 drm_object_attach_property(&radeon_connector
->base
.base
,
1909 rdev
->mode_info
.coherent_mode_property
,
1911 if (ASIC_IS_AVIVO(rdev
)) {
1912 drm_object_attach_property(&radeon_connector
->base
.base
,
1913 rdev
->mode_info
.underscan_property
,
1915 drm_object_attach_property(&radeon_connector
->base
.base
,
1916 rdev
->mode_info
.underscan_hborder_property
,
1918 drm_object_attach_property(&radeon_connector
->base
.base
,
1919 rdev
->mode_info
.underscan_vborder_property
,
1922 if (ASIC_IS_DCE2(rdev
) && (radeon_audio
!= 0)) {
1923 drm_object_attach_property(&radeon_connector
->base
.base
,
1924 rdev
->mode_info
.audio_property
,
1927 if (ASIC_IS_AVIVO(rdev
)) {
1928 drm_object_attach_property(&radeon_connector
->base
.base
,
1929 rdev
->mode_info
.dither_property
,
1930 RADEON_FMT_DITHER_DISABLE
);
1932 subpixel_order
= SubPixelHorizontalRGB
;
1933 connector
->interlace_allowed
= true;
1934 if (connector_type
== DRM_MODE_CONNECTOR_HDMIB
)
1935 connector
->doublescan_allowed
= true;
1937 connector
->doublescan_allowed
= false;
1939 case DRM_MODE_CONNECTOR_DisplayPort
:
1940 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
1941 if (!radeon_dig_connector
)
1943 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
1944 radeon_connector
->con_priv
= radeon_dig_connector
;
1945 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_dp_connector_funcs
, connector_type
);
1946 drm_connector_helper_add(&radeon_connector
->base
, &radeon_dp_connector_helper_funcs
);
1947 if (i2c_bus
->valid
) {
1948 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1949 if (radeon_connector
->ddc_bus
)
1952 DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1954 subpixel_order
= SubPixelHorizontalRGB
;
1955 drm_object_attach_property(&radeon_connector
->base
.base
,
1956 rdev
->mode_info
.coherent_mode_property
,
1958 if (ASIC_IS_AVIVO(rdev
)) {
1959 drm_object_attach_property(&radeon_connector
->base
.base
,
1960 rdev
->mode_info
.underscan_property
,
1962 drm_object_attach_property(&radeon_connector
->base
.base
,
1963 rdev
->mode_info
.underscan_hborder_property
,
1965 drm_object_attach_property(&radeon_connector
->base
.base
,
1966 rdev
->mode_info
.underscan_vborder_property
,
1969 if (ASIC_IS_DCE2(rdev
) && (radeon_audio
!= 0)) {
1970 drm_object_attach_property(&radeon_connector
->base
.base
,
1971 rdev
->mode_info
.audio_property
,
1974 if (ASIC_IS_AVIVO(rdev
)) {
1975 drm_object_attach_property(&radeon_connector
->base
.base
,
1976 rdev
->mode_info
.dither_property
,
1977 RADEON_FMT_DITHER_DISABLE
);
1980 connector
->interlace_allowed
= true;
1981 /* in theory with a DP to VGA converter... */
1982 connector
->doublescan_allowed
= false;
1984 case DRM_MODE_CONNECTOR_eDP
:
1985 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
1986 if (!radeon_dig_connector
)
1988 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
1989 radeon_connector
->con_priv
= radeon_dig_connector
;
1990 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_edp_connector_funcs
, connector_type
);
1991 drm_connector_helper_add(&radeon_connector
->base
, &radeon_dp_connector_helper_funcs
);
1992 if (i2c_bus
->valid
) {
1993 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1994 if (radeon_connector
->ddc_bus
)
1997 DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1999 drm_object_attach_property(&radeon_connector
->base
.base
,
2000 dev
->mode_config
.scaling_mode_property
,
2001 DRM_MODE_SCALE_FULLSCREEN
);
2002 subpixel_order
= SubPixelHorizontalRGB
;
2003 connector
->interlace_allowed
= false;
2004 connector
->doublescan_allowed
= false;
2006 case DRM_MODE_CONNECTOR_SVIDEO
:
2007 case DRM_MODE_CONNECTOR_Composite
:
2008 case DRM_MODE_CONNECTOR_9PinDIN
:
2009 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_tv_connector_funcs
, connector_type
);
2010 drm_connector_helper_add(&radeon_connector
->base
, &radeon_tv_connector_helper_funcs
);
2011 radeon_connector
->dac_load_detect
= true;
2012 drm_object_attach_property(&radeon_connector
->base
.base
,
2013 rdev
->mode_info
.load_detect_property
,
2015 drm_object_attach_property(&radeon_connector
->base
.base
,
2016 rdev
->mode_info
.tv_std_property
,
2017 radeon_atombios_get_tv_info(rdev
));
2018 /* no HPD on analog connectors */
2019 radeon_connector
->hpd
.hpd
= RADEON_HPD_NONE
;
2020 connector
->interlace_allowed
= false;
2021 connector
->doublescan_allowed
= false;
2023 case DRM_MODE_CONNECTOR_LVDS
:
2024 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
2025 if (!radeon_dig_connector
)
2027 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
2028 radeon_connector
->con_priv
= radeon_dig_connector
;
2029 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_lvds_connector_funcs
, connector_type
);
2030 drm_connector_helper_add(&radeon_connector
->base
, &radeon_lvds_connector_helper_funcs
);
2031 if (i2c_bus
->valid
) {
2032 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
2033 if (!radeon_connector
->ddc_bus
)
2034 DRM_ERROR("LVDS: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2036 drm_object_attach_property(&radeon_connector
->base
.base
,
2037 dev
->mode_config
.scaling_mode_property
,
2038 DRM_MODE_SCALE_FULLSCREEN
);
2039 subpixel_order
= SubPixelHorizontalRGB
;
2040 connector
->interlace_allowed
= false;
2041 connector
->doublescan_allowed
= false;
2046 if (radeon_connector
->hpd
.hpd
== RADEON_HPD_NONE
) {
2048 connector
->polled
= DRM_CONNECTOR_POLL_CONNECT
;
2050 connector
->polled
= DRM_CONNECTOR_POLL_HPD
;
2052 connector
->display_info
.subpixel_order
= subpixel_order
;
2053 drm_sysfs_connector_add(connector
);
2056 radeon_dp_aux_init(radeon_connector
);
2061 drm_connector_cleanup(connector
);
2066 radeon_add_legacy_connector(struct drm_device
*dev
,
2067 uint32_t connector_id
,
2068 uint32_t supported_device
,
2070 struct radeon_i2c_bus_rec
*i2c_bus
,
2071 uint16_t connector_object_id
,
2072 struct radeon_hpd
*hpd
)
2074 struct radeon_device
*rdev
= dev
->dev_private
;
2075 struct drm_connector
*connector
;
2076 struct radeon_connector
*radeon_connector
;
2077 uint32_t subpixel_order
= SubPixelNone
;
2079 if (connector_type
== DRM_MODE_CONNECTOR_Unknown
)
2082 /* if the user selected tv=0 don't try and add the connector */
2083 if (((connector_type
== DRM_MODE_CONNECTOR_SVIDEO
) ||
2084 (connector_type
== DRM_MODE_CONNECTOR_Composite
) ||
2085 (connector_type
== DRM_MODE_CONNECTOR_9PinDIN
)) &&
2089 /* see if we already added it */
2090 list_for_each_entry(connector
, &dev
->mode_config
.connector_list
, head
) {
2091 radeon_connector
= to_radeon_connector(connector
);
2092 if (radeon_connector
->connector_id
== connector_id
) {
2093 radeon_connector
->devices
|= supported_device
;
2098 radeon_connector
= kzalloc(sizeof(struct radeon_connector
), GFP_KERNEL
);
2099 if (!radeon_connector
)
2102 connector
= &radeon_connector
->base
;
2104 radeon_connector
->connector_id
= connector_id
;
2105 radeon_connector
->devices
= supported_device
;
2106 radeon_connector
->connector_object_id
= connector_object_id
;
2107 radeon_connector
->hpd
= *hpd
;
2109 switch (connector_type
) {
2110 case DRM_MODE_CONNECTOR_VGA
:
2111 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_vga_connector_funcs
, connector_type
);
2112 drm_connector_helper_add(&radeon_connector
->base
, &radeon_vga_connector_helper_funcs
);
2113 if (i2c_bus
->valid
) {
2114 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
2115 if (!radeon_connector
->ddc_bus
)
2116 DRM_ERROR("VGA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2118 radeon_connector
->dac_load_detect
= true;
2119 drm_object_attach_property(&radeon_connector
->base
.base
,
2120 rdev
->mode_info
.load_detect_property
,
2122 /* no HPD on analog connectors */
2123 radeon_connector
->hpd
.hpd
= RADEON_HPD_NONE
;
2124 connector
->polled
= DRM_CONNECTOR_POLL_CONNECT
;
2125 connector
->interlace_allowed
= true;
2126 connector
->doublescan_allowed
= true;
2128 case DRM_MODE_CONNECTOR_DVIA
:
2129 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_vga_connector_funcs
, connector_type
);
2130 drm_connector_helper_add(&radeon_connector
->base
, &radeon_vga_connector_helper_funcs
);
2131 if (i2c_bus
->valid
) {
2132 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
2133 if (!radeon_connector
->ddc_bus
)
2134 DRM_ERROR("DVIA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2136 radeon_connector
->dac_load_detect
= true;
2137 drm_object_attach_property(&radeon_connector
->base
.base
,
2138 rdev
->mode_info
.load_detect_property
,
2140 /* no HPD on analog connectors */
2141 radeon_connector
->hpd
.hpd
= RADEON_HPD_NONE
;
2142 connector
->interlace_allowed
= true;
2143 connector
->doublescan_allowed
= true;
2145 case DRM_MODE_CONNECTOR_DVII
:
2146 case DRM_MODE_CONNECTOR_DVID
:
2147 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_dvi_connector_funcs
, connector_type
);
2148 drm_connector_helper_add(&radeon_connector
->base
, &radeon_dvi_connector_helper_funcs
);
2149 if (i2c_bus
->valid
) {
2150 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
2151 if (!radeon_connector
->ddc_bus
)
2152 DRM_ERROR("DVI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2154 if (connector_type
== DRM_MODE_CONNECTOR_DVII
) {
2155 radeon_connector
->dac_load_detect
= true;
2156 drm_object_attach_property(&radeon_connector
->base
.base
,
2157 rdev
->mode_info
.load_detect_property
,
2160 subpixel_order
= SubPixelHorizontalRGB
;
2161 connector
->interlace_allowed
= true;
2162 if (connector_type
== DRM_MODE_CONNECTOR_DVII
)
2163 connector
->doublescan_allowed
= true;
2165 connector
->doublescan_allowed
= false;
2167 case DRM_MODE_CONNECTOR_SVIDEO
:
2168 case DRM_MODE_CONNECTOR_Composite
:
2169 case DRM_MODE_CONNECTOR_9PinDIN
:
2170 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_tv_connector_funcs
, connector_type
);
2171 drm_connector_helper_add(&radeon_connector
->base
, &radeon_tv_connector_helper_funcs
);
2172 radeon_connector
->dac_load_detect
= true;
2173 /* RS400,RC410,RS480 chipset seems to report a lot
2174 * of false positive on load detect, we haven't yet
2175 * found a way to make load detect reliable on those
2176 * chipset, thus just disable it for TV.
2178 if (rdev
->family
== CHIP_RS400
|| rdev
->family
== CHIP_RS480
)
2179 radeon_connector
->dac_load_detect
= false;
2180 drm_object_attach_property(&radeon_connector
->base
.base
,
2181 rdev
->mode_info
.load_detect_property
,
2182 radeon_connector
->dac_load_detect
);
2183 drm_object_attach_property(&radeon_connector
->base
.base
,
2184 rdev
->mode_info
.tv_std_property
,
2185 radeon_combios_get_tv_info(rdev
));
2186 /* no HPD on analog connectors */
2187 radeon_connector
->hpd
.hpd
= RADEON_HPD_NONE
;
2188 connector
->interlace_allowed
= false;
2189 connector
->doublescan_allowed
= false;
2191 case DRM_MODE_CONNECTOR_LVDS
:
2192 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_lvds_connector_funcs
, connector_type
);
2193 drm_connector_helper_add(&radeon_connector
->base
, &radeon_lvds_connector_helper_funcs
);
2194 if (i2c_bus
->valid
) {
2195 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
2196 if (!radeon_connector
->ddc_bus
)
2197 DRM_ERROR("LVDS: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2199 drm_object_attach_property(&radeon_connector
->base
.base
,
2200 dev
->mode_config
.scaling_mode_property
,
2201 DRM_MODE_SCALE_FULLSCREEN
);
2202 subpixel_order
= SubPixelHorizontalRGB
;
2203 connector
->interlace_allowed
= false;
2204 connector
->doublescan_allowed
= false;
2208 if (radeon_connector
->hpd
.hpd
== RADEON_HPD_NONE
) {
2210 connector
->polled
= DRM_CONNECTOR_POLL_CONNECT
;
2212 connector
->polled
= DRM_CONNECTOR_POLL_HPD
;
2213 connector
->display_info
.subpixel_order
= subpixel_order
;
2214 drm_sysfs_connector_add(connector
);