nouveau_connector.c 35.2 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
#include <nvif/event.h>

51
52
53
54
55
56
57
58
59
60
61
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);
62

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
	nvkm_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 nouveau_gpio *gpio = nouveau_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
132
133
134
135
136
137
	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);
		}
	}
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
155
156
		if (nv_encoder->dcb->type == DCB_OUTPUT_DP) {
			int ret = nouveau_dp_detect(nv_encoder);
			if (ret == 0)
				break;
		} else
		if (nv_encoder->i2c) {
			if (nv_probe_i2c(nv_encoder->i2c, 0x50))
				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
165
		gpio->set(gpio, 0, DCB_GPIO_PANEL_POWER, 0xff, panel);

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 (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
	nv_encoder = nouveau_connector_ddc_detect(connector);
	if (nv_encoder && (i2c = nv_encoder->i2c) != NULL) {
267
268
269
270
		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
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
317
318
319
320
321
322
		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);
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
466
467
468
469
470
471
472
473
474
	/* 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 */
475
		if (connector->connector_type == DRM_MODE_CONNECTOR_LVDS &&
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
		    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 {
498
			ret = nv_crtc->set_scale(nv_crtc, true);
499
500
501
502
503
504
505
			if (ret)
				return ret;
		}

		return 0;
	}

506
507
508
509
510
511
512
	/* Underscan */
	if (property == disp->underscan_property) {
		if (nv_connector->underscan != value) {
			nv_connector->underscan = value;
			if (!nv_crtc || !nv_crtc->set_scale)
				return 0;

513
			return nv_crtc->set_scale(nv_crtc, true);
514
515
516
517
518
519
520
521
522
523
524
		}

		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;

525
			return nv_crtc->set_scale(nv_crtc, true);
526
527
528
529
530
531
532
533
534
535
536
		}

		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;

537
			return nv_crtc->set_scale(nv_crtc, true);
538
539
540
541
542
		}

		return 0;
	}

543
	/* Dithering */
544
545
546
547
548
549
550
	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);
	}
551

552
553
	if (property == disp->dithering_depth) {
		nv_connector->dithering_depth = value;
554
555
556
		if (!nv_crtc || !nv_crtc->set_dither)
			return 0;

557
		return nv_crtc->set_dither(nv_crtc, true);
558
559
	}

560
561
562
563
564
565
566
567
568
569
570
571
572
	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);
		}
	}

573
	if (nv_encoder && nv_encoder->dcb->type == DCB_OUTPUT_TV)
574
575
		return get_slave_funcs(encoder)->set_property(
			encoder, connector, property, value);
576
577
578
579
580

	return -EINVAL;
}

