Subversion Repositories Kolibri OS

Rev

Rev 1246 | Rev 1313 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
1123 serge 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"
1126 serge 27
#include "drm_edid.h"
1123 serge 28
#include "drm_crtc_helper.h"
1221 serge 29
#include "drm_fb_helper.h"
1123 serge 30
#include "radeon_drm.h"
31
#include "radeon.h"
1179 serge 32
#include "atom.h"
1123 serge 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
 
1179 serge 43
static 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
}
1123 serge 52
static void
53
radeon_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
 
1179 serge 91
struct 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
 
1123 serge 112
struct 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
 
1179 serge 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
 */
135
static enum drm_connector_status
136
radeon_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
 
1123 serge 176
static 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;
1268 serge 181
	struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
1123 serge 182
 
1268 serge 183
	if (native_mode->hdisplay != 0 &&
184
	    native_mode->vdisplay != 0 &&
185
	    native_mode->clock != 0) {
186
		mode = drm_mode_duplicate(dev, native_mode);
1123 serge 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
 
1179 serge 195
static 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;
1268 serge 200
	struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
1179 serge 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++) {
1268 serge 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
		}
1179 serge 231
		if (radeon_encoder->devices & (ATOM_DEVICE_LCD_SUPPORT)) {
1268 serge 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))
1179 serge 236
				continue;
237
		}
238
		if (common_modes[i].w < 320 || common_modes[i].h < 200)
239
			continue;
240
 
1221 serge 241
		mode = drm_cvt_mode(dev, common_modes[i].w, common_modes[i].h, 60, false, false, false);
1179 serge 242
		drm_mode_probed_add(connector, mode);
243
	}
244
}
245
 
1123 serge 246
int radeon_connector_set_property(struct drm_connector *connector, struct drm_property *property,
247
				  uint64_t val)
248
{
1179 serge 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
 
1123 serge 332
	return 0;
333
}
334
 
1179 serge 335
static 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);
1268 serge 339
	struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
1123 serge 340
 
1179 serge 341
	/* Try to get native mode details from EDID if necessary */
1268 serge 342
	if (!native_mode->clock) {
1179 serge 343
		struct drm_display_mode *t, *mode;
344
 
345
		list_for_each_entry_safe(mode, t, &connector->probed_modes, head) {
1268 serge 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);
1179 serge 350
				DRM_INFO("Determined LVDS native mode details from EDID\n");
351
				break;
352
			}
353
		}
354
	}
1268 serge 355
	if (!native_mode->clock) {
1179 serge 356
		DRM_INFO("No LVDS native mode details, disabling RMX\n");
357
		radeon_encoder->rmx_type = RMX_OFF;
358
	}
359
}
360
 
1123 serge 361
static 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) {
1179 serge 371
			encoder = radeon_best_single_encoder(connector);
372
			if (encoder) {
373
				radeon_fixup_lvds_native_mode(encoder, connector);
374
				/* add scaled modes */
375
				radeon_add_common_modes(encoder, connector);
376
			}
1123 serge 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);
1179 serge 390
		/* add scaled modes */
391
		radeon_add_common_modes(encoder, connector);
1123 serge 392
	}
1179 serge 393
 
1123 serge 394
	return ret;
395
}
396
 
397
static int radeon_lvds_mode_valid(struct drm_connector *connector,
398
				  struct drm_display_mode *mode)
399
{
1268 serge 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
 
1123 serge 424
	return MODE_OK;
425
}
426
 
