Subversion Repositories Kolibri OS

Rev

Rev 1404 | Rev 1430 | 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
 
1321 serge 43
void radeon_connector_hotplug(struct drm_connector *connector)
44
{
45
	struct drm_device *dev = connector->dev;
46
	struct radeon_device *rdev = dev->dev_private;
47
	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
48
 
49
	if (radeon_connector->hpd.hpd != RADEON_HPD_NONE)
50
		radeon_hpd_set_polarity(rdev, radeon_connector->hpd.hpd);
51
 
1403 serge 52
	if ((connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort) ||
53
	    (connector->connector_type == DRM_MODE_CONNECTOR_eDP)) {
54
		if ((radeon_dp_getsinktype(radeon_connector) == CONNECTOR_OBJECT_ID_DISPLAYPORT) ||
55
		    (radeon_dp_getsinktype(radeon_connector) == CONNECTOR_OBJECT_ID_eDP)) {
1321 serge 56
			if (radeon_dp_needs_link_train(radeon_connector)) {
57
				if (connector->encoder)
58
					dp_link_train(connector->encoder, connector);
59
			}
60
		}
61
	}
62
 
63
}
64
 
1179 serge 65
static void radeon_property_change_mode(struct drm_encoder *encoder)
66
{
67
	struct drm_crtc *crtc = encoder->crtc;
68
 
69
	if (crtc && crtc->enabled) {
70
		drm_crtc_helper_set_mode(crtc, &crtc->mode,
71
					 crtc->x, crtc->y, crtc->fb);
72
	}
73
}
1123 serge 74
static void
75
radeon_connector_update_scratch_regs(struct drm_connector *connector, enum drm_connector_status status)
76
{
77
	struct drm_device *dev = connector->dev;
78
	struct radeon_device *rdev = dev->dev_private;
79
	struct drm_encoder *best_encoder = NULL;
80
	struct drm_encoder *encoder = NULL;
81
	struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
82
	struct drm_mode_object *obj;
83
	bool connected;
84
	int i;
85
 
86
	best_encoder = connector_funcs->best_encoder(connector);
87
 
88
	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
89
		if (connector->encoder_ids[i] == 0)
90
			break;
91
 
92
		obj = drm_mode_object_find(connector->dev,
93
					   connector->encoder_ids[i],
94
					   DRM_MODE_OBJECT_ENCODER);
95
		if (!obj)
96
			continue;
97
 
98
		encoder = obj_to_encoder(obj);
99
 
100
		if ((encoder == best_encoder) && (status == connector_status_connected))
101
			connected = true;
102
		else
103
			connected = false;
104
 
105
		if (rdev->is_atom_bios)
106
			radeon_atombios_connected_scratch_regs(connector, encoder, connected);
107
		else
108
			radeon_combios_connected_scratch_regs(connector, encoder, connected);
109
 
110
	}
111
}
112
 
1179 serge 113
struct drm_encoder *radeon_find_encoder(struct drm_connector *connector, int encoder_type)
114
{
115
	struct drm_mode_object *obj;
116
	struct drm_encoder *encoder;
117
	int i;
118
 
119
	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
120
		if (connector->encoder_ids[i] == 0)
121
			break;
122
 
123
		obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
124
		if (!obj)
125
			continue;
126
 
127
		encoder = obj_to_encoder(obj);
128
		if (encoder->encoder_type == encoder_type)
129
			return encoder;
130
	}
131
	return NULL;
132
}
133
 
1123 serge 134
struct drm_encoder *radeon_best_single_encoder(struct drm_connector *connector)
135
{
136
	int enc_id = connector->encoder_ids[0];
137
	struct drm_mode_object *obj;
138
	struct drm_encoder *encoder;
139
 
140
	/* pick the encoder ids */
141
	if (enc_id) {
142
		obj = drm_mode_object_find(connector->dev, enc_id, DRM_MODE_OBJECT_ENCODER);
143
		if (!obj)
144
			return NULL;
145
		encoder = obj_to_encoder(obj);
146
		return encoder;
147
	}
148
	return NULL;
149
}
150
 
1179 serge 151
/*
152
 * radeon_connector_analog_encoder_conflict_solve
153
 * - search for other connectors sharing this encoder
154
 *   if priority is true, then set them disconnected if this is connected
155
 *   if priority is false, set us disconnected if they are connected
156
 */
157
static enum drm_connector_status
158
radeon_connector_analog_encoder_conflict_solve(struct drm_connector *connector,
159
					       struct drm_encoder *encoder,
160
					       enum drm_connector_status current_status,
161
					       bool priority)
162
{
163
	struct drm_device *dev = connector->dev;
164
	struct drm_connector *conflict;
165
	int i;
166
 
167
	list_for_each_entry(conflict, &dev->mode_config.connector_list, head) {
168
		if (conflict == connector)
169
			continue;
170
 
171
		for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
172
			if (conflict->encoder_ids[i] == 0)
173
				break;
174
 
175
			/* if the IDs match */
176
			if (conflict->encoder_ids[i] == encoder->base.id) {
177
				if (conflict->status != connector_status_connected)
178
					continue;
179
 
180
				if (priority == true) {
181
					DRM_INFO("1: conflicting encoders switching off %s\n", drm_get_connector_name(conflict));
182
					DRM_INFO("in favor of %s\n", drm_get_connector_name(connector));
183
					conflict->status = connector_status_disconnected;
184
					radeon_connector_update_scratch_regs(conflict, connector_status_disconnected);
185
				} else {
186
					DRM_INFO("2: conflicting encoders switching off %s\n", drm_get_connector_name(connector));
187
					DRM_INFO("in favor of %s\n", drm_get_connector_name(conflict));
188
					current_status = connector_status_disconnected;
189
				}
190
				break;
191
			}
192
		}
193
	}
194
	return current_status;
195
 
196
}
197
 
1123 serge 198
static struct drm_display_mode *radeon_fp_native_mode(struct drm_encoder *encoder)
199
{
200
	struct drm_device *dev = encoder->dev;
201
	struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
202
	struct drm_display_mode *mode = NULL;
1268 serge 203
	struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
1123 serge 204
 
1268 serge 205
	if (native_mode->hdisplay != 0 &&
206
	    native_mode->vdisplay != 0 &&
207
	    native_mode->clock != 0) {
208
		mode = drm_mode_duplicate(dev, native_mode);
1123 serge 209
		mode->type = DRM_MODE_TYPE_PREFERRED | DRM_MODE_TYPE_DRIVER;
210
		drm_mode_set_name(mode);
211
 
212
		DRM_DEBUG("Adding native panel mode %s\n", mode->name);
1403 serge 213
	} else if (native_mode->hdisplay != 0 &&
214
		   native_mode->vdisplay != 0) {
215
		/* mac laptops without an edid */
216
		/* Note that this is not necessarily the exact panel mode,
217
		 * but an approximation based on the cvt formula.  For these
218
		 * systems we should ideally read the mode info out of the
219
		 * registers or add a mode table, but this works and is much
220
		 * simpler.
221
		 */
222
		mode = drm_cvt_mode(dev, native_mode->hdisplay, native_mode->vdisplay, 60, true, false, false);
223
		mode->type = DRM_MODE_TYPE_PREFERRED | DRM_MODE_TYPE_DRIVER;
224
		DRM_DEBUG("Adding cvt approximation of native panel mode %s\n", mode->name);
1123 serge 225
	}
226
	return mode;
227
}
228
 
