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
;
222 best_encoder
= connector_funcs
->best_encoder(connector
);
224 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
225 if (connector
->encoder_ids
[i
] == 0)
228 encoder
= drm_encoder_find(connector
->dev
,
229 connector
->encoder_ids
[i
]);
233 if ((encoder
== best_encoder
) && (status
== connector_status_connected
))
238 if (rdev
->is_atom_bios
)
239 radeon_atombios_connected_scratch_regs(connector
, encoder
, connected
);
241 radeon_combios_connected_scratch_regs(connector
, encoder
, connected
);
246 static struct drm_encoder
*radeon_find_encoder(struct drm_connector
*connector
, int encoder_type
)
248 struct drm_encoder
*encoder
;
251 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
252 if (connector
->encoder_ids
[i
] == 0)
255 encoder
= drm_encoder_find(connector
->dev
, connector
->encoder_ids
[i
]);
259 if (encoder
->encoder_type
== encoder_type
)
265 static struct drm_encoder
*radeon_best_single_encoder(struct drm_connector
*connector
)
267 int enc_id
= connector
->encoder_ids
[0];
268 /* pick the encoder ids */
270 return drm_encoder_find(connector
->dev
, enc_id
);
275 * radeon_connector_analog_encoder_conflict_solve
276 * - search for other connectors sharing this encoder
277 * if priority is true, then set them disconnected if this is connected
278 * if priority is false, set us disconnected if they are connected
280 static enum drm_connector_status
281 radeon_connector_analog_encoder_conflict_solve(struct drm_connector
*connector
,
282 struct drm_encoder
*encoder
,
283 enum drm_connector_status current_status
,
286 struct drm_device
*dev
= connector
->dev
;
287 struct drm_connector
*conflict
;
288 struct radeon_connector
*radeon_conflict
;
291 list_for_each_entry(conflict
, &dev
->mode_config
.connector_list
, head
) {
292 if (conflict
== connector
)
295 radeon_conflict
= to_radeon_connector(conflict
);
296 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
297 if (conflict
->encoder_ids
[i
] == 0)
300 /* if the IDs match */
301 if (conflict
->encoder_ids
[i
] == encoder
->base
.id
) {
302 if (conflict
->status
!= connector_status_connected
)
305 if (radeon_conflict
->use_digital
)
308 if (priority
== true) {
309 DRM_DEBUG_KMS("1: conflicting encoders switching off %s\n",
311 DRM_DEBUG_KMS("in favor of %s\n",
313 conflict
->status
= connector_status_disconnected
;
314 radeon_connector_update_scratch_regs(conflict
, connector_status_disconnected
);
316 DRM_DEBUG_KMS("2: conflicting encoders switching off %s\n",
318 DRM_DEBUG_KMS("in favor of %s\n",
320 current_status
= connector_status_disconnected
;
326 return current_status
;
330 static struct drm_display_mode
*radeon_fp_native_mode(struct drm_encoder
*encoder
)
332 struct drm_device
*dev
= encoder
->dev
;
333 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
334 struct drm_display_mode
*mode
= NULL
;
335 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
337 if (native_mode
->hdisplay
!= 0 &&
338 native_mode
->vdisplay
!= 0 &&
339 native_mode
->clock
!= 0) {
340 mode
= drm_mode_duplicate(dev
, native_mode
);
341 mode
->type
= DRM_MODE_TYPE_PREFERRED
| DRM_MODE_TYPE_DRIVER
;
342 drm_mode_set_name(mode
);
344 DRM_DEBUG_KMS("Adding native panel mode %s\n", mode
->name
);
345 } else if (native_mode
->hdisplay
!= 0 &&
346 native_mode
->vdisplay
!= 0) {
347 /* mac laptops without an edid */
348 /* Note that this is not necessarily the exact panel mode,
349 * but an approximation based on the cvt formula. For these
350 * systems we should ideally read the mode info out of the
351 * registers or add a mode table, but this works and is much
354 mode
= drm_cvt_mode(dev
, native_mode
->hdisplay
, native_mode
->vdisplay
, 60, true, false, false);
355 mode
->type
= DRM_MODE_TYPE_PREFERRED
| DRM_MODE_TYPE_DRIVER
;
356 DRM_DEBUG_KMS("Adding cvt approximation of native panel mode %s\n", mode
->name
);
361 static void radeon_add_common_modes(struct drm_encoder
*encoder
, struct drm_connector
*connector
)
363 struct drm_device
*dev
= encoder
->dev
;
364 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
365 struct drm_display_mode
*mode
= NULL
;
366 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
371 } common_modes
[17] = {
391 for (i
= 0; i
< 17; i
++) {
392 if (radeon_encoder
->devices
& (ATOM_DEVICE_TV_SUPPORT
)) {
393 if (common_modes
[i
].w
> 1024 ||
394 common_modes
[i
].h
> 768)
397 if (radeon_encoder
->devices
& (ATOM_DEVICE_LCD_SUPPORT
)) {
398 if (common_modes
[i
].w
> native_mode
->hdisplay
||
399 common_modes
[i
].h
> native_mode
->vdisplay
||
400 (common_modes
[i
].w
== native_mode
->hdisplay
&&
401 common_modes
[i
].h
== native_mode
->vdisplay
))
404 if (common_modes
[i
].w
< 320 || common_modes
[i
].h
< 200)
407 mode
= drm_cvt_mode(dev
, common_modes
[i
].w
, common_modes
[i
].h
, 60, false, false, false);
408 drm_mode_probed_add(connector
, mode
);
412 static int radeon_connector_set_property(struct drm_connector
*connector
, struct drm_property
*property
,
415 struct drm_device
*dev
= connector
->dev
;
416 struct radeon_device
*rdev
= dev
->dev_private
;
417 struct drm_encoder
*encoder
;
418 struct radeon_encoder
*radeon_encoder
;
420 if (property
== rdev
->mode_info
.coherent_mode_property
) {
421 struct radeon_encoder_atom_dig
*dig
;
422 bool new_coherent_mode
;
424 /* need to find digital encoder on connector */
425 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TMDS
);
429 radeon_encoder
= to_radeon_encoder(encoder
);
431 if (!radeon_encoder
->enc_priv
)
434 dig
= radeon_encoder
->enc_priv
;
435 new_coherent_mode
= val
? true : false;
436 if (dig
->coherent_mode
!= new_coherent_mode
) {
437 dig
->coherent_mode
= new_coherent_mode
;
438 radeon_property_change_mode(&radeon_encoder
->base
);
442 if (property
== rdev
->mode_info
.audio_property
) {
443 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
444 /* need to find digital encoder on connector */
445 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TMDS
);
449 radeon_encoder
= to_radeon_encoder(encoder
);
451 if (radeon_connector
->audio
!= val
) {
452 radeon_connector
->audio
= val
;
453 radeon_property_change_mode(&radeon_encoder
->base
);
457 if (property
== rdev
->mode_info
.dither_property
) {
458 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
459 /* need to find digital encoder on connector */
460 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TMDS
);
464 radeon_encoder
= to_radeon_encoder(encoder
);
466 if (radeon_connector
->dither
!= val
) {
467 radeon_connector
->dither
= val
;
468 radeon_property_change_mode(&radeon_encoder
->base
);
472 if (property
== rdev
->mode_info
.underscan_property
) {
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_encoder
->underscan_type
!= val
) {
481 radeon_encoder
->underscan_type
= val
;
482 radeon_property_change_mode(&radeon_encoder
->base
);
486 if (property
== rdev
->mode_info
.underscan_hborder_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_hborder
!= val
) {
495 radeon_encoder
->underscan_hborder
= val
;
496 radeon_property_change_mode(&radeon_encoder
->base
);
500 if (property
== rdev
->mode_info
.underscan_vborder_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_vborder
!= val
) {
509 radeon_encoder
->underscan_vborder
= val
;
510 radeon_property_change_mode(&radeon_encoder
->base
);
514 if (property
== rdev
->mode_info
.tv_std_property
) {
515 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TVDAC
);
517 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_DAC
);
523 radeon_encoder
= to_radeon_encoder(encoder
);
524 if (!radeon_encoder
->enc_priv
)
526 if (ASIC_IS_AVIVO(rdev
) || radeon_r4xx_atom
) {
527 struct radeon_encoder_atom_dac
*dac_int
;
528 dac_int
= radeon_encoder
->enc_priv
;
529 dac_int
->tv_std
= val
;
531 struct radeon_encoder_tv_dac
*dac_int
;
532 dac_int
= radeon_encoder
->enc_priv
;
533 dac_int
->tv_std
= val
;
535 radeon_property_change_mode(&radeon_encoder
->base
);
538 if (property
== rdev
->mode_info
.load_detect_property
) {
539 struct radeon_connector
*radeon_connector
=
540 to_radeon_connector(connector
);
543 radeon_connector
->dac_load_detect
= false;
545 radeon_connector
->dac_load_detect
= true;
548 if (property
== rdev
->mode_info
.tmds_pll_property
) {
549 struct radeon_encoder_int_tmds
*tmds
= NULL
;
551 /* need to find digital encoder on connector */
552 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TMDS
);
556 radeon_encoder
= to_radeon_encoder(encoder
);
558 tmds
= radeon_encoder
->enc_priv
;
563 if (rdev
->is_atom_bios
)
564 ret
= radeon_atombios_get_tmds_info(radeon_encoder
, tmds
);
566 ret
= radeon_legacy_get_tmds_info_from_combios(radeon_encoder
, tmds
);
568 if (val
== 1 || ret
== false) {
569 radeon_legacy_get_tmds_info_from_table(radeon_encoder
, tmds
);
571 radeon_property_change_mode(&radeon_encoder
->base
);
577 static void radeon_fixup_lvds_native_mode(struct drm_encoder
*encoder
,
578 struct drm_connector
*connector
)
580 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
581 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
582 struct drm_display_mode
*t
, *mode
;
584 /* If the EDID preferred mode doesn't match the native mode, use it */
585 list_for_each_entry_safe(mode
, t
, &connector
->probed_modes
, head
) {
586 if (mode
->type
& DRM_MODE_TYPE_PREFERRED
) {
587 if (mode
->hdisplay
!= native_mode
->hdisplay
||
588 mode
->vdisplay
!= native_mode
->vdisplay
)
589 memcpy(native_mode
, mode
, sizeof(*mode
));
593 /* Try to get native mode details from EDID if necessary */
594 if (!native_mode
->clock
) {
595 list_for_each_entry_safe(mode
, t
, &connector
->probed_modes
, head
) {
596 if (mode
->hdisplay
== native_mode
->hdisplay
&&
597 mode
->vdisplay
== native_mode
->vdisplay
) {
598 *native_mode
= *mode
;
599 drm_mode_set_crtcinfo(native_mode
, CRTC_INTERLACE_HALVE_V
);
600 DRM_DEBUG_KMS("Determined LVDS native mode details from EDID\n");
606 if (!native_mode
->clock
) {
607 DRM_DEBUG_KMS("No LVDS native mode details, disabling RMX\n");
608 radeon_encoder
->rmx_type
= RMX_OFF
;
612 static int radeon_lvds_get_modes(struct drm_connector
*connector
)
614 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
615 struct drm_encoder
*encoder
;
617 struct drm_display_mode
*mode
;
619 if (radeon_connector
->ddc_bus
) {
620 ret
= radeon_ddc_get_modes(radeon_connector
);
622 encoder
= radeon_best_single_encoder(connector
);
624 radeon_fixup_lvds_native_mode(encoder
, connector
);
625 /* add scaled modes */
626 radeon_add_common_modes(encoder
, connector
);
632 encoder
= radeon_best_single_encoder(connector
);
636 /* we have no EDID modes */
637 mode
= radeon_fp_native_mode(encoder
);
640 drm_mode_probed_add(connector
, mode
);
641 /* add the width/height from vbios tables if available */
642 connector
->display_info
.width_mm
= mode
->width_mm
;
643 connector
->display_info
.height_mm
= mode
->height_mm
;
644 /* add scaled modes */
645 radeon_add_common_modes(encoder
, connector
);
651 static int radeon_lvds_mode_valid(struct drm_connector
*connector
,
652 struct drm_display_mode
*mode
)
654 struct drm_encoder
*encoder
= radeon_best_single_encoder(connector
);
656 if ((mode
->hdisplay
< 320) || (mode
->vdisplay
< 240))
660 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
661 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
663 /* AVIVO hardware supports downscaling modes larger than the panel
664 * to the panel size, but I'm not sure this is desirable.
666 if ((mode
->hdisplay
> native_mode
->hdisplay
) ||
667 (mode
->vdisplay
> native_mode
->vdisplay
))
670 /* if scaling is disabled, block non-native modes */
671 if (radeon_encoder
->rmx_type
== RMX_OFF
) {
672 if ((mode
->hdisplay
!= native_mode
->hdisplay
) ||
673 (mode
->vdisplay
!= native_mode
->vdisplay
))
681 static enum drm_connector_status
682 radeon_lvds_detect(struct drm_connector
*connector
, bool force
)
684 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
685 struct drm_encoder
*encoder
= radeon_best_single_encoder(connector
);
686 enum drm_connector_status ret
= connector_status_disconnected
;
689 r
= pm_runtime_get_sync(connector
->dev
->dev
);
691 return connector_status_disconnected
;
694 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
695 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
697 /* check if panel is valid */
698 if (native_mode
->hdisplay
>= 320 && native_mode
->vdisplay
>= 240)
699 ret
= connector_status_connected
;
703 /* check for edid as well */
704 if (radeon_connector
->edid
)
705 ret
= connector_status_connected
;
707 if (radeon_connector
->ddc_bus
) {
708 radeon_connector
->edid
= drm_get_edid(&radeon_connector
->base
,
709 &radeon_connector
->ddc_bus
->adapter
);
710 if (radeon_connector
->edid
)
711 ret
= connector_status_connected
;
714 /* check acpi lid status ??? */
716 radeon_connector_update_scratch_regs(connector
, ret
);
717 pm_runtime_mark_last_busy(connector
->dev
->dev
);
718 pm_runtime_put_autosuspend(connector
->dev
->dev
);
722 static void radeon_connector_destroy(struct drm_connector
*connector
)
724 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
726 if (radeon_connector
->edid
)
727 kfree(radeon_connector
->edid
);
728 kfree(radeon_connector
->con_priv
);
729 drm_connector_unregister(connector
);
730 drm_connector_cleanup(connector
);
734 static int radeon_lvds_set_property(struct drm_connector
*connector
,
735 struct drm_property
*property
,
738 struct drm_device
*dev
= connector
->dev
;
739 struct radeon_encoder
*radeon_encoder
;
740 enum radeon_rmx_type rmx_type
;
743 if (property
!= dev
->mode_config
.scaling_mode_property
)
746 if (connector
->encoder
)
747 radeon_encoder
= to_radeon_encoder(connector
->encoder
);
749 struct drm_connector_helper_funcs
*connector_funcs
= connector
->helper_private
;
750 radeon_encoder
= to_radeon_encoder(connector_funcs
->best_encoder(connector
));
754 case DRM_MODE_SCALE_NONE
: rmx_type
= RMX_OFF
; break;
755 case DRM_MODE_SCALE_CENTER
: rmx_type
= RMX_CENTER
; break;
756 case DRM_MODE_SCALE_ASPECT
: rmx_type
= RMX_ASPECT
; break;
758 case DRM_MODE_SCALE_FULLSCREEN
: rmx_type
= RMX_FULL
; break;
760 if (radeon_encoder
->rmx_type
== rmx_type
)
763 radeon_encoder
->rmx_type
= rmx_type
;
765 radeon_property_change_mode(&radeon_encoder
->base
);
770 static const struct drm_connector_helper_funcs radeon_lvds_connector_helper_funcs
= {
771 .get_modes
= radeon_lvds_get_modes
,
772 .mode_valid
= radeon_lvds_mode_valid
,
773 .best_encoder
= radeon_best_single_encoder
,
776 static const struct drm_connector_funcs radeon_lvds_connector_funcs
= {
777 .dpms
= drm_helper_connector_dpms
,
778 .detect
= radeon_lvds_detect
,
779 .fill_modes
= drm_helper_probe_single_connector_modes
,
780 .destroy
= radeon_connector_destroy
,
781 .set_property
= radeon_lvds_set_property
,
784 static int radeon_vga_get_modes(struct drm_connector
*connector
)
786 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
789 ret
= radeon_ddc_get_modes(radeon_connector
);
794 static int radeon_vga_mode_valid(struct drm_connector
*connector
,
795 struct drm_display_mode
*mode
)
797 struct drm_device
*dev
= connector
->dev
;
798 struct radeon_device
*rdev
= dev
->dev_private
;
800 /* XXX check mode bandwidth */
802 if ((mode
->clock
/ 10) > rdev
->clock
.max_pixel_clock
)
803 return MODE_CLOCK_HIGH
;
808 static enum drm_connector_status
809 radeon_vga_detect(struct drm_connector
*connector
, bool force
)
811 struct drm_device
*dev
= connector
->dev
;
812 struct radeon_device
*rdev
= dev
->dev_private
;
813 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
814 struct drm_encoder
*encoder
;
815 struct drm_encoder_helper_funcs
*encoder_funcs
;
817 enum drm_connector_status ret
= connector_status_disconnected
;
820 r
= pm_runtime_get_sync(connector
->dev
->dev
);
822 return connector_status_disconnected
;
824 encoder
= radeon_best_single_encoder(connector
);
826 ret
= connector_status_disconnected
;
828 if (radeon_connector
->ddc_bus
)
829 dret
= radeon_ddc_probe(radeon_connector
, false);
831 radeon_connector
->detected_by_load
= false;
832 if (radeon_connector
->edid
) {
833 kfree(radeon_connector
->edid
);
834 radeon_connector
->edid
= NULL
;
836 radeon_connector
->edid
= drm_get_edid(&radeon_connector
->base
, &radeon_connector
->ddc_bus
->adapter
);
838 if (!radeon_connector
->edid
) {
839 DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
841 ret
= connector_status_connected
;
843 radeon_connector
->use_digital
= !!(radeon_connector
->edid
->input
& DRM_EDID_INPUT_DIGITAL
);
845 /* some oems have boards with separate digital and analog connectors
846 * with a shared ddc line (often vga + hdmi)
848 if (radeon_connector
->use_digital
&& radeon_connector
->shared_ddc
) {
849 kfree(radeon_connector
->edid
);
850 radeon_connector
->edid
= NULL
;
851 ret
= connector_status_disconnected
;
853 ret
= connector_status_connected
;
857 /* if we aren't forcing don't do destructive polling */
859 /* only return the previous status if we last
860 * detected a monitor via load.
862 if (radeon_connector
->detected_by_load
)
863 ret
= connector
->status
;
867 if (radeon_connector
->dac_load_detect
&& encoder
) {
868 encoder_funcs
= encoder
->helper_private
;
869 ret
= encoder_funcs
->detect(encoder
, connector
);
870 if (ret
!= connector_status_disconnected
)
871 radeon_connector
->detected_by_load
= true;
875 if (ret
== connector_status_connected
)
876 ret
= radeon_connector_analog_encoder_conflict_solve(connector
, encoder
, ret
, true);
878 /* RN50 and some RV100 asics in servers often have a hardcoded EDID in the
879 * vbios to deal with KVMs. If we have one and are not able to detect a monitor
880 * by other means, assume the CRT is connected and use that EDID.
882 if ((!rdev
->is_atom_bios
) &&
883 (ret
== connector_status_disconnected
) &&
884 rdev
->mode_info
.bios_hardcoded_edid_size
) {
885 ret
= connector_status_connected
;
888 radeon_connector_update_scratch_regs(connector
, ret
);
891 pm_runtime_mark_last_busy(connector
->dev
->dev
);
892 pm_runtime_put_autosuspend(connector
->dev
->dev
);
897 static const struct drm_connector_helper_funcs radeon_vga_connector_helper_funcs
= {
898 .get_modes
= radeon_vga_get_modes
,
899 .mode_valid
= radeon_vga_mode_valid
,
900 .best_encoder
= radeon_best_single_encoder
,
903 static const struct drm_connector_funcs radeon_vga_connector_funcs
= {
904 .dpms
= drm_helper_connector_dpms
,
905 .detect
= radeon_vga_detect
,
906 .fill_modes
= drm_helper_probe_single_connector_modes
,
907 .destroy
= radeon_connector_destroy
,
908 .set_property
= radeon_connector_set_property
,
911 static int radeon_tv_get_modes(struct drm_connector
*connector
)
913 struct drm_device
*dev
= connector
->dev
;
914 struct radeon_device
*rdev
= dev
->dev_private
;
915 struct drm_display_mode
*tv_mode
;
916 struct drm_encoder
*encoder
;
918 encoder
= radeon_best_single_encoder(connector
);
922 /* avivo chips can scale any mode */
923 if (rdev
->family
>= CHIP_RS600
)
924 /* add scaled modes */
925 radeon_add_common_modes(encoder
, connector
);
927 /* only 800x600 is supported right now on pre-avivo chips */
928 tv_mode
= drm_cvt_mode(dev
, 800, 600, 60, false, false, false);
929 tv_mode
->type
= DRM_MODE_TYPE_DRIVER
| DRM_MODE_TYPE_PREFERRED
;
930 drm_mode_probed_add(connector
, tv_mode
);
935 static int radeon_tv_mode_valid(struct drm_connector
*connector
,
936 struct drm_display_mode
*mode
)
938 if ((mode
->hdisplay
> 1024) || (mode
->vdisplay
> 768))
939 return MODE_CLOCK_RANGE
;
943 static enum drm_connector_status
944 radeon_tv_detect(struct drm_connector
*connector
, bool force
)
946 struct drm_encoder
*encoder
;
947 struct drm_encoder_helper_funcs
*encoder_funcs
;
948 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
949 enum drm_connector_status ret
= connector_status_disconnected
;
952 if (!radeon_connector
->dac_load_detect
)
955 r
= pm_runtime_get_sync(connector
->dev
->dev
);
957 return connector_status_disconnected
;
959 encoder
= radeon_best_single_encoder(connector
);
961 ret
= connector_status_disconnected
;
963 encoder_funcs
= encoder
->helper_private
;
964 ret
= encoder_funcs
->detect(encoder
, connector
);
966 if (ret
== connector_status_connected
)
967 ret
= radeon_connector_analog_encoder_conflict_solve(connector
, encoder
, ret
, false);
968 radeon_connector_update_scratch_regs(connector
, ret
);
969 pm_runtime_mark_last_busy(connector
->dev
->dev
);
970 pm_runtime_put_autosuspend(connector
->dev
->dev
);
974 static const struct drm_connector_helper_funcs radeon_tv_connector_helper_funcs
= {
975 .get_modes
= radeon_tv_get_modes
,
976 .mode_valid
= radeon_tv_mode_valid
,
977 .best_encoder
= radeon_best_single_encoder
,
980 static const struct drm_connector_funcs radeon_tv_connector_funcs
= {
981 .dpms
= drm_helper_connector_dpms
,
982 .detect
= radeon_tv_detect
,
983 .fill_modes
= drm_helper_probe_single_connector_modes
,
984 .destroy
= radeon_connector_destroy
,
985 .set_property
= radeon_connector_set_property
,
988 static int radeon_dvi_get_modes(struct drm_connector
*connector
)
990 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
993 ret
= radeon_ddc_get_modes(radeon_connector
);
997 static bool radeon_check_hpd_status_unchanged(struct drm_connector
*connector
)
999 struct drm_device
*dev
= connector
->dev
;
1000 struct radeon_device
*rdev
= dev
->dev_private
;
1001 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1002 enum drm_connector_status status
;
1004 /* We only trust HPD on R600 and newer ASICS. */
1005 if (rdev
->family
>= CHIP_R600
1006 && radeon_connector
->hpd
.hpd
!= RADEON_HPD_NONE
) {
1007 if (radeon_hpd_sense(rdev
, radeon_connector
->hpd
.hpd
))
1008 status
= connector_status_connected
;
1010 status
= connector_status_disconnected
;
1011 if (connector
->status
== status
)
1019 * DVI is complicated
1020 * Do a DDC probe, if DDC probe passes, get the full EDID so
1021 * we can do analog/digital monitor detection at this point.
1022 * If the monitor is an analog monitor or we got no DDC,
1023 * we need to find the DAC encoder object for this connector.
1024 * If we got no DDC, we do load detection on the DAC encoder object.
1025 * If we got analog DDC or load detection passes on the DAC encoder
1026 * we have to check if this analog encoder is shared with anyone else (TV)
1027 * if its shared we have to set the other connector to disconnected.
1029 static enum drm_connector_status
1030 radeon_dvi_detect(struct drm_connector
*connector
, bool force
)
1032 struct drm_device
*dev
= connector
->dev
;
1033 struct radeon_device
*rdev
= dev
->dev_private
;
1034 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1035 struct drm_encoder
*encoder
= NULL
;
1036 struct drm_encoder_helper_funcs
*encoder_funcs
;
1038 enum drm_connector_status ret
= connector_status_disconnected
;
1039 bool dret
= false, broken_edid
= false;
1041 r
= pm_runtime_get_sync(connector
->dev
->dev
);
1043 return connector_status_disconnected
;
1045 if (!force
&& radeon_check_hpd_status_unchanged(connector
)) {
1046 ret
= connector
->status
;
1050 if (radeon_connector
->ddc_bus
)
1051 dret
= radeon_ddc_probe(radeon_connector
, false);
1053 radeon_connector
->detected_by_load
= false;
1054 if (radeon_connector
->edid
) {
1055 kfree(radeon_connector
->edid
);
1056 radeon_connector
->edid
= NULL
;
1058 radeon_connector
->edid
= drm_get_edid(&radeon_connector
->base
, &radeon_connector
->ddc_bus
->adapter
);
1060 if (!radeon_connector
->edid
) {
1061 DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
1063 /* rs690 seems to have a problem with connectors not existing and always
1064 * return a block of 0's. If we see this just stop polling on this output */
1065 if ((rdev
->family
== CHIP_RS690
|| rdev
->family
== CHIP_RS740
) && radeon_connector
->base
.null_edid_counter
) {
1066 ret
= connector_status_disconnected
;
1067 DRM_ERROR("%s: detected RS690 floating bus bug, stopping ddc detect\n",
1069 radeon_connector
->ddc_bus
= NULL
;
1071 ret
= connector_status_connected
;
1072 broken_edid
= true; /* defer use_digital to later */
1075 radeon_connector
->use_digital
= !!(radeon_connector
->edid
->input
& DRM_EDID_INPUT_DIGITAL
);
1077 /* some oems have boards with separate digital and analog connectors
1078 * with a shared ddc line (often vga + hdmi)
1080 if ((!radeon_connector
->use_digital
) && radeon_connector
->shared_ddc
) {
1081 kfree(radeon_connector
->edid
);
1082 radeon_connector
->edid
= NULL
;
1083 ret
= connector_status_disconnected
;
1085 ret
= connector_status_connected
;
1087 /* This gets complicated. We have boards with VGA + HDMI with a
1088 * shared DDC line and we have boards with DVI-D + HDMI with a shared
1089 * DDC line. The latter is more complex because with DVI<->HDMI adapters
1090 * you don't really know what's connected to which port as both are digital.
1092 if (radeon_connector
->shared_ddc
&& (ret
== connector_status_connected
)) {
1093 struct drm_connector
*list_connector
;
1094 struct radeon_connector
*list_radeon_connector
;
1095 list_for_each_entry(list_connector
, &dev
->mode_config
.connector_list
, head
) {
1096 if (connector
== list_connector
)
1098 list_radeon_connector
= to_radeon_connector(list_connector
);
1099 if (list_radeon_connector
->shared_ddc
&&
1100 (list_radeon_connector
->ddc_bus
->rec
.i2c_id
==
1101 radeon_connector
->ddc_bus
->rec
.i2c_id
)) {
1102 /* cases where both connectors are digital */
1103 if (list_connector
->connector_type
!= DRM_MODE_CONNECTOR_VGA
) {
1104 /* hpd is our only option in this case */
1105 if (!radeon_hpd_sense(rdev
, radeon_connector
->hpd
.hpd
)) {
1106 kfree(radeon_connector
->edid
);
1107 radeon_connector
->edid
= NULL
;
1108 ret
= connector_status_disconnected
;
1117 if ((ret
== connector_status_connected
) && (radeon_connector
->use_digital
== true))
1120 /* DVI-D and HDMI-A are digital only */
1121 if ((connector
->connector_type
== DRM_MODE_CONNECTOR_DVID
) ||
1122 (connector
->connector_type
== DRM_MODE_CONNECTOR_HDMIA
))
1125 /* if we aren't forcing don't do destructive polling */
1127 /* only return the previous status if we last
1128 * detected a monitor via load.
1130 if (radeon_connector
->detected_by_load
)
1131 ret
= connector
->status
;
1135 /* find analog encoder */
1136 if (radeon_connector
->dac_load_detect
) {
1137 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
1138 if (connector
->encoder_ids
[i
] == 0)
1141 encoder
= drm_encoder_find(connector
->dev
,
1142 connector
->encoder_ids
[i
]);
1146 if (encoder
->encoder_type
!= DRM_MODE_ENCODER_DAC
&&
1147 encoder
->encoder_type
!= DRM_MODE_ENCODER_TVDAC
)
1150 encoder_funcs
= encoder
->helper_private
;
1151 if (encoder_funcs
->detect
) {
1153 if (ret
!= connector_status_connected
) {
1154 /* deal with analog monitors without DDC */
1155 ret
= encoder_funcs
->detect(encoder
, connector
);
1156 if (ret
== connector_status_connected
) {
1157 radeon_connector
->use_digital
= false;
1159 if (ret
!= connector_status_disconnected
)
1160 radeon_connector
->detected_by_load
= true;
1163 enum drm_connector_status lret
;
1164 /* assume digital unless load detected otherwise */
1165 radeon_connector
->use_digital
= true;
1166 lret
= encoder_funcs
->detect(encoder
, connector
);
1167 DRM_DEBUG_KMS("load_detect %x returned: %x\n",encoder
->encoder_type
,lret
);
1168 if (lret
== connector_status_connected
)
1169 radeon_connector
->use_digital
= false;
1176 if ((ret
== connector_status_connected
) && (radeon_connector
->use_digital
== false) &&
1178 ret
= radeon_connector_analog_encoder_conflict_solve(connector
, encoder
, ret
, true);
1181 /* RN50 and some RV100 asics in servers often have a hardcoded EDID in the
1182 * vbios to deal with KVMs. If we have one and are not able to detect a monitor
1183 * by other means, assume the DFP is connected and use that EDID. In most
1184 * cases the DVI port is actually a virtual KVM port connected to the service
1188 if ((!rdev
->is_atom_bios
) &&
1189 (ret
== connector_status_disconnected
) &&
1190 rdev
->mode_info
.bios_hardcoded_edid_size
) {
1191 radeon_connector
->use_digital
= true;
1192 ret
= connector_status_connected
;
1195 /* updated in get modes as well since we need to know if it's analog or digital */
1196 radeon_connector_update_scratch_regs(connector
, ret
);
1199 pm_runtime_mark_last_busy(connector
->dev
->dev
);
1200 pm_runtime_put_autosuspend(connector
->dev
->dev
);
1205 /* okay need to be smart in here about which encoder to pick */
1206 static struct drm_encoder
*radeon_dvi_encoder(struct drm_connector
*connector
)
1208 int enc_id
= connector
->encoder_ids
[0];
1209 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1210 struct drm_encoder
*encoder
;
1212 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
1213 if (connector
->encoder_ids
[i
] == 0)
1216 encoder
= drm_encoder_find(connector
->dev
, connector
->encoder_ids
[i
]);
1220 if (radeon_connector
->use_digital
== true) {
1221 if (encoder
->encoder_type
== DRM_MODE_ENCODER_TMDS
)
1224 if (encoder
->encoder_type
== DRM_MODE_ENCODER_DAC
||
1225 encoder
->encoder_type
== DRM_MODE_ENCODER_TVDAC
)
1230 /* see if we have a default encoder TODO */
1232 /* then check use digitial */
1233 /* pick the first one */
1235 return drm_encoder_find(connector
->dev
, enc_id
);
1239 static void radeon_dvi_force(struct drm_connector
*connector
)
1241 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1242 if (connector
->force
== DRM_FORCE_ON
)
1243 radeon_connector
->use_digital
= false;
1244 if (connector
->force
== DRM_FORCE_ON_DIGITAL
)
1245 radeon_connector
->use_digital
= true;
1248 static int radeon_dvi_mode_valid(struct drm_connector
*connector
,
1249 struct drm_display_mode
*mode
)
1251 struct drm_device
*dev
= connector
->dev
;
1252 struct radeon_device
*rdev
= dev
->dev_private
;
1253 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1255 /* XXX check mode bandwidth */
1257 /* clocks over 135 MHz have heat issues with DVI on RV100 */
1258 if (radeon_connector
->use_digital
&&
1259 (rdev
->family
== CHIP_RV100
) &&
1260 (mode
->clock
> 135000))
1261 return MODE_CLOCK_HIGH
;
1263 if (radeon_connector
->use_digital
&& (mode
->clock
> 165000)) {
1264 if ((radeon_connector
->connector_object_id
== CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_I
) ||
1265 (radeon_connector
->connector_object_id
== CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_D
) ||
1266 (radeon_connector
->connector_object_id
== CONNECTOR_OBJECT_ID_HDMI_TYPE_B
))
1268 else if (ASIC_IS_DCE6(rdev
) && drm_detect_hdmi_monitor(radeon_connector
->edid
)) {
1269 /* HDMI 1.3+ supports max clock of 340 Mhz */
1270 if (mode
->clock
> 340000)
1271 return MODE_CLOCK_HIGH
;
1275 return MODE_CLOCK_HIGH
;
1279 /* check against the max pixel clock */
1280 if ((mode
->clock
/ 10) > rdev
->clock
.max_pixel_clock
)
1281 return MODE_CLOCK_HIGH
;
1286 static const struct drm_connector_helper_funcs radeon_dvi_connector_helper_funcs
= {
1287 .get_modes
= radeon_dvi_get_modes
,
1288 .mode_valid
= radeon_dvi_mode_valid
,
1289 .best_encoder
= radeon_dvi_encoder
,
1292 static const struct drm_connector_funcs radeon_dvi_connector_funcs
= {
1293 .dpms
= drm_helper_connector_dpms
,
1294 .detect
= radeon_dvi_detect
,
1295 .fill_modes
= drm_helper_probe_single_connector_modes
,
1296 .set_property
= radeon_connector_set_property
,
1297 .destroy
= radeon_connector_destroy
,
1298 .force
= radeon_dvi_force
,
1301 static int radeon_dp_get_modes(struct drm_connector
*connector
)
1303 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1304 struct radeon_connector_atom_dig
*radeon_dig_connector
= radeon_connector
->con_priv
;
1305 struct drm_encoder
*encoder
= radeon_best_single_encoder(connector
);
1308 if ((connector
->connector_type
== DRM_MODE_CONNECTOR_eDP
) ||
1309 (connector
->connector_type
== DRM_MODE_CONNECTOR_LVDS
)) {
1310 struct drm_display_mode
*mode
;
1312 if (connector
->connector_type
== DRM_MODE_CONNECTOR_eDP
) {
1313 if (!radeon_dig_connector
->edp_on
)
1314 atombios_set_edp_panel_power(connector
,
1315 ATOM_TRANSMITTER_ACTION_POWER_ON
);
1316 ret
= radeon_ddc_get_modes(radeon_connector
);
1317 if (!radeon_dig_connector
->edp_on
)
1318 atombios_set_edp_panel_power(connector
,
1319 ATOM_TRANSMITTER_ACTION_POWER_OFF
);
1321 /* need to setup ddc on the bridge */
1322 if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector
) !=
1323 ENCODER_OBJECT_ID_NONE
) {
1325 radeon_atom_ext_encoder_setup_ddc(encoder
);
1327 ret
= radeon_ddc_get_modes(radeon_connector
);
1332 radeon_fixup_lvds_native_mode(encoder
, connector
);
1333 /* add scaled modes */
1334 radeon_add_common_modes(encoder
, connector
);
1342 /* we have no EDID modes */
1343 mode
= radeon_fp_native_mode(encoder
);
1346 drm_mode_probed_add(connector
, mode
);
1347 /* add the width/height from vbios tables if available */
1348 connector
->display_info
.width_mm
= mode
->width_mm
;
1349 connector
->display_info
.height_mm
= mode
->height_mm
;
1350 /* add scaled modes */
1351 radeon_add_common_modes(encoder
, connector
);
1354 /* need to setup ddc on the bridge */
1355 if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector
) !=
1356 ENCODER_OBJECT_ID_NONE
) {
1358 radeon_atom_ext_encoder_setup_ddc(encoder
);
1360 ret
= radeon_ddc_get_modes(radeon_connector
);
1366 u16
radeon_connector_encoder_get_dp_bridge_encoder_id(struct drm_connector
*connector
)
1368 struct drm_encoder
*encoder
;
1369 struct radeon_encoder
*radeon_encoder
;
1372 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
1373 if (connector
->encoder_ids
[i
] == 0)
1376 encoder
= drm_encoder_find(connector
->dev
, connector
->encoder_ids
[i
]);
1380 radeon_encoder
= to_radeon_encoder(encoder
);
1382 switch (radeon_encoder
->encoder_id
) {
1383 case ENCODER_OBJECT_ID_TRAVIS
:
1384 case ENCODER_OBJECT_ID_NUTMEG
:
1385 return radeon_encoder
->encoder_id
;
1391 return ENCODER_OBJECT_ID_NONE
;
1394 bool radeon_connector_encoder_is_hbr2(struct drm_connector
*connector
)
1396 struct drm_encoder
*encoder
;
1397 struct radeon_encoder
*radeon_encoder
;
1401 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
1402 if (connector
->encoder_ids
[i
] == 0)
1405 encoder
= drm_encoder_find(connector
->dev
, connector
->encoder_ids
[i
]);
1409 radeon_encoder
= to_radeon_encoder(encoder
);
1410 if (radeon_encoder
->caps
& ATOM_ENCODER_CAP_RECORD_HBR2
)
1417 bool radeon_connector_is_dp12_capable(struct drm_connector
*connector
)
1419 struct drm_device
*dev
= connector
->dev
;
1420 struct radeon_device
*rdev
= dev
->dev_private
;
1422 if (ASIC_IS_DCE5(rdev
) &&
1423 (rdev
->clock
.default_dispclk
>= 53900) &&
1424 radeon_connector_encoder_is_hbr2(connector
)) {
1431 static enum drm_connector_status
1432 radeon_dp_detect(struct drm_connector
*connector
, bool force
)
1434 struct drm_device
*dev
= connector
->dev
;
1435 struct radeon_device
*rdev
= dev
->dev_private
;
1436 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1437 enum drm_connector_status ret
= connector_status_disconnected
;
1438 struct radeon_connector_atom_dig
*radeon_dig_connector
= radeon_connector
->con_priv
;
1439 struct drm_encoder
*encoder
= radeon_best_single_encoder(connector
);
1442 r
= pm_runtime_get_sync(connector
->dev
->dev
);
1444 return connector_status_disconnected
;
1446 if (!force
&& radeon_check_hpd_status_unchanged(connector
)) {
1447 ret
= connector
->status
;
1451 if (radeon_connector
->edid
) {
1452 kfree(radeon_connector
->edid
);
1453 radeon_connector
->edid
= NULL
;
1456 if ((connector
->connector_type
== DRM_MODE_CONNECTOR_eDP
) ||
1457 (connector
->connector_type
== DRM_MODE_CONNECTOR_LVDS
)) {
1459 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
1460 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
1462 /* check if panel is valid */
1463 if (native_mode
->hdisplay
>= 320 && native_mode
->vdisplay
>= 240)
1464 ret
= connector_status_connected
;
1466 /* eDP is always DP */
1467 radeon_dig_connector
->dp_sink_type
= CONNECTOR_OBJECT_ID_DISPLAYPORT
;
1468 if (!radeon_dig_connector
->edp_on
)
1469 atombios_set_edp_panel_power(connector
,
1470 ATOM_TRANSMITTER_ACTION_POWER_ON
);
1471 if (radeon_dp_getdpcd(radeon_connector
))
1472 ret
= connector_status_connected
;
1473 if (!radeon_dig_connector
->edp_on
)
1474 atombios_set_edp_panel_power(connector
,
1475 ATOM_TRANSMITTER_ACTION_POWER_OFF
);
1476 } else if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector
) !=
1477 ENCODER_OBJECT_ID_NONE
) {
1478 /* DP bridges are always DP */
1479 radeon_dig_connector
->dp_sink_type
= CONNECTOR_OBJECT_ID_DISPLAYPORT
;
1480 /* get the DPCD from the bridge */
1481 radeon_dp_getdpcd(radeon_connector
);
1484 /* setup ddc on the bridge */
1485 radeon_atom_ext_encoder_setup_ddc(encoder
);
1486 /* bridge chips are always aux */
1487 if (radeon_ddc_probe(radeon_connector
, true)) /* try DDC */
1488 ret
= connector_status_connected
;
1489 else if (radeon_connector
->dac_load_detect
) { /* try load detection */
1490 struct drm_encoder_helper_funcs
*encoder_funcs
= encoder
->helper_private
;
1491 ret
= encoder_funcs
->detect(encoder
, connector
);
1495 radeon_dig_connector
->dp_sink_type
= radeon_dp_getsinktype(radeon_connector
);
1496 if (radeon_hpd_sense(rdev
, radeon_connector
->hpd
.hpd
)) {
1497 ret
= connector_status_connected
;
1498 if (radeon_dig_connector
->dp_sink_type
== CONNECTOR_OBJECT_ID_DISPLAYPORT
)
1499 radeon_dp_getdpcd(radeon_connector
);
1501 if (radeon_dig_connector
->dp_sink_type
== CONNECTOR_OBJECT_ID_DISPLAYPORT
) {
1502 if (radeon_dp_getdpcd(radeon_connector
))
1503 ret
= connector_status_connected
;
1505 /* try non-aux ddc (DP to DVI/HDMI/etc. adapter) */
1506 if (radeon_ddc_probe(radeon_connector
, false))
1507 ret
= connector_status_connected
;
1512 radeon_connector_update_scratch_regs(connector
, ret
);
1514 pm_runtime_mark_last_busy(connector
->dev
->dev
);
1515 pm_runtime_put_autosuspend(connector
->dev
->dev
);
1520 static int radeon_dp_mode_valid(struct drm_connector
*connector
,
1521 struct drm_display_mode
*mode
)
1523 struct drm_device
*dev
= connector
->dev
;
1524 struct radeon_device
*rdev
= dev
->dev_private
;
1525 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1526 struct radeon_connector_atom_dig
*radeon_dig_connector
= radeon_connector
->con_priv
;
1528 /* XXX check mode bandwidth */
1530 if ((connector
->connector_type
== DRM_MODE_CONNECTOR_eDP
) ||
1531 (connector
->connector_type
== DRM_MODE_CONNECTOR_LVDS
)) {
1532 struct drm_encoder
*encoder
= radeon_best_single_encoder(connector
);
1534 if ((mode
->hdisplay
< 320) || (mode
->vdisplay
< 240))
1538 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
1539 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
1541 /* AVIVO hardware supports downscaling modes larger than the panel
1542 * to the panel size, but I'm not sure this is desirable.
1544 if ((mode
->hdisplay
> native_mode
->hdisplay
) ||
1545 (mode
->vdisplay
> native_mode
->vdisplay
))
1548 /* if scaling is disabled, block non-native modes */
1549 if (radeon_encoder
->rmx_type
== RMX_OFF
) {
1550 if ((mode
->hdisplay
!= native_mode
->hdisplay
) ||
1551 (mode
->vdisplay
!= native_mode
->vdisplay
))
1556 if ((radeon_dig_connector
->dp_sink_type
== CONNECTOR_OBJECT_ID_DISPLAYPORT
) ||
1557 (radeon_dig_connector
->dp_sink_type
== CONNECTOR_OBJECT_ID_eDP
)) {
1558 return radeon_dp_mode_valid_helper(connector
, mode
);
1560 if (ASIC_IS_DCE6(rdev
) && drm_detect_hdmi_monitor(radeon_connector
->edid
)) {
1561 /* HDMI 1.3+ supports max clock of 340 Mhz */
1562 if (mode
->clock
> 340000)
1563 return MODE_CLOCK_HIGH
;
1565 if (mode
->clock
> 165000)
1566 return MODE_CLOCK_HIGH
;
1574 static const struct drm_connector_helper_funcs radeon_dp_connector_helper_funcs
= {
1575 .get_modes
= radeon_dp_get_modes
,
1576 .mode_valid
= radeon_dp_mode_valid
,
1577 .best_encoder
= radeon_dvi_encoder
,
1580 static const struct drm_connector_funcs radeon_dp_connector_funcs
= {
1581 .dpms
= drm_helper_connector_dpms
,
1582 .detect
= radeon_dp_detect
,
1583 .fill_modes
= drm_helper_probe_single_connector_modes
,
1584 .set_property
= radeon_connector_set_property
,
1585 .destroy
= radeon_connector_destroy
,
1586 .force
= radeon_dvi_force
,
1589 static const struct drm_connector_funcs radeon_edp_connector_funcs
= {
1590 .dpms
= drm_helper_connector_dpms
,
1591 .detect
= radeon_dp_detect
,
1592 .fill_modes
= drm_helper_probe_single_connector_modes
,
1593 .set_property
= radeon_lvds_set_property
,
1594 .destroy
= radeon_connector_destroy
,
1595 .force
= radeon_dvi_force
,
1598 static const struct drm_connector_funcs radeon_lvds_bridge_connector_funcs
= {
1599 .dpms
= drm_helper_connector_dpms
,
1600 .detect
= radeon_dp_detect
,
1601 .fill_modes
= drm_helper_probe_single_connector_modes
,
1602 .set_property
= radeon_lvds_set_property
,
1603 .destroy
= radeon_connector_destroy
,
1604 .force
= radeon_dvi_force
,
1608 radeon_add_atom_connector(struct drm_device
*dev
,
1609 uint32_t connector_id
,
1610 uint32_t supported_device
,
1612 struct radeon_i2c_bus_rec
*i2c_bus
,
1613 uint32_t igp_lane_info
,
1614 uint16_t connector_object_id
,
1615 struct radeon_hpd
*hpd
,
1616 struct radeon_router
*router
)
1618 struct radeon_device
*rdev
= dev
->dev_private
;
1619 struct drm_connector
*connector
;
1620 struct radeon_connector
*radeon_connector
;
1621 struct radeon_connector_atom_dig
*radeon_dig_connector
;
1622 struct drm_encoder
*encoder
;
1623 struct radeon_encoder
*radeon_encoder
;
1624 uint32_t subpixel_order
= SubPixelNone
;
1625 bool shared_ddc
= false;
1626 bool is_dp_bridge
= false;
1627 bool has_aux
= false;
1629 if (connector_type
== DRM_MODE_CONNECTOR_Unknown
)
1632 /* if the user selected tv=0 don't try and add the connector */
1633 if (((connector_type
== DRM_MODE_CONNECTOR_SVIDEO
) ||
1634 (connector_type
== DRM_MODE_CONNECTOR_Composite
) ||
1635 (connector_type
== DRM_MODE_CONNECTOR_9PinDIN
)) &&
1639 /* see if we already added it */
1640 list_for_each_entry(connector
, &dev
->mode_config
.connector_list
, head
) {
1641 radeon_connector
= to_radeon_connector(connector
);
1642 if (radeon_connector
->connector_id
== connector_id
) {
1643 radeon_connector
->devices
|= supported_device
;
1646 if (radeon_connector
->ddc_bus
&& i2c_bus
->valid
) {
1647 if (radeon_connector
->ddc_bus
->rec
.i2c_id
== i2c_bus
->i2c_id
) {
1648 radeon_connector
->shared_ddc
= true;
1651 if (radeon_connector
->router_bus
&& router
->ddc_valid
&&
1652 (radeon_connector
->router
.router_id
== router
->router_id
)) {
1653 radeon_connector
->shared_ddc
= false;
1659 /* check if it's a dp bridge */
1660 list_for_each_entry(encoder
, &dev
->mode_config
.encoder_list
, head
) {
1661 radeon_encoder
= to_radeon_encoder(encoder
);
1662 if (radeon_encoder
->devices
& supported_device
) {
1663 switch (radeon_encoder
->encoder_id
) {
1664 case ENCODER_OBJECT_ID_TRAVIS
:
1665 case ENCODER_OBJECT_ID_NUTMEG
:
1666 is_dp_bridge
= true;
1674 radeon_connector
= kzalloc(sizeof(struct radeon_connector
), GFP_KERNEL
);
1675 if (!radeon_connector
)
1678 connector
= &radeon_connector
->base
;
1680 radeon_connector
->connector_id
= connector_id
;
1681 radeon_connector
->devices
= supported_device
;
1682 radeon_connector
->shared_ddc
= shared_ddc
;
1683 radeon_connector
->connector_object_id
= connector_object_id
;
1684 radeon_connector
->hpd
= *hpd
;
1686 radeon_connector
->router
= *router
;
1687 if (router
->ddc_valid
|| router
->cd_valid
) {
1688 radeon_connector
->router_bus
= radeon_i2c_lookup(rdev
, &router
->i2c_info
);
1689 if (!radeon_connector
->router_bus
)
1690 DRM_ERROR("Failed to assign router i2c bus! Check dmesg for i2c errors.\n");
1694 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
1695 if (!radeon_dig_connector
)
1697 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
1698 radeon_connector
->con_priv
= radeon_dig_connector
;
1699 if (i2c_bus
->valid
) {
1700 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1701 if (radeon_connector
->ddc_bus
)
1704 DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1706 switch (connector_type
) {
1707 case DRM_MODE_CONNECTOR_VGA
:
1708 case DRM_MODE_CONNECTOR_DVIA
:
1710 drm_connector_init(dev
, &radeon_connector
->base
,
1711 &radeon_dp_connector_funcs
, connector_type
);
1712 drm_connector_helper_add(&radeon_connector
->base
,
1713 &radeon_dp_connector_helper_funcs
);
1714 connector
->interlace_allowed
= true;
1715 connector
->doublescan_allowed
= true;
1716 radeon_connector
->dac_load_detect
= true;
1717 drm_object_attach_property(&radeon_connector
->base
.base
,
1718 rdev
->mode_info
.load_detect_property
,
1721 case DRM_MODE_CONNECTOR_DVII
:
1722 case DRM_MODE_CONNECTOR_DVID
:
1723 case DRM_MODE_CONNECTOR_HDMIA
:
1724 case DRM_MODE_CONNECTOR_HDMIB
:
1725 case DRM_MODE_CONNECTOR_DisplayPort
:
1726 drm_connector_init(dev
, &radeon_connector
->base
,
1727 &radeon_dp_connector_funcs
, connector_type
);
1728 drm_connector_helper_add(&radeon_connector
->base
,
1729 &radeon_dp_connector_helper_funcs
);
1730 drm_object_attach_property(&radeon_connector
->base
.base
,
1731 rdev
->mode_info
.underscan_property
,
1733 drm_object_attach_property(&radeon_connector
->base
.base
,
1734 rdev
->mode_info
.underscan_hborder_property
,
1736 drm_object_attach_property(&radeon_connector
->base
.base
,
1737 rdev
->mode_info
.underscan_vborder_property
,
1740 drm_object_attach_property(&radeon_connector
->base
.base
,
1741 rdev
->mode_info
.dither_property
,
1742 RADEON_FMT_DITHER_DISABLE
);
1744 if (radeon_audio
!= 0)
1745 drm_object_attach_property(&radeon_connector
->base
.base
,
1746 rdev
->mode_info
.audio_property
,
1749 subpixel_order
= SubPixelHorizontalRGB
;
1750 connector
->interlace_allowed
= true;
1751 if (connector_type
== DRM_MODE_CONNECTOR_HDMIB
)
1752 connector
->doublescan_allowed
= true;
1754 connector
->doublescan_allowed
= false;
1755 if (connector_type
== DRM_MODE_CONNECTOR_DVII
) {
1756 radeon_connector
->dac_load_detect
= true;
1757 drm_object_attach_property(&radeon_connector
->base
.base
,
1758 rdev
->mode_info
.load_detect_property
,
1762 case DRM_MODE_CONNECTOR_LVDS
:
1763 case DRM_MODE_CONNECTOR_eDP
:
1764 drm_connector_init(dev
, &radeon_connector
->base
,
1765 &radeon_lvds_bridge_connector_funcs
, connector_type
);
1766 drm_connector_helper_add(&radeon_connector
->base
,
1767 &radeon_dp_connector_helper_funcs
);
1768 drm_object_attach_property(&radeon_connector
->base
.base
,
1769 dev
->mode_config
.scaling_mode_property
,
1770 DRM_MODE_SCALE_FULLSCREEN
);
1771 subpixel_order
= SubPixelHorizontalRGB
;
1772 connector
->interlace_allowed
= false;
1773 connector
->doublescan_allowed
= false;
1777 switch (connector_type
) {
1778 case DRM_MODE_CONNECTOR_VGA
:
1779 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_vga_connector_funcs
, connector_type
);
1780 drm_connector_helper_add(&radeon_connector
->base
, &radeon_vga_connector_helper_funcs
);
1781 if (i2c_bus
->valid
) {
1782 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1783 if (!radeon_connector
->ddc_bus
)
1784 DRM_ERROR("VGA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1786 radeon_connector
->dac_load_detect
= true;
1787 drm_object_attach_property(&radeon_connector
->base
.base
,
1788 rdev
->mode_info
.load_detect_property
,
1790 /* no HPD on analog connectors */
1791 radeon_connector
->hpd
.hpd
= RADEON_HPD_NONE
;
1792 connector
->polled
= DRM_CONNECTOR_POLL_CONNECT
;
1793 connector
->interlace_allowed
= true;
1794 connector
->doublescan_allowed
= true;
1796 case DRM_MODE_CONNECTOR_DVIA
:
1797 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_vga_connector_funcs
, connector_type
);
1798 drm_connector_helper_add(&radeon_connector
->base
, &radeon_vga_connector_helper_funcs
);
1799 if (i2c_bus
->valid
) {
1800 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1801 if (!radeon_connector
->ddc_bus
)
1802 DRM_ERROR("DVIA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1804 radeon_connector
->dac_load_detect
= true;
1805 drm_object_attach_property(&radeon_connector
->base
.base
,
1806 rdev
->mode_info
.load_detect_property
,
1808 /* no HPD on analog connectors */
1809 radeon_connector
->hpd
.hpd
= RADEON_HPD_NONE
;
1810 connector
->interlace_allowed
= true;
1811 connector
->doublescan_allowed
= true;
1813 case DRM_MODE_CONNECTOR_DVII
:
1814 case DRM_MODE_CONNECTOR_DVID
:
1815 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
1816 if (!radeon_dig_connector
)
1818 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
1819 radeon_connector
->con_priv
= radeon_dig_connector
;
1820 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_dvi_connector_funcs
, connector_type
);
1821 drm_connector_helper_add(&radeon_connector
->base
, &radeon_dvi_connector_helper_funcs
);
1822 if (i2c_bus
->valid
) {
1823 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1824 if (!radeon_connector
->ddc_bus
)
1825 DRM_ERROR("DVI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1827 subpixel_order
= SubPixelHorizontalRGB
;
1828 drm_object_attach_property(&radeon_connector
->base
.base
,
1829 rdev
->mode_info
.coherent_mode_property
,
1831 if (ASIC_IS_AVIVO(rdev
)) {
1832 drm_object_attach_property(&radeon_connector
->base
.base
,
1833 rdev
->mode_info
.underscan_property
,
1835 drm_object_attach_property(&radeon_connector
->base
.base
,
1836 rdev
->mode_info
.underscan_hborder_property
,
1838 drm_object_attach_property(&radeon_connector
->base
.base
,
1839 rdev
->mode_info
.underscan_vborder_property
,
1842 if (ASIC_IS_DCE2(rdev
) && (radeon_audio
!= 0)) {
1843 drm_object_attach_property(&radeon_connector
->base
.base
,
1844 rdev
->mode_info
.audio_property
,
1847 if (ASIC_IS_AVIVO(rdev
)) {
1848 drm_object_attach_property(&radeon_connector
->base
.base
,
1849 rdev
->mode_info
.dither_property
,
1850 RADEON_FMT_DITHER_DISABLE
);
1852 if (connector_type
== DRM_MODE_CONNECTOR_DVII
) {
1853 radeon_connector
->dac_load_detect
= true;
1854 drm_object_attach_property(&radeon_connector
->base
.base
,
1855 rdev
->mode_info
.load_detect_property
,
1858 connector
->interlace_allowed
= true;
1859 if (connector_type
== DRM_MODE_CONNECTOR_DVII
)
1860 connector
->doublescan_allowed
= true;
1862 connector
->doublescan_allowed
= false;
1864 case DRM_MODE_CONNECTOR_HDMIA
:
1865 case DRM_MODE_CONNECTOR_HDMIB
:
1866 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
1867 if (!radeon_dig_connector
)
1869 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
1870 radeon_connector
->con_priv
= radeon_dig_connector
;
1871 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_dvi_connector_funcs
, connector_type
);
1872 drm_connector_helper_add(&radeon_connector
->base
, &radeon_dvi_connector_helper_funcs
);
1873 if (i2c_bus
->valid
) {
1874 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1875 if (!radeon_connector
->ddc_bus
)
1876 DRM_ERROR("HDMI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1878 drm_object_attach_property(&radeon_connector
->base
.base
,
1879 rdev
->mode_info
.coherent_mode_property
,
1881 if (ASIC_IS_AVIVO(rdev
)) {
1882 drm_object_attach_property(&radeon_connector
->base
.base
,
1883 rdev
->mode_info
.underscan_property
,
1885 drm_object_attach_property(&radeon_connector
->base
.base
,
1886 rdev
->mode_info
.underscan_hborder_property
,
1888 drm_object_attach_property(&radeon_connector
->base
.base
,
1889 rdev
->mode_info
.underscan_vborder_property
,
1892 if (ASIC_IS_DCE2(rdev
) && (radeon_audio
!= 0)) {
1893 drm_object_attach_property(&radeon_connector
->base
.base
,
1894 rdev
->mode_info
.audio_property
,
1897 if (ASIC_IS_AVIVO(rdev
)) {
1898 drm_object_attach_property(&radeon_connector
->base
.base
,
1899 rdev
->mode_info
.dither_property
,
1900 RADEON_FMT_DITHER_DISABLE
);
1902 subpixel_order
= SubPixelHorizontalRGB
;
1903 connector
->interlace_allowed
= true;
1904 if (connector_type
== DRM_MODE_CONNECTOR_HDMIB
)
1905 connector
->doublescan_allowed
= true;
1907 connector
->doublescan_allowed
= false;
1909 case DRM_MODE_CONNECTOR_DisplayPort
:
1910 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
1911 if (!radeon_dig_connector
)
1913 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
1914 radeon_connector
->con_priv
= radeon_dig_connector
;
1915 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_dp_connector_funcs
, connector_type
);
1916 drm_connector_helper_add(&radeon_connector
->base
, &radeon_dp_connector_helper_funcs
);
1917 if (i2c_bus
->valid
) {
1918 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1919 if (radeon_connector
->ddc_bus
)
1922 DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1924 subpixel_order
= SubPixelHorizontalRGB
;
1925 drm_object_attach_property(&radeon_connector
->base
.base
,
1926 rdev
->mode_info
.coherent_mode_property
,
1928 if (ASIC_IS_AVIVO(rdev
)) {
1929 drm_object_attach_property(&radeon_connector
->base
.base
,
1930 rdev
->mode_info
.underscan_property
,
1932 drm_object_attach_property(&radeon_connector
->base
.base
,
1933 rdev
->mode_info
.underscan_hborder_property
,
1935 drm_object_attach_property(&radeon_connector
->base
.base
,
1936 rdev
->mode_info
.underscan_vborder_property
,
1939 if (ASIC_IS_DCE2(rdev
) && (radeon_audio
!= 0)) {
1940 drm_object_attach_property(&radeon_connector
->base
.base
,
1941 rdev
->mode_info
.audio_property
,
1944 if (ASIC_IS_AVIVO(rdev
)) {
1945 drm_object_attach_property(&radeon_connector
->base
.base
,
1946 rdev
->mode_info
.dither_property
,
1947 RADEON_FMT_DITHER_DISABLE
);
1950 connector
->interlace_allowed
= true;
1951 /* in theory with a DP to VGA converter... */
1952 connector
->doublescan_allowed
= false;
1954 case DRM_MODE_CONNECTOR_eDP
:
1955 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
1956 if (!radeon_dig_connector
)
1958 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
1959 radeon_connector
->con_priv
= radeon_dig_connector
;
1960 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_edp_connector_funcs
, connector_type
);
1961 drm_connector_helper_add(&radeon_connector
->base
, &radeon_dp_connector_helper_funcs
);
1962 if (i2c_bus
->valid
) {
1963 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1964 if (radeon_connector
->ddc_bus
)
1967 DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1969 drm_object_attach_property(&radeon_connector
->base
.base
,
1970 dev
->mode_config
.scaling_mode_property
,
1971 DRM_MODE_SCALE_FULLSCREEN
);
1972 subpixel_order
= SubPixelHorizontalRGB
;
1973 connector
->interlace_allowed
= false;
1974 connector
->doublescan_allowed
= false;
1976 case DRM_MODE_CONNECTOR_SVIDEO
:
1977 case DRM_MODE_CONNECTOR_Composite
:
1978 case DRM_MODE_CONNECTOR_9PinDIN
:
1979 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_tv_connector_funcs
, connector_type
);
1980 drm_connector_helper_add(&radeon_connector
->base
, &radeon_tv_connector_helper_funcs
);
1981 radeon_connector
->dac_load_detect
= true;
1982 drm_object_attach_property(&radeon_connector
->base
.base
,
1983 rdev
->mode_info
.load_detect_property
,
1985 drm_object_attach_property(&radeon_connector
->base
.base
,
1986 rdev
->mode_info
.tv_std_property
,
1987 radeon_atombios_get_tv_info(rdev
));
1988 /* no HPD on analog connectors */
1989 radeon_connector
->hpd
.hpd
= RADEON_HPD_NONE
;
1990 connector
->interlace_allowed
= false;
1991 connector
->doublescan_allowed
= false;
1993 case DRM_MODE_CONNECTOR_LVDS
:
1994 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
1995 if (!radeon_dig_connector
)
1997 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
1998 radeon_connector
->con_priv
= radeon_dig_connector
;
1999 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_lvds_connector_funcs
, connector_type
);
2000 drm_connector_helper_add(&radeon_connector
->base
, &radeon_lvds_connector_helper_funcs
);
2001 if (i2c_bus
->valid
) {
2002 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
2003 if (!radeon_connector
->ddc_bus
)
2004 DRM_ERROR("LVDS: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2006 drm_object_attach_property(&radeon_connector
->base
.base
,
2007 dev
->mode_config
.scaling_mode_property
,
2008 DRM_MODE_SCALE_FULLSCREEN
);
2009 subpixel_order
= SubPixelHorizontalRGB
;
2010 connector
->interlace_allowed
= false;
2011 connector
->doublescan_allowed
= false;
2016 if (radeon_connector
->hpd
.hpd
== RADEON_HPD_NONE
) {
2018 connector
->polled
= DRM_CONNECTOR_POLL_CONNECT
;
2020 connector
->polled
= DRM_CONNECTOR_POLL_HPD
;
2022 connector
->display_info
.subpixel_order
= subpixel_order
;
2023 drm_connector_register(connector
);
2026 radeon_dp_aux_init(radeon_connector
);
2031 drm_connector_cleanup(connector
);
2036 radeon_add_legacy_connector(struct drm_device
*dev
,
2037 uint32_t connector_id
,
2038 uint32_t supported_device
,
2040 struct radeon_i2c_bus_rec
*i2c_bus
,
2041 uint16_t connector_object_id
,
2042 struct radeon_hpd
*hpd
)
2044 struct radeon_device
*rdev
= dev
->dev_private
;
2045 struct drm_connector
*connector
;
2046 struct radeon_connector
*radeon_connector
;
2047 uint32_t subpixel_order
= SubPixelNone
;
2049 if (connector_type
== DRM_MODE_CONNECTOR_Unknown
)
2052 /* if the user selected tv=0 don't try and add the connector */
2053 if (((connector_type
== DRM_MODE_CONNECTOR_SVIDEO
) ||
2054 (connector_type
== DRM_MODE_CONNECTOR_Composite
) ||
2055 (connector_type
== DRM_MODE_CONNECTOR_9PinDIN
)) &&
2059 /* see if we already added it */
2060 list_for_each_entry(connector
, &dev
->mode_config
.connector_list
, head
) {
2061 radeon_connector
= to_radeon_connector(connector
);
2062 if (radeon_connector
->connector_id
== connector_id
) {
2063 radeon_connector
->devices
|= supported_device
;
2068 radeon_connector
= kzalloc(sizeof(struct radeon_connector
), GFP_KERNEL
);
2069 if (!radeon_connector
)
2072 connector
= &radeon_connector
->base
;
2074 radeon_connector
->connector_id
= connector_id
;
2075 radeon_connector
->devices
= supported_device
;
2076 radeon_connector
->connector_object_id
= connector_object_id
;
2077 radeon_connector
->hpd
= *hpd
;
2079 switch (connector_type
) {
2080 case DRM_MODE_CONNECTOR_VGA
:
2081 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_vga_connector_funcs
, connector_type
);
2082 drm_connector_helper_add(&radeon_connector
->base
, &radeon_vga_connector_helper_funcs
);
2083 if (i2c_bus
->valid
) {
2084 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
2085 if (!radeon_connector
->ddc_bus
)
2086 DRM_ERROR("VGA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2088 radeon_connector
->dac_load_detect
= true;
2089 drm_object_attach_property(&radeon_connector
->base
.base
,
2090 rdev
->mode_info
.load_detect_property
,
2092 /* no HPD on analog connectors */
2093 radeon_connector
->hpd
.hpd
= RADEON_HPD_NONE
;
2094 connector
->polled
= DRM_CONNECTOR_POLL_CONNECT
;
2095 connector
->interlace_allowed
= true;
2096 connector
->doublescan_allowed
= true;
2098 case DRM_MODE_CONNECTOR_DVIA
:
2099 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_vga_connector_funcs
, connector_type
);
2100 drm_connector_helper_add(&radeon_connector
->base
, &radeon_vga_connector_helper_funcs
);
2101 if (i2c_bus
->valid
) {
2102 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
2103 if (!radeon_connector
->ddc_bus
)
2104 DRM_ERROR("DVIA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2106 radeon_connector
->dac_load_detect
= true;
2107 drm_object_attach_property(&radeon_connector
->base
.base
,
2108 rdev
->mode_info
.load_detect_property
,
2110 /* no HPD on analog connectors */
2111 radeon_connector
->hpd
.hpd
= RADEON_HPD_NONE
;
2112 connector
->interlace_allowed
= true;
2113 connector
->doublescan_allowed
= true;
2115 case DRM_MODE_CONNECTOR_DVII
:
2116 case DRM_MODE_CONNECTOR_DVID
:
2117 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_dvi_connector_funcs
, connector_type
);
2118 drm_connector_helper_add(&radeon_connector
->base
, &radeon_dvi_connector_helper_funcs
);
2119 if (i2c_bus
->valid
) {
2120 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
2121 if (!radeon_connector
->ddc_bus
)
2122 DRM_ERROR("DVI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2124 if (connector_type
== DRM_MODE_CONNECTOR_DVII
) {
2125 radeon_connector
->dac_load_detect
= true;
2126 drm_object_attach_property(&radeon_connector
->base
.base
,
2127 rdev
->mode_info
.load_detect_property
,
2130 subpixel_order
= SubPixelHorizontalRGB
;
2131 connector
->interlace_allowed
= true;
2132 if (connector_type
== DRM_MODE_CONNECTOR_DVII
)
2133 connector
->doublescan_allowed
= true;
2135 connector
->doublescan_allowed
= false;
2137 case DRM_MODE_CONNECTOR_SVIDEO
:
2138 case DRM_MODE_CONNECTOR_Composite
:
2139 case DRM_MODE_CONNECTOR_9PinDIN
:
2140 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_tv_connector_funcs
, connector_type
);
2141 drm_connector_helper_add(&radeon_connector
->base
, &radeon_tv_connector_helper_funcs
);
2142 radeon_connector
->dac_load_detect
= true;
2143 /* RS400,RC410,RS480 chipset seems to report a lot
2144 * of false positive on load detect, we haven't yet
2145 * found a way to make load detect reliable on those
2146 * chipset, thus just disable it for TV.
2148 if (rdev
->family
== CHIP_RS400
|| rdev
->family
== CHIP_RS480
)
2149 radeon_connector
->dac_load_detect
= false;
2150 drm_object_attach_property(&radeon_connector
->base
.base
,
2151 rdev
->mode_info
.load_detect_property
,
2152 radeon_connector
->dac_load_detect
);
2153 drm_object_attach_property(&radeon_connector
->base
.base
,
2154 rdev
->mode_info
.tv_std_property
,
2155 radeon_combios_get_tv_info(rdev
));
2156 /* no HPD on analog connectors */
2157 radeon_connector
->hpd
.hpd
= RADEON_HPD_NONE
;
2158 connector
->interlace_allowed
= false;
2159 connector
->doublescan_allowed
= false;
2161 case DRM_MODE_CONNECTOR_LVDS
:
2162 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_lvds_connector_funcs
, connector_type
);
2163 drm_connector_helper_add(&radeon_connector
->base
, &radeon_lvds_connector_helper_funcs
);
2164 if (i2c_bus
->valid
) {
2165 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
2166 if (!radeon_connector
->ddc_bus
)
2167 DRM_ERROR("LVDS: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2169 drm_object_attach_property(&radeon_connector
->base
.base
,
2170 dev
->mode_config
.scaling_mode_property
,
2171 DRM_MODE_SCALE_FULLSCREEN
);
2172 subpixel_order
= SubPixelHorizontalRGB
;
2173 connector
->interlace_allowed
= false;
2174 connector
->doublescan_allowed
= false;
2178 if (radeon_connector
->hpd
.hpd
== RADEON_HPD_NONE
) {
2180 connector
->polled
= DRM_CONNECTOR_POLL_CONNECT
;
2182 connector
->polled
= DRM_CONNECTOR_POLL_HPD
;
2183 connector
->display_info
.subpixel_order
= subpixel_order
;
2184 drm_connector_register(connector
);