Lines Matching refs:connector
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) {
255 static void amdgpu_connector_get_edid(struct drm_connector *connector)
257 struct drm_device *dev = connector->dev;
259 struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
268 if ((amdgpu_connector_encoder_get_dp_bridge_encoder_id(connector) !=
271 amdgpu_connector->edid = drm_get_edid(connector,
273 } else if ((connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort) ||
274 (connector->connector_type == DRM_MODE_CONNECTOR_eDP)) {
280 amdgpu_connector->edid = drm_get_edid(connector,
283 amdgpu_connector->edid = drm_get_edid(connector,
286 amdgpu_connector->edid = drm_get_edid(connector,
292 if (((connector->connector_type == DRM_MODE_CONNECTOR_LVDS) ||
293 (connector->connector_type == DRM_MODE_CONNECTOR_eDP))) {
295 drm_connector_update_edid_property(connector, amdgpu_connector->edid);
300 static void amdgpu_connector_free_edid(struct drm_connector *connector)
302 struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
308 static int amdgpu_connector_ddc_get_modes(struct drm_connector *connector)
310 struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
314 drm_connector_update_edid_property(connector, amdgpu_connector->edid);
315 ret = drm_add_edid_modes(connector, amdgpu_connector->edid);
318 drm_connector_update_edid_property(connector, NULL);
323 amdgpu_connector_best_single_encoder(struct drm_connector *connector)
328 drm_connector_for_each_possible_encoder(connector, encoder)
334 static void amdgpu_get_native_mode(struct drm_connector *connector)
336 struct drm_encoder *encoder = amdgpu_connector_best_single_encoder(connector);
344 if (!list_empty(&connector->probed_modes)) {
346 list_first_entry(&connector->probed_modes,
394 struct drm_connector *connector)
444 drm_mode_probed_add(connector, mode);
448 static int amdgpu_connector_set_property(struct drm_connector *connector,
452 struct drm_device *dev = connector->dev;
461 /* need to find digital encoder on connector */
462 encoder = amdgpu_connector_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
480 struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
481 /* need to find digital encoder on connector */
482 encoder = amdgpu_connector_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
495 struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
496 /* need to find digital encoder on connector */
497 encoder = amdgpu_connector_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
510 /* need to find digital encoder on connector */
511 encoder = amdgpu_connector_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
524 /* need to find digital encoder on connector */
525 encoder = amdgpu_connector_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
538 /* need to find digital encoder on connector */
539 encoder = amdgpu_connector_find_encoder(connector, DRM_MODE_ENCODER_TMDS);
553 to_amdgpu_connector(connector);
564 if (connector->encoder) {
565 amdgpu_encoder = to_amdgpu_encoder(connector->encoder);
567 const struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
569 amdgpu_encoder = to_amdgpu_encoder(connector_funcs->best_encoder(connector));
605 struct drm_connector *connector)
612 list_for_each_entry_safe(mode, t, &connector->probed_modes, head) {
622 list_for_each_entry_safe(mode, t, &connector->probed_modes, head) {
639 static int amdgpu_connector_lvds_get_modes(struct drm_connector *connector)
645 amdgpu_connector_get_edid(connector);
646 ret = amdgpu_connector_ddc_get_modes(connector);
648 encoder = amdgpu_connector_best_single_encoder(connector);
650 amdgpu_connector_fixup_lcd_native_mode(encoder, connector);
652 amdgpu_connector_add_common_modes(encoder, connector);
657 encoder = amdgpu_connector_best_single_encoder(connector);
665 drm_mode_probed_add(connector, mode);
667 connector->display_info.width_mm = mode->width_mm;
668 connector->display_info.height_mm = mode->height_mm;
670 amdgpu_connector_add_common_modes(encoder, connector);
676 static enum drm_mode_status amdgpu_connector_lvds_mode_valid(struct drm_connector *connector,
679 struct drm_encoder *encoder = amdgpu_connector_best_single_encoder(connector);
707 amdgpu_connector_lvds_detect(struct drm_connector *connector, bool force)
709 struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
710 struct drm_encoder *encoder = amdgpu_connector_best_single_encoder(connector);
715 r = pm_runtime_get_sync(connector->dev->dev);
717 pm_runtime_put_autosuspend(connector->dev->dev);
733 amdgpu_connector_get_edid(connector);
738 amdgpu_connector_update_scratch_regs(connector, ret);
741 pm_runtime_mark_last_busy(connector->dev->dev);
742 pm_runtime_put_autosuspend(connector->dev->dev);
748 static void amdgpu_connector_unregister(struct drm_connector *connector)
750 struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
758 static void amdgpu_connector_destroy(struct drm_connector *connector)
760 struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
762 amdgpu_connector_free_edid(connector);
764 drm_connector_unregister(connector);
765 drm_connector_cleanup(connector);
766 kfree(connector);
769 static int amdgpu_connector_set_lcd_property(struct drm_connector *connector,
773 struct drm_device *dev = connector->dev;
781 if (connector->encoder)
782 amdgpu_encoder = to_amdgpu_encoder(connector->encoder);
784 const struct drm_connector_helper_funcs *connector_funcs = connector->helper_private;
786 amdgpu_encoder = to_amdgpu_encoder(connector_funcs->best_encoder(connector));
830 static int amdgpu_connector_vga_get_modes(struct drm_connector *connector)
834 amdgpu_connector_get_edid(connector);
835 ret = amdgpu_connector_ddc_get_modes(connector);
836 amdgpu_get_native_mode(connector);
841 static enum drm_mode_status amdgpu_connector_vga_mode_valid(struct drm_connector *connector,
844 struct drm_device *dev = connector->dev;
856 amdgpu_connector_vga_detect(struct drm_connector *connector, bool force)
858 struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
866 r = pm_runtime_get_sync(connector->dev->dev);
868 pm_runtime_put_autosuspend(connector->dev->dev);
873 encoder = amdgpu_connector_best_single_encoder(connector);
881 amdgpu_connector_free_edid(connector);
882 amdgpu_connector_get_edid(connector);
886 connector->name);
896 amdgpu_connector_free_edid(connector);
910 ret = connector->status;
916 ret = encoder_funcs->detect(encoder, connector);
922 amdgpu_connector_update_scratch_regs(connector, ret);
926 pm_runtime_mark_last_busy(connector->dev->dev);
927 pm_runtime_put_autosuspend(connector->dev->dev);
949 amdgpu_connector_check_hpd_status_unchanged(struct drm_connector *connector)
951 struct drm_device *dev = connector->dev;
953 struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
961 if (connector->status == status)
969 struct drm_connector *connector,
975 struct drm_device *dev = connector->dev;
982 if (connector == list_connector)
993 amdgpu_connector_free_edid(connector);
1008 * we need to find the DAC encoder object for this connector.
1012 * if its shared we have to set the other connector to disconnected.
1015 amdgpu_connector_dvi_detect(struct drm_connector *connector, bool force)
1017 struct drm_device *dev = connector->dev;
1019 struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
1026 r = pm_runtime_get_sync(connector->dev->dev);
1028 pm_runtime_put_autosuspend(connector->dev->dev);
1038 if (!force && amdgpu_connector_check_hpd_status_unchanged(connector)) {
1039 ret = connector->status;
1062 amdgpu_connector_free_edid(connector);
1063 amdgpu_connector_get_edid(connector);
1067 connector->name);
1078 amdgpu_connector_free_edid(connector);
1089 amdgpu_connector_shared_ddc(&ret, connector, amdgpu_connector);
1097 if ((connector->connector_type == DRM_MODE_CONNECTOR_DVID) ||
1098 (connector->connector_type == DRM_MODE_CONNECTOR_HDMIA))
1107 ret = connector->status;
1115 drm_connector_for_each_possible_encoder(connector, encoder) {
1125 ret = encoder_funcs->detect(encoder, connector);
1136 lret = encoder_funcs->detect(encoder, connector);
1149 amdgpu_connector_update_scratch_regs(connector, ret);
1153 pm_runtime_mark_last_busy(connector->dev->dev);
1154 pm_runtime_put_autosuspend(connector->dev->dev);
1162 amdgpu_connector_dvi_encoder(struct drm_connector *connector)
1164 struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
1167 drm_connector_for_each_possible_encoder(connector, encoder) {
1182 drm_connector_for_each_possible_encoder(connector, encoder)
1188 static void amdgpu_connector_dvi_force(struct drm_connector *connector)
1190 struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
1192 if (connector->force == DRM_FORCE_ON)
1194 if (connector->force == DRM_FORCE_ON_DIGITAL)
1198 static enum drm_mode_status amdgpu_connector_dvi_mode_valid(struct drm_connector *connector,
1201 struct drm_device *dev = connector->dev;
1203 struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
1212 } else if (connector->display_info.is_hdmi) {
1246 static int amdgpu_connector_dp_get_modes(struct drm_connector *connector)
1248 struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
1250 struct drm_encoder *encoder = amdgpu_connector_best_single_encoder(connector);
1253 if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) ||
1254 (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
1257 if (connector->connector_type == DRM_MODE_CONNECTOR_eDP) {
1259 amdgpu_atombios_encoder_set_edp_panel_power(connector,
1261 amdgpu_connector_get_edid(connector);
1262 ret = amdgpu_connector_ddc_get_modes(connector);
1264 amdgpu_atombios_encoder_set_edp_panel_power(connector,
1268 if (amdgpu_connector_encoder_get_dp_bridge_encoder_id(connector) !=
1273 amdgpu_connector_get_edid(connector);
1274 ret = amdgpu_connector_ddc_get_modes(connector);
1279 amdgpu_connector_fixup_lcd_native_mode(encoder, connector);
1281 amdgpu_connector_add_common_modes(encoder, connector);
1293 drm_mode_probed_add(connector, mode);
1295 connector->display_info.width_mm = mode->width_mm;
1296 connector->display_info.height_mm = mode->height_mm;
1298 amdgpu_connector_add_common_modes(encoder, connector);
1302 if (amdgpu_connector_encoder_get_dp_bridge_encoder_id(connector) !=
1307 amdgpu_connector_get_edid(connector);
1308 ret = amdgpu_connector_ddc_get_modes(connector);
1310 amdgpu_get_native_mode(connector);
1316 u16 amdgpu_connector_encoder_get_dp_bridge_encoder_id(struct drm_connector *connector)
1321 drm_connector_for_each_possible_encoder(connector, encoder) {
1336 static bool amdgpu_connector_encoder_is_hbr2(struct drm_connector *connector)
1342 drm_connector_for_each_possible_encoder(connector, encoder) {
1351 bool amdgpu_connector_is_dp12_capable(struct drm_connector *connector)
1353 struct drm_device *dev = connector->dev;
1357 amdgpu_connector_encoder_is_hbr2(connector)) {
1365 amdgpu_connector_dp_detect(struct drm_connector *connector, bool force)
1367 struct drm_device *dev = connector->dev;
1369 struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
1372 struct drm_encoder *encoder = amdgpu_connector_best_single_encoder(connector);
1376 r = pm_runtime_get_sync(connector->dev->dev);
1378 pm_runtime_put_autosuspend(connector->dev->dev);
1383 if (!force && amdgpu_connector_check_hpd_status_unchanged(connector)) {
1384 ret = connector->status;
1388 amdgpu_connector_free_edid(connector);
1390 if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) ||
1391 (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
1403 amdgpu_atombios_encoder_set_edp_panel_power(connector,
1408 amdgpu_atombios_encoder_set_edp_panel_power(connector,
1410 } else if (amdgpu_connector_encoder_get_dp_bridge_encoder_id(connector) !=
1427 ret = encoder_funcs->detect(encoder, connector);
1450 amdgpu_connector_update_scratch_regs(connector, ret);
1453 pm_runtime_mark_last_busy(connector->dev->dev);
1454 pm_runtime_put_autosuspend(connector->dev->dev);
1457 if (connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort ||
1458 connector->connector_type == DRM_MODE_CONNECTOR_eDP)
1466 static enum drm_mode_status amdgpu_connector_dp_mode_valid(struct drm_connector *connector,
1469 struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
1474 if ((connector->connector_type == DRM_MODE_CONNECTOR_eDP) ||
1475 (connector->connector_type == DRM_MODE_CONNECTOR_LVDS)) {
1476 struct drm_encoder *encoder = amdgpu_connector_best_single_encoder(connector);
1503 return amdgpu_atombios_dp_mode_valid_helper(connector, mode);
1505 if (connector->display_info.is_hdmi) {
1520 amdgpu_connector_late_register(struct drm_connector *connector)
1522 struct amdgpu_connector *amdgpu_connector = to_amdgpu_connector(connector);
1572 struct drm_connector *connector;
1589 drm_for_each_connector_iter(connector, &iter) {
1590 amdgpu_connector = to_amdgpu_connector(connector);
1629 connector = &amdgpu_connector->base;
1668 connector->interlace_allowed = true;
1669 connector->doublescan_allowed = true;
1715 connector->interlace_allowed = true;
1717 connector->doublescan_allowed = true;
1719 connector->doublescan_allowed = false;
1739 connector->interlace_allowed = false;
1740 connector->doublescan_allowed = false;
1767 connector->interlace_allowed = true;
1768 connector->doublescan_allowed = true;
1792 connector->interlace_allowed = true;
1793 connector->doublescan_allowed = true;
1845 connector->interlace_allowed = true;
1847 connector->doublescan_allowed = true;
1849 connector->doublescan_allowed = false;
1894 connector->interlace_allowed = true;
1896 connector->doublescan_allowed = true;
1898 connector->doublescan_allowed = false;
1944 connector->interlace_allowed = true;
1946 connector->doublescan_allowed = false;
1971 connector->interlace_allowed = false;
1972 connector->doublescan_allowed = false;
1995 connector->interlace_allowed = false;
1996 connector->doublescan_allowed = false;
2003 connector->polled = DRM_CONNECTOR_POLL_CONNECT |
2007 connector->polled = DRM_CONNECTOR_POLL_HPD;
2009 connector->display_info.subpixel_order = subpixel_order;
2022 drm_connector_cleanup(connector);
2023 kfree(connector);