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/drm_dp_mst_helper.h>
31 #include <drm/radeon_drm.h>
32 #include "radeon.h"
33 #include "radeon_audio.h"
34 #include "atom.h"
35 
36 #include <linux/pm_runtime.h>
37 #include <linux/vga_switcheroo.h>
38 
39 static int radeon_dp_handle_hpd(struct drm_connector *connector)
40 {
41 	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
42 	int ret;
43 
44 	ret = radeon_dp_mst_check_status(radeon_connector);
45 	if (ret == -EINVAL)
46 		return 1;
47 	return 0;
48 }
49 void radeon_connector_hotplug(struct drm_connector *connector)
50 {
51 	struct drm_device *dev = connector->dev;
52 	struct radeon_device *rdev = dev->dev_private;
53 	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
54 
55 	if (connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort) {
56 		struct radeon_connector_atom_dig *dig_connector =
57 			radeon_connector->con_priv;
58 
59 		if (radeon_connector->is_mst_connector)
60 			return;
61 		if (dig_connector->is_mst) {
62 			radeon_dp_handle_hpd(connector);
63 			return;
64 		}
65 	}
66 	/* bail if the connector does not have hpd pin, e.g.,
67 	 * VGA, TV, etc.
68 	 */
69 	if (radeon_connector->hpd.hpd == RADEON_HPD_NONE)
70 		return;
71 
72 	radeon_hpd_set_polarity(rdev, radeon_connector->hpd.hpd);
73 
74 	/* if the connector is already off, don't turn it back on */
75 	/* FIXME: This access isn't protected by any locks. */
76 	if (connector->dpms != DRM_MODE_DPMS_ON)
77 		return;
78 
79 	/* just deal with DP (not eDP) here. */
80 	if (connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort) {
81 		struct radeon_connector_atom_dig *dig_connector =
82 			radeon_connector->con_priv;
83 
84 		/* if existing sink type was not DP no need to retrain */
85 		if (dig_connector->dp_sink_type != CONNECTOR_OBJECT_ID_DISPLAYPORT)
86 			return;
87 
88 		/* first get sink type as it may be reset after (un)plug */
89 		dig_connector->dp_sink_type = radeon_dp_getsinktype(radeon_connector);
90 		/* don't do anything if sink is not display port, i.e.,
91 		 * passive dp->(dvi|hdmi) adaptor
92 		 */
93 		if (dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) {
94 			int saved_dpms = connector->dpms;
95 			/* Only turn off the display if it's physically disconnected */
96 			if (!radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) {
97 				drm_helper_connector_dpms(connector, DRM_MODE_DPMS_OFF);
98 			} else if (radeon_dp_needs_link_train(radeon_connector)) {
99 				/* Don't try to start link training before we
100 				 * have the dpcd */
101 				if (!radeon_dp_getdpcd(radeon_connector))
102 					return;
103 
104 				/* set it to OFF so that drm_helper_connector_dpms()
105 				 * won't return immediately since the current state
106 				 * is ON at this point.
107 				 */
108 				connector->dpms = DRM_MODE_DPMS_OFF;
109 				drm_helper_connector_dpms(connector, DRM_MODE_DPMS_ON);
110 			}
111 			connector->dpms = saved_dpms;
112 		}
113 	}
114 }
115 
116 static void radeon_property_change_mode(struct drm_encoder *encoder)
117 {
118 	struct drm_crtc *crtc = encoder->crtc;
119 
120 	if (crtc && crtc->enabled) {
121 		drm_crtc_helper_set_mode(crtc, &crtc->mode,
122 					 crtc->x, crtc->y, crtc->primary->fb);
123 	}
124 }
125 
126 int radeon_get_monitor_bpc(struct drm_connector *connector)
127 {
128 	struct drm_device *dev = connector->dev;
129 	struct radeon_device *rdev = dev->dev_private;
130 	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
131 	struct radeon_connector_atom_dig *dig_connector;
132 	int bpc = 8;
133 	int mode_clock, max_tmds_clock;
134 
135 	switch (connector->connector_type) {
136 	case DRM_MODE_CONNECTOR_DVII:
137 	case DRM_MODE_CONNECTOR_HDMIB:
138 		if (radeon_connector->use_digital) {
139 			if (drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
140 				if (connector->display_info.bpc)
141 					bpc = connector->display_info.bpc;
142 			}
143 		}
144 		break;
145 	case DRM_MODE_CONNECTOR_DVID:
146 	case DRM_MODE_CONNECTOR_HDMIA:
147 		if (drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
148 			if (connector->display_info.bpc)
149 				bpc = connector->display_info.bpc;
150 		}
151 		break;
152 	case DRM_MODE_CONNECTOR_DisplayPort:
153 		dig_connector = radeon_connector->con_priv;
154 		if ((dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) ||
155 		    (dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_eDP) ||
156 		    drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
157 			if (connector->display_info.bpc)
158 				bpc = connector->display_info.bpc;
159 		}
160 		break;
161 	case DRM_MODE_CONNECTOR_eDP:
162 	case DRM_MODE_CONNECTOR_LVDS:
163 		if (connector->display_info.bpc)
164 			bpc = connector->display_info.bpc;
165 		else if (ASIC_IS_DCE41(rdev) || ASIC_IS_DCE5(rdev)) {
166 			const struct drm_connector_helper_funcs *connector_funcs =
167 				connector->helper_private;
168 			struct drm_encoder *encoder = connector_funcs->best_encoder(connector);
169 			struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
170 			struct radeon_encoder_atom_dig *dig = radeon_encoder->enc_priv;
171 
172 			if (dig->lcd_misc & ATOM_PANEL_MISC_V13_6BIT_PER_COLOR)
173 				bpc = 6;
174 			else if (dig->lcd_misc & ATOM_PANEL_MISC_V13_8BIT_PER_COLOR)
175 				bpc = 8;
176 		}
177 		break;
178 	}
179 
180 	if (drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
181 		/* hdmi deep color only implemented on DCE4+ */
182 		if ((bpc > 8) && !ASIC_IS_DCE4(rdev)) {
183 			DRM_DEBUG("%s: HDMI deep color %d bpc unsupported. Using 8 bpc.\n",
184 					  connector->name, bpc);
185 			bpc = 8;
186 		}
187 
188 		/*
189 		 * Pre DCE-8 hw can't handle > 12 bpc, and more than 12 bpc doesn't make
190 		 * much sense without support for > 12 bpc framebuffers. RGB 4:4:4 at
191 		 * 12 bpc is always supported on hdmi deep color sinks, as this is
192 		 * required by the HDMI-1.3 spec. Clamp to a safe 12 bpc maximum.
193 		 */
194 		if (bpc > 12) {
195 			DRM_DEBUG("%s: HDMI deep color %d bpc unsupported. Using 12 bpc.\n",
196 					  connector->name, bpc);
197 			bpc = 12;
198 		}
199 
200 		/* Any defined maximum tmds clock limit we must not exceed? */
201 		if (connector->display_info.max_tmds_clock > 0) {
202 			/* mode_clock is clock in kHz for mode to be modeset on this connector */
203 			mode_clock = radeon_connector->pixelclock_for_modeset;
204 
205 			/* Maximum allowable input clock in kHz */
206 			max_tmds_clock = connector->display_info.max_tmds_clock;
207 
208 			DRM_DEBUG("%s: hdmi mode dotclock %d kHz, max tmds input clock %d kHz.\n",
209 					  connector->name, mode_clock, max_tmds_clock);
210 
211 			/* Check if bpc is within clock limit. Try to degrade gracefully otherwise */
212 			if ((bpc == 12) && (mode_clock * 3/2 > max_tmds_clock)) {
213 				if ((connector->display_info.edid_hdmi_dc_modes & DRM_EDID_HDMI_DC_30) &&
214 					(mode_clock * 5/4 <= max_tmds_clock))
215 					bpc = 10;
216 				else
217 					bpc = 8;
218 
219 				DRM_DEBUG("%s: HDMI deep color 12 bpc exceeds max tmds clock. Using %d bpc.\n",
220 						  connector->name, bpc);
221 			}
222 
223 			if ((bpc == 10) && (mode_clock * 5/4 > max_tmds_clock)) {
224 				bpc = 8;
225 				DRM_DEBUG("%s: HDMI deep color 10 bpc exceeds max tmds clock. Using %d bpc.\n",
226 						  connector->name, bpc);
227 			}
228 		}
229 		else if (bpc > 8) {
230 			/* max_tmds_clock missing, but hdmi spec mandates it for deep color. */
231 			DRM_DEBUG("%s: Required max tmds clock for HDMI deep color missing. Using 8 bpc.\n",
232 					  connector->name);
233 			bpc = 8;
234 		}
235 	}
236 
237 	if ((radeon_deep_color == 0) && (bpc > 8)) {
238 		DRM_DEBUG("%s: Deep color disabled. Set radeon module param deep_color=1 to enable.\n",
239 				  connector->name);
240 		bpc = 8;
241 	}
242 
243 	DRM_DEBUG("%s: Display bpc=%d, returned bpc=%d\n",
244 			  connector->name, connector->display_info.bpc, bpc);
245 
246 	return bpc;
247 }
248 
249 static void
250 radeon_connector_update_scratch_regs(struct drm_connector *connector, enum drm_connector_status status)
251 {
252 	struct drm_device *dev = connector->dev;
253 	struct radeon_device *rdev = dev->dev_private;
254 	struct drm_encoder *best_encoder = NULL;
255 	struct drm_encoder *encoder = NULL;
256 	const struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
257 	bool connected;
258 	int i;
259 
260 	best_encoder = connector_funcs->best_encoder(connector);
261 
262 	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
263 		if (connector->encoder_ids[i] == 0)
264 			break;
265 
266 		encoder = drm_encoder_find(connector->dev,
267 					   connector->encoder_ids[i]);
268 		if (!encoder)
269 			continue;
270 
271 		if ((encoder == best_encoder) && (status == connector_status_connected))
272 			connected = true;
273 		else
274 			connected = false;
275 
276 		if (rdev->is_atom_bios)
277 			radeon_atombios_connected_scratch_regs(connector, encoder, connected);
278 		else
279 			radeon_combios_connected_scratch_regs(connector, encoder, connected);
280 
281 	}
282 }
283 
284 static struct drm_encoder *radeon_find_encoder(struct drm_connector *connector, int encoder_type)
285 {
286 	struct drm_encoder *encoder;
287 	int i;
288 
289 	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
290 		if (connector->encoder_ids[i] == 0)
291 			break;
292 
293 		encoder = drm_encoder_find(connector->dev, connector->encoder_ids[i]);
294 		if (!encoder)
295 			continue;
296 
297 		if (encoder->encoder_type == encoder_type)
298 			return encoder;
299 	}
300 	return NULL;
301 }
302 
303 struct edid *radeon_connector_edid(struct drm_connector *connector)
304 {
305 	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
306 	struct drm_property_blob *edid_blob = connector->edid_blob_ptr;
307 
308 	if (radeon_connector->edid) {
309 		return radeon_connector->edid;
310 	} else if (edid_blob) {
311 		struct edid *edid = kmemdup(edid_blob->data, edid_blob->length, GFP_KERNEL);
312 		if (edid)
313 			radeon_connector->edid = edid;
314 	}
315 	return radeon_connector->edid;
316 }
317 
318 static void radeon_connector_get_edid(struct drm_connector *connector)
319 {
320 	struct drm_device *dev = connector->dev;
321 	struct radeon_device *rdev = dev->dev_private;
322 	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
323 
324 	if (radeon_connector->edid)
325 		return;
326 
327 	/* on hw with routers, select right port */
328 	if (radeon_connector->router.ddc_valid)
329 		radeon_router_select_ddc_port(radeon_connector);
330 
331 	if ((radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
332 	     ENCODER_OBJECT_ID_NONE) &&
333 	    radeon_connector->ddc_bus->has_aux) {
334 		radeon_connector->edid = drm_get_edid(connector,
335 						      &radeon_connector->ddc_bus->aux.ddc);
336 	} else if ((connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort) ||
337 		   (connector->connector_type == DRM_MODE_CONNECTOR_eDP)) {
338 		struct radeon_connector_atom_dig *dig = radeon_connector->con_priv;
339 
340 		if ((dig->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT ||
341 		     dig->dp_sink_type == CONNECTOR_OBJECT_ID_eDP) &&
342 		    radeon_connector->ddc_bus->has_aux)
343 			radeon_connector->edid = drm_get_edid(&radeon_connector->base,
344 							      &radeon_connector->ddc_bus->aux.ddc);
345 		else if (radeon_connector->ddc_bus)
346 			radeon_connector->edid = drm_get_edid(&radeon_connector->base,
347 							      &radeon_connector->ddc_bus->adapter);
348 	} else if (vga_switcheroo_handler_flags() & VGA_SWITCHEROO_CAN_SWITCH_DDC &&
349 		   connector->connector_type == DRM_MODE_CONNECTOR_LVDS &&
350 		   radeon_connector->ddc_bus) {
351 		radeon_connector->edid = drm_get_edid_switcheroo(&radeon_connector->base,
352 								 &radeon_connector->ddc_bus->adapter);
353 	} else if (radeon_connector->ddc_bus) {
354 		radeon_connector->edid = drm_get_edid(&radeon_connector->base,
355 						      &radeon_connector->ddc_bus->adapter);
356 	}
357 
358 	if (!radeon_connector->edid) {
359 		/* don't fetch the edid from the vbios if ddc fails and runpm is
360 		 * enabled so we report disconnected.
361 		 */
362 		if ((rdev->flags & RADEON_IS_PX) && (radeon_runtime_pm != 0))
363 			return;
364 
365 		if (rdev->is_atom_bios) {
366 			/* some laptops provide a hardcoded edid in rom for LCDs */
367 			if (((connector->connector_type == DRM_MODE_CONNECTOR_LVDS) ||
368 			     (connector->connector_type == DRM_MODE_CONNECTOR_eDP)))
369 				radeon_connector->edid = radeon_bios_get_hardcoded_edid(rdev);
370 		} else {
371 			/* some servers provide a hardcoded edid in rom for KVMs */
372 			radeon_connector->edid = radeon_bios_get_hardcoded_edid(rdev);
373 		}
374 	}
375 }
376 
377 static void radeon_connector_free_edid(struct drm_connector *connector)
378 {
379 	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
380 
381 	if (radeon_connector->edid) {
382 		kfree(radeon_connector->edid);
383 		radeon_connector->edid = NULL;
384 	}
385 }
386 
387 static int radeon_ddc_get_modes(struct drm_connector *connector)
388 {
389 	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
390 	int ret;
391 
392 	if (radeon_connector->edid) {
393 		drm_mode_connector_update_edid_property(connector, radeon_connector->edid);
394 		ret = drm_add_edid_modes(connector, radeon_connector->edid);
395 		drm_edid_to_eld(connector, radeon_connector->edid);
396 		return ret;
397 	}
398 	drm_mode_connector_update_edid_property(connector, NULL);
399 	return 0;
400 }
401 
402 static struct drm_encoder *radeon_best_single_encoder(struct drm_connector *connector)
403 {
404 	int enc_id = connector->encoder_ids[0];
405 	/* pick the encoder ids */
406 	if (enc_id)
407 		return drm_encoder_find(connector->dev, enc_id);
408 	return NULL;
409 }
410 
411 static void radeon_get_native_mode(struct drm_connector *connector)
412 {
413 	struct drm_encoder *encoder = radeon_best_single_encoder(connector);
414 	struct radeon_encoder *radeon_encoder;
415 
416 	if (encoder == NULL)
417 		return;
418 
419 	radeon_encoder = to_radeon_encoder(encoder);
420 
421 	if (!list_empty(&connector->probed_modes)) {
422 		struct drm_display_mode *preferred_mode =
423 			list_first_entry(&connector->probed_modes,
424 					 struct drm_display_mode, head);
425 
426 		radeon_encoder->native_mode = *preferred_mode;
427 	} else {
428 		radeon_encoder->native_mode.clock = 0;
429 	}
430 }
431 
432 /*
433  * radeon_connector_analog_encoder_conflict_solve
434  * - search for other connectors sharing this encoder
435  *   if priority is true, then set them disconnected if this is connected
436  *   if priority is false, set us disconnected if they are connected
437  */
438 static enum drm_connector_status
439 radeon_connector_analog_encoder_conflict_solve(struct drm_connector *connector,
440 					       struct drm_encoder *encoder,
441 					       enum drm_connector_status current_status,
442 					       bool priority)
443 {
444 	struct drm_device *dev = connector->dev;
445 	struct drm_connector *conflict;
446 	struct radeon_connector *radeon_conflict;
447 	int i;
448 
449 	list_for_each_entry(conflict, &dev->mode_config.connector_list, head) {
450 		if (conflict == connector)
451 			continue;
452 
453 		radeon_conflict = to_radeon_connector(conflict);
454 		for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
455 			if (conflict->encoder_ids[i] == 0)
456 				break;
457 
458 			/* if the IDs match */
459 			if (conflict->encoder_ids[i] == encoder->base.id) {
460 				if (conflict->status != connector_status_connected)
461 					continue;
462 
463 				if (radeon_conflict->use_digital)
464 					continue;
465 
466 				if (priority == true) {
467 					DRM_DEBUG_KMS("1: conflicting encoders switching off %s\n",
468 						      conflict->name);
469 					DRM_DEBUG_KMS("in favor of %s\n",
470 						      connector->name);
471 					conflict->status = connector_status_disconnected;
472 					radeon_connector_update_scratch_regs(conflict, connector_status_disconnected);
473 				} else {
474 					DRM_DEBUG_KMS("2: conflicting encoders switching off %s\n",
475 						      connector->name);
476 					DRM_DEBUG_KMS("in favor of %s\n",
477 						      conflict->name);
478 					current_status = connector_status_disconnected;
479 				}
480 				break;
481 			}
482 		}
483 	}
484 	return current_status;
485 
486 }
487 
488 static struct drm_display_mode *radeon_fp_native_mode(struct drm_encoder *encoder)
489 {
490 	struct drm_device *dev = encoder->dev;
491 	struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
492 	struct drm_display_mode *mode = NULL;
493 	struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
494 
495 	if (native_mode->hdisplay != 0 &&
496 	    native_mode->vdisplay != 0 &&
497 	    native_mode->clock != 0) {
498 		mode = drm_mode_duplicate(dev, native_mode);
499 		mode->type = DRM_MODE_TYPE_PREFERRED | DRM_MODE_TYPE_DRIVER;
500 		drm_mode_set_name(mode);
501 
502 		DRM_DEBUG_KMS("Adding native panel mode %s\n", mode->name);
503 	} else if (native_mode->hdisplay != 0 &&
504 		   native_mode->vdisplay != 0) {
505 		/* mac laptops without an edid */
506 		/* Note that this is not necessarily the exact panel mode,
507 		 * but an approximation based on the cvt formula.  For these
508 		 * systems we should ideally read the mode info out of the
509 		 * registers or add a mode table, but this works and is much
510 		 * simpler.
511 		 */
512 		mode = drm_cvt_mode(dev, native_mode->hdisplay, native_mode->vdisplay, 60, true, false, false);
513 		mode->type = DRM_MODE_TYPE_PREFERRED | DRM_MODE_TYPE_DRIVER;
514 		DRM_DEBUG_KMS("Adding cvt approximation of native panel mode %s\n", mode->name);
515 	}
516 	return mode;
517 }
518 
519 static void radeon_add_common_modes(struct drm_encoder *encoder, struct drm_connector *connector)
520 {
521 	struct drm_device *dev = encoder->dev;
522 	struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
523 	struct drm_display_mode *mode = NULL;
524 	struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
525 	int i;
526 	struct mode_size {
527 		int w;
528 		int h;
529 	} common_modes[17] = {
530 		{ 640,  480},
531 		{ 720,  480},
532 		{ 800,  600},
533 		{ 848,  480},
534 		{1024,  768},
535 		{1152,  768},
536 		{1280,  720},
537 		{1280,  800},
538 		{1280,  854},
539 		{1280,  960},
540 		{1280, 1024},
541 		{1440,  900},
542 		{1400, 1050},
543 		{1680, 1050},
544 		{1600, 1200},
545 		{1920, 1080},
546 		{1920, 1200}
547 	};
548 
549 	for (i = 0; i < 17; i++) {
550 		if (radeon_encoder->devices & (ATOM_DEVICE_TV_SUPPORT)) {
551 			if (common_modes[i].w > 1024 ||
552 			    common_modes[i].h > 768)
553 				continue;
554 		}
555 		if (radeon_encoder->devices & (ATOM_DEVICE_LCD_SUPPORT)) {
556 			if (common_modes[i].w > native_mode->hdisplay ||
557 			    common_modes[i].h > native_mode->vdisplay ||
558 			    (common_modes[i].w == native_mode->hdisplay &&
559 			     common_modes[i].h == native_mode->vdisplay))
560 				continue;
561 		}
562 		if (common_modes[i].w < 320 || common_modes[i].h < 200)
563 			continue;
564 
565 		mode = drm_cvt_mode(dev, common_modes[i].w, common_modes[i].h, 60, false, false, false);
566 		drm_mode_probed_add(connector, mode);
567 	}
568 }
569 
570 static int radeon_connector_set_property(struct drm_connector *connector, struct drm_property *property,
571 				  uint64_t val)
572 {
573 	struct drm_device *dev = connector->dev;
574 	struct radeon_device *rdev = dev->dev_private;
575 	struct drm_encoder *encoder;
576 	struct radeon_encoder *radeon_encoder;
577 
578 	if (property == rdev->mode_info.coherent_mode_property) {
579 		struct radeon_encoder_atom_dig *dig;
580 		bool new_coherent_mode;
581 
582 		/* need to find digital encoder on connector */
583 		encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
584 		if (!encoder)
585 			return 0;
586 
587 		radeon_encoder = to_radeon_encoder(encoder);
588 
589 		if (!radeon_encoder->enc_priv)
590 			return 0;
591 
592 		dig = radeon_encoder->enc_priv;
593 		new_coherent_mode = val ? true : false;
594 		if (dig->coherent_mode != new_coherent_mode) {
595 			dig->coherent_mode = new_coherent_mode;
596 			radeon_property_change_mode(&radeon_encoder->base);
597 		}
598 	}
599 
600 	if (property == rdev->mode_info.audio_property) {
601 		struct radeon_connector *radeon_connector = to_radeon_connector(connector);
602 		/* need to find digital encoder on connector */
603 		encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
604 		if (!encoder)
605 			return 0;
606 
607 		radeon_encoder = to_radeon_encoder(encoder);
608 
609 		if (radeon_connector->audio != val) {
610 			radeon_connector->audio = val;
611 			radeon_property_change_mode(&radeon_encoder->base);
612 		}
613 	}
614 
615 	if (property == rdev->mode_info.dither_property) {
616 		struct radeon_connector *radeon_connector = to_radeon_connector(connector);
617 		/* need to find digital encoder on connector */
618 		encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
619 		if (!encoder)
620 			return 0;
621 
622 		radeon_encoder = to_radeon_encoder(encoder);
623 
624 		if (radeon_connector->dither != val) {
625 			radeon_connector->dither = val;
626 			radeon_property_change_mode(&radeon_encoder->base);
627 		}
628 	}
629 
630 	if (property == rdev->mode_info.underscan_property) {
631 		/* need to find digital encoder on connector */
632 		encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
633 		if (!encoder)
634 			return 0;
635 
636 		radeon_encoder = to_radeon_encoder(encoder);
637 
638 		if (radeon_encoder->underscan_type != val) {
639 			radeon_encoder->underscan_type = val;
640 			radeon_property_change_mode(&radeon_encoder->base);
641 		}
642 	}
643 
644 	if (property == rdev->mode_info.underscan_hborder_property) {
645 		/* need to find digital encoder on connector */
646 		encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
647 		if (!encoder)
648 			return 0;
649 
650 		radeon_encoder = to_radeon_encoder(encoder);
651 
652 		if (radeon_encoder->underscan_hborder != val) {
653 			radeon_encoder->underscan_hborder = val;
654 			radeon_property_change_mode(&radeon_encoder->base);
655 		}
656 	}
657 
658 	if (property == rdev->mode_info.underscan_vborder_property) {
659 		/* need to find digital encoder on connector */
660 		encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
661 		if (!encoder)
662 			return 0;
663 
664 		radeon_encoder = to_radeon_encoder(encoder);
665 
666 		if (radeon_encoder->underscan_vborder != val) {
667 			radeon_encoder->underscan_vborder = val;
668 			radeon_property_change_mode(&radeon_encoder->base);
669 		}
670 	}
671 
672 	if (property == rdev->mode_info.tv_std_property) {
673 		encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TVDAC);
674 		if (!encoder) {
675 			encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_DAC);
676 		}
677 
678 		if (!encoder)
679 			return 0;
680 
681 		radeon_encoder = to_radeon_encoder(encoder);
682 		if (!radeon_encoder->enc_priv)
683 			return 0;
684 		if (ASIC_IS_AVIVO(rdev) || radeon_r4xx_atom) {
685 			struct radeon_encoder_atom_dac *dac_int;
686 			dac_int = radeon_encoder->enc_priv;
687 			dac_int->tv_std = val;
688 		} else {
689 			struct radeon_encoder_tv_dac *dac_int;
690 			dac_int = radeon_encoder->enc_priv;
691 			dac_int->tv_std = val;
692 		}
693 		radeon_property_change_mode(&radeon_encoder->base);
694 	}
695 
696 	if (property == rdev->mode_info.load_detect_property) {
697 		struct radeon_connector *radeon_connector =
698 			to_radeon_connector(connector);
699 
700 		if (val == 0)
701 			radeon_connector->dac_load_detect = false;
702 		else
703 			radeon_connector->dac_load_detect = true;
704 	}
705 
706 	if (property == rdev->mode_info.tmds_pll_property) {
707 		struct radeon_encoder_int_tmds *tmds = NULL;
708 		bool ret = false;
709 		/* need to find digital encoder on connector */
710 		encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
711 		if (!encoder)
712 			return 0;
713 
714 		radeon_encoder = to_radeon_encoder(encoder);
715 
716 		tmds = radeon_encoder->enc_priv;
717 		if (!tmds)
718 			return 0;
719 
720 		if (val == 0) {
721 			if (rdev->is_atom_bios)
722 				ret = radeon_atombios_get_tmds_info(radeon_encoder, tmds);
723 			else
724 				ret = radeon_legacy_get_tmds_info_from_combios(radeon_encoder, tmds);
725 		}
726 		if (val == 1 || ret == false) {
727 			radeon_legacy_get_tmds_info_from_table(radeon_encoder, tmds);
728 		}
729 		radeon_property_change_mode(&radeon_encoder->base);
730 	}
731 
732 	if (property == dev->mode_config.scaling_mode_property) {
733 		enum radeon_rmx_type rmx_type;
734 
735 		if (connector->encoder)
736 			radeon_encoder = to_radeon_encoder(connector->encoder);
737 		else {
738 			const struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
739 			radeon_encoder = to_radeon_encoder(connector_funcs->best_encoder(connector));
740 		}
741 
742 		switch (val) {
743 		default:
744 		case DRM_MODE_SCALE_NONE: rmx_type = RMX_OFF; break;
745 		case DRM_MODE_SCALE_CENTER: rmx_type = RMX_CENTER; break;
746 		case DRM_MODE_SCALE_ASPECT: rmx_type = RMX_ASPECT; break;
747 		case DRM_MODE_SCALE_FULLSCREEN: rmx_type = RMX_FULL; break;
748 		}
749 		if (radeon_encoder->rmx_type == rmx_type)
750 			return 0;
751 
752 		if ((rmx_type != DRM_MODE_SCALE_NONE) &&
753 		    (radeon_encoder->native_mode.clock == 0))
754 			return 0;
755 
756 		radeon_encoder->rmx_type = rmx_type;
757 
758 		radeon_property_change_mode(&radeon_encoder->base);
759 	}
760 
761 	if (property == rdev->mode_info.output_csc_property) {
762 		if (connector->encoder)
763 			radeon_encoder = to_radeon_encoder(connector->encoder);
764 		else {
765 			const struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
766 			radeon_encoder = to_radeon_encoder(connector_funcs->best_encoder(connector));
767 		}
768 
769 		if (radeon_encoder->output_csc == val)
770 			return 0;
771 
772 		radeon_encoder->output_csc = val;
773 
774 		if (connector->encoder->crtc) {
775 			struct drm_crtc *crtc  = connector->encoder->crtc;
776 			const struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
777 			struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc);
778 
779 			radeon_crtc->output_csc = radeon_encoder->output_csc;
780 
781 			(*crtc_funcs->load_lut)(crtc);
782 		}
783 	}
784 
785 	return 0;
786 }
787 
788 static void radeon_fixup_lvds_native_mode(struct drm_encoder *encoder,
789 					  struct drm_connector *connector)
790 {
791 	struct radeon_encoder *radeon_encoder =	to_radeon_encoder(encoder);
792 	struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
793 	struct drm_display_mode *t, *mode;
794 
795 	/* If the EDID preferred mode doesn't match the native mode, use it */
796 	list_for_each_entry_safe(mode, t, &connector->probed_modes, head) {
797 		if (mode->type & DRM_MODE_TYPE_PREFERRED) {
798 			if (mode->hdisplay != native_mode->hdisplay ||
799 			    mode->vdisplay != native_mode->vdisplay)
800 				memcpy(native_mode, mode, sizeof(*mode));
801 		}
802 	}
803 
804 	/* Try to get native mode details from EDID if necessary */
805 	if (!native_mode->clock) {
806 		list_for_each_entry_safe(mode, t, &connector->probed_modes, head) {
807 			if (mode->hdisplay == native_mode->hdisplay &&
808 			    mode->vdisplay == native_mode->vdisplay) {
809 				*native_mode = *mode;
810 				drm_mode_set_crtcinfo(native_mode, CRTC_INTERLACE_HALVE_V);
811 				DRM_DEBUG_KMS("Determined LVDS native mode details from EDID\n");
812 				break;
813 			}
814 		}
815 	}
816 
817 	if (!native_mode->clock) {
818 		DRM_DEBUG_KMS("No LVDS native mode details, disabling RMX\n");
819 		radeon_encoder->rmx_type = RMX_OFF;
820 	}
821 }
822 
823 static int radeon_lvds_get_modes(struct drm_connector *connector)
824 {
825 	struct drm_encoder *encoder;
826 	int ret = 0;
827 	struct drm_display_mode *mode;
828 
829 	radeon_connector_get_edid(connector);
830 	ret = radeon_ddc_get_modes(connector);
831 	if (ret > 0) {
832 		encoder = radeon_best_single_encoder(connector);
833 		if (encoder) {
834 			radeon_fixup_lvds_native_mode(encoder, connector);
835 			/* add scaled modes */
836 			radeon_add_common_modes(encoder, connector);
837 		}
838 		return ret;
839 	}
840 
841 	encoder = radeon_best_single_encoder(connector);
842 	if (!encoder)
843 		return 0;
844 
845 	/* we have no EDID modes */
846 	mode = radeon_fp_native_mode(encoder);
847 	if (mode) {
848 		ret = 1;
849 		drm_mode_probed_add(connector, mode);
850 		/* add the width/height from vbios tables if available */
851 		connector->display_info.width_mm = mode->width_mm;
852 		connector->display_info.height_mm = mode->height_mm;
853 		/* add scaled modes */
854 		radeon_add_common_modes(encoder, connector);
855 	}
856 
857 	return ret;
858 }
859 
860 static int radeon_lvds_mode_valid(struct drm_connector *connector,
861 				  struct drm_display_mode *mode)
862 {
863 	struct drm_encoder *encoder = radeon_best_single_encoder(connector);
864 
865 	if ((mode->hdisplay < 320) || (mode->vdisplay < 240))
866 		return MODE_PANEL;
867 
868 	if (encoder) {
869 		struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
870 		struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
871 
872 		/* AVIVO hardware supports downscaling modes larger than the panel
873 		 * to the panel size, but I'm not sure this is desirable.
874 		 */
875 		if ((mode->hdisplay > native_mode->hdisplay) ||
876 		    (mode->vdisplay > native_mode->vdisplay))
877 			return MODE_PANEL;
878 
879 		/* if scaling is disabled, block non-native modes */
880 		if (radeon_encoder->rmx_type == RMX_OFF) {
881 			if ((mode->hdisplay != native_mode->hdisplay) ||
882 			    (mode->vdisplay != native_mode->vdisplay))
883 				return MODE_PANEL;
884 		}
885 	}
886 
887 	return MODE_OK;
888 }
889 
890 static enum drm_connector_status
891 radeon_lvds_detect(struct drm_connector *connector, bool force)
892 {
893 	struct drm_device *dev = connector->dev;
894 	struct radeon_device *rdev = dev->dev_private;
895 	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
896 	struct drm_encoder *encoder = radeon_best_single_encoder(connector);
897 	enum drm_connector_status ret = connector_status_disconnected;
898 	int r;
899 
900 	r = pm_runtime_get_sync(connector->dev->dev);
901 	if (r < 0)
902 		return connector_status_disconnected;
903 
904 	if (encoder) {
905 		struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
906 		struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
907 
908 		/* check if panel is valid */
909 		if (native_mode->hdisplay >= 320 && native_mode->vdisplay >= 240)
910 			ret = connector_status_connected;
911 		/* don't fetch the edid from the vbios if ddc fails and runpm is
912 		 * enabled so we report disconnected.
913 		 */
914 		if ((rdev->flags & RADEON_IS_PX) && (radeon_runtime_pm != 0))
915 			ret = connector_status_disconnected;
916 	}
917 
918 	/* check for edid as well */
919 	radeon_connector_get_edid(connector);
920 	if (radeon_connector->edid)
921 		ret = connector_status_connected;
922 	/* check acpi lid status ??? */
923 
924 	radeon_connector_update_scratch_regs(connector, ret);
925 	pm_runtime_mark_last_busy(connector->dev->dev);
926 	pm_runtime_put_autosuspend(connector->dev->dev);
927 	return ret;
928 }
929 
930 static void radeon_connector_unregister(struct drm_connector *connector)
931 {
932 	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
933 
934 	if (radeon_connector->ddc_bus && radeon_connector->ddc_bus->has_aux) {
935 		drm_dp_aux_unregister(&radeon_connector->ddc_bus->aux);
936 		radeon_connector->ddc_bus->has_aux = false;
937 	}
938 }
939 
940 static void radeon_connector_destroy(struct drm_connector *connector)
941 {
942 	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
943 
944 	radeon_connector_free_edid(connector);
945 	kfree(radeon_connector->con_priv);
946 	drm_connector_unregister(connector);
947 	drm_connector_cleanup(connector);
948 	kfree(connector);
949 }
950 
951 static int radeon_lvds_set_property(struct drm_connector *connector,
952 				    struct drm_property *property,
953 				    uint64_t value)
954 {
955 	struct drm_device *dev = connector->dev;
956 	struct radeon_encoder *radeon_encoder;
957 	enum radeon_rmx_type rmx_type;
958 
959 	DRM_DEBUG_KMS("\n");
960 	if (property != dev->mode_config.scaling_mode_property)
961 		return 0;
962 
963 	if (connector->encoder)
964 		radeon_encoder = to_radeon_encoder(connector->encoder);
965 	else {
966 		const struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
967 		radeon_encoder = to_radeon_encoder(connector_funcs->best_encoder(connector));
968 	}
969 
970 	switch (value) {
971 	case DRM_MODE_SCALE_NONE: rmx_type = RMX_OFF; break;
972 	case DRM_MODE_SCALE_CENTER: rmx_type = RMX_CENTER; break;
973 	case DRM_MODE_SCALE_ASPECT: rmx_type = RMX_ASPECT; break;
974 	default:
975 	case DRM_MODE_SCALE_FULLSCREEN: rmx_type = RMX_FULL; break;
976 	}
977 	if (radeon_encoder->rmx_type == rmx_type)
978 		return 0;
979 
980 	radeon_encoder->rmx_type = rmx_type;
981 
982 	radeon_property_change_mode(&radeon_encoder->base);
983 	return 0;
984 }
985 
986 
987 static const struct drm_connector_helper_funcs radeon_lvds_connector_helper_funcs = {
988 	.get_modes = radeon_lvds_get_modes,
989 	.mode_valid = radeon_lvds_mode_valid,
990 	.best_encoder = radeon_best_single_encoder,
991 };
992 
993 static const struct drm_connector_funcs radeon_lvds_connector_funcs = {
994 	.dpms = drm_helper_connector_dpms,
995 	.detect = radeon_lvds_detect,
996 	.fill_modes = drm_helper_probe_single_connector_modes,
997 	.early_unregister = radeon_connector_unregister,
998 	.destroy = radeon_connector_destroy,
999 	.set_property = radeon_lvds_set_property,
1000 };
1001 
1002 static int radeon_vga_get_modes(struct drm_connector *connector)
1003 {
1004 	int ret;
1005 
1006 	radeon_connector_get_edid(connector);
1007 	ret = radeon_ddc_get_modes(connector);
1008 
1009 	radeon_get_native_mode(connector);
1010 
1011 	return ret;
1012 }
1013 
1014 static int radeon_vga_mode_valid(struct drm_connector *connector,
1015 				  struct drm_display_mode *mode)
1016 {
1017 	struct drm_device *dev = connector->dev;
1018 	struct radeon_device *rdev = dev->dev_private;
1019 
1020 	/* XXX check mode bandwidth */
1021 
1022 	if ((mode->clock / 10) > rdev->clock.max_pixel_clock)
1023 		return MODE_CLOCK_HIGH;
1024 
1025 	return MODE_OK;
1026 }
1027 
1028 static enum drm_connector_status
1029 radeon_vga_detect(struct drm_connector *connector, bool force)
1030 {
1031 	struct drm_device *dev = connector->dev;
1032 	struct radeon_device *rdev = dev->dev_private;
1033 	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1034 	struct drm_encoder *encoder;
1035 	const struct drm_encoder_helper_funcs *encoder_funcs;
1036 	bool dret = false;
1037 	enum drm_connector_status ret = connector_status_disconnected;
1038 	int r;
1039 
1040 	r = pm_runtime_get_sync(connector->dev->dev);
1041 	if (r < 0)
1042 		return connector_status_disconnected;
1043 
1044 	encoder = radeon_best_single_encoder(connector);
1045 	if (!encoder)
1046 		ret = connector_status_disconnected;
1047 
1048 	if (radeon_connector->ddc_bus)
1049 		dret = radeon_ddc_probe(radeon_connector, false);
1050 	if (dret) {
1051 		radeon_connector->detected_by_load = false;
1052 		radeon_connector_free_edid(connector);
1053 		radeon_connector_get_edid(connector);
1054 
1055 		if (!radeon_connector->edid) {
1056 			DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
1057 					connector->name);
1058 			ret = connector_status_connected;
1059 		} else {
1060 			radeon_connector->use_digital =
1061 				!!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
1062 
1063 			/* some oems have boards with separate digital and analog connectors
1064 			 * with a shared ddc line (often vga + hdmi)
1065 			 */
1066 			if (radeon_connector->use_digital && radeon_connector->shared_ddc) {
1067 				radeon_connector_free_edid(connector);
1068 				ret = connector_status_disconnected;
1069 			} else {
1070 				ret = connector_status_connected;
1071 			}
1072 		}
1073 	} else {
1074 
1075 		/* if we aren't forcing don't do destructive polling */
1076 		if (!force) {
1077 			/* only return the previous status if we last
1078 			 * detected a monitor via load.
1079 			 */
1080 			if (radeon_connector->detected_by_load)
1081 				ret = connector->status;
1082 			goto out;
1083 		}
1084 
1085 		if (radeon_connector->dac_load_detect && encoder) {
1086 			encoder_funcs = encoder->helper_private;
1087 			ret = encoder_funcs->detect(encoder, connector);
1088 			if (ret != connector_status_disconnected)
1089 				radeon_connector->detected_by_load = true;
1090 		}
1091 	}
1092 
1093 	if (ret == connector_status_connected)
1094 		ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
1095 
1096 	/* RN50 and some RV100 asics in servers often have a hardcoded EDID in the
1097 	 * vbios to deal with KVMs. If we have one and are not able to detect a monitor
1098 	 * by other means, assume the CRT is connected and use that EDID.
1099 	 */
1100 	if ((!rdev->is_atom_bios) &&
1101 	    (ret == connector_status_disconnected) &&
1102 	    rdev->mode_info.bios_hardcoded_edid_size) {
1103 		ret = connector_status_connected;
1104 	}
1105 
1106 	radeon_connector_update_scratch_regs(connector, ret);
1107 
1108 out:
1109 	pm_runtime_mark_last_busy(connector->dev->dev);
1110 	pm_runtime_put_autosuspend(connector->dev->dev);
1111 
1112 	return ret;
1113 }
1114 
1115 static const struct drm_connector_helper_funcs radeon_vga_connector_helper_funcs = {
1116 	.get_modes = radeon_vga_get_modes,
1117 	.mode_valid = radeon_vga_mode_valid,
1118 	.best_encoder = radeon_best_single_encoder,
1119 };
1120 
1121 static const struct drm_connector_funcs radeon_vga_connector_funcs = {
1122 	.dpms = drm_helper_connector_dpms,
1123 	.detect = radeon_vga_detect,
1124 	.fill_modes = drm_helper_probe_single_connector_modes,
1125 	.early_unregister = radeon_connector_unregister,
1126 	.destroy = radeon_connector_destroy,
1127 	.set_property = radeon_connector_set_property,
1128 };
1129 
1130 static int radeon_tv_get_modes(struct drm_connector *connector)
1131 {
1132 	struct drm_device *dev = connector->dev;
1133 	struct radeon_device *rdev = dev->dev_private;
1134 	struct drm_display_mode *tv_mode;
1135 	struct drm_encoder *encoder;
1136 
1137 	encoder = radeon_best_single_encoder(connector);
1138 	if (!encoder)
1139 		return 0;
1140 
1141 	/* avivo chips can scale any mode */
1142 	if (rdev->family >= CHIP_RS600)
1143 		/* add scaled modes */
1144 		radeon_add_common_modes(encoder, connector);
1145 	else {
1146 		/* only 800x600 is supported right now on pre-avivo chips */
1147 		tv_mode = drm_cvt_mode(dev, 800, 600, 60, false, false, false);
1148 		tv_mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
1149 		drm_mode_probed_add(connector, tv_mode);
1150 	}
1151 	return 1;
1152 }
1153 
1154 static int radeon_tv_mode_valid(struct drm_connector *connector,
1155 				struct drm_display_mode *mode)
1156 {
1157 	if ((mode->hdisplay > 1024) || (mode->vdisplay > 768))
1158 		return MODE_CLOCK_RANGE;
1159 	return MODE_OK;
1160 }
1161 
1162 static enum drm_connector_status
1163 radeon_tv_detect(struct drm_connector *connector, bool force)
1164 {
1165 	struct drm_encoder *encoder;
1166 	const struct drm_encoder_helper_funcs *encoder_funcs;
1167 	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1168 	enum drm_connector_status ret = connector_status_disconnected;
1169 	int r;
1170 
1171 	if (!radeon_connector->dac_load_detect)
1172 		return ret;
1173 
1174 	r = pm_runtime_get_sync(connector->dev->dev);
1175 	if (r < 0)
1176 		return connector_status_disconnected;
1177 
1178 	encoder = radeon_best_single_encoder(connector);
1179 	if (!encoder)
1180 		ret = connector_status_disconnected;
1181 	else {
1182 		encoder_funcs = encoder->helper_private;
1183 		ret = encoder_funcs->detect(encoder, connector);
1184 	}
1185 	if (ret == connector_status_connected)
1186 		ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, false);
1187 	radeon_connector_update_scratch_regs(connector, ret);
1188 	pm_runtime_mark_last_busy(connector->dev->dev);
1189 	pm_runtime_put_autosuspend(connector->dev->dev);
1190 	return ret;
1191 }
1192 
1193 static const struct drm_connector_helper_funcs radeon_tv_connector_helper_funcs = {
1194 	.get_modes = radeon_tv_get_modes,
1195 	.mode_valid = radeon_tv_mode_valid,
1196 	.best_encoder = radeon_best_single_encoder,
1197 };
1198 
1199 static const struct drm_connector_funcs radeon_tv_connector_funcs = {
1200 	.dpms = drm_helper_connector_dpms,
1201 	.detect = radeon_tv_detect,
1202 	.fill_modes = drm_helper_probe_single_connector_modes,
1203 	.early_unregister = radeon_connector_unregister,
1204 	.destroy = radeon_connector_destroy,
1205 	.set_property = radeon_connector_set_property,
1206 };
1207 
1208 static bool radeon_check_hpd_status_unchanged(struct drm_connector *connector)
1209 {
1210 	struct drm_device *dev = connector->dev;
1211 	struct radeon_device *rdev = dev->dev_private;
1212 	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1213 	enum drm_connector_status status;
1214 
1215 	/* We only trust HPD on R600 and newer ASICS. */
1216 	if (rdev->family >= CHIP_R600
1217 	  && radeon_connector->hpd.hpd != RADEON_HPD_NONE) {
1218 		if (radeon_hpd_sense(rdev, radeon_connector->hpd.hpd))
1219 			status = connector_status_connected;
1220 		else
1221 			status = connector_status_disconnected;
1222 		if (connector->status == status)
1223 			return true;
1224 	}
1225 
1226 	return false;
1227 }
1228 
1229 /*
1230  * DVI is complicated
1231  * Do a DDC probe, if DDC probe passes, get the full EDID so
1232  * we can do analog/digital monitor detection at this point.
1233  * If the monitor is an analog monitor or we got no DDC,
1234  * we need to find the DAC encoder object for this connector.
1235  * If we got no DDC, we do load detection on the DAC encoder object.
1236  * If we got analog DDC or load detection passes on the DAC encoder
1237  * we have to check if this analog encoder is shared with anyone else (TV)
1238  * if its shared we have to set the other connector to disconnected.
1239  */
1240 static enum drm_connector_status
1241 radeon_dvi_detect(struct drm_connector *connector, bool force)
1242 {
1243 	struct drm_device *dev = connector->dev;
1244 	struct radeon_device *rdev = dev->dev_private;
1245 	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1246 	struct drm_encoder *encoder = NULL;
1247 	const struct drm_encoder_helper_funcs *encoder_funcs;
1248 	int i, r;
1249 	enum drm_connector_status ret = connector_status_disconnected;
1250 	bool dret = false, broken_edid = false;
1251 
1252 	r = pm_runtime_get_sync(connector->dev->dev);
1253 	if (r < 0)
1254 		return connector_status_disconnected;
1255 
1256 	if (radeon_connector->detected_hpd_without_ddc) {
1257 		force = true;
1258 		radeon_connector->detected_hpd_without_ddc = false;
1259 	}
1260 
1261 	if (!force && radeon_check_hpd_status_unchanged(connector)) {
1262 		ret = connector->status;
1263 		goto exit;
1264 	}
1265 
1266 	if (radeon_connector->ddc_bus) {
1267 		dret = radeon_ddc_probe(radeon_connector, false);
1268 
1269 		/* Sometimes the pins required for the DDC probe on DVI
1270 		 * connectors don't make contact at the same time that the ones
1271 		 * for HPD do. If the DDC probe fails even though we had an HPD
1272 		 * signal, try again later */
1273 		if (!dret && !force &&
1274 		    connector->status != connector_status_connected) {
1275 			DRM_DEBUG_KMS("hpd detected without ddc, retrying in 1 second\n");
1276 			radeon_connector->detected_hpd_without_ddc = true;
1277 			schedule_delayed_work(&rdev->hotplug_work,
1278 					      msecs_to_jiffies(1000));
1279 			goto exit;
1280 		}
1281 	}
1282 	if (dret) {
1283 		radeon_connector->detected_by_load = false;
1284 		radeon_connector_free_edid(connector);
1285 		radeon_connector_get_edid(connector);
1286 
1287 		if (!radeon_connector->edid) {
1288 			DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
1289 					connector->name);
1290 			/* rs690 seems to have a problem with connectors not existing and always
1291 			 * return a block of 0's. If we see this just stop polling on this output */
1292 			if ((rdev->family == CHIP_RS690 || rdev->family == CHIP_RS740) &&
1293 			    radeon_connector->base.null_edid_counter) {
1294 				ret = connector_status_disconnected;
1295 				DRM_ERROR("%s: detected RS690 floating bus bug, stopping ddc detect\n",
1296 					  connector->name);
1297 				radeon_connector->ddc_bus = NULL;
1298 			} else {
1299 				ret = connector_status_connected;
1300 				broken_edid = true; /* defer use_digital to later */
1301 			}
1302 		} else {
1303 			radeon_connector->use_digital =
1304 				!!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
1305 
1306 			/* some oems have boards with separate digital and analog connectors
1307 			 * with a shared ddc line (often vga + hdmi)
1308 			 */
1309 			if ((!radeon_connector->use_digital) && radeon_connector->shared_ddc) {
1310 				radeon_connector_free_edid(connector);
1311 				ret = connector_status_disconnected;
1312 			} else {
1313 				ret = connector_status_connected;
1314 			}
1315 			/* This gets complicated.  We have boards with VGA + HDMI with a
1316 			 * shared DDC line and we have boards with DVI-D + HDMI with a shared
1317 			 * DDC line.  The latter is more complex because with DVI<->HDMI adapters
1318 			 * you don't really know what's connected to which port as both are digital.
1319 			 */
1320 			if (radeon_connector->shared_ddc && (ret == connector_status_connected)) {
1321 				struct drm_connector *list_connector;
1322 				struct radeon_connector *list_radeon_connector;
1323 				list_for_each_entry(list_connector, &dev->mode_config.connector_list, head) {
1324 					if (connector == list_connector)
1325 						continue;
1326 					list_radeon_connector = to_radeon_connector(list_connector);
1327 					if (list_radeon_connector->shared_ddc &&
1328 					    (list_radeon_connector->ddc_bus->rec.i2c_id ==
1329 					     radeon_connector->ddc_bus->rec.i2c_id)) {
1330 						/* cases where both connectors are digital */
1331 						if (list_connector->connector_type != DRM_MODE_CONNECTOR_VGA) {
1332 							/* hpd is our only option in this case */
1333 							if (!radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) {
1334 								radeon_connector_free_edid(connector);
1335 								ret = connector_status_disconnected;
1336 							}
1337 						}
1338 					}
1339 				}
1340 			}
1341 		}
1342 	}
1343 
1344 	if ((ret == connector_status_connected) && (radeon_connector->use_digital == true))
1345 		goto out;
1346 
1347 	/* DVI-D and HDMI-A are digital only */
1348 	if ((connector->connector_type == DRM_MODE_CONNECTOR_DVID) ||
1349 	    (connector->connector_type == DRM_MODE_CONNECTOR_HDMIA))
1350 		goto out;
1351 
1352 	/* if we aren't forcing don't do destructive polling */
1353 	if (!force) {
1354 		/* only return the previous status if we last
1355 		 * detected a monitor via load.
1356 		 */
1357 		if (radeon_connector->detected_by_load)
1358 			ret = connector->status;
1359 		goto out;
1360 	}
1361 
1362 	/* find analog encoder */
1363 	if (radeon_connector->dac_load_detect) {
1364 		for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
1365 			if (connector->encoder_ids[i] == 0)
1366 				break;
1367 
1368 			encoder = drm_encoder_find(connector->dev,
1369 						   connector->encoder_ids[i]);
1370 			if (!encoder)
1371 				continue;
1372 
1373 			if (encoder->encoder_type != DRM_MODE_ENCODER_DAC &&
1374 			    encoder->encoder_type != DRM_MODE_ENCODER_TVDAC)
1375 				continue;
1376 
1377 			encoder_funcs = encoder->helper_private;
1378 			if (encoder_funcs->detect) {
1379 				if (!broken_edid) {
1380 					if (ret != connector_status_connected) {
1381 						/* deal with analog monitors without DDC */
1382 						ret = encoder_funcs->detect(encoder, connector);
1383 						if (ret == connector_status_connected) {
1384 							radeon_connector->use_digital = false;
1385 						}
1386 						if (ret != connector_status_disconnected)
1387 							radeon_connector->detected_by_load = true;
1388 					}
1389 				} else {
1390 					enum drm_connector_status lret;
1391 					/* assume digital unless load detected otherwise */
1392 					radeon_connector->use_digital = true;
1393 					lret = encoder_funcs->detect(encoder, connector);
1394 					DRM_DEBUG_KMS("load_detect %x returned: %x\n",encoder->encoder_type,lret);
1395 					if (lret == connector_status_connected)
1396 						radeon_connector->use_digital = false;
1397 				}
1398 				break;
1399 			}
1400 		}
1401 	}
1402 
1403 	if ((ret == connector_status_connected) && (radeon_connector->use_digital == false) &&
1404 	    encoder) {
1405 		ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
1406 	}
1407 
1408 	/* RN50 and some RV100 asics in servers often have a hardcoded EDID in the
1409 	 * vbios to deal with KVMs. If we have one and are not able to detect a monitor
1410 	 * by other means, assume the DFP is connected and use that EDID.  In most
1411 	 * cases the DVI port is actually a virtual KVM port connected to the service
1412 	 * processor.
1413 	 */
1414 out:
1415 	if ((!rdev->is_atom_bios) &&
1416 	    (ret == connector_status_disconnected) &&
1417 	    rdev->mode_info.bios_hardcoded_edid_size) {
1418 		radeon_connector->use_digital = true;
1419 		ret = connector_status_connected;
1420 	}
1421 
1422 	/* updated in get modes as well since we need to know if it's analog or digital */
1423 	radeon_connector_update_scratch_regs(connector, ret);
1424 
1425 	if ((radeon_audio != 0) && radeon_connector->use_digital) {
1426 		const struct drm_connector_helper_funcs *connector_funcs =
1427 			connector->helper_private;
1428 
1429 		encoder = connector_funcs->best_encoder(connector);
1430 		if (encoder && (encoder->encoder_type == DRM_MODE_ENCODER_TMDS)) {
1431 			radeon_connector_get_edid(connector);
1432 			radeon_audio_detect(connector, encoder, ret);
1433 		}
1434 	}
1435 
1436 exit:
1437 	pm_runtime_mark_last_busy(connector->dev->dev);
1438 	pm_runtime_put_autosuspend(connector->dev->dev);
1439 
1440 	return ret;
1441 }
1442 
1443 /* okay need to be smart in here about which encoder to pick */
1444 static struct drm_encoder *radeon_dvi_encoder(struct drm_connector *connector)
1445 {
1446 	int enc_id = connector->encoder_ids[0];
1447 	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1448 	struct drm_encoder *encoder;
1449 	int i;
1450 	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
1451 		if (connector->encoder_ids[i] == 0)
1452 			break;
1453 
1454 		encoder = drm_encoder_find(connector->dev, connector->encoder_ids[i]);
1455 		if (!encoder)
1456 			continue;
1457 
1458 		if (radeon_connector->use_digital == true) {
1459 			if (encoder->encoder_type == DRM_MODE_ENCODER_TMDS)
1460 				return encoder;
1461 		} else {
1462 			if (encoder->encoder_type == DRM_MODE_ENCODER_DAC ||
1463 			    encoder->encoder_type == DRM_MODE_ENCODER_TVDAC)
1464 				return encoder;
1465 		}
1466 	}
1467 
1468 	/* see if we have a default encoder  TODO */
1469 
1470 	/* then check use digitial */
1471 	/* pick the first one */
1472 	if (enc_id)
1473 		return drm_encoder_find(connector->dev, enc_id);
1474 	return NULL;
1475 }
1476 
1477 static void radeon_dvi_force(struct drm_connector *connector)
1478 {
1479 	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1480 	if (connector->force == DRM_FORCE_ON)
1481 		radeon_connector->use_digital = false;
1482 	if (connector->force == DRM_FORCE_ON_DIGITAL)
1483 		radeon_connector->use_digital = true;
1484 }
1485 
1486 static int radeon_dvi_mode_valid(struct drm_connector *connector,
1487 				  struct drm_display_mode *mode)
1488 {
1489 	struct drm_device *dev = connector->dev;
1490 	struct radeon_device *rdev = dev->dev_private;
1491 	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1492 
1493 	/* XXX check mode bandwidth */
1494 
1495 	/* clocks over 135 MHz have heat issues with DVI on RV100 */
1496 	if (radeon_connector->use_digital &&
1497 	    (rdev->family == CHIP_RV100) &&
1498 	    (mode->clock > 135000))
1499 		return MODE_CLOCK_HIGH;
1500 
1501 	if (radeon_connector->use_digital && (mode->clock > 165000)) {
1502 		if ((radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_I) ||
1503 		    (radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_D) ||
1504 		    (radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_HDMI_TYPE_B))
1505 			return MODE_OK;
1506 		else if (ASIC_IS_DCE6(rdev) && drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
1507 			/* HDMI 1.3+ supports max clock of 340 Mhz */
1508 			if (mode->clock > 340000)
1509 				return MODE_CLOCK_HIGH;
1510 			else
1511 				return MODE_OK;
1512 		} else {
1513 			return MODE_CLOCK_HIGH;
1514 		}
1515 	}
1516 
1517 	/* check against the max pixel clock */
1518 	if ((mode->clock / 10) > rdev->clock.max_pixel_clock)
1519 		return MODE_CLOCK_HIGH;
1520 
1521 	return MODE_OK;
1522 }
1523 
1524 static const struct drm_connector_helper_funcs radeon_dvi_connector_helper_funcs = {
1525 	.get_modes = radeon_vga_get_modes,
1526 	.mode_valid = radeon_dvi_mode_valid,
1527 	.best_encoder = radeon_dvi_encoder,
1528 };
1529 
1530 static const struct drm_connector_funcs radeon_dvi_connector_funcs = {
1531 	.dpms = drm_helper_connector_dpms,
1532 	.detect = radeon_dvi_detect,
1533 	.fill_modes = drm_helper_probe_single_connector_modes,
1534 	.set_property = radeon_connector_set_property,
1535 	.early_unregister = radeon_connector_unregister,
1536 	.destroy = radeon_connector_destroy,
1537 	.force = radeon_dvi_force,
1538 };
1539 
1540 static int radeon_dp_get_modes(struct drm_connector *connector)
1541 {
1542 	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1543 	struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
1544 	struct drm_encoder *encoder = radeon_best_single_encoder(connector);
1545 	int ret;
1546 
1547 	if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) ||
1548 	    (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
1549 		struct drm_display_mode *mode;
1550 
1551 		if (connector->connector_type == DRM_MODE_CONNECTOR_eDP) {
1552 			if (!radeon_dig_connector->edp_on)
1553 				atombios_set_edp_panel_power(connector,
1554 							     ATOM_TRANSMITTER_ACTION_POWER_ON);
1555 			radeon_connector_get_edid(connector);
1556 			ret = radeon_ddc_get_modes(connector);
1557 			if (!radeon_dig_connector->edp_on)
1558 				atombios_set_edp_panel_power(connector,
1559 							     ATOM_TRANSMITTER_ACTION_POWER_OFF);
1560 		} else {
1561 			/* need to setup ddc on the bridge */
1562 			if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
1563 			    ENCODER_OBJECT_ID_NONE) {
1564 				if (encoder)
1565 					radeon_atom_ext_encoder_setup_ddc(encoder);
1566 			}
1567 			radeon_connector_get_edid(connector);
1568 			ret = radeon_ddc_get_modes(connector);
1569 		}
1570 
1571 		if (ret > 0) {
1572 			if (encoder) {
1573 				radeon_fixup_lvds_native_mode(encoder, connector);
1574 				/* add scaled modes */
1575 				radeon_add_common_modes(encoder, connector);
1576 			}
1577 			return ret;
1578 		}
1579 
1580 		if (!encoder)
1581 			return 0;
1582 
1583 		/* we have no EDID modes */
1584 		mode = radeon_fp_native_mode(encoder);
1585 		if (mode) {
1586 			ret = 1;
1587 			drm_mode_probed_add(connector, mode);
1588 			/* add the width/height from vbios tables if available */
1589 			connector->display_info.width_mm = mode->width_mm;
1590 			connector->display_info.height_mm = mode->height_mm;
1591 			/* add scaled modes */
1592 			radeon_add_common_modes(encoder, connector);
1593 		}
1594 	} else {
1595 		/* need to setup ddc on the bridge */
1596 		if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
1597 			ENCODER_OBJECT_ID_NONE) {
1598 			if (encoder)
1599 				radeon_atom_ext_encoder_setup_ddc(encoder);
1600 		}
1601 		radeon_connector_get_edid(connector);
1602 		ret = radeon_ddc_get_modes(connector);
1603 
1604 		radeon_get_native_mode(connector);
1605 	}
1606 
1607 	return ret;
1608 }
1609 
1610 u16 radeon_connector_encoder_get_dp_bridge_encoder_id(struct drm_connector *connector)
1611 {
1612 	struct drm_encoder *encoder;
1613 	struct radeon_encoder *radeon_encoder;
1614 	int i;
1615 
1616 	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
1617 		if (connector->encoder_ids[i] == 0)
1618 			break;
1619 
1620 		encoder = drm_encoder_find(connector->dev, connector->encoder_ids[i]);
1621 		if (!encoder)
1622 			continue;
1623 
1624 		radeon_encoder = to_radeon_encoder(encoder);
1625 
1626 		switch (radeon_encoder->encoder_id) {
1627 		case ENCODER_OBJECT_ID_TRAVIS:
1628 		case ENCODER_OBJECT_ID_NUTMEG:
1629 			return radeon_encoder->encoder_id;
1630 		default:
1631 			break;
1632 		}
1633 	}
1634 
1635 	return ENCODER_OBJECT_ID_NONE;
1636 }
1637 
1638 static bool radeon_connector_encoder_is_hbr2(struct drm_connector *connector)
1639 {
1640 	struct drm_encoder *encoder;
1641 	struct radeon_encoder *radeon_encoder;
1642 	int i;
1643 	bool found = false;
1644 
1645 	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
1646 		if (connector->encoder_ids[i] == 0)
1647 			break;
1648 
1649 		encoder = drm_encoder_find(connector->dev, connector->encoder_ids[i]);
1650 		if (!encoder)
1651 			continue;
1652 
1653 		radeon_encoder = to_radeon_encoder(encoder);
1654 		if (radeon_encoder->caps & ATOM_ENCODER_CAP_RECORD_HBR2)
1655 			found = true;
1656 	}
1657 
1658 	return found;
1659 }
1660 
1661 bool radeon_connector_is_dp12_capable(struct drm_connector *connector)
1662 {
1663 	struct drm_device *dev = connector->dev;
1664 	struct radeon_device *rdev = dev->dev_private;
1665 
1666 	if (ASIC_IS_DCE5(rdev) &&
1667 	    (rdev->clock.default_dispclk >= 53900) &&
1668 	    radeon_connector_encoder_is_hbr2(connector)) {
1669 		return true;
1670 	}
1671 
1672 	return false;
1673 }
1674 
1675 static enum drm_connector_status
1676 radeon_dp_detect(struct drm_connector *connector, bool force)
1677 {
1678 	struct drm_device *dev = connector->dev;
1679 	struct radeon_device *rdev = dev->dev_private;
1680 	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1681 	enum drm_connector_status ret = connector_status_disconnected;
1682 	struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
1683 	struct drm_encoder *encoder = radeon_best_single_encoder(connector);
1684 	int r;
1685 
1686 	if (radeon_dig_connector->is_mst)
1687 		return connector_status_disconnected;
1688 
1689 	r = pm_runtime_get_sync(connector->dev->dev);
1690 	if (r < 0)
1691 		return connector_status_disconnected;
1692 
1693 	if (!force && radeon_check_hpd_status_unchanged(connector)) {
1694 		ret = connector->status;
1695 		goto out;
1696 	}
1697 
1698 	radeon_connector_free_edid(connector);
1699 
1700 	if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) ||
1701 	    (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
1702 		if (encoder) {
1703 			struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
1704 			struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
1705 
1706 			/* check if panel is valid */
1707 			if (native_mode->hdisplay >= 320 && native_mode->vdisplay >= 240)
1708 				ret = connector_status_connected;
1709 			/* don't fetch the edid from the vbios if ddc fails and runpm is
1710 			 * enabled so we report disconnected.
1711 			 */
1712 			if ((rdev->flags & RADEON_IS_PX) && (radeon_runtime_pm != 0))
1713 				ret = connector_status_disconnected;
1714 		}
1715 		/* eDP is always DP */
1716 		radeon_dig_connector->dp_sink_type = CONNECTOR_OBJECT_ID_DISPLAYPORT;
1717 		if (!radeon_dig_connector->edp_on)
1718 			atombios_set_edp_panel_power(connector,
1719 						     ATOM_TRANSMITTER_ACTION_POWER_ON);
1720 		if (radeon_dp_getdpcd(radeon_connector))
1721 			ret = connector_status_connected;
1722 		if (!radeon_dig_connector->edp_on)
1723 			atombios_set_edp_panel_power(connector,
1724 						     ATOM_TRANSMITTER_ACTION_POWER_OFF);
1725 	} else if (radeon_connector_encoder_get_dp_bridge_encoder_id(connector) !=
1726 		   ENCODER_OBJECT_ID_NONE) {
1727 		/* DP bridges are always DP */
1728 		radeon_dig_connector->dp_sink_type = CONNECTOR_OBJECT_ID_DISPLAYPORT;
1729 		/* get the DPCD from the bridge */
1730 		radeon_dp_getdpcd(radeon_connector);
1731 
1732 		if (encoder) {
1733 			/* setup ddc on the bridge */
1734 			radeon_atom_ext_encoder_setup_ddc(encoder);
1735 			/* bridge chips are always aux */
1736 			if (radeon_ddc_probe(radeon_connector, true)) /* try DDC */
1737 				ret = connector_status_connected;
1738 			else if (radeon_connector->dac_load_detect) { /* try load detection */
1739 				const struct drm_encoder_helper_funcs *encoder_funcs = encoder->helper_private;
1740 				ret = encoder_funcs->detect(encoder, connector);
1741 			}
1742 		}
1743 	} else {
1744 		radeon_dig_connector->dp_sink_type = radeon_dp_getsinktype(radeon_connector);
1745 		if (radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) {
1746 			ret = connector_status_connected;
1747 			if (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) {
1748 				radeon_dp_getdpcd(radeon_connector);
1749 				r = radeon_dp_mst_probe(radeon_connector);
1750 				if (r == 1)
1751 					ret = connector_status_disconnected;
1752 			}
1753 		} else {
1754 			if (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) {
1755 				if (radeon_dp_getdpcd(radeon_connector)) {
1756 					r = radeon_dp_mst_probe(radeon_connector);
1757 					if (r == 1)
1758 						ret = connector_status_disconnected;
1759 					else
1760 						ret = connector_status_connected;
1761 				}
1762 			} else {
1763 				/* try non-aux ddc (DP to DVI/HDMI/etc. adapter) */
1764 				if (radeon_ddc_probe(radeon_connector, false))
1765 					ret = connector_status_connected;
1766 			}
1767 		}
1768 	}
1769 
1770 	radeon_connector_update_scratch_regs(connector, ret);
1771 
1772 	if ((radeon_audio != 0) && encoder) {
1773 		radeon_connector_get_edid(connector);
1774 		radeon_audio_detect(connector, encoder, ret);
1775 	}
1776 
1777 out:
1778 	pm_runtime_mark_last_busy(connector->dev->dev);
1779 	pm_runtime_put_autosuspend(connector->dev->dev);
1780 
1781 	return ret;
1782 }
1783 
1784 static int radeon_dp_mode_valid(struct drm_connector *connector,
1785 				  struct drm_display_mode *mode)
1786 {
1787 	struct drm_device *dev = connector->dev;
1788 	struct radeon_device *rdev = dev->dev_private;
1789 	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1790 	struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
1791 
1792 	/* XXX check mode bandwidth */
1793 
1794 	if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) ||
1795 	    (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
1796 		struct drm_encoder *encoder = radeon_best_single_encoder(connector);
1797 
1798 		if ((mode->hdisplay < 320) || (mode->vdisplay < 240))
1799 			return MODE_PANEL;
1800 
1801 		if (encoder) {
1802 			struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
1803 			struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
1804 
1805 			/* AVIVO hardware supports downscaling modes larger than the panel
1806 			 * to the panel size, but I'm not sure this is desirable.
1807 			 */
1808 			if ((mode->hdisplay > native_mode->hdisplay) ||
1809 			    (mode->vdisplay > native_mode->vdisplay))
1810 				return MODE_PANEL;
1811 
1812 			/* if scaling is disabled, block non-native modes */
1813 			if (radeon_encoder->rmx_type == RMX_OFF) {
1814 				if ((mode->hdisplay != native_mode->hdisplay) ||
1815 				    (mode->vdisplay != native_mode->vdisplay))
1816 					return MODE_PANEL;
1817 			}
1818 		}
1819 	} else {
1820 		if ((radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) ||
1821 		    (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_eDP)) {
1822 			return radeon_dp_mode_valid_helper(connector, mode);
1823 		} else {
1824 			if (ASIC_IS_DCE6(rdev) && drm_detect_hdmi_monitor(radeon_connector_edid(connector))) {
1825 				/* HDMI 1.3+ supports max clock of 340 Mhz */
1826 				if (mode->clock > 340000)
1827 					return MODE_CLOCK_HIGH;
1828 			} else {
1829 				if (mode->clock > 165000)
1830 					return MODE_CLOCK_HIGH;
1831 			}
1832 		}
1833 	}
1834 
1835 	return MODE_OK;
1836 }
1837 
1838 static const struct drm_connector_helper_funcs radeon_dp_connector_helper_funcs = {
1839 	.get_modes = radeon_dp_get_modes,
1840 	.mode_valid = radeon_dp_mode_valid,
1841 	.best_encoder = radeon_dvi_encoder,
1842 };
1843 
1844 static const struct drm_connector_funcs radeon_dp_connector_funcs = {
1845 	.dpms = drm_helper_connector_dpms,
1846 	.detect = radeon_dp_detect,
1847 	.fill_modes = drm_helper_probe_single_connector_modes,
1848 	.set_property = radeon_connector_set_property,
1849 	.early_unregister = radeon_connector_unregister,
1850 	.destroy = radeon_connector_destroy,
1851 	.force = radeon_dvi_force,
1852 };
1853 
1854 static const struct drm_connector_funcs radeon_edp_connector_funcs = {
1855 	.dpms = drm_helper_connector_dpms,
1856 	.detect = radeon_dp_detect,
1857 	.fill_modes = drm_helper_probe_single_connector_modes,
1858 	.set_property = radeon_lvds_set_property,
1859 	.early_unregister = radeon_connector_unregister,
1860 	.destroy = radeon_connector_destroy,
1861 	.force = radeon_dvi_force,
1862 };
1863 
1864 static const struct drm_connector_funcs radeon_lvds_bridge_connector_funcs = {
1865 	.dpms = drm_helper_connector_dpms,
1866 	.detect = radeon_dp_detect,
1867 	.fill_modes = drm_helper_probe_single_connector_modes,
1868 	.set_property = radeon_lvds_set_property,
1869 	.early_unregister = radeon_connector_unregister,
1870 	.destroy = radeon_connector_destroy,
1871 	.force = radeon_dvi_force,
1872 };
1873 
1874 void
1875 radeon_add_atom_connector(struct drm_device *dev,
1876 			  uint32_t connector_id,
1877 			  uint32_t supported_device,
1878 			  int connector_type,
1879 			  struct radeon_i2c_bus_rec *i2c_bus,
1880 			  uint32_t igp_lane_info,
1881 			  uint16_t connector_object_id,
1882 			  struct radeon_hpd *hpd,
1883 			  struct radeon_router *router)
1884 {
1885 	struct radeon_device *rdev = dev->dev_private;
1886 	struct drm_connector *connector;
1887 	struct radeon_connector *radeon_connector;
1888 	struct radeon_connector_atom_dig *radeon_dig_connector;
1889 	struct drm_encoder *encoder;
1890 	struct radeon_encoder *radeon_encoder;
1891 	uint32_t subpixel_order = SubPixelNone;
1892 	bool shared_ddc = false;
1893 	bool is_dp_bridge = false;
1894 	bool has_aux = false;
1895 
1896 	if (connector_type == DRM_MODE_CONNECTOR_Unknown)
1897 		return;
1898 
1899 	/* if the user selected tv=0 don't try and add the connector */
1900 	if (((connector_type == DRM_MODE_CONNECTOR_SVIDEO) ||
1901 	     (connector_type == DRM_MODE_CONNECTOR_Composite) ||
1902 	     (connector_type == DRM_MODE_CONNECTOR_9PinDIN)) &&
1903 	    (radeon_tv == 0))
1904 		return;
1905 
1906 	/* see if we already added it */
1907 	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
1908 		radeon_connector = to_radeon_connector(connector);
1909 		if (radeon_connector->connector_id == connector_id) {
1910 			radeon_connector->devices |= supported_device;
1911 			return;
1912 		}
1913 		if (radeon_connector->ddc_bus && i2c_bus->valid) {
1914 			if (radeon_connector->ddc_bus->rec.i2c_id == i2c_bus->i2c_id) {
1915 				radeon_connector->shared_ddc = true;
1916 				shared_ddc = true;
1917 			}
1918 			if (radeon_connector->router_bus && router->ddc_valid &&
1919 			    (radeon_connector->router.router_id == router->router_id)) {
1920 				radeon_connector->shared_ddc = false;
1921 				shared_ddc = false;
1922 			}
1923 		}
1924 	}
1925 
1926 	/* check if it's a dp bridge */
1927 	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
1928 		radeon_encoder = to_radeon_encoder(encoder);
1929 		if (radeon_encoder->devices & supported_device) {
1930 			switch (radeon_encoder->encoder_id) {
1931 			case ENCODER_OBJECT_ID_TRAVIS:
1932 			case ENCODER_OBJECT_ID_NUTMEG:
1933 				is_dp_bridge = true;
1934 				break;
1935 			default:
1936 				break;
1937 			}
1938 		}
1939 	}
1940 
1941 	radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
1942 	if (!radeon_connector)
1943 		return;
1944 
1945 	connector = &radeon_connector->base;
1946 
1947 	radeon_connector->connector_id = connector_id;
1948 	radeon_connector->devices = supported_device;
1949 	radeon_connector->shared_ddc = shared_ddc;
1950 	radeon_connector->connector_object_id = connector_object_id;
1951 	radeon_connector->hpd = *hpd;
1952 
1953 	radeon_connector->router = *router;
1954 	if (router->ddc_valid || router->cd_valid) {
1955 		radeon_connector->router_bus = radeon_i2c_lookup(rdev, &router->i2c_info);
1956 		if (!radeon_connector->router_bus)
1957 			DRM_ERROR("Failed to assign router i2c bus! Check dmesg for i2c errors.\n");
1958 	}
1959 
1960 	if (is_dp_bridge) {
1961 		radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1962 		if (!radeon_dig_connector)
1963 			goto failed;
1964 		radeon_dig_connector->igp_lane_info = igp_lane_info;
1965 		radeon_connector->con_priv = radeon_dig_connector;
1966 		if (i2c_bus->valid) {
1967 			radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
1968 			if (radeon_connector->ddc_bus)
1969 				has_aux = true;
1970 			else
1971 				DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
1972 		}
1973 		switch (connector_type) {
1974 		case DRM_MODE_CONNECTOR_VGA:
1975 		case DRM_MODE_CONNECTOR_DVIA:
1976 		default:
1977 			drm_connector_init(dev, &radeon_connector->base,
1978 					   &radeon_dp_connector_funcs, connector_type);
1979 			drm_connector_helper_add(&radeon_connector->base,
1980 						 &radeon_dp_connector_helper_funcs);
1981 			connector->interlace_allowed = true;
1982 			connector->doublescan_allowed = true;
1983 			radeon_connector->dac_load_detect = true;
1984 			drm_object_attach_property(&radeon_connector->base.base,
1985 						      rdev->mode_info.load_detect_property,
1986 						      1);
1987 			drm_object_attach_property(&radeon_connector->base.base,
1988 						   dev->mode_config.scaling_mode_property,
1989 						   DRM_MODE_SCALE_NONE);
1990 			if (ASIC_IS_DCE5(rdev))
1991 				drm_object_attach_property(&radeon_connector->base.base,
1992 							   rdev->mode_info.output_csc_property,
1993 							   RADEON_OUTPUT_CSC_BYPASS);
1994 			break;
1995 		case DRM_MODE_CONNECTOR_DVII:
1996 		case DRM_MODE_CONNECTOR_DVID:
1997 		case DRM_MODE_CONNECTOR_HDMIA:
1998 		case DRM_MODE_CONNECTOR_HDMIB:
1999 		case DRM_MODE_CONNECTOR_DisplayPort:
2000 			drm_connector_init(dev, &radeon_connector->base,
2001 					   &radeon_dp_connector_funcs, connector_type);
2002 			drm_connector_helper_add(&radeon_connector->base,
2003 						 &radeon_dp_connector_helper_funcs);
2004 			drm_object_attach_property(&radeon_connector->base.base,
2005 						      rdev->mode_info.underscan_property,
2006 						      UNDERSCAN_OFF);
2007 			drm_object_attach_property(&radeon_connector->base.base,
2008 						      rdev->mode_info.underscan_hborder_property,
2009 						      0);
2010 			drm_object_attach_property(&radeon_connector->base.base,
2011 						      rdev->mode_info.underscan_vborder_property,
2012 						      0);
2013 
2014 			drm_object_attach_property(&radeon_connector->base.base,
2015 						      dev->mode_config.scaling_mode_property,
2016 						      DRM_MODE_SCALE_NONE);
2017 
2018 			drm_object_attach_property(&radeon_connector->base.base,
2019 						   rdev->mode_info.dither_property,
2020 						   RADEON_FMT_DITHER_DISABLE);
2021 
2022 			if (radeon_audio != 0) {
2023 				drm_object_attach_property(&radeon_connector->base.base,
2024 							   rdev->mode_info.audio_property,
2025 							   RADEON_AUDIO_AUTO);
2026 				radeon_connector->audio = RADEON_AUDIO_AUTO;
2027 			}
2028 			if (ASIC_IS_DCE5(rdev))
2029 				drm_object_attach_property(&radeon_connector->base.base,
2030 							   rdev->mode_info.output_csc_property,
2031 							   RADEON_OUTPUT_CSC_BYPASS);
2032 
2033 			subpixel_order = SubPixelHorizontalRGB;
2034 			connector->interlace_allowed = true;
2035 			if (connector_type == DRM_MODE_CONNECTOR_HDMIB)
2036 				connector->doublescan_allowed = true;
2037 			else
2038 				connector->doublescan_allowed = false;
2039 			if (connector_type == DRM_MODE_CONNECTOR_DVII) {
2040 				radeon_connector->dac_load_detect = true;
2041 				drm_object_attach_property(&radeon_connector->base.base,
2042 							      rdev->mode_info.load_detect_property,
2043 							      1);
2044 			}
2045 			break;
2046 		case DRM_MODE_CONNECTOR_LVDS:
2047 		case DRM_MODE_CONNECTOR_eDP:
2048 			drm_connector_init(dev, &radeon_connector->base,
2049 					   &radeon_lvds_bridge_connector_funcs, connector_type);
2050 			drm_connector_helper_add(&radeon_connector->base,
2051 						 &radeon_dp_connector_helper_funcs);
2052 			drm_object_attach_property(&radeon_connector->base.base,
2053 						      dev->mode_config.scaling_mode_property,
2054 						      DRM_MODE_SCALE_FULLSCREEN);
2055 			subpixel_order = SubPixelHorizontalRGB;
2056 			connector->interlace_allowed = false;
2057 			connector->doublescan_allowed = false;
2058 			break;
2059 		}
2060 	} else {
2061 		switch (connector_type) {
2062 		case DRM_MODE_CONNECTOR_VGA:
2063 			drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
2064 			drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
2065 			if (i2c_bus->valid) {
2066 				radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2067 				if (!radeon_connector->ddc_bus)
2068 					DRM_ERROR("VGA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2069 			}
2070 			radeon_connector->dac_load_detect = true;
2071 			drm_object_attach_property(&radeon_connector->base.base,
2072 						      rdev->mode_info.load_detect_property,
2073 						      1);
2074 			if (ASIC_IS_AVIVO(rdev))
2075 				drm_object_attach_property(&radeon_connector->base.base,
2076 							   dev->mode_config.scaling_mode_property,
2077 							   DRM_MODE_SCALE_NONE);
2078 			if (ASIC_IS_DCE5(rdev))
2079 				drm_object_attach_property(&radeon_connector->base.base,
2080 							   rdev->mode_info.output_csc_property,
2081 							   RADEON_OUTPUT_CSC_BYPASS);
2082 			/* no HPD on analog connectors */
2083 			radeon_connector->hpd.hpd = RADEON_HPD_NONE;
2084 			connector->interlace_allowed = true;
2085 			connector->doublescan_allowed = true;
2086 			break;
2087 		case DRM_MODE_CONNECTOR_DVIA:
2088 			drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
2089 			drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
2090 			if (i2c_bus->valid) {
2091 				radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2092 				if (!radeon_connector->ddc_bus)
2093 					DRM_ERROR("DVIA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2094 			}
2095 			radeon_connector->dac_load_detect = true;
2096 			drm_object_attach_property(&radeon_connector->base.base,
2097 						      rdev->mode_info.load_detect_property,
2098 						      1);
2099 			if (ASIC_IS_AVIVO(rdev))
2100 				drm_object_attach_property(&radeon_connector->base.base,
2101 							   dev->mode_config.scaling_mode_property,
2102 							   DRM_MODE_SCALE_NONE);
2103 			if (ASIC_IS_DCE5(rdev))
2104 				drm_object_attach_property(&radeon_connector->base.base,
2105 							   rdev->mode_info.output_csc_property,
2106 							   RADEON_OUTPUT_CSC_BYPASS);
2107 			/* no HPD on analog connectors */
2108 			radeon_connector->hpd.hpd = RADEON_HPD_NONE;
2109 			connector->interlace_allowed = true;
2110 			connector->doublescan_allowed = true;
2111 			break;
2112 		case DRM_MODE_CONNECTOR_DVII:
2113 		case DRM_MODE_CONNECTOR_DVID:
2114 			radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
2115 			if (!radeon_dig_connector)
2116 				goto failed;
2117 			radeon_dig_connector->igp_lane_info = igp_lane_info;
2118 			radeon_connector->con_priv = radeon_dig_connector;
2119 			drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
2120 			drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
2121 			if (i2c_bus->valid) {
2122 				radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2123 				if (!radeon_connector->ddc_bus)
2124 					DRM_ERROR("DVI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2125 			}
2126 			subpixel_order = SubPixelHorizontalRGB;
2127 			drm_object_attach_property(&radeon_connector->base.base,
2128 						      rdev->mode_info.coherent_mode_property,
2129 						      1);
2130 			if (ASIC_IS_AVIVO(rdev)) {
2131 				drm_object_attach_property(&radeon_connector->base.base,
2132 							      rdev->mode_info.underscan_property,
2133 							      UNDERSCAN_OFF);
2134 				drm_object_attach_property(&radeon_connector->base.base,
2135 							      rdev->mode_info.underscan_hborder_property,
2136 							      0);
2137 				drm_object_attach_property(&radeon_connector->base.base,
2138 							      rdev->mode_info.underscan_vborder_property,
2139 							      0);
2140 				drm_object_attach_property(&radeon_connector->base.base,
2141 							   rdev->mode_info.dither_property,
2142 							   RADEON_FMT_DITHER_DISABLE);
2143 				drm_object_attach_property(&radeon_connector->base.base,
2144 							   dev->mode_config.scaling_mode_property,
2145 							   DRM_MODE_SCALE_NONE);
2146 			}
2147 			if (ASIC_IS_DCE2(rdev) && (radeon_audio != 0)) {
2148 				drm_object_attach_property(&radeon_connector->base.base,
2149 							   rdev->mode_info.audio_property,
2150 							   RADEON_AUDIO_AUTO);
2151 				radeon_connector->audio = RADEON_AUDIO_AUTO;
2152 			}
2153 			if (connector_type == DRM_MODE_CONNECTOR_DVII) {
2154 				radeon_connector->dac_load_detect = true;
2155 				drm_object_attach_property(&radeon_connector->base.base,
2156 							      rdev->mode_info.load_detect_property,
2157 							      1);
2158 			}
2159 			if (ASIC_IS_DCE5(rdev))
2160 				drm_object_attach_property(&radeon_connector->base.base,
2161 							   rdev->mode_info.output_csc_property,
2162 							   RADEON_OUTPUT_CSC_BYPASS);
2163 			connector->interlace_allowed = true;
2164 			if (connector_type == DRM_MODE_CONNECTOR_DVII)
2165 				connector->doublescan_allowed = true;
2166 			else
2167 				connector->doublescan_allowed = false;
2168 			break;
2169 		case DRM_MODE_CONNECTOR_HDMIA:
2170 		case DRM_MODE_CONNECTOR_HDMIB:
2171 			radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
2172 			if (!radeon_dig_connector)
2173 				goto failed;
2174 			radeon_dig_connector->igp_lane_info = igp_lane_info;
2175 			radeon_connector->con_priv = radeon_dig_connector;
2176 			drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
2177 			drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
2178 			if (i2c_bus->valid) {
2179 				radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2180 				if (!radeon_connector->ddc_bus)
2181 					DRM_ERROR("HDMI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2182 			}
2183 			drm_object_attach_property(&radeon_connector->base.base,
2184 						      rdev->mode_info.coherent_mode_property,
2185 						      1);
2186 			if (ASIC_IS_AVIVO(rdev)) {
2187 				drm_object_attach_property(&radeon_connector->base.base,
2188 							      rdev->mode_info.underscan_property,
2189 							      UNDERSCAN_OFF);
2190 				drm_object_attach_property(&radeon_connector->base.base,
2191 							      rdev->mode_info.underscan_hborder_property,
2192 							      0);
2193 				drm_object_attach_property(&radeon_connector->base.base,
2194 							      rdev->mode_info.underscan_vborder_property,
2195 							      0);
2196 				drm_object_attach_property(&radeon_connector->base.base,
2197 							   rdev->mode_info.dither_property,
2198 							   RADEON_FMT_DITHER_DISABLE);
2199 				drm_object_attach_property(&radeon_connector->base.base,
2200 							   dev->mode_config.scaling_mode_property,
2201 							   DRM_MODE_SCALE_NONE);
2202 			}
2203 			if (ASIC_IS_DCE2(rdev) && (radeon_audio != 0)) {
2204 				drm_object_attach_property(&radeon_connector->base.base,
2205 							   rdev->mode_info.audio_property,
2206 							   RADEON_AUDIO_AUTO);
2207 				radeon_connector->audio = RADEON_AUDIO_AUTO;
2208 			}
2209 			if (ASIC_IS_DCE5(rdev))
2210 				drm_object_attach_property(&radeon_connector->base.base,
2211 							   rdev->mode_info.output_csc_property,
2212 							   RADEON_OUTPUT_CSC_BYPASS);
2213 			subpixel_order = SubPixelHorizontalRGB;
2214 			connector->interlace_allowed = true;
2215 			if (connector_type == DRM_MODE_CONNECTOR_HDMIB)
2216 				connector->doublescan_allowed = true;
2217 			else
2218 				connector->doublescan_allowed = false;
2219 			break;
2220 		case DRM_MODE_CONNECTOR_DisplayPort:
2221 			radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
2222 			if (!radeon_dig_connector)
2223 				goto failed;
2224 			radeon_dig_connector->igp_lane_info = igp_lane_info;
2225 			radeon_connector->con_priv = radeon_dig_connector;
2226 			drm_connector_init(dev, &radeon_connector->base, &radeon_dp_connector_funcs, connector_type);
2227 			drm_connector_helper_add(&radeon_connector->base, &radeon_dp_connector_helper_funcs);
2228 			if (i2c_bus->valid) {
2229 				radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2230 				if (radeon_connector->ddc_bus)
2231 					has_aux = true;
2232 				else
2233 					DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2234 			}
2235 			subpixel_order = SubPixelHorizontalRGB;
2236 			drm_object_attach_property(&radeon_connector->base.base,
2237 						      rdev->mode_info.coherent_mode_property,
2238 						      1);
2239 			if (ASIC_IS_AVIVO(rdev)) {
2240 				drm_object_attach_property(&radeon_connector->base.base,
2241 							      rdev->mode_info.underscan_property,
2242 							      UNDERSCAN_OFF);
2243 				drm_object_attach_property(&radeon_connector->base.base,
2244 							      rdev->mode_info.underscan_hborder_property,
2245 							      0);
2246 				drm_object_attach_property(&radeon_connector->base.base,
2247 							      rdev->mode_info.underscan_vborder_property,
2248 							      0);
2249 				drm_object_attach_property(&radeon_connector->base.base,
2250 							   rdev->mode_info.dither_property,
2251 							   RADEON_FMT_DITHER_DISABLE);
2252 				drm_object_attach_property(&radeon_connector->base.base,
2253 							   dev->mode_config.scaling_mode_property,
2254 							   DRM_MODE_SCALE_NONE);
2255 			}
2256 			if (ASIC_IS_DCE2(rdev) && (radeon_audio != 0)) {
2257 				drm_object_attach_property(&radeon_connector->base.base,
2258 							   rdev->mode_info.audio_property,
2259 							   RADEON_AUDIO_AUTO);
2260 				radeon_connector->audio = RADEON_AUDIO_AUTO;
2261 			}
2262 			if (ASIC_IS_DCE5(rdev))
2263 				drm_object_attach_property(&radeon_connector->base.base,
2264 							   rdev->mode_info.output_csc_property,
2265 							   RADEON_OUTPUT_CSC_BYPASS);
2266 			connector->interlace_allowed = true;
2267 			/* in theory with a DP to VGA converter... */
2268 			connector->doublescan_allowed = false;
2269 			break;
2270 		case DRM_MODE_CONNECTOR_eDP:
2271 			radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
2272 			if (!radeon_dig_connector)
2273 				goto failed;
2274 			radeon_dig_connector->igp_lane_info = igp_lane_info;
2275 			radeon_connector->con_priv = radeon_dig_connector;
2276 			drm_connector_init(dev, &radeon_connector->base, &radeon_edp_connector_funcs, connector_type);
2277 			drm_connector_helper_add(&radeon_connector->base, &radeon_dp_connector_helper_funcs);
2278 			if (i2c_bus->valid) {
2279 				radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2280 				if (radeon_connector->ddc_bus)
2281 					has_aux = true;
2282 				else
2283 					DRM_ERROR("DP: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2284 			}
2285 			drm_object_attach_property(&radeon_connector->base.base,
2286 						      dev->mode_config.scaling_mode_property,
2287 						      DRM_MODE_SCALE_FULLSCREEN);
2288 			subpixel_order = SubPixelHorizontalRGB;
2289 			connector->interlace_allowed = false;
2290 			connector->doublescan_allowed = false;
2291 			break;
2292 		case DRM_MODE_CONNECTOR_SVIDEO:
2293 		case DRM_MODE_CONNECTOR_Composite:
2294 		case DRM_MODE_CONNECTOR_9PinDIN:
2295 			drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
2296 			drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
2297 			radeon_connector->dac_load_detect = true;
2298 			drm_object_attach_property(&radeon_connector->base.base,
2299 						      rdev->mode_info.load_detect_property,
2300 						      1);
2301 			drm_object_attach_property(&radeon_connector->base.base,
2302 						      rdev->mode_info.tv_std_property,
2303 						      radeon_atombios_get_tv_info(rdev));
2304 			/* no HPD on analog connectors */
2305 			radeon_connector->hpd.hpd = RADEON_HPD_NONE;
2306 			connector->interlace_allowed = false;
2307 			connector->doublescan_allowed = false;
2308 			break;
2309 		case DRM_MODE_CONNECTOR_LVDS:
2310 			radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
2311 			if (!radeon_dig_connector)
2312 				goto failed;
2313 			radeon_dig_connector->igp_lane_info = igp_lane_info;
2314 			radeon_connector->con_priv = radeon_dig_connector;
2315 			drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
2316 			drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
2317 			if (i2c_bus->valid) {
2318 				radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2319 				if (!radeon_connector->ddc_bus)
2320 					DRM_ERROR("LVDS: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2321 			}
2322 			drm_object_attach_property(&radeon_connector->base.base,
2323 						      dev->mode_config.scaling_mode_property,
2324 						      DRM_MODE_SCALE_FULLSCREEN);
2325 			subpixel_order = SubPixelHorizontalRGB;
2326 			connector->interlace_allowed = false;
2327 			connector->doublescan_allowed = false;
2328 			break;
2329 		}
2330 	}
2331 
2332 	if (radeon_connector->hpd.hpd == RADEON_HPD_NONE) {
2333 		if (i2c_bus->valid) {
2334 			connector->polled = DRM_CONNECTOR_POLL_CONNECT |
2335 			                    DRM_CONNECTOR_POLL_DISCONNECT;
2336 		}
2337 	} else
2338 		connector->polled = DRM_CONNECTOR_POLL_HPD;
2339 
2340 	connector->display_info.subpixel_order = subpixel_order;
2341 	drm_connector_register(connector);
2342 
2343 	if (has_aux)
2344 		radeon_dp_aux_init(radeon_connector);
2345 
2346 	return;
2347 
2348 failed:
2349 	drm_connector_cleanup(connector);
2350 	kfree(connector);
2351 }
2352 
2353 void
2354 radeon_add_legacy_connector(struct drm_device *dev,
2355 			    uint32_t connector_id,
2356 			    uint32_t supported_device,
2357 			    int connector_type,
2358 			    struct radeon_i2c_bus_rec *i2c_bus,
2359 			    uint16_t connector_object_id,
2360 			    struct radeon_hpd *hpd)
2361 {
2362 	struct radeon_device *rdev = dev->dev_private;
2363 	struct drm_connector *connector;
2364 	struct radeon_connector *radeon_connector;
2365 	uint32_t subpixel_order = SubPixelNone;
2366 
2367 	if (connector_type == DRM_MODE_CONNECTOR_Unknown)
2368 		return;
2369 
2370 	/* if the user selected tv=0 don't try and add the connector */
2371 	if (((connector_type == DRM_MODE_CONNECTOR_SVIDEO) ||
2372 	     (connector_type == DRM_MODE_CONNECTOR_Composite) ||
2373 	     (connector_type == DRM_MODE_CONNECTOR_9PinDIN)) &&
2374 	    (radeon_tv == 0))
2375 		return;
2376 
2377 	/* see if we already added it */
2378 	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
2379 		radeon_connector = to_radeon_connector(connector);
2380 		if (radeon_connector->connector_id == connector_id) {
2381 			radeon_connector->devices |= supported_device;
2382 			return;
2383 		}
2384 	}
2385 
2386 	radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
2387 	if (!radeon_connector)
2388 		return;
2389 
2390 	connector = &radeon_connector->base;
2391 
2392 	radeon_connector->connector_id = connector_id;
2393 	radeon_connector->devices = supported_device;
2394 	radeon_connector->connector_object_id = connector_object_id;
2395 	radeon_connector->hpd = *hpd;
2396 
2397 	switch (connector_type) {
2398 	case DRM_MODE_CONNECTOR_VGA:
2399 		drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
2400 		drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
2401 		if (i2c_bus->valid) {
2402 			radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2403 			if (!radeon_connector->ddc_bus)
2404 				DRM_ERROR("VGA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2405 		}
2406 		radeon_connector->dac_load_detect = true;
2407 		drm_object_attach_property(&radeon_connector->base.base,
2408 					      rdev->mode_info.load_detect_property,
2409 					      1);
2410 		/* no HPD on analog connectors */
2411 		radeon_connector->hpd.hpd = RADEON_HPD_NONE;
2412 		connector->interlace_allowed = true;
2413 		connector->doublescan_allowed = true;
2414 		break;
2415 	case DRM_MODE_CONNECTOR_DVIA:
2416 		drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
2417 		drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
2418 		if (i2c_bus->valid) {
2419 			radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2420 			if (!radeon_connector->ddc_bus)
2421 				DRM_ERROR("DVIA: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2422 		}
2423 		radeon_connector->dac_load_detect = true;
2424 		drm_object_attach_property(&radeon_connector->base.base,
2425 					      rdev->mode_info.load_detect_property,
2426 					      1);
2427 		/* no HPD on analog connectors */
2428 		radeon_connector->hpd.hpd = RADEON_HPD_NONE;
2429 		connector->interlace_allowed = true;
2430 		connector->doublescan_allowed = true;
2431 		break;
2432 	case DRM_MODE_CONNECTOR_DVII:
2433 	case DRM_MODE_CONNECTOR_DVID:
2434 		drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
2435 		drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
2436 		if (i2c_bus->valid) {
2437 			radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2438 			if (!radeon_connector->ddc_bus)
2439 				DRM_ERROR("DVI: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2440 		}
2441 		if (connector_type == DRM_MODE_CONNECTOR_DVII) {
2442 			radeon_connector->dac_load_detect = true;
2443 			drm_object_attach_property(&radeon_connector->base.base,
2444 						      rdev->mode_info.load_detect_property,
2445 						      1);
2446 		}
2447 		subpixel_order = SubPixelHorizontalRGB;
2448 		connector->interlace_allowed = true;
2449 		if (connector_type == DRM_MODE_CONNECTOR_DVII)
2450 			connector->doublescan_allowed = true;
2451 		else
2452 			connector->doublescan_allowed = false;
2453 		break;
2454 	case DRM_MODE_CONNECTOR_SVIDEO:
2455 	case DRM_MODE_CONNECTOR_Composite:
2456 	case DRM_MODE_CONNECTOR_9PinDIN:
2457 		drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
2458 		drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
2459 		radeon_connector->dac_load_detect = true;
2460 		/* RS400,RC410,RS480 chipset seems to report a lot
2461 		 * of false positive on load detect, we haven't yet
2462 		 * found a way to make load detect reliable on those
2463 		 * chipset, thus just disable it for TV.
2464 		 */
2465 		if (rdev->family == CHIP_RS400 || rdev->family == CHIP_RS480)
2466 			radeon_connector->dac_load_detect = false;
2467 		drm_object_attach_property(&radeon_connector->base.base,
2468 					      rdev->mode_info.load_detect_property,
2469 					      radeon_connector->dac_load_detect);
2470 		drm_object_attach_property(&radeon_connector->base.base,
2471 					      rdev->mode_info.tv_std_property,
2472 					      radeon_combios_get_tv_info(rdev));
2473 		/* no HPD on analog connectors */
2474 		radeon_connector->hpd.hpd = RADEON_HPD_NONE;
2475 		connector->interlace_allowed = false;
2476 		connector->doublescan_allowed = false;
2477 		break;
2478 	case DRM_MODE_CONNECTOR_LVDS:
2479 		drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
2480 		drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
2481 		if (i2c_bus->valid) {
2482 			radeon_connector->ddc_bus = radeon_i2c_lookup(rdev, i2c_bus);
2483 			if (!radeon_connector->ddc_bus)
2484 				DRM_ERROR("LVDS: Failed to assign ddc bus! Check dmesg for i2c errors.\n");
2485 		}
2486 		drm_object_attach_property(&radeon_connector->base.base,
2487 					      dev->mode_config.scaling_mode_property,
2488 					      DRM_MODE_SCALE_FULLSCREEN);
2489 		subpixel_order = SubPixelHorizontalRGB;
2490 		connector->interlace_allowed = false;
2491 		connector->doublescan_allowed = false;
2492 		break;
2493 	}
2494 
2495 	if (radeon_connector->hpd.hpd == RADEON_HPD_NONE) {
2496 		if (i2c_bus->valid) {
2497 			connector->polled = DRM_CONNECTOR_POLL_CONNECT |
2498 			                    DRM_CONNECTOR_POLL_DISCONNECT;
2499 		}
2500 	} else
2501 		connector->polled = DRM_CONNECTOR_POLL_HPD;
2502 
2503 	connector->display_info.subpixel_order = subpixel_order;
2504 	drm_connector_register(connector);
2505 }
2506 
2507 void radeon_setup_mst_connector(struct drm_device *dev)
2508 {
2509 	struct radeon_device *rdev = dev->dev_private;
2510 	struct drm_connector *connector;
2511 	struct radeon_connector *radeon_connector;
2512 
2513 	if (!ASIC_IS_DCE5(rdev))
2514 		return;
2515 
2516 	if (radeon_mst == 0)
2517 		return;
2518 
2519 	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
2520 		int ret;
2521 
2522 		radeon_connector = to_radeon_connector(connector);
2523 
2524 		if (connector->connector_type != DRM_MODE_CONNECTOR_DisplayPort)
2525 			continue;
2526 
2527 		ret = radeon_dp_mst_init(radeon_connector);
2528 	}
2529 }
2530