1179 serge 229
static void radeon_add_common_modes(struct drm_encoder *encoder, struct drm_connector *connector)
230
{
231
	struct drm_device *dev = encoder->dev;
232
	struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
233
	struct drm_display_mode *mode = NULL;
1268 serge 234
	struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
1179 serge 235
	int i;
236
	struct mode_size {
237
		int w;
238
		int h;
239
	} common_modes[17] = {
240
		{ 640,  480},
241
		{ 720,  480},
242
		{ 800,  600},
243
		{ 848,  480},
244
		{1024,  768},
245
		{1152,  768},
246
		{1280,  720},
247
		{1280,  800},
248
		{1280,  854},
249
		{1280,  960},
250
		{1280, 1024},
251
		{1440,  900},
252
		{1400, 1050},
253
		{1680, 1050},
254
		{1600, 1200},
255
		{1920, 1080},
256
		{1920, 1200}
257
	};
258
 
259
	for (i = 0; i < 17; i++) {
1268 serge 260
		if (radeon_encoder->devices & (ATOM_DEVICE_TV_SUPPORT)) {
261
			if (common_modes[i].w > 1024 ||
262
			    common_modes[i].h > 768)
263
				continue;
264
		}
1179 serge 265
		if (radeon_encoder->devices & (ATOM_DEVICE_LCD_SUPPORT)) {
1268 serge 266
			if (common_modes[i].w > native_mode->hdisplay ||
267
			    common_modes[i].h > native_mode->vdisplay ||
268
			    (common_modes[i].w == native_mode->hdisplay &&
269
			     common_modes[i].h == native_mode->vdisplay))
1179 serge 270
				continue;
271
		}
272
		if (common_modes[i].w < 320 || common_modes[i].h < 200)
273
			continue;
274
 
1221 serge 275
		mode = drm_cvt_mode(dev, common_modes[i].w, common_modes[i].h, 60, false, false, false);
1179 serge 276
		drm_mode_probed_add(connector, mode);
277
	}
278
}
279
 
1123 serge 280
int radeon_connector_set_property(struct drm_connector *connector, struct drm_property *property,
281
				  uint64_t val)
282
{
1179 serge 283
	struct drm_device *dev = connector->dev;
284
	struct radeon_device *rdev = dev->dev_private;
285
	struct drm_encoder *encoder;
286
	struct radeon_encoder *radeon_encoder;
287
 
288
	if (property == rdev->mode_info.coherent_mode_property) {
289
		struct radeon_encoder_atom_dig *dig;
290
 
291
		/* need to find digital encoder on connector */
292
		encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
293
		if (!encoder)
294
			return 0;
295
 
296
		radeon_encoder = to_radeon_encoder(encoder);
297
 
298
		if (!radeon_encoder->enc_priv)
299
			return 0;
300
 
301
		dig = radeon_encoder->enc_priv;
302
		dig->coherent_mode = val ? true : false;
303
		radeon_property_change_mode(&radeon_encoder->base);
304
	}
305
 
306
	if (property == rdev->mode_info.tv_std_property) {
307
		encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TVDAC);
308
		if (!encoder) {
309
			encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_DAC);
310
		}
311
 
312
		if (!encoder)
313
			return 0;
314
 
315
		radeon_encoder = to_radeon_encoder(encoder);
316
		if (!radeon_encoder->enc_priv)
317
			return 0;
318
		if (rdev->is_atom_bios) {
319
			struct radeon_encoder_atom_dac *dac_int;
320
			dac_int = radeon_encoder->enc_priv;
321
			dac_int->tv_std = val;
322
		} else {
323
			struct radeon_encoder_tv_dac *dac_int;
324
			dac_int = radeon_encoder->enc_priv;
325
			dac_int->tv_std = val;
326
		}
327
		radeon_property_change_mode(&radeon_encoder->base);
328
	}
329
 
330
	if (property == rdev->mode_info.load_detect_property) {
331
		struct radeon_connector *radeon_connector =
332
			to_radeon_connector(connector);
333
 
334
		if (val == 0)
335
			radeon_connector->dac_load_detect = false;
336
		else
337
			radeon_connector->dac_load_detect = true;
338
	}
339
 
340
	if (property == rdev->mode_info.tmds_pll_property) {
341
		struct radeon_encoder_int_tmds *tmds = NULL;
342
		bool ret = false;
343
		/* need to find digital encoder on connector */
344
		encoder = radeon_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
345
		if (!encoder)
346
			return 0;
347
 
348
		radeon_encoder = to_radeon_encoder(encoder);
349
 
350
		tmds = radeon_encoder->enc_priv;
351
		if (!tmds)
352
			return 0;
353
 
354
		if (val == 0) {
355
			if (rdev->is_atom_bios)
356
				ret = radeon_atombios_get_tmds_info(radeon_encoder, tmds);
357
			else
358
				ret = radeon_legacy_get_tmds_info_from_combios(radeon_encoder, tmds);
359
		}
360
		if (val == 1 || ret == false) {
361
			radeon_legacy_get_tmds_info_from_table(radeon_encoder, tmds);
362
		}
363
		radeon_property_change_mode(&radeon_encoder->base);
364
	}
365
 
1123 serge 366
	return 0;
367
}
368
 
1179 serge 369
static void radeon_fixup_lvds_native_mode(struct drm_encoder *encoder,
370
					  struct drm_connector *connector)
371
{
372
	struct radeon_encoder *radeon_encoder =	to_radeon_encoder(encoder);
1268 serge 373
	struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
1123 serge 374
 
1179 serge 375
	/* Try to get native mode details from EDID if necessary */
1268 serge 376
	if (!native_mode->clock) {
1179 serge 377
		struct drm_display_mode *t, *mode;
378
 
379
		list_for_each_entry_safe(mode, t, &connector->probed_modes, head) {
1268 serge 380
			if (mode->hdisplay == native_mode->hdisplay &&
381
			    mode->vdisplay == native_mode->vdisplay) {
382
				*native_mode = *mode;
383
				drm_mode_set_crtcinfo(native_mode, CRTC_INTERLACE_HALVE_V);
1179 serge 384
				DRM_INFO("Determined LVDS native mode details from EDID\n");
385
				break;
386
			}
387
		}
388
	}
1268 serge 389
	if (!native_mode->clock) {
1179 serge 390
		DRM_INFO("No LVDS native mode details, disabling RMX\n");
391
		radeon_encoder->rmx_type = RMX_OFF;
392
	}
393
}
394
 
