aboutsummaryrefslogtreecommitdiffstats
path: root/meta-amd-bsp/recipes-kernel/linux-4.19/linux-yocto-4.19.8/1048-drm-amd-display-Move-iteration-out-of-dm_update_plan.patch
diff options
context:
space:
mode:
Diffstat (limited to 'meta-amd-bsp/recipes-kernel/linux-4.19/linux-yocto-4.19.8/1048-drm-amd-display-Move-iteration-out-of-dm_update_plan.patch')
-rw-r--r--meta-amd-bsp/recipes-kernel/linux-4.19/linux-yocto-4.19.8/1048-drm-amd-display-Move-iteration-out-of-dm_update_plan.patch315
1 files changed, 315 insertions, 0 deletions
diff --git a/meta-amd-bsp/recipes-kernel/linux-4.19/linux-yocto-4.19.8/1048-drm-amd-display-Move-iteration-out-of-dm_update_plan.patch b/meta-amd-bsp/recipes-kernel/linux-4.19/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/meta-amd-bsp/recipes-kernel/linux-4.19/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
+
generated by cgit 1.2.3-korg (git 2.39.0) at 2024-04-25 11:28:05 +0000