nouveau_connector.c 32.4 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
/*
 * Copyright (C) 2008 Maarten Maathuis.
 * All Rights Reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice (including the
 * next paragraph) shall be included in all copies or substantial
 * portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 */

27
28
#include <acpi/button.h>

29
30
31
#include <drm/drmP.h>
#include <drm/drm_edid.h>
#include <drm/drm_crtc_helper.h>
32

33
#include "nouveau_reg.h"
34
#include "nouveau_drm.h"
35
#include "nouveau_hw.h"
36
#include "nouveau_acpi.h"
37

38
39
#include "nouveau_display.h"
#include "nouveau_connector.h"
40
41
#include "nouveau_encoder.h"
#include "nouveau_crtc.h"
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

#include <subdev/i2c.h>
#include <subdev/gpio.h>

MODULE_PARM_DESC(tv_disable, "Disable TV-out detection");
static int nouveau_tv_disable = 0;
module_param_named(tv_disable, nouveau_tv_disable, int, 0400);

MODULE_PARM_DESC(ignorelid, "Ignore ACPI lid status");
static int nouveau_ignorelid = 0;
module_param_named(ignorelid, nouveau_ignorelid, int, 0400);

MODULE_PARM_DESC(duallink, "Allow dual-link TMDS (default: enabled)");
static int nouveau_duallink = 1;
module_param_named(duallink, nouveau_duallink, int, 0400);
57

58
59
static void nouveau_connector_hotplug(void *, int);

60
struct nouveau_encoder *
61
find_encoder(struct drm_connector *connector, int type)
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
{
	struct drm_device *dev = connector->dev;
	struct nouveau_encoder *nv_encoder;
	struct drm_mode_object *obj;
	int i, id;

	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
		id = connector->encoder_ids[i];
		if (!id)
			break;

		obj = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_ENCODER);
		if (!obj)
			continue;
		nv_encoder = nouveau_encoder(obj_to_encoder(obj));

78
		if (type == DCB_OUTPUT_ANY || nv_encoder->dcb->type == type)
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
			return nv_encoder;
	}

	return NULL;
}

struct nouveau_connector *
nouveau_encoder_connector_get(struct nouveau_encoder *encoder)
{
	struct drm_device *dev = to_drm_encoder(encoder)->dev;
	struct drm_connector *drm_connector;

	list_for_each_entry(drm_connector, &dev->mode_config.connector_list, head) {
		if (drm_connector->encoder == to_drm_encoder(encoder))
			return nouveau_connector(drm_connector);
	}

	return NULL;
}

static void
100
nouveau_connector_destroy(struct drm_connector *connector)
101
{
102
	struct nouveau_connector *nv_connector = nouveau_connector(connector);
103
104
	struct nouveau_gpio *gpio;
	struct nouveau_drm *drm;
105
	struct drm_device *dev;
106

107
	if (!nv_connector)
108
109
		return;

110
111
112
	dev  = nv_connector->base.dev;
	drm  = nouveau_drm(dev);
	gpio = nouveau_gpio(drm->device);
113

114
115
116
	if (gpio && nv_connector->hpd != DCB_GPIO_UNUSED) {
		gpio->isr_del(gpio, 0, nv_connector->hpd, 0xff,
			      nouveau_connector_hotplug, connector);
117
118
	}

119
	kfree(nv_connector->edid);
120
121
122
	drm_sysfs_connector_remove(connector);
	drm_connector_cleanup(connector);
	kfree(connector);
123
124
}

125
static struct nouveau_i2c_port *
126
127
128
129
nouveau_connector_ddc_detect(struct drm_connector *connector,
			     struct nouveau_encoder **pnv_encoder)
{
	struct drm_device *dev = connector->dev;
130
131
	struct nouveau_drm *drm = nouveau_drm(dev);
	struct nouveau_i2c *i2c = nouveau_i2c(drm->device);
132
	int i;
133
134

	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
135
		struct nouveau_i2c_port *port = NULL;
136
137
138
139
140
141
142
143
144
145
146
147
		struct nouveau_encoder *nv_encoder;
		struct drm_mode_object *obj;
		int id;

		id = connector->encoder_ids[i];
		if (!id)
			break;

		obj = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_ENCODER);
		if (!obj)
			continue;
		nv_encoder = nouveau_encoder(obj_to_encoder(obj));
148
149

		if (nv_encoder->dcb->i2c_index < 0xf)
150
151
			port = i2c->find(i2c, nv_encoder->dcb->i2c_index);
		if (port && nv_probe_i2c(port, 0x50)) {
152
			*pnv_encoder = nv_encoder;
153
			return port;
154
155
156
157
158
159
		}
	}

	return NULL;
}

160
161
162
163
164
165
166
167
168
169
static struct nouveau_encoder *
nouveau_connector_of_detect(struct drm_connector *connector)
{
#ifdef __powerpc__
	struct drm_device *dev = connector->dev;
	struct nouveau_connector *nv_connector = nouveau_connector(connector);
	struct nouveau_encoder *nv_encoder;
	struct device_node *cn, *dn = pci_device_to_OF_node(dev->pdev);

	if (!dn ||
170
171
	    !((nv_encoder = find_encoder(connector, DCB_OUTPUT_TMDS)) ||
	      (nv_encoder = find_encoder(connector, DCB_OUTPUT_ANALOG))))
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
		return NULL;

	for_each_child_of_node(dn, cn) {
		const char *name = of_get_property(cn, "name", NULL);
		const void *edid = of_get_property(cn, "EDID", NULL);
		int idx = name ? name[strlen(name) - 1] - 'A' : 0;

		if (nv_encoder->dcb->i2c_index == idx && edid) {
			nv_connector->edid =
				kmemdup(edid, EDID_LENGTH, GFP_KERNEL);
			of_node_put(cn);
			return nv_encoder;
		}
	}
#endif
	return NULL;
}