427
static enum drm_connector_status radeon_lvds_detect(struct drm_connector *connector)
428
{
1268 serge 429
	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
430
	struct drm_encoder *encoder = radeon_best_single_encoder(connector);
431
	enum drm_connector_status ret = connector_status_disconnected;
432
 
433
	if (encoder) {
434
		struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
435
		struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
436
 
437
		/* check if panel is valid */
438
		if (native_mode->hdisplay >= 320 && native_mode->vdisplay >= 240)
439
			ret = connector_status_connected;
440
 
441
	}
442
 
443
	/* check for edid as well */
444
	if (radeon_connector->edid)
445
		ret = connector_status_connected;
446
	else {
447
		if (radeon_connector->ddc_bus) {
448
			radeon_i2c_do_lock(radeon_connector, 1);
449
			radeon_connector->edid = drm_get_edid(&radeon_connector->base,
450
							      &radeon_connector->ddc_bus->adapter);
451
			radeon_i2c_do_lock(radeon_connector, 0);
452
			if (radeon_connector->edid)
453
				ret = connector_status_connected;
454
		}
455
	}
1123 serge 456
	/* check acpi lid status ??? */
1268 serge 457
 
1123 serge 458
	radeon_connector_update_scratch_regs(connector, ret);
459
	return ret;
460
}
461
 
462
static 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);
1268 serge 468
	if (radeon_connector->edid)
469
		kfree(radeon_connector->edid);
1123 serge 470
	kfree(radeon_connector->con_priv);
1233 serge 471
	drm_sysfs_connector_remove(connector);
1123 serge 472
	drm_connector_cleanup(connector);
473
	kfree(connector);
474
}
475
 
1179 serge 476
static 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
 
1123 serge 512
struct 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
 
518
struct 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,
1179 serge 523
	.set_property = radeon_lvds_set_property,
1123 serge 524
};
525
 
526
static 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
 
536
static int radeon_vga_mode_valid(struct drm_connector *connector,
537
				  struct drm_display_mode *mode)
538
{
1268 serge 539
	/* XXX check mode bandwidth */
540
	/* XXX verify against max DAC output frequency */
1123 serge 541
	return MODE_OK;
542
}
543
 
544
static 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
 
1179 serge 552
	encoder = radeon_best_single_encoder(connector);
553
	if (!encoder)
554
		ret = connector_status_disconnected;
555
 
1123 serge 556
	radeon_i2c_do_lock(radeon_connector, 1);
557
	dret = radeon_ddc_probe(radeon_connector);
558
	radeon_i2c_do_lock(radeon_connector, 0);
1268 serge 559
	if (dret) {
560
		if (radeon_connector->edid) {
561
			kfree(radeon_connector->edid);
562
			radeon_connector->edid = NULL;
563
		}
564
		radeon_i2c_do_lock(radeon_connector, 1);
565
		radeon_connector->edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
566
		radeon_i2c_do_lock(radeon_connector, 0);
567
 
568
		if (!radeon_connector->edid) {
569
			DRM_ERROR("DDC responded but not EDID found for %s\n",
570
				  drm_get_connector_name(connector));
571
		} else {
572
			radeon_connector->use_digital = !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
573
 
574
			/* some oems have boards with separate digital and analog connectors
575
			 * with a shared ddc line (often vga + hdmi)
576
			 */
577
			if (radeon_connector->use_digital && radeon_connector->shared_ddc) {
578
				kfree(radeon_connector->edid);
579
				radeon_connector->edid = NULL;
580
				ret = connector_status_disconnected;
581
			} else
1123 serge 582
		ret = connector_status_connected;
1268 serge 583
		}
584
	} else {
1179 serge 585
		if (radeon_connector->dac_load_detect) {
1123 serge 586
			encoder_funcs = encoder->helper_private;
587
			ret = encoder_funcs->detect(encoder, connector);
588
		}
589
	}
590
 
1179 serge 591
	if (ret == connector_status_connected)
592
		ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
1123 serge 593
	radeon_connector_update_scratch_regs(connector, ret);
594
	return ret;
595
}
596
 
597
struct drm_connector_helper_funcs radeon_vga_connector_helper_funcs = {
598
	.get_modes = radeon_vga_get_modes,
599
	.mode_valid = radeon_vga_mode_valid,
600
	.best_encoder = radeon_best_single_encoder,
601
};
602
 
