backend-drm: Teach drm_property_info_populate() to retrieve range values

Useful for zpos range values.

Signed-off-by: Marius Vlad <marius.vlad@collabora.com>
Suggested-by: Daniel Stone <daniel.stone@collabora.com>

libweston/backend-drm/drm-internal.h

@@ -72,6 +72,10 @@
 #define GBM_BO_USE_LINEAR (1 << 4)
 #endif
 
+#ifndef DRM_PLANE_ZPOS_INVALID_PLANE
+#define DRM_PLANE_ZPOS_INVALID_PLANE	0xffffffffffffffffULL
+#endif
+
 /**
  * A small wrapper to print information into the 'drm-backend' debug scope.
  *
@@ -144,8 +148,11 @@ struct drm_property_enum_info {
 struct drm_property_info {
 	const char *name; /**< name as string (static, not freed) */
 	uint32_t prop_id; /**< KMS property object ID */
+	uint32_t flags;
 	unsigned int num_enum_values; /**< number of enum values */
 	struct drm_property_enum_info *enum_values; /**< array of enum values */
+	unsigned int num_range_values;
+	uint64_t range_values[2];
 };
 
 /**
@@ -166,6 +173,7 @@ enum wdrm_plane_property {
 	WDRM_PLANE_IN_FORMATS,
 	WDRM_PLANE_IN_FENCE_FD,
 	WDRM_PLANE_FB_DAMAGE_CLIPS,
+	WDRM_PLANE_ZPOS,
 	WDRM_PLANE__COUNT
 };
 
@@ -361,6 +369,16 @@ struct drm_output_state {
 	struct wl_list plane_list;
 };
 
+/**
+ * An instance of this class is created each time we believe we have a plane
+ * suitable to be used by a view as a direct scan-out. The list is initalized
+ * and populated locally.
+ */
+struct drm_plane_zpos {
+	struct drm_plane *plane;
+	struct wl_list link;	/**< :candidate_plane_zpos_list */
+};
+
 /**
  * Plane state holds the dynamic state for a plane: where it is positioned,
  * and which buffer it is currently displaying.
@@ -382,6 +400,8 @@ struct drm_plane_state {
 	int32_t dest_x, dest_y;
 	uint32_t dest_w, dest_h;
 
+	uint64_t zpos;
+
 	bool complete;
 
 	/* We don't own the fd, so we shouldn't close it */
@@ -423,6 +443,9 @@ struct drm_plane {
 	/* The last state submitted to the kernel for this plane. */
 	struct drm_plane_state *state_cur;
 
+	uint64_t zpos_min;
+	uint64_t zpos_max;
+
 	struct wl_list link;
 
 	struct {
@@ -523,6 +546,22 @@ to_drm_mode(struct weston_mode *base)
 	return container_of(base, struct drm_mode, base);
 }
 
+static inline const char *
+drm_output_get_plane_type_name(struct drm_plane *p)
+{
+	switch (p->type) {
+	case WDRM_PLANE_TYPE_PRIMARY:
+		return "primary";
+	case WDRM_PLANE_TYPE_CURSOR:
+		return "cursor";
+	case WDRM_PLANE_TYPE_OVERLAY:
+		return "overlay";
+	default:
+		assert(0);
+		break;
+	}
+}
+
 struct drm_output *
 drm_output_find_by_crtc(struct drm_backend *b, uint32_t crtc_id);
 
@@ -579,6 +618,9 @@ uint64_t
 drm_property_get_value(struct drm_property_info *info,
 		       const drmModeObjectProperties *props,
 		       uint64_t def);
+uint64_t *
+drm_property_get_range_values(struct drm_property_info *info,
+			      const drmModeObjectProperties *props);
 int
 drm_plane_populate_formats(struct drm_plane *plane, const drmModePlane *kplane,
 			   const drmModeObjectProperties *props);
@@ -695,7 +737,7 @@ void
 drm_plane_state_put_back(struct drm_plane_state *state);
 bool
 drm_plane_state_coords_for_view(struct drm_plane_state *state,
-				struct weston_view *ev);
+				struct weston_view *ev, uint64_t zpos);
 
 void
 drm_assign_planes(struct weston_output *output_base, void *repaint_data);

libweston/backend-drm/drm.c

@@ -68,6 +68,61 @@
 
 static const char default_seat[] = "seat0";
 