190
191
192
193
194
static void
nouveau_connector_set_encoder(struct drm_connector *connector,
			      struct nouveau_encoder *nv_encoder)
{
	struct nouveau_connector *nv_connector = nouveau_connector(connector);
195
	struct nouveau_drm *drm = nouveau_drm(connector->dev);
196
197
198
199
200
201
	struct drm_device *dev = connector->dev;

	if (nv_connector->detected_encoder == nv_encoder)
		return;
	nv_connector->detected_encoder = nv_encoder;

202
	if (nv_device(drm->device)->card_type >= NV_50) {
203
204
205
		connector->interlace_allowed = true;
		connector->doublescan_allowed = true;
	} else
206
207
	if (nv_encoder->dcb->type == DCB_OUTPUT_LVDS ||
	    nv_encoder->dcb->type == DCB_OUTPUT_TMDS) {
208
209
210
211
		connector->doublescan_allowed = false;
		connector->interlace_allowed = false;
	} else {
		connector->doublescan_allowed = true;
212
213
		if (nv_device(drm->device)->card_type == NV_20 ||
		   (nv_device(drm->device)->card_type == NV_10 &&
214
215
216
217
218
219
220
221
		    (dev->pci_device & 0x0ff0) != 0x0100 &&
		    (dev->pci_device & 0x0ff0) != 0x0150))
			/* HW is broken */
			connector->interlace_allowed = false;
		else
			connector->interlace_allowed = true;
	}

222
	if (nv_connector->type == DCB_CONNECTOR_DVI_I) {
223
		drm_object_property_set_value(&connector->base,
224
			dev->mode_config.dvi_i_subconnector_property,
225
			nv_encoder->dcb->type == DCB_OUTPUT_TMDS ?
226
227
228
229
230
231
			DRM_MODE_SUBCONNECTOR_DVID :
			DRM_MODE_SUBCONNECTOR_DVIA);
	}
}

static enum drm_connector_status
232
nouveau_connector_detect(struct drm_connector *connector, bool force)
233
234
{
	struct drm_device *dev = connector->dev;
235
	struct nouveau_drm *drm = nouveau_drm(dev);
236
237
	struct nouveau_connector *nv_connector = nouveau_connector(connector);
	struct nouveau_encoder *nv_encoder = NULL;
238
	struct nouveau_encoder *nv_partner;
239
	struct nouveau_i2c_port *i2c;
240
	int type;
241

242
243
244
245
246
247
	/* Cleanup the previous EDID block. */
	if (nv_connector->edid) {
		drm_mode_connector_update_edid_property(connector, NULL);
		kfree(nv_connector->edid);
		nv_connector->edid = NULL;
	}
248

249
250
251
252
253
254
	i2c = nouveau_connector_ddc_detect(connector, &nv_encoder);
	if (i2c) {
		nv_connector->edid = drm_get_edid(connector, &i2c->adapter);
		drm_mode_connector_update_edid_property(connector,
							nv_connector->edid);
		if (!nv_connector->edid) {
255
			NV_ERROR(drm, "DDC responded, but no EDID for %s\n",
256
				 drm_get_connector_name(connector));
257
			goto detect_analog;
258
259
		}

260
		if (nv_encoder->dcb->type == DCB_OUTPUT_DP &&
261
		    !nouveau_dp_detect(to_drm_encoder(nv_encoder))) {
262
			NV_ERROR(drm, "Detected %s, but failed init\n",
263
264
265
266
267
268
269
270
271
				 drm_get_connector_name(connector));
			return connector_status_disconnected;
		}

		/* Override encoder type for DVI-I based on whether EDID
		 * says the display is digital or analog, both use the
		 * same i2c channel so the value returned from ddc_detect
		 * isn't necessarily correct.
		 */
272
		nv_partner = NULL;
273
274
275
276
277
278
279
280
281
		if (nv_encoder->dcb->type == DCB_OUTPUT_TMDS)
			nv_partner = find_encoder(connector, DCB_OUTPUT_ANALOG);
		if (nv_encoder->dcb->type == DCB_OUTPUT_ANALOG)
			nv_partner = find_encoder(connector, DCB_OUTPUT_TMDS);

		if (nv_partner && ((nv_encoder->dcb->type == DCB_OUTPUT_ANALOG &&
				    nv_partner->dcb->type == DCB_OUTPUT_TMDS) ||
				   (nv_encoder->dcb->type == DCB_OUTPUT_TMDS &&
				    nv_partner->dcb->type == DCB_OUTPUT_ANALOG))) {
282
			if (nv_connector->edid->input & DRM_EDID_INPUT_DIGITAL)
283
				type = DCB_OUTPUT_TMDS;
284
			else
285
				type = DCB_OUTPUT_ANALOG;
286

287
			nv_encoder = find_encoder(connector, type);
288
289
290
291
292
293
		}

		nouveau_connector_set_encoder(connector, nv_encoder);
		return connector_status_connected;
	}

294
295
296
297
298
299
	nv_encoder = nouveau_connector_of_detect(connector);
	if (nv_encoder) {
		nouveau_connector_set_encoder(connector, nv_encoder);
		return connector_status_connected;
	}

300
detect_analog:
301
	nv_encoder = find_encoder(connector, DCB_OUTPUT_ANALOG);
302
	if (!nv_encoder && !nouveau_tv_disable)
303
		nv_encoder = find_encoder(connector, DCB_OUTPUT_TV);
304
	if (nv_encoder && force) {
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
		struct drm_encoder *encoder = to_drm_encoder(nv_encoder);
		struct drm_encoder_helper_funcs *helper =
						encoder->helper_private;

		if (helper->detect(encoder, connector) ==
						connector_status_connected) {
			nouveau_connector_set_encoder(connector, nv_encoder);
			return connector_status_connected;
		}

	}

	return connector_status_disconnected;
}

