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_INFO("1: conflicting encoders switching off %s\n", drm_get_connector_name(conflict
));
187 DRM_INFO("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_INFO("2: conflicting encoders switching off %s\n", drm_get_connector_name(connector
));
192 DRM_INFO("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("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("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
.tv_std_property
) {
316 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TVDAC
);
318 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_DAC
);
324 radeon_encoder
= to_radeon_encoder(encoder
);
325 if (!radeon_encoder
->enc_priv
)
327 if (ASIC_IS_AVIVO(rdev
) || radeon_r4xx_atom
) {
328 struct radeon_encoder_atom_dac
*dac_int
;
329 dac_int
= radeon_encoder
->enc_priv
;
330 dac_int
->tv_std
= val
;
332 struct radeon_encoder_tv_dac
*dac_int
;
333 dac_int
= radeon_encoder
->enc_priv
;
334 dac_int
->tv_std
= val
;
336 radeon_property_change_mode(&radeon_encoder
->base
);
339 if (property
== rdev
->mode_info
.load_detect_property
) {
340 struct radeon_connector
*radeon_connector
=
341 to_radeon_connector(connector
);
344 radeon_connector
->dac_load_detect
= false;
346 radeon_connector
->dac_load_detect
= true;
349 if (property
== rdev
->mode_info
.tmds_pll_property
) {
350 struct radeon_encoder_int_tmds
*tmds
= NULL
;
352 /* need to find digital encoder on connector */
353 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TMDS
);
357 radeon_encoder
= to_radeon_encoder(encoder
);
359 tmds
= radeon_encoder
->enc_priv
;
364 if (rdev
->is_atom_bios
)
365 ret
= radeon_atombios_get_tmds_info(radeon_encoder
, tmds
);
367 ret
= radeon_legacy_get_tmds_info_from_combios(radeon_encoder
, tmds
);
369 if (val
== 1 || ret
== false) {
370 radeon_legacy_get_tmds_info_from_table(radeon_encoder
, tmds
);
372 radeon_property_change_mode(&radeon_encoder
->base
);
378 static void radeon_fixup_lvds_native_mode(struct drm_encoder
*encoder
,
379 struct drm_connector
*connector
)
381 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
382 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
384 /* Try to get native mode details from EDID if necessary */
385 if (!native_mode
->clock
) {
386 struct drm_display_mode
*t
, *mode
;
388 list_for_each_entry_safe(mode
, t
, &connector
->probed_modes
, head
) {
389 if (mode
->hdisplay
== native_mode
->hdisplay
&&
390 mode
->vdisplay
== native_mode
->vdisplay
) {
391 *native_mode
= *mode
;
392 drm_mode_set_crtcinfo(native_mode
, CRTC_INTERLACE_HALVE_V
);
393 DRM_INFO("Determined LVDS native mode details from EDID\n");
398 if (!native_mode
->clock
) {
399 DRM_INFO("No LVDS native mode details, disabling RMX\n");
400 radeon_encoder
->rmx_type
= RMX_OFF
;
404 static int radeon_lvds_get_modes(struct drm_connector
*connector
)
406 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
407 struct drm_encoder
*encoder
;
409 struct drm_display_mode
*mode
;
411 if (radeon_connector
->ddc_bus
) {
412 ret
= radeon_ddc_get_modes(radeon_connector
);
414 encoder
= radeon_best_single_encoder(connector
);
416 radeon_fixup_lvds_native_mode(encoder
, connector
);
417 /* add scaled modes */
418 radeon_add_common_modes(encoder
, connector
);
424 encoder
= radeon_best_single_encoder(connector
);
428 /* we have no EDID modes */
429 mode
= radeon_fp_native_mode(encoder
);
432 drm_mode_probed_add(connector
, mode
);
433 /* add scaled modes */
434 radeon_add_common_modes(encoder
, connector
);
440 static int radeon_lvds_mode_valid(struct drm_connector
*connector
,
441 struct drm_display_mode
*mode
)
443 struct drm_encoder
*encoder
= radeon_best_single_encoder(connector
);
445 if ((mode
->hdisplay
< 320) || (mode
->vdisplay
< 240))
449 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
450 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
452 /* AVIVO hardware supports downscaling modes larger than the panel
453 * to the panel size, but I'm not sure this is desirable.
455 if ((mode
->hdisplay
> native_mode
->hdisplay
) ||
456 (mode
->vdisplay
> native_mode
->vdisplay
))
459 /* if scaling is disabled, block non-native modes */
460 if (radeon_encoder
->rmx_type
== RMX_OFF
) {
461 if ((mode
->hdisplay
!= native_mode
->hdisplay
) ||
462 (mode
->vdisplay
!= native_mode
->vdisplay
))
470 static enum drm_connector_status
radeon_lvds_detect(struct drm_connector
*connector
)
472 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
473 struct drm_encoder
*encoder
= radeon_best_single_encoder(connector
);
474 enum drm_connector_status ret
= connector_status_disconnected
;
477 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
478 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
480 /* check if panel is valid */
481 if (native_mode
->hdisplay
>= 320 && native_mode
->vdisplay
>= 240)
482 ret
= connector_status_connected
;
486 /* check for edid as well */
487 if (radeon_connector
->edid
)
488 ret
= connector_status_connected
;
490 if (radeon_connector
->ddc_bus
) {
491 radeon_connector
->edid
= drm_get_edid(&radeon_connector
->base
,
492 &radeon_connector
->ddc_bus
->adapter
);
493 if (radeon_connector
->edid
)
494 ret
= connector_status_connected
;
497 /* check acpi lid status ??? */
499 radeon_connector_update_scratch_regs(connector
, ret
);
503 static void radeon_connector_destroy(struct drm_connector
*connector
)
505 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
507 if (radeon_connector
->ddc_bus
)
508 radeon_i2c_destroy(radeon_connector
->ddc_bus
);
509 if (radeon_connector
->edid
)
510 kfree(radeon_connector
->edid
);
511 kfree(radeon_connector
->con_priv
);
512 drm_sysfs_connector_remove(connector
);
513 drm_connector_cleanup(connector
);
517 static int radeon_lvds_set_property(struct drm_connector
*connector
,
518 struct drm_property
*property
,
521 struct drm_device
*dev
= connector
->dev
;
522 struct radeon_encoder
*radeon_encoder
;
523 enum radeon_rmx_type rmx_type
;
526 if (property
!= dev
->mode_config
.scaling_mode_property
)
529 if (connector
->encoder
)
530 radeon_encoder
= to_radeon_encoder(connector
->encoder
);
532 struct drm_connector_helper_funcs
*connector_funcs
= connector
->helper_private
;
533 radeon_encoder
= to_radeon_encoder(connector_funcs
->best_encoder(connector
));
537 case DRM_MODE_SCALE_NONE
: rmx_type
= RMX_OFF
; break;
538 case DRM_MODE_SCALE_CENTER
: rmx_type
= RMX_CENTER
; break;
539 case DRM_MODE_SCALE_ASPECT
: rmx_type
= RMX_ASPECT
; break;
541 case DRM_MODE_SCALE_FULLSCREEN
: rmx_type
= RMX_FULL
; break;
543 if (radeon_encoder
->rmx_type
== rmx_type
)
546 radeon_encoder
->rmx_type
= rmx_type
;
548 radeon_property_change_mode(&radeon_encoder
->base
);
553 struct drm_connector_helper_funcs radeon_lvds_connector_helper_funcs
= {
554 .get_modes
= radeon_lvds_get_modes
,
555 .mode_valid
= radeon_lvds_mode_valid
,
556 .best_encoder
= radeon_best_single_encoder
,
559 struct drm_connector_funcs radeon_lvds_connector_funcs
= {
560 .dpms
= drm_helper_connector_dpms
,
561 .detect
= radeon_lvds_detect
,
562 .fill_modes
= drm_helper_probe_single_connector_modes
,
563 .destroy
= radeon_connector_destroy
,
564 .set_property
= radeon_lvds_set_property
,
567 static int radeon_vga_get_modes(struct drm_connector
*connector
)
569 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
572 ret
= radeon_ddc_get_modes(radeon_connector
);
577 static int radeon_vga_mode_valid(struct drm_connector
*connector
,
578 struct drm_display_mode
*mode
)
580 /* XXX check mode bandwidth */
581 /* XXX verify against max DAC output frequency */
585 static enum drm_connector_status
radeon_vga_detect(struct drm_connector
*connector
)
587 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
588 struct drm_encoder
*encoder
;
589 struct drm_encoder_helper_funcs
*encoder_funcs
;
591 enum drm_connector_status ret
= connector_status_disconnected
;
593 encoder
= radeon_best_single_encoder(connector
);
595 ret
= connector_status_disconnected
;
597 if (radeon_connector
->ddc_bus
)
598 dret
= radeon_ddc_probe(radeon_connector
);
600 if (radeon_connector
->edid
) {
601 kfree(radeon_connector
->edid
);
602 radeon_connector
->edid
= NULL
;
604 radeon_connector
->edid
= drm_get_edid(&radeon_connector
->base
, &radeon_connector
->ddc_bus
->adapter
);
606 if (!radeon_connector
->edid
) {
607 DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
608 drm_get_connector_name(connector
));
609 ret
= connector_status_connected
;
611 radeon_connector
->use_digital
= !!(radeon_connector
->edid
->input
& DRM_EDID_INPUT_DIGITAL
);
613 /* some oems have boards with separate digital and analog connectors
614 * with a shared ddc line (often vga + hdmi)
616 if (radeon_connector
->use_digital
&& radeon_connector
->shared_ddc
) {
617 kfree(radeon_connector
->edid
);
618 radeon_connector
->edid
= NULL
;
619 ret
= connector_status_disconnected
;
621 ret
= connector_status_connected
;
624 if (radeon_connector
->dac_load_detect
&& encoder
) {
625 encoder_funcs
= encoder
->helper_private
;
626 ret
= encoder_funcs
->detect(encoder
, connector
);
630 if (ret
== connector_status_connected
)
631 ret
= radeon_connector_analog_encoder_conflict_solve(connector
, encoder
, ret
, true);
632 radeon_connector_update_scratch_regs(connector
, ret
);
636 struct drm_connector_helper_funcs radeon_vga_connector_helper_funcs
= {
637 .get_modes
= radeon_vga_get_modes
,
638 .mode_valid
= radeon_vga_mode_valid
,
639 .best_encoder
= radeon_best_single_encoder
,
642 struct drm_connector_funcs radeon_vga_connector_funcs
= {
643 .dpms
= drm_helper_connector_dpms
,
644 .detect
= radeon_vga_detect
,
645 .fill_modes
= drm_helper_probe_single_connector_modes
,
646 .destroy
= radeon_connector_destroy
,
647 .set_property
= radeon_connector_set_property
,
650 static int radeon_tv_get_modes(struct drm_connector
*connector
)
652 struct drm_device
*dev
= connector
->dev
;
653 struct radeon_device
*rdev
= dev
->dev_private
;
654 struct drm_display_mode
*tv_mode
;
655 struct drm_encoder
*encoder
;
657 encoder
= radeon_best_single_encoder(connector
);
661 /* avivo chips can scale any mode */
662 if (rdev
->family
>= CHIP_RS600
)
663 /* add scaled modes */
664 radeon_add_common_modes(encoder
, connector
);
666 /* only 800x600 is supported right now on pre-avivo chips */
667 tv_mode
= drm_cvt_mode(dev
, 800, 600, 60, false, false, false);
668 tv_mode
->type
= DRM_MODE_TYPE_DRIVER
| DRM_MODE_TYPE_PREFERRED
;
669 drm_mode_probed_add(connector
, tv_mode
);
674 static int radeon_tv_mode_valid(struct drm_connector
*connector
,
675 struct drm_display_mode
*mode
)
677 if ((mode
->hdisplay
> 1024) || (mode
->vdisplay
> 768))
678 return MODE_CLOCK_RANGE
;
682 static enum drm_connector_status
radeon_tv_detect(struct drm_connector
*connector
)
684 struct drm_encoder
*encoder
;
685 struct drm_encoder_helper_funcs
*encoder_funcs
;
686 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
687 enum drm_connector_status ret
= connector_status_disconnected
;
689 if (!radeon_connector
->dac_load_detect
)
692 encoder
= radeon_best_single_encoder(connector
);
694 ret
= connector_status_disconnected
;
696 encoder_funcs
= encoder
->helper_private
;
697 ret
= encoder_funcs
->detect(encoder
, connector
);
699 if (ret
== connector_status_connected
)
700 ret
= radeon_connector_analog_encoder_conflict_solve(connector
, encoder
, ret
, false);
701 radeon_connector_update_scratch_regs(connector
, ret
);
705 struct drm_connector_helper_funcs radeon_tv_connector_helper_funcs
= {
706 .get_modes
= radeon_tv_get_modes
,
707 .mode_valid
= radeon_tv_mode_valid
,
708 .best_encoder
= radeon_best_single_encoder
,
711 struct drm_connector_funcs radeon_tv_connector_funcs
= {
712 .dpms
= drm_helper_connector_dpms
,
713 .detect
= radeon_tv_detect
,
714 .fill_modes
= drm_helper_probe_single_connector_modes
,
715 .destroy
= radeon_connector_destroy
,
716 .set_property
= radeon_connector_set_property
,
719 static int radeon_dvi_get_modes(struct drm_connector
*connector
)
721 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
724 ret
= radeon_ddc_get_modes(radeon_connector
);
730 * Do a DDC probe, if DDC probe passes, get the full EDID so
731 * we can do analog/digital monitor detection at this point.
732 * If the monitor is an analog monitor or we got no DDC,
733 * we need to find the DAC encoder object for this connector.
734 * If we got no DDC, we do load detection on the DAC encoder object.
735 * If we got analog DDC or load detection passes on the DAC encoder
736 * we have to check if this analog encoder is shared with anyone else (TV)
737 * if its shared we have to set the other connector to disconnected.
739 static enum drm_connector_status
radeon_dvi_detect(struct drm_connector
*connector
)
741 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
742 struct drm_encoder
*encoder
= NULL
;
743 struct drm_encoder_helper_funcs
*encoder_funcs
;
744 struct drm_mode_object
*obj
;
746 enum drm_connector_status ret
= connector_status_disconnected
;
749 if (radeon_connector
->ddc_bus
)
750 dret
= radeon_ddc_probe(radeon_connector
);
752 if (radeon_connector
->edid
) {
753 kfree(radeon_connector
->edid
);
754 radeon_connector
->edid
= NULL
;
756 radeon_connector
->edid
= drm_get_edid(&radeon_connector
->base
, &radeon_connector
->ddc_bus
->adapter
);
758 if (!radeon_connector
->edid
) {
759 DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
760 drm_get_connector_name(connector
));
762 radeon_connector
->use_digital
= !!(radeon_connector
->edid
->input
& DRM_EDID_INPUT_DIGITAL
);
764 /* some oems have boards with separate digital and analog connectors
765 * with a shared ddc line (often vga + hdmi)
767 if ((!radeon_connector
->use_digital
) && radeon_connector
->shared_ddc
) {
768 kfree(radeon_connector
->edid
);
769 radeon_connector
->edid
= NULL
;
770 ret
= connector_status_disconnected
;
772 ret
= connector_status_connected
;
774 /* multiple connectors on the same encoder with the same ddc line
775 * This tends to be HDMI and DVI on the same encoder with the
776 * same ddc line. If the edid says HDMI, consider the HDMI port
777 * connected and the DVI port disconnected. If the edid doesn't
778 * say HDMI, vice versa.
780 if (radeon_connector
->shared_ddc
&& (ret
== connector_status_connected
)) {
781 struct drm_device
*dev
= connector
->dev
;
782 struct drm_connector
*list_connector
;
783 struct radeon_connector
*list_radeon_connector
;
784 list_for_each_entry(list_connector
, &dev
->mode_config
.connector_list
, head
) {
785 if (connector
== list_connector
)
787 list_radeon_connector
= to_radeon_connector(list_connector
);
788 if (radeon_connector
->devices
== list_radeon_connector
->devices
) {
789 if (drm_detect_hdmi_monitor(radeon_connector
->edid
)) {
790 if (connector
->connector_type
== DRM_MODE_CONNECTOR_DVID
) {
791 kfree(radeon_connector
->edid
);
792 radeon_connector
->edid
= NULL
;
793 ret
= connector_status_disconnected
;
796 if ((connector
->connector_type
== DRM_MODE_CONNECTOR_HDMIA
) ||
797 (connector
->connector_type
== DRM_MODE_CONNECTOR_HDMIB
)) {
798 kfree(radeon_connector
->edid
);
799 radeon_connector
->edid
= NULL
;
800 ret
= connector_status_disconnected
;
809 if ((ret
== connector_status_connected
) && (radeon_connector
->use_digital
== true))
812 /* find analog encoder */
813 if (radeon_connector
->dac_load_detect
) {
814 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
815 if (connector
->encoder_ids
[i
] == 0)
818 obj
= drm_mode_object_find(connector
->dev
,
819 connector
->encoder_ids
[i
],
820 DRM_MODE_OBJECT_ENCODER
);
824 encoder
= obj_to_encoder(obj
);
826 encoder_funcs
= encoder
->helper_private
;
827 if (encoder_funcs
->detect
) {
828 if (ret
!= connector_status_connected
) {
829 ret
= encoder_funcs
->detect(encoder
, connector
);
830 if (ret
== connector_status_connected
) {
831 radeon_connector
->use_digital
= false;
839 if ((ret
== connector_status_connected
) && (radeon_connector
->use_digital
== false) &&
841 ret
= radeon_connector_analog_encoder_conflict_solve(connector
, encoder
, ret
, true);
845 /* updated in get modes as well since we need to know if it's analog or digital */
846 radeon_connector_update_scratch_regs(connector
, ret
);
850 /* okay need to be smart in here about which encoder to pick */
851 struct drm_encoder
*radeon_dvi_encoder(struct drm_connector
*connector
)
853 int enc_id
= connector
->encoder_ids
[0];
854 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
855 struct drm_mode_object
*obj
;
856 struct drm_encoder
*encoder
;
858 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
859 if (connector
->encoder_ids
[i
] == 0)
862 obj
= drm_mode_object_find(connector
->dev
, connector
->encoder_ids
[i
], DRM_MODE_OBJECT_ENCODER
);
866 encoder
= obj_to_encoder(obj
);
868 if (radeon_connector
->use_digital
== true) {
869 if (encoder
->encoder_type
== DRM_MODE_ENCODER_TMDS
)
872 if (encoder
->encoder_type
== DRM_MODE_ENCODER_DAC
||
873 encoder
->encoder_type
== DRM_MODE_ENCODER_TVDAC
)
878 /* see if we have a default encoder TODO */
880 /* then check use digitial */
881 /* pick the first one */
883 obj
= drm_mode_object_find(connector
->dev
, enc_id
, DRM_MODE_OBJECT_ENCODER
);
886 encoder
= obj_to_encoder(obj
);
892 static void radeon_dvi_force(struct drm_connector
*connector
)
894 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
895 if (connector
->force
== DRM_FORCE_ON
)
896 radeon_connector
->use_digital
= false;
897 if (connector
->force
== DRM_FORCE_ON_DIGITAL
)
898 radeon_connector
->use_digital
= true;
901 static int radeon_dvi_mode_valid(struct drm_connector
*connector
,
902 struct drm_display_mode
*mode
)
904 struct drm_device
*dev
= connector
->dev
;
905 struct radeon_device
*rdev
= dev
->dev_private
;
906 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
908 /* XXX check mode bandwidth */
910 /* clocks over 135 MHz have heat issues with DVI on RV100 */
911 if (radeon_connector
->use_digital
&&
912 (rdev
->family
== CHIP_RV100
) &&
913 (mode
->clock
> 135000))
914 return MODE_CLOCK_HIGH
;
916 if (radeon_connector
->use_digital
&& (mode
->clock
> 165000)) {
917 if ((radeon_connector
->connector_object_id
== CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_I
) ||
918 (radeon_connector
->connector_object_id
== CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_D
) ||
919 (radeon_connector
->connector_object_id
== CONNECTOR_OBJECT_ID_HDMI_TYPE_B
))
922 return MODE_CLOCK_HIGH
;
927 struct drm_connector_helper_funcs radeon_dvi_connector_helper_funcs
= {
928 .get_modes
= radeon_dvi_get_modes
,
929 .mode_valid
= radeon_dvi_mode_valid
,
930 .best_encoder
= radeon_dvi_encoder
,
933 struct drm_connector_funcs radeon_dvi_connector_funcs
= {
934 .dpms
= drm_helper_connector_dpms
,
935 .detect
= radeon_dvi_detect
,
936 .fill_modes
= drm_helper_probe_single_connector_modes
,
937 .set_property
= radeon_connector_set_property
,
938 .destroy
= radeon_connector_destroy
,
939 .force
= radeon_dvi_force
,
942 static void radeon_dp_connector_destroy(struct drm_connector
*connector
)
944 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
945 struct radeon_connector_atom_dig
*radeon_dig_connector
= radeon_connector
->con_priv
;
947 if (radeon_connector
->ddc_bus
)
948 radeon_i2c_destroy(radeon_connector
->ddc_bus
);
949 if (radeon_connector
->edid
)
950 kfree(radeon_connector
->edid
);
951 if (radeon_dig_connector
->dp_i2c_bus
)
952 radeon_i2c_destroy(radeon_dig_connector
->dp_i2c_bus
);
953 kfree(radeon_connector
->con_priv
);
954 drm_sysfs_connector_remove(connector
);
955 drm_connector_cleanup(connector
);
959 static int radeon_dp_get_modes(struct drm_connector
*connector
)
961 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
964 ret
= radeon_ddc_get_modes(radeon_connector
);
968 static enum drm_connector_status
radeon_dp_detect(struct drm_connector
*connector
)
970 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
971 enum drm_connector_status ret
= connector_status_disconnected
;
972 struct radeon_connector_atom_dig
*radeon_dig_connector
= radeon_connector
->con_priv
;
975 if (radeon_connector
->edid
) {
976 kfree(radeon_connector
->edid
);
977 radeon_connector
->edid
= NULL
;
980 sink_type
= radeon_dp_getsinktype(radeon_connector
);
981 if ((sink_type
== CONNECTOR_OBJECT_ID_DISPLAYPORT
) ||
982 (sink_type
== CONNECTOR_OBJECT_ID_eDP
)) {
983 if (radeon_dp_getdpcd(radeon_connector
)) {
984 radeon_dig_connector
->dp_sink_type
= sink_type
;
985 ret
= connector_status_connected
;
988 if (radeon_ddc_probe(radeon_connector
)) {
989 radeon_dig_connector
->dp_sink_type
= sink_type
;
990 ret
= connector_status_connected
;
997 static int radeon_dp_mode_valid(struct drm_connector
*connector
,
998 struct drm_display_mode
*mode
)
1000 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1001 struct radeon_connector_atom_dig
*radeon_dig_connector
= radeon_connector
->con_priv
;
1003 /* XXX check mode bandwidth */
1005 if ((radeon_dig_connector
->dp_sink_type
== CONNECTOR_OBJECT_ID_DISPLAYPORT
) ||
1006 (radeon_dig_connector
->dp_sink_type
== CONNECTOR_OBJECT_ID_eDP
))
1007 return radeon_dp_mode_valid_helper(radeon_connector
, mode
);
1012 struct drm_connector_helper_funcs radeon_dp_connector_helper_funcs
= {
1013 .get_modes
= radeon_dp_get_modes
,
1014 .mode_valid
= radeon_dp_mode_valid
,
1015 .best_encoder
= radeon_dvi_encoder
,
1018 struct drm_connector_funcs radeon_dp_connector_funcs
= {
1019 .dpms
= drm_helper_connector_dpms
,
1020 .detect
= radeon_dp_detect
,
1021 .fill_modes
= drm_helper_probe_single_connector_modes
,
1022 .set_property
= radeon_connector_set_property
,
1023 .destroy
= radeon_dp_connector_destroy
,
1024 .force
= radeon_dvi_force
,
1028 radeon_add_atom_connector(struct drm_device
*dev
,
1029 uint32_t connector_id
,
1030 uint32_t supported_device
,
1032 struct radeon_i2c_bus_rec
*i2c_bus
,
1034 uint32_t igp_lane_info
,
1035 uint16_t connector_object_id
,
1036 struct radeon_hpd
*hpd
)
1038 struct radeon_device
*rdev
= dev
->dev_private
;
1039 struct drm_connector
*connector
;
1040 struct radeon_connector
*radeon_connector
;
1041 struct radeon_connector_atom_dig
*radeon_dig_connector
;
1042 uint32_t subpixel_order
= SubPixelNone
;
1043 bool shared_ddc
= false;
1046 /* fixme - tv/cv/din */
1047 if (connector_type
== DRM_MODE_CONNECTOR_Unknown
)
1050 /* see if we already added it */
1051 list_for_each_entry(connector
, &dev
->mode_config
.connector_list
, head
) {
1052 radeon_connector
= to_radeon_connector(connector
);
1053 if (radeon_connector
->connector_id
== connector_id
) {
1054 radeon_connector
->devices
|= supported_device
;
1057 if (radeon_connector
->ddc_bus
&& i2c_bus
->valid
) {
1058 if (radeon_connector
->ddc_bus
->rec
.i2c_id
== i2c_bus
->i2c_id
) {
1059 radeon_connector
->shared_ddc
= true;
1065 radeon_connector
= kzalloc(sizeof(struct radeon_connector
), GFP_KERNEL
);
1066 if (!radeon_connector
)
1069 connector
= &radeon_connector
->base
;
1071 radeon_connector
->connector_id
= connector_id
;
1072 radeon_connector
->devices
= supported_device
;
1073 radeon_connector
->shared_ddc
= shared_ddc
;
1074 radeon_connector
->connector_object_id
= connector_object_id
;
1075 radeon_connector
->hpd
= *hpd
;
1076 switch (connector_type
) {
1077 case DRM_MODE_CONNECTOR_VGA
:
1078 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_vga_connector_funcs
, connector_type
);
1079 ret
= drm_connector_helper_add(&radeon_connector
->base
, &radeon_vga_connector_helper_funcs
);
1082 if (i2c_bus
->valid
) {
1083 radeon_connector
->ddc_bus
= radeon_i2c_create(dev
, i2c_bus
, "VGA");
1084 if (!radeon_connector
->ddc_bus
)
1087 radeon_connector
->dac_load_detect
= true;
1088 drm_connector_attach_property(&radeon_connector
->base
,
1089 rdev
->mode_info
.load_detect_property
,
1092 case DRM_MODE_CONNECTOR_DVIA
:
1093 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_vga_connector_funcs
, connector_type
);
1094 ret
= drm_connector_helper_add(&radeon_connector
->base
, &radeon_vga_connector_helper_funcs
);
1097 if (i2c_bus
->valid
) {
1098 radeon_connector
->ddc_bus
= radeon_i2c_create(dev
, i2c_bus
, "DVI");
1099 if (!radeon_connector
->ddc_bus
)
1102 radeon_connector
->dac_load_detect
= true;
1103 drm_connector_attach_property(&radeon_connector
->base
,
1104 rdev
->mode_info
.load_detect_property
,
1107 case DRM_MODE_CONNECTOR_DVII
:
1108 case DRM_MODE_CONNECTOR_DVID
:
1109 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
1110 if (!radeon_dig_connector
)
1112 radeon_dig_connector
->linkb
= linkb
;
1113 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
1114 radeon_connector
->con_priv
= radeon_dig_connector
;
1115 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_dvi_connector_funcs
, connector_type
);
1116 ret
= drm_connector_helper_add(&radeon_connector
->base
, &radeon_dvi_connector_helper_funcs
);
1119 if (i2c_bus
->valid
) {
1120 radeon_connector
->ddc_bus
= radeon_i2c_create(dev
, i2c_bus
, "DVI");
1121 if (!radeon_connector
->ddc_bus
)
1124 subpixel_order
= SubPixelHorizontalRGB
;
1125 drm_connector_attach_property(&radeon_connector
->base
,
1126 rdev
->mode_info
.coherent_mode_property
,
1128 if (connector_type
== DRM_MODE_CONNECTOR_DVII
) {
1129 radeon_connector
->dac_load_detect
= true;
1130 drm_connector_attach_property(&radeon_connector
->base
,
1131 rdev
->mode_info
.load_detect_property
,
1135 case DRM_MODE_CONNECTOR_HDMIA
:
1136 case DRM_MODE_CONNECTOR_HDMIB
:
1137 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
1138 if (!radeon_dig_connector
)
1140 radeon_dig_connector
->linkb
= linkb
;
1141 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
1142 radeon_connector
->con_priv
= radeon_dig_connector
;
1143 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_dvi_connector_funcs
, connector_type
);
1144 ret
= drm_connector_helper_add(&radeon_connector
->base
, &radeon_dvi_connector_helper_funcs
);
1147 if (i2c_bus
->valid
) {
1148 radeon_connector
->ddc_bus
= radeon_i2c_create(dev
, i2c_bus
, "HDMI");
1149 if (!radeon_connector
->ddc_bus
)
1152 drm_connector_attach_property(&radeon_connector
->base
,
1153 rdev
->mode_info
.coherent_mode_property
,
1155 subpixel_order
= SubPixelHorizontalRGB
;
1157 case DRM_MODE_CONNECTOR_DisplayPort
:
1158 case DRM_MODE_CONNECTOR_eDP
:
1159 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
1160 if (!radeon_dig_connector
)
1162 radeon_dig_connector
->linkb
= linkb
;
1163 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
1164 radeon_connector
->con_priv
= radeon_dig_connector
;
1165 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_dp_connector_funcs
, connector_type
);
1166 ret
= drm_connector_helper_add(&radeon_connector
->base
, &radeon_dp_connector_helper_funcs
);
1169 if (i2c_bus
->valid
) {
1170 /* add DP i2c bus */
1171 if (connector_type
== DRM_MODE_CONNECTOR_eDP
)
1172 radeon_dig_connector
->dp_i2c_bus
= radeon_i2c_create_dp(dev
, i2c_bus
, "eDP-auxch");
1174 radeon_dig_connector
->dp_i2c_bus
= radeon_i2c_create_dp(dev
, i2c_bus
, "DP-auxch");
1175 if (!radeon_dig_connector
->dp_i2c_bus
)
1177 if (connector_type
== DRM_MODE_CONNECTOR_eDP
)
1178 radeon_connector
->ddc_bus
= radeon_i2c_create(dev
, i2c_bus
, "eDP");
1180 radeon_connector
->ddc_bus
= radeon_i2c_create(dev
, i2c_bus
, "DP");
1181 if (!radeon_connector
->ddc_bus
)
1184 subpixel_order
= SubPixelHorizontalRGB
;
1185 drm_connector_attach_property(&radeon_connector
->base
,
1186 rdev
->mode_info
.coherent_mode_property
,
1189 case DRM_MODE_CONNECTOR_SVIDEO
:
1190 case DRM_MODE_CONNECTOR_Composite
:
1191 case DRM_MODE_CONNECTOR_9PinDIN
:
1192 if (radeon_tv
== 1) {
1193 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_tv_connector_funcs
, connector_type
);
1194 ret
= drm_connector_helper_add(&radeon_connector
->base
, &radeon_tv_connector_helper_funcs
);
1197 radeon_connector
->dac_load_detect
= true;
1198 drm_connector_attach_property(&radeon_connector
->base
,
1199 rdev
->mode_info
.load_detect_property
,
1201 drm_connector_attach_property(&radeon_connector
->base
,
1202 rdev
->mode_info
.tv_std_property
,
1203 radeon_atombios_get_tv_info(rdev
));
1206 case DRM_MODE_CONNECTOR_LVDS
:
1207 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
1208 if (!radeon_dig_connector
)
1210 radeon_dig_connector
->linkb
= linkb
;
1211 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
1212 radeon_connector
->con_priv
= radeon_dig_connector
;
1213 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_lvds_connector_funcs
, connector_type
);
1214 ret
= drm_connector_helper_add(&radeon_connector
->base
, &radeon_lvds_connector_helper_funcs
);
1217 if (i2c_bus
->valid
) {
1218 radeon_connector
->ddc_bus
= radeon_i2c_create(dev
, i2c_bus
, "LVDS");
1219 if (!radeon_connector
->ddc_bus
)
1222 drm_connector_attach_property(&radeon_connector
->base
,
1223 dev
->mode_config
.scaling_mode_property
,
1224 DRM_MODE_SCALE_FULLSCREEN
);
1225 subpixel_order
= SubPixelHorizontalRGB
;
1229 connector
->display_info
.subpixel_order
= subpixel_order
;
1230 drm_sysfs_connector_add(connector
);
1234 if (radeon_connector
->ddc_bus
)
1235 radeon_i2c_destroy(radeon_connector
->ddc_bus
);
1236 drm_connector_cleanup(connector
);
1241 radeon_add_legacy_connector(struct drm_device
*dev
,
1242 uint32_t connector_id
,
1243 uint32_t supported_device
,
1245 struct radeon_i2c_bus_rec
*i2c_bus
,
1246 uint16_t connector_object_id
,
1247 struct radeon_hpd
*hpd
)
1249 struct radeon_device
*rdev
= dev
->dev_private
;
1250 struct drm_connector
*connector
;
1251 struct radeon_connector
*radeon_connector
;
1252 uint32_t subpixel_order
= SubPixelNone
;
1255 /* fixme - tv/cv/din */
1256 if (connector_type
== DRM_MODE_CONNECTOR_Unknown
)
1259 /* see if we already added it */
1260 list_for_each_entry(connector
, &dev
->mode_config
.connector_list
, head
) {
1261 radeon_connector
= to_radeon_connector(connector
);
1262 if (radeon_connector
->connector_id
== connector_id
) {
1263 radeon_connector
->devices
|= supported_device
;
1268 radeon_connector
= kzalloc(sizeof(struct radeon_connector
), GFP_KERNEL
);
1269 if (!radeon_connector
)
1272 connector
= &radeon_connector
->base
;
1274 radeon_connector
->connector_id
= connector_id
;
1275 radeon_connector
->devices
= supported_device
;
1276 radeon_connector
->connector_object_id
= connector_object_id
;
1277 radeon_connector
->hpd
= *hpd
;
1278 switch (connector_type
) {
1279 case DRM_MODE_CONNECTOR_VGA
:
1280 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_vga_connector_funcs
, connector_type
);
1281 ret
= drm_connector_helper_add(&radeon_connector
->base
, &radeon_vga_connector_helper_funcs
);
1284 if (i2c_bus
->valid
) {
1285 radeon_connector
->ddc_bus
= radeon_i2c_create(dev
, i2c_bus
, "VGA");
1286 if (!radeon_connector
->ddc_bus
)
1289 radeon_connector
->dac_load_detect
= true;
1290 drm_connector_attach_property(&radeon_connector
->base
,
1291 rdev
->mode_info
.load_detect_property
,
1294 case DRM_MODE_CONNECTOR_DVIA
:
1295 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_vga_connector_funcs
, connector_type
);
1296 ret
= drm_connector_helper_add(&radeon_connector
->base
, &radeon_vga_connector_helper_funcs
);
1299 if (i2c_bus
->valid
) {
1300 radeon_connector
->ddc_bus
= radeon_i2c_create(dev
, i2c_bus
, "DVI");
1301 if (!radeon_connector
->ddc_bus
)
1304 radeon_connector
->dac_load_detect
= true;
1305 drm_connector_attach_property(&radeon_connector
->base
,
1306 rdev
->mode_info
.load_detect_property
,
1309 case DRM_MODE_CONNECTOR_DVII
:
1310 case DRM_MODE_CONNECTOR_DVID
:
1311 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_dvi_connector_funcs
, connector_type
);
1312 ret
= drm_connector_helper_add(&radeon_connector
->base
, &radeon_dvi_connector_helper_funcs
);
1315 if (i2c_bus
->valid
) {
1316 radeon_connector
->ddc_bus
= radeon_i2c_create(dev
, i2c_bus
, "DVI");
1317 if (!radeon_connector
->ddc_bus
)
1320 if (connector_type
== DRM_MODE_CONNECTOR_DVII
) {
1321 radeon_connector
->dac_load_detect
= true;
1322 drm_connector_attach_property(&radeon_connector
->base
,
1323 rdev
->mode_info
.load_detect_property
,
1326 subpixel_order
= SubPixelHorizontalRGB
;
1328 case DRM_MODE_CONNECTOR_SVIDEO
:
1329 case DRM_MODE_CONNECTOR_Composite
:
1330 case DRM_MODE_CONNECTOR_9PinDIN
:
1331 if (radeon_tv
== 1) {
1332 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_tv_connector_funcs
, connector_type
);
1333 ret
= drm_connector_helper_add(&radeon_connector
->base
, &radeon_tv_connector_helper_funcs
);
1336 radeon_connector
->dac_load_detect
= true;
1337 /* RS400,RC410,RS480 chipset seems to report a lot
1338 * of false positive on load detect, we haven't yet
1339 * found a way to make load detect reliable on those
1340 * chipset, thus just disable it for TV.
1342 if (rdev
->family
== CHIP_RS400
|| rdev
->family
== CHIP_RS480
)
1343 radeon_connector
->dac_load_detect
= false;
1344 drm_connector_attach_property(&radeon_connector
->base
,
1345 rdev
->mode_info
.load_detect_property
,
1346 radeon_connector
->dac_load_detect
);
1347 drm_connector_attach_property(&radeon_connector
->base
,
1348 rdev
->mode_info
.tv_std_property
,
1349 radeon_combios_get_tv_info(rdev
));
1352 case DRM_MODE_CONNECTOR_LVDS
:
1353 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_lvds_connector_funcs
, connector_type
);
1354 ret
= drm_connector_helper_add(&radeon_connector
->base
, &radeon_lvds_connector_helper_funcs
);
1357 if (i2c_bus
->valid
) {
1358 radeon_connector
->ddc_bus
= radeon_i2c_create(dev
, i2c_bus
, "LVDS");
1359 if (!radeon_connector
->ddc_bus
)
1362 drm_connector_attach_property(&radeon_connector
->base
,
1363 dev
->mode_config
.scaling_mode_property
,
1364 DRM_MODE_SCALE_FULLSCREEN
);
1365 subpixel_order
= SubPixelHorizontalRGB
;
1369 connector
->display_info
.subpixel_order
= subpixel_order
;
1370 drm_sysfs_connector_add(connector
);
1374 if (radeon_connector
->ddc_bus
)
1375 radeon_i2c_destroy(radeon_connector
->ddc_bus
);
1376 drm_connector_cleanup(connector
);