Gustavo Padovan gustavo@padovan.org writes:

From: Gustavo Padovan gustavo.padovan@collabora.com

In some cases, like cursor updates, it is interesting to update the plane in an asynchronous fashion to avoid big delays. The current queued update could be still waiting for a fence to signal and thus block any subsequent update until its scan out. In cases like this if we update the cursor synchronously through the atomic API it will cause significant delays that would even be noticed by the final user.

This patch creates a fast path to jump ahead the current queued state and do single planes updates without going through all atomic steps in drm_atomic_helper_commit(). We take this path for legacy cursor updates.

For now only single plane updates are supported, but we plan to support multiple planes updates and async PageFlips through this interface as well in the near future.

Sorry for taking so long to do some review for this.

---

drivers/gpu/drm/drm_atomic.c | 65 ++++++++++++++++++++++++++++++++ drivers/gpu/drm/drm_atomic_helper.c | 35 +++++++++++++++++ include/drm/drm_atomic.h | 2 + include/drm/drm_atomic_helper.h | 2 + include/drm/drm_modeset_helper_vtables.h | 48 +++++++++++++++++++++++ 5 files changed, 152 insertions(+)

diff --git a/drivers/gpu/drm/drm_atomic.c b/drivers/gpu/drm/drm_atomic.c index be62774..2a0c297 100644 --- a/drivers/gpu/drm/drm_atomic.c +++ b/drivers/gpu/drm/drm_atomic.c @@ -631,6 +631,68 @@ static int drm_atomic_crtc_check(struct drm_crtc *crtc, return 0; }

+static bool drm_atomic_async_check(struct drm_atomic_state *state) +{

• struct drm_crtc *crtc;
• struct drm_crtc_state *crtc_state;
• struct drm_crtc_commit *commit;
• struct drm_plane *__plane, *plane = NULL;
• struct drm_plane_state *__plane_state, *plane_state = NULL;
• const struct drm_plane_helper_funcs *funcs;
• int i, j, n_planes = 0;
• for_each_new_crtc_in_state(state, crtc, crtc_state, i) {

• if (drm_atomic_crtc_needs_modeset(crtc_state))
  

• 	return false;
  

• }
• for_each_new_plane_in_state(state, __plane, __plane_state, i) {

• n_planes++;
  

• plane = __plane;
  

• plane_state = __plane_state;
  

• }
• /* FIXME: we support only single plane updates for now */
• if (!plane || n_planes != 1)

• return false;
  

• if (!plane_state->crtc)

• return false;
  

• funcs = plane->helper_private;
• if (!funcs->atomic_async_update)

• return false;
  

• if (plane_state->fence)

• return false;
  

Could you add a comment here like:

/* Don't do an async update if there is an outstanding commit modifying * the plane. This prevents our async update's changes from getting * overridden by a previous synchronous update's state. */

(assuming I understand its intent correctly)

I don't understand KMS locking enough to say if this loop is actually safely guaranteeing that. If you're convinced of that, then with my little cleanups this patch will be:

Acked-by: Eric Anholt eric@anholt.net

• for_each_new_crtc_in_state(state, crtc, crtc_state, i) {

• if (plane->crtc != crtc)
  

• 	continue;
  

• spin_lock(&crtc->commit_lock);
  

• commit = list_first_entry_or_null(&crtc->commit_list,
  

• 				  struct drm_crtc_commit,
  

• 				  commit_entry);
  

• if (!commit) {
  

• 	spin_unlock(&crtc->commit_lock);
  

• 	continue;
  

• }
  

• spin_unlock(&crtc->commit_lock);
  

• if (!crtc->state->state)
  

• 	continue;
  

• for_each_plane_in_state(crtc->state->state, __plane,
  

• 			__plane_state, j) {
  

• 	if (__plane == plane)
  

• 		return false;
  

• }
  

• }
• return !funcs->atomic_async_check(plane, plane_state);

+}

static void drm_atomic_crtc_print_state(struct drm_printer *p, const struct drm_crtc_state *state) { @@ -1591,6 +1653,9 @@ int drm_atomic_check_only(struct drm_atomic_state *state) } }

• if (state->legacy_cursor_update)

• state->async_update = drm_atomic_async_check(state);
  