320
static enum drm_connector_status
321
nouveau_connector_detect_lvds(struct drm_connector *connector, bool force)
322
323
{
	struct drm_device *dev = connector->dev;
324
	struct nouveau_drm *drm = nouveau_drm(dev);
325
326
327
328
329
330
331
332
333
334
335
	struct nouveau_connector *nv_connector = nouveau_connector(connector);
	struct nouveau_encoder *nv_encoder = NULL;
	enum drm_connector_status status = connector_status_disconnected;

	/* Cleanup the previous EDID block. */
	if (nv_connector->edid) {
		drm_mode_connector_update_edid_property(connector, NULL);
		kfree(nv_connector->edid);
		nv_connector->edid = NULL;
	}

336
	nv_encoder = find_encoder(connector, DCB_OUTPUT_LVDS);
337
338
339
	if (!nv_encoder)
		return connector_status_disconnected;

340
	/* Try retrieving EDID via DDC */
341
	if (!drm->vbios.fp_no_ddc) {
342
		status = nouveau_connector_detect(connector, force);
343
344
345
346
		if (status == connector_status_connected)
			goto out;
	}

347
348
349
350
351
352
353
354
355
356
	/* On some laptops (Sony, i'm looking at you) there appears to
	 * be no direct way of accessing the panel's EDID.  The only
	 * option available to us appears to be to ask ACPI for help..
	 *
	 * It's important this check's before trying straps, one of the
	 * said manufacturer's laptops are configured in such a way
	 * the nouveau decides an entry in the VBIOS FP mode table is
	 * valid - it's not (rh#613284)
	 */
	if (nv_encoder->dcb->lvdsconf.use_acpi_for_edid) {
357
		if ((nv_connector->edid = nouveau_acpi_edid(dev, connector))) {
358
359
360
361
362
			status = connector_status_connected;
			goto out;
		}
	}

363
364
365
366
	/* If no EDID found above, and the VBIOS indicates a hardcoded
	 * modeline is avalilable for the panel, set it as the panel's
	 * native mode and exit.
	 */
367
	if (nouveau_bios_fp_mode(dev, NULL) && (drm->vbios.fp_no_ddc ||
368
369
370
371
372
373
374
375
	    nv_encoder->dcb->lvdsconf.use_straps_for_mode)) {
		status = connector_status_connected;
		goto out;
	}

	/* Still nothing, some VBIOS images have a hardcoded EDID block
	 * stored for the panel stored in them.
	 */
376
	if (!drm->vbios.fp_no_ddc) {
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
		struct edid *edid =
			(struct edid *)nouveau_bios_embedded_edid(dev);
		if (edid) {
			nv_connector->edid = kmalloc(EDID_LENGTH, GFP_KERNEL);
			*(nv_connector->edid) = *edid;
			status = connector_status_connected;
		}
	}

out:
#if defined(CONFIG_ACPI_BUTTON) || \
	(defined(CONFIG_ACPI_BUTTON_MODULE) && defined(MODULE))
	if (status == connector_status_connected &&
	    !nouveau_ignorelid && !acpi_lid_open())
		status = connector_status_unknown;
#endif

	drm_mode_connector_update_edid_property(connector, nv_connector->edid);
395
	nouveau_connector_set_encoder(connector, nv_encoder);
396
397
398
	return status;
}

399
400
401
static void
nouveau_connector_force(struct drm_connector *connector)
{
402
	struct nouveau_drm *drm = nouveau_drm(connector->dev);
403
	struct nouveau_connector *nv_connector = nouveau_connector(connector);
404
405
406
	struct nouveau_encoder *nv_encoder;
	int type;

407
	if (nv_connector->type == DCB_CONNECTOR_DVI_I) {
408
		if (connector->force == DRM_FORCE_ON_DIGITAL)
409
			type = DCB_OUTPUT_TMDS;
410
		else
411
			type = DCB_OUTPUT_ANALOG;
412
	} else
413
		type = DCB_OUTPUT_ANY;
414

415
	nv_encoder = find_encoder(connector, type);
416
	if (!nv_encoder) {
417
		NV_ERROR(drm, "can't find encoder to force %s on!\n",
418
419
420
421
422
423
424
425
426
427
428
429
			 drm_get_connector_name(connector));
		connector->status = connector_status_disconnected;
		return;
	}

	nouveau_connector_set_encoder(connector, nv_encoder);
}