603
struct drm_connector_funcs radeon_vga_connector_funcs = {
604
	.dpms = drm_helper_connector_dpms,
605
	.detect = radeon_vga_detect,
606
	.fill_modes = drm_helper_probe_single_connector_modes,
607
	.destroy = radeon_connector_destroy,
608
	.set_property = radeon_connector_set_property,
609
};
610
 
1179 serge 611
static int radeon_tv_get_modes(struct drm_connector *connector)
612
{
613
	struct drm_device *dev = connector->dev;
614
	struct radeon_device *rdev = dev->dev_private;
615
	struct drm_display_mode *tv_mode;
616
	struct drm_encoder *encoder;
617
 
618
	encoder = radeon_best_single_encoder(connector);
619
	if (!encoder)
620
		return 0;
621
 
622
	/* avivo chips can scale any mode */
623
	if (rdev->family >= CHIP_RS600)
624
		/* add scaled modes */
625
		radeon_add_common_modes(encoder, connector);
626
	else {
627
		/* only 800x600 is supported right now on pre-avivo chips */
1221 serge 628
		tv_mode = drm_cvt_mode(dev, 800, 600, 60, false, false, false);
1179 serge 629
		tv_mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
630
		drm_mode_probed_add(connector, tv_mode);
631
	}
632
	return 1;
633
}
634
 
635
static int radeon_tv_mode_valid(struct drm_connector *connector,
636
				struct drm_display_mode *mode)
637
{
1268 serge 638
	if ((mode->hdisplay > 1024) || (mode->vdisplay > 768))
639
		return MODE_CLOCK_RANGE;
1179 serge 640
	return MODE_OK;
641
}
642
 
643
static enum drm_connector_status radeon_tv_detect(struct drm_connector *connector)
644
{
645
	struct drm_encoder *encoder;
646
	struct drm_encoder_helper_funcs *encoder_funcs;
647
	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
648
	enum drm_connector_status ret = connector_status_disconnected;
649
 
650
	if (!radeon_connector->dac_load_detect)
651
		return ret;
652
 
653
	encoder = radeon_best_single_encoder(connector);
654
	if (!encoder)
655
		ret = connector_status_disconnected;
656
	else {
657
		encoder_funcs = encoder->helper_private;
658
		ret = encoder_funcs->detect(encoder, connector);
659
	}
660
	if (ret == connector_status_connected)
661
		ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, false);
662
	radeon_connector_update_scratch_regs(connector, ret);
663
	return ret;
664
}
665
 
666
struct drm_connector_helper_funcs radeon_tv_connector_helper_funcs = {
667
	.get_modes = radeon_tv_get_modes,
668
	.mode_valid = radeon_tv_mode_valid,
669
	.best_encoder = radeon_best_single_encoder,
670
};
671
 
672
struct drm_connector_funcs radeon_tv_connector_funcs = {
673
	.dpms = drm_helper_connector_dpms,
674
	.detect = radeon_tv_detect,
675
	.fill_modes = drm_helper_probe_single_connector_modes,
676
	.destroy = radeon_connector_destroy,
677
	.set_property = radeon_connector_set_property,
678
};
679
 
1123 serge 680
static int radeon_dvi_get_modes(struct drm_connector *connector)
681
{
682
	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
683
	int ret;
684
 
685
	ret = radeon_ddc_get_modes(radeon_connector);
686
	return ret;
687
}
688
 
1179 serge 689
/*
690
 * DVI is complicated
691
 * Do a DDC probe, if DDC probe passes, get the full EDID so
692
 * we can do analog/digital monitor detection at this point.
693
 * If the monitor is an analog monitor or we got no DDC,
694
 * we need to find the DAC encoder object for this connector.
695
 * If we got no DDC, we do load detection on the DAC encoder object.
696
 * If we got analog DDC or load detection passes on the DAC encoder
697
 * we have to check if this analog encoder is shared with anyone else (TV)
698
 * if its shared we have to set the other connector to disconnected.
699
 */
