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;
281 static void amdgpu_connector_get_edid(struct drm_connector *connector)
283 	struct drm_device *dev = connector->dev;
285 	struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
294 	if ((amdgpu_connector_encoder_get_dp_bridge_encoder_id(connector) !=
297 		amdgpu_connector->edid = drm_get_edid(connector,
299 	} else if ((connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort) ||
300 		   (connector->connector_type == DRM_MODE_CONNECTOR_eDP)) {
306 			amdgpu_connector->edid = drm_get_edid(connector,
309 			amdgpu_connector->edid = drm_get_edid(connector,
312 		amdgpu_connector->edid = drm_get_edid(connector,
318 		if (((connector->connector_type == DRM_MODE_CONNECTOR_LVDS) ||
319 		     (connector->connector_type == DRM_MODE_CONNECTOR_eDP))) {
321 			drm_connector_update_edid_property(connector, amdgpu_connector->edid);
326 static void amdgpu_connector_free_edid(struct drm_connector *connector)
328 	struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
334 static int amdgpu_connector_ddc_get_modes(struct drm_connector *connector)
336 	struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
340 		drm_connector_update_edid_property(connector, amdgpu_connector->edid);
341 		ret = drm_add_edid_modes(connector, amdgpu_connector->edid);
344 	drm_connector_update_edid_property(connector, NULL);
349 amdgpu_connector_best_single_encoder(struct drm_connector *connector)
354 	drm_connector_for_each_possible_encoder(connector, encoder)
360 static void amdgpu_get_native_mode(struct drm_connector *connector)
362 	struct drm_encoder *encoder = amdgpu_connector_best_single_encoder(connector);
370 	if (!list_empty(&connector->probed_modes)) {
372 			list_first_entry(&connector->probed_modes,
420 					       struct drm_connector *connector)
467 		drm_mode_probed_add(connector, mode);
471 static int amdgpu_connector_set_property(struct drm_connector *connector,
475 	struct drm_device *dev = connector->dev;
484 		/* need to find digital encoder on connector */
485 		encoder = amdgpu_connector_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
503 		struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
504 		/* need to find digital encoder on connector */
505 		encoder = amdgpu_connector_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
518 		struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
519 		/* need to find digital encoder on connector */
520 		encoder = amdgpu_connector_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
533 		/* need to find digital encoder on connector */
534 		encoder = amdgpu_connector_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
547 		/* need to find digital encoder on connector */
548 		encoder = amdgpu_connector_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
561 		/* need to find digital encoder on connector */
562 		encoder = amdgpu_connector_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
576 			to_amdgpu_connector(connector);
587 		if (connector->encoder) {
588 			amdgpu_encoder = to_amdgpu_encoder(connector->encoder);
590 			const struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
591 			amdgpu_encoder = to_amdgpu_encoder(connector_funcs->best_encoder(connector));
627 					struct drm_connector *connector)
634 	list_for_each_entry_safe(mode, t, &connector->probed_modes, head) {
644 		list_for_each_entry_safe(mode, t, &connector->probed_modes, head) {
661 static int amdgpu_connector_lvds_get_modes(struct drm_connector *connector)
667 	amdgpu_connector_get_edid(connector);
668 	ret = amdgpu_connector_ddc_get_modes(connector);
670 		encoder = amdgpu_connector_best_single_encoder(connector);
672 			amdgpu_connector_fixup_lcd_native_mode(encoder, connector);
674 			amdgpu_connector_add_common_modes(encoder, connector);
679 	encoder = amdgpu_connector_best_single_encoder(connector);
687 		drm_mode_probed_add(connector, mode);
689 		connector->display_info.width_mm = mode->width_mm;
690 		connector->display_info.height_mm = mode->height_mm;
692 		amdgpu_connector_add_common_modes(encoder, connector);
698 static enum drm_mode_status amdgpu_connector_lvds_mode_valid(struct drm_connector *connector,
701 	struct drm_encoder *encoder = amdgpu_connector_best_single_encoder(connector);
729 amdgpu_connector_lvds_detect(struct drm_connector *connector, bool force)
731 	struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
732 	struct drm_encoder *encoder = amdgpu_connector_best_single_encoder(connector);
737 		r = pm_runtime_get_sync(connector->dev->dev);
739 			pm_runtime_put_autosuspend(connector->dev->dev);
755 	amdgpu_connector_get_edid(connector);
760 	amdgpu_connector_update_scratch_regs(connector, ret);
763 		pm_runtime_mark_last_busy(connector->dev->dev);
764 		pm_runtime_put_autosuspend(connector->dev->dev);
770 static void amdgpu_connector_unregister(struct drm_connector *connector)
772 	struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
780 static void amdgpu_connector_destroy(struct drm_connector *connector)
782 	struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
784 	amdgpu_connector_free_edid(connector);
786 	drm_connector_unregister(connector);
787 	drm_connector_cleanup(connector);
788 	kfree(connector);
791 static int amdgpu_connector_set_lcd_property(struct drm_connector *connector,
795 	struct drm_device *dev = connector->dev;
803 	if (connector->encoder)
804 		amdgpu_encoder = to_amdgpu_encoder(connector->encoder);
806 		const struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
807 		amdgpu_encoder = to_amdgpu_encoder(connector_funcs->best_encoder(connector));
851 static int amdgpu_connector_vga_get_modes(struct drm_connector *connector)
855 	amdgpu_connector_get_edid(connector);
856 	ret = amdgpu_connector_ddc_get_modes(connector);
857 	amdgpu_get_native_mode(connector);
862 static enum drm_mode_status amdgpu_connector_vga_mode_valid(struct drm_connector *connector,
865 	struct drm_device *dev = connector->dev;
877 amdgpu_connector_vga_detect(struct drm_connector *connector, bool force)
879 	struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
887 		r = pm_runtime_get_sync(connector->dev->dev);
889 			pm_runtime_put_autosuspend(connector->dev->dev);
894 	encoder = amdgpu_connector_best_single_encoder(connector);
902 		amdgpu_connector_free_edid(connector);
903 		amdgpu_connector_get_edid(connector);
907 					connector->name);
917 				amdgpu_connector_free_edid(connector);
931 				ret = connector->status;
937 			ret = encoder_funcs->detect(encoder, connector);
943 	amdgpu_connector_update_scratch_regs(connector, ret);
947 		pm_runtime_mark_last_busy(connector->dev->dev);
948 		pm_runtime_put_autosuspend(connector->dev->dev);
970 amdgpu_connector_check_hpd_status_unchanged(struct drm_connector *connector)
972 	struct drm_device *dev = connector->dev;
974 	struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
982 		if (connector->status == status)
994  * we need to find the DAC encoder object for this connector.
998  * if its shared we have to set the other connector to disconnected.
1001 amdgpu_connector_dvi_detect(struct drm_connector *connector, bool force)
1003 	struct drm_device *dev = connector->dev;
1005 	struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
1012 		r = pm_runtime_get_sync(connector->dev->dev);
1014 			pm_runtime_put_autosuspend(connector->dev->dev);
1024 	if (!force && amdgpu_connector_check_hpd_status_unchanged(connector)) {
1025 		ret = connector->status;
1048 		amdgpu_connector_free_edid(connector);
1049 		amdgpu_connector_get_edid(connector);
1053 					connector->name);
1064 				amdgpu_connector_free_edid(connector);
1083 					if (connector == list_connector)
1093 								amdgpu_connector_free_edid(connector);
1108 	if ((connector->connector_type == DRM_MODE_CONNECTOR_DVID) ||
1109 	    (connector->connector_type == DRM_MODE_CONNECTOR_HDMIA))
1118 			ret = connector->status;
1126 		drm_connector_for_each_possible_encoder(connector, encoder) {
1136 						ret = encoder_funcs->detect(encoder, connector);
1147 					lret = encoder_funcs->detect(encoder, connector);
1160 	amdgpu_connector_update_scratch_regs(connector, ret);
1164 		pm_runtime_mark_last_busy(connector->dev->dev);
1165 		pm_runtime_put_autosuspend(connector->dev->dev);
1173 amdgpu_connector_dvi_encoder(struct drm_connector *connector)
1175 	struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
1178 	drm_connector_for_each_possible_encoder(connector, encoder) {
1193 	drm_connector_for_each_possible_encoder(connector, encoder)
1199 static void amdgpu_connector_dvi_force(struct drm_connector *connector)
1201 	struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
1202 	if (connector->force == DRM_FORCE_ON)
1204 	if (connector->force == DRM_FORCE_ON_DIGITAL)
1208 static enum drm_mode_status amdgpu_connector_dvi_mode_valid(struct drm_connector *connector,
1211 	struct drm_device *dev = connector->dev;
1213 	struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
1222 		} else if (connector->display_info.is_hdmi) {
1256 static int amdgpu_connector_dp_get_modes(struct drm_connector *connector)
1258 	struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
1260 	struct drm_encoder *encoder = amdgpu_connector_best_single_encoder(connector);
1263 	if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) ||
1264 	    (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
1267 		if (connector->connector_type == DRM_MODE_CONNECTOR_eDP) {
1269 				amdgpu_atombios_encoder_set_edp_panel_power(connector,
1271 			amdgpu_connector_get_edid(connector);
1272 			ret = amdgpu_connector_ddc_get_modes(connector);
1274 				amdgpu_atombios_encoder_set_edp_panel_power(connector,
1278 			if (amdgpu_connector_encoder_get_dp_bridge_encoder_id(connector) !=
1283 			amdgpu_connector_get_edid(connector);
1284 			ret = amdgpu_connector_ddc_get_modes(connector);
1289 				amdgpu_connector_fixup_lcd_native_mode(encoder, connector);
1291 				amdgpu_connector_add_common_modes(encoder, connector);
1303 			drm_mode_probed_add(connector, mode);
1305 			connector->display_info.width_mm = mode->width_mm;
1306 			connector->display_info.height_mm = mode->height_mm;
1308 			amdgpu_connector_add_common_modes(encoder, connector);
1312 		if (amdgpu_connector_encoder_get_dp_bridge_encoder_id(connector) !=
1317 		amdgpu_connector_get_edid(connector);
1318 		ret = amdgpu_connector_ddc_get_modes(connector);
1320 		amdgpu_get_native_mode(connector);
1326 u16 amdgpu_connector_encoder_get_dp_bridge_encoder_id(struct drm_connector *connector)
1331 	drm_connector_for_each_possible_encoder(connector, encoder) {
1346 static bool amdgpu_connector_encoder_is_hbr2(struct drm_connector *connector)
1352 	drm_connector_for_each_possible_encoder(connector, encoder) {
1361 bool amdgpu_connector_is_dp12_capable(struct drm_connector *connector)
1363 	struct drm_device *dev = connector->dev;
1367 	    amdgpu_connector_encoder_is_hbr2(connector)) {
1375 amdgpu_connector_dp_detect(struct drm_connector *connector, bool force)
1377 	struct drm_device *dev = connector->dev;
1379 	struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
1382 	struct drm_encoder *encoder = amdgpu_connector_best_single_encoder(connector);
1386 		r = pm_runtime_get_sync(connector->dev->dev);
1388 			pm_runtime_put_autosuspend(connector->dev->dev);
1393 	if (!force && amdgpu_connector_check_hpd_status_unchanged(connector)) {
1394 		ret = connector->status;
1398 	amdgpu_connector_free_edid(connector);
1400 	if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) ||
1401 	    (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
1413 			amdgpu_atombios_encoder_set_edp_panel_power(connector,
1418 			amdgpu_atombios_encoder_set_edp_panel_power(connector,
1420 	} else if (amdgpu_connector_encoder_get_dp_bridge_encoder_id(connector) !=
1436 				ret = encoder_funcs->detect(encoder, connector);
1459 	amdgpu_connector_update_scratch_regs(connector, ret);
1462 		pm_runtime_mark_last_busy(connector->dev->dev);
1463 		pm_runtime_put_autosuspend(connector->dev->dev);
1466 	if (connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort ||
1467 	    connector->connector_type == DRM_MODE_CONNECTOR_eDP)
1475 static enum drm_mode_status amdgpu_connector_dp_mode_valid(struct drm_connector *connector,
1478 	struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
1483 	if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) ||
1484 	    (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
1485 		struct drm_encoder *encoder = amdgpu_connector_best_single_encoder(connector);
1512 			return amdgpu_atombios_dp_mode_valid_helper(connector, mode);
1514 			if (connector->display_info.is_hdmi) {
1529 amdgpu_connector_late_register(struct drm_connector *connector)
1531 	struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
1581 	struct drm_connector *connector;
1598 	drm_for_each_connector_iter(connector, &iter) {
1599 		amdgpu_connector = to_amdgpu_connector(connector);
1638 	connector = &amdgpu_connector->base;
1677 			connector->interlace_allowed = true;
1678 			connector->doublescan_allowed = true;
1724 			connector->interlace_allowed = true;
1726 				connector->doublescan_allowed = true;
1728 				connector->doublescan_allowed = false;
1748 			connector->interlace_allowed = false;
1749 			connector->doublescan_allowed = false;
1776 			connector->interlace_allowed = true;
1777 			connector->doublescan_allowed = true;
1801 			connector->interlace_allowed = true;
1802 			connector->doublescan_allowed = true;
1854 			connector->interlace_allowed = true;
1856 				connector->doublescan_allowed = true;
1858 				connector->doublescan_allowed = false;
1903 			connector->interlace_allowed = true;
1905 				connector->doublescan_allowed = true;
1907 				connector->doublescan_allowed = false;
1953 			connector->interlace_allowed = true;
1955 			connector->doublescan_allowed = false;
1980 			connector->interlace_allowed = false;
1981 			connector->doublescan_allowed = false;
2004 			connector->interlace_allowed = false;
2005 			connector->doublescan_allowed = false;
2012 			connector->polled = DRM_CONNECTOR_POLL_CONNECT |
2016 		connector->polled = DRM_CONNECTOR_POLL_HPD;
2018 	connector->display_info.subpixel_order = subpixel_order;
2031 	drm_connector_cleanup(connector);
2032 	kfree(connector);