static int
nouveau_connector_set_property(struct drm_connector *connector,
			       struct drm_property *property, uint64_t value)
{
430
	struct nouveau_display *disp = nouveau_display(connector->dev);
431
432
	struct nouveau_connector *nv_connector = nouveau_connector(connector);
	struct nouveau_encoder *nv_encoder = nv_connector->detected_encoder;
433
	struct drm_encoder *encoder = to_drm_encoder(nv_encoder);
434
	struct drm_device *dev = connector->dev;
435
	struct nouveau_crtc *nv_crtc;
436
437
	int ret;

438
439
440
441
	nv_crtc = NULL;
	if (connector->encoder && connector->encoder->crtc)
		nv_crtc = nouveau_crtc(connector->encoder->crtc);

442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
	/* Scaling mode */
	if (property == dev->mode_config.scaling_mode_property) {
		bool modeset = false;

		switch (value) {
		case DRM_MODE_SCALE_NONE:
		case DRM_MODE_SCALE_FULLSCREEN:
		case DRM_MODE_SCALE_CENTER:
		case DRM_MODE_SCALE_ASPECT:
			break;
		default:
			return -EINVAL;
		}

		/* LVDS always needs gpu scaling */
457
		if (connector->connector_type == DRM_MODE_CONNECTOR_LVDS &&
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
		    value == DRM_MODE_SCALE_NONE)
			return -EINVAL;

		/* Changing between GPU and panel scaling requires a full
		 * modeset
		 */
		if ((nv_connector->scaling_mode == DRM_MODE_SCALE_NONE) ||
		    (value == DRM_MODE_SCALE_NONE))
			modeset = true;
		nv_connector->scaling_mode = value;

		if (!nv_crtc)
			return 0;

		if (modeset || !nv_crtc->set_scale) {
			ret = drm_crtc_helper_set_mode(&nv_crtc->base,
							&nv_crtc->base.mode,
							nv_crtc->base.x,
							nv_crtc->base.y, NULL);
			if (!ret)
				return -EINVAL;
		} else {
480
			ret = nv_crtc->set_scale(nv_crtc, true);
481
482
483
484
485
486
487
			if (ret)
				return ret;
		}

		return 0;
	}

488
489
490
491
492
493
494
	/* Underscan */
	if (property == disp->underscan_property) {
		if (nv_connector->underscan != value) {
			nv_connector->underscan = value;
			if (!nv_crtc || !nv_crtc->set_scale)
				return 0;

495
			return nv_crtc->set_scale(nv_crtc, true);
496
497
498
499
500
501
502
503
504
505
506
		}

		return 0;
	}

	if (property == disp->underscan_hborder_property) {
		if (nv_connector->underscan_hborder != value) {
			nv_connector->underscan_hborder = value;
			if (!nv_crtc || !nv_crtc->set_scale)
				return 0;

507
			return nv_crtc->set_scale(nv_crtc, true);
508
509
510
511
512
513
514
515
516
517
518
		}

		return 0;
	}

	if (property == disp->underscan_vborder_property) {
		if (nv_connector->underscan_vborder != value) {
			nv_connector->underscan_vborder = value;
			if (!nv_crtc || !nv_crtc->set_scale)
				return 0;

519
			return nv_crtc->set_scale(nv_crtc, true);
520
521
522
523
524
		}

		return 0;
	}

525
	/* Dithering */
526
527
528
529
530
531
532
	if (property == disp->dithering_mode) {
		nv_connector->dithering_mode = value;
		if (!nv_crtc || !nv_crtc->set_dither)
			return 0;

		return nv_crtc->set_dither(nv_crtc, true);
	}
533

534
535
	if (property == disp->dithering_depth) {
		nv_connector->dithering_depth = value;
536
537
538
		if (!nv_crtc || !nv_crtc->set_dither)
			return 0;

539
		return nv_crtc->set_dither(nv_crtc, true);
540
541
	}

542
543
544
545
546
547
548
549
550
551
552
553
554
	if (nv_crtc && nv_crtc->set_color_vibrance) {
		/* Hue */
		if (property == disp->vibrant_hue_property) {
			nv_crtc->vibrant_hue = value - 90;
			return nv_crtc->set_color_vibrance(nv_crtc, true);
		}
		/* Saturation */
		if (property == disp->color_vibrance_property) {
			nv_crtc->color_vibrance = value - 100;
			return nv_crtc->set_color_vibrance(nv_crtc, true);
		}
	}

555
	if (nv_encoder && nv_encoder->dcb->type == DCB_OUTPUT_TV)
556
557
		return get_slave_funcs(encoder)->set_property(
			encoder, connector, property, value);
558
559
560
561
562

	return -EINVAL;
}

static struct drm_display_mode *
563
nouveau_connector_native_mode(struct drm_connector *connector)
564
{
565
	struct drm_connector_helper_funcs *helper = connector->helper_private;
566
	struct nouveau_drm *drm = nouveau_drm(connector->dev);
567
568
	struct nouveau_connector *nv_connector = nouveau_connector(connector);
	struct drm_device *dev = connector->dev;
569
570
571
	struct drm_display_mode *mode, *largest = NULL;
	int high_w = 0, high_h = 0, high_v = 0;

572
	list_for_each_entry(mode, &nv_connector->base.probed_modes, head) {
573
		mode->vrefresh = drm_mode_vrefresh(mode);
574
575
		if (helper->mode_valid(connector, mode) != MODE_OK ||
		    (mode->flags & DRM_MODE_FLAG_INTERLACE))
576
577
578
			continue;

		/* Use preferred mode if there is one.. */
579
		if (mode->type & DRM_MODE_TYPE_PREFERRED) {
580
			NV_DEBUG(drm, "native mode from preferred\n");
581
582
583
			return drm_mode_duplicate(dev, mode);
		}

584
585
586
		/* Otherwise, take the resolution with the largest width, then
		 * height, then vertical refresh
		 */
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
		if (mode->hdisplay < high_w)
			continue;

		if (mode->hdisplay == high_w && mode->vdisplay < high_h)
			continue;

		if (mode->hdisplay == high_w && mode->vdisplay == high_h &&
		    mode->vrefresh < high_v)
			continue;

		high_w = mode->hdisplay;
		high_h = mode->vdisplay;
		high_v = mode->vrefresh;
		largest = mode;
	}

603
	NV_DEBUG(drm, "native mode from largest: %dx%d@%d\n",
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
		      high_w, high_h, high_v);
	return largest ? drm_mode_duplicate(dev, largest) : NULL;
}

