nouveau_connector.c 35.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 <subdev/i2c.h>
#include <subdev/gpio.h>
47
#include <engine/disp.h>
48
49
50
51
52
53
54
55
56
57
58
59

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);
60

61
struct nouveau_encoder *
62
find_encoder(struct drm_connector *connector, int type)
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
{
	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));

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

114
static struct nouveau_i2c_port *
115
116
117
118
nouveau_connector_ddc_detect(struct drm_connector *connector,
			     struct nouveau_encoder **pnv_encoder)
{
	struct drm_device *dev = connector->dev;
119
	struct nouveau_connector *nv_connector = nouveau_connector(connector);
120
	struct nouveau_drm *drm = nouveau_drm(dev);
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
	struct nouveau_gpio *gpio = nouveau_gpio(drm->device);
	struct nouveau_i2c_port *port = NULL;
	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) {
		panel = gpio->get(gpio, 0, DCB_GPIO_PANEL_POWER, 0xff);
		if (panel == 0) {
			gpio->set(gpio, 0, DCB_GPIO_PANEL_POWER, 0xff, 1);
			msleep(300);
		}
	}
136
137
138
139
140
141
142
143
144
145
146
147
148
149

	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
		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));
150

151
		port = nv_encoder->i2c;
152
		if (port && nv_probe_i2c(port, 0x50)) {
153
			*pnv_encoder = nv_encoder;
154
			break;
155
		}
156
157

		port = NULL;
158
159
	}

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

	return port;
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 (nv_device(drm->device)->card_type >= NV_50) {
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
		if (nv_device(drm->device)->card_type == NV_20 ||
222
223
224
225
		    ((nv_device(drm->device)->card_type == NV_10 ||
		      nv_device(drm->device)->card_type == NV_11) &&
		     (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 nouveau_i2c_port *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
267
268
269
270
	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) {
271
			NV_ERROR(drm, "DDC responded, but no EDID for %s\n",
272
				 connector->name);
273
			goto detect_analog;
274
275
		}

276
		if (nv_encoder->dcb->type == DCB_OUTPUT_DP &&
277
		    !nouveau_dp_detect(to_drm_encoder(nv_encoder))) {
278
			NV_ERROR(drm, "Detected %s, but failed init\n",
279
				 connector->name);
280
281
			conn_status = connector_status_disconnected;
			goto out;
282
283
284
285
286
287
288
		}

		/* 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.
		 */
289
		nv_partner = NULL;
290
291
292
293
294
295
296
297
298
		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))) {
299
			if (nv_connector->edid->input & DRM_EDID_INPUT_DIGITAL)
300
				type = DCB_OUTPUT_TMDS;
301
			else
302
				type = DCB_OUTPUT_ANALOG;
303

304
			nv_encoder = find_encoder(connector, type);
305
306
307
		}

		nouveau_connector_set_encoder(connector, nv_encoder);
308
309
		conn_status = connector_status_connected;
		goto out;
310
311
	}

312
313
314
	nv_encoder = nouveau_connector_of_detect(connector);
	if (nv_encoder) {
		nouveau_connector_set_encoder(connector, nv_encoder);
315
316
		conn_status = connector_status_connected;
		goto out;
317
318
	}

319
detect_analog:
320
	nv_encoder = find_encoder(connector, DCB_OUTPUT_ANALOG);
321
	if (!nv_encoder && !nouveau_tv_disable)
322
		nv_encoder = find_encoder(connector, DCB_OUTPUT_TV);
323
	if (nv_encoder && force) {
324
325
326
327
328
329
330
		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);
331
332
			conn_status = connector_status_connected;
			goto out;
333
334
335
336
		}

	}

337
338
339
340
341
342
 out:

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

	return conn_status;
343
344
}

345
static enum drm_connector_status
346
nouveau_connector_detect_lvds(struct drm_connector *connector, bool force)
347
348
{
	struct drm_device *dev = connector->dev;
349
	struct nouveau_drm *drm = nouveau_drm(dev);
350
351
352
353
354
355
356
357
358
359
360
	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;
	}

361
	nv_encoder = find_encoder(connector, DCB_OUTPUT_LVDS);