• return ret;

} EXPORT_SYMBOL(drm_atomic_check_only); diff --git a/drivers/gpu/drm/drm_atomic_helper.c b/drivers/gpu/drm/drm_atomic_helper.c index 5a3c9c0..a8efdfe 100644 --- a/drivers/gpu/drm/drm_atomic_helper.c +++ b/drivers/gpu/drm/drm_atomic_helper.c @@ -1235,6 +1235,30 @@ static void commit_work(struct work_struct *work) }

/**

• • drm_atomic_helper_async_commit - commit state asynchronously
• • This function commits a state asynchronously, i.e., not vblank
• • synchronized. It should be used on a state only when
• • 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.
• */

+void drm_atomic_helper_async_commit(struct drm_device *dev,

• 		    struct drm_atomic_state *state)
  

+{

• struct drm_plane *plane;
• struct drm_plane_state *plane_state;
• const struct drm_plane_helper_funcs *funcs;
• int i;
• for_each_new_plane_in_state(state, plane, plane_state, i) {

• funcs = plane->helper_private;
  

• funcs->atomic_async_update(plane, plane_state);
  

• }

+} +EXPORT_SYMBOL(drm_atomic_helper_async_commit);

+/**

• drm_atomic_helper_commit - commit validated state object
• @dev: DRM device
• @state: the driver state object

@@ -1258,6 +1282,17 @@ int drm_atomic_helper_commit(struct drm_device *dev, { int ret;

• if (state->async_update) {

• ret = drm_atomic_helper_prepare_planes(dev, state);
  

• if (ret)
  

• 	return ret;
  

• drm_atomic_helper_async_commit(dev, state);
  

• drm_atomic_helper_cleanup_planes(dev, state);
  

• return 0;
  

• }
• ret = drm_atomic_helper_setup_commit(state, nonblock); if (ret) return ret;

diff --git a/include/drm/drm_atomic.h b/include/drm/drm_atomic.h index 788daf7..70ca279 100644 --- a/include/drm/drm_atomic.h +++ b/include/drm/drm_atomic.h @@ -160,6 +160,7 @@ struct __drm_connnectors_state {

• @dev: parent DRM device
• @allow_modeset: allow full modeset
• @legacy_cursor_update: hint to enforce legacy cursor IOCTL semantics

• • @async_update: hint for asynchronous plane update
  • @planes: pointer to array of structures with per-plane data
  • @crtcs: pointer to array of CRTC pointers
  • @num_connector: size of the @connectors and @connector_states arrays

@@ -172,6 +173,7 @@ struct drm_atomic_state { struct drm_device *dev; bool allow_modeset : 1; bool legacy_cursor_update : 1;

• bool async_update : 1; struct __drm_planes_state *planes; struct __drm_crtcs_state *crtcs; int num_connector;

diff --git a/include/drm/drm_atomic_helper.h b/include/drm/drm_atomic_helper.h index f0a8678..8571b51 100644 --- a/include/drm/drm_atomic_helper.h +++ b/include/drm/drm_atomic_helper.h @@ -44,6 +44,8 @@ void drm_atomic_helper_commit_tail(struct drm_atomic_state *state); int drm_atomic_helper_commit(struct drm_device *dev, struct drm_atomic_state *state, bool nonblock); +void drm_atomic_helper_async_commit(struct drm_device *dev,

• 		    struct drm_atomic_state *state);
  
  

int drm_atomic_helper_wait_for_fences(struct drm_device *dev, struct drm_atomic_state *state, diff --git a/include/drm/drm_modeset_helper_vtables.h b/include/drm/drm_modeset_helper_vtables.h index c01c328..7964a78 100644 --- a/include/drm/drm_modeset_helper_vtables.h +++ b/include/drm/drm_modeset_helper_vtables.h @@ -1048,6 +1048,54 @@ struct drm_plane_helper_funcs { */ void (*atomic_disable)(struct drm_plane *plane, struct drm_plane_state *old_state);

