forked from ~ljy/RK356X_SDK_RELEASE
blame | history | patch | commit | commitdiff
hc
2023-12-11 6778948f9de86c3cfaf36725a7c87dcff9ba247f 
 kernel/drivers/gpu/drm/nouveau/nouveau_connector.c
....@@ -29,15 +29,16 @@
2929 #include <linux/pm_runtime.h>
3030 #include <linux/vga_switcheroo.h>
3131 
32
-#include <drm/drmP.h>
3332 #include <drm/drm_atomic_helper.h>
3433 #include <drm/drm_edid.h>
3534 #include <drm/drm_crtc_helper.h>
35
+#include <drm/drm_probe_helper.h>
3636 #include <drm/drm_atomic.h>
3737 
3838 #include "nouveau_reg.h"
3939 #include "nouveau_drv.h"
4040 #include "dispnv04/hw.h"
41
+#include "dispnv50/disp.h"
4142 #include "nouveau_acpi.h"
4243 
4344 #include "nouveau_display.h"
....@@ -59,7 +60,6 @@
5960 	int high_w = 0, high_h = 0, high_v = 0;
6061 
6162 	list_for_each_entry(mode, &connector->probed_modes, head) {
62
-		mode->vrefresh = drm_mode_vrefresh(mode);
6363 		if (helper->mode_valid(connector, mode) != MODE_OK ||
6464 		    (mode->flags & DRM_MODE_FLAG_INTERLACE))
6565 			continue;
....@@ -80,12 +80,12 @@
8080 			continue;
8181 
8282 		if (mode->hdisplay == high_w && mode->vdisplay == high_h &&
83
-		    mode->vrefresh < high_v)
83
+		    drm_mode_vrefresh(mode) < high_v)
8484 			continue;
8585 
8686 		high_w = mode->hdisplay;
8787 		high_h = mode->vdisplay;
88
-		high_v = mode->vrefresh;
88
+		high_v = drm_mode_vrefresh(mode);
8989 		largest = mode;
9090 	}
9191 
....@@ -245,14 +245,22 @@
245245 void
246246 nouveau_conn_reset(struct drm_connector *connector)
247247 {
248
+	struct nouveau_connector *nv_connector = nouveau_connector(connector);
248249 	struct nouveau_conn_atom *asyc;
249250 
250
-	if (WARN_ON(!(asyc = kzalloc(sizeof(*asyc), GFP_KERNEL))))
251
-		return;
251
+	if (drm_drv_uses_atomic_modeset(connector->dev)) {
252
+		if (WARN_ON(!(asyc = kzalloc(sizeof(*asyc), GFP_KERNEL))))
253
+			return;
252254 
253
-	if (connector->state)
254
-		nouveau_conn_atomic_destroy_state(connector, connector->state);
255
-	__drm_atomic_helper_connector_reset(connector, &asyc->state);
255
+		if (connector->state)
256
+			nouveau_conn_atomic_destroy_state(connector,
257
+							  connector->state);
258
+
259
+		__drm_atomic_helper_connector_reset(connector, &asyc->state);
260
+	} else {
261
+		asyc = &nv_connector->properties_state;
262
+	}
263
+
256264 	asyc->dither.mode = DITHERING_MODE_AUTO;
257265 	asyc->dither.depth = DITHERING_DEPTH_AUTO;
258266 	asyc->scaler.mode = DRM_MODE_SCALE_NONE;
....@@ -276,8 +284,14 @@
276284 nouveau_conn_attach_properties(struct drm_connector *connector)
277285 {
278286 	struct drm_device *dev = connector->dev;
279
-	struct nouveau_conn_atom *armc = nouveau_conn_atom(connector->state);
280287 	struct nouveau_display *disp = nouveau_display(dev);
288
+	struct nouveau_connector *nv_connector = nouveau_connector(connector);
289
+	struct nouveau_conn_atom *armc;
290
+
291
+	if (drm_drv_uses_atomic_modeset(connector->dev))
292
+		armc = nouveau_conn_atom(connector->state);
293
+	else
294
+		armc = &nv_connector->properties_state;
281295 
282296 	/* Init DVI-I specific properties. */
283297 	if (connector->connector_type == DRM_MODE_CONNECTOR_DVII)
....@@ -316,7 +330,7 @@
316330 	case DRM_MODE_CONNECTOR_VGA:
317331 		if (disp->disp.object.oclass < NV50_DISP)
318332 			break; /* Can only scale on DFPs. */
319
-		/* Fall-through. */
333
+		fallthrough;
320334 	default:
321335 		drm_object_attach_property(&connector->base, dev->mode_config.
322336 					   scaling_mode_property,
....@@ -365,9 +379,8 @@
365379 {
366380 	struct nouveau_encoder *nv_encoder;
367381 	struct drm_encoder *enc;
368
-	int i;
369382 
370
-	drm_connector_for_each_possible_encoder(connector, enc, i) {
383
+	drm_connector_for_each_possible_encoder(connector, enc) {
371384 		nv_encoder = nouveau_encoder(enc);
372385 
373386 		if (type == DCB_OUTPUT_ANY ||
....@@ -378,30 +391,19 @@
378391 	return NULL;
379392 }
380393 
381
-struct nouveau_connector *
382
-nouveau_encoder_connector_get(struct nouveau_encoder *encoder)
383
-{
384
-	struct drm_device *dev = to_drm_encoder(encoder)->dev;
385
-	struct drm_connector *drm_connector;
386
-
387
-	list_for_each_entry(drm_connector, &dev->mode_config.connector_list, head) {
388
-		if (drm_connector->encoder == to_drm_encoder(encoder))
389
-			return nouveau_connector(drm_connector);
390
-	}
391
-
392
-	return NULL;
393
-}
394
-
395394 static void
396395 nouveau_connector_destroy(struct drm_connector *connector)
397396 {
398397 	struct nouveau_connector *nv_connector = nouveau_connector(connector);
399
-	nvif_notify_fini(&nv_connector->hpd);
398
+	nvif_notify_dtor(&nv_connector->hpd);
400399 	kfree(nv_connector->edid);
401400 	drm_connector_unregister(connector);
402401 	drm_connector_cleanup(connector);
403
-	if (nv_connector->aux.transfer)
402
+	if (nv_connector->aux.transfer) {
403
+		drm_dp_cec_unregister_connector(&nv_connector->aux);
404404 		drm_dp_aux_unregister(&nv_connector->aux);
405
+		kfree(nv_connector->aux.name);
406
+	}
405407 	kfree(connector);
406408 }
407409 
....@@ -411,15 +413,16 @@
411413 	struct drm_device *dev = connector->dev;
412414 	struct nouveau_encoder *nv_encoder = NULL, *found = NULL;
413415 	struct drm_encoder *encoder;
414
-	int i, ret;
416
+	int ret;
415417 	bool switcheroo_ddc = false;
416418 
417
-	drm_connector_for_each_possible_encoder(connector, encoder, i) {
419
+	drm_connector_for_each_possible_encoder(connector, encoder) {
418420 		nv_encoder = nouveau_encoder(encoder);
419421 
420422 		switch (nv_encoder->dcb->type) {
421423 		case DCB_OUTPUT_DP:
422
-			ret = nouveau_dp_detect(nv_encoder);
424
+			ret = nouveau_dp_detect(nouveau_connector(connector),
425
+						nv_encoder);
423426 			if (ret == NOUVEAU_DP_MST)
424427 				return NULL;
425428 			else if (ret == NOUVEAU_DP_SST)
....@@ -429,7 +432,7 @@
429432 		case DCB_OUTPUT_LVDS:
430433 			switcheroo_ddc = !!(vga_switcheroo_handler_flags() &
431434 					    VGA_SWITCHEROO_CAN_SWITCH_DDC);
432
-		/* fall-through */
435
+			fallthrough;
433436 		default:
434437 			if (!nv_encoder->i2c)
435438 				break;
....@@ -493,7 +496,12 @@
493496 	nv_connector->detected_encoder = nv_encoder;
494497 
495498 	if (drm->client.device.info.family >= NV_DEVICE_INFO_V0_TESLA) {
496
-		connector->interlace_allowed = true;
499
+		if (nv_encoder->dcb->type == DCB_OUTPUT_DP)
500
+			connector->interlace_allowed =
501
+				nv_encoder->caps.dp_interlace;
502
+		else
503
+			connector->interlace_allowed =
504
+				drm->client.device.info.family < NV_DEVICE_INFO_V0_VOLTA;
497505 		connector->doublescan_allowed = true;
498506 	} else
499507 	if (nv_encoder->dcb->type == DCB_OUTPUT_LVDS ||
....@@ -521,6 +529,19 @@
521529 	}
522530 }
523531 
532
+static void
533
+nouveau_connector_set_edid(struct nouveau_connector *nv_connector,
534
+			   struct edid *edid)
535
+{
536
+	if (nv_connector->edid != edid) {
537
+		struct edid *old_edid = nv_connector->edid;
538
+
539
+		drm_connector_update_edid_property(&nv_connector->base, edid);
540
+		kfree(old_edid);
541
+		nv_connector->edid = edid;
542
+	}
543
+}
544
+
524545 static enum drm_connector_status
525546 nouveau_connector_detect(struct drm_connector *connector, bool force)
526547 {
....@@ -534,13 +555,6 @@
534555 	int ret;
535556 	enum drm_connector_status conn_status = connector_status_disconnected;
536557 
537
-	/* Cleanup the previous EDID block. */
538
-	if (nv_connector->edid) {
539
-		drm_connector_update_edid_property(connector, NULL);
540
-		kfree(nv_connector->edid);
541
-		nv_connector->edid = NULL;
542
-	}
543
-
544558 	/* Outputs are only polled while runtime active, so resuming the
545559 	 * device here is unnecessary (and would deadlock upon runtime suspend
546560 	 * because it waits for polling to finish). We do however, want to
....@@ -553,22 +567,23 @@
553567 		ret = pm_runtime_get_sync(dev->dev);
554568 		if (ret < 0 && ret != -EACCES) {
555569 			pm_runtime_put_autosuspend(dev->dev);
570
+			nouveau_connector_set_edid(nv_connector, NULL);
556571 			return conn_status;
557572 		}
558573 	}
559574 
560575 	nv_encoder = nouveau_connector_ddc_detect(connector);
561576 	if (nv_encoder && (i2c = nv_encoder->i2c) != NULL) {
577
+		struct edid *new_edid;
578
+
562579 		if ((vga_switcheroo_handler_flags() &
563580 		     VGA_SWITCHEROO_CAN_SWITCH_DDC) &&
564581 		    nv_connector->type == DCB_CONNECTOR_LVDS)
565
-			nv_connector->edid = drm_get_edid_switcheroo(connector,
566
-								     i2c);
582
+			new_edid = drm_get_edid_switcheroo(connector, i2c);
567583 		else
568
-			nv_connector->edid = drm_get_edid(connector, i2c);
584
+			new_edid = drm_get_edid(connector, i2c);
569585 
570
-		drm_connector_update_edid_property(connector,
571
-							nv_connector->edid);
586
+		nouveau_connector_set_edid(nv_connector, new_edid);
572587 		if (!nv_connector->edid) {
573588 			NV_ERROR(drm, "DDC responded, but no EDID for %s\n",
574589 				 connector->name);
....@@ -600,7 +615,10 @@
600615 
601616 		nouveau_connector_set_encoder(connector, nv_encoder);
602617 		conn_status = connector_status_connected;
618
+		drm_dp_cec_set_edid(&nv_connector->aux, nv_connector->edid);
603619 		goto out;
620
+	} else {
621
+		nouveau_connector_set_edid(nv_connector, NULL);
604622 	}
605623 
606624 	nv_encoder = nouveau_connector_of_detect(connector);
....@@ -625,10 +643,11 @@
625643 			conn_status = connector_status_connected;
626644 			goto out;
627645 		}
628
-
629646 	}
630647 
631648  out:
649
+	if (!nv_connector->edid)
650
+		drm_dp_cec_unset_edid(&nv_connector->aux);
632651 
633652 	pm_runtime_mark_last_busy(dev->dev);
634653 	pm_runtime_put_autosuspend(dev->dev);
....@@ -643,24 +662,20 @@
643662 	struct nouveau_drm *drm = nouveau_drm(dev);
644663 	struct nouveau_connector *nv_connector = nouveau_connector(connector);
645664 	struct nouveau_encoder *nv_encoder = NULL;
665
+	struct edid *edid = NULL;
646666 	enum drm_connector_status status = connector_status_disconnected;
647
-
648
-	/* Cleanup the previous EDID block. */
649
-	if (nv_connector->edid) {
650
-		drm_connector_update_edid_property(connector, NULL);
651
-		kfree(nv_connector->edid);
652
-		nv_connector->edid = NULL;
653
-	}
654667 
655668 	nv_encoder = find_encoder(connector, DCB_OUTPUT_LVDS);
656669 	if (!nv_encoder)
657
-		return connector_status_disconnected;
670
+		goto out;
658671 
659672 	/* Try retrieving EDID via DDC */
660673 	if (!drm->vbios.fp_no_ddc) {
661674 		status = nouveau_connector_detect(connector, force);
662
-		if (status == connector_status_connected)
675
+		if (status == connector_status_connected) {
676
+			edid = nv_connector->edid;
663677 			goto out;
678
+		}
664679 	}
665680 
666681 	/* On some laptops (Sony, i'm looking at you) there appears to
....@@ -673,7 +688,8 @@
673688 	 * valid - it's not (rh#613284)
674689 	 */
675690 	if (nv_encoder->dcb->lvdsconf.use_acpi_for_edid) {
676
-		if ((nv_connector->edid = nouveau_acpi_edid(dev, connector))) {
691
+		edid = nouveau_acpi_edid(dev, connector);
692
+		if (edid) {
677693 			status = connector_status_connected;
678694 			goto out;
679695 		}
....@@ -693,12 +709,10 @@
693709 	 * stored for the panel stored in them.
694710 	 */
695711 	if (!drm->vbios.fp_no_ddc) {
696
-		struct edid *edid =
697
-			(struct edid *)nouveau_bios_embedded_edid(dev);
712
+		edid = (struct edid *)nouveau_bios_embedded_edid(dev);
698713 		if (edid) {
699
-			nv_connector->edid =
700
-					kmemdup(edid, EDID_LENGTH, GFP_KERNEL);
701
-			if (nv_connector->edid)
714
+			edid = kmemdup(edid, EDID_LENGTH, GFP_KERNEL);
715
+			if (edid)
702716 				status = connector_status_connected;
703717 		}
704718 	}
....@@ -711,7 +725,7 @@
711725 		status = connector_status_unknown;
712726 #endif
713727 
714
-	drm_connector_update_edid_property(connector, nv_connector->edid);
728
+	nouveau_connector_set_edid(nv_connector, edid);
715729 	nouveau_connector_set_encoder(connector, nv_encoder);
716730 	return status;
717731 }
....@@ -747,9 +761,9 @@
747761 nouveau_connector_set_property(struct drm_connector *connector,
748762 			       struct drm_property *property, uint64_t value)
749763 {
750
-	struct nouveau_conn_atom *asyc = nouveau_conn_atom(connector->state);
751764 	struct nouveau_connector *nv_connector = nouveau_connector(connector);
752765 	struct nouveau_encoder *nv_encoder = nv_connector->detected_encoder;
766
+	struct nouveau_conn_atom *asyc = &nv_connector->properties_state;
753767 	struct drm_encoder *encoder = to_drm_encoder(nv_encoder);
754768 	int ret;
755769 
....@@ -885,6 +899,22 @@
885899 }
886900 
887901 static int
902
+nouveau_connector_late_register(struct drm_connector *connector)
903
+{
904
+	int ret;
905
+
906
+	ret = nouveau_backlight_init(connector);
907
+
908
+	return ret;
909
+}
910
+
911
+static void
912
+nouveau_connector_early_unregister(struct drm_connector *connector)
913
+{
914
+	nouveau_backlight_fini(connector);
915
+}
916
+
917
+static int
888918 nouveau_connector_get_modes(struct drm_connector *connector)
889919 {
890920 	struct drm_device *dev = connector->dev;
....@@ -952,32 +982,50 @@
952982 }
953983 
954984 static unsigned
955
-get_tmds_link_bandwidth(struct drm_connector *connector, bool hdmi)
985
+get_tmds_link_bandwidth(struct drm_connector *connector)
956986 {
957987 	struct nouveau_connector *nv_connector = nouveau_connector(connector);
988
+	struct nouveau_encoder *nv_encoder = nv_connector->detected_encoder;
958989 	struct nouveau_drm *drm = nouveau_drm(connector->dev);
959990 	struct dcb_output *dcb = nv_connector->detected_encoder->dcb;
991
+	struct drm_display_info *info = NULL;
992
+	unsigned duallink_scale =
993
+		nouveau_duallink && nv_encoder->dcb->duallink_possible ? 2 : 1;
960994 
961
-	if (hdmi) {
995
+	if (drm_detect_hdmi_monitor(nv_connector->edid)) {
996
+		info = &nv_connector->base.display_info;
997
+		duallink_scale = 1;
998
+	}
999
+
1000
+	if (info) {
9621001 		if (nouveau_hdmimhz > 0)
9631002 			return nouveau_hdmimhz * 1000;
9641003 		/* Note: these limits are conservative, some Fermi's
9651004 		 * can do 297 MHz. Unclear how this can be determined.
9661005 		 */
1006
+		if (drm->client.device.info.chipset >= 0x120) {
1007
+			const int max_tmds_clock =
1008
+				info->hdmi.scdc.scrambling.supported ?
1009
+				594000 : 340000;
1010
+			return info->max_tmds_clock ?
1011
+				min(info->max_tmds_clock, max_tmds_clock) :
1012
+				max_tmds_clock;
1013
+		}
9671014 		if (drm->client.device.info.family >= NV_DEVICE_INFO_V0_KEPLER)
9681015 			return 297000;
9691016 		if (drm->client.device.info.family >= NV_DEVICE_INFO_V0_FERMI)
9701017 			return 225000;
9711018 	}
1019
+
9721020 	if (dcb->location != DCB_LOC_ON_CHIP ||
9731021 	    drm->client.device.info.chipset >= 0x46)
974
-		return 165000;
1022
+		return 165000 * duallink_scale;
9751023 	else if (drm->client.device.info.chipset >= 0x40)
976
-		return 155000;
1024
+		return 155000 * duallink_scale;
9771025 	else if (drm->client.device.info.chipset >= 0x18)
978
-		return 135000;
1026
+		return 135000 * duallink_scale;
9791027 	else
980
-		return 112000;
1028
+		return 112000 * duallink_scale;
9811029 }
9821030 
9831031 static enum drm_mode_status
....@@ -987,9 +1035,7 @@
9871035 	struct nouveau_connector *nv_connector = nouveau_connector(connector);
9881036 	struct nouveau_encoder *nv_encoder = nv_connector->detected_encoder;
9891037 	struct drm_encoder *encoder = to_drm_encoder(nv_encoder);
990
-	unsigned min_clock = 25000, max_clock = min_clock;
991
-	unsigned clock = mode->clock;
992
-	bool hdmi;
1038
+	unsigned int min_clock = 25000, max_clock = min_clock, clock = mode->clock;
9931039 
9941040 	switch (nv_encoder->dcb->type) {
9951041 	case DCB_OUTPUT_LVDS:
....@@ -1002,11 +1048,7 @@
10021048 		max_clock = 400000;
10031049 		break;
10041050 	case DCB_OUTPUT_TMDS:
1005
-		hdmi = drm_detect_hdmi_monitor(nv_connector->edid);
1006
-		max_clock = get_tmds_link_bandwidth(connector, hdmi);
1007
-		if (!hdmi && nouveau_duallink &&
1008
-		    nv_encoder->dcb->duallink_possible)
1009
-			max_clock *= 2;
1051
+		max_clock = get_tmds_link_bandwidth(connector);
10101052 		break;
10111053 	case DCB_OUTPUT_ANALOG:
10121054 		max_clock = nv_encoder->dcb->crtconf.maxfreq;
....@@ -1016,10 +1058,7 @@
10161058 	case DCB_OUTPUT_TV:
10171059 		return get_slave_funcs(encoder)->mode_valid(encoder, mode);
10181060 	case DCB_OUTPUT_DP:
1019
-		max_clock  = nv_encoder->dp.link_nr;
1020
-		max_clock *= nv_encoder->dp.link_bw;
1021
-		clock = clock * (connector->display_info.bpc * 3) / 10;
1022
-		break;
1061
+		return nv50_dp_mode_valid(connector, nv_encoder, mode, NULL);
10231062 	default:
10241063 		BUG();
10251064 		return MODE_BAD;
....@@ -1030,7 +1069,6 @@
10301069 
10311070 	if (clock < min_clock)
10321071 		return MODE_CLOCK_LOW;
1033
-
10341072 	if (clock > max_clock)
10351073 		return MODE_CLOCK_HIGH;
10361074 
....@@ -1068,6 +1106,8 @@
10681106 	.atomic_destroy_state = nouveau_conn_atomic_destroy_state,
10691107 	.atomic_set_property = nouveau_conn_atomic_set_property,
10701108 	.atomic_get_property = nouveau_conn_atomic_get_property,
1109
+	.late_register = nouveau_connector_late_register,
1110
+	.early_unregister = nouveau_connector_early_unregister,
10711111 };
10721112 
10731113 static const struct drm_connector_funcs
....@@ -1083,7 +1123,23 @@
10831123 	.atomic_destroy_state = nouveau_conn_atomic_destroy_state,
10841124 	.atomic_set_property = nouveau_conn_atomic_set_property,
10851125 	.atomic_get_property = nouveau_conn_atomic_get_property,
1126
+	.late_register = nouveau_connector_late_register,
1127
+	.early_unregister = nouveau_connector_early_unregister,
10861128 };
1129
+
1130
+void
1131
+nouveau_connector_hpd(struct drm_connector *connector)
1132
+{
1133
+	struct nouveau_drm *drm = nouveau_drm(connector->dev);
1134
+	u32 mask = drm_connector_mask(connector);
1135
+
1136
+	mutex_lock(&drm->hpd_lock);
1137
+	if (!(drm->hpd_pending & mask)) {
1138
+		drm->hpd_pending |= mask;
1139
+		schedule_work(&drm->hpd_work);
1140
+	}
1141
+	mutex_unlock(&drm->hpd_lock);
1142
+}
10871143 
10881144 static int
10891145 nouveau_connector_hotplug(struct nvif_notify *notify)
....@@ -1091,49 +1147,19 @@
10911147 	struct nouveau_connector *nv_connector =
10921148 		container_of(notify, typeof(*nv_connector), hpd);
10931149 	struct drm_connector *connector = &nv_connector->base;
1094
-	struct nouveau_drm *drm = nouveau_drm(connector->dev);
1150
+	struct drm_device *dev = connector->dev;
1151
+	struct nouveau_drm *drm = nouveau_drm(dev);
10951152 	const struct nvif_notify_conn_rep_v0 *rep = notify->data;
1096
-	const char *name = connector->name;
1097
-	struct nouveau_encoder *nv_encoder;
1098
-	int ret;
1099
-
1100
-	ret = pm_runtime_get(drm->dev->dev);
1101
-	if (ret == 0) {
1102
-		/* We can't block here if there's a pending PM request
1103
-		 * running, as we'll deadlock nouveau_display_fini() when it
1104
-		 * calls nvif_put() on our nvif_notify struct. So, simply
1105
-		 * defer the hotplug event until the device finishes resuming
1106
-		 */
1107
-		NV_DEBUG(drm, "Deferring HPD on %s until runtime resume\n",
1108
-			 name);
1109
-		schedule_work(&drm->hpd_work);
1110
-
1111
-		pm_runtime_put_noidle(drm->dev->dev);
1112
-		return NVIF_NOTIFY_KEEP;
1113
-	} else if (ret != 1 && ret != -EACCES) {
1114
-		NV_WARN(drm, "HPD on %s dropped due to RPM failure: %d\n",
1115
-			name, ret);
1116
-		return NVIF_NOTIFY_DROP;
1117
-	}
1153
+	bool plugged = (rep->mask != NVIF_NOTIFY_CONN_V0_UNPLUG);
11181154 
11191155 	if (rep->mask & NVIF_NOTIFY_CONN_V0_IRQ) {
1120
-		NV_DEBUG(drm, "service %s\n", name);
1121
-		if ((nv_encoder = find_encoder(connector, DCB_OUTPUT_DP)))
1122
-			nv50_mstm_service(nv_encoder->dp.mstm);
1123
-	} else {
1124
-		bool plugged = (rep->mask != NVIF_NOTIFY_CONN_V0_UNPLUG);
1125
-
1126
-		NV_DEBUG(drm, "%splugged %s\n", plugged ? "" : "un", name);
1127
-		if ((nv_encoder = find_encoder(connector, DCB_OUTPUT_DP))) {
1128
-			if (!plugged)
1129
-				nv50_mstm_remove(nv_encoder->dp.mstm);
1130
-		}
1131
-
1132
-		drm_helper_hpd_irq_event(connector->dev);
1156
+		nouveau_dp_irq(drm, nv_connector);
1157
+		return NVIF_NOTIFY_KEEP;
11331158 	}
11341159 
1135
-	pm_runtime_mark_last_busy(drm->dev->dev);
1136
-	pm_runtime_put_autosuspend(drm->dev->dev);
1160
+	NV_DEBUG(drm, "%splugged %s\n", plugged ? "" : "un", connector->name);
1161
+	nouveau_connector_hpd(connector);
1162
+
11371163 	return NVIF_NOTIFY_KEEP;
11381164 }
11391165 
....@@ -1184,7 +1210,9 @@
11841210 	case DCB_CONNECTOR_LVDS_SPWG: return DRM_MODE_CONNECTOR_LVDS;
11851211 	case DCB_CONNECTOR_DMS59_DP0:
11861212 	case DCB_CONNECTOR_DMS59_DP1:
1187
-	case DCB_CONNECTOR_DP       : return DRM_MODE_CONNECTOR_DisplayPort;
1213
+	case DCB_CONNECTOR_DP       :
1214
+	case DCB_CONNECTOR_mDP      :
1215
+	case DCB_CONNECTOR_USB_C    : return DRM_MODE_CONNECTOR_DisplayPort;
11881216 	case DCB_CONNECTOR_eDP      : return DRM_MODE_CONNECTOR_eDP;
11891217 	case DCB_CONNECTOR_HDMI_0   :
11901218 	case DCB_CONNECTOR_HDMI_1   :
....@@ -1198,7 +1226,8 @@
11981226 }
11991227 
12001228 struct drm_connector *
1201
-nouveau_connector_create(struct drm_device *dev, int index)
1229
+nouveau_connector_create(struct drm_device *dev,
1230
+			 const struct dcb_output *dcbe)
12021231 {
12031232 	const struct drm_connector_funcs *funcs = &nouveau_connector_funcs;
12041233 	struct nouveau_drm *drm = nouveau_drm(dev);
....@@ -1206,6 +1235,8 @@
12061235 	struct nouveau_connector *nv_connector = NULL;
12071236 	struct drm_connector *connector;
12081237 	struct drm_connector_list_iter conn_iter;
1238
+	char aux_name[48] = {0};
1239
+	int index = dcbe->connector;
12091240 	int type, ret = 0;
12101241 	bool dummy;
12111242 
....@@ -1306,15 +1337,17 @@
13061337 		break;
13071338 	case DRM_MODE_CONNECTOR_DisplayPort:
13081339 	case DRM_MODE_CONNECTOR_eDP:
1309
-		nv_connector->aux.dev = dev->dev;
1340
+		nv_connector->aux.dev = connector->kdev;
13101341 		nv_connector->aux.transfer = nouveau_connector_aux_xfer;
1342
+		snprintf(aux_name, sizeof(aux_name), "sor-%04x-%04x",
1343
+			 dcbe->hasht, dcbe->hashm);
1344
+		nv_connector->aux.name = kstrdup(aux_name, GFP_KERNEL);
13111345 		ret = drm_dp_aux_register(&nv_connector->aux);
13121346 		if (ret) {
13131347 			NV_ERROR(drm, "failed to register aux channel\n");
13141348 			kfree(nv_connector);
13151349 			return ERR_PTR(ret);
13161350 		}
1317
-
13181351 		funcs = &nouveau_connector_funcs;
13191352 		break;
13201353 	default:
....@@ -1368,7 +1401,15 @@
13681401 		break;
13691402 	}
13701403 
1371
-	ret = nvif_notify_init(&disp->disp.object, nouveau_connector_hotplug,
1404
+	switch (type) {
1405
+	case DRM_MODE_CONNECTOR_DisplayPort:
1406
+	case DRM_MODE_CONNECTOR_eDP:
1407
+		drm_dp_cec_register_connector(&nv_connector->aux, connector);
1408
+		break;
1409
+	}
1410
+
1411
+	ret = nvif_notify_ctor(&disp->disp.object, "kmsHotplug",
1412
+			       nouveau_connector_hotplug,
13721413 			       true, NV04_DISP_NTFY_CONN,
13731414 			       &(struct nvif_notify_conn_req_v0) {
13741415 				.mask = NVIF_NOTIFY_CONN_V0_ANY,