1123 serge 700
static enum drm_connector_status radeon_dvi_detect(struct drm_connector *connector)
701
{
702
	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1179 serge 703
	struct drm_encoder *encoder = NULL;
1123 serge 704
	struct drm_encoder_helper_funcs *encoder_funcs;
705
	struct drm_mode_object *obj;
706
	int i;
707
	enum drm_connector_status ret = connector_status_disconnected;
708
	bool dret;
709
 
710
	radeon_i2c_do_lock(radeon_connector, 1);
711
	dret = radeon_ddc_probe(radeon_connector);
712
	radeon_i2c_do_lock(radeon_connector, 0);
1179 serge 713
	if (dret) {
1268 serge 714
		if (radeon_connector->edid) {
715
			kfree(radeon_connector->edid);
716
			radeon_connector->edid = NULL;
717
		}
1179 serge 718
		radeon_i2c_do_lock(radeon_connector, 1);
719
		radeon_connector->edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
720
		radeon_i2c_do_lock(radeon_connector, 0);
721
 
722
		if (!radeon_connector->edid) {
723
			DRM_ERROR("DDC responded but not EDID found for %s\n",
724
				  drm_get_connector_name(connector));
725
		} else {
726
			radeon_connector->use_digital = !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
727
 
1268 serge 728
			/* some oems have boards with separate digital and analog connectors
729
			 * with a shared ddc line (often vga + hdmi)
730
			 */
731
			if ((!radeon_connector->use_digital) && radeon_connector->shared_ddc) {
732
				kfree(radeon_connector->edid);
733
				radeon_connector->edid = NULL;
734
				ret = connector_status_disconnected;
735
			} else
1123 serge 736
		ret = connector_status_connected;
1179 serge 737
		}
738
	}
739
 
740
	if ((ret == connector_status_connected) && (radeon_connector->use_digital == true))
741
		goto out;
742
 
743
	/* find analog encoder */
744
	if (radeon_connector->dac_load_detect) {
1123 serge 745
		for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
746
			if (connector->encoder_ids[i] == 0)
747
				break;
748
 
749
			obj = drm_mode_object_find(connector->dev,
750
						   connector->encoder_ids[i],
751
						   DRM_MODE_OBJECT_ENCODER);
752
			if (!obj)
753
				continue;
754
 
755
			encoder = obj_to_encoder(obj);
756
 
757
			encoder_funcs = encoder->helper_private;
758
			if (encoder_funcs->detect) {
1179 serge 759
				if (ret != connector_status_connected) {
1123 serge 760
				ret = encoder_funcs->detect(encoder, connector);
761
				if (ret == connector_status_connected) {
1179 serge 762
						radeon_connector->use_digital = false;
763
					}
764
				}
1123 serge 765
					break;
766
				}
767
			}
768
		}
1179 serge 769
 
770
	if ((ret == connector_status_connected) && (radeon_connector->use_digital == false) &&
771
	    encoder) {
772
		ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
1123 serge 773
	}
774
 
1179 serge 775
out:
1123 serge 776
	/* updated in get modes as well since we need to know if it's analog or digital */
777
	radeon_connector_update_scratch_regs(connector, ret);
778
	return ret;
779
}
780
 
781
/* okay need to be smart in here about which encoder to pick */
782
struct drm_encoder *radeon_dvi_encoder(struct drm_connector *connector)
783
{
784
	int enc_id = connector->encoder_ids[0];
785
	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
786
	struct drm_mode_object *obj;
787
	struct drm_encoder *encoder;
788
	int i;
789
	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
790
		if (connector->encoder_ids[i] == 0)
791
			break;
792
 
793
		obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
794
		if (!obj)
795
			continue;
796
 
797
		encoder = obj_to_encoder(obj);
798
 
1179 serge 799
		if (radeon_connector->use_digital == true) {
1123 serge 800
			if (encoder->encoder_type == DRM_MODE_ENCODER_TMDS)
801
				return encoder;
802
		} else {
803
			if (encoder->encoder_type == DRM_MODE_ENCODER_DAC ||
804
			    encoder->encoder_type == DRM_MODE_ENCODER_TVDAC)
805
				return encoder;
806
		}
807
	}