• /**

• * @atomic_async_check:
  

• *
  

• * Drivers should set this function pointer to check if the plane state
  

• * can be updated in a async fashion. Here async means "not vblank
  

• * synchronized".
  

• *
  

• * This hook is called by drm_atomic_async_check() to establish if a
  

• * given update can be committed asynchronously, that is, if it can
  

• * jump ahead the state currently queued for update.
  

• *
  

• * RETURNS:
  

• *
  

• * Return 0 on success and any error returned indicates that the update
  

• * can not be applied in asynchronous manner.
  

• */
  

• int (*atomic_async_check)(struct drm_plane *plane,

• 		  struct drm_plane_state *state);
  

• /**

• * @atomic_async_update:
  

• *
  

• * Drivers should set this function pointer to perform asynchronous
  

• * updates of planes, that is, jump ahead the currently queued
  

"jump ahead of the"

• * state for and update the plane. Here async means "not vblank
  

s/for //

• * synchronized".
  

• *
  

• * This hook is called by drm_atomic_helper_async_commit().
  

• *
  

• * An async update will happen on legacy cursor updates.
  

• *
  

• * Note that unlike &drm_plane_helper_funcs.atomic_update this hook
  

• * takes the new &drm_plane_state as parameter. When doing async_update
  

• * drivers shouldn't replace the &drm_plane_state but update the
  

• * current one with the new plane configurations in the new
  

• * plane_state.
  

Also maybe document that this won't be called if there is an outstanding commit modifying the plane?

• *
  

• * FIXME:
  

• *  - It only works for single plane updates
  

• *  - Async Pageflips are not supported yet
  

• *  - Some hm might still scan out the old buffer until the next
  

"Some hw"?

• *  vblank, however we let go of the fb references as soon as
  

• *  we run this hook. For now drivers must implement their own workers
  

• *  for defering if needed, until a common solution is created.
  

• */
  

"deferring"

• void (*atomic_async_update)(struct drm_plane *plane,

• 		    struct drm_plane_state *new_state);
  

Is there a simple list of what parts of drm_plane_state may change in this hook? I noticed that vc4 wasn't checking that the format doesn't change, for example. I'm also not sure if we're guaranteed that the plane-is-enabled state isn't changing, either.

If it's "everything", we'll need to improve the vc4 async check before we expose this under anything but the cursor ioctl.

2017-06-01 Gustavo Padovan gustavo@padovan.org:

2017-05-31 Eric Anholt eric@anholt.net:

...

Gustavo Padovan gustavo@padovan.org writes:

...

From: Gustavo Padovan gustavo.padovan@collabora.com

In some cases, like cursor updates, it is interesting to update the plane in an asynchronous fashion to avoid big delays. The current queued update could be still waiting for a fence to signal and thus block any subsequent update until its scan out. In cases like this if we update the cursor synchronously through the atomic API it will cause significant delays that would even be noticed by the final user.

This patch creates a fast path to jump ahead the current queued state and do single planes updates without going through all atomic steps in drm_atomic_helper_commit(). We take this path for legacy cursor updates.

For now only single plane updates are supported, but we plan to support multiple planes updates and async PageFlips through this interface as well in the near future.

Sorry for taking so long to do some review for this.

...

---

drivers/gpu/drm/drm_atomic.c | 65 ++++++++++++++++++++++++++++++++ drivers/gpu/drm/drm_atomic_helper.c | 35 +++++++++++++++++ include/drm/drm_atomic.h | 2 + include/drm/drm_atomic_helper.h | 2 + include/drm/drm_modeset_helper_vtables.h | 48 +++++++++++++++++++++++ 5 files changed, 152 insertions(+)

diff --git a/drivers/gpu/drm/drm_atomic.c b/drivers/gpu/drm/drm_atomic.c index be62774..2a0c297 100644 --- a/drivers/gpu/drm/drm_atomic.c +++ b/drivers/gpu/drm/drm_atomic.c @@ -631,6 +631,68 @@ static int drm_atomic_crtc_check(struct drm_crtc *crtc, return 0; }