static struct drm_display_mode *
581
nouveau_connector_native_mode(struct drm_connector *connector)
582
{
583
	struct drm_connector_helper_funcs *helper = connector->helper_private;
584
	struct nouveau_drm *drm = nouveau_drm(connector->dev);
585
586
	struct nouveau_connector *nv_connector = nouveau_connector(connector);
	struct drm_device *dev = connector->dev;
587
588
589
	struct drm_display_mode *mode, *largest = NULL;
	int high_w = 0, high_h = 0, high_v = 0;

590
	list_for_each_entry(mode, &nv_connector->base.probed_modes, head) {
591
		mode->vrefresh = drm_mode_vrefresh(mode);
592
593
		if (helper->mode_valid(connector, mode) != MODE_OK ||
		    (mode->flags & DRM_MODE_FLAG_INTERLACE))
594
595
596
			continue;

		/* Use preferred mode if there is one.. */
597
		if (mode->type & DRM_MODE_TYPE_PREFERRED) {
598
			NV_DEBUG(drm, "native mode from preferred\n");
599
600
601
			return drm_mode_duplicate(dev, mode);
		}

602
603
604
		/* Otherwise, take the resolution with the largest width, then
		 * height, then vertical refresh
		 */
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
		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;
	}

621
	NV_DEBUG(drm, "native mode from largest: %dx%d@%d\n",
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
		      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;
}

682
683
684
static void
nouveau_connector_detect_depth(struct drm_connector *connector)
{
685
	struct nouveau_drm *drm = nouveau_drm(connector->dev);
686
687
	struct nouveau_connector *nv_connector = nouveau_connector(connector);
	struct nouveau_encoder *nv_encoder = nv_connector->detected_encoder;
688
	struct nvbios *bios = &drm->vbios;
689
690
691
692
693
694
695
	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;

696
697
698
699
700
701
702
	/* 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 */
703
	if (nv_encoder->dcb->type != DCB_OUTPUT_LVDS) {
704
		connector->display_info.bpc = 8;
705
		return;
706
707
708
	}

	connector->display_info.bpc = 6;
709
710
711
712
713
714
715
716
717
718
719
720

	/* 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 &&
721
	    nv_connector->type == DCB_CONNECTOR_LVDS_SPWG)
722
723
724
725
726
727
728
729
730
		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;
}

731
732
733
734
static int
nouveau_connector_get_modes(struct drm_connector *connector)
{
	struct drm_device *dev = connector->dev;
735
	struct nouveau_drm *drm = nouveau_drm(dev);
736
737
	struct nouveau_connector *nv_connector = nouveau_connector(connector);
	struct nouveau_encoder *nv_encoder = nv_connector->detected_encoder;
738
	struct drm_encoder *encoder = to_drm_encoder(nv_encoder);
739
740
	int ret = 0;

741
	/* destroy the native mode, the attached monitor could have changed.
742
	 */
743
	if (nv_connector->native_mode) {
744
745
746
747
748
749
		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);
750
	else
751
	if (nv_encoder->dcb->type == DCB_OUTPUT_LVDS &&
752
	    (nv_encoder->dcb->lvdsconf.use_straps_for_mode ||
753
	     drm->vbios.fp_no_ddc) && nouveau_bios_fp_mode(dev, NULL)) {
754
755
756
757
		struct drm_display_mode mode;

		nouveau_bios_fp_mode(dev, &mode);
		nv_connector->native_mode = drm_mode_duplicate(dev, &mode);
758
	}
759

760
761
762
763
764
765
	/* 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);

766
767
768
769
770
771
	/* 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 =
772
			nouveau_connector_native_mode(connector);
773
774
775
776
777
778
779
780
	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;
	}

781
782
783
	/* 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...
784
	 */
785
786
	if (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)
		nouveau_connector_detect_depth(connector);
787

788
	if (nv_encoder->dcb->type == DCB_OUTPUT_TV)
789
		ret = get_slave_funcs(encoder)->get_modes(encoder, connector);
790

791
792
793
	if (nv_connector->type == DCB_CONNECTOR_LVDS ||
	    nv_connector->type == DCB_CONNECTOR_LVDS_SPWG ||
	    nv_connector->type == DCB_CONNECTOR_eDP)
794
795
796
797
798
		ret += nouveau_connector_scaler_modes_add(connector);

	return ret;
}

799
800
801
802
static unsigned
get_tmds_link_bandwidth(struct drm_connector *connector)
{
	struct nouveau_connector *nv_connector = nouveau_connector(connector);
803
	struct nouveau_drm *drm = nouveau_drm(connector->dev);
804
	struct dcb_output *dcb = nv_connector->detected_encoder->dcb;
805
806

	if (dcb->location != DCB_LOC_ON_CHIP ||
807
	    nv_device(drm->device)->chipset >= 0x46)
808
		return 165000;
809
	else if (nv_device(drm->device)->chipset >= 0x40)
810
		return 155000;
811
	else if (nv_device(drm->device)->chipset >= 0x18)
812
813
814
815
816
		return 135000;
	else
		return 112000;
}

817
818
819
820
821
822
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;
823
	struct drm_encoder *encoder = to_drm_encoder(nv_encoder);
824
825
826
827
	unsigned min_clock = 25000, max_clock = min_clock;
	unsigned clock = mode->clock;

	switch (nv_encoder->dcb->type) {
828
	case DCB_OUTPUT_LVDS:
829
830
831
		if (nv_connector->native_mode &&
		    (mode->hdisplay > nv_connector->native_mode->hdisplay ||
		     mode->vdisplay > nv_connector->native_mode->vdisplay))
832
833
834
835
836
			return MODE_PANEL;

		min_clock = 0;
		max_clock = 400000;
		break;
837
	case DCB_OUTPUT_TMDS:
838
839
840
		max_clock = get_tmds_link_bandwidth(connector);
		if (nouveau_duallink && nv_encoder->dcb->duallink_possible)
			max_clock *= 2;
841
		break;
842
	case DCB_OUTPUT_ANALOG:
843
844
845
846
		max_clock = nv_encoder->dcb->crtconf.maxfreq;
		if (!max_clock)
			max_clock = 350000;
		break;
847
	case DCB_OUTPUT_TV:
848
		return get_slave_funcs(encoder)->mode_valid(encoder, mode);
849
	case DCB_OUTPUT_DP:
850
851
		max_clock  = nv_encoder->dp.link_nr;
		max_clock *= nv_encoder->dp.link_bw;
852
		clock = clock * (connector->display_info.bpc * 3) / 10;
853
		break;
854
855
856
	default:
		BUG_ON(1);
		return MODE_BAD;
857
858
859
860
861
862
863
864
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
	}

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

898
899
900
901
902
903
904
905
906
907
908
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
};
909