362
363
364
	if (!nv_encoder)
		return connector_status_disconnected;

365
	/* Try retrieving EDID via DDC */
366
	if (!drm->vbios.fp_no_ddc) {
367
		status = nouveau_connector_detect(connector, force);
368
369
370
371
		if (status == connector_status_connected)
			goto out;
	}

372
373
374
375
376
377
378
379
380
381
	/* 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) {
382
		if ((nv_connector->edid = nouveau_acpi_edid(dev, connector))) {
383
384
385
386
387
			status = connector_status_connected;
			goto out;
		}
	}

388
389
390
391
	/* 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.
	 */
392
	if (nouveau_bios_fp_mode(dev, NULL) && (drm->vbios.fp_no_ddc ||
393
394
395
396
397
398
399
400
	    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.
	 */
401
	if (!drm->vbios.fp_no_ddc) {
402
403
404
		struct edid *edid =
			(struct edid *)nouveau_bios_embedded_edid(dev);
		if (edid) {
405
406
407
408
			nv_connector->edid =
					kmemdup(edid, EDID_LENGTH, GFP_KERNEL);
			if (nv_connector->edid)
				status = connector_status_connected;
409
410
411
412
413
414
415
416
417
418
419
420
		}
	}

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);
421
	nouveau_connector_set_encoder(connector, nv_encoder);
422
423
424
	return status;
}

425
426
427
static void
nouveau_connector_force(struct drm_connector *connector)
{
428
	struct nouveau_drm *drm = nouveau_drm(connector->dev);
429
	struct nouveau_connector *nv_connector = nouveau_connector(connector);
430
431
432
	struct nouveau_encoder *nv_encoder;
	int type;

433
	if (nv_connector->type == DCB_CONNECTOR_DVI_I) {
434
		if (connector->force == DRM_FORCE_ON_DIGITAL)
435
			type = DCB_OUTPUT_TMDS;
436
		else
437
			type = DCB_OUTPUT_ANALOG;
438
	} else
439
		type = DCB_OUTPUT_ANY;
440

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

464
465
466
467
	nv_crtc = NULL;
	if (connector->encoder && connector->encoder->crtc)
		nv_crtc = nouveau_crtc(connector->encoder->crtc);

468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
	/* 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 */
483
		if (connector->connector_type == DRM_MODE_CONNECTOR_LVDS &&
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
		    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 {
506
			ret = nv_crtc->set_scale(nv_crtc, true);
507
508
509
510
511
512
513
			if (ret)
				return ret;
		}

		return 0;
	}

514
515
516
517
518
519
520
	/* Underscan */
	if (property == disp->underscan_property) {
		if (nv_connector->underscan != value) {
			nv_connector->underscan = value;
			if (!nv_crtc || !nv_crtc->set_scale)
				return 0;

521
			return nv_crtc->set_scale(nv_crtc, true);
522
523
524
525
526
527
528
529
530
531
532
		}

		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;

533
			return nv_crtc->set_scale(nv_crtc, true);
534
535
536
537
538
539
540
541
542
543
544
		}

		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;

545
			return nv_crtc->set_scale(nv_crtc, true);
546
547
548
549
550
		}

		return 0;
	}

551
	/* Dithering */
552
553
554
555
556
557
558
	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);
	}
559

560
561
	if (property == disp->dithering_depth) {
		nv_connector->dithering_depth = value;
562
563
564
		if (!nv_crtc || !nv_crtc->set_dither)
			return 0;

565
		return nv_crtc->set_dither(nv_crtc, true);
566
567
	}

568
569
570
571
572
573
574
575
576
577
578
579
580
	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);
		}
	}

581
	if (nv_encoder && nv_encoder->dcb->type == DCB_OUTPUT_TV)
582
583
		return get_slave_funcs(encoder)->set_property(
			encoder, connector, property, value);
584
585
586
587
588

	return -EINVAL;
}