+static bool drm_atomic_async_check(struct drm_atomic_state *state) +{

• struct drm_crtc *crtc;
• struct drm_crtc_state *crtc_state;
• struct drm_crtc_commit *commit;
• struct drm_plane *__plane, *plane = NULL;
• struct drm_plane_state *__plane_state, *plane_state = NULL;
• const struct drm_plane_helper_funcs *funcs;
• int i, j, n_planes = 0;
• for_each_new_crtc_in_state(state, crtc, crtc_state, i) {

• if (drm_atomic_crtc_needs_modeset(crtc_state))
  

• 	return false;
  

• }
• for_each_new_plane_in_state(state, __plane, __plane_state, i) {

• n_planes++;
  

• plane = __plane;
  

• plane_state = __plane_state;
  

• }
• /* FIXME: we support only single plane updates for now */
• if (!plane || n_planes != 1)

• return false;
  

• if (!plane_state->crtc)

• return false;
  

• funcs = plane->helper_private;
• if (!funcs->atomic_async_update)

• return false;
  

• if (plane_state->fence)

• return false;
  

Could you add a comment here like:

/* Don't do an async update if there is an outstanding commit modifying

• the plane. This prevents our async update's changes from getting
• overridden by a previous synchronous update's state.

*/

(assuming I understand its intent correctly)

I don't understand KMS locking enough to say if this loop is actually safely guaranteeing that. If you're convinced of that, then with my little cleanups this patch will be:

I'm going to check the locking again just to make sure.

...

Acked-by: Eric Anholt eric@anholt.net

...

• for_each_new_crtc_in_state(state, crtc, crtc_state, i) {

• if (plane->crtc != crtc)
  

• 	continue;
  

• spin_lock(&crtc->commit_lock);
  

• commit = list_first_entry_or_null(&crtc->commit_list,
  

• 				  struct drm_crtc_commit,
  

• 				  commit_entry);
  

• if (!commit) {
  

• 	spin_unlock(&crtc->commit_lock);
  

• 	continue;
  

• }
  

• spin_unlock(&crtc->commit_lock);
  

• if (!crtc->state->state)
  

• 	continue;
  

• for_each_plane_in_state(crtc->state->state, __plane,
  

• 			__plane_state, j) {
  

• 	if (__plane == plane)
  

• 		return false;
  

• }
  

• }
• return !funcs->atomic_async_check(plane, plane_state);

+}

static void drm_atomic_crtc_print_state(struct drm_printer *p, const struct drm_crtc_state *state) { @@ -1591,6 +1653,9 @@ int drm_atomic_check_only(struct drm_atomic_state *state) } }

• if (state->legacy_cursor_update)

• state->async_update = drm_atomic_async_check(state);
  

• return ret;

} EXPORT_SYMBOL(drm_atomic_check_only); diff --git a/drivers/gpu/drm/drm_atomic_helper.c b/drivers/gpu/drm/drm_atomic_helper.c index 5a3c9c0..a8efdfe 100644 --- a/drivers/gpu/drm/drm_atomic_helper.c +++ b/drivers/gpu/drm/drm_atomic_helper.c @@ -1235,6 +1235,30 @@ static void commit_work(struct work_struct *work) }

/**

• • drm_atomic_helper_async_commit - commit state asynchronously
• • This function commits a state asynchronously, i.e., not vblank
• • synchronized. It should be used on a state only when
• • 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.
• */

+void drm_atomic_helper_async_commit(struct drm_device *dev,

• 		    struct drm_atomic_state *state)
  

+{

• struct drm_plane *plane;
• struct drm_plane_state *plane_state;
• const struct drm_plane_helper_funcs *funcs;
• int i;
• for_each_new_plane_in_state(state, plane, plane_state, i) {

• funcs = plane->helper_private;
  

• funcs->atomic_async_update(plane, plane_state);
  

• }

+} +EXPORT_SYMBOL(drm_atomic_helper_async_commit);

