drm: rcar-du: Use new iterator macros

for_each_obj_in_state is about to be removed, so use the correct new
iterator macros.

Also look at new_plane_state instead of plane->state when looking up
the hw planes in use. They should be the same except when reallocating,
(in which case this code is skipped) and we should really stop looking
at obj->state whenever possible.

Signed-off-by: Maarten Lankhorst <maarten.lankhorst@linux.intel.com>
Reviewed-by: Laurent Pinchart <laurent.pinchart+renesas@ideasonboard.com>
Signed-off-by: Laurent Pinchart <laurent.pinchart+renesas@ideasonboard.com>

diff --git a/drivers/gpu/drm/rcar-du/rcar_du_plane.c b/drivers/gpu/drm/rcar-du/rcar_du_plane.c
index b004047..25623cf 100644 (file)
--- a/drivers/gpu/drm/rcar-du/rcar_du_plane.c
+++ b/drivers/gpu/drm/rcar-du/rcar_du_plane.c
@@ -50,24 +50,21 @@
  * 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)
+static bool rcar_du_plane_needs_realloc(
+                               const struct rcar_du_plane_state *old_state,
+                               const 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)
+       if (!old_state->format ||
+           old_state->format->planes != new_state->format->planes)
                return true;
 
        /* Reallocate hardware planes if the source has changed. */
-       if (cur_state->source != new_state->source)
+       if (old_state->source != new_state->source)
                return true;
 
        return false;
@@ -142,16 +139,20 @@ int rcar_du_atomic_check_planes(struct drm_device *dev,
        unsigned int groups = 0;
        unsigned int i;
        struct drm_plane *drm_plane;
-       struct drm_plane_state *drm_plane_state;
+       struct drm_plane_state *old_drm_plane_state;
+       struct drm_plane_state *new_drm_plane_state;
 
        /* Check if hardware planes need to be reallocated. */
-       for_each_plane_in_state(state, drm_plane, drm_plane_state, i) {
-               struct rcar_du_plane_state *plane_state;
+       for_each_oldnew_plane_in_state(state, drm_plane, old_drm_plane_state,
+                                      new_drm_plane_state, i) {
+               struct rcar_du_plane_state *old_plane_state;
+               struct rcar_du_plane_state *new_plane_state;
                struct rcar_du_plane *plane;
                unsigned int index;
 
                plane = to_rcar_plane(drm_plane);
-               plane_state = to_rcar_plane_state(drm_plane_state);
+               old_plane_state = to_rcar_plane_state(old_drm_plane_state);
+               new_plane_state = to_rcar_plane_state(new_drm_plane_state);
 
                dev_dbg(rcdu->dev, "%s: checking plane (%u,%tu)\n", __func__,
                        plane->group->index, plane - plane->group->planes);
@@ -161,12 +162,12 @@ int rcar_du_atomic_check_planes(struct drm_device *dev,
                 * the full reallocation procedure. Just mark the hardware
                 * plane(s) as freed.
                 */
-               if (!plane_state->format) {
+               if (!new_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;
+                       new_plane_state->hwindex = -1;
                        continue;
                }
 
@@ -174,7 +175,7 @@ int rcar_du_atomic_check_planes(struct drm_device *dev,
                 * 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)) {
+               if (rcar_du_plane_needs_realloc(old_plane_state, new_plane_state)) {
                        dev_dbg(rcdu->dev, "%s: plane needs reallocation\n",
                                __func__);
                        groups |= 1 << plane->group->index;
@@ -182,7 +183,7 @@ int rcar_du_atomic_check_planes(struct drm_device *dev,
 
                        index = plane - plane->group->planes;
                        group_freed_planes[plane->group->index] |= 1 << index;
-                       plane_state->hwindex = -1;
+                       new_plane_state->hwindex = -1;
                }
        }
 
@@ -208,7 +209,7 @@ int rcar_du_atomic_check_planes(struct drm_device *dev,
 
                for (i = 0; i < group->num_planes; ++i) {
                        struct rcar_du_plane *plane = &group->planes[i];
-                       struct rcar_du_plane_state *plane_state;
+                       struct rcar_du_plane_state *new_plane_state;
                        struct drm_plane_state *s;
 
                        s = drm_atomic_get_plane_state(state, &plane->plane);
@@ -231,16 +232,16 @@ int rcar_du_atomic_check_planes(struct drm_device *dev,
                                continue;
                        }
 
-                       plane_state = to_rcar_plane_state(plane->plane.state);
-                       used_planes |= rcar_du_plane_hwmask(plane_state);
+                       new_plane_state = to_rcar_plane_state(s);
+                       used_planes |= rcar_du_plane_hwmask(new_plane_state);
 
                        dev_dbg(rcdu->dev,
                                "%s: plane (%u,%tu) 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);
+                               new_plane_state->format ?
+                               new_plane_state->format->planes : 0,
+                               new_plane_state->hwindex);
                }
 
                group_free_planes[index] = 0xff & ~used_planes;
@@ -251,15 +252,18 @@ int rcar_du_atomic_check_planes(struct drm_device *dev,
        }
 
        /* Reallocate hardware planes for each plane that needs it. */
-       for_each_plane_in_state(state, drm_plane, drm_plane_state, i) {
-               struct rcar_du_plane_state *plane_state;
+       for_each_oldnew_plane_in_state(state, drm_plane, old_drm_plane_state,
+                                      new_drm_plane_state, i) {
+               struct rcar_du_plane_state *old_plane_state;
+               struct rcar_du_plane_state *new_plane_state;
                struct rcar_du_plane *plane;
                unsigned int crtc_planes;
                unsigned int free;
                int idx;
 
                plane = to_rcar_plane(drm_plane);
-               plane_state = to_rcar_plane_state(drm_plane_state);
+               old_plane_state = to_rcar_plane_state(old_drm_plane_state);
+               new_plane_state = to_rcar_plane_state(new_drm_plane_state);
 
                dev_dbg(rcdu->dev, "%s: allocating plane (%u,%tu)\n", __func__,
                        plane->group->index, plane - plane->group->planes);
@@ -268,8 +272,8 @@ int rcar_du_atomic_check_planes(struct drm_device *dev,
                 * 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))
+               if (!new_plane_state->format ||
+                   !rcar_du_plane_needs_realloc(old_plane_state, new_plane_state))
                        continue;
 
                /*
@@ -278,15 +282,15 @@ int rcar_du_atomic_check_planes(struct drm_device *dev,
                 * 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
+               crtc_planes = to_rcar_crtc(new_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,
+               idx = rcar_du_plane_hwalloc(plane, new_plane_state,
                                            free & crtc_planes);
                if (idx < 0)
-                       idx = rcar_du_plane_hwalloc(plane, plane_state,
+                       idx = rcar_du_plane_hwalloc(plane, new_plane_state,
                                                    free);
                if (idx < 0) {
                        dev_dbg(rcdu->dev, "%s: no available hardware plane\n",
@@ -295,12 +299,12 @@ int rcar_du_atomic_check_planes(struct drm_device *dev,
                }
 
                dev_dbg(rcdu->dev, "%s: allocated %u hwplanes (index %u)\n",
-                       __func__, plane_state->format->planes, idx);
+                       __func__, new_plane_state->format->planes, idx);
 
-               plane_state->hwindex = idx;
+               new_plane_state->hwindex = idx;
 
                group_free_planes[plane->group->index] &=
-                       ~rcar_du_plane_hwmask(plane_state);
+                       ~rcar_du_plane_hwmask(new_plane_state);
 
                dev_dbg(rcdu->dev, "%s: group %u free planes mask 0x%02x\n",
                        __func__, plane->group->index,