static bool intel_plane_uses_fence(const struct intel_plane_state *plane_state)
 {
-       struct intel_plane *plane = to_intel_plane(plane_state->base.plane);
+       struct intel_plane *plane = to_intel_plane(plane_state->uapi.plane);
        struct drm_i915_private *dev_priv = to_i915(plane->base.dev);
 
        return INTEL_GEN(dev_priv) < 4 ||
                                              const struct intel_plane_state *state,
                                              int color_plane)
 {
-       struct intel_plane *intel_plane = to_intel_plane(state->base.plane);
+       struct intel_plane *intel_plane = to_intel_plane(state->uapi.plane);
        struct drm_i915_private *dev_priv = to_i915(intel_plane->base.dev);
        const struct drm_framebuffer *fb = state->hw.fb;
        unsigned int rotation = state->hw.rotation;
 
 bool intel_plane_can_remap(const struct intel_plane_state *plane_state)
 {
-       struct intel_plane *plane = to_intel_plane(plane_state->base.plane);
+       struct intel_plane *plane = to_intel_plane(plane_state->uapi.plane);
        struct drm_i915_private *dev_priv = to_i915(plane->base.dev);
        const struct drm_framebuffer *fb = plane_state->hw.fb;
        int i;
 
 static bool intel_plane_needs_remap(const struct intel_plane_state *plane_state)
 {
-       struct intel_plane *plane = to_intel_plane(plane_state->base.plane);
+       struct intel_plane *plane = to_intel_plane(plane_state->uapi.plane);
        const struct drm_framebuffer *fb = plane_state->hw.fb;
        unsigned int rotation = plane_state->hw.rotation;
        u32 stride, max_stride;
         * No remapping for invisible planes since we don't have
         * an actual source viewport to remap.
         */
-       if (!plane_state->base.visible)
+       if (!plane_state->uapi.visible)
                return false;
 
        if (!intel_plane_can_remap(plane_state))
 intel_plane_remap_gtt(struct intel_plane_state *plane_state)
 {
        struct drm_i915_private *dev_priv =
-               to_i915(plane_state->base.plane->dev);
+               to_i915(plane_state->uapi.plane->dev);
        struct drm_framebuffer *fb = plane_state->hw.fb;
        struct intel_framebuffer *intel_fb = to_intel_framebuffer(fb);
        struct intel_rotation_info *info = &plane_state->view.rotated;
        plane_state->view.type = drm_rotation_90_or_270(rotation) ?
                I915_GGTT_VIEW_ROTATED : I915_GGTT_VIEW_REMAPPED;
 
-       src_x = plane_state->base.src.x1 >> 16;
-       src_y = plane_state->base.src.y1 >> 16;
-       src_w = drm_rect_width(&plane_state->base.src) >> 16;
-       src_h = drm_rect_height(&plane_state->base.src) >> 16;
+       src_x = plane_state->uapi.src.x1 >> 16;
+       src_y = plane_state->uapi.src.y1 >> 16;
+       src_w = drm_rect_width(&plane_state->uapi.src) >> 16;
+       src_h = drm_rect_height(&plane_state->uapi.src) >> 16;
 
        WARN_ON(is_ccs_modifier(fb->modifier));
 
        /* Make src coordinates relative to the viewport */
-       drm_rect_translate(&plane_state->base.src,
+       drm_rect_translate(&plane_state->uapi.src,
                           -(src_x << 16), -(src_y << 16));
 
        /* Rotate src coordinates to match rotated GTT view */
        if (drm_rotation_90_or_270(rotation))
-               drm_rect_rotate(&plane_state->base.src,
+               drm_rect_rotate(&plane_state->uapi.src,
                                src_w << 16, src_h << 16,
                                DRM_MODE_ROTATE_270);
 
 
        /* Rotate src coordinates to match rotated GTT view */
        if (drm_rotation_90_or_270(rotation))
-               drm_rect_rotate(&plane_state->base.src,
+               drm_rect_rotate(&plane_state->uapi.src,
                                fb->base.width << 16, fb->base.height << 16,
                                DRM_MODE_ROTATE_270);
 
                        struct intel_plane_state *plane_state,
                        bool visible)
 {
-       struct intel_plane *plane = to_intel_plane(plane_state->base.plane);
+       struct intel_plane *plane = to_intel_plane(plane_state->uapi.plane);
 
-       plane_state->base.visible = visible;
+       plane_state->uapi.visible = visible;
 
        if (visible)
                crtc_state->uapi.plane_mask |= drm_plane_mask(&plane->base);
        plane_state->crtc_w = fb->width;
        plane_state->crtc_h = fb->height;
 
-       intel_state->base.src = drm_plane_state_src(plane_state);
-       intel_state->base.dst = drm_plane_state_dest(plane_state);
+       intel_state->uapi.src = drm_plane_state_src(plane_state);
+       intel_state->uapi.dst = drm_plane_state_dest(plane_state);
 
        if (plane_config->tiling)
                dev_priv->preserve_bios_swizzle = true;
 
 static int skl_check_main_surface(struct intel_plane_state *plane_state)
 {
-       struct drm_i915_private *dev_priv = to_i915(plane_state->base.plane->dev);
+       struct drm_i915_private *dev_priv = to_i915(plane_state->uapi.plane->dev);
        const struct drm_framebuffer *fb = plane_state->hw.fb;
        unsigned int rotation = plane_state->hw.rotation;
-       int x = plane_state->base.src.x1 >> 16;
-       int y = plane_state->base.src.y1 >> 16;
-       int w = drm_rect_width(&plane_state->base.src) >> 16;
-       int h = drm_rect_height(&plane_state->base.src) >> 16;
+       int x = plane_state->uapi.src.x1 >> 16;
+       int y = plane_state->uapi.src.y1 >> 16;
+       int w = drm_rect_width(&plane_state->uapi.src) >> 16;
+       int h = drm_rect_height(&plane_state->uapi.src) >> 16;
        int max_width;
        int max_height;
        u32 alignment, offset, aux_offset = plane_state->color_plane[1].offset;
         * Put the final coordinates back so that the src
         * coordinate checks will see the right values.
         */
-       drm_rect_translate_to(&plane_state->base.src,
+       drm_rect_translate_to(&plane_state->uapi.src,
                              x << 16, y << 16);
 
        return 0;
        unsigned int rotation = plane_state->hw.rotation;
        int max_width = skl_max_plane_width(fb, 1, rotation);
        int max_height = 4096;
-       int x = plane_state->base.src.x1 >> 17;
-       int y = plane_state->base.src.y1 >> 17;
-       int w = drm_rect_width(&plane_state->base.src) >> 17;
-       int h = drm_rect_height(&plane_state->base.src) >> 17;
+       int x = plane_state->uapi.src.x1 >> 17;
+       int y = plane_state->uapi.src.y1 >> 17;
+       int w = drm_rect_width(&plane_state->uapi.src) >> 17;
+       int h = drm_rect_height(&plane_state->uapi.src) >> 17;
        u32 offset;
 
        intel_add_fb_offsets(&x, &y, plane_state, 1);
 static int skl_check_ccs_aux_surface(struct intel_plane_state *plane_state)
 {
        const struct drm_framebuffer *fb = plane_state->hw.fb;
-       int src_x = plane_state->base.src.x1 >> 16;
-       int src_y = plane_state->base.src.y1 >> 16;
+       int src_x = plane_state->uapi.src.x1 >> 16;
+       int src_y = plane_state->uapi.src.y1 >> 16;
        int hsub = fb->format->hsub;
        int vsub = fb->format->vsub;
        int x = src_x / hsub;
        if (ret)
                return ret;
 
-       if (!plane_state->base.visible)
+       if (!plane_state->uapi.visible)
                return 0;
 
        /*
                          const struct intel_plane_state *plane_state)
 {
        struct drm_i915_private *dev_priv =
-               to_i915(plane_state->base.plane->dev);
+               to_i915(plane_state->uapi.plane->dev);
        const struct drm_framebuffer *fb = plane_state->hw.fb;
        unsigned int rotation = plane_state->hw.rotation;
        u32 dspcntr;
 int i9xx_check_plane_surface(struct intel_plane_state *plane_state)
 {
        struct drm_i915_private *dev_priv =
-               to_i915(plane_state->base.plane->dev);
+               to_i915(plane_state->uapi.plane->dev);
        const struct drm_framebuffer *fb = plane_state->hw.fb;
        int src_x, src_y, src_w;
        u32 offset;
        if (ret)
                return ret;
 
-       if (!plane_state->base.visible)
+       if (!plane_state->uapi.visible)
                return 0;
 
-       src_w = drm_rect_width(&plane_state->base.src) >> 16;
-       src_x = plane_state->base.src.x1 >> 16;
-       src_y = plane_state->base.src.y1 >> 16;
+       src_w = drm_rect_width(&plane_state->uapi.src) >> 16;
+       src_x = plane_state->uapi.src.x1 >> 16;
+       src_y = plane_state->uapi.src.y1 >> 16;
 
        /* Undocumented hardware limit on i965/g4x/vlv/chv */
        if (HAS_GMCH(dev_priv) && fb->format->cpp[0] == 8 && src_w > 2048)
         * Put the final coordinates back so that the src
         * coordinate checks will see the right values.
         */
-       drm_rect_translate_to(&plane_state->base.src,
+       drm_rect_translate_to(&plane_state->uapi.src,
                              src_x << 16, src_y << 16);
 
        /* HSW/BDW do this automagically in hardware */
        if (!IS_HASWELL(dev_priv) && !IS_BROADWELL(dev_priv)) {
                unsigned int rotation = plane_state->hw.rotation;
-               int src_w = drm_rect_width(&plane_state->base.src) >> 16;
-               int src_h = drm_rect_height(&plane_state->base.src) >> 16;
+               int src_w = drm_rect_width(&plane_state->uapi.src) >> 16;
+               int src_h = drm_rect_height(&plane_state->uapi.src) >> 16;
 
                if (rotation & DRM_MODE_ROTATE_180) {
                        src_x += src_w - 1;
 i9xx_plane_check(struct intel_crtc_state *crtc_state,
                 struct intel_plane_state *plane_state)
 {
-       struct intel_plane *plane = to_intel_plane(plane_state->base.plane);
+       struct intel_plane *plane = to_intel_plane(plane_state->uapi.plane);
        int ret;
 
        ret = chv_plane_check_rotation(plane_state);
        if (ret)
                return ret;
 
-       ret = drm_atomic_helper_check_plane_state(&plane_state->base,
+       ret = drm_atomic_helper_check_plane_state(&plane_state->uapi,
                                                  &crtc_state->uapi,
                                                  DRM_PLANE_HELPER_NO_SCALING,
                                                  DRM_PLANE_HELPER_NO_SCALING,
        if (ret)
                return ret;
 
-       if (!plane_state->base.visible)
+       if (!plane_state->uapi.visible)
                return 0;
 
        ret = intel_plane_check_src_coordinates(plane_state);
        u32 linear_offset;
        int x = plane_state->color_plane[0].x;
        int y = plane_state->color_plane[0].y;
-       int crtc_x = plane_state->base.dst.x1;
-       int crtc_y = plane_state->base.dst.y1;
-       int crtc_w = drm_rect_width(&plane_state->base.dst);
-       int crtc_h = drm_rect_height(&plane_state->base.dst);
+       int crtc_x = plane_state->uapi.dst.x1;
+       int crtc_y = plane_state->uapi.dst.y1;
+       int crtc_w = drm_rect_width(&plane_state->uapi.dst);
+       int crtc_h = drm_rect_height(&plane_state->uapi.dst);
        unsigned long irqflags;
        u32 dspaddr_offset;
        u32 dspcntr;
                  const struct intel_plane_state *plane_state)
 {
        struct drm_i915_private *dev_priv =
-               to_i915(plane_state->base.plane->dev);
+               to_i915(plane_state->uapi.plane->dev);
        const struct drm_framebuffer *fb = plane_state->hw.fb;
        unsigned int rotation = plane_state->hw.rotation;
        const struct drm_intel_sprite_colorkey *key = &plane_state->ckey;
                        const struct intel_plane_state *plane_state)
 {
        struct drm_i915_private *dev_priv =
-               to_i915(plane_state->base.plane->dev);
+               to_i915(plane_state->uapi.plane->dev);
        const struct drm_framebuffer *fb = plane_state->hw.fb;
-       struct intel_plane *plane = to_intel_plane(plane_state->base.plane);
+       struct intel_plane *plane = to_intel_plane(plane_state->uapi.plane);
        u32 plane_color_ctl = 0;
 
        plane_color_ctl |= PLANE_COLOR_PLANE_GAMMA_DISABLE;
                                   struct intel_plane_state *plane_state)
 {
        struct intel_plane *intel_plane =
-               to_intel_plane(plane_state->base.plane);
+               to_intel_plane(plane_state->uapi.plane);
        struct drm_i915_private *dev_priv = to_i915(intel_plane->base.dev);
        struct drm_framebuffer *fb = plane_state->hw.fb;
        int ret;
-       bool force_detach = !fb || !plane_state->base.visible;
+       bool force_detach = !fb || !plane_state->uapi.visible;
        bool need_scaler = false;
 
        /* Pre-gen11 and SDR planes always need a scaler for planar formats. */
        ret = skl_update_scaler(crtc_state, force_detach,
                                drm_plane_index(&intel_plane->base),
                                &plane_state->scaler_id,
-                               drm_rect_width(&plane_state->base.src) >> 16,
-                               drm_rect_height(&plane_state->base.src) >> 16,
-                               drm_rect_width(&plane_state->base.dst),
-                               drm_rect_height(&plane_state->base.dst),
+                               drm_rect_width(&plane_state->uapi.src) >> 16,
+                               drm_rect_height(&plane_state->uapi.src) >> 16,
+                               drm_rect_width(&plane_state->uapi.dst),
+                               drm_rect_height(&plane_state->uapi.dst),
                                fb ? fb->format : NULL, need_scaler);
 
        if (ret || plane_state->scaler_id < 0)
                 * So disable underrun reporting before all the planes get disabled.
                 */
                if (IS_GEN(dev_priv, 2) && old_primary_state->visible &&
-                   (modeset || !new_primary_state->base.visible))
+                   (modeset || !new_primary_state->uapi.visible))
                        intel_set_cpu_fifo_underrun_reporting(dev_priv, crtc->pipe, false);
        }
 
 
                intel_disable_plane(plane, new_crtc_state);
 
-               if (old_plane_state->base.visible)
+               if (old_plane_state->uapi.visible)
                        fb_bits |= plane->frontbuffer_bit;
        }
 
                const struct intel_plane_state *plane_state =
                        to_intel_plane_state(plane->base.state);
 
-               if (plane_state->base.visible)
+               if (plane_state->uapi.visible)
                        intel_plane_disable_noatomic(intel_crtc, plane);
        }
 
 static u32 intel_cursor_base(const struct intel_plane_state *plane_state)
 {
        struct drm_i915_private *dev_priv =
-               to_i915(plane_state->base.plane->dev);
+               to_i915(plane_state->uapi.plane->dev);
        const struct drm_framebuffer *fb = plane_state->hw.fb;
        const struct drm_i915_gem_object *obj = intel_fb_obj(fb);
        u32 base;
 
 static u32 intel_cursor_position(const struct intel_plane_state *plane_state)
 {
-       int x = plane_state->base.dst.x1;
-       int y = plane_state->base.dst.y1;
+       int x = plane_state->uapi.dst.x1;
+       int y = plane_state->uapi.dst.y1;
        u32 pos = 0;
 
        if (x < 0) {
 static bool intel_cursor_size_ok(const struct intel_plane_state *plane_state)
 {
        const struct drm_mode_config *config =
-               &plane_state->base.plane->dev->mode_config;
-       int width = drm_rect_width(&plane_state->base.dst);
-       int height = drm_rect_height(&plane_state->base.dst);
+               &plane_state->uapi.plane->dev->mode_config;
+       int width = drm_rect_width(&plane_state->uapi.dst);
+       int height = drm_rect_height(&plane_state->uapi.dst);
 
        return width > 0 && width <= config->cursor_width &&
                height > 0 && height <= config->cursor_height;
 static int intel_cursor_check_surface(struct intel_plane_state *plane_state)
 {
        struct drm_i915_private *dev_priv =
-               to_i915(plane_state->base.plane->dev);
+               to_i915(plane_state->uapi.plane->dev);
        unsigned int rotation = plane_state->hw.rotation;
        int src_x, src_y;
        u32 offset;
        if (ret)
                return ret;
 
-       if (!plane_state->base.visible)
+       if (!plane_state->uapi.visible)
                return 0;
 
-       src_x = plane_state->base.src.x1 >> 16;
-       src_y = plane_state->base.src.y1 >> 16;
+       src_x = plane_state->uapi.src.x1 >> 16;
+       src_y = plane_state->uapi.src.y1 >> 16;
 
        intel_add_fb_offsets(&src_x, &src_y, plane_state, 0);
        offset = intel_plane_compute_aligned_offset(&src_x, &src_y,
         * Put the final coordinates back so that the src
         * coordinate checks will see the right values.
         */
-       drm_rect_translate_to(&plane_state->base.src,
+       drm_rect_translate_to(&plane_state->uapi.src,
                              src_x << 16, src_y << 16);
 
        /* ILK+ do this automagically in hardware */
        if (HAS_GMCH(dev_priv) && rotation & DRM_MODE_ROTATE_180) {
                const struct drm_framebuffer *fb = plane_state->hw.fb;
-               int src_w = drm_rect_width(&plane_state->base.src) >> 16;
-               int src_h = drm_rect_height(&plane_state->base.src) >> 16;
+               int src_w = drm_rect_width(&plane_state->uapi.src) >> 16;
+               int src_h = drm_rect_height(&plane_state->uapi.src) >> 16;
 
                offset += (src_h * src_w - 1) * fb->format->cpp[0];
        }
                return -EINVAL;
        }
 
-       ret = drm_atomic_helper_check_plane_state(&plane_state->base,
+       ret = drm_atomic_helper_check_plane_state(&plane_state->uapi,
                                                  &crtc_state->uapi,
                                                  DRM_PLANE_HELPER_NO_SCALING,
                                                  DRM_PLANE_HELPER_NO_SCALING,
                return ret;
 
        /* Use the unclipped src/dst rectangles, which we program to hw */
-       plane_state->base.src = drm_plane_state_src(&plane_state->base);
-       plane_state->base.dst = drm_plane_state_dest(&plane_state->base);
+       plane_state->uapi.src = drm_plane_state_src(&plane_state->uapi);
+       plane_state->uapi.dst = drm_plane_state_dest(&plane_state->uapi);
 
        ret = intel_cursor_check_surface(plane_state);
        if (ret)
                return ret;
 
-       if (!plane_state->base.visible)
+       if (!plane_state->uapi.visible)
                return 0;
 
        ret = intel_plane_check_src_coordinates(plane_state);
 
 static bool i845_cursor_size_ok(const struct intel_plane_state *plane_state)
 {
-       int width = drm_rect_width(&plane_state->base.dst);
+       int width = drm_rect_width(&plane_state->uapi.dst);
 
        /*
         * 845g/865g are only limited by the width of their cursors,
        /* Check for which cursor types we support */
        if (!i845_cursor_size_ok(plane_state)) {
                DRM_DEBUG("Cursor dimension %dx%d not supported\n",
-                         drm_rect_width(&plane_state->base.dst),
-                         drm_rect_height(&plane_state->base.dst));
+                         drm_rect_width(&plane_state->uapi.dst),
+                         drm_rect_height(&plane_state->uapi.dst));
                return -EINVAL;
        }
 
-       WARN_ON(plane_state->base.visible &&
+       WARN_ON(plane_state->uapi.visible &&
                plane_state->color_plane[0].stride != fb->pitches[0]);
 
        switch (fb->pitches[0]) {
        u32 cntl = 0, base = 0, pos = 0, size = 0;
        unsigned long irqflags;
 
-       if (plane_state && plane_state->base.visible) {
-               unsigned int width = drm_rect_width(&plane_state->base.dst);
-               unsigned int height = drm_rect_height(&plane_state->base.dst);
+       if (plane_state && plane_state->uapi.visible) {
+               unsigned int width = drm_rect_width(&plane_state->uapi.dst);
+               unsigned int height = drm_rect_height(&plane_state->uapi.dst);
 
                cntl = plane_state->ctl |
                        i845_cursor_ctl_crtc(crtc_state);
                           const struct intel_plane_state *plane_state)
 {
        struct drm_i915_private *dev_priv =
-               to_i915(plane_state->base.plane->dev);
+               to_i915(plane_state->uapi.plane->dev);
        u32 cntl = 0;
 
        if (IS_GEN(dev_priv, 6) || IS_IVYBRIDGE(dev_priv))
                cntl |= MCURSOR_TRICKLE_FEED_DISABLE;
 
-       switch (drm_rect_width(&plane_state->base.dst)) {
+       switch (drm_rect_width(&plane_state->uapi.dst)) {
        case 64:
                cntl |= MCURSOR_MODE_64_ARGB_AX;
                break;
                cntl |= MCURSOR_MODE_256_ARGB_AX;
                break;
        default:
-               MISSING_CASE(drm_rect_width(&plane_state->base.dst));
+               MISSING_CASE(drm_rect_width(&plane_state->uapi.dst));
                return 0;
        }
 
 static bool i9xx_cursor_size_ok(const struct intel_plane_state *plane_state)
 {
        struct drm_i915_private *dev_priv =
-               to_i915(plane_state->base.plane->dev);
-       int width = drm_rect_width(&plane_state->base.dst);
-       int height = drm_rect_height(&plane_state->base.dst);
+               to_i915(plane_state->uapi.plane->dev);
+       int width = drm_rect_width(&plane_state->uapi.dst);
+       int height = drm_rect_height(&plane_state->uapi.dst);
 
        if (!intel_cursor_size_ok(plane_state))
                return false;
 static int i9xx_check_cursor(struct intel_crtc_state *crtc_state,
                             struct intel_plane_state *plane_state)
 {
-       struct intel_plane *plane = to_intel_plane(plane_state->base.plane);
+       struct intel_plane *plane = to_intel_plane(plane_state->uapi.plane);
        struct drm_i915_private *dev_priv = to_i915(plane->base.dev);
        const struct drm_framebuffer *fb = plane_state->hw.fb;
        enum pipe pipe = plane->pipe;
        /* Check for which cursor types we support */
        if (!i9xx_cursor_size_ok(plane_state)) {
                DRM_DEBUG("Cursor dimension %dx%d not supported\n",
-                         drm_rect_width(&plane_state->base.dst),
-                         drm_rect_height(&plane_state->base.dst));
+                         drm_rect_width(&plane_state->uapi.dst),
+                         drm_rect_height(&plane_state->uapi.dst));
                return -EINVAL;
        }
 
-       WARN_ON(plane_state->base.visible &&
+       WARN_ON(plane_state->uapi.visible &&
                plane_state->color_plane[0].stride != fb->pitches[0]);
 
        if (fb->pitches[0] !=
-           drm_rect_width(&plane_state->base.dst) * fb->format->cpp[0]) {
+           drm_rect_width(&plane_state->uapi.dst) * fb->format->cpp[0]) {
                DRM_DEBUG_KMS("Invalid cursor stride (%u) (cursor width %d)\n",
                              fb->pitches[0],
-                             drm_rect_width(&plane_state->base.dst));
+                             drm_rect_width(&plane_state->uapi.dst));
                return -EINVAL;
        }
 
         * Refuse the put the cursor into that compromised position.
         */
        if (IS_CHERRYVIEW(dev_priv) && pipe == PIPE_C &&
-           plane_state->base.visible && plane_state->base.dst.x1 < 0) {
+           plane_state->uapi.visible && plane_state->uapi.dst.x1 < 0) {
                DRM_DEBUG_KMS("CHV cursor C not allowed to straddle the left screen edge\n");
                return -EINVAL;
        }
        u32 cntl = 0, base = 0, pos = 0, fbc_ctl = 0;
        unsigned long irqflags;
 
-       if (plane_state && plane_state->base.visible) {
-               unsigned width = drm_rect_width(&plane_state->base.dst);
-               unsigned height = drm_rect_height(&plane_state->base.dst);
+       if (plane_state && plane_state->uapi.visible) {
+               unsigned width = drm_rect_width(&plane_state->uapi.dst);
+               unsigned height = drm_rect_height(&plane_state->uapi.dst);
 
                cntl = plane_state->ctl |
                        i9xx_cursor_ctl_crtc(crtc_state);
                                 struct intel_plane_state *new)
 {
        /* Update watermarks on tiling or size changes. */
-       if (new->base.visible != cur->base.visible)
+       if (new->uapi.visible != cur->uapi.visible)
                return true;
 
        if (!cur->hw.fb || !new->hw.fb)
 
        if (cur->hw.fb->modifier != new->hw.fb->modifier ||
            cur->hw.rotation != new->hw.rotation ||
-           drm_rect_width(&new->base.src) != drm_rect_width(&cur->base.src) ||
-           drm_rect_height(&new->base.src) != drm_rect_height(&cur->base.src) ||
-           drm_rect_width(&new->base.dst) != drm_rect_width(&cur->base.dst) ||
-           drm_rect_height(&new->base.dst) != drm_rect_height(&cur->base.dst))
+           drm_rect_width(&new->uapi.src) != drm_rect_width(&cur->uapi.src) ||
+           drm_rect_height(&new->uapi.src) != drm_rect_height(&cur->uapi.src) ||
+           drm_rect_width(&new->uapi.dst) != drm_rect_width(&cur->uapi.dst) ||
+           drm_rect_height(&new->uapi.dst) != drm_rect_height(&cur->uapi.dst))
                return true;
 
        return false;
 
 static bool needs_scaling(const struct intel_plane_state *state)
 {
-       int src_w = drm_rect_width(&state->base.src) >> 16;
-       int src_h = drm_rect_height(&state->base.src) >> 16;
-       int dst_w = drm_rect_width(&state->base.dst);
-       int dst_h = drm_rect_height(&state->base.dst);
+       int src_w = drm_rect_width(&state->uapi.src) >> 16;
+       int src_h = drm_rect_height(&state->uapi.src) >> 16;
+       int dst_w = drm_rect_width(&state->uapi.dst);
+       int dst_h = drm_rect_height(&state->uapi.dst);
 
        return (src_w != dst_w || src_h != dst_h);
 }
                                    struct intel_plane_state *plane_state)
 {
        struct intel_crtc *crtc = to_intel_crtc(crtc_state->uapi.crtc);
-       struct intel_plane *plane = to_intel_plane(plane_state->base.plane);
+       struct intel_plane *plane = to_intel_plane(plane_state->uapi.plane);
        struct drm_i915_private *dev_priv = to_i915(crtc->base.dev);
        bool mode_changed = needs_modeset(crtc_state);
        bool was_crtc_enabled = old_crtc_state->hw.active;
                        return ret;
        }
 
-       was_visible = old_plane_state->base.visible;
-       visible = plane_state->base.visible;
+       was_visible = old_plane_state->uapi.visible;
+       visible = plane_state->uapi.visible;
 
        if (!was_crtc_enabled && WARN_ON(was_visible))
                was_visible = false;
         * only combine the results from all planes in the current place?
         */
        if (!is_crtc_enabled) {
-               plane_state->base.visible = visible = false;
+               plane_state->uapi.visible = visible = false;
                crtc_state->active_planes &= ~BIT(plane->id);
                crtc_state->data_rate[plane->id] = 0;
                crtc_state->min_cdclk[plane->id] = 0;
                        continue;
 
                plane_state->planar_linked_plane = NULL;
-               if (plane_state->planar_slave && !plane_state->base.visible) {
+               if (plane_state->planar_slave && !plane_state->uapi.visible) {
                        crtc_state->active_planes &= ~BIT(plane->id);
                        crtc_state->update_planes |= BIT(plane->id);
                }
 
 static void intel_dump_plane_state(const struct intel_plane_state *plane_state)
 {
-       struct intel_plane *plane = to_intel_plane(plane_state->base.plane);
+       struct intel_plane *plane = to_intel_plane(plane_state->uapi.plane);
        const struct drm_framebuffer *fb = plane_state->hw.fb;
        struct drm_format_name_buf format_name;
 
        if (!fb) {
                DRM_DEBUG_KMS("[PLANE:%d:%s] fb: [NOFB], visible: %s\n",
                              plane->base.base.id, plane->base.name,
-                             yesno(plane_state->base.visible));
+                             yesno(plane_state->uapi.visible));
                return;
        }
 
                      plane->base.base.id, plane->base.name,
                      fb->base.id, fb->width, fb->height,
                      drm_get_format_name(fb->format->format, &format_name),
-                     yesno(plane_state->base.visible));
+                     yesno(plane_state->uapi.visible));
        DRM_DEBUG_KMS("\trotation: 0x%x, scaler: %d\n",
                      plane_state->hw.rotation, plane_state->scaler_id);
-       if (plane_state->base.visible)
+       if (plane_state->uapi.visible)
                DRM_DEBUG_KMS("\tsrc: " DRM_RECT_FP_FMT " dst: " DRM_RECT_FMT "\n",
-                             DRM_RECT_FP_ARG(&plane_state->base.src),
-                             DRM_RECT_ARG(&plane_state->base.dst));
+                             DRM_RECT_FP_ARG(&plane_state->uapi.src),
+                             DRM_RECT_ARG(&plane_state->uapi.dst));
 }
 
 static void intel_dump_pipe_config(const struct intel_crtc_state *pipe_config,
        for_each_new_intel_plane_in_state(state, plane,
                                          plane_state, i)
                assert_plane(plane, plane_state->planar_slave ||
-                            plane_state->base.visible);
+                            plane_state->uapi.visible);
 }
 
 static void
 
 static int intel_plane_pin_fb(struct intel_plane_state *plane_state)
 {
-       struct intel_plane *plane = to_intel_plane(plane_state->base.plane);
+       struct intel_plane *plane = to_intel_plane(plane_state->uapi.plane);
        struct drm_i915_private *dev_priv = to_i915(plane->base.dev);
        struct drm_framebuffer *fb = plane_state->hw.fb;
        struct i915_vma *vma;
        struct intel_plane_state *new_plane_state =
                to_intel_plane_state(_new_plane_state);
        struct intel_atomic_state *intel_state =
-               to_intel_atomic_state(new_plane_state->base.state);
+               to_intel_atomic_state(new_plane_state->uapi.state);
        struct drm_i915_private *dev_priv = to_i915(plane->dev);
        struct drm_framebuffer *fb = new_plane_state->hw.fb;
        struct drm_i915_gem_object *obj = intel_fb_obj(fb);
                }
        }
 
-       if (new_plane_state->base.fence) { /* explicit fencing */
+       if (new_plane_state->uapi.fence) { /* explicit fencing */
                ret = i915_sw_fence_await_dma_fence(&intel_state->commit_ready,
-                                                   new_plane_state->base.fence,
+                                                   new_plane_state->uapi.fence,
                                                    I915_FENCE_TIMEOUT,
                                                    GFP_KERNEL);
                if (ret < 0)
        fb_obj_bump_render_priority(obj);
        intel_frontbuffer_flush(obj->frontbuffer, ORIGIN_DIRTYFB);
 
-       if (!new_plane_state->base.fence) { /* implicit fencing */
+       if (!new_plane_state->uapi.fence) { /* implicit fencing */
                struct dma_fence *fence;
 
                ret = i915_sw_fence_await_reservation(&intel_state->commit_ready,
                }
        } else {
                add_rps_boost_after_vblank(new_plane_state->hw.crtc,
-                                          new_plane_state->base.fence);
+                                          new_plane_state->uapi.fence);
        }
 
        /*
        struct intel_plane_state *old_plane_state =
                to_intel_plane_state(_old_plane_state);
        struct intel_atomic_state *intel_state =
-               to_intel_atomic_state(old_plane_state->base.state);
+               to_intel_atomic_state(old_plane_state->uapi.state);
        struct drm_i915_private *dev_priv = to_i915(plane->dev);
 
        if (intel_state->rps_interactive) {
         * the plane.  This prevents our async update's changes from getting
         * overridden by a previous synchronous update's state.
         */
-       if (old_plane_state->base.commit &&
-           !try_wait_for_completion(&old_plane_state->base.commit->hw_done))
+       if (old_plane_state->uapi.commit &&
+           !try_wait_for_completion(&old_plane_state->uapi.commit->hw_done))
                goto slow;
 
        /*
                        const struct intel_plane_state *plane_state =
                                to_intel_plane_state(plane->base.state);
 
-                       if (plane_state->base.visible &&
+                       if (plane_state->uapi.visible &&
                            plane->base.type != DRM_PLANE_TYPE_PRIMARY)
                                intel_plane_disable_noatomic(crtc, plane);
                }
                         * FIXME don't have the fb yet, so can't
                         * use intel_plane_data_rate() :(
                         */
-                       if (plane_state->base.visible)
+                       if (plane_state->uapi.visible)
                                crtc_state->data_rate[plane->id] =
                                        4 * crtc_state->pixel_rate;
                        /*
                         * FIXME don't have the fb yet, so can't
                         * use plane->min_cdclk() :(
                         */
-                       if (plane_state->base.visible && plane->min_cdclk) {
+                       if (plane_state->uapi.visible && plane->min_cdclk) {
                                if (crtc_state->double_wide ||
                                    INTEL_GEN(dev_priv) >= 10 || IS_GEMINILAKE(dev_priv))
                                        crtc_state->min_cdclk[plane->id] =
 
 
 int intel_plane_check_stride(const struct intel_plane_state *plane_state)
 {
-       struct intel_plane *plane = to_intel_plane(plane_state->base.plane);
+       struct intel_plane *plane = to_intel_plane(plane_state->uapi.plane);
        const struct drm_framebuffer *fb = plane_state->hw.fb;
        unsigned int rotation = plane_state->hw.rotation;
        u32 stride, max_stride;
         * kick in due the plane being invisible.
         */
        if (intel_plane_can_remap(plane_state) &&
-           !plane_state->base.visible)
+           !plane_state->uapi.visible)
                return 0;
 
        /* FIXME other color planes? */
 int intel_plane_check_src_coordinates(struct intel_plane_state *plane_state)
 {
        const struct drm_framebuffer *fb = plane_state->hw.fb;
-       struct drm_rect *src = &plane_state->base.src;
+       struct drm_rect *src = &plane_state->uapi.src;
        u32 src_x, src_y, src_w, src_h, hsub, vsub;
        bool rotated = drm_rotation_90_or_270(plane_state->hw.rotation);
 
                const struct intel_plane_state *plane_state,
                unsigned int *num, unsigned int *den)
 {
-       struct drm_i915_private *dev_priv = to_i915(plane_state->base.plane->dev);
+       struct drm_i915_private *dev_priv = to_i915(plane_state->uapi.plane->dev);
        const struct drm_framebuffer *fb = plane_state->hw.fb;
 
        if (fb->format->cpp[0] == 8) {
 static int skl_plane_min_cdclk(const struct intel_crtc_state *crtc_state,
                               const struct intel_plane_state *plane_state)
 {
-       struct drm_i915_private *dev_priv = to_i915(plane_state->base.plane->dev);
+       struct drm_i915_private *dev_priv = to_i915(plane_state->uapi.plane->dev);
        unsigned int pixel_rate = crtc_state->pixel_rate;
        unsigned int src_w, src_h, dst_w, dst_h;
        unsigned int num, den;
        if (INTEL_GEN(dev_priv) >= 10 || IS_GEMINILAKE(dev_priv))
                den *= 2;
 
-       src_w = drm_rect_width(&plane_state->base.src) >> 16;
-       src_h = drm_rect_height(&plane_state->base.src) >> 16;
-       dst_w = drm_rect_width(&plane_state->base.dst);
-       dst_h = drm_rect_height(&plane_state->base.dst);
+       src_w = drm_rect_width(&plane_state->uapi.src) >> 16;
+       src_h = drm_rect_height(&plane_state->uapi.src) >> 16;
+       dst_w = drm_rect_width(&plane_state->uapi.dst);
+       dst_h = drm_rect_height(&plane_state->uapi.dst);
 
        /* Downscaling limits the maximum pixel rate */
        dst_w = min(src_w, dst_w);
        int scaler_id = plane_state->scaler_id;
        const struct intel_scaler *scaler =
                &crtc_state->scaler_state.scalers[scaler_id];
-       int crtc_x = plane_state->base.dst.x1;
-       int crtc_y = plane_state->base.dst.y1;
-       u32 crtc_w = drm_rect_width(&plane_state->base.dst);
-       u32 crtc_h = drm_rect_height(&plane_state->base.dst);
+       int crtc_x = plane_state->uapi.dst.x1;
+       int crtc_y = plane_state->uapi.dst.y1;
+       u32 crtc_w = drm_rect_width(&plane_state->uapi.dst);
+       u32 crtc_h = drm_rect_height(&plane_state->uapi.dst);
        u16 y_hphase, uv_rgb_hphase;
        u16 y_vphase, uv_rgb_vphase;
        int hscale, vscale;
 
-       hscale = drm_rect_calc_hscale(&plane_state->base.src,
-                                     &plane_state->base.dst,
+       hscale = drm_rect_calc_hscale(&plane_state->uapi.src,
+                                     &plane_state->uapi.dst,
                                      0, INT_MAX);
-       vscale = drm_rect_calc_vscale(&plane_state->base.src,
-                                     &plane_state->base.dst,
+       vscale = drm_rect_calc_vscale(&plane_state->uapi.src,
+                                     &plane_state->uapi.dst,
                                      0, INT_MAX);
 
        /* TODO: handle sub-pixel coordinates */
        u32 surf_addr = plane_state->color_plane[color_plane].offset;
        u32 stride = skl_plane_stride(plane_state, color_plane);
        u32 aux_stride = skl_plane_stride(plane_state, 1);
-       int crtc_x = plane_state->base.dst.x1;
-       int crtc_y = plane_state->base.dst.y1;
+       int crtc_x = plane_state->uapi.dst.x1;
+       int crtc_y = plane_state->uapi.dst.y1;
        u32 x = plane_state->color_plane[color_plane].x;
        u32 y = plane_state->color_plane[color_plane].y;
-       u32 src_w = drm_rect_width(&plane_state->base.src) >> 16;
-       u32 src_h = drm_rect_height(&plane_state->base.src) >> 16;
+       u32 src_w = drm_rect_width(&plane_state->uapi.src) >> 16;
+       u32 src_h = drm_rect_height(&plane_state->uapi.src) >> 16;
        struct intel_plane *linked = plane_state->planar_linked_plane;
        const struct drm_framebuffer *fb = plane_state->hw.fb;
        u8 alpha = plane_state->hw.alpha >> 8;
 static void
 chv_update_csc(const struct intel_plane_state *plane_state)
 {
-       struct intel_plane *plane = to_intel_plane(plane_state->base.plane);
+       struct intel_plane *plane = to_intel_plane(plane_state->uapi.plane);
        struct drm_i915_private *dev_priv = to_i915(plane->base.dev);
        const struct drm_framebuffer *fb = plane_state->hw.fb;
        enum plane_id plane_id = plane->id;
 static void
 vlv_update_clrc(const struct intel_plane_state *plane_state)
 {
-       struct intel_plane *plane = to_intel_plane(plane_state->base.plane);
+       struct intel_plane *plane = to_intel_plane(plane_state->uapi.plane);
        struct drm_i915_private *dev_priv = to_i915(plane->base.dev);
        const struct drm_framebuffer *fb = plane_state->hw.fb;
        enum pipe pipe = plane->pipe;
 
 static void vlv_update_gamma(const struct intel_plane_state *plane_state)
 {
-       struct intel_plane *plane = to_intel_plane(plane_state->base.plane);
+       struct intel_plane *plane = to_intel_plane(plane_state->uapi.plane);
        struct drm_i915_private *dev_priv = to_i915(plane->base.dev);
        const struct drm_framebuffer *fb = plane_state->hw.fb;
        enum pipe pipe = plane->pipe;
        u32 sprsurf_offset = plane_state->color_plane[0].offset;
        u32 linear_offset;
        const struct drm_intel_sprite_colorkey *key = &plane_state->ckey;
-       int crtc_x = plane_state->base.dst.x1;
-       int crtc_y = plane_state->base.dst.y1;
-       u32 crtc_w = drm_rect_width(&plane_state->base.dst);
-       u32 crtc_h = drm_rect_height(&plane_state->base.dst);
+       int crtc_x = plane_state->uapi.dst.x1;
+       int crtc_y = plane_state->uapi.dst.y1;
+       u32 crtc_w = drm_rect_width(&plane_state->uapi.dst);
+       u32 crtc_h = drm_rect_height(&plane_state->uapi.dst);
        u32 x = plane_state->color_plane[0].x;
        u32 y = plane_state->color_plane[0].y;
        unsigned long irqflags;
         */
        pixel_rate = crtc_state->pixel_rate;
 
-       src_w = drm_rect_width(&plane_state->base.src) >> 16;
-       dst_w = drm_rect_width(&plane_state->base.dst);
+       src_w = drm_rect_width(&plane_state->uapi.src) >> 16;
+       dst_w = drm_rect_width(&plane_state->uapi.dst);
 
        if (src_w != dst_w)
                ivb_plane_ratio_scaling(crtc_state, plane_state, &num, &den);
 static bool ivb_need_sprite_gamma(const struct intel_plane_state *plane_state)
 {
        struct drm_i915_private *dev_priv =
-               to_i915(plane_state->base.plane->dev);
+               to_i915(plane_state->uapi.plane->dev);
        const struct drm_framebuffer *fb = plane_state->hw.fb;
 
        return fb->format->cpp[0] == 8 &&
                          const struct intel_plane_state *plane_state)
 {
        struct drm_i915_private *dev_priv =
-               to_i915(plane_state->base.plane->dev);
+               to_i915(plane_state->uapi.plane->dev);
        const struct drm_framebuffer *fb = plane_state->hw.fb;
        unsigned int rotation = plane_state->hw.rotation;
        const struct drm_intel_sprite_colorkey *key = &plane_state->ckey;
 
 static void ivb_update_gamma(const struct intel_plane_state *plane_state)
 {
-       struct intel_plane *plane = to_intel_plane(plane_state->base.plane);
+       struct intel_plane *plane = to_intel_plane(plane_state->uapi.plane);
        struct drm_i915_private *dev_priv = to_i915(plane->base.dev);
        enum pipe pipe = plane->pipe;
        u16 gamma[18];
        u32 sprsurf_offset = plane_state->color_plane[0].offset;
        u32 linear_offset;
        const struct drm_intel_sprite_colorkey *key = &plane_state->ckey;
-       int crtc_x = plane_state->base.dst.x1;
-       int crtc_y = plane_state->base.dst.y1;
-       u32 crtc_w = drm_rect_width(&plane_state->base.dst);
-       u32 crtc_h = drm_rect_height(&plane_state->base.dst);
+       int crtc_x = plane_state->uapi.dst.x1;
+       int crtc_y = plane_state->uapi.dst.y1;
+       u32 crtc_w = drm_rect_width(&plane_state->uapi.dst);
+       u32 crtc_h = drm_rect_height(&plane_state->uapi.dst);
        u32 x = plane_state->color_plane[0].x;
        u32 y = plane_state->color_plane[0].y;
-       u32 src_w = drm_rect_width(&plane_state->base.src) >> 16;
-       u32 src_h = drm_rect_height(&plane_state->base.src) >> 16;
+       u32 src_w = drm_rect_width(&plane_state->uapi.src) >> 16;
+       u32 src_h = drm_rect_height(&plane_state->uapi.src) >> 16;
        u32 sprctl, sprscale = 0;
        unsigned long irqflags;
 
        pixel_rate = crtc_state->pixel_rate;
 
        /* Horizontal downscaling limits the maximum pixel rate */
-       hscale = drm_rect_calc_hscale(&plane_state->base.src,
-                                     &plane_state->base.dst,
+       hscale = drm_rect_calc_hscale(&plane_state->uapi.src,
+                                     &plane_state->uapi.dst,
                                      0, INT_MAX);
        if (hscale < 0x10000)
                return pixel_rate;
                          const struct intel_plane_state *plane_state)
 {
        struct drm_i915_private *dev_priv =
-               to_i915(plane_state->base.plane->dev);
+               to_i915(plane_state->uapi.plane->dev);
        const struct drm_framebuffer *fb = plane_state->hw.fb;
        unsigned int rotation = plane_state->hw.rotation;
        const struct drm_intel_sprite_colorkey *key = &plane_state->ckey;
 
 static void g4x_update_gamma(const struct intel_plane_state *plane_state)
 {
-       struct intel_plane *plane = to_intel_plane(plane_state->base.plane);
+       struct intel_plane *plane = to_intel_plane(plane_state->uapi.plane);
        struct drm_i915_private *dev_priv = to_i915(plane->base.dev);
        const struct drm_framebuffer *fb = plane_state->hw.fb;
        enum pipe pipe = plane->pipe;
 
 static void ilk_update_gamma(const struct intel_plane_state *plane_state)
 {
-       struct intel_plane *plane = to_intel_plane(plane_state->base.plane);
+       struct intel_plane *plane = to_intel_plane(plane_state->uapi.plane);
        struct drm_i915_private *dev_priv = to_i915(plane->base.dev);
        const struct drm_framebuffer *fb = plane_state->hw.fb;
        enum pipe pipe = plane->pipe;
        u32 dvssurf_offset = plane_state->color_plane[0].offset;
        u32 linear_offset;
        const struct drm_intel_sprite_colorkey *key = &plane_state->ckey;
-       int crtc_x = plane_state->base.dst.x1;
-       int crtc_y = plane_state->base.dst.y1;
-       u32 crtc_w = drm_rect_width(&plane_state->base.dst);
-       u32 crtc_h = drm_rect_height(&plane_state->base.dst);
+       int crtc_x = plane_state->uapi.dst.x1;
+       int crtc_y = plane_state->uapi.dst.y1;
+       u32 crtc_w = drm_rect_width(&plane_state->uapi.dst);
+       u32 crtc_h = drm_rect_height(&plane_state->uapi.dst);
        u32 x = plane_state->color_plane[0].x;
        u32 y = plane_state->color_plane[0].y;
-       u32 src_w = drm_rect_width(&plane_state->base.src) >> 16;
-       u32 src_h = drm_rect_height(&plane_state->base.src) >> 16;
+       u32 src_w = drm_rect_width(&plane_state->uapi.src) >> 16;
+       u32 src_h = drm_rect_height(&plane_state->uapi.src) >> 16;
        u32 dvscntr, dvsscale = 0;
        unsigned long irqflags;
 
                         struct intel_plane_state *plane_state)
 {
        const struct drm_framebuffer *fb = plane_state->hw.fb;
-       const struct drm_rect *src = &plane_state->base.src;
-       const struct drm_rect *dst = &plane_state->base.dst;
+       const struct drm_rect *src = &plane_state->uapi.src;
+       const struct drm_rect *dst = &plane_state->uapi.dst;
        int src_x, src_w, src_h, crtc_w, crtc_h;
        const struct drm_display_mode *adjusted_mode =
                &crtc_state->hw.adjusted_mode;
 g4x_sprite_check(struct intel_crtc_state *crtc_state,
                 struct intel_plane_state *plane_state)
 {
-       struct intel_plane *plane = to_intel_plane(plane_state->base.plane);
+       struct intel_plane *plane = to_intel_plane(plane_state->uapi.plane);
        struct drm_i915_private *dev_priv = to_i915(plane->base.dev);
        int min_scale = DRM_PLANE_HELPER_NO_SCALING;
        int max_scale = DRM_PLANE_HELPER_NO_SCALING;
                }
        }
 
-       ret = drm_atomic_helper_check_plane_state(&plane_state->base,
+       ret = drm_atomic_helper_check_plane_state(&plane_state->uapi,
                                                  &crtc_state->uapi,
                                                  min_scale, max_scale,
                                                  true, true);
        if (ret)
                return ret;
 
-       if (!plane_state->base.visible)
+       if (!plane_state->uapi.visible)
                return 0;
 
        ret = intel_plane_check_src_coordinates(plane_state);
 
 int chv_plane_check_rotation(const struct intel_plane_state *plane_state)
 {
-       struct intel_plane *plane = to_intel_plane(plane_state->base.plane);
+       struct intel_plane *plane = to_intel_plane(plane_state->uapi.plane);
        struct drm_i915_private *dev_priv = to_i915(plane->base.dev);
        unsigned int rotation = plane_state->hw.rotation;
 
        if (ret)
                return ret;
 
-       ret = drm_atomic_helper_check_plane_state(&plane_state->base,
+       ret = drm_atomic_helper_check_plane_state(&plane_state->uapi,
                                                  &crtc_state->uapi,
                                                  DRM_PLANE_HELPER_NO_SCALING,
                                                  DRM_PLANE_HELPER_NO_SCALING,
        if (ret)
                return ret;
 
-       if (!plane_state->base.visible)
+       if (!plane_state->uapi.visible)
                return 0;
 
        ret = intel_plane_check_src_coordinates(plane_state);
 static int skl_plane_check_fb(const struct intel_crtc_state *crtc_state,
                              const struct intel_plane_state *plane_state)
 {
-       struct intel_plane *plane = to_intel_plane(plane_state->base.plane);
+       struct intel_plane *plane = to_intel_plane(plane_state->uapi.plane);
        struct drm_i915_private *dev_priv = to_i915(plane->base.dev);
        const struct drm_framebuffer *fb = plane_state->hw.fb;
        unsigned int rotation = plane_state->hw.rotation;
                                           const struct intel_plane_state *plane_state)
 {
        struct drm_i915_private *dev_priv =
-               to_i915(plane_state->base.plane->dev);
-       int crtc_x = plane_state->base.dst.x1;
-       int crtc_w = drm_rect_width(&plane_state->base.dst);
+               to_i915(plane_state->uapi.plane->dev);
+       int crtc_x = plane_state->uapi.dst.x1;
+       int crtc_w = drm_rect_width(&plane_state->uapi.dst);
        int pipe_src_w = crtc_state->pipe_src_w;
 
        /*
 {
        const struct drm_framebuffer *fb = plane_state->hw.fb;
        unsigned int rotation = plane_state->hw.rotation;
-       int src_w = drm_rect_width(&plane_state->base.src) >> 16;
+       int src_w = drm_rect_width(&plane_state->uapi.src) >> 16;
 
        /* Display WA #1106 */
        if (drm_format_info_is_yuv_semiplanar(fb->format) && src_w & 3 &&
 static int skl_plane_check(struct intel_crtc_state *crtc_state,
                           struct intel_plane_state *plane_state)
 {
-       struct intel_plane *plane = to_intel_plane(plane_state->base.plane);
+       struct intel_plane *plane = to_intel_plane(plane_state->uapi.plane);
        struct drm_i915_private *dev_priv = to_i915(plane->base.dev);
        const struct drm_framebuffer *fb = plane_state->hw.fb;
        int min_scale = DRM_PLANE_HELPER_NO_SCALING;
                max_scale = skl_plane_max_scale(dev_priv, fb);
        }
 
-       ret = drm_atomic_helper_check_plane_state(&plane_state->base,
+       ret = drm_atomic_helper_check_plane_state(&plane_state->uapi,
                                                  &crtc_state->uapi,
                                                  min_scale, max_scale,
                                                  true, true);
        if (ret)
                return ret;
 
-       if (!plane_state->base.visible)
+       if (!plane_state->uapi.visible)
                return 0;
 
        ret = skl_plane_check_dst_coordinates(crtc_state, plane_state);
 
        /* HW only has 8 bits pixel precision, disable plane if invisible */
        if (!(plane_state->hw.alpha >> 8))
-               plane_state->base.visible = false;
+               plane_state->uapi.visible = false;
 
        plane_state->ctl = skl_plane_ctl(crtc_state, plane_state);
 
 static void intel_plane_set_ckey(struct intel_plane_state *plane_state,
                                 const struct drm_intel_sprite_colorkey *set)
 {
-       struct intel_plane *plane = to_intel_plane(plane_state->base.plane);
+       struct intel_plane *plane = to_intel_plane(plane_state->uapi.plane);
        struct drm_i915_private *dev_priv = to_i915(plane->base.dev);
        struct drm_intel_sprite_colorkey *key = &plane_state->ckey;
 
 
 static bool intel_wm_plane_visible(const struct intel_crtc_state *crtc_state,
                                   const struct intel_plane_state *plane_state)
 {
-       struct intel_plane *plane = to_intel_plane(plane_state->base.plane);
+       struct intel_plane *plane = to_intel_plane(plane_state->uapi.plane);
 
        /* FIXME check the 'enable' instead */
        if (!crtc_state->hw.active)
        if (plane->id == PLANE_CURSOR)
                return plane_state->hw.fb != NULL;
        else
-               return plane_state->base.visible;
+               return plane_state->uapi.visible;
 }
 
 static struct intel_crtc *single_enabled_crtc(struct drm_i915_private *dev_priv)
                          const struct intel_plane_state *plane_state,
                          int level)
 {
-       struct intel_plane *plane = to_intel_plane(plane_state->base.plane);
+       struct intel_plane *plane = to_intel_plane(plane_state->uapi.plane);
        struct drm_i915_private *dev_priv = to_i915(plane->base.dev);
        const struct drm_display_mode *adjusted_mode =
                &crtc_state->hw.adjusted_mode;
        clock = adjusted_mode->crtc_clock;
        htotal = adjusted_mode->crtc_htotal;
 
-       width = drm_rect_width(&plane_state->base.dst);
+       width = drm_rect_width(&plane_state->uapi.dst);
 
        if (plane->id == PLANE_CURSOR) {
                wm = intel_wm_method2(clock, htotal, width, cpp, latency);
 static bool g4x_raw_plane_wm_compute(struct intel_crtc_state *crtc_state,
                                     const struct intel_plane_state *plane_state)
 {
-       struct intel_plane *plane = to_intel_plane(plane_state->base.plane);
+       struct intel_plane *plane = to_intel_plane(plane_state->uapi.plane);
        int num_levels = intel_wm_num_levels(to_i915(plane->base.dev));
        enum plane_id plane_id = plane->id;
        bool dirty = false;
                                const struct intel_plane_state *plane_state,
                                int level)
 {
-       struct intel_plane *plane = to_intel_plane(plane_state->base.plane);
+       struct intel_plane *plane = to_intel_plane(plane_state->uapi.plane);
        struct drm_i915_private *dev_priv = to_i915(plane->base.dev);
        const struct drm_display_mode *adjusted_mode =
                &crtc_state->hw.adjusted_mode;
 static bool vlv_raw_plane_wm_compute(struct intel_crtc_state *crtc_state,
                                     const struct intel_plane_state *plane_state)
 {
-       struct intel_plane *plane = to_intel_plane(plane_state->base.plane);
+       struct intel_plane *plane = to_intel_plane(plane_state->uapi.plane);
        enum plane_id plane_id = plane->id;
        int num_levels = intel_wm_num_levels(to_i915(plane->base.dev));
        int level;
 
        method2 = ilk_wm_method2(crtc_state->pixel_rate,
                                 crtc_state->hw.adjusted_mode.crtc_htotal,
-                                drm_rect_width(&plane_state->base.dst),
+                                drm_rect_width(&plane_state->uapi.dst),
                                 cpp, mem_value);
 
        return min(method1, method2);
        method1 = ilk_wm_method1(crtc_state->pixel_rate, cpp, mem_value);
        method2 = ilk_wm_method2(crtc_state->pixel_rate,
                                 crtc_state->hw.adjusted_mode.crtc_htotal,
-                                drm_rect_width(&plane_state->base.dst),
+                                drm_rect_width(&plane_state->uapi.dst),
                                 cpp, mem_value);
        return min(method1, method2);
 }
 
        return ilk_wm_method2(crtc_state->pixel_rate,
                              crtc_state->hw.adjusted_mode.crtc_htotal,
-                             drm_rect_width(&plane_state->base.dst),
+                             drm_rect_width(&plane_state->uapi.dst),
                              cpp, mem_value);
 }
 
 
        cpp = plane_state->hw.fb->format->cpp[0];
 
-       return ilk_wm_fbc(pri_val, drm_rect_width(&plane_state->base.dst), cpp);
+       return ilk_wm_fbc(pri_val, drm_rect_width(&plane_state->uapi.dst),
+                         cpp);
 }
 
 static unsigned int
 
        pipe_wm->pipe_enabled = crtc_state->hw.active;
        if (sprstate) {
-               pipe_wm->sprites_enabled = sprstate->base.visible;
-               pipe_wm->sprites_scaled = sprstate->base.visible &&
-                       (drm_rect_width(&sprstate->base.dst) != drm_rect_width(&sprstate->base.src) >> 16 ||
-                        drm_rect_height(&sprstate->base.dst) != drm_rect_height(&sprstate->base.src) >> 16);
+               pipe_wm->sprites_enabled = sprstate->uapi.visible;
+               pipe_wm->sprites_scaled = sprstate->uapi.visible &&
+                       (drm_rect_width(&sprstate->uapi.dst) != drm_rect_width(&sprstate->uapi.src) >> 16 ||
+                        drm_rect_height(&sprstate->uapi.dst) != drm_rect_height(&sprstate->uapi.src) >> 16);
        }
 
        usable_level = max_level;
         *
         * n.b., src is 16.16 fixed point, dst is whole integer.
         */
-       src_w = drm_rect_width(&plane_state->base.src) >> 16;
-       src_h = drm_rect_height(&plane_state->base.src) >> 16;
-       dst_w = drm_rect_width(&plane_state->base.dst);
-       dst_h = drm_rect_height(&plane_state->base.dst);
+       src_w = drm_rect_width(&plane_state->uapi.src) >> 16;
+       src_h = drm_rect_height(&plane_state->uapi.src) >> 16;
+       dst_w = drm_rect_width(&plane_state->uapi.dst);
+       dst_h = drm_rect_height(&plane_state->uapi.dst);
 
        fp_w_ratio = div_fixed16(src_w, dst_w);
        fp_h_ratio = div_fixed16(src_h, dst_h);
                             const struct intel_plane_state *plane_state,
                             int color_plane)
 {
-       struct intel_plane *plane = to_intel_plane(plane_state->base.plane);
+       struct intel_plane *plane = to_intel_plane(plane_state->uapi.plane);
        const struct drm_framebuffer *fb = plane_state->hw.fb;
        u32 data_rate;
        u32 width = 0, height = 0;
        uint_fixed_16_16_t down_scale_amount;
        u64 rate;
 
-       if (!plane_state->base.visible)
+       if (!plane_state->uapi.visible)
                return 0;
 
        if (plane->id == PLANE_CURSOR)
         * the 90/270 degree plane rotation cases (to match the
         * GTT mapping), hence no need to account for rotation here.
         */
-       width = drm_rect_width(&plane_state->base.src) >> 16;
-       height = drm_rect_height(&plane_state->base.src) >> 16;
+       width = drm_rect_width(&plane_state->uapi.src) >> 16;
+       height = drm_rect_height(&plane_state->uapi.src) >> 16;
 
        /* UV plane does 1/2 pixel sub-sampling */
        if (color_plane == 1) {
         * the 90/270 degree plane rotation cases (to match the
         * GTT mapping), hence no need to account for rotation here.
         */
-       width = drm_rect_width(&plane_state->base.src) >> 16;
+       width = drm_rect_width(&plane_state->uapi.src) >> 16;
 
        return skl_compute_wm_params(crtc_state, width,
                                     fb->format, fb->modifier,
 static int skl_build_plane_wm(struct intel_crtc_state *crtc_state,
                              const struct intel_plane_state *plane_state)
 {
-       struct intel_plane *plane = to_intel_plane(plane_state->base.plane);
+       struct intel_plane *plane = to_intel_plane(plane_state->uapi.plane);
        const struct drm_framebuffer *fb = plane_state->hw.fb;
        enum plane_id plane_id = plane->id;
        int ret;
 static int icl_build_plane_wm(struct intel_crtc_state *crtc_state,
                              const struct intel_plane_state *plane_state)
 {
-       enum plane_id plane_id = to_intel_plane(plane_state->base.plane)->id;
+       enum plane_id plane_id = to_intel_plane(plane_state->uapi.plane)->id;
        int ret;
 
        /* Watermarks calculated in master */
                enum plane_id plane_id = plane->id;
                int level;
 
-               if (plane_state->base.visible)
+               if (plane_state->uapi.visible)
                        continue;
 
                for (level = 0; level < 3; level++) {
                enum plane_id plane_id = plane->id;
                int level;
 
-               if (plane_state->base.visible)
+               if (plane_state->uapi.visible)
                        continue;
 
                for (level = 0; level < wm_state->num_levels; level++) {