808
 
809
	/* see if we have a default encoder  TODO */
810
 
811
	/* then check use digitial */
812
	/* pick the first one */
813
	if (enc_id) {
814
		obj = drm_mode_object_find(connector->dev, enc_id, DRM_MODE_OBJECT_ENCODER);
815
		if (!obj)
816
			return NULL;
817
		encoder = obj_to_encoder(obj);
818
		return encoder;
819
	}
820
	return NULL;
821
}
822
 
1221 serge 823
static void radeon_dvi_force(struct drm_connector *connector)
824
{
825
	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
826
	if (connector->force == DRM_FORCE_ON)
827
		radeon_connector->use_digital = false;
828
	if (connector->force == DRM_FORCE_ON_DIGITAL)
829
		radeon_connector->use_digital = true;
830
}
831
 
1268 serge 832
static int radeon_dvi_mode_valid(struct drm_connector *connector,
833
				  struct drm_display_mode *mode)
834
{
835
	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
836
 
837
	/* XXX check mode bandwidth */
838
 
839
	if (radeon_connector->use_digital && (mode->clock > 165000)) {
840
		if ((radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_I) ||
841
		    (radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_D) ||
842
		    (radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_HDMI_TYPE_B))
843
			return MODE_OK;
844
		else
845
			return MODE_CLOCK_HIGH;
846
	}
847
	return MODE_OK;
848
}
849
 
1123 serge 850
struct drm_connector_helper_funcs radeon_dvi_connector_helper_funcs = {
851
	.get_modes = radeon_dvi_get_modes,
1268 serge 852
	.mode_valid = radeon_dvi_mode_valid,
1123 serge 853
	.best_encoder = radeon_dvi_encoder,
854
};
855
 
856
struct drm_connector_funcs radeon_dvi_connector_funcs = {
857
	.dpms = drm_helper_connector_dpms,
858
	.detect = radeon_dvi_detect,
859
	.fill_modes = drm_helper_probe_single_connector_modes,
860
	.set_property = radeon_connector_set_property,
861
	.destroy = radeon_connector_destroy,
1221 serge 862
	.force = radeon_dvi_force,
1123 serge 863
};
864
 
865
void
866
radeon_add_atom_connector(struct drm_device *dev,
867
			  uint32_t connector_id,
868
			  uint32_t supported_device,
869
			  int connector_type,
870
			  struct radeon_i2c_bus_rec *i2c_bus,
871
			  bool linkb,
1268 serge 872
			  uint32_t igp_lane_info,
873
			  uint16_t connector_object_id)
1123 serge 874
{
1179 serge 875
	struct radeon_device *rdev = dev->dev_private;
1123 serge 876
	struct drm_connector *connector;
877
	struct radeon_connector *radeon_connector;
878
	struct radeon_connector_atom_dig *radeon_dig_connector;
879
	uint32_t subpixel_order = SubPixelNone;
1268 serge 880
	bool shared_ddc = false;
1221 serge 881
	int ret;
1123 serge 882
 
883
	/* fixme - tv/cv/din */
1179 serge 884
	if (connector_type == DRM_MODE_CONNECTOR_Unknown)
1123 serge 885
		return;
886
 
887
	/* see if we already added it */
888
	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
889
		radeon_connector = to_radeon_connector(connector);
890
		if (radeon_connector->connector_id == connector_id) {
891
			radeon_connector->devices |= supported_device;
892
			return;
893
		}
1268 serge 894
		if (radeon_connector->ddc_bus && i2c_bus->valid) {
895
			if (memcmp(&radeon_connector->ddc_bus->rec, i2c_bus,
896
				    sizeof(struct radeon_i2c_bus_rec)) == 0) {
897
				radeon_connector->shared_ddc = true;
898
				shared_ddc = true;
899
			}
900
		}
1123 serge 901
	}