struct moderec {
	int hdisplay;
	int vdisplay;
};

static struct moderec scaler_modes[] = {
	{ 1920, 1200 },
	{ 1920, 1080 },
	{ 1680, 1050 },
	{ 1600, 1200 },
	{ 1400, 1050 },
	{ 1280, 1024 },
	{ 1280, 960 },
	{ 1152, 864 },
	{ 1024, 768 },
	{ 800, 600 },
	{ 720, 400 },
	{ 640, 480 },
	{ 640, 400 },
	{ 640, 350 },
	{}
};

static int
nouveau_connector_scaler_modes_add(struct drm_connector *connector)
{
	struct nouveau_connector *nv_connector = nouveau_connector(connector);
	struct drm_display_mode *native = nv_connector->native_mode, *m;
	struct drm_device *dev = connector->dev;
	struct moderec *mode = &scaler_modes[0];
	int modes = 0;

	if (!native)
		return 0;

	while (mode->hdisplay) {
		if (mode->hdisplay <= native->hdisplay &&
		    mode->vdisplay <= native->vdisplay) {
			m = drm_cvt_mode(dev, mode->hdisplay, mode->vdisplay,
					 drm_mode_vrefresh(native), false,
					 false, false);
			if (!m)
				continue;

			m->type |= DRM_MODE_TYPE_DRIVER;

			drm_mode_probed_add(connector, m);
			modes++;
		}

		mode++;
	}

	return modes;
}

664
665
666
static void
nouveau_connector_detect_depth(struct drm_connector *connector)
{
667
	struct nouveau_drm *drm = nouveau_drm(connector->dev);
668
669
	struct nouveau_connector *nv_connector = nouveau_connector(connector);
	struct nouveau_encoder *nv_encoder = nv_connector->detected_encoder;
670
	struct nvbios *bios = &drm->vbios;
671
672
673
674
675
676
677
	struct drm_display_mode *mode = nv_connector->native_mode;
	bool duallink;

	/* if the edid is feeling nice enough to provide this info, use it */
	if (nv_connector->edid && connector->display_info.bpc)
		return;

678
679
680
681
682
683
684
	/* EDID 1.4 is *supposed* to be supported on eDP, but, Apple... */
	if (nv_connector->type == DCB_CONNECTOR_eDP) {
		connector->display_info.bpc = 6;
		return;
	}

	/* we're out of options unless we're LVDS, default to 8bpc */
685
	if (nv_encoder->dcb->type != DCB_OUTPUT_LVDS) {
686
		connector->display_info.bpc = 8;
687
		return;
688
689
690
	}

	connector->display_info.bpc = 6;
691
692
693
694
695
696
697
698
699
700
701
702

	/* LVDS: panel straps */
	if (bios->fp_no_ddc) {
		if (bios->fp.if_is_24bit)
			connector->display_info.bpc = 8;
		return;
	}

	/* LVDS: DDC panel, need to first determine the number of links to
	 * know which if_is_24bit flag to check...
	 */
	if (nv_connector->edid &&
703
	    nv_connector->type == DCB_CONNECTOR_LVDS_SPWG)
704
705
706
707
708
709
710
711
712
		duallink = ((u8 *)nv_connector->edid)[121] == 2;
	else
		duallink = mode->clock >= bios->fp.duallink_transition_clk;

	if ((!duallink && (bios->fp.strapless_is_24bit & 1)) ||
	    ( duallink && (bios->fp.strapless_is_24bit & 2)))
		connector->display_info.bpc = 8;
}

713
714
715
716
static int
nouveau_connector_get_modes(struct drm_connector *connector)
{
	struct drm_device *dev = connector->dev;
717
	struct nouveau_drm *drm = nouveau_drm(dev);
718
719
	struct nouveau_connector *nv_connector = nouveau_connector(connector);
	struct nouveau_encoder *nv_encoder = nv_connector->detected_encoder;
720
	struct drm_encoder *encoder = to_drm_encoder(nv_encoder);
721
722
	int ret = 0;

723
	/* destroy the native mode, the attached monitor could have changed.
724
	 */
725
	if (nv_connector->native_mode) {
726
727
728
729
730
731
		drm_mode_destroy(dev, nv_connector->native_mode);
		nv_connector->native_mode = NULL;
	}

	if (nv_connector->edid)
		ret = drm_add_edid_modes(connector, nv_connector->edid);
732
	else
733
	if (nv_encoder->dcb->type == DCB_OUTPUT_LVDS &&
734
	    (nv_encoder->dcb->lvdsconf.use_straps_for_mode ||
735
	     drm->vbios.fp_no_ddc) && nouveau_bios_fp_mode(dev, NULL)) {
736
737
738
739
		struct drm_display_mode mode;

		nouveau_bios_fp_mode(dev, &mode);
		nv_connector->native_mode = drm_mode_duplicate(dev, &mode);
740
	}
741

742
743
744
745
746
747
	/* Determine display colour depth for everything except LVDS now,
	 * DP requires this before mode_valid() is called.
	 */
	if (connector->connector_type != DRM_MODE_CONNECTOR_LVDS)
		nouveau_connector_detect_depth(connector);

748
749
750
751
752
753
	/* Find the native mode if this is a digital panel, if we didn't
	 * find any modes through DDC previously add the native mode to
	 * the list of modes.
	 */
	if (!nv_connector->native_mode)
		nv_connector->native_mode =
754
			nouveau_connector_native_mode(connector);
755
756
757
758
759
760
761
762
	if (ret == 0 && nv_connector->native_mode) {
		struct drm_display_mode *mode;

		mode = drm_mode_duplicate(dev, nv_connector->native_mode);
		drm_mode_probed_add(connector, mode);
		ret = 1;
	}

763
764
765
	/* Determine LVDS colour depth, must happen after determining
	 * "native" mode as some VBIOS tables require us to use the
	 * pixel clock as part of the lookup...
766
	 */
767
768
	if (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)
		nouveau_connector_detect_depth(connector);
769

770
	if (nv_encoder->dcb->type == DCB_OUTPUT_TV)
771
		ret = get_slave_funcs(encoder)->get_modes(encoder, connector);
772

773
774
775
	if (nv_connector->type == DCB_CONNECTOR_LVDS ||
	    nv_connector->type == DCB_CONNECTOR_LVDS_SPWG ||
	    nv_connector->type == DCB_CONNECTOR_eDP)
776
777
778
779
780
		ret += nouveau_connector_scaler_modes_add(connector);

	return ret;
}

