7 files changed, 275 insertions, 1 deletions

diff --git a/Documentation/gpu/kms-properties.csv b/Documentation/gpu/kms-properties.csv
index b6fcaf639c04..4c5ce3edcfd9 100644
--- a/Documentation/gpu/kms-properties.csv
+++ b/Documentation/gpu/kms-properties.csv
@@ -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
diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile
index e3dba6f44a79..0238bf8bc8c3 100644
--- a/drivers/gpu/drm/Makefile
+++ b/drivers/gpu/drm/Makefile
@@ -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
diff --git a/drivers/gpu/drm/drm_atomic.c b/drivers/gpu/drm/drm_atomic.c
index 8d2f111fa113..fa3930757972 100644
--- a/drivers/gpu/drm/drm_atomic.c
+++ b/drivers/gpu/drm/drm_atomic.c
@@ -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 {
diff --git a/drivers/gpu/drm/drm_atomic_helper.c b/drivers/gpu/drm/drm_atomic_helper.c
index de7fddce3cef..20be86d89a20 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
  *
@@ -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);
diff --git a/drivers/gpu/drm/drm_blend.c b/drivers/gpu/drm/drm_blend.c
new file mode 100644
index 000000000000..f3c0942bd756
--- /dev/null
+++ b/drivers/gpu/drm/drm_blend.c
@@ -0,0 +1,238 @@
+/*
+ * 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;
+}
diff --git a/drivers/gpu/drm/drm_crtc_internal.h b/drivers/gpu/drm/drm_crtc_internal.h
index 47a500b90fd7..0c34e6d906d1 100644
--- a/drivers/gpu/drm/drm_crtc_internal.h
+++ b/drivers/gpu/drm/drm_crtc_internal.h
@@ -128,3 +128,7 @@ int drm_mode_atomic_ioctl(struct drm_device *dev,
 
 int drm_modeset_register_all(struct drm_device *dev);
 void drm_modeset_unregister_all(struct drm_device *dev);
+
+/* 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 3edeaf88ebc0..44e070800b6d 100644
--- a/include/drm/drm_crtc.h
+++ b/include/drm/drm_crtc.h
@@ -308,6 +308,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
@@ -344,6 +345,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:
@@ -1409,6 +1411,9 @@ struct drm_connector {
  * @src_w: width of visible portion of plane (in 16.16)
  * @src_h: height of visible portion of plane (in 16.16)
  * @rotation: rotation of the plane
+ * @zpos: priority of the given plane on crtc (optional)
+ * @normalized_zpos: normalized value of zpos: unique, range from 0 to N-1
+ *      where N is the number of active planes for given crtc
  * @state: backpointer to global drm_atomic_state
  */
 struct drm_plane_state {
@@ -1429,6 +1434,10 @@ struct drm_plane_state {
         /* Plane rotation */
         unsigned int rotation;
 
+        /* Plane zpos */
+        unsigned int zpos;
+        unsigned int normalized_zpos;
+
         struct drm_atomic_state *state;
 };
 
@@ -1688,6 +1697,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
  * @helper_private: mid-layer private data
  */
 struct drm_plane {
@@ -1732,6 +1742,8 @@ struct drm_plane {
         const struct drm_plane_helper_funcs *helper_private;
 
         struct drm_plane_state *state;
+
+        struct drm_property *zpos_property;
 };
 
 /**
@@ -2958,6 +2970,14 @@ extern void drm_crtc_enable_color_mgmt(struct drm_crtc *crtc,
                                        uint degamma_lut_size,
                                        bool has_ctm,
                                        uint gamma_lut_size);
+
+int drm_plane_create_zpos_property(struct drm_plane *plane,
+                                   unsigned int zpos,
+                                   unsigned int min, unsigned int max);
+
+int drm_plane_create_zpos_immutable_property(struct drm_plane *plane,
+                                             unsigned int zpos);
+
 /* Helpers */
 struct drm_mode_object *drm_mode_object_find(struct drm_device *dev,
                                              uint32_t id, uint32_t type);