1123 serge 395
static int radeon_lvds_get_modes(struct drm_connector *connector)
396
{
397
	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
398
	struct drm_encoder *encoder;
399
	int ret = 0;
400
	struct drm_display_mode *mode;
401
 
402
	if (radeon_connector->ddc_bus) {
403
		ret = radeon_ddc_get_modes(radeon_connector);
404
		if (ret > 0) {
1179 serge 405
			encoder = radeon_best_single_encoder(connector);
406
			if (encoder) {
407
				radeon_fixup_lvds_native_mode(encoder, connector);
408
				/* add scaled modes */
409
				radeon_add_common_modes(encoder, connector);
410
			}
1123 serge 411
			return ret;
412
		}
413
	}
414
 
415
	encoder = radeon_best_single_encoder(connector);
416
	if (!encoder)
417
		return 0;
418
 
419
	/* we have no EDID modes */
420
	mode = radeon_fp_native_mode(encoder);
421
	if (mode) {
422
		ret = 1;
423
		drm_mode_probed_add(connector, mode);
1179 serge 424
		/* add scaled modes */
425
		radeon_add_common_modes(encoder, connector);
1123 serge 426
	}
1179 serge 427
 
1123 serge 428
	return ret;
429
}
430
 
431
static int radeon_lvds_mode_valid(struct drm_connector *connector,
432
				  struct drm_display_mode *mode)
433
{
1268 serge 434
	struct drm_encoder *encoder = radeon_best_single_encoder(connector);
435
 
436
	if ((mode->hdisplay < 320) || (mode->vdisplay < 240))
437
		return MODE_PANEL;
438
 
439
	if (encoder) {
440
		struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
441
		struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
442
 
443
		/* AVIVO hardware supports downscaling modes larger than the panel
444
		 * to the panel size, but I'm not sure this is desirable.
445
		 */
446
		if ((mode->hdisplay > native_mode->hdisplay) ||
447
		    (mode->vdisplay > native_mode->vdisplay))
448
			return MODE_PANEL;
449
 
450
		/* if scaling is disabled, block non-native modes */
451
		if (radeon_encoder->rmx_type == RMX_OFF) {
452
			if ((mode->hdisplay != native_mode->hdisplay) ||
453
			    (mode->vdisplay != native_mode->vdisplay))
454
				return MODE_PANEL;
455
		}
456
	}
457
 
1123 serge 458
	return MODE_OK;
459
}
460
 
461
static enum drm_connector_status radeon_lvds_detect(struct drm_connector *connector)
462
{
1268 serge 463
	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
464
	struct drm_encoder *encoder = radeon_best_single_encoder(connector);
465
	enum drm_connector_status ret = connector_status_disconnected;
466
 
467
	if (encoder) {
468
		struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
469
		struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
470
 
471
		/* check if panel is valid */
472
		if (native_mode->hdisplay >= 320 && native_mode->vdisplay >= 240)
473
			ret = connector_status_connected;
474
 
475
	}
476
 
477
	/* check for edid as well */
478
	if (radeon_connector->edid)
479
		ret = connector_status_connected;
480
	else {
481
		if (radeon_connector->ddc_bus) {
1321 serge 482
			radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
1268 serge 483
			radeon_connector->edid = drm_get_edid(&radeon_connector->base,
484
							      &radeon_connector->ddc_bus->adapter);
1321 serge 485
			radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
1268 serge 486
			if (radeon_connector->edid)
487
				ret = connector_status_connected;
488
		}
489
	}
1123 serge 490
	/* check acpi lid status ??? */
1268 serge 491
 
1123 serge 492
	radeon_connector_update_scratch_regs(connector, ret);
493
	return ret;
494
}
495
 
496
static void radeon_connector_destroy(struct drm_connector *connector)
497
{
498
	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
499
 
500
	if (radeon_connector->ddc_bus)
501
		radeon_i2c_destroy(radeon_connector->ddc_bus);
1268 serge 502
	if (radeon_connector->edid)
503
		kfree(radeon_connector->edid);
1123 serge 504
	kfree(radeon_connector->con_priv);
1233 serge 505
	drm_sysfs_connector_remove(connector);
1123 serge 506
	drm_connector_cleanup(connector);
507
	kfree(connector);
508
}
509
 
1179 serge 510
static int radeon_lvds_set_property(struct drm_connector *connector,
511
				    struct drm_property *property,
512
				    uint64_t value)
513
{
514
	struct drm_device *dev = connector->dev;
515
	struct radeon_encoder *radeon_encoder;
516
	enum radeon_rmx_type rmx_type;
517
 
518
	DRM_DEBUG("\n");
519
	if (property != dev->mode_config.scaling_mode_property)
520
		return 0;
521
 
522
	if (connector->encoder)
523
		radeon_encoder = to_radeon_encoder(connector->encoder);
524
	else {
525
		struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
526
		radeon_encoder = to_radeon_encoder(connector_funcs->best_encoder(connector));
527
	}
528
 
529
	switch (value) {
530
	case DRM_MODE_SCALE_NONE: rmx_type = RMX_OFF; break;
531
	case DRM_MODE_SCALE_CENTER: rmx_type = RMX_CENTER; break;
532
	case DRM_MODE_SCALE_ASPECT: rmx_type = RMX_ASPECT; break;
533
	default:
534
	case DRM_MODE_SCALE_FULLSCREEN: rmx_type = RMX_FULL; break;
535
	}
536
	if (radeon_encoder->rmx_type == rmx_type)
537
		return 0;
538
 
539
	radeon_encoder->rmx_type = rmx_type;
540
 
541
	radeon_property_change_mode(&radeon_encoder->base);
542
	return 0;
543
}
544
 
545
 
1123 serge 546
struct drm_connector_helper_funcs radeon_lvds_connector_helper_funcs = {
547
	.get_modes = radeon_lvds_get_modes,
548
	.mode_valid = radeon_lvds_mode_valid,
549
	.best_encoder = radeon_best_single_encoder,
550
};
551
 
552
struct drm_connector_funcs radeon_lvds_connector_funcs = {
553
	.dpms = drm_helper_connector_dpms,
554
	.detect = radeon_lvds_detect,
555
	.fill_modes = drm_helper_probe_single_connector_modes,
556
	.destroy = radeon_connector_destroy,
1179 serge 557
	.set_property = radeon_lvds_set_property,
1123 serge 558
};
559
 
560
static int radeon_vga_get_modes(struct drm_connector *connector)
561
{
562
	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
563
	int ret;
564
 
565
	ret = radeon_ddc_get_modes(radeon_connector);
566
 
567
	return ret;
568
}
569
 
570
static int radeon_vga_mode_valid(struct drm_connector *connector,
571
				  struct drm_display_mode *mode)
572
{
1268 serge 573
	/* XXX check mode bandwidth */
574
	/* XXX verify against max DAC output frequency */
1123 serge 575
	return MODE_OK;
576
}
577
 
