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
27 #include <drm/drm_edid.h>
28 #include <drm/drm_crtc_helper.h>
29 #include <drm/drm_fb_helper.h>
30 #include <uapi_drm/radeon_drm.h>
32 #include "radeon_audio.h"
35 #include <linux/string.h>
38 #include <linux/pm_runtime.h>
41 void radeon_connector_hotplug(struct drm_connector
*connector
)
43 struct drm_device
*dev
= connector
->dev
;
44 struct radeon_device
*rdev
= dev
->dev_private
;
45 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
47 /* bail if the connector does not have hpd pin, e.g.,
50 if (radeon_connector
->hpd
.hpd
== RADEON_HPD_NONE
)
53 radeon_hpd_set_polarity(rdev
, radeon_connector
->hpd
.hpd
);
55 /* if the connector is already off, don't turn it back on */
56 /* FIXME: This access isn't protected by any locks. */
57 if (connector
->dpms
!= DRM_MODE_DPMS_ON
)
60 /* just deal with DP (not eDP) here. */
61 if (connector
->connector_type
== DRM_MODE_CONNECTOR_DisplayPort
) {
62 struct radeon_connector_atom_dig
*dig_connector
=
63 radeon_connector
->con_priv
;
65 /* if existing sink type was not DP no need to retrain */
66 if (dig_connector
->dp_sink_type
!= CONNECTOR_OBJECT_ID_DISPLAYPORT
)
69 /* first get sink type as it may be reset after (un)plug */
70 dig_connector
->dp_sink_type
= radeon_dp_getsinktype(radeon_connector
);
71 /* don't do anything if sink is not display port, i.e.,
72 * passive dp->(dvi|hdmi) adaptor
74 if (dig_connector
->dp_sink_type
== CONNECTOR_OBJECT_ID_DISPLAYPORT
) {
75 int saved_dpms
= connector
->dpms
;
76 /* Only turn off the display if it's physically disconnected */
77 if (!radeon_hpd_sense(rdev
, radeon_connector
->hpd
.hpd
)) {
78 drm_helper_connector_dpms(connector
, DRM_MODE_DPMS_OFF
);
79 } else if (radeon_dp_needs_link_train(radeon_connector
)) {
80 /* Don't try to start link training before we
82 if (!radeon_dp_getdpcd(radeon_connector
))
85 /* set it to OFF so that drm_helper_connector_dpms()
86 * won't return immediately since the current state
87 * is ON at this point.
89 connector
->dpms
= DRM_MODE_DPMS_OFF
;
90 drm_helper_connector_dpms(connector
, DRM_MODE_DPMS_ON
);
92 connector
->dpms
= saved_dpms
;
97 static void radeon_property_change_mode(struct drm_encoder
*encoder
)
99 struct drm_crtc
*crtc
= encoder
->crtc
;
101 if (crtc
&& crtc
->enabled
) {
102 drm_crtc_helper_set_mode(crtc
, &crtc
->mode
,
103 crtc
->x
, crtc
->y
, crtc
->primary
->fb
);
107 int radeon_get_monitor_bpc(struct drm_connector
*connector
)
109 struct drm_device
*dev
= connector
->dev
;
110 struct radeon_device
*rdev
= dev
->dev_private
;
111 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
112 struct radeon_connector_atom_dig
*dig_connector
;
114 int mode_clock
, max_tmds_clock
;
116 switch (connector
->connector_type
) {
117 case DRM_MODE_CONNECTOR_DVII
:
118 case DRM_MODE_CONNECTOR_HDMIB
:
119 if (radeon_connector
->use_digital
) {
120 if (drm_detect_hdmi_monitor(radeon_connector_edid(connector
))) {
121 if (connector
->display_info
.bpc
)
122 bpc
= connector
->display_info
.bpc
;
126 case DRM_MODE_CONNECTOR_DVID
:
127 case DRM_MODE_CONNECTOR_HDMIA
:
128 if (drm_detect_hdmi_monitor(radeon_connector_edid(connector
))) {
129 if (connector
->display_info
.bpc
)
130 bpc
= connector
->display_info
.bpc
;
133 case DRM_MODE_CONNECTOR_DisplayPort
:
134 dig_connector
= radeon_connector
->con_priv
;
135 if ((dig_connector
->dp_sink_type
== CONNECTOR_OBJECT_ID_DISPLAYPORT
) ||
136 (dig_connector
->dp_sink_type
== CONNECTOR_OBJECT_ID_eDP
) ||
137 drm_detect_hdmi_monitor(radeon_connector_edid(connector
))) {
138 if (connector
->display_info
.bpc
)
139 bpc
= connector
->display_info
.bpc
;
142 case DRM_MODE_CONNECTOR_eDP
:
143 case DRM_MODE_CONNECTOR_LVDS
:
144 if (connector
->display_info
.bpc
)
145 bpc
= connector
->display_info
.bpc
;
146 else if (ASIC_IS_DCE41(rdev
) || ASIC_IS_DCE5(rdev
)) {
147 const struct drm_connector_helper_funcs
*connector_funcs
=
148 connector
->helper_private
;
149 struct drm_encoder
*encoder
= connector_funcs
->best_encoder(connector
);
150 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
151 struct radeon_encoder_atom_dig
*dig
= radeon_encoder
->enc_priv
;
153 if (dig
->lcd_misc
& ATOM_PANEL_MISC_V13_6BIT_PER_COLOR
)
155 else if (dig
->lcd_misc
& ATOM_PANEL_MISC_V13_8BIT_PER_COLOR
)
161 if (drm_detect_hdmi_monitor(radeon_connector_edid(connector
))) {
162 /* hdmi deep color only implemented on DCE4+ */
163 if ((bpc
> 8) && !ASIC_IS_DCE4(rdev
)) {
164 DRM_DEBUG("%s: HDMI deep color %d bpc unsupported. Using 8 bpc.\n",
165 connector
->name
, bpc
);
170 * Pre DCE-8 hw can't handle > 12 bpc, and more than 12 bpc doesn't make
171 * much sense without support for > 12 bpc framebuffers. RGB 4:4:4 at
172 * 12 bpc is always supported on hdmi deep color sinks, as this is
173 * required by the HDMI-1.3 spec. Clamp to a safe 12 bpc maximum.
176 DRM_DEBUG("%s: HDMI deep color %d bpc unsupported. Using 12 bpc.\n",
177 connector
->name
, bpc
);
181 /* Any defined maximum tmds clock limit we must not exceed? */
182 if (connector
->max_tmds_clock
> 0) {
183 /* mode_clock is clock in kHz for mode to be modeset on this connector */
184 mode_clock
= radeon_connector
->pixelclock_for_modeset
;
186 /* Maximum allowable input clock in kHz */
187 max_tmds_clock
= connector
->max_tmds_clock
* 1000;
189 DRM_DEBUG("%s: hdmi mode dotclock %d kHz, max tmds input clock %d kHz.\n",
190 connector
->name
, mode_clock
, max_tmds_clock
);
192 /* Check if bpc is within clock limit. Try to degrade gracefully otherwise */
193 if ((bpc
== 12) && (mode_clock
* 3/2 > max_tmds_clock
)) {
194 if ((connector
->display_info
.edid_hdmi_dc_modes
& DRM_EDID_HDMI_DC_30
) &&
195 (mode_clock
* 5/4 <= max_tmds_clock
))
200 DRM_DEBUG("%s: HDMI deep color 12 bpc exceeds max tmds clock. Using %d bpc.\n",
201 connector
->name
, bpc
);
204 if ((bpc
== 10) && (mode_clock
* 5/4 > max_tmds_clock
)) {
206 DRM_DEBUG("%s: HDMI deep color 10 bpc exceeds max tmds clock. Using %d bpc.\n",
207 connector
->name
, bpc
);
211 /* max_tmds_clock missing, but hdmi spec mandates it for deep color. */
212 DRM_DEBUG("%s: Required max tmds clock for HDMI deep color missing. Using 8 bpc.\n",
218 if ((radeon_deep_color
== 0) && (bpc
> 8)) {
219 DRM_DEBUG("%s: Deep color disabled. Set radeon module param deep_color=1 to enable.\n",
224 DRM_DEBUG("%s: Display bpc=%d, returned bpc=%d\n",
225 connector
->name
, connector
->display_info
.bpc
, bpc
);
231 radeon_connector_update_scratch_regs(struct drm_connector
*connector
, enum drm_connector_status status
)
233 struct drm_device
*dev
= connector
->dev
;
234 struct radeon_device
*rdev
= dev
->dev_private
;
235 struct drm_encoder
*best_encoder
= NULL
;
236 struct drm_encoder
*encoder
= NULL
;
237 const struct drm_connector_helper_funcs
*connector_funcs
= connector
->helper_private
;
241 best_encoder
= connector_funcs
->best_encoder(connector
);
243 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
244 if (connector
->encoder_ids
[i
] == 0)
247 encoder
= drm_encoder_find(connector
->dev
,
248 connector
->encoder_ids
[i
]);
252 if ((encoder
== best_encoder
) && (status
== connector_status_connected
))
257 if (rdev
->is_atom_bios
)
258 radeon_atombios_connected_scratch_regs(connector
, encoder
, connected
);
260 radeon_combios_connected_scratch_regs(connector
, encoder
, connected
);
265 static struct drm_encoder
*radeon_find_encoder(struct drm_connector
*connector
, int encoder_type
)
267 struct drm_encoder
*encoder
;
270 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
271 if (connector
->encoder_ids
[i
] == 0)
274 encoder
= drm_encoder_find(connector
->dev
, connector
->encoder_ids
[i
]);
278 if (encoder
->encoder_type
== encoder_type
)
284 struct edid
*radeon_connector_edid(struct drm_connector
*connector
)
286 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
287 struct drm_property_blob
*edid_blob
= connector
->edid_blob_ptr
;
289 if (radeon_connector
->edid
) {
290 return radeon_connector
->edid
;
291 } else if (edid_blob
) {
292 struct edid
*edid
= kmemdup(edid_blob
->data
, edid_blob
->length
, GFP_KERNEL
);
294 radeon_connector
->edid
= edid
;
296 return radeon_connector
->edid
;
299 static void radeon_connector_get_edid(struct drm_connector
*connector
)
301 struct drm_device
*dev
= connector
->dev
;
302 struct radeon_device
*rdev
= dev
->dev_private
;
303 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
305 if (radeon_connector
->edid
)
308 /* on hw with routers, select right port */
309 if (radeon_connector
->router
.ddc_valid
)
310 radeon_router_select_ddc_port(radeon_connector
);
312 if ((radeon_connector_encoder_get_dp_bridge_encoder_id(connector
) !=
313 ENCODER_OBJECT_ID_NONE
) &&
314 radeon_connector
->ddc_bus
->has_aux
) {
315 radeon_connector
->edid
= drm_get_edid_iic(connector
,
316 radeon_connector
->ddc_bus
->aux
.dev
->bsddev
);
317 } else if ((connector
->connector_type
== DRM_MODE_CONNECTOR_DisplayPort
) ||
318 (connector
->connector_type
== DRM_MODE_CONNECTOR_eDP
)) {
319 struct radeon_connector_atom_dig
*dig
= radeon_connector
->con_priv
;
321 if ((dig
->dp_sink_type
== CONNECTOR_OBJECT_ID_DISPLAYPORT
||
322 dig
->dp_sink_type
== CONNECTOR_OBJECT_ID_eDP
) &&
323 radeon_connector
->ddc_bus
->has_aux
)
324 radeon_connector
->edid
= drm_get_edid_iic(&radeon_connector
->base
,
325 radeon_connector
->ddc_bus
->aux
.dev
->bsddev
);
326 else if (radeon_connector
->ddc_bus
)
327 radeon_connector
->edid
= drm_get_edid_iic(&radeon_connector
->base
,
328 radeon_connector
->ddc_bus
->adapter_dev
);
330 } else if (radeon_connector
->ddc_bus
) {
331 radeon_connector
->edid
= drm_get_edid_iic(&radeon_connector
->base
,
332 radeon_connector
->ddc_bus
->adapter_dev
);
335 if (!radeon_connector
->edid
) {
336 /* don't fetch the edid from the vbios if ddc fails and runpm is
337 * enabled so we report disconnected.
339 if ((rdev
->flags
& RADEON_IS_PX
) && (radeon_runtime_pm
!= 0))
342 if (rdev
->is_atom_bios
) {
343 /* some laptops provide a hardcoded edid in rom for LCDs */
344 if (((connector
->connector_type
== DRM_MODE_CONNECTOR_LVDS
) ||
345 (connector
->connector_type
== DRM_MODE_CONNECTOR_eDP
)))
346 radeon_connector
->edid
= radeon_bios_get_hardcoded_edid(rdev
);
348 /* some servers provide a hardcoded edid in rom for KVMs */
349 radeon_connector
->edid
= radeon_bios_get_hardcoded_edid(rdev
);
354 static void radeon_connector_free_edid(struct drm_connector
*connector
)
356 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
358 if (radeon_connector
->edid
) {
359 kfree(radeon_connector
->edid
);
360 radeon_connector
->edid
= NULL
;
364 static int radeon_ddc_get_modes(struct drm_connector
*connector
)
366 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
369 if (radeon_connector
->edid
) {
370 drm_mode_connector_update_edid_property(connector
, radeon_connector
->edid
);
371 ret
= drm_add_edid_modes(connector
, radeon_connector
->edid
);
372 drm_edid_to_eld(connector
, radeon_connector
->edid
);
375 drm_mode_connector_update_edid_property(connector
, NULL
);
379 static struct drm_encoder
*radeon_best_single_encoder(struct drm_connector
*connector
)
381 int enc_id
= connector
->encoder_ids
[0];
382 /* pick the encoder ids */
384 return drm_encoder_find(connector
->dev
, enc_id
);
388 static void radeon_get_native_mode(struct drm_connector
*connector
)
390 struct drm_encoder
*encoder
= radeon_best_single_encoder(connector
);
391 struct radeon_encoder
*radeon_encoder
;
396 radeon_encoder
= to_radeon_encoder(encoder
);
398 if (!list_empty(&connector
->probed_modes
)) {
399 struct drm_display_mode
*preferred_mode
=
400 list_first_entry(&connector
->probed_modes
,
401 struct drm_display_mode
, head
);
403 radeon_encoder
->native_mode
= *preferred_mode
;
405 radeon_encoder
->native_mode
.clock
= 0;
410 * radeon_connector_analog_encoder_conflict_solve
411 * - search for other connectors sharing this encoder
412 * if priority is true, then set them disconnected if this is connected
413 * if priority is false, set us disconnected if they are connected
415 static enum drm_connector_status
416 radeon_connector_analog_encoder_conflict_solve(struct drm_connector
*connector
,
417 struct drm_encoder
*encoder
,
418 enum drm_connector_status current_status
,
421 struct drm_device
*dev
= connector
->dev
;
422 struct drm_connector
*conflict
;
423 struct radeon_connector
*radeon_conflict
;
426 list_for_each_entry(conflict
, &dev
->mode_config
.connector_list
, head
) {
427 if (conflict
== connector
)
430 radeon_conflict
= to_radeon_connector(conflict
);
431 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
432 if (conflict
->encoder_ids
[i
] == 0)
435 /* if the IDs match */
436 if (conflict
->encoder_ids
[i
] == encoder
->base
.id
) {
437 if (conflict
->status
!= connector_status_connected
)
440 if (radeon_conflict
->use_digital
)
443 if (priority
== true) {
444 DRM_DEBUG_KMS("1: conflicting encoders switching off %s\n",
446 DRM_DEBUG_KMS("in favor of %s\n",
448 conflict
->status
= connector_status_disconnected
;
449 radeon_connector_update_scratch_regs(conflict
, connector_status_disconnected
);
451 DRM_DEBUG_KMS("2: conflicting encoders switching off %s\n",
453 DRM_DEBUG_KMS("in favor of %s\n",
455 current_status
= connector_status_disconnected
;
461 return current_status
;
465 static struct drm_display_mode
*radeon_fp_native_mode(struct drm_encoder
*encoder
)
467 struct drm_device
*dev
= encoder
->dev
;
468 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
469 struct drm_display_mode
*mode
= NULL
;
470 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
472 if (native_mode
->hdisplay
!= 0 &&
473 native_mode
->vdisplay
!= 0 &&
474 native_mode
->clock
!= 0) {
475 mode
= drm_mode_duplicate(dev
, native_mode
);
476 mode
->type
= DRM_MODE_TYPE_PREFERRED
| DRM_MODE_TYPE_DRIVER
;
477 drm_mode_set_name(mode
);
479 DRM_DEBUG_KMS("Adding native panel mode %s\n", mode
->name
);
480 } else if (native_mode
->hdisplay
!= 0 &&
481 native_mode
->vdisplay
!= 0) {
482 /* mac laptops without an edid */
483 /* Note that this is not necessarily the exact panel mode,
484 * but an approximation based on the cvt formula. For these
485 * systems we should ideally read the mode info out of the
486 * registers or add a mode table, but this works and is much
489 mode
= drm_cvt_mode(dev
, native_mode
->hdisplay
, native_mode
->vdisplay
, 60, true, false, false);
490 mode
->type
= DRM_MODE_TYPE_PREFERRED
| DRM_MODE_TYPE_DRIVER
;
491 DRM_DEBUG_KMS("Adding cvt approximation of native panel mode %s\n", mode
->name
);
496 static void radeon_add_common_modes(struct drm_encoder
*encoder
, struct drm_connector
*connector
)
498 struct drm_device
*dev
= encoder
->dev
;
499 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
500 struct drm_display_mode
*mode
= NULL
;
501 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
506 } common_modes
[17] = {
526 for (i
= 0; i
< 17; i
++) {
527 if (radeon_encoder
->devices
& (ATOM_DEVICE_TV_SUPPORT
)) {
528 if (common_modes
[i
].w
> 1024 ||
529 common_modes
[i
].h
> 768)
532 if (radeon_encoder
->devices
& (ATOM_DEVICE_LCD_SUPPORT
)) {
533 if (common_modes
[i
].w
> native_mode
->hdisplay
||
534 common_modes
[i
].h
> native_mode
->vdisplay
||
535 (common_modes
[i
].w
== native_mode
->hdisplay
&&
536 common_modes
[i
].h
== native_mode
->vdisplay
))
539 if (common_modes
[i
].w
< 320 || common_modes
[i
].h
< 200)
542 mode
= drm_cvt_mode(dev
, common_modes
[i
].w
, common_modes
[i
].h
, 60, false, false, false);
543 drm_mode_probed_add(connector
, mode
);
547 static int radeon_connector_set_property(struct drm_connector
*connector
, struct drm_property
*property
,
550 struct drm_device
*dev
= connector
->dev
;
551 struct radeon_device
*rdev
= dev
->dev_private
;
552 struct drm_encoder
*encoder
;
553 struct radeon_encoder
*radeon_encoder
;
555 if (property
== rdev
->mode_info
.coherent_mode_property
) {
556 struct radeon_encoder_atom_dig
*dig
;
557 bool new_coherent_mode
;
559 /* need to find digital encoder on connector */
560 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TMDS
);
564 radeon_encoder
= to_radeon_encoder(encoder
);
566 if (!radeon_encoder
->enc_priv
)
569 dig
= radeon_encoder
->enc_priv
;
570 new_coherent_mode
= val
? true : false;
571 if (dig
->coherent_mode
!= new_coherent_mode
) {
572 dig
->coherent_mode
= new_coherent_mode
;
573 radeon_property_change_mode(&radeon_encoder
->base
);
577 if (property
== rdev
->mode_info
.audio_property
) {
578 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
579 /* need to find digital encoder on connector */
580 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TMDS
);
584 radeon_encoder
= to_radeon_encoder(encoder
);
586 if (radeon_connector
->audio
!= val
) {
587 radeon_connector
->audio
= val
;
588 radeon_property_change_mode(&radeon_encoder
->base
);
592 if (property
== rdev
->mode_info
.dither_property
) {
593 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
594 /* need to find digital encoder on connector */
595 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TMDS
);
599 radeon_encoder
= to_radeon_encoder(encoder
);
601 if (radeon_connector
->dither
!= val
) {
602 radeon_connector
->dither
= val
;
603 radeon_property_change_mode(&radeon_encoder
->base
);
607 if (property
== rdev
->mode_info
.underscan_property
) {
608 /* need to find digital encoder on connector */
609 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TMDS
);
613 radeon_encoder
= to_radeon_encoder(encoder
);
615 if (radeon_encoder
->underscan_type
!= val
) {
616 radeon_encoder
->underscan_type
= val
;
617 radeon_property_change_mode(&radeon_encoder
->base
);
621 if (property
== rdev
->mode_info
.underscan_hborder_property
) {
622 /* need to find digital encoder on connector */
623 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TMDS
);
627 radeon_encoder
= to_radeon_encoder(encoder
);
629 if (radeon_encoder
->underscan_hborder
!= val
) {
630 radeon_encoder
->underscan_hborder
= val
;
631 radeon_property_change_mode(&radeon_encoder
->base
);
635 if (property
== rdev
->mode_info
.underscan_vborder_property
) {
636 /* need to find digital encoder on connector */
637 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TMDS
);
641 radeon_encoder
= to_radeon_encoder(encoder
);
643 if (radeon_encoder
->underscan_vborder
!= val
) {
644 radeon_encoder
->underscan_vborder
= val
;
645 radeon_property_change_mode(&radeon_encoder
->base
);
649 if (property
== rdev
->mode_info
.tv_std_property
) {
650 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TVDAC
);
652 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_DAC
);
658 radeon_encoder
= to_radeon_encoder(encoder
);
659 if (!radeon_encoder
->enc_priv
)
661 if (ASIC_IS_AVIVO(rdev
) || radeon_r4xx_atom
) {
662 struct radeon_encoder_atom_dac
*dac_int
;
663 dac_int
= radeon_encoder
->enc_priv
;
664 dac_int
->tv_std
= val
;
666 struct radeon_encoder_tv_dac
*dac_int
;
667 dac_int
= radeon_encoder
->enc_priv
;
668 dac_int
->tv_std
= val
;
670 radeon_property_change_mode(&radeon_encoder
->base
);
673 if (property
== rdev
->mode_info
.load_detect_property
) {
674 struct radeon_connector
*radeon_connector
=
675 to_radeon_connector(connector
);
678 radeon_connector
->dac_load_detect
= false;
680 radeon_connector
->dac_load_detect
= true;
683 if (property
== rdev
->mode_info
.tmds_pll_property
) {
684 struct radeon_encoder_int_tmds
*tmds
= NULL
;
686 /* need to find digital encoder on connector */
687 encoder
= radeon_find_encoder(connector
, DRM_MODE_ENCODER_TMDS
);
691 radeon_encoder
= to_radeon_encoder(encoder
);
693 tmds
= radeon_encoder
->enc_priv
;
698 if (rdev
->is_atom_bios
)
699 ret
= radeon_atombios_get_tmds_info(radeon_encoder
, tmds
);
701 ret
= radeon_legacy_get_tmds_info_from_combios(radeon_encoder
, tmds
);
703 if (val
== 1 || ret
== false) {
704 radeon_legacy_get_tmds_info_from_table(radeon_encoder
, tmds
);
706 radeon_property_change_mode(&radeon_encoder
->base
);
709 if (property
== dev
->mode_config
.scaling_mode_property
) {
710 enum radeon_rmx_type rmx_type
;
712 if (connector
->encoder
)
713 radeon_encoder
= to_radeon_encoder(connector
->encoder
);
715 const struct drm_connector_helper_funcs
*connector_funcs
= connector
->helper_private
;
716 radeon_encoder
= to_radeon_encoder(connector_funcs
->best_encoder(connector
));
721 case DRM_MODE_SCALE_NONE
: rmx_type
= RMX_OFF
; break;
722 case DRM_MODE_SCALE_CENTER
: rmx_type
= RMX_CENTER
; break;
723 case DRM_MODE_SCALE_ASPECT
: rmx_type
= RMX_ASPECT
; break;
724 case DRM_MODE_SCALE_FULLSCREEN
: rmx_type
= RMX_FULL
; break;
726 if (radeon_encoder
->rmx_type
== rmx_type
)
729 if ((rmx_type
!= DRM_MODE_SCALE_NONE
) &&
730 (radeon_encoder
->native_mode
.clock
== 0))
733 radeon_encoder
->rmx_type
= rmx_type
;
735 radeon_property_change_mode(&radeon_encoder
->base
);
738 if (property
== rdev
->mode_info
.output_csc_property
) {
739 if (connector
->encoder
)
740 radeon_encoder
= to_radeon_encoder(connector
->encoder
);
742 const struct drm_connector_helper_funcs
*connector_funcs
= connector
->helper_private
;
743 radeon_encoder
= to_radeon_encoder(connector_funcs
->best_encoder(connector
));
746 if (radeon_encoder
->output_csc
== val
)
749 radeon_encoder
->output_csc
= val
;
751 if (connector
->encoder
->crtc
) {
752 struct drm_crtc
*crtc
= connector
->encoder
->crtc
;
753 const struct drm_crtc_helper_funcs
*crtc_funcs
= crtc
->helper_private
;
754 struct radeon_crtc
*radeon_crtc
= to_radeon_crtc(crtc
);
756 radeon_crtc
->output_csc
= radeon_encoder
->output_csc
;
758 (*crtc_funcs
->load_lut
)(crtc
);
765 static void radeon_fixup_lvds_native_mode(struct drm_encoder
*encoder
,
766 struct drm_connector
*connector
)
768 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
769 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
770 struct drm_display_mode
*t
, *mode
;
772 /* If the EDID preferred mode doesn't match the native mode, use it */
773 list_for_each_entry_safe(mode
, t
, &connector
->probed_modes
, head
) {
774 if (mode
->type
& DRM_MODE_TYPE_PREFERRED
) {
775 if (mode
->hdisplay
!= native_mode
->hdisplay
||
776 mode
->vdisplay
!= native_mode
->vdisplay
)
777 memcpy(native_mode
, mode
, sizeof(*mode
));
781 /* Try to get native mode details from EDID if necessary */
782 if (!native_mode
->clock
) {
783 list_for_each_entry_safe(mode
, t
, &connector
->probed_modes
, head
) {
784 if (mode
->hdisplay
== native_mode
->hdisplay
&&
785 mode
->vdisplay
== native_mode
->vdisplay
) {
786 *native_mode
= *mode
;
787 drm_mode_set_crtcinfo(native_mode
, CRTC_INTERLACE_HALVE_V
);
788 DRM_DEBUG_KMS("Determined LVDS native mode details from EDID\n");
794 if (!native_mode
->clock
) {
795 DRM_DEBUG_KMS("No LVDS native mode details, disabling RMX\n");
796 radeon_encoder
->rmx_type
= RMX_OFF
;
800 static int radeon_lvds_get_modes(struct drm_connector
*connector
)
802 // struct radeon_connector *radeon_connector = to_radeon_connector(connector);
803 struct drm_encoder
*encoder
;
805 struct drm_display_mode
*mode
;
807 // if (radeon_connector->ddc_bus) {
808 radeon_connector_get_edid(connector
);
809 ret
= radeon_ddc_get_modes(connector
);
811 encoder
= radeon_best_single_encoder(connector
);
813 radeon_fixup_lvds_native_mode(encoder
, connector
);
814 /* add scaled modes */
815 radeon_add_common_modes(encoder
, connector
);
821 encoder
= radeon_best_single_encoder(connector
);
825 /* we have no EDID modes */
826 mode
= radeon_fp_native_mode(encoder
);
829 drm_mode_probed_add(connector
, mode
);
830 /* add the width/height from vbios tables if available */
831 connector
->display_info
.width_mm
= mode
->width_mm
;
832 connector
->display_info
.height_mm
= mode
->height_mm
;
833 /* add scaled modes */
834 radeon_add_common_modes(encoder
, connector
);
840 static int radeon_lvds_mode_valid(struct drm_connector
*connector
,
841 struct drm_display_mode
*mode
)
843 struct drm_encoder
*encoder
= radeon_best_single_encoder(connector
);
845 if ((mode
->hdisplay
< 320) || (mode
->vdisplay
< 240))
849 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
850 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
852 /* AVIVO hardware supports downscaling modes larger than the panel
853 * to the panel size, but I'm not sure this is desirable.
855 if ((mode
->hdisplay
> native_mode
->hdisplay
) ||
856 (mode
->vdisplay
> native_mode
->vdisplay
))
859 /* if scaling is disabled, block non-native modes */
860 if (radeon_encoder
->rmx_type
== RMX_OFF
) {
861 if ((mode
->hdisplay
!= native_mode
->hdisplay
) ||
862 (mode
->vdisplay
!= native_mode
->vdisplay
))
870 static enum drm_connector_status
871 radeon_lvds_detect(struct drm_connector
*connector
, bool force
)
873 struct drm_device
*dev
= connector
->dev
;
874 struct radeon_device
*rdev
= dev
->dev_private
;
875 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
876 struct drm_encoder
*encoder
= radeon_best_single_encoder(connector
);
877 enum drm_connector_status ret
= connector_status_disconnected
;
881 r
= pm_runtime_get_sync(connector
->dev
->dev
);
883 return connector_status_disconnected
;
887 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
888 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
890 /* check if panel is valid */
891 if (native_mode
->hdisplay
>= 320 && native_mode
->vdisplay
>= 240)
892 ret
= connector_status_connected
;
893 /* don't fetch the edid from the vbios if ddc fails and runpm is
894 * enabled so we report disconnected.
896 if ((rdev
->flags
& RADEON_IS_PX
) && (radeon_runtime_pm
!= 0))
897 ret
= connector_status_disconnected
;
900 /* check for edid as well */
901 radeon_connector_get_edid(connector
);
902 if (radeon_connector
->edid
)
903 ret
= connector_status_connected
;
904 #if defined(__DragonFly__)
906 if (radeon_connector
->ddc_bus
) {
907 radeon_connector
->edid
= drm_get_edid_iic(&radeon_connector
->base
,
908 radeon_connector
->ddc_bus
->adapter_dev
);
909 if (radeon_connector
->edid
)
910 ret
= connector_status_connected
;
914 /* check acpi lid status ??? */
916 radeon_connector_update_scratch_regs(connector
, ret
);
918 pm_runtime_mark_last_busy(connector
->dev
->dev
);
919 pm_runtime_put_autosuspend(connector
->dev
->dev
);
924 static void radeon_connector_destroy(struct drm_connector
*connector
)
926 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
928 radeon_connector_free_edid(connector
);
929 kfree(radeon_connector
->con_priv
);
930 drm_connector_unregister(connector
);
931 drm_connector_cleanup(connector
);
935 static int radeon_lvds_set_property(struct drm_connector
*connector
,
936 struct drm_property
*property
,
939 struct drm_device
*dev
= connector
->dev
;
940 struct radeon_encoder
*radeon_encoder
;
941 enum radeon_rmx_type rmx_type
;
944 if (property
!= dev
->mode_config
.scaling_mode_property
)
947 if (connector
->encoder
)
948 radeon_encoder
= to_radeon_encoder(connector
->encoder
);
950 const struct drm_connector_helper_funcs
*connector_funcs
= connector
->helper_private
;
951 radeon_encoder
= to_radeon_encoder(connector_funcs
->best_encoder(connector
));
955 case DRM_MODE_SCALE_NONE
: rmx_type
= RMX_OFF
; break;
956 case DRM_MODE_SCALE_CENTER
: rmx_type
= RMX_CENTER
; break;
957 case DRM_MODE_SCALE_ASPECT
: rmx_type
= RMX_ASPECT
; break;
959 case DRM_MODE_SCALE_FULLSCREEN
: rmx_type
= RMX_FULL
; break;
961 if (radeon_encoder
->rmx_type
== rmx_type
)
964 radeon_encoder
->rmx_type
= rmx_type
;
966 radeon_property_change_mode(&radeon_encoder
->base
);
971 static const struct drm_connector_helper_funcs radeon_lvds_connector_helper_funcs
= {
972 .get_modes
= radeon_lvds_get_modes
,
973 .mode_valid
= radeon_lvds_mode_valid
,
974 .best_encoder
= radeon_best_single_encoder
,
977 static const struct drm_connector_funcs radeon_lvds_connector_funcs
= {
978 .dpms
= drm_helper_connector_dpms
,
979 .detect
= radeon_lvds_detect
,
980 .fill_modes
= drm_helper_probe_single_connector_modes
,
981 .destroy
= radeon_connector_destroy
,
982 .set_property
= radeon_lvds_set_property
,
985 static int radeon_vga_get_modes(struct drm_connector
*connector
)
989 radeon_connector_get_edid(connector
);
990 ret
= radeon_ddc_get_modes(connector
);
992 radeon_get_native_mode(connector
);
997 static int radeon_vga_mode_valid(struct drm_connector
*connector
,
998 struct drm_display_mode
*mode
)
1000 struct drm_device
*dev
= connector
->dev
;
1001 struct radeon_device
*rdev
= dev
->dev_private
;
1003 /* XXX check mode bandwidth */
1005 if ((mode
->clock
/ 10) > rdev
->clock
.max_pixel_clock
)
1006 return MODE_CLOCK_HIGH
;
1011 static enum drm_connector_status
1012 radeon_vga_detect(struct drm_connector
*connector
, bool force
)
1014 struct drm_device
*dev
= connector
->dev
;
1015 struct radeon_device
*rdev
= dev
->dev_private
;
1016 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1017 struct drm_encoder
*encoder
;
1018 const struct drm_encoder_helper_funcs
*encoder_funcs
;
1020 enum drm_connector_status ret
= connector_status_disconnected
;
1024 r
= pm_runtime_get_sync(connector
->dev
->dev
);
1026 return connector_status_disconnected
;
1029 encoder
= radeon_best_single_encoder(connector
);
1031 ret
= connector_status_disconnected
;
1033 if (radeon_connector
->ddc_bus
)
1034 dret
= radeon_ddc_probe(radeon_connector
, false);
1036 radeon_connector
->detected_by_load
= false;
1037 radeon_connector_free_edid(connector
);
1038 radeon_connector_get_edid(connector
);
1040 if (!radeon_connector
->edid
) {
1041 DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
1043 ret
= connector_status_connected
;
1045 radeon_connector
->use_digital
=
1046 !!(radeon_connector
->edid
->input
& DRM_EDID_INPUT_DIGITAL
);
1048 /* some oems have boards with separate digital and analog connectors
1049 * with a shared ddc line (often vga + hdmi)
1051 if (radeon_connector
->use_digital
&& radeon_connector
->shared_ddc
) {
1052 radeon_connector_free_edid(connector
);
1053 ret
= connector_status_disconnected
;
1055 ret
= connector_status_connected
;
1060 /* if we aren't forcing don't do destructive polling */
1062 /* only return the previous status if we last
1063 * detected a monitor via load.
1065 if (radeon_connector
->detected_by_load
)
1066 ret
= connector
->status
;
1070 if (radeon_connector
->dac_load_detect
&& encoder
) {
1071 encoder_funcs
= encoder
->helper_private
;
1072 ret
= encoder_funcs
->detect(encoder
, connector
);
1073 if (ret
!= connector_status_disconnected
)
1074 radeon_connector
->detected_by_load
= true;
1078 if (ret
== connector_status_connected
)
1079 ret
= radeon_connector_analog_encoder_conflict_solve(connector
, encoder
, ret
, true);
1081 /* RN50 and some RV100 asics in servers often have a hardcoded EDID in the
1082 * vbios to deal with KVMs. If we have one and are not able to detect a monitor
1083 * by other means, assume the CRT is connected and use that EDID.
1085 if ((!rdev
->is_atom_bios
) &&
1086 (ret
== connector_status_disconnected
) &&
1087 rdev
->mode_info
.bios_hardcoded_edid_size
) {
1088 ret
= connector_status_connected
;
1091 radeon_connector_update_scratch_regs(connector
, ret
);
1095 pm_runtime_mark_last_busy(connector
->dev
->dev
);
1096 pm_runtime_put_autosuspend(connector
->dev
->dev
);
1102 static const struct drm_connector_helper_funcs radeon_vga_connector_helper_funcs
= {
1103 .get_modes
= radeon_vga_get_modes
,
1104 .mode_valid
= radeon_vga_mode_valid
,
1105 .best_encoder
= radeon_best_single_encoder
,
1108 static const struct drm_connector_funcs radeon_vga_connector_funcs
= {
1109 .dpms
= drm_helper_connector_dpms
,
1110 .detect
= radeon_vga_detect
,
1111 .fill_modes
= drm_helper_probe_single_connector_modes
,
1112 .destroy
= radeon_connector_destroy
,
1113 .set_property
= radeon_connector_set_property
,
1116 static int radeon_tv_get_modes(struct drm_connector
*connector
)
1118 struct drm_device
*dev
= connector
->dev
;
1119 struct radeon_device
*rdev
= dev
->dev_private
;
1120 struct drm_display_mode
*tv_mode
;
1121 struct drm_encoder
*encoder
;
1123 encoder
= radeon_best_single_encoder(connector
);
1127 /* avivo chips can scale any mode */
1128 if (rdev
->family
>= CHIP_RS600
)
1129 /* add scaled modes */
1130 radeon_add_common_modes(encoder
, connector
);
1132 /* only 800x600 is supported right now on pre-avivo chips */
1133 tv_mode
= drm_cvt_mode(dev
, 800, 600, 60, false, false, false);
1134 tv_mode
->type
= DRM_MODE_TYPE_DRIVER
| DRM_MODE_TYPE_PREFERRED
;
1135 drm_mode_probed_add(connector
, tv_mode
);
1140 static int radeon_tv_mode_valid(struct drm_connector
*connector
,
1141 struct drm_display_mode
*mode
)
1143 if ((mode
->hdisplay
> 1024) || (mode
->vdisplay
> 768))
1144 return MODE_CLOCK_RANGE
;
1148 static enum drm_connector_status
1149 radeon_tv_detect(struct drm_connector
*connector
, bool force
)
1151 struct drm_encoder
*encoder
;
1152 const struct drm_encoder_helper_funcs
*encoder_funcs
;
1153 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1154 enum drm_connector_status ret
= connector_status_disconnected
;
1159 if (!radeon_connector
->dac_load_detect
)
1163 r
= pm_runtime_get_sync(connector
->dev
->dev
);
1165 return connector_status_disconnected
;
1168 encoder
= radeon_best_single_encoder(connector
);
1170 ret
= connector_status_disconnected
;
1172 encoder_funcs
= encoder
->helper_private
;
1173 ret
= encoder_funcs
->detect(encoder
, connector
);
1175 if (ret
== connector_status_connected
)
1176 ret
= radeon_connector_analog_encoder_conflict_solve(connector
, encoder
, ret
, false);
1177 radeon_connector_update_scratch_regs(connector
, ret
);
1179 pm_runtime_mark_last_busy(connector
->dev
->dev
);
1180 pm_runtime_put_autosuspend(connector
->dev
->dev
);
1185 static const struct drm_connector_helper_funcs radeon_tv_connector_helper_funcs
= {
1186 .get_modes
= radeon_tv_get_modes
,
1187 .mode_valid
= radeon_tv_mode_valid
,
1188 .best_encoder
= radeon_best_single_encoder
,
1191 static const struct drm_connector_funcs radeon_tv_connector_funcs
= {
1192 .dpms
= drm_helper_connector_dpms
,
1193 .detect
= radeon_tv_detect
,
1194 .fill_modes
= drm_helper_probe_single_connector_modes
,
1195 .destroy
= radeon_connector_destroy
,
1196 .set_property
= radeon_connector_set_property
,
1199 static bool radeon_check_hpd_status_unchanged(struct drm_connector
*connector
)
1201 struct drm_device
*dev
= connector
->dev
;
1202 struct radeon_device
*rdev
= dev
->dev_private
;
1203 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1204 enum drm_connector_status status
;
1206 /* We only trust HPD on R600 and newer ASICS. */
1207 if (rdev
->family
>= CHIP_R600
1208 && radeon_connector
->hpd
.hpd
!= RADEON_HPD_NONE
) {
1209 if (radeon_hpd_sense(rdev
, radeon_connector
->hpd
.hpd
))
1210 status
= connector_status_connected
;
1212 status
= connector_status_disconnected
;
1213 if (connector
->status
== status
)
1221 * DVI is complicated
1222 * Do a DDC probe, if DDC probe passes, get the full EDID so
1223 * we can do analog/digital monitor detection at this point.
1224 * If the monitor is an analog monitor or we got no DDC,
1225 * we need to find the DAC encoder object for this connector.
1226 * If we got no DDC, we do load detection on the DAC encoder object.
1227 * If we got analog DDC or load detection passes on the DAC encoder
1228 * we have to check if this analog encoder is shared with anyone else (TV)
1229 * if its shared we have to set the other connector to disconnected.
1231 static enum drm_connector_status
1232 radeon_dvi_detect(struct drm_connector
*connector
, bool force
)
1234 struct drm_device
*dev
= connector
->dev
;
1235 struct radeon_device
*rdev
= dev
->dev_private
;
1236 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1237 struct drm_encoder
*encoder
= NULL
;
1238 const struct drm_encoder_helper_funcs
*encoder_funcs
;
1240 enum drm_connector_status ret
= connector_status_disconnected
;
1241 bool dret
= false, broken_edid
= false;
1244 r
= pm_runtime_get_sync(connector
->dev
->dev
);
1246 return connector_status_disconnected
;
1249 if (!force
&& radeon_check_hpd_status_unchanged(connector
)) {
1250 ret
= connector
->status
;
1254 if (radeon_connector
->ddc_bus
)
1255 dret
= radeon_ddc_probe(radeon_connector
, false);
1257 radeon_connector
->detected_by_load
= false;
1258 radeon_connector_free_edid(connector
);
1259 radeon_connector_get_edid(connector
);
1261 if (!radeon_connector
->edid
) {
1262 DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
1264 /* rs690 seems to have a problem with connectors not existing and always
1265 * return a block of 0's. If we see this just stop polling on this output */
1266 if ((rdev
->family
== CHIP_RS690
|| rdev
->family
== CHIP_RS740
) &&
1267 radeon_connector
->base
.null_edid_counter
) {
1268 ret
= connector_status_disconnected
;
1269 DRM_ERROR("%s: detected RS690 floating bus bug, stopping ddc detect\n",
1271 radeon_connector
->ddc_bus
= NULL
;
1273 ret
= connector_status_connected
;
1274 broken_edid
= true; /* defer use_digital to later */
1277 radeon_connector
->use_digital
=
1278 !!(radeon_connector
->edid
->input
& DRM_EDID_INPUT_DIGITAL
);
1280 /* some oems have boards with separate digital and analog connectors
1281 * with a shared ddc line (often vga + hdmi)
1283 if ((!radeon_connector
->use_digital
) && radeon_connector
->shared_ddc
) {
1284 radeon_connector_free_edid(connector
);
1285 ret
= connector_status_disconnected
;
1287 ret
= connector_status_connected
;
1289 /* This gets complicated. We have boards with VGA + HDMI with a
1290 * shared DDC line and we have boards with DVI-D + HDMI with a shared
1291 * DDC line. The latter is more complex because with DVI<->HDMI adapters
1292 * you don't really know what's connected to which port as both are digital.
1294 if (radeon_connector
->shared_ddc
&& (ret
== connector_status_connected
)) {
1295 struct drm_connector
*list_connector
;
1296 struct radeon_connector
*list_radeon_connector
;
1297 list_for_each_entry(list_connector
, &dev
->mode_config
.connector_list
, head
) {
1298 if (connector
== list_connector
)
1300 list_radeon_connector
= to_radeon_connector(list_connector
);
1301 if (list_radeon_connector
->shared_ddc
&&
1302 (list_radeon_connector
->ddc_bus
->rec
.i2c_id
==
1303 radeon_connector
->ddc_bus
->rec
.i2c_id
)) {
1304 /* cases where both connectors are digital */
1305 if (list_connector
->connector_type
!= DRM_MODE_CONNECTOR_VGA
) {
1306 /* hpd is our only option in this case */
1307 if (!radeon_hpd_sense(rdev
, radeon_connector
->hpd
.hpd
)) {
1308 radeon_connector_free_edid(connector
);
1309 ret
= connector_status_disconnected
;
1318 if ((ret
== connector_status_connected
) && (radeon_connector
->use_digital
== true))
1321 /* DVI-D and HDMI-A are digital only */
1322 if ((connector
->connector_type
== DRM_MODE_CONNECTOR_DVID
) ||
1323 (connector
->connector_type
== DRM_MODE_CONNECTOR_HDMIA
))
1326 /* if we aren't forcing don't do destructive polling */
1328 /* only return the previous status if we last
1329 * detected a monitor via load.
1331 if (radeon_connector
->detected_by_load
)
1332 ret
= connector
->status
;
1336 /* find analog encoder */
1337 if (radeon_connector
->dac_load_detect
) {
1338 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
1339 if (connector
->encoder_ids
[i
] == 0)
1342 encoder
= drm_encoder_find(connector
->dev
,
1343 connector
->encoder_ids
[i
]);
1347 if (encoder
->encoder_type
!= DRM_MODE_ENCODER_DAC
&&
1348 encoder
->encoder_type
!= DRM_MODE_ENCODER_TVDAC
)
1351 encoder_funcs
= encoder
->helper_private
;
1352 if (encoder_funcs
->detect
) {
1354 if (ret
!= connector_status_connected
) {
1355 /* deal with analog monitors without DDC */
1356 ret
= encoder_funcs
->detect(encoder
, connector
);
1357 if (ret
== connector_status_connected
) {
1358 radeon_connector
->use_digital
= false;
1360 if (ret
!= connector_status_disconnected
)
1361 radeon_connector
->detected_by_load
= true;
1364 enum drm_connector_status lret
;
1365 /* assume digital unless load detected otherwise */
1366 radeon_connector
->use_digital
= true;
1367 lret
= encoder_funcs
->detect(encoder
, connector
);
1368 DRM_DEBUG_KMS("load_detect %x returned: %x\n",encoder
->encoder_type
,lret
);
1369 if (lret
== connector_status_connected
)
1370 radeon_connector
->use_digital
= false;
1377 if ((ret
== connector_status_connected
) && (radeon_connector
->use_digital
== false) &&
1379 ret
= radeon_connector_analog_encoder_conflict_solve(connector
, encoder
, ret
, true);
1382 /* RN50 and some RV100 asics in servers often have a hardcoded EDID in the
1383 * vbios to deal with KVMs. If we have one and are not able to detect a monitor
1384 * by other means, assume the DFP is connected and use that EDID. In most
1385 * cases the DVI port is actually a virtual KVM port connected to the service
1389 if ((!rdev
->is_atom_bios
) &&
1390 (ret
== connector_status_disconnected
) &&
1391 rdev
->mode_info
.bios_hardcoded_edid_size
) {
1392 radeon_connector
->use_digital
= true;
1393 ret
= connector_status_connected
;
1396 /* updated in get modes as well since we need to know if it's analog or digital */
1397 radeon_connector_update_scratch_regs(connector
, ret
);
1399 if ((radeon_audio
!= 0) && radeon_connector
->use_digital
) {
1400 const struct drm_connector_helper_funcs
*connector_funcs
=
1401 connector
->helper_private
;
1403 encoder
= connector_funcs
->best_encoder(connector
);
1404 if (encoder
&& (encoder
->encoder_type
== DRM_MODE_ENCODER_TMDS
)) {
1405 radeon_connector_get_edid(connector
);
1406 radeon_audio_detect(connector
, encoder
, ret
);
1412 pm_runtime_mark_last_busy(connector
->dev
->dev
);
1413 pm_runtime_put_autosuspend(connector
->dev
->dev
);
1419 /* okay need to be smart in here about which encoder to pick */
1420 static struct drm_encoder
*radeon_dvi_encoder(struct drm_connector
*connector
)
1422 int enc_id
= connector
->encoder_ids
[0];
1423 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1424 struct drm_encoder
*encoder
;
1426 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
1427 if (connector
->encoder_ids
[i
] == 0)
1430 encoder
= drm_encoder_find(connector
->dev
, connector
->encoder_ids
[i
]);
1434 if (radeon_connector
->use_digital
== true) {
1435 if (encoder
->encoder_type
== DRM_MODE_ENCODER_TMDS
)
1438 if (encoder
->encoder_type
== DRM_MODE_ENCODER_DAC
||
1439 encoder
->encoder_type
== DRM_MODE_ENCODER_TVDAC
)
1444 /* see if we have a default encoder TODO */
1446 /* then check use digitial */
1447 /* pick the first one */
1449 return drm_encoder_find(connector
->dev
, enc_id
);
1453 static void radeon_dvi_force(struct drm_connector
*connector
)
1455 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1456 if (connector
->force
== DRM_FORCE_ON
)
1457 radeon_connector
->use_digital
= false;
1458 if (connector
->force
== DRM_FORCE_ON_DIGITAL
)
1459 radeon_connector
->use_digital
= true;
1462 static int radeon_dvi_mode_valid(struct drm_connector
*connector
,
1463 struct drm_display_mode
*mode
)
1465 struct drm_device
*dev
= connector
->dev
;
1466 struct radeon_device
*rdev
= dev
->dev_private
;
1467 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1469 /* XXX check mode bandwidth */
1471 /* clocks over 135 MHz have heat issues with DVI on RV100 */
1472 if (radeon_connector
->use_digital
&&
1473 (rdev
->family
== CHIP_RV100
) &&
1474 (mode
->clock
> 135000))
1475 return MODE_CLOCK_HIGH
;
1477 if (radeon_connector
->use_digital
&& (mode
->clock
> 165000)) {
1478 if ((radeon_connector
->connector_object_id
== CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_I
) ||
1479 (radeon_connector
->connector_object_id
== CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_D
) ||
1480 (radeon_connector
->connector_object_id
== CONNECTOR_OBJECT_ID_HDMI_TYPE_B
))
1482 else if (ASIC_IS_DCE6(rdev
) && drm_detect_hdmi_monitor(radeon_connector_edid(connector
))) {
1483 /* HDMI 1.3+ supports max clock of 340 Mhz */
1484 if (mode
->clock
> 340000)
1485 return MODE_CLOCK_HIGH
;
1489 return MODE_CLOCK_HIGH
;
1493 /* check against the max pixel clock */
1494 if ((mode
->clock
/ 10) > rdev
->clock
.max_pixel_clock
)
1495 return MODE_CLOCK_HIGH
;
1500 static const struct drm_connector_helper_funcs radeon_dvi_connector_helper_funcs
= {
1501 .get_modes
= radeon_vga_get_modes
,
1502 .mode_valid
= radeon_dvi_mode_valid
,
1503 .best_encoder
= radeon_dvi_encoder
,
1506 static const struct drm_connector_funcs radeon_dvi_connector_funcs
= {
1507 .dpms
= drm_helper_connector_dpms
,
1508 .detect
= radeon_dvi_detect
,
1509 .fill_modes
= drm_helper_probe_single_connector_modes
,
1510 .set_property
= radeon_connector_set_property
,
1511 .destroy
= radeon_connector_destroy
,
1512 .force
= radeon_dvi_force
,
1515 static int radeon_dp_get_modes(struct drm_connector
*connector
)
1517 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1518 struct radeon_connector_atom_dig
*radeon_dig_connector
= radeon_connector
->con_priv
;
1519 struct drm_encoder
*encoder
= radeon_best_single_encoder(connector
);
1522 if ((connector
->connector_type
== DRM_MODE_CONNECTOR_eDP
) ||
1523 (connector
->connector_type
== DRM_MODE_CONNECTOR_LVDS
)) {
1524 struct drm_display_mode
*mode
;
1526 if (connector
->connector_type
== DRM_MODE_CONNECTOR_eDP
) {
1527 if (!radeon_dig_connector
->edp_on
)
1528 atombios_set_edp_panel_power(connector
,
1529 ATOM_TRANSMITTER_ACTION_POWER_ON
);
1530 radeon_connector_get_edid(connector
);
1531 ret
= radeon_ddc_get_modes(connector
);
1532 if (!radeon_dig_connector
->edp_on
)
1533 atombios_set_edp_panel_power(connector
,
1534 ATOM_TRANSMITTER_ACTION_POWER_OFF
);
1536 /* need to setup ddc on the bridge */
1537 if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector
) !=
1538 ENCODER_OBJECT_ID_NONE
) {
1540 radeon_atom_ext_encoder_setup_ddc(encoder
);
1542 radeon_connector_get_edid(connector
);
1543 ret
= radeon_ddc_get_modes(connector
);
1548 radeon_fixup_lvds_native_mode(encoder
, connector
);
1549 /* add scaled modes */
1550 radeon_add_common_modes(encoder
, connector
);
1558 /* we have no EDID modes */
1559 mode
= radeon_fp_native_mode(encoder
);
1562 drm_mode_probed_add(connector
, mode
);
1563 /* add the width/height from vbios tables if available */
1564 connector
->display_info
.width_mm
= mode
->width_mm
;
1565 connector
->display_info
.height_mm
= mode
->height_mm
;
1566 /* add scaled modes */
1567 radeon_add_common_modes(encoder
, connector
);
1570 /* need to setup ddc on the bridge */
1571 if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector
) !=
1572 ENCODER_OBJECT_ID_NONE
) {
1574 radeon_atom_ext_encoder_setup_ddc(encoder
);
1576 radeon_connector_get_edid(connector
);
1577 ret
= radeon_ddc_get_modes(connector
);
1579 radeon_get_native_mode(connector
);
1585 u16
radeon_connector_encoder_get_dp_bridge_encoder_id(struct drm_connector
*connector
)
1587 struct drm_encoder
*encoder
;
1588 struct radeon_encoder
*radeon_encoder
;
1591 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
1592 if (connector
->encoder_ids
[i
] == 0)
1595 encoder
= drm_encoder_find(connector
->dev
, connector
->encoder_ids
[i
]);
1599 radeon_encoder
= to_radeon_encoder(encoder
);
1601 switch (radeon_encoder
->encoder_id
) {
1602 case ENCODER_OBJECT_ID_TRAVIS
:
1603 case ENCODER_OBJECT_ID_NUTMEG
:
1604 return radeon_encoder
->encoder_id
;
1610 return ENCODER_OBJECT_ID_NONE
;
1613 static bool radeon_connector_encoder_is_hbr2(struct drm_connector
*connector
)
1615 struct drm_encoder
*encoder
;
1616 struct radeon_encoder
*radeon_encoder
;
1620 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
1621 if (connector
->encoder_ids
[i
] == 0)
1624 encoder
= drm_encoder_find(connector
->dev
, connector
->encoder_ids
[i
]);
1628 radeon_encoder
= to_radeon_encoder(encoder
);
1629 if (radeon_encoder
->caps
& ATOM_ENCODER_CAP_RECORD_HBR2
)
1636 bool radeon_connector_is_dp12_capable(struct drm_connector
*connector
)
1638 struct drm_device
*dev
= connector
->dev
;
1639 struct radeon_device
*rdev
= dev
->dev_private
;
1641 if (ASIC_IS_DCE5(rdev
) &&
1642 (rdev
->clock
.default_dispclk
>= 53900) &&
1643 radeon_connector_encoder_is_hbr2(connector
)) {
1650 static enum drm_connector_status
1651 radeon_dp_detect(struct drm_connector
*connector
, bool force
)
1653 struct drm_device
*dev
= connector
->dev
;
1654 struct radeon_device
*rdev
= dev
->dev_private
;
1655 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1656 enum drm_connector_status ret
= connector_status_disconnected
;
1657 struct radeon_connector_atom_dig
*radeon_dig_connector
= radeon_connector
->con_priv
;
1658 struct drm_encoder
*encoder
= radeon_best_single_encoder(connector
);
1662 r
= pm_runtime_get_sync(connector
->dev
->dev
);
1664 return connector_status_disconnected
;
1667 if (!force
&& radeon_check_hpd_status_unchanged(connector
)) {
1668 ret
= connector
->status
;
1672 radeon_connector_free_edid(connector
);
1674 if ((connector
->connector_type
== DRM_MODE_CONNECTOR_eDP
) ||
1675 (connector
->connector_type
== DRM_MODE_CONNECTOR_LVDS
)) {
1677 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
1678 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
1680 /* check if panel is valid */
1681 if (native_mode
->hdisplay
>= 320 && native_mode
->vdisplay
>= 240)
1682 ret
= connector_status_connected
;
1683 /* don't fetch the edid from the vbios if ddc fails and runpm is
1684 * enabled so we report disconnected.
1686 if ((rdev
->flags
& RADEON_IS_PX
) && (radeon_runtime_pm
!= 0))
1687 ret
= connector_status_disconnected
;
1689 /* eDP is always DP */
1690 radeon_dig_connector
->dp_sink_type
= CONNECTOR_OBJECT_ID_DISPLAYPORT
;
1691 if (!radeon_dig_connector
->edp_on
)
1692 atombios_set_edp_panel_power(connector
,
1693 ATOM_TRANSMITTER_ACTION_POWER_ON
);
1694 if (radeon_dp_getdpcd(radeon_connector
))
1695 ret
= connector_status_connected
;
1696 if (!radeon_dig_connector
->edp_on
)
1697 atombios_set_edp_panel_power(connector
,
1698 ATOM_TRANSMITTER_ACTION_POWER_OFF
);
1699 } else if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector
) !=
1700 ENCODER_OBJECT_ID_NONE
) {
1701 /* DP bridges are always DP */
1702 radeon_dig_connector
->dp_sink_type
= CONNECTOR_OBJECT_ID_DISPLAYPORT
;
1703 /* get the DPCD from the bridge */
1704 radeon_dp_getdpcd(radeon_connector
);
1707 /* setup ddc on the bridge */
1708 radeon_atom_ext_encoder_setup_ddc(encoder
);
1709 /* bridge chips are always aux */
1710 if (radeon_ddc_probe(radeon_connector
, true)) /* try DDC */
1711 ret
= connector_status_connected
;
1712 else if (radeon_connector
->dac_load_detect
) { /* try load detection */
1713 const struct drm_encoder_helper_funcs
*encoder_funcs
= encoder
->helper_private
;
1714 ret
= encoder_funcs
->detect(encoder
, connector
);
1718 radeon_dig_connector
->dp_sink_type
= radeon_dp_getsinktype(radeon_connector
);
1719 if (radeon_hpd_sense(rdev
, radeon_connector
->hpd
.hpd
)) {
1720 ret
= connector_status_connected
;
1721 if (radeon_dig_connector
->dp_sink_type
== CONNECTOR_OBJECT_ID_DISPLAYPORT
)
1722 radeon_dp_getdpcd(radeon_connector
);
1724 if (radeon_dig_connector
->dp_sink_type
== CONNECTOR_OBJECT_ID_DISPLAYPORT
) {
1725 if (radeon_dp_getdpcd(radeon_connector
))
1726 ret
= connector_status_connected
;
1728 /* try non-aux ddc (DP to DVI/HDMI/etc. adapter) */
1729 if (radeon_ddc_probe(radeon_connector
, false))
1730 ret
= connector_status_connected
;
1735 radeon_connector_update_scratch_regs(connector
, ret
);
1737 if ((radeon_audio
!= 0) && encoder
) {
1738 radeon_connector_get_edid(connector
);
1739 radeon_audio_detect(connector
, encoder
, ret
);
1744 pm_runtime_mark_last_busy(connector
->dev
->dev
);
1745 pm_runtime_put_autosuspend(connector
->dev
->dev
);
1751 static int radeon_dp_mode_valid(struct drm_connector
*connector
,
1752 struct drm_display_mode
*mode
)
1754 struct drm_device
*dev
= connector
->dev
;
1755 struct radeon_device
*rdev
= dev
->dev_private
;
1756 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1757 struct radeon_connector_atom_dig
*radeon_dig_connector
= radeon_connector
->con_priv
;
1759 /* XXX check mode bandwidth */
1761 if ((connector
->connector_type
== DRM_MODE_CONNECTOR_eDP
) ||
1762 (connector
->connector_type
== DRM_MODE_CONNECTOR_LVDS
)) {
1763 struct drm_encoder
*encoder
= radeon_best_single_encoder(connector
);
1765 if ((mode
->hdisplay
< 320) || (mode
->vdisplay
< 240))
1769 struct radeon_encoder
*radeon_encoder
= to_radeon_encoder(encoder
);
1770 struct drm_display_mode
*native_mode
= &radeon_encoder
->native_mode
;
1772 /* AVIVO hardware supports downscaling modes larger than the panel
1773 * to the panel size, but I'm not sure this is desirable.
1775 if ((mode
->hdisplay
> native_mode
->hdisplay
) ||
1776 (mode
->vdisplay
> native_mode
->vdisplay
))
1779 /* if scaling is disabled, block non-native modes */
1780 if (radeon_encoder
->rmx_type
== RMX_OFF
) {
1781 if ((mode
->hdisplay
!= native_mode
->hdisplay
) ||
1782 (mode
->vdisplay
!= native_mode
->vdisplay
))
1787 if ((radeon_dig_connector
->dp_sink_type
== CONNECTOR_OBJECT_ID_DISPLAYPORT
) ||
1788 (radeon_dig_connector
->dp_sink_type
== CONNECTOR_OBJECT_ID_eDP
)) {
1789 return radeon_dp_mode_valid_helper(connector
, mode
);
1791 if (ASIC_IS_DCE6(rdev
) && drm_detect_hdmi_monitor(radeon_connector_edid(connector
))) {
1792 /* HDMI 1.3+ supports max clock of 340 Mhz */
1793 if (mode
->clock
> 340000)
1794 return MODE_CLOCK_HIGH
;
1796 if (mode
->clock
> 165000)
1797 return MODE_CLOCK_HIGH
;
1805 static const struct drm_connector_helper_funcs radeon_dp_connector_helper_funcs
= {
1806 .get_modes
= radeon_dp_get_modes
,
1807 .mode_valid
= radeon_dp_mode_valid
,
1808 .best_encoder
= radeon_dvi_encoder
,
1811 static const struct drm_connector_funcs radeon_dp_connector_funcs
= {
1812 .dpms
= drm_helper_connector_dpms
,
1813 .detect
= radeon_dp_detect
,
1814 .fill_modes
= drm_helper_probe_single_connector_modes
,
1815 .set_property
= radeon_connector_set_property
,
1816 .destroy
= radeon_connector_destroy
,
1817 .force
= radeon_dvi_force
,
1820 static const struct drm_connector_funcs radeon_edp_connector_funcs
= {
1821 .dpms
= drm_helper_connector_dpms
,
1822 .detect
= radeon_dp_detect
,
1823 .fill_modes
= drm_helper_probe_single_connector_modes
,
1824 .set_property
= radeon_lvds_set_property
,
1825 .destroy
= radeon_connector_destroy
,
1826 .force
= radeon_dvi_force
,
1829 static const struct drm_connector_funcs radeon_lvds_bridge_connector_funcs
= {
1830 .dpms
= drm_helper_connector_dpms
,
1831 .detect
= radeon_dp_detect
,
1832 .fill_modes
= drm_helper_probe_single_connector_modes
,
1833 .set_property
= radeon_lvds_set_property
,
1834 .destroy
= radeon_connector_destroy
,
1835 .force
= radeon_dvi_force
,
1839 radeon_add_atom_connector(struct drm_device
*dev
,
1840 uint32_t connector_id
,
1841 uint32_t supported_device
,
1843 struct radeon_i2c_bus_rec
*i2c_bus
,
1844 uint32_t igp_lane_info
,
1845 uint16_t connector_object_id
,
1846 struct radeon_hpd
*hpd
,
1847 struct radeon_router
*router
)
1849 struct radeon_device
*rdev
= dev
->dev_private
;
1850 struct drm_connector
*connector
;
1851 struct radeon_connector
*radeon_connector
;
1852 struct radeon_connector_atom_dig
*radeon_dig_connector
;
1853 struct drm_encoder
*encoder
;
1854 struct radeon_encoder
*radeon_encoder
;
1855 uint32_t subpixel_order
= SubPixelNone
;
1856 bool shared_ddc
= false;
1857 bool is_dp_bridge
= false;
1858 bool has_aux
= false;
1860 if (connector_type
== DRM_MODE_CONNECTOR_Unknown
)
1863 /* if the user selected tv=0 don't try and add the connector */
1864 if (((connector_type
== DRM_MODE_CONNECTOR_SVIDEO
) ||
1865 (connector_type
== DRM_MODE_CONNECTOR_Composite
) ||
1866 (connector_type
== DRM_MODE_CONNECTOR_9PinDIN
)) &&
1870 /* see if we already added it */
1871 list_for_each_entry(connector
, &dev
->mode_config
.connector_list
, head
) {
1872 radeon_connector
= to_radeon_connector(connector
);
1873 if (radeon_connector
->connector_id
== connector_id
) {
1874 radeon_connector
->devices
|= supported_device
;
1877 if (radeon_connector
->ddc_bus
&& i2c_bus
->valid
) {
1878 if (radeon_connector
->ddc_bus
->rec
.i2c_id
== i2c_bus
->i2c_id
) {
1879 radeon_connector
->shared_ddc
= true;
1882 if (radeon_connector
->router_bus
&& router
->ddc_valid
&&
1883 (radeon_connector
->router
.router_id
== router
->router_id
)) {
1884 radeon_connector
->shared_ddc
= false;
1890 /* check if it's a dp bridge */
1891 list_for_each_entry(encoder
, &dev
->mode_config
.encoder_list
, head
) {
1892 radeon_encoder
= to_radeon_encoder(encoder
);
1893 if (radeon_encoder
->devices
& supported_device
) {
1894 switch (radeon_encoder
->encoder_id
) {
1895 case ENCODER_OBJECT_ID_TRAVIS
:
1896 case ENCODER_OBJECT_ID_NUTMEG
:
1897 is_dp_bridge
= true;
1905 radeon_connector
= kzalloc(sizeof(struct radeon_connector
), GFP_KERNEL
);
1906 if (!radeon_connector
)
1909 connector
= &radeon_connector
->base
;
1911 radeon_connector
->connector_id
= connector_id
;
1912 radeon_connector
->devices
= supported_device
;
1913 radeon_connector
->shared_ddc
= shared_ddc
;
1914 radeon_connector
->connector_object_id
= connector_object_id
;
1915 radeon_connector
->hpd
= *hpd
;
1917 radeon_connector
->router
= *router
;
1918 if (router
->ddc_valid
|| router
->cd_valid
) {
1919 radeon_connector
->router_bus
= radeon_i2c_lookup(rdev
, &router
->i2c_info
);
1920 if (!radeon_connector
->router_bus
)
1921 DRM_ERROR("Failed to assign router i2c bus! Check dmesg for i2c errors.\n");
1925 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
1926 if (!radeon_dig_connector
)
1928 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
1929 radeon_connector
->con_priv
= radeon_dig_connector
;
1930 if (i2c_bus
->valid
) {
1931 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
1932 if (radeon_connector
->ddc_bus
)
1935 DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1937 switch (connector_type
) {
1938 case DRM_MODE_CONNECTOR_VGA
:
1939 case DRM_MODE_CONNECTOR_DVIA
:
1941 drm_connector_init(dev
, &radeon_connector
->base
,
1942 &radeon_dp_connector_funcs
, connector_type
);
1943 drm_connector_helper_add(&radeon_connector
->base
,
1944 &radeon_dp_connector_helper_funcs
);
1945 connector
->interlace_allowed
= true;
1946 connector
->doublescan_allowed
= true;
1947 radeon_connector
->dac_load_detect
= true;
1948 drm_object_attach_property(&radeon_connector
->base
.base
,
1949 rdev
->mode_info
.load_detect_property
,
1951 drm_object_attach_property(&radeon_connector
->base
.base
,
1952 dev
->mode_config
.scaling_mode_property
,
1953 DRM_MODE_SCALE_NONE
);
1954 if (ASIC_IS_DCE5(rdev
))
1955 drm_object_attach_property(&radeon_connector
->base
.base
,
1956 rdev
->mode_info
.output_csc_property
,
1957 RADEON_OUTPUT_CSC_BYPASS
);
1959 case DRM_MODE_CONNECTOR_DVII
:
1960 case DRM_MODE_CONNECTOR_DVID
:
1961 case DRM_MODE_CONNECTOR_HDMIA
:
1962 case DRM_MODE_CONNECTOR_HDMIB
:
1963 case DRM_MODE_CONNECTOR_DisplayPort
:
1964 drm_connector_init(dev
, &radeon_connector
->base
,
1965 &radeon_dp_connector_funcs
, connector_type
);
1966 drm_connector_helper_add(&radeon_connector
->base
,
1967 &radeon_dp_connector_helper_funcs
);
1968 drm_object_attach_property(&radeon_connector
->base
.base
,
1969 rdev
->mode_info
.underscan_property
,
1971 drm_object_attach_property(&radeon_connector
->base
.base
,
1972 rdev
->mode_info
.underscan_hborder_property
,
1974 drm_object_attach_property(&radeon_connector
->base
.base
,
1975 rdev
->mode_info
.underscan_vborder_property
,
1978 drm_object_attach_property(&radeon_connector
->base
.base
,
1979 dev
->mode_config
.scaling_mode_property
,
1980 DRM_MODE_SCALE_NONE
);
1982 drm_object_attach_property(&radeon_connector
->base
.base
,
1983 rdev
->mode_info
.dither_property
,
1984 RADEON_FMT_DITHER_DISABLE
);
1986 if (radeon_audio
!= 0) {
1987 drm_object_attach_property(&radeon_connector
->base
.base
,
1988 rdev
->mode_info
.audio_property
,
1990 radeon_connector
->audio
= RADEON_AUDIO_AUTO
;
1992 if (ASIC_IS_DCE5(rdev
))
1993 drm_object_attach_property(&radeon_connector
->base
.base
,
1994 rdev
->mode_info
.output_csc_property
,
1995 RADEON_OUTPUT_CSC_BYPASS
);
1997 subpixel_order
= SubPixelHorizontalRGB
;
1998 connector
->interlace_allowed
= true;
1999 if (connector_type
== DRM_MODE_CONNECTOR_HDMIB
)
2000 connector
->doublescan_allowed
= true;
2002 connector
->doublescan_allowed
= false;
2003 if (connector_type
== DRM_MODE_CONNECTOR_DVII
) {
2004 radeon_connector
->dac_load_detect
= true;
2005 drm_object_attach_property(&radeon_connector
->base
.base
,
2006 rdev
->mode_info
.load_detect_property
,
2010 case DRM_MODE_CONNECTOR_LVDS
:
2011 case DRM_MODE_CONNECTOR_eDP
:
2012 drm_connector_init(dev
, &radeon_connector
->base
,
2013 &radeon_lvds_bridge_connector_funcs
, connector_type
);
2014 drm_connector_helper_add(&radeon_connector
->base
,
2015 &radeon_dp_connector_helper_funcs
);
2016 drm_object_attach_property(&radeon_connector
->base
.base
,
2017 dev
->mode_config
.scaling_mode_property
,
2018 DRM_MODE_SCALE_FULLSCREEN
);
2019 subpixel_order
= SubPixelHorizontalRGB
;
2020 connector
->interlace_allowed
= false;
2021 connector
->doublescan_allowed
= false;
2025 switch (connector_type
) {
2026 case DRM_MODE_CONNECTOR_VGA
:
2027 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_vga_connector_funcs
, connector_type
);
2028 drm_connector_helper_add(&radeon_connector
->base
, &radeon_vga_connector_helper_funcs
);
2029 if (i2c_bus
->valid
) {
2030 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
2031 if (!radeon_connector
->ddc_bus
)
2032 DRM_ERROR("VGA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2034 radeon_connector
->dac_load_detect
= true;
2035 drm_object_attach_property(&radeon_connector
->base
.base
,
2036 rdev
->mode_info
.load_detect_property
,
2038 if (ASIC_IS_AVIVO(rdev
))
2039 drm_object_attach_property(&radeon_connector
->base
.base
,
2040 dev
->mode_config
.scaling_mode_property
,
2041 DRM_MODE_SCALE_NONE
);
2042 if (ASIC_IS_DCE5(rdev
))
2043 drm_object_attach_property(&radeon_connector
->base
.base
,
2044 rdev
->mode_info
.output_csc_property
,
2045 RADEON_OUTPUT_CSC_BYPASS
);
2046 /* no HPD on analog connectors */
2047 radeon_connector
->hpd
.hpd
= RADEON_HPD_NONE
;
2048 connector
->interlace_allowed
= true;
2049 connector
->doublescan_allowed
= true;
2051 case DRM_MODE_CONNECTOR_DVIA
:
2052 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_vga_connector_funcs
, connector_type
);
2053 drm_connector_helper_add(&radeon_connector
->base
, &radeon_vga_connector_helper_funcs
);
2054 if (i2c_bus
->valid
) {
2055 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
2056 if (!radeon_connector
->ddc_bus
)
2057 DRM_ERROR("DVIA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2059 radeon_connector
->dac_load_detect
= true;
2060 drm_object_attach_property(&radeon_connector
->base
.base
,
2061 rdev
->mode_info
.load_detect_property
,
2063 if (ASIC_IS_AVIVO(rdev
))
2064 drm_object_attach_property(&radeon_connector
->base
.base
,
2065 dev
->mode_config
.scaling_mode_property
,
2066 DRM_MODE_SCALE_NONE
);
2067 if (ASIC_IS_DCE5(rdev
))
2068 drm_object_attach_property(&radeon_connector
->base
.base
,
2069 rdev
->mode_info
.output_csc_property
,
2070 RADEON_OUTPUT_CSC_BYPASS
);
2071 /* no HPD on analog connectors */
2072 radeon_connector
->hpd
.hpd
= RADEON_HPD_NONE
;
2073 connector
->interlace_allowed
= true;
2074 connector
->doublescan_allowed
= true;
2076 case DRM_MODE_CONNECTOR_DVII
:
2077 case DRM_MODE_CONNECTOR_DVID
:
2078 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
2079 if (!radeon_dig_connector
)
2081 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
2082 radeon_connector
->con_priv
= radeon_dig_connector
;
2083 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_dvi_connector_funcs
, connector_type
);
2084 drm_connector_helper_add(&radeon_connector
->base
, &radeon_dvi_connector_helper_funcs
);
2085 if (i2c_bus
->valid
) {
2086 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
2087 if (!radeon_connector
->ddc_bus
)
2088 DRM_ERROR("DVI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2090 subpixel_order
= SubPixelHorizontalRGB
;
2091 drm_object_attach_property(&radeon_connector
->base
.base
,
2092 rdev
->mode_info
.coherent_mode_property
,
2094 if (ASIC_IS_AVIVO(rdev
)) {
2095 drm_object_attach_property(&radeon_connector
->base
.base
,
2096 rdev
->mode_info
.underscan_property
,
2098 drm_object_attach_property(&radeon_connector
->base
.base
,
2099 rdev
->mode_info
.underscan_hborder_property
,
2101 drm_object_attach_property(&radeon_connector
->base
.base
,
2102 rdev
->mode_info
.underscan_vborder_property
,
2104 drm_object_attach_property(&radeon_connector
->base
.base
,
2105 rdev
->mode_info
.dither_property
,
2106 RADEON_FMT_DITHER_DISABLE
);
2107 drm_object_attach_property(&radeon_connector
->base
.base
,
2108 dev
->mode_config
.scaling_mode_property
,
2109 DRM_MODE_SCALE_NONE
);
2111 if (ASIC_IS_DCE2(rdev
) && (radeon_audio
!= 0)) {
2112 drm_object_attach_property(&radeon_connector
->base
.base
,
2113 rdev
->mode_info
.audio_property
,
2115 radeon_connector
->audio
= RADEON_AUDIO_AUTO
;
2117 if (connector_type
== DRM_MODE_CONNECTOR_DVII
) {
2118 radeon_connector
->dac_load_detect
= true;
2119 drm_object_attach_property(&radeon_connector
->base
.base
,
2120 rdev
->mode_info
.load_detect_property
,
2123 if (ASIC_IS_DCE5(rdev
))
2124 drm_object_attach_property(&radeon_connector
->base
.base
,
2125 rdev
->mode_info
.output_csc_property
,
2126 RADEON_OUTPUT_CSC_BYPASS
);
2127 connector
->interlace_allowed
= true;
2128 if (connector_type
== DRM_MODE_CONNECTOR_DVII
)
2129 connector
->doublescan_allowed
= true;
2131 connector
->doublescan_allowed
= false;
2133 case DRM_MODE_CONNECTOR_HDMIA
:
2134 case DRM_MODE_CONNECTOR_HDMIB
:
2135 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
2136 if (!radeon_dig_connector
)
2138 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
2139 radeon_connector
->con_priv
= radeon_dig_connector
;
2140 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_dvi_connector_funcs
, connector_type
);
2141 drm_connector_helper_add(&radeon_connector
->base
, &radeon_dvi_connector_helper_funcs
);
2142 if (i2c_bus
->valid
) {
2143 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
2144 if (!radeon_connector
->ddc_bus
)
2145 DRM_ERROR("HDMI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2147 drm_object_attach_property(&radeon_connector
->base
.base
,
2148 rdev
->mode_info
.coherent_mode_property
,
2150 if (ASIC_IS_AVIVO(rdev
)) {
2151 drm_object_attach_property(&radeon_connector
->base
.base
,
2152 rdev
->mode_info
.underscan_property
,
2154 drm_object_attach_property(&radeon_connector
->base
.base
,
2155 rdev
->mode_info
.underscan_hborder_property
,
2157 drm_object_attach_property(&radeon_connector
->base
.base
,
2158 rdev
->mode_info
.underscan_vborder_property
,
2160 drm_object_attach_property(&radeon_connector
->base
.base
,
2161 rdev
->mode_info
.dither_property
,
2162 RADEON_FMT_DITHER_DISABLE
);
2163 drm_object_attach_property(&radeon_connector
->base
.base
,
2164 dev
->mode_config
.scaling_mode_property
,
2165 DRM_MODE_SCALE_NONE
);
2167 if (ASIC_IS_DCE2(rdev
) && (radeon_audio
!= 0)) {
2168 drm_object_attach_property(&radeon_connector
->base
.base
,
2169 rdev
->mode_info
.audio_property
,
2171 radeon_connector
->audio
= RADEON_AUDIO_AUTO
;
2173 if (ASIC_IS_DCE5(rdev
))
2174 drm_object_attach_property(&radeon_connector
->base
.base
,
2175 rdev
->mode_info
.output_csc_property
,
2176 RADEON_OUTPUT_CSC_BYPASS
);
2177 subpixel_order
= SubPixelHorizontalRGB
;
2178 connector
->interlace_allowed
= true;
2179 if (connector_type
== DRM_MODE_CONNECTOR_HDMIB
)
2180 connector
->doublescan_allowed
= true;
2182 connector
->doublescan_allowed
= false;
2184 case DRM_MODE_CONNECTOR_DisplayPort
:
2185 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
2186 if (!radeon_dig_connector
)
2188 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
2189 radeon_connector
->con_priv
= radeon_dig_connector
;
2190 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_dp_connector_funcs
, connector_type
);
2191 drm_connector_helper_add(&radeon_connector
->base
, &radeon_dp_connector_helper_funcs
);
2192 if (i2c_bus
->valid
) {
2193 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
2194 if (radeon_connector
->ddc_bus
)
2197 DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2199 subpixel_order
= SubPixelHorizontalRGB
;
2200 drm_object_attach_property(&radeon_connector
->base
.base
,
2201 rdev
->mode_info
.coherent_mode_property
,
2203 if (ASIC_IS_AVIVO(rdev
)) {
2204 drm_object_attach_property(&radeon_connector
->base
.base
,
2205 rdev
->mode_info
.underscan_property
,
2207 drm_object_attach_property(&radeon_connector
->base
.base
,
2208 rdev
->mode_info
.underscan_hborder_property
,
2210 drm_object_attach_property(&radeon_connector
->base
.base
,
2211 rdev
->mode_info
.underscan_vborder_property
,
2213 drm_object_attach_property(&radeon_connector
->base
.base
,
2214 rdev
->mode_info
.dither_property
,
2215 RADEON_FMT_DITHER_DISABLE
);
2216 drm_object_attach_property(&radeon_connector
->base
.base
,
2217 dev
->mode_config
.scaling_mode_property
,
2218 DRM_MODE_SCALE_NONE
);
2220 if (ASIC_IS_DCE2(rdev
) && (radeon_audio
!= 0)) {
2221 drm_object_attach_property(&radeon_connector
->base
.base
,
2222 rdev
->mode_info
.audio_property
,
2224 radeon_connector
->audio
= RADEON_AUDIO_AUTO
;
2226 if (ASIC_IS_DCE5(rdev
))
2227 drm_object_attach_property(&radeon_connector
->base
.base
,
2228 rdev
->mode_info
.output_csc_property
,
2229 RADEON_OUTPUT_CSC_BYPASS
);
2230 connector
->interlace_allowed
= true;
2231 /* in theory with a DP to VGA converter... */
2232 connector
->doublescan_allowed
= false;
2234 case DRM_MODE_CONNECTOR_eDP
:
2235 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
2236 if (!radeon_dig_connector
)
2238 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
2239 radeon_connector
->con_priv
= radeon_dig_connector
;
2240 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_edp_connector_funcs
, connector_type
);
2241 drm_connector_helper_add(&radeon_connector
->base
, &radeon_dp_connector_helper_funcs
);
2242 if (i2c_bus
->valid
) {
2243 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
2244 if (radeon_connector
->ddc_bus
)
2247 DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2249 drm_object_attach_property(&radeon_connector
->base
.base
,
2250 dev
->mode_config
.scaling_mode_property
,
2251 DRM_MODE_SCALE_FULLSCREEN
);
2252 subpixel_order
= SubPixelHorizontalRGB
;
2253 connector
->interlace_allowed
= false;
2254 connector
->doublescan_allowed
= false;
2256 case DRM_MODE_CONNECTOR_SVIDEO
:
2257 case DRM_MODE_CONNECTOR_Composite
:
2258 case DRM_MODE_CONNECTOR_9PinDIN
:
2259 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_tv_connector_funcs
, connector_type
);
2260 drm_connector_helper_add(&radeon_connector
->base
, &radeon_tv_connector_helper_funcs
);
2261 radeon_connector
->dac_load_detect
= true;
2262 drm_object_attach_property(&radeon_connector
->base
.base
,
2263 rdev
->mode_info
.load_detect_property
,
2265 drm_object_attach_property(&radeon_connector
->base
.base
,
2266 rdev
->mode_info
.tv_std_property
,
2267 radeon_atombios_get_tv_info(rdev
));
2268 /* no HPD on analog connectors */
2269 radeon_connector
->hpd
.hpd
= RADEON_HPD_NONE
;
2270 connector
->interlace_allowed
= false;
2271 connector
->doublescan_allowed
= false;
2273 case DRM_MODE_CONNECTOR_LVDS
:
2274 radeon_dig_connector
= kzalloc(sizeof(struct radeon_connector_atom_dig
), GFP_KERNEL
);
2275 if (!radeon_dig_connector
)
2277 radeon_dig_connector
->igp_lane_info
= igp_lane_info
;
2278 radeon_connector
->con_priv
= radeon_dig_connector
;
2279 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_lvds_connector_funcs
, connector_type
);
2280 drm_connector_helper_add(&radeon_connector
->base
, &radeon_lvds_connector_helper_funcs
);
2281 if (i2c_bus
->valid
) {
2282 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
2283 if (!radeon_connector
->ddc_bus
)
2284 DRM_ERROR("LVDS: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2286 drm_object_attach_property(&radeon_connector
->base
.base
,
2287 dev
->mode_config
.scaling_mode_property
,
2288 DRM_MODE_SCALE_FULLSCREEN
);
2289 subpixel_order
= SubPixelHorizontalRGB
;
2290 connector
->interlace_allowed
= false;
2291 connector
->doublescan_allowed
= false;
2296 if (radeon_connector
->hpd
.hpd
== RADEON_HPD_NONE
) {
2297 if (i2c_bus
->valid
) {
2298 connector
->polled
= DRM_CONNECTOR_POLL_CONNECT
|
2299 DRM_CONNECTOR_POLL_DISCONNECT
;
2302 connector
->polled
= DRM_CONNECTOR_POLL_HPD
;
2304 connector
->display_info
.subpixel_order
= subpixel_order
;
2305 drm_connector_register(connector
);
2308 radeon_dp_aux_init(radeon_connector
);
2313 drm_connector_cleanup(connector
);
2318 radeon_add_legacy_connector(struct drm_device
*dev
,
2319 uint32_t connector_id
,
2320 uint32_t supported_device
,
2322 struct radeon_i2c_bus_rec
*i2c_bus
,
2323 uint16_t connector_object_id
,
2324 struct radeon_hpd
*hpd
)
2326 struct radeon_device
*rdev
= dev
->dev_private
;
2327 struct drm_connector
*connector
;
2328 struct radeon_connector
*radeon_connector
;
2329 uint32_t subpixel_order
= SubPixelNone
;
2331 if (connector_type
== DRM_MODE_CONNECTOR_Unknown
)
2334 /* if the user selected tv=0 don't try and add the connector */
2335 if (((connector_type
== DRM_MODE_CONNECTOR_SVIDEO
) ||
2336 (connector_type
== DRM_MODE_CONNECTOR_Composite
) ||
2337 (connector_type
== DRM_MODE_CONNECTOR_9PinDIN
)) &&
2341 /* see if we already added it */
2342 list_for_each_entry(connector
, &dev
->mode_config
.connector_list
, head
) {
2343 radeon_connector
= to_radeon_connector(connector
);
2344 if (radeon_connector
->connector_id
== connector_id
) {
2345 radeon_connector
->devices
|= supported_device
;
2350 radeon_connector
= kzalloc(sizeof(struct radeon_connector
), GFP_KERNEL
);
2351 if (!radeon_connector
)
2354 connector
= &radeon_connector
->base
;
2356 radeon_connector
->connector_id
= connector_id
;
2357 radeon_connector
->devices
= supported_device
;
2358 radeon_connector
->connector_object_id
= connector_object_id
;
2359 radeon_connector
->hpd
= *hpd
;
2361 switch (connector_type
) {
2362 case DRM_MODE_CONNECTOR_VGA
:
2363 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_vga_connector_funcs
, connector_type
);
2364 drm_connector_helper_add(&radeon_connector
->base
, &radeon_vga_connector_helper_funcs
);
2365 if (i2c_bus
->valid
) {
2366 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
2367 if (!radeon_connector
->ddc_bus
)
2368 DRM_ERROR("VGA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2370 radeon_connector
->dac_load_detect
= true;
2371 drm_object_attach_property(&radeon_connector
->base
.base
,
2372 rdev
->mode_info
.load_detect_property
,
2374 /* no HPD on analog connectors */
2375 radeon_connector
->hpd
.hpd
= RADEON_HPD_NONE
;
2376 connector
->interlace_allowed
= true;
2377 connector
->doublescan_allowed
= true;
2379 case DRM_MODE_CONNECTOR_DVIA
:
2380 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_vga_connector_funcs
, connector_type
);
2381 drm_connector_helper_add(&radeon_connector
->base
, &radeon_vga_connector_helper_funcs
);
2382 if (i2c_bus
->valid
) {
2383 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
2384 if (!radeon_connector
->ddc_bus
)
2385 DRM_ERROR("DVIA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2387 radeon_connector
->dac_load_detect
= true;
2388 drm_object_attach_property(&radeon_connector
->base
.base
,
2389 rdev
->mode_info
.load_detect_property
,
2391 /* no HPD on analog connectors */
2392 radeon_connector
->hpd
.hpd
= RADEON_HPD_NONE
;
2393 connector
->interlace_allowed
= true;
2394 connector
->doublescan_allowed
= true;
2396 case DRM_MODE_CONNECTOR_DVII
:
2397 case DRM_MODE_CONNECTOR_DVID
:
2398 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_dvi_connector_funcs
, connector_type
);
2399 drm_connector_helper_add(&radeon_connector
->base
, &radeon_dvi_connector_helper_funcs
);
2400 if (i2c_bus
->valid
) {
2401 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
2402 if (!radeon_connector
->ddc_bus
)
2403 DRM_ERROR("DVI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2405 if (connector_type
== DRM_MODE_CONNECTOR_DVII
) {
2406 radeon_connector
->dac_load_detect
= true;
2407 drm_object_attach_property(&radeon_connector
->base
.base
,
2408 rdev
->mode_info
.load_detect_property
,
2411 subpixel_order
= SubPixelHorizontalRGB
;
2412 connector
->interlace_allowed
= true;
2413 if (connector_type
== DRM_MODE_CONNECTOR_DVII
)
2414 connector
->doublescan_allowed
= true;
2416 connector
->doublescan_allowed
= false;
2418 case DRM_MODE_CONNECTOR_SVIDEO
:
2419 case DRM_MODE_CONNECTOR_Composite
:
2420 case DRM_MODE_CONNECTOR_9PinDIN
:
2421 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_tv_connector_funcs
, connector_type
);
2422 drm_connector_helper_add(&radeon_connector
->base
, &radeon_tv_connector_helper_funcs
);
2423 radeon_connector
->dac_load_detect
= true;
2424 /* RS400,RC410,RS480 chipset seems to report a lot
2425 * of false positive on load detect, we haven't yet
2426 * found a way to make load detect reliable on those
2427 * chipset, thus just disable it for TV.
2429 if (rdev
->family
== CHIP_RS400
|| rdev
->family
== CHIP_RS480
)
2430 radeon_connector
->dac_load_detect
= false;
2431 drm_object_attach_property(&radeon_connector
->base
.base
,
2432 rdev
->mode_info
.load_detect_property
,
2433 radeon_connector
->dac_load_detect
);
2434 drm_object_attach_property(&radeon_connector
->base
.base
,
2435 rdev
->mode_info
.tv_std_property
,
2436 radeon_combios_get_tv_info(rdev
));
2437 /* no HPD on analog connectors */
2438 radeon_connector
->hpd
.hpd
= RADEON_HPD_NONE
;
2439 connector
->interlace_allowed
= false;
2440 connector
->doublescan_allowed
= false;
2442 case DRM_MODE_CONNECTOR_LVDS
:
2443 drm_connector_init(dev
, &radeon_connector
->base
, &radeon_lvds_connector_funcs
, connector_type
);
2444 drm_connector_helper_add(&radeon_connector
->base
, &radeon_lvds_connector_helper_funcs
);
2445 if (i2c_bus
->valid
) {
2446 radeon_connector
->ddc_bus
= radeon_i2c_lookup(rdev
, i2c_bus
);
2447 if (!radeon_connector
->ddc_bus
)
2448 DRM_ERROR("LVDS: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2450 drm_object_attach_property(&radeon_connector
->base
.base
,
2451 dev
->mode_config
.scaling_mode_property
,
2452 DRM_MODE_SCALE_FULLSCREEN
);
2453 subpixel_order
= SubPixelHorizontalRGB
;
2454 connector
->interlace_allowed
= false;
2455 connector
->doublescan_allowed
= false;
2459 if (radeon_connector
->hpd
.hpd
== RADEON_HPD_NONE
) {
2460 if (i2c_bus
->valid
) {
2461 connector
->polled
= DRM_CONNECTOR_POLL_CONNECT
|
2462 DRM_CONNECTOR_POLL_DISCONNECT
;
2465 connector
->polled
= DRM_CONNECTOR_POLL_HPD
;
2467 connector
->display_info
.subpixel_order
= subpixel_order
;
2468 drm_connector_register(connector
);