781
782
783
784
static unsigned
get_tmds_link_bandwidth(struct drm_connector *connector)
{
	struct nouveau_connector *nv_connector = nouveau_connector(connector);
785
	struct nouveau_drm *drm = nouveau_drm(connector->dev);
786
	struct dcb_output *dcb = nv_connector->detected_encoder->dcb;
787
788

	if (dcb->location != DCB_LOC_ON_CHIP ||
789
	    nv_device(drm->device)->chipset >= 0x46)
790
		return 165000;
791
	else if (nv_device(drm->device)->chipset >= 0x40)
792
		return 155000;
793
	else if (nv_device(drm->device)->chipset >= 0x18)
794
795
796
797
798
		return 135000;
	else
		return 112000;
}

799
800
801
802
803
804
static int
nouveau_connector_mode_valid(struct drm_connector *connector,
			     struct drm_display_mode *mode)
{
	struct nouveau_connector *nv_connector = nouveau_connector(connector);
	struct nouveau_encoder *nv_encoder = nv_connector->detected_encoder;
805
	struct drm_encoder *encoder = to_drm_encoder(nv_encoder);
806
807
808
809
	unsigned min_clock = 25000, max_clock = min_clock;
	unsigned clock = mode->clock;

	switch (nv_encoder->dcb->type) {
810
	case DCB_OUTPUT_LVDS:
811
812
813
		if (nv_connector->native_mode &&
		    (mode->hdisplay > nv_connector->native_mode->hdisplay ||
		     mode->vdisplay > nv_connector->native_mode->vdisplay))
814
815
816
817
818
			return MODE_PANEL;

		min_clock = 0;
		max_clock = 400000;
		break;
819
	case DCB_OUTPUT_TMDS:
820
821
822
		max_clock = get_tmds_link_bandwidth(connector);
		if (nouveau_duallink && nv_encoder->dcb->duallink_possible)
			max_clock *= 2;
823
		break;
824
	case DCB_OUTPUT_ANALOG:
825
826
827
828
		max_clock = nv_encoder->dcb->crtconf.maxfreq;
		if (!max_clock)
			max_clock = 350000;
		break;
829
	case DCB_OUTPUT_TV:
830
		return get_slave_funcs(encoder)->mode_valid(encoder, mode);
831
	case DCB_OUTPUT_DP:
832
833
		max_clock  = nv_encoder->dp.link_nr;
		max_clock *= nv_encoder->dp.link_bw;
834
		clock = clock * (connector->display_info.bpc * 3) / 10;
835
		break;
836
837
838
	default:
		BUG_ON(1);
		return MODE_BAD;
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
	}

	if (clock < min_clock)
		return MODE_CLOCK_LOW;

	if (clock > max_clock)
		return MODE_CLOCK_HIGH;

	return MODE_OK;
}

static struct drm_encoder *
nouveau_connector_best_encoder(struct drm_connector *connector)
{
	struct nouveau_connector *nv_connector = nouveau_connector(connector);

	if (nv_connector->detected_encoder)
		return to_drm_encoder(nv_connector->detected_encoder);

	return NULL;
}

static const struct drm_connector_helper_funcs
nouveau_connector_helper_funcs = {
	.get_modes = nouveau_connector_get_modes,
	.mode_valid = nouveau_connector_mode_valid,
	.best_encoder = nouveau_connector_best_encoder,
};

static const struct drm_connector_funcs
nouveau_connector_funcs = {
	.dpms = drm_helper_connector_dpms,
	.save = NULL,
	.restore = NULL,
	.detect = nouveau_connector_detect,
	.destroy = nouveau_connector_destroy,
	.fill_modes = drm_helper_probe_single_connector_modes,
	.set_property = nouveau_connector_set_property,
	.force = nouveau_connector_force
};

880
881
882
883
884
885
886
887
888
889
890
static const struct drm_connector_funcs
nouveau_connector_funcs_lvds = {
	.dpms = drm_helper_connector_dpms,
	.save = NULL,
	.restore = NULL,
	.detect = nouveau_connector_detect_lvds,
	.destroy = nouveau_connector_destroy,
	.fill_modes = drm_helper_probe_single_connector_modes,
	.set_property = nouveau_connector_set_property,
	.force = nouveau_connector_force
};
891

