Subversion Repositories Kolibri OS

Rev

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