static struct drm_display_mode *
589
nouveau_connector_native_mode(struct drm_connector *connector)
590
{
591
	struct drm_connector_helper_funcs *helper = connector->helper_private;
592
	struct nouveau_drm *drm = nouveau_drm(connector->dev);
593
594
	struct nouveau_connector *nv_connector = nouveau_connector(connector);
	struct drm_device *dev = connector->dev;
595
596
597
	struct drm_display_mode *mode, *largest = NULL;
	int high_w = 0, high_h = 0, high_v = 0;

598
	list_for_each_entry(mode, &nv_connector->base.probed_modes, head) {
599
		mode->vrefresh = drm_mode_vrefresh(mode);
600
601
		if (helper->mode_valid(connector, mode) != MODE_OK ||
		    (mode->flags & DRM_MODE_FLAG_INTERLACE))
602
603
604
			continue;

		/* Use preferred mode if there is one.. */
605
		if (mode->type & DRM_MODE_TYPE_PREFERRED) {
606
			NV_DEBUG(drm, "native mode from preferred\n");
607
608
609
			return drm_mode_duplicate(dev, mode);
		}

610
611
612
		/* Otherwise, take the resolution with the largest width, then
		 * height, then vertical refresh
		 */
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
		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;
	}

629
	NV_DEBUG(drm, "native mode from largest: %dx%d@%d\n",
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
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
		      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;
}

690
691
692
static void
nouveau_connector_detect_depth(struct drm_connector *connector)
{
693
	struct nouveau_drm *drm = nouveau_drm(connector->dev);
694
695
	struct nouveau_connector *nv_connector = nouveau_connector(connector);
	struct nouveau_encoder *nv_encoder = nv_connector->detected_encoder;
696
	struct nvbios *bios = &drm->vbios;
697
698
699
700
701
702
703
	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;

704
705
706
707
708
709
710
	/* 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 */
711
	if (nv_encoder->dcb->type != DCB_OUTPUT_LVDS) {
712
		connector->display_info.bpc = 8;
713
		return;
714
715
716
	}

	connector->display_info.bpc = 6;
717
718
719
720
721
722
723
724
725
726
727
728

	/* 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 &&
729
	    nv_connector->type == DCB_CONNECTOR_LVDS_SPWG)
730
731
732
733
734
735
736
737
738
		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;
}

739
740
741
742
static int
nouveau_connector_get_modes(struct drm_connector *connector)
{
	struct drm_device *dev = connector->dev;
743
	struct nouveau_drm *drm = nouveau_drm(dev);
744
745
	struct nouveau_connector *nv_connector = nouveau_connector(connector);
	struct nouveau_encoder *nv_encoder = nv_connector->detected_encoder;
746
	struct drm_encoder *encoder = to_drm_encoder(nv_encoder);
747
748
	int ret = 0;

749
	/* destroy the native mode, the attached monitor could have changed.
750
	 */
751
	if (nv_connector->native_mode) {
752
753
754
755
756
757
		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);
758
	else
759
	if (nv_encoder->dcb->type == DCB_OUTPUT_LVDS &&
760
	    (nv_encoder->dcb->lvdsconf.use_straps_for_mode ||
761
	     drm->vbios.fp_no_ddc) && nouveau_bios_fp_mode(dev, NULL)) {
762
763
764
765
		struct drm_display_mode mode;

		nouveau_bios_fp_mode(dev, &mode);
		nv_connector->native_mode = drm_mode_duplicate(dev, &mode);
766
	}
767

768
769
770
771
772
773
	/* 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);

774
775
776
777
778
779
	/* 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 =
780
			nouveau_connector_native_mode(connector);
781
782
783
784
785
786
787
788
	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;
	}

789
790
791
	/* 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...
792
	 */
793
794
	if (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)
		nouveau_connector_detect_depth(connector);
795

796
	if (nv_encoder->dcb->type == DCB_OUTPUT_TV)
797
		ret = get_slave_funcs(encoder)->get_modes(encoder, connector);
798

799
800
801
	if (nv_connector->type == DCB_CONNECTOR_LVDS ||
	    nv_connector->type == DCB_CONNECTOR_LVDS_SPWG ||
	    nv_connector->type == DCB_CONNECTOR_eDP)
802
803
804
805
806
		ret += nouveau_connector_scaler_modes_add(connector);

	return ret;
}

807
808
809
810
static unsigned
get_tmds_link_bandwidth(struct drm_connector *connector)
{
	struct nouveau_connector *nv_connector = nouveau_connector(connector);
811
	struct nouveau_drm *drm = nouveau_drm(connector->dev);
812
	struct dcb_output *dcb = nv_connector->detected_encoder->dcb;
813
814

	if (dcb->location != DCB_LOC_ON_CHIP ||
815
	    nv_device(drm->device)->chipset >= 0x46)
816
		return 165000;
817
	else if (nv_device(drm->device)->chipset >= 0x40)
818
		return 155000;
819
	else if (nv_device(drm->device)->chipset >= 0x18)
820
821
822
823
824
		return 135000;
	else
		return 112000;
}

825
826
827
828
829
830
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;
831
	struct drm_encoder *encoder = to_drm_encoder(nv_encoder);
832
833
834
835
	unsigned min_clock = 25000, max_clock = min_clock;
	unsigned clock = mode->clock;

	switch (nv_encoder->dcb->type) {
836
	case DCB_OUTPUT_LVDS:
837
838
839
		if (nv_connector->native_mode &&
		    (mode->hdisplay > nv_connector->native_mode->hdisplay ||
		     mode->vdisplay > nv_connector->native_mode->vdisplay))
840
841
842
843
844
			return MODE_PANEL;

		min_clock = 0;
		max_clock = 400000;
		break;
845
	case DCB_OUTPUT_TMDS:
846
847
848
		max_clock = get_tmds_link_bandwidth(connector);
		if (nouveau_duallink && nv_encoder->dcb->duallink_possible)
			max_clock *= 2;
849
		break;
850
	case DCB_OUTPUT_ANALOG:
851
852
853
854
		max_clock = nv_encoder->dcb->crtconf.maxfreq;
		if (!max_clock)
			max_clock = 350000;
		break;
855
	case DCB_OUTPUT_TV:
856
		return get_slave_funcs(encoder)->mode_valid(encoder, mode);
857
	case DCB_OUTPUT_DP:
858
859
		max_clock  = nv_encoder->dp.link_nr;
		max_clock *= nv_encoder->dp.link_bw;
860
		clock = clock * (connector->display_info.bpc * 3) / 10;
861
		break;
862
863
864
	default:
		BUG_ON(1);
		return MODE_BAD;
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
	}

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

906
907
908
909
910
911
912
913
914
915
916
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
};
917

