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
113
	dev  = nv_connector->base.dev;
	drm  = nouveau_drm(dev);
	gpio = nouveau_gpio(drm->device);
	NV_DEBUG(drm, "\n");
114

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

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

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

	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
136
		struct nouveau_i2c_port *port = NULL;
137
138
139
140
141
142
143
144
145
146
147
148
		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));
149
150

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

	return NULL;
}

161
162
163
164
165
166
167
168
169
170
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 ||
171
172
	    !((nv_encoder = find_encoder(connector, DCB_OUTPUT_TMDS)) ||
	      (nv_encoder = find_encoder(connector, DCB_OUTPUT_ANALOG))))
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
		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;
}

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

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

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

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

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

243
244
245
246
247
248
	/* 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;
	}
249

250
251
252
253
254
255
	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) {
256
			NV_ERROR(drm, "DDC responded, but no EDID for %s\n",
257
				 drm_get_connector_name(connector));
258
			goto detect_analog;
259
260
		}

261
		if (nv_encoder->dcb->type == DCB_OUTPUT_DP &&
262
		    !nouveau_dp_detect(to_drm_encoder(nv_encoder))) {
263
			NV_ERROR(drm, "Detected %s, but failed init\n",
264
265
266
267
268
269
270
271
272
				 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.
		 */
273
		nv_partner = NULL;
274
275
276
277
278
279
280
281
282
		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))) {
283
			if (nv_connector->edid->input & DRM_EDID_INPUT_DIGITAL)
284
				type = DCB_OUTPUT_TMDS;
285
			else
286
				type = DCB_OUTPUT_ANALOG;
287

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

		nouveau_connector_set_encoder(connector, nv_encoder);
		return connector_status_connected;
	}

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

301
detect_analog:
302
	nv_encoder = find_encoder(connector, DCB_OUTPUT_ANALOG);
303
	if (!nv_encoder && !nouveau_tv_disable)
304
		nv_encoder = find_encoder(connector, DCB_OUTPUT_TV);
305
	if (nv_encoder && force) {
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
		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;
}

321
static enum drm_connector_status
322
nouveau_connector_detect_lvds(struct drm_connector *connector, bool force)
323
324
{
	struct drm_device *dev = connector->dev;
325
	struct nouveau_drm *drm = nouveau_drm(dev);
326
327
328
329
330
331
332
333
334
335
336
	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;
	}

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

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

348
349
350
351
352
353
354
355
356
357
	/* 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) {
358
		if (!(nv_connector->edid = nouveau_acpi_edid(dev, connector))) {
359
360
361
362
363
			status = connector_status_connected;
			goto out;
		}
	}

364
365
366
367
	/* 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.
	 */
368
	if (nouveau_bios_fp_mode(dev, NULL) && (drm->vbios.fp_no_ddc ||
369
370
371
372
373
374
375
376
	    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.
	 */
377
	if (!drm->vbios.fp_no_ddc) {
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
		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);
396
	nouveau_connector_set_encoder(connector, nv_encoder);
397
398
399
	return status;
}

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

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

416
	nv_encoder = find_encoder(connector, type);
417
	if (!nv_encoder) {
418
		NV_ERROR(drm, "can't find encoder to force %s on!\n",
419
420
421
422
423
424
425
426
427
428
429
430
			 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)
{
431
	struct nouveau_display *disp = nouveau_display(connector->dev);
432
433
	struct nouveau_connector *nv_connector = nouveau_connector(connector);
	struct nouveau_encoder *nv_encoder = nv_connector->detected_encoder;
434
	struct drm_encoder *encoder = to_drm_encoder(nv_encoder);
435
	struct drm_device *dev = connector->dev;
436
	struct nouveau_crtc *nv_crtc;
437
438
	int ret;

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

443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
	/* 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 */
458
		if (connector->connector_type == DRM_MODE_CONNECTOR_LVDS &&
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
		    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 {
481
			ret = nv_crtc->set_scale(nv_crtc, true);
482
483
484
485
486
487
488
			if (ret)
				return ret;
		}

		return 0;
	}

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

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

		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;

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

		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;

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

		return 0;
	}

526
	/* Dithering */
527
528
529
530
531
532
533
	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);
	}
