[PATCH v3 0/2] drm/blend: Add per-plane pixel blend mode property

[PATCH v3 0/2] drm/blend: Add per-plane pixel blend mode property

[Lowry Li]

Hi,

This serie aims at adding the support for pixel blend modes represent the
alpha blending equation selection in the driver. It also introduces to use
it in the malidp driver.

Let me know what you think,
Lowry

Changes for v3:
 - Refines the comments of drm_plane_create_blend_mode_property:
      1) Puts the descriptions (after the ":") on a new line
      2) Adds explaining why @supported_modes need PREMUL as default
 - Refines the comments of drm/mali-dp patchset
 - Rebased on drm-misc-next and fixed the confilcts with plane alpha patch

Changes for v2:
 - Moves the blending equation into the DOC comment
 - Refines the comments of drm_plane_create_blend_mode_property to not
   enumerate the #defines, but instead the string values
 - Uses fg.* instead of pixel.* and plane_alpha instead of plane.alpha
 - Introduces to use it in the malidp driver, which depends on the plane
   alpha patch

Changes from v1:
 - v1 is just the core changes to request for commments
 - Adds a pixel_blend_mode to drm_plane_state and a blend_mode_property to
   drm_plane, and related support functions
 - Defines three blend modes in drm_blend.h
 - Rebased on current drm-next

Lowry Li (2):
  drm: Add per-plane pixel blend mode property
  drm/mali-dp: Implement plane alpha and pixel blend on malidp

 drivers/gpu/drm/arm/malidp_planes.c |  76 +++++++++++++---------
 drivers/gpu/drm/drm_atomic.c        |   4 ++
 drivers/gpu/drm/drm_atomic_helper.c |   1 +
 drivers/gpu/drm/drm_blend.c         | 126 ++++++++++++++++++++++++++++++++++++
 include/drm/drm_blend.h             |   6 ++
 include/drm/drm_plane.h             |   5 ++
 6 files changed, 186 insertions(+), 32 deletions(-)

-- 
1.9.1

[PATCH v3 1/2] drm: Add per-plane pixel blend mode property

[Lowry Li]

Pixel blend modes represent the alpha blending equation
selection, describing how the pixels from the current
plane are composited with the background.

Add a pixel_blend_mode to drm_plane_state and a
blend_mode_property to drm_plane, and related support
functions.

Defines three blend modes in drm_blend.h.

Signed-off-by: Lowry Li <lowry.li@arm.com>
---
 drivers/gpu/drm/drm_atomic.c        |   4 ++
 drivers/gpu/drm/drm_atomic_helper.c |   1 +
 drivers/gpu/drm/drm_blend.c         | 126 ++++++++++++++++++++++++++++++++++++
 include/drm/drm_blend.h             |   6 ++
 include/drm/drm_plane.h             |   5 ++
 5 files changed, 142 insertions(+)

diff --git a/drivers/gpu/drm/drm_atomic.c b/drivers/gpu/drm/drm_atomic.c
index 07fef42..1d18389 100644
--- a/drivers/gpu/drm/drm_atomic.c
+++ b/drivers/gpu/drm/drm_atomic.c
@@ -785,6 +785,8 @@ static int drm_atomic_plane_set_property(struct drm_plane *plane,
 		state->src_h = val;
 	} else if (property == plane->alpha_property) {
 		state->alpha = val;
+	} else if (property == plane->blend_mode_property) {
+		state->pixel_blend_mode = val;
 	} else if (property == plane->rotation_property) {
 		if (!is_power_of_2(val & DRM_MODE_ROTATE_MASK))
 			return -EINVAL;
@@ -852,6 +854,8 @@ static int drm_atomic_plane_set_property(struct drm_plane *plane,
 		*val = state->src_h;
 	} else if (property == plane->alpha_property) {
 		*val = state->alpha;
+	} else if (property == plane->blend_mode_property) {
+		*val = state->pixel_blend_mode;
 	} else if (property == plane->rotation_property) {
 		*val = state->rotation;
 	} else if (property == plane->zpos_property) {
diff --git a/drivers/gpu/drm/drm_atomic_helper.c b/drivers/gpu/drm/drm_atomic_helper.c
index 130da51..7f5d463 100644
--- a/drivers/gpu/drm/drm_atomic_helper.c
+++ b/drivers/gpu/drm/drm_atomic_helper.c
@@ -3515,6 +3515,7 @@ void drm_atomic_helper_plane_reset(struct drm_plane *plane)
 		/* Reset the alpha value to fully opaque if it matters */
 		if (plane->alpha_property)
 			plane->state->alpha = plane->alpha_property->values[1];
+		plane->state->pixel_blend_mode = DRM_MODE_BLEND_PREMULTI;
 	}
 }
 EXPORT_SYMBOL(drm_atomic_helper_plane_reset);
diff --git a/drivers/gpu/drm/drm_blend.c b/drivers/gpu/drm/drm_blend.c
index a16a74d..ac6f19c 100644
--- a/drivers/gpu/drm/drm_blend.c
+++ b/drivers/gpu/drm/drm_blend.c
@@ -107,6 +107,52 @@
  *	planes. Without this property the primary plane is always below the cursor
  *	plane, and ordering between all other planes is undefined.
  *
+ * pixel blend mode:
+ *	Pixel blend mode is set up with drm_plane_create_blend_mode_property().
+ *	It adds a blend mode for alpha blending equation selection, describing
+ *	how the pixels from the current plane are composited with the
+ *	background.
+ *
+ *	 Three alpha blending equations are defined:
+ *
+ *	 "None":
+ *		 Blend formula that ignores the pixel alpha::
+ *
+ *			 out.rgb = plane_alpha * fg.rgb +
+ *				 (1 - plane_alpha) * bg.rgb
+ *
+ *	 "Pre-multiplied":
+ *		 Blend formula that assumes the pixel color values
+ *		 have been already pre-multiplied with the alpha
+ *		 channel values::
+ *
+ *			 out.rgb = plane_alpha * fg.rgb +
+ *				 (1 - (plane_alpha * fg.alpha)) * bg.rgb
+ *
+ *	 "Coverage":
+ *		 Blend formula that assumes the pixel color values have not
+ *		 been pre-multiplied and will do so when blending them to the
+ *		 background color values::
+ *
+ *			 out.rgb = plane_alpha * fg.alpha * fg.rgb +
+ *				 (1 - (plane_alpha * fg.alpha)) * bg.rgb
+ *
+ *	 Using the following symbols:
+ *
+ *	 ``fg.rgb``:
+ *		 Each of the RGB component values from the plane's pixel
+ *	 ``fg.alpha``:
+ *		 Alpha component value from the plane's pixel. If the plane's
+ *		 pixel format has no alpha component, then this is assumed to be
+ *		 1.0. In these cases, this property has no effect, as all three
+ *		 equations become equivalent.
+ *	 ``bg.rgb``:
+ *		 Each of the RGB component values from the background
+ *	 ``plane_alpha``:
+ *		 Plane alpha value set by the plane "alpha" property. If the
+ *		 plane does not expose the "alpha" property, then this is
+ *		 assumed to be 1.0
+ *
  * Note that all the property extensions described here apply either to the
  * plane or the CRTC (e.g. for the background color, which currently is not
  * exposed and assumed to be black).