918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
static void
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;
			nv_wraux(nv_encoder->i2c, DP_SET_POWER, &data, 1);
			usleep_range(1000, 2000);
		} else {
			u8 data = DP_SET_POWER_D3;
			nv_wraux(nv_encoder->i2c, DP_SET_POWER, &data, 1);
		}
	}

	drm_helper_connector_dpms(connector, mode);
}

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

952
953
954
955
static void
nouveau_connector_hotplug_work(struct work_struct *work)
{
	struct nouveau_connector *nv_connector =
956
		container_of(work, typeof(*nv_connector), work);
957
	struct drm_connector *connector = &nv_connector->base;
958
959
	struct nouveau_drm *drm = nouveau_drm(connector->dev);
	const char *name = connector->name;
960

961
962
963
	if (nv_connector->status & NVKM_HPD_IRQ) {
	} else {
		bool plugged = (nv_connector->status != NVKM_HPD_UNPLUG);
964

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

967
968
969
970
971
972
973
974
		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);
	}

	nouveau_event_get(nv_connector->hpd);
975
976
977
}

static int
978
nouveau_connector_hotplug(void *data, u32 type, int index)
979
{
980
	struct nouveau_connector *nv_connector = data;
981
982
983
	nv_connector->status = type;
	schedule_work(&nv_connector->work);
	return NVKM_EVENT_DROP;
984
985
}