892
893
894
895
896
897
898
899
static int
drm_conntype_from_dcb(enum dcb_connector_type dcb)
{
	switch (dcb) {
	case DCB_CONNECTOR_VGA      : return DRM_MODE_CONNECTOR_VGA;
	case DCB_CONNECTOR_TV_0     :
	case DCB_CONNECTOR_TV_1     :
	case DCB_CONNECTOR_TV_3     : return DRM_MODE_CONNECTOR_TV;
900
901
	case DCB_CONNECTOR_DMS59_0  :
	case DCB_CONNECTOR_DMS59_1  :
902
903
904
905
	case DCB_CONNECTOR_DVI_I    : return DRM_MODE_CONNECTOR_DVII;
	case DCB_CONNECTOR_DVI_D    : return DRM_MODE_CONNECTOR_DVID;
	case DCB_CONNECTOR_LVDS     :
	case DCB_CONNECTOR_LVDS_SPWG: return DRM_MODE_CONNECTOR_LVDS;
906
907
	case DCB_CONNECTOR_DMS59_DP0:
	case DCB_CONNECTOR_DMS59_DP1:
908
909
910
911
912
913
914
915
916
917
918
	case DCB_CONNECTOR_DP       : return DRM_MODE_CONNECTOR_DisplayPort;
	case DCB_CONNECTOR_eDP      : return DRM_MODE_CONNECTOR_eDP;
	case DCB_CONNECTOR_HDMI_0   :
	case DCB_CONNECTOR_HDMI_1   : return DRM_MODE_CONNECTOR_HDMIA;
	default:
		break;
	}

	return DRM_MODE_CONNECTOR_Unknown;
}

919
920
struct drm_connector *
nouveau_connector_create(struct drm_device *dev, int index)
921
{
922
	const struct drm_connector_funcs *funcs = &nouveau_connector_funcs;
923
924
925
	struct nouveau_drm *drm = nouveau_drm(dev);
	struct nouveau_gpio *gpio = nouveau_gpio(drm->device);
	struct nouveau_display *disp = nouveau_display(dev);
926
927
	struct nouveau_connector *nv_connector = NULL;
	struct drm_connector *connector;
928
	int type, ret = 0;
929
	bool dummy;
930

931
932
933
934
	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
		nv_connector = nouveau_connector(connector);
		if (nv_connector->index == index)
			return connector;
935
936
	}

937
938
	nv_connector = kzalloc(sizeof(*nv_connector), GFP_KERNEL);
	if (!nv_connector)
939
		return ERR_PTR(-ENOMEM);
940

941
	connector = &nv_connector->base;
942
943
944
	nv_connector->index = index;

	/* attempt to parse vbios connector type and hotplug gpio */
945
	nv_connector->dcb = olddcb_conn(dev, index);
946
947
948
949
950
951
952
	if (nv_connector->dcb) {
		static const u8 hpd[16] = {
			0xff, 0x07, 0x08, 0xff, 0xff, 0x51, 0x52, 0xff,
			0xff, 0xff, 0xff, 0xff, 0xff, 0x5e, 0x5f, 0x60,
		};

		u32 entry = ROM16(nv_connector->dcb[0]);
953
		if (olddcb_conntab(dev)[3] >= 4)
954
955
956
957
958
959
960
961
			entry |= (u32)ROM16(nv_connector->dcb[2]) << 16;

		nv_connector->hpd = ffs((entry & 0x07033000) >> 12);
		nv_connector->hpd = hpd[nv_connector->hpd];

		nv_connector->type = nv_connector->dcb[0];
		if (drm_conntype_from_dcb(nv_connector->type) ==
					  DRM_MODE_CONNECTOR_Unknown) {
962
			NV_WARN(drm, "unknown connector type %02x\n",
963
964
965
				nv_connector->type);
			nv_connector->type = DCB_CONNECTOR_NONE;
		}
966

967
968
969
970
971
		/* Gigabyte NX85T */
		if (nv_match_device(dev, 0x0421, 0x1458, 0x344c)) {
			if (nv_connector->type == DCB_CONNECTOR_HDMI_1)
				nv_connector->type = DCB_CONNECTOR_DVI_I;
		}
972

973
974
975
976
977
978
979
980
981
982
983
984
985
986
		/* Gigabyte GV-NX86T512H */
		if (nv_match_device(dev, 0x0402, 0x1458, 0x3455)) {
			if (nv_connector->type == DCB_CONNECTOR_HDMI_1)
				nv_connector->type = DCB_CONNECTOR_DVI_I;
		}
	} else {
		nv_connector->type = DCB_CONNECTOR_NONE;
		nv_connector->hpd = DCB_GPIO_UNUSED;
	}

	/* no vbios data, or an unknown dcb connector type - attempt to
	 * figure out something suitable ourselves
	 */
	if (nv_connector->type == DCB_CONNECTOR_NONE) {
987
988
		struct nouveau_drm *drm = nouveau_drm(dev);
		struct dcb_table *dcbt = &drm->vbios.dcb;
989
990
991
992
993
994
995
		u32 encoders = 0;
		int i;

		for (i = 0; i < dcbt->entries; i++) {
			if (dcbt->entry[i].connector == nv_connector->index)
				encoders |= (1 << dcbt->entry[i].type);
		}
996

997
998
		if (encoders & (1 << DCB_OUTPUT_DP)) {
			if (encoders & (1 << DCB_OUTPUT_TMDS))
999
1000
1001
1002
				nv_connector->type = DCB_CONNECTOR_DP;
			else
				nv_connector->type = DCB_CONNECTOR_eDP;
		} else
1003
1004
		if (encoders & (1 << DCB_OUTPUT_TMDS)) {
			if (encoders & (1 << DCB_OUTPUT_ANALOG))
1005
1006
1007
1008
				nv_connector->type = DCB_CONNECTOR_DVI_I;
			else
				nv_connector->type = DCB_CONNECTOR_DVI_D;
		} else
1009
		if (encoders & (1 << DCB_OUTPUT_ANALOG)) {
1010
1011
			nv_connector->type = DCB_CONNECTOR_VGA;
		} else
1012
		if (encoders & (1 << DCB_OUTPUT_LVDS)) {
1013
1014
			nv_connector->type = DCB_CONNECTOR_LVDS;
		} else
1015
		if (encoders & (1 << DCB_OUTPUT_TV)) {
1016
1017
1018
			nv_connector->type = DCB_CONNECTOR_TV_0;
		}
	}