@@ -448,3 +494,83 @@ int drm_atomic_normalize_zpos(struct drm_device *dev,
 	return 0;
 }
 EXPORT_SYMBOL(drm_atomic_normalize_zpos);
+
+/**
+ * drm_plane_create_blend_mode_property - create a new blend mode property
+ * @plane: drm plane
+ * @supported_modes: bitmask of supported modes, must include
+ *		     BIT(DRM_MODE_BLEND_PREMULTI). Current DRM assumption is
+ *		     that alpha is premultiplied, and old userspace can break if
+ *		     the property defaults to coverage.
+ *
+ * This creates a new property describing the blend mode.
+ *
+ * The property exposed to userspace is an enumeration property (see
+ * drm_property_create_enum()) called "pixel blend mode" and has the
+ * following enumeration values:
+ *
+ * "None":
+ *	Blend formula that ignores the pixel alpha.
+ *
+ * "Pre-multiplied":
+ *	Blend formula that assumes the pixel color values have been already
+ *	pre-multiplied with the alpha channel values.
+ *
+ * "Coverage":
+ *	Blend formula that assumes the pixel color values have not been
+ *	pre-multiplied and will do so when blending them to the background color
+ *	values.
+ *
+ * RETURNS:
+ * Zero for success or -errno
+ */
+int drm_plane_create_blend_mode_property(struct drm_plane *plane,
+					 unsigned int supported_modes)
+{
+	struct drm_device *dev = plane->dev;
+	struct drm_property *prop;
+	static const struct drm_prop_enum_list props[] = {
+		{ DRM_MODE_BLEND_PIXEL_NONE, "None" },
+		{ DRM_MODE_BLEND_PREMULTI, "Pre-multiplied" },
+		{ DRM_MODE_BLEND_COVERAGE, "Coverage" },
+	};
+	unsigned int valid_mode_mask = BIT(DRM_MODE_BLEND_PIXEL_NONE) |
+				       BIT(DRM_MODE_BLEND_PREMULTI)   |
+				       BIT(DRM_MODE_BLEND_COVERAGE);
+	int i, j = 0;
+
+	if (WARN_ON((supported_modes & ~valid_mode_mask) ||
+		    ((supported_modes & BIT(DRM_MODE_BLEND_PREMULTI)) == 0)))
+		return -EINVAL;
+
+	prop = drm_property_create(dev, DRM_MODE_PROP_ENUM,
+				   "pixel blend mode",
+				   hweight32(supported_modes));
+	if (!prop)
+		return -ENOMEM;
+
+	for (i = 0; i < ARRAY_SIZE(props); i++) {
+		int ret;
+
+		if (!(BIT(props[i].type) & supported_modes))
+			continue;
+
+		ret = drm_property_add_enum(prop, j++, props[i].type,
+					    props[i].name);
+
+		if (ret) {
+			drm_property_destroy(dev, prop);
+
+			return ret;
+		}
+	}
+
+	drm_object_attach_property(&plane->base, prop, DRM_MODE_BLEND_PREMULTI);
+	plane->blend_mode_property = prop;
+
+	if (plane->state)
+		plane->state->pixel_blend_mode = DRM_MODE_BLEND_PREMULTI;
+
+	return 0;
+}
+EXPORT_SYMBOL(drm_plane_create_blend_mode_property);
diff --git a/include/drm/drm_blend.h b/include/drm/drm_blend.h
index 330c561..28c5076 100644
--- a/include/drm/drm_blend.h
+++ b/include/drm/drm_blend.h
@@ -27,6 +27,10 @@
 #include <linux/ctype.h>
 #include <drm/drm_mode.h>
 
+#define DRM_MODE_BLEND_PIXEL_NONE	0
+#define DRM_MODE_BLEND_PREMULTI		1
+#define DRM_MODE_BLEND_COVERAGE		2
+
 struct drm_device;
 struct drm_atomic_state;
 struct drm_plane;
@@ -52,4 +56,6 @@ int drm_plane_create_zpos_immutable_property(struct drm_plane *plane,
 					     unsigned int zpos);
 int drm_atomic_normalize_zpos(struct drm_device *dev,
 			      struct drm_atomic_state *state);
+int drm_plane_create_blend_mode_property(struct drm_plane *plane,
+					 unsigned int supported_modes);
 #endif
diff --git a/include/drm/drm_plane.h b/include/drm/drm_plane.h
index 14b1607..6e2c045 100644
--- a/include/drm/drm_plane.h
+++ b/include/drm/drm_plane.h
@@ -44,6 +44,8 @@
  * @src_w: width of visible portion of plane (in 16.16)
  * @src_h: height of visible portion of plane (in 16.16)
  * @alpha: opacity of the plane
+ * @pixel_blend_mode: how the plane's framebuffer alpha channel is used when
+ *	blending with the background colour.
  * @rotation: rotation of the plane
  * @zpos: priority of the given plane on crtc (optional)
  *	Note that multiple active planes on the same crtc can have an identical