910
911
912
913
914
915
916
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
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
};

944
945
static int
nouveau_connector_hotplug(struct nvkm_notify *notify)
946
947
{
	struct nouveau_connector *nv_connector =
948
		container_of(notify, typeof(*nv_connector), hpd);
949
	struct drm_connector *connector = &nv_connector->base;
950
	struct nouveau_drm *drm = nouveau_drm(connector->dev);
951
	const struct nvif_notify_conn_rep_v0 *rep = notify->data;
952
	const char *name = connector->name;
953

954
	if (rep->mask & NVIF_NOTIFY_CONN_V0_IRQ) {
955
	} else {
956
		bool plugged = (rep->mask != NVIF_NOTIFY_CONN_V0_UNPLUG);
957

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

960
961
962
963
964
965
966
		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);
	}

967
	return NVKM_NOTIFY_KEEP;
968
969
}

970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
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;
}

1002
1003
1004
1005
1006
1007
1008
1009
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;
1010
1011
	case DCB_CONNECTOR_DMS59_0  :
	case DCB_CONNECTOR_DMS59_1  :
1012
1013
1014
1015
	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;
1016
1017
	case DCB_CONNECTOR_DMS59_DP0:
	case DCB_CONNECTOR_DMS59_DP1:
1018
1019
1020
	case DCB_CONNECTOR_DP       : return DRM_MODE_CONNECTOR_DisplayPort;
	case DCB_CONNECTOR_eDP      : return DRM_MODE_CONNECTOR_eDP;
	case DCB_CONNECTOR_HDMI_0   :
1021
1022
	case DCB_CONNECTOR_HDMI_1   :
	case DCB_CONNECTOR_HDMI_C   : return DRM_MODE_CONNECTOR_HDMIA;
1023
1024
1025
1026
1027
1028
1029
	default:
		break;
	}

	return DRM_MODE_CONNECTOR_Unknown;
}

1030
1031
struct drm_connector *
nouveau_connector_create(struct drm_device *dev, int index)
1032
{
1033
	const struct drm_connector_funcs *funcs = &nouveau_connector_funcs;
1034
1035
	struct nouveau_drm *drm = nouveau_drm(dev);
	struct nouveau_display *disp = nouveau_display(dev);
1036
	struct nouveau_connector *nv_connector = NULL;
1037
	struct nouveau_disp *pdisp = nouveau_disp(drm->device);
1038
	struct drm_connector *connector;
1039
	int type, ret = 0;
1040
	bool dummy;
1041

1042
1043
1044
1045
	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
		nv_connector = nouveau_connector(connector);
		if (nv_connector->index == index)
			return connector;
1046
1047
	}

1048
1049
	nv_connector = kzalloc(sizeof(*nv_connector), GFP_KERNEL);
	if (!nv_connector)
1050
		return ERR_PTR(-ENOMEM);
1051

1052
	connector = &nv_connector->base;
1053
1054
1055
	nv_connector->index = index;

	/* attempt to parse vbios connector type and hotplug gpio */
1056
	nv_connector->dcb = olddcb_conn(dev, index);
1057
1058
	if (nv_connector->dcb) {
		u32 entry = ROM16(nv_connector->dcb[0]);
1059
		if (olddcb_conntab(dev)[3] >= 4)
1060
1061
1062
1063
1064
			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) {
1065
			NV_WARN(drm, "unknown connector type %02x\n",
1066
1067
1068
				nv_connector->type);
			nv_connector->type = DCB_CONNECTOR_NONE;
		}
1069

