[1/4] drm: add generic zpos property
diff mbox

Message ID 1463048902-9388-1-git-send-email-benjamin.gaignard@linaro.org
State Not Applicable
Headers show

Commit Message

Benjamin Gaignard May 12, 2016, 10:28 a.m. UTC
From: Marek Szyprowski <m.szyprowski@samsung.com>

This patch adds support for generic plane's zpos property property with
well-defined semantics:
- added zpos properties to plane and plane state structures
- added helpers for normalizing zpos properties of given set of planes
- well defined semantics: planes are sorted by zpos values and then plane
  id value if zpos equals

Normalized zpos values are calculated automatically when generic
muttable zpos property has been initialized. Drivers can simply use
plane_state->normalized_zpos in their atomic_check and/or plane_update
callbacks without any additional calls to DRM core.

Signed-off-by: Marek Szyprowski <m.szyprowski@samsung.com>

Compare to Marek's original patch zpos property is now specific to each
plane and no more to the core.
Normalize function take care of the range of per plane defined range
before set normalized_zpos.

Signed-off-by: Benjamin Gaignard <benjamin.gaignard@linaro.org>

Cc: Inki Dae <inki.dae@samsung.com>
Cc: Daniel Vetter <daniel@ffwll.ch>
Cc: Ville Syrjala <ville.syrjala@linux.intel.com>
Cc: Joonyoung Shim <jy0922.shim@samsung.com>
Cc: Seung-Woo Kim <sw0312.kim@samsung.com>
Cc: Andrzej Hajda <a.hajda@samsung.com>
Cc: Krzysztof Kozlowski <k.kozlowski@samsung.com>
Cc: Bartlomiej Zolnierkiewicz <b.zolnierkie@samsung.com>
Cc: Tobias Jakobi <tjakobi@math.uni-bielefeld.de>
Cc: Gustavo Padovan <gustavo@padovan.org>
Cc: vincent.abriou@st.com
Cc: fabien.dessenne@st.com
Cc: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
---
 Documentation/DocBook/gpu.tmpl      |  10 ++
 drivers/gpu/drm/Makefile            |   2 +-
 drivers/gpu/drm/drm_atomic.c        |   4 +
 drivers/gpu/drm/drm_atomic_helper.c |   6 +
 drivers/gpu/drm/drm_blend.c         | 229 ++++++++++++++++++++++++++++++++++++
 drivers/gpu/drm/drm_crtc_internal.h |   3 +
 include/drm/drm_crtc.h              |  28 +++++
 7 files changed, 281 insertions(+), 1 deletion(-)
 create mode 100644 drivers/gpu/drm/drm_blend.c

Comments

