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
,
43 static void radeon_property_change_mode(struct drm_encoder
*encoder
)
45 struct drm_crtc
*crtc
= encoder
->crtc
;
47 if (crtc
&& crtc
->enabled
) {
48 drm_crtc_helper_set_mode(crtc
, &crtc
->mode
,
49 crtc
->x
, crtc
->y
, crtc
->fb
);
53 radeon_connector_update_scratch_regs(struct drm_connector
*connector
, enum drm_connector_status status
)
55 struct drm_device
*dev
= connector
->dev
;
56 struct radeon_device
*rdev
= dev
->dev_private
;
57 struct drm_encoder
*best_encoder
= NULL
;
58 struct drm_encoder
*encoder
= NULL
;
59 struct drm_connector_helper_funcs
*connector_funcs
= connector
->helper_private
;
60 struct drm_mode_object
*obj
;
64 best_encoder
= connector_funcs
->best_encoder(connector
);
66 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
67 if (connector
->encoder_ids
[i
] == 0)
70 obj
= drm_mode_object_find(connector
->dev
,
71 connector
->encoder_ids
[i
],
72 DRM_MODE_OBJECT_ENCODER
);
76 encoder
= obj_to_encoder(obj
);
78 if ((encoder
== best_encoder
) && (status
== connector_status_connected
))
83 if (rdev
->is_atom_bios
)
84 radeon_atombios_connected_scratch_regs(connector
, encoder
, connected
);
86 radeon_combios_connected_scratch_regs(connector
, encoder
, connected
);
91 struct drm_encoder
*radeon_find_encoder(struct drm_connector
*connector
, int encoder_type
)
93 struct drm_mode_object
*obj
;
94 struct drm_encoder
*encoder
;
97 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
98 if (connector
->encoder_ids
[i
] == 0)
101 obj
= drm_mode_object_find(connector
->dev
, connector
->encoder_ids
[i
], DRM_MODE_OBJECT_ENCODER
);
105 encoder
= obj_to_encoder(obj
);
106 if (encoder
->encoder_type
== encoder_type
)
112 struct drm_encoder
*radeon_best_single_encoder(struct drm_connector
*connector
)
114 int enc_id
= connector
->encoder_ids
[0];
115 struct drm_mode_object
*obj
;
116 struct drm_encoder
*encoder
;
118 /* pick the encoder ids */
120 obj
= drm_mode_object_find(connector
->dev
, enc_id
, DRM_MODE_OBJECT_ENCODER
);
123 encoder
= obj_to_encoder(obj
);
130 * radeon_connector_analog_encoder_conflict_solve
131 * - search for other connectors sharing this encoder
132 * if priority is true, then set them disconnected if this is connected
133 * if priority is false, set us disconnected if they are connected
135 static enum drm_connector_status
136 radeon_connector_analog_encoder_conflict_solve(struct drm_connector
*connector
,
137 struct drm_encoder
*encoder
,
138 enum drm_connector_status current_status
,
141 struct drm_device
*dev
= connector
->dev
;
142 struct drm_connector
*conflict
;
145 list_for_each_entry(conflict
, &dev
->mode_config
.connector_list
, head
) {
146 if (conflict
== connector
)
149 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
150 if (conflict
->encoder_ids
[i
] == 0)
153 /* if the IDs match */
154 if (conflict
->encoder_ids
[i
] == encoder
->base
.id
) {
155 if (conflict
->status
!= connector_status_connected
)
158 if (priority
== true) {
159 DRM_INFO("1: conflicting encoders switching off %s\n", drm_get_connector_name(conflict
));
160 DRM_INFO("in favor of %s\n", drm_get_connector_name(connector
));
161 conflict
->status
= connector_status_disconnected
;
162 radeon_connector_update_scratch_regs(conflict
, connector_status_disconnected
);
164 DRM_INFO("2: conflicting encoders switching off %s\n", drm_get_connector_name(connector
));
165 DRM_INFO("in favor of %s\n", drm_get_connector_name(conflict
));
166 current_status
= connector_status_disconnected
;
172 return current_status
;
176 static struct drm_display_mode
*radeon_fp_native_mode(struct drm_encoder
*encoder
)
178 struct drm_device
*dev
= encoder
->dev
;
179 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
180 struct drm_display_mode
*mode
= NULL
;
181 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
183 if (native_mode
->hdisplay
!= 0 &&
184 native_mode
->vdisplay
!= 0 &&
185 native_mode
->clock
!= 0) {
186 mode
= drm_mode_duplicate(dev
, native_mode
);
187 mode
->type
= DRM_MODE_TYPE_PREFERRED
| DRM_MODE_TYPE_DRIVER
;
188 drm_mode_set_name(mode
);
190 DRM_DEBUG("Adding native panel mode %s\n", mode
->name
);
195 static void radeon_add_common_modes(struct drm_encoder
*encoder
, struct drm_connector
*connector
)
197 struct drm_device
*dev
= encoder
->dev
;
198 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
199 struct drm_display_mode
*mode
= NULL
;
200 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
205 } common_modes
[17] = {
225 for (i
= 0; i
< 17; i
++) {
226 if (radeon_encoder
->devices
& (ATOM_DEVICE_TV_SUPPORT
)) {
227 if (common_modes
[i
].w
> 1024 ||
228 common_modes
[i
].h
> 768)
231 if (radeon_encoder
->devices
& (ATOM_DEVICE_LCD_SUPPORT
)) {
232 if (common_modes
[i
].w
> native_mode
->hdisplay
||
233 common_modes
[i
].h
> native_mode
->vdisplay
||
234 (common_modes
[i
].w
== native_mode
->hdisplay
&&
235 common_modes
[i
].h
== native_mode
->vdisplay
))
238 if (common_modes
[i
].w
< 320 || common_modes
[i
].h
< 200)
241 mode
= drm_cvt_mode(dev
, common_modes
[i
].w
, common_modes
[i
].h
, 60, false, false, false);
242 drm_mode_probed_add(connector
, mode
);
246 int radeon_connector_set_property(struct drm_connector
*connector
, struct drm_property
*property
,
249 struct drm_device
*dev
= connector
->dev
;
250 struct radeon_device
*rdev
= dev
->dev_private
;
251 struct drm_encoder
*encoder
;
252 struct radeon_encoder
*radeon_encoder
;
254 if (property
== rdev
->mode_info
.coherent_mode_property
) {
255 struct radeon_encoder_atom_dig
*dig
;
257 /* need to find digital encoder on connector */
258 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TMDS
);
262 radeon_encoder
= to_radeon_encoder(encoder
);
264 if (!radeon_encoder
->enc_priv
)
267 dig
= radeon_encoder
->enc_priv
;
268 dig
->coherent_mode
= val
? true : false;
269 radeon_property_change_mode(&radeon_encoder
->base
);
272 if (property
== rdev
->mode_info
.tv_std_property
) {
273 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TVDAC
);
275 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_DAC
);
281 radeon_encoder
= to_radeon_encoder(encoder
);
282 if (!radeon_encoder
->enc_priv
)
284 if (rdev
->is_atom_bios
) {
285 struct radeon_encoder_atom_dac
*dac_int
;
286 dac_int
= radeon_encoder
->enc_priv
;
287 dac_int
->tv_std
= val
;
289 struct radeon_encoder_tv_dac
*dac_int
;
290 dac_int
= radeon_encoder
->enc_priv
;
291 dac_int
->tv_std
= val
;
293 radeon_property_change_mode(&radeon_encoder
->base
);
296 if (property
== rdev
->mode_info
.load_detect_property
) {
297 struct radeon_connector
*radeon_connector
=
298 to_radeon_connector(connector
);
301 radeon_connector
->dac_load_detect
= false;
303 radeon_connector
->dac_load_detect
= true;
306 if (property
== rdev
->mode_info
.tmds_pll_property
) {
307 struct radeon_encoder_int_tmds
*tmds
= NULL
;
309 /* need to find digital encoder on connector */
310 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TMDS
);
314 radeon_encoder
= to_radeon_encoder(encoder
);
316 tmds
= radeon_encoder
->enc_priv
;
321 if (rdev
->is_atom_bios
)
322 ret
= radeon_atombios_get_tmds_info(radeon_encoder
, tmds
);
324 ret
= radeon_legacy_get_tmds_info_from_combios(radeon_encoder
, tmds
);
326 if (val
== 1 || ret
== false) {
327 radeon_legacy_get_tmds_info_from_table(radeon_encoder
, tmds
);
329 radeon_property_change_mode(&radeon_encoder
->base
);
335 static void radeon_fixup_lvds_native_mode(struct drm_encoder
*encoder
,
336 struct drm_connector
*connector
)
338 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
339 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
341 /* Try to get native mode details from EDID if necessary */
342 if (!native_mode
->clock
) {
343 struct drm_display_mode
*t
, *mode
;
345 list_for_each_entry_safe(mode
, t
, &connector
->probed_modes
, head
) {
346 if (mode
->hdisplay
== native_mode
->hdisplay
&&
347 mode
->vdisplay
== native_mode
->vdisplay
) {
348 *native_mode
= *mode
;
349 drm_mode_set_crtcinfo(native_mode
, CRTC_INTERLACE_HALVE_V
);
350 DRM_INFO("Determined LVDS native mode details from EDID\n");
355 if (!native_mode
->clock
) {
356 DRM_INFO("No LVDS native mode details, disabling RMX\n");
357 radeon_encoder
->rmx_type
= RMX_OFF
;
361 static int radeon_lvds_get_modes(struct drm_connector
*connector
)
363 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
364 struct drm_encoder
*encoder
;
366 struct drm_display_mode
*mode
;
368 if (radeon_connector
->ddc_bus
) {
369 ret
= radeon_ddc_get_modes(radeon_connector
);
371 encoder
= radeon_best_single_encoder(connector
);
373 radeon_fixup_lvds_native_mode(encoder
, connector
);
374 /* add scaled modes */
375 radeon_add_common_modes(encoder
, connector
);
381 encoder
= radeon_best_single_encoder(connector
);
385 /* we have no EDID modes */
386 mode
= radeon_fp_native_mode(encoder
);
389 drm_mode_probed_add(connector
, mode
);
390 /* add scaled modes */
391 radeon_add_common_modes(encoder
, connector
);
397 static int radeon_lvds_mode_valid(struct drm_connector
*connector
,
398 struct drm_display_mode
*mode
)
400 struct drm_encoder
*encoder
= radeon_best_single_encoder(connector
);
402 if ((mode
->hdisplay
< 320) || (mode
->vdisplay
< 240))
406 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
407 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
409 /* AVIVO hardware supports downscaling modes larger than the panel
410 * to the panel size, but I'm not sure this is desirable.
412 if ((mode
->hdisplay
> native_mode
->hdisplay
) ||
413 (mode
->vdisplay
> native_mode
->vdisplay
))
416 /* if scaling is disabled, block non-native modes */
417 if (radeon_encoder
->rmx_type
== RMX_OFF
) {
418 if ((mode
->hdisplay
!= native_mode
->hdisplay
) ||
419 (mode
->vdisplay
!= native_mode
->vdisplay
))
427 static enum drm_connector_status
radeon_lvds_detect(struct drm_connector
*connector
)
429 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
430 struct drm_encoder
*encoder
= radeon_best_single_encoder(connector
);
431 enum drm_connector_status ret
= connector_status_disconnected
;
434 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
435 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
437 /* check if panel is valid */
438 if (native_mode
->hdisplay
>= 320 && native_mode
->vdisplay
>= 240)
439 ret
= connector_status_connected
;
443 /* check for edid as well */
444 if (radeon_connector
->edid
)
445 ret
= connector_status_connected
;
447 if (radeon_connector
->ddc_bus
) {
448 radeon_i2c_do_lock(radeon_connector
->ddc_bus
, 1);
449 radeon_connector
->edid
= drm_get_edid(&radeon_connector
->base
,
450 &radeon_connector
->ddc_bus
->adapter
);
451 radeon_i2c_do_lock(radeon_connector
->ddc_bus
, 0);
452 if (radeon_connector
->edid
)
453 ret
= connector_status_connected
;
456 /* check acpi lid status ??? */
458 radeon_connector_update_scratch_regs(connector
, ret
);
462 static void radeon_connector_destroy(struct drm_connector
*connector
)
464 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
466 if (radeon_connector
->ddc_bus
)
467 radeon_i2c_destroy(radeon_connector
->ddc_bus
);
468 if (radeon_connector
->edid
)
469 kfree(radeon_connector
->edid
);
470 kfree(radeon_connector
->con_priv
);
471 drm_sysfs_connector_remove(connector
);
472 drm_connector_cleanup(connector
);
476 static int radeon_lvds_set_property(struct drm_connector
*connector
,
477 struct drm_property
*property
,
480 struct drm_device
*dev
= connector
->dev
;
481 struct radeon_encoder
*radeon_encoder
;
482 enum radeon_rmx_type rmx_type
;
485 if (property
!= dev
->mode_config
.scaling_mode_property
)
488 if (connector
->encoder
)
489 radeon_encoder
= to_radeon_encoder(connector
->encoder
);
491 struct drm_connector_helper_funcs
*connector_funcs
= connector
->helper_private
;
492 radeon_encoder
= to_radeon_encoder(connector_funcs
->best_encoder(connector
));
496 case DRM_MODE_SCALE_NONE
: rmx_type
= RMX_OFF
; break;
497 case DRM_MODE_SCALE_CENTER
: rmx_type
= RMX_CENTER
; break;
498 case DRM_MODE_SCALE_ASPECT
: rmx_type
= RMX_ASPECT
; break;
500 case DRM_MODE_SCALE_FULLSCREEN
: rmx_type
= RMX_FULL
; break;
502 if (radeon_encoder
->rmx_type
== rmx_type
)
505 radeon_encoder
->rmx_type
= rmx_type
;
507 radeon_property_change_mode(&radeon_encoder
->base
);
512 struct drm_connector_helper_funcs radeon_lvds_connector_helper_funcs
= {
513 .get_modes
= radeon_lvds_get_modes
,
514 .mode_valid
= radeon_lvds_mode_valid
,
515 .best_encoder
= radeon_best_single_encoder
,
518 struct drm_connector_funcs radeon_lvds_connector_funcs
= {
519 .dpms
= drm_helper_connector_dpms
,
520 .detect
= radeon_lvds_detect
,
521 .fill_modes
= drm_helper_probe_single_connector_modes
,
522 .destroy
= radeon_connector_destroy
,
523 .set_property
= radeon_lvds_set_property
,
526 static int radeon_vga_get_modes(struct drm_connector
*connector
)
528 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
531 ret
= radeon_ddc_get_modes(radeon_connector
);
536 static int radeon_vga_mode_valid(struct drm_connector
*connector
,
537 struct drm_display_mode
*mode
)
539 /* XXX check mode bandwidth */
540 /* XXX verify against max DAC output frequency */
544 static enum drm_connector_status
radeon_vga_detect(struct drm_connector
*connector
)
546 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
547 struct drm_encoder
*encoder
;
548 struct drm_encoder_helper_funcs
*encoder_funcs
;
550 enum drm_connector_status ret
= connector_status_disconnected
;
552 encoder
= radeon_best_single_encoder(connector
);
554 ret
= connector_status_disconnected
;
556 radeon_i2c_do_lock(radeon_connector
->ddc_bus
, 1);
557 dret
= radeon_ddc_probe(radeon_connector
);
558 radeon_i2c_do_lock(radeon_connector
->ddc_bus
, 0);
560 if (radeon_connector
->edid
) {
561 kfree(radeon_connector
->edid
);
562 radeon_connector
->edid
= NULL
;
564 radeon_i2c_do_lock(radeon_connector
->ddc_bus
, 1);
565 radeon_connector
->edid
= drm_get_edid(&radeon_connector
->base
, &radeon_connector
->ddc_bus
->adapter
);
566 radeon_i2c_do_lock(radeon_connector
->ddc_bus
, 0);
568 if (!radeon_connector
->edid
) {
569 DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
570 drm_get_connector_name(connector
));
571 ret
= connector_status_connected
;
573 radeon_connector
->use_digital
= !!(radeon_connector
->edid
->input
& DRM_EDID_INPUT_DIGITAL
);
575 /* some oems have boards with separate digital and analog connectors
576 * with a shared ddc line (often vga + hdmi)
578 if (radeon_connector
->use_digital
&& radeon_connector
->shared_ddc
) {
579 kfree(radeon_connector
->edid
);
580 radeon_connector
->edid
= NULL
;
581 ret
= connector_status_disconnected
;
583 ret
= connector_status_connected
;
586 if (radeon_connector
->dac_load_detect
) {
587 encoder_funcs
= encoder
->helper_private
;
588 ret
= encoder_funcs
->detect(encoder
, connector
);
592 if (ret
== connector_status_connected
)
593 ret
= radeon_connector_analog_encoder_conflict_solve(connector
, encoder
, ret
, true);
594 radeon_connector_update_scratch_regs(connector
, ret
);
598 struct drm_connector_helper_funcs radeon_vga_connector_helper_funcs
= {
599 .get_modes
= radeon_vga_get_modes
,
600 .mode_valid
= radeon_vga_mode_valid
,
601 .best_encoder
= radeon_best_single_encoder
,
604 struct drm_connector_funcs radeon_vga_connector_funcs
= {
605 .dpms
= drm_helper_connector_dpms
,
606 .detect
= radeon_vga_detect
,
607 .fill_modes
= drm_helper_probe_single_connector_modes
,
608 .destroy
= radeon_connector_destroy
,
609 .set_property
= radeon_connector_set_property
,
612 static int radeon_tv_get_modes(struct drm_connector
*connector
)
614 struct drm_device
*dev
= connector
->dev
;
615 struct radeon_device
*rdev
= dev
->dev_private
;
616 struct drm_display_mode
*tv_mode
;
617 struct drm_encoder
*encoder
;
619 encoder
= radeon_best_single_encoder(connector
);
623 /* avivo chips can scale any mode */
624 if (rdev
->family
>= CHIP_RS600
)
625 /* add scaled modes */
626 radeon_add_common_modes(encoder
, connector
);
628 /* only 800x600 is supported right now on pre-avivo chips */
629 tv_mode
= drm_cvt_mode(dev
, 800, 600, 60, false, false, false);
630 tv_mode
->type
= DRM_MODE_TYPE_DRIVER
| DRM_MODE_TYPE_PREFERRED
;
631 drm_mode_probed_add(connector
, tv_mode
);
636 static int radeon_tv_mode_valid(struct drm_connector
*connector
,
637 struct drm_display_mode
*mode
)
639 if ((mode
->hdisplay
> 1024) || (mode
->vdisplay
> 768))
640 return MODE_CLOCK_RANGE
;
644 static enum drm_connector_status
radeon_tv_detect(struct drm_connector
*connector
)
646 struct drm_encoder
*encoder
;
647 struct drm_encoder_helper_funcs
*encoder_funcs
;
648 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
649 enum drm_connector_status ret
= connector_status_disconnected
;
651 if (!radeon_connector
->dac_load_detect
)
654 encoder
= radeon_best_single_encoder(connector
);
656 ret
= connector_status_disconnected
;
658 encoder_funcs
= encoder
->helper_private
;
659 ret
= encoder_funcs
->detect(encoder
, connector
);
661 if (ret
== connector_status_connected
)
662 ret
= radeon_connector_analog_encoder_conflict_solve(connector
, encoder
, ret
, false);
663 radeon_connector_update_scratch_regs(connector
, ret
);
667 struct drm_connector_helper_funcs radeon_tv_connector_helper_funcs
= {
668 .get_modes
= radeon_tv_get_modes
,
669 .mode_valid
= radeon_tv_mode_valid
,
670 .best_encoder
= radeon_best_single_encoder
,
673 struct drm_connector_funcs radeon_tv_connector_funcs
= {
674 .dpms
= drm_helper_connector_dpms
,
675 .detect
= radeon_tv_detect
,
676 .fill_modes
= drm_helper_probe_single_connector_modes
,
677 .destroy
= radeon_connector_destroy
,
678 .set_property
= radeon_connector_set_property
,
681 static int radeon_dvi_get_modes(struct drm_connector
*connector
)
683 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
686 ret
= radeon_ddc_get_modes(radeon_connector
);
692 * Do a DDC probe, if DDC probe passes, get the full EDID so
693 * we can do analog/digital monitor detection at this point.
694 * If the monitor is an analog monitor or we got no DDC,
695 * we need to find the DAC encoder object for this connector.
696 * If we got no DDC, we do load detection on the DAC encoder object.
697 * If we got analog DDC or load detection passes on the DAC encoder
698 * we have to check if this analog encoder is shared with anyone else (TV)
699 * if its shared we have to set the other connector to disconnected.
701 static enum drm_connector_status
radeon_dvi_detect(struct drm_connector
*connector
)
703 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
704 struct drm_encoder
*encoder
= NULL
;
705 struct drm_encoder_helper_funcs
*encoder_funcs
;
706 struct drm_mode_object
*obj
;
708 enum drm_connector_status ret
= connector_status_disconnected
;
711 radeon_i2c_do_lock(radeon_connector
->ddc_bus
, 1);
712 dret
= radeon_ddc_probe(radeon_connector
);
713 radeon_i2c_do_lock(radeon_connector
->ddc_bus
, 0);
715 if (radeon_connector
->edid
) {
716 kfree(radeon_connector
->edid
);
717 radeon_connector
->edid
= NULL
;
719 radeon_i2c_do_lock(radeon_connector
->ddc_bus
, 1);
720 radeon_connector
->edid
= drm_get_edid(&radeon_connector
->base
, &radeon_connector
->ddc_bus
->adapter
);
721 radeon_i2c_do_lock(radeon_connector
->ddc_bus
, 0);
723 if (!radeon_connector
->edid
) {
724 DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
725 drm_get_connector_name(connector
));
727 radeon_connector
->use_digital
= !!(radeon_connector
->edid
->input
& DRM_EDID_INPUT_DIGITAL
);
729 /* some oems have boards with separate digital and analog connectors
730 * with a shared ddc line (often vga + hdmi)
732 if ((!radeon_connector
->use_digital
) && radeon_connector
->shared_ddc
) {
733 kfree(radeon_connector
->edid
);
734 radeon_connector
->edid
= NULL
;
735 ret
= connector_status_disconnected
;
737 ret
= connector_status_connected
;
739 /* multiple connectors on the same encoder with the same ddc line
740 * This tends to be HDMI and DVI on the same encoder with the
741 * same ddc line. If the edid says HDMI, consider the HDMI port
742 * connected and the DVI port disconnected. If the edid doesn't
743 * say HDMI, vice versa.
745 if (radeon_connector
->shared_ddc
&& connector_status_connected
) {
746 struct drm_device
*dev
= connector
->dev
;
747 struct drm_connector
*list_connector
;
748 struct radeon_connector
*list_radeon_connector
;
749 list_for_each_entry(list_connector
, &dev
->mode_config
.connector_list
, head
) {
750 if (connector
== list_connector
)
752 list_radeon_connector
= to_radeon_connector(list_connector
);
753 if (radeon_connector
->devices
== list_radeon_connector
->devices
) {
754 if (drm_detect_hdmi_monitor(radeon_connector
->edid
)) {
755 if (connector
->connector_type
== DRM_MODE_CONNECTOR_DVID
) {
756 kfree(radeon_connector
->edid
);
757 radeon_connector
->edid
= NULL
;
758 ret
= connector_status_disconnected
;
761 if ((connector
->connector_type
== DRM_MODE_CONNECTOR_HDMIA
) ||
762 (connector
->connector_type
== DRM_MODE_CONNECTOR_HDMIB
)) {
763 kfree(radeon_connector
->edid
);
764 radeon_connector
->edid
= NULL
;
765 ret
= connector_status_disconnected
;
774 if ((ret
== connector_status_connected
) && (radeon_connector
->use_digital
== true))
777 /* find analog encoder */
778 if (radeon_connector
->dac_load_detect
) {
779 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
780 if (connector
->encoder_ids
[i
] == 0)
783 obj
= drm_mode_object_find(connector
->dev
,
784 connector
->encoder_ids
[i
],
785 DRM_MODE_OBJECT_ENCODER
);
789 encoder
= obj_to_encoder(obj
);
791 encoder_funcs
= encoder
->helper_private
;
792 if (encoder_funcs
->detect
) {
793 if (ret
!= connector_status_connected
) {
794 ret
= encoder_funcs
->detect(encoder
, connector
);
795 if (ret
== connector_status_connected
) {
796 radeon_connector
->use_digital
= false;
804 if ((ret
== connector_status_connected
) && (radeon_connector
->use_digital
== false) &&
806 ret
= radeon_connector_analog_encoder_conflict_solve(connector
, encoder
, ret
, true);
810 /* updated in get modes as well since we need to know if it's analog or digital */
811 radeon_connector_update_scratch_regs(connector
, ret
);
815 /* okay need to be smart in here about which encoder to pick */
816 struct drm_encoder
*radeon_dvi_encoder(struct drm_connector
*connector
)
818 int enc_id
= connector
->encoder_ids
[0];
819 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
820 struct drm_mode_object
*obj
;
821 struct drm_encoder
*encoder
;
823 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
824 if (connector
->encoder_ids
[i
] == 0)
827 obj
= drm_mode_object_find(connector
->dev
, connector
->encoder_ids
[i
], DRM_MODE_OBJECT_ENCODER
);
831 encoder
= obj_to_encoder(obj
);
833 if (radeon_connector
->use_digital
== true) {
834 if (encoder
->encoder_type
== DRM_MODE_ENCODER_TMDS
)
837 if (encoder
->encoder_type
== DRM_MODE_ENCODER_DAC
||
838 encoder
->encoder_type
== DRM_MODE_ENCODER_TVDAC
)
843 /* see if we have a default encoder TODO */
845 /* then check use digitial */
846 /* pick the first one */
848 obj
= drm_mode_object_find(connector
->dev
, enc_id
, DRM_MODE_OBJECT_ENCODER
);
851 encoder
= obj_to_encoder(obj
);
857 static void radeon_dvi_force(struct drm_connector
*connector
)
859 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
860 if (connector
->force
== DRM_FORCE_ON
)
861 radeon_connector
->use_digital
= false;
862 if (connector
->force
== DRM_FORCE_ON_DIGITAL
)
863 radeon_connector
->use_digital
= true;
866 static int radeon_dvi_mode_valid(struct drm_connector
*connector
,
867 struct drm_display_mode
*mode
)
869 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
871 /* XXX check mode bandwidth */
873 if (radeon_connector
->use_digital
&& (mode
->clock
> 165000)) {
874 if ((radeon_connector
->connector_object_id
== CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_I
) ||
875 (radeon_connector
->connector_object_id
== CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_D
) ||
876 (radeon_connector
->connector_object_id
== CONNECTOR_OBJECT_ID_HDMI_TYPE_B
))
879 return MODE_CLOCK_HIGH
;
884 struct drm_connector_helper_funcs radeon_dvi_connector_helper_funcs
= {
885 .get_modes
= radeon_dvi_get_modes
,
886 .mode_valid
= radeon_dvi_mode_valid
,
887 .best_encoder
= radeon_dvi_encoder
,
890 struct drm_connector_funcs radeon_dvi_connector_funcs
= {
891 .dpms
= drm_helper_connector_dpms
,
892 .detect
= radeon_dvi_detect
,
893 .fill_modes
= drm_helper_probe_single_connector_modes
,
894 .set_property
= radeon_connector_set_property
,
895 .destroy
= radeon_connector_destroy
,
896 .force
= radeon_dvi_force
,
899 static int radeon_dp_get_modes(struct drm_connector
*connector
)
901 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
904 ret
= radeon_ddc_get_modes(radeon_connector
);
908 static enum drm_connector_status
radeon_dp_detect(struct drm_connector
*connector
)
910 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
911 struct drm_encoder
*encoder
= NULL
;
912 struct drm_encoder_helper_funcs
*encoder_funcs
;
913 struct drm_mode_object
*obj
;
915 enum drm_connector_status ret
= connector_status_disconnected
;
919 if (radeon_connector
->edid
) {
920 kfree(radeon_connector
->edid
);
921 radeon_connector
->edid
= NULL
;
924 sink_type
= radeon_dp_getsinktype(radeon_connector
);
925 if (sink_type
== CONNECTOR_OBJECT_ID_DISPLAYPORT
) {
926 radeon_dp_getdpcp(radeon_connector
);
927 ret
= connector_status_connected
;
932 struct drm_connector_helper_funcs radeon_dp_connector_helper_funcs
= {
933 .get_modes
= radeon_dp_get_modes
,
934 .mode_valid
= radeon_dvi_mode_valid
,
935 .best_encoder
= radeon_dvi_encoder
,
938 struct drm_connector_funcs radeon_dp_connector_funcs
= {
939 .dpms
= drm_helper_connector_dpms
,
940 .detect
= radeon_dp_detect
,
941 .fill_modes
= drm_helper_probe_single_connector_modes
,
942 .set_property
= radeon_connector_set_property
,
943 .destroy
= radeon_connector_destroy
,
944 .force
= radeon_dvi_force
,
948 radeon_add_atom_connector(struct drm_device
*dev
,
949 uint32_t connector_id
,
950 uint32_t supported_device
,
952 struct radeon_i2c_bus_rec
*i2c_bus
,
954 uint32_t igp_lane_info
,
955 uint16_t connector_object_id
, uint8_t uc_i2c_id
)
957 struct radeon_device
*rdev
= dev
->dev_private
;
958 struct drm_connector
*connector
;
959 struct radeon_connector
*radeon_connector
;
960 struct radeon_connector_atom_dig
*radeon_dig_connector
;
961 uint32_t subpixel_order
= SubPixelNone
;
962 bool shared_ddc
= false;
965 /* fixme - tv/cv/din */
966 if (connector_type
== DRM_MODE_CONNECTOR_Unknown
)
969 /* see if we already added it */
970 list_for_each_entry(connector
, &dev
->mode_config
.connector_list
, head
) {
971 radeon_connector
= to_radeon_connector(connector
);
972 if (radeon_connector
->connector_id
== connector_id
) {
973 radeon_connector
->devices
|= supported_device
;
976 if (radeon_connector
->ddc_bus
&& i2c_bus
->valid
) {
977 if (memcmp(&radeon_connector
->ddc_bus
->rec
, i2c_bus
,
978 sizeof(struct radeon_i2c_bus_rec
)) == 0) {
979 radeon_connector
->shared_ddc
= true;
985 radeon_connector
= kzalloc(sizeof(struct radeon_connector
), GFP_KERNEL
);
986 if (!radeon_connector
)
989 connector
= &radeon_connector
->base
;
991 radeon_connector
->connector_id
= connector_id
;
992 radeon_connector
->devices
= supported_device
;
993 radeon_connector
->shared_ddc
= shared_ddc
;
994 radeon_connector
->connector_object_id
= connector_object_id
;
995 switch (connector_type
) {
996 case DRM_MODE_CONNECTOR_VGA
:
997 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_vga_connector_funcs
, connector_type
);
998 ret
= drm_connector_helper_add(&radeon_connector
->base
, &radeon_vga_connector_helper_funcs
);
1001 if (i2c_bus
->valid
) {
1002 radeon_connector
->ddc_bus
= radeon_i2c_create(dev
, i2c_bus
, "VGA");
1003 if (!radeon_connector
->ddc_bus
)
1006 radeon_connector
->dac_load_detect
= true;
1007 drm_connector_attach_property(&radeon_connector
->base
,
1008 rdev
->mode_info
.load_detect_property
,
1011 case DRM_MODE_CONNECTOR_DVIA
:
1012 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_vga_connector_funcs
, connector_type
);
1013 ret
= drm_connector_helper_add(&radeon_connector
->base
, &radeon_vga_connector_helper_funcs
);
1016 if (i2c_bus
->valid
) {
1017 radeon_connector
->ddc_bus
= radeon_i2c_create(dev
, i2c_bus
, "DVI");
1018 if (!radeon_connector
->ddc_bus
)
1021 radeon_connector
->dac_load_detect
= true;
1022 drm_connector_attach_property(&radeon_connector
->base
,
1023 rdev
->mode_info
.load_detect_property
,
1026 case DRM_MODE_CONNECTOR_DVII
:
1027 case DRM_MODE_CONNECTOR_DVID
:
1028 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
1029 if (!radeon_dig_connector
)
1031 radeon_dig_connector
->linkb
= linkb
;
1032 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
1033 radeon_connector
->con_priv
= radeon_dig_connector
;
1034 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_dvi_connector_funcs
, connector_type
);
1035 ret
= drm_connector_helper_add(&radeon_connector
->base
, &radeon_dvi_connector_helper_funcs
);
1038 if (i2c_bus
->valid
) {
1039 radeon_connector
->ddc_bus
= radeon_i2c_create(dev
, i2c_bus
, "DVI");
1040 if (!radeon_connector
->ddc_bus
)
1043 subpixel_order
= SubPixelHorizontalRGB
;
1044 drm_connector_attach_property(&radeon_connector
->base
,
1045 rdev
->mode_info
.coherent_mode_property
,
1047 radeon_connector
->dac_load_detect
= true;
1048 drm_connector_attach_property(&radeon_connector
->base
,
1049 rdev
->mode_info
.load_detect_property
,
1052 case DRM_MODE_CONNECTOR_HDMIA
:
1053 case DRM_MODE_CONNECTOR_HDMIB
:
1054 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
1055 if (!radeon_dig_connector
)
1057 radeon_dig_connector
->linkb
= linkb
;
1058 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
1059 radeon_connector
->con_priv
= radeon_dig_connector
;
1060 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_dvi_connector_funcs
, connector_type
);
1061 ret
= drm_connector_helper_add(&radeon_connector
->base
, &radeon_dvi_connector_helper_funcs
);
1064 if (i2c_bus
->valid
) {
1065 radeon_connector
->ddc_bus
= radeon_i2c_create(dev
, i2c_bus
, "HDMI");
1066 if (!radeon_connector
->ddc_bus
)
1069 drm_connector_attach_property(&radeon_connector
->base
,
1070 rdev
->mode_info
.coherent_mode_property
,
1072 subpixel_order
= SubPixelHorizontalRGB
;
1074 case DRM_MODE_CONNECTOR_DisplayPort
:
1075 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
1076 if (!radeon_dig_connector
)
1078 radeon_dig_connector
->linkb
= linkb
;
1079 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
1080 radeon_connector
->con_priv
= radeon_dig_connector
;
1081 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_dp_connector_funcs
, connector_type
);
1082 ret
= drm_connector_helper_add(&radeon_connector
->base
, &radeon_dp_connector_helper_funcs
);
1085 /* add DP i2c bus */
1086 radeon_dig_connector
->uc_i2c_id
= uc_i2c_id
;
1087 radeon_dig_connector
->dp_i2c_bus
= radeon_i2c_create_dp(dev
, "DP-auxch", true, uc_i2c_id
);
1088 if (i2c_bus
->valid
) {
1089 radeon_connector
->ddc_bus
= radeon_i2c_create(dev
, i2c_bus
, "DP");
1090 if (!radeon_connector
->ddc_bus
)
1093 subpixel_order
= SubPixelHorizontalRGB
;
1095 case DRM_MODE_CONNECTOR_SVIDEO
:
1096 case DRM_MODE_CONNECTOR_Composite
:
1097 case DRM_MODE_CONNECTOR_9PinDIN
:
1098 if (radeon_tv
== 1) {
1099 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_tv_connector_funcs
, connector_type
);
1100 ret
= drm_connector_helper_add(&radeon_connector
->base
, &radeon_tv_connector_helper_funcs
);
1103 radeon_connector
->dac_load_detect
= true;
1104 drm_connector_attach_property(&radeon_connector
->base
,
1105 rdev
->mode_info
.load_detect_property
,
1107 drm_connector_attach_property(&radeon_connector
->base
,
1108 rdev
->mode_info
.tv_std_property
,
1112 case DRM_MODE_CONNECTOR_LVDS
:
1113 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
1114 if (!radeon_dig_connector
)
1116 radeon_dig_connector
->linkb
= linkb
;
1117 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
1118 radeon_connector
->con_priv
= radeon_dig_connector
;
1119 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_lvds_connector_funcs
, connector_type
);
1120 ret
= drm_connector_helper_add(&radeon_connector
->base
, &radeon_lvds_connector_helper_funcs
);
1123 if (i2c_bus
->valid
) {
1124 radeon_connector
->ddc_bus
= radeon_i2c_create(dev
, i2c_bus
, "LVDS");
1125 if (!radeon_connector
->ddc_bus
)
1128 drm_mode_create_scaling_mode_property(dev
);
1129 drm_connector_attach_property(&radeon_connector
->base
,
1130 dev
->mode_config
.scaling_mode_property
,
1131 DRM_MODE_SCALE_FULLSCREEN
);
1132 subpixel_order
= SubPixelHorizontalRGB
;
1136 connector
->display_info
.subpixel_order
= subpixel_order
;
1137 drm_sysfs_connector_add(connector
);
1141 if (radeon_connector
->ddc_bus
)
1142 radeon_i2c_destroy(radeon_connector
->ddc_bus
);
1143 drm_connector_cleanup(connector
);
1148 radeon_add_legacy_connector(struct drm_device
*dev
,
1149 uint32_t connector_id
,
1150 uint32_t supported_device
,
1152 struct radeon_i2c_bus_rec
*i2c_bus
,
1153 uint16_t connector_object_id
)
1155 struct radeon_device
*rdev
= dev
->dev_private
;
1156 struct drm_connector
*connector
;
1157 struct radeon_connector
*radeon_connector
;
1158 uint32_t subpixel_order
= SubPixelNone
;
1161 /* fixme - tv/cv/din */
1162 if (connector_type
== DRM_MODE_CONNECTOR_Unknown
)
1165 /* see if we already added it */
1166 list_for_each_entry(connector
, &dev
->mode_config
.connector_list
, head
) {
1167 radeon_connector
= to_radeon_connector(connector
);
1168 if (radeon_connector
->connector_id
== connector_id
) {
1169 radeon_connector
->devices
|= supported_device
;
1174 radeon_connector
= kzalloc(sizeof(struct radeon_connector
), GFP_KERNEL
);
1175 if (!radeon_connector
)
1178 connector
= &radeon_connector
->base
;
1180 radeon_connector
->connector_id
= connector_id
;
1181 radeon_connector
->devices
= supported_device
;
1182 radeon_connector
->connector_object_id
= connector_object_id
;
1183 switch (connector_type
) {
1184 case DRM_MODE_CONNECTOR_VGA
:
1185 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_vga_connector_funcs
, connector_type
);
1186 ret
= drm_connector_helper_add(&radeon_connector
->base
, &radeon_vga_connector_helper_funcs
);
1189 if (i2c_bus
->valid
) {
1190 radeon_connector
->ddc_bus
= radeon_i2c_create(dev
, i2c_bus
, "VGA");
1191 if (!radeon_connector
->ddc_bus
)
1194 radeon_connector
->dac_load_detect
= true;
1195 drm_connector_attach_property(&radeon_connector
->base
,
1196 rdev
->mode_info
.load_detect_property
,
1199 case DRM_MODE_CONNECTOR_DVIA
:
1200 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_vga_connector_funcs
, connector_type
);
1201 ret
= drm_connector_helper_add(&radeon_connector
->base
, &radeon_vga_connector_helper_funcs
);
1204 if (i2c_bus
->valid
) {
1205 radeon_connector
->ddc_bus
= radeon_i2c_create(dev
, i2c_bus
, "DVI");
1206 if (!radeon_connector
->ddc_bus
)
1209 radeon_connector
->dac_load_detect
= true;
1210 drm_connector_attach_property(&radeon_connector
->base
,
1211 rdev
->mode_info
.load_detect_property
,
1214 case DRM_MODE_CONNECTOR_DVII
:
1215 case DRM_MODE_CONNECTOR_DVID
:
1216 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_dvi_connector_funcs
, connector_type
);
1217 ret
= drm_connector_helper_add(&radeon_connector
->base
, &radeon_dvi_connector_helper_funcs
);
1220 if (i2c_bus
->valid
) {
1221 radeon_connector
->ddc_bus
= radeon_i2c_create(dev
, i2c_bus
, "DVI");
1222 if (!radeon_connector
->ddc_bus
)
1224 radeon_connector
->dac_load_detect
= true;
1225 drm_connector_attach_property(&radeon_connector
->base
,
1226 rdev
->mode_info
.load_detect_property
,
1229 subpixel_order
= SubPixelHorizontalRGB
;
1231 case DRM_MODE_CONNECTOR_SVIDEO
:
1232 case DRM_MODE_CONNECTOR_Composite
:
1233 case DRM_MODE_CONNECTOR_9PinDIN
:
1234 if (radeon_tv
== 1) {
1235 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_tv_connector_funcs
, connector_type
);
1236 ret
= drm_connector_helper_add(&radeon_connector
->base
, &radeon_tv_connector_helper_funcs
);
1239 radeon_connector
->dac_load_detect
= true;
1240 /* RS400,RC410,RS480 chipset seems to report a lot
1241 * of false positive on load detect, we haven't yet
1242 * found a way to make load detect reliable on those
1243 * chipset, thus just disable it for TV.
1245 if (rdev
->family
== CHIP_RS400
|| rdev
->family
== CHIP_RS480
)
1246 radeon_connector
->dac_load_detect
= false;
1247 drm_connector_attach_property(&radeon_connector
->base
,
1248 rdev
->mode_info
.load_detect_property
,
1250 drm_connector_attach_property(&radeon_connector
->base
,
1251 rdev
->mode_info
.tv_std_property
,
1255 case DRM_MODE_CONNECTOR_LVDS
:
1256 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_lvds_connector_funcs
, connector_type
);
1257 ret
= drm_connector_helper_add(&radeon_connector
->base
, &radeon_lvds_connector_helper_funcs
);
1260 if (i2c_bus
->valid
) {
1261 radeon_connector
->ddc_bus
= radeon_i2c_create(dev
, i2c_bus
, "LVDS");
1262 if (!radeon_connector
->ddc_bus
)
1265 drm_connector_attach_property(&radeon_connector
->base
,
1266 dev
->mode_config
.scaling_mode_property
,
1267 DRM_MODE_SCALE_FULLSCREEN
);
1268 subpixel_order
= SubPixelHorizontalRGB
;
1272 connector
->display_info
.subpixel_order
= subpixel_order
;
1273 drm_sysfs_connector_add(connector
);
1277 if (radeon_connector
->ddc_bus
)
1278 radeon_i2c_destroy(radeon_connector
->ddc_bus
);
1279 drm_connector_cleanup(connector
);