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

113
static struct nouveau_i2c_port *
114
115
116
117
nouveau_connector_ddc_detect(struct drm_connector *connector,
			     struct nouveau_encoder **pnv_encoder)
{
	struct drm_device *dev = connector->dev;
118
	struct nouveau_connector *nv_connector = nouveau_connector(connector);
119
	struct nouveau_drm *drm = nouveau_drm(dev);
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
	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);
		}
	}
135
136
137
138
139
140
141
142
143
144
145
146
147
148

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

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

		port = NULL;
157
158
	}

159
160
161
162
163
164
165
	/* 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;
166
167
}

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

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

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

210
	if (nv_device(drm->device)->card_type >= NV_50) {
211
212
213
		connector->interlace_allowed = true;
		connector->doublescan_allowed = true;
	} else
214
215
	if (nv_encoder->dcb->type == DCB_OUTPUT_LVDS ||
	    nv_encoder->dcb->type == DCB_OUTPUT_TMDS) {
216
217
218
219
		connector->doublescan_allowed = false;
		connector->interlace_allowed = false;
	} else {
		connector->doublescan_allowed = true;
220
		if (nv_device(drm->device)->card_type == NV_20 ||
221
222
223
224
		    ((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))
225
226
227
228
229
230
			/* HW is broken */
			connector->interlace_allowed = false;
		else
			connector->interlace_allowed = true;
	}

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

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

253
254
255
256
257
258
	/* Cleanup the previous EDID block. */
	if (nv_connector->edid) {
		drm_mode_connector_update_edid_property(connector, NULL);
		kfree(nv_connector->edid);
		nv_connector->edid = NULL;
	}
259

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

264
265
266
267
268
269
	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) {
270
			NV_ERROR(drm, "DDC responded, but no EDID for %s\n",
271
				 connector->name);
272
			goto detect_analog;
273
274
		}

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

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

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

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

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

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

	}

336
337
338
339
340
341
 out:

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

	return conn_status;
342
343
}

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

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

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

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

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

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

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

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

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

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

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

		return 0;
	}

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

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

		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;

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

		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;

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

		return 0;
	}

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

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

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

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

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

	return -EINVAL;
}

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

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

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

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

628
	NV_DEBUG(drm, "native mode from largest: %dx%d@%d\n",
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
682
683
684
685
686
687
688
		      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;
}

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

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

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

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

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

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

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

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

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

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

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

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

	return ret;
}

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

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

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

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

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

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

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

917
918
919
920
static void
nouveau_connector_hotplug_work(struct work_struct *work)
{
	struct nouveau_connector *nv_connector =
921
		container_of(work, typeof(*nv_connector), work);
922
	struct drm_connector *connector = &nv_connector->base;
923
924
	struct nouveau_drm *drm = nouveau_drm(connector->dev);
	const char *name = connector->name;
925

926
927
928
	if (nv_connector->status & NVKM_HPD_IRQ) {
	} else {
		bool plugged = (nv_connector->status != NVKM_HPD_UNPLUG);
929

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

932
933
934
935
936
937
938
939
		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);
940
941
942
}

static int
943
nouveau_connector_hotplug(void *data, u32 type, int index)
944
{
945
	struct nouveau_connector *nv_connector = data;
946
947
948
	nv_connector->status = type;
	schedule_work(&nv_connector->work);
	return NVKM_EVENT_DROP;
949
950
}

951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
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;
}

983
984
985
986
987
988
989
990
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;
991
992
	case DCB_CONNECTOR_DMS59_0  :
	case DCB_CONNECTOR_DMS59_1  :
993
994
995
996
	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;
997
998
	case DCB_CONNECTOR_DMS59_DP0:
	case DCB_CONNECTOR_DMS59_DP1:
999
1000
1001
	case DCB_CONNECTOR_DP       : return DRM_MODE_CONNECTOR_DisplayPort;
	case DCB_CONNECTOR_eDP      : return DRM_MODE_CONNECTOR_eDP;
	case DCB_CONNECTOR_HDMI_0   :
1002
1003
	case DCB_CONNECTOR_HDMI_1   :
	case DCB_CONNECTOR_HDMI_C   : return DRM_MODE_CONNECTOR_HDMIA;
1004
1005
1006
1007
1008
1009
1010
	default:
		break;
	}

	return DRM_MODE_CONNECTOR_Unknown;
}

1011
1012
struct drm_connector *
nouveau_connector_create(struct drm_device *dev, int index)
1013
{
1014
	const struct drm_connector_funcs *funcs = &nouveau_connector_funcs;
1015
1016
	struct nouveau_drm *drm = nouveau_drm(dev);
	struct nouveau_display *disp = nouveau_display(dev);
1017
	struct nouveau_connector *nv_connector = NULL;
1018
	struct nouveau_disp *pdisp = nouveau_disp(drm->device);
1019
	struct drm_connector *connector;
1020
	int type, ret = 0;
1021
	bool dummy;
1022

1023
1024
1025
1026
	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
		nv_connector = nouveau_connector(connector);
		if (nv_connector->index == index)
			return connector;
1027
1028
	}

1029
1030
	nv_connector = kzalloc(sizeof(*nv_connector), GFP_KERNEL);
	if (!nv_connector)
1031
		return ERR_PTR(-ENOMEM);
1032

1033
	connector = &nv_connector->base;
1034
1035
1036
	nv_connector->index = index;

	/* attempt to parse vbios connector type and hotplug gpio */
1037
	nv_connector->dcb = olddcb_conn(dev, index);
1038
1039
	if (nv_connector->dcb) {
		u32 entry = ROM16(nv_connector->dcb[0]);
1040
		if (olddcb_conntab(dev)[3] >= 4)
1041
1042
1043
1044
1045
			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) {
1046
			NV_WARN(drm, "unknown connector type %02x\n",
1047
1048
1049
				nv_connector->type);
			nv_connector->type = DCB_CONNECTOR_NONE;
		}
