Hello,
I'm re-sending this series with the acked by in the msm patch and updating the docs in the last patch, the rest is the same.
v3 link: https://patchwork.kernel.org/project/dri-devel/list/?series=91353
Thanks! Helen
Changes in v4: - add acked by tag - update docs in atomic_async_update callback
Changes in v3: - use swap() to swap old and new framebuffers in async_update - get the reference to old_fb and set the worker after vop_plane_atomic_update() - add a FIXME tag for when we have multiple fbs to be released when vblank happens. - update commit message - Add Reviewed-by tags - Add TODO in drm_atomic_helper_async_commit()
Changes in v2: - added reviewed-by tag - update CC stable and Fixes tag - Added reviewed-by tag - updated CC stable and Fixes tag - Change the order of the patch in the series, add this as the last one. - Add documentation - s/ballanced/balanced
Helen Koike (5): drm/rockchip: fix fb references in async update drm/amd: fix fb references in async update drm/msm: fix fb references in async update drm/vc4: fix fb references in async update drm: don't block fb changes for async plane updates
.../gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c | 3 +- drivers/gpu/drm/drm_atomic_helper.c | 22 ++++---- drivers/gpu/drm/msm/disp/mdp5/mdp5_plane.c | 4 ++ drivers/gpu/drm/rockchip/rockchip_drm_vop.c | 51 ++++++++++--------- drivers/gpu/drm/vc4/vc4_plane.c | 2 +- include/drm/drm_modeset_helper_vtables.h | 8 +++ 6 files changed, 52 insertions(+), 38 deletions(-)
In the case of async update, modifications are done in place, i.e. in the current plane state, so the new_state is prepared and the new_state is cleaned up (instead of the old_state, unlike what happens in a normal sync update). To cleanup the old_fb properly, it needs to be placed in the new_state in the end of async_update, so cleanup call will unreference the old_fb correctly.
Also, the previous code had a:
plane_state = plane->funcs->atomic_duplicate_state(plane); ... swap(plane_state, plane->state);
if (plane->state->fb && plane->state->fb != new_state->fb) { ... }
Which was wrong, as the fb were just assigned to be equal, so this if statement nevers evaluates to true.
Another details is that the function drm_crtc_vblank_get() can only be called when vop->is_enabled is true, otherwise it has no effect and trows a WARN_ON().
Calling drm_atomic_set_fb_for_plane() (which get a referent of the new fb and pus the old fb) is not required, as it is taken care by drm_mode_cursor_universal() when calling drm_atomic_helper_update_plane().
Signed-off-by: Helen Koike helen.koike@collabora.com
--- Hello,
I tested on the rockchip ficus v1.1 using igt plane_cursor_legacy and kms_cursor_legacy and I didn't see any regressions.
Changes in v4: None Changes in v3: - use swap() to swap old and new framebuffers in async_update - get the reference to old_fb and set the worker after vop_plane_atomic_update() - add a FIXME tag for when we have multiple fbs to be released when vblank happens. - update commit message
Changes in v2: None
drivers/gpu/drm/rockchip/rockchip_drm_vop.c | 51 +++++++++++---------- 1 file changed, 26 insertions(+), 25 deletions(-)
diff --git a/drivers/gpu/drm/rockchip/rockchip_drm_vop.c b/drivers/gpu/drm/rockchip/rockchip_drm_vop.c index 4189ca17f381..b7c47d1153c6 100644 --- a/drivers/gpu/drm/rockchip/rockchip_drm_vop.c +++ b/drivers/gpu/drm/rockchip/rockchip_drm_vop.c @@ -919,29 +919,17 @@ static void vop_plane_atomic_async_update(struct drm_plane *plane, struct drm_plane_state *new_state) { struct vop *vop = to_vop(plane->state->crtc); - struct drm_plane_state *plane_state; - - plane_state = plane->funcs->atomic_duplicate_state(plane); - plane_state->crtc_x = new_state->crtc_x; - plane_state->crtc_y = new_state->crtc_y; - plane_state->crtc_h = new_state->crtc_h; - plane_state->crtc_w = new_state->crtc_w; - plane_state->src_x = new_state->src_x; - plane_state->src_y = new_state->src_y; - plane_state->src_h = new_state->src_h; - plane_state->src_w = new_state->src_w; - - if (plane_state->fb != new_state->fb) - drm_atomic_set_fb_for_plane(plane_state, new_state->fb); - - swap(plane_state, plane->state); - - if (plane->state->fb && plane->state->fb != new_state->fb) { - drm_framebuffer_get(plane->state->fb); - WARN_ON(drm_crtc_vblank_get(plane->state->crtc) != 0); - drm_flip_work_queue(&vop->fb_unref_work, plane->state->fb); - set_bit(VOP_PENDING_FB_UNREF, &vop->pending); - } + struct drm_framebuffer *old_fb = plane->state->fb; + + plane->state->crtc_x = new_state->crtc_x; + plane->state->crtc_y = new_state->crtc_y; + plane->state->crtc_h = new_state->crtc_h; + plane->state->crtc_w = new_state->crtc_w; + plane->state->src_x = new_state->src_x; + plane->state->src_y = new_state->src_y; + plane->state->src_h = new_state->src_h; + plane->state->src_w = new_state->src_w; + swap(plane->state->fb, new_state->fb);
if (vop->is_enabled) { rockchip_drm_psr_inhibit_get_state(new_state->state); @@ -950,9 +938,22 @@ static void vop_plane_atomic_async_update(struct drm_plane *plane, vop_cfg_done(vop); spin_unlock(&vop->reg_lock); rockchip_drm_psr_inhibit_put_state(new_state->state); - }
- plane->funcs->atomic_destroy_state(plane, plane_state); + /* + * A scanout can still be occurring, so we can't drop the + * reference to the old framebuffer. To solve this we get a + * reference to old_fb and set a worker to release it later. + * FIXME: if we perform 500 async_update calls before the + * vblank, then we can have 500 different framebuffers waiting + * to be released. + */ + if (old_fb && plane->state->fb != old_fb) { + drm_framebuffer_get(old_fb); + WARN_ON(drm_crtc_vblank_get(plane->state->crtc) != 0); + drm_flip_work_queue(&vop->fb_unref_work, old_fb); + set_bit(VOP_PENDING_FB_UNREF, &vop->pending); + } + } }
static const struct drm_plane_helper_funcs plane_helper_funcs = {
On 6/3/19 1:56 PM, Helen Koike wrote:
In the case of async update, modifications are done in place, i.e. in the current plane state, so the new_state is prepared and the new_state is cleaned up (instead of the old_state, unlike what happens in a normal sync update). To cleanup the old_fb properly, it needs to be placed in the new_state in the end of async_update, so cleanup call will unreference the old_fb correctly.
Also, the previous code had a:
plane_state = plane->funcs->atomic_duplicate_state(plane); ... swap(plane_state, plane->state);
if (plane->state->fb && plane->state->fb != new_state->fb) { ... }
Which was wrong, as the fb were just assigned to be equal, so this if statement nevers evaluates to true.
Another details is that the function drm_crtc_vblank_get() can only be called when vop->is_enabled is true, otherwise it has no effect and trows a WARN_ON().
Calling drm_atomic_set_fb_for_plane() (which get a referent of the new fb and pus the old fb) is not required, as it is taken care by drm_mode_cursor_universal() when calling drm_atomic_helper_update_plane().
Signed-off-by: Helen Koike helen.koike@collabora.com
Cc: stable@vger.kernel.org # v4.20+ Fixes: 15609559a834 ("drm/rockchip: update cursors asynchronously through atomic.")
Hello,
I tested on the rockchip ficus v1.1 using igt plane_cursor_legacy and kms_cursor_legacy and I didn't see any regressions.
Changes in v4: None Changes in v3:
- use swap() to swap old and new framebuffers in async_update
- get the reference to old_fb and set the worker after vop_plane_atomic_update()
- add a FIXME tag for when we have multiple fbs to be released when
vblank happens.
- update commit message
Changes in v2: None
drivers/gpu/drm/rockchip/rockchip_drm_vop.c | 51 +++++++++++---------- 1 file changed, 26 insertions(+), 25 deletions(-)
diff --git a/drivers/gpu/drm/rockchip/rockchip_drm_vop.c b/drivers/gpu/drm/rockchip/rockchip_drm_vop.c index 4189ca17f381..b7c47d1153c6 100644 --- a/drivers/gpu/drm/rockchip/rockchip_drm_vop.c +++ b/drivers/gpu/drm/rockchip/rockchip_drm_vop.c @@ -919,29 +919,17 @@ static void vop_plane_atomic_async_update(struct drm_plane *plane, struct drm_plane_state *new_state) { struct vop *vop = to_vop(plane->state->crtc);
- struct drm_plane_state *plane_state;
- plane_state = plane->funcs->atomic_duplicate_state(plane);
- plane_state->crtc_x = new_state->crtc_x;
- plane_state->crtc_y = new_state->crtc_y;
- plane_state->crtc_h = new_state->crtc_h;
- plane_state->crtc_w = new_state->crtc_w;
- plane_state->src_x = new_state->src_x;
- plane_state->src_y = new_state->src_y;
- plane_state->src_h = new_state->src_h;
- plane_state->src_w = new_state->src_w;
- if (plane_state->fb != new_state->fb)
drm_atomic_set_fb_for_plane(plane_state, new_state->fb);- swap(plane_state, plane->state);
- if (plane->state->fb && plane->state->fb != new_state->fb) {
drm_framebuffer_get(plane->state->fb);WARN_ON(drm_crtc_vblank_get(plane->state->crtc) != 0);drm_flip_work_queue(&vop->fb_unref_work, plane->state->fb);set_bit(VOP_PENDING_FB_UNREF, &vop->pending);- }
struct drm_framebuffer *old_fb = plane->state->fb;
plane->state->crtc_x = new_state->crtc_x;
plane->state->crtc_y = new_state->crtc_y;
plane->state->crtc_h = new_state->crtc_h;
plane->state->crtc_w = new_state->crtc_w;
plane->state->src_x = new_state->src_x;
plane->state->src_y = new_state->src_y;
plane->state->src_h = new_state->src_h;
plane->state->src_w = new_state->src_w;
swap(plane->state->fb, new_state->fb);
if (vop->is_enabled) { rockchip_drm_psr_inhibit_get_state(new_state->state);
@@ -950,9 +938,22 @@ static void vop_plane_atomic_async_update(struct drm_plane *plane, vop_cfg_done(vop); spin_unlock(&vop->reg_lock); rockchip_drm_psr_inhibit_put_state(new_state->state);
}
plane->funcs->atomic_destroy_state(plane, plane_state);
/** A scanout can still be occurring, so we can't drop the* reference to the old framebuffer. To solve this we get a* reference to old_fb and set a worker to release it later.* FIXME: if we perform 500 async_update calls before the* vblank, then we can have 500 different framebuffers waiting* to be released.*/if (old_fb && plane->state->fb != old_fb) {drm_framebuffer_get(old_fb);WARN_ON(drm_crtc_vblank_get(plane->state->crtc) != 0);drm_flip_work_queue(&vop->fb_unref_work, old_fb);set_bit(VOP_PENDING_FB_UNREF, &vop->pending);}- }
}
static const struct drm_plane_helper_funcs plane_helper_funcs = {
On Mon, 3 Jun 2019 17:13:34 -0300 Helen Koike helen.koike@collabora.com wrote:
On 6/3/19 1:56 PM, Helen Koike wrote:
In the case of async update, modifications are done in place, i.e. in the current plane state, so the new_state is prepared and the new_state is cleaned up (instead of the old_state, unlike what happens in a normal sync update). To cleanup the old_fb properly, it needs to be placed in the new_state in the end of async_update, so cleanup call will unreference the old_fb correctly.
Also, the previous code had a:
plane_state = plane->funcs->atomic_duplicate_state(plane); ... swap(plane_state, plane->state);
if (plane->state->fb && plane->state->fb != new_state->fb) { ... }
Which was wrong, as the fb were just assigned to be equal, so this if statement nevers evaluates to true.
Another details is that the function drm_crtc_vblank_get() can only be called when vop->is_enabled is true, otherwise it has no effect and trows a WARN_ON().
Calling drm_atomic_set_fb_for_plane() (which get a referent of the new fb and pus the old fb) is not required, as it is taken care by drm_mode_cursor_universal() when calling drm_atomic_helper_update_plane().
Signed-off-by: Helen Koike helen.koike@collabora.com
Cc: stable@vger.kernel.org # v4.20+ Fixes: 15609559a834 ("drm/rockchip: update cursors asynchronously through atomic.")
One comment for next time you have to add such tags after the fact: please try to keep lines unwrapped, otherwise patchwork only gets what's on the first line.
Async update callbacks are expected to set the old_fb in the new_state so prepare/cleanup framebuffers are balanced.
Calling drm_atomic_set_fb_for_plane() (which gets a reference of the new fb and put the old fb) is not required, as it's taken care by drm_mode_cursor_universal() when calling drm_atomic_helper_update_plane().
Suggested-by: Boris Brezillon boris.brezillon@collabora.com Signed-off-by: Helen Koike helen.koike@collabora.com Reviewed-by: Nicholas Kazlauskas nicholas.kazlauskas@amd.com
---
Changes in v4: None Changes in v3: None Changes in v2: - added reviewed-by tag
drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c | 3 +-- 1 file changed, 1 insertion(+), 2 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 443b13ec268d..40624b2c630e 100644 --- a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c +++ b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c @@ -4347,8 +4347,7 @@ static void dm_plane_atomic_async_update(struct drm_plane *plane, struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(new_state->state, plane);
- if (plane->state->fb != new_state->fb) - drm_atomic_set_fb_for_plane(plane->state, new_state->fb); + swap(plane->state->fb, new_state->fb);
plane->state->src_x = new_state->src_x; plane->state->src_y = new_state->src_y;
On 6/3/19 1:56 PM, Helen Koike wrote:
Async update callbacks are expected to set the old_fb in the new_state so prepare/cleanup framebuffers are balanced.
Calling drm_atomic_set_fb_for_plane() (which gets a reference of the new fb and put the old fb) is not required, as it's taken care by drm_mode_cursor_universal() when calling drm_atomic_helper_update_plane().
Suggested-by: Boris Brezillon boris.brezillon@collabora.com Signed-off-by: Helen Koike helen.koike@collabora.com Reviewed-by: Nicholas Kazlauskas nicholas.kazlauskas@amd.com
Cc: stable@vger.kernel.org # v4.20+ Fixes: 674e78acae0d ("drm/amd/display: Add fast path for cursor plane updates")
Changes in v4: None Changes in v3: None Changes in v2:
- added reviewed-by tag
drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c | 3 +-- 1 file changed, 1 insertion(+), 2 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 443b13ec268d..40624b2c630e 100644 --- a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c +++ b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c @@ -4347,8 +4347,7 @@ static void dm_plane_atomic_async_update(struct drm_plane *plane, struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(new_state->state, plane);
- if (plane->state->fb != new_state->fb)
drm_atomic_set_fb_for_plane(plane->state, new_state->fb);
swap(plane->state->fb, new_state->fb);
plane->state->src_x = new_state->src_x; plane->state->src_y = new_state->src_y;
Async update callbacks are expected to set the old_fb in the new_state so prepare/cleanup framebuffers are balanced.
Cc: stable@vger.kernel.org # v4.14+ Fixes: 224a4c970987 ("drm/msm: update cursors asynchronously through atomic") Suggested-by: Boris Brezillon boris.brezillon@collabora.com Signed-off-by: Helen Koike helen.koike@collabora.com Acked-by: Rob Clark robdclark@gmail.com
--- Hello,
This was tested on the dragonboard 410c using igt plane_cursor_legacy and kms_cursor_legacy and I didn't see any regressions.
Changes in v4: - add acked by tag
Changes in v3: None Changes in v2: - update CC stable and Fixes tag
drivers/gpu/drm/msm/disp/mdp5/mdp5_plane.c | 4 ++++ 1 file changed, 4 insertions(+)
diff --git a/drivers/gpu/drm/msm/disp/mdp5/mdp5_plane.c b/drivers/gpu/drm/msm/disp/mdp5/mdp5_plane.c index 9d9fb6c5fd68..1105c2433f14 100644 --- a/drivers/gpu/drm/msm/disp/mdp5/mdp5_plane.c +++ b/drivers/gpu/drm/msm/disp/mdp5/mdp5_plane.c @@ -502,6 +502,8 @@ static int mdp5_plane_atomic_async_check(struct drm_plane *plane, static void mdp5_plane_atomic_async_update(struct drm_plane *plane, struct drm_plane_state *new_state) { + struct drm_framebuffer *old_fb = plane->state->fb; + plane->state->src_x = new_state->src_x; plane->state->src_y = new_state->src_y; plane->state->crtc_x = new_state->crtc_x; @@ -524,6 +526,8 @@ static void mdp5_plane_atomic_async_update(struct drm_plane *plane,
*to_mdp5_plane_state(plane->state) = *to_mdp5_plane_state(new_state); + + new_state->fb = old_fb; }
static const struct drm_plane_helper_funcs mdp5_plane_helper_funcs = {
Async update callbacks are expected to set the old_fb in the new_state so prepare/cleanup framebuffers are balanced.
Calling drm_atomic_set_fb_for_plane() (which gets a reference of the new fb and put the old fb) is not required, as it's taken care by drm_mode_cursor_universal() when calling drm_atomic_helper_update_plane().
Cc: stable@vger.kernel.org # v4.19+ Fixes: 539c320bfa97 ("drm/vc4: update cursors asynchronously through atomic") Suggested-by: Boris Brezillon boris.brezillon@collabora.com Signed-off-by: Helen Koike helen.koike@collabora.com Reviewed-by: Boris Brezillon boris.brezillon@collabora.com
--- Hello,
I tested on a Raspberry Pi model B rev2 with igt plane_cursor_legacy and kms_cursor_legacy and I didn't see any regressions.
Changes in v4: None Changes in v3: None Changes in v2: - Added reviewed-by tag - updated CC stable and Fixes tag
drivers/gpu/drm/vc4/vc4_plane.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/drivers/gpu/drm/vc4/vc4_plane.c b/drivers/gpu/drm/vc4/vc4_plane.c index be2274924b34..441e06d45c89 100644 --- a/drivers/gpu/drm/vc4/vc4_plane.c +++ b/drivers/gpu/drm/vc4/vc4_plane.c @@ -1020,7 +1020,7 @@ static void vc4_plane_atomic_async_update(struct drm_plane *plane, { struct vc4_plane_state *vc4_state, *new_vc4_state;
- drm_atomic_set_fb_for_plane(plane->state, state->fb); + swap(plane->state->fb, state->fb); plane->state->crtc_x = state->crtc_x; plane->state->crtc_y = state->crtc_y; plane->state->crtc_w = state->crtc_w;
In the case of a normal sync update, the preparation of framebuffers (be it calling drm_atomic_helper_prepare_planes() or doing setups with drm_framebuffer_get()) are performed in the new_state and the respective cleanups are performed in the old_state.
In the case of async updates, the preparation is also done in the new_state but the cleanups are done in the new_state (because updates are performed in place, i.e. in the current state).
The current code blocks async udpates when the fb is changed, turning async updates into sync updates, slowing down cursor updates and introducing regressions in igt tests with errors of type:
"CRITICAL: completed 97 cursor updated in a period of 30 flips, we expect to complete approximately 15360 updates, with the threshold set at 7680"
Fb changes in async updates were prevented to avoid the following scenario:
- Async update, oldfb = NULL, newfb = fb1, prepare fb1, cleanup fb1 - Async update, oldfb = fb1, newfb = fb2, prepare fb2, cleanup fb2 - Non-async commit, oldfb = fb2, newfb = fb1, prepare fb1, cleanup fb2 (wrong) Where we have a single call to prepare fb2 but double cleanup call to fb2.
To solve the above problems, instead of blocking async fb changes, we place the old framebuffer in the new_state object, so when the code performs cleanups in the new_state it will cleanup the old_fb and we will have the following scenario instead:
- Async update, oldfb = NULL, newfb = fb1, prepare fb1, no cleanup - Async update, oldfb = fb1, newfb = fb2, prepare fb2, cleanup fb1 - Non-async commit, oldfb = fb2, newfb = fb1, prepare fb1, cleanup fb2
Where calls to prepare/cleanup are balanced.
Cc: stable@vger.kernel.org # v4.14+ Fixes: 25dc194b34dd ("drm: Block fb changes for async plane updates") Suggested-by: Boris Brezillon boris.brezillon@collabora.com Signed-off-by: Helen Koike helen.koike@collabora.com Reviewed-by: Boris Brezillon boris.brezillon@collabora.com Reviewed-by: Nicholas Kazlauskas nicholas.kazlauskas@amd.com
---
Changes in v4: - update docs in atomic_async_update callback
Changes in v3: - Add Reviewed-by tags - Add TODO in drm_atomic_helper_async_commit()
Changes in v2: - Change the order of the patch in the series, add this as the last one. - Add documentation - s/ballanced/balanced
drivers/gpu/drm/drm_atomic_helper.c | 22 ++++++++++++---------- include/drm/drm_modeset_helper_vtables.h | 8 ++++++++ 2 files changed, 20 insertions(+), 10 deletions(-)
diff --git a/drivers/gpu/drm/drm_atomic_helper.c b/drivers/gpu/drm/drm_atomic_helper.c index acf993cb8e52..ac81d8440b40 100644 --- a/drivers/gpu/drm/drm_atomic_helper.c +++ b/drivers/gpu/drm/drm_atomic_helper.c @@ -1610,15 +1610,6 @@ int drm_atomic_helper_async_check(struct drm_device *dev, old_plane_state->crtc != new_plane_state->crtc) return -EINVAL;
- /* - * FIXME: Since prepare_fb and cleanup_fb are always called on - * the new_plane_state for async updates we need to block framebuffer - * changes. This prevents use of a fb that's been cleaned up and - * double cleanups from occuring. - */ - if (old_plane_state->fb != new_plane_state->fb) - return -EINVAL; - funcs = plane->helper_private; if (!funcs->atomic_async_update) return -EINVAL; @@ -1649,6 +1640,8 @@ EXPORT_SYMBOL(drm_atomic_helper_async_check); * drm_atomic_async_check() succeeds. Async commits are not supposed to swap * the states like normal sync commits, but just do in-place changes on the * current state. + * + * TODO: Implement full swap instead of doing in-place changes. */ void drm_atomic_helper_async_commit(struct drm_device *dev, struct drm_atomic_state *state) @@ -1659,6 +1652,9 @@ void drm_atomic_helper_async_commit(struct drm_device *dev, int i;
for_each_new_plane_in_state(state, plane, plane_state, i) { + struct drm_framebuffer *new_fb = plane_state->fb; + struct drm_framebuffer *old_fb = plane->state->fb; + funcs = plane->helper_private; funcs->atomic_async_update(plane, plane_state);
@@ -1667,11 +1663,17 @@ void drm_atomic_helper_async_commit(struct drm_device *dev, * plane->state in-place, make sure at least common * properties have been properly updated. */ - WARN_ON_ONCE(plane->state->fb != plane_state->fb); + WARN_ON_ONCE(plane->state->fb != new_fb); WARN_ON_ONCE(plane->state->crtc_x != plane_state->crtc_x); WARN_ON_ONCE(plane->state->crtc_y != plane_state->crtc_y); WARN_ON_ONCE(plane->state->src_x != plane_state->src_x); WARN_ON_ONCE(plane->state->src_y != plane_state->src_y); + + /* + * Make sure the FBs have been swapped so that cleanups in the + * new_state performs a cleanup in the old FB. + */ + WARN_ON_ONCE(plane_state->fb != old_fb); } } EXPORT_SYMBOL(drm_atomic_helper_async_commit); diff --git a/include/drm/drm_modeset_helper_vtables.h b/include/drm/drm_modeset_helper_vtables.h index f9c94c2a1364..f7bbd0b0ecd1 100644 --- a/include/drm/drm_modeset_helper_vtables.h +++ b/include/drm/drm_modeset_helper_vtables.h @@ -1185,6 +1185,14 @@ struct drm_plane_helper_funcs { * current one with the new plane configurations in the new * plane_state. * + * Drivers should also swap the framebuffers between current plane + * state (&drm_plane.state) and new_state. + * This is required since cleanup for async commits is performed on + * the new state, rather than old state like for traditional commits. + * Since we want to give up the reference on the current (old) fb + * instead of our brand new one, swap them in the driver during the + * async commit. + * * FIXME: * - It only works for single plane updates * - Async Pageflips are not supported yet
On Mon, 3 Jun 2019 13:56:05 -0300 Helen Koike helen.koike@collabora.com wrote:
Hello,
I'm re-sending this series with the acked by in the msm patch and updating the docs in the last patch, the rest is the same.
v3 link: https://patchwork.kernel.org/project/dri-devel/list/?series=91353
Series queued to drm-misc-fixes.
Thanks! Helen
Changes in v4:
- add acked by tag
- update docs in atomic_async_update callback
Changes in v3:
- use swap() to swap old and new framebuffers in async_update
- get the reference to old_fb and set the worker after vop_plane_atomic_update()
- add a FIXME tag for when we have multiple fbs to be released when
vblank happens.
- update commit message
- Add Reviewed-by tags
- Add TODO in drm_atomic_helper_async_commit()
Changes in v2:
- added reviewed-by tag
- update CC stable and Fixes tag
- Added reviewed-by tag
- updated CC stable and Fixes tag
- Change the order of the patch in the series, add this as the last one.
- Add documentation
- s/ballanced/balanced
Helen Koike (5): drm/rockchip: fix fb references in async update drm/amd: fix fb references in async update drm/msm: fix fb references in async update drm/vc4: fix fb references in async update drm: don't block fb changes for async plane updates
.../gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c | 3 +- drivers/gpu/drm/drm_atomic_helper.c | 22 ++++---- drivers/gpu/drm/msm/disp/mdp5/mdp5_plane.c | 4 ++ drivers/gpu/drm/rockchip/rockchip_drm_vop.c | 51 ++++++++++--------- drivers/gpu/drm/vc4/vc4_plane.c | 2 +- include/drm/drm_modeset_helper_vtables.h | 8 +++ 6 files changed, 52 insertions(+), 38 deletions(-)
dri-devel@lists.freedesktop.org
-
Boris Brezillon -
Helen Koike