drm/amd/display: Re-enable CRC capture following modeset

[Why]
During any modeset the CRTC stream is removed and a new stream is added.
This new stream doesn't carry over CRC capture state if it was
previously set.

[How]
Re-program the stream for CRC capture. The existing DRM callback can
be re-used here for the most part - the only modification needed is
additional locking now that it's called from within commit tail.

Signed-off-by: Nicholas Kazlauskas <nicholas.kazlauskas@amd.com>
Reviewed-by: Harry Wentland <Harry.Wentland@amd.com>
Reviewed-by: Sun peng Li <Sunpeng.Li@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 b0bdf5ceed0e1656d82c4174810a0f76a9331ef0..a247cb19077c3c27e11ab2ee06085900a0e4ada3 100644 (file)
--- a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c
+++ b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c
@@ -4923,10 +4923,13 @@ static int amdgpu_dm_atomic_commit(struct drm_device *dev,
                if (drm_atomic_crtc_needs_modeset(new_crtc_state)
                    && dm_old_crtc_state->stream) {
                        /*
-                        * CRC capture was enabled but not disabled.
-                        * Release the vblank reference.
+                        * If the stream is removed and CRC capture was
+                        * enabled on the CRTC the extra vblank reference
+                        * needs to be dropped since CRC capture will be
+                        * disabled.
                         */
-                       if (dm_new_crtc_state->crc_enabled) {
+                       if (!dm_new_crtc_state->stream
+                           && dm_new_crtc_state->crc_enabled) {
                                drm_crtc_vblank_put(crtc);
                                dm_new_crtc_state->crc_enabled = false;
                        }
@@ -5164,6 +5167,10 @@ static void amdgpu_dm_atomic_commit_tail(struct drm_atomic_state *state)
                        continue;
 
                manage_dm_interrupts(adev, acrtc, true);
+
+               /* The stream has changed so CRC capture needs to re-enabled. */
+               if (dm_new_crtc_state->crc_enabled)
+                       amdgpu_dm_crtc_set_crc_source(crtc, "auto");
        }
 
        /* update planes when needed per crtc*/

diff --git a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_crc.c b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_crc.c
index 26b651148c67a17f06c0fd09a924c9dbe6ef93ac..a10e3a50d9ef7cac2735347bf929580cc74ed945 100644 (file)
--- a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_crc.c
+++ b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_crc.c
@@ -64,6 +64,7 @@ amdgpu_dm_crtc_verify_crc_source(struct drm_crtc *crtc, const char *src_name,
 
 int amdgpu_dm_crtc_set_crc_source(struct drm_crtc *crtc, const char *src_name)
 {
+       struct amdgpu_device *adev = crtc->dev->dev_private;
        struct dm_crtc_state *crtc_state = to_dm_crtc_state(crtc->state);
        struct dc_stream_state *stream_state = crtc_state->stream;
        bool enable;
@@ -83,15 +84,20 @@ int amdgpu_dm_crtc_set_crc_source(struct drm_crtc *crtc, const char *src_name)
 
        enable = (source == AMDGPU_DM_PIPE_CRC_SOURCE_AUTO);
 
+       mutex_lock(&adev->dm.dc_lock);
        if (!dc_stream_configure_crc(stream_state->ctx->dc, stream_state,
-                                    enable, enable))
+                                    enable, enable)) {
+               mutex_unlock(&adev->dm.dc_lock);
                return -EINVAL;
+       }
 
        /* When enabling CRC, we should also disable dithering. */
        dc_stream_set_dither_option(stream_state,
                                    enable ? DITHER_OPTION_TRUN8
                                           : DITHER_OPTION_DEFAULT);
 
+       mutex_unlock(&adev->dm.dc_lock);
+
        /*
         * Reading the CRC requires the vblank interrupt handler to be
         * enabled. Keep a reference until CRC capture stops.