986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
static ssize_t
nouveau_connector_aux_xfer(struct drm_dp_aux *aux, struct drm_dp_aux_msg *msg)
{
	struct nouveau_connector *nv_connector =
		container_of(aux, typeof(*nv_connector), aux);
	struct nouveau_encoder *nv_encoder;
	struct nouveau_i2c_port *port;
	int ret;

	nv_encoder = find_encoder(&nv_connector->base, DCB_OUTPUT_DP);
	if (!nv_encoder || !(port = nv_encoder->i2c))
		return -ENODEV;
	if (WARN_ON(msg->size > 16))
		return -E2BIG;
	if (msg->size == 0)
		return msg->size;

	ret = nouveau_i2c(port)->acquire(port, 0);
	if (ret)
		return ret;

	ret = port->func->aux(port, false, msg->request, msg->address,
			      msg->buffer, msg->size);
	nouveau_i2c(port)->release(port);
	if (ret >= 0) {
		msg->reply = ret;
		return msg->size;
	}

	return ret;
}

1018
1019
1020
1021
1022
1023
1024
1025
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;
1026
1027
	case DCB_CONNECTOR_DMS59_0  :
	case DCB_CONNECTOR_DMS59_1  :
1028
1029
1030
1031
	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;
1032
1033
	case DCB_CONNECTOR_DMS59_DP0:
	case DCB_CONNECTOR_DMS59_DP1:
1034
1035
1036
	case DCB_CONNECTOR_DP       : return DRM_MODE_CONNECTOR_DisplayPort;
	case DCB_CONNECTOR_eDP      : return DRM_MODE_CONNECTOR_eDP;
	case DCB_CONNECTOR_HDMI_0   :
1037
1038
	case DCB_CONNECTOR_HDMI_1   :
	case DCB_CONNECTOR_HDMI_C   : return DRM_MODE_CONNECTOR_HDMIA;
1039
1040
1041
1042
1043
1044
1045
	default:
		break;
	}

	return DRM_MODE_CONNECTOR_Unknown;
}

1046
1047
struct drm_connector *
nouveau_connector_create(struct drm_device *dev, int index)
1048
{
1049
	const struct drm_connector_funcs *funcs = &nouveau_connector_funcs;
1050
1051
	struct nouveau_drm *drm = nouveau_drm(dev);
	struct nouveau_display *disp = nouveau_display(dev);
1052
	struct nouveau_connector *nv_connector = NULL;
1053
	struct nouveau_disp *pdisp = nouveau_disp(drm->device);
1054
	struct drm_connector *connector;
1055
	int type, ret = 0;
1056
	bool dummy;
1057

1058
1059
1060
1061
	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
		nv_connector = nouveau_connector(connector);
		if (nv_connector->index == index)
			return connector;
1062
1063
	}

1064
1065
	nv_connector = kzalloc(sizeof(*nv_connector), GFP_KERNEL);
	if (!nv_connector)
1066
		return ERR_PTR(-ENOMEM);
1067

1068
	connector = &nv_connector->base;
1069
1070
1071
	nv_connector->index = index;

	/* attempt to parse vbios connector type and hotplug gpio */
1072
	nv_connector->dcb = olddcb_conn(dev, index);
1073
1074
	if (nv_connector->dcb) {
		u32 entry = ROM16(nv_connector->dcb[0]);
1075
		if (olddcb_conntab(dev)[3] >= 4)
1076
1077
1078
1079
1080
			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) {
1081
			NV_WARN(drm, "unknown connector type %02x\n",
1082
1083
1084
				nv_connector->type);
			nv_connector->type = DCB_CONNECTOR_NONE;
		}
1085