1019

1020
1021
1022
	type = drm_conntype_from_dcb(nv_connector->type);
	if (type == DRM_MODE_CONNECTOR_LVDS) {
		ret = nouveau_bios_parse_lvds_table(dev, 0, &dummy, &dummy);
1023
		if (ret) {
1024
			NV_ERROR(drm, "Error parsing LVDS table, disabling\n");
1025
1026
			kfree(nv_connector);
			return ERR_PTR(ret);
1027
		}
1028
1029
1030
1031

		funcs = &nouveau_connector_funcs_lvds;
	} else {
		funcs = &nouveau_connector_funcs;
1032
1033
	}

1034
1035
1036
1037
1038
1039
1040
	/* defaults, will get overridden in detect() */
	connector->interlace_allowed = false;
	connector->doublescan_allowed = false;

	drm_connector_init(dev, connector, funcs, type);
	drm_connector_helper_add(connector, &nouveau_connector_helper_funcs);

1041
	/* Init DVI-I specific properties */
1042
	if (nv_connector->type == DCB_CONNECTOR_DVI_I)
1043
		drm_object_attach_property(&connector->base, dev->mode_config.dvi_i_subconnector_property, 0);
1044

1045
	/* Add overscan compensation options to digital outputs */
1046
	if (disp->underscan_property &&
1047
1048
1049
1050
	    (type == DRM_MODE_CONNECTOR_DVID ||
	     type == DRM_MODE_CONNECTOR_DVII ||
	     type == DRM_MODE_CONNECTOR_HDMIA ||
	     type == DRM_MODE_CONNECTOR_DisplayPort)) {
1051
		drm_object_attach_property(&connector->base,
1052
1053
					      disp->underscan_property,
					      UNDERSCAN_OFF);
1054
		drm_object_attach_property(&connector->base,
1055
1056
					      disp->underscan_hborder_property,
					      0);
1057
		drm_object_attach_property(&connector->base,
1058
1059
1060
1061
					      disp->underscan_vborder_property,
					      0);
	}

1062
1063
	/* Add hue and saturation options */
	if (disp->vibrant_hue_property)
1064
		drm_object_attach_property(&connector->base,
1065
1066
1067
					      disp->vibrant_hue_property,
					      90);
	if (disp->color_vibrance_property)
1068
		drm_object_attach_property(&connector->base,
1069
1070
1071
					      disp->color_vibrance_property,
					      150);

1072
	switch (nv_connector->type) {
1073
	case DCB_CONNECTOR_VGA:
1074
		if (nv_device(drm->device)->card_type >= NV_50) {
1075
			drm_object_attach_property(&connector->base,
1076
1077
1078
					dev->mode_config.scaling_mode_property,
					nv_connector->scaling_mode);
		}
1079
1080
1081
1082
1083
1084
1085
1086
1087
		/* fall-through */
	case DCB_CONNECTOR_TV_0:
	case DCB_CONNECTOR_TV_1:
	case DCB_CONNECTOR_TV_3:
		nv_connector->scaling_mode = DRM_MODE_SCALE_NONE;
		break;
	default:
		nv_connector->scaling_mode = DRM_MODE_SCALE_FULLSCREEN;

1088
		drm_object_attach_property(&connector->base,
1089
1090
				dev->mode_config.scaling_mode_property,
				nv_connector->scaling_mode);
1091
1092
		if (disp->dithering_mode) {
			nv_connector->dithering_mode = DITHERING_MODE_AUTO;
1093
			drm_object_attach_property(&connector->base,
1094
1095
1096
1097
1098
						disp->dithering_mode,
						nv_connector->dithering_mode);
		}
		if (disp->dithering_depth) {
			nv_connector->dithering_depth = DITHERING_DEPTH_AUTO;
1099
			drm_object_attach_property(&connector->base,
1100
1101
1102
						disp->dithering_depth,
						nv_connector->dithering_depth);
		}
1103
		break;
1104
1105
	}

1106
	connector->polled = DRM_CONNECTOR_POLL_CONNECT;
1107
1108
1109
	if (gpio && nv_connector->hpd != DCB_GPIO_UNUSED) {
		ret = gpio->isr_add(gpio, 0, nv_connector->hpd, 0xff,
				    nouveau_connector_hotplug, connector);
1110
1111
		if (ret == 0)
			connector->polled = DRM_CONNECTOR_POLL_HPD;
1112
1113
	}

1114
	drm_sysfs_connector_add(connector);
1115
	return connector;
1116
}
1117
1118
1119
1120
1121
1122

static void
nouveau_connector_hotplug(void *data, int plugged)
{
	struct drm_connector *connector = data;
	struct drm_device *dev = connector->dev;
1123
	struct nouveau_drm *drm = nouveau_drm(dev);
1124

1125
	NV_DEBUG(drm, "%splugged %s\n", plugged ? "" : "un",
1126
		 drm_get_connector_name(connector));
1127

1128
1129
1130
1131
	if (plugged)
		drm_helper_connector_dpms(connector, DRM_MODE_DPMS_ON);
	else
		drm_helper_connector_dpms(connector, DRM_MODE_DPMS_OFF);
1132
1133
1134

	drm_helper_hpd_irq_event(dev);
}