The current check doesn't handle the case where we don't steal an
encoder, but keep it on the current connector. If we repurpose
disable_conflicting_encoders to do the checking, we just have
to reject the ones that conflict.

Changes since v1:
- Return early when encoder_mask is empty, drm_for_each_connector
  requires connection_mutex held.

Signed-off-by: Maarten Lankhorst <maarten.lankho...@linux.intel.com>
Testcase: kms_setmode.invalid-clone-single-crtc-stealing
---
diff --git a/drivers/gpu/drm/drm_atomic_helper.c 
b/drivers/gpu/drm/drm_atomic_helper.c
index 3543c7fcd072..f44c043596d0 100644
--- a/drivers/gpu/drm/drm_atomic_helper.c
+++ b/drivers/gpu/drm/drm_atomic_helper.c
@@ -86,7 +86,8 @@ drm_atomic_helper_plane_changed(struct drm_atomic_state 
*state,
        }
 }
 
-static int disable_conflicting_connectors(struct drm_atomic_state *state)
+static int handle_conflicting_encoders(struct drm_atomic_state *state,
+                                      bool disable_conflicting_encoders)
 {
        struct drm_connector_state *conn_state;
        struct drm_connector *connector;
@@ -106,10 +107,22 @@ static int disable_conflicting_connectors(struct 
drm_atomic_state *state)
                else
                        new_encoder = funcs->best_encoder(connector);
 
-               if (new_encoder)
+               if (new_encoder) {
+                       if (encoder_mask & (1 << 
drm_encoder_index(new_encoder))) {
+                               DRM_DEBUG_ATOMIC("[ENCODER:%d:%s] on 
[CONNECTOR:%d:%s] already assigned\n",
+                                       new_encoder->base.id, new_encoder->name,
+                                       connector->base.id, connector->name);
+
+                               return -EINVAL;
+                       }
+
                        encoder_mask |= 1 << drm_encoder_index(new_encoder);
+               }
        }
 
+       if (!encoder_mask)
+               return 0;
+
        drm_for_each_connector(connector, state->dev) {
                struct drm_crtc_state *crtc_state;
 
@@ -120,6 +133,15 @@ static int disable_conflicting_connectors(struct 
drm_atomic_state *state)
                if (!encoder || !(encoder_mask & (1 << 
drm_encoder_index(encoder))))
                        continue;
 
+               if (!disable_conflicting_encoders) {
+                       DRM_DEBUG_ATOMIC("[ENCODER:%d:%s] in use on 
[CRTC:%d:%s] by [CONNECTOR:%d:%s]\n",
+                                        encoder->base.id, encoder->name,
+                                        connector->state->crtc->base.id,
+                                        connector->state->crtc->name,
+                                        connector->base.id, connector->name);
+                       return -EINVAL;
+               }
+
                conn_state = drm_atomic_get_connector_state(state, connector);
                if (IS_ERR(conn_state))
                        return PTR_ERR(conn_state);
@@ -148,26 +170,6 @@ static int disable_conflicting_connectors(struct 
drm_atomic_state *state)
        return 0;
 }
 
-static bool
-check_pending_encoder_assignment(struct drm_atomic_state *state,
-                                struct drm_encoder *new_encoder)
-{
-       struct drm_connector *connector;
-       struct drm_connector_state *conn_state;
-       int i;
-
-       for_each_connector_in_state(state, connector, conn_state, i) {
-               if (conn_state->best_encoder != new_encoder)
-                       continue;
-
-               /* encoder already assigned and we're trying to re-steal it! */
-               if (connector->state->best_encoder != conn_state->best_encoder)
-                       return false;
-       }
-
-       return true;
-}
-
 static void
 set_best_encoder(struct drm_atomic_state *state,
                 struct drm_connector_state *conn_state,
@@ -326,13 +328,6 @@ update_connector_routing(struct drm_atomic_state *state,
                return 0;
        }
 
-       if (!check_pending_encoder_assignment(state, new_encoder)) {
-               DRM_DEBUG_ATOMIC("Encoder for [CONNECTOR:%d:%s] already 
assigned\n",
-                                connector->base.id,
-                                connector->name);
-               return -EINVAL;
-       }
-
        ret = steal_encoder(state, new_encoder);
        if (ret) {
                DRM_DEBUG_ATOMIC("Encoder stealing failed for 
[CONNECTOR:%d:%s]\n",
@@ -511,11 +506,9 @@ drm_atomic_helper_check_modeset(struct drm_device *dev,
                }
        }
 
-       if (state->legacy_set_config) {
-               ret = disable_conflicting_connectors(state);
-               if (ret)
-                       return ret;
-       }
+       ret = handle_conflicting_encoders(state, state->legacy_set_config);
+       if (ret)
+               return ret;
 
        for_each_connector_in_state(state, connector, connector_state, i) {
                /*

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Reply via email to