+static void
+drm_backend_create_faked_zpos(struct drm_backend *b)
+{
+	struct drm_plane *plane;
+	uint64_t zpos = 0ULL;
+	uint64_t zpos_min_primary;
+	uint64_t zpos_min_overlay;
+	uint64_t zpos_min_cursor;
+
+	zpos_min_primary = zpos;
+	wl_list_for_each(plane, &b->plane_list, link) {
+		/* if the property is there, bail out sooner */
+		if (plane->props[WDRM_PLANE_ZPOS].prop_id != 0)
+			return;
+
+		if (plane->type != WDRM_PLANE_TYPE_PRIMARY)
+			continue;
+		zpos++;
+	}
+
+	zpos_min_overlay = zpos;
+	wl_list_for_each(plane, &b->plane_list, link) {
+		if (plane->type != WDRM_PLANE_TYPE_OVERLAY)
+			continue;
+		zpos++;
+	}
+
+	zpos_min_cursor = zpos;
+	wl_list_for_each(plane, &b->plane_list, link) {
+		if (plane->type != WDRM_PLANE_TYPE_CURSOR)
+			continue;
+		zpos++;
+	}
+
+	drm_debug(b, "[drm-backend] zpos property not found. "
+		     "Using invented immutable zpos values:\n");
+	/* assume that invented zpos values are immutable */
+	wl_list_for_each(plane, &b->plane_list, link) {
+		if (plane->type == WDRM_PLANE_TYPE_PRIMARY) {
+			plane->zpos_min = zpos_min_primary;
+			plane->zpos_max = zpos_min_primary;
+		} else if (plane->type == WDRM_PLANE_TYPE_OVERLAY) {
+			plane->zpos_min = zpos_min_overlay;
+			plane->zpos_max = zpos_min_overlay;
+		} else if (plane->type == WDRM_PLANE_TYPE_CURSOR) {
+			plane->zpos_min = zpos_min_cursor;
+			plane->zpos_max = zpos_min_cursor;
+		}
+		drm_debug(b, "\t[plane] %s plane %d, zpos_min %"PRIu64", "
+			      "zpos_max %"PRIu64"\n",
+			      drm_output_get_plane_type_name(plane),
+			      plane->plane_id, plane->zpos_min, plane->zpos_max);
+	}
+}
+
 static void
 wl_array_remove_uint32(struct wl_array *array, uint32_t elm)
 {
@@ -680,6 +735,7 @@ drm_plane_create(struct drm_backend *b, const drmModePlane *kplane,
 {
 	struct drm_plane *plane;
 	drmModeObjectProperties *props;
+	uint64_t *zpos_range_values;
 	uint32_t num_formats = (kplane) ? kplane->count_formats : 1;
 
 	plane = zalloc(sizeof(*plane) +
@@ -711,6 +767,18 @@ drm_plane_create(struct drm_backend *b, const drmModePlane *kplane,
 					       props,
 					       WDRM_PLANE_TYPE__COUNT);
 
+		zpos_range_values =
+			drm_property_get_range_values(&plane->props[WDRM_PLANE_ZPOS], 
+						      props);
+
+		if (zpos_range_values) {
+			plane->zpos_min = zpos_range_values[0];
+			plane->zpos_max = zpos_range_values[1];
+		} else {
+			plane->zpos_min = DRM_PLANE_ZPOS_INVALID_PLANE;
+			plane->zpos_max = DRM_PLANE_ZPOS_INVALID_PLANE;
+		}
+
 		if (drm_plane_populate_formats(plane, kplane, props) < 0) {
 			drmModeFreeObjectProperties(props);
 			goto err;
@@ -724,6 +792,8 @@ drm_plane_create(struct drm_backend *b, const drmModePlane *kplane,
 		plane->count_formats = 1;
 		plane->formats[0].format = format;
 		plane->type = type;
+		plane->zpos_max = DRM_PLANE_ZPOS_INVALID_PLANE;
+		plane->zpos_min = DRM_PLANE_ZPOS_INVALID_PLANE;
 	}
 
 	if (plane->type == WDRM_PLANE_TYPE__COUNT)
@@ -2841,6 +2911,9 @@ drm_backend_create(struct weston_compositor *compositor,
 		goto err_udev_input;
 	}
 
+	/* 'compute' faked zpos values in case HW doesn't expose any */
+	drm_backend_create_faked_zpos(b);
+
 	/* A this point we have some idea of whether or not we have a working
 	 * cursor plane. */
 	if (!b->cursors_are_broken)

libweston/backend-drm/kms.c

@@ -77,6 +77,7 @@ const struct drm_property_info plane_props[] = {
 	[WDRM_PLANE_IN_FORMATS] = { .name = "IN_FORMATS" },
 	[WDRM_PLANE_IN_FENCE_FD] = { .name = "IN_FENCE_FD" },
 	[WDRM_PLANE_FB_DAMAGE_CLIPS] = { .name = "FB_DAMAGE_CLIPS" },
+	[WDRM_PLANE_ZPOS] = { .name = "zpos" },
 };
 
 struct drm_property_enum_info dpms_state_enums[] = {
@@ -202,6 +203,42 @@ drm_property_get_value(struct drm_property_info *info,
 	return def;
 }
 
+/**
+ * Get the current range values of a KMS property
+ *
+ * Given a drmModeObjectGetProperties return, as well as the drm_property_info
+ * for the target property, return the current range values of that property,
+ *
+ * If the property is not present, or there's no it is not a prop range then
+ * NULL will be returned.
+ *
+ * @param info Internal structure for property to look up
+ * @param props Raw KMS properties for the target object
+ */
+uint64_t *
+drm_property_get_range_values(struct drm_property_info *info,
+			      const drmModeObjectProperties *props)
+{
+	unsigned int i;
+
+	if (info->prop_id == 0)
+		return NULL;
+
+	for (i = 0; i < props->count_props; i++) {
+
+		if (props->props[i] != info->prop_id)
+			continue;
+
+		if (!(info->flags & DRM_MODE_PROP_RANGE) &&
+		    !(info->flags & DRM_MODE_PROP_SIGNED_RANGE))
+			continue;
+
+		return info->range_values;
+	}
+
+	return NULL;
+}
+
 /**
  * Cache DRM property values
  *
@@ -294,6 +331,15 @@ drm_property_info_populate(struct drm_backend *b,
 		}
 
 		info[j].prop_id = props->props[i];
+		info[j].flags = prop->flags;
+
+		if (prop->flags & DRM_MODE_PROP_RANGE ||
+		    prop->flags & DRM_MODE_PROP_SIGNED_RANGE) {
+			info[j].num_range_values = prop->count_values;
+			for (int i = 0; i < prop->count_values; i++)
+				info[j].range_values[i] = prop->values[i];
+		}
+
 
 		if (info[j].num_enum_values == 0) {
 			drmModeFreeProperty(prop);
@@ -1005,6 +1051,13 @@ drm_output_apply_state_atomic(struct drm_output_state *state,
 					      plane_state->in_fence_fd);
 		}
 
+		/* do note, that 'invented' zpos values are set as immutable */
+		if (plane_state->zpos != DRM_PLANE_ZPOS_INVALID_PLANE &&
+		    plane_state->plane->zpos_min != plane_state->plane->zpos_max)
+			ret |= plane_add_prop(req, plane,
+					      WDRM_PLANE_ZPOS,
+					      plane_state->zpos);
+
 		if (ret != 0) {
 			weston_log("couldn't set plane state\n");
 			return ret;

libweston/backend-drm/state-helpers.c

@@ -48,6 +48,7 @@ drm_plane_state_alloc(struct drm_output_state *state_output,
 	state->output_state = state_output;
 	state->plane = plane;
 	state->in_fence_fd = -1;
+	state->zpos = DRM_PLANE_ZPOS_INVALID_PLANE;
 	pixman_region32_init(&state->damage);
 
 	/* Here we only add the plane state to the desired link, and not
@@ -80,6 +81,7 @@ drm_plane_state_free(struct drm_plane_state *state, bool force)
 	wl_list_init(&state->link);
 	state->output_state = NULL;
 	state->in_fence_fd = -1;
+	state->zpos = DRM_PLANE_ZPOS_INVALID_PLANE;
 	pixman_region32_fini(&state->damage);
 
 	if (force || state != state->plane->state_cur) {
@@ -163,7 +165,7 @@ drm_plane_state_put_back(struct drm_plane_state *state)
  */
 bool
 drm_plane_state_coords_for_view(struct drm_plane_state *state,
-				struct weston_view *ev)
+				struct weston_view *ev, uint64_t zpos)
 {
 	struct drm_output *output = state->output;
 	struct weston_buffer *buffer = ev->surface->buffer_ref.buffer;
@@ -243,6 +245,9 @@ drm_plane_state_coords_for_view(struct drm_plane_state *state,
 	if (state->src_h > (uint32_t) ((buffer->height << 16) - state->src_y))
 		state->src_h = (buffer->height << 16) - state->src_y;
 
+	/* apply zpos if available */
+	state->zpos = zpos;
+
 	return true;
 }
 

libweston/backend-drm/state-propose.c

@@ -62,155 +62,200 @@ drm_propose_state_mode_to_string(enum drm_output_propose_state_mode mode)
 	return drm_output_propose_state_mode_as_string[mode];
 }
 
-static struct drm_plane_state *
+static void
-drm_output_prepare_overlay_view(struct drm_output_state *output_state,
+drm_output_add_zpos_plane(struct drm_plane *plane, struct wl_list *planes)
-				struct weston_view *ev,
-				enum drm_output_propose_state_mode mode)
 {
-	struct drm_output *output = output_state->output;
+	struct drm_backend *b = plane->backend;
-	struct weston_compositor *ec = output->base.compositor;
+	struct drm_plane_zpos *h_plane;
-	struct drm_backend *b = to_drm_backend(ec);
+	struct drm_plane_zpos *plane_zpos;
-	struct drm_plane *p;
-	struct drm_plane_state *state = NULL;
-	struct drm_fb *fb;
-	unsigned int i;
-	int ret;
-	enum {
-		NO_PLANES,
-		NO_PLANES_WITH_FORMAT,
-		NO_PLANES_ACCEPTED,
-		PLACED_ON_PLANE,
-	} availability = NO_PLANES;
 
-	assert(!b->sprites_are_broken);
+	plane_zpos = zalloc(sizeof(*plane_zpos));
-	assert(b->atomic_modeset);
+	if (!plane_zpos)
+		return;
 
-	fb = drm_fb_get_from_view(output_state, ev);
+	plane_zpos->plane = plane;
-	if (!fb) {
+
-		drm_debug(b, "\t\t\t\t[overlay] not placing view %p on overlay: "
+	drm_debug(b, "\t\t\t\t[plane] plane %d added to candidate list\n",
-			     " couldn't get fb\n", ev);
+		      plane->plane_id);
-		return NULL;
+
+	if (wl_list_empty(planes)) {
+		wl_list_insert(planes, &plane_zpos->link);
+		return;
 	}
 
-	wl_list_for_each(p, &b->plane_list, link) {
+	h_plane = wl_container_of(planes->next, h_plane, link);
-		if (p->type != WDRM_PLANE_TYPE_OVERLAY)
+	if (h_plane->plane->zpos_max >= plane->zpos_max) {
-			continue;
+		wl_list_insert(planes->prev, &plane_zpos->link);
+	} else {
+		struct drm_plane_zpos *p_zpos = NULL;
 
-		if (!drm_plane_is_available(p, output))
+		if (wl_list_length(planes) == 1) {
-			continue;
+			wl_list_insert(planes->prev, &plane_zpos->link);
+			return;
+		}
 
-		state = drm_output_state_get_plane(output_state, p);
+		wl_list_for_each(p_zpos, planes, link) {
-		if (state->fb) {
+			if (p_zpos->plane->zpos_max >
-			state = NULL;
+			    plane_zpos->plane->zpos_max)
-			continue;
+				break;
 		}
 
-		if (availability == NO_PLANES)
+		wl_list_insert(p_zpos->link.prev, &plane_zpos->link);
-			availability = NO_PLANES_WITH_FORMAT;
+	}
+}
+
+static void
+drm_output_destroy_zpos_plane(struct drm_plane_zpos *plane_zpos)
+{
+	wl_list_remove(&plane_zpos->link);
+	free(plane_zpos);
+}
+
+static bool
+drm_output_check_plane_has_view_assigned(struct drm_plane *plane,
+                                        struct drm_output_state *output_state)
+{
+	struct drm_plane_state *ps;
+	wl_list_for_each(ps, &output_state->plane_list, link) {
+		if (ps->plane == plane && ps->fb)
+			return true;
+	}
+	return false;
+}
 
-		/* Check whether the format is supported */
+static bool
-		for (i = 0; i < p->count_formats; i++) {
+drm_output_plane_has_valid_format(struct drm_plane *plane,
-			unsigned int j;
+				  struct drm_output_state *state,
+				  struct drm_fb *fb)
+{
+	struct drm_backend *b = plane->backend;
+	unsigned int i;
 
-			if (p->formats[i].format != fb->format->format)
+	if (!fb)
-				continue;
+		return false;
 
-			if (fb->modifier == DRM_FORMAT_MOD_INVALID)
+	/* Check whether the format is supported */
-				break;
+	for (i = 0; i < plane->count_formats; i++) {
+		unsigned int j;
 
-			for (j = 0; j < p->formats[i].count_modifiers; j++) {
+		if (plane->formats[i].format != fb->format->format)
-				if (p->formats[i].modifiers[j] == fb->modifier)
-					break;
-			}
-			if (j != p->formats[i].count_modifiers)
-				break;
-		}
-		if (i == p->count_formats) {
-			drm_plane_state_put_back(state);
-			state = NULL;
 			continue;
-		}
 
-		if (availability == NO_PLANES_WITH_FORMAT)
+		if (fb->modifier == DRM_FORMAT_MOD_INVALID)
-			availability = NO_PLANES_ACCEPTED;
+			return true;
 
-		state->ev = ev;
+		for (j = 0; j < plane->formats[i].count_modifiers; j++) {
-		state->output = output;
+			if (plane->formats[i].modifiers[j] == fb->modifier)
-		if (!drm_plane_state_coords_for_view(state, ev)) {
+				return true;
-			drm_debug(b, "\t\t\t\t[overlay] not placing view %p on overlay: "
-				     "unsuitable transform\n", ev);
-			drm_plane_state_put_back(state);
-			state = NULL;
-			continue;
 		}
+	}
 
-		/* If the surface buffer has an in-fence fd, but the plane
+	drm_debug(b, "\t\t\t\t[%s] not placing view on %s: "
-		 * doesn't support fences, we can't place the buffer on this
+		  "no free %s planes matching format %s (0x%lx) "
-		 * plane. */
+		  "modifier 0x%llx\n",
-		if (ev->surface->acquire_fence_fd >= 0 &&
+		  drm_output_get_plane_type_name(plane),
-		     p->props[WDRM_PLANE_IN_FENCE_FD].prop_id == 0) {
+		  drm_output_get_plane_type_name(plane),
-			drm_debug(b, "\t\t\t\t[overlay] not placing view %p on overlay: "
+		  drm_output_get_plane_type_name(plane),
-				     "no in-fence support\n", ev);
+		  fb->format->drm_format_name,
-			drm_plane_state_put_back(state);
+		  (unsigned long) fb->format,
-			state = NULL;
+		  (unsigned long long) fb->modifier);
-			continue;
+
-		}
+	return false;
+}
 
-		/* We hold one reference for the lifetime of this function;
+static bool
-		 * from calling drm_fb_get_from_view, to the out label where
+drm_output_plane_cursor_has_valid_format(struct weston_view *ev)
-		 * we unconditionally drop the reference. So, we take another
+{
-		 * reference here to live within the state. */
+	struct wl_shm_buffer *shmbuf =
-		state->fb = drm_fb_ref(fb);
+		wl_shm_buffer_get(ev->surface->buffer_ref.buffer->resource);
 
-		state->in_fence_fd = ev->surface->acquire_fence_fd;
+	if (shmbuf && wl_shm_buffer_get_format(shmbuf) == WL_SHM_FORMAT_ARGB8888)
+		return true;
 
-		/* In planes-only mode, we don't have an incremental state to
+	return false;
-		 * test against, so we just hope it'll work. */
+}
-		if (mode == DRM_OUTPUT_PROPOSE_STATE_PLANES_ONLY) {
-			drm_debug(b, "\t\t\t\t[overlay] provisionally placing "
-				     "view %p on overlay %lu in planes-only mode\n",
-				  ev, (unsigned long) p->plane_id);
-			availability = PLACED_ON_PLANE;
-			goto out;
-		}
 
-		ret = drm_pending_state_test(output_state->pending_state);
+static struct drm_plane_state *
-		if (ret == 0) {
+drm_output_prepare_overlay_view(struct drm_plane *plane,
-			drm_debug(b, "\t\t\t\t[overlay] provisionally placing "
+				struct drm_output_state *output_state,
-				     "view %p on overlay %d in mixed mode\n",
+				struct weston_view *ev,
-				  ev, p->plane_id);
+				enum drm_output_propose_state_mode mode,
-			availability = PLACED_ON_PLANE;
+				struct drm_fb *fb, uint64_t zpos)
-			goto out;
+{
-		}
+	struct drm_output *output = output_state->output;
+	struct weston_compositor *ec = output->base.compositor;
+	struct drm_backend *b = to_drm_backend(ec);
+	struct drm_plane_state *state = NULL;
+	int ret;
+
+	assert(!b->sprites_are_broken);
+	assert(b->atomic_modeset);
 
-		drm_debug(b, "\t\t\t\t[overlay] not placing view %p on overlay %lu "
+	if (!fb) {
-			     "in mixed mode: kernel test failed\n",
+		drm_debug(b, "\t\t\t\t[overlay] not placing view %p on overlay: "
-			  ev, (unsigned long) p->plane_id);
+			     " couldn't get fb\n", ev);
+		return NULL;
+	}
+
+	state = drm_output_state_get_plane(output_state, plane);
+	/* we can't have a 'pending' framebuffer as never set one before reaching here */
+	assert(!state->fb);
 
+	state->ev = ev;
+	state->output = output;
+
+	if (!drm_plane_state_coords_for_view(state, ev, zpos)) {
+		drm_debug(b, "\t\t\t\t[overlay] not placing view %p on overlay: "
+			     "unsuitable transform\n", ev);
 		drm_plane_state_put_back(state);
 		state = NULL;
+		goto out;
 	}
 
-	switch (availability) {
+	/* If the surface buffer has an in-fence fd, but the plane
-	case NO_PLANES:
+	 * doesn't support fences, we can't place the buffer on this
-		drm_debug(b, "\t\t\t\t[overlay] not placing view %p on overlay: "
+	 * plane. */
-			     "no free overlay planes\n", ev);
+	if (ev->surface->acquire_fence_fd >= 0 &&
-		break;
+	     plane->props[WDRM_PLANE_IN_FENCE_FD].prop_id == 0) {
-	case NO_PLANES_WITH_FORMAT:
 		drm_debug(b, "\t\t\t\t[overlay] not placing view %p on overlay: "
-			     "no free overlay planes matching format %s (0x%lx) "
+			     "no in-fence support\n", ev);
-			     "modifier 0x%llx\n",
+		drm_plane_state_put_back(state);
-			  ev, fb->format->drm_format_name,
+		state = NULL;
-			  (unsigned long) fb->format,
+		goto out;
-			  (unsigned long long) fb->modifier);
+	}
-		break;
+
-	case NO_PLANES_ACCEPTED:
+	/* We hold one reference for the lifetime of this function; from
-	case PLACED_ON_PLANE:
+	 * calling drm_fb_get_from_view() in drm_output_prepare_plane_view(),
-		break;
+	 * so, we take another reference here to live within the state. */
+	state->fb = drm_fb_ref(fb);
+
+	state->in_fence_fd = ev->surface->acquire_fence_fd;
+
+	/* In planes-only mode, we don't have an incremental state to
+	 * test against, so we just hope it'll work. */
+	if (mode == DRM_OUTPUT_PROPOSE_STATE_PLANES_ONLY) {
+		drm_debug(b, "\t\t\t[overlay] provisionally placing "
+			     "view %p on overlay %lu in planes-only mode\n",
+			  ev, (unsigned long) plane->plane_id);
+		goto out;
 	}
 
+	ret = drm_pending_state_test(output_state->pending_state);
+	if (ret == 0) {
+		drm_debug(b, "\t\t\t[overlay] provisionally placing "
+			     "view %p on overlay %d in mixed mode\n",
+			  ev, plane->plane_id);
+		goto out;
+	}
+
+	drm_debug(b, "\t\t\t[overlay] not placing view %p on overlay %lu "
+		     "in mixed mode: kernel test failed\n",
+		  ev, (unsigned long) plane->plane_id);
+
+	drm_plane_state_put_back(state);
+	state = NULL;
+
 out:
-	drm_fb_unref(fb);
 	return state;
 }
 
@@ -254,14 +299,14 @@ cursor_bo_update(struct drm_plane_state *plane_state, struct weston_view *ev)
 
 static struct drm_plane_state *
 drm_output_prepare_cursor_view(struct drm_output_state *output_state,
-			       struct weston_view *ev)
+			       struct weston_view *ev, uint64_t zpos)
 {
 	struct drm_output *output = output_state->output;
 	struct drm_backend *b = to_drm_backend(output->base.compositor);
 	struct drm_plane *plane = output->cursor_plane;
 	struct drm_plane_state *plane_state;
-	struct wl_shm_buffer *shmbuf;
 	bool needs_update = false;
+	const char *p_name = drm_output_get_plane_type_name(plane);
 
 	assert(!b->cursors_are_broken);
 
@@ -278,24 +323,6 @@ drm_output_prepare_cursor_view(struct drm_output_state *output_state,
 	if (b->gbm == NULL)
 		return NULL;
 
-	if (ev->surface->buffer_ref.buffer == NULL) {
-		drm_debug(b, "\t\t\t\t[cursor] not assigning view %p to cursor plane "
-			     "(no buffer available)\n", ev);
-		return NULL;
-	}
-	shmbuf = wl_shm_buffer_get(ev->surface->buffer_ref.buffer->resource);
-	if (!shmbuf) {
-		drm_debug(b, "\t\t\t\t[cursor] not assigning view %p to cursor plane "
-			     "(buffer isn't SHM)\n", ev);
-		return NULL;
-	}
-	if (wl_shm_buffer_get_format(shmbuf) != WL_SHM_FORMAT_ARGB8888) {
-		drm_debug(b, "\t\t\t\t[cursor] not assigning view %p to cursor plane "
-			     "(format 0x%lx unsuitable)\n",
-			  ev, (unsigned long) wl_shm_buffer_get_format(shmbuf));
-		return NULL;
-	}
-
 	plane_state =
 		drm_output_state_get_plane(output_state, output->cursor_plane);
 
@@ -305,16 +332,20 @@ drm_output_prepare_cursor_view(struct drm_output_state *output_state,
 	/* We can't scale with the legacy API, and we don't try to account for
 	 * simple cropping/translation in cursor_bo_update. */
 	plane_state->output = output;
-	if (!drm_plane_state_coords_for_view(plane_state, ev))
+	if (!drm_plane_state_coords_for_view(plane_state, ev, zpos)) {
+		drm_debug(b, "\t\t\t\t[%s] not placing view %p on %s: "
+			     "unsuitable transform\n", p_name, ev, p_name);
 		goto err;
+	}
 
 	if (plane_state->src_x != 0 || plane_state->src_y != 0 ||
 	    plane_state->src_w > (unsigned) b->cursor_width << 16 ||
 	    plane_state->src_h > (unsigned) b->cursor_height << 16 ||
 	    plane_state->src_w != plane_state->dest_w << 16 ||
 	    plane_state->src_h != plane_state->dest_h << 16) {
-		drm_debug(b, "\t\t\t\t[cursor] not assigning view %p to cursor plane "
+		drm_debug(b, "\t\t\t\t[%s] not assigning view %p to %s plane "
-			     "(positioning requires cropping or scaling)\n", ev);
+			     "(positioning requires cropping or scaling)\n",
+			     p_name, ev, p_name);
 		goto err;
 	}
 
@@ -340,7 +371,7 @@ drm_output_prepare_cursor_view(struct drm_output_state *output_state,
 		drm_fb_ref(output->gbm_cursor_fb[output->current_cursor]);
 
 	if (needs_update) {
-		drm_debug(b, "\t\t\t\t[cursor] copying new content to cursor BO\n");
+		drm_debug(b, "\t\t\t\t[%s] copying new content to cursor BO\n", p_name);
 		cursor_bo_update(plane_state, ev);
 	}
 
@@ -353,8 +384,8 @@ drm_output_prepare_cursor_view(struct drm_output_state *output_state,
 	plane_state->dest_w = b->cursor_width;
 	plane_state->dest_h = b->cursor_height;
 
-	drm_debug(b, "\t\t\t\t[cursor] provisionally assigned view %p to cursor\n",
+	drm_debug(b, "\t\t\t\t[%s] provisionally assigned view %p to cursor\n",
-		  ev);
+		  p_name, ev);
 
 	return plane_state;
 
@@ -365,7 +396,7 @@ err:
 #else
 static struct drm_plane_state *
 drm_output_prepare_cursor_view(struct drm_output_state *output_state,
-			       struct weston_view *ev)
+			       struct weston_view *ev, uint64_t zpos)
 {
 	return NULL;
 }
@@ -374,14 +405,14 @@ drm_output_prepare_cursor_view(struct drm_output_state *output_state,
 static struct drm_plane_state *
 drm_output_prepare_scanout_view(struct drm_output_state *output_state,
 				struct weston_view *ev,
-				enum drm_output_propose_state_mode mode)
+				enum drm_output_propose_state_mode mode,
+				struct drm_fb *fb, uint64_t zpos)
 {
 	struct drm_output *output = output_state->output;
 	struct drm_backend *b = to_drm_backend(output->base.compositor);
 	struct drm_plane *scanout_plane = output->scanout_plane;
 	struct drm_plane_state *state;
-	struct drm_fb *fb;
+	const char *p_name = drm_output_get_plane_type_name(scanout_plane);
-	pixman_box32_t *extents;
 
 	assert(!b->sprites_are_broken);
 	assert(b->atomic_modeset);
@@ -389,23 +420,25 @@ drm_output_prepare_scanout_view(struct drm_output_state *output_state,
 
 	/* Check the view spans exactly the output size, calculated in the
 	 * logical co-ordinate space. */
-	extents = pixman_region32_extents(&ev->transform.boundingbox);
+	if (!weston_view_matches_output_entirely(ev, &output->base)) {
-	if (extents->x1 != output->base.x ||
+		drm_debug(b, "\t\t\t\t[%s] not placing view %p on %s: "
-	    extents->y1 != output->base.y ||
+			     " view does not match output entirely\n",
-	    extents->x2 != output->base.x + output->base.width ||
+			     p_name, ev, p_name);
-	    extents->y2 != output->base.y + output->base.height)
 		return NULL;
+	}
 
 	/* If the surface buffer has an in-fence fd, but the plane doesn't
 	 * support fences, we can't place the buffer on this plane. */
 	if (ev->surface->acquire_fence_fd >= 0 &&
-	    scanout_plane->props[WDRM_PLANE_IN_FENCE_FD].prop_id == 0)
+	    scanout_plane->props[WDRM_PLANE_IN_FENCE_FD].prop_id == 0) {
+		drm_debug(b, "\t\t\t\t[%s] not placing view %p on %s: "
+			     "no in-fence support\n", p_name, ev, p_name);
 		return NULL;
+	}
 
-	fb = drm_fb_get_from_view(output_state, ev);
 	if (!fb) {
-		drm_debug(b, "\t\t\t\t[scanout] not placing view %p on scanout: "
+		drm_debug(b, "\t\t\t\t[%s] not placing view %p on %s: "
-			     " couldn't get fb\n", ev);
+			     " couldn't get fb\n", p_name, ev, p_name);
 		return NULL;
 	}
 
@@ -417,16 +450,24 @@ drm_output_prepare_scanout_view(struct drm_output_state *output_state,
 	 * and in the latter case, the view must have been marked as occluded,
 	 * meaning we should never have ended up here. */
 	assert(!state->fb);
-	state->fb = fb;
+
+	/* take another reference here to live within the state */
+	state->fb = drm_fb_ref(fb);
 	state->ev = ev;
 	state->output = output;
-	if (!drm_plane_state_coords_for_view(state, ev))
+	if (!drm_plane_state_coords_for_view(state, ev, zpos)) {
+		drm_debug(b, "\t\t\t\t[%s] not placing view %p on %s: "
+			     "unsuitable transform\n", p_name, ev, p_name);
 		goto err;
+	}
 
 	if (state->dest_x != 0 || state->dest_y != 0 ||
 	    state->dest_w != (unsigned) output->base.current_mode->width ||
-	    state->dest_h != (unsigned) output->base.current_mode->height)
+	    state->dest_h != (unsigned) output->base.current_mode->height) {
+		drm_debug(b, "\t\t\t\t[%s] not placing view %p on %s: "
+			     " invalid plane state\n", p_name, ev, p_name);
 		goto err;
+	}
 
 	state->in_fence_fd = ev->surface->acquire_fence_fd;
 
@@ -439,6 +480,252 @@ err:
 	return NULL;
 }
 
+static bool
+drm_output_plane_view_has_valid_format(struct drm_plane *plane,
+				       struct drm_output_state *state,
+				       struct weston_view *ev,
+				       struct drm_fb *fb)
+{
+	/* depending on the type of the plane we have different requirements */
+	switch (plane->type) {
+	case WDRM_PLANE_TYPE_CURSOR:
+		return drm_output_plane_cursor_has_valid_format(ev);
+	case WDRM_PLANE_TYPE_OVERLAY:
+		return drm_output_plane_has_valid_format(plane, state, fb);
+	case WDRM_PLANE_TYPE_PRIMARY:
+		return drm_output_plane_has_valid_format(plane, state, fb);
+	default:
+		assert(0);
+		return false;
+	}
+
+	return false;
+}
+
+static struct drm_plane_state *
+drm_output_try_view_on_plane(struct drm_plane *plane,
+			     struct drm_output_state *state,
+			     struct weston_view *ev,
+			     enum drm_output_propose_state_mode mode,
+			     struct drm_fb *fb, uint64_t zpos)
+{
+	struct drm_backend *b = state->pending_state->backend;
+	struct weston_output *wet_output = &state->output->base;
+	bool view_matches_entire_output, scanout_has_view_assigned;
+	struct drm_plane *scanout_plane = state->output->scanout_plane;
+	struct drm_plane_state *ps = NULL;
+	const char *p_name = drm_output_get_plane_type_name(plane);
+	enum {
+		NO_PLANES,	/* generic err-handle */
+		NO_PLANES_ACCEPTED,
+		PLACED_ON_PLANE,
+	} availability = NO_PLANES;
+
+	/* sanity checks in case we over/underflow zpos or pass incorrect
+	 * values */
+	assert(zpos <= plane->zpos_max ||
+	       zpos != DRM_PLANE_ZPOS_INVALID_PLANE);
+
+	switch (plane->type) {
+	case WDRM_PLANE_TYPE_CURSOR:
+		if (b->cursors_are_broken) {
+			availability = NO_PLANES_ACCEPTED;
+			goto out;
+		}
+
+		ps = drm_output_prepare_cursor_view(state, ev, zpos);
+		if (ps)
+			availability = PLACED_ON_PLANE;
+		break;
+	case WDRM_PLANE_TYPE_OVERLAY:
+		/* do not attempt to place it in the overlay if we don't have
+		 * anything in the scanout/primary and the view doesn't cover
+		 * the entire output  */
+		view_matches_entire_output =
+			weston_view_matches_output_entirely(ev, wet_output);
+		scanout_has_view_assigned =
+			drm_output_check_plane_has_view_assigned(scanout_plane,
+								 state);
+
+		if (view_matches_entire_output && !scanout_has_view_assigned) {
+			availability = NO_PLANES_ACCEPTED;
+			goto out;
+		}
+
+		ps = drm_output_prepare_overlay_view(plane, state, ev, mode,
+						     fb, zpos);
+		if (ps)
+			availability = PLACED_ON_PLANE;
+		break;
+	case WDRM_PLANE_TYPE_PRIMARY:
+		if (mode != DRM_OUTPUT_PROPOSE_STATE_PLANES_ONLY) {
+			availability = NO_PLANES_ACCEPTED;
+			goto out;
+		}
+
+		ps = drm_output_prepare_scanout_view(state, ev, mode,
+						     fb, zpos);
+		if (ps)
+			availability = PLACED_ON_PLANE;
+		break;
+	default:
+		assert(0);
+		break;
+	}
+
+out:
+	switch (availability) {
+	case NO_PLANES:
+		/* set initial to this catch-all case, such that
+		 * prepare_cursor/overlay/scanout() should have/contain the
+		 * reason for failling */
+		break;
+	case NO_PLANES_ACCEPTED:
+		drm_debug(b, "\t\t\t\t[plane] plane %d refusing to "
+			     "place view %p in %s\n",
+			     plane->plane_id, ev, p_name);
+		break;
+	case PLACED_ON_PLANE:
+		break;
+	}
+
+
+	return ps;
+}
+
+static int
+drm_output_check_zpos_plane_states(struct drm_output_state *state)
+{
+	struct drm_backend *b = state->pending_state->backend;
+	struct drm_plane_state *ps;
+	int ret = 0;
+
+	wl_list_for_each(ps, &state->plane_list, link) {
+		struct wl_list *next_node = ps->link.next;
+		bool found_dup = false;
+
+		/* find another plane with the same zpos value */
+		if (next_node == &state->plane_list)
+			break;
+
+		while (next_node && next_node != &state->plane_list) {
+			struct drm_plane_state *ps_next;
+
+			ps_next = container_of(next_node,
+					       struct drm_plane_state,
+					       link);
+
+			if (ps->zpos == ps_next->zpos) {
+				found_dup = true;
+				break;
+			}
+			next_node = next_node->next;
+		}
+
+		if (found_dup) {
+			ret = 1;
+			drm_debug(b, "\t\t\t[plane] found duplicate zpos values\n");
+			break;
+		}
+	}
+
+	return ret;
+}
+
+static struct drm_plane_state *
+drm_output_prepare_plane_view(struct drm_output_state *state,
+			      struct weston_view *ev,
+			      enum drm_output_propose_state_mode mode,
+			      uint64_t current_lowest_zpos)
+{
+	struct drm_output *output = state->output;
+	struct drm_backend *b = to_drm_backend(output->base.compositor);
+
+	struct drm_plane_state *ps = NULL;
+	struct drm_plane *plane;
+	struct drm_plane_zpos *p_zpos, *p_zpos_next;
+	struct wl_list zpos_candidate_list;
+
+	struct drm_fb *fb;
+
+	wl_list_init(&zpos_candidate_list);
+
+	/* check view for valid buffer, doesn't make sense to even try */
+	if (!weston_view_has_valid_buffer(ev))
+		return ps;
+
+	fb = drm_fb_get_from_view(state, ev);
+
+	/* assemble a list with possible candidates */
+	wl_list_for_each(plane, &b->plane_list, link) {
+		if (!drm_plane_is_available(plane, output))
+			continue;
+
+		if (drm_output_check_plane_has_view_assigned(plane, state)) {
+			drm_debug(b, "\t\t\t\t[plane] not adding plane %d to"
+				     " candidate list: view already assigned "
+				     "to a plane\n", plane->plane_id);
+			continue;
+		}
+
+		if (plane->zpos_min >= current_lowest_zpos) {
+			drm_debug(b, "\t\t\t\t[plane] not adding plane %d to "
+				     "candidate list: minium zpos (%"PRIu64") "
+				     "plane's above current lowest zpos "
+				     "(%"PRIu64")\n", plane->plane_id,
+				     plane->zpos_min, current_lowest_zpos);
+			continue;
+		}
+
+		if (!drm_output_plane_view_has_valid_format(plane, state, ev, fb)) {
+			drm_debug(b, "\t\t\t\t[plane] not adding plane %d to "
+				     "candidate list: invalid pixel format\n",
+				     plane->plane_id);
+			continue;
+		}
+
+		drm_output_add_zpos_plane(plane, &zpos_candidate_list);
+	}
+
+	/* go over the potential candidate list and try to find a possible
+	 * plane suitable for \c ev; start with the highest zpos value of a
+	 * plane to maximize our chances, but do note we pass the zpos value
+	 * based on current tracked value by \c current_lowest_zpos_in_use */
+	while (!wl_list_empty(&zpos_candidate_list)) {
+		struct drm_plane_zpos *head_p_zpos =
+			wl_container_of(zpos_candidate_list.next,
+					head_p_zpos, link);
+		struct drm_plane *plane = head_p_zpos->plane;
+		const char *p_name = drm_output_get_plane_type_name(plane);
+		uint64_t zpos;
+
+		if (current_lowest_zpos == DRM_PLANE_ZPOS_INVALID_PLANE)
+			zpos = plane->zpos_max;
+		else
+			zpos = MIN(current_lowest_zpos - 1, plane->zpos_max);
+
+		drm_debug(b, "\t\t\t\t[plane] plane %d picked "
+			     "from candidate list, type: %s\n",
+			     plane->plane_id, p_name);
+
+		ps = drm_output_try_view_on_plane(plane, state, ev,
+						  mode, fb, zpos);
+		drm_output_destroy_zpos_plane(head_p_zpos);
+		if (ps) {
+			drm_debug(b, "\t\t\t\t[view] view %p has been placed to "
+				     "%s plane with computed zpos %"PRIu64"\n",
+				     ev, p_name, zpos);
+			break;
+		}
+	}
+
+	wl_list_for_each_safe(p_zpos, p_zpos_next, &zpos_candidate_list, link)
+		drm_output_destroy_zpos_plane(p_zpos);
+
+	drm_fb_unref(fb);
+	return ps;
+}
+
 static struct drm_output_state *
 drm_output_propose_state(struct weston_output *output_base,
 			 struct drm_pending_state *pending_state,
@@ -449,10 +736,13 @@ drm_output_propose_state(struct weston_output *output_base,
 	struct drm_output_state *state;
 	struct drm_plane_state *scanout_state = NULL;
 	struct weston_view *ev;
-	pixman_region32_t surface_overlap, renderer_region, occluded_region;
+
-	bool planes_ok = (mode != DRM_OUTPUT_PROPOSE_STATE_RENDERER_ONLY);
+	pixman_region32_t surface_overlap, renderer_region, planes_region;
+	pixman_region32_t occluded_region;
+
 	bool renderer_ok = (mode != DRM_OUTPUT_PROPOSE_STATE_PLANES_ONLY);
 	int ret;
+	uint64_t current_lowest_zpos = DRM_PLANE_ZPOS_INVALID_PLANE;
 
 	assert(!output->state_last);
 	state = drm_output_state_duplicate(output->state_cur,
@@ -502,20 +792,19 @@ drm_output_propose_state(struct weston_output *output_base,
 			  (unsigned long) output->base.id);
 	}
 
-	/*
+	/* - renderer_region contains the total region which which will be
-	 * Find a surface for each sprite in the output using some heuristics:
+	 *   covered by the renderer
-	 * 1) size
+	 * - planes_region contains the total region which has been covered by
-	 * 2) frequency of update
+	 *   hardware planes
-	 * 3) opacity (though some hw might support alpha blending)
+	 * - occluded_region contains the total region which which will be
-	 * 4) clipping (this can be fixed with color keys)
+	 *   covered by the renderer and hardware planes, where the view's
-	 *
+	 *   visible-and-opaque region is added in both cases (the view's
-	 * The idea is to save on blitting since this should save power.
+	 *   opaque region  accumulates there for each view); it is being used
-	 * If we can get a large video surface on the sprite for example,
+	 *   to skip the view, if it is completely occluded; includes the
-	 * the main display surface may not need to update at all, and
+	 *   situation where occluded_region covers entire output's region.
-	 * the client buffer can be used directly for the sprite surface
-	 * as we do for flipping full screen surfaces.
 	 */
 	pixman_region32_init(&renderer_region);
+	pixman_region32_init(&planes_region);
 	pixman_region32_init(&occluded_region);
 
 	wl_list_for_each(ev, &output_base->compositor->view_list, link) {
@@ -523,7 +812,6 @@ drm_output_propose_state(struct weston_output *output_base,
 		bool force_renderer = false;
 		pixman_region32_t clipped_view;
 		bool totally_occluded = false;
-		bool overlay_occluded = false;
 
 		drm_debug(b, "\t\t\t[view] evaluating view %p for "
 		             "output %s (%lu)\n",
@@ -546,7 +834,7 @@ drm_output_propose_state(struct weston_output *output_base,
 			force_renderer = true;
 		}
 
-		if (!ev->surface->buffer_ref.buffer) {
+		if (!weston_view_has_valid_buffer(ev)) {
 			drm_debug(b, "\t\t\t\t[view] not assigning view %p to plane "
 			             "(no buffer available)\n", ev);
 			force_renderer = true;
@@ -561,6 +849,9 @@ drm_output_propose_state(struct weston_output *output_base,
 		pixman_region32_init(&surface_overlap);
 		pixman_region32_subtract(&surface_overlap, &clipped_view,
 					 &occluded_region);
+		/* if the view is completely occluded then ignore that
+		 * view; includes the case where occluded_region covers
+		 * the entire output */
 		totally_occluded = !pixman_region32_not_empty(&surface_overlap);
 		if (totally_occluded) {
 			drm_debug(b, "\t\t\t\t[view] ignoring view %p "
@@ -580,6 +871,7 @@ drm_output_propose_state(struct weston_output *output_base,
 			             "(occluded by renderer views)\n", ev);
 			force_renderer = true;
 		}
+		pixman_region32_fini(&surface_overlap);
 
 		/* In case of enforced mode of content-protection do not
 		 * assign planes for a protected surface on an unsecured output.
@@ -591,51 +883,18 @@ drm_output_propose_state(struct weston_output *output_base,
 			force_renderer = true;
 		}
 
-		/* We do not control the stacking order of overlay planes;
+		if (!force_renderer) {
-		 * the scanout plane is strictly stacked bottom and the cursor
+			drm_debug(b, "\t\t\t[plane] started with zpos %"PRIu64"\n",
-		 * plane top, but the ordering of overlay planes with respect
+				      current_lowest_zpos);
-		 * to each other is undefined. Make sure we do not have two
+			ps = drm_output_prepare_plane_view(state, ev, mode,
-		 * planes overlapping each other. */
+							   current_lowest_zpos);
-		pixman_region32_intersect(&surface_overlap, &occluded_region,
-					  &clipped_view);
-		if (pixman_region32_not_empty(&surface_overlap)) {
-			drm_debug(b, "\t\t\t\t[view] not assigning view %p to plane "
-			             "(occluded by other overlay planes)\n", ev);
-			overlay_occluded = true;
 		}
-		pixman_region32_fini(&surface_overlap);
-
-		/* The cursor plane is 'special' in the sense that we can still
-		 * place it in the legacy API, and we gate that with a separate
-		 * cursors_are_broken flag. */
-		if (!force_renderer && !overlay_occluded && !b->cursors_are_broken)
-			ps = drm_output_prepare_cursor_view(state, ev);
-
-		/* If sprites are disabled or the view is not fully opaque, we
-		 * must put the view into the renderer - unless it has already
-		 * been placed in the cursor plane, which can handle alpha. */
-		if (!ps && !planes_ok) {
-			drm_debug(b, "\t\t\t\t[view] not assigning view %p to plane "
-			             "(precluded by mode)\n", ev);
-			force_renderer = true;
-		}
-		if (!ps && !weston_view_is_opaque(ev, &clipped_view)) {
-			drm_debug(b, "\t\t\t\t[view] not assigning view %p to plane "
-			             "(view not fully opaque)\n", ev);
-			force_renderer = true;
-		}
-
-		/* Only try to place scanout surfaces in planes-only mode; in
-		 * mixed mode, we have already failed to place a view on the
-		 * scanout surface, forcing usage of the renderer on the
-		 * scanout plane. */
-		if (!ps && !force_renderer && !renderer_ok)
-			ps = drm_output_prepare_scanout_view(state, ev, mode);
-
-		if (!ps && !overlay_occluded && !force_renderer)
-			ps = drm_output_prepare_overlay_view(state, ev, mode);
 
 		if (ps) {
+			current_lowest_zpos = ps->zpos;
+			drm_debug(b, "\t\t\t[plane] next zpos to use %"PRIu64"\n",
+				      current_lowest_zpos);
+
 			/* If we have been assigned to an overlay or scanout
 			 * plane, add this area to the occluded region, so
 			 * other views are known to be behind it. The cursor
@@ -644,10 +903,22 @@ drm_output_propose_state(struct weston_output *output_base,
 			 * be added to the renderer region nor the occluded
 			 * region. */
 			if (ps->plane->type != WDRM_PLANE_TYPE_CURSOR) {
+				pixman_region32_union(&planes_region,
+						      &planes_region,
+						      &clipped_view);
+
+				if (!weston_view_is_opaque(ev, &clipped_view))
+					pixman_region32_intersect(&clipped_view,
+								  &clipped_view,
+								  &ev->transform.opaque);
+				/* the visible-and-opaque region of this view
+				 * will occlude views underneath it */
 				pixman_region32_union(&occluded_region,
 						      &occluded_region,
 						      &clipped_view);
+
 				pixman_region32_fini(&clipped_view);
+
 			}
 			continue;
 		}
@@ -666,9 +937,24 @@ drm_output_propose_state(struct weston_output *output_base,
 		pixman_region32_union(&renderer_region,
 				      &renderer_region,
 				      &clipped_view);
+
+		if (!weston_view_is_opaque(ev, &clipped_view))
+			pixman_region32_intersect(&clipped_view,
+						  &clipped_view,
+						  &ev->transform.opaque);
+
+		pixman_region32_union(&occluded_region,
+				      &occluded_region,
+				      &clipped_view);
+
 		pixman_region32_fini(&clipped_view);
+
+		drm_debug(b, "\t\t\t\t[view] view %p will be placed "
+			     "on the renderer\n", ev);
 	}
+
 	pixman_region32_fini(&renderer_region);
+	pixman_region32_fini(&planes_region);
 	pixman_region32_fini(&occluded_region);
 
 	/* In renderer-only mode, we can't test the state as we don't have a
@@ -676,6 +962,14 @@ drm_output_propose_state(struct weston_output *output_base,
 	if (mode == DRM_OUTPUT_PROPOSE_STATE_RENDERER_ONLY)
 		return state;
 
+	/* check if we have invalid zpos values, like duplicate(s) */
+	ret = drm_output_check_zpos_plane_states(state);
+	if (ret != 0) {
+		drm_debug(b, "\t\t[view] failing state generation: "
+			     "zpos values are in-consistent\n");
+		goto err;
+	}
+
 	/* Check to see if this state will actually work. */
 	ret = drm_pending_state_test(state->pending_state);
 	if (ret != 0) {
@@ -764,7 +1058,7 @@ drm_assign_planes(struct weston_output *output_base, void *repaint_data)
 		 * to the buffer anyway, there is no side effects.
 		 */
 		if (b->use_pixman ||
-		    (ev->surface->buffer_ref.buffer &&
+		    (weston_view_has_valid_buffer(ev) &&
 		    (!wl_shm_buffer_get(ev->surface->buffer_ref.buffer->resource) ||
 		     (ev->surface->width <= b->cursor_width &&
 		      ev->surface->height <= b->cursor_height))))

libweston/compositor.c

@@ -1852,6 +1852,41 @@ weston_view_is_opaque(struct weston_view *ev, pixman_region32_t *region)
 	return ret;
 }
 
+/** Check if the view has a valid buffer available
+ *
+ * @param ev The view to check if it has a valid buffer.
+ *
+ * Returns true if the view has a valid buffer or false otherwise.
+ */
+WL_EXPORT bool
+weston_view_has_valid_buffer(struct weston_view *ev)
+{
+	return ev->surface->buffer_ref.buffer != NULL;
+}
+
+/** Check if the view matches the entire output
+ *
+ * @param ev The view to check.
+ * @param output The output to check against.
+ *
+ * Returns true if the view does indeed matches the entire output.
+ */
+WL_EXPORT bool
+weston_view_matches_output_entirely(struct weston_view *ev,
+				    struct weston_output *output)
+{
+	pixman_box32_t *extents =
+		pixman_region32_extents(&ev->transform.boundingbox);
+
+	if (extents->x1 != output->x ||
+	    extents->y1 != output->y ||
+	    extents->x2 != output->x + output->width ||
+	    extents->y2 != output->y + output->height)
+		return false;
+
+	return true;
+}
+
 /* Check if a surface has a view assigned to it
  *
  * The indicator is set manually when mapping

libweston/libweston-internal.h

@@ -287,6 +287,12 @@ weston_view_from_global_float(struct weston_view *view,
 bool
 weston_view_is_opaque(struct weston_view *ev, pixman_region32_t *region);
 
+bool
+weston_view_has_valid_buffer(struct weston_view *ev);
+
+bool
+weston_view_matches_output_entirely(struct weston_view *ev,
+				    struct weston_output *output);
 void
 weston_view_move_to_plane(struct weston_view *view,
 			  struct weston_plane *plane);