2 * Copyright 2007-8 Advanced Micro Devices, Inc.
3 * Copyright 2008 Red Hat Inc.
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
12 * The above copyright notice and this permission notice shall be included in
13 * all copies or substantial portions of the Software.
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
19 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
20 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
21 * OTHER DEALINGS IN THE SOFTWARE.
23 * Authors: Dave Airlie
28 #include "drm_crtc_helper.h"
29 #include "drm_fb_helper.h"
30 #include "radeon_drm.h"
35 radeon_combios_connected_scratch_regs(struct drm_connector *connector,
36 struct drm_encoder *encoder,
39 radeon_atombios_connected_scratch_regs(struct drm_connector *connector,
40 struct drm_encoder *encoder,
44 radeon_legacy_backlight_init(struct radeon_encoder *radeon_encoder,
45 struct drm_connector *drm_connector);
47 void radeon_connector_hotplug(struct drm_connector *connector)
49 struct drm_device *dev = connector->dev;
50 struct radeon_device *rdev = dev->dev_private;
51 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
53 /* bail if the connector does not have hpd pin, e.g.,
56 if (radeon_connector->hpd.hpd == RADEON_HPD_NONE)
59 radeon_hpd_set_polarity(rdev, radeon_connector->hpd.hpd);
61 /* if the connector is already off, don't turn it back on */
62 if (connector->dpms != DRM_MODE_DPMS_ON)
65 /* just deal with DP (not eDP) here. */
66 if (connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort) {
67 struct radeon_connector_atom_dig *dig_connector =
68 radeon_connector->con_priv;
70 /* if existing sink type was not DP no need to retrain */
71 if (dig_connector->dp_sink_type != CONNECTOR_OBJECT_ID_DISPLAYPORT)
74 /* first get sink type as it may be reset after (un)plug */
75 dig_connector->dp_sink_type = radeon_dp_getsinktype(radeon_connector);
76 /* don't do anything if sink is not display port, i.e.,
77 * passive dp->(dvi|hdmi) adaptor
79 if (dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) {
80 int saved_dpms = connector->dpms;
81 /* Only turn off the display if it's physically disconnected */
82 if (!radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) {
83 drm_helper_connector_dpms(connector, DRM_MODE_DPMS_OFF);
84 } else if (radeon_dp_needs_link_train(radeon_connector)) {
85 /* Don't try to start link training before we
87 if (!radeon_dp_getdpcd(radeon_connector))
90 /* set it to OFF so that drm_helper_connector_dpms()
91 * won't return immediately since the current state
92 * is ON at this point.
94 connector->dpms = DRM_MODE_DPMS_OFF;
95 drm_helper_connector_dpms(connector, DRM_MODE_DPMS_ON);
97 connector->dpms = saved_dpms;
102 static void radeon_property_change_mode(struct drm_encoder *encoder)
104 struct drm_crtc *crtc = encoder->crtc;
106 if (crtc && crtc->enabled) {
107 drm_crtc_helper_set_mode(crtc, &crtc->mode,
108 crtc->x, crtc->y, crtc->fb);
112 radeon_connector_update_scratch_regs(struct drm_connector *connector, enum drm_connector_status status)
114 struct drm_device *dev = connector->dev;
115 struct radeon_device *rdev = dev->dev_private;
116 struct drm_encoder *best_encoder = NULL;
117 struct drm_encoder *encoder = NULL;
118 struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
119 struct drm_mode_object *obj;
123 best_encoder = connector_funcs->best_encoder(connector);
125 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
126 if (connector->encoder_ids[i] == 0)
129 obj = drm_mode_object_find(connector->dev,
130 connector->encoder_ids[i],
131 DRM_MODE_OBJECT_ENCODER);
135 encoder = obj_to_encoder(obj);
137 if ((encoder == best_encoder) && (status == connector_status_connected))
142 if (rdev->is_atom_bios)
143 radeon_atombios_connected_scratch_regs(connector, encoder, connected);
145 radeon_combios_connected_scratch_regs(connector, encoder, connected);
150 struct drm_encoder *radeon_find_encoder(struct drm_connector *connector, int encoder_type)
152 struct drm_mode_object *obj;
153 struct drm_encoder *encoder;
156 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
157 if (connector->encoder_ids[i] == 0)
160 obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
164 encoder = obj_to_encoder(obj);
165 if (encoder->encoder_type == encoder_type)
171 struct drm_encoder *radeon_best_single_encoder(struct drm_connector *connector)
173 int enc_id = connector->encoder_ids[0];
174 struct drm_mode_object *obj;
175 struct drm_encoder *encoder;
177 /* pick the encoder ids */
179 obj = drm_mode_object_find(connector->dev, enc_id, DRM_MODE_OBJECT_ENCODER);
182 encoder = obj_to_encoder(obj);
189 * radeon_connector_analog_encoder_conflict_solve
190 * - search for other connectors sharing this encoder
191 * if priority is true, then set them disconnected if this is connected
192 * if priority is false, set us disconnected if they are connected
194 static enum drm_connector_status
195 radeon_connector_analog_encoder_conflict_solve(struct drm_connector *connector,
196 struct drm_encoder *encoder,
197 enum drm_connector_status current_status,
200 struct drm_device *dev = connector->dev;
201 struct drm_connector *conflict;
202 struct radeon_connector *radeon_conflict;
205 list_for_each_entry(conflict, &dev->mode_config.connector_list, head) {
206 if (conflict == connector)
209 radeon_conflict = to_radeon_connector(conflict);
210 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
211 if (conflict->encoder_ids[i] == 0)
214 /* if the IDs match */
215 if (conflict->encoder_ids[i] == encoder->base.id) {
216 if (conflict->status != connector_status_connected)
219 if (radeon_conflict->use_digital)
222 if (priority == true) {
223 DRM_DEBUG_KMS("1: conflicting encoders switching off %s\n", drm_get_connector_name(conflict));
224 DRM_DEBUG_KMS("in favor of %s\n", drm_get_connector_name(connector));
225 conflict->status = connector_status_disconnected;
226 radeon_connector_update_scratch_regs(conflict, connector_status_disconnected);
228 DRM_DEBUG_KMS("2: conflicting encoders switching off %s\n", drm_get_connector_name(connector));
229 DRM_DEBUG_KMS("in favor of %s\n", drm_get_connector_name(conflict));
230 current_status = connector_status_disconnected;
236 return current_status;
240 static struct drm_display_mode *radeon_fp_native_mode(struct drm_encoder *encoder)
242 struct drm_device *dev = encoder->dev;
243 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
244 struct drm_display_mode *mode = NULL;
245 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
247 if (native_mode->hdisplay != 0 &&
248 native_mode->vdisplay != 0 &&
249 native_mode->clock != 0) {
250 mode = drm_mode_duplicate(dev, native_mode);
251 mode->type = DRM_MODE_TYPE_PREFERRED | DRM_MODE_TYPE_DRIVER;
252 drm_mode_set_name(mode);
254 DRM_DEBUG_KMS("Adding native panel mode %s\n", mode->name);
255 } else if (native_mode->hdisplay != 0 &&
256 native_mode->vdisplay != 0) {
257 /* mac laptops without an edid */
258 /* Note that this is not necessarily the exact panel mode,
259 * but an approximation based on the cvt formula. For these
260 * systems we should ideally read the mode info out of the
261 * registers or add a mode table, but this works and is much
264 mode = drm_cvt_mode(dev, native_mode->hdisplay, native_mode->vdisplay, 60, true, false, false);
265 mode->type = DRM_MODE_TYPE_PREFERRED | DRM_MODE_TYPE_DRIVER;
266 DRM_DEBUG_KMS("Adding cvt approximation of native panel mode %s\n", mode->name);
271 static void radeon_add_common_modes(struct drm_encoder *encoder, struct drm_connector *connector)
273 struct drm_device *dev = encoder->dev;
274 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
275 struct drm_display_mode *mode = NULL;
276 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
281 } common_modes[17] = {
301 for (i = 0; i < 17; i++) {
302 if (radeon_encoder->devices & (ATOM_DEVICE_TV_SUPPORT)) {
303 if (common_modes[i].w > 1024 ||
304 common_modes[i].h > 768)
307 if (radeon_encoder->devices & (ATOM_DEVICE_LCD_SUPPORT)) {
308 if (common_modes[i].w > native_mode->hdisplay ||
309 common_modes[i].h > native_mode->vdisplay ||
310 (common_modes[i].w == native_mode->hdisplay &&
311 common_modes[i].h == native_mode->vdisplay))
314 if (common_modes[i].w < 320 || common_modes[i].h < 200)
317 mode = drm_cvt_mode(dev, common_modes[i].w, common_modes[i].h, 60, false, false, false);
318 drm_mode_probed_add(connector, mode);
322 int radeon_connector_set_property(struct drm_connector *connector, struct drm_property *property,
325 struct drm_device *dev = connector->dev;
326 struct radeon_device *rdev = dev->dev_private;
327 struct drm_encoder *encoder;
328 struct radeon_encoder *radeon_encoder;
330 if (property == rdev->mode_info.coherent_mode_property) {
331 struct radeon_encoder_atom_dig *dig;
332 bool new_coherent_mode;
334 /* need to find digital encoder on connector */
335 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
339 radeon_encoder = to_radeon_encoder(encoder);
341 if (!radeon_encoder->enc_priv)
344 dig = radeon_encoder->enc_priv;
345 new_coherent_mode = val ? true : false;
346 if (dig->coherent_mode != new_coherent_mode) {
347 dig->coherent_mode = new_coherent_mode;
348 radeon_property_change_mode(&radeon_encoder->base);
352 if (property == rdev->mode_info.underscan_property) {
353 /* need to find digital encoder on connector */
354 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
358 radeon_encoder = to_radeon_encoder(encoder);
360 if (radeon_encoder->underscan_type != val) {
361 radeon_encoder->underscan_type = val;
362 radeon_property_change_mode(&radeon_encoder->base);
366 if (property == rdev->mode_info.underscan_hborder_property) {
367 /* need to find digital encoder on connector */
368 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
372 radeon_encoder = to_radeon_encoder(encoder);
374 if (radeon_encoder->underscan_hborder != val) {
375 radeon_encoder->underscan_hborder = val;
376 radeon_property_change_mode(&radeon_encoder->base);
380 if (property == rdev->mode_info.underscan_vborder_property) {
381 /* need to find digital encoder on connector */
382 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
386 radeon_encoder = to_radeon_encoder(encoder);
388 if (radeon_encoder->underscan_vborder != val) {
389 radeon_encoder->underscan_vborder = val;
390 radeon_property_change_mode(&radeon_encoder->base);
394 if (property == rdev->mode_info.tv_std_property) {
395 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TVDAC);
397 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_DAC);
403 radeon_encoder = to_radeon_encoder(encoder);
404 if (!radeon_encoder->enc_priv)
406 if (ASIC_IS_AVIVO(rdev) || radeon_r4xx_atom) {
407 struct radeon_encoder_atom_dac *dac_int;
408 dac_int = radeon_encoder->enc_priv;
409 dac_int->tv_std = val;
411 struct radeon_encoder_tv_dac *dac_int;
412 dac_int = radeon_encoder->enc_priv;
413 dac_int->tv_std = val;
415 radeon_property_change_mode(&radeon_encoder->base);
418 if (property == rdev->mode_info.load_detect_property) {
419 struct radeon_connector *radeon_connector =
420 to_radeon_connector(connector);
423 radeon_connector->dac_load_detect = false;
425 radeon_connector->dac_load_detect = true;
428 if (property == rdev->mode_info.tmds_pll_property) {
429 struct radeon_encoder_int_tmds *tmds = NULL;
431 /* need to find digital encoder on connector */
432 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
436 radeon_encoder = to_radeon_encoder(encoder);
438 tmds = radeon_encoder->enc_priv;
443 if (rdev->is_atom_bios)
444 ret = radeon_atombios_get_tmds_info(radeon_encoder, tmds);
446 ret = radeon_legacy_get_tmds_info_from_combios(radeon_encoder, tmds);
448 if (val == 1 || ret == false) {
449 radeon_legacy_get_tmds_info_from_table(radeon_encoder, tmds);
451 radeon_property_change_mode(&radeon_encoder->base);
457 static void radeon_fixup_lvds_native_mode(struct drm_encoder *encoder,
458 struct drm_connector *connector)
460 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
461 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
462 struct drm_display_mode *t, *mode;
464 /* If the EDID preferred mode doesn't match the native mode, use it */
465 list_for_each_entry_safe(mode, t, &connector->probed_modes, head) {
466 if (mode->type & DRM_MODE_TYPE_PREFERRED) {
467 if (mode->hdisplay != native_mode->hdisplay ||
468 mode->vdisplay != native_mode->vdisplay)
469 memcpy(native_mode, mode, sizeof(*mode));
473 /* Try to get native mode details from EDID if necessary */
474 if (!native_mode->clock) {
475 list_for_each_entry_safe(mode, t, &connector->probed_modes, head) {
476 if (mode->hdisplay == native_mode->hdisplay &&
477 mode->vdisplay == native_mode->vdisplay) {
478 *native_mode = *mode;
479 drm_mode_set_crtcinfo(native_mode, CRTC_INTERLACE_HALVE_V);
480 DRM_DEBUG_KMS("Determined LVDS native mode details from EDID\n");
486 if (!native_mode->clock) {
487 DRM_DEBUG_KMS("No LVDS native mode details, disabling RMX\n");
488 radeon_encoder->rmx_type = RMX_OFF;
492 static int radeon_lvds_get_modes(struct drm_connector *connector)
494 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
495 struct drm_encoder *encoder;
497 struct drm_display_mode *mode;
499 if (radeon_connector->ddc_bus) {
500 ret = radeon_ddc_get_modes(radeon_connector);
502 encoder = radeon_best_single_encoder(connector);
504 radeon_fixup_lvds_native_mode(encoder, connector);
505 /* add scaled modes */
506 radeon_add_common_modes(encoder, connector);
512 encoder = radeon_best_single_encoder(connector);
516 /* we have no EDID modes */
517 mode = radeon_fp_native_mode(encoder);
520 drm_mode_probed_add(connector, mode);
521 /* add the width/height from vbios tables if available */
522 connector->display_info.width_mm = mode->width_mm;
523 connector->display_info.height_mm = mode->height_mm;
524 /* add scaled modes */
525 radeon_add_common_modes(encoder, connector);
531 static int radeon_lvds_mode_valid(struct drm_connector *connector,
532 struct drm_display_mode *mode)
534 struct drm_encoder *encoder = radeon_best_single_encoder(connector);
536 if ((mode->hdisplay < 320) || (mode->vdisplay < 240))
540 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
541 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
543 /* AVIVO hardware supports downscaling modes larger than the panel
544 * to the panel size, but I'm not sure this is desirable.
546 if ((mode->hdisplay > native_mode->hdisplay) ||
547 (mode->vdisplay > native_mode->vdisplay))
550 /* if scaling is disabled, block non-native modes */
551 if (radeon_encoder->rmx_type == RMX_OFF) {
552 if ((mode->hdisplay != native_mode->hdisplay) ||
553 (mode->vdisplay != native_mode->vdisplay))
561 static enum drm_connector_status
562 radeon_lvds_detect(struct drm_connector *connector, bool force)
564 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
565 struct drm_encoder *encoder = radeon_best_single_encoder(connector);
566 enum drm_connector_status ret = connector_status_disconnected;
569 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
570 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
572 /* check if panel is valid */
573 if (native_mode->hdisplay >= 320 && native_mode->vdisplay >= 240)
574 ret = connector_status_connected;
578 /* check for edid as well */
579 if (radeon_connector->edid)
580 ret = connector_status_connected;
582 if (radeon_connector->ddc_bus) {
583 radeon_connector->edid = drm_get_edid(&radeon_connector->base,
584 &radeon_connector->ddc_bus->adapter);
585 if (radeon_connector->edid)
586 ret = connector_status_connected;
589 /* check acpi lid status ??? */
591 radeon_connector_update_scratch_regs(connector, ret);
595 static void radeon_connector_destroy(struct drm_connector *connector)
597 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
599 if (radeon_connector->edid)
600 kfree(radeon_connector->edid);
601 kfree(radeon_connector->con_priv);
602 drm_sysfs_connector_remove(connector);
603 drm_connector_cleanup(connector);
607 static int radeon_lvds_set_property(struct drm_connector *connector,
608 struct drm_property *property,
611 struct drm_device *dev = connector->dev;
612 struct radeon_encoder *radeon_encoder;
613 enum radeon_rmx_type rmx_type;
616 if (property != dev->mode_config.scaling_mode_property)
619 if (connector->encoder)
620 radeon_encoder = to_radeon_encoder(connector->encoder);
622 struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
623 radeon_encoder = to_radeon_encoder(connector_funcs->best_encoder(connector));
627 case DRM_MODE_SCALE_NONE: rmx_type = RMX_OFF; break;
628 case DRM_MODE_SCALE_CENTER: rmx_type = RMX_CENTER; break;
629 case DRM_MODE_SCALE_ASPECT: rmx_type = RMX_ASPECT; break;
631 case DRM_MODE_SCALE_FULLSCREEN: rmx_type = RMX_FULL; break;
633 if (radeon_encoder->rmx_type == rmx_type)
636 radeon_encoder->rmx_type = rmx_type;
638 radeon_property_change_mode(&radeon_encoder->base);
643 struct drm_connector_helper_funcs radeon_lvds_connector_helper_funcs = {
644 .get_modes = radeon_lvds_get_modes,
645 .mode_valid = radeon_lvds_mode_valid,
646 .best_encoder = radeon_best_single_encoder,
649 struct drm_connector_funcs radeon_lvds_connector_funcs = {
650 .dpms = drm_helper_connector_dpms,
651 .detect = radeon_lvds_detect,
652 .fill_modes = drm_helper_probe_single_connector_modes,
653 .destroy = radeon_connector_destroy,
654 .set_property = radeon_lvds_set_property,
657 static int radeon_vga_get_modes(struct drm_connector *connector)
659 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
662 ret = radeon_ddc_get_modes(radeon_connector);
667 static int radeon_vga_mode_valid(struct drm_connector *connector,
668 struct drm_display_mode *mode)
670 struct drm_device *dev = connector->dev;
671 struct radeon_device *rdev = dev->dev_private;
673 /* XXX check mode bandwidth */
675 if ((mode->clock / 10) > rdev->clock.max_pixel_clock)
676 return MODE_CLOCK_HIGH;
681 static enum drm_connector_status
682 radeon_vga_detect(struct drm_connector *connector, bool force)
684 struct drm_device *dev = connector->dev;
685 struct radeon_device *rdev = dev->dev_private;
686 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
687 struct drm_encoder *encoder;
688 struct drm_encoder_helper_funcs *encoder_funcs;
690 enum drm_connector_status ret = connector_status_disconnected;
692 encoder = radeon_best_single_encoder(connector);
694 ret = connector_status_disconnected;
696 if (radeon_connector->ddc_bus)
697 dret = radeon_ddc_probe(radeon_connector, false);
699 radeon_connector->detected_by_load = false;
700 if (radeon_connector->edid) {
701 kfree(radeon_connector->edid);
702 radeon_connector->edid = NULL;
704 radeon_connector->edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
706 if (!radeon_connector->edid) {
707 DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
708 drm_get_connector_name(connector));
709 ret = connector_status_connected;
711 radeon_connector->use_digital = !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
713 /* some oems have boards with separate digital and analog connectors
714 * with a shared ddc line (often vga + hdmi)
716 if (radeon_connector->use_digital && radeon_connector->shared_ddc) {
717 kfree(radeon_connector->edid);
718 radeon_connector->edid = NULL;
719 ret = connector_status_disconnected;
721 ret = connector_status_connected;
725 /* if we aren't forcing don't do destructive polling */
727 /* only return the previous status if we last
728 * detected a monitor via load.
730 if (radeon_connector->detected_by_load)
731 return connector->status;
736 if (radeon_connector->dac_load_detect && encoder) {
737 encoder_funcs = encoder->helper_private;
738 ret = encoder_funcs->detect(encoder, connector);
739 if (ret != connector_status_disconnected)
740 radeon_connector->detected_by_load = true;
744 if (ret == connector_status_connected)
745 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
747 /* RN50 and some RV100 asics in servers often have a hardcoded EDID in the
748 * vbios to deal with KVMs. If we have one and are not able to detect a monitor
749 * by other means, assume the CRT is connected and use that EDID.
751 if ((!rdev->is_atom_bios) &&
752 (ret == connector_status_disconnected) &&
753 rdev->mode_info.bios_hardcoded_edid_size) {
754 ret = connector_status_connected;
757 radeon_connector_update_scratch_regs(connector, ret);
761 struct drm_connector_helper_funcs radeon_vga_connector_helper_funcs = {
762 .get_modes = radeon_vga_get_modes,
763 .mode_valid = radeon_vga_mode_valid,
764 .best_encoder = radeon_best_single_encoder,
767 struct drm_connector_funcs radeon_vga_connector_funcs = {
768 .dpms = drm_helper_connector_dpms,
769 .detect = radeon_vga_detect,
770 .fill_modes = drm_helper_probe_single_connector_modes,
771 .destroy = radeon_connector_destroy,
772 .set_property = radeon_connector_set_property,
775 static int radeon_tv_get_modes(struct drm_connector *connector)
777 struct drm_device *dev = connector->dev;
778 struct radeon_device *rdev = dev->dev_private;
779 struct drm_display_mode *tv_mode;
780 struct drm_encoder *encoder;
782 encoder = radeon_best_single_encoder(connector);
786 /* avivo chips can scale any mode */
787 if (rdev->family >= CHIP_RS600)
788 /* add scaled modes */
789 radeon_add_common_modes(encoder, connector);
791 /* only 800x600 is supported right now on pre-avivo chips */
792 tv_mode = drm_cvt_mode(dev, 800, 600, 60, false, false, false);
793 tv_mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
794 drm_mode_probed_add(connector, tv_mode);
799 static int radeon_tv_mode_valid(struct drm_connector *connector,
800 struct drm_display_mode *mode)
802 if ((mode->hdisplay > 1024) || (mode->vdisplay > 768))
803 return MODE_CLOCK_RANGE;
807 static enum drm_connector_status
808 radeon_tv_detect(struct drm_connector *connector, bool force)
810 struct drm_encoder *encoder;
811 struct drm_encoder_helper_funcs *encoder_funcs;
812 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
813 enum drm_connector_status ret = connector_status_disconnected;
815 if (!radeon_connector->dac_load_detect)
818 encoder = radeon_best_single_encoder(connector);
820 ret = connector_status_disconnected;
822 encoder_funcs = encoder->helper_private;
823 ret = encoder_funcs->detect(encoder, connector);
825 if (ret == connector_status_connected)
826 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, false);
827 radeon_connector_update_scratch_regs(connector, ret);
831 struct drm_connector_helper_funcs radeon_tv_connector_helper_funcs = {
832 .get_modes = radeon_tv_get_modes,
833 .mode_valid = radeon_tv_mode_valid,
834 .best_encoder = radeon_best_single_encoder,
837 struct drm_connector_funcs radeon_tv_connector_funcs = {
838 .dpms = drm_helper_connector_dpms,
839 .detect = radeon_tv_detect,
840 .fill_modes = drm_helper_probe_single_connector_modes,
841 .destroy = radeon_connector_destroy,
842 .set_property = radeon_connector_set_property,
845 static int radeon_dvi_get_modes(struct drm_connector *connector)
847 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
850 ret = radeon_ddc_get_modes(radeon_connector);
856 * Do a DDC probe, if DDC probe passes, get the full EDID so
857 * we can do analog/digital monitor detection at this point.
858 * If the monitor is an analog monitor or we got no DDC,
859 * we need to find the DAC encoder object for this connector.
860 * If we got no DDC, we do load detection on the DAC encoder object.
861 * If we got analog DDC or load detection passes on the DAC encoder
862 * we have to check if this analog encoder is shared with anyone else (TV)
863 * if its shared we have to set the other connector to disconnected.
865 static enum drm_connector_status
866 radeon_dvi_detect(struct drm_connector *connector, bool force)
868 struct drm_device *dev = connector->dev;
869 struct radeon_device *rdev = dev->dev_private;
870 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
871 struct drm_encoder *encoder = NULL;
872 struct drm_encoder_helper_funcs *encoder_funcs;
873 struct drm_mode_object *obj;
875 enum drm_connector_status ret = connector_status_disconnected;
878 if (radeon_connector->ddc_bus)
879 dret = radeon_ddc_probe(radeon_connector, false);
881 radeon_connector->detected_by_load = false;
882 if (radeon_connector->edid) {
883 kfree(radeon_connector->edid);
884 radeon_connector->edid = NULL;
886 radeon_connector->edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
888 if (!radeon_connector->edid) {
889 DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
890 drm_get_connector_name(connector));
891 /* rs690 seems to have a problem with connectors not existing and always
892 * return a block of 0's. If we see this just stop polling on this output */
893 if ((rdev->family == CHIP_RS690 || rdev->family == CHIP_RS740) && radeon_connector->base.null_edid_counter) {
894 ret = connector_status_disconnected;
895 DRM_ERROR("%s: detected RS690 floating bus bug, stopping ddc detect\n", drm_get_connector_name(connector));
896 radeon_connector->ddc_bus = NULL;
899 radeon_connector->use_digital = !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
901 /* some oems have boards with separate digital and analog connectors
902 * with a shared ddc line (often vga + hdmi)
904 if ((!radeon_connector->use_digital) && radeon_connector->shared_ddc) {
905 kfree(radeon_connector->edid);
906 radeon_connector->edid = NULL;
907 ret = connector_status_disconnected;
909 ret = connector_status_connected;
911 /* This gets complicated. We have boards with VGA + HDMI with a
912 * shared DDC line and we have boards with DVI-D + HDMI with a shared
913 * DDC line. The latter is more complex because with DVI<->HDMI adapters
914 * you don't really know what's connected to which port as both are digital.
916 if (radeon_connector->shared_ddc && (ret == connector_status_connected)) {
917 struct drm_connector *list_connector;
918 struct radeon_connector *list_radeon_connector;
919 list_for_each_entry(list_connector, &dev->mode_config.connector_list, head) {
920 if (connector == list_connector)
922 list_radeon_connector = to_radeon_connector(list_connector);
923 if (list_radeon_connector->shared_ddc &&
924 (list_radeon_connector->ddc_bus->rec.i2c_id ==
925 radeon_connector->ddc_bus->rec.i2c_id)) {
926 /* cases where both connectors are digital */
927 if (list_connector->connector_type != DRM_MODE_CONNECTOR_VGA) {
928 /* hpd is our only option in this case */
929 if (!radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) {
930 kfree(radeon_connector->edid);
931 radeon_connector->edid = NULL;
932 ret = connector_status_disconnected;
941 if ((ret == connector_status_connected) && (radeon_connector->use_digital == true))
944 /* DVI-D and HDMI-A are digital only */
945 if ((connector->connector_type == DRM_MODE_CONNECTOR_DVID) ||
946 (connector->connector_type == DRM_MODE_CONNECTOR_HDMIA))
949 /* if we aren't forcing don't do destructive polling */
951 /* only return the previous status if we last
952 * detected a monitor via load.
954 if (radeon_connector->detected_by_load)
955 ret = connector->status;
959 /* find analog encoder */
960 if (radeon_connector->dac_load_detect) {
961 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
962 if (connector->encoder_ids[i] == 0)
965 obj = drm_mode_object_find(connector->dev,
966 connector->encoder_ids[i],
967 DRM_MODE_OBJECT_ENCODER);
971 encoder = obj_to_encoder(obj);
973 if (encoder->encoder_type != DRM_MODE_ENCODER_DAC &&
974 encoder->encoder_type != DRM_MODE_ENCODER_TVDAC)
977 encoder_funcs = encoder->helper_private;
978 if (encoder_funcs->detect) {
979 if (ret != connector_status_connected) {
980 ret = encoder_funcs->detect(encoder, connector);
981 if (ret == connector_status_connected) {
982 radeon_connector->use_digital = false;
984 if (ret != connector_status_disconnected)
985 radeon_connector->detected_by_load = true;
992 if ((ret == connector_status_connected) && (radeon_connector->use_digital == false) &&
994 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
997 /* RN50 and some RV100 asics in servers often have a hardcoded EDID in the
998 * vbios to deal with KVMs. If we have one and are not able to detect a monitor
999 * by other means, assume the DFP is connected and use that EDID. In most
1000 * cases the DVI port is actually a virtual KVM port connected to the service
1004 if ((!rdev->is_atom_bios) &&
1005 (ret == connector_status_disconnected) &&
1006 rdev->mode_info.bios_hardcoded_edid_size) {
1007 radeon_connector->use_digital = true;
1008 ret = connector_status_connected;
1011 /* updated in get modes as well since we need to know if it's analog or digital */
1012 radeon_connector_update_scratch_regs(connector, ret);
1016 /* okay need to be smart in here about which encoder to pick */
1017 struct drm_encoder *radeon_dvi_encoder(struct drm_connector *connector)
1019 int enc_id = connector->encoder_ids[0];
1020 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1021 struct drm_mode_object *obj;
1022 struct drm_encoder *encoder;
1024 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
1025 if (connector->encoder_ids[i] == 0)
1028 obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
1032 encoder = obj_to_encoder(obj);
1034 if (radeon_connector->use_digital == true) {
1035 if (encoder->encoder_type == DRM_MODE_ENCODER_TMDS)
1038 if (encoder->encoder_type == DRM_MODE_ENCODER_DAC ||
1039 encoder->encoder_type == DRM_MODE_ENCODER_TVDAC)
1044 /* see if we have a default encoder TODO */
1046 /* then check use digitial */
1047 /* pick the first one */
1049 obj = drm_mode_object_find(connector->dev, enc_id, DRM_MODE_OBJECT_ENCODER);
1052 encoder = obj_to_encoder(obj);
1058 static void radeon_dvi_force(struct drm_connector *connector)
1060 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1061 if (connector->force == DRM_FORCE_ON)
1062 radeon_connector->use_digital = false;
1063 if (connector->force == DRM_FORCE_ON_DIGITAL)
1064 radeon_connector->use_digital = true;
1067 static int radeon_dvi_mode_valid(struct drm_connector *connector,
1068 struct drm_display_mode *mode)
1070 struct drm_device *dev = connector->dev;
1071 struct radeon_device *rdev = dev->dev_private;
1072 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1074 /* XXX check mode bandwidth */
1076 /* clocks over 135 MHz have heat issues with DVI on RV100 */
1077 if (radeon_connector->use_digital &&
1078 (rdev->family == CHIP_RV100) &&
1079 (mode->clock > 135000))
1080 return MODE_CLOCK_HIGH;
1082 if (radeon_connector->use_digital && (mode->clock > 165000)) {
1083 if ((radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_I) ||
1084 (radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_D) ||
1085 (radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_HDMI_TYPE_B))
1087 else if (radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_HDMI_TYPE_A) {
1088 if (ASIC_IS_DCE3(rdev)) {
1089 /* HDMI 1.3+ supports max clock of 340 Mhz */
1090 if (mode->clock > 340000)
1091 return MODE_CLOCK_HIGH;
1095 return MODE_CLOCK_HIGH;
1097 return MODE_CLOCK_HIGH;
1100 /* check against the max pixel clock */
1101 if ((mode->clock / 10) > rdev->clock.max_pixel_clock)
1102 return MODE_CLOCK_HIGH;
1107 struct drm_connector_helper_funcs radeon_dvi_connector_helper_funcs = {
1108 .get_modes = radeon_dvi_get_modes,
1109 .mode_valid = radeon_dvi_mode_valid,
1110 .best_encoder = radeon_dvi_encoder,
1113 struct drm_connector_funcs radeon_dvi_connector_funcs = {
1114 .dpms = drm_helper_connector_dpms,
1115 .detect = radeon_dvi_detect,
1116 .fill_modes = drm_helper_probe_single_connector_modes,
1117 .set_property = radeon_connector_set_property,
1118 .destroy = radeon_connector_destroy,
1119 .force = radeon_dvi_force,
1122 static void radeon_dp_connector_destroy(struct drm_connector *connector)
1124 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1125 struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
1127 if (radeon_connector->edid)
1128 kfree(radeon_connector->edid);
1129 if (radeon_dig_connector->dp_i2c_bus)
1130 radeon_i2c_destroy(radeon_dig_connector->dp_i2c_bus);
1131 kfree(radeon_connector->con_priv);
1132 drm_sysfs_connector_remove(connector);
1133 drm_connector_cleanup(connector);
1137 static int radeon_dp_get_modes(struct drm_connector *connector)
1139 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1140 struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
1141 struct drm_encoder *encoder = radeon_best_single_encoder(connector);
1144 if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) ||
1145 (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
1146 struct drm_display_mode *mode;
1148 if (!radeon_dig_connector->edp_on)
1149 atombios_set_edp_panel_power(connector,
1150 ATOM_TRANSMITTER_ACTION_POWER_ON);
1151 ret = radeon_ddc_get_modes(radeon_connector);
1152 if (!radeon_dig_connector->edp_on)
1153 atombios_set_edp_panel_power(connector,
1154 ATOM_TRANSMITTER_ACTION_POWER_OFF);
1158 radeon_fixup_lvds_native_mode(encoder, connector);
1159 /* add scaled modes */
1160 radeon_add_common_modes(encoder, connector);
1165 encoder = radeon_best_single_encoder(connector);
1169 /* we have no EDID modes */
1170 mode = radeon_fp_native_mode(encoder);
1173 drm_mode_probed_add(connector, mode);
1174 /* add the width/height from vbios tables if available */
1175 connector->display_info.width_mm = mode->width_mm;
1176 connector->display_info.height_mm = mode->height_mm;
1177 /* add scaled modes */
1178 radeon_add_common_modes(encoder, connector);
1181 /* need to setup ddc on the bridge */
1182 if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
1183 ENCODER_OBJECT_ID_NONE) {
1185 radeon_atom_ext_encoder_setup_ddc(encoder);
1187 ret = radeon_ddc_get_modes(radeon_connector);
1193 u16 radeon_connector_encoder_get_dp_bridge_encoder_id(struct drm_connector *connector)
1195 struct drm_mode_object *obj;
1196 struct drm_encoder *encoder;
1197 struct radeon_encoder *radeon_encoder;
1200 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
1201 if (connector->encoder_ids[i] == 0)
1204 obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
1208 encoder = obj_to_encoder(obj);
1209 radeon_encoder = to_radeon_encoder(encoder);
1211 switch (radeon_encoder->encoder_id) {
1212 case ENCODER_OBJECT_ID_TRAVIS:
1213 case ENCODER_OBJECT_ID_NUTMEG:
1214 return radeon_encoder->encoder_id;
1220 return ENCODER_OBJECT_ID_NONE;
1223 bool radeon_connector_encoder_is_hbr2(struct drm_connector *connector)
1225 struct drm_mode_object *obj;
1226 struct drm_encoder *encoder;
1227 struct radeon_encoder *radeon_encoder;
1231 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
1232 if (connector->encoder_ids[i] == 0)
1235 obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
1239 encoder = obj_to_encoder(obj);
1240 radeon_encoder = to_radeon_encoder(encoder);
1241 if (radeon_encoder->caps & ATOM_ENCODER_CAP_RECORD_HBR2)
1248 bool radeon_connector_is_dp12_capable(struct drm_connector *connector)
1250 struct drm_device *dev = connector->dev;
1251 struct radeon_device *rdev = dev->dev_private;
1253 if (ASIC_IS_DCE5(rdev) &&
1254 (rdev->clock.default_dispclk >= 53900) &&
1255 radeon_connector_encoder_is_hbr2(connector)) {
1262 static enum drm_connector_status
1263 radeon_dp_detect(struct drm_connector *connector, bool force)
1265 struct drm_device *dev = connector->dev;
1266 struct radeon_device *rdev = dev->dev_private;
1267 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1268 enum drm_connector_status ret = connector_status_disconnected;
1269 struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
1270 struct drm_encoder *encoder = radeon_best_single_encoder(connector);
1272 if (radeon_connector->edid) {
1273 kfree(radeon_connector->edid);
1274 radeon_connector->edid = NULL;
1277 if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) ||
1278 (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
1280 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
1281 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
1283 /* check if panel is valid */
1284 if (native_mode->hdisplay >= 320 && native_mode->vdisplay >= 240)
1285 ret = connector_status_connected;
1287 /* eDP is always DP */
1288 radeon_dig_connector->dp_sink_type = CONNECTOR_OBJECT_ID_DISPLAYPORT;
1289 if (!radeon_dig_connector->edp_on)
1290 atombios_set_edp_panel_power(connector,
1291 ATOM_TRANSMITTER_ACTION_POWER_ON);
1292 if (radeon_dp_getdpcd(radeon_connector))
1293 ret = connector_status_connected;
1294 if (!radeon_dig_connector->edp_on)
1295 atombios_set_edp_panel_power(connector,
1296 ATOM_TRANSMITTER_ACTION_POWER_OFF);
1297 } else if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
1298 ENCODER_OBJECT_ID_NONE) {
1299 /* DP bridges are always DP */
1300 radeon_dig_connector->dp_sink_type = CONNECTOR_OBJECT_ID_DISPLAYPORT;
1301 /* get the DPCD from the bridge */
1302 radeon_dp_getdpcd(radeon_connector);
1305 /* setup ddc on the bridge */
1306 radeon_atom_ext_encoder_setup_ddc(encoder);
1307 /* bridge chips are always aux */
1308 if (radeon_ddc_probe(radeon_connector, true)) /* try DDC */
1309 ret = connector_status_connected;
1310 else if (radeon_connector->dac_load_detect) { /* try load detection */
1311 struct drm_encoder_helper_funcs *encoder_funcs = encoder->helper_private;
1312 ret = encoder_funcs->detect(encoder, connector);
1316 radeon_dig_connector->dp_sink_type = radeon_dp_getsinktype(radeon_connector);
1317 if (radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) {
1318 ret = connector_status_connected;
1319 if (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT)
1320 radeon_dp_getdpcd(radeon_connector);
1322 if (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) {
1323 if (radeon_dp_getdpcd(radeon_connector))
1324 ret = connector_status_connected;
1326 /* try non-aux ddc (DP to DVI/HMDI/etc. adapter) */
1327 if (radeon_ddc_probe(radeon_connector, false))
1328 ret = connector_status_connected;
1333 radeon_connector_update_scratch_regs(connector, ret);
1337 static int radeon_dp_mode_valid(struct drm_connector *connector,
1338 struct drm_display_mode *mode)
1340 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1341 struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
1343 /* XXX check mode bandwidth */
1345 if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) ||
1346 (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
1347 struct drm_encoder *encoder = radeon_best_single_encoder(connector);
1349 if ((mode->hdisplay < 320) || (mode->vdisplay < 240))
1353 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
1354 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
1356 /* AVIVO hardware supports downscaling modes larger than the panel
1357 * to the panel size, but I'm not sure this is desirable.
1359 if ((mode->hdisplay > native_mode->hdisplay) ||
1360 (mode->vdisplay > native_mode->vdisplay))
1363 /* if scaling is disabled, block non-native modes */
1364 if (radeon_encoder->rmx_type == RMX_OFF) {
1365 if ((mode->hdisplay != native_mode->hdisplay) ||
1366 (mode->vdisplay != native_mode->vdisplay))
1372 if ((radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) ||
1373 (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_eDP))
1374 return radeon_dp_mode_valid_helper(connector, mode);
1380 struct drm_connector_helper_funcs radeon_dp_connector_helper_funcs = {
1381 .get_modes = radeon_dp_get_modes,
1382 .mode_valid = radeon_dp_mode_valid,
1383 .best_encoder = radeon_dvi_encoder,
1386 struct drm_connector_funcs radeon_dp_connector_funcs = {
1387 .dpms = drm_helper_connector_dpms,
1388 .detect = radeon_dp_detect,
1389 .fill_modes = drm_helper_probe_single_connector_modes,
1390 .set_property = radeon_connector_set_property,
1391 .destroy = radeon_dp_connector_destroy,
1392 .force = radeon_dvi_force,
1395 static const struct drm_connector_funcs radeon_edp_connector_funcs = {
1396 .dpms = drm_helper_connector_dpms,
1397 .detect = radeon_dp_detect,
1398 .fill_modes = drm_helper_probe_single_connector_modes,
1399 .set_property = radeon_lvds_set_property,
1400 .destroy = radeon_dp_connector_destroy,
1401 .force = radeon_dvi_force,
1404 static const struct drm_connector_funcs radeon_lvds_bridge_connector_funcs = {
1405 .dpms = drm_helper_connector_dpms,
1406 .detect = radeon_dp_detect,
1407 .fill_modes = drm_helper_probe_single_connector_modes,
1408 .set_property = radeon_lvds_set_property,
1409 .destroy = radeon_dp_connector_destroy,
1410 .force = radeon_dvi_force,
1414 radeon_add_atom_connector(struct drm_device *dev,
1415 uint32_t connector_id,
1416 uint32_t supported_device,
1418 struct radeon_i2c_bus_rec *i2c_bus,
1419 uint32_t igp_lane_info,
1420 uint16_t connector_object_id,
1421 struct radeon_hpd *hpd,
1422 struct radeon_router *router)
1424 struct radeon_device *rdev = dev->dev_private;
1425 struct drm_connector *connector;
1426 struct radeon_connector *radeon_connector;
1427 struct radeon_connector_atom_dig *radeon_dig_connector;
1428 struct drm_encoder *encoder;
1429 struct radeon_encoder *radeon_encoder;
1430 uint32_t subpixel_order = SubPixelNone;
1431 bool shared_ddc = false;
1432 bool is_dp_bridge = false;
1434 if (connector_type == DRM_MODE_CONNECTOR_Unknown)
1437 /* if the user selected tv=0 don't try and add the connector */
1438 if (((connector_type == DRM_MODE_CONNECTOR_SVIDEO) ||
1439 (connector_type == DRM_MODE_CONNECTOR_Composite) ||
1440 (connector_type == DRM_MODE_CONNECTOR_9PinDIN)) &&
1444 /* see if we already added it */
1445 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
1446 radeon_connector = to_radeon_connector(connector);
1447 if (radeon_connector->connector_id == connector_id) {
1448 radeon_connector->devices |= supported_device;
1451 if (radeon_connector->ddc_bus && i2c_bus->valid) {
1452 if (radeon_connector->ddc_bus->rec.i2c_id == i2c_bus->i2c_id) {
1453 radeon_connector->shared_ddc = true;
1456 if (radeon_connector->router_bus && router->ddc_valid &&
1457 (radeon_connector->router.router_id == router->router_id)) {
1458 radeon_connector->shared_ddc = false;
1464 /* check if it's a dp bridge */
1465 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
1466 radeon_encoder = to_radeon_encoder(encoder);
1467 if (radeon_encoder->devices & supported_device) {
1468 switch (radeon_encoder->encoder_id) {
1469 case ENCODER_OBJECT_ID_TRAVIS:
1470 case ENCODER_OBJECT_ID_NUTMEG:
1471 is_dp_bridge = true;
1479 radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
1480 if (!radeon_connector)
1483 connector = &radeon_connector->base;
1485 radeon_connector->connector_id = connector_id;
1486 radeon_connector->devices = supported_device;
1487 radeon_connector->shared_ddc = shared_ddc;
1488 radeon_connector->connector_object_id = connector_object_id;
1489 radeon_connector->hpd = *hpd;
1491 radeon_connector->router = *router;
1492 if (router->ddc_valid || router->cd_valid) {
1493 radeon_connector->router_bus = radeon_i2c_lookup(rdev, &router->i2c_info);
1494 if (!radeon_connector->router_bus)
1495 DRM_ERROR("Failed to assign router i2c bus! Check dmesg for i2c errors.\n");
1499 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1500 if (!radeon_dig_connector)
1502 radeon_dig_connector->igp_lane_info = igp_lane_info;
1503 radeon_connector->con_priv = radeon_dig_connector;
1504 if (i2c_bus->valid) {
1505 /* add DP i2c bus */
1506 if (connector_type == DRM_MODE_CONNECTOR_eDP)
1507 radeon_dig_connector->dp_i2c_bus = radeon_i2c_create_dp(dev, i2c_bus, "eDP-auxch");
1509 radeon_dig_connector->dp_i2c_bus = radeon_i2c_create_dp(dev, i2c_bus, "DP-auxch");
1510 if (!radeon_dig_connector->dp_i2c_bus)
1511 DRM_ERROR("DP: Failed to assign dp ddc bus! Check dmesg for i2c errors.\n");
1512 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1513 if (!radeon_connector->ddc_bus)
1514 DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1516 switch (connector_type) {
1517 case DRM_MODE_CONNECTOR_VGA:
1518 case DRM_MODE_CONNECTOR_DVIA:
1520 drm_connector_init(dev, &radeon_connector->base,
1521 &radeon_dp_connector_funcs, connector_type);
1522 drm_connector_helper_add(&radeon_connector->base,
1523 &radeon_dp_connector_helper_funcs);
1524 connector->interlace_allowed = true;
1525 connector->doublescan_allowed = true;
1526 radeon_connector->dac_load_detect = true;
1527 drm_connector_attach_property(&radeon_connector->base,
1528 rdev->mode_info.load_detect_property,
1531 case DRM_MODE_CONNECTOR_DVII:
1532 case DRM_MODE_CONNECTOR_DVID:
1533 case DRM_MODE_CONNECTOR_HDMIA:
1534 case DRM_MODE_CONNECTOR_HDMIB:
1535 case DRM_MODE_CONNECTOR_DisplayPort:
1536 drm_connector_init(dev, &radeon_connector->base,
1537 &radeon_dp_connector_funcs, connector_type);
1538 drm_connector_helper_add(&radeon_connector->base,
1539 &radeon_dp_connector_helper_funcs);
1540 drm_connector_attach_property(&radeon_connector->base,
1541 rdev->mode_info.underscan_property,
1543 drm_connector_attach_property(&radeon_connector->base,
1544 rdev->mode_info.underscan_hborder_property,
1546 drm_connector_attach_property(&radeon_connector->base,
1547 rdev->mode_info.underscan_vborder_property,
1549 subpixel_order = SubPixelHorizontalRGB;
1550 connector->interlace_allowed = true;
1551 if (connector_type == DRM_MODE_CONNECTOR_HDMIB)
1552 connector->doublescan_allowed = true;
1554 connector->doublescan_allowed = false;
1555 if (connector_type == DRM_MODE_CONNECTOR_DVII) {
1556 radeon_connector->dac_load_detect = true;
1557 drm_connector_attach_property(&radeon_connector->base,
1558 rdev->mode_info.load_detect_property,
1562 case DRM_MODE_CONNECTOR_LVDS:
1563 case DRM_MODE_CONNECTOR_eDP:
1564 drm_connector_init(dev, &radeon_connector->base,
1565 &radeon_lvds_bridge_connector_funcs, connector_type);
1566 drm_connector_helper_add(&radeon_connector->base,
1567 &radeon_dp_connector_helper_funcs);
1568 drm_connector_attach_property(&radeon_connector->base,
1569 dev->mode_config.scaling_mode_property,
1570 DRM_MODE_SCALE_FULLSCREEN);
1571 subpixel_order = SubPixelHorizontalRGB;
1572 connector->interlace_allowed = false;
1573 connector->doublescan_allowed = false;
1577 switch (connector_type) {
1578 case DRM_MODE_CONNECTOR_VGA:
1579 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1580 drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1581 if (i2c_bus->valid) {
1582 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1583 if (!radeon_connector->ddc_bus)
1584 DRM_ERROR("VGA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1586 radeon_connector->dac_load_detect = true;
1587 drm_connector_attach_property(&radeon_connector->base,
1588 rdev->mode_info.load_detect_property,
1590 /* no HPD on analog connectors */
1591 radeon_connector->hpd.hpd = RADEON_HPD_NONE;
1592 connector->polled = DRM_CONNECTOR_POLL_CONNECT;
1593 connector->interlace_allowed = true;
1594 connector->doublescan_allowed = true;
1596 case DRM_MODE_CONNECTOR_DVIA:
1597 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1598 drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1599 if (i2c_bus->valid) {
1600 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1601 if (!radeon_connector->ddc_bus)
1602 DRM_ERROR("DVIA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1604 radeon_connector->dac_load_detect = true;
1605 drm_connector_attach_property(&radeon_connector->base,
1606 rdev->mode_info.load_detect_property,
1608 /* no HPD on analog connectors */
1609 radeon_connector->hpd.hpd = RADEON_HPD_NONE;
1610 connector->interlace_allowed = true;
1611 connector->doublescan_allowed = true;
1613 case DRM_MODE_CONNECTOR_DVII:
1614 case DRM_MODE_CONNECTOR_DVID:
1615 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1616 if (!radeon_dig_connector)
1618 radeon_dig_connector->igp_lane_info = igp_lane_info;
1619 radeon_connector->con_priv = radeon_dig_connector;
1620 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
1621 drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
1622 if (i2c_bus->valid) {
1623 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1624 if (!radeon_connector->ddc_bus)
1625 DRM_ERROR("DVI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1627 subpixel_order = SubPixelHorizontalRGB;
1628 drm_connector_attach_property(&radeon_connector->base,
1629 rdev->mode_info.coherent_mode_property,
1631 if (ASIC_IS_AVIVO(rdev)) {
1632 drm_connector_attach_property(&radeon_connector->base,
1633 rdev->mode_info.underscan_property,
1635 drm_connector_attach_property(&radeon_connector->base,
1636 rdev->mode_info.underscan_hborder_property,
1638 drm_connector_attach_property(&radeon_connector->base,
1639 rdev->mode_info.underscan_vborder_property,
1642 if (connector_type == DRM_MODE_CONNECTOR_DVII) {
1643 radeon_connector->dac_load_detect = true;
1644 drm_connector_attach_property(&radeon_connector->base,
1645 rdev->mode_info.load_detect_property,
1648 connector->interlace_allowed = true;
1649 if (connector_type == DRM_MODE_CONNECTOR_DVII)
1650 connector->doublescan_allowed = true;
1652 connector->doublescan_allowed = false;
1654 case DRM_MODE_CONNECTOR_HDMIA:
1655 case DRM_MODE_CONNECTOR_HDMIB:
1656 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1657 if (!radeon_dig_connector)
1659 radeon_dig_connector->igp_lane_info = igp_lane_info;
1660 radeon_connector->con_priv = radeon_dig_connector;
1661 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
1662 drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
1663 if (i2c_bus->valid) {
1664 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1665 if (!radeon_connector->ddc_bus)
1666 DRM_ERROR("HDMI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1668 drm_connector_attach_property(&radeon_connector->base,
1669 rdev->mode_info.coherent_mode_property,
1671 if (ASIC_IS_AVIVO(rdev)) {
1672 drm_connector_attach_property(&radeon_connector->base,
1673 rdev->mode_info.underscan_property,
1675 drm_connector_attach_property(&radeon_connector->base,
1676 rdev->mode_info.underscan_hborder_property,
1678 drm_connector_attach_property(&radeon_connector->base,
1679 rdev->mode_info.underscan_vborder_property,
1682 subpixel_order = SubPixelHorizontalRGB;
1683 connector->interlace_allowed = true;
1684 if (connector_type == DRM_MODE_CONNECTOR_HDMIB)
1685 connector->doublescan_allowed = true;
1687 connector->doublescan_allowed = false;
1689 case DRM_MODE_CONNECTOR_DisplayPort:
1690 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1691 if (!radeon_dig_connector)
1693 radeon_dig_connector->igp_lane_info = igp_lane_info;
1694 radeon_connector->con_priv = radeon_dig_connector;
1695 drm_connector_init(dev, &radeon_connector->base, &radeon_dp_connector_funcs, connector_type);
1696 drm_connector_helper_add(&radeon_connector->base, &radeon_dp_connector_helper_funcs);
1697 if (i2c_bus->valid) {
1698 /* add DP i2c bus */
1699 radeon_dig_connector->dp_i2c_bus = radeon_i2c_create_dp(dev, i2c_bus, "DP-auxch");
1700 if (!radeon_dig_connector->dp_i2c_bus)
1701 DRM_ERROR("DP: Failed to assign dp ddc bus! Check dmesg for i2c errors.\n");
1702 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1703 if (!radeon_connector->ddc_bus)
1704 DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1706 subpixel_order = SubPixelHorizontalRGB;
1707 drm_connector_attach_property(&radeon_connector->base,
1708 rdev->mode_info.coherent_mode_property,
1710 if (ASIC_IS_AVIVO(rdev)) {
1711 drm_connector_attach_property(&radeon_connector->base,
1712 rdev->mode_info.underscan_property,
1714 drm_connector_attach_property(&radeon_connector->base,
1715 rdev->mode_info.underscan_hborder_property,
1717 drm_connector_attach_property(&radeon_connector->base,
1718 rdev->mode_info.underscan_vborder_property,
1721 connector->interlace_allowed = true;
1722 /* in theory with a DP to VGA converter... */
1723 connector->doublescan_allowed = false;
1725 case DRM_MODE_CONNECTOR_eDP:
1726 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1727 if (!radeon_dig_connector)
1729 radeon_dig_connector->igp_lane_info = igp_lane_info;
1730 radeon_connector->con_priv = radeon_dig_connector;
1731 drm_connector_init(dev, &radeon_connector->base, &radeon_edp_connector_funcs, connector_type);
1732 drm_connector_helper_add(&radeon_connector->base, &radeon_dp_connector_helper_funcs);
1733 if (i2c_bus->valid) {
1734 /* add DP i2c bus */
1735 radeon_dig_connector->dp_i2c_bus = radeon_i2c_create_dp(dev, i2c_bus, "eDP-auxch");
1736 if (!radeon_dig_connector->dp_i2c_bus)
1737 DRM_ERROR("DP: Failed to assign dp ddc bus! Check dmesg for i2c errors.\n");
1738 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1739 if (!radeon_connector->ddc_bus)
1740 DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1742 drm_connector_attach_property(&radeon_connector->base,
1743 dev->mode_config.scaling_mode_property,
1744 DRM_MODE_SCALE_FULLSCREEN);
1745 subpixel_order = SubPixelHorizontalRGB;
1746 connector->interlace_allowed = false;
1747 connector->doublescan_allowed = false;
1749 case DRM_MODE_CONNECTOR_SVIDEO:
1750 case DRM_MODE_CONNECTOR_Composite:
1751 case DRM_MODE_CONNECTOR_9PinDIN:
1752 drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
1753 drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
1754 radeon_connector->dac_load_detect = true;
1755 drm_connector_attach_property(&radeon_connector->base,
1756 rdev->mode_info.load_detect_property,
1758 drm_connector_attach_property(&radeon_connector->base,
1759 rdev->mode_info.tv_std_property,
1760 radeon_atombios_get_tv_info(rdev));
1761 /* no HPD on analog connectors */
1762 radeon_connector->hpd.hpd = RADEON_HPD_NONE;
1763 connector->interlace_allowed = false;
1764 connector->doublescan_allowed = false;
1766 case DRM_MODE_CONNECTOR_LVDS:
1767 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1768 if (!radeon_dig_connector)
1770 radeon_dig_connector->igp_lane_info = igp_lane_info;
1771 radeon_connector->con_priv = radeon_dig_connector;
1772 drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
1773 drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
1774 if (i2c_bus->valid) {
1775 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1776 if (!radeon_connector->ddc_bus)
1777 DRM_ERROR("LVDS: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1779 drm_connector_attach_property(&radeon_connector->base,
1780 dev->mode_config.scaling_mode_property,
1781 DRM_MODE_SCALE_FULLSCREEN);
1782 subpixel_order = SubPixelHorizontalRGB;
1783 connector->interlace_allowed = false;
1784 connector->doublescan_allowed = false;
1789 if (radeon_connector->hpd.hpd == RADEON_HPD_NONE) {
1791 connector->polled = DRM_CONNECTOR_POLL_CONNECT;
1793 connector->polled = DRM_CONNECTOR_POLL_HPD;
1795 connector->display_info.subpixel_order = subpixel_order;
1796 drm_sysfs_connector_add(connector);
1800 drm_connector_cleanup(connector);
1805 radeon_add_legacy_connector(struct drm_device *dev,
1806 uint32_t connector_id,
1807 uint32_t supported_device,
1809 struct radeon_i2c_bus_rec *i2c_bus,
1810 uint16_t connector_object_id,
1811 struct radeon_hpd *hpd)
1813 struct radeon_device *rdev = dev->dev_private;
1814 struct drm_connector *connector;
1815 struct radeon_connector *radeon_connector;
1816 uint32_t subpixel_order = SubPixelNone;
1818 if (connector_type == DRM_MODE_CONNECTOR_Unknown)
1821 /* if the user selected tv=0 don't try and add the connector */
1822 if (((connector_type == DRM_MODE_CONNECTOR_SVIDEO) ||
1823 (connector_type == DRM_MODE_CONNECTOR_Composite) ||
1824 (connector_type == DRM_MODE_CONNECTOR_9PinDIN)) &&
1828 /* see if we already added it */
1829 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
1830 radeon_connector = to_radeon_connector(connector);
1831 if (radeon_connector->connector_id == connector_id) {
1832 radeon_connector->devices |= supported_device;
1837 radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
1838 if (!radeon_connector)
1841 connector = &radeon_connector->base;
1843 radeon_connector->connector_id = connector_id;
1844 radeon_connector->devices = supported_device;
1845 radeon_connector->connector_object_id = connector_object_id;
1846 radeon_connector->hpd = *hpd;
1848 switch (connector_type) {
1849 case DRM_MODE_CONNECTOR_VGA:
1850 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1851 drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1852 if (i2c_bus->valid) {
1853 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1854 if (!radeon_connector->ddc_bus)
1855 DRM_ERROR("VGA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1857 radeon_connector->dac_load_detect = true;
1858 drm_connector_attach_property(&radeon_connector->base,
1859 rdev->mode_info.load_detect_property,
1861 /* no HPD on analog connectors */
1862 radeon_connector->hpd.hpd = RADEON_HPD_NONE;
1863 connector->polled = DRM_CONNECTOR_POLL_CONNECT;
1864 connector->interlace_allowed = true;
1865 connector->doublescan_allowed = true;
1867 case DRM_MODE_CONNECTOR_DVIA:
1868 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1869 drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1870 if (i2c_bus->valid) {
1871 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1872 if (!radeon_connector->ddc_bus)
1873 DRM_ERROR("DVIA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1875 radeon_connector->dac_load_detect = true;
1876 drm_connector_attach_property(&radeon_connector->base,
1877 rdev->mode_info.load_detect_property,
1879 /* no HPD on analog connectors */
1880 radeon_connector->hpd.hpd = RADEON_HPD_NONE;
1881 connector->interlace_allowed = true;
1882 connector->doublescan_allowed = true;
1884 case DRM_MODE_CONNECTOR_DVII:
1885 case DRM_MODE_CONNECTOR_DVID:
1886 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
1887 drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
1888 if (i2c_bus->valid) {
1889 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1890 if (!radeon_connector->ddc_bus)
1891 DRM_ERROR("DVI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1893 if (connector_type == DRM_MODE_CONNECTOR_DVII) {
1894 radeon_connector->dac_load_detect = true;
1895 drm_connector_attach_property(&radeon_connector->base,
1896 rdev->mode_info.load_detect_property,
1899 subpixel_order = SubPixelHorizontalRGB;
1900 connector->interlace_allowed = true;
1901 if (connector_type == DRM_MODE_CONNECTOR_DVII)
1902 connector->doublescan_allowed = true;
1904 connector->doublescan_allowed = false;
1906 case DRM_MODE_CONNECTOR_SVIDEO:
1907 case DRM_MODE_CONNECTOR_Composite:
1908 case DRM_MODE_CONNECTOR_9PinDIN:
1909 drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
1910 drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
1911 radeon_connector->dac_load_detect = true;
1912 /* RS400,RC410,RS480 chipset seems to report a lot
1913 * of false positive on load detect, we haven't yet
1914 * found a way to make load detect reliable on those
1915 * chipset, thus just disable it for TV.
1917 if (rdev->family == CHIP_RS400 || rdev->family == CHIP_RS480)
1918 radeon_connector->dac_load_detect = false;
1919 drm_connector_attach_property(&radeon_connector->base,
1920 rdev->mode_info.load_detect_property,
1921 radeon_connector->dac_load_detect);
1922 drm_connector_attach_property(&radeon_connector->base,
1923 rdev->mode_info.tv_std_property,
1924 radeon_combios_get_tv_info(rdev));
1925 /* no HPD on analog connectors */
1926 radeon_connector->hpd.hpd = RADEON_HPD_NONE;
1927 connector->interlace_allowed = false;
1928 connector->doublescan_allowed = false;
1930 case DRM_MODE_CONNECTOR_LVDS:
1931 drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
1932 drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
1933 if (i2c_bus->valid) {
1934 radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1935 if (!radeon_connector->ddc_bus)
1936 DRM_ERROR("LVDS: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1938 drm_connector_attach_property(&radeon_connector->base,
1939 dev->mode_config.scaling_mode_property,
1940 DRM_MODE_SCALE_FULLSCREEN);
1941 subpixel_order = SubPixelHorizontalRGB;
1942 connector->interlace_allowed = false;
1943 connector->doublescan_allowed = false;
1947 if (radeon_connector->hpd.hpd == RADEON_HPD_NONE) {
1949 connector->polled = DRM_CONNECTOR_POLL_CONNECT;
1951 connector->polled = DRM_CONNECTOR_POLL_HPD;
1952 connector->display_info.subpixel_order = subpixel_order;
1953 drm_sysfs_connector_add(connector);
1954 if (connector_type == DRM_MODE_CONNECTOR_LVDS) {
1955 struct drm_encoder *drm_encoder;
1957 list_for_each_entry(drm_encoder, &dev->mode_config.encoder_list, head) {
1958 struct radeon_encoder *radeon_encoder;
1960 radeon_encoder = to_radeon_encoder(drm_encoder);
1961 if (radeon_encoder->encoder_id == ENCODER_OBJECT_ID_INTERNAL_LVDS)
1962 radeon_legacy_backlight_init(radeon_encoder, connector);