amd/amdgpu/amdgpu_connectors.c

43 void amdgpu_connector_hotplug(struct drm_connector *connector)
45 	struct drm_device *dev = connector->dev;
47 	struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
49 	/* bail if the connector does not have hpd pin, e.g.,
57 	/* if the connector is already off, don't turn it back on */
58 	if (connector->dpms != DRM_MODE_DPMS_ON)
62 	if (connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort) {
82 			/* Turn the connector off and back on immediately, which
85 			drm_helper_connector_dpms(connector, DRM_MODE_DPMS_OFF);
86 			drm_helper_connector_dpms(connector, DRM_MODE_DPMS_ON);
101 int amdgpu_connector_get_monitor_bpc(struct drm_connector *connector)
103 	struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
108 	switch (connector->connector_type) {
112 			if (connector->display_info.is_hdmi) {
113 				if (connector->display_info.bpc)
114 					bpc = connector->display_info.bpc;
120 		if (connector->display_info.is_hdmi) {
121 			if (connector->display_info.bpc)
122 				bpc = connector->display_info.bpc;
129 		    connector->display_info.is_hdmi) {
130 			if (connector->display_info.bpc)
131 				bpc = connector->display_info.bpc;
136 		if (connector->display_info.bpc)
137 			bpc = connector->display_info.bpc;
140 				connector->helper_private;
141 			struct drm_encoder *encoder = connector_funcs->best_encoder(connector);
153 	if (connector->display_info.is_hdmi) {
162 				  connector->name, bpc);
167 		if (connector->display_info.max_tmds_clock > 0) {
168 			/* mode_clock is clock in kHz for mode to be modeset on this connector */
172 			max_tmds_clock = connector->display_info.max_tmds_clock;
175 				  connector->name, mode_clock, max_tmds_clock);
179 				if ((connector->display_info.edid_hdmi_rgb444_dc_modes & DRM_EDID_HDMI_DC_30) &&
186 					  connector->name, bpc);
192 					  connector->name, bpc);
197 				  connector->name);
204 			  connector->name);
209 		  connector->name, connector->display_info.bpc, bpc);
215 amdgpu_connector_update_scratch_regs(struct drm_connector *connector,
220 	const struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
223 	best_encoder = connector_funcs->best_encoder(connector);
225 	drm_connector_for_each_possible_encoder(connector, encoder) {
231 		amdgpu_atombios_encoder_set_bios_scratch_regs(connector, encoder, connected);
236 amdgpu_connector_find_encoder(struct drm_connector *connector,
241 	drm_connector_for_each_possible_encoder(connector, encoder) {
249 struct edid *amdgpu_connector_edid(struct drm_connector *connector)
251 	struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
252 	struct drm_property_blob *edid_blob = connector->edid_blob_ptr;
275 static void amdgpu_connector_get_edid(struct drm_connector *connector)
277 	struct drm_device *dev = connector->dev;
279 	struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
288 	if ((amdgpu_connector_encoder_get_dp_bridge_encoder_id(connector) !=
291 		amdgpu_connector->edid = drm_get_edid(connector,
293 	} else if ((connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort) ||
294 		   (connector->connector_type == DRM_MODE_CONNECTOR_eDP)) {
300 			amdgpu_connector->edid = drm_get_edid(connector,
303 			amdgpu_connector->edid = drm_get_edid(connector,
306 		amdgpu_connector->edid = drm_get_edid(connector,
312 		if (((connector->connector_type == DRM_MODE_CONNECTOR_LVDS) ||
313 		     (connector->connector_type == DRM_MODE_CONNECTOR_eDP))) {
315 			drm_connector_update_edid_property(connector, amdgpu_connector->edid);
320 static void amdgpu_connector_free_edid(struct drm_connector *connector)
322 	struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
328 static int amdgpu_connector_ddc_get_modes(struct drm_connector *connector)
330 	struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
334 		drm_connector_update_edid_property(connector, amdgpu_connector->edid);
335 		ret = drm_add_edid_modes(connector, amdgpu_connector->edid);
338 	drm_connector_update_edid_property(connector, NULL);
343 amdgpu_connector_best_single_encoder(struct drm_connector *connector)
348 	drm_connector_for_each_possible_encoder(connector, encoder)
354 static void amdgpu_get_native_mode(struct drm_connector *connector)
356 	struct drm_encoder *encoder = amdgpu_connector_best_single_encoder(connector);
364 	if (!list_empty(&connector->probed_modes)) {
366 			list_first_entry(&connector->probed_modes,
414 					       struct drm_connector *connector)
461 		drm_mode_probed_add(connector, mode);
465 static int amdgpu_connector_set_property(struct drm_connector *connector,
469 	struct drm_device *dev = connector->dev;
478 		/* need to find digital encoder on connector */
479 		encoder = amdgpu_connector_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
497 		struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
498 		/* need to find digital encoder on connector */
499 		encoder = amdgpu_connector_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
512 		struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
513 		/* need to find digital encoder on connector */
514 		encoder = amdgpu_connector_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
527 		/* need to find digital encoder on connector */
528 		encoder = amdgpu_connector_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
541 		/* need to find digital encoder on connector */
542 		encoder = amdgpu_connector_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
555 		/* need to find digital encoder on connector */
556 		encoder = amdgpu_connector_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
570 			to_amdgpu_connector(connector);
581 		if (connector->encoder) {
582 			amdgpu_encoder = to_amdgpu_encoder(connector->encoder);
584 			const struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
586 			amdgpu_encoder = to_amdgpu_encoder(connector_funcs->best_encoder(connector));
622 					struct drm_connector *connector)
629 	list_for_each_entry_safe(mode, t, &connector->probed_modes, head) {
639 		list_for_each_entry_safe(mode, t, &connector->probed_modes, head) {
656 static int amdgpu_connector_lvds_get_modes(struct drm_connector *connector)
662 	amdgpu_connector_get_edid(connector);
663 	ret = amdgpu_connector_ddc_get_modes(connector);
665 		encoder = amdgpu_connector_best_single_encoder(connector);
667 			amdgpu_connector_fixup_lcd_native_mode(encoder, connector);
669 			amdgpu_connector_add_common_modes(encoder, connector);
674 	encoder = amdgpu_connector_best_single_encoder(connector);
682 		drm_mode_probed_add(connector, mode);
684 		connector->display_info.width_mm = mode->width_mm;
685 		connector->display_info.height_mm = mode->height_mm;
687 		amdgpu_connector_add_common_modes(encoder, connector);
693 static enum drm_mode_status amdgpu_connector_lvds_mode_valid(struct drm_connector *connector,
696 	struct drm_encoder *encoder = amdgpu_connector_best_single_encoder(connector);
724 amdgpu_connector_lvds_detect(struct drm_connector *connector, bool force)
726 	struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
727 	struct drm_encoder *encoder = amdgpu_connector_best_single_encoder(connector);
732 		r = pm_runtime_get_sync(connector->dev->dev);
734 			pm_runtime_put_autosuspend(connector->dev->dev);
750 	amdgpu_connector_get_edid(connector);
755 	amdgpu_connector_update_scratch_regs(connector, ret);
758 		pm_runtime_mark_last_busy(connector->dev->dev);
759 		pm_runtime_put_autosuspend(connector->dev->dev);
765 static void amdgpu_connector_unregister(struct drm_connector *connector)
767 	struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
775 static void amdgpu_connector_destroy(struct drm_connector *connector)
777 	struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
779 	amdgpu_connector_free_edid(connector);
781 	drm_connector_unregister(connector);
782 	drm_connector_cleanup(connector);
783 	kfree(connector);
786 static int amdgpu_connector_set_lcd_property(struct drm_connector *connector,
790 	struct drm_device *dev = connector->dev;
798 	if (connector->encoder)
799 		amdgpu_encoder = to_amdgpu_encoder(connector->encoder);
801 		const struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
803 		amdgpu_encoder = to_amdgpu_encoder(connector_funcs->best_encoder(connector));
847 static int amdgpu_connector_vga_get_modes(struct drm_connector *connector)
851 	amdgpu_connector_get_edid(connector);
852 	ret = amdgpu_connector_ddc_get_modes(connector);
853 	amdgpu_get_native_mode(connector);
858 static enum drm_mode_status amdgpu_connector_vga_mode_valid(struct drm_connector *connector,
861 	struct drm_device *dev = connector->dev;
873 amdgpu_connector_vga_detect(struct drm_connector *connector, bool force)
875 	struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
883 		r = pm_runtime_get_sync(connector->dev->dev);
885 			pm_runtime_put_autosuspend(connector->dev->dev);
890 	encoder = amdgpu_connector_best_single_encoder(connector);
898 		amdgpu_connector_free_edid(connector);
899 		amdgpu_connector_get_edid(connector);
903 					connector->name);
913 				amdgpu_connector_free_edid(connector);
927 				ret = connector->status;
933 			ret = encoder_funcs->detect(encoder, connector);
939 	amdgpu_connector_update_scratch_regs(connector, ret);
943 		pm_runtime_mark_last_busy(connector->dev->dev);
944 		pm_runtime_put_autosuspend(connector->dev->dev);
966 amdgpu_connector_check_hpd_status_unchanged(struct drm_connector *connector)
968 	struct drm_device *dev = connector->dev;
970 	struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
978 		if (connector->status == status)
986 					struct drm_connector *connector,
992 	struct drm_device *dev = connector->dev;
999 			if (connector == list_connector)
1010 						amdgpu_connector_free_edid(connector);
1025  * we need to find the DAC encoder object for this connector.
1029  * if its shared we have to set the other connector to disconnected.
1032 amdgpu_connector_dvi_detect(struct drm_connector *connector, bool force)
1034 	struct drm_device *dev = connector->dev;
1036 	struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
1043 		r = pm_runtime_get_sync(connector->dev->dev);
1045 			pm_runtime_put_autosuspend(connector->dev->dev);
1055 	if (!force && amdgpu_connector_check_hpd_status_unchanged(connector)) {
1056 		ret = connector->status;
1079 		amdgpu_connector_free_edid(connector);
1080 		amdgpu_connector_get_edid(connector);
1084 					connector->name);
1095 				amdgpu_connector_free_edid(connector);
1106 			amdgpu_connector_shared_ddc(&ret, connector, amdgpu_connector);
1114 	if ((connector->connector_type == DRM_MODE_CONNECTOR_DVID) ||
1115 	    (connector->connector_type == DRM_MODE_CONNECTOR_HDMIA))
1124 			ret = connector->status;
1132 		drm_connector_for_each_possible_encoder(connector, encoder) {
1142 						ret = encoder_funcs->detect(encoder, connector);
1153 					lret = encoder_funcs->detect(encoder, connector);
1166 	amdgpu_connector_update_scratch_regs(connector, ret);
1170 		pm_runtime_mark_last_busy(connector->dev->dev);
1171 		pm_runtime_put_autosuspend(connector->dev->dev);
1179 amdgpu_connector_dvi_encoder(struct drm_connector *connector)
1181 	struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
1184 	drm_connector_for_each_possible_encoder(connector, encoder) {
1199 	drm_connector_for_each_possible_encoder(connector, encoder)
1205 static void amdgpu_connector_dvi_force(struct drm_connector *connector)
1207 	struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
1209 	if (connector->force == DRM_FORCE_ON)
1211 	if (connector->force == DRM_FORCE_ON_DIGITAL)
1215 static enum drm_mode_status amdgpu_connector_dvi_mode_valid(struct drm_connector *connector,
1218 	struct drm_device *dev = connector->dev;
1220 	struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
1229 		} else if (connector->display_info.is_hdmi) {
1263 static int amdgpu_connector_dp_get_modes(struct drm_connector *connector)
1265 	struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
1267 	struct drm_encoder *encoder = amdgpu_connector_best_single_encoder(connector);
1270 	if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) ||
1271 	    (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
1274 		if (connector->connector_type == DRM_MODE_CONNECTOR_eDP) {
1276 				amdgpu_atombios_encoder_set_edp_panel_power(connector,
1278 			amdgpu_connector_get_edid(connector);
1279 			ret = amdgpu_connector_ddc_get_modes(connector);
1281 				amdgpu_atombios_encoder_set_edp_panel_power(connector,
1285 			if (amdgpu_connector_encoder_get_dp_bridge_encoder_id(connector) !=
1290 			amdgpu_connector_get_edid(connector);
1291 			ret = amdgpu_connector_ddc_get_modes(connector);
1296 				amdgpu_connector_fixup_lcd_native_mode(encoder, connector);
1298 				amdgpu_connector_add_common_modes(encoder, connector);
1310 			drm_mode_probed_add(connector, mode);
1312 			connector->display_info.width_mm = mode->width_mm;
1313 			connector->display_info.height_mm = mode->height_mm;
1315 			amdgpu_connector_add_common_modes(encoder, connector);
1319 		if (amdgpu_connector_encoder_get_dp_bridge_encoder_id(connector) !=
1324 		amdgpu_connector_get_edid(connector);
1325 		ret = amdgpu_connector_ddc_get_modes(connector);
1327 		amdgpu_get_native_mode(connector);
1333 u16 amdgpu_connector_encoder_get_dp_bridge_encoder_id(struct drm_connector *connector)
1338 	drm_connector_for_each_possible_encoder(connector, encoder) {
1353 static bool amdgpu_connector_encoder_is_hbr2(struct drm_connector *connector)
1359 	drm_connector_for_each_possible_encoder(connector, encoder) {
1368 bool amdgpu_connector_is_dp12_capable(struct drm_connector *connector)
1370 	struct drm_device *dev = connector->dev;
1374 	    amdgpu_connector_encoder_is_hbr2(connector)) {
1382 amdgpu_connector_dp_detect(struct drm_connector *connector, bool force)
1384 	struct drm_device *dev = connector->dev;
1386 	struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
1389 	struct drm_encoder *encoder = amdgpu_connector_best_single_encoder(connector);
1393 		r = pm_runtime_get_sync(connector->dev->dev);
1395 			pm_runtime_put_autosuspend(connector->dev->dev);
1400 	if (!force && amdgpu_connector_check_hpd_status_unchanged(connector)) {
1401 		ret = connector->status;
1405 	amdgpu_connector_free_edid(connector);
1407 	if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) ||
1408 	    (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
1420 			amdgpu_atombios_encoder_set_edp_panel_power(connector,
1425 			amdgpu_atombios_encoder_set_edp_panel_power(connector,
1427 	} else if (amdgpu_connector_encoder_get_dp_bridge_encoder_id(connector) !=
1444 				ret = encoder_funcs->detect(encoder, connector);
1467 	amdgpu_connector_update_scratch_regs(connector, ret);
1470 		pm_runtime_mark_last_busy(connector->dev->dev);
1471 		pm_runtime_put_autosuspend(connector->dev->dev);
1474 	if (connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort ||
1475 	    connector->connector_type == DRM_MODE_CONNECTOR_eDP)
1483 static enum drm_mode_status amdgpu_connector_dp_mode_valid(struct drm_connector *connector,
1486 	struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
1491 	if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) ||
1492 	    (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
1493 		struct drm_encoder *encoder = amdgpu_connector_best_single_encoder(connector);
1520 			return amdgpu_atombios_dp_mode_valid_helper(connector, mode);
1522 			if (connector->display_info.is_hdmi) {
1537 amdgpu_connector_late_register(struct drm_connector *connector)
1539 	struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
1589 	struct drm_connector *connector;
1606 	drm_for_each_connector_iter(connector, &iter) {
1607 		amdgpu_connector = to_amdgpu_connector(connector);
1646 	connector = &amdgpu_connector->base;
1685 			connector->interlace_allowed = true;
1686 			connector->doublescan_allowed = true;
1732 			connector->interlace_allowed = true;
1734 				connector->doublescan_allowed = true;
1736 				connector->doublescan_allowed = false;
1756 			connector->interlace_allowed = false;
1757 			connector->doublescan_allowed = false;
1784 			connector->interlace_allowed = true;
1785 			connector->doublescan_allowed = true;
1809 			connector->interlace_allowed = true;
1810 			connector->doublescan_allowed = true;
1862 			connector->interlace_allowed = true;
1864 				connector->doublescan_allowed = true;
1866 				connector->doublescan_allowed = false;
1911 			connector->interlace_allowed = true;
1913 				connector->doublescan_allowed = true;
1915 				connector->doublescan_allowed = false;
1961 			connector->interlace_allowed = true;
1963 			connector->doublescan_allowed = false;
1988 			connector->interlace_allowed = false;
1989 			connector->doublescan_allowed = false;
2012 			connector->interlace_allowed = false;
2013 			connector->doublescan_allowed = false;
2020 			connector->polled = DRM_CONNECTOR_POLL_CONNECT |
2024 		connector->polled = DRM_CONNECTOR_POLL_HPD;
2026 	connector->display_info.subpixel_order = subpixel_order;
2039 	drm_connector_cleanup(connector);
2040 	kfree(connector);