nouveau_connector.c 36.6 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
#include <nvif/cl0046.h>
46
47
#include <nvif/event.h>

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

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

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

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

64
struct nouveau_encoder *
65
find_encoder(struct drm_connector *connector, int type)
66
67
68
{
	struct drm_device *dev = connector->dev;
	struct nouveau_encoder *nv_encoder;
Rob Clark's avatar
Rob Clark committed
69
	struct drm_encoder *enc;
70
71
72
73
74
75
76
	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
77
78
		enc = drm_encoder_find(dev, id);
		if (!enc)
79
			continue;
Rob Clark's avatar
Rob Clark committed
80
		nv_encoder = nouveau_encoder(enc);
81

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

117
118
static struct nouveau_encoder *
nouveau_connector_ddc_detect(struct drm_connector *connector)
119
120
{
	struct drm_device *dev = connector->dev;
121
	struct nouveau_connector *nv_connector = nouveau_connector(connector);
122
	struct nouveau_drm *drm = nouveau_drm(dev);
123
	struct nvkm_gpio *gpio = nvxx_gpio(&drm->device);
124
	struct nouveau_encoder *nv_encoder;
Rob Clark's avatar
Rob Clark committed
125
	struct drm_encoder *encoder;
126
127
128
129
130
131
132
	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) {
133
		panel = nvkm_gpio_get(gpio, 0, DCB_GPIO_PANEL_POWER, 0xff);
134
		if (panel == 0) {
135
			nvkm_gpio_set(gpio, 0, DCB_GPIO_PANEL_POWER, 0xff, 1);
136
137
138
			msleep(300);
		}
	}
139

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

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

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

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

167
	return nv_encoder;
168
169
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	}

329
330
331
332
333
334
 out:

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

	return conn_status;
335
336
}

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

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

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

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

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

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

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

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

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

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

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

		switch (value) {
		case DRM_MODE_SCALE_NONE:
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
			/* 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;
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
514
		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 {
515
			ret = nv_crtc->set_scale(nv_crtc, true);
516
517
518
519
520
521
522
			if (ret)
				return ret;
		}

		return 0;
	}

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

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

		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;

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

		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;

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

		return 0;
	}

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

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

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

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

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

	return -EINVAL;
}

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

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

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

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

638
	NV_DEBUG(drm, "native mode from largest: %dx%d@%d\n",
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
679
		      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 &&
680
681
682
		    mode->vdisplay <= native->vdisplay &&
		    (mode->hdisplay != native->hdisplay ||
		     mode->vdisplay != native->vdisplay)) {
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
			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;
}

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

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

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

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

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

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

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

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

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

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

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

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

	return ret;
}

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

823
824
825
826
827
828
829
830
831
832
833
	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;
	}
834
	if (dcb->location != DCB_LOC_ON_CHIP ||
835
	    drm->device.info.chipset >= 0x46)
836
		return 165000;
837
	else if (drm->device.info.chipset >= 0x40)
838
		return 155000;
839
	else if (drm->device.info.chipset >= 0x18)
840
841
842
843
844
		return 135000;
	else
		return 112000;
}

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

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

		min_clock = 0;
		max_clock = 400000;
		break;
866
	case DCB_OUTPUT_TMDS:
867
868
869
870
		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)
871
			max_clock *= 2;
872
		break;
873
	case DCB_OUTPUT_ANALOG:
874
875
876
877
		max_clock = nv_encoder->dcb->crtconf.maxfreq;
		if (!max_clock)
			max_clock = 350000;
		break;
878
	case DCB_OUTPUT_TV:
879
		return get_slave_funcs(encoder)->mode_valid(encoder, mode);
880
	case DCB_OUTPUT_DP:
881
882
		max_clock  = nv_encoder->dp.link_nr;
		max_clock *= nv_encoder->dp.link_bw;
883
		clock = clock * (connector->display_info.bpc * 3) / 10;
884
		break;
885
886
887
	default:
		BUG_ON(1);
		return MODE_BAD;
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
926
	}

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

927
928
929
930
931
932
933
934
935
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
};
936

937
static int
938
939
940
941
942
943
944
945
946
947
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;
948
			nvkm_wraux(nv_encoder->aux, DP_SET_POWER, &data, 1);
949
950
951
			usleep_range(1000, 2000);
		} else {
			u8 data = DP_SET_POWER_D3;
952
			nvkm_wraux(nv_encoder->aux, DP_SET_POWER, &data, 1);
953
954
955
		}
	}

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

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

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

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

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

985
986
987
988
989
990
991
		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);
	}

992
	return NVIF_NOTIFY_KEEP;
993
994
}

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

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

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

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

	return ret;
}

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

	return DRM_MODE_CONNECTOR_Unknown;
}

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

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

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

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

	/* attempt to parse vbios connector type and hotplug gpio */
1080
	nv_connector->dcb = olddcb_conn(dev, index);
1081
1082
	if (nv_connector->dcb) {
		u32 entry = ROM16(nv_connector->dcb[0]);
1083
		if (olddcb_conntab(dev)[3] >= 4)
1084
1085
1086
1087
1088
			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) {
1089
			NV_WARN(drm, "unknown connector type %02x\n",
1090
1091
1092
				nv_connector->type);
			nv_connector->type = DCB_CONNECTOR_NONE;
		}
1093

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

1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
		/* 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) {
1113
1114
		struct nouveau_drm *drm = nouveau_drm(dev);
		struct dcb_table *dcbt = &drm->vbios.dcb;
1115
1116
1117
1118
1119
1120
1121
		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);
		}
1122

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

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

		funcs = &nouveau_connector_funcs_lvds;
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
		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);
		}