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>
35 radeon_combios_connected_scratch_regs(struct drm_connector
*connector
,
36 struct drm_encoder
*encoder
,
39 radeon_atombios_connected_scratch_regs(struct drm_connector
*connector
,
40 struct drm_encoder
*encoder
,
44 radeon_legacy_backlight_init(struct radeon_encoder
*radeon_encoder
,
45 struct drm_connector
*drm_connector
);
47 void radeon_connector_hotplug(struct drm_connector
*connector
)
49 struct drm_device
*dev
= connector
->dev
;
50 struct radeon_device
*rdev
= dev
->dev_private
;
51 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
53 /* bail if the connector does not have hpd pin, e.g.,
56 if (radeon_connector
->hpd
.hpd
== RADEON_HPD_NONE
)
59 radeon_hpd_set_polarity(rdev
, radeon_connector
->hpd
.hpd
);
61 /* if the connector is already off, don't turn it back on */
62 if (connector
->dpms
!= DRM_MODE_DPMS_ON
)
65 /* just deal with DP (not eDP) here. */
66 if (connector
->connector_type
== DRM_MODE_CONNECTOR_DisplayPort
) {
67 struct radeon_connector_atom_dig
*dig_connector
=
68 radeon_connector
->con_priv
;
70 /* if existing sink type was not DP no need to retrain */
71 if (dig_connector
->dp_sink_type
!= CONNECTOR_OBJECT_ID_DISPLAYPORT
)
74 /* first get sink type as it may be reset after (un)plug */
75 dig_connector
->dp_sink_type
= radeon_dp_getsinktype(radeon_connector
);
76 /* don't do anything if sink is not display port, i.e.,
77 * passive dp->(dvi|hdmi) adaptor
79 if (dig_connector
->dp_sink_type
== CONNECTOR_OBJECT_ID_DISPLAYPORT
) {
80 int saved_dpms
= connector
->dpms
;
81 /* Only turn off the display if it's physically disconnected */
82 if (!radeon_hpd_sense(rdev
, radeon_connector
->hpd
.hpd
)) {
83 drm_helper_connector_dpms(connector
, DRM_MODE_DPMS_OFF
);
84 } else if (radeon_dp_needs_link_train(radeon_connector
)) {
85 /* set it to OFF so that drm_helper_connector_dpms()
86 * won't return immediately since the current state
87 * is ON at this point.
89 connector
->dpms
= DRM_MODE_DPMS_OFF
;
90 drm_helper_connector_dpms(connector
, DRM_MODE_DPMS_ON
);
92 connector
->dpms
= saved_dpms
;
97 static void radeon_property_change_mode(struct drm_encoder
*encoder
)
99 struct drm_crtc
*crtc
= encoder
->crtc
;
101 if (crtc
&& crtc
->enabled
) {
102 drm_crtc_helper_set_mode(crtc
, &crtc
->mode
,
103 crtc
->x
, crtc
->y
, crtc
->fb
);
107 int radeon_get_monitor_bpc(struct drm_connector
*connector
)
109 struct drm_device
*dev
= connector
->dev
;
110 struct radeon_device
*rdev
= dev
->dev_private
;
111 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
112 struct radeon_connector_atom_dig
*dig_connector
;
115 switch (connector
->connector_type
) {
116 case DRM_MODE_CONNECTOR_DVII
:
117 case DRM_MODE_CONNECTOR_HDMIB
:
118 if (radeon_connector
->use_digital
) {
119 if (drm_detect_hdmi_monitor(radeon_connector
->edid
)) {
120 if (connector
->display_info
.bpc
)
121 bpc
= connector
->display_info
.bpc
;
125 case DRM_MODE_CONNECTOR_DVID
:
126 case DRM_MODE_CONNECTOR_HDMIA
:
127 if (drm_detect_hdmi_monitor(radeon_connector
->edid
)) {
128 if (connector
->display_info
.bpc
)
129 bpc
= connector
->display_info
.bpc
;
132 case DRM_MODE_CONNECTOR_DisplayPort
:
133 dig_connector
= radeon_connector
->con_priv
;
134 if ((dig_connector
->dp_sink_type
== CONNECTOR_OBJECT_ID_DISPLAYPORT
) ||
135 (dig_connector
->dp_sink_type
== CONNECTOR_OBJECT_ID_eDP
) ||
136 drm_detect_hdmi_monitor(radeon_connector
->edid
)) {
137 if (connector
->display_info
.bpc
)
138 bpc
= connector
->display_info
.bpc
;
141 case DRM_MODE_CONNECTOR_eDP
:
142 case DRM_MODE_CONNECTOR_LVDS
:
143 if (connector
->display_info
.bpc
)
144 bpc
= connector
->display_info
.bpc
;
145 else if (ASIC_IS_DCE41(rdev
) || ASIC_IS_DCE5(rdev
)) {
146 struct drm_connector_helper_funcs
*connector_funcs
=
147 connector
->helper_private
;
148 struct drm_encoder
*encoder
= connector_funcs
->best_encoder(connector
);
149 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
150 struct radeon_encoder_atom_dig
*dig
= radeon_encoder
->enc_priv
;
152 if (dig
->lcd_misc
& ATOM_PANEL_MISC_V13_6BIT_PER_COLOR
)
154 else if (dig
->lcd_misc
& ATOM_PANEL_MISC_V13_8BIT_PER_COLOR
)
163 radeon_connector_update_scratch_regs(struct drm_connector
*connector
, enum drm_connector_status status
)
165 struct drm_device
*dev
= connector
->dev
;
166 struct radeon_device
*rdev
= dev
->dev_private
;
167 struct drm_encoder
*best_encoder
= NULL
;
168 struct drm_encoder
*encoder
= NULL
;
169 struct drm_connector_helper_funcs
*connector_funcs
= connector
->helper_private
;
170 struct drm_mode_object
*obj
;
174 best_encoder
= connector_funcs
->best_encoder(connector
);
176 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
177 if (connector
->encoder_ids
[i
] == 0)
180 obj
= drm_mode_object_find(connector
->dev
,
181 connector
->encoder_ids
[i
],
182 DRM_MODE_OBJECT_ENCODER
);
186 encoder
= obj_to_encoder(obj
);
188 if ((encoder
== best_encoder
) && (status
== connector_status_connected
))
193 if (rdev
->is_atom_bios
)
194 radeon_atombios_connected_scratch_regs(connector
, encoder
, connected
);
196 radeon_combios_connected_scratch_regs(connector
, encoder
, connected
);
201 struct drm_encoder
*radeon_find_encoder(struct drm_connector
*connector
, int encoder_type
)
203 struct drm_mode_object
*obj
;
204 struct drm_encoder
*encoder
;
207 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
208 if (connector
->encoder_ids
[i
] == 0)
211 obj
= drm_mode_object_find(connector
->dev
, connector
->encoder_ids
[i
], DRM_MODE_OBJECT_ENCODER
);
215 encoder
= obj_to_encoder(obj
);
216 if (encoder
->encoder_type
== encoder_type
)
222 struct drm_encoder
*radeon_best_single_encoder(struct drm_connector
*connector
)
224 int enc_id
= connector
->encoder_ids
[0];
225 struct drm_mode_object
*obj
;
226 struct drm_encoder
*encoder
;
228 /* pick the encoder ids */
230 obj
= drm_mode_object_find(connector
->dev
, enc_id
, DRM_MODE_OBJECT_ENCODER
);
233 encoder
= obj_to_encoder(obj
);
240 * radeon_connector_analog_encoder_conflict_solve
241 * - search for other connectors sharing this encoder
242 * if priority is true, then set them disconnected if this is connected
243 * if priority is false, set us disconnected if they are connected
245 static enum drm_connector_status
246 radeon_connector_analog_encoder_conflict_solve(struct drm_connector
*connector
,
247 struct drm_encoder
*encoder
,
248 enum drm_connector_status current_status
,
251 struct drm_device
*dev
= connector
->dev
;
252 struct drm_connector
*conflict
;
253 struct radeon_connector
*radeon_conflict
;
256 list_for_each_entry(conflict
, &dev
->mode_config
.connector_list
, head
) {
257 if (conflict
== connector
)
260 radeon_conflict
= to_radeon_connector(conflict
);
261 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
262 if (conflict
->encoder_ids
[i
] == 0)
265 /* if the IDs match */
266 if (conflict
->encoder_ids
[i
] == encoder
->base
.id
) {
267 if (conflict
->status
!= connector_status_connected
)
270 if (radeon_conflict
->use_digital
)
273 if (priority
== true) {
274 DRM_DEBUG_KMS("1: conflicting encoders switching off %s\n", drm_get_connector_name(conflict
));
275 DRM_DEBUG_KMS("in favor of %s\n", drm_get_connector_name(connector
));
276 conflict
->status
= connector_status_disconnected
;
277 radeon_connector_update_scratch_regs(conflict
, connector_status_disconnected
);
279 DRM_DEBUG_KMS("2: conflicting encoders switching off %s\n", drm_get_connector_name(connector
));
280 DRM_DEBUG_KMS("in favor of %s\n", drm_get_connector_name(conflict
));
281 current_status
= connector_status_disconnected
;
287 return current_status
;
291 static struct drm_display_mode
*radeon_fp_native_mode(struct drm_encoder
*encoder
)
293 struct drm_device
*dev
= encoder
->dev
;
294 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
295 struct drm_display_mode
*mode
= NULL
;
296 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
298 if (native_mode
->hdisplay
!= 0 &&
299 native_mode
->vdisplay
!= 0 &&
300 native_mode
->clock
!= 0) {
301 mode
= drm_mode_duplicate(dev
, native_mode
);
302 mode
->type
= DRM_MODE_TYPE_PREFERRED
| DRM_MODE_TYPE_DRIVER
;
303 drm_mode_set_name(mode
);
305 DRM_DEBUG_KMS("Adding native panel mode %s\n", mode
->name
);
306 } else if (native_mode
->hdisplay
!= 0 &&
307 native_mode
->vdisplay
!= 0) {
308 /* mac laptops without an edid */
309 /* Note that this is not necessarily the exact panel mode,
310 * but an approximation based on the cvt formula. For these
311 * systems we should ideally read the mode info out of the
312 * registers or add a mode table, but this works and is much
315 mode
= drm_cvt_mode(dev
, native_mode
->hdisplay
, native_mode
->vdisplay
, 60, true, false, false);
316 mode
->type
= DRM_MODE_TYPE_PREFERRED
| DRM_MODE_TYPE_DRIVER
;
317 DRM_DEBUG_KMS("Adding cvt approximation of native panel mode %s\n", mode
->name
);
322 static void radeon_add_common_modes(struct drm_encoder
*encoder
, struct drm_connector
*connector
)
324 struct drm_device
*dev
= encoder
->dev
;
325 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
326 struct drm_display_mode
*mode
= NULL
;
327 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
332 } common_modes
[17] = {
352 for (i
= 0; i
< 17; i
++) {
353 if (radeon_encoder
->devices
& (ATOM_DEVICE_TV_SUPPORT
)) {
354 if (common_modes
[i
].w
> 1024 ||
355 common_modes
[i
].h
> 768)
358 if (radeon_encoder
->devices
& (ATOM_DEVICE_LCD_SUPPORT
)) {
359 if (common_modes
[i
].w
> native_mode
->hdisplay
||
360 common_modes
[i
].h
> native_mode
->vdisplay
||
361 (common_modes
[i
].w
== native_mode
->hdisplay
&&
362 common_modes
[i
].h
== native_mode
->vdisplay
))
365 if (common_modes
[i
].w
< 320 || common_modes
[i
].h
< 200)
368 mode
= drm_cvt_mode(dev
, common_modes
[i
].w
, common_modes
[i
].h
, 60, false, false, false);
369 drm_mode_probed_add(connector
, mode
);
373 int radeon_connector_set_property(struct drm_connector
*connector
, struct drm_property
*property
,
376 struct drm_device
*dev
= connector
->dev
;
377 struct radeon_device
*rdev
= dev
->dev_private
;
378 struct drm_encoder
*encoder
;
379 struct radeon_encoder
*radeon_encoder
;
381 if (property
== rdev
->mode_info
.coherent_mode_property
) {
382 struct radeon_encoder_atom_dig
*dig
;
383 bool new_coherent_mode
;
385 /* need to find digital encoder on connector */
386 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TMDS
);
390 radeon_encoder
= to_radeon_encoder(encoder
);
392 if (!radeon_encoder
->enc_priv
)
395 dig
= radeon_encoder
->enc_priv
;
396 new_coherent_mode
= val
? true : false;
397 if (dig
->coherent_mode
!= new_coherent_mode
) {
398 dig
->coherent_mode
= new_coherent_mode
;
399 radeon_property_change_mode(&radeon_encoder
->base
);
403 if (property
== rdev
->mode_info
.underscan_property
) {
404 /* need to find digital encoder on connector */
405 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TMDS
);
409 radeon_encoder
= to_radeon_encoder(encoder
);
411 if (radeon_encoder
->underscan_type
!= val
) {
412 radeon_encoder
->underscan_type
= val
;
413 radeon_property_change_mode(&radeon_encoder
->base
);
417 if (property
== rdev
->mode_info
.underscan_hborder_property
) {
418 /* need to find digital encoder on connector */
419 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TMDS
);
423 radeon_encoder
= to_radeon_encoder(encoder
);
425 if (radeon_encoder
->underscan_hborder
!= val
) {
426 radeon_encoder
->underscan_hborder
= val
;
427 radeon_property_change_mode(&radeon_encoder
->base
);
431 if (property
== rdev
->mode_info
.underscan_vborder_property
) {
432 /* need to find digital encoder on connector */
433 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TMDS
);
437 radeon_encoder
= to_radeon_encoder(encoder
);
439 if (radeon_encoder
->underscan_vborder
!= val
) {
440 radeon_encoder
->underscan_vborder
= val
;
441 radeon_property_change_mode(&radeon_encoder
->base
);
445 if (property
== rdev
->mode_info
.tv_std_property
) {
446 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TVDAC
);
448 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_DAC
);
454 radeon_encoder
= to_radeon_encoder(encoder
);
455 if (!radeon_encoder
->enc_priv
)
457 if (ASIC_IS_AVIVO(rdev
) || radeon_r4xx_atom
) {
458 struct radeon_encoder_atom_dac
*dac_int
;
459 dac_int
= radeon_encoder
->enc_priv
;
460 dac_int
->tv_std
= val
;
462 struct radeon_encoder_tv_dac
*dac_int
;
463 dac_int
= radeon_encoder
->enc_priv
;
464 dac_int
->tv_std
= val
;
466 radeon_property_change_mode(&radeon_encoder
->base
);
469 if (property
== rdev
->mode_info
.load_detect_property
) {
470 struct radeon_connector
*radeon_connector
=
471 to_radeon_connector(connector
);
474 radeon_connector
->dac_load_detect
= false;
476 radeon_connector
->dac_load_detect
= true;
479 if (property
== rdev
->mode_info
.tmds_pll_property
) {
480 struct radeon_encoder_int_tmds
*tmds
= NULL
;
482 /* need to find digital encoder on connector */
483 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TMDS
);
487 radeon_encoder
= to_radeon_encoder(encoder
);
489 tmds
= radeon_encoder
->enc_priv
;
494 if (rdev
->is_atom_bios
)
495 ret
= radeon_atombios_get_tmds_info(radeon_encoder
, tmds
);
497 ret
= radeon_legacy_get_tmds_info_from_combios(radeon_encoder
, tmds
);
499 if (val
== 1 || ret
== false) {
500 radeon_legacy_get_tmds_info_from_table(radeon_encoder
, tmds
);
502 radeon_property_change_mode(&radeon_encoder
->base
);
508 static void radeon_fixup_lvds_native_mode(struct drm_encoder
*encoder
,
509 struct drm_connector
*connector
)
511 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
512 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
513 struct drm_display_mode
*t
, *mode
;
515 /* If the EDID preferred mode doesn't match the native mode, use it */
516 list_for_each_entry_safe(mode
, t
, &connector
->probed_modes
, head
) {
517 if (mode
->type
& DRM_MODE_TYPE_PREFERRED
) {
518 if (mode
->hdisplay
!= native_mode
->hdisplay
||
519 mode
->vdisplay
!= native_mode
->vdisplay
)
520 memcpy(native_mode
, mode
, sizeof(*mode
));
524 /* Try to get native mode details from EDID if necessary */
525 if (!native_mode
->clock
) {
526 list_for_each_entry_safe(mode
, t
, &connector
->probed_modes
, head
) {
527 if (mode
->hdisplay
== native_mode
->hdisplay
&&
528 mode
->vdisplay
== native_mode
->vdisplay
) {
529 *native_mode
= *mode
;
530 drm_mode_set_crtcinfo(native_mode
, CRTC_INTERLACE_HALVE_V
);
531 DRM_DEBUG_KMS("Determined LVDS native mode details from EDID\n");
537 if (!native_mode
->clock
) {
538 DRM_DEBUG_KMS("No LVDS native mode details, disabling RMX\n");
539 radeon_encoder
->rmx_type
= RMX_OFF
;
543 static int radeon_lvds_get_modes(struct drm_connector
*connector
)
545 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
546 struct drm_encoder
*encoder
;
548 struct drm_display_mode
*mode
;
550 if (radeon_connector
->ddc_bus
) {
551 ret
= radeon_ddc_get_modes(radeon_connector
);
553 encoder
= radeon_best_single_encoder(connector
);
555 radeon_fixup_lvds_native_mode(encoder
, connector
);
556 /* add scaled modes */
557 radeon_add_common_modes(encoder
, connector
);
563 encoder
= radeon_best_single_encoder(connector
);
567 /* we have no EDID modes */
568 mode
= radeon_fp_native_mode(encoder
);
571 drm_mode_probed_add(connector
, mode
);
572 /* add the width/height from vbios tables if available */
573 connector
->display_info
.width_mm
= mode
->width_mm
;
574 connector
->display_info
.height_mm
= mode
->height_mm
;
575 /* add scaled modes */
576 radeon_add_common_modes(encoder
, connector
);
582 static int radeon_lvds_mode_valid(struct drm_connector
*connector
,
583 struct drm_display_mode
*mode
)
585 struct drm_encoder
*encoder
= radeon_best_single_encoder(connector
);
587 if ((mode
->hdisplay
< 320) || (mode
->vdisplay
< 240))
591 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
592 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
594 /* AVIVO hardware supports downscaling modes larger than the panel
595 * to the panel size, but I'm not sure this is desirable.
597 if ((mode
->hdisplay
> native_mode
->hdisplay
) ||
598 (mode
->vdisplay
> native_mode
->vdisplay
))
601 /* if scaling is disabled, block non-native modes */
602 if (radeon_encoder
->rmx_type
== RMX_OFF
) {
603 if ((mode
->hdisplay
!= native_mode
->hdisplay
) ||
604 (mode
->vdisplay
!= native_mode
->vdisplay
))
612 static enum drm_connector_status
613 radeon_lvds_detect(struct drm_connector
*connector
, bool force
)
615 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
616 struct drm_encoder
*encoder
= radeon_best_single_encoder(connector
);
617 enum drm_connector_status ret
= connector_status_disconnected
;
620 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
621 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
623 /* check if panel is valid */
624 if (native_mode
->hdisplay
>= 320 && native_mode
->vdisplay
>= 240)
625 ret
= connector_status_connected
;
629 /* check for edid as well */
630 if (radeon_connector
->edid
)
631 ret
= connector_status_connected
;
633 if (radeon_connector
->ddc_bus
) {
634 radeon_connector
->edid
= drm_get_edid(&radeon_connector
->base
,
635 &radeon_connector
->ddc_bus
->adapter
);
636 if (radeon_connector
->edid
)
637 ret
= connector_status_connected
;
640 /* check acpi lid status ??? */
642 radeon_connector_update_scratch_regs(connector
, ret
);
646 static void radeon_connector_destroy(struct drm_connector
*connector
)
648 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
650 if (radeon_connector
->edid
)
651 kfree(radeon_connector
->edid
);
652 kfree(radeon_connector
->con_priv
);
653 drm_sysfs_connector_remove(connector
);
654 drm_connector_cleanup(connector
);
658 static int radeon_lvds_set_property(struct drm_connector
*connector
,
659 struct drm_property
*property
,
662 struct drm_device
*dev
= connector
->dev
;
663 struct radeon_encoder
*radeon_encoder
;
664 enum radeon_rmx_type rmx_type
;
667 if (property
!= dev
->mode_config
.scaling_mode_property
)
670 if (connector
->encoder
)
671 radeon_encoder
= to_radeon_encoder(connector
->encoder
);
673 struct drm_connector_helper_funcs
*connector_funcs
= connector
->helper_private
;
674 radeon_encoder
= to_radeon_encoder(connector_funcs
->best_encoder(connector
));
678 case DRM_MODE_SCALE_NONE
: rmx_type
= RMX_OFF
; break;
679 case DRM_MODE_SCALE_CENTER
: rmx_type
= RMX_CENTER
; break;
680 case DRM_MODE_SCALE_ASPECT
: rmx_type
= RMX_ASPECT
; break;
682 case DRM_MODE_SCALE_FULLSCREEN
: rmx_type
= RMX_FULL
; break;
684 if (radeon_encoder
->rmx_type
== rmx_type
)
687 radeon_encoder
->rmx_type
= rmx_type
;
689 radeon_property_change_mode(&radeon_encoder
->base
);
694 struct drm_connector_helper_funcs radeon_lvds_connector_helper_funcs
= {
695 .get_modes
= radeon_lvds_get_modes
,
696 .mode_valid
= radeon_lvds_mode_valid
,
697 .best_encoder
= radeon_best_single_encoder
,
700 struct drm_connector_funcs radeon_lvds_connector_funcs
= {
701 .dpms
= drm_helper_connector_dpms
,
702 .detect
= radeon_lvds_detect
,
703 .fill_modes
= drm_helper_probe_single_connector_modes
,
704 .destroy
= radeon_connector_destroy
,
705 .set_property
= radeon_lvds_set_property
,
708 static int radeon_vga_get_modes(struct drm_connector
*connector
)
710 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
713 ret
= radeon_ddc_get_modes(radeon_connector
);
718 static int radeon_vga_mode_valid(struct drm_connector
*connector
,
719 struct drm_display_mode
*mode
)
721 struct drm_device
*dev
= connector
->dev
;
722 struct radeon_device
*rdev
= dev
->dev_private
;
724 /* XXX check mode bandwidth */
726 if ((mode
->clock
/ 10) > rdev
->clock
.max_pixel_clock
)
727 return MODE_CLOCK_HIGH
;
732 static enum drm_connector_status
733 radeon_vga_detect(struct drm_connector
*connector
, bool force
)
735 struct drm_device
*dev
= connector
->dev
;
736 struct radeon_device
*rdev
= dev
->dev_private
;
737 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
738 struct drm_encoder
*encoder
;
739 struct drm_encoder_helper_funcs
*encoder_funcs
;
741 enum drm_connector_status ret
= connector_status_disconnected
;
743 encoder
= radeon_best_single_encoder(connector
);
745 ret
= connector_status_disconnected
;
747 if (radeon_connector
->ddc_bus
)
748 dret
= radeon_ddc_probe(radeon_connector
);
750 radeon_connector
->detected_by_load
= false;
751 if (radeon_connector
->edid
) {
752 kfree(radeon_connector
->edid
);
753 radeon_connector
->edid
= NULL
;
755 radeon_connector
->edid
= drm_get_edid(&radeon_connector
->base
, &radeon_connector
->ddc_bus
->adapter
);
757 if (!radeon_connector
->edid
) {
758 DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
759 drm_get_connector_name(connector
));
760 ret
= connector_status_connected
;
762 radeon_connector
->use_digital
= !!(radeon_connector
->edid
->input
& DRM_EDID_INPUT_DIGITAL
);
764 /* some oems have boards with separate digital and analog connectors
765 * with a shared ddc line (often vga + hdmi)
767 if (radeon_connector
->use_digital
&& radeon_connector
->shared_ddc
) {
768 kfree(radeon_connector
->edid
);
769 radeon_connector
->edid
= NULL
;
770 ret
= connector_status_disconnected
;
772 ret
= connector_status_connected
;
776 /* if we aren't forcing don't do destructive polling */
778 /* only return the previous status if we last
779 * detected a monitor via load.
781 if (radeon_connector
->detected_by_load
)
782 return connector
->status
;
787 if (radeon_connector
->dac_load_detect
&& encoder
) {
788 encoder_funcs
= encoder
->helper_private
;
789 ret
= encoder_funcs
->detect(encoder
, connector
);
790 if (ret
!= connector_status_disconnected
)
791 radeon_connector
->detected_by_load
= true;
795 if (ret
== connector_status_connected
)
796 ret
= radeon_connector_analog_encoder_conflict_solve(connector
, encoder
, ret
, true);
798 /* RN50 and some RV100 asics in servers often have a hardcoded EDID in the
799 * vbios to deal with KVMs. If we have one and are not able to detect a monitor
800 * by other means, assume the CRT is connected and use that EDID.
802 if ((!rdev
->is_atom_bios
) &&
803 (ret
== connector_status_disconnected
) &&
804 rdev
->mode_info
.bios_hardcoded_edid_size
) {
805 ret
= connector_status_connected
;
808 radeon_connector_update_scratch_regs(connector
, ret
);
812 struct drm_connector_helper_funcs radeon_vga_connector_helper_funcs
= {
813 .get_modes
= radeon_vga_get_modes
,
814 .mode_valid
= radeon_vga_mode_valid
,
815 .best_encoder
= radeon_best_single_encoder
,
818 struct drm_connector_funcs radeon_vga_connector_funcs
= {
819 .dpms
= drm_helper_connector_dpms
,
820 .detect
= radeon_vga_detect
,
821 .fill_modes
= drm_helper_probe_single_connector_modes
,
822 .destroy
= radeon_connector_destroy
,
823 .set_property
= radeon_connector_set_property
,
826 static int radeon_tv_get_modes(struct drm_connector
*connector
)
828 struct drm_device
*dev
= connector
->dev
;
829 struct radeon_device
*rdev
= dev
->dev_private
;
830 struct drm_display_mode
*tv_mode
;
831 struct drm_encoder
*encoder
;
833 encoder
= radeon_best_single_encoder(connector
);
837 /* avivo chips can scale any mode */
838 if (rdev
->family
>= CHIP_RS600
)
839 /* add scaled modes */
840 radeon_add_common_modes(encoder
, connector
);
842 /* only 800x600 is supported right now on pre-avivo chips */
843 tv_mode
= drm_cvt_mode(dev
, 800, 600, 60, false, false, false);
844 tv_mode
->type
= DRM_MODE_TYPE_DRIVER
| DRM_MODE_TYPE_PREFERRED
;
845 drm_mode_probed_add(connector
, tv_mode
);
850 static int radeon_tv_mode_valid(struct drm_connector
*connector
,
851 struct drm_display_mode
*mode
)
853 if ((mode
->hdisplay
> 1024) || (mode
->vdisplay
> 768))
854 return MODE_CLOCK_RANGE
;
858 static enum drm_connector_status
859 radeon_tv_detect(struct drm_connector
*connector
, bool force
)
861 struct drm_encoder
*encoder
;
862 struct drm_encoder_helper_funcs
*encoder_funcs
;
863 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
864 enum drm_connector_status ret
= connector_status_disconnected
;
866 if (!radeon_connector
->dac_load_detect
)
869 encoder
= radeon_best_single_encoder(connector
);
871 ret
= connector_status_disconnected
;
873 encoder_funcs
= encoder
->helper_private
;
874 ret
= encoder_funcs
->detect(encoder
, connector
);
876 if (ret
== connector_status_connected
)
877 ret
= radeon_connector_analog_encoder_conflict_solve(connector
, encoder
, ret
, false);
878 radeon_connector_update_scratch_regs(connector
, ret
);
882 struct drm_connector_helper_funcs radeon_tv_connector_helper_funcs
= {
883 .get_modes
= radeon_tv_get_modes
,
884 .mode_valid
= radeon_tv_mode_valid
,
885 .best_encoder
= radeon_best_single_encoder
,
888 struct drm_connector_funcs radeon_tv_connector_funcs
= {
889 .dpms
= drm_helper_connector_dpms
,
890 .detect
= radeon_tv_detect
,
891 .fill_modes
= drm_helper_probe_single_connector_modes
,
892 .destroy
= radeon_connector_destroy
,
893 .set_property
= radeon_connector_set_property
,
896 static int radeon_dvi_get_modes(struct drm_connector
*connector
)
898 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
901 ret
= radeon_ddc_get_modes(radeon_connector
);
905 static bool radeon_check_hpd_status_unchanged(struct drm_connector
*connector
)
907 struct drm_device
*dev
= connector
->dev
;
908 struct radeon_device
*rdev
= dev
->dev_private
;
909 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
910 enum drm_connector_status status
;
912 /* We only trust HPD on R600 and newer ASICS. */
913 if (rdev
->family
>= CHIP_R600
914 && radeon_connector
->hpd
.hpd
!= RADEON_HPD_NONE
) {
915 if (radeon_hpd_sense(rdev
, radeon_connector
->hpd
.hpd
))
916 status
= connector_status_connected
;
918 status
= connector_status_disconnected
;
919 if (connector
->status
== status
)
928 * Do a DDC probe, if DDC probe passes, get the full EDID so
929 * we can do analog/digital monitor detection at this point.
930 * If the monitor is an analog monitor or we got no DDC,
931 * we need to find the DAC encoder object for this connector.
932 * If we got no DDC, we do load detection on the DAC encoder object.
933 * If we got analog DDC or load detection passes on the DAC encoder
934 * we have to check if this analog encoder is shared with anyone else (TV)
935 * if its shared we have to set the other connector to disconnected.
937 static enum drm_connector_status
938 radeon_dvi_detect(struct drm_connector
*connector
, bool force
)
940 struct drm_device
*dev
= connector
->dev
;
941 struct radeon_device
*rdev
= dev
->dev_private
;
942 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
943 struct drm_encoder
*encoder
= NULL
;
944 struct drm_encoder_helper_funcs
*encoder_funcs
;
945 struct drm_mode_object
*obj
;
947 enum drm_connector_status ret
= connector_status_disconnected
;
950 if (!force
&& radeon_check_hpd_status_unchanged(connector
))
951 return connector
->status
;
953 if (radeon_connector
->ddc_bus
)
954 dret
= radeon_ddc_probe(radeon_connector
);
956 radeon_connector
->detected_by_load
= false;
957 if (radeon_connector
->edid
) {
958 kfree(radeon_connector
->edid
);
959 radeon_connector
->edid
= NULL
;
961 radeon_connector
->edid
= drm_get_edid(&radeon_connector
->base
, &radeon_connector
->ddc_bus
->adapter
);
963 if (!radeon_connector
->edid
) {
964 DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
965 drm_get_connector_name(connector
));
966 /* rs690 seems to have a problem with connectors not existing and always
967 * return a block of 0's. If we see this just stop polling on this output */
968 if ((rdev
->family
== CHIP_RS690
|| rdev
->family
== CHIP_RS740
) && radeon_connector
->base
.null_edid_counter
) {
969 ret
= connector_status_disconnected
;
970 DRM_ERROR("%s: detected RS690 floating bus bug, stopping ddc detect\n", drm_get_connector_name(connector
));
971 radeon_connector
->ddc_bus
= NULL
;
974 radeon_connector
->use_digital
= !!(radeon_connector
->edid
->input
& DRM_EDID_INPUT_DIGITAL
);
976 /* some oems have boards with separate digital and analog connectors
977 * with a shared ddc line (often vga + hdmi)
979 if ((!radeon_connector
->use_digital
) && radeon_connector
->shared_ddc
) {
980 kfree(radeon_connector
->edid
);
981 radeon_connector
->edid
= NULL
;
982 ret
= connector_status_disconnected
;
984 ret
= connector_status_connected
;
986 /* This gets complicated. We have boards with VGA + HDMI with a
987 * shared DDC line and we have boards with DVI-D + HDMI with a shared
988 * DDC line. The latter is more complex because with DVI<->HDMI adapters
989 * you don't really know what's connected to which port as both are digital.
991 if (radeon_connector
->shared_ddc
&& (ret
== connector_status_connected
)) {
992 struct drm_connector
*list_connector
;
993 struct radeon_connector
*list_radeon_connector
;
994 list_for_each_entry(list_connector
, &dev
->mode_config
.connector_list
, head
) {
995 if (connector
== list_connector
)
997 list_radeon_connector
= to_radeon_connector(list_connector
);
998 if (list_radeon_connector
->shared_ddc
&&
999 (list_radeon_connector
->ddc_bus
->rec
.i2c_id
==
1000 radeon_connector
->ddc_bus
->rec
.i2c_id
)) {
1001 /* cases where both connectors are digital */
1002 if (list_connector
->connector_type
!= DRM_MODE_CONNECTOR_VGA
) {
1003 /* hpd is our only option in this case */
1004 if (!radeon_hpd_sense(rdev
, radeon_connector
->hpd
.hpd
)) {
1005 kfree(radeon_connector
->edid
);
1006 radeon_connector
->edid
= NULL
;
1007 ret
= connector_status_disconnected
;
1016 if ((ret
== connector_status_connected
) && (radeon_connector
->use_digital
== true))
1019 /* DVI-D and HDMI-A are digital only */
1020 if ((connector
->connector_type
== DRM_MODE_CONNECTOR_DVID
) ||
1021 (connector
->connector_type
== DRM_MODE_CONNECTOR_HDMIA
))
1024 /* if we aren't forcing don't do destructive polling */
1026 /* only return the previous status if we last
1027 * detected a monitor via load.
1029 if (radeon_connector
->detected_by_load
)
1030 ret
= connector
->status
;
1034 /* find analog encoder */
1035 if (radeon_connector
->dac_load_detect
) {
1036 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
1037 if (connector
->encoder_ids
[i
] == 0)
1040 obj
= drm_mode_object_find(connector
->dev
,
1041 connector
->encoder_ids
[i
],
1042 DRM_MODE_OBJECT_ENCODER
);
1046 encoder
= obj_to_encoder(obj
);
1048 if (encoder
->encoder_type
!= DRM_MODE_ENCODER_DAC
&&
1049 encoder
->encoder_type
!= DRM_MODE_ENCODER_TVDAC
)
1052 encoder_funcs
= encoder
->helper_private
;
1053 if (encoder_funcs
->detect
) {
1054 if (ret
!= connector_status_connected
) {
1055 ret
= encoder_funcs
->detect(encoder
, connector
);
1056 if (ret
== connector_status_connected
) {
1057 radeon_connector
->use_digital
= false;
1059 if (ret
!= connector_status_disconnected
)
1060 radeon_connector
->detected_by_load
= true;
1067 if ((ret
== connector_status_connected
) && (radeon_connector
->use_digital
== false) &&
1069 ret
= radeon_connector_analog_encoder_conflict_solve(connector
, encoder
, ret
, true);
1072 /* RN50 and some RV100 asics in servers often have a hardcoded EDID in the
1073 * vbios to deal with KVMs. If we have one and are not able to detect a monitor
1074 * by other means, assume the DFP is connected and use that EDID. In most
1075 * cases the DVI port is actually a virtual KVM port connected to the service
1079 if ((!rdev
->is_atom_bios
) &&
1080 (ret
== connector_status_disconnected
) &&
1081 rdev
->mode_info
.bios_hardcoded_edid_size
) {
1082 radeon_connector
->use_digital
= true;
1083 ret
= connector_status_connected
;
1086 /* updated in get modes as well since we need to know if it's analog or digital */
1087 radeon_connector_update_scratch_regs(connector
, ret
);
1091 /* okay need to be smart in here about which encoder to pick */
1092 struct drm_encoder
*radeon_dvi_encoder(struct drm_connector
*connector
)
1094 int enc_id
= connector
->encoder_ids
[0];
1095 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1096 struct drm_mode_object
*obj
;
1097 struct drm_encoder
*encoder
;
1099 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
1100 if (connector
->encoder_ids
[i
] == 0)
1103 obj
= drm_mode_object_find(connector
->dev
, connector
->encoder_ids
[i
], DRM_MODE_OBJECT_ENCODER
);
1107 encoder
= obj_to_encoder(obj
);
1109 if (radeon_connector
->use_digital
== true) {
1110 if (encoder
->encoder_type
== DRM_MODE_ENCODER_TMDS
)
1113 if (encoder
->encoder_type
== DRM_MODE_ENCODER_DAC
||
1114 encoder
->encoder_type
== DRM_MODE_ENCODER_TVDAC
)
1119 /* see if we have a default encoder TODO */
1121 /* then check use digitial */
1122 /* pick the first one */
1124 obj
= drm_mode_object_find(connector
->dev
, enc_id
, DRM_MODE_OBJECT_ENCODER
);
1127 encoder
= obj_to_encoder(obj
);
1133 static void radeon_dvi_force(struct drm_connector
*connector
)
1135 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1136 if (connector
->force
== DRM_FORCE_ON
)
1137 radeon_connector
->use_digital
= false;
1138 if (connector
->force
== DRM_FORCE_ON_DIGITAL
)
1139 radeon_connector
->use_digital
= true;
1142 static int radeon_dvi_mode_valid(struct drm_connector
*connector
,
1143 struct drm_display_mode
*mode
)
1145 struct drm_device
*dev
= connector
->dev
;
1146 struct radeon_device
*rdev
= dev
->dev_private
;
1147 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1149 /* XXX check mode bandwidth */
1151 /* clocks over 135 MHz have heat issues with DVI on RV100 */
1152 if (radeon_connector
->use_digital
&&
1153 (rdev
->family
== CHIP_RV100
) &&
1154 (mode
->clock
> 135000))
1155 return MODE_CLOCK_HIGH
;
1157 if (radeon_connector
->use_digital
&& (mode
->clock
> 165000)) {
1158 if ((radeon_connector
->connector_object_id
== CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_I
) ||
1159 (radeon_connector
->connector_object_id
== CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_D
) ||
1160 (radeon_connector
->connector_object_id
== CONNECTOR_OBJECT_ID_HDMI_TYPE_B
))
1162 else if (radeon_connector
->connector_object_id
== CONNECTOR_OBJECT_ID_HDMI_TYPE_A
) {
1163 if (ASIC_IS_DCE6(rdev
)) {
1164 /* HDMI 1.3+ supports max clock of 340 Mhz */
1165 if (mode
->clock
> 340000)
1166 return MODE_CLOCK_HIGH
;
1170 return MODE_CLOCK_HIGH
;
1172 return MODE_CLOCK_HIGH
;
1175 /* check against the max pixel clock */
1176 if ((mode
->clock
/ 10) > rdev
->clock
.max_pixel_clock
)
1177 return MODE_CLOCK_HIGH
;
1182 struct drm_connector_helper_funcs radeon_dvi_connector_helper_funcs
= {
1183 .get_modes
= radeon_dvi_get_modes
,
1184 .mode_valid
= radeon_dvi_mode_valid
,
1185 .best_encoder
= radeon_dvi_encoder
,
1188 struct drm_connector_funcs radeon_dvi_connector_funcs
= {
1189 .dpms
= drm_helper_connector_dpms
,
1190 .detect
= radeon_dvi_detect
,
1191 .fill_modes
= drm_helper_probe_single_connector_modes
,
1192 .set_property
= radeon_connector_set_property
,
1193 .destroy
= radeon_connector_destroy
,
1194 .force
= radeon_dvi_force
,
1197 static void radeon_dp_connector_destroy(struct drm_connector
*connector
)
1199 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1200 struct radeon_connector_atom_dig
*radeon_dig_connector
= radeon_connector
->con_priv
;
1202 if (radeon_connector
->edid
)
1203 kfree(radeon_connector
->edid
);
1204 if (radeon_dig_connector
->dp_i2c_bus
)
1205 radeon_i2c_destroy(radeon_dig_connector
->dp_i2c_bus
);
1206 kfree(radeon_connector
->con_priv
);
1207 drm_sysfs_connector_remove(connector
);
1208 drm_connector_cleanup(connector
);
1212 static int radeon_dp_get_modes(struct drm_connector
*connector
)
1214 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1215 struct radeon_connector_atom_dig
*radeon_dig_connector
= radeon_connector
->con_priv
;
1216 struct drm_encoder
*encoder
= radeon_best_single_encoder(connector
);
1219 if ((connector
->connector_type
== DRM_MODE_CONNECTOR_eDP
) ||
1220 (connector
->connector_type
== DRM_MODE_CONNECTOR_LVDS
)) {
1221 struct drm_display_mode
*mode
;
1223 if (connector
->connector_type
== DRM_MODE_CONNECTOR_eDP
) {
1224 if (!radeon_dig_connector
->edp_on
)
1225 atombios_set_edp_panel_power(connector
,
1226 ATOM_TRANSMITTER_ACTION_POWER_ON
);
1227 ret
= radeon_ddc_get_modes(radeon_connector
);
1228 if (!radeon_dig_connector
->edp_on
)
1229 atombios_set_edp_panel_power(connector
,
1230 ATOM_TRANSMITTER_ACTION_POWER_OFF
);
1232 /* need to setup ddc on the bridge */
1233 if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector
) !=
1234 ENCODER_OBJECT_ID_NONE
) {
1236 radeon_atom_ext_encoder_setup_ddc(encoder
);
1238 ret
= radeon_ddc_get_modes(radeon_connector
);
1243 radeon_fixup_lvds_native_mode(encoder
, connector
);
1244 /* add scaled modes */
1245 radeon_add_common_modes(encoder
, connector
);
1253 /* we have no EDID modes */
1254 mode
= radeon_fp_native_mode(encoder
);
1257 drm_mode_probed_add(connector
, mode
);
1258 /* add the width/height from vbios tables if available */
1259 connector
->display_info
.width_mm
= mode
->width_mm
;
1260 connector
->display_info
.height_mm
= mode
->height_mm
;
1261 /* add scaled modes */
1262 radeon_add_common_modes(encoder
, connector
);
1265 /* need to setup ddc on the bridge */
1266 if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector
) !=
1267 ENCODER_OBJECT_ID_NONE
) {
1269 radeon_atom_ext_encoder_setup_ddc(encoder
);
1271 ret
= radeon_ddc_get_modes(radeon_connector
);
1277 u16
radeon_connector_encoder_get_dp_bridge_encoder_id(struct drm_connector
*connector
)
1279 struct drm_mode_object
*obj
;
1280 struct drm_encoder
*encoder
;
1281 struct radeon_encoder
*radeon_encoder
;
1284 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
1285 if (connector
->encoder_ids
[i
] == 0)
1288 obj
= drm_mode_object_find(connector
->dev
, connector
->encoder_ids
[i
], DRM_MODE_OBJECT_ENCODER
);
1292 encoder
= obj_to_encoder(obj
);
1293 radeon_encoder
= to_radeon_encoder(encoder
);
1295 switch (radeon_encoder
->encoder_id
) {
1296 case ENCODER_OBJECT_ID_TRAVIS
:
1297 case ENCODER_OBJECT_ID_NUTMEG
:
1298 return radeon_encoder
->encoder_id
;
1304 return ENCODER_OBJECT_ID_NONE
;
1307 bool radeon_connector_encoder_is_hbr2(struct drm_connector
*connector
)
1309 struct drm_mode_object
*obj
;
1310 struct drm_encoder
*encoder
;
1311 struct radeon_encoder
*radeon_encoder
;
1315 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
1316 if (connector
->encoder_ids
[i
] == 0)
1319 obj
= drm_mode_object_find(connector
->dev
, connector
->encoder_ids
[i
], DRM_MODE_OBJECT_ENCODER
);
1323 encoder
= obj_to_encoder(obj
);
1324 radeon_encoder
= to_radeon_encoder(encoder
);
1325 if (radeon_encoder
->caps
& ATOM_ENCODER_CAP_RECORD_HBR2
)
1332 bool radeon_connector_is_dp12_capable(struct drm_connector
*connector
)
1334 struct drm_device
*dev
= connector
->dev
;
1335 struct radeon_device
*rdev
= dev
->dev_private
;
1337 if (ASIC_IS_DCE5(rdev
) &&
1338 (rdev
->clock
.dp_extclk
>= 53900) &&
1339 radeon_connector_encoder_is_hbr2(connector
)) {
1346 static enum drm_connector_status
1347 radeon_dp_detect(struct drm_connector
*connector
, bool force
)
1349 struct drm_device
*dev
= connector
->dev
;
1350 struct radeon_device
*rdev
= dev
->dev_private
;
1351 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1352 enum drm_connector_status ret
= connector_status_disconnected
;
1353 struct radeon_connector_atom_dig
*radeon_dig_connector
= radeon_connector
->con_priv
;
1354 struct drm_encoder
*encoder
= radeon_best_single_encoder(connector
);
1356 if (!force
&& radeon_check_hpd_status_unchanged(connector
))
1357 return connector
->status
;
1359 if (radeon_connector
->edid
) {
1360 kfree(radeon_connector
->edid
);
1361 radeon_connector
->edid
= NULL
;
1364 if ((connector
->connector_type
== DRM_MODE_CONNECTOR_eDP
) ||
1365 (connector
->connector_type
== DRM_MODE_CONNECTOR_LVDS
)) {
1367 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
1368 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
1370 /* check if panel is valid */
1371 if (native_mode
->hdisplay
>= 320 && native_mode
->vdisplay
>= 240)
1372 ret
= connector_status_connected
;
1374 /* eDP is always DP */
1375 radeon_dig_connector
->dp_sink_type
= CONNECTOR_OBJECT_ID_DISPLAYPORT
;
1376 if (!radeon_dig_connector
->edp_on
)
1377 atombios_set_edp_panel_power(connector
,
1378 ATOM_TRANSMITTER_ACTION_POWER_ON
);
1379 if (radeon_dp_getdpcd(radeon_connector
))
1380 ret
= connector_status_connected
;
1381 if (!radeon_dig_connector
->edp_on
)
1382 atombios_set_edp_panel_power(connector
,
1383 ATOM_TRANSMITTER_ACTION_POWER_OFF
);
1384 } else if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector
) !=
1385 ENCODER_OBJECT_ID_NONE
) {
1386 /* DP bridges are always DP */
1387 radeon_dig_connector
->dp_sink_type
= CONNECTOR_OBJECT_ID_DISPLAYPORT
;
1388 /* get the DPCD from the bridge */
1389 radeon_dp_getdpcd(radeon_connector
);
1392 /* setup ddc on the bridge */
1393 radeon_atom_ext_encoder_setup_ddc(encoder
);
1394 if (radeon_ddc_probe(radeon_connector
)) /* try DDC */
1395 ret
= connector_status_connected
;
1396 else if (radeon_connector
->dac_load_detect
) { /* try load detection */
1397 struct drm_encoder_helper_funcs
*encoder_funcs
= encoder
->helper_private
;
1398 ret
= encoder_funcs
->detect(encoder
, connector
);
1402 radeon_dig_connector
->dp_sink_type
= radeon_dp_getsinktype(radeon_connector
);
1403 if (radeon_hpd_sense(rdev
, radeon_connector
->hpd
.hpd
)) {
1404 ret
= connector_status_connected
;
1405 if (radeon_dig_connector
->dp_sink_type
== CONNECTOR_OBJECT_ID_DISPLAYPORT
)
1406 radeon_dp_getdpcd(radeon_connector
);
1408 if (radeon_dig_connector
->dp_sink_type
== CONNECTOR_OBJECT_ID_DISPLAYPORT
) {
1409 if (radeon_dp_getdpcd(radeon_connector
))
1410 ret
= connector_status_connected
;
1412 if (radeon_ddc_probe(radeon_connector
))
1413 ret
= connector_status_connected
;
1418 radeon_connector_update_scratch_regs(connector
, ret
);
1422 static int radeon_dp_mode_valid(struct drm_connector
*connector
,
1423 struct drm_display_mode
*mode
)
1425 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1426 struct radeon_connector_atom_dig
*radeon_dig_connector
= radeon_connector
->con_priv
;
1428 /* XXX check mode bandwidth */
1430 if ((connector
->connector_type
== DRM_MODE_CONNECTOR_eDP
) ||
1431 (connector
->connector_type
== DRM_MODE_CONNECTOR_LVDS
)) {
1432 struct drm_encoder
*encoder
= radeon_best_single_encoder(connector
);
1434 if ((mode
->hdisplay
< 320) || (mode
->vdisplay
< 240))
1438 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
1439 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
1441 /* AVIVO hardware supports downscaling modes larger than the panel
1442 * to the panel size, but I'm not sure this is desirable.
1444 if ((mode
->hdisplay
> native_mode
->hdisplay
) ||
1445 (mode
->vdisplay
> native_mode
->vdisplay
))
1448 /* if scaling is disabled, block non-native modes */
1449 if (radeon_encoder
->rmx_type
== RMX_OFF
) {
1450 if ((mode
->hdisplay
!= native_mode
->hdisplay
) ||
1451 (mode
->vdisplay
!= native_mode
->vdisplay
))
1457 if ((radeon_dig_connector
->dp_sink_type
== CONNECTOR_OBJECT_ID_DISPLAYPORT
) ||
1458 (radeon_dig_connector
->dp_sink_type
== CONNECTOR_OBJECT_ID_eDP
))
1459 return radeon_dp_mode_valid_helper(connector
, mode
);
1465 struct drm_connector_helper_funcs radeon_dp_connector_helper_funcs
= {
1466 .get_modes
= radeon_dp_get_modes
,
1467 .mode_valid
= radeon_dp_mode_valid
,
1468 .best_encoder
= radeon_dvi_encoder
,
1471 struct drm_connector_funcs radeon_dp_connector_funcs
= {
1472 .dpms
= drm_helper_connector_dpms
,
1473 .detect
= radeon_dp_detect
,
1474 .fill_modes
= drm_helper_probe_single_connector_modes
,
1475 .set_property
= radeon_connector_set_property
,
1476 .destroy
= radeon_dp_connector_destroy
,
1477 .force
= radeon_dvi_force
,
1481 radeon_add_atom_connector(struct drm_device
*dev
,
1482 uint32_t connector_id
,
1483 uint32_t supported_device
,
1485 struct radeon_i2c_bus_rec
*i2c_bus
,
1486 uint32_t igp_lane_info
,
1487 uint16_t connector_object_id
,
1488 struct radeon_hpd
*hpd
,
1489 struct radeon_router
*router
)
1491 struct radeon_device
*rdev
= dev
->dev_private
;
1492 struct drm_connector
*connector
;
1493 struct radeon_connector
*radeon_connector
;
1494 struct radeon_connector_atom_dig
*radeon_dig_connector
;
1495 struct drm_encoder
*encoder
;
1496 struct radeon_encoder
*radeon_encoder
;
1497 uint32_t subpixel_order
= SubPixelNone
;
1498 bool shared_ddc
= false;
1499 bool is_dp_bridge
= false;
1501 if (connector_type
== DRM_MODE_CONNECTOR_Unknown
)
1504 /* if the user selected tv=0 don't try and add the connector */
1505 if (((connector_type
== DRM_MODE_CONNECTOR_SVIDEO
) ||
1506 (connector_type
== DRM_MODE_CONNECTOR_Composite
) ||
1507 (connector_type
== DRM_MODE_CONNECTOR_9PinDIN
)) &&
1511 /* see if we already added it */
1512 list_for_each_entry(connector
, &dev
->mode_config
.connector_list
, head
) {
1513 radeon_connector
= to_radeon_connector(connector
);
1514 if (radeon_connector
->connector_id
== connector_id
) {
1515 radeon_connector
->devices
|= supported_device
;
1518 if (radeon_connector
->ddc_bus
&& i2c_bus
->valid
) {
1519 if (radeon_connector
->ddc_bus
->rec
.i2c_id
== i2c_bus
->i2c_id
) {
1520 radeon_connector
->shared_ddc
= true;
1523 if (radeon_connector
->router_bus
&& router
->ddc_valid
&&
1524 (radeon_connector
->router
.router_id
== router
->router_id
)) {
1525 radeon_connector
->shared_ddc
= false;
1531 /* check if it's a dp bridge */
1532 list_for_each_entry(encoder
, &dev
->mode_config
.encoder_list
, head
) {
1533 radeon_encoder
= to_radeon_encoder(encoder
);
1534 if (radeon_encoder
->devices
& supported_device
) {
1535 switch (radeon_encoder
->encoder_id
) {
1536 case ENCODER_OBJECT_ID_TRAVIS
:
1537 case ENCODER_OBJECT_ID_NUTMEG
:
1538 is_dp_bridge
= true;
1546 radeon_connector
= kzalloc(sizeof(struct radeon_connector
), GFP_KERNEL
);
1547 if (!radeon_connector
)
1550 connector
= &radeon_connector
->base
;
1552 radeon_connector
->connector_id
= connector_id
;
1553 radeon_connector
->devices
= supported_device
;
1554 radeon_connector
->shared_ddc
= shared_ddc
;
1555 radeon_connector
->connector_object_id
= connector_object_id
;
1556 radeon_connector
->hpd
= *hpd
;
1558 radeon_connector
->router
= *router
;
1559 if (router
->ddc_valid
|| router
->cd_valid
) {
1560 radeon_connector
->router_bus
= radeon_i2c_lookup(rdev
, &router
->i2c_info
);
1561 if (!radeon_connector
->router_bus
)
1562 DRM_ERROR("Failed to assign router i2c bus! Check dmesg for i2c errors.\n");
1566 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
1567 if (!radeon_dig_connector
)
1569 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
1570 radeon_connector
->con_priv
= radeon_dig_connector
;
1571 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_dp_connector_funcs
, connector_type
);
1572 drm_connector_helper_add(&radeon_connector
->base
, &radeon_dp_connector_helper_funcs
);
1573 if (i2c_bus
->valid
) {
1574 /* add DP i2c bus */
1575 if (connector_type
== DRM_MODE_CONNECTOR_eDP
)
1576 radeon_dig_connector
->dp_i2c_bus
= radeon_i2c_create_dp(dev
, i2c_bus
, "eDP-auxch");
1578 radeon_dig_connector
->dp_i2c_bus
= radeon_i2c_create_dp(dev
, i2c_bus
, "DP-auxch");
1579 if (!radeon_dig_connector
->dp_i2c_bus
)
1580 DRM_ERROR("DP: Failed to assign dp ddc bus! Check dmesg for i2c errors.\n");
1581 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1582 if (!radeon_connector
->ddc_bus
)
1583 DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1585 switch (connector_type
) {
1586 case DRM_MODE_CONNECTOR_VGA
:
1587 case DRM_MODE_CONNECTOR_DVIA
:
1589 connector
->interlace_allowed
= true;
1590 connector
->doublescan_allowed
= true;
1591 radeon_connector
->dac_load_detect
= true;
1592 drm_connector_attach_property(&radeon_connector
->base
,
1593 rdev
->mode_info
.load_detect_property
,
1596 case DRM_MODE_CONNECTOR_DVII
:
1597 case DRM_MODE_CONNECTOR_DVID
:
1598 case DRM_MODE_CONNECTOR_HDMIA
:
1599 case DRM_MODE_CONNECTOR_HDMIB
:
1600 case DRM_MODE_CONNECTOR_DisplayPort
:
1601 drm_connector_attach_property(&radeon_connector
->base
,
1602 rdev
->mode_info
.underscan_property
,
1604 drm_connector_attach_property(&radeon_connector
->base
,
1605 rdev
->mode_info
.underscan_hborder_property
,
1607 drm_connector_attach_property(&radeon_connector
->base
,
1608 rdev
->mode_info
.underscan_vborder_property
,
1610 subpixel_order
= SubPixelHorizontalRGB
;
1611 connector
->interlace_allowed
= true;
1612 if (connector_type
== DRM_MODE_CONNECTOR_HDMIB
)
1613 connector
->doublescan_allowed
= true;
1615 connector
->doublescan_allowed
= false;
1616 if (connector_type
== DRM_MODE_CONNECTOR_DVII
) {
1617 radeon_connector
->dac_load_detect
= true;
1618 drm_connector_attach_property(&radeon_connector
->base
,
1619 rdev
->mode_info
.load_detect_property
,
1623 case DRM_MODE_CONNECTOR_LVDS
:
1624 case DRM_MODE_CONNECTOR_eDP
:
1625 drm_connector_attach_property(&radeon_connector
->base
,
1626 dev
->mode_config
.scaling_mode_property
,
1627 DRM_MODE_SCALE_FULLSCREEN
);
1628 subpixel_order
= SubPixelHorizontalRGB
;
1629 connector
->interlace_allowed
= false;
1630 connector
->doublescan_allowed
= false;
1634 switch (connector_type
) {
1635 case DRM_MODE_CONNECTOR_VGA
:
1636 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_vga_connector_funcs
, connector_type
);
1637 drm_connector_helper_add(&radeon_connector
->base
, &radeon_vga_connector_helper_funcs
);
1638 if (i2c_bus
->valid
) {
1639 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1640 if (!radeon_connector
->ddc_bus
)
1641 DRM_ERROR("VGA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1643 radeon_connector
->dac_load_detect
= true;
1644 drm_connector_attach_property(&radeon_connector
->base
,
1645 rdev
->mode_info
.load_detect_property
,
1647 /* no HPD on analog connectors */
1648 radeon_connector
->hpd
.hpd
= RADEON_HPD_NONE
;
1649 connector
->polled
= DRM_CONNECTOR_POLL_CONNECT
;
1650 connector
->interlace_allowed
= true;
1651 connector
->doublescan_allowed
= true;
1653 case DRM_MODE_CONNECTOR_DVIA
:
1654 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_vga_connector_funcs
, connector_type
);
1655 drm_connector_helper_add(&radeon_connector
->base
, &radeon_vga_connector_helper_funcs
);
1656 if (i2c_bus
->valid
) {
1657 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1658 if (!radeon_connector
->ddc_bus
)
1659 DRM_ERROR("DVIA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1661 radeon_connector
->dac_load_detect
= true;
1662 drm_connector_attach_property(&radeon_connector
->base
,
1663 rdev
->mode_info
.load_detect_property
,
1665 /* no HPD on analog connectors */
1666 radeon_connector
->hpd
.hpd
= RADEON_HPD_NONE
;
1667 connector
->interlace_allowed
= true;
1668 connector
->doublescan_allowed
= true;
1670 case DRM_MODE_CONNECTOR_DVII
:
1671 case DRM_MODE_CONNECTOR_DVID
:
1672 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
1673 if (!radeon_dig_connector
)
1675 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
1676 radeon_connector
->con_priv
= radeon_dig_connector
;
1677 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_dvi_connector_funcs
, connector_type
);
1678 drm_connector_helper_add(&radeon_connector
->base
, &radeon_dvi_connector_helper_funcs
);
1679 if (i2c_bus
->valid
) {
1680 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1681 if (!radeon_connector
->ddc_bus
)
1682 DRM_ERROR("DVI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1684 subpixel_order
= SubPixelHorizontalRGB
;
1685 drm_connector_attach_property(&radeon_connector
->base
,
1686 rdev
->mode_info
.coherent_mode_property
,
1688 if (ASIC_IS_AVIVO(rdev
)) {
1689 drm_connector_attach_property(&radeon_connector
->base
,
1690 rdev
->mode_info
.underscan_property
,
1692 drm_connector_attach_property(&radeon_connector
->base
,
1693 rdev
->mode_info
.underscan_hborder_property
,
1695 drm_connector_attach_property(&radeon_connector
->base
,
1696 rdev
->mode_info
.underscan_vborder_property
,
1699 if (connector_type
== DRM_MODE_CONNECTOR_DVII
) {
1700 radeon_connector
->dac_load_detect
= true;
1701 drm_connector_attach_property(&radeon_connector
->base
,
1702 rdev
->mode_info
.load_detect_property
,
1705 connector
->interlace_allowed
= true;
1706 if (connector_type
== DRM_MODE_CONNECTOR_DVII
)
1707 connector
->doublescan_allowed
= true;
1709 connector
->doublescan_allowed
= false;
1711 case DRM_MODE_CONNECTOR_HDMIA
:
1712 case DRM_MODE_CONNECTOR_HDMIB
:
1713 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
1714 if (!radeon_dig_connector
)
1716 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
1717 radeon_connector
->con_priv
= radeon_dig_connector
;
1718 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_dvi_connector_funcs
, connector_type
);
1719 drm_connector_helper_add(&radeon_connector
->base
, &radeon_dvi_connector_helper_funcs
);
1720 if (i2c_bus
->valid
) {
1721 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1722 if (!radeon_connector
->ddc_bus
)
1723 DRM_ERROR("HDMI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1725 drm_connector_attach_property(&radeon_connector
->base
,
1726 rdev
->mode_info
.coherent_mode_property
,
1728 if (ASIC_IS_AVIVO(rdev
)) {
1729 drm_connector_attach_property(&radeon_connector
->base
,
1730 rdev
->mode_info
.underscan_property
,
1732 drm_connector_attach_property(&radeon_connector
->base
,
1733 rdev
->mode_info
.underscan_hborder_property
,
1735 drm_connector_attach_property(&radeon_connector
->base
,
1736 rdev
->mode_info
.underscan_vborder_property
,
1739 subpixel_order
= SubPixelHorizontalRGB
;
1740 connector
->interlace_allowed
= true;
1741 if (connector_type
== DRM_MODE_CONNECTOR_HDMIB
)
1742 connector
->doublescan_allowed
= true;
1744 connector
->doublescan_allowed
= false;
1746 case DRM_MODE_CONNECTOR_DisplayPort
:
1747 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
1748 if (!radeon_dig_connector
)
1750 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
1751 radeon_connector
->con_priv
= radeon_dig_connector
;
1752 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_dp_connector_funcs
, connector_type
);
1753 drm_connector_helper_add(&radeon_connector
->base
, &radeon_dp_connector_helper_funcs
);
1754 if (i2c_bus
->valid
) {
1755 /* add DP i2c bus */
1756 radeon_dig_connector
->dp_i2c_bus
= radeon_i2c_create_dp(dev
, i2c_bus
, "DP-auxch");
1757 if (!radeon_dig_connector
->dp_i2c_bus
)
1758 DRM_ERROR("DP: Failed to assign dp ddc bus! Check dmesg for i2c errors.\n");
1759 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1760 if (!radeon_connector
->ddc_bus
)
1761 DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1763 subpixel_order
= SubPixelHorizontalRGB
;
1764 drm_connector_attach_property(&radeon_connector
->base
,
1765 rdev
->mode_info
.coherent_mode_property
,
1767 if (ASIC_IS_AVIVO(rdev
)) {
1768 drm_connector_attach_property(&radeon_connector
->base
,
1769 rdev
->mode_info
.underscan_property
,
1771 drm_connector_attach_property(&radeon_connector
->base
,
1772 rdev
->mode_info
.underscan_hborder_property
,
1774 drm_connector_attach_property(&radeon_connector
->base
,
1775 rdev
->mode_info
.underscan_vborder_property
,
1778 connector
->interlace_allowed
= true;
1779 /* in theory with a DP to VGA converter... */
1780 connector
->doublescan_allowed
= false;
1782 case DRM_MODE_CONNECTOR_eDP
:
1783 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
1784 if (!radeon_dig_connector
)
1786 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
1787 radeon_connector
->con_priv
= radeon_dig_connector
;
1788 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_dp_connector_funcs
, connector_type
);
1789 drm_connector_helper_add(&radeon_connector
->base
, &radeon_dp_connector_helper_funcs
);
1790 if (i2c_bus
->valid
) {
1791 /* add DP i2c bus */
1792 radeon_dig_connector
->dp_i2c_bus
= radeon_i2c_create_dp(dev
, i2c_bus
, "eDP-auxch");
1793 if (!radeon_dig_connector
->dp_i2c_bus
)
1794 DRM_ERROR("DP: Failed to assign dp ddc bus! Check dmesg for i2c errors.\n");
1795 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1796 if (!radeon_connector
->ddc_bus
)
1797 DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1799 drm_connector_attach_property(&radeon_connector
->base
,
1800 dev
->mode_config
.scaling_mode_property
,
1801 DRM_MODE_SCALE_FULLSCREEN
);
1802 subpixel_order
= SubPixelHorizontalRGB
;
1803 connector
->interlace_allowed
= false;
1804 connector
->doublescan_allowed
= false;
1806 case DRM_MODE_CONNECTOR_SVIDEO
:
1807 case DRM_MODE_CONNECTOR_Composite
:
1808 case DRM_MODE_CONNECTOR_9PinDIN
:
1809 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_tv_connector_funcs
, connector_type
);
1810 drm_connector_helper_add(&radeon_connector
->base
, &radeon_tv_connector_helper_funcs
);
1811 radeon_connector
->dac_load_detect
= true;
1812 drm_connector_attach_property(&radeon_connector
->base
,
1813 rdev
->mode_info
.load_detect_property
,
1815 drm_connector_attach_property(&radeon_connector
->base
,
1816 rdev
->mode_info
.tv_std_property
,
1817 radeon_atombios_get_tv_info(rdev
));
1818 /* no HPD on analog connectors */
1819 radeon_connector
->hpd
.hpd
= RADEON_HPD_NONE
;
1820 connector
->interlace_allowed
= false;
1821 connector
->doublescan_allowed
= false;
1823 case DRM_MODE_CONNECTOR_LVDS
:
1824 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
1825 if (!radeon_dig_connector
)
1827 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
1828 radeon_connector
->con_priv
= radeon_dig_connector
;
1829 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_lvds_connector_funcs
, connector_type
);
1830 drm_connector_helper_add(&radeon_connector
->base
, &radeon_lvds_connector_helper_funcs
);
1831 if (i2c_bus
->valid
) {
1832 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1833 if (!radeon_connector
->ddc_bus
)
1834 DRM_ERROR("LVDS: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1836 drm_connector_attach_property(&radeon_connector
->base
,
1837 dev
->mode_config
.scaling_mode_property
,
1838 DRM_MODE_SCALE_FULLSCREEN
);
1839 subpixel_order
= SubPixelHorizontalRGB
;
1840 connector
->interlace_allowed
= false;
1841 connector
->doublescan_allowed
= false;
1846 if (radeon_connector
->hpd
.hpd
== RADEON_HPD_NONE
) {
1848 connector
->polled
= DRM_CONNECTOR_POLL_CONNECT
;
1850 connector
->polled
= DRM_CONNECTOR_POLL_HPD
;
1852 connector
->display_info
.subpixel_order
= subpixel_order
;
1853 drm_sysfs_connector_add(connector
);
1857 drm_connector_cleanup(connector
);
1862 radeon_add_legacy_connector(struct drm_device
*dev
,
1863 uint32_t connector_id
,
1864 uint32_t supported_device
,
1866 struct radeon_i2c_bus_rec
*i2c_bus
,
1867 uint16_t connector_object_id
,
1868 struct radeon_hpd
*hpd
)
1870 struct radeon_device
*rdev
= dev
->dev_private
;
1871 struct drm_connector
*connector
;
1872 struct radeon_connector
*radeon_connector
;
1873 uint32_t subpixel_order
= SubPixelNone
;
1875 if (connector_type
== DRM_MODE_CONNECTOR_Unknown
)
1878 /* if the user selected tv=0 don't try and add the connector */
1879 if (((connector_type
== DRM_MODE_CONNECTOR_SVIDEO
) ||
1880 (connector_type
== DRM_MODE_CONNECTOR_Composite
) ||
1881 (connector_type
== DRM_MODE_CONNECTOR_9PinDIN
)) &&
1885 /* see if we already added it */
1886 list_for_each_entry(connector
, &dev
->mode_config
.connector_list
, head
) {
1887 radeon_connector
= to_radeon_connector(connector
);
1888 if (radeon_connector
->connector_id
== connector_id
) {
1889 radeon_connector
->devices
|= supported_device
;
1894 radeon_connector
= kzalloc(sizeof(struct radeon_connector
), GFP_KERNEL
);
1895 if (!radeon_connector
)
1898 connector
= &radeon_connector
->base
;
1900 radeon_connector
->connector_id
= connector_id
;
1901 radeon_connector
->devices
= supported_device
;
1902 radeon_connector
->connector_object_id
= connector_object_id
;
1903 radeon_connector
->hpd
= *hpd
;
1905 switch (connector_type
) {
1906 case DRM_MODE_CONNECTOR_VGA
:
1907 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_vga_connector_funcs
, connector_type
);
1908 drm_connector_helper_add(&radeon_connector
->base
, &radeon_vga_connector_helper_funcs
);
1909 if (i2c_bus
->valid
) {
1910 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1911 if (!radeon_connector
->ddc_bus
)
1912 DRM_ERROR("VGA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1914 radeon_connector
->dac_load_detect
= true;
1915 drm_connector_attach_property(&radeon_connector
->base
,
1916 rdev
->mode_info
.load_detect_property
,
1918 /* no HPD on analog connectors */
1919 radeon_connector
->hpd
.hpd
= RADEON_HPD_NONE
;
1920 connector
->polled
= DRM_CONNECTOR_POLL_CONNECT
;
1921 connector
->interlace_allowed
= true;
1922 connector
->doublescan_allowed
= true;
1924 case DRM_MODE_CONNECTOR_DVIA
:
1925 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_vga_connector_funcs
, connector_type
);
1926 drm_connector_helper_add(&radeon_connector
->base
, &radeon_vga_connector_helper_funcs
);
1927 if (i2c_bus
->valid
) {
1928 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1929 if (!radeon_connector
->ddc_bus
)
1930 DRM_ERROR("DVIA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1932 radeon_connector
->dac_load_detect
= true;
1933 drm_connector_attach_property(&radeon_connector
->base
,
1934 rdev
->mode_info
.load_detect_property
,
1936 /* no HPD on analog connectors */
1937 radeon_connector
->hpd
.hpd
= RADEON_HPD_NONE
;
1938 connector
->interlace_allowed
= true;
1939 connector
->doublescan_allowed
= true;
1941 case DRM_MODE_CONNECTOR_DVII
:
1942 case DRM_MODE_CONNECTOR_DVID
:
1943 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_dvi_connector_funcs
, connector_type
);
1944 drm_connector_helper_add(&radeon_connector
->base
, &radeon_dvi_connector_helper_funcs
);
1945 if (i2c_bus
->valid
) {
1946 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1947 if (!radeon_connector
->ddc_bus
)
1948 DRM_ERROR("DVI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1950 if (connector_type
== DRM_MODE_CONNECTOR_DVII
) {
1951 radeon_connector
->dac_load_detect
= true;
1952 drm_connector_attach_property(&radeon_connector
->base
,
1953 rdev
->mode_info
.load_detect_property
,
1956 subpixel_order
= SubPixelHorizontalRGB
;
1957 connector
->interlace_allowed
= true;
1958 if (connector_type
== DRM_MODE_CONNECTOR_DVII
)
1959 connector
->doublescan_allowed
= true;
1961 connector
->doublescan_allowed
= false;
1963 case DRM_MODE_CONNECTOR_SVIDEO
:
1964 case DRM_MODE_CONNECTOR_Composite
:
1965 case DRM_MODE_CONNECTOR_9PinDIN
:
1966 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_tv_connector_funcs
, connector_type
);
1967 drm_connector_helper_add(&radeon_connector
->base
, &radeon_tv_connector_helper_funcs
);
1968 radeon_connector
->dac_load_detect
= true;
1969 /* RS400,RC410,RS480 chipset seems to report a lot
1970 * of false positive on load detect, we haven't yet
1971 * found a way to make load detect reliable on those
1972 * chipset, thus just disable it for TV.
1974 if (rdev
->family
== CHIP_RS400
|| rdev
->family
== CHIP_RS480
)
1975 radeon_connector
->dac_load_detect
= false;
1976 drm_connector_attach_property(&radeon_connector
->base
,
1977 rdev
->mode_info
.load_detect_property
,
1978 radeon_connector
->dac_load_detect
);
1979 drm_connector_attach_property(&radeon_connector
->base
,
1980 rdev
->mode_info
.tv_std_property
,
1981 radeon_combios_get_tv_info(rdev
));
1982 /* no HPD on analog connectors */
1983 radeon_connector
->hpd
.hpd
= RADEON_HPD_NONE
;
1984 connector
->interlace_allowed
= false;
1985 connector
->doublescan_allowed
= false;
1987 case DRM_MODE_CONNECTOR_LVDS
:
1988 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_lvds_connector_funcs
, connector_type
);
1989 drm_connector_helper_add(&radeon_connector
->base
, &radeon_lvds_connector_helper_funcs
);
1990 if (i2c_bus
->valid
) {
1991 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1992 if (!radeon_connector
->ddc_bus
)
1993 DRM_ERROR("LVDS: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1995 drm_connector_attach_property(&radeon_connector
->base
,
1996 dev
->mode_config
.scaling_mode_property
,
1997 DRM_MODE_SCALE_FULLSCREEN
);
1998 subpixel_order
= SubPixelHorizontalRGB
;
1999 connector
->interlace_allowed
= false;
2000 connector
->doublescan_allowed
= false;
2004 if (radeon_connector
->hpd
.hpd
== RADEON_HPD_NONE
) {
2006 connector
->polled
= DRM_CONNECTOR_POLL_CONNECT
;
2008 connector
->polled
= DRM_CONNECTOR_POLL_HPD
;
2009 connector
->display_info
.subpixel_order
= subpixel_order
;
2010 drm_sysfs_connector_add(connector
);
2011 if (connector_type
== DRM_MODE_CONNECTOR_LVDS
) {
2012 struct drm_encoder
*drm_encoder
;
2014 list_for_each_entry(drm_encoder
, &dev
->mode_config
.encoder_list
, head
) {
2015 struct radeon_encoder
*radeon_encoder
;
2017 radeon_encoder
= to_radeon_encoder(drm_encoder
);
2018 if (radeon_encoder
->encoder_id
== ENCODER_OBJECT_ID_INTERNAL_LVDS
)
2019 radeon_legacy_backlight_init(radeon_encoder
, connector
);