1086
1087
1088
1089
1090
		/* 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;
		}
1091

1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
		/* 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) {
1105
1106
		struct nouveau_drm *drm = nouveau_drm(dev);
		struct dcb_table *dcbt = &drm->vbios.dcb;
1107
1108
1109
1110
1111
1112
1113
		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);
		}
1114

1115
1116
		if (encoders & (1 << DCB_OUTPUT_DP)) {
			if (encoders & (1 << DCB_OUTPUT_TMDS))
1117
1118
1119
1120
				nv_connector->type = DCB_CONNECTOR_DP;
			else
				nv_connector->type = DCB_CONNECTOR_eDP;
		} else
1121
1122
		if (encoders & (1 << DCB_OUTPUT_TMDS)) {
			if (encoders & (1 << DCB_OUTPUT_ANALOG))
1123
1124
1125
1126
				nv_connector->type = DCB_CONNECTOR_DVI_I;
			else
				nv_connector->type = DCB_CONNECTOR_DVI_D;
		} else
1127
		if (encoders & (1 << DCB_OUTPUT_ANALOG)) {
1128
1129
			nv_connector->type = DCB_CONNECTOR_VGA;
		} else
1130
		if (encoders & (1 << DCB_OUTPUT_LVDS)) {
1131
1132
			nv_connector->type = DCB_CONNECTOR_LVDS;
		} else
1133
		if (encoders & (1 << DCB_OUTPUT_TV)) {
1134
1135
1136
			nv_connector->type = DCB_CONNECTOR_TV_0;
		}
	}
1137

1138
1139
	switch ((type = drm_conntype_from_dcb(nv_connector->type))) {
	case DRM_MODE_CONNECTOR_LVDS:
1140
		ret = nouveau_bios_parse_lvds_table(dev, 0, &dummy, &dummy);
1141
		if (ret) {
1142
			NV_ERROR(drm, "Error parsing LVDS table, disabling\n");
1143
1144
			kfree(nv_connector);
			return ERR_PTR(ret);
1145
		}
1146
1147

		funcs = &nouveau_connector_funcs_lvds;
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
		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);
		}

1160
		funcs = &nouveau_connector_funcs_dp;
1161
1162
1163
1164
		break;
	default:
		funcs = &nouveau_connector_funcs;
		break;
1165
1166
	}

1167
1168
1169
1170
1171
1172
1173
	/* 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);

1174
	/* Init DVI-I specific properties */
1175
	if (nv_connector->type == DCB_CONNECTOR_DVI_I)
1176
		drm_object_attach_property(&connector->base, dev->mode_config.dvi_i_subconnector_property, 0);
1177

1178
	/* Add overscan compensation options to digital outputs */
1179
	if (disp->underscan_property &&
1180
1181
1182
1183
	    (type == DRM_MODE_CONNECTOR_DVID ||
	     type == DRM_MODE_CONNECTOR_DVII ||
	     type == DRM_MODE_CONNECTOR_HDMIA ||
	     type == DRM_MODE_CONNECTOR_DisplayPort)) {
1184
		drm_object_attach_property(&connector->base,
1185
1186
					      disp->underscan_property,
					      UNDERSCAN_OFF);
1187
		drm_object_attach_property(&connector->base,
1188
1189
					      disp->underscan_hborder_property,
					      0);
1190
		drm_object_attach_property(&connector->base,
1191
1192
1193
1194
					      disp->underscan_vborder_property,
					      0);
	}

1195
1196
	/* Add hue and saturation options */
	if (disp->vibrant_hue_property)
1197
		drm_object_attach_property(&connector->base,
1198
1199
1200
					      disp->vibrant_hue_property,
					      90);
	if (disp->color_vibrance_property)
1201
		drm_object_attach_property(&connector->base,
1202
1203
1204
					      disp->color_vibrance_property,
					      150);

1205
	switch (nv_connector->type) {
1206
	case DCB_CONNECTOR_VGA:
1207
		if (nv_device(drm->device)->card_type >= NV_50) {
1208
			drm_object_attach_property(&connector->base,
1209
1210
1211
					dev->mode_config.scaling_mode_property,
					nv_connector->scaling_mode);
		}
1212
1213
1214
1215
1216
1217
1218
1219
1220
		/* 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;

1221
		drm_object_attach_property(&connector->base,
1222
1223
				dev->mode_config.scaling_mode_property,
				nv_connector->scaling_mode);
1224
1225
		if (disp->dithering_mode) {
			nv_connector->dithering_mode = DITHERING_MODE_AUTO;
1226
			drm_object_attach_property(&connector->base,
1227
1228
1229
1230
1231
						disp->dithering_mode,
						nv_connector->dithering_mode);
		}
		if (disp->dithering_depth) {
			nv_connector->dithering_depth = DITHERING_DEPTH_AUTO;
1232
			drm_object_attach_property(&connector->base,
1233
1234
1235
						disp->dithering_depth,
						nv_connector->dithering_depth);
		}
1236
		break;
1237
1238
	}