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(connector
))) {
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(connector
))) {
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(connector
))) {
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(connector
))) {
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
);
201 /* max_tmds_clock missing, but hdmi spec mandates it for deep color. */
202 DRM_DEBUG("%s: Required max tmds clock for HDMI deep color missing. Using 8 bpc.\n",
208 if ((radeon_deep_color
== 0) && (bpc
> 8)) {
209 DRM_DEBUG("%s: Deep color disabled. Set radeon module param deep_color=1 to enable.\n",
214 DRM_DEBUG("%s: Display bpc=%d, returned bpc=%d\n",
215 connector
->name
, connector
->display_info
.bpc
, bpc
);
221 radeon_connector_update_scratch_regs(struct drm_connector
*connector
, enum drm_connector_status status
)
223 struct drm_device
*dev
= connector
->dev
;
224 struct radeon_device
*rdev
= dev
->dev_private
;
225 struct drm_encoder
*best_encoder
= NULL
;
226 struct drm_encoder
*encoder
= NULL
;
227 struct drm_connector_helper_funcs
*connector_funcs
= connector
->helper_private
;
231 best_encoder
= connector_funcs
->best_encoder(connector
);
233 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
234 if (connector
->encoder_ids
[i
] == 0)
237 encoder
= drm_encoder_find(connector
->dev
,
238 connector
->encoder_ids
[i
]);
242 if ((encoder
== best_encoder
) && (status
== connector_status_connected
))
247 if (rdev
->is_atom_bios
)
248 radeon_atombios_connected_scratch_regs(connector
, encoder
, connected
);
250 radeon_combios_connected_scratch_regs(connector
, encoder
, connected
);
255 static struct drm_encoder
*radeon_find_encoder(struct drm_connector
*connector
, int encoder_type
)
257 struct drm_encoder
*encoder
;
260 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
261 if (connector
->encoder_ids
[i
] == 0)
264 encoder
= drm_encoder_find(connector
->dev
, connector
->encoder_ids
[i
]);
268 if (encoder
->encoder_type
== encoder_type
)
274 struct edid
*radeon_connector_edid(struct drm_connector
*connector
)
276 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
277 struct drm_property_blob
*edid_blob
= connector
->edid_blob_ptr
;
279 if (radeon_connector
->edid
) {
280 return radeon_connector
->edid
;
281 } else if (edid_blob
) {
282 struct edid
*edid
= kmemdup(edid_blob
->data
, edid_blob
->length
, GFP_KERNEL
);
284 radeon_connector
->edid
= edid
;
286 return radeon_connector
->edid
;
289 static void radeon_connector_get_edid(struct drm_connector
*connector
)
291 struct drm_device
*dev
= connector
->dev
;
292 struct radeon_device
*rdev
= dev
->dev_private
;
293 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
295 if (radeon_connector
->edid
)
298 /* on hw with routers, select right port */
299 if (radeon_connector
->router
.ddc_valid
)
300 radeon_router_select_ddc_port(radeon_connector
);
302 if ((radeon_connector_encoder_get_dp_bridge_encoder_id(connector
) !=
303 ENCODER_OBJECT_ID_NONE
) &&
304 radeon_connector
->ddc_bus
->has_aux
) {
305 radeon_connector
->edid
= drm_get_edid(connector
,
306 &radeon_connector
->ddc_bus
->aux
.ddc
);
307 } else if ((connector
->connector_type
== DRM_MODE_CONNECTOR_DisplayPort
) ||
308 (connector
->connector_type
== DRM_MODE_CONNECTOR_eDP
)) {
309 struct radeon_connector_atom_dig
*dig
= radeon_connector
->con_priv
;
311 if ((dig
->dp_sink_type
== CONNECTOR_OBJECT_ID_DISPLAYPORT
||
312 dig
->dp_sink_type
== CONNECTOR_OBJECT_ID_eDP
) &&
313 radeon_connector
->ddc_bus
->has_aux
)
314 radeon_connector
->edid
= drm_get_edid(&radeon_connector
->base
,
315 &radeon_connector
->ddc_bus
->aux
.ddc
);
316 else if (radeon_connector
->ddc_bus
)
317 radeon_connector
->edid
= drm_get_edid(&radeon_connector
->base
,
318 &radeon_connector
->ddc_bus
->adapter
);
319 } else if (radeon_connector
->ddc_bus
) {
320 radeon_connector
->edid
= drm_get_edid(&radeon_connector
->base
,
321 &radeon_connector
->ddc_bus
->adapter
);
324 if (!radeon_connector
->edid
) {
325 /* don't fetch the edid from the vbios if ddc fails and runpm is
326 * enabled so we report disconnected.
328 if ((rdev
->flags
& RADEON_IS_PX
) && (radeon_runtime_pm
!= 0))
331 if (rdev
->is_atom_bios
) {
332 /* some laptops provide a hardcoded edid in rom for LCDs */
333 if (((connector
->connector_type
== DRM_MODE_CONNECTOR_LVDS
) ||
334 (connector
->connector_type
== DRM_MODE_CONNECTOR_eDP
)))
335 radeon_connector
->edid
= radeon_bios_get_hardcoded_edid(rdev
);
337 /* some servers provide a hardcoded edid in rom for KVMs */
338 radeon_connector
->edid
= radeon_bios_get_hardcoded_edid(rdev
);
343 static void radeon_connector_free_edid(struct drm_connector
*connector
)
345 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
347 if (radeon_connector
->edid
) {
348 kfree(radeon_connector
->edid
);
349 radeon_connector
->edid
= NULL
;
353 static int radeon_ddc_get_modes(struct drm_connector
*connector
)
355 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
358 if (radeon_connector
->edid
) {
359 drm_mode_connector_update_edid_property(connector
, radeon_connector
->edid
);
360 ret
= drm_add_edid_modes(connector
, radeon_connector
->edid
);
361 drm_edid_to_eld(connector
, radeon_connector
->edid
);
364 drm_mode_connector_update_edid_property(connector
, NULL
);
368 static struct drm_encoder
*radeon_best_single_encoder(struct drm_connector
*connector
)
370 int enc_id
= connector
->encoder_ids
[0];
371 /* pick the encoder ids */
373 return drm_encoder_find(connector
->dev
, enc_id
);
377 static void radeon_get_native_mode(struct drm_connector
*connector
)
379 struct drm_encoder
*encoder
= radeon_best_single_encoder(connector
);
380 struct radeon_encoder
*radeon_encoder
;
385 radeon_encoder
= to_radeon_encoder(encoder
);
387 if (!list_empty(&connector
->probed_modes
)) {
388 struct drm_display_mode
*preferred_mode
=
389 list_first_entry(&connector
->probed_modes
,
390 struct drm_display_mode
, head
);
392 radeon_encoder
->native_mode
= *preferred_mode
;
394 radeon_encoder
->native_mode
.clock
= 0;
399 * radeon_connector_analog_encoder_conflict_solve
400 * - search for other connectors sharing this encoder
401 * if priority is true, then set them disconnected if this is connected
402 * if priority is false, set us disconnected if they are connected
404 static enum drm_connector_status
405 radeon_connector_analog_encoder_conflict_solve(struct drm_connector
*connector
,
406 struct drm_encoder
*encoder
,
407 enum drm_connector_status current_status
,
410 struct drm_device
*dev
= connector
->dev
;
411 struct drm_connector
*conflict
;
412 struct radeon_connector
*radeon_conflict
;
415 list_for_each_entry(conflict
, &dev
->mode_config
.connector_list
, head
) {
416 if (conflict
== connector
)
419 radeon_conflict
= to_radeon_connector(conflict
);
420 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
421 if (conflict
->encoder_ids
[i
] == 0)
424 /* if the IDs match */
425 if (conflict
->encoder_ids
[i
] == encoder
->base
.id
) {
426 if (conflict
->status
!= connector_status_connected
)
429 if (radeon_conflict
->use_digital
)
432 if (priority
== true) {
433 DRM_DEBUG_KMS("1: conflicting encoders switching off %s\n",
435 DRM_DEBUG_KMS("in favor of %s\n",
437 conflict
->status
= connector_status_disconnected
;
438 radeon_connector_update_scratch_regs(conflict
, connector_status_disconnected
);
440 DRM_DEBUG_KMS("2: conflicting encoders switching off %s\n",
442 DRM_DEBUG_KMS("in favor of %s\n",
444 current_status
= connector_status_disconnected
;
450 return current_status
;
454 static struct drm_display_mode
*radeon_fp_native_mode(struct drm_encoder
*encoder
)
456 struct drm_device
*dev
= encoder
->dev
;
457 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
458 struct drm_display_mode
*mode
= NULL
;
459 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
461 if (native_mode
->hdisplay
!= 0 &&
462 native_mode
->vdisplay
!= 0 &&
463 native_mode
->clock
!= 0) {
464 mode
= drm_mode_duplicate(dev
, native_mode
);
465 mode
->type
= DRM_MODE_TYPE_PREFERRED
| DRM_MODE_TYPE_DRIVER
;
466 drm_mode_set_name(mode
);
468 DRM_DEBUG_KMS("Adding native panel mode %s\n", mode
->name
);
469 } else if (native_mode
->hdisplay
!= 0 &&
470 native_mode
->vdisplay
!= 0) {
471 /* mac laptops without an edid */
472 /* Note that this is not necessarily the exact panel mode,
473 * but an approximation based on the cvt formula. For these
474 * systems we should ideally read the mode info out of the
475 * registers or add a mode table, but this works and is much
478 mode
= drm_cvt_mode(dev
, native_mode
->hdisplay
, native_mode
->vdisplay
, 60, true, false, false);
479 mode
->type
= DRM_MODE_TYPE_PREFERRED
| DRM_MODE_TYPE_DRIVER
;
480 DRM_DEBUG_KMS("Adding cvt approximation of native panel mode %s\n", mode
->name
);
485 static void radeon_add_common_modes(struct drm_encoder
*encoder
, struct drm_connector
*connector
)
487 struct drm_device
*dev
= encoder
->dev
;
488 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
489 struct drm_display_mode
*mode
= NULL
;
490 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
495 } common_modes
[17] = {
515 for (i
= 0; i
< 17; i
++) {
516 if (radeon_encoder
->devices
& (ATOM_DEVICE_TV_SUPPORT
)) {
517 if (common_modes
[i
].w
> 1024 ||
518 common_modes
[i
].h
> 768)
521 if (radeon_encoder
->devices
& (ATOM_DEVICE_LCD_SUPPORT
)) {
522 if (common_modes
[i
].w
> native_mode
->hdisplay
||
523 common_modes
[i
].h
> native_mode
->vdisplay
||
524 (common_modes
[i
].w
== native_mode
->hdisplay
&&
525 common_modes
[i
].h
== native_mode
->vdisplay
))
528 if (common_modes
[i
].w
< 320 || common_modes
[i
].h
< 200)
531 mode
= drm_cvt_mode(dev
, common_modes
[i
].w
, common_modes
[i
].h
, 60, false, false, false);
532 drm_mode_probed_add(connector
, mode
);
536 static int radeon_connector_set_property(struct drm_connector
*connector
, struct drm_property
*property
,
539 struct drm_device
*dev
= connector
->dev
;
540 struct radeon_device
*rdev
= dev
->dev_private
;
541 struct drm_encoder
*encoder
;
542 struct radeon_encoder
*radeon_encoder
;
544 if (property
== rdev
->mode_info
.coherent_mode_property
) {
545 struct radeon_encoder_atom_dig
*dig
;
546 bool new_coherent_mode
;
548 /* need to find digital encoder on connector */
549 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TMDS
);
553 radeon_encoder
= to_radeon_encoder(encoder
);
555 if (!radeon_encoder
->enc_priv
)
558 dig
= radeon_encoder
->enc_priv
;
559 new_coherent_mode
= val
? true : false;
560 if (dig
->coherent_mode
!= new_coherent_mode
) {
561 dig
->coherent_mode
= new_coherent_mode
;
562 radeon_property_change_mode(&radeon_encoder
->base
);
566 if (property
== rdev
->mode_info
.audio_property
) {
567 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
568 /* need to find digital encoder on connector */
569 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TMDS
);
573 radeon_encoder
= to_radeon_encoder(encoder
);
575 if (radeon_connector
->audio
!= val
) {
576 radeon_connector
->audio
= val
;
577 radeon_property_change_mode(&radeon_encoder
->base
);
581 if (property
== rdev
->mode_info
.dither_property
) {
582 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
583 /* need to find digital encoder on connector */
584 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TMDS
);
588 radeon_encoder
= to_radeon_encoder(encoder
);
590 if (radeon_connector
->dither
!= val
) {
591 radeon_connector
->dither
= val
;
592 radeon_property_change_mode(&radeon_encoder
->base
);
596 if (property
== rdev
->mode_info
.underscan_property
) {
597 /* need to find digital encoder on connector */
598 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TMDS
);
602 radeon_encoder
= to_radeon_encoder(encoder
);
604 if (radeon_encoder
->underscan_type
!= val
) {
605 radeon_encoder
->underscan_type
= val
;
606 radeon_property_change_mode(&radeon_encoder
->base
);
610 if (property
== rdev
->mode_info
.underscan_hborder_property
) {
611 /* need to find digital encoder on connector */
612 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TMDS
);
616 radeon_encoder
= to_radeon_encoder(encoder
);
618 if (radeon_encoder
->underscan_hborder
!= val
) {
619 radeon_encoder
->underscan_hborder
= val
;
620 radeon_property_change_mode(&radeon_encoder
->base
);
624 if (property
== rdev
->mode_info
.underscan_vborder_property
) {
625 /* need to find digital encoder on connector */
626 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TMDS
);
630 radeon_encoder
= to_radeon_encoder(encoder
);
632 if (radeon_encoder
->underscan_vborder
!= val
) {
633 radeon_encoder
->underscan_vborder
= val
;
634 radeon_property_change_mode(&radeon_encoder
->base
);
638 if (property
== rdev
->mode_info
.tv_std_property
) {
639 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TVDAC
);
641 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_DAC
);
647 radeon_encoder
= to_radeon_encoder(encoder
);
648 if (!radeon_encoder
->enc_priv
)
650 if (ASIC_IS_AVIVO(rdev
) || radeon_r4xx_atom
) {
651 struct radeon_encoder_atom_dac
*dac_int
;
652 dac_int
= radeon_encoder
->enc_priv
;
653 dac_int
->tv_std
= val
;
655 struct radeon_encoder_tv_dac
*dac_int
;
656 dac_int
= radeon_encoder
->enc_priv
;
657 dac_int
->tv_std
= val
;
659 radeon_property_change_mode(&radeon_encoder
->base
);
662 if (property
== rdev
->mode_info
.load_detect_property
) {
663 struct radeon_connector
*radeon_connector
=
664 to_radeon_connector(connector
);
667 radeon_connector
->dac_load_detect
= false;
669 radeon_connector
->dac_load_detect
= true;
672 if (property
== rdev
->mode_info
.tmds_pll_property
) {
673 struct radeon_encoder_int_tmds
*tmds
= NULL
;
675 /* need to find digital encoder on connector */
676 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TMDS
);
680 radeon_encoder
= to_radeon_encoder(encoder
);
682 tmds
= radeon_encoder
->enc_priv
;
687 if (rdev
->is_atom_bios
)
688 ret
= radeon_atombios_get_tmds_info(radeon_encoder
, tmds
);
690 ret
= radeon_legacy_get_tmds_info_from_combios(radeon_encoder
, tmds
);
692 if (val
== 1 || ret
== false) {
693 radeon_legacy_get_tmds_info_from_table(radeon_encoder
, tmds
);
695 radeon_property_change_mode(&radeon_encoder
->base
);
698 if (property
== dev
->mode_config
.scaling_mode_property
) {
699 enum radeon_rmx_type rmx_type
;
701 if (connector
->encoder
)
702 radeon_encoder
= to_radeon_encoder(connector
->encoder
);
704 struct drm_connector_helper_funcs
*connector_funcs
= connector
->helper_private
;
705 radeon_encoder
= to_radeon_encoder(connector_funcs
->best_encoder(connector
));
710 case DRM_MODE_SCALE_NONE
: rmx_type
= RMX_OFF
; break;
711 case DRM_MODE_SCALE_CENTER
: rmx_type
= RMX_CENTER
; break;
712 case DRM_MODE_SCALE_ASPECT
: rmx_type
= RMX_ASPECT
; break;
713 case DRM_MODE_SCALE_FULLSCREEN
: rmx_type
= RMX_FULL
; break;
715 if (radeon_encoder
->rmx_type
== rmx_type
)
718 if ((rmx_type
!= DRM_MODE_SCALE_NONE
) &&
719 (radeon_encoder
->native_mode
.clock
== 0))
722 radeon_encoder
->rmx_type
= rmx_type
;
724 radeon_property_change_mode(&radeon_encoder
->base
);
730 static void radeon_fixup_lvds_native_mode(struct drm_encoder
*encoder
,
731 struct drm_connector
*connector
)
733 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
734 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
735 struct drm_display_mode
*t
, *mode
;
737 /* If the EDID preferred mode doesn't match the native mode, use it */
738 list_for_each_entry_safe(mode
, t
, &connector
->probed_modes
, head
) {
739 if (mode
->type
& DRM_MODE_TYPE_PREFERRED
) {
740 if (mode
->hdisplay
!= native_mode
->hdisplay
||
741 mode
->vdisplay
!= native_mode
->vdisplay
)
742 memcpy(native_mode
, mode
, sizeof(*mode
));
746 /* Try to get native mode details from EDID if necessary */
747 if (!native_mode
->clock
) {
748 list_for_each_entry_safe(mode
, t
, &connector
->probed_modes
, head
) {
749 if (mode
->hdisplay
== native_mode
->hdisplay
&&
750 mode
->vdisplay
== native_mode
->vdisplay
) {
751 *native_mode
= *mode
;
752 drm_mode_set_crtcinfo(native_mode
, CRTC_INTERLACE_HALVE_V
);
753 DRM_DEBUG_KMS("Determined LVDS native mode details from EDID\n");
759 if (!native_mode
->clock
) {
760 DRM_DEBUG_KMS("No LVDS native mode details, disabling RMX\n");
761 radeon_encoder
->rmx_type
= RMX_OFF
;
765 static int radeon_lvds_get_modes(struct drm_connector
*connector
)
767 struct drm_encoder
*encoder
;
769 struct drm_display_mode
*mode
;
771 radeon_connector_get_edid(connector
);
772 ret
= radeon_ddc_get_modes(connector
);
774 encoder
= radeon_best_single_encoder(connector
);
776 radeon_fixup_lvds_native_mode(encoder
, connector
);
777 /* add scaled modes */
778 radeon_add_common_modes(encoder
, connector
);
783 encoder
= radeon_best_single_encoder(connector
);
787 /* we have no EDID modes */
788 mode
= radeon_fp_native_mode(encoder
);
791 drm_mode_probed_add(connector
, mode
);
792 /* add the width/height from vbios tables if available */
793 connector
->display_info
.width_mm
= mode
->width_mm
;
794 connector
->display_info
.height_mm
= mode
->height_mm
;
795 /* add scaled modes */
796 radeon_add_common_modes(encoder
, connector
);
802 static int radeon_lvds_mode_valid(struct drm_connector
*connector
,
803 struct drm_display_mode
*mode
)
805 struct drm_encoder
*encoder
= radeon_best_single_encoder(connector
);
807 if ((mode
->hdisplay
< 320) || (mode
->vdisplay
< 240))
811 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
812 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
814 /* AVIVO hardware supports downscaling modes larger than the panel
815 * to the panel size, but I'm not sure this is desirable.
817 if ((mode
->hdisplay
> native_mode
->hdisplay
) ||
818 (mode
->vdisplay
> native_mode
->vdisplay
))
821 /* if scaling is disabled, block non-native modes */
822 if (radeon_encoder
->rmx_type
== RMX_OFF
) {
823 if ((mode
->hdisplay
!= native_mode
->hdisplay
) ||
824 (mode
->vdisplay
!= native_mode
->vdisplay
))
832 static enum drm_connector_status
833 radeon_lvds_detect(struct drm_connector
*connector
, bool force
)
835 struct drm_device
*dev
= connector
->dev
;
836 struct radeon_device
*rdev
= dev
->dev_private
;
837 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
838 struct drm_encoder
*encoder
= radeon_best_single_encoder(connector
);
839 enum drm_connector_status ret
= connector_status_disconnected
;
842 r
= pm_runtime_get_sync(connector
->dev
->dev
);
844 return connector_status_disconnected
;
847 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
848 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
850 /* check if panel is valid */
851 if (native_mode
->hdisplay
>= 320 && native_mode
->vdisplay
>= 240)
852 ret
= connector_status_connected
;
853 /* don't fetch the edid from the vbios if ddc fails and runpm is
854 * enabled so we report disconnected.
856 if ((rdev
->flags
& RADEON_IS_PX
) && (radeon_runtime_pm
!= 0))
857 ret
= connector_status_disconnected
;
860 /* check for edid as well */
861 radeon_connector_get_edid(connector
);
862 if (radeon_connector
->edid
)
863 ret
= connector_status_connected
;
864 /* check acpi lid status ??? */
866 radeon_connector_update_scratch_regs(connector
, ret
);
867 pm_runtime_mark_last_busy(connector
->dev
->dev
);
868 pm_runtime_put_autosuspend(connector
->dev
->dev
);
872 static void radeon_connector_destroy(struct drm_connector
*connector
)
874 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
876 radeon_connector_free_edid(connector
);
877 kfree(radeon_connector
->con_priv
);
878 drm_connector_unregister(connector
);
879 drm_connector_cleanup(connector
);
883 static int radeon_lvds_set_property(struct drm_connector
*connector
,
884 struct drm_property
*property
,
887 struct drm_device
*dev
= connector
->dev
;
888 struct radeon_encoder
*radeon_encoder
;
889 enum radeon_rmx_type rmx_type
;
892 if (property
!= dev
->mode_config
.scaling_mode_property
)
895 if (connector
->encoder
)
896 radeon_encoder
= to_radeon_encoder(connector
->encoder
);
898 struct drm_connector_helper_funcs
*connector_funcs
= connector
->helper_private
;
899 radeon_encoder
= to_radeon_encoder(connector_funcs
->best_encoder(connector
));
903 case DRM_MODE_SCALE_NONE
: rmx_type
= RMX_OFF
; break;
904 case DRM_MODE_SCALE_CENTER
: rmx_type
= RMX_CENTER
; break;
905 case DRM_MODE_SCALE_ASPECT
: rmx_type
= RMX_ASPECT
; break;
907 case DRM_MODE_SCALE_FULLSCREEN
: rmx_type
= RMX_FULL
; break;
909 if (radeon_encoder
->rmx_type
== rmx_type
)
912 radeon_encoder
->rmx_type
= rmx_type
;
914 radeon_property_change_mode(&radeon_encoder
->base
);
919 static const struct drm_connector_helper_funcs radeon_lvds_connector_helper_funcs
= {
920 .get_modes
= radeon_lvds_get_modes
,
921 .mode_valid
= radeon_lvds_mode_valid
,
922 .best_encoder
= radeon_best_single_encoder
,
925 static const struct drm_connector_funcs radeon_lvds_connector_funcs
= {
926 .dpms
= drm_helper_connector_dpms
,
927 .detect
= radeon_lvds_detect
,
928 .fill_modes
= drm_helper_probe_single_connector_modes
,
929 .destroy
= radeon_connector_destroy
,
930 .set_property
= radeon_lvds_set_property
,
933 static int radeon_vga_get_modes(struct drm_connector
*connector
)
937 radeon_connector_get_edid(connector
);
938 ret
= radeon_ddc_get_modes(connector
);
940 radeon_get_native_mode(connector
);
945 static int radeon_vga_mode_valid(struct drm_connector
*connector
,
946 struct drm_display_mode
*mode
)
948 struct drm_device
*dev
= connector
->dev
;
949 struct radeon_device
*rdev
= dev
->dev_private
;
951 /* XXX check mode bandwidth */
953 if ((mode
->clock
/ 10) > rdev
->clock
.max_pixel_clock
)
954 return MODE_CLOCK_HIGH
;
959 static enum drm_connector_status
960 radeon_vga_detect(struct drm_connector
*connector
, bool force
)
962 struct drm_device
*dev
= connector
->dev
;
963 struct radeon_device
*rdev
= dev
->dev_private
;
964 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
965 struct drm_encoder
*encoder
;
966 struct drm_encoder_helper_funcs
*encoder_funcs
;
968 enum drm_connector_status ret
= connector_status_disconnected
;
971 r
= pm_runtime_get_sync(connector
->dev
->dev
);
973 return connector_status_disconnected
;
975 encoder
= radeon_best_single_encoder(connector
);
977 ret
= connector_status_disconnected
;
979 if (radeon_connector
->ddc_bus
)
980 dret
= radeon_ddc_probe(radeon_connector
, false);
982 radeon_connector
->detected_by_load
= false;
983 radeon_connector_free_edid(connector
);
984 radeon_connector_get_edid(connector
);
986 if (!radeon_connector
->edid
) {
987 DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
989 ret
= connector_status_connected
;
991 radeon_connector
->use_digital
=
992 !!(radeon_connector
->edid
->input
& DRM_EDID_INPUT_DIGITAL
);
994 /* some oems have boards with separate digital and analog connectors
995 * with a shared ddc line (often vga + hdmi)
997 if (radeon_connector
->use_digital
&& radeon_connector
->shared_ddc
) {
998 radeon_connector_free_edid(connector
);
999 ret
= connector_status_disconnected
;
1001 ret
= connector_status_connected
;
1006 /* if we aren't forcing don't do destructive polling */
1008 /* only return the previous status if we last
1009 * detected a monitor via load.
1011 if (radeon_connector
->detected_by_load
)
1012 ret
= connector
->status
;
1016 if (radeon_connector
->dac_load_detect
&& encoder
) {
1017 encoder_funcs
= encoder
->helper_private
;
1018 ret
= encoder_funcs
->detect(encoder
, connector
);
1019 if (ret
!= connector_status_disconnected
)
1020 radeon_connector
->detected_by_load
= true;
1024 if (ret
== connector_status_connected
)
1025 ret
= radeon_connector_analog_encoder_conflict_solve(connector
, encoder
, ret
, true);
1027 /* RN50 and some RV100 asics in servers often have a hardcoded EDID in the
1028 * vbios to deal with KVMs. If we have one and are not able to detect a monitor
1029 * by other means, assume the CRT is connected and use that EDID.
1031 if ((!rdev
->is_atom_bios
) &&
1032 (ret
== connector_status_disconnected
) &&
1033 rdev
->mode_info
.bios_hardcoded_edid_size
) {
1034 ret
= connector_status_connected
;
1037 radeon_connector_update_scratch_regs(connector
, ret
);
1040 pm_runtime_mark_last_busy(connector
->dev
->dev
);
1041 pm_runtime_put_autosuspend(connector
->dev
->dev
);
1046 static const struct drm_connector_helper_funcs radeon_vga_connector_helper_funcs
= {
1047 .get_modes
= radeon_vga_get_modes
,
1048 .mode_valid
= radeon_vga_mode_valid
,
1049 .best_encoder
= radeon_best_single_encoder
,
1052 static const struct drm_connector_funcs radeon_vga_connector_funcs
= {
1053 .dpms
= drm_helper_connector_dpms
,
1054 .detect
= radeon_vga_detect
,
1055 .fill_modes
= drm_helper_probe_single_connector_modes
,
1056 .destroy
= radeon_connector_destroy
,
1057 .set_property
= radeon_connector_set_property
,
1060 static int radeon_tv_get_modes(struct drm_connector
*connector
)
1062 struct drm_device
*dev
= connector
->dev
;
1063 struct radeon_device
*rdev
= dev
->dev_private
;
1064 struct drm_display_mode
*tv_mode
;
1065 struct drm_encoder
*encoder
;
1067 encoder
= radeon_best_single_encoder(connector
);
1071 /* avivo chips can scale any mode */
1072 if (rdev
->family
>= CHIP_RS600
)
1073 /* add scaled modes */
1074 radeon_add_common_modes(encoder
, connector
);
1076 /* only 800x600 is supported right now on pre-avivo chips */
1077 tv_mode
= drm_cvt_mode(dev
, 800, 600, 60, false, false, false);
1078 tv_mode
->type
= DRM_MODE_TYPE_DRIVER
| DRM_MODE_TYPE_PREFERRED
;
1079 drm_mode_probed_add(connector
, tv_mode
);
1084 static int radeon_tv_mode_valid(struct drm_connector
*connector
,
1085 struct drm_display_mode
*mode
)
1087 if ((mode
->hdisplay
> 1024) || (mode
->vdisplay
> 768))
1088 return MODE_CLOCK_RANGE
;
1092 static enum drm_connector_status
1093 radeon_tv_detect(struct drm_connector
*connector
, bool force
)
1095 struct drm_encoder
*encoder
;
1096 struct drm_encoder_helper_funcs
*encoder_funcs
;
1097 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1098 enum drm_connector_status ret
= connector_status_disconnected
;
1101 if (!radeon_connector
->dac_load_detect
)
1104 r
= pm_runtime_get_sync(connector
->dev
->dev
);
1106 return connector_status_disconnected
;
1108 encoder
= radeon_best_single_encoder(connector
);
1110 ret
= connector_status_disconnected
;
1112 encoder_funcs
= encoder
->helper_private
;
1113 ret
= encoder_funcs
->detect(encoder
, connector
);
1115 if (ret
== connector_status_connected
)
1116 ret
= radeon_connector_analog_encoder_conflict_solve(connector
, encoder
, ret
, false);
1117 radeon_connector_update_scratch_regs(connector
, ret
);
1118 pm_runtime_mark_last_busy(connector
->dev
->dev
);
1119 pm_runtime_put_autosuspend(connector
->dev
->dev
);
1123 static const struct drm_connector_helper_funcs radeon_tv_connector_helper_funcs
= {
1124 .get_modes
= radeon_tv_get_modes
,
1125 .mode_valid
= radeon_tv_mode_valid
,
1126 .best_encoder
= radeon_best_single_encoder
,
1129 static const struct drm_connector_funcs radeon_tv_connector_funcs
= {
1130 .dpms
= drm_helper_connector_dpms
,
1131 .detect
= radeon_tv_detect
,
1132 .fill_modes
= drm_helper_probe_single_connector_modes
,
1133 .destroy
= radeon_connector_destroy
,
1134 .set_property
= radeon_connector_set_property
,
1137 static bool radeon_check_hpd_status_unchanged(struct drm_connector
*connector
)
1139 struct drm_device
*dev
= connector
->dev
;
1140 struct radeon_device
*rdev
= dev
->dev_private
;
1141 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1142 enum drm_connector_status status
;
1144 /* We only trust HPD on R600 and newer ASICS. */
1145 if (rdev
->family
>= CHIP_R600
1146 && radeon_connector
->hpd
.hpd
!= RADEON_HPD_NONE
) {
1147 if (radeon_hpd_sense(rdev
, radeon_connector
->hpd
.hpd
))
1148 status
= connector_status_connected
;
1150 status
= connector_status_disconnected
;
1151 if (connector
->status
== status
)
1159 * DVI is complicated
1160 * Do a DDC probe, if DDC probe passes, get the full EDID so
1161 * we can do analog/digital monitor detection at this point.
1162 * If the monitor is an analog monitor or we got no DDC,
1163 * we need to find the DAC encoder object for this connector.
1164 * If we got no DDC, we do load detection on the DAC encoder object.
1165 * If we got analog DDC or load detection passes on the DAC encoder
1166 * we have to check if this analog encoder is shared with anyone else (TV)
1167 * if its shared we have to set the other connector to disconnected.
1169 static enum drm_connector_status
1170 radeon_dvi_detect(struct drm_connector
*connector
, bool force
)
1172 struct drm_device
*dev
= connector
->dev
;
1173 struct radeon_device
*rdev
= dev
->dev_private
;
1174 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1175 struct drm_encoder
*encoder
= NULL
;
1176 struct drm_encoder_helper_funcs
*encoder_funcs
;
1178 enum drm_connector_status ret
= connector_status_disconnected
;
1179 bool dret
= false, broken_edid
= false;
1181 r
= pm_runtime_get_sync(connector
->dev
->dev
);
1183 return connector_status_disconnected
;
1185 if (!force
&& radeon_check_hpd_status_unchanged(connector
)) {
1186 ret
= connector
->status
;
1190 if (radeon_connector
->ddc_bus
)
1191 dret
= radeon_ddc_probe(radeon_connector
, false);
1193 radeon_connector
->detected_by_load
= false;
1194 radeon_connector_free_edid(connector
);
1195 radeon_connector_get_edid(connector
);
1197 if (!radeon_connector
->edid
) {
1198 DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
1200 /* rs690 seems to have a problem with connectors not existing and always
1201 * return a block of 0's. If we see this just stop polling on this output */
1202 if ((rdev
->family
== CHIP_RS690
|| rdev
->family
== CHIP_RS740
) &&
1203 radeon_connector
->base
.null_edid_counter
) {
1204 ret
= connector_status_disconnected
;
1205 DRM_ERROR("%s: detected RS690 floating bus bug, stopping ddc detect\n",
1207 radeon_connector
->ddc_bus
= NULL
;
1209 ret
= connector_status_connected
;
1210 broken_edid
= true; /* defer use_digital to later */
1213 radeon_connector
->use_digital
=
1214 !!(radeon_connector
->edid
->input
& DRM_EDID_INPUT_DIGITAL
);
1216 /* some oems have boards with separate digital and analog connectors
1217 * with a shared ddc line (often vga + hdmi)
1219 if ((!radeon_connector
->use_digital
) && radeon_connector
->shared_ddc
) {
1220 radeon_connector_free_edid(connector
);
1221 ret
= connector_status_disconnected
;
1223 ret
= connector_status_connected
;
1225 /* This gets complicated. We have boards with VGA + HDMI with a
1226 * shared DDC line and we have boards with DVI-D + HDMI with a shared
1227 * DDC line. The latter is more complex because with DVI<->HDMI adapters
1228 * you don't really know what's connected to which port as both are digital.
1230 if (radeon_connector
->shared_ddc
&& (ret
== connector_status_connected
)) {
1231 struct drm_connector
*list_connector
;
1232 struct radeon_connector
*list_radeon_connector
;
1233 list_for_each_entry(list_connector
, &dev
->mode_config
.connector_list
, head
) {
1234 if (connector
== list_connector
)
1236 list_radeon_connector
= to_radeon_connector(list_connector
);
1237 if (list_radeon_connector
->shared_ddc
&&
1238 (list_radeon_connector
->ddc_bus
->rec
.i2c_id
==
1239 radeon_connector
->ddc_bus
->rec
.i2c_id
)) {
1240 /* cases where both connectors are digital */
1241 if (list_connector
->connector_type
!= DRM_MODE_CONNECTOR_VGA
) {
1242 /* hpd is our only option in this case */
1243 if (!radeon_hpd_sense(rdev
, radeon_connector
->hpd
.hpd
)) {
1244 radeon_connector_free_edid(connector
);
1245 ret
= connector_status_disconnected
;
1254 if ((ret
== connector_status_connected
) && (radeon_connector
->use_digital
== true))
1257 /* DVI-D and HDMI-A are digital only */
1258 if ((connector
->connector_type
== DRM_MODE_CONNECTOR_DVID
) ||
1259 (connector
->connector_type
== DRM_MODE_CONNECTOR_HDMIA
))
1262 /* if we aren't forcing don't do destructive polling */
1264 /* only return the previous status if we last
1265 * detected a monitor via load.
1267 if (radeon_connector
->detected_by_load
)
1268 ret
= connector
->status
;
1272 /* find analog encoder */
1273 if (radeon_connector
->dac_load_detect
) {
1274 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
1275 if (connector
->encoder_ids
[i
] == 0)
1278 encoder
= drm_encoder_find(connector
->dev
,
1279 connector
->encoder_ids
[i
]);
1283 if (encoder
->encoder_type
!= DRM_MODE_ENCODER_DAC
&&
1284 encoder
->encoder_type
!= DRM_MODE_ENCODER_TVDAC
)
1287 encoder_funcs
= encoder
->helper_private
;
1288 if (encoder_funcs
->detect
) {
1290 if (ret
!= connector_status_connected
) {
1291 /* deal with analog monitors without DDC */
1292 ret
= encoder_funcs
->detect(encoder
, connector
);
1293 if (ret
== connector_status_connected
) {
1294 radeon_connector
->use_digital
= false;
1296 if (ret
!= connector_status_disconnected
)
1297 radeon_connector
->detected_by_load
= true;
1300 enum drm_connector_status lret
;
1301 /* assume digital unless load detected otherwise */
1302 radeon_connector
->use_digital
= true;
1303 lret
= encoder_funcs
->detect(encoder
, connector
);
1304 DRM_DEBUG_KMS("load_detect %x returned: %x\n",encoder
->encoder_type
,lret
);
1305 if (lret
== connector_status_connected
)
1306 radeon_connector
->use_digital
= false;
1313 if ((ret
== connector_status_connected
) && (radeon_connector
->use_digital
== false) &&
1315 ret
= radeon_connector_analog_encoder_conflict_solve(connector
, encoder
, ret
, true);
1318 /* RN50 and some RV100 asics in servers often have a hardcoded EDID in the
1319 * vbios to deal with KVMs. If we have one and are not able to detect a monitor
1320 * by other means, assume the DFP is connected and use that EDID. In most
1321 * cases the DVI port is actually a virtual KVM port connected to the service
1325 if ((!rdev
->is_atom_bios
) &&
1326 (ret
== connector_status_disconnected
) &&
1327 rdev
->mode_info
.bios_hardcoded_edid_size
) {
1328 radeon_connector
->use_digital
= true;
1329 ret
= connector_status_connected
;
1332 /* updated in get modes as well since we need to know if it's analog or digital */
1333 radeon_connector_update_scratch_regs(connector
, ret
);
1336 pm_runtime_mark_last_busy(connector
->dev
->dev
);
1337 pm_runtime_put_autosuspend(connector
->dev
->dev
);
1342 /* okay need to be smart in here about which encoder to pick */
1343 static struct drm_encoder
*radeon_dvi_encoder(struct drm_connector
*connector
)
1345 int enc_id
= connector
->encoder_ids
[0];
1346 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1347 struct drm_encoder
*encoder
;
1349 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
1350 if (connector
->encoder_ids
[i
] == 0)
1353 encoder
= drm_encoder_find(connector
->dev
, connector
->encoder_ids
[i
]);
1357 if (radeon_connector
->use_digital
== true) {
1358 if (encoder
->encoder_type
== DRM_MODE_ENCODER_TMDS
)
1361 if (encoder
->encoder_type
== DRM_MODE_ENCODER_DAC
||
1362 encoder
->encoder_type
== DRM_MODE_ENCODER_TVDAC
)
1367 /* see if we have a default encoder TODO */
1369 /* then check use digitial */
1370 /* pick the first one */
1372 return drm_encoder_find(connector
->dev
, enc_id
);
1376 static void radeon_dvi_force(struct drm_connector
*connector
)
1378 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1379 if (connector
->force
== DRM_FORCE_ON
)
1380 radeon_connector
->use_digital
= false;
1381 if (connector
->force
== DRM_FORCE_ON_DIGITAL
)
1382 radeon_connector
->use_digital
= true;
1385 static int radeon_dvi_mode_valid(struct drm_connector
*connector
,
1386 struct drm_display_mode
*mode
)
1388 struct drm_device
*dev
= connector
->dev
;
1389 struct radeon_device
*rdev
= dev
->dev_private
;
1390 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1392 /* XXX check mode bandwidth */
1394 /* clocks over 135 MHz have heat issues with DVI on RV100 */
1395 if (radeon_connector
->use_digital
&&
1396 (rdev
->family
== CHIP_RV100
) &&
1397 (mode
->clock
> 135000))
1398 return MODE_CLOCK_HIGH
;
1400 if (radeon_connector
->use_digital
&& (mode
->clock
> 165000)) {
1401 if ((radeon_connector
->connector_object_id
== CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_I
) ||
1402 (radeon_connector
->connector_object_id
== CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_D
) ||
1403 (radeon_connector
->connector_object_id
== CONNECTOR_OBJECT_ID_HDMI_TYPE_B
))
1405 else if (ASIC_IS_DCE6(rdev
) && drm_detect_hdmi_monitor(radeon_connector_edid(connector
))) {
1406 /* HDMI 1.3+ supports max clock of 340 Mhz */
1407 if (mode
->clock
> 340000)
1408 return MODE_CLOCK_HIGH
;
1412 return MODE_CLOCK_HIGH
;
1416 /* check against the max pixel clock */
1417 if ((mode
->clock
/ 10) > rdev
->clock
.max_pixel_clock
)
1418 return MODE_CLOCK_HIGH
;
1423 static const struct drm_connector_helper_funcs radeon_dvi_connector_helper_funcs
= {
1424 .get_modes
= radeon_vga_get_modes
,
1425 .mode_valid
= radeon_dvi_mode_valid
,
1426 .best_encoder
= radeon_dvi_encoder
,
1429 static const struct drm_connector_funcs radeon_dvi_connector_funcs
= {
1430 .dpms
= drm_helper_connector_dpms
,
1431 .detect
= radeon_dvi_detect
,
1432 .fill_modes
= drm_helper_probe_single_connector_modes
,
1433 .set_property
= radeon_connector_set_property
,
1434 .destroy
= radeon_connector_destroy
,
1435 .force
= radeon_dvi_force
,
1438 static int radeon_dp_get_modes(struct drm_connector
*connector
)
1440 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1441 struct radeon_connector_atom_dig
*radeon_dig_connector
= radeon_connector
->con_priv
;
1442 struct drm_encoder
*encoder
= radeon_best_single_encoder(connector
);
1445 if ((connector
->connector_type
== DRM_MODE_CONNECTOR_eDP
) ||
1446 (connector
->connector_type
== DRM_MODE_CONNECTOR_LVDS
)) {
1447 struct drm_display_mode
*mode
;
1449 if (connector
->connector_type
== DRM_MODE_CONNECTOR_eDP
) {
1450 if (!radeon_dig_connector
->edp_on
)
1451 atombios_set_edp_panel_power(connector
,
1452 ATOM_TRANSMITTER_ACTION_POWER_ON
);
1453 radeon_connector_get_edid(connector
);
1454 ret
= radeon_ddc_get_modes(connector
);
1455 if (!radeon_dig_connector
->edp_on
)
1456 atombios_set_edp_panel_power(connector
,
1457 ATOM_TRANSMITTER_ACTION_POWER_OFF
);
1459 /* need to setup ddc on the bridge */
1460 if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector
) !=
1461 ENCODER_OBJECT_ID_NONE
) {
1463 radeon_atom_ext_encoder_setup_ddc(encoder
);
1465 radeon_connector_get_edid(connector
);
1466 ret
= radeon_ddc_get_modes(connector
);
1471 radeon_fixup_lvds_native_mode(encoder
, connector
);
1472 /* add scaled modes */
1473 radeon_add_common_modes(encoder
, connector
);
1481 /* we have no EDID modes */
1482 mode
= radeon_fp_native_mode(encoder
);
1485 drm_mode_probed_add(connector
, mode
);
1486 /* add the width/height from vbios tables if available */
1487 connector
->display_info
.width_mm
= mode
->width_mm
;
1488 connector
->display_info
.height_mm
= mode
->height_mm
;
1489 /* add scaled modes */
1490 radeon_add_common_modes(encoder
, connector
);
1493 /* need to setup ddc on the bridge */
1494 if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector
) !=
1495 ENCODER_OBJECT_ID_NONE
) {
1497 radeon_atom_ext_encoder_setup_ddc(encoder
);
1499 radeon_connector_get_edid(connector
);
1500 ret
= radeon_ddc_get_modes(connector
);
1502 radeon_get_native_mode(connector
);
1508 u16
radeon_connector_encoder_get_dp_bridge_encoder_id(struct drm_connector
*connector
)
1510 struct drm_encoder
*encoder
;
1511 struct radeon_encoder
*radeon_encoder
;
1514 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
1515 if (connector
->encoder_ids
[i
] == 0)
1518 encoder
= drm_encoder_find(connector
->dev
, connector
->encoder_ids
[i
]);
1522 radeon_encoder
= to_radeon_encoder(encoder
);
1524 switch (radeon_encoder
->encoder_id
) {
1525 case ENCODER_OBJECT_ID_TRAVIS
:
1526 case ENCODER_OBJECT_ID_NUTMEG
:
1527 return radeon_encoder
->encoder_id
;
1533 return ENCODER_OBJECT_ID_NONE
;
1536 static bool radeon_connector_encoder_is_hbr2(struct drm_connector
*connector
)
1538 struct drm_encoder
*encoder
;
1539 struct radeon_encoder
*radeon_encoder
;
1543 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
1544 if (connector
->encoder_ids
[i
] == 0)
1547 encoder
= drm_encoder_find(connector
->dev
, connector
->encoder_ids
[i
]);
1551 radeon_encoder
= to_radeon_encoder(encoder
);
1552 if (radeon_encoder
->caps
& ATOM_ENCODER_CAP_RECORD_HBR2
)
1559 bool radeon_connector_is_dp12_capable(struct drm_connector
*connector
)
1561 struct drm_device
*dev
= connector
->dev
;
1562 struct radeon_device
*rdev
= dev
->dev_private
;
1564 if (ASIC_IS_DCE5(rdev
) &&
1565 (rdev
->clock
.default_dispclk
>= 53900) &&
1566 radeon_connector_encoder_is_hbr2(connector
)) {
1573 static enum drm_connector_status
1574 radeon_dp_detect(struct drm_connector
*connector
, bool force
)
1576 struct drm_device
*dev
= connector
->dev
;
1577 struct radeon_device
*rdev
= dev
->dev_private
;
1578 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1579 enum drm_connector_status ret
= connector_status_disconnected
;
1580 struct radeon_connector_atom_dig
*radeon_dig_connector
= radeon_connector
->con_priv
;
1581 struct drm_encoder
*encoder
= radeon_best_single_encoder(connector
);
1584 r
= pm_runtime_get_sync(connector
->dev
->dev
);
1586 return connector_status_disconnected
;
1588 if (!force
&& radeon_check_hpd_status_unchanged(connector
)) {
1589 ret
= connector
->status
;
1593 radeon_connector_free_edid(connector
);
1595 if ((connector
->connector_type
== DRM_MODE_CONNECTOR_eDP
) ||
1596 (connector
->connector_type
== DRM_MODE_CONNECTOR_LVDS
)) {
1598 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
1599 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
1601 /* check if panel is valid */
1602 if (native_mode
->hdisplay
>= 320 && native_mode
->vdisplay
>= 240)
1603 ret
= connector_status_connected
;
1604 /* don't fetch the edid from the vbios if ddc fails and runpm is
1605 * enabled so we report disconnected.
1607 if ((rdev
->flags
& RADEON_IS_PX
) && (radeon_runtime_pm
!= 0))
1608 ret
= connector_status_disconnected
;
1610 /* eDP is always DP */
1611 radeon_dig_connector
->dp_sink_type
= CONNECTOR_OBJECT_ID_DISPLAYPORT
;
1612 if (!radeon_dig_connector
->edp_on
)
1613 atombios_set_edp_panel_power(connector
,
1614 ATOM_TRANSMITTER_ACTION_POWER_ON
);
1615 if (radeon_dp_getdpcd(radeon_connector
))
1616 ret
= connector_status_connected
;
1617 if (!radeon_dig_connector
->edp_on
)
1618 atombios_set_edp_panel_power(connector
,
1619 ATOM_TRANSMITTER_ACTION_POWER_OFF
);
1620 } else if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector
) !=
1621 ENCODER_OBJECT_ID_NONE
) {
1622 /* DP bridges are always DP */
1623 radeon_dig_connector
->dp_sink_type
= CONNECTOR_OBJECT_ID_DISPLAYPORT
;
1624 /* get the DPCD from the bridge */
1625 radeon_dp_getdpcd(radeon_connector
);
1628 /* setup ddc on the bridge */
1629 radeon_atom_ext_encoder_setup_ddc(encoder
);
1630 /* bridge chips are always aux */
1631 if (radeon_ddc_probe(radeon_connector
, true)) /* try DDC */
1632 ret
= connector_status_connected
;
1633 else if (radeon_connector
->dac_load_detect
) { /* try load detection */
1634 struct drm_encoder_helper_funcs
*encoder_funcs
= encoder
->helper_private
;
1635 ret
= encoder_funcs
->detect(encoder
, connector
);
1639 radeon_dig_connector
->dp_sink_type
= radeon_dp_getsinktype(radeon_connector
);
1640 if (radeon_hpd_sense(rdev
, radeon_connector
->hpd
.hpd
)) {
1641 ret
= connector_status_connected
;
1642 if (radeon_dig_connector
->dp_sink_type
== CONNECTOR_OBJECT_ID_DISPLAYPORT
)
1643 radeon_dp_getdpcd(radeon_connector
);
1645 if (radeon_dig_connector
->dp_sink_type
== CONNECTOR_OBJECT_ID_DISPLAYPORT
) {
1646 if (radeon_dp_getdpcd(radeon_connector
))
1647 ret
= connector_status_connected
;
1649 /* try non-aux ddc (DP to DVI/HDMI/etc. adapter) */
1650 if (radeon_ddc_probe(radeon_connector
, false))
1651 ret
= connector_status_connected
;
1656 radeon_connector_update_scratch_regs(connector
, ret
);
1658 pm_runtime_mark_last_busy(connector
->dev
->dev
);
1659 pm_runtime_put_autosuspend(connector
->dev
->dev
);
1664 static int radeon_dp_mode_valid(struct drm_connector
*connector
,
1665 struct drm_display_mode
*mode
)
1667 struct drm_device
*dev
= connector
->dev
;
1668 struct radeon_device
*rdev
= dev
->dev_private
;
1669 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1670 struct radeon_connector_atom_dig
*radeon_dig_connector
= radeon_connector
->con_priv
;
1672 /* XXX check mode bandwidth */
1674 if ((connector
->connector_type
== DRM_MODE_CONNECTOR_eDP
) ||
1675 (connector
->connector_type
== DRM_MODE_CONNECTOR_LVDS
)) {
1676 struct drm_encoder
*encoder
= radeon_best_single_encoder(connector
);
1678 if ((mode
->hdisplay
< 320) || (mode
->vdisplay
< 240))
1682 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
1683 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
1685 /* AVIVO hardware supports downscaling modes larger than the panel
1686 * to the panel size, but I'm not sure this is desirable.
1688 if ((mode
->hdisplay
> native_mode
->hdisplay
) ||
1689 (mode
->vdisplay
> native_mode
->vdisplay
))
1692 /* if scaling is disabled, block non-native modes */
1693 if (radeon_encoder
->rmx_type
== RMX_OFF
) {
1694 if ((mode
->hdisplay
!= native_mode
->hdisplay
) ||
1695 (mode
->vdisplay
!= native_mode
->vdisplay
))
1700 if ((radeon_dig_connector
->dp_sink_type
== CONNECTOR_OBJECT_ID_DISPLAYPORT
) ||
1701 (radeon_dig_connector
->dp_sink_type
== CONNECTOR_OBJECT_ID_eDP
)) {
1702 return radeon_dp_mode_valid_helper(connector
, mode
);
1704 if (ASIC_IS_DCE6(rdev
) && drm_detect_hdmi_monitor(radeon_connector_edid(connector
))) {
1705 /* HDMI 1.3+ supports max clock of 340 Mhz */
1706 if (mode
->clock
> 340000)
1707 return MODE_CLOCK_HIGH
;
1709 if (mode
->clock
> 165000)
1710 return MODE_CLOCK_HIGH
;
1718 static const struct drm_connector_helper_funcs radeon_dp_connector_helper_funcs
= {
1719 .get_modes
= radeon_dp_get_modes
,
1720 .mode_valid
= radeon_dp_mode_valid
,
1721 .best_encoder
= radeon_dvi_encoder
,
1724 static const struct drm_connector_funcs radeon_dp_connector_funcs
= {
1725 .dpms
= drm_helper_connector_dpms
,
1726 .detect
= radeon_dp_detect
,
1727 .fill_modes
= drm_helper_probe_single_connector_modes
,
1728 .set_property
= radeon_connector_set_property
,
1729 .destroy
= radeon_connector_destroy
,
1730 .force
= radeon_dvi_force
,
1733 static const struct drm_connector_funcs radeon_edp_connector_funcs
= {
1734 .dpms
= drm_helper_connector_dpms
,
1735 .detect
= radeon_dp_detect
,
1736 .fill_modes
= drm_helper_probe_single_connector_modes
,
1737 .set_property
= radeon_lvds_set_property
,
1738 .destroy
= radeon_connector_destroy
,
1739 .force
= radeon_dvi_force
,
1742 static const struct drm_connector_funcs radeon_lvds_bridge_connector_funcs
= {
1743 .dpms
= drm_helper_connector_dpms
,
1744 .detect
= radeon_dp_detect
,
1745 .fill_modes
= drm_helper_probe_single_connector_modes
,
1746 .set_property
= radeon_lvds_set_property
,
1747 .destroy
= radeon_connector_destroy
,
1748 .force
= radeon_dvi_force
,
1752 radeon_add_atom_connector(struct drm_device
*dev
,
1753 uint32_t connector_id
,
1754 uint32_t supported_device
,
1756 struct radeon_i2c_bus_rec
*i2c_bus
,
1757 uint32_t igp_lane_info
,
1758 uint16_t connector_object_id
,
1759 struct radeon_hpd
*hpd
,
1760 struct radeon_router
*router
)
1762 struct radeon_device
*rdev
= dev
->dev_private
;
1763 struct drm_connector
*connector
;
1764 struct radeon_connector
*radeon_connector
;
1765 struct radeon_connector_atom_dig
*radeon_dig_connector
;
1766 struct drm_encoder
*encoder
;
1767 struct radeon_encoder
*radeon_encoder
;
1768 uint32_t subpixel_order
= SubPixelNone
;
1769 bool shared_ddc
= false;
1770 bool is_dp_bridge
= false;
1771 bool has_aux
= false;
1773 if (connector_type
== DRM_MODE_CONNECTOR_Unknown
)
1776 /* if the user selected tv=0 don't try and add the connector */
1777 if (((connector_type
== DRM_MODE_CONNECTOR_SVIDEO
) ||
1778 (connector_type
== DRM_MODE_CONNECTOR_Composite
) ||
1779 (connector_type
== DRM_MODE_CONNECTOR_9PinDIN
)) &&
1783 /* see if we already added it */
1784 list_for_each_entry(connector
, &dev
->mode_config
.connector_list
, head
) {
1785 radeon_connector
= to_radeon_connector(connector
);
1786 if (radeon_connector
->connector_id
== connector_id
) {
1787 radeon_connector
->devices
|= supported_device
;
1790 if (radeon_connector
->ddc_bus
&& i2c_bus
->valid
) {
1791 if (radeon_connector
->ddc_bus
->rec
.i2c_id
== i2c_bus
->i2c_id
) {
1792 radeon_connector
->shared_ddc
= true;
1795 if (radeon_connector
->router_bus
&& router
->ddc_valid
&&
1796 (radeon_connector
->router
.router_id
== router
->router_id
)) {
1797 radeon_connector
->shared_ddc
= false;
1803 /* check if it's a dp bridge */
1804 list_for_each_entry(encoder
, &dev
->mode_config
.encoder_list
, head
) {
1805 radeon_encoder
= to_radeon_encoder(encoder
);
1806 if (radeon_encoder
->devices
& supported_device
) {
1807 switch (radeon_encoder
->encoder_id
) {
1808 case ENCODER_OBJECT_ID_TRAVIS
:
1809 case ENCODER_OBJECT_ID_NUTMEG
:
1810 is_dp_bridge
= true;
1818 radeon_connector
= kzalloc(sizeof(struct radeon_connector
), GFP_KERNEL
);
1819 if (!radeon_connector
)
1822 connector
= &radeon_connector
->base
;
1824 radeon_connector
->connector_id
= connector_id
;
1825 radeon_connector
->devices
= supported_device
;
1826 radeon_connector
->shared_ddc
= shared_ddc
;
1827 radeon_connector
->connector_object_id
= connector_object_id
;
1828 radeon_connector
->hpd
= *hpd
;
1830 radeon_connector
->router
= *router
;
1831 if (router
->ddc_valid
|| router
->cd_valid
) {
1832 radeon_connector
->router_bus
= radeon_i2c_lookup(rdev
, &router
->i2c_info
);
1833 if (!radeon_connector
->router_bus
)
1834 DRM_ERROR("Failed to assign router i2c bus! Check dmesg for i2c errors.\n");
1838 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
1839 if (!radeon_dig_connector
)
1841 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
1842 radeon_connector
->con_priv
= radeon_dig_connector
;
1843 if (i2c_bus
->valid
) {
1844 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1845 if (radeon_connector
->ddc_bus
)
1848 DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1850 switch (connector_type
) {
1851 case DRM_MODE_CONNECTOR_VGA
:
1852 case DRM_MODE_CONNECTOR_DVIA
:
1854 drm_connector_init(dev
, &radeon_connector
->base
,
1855 &radeon_dp_connector_funcs
, connector_type
);
1856 drm_connector_helper_add(&radeon_connector
->base
,
1857 &radeon_dp_connector_helper_funcs
);
1858 connector
->interlace_allowed
= true;
1859 connector
->doublescan_allowed
= true;
1860 radeon_connector
->dac_load_detect
= true;
1861 drm_object_attach_property(&radeon_connector
->base
.base
,
1862 rdev
->mode_info
.load_detect_property
,
1864 drm_object_attach_property(&radeon_connector
->base
.base
,
1865 dev
->mode_config
.scaling_mode_property
,
1866 DRM_MODE_SCALE_NONE
);
1868 case DRM_MODE_CONNECTOR_DVII
:
1869 case DRM_MODE_CONNECTOR_DVID
:
1870 case DRM_MODE_CONNECTOR_HDMIA
:
1871 case DRM_MODE_CONNECTOR_HDMIB
:
1872 case DRM_MODE_CONNECTOR_DisplayPort
:
1873 drm_connector_init(dev
, &radeon_connector
->base
,
1874 &radeon_dp_connector_funcs
, connector_type
);
1875 drm_connector_helper_add(&radeon_connector
->base
,
1876 &radeon_dp_connector_helper_funcs
);
1877 drm_object_attach_property(&radeon_connector
->base
.base
,
1878 rdev
->mode_info
.underscan_property
,
1880 drm_object_attach_property(&radeon_connector
->base
.base
,
1881 rdev
->mode_info
.underscan_hborder_property
,
1883 drm_object_attach_property(&radeon_connector
->base
.base
,
1884 rdev
->mode_info
.underscan_vborder_property
,
1887 drm_object_attach_property(&radeon_connector
->base
.base
,
1888 dev
->mode_config
.scaling_mode_property
,
1889 DRM_MODE_SCALE_NONE
);
1891 drm_object_attach_property(&radeon_connector
->base
.base
,
1892 rdev
->mode_info
.dither_property
,
1893 RADEON_FMT_DITHER_DISABLE
);
1895 if (radeon_audio
!= 0)
1896 drm_object_attach_property(&radeon_connector
->base
.base
,
1897 rdev
->mode_info
.audio_property
,
1900 subpixel_order
= SubPixelHorizontalRGB
;
1901 connector
->interlace_allowed
= true;
1902 if (connector_type
== DRM_MODE_CONNECTOR_HDMIB
)
1903 connector
->doublescan_allowed
= true;
1905 connector
->doublescan_allowed
= false;
1906 if (connector_type
== DRM_MODE_CONNECTOR_DVII
) {
1907 radeon_connector
->dac_load_detect
= true;
1908 drm_object_attach_property(&radeon_connector
->base
.base
,
1909 rdev
->mode_info
.load_detect_property
,
1913 case DRM_MODE_CONNECTOR_LVDS
:
1914 case DRM_MODE_CONNECTOR_eDP
:
1915 drm_connector_init(dev
, &radeon_connector
->base
,
1916 &radeon_lvds_bridge_connector_funcs
, connector_type
);
1917 drm_connector_helper_add(&radeon_connector
->base
,
1918 &radeon_dp_connector_helper_funcs
);
1919 drm_object_attach_property(&radeon_connector
->base
.base
,
1920 dev
->mode_config
.scaling_mode_property
,
1921 DRM_MODE_SCALE_FULLSCREEN
);
1922 subpixel_order
= SubPixelHorizontalRGB
;
1923 connector
->interlace_allowed
= false;
1924 connector
->doublescan_allowed
= false;
1928 switch (connector_type
) {
1929 case DRM_MODE_CONNECTOR_VGA
:
1930 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_vga_connector_funcs
, connector_type
);
1931 drm_connector_helper_add(&radeon_connector
->base
, &radeon_vga_connector_helper_funcs
);
1932 if (i2c_bus
->valid
) {
1933 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1934 if (!radeon_connector
->ddc_bus
)
1935 DRM_ERROR("VGA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1937 radeon_connector
->dac_load_detect
= true;
1938 drm_object_attach_property(&radeon_connector
->base
.base
,
1939 rdev
->mode_info
.load_detect_property
,
1941 if (ASIC_IS_AVIVO(rdev
))
1942 drm_object_attach_property(&radeon_connector
->base
.base
,
1943 dev
->mode_config
.scaling_mode_property
,
1944 DRM_MODE_SCALE_NONE
);
1945 /* no HPD on analog connectors */
1946 radeon_connector
->hpd
.hpd
= RADEON_HPD_NONE
;
1947 connector
->polled
= DRM_CONNECTOR_POLL_CONNECT
;
1948 connector
->interlace_allowed
= true;
1949 connector
->doublescan_allowed
= true;
1951 case DRM_MODE_CONNECTOR_DVIA
:
1952 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_vga_connector_funcs
, connector_type
);
1953 drm_connector_helper_add(&radeon_connector
->base
, &radeon_vga_connector_helper_funcs
);
1954 if (i2c_bus
->valid
) {
1955 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1956 if (!radeon_connector
->ddc_bus
)
1957 DRM_ERROR("DVIA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1959 radeon_connector
->dac_load_detect
= true;
1960 drm_object_attach_property(&radeon_connector
->base
.base
,
1961 rdev
->mode_info
.load_detect_property
,
1963 if (ASIC_IS_AVIVO(rdev
))
1964 drm_object_attach_property(&radeon_connector
->base
.base
,
1965 dev
->mode_config
.scaling_mode_property
,
1966 DRM_MODE_SCALE_NONE
);
1967 /* no HPD on analog connectors */
1968 radeon_connector
->hpd
.hpd
= RADEON_HPD_NONE
;
1969 connector
->interlace_allowed
= true;
1970 connector
->doublescan_allowed
= true;
1972 case DRM_MODE_CONNECTOR_DVII
:
1973 case DRM_MODE_CONNECTOR_DVID
:
1974 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
1975 if (!radeon_dig_connector
)
1977 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
1978 radeon_connector
->con_priv
= radeon_dig_connector
;
1979 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_dvi_connector_funcs
, connector_type
);
1980 drm_connector_helper_add(&radeon_connector
->base
, &radeon_dvi_connector_helper_funcs
);
1981 if (i2c_bus
->valid
) {
1982 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1983 if (!radeon_connector
->ddc_bus
)
1984 DRM_ERROR("DVI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1986 subpixel_order
= SubPixelHorizontalRGB
;
1987 drm_object_attach_property(&radeon_connector
->base
.base
,
1988 rdev
->mode_info
.coherent_mode_property
,
1990 if (ASIC_IS_AVIVO(rdev
)) {
1991 drm_object_attach_property(&radeon_connector
->base
.base
,
1992 rdev
->mode_info
.underscan_property
,
1994 drm_object_attach_property(&radeon_connector
->base
.base
,
1995 rdev
->mode_info
.underscan_hborder_property
,
1997 drm_object_attach_property(&radeon_connector
->base
.base
,
1998 rdev
->mode_info
.underscan_vborder_property
,
2000 drm_object_attach_property(&radeon_connector
->base
.base
,
2001 rdev
->mode_info
.dither_property
,
2002 RADEON_FMT_DITHER_DISABLE
);
2003 drm_object_attach_property(&radeon_connector
->base
.base
,
2004 dev
->mode_config
.scaling_mode_property
,
2005 DRM_MODE_SCALE_NONE
);
2007 if (ASIC_IS_DCE2(rdev
) && (radeon_audio
!= 0)) {
2008 drm_object_attach_property(&radeon_connector
->base
.base
,
2009 rdev
->mode_info
.audio_property
,
2012 if (connector_type
== DRM_MODE_CONNECTOR_DVII
) {
2013 radeon_connector
->dac_load_detect
= true;
2014 drm_object_attach_property(&radeon_connector
->base
.base
,
2015 rdev
->mode_info
.load_detect_property
,
2018 connector
->interlace_allowed
= true;
2019 if (connector_type
== DRM_MODE_CONNECTOR_DVII
)
2020 connector
->doublescan_allowed
= true;
2022 connector
->doublescan_allowed
= false;
2024 case DRM_MODE_CONNECTOR_HDMIA
:
2025 case DRM_MODE_CONNECTOR_HDMIB
:
2026 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
2027 if (!radeon_dig_connector
)
2029 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
2030 radeon_connector
->con_priv
= radeon_dig_connector
;
2031 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_dvi_connector_funcs
, connector_type
);
2032 drm_connector_helper_add(&radeon_connector
->base
, &radeon_dvi_connector_helper_funcs
);
2033 if (i2c_bus
->valid
) {
2034 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
2035 if (!radeon_connector
->ddc_bus
)
2036 DRM_ERROR("HDMI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2038 drm_object_attach_property(&radeon_connector
->base
.base
,
2039 rdev
->mode_info
.coherent_mode_property
,
2041 if (ASIC_IS_AVIVO(rdev
)) {
2042 drm_object_attach_property(&radeon_connector
->base
.base
,
2043 rdev
->mode_info
.underscan_property
,
2045 drm_object_attach_property(&radeon_connector
->base
.base
,
2046 rdev
->mode_info
.underscan_hborder_property
,
2048 drm_object_attach_property(&radeon_connector
->base
.base
,
2049 rdev
->mode_info
.underscan_vborder_property
,
2051 drm_object_attach_property(&radeon_connector
->base
.base
,
2052 rdev
->mode_info
.dither_property
,
2053 RADEON_FMT_DITHER_DISABLE
);
2054 drm_object_attach_property(&radeon_connector
->base
.base
,
2055 dev
->mode_config
.scaling_mode_property
,
2056 DRM_MODE_SCALE_NONE
);
2058 if (ASIC_IS_DCE2(rdev
) && (radeon_audio
!= 0)) {
2059 drm_object_attach_property(&radeon_connector
->base
.base
,
2060 rdev
->mode_info
.audio_property
,
2063 subpixel_order
= SubPixelHorizontalRGB
;
2064 connector
->interlace_allowed
= true;
2065 if (connector_type
== DRM_MODE_CONNECTOR_HDMIB
)
2066 connector
->doublescan_allowed
= true;
2068 connector
->doublescan_allowed
= false;
2070 case DRM_MODE_CONNECTOR_DisplayPort
:
2071 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
2072 if (!radeon_dig_connector
)
2074 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
2075 radeon_connector
->con_priv
= radeon_dig_connector
;
2076 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_dp_connector_funcs
, connector_type
);
2077 drm_connector_helper_add(&radeon_connector
->base
, &radeon_dp_connector_helper_funcs
);
2078 if (i2c_bus
->valid
) {
2079 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
2080 if (radeon_connector
->ddc_bus
)
2083 DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2085 subpixel_order
= SubPixelHorizontalRGB
;
2086 drm_object_attach_property(&radeon_connector
->base
.base
,
2087 rdev
->mode_info
.coherent_mode_property
,
2089 if (ASIC_IS_AVIVO(rdev
)) {
2090 drm_object_attach_property(&radeon_connector
->base
.base
,
2091 rdev
->mode_info
.underscan_property
,
2093 drm_object_attach_property(&radeon_connector
->base
.base
,
2094 rdev
->mode_info
.underscan_hborder_property
,
2096 drm_object_attach_property(&radeon_connector
->base
.base
,
2097 rdev
->mode_info
.underscan_vborder_property
,
2099 drm_object_attach_property(&radeon_connector
->base
.base
,
2100 rdev
->mode_info
.dither_property
,
2101 RADEON_FMT_DITHER_DISABLE
);
2102 drm_object_attach_property(&radeon_connector
->base
.base
,
2103 dev
->mode_config
.scaling_mode_property
,
2104 DRM_MODE_SCALE_NONE
);
2106 if (ASIC_IS_DCE2(rdev
) && (radeon_audio
!= 0)) {
2107 drm_object_attach_property(&radeon_connector
->base
.base
,
2108 rdev
->mode_info
.audio_property
,
2111 connector
->interlace_allowed
= true;
2112 /* in theory with a DP to VGA converter... */
2113 connector
->doublescan_allowed
= false;
2115 case DRM_MODE_CONNECTOR_eDP
:
2116 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
2117 if (!radeon_dig_connector
)
2119 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
2120 radeon_connector
->con_priv
= radeon_dig_connector
;
2121 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_edp_connector_funcs
, connector_type
);
2122 drm_connector_helper_add(&radeon_connector
->base
, &radeon_dp_connector_helper_funcs
);
2123 if (i2c_bus
->valid
) {
2124 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
2125 if (radeon_connector
->ddc_bus
)
2128 DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2130 drm_object_attach_property(&radeon_connector
->base
.base
,
2131 dev
->mode_config
.scaling_mode_property
,
2132 DRM_MODE_SCALE_FULLSCREEN
);
2133 subpixel_order
= SubPixelHorizontalRGB
;
2134 connector
->interlace_allowed
= false;
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 drm_object_attach_property(&radeon_connector
->base
.base
,
2144 rdev
->mode_info
.load_detect_property
,
2146 drm_object_attach_property(&radeon_connector
->base
.base
,
2147 rdev
->mode_info
.tv_std_property
,
2148 radeon_atombios_get_tv_info(rdev
));
2149 /* no HPD on analog connectors */
2150 radeon_connector
->hpd
.hpd
= RADEON_HPD_NONE
;
2151 connector
->interlace_allowed
= false;
2152 connector
->doublescan_allowed
= false;
2154 case DRM_MODE_CONNECTOR_LVDS
:
2155 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
2156 if (!radeon_dig_connector
)
2158 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
2159 radeon_connector
->con_priv
= radeon_dig_connector
;
2160 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_lvds_connector_funcs
, connector_type
);
2161 drm_connector_helper_add(&radeon_connector
->base
, &radeon_lvds_connector_helper_funcs
);
2162 if (i2c_bus
->valid
) {
2163 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
2164 if (!radeon_connector
->ddc_bus
)
2165 DRM_ERROR("LVDS: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2167 drm_object_attach_property(&radeon_connector
->base
.base
,
2168 dev
->mode_config
.scaling_mode_property
,
2169 DRM_MODE_SCALE_FULLSCREEN
);
2170 subpixel_order
= SubPixelHorizontalRGB
;
2171 connector
->interlace_allowed
= false;
2172 connector
->doublescan_allowed
= false;
2177 if (radeon_connector
->hpd
.hpd
== RADEON_HPD_NONE
) {
2179 connector
->polled
= DRM_CONNECTOR_POLL_CONNECT
;
2181 connector
->polled
= DRM_CONNECTOR_POLL_HPD
;
2183 connector
->display_info
.subpixel_order
= subpixel_order
;
2184 drm_connector_register(connector
);
2187 radeon_dp_aux_init(radeon_connector
);
2192 drm_connector_cleanup(connector
);
2197 radeon_add_legacy_connector(struct drm_device
*dev
,
2198 uint32_t connector_id
,
2199 uint32_t supported_device
,
2201 struct radeon_i2c_bus_rec
*i2c_bus
,
2202 uint16_t connector_object_id
,
2203 struct radeon_hpd
*hpd
)
2205 struct radeon_device
*rdev
= dev
->dev_private
;
2206 struct drm_connector
*connector
;
2207 struct radeon_connector
*radeon_connector
;
2208 uint32_t subpixel_order
= SubPixelNone
;
2210 if (connector_type
== DRM_MODE_CONNECTOR_Unknown
)
2213 /* if the user selected tv=0 don't try and add the connector */
2214 if (((connector_type
== DRM_MODE_CONNECTOR_SVIDEO
) ||
2215 (connector_type
== DRM_MODE_CONNECTOR_Composite
) ||
2216 (connector_type
== DRM_MODE_CONNECTOR_9PinDIN
)) &&
2220 /* see if we already added it */
2221 list_for_each_entry(connector
, &dev
->mode_config
.connector_list
, head
) {
2222 radeon_connector
= to_radeon_connector(connector
);
2223 if (radeon_connector
->connector_id
== connector_id
) {
2224 radeon_connector
->devices
|= supported_device
;
2229 radeon_connector
= kzalloc(sizeof(struct radeon_connector
), GFP_KERNEL
);
2230 if (!radeon_connector
)
2233 connector
= &radeon_connector
->base
;
2235 radeon_connector
->connector_id
= connector_id
;
2236 radeon_connector
->devices
= supported_device
;
2237 radeon_connector
->connector_object_id
= connector_object_id
;
2238 radeon_connector
->hpd
= *hpd
;
2240 switch (connector_type
) {
2241 case DRM_MODE_CONNECTOR_VGA
:
2242 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_vga_connector_funcs
, connector_type
);
2243 drm_connector_helper_add(&radeon_connector
->base
, &radeon_vga_connector_helper_funcs
);
2244 if (i2c_bus
->valid
) {
2245 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
2246 if (!radeon_connector
->ddc_bus
)
2247 DRM_ERROR("VGA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2249 radeon_connector
->dac_load_detect
= true;
2250 drm_object_attach_property(&radeon_connector
->base
.base
,
2251 rdev
->mode_info
.load_detect_property
,
2253 /* no HPD on analog connectors */
2254 radeon_connector
->hpd
.hpd
= RADEON_HPD_NONE
;
2255 connector
->polled
= DRM_CONNECTOR_POLL_CONNECT
;
2256 connector
->interlace_allowed
= true;
2257 connector
->doublescan_allowed
= true;
2259 case DRM_MODE_CONNECTOR_DVIA
:
2260 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_vga_connector_funcs
, connector_type
);
2261 drm_connector_helper_add(&radeon_connector
->base
, &radeon_vga_connector_helper_funcs
);
2262 if (i2c_bus
->valid
) {
2263 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
2264 if (!radeon_connector
->ddc_bus
)
2265 DRM_ERROR("DVIA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2267 radeon_connector
->dac_load_detect
= true;
2268 drm_object_attach_property(&radeon_connector
->base
.base
,
2269 rdev
->mode_info
.load_detect_property
,
2271 /* no HPD on analog connectors */
2272 radeon_connector
->hpd
.hpd
= RADEON_HPD_NONE
;
2273 connector
->interlace_allowed
= true;
2274 connector
->doublescan_allowed
= true;
2276 case DRM_MODE_CONNECTOR_DVII
:
2277 case DRM_MODE_CONNECTOR_DVID
:
2278 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_dvi_connector_funcs
, connector_type
);
2279 drm_connector_helper_add(&radeon_connector
->base
, &radeon_dvi_connector_helper_funcs
);
2280 if (i2c_bus
->valid
) {
2281 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
2282 if (!radeon_connector
->ddc_bus
)
2283 DRM_ERROR("DVI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2285 if (connector_type
== DRM_MODE_CONNECTOR_DVII
) {
2286 radeon_connector
->dac_load_detect
= true;
2287 drm_object_attach_property(&radeon_connector
->base
.base
,
2288 rdev
->mode_info
.load_detect_property
,
2291 subpixel_order
= SubPixelHorizontalRGB
;
2292 connector
->interlace_allowed
= true;
2293 if (connector_type
== DRM_MODE_CONNECTOR_DVII
)
2294 connector
->doublescan_allowed
= true;
2296 connector
->doublescan_allowed
= false;
2298 case DRM_MODE_CONNECTOR_SVIDEO
:
2299 case DRM_MODE_CONNECTOR_Composite
:
2300 case DRM_MODE_CONNECTOR_9PinDIN
:
2301 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_tv_connector_funcs
, connector_type
);
2302 drm_connector_helper_add(&radeon_connector
->base
, &radeon_tv_connector_helper_funcs
);
2303 radeon_connector
->dac_load_detect
= true;
2304 /* RS400,RC410,RS480 chipset seems to report a lot
2305 * of false positive on load detect, we haven't yet
2306 * found a way to make load detect reliable on those
2307 * chipset, thus just disable it for TV.
2309 if (rdev
->family
== CHIP_RS400
|| rdev
->family
== CHIP_RS480
)
2310 radeon_connector
->dac_load_detect
= false;
2311 drm_object_attach_property(&radeon_connector
->base
.base
,
2312 rdev
->mode_info
.load_detect_property
,
2313 radeon_connector
->dac_load_detect
);
2314 drm_object_attach_property(&radeon_connector
->base
.base
,
2315 rdev
->mode_info
.tv_std_property
,
2316 radeon_combios_get_tv_info(rdev
));
2317 /* no HPD on analog connectors */
2318 radeon_connector
->hpd
.hpd
= RADEON_HPD_NONE
;
2319 connector
->interlace_allowed
= false;
2320 connector
->doublescan_allowed
= false;
2322 case DRM_MODE_CONNECTOR_LVDS
:
2323 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_lvds_connector_funcs
, connector_type
);
2324 drm_connector_helper_add(&radeon_connector
->base
, &radeon_lvds_connector_helper_funcs
);
2325 if (i2c_bus
->valid
) {
2326 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
2327 if (!radeon_connector
->ddc_bus
)
2328 DRM_ERROR("LVDS: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2330 drm_object_attach_property(&radeon_connector
->base
.base
,
2331 dev
->mode_config
.scaling_mode_property
,
2332 DRM_MODE_SCALE_FULLSCREEN
);
2333 subpixel_order
= SubPixelHorizontalRGB
;
2334 connector
->interlace_allowed
= false;
2335 connector
->doublescan_allowed
= false;
2339 if (radeon_connector
->hpd
.hpd
== RADEON_HPD_NONE
) {
2341 connector
->polled
= DRM_CONNECTOR_POLL_CONNECT
;
2343 connector
->polled
= DRM_CONNECTOR_POLL_HPD
;
2344 connector
->display_info
.subpixel_order
= subpixel_order
;
2345 drm_connector_register(connector
);