]> bbs.cooldavid.org Git - net-next-2.6.git/blame - drivers/gpu/drm/radeon/radeon_connectors.c
git://bbs.cooldavid.org / net-next-2.6.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
drm/radeon/kms/atom: fix tv-out
[net-next-2.6.git] / drivers / gpu / drm / radeon / radeon_connectors.c
CommitLineData
771fe6b9
JG		 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"
d50ba256 29#include "drm_fb_helper.h"
771fe6b9
JG		 30#include "radeon_drm.h"
31#include "radeon.h"
923f6848 32#include "atom.h"
771fe6b9
JG		 33
34extern void
35radeon_combios_connected_scratch_regs(struct drm_connector *connector,
36 struct drm_encoder *encoder,
37 bool connected);
38extern void
39radeon_atombios_connected_scratch_regs(struct drm_connector *connector,
40 struct drm_encoder *encoder,
41 bool connected);
42
445282db
DA		 43static void radeon_property_change_mode(struct drm_encoder *encoder)
44{
45 struct drm_crtc *crtc = encoder->crtc;
46
47 if (crtc && crtc->enabled) {
48 drm_crtc_helper_set_mode(crtc, &crtc->mode,
49 crtc->x, crtc->y, crtc->fb);
50 }
51}
771fe6b9
JG		 52static void
53radeon_connector_update_scratch_regs(struct drm_connector *connector, enum drm_connector_status status)
54{
55 struct drm_device *dev = connector->dev;
56 struct radeon_device *rdev = dev->dev_private;
57 struct drm_encoder *best_encoder = NULL;
58 struct drm_encoder *encoder = NULL;
59 struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
60 struct drm_mode_object *obj;
61 bool connected;
62 int i;
63
64 best_encoder = connector_funcs->best_encoder(connector);
65
66 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
67 if (connector->encoder_ids[i] == 0)
68 break;
69
70 obj = drm_mode_object_find(connector->dev,
71 connector->encoder_ids[i],
72 DRM_MODE_OBJECT_ENCODER);
73 if (!obj)
74 continue;
75
76 encoder = obj_to_encoder(obj);
77
78 if ((encoder == best_encoder) && (status == connector_status_connected))
79 connected = true;
80 else
81 connected = false;
82
83 if (rdev->is_atom_bios)
84 radeon_atombios_connected_scratch_regs(connector, encoder, connected);
85 else
86 radeon_combios_connected_scratch_regs(connector, encoder, connected);
87
88 }
89}
90
445282db
DA		 91struct drm_encoder *radeon_find_encoder(struct drm_connector *connector, int encoder_type)
92{
93 struct drm_mode_object *obj;
94 struct drm_encoder *encoder;
95 int i;
96
97 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
98 if (connector->encoder_ids[i] == 0)
99 break;
100
101 obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
102 if (!obj)
103 continue;
104
105 encoder = obj_to_encoder(obj);
106 if (encoder->encoder_type == encoder_type)
107 return encoder;
108 }
109 return NULL;
110}
111
771fe6b9
JG		 112struct drm_encoder *radeon_best_single_encoder(struct drm_connector *connector)
113{
114 int enc_id = connector->encoder_ids[0];
115 struct drm_mode_object *obj;
116 struct drm_encoder *encoder;
117
118 /* pick the encoder ids */
119 if (enc_id) {
120 obj = drm_mode_object_find(connector->dev, enc_id, DRM_MODE_OBJECT_ENCODER);
121 if (!obj)
122 return NULL;
123 encoder = obj_to_encoder(obj);
124 return encoder;
125 }
126 return NULL;
127}
128
4ce001ab
DA		 129/*
130 * radeon_connector_analog_encoder_conflict_solve
131 * - search for other connectors sharing this encoder
132 * if priority is true, then set them disconnected if this is connected
133 * if priority is false, set us disconnected if they are connected
134 */
135static enum drm_connector_status
136radeon_connector_analog_encoder_conflict_solve(struct drm_connector *connector,
137 struct drm_encoder *encoder,
138 enum drm_connector_status current_status,
139 bool priority)
140{
141 struct drm_device *dev = connector->dev;
142 struct drm_connector *conflict;
143 int i;
144
145 list_for_each_entry(conflict, &dev->mode_config.connector_list, head) {
146 if (conflict == connector)
147 continue;
148
149 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
150 if (conflict->encoder_ids[i] == 0)
151 break;
152
153 /* if the IDs match */
154 if (conflict->encoder_ids[i] == encoder->base.id) {
155 if (conflict->status != connector_status_connected)
156 continue;
157
158 if (priority == true) {
159 DRM_INFO("1: conflicting encoders switching off %s\n", drm_get_connector_name(conflict));
160 DRM_INFO("in favor of %s\n", drm_get_connector_name(connector));
161 conflict->status = connector_status_disconnected;
162 radeon_connector_update_scratch_regs(conflict, connector_status_disconnected);
163 } else {
164 DRM_INFO("2: conflicting encoders switching off %s\n", drm_get_connector_name(connector));
165 DRM_INFO("in favor of %s\n", drm_get_connector_name(conflict));
166 current_status = connector_status_disconnected;
167 }
168 break;
169 }
170 }
171 }
172 return current_status;
173
174}
175
771fe6b9
JG		 176static struct drm_display_mode *radeon_fp_native_mode(struct drm_encoder *encoder)
177{
178 struct drm_device *dev = encoder->dev;
179 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
180 struct drm_display_mode *mode = NULL;
de2103e4 181 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
771fe6b9 182
de2103e4
AD		 183 if (native_mode->hdisplay != 0 &&
184 native_mode->vdisplay != 0 &&
185 native_mode->clock != 0) {
fb06ca8f 186 mode = drm_mode_duplicate(dev, native_mode);
771fe6b9
JG		 187 mode->type = DRM_MODE_TYPE_PREFERRED | DRM_MODE_TYPE_DRIVER;
188 drm_mode_set_name(mode);
189
190 DRM_DEBUG("Adding native panel mode %s\n", mode->name);
191 }
192 return mode;
193}
194
923f6848
AD		 195static void radeon_add_common_modes(struct drm_encoder *encoder, struct drm_connector *connector)
196{
197 struct drm_device *dev = encoder->dev;
198 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
199 struct drm_display_mode *mode = NULL;
de2103e4 200 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
923f6848
AD		 201 int i;
202 struct mode_size {
203 int w;
204 int h;
205 } common_modes[17] = {
206 { 640, 480},
207 { 720, 480},
208 { 800, 600},
209 { 848, 480},
210 {1024, 768},
211 {1152, 768},
212 {1280, 720},
213 {1280, 800},
214 {1280, 854},
215 {1280, 960},
216 {1280, 1024},
217 {1440, 900},
218 {1400, 1050},
219 {1680, 1050},
220 {1600, 1200},
221 {1920, 1080},
222 {1920, 1200}
223 };
224
225 for (i = 0; i < 17; i++) {
226 if (radeon_encoder->devices & (ATOM_DEVICE_LCD_SUPPORT)) {
de2103e4
AD		 227 if (common_modes[i].w > native_mode->hdisplay ||
228 common_modes[i].h > native_mode->vdisplay ||
229 (common_modes[i].w == native_mode->hdisplay &&
230 common_modes[i].h == native_mode->vdisplay))
923f6848
AD		 231 continue;
232 }
233 if (common_modes[i].w < 320 || common_modes[i].h < 200)
234 continue;
235
d50ba256 236 mode = drm_cvt_mode(dev, common_modes[i].w, common_modes[i].h, 60, false, false, false);
923f6848
AD		 237 drm_mode_probed_add(connector, mode);
238 }
239}
240
771fe6b9
JG		 241int radeon_connector_set_property(struct drm_connector *connector, struct drm_property *property,
242 uint64_t val)
243{
445282db
DA		 244 struct drm_device *dev = connector->dev;
245 struct radeon_device *rdev = dev->dev_private;
246 struct drm_encoder *encoder;
247 struct radeon_encoder *radeon_encoder;
248
249 if (property == rdev->mode_info.coherent_mode_property) {
250 struct radeon_encoder_atom_dig *dig;
251
252 /* need to find digital encoder on connector */
253 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
254 if (!encoder)
255 return 0;
256
257 radeon_encoder = to_radeon_encoder(encoder);
258
259 if (!radeon_encoder->enc_priv)
260 return 0;
261
262 dig = radeon_encoder->enc_priv;
263 dig->coherent_mode = val ? true : false;
264 radeon_property_change_mode(&radeon_encoder->base);
265 }
266
267 if (property == rdev->mode_info.tv_std_property) {
268 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TVDAC);
269 if (!encoder) {
270 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_DAC);
271 }
272
273 if (!encoder)
274 return 0;
275
276 radeon_encoder = to_radeon_encoder(encoder);
277 if (!radeon_encoder->enc_priv)
278 return 0;
279 if (rdev->is_atom_bios) {
280 struct radeon_encoder_atom_dac *dac_int;
281 dac_int = radeon_encoder->enc_priv;
282 dac_int->tv_std = val;
283 } else {
284 struct radeon_encoder_tv_dac *dac_int;
285 dac_int = radeon_encoder->enc_priv;
286 dac_int->tv_std = val;
287 }
288 radeon_property_change_mode(&radeon_encoder->base);
289 }
290
291 if (property == rdev->mode_info.load_detect_property) {
292 struct radeon_connector *radeon_connector =
293 to_radeon_connector(connector);
294
295 if (val == 0)
296 radeon_connector->dac_load_detect = false;
297 else
298 radeon_connector->dac_load_detect = true;
299 }
300
301 if (property == rdev->mode_info.tmds_pll_property) {
302 struct radeon_encoder_int_tmds *tmds = NULL;
303 bool ret = false;
304 /* need to find digital encoder on connector */
305 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
306 if (!encoder)
307 return 0;
308
309 radeon_encoder = to_radeon_encoder(encoder);
310
311 tmds = radeon_encoder->enc_priv;
312 if (!tmds)
313 return 0;
314
315 if (val == 0) {
316 if (rdev->is_atom_bios)
317 ret = radeon_atombios_get_tmds_info(radeon_encoder, tmds);
318 else
319 ret = radeon_legacy_get_tmds_info_from_combios(radeon_encoder, tmds);
320 }
321 if (val == 1 || ret == false) {
322 radeon_legacy_get_tmds_info_from_table(radeon_encoder, tmds);
323 }
324 radeon_property_change_mode(&radeon_encoder->base);
325 }
326
771fe6b9
JG		 327 return 0;
328}
329
8dfaa8a7
MD		 330static void radeon_fixup_lvds_native_mode(struct drm_encoder *encoder,
331 struct drm_connector *connector)
332{
333 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
de2103e4 334 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
8dfaa8a7
MD		 335
336 /* Try to get native mode details from EDID if necessary */
de2103e4 337 if (!native_mode->clock) {
8dfaa8a7
MD		 338 struct drm_display_mode *t, *mode;
339
340 list_for_each_entry_safe(mode, t, &connector->probed_modes, head) {
de2103e4
AD		 341 if (mode->hdisplay == native_mode->hdisplay &&
342 mode->vdisplay == native_mode->vdisplay) {
343 *native_mode = *mode;
344 drm_mode_set_crtcinfo(native_mode, CRTC_INTERLACE_HALVE_V);
8dfaa8a7
MD		 345 DRM_INFO("Determined LVDS native mode details from EDID\n");
346 break;
347 }
348 }
349 }
de2103e4 350 if (!native_mode->clock) {
8dfaa8a7
MD		 351 DRM_INFO("No LVDS native mode details, disabling RMX\n");
352 radeon_encoder->rmx_type = RMX_OFF;
353 }
354}
771fe6b9
JG		 355
356static int radeon_lvds_get_modes(struct drm_connector *connector)
357{
358 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
359 struct drm_encoder *encoder;
360 int ret = 0;
361 struct drm_display_mode *mode;
362
363 if (radeon_connector->ddc_bus) {
364 ret = radeon_ddc_get_modes(radeon_connector);
365 if (ret > 0) {
7747b713 366 encoder = radeon_best_single_encoder(connector);
8dfaa8a7
MD		 367 if (encoder) {
368 radeon_fixup_lvds_native_mode(encoder, connector);
7747b713
AD		 369 /* add scaled modes */
370 radeon_add_common_modes(encoder, connector);
8dfaa8a7 371 }
771fe6b9
JG		 372 return ret;
373 }
374 }
375
376 encoder = radeon_best_single_encoder(connector);
377 if (!encoder)
378 return 0;
379
380 /* we have no EDID modes */
381 mode = radeon_fp_native_mode(encoder);
382 if (mode) {
383 ret = 1;
384 drm_mode_probed_add(connector, mode);
7747b713
AD		 385 /* add scaled modes */
386 radeon_add_common_modes(encoder, connector);
771fe6b9 387 }
923f6848 388
771fe6b9
JG		 389 return ret;
390}
391
392static int radeon_lvds_mode_valid(struct drm_connector *connector,
393 struct drm_display_mode *mode)
394{
395 return MODE_OK;
396}
397
398static enum drm_connector_status radeon_lvds_detect(struct drm_connector *connector)
399{
0549a061 400 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
2ffb8429 401 struct drm_encoder *encoder = radeon_best_single_encoder(connector);
0549a061 402 enum drm_connector_status ret = connector_status_disconnected;
2ffb8429
AD		 403
404 if (encoder) {
405 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
de2103e4 406 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
2ffb8429
AD		 407
408 /* check if panel is valid */
de2103e4 409 if (native_mode->hdisplay >= 320 && native_mode->vdisplay >= 240)
2ffb8429
AD		 410 ret = connector_status_connected;
411
412 }
0549a061
AD		 413
414 /* check for edid as well */
0294cf4f
AD		 415 if (radeon_connector->edid)
416 ret = connector_status_connected;
417 else {
418 if (radeon_connector->ddc_bus) {
419 radeon_i2c_do_lock(radeon_connector, 1);
420 radeon_connector->edid = drm_get_edid(&radeon_connector->base,
421 &radeon_connector->ddc_bus->adapter);
422 radeon_i2c_do_lock(radeon_connector, 0);
423 if (radeon_connector->edid)
424 ret = connector_status_connected;
425 }
0549a061 426 }
771fe6b9 427 /* check acpi lid status ??? */
2ffb8429 428
771fe6b9
JG		 429 radeon_connector_update_scratch_regs(connector, ret);
430 return ret;
431}
432
433static void radeon_connector_destroy(struct drm_connector *connector)
434{
435 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
436
437 if (radeon_connector->ddc_bus)
438 radeon_i2c_destroy(radeon_connector->ddc_bus);
0294cf4f
AD		 439 if (radeon_connector->edid)
440 kfree(radeon_connector->edid);
771fe6b9
JG		 441 kfree(radeon_connector->con_priv);
442 drm_sysfs_connector_remove(connector);
443 drm_connector_cleanup(connector);
444 kfree(connector);
445}
446
445282db
DA		 447static int radeon_lvds_set_property(struct drm_connector *connector,
448 struct drm_property *property,
449 uint64_t value)
450{
451 struct drm_device *dev = connector->dev;
452 struct radeon_encoder *radeon_encoder;
453 enum radeon_rmx_type rmx_type;
454
455 DRM_DEBUG("\n");
456 if (property != dev->mode_config.scaling_mode_property)
457 return 0;
458
459 if (connector->encoder)
460 radeon_encoder = to_radeon_encoder(connector->encoder);
461 else {
462 struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
463 radeon_encoder = to_radeon_encoder(connector_funcs->best_encoder(connector));
464 }
465
466 switch (value) {
467 case DRM_MODE_SCALE_NONE: rmx_type = RMX_OFF; break;
468 case DRM_MODE_SCALE_CENTER: rmx_type = RMX_CENTER; break;
469 case DRM_MODE_SCALE_ASPECT: rmx_type = RMX_ASPECT; break;
470 default:
471 case DRM_MODE_SCALE_FULLSCREEN: rmx_type = RMX_FULL; break;
472 }
473 if (radeon_encoder->rmx_type == rmx_type)
474 return 0;
475
476 radeon_encoder->rmx_type = rmx_type;
477
478 radeon_property_change_mode(&radeon_encoder->base);
479 return 0;
480}
481
482
771fe6b9
JG		 483struct drm_connector_helper_funcs radeon_lvds_connector_helper_funcs = {
484 .get_modes = radeon_lvds_get_modes,
485 .mode_valid = radeon_lvds_mode_valid,
486 .best_encoder = radeon_best_single_encoder,
487};
488
489struct drm_connector_funcs radeon_lvds_connector_funcs = {
490 .dpms = drm_helper_connector_dpms,
491 .detect = radeon_lvds_detect,
492 .fill_modes = drm_helper_probe_single_connector_modes,
493 .destroy = radeon_connector_destroy,
445282db 494 .set_property = radeon_lvds_set_property,
771fe6b9
JG		 495};
496
497static int radeon_vga_get_modes(struct drm_connector *connector)
498{
499 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
500 int ret;
501
502 ret = radeon_ddc_get_modes(radeon_connector);
503
504 return ret;
505}
506
507static int radeon_vga_mode_valid(struct drm_connector *connector,
508 struct drm_display_mode *mode)
509{
771fe6b9
JG		 510 return MODE_OK;
511}
512
513static enum drm_connector_status radeon_vga_detect(struct drm_connector *connector)
514{
515 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
516 struct drm_encoder *encoder;
517 struct drm_encoder_helper_funcs *encoder_funcs;
518 bool dret;
519 enum drm_connector_status ret = connector_status_disconnected;
520
4ce001ab
DA		 521 encoder = radeon_best_single_encoder(connector);
522 if (!encoder)
523 ret = connector_status_disconnected;
524
771fe6b9
JG		 525 radeon_i2c_do_lock(radeon_connector, 1);
526 dret = radeon_ddc_probe(radeon_connector);
527 radeon_i2c_do_lock(radeon_connector, 0);
0294cf4f
AD		 528 if (dret) {
529 if (radeon_connector->edid) {
530 kfree(radeon_connector->edid);
531 radeon_connector->edid = NULL;
532 }
533 radeon_i2c_do_lock(radeon_connector, 1);
534 radeon_connector->edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
535 radeon_i2c_do_lock(radeon_connector, 0);
536
537 if (!radeon_connector->edid) {
538 DRM_ERROR("DDC responded but not EDID found for %s\n",
539 drm_get_connector_name(connector));
540 } else {
541 radeon_connector->use_digital = !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
542
543 /* some oems have boards with separate digital and analog connectors
544 * with a shared ddc line (often vga + hdmi)
545 */
546 if (radeon_connector->use_digital && radeon_connector->shared_ddc) {
547 kfree(radeon_connector->edid);
548 radeon_connector->edid = NULL;
549 ret = connector_status_disconnected;
550 } else
551 ret = connector_status_connected;
552 }
553 } else {
445282db
DA		 554 if (radeon_connector->dac_load_detect) {
555 encoder_funcs = encoder->helper_private;
556 ret = encoder_funcs->detect(encoder, connector);
557 }
771fe6b9
JG		 558 }
559
4ce001ab
DA		 560 if (ret == connector_status_connected)
561 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
771fe6b9
JG		 562 radeon_connector_update_scratch_regs(connector, ret);
563 return ret;
564}
565
566struct drm_connector_helper_funcs radeon_vga_connector_helper_funcs = {
567 .get_modes = radeon_vga_get_modes,
568 .mode_valid = radeon_vga_mode_valid,
569 .best_encoder = radeon_best_single_encoder,
570};
571
572struct drm_connector_funcs radeon_vga_connector_funcs = {
573 .dpms = drm_helper_connector_dpms,
574 .detect = radeon_vga_detect,
575 .fill_modes = drm_helper_probe_single_connector_modes,
576 .destroy = radeon_connector_destroy,
577 .set_property = radeon_connector_set_property,
578};
579
4ce001ab
DA		 580static int radeon_tv_get_modes(struct drm_connector *connector)
581{
582 struct drm_device *dev = connector->dev;
923f6848 583 struct radeon_device *rdev = dev->dev_private;
4ce001ab 584 struct drm_display_mode *tv_mode;
923f6848 585 struct drm_encoder *encoder;
4ce001ab 586
923f6848
AD		 587 encoder = radeon_best_single_encoder(connector);
588 if (!encoder)
589 return 0;
4ce001ab 590
923f6848
AD		 591 /* avivo chips can scale any mode */
592 if (rdev->family >= CHIP_RS600)
593 /* add scaled modes */
594 radeon_add_common_modes(encoder, connector);
595 else {
596 /* only 800x600 is supported right now on pre-avivo chips */
d50ba256 597 tv_mode = drm_cvt_mode(dev, 800, 600, 60, false, false, false);
923f6848
AD		 598 tv_mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
599 drm_mode_probed_add(connector, tv_mode);
600 }
4ce001ab
DA		 601 return 1;
602}
603
604static int radeon_tv_mode_valid(struct drm_connector *connector,
605 struct drm_display_mode *mode)
606{
607 return MODE_OK;
608}
609
610static enum drm_connector_status radeon_tv_detect(struct drm_connector *connector)
611{
612 struct drm_encoder *encoder;
613 struct drm_encoder_helper_funcs *encoder_funcs;
445282db
DA		 614 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
615 enum drm_connector_status ret = connector_status_disconnected;
616
617 if (!radeon_connector->dac_load_detect)
618 return ret;
4ce001ab
DA		 619
620 encoder = radeon_best_single_encoder(connector);
621 if (!encoder)
622 ret = connector_status_disconnected;
623 else {
624 encoder_funcs = encoder->helper_private;
625 ret = encoder_funcs->detect(encoder, connector);
626 }
627 if (ret == connector_status_connected)
628 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, false);
629 radeon_connector_update_scratch_regs(connector, ret);
630 return ret;
631}
632
633struct drm_connector_helper_funcs radeon_tv_connector_helper_funcs = {
634 .get_modes = radeon_tv_get_modes,
635 .mode_valid = radeon_tv_mode_valid,
636 .best_encoder = radeon_best_single_encoder,
637};
638
639struct drm_connector_funcs radeon_tv_connector_funcs = {
640 .dpms = drm_helper_connector_dpms,
641 .detect = radeon_tv_detect,
642 .fill_modes = drm_helper_probe_single_connector_modes,
643 .destroy = radeon_connector_destroy,
644 .set_property = radeon_connector_set_property,
645};
646
771fe6b9
JG		 647static int radeon_dvi_get_modes(struct drm_connector *connector)
648{
649 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
650 int ret;
651
652 ret = radeon_ddc_get_modes(radeon_connector);
771fe6b9
JG		 653 return ret;
654}
655
4ce001ab
DA		 656/*
657 * DVI is complicated
658 * Do a DDC probe, if DDC probe passes, get the full EDID so
659 * we can do analog/digital monitor detection at this point.
660 * If the monitor is an analog monitor or we got no DDC,
661 * we need to find the DAC encoder object for this connector.
662 * If we got no DDC, we do load detection on the DAC encoder object.
663 * If we got analog DDC or load detection passes on the DAC encoder
664 * we have to check if this analog encoder is shared with anyone else (TV)
665 * if its shared we have to set the other connector to disconnected.
666 */
771fe6b9
JG		 667static enum drm_connector_status radeon_dvi_detect(struct drm_connector *connector)
668{
669 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
4ce001ab 670 struct drm_encoder *encoder = NULL;
771fe6b9
JG		 671 struct drm_encoder_helper_funcs *encoder_funcs;
672 struct drm_mode_object *obj;
673 int i;
674 enum drm_connector_status ret = connector_status_disconnected;
675 bool dret;
676
677 radeon_i2c_do_lock(radeon_connector, 1);
678 dret = radeon_ddc_probe(radeon_connector);
679 radeon_i2c_do_lock(radeon_connector, 0);
4ce001ab 680 if (dret) {
0294cf4f
AD		 681 if (radeon_connector->edid) {
682 kfree(radeon_connector->edid);
683 radeon_connector->edid = NULL;
684 }
4ce001ab
DA		 685 radeon_i2c_do_lock(radeon_connector, 1);
686 radeon_connector->edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
687 radeon_i2c_do_lock(radeon_connector, 0);
688
689 if (!radeon_connector->edid) {
690 DRM_ERROR("DDC responded but not EDID found for %s\n",
691 drm_get_connector_name(connector));
692 } else {
693 radeon_connector->use_digital = !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
694
0294cf4f
AD		 695 /* some oems have boards with separate digital and analog connectors
696 * with a shared ddc line (often vga + hdmi)
697 */
698 if ((!radeon_connector->use_digital) && radeon_connector->shared_ddc) {
699 kfree(radeon_connector->edid);
700 radeon_connector->edid = NULL;
701 ret = connector_status_disconnected;
702 } else
703 ret = connector_status_connected;
4ce001ab
DA		 704 }
705 }
706
707 if ((ret == connector_status_connected) && (radeon_connector->use_digital == true))
708 goto out;
709
710 /* find analog encoder */
445282db
DA		 711 if (radeon_connector->dac_load_detect) {
712 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
713 if (connector->encoder_ids[i] == 0)
714 break;
771fe6b9 715
445282db
DA		 716 obj = drm_mode_object_find(connector->dev,
717 connector->encoder_ids[i],
718 DRM_MODE_OBJECT_ENCODER);
719 if (!obj)
720 continue;
771fe6b9 721
445282db 722 encoder = obj_to_encoder(obj);
771fe6b9 723
445282db
DA		 724 encoder_funcs = encoder->helper_private;
725 if (encoder_funcs->detect) {
726 if (ret != connector_status_connected) {
727 ret = encoder_funcs->detect(encoder, connector);
728 if (ret == connector_status_connected) {
729 radeon_connector->use_digital = false;
730 }
771fe6b9 731 }
445282db 732 break;
771fe6b9
JG		 733 }
734 }
735 }
736
4ce001ab
DA		 737 if ((ret == connector_status_connected) && (radeon_connector->use_digital == false) &&
738 encoder) {
739 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
740 }
741
742out:
771fe6b9
JG		 743 /* updated in get modes as well since we need to know if it's analog or digital */
744 radeon_connector_update_scratch_regs(connector, ret);
745 return ret;
746}
747
748/* okay need to be smart in here about which encoder to pick */
749struct drm_encoder *radeon_dvi_encoder(struct drm_connector *connector)
750{
751 int enc_id = connector->encoder_ids[0];
752 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
753 struct drm_mode_object *obj;
754 struct drm_encoder *encoder;
755 int i;
756 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
757 if (connector->encoder_ids[i] == 0)
758 break;
759
760 obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
761 if (!obj)
762 continue;
763
764 encoder = obj_to_encoder(obj);
765
4ce001ab 766 if (radeon_connector->use_digital == true) {
771fe6b9
JG		 767 if (encoder->encoder_type == DRM_MODE_ENCODER_TMDS)
768 return encoder;
769 } else {
770 if (encoder->encoder_type == DRM_MODE_ENCODER_DAC ||
771 encoder->encoder_type == DRM_MODE_ENCODER_TVDAC)
772 return encoder;
773 }
774 }
775
776 /* see if we have a default encoder TODO */
777
778 /* then check use digitial */
779 /* pick the first one */
780 if (enc_id) {
781 obj = drm_mode_object_find(connector->dev, enc_id, DRM_MODE_OBJECT_ENCODER);
782 if (!obj)
783 return NULL;
784 encoder = obj_to_encoder(obj);
785 return encoder;
786 }
787 return NULL;
788}
789
d50ba256
DA		 790static void radeon_dvi_force(struct drm_connector *connector)
791{
792 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
793 if (connector->force == DRM_FORCE_ON)
794 radeon_connector->use_digital = false;
795 if (connector->force == DRM_FORCE_ON_DIGITAL)
796 radeon_connector->use_digital = true;
797}
798
771fe6b9
JG		 799struct drm_connector_helper_funcs radeon_dvi_connector_helper_funcs = {
800 .get_modes = radeon_dvi_get_modes,
801 .mode_valid = radeon_vga_mode_valid,
802 .best_encoder = radeon_dvi_encoder,
803};
804
805struct drm_connector_funcs radeon_dvi_connector_funcs = {
806 .dpms = drm_helper_connector_dpms,
807 .detect = radeon_dvi_detect,
808 .fill_modes = drm_helper_probe_single_connector_modes,
809 .set_property = radeon_connector_set_property,
810 .destroy = radeon_connector_destroy,
d50ba256 811 .force = radeon_dvi_force,
771fe6b9
JG		 812};
813
814void
815radeon_add_atom_connector(struct drm_device *dev,
816 uint32_t connector_id,
817 uint32_t supported_device,
818 int connector_type,
819 struct radeon_i2c_bus_rec *i2c_bus,
820 bool linkb,
821 uint32_t igp_lane_info)
822{
445282db 823 struct radeon_device *rdev = dev->dev_private;
771fe6b9
JG		 824 struct drm_connector *connector;
825 struct radeon_connector *radeon_connector;
826 struct radeon_connector_atom_dig *radeon_dig_connector;
827 uint32_t subpixel_order = SubPixelNone;
0294cf4f 828 bool shared_ddc = false;
d50ba256 829 int ret;
771fe6b9
JG		 830
831 /* fixme - tv/cv/din */
4ce001ab 832 if (connector_type == DRM_MODE_CONNECTOR_Unknown)
771fe6b9
JG		 833 return;
834
835 /* see if we already added it */
836 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
837 radeon_connector = to_radeon_connector(connector);
838 if (radeon_connector->connector_id == connector_id) {
839 radeon_connector->devices |= supported_device;
840 return;
841 }
0294cf4f
AD		 842 if (radeon_connector->ddc_bus && i2c_bus->valid) {
843 if (memcmp(&radeon_connector->ddc_bus->rec, i2c_bus,
844 sizeof(struct radeon_i2c_bus_rec)) == 0) {
845 radeon_connector->shared_ddc = true;
846 shared_ddc = true;
847 }
848 }
771fe6b9
JG		 849 }
850
851 radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
852 if (!radeon_connector)
853 return;
854
855 connector = &radeon_connector->base;
856
857 radeon_connector->connector_id = connector_id;
858 radeon_connector->devices = supported_device;
0294cf4f 859 radeon_connector->shared_ddc = shared_ddc;
771fe6b9
JG		 860 switch (connector_type) {
861 case DRM_MODE_CONNECTOR_VGA:
862 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
74bf2ad5
DA		 863 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
864 if (ret)
865 goto failed;
771fe6b9
JG		 866 if (i2c_bus->valid) {
867 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "VGA");
868 if (!radeon_connector->ddc_bus)
869 goto failed;
870 }
35e4b7af 871 radeon_connector->dac_load_detect = true;
445282db
DA		 872 drm_connector_attach_property(&radeon_connector->base,
873 rdev->mode_info.load_detect_property,
874 1);
771fe6b9
JG		 875 break;
876 case DRM_MODE_CONNECTOR_DVIA:
877 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
74bf2ad5
DA		 878 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
879 if (ret)
880 goto failed;
771fe6b9
JG		 881 if (i2c_bus->valid) {
882 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
883 if (!radeon_connector->ddc_bus)
884 goto failed;
885 }
35e4b7af 886 radeon_connector->dac_load_detect = true;
445282db
DA		 887 drm_connector_attach_property(&radeon_connector->base,
888 rdev->mode_info.load_detect_property,
889 1);
771fe6b9
JG		 890 break;
891 case DRM_MODE_CONNECTOR_DVII:
892 case DRM_MODE_CONNECTOR_DVID:
893 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
894 if (!radeon_dig_connector)
895 goto failed;
896 radeon_dig_connector->linkb = linkb;
897 radeon_dig_connector->igp_lane_info = igp_lane_info;
898 radeon_connector->con_priv = radeon_dig_connector;
899 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
74bf2ad5
DA		 900 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
901 if (ret)
902 goto failed;
771fe6b9
JG		 903 if (i2c_bus->valid) {
904 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
905 if (!radeon_connector->ddc_bus)
906 goto failed;
907 }
908 subpixel_order = SubPixelHorizontalRGB;
445282db
DA		 909 drm_connector_attach_property(&radeon_connector->base,
910 rdev->mode_info.coherent_mode_property,
911 1);
35e4b7af 912 radeon_connector->dac_load_detect = true;
445282db
DA		 913 drm_connector_attach_property(&radeon_connector->base,
914 rdev->mode_info.load_detect_property,
915 1);
771fe6b9
JG		 916 break;
917 case DRM_MODE_CONNECTOR_HDMIA:
918 case DRM_MODE_CONNECTOR_HDMIB:
919 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
920 if (!radeon_dig_connector)
921 goto failed;
922 radeon_dig_connector->linkb = linkb;
923 radeon_dig_connector->igp_lane_info = igp_lane_info;
924 radeon_connector->con_priv = radeon_dig_connector;
925 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
74bf2ad5
DA		 926 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
927 if (ret)
928 goto failed;
771fe6b9
JG		 929 if (i2c_bus->valid) {
930 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "HDMI");
931 if (!radeon_connector->ddc_bus)
932 goto failed;
933 }
445282db
DA		 934 drm_connector_attach_property(&radeon_connector->base,
935 rdev->mode_info.coherent_mode_property,
936 1);
771fe6b9
JG		 937 subpixel_order = SubPixelHorizontalRGB;
938 break;
939 case DRM_MODE_CONNECTOR_DisplayPort:
940 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
941 if (!radeon_dig_connector)
942 goto failed;
943 radeon_dig_connector->linkb = linkb;
944 radeon_dig_connector->igp_lane_info = igp_lane_info;
945 radeon_connector->con_priv = radeon_dig_connector;
946 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
74bf2ad5
DA		 947 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
948 if (ret)
949 goto failed;
771fe6b9
JG		 950 if (i2c_bus->valid) {
951 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DP");
952 if (!radeon_connector->ddc_bus)
953 goto failed;
954 }
955 subpixel_order = SubPixelHorizontalRGB;
956 break;
957 case DRM_MODE_CONNECTOR_SVIDEO:
958 case DRM_MODE_CONNECTOR_Composite:
959 case DRM_MODE_CONNECTOR_9PinDIN:
4ce001ab
DA		 960 if (radeon_tv == 1) {
961 drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
74bf2ad5
DA		 962 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
963 if (ret)
964 goto failed;
965 radeon_connector->dac_load_detect = true;
966 drm_connector_attach_property(&radeon_connector->base,
967 rdev->mode_info.load_detect_property,
968 1);
4ce001ab 969 }
771fe6b9
JG		 970 break;
971 case DRM_MODE_CONNECTOR_LVDS:
972 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
973 if (!radeon_dig_connector)
974 goto failed;
975 radeon_dig_connector->linkb = linkb;
976 radeon_dig_connector->igp_lane_info = igp_lane_info;
977 radeon_connector->con_priv = radeon_dig_connector;
978 drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
74bf2ad5
DA		 979 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
980 if (ret)
981 goto failed;
771fe6b9
JG		 982 if (i2c_bus->valid) {
983 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "LVDS");
984 if (!radeon_connector->ddc_bus)
985 goto failed;
986 }
445282db
DA		 987 drm_mode_create_scaling_mode_property(dev);
988 drm_connector_attach_property(&radeon_connector->base,
989 dev->mode_config.scaling_mode_property,
990 DRM_MODE_SCALE_FULLSCREEN);
771fe6b9
JG		 991 subpixel_order = SubPixelHorizontalRGB;
992 break;
993 }
994
995 connector->display_info.subpixel_order = subpixel_order;
996 drm_sysfs_connector_add(connector);
997 return;
998
999failed:
1000 if (radeon_connector->ddc_bus)
1001 radeon_i2c_destroy(radeon_connector->ddc_bus);
1002 drm_connector_cleanup(connector);
1003 kfree(connector);
1004}
1005
1006void
1007radeon_add_legacy_connector(struct drm_device *dev,
1008 uint32_t connector_id,
1009 uint32_t supported_device,
1010 int connector_type,
1011 struct radeon_i2c_bus_rec *i2c_bus)
1012{
445282db 1013 struct radeon_device *rdev = dev->dev_private;
771fe6b9
JG		 1014 struct drm_connector *connector;
1015 struct radeon_connector *radeon_connector;
1016 uint32_t subpixel_order = SubPixelNone;
d50ba256 1017 int ret;
771fe6b9
JG		 1018
1019 /* fixme - tv/cv/din */
4ce001ab 1020 if (connector_type == DRM_MODE_CONNECTOR_Unknown)
771fe6b9
JG		 1021 return;
1022
1023 /* see if we already added it */
1024 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
1025 radeon_connector = to_radeon_connector(connector);
1026 if (radeon_connector->connector_id == connector_id) {
1027 radeon_connector->devices |= supported_device;
1028 return;
1029 }
1030 }
1031
1032 radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
1033 if (!radeon_connector)
1034 return;
1035
1036 connector = &radeon_connector->base;
1037
1038 radeon_connector->connector_id = connector_id;
1039 radeon_connector->devices = supported_device;
1040 switch (connector_type) {
1041 case DRM_MODE_CONNECTOR_VGA:
1042 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
74bf2ad5
DA		 1043 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1044 if (ret)
1045 goto failed;
771fe6b9
JG		 1046 if (i2c_bus->valid) {
1047 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "VGA");
1048 if (!radeon_connector->ddc_bus)
1049 goto failed;
1050 }
35e4b7af 1051 radeon_connector->dac_load_detect = true;
445282db
DA		 1052 drm_connector_attach_property(&radeon_connector->base,
1053 rdev->mode_info.load_detect_property,
1054 1);
771fe6b9
JG		 1055 break;
1056 case DRM_MODE_CONNECTOR_DVIA:
1057 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
74bf2ad5
DA		 1058 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1059 if (ret)
1060 goto failed;
771fe6b9
JG		 1061 if (i2c_bus->valid) {
1062 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
1063 if (!radeon_connector->ddc_bus)
1064 goto failed;
1065 }
35e4b7af 1066 radeon_connector->dac_load_detect = true;
445282db
DA		 1067 drm_connector_attach_property(&radeon_connector->base,
1068 rdev->mode_info.load_detect_property,
1069 1);
771fe6b9
JG		 1070 break;
1071 case DRM_MODE_CONNECTOR_DVII:
1072 case DRM_MODE_CONNECTOR_DVID:
1073 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
74bf2ad5
DA		 1074 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
1075 if (ret)
1076 goto failed;
771fe6b9
JG		 1077 if (i2c_bus->valid) {
1078 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
1079 if (!radeon_connector->ddc_bus)
1080 goto failed;
35e4b7af 1081 radeon_connector->dac_load_detect = true;
445282db
DA		 1082 drm_connector_attach_property(&radeon_connector->base,
1083 rdev->mode_info.load_detect_property,
1084 1);
771fe6b9
JG		 1085 }
1086 subpixel_order = SubPixelHorizontalRGB;
1087 break;
1088 case DRM_MODE_CONNECTOR_SVIDEO:
1089 case DRM_MODE_CONNECTOR_Composite:
1090 case DRM_MODE_CONNECTOR_9PinDIN:
4ce001ab
DA		 1091 if (radeon_tv == 1) {
1092 drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
74bf2ad5
DA		 1093 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
1094 if (ret)
1095 goto failed;
35e4b7af 1096 radeon_connector->dac_load_detect = true;
445282db
DA		 1097 drm_connector_attach_property(&radeon_connector->base,
1098 rdev->mode_info.load_detect_property,
1099 1);
4ce001ab 1100 }
771fe6b9
JG		 1101 break;
1102 case DRM_MODE_CONNECTOR_LVDS:
1103 drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
74bf2ad5
DA		 1104 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
1105 if (ret)
1106 goto failed;
771fe6b9
JG		 1107 if (i2c_bus->valid) {
1108 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "LVDS");
1109 if (!radeon_connector->ddc_bus)
1110 goto failed;
1111 }
445282db
DA		 1112 drm_connector_attach_property(&radeon_connector->base,
1113 dev->mode_config.scaling_mode_property,
1114 DRM_MODE_SCALE_FULLSCREEN);
771fe6b9
JG		 1115 subpixel_order = SubPixelHorizontalRGB;
1116 break;
1117 }
1118
1119 connector->display_info.subpixel_order = subpixel_order;
1120 drm_sysfs_connector_add(connector);
1121 return;
1122
1123failed:
1124 if (radeon_connector->ddc_bus)
1125 radeon_i2c_destroy(radeon_connector->ddc_bus);
1126 drm_connector_cleanup(connector);
1127 kfree(connector);
1128}
Clone of davem's net-next-2.6 tree