]> 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: i2c reorg
[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++) {
dfdd6467
AD		 226 if (radeon_encoder->devices & (ATOM_DEVICE_TV_SUPPORT)) {
227 if (common_modes[i].w > 1024 ||
228 common_modes[i].h > 768)
229 continue;
230 }
923f6848 231 if (radeon_encoder->devices & (ATOM_DEVICE_LCD_SUPPORT)) {
de2103e4
AD		 232 if (common_modes[i].w > native_mode->hdisplay ||
233 common_modes[i].h > native_mode->vdisplay ||
234 (common_modes[i].w == native_mode->hdisplay &&
235 common_modes[i].h == native_mode->vdisplay))
923f6848
AD		 236 continue;
237 }
238 if (common_modes[i].w < 320 || common_modes[i].h < 200)
239 continue;
240
d50ba256 241 mode = drm_cvt_mode(dev, common_modes[i].w, common_modes[i].h, 60, false, false, false);
923f6848
AD		 242 drm_mode_probed_add(connector, mode);
243 }
244}
245
771fe6b9
JG		 246int radeon_connector_set_property(struct drm_connector *connector, struct drm_property *property,
247 uint64_t val)
248{
445282db
DA		 249 struct drm_device *dev = connector->dev;
250 struct radeon_device *rdev = dev->dev_private;
251 struct drm_encoder *encoder;
252 struct radeon_encoder *radeon_encoder;
253
254 if (property == rdev->mode_info.coherent_mode_property) {
255 struct radeon_encoder_atom_dig *dig;
256
257 /* need to find digital encoder on connector */
258 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
259 if (!encoder)
260 return 0;
261
262 radeon_encoder = to_radeon_encoder(encoder);
263
264 if (!radeon_encoder->enc_priv)
265 return 0;
266
267 dig = radeon_encoder->enc_priv;
268 dig->coherent_mode = val ? true : false;
269 radeon_property_change_mode(&radeon_encoder->base);
270 }
271
272 if (property == rdev->mode_info.tv_std_property) {
273 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TVDAC);
274 if (!encoder) {
275 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_DAC);
276 }
277
278 if (!encoder)
279 return 0;
280
281 radeon_encoder = to_radeon_encoder(encoder);
282 if (!radeon_encoder->enc_priv)
283 return 0;
284 if (rdev->is_atom_bios) {
285 struct radeon_encoder_atom_dac *dac_int;
286 dac_int = radeon_encoder->enc_priv;
287 dac_int->tv_std = val;
288 } else {
289 struct radeon_encoder_tv_dac *dac_int;
290 dac_int = radeon_encoder->enc_priv;
291 dac_int->tv_std = val;
292 }
293 radeon_property_change_mode(&radeon_encoder->base);
294 }
295
296 if (property == rdev->mode_info.load_detect_property) {
297 struct radeon_connector *radeon_connector =
298 to_radeon_connector(connector);
299
300 if (val == 0)
301 radeon_connector->dac_load_detect = false;
302 else
303 radeon_connector->dac_load_detect = true;
304 }
305
306 if (property == rdev->mode_info.tmds_pll_property) {
307 struct radeon_encoder_int_tmds *tmds = NULL;
308 bool ret = false;
309 /* need to find digital encoder on connector */
310 encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
311 if (!encoder)
312 return 0;
313
314 radeon_encoder = to_radeon_encoder(encoder);
315
316 tmds = radeon_encoder->enc_priv;
317 if (!tmds)
318 return 0;
319
320 if (val == 0) {
321 if (rdev->is_atom_bios)
322 ret = radeon_atombios_get_tmds_info(radeon_encoder, tmds);
323 else
324 ret = radeon_legacy_get_tmds_info_from_combios(radeon_encoder, tmds);
325 }
326 if (val == 1 || ret == false) {
327 radeon_legacy_get_tmds_info_from_table(radeon_encoder, tmds);
328 }
329 radeon_property_change_mode(&radeon_encoder->base);
330 }
331
771fe6b9
JG		 332 return 0;
333}
334
8dfaa8a7
MD		 335static void radeon_fixup_lvds_native_mode(struct drm_encoder *encoder,
336 struct drm_connector *connector)
337{
338 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
de2103e4 339 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
8dfaa8a7
MD		 340
341 /* Try to get native mode details from EDID if necessary */
de2103e4 342 if (!native_mode->clock) {
8dfaa8a7
MD		 343 struct drm_display_mode *t, *mode;
344
345 list_for_each_entry_safe(mode, t, &connector->probed_modes, head) {
de2103e4
AD		 346 if (mode->hdisplay == native_mode->hdisplay &&
347 mode->vdisplay == native_mode->vdisplay) {
348 *native_mode = *mode;
349 drm_mode_set_crtcinfo(native_mode, CRTC_INTERLACE_HALVE_V);
8dfaa8a7
MD		 350 DRM_INFO("Determined LVDS native mode details from EDID\n");
351 break;
352 }
353 }
354 }
de2103e4 355 if (!native_mode->clock) {
8dfaa8a7
MD		 356 DRM_INFO("No LVDS native mode details, disabling RMX\n");
357 radeon_encoder->rmx_type = RMX_OFF;
358 }
359}
771fe6b9
JG		 360
361static int radeon_lvds_get_modes(struct drm_connector *connector)
362{
363 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
364 struct drm_encoder *encoder;
365 int ret = 0;
366 struct drm_display_mode *mode;
367
368 if (radeon_connector->ddc_bus) {
369 ret = radeon_ddc_get_modes(radeon_connector);
370 if (ret > 0) {
7747b713 371 encoder = radeon_best_single_encoder(connector);
8dfaa8a7
MD		 372 if (encoder) {
373 radeon_fixup_lvds_native_mode(encoder, connector);
7747b713
AD		 374 /* add scaled modes */
375 radeon_add_common_modes(encoder, connector);
8dfaa8a7 376 }
771fe6b9
JG		 377 return ret;
378 }
379 }
380
381 encoder = radeon_best_single_encoder(connector);
382 if (!encoder)
383 return 0;
384
385 /* we have no EDID modes */
386 mode = radeon_fp_native_mode(encoder);
387 if (mode) {
388 ret = 1;
389 drm_mode_probed_add(connector, mode);
7747b713
AD		 390 /* add scaled modes */
391 radeon_add_common_modes(encoder, connector);
771fe6b9 392 }
923f6848 393
771fe6b9
JG		 394 return ret;
395}
396
397static int radeon_lvds_mode_valid(struct drm_connector *connector,
398 struct drm_display_mode *mode)
399{
a3fa6320
AD		 400 struct drm_encoder *encoder = radeon_best_single_encoder(connector);
401
402 if ((mode->hdisplay < 320) || (mode->vdisplay < 240))
403 return MODE_PANEL;
404
405 if (encoder) {
406 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
407 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
408
409 /* AVIVO hardware supports downscaling modes larger than the panel
410 * to the panel size, but I'm not sure this is desirable.
411 */
412 if ((mode->hdisplay > native_mode->hdisplay) ||
413 (mode->vdisplay > native_mode->vdisplay))
414 return MODE_PANEL;
415
416 /* if scaling is disabled, block non-native modes */
417 if (radeon_encoder->rmx_type == RMX_OFF) {
418 if ((mode->hdisplay != native_mode->hdisplay) ||
419 (mode->vdisplay != native_mode->vdisplay))
420 return MODE_PANEL;
421 }
422 }
423
771fe6b9
JG		 424 return MODE_OK;
425}
426
427static enum drm_connector_status radeon_lvds_detect(struct drm_connector *connector)
428{
0549a061 429 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
2ffb8429 430 struct drm_encoder *encoder = radeon_best_single_encoder(connector);
0549a061 431 enum drm_connector_status ret = connector_status_disconnected;
2ffb8429
AD		 432
433 if (encoder) {
434 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
de2103e4 435 struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
2ffb8429
AD		 436
437 /* check if panel is valid */
de2103e4 438 if (native_mode->hdisplay >= 320 && native_mode->vdisplay >= 240)
2ffb8429
AD		 439 ret = connector_status_connected;
440
441 }
0549a061
AD		 442
443 /* check for edid as well */
0294cf4f
AD		 444 if (radeon_connector->edid)
445 ret = connector_status_connected;
446 else {
447 if (radeon_connector->ddc_bus) {
ab1e9ea0 448 radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
0294cf4f
AD		 449 radeon_connector->edid = drm_get_edid(&radeon_connector->base,
450 &radeon_connector->ddc_bus->adapter);
ab1e9ea0 451 radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
0294cf4f
AD		 452 if (radeon_connector->edid)
453 ret = connector_status_connected;
454 }
0549a061 455 }
771fe6b9 456 /* check acpi lid status ??? */
2ffb8429 457
771fe6b9
JG		 458 radeon_connector_update_scratch_regs(connector, ret);
459 return ret;
460}
461
462static void radeon_connector_destroy(struct drm_connector *connector)
463{
464 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
465
466 if (radeon_connector->ddc_bus)
467 radeon_i2c_destroy(radeon_connector->ddc_bus);
0294cf4f
AD		 468 if (radeon_connector->edid)
469 kfree(radeon_connector->edid);
771fe6b9
JG		 470 kfree(radeon_connector->con_priv);
471 drm_sysfs_connector_remove(connector);
472 drm_connector_cleanup(connector);
473 kfree(connector);
474}
475
445282db
DA		 476static int radeon_lvds_set_property(struct drm_connector *connector,
477 struct drm_property *property,
478 uint64_t value)
479{
480 struct drm_device *dev = connector->dev;
481 struct radeon_encoder *radeon_encoder;
482 enum radeon_rmx_type rmx_type;
483
484 DRM_DEBUG("\n");
485 if (property != dev->mode_config.scaling_mode_property)
486 return 0;
487
488 if (connector->encoder)
489 radeon_encoder = to_radeon_encoder(connector->encoder);
490 else {
491 struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
492 radeon_encoder = to_radeon_encoder(connector_funcs->best_encoder(connector));
493 }
494
495 switch (value) {
496 case DRM_MODE_SCALE_NONE: rmx_type = RMX_OFF; break;
497 case DRM_MODE_SCALE_CENTER: rmx_type = RMX_CENTER; break;
498 case DRM_MODE_SCALE_ASPECT: rmx_type = RMX_ASPECT; break;
499 default:
500 case DRM_MODE_SCALE_FULLSCREEN: rmx_type = RMX_FULL; break;
501 }
502 if (radeon_encoder->rmx_type == rmx_type)
503 return 0;
504
505 radeon_encoder->rmx_type = rmx_type;
506
507 radeon_property_change_mode(&radeon_encoder->base);
508 return 0;
509}
510
511
771fe6b9
JG		 512struct drm_connector_helper_funcs radeon_lvds_connector_helper_funcs = {
513 .get_modes = radeon_lvds_get_modes,
514 .mode_valid = radeon_lvds_mode_valid,
515 .best_encoder = radeon_best_single_encoder,
516};
517
518struct drm_connector_funcs radeon_lvds_connector_funcs = {
519 .dpms = drm_helper_connector_dpms,
520 .detect = radeon_lvds_detect,
521 .fill_modes = drm_helper_probe_single_connector_modes,
522 .destroy = radeon_connector_destroy,
445282db 523 .set_property = radeon_lvds_set_property,
771fe6b9
JG		 524};
525
526static int radeon_vga_get_modes(struct drm_connector *connector)
527{
528 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
529 int ret;
530
531 ret = radeon_ddc_get_modes(radeon_connector);
532
533 return ret;
534}
535
536static int radeon_vga_mode_valid(struct drm_connector *connector,
537 struct drm_display_mode *mode)
538{
a3fa6320
AD		 539 /* XXX check mode bandwidth */
540 /* XXX verify against max DAC output frequency */
771fe6b9
JG		 541 return MODE_OK;
542}
543
544static enum drm_connector_status radeon_vga_detect(struct drm_connector *connector)
545{
546 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
547 struct drm_encoder *encoder;
548 struct drm_encoder_helper_funcs *encoder_funcs;
549 bool dret;
550 enum drm_connector_status ret = connector_status_disconnected;
551
4ce001ab
DA		 552 encoder = radeon_best_single_encoder(connector);
553 if (!encoder)
554 ret = connector_status_disconnected;
555
ab1e9ea0 556 radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
771fe6b9 557 dret = radeon_ddc_probe(radeon_connector);
ab1e9ea0 558 radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
0294cf4f
AD		 559 if (dret) {
560 if (radeon_connector->edid) {
561 kfree(radeon_connector->edid);
562 radeon_connector->edid = NULL;
563 }
ab1e9ea0 564 radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
0294cf4f 565 radeon_connector->edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
ab1e9ea0 566 radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
0294cf4f
AD		 567
568 if (!radeon_connector->edid) {
f82f5f3a
JG		 569 DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
570 drm_get_connector_name(connector));
571 ret = connector_status_connected;
0294cf4f
AD		 572 } else {
573 radeon_connector->use_digital = !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
574
575 /* some oems have boards with separate digital and analog connectors
576 * with a shared ddc line (often vga + hdmi)
577 */
578 if (radeon_connector->use_digital && radeon_connector->shared_ddc) {
579 kfree(radeon_connector->edid);
580 radeon_connector->edid = NULL;
581 ret = connector_status_disconnected;
582 } else
583 ret = connector_status_connected;
584 }
585 } else {
445282db
DA		 586 if (radeon_connector->dac_load_detect) {
587 encoder_funcs = encoder->helper_private;
588 ret = encoder_funcs->detect(encoder, connector);
589 }
771fe6b9
JG		 590 }
591
4ce001ab
DA		 592 if (ret == connector_status_connected)
593 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
771fe6b9
JG		 594 radeon_connector_update_scratch_regs(connector, ret);
595 return ret;
596}
597
598struct drm_connector_helper_funcs radeon_vga_connector_helper_funcs = {
599 .get_modes = radeon_vga_get_modes,
600 .mode_valid = radeon_vga_mode_valid,
601 .best_encoder = radeon_best_single_encoder,
602};
603
604struct drm_connector_funcs radeon_vga_connector_funcs = {
605 .dpms = drm_helper_connector_dpms,
606 .detect = radeon_vga_detect,
607 .fill_modes = drm_helper_probe_single_connector_modes,
608 .destroy = radeon_connector_destroy,
609 .set_property = radeon_connector_set_property,
610};
611
4ce001ab
DA		 612static int radeon_tv_get_modes(struct drm_connector *connector)
613{
614 struct drm_device *dev = connector->dev;
923f6848 615 struct radeon_device *rdev = dev->dev_private;
4ce001ab 616 struct drm_display_mode *tv_mode;
923f6848 617 struct drm_encoder *encoder;
4ce001ab 618
923f6848
AD		 619 encoder = radeon_best_single_encoder(connector);
620 if (!encoder)
621 return 0;
4ce001ab 622
923f6848
AD		 623 /* avivo chips can scale any mode */
624 if (rdev->family >= CHIP_RS600)
625 /* add scaled modes */
626 radeon_add_common_modes(encoder, connector);
627 else {
628 /* only 800x600 is supported right now on pre-avivo chips */
d50ba256 629 tv_mode = drm_cvt_mode(dev, 800, 600, 60, false, false, false);
923f6848
AD		 630 tv_mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
631 drm_mode_probed_add(connector, tv_mode);
632 }
4ce001ab
DA		 633 return 1;
634}
635
636static int radeon_tv_mode_valid(struct drm_connector *connector,
637 struct drm_display_mode *mode)
638{
a3fa6320
AD		 639 if ((mode->hdisplay > 1024) || (mode->vdisplay > 768))
640 return MODE_CLOCK_RANGE;
4ce001ab
DA		 641 return MODE_OK;
642}
643
644static enum drm_connector_status radeon_tv_detect(struct drm_connector *connector)
645{
646 struct drm_encoder *encoder;
647 struct drm_encoder_helper_funcs *encoder_funcs;
445282db
DA		 648 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
649 enum drm_connector_status ret = connector_status_disconnected;
650
651 if (!radeon_connector->dac_load_detect)
652 return ret;
4ce001ab
DA		 653
654 encoder = radeon_best_single_encoder(connector);
655 if (!encoder)
656 ret = connector_status_disconnected;
657 else {
658 encoder_funcs = encoder->helper_private;
659 ret = encoder_funcs->detect(encoder, connector);
660 }
661 if (ret == connector_status_connected)
662 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, false);
663 radeon_connector_update_scratch_regs(connector, ret);
664 return ret;
665}
666
667struct drm_connector_helper_funcs radeon_tv_connector_helper_funcs = {
668 .get_modes = radeon_tv_get_modes,
669 .mode_valid = radeon_tv_mode_valid,
670 .best_encoder = radeon_best_single_encoder,
671};
672
673struct drm_connector_funcs radeon_tv_connector_funcs = {
674 .dpms = drm_helper_connector_dpms,
675 .detect = radeon_tv_detect,
676 .fill_modes = drm_helper_probe_single_connector_modes,
677 .destroy = radeon_connector_destroy,
678 .set_property = radeon_connector_set_property,
679};
680
771fe6b9
JG		 681static int radeon_dvi_get_modes(struct drm_connector *connector)
682{
683 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
684 int ret;
685
686 ret = radeon_ddc_get_modes(radeon_connector);
771fe6b9
JG		 687 return ret;
688}
689
4ce001ab
DA		 690/*
691 * DVI is complicated
692 * Do a DDC probe, if DDC probe passes, get the full EDID so
693 * we can do analog/digital monitor detection at this point.
694 * If the monitor is an analog monitor or we got no DDC,
695 * we need to find the DAC encoder object for this connector.
696 * If we got no DDC, we do load detection on the DAC encoder object.
697 * If we got analog DDC or load detection passes on the DAC encoder
698 * we have to check if this analog encoder is shared with anyone else (TV)
699 * if its shared we have to set the other connector to disconnected.
700 */
771fe6b9
JG		 701static enum drm_connector_status radeon_dvi_detect(struct drm_connector *connector)
702{
703 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
4ce001ab 704 struct drm_encoder *encoder = NULL;
771fe6b9
JG		 705 struct drm_encoder_helper_funcs *encoder_funcs;
706 struct drm_mode_object *obj;
707 int i;
708 enum drm_connector_status ret = connector_status_disconnected;
709 bool dret;
710
ab1e9ea0 711 radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
771fe6b9 712 dret = radeon_ddc_probe(radeon_connector);
ab1e9ea0 713 radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
4ce001ab 714 if (dret) {
0294cf4f
AD		 715 if (radeon_connector->edid) {
716 kfree(radeon_connector->edid);
717 radeon_connector->edid = NULL;
718 }
ab1e9ea0 719 radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
4ce001ab 720 radeon_connector->edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
ab1e9ea0 721 radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
4ce001ab
DA		 722
723 if (!radeon_connector->edid) {
f82f5f3a
JG		 724 DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
725 drm_get_connector_name(connector));
4ce001ab
DA		 726 } else {
727 radeon_connector->use_digital = !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
728
0294cf4f
AD		 729 /* some oems have boards with separate digital and analog connectors
730 * with a shared ddc line (often vga + hdmi)
731 */
732 if ((!radeon_connector->use_digital) && radeon_connector->shared_ddc) {
733 kfree(radeon_connector->edid);
734 radeon_connector->edid = NULL;
735 ret = connector_status_disconnected;
736 } else
737 ret = connector_status_connected;
71407c46
AD		 738
739 /* multiple connectors on the same encoder with the same ddc line
740 * This tends to be HDMI and DVI on the same encoder with the
741 * same ddc line. If the edid says HDMI, consider the HDMI port
742 * connected and the DVI port disconnected. If the edid doesn't
743 * say HDMI, vice versa.
744 */
745 if (radeon_connector->shared_ddc && connector_status_connected) {
746 struct drm_device *dev = connector->dev;
747 struct drm_connector *list_connector;
748 struct radeon_connector *list_radeon_connector;
749 list_for_each_entry(list_connector, &dev->mode_config.connector_list, head) {
750 if (connector == list_connector)
751 continue;
752 list_radeon_connector = to_radeon_connector(list_connector);
753 if (radeon_connector->devices == list_radeon_connector->devices) {
754 if (drm_detect_hdmi_monitor(radeon_connector->edid)) {
755 if (connector->connector_type == DRM_MODE_CONNECTOR_DVID) {
756 kfree(radeon_connector->edid);
757 radeon_connector->edid = NULL;
758 ret = connector_status_disconnected;
759 }
760 } else {
761 if ((connector->connector_type == DRM_MODE_CONNECTOR_HDMIA) ||
762 (connector->connector_type == DRM_MODE_CONNECTOR_HDMIB)) {
763 kfree(radeon_connector->edid);
764 radeon_connector->edid = NULL;
765 ret = connector_status_disconnected;
766 }
767 }
768 }
769 }
770 }
4ce001ab
DA		 771 }
772 }
773
774 if ((ret == connector_status_connected) && (radeon_connector->use_digital == true))
775 goto out;
776
777 /* find analog encoder */
445282db
DA		 778 if (radeon_connector->dac_load_detect) {
779 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
780 if (connector->encoder_ids[i] == 0)
781 break;
771fe6b9 782
445282db
DA		 783 obj = drm_mode_object_find(connector->dev,
784 connector->encoder_ids[i],
785 DRM_MODE_OBJECT_ENCODER);
786 if (!obj)
787 continue;
771fe6b9 788
445282db 789 encoder = obj_to_encoder(obj);
771fe6b9 790
445282db
DA		 791 encoder_funcs = encoder->helper_private;
792 if (encoder_funcs->detect) {
793 if (ret != connector_status_connected) {
794 ret = encoder_funcs->detect(encoder, connector);
795 if (ret == connector_status_connected) {
796 radeon_connector->use_digital = false;
797 }
771fe6b9 798 }
445282db 799 break;
771fe6b9
JG		 800 }
801 }
802 }
803
4ce001ab
DA		 804 if ((ret == connector_status_connected) && (radeon_connector->use_digital == false) &&
805 encoder) {
806 ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
807 }
808
809out:
771fe6b9
JG		 810 /* updated in get modes as well since we need to know if it's analog or digital */
811 radeon_connector_update_scratch_regs(connector, ret);
812 return ret;
813}
814
815/* okay need to be smart in here about which encoder to pick */
816struct drm_encoder *radeon_dvi_encoder(struct drm_connector *connector)
817{
818 int enc_id = connector->encoder_ids[0];
819 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
820 struct drm_mode_object *obj;
821 struct drm_encoder *encoder;
822 int i;
823 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
824 if (connector->encoder_ids[i] == 0)
825 break;
826
827 obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
828 if (!obj)
829 continue;
830
831 encoder = obj_to_encoder(obj);
832
4ce001ab 833 if (radeon_connector->use_digital == true) {
771fe6b9
JG		 834 if (encoder->encoder_type == DRM_MODE_ENCODER_TMDS)
835 return encoder;
836 } else {
837 if (encoder->encoder_type == DRM_MODE_ENCODER_DAC ||
838 encoder->encoder_type == DRM_MODE_ENCODER_TVDAC)
839 return encoder;
840 }
841 }
842
843 /* see if we have a default encoder TODO */
844
845 /* then check use digitial */
846 /* pick the first one */
847 if (enc_id) {
848 obj = drm_mode_object_find(connector->dev, enc_id, DRM_MODE_OBJECT_ENCODER);
849 if (!obj)
850 return NULL;
851 encoder = obj_to_encoder(obj);
852 return encoder;
853 }
854 return NULL;
855}
856
d50ba256
DA		 857static void radeon_dvi_force(struct drm_connector *connector)
858{
859 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
860 if (connector->force == DRM_FORCE_ON)
861 radeon_connector->use_digital = false;
862 if (connector->force == DRM_FORCE_ON_DIGITAL)
863 radeon_connector->use_digital = true;
864}
865
a3fa6320
AD		 866static int radeon_dvi_mode_valid(struct drm_connector *connector,
867 struct drm_display_mode *mode)
868{
869 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
870
871 /* XXX check mode bandwidth */
872
873 if (radeon_connector->use_digital && (mode->clock > 165000)) {
874 if ((radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_I) ||
875 (radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_D) ||
876 (radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_HDMI_TYPE_B))
877 return MODE_OK;
878 else
879 return MODE_CLOCK_HIGH;
880 }
881 return MODE_OK;
882}
883
771fe6b9
JG		 884struct drm_connector_helper_funcs radeon_dvi_connector_helper_funcs = {
885 .get_modes = radeon_dvi_get_modes,
a3fa6320 886 .mode_valid = radeon_dvi_mode_valid,
771fe6b9
JG		 887 .best_encoder = radeon_dvi_encoder,
888};
889
890struct drm_connector_funcs radeon_dvi_connector_funcs = {
891 .dpms = drm_helper_connector_dpms,
892 .detect = radeon_dvi_detect,
893 .fill_modes = drm_helper_probe_single_connector_modes,
894 .set_property = radeon_connector_set_property,
895 .destroy = radeon_connector_destroy,
d50ba256 896 .force = radeon_dvi_force,
771fe6b9
JG		 897};
898
746c1aa4
DA		 899static int radeon_dp_get_modes(struct drm_connector *connector)
900{
901 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
902 int ret;
903
904 ret = radeon_ddc_get_modes(radeon_connector);
905 return ret;
906}
907
908static enum drm_connector_status radeon_dp_detect(struct drm_connector *connector)
909{
910 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
911 struct drm_encoder *encoder = NULL;
912 struct drm_encoder_helper_funcs *encoder_funcs;
913 struct drm_mode_object *obj;
914 int i;
915 enum drm_connector_status ret = connector_status_disconnected;
916 int sink_type;
917 bool dret;
918
919 if (radeon_connector->edid) {
920 kfree(radeon_connector->edid);
921 radeon_connector->edid = NULL;
922 }
923
924 sink_type = radeon_dp_getsinktype(radeon_connector);
925 if (sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) {
1a66c95a 926 radeon_dp_getdpcd(radeon_connector);
746c1aa4
DA		 927 ret = connector_status_connected;
928 }
929 return ret;
930}
931
932struct drm_connector_helper_funcs radeon_dp_connector_helper_funcs = {
933 .get_modes = radeon_dp_get_modes,
934 .mode_valid = radeon_dvi_mode_valid,
935 .best_encoder = radeon_dvi_encoder,
936};
937
938struct drm_connector_funcs radeon_dp_connector_funcs = {
939 .dpms = drm_helper_connector_dpms,
940 .detect = radeon_dp_detect,
941 .fill_modes = drm_helper_probe_single_connector_modes,
942 .set_property = radeon_connector_set_property,
943 .destroy = radeon_connector_destroy,
944 .force = radeon_dvi_force,
945};
946
771fe6b9
JG		 947void
948radeon_add_atom_connector(struct drm_device *dev,
949 uint32_t connector_id,
950 uint32_t supported_device,
951 int connector_type,
952 struct radeon_i2c_bus_rec *i2c_bus,
953 bool linkb,
b75fad06 954 uint32_t igp_lane_info,
6a93cb25 955 uint16_t connector_object_id)
771fe6b9 956{
445282db 957 struct radeon_device *rdev = dev->dev_private;
771fe6b9
JG		 958 struct drm_connector *connector;
959 struct radeon_connector *radeon_connector;
960 struct radeon_connector_atom_dig *radeon_dig_connector;
961 uint32_t subpixel_order = SubPixelNone;
0294cf4f 962 bool shared_ddc = false;
d50ba256 963 int ret;
771fe6b9
JG		 964
965 /* fixme - tv/cv/din */
4ce001ab 966 if (connector_type == DRM_MODE_CONNECTOR_Unknown)
771fe6b9
JG		 967 return;
968
969 /* see if we already added it */
970 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
971 radeon_connector = to_radeon_connector(connector);
972 if (radeon_connector->connector_id == connector_id) {
973 radeon_connector->devices |= supported_device;
974 return;
975 }
0294cf4f
AD		 976 if (radeon_connector->ddc_bus && i2c_bus->valid) {
977 if (memcmp(&radeon_connector->ddc_bus->rec, i2c_bus,
978 sizeof(struct radeon_i2c_bus_rec)) == 0) {
979 radeon_connector->shared_ddc = true;
980 shared_ddc = true;
981 }
982 }
771fe6b9
JG		 983 }
984
985 radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
986 if (!radeon_connector)
987 return;
988
989 connector = &radeon_connector->base;
990
991 radeon_connector->connector_id = connector_id;
992 radeon_connector->devices = supported_device;
0294cf4f 993 radeon_connector->shared_ddc = shared_ddc;
b75fad06 994 radeon_connector->connector_object_id = connector_object_id;
771fe6b9
JG		 995 switch (connector_type) {
996 case DRM_MODE_CONNECTOR_VGA:
997 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
74bf2ad5
DA		 998 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
999 if (ret)
1000 goto failed;
771fe6b9
JG		 1001 if (i2c_bus->valid) {
1002 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "VGA");
1003 if (!radeon_connector->ddc_bus)
1004 goto failed;
1005 }
35e4b7af 1006 radeon_connector->dac_load_detect = true;
445282db
DA		 1007 drm_connector_attach_property(&radeon_connector->base,
1008 rdev->mode_info.load_detect_property,
1009 1);
771fe6b9
JG		 1010 break;
1011 case DRM_MODE_CONNECTOR_DVIA:
1012 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
74bf2ad5
DA		 1013 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1014 if (ret)
1015 goto failed;
771fe6b9
JG		 1016 if (i2c_bus->valid) {
1017 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
1018 if (!radeon_connector->ddc_bus)
1019 goto failed;
1020 }
35e4b7af 1021 radeon_connector->dac_load_detect = true;
445282db
DA		 1022 drm_connector_attach_property(&radeon_connector->base,
1023 rdev->mode_info.load_detect_property,
1024 1);
771fe6b9
JG		 1025 break;
1026 case DRM_MODE_CONNECTOR_DVII:
1027 case DRM_MODE_CONNECTOR_DVID:
1028 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1029 if (!radeon_dig_connector)
1030 goto failed;
1031 radeon_dig_connector->linkb = linkb;
1032 radeon_dig_connector->igp_lane_info = igp_lane_info;
1033 radeon_connector->con_priv = radeon_dig_connector;
1034 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
74bf2ad5
DA		 1035 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
1036 if (ret)
1037 goto failed;
771fe6b9
JG		 1038 if (i2c_bus->valid) {
1039 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
1040 if (!radeon_connector->ddc_bus)
1041 goto failed;
1042 }
1043 subpixel_order = SubPixelHorizontalRGB;
445282db
DA		 1044 drm_connector_attach_property(&radeon_connector->base,
1045 rdev->mode_info.coherent_mode_property,
1046 1);
35e4b7af 1047 radeon_connector->dac_load_detect = true;
445282db
DA		 1048 drm_connector_attach_property(&radeon_connector->base,
1049 rdev->mode_info.load_detect_property,
1050 1);
771fe6b9
JG		 1051 break;
1052 case DRM_MODE_CONNECTOR_HDMIA:
1053 case DRM_MODE_CONNECTOR_HDMIB:
1054 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1055 if (!radeon_dig_connector)
1056 goto failed;
1057 radeon_dig_connector->linkb = linkb;
1058 radeon_dig_connector->igp_lane_info = igp_lane_info;
1059 radeon_connector->con_priv = radeon_dig_connector;
1060 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
74bf2ad5
DA		 1061 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
1062 if (ret)
1063 goto failed;
771fe6b9
JG		 1064 if (i2c_bus->valid) {
1065 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "HDMI");
1066 if (!radeon_connector->ddc_bus)
1067 goto failed;
1068 }
445282db
DA		 1069 drm_connector_attach_property(&radeon_connector->base,
1070 rdev->mode_info.coherent_mode_property,
1071 1);
771fe6b9
JG		 1072 subpixel_order = SubPixelHorizontalRGB;
1073 break;
1074 case DRM_MODE_CONNECTOR_DisplayPort:
1075 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1076 if (!radeon_dig_connector)
1077 goto failed;
1078 radeon_dig_connector->linkb = linkb;
1079 radeon_dig_connector->igp_lane_info = igp_lane_info;
1080 radeon_connector->con_priv = radeon_dig_connector;
746c1aa4
DA		 1081 drm_connector_init(dev, &radeon_connector->base, &radeon_dp_connector_funcs, connector_type);
1082 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dp_connector_helper_funcs);
74bf2ad5
DA		 1083 if (ret)
1084 goto failed;
746c1aa4 1085 /* add DP i2c bus */
6a93cb25 1086 radeon_dig_connector->dp_i2c_bus = radeon_i2c_create_dp(dev, i2c_bus, "DP-auxch");
771fe6b9
JG		 1087 if (i2c_bus->valid) {
1088 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DP");
1089 if (!radeon_connector->ddc_bus)
1090 goto failed;
1091 }
1092 subpixel_order = SubPixelHorizontalRGB;
1093 break;
1094 case DRM_MODE_CONNECTOR_SVIDEO:
1095 case DRM_MODE_CONNECTOR_Composite:
1096 case DRM_MODE_CONNECTOR_9PinDIN:
4ce001ab
DA		 1097 if (radeon_tv == 1) {
1098 drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
74bf2ad5
DA		 1099 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
1100 if (ret)
1101 goto failed;
1102 radeon_connector->dac_load_detect = true;
1103 drm_connector_attach_property(&radeon_connector->base,
1104 rdev->mode_info.load_detect_property,
1105 1);
ed160143
AD		 1106 drm_connector_attach_property(&radeon_connector->base,
1107 rdev->mode_info.tv_std_property,
1108 1);
4ce001ab 1109 }
771fe6b9
JG		 1110 break;
1111 case DRM_MODE_CONNECTOR_LVDS:
1112 radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1113 if (!radeon_dig_connector)
1114 goto failed;
1115 radeon_dig_connector->linkb = linkb;
1116 radeon_dig_connector->igp_lane_info = igp_lane_info;
1117 radeon_connector->con_priv = radeon_dig_connector;
1118 drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
74bf2ad5
DA		 1119 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
1120 if (ret)
1121 goto failed;
771fe6b9
JG		 1122 if (i2c_bus->valid) {
1123 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "LVDS");
1124 if (!radeon_connector->ddc_bus)
1125 goto failed;
1126 }
445282db
DA		 1127 drm_mode_create_scaling_mode_property(dev);
1128 drm_connector_attach_property(&radeon_connector->base,
1129 dev->mode_config.scaling_mode_property,
1130 DRM_MODE_SCALE_FULLSCREEN);
771fe6b9
JG		 1131 subpixel_order = SubPixelHorizontalRGB;
1132 break;
1133 }
1134
1135 connector->display_info.subpixel_order = subpixel_order;
1136 drm_sysfs_connector_add(connector);
1137 return;
1138
1139failed:
1140 if (radeon_connector->ddc_bus)
1141 radeon_i2c_destroy(radeon_connector->ddc_bus);
1142 drm_connector_cleanup(connector);
1143 kfree(connector);
1144}
1145
1146void
1147radeon_add_legacy_connector(struct drm_device *dev,
1148 uint32_t connector_id,
1149 uint32_t supported_device,
1150 int connector_type,
b75fad06
AD		 1151 struct radeon_i2c_bus_rec *i2c_bus,
1152 uint16_t connector_object_id)
771fe6b9 1153{
445282db 1154 struct radeon_device *rdev = dev->dev_private;
771fe6b9
JG		 1155 struct drm_connector *connector;
1156 struct radeon_connector *radeon_connector;
1157 uint32_t subpixel_order = SubPixelNone;
d50ba256 1158 int ret;
771fe6b9
JG		 1159
1160 /* fixme - tv/cv/din */
4ce001ab 1161 if (connector_type == DRM_MODE_CONNECTOR_Unknown)
771fe6b9
JG		 1162 return;
1163
1164 /* see if we already added it */
1165 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
1166 radeon_connector = to_radeon_connector(connector);
1167 if (radeon_connector->connector_id == connector_id) {
1168 radeon_connector->devices |= supported_device;
1169 return;
1170 }
1171 }
1172
1173 radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
1174 if (!radeon_connector)
1175 return;
1176
1177 connector = &radeon_connector->base;
1178
1179 radeon_connector->connector_id = connector_id;
1180 radeon_connector->devices = supported_device;
b75fad06 1181 radeon_connector->connector_object_id = connector_object_id;
771fe6b9
JG		 1182 switch (connector_type) {
1183 case DRM_MODE_CONNECTOR_VGA:
1184 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
74bf2ad5
DA		 1185 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1186 if (ret)
1187 goto failed;
771fe6b9
JG		 1188 if (i2c_bus->valid) {
1189 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "VGA");
1190 if (!radeon_connector->ddc_bus)
1191 goto failed;
1192 }
35e4b7af 1193 radeon_connector->dac_load_detect = true;
445282db
DA		 1194 drm_connector_attach_property(&radeon_connector->base,
1195 rdev->mode_info.load_detect_property,
1196 1);
771fe6b9
JG		 1197 break;
1198 case DRM_MODE_CONNECTOR_DVIA:
1199 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
74bf2ad5
DA		 1200 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1201 if (ret)
1202 goto failed;
771fe6b9
JG		 1203 if (i2c_bus->valid) {
1204 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
1205 if (!radeon_connector->ddc_bus)
1206 goto failed;
1207 }
35e4b7af 1208 radeon_connector->dac_load_detect = true;
445282db
DA		 1209 drm_connector_attach_property(&radeon_connector->base,
1210 rdev->mode_info.load_detect_property,
1211 1);
771fe6b9
JG		 1212 break;
1213 case DRM_MODE_CONNECTOR_DVII:
1214 case DRM_MODE_CONNECTOR_DVID:
1215 drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
74bf2ad5
DA		 1216 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
1217 if (ret)
1218 goto failed;
771fe6b9
JG		 1219 if (i2c_bus->valid) {
1220 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
1221 if (!radeon_connector->ddc_bus)
1222 goto failed;
35e4b7af 1223 radeon_connector->dac_load_detect = true;
445282db
DA		 1224 drm_connector_attach_property(&radeon_connector->base,
1225 rdev->mode_info.load_detect_property,
1226 1);
771fe6b9
JG		 1227 }
1228 subpixel_order = SubPixelHorizontalRGB;
1229 break;
1230 case DRM_MODE_CONNECTOR_SVIDEO:
1231 case DRM_MODE_CONNECTOR_Composite:
1232 case DRM_MODE_CONNECTOR_9PinDIN:
4ce001ab
DA		 1233 if (radeon_tv == 1) {
1234 drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
74bf2ad5
DA		 1235 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
1236 if (ret)
1237 goto failed;
35e4b7af 1238 radeon_connector->dac_load_detect = true;
0beb81ab
JG		 1239 /* RS400,RC410,RS480 chipset seems to report a lot
1240 * of false positive on load detect, we haven't yet
1241 * found a way to make load detect reliable on those
1242 * chipset, thus just disable it for TV.
1243 */
1244 if (rdev->family == CHIP_RS400 || rdev->family == CHIP_RS480)
1245 radeon_connector->dac_load_detect = false;
445282db
DA		 1246 drm_connector_attach_property(&radeon_connector->base,
1247 rdev->mode_info.load_detect_property,
1248 1);
ed160143
AD		 1249 drm_connector_attach_property(&radeon_connector->base,
1250 rdev->mode_info.tv_std_property,
1251 1);
4ce001ab 1252 }
771fe6b9
JG		 1253 break;
1254 case DRM_MODE_CONNECTOR_LVDS:
1255 drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
74bf2ad5
DA		 1256 ret = drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
1257 if (ret)
1258 goto failed;
771fe6b9
JG		 1259 if (i2c_bus->valid) {
1260 radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "LVDS");
1261 if (!radeon_connector->ddc_bus)
1262 goto failed;
1263 }
445282db
DA		 1264 drm_connector_attach_property(&radeon_connector->base,
1265 dev->mode_config.scaling_mode_property,
1266 DRM_MODE_SCALE_FULLSCREEN);
771fe6b9
JG		 1267 subpixel_order = SubPixelHorizontalRGB;
1268 break;
1269 }
1270
1271 connector->display_info.subpixel_order = subpixel_order;
1272 drm_sysfs_connector_add(connector);
1273 return;
1274
1275failed:
1276 if (radeon_connector->ddc_bus)
1277 radeon_i2c_destroy(radeon_connector->ddc_bus);
1278 drm_connector_cleanup(connector);
1279 kfree(connector);
1280}
Clone of davem's net-next-2.6 tree