redonkable/remarkable-linux
redonkable/remarkable-linux
1
0
Fork 0
Code Releases Activity

drm/atomic: Unconfuse the old_state mess in commmit_tail

Browse source 
I totally butcherd the job on typing the kernel-doc for these, and no
one realized. Noticed by Russell. Maarten has a more complete approach
to this confusion, by making it more explicit what the new/old state
is, instead of this magic switching behaviour.

v2:
- Liviu pointed out that wait_for_fences is even more magic. Leave
that as @state, and document @pre_swap better.
- While at it, patch in header for the reference section.
- Fix spelling issues Russell noticed.

v3: Fix up the @pre_swap note (Liviu): Also s/synchronous/blocking/,
since async flip is something else than non-blocking.

Cc: Liviu Dudau <liviu.dudau@arm.com>
Reported-by: Russell King - ARM Linux <linux@armlinux.org.uk>
Cc: Russell King - ARM Linux <linux@armlinux.org.uk>
Fixes: 9f2a7950e7 ("drm/atomic-helper: nonblocking commit support")
Cc: Gustavo Padovan <gustavo.padovan@collabora.co.uk>
Cc: Maarten Lankhorst <maarten.lankhorst@linux.intel.com>
Cc: Tomeu Vizoso <tomeu.vizoso@gmail.com>
Cc: Daniel Stone <daniels@collabora.com>
Reviewed-by: Liviu Dudau <liviu.dudau@arm.com>
Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
Link: http://patchwork.freedesktop.org/patch/msgid/20161121171802.24147-1-daniel.vetter@ffwll.ch
This commit is contained in:
Daniel Vetter 2016-11-21 18:18:02 +01:00
parent 9a83a71ac0
commit 1ea0c02e70
3 changed files with 54 additions and 39 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
Documentation/gpu/drm-kms-helpers.rst
View file

@ -63,6 +63,9 @@ Atomic State Reset and Initialization
.. kernel-doc:: drivers/gpu/drm/drm_atomic_helper.c .. kernel-doc:: drivers/gpu/drm/drm_atomic_helper.c
:doc: atomic state reset and initialization :doc: atomic state reset and initialization
Helper Functions Reference
--------------------------
.. kernel-doc:: include/drm/drm_atomic_helper.h .. kernel-doc:: include/drm/drm_atomic_helper.h
:internal: :internal:

78
drivers/gpu/drm/drm_atomic_helper.c
View file

