nouveau_connector.c 36.5 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
#include <linux/pm_runtime.h>

31
32
33
#include <drm/drmP.h>
#include <drm/drm_edid.h>
#include <drm/drm_crtc_helper.h>
34

35
#include "nouveau_reg.h"
36
#include "nouveau_drm.h"
37
#include "dispnv04/hw.h"
38
#include "nouveau_acpi.h"
39

40
41
#include "nouveau_display.h"
#include "nouveau_connector.h"
42
43
#include "nouveau_encoder.h"
#include "nouveau_crtc.h"
44

45
46
#include <nvif/event.h>

47
MODULE_PARM_DESC(tv_disable, "Disable TV-out detection");
48
int nouveau_tv_disable = 0;
49
50
51
module_param_named(tv_disable, nouveau_tv_disable, int, 0400);

MODULE_PARM_DESC(ignorelid, "Ignore ACPI lid status");
52
int nouveau_ignorelid = 0;
53
54
55
module_param_named(ignorelid, nouveau_ignorelid, int, 0400);

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

59
60
61
62
MODULE_PARM_DESC(hdmimhz, "Force a maximum HDMI pixel clock (in MHz)");
int nouveau_hdmimhz = 0;
module_param_named(hdmimhz, nouveau_hdmimhz, int, 0400);

63
struct nouveau_encoder *
64
find_encoder(struct drm_connector *connector, int type)
65
66
67
{
	struct drm_device *dev = connector->dev;
	struct nouveau_encoder *nv_encoder;
Rob Clark's avatar
Rob Clark committed
68
	struct drm_encoder *enc;
69
70
71
72
73
74
75
	int i, id;

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

Rob Clark's avatar
Rob Clark committed
76
77
		enc = drm_encoder_find(dev, id);
		if (!enc)
78
			continue;
Rob Clark's avatar
Rob Clark committed
79
		nv_encoder = nouveau_encoder(enc);
80

81
82
		if (type == DCB_OUTPUT_ANY ||
		    (nv_encoder->dcb && nv_encoder->dcb->type == type))
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
			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
104
nouveau_connector_destroy(struct drm_connector *connector)
105
{
106
	struct nouveau_connector *nv_connector = nouveau_connector(connector);
107
	nvif_notify_fini(&nv_connector->hpd);
108
	kfree(nv_connector->edid);
109
	drm_connector_unregister(connector);
110
	drm_connector_cleanup(connector);
111
112
	if (nv_connector->aux.transfer)
		drm_dp_aux_unregister(&nv_connector->aux);
113
	kfree(connector);
114
115
}

116
117
static struct nouveau_encoder *
nouveau_connector_ddc_detect(struct drm_connector *connector)
118
119
{
	struct drm_device *dev = connector->dev;
120
	struct nouveau_connector *nv_connector = nouveau_connector(connector);
121
	struct nouveau_drm *drm = nouveau_drm(dev);
122
	struct nvkm_gpio *gpio = nvxx_gpio(&drm->device);
123
	struct nouveau_encoder *nv_encoder;
Rob Clark's avatar
Rob Clark committed
124
	struct drm_encoder *encoder;
125
126
127
128
129
130
131
	int i, panel = -ENODEV;

	/* eDP panels need powering on by us (if the VBIOS doesn't default it
	 * to on) before doing any AUX channel transactions.  LVDS panel power
	 * is handled by the SOR itself, and not required for LVDS DDC.
	 */
	if (nv_connector->type == DCB_CONNECTOR_eDP) {
132
		panel = nvkm_gpio_get(gpio, 0, DCB_GPIO_PANEL_POWER, 0xff);
133
		if (panel == 0) {
134
			nvkm_gpio_set(gpio, 0, DCB_GPIO_PANEL_POWER, 0xff, 1);
135
136
137
			msleep(300);
		}
	}
138

139
140
141
	for (i = 0; nv_encoder = NULL, i < DRM_CONNECTOR_MAX_ENCODER; i++) {
		int id = connector->encoder_ids[i];
		if (id == 0)
142
143
			break;

Rob Clark's avatar
Rob Clark committed
144
145
		encoder = drm_encoder_find(dev, id);
		if (!encoder)
146
			continue;
Rob Clark's avatar
Rob Clark committed
147
		nv_encoder = nouveau_encoder(encoder);
148

149
150
151
152
153
154
		if (nv_encoder->dcb->type == DCB_OUTPUT_DP) {
			int ret = nouveau_dp_detect(nv_encoder);
			if (ret == 0)
				break;
		} else
		if (nv_encoder->i2c) {
155
			if (nvkm_probe_i2c(nv_encoder->i2c, 0x50))
156
				break;
157
158
159
		}
	}

160
161
162
	/* eDP panel not detected, restore panel power GPIO to previous
	 * state to avoid confusing the SOR for other output types.
	 */
163
	if (!nv_encoder && panel == 0)
164
		nvkm_gpio_set(gpio, 0, DCB_GPIO_PANEL_POWER, 0xff, panel);
165

166
	return nv_encoder;
167
168
}

169
170
171
172
173
174
175
176
177
178
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 ||
179
180
	    !((nv_encoder = find_encoder(connector, DCB_OUTPUT_TMDS)) ||
	      (nv_encoder = find_encoder(connector, DCB_OUTPUT_ANALOG))))
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
		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;
}