578
static enum drm_connector_status radeon_vga_detect(struct drm_connector *connector)
579
{
580
	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
581
	struct drm_encoder *encoder;
582
	struct drm_encoder_helper_funcs *encoder_funcs;
1404 serge 583
	bool dret = false;
1123 serge 584
	enum drm_connector_status ret = connector_status_disconnected;
585
 
1179 serge 586
	encoder = radeon_best_single_encoder(connector);
587
	if (!encoder)
588
		ret = connector_status_disconnected;
589
 
1404 serge 590
	if (radeon_connector->ddc_bus) {
591
	    radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
592
	    dret = radeon_ddc_probe(radeon_connector);
593
	    radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
594
	}
1268 serge 595
	if (dret) {
596
		if (radeon_connector->edid) {
597
			kfree(radeon_connector->edid);
598
			radeon_connector->edid = NULL;
599
		}
1321 serge 600
		radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
1268 serge 601
		radeon_connector->edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
1321 serge 602
		radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
1268 serge 603
 
604
		if (!radeon_connector->edid) {
1313 serge 605
			DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
1268 serge 606
				  drm_get_connector_name(connector));
1313 serge 607
			ret = connector_status_connected;
1268 serge 608
		} else {
609
			radeon_connector->use_digital = !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
610
 
611
			/* some oems have boards with separate digital and analog connectors
612
			 * with a shared ddc line (often vga + hdmi)
613
			 */
614
			if (radeon_connector->use_digital && radeon_connector->shared_ddc) {
615
				kfree(radeon_connector->edid);
616
				radeon_connector->edid = NULL;
617
				ret = connector_status_disconnected;
618
			} else
1123 serge 619
		ret = connector_status_connected;
1268 serge 620
		}
621
	} else {
1403 serge 622
		if (radeon_connector->dac_load_detect && encoder) {
1123 serge 623
			encoder_funcs = encoder->helper_private;
624
			ret = encoder_funcs->detect(encoder, connector);
625
		}
626
	}
627
 
1179 serge 628
	if (ret == connector_status_connected)
629
		ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
1123 serge 630
	radeon_connector_update_scratch_regs(connector, ret);
631
	return ret;
632
}
633
 
634
struct drm_connector_helper_funcs radeon_vga_connector_helper_funcs = {
635
	.get_modes = radeon_vga_get_modes,
636
	.mode_valid = radeon_vga_mode_valid,
637
	.best_encoder = radeon_best_single_encoder,
638
};
639
 
640
struct drm_connector_funcs radeon_vga_connector_funcs = {
641
	.dpms = drm_helper_connector_dpms,
642
	.detect = radeon_vga_detect,
643
	.fill_modes = drm_helper_probe_single_connector_modes,
644
	.destroy = radeon_connector_destroy,
645
	.set_property = radeon_connector_set_property,
646
};
647
 
1179 serge 648
static int radeon_tv_get_modes(struct drm_connector *connector)
649
{
650
	struct drm_device *dev = connector->dev;
651
	struct radeon_device *rdev = dev->dev_private;
652
	struct drm_display_mode *tv_mode;
653
	struct drm_encoder *encoder;
654
 
655
	encoder = radeon_best_single_encoder(connector);
656
	if (!encoder)
657
		return 0;
658
 
659
	/* avivo chips can scale any mode */
660
	if (rdev->family >= CHIP_RS600)
661
		/* add scaled modes */
662
		radeon_add_common_modes(encoder, connector);
663
	else {
664
		/* only 800x600 is supported right now on pre-avivo chips */
1221 serge 665
		tv_mode = drm_cvt_mode(dev, 800, 600, 60, false, false, false);
1179 serge 666
		tv_mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
667
		drm_mode_probed_add(connector, tv_mode);
668
	}
669
	return 1;
670
}
671
 
672
static int radeon_tv_mode_valid(struct drm_connector *connector,
673
				struct drm_display_mode *mode)
674
{
1268 serge 675
	if ((mode->hdisplay > 1024) || (mode->vdisplay > 768))
676
		return MODE_CLOCK_RANGE;
1179 serge 677
	return MODE_OK;
678
}
679
 
680
static enum drm_connector_status radeon_tv_detect(struct drm_connector *connector)
681
{
682
	struct drm_encoder *encoder;
683
	struct drm_encoder_helper_funcs *encoder_funcs;
684
	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
685
	enum drm_connector_status ret = connector_status_disconnected;
686
 
687
	if (!radeon_connector->dac_load_detect)
688
		return ret;
689
 
690
	encoder = radeon_best_single_encoder(connector);
691
	if (!encoder)
692
		ret = connector_status_disconnected;
693
	else {
694
		encoder_funcs = encoder->helper_private;
695
		ret = encoder_funcs->detect(encoder, connector);
696
	}
697
	if (ret == connector_status_connected)
698
		ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, false);
699
	radeon_connector_update_scratch_regs(connector, ret);
700
	return ret;
701
}
702
 
703
struct drm_connector_helper_funcs radeon_tv_connector_helper_funcs = {
704
	.get_modes = radeon_tv_get_modes,
705
	.mode_valid = radeon_tv_mode_valid,
706
	.best_encoder = radeon_best_single_encoder,
707
};
708
 
709
struct drm_connector_funcs radeon_tv_connector_funcs = {
710
	.dpms = drm_helper_connector_dpms,
711
	.detect = radeon_tv_detect,
712
	.fill_modes = drm_helper_probe_single_connector_modes,
713
	.destroy = radeon_connector_destroy,
714
	.set_property = radeon_connector_set_property,
715
};
716
 
1123 serge 717
static int radeon_dvi_get_modes(struct drm_connector *connector)
718
{
719
	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
720
	int ret;
721
 
722
	ret = radeon_ddc_get_modes(radeon_connector);
723
	return ret;
724
}
725
 
1179 serge 726
/*
727
 * DVI is complicated
728
 * Do a DDC probe, if DDC probe passes, get the full EDID so
729
 * we can do analog/digital monitor detection at this point.
730
 * If the monitor is an analog monitor or we got no DDC,
731
 * we need to find the DAC encoder object for this connector.
732
 * If we got no DDC, we do load detection on the DAC encoder object.
733
 * If we got analog DDC or load detection passes on the DAC encoder
734
 * we have to check if this analog encoder is shared with anyone else (TV)
735
 * if its shared we have to set the other connector to disconnected.
736
 */