902
 
903
	radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
904
	if (!radeon_connector)
905
		return;
906
 
907
	connector = &radeon_connector->base;
908
 
909
	radeon_connector->connector_id = connector_id;
910
	radeon_connector->devices = supported_device;
1268 serge 911
	radeon_connector->shared_ddc = shared_ddc;
912
	radeon_connector->connector_object_id = connector_object_id;
1123 serge 913
	switch (connector_type) {
914
	case DRM_MODE_CONNECTOR_VGA:
915
		drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1221 serge 916
		ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
917
		if (ret)
918
			goto failed;
1123 serge 919
		if (i2c_bus->valid) {
920
			radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "VGA");
921
			if (!radeon_connector->ddc_bus)
922
				goto failed;
923
		}
1221 serge 924
		radeon_connector->dac_load_detect = true;
1179 serge 925
		drm_connector_attach_property(&radeon_connector->base,
926
					      rdev->mode_info.load_detect_property,
927
					      1);
1123 serge 928
		break;
929
	case DRM_MODE_CONNECTOR_DVIA:
930
		drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1221 serge 931
		ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
932
		if (ret)
933
			goto failed;
1123 serge 934
		if (i2c_bus->valid) {
935
			radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
936
			if (!radeon_connector->ddc_bus)
937
				goto failed;
938
		}
1221 serge 939
		radeon_connector->dac_load_detect = true;
1179 serge 940
		drm_connector_attach_property(&radeon_connector->base,
941
					      rdev->mode_info.load_detect_property,
942
					      1);
1123 serge 943
		break;
944
	case DRM_MODE_CONNECTOR_DVII:
945
	case DRM_MODE_CONNECTOR_DVID:
946
		radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
947
		if (!radeon_dig_connector)
948
			goto failed;
949
		radeon_dig_connector->linkb = linkb;
950
		radeon_dig_connector->igp_lane_info = igp_lane_info;
951
		radeon_connector->con_priv = radeon_dig_connector;
952
		drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
1221 serge 953
		ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
954
		if (ret)
955
			goto failed;
1123 serge 956
		if (i2c_bus->valid) {
957
			radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
958
			if (!radeon_connector->ddc_bus)
959
				goto failed;
960
		}
961
		subpixel_order = SubPixelHorizontalRGB;
1179 serge 962
		drm_connector_attach_property(&radeon_connector->base,
963
					      rdev->mode_info.coherent_mode_property,
964
					      1);
1221 serge 965
		radeon_connector->dac_load_detect = true;
1179 serge 966
		drm_connector_attach_property(&radeon_connector->base,
967
					      rdev->mode_info.load_detect_property,
968
					      1);
1123 serge 969
		break;
970
	case DRM_MODE_CONNECTOR_HDMIA:
971
	case DRM_MODE_CONNECTOR_HDMIB:
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_dvi_connector_funcs, connector_type);
1221 serge 979
		ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
980
		if (ret)
981
			goto failed;
1123 serge 982
		if (i2c_bus->valid) {
983
			radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "HDMI");
984
			if (!radeon_connector->ddc_bus)
985
				goto failed;
986
		}
1179 serge 987
		drm_connector_attach_property(&radeon_connector->base,
988
					      rdev->mode_info.coherent_mode_property,
989
					      1);
1123 serge 990
		subpixel_order = SubPixelHorizontalRGB;
991
		break;
992
	case DRM_MODE_CONNECTOR_DisplayPort:
993
		radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
994
		if (!radeon_dig_connector)
995
			goto failed;
996
		radeon_dig_connector->linkb = linkb;
997
		radeon_dig_connector->igp_lane_info = igp_lane_info;
998
		radeon_connector->con_priv = radeon_dig_connector;
999
		drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
1221 serge 1000
		ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
1001
		if (ret)
1002
			goto failed;
1123 serge 1003
		if (i2c_bus->valid) {
1004
			radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DP");
1005
			if (!radeon_connector->ddc_bus)
1006
				goto failed;
1007
		}