199
200
201
202
203
static void
nouveau_connector_set_encoder(struct drm_connector *connector,
			      struct nouveau_encoder *nv_encoder)
{
	struct nouveau_connector *nv_connector = nouveau_connector(connector);
204
	struct nouveau_drm *drm = nouveau_drm(connector->dev);
205
206
207
208
209
210
	struct drm_device *dev = connector->dev;

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

211
	if (drm->device.info.family >= NV_DEVICE_INFO_V0_TESLA) {
212
213
214
		connector->interlace_allowed = true;
		connector->doublescan_allowed = true;
	} else
215
216
	if (nv_encoder->dcb->type == DCB_OUTPUT_LVDS ||
	    nv_encoder->dcb->type == DCB_OUTPUT_TMDS) {
217
218
219
220
		connector->doublescan_allowed = false;
		connector->interlace_allowed = false;
	} else {
		connector->doublescan_allowed = true;
221
222
		if (drm->device.info.family == NV_DEVICE_INFO_V0_KELVIN ||
		    (drm->device.info.family == NV_DEVICE_INFO_V0_CELSIUS &&
223
224
		     (dev->pdev->device & 0x0ff0) != 0x0100 &&
		     (dev->pdev->device & 0x0ff0) != 0x0150))
225
226
227
228
229
230
			/* HW is broken */
			connector->interlace_allowed = false;
		else
			connector->interlace_allowed = true;
	}

231
	if (nv_connector->type == DCB_CONNECTOR_DVI_I) {
232
		drm_object_property_set_value(&connector->base,
233
			dev->mode_config.dvi_i_subconnector_property,
234
			nv_encoder->dcb->type == DCB_OUTPUT_TMDS ?
235
236
237
238
239
240
			DRM_MODE_SUBCONNECTOR_DVID :
			DRM_MODE_SUBCONNECTOR_DVIA);
	}
}

static enum drm_connector_status
241
nouveau_connector_detect(struct drm_connector *connector, bool force)
242
243
{
	struct drm_device *dev = connector->dev;
244
	struct nouveau_drm *drm = nouveau_drm(dev);
245
246
	struct nouveau_connector *nv_connector = nouveau_connector(connector);
	struct nouveau_encoder *nv_encoder = NULL;
247
	struct nouveau_encoder *nv_partner;
248
	struct i2c_adapter *i2c;
249
	int type;
250
251
	int ret;
	enum drm_connector_status conn_status = connector_status_disconnected;
252

253
254
255
256
257
258
	/* 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;
	}
259

260
	ret = pm_runtime_get_sync(connector->dev->dev);
261
	if (ret < 0 && ret != -EACCES)
262
263
		return conn_status;

264
265
	nv_encoder = nouveau_connector_ddc_detect(connector);
	if (nv_encoder && (i2c = nv_encoder->i2c) != NULL) {
266
		nv_connector->edid = drm_get_edid(connector, i2c);
267
268
269
		drm_mode_connector_update_edid_property(connector,
							nv_connector->edid);
		if (!nv_connector->edid) {
270
			NV_ERROR(drm, "DDC responded, but no EDID for %s\n",
271
				 connector->name);
272
			goto detect_analog;
273
274
275
276
277
278
279
		}

		/* 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.
		 */
280
		nv_partner = NULL;
281
282
283
284
285
286
287
288
289
		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))) {
290
			if (nv_connector->edid->input & DRM_EDID_INPUT_DIGITAL)
291
				type = DCB_OUTPUT_TMDS;
292
			else
293
				type = DCB_OUTPUT_ANALOG;
294

295
			nv_encoder = find_encoder(connector, type);
296
297
298
		}

		nouveau_connector_set_encoder(connector, nv_encoder);