534

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

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

543
544
545
546
547
548
549
550
551
552
553
554
555
	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);
		}
	}

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

	return -EINVAL;
}

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

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

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

585
586
587
		/* Otherwise, take the resolution with the largest width, then
		 * height, then vertical refresh
		 */
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
		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;
	}

604
	NV_DEBUG(drm, "native mode from largest: %dx%d@%d\n",
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
664
		      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;
}

665
666
667
static void
nouveau_connector_detect_depth(struct drm_connector *connector)
{
668
	struct nouveau_drm *drm = nouveau_drm(connector->dev);
669
670
	struct nouveau_connector *nv_connector = nouveau_connector(connector);
	struct nouveau_encoder *nv_encoder = nv_connector->detected_encoder;
671
	struct nvbios *bios = &drm->vbios;
672
673
674
675
676
677
678
	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;

679
680
681
682
683
684
685
	/* 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 */
686
	if (nv_encoder->dcb->type != DCB_OUTPUT_LVDS) {
687
		connector->display_info.bpc = 8;
688
		return;
689
690
691
	}

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

	/* 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 &&
704
	    nv_connector->type == DCB_CONNECTOR_LVDS_SPWG)
705
706
707
708
709
710
711
712
713
		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;
}

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

724
	/* destroy the native mode, the attached monitor could have changed.
725
	 */
726
	if (nv_connector->native_mode) {
727
728
729
730
731
732
		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);
733
	else
734
	if (nv_encoder->dcb->type == DCB_OUTPUT_LVDS &&
735
	    (nv_encoder->dcb->lvdsconf.use_straps_for_mode ||
736
	     drm->vbios.fp_no_ddc) && nouveau_bios_fp_mode(dev, NULL)) {
737
738
739
740
		struct drm_display_mode mode;

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

743
744
745
746
747
748
	/* 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);

749
750
751
752
753
754
	/* 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 =
755
			nouveau_connector_native_mode(connector);
756
757
758
759
760
761
762
763
	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;
	}

764
765
766
	/* 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...
767
	 */
768
769
	if (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)
		nouveau_connector_detect_depth(connector);
770

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

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

	return ret;
}

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

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

800
801
802
803
804
805
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;
806
	struct drm_encoder *encoder = to_drm_encoder(nv_encoder);
807
808
809
810
	unsigned min_clock = 25000, max_clock = min_clock;
	unsigned clock = mode->clock;

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

		min_clock = 0;
		max_clock = 400000;
		break;
820
	case DCB_OUTPUT_TMDS:
821
822
823
		max_clock = get_tmds_link_bandwidth(connector);
		if (nouveau_duallink && nv_encoder->dcb->duallink_possible)
			max_clock *= 2;
824
		break;
825
	case DCB_OUTPUT_ANALOG:
826
827
828
829
		max_clock = nv_encoder->dcb->crtconf.maxfreq;
		if (!max_clock)
			max_clock = 350000;
		break;
830
	case DCB_OUTPUT_TV:
831
		return get_slave_funcs(encoder)->mode_valid(encoder, mode);
832
	case DCB_OUTPUT_DP:
833
834
		max_clock  = nv_encoder->dp.link_nr;
		max_clock *= nv_encoder->dp.link_bw;
835
		clock = clock * (connector->display_info.bpc * 3) / 10;
836
		break;
837
838
839
	default:
		BUG_ON(1);
		return MODE_BAD;
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
880
	}

	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
};

881
882
883
884
885
886
887
888
889
890
891
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
};
892

