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
28 #include "drm_crtc_helper.h"
29 #include "drm_fb_helper.h"
30 #include "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 radeon_hpd_set_polarity(rdev
, radeon_connector
->hpd
.hpd
);
55 /* pre-r600 did not always have the hpd pins mapped accurately to connectors */
56 if (rdev
->family
>= CHIP_R600
) {
57 if (radeon_hpd_sense(rdev
, radeon_connector
->hpd
.hpd
))
58 drm_helper_connector_dpms(connector
, DRM_MODE_DPMS_ON
);
60 drm_helper_connector_dpms(connector
, DRM_MODE_DPMS_OFF
);
64 static void radeon_property_change_mode(struct drm_encoder
*encoder
)
66 struct drm_crtc
*crtc
= encoder
->crtc
;
68 if (crtc
&& crtc
->enabled
) {
69 drm_crtc_helper_set_mode(crtc
, &crtc
->mode
,
70 crtc
->x
, crtc
->y
, crtc
->fb
);
74 radeon_connector_update_scratch_regs(struct drm_connector
*connector
, enum drm_connector_status status
)
76 struct drm_device
*dev
= connector
->dev
;
77 struct radeon_device
*rdev
= dev
->dev_private
;
78 struct drm_encoder
*best_encoder
= NULL
;
79 struct drm_encoder
*encoder
= NULL
;
80 struct drm_connector_helper_funcs
*connector_funcs
= connector
->helper_private
;
81 struct drm_mode_object
*obj
;
85 best_encoder
= connector_funcs
->best_encoder(connector
);
87 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
88 if (connector
->encoder_ids
[i
] == 0)
91 obj
= drm_mode_object_find(connector
->dev
,
92 connector
->encoder_ids
[i
],
93 DRM_MODE_OBJECT_ENCODER
);
97 encoder
= obj_to_encoder(obj
);
99 if ((encoder
== best_encoder
) && (status
== connector_status_connected
))
104 if (rdev
->is_atom_bios
)
105 radeon_atombios_connected_scratch_regs(connector
, encoder
, connected
);
107 radeon_combios_connected_scratch_regs(connector
, encoder
, connected
);
112 struct drm_encoder
*radeon_find_encoder(struct drm_connector
*connector
, int encoder_type
)
114 struct drm_mode_object
*obj
;
115 struct drm_encoder
*encoder
;
118 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
119 if (connector
->encoder_ids
[i
] == 0)
122 obj
= drm_mode_object_find(connector
->dev
, connector
->encoder_ids
[i
], DRM_MODE_OBJECT_ENCODER
);
126 encoder
= obj_to_encoder(obj
);
127 if (encoder
->encoder_type
== encoder_type
)
133 struct drm_encoder
*radeon_best_single_encoder(struct drm_connector
*connector
)
135 int enc_id
= connector
->encoder_ids
[0];
136 struct drm_mode_object
*obj
;
137 struct drm_encoder
*encoder
;
139 /* pick the encoder ids */
141 obj
= drm_mode_object_find(connector
->dev
, enc_id
, DRM_MODE_OBJECT_ENCODER
);
144 encoder
= obj_to_encoder(obj
);
151 * radeon_connector_analog_encoder_conflict_solve
152 * - search for other connectors sharing this encoder
153 * if priority is true, then set them disconnected if this is connected
154 * if priority is false, set us disconnected if they are connected
156 static enum drm_connector_status
157 radeon_connector_analog_encoder_conflict_solve(struct drm_connector
*connector
,
158 struct drm_encoder
*encoder
,
159 enum drm_connector_status current_status
,
162 struct drm_device
*dev
= connector
->dev
;
163 struct drm_connector
*conflict
;
164 struct radeon_connector
*radeon_conflict
;
167 list_for_each_entry(conflict
, &dev
->mode_config
.connector_list
, head
) {
168 if (conflict
== connector
)
171 radeon_conflict
= to_radeon_connector(conflict
);
172 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
173 if (conflict
->encoder_ids
[i
] == 0)
176 /* if the IDs match */
177 if (conflict
->encoder_ids
[i
] == encoder
->base
.id
) {
178 if (conflict
->status
!= connector_status_connected
)
181 if (radeon_conflict
->use_digital
)
184 if (priority
== true) {
185 DRM_DEBUG_KMS("1: conflicting encoders switching off %s\n", drm_get_connector_name(conflict
));
186 DRM_DEBUG_KMS("in favor of %s\n", drm_get_connector_name(connector
));
187 conflict
->status
= connector_status_disconnected
;
188 radeon_connector_update_scratch_regs(conflict
, connector_status_disconnected
);
190 DRM_DEBUG_KMS("2: conflicting encoders switching off %s\n", drm_get_connector_name(connector
));
191 DRM_DEBUG_KMS("in favor of %s\n", drm_get_connector_name(conflict
));
192 current_status
= connector_status_disconnected
;
198 return current_status
;
202 static struct drm_display_mode
*radeon_fp_native_mode(struct drm_encoder
*encoder
)
204 struct drm_device
*dev
= encoder
->dev
;
205 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
206 struct drm_display_mode
*mode
= NULL
;
207 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
209 if (native_mode
->hdisplay
!= 0 &&
210 native_mode
->vdisplay
!= 0 &&
211 native_mode
->clock
!= 0) {
212 mode
= drm_mode_duplicate(dev
, native_mode
);
213 mode
->type
= DRM_MODE_TYPE_PREFERRED
| DRM_MODE_TYPE_DRIVER
;
214 drm_mode_set_name(mode
);
216 DRM_DEBUG_KMS("Adding native panel mode %s\n", mode
->name
);
217 } else if (native_mode
->hdisplay
!= 0 &&
218 native_mode
->vdisplay
!= 0) {
219 /* mac laptops without an edid */
220 /* Note that this is not necessarily the exact panel mode,
221 * but an approximation based on the cvt formula. For these
222 * systems we should ideally read the mode info out of the
223 * registers or add a mode table, but this works and is much
226 mode
= drm_cvt_mode(dev
, native_mode
->hdisplay
, native_mode
->vdisplay
, 60, true, false, false);
227 mode
->type
= DRM_MODE_TYPE_PREFERRED
| DRM_MODE_TYPE_DRIVER
;
228 DRM_DEBUG_KMS("Adding cvt approximation of native panel mode %s\n", mode
->name
);
233 static void radeon_add_common_modes(struct drm_encoder
*encoder
, struct drm_connector
*connector
)
235 struct drm_device
*dev
= encoder
->dev
;
236 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
237 struct drm_display_mode
*mode
= NULL
;
238 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
243 } common_modes
[17] = {
263 for (i
= 0; i
< 17; i
++) {
264 if (radeon_encoder
->devices
& (ATOM_DEVICE_TV_SUPPORT
)) {
265 if (common_modes
[i
].w
> 1024 ||
266 common_modes
[i
].h
> 768)
269 if (radeon_encoder
->devices
& (ATOM_DEVICE_LCD_SUPPORT
)) {
270 if (common_modes
[i
].w
> native_mode
->hdisplay
||
271 common_modes
[i
].h
> native_mode
->vdisplay
||
272 (common_modes
[i
].w
== native_mode
->hdisplay
&&
273 common_modes
[i
].h
== native_mode
->vdisplay
))
276 if (common_modes
[i
].w
< 320 || common_modes
[i
].h
< 200)
279 mode
= drm_cvt_mode(dev
, common_modes
[i
].w
, common_modes
[i
].h
, 60, false, false, false);
280 drm_mode_probed_add(connector
, mode
);
284 int radeon_connector_set_property(struct drm_connector
*connector
, struct drm_property
*property
,
287 struct drm_device
*dev
= connector
->dev
;
288 struct radeon_device
*rdev
= dev
->dev_private
;
289 struct drm_encoder
*encoder
;
290 struct radeon_encoder
*radeon_encoder
;
292 if (property
== rdev
->mode_info
.coherent_mode_property
) {
293 struct radeon_encoder_atom_dig
*dig
;
294 bool new_coherent_mode
;
296 /* need to find digital encoder on connector */
297 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TMDS
);
301 radeon_encoder
= to_radeon_encoder(encoder
);
303 if (!radeon_encoder
->enc_priv
)
306 dig
= radeon_encoder
->enc_priv
;
307 new_coherent_mode
= val
? true : false;
308 if (dig
->coherent_mode
!= new_coherent_mode
) {
309 dig
->coherent_mode
= new_coherent_mode
;
310 radeon_property_change_mode(&radeon_encoder
->base
);
314 if (property
== rdev
->mode_info
.underscan_property
) {
315 /* need to find digital encoder on connector */
316 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TMDS
);
320 radeon_encoder
= to_radeon_encoder(encoder
);
322 if (radeon_encoder
->underscan_type
!= val
) {
323 radeon_encoder
->underscan_type
= val
;
324 radeon_property_change_mode(&radeon_encoder
->base
);
328 if (property
== rdev
->mode_info
.underscan_hborder_property
) {
329 /* need to find digital encoder on connector */
330 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TMDS
);
334 radeon_encoder
= to_radeon_encoder(encoder
);
336 if (radeon_encoder
->underscan_hborder
!= val
) {
337 radeon_encoder
->underscan_hborder
= val
;
338 radeon_property_change_mode(&radeon_encoder
->base
);
342 if (property
== rdev
->mode_info
.underscan_vborder_property
) {
343 /* need to find digital encoder on connector */
344 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TMDS
);
348 radeon_encoder
= to_radeon_encoder(encoder
);
350 if (radeon_encoder
->underscan_vborder
!= val
) {
351 radeon_encoder
->underscan_vborder
= val
;
352 radeon_property_change_mode(&radeon_encoder
->base
);
356 if (property
== rdev
->mode_info
.tv_std_property
) {
357 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TVDAC
);
359 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_DAC
);
365 radeon_encoder
= to_radeon_encoder(encoder
);
366 if (!radeon_encoder
->enc_priv
)
368 if (ASIC_IS_AVIVO(rdev
) || radeon_r4xx_atom
) {
369 struct radeon_encoder_atom_dac
*dac_int
;
370 dac_int
= radeon_encoder
->enc_priv
;
371 dac_int
->tv_std
= val
;
373 struct radeon_encoder_tv_dac
*dac_int
;
374 dac_int
= radeon_encoder
->enc_priv
;
375 dac_int
->tv_std
= val
;
377 radeon_property_change_mode(&radeon_encoder
->base
);
380 if (property
== rdev
->mode_info
.load_detect_property
) {
381 struct radeon_connector
*radeon_connector
=
382 to_radeon_connector(connector
);
385 radeon_connector
->dac_load_detect
= false;
387 radeon_connector
->dac_load_detect
= true;
390 if (property
== rdev
->mode_info
.tmds_pll_property
) {
391 struct radeon_encoder_int_tmds
*tmds
= NULL
;
393 /* need to find digital encoder on connector */
394 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TMDS
);
398 radeon_encoder
= to_radeon_encoder(encoder
);
400 tmds
= radeon_encoder
->enc_priv
;
405 if (rdev
->is_atom_bios
)
406 ret
= radeon_atombios_get_tmds_info(radeon_encoder
, tmds
);
408 ret
= radeon_legacy_get_tmds_info_from_combios(radeon_encoder
, tmds
);
410 if (val
== 1 || ret
== false) {
411 radeon_legacy_get_tmds_info_from_table(radeon_encoder
, tmds
);
413 radeon_property_change_mode(&radeon_encoder
->base
);
419 static void radeon_fixup_lvds_native_mode(struct drm_encoder
*encoder
,
420 struct drm_connector
*connector
)
422 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
423 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
425 /* Try to get native mode details from EDID if necessary */
426 if (!native_mode
->clock
) {
427 struct drm_display_mode
*t
, *mode
;
429 list_for_each_entry_safe(mode
, t
, &connector
->probed_modes
, head
) {
430 if (mode
->hdisplay
== native_mode
->hdisplay
&&
431 mode
->vdisplay
== native_mode
->vdisplay
) {
432 *native_mode
= *mode
;
433 drm_mode_set_crtcinfo(native_mode
, CRTC_INTERLACE_HALVE_V
);
434 DRM_DEBUG_KMS("Determined LVDS native mode details from EDID\n");
439 if (!native_mode
->clock
) {
440 DRM_DEBUG_KMS("No LVDS native mode details, disabling RMX\n");
441 radeon_encoder
->rmx_type
= RMX_OFF
;
445 static int radeon_lvds_get_modes(struct drm_connector
*connector
)
447 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
448 struct drm_encoder
*encoder
;
450 struct drm_display_mode
*mode
;
452 if (radeon_connector
->ddc_bus
) {
453 ret
= radeon_ddc_get_modes(radeon_connector
);
455 encoder
= radeon_best_single_encoder(connector
);
457 radeon_fixup_lvds_native_mode(encoder
, connector
);
458 /* add scaled modes */
459 radeon_add_common_modes(encoder
, connector
);
465 encoder
= radeon_best_single_encoder(connector
);
469 /* we have no EDID modes */
470 mode
= radeon_fp_native_mode(encoder
);
473 drm_mode_probed_add(connector
, mode
);
474 /* add the width/height from vbios tables if available */
475 connector
->display_info
.width_mm
= mode
->width_mm
;
476 connector
->display_info
.height_mm
= mode
->height_mm
;
477 /* add scaled modes */
478 radeon_add_common_modes(encoder
, connector
);
484 static int radeon_lvds_mode_valid(struct drm_connector
*connector
,
485 struct drm_display_mode
*mode
)
487 struct drm_encoder
*encoder
= radeon_best_single_encoder(connector
);
489 if ((mode
->hdisplay
< 320) || (mode
->vdisplay
< 240))
493 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
494 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
496 /* AVIVO hardware supports downscaling modes larger than the panel
497 * to the panel size, but I'm not sure this is desirable.
499 if ((mode
->hdisplay
> native_mode
->hdisplay
) ||
500 (mode
->vdisplay
> native_mode
->vdisplay
))
503 /* if scaling is disabled, block non-native modes */
504 if (radeon_encoder
->rmx_type
== RMX_OFF
) {
505 if ((mode
->hdisplay
!= native_mode
->hdisplay
) ||
506 (mode
->vdisplay
!= native_mode
->vdisplay
))
514 static enum drm_connector_status
515 radeon_lvds_detect(struct drm_connector
*connector
, bool force
)
517 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
518 struct drm_encoder
*encoder
= radeon_best_single_encoder(connector
);
519 enum drm_connector_status ret
= connector_status_disconnected
;
522 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
523 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
525 /* check if panel is valid */
526 if (native_mode
->hdisplay
>= 320 && native_mode
->vdisplay
>= 240)
527 ret
= connector_status_connected
;
531 /* check for edid as well */
532 if (radeon_connector
->edid
)
533 ret
= connector_status_connected
;
535 if (radeon_connector
->ddc_bus
) {
536 radeon_connector
->edid
= drm_get_edid(&radeon_connector
->base
,
537 &radeon_connector
->ddc_bus
->adapter
);
538 if (radeon_connector
->edid
)
539 ret
= connector_status_connected
;
542 /* check acpi lid status ??? */
544 radeon_connector_update_scratch_regs(connector
, ret
);
548 static void radeon_connector_destroy(struct drm_connector
*connector
)
550 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
552 if (radeon_connector
->edid
)
553 kfree(radeon_connector
->edid
);
554 kfree(radeon_connector
->con_priv
);
555 drm_sysfs_connector_remove(connector
);
556 drm_connector_cleanup(connector
);
560 static int radeon_lvds_set_property(struct drm_connector
*connector
,
561 struct drm_property
*property
,
564 struct drm_device
*dev
= connector
->dev
;
565 struct radeon_encoder
*radeon_encoder
;
566 enum radeon_rmx_type rmx_type
;
569 if (property
!= dev
->mode_config
.scaling_mode_property
)
572 if (connector
->encoder
)
573 radeon_encoder
= to_radeon_encoder(connector
->encoder
);
575 struct drm_connector_helper_funcs
*connector_funcs
= connector
->helper_private
;
576 radeon_encoder
= to_radeon_encoder(connector_funcs
->best_encoder(connector
));
580 case DRM_MODE_SCALE_NONE
: rmx_type
= RMX_OFF
; break;
581 case DRM_MODE_SCALE_CENTER
: rmx_type
= RMX_CENTER
; break;
582 case DRM_MODE_SCALE_ASPECT
: rmx_type
= RMX_ASPECT
; break;
584 case DRM_MODE_SCALE_FULLSCREEN
: rmx_type
= RMX_FULL
; break;
586 if (radeon_encoder
->rmx_type
== rmx_type
)
589 radeon_encoder
->rmx_type
= rmx_type
;
591 radeon_property_change_mode(&radeon_encoder
->base
);
596 struct drm_connector_helper_funcs radeon_lvds_connector_helper_funcs
= {
597 .get_modes
= radeon_lvds_get_modes
,
598 .mode_valid
= radeon_lvds_mode_valid
,
599 .best_encoder
= radeon_best_single_encoder
,
602 struct drm_connector_funcs radeon_lvds_connector_funcs
= {
603 .dpms
= drm_helper_connector_dpms
,
604 .detect
= radeon_lvds_detect
,
605 .fill_modes
= drm_helper_probe_single_connector_modes
,
606 .destroy
= radeon_connector_destroy
,
607 .set_property
= radeon_lvds_set_property
,
610 static int radeon_vga_get_modes(struct drm_connector
*connector
)
612 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
615 ret
= radeon_ddc_get_modes(radeon_connector
);
620 static int radeon_vga_mode_valid(struct drm_connector
*connector
,
621 struct drm_display_mode
*mode
)
623 /* XXX check mode bandwidth */
624 /* XXX verify against max DAC output frequency */
628 static enum drm_connector_status
629 radeon_vga_detect(struct drm_connector
*connector
, bool force
)
631 struct drm_device
*dev
= connector
->dev
;
632 struct radeon_device
*rdev
= dev
->dev_private
;
633 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
634 struct drm_encoder
*encoder
;
635 struct drm_encoder_helper_funcs
*encoder_funcs
;
637 enum drm_connector_status ret
= connector_status_disconnected
;
639 encoder
= radeon_best_single_encoder(connector
);
641 ret
= connector_status_disconnected
;
643 if (radeon_connector
->ddc_bus
)
644 dret
= radeon_ddc_probe(radeon_connector
);
646 if (radeon_connector
->edid
) {
647 kfree(radeon_connector
->edid
);
648 radeon_connector
->edid
= NULL
;
650 radeon_connector
->edid
= drm_get_edid(&radeon_connector
->base
, &radeon_connector
->ddc_bus
->adapter
);
652 if (!radeon_connector
->edid
) {
653 DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
654 drm_get_connector_name(connector
));
655 ret
= connector_status_connected
;
657 radeon_connector
->use_digital
= !!(radeon_connector
->edid
->input
& DRM_EDID_INPUT_DIGITAL
);
659 /* some oems have boards with separate digital and analog connectors
660 * with a shared ddc line (often vga + hdmi)
662 if (radeon_connector
->use_digital
&& radeon_connector
->shared_ddc
) {
663 kfree(radeon_connector
->edid
);
664 radeon_connector
->edid
= NULL
;
665 ret
= connector_status_disconnected
;
667 ret
= connector_status_connected
;
671 /* if we aren't forcing don't do destructive polling */
673 return connector
->status
;
675 if (radeon_connector
->dac_load_detect
&& encoder
) {
676 encoder_funcs
= encoder
->helper_private
;
677 ret
= encoder_funcs
->detect(encoder
, connector
);
681 if (ret
== connector_status_connected
)
682 ret
= radeon_connector_analog_encoder_conflict_solve(connector
, encoder
, ret
, true);
684 /* RN50 and some RV100 asics in servers often have a hardcoded EDID in the
685 * vbios to deal with KVMs. If we have one and are not able to detect a monitor
686 * by other means, assume the CRT is connected and use that EDID.
688 if ((!rdev
->is_atom_bios
) &&
689 (ret
== connector_status_disconnected
) &&
690 rdev
->mode_info
.bios_hardcoded_edid_size
) {
691 ret
= connector_status_connected
;
694 radeon_connector_update_scratch_regs(connector
, ret
);
698 struct drm_connector_helper_funcs radeon_vga_connector_helper_funcs
= {
699 .get_modes
= radeon_vga_get_modes
,
700 .mode_valid
= radeon_vga_mode_valid
,
701 .best_encoder
= radeon_best_single_encoder
,
704 struct drm_connector_funcs radeon_vga_connector_funcs
= {
705 .dpms
= drm_helper_connector_dpms
,
706 .detect
= radeon_vga_detect
,
707 .fill_modes
= drm_helper_probe_single_connector_modes
,
708 .destroy
= radeon_connector_destroy
,
709 .set_property
= radeon_connector_set_property
,
712 static int radeon_tv_get_modes(struct drm_connector
*connector
)
714 struct drm_device
*dev
= connector
->dev
;
715 struct radeon_device
*rdev
= dev
->dev_private
;
716 struct drm_display_mode
*tv_mode
;
717 struct drm_encoder
*encoder
;
719 encoder
= radeon_best_single_encoder(connector
);
723 /* avivo chips can scale any mode */
724 if (rdev
->family
>= CHIP_RS600
)
725 /* add scaled modes */
726 radeon_add_common_modes(encoder
, connector
);
728 /* only 800x600 is supported right now on pre-avivo chips */
729 tv_mode
= drm_cvt_mode(dev
, 800, 600, 60, false, false, false);
730 tv_mode
->type
= DRM_MODE_TYPE_DRIVER
| DRM_MODE_TYPE_PREFERRED
;
731 drm_mode_probed_add(connector
, tv_mode
);
736 static int radeon_tv_mode_valid(struct drm_connector
*connector
,
737 struct drm_display_mode
*mode
)
739 if ((mode
->hdisplay
> 1024) || (mode
->vdisplay
> 768))
740 return MODE_CLOCK_RANGE
;
744 static enum drm_connector_status
745 radeon_tv_detect(struct drm_connector
*connector
, bool force
)
747 struct drm_encoder
*encoder
;
748 struct drm_encoder_helper_funcs
*encoder_funcs
;
749 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
750 enum drm_connector_status ret
= connector_status_disconnected
;
752 if (!radeon_connector
->dac_load_detect
)
755 encoder
= radeon_best_single_encoder(connector
);
757 ret
= connector_status_disconnected
;
759 encoder_funcs
= encoder
->helper_private
;
760 ret
= encoder_funcs
->detect(encoder
, connector
);
762 if (ret
== connector_status_connected
)
763 ret
= radeon_connector_analog_encoder_conflict_solve(connector
, encoder
, ret
, false);
764 radeon_connector_update_scratch_regs(connector
, ret
);
768 struct drm_connector_helper_funcs radeon_tv_connector_helper_funcs
= {
769 .get_modes
= radeon_tv_get_modes
,
770 .mode_valid
= radeon_tv_mode_valid
,
771 .best_encoder
= radeon_best_single_encoder
,
774 struct drm_connector_funcs radeon_tv_connector_funcs
= {
775 .dpms
= drm_helper_connector_dpms
,
776 .detect
= radeon_tv_detect
,
777 .fill_modes
= drm_helper_probe_single_connector_modes
,
778 .destroy
= radeon_connector_destroy
,
779 .set_property
= radeon_connector_set_property
,
782 static int radeon_dvi_get_modes(struct drm_connector
*connector
)
784 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
787 ret
= radeon_ddc_get_modes(radeon_connector
);
793 * Do a DDC probe, if DDC probe passes, get the full EDID so
794 * we can do analog/digital monitor detection at this point.
795 * If the monitor is an analog monitor or we got no DDC,
796 * we need to find the DAC encoder object for this connector.
797 * If we got no DDC, we do load detection on the DAC encoder object.
798 * If we got analog DDC or load detection passes on the DAC encoder
799 * we have to check if this analog encoder is shared with anyone else (TV)
800 * if its shared we have to set the other connector to disconnected.
802 static enum drm_connector_status
803 radeon_dvi_detect(struct drm_connector
*connector
, bool force
)
805 struct drm_device
*dev
= connector
->dev
;
806 struct radeon_device
*rdev
= dev
->dev_private
;
807 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
808 struct drm_encoder
*encoder
= NULL
;
809 struct drm_encoder_helper_funcs
*encoder_funcs
;
810 struct drm_mode_object
*obj
;
812 enum drm_connector_status ret
= connector_status_disconnected
;
815 if (radeon_connector
->ddc_bus
)
816 dret
= radeon_ddc_probe(radeon_connector
);
818 if (radeon_connector
->edid
) {
819 kfree(radeon_connector
->edid
);
820 radeon_connector
->edid
= NULL
;
822 radeon_connector
->edid
= drm_get_edid(&radeon_connector
->base
, &radeon_connector
->ddc_bus
->adapter
);
824 if (!radeon_connector
->edid
) {
825 DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
826 drm_get_connector_name(connector
));
828 radeon_connector
->use_digital
= !!(radeon_connector
->edid
->input
& DRM_EDID_INPUT_DIGITAL
);
830 /* some oems have boards with separate digital and analog connectors
831 * with a shared ddc line (often vga + hdmi)
833 if ((!radeon_connector
->use_digital
) && radeon_connector
->shared_ddc
) {
834 kfree(radeon_connector
->edid
);
835 radeon_connector
->edid
= NULL
;
836 ret
= connector_status_disconnected
;
838 ret
= connector_status_connected
;
840 /* This gets complicated. We have boards with VGA + HDMI with a
841 * shared DDC line and we have boards with DVI-D + HDMI with a shared
842 * DDC line. The latter is more complex because with DVI<->HDMI adapters
843 * you don't really know what's connected to which port as both are digital.
845 if (radeon_connector
->shared_ddc
&& (ret
== connector_status_connected
)) {
846 struct drm_connector
*list_connector
;
847 struct radeon_connector
*list_radeon_connector
;
848 list_for_each_entry(list_connector
, &dev
->mode_config
.connector_list
, head
) {
849 if (connector
== list_connector
)
851 list_radeon_connector
= to_radeon_connector(list_connector
);
852 if (list_radeon_connector
->shared_ddc
&&
853 (list_radeon_connector
->ddc_bus
->rec
.i2c_id
==
854 radeon_connector
->ddc_bus
->rec
.i2c_id
)) {
855 /* cases where both connectors are digital */
856 if (list_connector
->connector_type
!= DRM_MODE_CONNECTOR_VGA
) {
857 /* hpd is our only option in this case */
858 if (!radeon_hpd_sense(rdev
, radeon_connector
->hpd
.hpd
)) {
859 kfree(radeon_connector
->edid
);
860 radeon_connector
->edid
= NULL
;
861 ret
= connector_status_disconnected
;
870 if ((ret
== connector_status_connected
) && (radeon_connector
->use_digital
== true))
874 ret
= connector
->status
;
878 /* find analog encoder */
879 if (radeon_connector
->dac_load_detect
) {
880 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
881 if (connector
->encoder_ids
[i
] == 0)
884 obj
= drm_mode_object_find(connector
->dev
,
885 connector
->encoder_ids
[i
],
886 DRM_MODE_OBJECT_ENCODER
);
890 encoder
= obj_to_encoder(obj
);
892 encoder_funcs
= encoder
->helper_private
;
893 if (encoder_funcs
->detect
) {
894 if (ret
!= connector_status_connected
) {
895 ret
= encoder_funcs
->detect(encoder
, connector
);
896 if (ret
== connector_status_connected
) {
897 radeon_connector
->use_digital
= false;
905 if ((ret
== connector_status_connected
) && (radeon_connector
->use_digital
== false) &&
907 ret
= radeon_connector_analog_encoder_conflict_solve(connector
, encoder
, ret
, true);
910 /* RN50 and some RV100 asics in servers often have a hardcoded EDID in the
911 * vbios to deal with KVMs. If we have one and are not able to detect a monitor
912 * by other means, assume the DFP is connected and use that EDID. In most
913 * cases the DVI port is actually a virtual KVM port connected to the service
916 if ((!rdev
->is_atom_bios
) &&
917 (ret
== connector_status_disconnected
) &&
918 rdev
->mode_info
.bios_hardcoded_edid_size
) {
919 radeon_connector
->use_digital
= true;
920 ret
= connector_status_connected
;
924 /* updated in get modes as well since we need to know if it's analog or digital */
925 radeon_connector_update_scratch_regs(connector
, ret
);
929 /* okay need to be smart in here about which encoder to pick */
930 struct drm_encoder
*radeon_dvi_encoder(struct drm_connector
*connector
)
932 int enc_id
= connector
->encoder_ids
[0];
933 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
934 struct drm_mode_object
*obj
;
935 struct drm_encoder
*encoder
;
937 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
938 if (connector
->encoder_ids
[i
] == 0)
941 obj
= drm_mode_object_find(connector
->dev
, connector
->encoder_ids
[i
], DRM_MODE_OBJECT_ENCODER
);
945 encoder
= obj_to_encoder(obj
);
947 if (radeon_connector
->use_digital
== true) {
948 if (encoder
->encoder_type
== DRM_MODE_ENCODER_TMDS
)
951 if (encoder
->encoder_type
== DRM_MODE_ENCODER_DAC
||
952 encoder
->encoder_type
== DRM_MODE_ENCODER_TVDAC
)
957 /* see if we have a default encoder TODO */
959 /* then check use digitial */
960 /* pick the first one */
962 obj
= drm_mode_object_find(connector
->dev
, enc_id
, DRM_MODE_OBJECT_ENCODER
);
965 encoder
= obj_to_encoder(obj
);
971 static void radeon_dvi_force(struct drm_connector
*connector
)
973 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
974 if (connector
->force
== DRM_FORCE_ON
)
975 radeon_connector
->use_digital
= false;
976 if (connector
->force
== DRM_FORCE_ON_DIGITAL
)
977 radeon_connector
->use_digital
= true;
980 static int radeon_dvi_mode_valid(struct drm_connector
*connector
,
981 struct drm_display_mode
*mode
)
983 struct drm_device
*dev
= connector
->dev
;
984 struct radeon_device
*rdev
= dev
->dev_private
;
985 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
987 /* XXX check mode bandwidth */
989 /* clocks over 135 MHz have heat issues with DVI on RV100 */
990 if (radeon_connector
->use_digital
&&
991 (rdev
->family
== CHIP_RV100
) &&
992 (mode
->clock
> 135000))
993 return MODE_CLOCK_HIGH
;
995 if (radeon_connector
->use_digital
&& (mode
->clock
> 165000)) {
996 if ((radeon_connector
->connector_object_id
== CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_I
) ||
997 (radeon_connector
->connector_object_id
== CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_D
) ||
998 (radeon_connector
->connector_object_id
== CONNECTOR_OBJECT_ID_HDMI_TYPE_B
))
1000 else if (radeon_connector
->connector_object_id
== CONNECTOR_OBJECT_ID_HDMI_TYPE_A
) {
1001 if (ASIC_IS_DCE3(rdev
)) {
1002 /* HDMI 1.3+ supports max clock of 340 Mhz */
1003 if (mode
->clock
> 340000)
1004 return MODE_CLOCK_HIGH
;
1008 return MODE_CLOCK_HIGH
;
1010 return MODE_CLOCK_HIGH
;
1015 struct drm_connector_helper_funcs radeon_dvi_connector_helper_funcs
= {
1016 .get_modes
= radeon_dvi_get_modes
,
1017 .mode_valid
= radeon_dvi_mode_valid
,
1018 .best_encoder
= radeon_dvi_encoder
,
1021 struct drm_connector_funcs radeon_dvi_connector_funcs
= {
1022 .dpms
= drm_helper_connector_dpms
,
1023 .detect
= radeon_dvi_detect
,
1024 .fill_modes
= drm_helper_probe_single_connector_modes
,
1025 .set_property
= radeon_connector_set_property
,
1026 .destroy
= radeon_connector_destroy
,
1027 .force
= radeon_dvi_force
,
1030 static void radeon_dp_connector_destroy(struct drm_connector
*connector
)
1032 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1033 struct radeon_connector_atom_dig
*radeon_dig_connector
= radeon_connector
->con_priv
;
1035 if (radeon_connector
->edid
)
1036 kfree(radeon_connector
->edid
);
1037 if (radeon_dig_connector
->dp_i2c_bus
)
1038 radeon_i2c_destroy(radeon_dig_connector
->dp_i2c_bus
);
1039 kfree(radeon_connector
->con_priv
);
1040 drm_sysfs_connector_remove(connector
);
1041 drm_connector_cleanup(connector
);
1045 static int radeon_dp_get_modes(struct drm_connector
*connector
)
1047 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1048 struct radeon_connector_atom_dig
*radeon_dig_connector
= radeon_connector
->con_priv
;
1051 if (connector
->connector_type
== DRM_MODE_CONNECTOR_eDP
) {
1052 if (!radeon_dig_connector
->edp_on
)
1053 atombios_set_edp_panel_power(connector
,
1054 ATOM_TRANSMITTER_ACTION_POWER_ON
);
1056 ret
= radeon_ddc_get_modes(radeon_connector
);
1057 if (connector
->connector_type
== DRM_MODE_CONNECTOR_eDP
) {
1058 if (!radeon_dig_connector
->edp_on
)
1059 atombios_set_edp_panel_power(connector
,
1060 ATOM_TRANSMITTER_ACTION_POWER_OFF
);
1066 bool radeon_connector_encoder_is_dp_bridge(struct drm_connector
*connector
)
1068 struct drm_mode_object
*obj
;
1069 struct drm_encoder
*encoder
;
1070 struct radeon_encoder
*radeon_encoder
;
1074 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
1075 if (connector
->encoder_ids
[i
] == 0)
1078 obj
= drm_mode_object_find(connector
->dev
, connector
->encoder_ids
[i
], DRM_MODE_OBJECT_ENCODER
);
1082 encoder
= obj_to_encoder(obj
);
1083 radeon_encoder
= to_radeon_encoder(encoder
);
1085 switch (radeon_encoder
->encoder_id
) {
1086 case ENCODER_OBJECT_ID_TRAVIS
:
1087 case ENCODER_OBJECT_ID_NUTMEG
:
1098 bool radeon_connector_encoder_is_hbr2(struct drm_connector
*connector
)
1100 struct drm_mode_object
*obj
;
1101 struct drm_encoder
*encoder
;
1102 struct radeon_encoder
*radeon_encoder
;
1106 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
1107 if (connector
->encoder_ids
[i
] == 0)
1110 obj
= drm_mode_object_find(connector
->dev
, connector
->encoder_ids
[i
], DRM_MODE_OBJECT_ENCODER
);
1114 encoder
= obj_to_encoder(obj
);
1115 radeon_encoder
= to_radeon_encoder(encoder
);
1116 if (radeon_encoder
->caps
& ATOM_ENCODER_CAP_RECORD_HBR2
)
1123 bool radeon_connector_is_dp12_capable(struct drm_connector
*connector
)
1125 struct drm_device
*dev
= connector
->dev
;
1126 struct radeon_device
*rdev
= dev
->dev_private
;
1128 if (ASIC_IS_DCE5(rdev
) &&
1129 (rdev
->clock
.dp_extclk
>= 53900) &&
1130 radeon_connector_encoder_is_hbr2(connector
)) {
1137 static enum drm_connector_status
1138 radeon_dp_detect(struct drm_connector
*connector
, bool force
)
1140 struct drm_device
*dev
= connector
->dev
;
1141 struct radeon_device
*rdev
= dev
->dev_private
;
1142 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1143 enum drm_connector_status ret
= connector_status_disconnected
;
1144 struct radeon_connector_atom_dig
*radeon_dig_connector
= radeon_connector
->con_priv
;
1146 if (radeon_connector
->edid
) {
1147 kfree(radeon_connector
->edid
);
1148 radeon_connector
->edid
= NULL
;
1151 if (connector
->connector_type
== DRM_MODE_CONNECTOR_eDP
) {
1152 /* eDP is always DP */
1153 radeon_dig_connector
->dp_sink_type
= CONNECTOR_OBJECT_ID_DISPLAYPORT
;
1154 if (!radeon_dig_connector
->edp_on
)
1155 atombios_set_edp_panel_power(connector
,
1156 ATOM_TRANSMITTER_ACTION_POWER_ON
);
1157 if (radeon_dp_getdpcd(radeon_connector
))
1158 ret
= connector_status_connected
;
1159 if (!radeon_dig_connector
->edp_on
)
1160 atombios_set_edp_panel_power(connector
,
1161 ATOM_TRANSMITTER_ACTION_POWER_OFF
);
1163 radeon_dig_connector
->dp_sink_type
= radeon_dp_getsinktype(radeon_connector
);
1164 if (radeon_hpd_sense(rdev
, radeon_connector
->hpd
.hpd
)) {
1165 ret
= connector_status_connected
;
1166 if (radeon_dig_connector
->dp_sink_type
== CONNECTOR_OBJECT_ID_DISPLAYPORT
)
1167 radeon_dp_getdpcd(radeon_connector
);
1169 if (radeon_dig_connector
->dp_sink_type
== CONNECTOR_OBJECT_ID_DISPLAYPORT
) {
1170 if (radeon_dp_getdpcd(radeon_connector
))
1171 ret
= connector_status_connected
;
1173 if (radeon_ddc_probe(radeon_connector
))
1174 ret
= connector_status_connected
;
1179 radeon_connector_update_scratch_regs(connector
, ret
);
1183 static int radeon_dp_mode_valid(struct drm_connector
*connector
,
1184 struct drm_display_mode
*mode
)
1186 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1187 struct radeon_connector_atom_dig
*radeon_dig_connector
= radeon_connector
->con_priv
;
1189 /* XXX check mode bandwidth */
1191 if ((radeon_dig_connector
->dp_sink_type
== CONNECTOR_OBJECT_ID_DISPLAYPORT
) ||
1192 (radeon_dig_connector
->dp_sink_type
== CONNECTOR_OBJECT_ID_eDP
))
1193 return radeon_dp_mode_valid_helper(connector
, mode
);
1198 struct drm_connector_helper_funcs radeon_dp_connector_helper_funcs
= {
1199 .get_modes
= radeon_dp_get_modes
,
1200 .mode_valid
= radeon_dp_mode_valid
,
1201 .best_encoder
= radeon_dvi_encoder
,
1204 struct drm_connector_funcs radeon_dp_connector_funcs
= {
1205 .dpms
= drm_helper_connector_dpms
,
1206 .detect
= radeon_dp_detect
,
1207 .fill_modes
= drm_helper_probe_single_connector_modes
,
1208 .set_property
= radeon_connector_set_property
,
1209 .destroy
= radeon_dp_connector_destroy
,
1210 .force
= radeon_dvi_force
,
1214 radeon_add_atom_connector(struct drm_device
*dev
,
1215 uint32_t connector_id
,
1216 uint32_t supported_device
,
1218 struct radeon_i2c_bus_rec
*i2c_bus
,
1219 uint32_t igp_lane_info
,
1220 uint16_t connector_object_id
,
1221 struct radeon_hpd
*hpd
,
1222 struct radeon_router
*router
)
1224 struct radeon_device
*rdev
= dev
->dev_private
;
1225 struct drm_connector
*connector
;
1226 struct radeon_connector
*radeon_connector
;
1227 struct radeon_connector_atom_dig
*radeon_dig_connector
;
1228 struct drm_encoder
*encoder
;
1229 struct radeon_encoder
*radeon_encoder
;
1230 uint32_t subpixel_order
= SubPixelNone
;
1231 bool shared_ddc
= false;
1232 bool is_dp_bridge
= false;
1234 if (connector_type
== DRM_MODE_CONNECTOR_Unknown
)
1237 /* if the user selected tv=0 don't try and add the connector */
1238 if (((connector_type
== DRM_MODE_CONNECTOR_SVIDEO
) ||
1239 (connector_type
== DRM_MODE_CONNECTOR_Composite
) ||
1240 (connector_type
== DRM_MODE_CONNECTOR_9PinDIN
)) &&
1244 /* see if we already added it */
1245 list_for_each_entry(connector
, &dev
->mode_config
.connector_list
, head
) {
1246 radeon_connector
= to_radeon_connector(connector
);
1247 if (radeon_connector
->connector_id
== connector_id
) {
1248 radeon_connector
->devices
|= supported_device
;
1251 if (radeon_connector
->ddc_bus
&& i2c_bus
->valid
) {
1252 if (radeon_connector
->ddc_bus
->rec
.i2c_id
== i2c_bus
->i2c_id
) {
1253 radeon_connector
->shared_ddc
= true;
1256 if (radeon_connector
->router_bus
&& router
->ddc_valid
&&
1257 (radeon_connector
->router
.router_id
== router
->router_id
)) {
1258 radeon_connector
->shared_ddc
= false;
1264 /* check if it's a dp bridge */
1265 list_for_each_entry(encoder
, &dev
->mode_config
.encoder_list
, head
) {
1266 radeon_encoder
= to_radeon_encoder(encoder
);
1267 if (radeon_encoder
->devices
& supported_device
) {
1268 switch (radeon_encoder
->encoder_id
) {
1269 case ENCODER_OBJECT_ID_TRAVIS
:
1270 case ENCODER_OBJECT_ID_NUTMEG
:
1271 is_dp_bridge
= true;
1279 radeon_connector
= kzalloc(sizeof(struct radeon_connector
), GFP_KERNEL
);
1280 if (!radeon_connector
)
1283 connector
= &radeon_connector
->base
;
1285 radeon_connector
->connector_id
= connector_id
;
1286 radeon_connector
->devices
= supported_device
;
1287 radeon_connector
->shared_ddc
= shared_ddc
;
1288 radeon_connector
->connector_object_id
= connector_object_id
;
1289 radeon_connector
->hpd
= *hpd
;
1290 radeon_connector
->router
= *router
;
1291 if (router
->ddc_valid
|| router
->cd_valid
) {
1292 radeon_connector
->router_bus
= radeon_i2c_lookup(rdev
, &router
->i2c_info
);
1293 if (!radeon_connector
->router_bus
)
1294 DRM_ERROR("Failed to assign router i2c bus! Check dmesg for i2c errors.\n");
1298 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
1299 if (!radeon_dig_connector
)
1301 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
1302 radeon_connector
->con_priv
= radeon_dig_connector
;
1303 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_dp_connector_funcs
, connector_type
);
1304 drm_connector_helper_add(&radeon_connector
->base
, &radeon_dp_connector_helper_funcs
);
1305 if (i2c_bus
->valid
) {
1306 /* add DP i2c bus */
1307 if (connector_type
== DRM_MODE_CONNECTOR_eDP
)
1308 radeon_dig_connector
->dp_i2c_bus
= radeon_i2c_create_dp(dev
, i2c_bus
, "eDP-auxch");
1310 radeon_dig_connector
->dp_i2c_bus
= radeon_i2c_create_dp(dev
, i2c_bus
, "DP-auxch");
1311 if (!radeon_dig_connector
->dp_i2c_bus
)
1312 DRM_ERROR("DP: Failed to assign dp ddc bus! Check dmesg for i2c errors.\n");
1313 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1314 if (!radeon_connector
->ddc_bus
)
1315 DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1317 switch (connector_type
) {
1318 case DRM_MODE_CONNECTOR_VGA
:
1319 case DRM_MODE_CONNECTOR_DVIA
:
1321 connector
->interlace_allowed
= true;
1322 connector
->doublescan_allowed
= true;
1324 case DRM_MODE_CONNECTOR_DVII
:
1325 case DRM_MODE_CONNECTOR_DVID
:
1326 case DRM_MODE_CONNECTOR_HDMIA
:
1327 case DRM_MODE_CONNECTOR_HDMIB
:
1328 case DRM_MODE_CONNECTOR_DisplayPort
:
1329 drm_connector_attach_property(&radeon_connector
->base
,
1330 rdev
->mode_info
.underscan_property
,
1332 drm_connector_attach_property(&radeon_connector
->base
,
1333 rdev
->mode_info
.underscan_hborder_property
,
1335 drm_connector_attach_property(&radeon_connector
->base
,
1336 rdev
->mode_info
.underscan_vborder_property
,
1338 subpixel_order
= SubPixelHorizontalRGB
;
1339 connector
->interlace_allowed
= true;
1340 if (connector_type
== DRM_MODE_CONNECTOR_HDMIB
)
1341 connector
->doublescan_allowed
= true;
1343 connector
->doublescan_allowed
= false;
1345 case DRM_MODE_CONNECTOR_LVDS
:
1346 case DRM_MODE_CONNECTOR_eDP
:
1347 drm_connector_attach_property(&radeon_connector
->base
,
1348 dev
->mode_config
.scaling_mode_property
,
1349 DRM_MODE_SCALE_FULLSCREEN
);
1350 subpixel_order
= SubPixelHorizontalRGB
;
1351 connector
->interlace_allowed
= false;
1352 connector
->doublescan_allowed
= false;
1356 switch (connector_type
) {
1357 case DRM_MODE_CONNECTOR_VGA
:
1358 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_vga_connector_funcs
, connector_type
);
1359 drm_connector_helper_add(&radeon_connector
->base
, &radeon_vga_connector_helper_funcs
);
1360 if (i2c_bus
->valid
) {
1361 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1362 if (!radeon_connector
->ddc_bus
)
1363 DRM_ERROR("VGA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1365 radeon_connector
->dac_load_detect
= true;
1366 drm_connector_attach_property(&radeon_connector
->base
,
1367 rdev
->mode_info
.load_detect_property
,
1369 /* no HPD on analog connectors */
1370 radeon_connector
->hpd
.hpd
= RADEON_HPD_NONE
;
1371 connector
->polled
= DRM_CONNECTOR_POLL_CONNECT
;
1372 connector
->interlace_allowed
= true;
1373 connector
->doublescan_allowed
= true;
1375 case DRM_MODE_CONNECTOR_DVIA
:
1376 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_vga_connector_funcs
, connector_type
);
1377 drm_connector_helper_add(&radeon_connector
->base
, &radeon_vga_connector_helper_funcs
);
1378 if (i2c_bus
->valid
) {
1379 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1380 if (!radeon_connector
->ddc_bus
)
1381 DRM_ERROR("DVIA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1383 radeon_connector
->dac_load_detect
= true;
1384 drm_connector_attach_property(&radeon_connector
->base
,
1385 rdev
->mode_info
.load_detect_property
,
1387 /* no HPD on analog connectors */
1388 radeon_connector
->hpd
.hpd
= RADEON_HPD_NONE
;
1389 connector
->interlace_allowed
= true;
1390 connector
->doublescan_allowed
= true;
1392 case DRM_MODE_CONNECTOR_DVII
:
1393 case DRM_MODE_CONNECTOR_DVID
:
1394 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
1395 if (!radeon_dig_connector
)
1397 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
1398 radeon_connector
->con_priv
= radeon_dig_connector
;
1399 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_dvi_connector_funcs
, connector_type
);
1400 drm_connector_helper_add(&radeon_connector
->base
, &radeon_dvi_connector_helper_funcs
);
1401 if (i2c_bus
->valid
) {
1402 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1403 if (!radeon_connector
->ddc_bus
)
1404 DRM_ERROR("DVI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1406 subpixel_order
= SubPixelHorizontalRGB
;
1407 drm_connector_attach_property(&radeon_connector
->base
,
1408 rdev
->mode_info
.coherent_mode_property
,
1410 if (ASIC_IS_AVIVO(rdev
)) {
1411 drm_connector_attach_property(&radeon_connector
->base
,
1412 rdev
->mode_info
.underscan_property
,
1414 drm_connector_attach_property(&radeon_connector
->base
,
1415 rdev
->mode_info
.underscan_hborder_property
,
1417 drm_connector_attach_property(&radeon_connector
->base
,
1418 rdev
->mode_info
.underscan_vborder_property
,
1421 if (connector_type
== DRM_MODE_CONNECTOR_DVII
) {
1422 radeon_connector
->dac_load_detect
= true;
1423 drm_connector_attach_property(&radeon_connector
->base
,
1424 rdev
->mode_info
.load_detect_property
,
1427 connector
->interlace_allowed
= true;
1428 if (connector_type
== DRM_MODE_CONNECTOR_DVII
)
1429 connector
->doublescan_allowed
= true;
1431 connector
->doublescan_allowed
= false;
1433 case DRM_MODE_CONNECTOR_HDMIA
:
1434 case DRM_MODE_CONNECTOR_HDMIB
:
1435 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
1436 if (!radeon_dig_connector
)
1438 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
1439 radeon_connector
->con_priv
= radeon_dig_connector
;
1440 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_dvi_connector_funcs
, connector_type
);
1441 drm_connector_helper_add(&radeon_connector
->base
, &radeon_dvi_connector_helper_funcs
);
1442 if (i2c_bus
->valid
) {
1443 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1444 if (!radeon_connector
->ddc_bus
)
1445 DRM_ERROR("HDMI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1447 drm_connector_attach_property(&radeon_connector
->base
,
1448 rdev
->mode_info
.coherent_mode_property
,
1450 if (ASIC_IS_AVIVO(rdev
)) {
1451 drm_connector_attach_property(&radeon_connector
->base
,
1452 rdev
->mode_info
.underscan_property
,
1454 drm_connector_attach_property(&radeon_connector
->base
,
1455 rdev
->mode_info
.underscan_hborder_property
,
1457 drm_connector_attach_property(&radeon_connector
->base
,
1458 rdev
->mode_info
.underscan_vborder_property
,
1461 subpixel_order
= SubPixelHorizontalRGB
;
1462 connector
->interlace_allowed
= true;
1463 if (connector_type
== DRM_MODE_CONNECTOR_HDMIB
)
1464 connector
->doublescan_allowed
= true;
1466 connector
->doublescan_allowed
= false;
1468 case DRM_MODE_CONNECTOR_DisplayPort
:
1469 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
1470 if (!radeon_dig_connector
)
1472 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
1473 radeon_connector
->con_priv
= radeon_dig_connector
;
1474 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_dp_connector_funcs
, connector_type
);
1475 drm_connector_helper_add(&radeon_connector
->base
, &radeon_dp_connector_helper_funcs
);
1476 if (i2c_bus
->valid
) {
1477 /* add DP i2c bus */
1478 radeon_dig_connector
->dp_i2c_bus
= radeon_i2c_create_dp(dev
, i2c_bus
, "DP-auxch");
1479 if (!radeon_dig_connector
->dp_i2c_bus
)
1480 DRM_ERROR("DP: Failed to assign dp ddc bus! Check dmesg for i2c errors.\n");
1481 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1482 if (!radeon_connector
->ddc_bus
)
1483 DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1485 subpixel_order
= SubPixelHorizontalRGB
;
1486 drm_connector_attach_property(&radeon_connector
->base
,
1487 rdev
->mode_info
.coherent_mode_property
,
1489 if (ASIC_IS_AVIVO(rdev
)) {
1490 drm_connector_attach_property(&radeon_connector
->base
,
1491 rdev
->mode_info
.underscan_property
,
1493 drm_connector_attach_property(&radeon_connector
->base
,
1494 rdev
->mode_info
.underscan_hborder_property
,
1496 drm_connector_attach_property(&radeon_connector
->base
,
1497 rdev
->mode_info
.underscan_vborder_property
,
1500 connector
->interlace_allowed
= true;
1501 /* in theory with a DP to VGA converter... */
1502 connector
->doublescan_allowed
= false;
1504 case DRM_MODE_CONNECTOR_eDP
:
1505 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
1506 if (!radeon_dig_connector
)
1508 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
1509 radeon_connector
->con_priv
= radeon_dig_connector
;
1510 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_dp_connector_funcs
, connector_type
);
1511 drm_connector_helper_add(&radeon_connector
->base
, &radeon_dp_connector_helper_funcs
);
1512 if (i2c_bus
->valid
) {
1513 /* add DP i2c bus */
1514 radeon_dig_connector
->dp_i2c_bus
= radeon_i2c_create_dp(dev
, i2c_bus
, "eDP-auxch");
1515 if (!radeon_dig_connector
->dp_i2c_bus
)
1516 DRM_ERROR("DP: Failed to assign dp ddc bus! Check dmesg for i2c errors.\n");
1517 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1518 if (!radeon_connector
->ddc_bus
)
1519 DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1521 drm_connector_attach_property(&radeon_connector
->base
,
1522 dev
->mode_config
.scaling_mode_property
,
1523 DRM_MODE_SCALE_FULLSCREEN
);
1524 subpixel_order
= SubPixelHorizontalRGB
;
1525 connector
->interlace_allowed
= false;
1526 connector
->doublescan_allowed
= false;
1528 case DRM_MODE_CONNECTOR_SVIDEO
:
1529 case DRM_MODE_CONNECTOR_Composite
:
1530 case DRM_MODE_CONNECTOR_9PinDIN
:
1531 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_tv_connector_funcs
, connector_type
);
1532 drm_connector_helper_add(&radeon_connector
->base
, &radeon_tv_connector_helper_funcs
);
1533 radeon_connector
->dac_load_detect
= true;
1534 drm_connector_attach_property(&radeon_connector
->base
,
1535 rdev
->mode_info
.load_detect_property
,
1537 drm_connector_attach_property(&radeon_connector
->base
,
1538 rdev
->mode_info
.tv_std_property
,
1539 radeon_atombios_get_tv_info(rdev
));
1540 /* no HPD on analog connectors */
1541 radeon_connector
->hpd
.hpd
= RADEON_HPD_NONE
;
1542 connector
->interlace_allowed
= false;
1543 connector
->doublescan_allowed
= false;
1545 case DRM_MODE_CONNECTOR_LVDS
:
1546 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
1547 if (!radeon_dig_connector
)
1549 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
1550 radeon_connector
->con_priv
= radeon_dig_connector
;
1551 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_lvds_connector_funcs
, connector_type
);
1552 drm_connector_helper_add(&radeon_connector
->base
, &radeon_lvds_connector_helper_funcs
);
1553 if (i2c_bus
->valid
) {
1554 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1555 if (!radeon_connector
->ddc_bus
)
1556 DRM_ERROR("LVDS: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1558 drm_connector_attach_property(&radeon_connector
->base
,
1559 dev
->mode_config
.scaling_mode_property
,
1560 DRM_MODE_SCALE_FULLSCREEN
);
1561 subpixel_order
= SubPixelHorizontalRGB
;
1562 connector
->interlace_allowed
= false;
1563 connector
->doublescan_allowed
= false;
1568 if (radeon_connector
->hpd
.hpd
== RADEON_HPD_NONE
) {
1570 connector
->polled
= DRM_CONNECTOR_POLL_CONNECT
;
1572 connector
->polled
= DRM_CONNECTOR_POLL_HPD
;
1574 connector
->display_info
.subpixel_order
= subpixel_order
;
1575 drm_sysfs_connector_add(connector
);
1579 drm_connector_cleanup(connector
);
1584 radeon_add_legacy_connector(struct drm_device
*dev
,
1585 uint32_t connector_id
,
1586 uint32_t supported_device
,
1588 struct radeon_i2c_bus_rec
*i2c_bus
,
1589 uint16_t connector_object_id
,
1590 struct radeon_hpd
*hpd
)
1592 struct radeon_device
*rdev
= dev
->dev_private
;
1593 struct drm_connector
*connector
;
1594 struct radeon_connector
*radeon_connector
;
1595 uint32_t subpixel_order
= SubPixelNone
;
1597 if (connector_type
== DRM_MODE_CONNECTOR_Unknown
)
1600 /* if the user selected tv=0 don't try and add the connector */
1601 if (((connector_type
== DRM_MODE_CONNECTOR_SVIDEO
) ||
1602 (connector_type
== DRM_MODE_CONNECTOR_Composite
) ||
1603 (connector_type
== DRM_MODE_CONNECTOR_9PinDIN
)) &&
1607 /* see if we already added it */
1608 list_for_each_entry(connector
, &dev
->mode_config
.connector_list
, head
) {
1609 radeon_connector
= to_radeon_connector(connector
);
1610 if (radeon_connector
->connector_id
== connector_id
) {
1611 radeon_connector
->devices
|= supported_device
;
1616 radeon_connector
= kzalloc(sizeof(struct radeon_connector
), GFP_KERNEL
);
1617 if (!radeon_connector
)
1620 connector
= &radeon_connector
->base
;
1622 radeon_connector
->connector_id
= connector_id
;
1623 radeon_connector
->devices
= supported_device
;
1624 radeon_connector
->connector_object_id
= connector_object_id
;
1625 radeon_connector
->hpd
= *hpd
;
1626 switch (connector_type
) {
1627 case DRM_MODE_CONNECTOR_VGA
:
1628 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_vga_connector_funcs
, connector_type
);
1629 drm_connector_helper_add(&radeon_connector
->base
, &radeon_vga_connector_helper_funcs
);
1630 if (i2c_bus
->valid
) {
1631 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1632 if (!radeon_connector
->ddc_bus
)
1633 DRM_ERROR("VGA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1635 radeon_connector
->dac_load_detect
= true;
1636 drm_connector_attach_property(&radeon_connector
->base
,
1637 rdev
->mode_info
.load_detect_property
,
1639 /* no HPD on analog connectors */
1640 radeon_connector
->hpd
.hpd
= RADEON_HPD_NONE
;
1641 connector
->polled
= DRM_CONNECTOR_POLL_CONNECT
;
1642 connector
->interlace_allowed
= true;
1643 connector
->doublescan_allowed
= true;
1645 case DRM_MODE_CONNECTOR_DVIA
:
1646 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_vga_connector_funcs
, connector_type
);
1647 drm_connector_helper_add(&radeon_connector
->base
, &radeon_vga_connector_helper_funcs
);
1648 if (i2c_bus
->valid
) {
1649 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1650 if (!radeon_connector
->ddc_bus
)
1651 DRM_ERROR("DVIA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1653 radeon_connector
->dac_load_detect
= true;
1654 drm_connector_attach_property(&radeon_connector
->base
,
1655 rdev
->mode_info
.load_detect_property
,
1657 /* no HPD on analog connectors */
1658 radeon_connector
->hpd
.hpd
= RADEON_HPD_NONE
;
1659 connector
->interlace_allowed
= true;
1660 connector
->doublescan_allowed
= true;
1662 case DRM_MODE_CONNECTOR_DVII
:
1663 case DRM_MODE_CONNECTOR_DVID
:
1664 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_dvi_connector_funcs
, connector_type
);
1665 drm_connector_helper_add(&radeon_connector
->base
, &radeon_dvi_connector_helper_funcs
);
1666 if (i2c_bus
->valid
) {
1667 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1668 if (!radeon_connector
->ddc_bus
)
1669 DRM_ERROR("DVI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1671 if (connector_type
== DRM_MODE_CONNECTOR_DVII
) {
1672 radeon_connector
->dac_load_detect
= true;
1673 drm_connector_attach_property(&radeon_connector
->base
,
1674 rdev
->mode_info
.load_detect_property
,
1677 subpixel_order
= SubPixelHorizontalRGB
;
1678 connector
->interlace_allowed
= true;
1679 if (connector_type
== DRM_MODE_CONNECTOR_DVII
)
1680 connector
->doublescan_allowed
= true;
1682 connector
->doublescan_allowed
= false;
1684 case DRM_MODE_CONNECTOR_SVIDEO
:
1685 case DRM_MODE_CONNECTOR_Composite
:
1686 case DRM_MODE_CONNECTOR_9PinDIN
:
1687 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_tv_connector_funcs
, connector_type
);
1688 drm_connector_helper_add(&radeon_connector
->base
, &radeon_tv_connector_helper_funcs
);
1689 radeon_connector
->dac_load_detect
= true;
1690 /* RS400,RC410,RS480 chipset seems to report a lot
1691 * of false positive on load detect, we haven't yet
1692 * found a way to make load detect reliable on those
1693 * chipset, thus just disable it for TV.
1695 if (rdev
->family
== CHIP_RS400
|| rdev
->family
== CHIP_RS480
)
1696 radeon_connector
->dac_load_detect
= false;
1697 drm_connector_attach_property(&radeon_connector
->base
,
1698 rdev
->mode_info
.load_detect_property
,
1699 radeon_connector
->dac_load_detect
);
1700 drm_connector_attach_property(&radeon_connector
->base
,
1701 rdev
->mode_info
.tv_std_property
,
1702 radeon_combios_get_tv_info(rdev
));
1703 /* no HPD on analog connectors */
1704 radeon_connector
->hpd
.hpd
= RADEON_HPD_NONE
;
1705 connector
->interlace_allowed
= false;
1706 connector
->doublescan_allowed
= false;
1708 case DRM_MODE_CONNECTOR_LVDS
:
1709 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_lvds_connector_funcs
, connector_type
);
1710 drm_connector_helper_add(&radeon_connector
->base
, &radeon_lvds_connector_helper_funcs
);
1711 if (i2c_bus
->valid
) {
1712 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1713 if (!radeon_connector
->ddc_bus
)
1714 DRM_ERROR("LVDS: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1716 drm_connector_attach_property(&radeon_connector
->base
,
1717 dev
->mode_config
.scaling_mode_property
,
1718 DRM_MODE_SCALE_FULLSCREEN
);
1719 subpixel_order
= SubPixelHorizontalRGB
;
1720 connector
->interlace_allowed
= false;
1721 connector
->doublescan_allowed
= false;
1725 if (radeon_connector
->hpd
.hpd
== RADEON_HPD_NONE
) {
1727 connector
->polled
= DRM_CONNECTOR_POLL_CONNECT
;
1729 connector
->polled
= DRM_CONNECTOR_POLL_HPD
;
1730 connector
->display_info
.subpixel_order
= subpixel_order
;
1731 drm_sysfs_connector_add(connector
);
1732 if (connector_type
== DRM_MODE_CONNECTOR_LVDS
) {
1733 struct drm_encoder
*drm_encoder
;
1735 list_for_each_entry(drm_encoder
, &dev
->mode_config
.encoder_list
, head
) {
1736 struct radeon_encoder
*radeon_encoder
;
1738 radeon_encoder
= to_radeon_encoder(drm_encoder
);
1739 if (radeon_encoder
->encoder_id
== ENCODER_OBJECT_ID_INTERNAL_LVDS
)
1740 radeon_legacy_backlight_init(radeon_encoder
, connector
);