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