drm/amd/display: Disable cursors before disabling planes

[Why]
We can't do cursor programming after the planes have been disabled
since there won't be any pipes - leading to lock warnings and the wrong
cursor state being left in the registers.

When we re-enable the planes after the previous cursor state will also
remain if we don't have a cursor plane.

[How]
If we're disabling the planes then do the cursor programming first.
If we're not disabling the planes then do the cursor programming after.

Introduce the amdgpu_dm_commit_cursors helper to avoid code duplication
for both of these cases.

Signed-off-by: Nicholas Kazlauskas <nicholas.kazlauskas@amd.com>
Reviewed-by: David Francis <David.Francis@amd.com>
Acked-by: Leo Li <sunpeng.li@amd.com>
Signed-off-by: Alex Deucher <alexander.deucher@amd.com>

diff --git a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c
index c82048cb901d256847faaa2b16b8c0a3cf36cceb..6bd7da6b25b5551608e0428050d9df18dcbb3a9c 100644 (file)
--- a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c
+++ b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c
@@ -5158,6 +5158,22 @@ static void amdgpu_dm_handle_vrr_transition(struct dm_crtc_state *old_state,
        }
 }
 
+static void amdgpu_dm_commit_cursors(struct drm_atomic_state *state)
+{
+       struct drm_plane *plane;
+       struct drm_plane_state *old_plane_state, *new_plane_state;
+       int i;
+
+       /*
+        * TODO: Make this per-stream so we don't issue redundant updates for
+        * commits with multiple streams.
+        */
+       for_each_oldnew_plane_in_state(state, plane, old_plane_state,
+                                      new_plane_state, i)
+               if (plane->type == DRM_PLANE_TYPE_CURSOR)
+                       handle_cursor_update(plane, old_plane_state);
+}
+
 static void amdgpu_dm_commit_planes(struct drm_atomic_state *state,
                                    struct dc_state *dc_state,
                                    struct drm_device *dev,
@@ -5197,6 +5213,14 @@ static void amdgpu_dm_commit_planes(struct drm_atomic_state *state,
                goto cleanup;
        }
 
+       /*
+        * Disable the cursor first if we're disabling all the planes.
+        * It'll remain on the screen after the planes are re-enabled
+        * if we don't.
+        */
+       if (acrtc_state->active_planes == 0)
+               amdgpu_dm_commit_cursors(state);
+
        /* update planes when needed */
        for_each_oldnew_plane_in_state(state, plane, old_plane_state, new_plane_state, i) {
                struct drm_crtc *crtc = new_plane_state->crtc;
@@ -5393,9 +5417,13 @@ static void amdgpu_dm_commit_planes(struct drm_atomic_state *state,
                mutex_unlock(&dm->dc_lock);
        }
 
-       for_each_oldnew_plane_in_state(state, plane, old_plane_state, new_plane_state, i)
-               if (plane->type == DRM_PLANE_TYPE_CURSOR)
-                       handle_cursor_update(plane, old_plane_state);
+       /*
+        * Update cursor state *after* programming all the planes.
+        * This avoids redundant programming in the case where we're going
+        * to be disabling a single plane - those pipes are being disabled.
+        */
+       if (acrtc_state->active_planes)
+               amdgpu_dm_commit_cursors(state);
 
 cleanup:
        kfree(bundle);