+/**

• drm_atomic_helper_commit - commit validated state object
• @dev: DRM device
• @state: the driver state object

@@ -1258,6 +1282,17 @@ int drm_atomic_helper_commit(struct drm_device *dev, { int ret;

• if (state->async_update) {

• ret = drm_atomic_helper_prepare_planes(dev, state);
  

• if (ret)
  

• 	return ret;
  

• drm_atomic_helper_async_commit(dev, state);
  

• drm_atomic_helper_cleanup_planes(dev, state);
  

• return 0;
  

• }
• ret = drm_atomic_helper_setup_commit(state, nonblock); if (ret) return ret;

diff --git a/include/drm/drm_atomic.h b/include/drm/drm_atomic.h index 788daf7..70ca279 100644 --- a/include/drm/drm_atomic.h +++ b/include/drm/drm_atomic.h @@ -160,6 +160,7 @@ struct __drm_connnectors_state {

• @dev: parent DRM device
• @allow_modeset: allow full modeset
• @legacy_cursor_update: hint to enforce legacy cursor IOCTL semantics

• • @async_update: hint for asynchronous plane update
  • @planes: pointer to array of structures with per-plane data
  • @crtcs: pointer to array of CRTC pointers
  • @num_connector: size of the @connectors and @connector_states arrays

@@ -172,6 +173,7 @@ struct drm_atomic_state { struct drm_device *dev; bool allow_modeset : 1; bool legacy_cursor_update : 1;

• bool async_update : 1; struct __drm_planes_state *planes; struct __drm_crtcs_state *crtcs; int num_connector;

diff --git a/include/drm/drm_atomic_helper.h b/include/drm/drm_atomic_helper.h index f0a8678..8571b51 100644 --- a/include/drm/drm_atomic_helper.h +++ b/include/drm/drm_atomic_helper.h @@ -44,6 +44,8 @@ void drm_atomic_helper_commit_tail(struct drm_atomic_state *state); int drm_atomic_helper_commit(struct drm_device *dev, struct drm_atomic_state *state, bool nonblock); +void drm_atomic_helper_async_commit(struct drm_device *dev,

• 		    struct drm_atomic_state *state);
  
  

int drm_atomic_helper_wait_for_fences(struct drm_device *dev, struct drm_atomic_state *state, diff --git a/include/drm/drm_modeset_helper_vtables.h b/include/drm/drm_modeset_helper_vtables.h index c01c328..7964a78 100644 --- a/include/drm/drm_modeset_helper_vtables.h +++ b/include/drm/drm_modeset_helper_vtables.h @@ -1048,6 +1048,54 @@ struct drm_plane_helper_funcs { */ void (*atomic_disable)(struct drm_plane *plane, struct drm_plane_state *old_state);

• /**

• * @atomic_async_check:
  

• *
  

• * Drivers should set this function pointer to check if the plane state
  

• * can be updated in a async fashion. Here async means "not vblank
  

• * synchronized".
  

• *
  

• * This hook is called by drm_atomic_async_check() to establish if a
  

• * given update can be committed asynchronously, that is, if it can
  

• * jump ahead the state currently queued for update.
  

• *
  

• * RETURNS:
  

• *
  

• * Return 0 on success and any error returned indicates that the update
  

• * can not be applied in asynchronous manner.
  

• */
  

• int (*atomic_async_check)(struct drm_plane *plane,

• 		  struct drm_plane_state *state);
  

• /**

• * @atomic_async_update:
  

• *
  

• * Drivers should set this function pointer to perform asynchronous
  

• * updates of planes, that is, jump ahead the currently queued
  

"jump ahead of the"

...

• * state for and update the plane. Here async means "not vblank
  

s/for //

...

• * synchronized".
  

• *
  

• * This hook is called by drm_atomic_helper_async_commit().
  

• *
  

• * An async update will happen on legacy cursor updates.
  

• *
  

• * Note that unlike &drm_plane_helper_funcs.atomic_update this hook
  

• * takes the new &drm_plane_state as parameter. When doing async_update
  

• * drivers shouldn't replace the &drm_plane_state but update the
  

• * current one with the new plane configurations in the new
  

• * plane_state.
  

Also maybe document that this won't be called if there is an outstanding commit modifying the plane?

...

• *
  

• * FIXME:
  

• *  - It only works for single plane updates
  

• *  - Async Pageflips are not supported yet
  

• *  - Some hm might still scan out the old buffer until the next
  

"Some hw"?

...

• *  vblank, however we let go of the fb references as soon as
  

• *  we run this hook. For now drivers must implement their own workers
  

• *  for defering if needed, until a common solution is created.
  

• */
  

"deferring"

...

• void (*atomic_async_update)(struct drm_plane *plane,

• 		    struct drm_plane_state *new_state);
  

Is there a simple list of what parts of drm_plane_state may change in this hook? I noticed that vc4 wasn't checking that the format doesn't change, for example. I'm also not sure if we're guaranteed that the plane-is-enabled state isn't changing, either.

