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 bool radeon_connector_encoder_is_dp_bridge(struct drm_connector
*connector
);
49 void radeon_connector_hotplug(struct drm_connector
*connector
)
51 struct drm_device
*dev
= connector
->dev
;
52 struct radeon_device
*rdev
= dev
->dev_private
;
53 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
55 /* bail if the connector does not have hpd pin, e.g.,
58 if (radeon_connector
->hpd
.hpd
== RADEON_HPD_NONE
)
61 radeon_hpd_set_polarity(rdev
, radeon_connector
->hpd
.hpd
);
63 /* if the connector is already off, don't turn it back on */
64 if (connector
->dpms
!= DRM_MODE_DPMS_ON
)
67 /* just deal with DP (not eDP) here. */
68 if (connector
->connector_type
== DRM_MODE_CONNECTOR_DisplayPort
) {
69 int saved_dpms
= connector
->dpms
;
71 if (radeon_hpd_sense(rdev
, radeon_connector
->hpd
.hpd
) &&
72 radeon_dp_needs_link_train(radeon_connector
))
73 drm_helper_connector_dpms(connector
, DRM_MODE_DPMS_ON
);
75 drm_helper_connector_dpms(connector
, DRM_MODE_DPMS_OFF
);
76 connector
->dpms
= saved_dpms
;
80 static void radeon_property_change_mode(struct drm_encoder
*encoder
)
82 struct drm_crtc
*crtc
= encoder
->crtc
;
84 if (crtc
&& crtc
->enabled
) {
85 drm_crtc_helper_set_mode(crtc
, &crtc
->mode
,
86 crtc
->x
, crtc
->y
, crtc
->fb
);
90 radeon_connector_update_scratch_regs(struct drm_connector
*connector
, enum drm_connector_status status
)
92 struct drm_device
*dev
= connector
->dev
;
93 struct radeon_device
*rdev
= dev
->dev_private
;
94 struct drm_encoder
*best_encoder
= NULL
;
95 struct drm_encoder
*encoder
= NULL
;
96 struct drm_connector_helper_funcs
*connector_funcs
= connector
->helper_private
;
97 struct drm_mode_object
*obj
;
101 best_encoder
= connector_funcs
->best_encoder(connector
);
103 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
104 if (connector
->encoder_ids
[i
] == 0)
107 obj
= drm_mode_object_find(connector
->dev
,
108 connector
->encoder_ids
[i
],
109 DRM_MODE_OBJECT_ENCODER
);
113 encoder
= obj_to_encoder(obj
);
115 if ((encoder
== best_encoder
) && (status
== connector_status_connected
))
120 if (rdev
->is_atom_bios
)
121 radeon_atombios_connected_scratch_regs(connector
, encoder
, connected
);
123 radeon_combios_connected_scratch_regs(connector
, encoder
, connected
);
128 struct drm_encoder
*radeon_find_encoder(struct drm_connector
*connector
, int encoder_type
)
130 struct drm_mode_object
*obj
;
131 struct drm_encoder
*encoder
;
134 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
135 if (connector
->encoder_ids
[i
] == 0)
138 obj
= drm_mode_object_find(connector
->dev
, connector
->encoder_ids
[i
], DRM_MODE_OBJECT_ENCODER
);
142 encoder
= obj_to_encoder(obj
);
143 if (encoder
->encoder_type
== encoder_type
)
149 struct drm_encoder
*radeon_best_single_encoder(struct drm_connector
*connector
)
151 int enc_id
= connector
->encoder_ids
[0];
152 struct drm_mode_object
*obj
;
153 struct drm_encoder
*encoder
;
155 /* pick the encoder ids */
157 obj
= drm_mode_object_find(connector
->dev
, enc_id
, DRM_MODE_OBJECT_ENCODER
);
160 encoder
= obj_to_encoder(obj
);
167 * radeon_connector_analog_encoder_conflict_solve
168 * - search for other connectors sharing this encoder
169 * if priority is true, then set them disconnected if this is connected
170 * if priority is false, set us disconnected if they are connected
172 static enum drm_connector_status
173 radeon_connector_analog_encoder_conflict_solve(struct drm_connector
*connector
,
174 struct drm_encoder
*encoder
,
175 enum drm_connector_status current_status
,
178 struct drm_device
*dev
= connector
->dev
;
179 struct drm_connector
*conflict
;
180 struct radeon_connector
*radeon_conflict
;
183 list_for_each_entry(conflict
, &dev
->mode_config
.connector_list
, head
) {
184 if (conflict
== connector
)
187 radeon_conflict
= to_radeon_connector(conflict
);
188 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
189 if (conflict
->encoder_ids
[i
] == 0)
192 /* if the IDs match */
193 if (conflict
->encoder_ids
[i
] == encoder
->base
.id
) {
194 if (conflict
->status
!= connector_status_connected
)
197 if (radeon_conflict
->use_digital
)
200 if (priority
== true) {
201 DRM_DEBUG_KMS("1: conflicting encoders switching off %s\n", drm_get_connector_name(conflict
));
202 DRM_DEBUG_KMS("in favor of %s\n", drm_get_connector_name(connector
));
203 conflict
->status
= connector_status_disconnected
;
204 radeon_connector_update_scratch_regs(conflict
, connector_status_disconnected
);
206 DRM_DEBUG_KMS("2: conflicting encoders switching off %s\n", drm_get_connector_name(connector
));
207 DRM_DEBUG_KMS("in favor of %s\n", drm_get_connector_name(conflict
));
208 current_status
= connector_status_disconnected
;
214 return current_status
;
218 static struct drm_display_mode
*radeon_fp_native_mode(struct drm_encoder
*encoder
)
220 struct drm_device
*dev
= encoder
->dev
;
221 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
222 struct drm_display_mode
*mode
= NULL
;
223 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
225 if (native_mode
->hdisplay
!= 0 &&
226 native_mode
->vdisplay
!= 0 &&
227 native_mode
->clock
!= 0) {
228 mode
= drm_mode_duplicate(dev
, native_mode
);
229 mode
->type
= DRM_MODE_TYPE_PREFERRED
| DRM_MODE_TYPE_DRIVER
;
230 drm_mode_set_name(mode
);
232 DRM_DEBUG_KMS("Adding native panel mode %s\n", mode
->name
);
233 } else if (native_mode
->hdisplay
!= 0 &&
234 native_mode
->vdisplay
!= 0) {
235 /* mac laptops without an edid */
236 /* Note that this is not necessarily the exact panel mode,
237 * but an approximation based on the cvt formula. For these
238 * systems we should ideally read the mode info out of the
239 * registers or add a mode table, but this works and is much
242 mode
= drm_cvt_mode(dev
, native_mode
->hdisplay
, native_mode
->vdisplay
, 60, true, false, false);
243 mode
->type
= DRM_MODE_TYPE_PREFERRED
| DRM_MODE_TYPE_DRIVER
;
244 DRM_DEBUG_KMS("Adding cvt approximation of native panel mode %s\n", mode
->name
);
249 static void radeon_add_common_modes(struct drm_encoder
*encoder
, struct drm_connector
*connector
)
251 struct drm_device
*dev
= encoder
->dev
;
252 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
253 struct drm_display_mode
*mode
= NULL
;
254 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
259 } common_modes
[17] = {
279 for (i
= 0; i
< 17; i
++) {
280 if (radeon_encoder
->devices
& (ATOM_DEVICE_TV_SUPPORT
)) {
281 if (common_modes
[i
].w
> 1024 ||
282 common_modes
[i
].h
> 768)
285 if (radeon_encoder
->devices
& (ATOM_DEVICE_LCD_SUPPORT
)) {
286 if (common_modes
[i
].w
> native_mode
->hdisplay
||
287 common_modes
[i
].h
> native_mode
->vdisplay
||
288 (common_modes
[i
].w
== native_mode
->hdisplay
&&
289 common_modes
[i
].h
== native_mode
->vdisplay
))
292 if (common_modes
[i
].w
< 320 || common_modes
[i
].h
< 200)
295 mode
= drm_cvt_mode(dev
, common_modes
[i
].w
, common_modes
[i
].h
, 60, false, false, false);
296 drm_mode_probed_add(connector
, mode
);
300 int radeon_connector_set_property(struct drm_connector
*connector
, struct drm_property
*property
,
303 struct drm_device
*dev
= connector
->dev
;
304 struct radeon_device
*rdev
= dev
->dev_private
;
305 struct drm_encoder
*encoder
;
306 struct radeon_encoder
*radeon_encoder
;
308 if (property
== rdev
->mode_info
.coherent_mode_property
) {
309 struct radeon_encoder_atom_dig
*dig
;
310 bool new_coherent_mode
;
312 /* need to find digital encoder on connector */
313 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TMDS
);
317 radeon_encoder
= to_radeon_encoder(encoder
);
319 if (!radeon_encoder
->enc_priv
)
322 dig
= radeon_encoder
->enc_priv
;
323 new_coherent_mode
= val
? true : false;
324 if (dig
->coherent_mode
!= new_coherent_mode
) {
325 dig
->coherent_mode
= new_coherent_mode
;
326 radeon_property_change_mode(&radeon_encoder
->base
);
330 if (property
== rdev
->mode_info
.underscan_property
) {
331 /* need to find digital encoder on connector */
332 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TMDS
);
336 radeon_encoder
= to_radeon_encoder(encoder
);
338 if (radeon_encoder
->underscan_type
!= val
) {
339 radeon_encoder
->underscan_type
= val
;
340 radeon_property_change_mode(&radeon_encoder
->base
);
344 if (property
== rdev
->mode_info
.underscan_hborder_property
) {
345 /* need to find digital encoder on connector */
346 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TMDS
);
350 radeon_encoder
= to_radeon_encoder(encoder
);
352 if (radeon_encoder
->underscan_hborder
!= val
) {
353 radeon_encoder
->underscan_hborder
= val
;
354 radeon_property_change_mode(&radeon_encoder
->base
);
358 if (property
== rdev
->mode_info
.underscan_vborder_property
) {
359 /* need to find digital encoder on connector */
360 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TMDS
);
364 radeon_encoder
= to_radeon_encoder(encoder
);
366 if (radeon_encoder
->underscan_vborder
!= val
) {
367 radeon_encoder
->underscan_vborder
= val
;
368 radeon_property_change_mode(&radeon_encoder
->base
);
372 if (property
== rdev
->mode_info
.tv_std_property
) {
373 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TVDAC
);
375 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_DAC
);
381 radeon_encoder
= to_radeon_encoder(encoder
);
382 if (!radeon_encoder
->enc_priv
)
384 if (ASIC_IS_AVIVO(rdev
) || radeon_r4xx_atom
) {
385 struct radeon_encoder_atom_dac
*dac_int
;
386 dac_int
= radeon_encoder
->enc_priv
;
387 dac_int
->tv_std
= val
;
389 struct radeon_encoder_tv_dac
*dac_int
;
390 dac_int
= radeon_encoder
->enc_priv
;
391 dac_int
->tv_std
= val
;
393 radeon_property_change_mode(&radeon_encoder
->base
);
396 if (property
== rdev
->mode_info
.load_detect_property
) {
397 struct radeon_connector
*radeon_connector
=
398 to_radeon_connector(connector
);
401 radeon_connector
->dac_load_detect
= false;
403 radeon_connector
->dac_load_detect
= true;
406 if (property
== rdev
->mode_info
.tmds_pll_property
) {
407 struct radeon_encoder_int_tmds
*tmds
= NULL
;
409 /* need to find digital encoder on connector */
410 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TMDS
);
414 radeon_encoder
= to_radeon_encoder(encoder
);
416 tmds
= radeon_encoder
->enc_priv
;
421 if (rdev
->is_atom_bios
)
422 ret
= radeon_atombios_get_tmds_info(radeon_encoder
, tmds
);
424 ret
= radeon_legacy_get_tmds_info_from_combios(radeon_encoder
, tmds
);
426 if (val
== 1 || ret
== false) {
427 radeon_legacy_get_tmds_info_from_table(radeon_encoder
, tmds
);
429 radeon_property_change_mode(&radeon_encoder
->base
);
436 * Some integrated ATI Radeon chipset implementations (e. g.
437 * Asus M2A-VM HDMI) may indicate the availability of a DDC,
438 * even when there's no monitor connected. For these connectors
439 * following DDC probe extension will be applied: check also for the
440 * availability of EDID with at least a correct EDID header. Only then,
441 * DDC is assumed to be available. This prevents drm_get_edid() and
442 * drm_edid_block_valid() from periodically dumping data and kernel
443 * errors into the logs and onto the terminal.
445 static bool radeon_connector_needs_extended_probe(struct radeon_device
*dev
,
446 uint32_t supported_device
,
449 /* Asus M2A-VM HDMI board sends data to i2c bus even,
450 * if HDMI add-on card is not plugged in or HDMI is disabled in
451 * BIOS. Valid DDC can only be assumed, if also a valid EDID header
452 * can be retrieved via i2c bus during DDC probe */
453 if ((dev
->pdev
->device
== 0x791e) &&
454 (dev
->pdev
->subsystem_vendor
== 0x1043) &&
455 (dev
->pdev
->subsystem_device
== 0x826d)) {
456 if ((connector_type
== DRM_MODE_CONNECTOR_HDMIA
) &&
457 (supported_device
== ATOM_DEVICE_DFP2_SUPPORT
))
460 /* ECS A740GM-M with ATI RADEON 2100 sends data to i2c bus
461 * for a DVI connector that is not implemented */
462 if ((dev
->pdev
->device
== 0x796e) &&
463 (dev
->pdev
->subsystem_vendor
== 0x1019) &&
464 (dev
->pdev
->subsystem_device
== 0x2615)) {
465 if ((connector_type
== DRM_MODE_CONNECTOR_DVID
) &&
466 (supported_device
== ATOM_DEVICE_DFP2_SUPPORT
))
470 /* Default: no EDID header probe required for DDC probing */
474 static void radeon_fixup_lvds_native_mode(struct drm_encoder
*encoder
,
475 struct drm_connector
*connector
)
477 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
478 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
479 struct drm_display_mode
*t
, *mode
;
481 /* If the EDID preferred mode doesn't match the native mode, use it */
482 list_for_each_entry_safe(mode
, t
, &connector
->probed_modes
, head
) {
483 if (mode
->type
& DRM_MODE_TYPE_PREFERRED
) {
484 if (mode
->hdisplay
!= native_mode
->hdisplay
||
485 mode
->vdisplay
!= native_mode
->vdisplay
)
486 memcpy(native_mode
, mode
, sizeof(*mode
));
490 /* Try to get native mode details from EDID if necessary */
491 if (!native_mode
->clock
) {
492 list_for_each_entry_safe(mode
, t
, &connector
->probed_modes
, head
) {
493 if (mode
->hdisplay
== native_mode
->hdisplay
&&
494 mode
->vdisplay
== native_mode
->vdisplay
) {
495 *native_mode
= *mode
;
496 drm_mode_set_crtcinfo(native_mode
, CRTC_INTERLACE_HALVE_V
);
497 DRM_DEBUG_KMS("Determined LVDS native mode details from EDID\n");
503 if (!native_mode
->clock
) {
504 DRM_DEBUG_KMS("No LVDS native mode details, disabling RMX\n");
505 radeon_encoder
->rmx_type
= RMX_OFF
;
509 static int radeon_lvds_get_modes(struct drm_connector
*connector
)
511 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
512 struct drm_encoder
*encoder
;
514 struct drm_display_mode
*mode
;
516 if (radeon_connector
->ddc_bus
) {
517 ret
= radeon_ddc_get_modes(radeon_connector
);
519 encoder
= radeon_best_single_encoder(connector
);
521 radeon_fixup_lvds_native_mode(encoder
, connector
);
522 /* add scaled modes */
523 radeon_add_common_modes(encoder
, connector
);
529 encoder
= radeon_best_single_encoder(connector
);
533 /* we have no EDID modes */
534 mode
= radeon_fp_native_mode(encoder
);
537 drm_mode_probed_add(connector
, mode
);
538 /* add the width/height from vbios tables if available */
539 connector
->display_info
.width_mm
= mode
->width_mm
;
540 connector
->display_info
.height_mm
= mode
->height_mm
;
541 /* add scaled modes */
542 radeon_add_common_modes(encoder
, connector
);
548 static int radeon_lvds_mode_valid(struct drm_connector
*connector
,
549 struct drm_display_mode
*mode
)
551 struct drm_encoder
*encoder
= radeon_best_single_encoder(connector
);
553 if ((mode
->hdisplay
< 320) || (mode
->vdisplay
< 240))
557 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
558 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
560 /* AVIVO hardware supports downscaling modes larger than the panel
561 * to the panel size, but I'm not sure this is desirable.
563 if ((mode
->hdisplay
> native_mode
->hdisplay
) ||
564 (mode
->vdisplay
> native_mode
->vdisplay
))
567 /* if scaling is disabled, block non-native modes */
568 if (radeon_encoder
->rmx_type
== RMX_OFF
) {
569 if ((mode
->hdisplay
!= native_mode
->hdisplay
) ||
570 (mode
->vdisplay
!= native_mode
->vdisplay
))
578 static enum drm_connector_status
579 radeon_lvds_detect(struct drm_connector
*connector
, bool force
)
581 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
582 struct drm_encoder
*encoder
= radeon_best_single_encoder(connector
);
583 enum drm_connector_status ret
= connector_status_disconnected
;
586 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
587 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
589 /* check if panel is valid */
590 if (native_mode
->hdisplay
>= 320 && native_mode
->vdisplay
>= 240)
591 ret
= connector_status_connected
;
595 /* check for edid as well */
596 if (radeon_connector
->edid
)
597 ret
= connector_status_connected
;
599 if (radeon_connector
->ddc_bus
) {
600 radeon_connector
->edid
= drm_get_edid(&radeon_connector
->base
,
601 &radeon_connector
->ddc_bus
->adapter
);
602 if (radeon_connector
->edid
)
603 ret
= connector_status_connected
;
606 /* check acpi lid status ??? */
608 radeon_connector_update_scratch_regs(connector
, ret
);
612 static void radeon_connector_destroy(struct drm_connector
*connector
)
614 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
616 if (radeon_connector
->edid
)
617 kfree(radeon_connector
->edid
);
618 kfree(radeon_connector
->con_priv
);
619 drm_sysfs_connector_remove(connector
);
620 drm_connector_cleanup(connector
);
624 static int radeon_lvds_set_property(struct drm_connector
*connector
,
625 struct drm_property
*property
,
628 struct drm_device
*dev
= connector
->dev
;
629 struct radeon_encoder
*radeon_encoder
;
630 enum radeon_rmx_type rmx_type
;
633 if (property
!= dev
->mode_config
.scaling_mode_property
)
636 if (connector
->encoder
)
637 radeon_encoder
= to_radeon_encoder(connector
->encoder
);
639 struct drm_connector_helper_funcs
*connector_funcs
= connector
->helper_private
;
640 radeon_encoder
= to_radeon_encoder(connector_funcs
->best_encoder(connector
));
644 case DRM_MODE_SCALE_NONE
: rmx_type
= RMX_OFF
; break;
645 case DRM_MODE_SCALE_CENTER
: rmx_type
= RMX_CENTER
; break;
646 case DRM_MODE_SCALE_ASPECT
: rmx_type
= RMX_ASPECT
; break;
648 case DRM_MODE_SCALE_FULLSCREEN
: rmx_type
= RMX_FULL
; break;
650 if (radeon_encoder
->rmx_type
== rmx_type
)
653 radeon_encoder
->rmx_type
= rmx_type
;
655 radeon_property_change_mode(&radeon_encoder
->base
);
660 struct drm_connector_helper_funcs radeon_lvds_connector_helper_funcs
= {
661 .get_modes
= radeon_lvds_get_modes
,
662 .mode_valid
= radeon_lvds_mode_valid
,
663 .best_encoder
= radeon_best_single_encoder
,
666 struct drm_connector_funcs radeon_lvds_connector_funcs
= {
667 .dpms
= drm_helper_connector_dpms
,
668 .detect
= radeon_lvds_detect
,
669 .fill_modes
= drm_helper_probe_single_connector_modes
,
670 .destroy
= radeon_connector_destroy
,
671 .set_property
= radeon_lvds_set_property
,
674 static int radeon_vga_get_modes(struct drm_connector
*connector
)
676 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
679 ret
= radeon_ddc_get_modes(radeon_connector
);
684 static int radeon_vga_mode_valid(struct drm_connector
*connector
,
685 struct drm_display_mode
*mode
)
687 struct drm_device
*dev
= connector
->dev
;
688 struct radeon_device
*rdev
= dev
->dev_private
;
690 /* XXX check mode bandwidth */
692 if ((mode
->clock
/ 10) > rdev
->clock
.max_pixel_clock
)
693 return MODE_CLOCK_HIGH
;
698 static enum drm_connector_status
699 radeon_vga_detect(struct drm_connector
*connector
, bool force
)
701 struct drm_device
*dev
= connector
->dev
;
702 struct radeon_device
*rdev
= dev
->dev_private
;
703 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
704 struct drm_encoder
*encoder
;
705 struct drm_encoder_helper_funcs
*encoder_funcs
;
707 enum drm_connector_status ret
= connector_status_disconnected
;
709 encoder
= radeon_best_single_encoder(connector
);
711 ret
= connector_status_disconnected
;
713 if (radeon_connector
->ddc_bus
)
714 dret
= radeon_ddc_probe(radeon_connector
,
715 radeon_connector
->requires_extended_probe
);
717 if (radeon_connector
->edid
) {
718 kfree(radeon_connector
->edid
);
719 radeon_connector
->edid
= NULL
;
721 radeon_connector
->edid
= drm_get_edid(&radeon_connector
->base
, &radeon_connector
->ddc_bus
->adapter
);
723 if (!radeon_connector
->edid
) {
724 DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
725 drm_get_connector_name(connector
));
726 ret
= connector_status_connected
;
728 radeon_connector
->use_digital
= !!(radeon_connector
->edid
->input
& DRM_EDID_INPUT_DIGITAL
);
730 /* some oems have boards with separate digital and analog connectors
731 * with a shared ddc line (often vga + hdmi)
733 if (radeon_connector
->use_digital
&& radeon_connector
->shared_ddc
) {
734 kfree(radeon_connector
->edid
);
735 radeon_connector
->edid
= NULL
;
736 ret
= connector_status_disconnected
;
738 ret
= connector_status_connected
;
742 /* if we aren't forcing don't do destructive polling */
744 return connector
->status
;
746 if (radeon_connector
->dac_load_detect
&& encoder
) {
747 encoder_funcs
= encoder
->helper_private
;
748 ret
= encoder_funcs
->detect(encoder
, connector
);
752 if (ret
== connector_status_connected
)
753 ret
= radeon_connector_analog_encoder_conflict_solve(connector
, encoder
, ret
, true);
755 /* RN50 and some RV100 asics in servers often have a hardcoded EDID in the
756 * vbios to deal with KVMs. If we have one and are not able to detect a monitor
757 * by other means, assume the CRT is connected and use that EDID.
759 if ((!rdev
->is_atom_bios
) &&
760 (ret
== connector_status_disconnected
) &&
761 rdev
->mode_info
.bios_hardcoded_edid_size
) {
762 ret
= connector_status_connected
;
765 radeon_connector_update_scratch_regs(connector
, ret
);
769 struct drm_connector_helper_funcs radeon_vga_connector_helper_funcs
= {
770 .get_modes
= radeon_vga_get_modes
,
771 .mode_valid
= radeon_vga_mode_valid
,
772 .best_encoder
= radeon_best_single_encoder
,
775 struct drm_connector_funcs radeon_vga_connector_funcs
= {
776 .dpms
= drm_helper_connector_dpms
,
777 .detect
= radeon_vga_detect
,
778 .fill_modes
= drm_helper_probe_single_connector_modes
,
779 .destroy
= radeon_connector_destroy
,
780 .set_property
= radeon_connector_set_property
,
783 static int radeon_tv_get_modes(struct drm_connector
*connector
)
785 struct drm_device
*dev
= connector
->dev
;
786 struct radeon_device
*rdev
= dev
->dev_private
;
787 struct drm_display_mode
*tv_mode
;
788 struct drm_encoder
*encoder
;
790 encoder
= radeon_best_single_encoder(connector
);
794 /* avivo chips can scale any mode */
795 if (rdev
->family
>= CHIP_RS600
)
796 /* add scaled modes */
797 radeon_add_common_modes(encoder
, connector
);
799 /* only 800x600 is supported right now on pre-avivo chips */
800 tv_mode
= drm_cvt_mode(dev
, 800, 600, 60, false, false, false);
801 tv_mode
->type
= DRM_MODE_TYPE_DRIVER
| DRM_MODE_TYPE_PREFERRED
;
802 drm_mode_probed_add(connector
, tv_mode
);
807 static int radeon_tv_mode_valid(struct drm_connector
*connector
,
808 struct drm_display_mode
*mode
)
810 if ((mode
->hdisplay
> 1024) || (mode
->vdisplay
> 768))
811 return MODE_CLOCK_RANGE
;
815 static enum drm_connector_status
816 radeon_tv_detect(struct drm_connector
*connector
, bool force
)
818 struct drm_encoder
*encoder
;
819 struct drm_encoder_helper_funcs
*encoder_funcs
;
820 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
821 enum drm_connector_status ret
= connector_status_disconnected
;
823 if (!radeon_connector
->dac_load_detect
)
826 encoder
= radeon_best_single_encoder(connector
);
828 ret
= connector_status_disconnected
;
830 encoder_funcs
= encoder
->helper_private
;
831 ret
= encoder_funcs
->detect(encoder
, connector
);
833 if (ret
== connector_status_connected
)
834 ret
= radeon_connector_analog_encoder_conflict_solve(connector
, encoder
, ret
, false);
835 radeon_connector_update_scratch_regs(connector
, ret
);
839 struct drm_connector_helper_funcs radeon_tv_connector_helper_funcs
= {
840 .get_modes
= radeon_tv_get_modes
,
841 .mode_valid
= radeon_tv_mode_valid
,
842 .best_encoder
= radeon_best_single_encoder
,
845 struct drm_connector_funcs radeon_tv_connector_funcs
= {
846 .dpms
= drm_helper_connector_dpms
,
847 .detect
= radeon_tv_detect
,
848 .fill_modes
= drm_helper_probe_single_connector_modes
,
849 .destroy
= radeon_connector_destroy
,
850 .set_property
= radeon_connector_set_property
,
853 static int radeon_dvi_get_modes(struct drm_connector
*connector
)
855 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
858 ret
= radeon_ddc_get_modes(radeon_connector
);
864 * Do a DDC probe, if DDC probe passes, get the full EDID so
865 * we can do analog/digital monitor detection at this point.
866 * If the monitor is an analog monitor or we got no DDC,
867 * we need to find the DAC encoder object for this connector.
868 * If we got no DDC, we do load detection on the DAC encoder object.
869 * If we got analog DDC or load detection passes on the DAC encoder
870 * we have to check if this analog encoder is shared with anyone else (TV)
871 * if its shared we have to set the other connector to disconnected.
873 static enum drm_connector_status
874 radeon_dvi_detect(struct drm_connector
*connector
, bool force
)
876 struct drm_device
*dev
= connector
->dev
;
877 struct radeon_device
*rdev
= dev
->dev_private
;
878 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
879 struct drm_encoder
*encoder
= NULL
;
880 struct drm_encoder_helper_funcs
*encoder_funcs
;
881 struct drm_mode_object
*obj
;
883 enum drm_connector_status ret
= connector_status_disconnected
;
886 if (radeon_connector
->ddc_bus
)
887 dret
= radeon_ddc_probe(radeon_connector
,
888 radeon_connector
->requires_extended_probe
);
890 if (radeon_connector
->edid
) {
891 kfree(radeon_connector
->edid
);
892 radeon_connector
->edid
= NULL
;
894 radeon_connector
->edid
= drm_get_edid(&radeon_connector
->base
, &radeon_connector
->ddc_bus
->adapter
);
896 if (!radeon_connector
->edid
) {
897 DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
898 drm_get_connector_name(connector
));
899 /* rs690 seems to have a problem with connectors not existing and always
900 * return a block of 0's. If we see this just stop polling on this output */
901 if ((rdev
->family
== CHIP_RS690
|| rdev
->family
== CHIP_RS740
) && radeon_connector
->base
.null_edid_counter
) {
902 ret
= connector_status_disconnected
;
903 DRM_ERROR("%s: detected RS690 floating bus bug, stopping ddc detect\n", drm_get_connector_name(connector
));
904 radeon_connector
->ddc_bus
= NULL
;
907 radeon_connector
->use_digital
= !!(radeon_connector
->edid
->input
& DRM_EDID_INPUT_DIGITAL
);
909 /* some oems have boards with separate digital and analog connectors
910 * with a shared ddc line (often vga + hdmi)
912 if ((!radeon_connector
->use_digital
) && radeon_connector
->shared_ddc
) {
913 kfree(radeon_connector
->edid
);
914 radeon_connector
->edid
= NULL
;
915 ret
= connector_status_disconnected
;
917 ret
= connector_status_connected
;
919 /* This gets complicated. We have boards with VGA + HDMI with a
920 * shared DDC line and we have boards with DVI-D + HDMI with a shared
921 * DDC line. The latter is more complex because with DVI<->HDMI adapters
922 * you don't really know what's connected to which port as both are digital.
924 if (radeon_connector
->shared_ddc
&& (ret
== connector_status_connected
)) {
925 struct drm_connector
*list_connector
;
926 struct radeon_connector
*list_radeon_connector
;
927 list_for_each_entry(list_connector
, &dev
->mode_config
.connector_list
, head
) {
928 if (connector
== list_connector
)
930 list_radeon_connector
= to_radeon_connector(list_connector
);
931 if (list_radeon_connector
->shared_ddc
&&
932 (list_radeon_connector
->ddc_bus
->rec
.i2c_id
==
933 radeon_connector
->ddc_bus
->rec
.i2c_id
)) {
934 /* cases where both connectors are digital */
935 if (list_connector
->connector_type
!= DRM_MODE_CONNECTOR_VGA
) {
936 /* hpd is our only option in this case */
937 if (!radeon_hpd_sense(rdev
, radeon_connector
->hpd
.hpd
)) {
938 kfree(radeon_connector
->edid
);
939 radeon_connector
->edid
= NULL
;
940 ret
= connector_status_disconnected
;
949 if ((ret
== connector_status_connected
) && (radeon_connector
->use_digital
== true))
953 ret
= connector
->status
;
957 /* find analog encoder */
958 if (radeon_connector
->dac_load_detect
) {
959 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
960 if (connector
->encoder_ids
[i
] == 0)
963 obj
= drm_mode_object_find(connector
->dev
,
964 connector
->encoder_ids
[i
],
965 DRM_MODE_OBJECT_ENCODER
);
969 encoder
= obj_to_encoder(obj
);
971 encoder_funcs
= encoder
->helper_private
;
972 if (encoder_funcs
->detect
) {
973 if (ret
!= connector_status_connected
) {
974 ret
= encoder_funcs
->detect(encoder
, connector
);
975 if (ret
== connector_status_connected
) {
976 radeon_connector
->use_digital
= false;
984 if ((ret
== connector_status_connected
) && (radeon_connector
->use_digital
== false) &&
986 ret
= radeon_connector_analog_encoder_conflict_solve(connector
, encoder
, ret
, true);
989 /* RN50 and some RV100 asics in servers often have a hardcoded EDID in the
990 * vbios to deal with KVMs. If we have one and are not able to detect a monitor
991 * by other means, assume the DFP is connected and use that EDID. In most
992 * cases the DVI port is actually a virtual KVM port connected to the service
995 if ((!rdev
->is_atom_bios
) &&
996 (ret
== connector_status_disconnected
) &&
997 rdev
->mode_info
.bios_hardcoded_edid_size
) {
998 radeon_connector
->use_digital
= true;
999 ret
= connector_status_connected
;
1003 /* updated in get modes as well since we need to know if it's analog or digital */
1004 radeon_connector_update_scratch_regs(connector
, ret
);
1008 /* okay need to be smart in here about which encoder to pick */
1009 struct drm_encoder
*radeon_dvi_encoder(struct drm_connector
*connector
)
1011 int enc_id
= connector
->encoder_ids
[0];
1012 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1013 struct drm_mode_object
*obj
;
1014 struct drm_encoder
*encoder
;
1016 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
1017 if (connector
->encoder_ids
[i
] == 0)
1020 obj
= drm_mode_object_find(connector
->dev
, connector
->encoder_ids
[i
], DRM_MODE_OBJECT_ENCODER
);
1024 encoder
= obj_to_encoder(obj
);
1026 if (radeon_connector
->use_digital
== true) {
1027 if (encoder
->encoder_type
== DRM_MODE_ENCODER_TMDS
)
1030 if (encoder
->encoder_type
== DRM_MODE_ENCODER_DAC
||
1031 encoder
->encoder_type
== DRM_MODE_ENCODER_TVDAC
)
1036 /* see if we have a default encoder TODO */
1038 /* then check use digitial */
1039 /* pick the first one */
1041 obj
= drm_mode_object_find(connector
->dev
, enc_id
, DRM_MODE_OBJECT_ENCODER
);
1044 encoder
= obj_to_encoder(obj
);
1050 static void radeon_dvi_force(struct drm_connector
*connector
)
1052 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1053 if (connector
->force
== DRM_FORCE_ON
)
1054 radeon_connector
->use_digital
= false;
1055 if (connector
->force
== DRM_FORCE_ON_DIGITAL
)
1056 radeon_connector
->use_digital
= true;
1059 static int radeon_dvi_mode_valid(struct drm_connector
*connector
,
1060 struct drm_display_mode
*mode
)
1062 struct drm_device
*dev
= connector
->dev
;
1063 struct radeon_device
*rdev
= dev
->dev_private
;
1064 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1066 /* XXX check mode bandwidth */
1068 /* clocks over 135 MHz have heat issues with DVI on RV100 */
1069 if (radeon_connector
->use_digital
&&
1070 (rdev
->family
== CHIP_RV100
) &&
1071 (mode
->clock
> 135000))
1072 return MODE_CLOCK_HIGH
;
1074 if (radeon_connector
->use_digital
&& (mode
->clock
> 165000)) {
1075 if ((radeon_connector
->connector_object_id
== CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_I
) ||
1076 (radeon_connector
->connector_object_id
== CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_D
) ||
1077 (radeon_connector
->connector_object_id
== CONNECTOR_OBJECT_ID_HDMI_TYPE_B
))
1079 else if (radeon_connector
->connector_object_id
== CONNECTOR_OBJECT_ID_HDMI_TYPE_A
) {
1080 if (ASIC_IS_DCE3(rdev
)) {
1081 /* HDMI 1.3+ supports max clock of 340 Mhz */
1082 if (mode
->clock
> 340000)
1083 return MODE_CLOCK_HIGH
;
1087 return MODE_CLOCK_HIGH
;
1089 return MODE_CLOCK_HIGH
;
1092 /* check against the max pixel clock */
1093 if ((mode
->clock
/ 10) > rdev
->clock
.max_pixel_clock
)
1094 return MODE_CLOCK_HIGH
;
1099 struct drm_connector_helper_funcs radeon_dvi_connector_helper_funcs
= {
1100 .get_modes
= radeon_dvi_get_modes
,
1101 .mode_valid
= radeon_dvi_mode_valid
,
1102 .best_encoder
= radeon_dvi_encoder
,
1105 struct drm_connector_funcs radeon_dvi_connector_funcs
= {
1106 .dpms
= drm_helper_connector_dpms
,
1107 .detect
= radeon_dvi_detect
,
1108 .fill_modes
= drm_helper_probe_single_connector_modes
,
1109 .set_property
= radeon_connector_set_property
,
1110 .destroy
= radeon_connector_destroy
,
1111 .force
= radeon_dvi_force
,
1114 static void radeon_dp_connector_destroy(struct drm_connector
*connector
)
1116 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1117 struct radeon_connector_atom_dig
*radeon_dig_connector
= radeon_connector
->con_priv
;
1119 if (radeon_connector
->edid
)
1120 kfree(radeon_connector
->edid
);
1121 if (radeon_dig_connector
->dp_i2c_bus
)
1122 radeon_i2c_destroy(radeon_dig_connector
->dp_i2c_bus
);
1123 kfree(radeon_connector
->con_priv
);
1124 drm_sysfs_connector_remove(connector
);
1125 drm_connector_cleanup(connector
);
1129 static int radeon_dp_get_modes(struct drm_connector
*connector
)
1131 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1132 struct radeon_connector_atom_dig
*radeon_dig_connector
= radeon_connector
->con_priv
;
1133 struct drm_encoder
*encoder
= radeon_best_single_encoder(connector
);
1136 if ((connector
->connector_type
== DRM_MODE_CONNECTOR_eDP
) ||
1137 (connector
->connector_type
== DRM_MODE_CONNECTOR_LVDS
)) {
1138 struct drm_display_mode
*mode
;
1140 if (!radeon_dig_connector
->edp_on
)
1141 atombios_set_edp_panel_power(connector
,
1142 ATOM_TRANSMITTER_ACTION_POWER_ON
);
1143 ret
= radeon_ddc_get_modes(radeon_connector
);
1144 if (!radeon_dig_connector
->edp_on
)
1145 atombios_set_edp_panel_power(connector
,
1146 ATOM_TRANSMITTER_ACTION_POWER_OFF
);
1150 radeon_fixup_lvds_native_mode(encoder
, connector
);
1151 /* add scaled modes */
1152 radeon_add_common_modes(encoder
, connector
);
1157 encoder
= radeon_best_single_encoder(connector
);
1161 /* we have no EDID modes */
1162 mode
= radeon_fp_native_mode(encoder
);
1165 drm_mode_probed_add(connector
, mode
);
1166 /* add the width/height from vbios tables if available */
1167 connector
->display_info
.width_mm
= mode
->width_mm
;
1168 connector
->display_info
.height_mm
= mode
->height_mm
;
1169 /* add scaled modes */
1170 radeon_add_common_modes(encoder
, connector
);
1173 /* need to setup ddc on the bridge */
1174 if (radeon_connector_encoder_is_dp_bridge(connector
)) {
1176 radeon_atom_ext_encoder_setup_ddc(encoder
);
1178 ret
= radeon_ddc_get_modes(radeon_connector
);
1184 bool radeon_connector_encoder_is_dp_bridge(struct drm_connector
*connector
)
1186 struct drm_mode_object
*obj
;
1187 struct drm_encoder
*encoder
;
1188 struct radeon_encoder
*radeon_encoder
;
1192 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
1193 if (connector
->encoder_ids
[i
] == 0)
1196 obj
= drm_mode_object_find(connector
->dev
, connector
->encoder_ids
[i
], DRM_MODE_OBJECT_ENCODER
);
1200 encoder
= obj_to_encoder(obj
);
1201 radeon_encoder
= to_radeon_encoder(encoder
);
1203 switch (radeon_encoder
->encoder_id
) {
1204 case ENCODER_OBJECT_ID_TRAVIS
:
1205 case ENCODER_OBJECT_ID_NUTMEG
:
1216 bool radeon_connector_encoder_is_hbr2(struct drm_connector
*connector
)
1218 struct drm_mode_object
*obj
;
1219 struct drm_encoder
*encoder
;
1220 struct radeon_encoder
*radeon_encoder
;
1224 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
1225 if (connector
->encoder_ids
[i
] == 0)
1228 obj
= drm_mode_object_find(connector
->dev
, connector
->encoder_ids
[i
], DRM_MODE_OBJECT_ENCODER
);
1232 encoder
= obj_to_encoder(obj
);
1233 radeon_encoder
= to_radeon_encoder(encoder
);
1234 if (radeon_encoder
->caps
& ATOM_ENCODER_CAP_RECORD_HBR2
)
1241 bool radeon_connector_is_dp12_capable(struct drm_connector
*connector
)
1243 struct drm_device
*dev
= connector
->dev
;
1244 struct radeon_device
*rdev
= dev
->dev_private
;
1246 if (ASIC_IS_DCE5(rdev
) &&
1247 (rdev
->clock
.dp_extclk
>= 53900) &&
1248 radeon_connector_encoder_is_hbr2(connector
)) {
1255 static enum drm_connector_status
1256 radeon_dp_detect(struct drm_connector
*connector
, bool force
)
1258 struct drm_device
*dev
= connector
->dev
;
1259 struct radeon_device
*rdev
= dev
->dev_private
;
1260 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1261 enum drm_connector_status ret
= connector_status_disconnected
;
1262 struct radeon_connector_atom_dig
*radeon_dig_connector
= radeon_connector
->con_priv
;
1263 struct drm_encoder
*encoder
= radeon_best_single_encoder(connector
);
1265 if (radeon_connector
->edid
) {
1266 kfree(radeon_connector
->edid
);
1267 radeon_connector
->edid
= NULL
;
1270 if ((connector
->connector_type
== DRM_MODE_CONNECTOR_eDP
) ||
1271 (connector
->connector_type
== DRM_MODE_CONNECTOR_LVDS
)) {
1273 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
1274 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
1276 /* check if panel is valid */
1277 if (native_mode
->hdisplay
>= 320 && native_mode
->vdisplay
>= 240)
1278 ret
= connector_status_connected
;
1280 /* eDP is always DP */
1281 radeon_dig_connector
->dp_sink_type
= CONNECTOR_OBJECT_ID_DISPLAYPORT
;
1282 if (!radeon_dig_connector
->edp_on
)
1283 atombios_set_edp_panel_power(connector
,
1284 ATOM_TRANSMITTER_ACTION_POWER_ON
);
1285 if (radeon_dp_getdpcd(radeon_connector
))
1286 ret
= connector_status_connected
;
1287 if (!radeon_dig_connector
->edp_on
)
1288 atombios_set_edp_panel_power(connector
,
1289 ATOM_TRANSMITTER_ACTION_POWER_OFF
);
1291 /* need to setup ddc on the bridge */
1292 if (radeon_connector_encoder_is_dp_bridge(connector
)) {
1294 radeon_atom_ext_encoder_setup_ddc(encoder
);
1296 radeon_dig_connector
->dp_sink_type
= radeon_dp_getsinktype(radeon_connector
);
1297 if (radeon_hpd_sense(rdev
, radeon_connector
->hpd
.hpd
)) {
1298 ret
= connector_status_connected
;
1299 if (radeon_dig_connector
->dp_sink_type
== CONNECTOR_OBJECT_ID_DISPLAYPORT
)
1300 radeon_dp_getdpcd(radeon_connector
);
1302 if (radeon_dig_connector
->dp_sink_type
== CONNECTOR_OBJECT_ID_DISPLAYPORT
) {
1303 if (radeon_dp_getdpcd(radeon_connector
))
1304 ret
= connector_status_connected
;
1306 if (radeon_ddc_probe(radeon_connector
,
1307 radeon_connector
->requires_extended_probe
))
1308 ret
= connector_status_connected
;
1312 if ((ret
== connector_status_disconnected
) &&
1313 radeon_connector
->dac_load_detect
) {
1314 struct drm_encoder
*encoder
= radeon_best_single_encoder(connector
);
1315 struct drm_encoder_helper_funcs
*encoder_funcs
;
1317 encoder_funcs
= encoder
->helper_private
;
1318 ret
= encoder_funcs
->detect(encoder
, connector
);
1323 radeon_connector_update_scratch_regs(connector
, ret
);
1327 static int radeon_dp_mode_valid(struct drm_connector
*connector
,
1328 struct drm_display_mode
*mode
)
1330 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1331 struct radeon_connector_atom_dig
*radeon_dig_connector
= radeon_connector
->con_priv
;
1333 /* XXX check mode bandwidth */
1335 if ((connector
->connector_type
== DRM_MODE_CONNECTOR_eDP
) ||
1336 (connector
->connector_type
== DRM_MODE_CONNECTOR_LVDS
)) {
1337 struct drm_encoder
*encoder
= radeon_best_single_encoder(connector
);
1339 if ((mode
->hdisplay
< 320) || (mode
->vdisplay
< 240))
1343 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
1344 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
1346 /* AVIVO hardware supports downscaling modes larger than the panel
1347 * to the panel size, but I'm not sure this is desirable.
1349 if ((mode
->hdisplay
> native_mode
->hdisplay
) ||
1350 (mode
->vdisplay
> native_mode
->vdisplay
))
1353 /* if scaling is disabled, block non-native modes */
1354 if (radeon_encoder
->rmx_type
== RMX_OFF
) {
1355 if ((mode
->hdisplay
!= native_mode
->hdisplay
) ||
1356 (mode
->vdisplay
!= native_mode
->vdisplay
))
1362 if ((radeon_dig_connector
->dp_sink_type
== CONNECTOR_OBJECT_ID_DISPLAYPORT
) ||
1363 (radeon_dig_connector
->dp_sink_type
== CONNECTOR_OBJECT_ID_eDP
))
1364 return radeon_dp_mode_valid_helper(connector
, mode
);
1370 struct drm_connector_helper_funcs radeon_dp_connector_helper_funcs
= {
1371 .get_modes
= radeon_dp_get_modes
,
1372 .mode_valid
= radeon_dp_mode_valid
,
1373 .best_encoder
= radeon_dvi_encoder
,
1376 struct drm_connector_funcs radeon_dp_connector_funcs
= {
1377 .dpms
= drm_helper_connector_dpms
,
1378 .detect
= radeon_dp_detect
,
1379 .fill_modes
= drm_helper_probe_single_connector_modes
,
1380 .set_property
= radeon_connector_set_property
,
1381 .destroy
= radeon_dp_connector_destroy
,
1382 .force
= radeon_dvi_force
,
1386 radeon_add_atom_connector(struct drm_device
*dev
,
1387 uint32_t connector_id
,
1388 uint32_t supported_device
,
1390 struct radeon_i2c_bus_rec
*i2c_bus
,
1391 uint32_t igp_lane_info
,
1392 uint16_t connector_object_id
,
1393 struct radeon_hpd
*hpd
,
1394 struct radeon_router
*router
)
1396 struct radeon_device
*rdev
= dev
->dev_private
;
1397 struct drm_connector
*connector
;
1398 struct radeon_connector
*radeon_connector
;
1399 struct radeon_connector_atom_dig
*radeon_dig_connector
;
1400 struct drm_encoder
*encoder
;
1401 struct radeon_encoder
*radeon_encoder
;
1402 uint32_t subpixel_order
= SubPixelNone
;
1403 bool shared_ddc
= false;
1404 bool is_dp_bridge
= false;
1406 if (connector_type
== DRM_MODE_CONNECTOR_Unknown
)
1409 /* if the user selected tv=0 don't try and add the connector */
1410 if (((connector_type
== DRM_MODE_CONNECTOR_SVIDEO
) ||
1411 (connector_type
== DRM_MODE_CONNECTOR_Composite
) ||
1412 (connector_type
== DRM_MODE_CONNECTOR_9PinDIN
)) &&
1416 /* see if we already added it */
1417 list_for_each_entry(connector
, &dev
->mode_config
.connector_list
, head
) {
1418 radeon_connector
= to_radeon_connector(connector
);
1419 if (radeon_connector
->connector_id
== connector_id
) {
1420 radeon_connector
->devices
|= supported_device
;
1423 if (radeon_connector
->ddc_bus
&& i2c_bus
->valid
) {
1424 if (radeon_connector
->ddc_bus
->rec
.i2c_id
== i2c_bus
->i2c_id
) {
1425 radeon_connector
->shared_ddc
= true;
1428 if (radeon_connector
->router_bus
&& router
->ddc_valid
&&
1429 (radeon_connector
->router
.router_id
== router
->router_id
)) {
1430 radeon_connector
->shared_ddc
= false;
1436 /* check if it's a dp bridge */
1437 list_for_each_entry(encoder
, &dev
->mode_config
.encoder_list
, head
) {
1438 radeon_encoder
= to_radeon_encoder(encoder
);
1439 if (radeon_encoder
->devices
& supported_device
) {
1440 switch (radeon_encoder
->encoder_id
) {
1441 case ENCODER_OBJECT_ID_TRAVIS
:
1442 case ENCODER_OBJECT_ID_NUTMEG
:
1443 is_dp_bridge
= true;
1451 radeon_connector
= kzalloc(sizeof(struct radeon_connector
), GFP_KERNEL
);
1452 if (!radeon_connector
)
1455 connector
= &radeon_connector
->base
;
1457 radeon_connector
->connector_id
= connector_id
;
1458 radeon_connector
->devices
= supported_device
;
1459 radeon_connector
->shared_ddc
= shared_ddc
;
1460 radeon_connector
->connector_object_id
= connector_object_id
;
1461 radeon_connector
->hpd
= *hpd
;
1462 radeon_connector
->requires_extended_probe
=
1463 radeon_connector_needs_extended_probe(rdev
, supported_device
,
1465 radeon_connector
->router
= *router
;
1466 if (router
->ddc_valid
|| router
->cd_valid
) {
1467 radeon_connector
->router_bus
= radeon_i2c_lookup(rdev
, &router
->i2c_info
);
1468 if (!radeon_connector
->router_bus
)
1469 DRM_ERROR("Failed to assign router i2c bus! Check dmesg for i2c errors.\n");
1473 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
1474 if (!radeon_dig_connector
)
1476 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
1477 radeon_connector
->con_priv
= radeon_dig_connector
;
1478 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_dp_connector_funcs
, connector_type
);
1479 drm_connector_helper_add(&radeon_connector
->base
, &radeon_dp_connector_helper_funcs
);
1480 if (i2c_bus
->valid
) {
1481 /* add DP i2c bus */
1482 if (connector_type
== DRM_MODE_CONNECTOR_eDP
)
1483 radeon_dig_connector
->dp_i2c_bus
= radeon_i2c_create_dp(dev
, i2c_bus
, "eDP-auxch");
1485 radeon_dig_connector
->dp_i2c_bus
= radeon_i2c_create_dp(dev
, i2c_bus
, "DP-auxch");
1486 if (!radeon_dig_connector
->dp_i2c_bus
)
1487 DRM_ERROR("DP: Failed to assign dp ddc bus! Check dmesg for i2c errors.\n");
1488 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1489 if (!radeon_connector
->ddc_bus
)
1490 DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1492 switch (connector_type
) {
1493 case DRM_MODE_CONNECTOR_VGA
:
1494 case DRM_MODE_CONNECTOR_DVIA
:
1496 connector
->interlace_allowed
= true;
1497 connector
->doublescan_allowed
= true;
1498 radeon_connector
->dac_load_detect
= true;
1499 drm_connector_attach_property(&radeon_connector
->base
,
1500 rdev
->mode_info
.load_detect_property
,
1503 case DRM_MODE_CONNECTOR_DVII
:
1504 case DRM_MODE_CONNECTOR_DVID
:
1505 case DRM_MODE_CONNECTOR_HDMIA
:
1506 case DRM_MODE_CONNECTOR_HDMIB
:
1507 case DRM_MODE_CONNECTOR_DisplayPort
:
1508 drm_connector_attach_property(&radeon_connector
->base
,
1509 rdev
->mode_info
.underscan_property
,
1511 drm_connector_attach_property(&radeon_connector
->base
,
1512 rdev
->mode_info
.underscan_hborder_property
,
1514 drm_connector_attach_property(&radeon_connector
->base
,
1515 rdev
->mode_info
.underscan_vborder_property
,
1517 subpixel_order
= SubPixelHorizontalRGB
;
1518 connector
->interlace_allowed
= true;
1519 if (connector_type
== DRM_MODE_CONNECTOR_HDMIB
)
1520 connector
->doublescan_allowed
= true;
1522 connector
->doublescan_allowed
= false;
1523 if (connector_type
== DRM_MODE_CONNECTOR_DVII
) {
1524 radeon_connector
->dac_load_detect
= true;
1525 drm_connector_attach_property(&radeon_connector
->base
,
1526 rdev
->mode_info
.load_detect_property
,
1530 case DRM_MODE_CONNECTOR_LVDS
:
1531 case DRM_MODE_CONNECTOR_eDP
:
1532 drm_connector_attach_property(&radeon_connector
->base
,
1533 dev
->mode_config
.scaling_mode_property
,
1534 DRM_MODE_SCALE_FULLSCREEN
);
1535 subpixel_order
= SubPixelHorizontalRGB
;
1536 connector
->interlace_allowed
= false;
1537 connector
->doublescan_allowed
= false;
1541 switch (connector_type
) {
1542 case DRM_MODE_CONNECTOR_VGA
:
1543 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_vga_connector_funcs
, connector_type
);
1544 drm_connector_helper_add(&radeon_connector
->base
, &radeon_vga_connector_helper_funcs
);
1545 if (i2c_bus
->valid
) {
1546 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1547 if (!radeon_connector
->ddc_bus
)
1548 DRM_ERROR("VGA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1550 radeon_connector
->dac_load_detect
= true;
1551 drm_connector_attach_property(&radeon_connector
->base
,
1552 rdev
->mode_info
.load_detect_property
,
1554 /* no HPD on analog connectors */
1555 radeon_connector
->hpd
.hpd
= RADEON_HPD_NONE
;
1556 connector
->polled
= DRM_CONNECTOR_POLL_CONNECT
;
1557 connector
->interlace_allowed
= true;
1558 connector
->doublescan_allowed
= true;
1560 case DRM_MODE_CONNECTOR_DVIA
:
1561 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_vga_connector_funcs
, connector_type
);
1562 drm_connector_helper_add(&radeon_connector
->base
, &radeon_vga_connector_helper_funcs
);
1563 if (i2c_bus
->valid
) {
1564 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1565 if (!radeon_connector
->ddc_bus
)
1566 DRM_ERROR("DVIA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1568 radeon_connector
->dac_load_detect
= true;
1569 drm_connector_attach_property(&radeon_connector
->base
,
1570 rdev
->mode_info
.load_detect_property
,
1572 /* no HPD on analog connectors */
1573 radeon_connector
->hpd
.hpd
= RADEON_HPD_NONE
;
1574 connector
->interlace_allowed
= true;
1575 connector
->doublescan_allowed
= true;
1577 case DRM_MODE_CONNECTOR_DVII
:
1578 case DRM_MODE_CONNECTOR_DVID
:
1579 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
1580 if (!radeon_dig_connector
)
1582 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
1583 radeon_connector
->con_priv
= radeon_dig_connector
;
1584 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_dvi_connector_funcs
, connector_type
);
1585 drm_connector_helper_add(&radeon_connector
->base
, &radeon_dvi_connector_helper_funcs
);
1586 if (i2c_bus
->valid
) {
1587 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1588 if (!radeon_connector
->ddc_bus
)
1589 DRM_ERROR("DVI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1591 subpixel_order
= SubPixelHorizontalRGB
;
1592 drm_connector_attach_property(&radeon_connector
->base
,
1593 rdev
->mode_info
.coherent_mode_property
,
1595 if (ASIC_IS_AVIVO(rdev
)) {
1596 drm_connector_attach_property(&radeon_connector
->base
,
1597 rdev
->mode_info
.underscan_property
,
1599 drm_connector_attach_property(&radeon_connector
->base
,
1600 rdev
->mode_info
.underscan_hborder_property
,
1602 drm_connector_attach_property(&radeon_connector
->base
,
1603 rdev
->mode_info
.underscan_vborder_property
,
1606 if (connector_type
== DRM_MODE_CONNECTOR_DVII
) {
1607 radeon_connector
->dac_load_detect
= true;
1608 drm_connector_attach_property(&radeon_connector
->base
,
1609 rdev
->mode_info
.load_detect_property
,
1612 connector
->interlace_allowed
= true;
1613 if (connector_type
== DRM_MODE_CONNECTOR_DVII
)
1614 connector
->doublescan_allowed
= true;
1616 connector
->doublescan_allowed
= false;
1618 case DRM_MODE_CONNECTOR_HDMIA
:
1619 case DRM_MODE_CONNECTOR_HDMIB
:
1620 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
1621 if (!radeon_dig_connector
)
1623 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
1624 radeon_connector
->con_priv
= radeon_dig_connector
;
1625 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_dvi_connector_funcs
, connector_type
);
1626 drm_connector_helper_add(&radeon_connector
->base
, &radeon_dvi_connector_helper_funcs
);
1627 if (i2c_bus
->valid
) {
1628 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1629 if (!radeon_connector
->ddc_bus
)
1630 DRM_ERROR("HDMI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1632 drm_connector_attach_property(&radeon_connector
->base
,
1633 rdev
->mode_info
.coherent_mode_property
,
1635 if (ASIC_IS_AVIVO(rdev
)) {
1636 drm_connector_attach_property(&radeon_connector
->base
,
1637 rdev
->mode_info
.underscan_property
,
1639 drm_connector_attach_property(&radeon_connector
->base
,
1640 rdev
->mode_info
.underscan_hborder_property
,
1642 drm_connector_attach_property(&radeon_connector
->base
,
1643 rdev
->mode_info
.underscan_vborder_property
,
1646 subpixel_order
= SubPixelHorizontalRGB
;
1647 connector
->interlace_allowed
= true;
1648 if (connector_type
== DRM_MODE_CONNECTOR_HDMIB
)
1649 connector
->doublescan_allowed
= true;
1651 connector
->doublescan_allowed
= false;
1653 case DRM_MODE_CONNECTOR_DisplayPort
:
1654 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
1655 if (!radeon_dig_connector
)
1657 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
1658 radeon_connector
->con_priv
= radeon_dig_connector
;
1659 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_dp_connector_funcs
, connector_type
);
1660 drm_connector_helper_add(&radeon_connector
->base
, &radeon_dp_connector_helper_funcs
);
1661 if (i2c_bus
->valid
) {
1662 /* add DP i2c bus */
1663 radeon_dig_connector
->dp_i2c_bus
= radeon_i2c_create_dp(dev
, i2c_bus
, "DP-auxch");
1664 if (!radeon_dig_connector
->dp_i2c_bus
)
1665 DRM_ERROR("DP: Failed to assign dp ddc bus! Check dmesg for i2c errors.\n");
1666 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1667 if (!radeon_connector
->ddc_bus
)
1668 DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1670 subpixel_order
= SubPixelHorizontalRGB
;
1671 drm_connector_attach_property(&radeon_connector
->base
,
1672 rdev
->mode_info
.coherent_mode_property
,
1674 if (ASIC_IS_AVIVO(rdev
)) {
1675 drm_connector_attach_property(&radeon_connector
->base
,
1676 rdev
->mode_info
.underscan_property
,
1678 drm_connector_attach_property(&radeon_connector
->base
,
1679 rdev
->mode_info
.underscan_hborder_property
,
1681 drm_connector_attach_property(&radeon_connector
->base
,
1682 rdev
->mode_info
.underscan_vborder_property
,
1685 connector
->interlace_allowed
= true;
1686 /* in theory with a DP to VGA converter... */
1687 connector
->doublescan_allowed
= false;
1689 case DRM_MODE_CONNECTOR_eDP
:
1690 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
1691 if (!radeon_dig_connector
)
1693 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
1694 radeon_connector
->con_priv
= radeon_dig_connector
;
1695 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_dp_connector_funcs
, connector_type
);
1696 drm_connector_helper_add(&radeon_connector
->base
, &radeon_dp_connector_helper_funcs
);
1697 if (i2c_bus
->valid
) {
1698 /* add DP i2c bus */
1699 radeon_dig_connector
->dp_i2c_bus
= radeon_i2c_create_dp(dev
, i2c_bus
, "eDP-auxch");
1700 if (!radeon_dig_connector
->dp_i2c_bus
)
1701 DRM_ERROR("DP: Failed to assign dp ddc bus! Check dmesg for i2c errors.\n");
1702 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1703 if (!radeon_connector
->ddc_bus
)
1704 DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1706 drm_connector_attach_property(&radeon_connector
->base
,
1707 dev
->mode_config
.scaling_mode_property
,
1708 DRM_MODE_SCALE_FULLSCREEN
);
1709 subpixel_order
= SubPixelHorizontalRGB
;
1710 connector
->interlace_allowed
= false;
1711 connector
->doublescan_allowed
= false;
1713 case DRM_MODE_CONNECTOR_SVIDEO
:
1714 case DRM_MODE_CONNECTOR_Composite
:
1715 case DRM_MODE_CONNECTOR_9PinDIN
:
1716 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_tv_connector_funcs
, connector_type
);
1717 drm_connector_helper_add(&radeon_connector
->base
, &radeon_tv_connector_helper_funcs
);
1718 radeon_connector
->dac_load_detect
= true;
1719 drm_connector_attach_property(&radeon_connector
->base
,
1720 rdev
->mode_info
.load_detect_property
,
1722 drm_connector_attach_property(&radeon_connector
->base
,
1723 rdev
->mode_info
.tv_std_property
,
1724 radeon_atombios_get_tv_info(rdev
));
1725 /* no HPD on analog connectors */
1726 radeon_connector
->hpd
.hpd
= RADEON_HPD_NONE
;
1727 connector
->interlace_allowed
= false;
1728 connector
->doublescan_allowed
= false;
1730 case DRM_MODE_CONNECTOR_LVDS
:
1731 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
1732 if (!radeon_dig_connector
)
1734 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
1735 radeon_connector
->con_priv
= radeon_dig_connector
;
1736 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_lvds_connector_funcs
, connector_type
);
1737 drm_connector_helper_add(&radeon_connector
->base
, &radeon_lvds_connector_helper_funcs
);
1738 if (i2c_bus
->valid
) {
1739 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1740 if (!radeon_connector
->ddc_bus
)
1741 DRM_ERROR("LVDS: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1743 drm_connector_attach_property(&radeon_connector
->base
,
1744 dev
->mode_config
.scaling_mode_property
,
1745 DRM_MODE_SCALE_FULLSCREEN
);
1746 subpixel_order
= SubPixelHorizontalRGB
;
1747 connector
->interlace_allowed
= false;
1748 connector
->doublescan_allowed
= false;
1753 if (radeon_connector
->hpd
.hpd
== RADEON_HPD_NONE
) {
1755 connector
->polled
= DRM_CONNECTOR_POLL_CONNECT
;
1757 connector
->polled
= DRM_CONNECTOR_POLL_HPD
;
1759 connector
->display_info
.subpixel_order
= subpixel_order
;
1760 drm_sysfs_connector_add(connector
);
1764 drm_connector_cleanup(connector
);
1769 radeon_add_legacy_connector(struct drm_device
*dev
,
1770 uint32_t connector_id
,
1771 uint32_t supported_device
,
1773 struct radeon_i2c_bus_rec
*i2c_bus
,
1774 uint16_t connector_object_id
,
1775 struct radeon_hpd
*hpd
)
1777 struct radeon_device
*rdev
= dev
->dev_private
;
1778 struct drm_connector
*connector
;
1779 struct radeon_connector
*radeon_connector
;
1780 uint32_t subpixel_order
= SubPixelNone
;
1782 if (connector_type
== DRM_MODE_CONNECTOR_Unknown
)
1785 /* if the user selected tv=0 don't try and add the connector */
1786 if (((connector_type
== DRM_MODE_CONNECTOR_SVIDEO
) ||
1787 (connector_type
== DRM_MODE_CONNECTOR_Composite
) ||
1788 (connector_type
== DRM_MODE_CONNECTOR_9PinDIN
)) &&
1792 /* see if we already added it */
1793 list_for_each_entry(connector
, &dev
->mode_config
.connector_list
, head
) {
1794 radeon_connector
= to_radeon_connector(connector
);
1795 if (radeon_connector
->connector_id
== connector_id
) {
1796 radeon_connector
->devices
|= supported_device
;
1801 radeon_connector
= kzalloc(sizeof(struct radeon_connector
), GFP_KERNEL
);
1802 if (!radeon_connector
)
1805 connector
= &radeon_connector
->base
;
1807 radeon_connector
->connector_id
= connector_id
;
1808 radeon_connector
->devices
= supported_device
;
1809 radeon_connector
->connector_object_id
= connector_object_id
;
1810 radeon_connector
->hpd
= *hpd
;
1811 radeon_connector
->requires_extended_probe
=
1812 radeon_connector_needs_extended_probe(rdev
, supported_device
,
1814 switch (connector_type
) {
1815 case DRM_MODE_CONNECTOR_VGA
:
1816 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_vga_connector_funcs
, connector_type
);
1817 drm_connector_helper_add(&radeon_connector
->base
, &radeon_vga_connector_helper_funcs
);
1818 if (i2c_bus
->valid
) {
1819 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1820 if (!radeon_connector
->ddc_bus
)
1821 DRM_ERROR("VGA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1823 radeon_connector
->dac_load_detect
= true;
1824 drm_connector_attach_property(&radeon_connector
->base
,
1825 rdev
->mode_info
.load_detect_property
,
1827 /* no HPD on analog connectors */
1828 radeon_connector
->hpd
.hpd
= RADEON_HPD_NONE
;
1829 connector
->polled
= DRM_CONNECTOR_POLL_CONNECT
;
1830 connector
->interlace_allowed
= true;
1831 connector
->doublescan_allowed
= true;
1833 case DRM_MODE_CONNECTOR_DVIA
:
1834 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_vga_connector_funcs
, connector_type
);
1835 drm_connector_helper_add(&radeon_connector
->base
, &radeon_vga_connector_helper_funcs
);
1836 if (i2c_bus
->valid
) {
1837 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1838 if (!radeon_connector
->ddc_bus
)
1839 DRM_ERROR("DVIA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1841 radeon_connector
->dac_load_detect
= true;
1842 drm_connector_attach_property(&radeon_connector
->base
,
1843 rdev
->mode_info
.load_detect_property
,
1845 /* no HPD on analog connectors */
1846 radeon_connector
->hpd
.hpd
= RADEON_HPD_NONE
;
1847 connector
->interlace_allowed
= true;
1848 connector
->doublescan_allowed
= true;
1850 case DRM_MODE_CONNECTOR_DVII
:
1851 case DRM_MODE_CONNECTOR_DVID
:
1852 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_dvi_connector_funcs
, connector_type
);
1853 drm_connector_helper_add(&radeon_connector
->base
, &radeon_dvi_connector_helper_funcs
);
1854 if (i2c_bus
->valid
) {
1855 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1856 if (!radeon_connector
->ddc_bus
)
1857 DRM_ERROR("DVI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1859 if (connector_type
== DRM_MODE_CONNECTOR_DVII
) {
1860 radeon_connector
->dac_load_detect
= true;
1861 drm_connector_attach_property(&radeon_connector
->base
,
1862 rdev
->mode_info
.load_detect_property
,
1865 subpixel_order
= SubPixelHorizontalRGB
;
1866 connector
->interlace_allowed
= true;
1867 if (connector_type
== DRM_MODE_CONNECTOR_DVII
)
1868 connector
->doublescan_allowed
= true;
1870 connector
->doublescan_allowed
= false;
1872 case DRM_MODE_CONNECTOR_SVIDEO
:
1873 case DRM_MODE_CONNECTOR_Composite
:
1874 case DRM_MODE_CONNECTOR_9PinDIN
:
1875 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_tv_connector_funcs
, connector_type
);
1876 drm_connector_helper_add(&radeon_connector
->base
, &radeon_tv_connector_helper_funcs
);
1877 radeon_connector
->dac_load_detect
= true;
1878 /* RS400,RC410,RS480 chipset seems to report a lot
1879 * of false positive on load detect, we haven't yet
1880 * found a way to make load detect reliable on those
1881 * chipset, thus just disable it for TV.
1883 if (rdev
->family
== CHIP_RS400
|| rdev
->family
== CHIP_RS480
)
1884 radeon_connector
->dac_load_detect
= false;
1885 drm_connector_attach_property(&radeon_connector
->base
,
1886 rdev
->mode_info
.load_detect_property
,
1887 radeon_connector
->dac_load_detect
);
1888 drm_connector_attach_property(&radeon_connector
->base
,
1889 rdev
->mode_info
.tv_std_property
,
1890 radeon_combios_get_tv_info(rdev
));
1891 /* no HPD on analog connectors */
1892 radeon_connector
->hpd
.hpd
= RADEON_HPD_NONE
;
1893 connector
->interlace_allowed
= false;
1894 connector
->doublescan_allowed
= false;
1896 case DRM_MODE_CONNECTOR_LVDS
:
1897 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_lvds_connector_funcs
, connector_type
);
1898 drm_connector_helper_add(&radeon_connector
->base
, &radeon_lvds_connector_helper_funcs
);
1899 if (i2c_bus
->valid
) {
1900 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1901 if (!radeon_connector
->ddc_bus
)
1902 DRM_ERROR("LVDS: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1904 drm_connector_attach_property(&radeon_connector
->base
,
1905 dev
->mode_config
.scaling_mode_property
,
1906 DRM_MODE_SCALE_FULLSCREEN
);
1907 subpixel_order
= SubPixelHorizontalRGB
;
1908 connector
->interlace_allowed
= false;
1909 connector
->doublescan_allowed
= false;
1913 if (radeon_connector
->hpd
.hpd
== RADEON_HPD_NONE
) {
1915 connector
->polled
= DRM_CONNECTOR_POLL_CONNECT
;
1917 connector
->polled
= DRM_CONNECTOR_POLL_HPD
;
1918 connector
->display_info
.subpixel_order
= subpixel_order
;
1919 drm_sysfs_connector_add(connector
);
1920 if (connector_type
== DRM_MODE_CONNECTOR_LVDS
) {
1921 struct drm_encoder
*drm_encoder
;
1923 list_for_each_entry(drm_encoder
, &dev
->mode_config
.encoder_list
, head
) {
1924 struct radeon_encoder
*radeon_encoder
;
1926 radeon_encoder
= to_radeon_encoder(drm_encoder
);
1927 if (radeon_encoder
->encoder_id
== ENCODER_OBJECT_ID_INTERNAL_LVDS
)
1928 radeon_legacy_backlight_init(radeon_encoder
, connector
);