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);
A
Albert Damen 已提交
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;
1216
}