I can look into building such a list. I'll do that and send a proposed one here.

The list of things that may change on this hook really depends on the driver, so I believe we need to improve the vc4 async check before enabling it through the atomic ioctl.

...

If it's "everything", we'll need to improve the vc4 async check before we expose this under anything but the cursor ioctl.

Gustavo

On 05/26/2017 01:21 AM, Gustavo Padovan wrote:

From: Gustavo Padovan gustavo.padovan@collabora.com

Add support to async updates of cursors by using the new atomic interface for that. Basically what this commit does is do what mdp5_update_cursor_plane_legacy() did but through atomic.

Tested-by: Archit Taneja architt@codeaurora.org

v4: add missing atomic async commit call to msm_atomic_commit(Archit Taneja)

v3: move size checks back to drivers (Ville Syrjälä)

v2: move fb setting to core and use new state (Eric Anholt)

Cc: Rob Clark robdclark@gmail.com Cc: Archit Taneja architt@codeaurora.org Signed-off-by: Gustavo Padovan gustavo.padovan@collabora.com

---

drivers/gpu/drm/msm/mdp/mdp5/mdp5_plane.c | 151 +++++++++++++----------------- drivers/gpu/drm/msm/msm_atomic.c | 6 ++ 2 files changed, 69 insertions(+), 88 deletions(-)

diff --git a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_plane.c b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_plane.c index a38c5fe..07106c1 100644 --- a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_plane.c +++ b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_plane.c @@ -33,15 +33,6 @@ static int mdp5_plane_mode_set(struct drm_plane *plane, struct drm_crtc *crtc, struct drm_framebuffer *fb, struct drm_rect *src, struct drm_rect *dest);

-static int mdp5_update_cursor_plane_legacy(struct drm_plane *plane,

• struct drm_crtc *crtc,
  

• struct drm_framebuffer *fb,
  

• int crtc_x, int crtc_y,
  

• unsigned int crtc_w, unsigned int crtc_h,
  

• uint32_t src_x, uint32_t src_y,
  

• uint32_t src_w, uint32_t src_h,
  

• struct drm_modeset_acquire_ctx *ctx);
  