299
300
		conn_status = connector_status_connected;
		goto out;
301
302
	}

303
304
305
	nv_encoder = nouveau_connector_of_detect(connector);
	if (nv_encoder) {
		nouveau_connector_set_encoder(connector, nv_encoder);
306
307
		conn_status = connector_status_connected;
		goto out;
308
309
	}

310
detect_analog:
311
	nv_encoder = find_encoder(connector, DCB_OUTPUT_ANALOG);
312
	if (!nv_encoder && !nouveau_tv_disable)
313
		nv_encoder = find_encoder(connector, DCB_OUTPUT_TV);
314
	if (nv_encoder && force) {
315
		struct drm_encoder *encoder = to_drm_encoder(nv_encoder);
316
		const struct drm_encoder_helper_funcs *helper =
317
318
319
320
321
						encoder->helper_private;

		if (helper->detect(encoder, connector) ==
						connector_status_connected) {
			nouveau_connector_set_encoder(connector, nv_encoder);
322
323
			conn_status = connector_status_connected;
			goto out;
324
325
326
327
		}

	}

328
329
330
331
332
333
 out:

	pm_runtime_mark_last_busy(connector->dev->dev);
	pm_runtime_put_autosuspend(connector->dev->dev);

	return conn_status;
334
335
}

336
static enum drm_connector_status
337
nouveau_connector_detect_lvds(struct drm_connector *connector, bool force)
338
339
{
	struct drm_device *dev = connector->dev;
340
	struct nouveau_drm *drm = nouveau_drm(dev);
341
342
343
344
345
346
347
348
349
350
351
	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;
	}

352
	nv_encoder = find_encoder(connector, DCB_OUTPUT_LVDS);
353
354
355
	if (!nv_encoder)
		return connector_status_disconnected;

356
	/* Try retrieving EDID via DDC */
357
	if (!drm->vbios.fp_no_ddc) {
358
		status = nouveau_connector_detect(connector, force);
359
360
361
362
		if (status == connector_status_connected)
			goto out;
	}

363
364
365
366
367
368
369
370
371
372
	/* 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) {
373
		if ((nv_connector->edid = nouveau_acpi_edid(dev, connector))) {
374
375
376
377
378
			status = connector_status_connected;
			goto out;
		}
	}

379
380
381
382
	/* 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.
	 */
383
	if (nouveau_bios_fp_mode(dev, NULL) && (drm->vbios.fp_no_ddc ||
384
385
386
387
388
389
390
391
	    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.
	 */
392
	if (!drm->vbios.fp_no_ddc) {
393
394
395
		struct edid *edid =
			(struct edid *)nouveau_bios_embedded_edid(dev);
		if (edid) {
396
397
398
399
			nv_connector->edid =
					kmemdup(edid, EDID_LENGTH, GFP_KERNEL);
			if (nv_connector->edid)
				status = connector_status_connected;
400
401
402
403
404
405
406
407
408
409
410
411
		}
	}

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);
412
	nouveau_connector_set_encoder(connector, nv_encoder);
413
414
415
	return status;
}

