static unsigned int plane_zpos(struct rcar_du_plane *plane)
 {
-       return to_rcar_du_plane_state(plane->plane.state)->zpos;
+       return to_rcar_plane_state(plane->plane.state)->zpos;
 }
 
 static const struct rcar_du_format_info *
 plane_format(struct rcar_du_plane *plane)
 {
-       return to_rcar_du_plane_state(plane->plane.state)->format;
+       return to_rcar_plane_state(plane->plane.state)->format;
 }
 
 static void rcar_du_crtc_update_planes(struct rcar_du_crtc *rcrtc)
        for (i = 0; i < num_planes; ++i) {
                struct rcar_du_plane *plane = planes[i];
                struct drm_plane_state *state = plane->plane.state;
-               unsigned int index = to_rcar_du_plane_state(state)->hwindex;
+               unsigned int index = to_rcar_plane_state(state)->hwindex;
 
                prio -= 4;
                dspr |= (index + 1) << prio;
 
 {
        const struct rcar_du_format_info *cur_format;
 
-       cur_format = to_rcar_du_plane_state(plane->plane.state)->format;
+       cur_format = to_rcar_plane_state(plane->plane.state)->format;
 
        /* Lowering the number of planes doesn't strictly require reallocation
         * as the extra hardware plane will be freed when committing, but doing
                        continue;
 
                plane = to_rcar_plane(state->planes[i]);
-               plane_state = to_rcar_du_plane_state(state->plane_states[i]);
+               plane_state = to_rcar_plane_state(state->plane_states[i]);
 
                /* If the plane is being disabled we don't need to go through
                 * the full reallocation procedure. Just mark the hardware
                        if (group_freed_planes[index] & (1 << i))
                                continue;
 
-                       plane_state = to_rcar_du_plane_state(plane->plane.state);
+                       plane_state = to_rcar_plane_state(plane->plane.state);
                        used_planes |= rcar_du_plane_hwmask(plane_state);
                }
 
                        continue;
 
                plane = to_rcar_plane(state->planes[i]);
-               plane_state = to_rcar_du_plane_state(state->plane_states[i]);
+               plane_state = to_rcar_plane_state(state->plane_states[i]);
 
                /* Skip planes that are being disabled or don't need to be
                 * reallocated.
 
 static void rcar_du_plane_setup_fb(struct rcar_du_plane *plane)
 {
        struct rcar_du_plane_state *state =
-               to_rcar_du_plane_state(plane->plane.state);
+               to_rcar_plane_state(plane->plane.state);
        struct drm_framebuffer *fb = plane->plane.state->fb;
        struct rcar_du_group *rgrp = plane->group;
        unsigned int src_x = state->state.src_x >> 16;
                                     unsigned int index)
 {
        struct rcar_du_plane_state *state =
-               to_rcar_du_plane_state(plane->plane.state);
+               to_rcar_plane_state(plane->plane.state);
        struct rcar_du_group *rgrp = plane->group;
        u32 colorkey;
        u32 pnmr;
                                  unsigned int index)
 {
        struct rcar_du_plane_state *state =
-               to_rcar_du_plane_state(plane->plane.state);
+               to_rcar_plane_state(plane->plane.state);
        struct rcar_du_group *rgrp = plane->group;
        u32 ddcr2 = PnDDCR2_CODE;
        u32 ddcr4;
 void rcar_du_plane_setup(struct rcar_du_plane *plane)
 {
        struct rcar_du_plane_state *state =
-               to_rcar_du_plane_state(plane->plane.state);
+               to_rcar_plane_state(plane->plane.state);
 
        __rcar_du_plane_setup(plane, state->hwindex);
        if (state->format->planes == 2)
 static int rcar_du_plane_atomic_check(struct drm_plane *plane,
                                      struct drm_plane_state *state)
 {
-       struct rcar_du_plane_state *rstate = to_rcar_du_plane_state(state);
+       struct rcar_du_plane_state *rstate = to_rcar_plane_state(state);
        struct rcar_du_plane *rplane = to_rcar_plane(plane);
        struct rcar_du_device *rcdu = rplane->group->dev;
 
        struct rcar_du_plane_state *state;
        struct rcar_du_plane_state *copy;
 
-       state = to_rcar_du_plane_state(plane->state);
+       state = to_rcar_plane_state(plane->state);
        copy = kmemdup(state, sizeof(*state), GFP_KERNEL);
        if (copy == NULL)
                return NULL;
        if (state->fb)
                drm_framebuffer_unreference(state->fb);
 
-       kfree(to_rcar_du_plane_state(state));
+       kfree(to_rcar_plane_state(state));
 }
 
 static int rcar_du_plane_atomic_set_property(struct drm_plane *plane,
                                             struct drm_property *property,
                                             uint64_t val)
 {
-       struct rcar_du_plane_state *rstate = to_rcar_du_plane_state(state);
+       struct rcar_du_plane_state *rstate = to_rcar_plane_state(state);
        struct rcar_du_device *rcdu = to_rcar_plane(plane)->group->dev;
 
        if (property == rcdu->props.alpha)