if (test_bit(BIT_SUSPENDED, &ctx->flags))
                return;
 
-       decon_shadow_protect_win(ctx, plane->zpos, true);
+       decon_shadow_protect_win(ctx, plane->index, true);
 }
 
 #define BIT_VAL(x, e, s) (((x) & ((1 << ((e) - (s) + 1)) - 1)) << (s))
                                to_exynos_plane_state(plane->base.state);
        struct decon_context *ctx = crtc->ctx;
        struct drm_framebuffer *fb = state->base.fb;
-       unsigned int win = plane->zpos;
+       unsigned int win = plane->index;
        unsigned int bpp = fb->bits_per_pixel >> 3;
        unsigned int pitch = fb->pitches[0];
        dma_addr_t dma_addr = exynos_drm_fb_dma_addr(fb, 0);
                                struct exynos_drm_plane *plane)
 {
        struct decon_context *ctx = crtc->ctx;
-       unsigned int win = plane->zpos;
+       unsigned int win = plane->index;
 
        if (test_bit(BIT_SUSPENDED, &ctx->flags))
                return;
        if (test_bit(BIT_SUSPENDED, &ctx->flags))
                return;
 
-       decon_shadow_protect_win(ctx, plane->zpos, false);
+       decon_shadow_protect_win(ctx, plane->index, false);
 
        if (ctx->out_type == IFTYPE_I80)
                set_bit(BIT_WIN_UPDATED, &ctx->flags);
                ctx->configs[win].zpos = win;
                ctx->configs[win].type = decon_win_types[tmp];
 
-               ret = exynos_plane_init(drm_dev, &ctx->planes[win],
+               ret = exynos_plane_init(drm_dev, &ctx->planes[win], win,
                                        1 << ctx->pipe, &ctx->configs[win]);
                if (ret)
                        return ret;
 
        if (ctx->suspended)
                return;
 
-       decon_shadow_protect_win(ctx, plane->zpos, true);
+       decon_shadow_protect_win(ctx, plane->index, true);
 }
 
 static void decon_update_plane(struct exynos_drm_crtc *crtc,
        unsigned long val, alpha;
        unsigned int last_x;
        unsigned int last_y;
-       unsigned int win = plane->zpos;
+       unsigned int win = plane->index;
        unsigned int bpp = fb->bits_per_pixel >> 3;
        unsigned int pitch = fb->pitches[0];
 
                                struct exynos_drm_plane *plane)
 {
        struct decon_context *ctx = crtc->ctx;
-       unsigned int win = plane->zpos;
+       unsigned int win = plane->index;
        u32 val;
 
        if (ctx->suspended)
        if (ctx->suspended)
                return;
 
-       decon_shadow_protect_win(ctx, plane->zpos, false);
+       decon_shadow_protect_win(ctx, plane->index, false);
 }
 
 static void decon_init(struct decon_context *ctx)
                ctx->configs[i].zpos = i;
                ctx->configs[i].type = decon_win_types[i];
 
-               ret = exynos_plane_init(drm_dev, &ctx->planes[i],
+               ret = exynos_plane_init(drm_dev, &ctx->planes[i], i,
                                        1 << ctx->pipe, &ctx->configs[i]);
                if (ret)
                        return ret;
 
  * Exynos drm common overlay structure.
  *
  * @base: plane object
- * @zpos: order of overlay layer(z position).
+ * @index: hardware index of the overlay layer
  *
  * this structure is common to exynos SoC and its contents would be copied
  * to hardware specific overlay info.
 struct exynos_drm_plane {
        struct drm_plane base;
        const struct exynos_drm_plane_config *config;
-       unsigned int zpos;
+       unsigned int index;
        struct drm_framebuffer *pending_fb;
 };
 
 
        if (ctx->suspended)
                return;
 
-       fimd_shadow_protect_win(ctx, plane->zpos, true);
+       fimd_shadow_protect_win(ctx, plane->index, true);
 }
 
 static void fimd_atomic_flush(struct exynos_drm_crtc *crtc,
        if (ctx->suspended)
                return;
 
-       fimd_shadow_protect_win(ctx, plane->zpos, false);
+       fimd_shadow_protect_win(ctx, plane->index, false);
 }
 
 static void fimd_update_plane(struct exynos_drm_crtc *crtc,
        dma_addr_t dma_addr;
        unsigned long val, size, offset;
        unsigned int last_x, last_y, buf_offsize, line_size;
-       unsigned int win = plane->zpos;
+       unsigned int win = plane->index;
        unsigned int bpp = fb->bits_per_pixel >> 3;
        unsigned int pitch = fb->pitches[0];
 
                               struct exynos_drm_plane *plane)
 {
        struct fimd_context *ctx = crtc->ctx;
-       unsigned int win = plane->zpos;
+       unsigned int win = plane->index;
 
        if (ctx->suspended)
                return;
                ctx->configs[i].num_pixel_formats = ARRAY_SIZE(fimd_formats);
                ctx->configs[i].zpos = i;
                ctx->configs[i].type = fimd_win_types[i];
-               ret = exynos_plane_init(drm_dev, &ctx->planes[i],
+               ret = exynos_plane_init(drm_dev, &ctx->planes[i], i,
                                        1 << ctx->pipe, &ctx->configs[i]);
                if (ret)
                        return ret;
 
 
 int exynos_plane_init(struct drm_device *dev,
                      struct exynos_drm_plane *exynos_plane,
-                     unsigned long possible_crtcs,
+                     unsigned int index, unsigned long possible_crtcs,
                      const struct exynos_drm_plane_config *config)
 {
        int err;
 
        drm_plane_helper_add(&exynos_plane->base, &plane_helper_funcs);
 
-       exynos_plane->zpos = config->zpos;
+       exynos_plane->index = index;
        exynos_plane->config = config;
 
        if (config->type == DRM_PLANE_TYPE_OVERLAY)
 
  */
 
 int exynos_plane_init(struct drm_device *dev,
-                     struct exynos_drm_plane *exynos_plane,
+                     struct exynos_drm_plane *exynos_plane, unsigned int index,
                      unsigned long possible_crtcs,
                      const struct exynos_drm_plane_config *config);
 
                plane_config.zpos = i;
                plane_config.type = vidi_win_types[i];
 
-               ret = exynos_plane_init(drm_dev, &ctx->planes[i],
+               ret = exynos_plane_init(drm_dev, &ctx->planes[i], i,
                                        1 << ctx->pipe, &plane_config);
                if (ret)
                        return ret;
 
 
        mixer_cfg_scan(ctx, mode->vdisplay);
        mixer_cfg_rgb_fmt(ctx, mode->vdisplay);
-       mixer_cfg_layer(ctx, plane->zpos, true);
+       mixer_cfg_layer(ctx, plane->index, true);
        mixer_run(ctx);
 
        mixer_vsync_set_update(ctx, true);
        struct mixer_resources *res = &ctx->mixer_res;
        struct drm_framebuffer *fb = state->base.fb;
        unsigned long flags;
-       unsigned int win = plane->zpos;
+       unsigned int win = plane->index;
        unsigned int x_ratio = 0, y_ratio = 0;
        unsigned int src_x_offset, src_y_offset, dst_x_offset, dst_y_offset;
        dma_addr_t dma_addr;
 {
        struct mixer_context *mixer_ctx = crtc->ctx;
 
-       DRM_DEBUG_KMS("win: %d\n", plane->zpos);
+       DRM_DEBUG_KMS("win: %d\n", plane->index);
 
        if (!test_bit(MXR_BIT_POWERED, &mixer_ctx->flags))
                return;
 
-       if (plane->zpos > 1 && mixer_ctx->vp_enabled)
+       if (plane->index > 1 && mixer_ctx->vp_enabled)
                vp_video_buffer(mixer_ctx, plane);
        else
                mixer_graph_buffer(mixer_ctx, plane);
        struct mixer_resources *res = &mixer_ctx->mixer_res;
        unsigned long flags;
 
-       DRM_DEBUG_KMS("win: %d\n", plane->zpos);
+       DRM_DEBUG_KMS("win: %d\n", plane->index);
 
        if (!test_bit(MXR_BIT_POWERED, &mixer_ctx->flags))
                return;
        spin_lock_irqsave(&res->reg_slock, flags);
        mixer_vsync_set_update(mixer_ctx, false);
 
-       mixer_cfg_layer(mixer_ctx, plane->zpos, false);
+       mixer_cfg_layer(mixer_ctx, plane->index, false);
 
        mixer_vsync_set_update(mixer_ctx, true);
        spin_unlock_irqrestore(&res->reg_slock, flags);
                if (i == VP_DEFAULT_WIN && !ctx->vp_enabled)
                        continue;
 
-               ret = exynos_plane_init(drm_dev, &ctx->planes[i],
+               ret = exynos_plane_init(drm_dev, &ctx->planes[i], i,
                                        1 << ctx->pipe, &plane_configs[i]);
                if (ret)
                        return ret;