416
417
418
static void
nouveau_connector_force(struct drm_connector *connector)
{
419
	struct nouveau_drm *drm = nouveau_drm(connector->dev);
420
	struct nouveau_connector *nv_connector = nouveau_connector(connector);
421
422
423
	struct nouveau_encoder *nv_encoder;
	int type;

424
	if (nv_connector->type == DCB_CONNECTOR_DVI_I) {
425
		if (connector->force == DRM_FORCE_ON_DIGITAL)
426
			type = DCB_OUTPUT_TMDS;
427
		else
428
			type = DCB_OUTPUT_ANALOG;
429
	} else
430
		type = DCB_OUTPUT_ANY;
431

432
	nv_encoder = find_encoder(connector, type);
433
	if (!nv_encoder) {
434
		NV_ERROR(drm, "can't find encoder to force %s on!\n",
435
			 connector->name);
436
437
438
439
440
441
442
443
444
445
446
		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)
{
447
	struct nouveau_display *disp = nouveau_display(connector->dev);
448
449
	struct nouveau_connector *nv_connector = nouveau_connector(connector);
	struct nouveau_encoder *nv_encoder = nv_connector->detected_encoder;
450
	struct drm_encoder *encoder = to_drm_encoder(nv_encoder);
451
	struct drm_device *dev = connector->dev;
452
	struct nouveau_crtc *nv_crtc;
453
454
	int ret;

455
456
457
458
	nv_crtc = NULL;
	if (connector->encoder && connector->encoder->crtc)
		nv_crtc = nouveau_crtc(connector->encoder->crtc);

459
460
461
462
463
464
	/* Scaling mode */
	if (property == dev->mode_config.scaling_mode_property) {
		bool modeset = false;

		switch (value) {
		case DRM_MODE_SCALE_NONE:
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
			/* We allow 'None' for EDID modes, even on a fixed
			 * panel (some exist with support for lower refresh
			 * rates, which people might want to use for power
			 * saving purposes).
			 *
			 * Non-EDID modes will force the use of GPU scaling
			 * to the native mode regardless of this setting.
			 */
			switch (nv_connector->type) {
			case DCB_CONNECTOR_LVDS:
			case DCB_CONNECTOR_LVDS_SPWG:
			case DCB_CONNECTOR_eDP:
				/* ... except prior to G80, where the code
				 * doesn't support such things.
				 */
				if (disp->disp.oclass < NV50_DISP)
					return -EINVAL;
				break;
			default:
				break;
			}
			break;
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
		case DRM_MODE_SCALE_FULLSCREEN:
		case DRM_MODE_SCALE_CENTER:
		case DRM_MODE_SCALE_ASPECT:
			break;
		default:
			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 {
514
			ret = nv_crtc->set_scale(nv_crtc, true);
515
516
517
518
519
520
521
			if (ret)
				return ret;
		}

		return 0;
	}

522
523
524
525
526
527
528
	/* Underscan */
	if (property == disp->underscan_property) {
		if (nv_connector->underscan != value) {
			nv_connector->underscan = value;
			if (!nv_crtc || !nv_crtc->set_scale)
				return 0;

529
			return nv_crtc->set_scale(nv_crtc, true);
530
531
532
533
534
535
536
537
538
539
540
		}

		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;

541
			return nv_crtc->set_scale(nv_crtc, true);
542
543
544
545
546
547
548
549
550
551
552
		}

		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;

553
			return nv_crtc->set_scale(nv_crtc, true);
554
555
556
557
558
		}

		return 0;
	}

559
	/* Dithering */
560
561
562
563
564
565
566
	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);
	}
567

568
569
	if (property == disp->dithering_depth) {
		nv_connector->dithering_depth = value;
570
571
572
		if (!nv_crtc || !nv_crtc->set_dither)
			return 0;

573
		return nv_crtc->set_dither(nv_crtc, true);
574
575
	}

576
577
578
579
580
581
582
583
584
585
586
587
588
	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);
		}
	}

589
	if (nv_encoder && nv_encoder->dcb->type == DCB_OUTPUT_TV)
590
591
		return get_slave_funcs(encoder)->set_property(
			encoder, connector, property, value);
592
593
594
595
596

	return -EINVAL;
}

