diff options
Diffstat (limited to 'common/recipes-kernel/linux/linux-yocto-4.19.8/1048-drm-amd-display-Move-iteration-out-of-dm_update_plan.patch')
-rw-r--r-- | common/recipes-kernel/linux/linux-yocto-4.19.8/1048-drm-amd-display-Move-iteration-out-of-dm_update_plan.patch | 315 |
1 files changed, 315 insertions, 0 deletions
diff --git a/common/recipes-kernel/linux/linux-yocto-4.19.8/1048-drm-amd-display-Move-iteration-out-of-dm_update_plan.patch b/common/recipes-kernel/linux/linux-yocto-4.19.8/1048-drm-amd-display-Move-iteration-out-of-dm_update_plan.patch new file mode 100644 index 00000000..6f5ce667 --- /dev/null +++ b/common/recipes-kernel/linux/linux-yocto-4.19.8/1048-drm-amd-display-Move-iteration-out-of-dm_update_plan.patch @@ -0,0 +1,315 @@ +From 7cc53a6506d511483112f6aecccfc6f611fb1eb3 Mon Sep 17 00:00:00 2001 +From: Leo Li <sunpeng.li@amd.com> +Date: Sun, 11 Nov 2018 11:11:52 -0500 +Subject: [PATCH 1048/2940] drm/amd/display: Move iteration out of + dm_update_planes + +[Why] +To reduce indentation of dm_update_planes, and to make it operate on +single plane instances. + +[How] +Move iteration of plane states into atomic_check. +No functional change is intended. + +Signed-off-by: Leo Li <sunpeng.li@amd.com> +Reviewed-by: Nicholas Kazlauskas <nicholas.kazlauskas@amd.com> +Signed-off-by: Alex Deucher <alexander.deucher@amd.com> +--- + .../gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c | 220 +++++++++--------- + 1 file changed, 114 insertions(+), 106 deletions(-) + +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 0f5397059c75..7a0c9bd48703 100644 +--- a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c ++++ b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c +@@ -5708,145 +5708,141 @@ static int dm_update_crtcs_state(struct amdgpu_display_manager *dm, + return ret; + } + +-static int dm_update_planes_state(struct dc *dc, +- struct drm_atomic_state *state, +- bool enable, +- bool *lock_and_validation_needed) ++static int dm_update_plane_state(struct dc *dc, ++ struct drm_atomic_state *state, ++ struct drm_plane *plane, ++ struct drm_plane_state *old_plane_state, ++ struct drm_plane_state *new_plane_state, ++ bool enable, ++ bool *lock_and_validation_needed) + { + + struct dm_atomic_state *dm_state = NULL; + struct drm_crtc *new_plane_crtc, *old_plane_crtc; + struct drm_crtc_state *old_crtc_state, *new_crtc_state; +- struct drm_plane *plane; +- struct drm_plane_state *old_plane_state, *new_plane_state; + struct dm_crtc_state *dm_new_crtc_state, *dm_old_crtc_state; + struct dm_plane_state *dm_new_plane_state, *dm_old_plane_state; +- int i ; + /* TODO return page_flip_needed() function */ + bool pflip_needed = !state->allow_modeset; + int ret = 0; + + +- /* Add new planes, in reverse order as DC expectation */ +- for_each_oldnew_plane_in_state_reverse(state, plane, old_plane_state, new_plane_state, i) { +- new_plane_crtc = new_plane_state->crtc; +- old_plane_crtc = old_plane_state->crtc; +- dm_new_plane_state = to_dm_plane_state(new_plane_state); +- dm_old_plane_state = to_dm_plane_state(old_plane_state); ++ new_plane_crtc = new_plane_state->crtc; ++ old_plane_crtc = old_plane_state->crtc; ++ dm_new_plane_state = to_dm_plane_state(new_plane_state); ++ dm_old_plane_state = to_dm_plane_state(old_plane_state); + +- /*TODO Implement atomic check for cursor plane */ +- if (plane->type == DRM_PLANE_TYPE_CURSOR) +- continue; ++ /*TODO Implement atomic check for cursor plane */ ++ if (plane->type == DRM_PLANE_TYPE_CURSOR) ++ return 0; + +- /* Remove any changed/removed planes */ +- if (!enable) { +- if (pflip_needed && +- plane->type != DRM_PLANE_TYPE_OVERLAY) +- continue; ++ /* Remove any changed/removed planes */ ++ if (!enable) { ++ if (pflip_needed && ++ plane->type != DRM_PLANE_TYPE_OVERLAY) ++ return 0; + +- if (!old_plane_crtc) +- continue; ++ if (!old_plane_crtc) ++ return 0; + +- old_crtc_state = drm_atomic_get_old_crtc_state( +- state, old_plane_crtc); +- dm_old_crtc_state = to_dm_crtc_state(old_crtc_state); ++ old_crtc_state = drm_atomic_get_old_crtc_state( ++ state, old_plane_crtc); ++ dm_old_crtc_state = to_dm_crtc_state(old_crtc_state); + +- if (!dm_old_crtc_state->stream) +- continue; ++ if (!dm_old_crtc_state->stream) ++ return 0; + +- DRM_DEBUG_ATOMIC("Disabling DRM plane: %d on DRM crtc %d\n", +- plane->base.id, old_plane_crtc->base.id); ++ DRM_DEBUG_ATOMIC("Disabling DRM plane: %d on DRM crtc %d\n", ++ plane->base.id, old_plane_crtc->base.id); + +- ret = dm_atomic_get_state(state, &dm_state); +- if (ret) +- return ret; ++ ret = dm_atomic_get_state(state, &dm_state); ++ if (ret) ++ return ret; + +- if (!dc_remove_plane_from_context( +- dc, +- dm_old_crtc_state->stream, +- dm_old_plane_state->dc_state, +- dm_state->context)) { ++ if (!dc_remove_plane_from_context( ++ dc, ++ dm_old_crtc_state->stream, ++ dm_old_plane_state->dc_state, ++ dm_state->context)) { + +- ret = EINVAL; +- return ret; +- } ++ ret = EINVAL; ++ return ret; ++ } + + +- dc_plane_state_release(dm_old_plane_state->dc_state); +- dm_new_plane_state->dc_state = NULL; ++ dc_plane_state_release(dm_old_plane_state->dc_state); ++ dm_new_plane_state->dc_state = NULL; + +- *lock_and_validation_needed = true; ++ *lock_and_validation_needed = true; + +- } else { /* Add new planes */ +- struct dc_plane_state *dc_new_plane_state; ++ } else { /* Add new planes */ ++ struct dc_plane_state *dc_new_plane_state; + +- if (drm_atomic_plane_disabling(plane->state, new_plane_state)) +- continue; ++ if (drm_atomic_plane_disabling(plane->state, new_plane_state)) ++ return 0; + +- if (!new_plane_crtc) +- continue; ++ if (!new_plane_crtc) ++ return 0; + +- new_crtc_state = drm_atomic_get_new_crtc_state(state, new_plane_crtc); +- dm_new_crtc_state = to_dm_crtc_state(new_crtc_state); ++ new_crtc_state = drm_atomic_get_new_crtc_state(state, new_plane_crtc); ++ dm_new_crtc_state = to_dm_crtc_state(new_crtc_state); + +- if (!dm_new_crtc_state->stream) +- continue; ++ if (!dm_new_crtc_state->stream) ++ return 0; + +- if (pflip_needed && +- plane->type != DRM_PLANE_TYPE_OVERLAY) +- continue; ++ if (pflip_needed && plane->type != DRM_PLANE_TYPE_OVERLAY) ++ return 0; + +- WARN_ON(dm_new_plane_state->dc_state); ++ WARN_ON(dm_new_plane_state->dc_state); + +- dc_new_plane_state = dc_create_plane_state(dc); +- if (!dc_new_plane_state) +- return -ENOMEM; ++ dc_new_plane_state = dc_create_plane_state(dc); ++ if (!dc_new_plane_state) ++ return -ENOMEM; + +- DRM_DEBUG_DRIVER("Enabling DRM plane: %d on DRM crtc %d\n", +- plane->base.id, new_plane_crtc->base.id); ++ DRM_DEBUG_DRIVER("Enabling DRM plane: %d on DRM crtc %d\n", ++ plane->base.id, new_plane_crtc->base.id); + +- ret = fill_plane_attributes( +- new_plane_crtc->dev->dev_private, +- dc_new_plane_state, +- new_plane_state, +- new_crtc_state); +- if (ret) { +- dc_plane_state_release(dc_new_plane_state); +- return ret; +- } ++ ret = fill_plane_attributes( ++ new_plane_crtc->dev->dev_private, ++ dc_new_plane_state, ++ new_plane_state, ++ new_crtc_state); ++ if (ret) { ++ dc_plane_state_release(dc_new_plane_state); ++ return ret; ++ } + +- ret = dm_atomic_get_state(state, &dm_state); +- if (ret) { +- dc_plane_state_release(dc_new_plane_state); +- return ret; +- } ++ ret = dm_atomic_get_state(state, &dm_state); ++ if (ret) { ++ dc_plane_state_release(dc_new_plane_state); ++ return ret; ++ } + +- /* +- * Any atomic check errors that occur after this will +- * not need a release. The plane state will be attached +- * to the stream, and therefore part of the atomic +- * state. It'll be released when the atomic state is +- * cleaned. +- */ +- if (!dc_add_plane_to_context( +- dc, +- dm_new_crtc_state->stream, +- dc_new_plane_state, +- dm_state->context)) { +- +- dc_plane_state_release(dc_new_plane_state); +- return -EINVAL; +- } ++ /* ++ * Any atomic check errors that occur after this will ++ * not need a release. The plane state will be attached ++ * to the stream, and therefore part of the atomic ++ * state. It'll be released when the atomic state is ++ * cleaned. ++ */ ++ if (!dc_add_plane_to_context( ++ dc, ++ dm_new_crtc_state->stream, ++ dc_new_plane_state, ++ dm_state->context)) { + +- dm_new_plane_state->dc_state = dc_new_plane_state; ++ dc_plane_state_release(dc_new_plane_state); ++ return -EINVAL; ++ } + +- /* Tell DC to do a full surface update every time there +- * is a plane change. Inefficient, but works for now. +- */ +- dm_new_plane_state->dc_state->update_flags.bits.full_update = 1; ++ dm_new_plane_state->dc_state = dc_new_plane_state; + +- *lock_and_validation_needed = true; +- } ++ /* Tell DC to do a full surface update every time there ++ * is a plane change. Inefficient, but works for now. ++ */ ++ dm_new_plane_state->dc_state->update_flags.bits.full_update = 1; ++ ++ *lock_and_validation_needed = true; + } + + +@@ -6004,6 +6000,8 @@ static int amdgpu_dm_atomic_check(struct drm_device *dev, + struct drm_connector_state *old_con_state, *new_con_state; + struct drm_crtc *crtc; + struct drm_crtc_state *old_crtc_state, *new_crtc_state; ++ struct drm_plane *plane; ++ struct drm_plane_state *old_plane_state, *new_plane_state; + enum surface_update_type update_type = UPDATE_TYPE_FAST; + enum surface_update_type overall_update_type = UPDATE_TYPE_FAST; + +@@ -6039,9 +6037,14 @@ static int amdgpu_dm_atomic_check(struct drm_device *dev, + } + + /* Remove exiting planes if they are modified */ +- ret = dm_update_planes_state(dc, state, false, &lock_and_validation_needed); +- if (ret) { +- goto fail; ++ for_each_oldnew_plane_in_state_reverse(state, plane, old_plane_state, new_plane_state, i) { ++ ret = dm_update_plane_state(dc, state, plane, ++ old_plane_state, ++ new_plane_state, ++ false, ++ &lock_and_validation_needed); ++ if (ret) ++ goto fail; + } + + /* Disable all crtcs which require disable */ +@@ -6057,9 +6060,14 @@ static int amdgpu_dm_atomic_check(struct drm_device *dev, + } + + /* Add new/modified planes */ +- ret = dm_update_planes_state(dc, state, true, &lock_and_validation_needed); +- if (ret) { +- goto fail; ++ for_each_oldnew_plane_in_state_reverse(state, plane, old_plane_state, new_plane_state, i) { ++ ret = dm_update_plane_state(dc, state, plane, ++ old_plane_state, ++ new_plane_state, ++ true, ++ &lock_and_validation_needed); ++ if (ret) ++ goto fail; + } + + /* Run this here since we want to validate the streams we created */ +-- +2.17.1 + |