1123 serge 737
static enum drm_connector_status radeon_dvi_detect(struct drm_connector *connector)
738
{
739
	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1179 serge 740
	struct drm_encoder *encoder = NULL;
1123 serge 741
	struct drm_encoder_helper_funcs *encoder_funcs;
742
	struct drm_mode_object *obj;
743
	int i;
744
	enum drm_connector_status ret = connector_status_disconnected;
1404 serge 745
	bool dret = false;
1123 serge 746
 
1404 serge 747
	if (radeon_connector->ddc_bus) {
1321 serge 748
	radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
1123 serge 749
	dret = radeon_ddc_probe(radeon_connector);
1321 serge 750
	radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
1404 serge 751
	}
1179 serge 752
	if (dret) {
1268 serge 753
		if (radeon_connector->edid) {
754
			kfree(radeon_connector->edid);
755
			radeon_connector->edid = NULL;
756
		}
1321 serge 757
		radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
1179 serge 758
		radeon_connector->edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
1321 serge 759
		radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
1179 serge 760
 
761
		if (!radeon_connector->edid) {
1313 serge 762
			DRM_ERROR("%s: probed a monitor but no|invalid EDID\n",
1179 serge 763
				  drm_get_connector_name(connector));
764
		} else {
765
			radeon_connector->use_digital = !!(radeon_connector->edid->input & DRM_EDID_INPUT_DIGITAL);
766
 
1268 serge 767
			/* some oems have boards with separate digital and analog connectors
768
			 * with a shared ddc line (often vga + hdmi)
769
			 */
770
			if ((!radeon_connector->use_digital) && radeon_connector->shared_ddc) {
771
				kfree(radeon_connector->edid);
772
				radeon_connector->edid = NULL;
773
				ret = connector_status_disconnected;
774
			} else
1123 serge 775
		ret = connector_status_connected;
1321 serge 776
 
777
			/* multiple connectors on the same encoder with the same ddc line
778
			 * This tends to be HDMI and DVI on the same encoder with the
779
			 * same ddc line.  If the edid says HDMI, consider the HDMI port
780
			 * connected and the DVI port disconnected.  If the edid doesn't
781
			 * say HDMI, vice versa.
782
			 */
1428 serge 783
			if (radeon_connector->shared_ddc && (ret == connector_status_connected)) {
1321 serge 784
				struct drm_device *dev = connector->dev;
785
				struct drm_connector *list_connector;
786
				struct radeon_connector *list_radeon_connector;
787
				list_for_each_entry(list_connector, &dev->mode_config.connector_list, head) {
788
					if (connector == list_connector)
789
						continue;
790
					list_radeon_connector = to_radeon_connector(list_connector);
791
					if (radeon_connector->devices == list_radeon_connector->devices) {
792
						if (drm_detect_hdmi_monitor(radeon_connector->edid)) {
793
							if (connector->connector_type == DRM_MODE_CONNECTOR_DVID) {
794
								kfree(radeon_connector->edid);
795
								radeon_connector->edid = NULL;
796
								ret = connector_status_disconnected;
797
							}
798
						} else {
799
							if ((connector->connector_type == DRM_MODE_CONNECTOR_HDMIA) ||
800
							    (connector->connector_type == DRM_MODE_CONNECTOR_HDMIB)) {
801
								kfree(radeon_connector->edid);
802
								radeon_connector->edid = NULL;
803
								ret = connector_status_disconnected;
804
							}
805
						}
806
					}
807
				}
808
			}
1179 serge 809
		}
810
	}
811
 
812
	if ((ret == connector_status_connected) && (radeon_connector->use_digital == true))
813
		goto out;
814
 
815
	/* find analog encoder */
816
	if (radeon_connector->dac_load_detect) {
1123 serge 817
		for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
818
			if (connector->encoder_ids[i] == 0)
819
				break;
820
 
821
			obj = drm_mode_object_find(connector->dev,
822
						   connector->encoder_ids[i],
823
						   DRM_MODE_OBJECT_ENCODER);
824
			if (!obj)
825
				continue;
826
 
827
			encoder = obj_to_encoder(obj);
828
 
829
			encoder_funcs = encoder->helper_private;
830
			if (encoder_funcs->detect) {
1179 serge 831
				if (ret != connector_status_connected) {
1123 serge 832
				ret = encoder_funcs->detect(encoder, connector);
833
				if (ret == connector_status_connected) {
1179 serge 834
						radeon_connector->use_digital = false;
835
					}
836
				}
1123 serge 837
					break;
838
				}
839
			}
840
		}
1179 serge 841
 
842
	if ((ret == connector_status_connected) && (radeon_connector->use_digital == false) &&
843
	    encoder) {
844
		ret = radeon_connector_analog_encoder_conflict_solve(connector, encoder, ret, true);
1123 serge 845
	}
846
 
1179 serge 847
out:
1123 serge 848
	/* updated in get modes as well since we need to know if it's analog or digital */
849
	radeon_connector_update_scratch_regs(connector, ret);
850
	return ret;
851
}
852
 
853
/* okay need to be smart in here about which encoder to pick */
854
struct drm_encoder *radeon_dvi_encoder(struct drm_connector *connector)
855
{
856
	int enc_id = connector->encoder_ids[0];
857
	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
858
	struct drm_mode_object *obj;
859
	struct drm_encoder *encoder;
860
	int i;
861
	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
862
		if (connector->encoder_ids[i] == 0)
863
			break;
864
 
865
		obj = drm_mode_object_find(connector->dev, connector->encoder_ids[i], DRM_MODE_OBJECT_ENCODER);
866
		if (!obj)
867
			continue;
868
 
869
		encoder = obj_to_encoder(obj);
870
 
1179 serge 871
		if (radeon_connector->use_digital == true) {
1123 serge 872
			if (encoder->encoder_type == DRM_MODE_ENCODER_TMDS)
873
				return encoder;
874
		} else {
875
			if (encoder->encoder_type == DRM_MODE_ENCODER_DAC ||
876
			    encoder->encoder_type == DRM_MODE_ENCODER_TVDAC)
877
				return encoder;
878
		}
879
	}
880
 
881
	/* see if we have a default encoder  TODO */
882
 
883
	/* then check use digitial */
884
	/* pick the first one */
885
	if (enc_id) {
886
		obj = drm_mode_object_find(connector->dev, enc_id, DRM_MODE_OBJECT_ENCODER);
887
		if (!obj)
888
			return NULL;
889
		encoder = obj_to_encoder(obj);
890
		return encoder;
891
	}
892
	return NULL;
893
}
894
 
1221 serge 895
static void radeon_dvi_force(struct drm_connector *connector)
896
{
897
	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
898
	if (connector->force == DRM_FORCE_ON)
899
		radeon_connector->use_digital = false;
900
	if (connector->force == DRM_FORCE_ON_DIGITAL)
901
		radeon_connector->use_digital = true;
902
}
903
 
1268 serge 904
static int radeon_dvi_mode_valid(struct drm_connector *connector,
905
				  struct drm_display_mode *mode)
906
{
1403 serge 907
	struct drm_device *dev = connector->dev;
908
	struct radeon_device *rdev = dev->dev_private;
1268 serge 909
	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
910
 
911
	/* XXX check mode bandwidth */
912
 
1403 serge 913
	/* clocks over 135 MHz have heat issues with DVI on RV100 */
914
	if (radeon_connector->use_digital &&
915
	    (rdev->family == CHIP_RV100) &&
916
	    (mode->clock > 135000))
917
		return MODE_CLOCK_HIGH;
918
 
1268 serge 919
	if (radeon_connector->use_digital && (mode->clock > 165000)) {
920
		if ((radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_I) ||
921
		    (radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_D) ||
922
		    (radeon_connector->connector_object_id == CONNECTOR_OBJECT_ID_HDMI_TYPE_B))
923
			return MODE_OK;
924
		else
925
			return MODE_CLOCK_HIGH;
926
	}
927
	return MODE_OK;
928
}
929
 