static struct drm_display_mode *
597
nouveau_connector_native_mode(struct drm_connector *connector)
598
{
599
	const struct drm_connector_helper_funcs *helper = connector->helper_private;
600
	struct nouveau_drm *drm = nouveau_drm(connector->dev);
601
602
	struct nouveau_connector *nv_connector = nouveau_connector(connector);
	struct drm_device *dev = connector->dev;
603
604
605
	struct drm_display_mode *mode, *largest = NULL;
	int high_w = 0, high_h = 0, high_v = 0;

606
	list_for_each_entry(mode, &nv_connector->base.probed_modes, head) {
607
		mode->vrefresh = drm_mode_vrefresh(mode);
608
609
		if (helper->mode_valid(connector, mode) != MODE_OK ||
		    (mode->flags & DRM_MODE_FLAG_INTERLACE))
610
611
612
			continue;

		/* Use preferred mode if there is one.. */
613
		if (mode->type & DRM_MODE_TYPE_PREFERRED) {
614
			NV_DEBUG(drm, "native mode from preferred\n");
615
616
617
			return drm_mode_duplicate(dev, mode);
		}

618
619
620
		/* Otherwise, take the resolution with the largest width, then
		 * height, then vertical refresh
		 */
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
		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;
	}

637
	NV_DEBUG(drm, "native mode from largest: %dx%d@%d\n",
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
665
666
667
668
669
670
671
672
673
674
675
676
677
678
		      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 &&
679
680
681
		    mode->vdisplay <= native->vdisplay &&
		    (mode->hdisplay != native->hdisplay ||
		     mode->vdisplay != native->vdisplay)) {
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
			m = drm_cvt_mode(dev, mode->hdisplay, mode->vdisplay,
					 drm_mode_vrefresh(native), false,
					 false, false);
			if (!m)
				continue;

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

		mode++;
	}

	return modes;
}

698
699
700
static void
nouveau_connector_detect_depth(struct drm_connector *connector)
{
701
	struct nouveau_drm *drm = nouveau_drm(connector->dev);
702
703
	struct nouveau_connector *nv_connector = nouveau_connector(connector);
	struct nouveau_encoder *nv_encoder = nv_connector->detected_encoder;
704
	struct nvbios *bios = &drm->vbios;
705
706
707
708
709
710
711
	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;

712
713
714
715
716
717
718
	/* 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 */
719
	if (nv_encoder->dcb->type != DCB_OUTPUT_LVDS) {
720
		connector->display_info.bpc = 8;
721
		return;
722
723
724
	}

	connector->display_info.bpc = 6;
725
726
727
728
729
730
731
732
733
734
735
736

	/* 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 &&
737
	    nv_connector->type == DCB_CONNECTOR_LVDS_SPWG)
738
739
740
741
742
743
744
745
746
		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;
}

747
748
749
750
static int
nouveau_connector_get_modes(struct drm_connector *connector)
{
	struct drm_device *dev = connector->dev;
751
	struct nouveau_drm *drm = nouveau_drm(dev);
752
753
	struct nouveau_connector *nv_connector = nouveau_connector(connector);
	struct nouveau_encoder *nv_encoder = nv_connector->detected_encoder;
754
	struct drm_encoder *encoder = to_drm_encoder(nv_encoder);
755
756
	int ret = 0;

757
	/* destroy the native mode, the attached monitor could have changed.
758
	 */
759
	if (nv_connector->native_mode) {
760
761
762
763
764
765
		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);
766
	else
767
	if (nv_encoder->dcb->type == DCB_OUTPUT_LVDS &&
768
	    (nv_encoder->dcb->lvdsconf.use_straps_for_mode ||
769
	     drm->vbios.fp_no_ddc) && nouveau_bios_fp_mode(dev, NULL)) {
770
771
772
773
		struct drm_display_mode mode;

		nouveau_bios_fp_mode(dev, &mode);
		nv_connector->native_mode = drm_mode_duplicate(dev, &mode);
774
	}
775

776
777
778
779
780
781
	/* 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);

782
783
784
785
786
787
	/* 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 =
788
			nouveau_connector_native_mode(connector);
789
790
791
792
793
794
795
796
	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;
	}

797
798
799
	/* 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...
800
	 */
801
802
	if (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)
		nouveau_connector_detect_depth(connector);
803

804
	if (nv_encoder->dcb->type == DCB_OUTPUT_TV)
805
		ret = get_slave_funcs(encoder)->get_modes(encoder, connector);
806

807
808
809
	if (nv_connector->type == DCB_CONNECTOR_LVDS ||
	    nv_connector->type == DCB_CONNECTOR_LVDS_SPWG ||
	    nv_connector->type == DCB_CONNECTOR_eDP)
810
811
812
813
814
		ret += nouveau_connector_scaler_modes_add(connector);

	return ret;
}