893
894
895
896
897
898
899
900
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;
901
902
	case DCB_CONNECTOR_DMS59_0  :
	case DCB_CONNECTOR_DMS59_1  :
903
904
905
906
	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;
907
908
	case DCB_CONNECTOR_DMS59_DP0:
	case DCB_CONNECTOR_DMS59_DP1:
909
910
911
912
913
914
915
916
917
918
919
	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;
}

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

932
	NV_DEBUG(drm, "\n");
933

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

940
941
	nv_connector = kzalloc(sizeof(*nv_connector), GFP_KERNEL);
	if (!nv_connector)
942
		return ERR_PTR(-ENOMEM);
943

944
	connector = &nv_connector->base;
945
946
947
	nv_connector->index = index;

	/* attempt to parse vbios connector type and hotplug gpio */
948
	nv_connector->dcb = olddcb_conn(dev, index);
949
950
951
952
953
954
955
	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]);
956
		if (olddcb_conntab(dev)[3] >= 4)
957
958
959
960
961
962
963
964
			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) {
965
			NV_WARN(drm, "unknown connector type %02x\n",
966
967
968
				nv_connector->type);
			nv_connector->type = DCB_CONNECTOR_NONE;
		}
969

970
971
972
973
974
		/* 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;
		}
975

976
977
978
979
980
981
982
983
984
985
986
987
988
989
		/* 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) {
990
991
		struct nouveau_drm *drm = nouveau_drm(dev);
		struct dcb_table *dcbt = &drm->vbios.dcb;
992
993
994
995
996
997
998
		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);
		}
999

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

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

		funcs = &nouveau_connector_funcs_lvds;
	} else {
		funcs = &nouveau_connector_funcs;
1035
1036
	}

1037
1038
1039
1040
1041
1042
1043
	/* 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);

1044
	/* Init DVI-I specific properties */
1045
	if (nv_connector->type == DCB_CONNECTOR_DVI_I)
1046
1047
		drm_connector_attach_property(connector, dev->mode_config.dvi_i_subconnector_property, 0);

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

1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
	/* Add hue and saturation options */
	if (disp->vibrant_hue_property)
		drm_connector_attach_property(connector,
					      disp->vibrant_hue_property,
					      90);
	if (disp->color_vibrance_property)
		drm_connector_attach_property(connector,
					      disp->color_vibrance_property,
					      150);

1075
	switch (nv_connector->type) {
1076
	case DCB_CONNECTOR_VGA:
1077
		if (nv_device(drm->device)->card_type >= NV_50) {
1078
1079
1080
1081
			drm_connector_attach_property(connector,
					dev->mode_config.scaling_mode_property,
					nv_connector->scaling_mode);
		}
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
		/* 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;

		drm_connector_attach_property(connector,
				dev->mode_config.scaling_mode_property,
				nv_connector->scaling_mode);
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
		if (disp->dithering_mode) {
			nv_connector->dithering_mode = DITHERING_MODE_AUTO;
			drm_connector_attach_property(connector,
						disp->dithering_mode,
						nv_connector->dithering_mode);
		}
		if (disp->dithering_depth) {
			nv_connector->dithering_depth = DITHERING_DEPTH_AUTO;
			drm_connector_attach_property(connector,
						disp->dithering_depth,
						nv_connector->dithering_depth);
		}
1106
		break;
1107
1108
	}

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

1117
	drm_sysfs_connector_add(connector);
1118
	return connector;
1119
}
1120
1121
1122
1123
1124
1125

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

1128
	NV_DEBUG(drm, "%splugged %s\n", plugged ? "" : "un",
1129
		 drm_get_connector_name(connector));
1130

1131
1132
1133
1134
	if (plugged)
		drm_helper_connector_dpms(connector, DRM_MODE_DPMS_ON);
	else
		drm_helper_connector_dpms(connector, DRM_MODE_DPMS_OFF);
1135
1136
1137

	drm_helper_hpd_irq_event(dev);
}