@@ -116,6 +118,7 @@ struct drm_plane_state {
 
 	/* Plane opacity */
 	u16 alpha;
+	uint16_t pixel_blend_mode;
 
 	/* Plane rotation */
 	unsigned int rotation;
@@ -513,6 +516,7 @@ enum drm_plane_type {
  * @alpha_property: alpha property for this plane
  * @zpos_property: zpos property for this plane
  * @rotation_property: rotation property for this plane
+ * @blend_mode_property: blend mode property for this plane
  * @helper_private: mid-layer private data
  */
 struct drm_plane {
@@ -589,6 +593,7 @@ struct drm_plane {
 	struct drm_property *alpha_property;
 	struct drm_property *zpos_property;
 	struct drm_property *rotation_property;
+	struct drm_property *blend_mode_property;
 
 	/**
 	 * @color_encoding_property:
-- 
1.9.1

Re: [PATCH v3 1/2] drm: Add per-plane pixel blend mode property

[Emil Velikov]

On 1 June 2018 at 13:41, Lowry Li <lowry.li@arm.com> wrote:
> Pixel blend modes represent the alpha blending equation
> selection, describing how the pixels from the current
> plane are composited with the background.
>
> Add a pixel_blend_mode to drm_plane_state and a
> blend_mode_property to drm_plane, and related support
> functions.
>
> Defines three blend modes in drm_blend.h.
>
> Signed-off-by: Lowry Li <lowry.li@arm.com>
> ---
>  drivers/gpu/drm/drm_atomic.c        |   4 ++
>  drivers/gpu/drm/drm_atomic_helper.c |   1 +
>  drivers/gpu/drm/drm_blend.c         | 126 ++++++++++++++++++++++++++++++++++++
>  include/drm/drm_blend.h             |   6 ++
>  include/drm/drm_plane.h             |   5 ++
>  5 files changed, 142 insertions(+)
>
> diff --git a/drivers/gpu/drm/drm_atomic.c b/drivers/gpu/drm/drm_atomic.c
> index 07fef42..1d18389 100644
> --- a/drivers/gpu/drm/drm_atomic.c
> +++ b/drivers/gpu/drm/drm_atomic.c
> @@ -785,6 +785,8 @@ static int drm_atomic_plane_set_property(struct drm_plane *plane,
>                 state->src_h = val;
>         } else if (property == plane->alpha_property) {
>                 state->alpha = val;
> +       } else if (property == plane->blend_mode_property) {
> +               state->pixel_blend_mode = val;
>         } else if (property == plane->rotation_property) {
>                 if (!is_power_of_2(val & DRM_MODE_ROTATE_MASK))
>                         return -EINVAL;
> @@ -852,6 +854,8 @@ static int drm_atomic_plane_set_property(struct drm_plane *plane,
>                 *val = state->src_h;
>         } else if (property == plane->alpha_property) {
>                 *val = state->alpha;
> +       } else if (property == plane->blend_mode_property) {
> +               *val = state->pixel_blend_mode;
>         } else if (property == plane->rotation_property) {
>                 *val = state->rotation;
>         } else if (property == plane->zpos_property) {
> diff --git a/drivers/gpu/drm/drm_atomic_helper.c b/drivers/gpu/drm/drm_atomic_helper.c
> index 130da51..7f5d463 100644
> --- a/drivers/gpu/drm/drm_atomic_helper.c
> +++ b/drivers/gpu/drm/drm_atomic_helper.c
> @@ -3515,6 +3515,7 @@ void drm_atomic_helper_plane_reset(struct drm_plane *plane)
>                 /* Reset the alpha value to fully opaque if it matters */
>                 if (plane->alpha_property)
>                         plane->state->alpha = plane->alpha_property->values[1];
> +               plane->state->pixel_blend_mode = DRM_MODE_BLEND_PREMULTI;
>         }
>  }
>  EXPORT_SYMBOL(drm_atomic_helper_plane_reset);
> diff --git a/drivers/gpu/drm/drm_blend.c b/drivers/gpu/drm/drm_blend.c
> index a16a74d..ac6f19c 100644
> --- a/drivers/gpu/drm/drm_blend.c
> +++ b/drivers/gpu/drm/drm_blend.c
> @@ -107,6 +107,52 @@
>   *     planes. Without this property the primary plane is always below the cursor
>   *     plane, and ordering between all other planes is undefined.
>   *
> + * pixel blend mode:
> + *     Pixel blend mode is set up with drm_plane_create_blend_mode_property().
> + *     It adds a blend mode for alpha blending equation selection, describing
> + *     how the pixels from the current plane are composited with the
> + *     background.
> + *
> + *      Three alpha blending equations are defined:
> + *
> + *      "None":
> + *              Blend formula that ignores the pixel alpha::
> + *
> + *                      out.rgb = plane_alpha * fg.rgb +
> + *                              (1 - plane_alpha) * bg.rgb
> + *
> + *      "Pre-multiplied":
> + *              Blend formula that assumes the pixel color values
> + *              have been already pre-multiplied with the alpha
> + *              channel values::
> + *
> + *                      out.rgb = plane_alpha * fg.rgb +
> + *                              (1 - (plane_alpha * fg.alpha)) * bg.rgb
> + *
> + *      "Coverage":
> + *              Blend formula that assumes the pixel color values have not
> + *              been pre-multiplied and will do so when blending them to the
> + *              background color values::
> + *
> + *                      out.rgb = plane_alpha * fg.alpha * fg.rgb +
> + *                              (1 - (plane_alpha * fg.alpha)) * bg.rgb
> + *
> + *      Using the following symbols:
> + *
> + *      ``fg.rgb``:
> + *              Each of the RGB component values from the plane's pixel
> + *      ``fg.alpha``:
> + *              Alpha component value from the plane's pixel. If the plane's
> + *              pixel format has no alpha component, then this is assumed to be
> + *              1.0. In these cases, this property has no effect, as all three
> + *              equations become equivalent.
> + *      ``bg.rgb``:
> + *              Each of the RGB component values from the background
> + *      ``plane_alpha``:
> + *              Plane alpha value set by the plane "alpha" property. If the
> + *              plane does not expose the "alpha" property, then this is
> + *              assumed to be 1.0
> + *
>   * Note that all the property extensions described here apply either to the
>   * plane or the CRTC (e.g. for the background color, which currently is not
>   * exposed and assumed to be black).
> @@ -448,3 +494,83 @@ int drm_atomic_normalize_zpos(struct drm_device *dev,
>         return 0;
>  }
>  EXPORT_SYMBOL(drm_atomic_normalize_zpos);
> +
> +/**
> + * drm_plane_create_blend_mode_property - create a new blend mode property
> + * @plane: drm plane
> + * @supported_modes: bitmask of supported modes, must include
> + *                  BIT(DRM_MODE_BLEND_PREMULTI). Current DRM assumption is
> + *                  that alpha is premultiplied, and old userspace can break if
> + *                  the property defaults to coverage.
> + *

Thanks for the explanation Lowry.
Sigh, old userspace :-\

One pedantic suggestion s/defaults to coverage/defaults to anything else/
Since defaulting to "none" or any future blend mode is also a no-go.

I wouldn't bother resending solely for ^^. Perhaps squash locally
before merging?

With that, the patch is
Reviewed-by: Emil Velikov <emil.velikov@collabora.com>

-Emil

Re: [PATCH v3 1/2] drm: Add per-plane pixel blend mode property

[Maarten Lankhorst]

Op 05-06-18 om 11:07 schreef Lowry Li:
> On Mon, Jun 04, 2018 at 02:49:26PM +0100, Emil Velikov wrote:
>> On 1 June 2018 at 13:41, Lowry Li <lowry.li@arm.com> wrote:
>>> Pixel blend modes represent the alpha blending equation
>>> selection, describing how the pixels from the current
>>> plane are composited with the background.
>>>
>>> Add a pixel_blend_mode to drm_plane_state and a
>>> blend_mode_property to drm_plane, and related support
>>> functions.
>>>
>>> Defines three blend modes in drm_blend.h.
>>>
>>> Signed-off-by: Lowry Li <lowry.li@arm.com>
>>> ---
>>>  drivers/gpu/drm/drm_atomic.c        |   4 ++
>>>  drivers/gpu/drm/drm_atomic_helper.c |   1 +
>>>  drivers/gpu/drm/drm_blend.c         | 126 ++++++++++++++++++++++++++++++++++++
>>>  include/drm/drm_blend.h             |   6 ++
>>>  include/drm/drm_plane.h             |   5 ++
>>>  5 files changed, 142 insertions(+)
>>>
>>> diff --git a/drivers/gpu/drm/drm_atomic.c b/drivers/gpu/drm/drm_atomic.c
>>> index 07fef42..1d18389 100644
>>> --- a/drivers/gpu/drm/drm_atomic.c
>>> +++ b/drivers/gpu/drm/drm_atomic.c
>>> @@ -785,6 +785,8 @@ static int drm_atomic_plane_set_property(struct drm_plane *plane,
>>>                 state->src_h = val;
>>>         } else if (property == plane->alpha_property) {
>>>                 state->alpha = val;
>>> +       } else if (property == plane->blend_mode_property) {
>>> +               state->pixel_blend_mode = val;
>>>         } else if (property == plane->rotation_property) {
>>>                 if (!is_power_of_2(val & DRM_MODE_ROTATE_MASK))
>>>                         return -EINVAL;
>>> @@ -852,6 +854,8 @@ static int drm_atomic_plane_set_property(struct drm_plane *plane,
>>>                 *val = state->src_h;
>>>         } else if (property == plane->alpha_property) {
>>>                 *val = state->alpha;
>>> +       } else if (property == plane->blend_mode_property) {
>>> +               *val = state->pixel_blend_mode;
>>>         } else if (property == plane->rotation_property) {
>>>                 *val = state->rotation;
>>>         } else if (property == plane->zpos_property) {
>>> diff --git a/drivers/gpu/drm/drm_atomic_helper.c b/drivers/gpu/drm/drm_atomic_helper.c
>>> index 130da51..7f5d463 100644
>>> --- a/drivers/gpu/drm/drm_atomic_helper.c
>>> +++ b/drivers/gpu/drm/drm_atomic_helper.c
>>> @@ -3515,6 +3515,7 @@ void drm_atomic_helper_plane_reset(struct drm_plane *plane)
>>>                 /* Reset the alpha value to fully opaque if it matters */
>>>                 if (plane->alpha_property)
>>>                         plane->state->alpha = plane->alpha_property->values[1];
>>> +               plane->state->pixel_blend_mode = DRM_MODE_BLEND_PREMULTI;
>>>         }
>>>  }
>>>  EXPORT_SYMBOL(drm_atomic_helper_plane_reset);
>>> diff --git a/drivers/gpu/drm/drm_blend.c b/drivers/gpu/drm/drm_blend.c
>>> index a16a74d..ac6f19c 100644
>>> --- a/drivers/gpu/drm/drm_blend.c
>>> +++ b/drivers/gpu/drm/drm_blend.c
>>> @@ -107,6 +107,52 @@
>>>   *     planes. Without this property the primary plane is always below the cursor
>>>   *     plane, and ordering between all other planes is undefined.
>>>   *
>>> + * pixel blend mode:
>>> + *     Pixel blend mode is set up with drm_plane_create_blend_mode_property().
>>> + *     It adds a blend mode for alpha blending equation selection, describing
>>> + *     how the pixels from the current plane are composited with the
>>> + *     background.
>>> + *
>>> + *      Three alpha blending equations are defined:
>>> + *
>>> + *      "None":
>>> + *              Blend formula that ignores the pixel alpha::
>>> + *
>>> + *                      out.rgb = plane_alpha * fg.rgb +
>>> + *                              (1 - plane_alpha) * bg.rgb
>>> + *
>>> + *      "Pre-multiplied":
>>> + *              Blend formula that assumes the pixel color values
>>> + *              have been already pre-multiplied with the alpha
>>> + *              channel values::
>>> + *
>>> + *                      out.rgb = plane_alpha * fg.rgb +
>>> + *                              (1 - (plane_alpha * fg.alpha)) * bg.rgb
>>> + *
>>> + *      "Coverage":
>>> + *              Blend formula that assumes the pixel color values have not
>>> + *              been pre-multiplied and will do so when blending them to the
>>> + *              background color values::
>>> + *
>>> + *                      out.rgb = plane_alpha * fg.alpha * fg.rgb +
>>> + *                              (1 - (plane_alpha * fg.alpha)) * bg.rgb
>>> + *
>>> + *      Using the following symbols:
>>> + *
>>> + *      ``fg.rgb``:
>>> + *              Each of the RGB component values from the plane's pixel
>>> + *      ``fg.alpha``:
>>> + *              Alpha component value from the plane's pixel. If the plane's
>>> + *              pixel format has no alpha component, then this is assumed to be
>>> + *              1.0. In these cases, this property has no effect, as all three
>>> + *              equations become equivalent.
>>> + *      ``bg.rgb``:
>>> + *              Each of the RGB component values from the background
>>> + *      ``plane_alpha``:
>>> + *              Plane alpha value set by the plane "alpha" property. If the
>>> + *              plane does not expose the "alpha" property, then this is
>>> + *              assumed to be 1.0
>>> + *
>>>   * Note that all the property extensions described here apply either to the
>>>   * plane or the CRTC (e.g. for the background color, which currently is not
>>>   * exposed and assumed to be black).
>>> @@ -448,3 +494,83 @@ int drm_atomic_normalize_zpos(struct drm_device *dev,
>>>         return 0;
>>>  }
>>>  EXPORT_SYMBOL(drm_atomic_normalize_zpos);
>>> +
>>> +/**
>>> + * drm_plane_create_blend_mode_property - create a new blend mode property
>>> + * @plane: drm plane
>>> + * @supported_modes: bitmask of supported modes, must include
>>> + *                  BIT(DRM_MODE_BLEND_PREMULTI). Current DRM assumption is
>>> + *                  that alpha is premultiplied, and old userspace can break if
>>> + *                  the property defaults to coverage.
>>> + *
>> Thanks for the explanation Lowry.
>> Sigh, old userspace :-\
>>
>> One pedantic suggestion s/defaults to coverage/defaults to anything else/
>> Since defaulting to "none" or any future blend mode is also a no-go.
>>
>> I wouldn't bother resending solely for ^^. Perhaps squash locally
>> before merging?
>>
>> With that, the patch is
>> Reviewed-by: Emil Velikov <emil.velikov@collabora.com>
>>
>> -Emil
> Hi Emil,
>
> Thanks a lot for your review and will change that.

Ping? Any updates?

~Maarten

Re: [PATCH v3 1/2] drm: Add per-plane pixel blend mode property

[Maarten Lankhorst]

Op 14-08-18 om 05:11 schreef Lowry Li:
> On Mon, Aug 13, 2018 at 12:49:13PM +0200, Maarten Lankhorst wrote:
>> Op 05-06-18 om 11:07 schreef Lowry Li:
>>> On Mon, Jun 04, 2018 at 02:49:26PM +0100, Emil Velikov wrote:
>>>> On 1 June 2018 at 13:41, Lowry Li <lowry.li@arm.com> wrote:
>>>>> Pixel blend modes represent the alpha blending equation
>>>>> selection, describing how the pixels from the current
>>>>> plane are composited with the background.
>>>>>
>>>>> Add a pixel_blend_mode to drm_plane_state and a
>>>>> blend_mode_property to drm_plane, and related support
>>>>> functions.
>>>>>
>>>>> Defines three blend modes in drm_blend.h.
>>>>>
>>>>> Signed-off-by: Lowry Li <lowry.li@arm.com>
>>>>> ---
>>>>>  drivers/gpu/drm/drm_atomic.c        |   4 ++
>>>>>  drivers/gpu/drm/drm_atomic_helper.c |   1 +
>>>>>  drivers/gpu/drm/drm_blend.c         | 126 ++++++++++++++++++++++++++++++++++++
>>>>>  include/drm/drm_blend.h             |   6 ++
>>>>>  include/drm/drm_plane.h             |   5 ++
>>>>>  5 files changed, 142 insertions(+)
>>>>>
>>>>> diff --git a/drivers/gpu/drm/drm_atomic.c b/drivers/gpu/drm/drm_atomic.c
>>>>> index 07fef42..1d18389 100644
>>>>> --- a/drivers/gpu/drm/drm_atomic.c
>>>>> +++ b/drivers/gpu/drm/drm_atomic.c
>>>>> @@ -785,6 +785,8 @@ static int drm_atomic_plane_set_property(struct drm_plane *plane,
>>>>>                 state->src_h = val;
>>>>>         } else if (property == plane->alpha_property) {
>>>>>                 state->alpha = val;
>>>>> +       } else if (property == plane->blend_mode_property) {
>>>>> +               state->pixel_blend_mode = val;
>>>>>         } else if (property == plane->rotation_property) {
>>>>>                 if (!is_power_of_2(val & DRM_MODE_ROTATE_MASK))
>>>>>                         return -EINVAL;
>>>>> @@ -852,6 +854,8 @@ static int drm_atomic_plane_set_property(struct drm_plane *plane,
>>>>>                 *val = state->src_h;
>>>>>         } else if (property == plane->alpha_property) {
>>>>>                 *val = state->alpha;
>>>>> +       } else if (property == plane->blend_mode_property) {
>>>>> +               *val = state->pixel_blend_mode;
>>>>>         } else if (property == plane->rotation_property) {
>>>>>                 *val = state->rotation;
>>>>>         } else if (property == plane->zpos_property) {
>>>>> diff --git a/drivers/gpu/drm/drm_atomic_helper.c b/drivers/gpu/drm/drm_atomic_helper.c
>>>>> index 130da51..7f5d463 100644
>>>>> --- a/drivers/gpu/drm/drm_atomic_helper.c
>>>>> +++ b/drivers/gpu/drm/drm_atomic_helper.c
>>>>> @@ -3515,6 +3515,7 @@ void drm_atomic_helper_plane_reset(struct drm_plane *plane)
>>>>>                 /* Reset the alpha value to fully opaque if it matters */
>>>>>                 if (plane->alpha_property)
>>>>>                         plane->state->alpha = plane->alpha_property->values[1];
>>>>> +               plane->state->pixel_blend_mode = DRM_MODE_BLEND_PREMULTI;
>>>>>         }
>>>>>  }
>>>>>  EXPORT_SYMBOL(drm_atomic_helper_plane_reset);
>>>>> diff --git a/drivers/gpu/drm/drm_blend.c b/drivers/gpu/drm/drm_blend.c
>>>>> index a16a74d..ac6f19c 100644
>>>>> --- a/drivers/gpu/drm/drm_blend.c
>>>>> +++ b/drivers/gpu/drm/drm_blend.c
>>>>> @@ -107,6 +107,52 @@
>>>>>   *     planes. Without this property the primary plane is always below the cursor
>>>>>   *     plane, and ordering between all other planes is undefined.
>>>>>   *
>>>>> + * pixel blend mode:
>>>>> + *     Pixel blend mode is set up with drm_plane_create_blend_mode_property().
>>>>> + *     It adds a blend mode for alpha blending equation selection, describing
>>>>> + *     how the pixels from the current plane are composited with the
>>>>> + *     background.
>>>>> + *
>>>>> + *      Three alpha blending equations are defined:
>>>>> + *
>>>>> + *      "None":
>>>>> + *              Blend formula that ignores the pixel alpha::
>>>>> + *
>>>>> + *                      out.rgb = plane_alpha * fg.rgb +
>>>>> + *                              (1 - plane_alpha) * bg.rgb
>>>>> + *
>>>>> + *      "Pre-multiplied":
>>>>> + *              Blend formula that assumes the pixel color values
>>>>> + *              have been already pre-multiplied with the alpha
>>>>> + *              channel values::
>>>>> + *
>>>>> + *                      out.rgb = plane_alpha * fg.rgb +
>>>>> + *                              (1 - (plane_alpha * fg.alpha)) * bg.rgb
>>>>> + *
>>>>> + *      "Coverage":
>>>>> + *              Blend formula that assumes the pixel color values have not
>>>>> + *              been pre-multiplied and will do so when blending them to the
>>>>> + *              background color values::
>>>>> + *
>>>>> + *                      out.rgb = plane_alpha * fg.alpha * fg.rgb +
>>>>> + *                              (1 - (plane_alpha * fg.alpha)) * bg.rgb
>>>>> + *
>>>>> + *      Using the following symbols:
>>>>> + *
>>>>> + *      ``fg.rgb``:
>>>>> + *              Each of the RGB component values from the plane's pixel
>>>>> + *      ``fg.alpha``:
>>>>> + *              Alpha component value from the plane's pixel. If the plane's
>>>>> + *              pixel format has no alpha component, then this is assumed to be
>>>>> + *              1.0. In these cases, this property has no effect, as all three
>>>>> + *              equations become equivalent.
>>>>> + *      ``bg.rgb``:
>>>>> + *              Each of the RGB component values from the background
>>>>> + *      ``plane_alpha``:
>>>>> + *              Plane alpha value set by the plane "alpha" property. If the
>>>>> + *              plane does not expose the "alpha" property, then this is
>>>>> + *              assumed to be 1.0
>>>>> + *
>>>>>   * Note that all the property extensions described here apply either to the
>>>>>   * plane or the CRTC (e.g. for the background color, which currently is not
>>>>>   * exposed and assumed to be black).
>>>>> @@ -448,3 +494,83 @@ int drm_atomic_normalize_zpos(struct drm_device *dev,
>>>>>         return 0;
>>>>>  }
>>>>>  EXPORT_SYMBOL(drm_atomic_normalize_zpos);
>>>>> +
>>>>> +/**
>>>>> + * drm_plane_create_blend_mode_property - create a new blend mode property
>>>>> + * @plane: drm plane
>>>>> + * @supported_modes: bitmask of supported modes, must include
>>>>> + *                  BIT(DRM_MODE_BLEND_PREMULTI). Current DRM assumption is
>>>>> + *                  that alpha is premultiplied, and old userspace can break if
>>>>> + *                  the property defaults to coverage.
>>>>> + *
>>>> Thanks for the explanation Lowry.
>>>> Sigh, old userspace :-\
>>>>
>>>> One pedantic suggestion s/defaults to coverage/defaults to anything else/
>>>> Since defaulting to "none" or any future blend mode is also a no-go.
>>>>
>>>> I wouldn't bother resending solely for ^^. Perhaps squash locally
>>>> before merging?
>>>>
>>>> With that, the patch is
>>>> Reviewed-by: Emil Velikov <emil.velikov@collabora.com>
>>>>
>>>> -Emil
>>> Hi Emil,
>>>
>>> Thanks a lot for your review and will change that.
>> Ping? Any updates?
>>
>> ~Maarten
> Hi Maarten,
>
> So far the merge request on user space patch has been verified by John
> Stultz. The comments from Sean has been fixed and now we are waiting the
> reviewed-tag from Sean. Once it merged, we'll send a new kernel patch to
> review.
>
Hey,

In general the kernel patch should be merged first, because userspace cannot rely on the behavior until the next -rc1 that integrates it.
However, in order to merge the kernel patch, a userspace proof of concept for validation is needed first. Since you're close to merging,
I would say the userspace requirement is satisfied. It's safe to send the kernel patch. :)

~Maarten

Re: [PATCH v3 1/2] drm: Add per-plane pixel blend mode property

[Daniel Vetter]

On Tue, Aug 14, 2018 at 11:15:43AM +0200, Maarten Lankhorst wrote:
> Op 14-08-18 om 05:11 schreef Lowry Li:
> > On Mon, Aug 13, 2018 at 12:49:13PM +0200, Maarten Lankhorst wrote:
> >> Op 05-06-18 om 11:07 schreef Lowry Li:
> >>> On Mon, Jun 04, 2018 at 02:49:26PM +0100, Emil Velikov wrote:
> >>>> On 1 June 2018 at 13:41, Lowry Li <lowry.li@arm.com> wrote:
> >>>>> Pixel blend modes represent the alpha blending equation
> >>>>> selection, describing how the pixels from the current
> >>>>> plane are composited with the background.
> >>>>>
> >>>>> Add a pixel_blend_mode to drm_plane_state and a
> >>>>> blend_mode_property to drm_plane, and related support
> >>>>> functions.
> >>>>>
> >>>>> Defines three blend modes in drm_blend.h.
> >>>>>
> >>>>> Signed-off-by: Lowry Li <lowry.li@arm.com>
> >>>>> ---
> >>>>>  drivers/gpu/drm/drm_atomic.c        |   4 ++
> >>>>>  drivers/gpu/drm/drm_atomic_helper.c |   1 +
> >>>>>  drivers/gpu/drm/drm_blend.c         | 126 ++++++++++++++++++++++++++++++++++++
> >>>>>  include/drm/drm_blend.h             |   6 ++
> >>>>>  include/drm/drm_plane.h             |   5 ++
> >>>>>  5 files changed, 142 insertions(+)
> >>>>>
> >>>>> diff --git a/drivers/gpu/drm/drm_atomic.c b/drivers/gpu/drm/drm_atomic.c
> >>>>> index 07fef42..1d18389 100644
> >>>>> --- a/drivers/gpu/drm/drm_atomic.c
> >>>>> +++ b/drivers/gpu/drm/drm_atomic.c
> >>>>> @@ -785,6 +785,8 @@ static int drm_atomic_plane_set_property(struct drm_plane *plane,
> >>>>>                 state->src_h = val;
> >>>>>         } else if (property == plane->alpha_property) {
> >>>>>                 state->alpha = val;
> >>>>> +       } else if (property == plane->blend_mode_property) {
> >>>>> +               state->pixel_blend_mode = val;
> >>>>>         } else if (property == plane->rotation_property) {
> >>>>>                 if (!is_power_of_2(val & DRM_MODE_ROTATE_MASK))
> >>>>>                         return -EINVAL;
> >>>>> @@ -852,6 +854,8 @@ static int drm_atomic_plane_set_property(struct drm_plane *plane,
> >>>>>                 *val = state->src_h;
> >>>>>         } else if (property == plane->alpha_property) {
> >>>>>                 *val = state->alpha;
> >>>>> +       } else if (property == plane->blend_mode_property) {
> >>>>> +               *val = state->pixel_blend_mode;
> >>>>>         } else if (property == plane->rotation_property) {
> >>>>>                 *val = state->rotation;
> >>>>>         } else if (property == plane->zpos_property) {
> >>>>> diff --git a/drivers/gpu/drm/drm_atomic_helper.c b/drivers/gpu/drm/drm_atomic_helper.c
> >>>>> index 130da51..7f5d463 100644
> >>>>> --- a/drivers/gpu/drm/drm_atomic_helper.c
> >>>>> +++ b/drivers/gpu/drm/drm_atomic_helper.c
> >>>>> @@ -3515,6 +3515,7 @@ void drm_atomic_helper_plane_reset(struct drm_plane *plane)
> >>>>>                 /* Reset the alpha value to fully opaque if it matters */
> >>>>>                 if (plane->alpha_property)
> >>>>>                         plane->state->alpha = plane->alpha_property->values[1];
> >>>>> +               plane->state->pixel_blend_mode = DRM_MODE_BLEND_PREMULTI;
> >>>>>         }
> >>>>>  }
> >>>>>  EXPORT_SYMBOL(drm_atomic_helper_plane_reset);
> >>>>> diff --git a/drivers/gpu/drm/drm_blend.c b/drivers/gpu/drm/drm_blend.c
> >>>>> index a16a74d..ac6f19c 100644
> >>>>> --- a/drivers/gpu/drm/drm_blend.c
> >>>>> +++ b/drivers/gpu/drm/drm_blend.c
> >>>>> @@ -107,6 +107,52 @@
> >>>>>   *     planes. Without this property the primary plane is always below the cursor
> >>>>>   *     plane, and ordering between all other planes is undefined.
> >>>>>   *
> >>>>> + * pixel blend mode:
> >>>>> + *     Pixel blend mode is set up with drm_plane_create_blend_mode_property().
> >>>>> + *     It adds a blend mode for alpha blending equation selection, describing
> >>>>> + *     how the pixels from the current plane are composited with the
> >>>>> + *     background.
> >>>>> + *
> >>>>> + *      Three alpha blending equations are defined:
> >>>>> + *
> >>>>> + *      "None":
> >>>>> + *              Blend formula that ignores the pixel alpha::
> >>>>> + *
> >>>>> + *                      out.rgb = plane_alpha * fg.rgb +
> >>>>> + *                              (1 - plane_alpha) * bg.rgb
> >>>>> + *
> >>>>> + *      "Pre-multiplied":
> >>>>> + *              Blend formula that assumes the pixel color values
> >>>>> + *              have been already pre-multiplied with the alpha
> >>>>> + *              channel values::
> >>>>> + *
> >>>>> + *                      out.rgb = plane_alpha * fg.rgb +
> >>>>> + *                              (1 - (plane_alpha * fg.alpha)) * bg.rgb
> >>>>> + *
> >>>>> + *      "Coverage":
> >>>>> + *              Blend formula that assumes the pixel color values have not
> >>>>> + *              been pre-multiplied and will do so when blending them to the
> >>>>> + *              background color values::
> >>>>> + *
> >>>>> + *                      out.rgb = plane_alpha * fg.alpha * fg.rgb +
> >>>>> + *                              (1 - (plane_alpha * fg.alpha)) * bg.rgb
> >>>>> + *
> >>>>> + *      Using the following symbols:
> >>>>> + *
> >>>>> + *      ``fg.rgb``:
> >>>>> + *              Each of the RGB component values from the plane's pixel
> >>>>> + *      ``fg.alpha``:
> >>>>> + *              Alpha component value from the plane's pixel. If the plane's
> >>>>> + *              pixel format has no alpha component, then this is assumed to be
> >>>>> + *              1.0. In these cases, this property has no effect, as all three
> >>>>> + *              equations become equivalent.
> >>>>> + *      ``bg.rgb``:
> >>>>> + *              Each of the RGB component values from the background
> >>>>> + *      ``plane_alpha``:
> >>>>> + *              Plane alpha value set by the plane "alpha" property. If the
> >>>>> + *              plane does not expose the "alpha" property, then this is
> >>>>> + *              assumed to be 1.0
> >>>>> + *
> >>>>>   * Note that all the property extensions described here apply either to the
> >>>>>   * plane or the CRTC (e.g. for the background color, which currently is not
> >>>>>   * exposed and assumed to be black).
> >>>>> @@ -448,3 +494,83 @@ int drm_atomic_normalize_zpos(struct drm_device *dev,
> >>>>>         return 0;
> >>>>>  }
> >>>>>  EXPORT_SYMBOL(drm_atomic_normalize_zpos);
> >>>>> +
> >>>>> +/**
> >>>>> + * drm_plane_create_blend_mode_property - create a new blend mode property
> >>>>> + * @plane: drm plane
> >>>>> + * @supported_modes: bitmask of supported modes, must include
> >>>>> + *                  BIT(DRM_MODE_BLEND_PREMULTI). Current DRM assumption is
> >>>>> + *                  that alpha is premultiplied, and old userspace can break if
> >>>>> + *                  the property defaults to coverage.
> >>>>> + *
> >>>> Thanks for the explanation Lowry.
> >>>> Sigh, old userspace :-\
> >>>>
> >>>> One pedantic suggestion s/defaults to coverage/defaults to anything else/
> >>>> Since defaulting to "none" or any future blend mode is also a no-go.
> >>>>
> >>>> I wouldn't bother resending solely for ^^. Perhaps squash locally
> >>>> before merging?
> >>>>
> >>>> With that, the patch is
> >>>> Reviewed-by: Emil Velikov <emil.velikov@collabora.com>
> >>>>
> >>>> -Emil
> >>> Hi Emil,
> >>>
> >>> Thanks a lot for your review and will change that.
> >> Ping? Any updates?
> >>
> >> ~Maarten
> > Hi Maarten,
> >
> > So far the merge request on user space patch has been verified by John
> > Stultz. The comments from Sean has been fixed and now we are waiting the
> > reviewed-tag from Sean. Once it merged, we'll send a new kernel patch to
> > review.
> >
> Hey,
> 
> In general the kernel patch should be merged first, because userspace cannot rely on the behavior until the next -rc1 that integrates it.
> However, in order to merge the kernel patch, a userspace proof of concept for validation is needed first. Since you're close to merging,
> I would say the userspace requirement is satisfied. It's safe to send the kernel patch. :)

Quick correction: Generally merged into -next is considered good enough.
-Daniel

> 
> ~Maarten
> 
> _______________________________________________
> dri-devel mailing list
> dri-devel@lists.freedesktop.org
> https://lists.freedesktop.org/mailman/listinfo/dri-devel

-- 
Daniel Vetter
Software Engineer, Intel Corporation
http://blog.ffwll.ch

[PATCH v3 2/2] drm/mali-dp: Implement plane alpha and pixel blend on malidp

[Lowry Li]

1. Check the pixel blending mode and plane alpha value when
do the plane_check. Mali DP supports blending the current plane
with the background either based on the pixel alpha blending
mode or by using the layer's alpha value, but not both at the
same time. If both case, plane_check will return failed.

2. Set the HW when doing plane_update accordingly. If plane alpha
is the 0xffff, set the pixel blending bits accordingly. If not
we'd set ALPHA bit as zero and layer alpha value.

Signed-off-by: Lowry Li <lowry.li@arm.com>
---
 drivers/gpu/drm/arm/malidp_planes.c | 76 +++++++++++++++++++++----------------
 1 file changed, 44 insertions(+), 32 deletions(-)

diff --git a/drivers/gpu/drm/arm/malidp_planes.c b/drivers/gpu/drm/arm/malidp_planes.c
index 7a44897..daa3f4f 100644
--- a/drivers/gpu/drm/arm/malidp_planes.c
+++ b/drivers/gpu/drm/arm/malidp_planes.c
@@ -35,6 +35,7 @@
 #define   LAYER_COMP_MASK		(0x3 << 12)
 #define   LAYER_COMP_PIXEL		(0x3 << 12)
 #define   LAYER_COMP_PLANE		(0x2 << 12)
+#define   LAYER_PMUL_ENABLE		(0x1 << 14)
 #define   LAYER_ALPHA_OFFSET		(16)
 #define   LAYER_ALPHA_MASK		(0xff)
 #define   LAYER_ALPHA(x)		(((x) & LAYER_ALPHA_MASK) << LAYER_ALPHA_OFFSET)
@@ -182,6 +183,7 @@ static int malidp_de_plane_check(struct drm_plane *plane,
 	struct malidp_plane_state *ms = to_malidp_plane_state(state);
 	bool rotated = state->rotation & MALIDP_ROTATED_MASK;
 	struct drm_framebuffer *fb;
+	u16 pixel_alpha = state->pixel_blend_mode;
 	int i, ret;
 
 	if (!state->crtc || !state->fb)
@@ -244,6 +246,11 @@ static int malidp_de_plane_check(struct drm_plane *plane,
 		ms->rotmem_size = val;
 	}
 
+	/* HW can't support plane + pixel blending */
+	if ((state->alpha != DRM_BLEND_ALPHA_OPAQUE) &&
+	    (pixel_alpha != DRM_MODE_BLEND_PIXEL_NONE))
+		return -EINVAL;
+
 	return 0;
 }
 