815
static unsigned
816
get_tmds_link_bandwidth(struct drm_connector *connector, bool hdmi)
817
818
{
	struct nouveau_connector *nv_connector = nouveau_connector(connector);
819
	struct nouveau_drm *drm = nouveau_drm(connector->dev);
820
	struct dcb_output *dcb = nv_connector->detected_encoder->dcb;
821

822
823
824
825
826
827
828
829
830
831
832
	if (hdmi) {
		if (nouveau_hdmimhz > 0)
			return nouveau_hdmimhz * 1000;
		/* Note: these limits are conservative, some Fermi's
		 * can do 297 MHz. Unclear how this can be determined.
		 */
		if (drm->device.info.family >= NV_DEVICE_INFO_V0_KEPLER)
			return 297000;
		if (drm->device.info.family >= NV_DEVICE_INFO_V0_FERMI)
			return 225000;
	}
833
	if (dcb->location != DCB_LOC_ON_CHIP ||
834
	    drm->device.info.chipset >= 0x46)
835
		return 165000;
836
	else if (drm->device.info.chipset >= 0x40)
837
		return 155000;
838
	else if (drm->device.info.chipset >= 0x18)
839
840
841
842
843
		return 135000;
	else
		return 112000;
}

844
845
846
847
848
849
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;
850
	struct drm_encoder *encoder = to_drm_encoder(nv_encoder);
851
852
	unsigned min_clock = 25000, max_clock = min_clock;
	unsigned clock = mode->clock;
853
	bool hdmi;
854
855

	switch (nv_encoder->dcb->type) {
856
	case DCB_OUTPUT_LVDS:
857
858
859
		if (nv_connector->native_mode &&
		    (mode->hdisplay > nv_connector->native_mode->hdisplay ||
		     mode->vdisplay > nv_connector->native_mode->vdisplay))
860
861
862
863
864
			return MODE_PANEL;

		min_clock = 0;
		max_clock = 400000;
		break;
865
	case DCB_OUTPUT_TMDS:
866
867
868
869
		hdmi = drm_detect_hdmi_monitor(nv_connector->edid);
		max_clock = get_tmds_link_bandwidth(connector, hdmi);
		if (!hdmi && nouveau_duallink &&
		    nv_encoder->dcb->duallink_possible)
870
			max_clock *= 2;
871
		break;
872
	case DCB_OUTPUT_ANALOG:
873
874
875
876
		max_clock = nv_encoder->dcb->crtconf.maxfreq;
		if (!max_clock)
			max_clock = 350000;
		break;
877
	case DCB_OUTPUT_TV:
878
		return get_slave_funcs(encoder)->mode_valid(encoder, mode);
879
	case DCB_OUTPUT_DP:
880
881
		max_clock  = nv_encoder->dp.link_nr;
		max_clock *= nv_encoder->dp.link_bw;
882
		clock = clock * (connector->display_info.bpc * 3) / 10;
883
		break;
884
885
886
	default:
		BUG_ON(1);
		return MODE_BAD;
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
	}

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

926
927
928
929
930
931
932
933
934
static const struct drm_connector_funcs
nouveau_connector_funcs_lvds = {
	.dpms = drm_helper_connector_dpms,
	.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
};
935

936
static int
937
938
939
940
941
942
943
944
945
946
nouveau_connector_dp_dpms(struct drm_connector *connector, int mode)
{
	struct nouveau_encoder *nv_encoder = NULL;

	if (connector->encoder)
		nv_encoder = nouveau_encoder(connector->encoder);
	if (nv_encoder && nv_encoder->dcb &&
	    nv_encoder->dcb->type == DCB_OUTPUT_DP) {
		if (mode == DRM_MODE_DPMS_ON) {
			u8 data = DP_SET_POWER_D0;
947
			nvkm_wraux(nv_encoder->aux, DP_SET_POWER, &data, 1);
948
949
950
			usleep_range(1000, 2000);
		} else {
			u8 data = DP_SET_POWER_D3;
951
			nvkm_wraux(nv_encoder->aux, DP_SET_POWER, &data, 1);
952
953
954
		}
	}

955
	return drm_helper_connector_dpms(connector, mode);
956
957
958
959
960
961
962
963
964
965
966
967
}