1070
1071
1072
1073
1074
		/* 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;
		}
1075

1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
		/* 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) {
1089
1090
		struct nouveau_drm *drm = nouveau_drm(dev);
		struct dcb_table *dcbt = &drm->vbios.dcb;
1091
1092
1093
1094
1095
1096
1097
		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);
		}
1098

1099
1100
		if (encoders & (1 << DCB_OUTPUT_DP)) {
			if (encoders & (1 << DCB_OUTPUT_TMDS))
1101
1102
1103
1104
				nv_connector->type = DCB_CONNECTOR_DP;
			else
				nv_connector->type = DCB_CONNECTOR_eDP;
		} else
1105
1106
		if (encoders & (1 << DCB_OUTPUT_TMDS)) {
			if (encoders & (1 << DCB_OUTPUT_ANALOG))
1107
1108
1109
1110
				nv_connector->type = DCB_CONNECTOR_DVI_I;
			else
				nv_connector->type = DCB_CONNECTOR_DVI_D;
		} else
1111
		if (encoders & (1 << DCB_OUTPUT_ANALOG)) {
1112
1113
			nv_connector->type = DCB_CONNECTOR_VGA;
		} else
1114
		if (encoders & (1 << DCB_OUTPUT_LVDS)) {
1115
1116
			nv_connector->type = DCB_CONNECTOR_LVDS;
		} else
1117
		if (encoders & (1 << DCB_OUTPUT_TV)) {
1118
1119
1120
			nv_connector->type = DCB_CONNECTOR_TV_0;
		}
	}
1121

1122
1123
	switch ((type = drm_conntype_from_dcb(nv_connector->type))) {
	case DRM_MODE_CONNECTOR_LVDS:
1124
		ret = nouveau_bios_parse_lvds_table(dev, 0, &dummy, &dummy);
1125
		if (ret) {
1126
			NV_ERROR(drm, "Error parsing LVDS table, disabling\n");
1127
1128
			kfree(nv_connector);
			return ERR_PTR(ret);
1129
		}
1130
1131

		funcs = &nouveau_connector_funcs_lvds;
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
		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);
		}

1144
		funcs = &nouveau_connector_funcs_dp;
1145
1146
1147
1148
		break;
	default:
		funcs = &nouveau_connector_funcs;
		break;
1149
1150
	}

1151
1152
1153
1154
1155
1156
1157
	/* 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);

1158
	/* Init DVI-I specific properties */
1159
	if (nv_connector->type == DCB_CONNECTOR_DVI_I)
1160
		drm_object_attach_property(&connector->base, dev->mode_config.dvi_i_subconnector_property, 0);
1161

1162
	/* Add overscan compensation options to digital outputs */
1163
	if (disp->underscan_property &&
1164
1165
1166
1167
	    (type == DRM_MODE_CONNECTOR_DVID ||
	     type == DRM_MODE_CONNECTOR_DVII ||
	     type == DRM_MODE_CONNECTOR_HDMIA ||
	     type == DRM_MODE_CONNECTOR_DisplayPort)) {
1168
		drm_object_attach_property(&connector->base,
1169
1170
					      disp->underscan_property,
					      UNDERSCAN_OFF);
1171
		drm_object_attach_property(&connector->base,
1172
1173
					      disp->underscan_hborder_property,
					      0);
1174
		drm_object_attach_property(&connector->base,
1175
1176
1177
1178
					      disp->underscan_vborder_property,
					      0);
	}

1179
1180
	/* Add hue and saturation options */
	if (disp->vibrant_hue_property)
1181
		drm_object_attach_property(&connector->base,
1182
1183
1184
					      disp->vibrant_hue_property,
					      90);
	if (disp->color_vibrance_property)
1185
		drm_object_attach_property(&connector->base,
1186
1187
1188
					      disp->color_vibrance_property,
					      150);

1189
	switch (nv_connector->type) {
1190
	case DCB_CONNECTOR_VGA:
1191
		if (nv_device(drm->device)->card_type >= NV_50) {
1192
			drm_object_attach_property(&connector->base,
1193
1194
1195
					dev->mode_config.scaling_mode_property,
					nv_connector->scaling_mode);
		}
1196
1197
1198
1199
1200
1201
1202
1203
1204
		/* 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;

1205
		drm_object_attach_property(&connector->base,
1206
1207
				dev->mode_config.scaling_mode_property,
				nv_connector->scaling_mode);
1208
1209
		if (disp->dithering_mode) {
			nv_connector->dithering_mode = DITHERING_MODE_AUTO;
1210
			drm_object_attach_property(&connector->base,
1211
1212
1213
1214