Ville Syrjälä May 12, 2016, 11:51 a.m. UTC | #1
On Thu, May 12, 2016 at 12:28:19PM +0200, Benjamin Gaignard wrote:
> From: Marek Szyprowski <m.szyprowski@samsung.com>
> 
> This patch adds support for generic plane's zpos property property with
> well-defined semantics:
> - added zpos properties to plane and plane state structures
> - added helpers for normalizing zpos properties of given set of planes
> - well defined semantics: planes are sorted by zpos values and then plane
>   id value if zpos equals
> 
> Normalized zpos values are calculated automatically when generic
> muttable zpos property has been initialized. Drivers can simply use
> plane_state->normalized_zpos in their atomic_check and/or plane_update
> callbacks without any additional calls to DRM core.
> 
> Signed-off-by: Marek Szyprowski <m.szyprowski@samsung.com>
> 
> Compare to Marek's original patch zpos property is now specific to each
> plane and no more to the core.
> Normalize function take care of the range of per plane defined range
> before set normalized_zpos.
> 
> Signed-off-by: Benjamin Gaignard <benjamin.gaignard@linaro.org>
> 
> Cc: Inki Dae <inki.dae@samsung.com>
> Cc: Daniel Vetter <daniel@ffwll.ch>
> Cc: Ville Syrjala <ville.syrjala@linux.intel.com>
> Cc: Joonyoung Shim <jy0922.shim@samsung.com>
> Cc: Seung-Woo Kim <sw0312.kim@samsung.com>
> Cc: Andrzej Hajda <a.hajda@samsung.com>
> Cc: Krzysztof Kozlowski <k.kozlowski@samsung.com>
> Cc: Bartlomiej Zolnierkiewicz <b.zolnierkie@samsung.com>
> Cc: Tobias Jakobi <tjakobi@math.uni-bielefeld.de>
> Cc: Gustavo Padovan <gustavo@padovan.org>
> Cc: vincent.abriou@st.com
> Cc: fabien.dessenne@st.com
> Cc: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
> ---
>  Documentation/DocBook/gpu.tmpl      |  10 ++
>  drivers/gpu/drm/Makefile            |   2 +-
>  drivers/gpu/drm/drm_atomic.c        |   4 +
>  drivers/gpu/drm/drm_atomic_helper.c |   6 +
>  drivers/gpu/drm/drm_blend.c         | 229 ++++++++++++++++++++++++++++++++++++
>  drivers/gpu/drm/drm_crtc_internal.h |   3 +
>  include/drm/drm_crtc.h              |  28 +++++
>  7 files changed, 281 insertions(+), 1 deletion(-)
>  create mode 100644 drivers/gpu/drm/drm_blend.c
> 
> diff --git a/Documentation/DocBook/gpu.tmpl b/Documentation/DocBook/gpu.tmpl
> index 9dd48f7..0df6abb 100644
> --- a/Documentation/DocBook/gpu.tmpl
> +++ b/Documentation/DocBook/gpu.tmpl
> @@ -2151,6 +2151,16 @@ void intel_crt_init(struct drm_device *dev)
>  		the underlying hardware).</td>
>  	</tr>
>  	<tr>
> +	<td valign="top" > "zpos" </td>
> +	<td valign="top" >RANGE</td>
> +	<td valign="top" >Min= driver dependent, Max= driver dependent</td>
> +	<td valign="top" >Plane</td>
> +	<td valign="top" >Plane's 'z' position during blending operation (0 for background, highest for frontmost).
> +		If two planes assigned to same CRTC have equal zpos values, the plane with higher plane
> +		id is treated as closer to front. Can be IMMUTABLE if driver doesn't support changing
> +		planes' order. Exact value range is driver dependent.</td>
> +	</tr>
> +	<tr>
>  	<td rowspan="20" valign="top" >i915</td>
>  	<td rowspan="2" valign="top" >Generic</td>
>  	<td valign="top" >"Broadcast RGB"</td>
> diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile
> index 2bd3e5a..df88253 100644
> --- a/drivers/gpu/drm/Makefile
> +++ b/drivers/gpu/drm/Makefile
> @@ -2,7 +2,7 @@
>  # Makefile for the drm device driver.  This driver provides support for the
>  # Direct Rendering Infrastructure (DRI) in XFree86 4.1.0 and higher.
>  
> -drm-y       :=	drm_auth.o drm_bufs.o drm_cache.o \
> +drm-y       :=	drm_auth.o drm_bufs.o drm_blend.o drm_cache.o \
>  		drm_context.o drm_dma.o \
>  		drm_fops.o drm_gem.o drm_ioctl.o drm_irq.o \
>  		drm_lock.o drm_memory.o drm_drv.o drm_vm.o \
> diff --git a/drivers/gpu/drm/drm_atomic.c b/drivers/gpu/drm/drm_atomic.c
> index 86e89db..bd457ca 100644
> --- a/drivers/gpu/drm/drm_atomic.c
> +++ b/drivers/gpu/drm/drm_atomic.c
> @@ -700,6 +700,8 @@ int drm_atomic_plane_set_property(struct drm_plane *plane,
>  		state->src_h = val;
>  	} else if (property == config->rotation_property) {
>  		state->rotation = val;
> +	} else if (property == plane->zpos_property) {
> +		state->zpos = val;
>  	} else if (plane->funcs->atomic_set_property) {
>  		return plane->funcs->atomic_set_property(plane, state,
>  				property, val);
> @@ -756,6 +758,8 @@ drm_atomic_plane_get_property(struct drm_plane *plane,
>  		*val = state->src_h;
>  	} else if (property == config->rotation_property) {
>  		*val = state->rotation;
> +	} else if (property == plane->zpos_property) {
> +		*val = state->zpos;
>  	} else if (plane->funcs->atomic_get_property) {
>  		return plane->funcs->atomic_get_property(plane, state, property, val);
>  	} else {
> diff --git a/drivers/gpu/drm/drm_atomic_helper.c b/drivers/gpu/drm/drm_atomic_helper.c
> index 997fd21..f10652f 100644
> --- a/drivers/gpu/drm/drm_atomic_helper.c
> +++ b/drivers/gpu/drm/drm_atomic_helper.c
> @@ -32,6 +32,8 @@
>  #include <drm/drm_atomic_helper.h>
>  #include <linux/fence.h>
>  
> +#include "drm_crtc_internal.h"
> +
>  /**
>   * DOC: overview
>   *
> @@ -587,6 +589,10 @@ drm_atomic_helper_check_planes(struct drm_device *dev,
>  	struct drm_plane_state *plane_state;
>  	int i, ret = 0;
>  
> +	ret = drm_atomic_helper_normalize_zpos(dev, state);
> +	if (ret)
> +		return ret;
> +
>  	for_each_plane_in_state(state, plane, plane_state, i) {
>  		const struct drm_plane_helper_funcs *funcs;
>  
> diff --git a/drivers/gpu/drm/drm_blend.c b/drivers/gpu/drm/drm_blend.c
> new file mode 100644
> index 0000000..eef59bb
> --- /dev/null
> +++ b/drivers/gpu/drm/drm_blend.c
> @@ -0,0 +1,229 @@
> +/*
> + * Copyright (C) 2016 Samsung Electronics Co.Ltd
> + * Authors:
> + *	Marek Szyprowski <m.szyprowski@samsung.com>
> + *
> + * DRM core plane blending related functions
> + *
> + * Permission to use, copy, modify, distribute, and sell this software and its
> + * documentation for any purpose is hereby granted without fee, provided that
> + * the above copyright notice appear in all copies and that both that copyright
> + * notice and this permission notice appear in supporting documentation, and
> + * that the name of the copyright holders not be used in advertising or
> + * publicity pertaining to distribution of the software without specific,
> + * written prior permission.  The copyright holders make no representations
> + * about the suitability of this software for any purpose.  It is provided "as
> + * is" without express or implied warranty.
> + *
> + * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
> + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
> + * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
> + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
> + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
> + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
> + * OF THIS SOFTWARE.
> + */
> +#include <drm/drmP.h>
> +#include <drm/drm_atomic.h>
> +#include <drm/drm_crtc.h>
> +#include <linux/export.h>
> +#include <linux/slab.h>
> +#include <linux/sort.h>
> +
> +#include "drm_internal.h"
> +
> +/**
> + * drm_plane_create_zpos_property - create mutable zpos property
> + * @plane: drm plane
> + * @min: minimal possible value of zpos property
> + * @max: maximal possible value of zpos property
> + *
> + * This function initializes generic mutable zpos property and enables support
> + * for it in drm core. Drivers can then attach this property to planes to enable
> + * support for configurable planes arrangement during blending operation.
> + * Once mutable zpos property has been enabled, the DRM core will automatically
> + * calculate drm_plane_state->normalized_zpos values. Usually min should be set
> + * to 0 and max to maximal number of planes for given crtc - 1.
> + *
> + * If zpos of some planes cannot be changed (like fixed background or
> + * cursor/topmost planes), driver should adjust min/max values and assign those
> + * planes immutable zpos property with lower or higher values (for more
> + * information, see drm_mode_create_zpos_immutable_property() function). In such
> + * case driver should also assign proper initial zpos values for all planes in
> + * its plane_reset() callback, so the planes will be always sorted properly.
> + *
> + * Returns:
> + * Zero on success, negative errno on failure.
> + */
> +int drm_plane_create_zpos_property(struct drm_plane *plane,
> +				   unsigned int min, unsigned int max)
> +{
> +	struct drm_property *prop;
> +
> +	prop = drm_property_create_range(plane->dev, 0, "zpos", min, max);
> +	if (!prop)
> +		return -ENOMEM;
> +
> +	drm_object_attach_property(&plane->base, prop, min);
> +
> +	plane->zpos_property = prop;
> +	return 0;
> +}
> +EXPORT_SYMBOL(drm_plane_create_zpos_property);
> +
> +/**
> + * drm_plane_create_zpos_immutable_property - create immuttable zpos property
> + * @plane: drm plane
> + * @min: minimal possible value of zpos property
> + * @max: maximal possible value of zpos property
> + *
> + * This function initializes generic immutable zpos property and enables
> + * support for it in drm core. Using this property driver lets userspace
> + * to get the arrangement of the planes for blending operation and notifies
> + * it that the hardware (or driver) doesn't support changing of the planes'
> + * order.
> + *
> + * Returns:
> + * Zero on success, negative errno on failure.
> + */
> +int drm_plane_create_zpos_immutable_property(struct drm_plane *plane,
> +					     unsigned int min, unsigned int max)
> +{
> +	struct drm_property *prop;
> +
> +	prop = drm_property_create_range(plane->dev, DRM_MODE_PROP_IMMUTABLE,
> +					 "zpos", min, max);
> +	if (!prop)
> +		return -ENOMEM;
> +
> +	drm_object_attach_property(&plane->base, prop, min);
> +
> +	plane->zpos_property = prop;
> +	return 0;
> +}
> +EXPORT_SYMBOL(drm_plane_create_zpos_immutable_property);
> +
> +static int drm_atomic_state_zpos_cmp(const void *a, const void *b)
> +{
> +	const struct drm_plane_state *sa = *(struct drm_plane_state **)a;
> +	const struct drm_plane_state *sb = *(struct drm_plane_state **)b;
> +
> +	if (sa->zpos != sb->zpos)
> +		return sa->zpos - sb->zpos;
> +	else
> +		return sa->plane->base.id - sb->plane->base.id;
> +}

Still not really convinced this normalization is a good idea when we
have atomic. It made sense before atomic since otherwise you might not be
able to swap the zpos of two planes without shutting one of them down,
but it makes interpreting the zpos prop values more confusing. And with
atomic we don't actually need it AFAICS. Or do we have an actual use case
for this behaviour?

> +
> +/**
> + * drm_atomic_helper_crtc_normalize_zpos - calculate normalized zpos values
> + * @crtc: crtc with planes, which have to be considered for normalization
> + * @crtc_state: new atomic state to apply
> + *
> + * This function checks new states of all planes assigned to given crtc and
> + * calculates normalized zpos value for them. Planes are compared first by their
> + * zpos values, then by plane id (if zpos equals). Plane with lowest zpos value
> + * is at the bottom. The plane_state->normalized_zpos is then filled with unique
> + * values from 0 to number of active planes in crtc minus one.
> + *
> + * RETURNS
> + * Zero for success or -errno
> + */
> +int drm_atomic_helper_crtc_normalize_zpos(struct drm_crtc *crtc,
> +					  struct drm_crtc_state *crtc_state)
> +{
> +	struct drm_atomic_state *state = crtc_state->state;
> +	struct drm_device *dev = crtc->dev;
> +	int total_planes = dev->mode_config.num_total_plane;
> +	struct drm_plane_state **states;
> +	struct drm_plane *plane;
> +	int i, zpos, n = 0;
> +	int ret = 0;
> +
> +	DRM_DEBUG_ATOMIC("[CRTC:%d:%s] calculating normalized zpos values\n",
> +			 crtc->base.id, crtc->name);
> +
> +	states = kmalloc(total_planes * sizeof(*states), GFP_KERNEL);

kmalloc_array(..., GFP_TEMPORARY);

> +	if (!states)
> +		return -ENOMEM;
> +
> +	/*
> +	 * Normalization process might create new states for planes which
> +	 * normalized_zpos has to be recalculated.
> +	 */
> +	drm_for_each_plane_mask(plane, dev, crtc_state->plane_mask) {
> +		struct drm_plane_state *plane_state =
> +			drm_atomic_get_plane_state(state, plane);
> +		if (IS_ERR(plane_state)) {
> +			ret = PTR_ERR(plane_state);
> +			goto done;
> +		}

Hmm. So if we change the zpos for any plane, we get to re-check every
plane. Not the most efficient thing perhaps, since on some hardware
you might only have a subset of planes that can even change their
zpos. OTOH I suppose it does make life a bit simpler when you don't
have to think which planes might be affected, so I guess it's fine.

> +		states[n++] = plane_state;
> +		DRM_DEBUG_ATOMIC("[PLANE:%d:%s] processing zpos value %d\n",
> +				 plane->base.id, plane->name,
> +				 plane_state->zpos);
> +	}
> +
> +	sort(states, n, sizeof(*states), drm_atomic_state_zpos_cmp, NULL);
> +
> +	for (i = 0, zpos = 0; i < n; i++, zpos++) {
> +		plane = states[i]->plane;
> +
> +		zpos = max_t(int, zpos, states[i]->zpos);
> +
> +		states[i]->normalized_zpos = zpos;
> +		DRM_DEBUG_ATOMIC("[PLANE:%d:%s] normalized zpos value %d\n",
> +				 plane->base.id, plane->name, zpos);
> +	}
> +	crtc_state->zpos_changed = true;
> +
> +done:
> +	kfree(states);
> +	return ret;
> +}
> +EXPORT_SYMBOL(drm_atomic_helper_crtc_normalize_zpos);
> +
> +/**
> + * drm_atomic_helper_normalize_zpos - calculate normalized zpos values for all
> + *				      crtcs
> + * @dev: DRM device
> + * @state: atomic state of DRM device
> + *
> + * This function calculates normalized zpos value for all modified planes in
> + * the provided atomic state of DRM device. For more information, see
> + * drm_atomic_helper_crtc_normalize_zpos() function.
> + *
> + * RETURNS
> + * Zero for success or -errno
> + */
> +int drm_atomic_helper_normalize_zpos(struct drm_device *dev,
> +				     struct drm_atomic_state *state)
> +{
> +	struct drm_crtc *crtc;
> +	struct drm_crtc_state *crtc_state;
> +	struct drm_plane *plane;
> +	struct drm_plane_state *plane_state;
> +	int i, ret = 0;
> +
> +	for_each_plane_in_state(state, plane, plane_state, i) {
> +		crtc = plane_state->crtc;
> +		if (!crtc)
> +			continue;
> +		if (plane->state->zpos != plane_state->zpos) {
> +			crtc_state =
> +				drm_atomic_get_existing_crtc_state(state, crtc);
> +			crtc_state->zpos_changed = true;
> +		}
> +	}
> +
> +	for_each_crtc_in_state(state, crtc, crtc_state, i) {
> +		if (crtc_state->plane_mask != crtc->state->plane_mask ||
> +		    crtc_state->zpos_changed) {
> +			ret = drm_atomic_helper_crtc_normalize_zpos(crtc,
> +								    crtc_state);
> +			if (ret)
> +				return ret;
> +		}
> +	}
> +	return 0;
> +}
> +EXPORT_SYMBOL(drm_atomic_helper_normalize_zpos);
> diff --git a/drivers/gpu/drm/drm_crtc_internal.h b/drivers/gpu/drm/drm_crtc_internal.h
> index a78c138..37d9068 100644
> --- a/drivers/gpu/drm/drm_crtc_internal.h
> +++ b/drivers/gpu/drm/drm_crtc_internal.h
> @@ -42,3 +42,6 @@ int drm_atomic_get_property(struct drm_mode_object *obj,
>  int drm_mode_atomic_ioctl(struct drm_device *dev,
>  			  void *data, struct drm_file *file_priv);
>  
> +/* drm_blend.c */
> +int drm_atomic_helper_normalize_zpos(struct drm_device *dev,
> +				     struct drm_atomic_state *state);
> diff --git a/include/drm/drm_crtc.h b/include/drm/drm_crtc.h
> index d1559cd..921c93f 100644
> --- a/include/drm/drm_crtc.h
> +++ b/include/drm/drm_crtc.h
> @@ -305,6 +305,7 @@ struct drm_plane_helper_funcs;
>   * @mode_changed: crtc_state->mode or crtc_state->enable has been changed
>   * @active_changed: crtc_state->active has been toggled.
>   * @connectors_changed: connectors to this crtc have been updated
> + * @zpos_changed: zpos values of planes on this crtc have been updated
>   * @color_mgmt_changed: color management properties have changed (degamma or
>   *	gamma LUT or CSC matrix)
>   * @plane_mask: bitmask of (1 << drm_plane_index(plane)) of attached planes
> @@ -340,6 +341,7 @@ struct drm_crtc_state {
>  	bool mode_changed : 1;
>  	bool active_changed : 1;
>  	bool connectors_changed : 1;
> +	bool zpos_changed : 1;
>  	bool color_mgmt_changed : 1;
>  
>  	/* attached planes bitmask:
> @@ -1263,6 +1265,9 @@ struct drm_connector {
>   *	plane (in 16.16)
>   * @src_w: width of visible portion of plane (in 16.16)
>   * @src_h: height of visible portion of plane (in 16.16)
> + * @zpos: priority of the given plane on crtc (optional)
> + * @normalized_zpos: normalized value of zpos: unique, range from 0 to N-1
> + *	 for given crtc
>   * @state: backpointer to global drm_atomic_state
>   */
>  struct drm_plane_state {
> @@ -1283,6 +1288,10 @@ struct drm_plane_state {
>  	/* Plane rotation */
>  	unsigned int rotation;
>  
> +	/* Plane zpos */
> +	unsigned int zpos;
> +	unsigned int normalized_zpos;
> +
>  	struct drm_atomic_state *state;
>  };
>  
> @@ -1516,6 +1525,7 @@ enum drm_plane_type {
>   * @properties: property tracking for this plane
>   * @type: type of plane (overlay, primary, cursor)
>   * @state: current atomic state for this plane
> + * @zpos_property: zpos property for this plane
>   */
>  struct drm_plane {
>  	struct drm_device *dev;
> @@ -1546,6 +1556,8 @@ struct drm_plane {
>  	const struct drm_plane_helper_funcs *helper_private;
>  
>  	struct drm_plane_state *state;
> +
> +	struct drm_property *zpos_property;
>  };
>  
>  /**
> @@ -2554,6 +2566,22 @@ extern struct drm_property *drm_mode_create_rotation_property(struct drm_device
>  extern unsigned int drm_rotation_simplify(unsigned int rotation,
>  					  unsigned int supported_rotations);
>  
> +int drm_plane_atomic_set_zpos_property(struct drm_plane *plane,
> +				       struct drm_plane_state *state,
> +				       struct drm_property *property,
> +				       uint64_t val);
> +
> +int drm_plane_atomic_get_zpos_property(struct drm_plane *plane,
> +				       const struct drm_plane_state *state,
> +				       struct drm_property *property,
> +				       uint64_t *val);
> +
> +int drm_plane_create_zpos_property(struct drm_plane *plane,
> +				   unsigned int min, unsigned int max);
> +int drm_plane_create_zpos_immutable_property(struct drm_plane *plane,
> +					     unsigned int min,
> +					     unsigned int max);
> +
>  /* Helpers */
>  
>  static inline struct drm_plane *drm_plane_find(struct drm_device *dev,
> -- 
> 1.9.1
Daniel Vetter May 12, 2016, 1:36 p.m. UTC | #2
On Thu, May 12, 2016 at 12:28:19PM +0200, Benjamin Gaignard wrote:
> From: Marek Szyprowski <m.szyprowski@samsung.com>
> 
> This patch adds support for generic plane's zpos property property with
> well-defined semantics:
> - added zpos properties to plane and plane state structures
> - added helpers for normalizing zpos properties of given set of planes
> - well defined semantics: planes are sorted by zpos values and then plane
>   id value if zpos equals
> 
> Normalized zpos values are calculated automatically when generic
> muttable zpos property has been initialized. Drivers can simply use
> plane_state->normalized_zpos in their atomic_check and/or plane_update
> callbacks without any additional calls to DRM core.
> 
> Signed-off-by: Marek Szyprowski <m.szyprowski@samsung.com>
> 
> Compare to Marek's original patch zpos property is now specific to each
> plane and no more to the core.
> Normalize function take care of the range of per plane defined range
> before set normalized_zpos.
> 
> Signed-off-by: Benjamin Gaignard <benjamin.gaignard@linaro.org>
> 
> Cc: Inki Dae <inki.dae@samsung.com>
> Cc: Daniel Vetter <daniel@ffwll.ch>
> Cc: Ville Syrjala <ville.syrjala@linux.intel.com>
> Cc: Joonyoung Shim <jy0922.shim@samsung.com>
> Cc: Seung-Woo Kim <sw0312.kim@samsung.com>
> Cc: Andrzej Hajda <a.hajda@samsung.com>
> Cc: Krzysztof Kozlowski <k.kozlowski@samsung.com>
> Cc: Bartlomiej Zolnierkiewicz <b.zolnierkie@samsung.com>
> Cc: Tobias Jakobi <tjakobi@math.uni-bielefeld.de>
> Cc: Gustavo Padovan <gustavo@padovan.org>
> Cc: vincent.abriou@st.com
> Cc: fabien.dessenne@st.com
> Cc: Laurent Pinchart <laurent.pinchart@ideasonboard.com>

When resending you must have a changelog somewhere. At elast in the cover
letter, better is per-patch. Otherwise reviewers need to dig out the old
threads and compare themselves.
-Daniel

> ---
>  Documentation/DocBook/gpu.tmpl      |  10 ++
>  drivers/gpu/drm/Makefile            |   2 +-
>  drivers/gpu/drm/drm_atomic.c        |   4 +
>  drivers/gpu/drm/drm_atomic_helper.c |   6 +
>  drivers/gpu/drm/drm_blend.c         | 229 ++++++++++++++++++++++++++++++++++++
>  drivers/gpu/drm/drm_crtc_internal.h |   3 +
>  include/drm/drm_crtc.h              |  28 +++++
>  7 files changed, 281 insertions(+), 1 deletion(-)
>  create mode 100644 drivers/gpu/drm/drm_blend.c
> 
> diff --git a/Documentation/DocBook/gpu.tmpl b/Documentation/DocBook/gpu.tmpl
> index 9dd48f7..0df6abb 100644
> --- a/Documentation/DocBook/gpu.tmpl
> +++ b/Documentation/DocBook/gpu.tmpl
> @@ -2151,6 +2151,16 @@ void intel_crt_init(struct drm_device *dev)
>  		the underlying hardware).</td>
>  	</tr>
>  	<tr>
> +	<td valign="top" > "zpos" </td>
> +	<td valign="top" >RANGE</td>
> +	<td valign="top" >Min= driver dependent, Max= driver dependent</td>
> +	<td valign="top" >Plane</td>
> +	<td valign="top" >Plane's 'z' position during blending operation (0 for background, highest for frontmost).
> +		If two planes assigned to same CRTC have equal zpos values, the plane with higher plane
> +		id is treated as closer to front. Can be IMMUTABLE if driver doesn't support changing
> +		planes' order. Exact value range is driver dependent.</td>
> +	</tr>
> +	<tr>
>  	<td rowspan="20" valign="top" >i915</td>
>  	<td rowspan="2" valign="top" >Generic</td>
>  	<td valign="top" >"Broadcast RGB"</td>
> diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile
> index 2bd3e5a..df88253 100644
> --- a/drivers/gpu/drm/Makefile
> +++ b/drivers/gpu/drm/Makefile
> @@ -2,7 +2,7 @@
>  # Makefile for the drm device driver.  This driver provides support for the
>  # Direct Rendering Infrastructure (DRI) in XFree86 4.1.0 and higher.
>  
> -drm-y       :=	drm_auth.o drm_bufs.o drm_cache.o \
> +drm-y       :=	drm_auth.o drm_bufs.o drm_blend.o drm_cache.o \
>  		drm_context.o drm_dma.o \
>  		drm_fops.o drm_gem.o drm_ioctl.o drm_irq.o \
>  		drm_lock.o drm_memory.o drm_drv.o drm_vm.o \
> diff --git a/drivers/gpu/drm/drm_atomic.c b/drivers/gpu/drm/drm_atomic.c
> index 86e89db..bd457ca 100644
> --- a/drivers/gpu/drm/drm_atomic.c
> +++ b/drivers/gpu/drm/drm_atomic.c
> @@ -700,6 +700,8 @@ int drm_atomic_plane_set_property(struct drm_plane *plane,
>  		state->src_h = val;
>  	} else if (property == config->rotation_property) {
>  		state->rotation = val;
> +	} else if (property == plane->zpos_property) {
> +		state->zpos = val;
>  	} else if (plane->funcs->atomic_set_property) {
>  		return plane->funcs->atomic_set_property(plane, state,
>  				property, val);
> @@ -756,6 +758,8 @@ drm_atomic_plane_get_property(struct drm_plane *plane,
>  		*val = state->src_h;
>  	} else if (property == config->rotation_property) {
>  		*val = state->rotation;
> +	} else if (property == plane->zpos_property) {
> +		*val = state->zpos;
>  	} else if (plane->funcs->atomic_get_property) {
>  		return plane->funcs->atomic_get_property(plane, state, property, val);
>  	} else {
> diff --git a/drivers/gpu/drm/drm_atomic_helper.c b/drivers/gpu/drm/drm_atomic_helper.c
> index 997fd21..f10652f 100644
> --- a/drivers/gpu/drm/drm_atomic_helper.c
> +++ b/drivers/gpu/drm/drm_atomic_helper.c
> @@ -32,6 +32,8 @@
>  #include <drm/drm_atomic_helper.h>
>  #include <linux/fence.h>
>  
> +#include "drm_crtc_internal.h"
> +
>  /**
>   * DOC: overview
>   *
> @@ -587,6 +589,10 @@ drm_atomic_helper_check_planes(struct drm_device *dev,
>  	struct drm_plane_state *plane_state;
>  	int i, ret = 0;
>  
> +	ret = drm_atomic_helper_normalize_zpos(dev, state);
> +	if (ret)
> +		return ret;
> +
>  	for_each_plane_in_state(state, plane, plane_state, i) {
>  		const struct drm_plane_helper_funcs *funcs;
>  
> diff --git a/drivers/gpu/drm/drm_blend.c b/drivers/gpu/drm/drm_blend.c
> new file mode 100644
> index 0000000..eef59bb
> --- /dev/null
> +++ b/drivers/gpu/drm/drm_blend.c
> @@ -0,0 +1,229 @@
> +/*
> + * Copyright (C) 2016 Samsung Electronics Co.Ltd
> + * Authors:
> + *	Marek Szyprowski <m.szyprowski@samsung.com>
> + *
> + * DRM core plane blending related functions
> + *
> + * Permission to use, copy, modify, distribute, and sell this software and its
> + * documentation for any purpose is hereby granted without fee, provided that
> + * the above copyright notice appear in all copies and that both that copyright
> + * notice and this permission notice appear in supporting documentation, and
> + * that the name of the copyright holders not be used in advertising or
> + * publicity pertaining to distribution of the software without specific,
> + * written prior permission.  The copyright holders make no representations
> + * about the suitability of this software for any purpose.  It is provided "as
> + * is" without express or implied warranty.
> + *
> + * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
> + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
> + * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
> + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
> + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
> + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
> + * OF THIS SOFTWARE.
> + */
> +#include <drm/drmP.h>
> +#include <drm/drm_atomic.h>
> +#include <drm/drm_crtc.h>
> +#include <linux/export.h>
> +#include <linux/slab.h>
> +#include <linux/sort.h>
> +
> +#include "drm_internal.h"
> +
> +/**
> + * drm_plane_create_zpos_property - create mutable zpos property
> + * @plane: drm plane
> + * @min: minimal possible value of zpos property
> + * @max: maximal possible value of zpos property
> + *
> + * This function initializes generic mutable zpos property and enables support
> + * for it in drm core. Drivers can then attach this property to planes to enable
> + * support for configurable planes arrangement during blending operation.
> + * Once mutable zpos property has been enabled, the DRM core will automatically
> + * calculate drm_plane_state->normalized_zpos values. Usually min should be set
> + * to 0 and max to maximal number of planes for given crtc - 1.
> + *
> + * If zpos of some planes cannot be changed (like fixed background or
> + * cursor/topmost planes), driver should adjust min/max values and assign those
> + * planes immutable zpos property with lower or higher values (for more
> + * information, see drm_mode_create_zpos_immutable_property() function). In such
> + * case driver should also assign proper initial zpos values for all planes in
> + * its plane_reset() callback, so the planes will be always sorted properly.
> + *
> + * Returns:
> + * Zero on success, negative errno on failure.
> + */
> +int drm_plane_create_zpos_property(struct drm_plane *plane,
> +				   unsigned int min, unsigned int max)
> +{
> +	struct drm_property *prop;
> +
> +	prop = drm_property_create_range(plane->dev, 0, "zpos", min, max);
> +	if (!prop)
> +		return -ENOMEM;
> +
> +	drm_object_attach_property(&plane->base, prop, min);
> +
> +	plane->zpos_property = prop;
> +	return 0;
> +}
> +EXPORT_SYMBOL(drm_plane_create_zpos_property);
> +
> +/**
> + * drm_plane_create_zpos_immutable_property - create immuttable zpos property
> + * @plane: drm plane
> + * @min: minimal possible value of zpos property
> + * @max: maximal possible value of zpos property
> + *
> + * This function initializes generic immutable zpos property and enables
> + * support for it in drm core. Using this property driver lets userspace
> + * to get the arrangement of the planes for blending operation and notifies
> + * it that the hardware (or driver) doesn't support changing of the planes'
> + * order.
> + *
> + * Returns:
> + * Zero on success, negative errno on failure.
> + */
> +int drm_plane_create_zpos_immutable_property(struct drm_plane *plane,
> +					     unsigned int min, unsigned int max)
> +{
> +	struct drm_property *prop;
> +
> +	prop = drm_property_create_range(plane->dev, DRM_MODE_PROP_IMMUTABLE,
> +					 "zpos", min, max);
> +	if (!prop)
> +		return -ENOMEM;
> +
> +	drm_object_attach_property(&plane->base, prop, min);
> +
> +	plane->zpos_property = prop;
> +	return 0;
> +}
> +EXPORT_SYMBOL(drm_plane_create_zpos_immutable_property);
> +
> +static int drm_atomic_state_zpos_cmp(const void *a, const void *b)
> +{
> +	const struct drm_plane_state *sa = *(struct drm_plane_state **)a;
> +	const struct drm_plane_state *sb = *(struct drm_plane_state **)b;
> +
> +	if (sa->zpos != sb->zpos)
> +		return sa->zpos - sb->zpos;
> +	else
> +		return sa->plane->base.id - sb->plane->base.id;
> +}
> +
> +/**
> + * drm_atomic_helper_crtc_normalize_zpos - calculate normalized zpos values
> + * @crtc: crtc with planes, which have to be considered for normalization
> + * @crtc_state: new atomic state to apply
> + *
> + * This function checks new states of all planes assigned to given crtc and
> + * calculates normalized zpos value for them. Planes are compared first by their
> + * zpos values, then by plane id (if zpos equals). Plane with lowest zpos value
> + * is at the bottom. The plane_state->normalized_zpos is then filled with unique
> + * values from 0 to number of active planes in crtc minus one.
> + *
> + * RETURNS
> + * Zero for success or -errno
> + */
> +int drm_atomic_helper_crtc_normalize_zpos(struct drm_crtc *crtc,
> +					  struct drm_crtc_state *crtc_state)
> +{
> +	struct drm_atomic_state *state = crtc_state->state;
> +	struct drm_device *dev = crtc->dev;
> +	int total_planes = dev->mode_config.num_total_plane;
> +	struct drm_plane_state **states;
> +	struct drm_plane *plane;
> +	int i, zpos, n = 0;
> +	int ret = 0;
> +
> +	DRM_DEBUG_ATOMIC("[CRTC:%d:%s] calculating normalized zpos values\n",
> +			 crtc->base.id, crtc->name);
> +
> +	states = kmalloc(total_planes * sizeof(*states), GFP_KERNEL);
> +	if (!states)
> +		return -ENOMEM;
> +
> +	/*
> +	 * Normalization process might create new states for planes which
> +	 * normalized_zpos has to be recalculated.
> +	 */
> +	drm_for_each_plane_mask(plane, dev, crtc_state->plane_mask) {
> +		struct drm_plane_state *plane_state =
> +			drm_atomic_get_plane_state(state, plane);
> +		if (IS_ERR(plane_state)) {
> +			ret = PTR_ERR(plane_state);
> +			goto done;
> +		}
> +		states[n++] = plane_state;
> +		DRM_DEBUG_ATOMIC("[PLANE:%d:%s] processing zpos value %d\n",
> +				 plane->base.id, plane->name,
> +				 plane_state->zpos);
> +	}
> +
> +	sort(states, n, sizeof(*states), drm_atomic_state_zpos_cmp, NULL);
> +
> +	for (i = 0, zpos = 0; i < n; i++, zpos++) {
> +		plane = states[i]->plane;
> +
> +		zpos = max_t(int, zpos, states[i]->zpos);
> +
> +		states[i]->normalized_zpos = zpos;
> +		DRM_DEBUG_ATOMIC("[PLANE:%d:%s] normalized zpos value %d\n",
> +				 plane->base.id, plane->name, zpos);
> +	}
> +	crtc_state->zpos_changed = true;
> +
> +done:
> +	kfree(states);
> +	return ret;
> +}
> +EXPORT_SYMBOL(drm_atomic_helper_crtc_normalize_zpos);
> +
> +/**
> + * drm_atomic_helper_normalize_zpos - calculate normalized zpos values for all
> + *				      crtcs
> + * @dev: DRM device
> + * @state: atomic state of DRM device
> + *
> + * This function calculates normalized zpos value for all modified planes in
> + * the provided atomic state of DRM device. For more information, see
> + * drm_atomic_helper_crtc_normalize_zpos() function.
> + *
> + * RETURNS
> + * Zero for success or -errno
> + */
> +int drm_atomic_helper_normalize_zpos(struct drm_device *dev,
> +				     struct drm_atomic_state *state)
> +{
> +	struct drm_crtc *crtc;
> +	struct drm_crtc_state *crtc_state;
> +	struct drm_plane *plane;
> +	struct drm_plane_state *plane_state;
> +	int i, ret = 0;
> +
> +	for_each_plane_in_state(state, plane, plane_state, i) {
> +		crtc = plane_state->crtc;
> +		if (!crtc)
> +			continue;
> +		if (plane->state->zpos != plane_state->zpos) {
> +			crtc_state =
> +				drm_atomic_get_existing_crtc_state(state, crtc);
> +			crtc_state->zpos_changed = true;
> +		}
> +	}
> +
> +	for_each_crtc_in_state(state, crtc, crtc_state, i) {
> +		if (crtc_state->plane_mask != crtc->state->plane_mask ||
> +		    crtc_state->zpos_changed) {
> +			ret = drm_atomic_helper_crtc_normalize_zpos(crtc,
> +								    crtc_state);
> +			if (ret)
> +				return ret;
> +		}
> +	}
> +	return 0;
> +}
> +EXPORT_SYMBOL(drm_atomic_helper_normalize_zpos);
> diff --git a/drivers/gpu/drm/drm_crtc_internal.h b/drivers/gpu/drm/drm_crtc_internal.h
> index a78c138..37d9068 100644
> --- a/drivers/gpu/drm/drm_crtc_internal.h
> +++ b/drivers/gpu/drm/drm_crtc_internal.h
> @@ -42,3 +42,6 @@ int drm_atomic_get_property(struct drm_mode_object *obj,
>  int drm_mode_atomic_ioctl(struct drm_device *dev,
>  			  void *data, struct drm_file *file_priv);
>  
> +/* drm_blend.c */
> +int drm_atomic_helper_normalize_zpos(struct drm_device *dev,
> +				     struct drm_atomic_state *state);
> diff --git a/include/drm/drm_crtc.h b/include/drm/drm_crtc.h
> index d1559cd..921c93f 100644
> --- a/include/drm/drm_crtc.h
> +++ b/include/drm/drm_crtc.h
> @@ -305,6 +305,7 @@ struct drm_plane_helper_funcs;
>   * @mode_changed: crtc_state->mode or crtc_state->enable has been changed
>   * @active_changed: crtc_state->active has been toggled.
>   * @connectors_changed: connectors to this crtc have been updated
> + * @zpos_changed: zpos values of planes on this crtc have been updated
>   * @color_mgmt_changed: color management properties have changed (degamma or
>   *	gamma LUT or CSC matrix)
>   * @plane_mask: bitmask of (1 << drm_plane_index(plane)) of attached planes
> @@ -340,6 +341,7 @@ struct drm_crtc_state {
>  	bool mode_changed : 1;
>  	bool active_changed : 1;
>  	bool connectors_changed : 1;
> +	bool zpos_changed : 1;
>  	bool color_mgmt_changed : 1;
>  
>  	/* attached planes bitmask:
> @@ -1263,6 +1265,9 @@ struct drm_connector {
>   *	plane (in 16.16)
>   * @src_w: width of visible portion of plane (in 16.16)
>   * @src_h: height of visible portion of plane (in 16.16)
> + * @zpos: priority of the given plane on crtc (optional)
> + * @normalized_zpos: normalized value of zpos: unique, range from 0 to N-1
> + *	 for given crtc
>   * @state: backpointer to global drm_atomic_state
>   */
>  struct drm_plane_state {
> @@ -1283,6 +1288,10 @@ struct drm_plane_state {
>  	/* Plane rotation */
>  	unsigned int rotation;
>  
> +	/* Plane zpos */
> +	unsigned int zpos;
> +	unsigned int normalized_zpos;
> +
>  	struct drm_atomic_state *state;
>  };
>  
> @@ -1516,6 +1525,7 @@ enum drm_plane_type {
>   * @properties: property tracking for this plane
>   * @type: type of plane (overlay, primary, cursor)
>   * @state: current atomic state for this plane
> + * @zpos_property: zpos property for this plane
>   */
>  struct drm_plane {
>  	struct drm_device *dev;
> @@ -1546,6 +1556,8 @@ struct drm_plane {
>  	const struct drm_plane_helper_funcs *helper_private;
>  
>  	struct drm_plane_state *state;
> +
> +	struct drm_property *zpos_property;
>  };
>  
>  /**
> @@ -2554,6 +2566,22 @@ extern struct drm_property *drm_mode_create_rotation_property(struct drm_device
>  extern unsigned int drm_rotation_simplify(unsigned int rotation,
>  					  unsigned int supported_rotations);
>  
> +int drm_plane_atomic_set_zpos_property(struct drm_plane *plane,
> +				       struct drm_plane_state *state,
> +				       struct drm_property *property,
> +				       uint64_t val);
> +
> +int drm_plane_atomic_get_zpos_property(struct drm_plane *plane,
> +				       const struct drm_plane_state *state,
> +				       struct drm_property *property,
> +				       uint64_t *val);
> +
> +int drm_plane_create_zpos_property(struct drm_plane *plane,
> +				   unsigned int min, unsigned int max);
> +int drm_plane_create_zpos_immutable_property(struct drm_plane *plane,
> +					     unsigned int min,
> +					     unsigned int max);
> +
>  /* Helpers */
>  
>  static inline struct drm_plane *drm_plane_find(struct drm_device *dev,
> -- 
> 1.9.1
>
Laurent Pinchart May 12, 2016, 7:06 p.m. UTC | #3
On Thursday 12 May 2016 15:36:07 Daniel Vetter wrote:
> On Thu, May 12, 2016 at 12:28:19PM +0200, Benjamin Gaignard wrote:
> > From: Marek Szyprowski <m.szyprowski@samsung.com>
> > 
> > This patch adds support for generic plane's zpos property property with
> > well-defined semantics:
> > - added zpos properties to plane and plane state structures
> > - added helpers for normalizing zpos properties of given set of planes
> > - well defined semantics: planes are sorted by zpos values and then plane
> > 
> >   id value if zpos equals
> > 
> > Normalized zpos values are calculated automatically when generic
> > muttable zpos property has been initialized. Drivers can simply use
> > plane_state->normalized_zpos in their atomic_check and/or plane_update
> > callbacks without any additional calls to DRM core.
> > 
> > Signed-off-by: Marek Szyprowski <m.szyprowski@samsung.com>
> > 
> > Compare to Marek's original patch zpos property is now specific to each
> > plane and no more to the core.
> > Normalize function take care of the range of per plane defined range
> > before set normalized_zpos.
> > 
> > Signed-off-by: Benjamin Gaignard <benjamin.gaignard@linaro.org>
> > 
> > Cc: Inki Dae <inki.dae@samsung.com>
> > Cc: Daniel Vetter <daniel@ffwll.ch>
> > Cc: Ville Syrjala <ville.syrjala@linux.intel.com>
> > Cc: Joonyoung Shim <jy0922.shim@samsung.com>
> > Cc: Seung-Woo Kim <sw0312.kim@samsung.com>
> > Cc: Andrzej Hajda <a.hajda@samsung.com>
> > Cc: Krzysztof Kozlowski <k.kozlowski@samsung.com>
> > Cc: Bartlomiej Zolnierkiewicz <b.zolnierkie@samsung.com>
> > Cc: Tobias Jakobi <tjakobi@math.uni-bielefeld.de>
> > Cc: Gustavo Padovan <gustavo@padovan.org>
> > Cc: vincent.abriou@st.com
> > Cc: fabien.dessenne@st.com
> > Cc: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
> 
> When resending you must have a changelog somewhere. At elast in the cover
> letter, better is per-patch. Otherwise reviewers need to dig out the old
> threads and compare themselves.

And please update the subject as well to include the version number. You can 
use

$ git format-patch --cover --subject-prefix 'PATCH vX'
Laurent Pinchart May 12, 2016, 7:20 p.m. UTC | #4
Hi Ville,

On Thursday 12 May 2016 14:51:55 Ville Syrjälä wrote:
> On Thu, May 12, 2016 at 12:28:19PM +0200, Benjamin Gaignard wrote:
> > From: Marek Szyprowski <m.szyprowski@samsung.com>
> > 
> > This patch adds support for generic plane's zpos property property with
> > well-defined semantics:
> > - added zpos properties to plane and plane state structures
> > - added helpers for normalizing zpos properties of given set of planes
> > - well defined semantics: planes are sorted by zpos values and then plane
> >   id value if zpos equals
> > 
> > Normalized zpos values are calculated automatically when generic
> > muttable zpos property has been initialized. Drivers can simply use
> > plane_state->normalized_zpos in their atomic_check and/or plane_update
> > callbacks without any additional calls to DRM core.
> > 
> > Signed-off-by: Marek Szyprowski <m.szyprowski@samsung.com>
> > 
> > Compare to Marek's original patch zpos property is now specific to each
> > plane and no more to the core.
> > Normalize function take care of the range of per plane defined range
> > before set normalized_zpos.
> > 
> > Signed-off-by: Benjamin Gaignard <benjamin.gaignard@linaro.org>
> > 
> > Cc: Inki Dae <inki.dae@samsung.com>
> > Cc: Daniel Vetter <daniel@ffwll.ch>
> > Cc: Ville Syrjala <ville.syrjala@linux.intel.com>
> > Cc: Joonyoung Shim <jy0922.shim@samsung.com>
> > Cc: Seung-Woo Kim <sw0312.kim@samsung.com>
> > Cc: Andrzej Hajda <a.hajda@samsung.com>
> > Cc: Krzysztof Kozlowski <k.kozlowski@samsung.com>
> > Cc: Bartlomiej Zolnierkiewicz <b.zolnierkie@samsung.com>
> > Cc: Tobias Jakobi <tjakobi@math.uni-bielefeld.de>
> > Cc: Gustavo Padovan <gustavo@padovan.org>
> > Cc: vincent.abriou@st.com
> > Cc: fabien.dessenne@st.com
> > Cc: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
> > ---
> > 
> >  Documentation/DocBook/gpu.tmpl      |  10 ++
> >  drivers/gpu/drm/Makefile            |   2 +-
> >  drivers/gpu/drm/drm_atomic.c        |   4 +
> >  drivers/gpu/drm/drm_atomic_helper.c |   6 +
> >  drivers/gpu/drm/drm_blend.c         | 229 +++++++++++++++++++++++++++++++
> >  drivers/gpu/drm/drm_crtc_internal.h |   3 +
> >  include/drm/drm_crtc.h              |  28 +++++
> >  7 files changed, 281 insertions(+), 1 deletion(-)
> >  create mode 100644 drivers/gpu/drm/drm_blend.c

[snip]

> > diff --git a/drivers/gpu/drm/drm_blend.c b/drivers/gpu/drm/drm_blend.c
> > new file mode 100644
> > index 0000000..eef59bb
> > --- /dev/null
> > +++ b/drivers/gpu/drm/drm_blend.c
> > @@ -0,0 +1,229 @@

[snip]

> > +static int drm_atomic_state_zpos_cmp(const void *a, const void *b)
> > +{
> > +	const struct drm_plane_state *sa = *(struct drm_plane_state **)a;
> > +	const struct drm_plane_state *sb = *(struct drm_plane_state **)b;
> > +
> > +	if (sa->zpos != sb->zpos)
> > +		return sa->zpos - sb->zpos;
> > +	else
> > +		return sa->plane->base.id - sb->plane->base.id;
> > +}
> 
> Still not really convinced this normalization is a good idea when we
> have atomic. It made sense before atomic since otherwise you might not be
> able to swap the zpos of two planes without shutting one of them down,
> but it makes interpreting the zpos prop values more confusing. And with
> atomic we don't actually need it AFAICS. Or do we have an actual use case
> for this behaviour?

Speaking selfishly about my use case (rcar-du-drm), I need to sort planes in 
display order from 0 to N-1 as that's how the hardware is programmed. 
Normalization gives me an array of sorted planes, which is exactly what I 
need. I expect other drivers to have similar requirements, so normalization in 
the core will allow code sharing.

Now, is your concern that allowing two planes to have the same zpos isn't 
needed with the atomic API ? I agree with that, but it would also make it 
impossible to swap two planes using the legacy API implemented on top of 
atomic drivers. I'll let others decide whether this is considered as a 
concern.

While at it, Benjamin told me that you've requested configurable min/max 
values per plane, what are your use cases for that ? On the same topic, please 
see below.

> > +
> > +/**
> > + * drm_atomic_helper_crtc_normalize_zpos - calculate normalized zpos
> > values
> > + * @crtc: crtc with planes, which have to be considered for normalization
> > + * @crtc_state: new atomic state to apply
> > + *
> > + * This function checks new states of all planes assigned to given crtc
> > and
> > + * calculates normalized zpos value for them. Planes are compared first
> > by their
> > + * zpos values, then by plane id (if zpos equals). Plane with lowest zpos
> > value
> > + * is at the bottom. The plane_state->normalized_zpos is then filled with
> > unique
> > + * values from 0 to number of active planes in crtc minus one.
> > + *
> > + * RETURNS
> > + * Zero for success or -errno
> > + */
> > +int drm_atomic_helper_crtc_normalize_zpos(struct drm_crtc *crtc,
> > +					  struct drm_crtc_state *crtc_state)
> > +{
> > +	struct drm_atomic_state *state = crtc_state->state;
> > +	struct drm_device *dev = crtc->dev;
> > +	int total_planes = dev->mode_config.num_total_plane;
> > +	struct drm_plane_state **states;
> > +	struct drm_plane *plane;
> > +	int i, zpos, n = 0;
> > +	int ret = 0;
> > +
> > +	DRM_DEBUG_ATOMIC("[CRTC:%d:%s] calculating normalized zpos values\n",
> > +			 crtc->base.id, crtc->name);
> > +
> > +	states = kmalloc(total_planes * sizeof(*states), GFP_KERNEL);
> 
> kmalloc_array(..., GFP_TEMPORARY);
> 
> > +	if (!states)
> > +		return -ENOMEM;
> > +
> > +	/*
> > +	 * Normalization process might create new states for planes which
> > +	 * normalized_zpos has to be recalculated.
> > +	 */
> > +	drm_for_each_plane_mask(plane, dev, crtc_state->plane_mask) {
> > +		struct drm_plane_state *plane_state =
> > +			drm_atomic_get_plane_state(state, plane);
> > +		if (IS_ERR(plane_state)) {
> > +			ret = PTR_ERR(plane_state);
> > +			goto done;
> > +		}
> 
> Hmm. So if we change the zpos for any plane, we get to re-check every
> plane. Not the most efficient thing perhaps, since on some hardware
> you might only have a subset of planes that can even change their
> zpos. OTOH I suppose it does make life a bit simpler when you don't
> have to think which planes might be affected, so I guess it's fine.
> 
> > +		states[n++] = plane_state;
> > +		DRM_DEBUG_ATOMIC("[PLANE:%d:%s] processing zpos value %d\n",
> > +				 plane->base.id, plane->name,
> > +				 plane_state->zpos);
> > +	}
> > +
> > +	sort(states, n, sizeof(*states), drm_atomic_state_zpos_cmp, NULL);
> > +
> > +	for (i = 0, zpos = 0; i < n; i++, zpos++) {
> > +		plane = states[i]->plane;
> > +
> > +		zpos = max_t(int, zpos, states[i]->zpos);

The purpose of this code is to support the per-plane min/max zpos values. As 
Benjamin explained, for example if the zpos range is [0,2] for plane X and 
[4,6] for plane Y, we need to be sure the min zpos value of plane Y is 4. To 
this I replied that's exactly what I'd rather avoid. I think the core code 
should take care of sorting planes, taking driver-specific constraints into 
account when possible (too exotic constraints can always be implemented 
directly by drivers), and then leave to the drivers the responsibility of 
taking the sorted planes array and computing whatever hardware-specific 
configuration is needed. Sorting planes from 0 to N-1 seems to be like a 
better API than having semi-random values for the normalized zpos. Do we have 
use cases that wouldn't be covered by a simpler implementation ?

> > +		states[i]->normalized_zpos = zpos;
> > +		DRM_DEBUG_ATOMIC("[PLANE:%d:%s] normalized zpos value %d\n",
> > +				 plane->base.id, plane->name, zpos);
> > +	}
> > +	crtc_state->zpos_changed = true;
> > +
> > +done:
> > +	kfree(states);
> > +	return ret;
> > +}
> > +EXPORT_SYMBOL(drm_atomic_helper_crtc_normalize_zpos);
Javier Martinez Canillas May 12, 2016, 7:25 p.m. UTC | #5
>
> And please update the subject as well to include the version number. You can
> use
>
> $ git format-patch --cover --subject-prefix 'PATCH vX'
>

And git even has a -v option now, so this could just be:

$ git format-patch --cover -vX

Best regards,
Javier
--
To unsubscribe from this list: send the line "unsubscribe linux-samsung-soc" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Ville Syrjälä May 12, 2016, 7:46 p.m. UTC | #6
On Thu, May 12, 2016 at 10:20:12PM +0300, Laurent Pinchart wrote:
> Hi Ville,
> 
> On Thursday 12 May 2016 14:51:55 Ville Syrjälä wrote:
> > On Thu, May 12, 2016 at 12:28:19PM +0200, Benjamin Gaignard wrote:
> > > From: Marek Szyprowski <m.szyprowski@samsung.com>
> > > 
> > > This patch adds support for generic plane's zpos property property with
> > > well-defined semantics:
> > > - added zpos properties to plane and plane state structures
> > > - added helpers for normalizing zpos properties of given set of planes
> > > - well defined semantics: planes are sorted by zpos values and then plane
> > >   id value if zpos equals
> > > 
> > > Normalized zpos values are calculated automatically when generic
> > > muttable zpos property has been initialized. Drivers can simply use
> > > plane_state->normalized_zpos in their atomic_check and/or plane_update
> > > callbacks without any additional calls to DRM core.
> > > 
> > > Signed-off-by: Marek Szyprowski <m.szyprowski@samsung.com>
> > > 
> > > Compare to Marek's original patch zpos property is now specific to each
> > > plane and no more to the core.
> > > Normalize function take care of the range of per plane defined range
> > > before set normalized_zpos.
> > > 
> > > Signed-off-by: Benjamin Gaignard <benjamin.gaignard@linaro.org>
> > > 
> > > Cc: Inki Dae <inki.dae@samsung.com>
> > > Cc: Daniel Vetter <daniel@ffwll.ch>
> > > Cc: Ville Syrjala <ville.syrjala@linux.intel.com>
> > > Cc: Joonyoung Shim <jy0922.shim@samsung.com>
> > > Cc: Seung-Woo Kim <sw0312.kim@samsung.com>
> > > Cc: Andrzej Hajda <a.hajda@samsung.com>
> > > Cc: Krzysztof Kozlowski <k.kozlowski@samsung.com>
> > > Cc: Bartlomiej Zolnierkiewicz <b.zolnierkie@samsung.com>
> > > Cc: Tobias Jakobi <tjakobi@math.uni-bielefeld.de>
> > > Cc: Gustavo Padovan <gustavo@padovan.org>
> > > Cc: vincent.abriou@st.com
> > > Cc: fabien.dessenne@st.com
> > > Cc: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
> > > ---
> > > 
> > >  Documentation/DocBook/gpu.tmpl      |  10 ++
> > >  drivers/gpu/drm/Makefile            |   2 +-
> > >  drivers/gpu/drm/drm_atomic.c        |   4 +
> > >  drivers/gpu/drm/drm_atomic_helper.c |   6 +
> > >  drivers/gpu/drm/drm_blend.c         | 229 +++++++++++++++++++++++++++++++
> > >  drivers/gpu/drm/drm_crtc_internal.h |   3 +
> > >  include/drm/drm_crtc.h              |  28 +++++
> > >  7 files changed, 281 insertions(+), 1 deletion(-)
> > >  create mode 100644 drivers/gpu/drm/drm_blend.c
> 
> [snip]
> 
> > > diff --git a/drivers/gpu/drm/drm_blend.c b/drivers/gpu/drm/drm_blend.c
> > > new file mode 100644
> > > index 0000000..eef59bb
> > > --- /dev/null
> > > +++ b/drivers/gpu/drm/drm_blend.c
> > > @@ -0,0 +1,229 @@
> 
> [snip]
> 
> > > +static int drm_atomic_state_zpos_cmp(const void *a, const void *b)
> > > +{
> > > +	const struct drm_plane_state *sa = *(struct drm_plane_state **)a;
> > > +	const struct drm_plane_state *sb = *(struct drm_plane_state **)b;
> > > +
> > > +	if (sa->zpos != sb->zpos)
> > > +		return sa->zpos - sb->zpos;
> > > +	else
> > > +		return sa->plane->base.id - sb->plane->base.id;
> > > +}
> > 
> > Still not really convinced this normalization is a good idea when we
> > have atomic. It made sense before atomic since otherwise you might not be
> > able to swap the zpos of two planes without shutting one of them down,
> > but it makes interpreting the zpos prop values more confusing. And with
> > atomic we don't actually need it AFAICS. Or do we have an actual use case
> > for this behaviour?
> 
> Speaking selfishly about my use case (rcar-du-drm), I need to sort planes in 
> display order from 0 to N-1 as that's how the hardware is programmed. 
> Normalization gives me an array of sorted planes, which is exactly what I 
> need. I expect other drivers to have similar requirements, so normalization in 
> the core will allow code sharing.

It just eliminates duplicate zpos values. It won't re-sort your plane
states magically or anything like that. Nor does it guarantee that
the zpos values for the actually visible planes are even contiguous.

> 
> Now, is your concern that allowing two planes to have the same zpos isn't 
> needed with the atomic API ? I agree with that, but it would also make it 
> impossible to swap two planes using the legacy API implemented on top of 
> atomic drivers. I'll let others decide whether this is considered as a 
> concern.
> 
> While at it, Benjamin told me that you've requested configurable min/max 
> values per plane, what are your use cases for that ? On the same topic, please 
> see below.
> 
> > > +
> > > +/**
> > > + * drm_atomic_helper_crtc_normalize_zpos - calculate normalized zpos
> > > values
> > > + * @crtc: crtc with planes, which have to be considered for normalization
> > > + * @crtc_state: new atomic state to apply
> > > + *
> > > + * This function checks new states of all planes assigned to given crtc
> > > and
> > > + * calculates normalized zpos value for them. Planes are compared first
> > > by their
> > > + * zpos values, then by plane id (if zpos equals). Plane with lowest zpos
> > > value
> > > + * is at the bottom. The plane_state->normalized_zpos is then filled with
> > > unique
> > > + * values from 0 to number of active planes in crtc minus one.
> > > + *
> > > + * RETURNS
> > > + * Zero for success or -errno
> > > + */
> > > +int drm_atomic_helper_crtc_normalize_zpos(struct drm_crtc *crtc,
> > > +					  struct drm_crtc_state *crtc_state)
> > > +{
> > > +	struct drm_atomic_state *state = crtc_state->state;
> > > +	struct drm_device *dev = crtc->dev;
> > > +	int total_planes = dev->mode_config.num_total_plane;
> > > +	struct drm_plane_state **states;
> > > +	struct drm_plane *plane;
> > > +	int i, zpos, n = 0;
> > > +	int ret = 0;
> > > +
> > > +	DRM_DEBUG_ATOMIC("[CRTC:%d:%s] calculating normalized zpos values\n",
> > > +			 crtc->base.id, crtc->name);
> > > +
> > > +	states = kmalloc(total_planes * sizeof(*states), GFP_KERNEL);
> > 
> > kmalloc_array(..., GFP_TEMPORARY);
> > 
> > > +	if (!states)
> > > +		return -ENOMEM;
> > > +
> > > +	/*
> > > +	 * Normalization process might create new states for planes which
> > > +	 * normalized_zpos has to be recalculated.
> > > +	 */
> > > +	drm_for_each_plane_mask(plane, dev, crtc_state->plane_mask) {
> > > +		struct drm_plane_state *plane_state =
> > > +			drm_atomic_get_plane_state(state, plane);
> > > +		if (IS_ERR(plane_state)) {
> > > +			ret = PTR_ERR(plane_state);
> > > +			goto done;
> > > +		}
> > 
> > Hmm. So if we change the zpos for any plane, we get to re-check every
> > plane. Not the most efficient thing perhaps, since on some hardware
> > you might only have a subset of planes that can even change their
> > zpos. OTOH I suppose it does make life a bit simpler when you don't
> > have to think which planes might be affected, so I guess it's fine.
> > 
> > > +		states[n++] = plane_state;
> > > +		DRM_DEBUG_ATOMIC("[PLANE:%d:%s] processing zpos value %d\n",
> > > +				 plane->base.id, plane->name,
> > > +				 plane_state->zpos);
> > > +	}
> > > +
> > > +	sort(states, n, sizeof(*states), drm_atomic_state_zpos_cmp, NULL);
> > > +
> > > +	for (i = 0, zpos = 0; i < n; i++, zpos++) {
> > > +		plane = states[i]->plane;
> > > +
> > > +		zpos = max_t(int, zpos, states[i]->zpos);
> 
> The purpose of this code is to support the per-plane min/max zpos values. As 
> Benjamin explained, for example if the zpos range is [0,2] for plane X and 
> [4,6] for plane Y, we need to be sure the min zpos value of plane Y is 4. To 
> this I replied that's exactly what I'd rather avoid. I think the core code 
> should take care of sorting planes, taking driver-specific constraints into 
> account when possible (too exotic constraints can always be implemented 
> directly by drivers), and then leave to the drivers the responsibility of 
> taking the sorted planes array and computing whatever hardware-specific 
> configuration is needed. Sorting planes from 0 to N-1 seems to be like a 
> better API than having semi-random values for the normalized zpos. Do we have 
> use cases that wouldn't be covered by a simpler implementation ?

The point of exposing ranges is to give userspace at least some chance
of getting the order right. Otherwise it'll just have to randomly try
different orders until something works. Most hardware is quite
constrained in this. Some don't support changing the zpos at all, in
which case we would set min==max.

> 
> > > +		states[i]->normalized_zpos = zpos;
> > > +		DRM_DEBUG_ATOMIC("[PLANE:%d:%s] normalized zpos value %d\n",
> > > +				 plane->base.id, plane->name, zpos);
> > > +	}
> > > +	crtc_state->zpos_changed = true;
> > > +
> > > +done:
> > > +	kfree(states);
> > > +	return ret;
> > > +}
> > > +EXPORT_SYMBOL(drm_atomic_helper_crtc_normalize_zpos);
> 
> -- 
> Regards,
> 
> Laurent Pinchart
Laurent Pinchart May 12, 2016, 8:15 p.m. UTC | #7
Hi Ville,

On Thursday 12 May 2016 22:46:05 Ville Syrjälä wrote:
> On Thu, May 12, 2016 at 10:20:12PM +0300, Laurent Pinchart wrote:
> > On Thursday 12 May 2016 14:51:55 Ville Syrjälä wrote:
> >> On Thu, May 12, 2016 at 12:28:19PM +0200, Benjamin Gaignard wrote:
> >>> From: Marek Szyprowski <m.szyprowski@samsung.com>
> >>> 
> >>> This patch adds support for generic plane's zpos property property
> >>> with well-defined semantics:
> >>> - added zpos properties to plane and plane state structures
> >>> - added helpers for normalizing zpos properties of given set of planes
> >>> - well defined semantics: planes are sorted by zpos values and then
> >>>   plane id value if zpos equals
> >>> 
> >>> Normalized zpos values are calculated automatically when generic
> >>> muttable zpos property has been initialized. Drivers can simply use
> >>> plane_state->normalized_zpos in their atomic_check and/or plane_update
> >>> callbacks without any additional calls to DRM core.
> >>> 
> >>> Signed-off-by: Marek Szyprowski <m.szyprowski@samsung.com>
> >>> 
> >>> Compare to Marek's original patch zpos property is now specific to
> >>> each plane and no more to the core.
> >>> Normalize function take care of the range of per plane defined range
> >>> before set normalized_zpos.
> >>> 
> >>> Signed-off-by: Benjamin Gaignard <benjamin.gaignard@linaro.org>
> >>> 
> >>> Cc: Inki Dae <inki.dae@samsung.com>
> >>> Cc: Daniel Vetter <daniel@ffwll.ch>
> >>> Cc: Ville Syrjala <ville.syrjala@linux.intel.com>
> >>> Cc: Joonyoung Shim <jy0922.shim@samsung.com>
> >>> Cc: Seung-Woo Kim <sw0312.kim@samsung.com>
> >>> Cc: Andrzej Hajda <a.hajda@samsung.com>
> >>> Cc: Krzysztof Kozlowski <k.kozlowski@samsung.com>
> >>> Cc: Bartlomiej Zolnierkiewicz <b.zolnierkie@samsung.com>
> >>> Cc: Tobias Jakobi <tjakobi@math.uni-bielefeld.de>
> >>> Cc: Gustavo Padovan <gustavo@padovan.org>
> >>> Cc: vincent.abriou@st.com
> >>> Cc: fabien.dessenne@st.com
> >>> Cc: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
> >>> ---
> >>> 
> >>>  Documentation/DocBook/gpu.tmpl      |  10 ++
> >>>  drivers/gpu/drm/Makefile            |   2 +-
> >>>  drivers/gpu/drm/drm_atomic.c        |   4 +
> >>>  drivers/gpu/drm/drm_atomic_helper.c |   6 +
> >>>  drivers/gpu/drm/drm_blend.c         | 229 ++++++++++++++++++++++++++++
> >>>  drivers/gpu/drm/drm_crtc_internal.h |   3 +
> >>>  include/drm/drm_crtc.h              |  28 +++++
> >>>  7 files changed, 281 insertions(+), 1 deletion(-)
> >>>  create mode 100644 drivers/gpu/drm/drm_blend.c
> > 
> > [snip]
> > 
> >>> diff --git a/drivers/gpu/drm/drm_blend.c b/drivers/gpu/drm/drm_blend.c
> >>> new file mode 100644
> >>> index 0000000..eef59bb
> >>> --- /dev/null
> >>> +++ b/drivers/gpu/drm/drm_blend.c
> >>> @@ -0,0 +1,229 @@
> > 
> > [snip]
> > 
> >>> +static int drm_atomic_state_zpos_cmp(const void *a, const void *b)
> >>> +{
> >>> +	const struct drm_plane_state *sa = *(struct drm_plane_state **)a;
> >>> +	const struct drm_plane_state *sb = *(struct drm_plane_state **)b;
> >>> +
> >>> +	if (sa->zpos != sb->zpos)
> >>> +		return sa->zpos - sb->zpos;
> >>> +	else
> >>> +		return sa->plane->base.id - sb->plane->base.id;
> >>> +}
> >> 
> >> Still not really convinced this normalization is a good idea when we
> >> have atomic. It made sense before atomic since otherwise you might not
> >> be able to swap the zpos of two planes without shutting one of them
> >> down, but it makes interpreting the zpos prop values more confusing. And
> >> with atomic we don't actually need it AFAICS. Or do we have an actual
> >> use case for this behaviour?
> > 
> > Speaking selfishly about my use case (rcar-du-drm), I need to sort planes
> > in display order from 0 to N-1 as that's how the hardware is programmed.
> > Normalization gives me an array of sorted planes, which is exactly what I
> > need. I expect other drivers to have similar requirements, so
> > normalization in the core will allow code sharing.
> 
> It just eliminates duplicate zpos values. It won't re-sort your plane
> states magically or anything like that. Nor does it guarantee that
> the zpos values for the actually visible planes are even contiguous.

To make normalization useful in my case I need contiguous values starting at 
0.

> > Now, is your concern that allowing two planes to have the same zpos isn't
> > needed with the atomic API ? I agree with that, but it would also make it
> > impossible to swap two planes using the legacy API implemented on top of
> > atomic drivers. I'll let others decide whether this is considered as a
> > concern.

Any opinion on this ?

> > While at it, Benjamin told me that you've requested configurable min/max
> > values per plane, what are your use cases for that ? On the same topic,
> > please see below.
> > 
> >>> +
> >>> +/**
> >>> + * drm_atomic_helper_crtc_normalize_zpos - calculate normalized zpos
> >>> values
> >>> + * @crtc: crtc with planes, which have to be considered for
> >>> normalization
> >>> + * @crtc_state: new atomic state to apply
> >>> + *
> >>> + * This function checks new states of all planes assigned to given
> >>> crtc and
> >>> + * calculates normalized zpos value for them. Planes are compared
> >>> first by their
> >>> + * zpos values, then by plane id (if zpos equals). Plane with lowest
> >>> zpos value
> >>> + * is at the bottom. The plane_state->normalized_zpos is then filled
> >>> with unique
> >>> + * values from 0 to number of active planes in crtc minus one.
> >>> + *
> >>> + * RETURNS
> >>> + * Zero for success or -errno
> >>> + */
> >>> +int drm_atomic_helper_crtc_normalize_zpos(struct drm_crtc *crtc,
> >>> +					  struct drm_crtc_state *crtc_state)
> >>> +{
> >>> +	struct drm_atomic_state *state = crtc_state->state;
> >>> +	struct drm_device *dev = crtc->dev;
> >>> +	int total_planes = dev->mode_config.num_total_plane;
> >>> +	struct drm_plane_state **states;
> >>> +	struct drm_plane *plane;
> >>> +	int i, zpos, n = 0;
> >>> +	int ret = 0;
> >>> +
> >>> +	DRM_DEBUG_ATOMIC("[CRTC:%d:%s] calculating normalized zpos
> >>> values\n",
> >>> +			 crtc->base.id, crtc->name);
> >>> +
> >>> +	states = kmalloc(total_planes * sizeof(*states), GFP_KERNEL);
> >> 
> >> kmalloc_array(..., GFP_TEMPORARY);
> >> 
> >>> +	if (!states)
> >>> +		return -ENOMEM;
> >>> +
> >>> +	/*
> >>> +	 * Normalization process might create new states for planes which
> >>> +	 * normalized_zpos has to be recalculated.
> >>> +	 */
> >>> +	drm_for_each_plane_mask(plane, dev, crtc_state->plane_mask) {
> >>> +		struct drm_plane_state *plane_state =
> >>> +			drm_atomic_get_plane_state(state, plane);
> >>> +		if (IS_ERR(plane_state)) {
> >>> +			ret = PTR_ERR(plane_state);
> >>> +			goto done;
> >>> +		}
> >> 
> >> Hmm. So if we change the zpos for any plane, we get to re-check every
> >> plane. Not the most efficient thing perhaps, since on some hardware
> >> you might only have a subset of planes that can even change their
> >> zpos. OTOH I suppose it does make life a bit simpler when you don't
> >> have to think which planes might be affected, so I guess it's fine.
> >>
> >>> +		states[n++] = plane_state;
> >>> +		DRM_DEBUG_ATOMIC("[PLANE:%d:%s] processing zpos value %d\n",
> >>> +				 plane->base.id, plane->name,
> >>> +				 plane_state->zpos);
> >>> +	}
> >>> +
> >>> +	sort(states, n, sizeof(*states), drm_atomic_state_zpos_cmp, NULL);
> >>> +
> >>> +	for (i = 0, zpos = 0; i < n; i++, zpos++) {
> >>> +		plane = states[i]->plane;
> >>> +
> >>> +		zpos = max_t(int, zpos, states[i]->zpos);
> > 
> > The purpose of this code is to support the per-plane min/max zpos values.
> > As Benjamin explained, for example if the zpos range is [0,2] for plane X
> > and [4,6] for plane Y, we need to be sure the min zpos value of plane Y
> > is 4. To this I replied that's exactly what I'd rather avoid. I think the
> > core code should take care of sorting planes, taking driver-specific
> > constraints into account when possible (too exotic constraints can always
> > be implemented directly by drivers), and then leave to the drivers the
> > responsibility of taking the sorted planes array and computing whatever
> > hardware-specific configuration is needed. Sorting planes from 0 to N-1
> > seems to be like a better API than having semi-random values for the
> > normalized zpos. Do we have use cases that wouldn't be covered by a
> > simpler implementation ?
> 
> The point of exposing ranges is to give userspace at least some chance
> of getting the order right. Otherwise it'll just have to randomly try
> different orders until something works. Most hardware is quite
> constrained in this.

Could you educate me by giving a few real world examples ?

> Some don't support changing the zpos at all, in which case we would set
> min==max.

But all this doesn't require adjusting the normalized zpos to take the 
original zpos constraints into account, does it ? Why can normalized_zpos be 
constrained to the range 0 to N-1, giving drivers the sorted planes and then 
letting them convert that to device-specific values ?

> >>> +		states[i]->normalized_zpos = zpos;
> >>> +		DRM_DEBUG_ATOMIC("[PLANE:%d:%s] normalized zpos value %d\n",
> >>> +				 plane->base.id, plane->name, zpos);
> >>> +	}
> >>> +	crtc_state->zpos_changed = true;
> >>> +
> >>> +done:
> >>> +	kfree(states);
> >>> +	return ret;
> >>> +}
> >>> +EXPORT_SYMBOL(drm_atomic_helper_crtc_normalize_zpos);
Ville Syrjälä May 12, 2016, 8:54 p.m. UTC | #8
On Thu, May 12, 2016 at 11:15:42PM +0300, Laurent Pinchart wrote:
> Hi Ville,
> 
> On Thursday 12 May 2016 22:46:05 Ville Syrjälä wrote:
> > On Thu, May 12, 2016 at 10:20:12PM +0300, Laurent Pinchart wrote:
> > > On Thursday 12 May 2016 14:51:55 Ville Syrjälä wrote:
> > >> On Thu, May 12, 2016 at 12:28:19PM +0200, Benjamin Gaignard wrote:
> > >>> From: Marek Szyprowski <m.szyprowski@samsung.com>
> > >>> 
> > >>> This patch adds support for generic plane's zpos property property
> > >>> with well-defined semantics:
> > >>> - added zpos properties to plane and plane state structures
> > >>> - added helpers for normalizing zpos properties of given set of planes
> > >>> - well defined semantics: planes are sorted by zpos values and then
> > >>>   plane id value if zpos equals
> > >>> 
> > >>> Normalized zpos values are calculated automatically when generic
> > >>> muttable zpos property has been initialized. Drivers can simply use
> > >>> plane_state->normalized_zpos in their atomic_check and/or plane_update
> > >>> callbacks without any additional calls to DRM core.
> > >>> 
> > >>> Signed-off-by: Marek Szyprowski <m.szyprowski@samsung.com>
> > >>> 
> > >>> Compare to Marek's original patch zpos property is now specific to
> > >>> each plane and no more to the core.
> > >>> Normalize function take care of the range of per plane defined range
> > >>> before set normalized_zpos.
> > >>> 
> > >>> Signed-off-by: Benjamin Gaignard <benjamin.gaignard@linaro.org>
> > >>> 
> > >>> Cc: Inki Dae <inki.dae@samsung.com>
> > >>> Cc: Daniel Vetter <daniel@ffwll.ch>
> > >>> Cc: Ville Syrjala <ville.syrjala@linux.intel.com>
> > >>> Cc: Joonyoung Shim <jy0922.shim@samsung.com>
> > >>> Cc: Seung-Woo Kim <sw0312.kim@samsung.com>
> > >>> Cc: Andrzej Hajda <a.hajda@samsung.com>
> > >>> Cc: Krzysztof Kozlowski <k.kozlowski@samsung.com>
> > >>> Cc: Bartlomiej Zolnierkiewicz <b.zolnierkie@samsung.com>
> > >>> Cc: Tobias Jakobi <tjakobi@math.uni-bielefeld.de>
> > >>> Cc: Gustavo Padovan <gustavo@padovan.org>
> > >>> Cc: vincent.abriou@st.com
> > >>> Cc: fabien.dessenne@st.com
> > >>> Cc: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
> > >>> ---
> > >>> 
> > >>>  Documentation/DocBook/gpu.tmpl      |  10 ++
> > >>>  drivers/gpu/drm/Makefile            |   2 +-
> > >>>  drivers/gpu/drm/drm_atomic.c        |   4 +
> > >>>  drivers/gpu/drm/drm_atomic_helper.c |   6 +
> > >>>  drivers/gpu/drm/drm_blend.c         | 229 ++++++++++++++++++++++++++++
> > >>>  drivers/gpu/drm/drm_crtc_internal.h |   3 +
> > >>>  include/drm/drm_crtc.h              |  28 +++++
> > >>>  7 files changed, 281 insertions(+), 1 deletion(-)
> > >>>  create mode 100644 drivers/gpu/drm/drm_blend.c
> > > 
> > > [snip]
> > > 
> > >>> diff --git a/drivers/gpu/drm/drm_blend.c b/drivers/gpu/drm/drm_blend.c
> > >>> new file mode 100644
> > >>> index 0000000..eef59bb
> > >>> --- /dev/null
> > >>> +++ b/drivers/gpu/drm/drm_blend.c
> > >>> @@ -0,0 +1,229 @@
> > > 
> > > [snip]
> > > 
> > >>> +static int drm_atomic_state_zpos_cmp(const void *a, const void *b)
> > >>> +{
> > >>> +	const struct drm_plane_state *sa = *(struct drm_plane_state **)a;
> > >>> +	const struct drm_plane_state *sb = *(struct drm_plane_state **)b;
> > >>> +
> > >>> +	if (sa->zpos != sb->zpos)
> > >>> +		return sa->zpos - sb->zpos;
> > >>> +	else
> > >>> +		return sa->plane->base.id - sb->plane->base.id;
> > >>> +}
> > >> 
> > >> Still not really convinced this normalization is a good idea when we
> > >> have atomic. It made sense before atomic since otherwise you might not
> > >> be able to swap the zpos of two planes without shutting one of them
> > >> down, but it makes interpreting the zpos prop values more confusing. And
> > >> with atomic we don't actually need it AFAICS. Or do we have an actual
> > >> use case for this behaviour?
> > > 
> > > Speaking selfishly about my use case (rcar-du-drm), I need to sort planes
> > > in display order from 0 to N-1 as that's how the hardware is programmed.
> > > Normalization gives me an array of sorted planes, which is exactly what I
> > > need. I expect other drivers to have similar requirements, so
> > > normalization in the core will allow code sharing.
> > 
> > It just eliminates duplicate zpos values. It won't re-sort your plane
> > states magically or anything like that. Nor does it guarantee that
> > the zpos values for the actually visible planes are even contiguous.
> 
> To make normalization useful in my case I need contiguous values starting at 
> 0.

Contigious values for all the planes on the whole device or on one crtc?
And what about the visible vs. not plane issue? Is it OK to have an
invisible plane somewhere in the middle of the zpos sequence?

> 
> > > Now, is your concern that allowing two planes to have the same zpos isn't
> > > needed with the atomic API ? I agree with that, but it would also make it
> > > impossible to swap two planes using the legacy API implemented on top of
> > > atomic drivers. I'll let others decide whether this is considered as a
> > > concern.
> 
> Any opinion on this ?

Not really. I already asked if we had a good use case for it. Dunno if
anyone has one.

> 
> > > While at it, Benjamin told me that you've requested configurable min/max
> > > values per plane, what are your use cases for that ? On the same topic,
> > > please see below.
> > > 
> > >>> +
> > >>> +/**
> > >>> + * drm_atomic_helper_crtc_normalize_zpos - calculate normalized zpos
> > >>> values
> > >>> + * @crtc: crtc with planes, which have to be considered for
> > >>> normalization
> > >>> + * @crtc_state: new atomic state to apply
> > >>> + *
> > >>> + * This function checks new states of all planes assigned to given
> > >>> crtc and
> > >>> + * calculates normalized zpos value for them. Planes are compared
> > >>> first by their
> > >>> + * zpos values, then by plane id (if zpos equals). Plane with lowest
> > >>> zpos value
> > >>> + * is at the bottom. The plane_state->normalized_zpos is then filled
> > >>> with unique
> > >>> + * values from 0 to number of active planes in crtc minus one.
> > >>> + *
> > >>> + * RETURNS
> > >>> + * Zero for success or -errno
> > >>> + */
> > >>> +int drm_atomic_helper_crtc_normalize_zpos(struct drm_crtc *crtc,
> > >>> +					  struct drm_crtc_state *crtc_state)
> > >>> +{
> > >>> +	struct drm_atomic_state *state = crtc_state->state;
> > >>> +	struct drm_device *dev = crtc->dev;
> > >>> +	int total_planes = dev->mode_config.num_total_plane;
> > >>> +	struct drm_plane_state **states;
> > >>> +	struct drm_plane *plane;
> > >>> +	int i, zpos, n = 0;
> > >>> +	int ret = 0;
> > >>> +
> > >>> +	DRM_DEBUG_ATOMIC("[CRTC:%d:%s] calculating normalized zpos
> > >>> values\n",
> > >>> +			 crtc->base.id, crtc->name);
> > >>> +
> > >>> +	states = kmalloc(total_planes * sizeof(*states), GFP_KERNEL);
> > >> 
> > >> kmalloc_array(..., GFP_TEMPORARY);
> > >> 
> > >>> +	if (!states)
> > >>> +		return -ENOMEM;
> > >>> +
> > >>> +	/*
> > >>> +	 * Normalization process might create new states for planes which
> > >>> +	 * normalized_zpos has to be recalculated.
> > >>> +	 */
> > >>> +	drm_for_each_plane_mask(plane, dev, crtc_state->plane_mask) {
> > >>> +		struct drm_plane_state *plane_state =
> > >>> +			drm_atomic_get_plane_state(state, plane);
> > >>> +		if (IS_ERR(plane_state)) {
> > >>> +			ret = PTR_ERR(plane_state);
> > >>> +			goto done;
> > >>> +		}
> > >> 
> > >> Hmm. So if we change the zpos for any plane, we get to re-check every
> > >> plane. Not the most efficient thing perhaps, since on some hardware
> > >> you might only have a subset of planes that can even change their
> > >> zpos. OTOH I suppose it does make life a bit simpler when you don't
> > >> have to think which planes might be affected, so I guess it's fine.
> > >>
> > >>> +		states[n++] = plane_state;
> > >>> +		DRM_DEBUG_ATOMIC("[PLANE:%d:%s] processing zpos value %d\n",
> > >>> +				 plane->base.id, plane->name,
> > >>> +				 plane_state->zpos);
> > >>> +	}
> > >>> +
> > >>> +	sort(states, n, sizeof(*states), drm_atomic_state_zpos_cmp, NULL);
> > >>> +
> > >>> +	for (i = 0, zpos = 0; i < n; i++, zpos++) {
> > >>> +		plane = states[i]->plane;
> > >>> +
> > >>> +		zpos = max_t(int, zpos, states[i]->zpos);
> > > 
> > > The purpose of this code is to support the per-plane min/max zpos values.
> > > As Benjamin explained, for example if the zpos range is [0,2] for plane X
> > > and [4,6] for plane Y, we need to be sure the min zpos value of plane Y
> > > is 4. To this I replied that's exactly what I'd rather avoid. I think the
> > > core code should take care of sorting planes, taking driver-specific
> > > constraints into account when possible (too exotic constraints can always
> > > be implemented directly by drivers), and then leave to the drivers the
> > > responsibility of taking the sorted planes array and computing whatever
> > > hardware-specific configuration is needed. Sorting planes from 0 to N-1
> > > seems to be like a better API than having semi-random values for the
> > > normalized zpos. Do we have use cases that wouldn't be covered by a
> > > simpler implementation ?
> > 
> > The point of exposing ranges is to give userspace at least some chance
> > of getting the order right. Otherwise it'll just have to randomly try
> > different orders until something works. Most hardware is quite
> > constrained in this.
> 
> Could you educate me by giving a few real world examples ?

Well, on Intel we have the simple case on many platforms (bottom->top):
primary->sprite->cursor
Most PC hardware from some years ago was similar. More modern stuff from
the other vendors might be more capable, not sure.

We also have another class of Intel hardware which has primary, two
sprites, and a cursor. The cursor is always on top, the other three
planes can be in any order amongst themselves.

The oldest Intel hardware we support is even more flexible. Those had
sort of 1 proper primary plane, 2 sprite planes, 1 video overlay, and
2 cursor planes. Normally they're spread among two crtcs, but they
can all be moved to a single crtc and then ordering constraints between
them are fairly convoluted.

As far as I can remember OMAP (at least 3 and maybe 4) had a totally
fixed order. GFX->VID1->VID2. Perhaps they changed this later, dunno.

One extra complication in this is destination color keying. What that
tends to do effectively is push some sprite/overlay plane below the
primary and punch a hole into the primary, but otherwise the
sprite/overlay sits above the primary. Not sure if we should make this
sort of thing explicit in the zpos API or if we should just declare
color keying somehow magic and potentially ignore some of the zpos
properties.

> 
> > Some don't support changing the zpos at all, in which case we would set
> > min==max.
> 
> But all this doesn't require adjusting the normalized zpos to take the 
> original zpos constraints into account, does it ? Why can normalized_zpos be 
> constrained to the range 0 to N-1, giving drivers the sorted planes and then 
> letting them convert that to device-specific values ?

Oh, I didn't even notice that it was mixing up the normalized and
non-normalized coordinates. Yes, that does seem wrong to me. The fact that
the ioctl would have rejected the out of range non-normalized coordinates
should already guarantee that the resulting normalized coordinates end
up in roughly the right order. That is, at least the order between different
"zpos groups" of planes would be already respected. Eg. in the Intel "3
freely ordered planes + cursor" case there would be no way to push the
cursor below any other plane.
Laurent Pinchart May 24, 2016, 2:01 p.m. UTC | #9
Hi Ville,

On Thursday 12 May 2016 23:54:09 Ville Syrjälä wrote:
> On Thu, May 12, 2016 at 11:15:42PM +0300, Laurent Pinchart wrote:
> > On Thursday 12 May 2016 22:46:05 Ville Syrjälä wrote:
> >> On Thu, May 12, 2016 at 10:20:12PM +0300, Laurent Pinchart wrote:
> >>> On Thursday 12 May 2016 14:51:55 Ville Syrjälä wrote:
> >>>> On Thu, May 12, 2016 at 12:28:19PM +0200, Benjamin Gaignard wrote:
> >>>>> From: Marek Szyprowski <m.szyprowski@samsung.com>
> >>>>> 
> >>>>> This patch adds support for generic plane's zpos property property
> >>>>> with well-defined semantics:
> >>>>> - added zpos properties to plane and plane state structures
> >>>>> - added helpers for normalizing zpos properties of given set of
> >>>>>   planes
> >>>>> - well defined semantics: planes are sorted by zpos values and then
> >>>>>   plane id value if zpos equals
> >>>>> 
> >>>>> Normalized zpos values are calculated automatically when generic
> >>>>> muttable zpos property has been initialized. Drivers can simply use
> >>>>> plane_state->normalized_zpos in their atomic_check and/or
> >>>>> plane_update callbacks without any additional calls to DRM core.
> >>>>> 
> >>>>> Signed-off-by: Marek Szyprowski <m.szyprowski@samsung.com>
> >>>>> 
> >>>>> Compare to Marek's original patch zpos property is now specific to
> >>>>> each plane and no more to the core.
> >>>>> Normalize function take care of the range of per plane defined range
> >>>>> before set normalized_zpos.
> >>>>> 
> >>>>> Signed-off-by: Benjamin Gaignard <benjamin.gaignard@linaro.org>
> >>>>> 
> >>>>> Cc: Inki Dae <inki.dae@samsung.com>
> >>>>> Cc: Daniel Vetter <daniel@ffwll.ch>
> >>>>> Cc: Ville Syrjala <ville.syrjala@linux.intel.com>
> >>>>> Cc: Joonyoung Shim <jy0922.shim@samsung.com>
> >>>>> Cc: Seung-Woo Kim <sw0312.kim@samsung.com>
> >>>>> Cc: Andrzej Hajda <a.hajda@samsung.com>
> >>>>> Cc: Krzysztof Kozlowski <k.kozlowski@samsung.com>
> >>>>> Cc: Bartlomiej Zolnierkiewicz <b.zolnierkie@samsung.com>
> >>>>> Cc: Tobias Jakobi <tjakobi@math.uni-bielefeld.de>
> >>>>> Cc: Gustavo Padovan <gustavo@padovan.org>
> >>>>> Cc: vincent.abriou@st.com
> >>>>> Cc: fabien.dessenne@st.com
> >>>>> Cc: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
> >>>>> ---
> >>>>> 
> >>>>>  Documentation/DocBook/gpu.tmpl      |  10 ++
> >>>>>  drivers/gpu/drm/Makefile            |   2 +-
> >>>>>  drivers/gpu/drm/drm_atomic.c        |   4 +
> >>>>>  drivers/gpu/drm/drm_atomic_helper.c |   6 +
> >>>>>  drivers/gpu/drm/drm_blend.c         | 229 +++++++++++++++++++++++++
> >>>>>  drivers/gpu/drm/drm_crtc_internal.h |   3 +
> >>>>>  include/drm/drm_crtc.h              |  28 +++++
> >>>>>  7 files changed, 281 insertions(+), 1 deletion(-)
> >>>>>  create mode 100644 drivers/gpu/drm/drm_blend.c
> >>> 
> >>> [snip]
> >>> 
> >>>>> diff --git a/drivers/gpu/drm/drm_blend.c
> >>>>> b/drivers/gpu/drm/drm_blend.c
> >>>>> new file mode 100644
> >>>>> index 0000000..eef59bb
> >>>>> --- /dev/null
> >>>>> +++ b/drivers/gpu/drm/drm_blend.c
> >>>>> @@ -0,0 +1,229 @@
> >>> 
> >>> [snip]
> >>> 
> >>>>> +static int drm_atomic_state_zpos_cmp(const void *a, const void *b)
> >>>>> +{
> >>>>> +	const struct drm_plane_state *sa = *(struct drm_plane_state **)a;
> >>>>> +	const struct drm_plane_state *sb = *(struct drm_plane_state **)b;
> >>>>> +
> >>>>> +	if (sa->zpos != sb->zpos)
> >>>>> +		return sa->zpos - sb->zpos;
> >>>>> +	else
> >>>>> +		return sa->plane->base.id - sb->plane->base.id;
> >>>>> +}
> >>>> 
> >>>> Still not really convinced this normalization is a good idea when we
> >>>> have atomic. It made sense before atomic since otherwise you might
> >>>> not be able to swap the zpos of two planes without shutting one of them
> >>>> down, but it makes interpreting the zpos prop values more confusing.
> >>>> And with atomic we don't actually need it AFAICS. Or do we have an
> >>>> actual use case for this behaviour?
> >>> 
> >>> Speaking selfishly about my use case (rcar-du-drm), I need to sort
> >>> planes in display order from 0 to N-1 as that's how the hardware is
> >>> programmed. Normalization gives me an array of sorted planes, which is
> >>> exactly what I need. I expect other drivers to have similar
> >>> requirements, so normalization in the core will allow code sharing.
> >> 
> >> It just eliminates duplicate zpos values. It won't re-sort your plane
> >> states magically or anything like that. Nor does it guarantee that
> >> the zpos values for the actually visible planes are even contiguous.
> > 
> > To make normalization useful in my case I need contiguous values starting
> > at 0.
> 
> Contigious values for all the planes on the whole device or on one crtc?
> And what about the visible vs. not plane issue? Is it OK to have an
> invisible plane somewhere in the middle of the zpos sequence?

In my case it would be per-CRTC, and invisible planes in the middle wouldn't 
be an issue.

To make normalization useful it needs to compute values that are usable by the 
majority of drivers. The question then becomes what should those values be ? 
Generally speaking they should be easy to convert to driver-specific values. 
That's why I believe we need feedback from driver developers on this topic.

> >>> Now, is your concern that allowing two planes to have the same zpos
> >>> isn't needed with the atomic API ? I agree with that, but it would also
> >>> make it impossible to swap two planes using the legacy API implemented
> >>> on top of atomic drivers. I'll let others decide whether this is
> >>> considered as a concern.
> > 
> > Any opinion on this ?
> 
> Not really. I already asked if we had a good use case for it. Dunno if
> anyone has one.

Non-atomic userspace needing to swap planes is such a use case. The question 
is whether we want to support it.

For atomic, the reason I can see to support the same feature is to make it 
easier for userspace to modify the zorder of a plane without requiring updates 
to all other planes. I don't have a strong opinion on that, but we need to 
decide whether we want to support it or not.

> >>> While at it, Benjamin told me that you've requested configurable
> >>> min/max values per plane, what are your use cases for that ? On the same
> >>> topic, please see below.
> >>> 
> >>>>> +
> >>>>> +/**
> >>>>> + * drm_atomic_helper_crtc_normalize_zpos - calculate normalized
> >>>>> zpos values
> >>>>> + * @crtc: crtc with planes, which have to be considered for
> >>>>> normalization
> >>>>> + * @crtc_state: new atomic state to apply
> >>>>> + *
> >>>>> + * This function checks new states of all planes assigned to given
> >>>>> crtc and
> >>>>> + * calculates normalized zpos value for them. Planes are compared
> >>>>> first by their
> >>>>> + * zpos values, then by plane id (if zpos equals). Plane with
> >>>>> lowest zpos value
> >>>>> + * is at the bottom. The plane_state->normalized_zpos is then
> >>>>> filled with unique
> >>>>> + * values from 0 to number of active planes in crtc minus one.
> >>>>> + *
> >>>>> + * RETURNS
> >>>>> + * Zero for success or -errno
> >>>>> + */
> >>>>> +int drm_atomic_helper_crtc_normalize_zpos(struct drm_crtc *crtc,
> >>>>> +					  struct drm_crtc_state *crtc_state)
> >>>>> +{
> >>>>> +	struct drm_atomic_state *state = crtc_state->state;
> >>>>> +	struct drm_device *dev = crtc->dev;
> >>>>> +	int total_planes = dev->mode_config.num_total_plane;
> >>>>> +	struct drm_plane_state **states;
> >>>>> +	struct drm_plane *plane;
> >>>>> +	int i, zpos, n = 0;
> >>>>> +	int ret = 0;
> >>>>> +
> >>>>> +	DRM_DEBUG_ATOMIC("[CRTC:%d:%s] calculating normalized zpos
> >>>>> values\n",
> >>>>> +			 crtc->base.id, crtc->name);
> >>>>> +
> >>>>> +	states = kmalloc(total_planes * sizeof(*states), GFP_KERNEL);
> >>>> 
> >>>> kmalloc_array(..., GFP_TEMPORARY);
> >>>> 
> >>>>> +	if (!states)
> >>>>> +		return -ENOMEM;
> >>>>> +
> >>>>> +	/*
> >>>>> +	 * Normalization process might create new states for planes which
> >>>>> +	 * normalized_zpos has to be recalculated.
> >>>>> +	 */
> >>>>> +	drm_for_each_plane_mask(plane, dev, crtc_state->plane_mask) {
> >>>>> +		struct drm_plane_state *plane_state =
> >>>>> +			drm_atomic_get_plane_state(state, plane);
> >>>>> +		if (IS_ERR(plane_state)) {
> >>>>> +			ret = PTR_ERR(plane_state);
> >>>>> +			goto done;
> >>>>> +		}
> >>>> 
> >>>> Hmm. So if we change the zpos for any plane, we get to re-check every
> >>>> plane. Not the most efficient thing perhaps, since on some hardware
> >>>> you might only have a subset of planes that can even change their
> >>>> zpos. OTOH I suppose it does make life a bit simpler when you don't
> >>>> have to think which planes might be affected, so I guess it's fine.
> >>>> 
> >>>>> +		states[n++] = plane_state;
> >>>>> +		DRM_DEBUG_ATOMIC("[PLANE:%d:%s] processing zpos value %d\n",
> >>>>> +				 plane->base.id, plane->name,
> >>>>> +				 plane_state->zpos);
> >>>>> +	}
> >>>>> +
> >>>>> +	sort(states, n, sizeof(*states), drm_atomic_state_zpos_cmp, NULL);
> >>>>> +
> >>>>> +	for (i = 0, zpos = 0; i < n; i++, zpos++) {
> >>>>> +		plane = states[i]->plane;
> >>>>> +
> >>>>> +		zpos = max_t(int, zpos, states[i]->zpos);
> >>> 
> >>> The purpose of this code is to support the per-plane min/max zpos
> >>> values. As Benjamin explained, for example if the zpos range is [0,2]
> >>> for plane X and [4,6] for plane Y, we need to be sure the min zpos value
> >>> of plane Y is 4. To this I replied that's exactly what I'd rather avoid.
> >>> I think the core code should take care of sorting planes, taking driver-
> >>> specific constraints into account when possible (too exotic constraints
> >>> can always be implemented directly by drivers), and then leave to the
> >>> drivers the responsibility of taking the sorted planes array and
> >>> computing whatever hardware-specific configuration is needed. Sorting
> >>> planes from 0 to N-1 seems to be like a better API than having semi-
> >>> random values for the normalized zpos. Do we have use cases that
> >>> wouldn't be covered by a simpler implementation ?
> >> 
> >> The point of exposing ranges is to give userspace at least some chance
> >> of getting the order right. Otherwise it'll just have to randomly try
> >> different orders until something works. Most hardware is quite
> >> constrained in this.
> > 
> > Could you educate me by giving a few real world examples ?
> 
> Well, on Intel we have the simple case on many platforms (bottom->top):
> primary->sprite->cursor
> Most PC hardware from some years ago was similar. More modern stuff from
> the other vendors might be more capable, not sure.
> 
> We also have another class of Intel hardware which has primary, two
> sprites, and a cursor. The cursor is always on top, the other three
> planes can be in any order amongst themselves.
> 
> The oldest Intel hardware we support is even more flexible. Those had
> sort of 1 proper primary plane, 2 sprite planes, 1 video overlay, and
> 2 cursor planes. Normally they're spread among two crtcs, but they
> can all be moved to a single crtc and then ordering constraints between
> them are fairly convoluted.

Thank you for the information.

> As far as I can remember OMAP (at least 3 and maybe 4) had a totally
> fixed order. GFX->VID1->VID2. Perhaps they changed this later, dunno.

OMAP3 has a fixed Z-order, while OMAP4 seems to be configurable according to 
the omapdrm driver.

> One extra complication in this is destination color keying. What that
> tends to do effectively is push some sprite/overlay plane below the
> primary and punch a hole into the primary, but otherwise the
> sprite/overlay sits above the primary. Not sure if we should make this
> sort of thing explicit in the zpos API or if we should just declare
> color keying somehow magic and potentially ignore some of the zpos
> properties.

Color-keying is a quite common feature, I think we should standardize 
properties to support it, which would then require defining the behaviour, 
including how it interacts with Z-order.

> >> Some don't support changing the zpos at all, in which case we would set
> >> min==max.
> > 
> > But all this doesn't require adjusting the normalized zpos to take the
> > original zpos constraints into account, does it ? Why can normalized_zpos

s/can/can't/

> > be constrained to the range 0 to N-1, giving drivers the sorted planes
> > and then letting them convert that to device-specific values ?
> 
> Oh, I didn't even notice that it was mixing up the normalized and
> non-normalized coordinates. Yes, that does seem wrong to me. The fact that
> the ioctl would have rejected the out of range non-normalized coordinates
> should already guarantee that the resulting normalized coordinates end
> up in roughly the right order. That is, at least the order between different
> "zpos groups" of planes would be already respected. Eg. in the Intel "3
> freely ordered planes + cursor" case there would be no way to push the
> cursor below any other plane.

I agree with you, and I still think that computing the zpos_normalized values 
in the 0 to N-1 range (N being the number of visible planes for the CRTC) 
would be the best option.
Ville Syrjälä May 24, 2016, 2:22 p.m. UTC | #10
On Tue, May 24, 2016 at 05:01:02PM +0300, Laurent Pinchart wrote:
> Hi Ville,
> 
> On Thursday 12 May 2016 23:54:09 Ville Syrjälä wrote:
> > On Thu, May 12, 2016 at 11:15:42PM +0300, Laurent Pinchart wrote:
> > > On Thursday 12 May 2016 22:46:05 Ville Syrjälä wrote:
> > >> On Thu, May 12, 2016 at 10:20:12PM +0300, Laurent Pinchart wrote:
> > >>> On Thursday 12 May 2016 14:51:55 Ville Syrjälä wrote:
> > >>>> On Thu, May 12, 2016 at 12:28:19PM +0200, Benjamin Gaignard wrote:
> > >>>>> From: Marek Szyprowski <m.szyprowski@samsung.com>
> > >>>>> 
> > >>>>> This patch adds support for generic plane's zpos property property
> > >>>>> with well-defined semantics:
> > >>>>> - added zpos properties to plane and plane state structures
> > >>>>> - added helpers for normalizing zpos properties of given set of
> > >>>>>   planes
> > >>>>> - well defined semantics: planes are sorted by zpos values and then
> > >>>>>   plane id value if zpos equals
> > >>>>> 
> > >>>>> Normalized zpos values are calculated automatically when generic
> > >>>>> muttable zpos property has been initialized. Drivers can simply use
> > >>>>> plane_state->normalized_zpos in their atomic_check and/or
> > >>>>> plane_update callbacks without any additional calls to DRM core.
> > >>>>> 
> > >>>>> Signed-off-by: Marek Szyprowski <m.szyprowski@samsung.com>
> > >>>>> 
> > >>>>> Compare to Marek's original patch zpos property is now specific to
> > >>>>> each plane and no more to the core.
> > >>>>> Normalize function take care of the range of per plane defined range
> > >>>>> before set normalized_zpos.
> > >>>>> 
> > >>>>> Signed-off-by: Benjamin Gaignard <benjamin.gaignard@linaro.org>
> > >>>>> 
> > >>>>> Cc: Inki Dae <inki.dae@samsung.com>
> > >>>>> Cc: Daniel Vetter <daniel@ffwll.ch>
> > >>>>> Cc: Ville Syrjala <ville.syrjala@linux.intel.com>
> > >>>>> Cc: Joonyoung Shim <jy0922.shim@samsung.com>
> > >>>>> Cc: Seung-Woo Kim <sw0312.kim@samsung.com>
> > >>>>> Cc: Andrzej Hajda <a.hajda@samsung.com>
> > >>>>> Cc: Krzysztof Kozlowski <k.kozlowski@samsung.com>
> > >>>>> Cc: Bartlomiej Zolnierkiewicz <b.zolnierkie@samsung.com>
> > >>>>> Cc: Tobias Jakobi <tjakobi@math.uni-bielefeld.de>
> > >>>>> Cc: Gustavo Padovan <gustavo@padovan.org>
> > >>>>> Cc: vincent.abriou@st.com
> > >>>>> Cc: fabien.dessenne@st.com
> > >>>>> Cc: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
> > >>>>> ---
> > >>>>> 
> > >>>>>  Documentation/DocBook/gpu.tmpl      |  10 ++
> > >>>>>  drivers/gpu/drm/Makefile            |   2 +-
> > >>>>>  drivers/gpu/drm/drm_atomic.c        |   4 +
> > >>>>>  drivers/gpu/drm/drm_atomic_helper.c |   6 +
> > >>>>>  drivers/gpu/drm/drm_blend.c         | 229 +++++++++++++++++++++++++
> > >>>>>  drivers/gpu/drm/drm_crtc_internal.h |   3 +
> > >>>>>  include/drm/drm_crtc.h              |  28 +++++
> > >>>>>  7 files changed, 281 insertions(+), 1 deletion(-)
> > >>>>>  create mode 100644 drivers/gpu/drm/drm_blend.c
> > >>> 
> > >>> [snip]
> > >>> 
> > >>>>> diff --git a/drivers/gpu/drm/drm_blend.c
> > >>>>> b/drivers/gpu/drm/drm_blend.c
> > >>>>> new file mode 100644
> > >>>>> index 0000000..eef59bb
> > >>>>> --- /dev/null
> > >>>>> +++ b/drivers/gpu/drm/drm_blend.c
> > >>>>> @@ -0,0 +1,229 @@
> > >>> 
> > >>> [snip]
> > >>> 
> > >>>>> +static int drm_atomic_state_zpos_cmp(const void *a, const void *b)
> > >>>>> +{
> > >>>>> +	const struct drm_plane_state *sa = *(struct drm_plane_state **)a;
> > >>>>> +	const struct drm_plane_state *sb = *(struct drm_plane_state **)b;
> > >>>>> +
> > >>>>> +	if (sa->zpos != sb->zpos)
> > >>>>> +		return sa->zpos - sb->zpos;
> > >>>>> +	else
> > >>>>> +		return sa->plane->base.id - sb->plane->base.id;
> > >>>>> +}
> > >>>> 
> > >>>> Still not really convinced this normalization is a good idea when we
> > >>>> have atomic. It made sense before atomic since otherwise you might
> > >>>> not be able to swap the zpos of two planes without shutting one of them
> > >>>> down, but it makes interpreting the zpos prop values more confusing.
> > >>>> And with atomic we don't actually need it AFAICS. Or do we have an
> > >>>> actual use case for this behaviour?
> > >>> 
> > >>> Speaking selfishly about my use case (rcar-du-drm), I need to sort
> > >>> planes in display order from 0 to N-1 as that's how the hardware is
> > >>> programmed. Normalization gives me an array of sorted planes, which is
> > >>> exactly what I need. I expect other drivers to have similar
> > >>> requirements, so normalization in the core will allow code sharing.
> > >> 
> > >> It just eliminates duplicate zpos values. It won't re-sort your plane
> > >> states magically or anything like that. Nor does it guarantee that
> > >> the zpos values for the actually visible planes are even contiguous.
> > > 
> > > To make normalization useful in my case I need contiguous values starting
> > > at 0.
> > 
> > Contigious values for all the planes on the whole device or on one crtc?
> > And what about the visible vs. not plane issue? Is it OK to have an
> > invisible plane somewhere in the middle of the zpos sequence?
> 
> In my case it would be per-CRTC, and invisible planes in the middle wouldn't 
> be an issue.
> 
> To make normalization useful it needs to compute values that are usable by the 
> majority of drivers. The question then becomes what should those values be ? 
> Generally speaking they should be easy to convert to driver-specific values. 
> That's why I believe we need feedback from driver developers on this topic.
> 
> > >>> Now, is your concern that allowing two planes to have the same zpos
> > >>> isn't needed with the atomic API ? I agree with that, but it would also
> > >>> make it impossible to swap two planes using the legacy API implemented
> > >>> on top of atomic drivers. I'll let others decide whether this is
> > >>> considered as a concern.
> > > 
> > > Any opinion on this ?
> > 
> > Not really. I already asked if we had a good use case for it. Dunno if
> > anyone has one.
> 
> Non-atomic userspace needing to swap planes is such a use case. The question 
> is whether we want to support it.

I was more asking if anyone is actually doing that, and do they need it
to keep working.

> 
> For atomic, the reason I can see to support the same feature is to make it 
> easier for userspace to modify the zorder of a plane without requiring updates 
> to all other planes. I don't have a strong opinion on that, but we need to 
> decide whether we want to support it or not.

Not sure it really helps in any measurable way. It might save a few
properties from getting pushed to the kernel, but that's all. Eg. if
userspace would maintain some kind of stack of planes in the right
zorder, then pushing a new plane into the middle of the stack would
required that it figures out the right zorder for that position.
That would be something like z=clamp(below_z + 1, below_z, above_z).
After that it would have to figure out if the magic conflict resolution
will result in the right zorder should below_z==z or above_z==z,
and if not it would have to change below_z and/or above_z too.
That process could ripple all the way through the entire stack.
Seems to me that it would be far easier to just readjust the z
order for all the planes above from the get go.

> 
> > >>> While at it, Benjamin told me that you've requested configurable
> > >>> min/max values per plane, what are your use cases for that ? On the same
> > >>> topic, please see below.
> > >>> 
> > >>>>> +
> > >>>>> +/**
> > >>>>> + * drm_atomic_helper_crtc_normalize_zpos - calculate normalized
> > >>>>> zpos values
> > >>>>> + * @crtc: crtc with planes, which have to be considered for
> > >>>>> normalization
> > >>>>> + * @crtc_state: new atomic state to apply
> > >>>>> + *
> > >>>>> + * This function checks new states of all planes assigned to given
> > >>>>> crtc and
> > >>>>> + * calculates normalized zpos value for them. Planes are compared
> > >>>>> first by their
> > >>>>> + * zpos values, then by plane id (if zpos equals). Plane with
> > >>>>> lowest zpos value
> > >>>>> + * is at the bottom. The plane_state->normalized_zpos is then
> > >>>>> filled with unique
> > >>>>> + * values from 0 to number of active planes in crtc minus one.
> > >>>>> + *
> > >>>>> + * RETURNS
> > >>>>> + * Zero for success or -errno
> > >>>>> + */
> > >>>>> +int drm_atomic_helper_crtc_normalize_zpos(struct drm_crtc *crtc,
> > >>>>> +					  struct drm_crtc_state *crtc_state)
> > >>>>> +{
> > >>>>> +	struct drm_atomic_state *state = crtc_state->state;
> > >>>>> +	struct drm_device *dev = crtc->dev;
> > >>>>> +	int total_planes = dev->mode_config.num_total_plane;
> > >>>>> +	struct drm_plane_state **states;
> > >>>>> +	struct drm_plane *plane;
> > >>>>> +	int i, zpos, n = 0;
> > >>>>> +	int ret = 0;
> > >>>>> +
> > >>>>> +	DRM_DEBUG_ATOMIC("[CRTC:%d:%s] calculating normalized zpos
> > >>>>> values\n",
> > >>>>> +			 crtc->base.id, crtc->name);
> > >>>>> +
> > >>>>> +	states = kmalloc(total_planes * sizeof(*states), GFP_KERNEL);
> > >>>> 
> > >>>> kmalloc_array(..., GFP_TEMPORARY);
> > >>>> 
> > >>>>> +	if (!states)
> > >>>>> +		return -ENOMEM;
> > >>>>> +
> > >>>>> +	/*
> > >>>>> +	 * Normalization process might create new states for planes which
> > >>>>> +	 * normalized_zpos has to be recalculated.
> > >>>>> +	 */
> > >>>>> +	drm_for_each_plane_mask(plane, dev, crtc_state->plane_mask) {
> > >>>>> +		struct drm_plane_state *plane_state =
> > >>>>> +			drm_atomic_get_plane_state(state, plane);
> > >>>>> +		if (IS_ERR(plane_state)) {
> > >>>>> +			ret = PTR_ERR(plane_state);
> > >>>>> +			goto done;
> > >>>>> +		}
> > >>>> 
> > >>>> Hmm. So if we change the zpos for any plane, we get to re-check every
> > >>>> plane. Not the most efficient thing perhaps, since on some hardware
> > >>>> you might only have a subset of planes that can even change their
> > >>>> zpos. OTOH I suppose it does make life a bit simpler when you don't
> > >>>> have to think which planes might be affected, so I guess it's fine.
> > >>>> 
> > >>>>> +		states[n++] = plane_state;
> > >>>>> +		DRM_DEBUG_ATOMIC("[PLANE:%d:%s] processing zpos value %d\n",
> > >>>>> +				 plane->base.id, plane->name,
> > >>>>> +				 plane_state->zpos);
> > >>>>> +	}
> > >>>>> +
> > >>>>> +	sort(states, n, sizeof(*states), drm_atomic_state_zpos_cmp, NULL);
> > >>>>> +
> > >>>>> +	for (i = 0, zpos = 0; i < n; i++, zpos++) {
> > >>>>> +		plane = states[i]->plane;
> > >>>>> +
> > >>>>> +		zpos = max_t(int, zpos, states[i]->zpos);
> > >>> 
> > >>> The purpose of this code is to support the per-plane min/max zpos
> > >>> values. As Benjamin explained, for example if the zpos range is [0,2]
> > >>> for plane X and [4,6] for plane Y, we need to be sure the min zpos value
> > >>> of plane Y is 4. To this I replied that's exactly what I'd rather avoid.
> > >>> I think the core code should take care of sorting planes, taking driver-
> > >>> specific constraints into account when possible (too exotic constraints
> > >>> can always be implemented directly by drivers), and then leave to the
> > >>> drivers the responsibility of taking the sorted planes array and
> > >>> computing whatever hardware-specific configuration is needed. Sorting
> > >>> planes from 0 to N-1 seems to be like a better API than having semi-
> > >>> random values for the normalized zpos. Do we have use cases that
> > >>> wouldn't be covered by a simpler implementation ?
> > >> 
> > >> The point of exposing ranges is to give userspace at least some chance
> > >> of getting the order right. Otherwise it'll just have to randomly try
> > >> different orders until something works. Most hardware is quite
> > >> constrained in this.
> > > 
> > > Could you educate me by giving a few real world examples ?
> > 
> > Well, on Intel we have the simple case on many platforms (bottom->top):
> > primary->sprite->cursor
> > Most PC hardware from some years ago was similar. More modern stuff from
> > the other vendors might be more capable, not sure.
> > 
> > We also have another class of Intel hardware which has primary, two
> > sprites, and a cursor. The cursor is always on top, the other three
> > planes can be in any order amongst themselves.
> > 
> > The oldest Intel hardware we support is even more flexible. Those had
> > sort of 1 proper primary plane, 2 sprite planes, 1 video overlay, and
> > 2 cursor planes. Normally they're spread among two crtcs, but they
> > can all be moved to a single crtc and then ordering constraints between
> > them are fairly convoluted.
> 
> Thank you for the information.
> 
> > As far as I can remember OMAP (at least 3 and maybe 4) had a totally
> > fixed order. GFX->VID1->VID2. Perhaps they changed this later, dunno.
> 
> OMAP3 has a fixed Z-order, while OMAP4 seems to be configurable according to 
> the omapdrm driver.
> 
> > One extra complication in this is destination color keying. What that
> > tends to do effectively is push some sprite/overlay plane below the
> > primary and punch a hole into the primary, but otherwise the
> > sprite/overlay sits above the primary. Not sure if we should make this
> > sort of thing explicit in the zpos API or if we should just declare
> > color keying somehow magic and potentially ignore some of the zpos
> > properties.
> 
> Color-keying is a quite common feature, I think we should standardize 
> properties to support it, which would then require defining the behaviour, 
> including how it interacts with Z-order.
> 
> > >> Some don't support changing the zpos at all, in which case we would set
> > >> min==max.
> > > 
> > > But all this doesn't require adjusting the normalized zpos to take the
> > > original zpos constraints into account, does it ? Why can normalized_zpos
> 
> s/can/can't/
> 
> > > be constrained to the range 0 to N-1, giving drivers the sorted planes
> > > and then letting them convert that to device-specific values ?
> > 
> > Oh, I didn't even notice that it was mixing up the normalized and
> > non-normalized coordinates. Yes, that does seem wrong to me. The fact that
> > the ioctl would have rejected the out of range non-normalized coordinates
> > should already guarantee that the resulting normalized coordinates end
> > up in roughly the right order. That is, at least the order between different
> > "zpos groups" of planes would be already respected. Eg. in the Intel "3
> > freely ordered planes + cursor" case there would be no way to push the
> > cursor below any other plane.
> 
> I agree with you, and I still think that computing the zpos_normalized values 
> in the 0 to N-1 range (N being the number of visible planes for the CRTC) 
> would be the best option.

You can't actually know what's visible when this gets called.

Patch
diff mbox

diff --git a/Documentation/DocBook/gpu.tmpl b/Documentation/DocBook/gpu.tmpl
index 9dd48f7..0df6abb 100644
--- a/Documentation/DocBook/gpu.tmpl
+++ b/Documentation/DocBook/gpu.tmpl
@@ -2151,6 +2151,16 @@  void intel_crt_init(struct drm_device *dev)
 		the underlying hardware).</td>
 	</tr>
 	<tr>
+	<td valign="top" > "zpos" </td>
+	<td valign="top" >RANGE</td>
+	<td valign="top" >Min= driver dependent, Max= driver dependent</td>
+	<td valign="top" >Plane</td>
+	<td valign="top" >Plane's 'z' position during blending operation (0 for background, highest for frontmost).
+		If two planes assigned to same CRTC have equal zpos values, the plane with higher plane
+		id is treated as closer to front. Can be IMMUTABLE if driver doesn't support changing
+		planes' order. Exact value range is driver dependent.</td>
+	</tr>
+	<tr>
 	<td rowspan="20" valign="top" >i915</td>
 	<td rowspan="2" valign="top" >Generic</td>
 	<td valign="top" >"Broadcast RGB"</td>
diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile
index 2bd3e5a..df88253 100644
--- a/drivers/gpu/drm/Makefile
+++ b/drivers/gpu/drm/Makefile
@@ -2,7 +2,7 @@ 
 # Makefile for the drm device driver.  This driver provides support for the
 # Direct Rendering Infrastructure (DRI) in XFree86 4.1.0 and higher.
 
-drm-y       :=	drm_auth.o drm_bufs.o drm_cache.o \
+drm-y       :=	drm_auth.o drm_bufs.o drm_blend.o drm_cache.o \
 		drm_context.o drm_dma.o \
 		drm_fops.o drm_gem.o drm_ioctl.o drm_irq.o \
 		drm_lock.o drm_memory.o drm_drv.o drm_vm.o \
diff --git a/drivers/gpu/drm/drm_atomic.c b/drivers/gpu/drm/drm_atomic.c
index 86e89db..bd457ca 100644
--- a/drivers/gpu/drm/drm_atomic.c
+++ b/drivers/gpu/drm/drm_atomic.c
@@ -700,6 +700,8 @@  int drm_atomic_plane_set_property(struct drm_plane *plane,
 		state->src_h = val;
 	} else if (property == config->rotation_property) {
 		state->rotation = val;
+	} else if (property == plane->zpos_property) {
+		state->zpos = val;
 	} else if (plane->funcs->atomic_set_property) {
 		return plane->funcs->atomic_set_property(plane, state,
 				property, val);
@@ -756,6 +758,8 @@  drm_atomic_plane_get_property(struct drm_plane *plane,
 		*val = state->src_h;
 	} else if (property == config->rotation_property) {
 		*val = state->rotation;
+	} else if (property == plane->zpos_property) {
+		*val = state->zpos;
 	} else if (plane->funcs->atomic_get_property) {
 		return plane->funcs->atomic_get_property(plane, state, property, val);
 	} else {
diff --git a/drivers/gpu/drm/drm_atomic_helper.c b/drivers/gpu/drm/drm_atomic_helper.c
index 997fd21..f10652f 100644
--- a/drivers/gpu/drm/drm_atomic_helper.c
+++ b/drivers/gpu/drm/drm_atomic_helper.c
@@ -32,6 +32,8 @@ 
 #include <drm/drm_atomic_helper.h>
 #include <linux/fence.h>
 
+#include "drm_crtc_internal.h"
+
 /**
  * DOC: overview
  *
@@ -587,6 +589,10 @@  drm_atomic_helper_check_planes(struct drm_device *dev,
 	struct drm_plane_state *plane_state;
 	int i, ret = 0;
 
+	ret = drm_atomic_helper_normalize_zpos(dev, state);
+	if (ret)
+		return ret;
+
 	for_each_plane_in_state(state, plane, plane_state, i) {
 		const struct drm_plane_helper_funcs *funcs;
 
diff --git a/drivers/gpu/drm/drm_blend.c b/drivers/gpu/drm/drm_blend.c
new file mode 100644
index 0000000..eef59bb
--- /dev/null
+++ b/drivers/gpu/drm/drm_blend.c
@@ -0,0 +1,229 @@ 
+/*
+ * Copyright (C) 2016 Samsung Electronics Co.Ltd
+ * Authors:
+ *	Marek Szyprowski <m.szyprowski@samsung.com>
+ *
+ * DRM core plane blending related functions
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting documentation, and
+ * that the name of the copyright holders not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission.  The copyright holders make no representations
+ * about the suitability of this software for any purpose.  It is provided "as
+ * is" without express or implied warranty.
+ *
+ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+ * OF THIS SOFTWARE.
+ */
+#include <drm/drmP.h>
+#include <drm/drm_atomic.h>
+#include <drm/drm_crtc.h>
+#include <linux/export.h>
+#include <linux/slab.h>
+#include <linux/sort.h>
+
+#include "drm_internal.h"
+
+/**
+ * drm_plane_create_zpos_property - create mutable zpos property
+ * @plane: drm plane
+ * @min: minimal possible value of zpos property
+ * @max: maximal possible value of zpos property
+ *
+ * This function initializes generic mutable zpos property and enables support
+ * for it in drm core. Drivers can then attach this property to planes to enable
+ * support for configurable planes arrangement during blending operation.
+ * Once mutable zpos property has been enabled, the DRM core will automatically
+ * calculate drm_plane_state->normalized_zpos values. Usually min should be set
+ * to 0 and max to maximal number of planes for given crtc - 1.
+ *
+ * If zpos of some planes cannot be changed (like fixed background or
+ * cursor/topmost planes), driver should adjust min/max values and assign those
+ * planes immutable zpos property with lower or higher values (for more
+ * information, see drm_mode_create_zpos_immutable_property() function). In such
+ * case driver should also assign proper initial zpos values for all planes in
+ * its plane_reset() callback, so the planes will be always sorted properly.
+ *
+ * Returns:
+ * Zero on success, negative errno on failure.
+ */
+int drm_plane_create_zpos_property(struct drm_plane *plane,
+				   unsigned int min, unsigned int max)
+{
+	struct drm_property *prop;
+
+	prop = drm_property_create_range(plane->dev, 0, "zpos", min, max);
+	if (!prop)
+		return -ENOMEM;
+
+	drm_object_attach_property(&plane->base, prop, min);
+
+	plane->zpos_property = prop;
+	return 0;
+}
+EXPORT_SYMBOL(drm_plane_create_zpos_property);
+
+/**
+ * drm_plane_create_zpos_immutable_property - create immuttable zpos property
+ * @plane: drm plane
+ * @min: minimal possible value of zpos property
+ * @max: maximal possible value of zpos property
+ *
+ * This function initializes generic immutable zpos property and enables
+ * support for it in drm core. Using this property driver lets userspace
+ * to get the arrangement of the planes for blending operation and notifies
+ * it that the hardware (or driver) doesn't support changing of the planes'
+ * order.
+ *
+ * Returns:
+ * Zero on success, negative errno on failure.
+ */
+int drm_plane_create_zpos_immutable_property(struct drm_plane *plane,
+					     unsigned int min, unsigned int max)
+{
+	struct drm_property *prop;
+
+	prop = drm_property_create_range(plane->dev, DRM_MODE_PROP_IMMUTABLE,
+					 "zpos", min, max);
+	if (!prop)
+		return -ENOMEM;
+
+	drm_object_attach_property(&plane->base, prop, min);
+
+	plane->zpos_property = prop;
+	return 0;
+}
+EXPORT_SYMBOL(drm_plane_create_zpos_immutable_property);
+
+static int drm_atomic_state_zpos_cmp(const void *a, const void *b)
+{
+	const struct drm_plane_state *sa = *(struct drm_plane_state **)a;
+	const struct drm_plane_state *sb = *(struct drm_plane_state **)b;
+
+	if (sa->zpos != sb->zpos)
+		return sa->zpos - sb->zpos;
+	else
+		return sa->plane->base.id - sb->plane->base.id;
+}
+
+/**
+ * drm_atomic_helper_crtc_normalize_zpos - calculate normalized zpos values
+ * @crtc: crtc with planes, which have to be considered for normalization
+ * @crtc_state: new atomic state to apply
+ *
+ * This function checks new states of all planes assigned to given crtc and
+ * calculates normalized zpos value for them. Planes are compared first by their
+ * zpos values, then by plane id (if zpos equals). Plane with lowest zpos value
+ * is at the bottom. The plane_state->normalized_zpos is then filled with unique
+ * values from 0 to number of active planes in crtc minus one.
+ *
+ * RETURNS
+ * Zero for success or -errno
+ */
+int drm_atomic_helper_crtc_normalize_zpos(struct drm_crtc *crtc,
+					  struct drm_crtc_state *crtc_state)
+{
+	struct drm_atomic_state *state = crtc_state->state;
+	struct drm_device *dev = crtc->dev;
+	int total_planes = dev->mode_config.num_total_plane;
+	struct drm_plane_state **states;
+	struct drm_plane *plane;
+	int i, zpos, n = 0;
+	int ret = 0;
+
+	DRM_DEBUG_ATOMIC("[CRTC:%d:%s] calculating normalized zpos values\n",
+			 crtc->base.id, crtc->name);
+
+	states = kmalloc(total_planes * sizeof(*states), GFP_KERNEL);
+	if (!states)
+		return -ENOMEM;
+
+	/*
+	 * Normalization process might create new states for planes which
+	 * normalized_zpos has to be recalculated.
+	 */
+	drm_for_each_plane_mask(plane, dev, crtc_state->plane_mask) {
+		struct drm_plane_state *plane_state =
+			drm_atomic_get_plane_state(state, plane);
+		if (IS_ERR(plane_state)) {
+			ret = PTR_ERR(plane_state);
+			goto done;
+		}
+		states[n++] = plane_state;
+		DRM_DEBUG_ATOMIC("[PLANE:%d:%s] processing zpos value %d\n",
+				 plane->base.id, plane->name,
+				 plane_state->zpos);
+	}
+
+	sort(states, n, sizeof(*states), drm_atomic_state_zpos_cmp, NULL);
+
+	for (i = 0, zpos = 0; i < n; i++, zpos++) {
+		plane = states[i]->plane;
+
+		zpos = max_t(int, zpos, states[i]->zpos);
+
+		states[i]->normalized_zpos = zpos;
+		DRM_DEBUG_ATOMIC("[PLANE:%d:%s] normalized zpos value %d\n",
+				 plane->base.id, plane->name, zpos);
+	}
+	crtc_state->zpos_changed = true;
+
+done:
+	kfree(states);
+	return ret;
+}
+EXPORT_SYMBOL(drm_atomic_helper_crtc_normalize_zpos);
+
+/**
+ * drm_atomic_helper_normalize_zpos - calculate normalized zpos values for all
+ *				      crtcs
+ * @dev: DRM device
+ * @state: atomic state of DRM device
+ *
+ * This function calculates normalized zpos value for all modified planes in
+ * the provided atomic state of DRM device. For more information, see
+ * drm_atomic_helper_crtc_normalize_zpos() function.
+ *
+ * RETURNS
+ * Zero for success or -errno
+ */
+int drm_atomic_helper_normalize_zpos(struct drm_device *dev,
+				     struct drm_atomic_state *state)
+{
+	struct drm_crtc *crtc;
+	struct drm_crtc_state *crtc_state;
+	struct drm_plane *plane;
+	struct drm_plane_state *plane_state;
+	int i, ret = 0;
+
+	for_each_plane_in_state(state, plane, plane_state, i) {
+		crtc = plane_state->crtc;
+		if (!crtc)
+			continue;
+		if (plane->state->zpos != plane_state->zpos) {
+			crtc_state =
+				drm_atomic_get_existing_crtc_state(state, crtc);
+			crtc_state->zpos_changed = true;
+		}
+	}
+
+	for_each_crtc_in_state(state, crtc, crtc_state, i) {
+		if (crtc_state->plane_mask != crtc->state->plane_mask ||
+		    crtc_state->zpos_changed) {
+			ret = drm_atomic_helper_crtc_normalize_zpos(crtc,
+								    crtc_state);
+			if (ret)
+				return ret;
+		}
+	}
+	return 0;
+}
+EXPORT_SYMBOL(drm_atomic_helper_normalize_zpos);
diff --git a/drivers/gpu/drm/drm_crtc_internal.h b/drivers/gpu/drm/drm_crtc_internal.h
index a78c138..37d9068 100644
--- a/drivers/gpu/drm/drm_crtc_internal.h
+++ b/drivers/gpu/drm/drm_crtc_internal.h
@@ -42,3 +42,6 @@  int drm_atomic_get_property(struct drm_mode_object *obj,
 int drm_mode_atomic_ioctl(struct drm_device *dev,
 			  void *data, struct drm_file *file_priv);
 
+/* drm_blend.c */
+int drm_atomic_helper_normalize_zpos(struct drm_device *dev,
+				     struct drm_atomic_state *state);
diff --git a/include/drm/drm_crtc.h b/include/drm/drm_crtc.h
index d1559cd..921c93f 100644
--- a/include/drm/drm_crtc.h
+++ b/include/drm/drm_crtc.h
@@ -305,6 +305,7 @@  struct drm_plane_helper_funcs;
  * @mode_changed: crtc_state->mode or crtc_state->enable has been changed
  * @active_changed: crtc_state->active has been toggled.
  * @connectors_changed: connectors to this crtc have been updated
+ * @zpos_changed: zpos values of planes on this crtc have been updated
  * @color_mgmt_changed: color management properties have changed (degamma or
  *	gamma LUT or CSC matrix)
  * @plane_mask: bitmask of (1 << drm_plane_index(plane)) of attached planes
@@ -340,6 +341,7 @@  struct drm_crtc_state {
 	bool mode_changed : 1;
 	bool active_changed : 1;
 	bool connectors_changed : 1;
+	bool zpos_changed : 1;
 	bool color_mgmt_changed : 1;
 
 	/* attached planes bitmask:
@@ -1263,6 +1265,9 @@  struct drm_connector {
  *	plane (in 16.16)
  * @src_w: width of visible portion of plane (in 16.16)
  * @src_h: height of visible portion of plane (in 16.16)
+ * @zpos: priority of the given plane on crtc (optional)
+ * @normalized_zpos: normalized value of zpos: unique, range from 0 to N-1
+ *	 for given crtc
  * @state: backpointer to global drm_atomic_state
  */
 struct drm_plane_state {
@@ -1283,6 +1288,10 @@  struct drm_plane_state {
 	/* Plane rotation */
 	unsigned int rotation;
 
+	/* Plane zpos */
+	unsigned int zpos;
+	unsigned int normalized_zpos;
+
 	struct drm_atomic_state *state;
 };
 
@@ -1516,6 +1525,7 @@  enum drm_plane_type {
  * @properties: property tracking for this plane
  * @type: type of plane (overlay, primary, cursor)
  * @state: current atomic state for this plane
+ * @zpos_property: zpos property for this plane
  */
 struct drm_plane {
 	struct drm_device *dev;
@@ -1546,6 +1556,8 @@  struct drm_plane {
 	const struct drm_plane_helper_funcs *helper_private;
 
 	struct drm_plane_state *state;
+
+	struct drm_property *zpos_property;
 };
 
 /**
@@ -2554,6 +2566,22 @@  extern struct drm_property *drm_mode_create_rotation_property(struct drm_device
 extern unsigned int drm_rotation_simplify(unsigned int rotation,
 					  unsigned int supported_rotations);
 
+int drm_plane_atomic_set_zpos_property(struct drm_plane *plane,
+				       struct drm_plane_state *state,
+				       struct drm_property *property,
+				       uint64_t val);
+
+int drm_plane_atomic_get_zpos_property(struct drm_plane *plane,
+				       const struct drm_plane_state *state,
+				       struct drm_property *property,
+				       uint64_t *val);
+
+int drm_plane_create_zpos_property(struct drm_plane *plane,
+				   unsigned int min, unsigned int max);
+int drm_plane_create_zpos_immutable_property(struct drm_plane *plane,
+					     unsigned int min,
+					     unsigned int max);
+
 /* Helpers */
 
 static inline struct drm_plane *drm_plane_find(struct drm_device *dev,