Lines Matching defs:connector
187 struct drm_connector *connector = &aconnector->base;
190 if (connector->connector_type != DRM_MODE_CONNECTOR_DisplayPort)
196 drm_object_property_set_value(&connector->base,
197 connector->dev->mode_config.dp_subconnector_property,
220 static int amdgpu_dm_connector_get_modes(struct drm_connector *connector);
698 struct drm_connector *connector;
722 drm_for_each_connector_iter(connector, &iter) {
723 aconnector = to_amdgpu_dm_connector(connector);
890 static void amdgpu_dm_fbc_init(struct drm_connector *connector)
892 struct drm_device *dev = connector->dev;
895 struct amdgpu_dm_connector *aconn = to_amdgpu_dm_connector(connector);
909 list_for_each_entry(mode, &connector->modes, head) {
936 struct drm_connector *connector;
946 drm_for_each_connector_iter(connector, &conn_iter) {
947 aconnector = to_amdgpu_dm_connector(connector);
952 ret = drm_eld_size(connector->eld);
953 memcpy(buf, connector->eld, min(max_bytes, ret));
1314 struct drm_connector *connector = &aconnector->base;
1316 mutex_lock(&connector->dev->mode_config.mutex);
1318 mutex_unlock(&connector->dev->mode_config.mutex);
1321 drm_kms_helper_connector_hotplug_event(connector);
1350 DRM_ERROR("KMS: Failed to detect connector\n");
1373 /* force connector disconnect and reconnect */
2265 struct drm_connector *connector;
2270 drm_for_each_connector_iter(connector, &iter) {
2271 aconnector = to_amdgpu_dm_connector(connector);
2393 struct drm_connector *connector;
2398 drm_for_each_connector_iter(connector, &iter) {
2399 aconnector = to_amdgpu_dm_connector(connector);
2667 struct drm_connector *connector;
2670 for_each_new_connector_in_state(state, connector, new_con_state, i) {
2674 return to_amdgpu_dm_connector(connector);
2735 DC_ERROR("Invalid connector type! signal:%d\n",
2809 struct drm_connector *connector;
2912 drm_for_each_connector_iter(connector, &iter) {
2913 aconnector = to_amdgpu_dm_connector(connector);
2927 DRM_ERROR("KMS: Failed to detect connector\n");
2982 drm_for_each_connector_iter(connector, &iter) {
2984 if (connector->connector_type == DRM_MODE_CONNECTOR_WRITEBACK)
2987 aconnector = to_amdgpu_dm_connector(connector);
3113 struct drm_connector *connector = &aconnector->base;
3114 struct drm_device *dev = connector->dev;
3126 * Edid mgmt connector gets first update only in mode_valid hook and then
3127 * the connector sink is set to either fake or physical sink depends on link status.
3135 * because on resume connector->sink is set to NULL
3141 amdgpu_dm_update_freesync_caps(connector, NULL);
3145 * to it anymore after disconnect, so on next crtc to connector
3152 amdgpu_dm_update_freesync_caps(connector,
3155 amdgpu_dm_update_freesync_caps(connector, NULL);
3196 * 1. Update status of the drm connector
3205 amdgpu_dm_update_freesync_caps(connector, NULL);
3233 drm_connector_update_edid_property(connector, aconnector->edid);
3234 amdgpu_dm_update_freesync_caps(connector, aconnector->edid);
3238 amdgpu_dm_update_freesync_caps(connector, NULL);
3239 drm_connector_update_edid_property(connector, NULL);
3247 if (connector->state->content_protection == DRM_MODE_CONTENT_PROTECTION_ENABLED)
3248 connector->state->content_protection = DRM_MODE_CONTENT_PROTECTION_DESIRED;
3261 struct drm_connector *connector = &aconnector->base;
3262 struct drm_device *dev = connector->dev;
3265 struct dm_connector_state *dm_con_state = to_dm_connector_state(connector->state);
3272 * In case of failure or MST no need to update connector status or notify the OS
3287 DRM_ERROR("KMS: Failed to detect connector\n");
3293 dm_restore_drm_connector_state(dev, connector);
3297 drm_kms_helper_connector_hotplug_event(connector);
3306 dm_restore_drm_connector_state(dev, connector);
3310 drm_kms_helper_connector_hotplug_event(connector);
3347 struct drm_connector *connector = &aconnector->base;
3348 struct drm_device *dev = connector->dev;
3428 DRM_ERROR("KMS: Failed to detect connector\n");
3440 dm_restore_drm_connector_state(dev, connector);
3443 drm_kms_helper_connector_hotplug_event(connector);
3458 dm_restore_drm_connector_state(dev, connector);
3461 drm_kms_helper_connector_hotplug_event(connector);
3479 struct drm_connector *connector;
3495 list_for_each_entry(connector,
3498 aconnector = to_amdgpu_dm_connector(connector);
4326 static void amdgpu_set_panel_orientation(struct drm_connector *connector);
4330 * connector -> encoder -> crtc
4331 * id not really requried. The crtc and connector will hold the
4482 DRM_ERROR("KMS: Failed to initialize connector\n");
4493 DRM_ERROR("KMS: Failed to detect connector\n");
5302 convert_color_depth_from_display_info(const struct drm_connector *connector,
5311 if (connector->display_info.hdmi.y420_dc_modes & DRM_EDID_YCBCR420_DC_48)
5313 else if (connector->display_info.hdmi.y420_dc_modes & DRM_EDID_YCBCR420_DC_36)
5315 else if (connector->display_info.hdmi.y420_dc_modes & DRM_EDID_YCBCR420_DC_30)
5318 bpc = (uint8_t)connector->display_info.bpc;
5328 * depending on when the connector gets added to the state
5467 const struct drm_connector *connector,
5473 const struct drm_display_info *info = &connector->display_info;
5474 struct amdgpu_dm_connector *aconnector = to_amdgpu_dm_connector(connector);
5492 else if ((connector->display_info.color_formats & DRM_COLOR_FORMAT_YCBCR444)
5500 connector,
5519 drm_hdmi_avi_infoframe_from_display_mode(&avi_frame, (struct drm_connector *)connector, mode_in);
5521 drm_hdmi_vendor_infoframe_from_display_mode(&hv_frame, (struct drm_connector *)connector, mode_in);
5748 * connector modeset list beforehand. With that, userspace can leverage
6161 amdgpu_dm_connector_detect(struct drm_connector *connector, bool force)
6164 struct amdgpu_dm_connector *aconnector = to_amdgpu_dm_connector(connector);
6186 int amdgpu_dm_connector_atomic_set_property(struct drm_connector *connector,
6191 struct drm_device *dev = connector->dev;
6194 to_dm_connector_state(connector->state);
6241 int amdgpu_dm_connector_atomic_get_property(struct drm_connector *connector,
6246 struct drm_device *dev = connector->dev;
6287 static void amdgpu_dm_connector_unregister(struct drm_connector *connector)
6289 struct amdgpu_dm_connector *amdgpu_dm_connector = to_amdgpu_dm_connector(connector);
6294 static void amdgpu_dm_connector_destroy(struct drm_connector *connector)
6296 struct amdgpu_dm_connector *aconnector = to_amdgpu_dm_connector(connector);
6297 struct amdgpu_device *adev = drm_to_adev(connector->dev);
6302 * for all connector types.
6320 drm_connector_unregister(connector);
6321 drm_connector_cleanup(connector);
6328 kfree(connector);
6331 void amdgpu_dm_connector_funcs_reset(struct drm_connector *connector)
6334 to_dm_connector_state(connector->state);
6336 if (connector->state)
6337 __drm_atomic_helper_connector_destroy_state(connector->state);
6352 if (connector->connector_type == DRM_MODE_CONNECTOR_eDP)
6356 __drm_atomic_helper_connector_reset(connector, &state->base);
6361 amdgpu_dm_connector_atomic_duplicate_state(struct drm_connector *connector)
6364 to_dm_connector_state(connector->state);
6372 __drm_atomic_helper_connector_duplicate_state(connector, &new_state->base);
6386 amdgpu_dm_connector_late_register(struct drm_connector *connector)
6389 to_amdgpu_dm_connector(connector);
6394 if ((connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort) ||
6395 (connector->connector_type == DRM_MODE_CONNECTOR_eDP)) {
6396 amdgpu_dm_connector->dm_dp_aux.aux.dev = connector->kdev;
6409 static void amdgpu_dm_connector_funcs_force(struct drm_connector *connector)
6411 struct amdgpu_dm_connector *aconnector = to_amdgpu_dm_connector(connector);
6416 if (!connector->edid_override)
6448 static int get_modes(struct drm_connector *connector)
6450 return amdgpu_dm_connector_get_modes(connector);
6462 /* if connector->edid_override valid, pass
6469 DRM_ERROR("No EDID firmware found on connector: %s ,forcing to OFF!\n",
6501 * In case of headless boot with force on for DP managed connector
6581 struct drm_connector *connector = &aconnector->base;
6582 struct amdgpu_device *adev = drm_to_adev(connector->dev);
6631 enum drm_mode_status amdgpu_dm_connector_mode_valid(struct drm_connector *connector,
6638 struct amdgpu_dm_connector *aconnector = to_amdgpu_dm_connector(connector);
6652 dc_sink = to_amdgpu_dm_connector(connector)->dc_sink;
6663 to_dm_connector_state(connector->state),
6701 switch (state->connector->connector_type) {
6840 struct drm_connector *connector = conn_state->connector;
6841 struct amdgpu_dm_connector *aconnector = to_amdgpu_dm_connector(connector);
6869 is_y420 = drm_mode_is_420_also(&connector->display_info, adjusted_mode) &&
6871 color_depth = convert_color_depth_from_display_info(connector,
6899 struct drm_connector *connector;
6906 for_each_new_connector_in_state(state, connector, new_con_state, i) {
6908 aconnector = to_amdgpu_dm_connector(connector);
6993 static struct drm_encoder *amdgpu_dm_connector_to_encoder(struct drm_connector *connector)
6997 /* There is only one encoder per connector */
6998 drm_connector_for_each_possible_encoder(connector, encoder)
7004 static void amdgpu_dm_get_native_mode(struct drm_connector *connector)
7009 encoder = amdgpu_dm_connector_to_encoder(connector);
7018 if (!list_empty(&connector->probed_modes)) {
7022 &connector->probed_modes,
7058 struct drm_connector *connector)
7064 to_amdgpu_dm_connector(connector);
7097 list_for_each_entry(curmode, &connector->probed_modes, head) {
7114 drm_mode_probed_add(connector, mode);
7119 static void amdgpu_set_panel_orientation(struct drm_connector *connector)
7125 if (connector->connector_type != DRM_MODE_CONNECTOR_eDP &&
7126 connector->connector_type != DRM_MODE_CONNECTOR_LVDS)
7129 mutex_lock(&connector->dev->mode_config.mutex);
7130 amdgpu_dm_connector_get_modes(connector);
7131 mutex_unlock(&connector->dev->mode_config.mutex);
7133 encoder = amdgpu_dm_connector_to_encoder(connector);
7143 drm_connector_set_panel_orientation_with_quirk(connector,
7149 static void amdgpu_dm_connector_ddc_get_modes(struct drm_connector *connector,
7153 to_amdgpu_dm_connector(connector);
7157 INIT_LIST_HEAD(&connector->probed_modes);
7159 drm_add_edid_modes(connector, edid);
7169 drm_mode_sort(&connector->probed_modes);
7170 amdgpu_dm_get_native_mode(connector);
7176 amdgpu_dm_update_freesync_caps(connector, edid);
7271 static void amdgpu_dm_connector_add_freesync_modes(struct drm_connector *connector,
7275 to_amdgpu_dm_connector(connector);
7285 static int amdgpu_dm_connector_get_modes(struct drm_connector *connector)
7288 to_amdgpu_dm_connector(connector);
7295 encoder = amdgpu_dm_connector_to_encoder(connector);
7299 drm_add_modes_noedid(connector, 640, 480);
7302 drm_add_modes_noedid(connector, 1920, 1080);
7304 amdgpu_dm_connector_ddc_get_modes(connector, edid);
7306 amdgpu_dm_connector_add_common_modes(encoder, connector);
7307 amdgpu_dm_connector_add_freesync_modes(connector, edid);
7309 amdgpu_dm_fbc_init(connector);
7330 * Allocate some default initial connector state with our reset helper.
7689 const struct drm_connector *connector,
7692 struct amdgpu_dm_connector *aconnector = to_amdgpu_dm_connector(connector);
7693 struct dm_connector_state *dm_con_state = to_dm_connector_state(connector->state);
7695 pr_debug("[HDCP_DM] connector->index: %x connect_status: %x dpms: %x\n",
7696 connector->index, connector->status, connector->dpms);
7755 connector->state->content_protection == DRM_MODE_CONTENT_PROTECTION_DESIRED) {
7772 connector->dpms == DRM_MODE_DPMS_ON && aconnector->dc_sink != NULL) {
8438 struct drm_connector *connector;
8446 for_each_oldnew_connector_in_state(state, connector, old_con_state, new_con_state, i) {
8465 if (connector->connector_type == DRM_MODE_CONNECTOR_WRITEBACK)
8468 aconnector = to_amdgpu_dm_connector(connector);
8479 for_each_new_connector_in_state(state, connector, new_con_state, i) {
8500 aconnector = to_amdgpu_dm_connector(connector);
8691 struct drm_connector *connector;
8707 for_each_oldnew_connector_in_state(state, connector, old_con_state, new_con_state, i) {
8710 struct amdgpu_dm_connector *aconnector = to_amdgpu_dm_connector(connector);
8717 if (!connector)
8720 pr_debug("[HDCP_DM] connector->index: %x connect_status: %x dpms: %x\n",
8721 connector->index, connector->status, connector->dpms);
8758 for_each_oldnew_connector_in_state(state, connector, old_con_state, new_con_state, i) {
8761 struct amdgpu_dm_connector *aconnector = to_amdgpu_dm_connector(connector);
8777 connector->state->content_protection == DRM_MODE_CONTENT_PROTECTION_ENABLED) {
8785 old_con_state, connector, adev->dm.hdcp_workqueue)) {
8787 * be destroyed within dm_dp_mst_connector_destroy. connector
8806 hdcp_w->hdcp_content_type[connector->index] =
8808 hdcp_w->content_protection[connector->index] =
8824 /* Handle connector state changes */
8825 for_each_oldnew_connector_in_state(state, connector, old_con_state, new_con_state, i) {
8987 /* Update audio instances for each connector. */
9041 static int dm_force_atomic_commit(struct drm_connector *connector)
9044 struct drm_device *ddev = connector->dev;
9046 struct amdgpu_crtc *disconnected_acrtc = to_amdgpu_crtc(connector->encoder->crtc);
9062 conn_state = drm_atomic_get_connector_state(state, connector);
9102 struct drm_connector *connector)
9104 struct amdgpu_dm_connector *aconnector = to_amdgpu_dm_connector(connector);
9108 if (!aconnector->dc_sink || !connector->state || !connector->encoder)
9111 disconnected_acrtc = to_amdgpu_crtc(connector->encoder->crtc);
9185 to_amdgpu_dm_connector(new_con_state->base.connector);
9502 * 2. Has a valid connector attached, and
10007 struct drm_connector *connector;
10012 for_each_oldnew_connector_in_state(state, connector, old_conn_state, conn_state, i) {
10019 aconnector = to_amdgpu_dm_connector(connector);
10052 * DC sink, which is tied to the DRM connector state. Cleaning this up should
10063 struct drm_connector *connector;
10086 /* Check connector changes */
10087 for_each_oldnew_connector_in_state(state, connector, old_con_state, new_con_state, i) {
10313 for_each_oldnew_connector_in_state(state, connector, old_con_state, new_con_state, i) {
10333 struct drm_connector *connector;
10338 drm_for_each_connector_iter(connector, &iter) {
10339 if (connector->index == mst_state->mgr->conn_base_id) {
10340 aconnector = to_amdgpu_dm_connector(connector);
10643 static void parse_edid_displayid_vrr(struct drm_connector *connector,
10676 connector->display_info.monitor_range.max_vfreq = max_vfreq;
10677 connector->display_info.monitor_range.min_vfreq = min_vfreq;
10755 * @connector: Connector to query.
10760 * amdgpu_dm. This function checks which type of connector we need to set the
10763 void amdgpu_dm_update_freesync_caps(struct drm_connector *connector,
10771 to_amdgpu_dm_connector(connector);
10775 struct drm_device *dev = connector->dev;
10781 if (!connector->state) {
10791 dm_con_state = to_dm_connector_state(connector->state);
10796 connector->display_info.monitor_range.min_vfreq = 0;
10797 connector->display_info.monitor_range.max_vfreq = 0;
10803 dm_con_state = to_dm_connector_state(connector->state);
10809 if ((connector->display_info.monitor_range.min_vfreq == 0 ||
10810 connector->display_info.monitor_range.max_vfreq == 0))
10811 parse_edid_displayid_vrr(connector, edid);
10820 amdgpu_dm_connector->min_vfreq = connector->display_info.monitor_range.min_vfreq;
10821 amdgpu_dm_connector->max_vfreq = connector->display_info.monitor_range.max_vfreq;
10852 connector->display_info.monitor_range.min_vfreq = range->min_vfreq;
10853 connector->display_info.monitor_range.max_vfreq = range->max_vfreq;
10857 connector->display_info.monitor_range.min_vfreq += 255;
10859 connector->display_info.monitor_range.max_vfreq += 255;
10863 connector->display_info.monitor_range.min_vfreq;
10865 connector->display_info.monitor_range.max_vfreq;
10897 connector->display_info.monitor_range.min_vfreq = vsdb_info.min_refresh_rate_hz;
10898 connector->display_info.monitor_range.max_vfreq = vsdb_info.max_refresh_rate_hz;
10917 connector->display_info.monitor_range.min_vfreq = vsdb_info.min_refresh_rate_hz;
10918 connector->display_info.monitor_range.max_vfreq = vsdb_info.max_refresh_rate_hz;
10926 if (connector->vrr_capable_property)
10927 drm_connector_set_vrr_capable_property(connector,