xref: /linux/drivers/gpu/drm/radeon/radeon_connectors.c (revision 4413e16d9d21673bb5048a2e542f1aaa00015c2e)
1 /*
2  * Copyright 2007-8 Advanced Micro Devices, Inc.
3  * Copyright 2008 Red Hat Inc.
4  *
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:
11  *
12  * The above copyright notice and this permission notice shall be included in
13  * all copies or substantial portions of the Software.
14  *
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.
22  *
23  * Authors: Dave Airlie
24  *          Alex Deucher
25  */
26 #include <drm/drmP.h>
27 #include <drm/drm_edid.h>
28 #include <drm/drm_crtc_helper.h>
29 #include <drm/drm_fb_helper.h>
30 #include <drm/radeon_drm.h>
31 #include "radeon.h"
32 #include "atom.h"
33 
34 extern void
35 radeon_combios_connected_scratch_regs(struct drm_connector *connector,
36 				      struct drm_encoder *encoder,
37 				      bool connected);
38 extern void
39 radeon_atombios_connected_scratch_regs(struct drm_connector *connector,
40 				       struct drm_encoder *encoder,
41 				       bool connected);
42 
43 extern void
44 radeon_legacy_backlight_init(struct radeon_encoder *radeon_encoder,
45 			     struct drm_connector *drm_connector);
46 
47 void radeon_connector_hotplug(struct drm_connector *connector)
48 {
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);
52 
53 	/* bail if the connector does not have hpd pin, e.g.,
54 	 * VGA, TV, etc.
55 	 */
56 	if (radeon_connector->hpd.hpd == RADEON_HPD_NONE)
57 		return;
58 
59 	radeon_hpd_set_polarity(rdev, radeon_connector->hpd.hpd);
60 
61 	/* if the connector is already off, don't turn it back on */
62 	if (connector->dpms != DRM_MODE_DPMS_ON)
63 		return;
64 
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;
69 
70 		/* if existing sink type was not DP no need to retrain */
71 		if (dig_connector->dp_sink_type != CONNECTOR_OBJECT_ID_DISPLAYPORT)
72 			return;
73 
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
78 		 */
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 				/* 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.
88 				 */
89 				connector->dpms = DRM_MODE_DPMS_OFF;
90 				drm_helper_connector_dpms(connector, DRM_MODE_DPMS_ON);
91 			}
92 			connector->dpms = saved_dpms;
93 		}
94 	}
95 }
96 
97 static void radeon_property_change_mode(struct drm_encoder *encoder)
98 {
99 	struct drm_crtc *crtc = encoder->crtc;
100 
101 	if (crtc && crtc->enabled) {
102 		drm_crtc_helper_set_mode(crtc, &crtc->mode,
103 					 crtc->x, crtc->y, crtc->fb);
104 	}
105 }
106 
107 int radeon_get_monitor_bpc(struct drm_connector *connector)
108 {
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;
113 	int bpc = 8;
114 
115 	switch (connector->connector_type) {
116 	case DRM_MODE_CONNECTOR_DVII:
117 	case DRM_MODE_CONNECTOR_HDMIB:
118 		if (radeon_connector->use_digital) {
119 			if (drm_detect_hdmi_monitor(radeon_connector->edid)) {
120 				if (connector->display_info.bpc)
121 					bpc = connector->display_info.bpc;
122 			}
123 		}
124 		break;
125 	case DRM_MODE_CONNECTOR_DVID:
126 	case DRM_MODE_CONNECTOR_HDMIA:
127 		if (drm_detect_hdmi_monitor(radeon_connector->edid)) {
128 			if (connector->display_info.bpc)
129 				bpc = connector->display_info.bpc;
130 		}
131 		break;
132 	case DRM_MODE_CONNECTOR_DisplayPort:
133 		dig_connector = radeon_connector->con_priv;
134 		if ((dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) ||
135 		    (dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_eDP) ||
136 		    drm_detect_hdmi_monitor(radeon_connector->edid)) {
137 			if (connector->display_info.bpc)
138 				bpc = connector->display_info.bpc;
139 		}
140 		break;
141 	case DRM_MODE_CONNECTOR_eDP:
142 	case DRM_MODE_CONNECTOR_LVDS:
143 		if (connector->display_info.bpc)
144 			bpc = connector->display_info.bpc;
145 		else if (ASIC_IS_DCE41(rdev) || ASIC_IS_DCE5(rdev)) {
146 			struct drm_connector_helper_funcs *connector_funcs =
147 				connector->helper_private;
148 			struct drm_encoder *encoder = connector_funcs->best_encoder(connector);
149 			struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
150 			struct radeon_encoder_atom_dig *dig = radeon_encoder->enc_priv;
151 
152 			if (dig->lcd_misc & ATOM_PANEL_MISC_V13_6BIT_PER_COLOR)
153 				bpc = 6;
154 			else if (dig->lcd_misc & ATOM_PANEL_MISC_V13_8BIT_PER_COLOR)
155 				bpc = 8;
156 		}
157 		break;
158 	}
159 	return bpc;
160 }
161 
162 static void
163 radeon_connector_update_scratch_regs(struct drm_connector *connector, enum drm_connector_status status)
164 {
165 	struct drm_device *dev = connector->dev;
166 	struct radeon_device *rdev = dev->dev_private;
167 	struct drm_encoder *best_encoder = NULL;
168 	struct drm_encoder *encoder = NULL;
169 	struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
170 	struct drm_mode_object *obj;
171 	bool connected;
172 	int i;
173 
174 	best_encoder = connector_funcs->best_encoder(connector);
175 
176 	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
177 		if (connector->encoder_ids[i] == 0)
178 			break;
179 
180 		obj = drm_mode_object_find(connector->dev,
181 					   connector->encoder_ids[i],
182 					   DRM_MODE_OBJECT_ENCODER);
183 		if (!obj)
184 			continue;
185 
186 		encoder = obj_to_encoder(obj);
187 
188 		if ((encoder == best_encoder) && (status == connector_status_connected))
189 			connected = true;
190 		else
191 			connected = false;
192 
193 		if (rdev->is_atom_bios)
194 			radeon_atombios_connected_scratch_regs(connector, encoder, connected);
195 		else
196 			radeon_combios_connected_scratch_regs(connector, encoder, connected);
197 
198 	}
199 }
200 
201 struct drm_encoder *radeon_find_encoder(struct drm_connector *connector, int encoder_type)
202 {
203 	struct drm_mode_object *obj;
204 	struct drm_encoder *encoder;
205 	int i;
206 
207 	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
208 		if (connector->encoder_ids[i] == 0)
209 			break;
210 
211 		obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
212 		if (!obj)
213 			continue;
214 
215 		encoder = obj_to_encoder(obj);
216 		if (encoder->encoder_type == encoder_type)
217 			return encoder;
218 	}
219 	return NULL;
220 }
221 
222 struct drm_encoder *radeon_best_single_encoder(struct drm_connector *connector)
223 {
224 	int enc_id = connector->encoder_ids[0];
225 	struct drm_mode_object *obj;
226 	struct drm_encoder *encoder;
227 
228 	/* pick the encoder ids */
229 	if (enc_id) {
230 		obj = drm_mode_object_find(connector->dev, enc_id, DRM_MODE_OBJECT_ENCODER);
231 		if (!obj)
232 			return NULL;
233 		encoder = obj_to_encoder(obj);
234 		return encoder;
235 	}
236 	return NULL;
237 }
238 
239 /*
240  * radeon_connector_analog_encoder_conflict_solve
241  * - search for other connectors sharing this encoder
242  *   if priority is true, then set them disconnected if this is connected
243  *   if priority is false, set us disconnected if they are connected
244  */
245 static enum drm_connector_status
246 radeon_connector_analog_encoder_conflict_solve(struct drm_connector *connector,
247 					       struct drm_encoder *encoder,
248 					       enum drm_connector_status current_status,
249 					       bool priority)
250 {
251 	struct drm_device *dev = connector->dev;
252 	struct drm_connector *conflict;
253 	struct radeon_connector *radeon_conflict;
254 	int i;
255 
256 	list_for_each_entry(conflict, &dev->mode_config.connector_list, head) {
257 		if (conflict == connector)
258 			continue;
259 
260 		radeon_conflict = to_radeon_connector(conflict);
261 		for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
262 			if (conflict->encoder_ids[i] == 0)
263 				break;
264 
265 			/* if the IDs match */
266 			if (conflict->encoder_ids[i] == encoder->base.id) {
267 				if (conflict->status != connector_status_connected)
268 					continue;
269 
270 				if (radeon_conflict->use_digital)
271 					continue;
272 
273 				if (priority == true) {
274 					DRM_DEBUG_KMS("1: conflicting encoders switching off %s\n", drm_get_connector_name(conflict));
275 					DRM_DEBUG_KMS("in favor of %s\n", drm_get_connector_name(connector));
276 					conflict->status = connector_status_disconnected;
277 					radeon_connector_update_scratch_regs(conflict, connector_status_disconnected);
278 				} else {
279 					DRM_DEBUG_KMS("2: conflicting encoders switching off %s\n", drm_get_connector_name(connector));
280 					DRM_DEBUG_KMS("in favor of %s\n", drm_get_connector_name(conflict));
281 					current_status = connector_status_disconnected;
282 				}
283 				break;
284 			}
285 		}
286 	}
287 	return current_status;
288 
289 }
290 
291 static struct drm_display_mode *radeon_fp_native_mode(struct drm_encoder *encoder)
292 {
293 	struct drm_device *dev = encoder->dev;
294 	struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
295 	struct drm_display_mode *mode = NULL;
296 	struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
297 
298 	if (native_mode->hdisplay != 0 &&
299 	    native_mode->vdisplay != 0 &&
300 	    native_mode->clock != 0) {
301 		mode = drm_mode_duplicate(dev, native_mode);
302 		mode->type = DRM_MODE_TYPE_PREFERRED | DRM_MODE_TYPE_DRIVER;
303 		drm_mode_set_name(mode);
304 
305 		DRM_DEBUG_KMS("Adding native panel mode %s\n", mode->name);
306 	} else if (native_mode->hdisplay != 0 &&
307 		   native_mode->vdisplay != 0) {
308 		/* mac laptops without an edid */
309 		/* Note that this is not necessarily the exact panel mode,
310 		 * but an approximation based on the cvt formula.  For these
311 		 * systems we should ideally read the mode info out of the
312 		 * registers or add a mode table, but this works and is much
313 		 * simpler.
314 		 */
315 		mode = drm_cvt_mode(dev, native_mode->hdisplay, native_mode->vdisplay, 60, true, false, false);
316 		mode->type = DRM_MODE_TYPE_PREFERRED | DRM_MODE_TYPE_DRIVER;
317 		DRM_DEBUG_KMS("Adding cvt approximation of native panel mode %s\n", mode->name);
318 	}
319 	return mode;
320 }
321 
322 static void radeon_add_common_modes(struct drm_encoder *encoder, struct drm_connector *connector)
323 {
324 	struct drm_device *dev = encoder->dev;
325 	struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
326 	struct drm_display_mode *mode = NULL;
327 	struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
328 	int i;
329 	struct mode_size {
330 		int w;
331 		int h;
332 	} common_modes[17] = {
333 		{ 640,  480},
334 		{ 720,  480},
335 		{ 800,  600},
336 		{ 848,  480},
337 		{1024,  768},
338 		{1152,  768},
339 		{1280,  720},
340 		{1280,  800},
341 		{1280,  854},
342 		{1280,  960},
343 		{1280, 1024},
344 		{1440,  900},
345 		{1400, 1050},
346 		{1680, 1050},
347 		{1600, 1200},
348 		{1920, 1080},
349 		{1920, 1200}
350 	};
351 
352 	for (i = 0; i < 17; i++) {
353 		if (radeon_encoder->devices & (ATOM_DEVICE_TV_SUPPORT)) {
354 			if (common_modes[i].w > 1024 ||
355 			    common_modes[i].h > 768)
356 				continue;
357 		}
358 		if (radeon_encoder->devices & (ATOM_DEVICE_LCD_SUPPORT)) {
359 			if (common_modes[i].w > native_mode->hdisplay ||
360 			    common_modes[i].h > native_mode->vdisplay ||
361 			    (common_modes[i].w == native_mode->hdisplay &&
362 			     common_modes[i].h == native_mode->vdisplay))
363 				continue;
364 		}
365 		if (common_modes[i].w < 320 || common_modes[i].h < 200)
366 			continue;
367 
368 		mode = drm_cvt_mode(dev, common_modes[i].w, common_modes[i].h, 60, false, false, false);
369 		drm_mode_probed_add(connector, mode);
370 	}
371 }
372 
373 int radeon_connector_set_property(struct drm_connector *connector, struct drm_property *property,
374 				  uint64_t val)
375 {
376 	struct drm_device *dev = connector->dev;
377 	struct radeon_device *rdev = dev->dev_private;
378 	struct drm_encoder *encoder;
379 	struct radeon_encoder *radeon_encoder;
380 
381 	if (property == rdev->mode_info.coherent_mode_property) {
382 		struct radeon_encoder_atom_dig *dig;
383 		bool new_coherent_mode;
384 
385 		/* need to find digital encoder on connector */
386 		encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
387 		if (!encoder)
388 			return 0;
389 
390 		radeon_encoder = to_radeon_encoder(encoder);
391 
392 		if (!radeon_encoder->enc_priv)
393 			return 0;
394 
395 		dig = radeon_encoder->enc_priv;
396 		new_coherent_mode = val ? true : false;
397 		if (dig->coherent_mode != new_coherent_mode) {
398 			dig->coherent_mode = new_coherent_mode;
399 			radeon_property_change_mode(&radeon_encoder->base);
400 		}
401 	}
402 
403 	if (property == rdev->mode_info.underscan_property) {
404 		/* need to find digital encoder on connector */
405 		encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
406 		if (!encoder)
407 			return 0;
408 
409 		radeon_encoder = to_radeon_encoder(encoder);
410 
411 		if (radeon_encoder->underscan_type != val) {
412 			radeon_encoder->underscan_type = val;
413 			radeon_property_change_mode(&radeon_encoder->base);
414 		}
415 	}
416 
417 	if (property == rdev->mode_info.underscan_hborder_property) {
418 		/* need to find digital encoder on connector */
419 		encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
420 		if (!encoder)
421 			return 0;
422 
423 		radeon_encoder = to_radeon_encoder(encoder);
424 
425 		if (radeon_encoder->underscan_hborder != val) {
426 			radeon_encoder->underscan_hborder = val;
427 			radeon_property_change_mode(&radeon_encoder->base);
428 		}
429 	}
430 
431 	if (property == rdev->mode_info.underscan_vborder_property) {
432 		/* need to find digital encoder on connector */
433 		encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
434 		if (!encoder)
435 			return 0;
436 
437 		radeon_encoder = to_radeon_encoder(encoder);
438 
439 		if (radeon_encoder->underscan_vborder != val) {
440 			radeon_encoder->underscan_vborder = val;
441 			radeon_property_change_mode(&radeon_encoder->base);
442 		}
443 	}
444 
445 	if (property == rdev->mode_info.tv_std_property) {
446 		encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TVDAC);
447 		if (!encoder) {
448 			encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_DAC);
449 		}
450 
451 		if (!encoder)
452 			return 0;
453 
454 		radeon_encoder = to_radeon_encoder(encoder);
455 		if (!radeon_encoder->enc_priv)
456 			return 0;
457 		if (ASIC_IS_AVIVO(rdev) || radeon_r4xx_atom) {
458 			struct radeon_encoder_atom_dac *dac_int;
459 			dac_int = radeon_encoder->enc_priv;
460 			dac_int->tv_std = val;
461 		} else {
462 			struct radeon_encoder_tv_dac *dac_int;
463 			dac_int = radeon_encoder->enc_priv;
464 			dac_int->tv_std = val;
465 		}
466 		radeon_property_change_mode(&radeon_encoder->base);
467 	}
468 
469 	if (property == rdev->mode_info.load_detect_property) {
470 		struct radeon_connector *radeon_connector =
471 			to_radeon_connector(connector);
472 
473 		if (val == 0)
474 			radeon_connector->dac_load_detect = false;
475 		else
476 			radeon_connector->dac_load_detect = true;
477 	}
478 
479 	if (property == rdev->mode_info.tmds_pll_property) {
480 		struct radeon_encoder_int_tmds *tmds = NULL;
481 		bool ret = false;
482 		/* need to find digital encoder on connector */
483 		encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
484 		if (!encoder)
485 			return 0;
486 
487 		radeon_encoder = to_radeon_encoder(encoder);
488 
489 		tmds = radeon_encoder->enc_priv;
490 		if (!tmds)
491 			return 0;
492 
493 		if (val == 0) {
494 			if (rdev->is_atom_bios)
495 				ret = radeon_atombios_get_tmds_info(radeon_encoder, tmds);
496 			else
497 				ret = radeon_legacy_get_tmds_info_from_combios(radeon_encoder, tmds);
498 		}
499 		if (val == 1 || ret == false) {
500 			radeon_legacy_get_tmds_info_from_table(radeon_encoder, tmds);
501 		}
502 		radeon_property_change_mode(&radeon_encoder->base);
503 	}
504 
505 	return 0;
506 }
507 
508 static void radeon_fixup_lvds_native_mode(struct drm_encoder *encoder,
509 					  struct drm_connector *connector)
510 {
511 	struct radeon_encoder *radeon_encoder =	to_radeon_encoder(encoder);
512 	struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
513 	struct drm_display_mode *t, *mode;
514 
515 	/* If the EDID preferred mode doesn't match the native mode, use it */
516 	list_for_each_entry_safe(mode, t, &connector->probed_modes, head) {
517 		if (mode->type & DRM_MODE_TYPE_PREFERRED) {
518 			if (mode->hdisplay != native_mode->hdisplay ||
519 			    mode->vdisplay != native_mode->vdisplay)
520 				memcpy(native_mode, mode, sizeof(*mode));
521 		}
522 	}
523 
524 	/* Try to get native mode details from EDID if necessary */
525 	if (!native_mode->clock) {
526 		list_for_each_entry_safe(mode, t, &connector->probed_modes, head) {
527 			if (mode->hdisplay == native_mode->hdisplay &&
528 			    mode->vdisplay == native_mode->vdisplay) {
529 				*native_mode = *mode;
530 				drm_mode_set_crtcinfo(native_mode, CRTC_INTERLACE_HALVE_V);
531 				DRM_DEBUG_KMS("Determined LVDS native mode details from EDID\n");
532 				break;
533 			}
534 		}
535 	}
536 
537 	if (!native_mode->clock) {
538 		DRM_DEBUG_KMS("No LVDS native mode details, disabling RMX\n");
539 		radeon_encoder->rmx_type = RMX_OFF;
540 	}
541 }
542 
543 static int radeon_lvds_get_modes(struct drm_connector *connector)
544 {
545 	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
546 	struct drm_encoder *encoder;
547 	int ret = 0;
548 	struct drm_display_mode *mode;
549 
550 	if (radeon_connector->ddc_bus) {
551 		ret = radeon_ddc_get_modes(radeon_connector);
552 		if (ret > 0) {
553 			encoder = radeon_best_single_encoder(connector);
554 			if (encoder) {
555 				radeon_fixup_lvds_native_mode(encoder, connector);
556 				/* add scaled modes */
557 				radeon_add_common_modes(encoder, connector);
558 			}
559 			return ret;
560 		}
561 	}
562 
563 	encoder = radeon_best_single_encoder(connector);
564 	if (!encoder)
565 		return 0;
566 
567 	/* we have no EDID modes */
568 	mode = radeon_fp_native_mode(encoder);
569 	if (mode) {
570 		ret = 1;
571 		drm_mode_probed_add(connector, mode);
572 		/* add the width/height from vbios tables if available */
573 		connector->display_info.width_mm = mode->width_mm;
574 		connector->display_info.height_mm = mode->height_mm;
575 		/* add scaled modes */
576 		radeon_add_common_modes(encoder, connector);
577 	}
578 
579 	return ret;
580 }
581 
582 static int radeon_lvds_mode_valid(struct drm_connector *connector,
583 				  struct drm_display_mode *mode)
584 {
585 	struct drm_encoder *encoder = radeon_best_single_encoder(connector);
586 
587 	if ((mode->hdisplay < 320) || (mode->vdisplay < 240))
588 		return MODE_PANEL;
589 
590 	if (encoder) {
591 		struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
592 		struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
593 
594 		/* AVIVO hardware supports downscaling modes larger than the panel
595 		 * to the panel size, but I'm not sure this is desirable.
596 		 */
597 		if ((mode->hdisplay > native_mode->hdisplay) ||
598 		    (mode->vdisplay > native_mode->vdisplay))
599 			return MODE_PANEL;
600 
601 		/* if scaling is disabled, block non-native modes */
602 		if (radeon_encoder->rmx_type == RMX_OFF) {
603 			if ((mode->hdisplay != native_mode->hdisplay) ||
604 			    (mode->vdisplay != native_mode->vdisplay))
605 				return MODE_PANEL;
606 		}
607 	}
608 
609 	return MODE_OK;
610 }
611 
612 static enum drm_connector_status
613 radeon_lvds_detect(struct drm_connector *connector, bool force)
614 {
615 	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
616 	struct drm_encoder *encoder = radeon_best_single_encoder(connector);
617 	enum drm_connector_status ret = connector_status_disconnected;
618 
619 	if (encoder) {
620 		struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
621 		struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
622 
623 		/* check if panel is valid */
624 		if (native_mode->hdisplay >= 320 && native_mode->vdisplay >= 240)
625 			ret = connector_status_connected;
626 
627 	}
628 
629 	/* check for edid as well */
630 	if (radeon_connector->edid)
631 		ret = connector_status_connected;
632 	else {
633 		if (radeon_connector->ddc_bus) {
634 			radeon_connector->edid = drm_get_edid(&radeon_connector->base,
635 							      &radeon_connector->ddc_bus->adapter);
636 			if (radeon_connector->edid)
637 				ret = connector_status_connected;
638 		}
639 	}
640 	/* check acpi lid status ??? */
641 
642 	radeon_connector_update_scratch_regs(connector, ret);
643 	return ret;
644 }
645 
646 static void radeon_connector_destroy(struct drm_connector *connector)
647 {
648 	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
649 
650 	if (radeon_connector->edid)
651 		kfree(radeon_connector->edid);
652 	kfree(radeon_connector->con_priv);
653 	drm_sysfs_connector_remove(connector);
654 	drm_connector_cleanup(connector);
655 	kfree(connector);
656 }
657 
658 static int radeon_lvds_set_property(struct drm_connector *connector,
659 				    struct drm_property *property,
660 				    uint64_t value)
661 {
662 	struct drm_device *dev = connector->dev;
663 	struct radeon_encoder *radeon_encoder;
664 	enum radeon_rmx_type rmx_type;
665 
666 	DRM_DEBUG_KMS("\n");
667 	if (property != dev->mode_config.scaling_mode_property)
668 		return 0;
669 
670 	if (connector->encoder)
671 		radeon_encoder = to_radeon_encoder(connector->encoder);
672 	else {
673 		struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
674 		radeon_encoder = to_radeon_encoder(connector_funcs->best_encoder(connector));
675 	}
676 
677 	switch (value) {
678 	case DRM_MODE_SCALE_NONE: rmx_type = RMX_OFF; break;
679 	case DRM_MODE_SCALE_CENTER: rmx_type = RMX_CENTER; break;
680 	case DRM_MODE_SCALE_ASPECT: rmx_type = RMX_ASPECT; break;
681 	default:
682 	case DRM_MODE_SCALE_FULLSCREEN: rmx_type = RMX_FULL; break;
683 	}
684 	if (radeon_encoder->rmx_type == rmx_type)
685 		return 0;
686 
687 	radeon_encoder->rmx_type = rmx_type;
688 
689 	radeon_property_change_mode(&radeon_encoder->base);
690 	return 0;
691 }
692 
693 
694 struct drm_connector_helper_funcs radeon_lvds_connector_helper_funcs = {
695 	.get_modes = radeon_lvds_get_modes,
696 	.mode_valid = radeon_lvds_mode_valid,
697 	.best_encoder = radeon_best_single_encoder,
698 };
699 
700 struct drm_connector_funcs radeon_lvds_connector_funcs = {
701 	.dpms = drm_helper_connector_dpms,
702 	.detect = radeon_lvds_detect,
703 	.fill_modes = drm_helper_probe_single_connector_modes,
704 	.destroy = radeon_connector_destroy,
705 	.set_property = radeon_lvds_set_property,
706 };
707 
708 static int radeon_vga_get_modes(struct drm_connector *connector)
709 {
710 	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
711 	int ret;
712 
713 	ret = radeon_ddc_get_modes(radeon_connector);
714 
715 	return ret;
716 }
717 
718 static int radeon_vga_mode_valid(struct drm_connector *connector,
719 				  struct drm_display_mode *mode)
720 {
721 	struct drm_device *dev = connector->dev;
722 	struct radeon_device *rdev = dev->dev_private;
723 
724 	/* XXX check mode bandwidth */
725 
726 	if ((mode->clock / 10) > rdev->clock.max_pixel_clock)
727 		return MODE_CLOCK_HIGH;
728 
729 	return MODE_OK;
730 }
731 
732 static enum drm_connector_status
733 radeon_vga_detect(struct drm_connector *connector, bool force)
734 {
735 	struct drm_device *dev = connector->dev;
736 	struct radeon_device *rdev = dev->dev_private;
737 	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
738 	struct drm_encoder *encoder;
739 	struct drm_encoder_helper_funcs *encoder_funcs;
740 	bool dret = false;
741 	enum drm_connector_status ret = connector_status_disconnected;
742 
743 	encoder = radeon_best_single_encoder(connector);
744 	if (!encoder)
745 		ret = connector_status_disconnected;
746 
747 	if (radeon_connector->ddc_bus)
748 		dret = radeon_ddc_probe(radeon_connector);
749 	if (dret) {
750 		radeon_connector->detected_by_load = false;
751 		if (radeon_connector->edid) {
752 			kfree(radeon_connector->edid);
753 			radeon_connector->edid = NULL;
754 		}
755 		radeon_connector->edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
756 
757 		if (!radeon_connector->edid) {
758 			DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
759 					drm_get_connector_name(connector));
760 			ret = connector_status_connected;
761 		} else {
762 			radeon_connector->use_digital = !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
763 
764 			/* some oems have boards with separate digital and analog connectors
765 			 * with a shared ddc line (often vga + hdmi)
766 			 */
767 			if (radeon_connector->use_digital && radeon_connector->shared_ddc) {
768 				kfree(radeon_connector->edid);
769 				radeon_connector->edid = NULL;
770 				ret = connector_status_disconnected;
771 			} else
772 				ret = connector_status_connected;
773 		}
774 	} else {
775 
776 		/* if we aren't forcing don't do destructive polling */
777 		if (!force) {
778 			/* only return the previous status if we last
779 			 * detected a monitor via load.
780 			 */
781 			if (radeon_connector->detected_by_load)
782 				return connector->status;
783 			else
784 				return ret;
785 		}
786 
787 		if (radeon_connector->dac_load_detect && encoder) {
788 			encoder_funcs = encoder->helper_private;
789 			ret = encoder_funcs->detect(encoder, connector);
790 			if (ret != connector_status_disconnected)
791 				radeon_connector->detected_by_load = true;
792 		}
793 	}
794 
795 	if (ret == connector_status_connected)
796 		ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
797 
798 	/* RN50 and some RV100 asics in servers often have a hardcoded EDID in the
799 	 * vbios to deal with KVMs. If we have one and are not able to detect a monitor
800 	 * by other means, assume the CRT is connected and use that EDID.
801 	 */
802 	if ((!rdev->is_atom_bios) &&
803 	    (ret == connector_status_disconnected) &&
804 	    rdev->mode_info.bios_hardcoded_edid_size) {
805 		ret = connector_status_connected;
806 	}
807 
808 	radeon_connector_update_scratch_regs(connector, ret);
809 	return ret;
810 }
811 
812 struct drm_connector_helper_funcs radeon_vga_connector_helper_funcs = {
813 	.get_modes = radeon_vga_get_modes,
814 	.mode_valid = radeon_vga_mode_valid,
815 	.best_encoder = radeon_best_single_encoder,
816 };
817 
818 struct drm_connector_funcs radeon_vga_connector_funcs = {
819 	.dpms = drm_helper_connector_dpms,
820 	.detect = radeon_vga_detect,
821 	.fill_modes = drm_helper_probe_single_connector_modes,
822 	.destroy = radeon_connector_destroy,
823 	.set_property = radeon_connector_set_property,
824 };
825 
826 static int radeon_tv_get_modes(struct drm_connector *connector)
827 {
828 	struct drm_device *dev = connector->dev;
829 	struct radeon_device *rdev = dev->dev_private;
830 	struct drm_display_mode *tv_mode;
831 	struct drm_encoder *encoder;
832 
833 	encoder = radeon_best_single_encoder(connector);
834 	if (!encoder)
835 		return 0;
836 
837 	/* avivo chips can scale any mode */
838 	if (rdev->family >= CHIP_RS600)
839 		/* add scaled modes */
840 		radeon_add_common_modes(encoder, connector);
841 	else {
842 		/* only 800x600 is supported right now on pre-avivo chips */
843 		tv_mode = drm_cvt_mode(dev, 800, 600, 60, false, false, false);
844 		tv_mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
845 		drm_mode_probed_add(connector, tv_mode);
846 	}
847 	return 1;
848 }
849 
850 static int radeon_tv_mode_valid(struct drm_connector *connector,
851 				struct drm_display_mode *mode)
852 {
853 	if ((mode->hdisplay > 1024) || (mode->vdisplay > 768))
854 		return MODE_CLOCK_RANGE;
855 	return MODE_OK;
856 }
857 
858 static enum drm_connector_status
859 radeon_tv_detect(struct drm_connector *connector, bool force)
860 {
861 	struct drm_encoder *encoder;
862 	struct drm_encoder_helper_funcs *encoder_funcs;
863 	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
864 	enum drm_connector_status ret = connector_status_disconnected;
865 
866 	if (!radeon_connector->dac_load_detect)
867 		return ret;
868 
869 	encoder = radeon_best_single_encoder(connector);
870 	if (!encoder)
871 		ret = connector_status_disconnected;
872 	else {
873 		encoder_funcs = encoder->helper_private;
874 		ret = encoder_funcs->detect(encoder, connector);
875 	}
876 	if (ret == connector_status_connected)
877 		ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, false);
878 	radeon_connector_update_scratch_regs(connector, ret);
879 	return ret;
880 }
881 
882 struct drm_connector_helper_funcs radeon_tv_connector_helper_funcs = {
883 	.get_modes = radeon_tv_get_modes,
884 	.mode_valid = radeon_tv_mode_valid,
885 	.best_encoder = radeon_best_single_encoder,
886 };
887 
888 struct drm_connector_funcs radeon_tv_connector_funcs = {
889 	.dpms = drm_helper_connector_dpms,
890 	.detect = radeon_tv_detect,
891 	.fill_modes = drm_helper_probe_single_connector_modes,
892 	.destroy = radeon_connector_destroy,
893 	.set_property = radeon_connector_set_property,
894 };
895 
896 static int radeon_dvi_get_modes(struct drm_connector *connector)
897 {
898 	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
899 	int ret;
900 
901 	ret = radeon_ddc_get_modes(radeon_connector);
902 	return ret;
903 }
904 
905 static bool radeon_check_hpd_status_unchanged(struct drm_connector *connector)
906 {
907 	struct drm_device *dev = connector->dev;
908 	struct radeon_device *rdev = dev->dev_private;
909 	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
910 	enum drm_connector_status status;
911 
912 	/* We only trust HPD on R600 and newer ASICS. */
913 	if (rdev->family >= CHIP_R600
914 	  && radeon_connector->hpd.hpd != RADEON_HPD_NONE) {
915 		if (radeon_hpd_sense(rdev, radeon_connector->hpd.hpd))
916 			status = connector_status_connected;
917 		else
918 			status = connector_status_disconnected;
919 		if (connector->status == status)
920 			return true;
921 	}
922 
923 	return false;
924 }
925 
926 /*
927  * DVI is complicated
928  * Do a DDC probe, if DDC probe passes, get the full EDID so
929  * we can do analog/digital monitor detection at this point.
930  * If the monitor is an analog monitor or we got no DDC,
931  * we need to find the DAC encoder object for this connector.
932  * If we got no DDC, we do load detection on the DAC encoder object.
933  * If we got analog DDC or load detection passes on the DAC encoder
934  * we have to check if this analog encoder is shared with anyone else (TV)
935  * if its shared we have to set the other connector to disconnected.
936  */
937 static enum drm_connector_status
938 radeon_dvi_detect(struct drm_connector *connector, bool force)
939 {
940 	struct drm_device *dev = connector->dev;
941 	struct radeon_device *rdev = dev->dev_private;
942 	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
943 	struct drm_encoder *encoder = NULL;
944 	struct drm_encoder_helper_funcs *encoder_funcs;
945 	struct drm_mode_object *obj;
946 	int i;
947 	enum drm_connector_status ret = connector_status_disconnected;
948 	bool dret = false;
949 
950 	if (!force && radeon_check_hpd_status_unchanged(connector))
951 		return connector->status;
952 
953 	if (radeon_connector->ddc_bus)
954 		dret = radeon_ddc_probe(radeon_connector);
955 	if (dret) {
956 		radeon_connector->detected_by_load = false;
957 		if (radeon_connector->edid) {
958 			kfree(radeon_connector->edid);
959 			radeon_connector->edid = NULL;
960 		}
961 		radeon_connector->edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
962 
963 		if (!radeon_connector->edid) {
964 			DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
965 					drm_get_connector_name(connector));
966 			/* rs690 seems to have a problem with connectors not existing and always
967 			 * return a block of 0's. If we see this just stop polling on this output */
968 			if ((rdev->family == CHIP_RS690 || rdev->family == CHIP_RS740) && radeon_connector->base.null_edid_counter) {
969 				ret = connector_status_disconnected;
970 				DRM_ERROR("%s: detected RS690 floating bus bug, stopping ddc detect\n", drm_get_connector_name(connector));
971 				radeon_connector->ddc_bus = NULL;
972 			}
973 		} else {
974 			radeon_connector->use_digital = !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
975 
976 			/* some oems have boards with separate digital and analog connectors
977 			 * with a shared ddc line (often vga + hdmi)
978 			 */
979 			if ((!radeon_connector->use_digital) && radeon_connector->shared_ddc) {
980 				kfree(radeon_connector->edid);
981 				radeon_connector->edid = NULL;
982 				ret = connector_status_disconnected;
983 			} else
984 				ret = connector_status_connected;
985 
986 			/* This gets complicated.  We have boards with VGA + HDMI with a
987 			 * shared DDC line and we have boards with DVI-D + HDMI with a shared
988 			 * DDC line.  The latter is more complex because with DVI<->HDMI adapters
989 			 * you don't really know what's connected to which port as both are digital.
990 			 */
991 			if (radeon_connector->shared_ddc && (ret == connector_status_connected)) {
992 				struct drm_connector *list_connector;
993 				struct radeon_connector *list_radeon_connector;
994 				list_for_each_entry(list_connector, &dev->mode_config.connector_list, head) {
995 					if (connector == list_connector)
996 						continue;
997 					list_radeon_connector = to_radeon_connector(list_connector);
998 					if (list_radeon_connector->shared_ddc &&
999 					    (list_radeon_connector->ddc_bus->rec.i2c_id ==
1000 					     radeon_connector->ddc_bus->rec.i2c_id)) {
1001 						/* cases where both connectors are digital */
1002 						if (list_connector->connector_type != DRM_MODE_CONNECTOR_VGA) {
1003 							/* hpd is our only option in this case */
1004 							if (!radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) {
1005 								kfree(radeon_connector->edid);
1006 								radeon_connector->edid = NULL;
1007 								ret = connector_status_disconnected;
1008 							}
1009 						}
1010 					}
1011 				}
1012 			}
1013 		}
1014 	}
1015 
1016 	if ((ret == connector_status_connected) && (radeon_connector->use_digital == true))
1017 		goto out;
1018 
1019 	/* DVI-D and HDMI-A are digital only */
1020 	if ((connector->connector_type == DRM_MODE_CONNECTOR_DVID) ||
1021 	    (connector->connector_type == DRM_MODE_CONNECTOR_HDMIA))
1022 		goto out;
1023 
1024 	/* if we aren't forcing don't do destructive polling */
1025 	if (!force) {
1026 		/* only return the previous status if we last
1027 		 * detected a monitor via load.
1028 		 */
1029 		if (radeon_connector->detected_by_load)
1030 			ret = connector->status;
1031 		goto out;
1032 	}
1033 
1034 	/* find analog encoder */
1035 	if (radeon_connector->dac_load_detect) {
1036 		for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
1037 			if (connector->encoder_ids[i] == 0)
1038 				break;
1039 
1040 			obj = drm_mode_object_find(connector->dev,
1041 						   connector->encoder_ids[i],
1042 						   DRM_MODE_OBJECT_ENCODER);
1043 			if (!obj)
1044 				continue;
1045 
1046 			encoder = obj_to_encoder(obj);
1047 
1048 			if (encoder->encoder_type != DRM_MODE_ENCODER_DAC &&
1049 			    encoder->encoder_type != DRM_MODE_ENCODER_TVDAC)
1050 				continue;
1051 
1052 			encoder_funcs = encoder->helper_private;
1053 			if (encoder_funcs->detect) {
1054 				if (ret != connector_status_connected) {
1055 					ret = encoder_funcs->detect(encoder, connector);
1056 					if (ret == connector_status_connected) {
1057 						radeon_connector->use_digital = false;
1058 					}
1059 					if (ret != connector_status_disconnected)
1060 						radeon_connector->detected_by_load = true;
1061 				}
1062 				break;
1063 			}
1064 		}
1065 	}
1066 
1067 	if ((ret == connector_status_connected) && (radeon_connector->use_digital == false) &&
1068 	    encoder) {
1069 		ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
1070 	}
1071 
1072 	/* RN50 and some RV100 asics in servers often have a hardcoded EDID in the
1073 	 * vbios to deal with KVMs. If we have one and are not able to detect a monitor
1074 	 * by other means, assume the DFP is connected and use that EDID.  In most
1075 	 * cases the DVI port is actually a virtual KVM port connected to the service
1076 	 * processor.
1077 	 */
1078 out:
1079 	if ((!rdev->is_atom_bios) &&
1080 	    (ret == connector_status_disconnected) &&
1081 	    rdev->mode_info.bios_hardcoded_edid_size) {
1082 		radeon_connector->use_digital = true;
1083 		ret = connector_status_connected;
1084 	}
1085 
1086 	/* updated in get modes as well since we need to know if it's analog or digital */
1087 	radeon_connector_update_scratch_regs(connector, ret);
1088 	return ret;
1089 }
1090 
1091 /* okay need to be smart in here about which encoder to pick */
1092 struct drm_encoder *radeon_dvi_encoder(struct drm_connector *connector)
1093 {
1094 	int enc_id = connector->encoder_ids[0];
1095 	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1096 	struct drm_mode_object *obj;
1097 	struct drm_encoder *encoder;
1098 	int i;
1099 	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
1100 		if (connector->encoder_ids[i] == 0)
1101 			break;
1102 
1103 		obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
1104 		if (!obj)
1105 			continue;
1106 
1107 		encoder = obj_to_encoder(obj);
1108 
1109 		if (radeon_connector->use_digital == true) {
1110 			if (encoder->encoder_type == DRM_MODE_ENCODER_TMDS)
1111 				return encoder;
1112 		} else {
1113 			if (encoder->encoder_type == DRM_MODE_ENCODER_DAC ||
1114 			    encoder->encoder_type == DRM_MODE_ENCODER_TVDAC)
1115 				return encoder;
1116 		}
1117 	}
1118 
1119 	/* see if we have a default encoder  TODO */
1120 
1121 	/* then check use digitial */
1122 	/* pick the first one */
1123 	if (enc_id) {
1124 		obj = drm_mode_object_find(connector->dev, enc_id, DRM_MODE_OBJECT_ENCODER);
1125 		if (!obj)
1126 			return NULL;
1127 		encoder = obj_to_encoder(obj);
1128 		return encoder;
1129 	}
1130 	return NULL;
1131 }
1132 
1133 static void radeon_dvi_force(struct drm_connector *connector)
1134 {
1135 	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1136 	if (connector->force == DRM_FORCE_ON)
1137 		radeon_connector->use_digital = false;
1138 	if (connector->force == DRM_FORCE_ON_DIGITAL)
1139 		radeon_connector->use_digital = true;
1140 }
1141 
1142 static int radeon_dvi_mode_valid(struct drm_connector *connector,
1143 				  struct drm_display_mode *mode)
1144 {
1145 	struct drm_device *dev = connector->dev;
1146 	struct radeon_device *rdev = dev->dev_private;
1147 	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1148 
1149 	/* XXX check mode bandwidth */
1150 
1151 	/* clocks over 135 MHz have heat issues with DVI on RV100 */
1152 	if (radeon_connector->use_digital &&
1153 	    (rdev->family == CHIP_RV100) &&
1154 	    (mode->clock > 135000))
1155 		return MODE_CLOCK_HIGH;
1156 
1157 	if (radeon_connector->use_digital && (mode->clock > 165000)) {
1158 		if ((radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_I) ||
1159 		    (radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_D) ||
1160 		    (radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_HDMI_TYPE_B))
1161 			return MODE_OK;
1162 		else if (radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_HDMI_TYPE_A) {
1163 			if (ASIC_IS_DCE6(rdev)) {
1164 				/* HDMI 1.3+ supports max clock of 340 Mhz */
1165 				if (mode->clock > 340000)
1166 					return MODE_CLOCK_HIGH;
1167 				else
1168 					return MODE_OK;
1169 			} else
1170 				return MODE_CLOCK_HIGH;
1171 		} else
1172 			return MODE_CLOCK_HIGH;
1173 	}
1174 
1175 	/* check against the max pixel clock */
1176 	if ((mode->clock / 10) > rdev->clock.max_pixel_clock)
1177 		return MODE_CLOCK_HIGH;
1178 
1179 	return MODE_OK;
1180 }
1181 
1182 struct drm_connector_helper_funcs radeon_dvi_connector_helper_funcs = {
1183 	.get_modes = radeon_dvi_get_modes,
1184 	.mode_valid = radeon_dvi_mode_valid,
1185 	.best_encoder = radeon_dvi_encoder,
1186 };
1187 
1188 struct drm_connector_funcs radeon_dvi_connector_funcs = {
1189 	.dpms = drm_helper_connector_dpms,
1190 	.detect = radeon_dvi_detect,
1191 	.fill_modes = drm_helper_probe_single_connector_modes,
1192 	.set_property = radeon_connector_set_property,
1193 	.destroy = radeon_connector_destroy,
1194 	.force = radeon_dvi_force,
1195 };
1196 
1197 static void radeon_dp_connector_destroy(struct drm_connector *connector)
1198 {
1199 	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1200 	struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
1201 
1202 	if (radeon_connector->edid)
1203 		kfree(radeon_connector->edid);
1204 	if (radeon_dig_connector->dp_i2c_bus)
1205 		radeon_i2c_destroy(radeon_dig_connector->dp_i2c_bus);
1206 	kfree(radeon_connector->con_priv);
1207 	drm_sysfs_connector_remove(connector);
1208 	drm_connector_cleanup(connector);
1209 	kfree(connector);
1210 }
1211 
1212 static int radeon_dp_get_modes(struct drm_connector *connector)
1213 {
1214 	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1215 	struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
1216 	struct drm_encoder *encoder = radeon_best_single_encoder(connector);
1217 	int ret;
1218 
1219 	if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) ||
1220 	    (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
1221 		struct drm_display_mode *mode;
1222 
1223 		if (connector->connector_type == DRM_MODE_CONNECTOR_eDP) {
1224 			if (!radeon_dig_connector->edp_on)
1225 				atombios_set_edp_panel_power(connector,
1226 							     ATOM_TRANSMITTER_ACTION_POWER_ON);
1227 			ret = radeon_ddc_get_modes(radeon_connector);
1228 			if (!radeon_dig_connector->edp_on)
1229 				atombios_set_edp_panel_power(connector,
1230 							     ATOM_TRANSMITTER_ACTION_POWER_OFF);
1231 		} else {
1232 			/* need to setup ddc on the bridge */
1233 			if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
1234 			    ENCODER_OBJECT_ID_NONE) {
1235 				if (encoder)
1236 					radeon_atom_ext_encoder_setup_ddc(encoder);
1237 			}
1238 			ret = radeon_ddc_get_modes(radeon_connector);
1239 		}
1240 
1241 		if (ret > 0) {
1242 			if (encoder) {
1243 				radeon_fixup_lvds_native_mode(encoder, connector);
1244 				/* add scaled modes */
1245 				radeon_add_common_modes(encoder, connector);
1246 			}
1247 			return ret;
1248 		}
1249 
1250 		if (!encoder)
1251 			return 0;
1252 
1253 		/* we have no EDID modes */
1254 		mode = radeon_fp_native_mode(encoder);
1255 		if (mode) {
1256 			ret = 1;
1257 			drm_mode_probed_add(connector, mode);
1258 			/* add the width/height from vbios tables if available */
1259 			connector->display_info.width_mm = mode->width_mm;
1260 			connector->display_info.height_mm = mode->height_mm;
1261 			/* add scaled modes */
1262 			radeon_add_common_modes(encoder, connector);
1263 		}
1264 	} else {
1265 		/* need to setup ddc on the bridge */
1266 		if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
1267 			ENCODER_OBJECT_ID_NONE) {
1268 			if (encoder)
1269 				radeon_atom_ext_encoder_setup_ddc(encoder);
1270 		}
1271 		ret = radeon_ddc_get_modes(radeon_connector);
1272 	}
1273 
1274 	return ret;
1275 }
1276 
1277 u16 radeon_connector_encoder_get_dp_bridge_encoder_id(struct drm_connector *connector)
1278 {
1279 	struct drm_mode_object *obj;
1280 	struct drm_encoder *encoder;
1281 	struct radeon_encoder *radeon_encoder;
1282 	int i;
1283 
1284 	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
1285 		if (connector->encoder_ids[i] == 0)
1286 			break;
1287 
1288 		obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
1289 		if (!obj)
1290 			continue;
1291 
1292 		encoder = obj_to_encoder(obj);
1293 		radeon_encoder = to_radeon_encoder(encoder);
1294 
1295 		switch (radeon_encoder->encoder_id) {
1296 		case ENCODER_OBJECT_ID_TRAVIS:
1297 		case ENCODER_OBJECT_ID_NUTMEG:
1298 			return radeon_encoder->encoder_id;
1299 		default:
1300 			break;
1301 		}
1302 	}
1303 
1304 	return ENCODER_OBJECT_ID_NONE;
1305 }
1306 
1307 bool radeon_connector_encoder_is_hbr2(struct drm_connector *connector)
1308 {
1309 	struct drm_mode_object *obj;
1310 	struct drm_encoder *encoder;
1311 	struct radeon_encoder *radeon_encoder;
1312 	int i;
1313 	bool found = false;
1314 
1315 	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
1316 		if (connector->encoder_ids[i] == 0)
1317 			break;
1318 
1319 		obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
1320 		if (!obj)
1321 			continue;
1322 
1323 		encoder = obj_to_encoder(obj);
1324 		radeon_encoder = to_radeon_encoder(encoder);
1325 		if (radeon_encoder->caps & ATOM_ENCODER_CAP_RECORD_HBR2)
1326 			found = true;
1327 	}
1328 
1329 	return found;
1330 }
1331 
1332 bool radeon_connector_is_dp12_capable(struct drm_connector *connector)
1333 {
1334 	struct drm_device *dev = connector->dev;
1335 	struct radeon_device *rdev = dev->dev_private;
1336 
1337 	if (ASIC_IS_DCE5(rdev) &&
1338 	    (rdev->clock.dp_extclk >= 53900) &&
1339 	    radeon_connector_encoder_is_hbr2(connector)) {
1340 		return true;
1341 	}
1342 
1343 	return false;
1344 }
1345 
1346 static enum drm_connector_status
1347 radeon_dp_detect(struct drm_connector *connector, bool force)
1348 {
1349 	struct drm_device *dev = connector->dev;
1350 	struct radeon_device *rdev = dev->dev_private;
1351 	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1352 	enum drm_connector_status ret = connector_status_disconnected;
1353 	struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
1354 	struct drm_encoder *encoder = radeon_best_single_encoder(connector);
1355 
1356 	if (!force && radeon_check_hpd_status_unchanged(connector))
1357 		return connector->status;
1358 
1359 	if (radeon_connector->edid) {
1360 		kfree(radeon_connector->edid);
1361 		radeon_connector->edid = NULL;
1362 	}
1363 
1364 	if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) ||
1365 	    (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
1366 		if (encoder) {
1367 			struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
1368 			struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
1369 
1370 			/* check if panel is valid */
1371 			if (native_mode->hdisplay >= 320 && native_mode->vdisplay >= 240)
1372 				ret = connector_status_connected;
1373 		}
1374 		/* eDP is always DP */
1375 		radeon_dig_connector->dp_sink_type = CONNECTOR_OBJECT_ID_DISPLAYPORT;
1376 		if (!radeon_dig_connector->edp_on)
1377 			atombios_set_edp_panel_power(connector,
1378 						     ATOM_TRANSMITTER_ACTION_POWER_ON);
1379 		if (radeon_dp_getdpcd(radeon_connector))
1380 			ret = connector_status_connected;
1381 		if (!radeon_dig_connector->edp_on)
1382 			atombios_set_edp_panel_power(connector,
1383 						     ATOM_TRANSMITTER_ACTION_POWER_OFF);
1384 	} else if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
1385 		   ENCODER_OBJECT_ID_NONE) {
1386 		/* DP bridges are always DP */
1387 		radeon_dig_connector->dp_sink_type = CONNECTOR_OBJECT_ID_DISPLAYPORT;
1388 		/* get the DPCD from the bridge */
1389 		radeon_dp_getdpcd(radeon_connector);
1390 
1391 		if (encoder) {
1392 			/* setup ddc on the bridge */
1393 			radeon_atom_ext_encoder_setup_ddc(encoder);
1394 			if (radeon_ddc_probe(radeon_connector)) /* try DDC */
1395 				ret = connector_status_connected;
1396 			else if (radeon_connector->dac_load_detect) { /* try load detection */
1397 				struct drm_encoder_helper_funcs *encoder_funcs = encoder->helper_private;
1398 				ret = encoder_funcs->detect(encoder, connector);
1399 			}
1400 		}
1401 	} else {
1402 		radeon_dig_connector->dp_sink_type = radeon_dp_getsinktype(radeon_connector);
1403 		if (radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) {
1404 			ret = connector_status_connected;
1405 			if (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT)
1406 				radeon_dp_getdpcd(radeon_connector);
1407 		} else {
1408 			if (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) {
1409 				if (radeon_dp_getdpcd(radeon_connector))
1410 					ret = connector_status_connected;
1411 			} else {
1412 				if (radeon_ddc_probe(radeon_connector))
1413 					ret = connector_status_connected;
1414 			}
1415 		}
1416 	}
1417 
1418 	radeon_connector_update_scratch_regs(connector, ret);
1419 	return ret;
1420 }
1421 
1422 static int radeon_dp_mode_valid(struct drm_connector *connector,
1423 				  struct drm_display_mode *mode)
1424 {
1425 	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1426 	struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
1427 
1428 	/* XXX check mode bandwidth */
1429 
1430 	if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) ||
1431 	    (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
1432 		struct drm_encoder *encoder = radeon_best_single_encoder(connector);
1433 
1434 		if ((mode->hdisplay < 320) || (mode->vdisplay < 240))
1435 			return MODE_PANEL;
1436 
1437 		if (encoder) {
1438 			struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
1439 			struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
1440 
1441 			/* AVIVO hardware supports downscaling modes larger than the panel
1442 			 * to the panel size, but I'm not sure this is desirable.
1443 			 */
1444 			if ((mode->hdisplay > native_mode->hdisplay) ||
1445 			    (mode->vdisplay > native_mode->vdisplay))
1446 				return MODE_PANEL;
1447 
1448 			/* if scaling is disabled, block non-native modes */
1449 			if (radeon_encoder->rmx_type == RMX_OFF) {
1450 				if ((mode->hdisplay != native_mode->hdisplay) ||
1451 				    (mode->vdisplay != native_mode->vdisplay))
1452 					return MODE_PANEL;
1453 			}
1454 		}
1455 		return MODE_OK;
1456 	} else {
1457 		if ((radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) ||
1458 		    (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_eDP))
1459 			return radeon_dp_mode_valid_helper(connector, mode);
1460 		else
1461 			return MODE_OK;
1462 	}
1463 }
1464 
1465 struct drm_connector_helper_funcs radeon_dp_connector_helper_funcs = {
1466 	.get_modes = radeon_dp_get_modes,
1467 	.mode_valid = radeon_dp_mode_valid,
1468 	.best_encoder = radeon_dvi_encoder,
1469 };
1470 
1471 struct drm_connector_funcs radeon_dp_connector_funcs = {
1472 	.dpms = drm_helper_connector_dpms,
1473 	.detect = radeon_dp_detect,
1474 	.fill_modes = drm_helper_probe_single_connector_modes,
1475 	.set_property = radeon_connector_set_property,
1476 	.destroy = radeon_dp_connector_destroy,
1477 	.force = radeon_dvi_force,
1478 };
1479 
1480 void
1481 radeon_add_atom_connector(struct drm_device *dev,
1482 			  uint32_t connector_id,
1483 			  uint32_t supported_device,
1484 			  int connector_type,
1485 			  struct radeon_i2c_bus_rec *i2c_bus,
1486 			  uint32_t igp_lane_info,
1487 			  uint16_t connector_object_id,
1488 			  struct radeon_hpd *hpd,
1489 			  struct radeon_router *router)
1490 {
1491 	struct radeon_device *rdev = dev->dev_private;
1492 	struct drm_connector *connector;
1493 	struct radeon_connector *radeon_connector;
1494 	struct radeon_connector_atom_dig *radeon_dig_connector;
1495 	struct drm_encoder *encoder;
1496 	struct radeon_encoder *radeon_encoder;
1497 	uint32_t subpixel_order = SubPixelNone;
1498 	bool shared_ddc = false;
1499 	bool is_dp_bridge = false;
1500 
1501 	if (connector_type == DRM_MODE_CONNECTOR_Unknown)
1502 		return;
1503 
1504 	/* if the user selected tv=0 don't try and add the connector */
1505 	if (((connector_type == DRM_MODE_CONNECTOR_SVIDEO) ||
1506 	     (connector_type == DRM_MODE_CONNECTOR_Composite) ||
1507 	     (connector_type == DRM_MODE_CONNECTOR_9PinDIN)) &&
1508 	    (radeon_tv == 0))
1509 		return;
1510 
1511 	/* see if we already added it */
1512 	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
1513 		radeon_connector = to_radeon_connector(connector);
1514 		if (radeon_connector->connector_id == connector_id) {
1515 			radeon_connector->devices |= supported_device;
1516 			return;
1517 		}
1518 		if (radeon_connector->ddc_bus && i2c_bus->valid) {
1519 			if (radeon_connector->ddc_bus->rec.i2c_id == i2c_bus->i2c_id) {
1520 				radeon_connector->shared_ddc = true;
1521 				shared_ddc = true;
1522 			}
1523 			if (radeon_connector->router_bus && router->ddc_valid &&
1524 			    (radeon_connector->router.router_id == router->router_id)) {
1525 				radeon_connector->shared_ddc = false;
1526 				shared_ddc = false;
1527 			}
1528 		}
1529 	}
1530 
1531 	/* check if it's a dp bridge */
1532 	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
1533 		radeon_encoder = to_radeon_encoder(encoder);
1534 		if (radeon_encoder->devices & supported_device) {
1535 			switch (radeon_encoder->encoder_id) {
1536 			case ENCODER_OBJECT_ID_TRAVIS:
1537 			case ENCODER_OBJECT_ID_NUTMEG:
1538 				is_dp_bridge = true;
1539 				break;
1540 			default:
1541 				break;
1542 			}
1543 		}
1544 	}
1545 
1546 	radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
1547 	if (!radeon_connector)
1548 		return;
1549 
1550 	connector = &radeon_connector->base;
1551 
1552 	radeon_connector->connector_id = connector_id;
1553 	radeon_connector->devices = supported_device;
1554 	radeon_connector->shared_ddc = shared_ddc;
1555 	radeon_connector->connector_object_id = connector_object_id;
1556 	radeon_connector->hpd = *hpd;
1557 
1558 	radeon_connector->router = *router;
1559 	if (router->ddc_valid || router->cd_valid) {
1560 		radeon_connector->router_bus = radeon_i2c_lookup(rdev, &router->i2c_info);
1561 		if (!radeon_connector->router_bus)
1562 			DRM_ERROR("Failed to assign router i2c bus! Check dmesg for i2c errors.\n");
1563 	}
1564 
1565 	if (is_dp_bridge) {
1566 		radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1567 		if (!radeon_dig_connector)
1568 			goto failed;
1569 		radeon_dig_connector->igp_lane_info = igp_lane_info;
1570 		radeon_connector->con_priv = radeon_dig_connector;
1571 		drm_connector_init(dev, &radeon_connector->base, &radeon_dp_connector_funcs, connector_type);
1572 		drm_connector_helper_add(&radeon_connector->base, &radeon_dp_connector_helper_funcs);
1573 		if (i2c_bus->valid) {
1574 			/* add DP i2c bus */
1575 			if (connector_type == DRM_MODE_CONNECTOR_eDP)
1576 				radeon_dig_connector->dp_i2c_bus = radeon_i2c_create_dp(dev, i2c_bus, "eDP-auxch");
1577 			else
1578 				radeon_dig_connector->dp_i2c_bus = radeon_i2c_create_dp(dev, i2c_bus, "DP-auxch");
1579 			if (!radeon_dig_connector->dp_i2c_bus)
1580 				DRM_ERROR("DP: Failed to assign dp ddc bus! Check dmesg for i2c errors.\n");
1581 			radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1582 			if (!radeon_connector->ddc_bus)
1583 				DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1584 		}
1585 		switch (connector_type) {
1586 		case DRM_MODE_CONNECTOR_VGA:
1587 		case DRM_MODE_CONNECTOR_DVIA:
1588 		default:
1589 			connector->interlace_allowed = true;
1590 			connector->doublescan_allowed = true;
1591 			radeon_connector->dac_load_detect = true;
1592 			drm_connector_attach_property(&radeon_connector->base,
1593 						      rdev->mode_info.load_detect_property,
1594 						      1);
1595 			break;
1596 		case DRM_MODE_CONNECTOR_DVII:
1597 		case DRM_MODE_CONNECTOR_DVID:
1598 		case DRM_MODE_CONNECTOR_HDMIA:
1599 		case DRM_MODE_CONNECTOR_HDMIB:
1600 		case DRM_MODE_CONNECTOR_DisplayPort:
1601 			drm_connector_attach_property(&radeon_connector->base,
1602 						      rdev->mode_info.underscan_property,
1603 						      UNDERSCAN_OFF);
1604 			drm_connector_attach_property(&radeon_connector->base,
1605 						      rdev->mode_info.underscan_hborder_property,
1606 						      0);
1607 			drm_connector_attach_property(&radeon_connector->base,
1608 						      rdev->mode_info.underscan_vborder_property,
1609 						      0);
1610 			subpixel_order = SubPixelHorizontalRGB;
1611 			connector->interlace_allowed = true;
1612 			if (connector_type == DRM_MODE_CONNECTOR_HDMIB)
1613 				connector->doublescan_allowed = true;
1614 			else
1615 				connector->doublescan_allowed = false;
1616 			if (connector_type == DRM_MODE_CONNECTOR_DVII) {
1617 				radeon_connector->dac_load_detect = true;
1618 				drm_connector_attach_property(&radeon_connector->base,
1619 							      rdev->mode_info.load_detect_property,
1620 							      1);
1621 			}
1622 			break;
1623 		case DRM_MODE_CONNECTOR_LVDS:
1624 		case DRM_MODE_CONNECTOR_eDP:
1625 			drm_connector_attach_property(&radeon_connector->base,
1626 						      dev->mode_config.scaling_mode_property,
1627 						      DRM_MODE_SCALE_FULLSCREEN);
1628 			subpixel_order = SubPixelHorizontalRGB;
1629 			connector->interlace_allowed = false;
1630 			connector->doublescan_allowed = false;
1631 			break;
1632 		}
1633 	} else {
1634 		switch (connector_type) {
1635 		case DRM_MODE_CONNECTOR_VGA:
1636 			drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1637 			drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1638 			if (i2c_bus->valid) {
1639 				radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1640 				if (!radeon_connector->ddc_bus)
1641 					DRM_ERROR("VGA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1642 			}
1643 			radeon_connector->dac_load_detect = true;
1644 			drm_connector_attach_property(&radeon_connector->base,
1645 						      rdev->mode_info.load_detect_property,
1646 						      1);
1647 			/* no HPD on analog connectors */
1648 			radeon_connector->hpd.hpd = RADEON_HPD_NONE;
1649 			connector->polled = DRM_CONNECTOR_POLL_CONNECT;
1650 			connector->interlace_allowed = true;
1651 			connector->doublescan_allowed = true;
1652 			break;
1653 		case DRM_MODE_CONNECTOR_DVIA:
1654 			drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1655 			drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1656 			if (i2c_bus->valid) {
1657 				radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1658 				if (!radeon_connector->ddc_bus)
1659 					DRM_ERROR("DVIA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1660 			}
1661 			radeon_connector->dac_load_detect = true;
1662 			drm_connector_attach_property(&radeon_connector->base,
1663 						      rdev->mode_info.load_detect_property,
1664 						      1);
1665 			/* no HPD on analog connectors */
1666 			radeon_connector->hpd.hpd = RADEON_HPD_NONE;
1667 			connector->interlace_allowed = true;
1668 			connector->doublescan_allowed = true;
1669 			break;
1670 		case DRM_MODE_CONNECTOR_DVII:
1671 		case DRM_MODE_CONNECTOR_DVID:
1672 			radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1673 			if (!radeon_dig_connector)
1674 				goto failed;
1675 			radeon_dig_connector->igp_lane_info = igp_lane_info;
1676 			radeon_connector->con_priv = radeon_dig_connector;
1677 			drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
1678 			drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
1679 			if (i2c_bus->valid) {
1680 				radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1681 				if (!radeon_connector->ddc_bus)
1682 					DRM_ERROR("DVI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1683 			}
1684 			subpixel_order = SubPixelHorizontalRGB;
1685 			drm_connector_attach_property(&radeon_connector->base,
1686 						      rdev->mode_info.coherent_mode_property,
1687 						      1);
1688 			if (ASIC_IS_AVIVO(rdev)) {
1689 				drm_connector_attach_property(&radeon_connector->base,
1690 							      rdev->mode_info.underscan_property,
1691 							      UNDERSCAN_OFF);
1692 				drm_connector_attach_property(&radeon_connector->base,
1693 							      rdev->mode_info.underscan_hborder_property,
1694 							      0);
1695 				drm_connector_attach_property(&radeon_connector->base,
1696 							      rdev->mode_info.underscan_vborder_property,
1697 							      0);
1698 			}
1699 			if (connector_type == DRM_MODE_CONNECTOR_DVII) {
1700 				radeon_connector->dac_load_detect = true;
1701 				drm_connector_attach_property(&radeon_connector->base,
1702 							      rdev->mode_info.load_detect_property,
1703 							      1);
1704 			}
1705 			connector->interlace_allowed = true;
1706 			if (connector_type == DRM_MODE_CONNECTOR_DVII)
1707 				connector->doublescan_allowed = true;
1708 			else
1709 				connector->doublescan_allowed = false;
1710 			break;
1711 		case DRM_MODE_CONNECTOR_HDMIA:
1712 		case DRM_MODE_CONNECTOR_HDMIB:
1713 			radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1714 			if (!radeon_dig_connector)
1715 				goto failed;
1716 			radeon_dig_connector->igp_lane_info = igp_lane_info;
1717 			radeon_connector->con_priv = radeon_dig_connector;
1718 			drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
1719 			drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
1720 			if (i2c_bus->valid) {
1721 				radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1722 				if (!radeon_connector->ddc_bus)
1723 					DRM_ERROR("HDMI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1724 			}
1725 			drm_connector_attach_property(&radeon_connector->base,
1726 						      rdev->mode_info.coherent_mode_property,
1727 						      1);
1728 			if (ASIC_IS_AVIVO(rdev)) {
1729 				drm_connector_attach_property(&radeon_connector->base,
1730 							      rdev->mode_info.underscan_property,
1731 							      UNDERSCAN_OFF);
1732 				drm_connector_attach_property(&radeon_connector->base,
1733 							      rdev->mode_info.underscan_hborder_property,
1734 							      0);
1735 				drm_connector_attach_property(&radeon_connector->base,
1736 							      rdev->mode_info.underscan_vborder_property,
1737 							      0);
1738 			}
1739 			subpixel_order = SubPixelHorizontalRGB;
1740 			connector->interlace_allowed = true;
1741 			if (connector_type == DRM_MODE_CONNECTOR_HDMIB)
1742 				connector->doublescan_allowed = true;
1743 			else
1744 				connector->doublescan_allowed = false;
1745 			break;
1746 		case DRM_MODE_CONNECTOR_DisplayPort:
1747 			radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1748 			if (!radeon_dig_connector)
1749 				goto failed;
1750 			radeon_dig_connector->igp_lane_info = igp_lane_info;
1751 			radeon_connector->con_priv = radeon_dig_connector;
1752 			drm_connector_init(dev, &radeon_connector->base, &radeon_dp_connector_funcs, connector_type);
1753 			drm_connector_helper_add(&radeon_connector->base, &radeon_dp_connector_helper_funcs);
1754 			if (i2c_bus->valid) {
1755 				/* add DP i2c bus */
1756 				radeon_dig_connector->dp_i2c_bus = radeon_i2c_create_dp(dev, i2c_bus, "DP-auxch");
1757 				if (!radeon_dig_connector->dp_i2c_bus)
1758 					DRM_ERROR("DP: Failed to assign dp ddc bus! Check dmesg for i2c errors.\n");
1759 				radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1760 				if (!radeon_connector->ddc_bus)
1761 					DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1762 			}
1763 			subpixel_order = SubPixelHorizontalRGB;
1764 			drm_connector_attach_property(&radeon_connector->base,
1765 						      rdev->mode_info.coherent_mode_property,
1766 						      1);
1767 			if (ASIC_IS_AVIVO(rdev)) {
1768 				drm_connector_attach_property(&radeon_connector->base,
1769 							      rdev->mode_info.underscan_property,
1770 							      UNDERSCAN_OFF);
1771 				drm_connector_attach_property(&radeon_connector->base,
1772 							      rdev->mode_info.underscan_hborder_property,
1773 							      0);
1774 				drm_connector_attach_property(&radeon_connector->base,
1775 							      rdev->mode_info.underscan_vborder_property,
1776 							      0);
1777 			}
1778 			connector->interlace_allowed = true;
1779 			/* in theory with a DP to VGA converter... */
1780 			connector->doublescan_allowed = false;
1781 			break;
1782 		case DRM_MODE_CONNECTOR_eDP:
1783 			radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1784 			if (!radeon_dig_connector)
1785 				goto failed;
1786 			radeon_dig_connector->igp_lane_info = igp_lane_info;
1787 			radeon_connector->con_priv = radeon_dig_connector;
1788 			drm_connector_init(dev, &radeon_connector->base, &radeon_dp_connector_funcs, connector_type);
1789 			drm_connector_helper_add(&radeon_connector->base, &radeon_dp_connector_helper_funcs);
1790 			if (i2c_bus->valid) {
1791 				/* add DP i2c bus */
1792 				radeon_dig_connector->dp_i2c_bus = radeon_i2c_create_dp(dev, i2c_bus, "eDP-auxch");
1793 				if (!radeon_dig_connector->dp_i2c_bus)
1794 					DRM_ERROR("DP: Failed to assign dp ddc bus! Check dmesg for i2c errors.\n");
1795 				radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1796 				if (!radeon_connector->ddc_bus)
1797 					DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1798 			}
1799 			drm_connector_attach_property(&radeon_connector->base,
1800 						      dev->mode_config.scaling_mode_property,
1801 						      DRM_MODE_SCALE_FULLSCREEN);
1802 			subpixel_order = SubPixelHorizontalRGB;
1803 			connector->interlace_allowed = false;
1804 			connector->doublescan_allowed = false;
1805 			break;
1806 		case DRM_MODE_CONNECTOR_SVIDEO:
1807 		case DRM_MODE_CONNECTOR_Composite:
1808 		case DRM_MODE_CONNECTOR_9PinDIN:
1809 			drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
1810 			drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
1811 			radeon_connector->dac_load_detect = true;
1812 			drm_connector_attach_property(&radeon_connector->base,
1813 						      rdev->mode_info.load_detect_property,
1814 						      1);
1815 			drm_connector_attach_property(&radeon_connector->base,
1816 						      rdev->mode_info.tv_std_property,
1817 						      radeon_atombios_get_tv_info(rdev));
1818 			/* no HPD on analog connectors */
1819 			radeon_connector->hpd.hpd = RADEON_HPD_NONE;
1820 			connector->interlace_allowed = false;
1821 			connector->doublescan_allowed = false;
1822 			break;
1823 		case DRM_MODE_CONNECTOR_LVDS:
1824 			radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1825 			if (!radeon_dig_connector)
1826 				goto failed;
1827 			radeon_dig_connector->igp_lane_info = igp_lane_info;
1828 			radeon_connector->con_priv = radeon_dig_connector;
1829 			drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
1830 			drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
1831 			if (i2c_bus->valid) {
1832 				radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1833 				if (!radeon_connector->ddc_bus)
1834 					DRM_ERROR("LVDS: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1835 			}
1836 			drm_connector_attach_property(&radeon_connector->base,
1837 						      dev->mode_config.scaling_mode_property,
1838 						      DRM_MODE_SCALE_FULLSCREEN);
1839 			subpixel_order = SubPixelHorizontalRGB;
1840 			connector->interlace_allowed = false;
1841 			connector->doublescan_allowed = false;
1842 			break;
1843 		}
1844 	}
1845 
1846 	if (radeon_connector->hpd.hpd == RADEON_HPD_NONE) {
1847 		if (i2c_bus->valid)
1848 			connector->polled = DRM_CONNECTOR_POLL_CONNECT;
1849 	} else
1850 		connector->polled = DRM_CONNECTOR_POLL_HPD;
1851 
1852 	connector->display_info.subpixel_order = subpixel_order;
1853 	drm_sysfs_connector_add(connector);
1854 	return;
1855 
1856 failed:
1857 	drm_connector_cleanup(connector);
1858 	kfree(connector);
1859 }
1860 
1861 void
1862 radeon_add_legacy_connector(struct drm_device *dev,
1863 			    uint32_t connector_id,
1864 			    uint32_t supported_device,
1865 			    int connector_type,
1866 			    struct radeon_i2c_bus_rec *i2c_bus,
1867 			    uint16_t connector_object_id,
1868 			    struct radeon_hpd *hpd)
1869 {
1870 	struct radeon_device *rdev = dev->dev_private;
1871 	struct drm_connector *connector;
1872 	struct radeon_connector *radeon_connector;
1873 	uint32_t subpixel_order = SubPixelNone;
1874 
1875 	if (connector_type == DRM_MODE_CONNECTOR_Unknown)
1876 		return;
1877 
1878 	/* if the user selected tv=0 don't try and add the connector */
1879 	if (((connector_type == DRM_MODE_CONNECTOR_SVIDEO) ||
1880 	     (connector_type == DRM_MODE_CONNECTOR_Composite) ||
1881 	     (connector_type == DRM_MODE_CONNECTOR_9PinDIN)) &&
1882 	    (radeon_tv == 0))
1883 		return;
1884 
1885 	/* see if we already added it */
1886 	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
1887 		radeon_connector = to_radeon_connector(connector);
1888 		if (radeon_connector->connector_id == connector_id) {
1889 			radeon_connector->devices |= supported_device;
1890 			return;
1891 		}
1892 	}
1893 
1894 	radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
1895 	if (!radeon_connector)
1896 		return;
1897 
1898 	connector = &radeon_connector->base;
1899 
1900 	radeon_connector->connector_id = connector_id;
1901 	radeon_connector->devices = supported_device;
1902 	radeon_connector->connector_object_id = connector_object_id;
1903 	radeon_connector->hpd = *hpd;
1904 
1905 	switch (connector_type) {
1906 	case DRM_MODE_CONNECTOR_VGA:
1907 		drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1908 		drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1909 		if (i2c_bus->valid) {
1910 			radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1911 			if (!radeon_connector->ddc_bus)
1912 				DRM_ERROR("VGA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1913 		}
1914 		radeon_connector->dac_load_detect = true;
1915 		drm_connector_attach_property(&radeon_connector->base,
1916 					      rdev->mode_info.load_detect_property,
1917 					      1);
1918 		/* no HPD on analog connectors */
1919 		radeon_connector->hpd.hpd = RADEON_HPD_NONE;
1920 		connector->polled = DRM_CONNECTOR_POLL_CONNECT;
1921 		connector->interlace_allowed = true;
1922 		connector->doublescan_allowed = true;
1923 		break;
1924 	case DRM_MODE_CONNECTOR_DVIA:
1925 		drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1926 		drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1927 		if (i2c_bus->valid) {
1928 			radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1929 			if (!radeon_connector->ddc_bus)
1930 				DRM_ERROR("DVIA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1931 		}
1932 		radeon_connector->dac_load_detect = true;
1933 		drm_connector_attach_property(&radeon_connector->base,
1934 					      rdev->mode_info.load_detect_property,
1935 					      1);
1936 		/* no HPD on analog connectors */
1937 		radeon_connector->hpd.hpd = RADEON_HPD_NONE;
1938 		connector->interlace_allowed = true;
1939 		connector->doublescan_allowed = true;
1940 		break;
1941 	case DRM_MODE_CONNECTOR_DVII:
1942 	case DRM_MODE_CONNECTOR_DVID:
1943 		drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
1944 		drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
1945 		if (i2c_bus->valid) {
1946 			radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1947 			if (!radeon_connector->ddc_bus)
1948 				DRM_ERROR("DVI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1949 		}
1950 		if (connector_type == DRM_MODE_CONNECTOR_DVII) {
1951 			radeon_connector->dac_load_detect = true;
1952 			drm_connector_attach_property(&radeon_connector->base,
1953 						      rdev->mode_info.load_detect_property,
1954 						      1);
1955 		}
1956 		subpixel_order = SubPixelHorizontalRGB;
1957 		connector->interlace_allowed = true;
1958 		if (connector_type == DRM_MODE_CONNECTOR_DVII)
1959 			connector->doublescan_allowed = true;
1960 		else
1961 			connector->doublescan_allowed = false;
1962 		break;
1963 	case DRM_MODE_CONNECTOR_SVIDEO:
1964 	case DRM_MODE_CONNECTOR_Composite:
1965 	case DRM_MODE_CONNECTOR_9PinDIN:
1966 		drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
1967 		drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
1968 		radeon_connector->dac_load_detect = true;
1969 		/* RS400,RC410,RS480 chipset seems to report a lot
1970 		 * of false positive on load detect, we haven't yet
1971 		 * found a way to make load detect reliable on those
1972 		 * chipset, thus just disable it for TV.
1973 		 */
1974 		if (rdev->family == CHIP_RS400 || rdev->family == CHIP_RS480)
1975 			radeon_connector->dac_load_detect = false;
1976 		drm_connector_attach_property(&radeon_connector->base,
1977 					      rdev->mode_info.load_detect_property,
1978 					      radeon_connector->dac_load_detect);
1979 		drm_connector_attach_property(&radeon_connector->base,
1980 					      rdev->mode_info.tv_std_property,
1981 					      radeon_combios_get_tv_info(rdev));
1982 		/* no HPD on analog connectors */
1983 		radeon_connector->hpd.hpd = RADEON_HPD_NONE;
1984 		connector->interlace_allowed = false;
1985 		connector->doublescan_allowed = false;
1986 		break;
1987 	case DRM_MODE_CONNECTOR_LVDS:
1988 		drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
1989 		drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
1990 		if (i2c_bus->valid) {
1991 			radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1992 			if (!radeon_connector->ddc_bus)
1993 				DRM_ERROR("LVDS: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1994 		}
1995 		drm_connector_attach_property(&radeon_connector->base,
1996 					      dev->mode_config.scaling_mode_property,
1997 					      DRM_MODE_SCALE_FULLSCREEN);
1998 		subpixel_order = SubPixelHorizontalRGB;
1999 		connector->interlace_allowed = false;
2000 		connector->doublescan_allowed = false;
2001 		break;
2002 	}
2003 
2004 	if (radeon_connector->hpd.hpd == RADEON_HPD_NONE) {
2005 		if (i2c_bus->valid)
2006 			connector->polled = DRM_CONNECTOR_POLL_CONNECT;
2007 	} else
2008 		connector->polled = DRM_CONNECTOR_POLL_HPD;
2009 	connector->display_info.subpixel_order = subpixel_order;
2010 	drm_sysfs_connector_add(connector);
2011 	if (connector_type == DRM_MODE_CONNECTOR_LVDS) {
2012 		struct drm_encoder *drm_encoder;
2013 
2014 		list_for_each_entry(drm_encoder, &dev->mode_config.encoder_list, head) {
2015 			struct radeon_encoder *radeon_encoder;
2016 
2017 			radeon_encoder = to_radeon_encoder(drm_encoder);
2018 			if (radeon_encoder->encoder_id == ENCODER_OBJECT_ID_INTERNAL_LVDS)
2019 				radeon_legacy_backlight_init(radeon_encoder, connector);
2020 		}
2021 	}
2022 }
2023