drm/msm/mdp5: Add support for legacy cursor updates

This code has been more or less picked up from the vc4 and intel
implementations of update_plane() funcs for cursor planes.

The update_plane() func is usually the drm_atomic_helper_update_plane
func that will issue an atomic commit with the plane updates. Such
commits are not intended to be done faster than the vsync rate.

The legacy cursor userspace API, on the other hand, expects the kernel
to handle cursor updates immediately.

Create a fast path in update_plane, which updates the cursor registers
and flushes the configuration. The fast path is taken when there is only
a change in the cursor's position in the crtc, or a change in the
cursor's crop co-ordinates. For anything else, we go via the slow path.

We take the slow path even when the fb changes, and when there is
currently no fb tied to the plane. This should hopefully ensure that we
always take a slow path for every new fb. This in turn should ensure that
the fb is pinned/prepared.

Signed-off-by: Archit Taneja <architt@codeaurora.org>
Signed-off-by: Rob Clark <robdclark@gmail.com>

diff --git a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_crtc.c b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_crtc.c
index 84fcb6e3a1766a88481b8f22f8e3060dafbef0e2..d0c8b38b96ce53a54d3c9af6c68794f21deb7d29 100644 (file)
--- a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_crtc.c
+++ b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_crtc.c
@@ -778,6 +778,13 @@ void mdp5_crtc_set_pipeline(struct drm_crtc *crtc,
        mdp5_ctl_set_pipeline(ctl, intf, lm);
 }
 
+struct mdp5_ctl *mdp5_crtc_get_ctl(struct drm_crtc *crtc)
+{
+       struct mdp5_crtc *mdp5_crtc = to_mdp5_crtc(crtc);
+
+       return mdp5_crtc->ctl;
+}
+
 int mdp5_crtc_get_lm(struct drm_crtc *crtc)
 {
        struct mdp5_crtc *mdp5_crtc = to_mdp5_crtc(crtc);

diff --git a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_kms.h b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_kms.h
index 0396e8adb693fc6bbba2103508192adaad77cb45..9de471191ebaaa30ff7e169994c50f95a4ce84d6 100644 (file)
--- a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_kms.h
+++ b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_kms.h
@@ -246,6 +246,7 @@ enum mdp5_pipe mdp5_plane_pipe(struct drm_plane *plane);
 struct drm_plane *mdp5_plane_init(struct drm_device *dev,
                                  enum drm_plane_type type);
 
+struct mdp5_ctl *mdp5_crtc_get_ctl(struct drm_crtc *crtc);
 uint32_t mdp5_crtc_vblank(struct drm_crtc *crtc);
 
 int mdp5_crtc_get_lm(struct drm_crtc *crtc);

diff --git a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_plane.c b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_plane.c
index 504201b710d93006c3edfb45567fe8c6c0fb0d07..0ffb8affef35848b458b77ce145478e7a9638a2b 100644 (file)
--- a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_plane.c
+++ b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_plane.c
@@ -31,6 +31,14 @@ 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);
+
 static void set_scanout_locked(struct drm_plane *plane,
                struct drm_framebuffer *fb);
 
@@ -243,6 +251,19 @@ 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 = mdp5_update_cursor_plane_legacy,
+               .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)
 {
@@ -860,6 +881,82 @@ 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_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;
+
+               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, 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);
+}
+
 enum mdp5_pipe mdp5_plane_pipe(struct drm_plane *plane)
 {
        struct mdp5_plane_state *pstate = to_mdp5_plane_state(plane->state);
@@ -899,9 +996,16 @@ struct drm_plane *mdp5_plane_init(struct drm_device *dev,
        mdp5_plane->nformats = mdp_get_formats(mdp5_plane->formats,
                ARRAY_SIZE(mdp5_plane->formats), false);
 
-       ret = drm_universal_plane_init(dev, plane, 0xff, &mdp5_plane_funcs,
-                                mdp5_plane->formats, mdp5_plane->nformats,
-                                type, NULL);
+       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);
        if (ret)
                goto fail;