Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 586efded authored by Dave Airlie's avatar Dave Airlie
Browse files

Merge branch 'generic-zpos-v8' of... 

Merge branch 'generic-zpos-v8' of http://git.linaro.org/people/benjamin.gaignard/kernel into drm-next

Merge generic ZPOS property support, this was backed up behind some other
changes I didn't have a stable branch point for. Now they are merged to Linus
tree this pull is just drm patches.

* 'generic-zpos-v8' of http://git.linaro.org/people/benjamin.gaignard/kernel:
  drm: rcar: use generic code for managing zpos plane property
  drm/exynos: use generic code for managing zpos plane property
  drm: sti: use generic zpos for plane
  drm: add generic zpos property
parents dfd2e9ab 2fc4d838

Documentation/gpu/kms-properties.csv

+1 −0
Original line number Diff line number Diff line
@@ -17,6 +17,7 @@ DRM,Generic,“rotation”,BITMASK,"{ 0, ""rotate-0"" }, { 1, ""rotate-90"" }, { 
,,“CRTC_H”,RANGE,"Min=0, Max=UINT_MAX",Plane,Scanout CRTC (destination) height (atomic)

,,“FB_ID”,OBJECT,DRM_MODE_OBJECT_FB,Plane,Scanout framebuffer (atomic)

,,“CRTC_ID”,OBJECT,DRM_MODE_OBJECT_CRTC,Plane,CRTC that plane is attached to (atomic)

,,“zpos”,RANGE,"Min=0, Max=UINT_MAX","Plane,Z-order of the plane.Planes with higher Z-order values are displayed on top, planes with identical Z-order values are display in an undefined order"

,DVI-I,“subconnector”,ENUM,"{ “Unknown”, “DVI-D”, “DVI-A” }",Connector,TBD

,,“select subconnector”,ENUM,"{ “Automatic”, “DVI-D”, “DVI-A” }",Connector,TBD

,TV,“subconnector”,ENUM,"{ ""Unknown"", ""Composite"", ""SVIDEO"", ""Component"", ""SCART"" }",Connector,TBD

drivers/gpu/drm/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -24,7 +24,7 @@ drm-$(CONFIG_AGP) += drm_agpsupport.o 
drm_kms_helper-y := drm_crtc_helper.o drm_dp_helper.o drm_probe_helper.o \

		drm_plane_helper.o drm_dp_mst_topology.o drm_atomic_helper.o \

		drm_kms_helper_common.o drm_dp_dual_mode_helper.o \

		drm_simple_kms_helper.o

		drm_simple_kms_helper.o drm_blend.o



drm_kms_helper-$(CONFIG_DRM_LOAD_EDID_FIRMWARE) += drm_edid_load.o

drm_kms_helper-$(CONFIG_DRM_FBDEV_EMULATION) += drm_fb_helper.o

drivers/gpu/drm/drm_atomic.c

+4 −0
Original line number Diff line number Diff line
@@ -711,6 +711,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);
@@ -767,6 +769,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 {

drivers/gpu/drm/drm_atomic_helper.c

+7 −0
Original line number Diff line number Diff line
@@ -32,6 +32,8 @@ 
#include <drm/drm_atomic_helper.h>

#include <linux/fence.h>



#include "drm_crtc_internal.h"



/**

 * DOC: overview

 *
@@ -592,6 +594,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;
@@ -2955,6 +2961,7 @@ void __drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc, 
	state->planes_changed = false;

	state->connectors_changed = false;

	state->color_mgmt_changed = false;

	state->zpos_changed = false;

	state->event = NULL;

}

EXPORT_SYMBOL(__drm_atomic_helper_crtc_duplicate_state);

drivers/gpu/drm/drm_blend.c

0 → 100644
+238 −0
Original line number Diff line number Diff line 
/*

 * 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

 * @zpos: initial value of zpos property

 * @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 zpos,

				   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, zpos);



	plane->zpos_property = prop;



	if (plane->state) {

		plane->state->zpos = zpos;

		plane->state->normalized_zpos = zpos;

	}



	return 0;

}

EXPORT_SYMBOL(drm_plane_create_zpos_property);



/**

 * drm_plane_create_zpos_immutable_property - create immuttable zpos property

 * @plane: drm plane

 * @zpos: 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 zpos)

{

	struct drm_property *prop;



	prop = drm_property_create_range(plane->dev, DRM_MODE_PROP_IMMUTABLE,

					 "zpos", zpos, zpos);

	if (!prop)

		return -ENOMEM;



	drm_object_attach_property(&plane->base, prop, zpos);



	plane->zpos_property = prop;



	if (plane->state) {

		plane->state->zpos = zpos;

		plane->state->normalized_zpos = zpos;

	}



	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

 */

static 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, n = 0;

	int ret = 0;



	DRM_DEBUG_ATOMIC("[CRTC:%d:%s] calculating normalized zpos values\n",

			 crtc->base.id, crtc->name);



	states = kmalloc_array(total_planes, sizeof(*states), 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;

		}

		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; i < n; i++) {

		plane = states[i]->plane;



		states[i]->normalized_zpos = i;

		DRM_DEBUG_ATOMIC("[PLANE:%d:%s] normalized zpos value %d\n",

				 plane->base.id, plane->name, i);

	}

	crtc_state->zpos_changed = true;



done:

	kfree(states);

	return ret;

}



/**

 * 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;

}