1050

1051
1052
1053
1054
1055
		/* 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;
		}
1056

1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
		/* 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) {
1070
1071
		struct nouveau_drm *drm = nouveau_drm(dev);
		struct dcb_table *dcbt = &drm->vbios.dcb;
1072
1073
1074
1075
1076
1077
1078
		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);
		}
1079

1080
1081
		if (encoders & (1 << DCB_OUTPUT_DP)) {
			if (encoders & (1 << DCB_OUTPUT_TMDS))
1082
1083
1084
1085
				nv_connector->type = DCB_CONNECTOR_DP;
			else
				nv_connector->type = DCB_CONNECTOR_eDP;
		} else
1086
1087
		if (encoders & (1 << DCB_OUTPUT_TMDS)) {
			if (encoders & (1 << DCB_OUTPUT_ANALOG))
1088
1089
1090
1091
				nv_connector->type = DCB_CONNECTOR_DVI_I;
			else
				nv_connector->type = DCB_CONNECTOR_DVI_D;
		} else
1092
		if (encoders & (1 << DCB_OUTPUT_ANALOG)) {
1093
1094
			nv_connector->type = DCB_CONNECTOR_VGA;
		} else
1095
		if (encoders & (1 << DCB_OUTPUT_LVDS)) {
1096
1097
			nv_connector->type = DCB_CONNECTOR_LVDS;
		} else
1098
		if (encoders & (1 << DCB_OUTPUT_TV)) {
1099
1100
1101
			nv_connector->type = DCB_CONNECTOR_TV_0;
		}
	}
1102

1103
1104
	switch ((type = drm_conntype_from_dcb(nv_connector->type))) {
	case DRM_MODE_CONNECTOR_LVDS:
1105
		ret = nouveau_bios_parse_lvds_table(dev, 0, &dummy, &dummy);
1106
		if (ret) {
1107
			NV_ERROR(drm, "Error parsing LVDS table, disabling\n");
1108
1109
			kfree(nv_connector);
			return ERR_PTR(ret);
1110
		}
1111
1112

		funcs = &nouveau_connector_funcs_lvds;
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
		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);
		}

1125
		funcs = &nouveau_connector_funcs;
1126
1127
1128
1129
		break;
	default:
		funcs = &nouveau_connector_funcs;
		break;
1130
1131
	}

1132
1133
1134
1135
1136
1137
1138
	/* 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);

1139
	/* Init DVI-I specific properties */
1140
	if (nv_connector->type == DCB_CONNECTOR_DVI_I)
1141
		drm_object_attach_property(&connector->base, dev->mode_config.dvi_i_subconnector_property, 0);
1142

1143
	/* Add overscan compensation options to digital outputs */
1144
	if (disp->underscan_property &&
1145
1146
1147
1148
	    (type == DRM_MODE_CONNECTOR_DVID ||
	     type == DRM_MODE_CONNECTOR_DVII ||
	     type == DRM_MODE_CONNECTOR_HDMIA ||
	     type == DRM_MODE_CONNECTOR_DisplayPort)) {
1149
		drm_object_attach_property(&connector->base,
1150
1151
					      disp->underscan_property,
					      UNDERSCAN_OFF);
1152
		drm_object_attach_property(&connector->base,
1153
1154
					      disp->underscan_hborder_property,
					      0);
1155
		drm_object_attach_property(&connector->base,
1156
1157
1158
1159
					      disp->underscan_vborder_property,
					      0);
	}

1160
1161
	/* Add hue and saturation options */
	if (disp->vibrant_hue_property)
1162
		drm_object_attach_property(&connector->base,
1163
1164
1165
					      disp->vibrant_hue_property,
					      90);
	if (disp->color_vibrance_property)
1166
		drm_object_attach_property(&connector->base,
1167
1168
1169
					      disp->color_vibrance_property,
					      150);

1170
	switch (nv_connector->type) {
1171
	case DCB_CONNECTOR_VGA:
1172
		if (nv_device(drm->device)->card_type >= NV_50) {
1173
			drm_object_attach_property(&connector->base,
1174
1175
1176
					dev->mode_config.scaling_mode_property,
					nv_connector->scaling_mode);
		}
1177
1178
1179
1180
1181
1182
1183
1184
1185
		/* 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;

1186
		drm_object_attach_property(&connector->base,
1187
1188
				dev->mode_config.scaling_mode_property,
				nv_connector->scaling_mode);
1189
1190
		if (disp->dithering_mode) {
			nv_connector->dithering_mode = DITHERING_MODE_AUTO;
1191
			drm_object_attach_property(&connector->base,
1192
1193
1194
1195
1196
						disp->dithering_mode,
						nv_connector->dithering_mode);
		}
		if (disp->dithering_depth) {
			nv_connector->dithering_depth = DITHERING_DEPTH_AUTO;
1197
			drm_object_attach_property(&connector->base,
1198
1199
1200
						disp->dithering_depth,
						nv_connector->dithering_depth);
		}
1201
		break;
1202
1203
	}

1204
1205
1206
1207
1208
1209
	ret = nouveau_event_new(pdisp->hpd, NVKM_HPD, index,
				nouveau_connector_hotplug,
				nv_connector, &nv_connector->hpd);
	if (ret)
		connector->polled = DRM_CONNECTOR_POLL_CONNECT;
	else
1210
		connector->polled = DRM_CONNECTOR_POLL_HPD;
1211

1212
1213
	INIT_WORK(&nv_connector->work, nouveau_connector_hotplug_work);

1214
	drm_sysfs_connector_add(connector);
1215
	return connector;