static struct mdp5_kms *get_kms(struct drm_plane *plane) { struct msm_drm_private *priv = plane->dev->dev_private; @@ -257,7 +248,7 @@ static const struct drm_plane_funcs mdp5_plane_funcs = { };

static const struct drm_plane_funcs mdp5_cursor_plane_funcs = {

• .update_plane = mdp5_update_cursor_plane_legacy,
  

• .update_plane = drm_atomic_helper_update_plane,
  

  .disable_plane = drm_atomic_helper_disable_plane, .destroy = mdp5_plane_destroy, .set_property = drm_atomic_helper_plane_set_property,

@@ -484,11 +475,73 @@ static void mdp5_plane_atomic_update(struct drm_plane *plane, } }

+static int mdp5_plane_atomic_async_check(struct drm_plane *plane,

• 			 struct drm_plane_state *state)
  

+{

• struct mdp5_plane_state *mdp5_state = to_mdp5_plane_state(state);
• struct drm_crtc_state *crtc_state;
• crtc_state = drm_atomic_get_existing_crtc_state(state->state,

• 					state->crtc);
  

• if (WARN_ON(!crtc_state))

• return -EINVAL;
  

• if (!crtc_state->active)

• return -EINVAL;
  

• mdp5_state = to_mdp5_plane_state(state);
• /* don't use fast path if we don't have a hwpipe allocated yet */
• if (!mdp5_state->hwpipe)

• return -EINVAL;
  

• /* only allow changing of position(crtc x/y or src x/y) in fast path */
• if (plane->state->crtc != state->crtc ||

•    plane->state->src_w != state->src_w ||
  

•    plane->state->src_h != state->src_h ||
  

•    plane->state->crtc_w != state->crtc_w ||
  

•    plane->state->crtc_h != state->crtc_h ||
  

•    !plane->state->fb ||
  

•    plane->state->fb != state->fb)
  

• return -EINVAL;
  

• return 0;

+}

+static void mdp5_plane_atomic_async_update(struct drm_plane *plane,

• 			   struct drm_plane_state *new_state)
  

+{

• plane->state->src_x = new_state->src_x;
• plane->state->src_y = new_state->src_y;
• plane->state->crtc_x = new_state->crtc_x;
• plane->state->crtc_y = new_state->crtc_y;
• if (plane_enabled(new_state)) {

• struct mdp5_ctl *ctl;
  

• struct mdp5_pipeline *pipeline =
  

• 			mdp5_crtc_get_pipeline(plane->crtc);
  

• int ret;
  

• ret = mdp5_plane_mode_set(plane, new_state->crtc, new_state->fb,
  

• 		&new_state->src, &new_state->dst);
  

• WARN_ON(ret < 0);
  

• ctl = mdp5_crtc_get_ctl(new_state->crtc);
  

• mdp5_ctl_commit(ctl, pipeline, mdp5_plane_get_flush(plane));
  

• }
• *to_mdp5_plane_state(plane->state) =

• *to_mdp5_plane_state(new_state);
  

+}

static const struct drm_plane_helper_funcs mdp5_plane_helper_funcs = { .prepare_fb = mdp5_plane_prepare_fb, .cleanup_fb = mdp5_plane_cleanup_fb, .atomic_check = mdp5_plane_atomic_check, .atomic_update = mdp5_plane_atomic_update,

• .atomic_async_check = mdp5_plane_atomic_async_check,
  

• .atomic_async_update = mdp5_plane_atomic_async_update,
  

};

static void set_scanout_locked(struct mdp5_kms *mdp5_kms, @@ -997,84 +1050,6 @@ static int mdp5_plane_mode_set(struct drm_plane *plane, return ret; }

-static int mdp5_update_cursor_plane_legacy(struct drm_plane *plane,

• 	struct drm_crtc *crtc, struct drm_framebuffer *fb,
  

• 	int crtc_x, int crtc_y,
  

• 	unsigned int crtc_w, unsigned int crtc_h,
  

• 	uint32_t src_x, uint32_t src_y,
  

• 	uint32_t src_w, uint32_t src_h,
  

• 	struct drm_modeset_acquire_ctx *ctx)
  

-{

• struct drm_plane_state *plane_state, *new_plane_state;
• struct mdp5_plane_state *mdp5_pstate;
• struct drm_crtc_state *crtc_state = crtc->state;
• int ret;
• if (!crtc_state->active || drm_atomic_crtc_needs_modeset(crtc_state))

• goto slow;
  

• plane_state = plane->state;
• mdp5_pstate = to_mdp5_plane_state(plane_state);
• /* don't use fast path if we don't have a hwpipe allocated yet */
• if (!mdp5_pstate->hwpipe)

• goto slow;
  

• /* only allow changing of position(crtc x/y or src x/y) in fast path */
• if (plane_state->crtc != crtc ||

•    plane_state->src_w != src_w ||
  

•    plane_state->src_h != src_h ||
  

•    plane_state->crtc_w != crtc_w ||
  

•    plane_state->crtc_h != crtc_h ||
  

•    !plane_state->fb ||
  

•    plane_state->fb != fb)
  

• goto slow;
  

• new_plane_state = mdp5_plane_duplicate_state(plane);
• if (!new_plane_state)

• return -ENOMEM;
  

• new_plane_state->src_x = src_x;
• new_plane_state->src_y = src_y;
• new_plane_state->src_w = src_w;
• new_plane_state->src_h = src_h;
• new_plane_state->crtc_x = crtc_x;
• new_plane_state->crtc_y = crtc_y;
• new_plane_state->crtc_w = crtc_w;
• new_plane_state->crtc_h = crtc_h;
• ret = mdp5_plane_atomic_check_with_state(crtc_state, new_plane_state);
• if (ret)

• goto slow_free;
  

• if (new_plane_state->visible) {

• struct mdp5_ctl *ctl;
  

• struct mdp5_pipeline *pipeline = mdp5_crtc_get_pipeline(crtc);
  

• ret = mdp5_plane_mode_set(plane, crtc, fb,
  

• 			  &new_plane_state->src,
  

• 			  &new_plane_state->dst);
  

• WARN_ON(ret < 0);
  

• ctl = mdp5_crtc_get_ctl(crtc);
  

• mdp5_ctl_commit(ctl, pipeline, mdp5_plane_get_flush(plane));
  

• }
• *to_mdp5_plane_state(plane_state) =

• *to_mdp5_plane_state(new_plane_state);
  

• mdp5_plane_destroy_state(plane, new_plane_state);
• return 0;

-slow_free:

• mdp5_plane_destroy_state(plane, new_plane_state);

-slow:

• return drm_atomic_helper_update_plane(plane, crtc, fb,

• 			      crtc_x, crtc_y, crtc_w, crtc_h,
  

• 			      src_x, src_y, src_w, src_h, ctx);
  

-}

/*

• Use this func and the one below only after the atomic state has been
• successfully swapped

diff --git a/drivers/gpu/drm/msm/msm_atomic.c b/drivers/gpu/drm/msm/msm_atomic.c index 9633a68b..0104311 100644 --- a/drivers/gpu/drm/msm/msm_atomic.c +++ b/drivers/gpu/drm/msm/msm_atomic.c @@ -202,6 +202,12 @@ int msm_atomic_commit(struct drm_device *dev, if (ret) return ret;

• if (state->async_update) {

• drm_atomic_helper_async_commit(dev, state);
  

• drm_atomic_helper_cleanup_planes(dev, state);
  

• return 0;
  

• }
• c = commit_init(state); if (!c) { ret = -ENOMEM;

On 05/26/2017 01:21 AM, Gustavo Padovan wrote:

From: Gustavo Padovan gustavo.padovan@collabora.com

After converting legacy cursor updates to atomic async commits mdp5_cursor_plane_funcs just duplicates mdp5_plane_funcs now.

Tested-by: Archit Taneja architt@codeaurora.org

Cc: Rob Clark robdclark@gmail.com Cc: Archit Taneja architt@codeaurora.org Signed-off-by: Gustavo Padovan gustavo.padovan@collabora.com

---

drivers/gpu/drm/msm/mdp/mdp5/mdp5_plane.c | 26 +++----------------------- 1 file changed, 3 insertions(+), 23 deletions(-)

diff --git a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_plane.c b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_plane.c index 07106c1..794ca07 100644 --- a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_plane.c +++ b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_plane.c @@ -247,19 +247,6 @@ static const struct drm_plane_funcs mdp5_plane_funcs = { .atomic_print_state = mdp5_plane_atomic_print_state, };

-static const struct drm_plane_funcs mdp5_cursor_plane_funcs = {

• .update_plane = drm_atomic_helper_update_plane,
  

• .disable_plane = drm_atomic_helper_disable_plane,
  

• .destroy = mdp5_plane_destroy,
  

• .set_property = drm_atomic_helper_plane_set_property,
  

• .atomic_set_property = mdp5_plane_atomic_set_property,
  

• .atomic_get_property = mdp5_plane_atomic_get_property,
  

• .reset = mdp5_plane_reset,
  

• .atomic_duplicate_state = mdp5_plane_duplicate_state,
  

• .atomic_destroy_state = mdp5_plane_destroy_state,
  

• .atomic_print_state = mdp5_plane_atomic_print_state,
  

-};

static int mdp5_plane_prepare_fb(struct drm_plane *plane, struct drm_plane_state *new_state) { @@ -1111,16 +1098,9 @@ struct drm_plane *mdp5_plane_init(struct drm_device *dev,

spin_lock_init(&mdp5_plane->pipe_lock);

• if (type == DRM_PLANE_TYPE_CURSOR)

• ret = drm_universal_plane_init(dev, plane, 0xff,
  

• 		&mdp5_cursor_plane_funcs,
  

• 		mdp5_plane->formats, mdp5_plane->nformats,
  

• 		type, NULL);
  

• else

• ret = drm_universal_plane_init(dev, plane, 0xff,
  

• 		&mdp5_plane_funcs,
  

• 		mdp5_plane->formats, mdp5_plane->nformats,
  

• 		type, NULL);
  

• ret = drm_universal_plane_init(dev, plane, 0xff, &mdp5_plane_funcs,

• 		       mdp5_plane->formats,
  

• 		       mdp5_plane->nformats, type, NULL);
  

  if (ret) goto fail;