1123 serge 930
struct drm_connector_helper_funcs radeon_dvi_connector_helper_funcs = {
931
	.get_modes = radeon_dvi_get_modes,
1268 serge 932
	.mode_valid = radeon_dvi_mode_valid,
1123 serge 933
	.best_encoder = radeon_dvi_encoder,
934
};
935
 
936
struct drm_connector_funcs radeon_dvi_connector_funcs = {
937
	.dpms = drm_helper_connector_dpms,
938
	.detect = radeon_dvi_detect,
939
	.fill_modes = drm_helper_probe_single_connector_modes,
940
	.set_property = radeon_connector_set_property,
941
	.destroy = radeon_connector_destroy,
1221 serge 942
	.force = radeon_dvi_force,
1123 serge 943
};
944
 
1321 serge 945
static void radeon_dp_connector_destroy(struct drm_connector *connector)
946
{
947
	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
948
	struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
949
 
950
	if (radeon_connector->ddc_bus)
951
		radeon_i2c_destroy(radeon_connector->ddc_bus);
952
	if (radeon_connector->edid)
953
		kfree(radeon_connector->edid);
954
	if (radeon_dig_connector->dp_i2c_bus)
955
		radeon_i2c_destroy(radeon_dig_connector->dp_i2c_bus);
956
	kfree(radeon_connector->con_priv);
957
	drm_sysfs_connector_remove(connector);
958
	drm_connector_cleanup(connector);
959
	kfree(connector);
960
}
961
 
962
static int radeon_dp_get_modes(struct drm_connector *connector)
963
{
964
	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
965
	int ret;
966
 
967
	ret = radeon_ddc_get_modes(radeon_connector);
968
	return ret;
969
}
970
 
971
static enum drm_connector_status radeon_dp_detect(struct drm_connector *connector)
972
{
973
	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
974
	enum drm_connector_status ret = connector_status_disconnected;
975
	struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
976
	u8 sink_type;
977
 
978
	if (radeon_connector->edid) {
979
		kfree(radeon_connector->edid);
980
		radeon_connector->edid = NULL;
981
	}
982
 
983
	sink_type = radeon_dp_getsinktype(radeon_connector);
1403 serge 984
	if ((sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) ||
985
	    (sink_type == CONNECTOR_OBJECT_ID_eDP)) {
1321 serge 986
		if (radeon_dp_getdpcd(radeon_connector)) {
987
			radeon_dig_connector->dp_sink_type = sink_type;
988
			ret = connector_status_connected;
989
		}
990
	} else {
991
		radeon_i2c_do_lock(radeon_connector->ddc_bus, 1);
992
		if (radeon_ddc_probe(radeon_connector)) {
993
			radeon_dig_connector->dp_sink_type = sink_type;
994
			ret = connector_status_connected;
995
		}
996
		radeon_i2c_do_lock(radeon_connector->ddc_bus, 0);
997
	}
998
 
999
	return ret;
1000
}
1001
 
1002
static int radeon_dp_mode_valid(struct drm_connector *connector,
1003
				  struct drm_display_mode *mode)
1004
{
1005
	struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1006
	struct radeon_connector_atom_dig *radeon_dig_connector = radeon_connector->con_priv;
1007
 
1008
	/* XXX check mode bandwidth */
1009
 
1403 serge 1010
	if ((radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT) ||
1011
	    (radeon_dig_connector->dp_sink_type == CONNECTOR_OBJECT_ID_eDP))
1321 serge 1012
		return radeon_dp_mode_valid_helper(radeon_connector, mode);
1013
	else
1014
		return MODE_OK;
1015
}
1016
 
1017
struct drm_connector_helper_funcs radeon_dp_connector_helper_funcs = {
1018
	.get_modes = radeon_dp_get_modes,
1019
	.mode_valid = radeon_dp_mode_valid,
1020
	.best_encoder = radeon_dvi_encoder,
1021
};
1022
 
1023
struct drm_connector_funcs radeon_dp_connector_funcs = {
1024
	.dpms = drm_helper_connector_dpms,
1025
	.detect = radeon_dp_detect,
1026
	.fill_modes = drm_helper_probe_single_connector_modes,
1027
	.set_property = radeon_connector_set_property,
1028
	.destroy = radeon_dp_connector_destroy,
1029
	.force = radeon_dvi_force,
1030
};
1031
 
1123 serge 1032
void
1033
radeon_add_atom_connector(struct drm_device *dev,
1034
			  uint32_t connector_id,
1035
			  uint32_t supported_device,
1036
			  int connector_type,
1037
			  struct radeon_i2c_bus_rec *i2c_bus,
1038
			  bool linkb,
1268 serge 1039
			  uint32_t igp_lane_info,
1321 serge 1040
			  uint16_t connector_object_id,
1041
			  struct radeon_hpd *hpd)
1123 serge 1042
{
1179 serge 1043
	struct radeon_device *rdev = dev->dev_private;
1123 serge 1044
	struct drm_connector *connector;
1045
	struct radeon_connector *radeon_connector;
1046
	struct radeon_connector_atom_dig *radeon_dig_connector;
1047
	uint32_t subpixel_order = SubPixelNone;
1268 serge 1048
	bool shared_ddc = false;
1221 serge 1049
	int ret;
1123 serge 1050
 
1051
	/* fixme - tv/cv/din */
1179 serge 1052
	if (connector_type == DRM_MODE_CONNECTOR_Unknown)
1123 serge 1053
		return;
1054
 
1055
	/* see if we already added it */
1056
	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
1057
		radeon_connector = to_radeon_connector(connector);
1058
		if (radeon_connector->connector_id == connector_id) {
1059
			radeon_connector->devices |= supported_device;
1060
			return;
1061
		}
1268 serge 1062
		if (radeon_connector->ddc_bus && i2c_bus->valid) {
1428 serge 1063
			if (radeon_connector->ddc_bus->rec.i2c_id == i2c_bus->i2c_id) {
1268 serge 1064
				radeon_connector->shared_ddc = true;
1065
				shared_ddc = true;
1066
			}
1067
		}
1123 serge 1068
	}
1069
 
1070
	radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
1071
	if (!radeon_connector)
1072
		return;
1073
 
1074
	connector = &radeon_connector->base;
1075
 
1076
	radeon_connector->connector_id = connector_id;
1077
	radeon_connector->devices = supported_device;
1268 serge 1078
	radeon_connector->shared_ddc = shared_ddc;
1079
	radeon_connector->connector_object_id = connector_object_id;
1321 serge 1080
	radeon_connector->hpd = *hpd;
1123 serge 1081
	switch (connector_type) {
1082
	case DRM_MODE_CONNECTOR_VGA:
1083
		drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1221 serge 1084
		ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1085
		if (ret)
1086
			goto failed;
1123 serge 1087
		if (i2c_bus->valid) {
1088
			radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "VGA");
1089
			if (!radeon_connector->ddc_bus)
1090
				goto failed;
1091
		}
1221 serge 1092
		radeon_connector->dac_load_detect = true;
