drm: rcar-du: Move plane allocator to rcar_du_plane.c

The plane allocator is specific to DU planes and won't be used for
VSP-based planes, move it with the rest of the DU planes code where it
belongs.

Signed-off-by: Laurent Pinchart <laurent.pinchart+renesas@ideasonboard.com>

3 files changed, 290 insertions, 275 deletions

diff --git a/drivers/gpu/drm/rcar-du/rcar_du_kms.c b/drivers/gpu/drm/rcar-du/rcar_du_kms.c
index a69d6075ceae..f5c00c0cd026 100644
--- a/drivers/gpu/drm/rcar-du/rcar_du_kms.c
+++ b/drivers/gpu/drm/rcar-du/rcar_du_kms.c
@@ -192,290 +192,16 @@ static void rcar_du_output_poll_changed(struct drm_device *dev)
  * Atomic Check and Update
  */
 
-/*
- * Atomic hardware plane allocator
- *
- * The hardware plane allocator is solely based on the atomic plane states
- * without keeping any external state to avoid races between .atomic_check()
- * and .atomic_commit().
- *
- * The core idea is to avoid using a free planes bitmask that would need to be
- * shared between check and commit handlers with a collective knowledge based on
- * the allocated hardware plane(s) for each KMS plane. The allocator then loops
- * over all plane states to compute the free planes bitmask, allocates hardware
- * planes based on that bitmask, and stores the result back in the plane states.
- *
- * For this to work we need to access the current state of planes not touched by
- * the atomic update. To ensure that it won't be modified, we need to lock all
- * planes using drm_atomic_get_plane_state(). This effectively serializes atomic
- * updates from .atomic_check() up to completion (when swapping the states if
- * the check step has succeeded) or rollback (when freeing the states if the
- * check step has failed).
- *
- * Allocation is performed in the .atomic_check() handler and applied
- * automatically when the core swaps the old and new states.
- */
-
-static bool rcar_du_plane_needs_realloc(struct rcar_du_plane *plane,
-                                        struct rcar_du_plane_state *new_state)
-{
-        struct rcar_du_plane_state *cur_state;
-
-        cur_state = to_rcar_plane_state(plane->plane.state);
-
-        /* Lowering the number of planes doesn't strictly require reallocation
-         * as the extra hardware plane will be freed when committing, but doing
-         * so could lead to more fragmentation.
-         */
-        if (!cur_state->format ||
-            cur_state->format->planes != new_state->format->planes)
-                return true;
-
-        /* Reallocate hardware planes if the source has changed. */
-        if (cur_state->source != new_state->source)
-                return true;
-
-        return false;
-}
-
-static unsigned int rcar_du_plane_hwmask(struct rcar_du_plane_state *state)
-{
-        unsigned int mask;
-
-        if (state->hwindex == -1)
-                return 0;
-
-        mask = 1 << state->hwindex;
-        if (state->format->planes == 2)
-                mask |= 1 << ((state->hwindex + 1) % 8);
-
-        return mask;
-}
-
-/*
- * The R8A7790 DU can source frames directly from the VSP1 devices VSPD0 and
- * VSPD1. VSPD0 feeds DU0/1 plane 0, and VSPD1 feeds either DU2 plane 0 or
- * DU0/1 plane 1.
- *
- * Allocate the correct fixed plane when sourcing frames from VSPD0 or VSPD1,
- * and allocate planes in reverse index order otherwise to ensure maximum
- * availability of planes 0 and 1.
- *
- * The caller is responsible for ensuring that the requested source is
- * compatible with the DU revision.
- */
-static int rcar_du_plane_hwalloc(struct rcar_du_plane *plane,
-                                 struct rcar_du_plane_state *state,
-                                 unsigned int free)
-{
-        unsigned int num_planes = state->format->planes;
-        int fixed = -1;
-        int i;
-
-        if (state->source == RCAR_DU_PLANE_VSPD0) {
-                /* VSPD0 feeds plane 0 on DU0/1. */
-                if (plane->group->index != 0)
-                        return -EINVAL;
-
-                fixed = 0;
-        } else if (state->source == RCAR_DU_PLANE_VSPD1) {
-                /* VSPD1 feeds plane 1 on DU0/1 or plane 0 on DU2. */
-                fixed = plane->group->index == 0 ? 1 : 0;
-        }
-
-        if (fixed >= 0)
-                return free & (1 << fixed) ? fixed : -EBUSY;
-
-        for (i = RCAR_DU_NUM_HW_PLANES - 1; i >= 0; --i) {
-                if (!(free & (1 << i)))
-                        continue;
-
-                if (num_planes == 1 || free & (1 << ((i + 1) % 8)))
-                        break;
-        }
-
-        return i < 0 ? -EBUSY : i;
-}
-
 static int rcar_du_atomic_check(struct drm_device *dev,
                                 struct drm_atomic_state *state)
 {
-        struct rcar_du_device *rcdu = dev->dev_private;
-        unsigned int group_freed_planes[RCAR_DU_MAX_GROUPS] = { 0, };
-        unsigned int group_free_planes[RCAR_DU_MAX_GROUPS] = { 0, };
-        bool needs_realloc = false;
-        unsigned int groups = 0;
-        unsigned int i;
         int ret;
 
         ret = drm_atomic_helper_check(dev, state);
         if (ret < 0)
                 return ret;
 
-        /* Check if hardware planes need to be reallocated. */
-        for (i = 0; i < dev->mode_config.num_total_plane; ++i) {
-                struct rcar_du_plane_state *plane_state;
-                struct rcar_du_plane *plane;
-                unsigned int index;
-
-                if (!state->planes[i])
-                        continue;
-
-                plane = to_rcar_plane(state->planes[i]);
-                plane_state = to_rcar_plane_state(state->plane_states[i]);
-
-                dev_dbg(rcdu->dev, "%s: checking plane (%u,%u)\n", __func__,
-                        plane->group->index, plane - plane->group->planes);
-
-                /* If the plane is being disabled we don't need to go through
-                 * the full reallocation procedure. Just mark the hardware
-                 * plane(s) as freed.
-                 */
-                if (!plane_state->format) {
-                        dev_dbg(rcdu->dev, "%s: plane is being disabled\n",
-                                __func__);
-                        index = plane - plane->group->planes;
-                        group_freed_planes[plane->group->index] |= 1 << index;
-                        plane_state->hwindex = -1;
-                        continue;
-                }
-
-                /* If the plane needs to be reallocated mark it as such, and
-                 * mark the hardware plane(s) as free.
-                 */
-                if (rcar_du_plane_needs_realloc(plane, plane_state)) {
-                        dev_dbg(rcdu->dev, "%s: plane needs reallocation\n",
-                                __func__);
-                        groups |= 1 << plane->group->index;
-                        needs_realloc = true;
-
-                        index = plane - plane->group->planes;
-                        group_freed_planes[plane->group->index] |= 1 << index;
-                        plane_state->hwindex = -1;
-                }
-        }
-
-        if (!needs_realloc)
-                return 0;
-
-        /* Grab all plane states for the groups that need reallocation to ensure
-         * locking and avoid racy updates. This serializes the update operation,
-         * but there's not much we can do about it as that's the hardware
-         * design.
-         *
-         * Compute the used planes mask for each group at the same time to avoid
-         * looping over the planes separately later.
-         */
-        while (groups) {
-                unsigned int index = ffs(groups) - 1;
-                struct rcar_du_group *group = &rcdu->groups[index];
-                unsigned int used_planes = 0;
-
-                dev_dbg(rcdu->dev, "%s: finding free planes for group %u\n",
-                        __func__, index);
-
-                for (i = 0; i < group->num_planes; ++i) {
-                        struct rcar_du_plane *plane = &group->planes[i];
-                        struct rcar_du_plane_state *plane_state;
-                        struct drm_plane_state *s;
-
-                        s = drm_atomic_get_plane_state(state, &plane->plane);
-                        if (IS_ERR(s))
-                                return PTR_ERR(s);
-
-                        /* If the plane has been freed in the above loop its
-                         * hardware planes must not be added to the used planes
-                         * bitmask. However, the current state doesn't reflect
-                         * the free state yet, as we've modified the new state
-                         * above. Use the local freed planes list to check for
-                         * that condition instead.
-                         */
-                        if (group_freed_planes[index] & (1 << i)) {
-                                dev_dbg(rcdu->dev,
-                                        "%s: plane (%u,%u) has been freed, skipping\n",
-                                        __func__, plane->group->index,
-                                        plane - plane->group->planes);
-                                continue;
-                        }
-
-                        plane_state = to_rcar_plane_state(plane->plane.state);
-                        used_planes |= rcar_du_plane_hwmask(plane_state);
-
-                        dev_dbg(rcdu->dev,
-                                "%s: plane (%u,%u) uses %u hwplanes (index %d)\n",
-                                __func__, plane->group->index,
-                                plane - plane->group->planes,
-                                plane_state->format ?
-                                plane_state->format->planes : 0,
-                                plane_state->hwindex);
-                }
-
-                group_free_planes[index] = 0xff & ~used_planes;
-                groups &= ~(1 << index);
-
-                dev_dbg(rcdu->dev, "%s: group %u free planes mask 0x%02x\n",
-                        __func__, index, group_free_planes[index]);
-        }
-
-        /* Reallocate hardware planes for each plane that needs it. */
-        for (i = 0; i < dev->mode_config.num_total_plane; ++i) {
-                struct rcar_du_plane_state *plane_state;
-                struct rcar_du_plane *plane;
-                unsigned int crtc_planes;
-                unsigned int free;
-                int idx;
-
-                if (!state->planes[i])
-                        continue;
-
-                plane = to_rcar_plane(state->planes[i]);
-                plane_state = to_rcar_plane_state(state->plane_states[i]);
-
-                dev_dbg(rcdu->dev, "%s: allocating plane (%u,%u)\n", __func__,
-                        plane->group->index, plane - plane->group->planes);
-
-                /* Skip planes that are being disabled or don't need to be
-                 * reallocated.
-                 */
-                if (!plane_state->format ||
-                    !rcar_du_plane_needs_realloc(plane, plane_state))
-                        continue;
-
-                /* Try to allocate the plane from the free planes currently
-                 * associated with the target CRTC to avoid restarting the CRTC
-                 * group and thus minimize flicker. If it fails fall back to
-                 * allocating from all free planes.
-                 */
-                crtc_planes = to_rcar_crtc(plane_state->state.crtc)->index % 2
-                            ? plane->group->dptsr_planes
-                            : ~plane->group->dptsr_planes;
-                free = group_free_planes[plane->group->index];
-
-                idx = rcar_du_plane_hwalloc(plane, plane_state,
-                                            free & crtc_planes);
-                if (idx < 0)
-                        idx = rcar_du_plane_hwalloc(plane, plane_state,
-                                                    free);
-                if (idx < 0) {
-                        dev_dbg(rcdu->dev, "%s: no available hardware plane\n",
-                                __func__);
-                        return idx;
-                }
-
-                dev_dbg(rcdu->dev, "%s: allocated %u hwplanes (index %u)\n",
-                        __func__, plane_state->format->planes, idx);
-
-                plane_state->hwindex = idx;
-
-                group_free_planes[plane->group->index] &=
-                        ~rcar_du_plane_hwmask(plane_state);
-
-                dev_dbg(rcdu->dev, "%s: group %u free planes mask 0x%02x\n",
-                        __func__, plane->group->index,
-                        group_free_planes[plane->group->index]);
-        }
-
-        return 0;
+        return rcar_du_atomic_check_planes(dev, state);
 }
 
 struct rcar_du_commit {
diff --git a/drivers/gpu/drm/rcar-du/rcar_du_plane.c b/drivers/gpu/drm/rcar-du/rcar_du_plane.c
index 2fa5745fca37..64450ce13526 100644
--- a/drivers/gpu/drm/rcar-du/rcar_du_plane.c
+++ b/drivers/gpu/drm/rcar-du/rcar_du_plane.c
@@ -12,6 +12,7 @@
  */
 
 #include <drm/drmP.h>
+#include <drm/drm_atomic.h>
 #include <drm/drm_atomic_helper.h>
 #include <drm/drm_crtc.h>
 #include <drm/drm_crtc_helper.h>
@@ -25,6 +26,291 @@
 #include "rcar_du_plane.h"
 #include "rcar_du_regs.h"
 
+/* -----------------------------------------------------------------------------
+ * Atomic hardware plane allocator
+ *
+ * The hardware plane allocator is solely based on the atomic plane states
+ * without keeping any external state to avoid races between .atomic_check()
+ * and .atomic_commit().
+ *
+ * The core idea is to avoid using a free planes bitmask that would need to be
+ * shared between check and commit handlers with a collective knowledge based on
+ * the allocated hardware plane(s) for each KMS plane. The allocator then loops
+ * over all plane states to compute the free planes bitmask, allocates hardware
+ * planes based on that bitmask, and stores the result back in the plane states.
+ *
+ * For this to work we need to access the current state of planes not touched by
+ * the atomic update. To ensure that it won't be modified, we need to lock all
+ * planes using drm_atomic_get_plane_state(). This effectively serializes atomic
+ * updates from .atomic_check() up to completion (when swapping the states if
+ * the check step has succeeded) or rollback (when freeing the states if the
+ * check step has failed).
+ *
+ * Allocation is performed in the .atomic_check() handler and applied
+ * automatically when the core swaps the old and new states.
+ */
+
+static bool rcar_du_plane_needs_realloc(struct rcar_du_plane *plane,
+                                        struct rcar_du_plane_state *new_state)
+{
+        struct rcar_du_plane_state *cur_state;
+
+        cur_state = to_rcar_plane_state(plane->plane.state);
+
+        /* Lowering the number of planes doesn't strictly require reallocation
+         * as the extra hardware plane will be freed when committing, but doing
+         * so could lead to more fragmentation.
+         */
+        if (!cur_state->format ||
+            cur_state->format->planes != new_state->format->planes)
+                return true;
+
+        /* Reallocate hardware planes if the source has changed. */
+        if (cur_state->source != new_state->source)
+                return true;
+
+        return false;
+}
+
+static unsigned int rcar_du_plane_hwmask(struct rcar_du_plane_state *state)
+{
+        unsigned int mask;
+
+        if (state->hwindex == -1)
+                return 0;
+
+        mask = 1 << state->hwindex;
+        if (state->format->planes == 2)
+                mask |= 1 << ((state->hwindex + 1) % 8);
+
+        return mask;
+}
+
+/*
+ * The R8A7790 DU can source frames directly from the VSP1 devices VSPD0 and
+ * VSPD1. VSPD0 feeds DU0/1 plane 0, and VSPD1 feeds either DU2 plane 0 or
+ * DU0/1 plane 1.
+ *
+ * Allocate the correct fixed plane when sourcing frames from VSPD0 or VSPD1,
+ * and allocate planes in reverse index order otherwise to ensure maximum
+ * availability of planes 0 and 1.
+ *
+ * The caller is responsible for ensuring that the requested source is
+ * compatible with the DU revision.
+ */
+static int rcar_du_plane_hwalloc(struct rcar_du_plane *plane,
+                                 struct rcar_du_plane_state *state,
+                                 unsigned int free)
+{
+        unsigned int num_planes = state->format->planes;
+        int fixed = -1;
+        int i;
+
+        if (state->source == RCAR_DU_PLANE_VSPD0) {
+                /* VSPD0 feeds plane 0 on DU0/1. */
+                if (plane->group->index != 0)
+                        return -EINVAL;
+
+                fixed = 0;
+        } else if (state->source == RCAR_DU_PLANE_VSPD1) {
+                /* VSPD1 feeds plane 1 on DU0/1 or plane 0 on DU2. */
+                fixed = plane->group->index == 0 ? 1 : 0;
+        }
+
+        if (fixed >= 0)
+                return free & (1 << fixed) ? fixed : -EBUSY;
+
+        for (i = RCAR_DU_NUM_HW_PLANES - 1; i >= 0; --i) {
+                if (!(free & (1 << i)))
+                        continue;
+
+                if (num_planes == 1 || free & (1 << ((i + 1) % 8)))
+                        break;
+        }
+
+        return i < 0 ? -EBUSY : i;
+}
+
+int rcar_du_atomic_check_planes(struct drm_device *dev,
+                                struct drm_atomic_state *state)
+{
+        struct rcar_du_device *rcdu = dev->dev_private;
+        unsigned int group_freed_planes[RCAR_DU_MAX_GROUPS] = { 0, };
+        unsigned int group_free_planes[RCAR_DU_MAX_GROUPS] = { 0, };
+        bool needs_realloc = false;
+        unsigned int groups = 0;
+        unsigned int i;
+
+        /* Check if hardware planes need to be reallocated. */
+        for (i = 0; i < dev->mode_config.num_total_plane; ++i) {
+                struct rcar_du_plane_state *plane_state;
+                struct rcar_du_plane *plane;
+                unsigned int index;
+
+                if (!state->planes[i])
+                        continue;
+
+                plane = to_rcar_plane(state->planes[i]);
+                plane_state = to_rcar_plane_state(state->plane_states[i]);
+
+                dev_dbg(rcdu->dev, "%s: checking plane (%u,%u)\n", __func__,
+                        plane->group->index, plane - plane->group->planes);
+
+                /* If the plane is being disabled we don't need to go through
+                 * the full reallocation procedure. Just mark the hardware
+                 * plane(s) as freed.
+                 */
+                if (!plane_state->format) {
+                        dev_dbg(rcdu->dev, "%s: plane is being disabled\n",
+                                __func__);
+                        index = plane - plane->group->planes;
+                        group_freed_planes[plane->group->index] |= 1 << index;
+                        plane_state->hwindex = -1;
+                        continue;
+                }
+
+                /* If the plane needs to be reallocated mark it as such, and
+                 * mark the hardware plane(s) as free.
+                 */
+                if (rcar_du_plane_needs_realloc(plane, plane_state)) {
+                        dev_dbg(rcdu->dev, "%s: plane needs reallocation\n",
+                                __func__);
+                        groups |= 1 << plane->group->index;
+                        needs_realloc = true;
+
+                        index = plane - plane->group->planes;
+                        group_freed_planes[plane->group->index] |= 1 << index;
+                        plane_state->hwindex = -1;
+                }
+        }
+
+        if (!needs_realloc)
+                return 0;
+
+        /* Grab all plane states for the groups that need reallocation to ensure
+         * locking and avoid racy updates. This serializes the update operation,
+         * but there's not much we can do about it as that's the hardware
+         * design.
+         *
+         * Compute the used planes mask for each group at the same time to avoid
+         * looping over the planes separately later.
+         */
+        while (groups) {
+                unsigned int index = ffs(groups) - 1;
+                struct rcar_du_group *group = &rcdu->groups[index];
+                unsigned int used_planes = 0;
+
+                dev_dbg(rcdu->dev, "%s: finding free planes for group %u\n",
+                        __func__, index);
+
+                for (i = 0; i < group->num_planes; ++i) {
+                        struct rcar_du_plane *plane = &group->planes[i];
+                        struct rcar_du_plane_state *plane_state;
+                        struct drm_plane_state *s;
+
+                        s = drm_atomic_get_plane_state(state, &plane->plane);
+                        if (IS_ERR(s))
+                                return PTR_ERR(s);
+
+                        /* If the plane has been freed in the above loop its
+                         * hardware planes must not be added to the used planes
+                         * bitmask. However, the current state doesn't reflect
+                         * the free state yet, as we've modified the new state
+                         * above. Use the local freed planes list to check for
+                         * that condition instead.
+                         */
+                        if (group_freed_planes[index] & (1 << i)) {
+                                dev_dbg(rcdu->dev,
+                                        "%s: plane (%u,%u) has been freed, skipping\n",
+                                        __func__, plane->group->index,
+                                        plane - plane->group->planes);
+                                continue;
+                        }
+
+                        plane_state = to_rcar_plane_state(plane->plane.state);
+                        used_planes |= rcar_du_plane_hwmask(plane_state);
+
+                        dev_dbg(rcdu->dev,
+                                "%s: plane (%u,%u) uses %u hwplanes (index %d)\n",
+                                __func__, plane->group->index,
+                                plane - plane->group->planes,
+                                plane_state->format ?
+                                plane_state->format->planes : 0,
+                                plane_state->hwindex);
+                }
+
+                group_free_planes[index] = 0xff & ~used_planes;
+                groups &= ~(1 << index);
+
+                dev_dbg(rcdu->dev, "%s: group %u free planes mask 0x%02x\n",
+                        __func__, index, group_free_planes[index]);
+        }
+
+        /* Reallocate hardware planes for each plane that needs it. */
+        for (i = 0; i < dev->mode_config.num_total_plane; ++i) {
+                struct rcar_du_plane_state *plane_state;
+                struct rcar_du_plane *plane;
+                unsigned int crtc_planes;
+                unsigned int free;
+                int idx;
+
+                if (!state->planes[i])
+                        continue;
+
+                plane = to_rcar_plane(state->planes[i]);
+                plane_state = to_rcar_plane_state(state->plane_states[i]);
+
+                dev_dbg(rcdu->dev, "%s: allocating plane (%u,%u)\n", __func__,
+                        plane->group->index, plane - plane->group->planes);
+
+                /* Skip planes that are being disabled or don't need to be
+                 * reallocated.
+                 */
+                if (!plane_state->format ||
+                    !rcar_du_plane_needs_realloc(plane, plane_state))
+                        continue;
+
+                /* Try to allocate the plane from the free planes currently
+                 * associated with the target CRTC to avoid restarting the CRTC
+                 * group and thus minimize flicker. If it fails fall back to
+                 * allocating from all free planes.
+                 */
+                crtc_planes = to_rcar_crtc(plane_state->state.crtc)->index % 2
+                            ? plane->group->dptsr_planes
+                            : ~plane->group->dptsr_planes;
+                free = group_free_planes[plane->group->index];
+
+                idx = rcar_du_plane_hwalloc(plane, plane_state,
+                                            free & crtc_planes);
+                if (idx < 0)
+                        idx = rcar_du_plane_hwalloc(plane, plane_state,
+                                                    free);
+                if (idx < 0) {
+                        dev_dbg(rcdu->dev, "%s: no available hardware plane\n",
+                                __func__);
+                        return idx;
+                }
+
+                dev_dbg(rcdu->dev, "%s: allocated %u hwplanes (index %u)\n",
+                        __func__, plane_state->format->planes, idx);
+
+                plane_state->hwindex = idx;
+
+                group_free_planes[plane->group->index] &=
+                        ~rcar_du_plane_hwmask(plane_state);
+
+                dev_dbg(rcdu->dev, "%s: group %u free planes mask 0x%02x\n",
+                        __func__, plane->group->index,
+                        group_free_planes[plane->group->index]);
+        }
+
+        return 0;
+}
+
+/* -----------------------------------------------------------------------------
+ * Plane Setup
+ */
+
 #define RCAR_DU_COLORKEY_NONE           (0 << 24)
 #define RCAR_DU_COLORKEY_SOURCE         (1 << 24)
 #define RCAR_DU_COLORKEY_MASK           (1 << 24)
diff --git a/drivers/gpu/drm/rcar-du/rcar_du_plane.h b/drivers/gpu/drm/rcar-du/rcar_du_plane.h
index e24e45828d6a..6a6460dffae4 100644
--- a/drivers/gpu/drm/rcar-du/rcar_du_plane.h
+++ b/drivers/gpu/drm/rcar-du/rcar_du_plane.h
@@ -71,6 +71,9 @@ to_rcar_plane_state(struct drm_plane_state *state)
         return container_of(state, struct rcar_du_plane_state, state);
 }
 
+int rcar_du_atomic_check_planes(struct drm_device *dev,
+                                struct drm_atomic_state *state);
+
 int rcar_du_planes_init(struct rcar_du_group *rgrp);
 
 void rcar_du_plane_setup(struct rcar_du_plane *plane);