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 void radeon_connector_hotplug(struct drm_connector
*connector
)
45 struct drm_device
*dev
= connector
->dev
;
46 struct radeon_device
*rdev
= dev
->dev_private
;
47 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
49 if (radeon_connector
->hpd
.hpd
!= RADEON_HPD_NONE
)
50 radeon_hpd_set_polarity(rdev
, radeon_connector
->hpd
.hpd
);
52 if ((connector
->connector_type
== DRM_MODE_CONNECTOR_DisplayPort
) ||
53 (connector
->connector_type
== DRM_MODE_CONNECTOR_eDP
)) {
54 if ((radeon_dp_getsinktype(radeon_connector
) == CONNECTOR_OBJECT_ID_DISPLAYPORT
) ||
55 (radeon_dp_getsinktype(radeon_connector
) == CONNECTOR_OBJECT_ID_eDP
)) {
56 if (radeon_dp_needs_link_train(radeon_connector
)) {
57 if (connector
->encoder
)
58 dp_link_train(connector
->encoder
, connector
);
65 static void radeon_property_change_mode(struct drm_encoder
*encoder
)
67 struct drm_crtc
*crtc
= encoder
->crtc
;
69 if (crtc
&& crtc
->enabled
) {
70 drm_crtc_helper_set_mode(crtc
, &crtc
->mode
,
71 crtc
->x
, crtc
->y
, crtc
->fb
);
75 radeon_connector_update_scratch_regs(struct drm_connector
*connector
, enum drm_connector_status status
)
77 struct drm_device
*dev
= connector
->dev
;
78 struct radeon_device
*rdev
= dev
->dev_private
;
79 struct drm_encoder
*best_encoder
= NULL
;
80 struct drm_encoder
*encoder
= NULL
;
81 struct drm_connector_helper_funcs
*connector_funcs
= connector
->helper_private
;
82 struct drm_mode_object
*obj
;
86 best_encoder
= connector_funcs
->best_encoder(connector
);
88 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
89 if (connector
->encoder_ids
[i
] == 0)
92 obj
= drm_mode_object_find(connector
->dev
,
93 connector
->encoder_ids
[i
],
94 DRM_MODE_OBJECT_ENCODER
);
98 encoder
= obj_to_encoder(obj
);
100 if ((encoder
== best_encoder
) && (status
== connector_status_connected
))
105 if (rdev
->is_atom_bios
)
106 radeon_atombios_connected_scratch_regs(connector
, encoder
, connected
);
108 radeon_combios_connected_scratch_regs(connector
, encoder
, connected
);
113 struct drm_encoder
*radeon_find_encoder(struct drm_connector
*connector
, int encoder_type
)
115 struct drm_mode_object
*obj
;
116 struct drm_encoder
*encoder
;
119 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
120 if (connector
->encoder_ids
[i
] == 0)
123 obj
= drm_mode_object_find(connector
->dev
, connector
->encoder_ids
[i
], DRM_MODE_OBJECT_ENCODER
);
127 encoder
= obj_to_encoder(obj
);
128 if (encoder
->encoder_type
== encoder_type
)
134 struct drm_encoder
*radeon_best_single_encoder(struct drm_connector
*connector
)
136 int enc_id
= connector
->encoder_ids
[0];
137 struct drm_mode_object
*obj
;
138 struct drm_encoder
*encoder
;
140 /* pick the encoder ids */
142 obj
= drm_mode_object_find(connector
->dev
, enc_id
, DRM_MODE_OBJECT_ENCODER
);
145 encoder
= obj_to_encoder(obj
);
152 * radeon_connector_analog_encoder_conflict_solve
153 * - search for other connectors sharing this encoder
154 * if priority is true, then set them disconnected if this is connected
155 * if priority is false, set us disconnected if they are connected
157 static enum drm_connector_status
158 radeon_connector_analog_encoder_conflict_solve(struct drm_connector
*connector
,
159 struct drm_encoder
*encoder
,
160 enum drm_connector_status current_status
,
163 struct drm_device
*dev
= connector
->dev
;
164 struct drm_connector
*conflict
;
165 struct radeon_connector
*radeon_conflict
;
168 list_for_each_entry(conflict
, &dev
->mode_config
.connector_list
, head
) {
169 if (conflict
== connector
)
172 radeon_conflict
= to_radeon_connector(conflict
);
173 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
174 if (conflict
->encoder_ids
[i
] == 0)
177 /* if the IDs match */
178 if (conflict
->encoder_ids
[i
] == encoder
->base
.id
) {
179 if (conflict
->status
!= connector_status_connected
)
182 if (radeon_conflict
->use_digital
)
185 if (priority
== true) {
186 DRM_DEBUG_KMS("1: conflicting encoders switching off %s\n", drm_get_connector_name(conflict
));
187 DRM_DEBUG_KMS("in favor of %s\n", drm_get_connector_name(connector
));
188 conflict
->status
= connector_status_disconnected
;
189 radeon_connector_update_scratch_regs(conflict
, connector_status_disconnected
);
191 DRM_DEBUG_KMS("2: conflicting encoders switching off %s\n", drm_get_connector_name(connector
));
192 DRM_DEBUG_KMS("in favor of %s\n", drm_get_connector_name(conflict
));
193 current_status
= connector_status_disconnected
;
199 return current_status
;
203 static struct drm_display_mode
*radeon_fp_native_mode(struct drm_encoder
*encoder
)
205 struct drm_device
*dev
= encoder
->dev
;
206 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
207 struct drm_display_mode
*mode
= NULL
;
208 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
210 if (native_mode
->hdisplay
!= 0 &&
211 native_mode
->vdisplay
!= 0 &&
212 native_mode
->clock
!= 0) {
213 mode
= drm_mode_duplicate(dev
, native_mode
);
214 mode
->type
= DRM_MODE_TYPE_PREFERRED
| DRM_MODE_TYPE_DRIVER
;
215 drm_mode_set_name(mode
);
217 DRM_DEBUG_KMS("Adding native panel mode %s\n", mode
->name
);
218 } else if (native_mode
->hdisplay
!= 0 &&
219 native_mode
->vdisplay
!= 0) {
220 /* mac laptops without an edid */
221 /* Note that this is not necessarily the exact panel mode,
222 * but an approximation based on the cvt formula. For these
223 * systems we should ideally read the mode info out of the
224 * registers or add a mode table, but this works and is much
227 mode
= drm_cvt_mode(dev
, native_mode
->hdisplay
, native_mode
->vdisplay
, 60, true, false, false);
228 mode
->type
= DRM_MODE_TYPE_PREFERRED
| DRM_MODE_TYPE_DRIVER
;
229 DRM_DEBUG_KMS("Adding cvt approximation of native panel mode %s\n", mode
->name
);
234 static void radeon_add_common_modes(struct drm_encoder
*encoder
, struct drm_connector
*connector
)
236 struct drm_device
*dev
= encoder
->dev
;
237 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
238 struct drm_display_mode
*mode
= NULL
;
239 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
244 } common_modes
[17] = {
264 for (i
= 0; i
< 17; i
++) {
265 if (radeon_encoder
->devices
& (ATOM_DEVICE_TV_SUPPORT
)) {
266 if (common_modes
[i
].w
> 1024 ||
267 common_modes
[i
].h
> 768)
270 if (radeon_encoder
->devices
& (ATOM_DEVICE_LCD_SUPPORT
)) {
271 if (common_modes
[i
].w
> native_mode
->hdisplay
||
272 common_modes
[i
].h
> native_mode
->vdisplay
||
273 (common_modes
[i
].w
== native_mode
->hdisplay
&&
274 common_modes
[i
].h
== native_mode
->vdisplay
))
277 if (common_modes
[i
].w
< 320 || common_modes
[i
].h
< 200)
280 mode
= drm_cvt_mode(dev
, common_modes
[i
].w
, common_modes
[i
].h
, 60, false, false, false);
281 drm_mode_probed_add(connector
, mode
);
285 int radeon_connector_set_property(struct drm_connector
*connector
, struct drm_property
*property
,
288 struct drm_device
*dev
= connector
->dev
;
289 struct radeon_device
*rdev
= dev
->dev_private
;
290 struct drm_encoder
*encoder
;
291 struct radeon_encoder
*radeon_encoder
;
293 if (property
== rdev
->mode_info
.coherent_mode_property
) {
294 struct radeon_encoder_atom_dig
*dig
;
295 bool new_coherent_mode
;
297 /* need to find digital encoder on connector */
298 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TMDS
);
302 radeon_encoder
= to_radeon_encoder(encoder
);
304 if (!radeon_encoder
->enc_priv
)
307 dig
= radeon_encoder
->enc_priv
;
308 new_coherent_mode
= val
? true : false;
309 if (dig
->coherent_mode
!= new_coherent_mode
) {
310 dig
->coherent_mode
= new_coherent_mode
;
311 radeon_property_change_mode(&radeon_encoder
->base
);
315 if (property
== rdev
->mode_info
.underscan_property
) {
316 /* need to find digital encoder on connector */
317 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TMDS
);
321 radeon_encoder
= to_radeon_encoder(encoder
);
323 if (radeon_encoder
->underscan_type
!= val
) {
324 radeon_encoder
->underscan_type
= val
;
325 radeon_property_change_mode(&radeon_encoder
->base
);
329 if (property
== rdev
->mode_info
.underscan_hborder_property
) {
330 /* need to find digital encoder on connector */
331 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TMDS
);
335 radeon_encoder
= to_radeon_encoder(encoder
);
337 if (radeon_encoder
->underscan_hborder
!= val
) {
338 radeon_encoder
->underscan_hborder
= val
;
339 radeon_property_change_mode(&radeon_encoder
->base
);
343 if (property
== rdev
->mode_info
.underscan_vborder_property
) {
344 /* need to find digital encoder on connector */
345 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TMDS
);
349 radeon_encoder
= to_radeon_encoder(encoder
);
351 if (radeon_encoder
->underscan_vborder
!= val
) {
352 radeon_encoder
->underscan_vborder
= val
;
353 radeon_property_change_mode(&radeon_encoder
->base
);
357 if (property
== rdev
->mode_info
.tv_std_property
) {
358 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TVDAC
);
360 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_DAC
);
366 radeon_encoder
= to_radeon_encoder(encoder
);
367 if (!radeon_encoder
->enc_priv
)
369 if (ASIC_IS_AVIVO(rdev
) || radeon_r4xx_atom
) {
370 struct radeon_encoder_atom_dac
*dac_int
;
371 dac_int
= radeon_encoder
->enc_priv
;
372 dac_int
->tv_std
= val
;
374 struct radeon_encoder_tv_dac
*dac_int
;
375 dac_int
= radeon_encoder
->enc_priv
;
376 dac_int
->tv_std
= val
;
378 radeon_property_change_mode(&radeon_encoder
->base
);
381 if (property
== rdev
->mode_info
.load_detect_property
) {
382 struct radeon_connector
*radeon_connector
=
383 to_radeon_connector(connector
);
386 radeon_connector
->dac_load_detect
= false;
388 radeon_connector
->dac_load_detect
= true;
391 if (property
== rdev
->mode_info
.tmds_pll_property
) {
392 struct radeon_encoder_int_tmds
*tmds
= NULL
;
394 /* need to find digital encoder on connector */
395 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TMDS
);
399 radeon_encoder
= to_radeon_encoder(encoder
);
401 tmds
= radeon_encoder
->enc_priv
;
406 if (rdev
->is_atom_bios
)
407 ret
= radeon_atombios_get_tmds_info(radeon_encoder
, tmds
);
409 ret
= radeon_legacy_get_tmds_info_from_combios(radeon_encoder
, tmds
);
411 if (val
== 1 || ret
== false) {
412 radeon_legacy_get_tmds_info_from_table(radeon_encoder
, tmds
);
414 radeon_property_change_mode(&radeon_encoder
->base
);
420 static void radeon_fixup_lvds_native_mode(struct drm_encoder
*encoder
,
421 struct drm_connector
*connector
)
423 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
424 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
426 /* Try to get native mode details from EDID if necessary */
427 if (!native_mode
->clock
) {
428 struct drm_display_mode
*t
, *mode
;
430 list_for_each_entry_safe(mode
, t
, &connector
->probed_modes
, head
) {
431 if (mode
->hdisplay
== native_mode
->hdisplay
&&
432 mode
->vdisplay
== native_mode
->vdisplay
) {
433 *native_mode
= *mode
;
434 drm_mode_set_crtcinfo(native_mode
, CRTC_INTERLACE_HALVE_V
);
435 DRM_DEBUG_KMS("Determined LVDS native mode details from EDID\n");
440 if (!native_mode
->clock
) {
441 DRM_DEBUG_KMS("No LVDS native mode details, disabling RMX\n");
442 radeon_encoder
->rmx_type
= RMX_OFF
;
446 static int radeon_lvds_get_modes(struct drm_connector
*connector
)
448 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
449 struct drm_encoder
*encoder
;
451 struct drm_display_mode
*mode
;
453 if (radeon_connector
->ddc_bus
) {
454 ret
= radeon_ddc_get_modes(radeon_connector
);
456 encoder
= radeon_best_single_encoder(connector
);
458 radeon_fixup_lvds_native_mode(encoder
, connector
);
459 /* add scaled modes */
460 radeon_add_common_modes(encoder
, connector
);
466 encoder
= radeon_best_single_encoder(connector
);
470 /* we have no EDID modes */
471 mode
= radeon_fp_native_mode(encoder
);
474 drm_mode_probed_add(connector
, mode
);
475 /* add scaled modes */
476 radeon_add_common_modes(encoder
, connector
);
482 static int radeon_lvds_mode_valid(struct drm_connector
*connector
,
483 struct drm_display_mode
*mode
)
485 struct drm_encoder
*encoder
= radeon_best_single_encoder(connector
);
487 if ((mode
->hdisplay
< 320) || (mode
->vdisplay
< 240))
491 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
492 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
494 /* AVIVO hardware supports downscaling modes larger than the panel
495 * to the panel size, but I'm not sure this is desirable.
497 if ((mode
->hdisplay
> native_mode
->hdisplay
) ||
498 (mode
->vdisplay
> native_mode
->vdisplay
))
501 /* if scaling is disabled, block non-native modes */
502 if (radeon_encoder
->rmx_type
== RMX_OFF
) {
503 if ((mode
->hdisplay
!= native_mode
->hdisplay
) ||
504 (mode
->vdisplay
!= native_mode
->vdisplay
))
512 static enum drm_connector_status
513 radeon_lvds_detect(struct drm_connector
*connector
, bool force
)
515 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
516 struct drm_encoder
*encoder
= radeon_best_single_encoder(connector
);
517 enum drm_connector_status ret
= connector_status_disconnected
;
520 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
521 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
523 /* check if panel is valid */
524 if (native_mode
->hdisplay
>= 320 && native_mode
->vdisplay
>= 240)
525 ret
= connector_status_connected
;
529 /* check for edid as well */
530 if (radeon_connector
->edid
)
531 ret
= connector_status_connected
;
533 if (radeon_connector
->ddc_bus
) {
534 radeon_connector
->edid
= drm_get_edid(&radeon_connector
->base
,
535 &radeon_connector
->ddc_bus
->adapter
);
536 if (radeon_connector
->edid
)
537 ret
= connector_status_connected
;
540 /* check acpi lid status ??? */
542 radeon_connector_update_scratch_regs(connector
, ret
);
546 static void radeon_connector_destroy(struct drm_connector
*connector
)
548 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
550 if (radeon_connector
->edid
)
551 kfree(radeon_connector
->edid
);
552 kfree(radeon_connector
->con_priv
);
553 drm_sysfs_connector_remove(connector
);
554 drm_connector_cleanup(connector
);
558 static int radeon_lvds_set_property(struct drm_connector
*connector
,
559 struct drm_property
*property
,
562 struct drm_device
*dev
= connector
->dev
;
563 struct radeon_encoder
*radeon_encoder
;
564 enum radeon_rmx_type rmx_type
;
567 if (property
!= dev
->mode_config
.scaling_mode_property
)
570 if (connector
->encoder
)
571 radeon_encoder
= to_radeon_encoder(connector
->encoder
);
573 struct drm_connector_helper_funcs
*connector_funcs
= connector
->helper_private
;
574 radeon_encoder
= to_radeon_encoder(connector_funcs
->best_encoder(connector
));
578 case DRM_MODE_SCALE_NONE
: rmx_type
= RMX_OFF
; break;
579 case DRM_MODE_SCALE_CENTER
: rmx_type
= RMX_CENTER
; break;
580 case DRM_MODE_SCALE_ASPECT
: rmx_type
= RMX_ASPECT
; break;
582 case DRM_MODE_SCALE_FULLSCREEN
: rmx_type
= RMX_FULL
; break;
584 if (radeon_encoder
->rmx_type
== rmx_type
)
587 radeon_encoder
->rmx_type
= rmx_type
;
589 radeon_property_change_mode(&radeon_encoder
->base
);
594 struct drm_connector_helper_funcs radeon_lvds_connector_helper_funcs
= {
595 .get_modes
= radeon_lvds_get_modes
,
596 .mode_valid
= radeon_lvds_mode_valid
,
597 .best_encoder
= radeon_best_single_encoder
,
600 struct drm_connector_funcs radeon_lvds_connector_funcs
= {
601 .dpms
= drm_helper_connector_dpms
,
602 .detect
= radeon_lvds_detect
,
603 .fill_modes
= drm_helper_probe_single_connector_modes
,
604 .destroy
= radeon_connector_destroy
,
605 .set_property
= radeon_lvds_set_property
,
608 static int radeon_vga_get_modes(struct drm_connector
*connector
)
610 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
613 ret
= radeon_ddc_get_modes(radeon_connector
);
618 static int radeon_vga_mode_valid(struct drm_connector
*connector
,
619 struct drm_display_mode
*mode
)
621 /* XXX check mode bandwidth */
622 /* XXX verify against max DAC output frequency */
626 static enum drm_connector_status
627 radeon_vga_detect(struct drm_connector
*connector
, bool force
)
629 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
630 struct drm_encoder
*encoder
;
631 struct drm_encoder_helper_funcs
*encoder_funcs
;
633 enum drm_connector_status ret
= connector_status_disconnected
;
635 encoder
= radeon_best_single_encoder(connector
);
637 ret
= connector_status_disconnected
;
639 if (radeon_connector
->ddc_bus
)
640 dret
= radeon_ddc_probe(radeon_connector
);
642 if (radeon_connector
->edid
) {
643 kfree(radeon_connector
->edid
);
644 radeon_connector
->edid
= NULL
;
646 radeon_connector
->edid
= drm_get_edid(&radeon_connector
->base
, &radeon_connector
->ddc_bus
->adapter
);
648 if (!radeon_connector
->edid
) {
649 DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
650 drm_get_connector_name(connector
));
651 ret
= connector_status_connected
;
653 radeon_connector
->use_digital
= !!(radeon_connector
->edid
->input
& DRM_EDID_INPUT_DIGITAL
);
655 /* some oems have boards with separate digital and analog connectors
656 * with a shared ddc line (often vga + hdmi)
658 if (radeon_connector
->use_digital
&& radeon_connector
->shared_ddc
) {
659 kfree(radeon_connector
->edid
);
660 radeon_connector
->edid
= NULL
;
661 ret
= connector_status_disconnected
;
663 ret
= connector_status_connected
;
667 /* if we aren't forcing don't do destructive polling */
669 return connector
->status
;
671 if (radeon_connector
->dac_load_detect
&& encoder
) {
672 encoder_funcs
= encoder
->helper_private
;
673 ret
= encoder_funcs
->detect(encoder
, connector
);
677 if (ret
== connector_status_connected
)
678 ret
= radeon_connector_analog_encoder_conflict_solve(connector
, encoder
, ret
, true);
679 radeon_connector_update_scratch_regs(connector
, ret
);
683 struct drm_connector_helper_funcs radeon_vga_connector_helper_funcs
= {
684 .get_modes
= radeon_vga_get_modes
,
685 .mode_valid
= radeon_vga_mode_valid
,
686 .best_encoder
= radeon_best_single_encoder
,
689 struct drm_connector_funcs radeon_vga_connector_funcs
= {
690 .dpms
= drm_helper_connector_dpms
,
691 .detect
= radeon_vga_detect
,
692 .fill_modes
= drm_helper_probe_single_connector_modes
,
693 .destroy
= radeon_connector_destroy
,
694 .set_property
= radeon_connector_set_property
,
697 static int radeon_tv_get_modes(struct drm_connector
*connector
)
699 struct drm_device
*dev
= connector
->dev
;
700 struct radeon_device
*rdev
= dev
->dev_private
;
701 struct drm_display_mode
*tv_mode
;
702 struct drm_encoder
*encoder
;
704 encoder
= radeon_best_single_encoder(connector
);
708 /* avivo chips can scale any mode */
709 if (rdev
->family
>= CHIP_RS600
)
710 /* add scaled modes */
711 radeon_add_common_modes(encoder
, connector
);
713 /* only 800x600 is supported right now on pre-avivo chips */
714 tv_mode
= drm_cvt_mode(dev
, 800, 600, 60, false, false, false);
715 tv_mode
->type
= DRM_MODE_TYPE_DRIVER
| DRM_MODE_TYPE_PREFERRED
;
716 drm_mode_probed_add(connector
, tv_mode
);
721 static int radeon_tv_mode_valid(struct drm_connector
*connector
,
722 struct drm_display_mode
*mode
)
724 if ((mode
->hdisplay
> 1024) || (mode
->vdisplay
> 768))
725 return MODE_CLOCK_RANGE
;
729 static enum drm_connector_status
730 radeon_tv_detect(struct drm_connector
*connector
, bool force
)
732 struct drm_encoder
*encoder
;
733 struct drm_encoder_helper_funcs
*encoder_funcs
;
734 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
735 enum drm_connector_status ret
= connector_status_disconnected
;
737 if (!radeon_connector
->dac_load_detect
)
740 encoder
= radeon_best_single_encoder(connector
);
742 ret
= connector_status_disconnected
;
744 encoder_funcs
= encoder
->helper_private
;
745 ret
= encoder_funcs
->detect(encoder
, connector
);
747 if (ret
== connector_status_connected
)
748 ret
= radeon_connector_analog_encoder_conflict_solve(connector
, encoder
, ret
, false);
749 radeon_connector_update_scratch_regs(connector
, ret
);
753 struct drm_connector_helper_funcs radeon_tv_connector_helper_funcs
= {
754 .get_modes
= radeon_tv_get_modes
,
755 .mode_valid
= radeon_tv_mode_valid
,
756 .best_encoder
= radeon_best_single_encoder
,
759 struct drm_connector_funcs radeon_tv_connector_funcs
= {
760 .dpms
= drm_helper_connector_dpms
,
761 .detect
= radeon_tv_detect
,
762 .fill_modes
= drm_helper_probe_single_connector_modes
,
763 .destroy
= radeon_connector_destroy
,
764 .set_property
= radeon_connector_set_property
,
767 static int radeon_dvi_get_modes(struct drm_connector
*connector
)
769 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
772 ret
= radeon_ddc_get_modes(radeon_connector
);
778 * Do a DDC probe, if DDC probe passes, get the full EDID so
779 * we can do analog/digital monitor detection at this point.
780 * If the monitor is an analog monitor or we got no DDC,
781 * we need to find the DAC encoder object for this connector.
782 * If we got no DDC, we do load detection on the DAC encoder object.
783 * If we got analog DDC or load detection passes on the DAC encoder
784 * we have to check if this analog encoder is shared with anyone else (TV)
785 * if its shared we have to set the other connector to disconnected.
787 static enum drm_connector_status
788 radeon_dvi_detect(struct drm_connector
*connector
, bool force
)
790 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
791 struct drm_encoder
*encoder
= NULL
;
792 struct drm_encoder_helper_funcs
*encoder_funcs
;
793 struct drm_mode_object
*obj
;
795 enum drm_connector_status ret
= connector_status_disconnected
;
798 if (radeon_connector
->ddc_bus
)
799 dret
= radeon_ddc_probe(radeon_connector
);
801 if (radeon_connector
->edid
) {
802 kfree(radeon_connector
->edid
);
803 radeon_connector
->edid
= NULL
;
805 radeon_connector
->edid
= drm_get_edid(&radeon_connector
->base
, &radeon_connector
->ddc_bus
->adapter
);
807 if (!radeon_connector
->edid
) {
808 DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
809 drm_get_connector_name(connector
));
811 radeon_connector
->use_digital
= !!(radeon_connector
->edid
->input
& DRM_EDID_INPUT_DIGITAL
);
813 /* some oems have boards with separate digital and analog connectors
814 * with a shared ddc line (often vga + hdmi)
816 if ((!radeon_connector
->use_digital
) && radeon_connector
->shared_ddc
) {
817 kfree(radeon_connector
->edid
);
818 radeon_connector
->edid
= NULL
;
819 ret
= connector_status_disconnected
;
821 ret
= connector_status_connected
;
823 /* This gets complicated. We have boards with VGA + HDMI with a
824 * shared DDC line and we have boards with DVI-D + HDMI with a shared
825 * DDC line. The latter is more complex because with DVI<->HDMI adapters
826 * you don't really know what's connected to which port as both are digital.
828 if (radeon_connector
->shared_ddc
&& (ret
== connector_status_connected
)) {
829 struct drm_device
*dev
= connector
->dev
;
830 struct radeon_device
*rdev
= dev
->dev_private
;
831 struct drm_connector
*list_connector
;
832 struct radeon_connector
*list_radeon_connector
;
833 list_for_each_entry(list_connector
, &dev
->mode_config
.connector_list
, head
) {
834 if (connector
== list_connector
)
836 list_radeon_connector
= to_radeon_connector(list_connector
);
837 if (list_radeon_connector
->shared_ddc
&&
838 (list_radeon_connector
->ddc_bus
->rec
.i2c_id
==
839 radeon_connector
->ddc_bus
->rec
.i2c_id
)) {
840 /* cases where both connectors are digital */
841 if (list_connector
->connector_type
!= DRM_MODE_CONNECTOR_VGA
) {
842 /* hpd is our only option in this case */
843 if (!radeon_hpd_sense(rdev
, radeon_connector
->hpd
.hpd
)) {
844 kfree(radeon_connector
->edid
);
845 radeon_connector
->edid
= NULL
;
846 ret
= connector_status_disconnected
;
855 if ((ret
== connector_status_connected
) && (radeon_connector
->use_digital
== true))
859 ret
= connector
->status
;
863 /* find analog encoder */
864 if (radeon_connector
->dac_load_detect
) {
865 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
866 if (connector
->encoder_ids
[i
] == 0)
869 obj
= drm_mode_object_find(connector
->dev
,
870 connector
->encoder_ids
[i
],
871 DRM_MODE_OBJECT_ENCODER
);
875 encoder
= obj_to_encoder(obj
);
877 encoder_funcs
= encoder
->helper_private
;
878 if (encoder_funcs
->detect
) {
879 if (ret
!= connector_status_connected
) {
880 ret
= encoder_funcs
->detect(encoder
, connector
);
881 if (ret
== connector_status_connected
) {
882 radeon_connector
->use_digital
= false;
890 if ((ret
== connector_status_connected
) && (radeon_connector
->use_digital
== false) &&
892 ret
= radeon_connector_analog_encoder_conflict_solve(connector
, encoder
, ret
, true);
896 /* updated in get modes as well since we need to know if it's analog or digital */
897 radeon_connector_update_scratch_regs(connector
, ret
);
901 /* okay need to be smart in here about which encoder to pick */
902 struct drm_encoder
*radeon_dvi_encoder(struct drm_connector
*connector
)
904 int enc_id
= connector
->encoder_ids
[0];
905 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
906 struct drm_mode_object
*obj
;
907 struct drm_encoder
*encoder
;
909 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
910 if (connector
->encoder_ids
[i
] == 0)
913 obj
= drm_mode_object_find(connector
->dev
, connector
->encoder_ids
[i
], DRM_MODE_OBJECT_ENCODER
);
917 encoder
= obj_to_encoder(obj
);
919 if (radeon_connector
->use_digital
== true) {
920 if (encoder
->encoder_type
== DRM_MODE_ENCODER_TMDS
)
923 if (encoder
->encoder_type
== DRM_MODE_ENCODER_DAC
||
924 encoder
->encoder_type
== DRM_MODE_ENCODER_TVDAC
)
929 /* see if we have a default encoder TODO */
931 /* then check use digitial */
932 /* pick the first one */
934 obj
= drm_mode_object_find(connector
->dev
, enc_id
, DRM_MODE_OBJECT_ENCODER
);
937 encoder
= obj_to_encoder(obj
);
943 static void radeon_dvi_force(struct drm_connector
*connector
)
945 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
946 if (connector
->force
== DRM_FORCE_ON
)
947 radeon_connector
->use_digital
= false;
948 if (connector
->force
== DRM_FORCE_ON_DIGITAL
)
949 radeon_connector
->use_digital
= true;
952 static int radeon_dvi_mode_valid(struct drm_connector
*connector
,
953 struct drm_display_mode
*mode
)
955 struct drm_device
*dev
= connector
->dev
;
956 struct radeon_device
*rdev
= dev
->dev_private
;
957 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
959 /* XXX check mode bandwidth */
961 /* clocks over 135 MHz have heat issues with DVI on RV100 */
962 if (radeon_connector
->use_digital
&&
963 (rdev
->family
== CHIP_RV100
) &&
964 (mode
->clock
> 135000))
965 return MODE_CLOCK_HIGH
;
967 if (radeon_connector
->use_digital
&& (mode
->clock
> 165000)) {
968 if ((radeon_connector
->connector_object_id
== CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_I
) ||
969 (radeon_connector
->connector_object_id
== CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_D
) ||
970 (radeon_connector
->connector_object_id
== CONNECTOR_OBJECT_ID_HDMI_TYPE_B
))
973 return MODE_CLOCK_HIGH
;
978 struct drm_connector_helper_funcs radeon_dvi_connector_helper_funcs
= {
979 .get_modes
= radeon_dvi_get_modes
,
980 .mode_valid
= radeon_dvi_mode_valid
,
981 .best_encoder
= radeon_dvi_encoder
,
984 struct drm_connector_funcs radeon_dvi_connector_funcs
= {
985 .dpms
= drm_helper_connector_dpms
,
986 .detect
= radeon_dvi_detect
,
987 .fill_modes
= drm_helper_probe_single_connector_modes
,
988 .set_property
= radeon_connector_set_property
,
989 .destroy
= radeon_connector_destroy
,
990 .force
= radeon_dvi_force
,
993 static void radeon_dp_connector_destroy(struct drm_connector
*connector
)
995 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
996 struct radeon_connector_atom_dig
*radeon_dig_connector
= radeon_connector
->con_priv
;
998 if (radeon_connector
->edid
)
999 kfree(radeon_connector
->edid
);
1000 if (radeon_dig_connector
->dp_i2c_bus
)
1001 radeon_i2c_destroy(radeon_dig_connector
->dp_i2c_bus
);
1002 kfree(radeon_connector
->con_priv
);
1003 drm_sysfs_connector_remove(connector
);
1004 drm_connector_cleanup(connector
);
1008 static int radeon_dp_get_modes(struct drm_connector
*connector
)
1010 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1011 struct radeon_connector_atom_dig
*radeon_dig_connector
= radeon_connector
->con_priv
;
1014 if (connector
->connector_type
== DRM_MODE_CONNECTOR_eDP
) {
1015 if (!radeon_dig_connector
->edp_on
)
1016 atombios_set_edp_panel_power(connector
,
1017 ATOM_TRANSMITTER_ACTION_POWER_ON
);
1019 ret
= radeon_ddc_get_modes(radeon_connector
);
1020 if (connector
->connector_type
== DRM_MODE_CONNECTOR_eDP
) {
1021 if (!radeon_dig_connector
->edp_on
)
1022 atombios_set_edp_panel_power(connector
,
1023 ATOM_TRANSMITTER_ACTION_POWER_OFF
);
1029 static enum drm_connector_status
1030 radeon_dp_detect(struct drm_connector
*connector
, bool force
)
1032 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1033 enum drm_connector_status ret
= connector_status_disconnected
;
1034 struct radeon_connector_atom_dig
*radeon_dig_connector
= radeon_connector
->con_priv
;
1036 if (radeon_connector
->edid
) {
1037 kfree(radeon_connector
->edid
);
1038 radeon_connector
->edid
= NULL
;
1041 if (connector
->connector_type
== DRM_MODE_CONNECTOR_eDP
) {
1042 /* eDP is always DP */
1043 radeon_dig_connector
->dp_sink_type
= CONNECTOR_OBJECT_ID_DISPLAYPORT
;
1044 if (!radeon_dig_connector
->edp_on
)
1045 atombios_set_edp_panel_power(connector
,
1046 ATOM_TRANSMITTER_ACTION_POWER_ON
);
1047 if (radeon_dp_getdpcd(radeon_connector
))
1048 ret
= connector_status_connected
;
1049 if (!radeon_dig_connector
->edp_on
)
1050 atombios_set_edp_panel_power(connector
,
1051 ATOM_TRANSMITTER_ACTION_POWER_OFF
);
1053 radeon_dig_connector
->dp_sink_type
= radeon_dp_getsinktype(radeon_connector
);
1054 if (radeon_dig_connector
->dp_sink_type
== CONNECTOR_OBJECT_ID_DISPLAYPORT
) {
1055 if (radeon_dp_getdpcd(radeon_connector
))
1056 ret
= connector_status_connected
;
1058 if (radeon_ddc_probe(radeon_connector
))
1059 ret
= connector_status_connected
;
1063 radeon_connector_update_scratch_regs(connector
, ret
);
1067 static int radeon_dp_mode_valid(struct drm_connector
*connector
,
1068 struct drm_display_mode
*mode
)
1070 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1071 struct radeon_connector_atom_dig
*radeon_dig_connector
= radeon_connector
->con_priv
;
1073 /* XXX check mode bandwidth */
1075 if ((radeon_dig_connector
->dp_sink_type
== CONNECTOR_OBJECT_ID_DISPLAYPORT
) ||
1076 (radeon_dig_connector
->dp_sink_type
== CONNECTOR_OBJECT_ID_eDP
))
1077 return radeon_dp_mode_valid_helper(radeon_connector
, mode
);
1082 struct drm_connector_helper_funcs radeon_dp_connector_helper_funcs
= {
1083 .get_modes
= radeon_dp_get_modes
,
1084 .mode_valid
= radeon_dp_mode_valid
,
1085 .best_encoder
= radeon_dvi_encoder
,
1088 struct drm_connector_funcs radeon_dp_connector_funcs
= {
1089 .dpms
= drm_helper_connector_dpms
,
1090 .detect
= radeon_dp_detect
,
1091 .fill_modes
= drm_helper_probe_single_connector_modes
,
1092 .set_property
= radeon_connector_set_property
,
1093 .destroy
= radeon_dp_connector_destroy
,
1094 .force
= radeon_dvi_force
,
1098 radeon_add_atom_connector(struct drm_device
*dev
,
1099 uint32_t connector_id
,
1100 uint32_t supported_device
,
1102 struct radeon_i2c_bus_rec
*i2c_bus
,
1103 uint32_t igp_lane_info
,
1104 uint16_t connector_object_id
,
1105 struct radeon_hpd
*hpd
,
1106 struct radeon_router
*router
)
1108 struct radeon_device
*rdev
= dev
->dev_private
;
1109 struct drm_connector
*connector
;
1110 struct radeon_connector
*radeon_connector
;
1111 struct radeon_connector_atom_dig
*radeon_dig_connector
;
1112 uint32_t subpixel_order
= SubPixelNone
;
1113 bool shared_ddc
= false;
1115 if (connector_type
== DRM_MODE_CONNECTOR_Unknown
)
1118 /* if the user selected tv=0 don't try and add the connector */
1119 if (((connector_type
== DRM_MODE_CONNECTOR_SVIDEO
) ||
1120 (connector_type
== DRM_MODE_CONNECTOR_Composite
) ||
1121 (connector_type
== DRM_MODE_CONNECTOR_9PinDIN
)) &&
1125 /* see if we already added it */
1126 list_for_each_entry(connector
, &dev
->mode_config
.connector_list
, head
) {
1127 radeon_connector
= to_radeon_connector(connector
);
1128 if (radeon_connector
->connector_id
== connector_id
) {
1129 radeon_connector
->devices
|= supported_device
;
1132 if (radeon_connector
->ddc_bus
&& i2c_bus
->valid
) {
1133 if (radeon_connector
->ddc_bus
->rec
.i2c_id
== i2c_bus
->i2c_id
) {
1134 radeon_connector
->shared_ddc
= true;
1137 if (radeon_connector
->router_bus
&& router
->ddc_valid
&&
1138 (radeon_connector
->router
.router_id
== router
->router_id
)) {
1139 radeon_connector
->shared_ddc
= false;
1145 radeon_connector
= kzalloc(sizeof(struct radeon_connector
), GFP_KERNEL
);
1146 if (!radeon_connector
)
1149 connector
= &radeon_connector
->base
;
1151 radeon_connector
->connector_id
= connector_id
;
1152 radeon_connector
->devices
= supported_device
;
1153 radeon_connector
->shared_ddc
= shared_ddc
;
1154 radeon_connector
->connector_object_id
= connector_object_id
;
1155 radeon_connector
->hpd
= *hpd
;
1156 radeon_connector
->router
= *router
;
1157 if (router
->ddc_valid
|| router
->cd_valid
) {
1158 radeon_connector
->router_bus
= radeon_i2c_lookup(rdev
, &router
->i2c_info
);
1159 if (!radeon_connector
->router_bus
)
1162 switch (connector_type
) {
1163 case DRM_MODE_CONNECTOR_VGA
:
1164 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_vga_connector_funcs
, connector_type
);
1165 drm_connector_helper_add(&radeon_connector
->base
, &radeon_vga_connector_helper_funcs
);
1166 if (i2c_bus
->valid
) {
1167 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1168 if (!radeon_connector
->ddc_bus
)
1171 radeon_connector
->dac_load_detect
= true;
1172 drm_connector_attach_property(&radeon_connector
->base
,
1173 rdev
->mode_info
.load_detect_property
,
1175 /* no HPD on analog connectors */
1176 radeon_connector
->hpd
.hpd
= RADEON_HPD_NONE
;
1177 connector
->polled
= DRM_CONNECTOR_POLL_CONNECT
;
1178 connector
->interlace_allowed
= true;
1179 connector
->doublescan_allowed
= true;
1181 case DRM_MODE_CONNECTOR_DVIA
:
1182 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_vga_connector_funcs
, connector_type
);
1183 drm_connector_helper_add(&radeon_connector
->base
, &radeon_vga_connector_helper_funcs
);
1184 if (i2c_bus
->valid
) {
1185 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1186 if (!radeon_connector
->ddc_bus
)
1189 radeon_connector
->dac_load_detect
= true;
1190 drm_connector_attach_property(&radeon_connector
->base
,
1191 rdev
->mode_info
.load_detect_property
,
1193 /* no HPD on analog connectors */
1194 radeon_connector
->hpd
.hpd
= RADEON_HPD_NONE
;
1195 connector
->interlace_allowed
= true;
1196 connector
->doublescan_allowed
= true;
1198 case DRM_MODE_CONNECTOR_DVII
:
1199 case DRM_MODE_CONNECTOR_DVID
:
1200 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
1201 if (!radeon_dig_connector
)
1203 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
1204 radeon_connector
->con_priv
= radeon_dig_connector
;
1205 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_dvi_connector_funcs
, connector_type
);
1206 drm_connector_helper_add(&radeon_connector
->base
, &radeon_dvi_connector_helper_funcs
);
1207 if (i2c_bus
->valid
) {
1208 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1209 if (!radeon_connector
->ddc_bus
)
1212 subpixel_order
= SubPixelHorizontalRGB
;
1213 drm_connector_attach_property(&radeon_connector
->base
,
1214 rdev
->mode_info
.coherent_mode_property
,
1216 if (ASIC_IS_AVIVO(rdev
)) {
1217 drm_connector_attach_property(&radeon_connector
->base
,
1218 rdev
->mode_info
.underscan_property
,
1220 drm_connector_attach_property(&radeon_connector
->base
,
1221 rdev
->mode_info
.underscan_hborder_property
,
1223 drm_connector_attach_property(&radeon_connector
->base
,
1224 rdev
->mode_info
.underscan_vborder_property
,
1227 if (connector_type
== DRM_MODE_CONNECTOR_DVII
) {
1228 radeon_connector
->dac_load_detect
= true;
1229 drm_connector_attach_property(&radeon_connector
->base
,
1230 rdev
->mode_info
.load_detect_property
,
1233 connector
->interlace_allowed
= true;
1234 if (connector_type
== DRM_MODE_CONNECTOR_DVII
)
1235 connector
->doublescan_allowed
= true;
1237 connector
->doublescan_allowed
= false;
1239 case DRM_MODE_CONNECTOR_HDMIA
:
1240 case DRM_MODE_CONNECTOR_HDMIB
:
1241 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
1242 if (!radeon_dig_connector
)
1244 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
1245 radeon_connector
->con_priv
= radeon_dig_connector
;
1246 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_dvi_connector_funcs
, connector_type
);
1247 drm_connector_helper_add(&radeon_connector
->base
, &radeon_dvi_connector_helper_funcs
);
1248 if (i2c_bus
->valid
) {
1249 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1250 if (!radeon_connector
->ddc_bus
)
1253 drm_connector_attach_property(&radeon_connector
->base
,
1254 rdev
->mode_info
.coherent_mode_property
,
1256 if (ASIC_IS_AVIVO(rdev
)) {
1257 drm_connector_attach_property(&radeon_connector
->base
,
1258 rdev
->mode_info
.underscan_property
,
1260 drm_connector_attach_property(&radeon_connector
->base
,
1261 rdev
->mode_info
.underscan_hborder_property
,
1263 drm_connector_attach_property(&radeon_connector
->base
,
1264 rdev
->mode_info
.underscan_vborder_property
,
1267 subpixel_order
= SubPixelHorizontalRGB
;
1268 connector
->interlace_allowed
= true;
1269 if (connector_type
== DRM_MODE_CONNECTOR_HDMIB
)
1270 connector
->doublescan_allowed
= true;
1272 connector
->doublescan_allowed
= false;
1274 case DRM_MODE_CONNECTOR_DisplayPort
:
1275 case DRM_MODE_CONNECTOR_eDP
:
1276 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
1277 if (!radeon_dig_connector
)
1279 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
1280 radeon_connector
->con_priv
= radeon_dig_connector
;
1281 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_dp_connector_funcs
, connector_type
);
1282 drm_connector_helper_add(&radeon_connector
->base
, &radeon_dp_connector_helper_funcs
);
1283 if (i2c_bus
->valid
) {
1284 /* add DP i2c bus */
1285 if (connector_type
== DRM_MODE_CONNECTOR_eDP
)
1286 radeon_dig_connector
->dp_i2c_bus
= radeon_i2c_create_dp(dev
, i2c_bus
, "eDP-auxch");
1288 radeon_dig_connector
->dp_i2c_bus
= radeon_i2c_create_dp(dev
, i2c_bus
, "DP-auxch");
1289 if (!radeon_dig_connector
->dp_i2c_bus
)
1291 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1292 if (!radeon_connector
->ddc_bus
)
1295 subpixel_order
= SubPixelHorizontalRGB
;
1296 drm_connector_attach_property(&radeon_connector
->base
,
1297 rdev
->mode_info
.coherent_mode_property
,
1299 if (ASIC_IS_AVIVO(rdev
)) {
1300 drm_connector_attach_property(&radeon_connector
->base
,
1301 rdev
->mode_info
.underscan_property
,
1303 drm_connector_attach_property(&radeon_connector
->base
,
1304 rdev
->mode_info
.underscan_hborder_property
,
1306 drm_connector_attach_property(&radeon_connector
->base
,
1307 rdev
->mode_info
.underscan_vborder_property
,
1310 connector
->interlace_allowed
= true;
1311 /* in theory with a DP to VGA converter... */
1312 connector
->doublescan_allowed
= false;
1314 case DRM_MODE_CONNECTOR_SVIDEO
:
1315 case DRM_MODE_CONNECTOR_Composite
:
1316 case DRM_MODE_CONNECTOR_9PinDIN
:
1317 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_tv_connector_funcs
, connector_type
);
1318 drm_connector_helper_add(&radeon_connector
->base
, &radeon_tv_connector_helper_funcs
);
1319 radeon_connector
->dac_load_detect
= true;
1320 drm_connector_attach_property(&radeon_connector
->base
,
1321 rdev
->mode_info
.load_detect_property
,
1323 drm_connector_attach_property(&radeon_connector
->base
,
1324 rdev
->mode_info
.tv_std_property
,
1325 radeon_atombios_get_tv_info(rdev
));
1326 /* no HPD on analog connectors */
1327 radeon_connector
->hpd
.hpd
= RADEON_HPD_NONE
;
1328 connector
->interlace_allowed
= false;
1329 connector
->doublescan_allowed
= false;
1331 case DRM_MODE_CONNECTOR_LVDS
:
1332 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
1333 if (!radeon_dig_connector
)
1335 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
1336 radeon_connector
->con_priv
= radeon_dig_connector
;
1337 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_lvds_connector_funcs
, connector_type
);
1338 drm_connector_helper_add(&radeon_connector
->base
, &radeon_lvds_connector_helper_funcs
);
1339 if (i2c_bus
->valid
) {
1340 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1341 if (!radeon_connector
->ddc_bus
)
1344 drm_connector_attach_property(&radeon_connector
->base
,
1345 dev
->mode_config
.scaling_mode_property
,
1346 DRM_MODE_SCALE_FULLSCREEN
);
1347 subpixel_order
= SubPixelHorizontalRGB
;
1348 connector
->interlace_allowed
= false;
1349 connector
->doublescan_allowed
= false;
1353 if (radeon_connector
->hpd
.hpd
== RADEON_HPD_NONE
) {
1355 connector
->polled
= DRM_CONNECTOR_POLL_CONNECT
;
1357 connector
->polled
= DRM_CONNECTOR_POLL_HPD
;
1359 connector
->display_info
.subpixel_order
= subpixel_order
;
1360 drm_sysfs_connector_add(connector
);
1364 drm_connector_cleanup(connector
);
1369 radeon_add_legacy_connector(struct drm_device
*dev
,
1370 uint32_t connector_id
,
1371 uint32_t supported_device
,
1373 struct radeon_i2c_bus_rec
*i2c_bus
,
1374 uint16_t connector_object_id
,
1375 struct radeon_hpd
*hpd
)
1377 struct radeon_device
*rdev
= dev
->dev_private
;
1378 struct drm_connector
*connector
;
1379 struct radeon_connector
*radeon_connector
;
1380 uint32_t subpixel_order
= SubPixelNone
;
1382 if (connector_type
== DRM_MODE_CONNECTOR_Unknown
)
1385 /* if the user selected tv=0 don't try and add the connector */
1386 if (((connector_type
== DRM_MODE_CONNECTOR_SVIDEO
) ||
1387 (connector_type
== DRM_MODE_CONNECTOR_Composite
) ||
1388 (connector_type
== DRM_MODE_CONNECTOR_9PinDIN
)) &&
1392 /* see if we already added it */
1393 list_for_each_entry(connector
, &dev
->mode_config
.connector_list
, head
) {
1394 radeon_connector
= to_radeon_connector(connector
);
1395 if (radeon_connector
->connector_id
== connector_id
) {
1396 radeon_connector
->devices
|= supported_device
;
1401 radeon_connector
= kzalloc(sizeof(struct radeon_connector
), GFP_KERNEL
);
1402 if (!radeon_connector
)
1405 connector
= &radeon_connector
->base
;
1407 radeon_connector
->connector_id
= connector_id
;
1408 radeon_connector
->devices
= supported_device
;
1409 radeon_connector
->connector_object_id
= connector_object_id
;
1410 radeon_connector
->hpd
= *hpd
;
1411 switch (connector_type
) {
1412 case DRM_MODE_CONNECTOR_VGA
:
1413 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_vga_connector_funcs
, connector_type
);
1414 drm_connector_helper_add(&radeon_connector
->base
, &radeon_vga_connector_helper_funcs
);
1415 if (i2c_bus
->valid
) {
1416 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1417 if (!radeon_connector
->ddc_bus
)
1420 radeon_connector
->dac_load_detect
= true;
1421 drm_connector_attach_property(&radeon_connector
->base
,
1422 rdev
->mode_info
.load_detect_property
,
1424 /* no HPD on analog connectors */
1425 radeon_connector
->hpd
.hpd
= RADEON_HPD_NONE
;
1426 connector
->polled
= DRM_CONNECTOR_POLL_CONNECT
;
1427 connector
->interlace_allowed
= true;
1428 connector
->doublescan_allowed
= true;
1430 case DRM_MODE_CONNECTOR_DVIA
:
1431 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_vga_connector_funcs
, connector_type
);
1432 drm_connector_helper_add(&radeon_connector
->base
, &radeon_vga_connector_helper_funcs
);
1433 if (i2c_bus
->valid
) {
1434 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1435 if (!radeon_connector
->ddc_bus
)
1438 radeon_connector
->dac_load_detect
= true;
1439 drm_connector_attach_property(&radeon_connector
->base
,
1440 rdev
->mode_info
.load_detect_property
,
1442 /* no HPD on analog connectors */
1443 radeon_connector
->hpd
.hpd
= RADEON_HPD_NONE
;
1444 connector
->interlace_allowed
= true;
1445 connector
->doublescan_allowed
= true;
1447 case DRM_MODE_CONNECTOR_DVII
:
1448 case DRM_MODE_CONNECTOR_DVID
:
1449 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_dvi_connector_funcs
, connector_type
);
1450 drm_connector_helper_add(&radeon_connector
->base
, &radeon_dvi_connector_helper_funcs
);
1451 if (i2c_bus
->valid
) {
1452 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1453 if (!radeon_connector
->ddc_bus
)
1456 if (connector_type
== DRM_MODE_CONNECTOR_DVII
) {
1457 radeon_connector
->dac_load_detect
= true;
1458 drm_connector_attach_property(&radeon_connector
->base
,
1459 rdev
->mode_info
.load_detect_property
,
1462 subpixel_order
= SubPixelHorizontalRGB
;
1463 connector
->interlace_allowed
= true;
1464 if (connector_type
== DRM_MODE_CONNECTOR_DVII
)
1465 connector
->doublescan_allowed
= true;
1467 connector
->doublescan_allowed
= false;
1469 case DRM_MODE_CONNECTOR_SVIDEO
:
1470 case DRM_MODE_CONNECTOR_Composite
:
1471 case DRM_MODE_CONNECTOR_9PinDIN
:
1472 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_tv_connector_funcs
, connector_type
);
1473 drm_connector_helper_add(&radeon_connector
->base
, &radeon_tv_connector_helper_funcs
);
1474 radeon_connector
->dac_load_detect
= true;
1475 /* RS400,RC410,RS480 chipset seems to report a lot
1476 * of false positive on load detect, we haven't yet
1477 * found a way to make load detect reliable on those
1478 * chipset, thus just disable it for TV.
1480 if (rdev
->family
== CHIP_RS400
|| rdev
->family
== CHIP_RS480
)
1481 radeon_connector
->dac_load_detect
= false;
1482 drm_connector_attach_property(&radeon_connector
->base
,
1483 rdev
->mode_info
.load_detect_property
,
1484 radeon_connector
->dac_load_detect
);
1485 drm_connector_attach_property(&radeon_connector
->base
,
1486 rdev
->mode_info
.tv_std_property
,
1487 radeon_combios_get_tv_info(rdev
));
1488 /* no HPD on analog connectors */
1489 radeon_connector
->hpd
.hpd
= RADEON_HPD_NONE
;
1490 connector
->interlace_allowed
= false;
1491 connector
->doublescan_allowed
= false;
1493 case DRM_MODE_CONNECTOR_LVDS
:
1494 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_lvds_connector_funcs
, connector_type
);
1495 drm_connector_helper_add(&radeon_connector
->base
, &radeon_lvds_connector_helper_funcs
);
1496 if (i2c_bus
->valid
) {
1497 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1498 if (!radeon_connector
->ddc_bus
)
1501 drm_connector_attach_property(&radeon_connector
->base
,
1502 dev
->mode_config
.scaling_mode_property
,
1503 DRM_MODE_SCALE_FULLSCREEN
);
1504 subpixel_order
= SubPixelHorizontalRGB
;
1505 connector
->interlace_allowed
= false;
1506 connector
->doublescan_allowed
= false;
1510 if (radeon_connector
->hpd
.hpd
== RADEON_HPD_NONE
) {
1512 connector
->polled
= DRM_CONNECTOR_POLL_CONNECT
;
1514 connector
->polled
= DRM_CONNECTOR_POLL_HPD
;
1515 connector
->display_info
.subpixel_order
= subpixel_order
;
1516 drm_sysfs_connector_add(connector
);
1520 drm_connector_cleanup(connector
);