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