1179 serge 1093
		drm_connector_attach_property(&radeon_connector->base,
1094
					      rdev->mode_info.load_detect_property,
1095
					      1);
1123 serge 1096
		break;
1097
	case DRM_MODE_CONNECTOR_DVIA:
1098
		drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1221 serge 1099
		ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1100
		if (ret)
1101
			goto failed;
1123 serge 1102
		if (i2c_bus->valid) {
1103
			radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
1104
			if (!radeon_connector->ddc_bus)
1105
				goto failed;
1106
		}
1221 serge 1107
		radeon_connector->dac_load_detect = true;
1179 serge 1108
		drm_connector_attach_property(&radeon_connector->base,
1109
					      rdev->mode_info.load_detect_property,
1110
					      1);
1123 serge 1111
		break;
1112
	case DRM_MODE_CONNECTOR_DVII:
1113
	case DRM_MODE_CONNECTOR_DVID:
1114
		radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1115
		if (!radeon_dig_connector)
1116
			goto failed;
1117
		radeon_dig_connector->linkb = linkb;
1118
		radeon_dig_connector->igp_lane_info = igp_lane_info;
1119
		radeon_connector->con_priv = radeon_dig_connector;
1120
		drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
1221 serge 1121
		ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
1122
		if (ret)
1123
			goto failed;
1123 serge 1124
		if (i2c_bus->valid) {
1125
			radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
1126
			if (!radeon_connector->ddc_bus)
1127
				goto failed;
1128
		}
1129
		subpixel_order = SubPixelHorizontalRGB;
1179 serge 1130
		drm_connector_attach_property(&radeon_connector->base,
1131
					      rdev->mode_info.coherent_mode_property,
1132
					      1);
1321 serge 1133
		if (connector_type == DRM_MODE_CONNECTOR_DVII) {
1221 serge 1134
		radeon_connector->dac_load_detect = true;
1179 serge 1135
		drm_connector_attach_property(&radeon_connector->base,
1136
					      rdev->mode_info.load_detect_property,
1137
					      1);
1321 serge 1138
		}
1123 serge 1139
		break;
1140
	case DRM_MODE_CONNECTOR_HDMIA:
1141
	case DRM_MODE_CONNECTOR_HDMIB:
1142
		radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1143
		if (!radeon_dig_connector)
1144
			goto failed;
1145
		radeon_dig_connector->linkb = linkb;
1146
		radeon_dig_connector->igp_lane_info = igp_lane_info;
1147
		radeon_connector->con_priv = radeon_dig_connector;
1148
		drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
1221 serge 1149
		ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
1150
		if (ret)
1151
			goto failed;
1123 serge 1152
		if (i2c_bus->valid) {
1153
			radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "HDMI");
1154
			if (!radeon_connector->ddc_bus)
1155
				goto failed;
1156
		}
1179 serge 1157
		drm_connector_attach_property(&radeon_connector->base,
1158
					      rdev->mode_info.coherent_mode_property,
1159
					      1);
1123 serge 1160
		subpixel_order = SubPixelHorizontalRGB;
1161
		break;
1162
	case DRM_MODE_CONNECTOR_DisplayPort:
1403 serge 1163
	case DRM_MODE_CONNECTOR_eDP:
1123 serge 1164
		radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1165
		if (!radeon_dig_connector)
1166
			goto failed;
1167
		radeon_dig_connector->linkb = linkb;
1168
		radeon_dig_connector->igp_lane_info = igp_lane_info;
1169
		radeon_connector->con_priv = radeon_dig_connector;
1321 serge 1170
		drm_connector_init(dev, &radeon_connector->base, &radeon_dp_connector_funcs, connector_type);
1171
		ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dp_connector_helper_funcs);
1221 serge 1172
		if (ret)
1173
			goto failed;
1123 serge 1174
		if (i2c_bus->valid) {
1321 serge 1175
			/* add DP i2c bus */
1403 serge 1176
			if (connector_type == DRM_MODE_CONNECTOR_eDP)
1177
				radeon_dig_connector->dp_i2c_bus = radeon_i2c_create_dp(dev, i2c_bus, "eDP-auxch");
1178
			else
1321 serge 1179
			radeon_dig_connector->dp_i2c_bus = radeon_i2c_create_dp(dev, i2c_bus, "DP-auxch");
1180
			if (!radeon_dig_connector->dp_i2c_bus)
1181
				goto failed;
1403 serge 1182
			if (connector_type == DRM_MODE_CONNECTOR_eDP)
1183
				radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "eDP");
1184
			else
1123 serge 1185
			radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DP");
1186
			if (!radeon_connector->ddc_bus)
1187
				goto failed;
1188
		}
1189
		subpixel_order = SubPixelHorizontalRGB;
1321 serge 1190
		drm_connector_attach_property(&radeon_connector->base,
1191
					      rdev->mode_info.coherent_mode_property,
1192
					      1);
1123 serge 1193
		break;
1194
	case DRM_MODE_CONNECTOR_SVIDEO:
1195
	case DRM_MODE_CONNECTOR_Composite:
1196
	case DRM_MODE_CONNECTOR_9PinDIN:
1179 serge 1197
		if (radeon_tv == 1) {
1198
			drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
1221 serge 1199
			ret = drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
1200
			if (ret)
1201
				goto failed;
1202
			radeon_connector->dac_load_detect = true;
1179 serge 1203
		drm_connector_attach_property(&radeon_connector->base,
1204
					      rdev->mode_info.load_detect_property,
1205
					      1);
1321 serge 1206
			drm_connector_attach_property(&radeon_connector->base,
1207
						      rdev->mode_info.tv_std_property,
1403 serge 1208
						      radeon_atombios_get_tv_info(rdev));
1221 serge 1209
		}
1123 serge 1210
		break;
1211
	case DRM_MODE_CONNECTOR_LVDS:
1212
		radeon_dig_connector = kzalloc(sizeof(struct radeon_connector_atom_dig), GFP_KERNEL);
1213
		if (!radeon_dig_connector)
1214
			goto failed;
1215
		radeon_dig_connector->linkb = linkb;
1216
		radeon_dig_connector->igp_lane_info = igp_lane_info;
1217
		radeon_connector->con_priv = radeon_dig_connector;
1218
		drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
1221 serge 1219
		ret = drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
1220
		if (ret)
1221
			goto failed;
1123 serge 1222
		if (i2c_bus->valid) {
1223
			radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "LVDS");
1224
			if (!radeon_connector->ddc_bus)
1225
				goto failed;
1226
		}
1179 serge 1227
		drm_connector_attach_property(&radeon_connector->base,
1228
					      dev->mode_config.scaling_mode_property,
1229
					      DRM_MODE_SCALE_FULLSCREEN);
1123 serge 1230
		subpixel_order = SubPixelHorizontalRGB;
1231
		break;
1232
	}
1233
 
1234
	connector->display_info.subpixel_order = subpixel_order;
1233 serge 1235
	drm_sysfs_connector_add(connector);
1123 serge 1236
	return;
1237
 
1238
failed:
1239
	if (radeon_connector->ddc_bus)
