u32 alignment = intel_surf_alignment(fb, 0);
                int cpp = fb->format->cpp[0];
 
-               while ((src_x + src_w) * cpp > plane_state->view.color_plane[0].stride) {
+               while ((src_x + src_w) * cpp > plane_state->view.color_plane[0].mapping_stride) {
                        if (offset == 0) {
                                drm_dbg_kms(&dev_priv->drm,
                                            "Unable to find suitable display surface offset due to X-tiling\n");
        spin_lock_irqsave(&dev_priv->uncore.lock, irqflags);
 
        intel_de_write_fw(dev_priv, DSPSTRIDE(i9xx_plane),
-                         plane_state->view.color_plane[0].stride);
+                         plane_state->view.color_plane[0].mapping_stride);
 
        if (DISPLAY_VER(dev_priv) < 4) {
                /*
 
 {
        return CURSOR_ENABLE |
                CURSOR_FORMAT_ARGB |
-               CURSOR_STRIDE(plane_state->view.color_plane[0].stride);
+               CURSOR_STRIDE(plane_state->view.color_plane[0].mapping_stride);
 }
 
 static bool i845_cursor_size_ok(const struct intel_plane_state *plane_state)
        }
 
        drm_WARN_ON(&i915->drm, plane_state->uapi.visible &&
-                   plane_state->view.color_plane[0].stride != fb->pitches[0]);
+                   plane_state->view.color_plane[0].mapping_stride != fb->pitches[0]);
 
        switch (fb->pitches[0]) {
        case 256:
        }
 
        drm_WARN_ON(&dev_priv->drm, plane_state->uapi.visible &&
-                   plane_state->view.color_plane[0].stride != fb->pitches[0]);
+                   plane_state->view.color_plane[0].mapping_stride != fb->pitches[0]);
 
        if (fb->pitches[0] !=
            drm_rect_width(&plane_state->uapi.dst) * fb->format->cpp[0]) {
 
 {
        const struct drm_framebuffer *fb = state->hw.fb;
        unsigned int cpp = fb->format->cpp[color_plane];
-       unsigned int pitch = state->view.color_plane[color_plane].stride;
+       unsigned int pitch = state->view.color_plane[color_plane].mapping_stride;
 
        return y * pitch + x * cpp;
 }
                        return -EINVAL;
                }
 
-               if (old_plane_state->view.color_plane[0].stride !=
-                   new_plane_state->view.color_plane[0].stride) {
+               if (old_plane_state->view.color_plane[0].mapping_stride !=
+                   new_plane_state->view.color_plane[0].mapping_stride) {
                        drm_dbg_kms(&i915->drm, "Stride cannot be changed in async flip\n");
                        return -EINVAL;
                }
 
                 *   bytes for 0/180 degree rotation
                 *   pixels for 90/270 degree rotation
                 */
-               unsigned int stride;
+               unsigned int mapping_stride;
        } color_plane[4];
 };
 
 
 {
        return intel_adjust_aligned_offset(x, y, state->hw.fb, color_plane,
                                           state->hw.rotation,
-                                          state->view.color_plane[color_plane].stride,
+                                          state->view.color_plane[color_plane].mapping_stride,
                                           old_offset, new_offset);
 }
 
        struct drm_i915_private *i915 = to_i915(intel_plane->base.dev);
        const struct drm_framebuffer *fb = state->hw.fb;
        unsigned int rotation = state->hw.rotation;
-       int pitch = state->view.color_plane[color_plane].stride;
+       int pitch = state->view.color_plane[color_plane].mapping_stride;
        u32 alignment;
 
        if (intel_plane->id == PLANE_CURSOR)
 static int intel_fb_pitch(const struct intel_framebuffer *fb, int color_plane, unsigned int rotation)
 {
        if (drm_rotation_90_or_270(rotation))
-               return fb->rotated_view.color_plane[color_plane].stride;
+               return fb->rotated_view.color_plane[color_plane].mapping_stride;
        else if (intel_fb_needs_pot_stride_remap(fb))
-               return fb->remapped_view.color_plane[color_plane].stride;
+               return fb->remapped_view.color_plane[color_plane].mapping_stride;
        else
-               return fb->normal_view.color_plane[color_plane].stride;
+               return fb->normal_view.color_plane[color_plane].mapping_stride;
 }
 
 static bool intel_plane_needs_remap(const struct intel_plane_state *plane_state)
                color_plane_info->x = r.x1;
                color_plane_info->y = r.y1;
 
-               color_plane_info->stride = remap_info->dst_stride * tile_height;
+               color_plane_info->mapping_stride = remap_info->dst_stride * tile_height;
 
                size += remap_info->dst_stride * remap_info->width;
 
                color_plane_info->y = y;
 
                if (remap_info->linear) {
-                       color_plane_info->stride = fb->base.pitches[color_plane];
+                       color_plane_info->mapping_stride = fb->base.pitches[color_plane];
 
                        size += remap_info->size;
                } else {
                                                                              remap_info->width);
 
                        assign_chk_ovf(i915, remap_info->dst_stride, dst_stride);
-                       color_plane_info->stride = dst_stride *
-                                                  tile_width * fb->base.format->cpp[color_plane];
+                       color_plane_info->mapping_stride = dst_stride *
+                                                          tile_width *
+                                                          fb->base.format->cpp[color_plane];
 
                        size += dst_stride * remap_info->height;
                }
        if (remap_info->linear)
                intel_adjust_linear_offset(&color_plane_info->x, &color_plane_info->y,
                                           fb->base.format->cpp[color_plane],
-                                          color_plane_info->stride,
+                                          color_plane_info->mapping_stride,
                                           gtt_offset * tile_size, 0);
        else
                intel_adjust_tile_offset(&color_plane_info->x, &color_plane_info->y,
                 */
                fb->normal_view.color_plane[i].x = x;
                fb->normal_view.color_plane[i].y = y;
-               fb->normal_view.color_plane[i].stride = fb->base.pitches[i];
+               fb->normal_view.color_plane[i].mapping_stride = fb->base.pitches[i];
 
                offset = calc_plane_aligned_offset(fb, i, &x, &y);
 
                return 0;
 
        /* FIXME other color planes? */
-       stride = plane_state->view.color_plane[0].stride;
+       stride = plane_state->view.color_plane[0].mapping_stride;
        max_stride = plane->max_stride(plane, fb->format->format,
                                       fb->modifier, rotation);
 
 
        const struct drm_framebuffer *fb = plane_state->hw.fb;
        unsigned int stride;
 
-       stride = plane_state->view.color_plane[0].stride;
+       stride = plane_state->view.color_plane[0].mapping_stride;
        if (!drm_rotation_90_or_270(plane_state->hw.rotation))
                stride /= fb->format->cpp[0];
 
 
        spin_lock_irqsave(&dev_priv->uncore.lock, irqflags);
 
        intel_de_write_fw(dev_priv, SPSTRIDE(pipe, plane_id),
-                         plane_state->view.color_plane[0].stride);
+                         plane_state->view.color_plane[0].mapping_stride);
        intel_de_write_fw(dev_priv, SPPOS(pipe, plane_id),
                          (crtc_y << 16) | crtc_x);
        intel_de_write_fw(dev_priv, SPSIZE(pipe, plane_id),
        spin_lock_irqsave(&dev_priv->uncore.lock, irqflags);
 
        intel_de_write_fw(dev_priv, SPRSTRIDE(pipe),
-                         plane_state->view.color_plane[0].stride);
+                         plane_state->view.color_plane[0].mapping_stride);
        intel_de_write_fw(dev_priv, SPRPOS(pipe), (crtc_y << 16) | crtc_x);
        intel_de_write_fw(dev_priv, SPRSIZE(pipe), (crtc_h << 16) | crtc_w);
        if (IS_IVYBRIDGE(dev_priv))
        spin_lock_irqsave(&dev_priv->uncore.lock, irqflags);
 
        intel_de_write_fw(dev_priv, DVSSTRIDE(pipe),
-                         plane_state->view.color_plane[0].stride);
+                         plane_state->view.color_plane[0].mapping_stride);
        intel_de_write_fw(dev_priv, DVSPOS(pipe), (crtc_y << 16) | crtc_x);
        intel_de_write_fw(dev_priv, DVSSIZE(pipe), (crtc_h << 16) | crtc_w);
        intel_de_write_fw(dev_priv, DVSSCALE(pipe), dvsscale);
        int src_x, src_w, src_h, crtc_w, crtc_h;
        const struct drm_display_mode *adjusted_mode =
                &crtc_state->hw.adjusted_mode;
-       unsigned int stride = plane_state->view.color_plane[0].stride;
+       unsigned int stride = plane_state->view.color_plane[0].mapping_stride;
        unsigned int cpp = fb->format->cpp[0];
        unsigned int width_bytes;
        int min_width, min_height;
 
 {
        const struct drm_framebuffer *fb = plane_state->hw.fb;
        unsigned int rotation = plane_state->hw.rotation;
-       u32 stride = plane_state->view.color_plane[color_plane].stride;
+       u32 stride = plane_state->view.color_plane[color_plane].mapping_stride;
 
        if (color_plane >= fb->format->num_planes)
                return 0;
        if (fb->modifier == I915_FORMAT_MOD_X_TILED) {
                int cpp = fb->format->cpp[0];
 
-               while ((*x + w) * cpp > plane_state->view.color_plane[0].stride) {
+               while ((*x + w) * cpp > plane_state->view.color_plane[0].mapping_stride) {
                        if (*offset == 0) {
                                drm_dbg_kms(&dev_priv->drm,
                                            "Unable to find suitable display surface offset due to X-tiling\n");