1008
		subpixel_order = SubPixelHorizontalRGB;
1009
		break;
1010
	case DRM_MODE_CONNECTOR_SVIDEO:
1011
	case DRM_MODE_CONNECTOR_Composite:
1012
	case DRM_MODE_CONNECTOR_9PinDIN:
1179 serge 1013
		if (radeon_tv == 1) {
1014
			drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
1221 serge 1015
			ret = drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
1016
			if (ret)
1017
				goto failed;
1018
			radeon_connector->dac_load_detect = true;
1179 serge 1019
		drm_connector_attach_property(&radeon_connector->base,
1020
					      rdev->mode_info.load_detect_property,
1021
					      1);
1221 serge 1022
		}
1123 serge 1023
		break;
1024
	case DRM_MODE_CONNECTOR_LVDS:
1025
		radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1026
		if (!radeon_dig_connector)
1027
			goto failed;
1028
		radeon_dig_connector->linkb = linkb;
1029
		radeon_dig_connector->igp_lane_info = igp_lane_info;
1030
		radeon_connector->con_priv = radeon_dig_connector;
1031
		drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
1221 serge 1032
		ret = drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
1033
		if (ret)
1034
			goto failed;
1123 serge 1035
		if (i2c_bus->valid) {
1036
			radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "LVDS");
1037
			if (!radeon_connector->ddc_bus)
1038
				goto failed;
1039
		}
1179 serge 1040
		drm_mode_create_scaling_mode_property(dev);
1041
		drm_connector_attach_property(&radeon_connector->base,
1042
					      dev->mode_config.scaling_mode_property,
1043
					      DRM_MODE_SCALE_FULLSCREEN);
1123 serge 1044
		subpixel_order = SubPixelHorizontalRGB;
1045
		break;
1046
	}
1047
 
1048
	connector->display_info.subpixel_order = subpixel_order;
1233 serge 1049
	drm_sysfs_connector_add(connector);
1123 serge 1050
	return;
1051
 
1052
failed:
1053
	if (radeon_connector->ddc_bus)
1054
		radeon_i2c_destroy(radeon_connector->ddc_bus);
1055
	drm_connector_cleanup(connector);
1056
	kfree(connector);
1057
}
1058
 
1059
void
1060
radeon_add_legacy_connector(struct drm_device *dev,
1061
			    uint32_t connector_id,
1062
			    uint32_t supported_device,
1063
			    int connector_type,
1268 serge 1064
			    struct radeon_i2c_bus_rec *i2c_bus,
1065
			    uint16_t connector_object_id)
1123 serge 1066
{
1179 serge 1067
	struct radeon_device *rdev = dev->dev_private;
1123 serge 1068
	struct drm_connector *connector;
1069
	struct radeon_connector *radeon_connector;
1070
	uint32_t subpixel_order = SubPixelNone;
1221 serge 1071
	int ret;
1123 serge 1072
 
1246 serge 1073
    ENTER();
1074
 
1075
    dbgprintf("id %d device %x type %x i2c %x\n",
1076
               connector_id, supported_device, connector_type, i2c_bus);
1123 serge 1077
	/* fixme - tv/cv/din */
1179 serge 1078
	if (connector_type == DRM_MODE_CONNECTOR_Unknown)
1123 serge 1079
		return;
1080
 
1081
	/* see if we already added it */
1082
	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
1083
		radeon_connector = to_radeon_connector(connector);
1084
		if (radeon_connector->connector_id == connector_id) {
1085
			radeon_connector->devices |= supported_device;
1246 serge 1086
            LEAVE();
1123 serge 1087
			return;
1088
		}
1089
	}
1090
 
1091
	radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
1092
	if (!radeon_connector)
1093
		return;
1094
 
1095
	connector = &radeon_connector->base;
1096
 
1097
	radeon_connector->connector_id = connector_id;
1098
	radeon_connector->devices = supported_device;