static const struct drm_connector_funcs
nouveau_connector_funcs_dp = {
	.dpms = nouveau_connector_dp_dpms,
	.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
};

968
static int
969
nouveau_connector_hotplug(struct nvif_notify *notify)
970
971
{
	struct nouveau_connector *nv_connector =
972
		container_of(notify, typeof(*nv_connector), hpd);
973
	struct drm_connector *connector = &nv_connector->base;
974
	struct nouveau_drm *drm = nouveau_drm(connector->dev);
975
	const struct nvif_notify_conn_rep_v0 *rep = notify->data;
976
	const char *name = connector->name;
977

978
	if (rep->mask & NVIF_NOTIFY_CONN_V0_IRQ) {
979
	} else {
980
		bool plugged = (rep->mask != NVIF_NOTIFY_CONN_V0_UNPLUG);
981

982
		NV_DEBUG(drm, "%splugged %s\n", plugged ? "" : "un", name);
983

984
985
986
987
988
989
990
		if (plugged)
			drm_helper_connector_dpms(connector, DRM_MODE_DPMS_ON);
		else
			drm_helper_connector_dpms(connector, DRM_MODE_DPMS_OFF);
		drm_helper_hpd_irq_event(connector->dev);
	}

991
	return NVIF_NOTIFY_KEEP;
992
993
}

994
static ssize_t
995
nouveau_connector_aux_xfer(struct drm_dp_aux *obj, struct drm_dp_aux_msg *msg)
996
997
{
	struct nouveau_connector *nv_connector =
998
		container_of(obj, typeof(*nv_connector), aux);
999
	struct nouveau_encoder *nv_encoder;
1000
	struct nvkm_i2c_aux *aux;
1001
1002
1003
	int ret;

	nv_encoder = find_encoder(&nv_connector->base, DCB_OUTPUT_DP);
1004
	if (!nv_encoder || !(aux = nv_encoder->aux))
1005
1006
1007
1008
1009
1010
		return -ENODEV;
	if (WARN_ON(msg->size > 16))
		return -E2BIG;
	if (msg->size == 0)
		return msg->size;

1011
	ret = nvkm_i2c_aux_acquire(aux);
1012
1013
1014
	if (ret)
		return ret;

1015
1016
1017
	ret = nvkm_i2c_aux_xfer(aux, false, msg->request, msg->address,
				msg->buffer, msg->size);
	nvkm_i2c_aux_release(aux);
1018
1019
1020
1021
1022
1023
1024
1025
	if (ret >= 0) {
		msg->reply = ret;
		return msg->size;
	}

	return ret;
}

1026
1027
1028
1029
1030
1031
1032
1033
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;
1034
1035
	case DCB_CONNECTOR_DMS59_0  :
	case DCB_CONNECTOR_DMS59_1  :
1036
1037
1038
1039
	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;
1040
1041
	case DCB_CONNECTOR_DMS59_DP0:
	case DCB_CONNECTOR_DMS59_DP1:
1042
1043
1044
	case DCB_CONNECTOR_DP       : return DRM_MODE_CONNECTOR_DisplayPort;
	case DCB_CONNECTOR_eDP      : return DRM_MODE_CONNECTOR_eDP;
	case DCB_CONNECTOR_HDMI_0   :
1045
1046
	case DCB_CONNECTOR_HDMI_1   :
	case DCB_CONNECTOR_HDMI_C   : return DRM_MODE_CONNECTOR_HDMIA;
1047
1048
1049
1050
1051
1052
1053
	default:
		break;
	}

	return DRM_MODE_CONNECTOR_Unknown;
}

1054
1055
struct drm_connector *
nouveau_connector_create(struct drm_device *dev, int index)
1056
{
1057
	const struct drm_connector_funcs *funcs = &nouveau_connector_funcs;
1058
1059
	struct nouveau_drm *drm = nouveau_drm(dev);
	struct nouveau_display *disp = nouveau_display(dev);
1060
1061
	struct nouveau_connector *nv_connector = NULL;
	struct drm_connector *connector;
1062
	int type, ret = 0;
1063
	bool dummy;
1064

1065
1066
1067
1068
	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
		nv_connector = nouveau_connector(connector);
		if (nv_connector->index == index)
			return connector;
1069
1070
	}