@@ -325,31 +332,33 @@ static void malidp_de_plane_update(struct drm_plane *plane,
 {
 	struct malidp_plane *mp;
 	struct malidp_plane_state *ms = to_malidp_plane_state(plane->state);
+	struct drm_plane_state *state = plane->state;
+	u16 pixel_alpha = state->pixel_blend_mode;
+	u8 plane_alpha = state->alpha >> 8;
 	u32 src_w, src_h, dest_w, dest_h, val;
 	int i;
-	bool format_has_alpha = plane->state->fb->format->has_alpha;
 
 	mp = to_malidp_plane(plane);
 
 	/* convert src values from Q16 fixed point to integer */
-	src_w = plane->state->src_w >> 16;
-	src_h = plane->state->src_h >> 16;
-	dest_w = plane->state->crtc_w;
-	dest_h = plane->state->crtc_h;
+	src_w = state->src_w >> 16;
+	src_h = state->src_h >> 16;
+	dest_w = state->crtc_w;
+	dest_h = state->crtc_h;
 
 	malidp_hw_write(mp->hwdev, ms->format, mp->layer->base);
 
 	for (i = 0; i < ms->n_planes; i++) {
 		/* calculate the offset for the layer's plane registers */
 		u16 ptr = mp->layer->ptr + (i << 4);
-		dma_addr_t fb_addr = drm_fb_cma_get_gem_addr(plane->state->fb,
-							     plane->state, i);
+		dma_addr_t fb_addr = drm_fb_cma_get_gem_addr(state->fb,
+							     state, i);
 
 		malidp_hw_write(mp->hwdev, lower_32_bits(fb_addr), ptr);
 		malidp_hw_write(mp->hwdev, upper_32_bits(fb_addr), ptr + 4);
 	}
 	malidp_de_set_plane_pitches(mp, ms->n_planes,
-				    plane->state->fb->pitches);
+				    state->fb->pitches);
 
 	if ((plane->state->color_encoding != old_state->color_encoding) ||
 	    (plane->state->color_range != old_state->color_range))
@@ -362,8 +371,8 @@ static void malidp_de_plane_update(struct drm_plane *plane,
 	malidp_hw_write(mp->hwdev, LAYER_H_VAL(dest_w) | LAYER_V_VAL(dest_h),
 			mp->layer->base + MALIDP_LAYER_COMP_SIZE);
 
-	malidp_hw_write(mp->hwdev, LAYER_H_VAL(plane->state->crtc_x) |
-			LAYER_V_VAL(plane->state->crtc_y),
+	malidp_hw_write(mp->hwdev, LAYER_H_VAL(state->crtc_x) |
+			LAYER_V_VAL(state->crtc_y),
 			mp->layer->base + MALIDP_LAYER_OFFSET);
 
 	if (mp->layer->id == DE_SMART)
@@ -376,38 +385,35 @@ static void malidp_de_plane_update(struct drm_plane *plane,
 	val &= ~LAYER_ROT_MASK;
 
 	/* setup the rotation and axis flip bits */
-	if (plane->state->rotation & DRM_MODE_ROTATE_MASK)
+	if (state->rotation & DRM_MODE_ROTATE_MASK)
 		val |= ilog2(plane->state->rotation & DRM_MODE_ROTATE_MASK) <<
 		       LAYER_ROT_OFFSET;
-	if (plane->state->rotation & DRM_MODE_REFLECT_X)
+	if (state->rotation & DRM_MODE_REFLECT_X)
 		val |= LAYER_H_FLIP;
-	if (plane->state->rotation & DRM_MODE_REFLECT_Y)
+	if (state->rotation & DRM_MODE_REFLECT_Y)
 		val |= LAYER_V_FLIP;
 
-	val &= ~LAYER_COMP_MASK;
-	if (format_has_alpha) {
-
-		/*
-		 * always enable pixel alpha blending until we have a way
-		 * to change blend modes
-		 */
-		val |= LAYER_COMP_PIXEL;
-	} else {
-
-		/*
-		 * do not enable pixel alpha blending as the color channel
-		 * does not have any alpha information
-		 */
-		val |= LAYER_COMP_PLANE;
-
-		/* Set layer alpha coefficient to 0xff ie fully opaque */
+	val &= ~(LAYER_COMP_MASK | LAYER_PMUL_ENABLE);
+
+	if (state->alpha != DRM_BLEND_ALPHA_OPAQUE) {
+		val |= LAYER_COMP_PLANE | LAYER_ALPHA(plane_alpha);
+	} else if (state->fb->format->has_alpha) {
+		/* We only care about blend mode if the format has alpha */
+		switch (pixel_alpha) {
+		case DRM_MODE_BLEND_PREMULTI:
+			val |= LAYER_COMP_PIXEL | LAYER_PMUL_ENABLE;
+			break;
+		case DRM_MODE_BLEND_COVERAGE:
+			val |= LAYER_COMP_PIXEL;
+			break;
+		}
 		val |= LAYER_ALPHA(0xff);
 	}
 
 	val &= ~LAYER_FLOWCFG(LAYER_FLOWCFG_MASK);
-	if (plane->state->crtc) {
+	if (state->crtc) {
 		struct malidp_crtc_state *m =
-			to_malidp_crtc_state(plane->state->crtc->state);
+			to_malidp_crtc_state(state->crtc->state);
 
 		if (m->scaler_config.scale_enable &&
 		    m->scaler_config.plane_src_id == mp->layer->id)
@@ -446,6 +452,9 @@ int malidp_de_planes_init(struct drm_device *drm)
 	unsigned long crtcs = 1 << drm->mode_config.num_crtc;
 	unsigned long flags = DRM_MODE_ROTATE_0 | DRM_MODE_ROTATE_90 | DRM_MODE_ROTATE_180 |
 			      DRM_MODE_ROTATE_270 | DRM_MODE_REFLECT_X | DRM_MODE_REFLECT_Y;
+	unsigned int blend_caps = BIT(DRM_MODE_BLEND_PIXEL_NONE) |
+				  BIT(DRM_MODE_BLEND_PREMULTI)   |
+				  BIT(DRM_MODE_BLEND_COVERAGE);
 	u32 *formats;
 	int ret, i, j, n;
 
@@ -498,6 +507,9 @@ int malidp_de_planes_init(struct drm_device *drm)
 		malidp_hw_write(malidp->dev, MALIDP_ALPHA_LUT,
 				plane->layer->base + MALIDP_LAYER_COMPOSE);
 
+		drm_plane_create_alpha_property(&plane->base);
+		drm_plane_create_blend_mode_property(&plane->base, blend_caps);
+
 		/* Attach the YUV->RGB property only to video layers */
 		if (id & (DE_VIDEO1 | DE_VIDEO2)) {
 			/* default encoding for YUV->RGB is BT601 NARROW */
-- 
1.9.1