1240
		radeon_i2c_destroy(radeon_connector->ddc_bus);
1241
	drm_connector_cleanup(connector);
1242
	kfree(connector);
1243
}
1244
 
1245
void
1246
radeon_add_legacy_connector(struct drm_device *dev,
1247
			    uint32_t connector_id,
1248
			    uint32_t supported_device,
1249
			    int connector_type,
1268 serge 1250
			    struct radeon_i2c_bus_rec *i2c_bus,
1321 serge 1251
			    uint16_t connector_object_id,
1252
			    struct radeon_hpd *hpd)
1123 serge 1253
{
1179 serge 1254
	struct radeon_device *rdev = dev->dev_private;
1123 serge 1255
	struct drm_connector *connector;
1256
	struct radeon_connector *radeon_connector;
1257
	uint32_t subpixel_order = SubPixelNone;
1221 serge 1258
	int ret;
1123 serge 1259
 
1260
	/* fixme - tv/cv/din */
1179 serge 1261
	if (connector_type == DRM_MODE_CONNECTOR_Unknown)
1123 serge 1262
		return;
1263
 
1264
	/* see if we already added it */
1265
	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
1266
		radeon_connector = to_radeon_connector(connector);
1267
		if (radeon_connector->connector_id == connector_id) {
1268
			radeon_connector->devices |= supported_device;
1269
			return;
1270
		}
1271
	}
1272
 
1273
	radeon_connector = kzalloc(sizeof(struct radeon_connector), GFP_KERNEL);
1274
	if (!radeon_connector)
1275
		return;
1276
 
1277
	connector = &radeon_connector->base;
1278
 
1279
	radeon_connector->connector_id = connector_id;
1280
	radeon_connector->devices = supported_device;
1268 serge 1281
	radeon_connector->connector_object_id = connector_object_id;
1321 serge 1282
	radeon_connector->hpd = *hpd;
1123 serge 1283
	switch (connector_type) {
1284
	case DRM_MODE_CONNECTOR_VGA:
1285
		drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1221 serge 1286
		ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1287
		if (ret)
1288
			goto failed;
1123 serge 1289
		if (i2c_bus->valid) {
1290
			radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "VGA");
1291
			if (!radeon_connector->ddc_bus)
1292
				goto failed;
1293
		}
1221 serge 1294
		radeon_connector->dac_load_detect = true;
1179 serge 1295
		drm_connector_attach_property(&radeon_connector->base,
1296
					      rdev->mode_info.load_detect_property,
1297
					      1);
1123 serge 1298
		break;
1299
	case DRM_MODE_CONNECTOR_DVIA:
1300
		drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
1221 serge 1301
		ret = drm_connector_helper_add(&radeon_connector->base, &radeon_vga_connector_helper_funcs);
1302
		if (ret)
1303
			goto failed;
1123 serge 1304
		if (i2c_bus->valid) {
1305
			radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
1306
			if (!radeon_connector->ddc_bus)
1307
				goto failed;
1308
		}
1221 serge 1309
		radeon_connector->dac_load_detect = true;
1179 serge 1310
		drm_connector_attach_property(&radeon_connector->base,
1311
					      rdev->mode_info.load_detect_property,
1312
					      1);
1123 serge 1313
		break;
1314
	case DRM_MODE_CONNECTOR_DVII:
1315
	case DRM_MODE_CONNECTOR_DVID:
1316
		drm_connector_init(dev, &radeon_connector->base, &radeon_dvi_connector_funcs, connector_type);
1221 serge 1317
		ret = drm_connector_helper_add(&radeon_connector->base, &radeon_dvi_connector_helper_funcs);
1318
		if (ret)
1319
			goto failed;
1123 serge 1320
		if (i2c_bus->valid) {
1321
			radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "DVI");
1322
			if (!radeon_connector->ddc_bus)
1323
				goto failed;
1221 serge 1324
			radeon_connector->dac_load_detect = true;
1179 serge 1325
			drm_connector_attach_property(&radeon_connector->base,
1326
						      rdev->mode_info.load_detect_property,
1327
						      1);
1123 serge 1328
		}
1329
		subpixel_order = SubPixelHorizontalRGB;
1330
		break;
1331
	case DRM_MODE_CONNECTOR_SVIDEO:
1332
	case DRM_MODE_CONNECTOR_Composite:
1333
	case DRM_MODE_CONNECTOR_9PinDIN:
1179 serge 1334
		if (radeon_tv == 1) {
1335
			drm_connector_init(dev, &radeon_connector->base, &radeon_tv_connector_funcs, connector_type);
1221 serge 1336
			ret = drm_connector_helper_add(&radeon_connector->base, &radeon_tv_connector_helper_funcs);
1337
			if (ret)
1338
				goto failed;
1339
			radeon_connector->dac_load_detect = true;
1313 serge 1340
			/* RS400,RC410,RS480 chipset seems to report a lot
1341
			 * of false positive on load detect, we haven't yet
1342
			 * found a way to make load detect reliable on those
1343
			 * chipset, thus just disable it for TV.
1344
			 */
1345
			if (rdev->family == CHIP_RS400 || rdev->family == CHIP_RS480)
1346
				radeon_connector->dac_load_detect = false;
1179 serge 1347
			drm_connector_attach_property(&radeon_connector->base,
1348
						      rdev->mode_info.load_detect_property,
1404 serge 1349
						      radeon_connector->dac_load_detect);
1321 serge 1350
			drm_connector_attach_property(&radeon_connector->base,
1351
						      rdev->mode_info.tv_std_property,
1403 serge 1352
						      radeon_combios_get_tv_info(rdev));
1179 serge 1353
		}
1123 serge 1354
		break;
1355
	case DRM_MODE_CONNECTOR_LVDS:
1356
		drm_connector_init(dev, &radeon_connector->base, &radeon_lvds_connector_funcs, connector_type);
1221 serge 1357
		ret = drm_connector_helper_add(&radeon_connector->base, &radeon_lvds_connector_helper_funcs);
1358
		if (ret)
1359
			goto failed;
1123 serge 1360
		if (i2c_bus->valid) {
1361
			radeon_connector->ddc_bus = radeon_i2c_create(dev, i2c_bus, "LVDS");
1362
			if (!radeon_connector->ddc_bus)
1363
				goto failed;
1364
		}
1179 serge 1365
		drm_connector_attach_property(&radeon_connector->base,
1366
					      dev->mode_config.scaling_mode_property,
1367
					      DRM_MODE_SCALE_FULLSCREEN);
1123 serge 1368
		subpixel_order = SubPixelHorizontalRGB;
1369
		break;
1370
	}
1371
 
1372
	connector->display_info.subpixel_order = subpixel_order;
1233 serge 1373
	drm_sysfs_connector_add(connector);
1123 serge 1374
	return;
1375
 
1376
failed:
1377
	if (radeon_connector->ddc_bus)
1378
		radeon_i2c_destroy(radeon_connector->ddc_bus);
1379
	drm_connector_cleanup(connector);
1380
	kfree(connector);
1381
}