1071
1072
	nv_connector = kzalloc(sizeof(*nv_connector), GFP_KERNEL);
	if (!nv_connector)
1073
		return ERR_PTR(-ENOMEM);
1074

1075
	connector = &nv_connector->base;
1076
1077
1078
	nv_connector->index = index;

	/* attempt to parse vbios connector type and hotplug gpio */
1079
	nv_connector->dcb = olddcb_conn(dev, index);
1080
1081
	if (nv_connector->dcb) {
		u32 entry = ROM16(nv_connector->dcb[0]);
1082
		if (olddcb_conntab(dev)[3] >= 4)
1083
1084
1085
1086
1087
			entry |= (u32)ROM16(nv_connector->dcb[2]) << 16;

		nv_connector->type = nv_connector->dcb[0];
		if (drm_conntype_from_dcb(nv_connector->type) ==
					  DRM_MODE_CONNECTOR_Unknown) {
1088
			NV_WARN(drm, "unknown connector type %02x\n",
1089
1090
1091
				nv_connector->type);
			nv_connector->type = DCB_CONNECTOR_NONE;
		}
1092

1093
1094
1095
1096
1097
		/* 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;
		}
1098

1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
		/* 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;
	}

	/* no vbios data, or an unknown dcb connector type - attempt to
	 * figure out something suitable ourselves
	 */
	if (nv_connector->type == DCB_CONNECTOR_NONE) {
1112
1113
		struct nouveau_drm *drm = nouveau_drm(dev);
		struct dcb_table *dcbt = &drm->vbios.dcb;
1114
1115
1116
1117
1118
1119
1120
		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);
		}
1121

1122
1123
		if (encoders & (1 << DCB_OUTPUT_DP)) {
			if (encoders & (1 << DCB_OUTPUT_TMDS))
1124
1125
1126
1127
				nv_connector->type = DCB_CONNECTOR_DP;
			else
				nv_connector->type = DCB_CONNECTOR_eDP;
		} else
1128
1129
		if (encoders & (1 << DCB_OUTPUT_TMDS)) {
			if (encoders & (1 << DCB_OUTPUT_ANALOG))
1130
1131
1132
1133
				nv_connector->type = DCB_CONNECTOR_DVI_I;
			else
				nv_connector->type = DCB_CONNECTOR_DVI_D;
		} else
1134
		if (encoders & (1 << DCB_OUTPUT_ANALOG)) {
1135
1136
			nv_connector->type = DCB_CONNECTOR_VGA;
		} else
1137
		if (encoders & (1 << DCB_OUTPUT_LVDS)) {
1138
1139
			nv_connector->type = DCB_CONNECTOR_LVDS;
		} else
1140
		if (encoders & (1 << DCB_OUTPUT_TV)) {
1141
1142
1143
			nv_connector->type = DCB_CONNECTOR_TV_0;
		}
	}
1144

1145
1146
	switch ((type = drm_conntype_from_dcb(nv_connector->type))) {
	case DRM_MODE_CONNECTOR_LVDS:
1147
		ret = nouveau_bios_parse_lvds_table(dev, 0, &dummy, &dummy);
1148
		if (ret) {
1149
			NV_ERROR(drm, "Error parsing LVDS table, disabling\n");
1150
1151
			kfree(nv_connector);
			return ERR_PTR(ret);
1152
		}
1153
1154

		funcs = &nouveau_connector_funcs_lvds;
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
		break;
	case DRM_MODE_CONNECTOR_DisplayPort:
	case DRM_MODE_CONNECTOR_eDP:
		nv_connector->aux.dev = dev->dev;
		nv_connector->aux.transfer = nouveau_connector_aux_xfer;
		ret = drm_dp_aux_register(&nv_connector->aux);
		if (ret) {
			NV_ERROR(drm, "failed to register aux channel\n");
			kfree(nv_connector);
			return ERR_PTR(ret);
		}

1167
		funcs = &nouveau_connector_funcs_dp;