1268 serge 1099
	radeon_connector->connector_object_id = connector_object_id;
1123 serge 1100
	switch (connector_type) {
1101
	case DRM_MODE_CONNECTOR_VGA:
1102
		drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1221 serge 1103
		ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1104
		if (ret)
1105
			goto failed;
1123 serge 1106
		if (i2c_bus->valid) {
1107
			radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "VGA");
1108
			if (!radeon_connector->ddc_bus)
1109
				goto failed;
1110
		}
1221 serge 1111
		radeon_connector->dac_load_detect = true;
1179 serge 1112
		drm_connector_attach_property(&radeon_connector->base,
1113
					      rdev->mode_info.load_detect_property,
1114
					      1);
1123 serge 1115
		break;
1116
	case DRM_MODE_CONNECTOR_DVIA:
1117
		drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1221 serge 1118
		ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1119
		if (ret)
1120
			goto failed;
1123 serge 1121
		if (i2c_bus->valid) {
1122
			radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
1123
			if (!radeon_connector->ddc_bus)
1124
				goto failed;
1125
		}
1221 serge 1126
		radeon_connector->dac_load_detect = true;
1179 serge 1127
		drm_connector_attach_property(&radeon_connector->base,
1128
					      rdev->mode_info.load_detect_property,
1129
					      1);
1123 serge 1130
		break;
1131
	case DRM_MODE_CONNECTOR_DVII:
1132
	case DRM_MODE_CONNECTOR_DVID:
1133
		drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
1221 serge 1134
		ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
1135
		if (ret)
1136
			goto failed;
1123 serge 1137
		if (i2c_bus->valid) {
1138
			radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
1139
			if (!radeon_connector->ddc_bus)
1140
				goto failed;
1221 serge 1141
			radeon_connector->dac_load_detect = true;
1179 serge 1142
			drm_connector_attach_property(&radeon_connector->base,
1143
						      rdev->mode_info.load_detect_property,
1144
						      1);
1123 serge 1145
		}
1146
		subpixel_order = SubPixelHorizontalRGB;
1147
		break;
1148
	case DRM_MODE_CONNECTOR_SVIDEO:
1149
	case DRM_MODE_CONNECTOR_Composite:
1150
	case DRM_MODE_CONNECTOR_9PinDIN:
1179 serge 1151
		if (radeon_tv == 1) {
1152
			drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
1221 serge 1153
			ret = drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
1154
			if (ret)
1155
				goto failed;
1156
			radeon_connector->dac_load_detect = true;
1179 serge 1157
			drm_connector_attach_property(&radeon_connector->base,
1158
						      rdev->mode_info.load_detect_property,
1159
						      1);
1160
		}
1123 serge 1161
		break;
1162
	case DRM_MODE_CONNECTOR_LVDS:
1163
		drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
1221 serge 1164
		ret = drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
1165
		if (ret)
1166
			goto failed;
1123 serge 1167
		if (i2c_bus->valid) {
1168
			radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "LVDS");
1169
			if (!radeon_connector->ddc_bus)
1170
				goto failed;
1171
		}
1179 serge 1172
		drm_connector_attach_property(&radeon_connector->base,
1173
					      dev->mode_config.scaling_mode_property,
1174
					      DRM_MODE_SCALE_FULLSCREEN);
1123 serge 1175
		subpixel_order = SubPixelHorizontalRGB;
1176
		break;
1177
	}
1178
 
1179
	connector->display_info.subpixel_order = subpixel_order;
1233 serge 1180
	drm_sysfs_connector_add(connector);
1246 serge 1181
    LEAVE();
1123 serge 1182
	return;
1183
 
1184
failed:
1185
	if (radeon_connector->ddc_bus)
1186
		radeon_i2c_destroy(radeon_connector->ddc_bus);
1187
	drm_connector_cleanup(connector);
1188
	kfree(connector);
1246 serge 1189
    LEAVE();
1123 serge 1190
}