@ -1006,13 +1006,21 @@ EXPORT_SYMBOL(drm_atomic_helper_commit_modeset_enables);
* drm_atomic_helper_wait_for_fences - wait for fences stashed in plane state * drm_atomic_helper_wait_for_fences - wait for fences stashed in plane state
* @dev: DRM device * @dev: DRM device
* @state: atomic state object with old state structures * @state: atomic state object with old state structures
* @pre_swap: if true, do an interruptible wait * @pre_swap: If true, do an interruptible wait, and @state is the new state.
* Otherwise @state is the old state.
* *
* For implicit sync, driver should fish the exclusive fence out from the * For implicit sync, driver should fish the exclusive fence out from the
* incoming fb's and stash it in the drm_plane_state. This is called after * incoming fb's and stash it in the drm_plane_state. This is called after
* drm_atomic_helper_swap_state() so it uses the current plane state (and * drm_atomic_helper_swap_state() so it uses the current plane state (and
* just uses the atomic state to find the changed planes) * just uses the atomic state to find the changed planes)
* *
* Note that @pre_swap is needed since the point where we block for fences moves
* around depending upon whether an atomic commit is blocking or
* non-blocking. For async commit all waiting needs to happen after
* drm_atomic_helper_swap_state() is called, but for synchronous commits we want
* to wait **before** we do anything that can't be easily rolled back. That is
* before we call drm_atomic_helper_swap_state().
*
* Returns zero if success or < 0 if dma_fence_wait() fails. * Returns zero if success or < 0 if dma_fence_wait() fails.
*/ */
int drm_atomic_helper_wait_for_fences(struct drm_device *dev, int drm_atomic_helper_wait_for_fences(struct drm_device *dev,
@ -1147,7 +1155,7 @@ EXPORT_SYMBOL(drm_atomic_helper_wait_for_vblanks);
/** /**
* drm_atomic_helper_commit_tail - commit atomic update to hardware * drm_atomic_helper_commit_tail - commit atomic update to hardware
* @state: new modeset state to be committed * @old_state: atomic state object with old state structures
* *
* This is the default implemenation for the ->atomic_commit_tail() hook of the * This is the default implemenation for the ->atomic_commit_tail() hook of the
* &drm_mode_config_helper_funcs vtable. * &drm_mode_config_helper_funcs vtable.
@ -1158,53 +1166,53 @@ EXPORT_SYMBOL(drm_atomic_helper_wait_for_vblanks);
* *
* For drivers supporting runtime PM the recommended sequence is instead :: * For drivers supporting runtime PM the recommended sequence is instead ::
* *
* drm_atomic_helper_commit_modeset_disables(dev, state); * drm_atomic_helper_commit_modeset_disables(dev, old_state);
* *
* drm_atomic_helper_commit_modeset_enables(dev, state); * drm_atomic_helper_commit_modeset_enables(dev, old_state);
* *
* drm_atomic_helper_commit_planes(dev, state, * drm_atomic_helper_commit_planes(dev, old_state,
* DRM_PLANE_COMMIT_ACTIVE_ONLY); * DRM_PLANE_COMMIT_ACTIVE_ONLY);
* *
* for committing the atomic update to hardware. See the kerneldoc entries for * for committing the atomic update to hardware. See the kerneldoc entries for
* these three functions for more details. * these three functions for more details.
*/ */
void drm_atomic_helper_commit_tail(struct drm_atomic_state *state) void drm_atomic_helper_commit_tail(struct drm_atomic_state *old_state)
{ {
struct drm_device *dev = state->dev; struct drm_device *dev = old_state->dev;
drm_atomic_helper_commit_modeset_disables(dev, state); drm_atomic_helper_commit_modeset_disables(dev, old_state);
drm_atomic_helper_commit_planes(dev, state, 0); drm_atomic_helper_commit_planes(dev, old_state, 0);
drm_atomic_helper_commit_modeset_enables(dev, state); drm_atomic_helper_commit_modeset_enables(dev, old_state);
drm_atomic_helper_commit_hw_done(state); drm_atomic_helper_commit_hw_done(old_state);
drm_atomic_helper_wait_for_vblanks(dev, state); drm_atomic_helper_wait_for_vblanks(dev, old_state);
drm_atomic_helper_cleanup_planes(dev, state); drm_atomic_helper_cleanup_planes(dev, old_state);
} }
EXPORT_SYMBOL(drm_atomic_helper_commit_tail); EXPORT_SYMBOL(drm_atomic_helper_commit_tail);
static void commit_tail(struct drm_atomic_state *state) static void commit_tail(struct drm_atomic_state *old_state)
{ {
struct drm_device *dev = state->dev; struct drm_device *dev = old_state->dev;
struct drm_mode_config_helper_funcs *funcs; struct drm_mode_config_helper_funcs *funcs;
funcs = dev->mode_config.helper_private; funcs = dev->mode_config.helper_private;
drm_atomic_helper_wait_for_fences(dev, state, false); drm_atomic_helper_wait_for_fences(dev, old_state, false);
drm_atomic_helper_wait_for_dependencies(state); drm_atomic_helper_wait_for_dependencies(old_state);
if (funcs && funcs->atomic_commit_tail) if (funcs && funcs->atomic_commit_tail)
funcs->atomic_commit_tail(state); funcs->atomic_commit_tail(old_state);
else else
drm_atomic_helper_commit_tail(state); drm_atomic_helper_commit_tail(old_state);
drm_atomic_helper_commit_cleanup_done(state); drm_atomic_helper_commit_cleanup_done(old_state);
drm_atomic_state_put(state); drm_atomic_state_put(old_state);
} }
static void commit_work(struct work_struct *work) static void commit_work(struct work_struct *work)
@ -1498,10 +1506,10 @@ static struct drm_crtc_commit *preceeding_commit(struct drm_crtc *crtc)
/** /**
* drm_atomic_helper_wait_for_dependencies - wait for required preceeding commits * drm_atomic_helper_wait_for_dependencies - wait for required preceeding commits
* @state: new modeset state to be committed * @old_state: atomic state object with old state structures
* *
* This function waits for all preceeding commits that touch the same CRTC as * This function waits for all preceeding commits that touch the same CRTC as
* @state to both be committed to the hardware (as signalled by * @old_state to both be committed to the hardware (as signalled by
* drm_atomic_helper_commit_hw_done) and executed by the hardware (as signalled * drm_atomic_helper_commit_hw_done) and executed by the hardware (as signalled
* by calling drm_crtc_vblank_send_event on the event member of * by calling drm_crtc_vblank_send_event on the event member of
* &drm_crtc_state). * &drm_crtc_state).
@ -1509,7 +1517,7 @@ static struct drm_crtc_commit *preceeding_commit(struct drm_crtc *crtc)
* This is part of the atomic helper support for nonblocking commits, see * This is part of the atomic helper support for nonblocking commits, see
* drm_atomic_helper_setup_commit() for an overview. * drm_atomic_helper_setup_commit() for an overview.
*/ */
void drm_atomic_helper_wait_for_dependencies(struct drm_atomic_state *state) void drm_atomic_helper_wait_for_dependencies(struct drm_atomic_state *old_state)
{ {
struct drm_crtc *crtc; struct drm_crtc *crtc;
struct drm_crtc_state *crtc_state; struct drm_crtc_state *crtc_state;
@ -1517,7 +1525,7 @@ void drm_atomic_helper_wait_for_dependencies(struct drm_atomic_state *state)
int i; int i;
long ret; long ret;
for_each_crtc_in_state(state, crtc, crtc_state, i) { for_each_crtc_in_state(old_state, crtc, crtc_state, i) {
spin_lock(&crtc->commit_lock); spin_lock(&crtc->commit_lock);
commit = preceeding_commit(crtc); commit = preceeding_commit(crtc);
if (commit) if (commit)
@ -1548,7 +1556,7 @@ EXPORT_SYMBOL(drm_atomic_helper_wait_for_dependencies);
/** /**
* drm_atomic_helper_commit_hw_done - setup possible nonblocking commit * drm_atomic_helper_commit_hw_done - setup possible nonblocking commit
* @state: new modeset state to be committed * @old_state: atomic state object with old state structures
* *
* This function is used to signal completion of the hardware commit step. After * This function is used to signal completion of the hardware commit step. After
* this step the driver is not allowed to read or change any permanent software * this step the driver is not allowed to read or change any permanent software
@ -1561,15 +1569,15 @@ EXPORT_SYMBOL(drm_atomic_helper_wait_for_dependencies);
* This is part of the atomic helper support for nonblocking commits, see * This is part of the atomic helper support for nonblocking commits, see
* drm_atomic_helper_setup_commit() for an overview. * drm_atomic_helper_setup_commit() for an overview.
*/ */
void drm_atomic_helper_commit_hw_done(struct drm_atomic_state *state) void drm_atomic_helper_commit_hw_done(struct drm_atomic_state *old_state)
{ {
struct drm_crtc *crtc; struct drm_crtc *crtc;
struct drm_crtc_state *crtc_state; struct drm_crtc_state *crtc_state;
struct drm_crtc_commit *commit; struct drm_crtc_commit *commit;
int i; int i;
for_each_crtc_in_state(state, crtc, crtc_state, i) { for_each_crtc_in_state(old_state, crtc, crtc_state, i) {
commit = state->crtcs[i].commit; commit = old_state->crtcs[i].commit;
if (!commit) if (!commit)
continue; continue;
@ -1584,16 +1592,16 @@ EXPORT_SYMBOL(drm_atomic_helper_commit_hw_done);
/** /**
* drm_atomic_helper_commit_cleanup_done - signal completion of commit * drm_atomic_helper_commit_cleanup_done - signal completion of commit
* @state: new modeset state to be committed * @old_state: atomic state object with old state structures
* *
* This signals completion of the atomic update @state, including any cleanup * This signals completion of the atomic update @old_state, including any
* work. If used, it must be called right before calling * cleanup work. If used, it must be called right before calling
* drm_atomic_state_put(). * drm_atomic_state_put().
* *
* This is part of the atomic helper support for nonblocking commits, see * This is part of the atomic helper support for nonblocking commits, see
* drm_atomic_helper_setup_commit() for an overview. * drm_atomic_helper_setup_commit() for an overview.
*/ */
void drm_atomic_helper_commit_cleanup_done(struct drm_atomic_state *state) void drm_atomic_helper_commit_cleanup_done(struct drm_atomic_state *old_state)
{ {
struct drm_crtc *crtc; struct drm_crtc *crtc;
struct drm_crtc_state *crtc_state; struct drm_crtc_state *crtc_state;
@ -1601,8 +1609,8 @@ void drm_atomic_helper_commit_cleanup_done(struct drm_atomic_state *state)
int i; int i;
long ret; long ret;
for_each_crtc_in_state(state, crtc, crtc_state, i) { for_each_crtc_in_state(old_state, crtc, crtc_state, i) {
commit = state->crtcs[i].commit; commit = old_state->crtcs[i].commit;
if (WARN_ON(!commit)) if (WARN_ON(!commit))
continue; continue;

12
include/drm/drm_modeset_helper_vtables.h
View file

@ -999,10 +999,14 @@ struct drm_mode_config_helper_funcs {
* to implement blocking and nonblocking commits easily. It is not used * to implement blocking and nonblocking commits easily. It is not used
* by the atomic helpers * by the atomic helpers
* *
* This hook should first commit the given atomic state to the hardware. * This function is called when the new atomic state has already been
* But drivers can add more waiting calls at the start of their * swapped into the various state pointers. The passed in state
* implementation, e.g. to wait for driver-internal request for implicit * therefore contains copies of the old/previous state. This hook should
* syncing, before starting to commit the update to the hardware. * commit the new state into hardware. Note that the helpers have
* already waited for preceeding atomic commits and fences, but drivers
* can add more waiting calls at the start of their implementation, e.g.
* to wait for driver-internal request for implicit syncing, before
* starting to commit the update to the hardware.
* *
* After the atomic update is committed to the hardware this hook needs * After the atomic update is committed to the hardware this hook needs
* to call drm_atomic_helper_commit_hw_done(). Then wait for the upate * to call drm_atomic_helper_commit_hw_done(). Then wait for the upate