[RFC 0/3] drm/omap: Add virtual wide planes support

[RFC 0/3] drm/omap: Add virtual wide planes support

[Benoit Parrot]

This patch series adds virtual wide plane support to omapdrm driver to
allow the use of display wider than 2048 pixels. This is achieve by
adding replacing the static omapdrm plane to hardware overlay static
mapping with a dynamic allocation method.

This replaces an original early series which the introduction of new DT
sub nodes. Since this solution is pretty different for the first few
iterations I decide to send as an RFC.

This implementation is inspired from the work done in msm/disp/mdp5
driver.

There is one issue that I did face while using the ww mutex for which I
would like reviewer to pay attention and comment on. You can find my
questions just before the omap_overlay_disable_unassigned() function in
drivers/gpu/drm/omapdrm/omap_overlay.c.


Benoit Parrot (3):
  drm/omap: Add ability to check if requested plane modes can be
    supported
  drm/omap: Add ovl checking funcs to dispc_ops
  drm/omap: Add wide display support using multiple overlays

 drivers/gpu/drm/omapdrm/Makefile       |   1 +
 drivers/gpu/drm/omapdrm/dss/dispc.c    |  37 ++++
 drivers/gpu/drm/omapdrm/dss/omapdss.h  |   6 +
 drivers/gpu/drm/omapdrm/omap_drv.c     | 119 ++++++++++-
 drivers/gpu/drm/omapdrm/omap_drv.h     |  15 +-
 drivers/gpu/drm/omapdrm/omap_fb.c      |  33 ++-
 drivers/gpu/drm/omapdrm/omap_fb.h      |   4 +-
 drivers/gpu/drm/omapdrm/omap_overlay.c | 366 +++++++++++++++++++++++++++++++++
 drivers/gpu/drm/omapdrm/omap_overlay.h |  80 +++++++
 drivers/gpu/drm/omapdrm/omap_plane.c   | 322 ++++++++++++++++++++++++-----
 drivers/gpu/drm/omapdrm/omap_plane.h   |  20 ++
 11 files changed, 935 insertions(+), 68 deletions(-)
 create mode 100644 drivers/gpu/drm/omapdrm/omap_overlay.c
 create mode 100644 drivers/gpu/drm/omapdrm/omap_overlay.h

-- 
2.9.0

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

[RFC 1/3] drm/omap: Add ability to check if requested plane modes can be supported

[Benoit Parrot]

We currently assumed that an overlay has the same width and height as
the overlay manager. This assumption is incorrect. On some variant the
overlay manager is twice the width that the overlay can handle. We need
to add the appropriate data per variant as well as export a helper
function to retrieve the data so check can be made dynamically. We
currently add such a check in the dispc_ovl_setup() which will return an
error along with a WARN in case the required width exceed the overlay's
ability.

Signed-off-by: Benoit Parrot <bparrot@ti.com>
---
 drivers/gpu/drm/omapdrm/dss/dispc.c   | 29 +++++++++++++++++++++++++++++
 drivers/gpu/drm/omapdrm/dss/omapdss.h |  2 ++
 2 files changed, 31 insertions(+)

diff --git a/drivers/gpu/drm/omapdrm/dss/dispc.c b/drivers/gpu/drm/omapdrm/dss/dispc.c
index cfdcc3681494..1b7a6ef7897f 100644
--- a/drivers/gpu/drm/omapdrm/dss/dispc.c
+++ b/drivers/gpu/drm/omapdrm/dss/dispc.c
@@ -103,6 +103,8 @@ struct dispc_features {
 	u8 mgr_height_start;
 	u16 mgr_width_max;
 	u16 mgr_height_max;
+	u16 ovl_width_max;
+	u16 ovl_height_max;
 	unsigned long max_lcd_pclk;
 	unsigned long max_tv_pclk;
 	unsigned int max_downscale;
@@ -2605,6 +2607,13 @@ static int dispc_ovl_calc_scaling(struct dispc_device *dispc,
 	return 0;
 }
 
+static void dispc_ovl_get_max_size(struct dispc_device *dispc,
+				   u16 *width, u16 *height)
+{
+	*width = dispc->feat->ovl_width_max;
+	*height = dispc->feat->ovl_height_max;
+}
+
 static int dispc_ovl_setup_common(struct dispc_device *dispc,
 				  enum omap_plane_id plane,
 				  enum omap_overlay_caps caps,
@@ -2648,6 +2657,11 @@ static int dispc_ovl_setup_common(struct dispc_device *dispc,
 	out_width = out_width == 0 ? width : out_width;
 	out_height = out_height == 0 ? height : out_height;
 
+	if (WARN(out_width > dispc->feat->ovl_width_max,
+		 "Requested OVL width (%d) is larger than can be supported (%d).\n",
+		 out_width, dispc->feat->ovl_width_max))
+		return -EINVAL;
+
 	if (plane != OMAP_DSS_WB) {
 		if (ilace && height == out_height)
 			fieldmode = true;
@@ -4262,6 +4276,8 @@ static const struct dispc_features omap24xx_dispc_feats = {
 	.mgr_height_start	=	26,
 	.mgr_width_max		=	2048,
 	.mgr_height_max		=	2048,
+	.ovl_width_max		=	2048,
+	.ovl_height_max		=	2048,
 	.max_lcd_pclk		=	66500000,
 	.max_downscale		=	2,
 	/*
@@ -4299,6 +4315,8 @@ static const struct dispc_features omap34xx_rev1_0_dispc_feats = {
 	.mgr_height_start	=	26,
 	.mgr_width_max		=	2048,
 	.mgr_height_max		=	2048,
+	.ovl_width_max		=	2048,
+	.ovl_height_max		=	2048,
 	.max_lcd_pclk		=	173000000,
 	.max_tv_pclk		=	59000000,
 	.max_downscale		=	4,
@@ -4333,6 +4351,8 @@ static const struct dispc_features omap34xx_rev3_0_dispc_feats = {
 	.mgr_height_start	=	26,
 	.mgr_width_max		=	2048,
 	.mgr_height_max		=	2048,
+	.ovl_width_max		=	2048,
+	.ovl_height_max		=	2048,
 	.max_lcd_pclk		=	173000000,
 	.max_tv_pclk		=	59000000,
 	.max_downscale		=	4,
@@ -4367,6 +4387,8 @@ static const struct dispc_features omap36xx_dispc_feats = {
 	.mgr_height_start	=	26,
 	.mgr_width_max		=	2048,
 	.mgr_height_max		=	2048,
+	.ovl_width_max		=	2048,
+	.ovl_height_max		=	2048,
 	.max_lcd_pclk		=	173000000,
 	.max_tv_pclk		=	59000000,
 	.max_downscale		=	4,
@@ -4401,6 +4423,8 @@ static const struct dispc_features am43xx_dispc_feats = {
 	.mgr_height_start	=	26,
 	.mgr_width_max		=	2048,
 	.mgr_height_max		=	2048,
+	.ovl_width_max		=	2048,
+	.ovl_height_max		=	2048,
 	.max_lcd_pclk		=	173000000,
 	.max_tv_pclk		=	59000000,
 	.max_downscale		=	4,
@@ -4435,6 +4459,8 @@ static const struct dispc_features omap44xx_dispc_feats = {
 	.mgr_height_start	=	26,
 	.mgr_width_max		=	2048,
 	.mgr_height_max		=	2048,
+	.ovl_width_max		=	2048,
+	.ovl_height_max		=	2048,
 	.max_lcd_pclk		=	170000000,
 	.max_tv_pclk		=	185625000,
 	.max_downscale		=	4,
@@ -4474,6 +4500,8 @@ static const struct dispc_features omap54xx_dispc_feats = {
 	.mgr_height_start	=	27,
 	.mgr_width_max		=	4096,
 	.mgr_height_max		=	4096,
+	.ovl_width_max		=	2048,
+	.ovl_height_max		=	4096,
 	.max_lcd_pclk		=	170000000,
 	.max_tv_pclk		=	186000000,
 	.max_downscale		=	4,
@@ -4749,6 +4777,7 @@ static const struct dispc_ops dispc_ops = {
 	.ovl_enable = dispc_ovl_enable,
 	.ovl_setup = dispc_ovl_setup,
 	.ovl_get_color_modes = dispc_ovl_get_color_modes,
+	.ovl_get_max_size = dispc_ovl_get_max_size,
 
 	.wb_get_framedone_irq = dispc_wb_get_framedone_irq,
 	.wb_setup = dispc_wb_setup,
diff --git a/drivers/gpu/drm/omapdrm/dss/omapdss.h b/drivers/gpu/drm/omapdrm/dss/omapdss.h
index 14d74adb13fb..3f264759eecb 100644
--- a/drivers/gpu/drm/omapdrm/dss/omapdss.h
+++ b/drivers/gpu/drm/omapdrm/dss/omapdss.h
@@ -743,6 +743,8 @@ struct dispc_ops {
 
 	const u32 *(*ovl_get_color_modes)(struct dispc_device *dispc,
 					  enum omap_plane_id plane);
+	void (*ovl_get_max_size)(struct dispc_device *dispc,
+				 u16 *width, u16 *height);
 
 	u32 (*wb_get_framedone_irq)(struct dispc_device *dispc);
 	int (*wb_setup)(struct dispc_device *dispc,
-- 
2.9.0

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

Re: [RFC 1/3] drm/omap: Add ability to check if requested plane modes can be supported

[Tomi Valkeinen]

Hi,

On 29/06/18 20:02, Benoit Parrot wrote:
> We currently assumed that an overlay has the same width and height as

same _maximum_.

> the overlay manager. This assumption is incorrect. On some variant the
> overlay manager is twice the width that the overlay can handle. We need

The maximum width supported is twice the max width that an overlay can
handle.

> to add the appropriate data per variant as well as export a helper
> function to retrieve the data so check can be made dynamically. We
> currently add such a check in the dispc_ovl_setup() which will return an
> error along with a WARN in case the required width exceed the overlay's
> ability.
> 
> Signed-off-by: Benoit Parrot <bparrot@ti.com>
> ---
>  drivers/gpu/drm/omapdrm/dss/dispc.c   | 29 +++++++++++++++++++++++++++++
>  drivers/gpu/drm/omapdrm/dss/omapdss.h |  2 ++
>  2 files changed, 31 insertions(+)
> 
> diff --git a/drivers/gpu/drm/omapdrm/dss/dispc.c b/drivers/gpu/drm/omapdrm/dss/dispc.c
> index cfdcc3681494..1b7a6ef7897f 100644
> --- a/drivers/gpu/drm/omapdrm/dss/dispc.c
> +++ b/drivers/gpu/drm/omapdrm/dss/dispc.c
> @@ -103,6 +103,8 @@ struct dispc_features {
>  	u8 mgr_height_start;
>  	u16 mgr_width_max;
>  	u16 mgr_height_max;
> +	u16 ovl_width_max;
> +	u16 ovl_height_max;
>  	unsigned long max_lcd_pclk;
>  	unsigned long max_tv_pclk;
>  	unsigned int max_downscale;
> @@ -2605,6 +2607,13 @@ static int dispc_ovl_calc_scaling(struct dispc_device *dispc,
>  	return 0;
>  }
>  
> +static void dispc_ovl_get_max_size(struct dispc_device *dispc,
> +				   u16 *width, u16 *height)
> +{
> +	*width = dispc->feat->ovl_width_max;
> +	*height = dispc->feat->ovl_height_max;
> +}
> +
>  static int dispc_ovl_setup_common(struct dispc_device *dispc,
>  				  enum omap_plane_id plane,
>  				  enum omap_overlay_caps caps,
> @@ -2648,6 +2657,11 @@ static int dispc_ovl_setup_common(struct dispc_device *dispc,
>  	out_width = out_width == 0 ? width : out_width;
>  	out_height = out_height == 0 ? height : out_height;
>  
> +	if (WARN(out_width > dispc->feat->ovl_width_max,
> +		 "Requested OVL width (%d) is larger than can be supported (%d).\n",
> +		 out_width, dispc->feat->ovl_width_max))
> +		return -EINVAL;

We should do this check in the omap_plane_atomic_check().

 Tomi

-- 
Texas Instruments Finland Oy, Porkkalankatu 22, 00180 Helsinki.
Y-tunnus/Business ID: 0615521-4. Kotipaikka/Domicile: Helsinki
_______________________________________________
dri-devel mailing list
dri-devel@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/dri-devel

[RFC 2/3] drm/omap: Add ovl checking funcs to dispc_ops

[Benoit Parrot]

In order to be able to dynamically assign overlays to planes we need to
be able to asses the overlay capabilities.

Add a helper function to be able to retrieve the supported capabilities
of an overlay.

And export the function to check if a fourcc is supported on a given
overlay.

Signed-off-by: Benoit Parrot <bparrot@ti.com>
---
 drivers/gpu/drm/omapdrm/dss/dispc.c   | 8 ++++++++
 drivers/gpu/drm/omapdrm/dss/omapdss.h | 4 ++++
 2 files changed, 12 insertions(+)

diff --git a/drivers/gpu/drm/omapdrm/dss/dispc.c b/drivers/gpu/drm/omapdrm/dss/dispc.c
index 1b7a6ef7897f..80ac1e68a036 100644
--- a/drivers/gpu/drm/omapdrm/dss/dispc.c
+++ b/drivers/gpu/drm/omapdrm/dss/dispc.c
@@ -2508,6 +2508,12 @@ static int dispc_ovl_calc_scaling_44xx(struct dispc_device *dispc,
 	return 0;
 }
 
+static enum omap_overlay_caps dispc_ovl_get_caps(struct dispc_device *dispc,
+						 enum omap_plane_id plane)
+{
+	return dispc->feat->overlay_caps[plane];
+}
+
 #define DIV_FRAC(dividend, divisor) \
 	((dividend) * 100 / (divisor) - ((dividend) / (divisor) * 100))
 
@@ -4777,6 +4783,8 @@ static const struct dispc_ops dispc_ops = {
 	.ovl_enable = dispc_ovl_enable,
 	.ovl_setup = dispc_ovl_setup,
 	.ovl_get_color_modes = dispc_ovl_get_color_modes,
+	.ovl_color_mode_supported = dispc_ovl_color_mode_supported,
+	.ovl_get_caps = dispc_ovl_get_caps,
 	.ovl_get_max_size = dispc_ovl_get_max_size,
 
 	.wb_get_framedone_irq = dispc_wb_get_framedone_irq,
diff --git a/drivers/gpu/drm/omapdrm/dss/omapdss.h b/drivers/gpu/drm/omapdrm/dss/omapdss.h
index 3f264759eecb..01fbd674a021 100644
--- a/drivers/gpu/drm/omapdrm/dss/omapdss.h
+++ b/drivers/gpu/drm/omapdrm/dss/omapdss.h
@@ -743,6 +743,10 @@ struct dispc_ops {
 
 	const u32 *(*ovl_get_color_modes)(struct dispc_device *dispc,
 					  enum omap_plane_id plane);
+	bool (*ovl_color_mode_supported)(struct dispc_device *dispc,
+					 enum omap_plane_id plane, u32 fourcc);
+	enum omap_overlay_caps (*ovl_get_caps)(struct dispc_device *dispc,
+					       enum omap_plane_id plane);
 	void (*ovl_get_max_size)(struct dispc_device *dispc,
 				 u16 *width, u16 *height);
 
-- 
2.9.0

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

[RFC 3/3] drm/omap: Add wide display support using multiple overlays

[Benoit Parrot]

In the case where we need to support wide-display using more than one
overlay to achieve the needed display resolution, we need to be able to
dynamically assign overlays to planes instead of having the overlays
being statically mapped to planes.

This also means that on occasion where the number of requested planes
exceeds the numbers of overlays required to display them then a failure
would be returned for the plane that cannot be handled at that time. It
is up to user space to make sure the H/W resource are not
over-subscribed.

Signed-off-by: Benoit Parrot <bparrot@ti.com>
---
 drivers/gpu/drm/omapdrm/Makefile       |   1 +
 drivers/gpu/drm/omapdrm/omap_drv.c     | 119 ++++++++++-
 drivers/gpu/drm/omapdrm/omap_drv.h     |  15 +-
 drivers/gpu/drm/omapdrm/omap_fb.c      |  33 ++-
 drivers/gpu/drm/omapdrm/omap_fb.h      |   4 +-
 drivers/gpu/drm/omapdrm/omap_overlay.c | 366 +++++++++++++++++++++++++++++++++
 drivers/gpu/drm/omapdrm/omap_overlay.h |  80 +++++++
 drivers/gpu/drm/omapdrm/omap_plane.c   | 322 ++++++++++++++++++++++++-----
 drivers/gpu/drm/omapdrm/omap_plane.h   |  20 ++
 9 files changed, 892 insertions(+), 68 deletions(-)
 create mode 100644 drivers/gpu/drm/omapdrm/omap_overlay.c
 create mode 100644 drivers/gpu/drm/omapdrm/omap_overlay.h

diff --git a/drivers/gpu/drm/omapdrm/Makefile b/drivers/gpu/drm/omapdrm/Makefile
index f115253115c5..800dfd035360 100644
--- a/drivers/gpu/drm/omapdrm/Makefile
+++ b/drivers/gpu/drm/omapdrm/Makefile
@@ -12,6 +12,7 @@ omapdrm-y := omap_drv.o \
 	omap_debugfs.o \
 	omap_crtc.o \
 	omap_plane.o \
+	omap_overlay.o \
 	omap_encoder.o \
 	omap_connector.o \
 	omap_fb.o \
diff --git a/drivers/gpu/drm/omapdrm/omap_drv.c b/drivers/gpu/drm/omapdrm/omap_drv.c
index ef3b0e3571ec..f0a5c3dab471 100644
--- a/drivers/gpu/drm/omapdrm/omap_drv.c
+++ b/drivers/gpu/drm/omapdrm/omap_drv.c
@@ -16,11 +16,7 @@
  */
 
 #include <linux/sys_soc.h>
-
-#include <drm/drm_atomic.h>
-#include <drm/drm_atomic_helper.h>
-#include <drm/drm_crtc_helper.h>
-#include <drm/drm_fb_helper.h>
+#include <linux/sort.h>
 
 #include "omap_dmm_tiler.h"
 #include "omap_drv.h"
@@ -113,9 +109,100 @@ static void omap_atomic_commit_tail(struct drm_atomic_state *old_state)
 
 	drm_atomic_helper_cleanup_planes(dev, old_state);
 
+	omap_overlay_disable_unassigned(old_state);
+
 	priv->dispc_ops->runtime_put(priv->dispc);
 }
 
+static int drm_atomic_state_normalized_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->normalized_zpos != sb->normalized_zpos)
+		return sa->normalized_zpos - sb->normalized_zpos;
+	else
+		return sa->plane->base.id - sb->plane->base.id;
+}
+
+static int omap_atomic_update_normalize_zpos(struct drm_device *dev,
+					     struct drm_atomic_state *state)
+{
+	struct drm_crtc *crtc;
+	struct drm_crtc_state *old_state, *new_state;
+	struct drm_plane *plane;
+	int i, n, inc;
+	int total_planes = dev->mode_config.num_total_plane;
+	struct drm_plane_state **states;
+	int ret = 0;
+
+	states = kmalloc_array(total_planes, sizeof(*states), GFP_KERNEL);
+	if (!states)
+		return -ENOMEM;
+
+	for_each_oldnew_crtc_in_state(state, crtc, old_state, new_state, i) {
+		if (old_state->plane_mask == new_state->plane_mask &&
+		    !new_state->zpos_changed)
+			continue;
+
+		/* Reset plane increment and index value for every crtc */
+		n = 0;
+
+		/*
+		 * Normalization process might create new states for planes
+		 * which normalized_zpos has to be recalculated.
+		 */
+		drm_for_each_plane_mask(plane, dev, new_state->plane_mask) {
+			struct drm_plane_state *plane_state =
+				drm_atomic_get_plane_state(new_state->state,
+							   plane);
+			if (IS_ERR(plane_state)) {
+				ret = PTR_ERR(plane_state);
+				goto done;
+			}
+			states[n++] = plane_state;
+		}
+
+		sort(states, n, sizeof(*states),
+		     drm_atomic_state_normalized_zpos_cmp, NULL);
+
+		for (i = 0, inc = 0; i < n; i++) {
+			plane = states[i]->plane;
+
+			states[i]->normalized_zpos = i + inc;
+			DRM_DEBUG_ATOMIC("[PLANE:%d:%s] updated normalized zpos value %d\n",
+					 plane->base.id, plane->name,
+					 states[i]->normalized_zpos);
+
+			if (is_omap_plane_dual_overlay(states[i]))
+				inc++;
+		}
+		new_state->zpos_changed = true;
+	}
+
+done:
+	kfree(states);
+	return ret;
+}
+
+static int omap_atomic_check(struct drm_device *dev,
+			     struct drm_atomic_state *state)
+{
+	int ret;
+
+	ret = drm_atomic_helper_check(dev, state);
+	if (ret)
+		return ret;
+
+	if (dev->mode_config.normalize_zpos) {
+		ret = omap_atomic_update_normalize_zpos(dev, state);
+		if (ret)
+			return ret;
+	}
+
+	return 0;
+}
+
 static const struct drm_mode_config_helper_funcs omap_mode_config_helper_funcs = {
 	.atomic_commit_tail = omap_atomic_commit_tail,
 };
@@ -123,7 +210,7 @@ static const struct drm_mode_config_helper_funcs omap_mode_config_helper_funcs =
 static const struct drm_mode_config_funcs omap_mode_config_funcs = {
 	.fb_create = omap_framebuffer_create,
 	.output_poll_changed = drm_fb_helper_output_poll_changed,
-	.atomic_check = drm_atomic_helper_check,
+	.atomic_check = omap_atomic_check,
 	.atomic_commit = drm_atomic_helper_commit,
 };
 
@@ -296,7 +383,7 @@ static int omap_modeset_init(struct drm_device *dev)
 			return -EINVAL;
 
 		plane = omap_plane_init(dev, plane_idx, DRM_PLANE_TYPE_OVERLAY,
-			plane_crtc_mask);
+					plane_crtc_mask);
 		if (IS_ERR(plane))
 			return PTR_ERR(plane);
 
@@ -560,10 +647,18 @@ static int omapdrm_init(struct omap_drm_private *priv, struct device *dev)
 
 	omap_gem_init(ddev);
 
+	ret = omap_global_obj_init(priv);
+	if (ret)
+		goto err_free_drm_dev;
+
+	ret = omap_hwoverlays_init(priv);
+	if (ret)
+		goto err_free_priv_obj;
+
 	ret = omap_modeset_init(ddev);
 	if (ret) {
 		dev_err(priv->dev, "omap_modeset_init failed: ret=%d\n", ret);
-		goto err_free_drm_dev;
+		goto err_free_overlays;
 	}
 
 	/* Initialize vblank handling, start with all CRTCs disabled. */
@@ -577,7 +672,6 @@ static int omapdrm_init(struct omap_drm_private *priv, struct device *dev)
 		drm_crtc_vblank_off(priv->crtcs[i]);
 
 	omap_fbdev_init(ddev);
-
 	drm_kms_helper_poll_init(ddev);
 	omap_modeset_enable_external_hpd();
 
@@ -599,6 +693,10 @@ static int omapdrm_init(struct omap_drm_private *priv, struct device *dev)
 err_cleanup_modeset:
 	drm_mode_config_cleanup(ddev);
 	omap_drm_irq_uninstall(ddev);
+err_free_overlays:
+	omap_hwoverlays_destroy(priv);
+err_free_priv_obj:
+	omap_global_obj_fini(priv);
 err_free_drm_dev:
 	omap_gem_deinit(ddev);
 	drm_dev_unref(ddev);
@@ -632,6 +730,9 @@ static void omapdrm_cleanup(struct omap_drm_private *priv)
 
 	drm_dev_unref(ddev);
 
+	omap_hwoverlays_destroy(priv);
+	omap_global_obj_fini(priv);
+
 	destroy_workqueue(priv->wq);
 
 	omap_disconnect_dssdevs();
diff --git a/drivers/gpu/drm/omapdrm/omap_drv.h b/drivers/gpu/drm/omapdrm/omap_drv.h
index 6eaee4df4559..eb71ea8decee 100644
--- a/drivers/gpu/drm/omapdrm/omap_drv.h
+++ b/drivers/gpu/drm/omapdrm/omap_drv.h
@@ -23,7 +23,10 @@
 #include <linux/workqueue.h>
 
 #include <drm/drmP.h>
+#include <drm/drm_atomic.h>
+#include <drm/drm_atomic_helper.h>
 #include <drm/drm_crtc_helper.h>
+#include <drm/drm_fb_helper.h>
 #include <drm/drm_gem.h>
 #include <drm/omap_drm.h>
 
@@ -37,6 +40,7 @@
 #include "omap_gem.h"
 #include "omap_irq.h"
 #include "omap_plane.h"
+#include "omap_overlay.h"
 
 #define DBG(fmt, ...) DRM_DEBUG(fmt"\n", ##__VA_ARGS__)
 #define VERB(fmt, ...) if (0) DRM_DEBUG(fmt, ##__VA_ARGS__) /* verbose debug */
@@ -66,6 +70,16 @@ struct omap_drm_private {
 	unsigned int num_connectors;
 	struct drm_connector *connectors[8];
 
+	unsigned int num_ovls;
+	struct omap_hw_overlay *overlays[8];
+
+        /*
+         * Global private object state, Do not access directly, use
+         * omap_global_get_state()
+         */
+        struct drm_modeset_lock glob_state_lock;
+        struct drm_private_obj glob_state;
+
 	struct drm_fb_helper *fbdev;
 
 	struct workqueue_struct *wq;
@@ -91,7 +105,6 @@ struct omap_drm_private {
 	unsigned int max_bandwidth;
 };
 
-
 int omap_debugfs_init(struct drm_minor *minor);
 
 #endif /* __OMAPDRM_DRV_H__ */
diff --git a/drivers/gpu/drm/omapdrm/omap_fb.c b/drivers/gpu/drm/omapdrm/omap_fb.c
index 5fd22ca73913..b9573c163117 100644
--- a/drivers/gpu/drm/omapdrm/omap_fb.c
+++ b/drivers/gpu/drm/omapdrm/omap_fb.c
@@ -153,7 +153,9 @@ static u32 drm_rotation_to_tiler(unsigned int drm_rot)
 /* update ovl info for scanout, handles cases of multi-planar fb's, etc.
  */
 void omap_framebuffer_update_scanout(struct drm_framebuffer *fb,
-		struct drm_plane_state *state, struct omap_overlay_info *info)
+		struct drm_plane_state *state,
+		struct omap_overlay_info *info,
+		struct omap_overlay_info *r_info)
 {
 	struct omap_framebuffer *omap_fb = to_omap_framebuffer(fb);
 	const struct drm_format_info *format = omap_fb->format;
@@ -206,7 +208,8 @@ void omap_framebuffer_update_scanout(struct drm_framebuffer *fb,
 		info->rotation_type = OMAP_DSS_ROT_TILER;
 		info->rotation = state->rotation ?: DRM_MODE_ROTATE_0;
 		/* Note: stride in TILER units, not pixels */
-		info->screen_width  = omap_gem_tiled_stride(plane->bo, orient);
+		info->screen_width  =
+				omap_gem_tiled_stride(plane->bo, orient);
 	} else {
 		switch (state->rotation & DRM_MODE_ROTATE_MASK) {
 		case 0:
@@ -221,10 +224,10 @@ void omap_framebuffer_update_scanout(struct drm_framebuffer *fb,
 			break;
 		}
 
-		info->paddr         = get_linear_addr(plane, format, 0, x, y);
+		info->paddr = get_linear_addr(plane, format, 0, x, y);
 		info->rotation_type = OMAP_DSS_ROT_NONE;
-		info->rotation      = DRM_MODE_ROTATE_0;
-		info->screen_width  = plane->pitch;
+		info->rotation = DRM_MODE_ROTATE_0;
+		info->screen_width = plane->pitch;
 	}
 
 	/* convert to pixels: */
@@ -238,11 +241,29 @@ void omap_framebuffer_update_scanout(struct drm_framebuffer *fb,
 			omap_gem_rotated_dma_addr(plane->bo, orient, x/2, y/2,
 						  &info->p_uv_addr);
 		} else {
-			info->p_uv_addr = get_linear_addr(plane, format, 1, x, y);
+			info->p_uv_addr =
+				get_linear_addr(plane, format, 1, x, y);
 		}
 	} else {
 		info->p_uv_addr = 0;
 	}
+
+	if (r_info) {
+		info->width /= 2;
+		info->out_width /= 2;
+
+		*r_info = *info;
+
+		r_info->pos_x = info->pos_x + info->out_width;
+
+		r_info->paddr =	get_linear_addr(&omap_fb->planes[0], format, 0,
+						x + info->width, y);
+		if (fb->format->format == DRM_FORMAT_NV12) {
+			r_info->p_uv_addr =
+				get_linear_addr(&omap_fb->planes[1], format, 1,
+						x + info->width, y);
+		}
+	}
 }
 
 /* pin, prepare for scanout: */
diff --git a/drivers/gpu/drm/omapdrm/omap_fb.h b/drivers/gpu/drm/omapdrm/omap_fb.h
index 94ad5f9e4404..8c116c1aac0d 100644
--- a/drivers/gpu/drm/omapdrm/omap_fb.h
+++ b/drivers/gpu/drm/omapdrm/omap_fb.h
@@ -37,7 +37,9 @@ struct drm_framebuffer *omap_framebuffer_init(struct drm_device *dev,
 int omap_framebuffer_pin(struct drm_framebuffer *fb);
 void omap_framebuffer_unpin(struct drm_framebuffer *fb);
 void omap_framebuffer_update_scanout(struct drm_framebuffer *fb,
-		struct drm_plane_state *state, struct omap_overlay_info *info);
+		struct drm_plane_state *state,
+		struct omap_overlay_info *info,
+		struct omap_overlay_info *r_info);
 struct drm_connector *omap_framebuffer_get_next_connector(
 		struct drm_framebuffer *fb, struct drm_connector *from);
 bool omap_framebuffer_supports_rotation(struct drm_framebuffer *fb);
diff --git a/drivers/gpu/drm/omapdrm/omap_overlay.c b/drivers/gpu/drm/omapdrm/omap_overlay.c
new file mode 100644
index 000000000000..0a1327c31b69
--- /dev/null
+++ b/drivers/gpu/drm/omapdrm/omap_overlay.c
@@ -0,0 +1,366 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) 2018 Texas Instruments Incorporated -  http://www.ti.com/
+ * Author: Benoit Parrot, <bparrot@ti.com>
+ */
+
+#include <drm/drm_atomic.h>
+#include <drm/drm_atomic_helper.h>
+#include <drm/drm_plane_helper.h>
+
+#include "omap_dmm_tiler.h"
+#include "omap_drv.h"
+
+/*
+ * overlay funcs
+ */
+static void __maybe_unused
+omap_overlay_atomic_print_state(struct drm_printer *p,
+				const struct omap_global_state *state,
+				struct omap_drm_private *priv)
+{
+	int i;
+
+	drm_printf(p, "\tomap_global_state=%p\n", state);
+	if (state) {
+		for (i = 0; i < priv->num_ovls; i++) {
+			struct drm_plane *plane =
+				state->overlay.hwoverlay_to_plane[i];
+
+			drm_printf(p, "\t\t[%d] plane=%p\n", i, plane);
+			if (plane)
+				drm_printf(p, "\t\t\t plane=%s\n", plane->name);
+		}
+	}
+}
+
+/* Global/shared object state funcs */
+
+/*
+ * This is a helper that returns the private state currently in operation.
+ * Note that this would return the "old_state" if called in the atomic check
+ * path, and the "new_state" after the atomic swap has been done.
+ */
+static struct omap_global_state *
+omap_get_existing_global_state(struct omap_drm_private *priv)
+{
+	return to_omap_global_state(priv->glob_state.state);
+}
+
+/*
+ * This acquires the modeset lock set aside for global state, creates
+ * a new duplicated private object state.
+ */
+static struct omap_global_state *__must_check
+omap_get_global_state(struct drm_atomic_state *s)
+{
+	struct omap_drm_private *priv = s->dev->dev_private;
+	struct drm_private_state *priv_state;
+	int ret;
+
+	while (1) {
+		ret = drm_modeset_lock(&priv->glob_state_lock, s->acquire_ctx);
+		if (ret != -EDEADLK)
+			break;
+
+		drm_modeset_backoff(s->acquire_ctx);
+	}
+
+	if (ret)
+		return ERR_PTR(ret);
+
+	priv_state = drm_atomic_get_private_obj_state(s, &priv->glob_state);
+	if (IS_ERR(priv_state))
+		return ERR_CAST(priv_state);
+
+	return to_omap_global_state(priv_state);
+}
+
+static struct drm_private_state *
+omap_global_duplicate_state(struct drm_private_obj *obj)
+{
+	struct omap_global_state *state;
+
+	state = kmemdup(obj->state, sizeof(*state), GFP_KERNEL);
+	if (!state)
+		return NULL;
+
+	__drm_atomic_helper_private_obj_duplicate_state(obj, &state->base);
+
+	return &state->base;
+}
+
+static void omap_global_destroy_state(struct drm_private_obj *obj,
+				      struct drm_private_state *state)
+{
+	struct omap_global_state *omap_state = to_omap_global_state(state);
+
+	kfree(omap_state);
+}
+
+static const struct drm_private_state_funcs omap_global_state_funcs = {
+	.atomic_duplicate_state = omap_global_duplicate_state,
+	.atomic_destroy_state = omap_global_destroy_state,
+};
+
+int omap_global_obj_init(struct omap_drm_private *priv)
+{
+	struct omap_global_state *state;
+
+	drm_modeset_lock_init(&priv->glob_state_lock);
+
+	state = kzalloc(sizeof(*state), GFP_KERNEL);
+	if (!state)
+		return -ENOMEM;
+
+	drm_atomic_private_obj_init(&priv->glob_state,
+				    &state->base,
+				    &omap_global_state_funcs);
+	return 0;
+}
+
+void omap_global_obj_fini(struct omap_drm_private *priv)
+{
+	drm_atomic_private_obj_fini(&priv->glob_state);
+	drm_modeset_lock_fini(&priv->glob_state_lock);
+}
+
+static struct omap_hw_overlay *
+omap_plane_find_free_overlay(struct drm_device *dev,
+			     struct omap_hw_overlay_state *new_state,
+			     u32 caps, u32 fourcc, u32 crtc_mask)
+{
+	struct omap_drm_private *priv = dev->dev_private;
+	const struct dispc_ops *ops = priv->dispc_ops;
+	int i;
+
+	DBG("caps: %x fourcc: %x crtc: %x\n", caps, fourcc, crtc_mask);
+
+	for (i = 0; i < priv->num_ovls; i++) {
+		struct omap_hw_overlay *cur = priv->overlays[i];
+	
+		DBG("%d: id: %d cur->caps: %x cur->crtc: %x\n",
+		    cur->idx, cur->overlay_id, cur->caps, cur->possible_crtcs);
+
+		/* skip if already in-use */
+		if (new_state->hwoverlay_to_plane[cur->idx])
+			continue;
+
+		/* check if allowed on crtc */
+		if (!(cur->possible_crtcs & crtc_mask))
+			continue;
+
+		/* skip if doesn't support some required caps: */
+		if (caps & ~cur->caps)
+			continue;
+
+		/* check supported format */
+		if (!ops->ovl_color_mode_supported(priv->dispc,
+						   cur->overlay_id,
+						   fourcc))
+			continue;
+
+		return cur;
+	}
+
+	DBG("no match\n");
+	return NULL;
+}
+
+int omap_overlay_assign(struct drm_atomic_state *s, struct drm_plane *plane,
+			u32 caps, u32 fourcc, u32 crtc_mask,
+			struct omap_hw_overlay **overlay,
+			struct omap_hw_overlay **r_overlay)
+{
+	struct omap_drm_private *priv = s->dev->dev_private;
+	struct omap_global_state *new_global_state, *old_global_state;
+	struct omap_hw_overlay_state *old_state, *new_state;
+	struct omap_hw_overlay *ovl, *r_ovl;
+
+	new_global_state = omap_get_global_state(s);
+	if (IS_ERR(new_global_state))
+		return PTR_ERR(new_global_state);
+
+	/*
+	 * grab old_state after omap_get_global_state(),
+	 * since now we hold lock:
+	 */
+	old_global_state = omap_get_existing_global_state(priv);
+	DBG("new_global_state: %p old_global_state: %p should be different (%d)",
+	    new_global_state, old_global_state, new_global_state != old_global_state);
+
+	old_state = &old_global_state->overlay;
+	new_state = &new_global_state->overlay;
+
+	if (!*overlay) {
+		ovl = omap_plane_find_free_overlay(s->dev, new_state,
+						   caps, fourcc, crtc_mask);
+		if (!ovl)
+			return -ENOMEM;
+
+		new_state->hwoverlay_to_plane[ovl->idx] = plane;
+		*overlay = ovl;
+
+		if (r_overlay) {
+			r_ovl = omap_plane_find_free_overlay(s->dev, new_state,
+							     caps, fourcc,
+							     crtc_mask);
+			if (!r_ovl) {
+				new_state->hwoverlay_to_plane[ovl->idx] = NULL;
+				*overlay = NULL;
+				return -ENOMEM;
+			}
+
+			new_state->hwoverlay_to_plane[r_ovl->idx] = plane;
+			*r_overlay = r_ovl;
+		}
+
+
+		DBG("%s: assign to plane %s for caps %x",
+		    (*overlay)->name, plane->name, caps);
+
+		if (r_overlay) {
+			DBG("%s: assign to right of plane %s for caps %x",
+			    (*r_overlay)->name, plane->name, caps);
+		}
+	}
+
+	return 0;
+}
+
+void omap_overlay_release(struct drm_atomic_state *s,
+			  struct omap_hw_overlay *overlay)
+{
+	struct omap_global_state *state = omap_get_global_state(s);
+	struct omap_hw_overlay_state *new_state = &state->overlay;
+
+	if (!overlay)
+		return;
+
+	if (WARN_ON(!new_state->hwoverlay_to_plane[overlay->idx]))
+		return;
+
+	DBG("%s: release from plane %s", overlay->name,
+	    new_state->hwoverlay_to_plane[overlay->idx]->name);
+
+	new_state->hwoverlay_to_plane[overlay->idx] = NULL;
+}
+
+/*
+ * This is called only from omap_atomic_commit_tail()
+ * as a cleanup step to make sure hw overlay which are no longer
+ * are disabled.
+ *
+ * I was originally taking the glob_state_lock here by calling
+ * omap_get_global_state(s) but doing so here was causing all kind
+ * lock related warnings, for instance:
+ *  WARNING: CPU: 0 PID: 68 at drivers/gpu/drm/drm_modeset_lock.c:241
+ * and
+ *  WARNING: CPU: 0 PID: 68 at drivers/gpu/drm/drm_modeset_lock.c:244
+ * As well as also generating these:
+ *  ==================================
+ *  WARNING: Nested lock was not taken
+ *  4.18.0-rc2-00055-g5d51e5159b0a #24 Tainted: G        W
+ *  ----------------------------------
+ *  kworker/u2:3/66 is trying to lock:
+ *  51abea2e (crtc_ww_class_mutex){+.+.}, at: drm_modeset_lock+0xd0/0x140
+ *
+ *  but this task is not holding:
+ *  �21
+ *
+ * The only thing that worked so far was to stop trying to take that lock
+ * in this particular case. It might the real solution but I would like
+ * to sure.
+ */
+void omap_overlay_disable_unassigned(struct drm_atomic_state *s)
+{
+	struct omap_drm_private *priv = s->dev->dev_private;
+	struct omap_hw_overlay_state *new_state;
+	struct omap_global_state *old_state;
+	int i;
+
+	old_state = omap_get_existing_global_state(priv);
+	new_state = &old_state->overlay;
+
+	for (i = 0; i < priv->num_ovls; i++) {
+		struct omap_hw_overlay *cur = priv->overlays[i];
+
+		if (!new_state->hwoverlay_to_plane[cur->idx]) {
+			priv->dispc_ops->ovl_enable(priv->dispc,
+						    cur->overlay_id,
+						    false);
+
+			/*
+			 * Since we are disabling this overlay in this
+			 * atomic cycle we can reset the avalaible crtcs
+			 * it can be used on
+			 */
+			cur->possible_crtcs = (1 << priv->num_crtcs) - 1;
+		}
+	}
+}
+
+void omap_overlay_destroy(struct omap_hw_overlay *overlay)
+{
+	kfree(overlay);
+}
+
+static struct omap_hw_overlay *omap_overlay_init(enum omap_plane_id overlay_id,
+						 enum omap_overlay_caps caps)
+{
+	struct omap_hw_overlay *overlay;
+
+	overlay = kzalloc(sizeof(*overlay), GFP_KERNEL);
+	if (!overlay)
+		return ERR_PTR(-ENOMEM);
+
+	overlay->name = overlay2name(overlay_id);
+	overlay->overlay_id = overlay_id;
+	overlay->caps = caps;
+	/* 
+	 * When this is called priv->num_crtcs is not known yet.
+	 * Use a safe mask value to start with, it will get updated to the
+	 * proper value after the first use.
+	 */
+	overlay->possible_crtcs = 0xff;
+
+	return overlay;
+}
+
+int omap_hwoverlays_init(struct omap_drm_private *priv)
+{
+	static const enum omap_plane_id overlays[] = {
+			OMAP_DSS_GFX, OMAP_DSS_VIDEO1,
+			OMAP_DSS_VIDEO2, OMAP_DSS_VIDEO3,
+	};
+	u32 num_overlays = priv->dispc_ops->get_num_ovls(priv->dispc);
+	enum omap_overlay_caps caps;
+	int i, ret;
+
+	for (i = 0; i < num_overlays; i++) {
+		struct omap_hw_overlay *overlay;
+
+		caps = priv->dispc_ops->ovl_get_caps(priv->dispc, overlays[i]);
+		overlay = omap_overlay_init(overlays[i], caps);
+		if (IS_ERR(overlay)) {
+			ret = PTR_ERR(overlay);
+			dev_err(priv->dev, "failed to construct overlay for %s (%d)\n",
+				overlay2name(i), ret);
+			return ret;
+		}
+		overlay->idx = priv->num_ovls;
+		priv->overlays[priv->num_ovls++] = overlay;
+	}
+
+	return 0;
+}
+
+void omap_hwoverlays_destroy(struct omap_drm_private *priv)
+{
+	int i;
+
+	for (i = 0; i < priv->num_ovls; i++) {
+		omap_overlay_destroy(priv->overlays[i]);
+		priv->overlays[i] = NULL;
+	}
+}
diff --git a/drivers/gpu/drm/omapdrm/omap_overlay.h b/drivers/gpu/drm/omapdrm/omap_overlay.h
new file mode 100644
index 000000000000..ed94a260ba10
--- /dev/null
+++ b/drivers/gpu/drm/omapdrm/omap_overlay.h
@@ -0,0 +1,80 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Copyright (C) 2018 Texas Instruments Incorporated -  http://www.ti.com/
+ * Author: Benoit Parrot, <bparrot@ti.com>
+ */
+
+#ifndef __OMAPDRM_OVERLAY_H__
+#define __OMAPDRM_OVERLAY_H__
+
+#include <linux/types.h>
+ 
+enum drm_plane_type;
+
+struct drm_device;
+struct drm_mode_object;
+struct drm_plane;
+
+/* Used to associate a HW overlay/plane to a plane */
+struct omap_hw_overlay {
+	int idx;
+
+	const char *name;
+	enum omap_plane_id overlay_id;
+
+	enum omap_overlay_caps caps;
+	/*
+	 * The CRTC(s) this overlay is currently allowed on.
+	 * When the overlay is unused and was not assigned to any crtc then
+	 * this will be the equal to the plane possible_crtcs otherwise it
+	 * will be the current crtc this overlay is displayed on.
+	 * When clearing the overlay to plane assignemnt while going through
+	 * an atomic_check sequence we need to remember which crtc the overlay
+	 * was on as we do not want to create flicker. We want to be able to
+	 * reassign the overlay to the same crtc it was previously on.
+	 */
+	u32 possible_crtcs;
+	/* Reference to the associated drm_plane */
+	struct drm_plane *plane;
+};
+
+/* global atomic state of assignment between pipes and planes: */
+struct omap_hw_overlay_state {
+	struct drm_plane *hwoverlay_to_plane[8];
+};
+
+/* Global private object state for tracking resources that are shared across
+ * multiple kms objects (planes/crtcs/etc).
+ */
+#define to_omap_global_state(x) container_of(x, struct omap_global_state, base)
+struct omap_global_state {
+	struct drm_private_state base;
+
+	struct drm_atomic_state *state;
+
+	struct omap_hw_overlay_state overlay;
+};
+
+static inline const char *overlay2name(enum omap_plane_id id)
+{
+	static const char *name[] = {
+		[OMAP_DSS_GFX] = "gfx",
+		[OMAP_DSS_VIDEO1] = "vid1",
+		[OMAP_DSS_VIDEO2] = "vid2",
+		[OMAP_DSS_VIDEO3] = "vid3",
+	};
+	return name[id];
+}
+
+int omap_hwoverlays_init(struct omap_drm_private *priv);
+void omap_global_obj_fini(struct omap_drm_private *priv);
+void omap_hwoverlays_destroy(struct omap_drm_private *priv);
+int omap_global_obj_init(struct omap_drm_private *priv);
+int omap_overlay_assign(struct drm_atomic_state *s, struct drm_plane *plane,
+			u32 caps, u32 fourcc, u32 crtc_mask,
+			struct omap_hw_overlay **overlay,
+			struct omap_hw_overlay **r_overlay);
+void omap_overlay_release(struct drm_atomic_state *s, struct omap_hw_overlay *overlay);
+void omap_overlay_disable_unassigned(struct drm_atomic_state *s);
+
+#endif /* __OMAPDRM_OVERLAY_H__ */
diff --git a/drivers/gpu/drm/omapdrm/omap_plane.c b/drivers/gpu/drm/omapdrm/omap_plane.c
index 161233cbc9a0..01f1da155994 100644
--- a/drivers/gpu/drm/omapdrm/omap_plane.c
+++ b/drivers/gpu/drm/omapdrm/omap_plane.c
@@ -30,10 +30,12 @@
 
 struct omap_plane {
 	struct drm_plane base;
-	enum omap_plane_id id;
+	enum omap_plane_id default_id;
 	const char *name;
 };
 
+static const char *plane_id_to_name[];
+
 static int omap_plane_prepare_fb(struct drm_plane *plane,
 				 struct drm_plane_state *new_state)
 {
@@ -50,15 +52,26 @@ static void omap_plane_cleanup_fb(struct drm_plane *plane,
 		omap_framebuffer_unpin(old_state->fb);
 }
 
+static bool plane_enabled(struct drm_plane_state *state)
+{
+	return state->visible;
+}
+
 static void omap_plane_atomic_update(struct drm_plane *plane,
 				     struct drm_plane_state *old_state)
 {
 	struct omap_drm_private *priv = plane->dev->dev_private;
 	struct omap_plane *omap_plane = to_omap_plane(plane);
 	struct drm_plane_state *state = plane->state;
-	struct omap_overlay_info info;
+	struct omap_plane_state *omap_state = to_omap_plane_state(state);
+	struct omap_overlay_info info, r_info;
+	enum omap_plane_id ovl_id, r_ovl_id;
 	int ret;
+	bool dual_plane = !!omap_state->r_overlay;
 
+	ovl_id = omap_state->overlay->overlay_id;
+	DBG("[PLANE:%d:%s] overlay_id: %d\n", plane->base.id, plane->name,
+	    ovl_id);
 	DBG("%s, crtc=%p fb=%p", omap_plane->name, state->crtc, state->fb);
 
 	memset(&info, 0, sizeof(info));
@@ -67,75 +80,231 @@ static void omap_plane_atomic_update(struct drm_plane *plane,
 	info.global_alpha = 0xff;
 	info.zorder = state->normalized_zpos;
 
+	r_info = info;
+
 	/* update scanout: */
-	omap_framebuffer_update_scanout(state->fb, state, &info);
+	omap_framebuffer_update_scanout(state->fb, state, &info,
+					dual_plane ? &r_info : NULL);
 
-	DBG("%dx%d -> %dx%d (%d)", info.width, info.height,
-			info.out_width, info.out_height,
-			info.screen_width);
+	DBG("%s: %dx%d -> %dx%d (%d)",
+	    overlay2name(ovl_id), info.width, info.height,
+	    info.out_width, info.out_height, info.screen_width);
 	DBG("%d,%d %pad %pad", info.pos_x, info.pos_y,
-			&info.paddr, &info.p_uv_addr);
+	    &info.paddr, &info.p_uv_addr);
+
+	if (dual_plane) {
+		r_ovl_id = omap_state->r_overlay->overlay_id;
+		/*
+		 * If the current plane uses 2 hw planes the very next
+		 * zorder is used by the r_overlay so we just use the
+		 * main overlay zorder + 1
+		 */
+		r_info.zorder = info.zorder + 1;
+
+		DBG("%s: %dx%d -> %dx%d (%d)",
+		    overlay2name(r_ovl_id), r_info.width, r_info.height,
+		    r_info.out_width, r_info.out_height, r_info.screen_width);
+		DBG("%d,%d %pad %pad", r_info.pos_x, r_info.pos_y,
+		    &r_info.paddr, &r_info.p_uv_addr);
+	}
 
 	/* and finally, update omapdss: */
-	ret = priv->dispc_ops->ovl_setup(priv->dispc, omap_plane->id, &info,
+	ret = priv->dispc_ops->ovl_setup(priv->dispc, ovl_id, &info,
 			      omap_crtc_timings(state->crtc), false,
 			      omap_crtc_channel(state->crtc));
 	if (ret) {
-		dev_err(plane->dev->dev, "Failed to setup plane %s\n",
+		dev_err(plane->dev->dev, "Failed to setup plane1 %s\n",
 			omap_plane->name);
-		priv->dispc_ops->ovl_enable(priv->dispc, omap_plane->id, false);
+		priv->dispc_ops->ovl_enable(priv->dispc, ovl_id, false);
 		return;
 	}
 
-	priv->dispc_ops->ovl_enable(priv->dispc, omap_plane->id, true);
+	priv->dispc_ops->ovl_enable(priv->dispc, ovl_id, true);
+
+	if (dual_plane) {
+		ret = priv->dispc_ops->ovl_setup(priv->dispc, r_ovl_id, &r_info,
+				      omap_crtc_timings(state->crtc), false,
+				      omap_crtc_channel(state->crtc));
+		if (ret) {
+			dev_err(plane->dev->dev, "Failed to setup plane2 %s\n",
+				omap_plane->name);
+			priv->dispc_ops->ovl_enable(priv->dispc, r_ovl_id, false);
+			priv->dispc_ops->ovl_enable(priv->dispc, ovl_id, false);
+			return;
+		}
+
+		priv->dispc_ops->ovl_enable(priv->dispc, r_ovl_id, true);
+	}
 }
 
 static void omap_plane_atomic_disable(struct drm_plane *plane,
 				      struct drm_plane_state *old_state)
 {
 	struct omap_drm_private *priv = plane->dev->dev_private;
-	struct omap_plane *omap_plane = to_omap_plane(plane);
+	struct omap_plane_state *omap_state = to_omap_plane_state(old_state);
+	bool dual_plane = !!omap_state->r_overlay;
+
+	DBG("%s: check (overlay %p r_overlay %p)", plane->name,
+	    omap_state->overlay, omap_state->r_overlay);
+
+	if (!omap_state->overlay)
+		return;
 
 	plane->state->rotation = DRM_MODE_ROTATE_0;
 	plane->state->zpos = plane->type == DRM_PLANE_TYPE_PRIMARY
-			   ? 0 : omap_plane->id;
-
-	priv->dispc_ops->ovl_enable(priv->dispc, omap_plane->id, false);
+			   ? 0 : omap_state->overlay->overlay_id;
+
+	priv->dispc_ops->ovl_enable(priv->dispc, omap_state->overlay->overlay_id, false);
+	omap_overlay_release(old_state->state, omap_state->overlay);
+	omap_state->overlay = NULL;
+	if (dual_plane) {
+		priv->dispc_ops->ovl_enable(priv->dispc, omap_state->r_overlay->overlay_id, false);
+		omap_overlay_release(old_state->state, omap_state->r_overlay);
+		omap_state->r_overlay = NULL;
+	}
 }
 
+#define FRAC_16_16(mult, div)    (((mult) << 16) / (div))
 static int omap_plane_atomic_check(struct drm_plane *plane,
 				   struct drm_plane_state *state)
 {
+	struct omap_drm_private *priv = plane->dev->dev_private;
+	struct drm_crtc *crtc;	
 	struct drm_crtc_state *crtc_state;
+	struct drm_plane_state *old_state = plane->state;
+	struct omap_plane_state *omap_state = to_omap_plane_state(state);
+	const struct dispc_ops *ops = priv->dispc_ops;
+	u16 width, height;
+	u32 crtc_mask;
+	u32 fourcc;
+	u32 caps = 0;
+	bool new_hw_overlay = false;
+	bool new_r_hw_overlay = false;
+	bool out_of_bounds = false;
+	int min_scale, max_scale;
+	u32 max_width, max_height;
+	int ret;
 
-	if (!state->fb)
-		return 0;
+	DBG("%s: check (%d -> %d)", plane->name,
+	    plane_enabled(old_state), plane_enabled(state));
+
+	priv->dispc_ops->ovl_get_max_size(priv->dispc, &width, &height);
+	max_width = width << 16;
+	max_height = height << 16;
 
-	/* crtc should only be NULL when disabling (i.e., !state->fb) */
-	if (WARN_ON(!state->crtc))
+	crtc = state->crtc ? state->crtc : plane->state->crtc;
+	if (!crtc)
 		return 0;
 
-	crtc_state = drm_atomic_get_existing_crtc_state(state->state, state->crtc);
+	crtc_state = drm_atomic_get_existing_crtc_state(state->state, crtc);
 	/* we should have a crtc state if the plane is attached to a crtc */
 	if (WARN_ON(!crtc_state))
 		return 0;
 
-	if (!crtc_state->enable)
-		return 0;
+	/* Make sure source dimensions are within bounds. */
+	if (state->src_h > max_height)
+		out_of_bounds = true;
 
-	if (state->crtc_x < 0 || state->crtc_y < 0)
-		return -EINVAL;
+	if (state->src_w > max_width) {
+		if (state->src_w <= (2 * max_width))
+			new_r_hw_overlay = true;
+		else
+			out_of_bounds = true;
+	}
 
-	if (state->crtc_x + state->crtc_w > crtc_state->adjusted_mode.hdisplay)
-		return -EINVAL;
+	if (out_of_bounds) {
+		struct drm_rect src = drm_plane_state_src(state);
+		DBG("Invalid source size "DRM_RECT_FP_FMT,
+		    DRM_RECT_FP_ARG(&src));
+		return -ERANGE;
+	}
 
-	if (state->crtc_y + state->crtc_h > crtc_state->adjusted_mode.vdisplay)
-		return -EINVAL;
+	min_scale = FRAC_16_16(1, 4);
+	max_scale = FRAC_16_16(8, 1);
+
+	ret = drm_atomic_helper_check_plane_state(state, crtc_state,
+						  min_scale, max_scale,
+						  true, true);
+	if (ret)
+		return ret;
 
 	if (state->rotation != DRM_MODE_ROTATE_0 &&
 	    !omap_framebuffer_supports_rotation(state->fb))
 		return -EINVAL;
 
+	if (plane_enabled(state)) {
+		if ((state->src_w >> 16) != state->crtc_w ||
+		    (state->src_h >> 16) != state->crtc_h)
+			caps |= OMAP_DSS_OVL_CAP_SCALE;
+
+		fourcc = state->fb->format->format;
+		crtc_mask = drm_crtc_mask(state->crtc);
+
+		/* (re)allocate hw overlay if we don't have one or caps-mismatch: */
+		if (!omap_state->overlay || (caps & ~omap_state->overlay->caps)) {
+			new_hw_overlay = true;
+		} else {
+			/* check if allowed on crtc */
+			if (!(omap_state->overlay->possible_crtcs & crtc_mask))
+				new_hw_overlay = true;
+
+			/* check supported format */
+			if (!ops->ovl_color_mode_supported(priv->dispc,
+						omap_state->overlay->overlay_id,
+						fourcc))
+				new_hw_overlay = true;
+		}
+		/* 
+		 * check if we need two overlays and only have 1 or
+		 * if we had 2 overlays but will only need 1
+		 */ 
+		if ((new_r_hw_overlay && !omap_state->r_overlay) ||
+		    (!new_r_hw_overlay && omap_state->r_overlay))
+			new_hw_overlay = true;
+
+		if (new_hw_overlay) {
+			struct omap_hw_overlay *old_ovl = 
+						omap_state->overlay;
+			struct omap_hw_overlay *old_r_ovl = 
+						omap_state->r_overlay;
+			struct omap_hw_overlay *new_ovl = NULL;
+			struct omap_hw_overlay *new_r_ovl = NULL;
+
+			omap_overlay_release(state->state, old_ovl);
+			omap_overlay_release(state->state, old_r_ovl);
+
+			ret = omap_overlay_assign(state->state, plane, caps,
+						  fourcc, crtc_mask, &new_ovl,
+						  new_r_hw_overlay ?
+						  &new_r_ovl : NULL);
+			if (ret) {
+				DBG("%s: failed to assign hw_overlay(s)!",
+				    plane->name);
+				omap_state->overlay = NULL;
+				omap_state->r_overlay = NULL;
+				return ret;
+			}
+
+			omap_state->overlay = new_ovl;
+			if (new_r_hw_overlay)
+				omap_state->r_overlay = new_r_ovl;
+			else
+				omap_state->r_overlay = NULL;
+		}
+	} else {
+		omap_overlay_release(state->state, omap_state->overlay);
+		omap_overlay_release(state->state, omap_state->r_overlay);
+		omap_state->overlay = NULL;
+		omap_state->r_overlay = NULL;
+	}
+
+	if (omap_state->overlay)
+		DBG("plane: %s overlay_id: %d", plane->name,
+		    omap_state->overlay->overlay_id);
+	if (omap_state->r_overlay)
+		DBG("plane: %s r_overlay_id: %d", plane->name,
+		    omap_state->r_overlay->overlay_id);
+
 	return 0;
 }
 
@@ -182,20 +351,77 @@ void omap_plane_install_properties(struct drm_plane *plane,
 	drm_object_attach_property(obj, priv->zorder_prop, 0);
 }
 
+/* Add duplicate and destroy state helper */
+static struct drm_plane_state *
+omap_plane_atomic_duplicate_state(struct drm_plane *plane)
+{
+	struct omap_plane_state *state;
+	struct omap_plane_state *copy;
+
+	if (WARN_ON(!plane->state))
+		return NULL;
+
+	state = to_omap_plane_state(plane->state);
+	copy = kmemdup(state, sizeof(*state), GFP_KERNEL);
+	if (copy == NULL)
+		return NULL;
+
+	__drm_atomic_helper_plane_duplicate_state(plane, &copy->base);
+
+	return &copy->base;
+}
+
+static void omap_plane_atomic_destroy_state(struct drm_plane *plane,
+					    struct drm_plane_state *state)
+{
+	__drm_atomic_helper_plane_destroy_state(state);
+	kfree(to_omap_plane_state(state));
+}
+
 static void omap_plane_reset(struct drm_plane *plane)
 {
 	struct omap_plane *omap_plane = to_omap_plane(plane);
+	struct omap_plane_state *omap_state;
+
+	if (plane->state)
+		omap_plane_atomic_destroy_state(plane, plane->state);
 
-	drm_atomic_helper_plane_reset(plane);
-	if (!plane->state)
+	omap_state = kzalloc(sizeof(*omap_state), GFP_KERNEL);
+	if (!omap_state)
 		return;
 
+	omap_state->base.plane = plane;
+	plane->state = &omap_state->base;
+	plane->state->plane = plane;
+	plane->state->rotation = DRM_MODE_ROTATE_0;
 	/*
 	 * Set the zpos default depending on whether we are a primary or overlay
 	 * plane.
 	 */
 	plane->state->zpos = plane->type == DRM_PLANE_TYPE_PRIMARY
-			   ? 0 : omap_plane->id;
+			   ? 0 : omap_plane->default_id;
+}
+
+static void omap_plane_atomic_print_state(struct drm_printer *p,
+		const struct drm_plane_state *state)
+{
+	struct omap_plane_state *omap_state = to_omap_plane_state(state);
+
+	drm_printf(p, "\toverlay=%p\n", omap_state->overlay);
+	if (omap_state->overlay) {
+		drm_printf(p, "\t\tidx=%d\n", omap_state->overlay->idx);
+		drm_printf(p, "\t\toverlay_id=%d\n", omap_state->overlay->overlay_id);
+		drm_printf(p, "\t\tcaps=0x%x\n", omap_state->overlay->caps);
+		drm_printf(p, "\t\tpossible_crtcs=0x%x\n", omap_state->overlay->possible_crtcs);
+	}
+
+	drm_printf(p, "\tr_overlay=%p\n", omap_state->r_overlay);
+	if (omap_state->r_overlay) {
+		drm_printf(p, "\t\tidx=%d\n", omap_state->r_overlay->idx);
+		drm_printf(p, "\t\toverlay_id=%d\n", omap_state->r_overlay->overlay_id);
+		drm_printf(p, "\t\tcaps=0x%x\n", omap_state->r_overlay->caps);
+		drm_printf(p, "\t\tpossible_crtcs=0x%x\n", omap_state->r_overlay->possible_crtcs);
+	}
 }
 
 static int omap_plane_atomic_set_property(struct drm_plane *plane,
@@ -233,10 +459,11 @@ static const struct drm_plane_funcs omap_plane_funcs = {
 	.disable_plane = drm_atomic_helper_disable_plane,
 	.reset = omap_plane_reset,
 	.destroy = omap_plane_destroy,
-	.atomic_duplicate_state = drm_atomic_helper_plane_duplicate_state,
-	.atomic_destroy_state = drm_atomic_helper_plane_destroy_state,
+	.atomic_duplicate_state = omap_plane_atomic_duplicate_state,
+	.atomic_destroy_state = omap_plane_atomic_destroy_state,
 	.atomic_set_property = omap_plane_atomic_set_property,
 	.atomic_get_property = omap_plane_atomic_get_property,
+	.atomic_print_state = omap_plane_atomic_print_state,
 };
 
 static const char *plane_id_to_name[] = {
@@ -246,14 +473,6 @@ static const char *plane_id_to_name[] = {
 	[OMAP_DSS_VIDEO3] = "vid3",
 };
 
-static const enum omap_plane_id plane_idx_to_id[] = {
-	OMAP_DSS_GFX,
-	OMAP_DSS_VIDEO1,
-	OMAP_DSS_VIDEO2,
-	OMAP_DSS_VIDEO3,
-};
-
-/* initialize plane */
 struct drm_plane *omap_plane_init(struct drm_device *dev,
 		int idx, enum drm_plane_type type,
 		u32 possible_crtcs)
@@ -262,27 +481,28 @@ struct drm_plane *omap_plane_init(struct drm_device *dev,
 	unsigned int num_planes = priv->dispc_ops->get_num_ovls(priv->dispc);
 	struct drm_plane *plane;
 	struct omap_plane *omap_plane;
-	enum omap_plane_id id;
 	int ret;
 	u32 nformats;
 	const u32 *formats;
 
-	if (WARN_ON(idx >= ARRAY_SIZE(plane_idx_to_id)))
+	if (WARN_ON(idx >= num_planes))
 		return ERR_PTR(-EINVAL);
 
-	id = plane_idx_to_id[idx];
-
-	DBG("%s: type=%d", plane_id_to_name[id], type);
-
 	omap_plane = kzalloc(sizeof(*omap_plane), GFP_KERNEL);
 	if (!omap_plane)
 		return ERR_PTR(-ENOMEM);
 
-	formats = priv->dispc_ops->ovl_get_color_modes(priv->dispc, id);
+	omap_plane->default_id = idx;
+	omap_plane->name = plane_id_to_name[idx];
+
+	DBG("%s: type=%d", omap_plane->name, type);
+	DBG("	omap_plane->default_id: %d", omap_plane->default_id);
+	DBG("	crtc_mask: 0x%04x", possible_crtcs);
+
+	formats = priv->dispc_ops->ovl_get_color_modes(priv->dispc,
+						       omap_plane->default_id);
 	for (nformats = 0; formats[nformats]; ++nformats)
 		;
-	omap_plane->id = id;
-	omap_plane->name = plane_id_to_name[id];
 
 	plane = &omap_plane->base;
 
@@ -301,7 +521,7 @@ struct drm_plane *omap_plane_init(struct drm_device *dev,
 
 error:
 	dev_err(dev->dev, "%s(): could not create plane: %s\n",
-		__func__, plane_id_to_name[id]);
+		__func__, omap_plane->name);
 
 	kfree(omap_plane);
 	return NULL;
diff --git a/drivers/gpu/drm/omapdrm/omap_plane.h b/drivers/gpu/drm/omapdrm/omap_plane.h
index dc5e82ad061d..9000f45a9b65 100644
--- a/drivers/gpu/drm/omapdrm/omap_plane.h
+++ b/drivers/gpu/drm/omapdrm/omap_plane.h
@@ -28,10 +28,30 @@ struct drm_device;
 struct drm_mode_object;
 struct drm_plane;
 
+/*
+ * Atomic plane state. Subclasses the base drm_plane_state in order to
+ * track assigned overlay and hw specific state.
+ */
+struct omap_plane_state {
+	struct drm_plane_state base;
+
+	struct omap_hw_overlay *overlay;
+	struct omap_hw_overlay *r_overlay;  /* right overlay */
+};
+#define to_omap_plane_state(x) \
+		container_of(x, struct omap_plane_state, base)
+
 struct drm_plane *omap_plane_init(struct drm_device *dev,
 		int idx, enum drm_plane_type type,
 		u32 possible_crtcs);
 void omap_plane_install_properties(struct drm_plane *plane,
 		struct drm_mode_object *obj);
 
+static inline bool is_omap_plane_dual_overlay(struct drm_plane_state *state)
+{
+	struct omap_plane_state *omap_state = to_omap_plane_state(state);
+
+	return !!omap_state->r_overlay;
+}
+
 #endif /* __OMAPDRM_PLANE_H__ */
-- 
2.9.0

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

Re: [RFC 3/3] drm/omap: Add wide display support using multiple overlays

[Tomi Valkeinen]

Hi Benoit,

On 29/06/18 20:02, Benoit Parrot wrote:
> In the case where we need to support wide-display using more than one
> overlay to achieve the needed display resolution, we need to be able to
> dynamically assign overlays to planes instead of having the overlays
> being statically mapped to planes.
> 
> This also means that on occasion where the number of requested planes
> exceeds the numbers of overlays required to display them then a failure
> would be returned for the plane that cannot be handled at that time. It
> is up to user space to make sure the H/W resource are not
> over-subscribed.

This is not a trivial patch, I think it needs much more explanation in
the desc on how the patch solves this issue and what it changes.

I have some small comments below here and there, but overall, I feel
it's rather difficult to review, and I really think this should be split
into multiple smaller patches. Some ideas on the patches it might be
split to:

- add plane state
- add global state
- add code which manages plane-id -> hw plane id
- add dual plane support

> Signed-off-by: Benoit Parrot <bparrot@ti.com>
> ---
>  drivers/gpu/drm/omapdrm/Makefile       |   1 +
>  drivers/gpu/drm/omapdrm/omap_drv.c     | 119 ++++++++++-
>  drivers/gpu/drm/omapdrm/omap_drv.h     |  15 +-
>  drivers/gpu/drm/omapdrm/omap_fb.c      |  33 ++-
>  drivers/gpu/drm/omapdrm/omap_fb.h      |   4 +-
>  drivers/gpu/drm/omapdrm/omap_overlay.c | 366 +++++++++++++++++++++++++++++++++
>  drivers/gpu/drm/omapdrm/omap_overlay.h |  80 +++++++
>  drivers/gpu/drm/omapdrm/omap_plane.c   | 322 ++++++++++++++++++++++++-----
>  drivers/gpu/drm/omapdrm/omap_plane.h   |  20 ++
>  9 files changed, 892 insertions(+), 68 deletions(-)
>  create mode 100644 drivers/gpu/drm/omapdrm/omap_overlay.c
>  create mode 100644 drivers/gpu/drm/omapdrm/omap_overlay.h
> 
> diff --git a/drivers/gpu/drm/omapdrm/Makefile b/drivers/gpu/drm/omapdrm/Makefile
> index f115253115c5..800dfd035360 100644
> --- a/drivers/gpu/drm/omapdrm/Makefile
> +++ b/drivers/gpu/drm/omapdrm/Makefile
> @@ -12,6 +12,7 @@ omapdrm-y := omap_drv.o \
>  	omap_debugfs.o \
>  	omap_crtc.o \
>  	omap_plane.o \
> +	omap_overlay.o \
>  	omap_encoder.o \
>  	omap_connector.o \
>  	omap_fb.o \
> diff --git a/drivers/gpu/drm/omapdrm/omap_drv.c b/drivers/gpu/drm/omapdrm/omap_drv.c
> index ef3b0e3571ec..f0a5c3dab471 100644
> --- a/drivers/gpu/drm/omapdrm/omap_drv.c
> +++ b/drivers/gpu/drm/omapdrm/omap_drv.c
> @@ -16,11 +16,7 @@
>   */
>  
>  #include <linux/sys_soc.h>
> -
> -#include <drm/drm_atomic.h>
> -#include <drm/drm_atomic_helper.h>
> -#include <drm/drm_crtc_helper.h>
> -#include <drm/drm_fb_helper.h>
> +#include <linux/sort.h>
>  
>  #include "omap_dmm_tiler.h"
>  #include "omap_drv.h"
> @@ -113,9 +109,100 @@ static void omap_atomic_commit_tail(struct drm_atomic_state *old_state)
>  
>  	drm_atomic_helper_cleanup_planes(dev, old_state);
>  
> +	omap_overlay_disable_unassigned(old_state);
> +
>  	priv->dispc_ops->runtime_put(priv->dispc);
>  }
>  
> +static int drm_atomic_state_normalized_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->normalized_zpos != sb->normalized_zpos)
> +		return sa->normalized_zpos - sb->normalized_zpos;
> +	else
> +		return sa->plane->base.id - sb->plane->base.id;
> +}
> +
> +static int omap_atomic_update_normalize_zpos(struct drm_device *dev,
> +					     struct drm_atomic_state *state)
> +{
> +	struct drm_crtc *crtc;
> +	struct drm_crtc_state *old_state, *new_state;
> +	struct drm_plane *plane;
> +	int i, n, inc;
> +	int total_planes = dev->mode_config.num_total_plane;
> +	struct drm_plane_state **states;
> +	int ret = 0;
> +
> +	states = kmalloc_array(total_planes, sizeof(*states), GFP_KERNEL);
> +	if (!states)
> +		return -ENOMEM;
> +
> +	for_each_oldnew_crtc_in_state(state, crtc, old_state, new_state, i) {
> +		if (old_state->plane_mask == new_state->plane_mask &&
> +		    !new_state->zpos_changed)
> +			continue;
> +
> +		/* Reset plane increment and index value for every crtc */
> +		n = 0;
> +
> +		/*
> +		 * Normalization process might create new states for planes
> +		 * which normalized_zpos has to be recalculated.
> +		 */
> +		drm_for_each_plane_mask(plane, dev, new_state->plane_mask) {
> +			struct drm_plane_state *plane_state =
> +				drm_atomic_get_plane_state(new_state->state,
> +							   plane);
> +			if (IS_ERR(plane_state)) {
> +				ret = PTR_ERR(plane_state);
> +				goto done;
> +			}
> +			states[n++] = plane_state;
> +		}
> +
> +		sort(states, n, sizeof(*states),
> +		     drm_atomic_state_normalized_zpos_cmp, NULL);
> +
> +		for (i = 0, inc = 0; i < n; i++) {
> +			plane = states[i]->plane;
> +
> +			states[i]->normalized_zpos = i + inc;
> +			DRM_DEBUG_ATOMIC("[PLANE:%d:%s] updated normalized zpos value %d\n",
> +					 plane->base.id, plane->name,
> +					 states[i]->normalized_zpos);
> +
> +			if (is_omap_plane_dual_overlay(states[i]))
> +				inc++;
> +		}
> +		new_state->zpos_changed = true;
> +	}
> +
> +done:
> +	kfree(states);
> +	return ret;
> +}
> +
> +static int omap_atomic_check(struct drm_device *dev,
> +			     struct drm_atomic_state *state)
> +{
> +	int ret;
> +
> +	ret = drm_atomic_helper_check(dev, state);
> +	if (ret)
> +		return ret;
> +
> +	if (dev->mode_config.normalize_zpos) {
> +		ret = omap_atomic_update_normalize_zpos(dev, state);
> +		if (ret)
> +			return ret;
> +	}
> +
> +	return 0;
> +}
> +
>  static const struct drm_mode_config_helper_funcs omap_mode_config_helper_funcs = {
>  	.atomic_commit_tail = omap_atomic_commit_tail,
>  };
> @@ -123,7 +210,7 @@ static const struct drm_mode_config_helper_funcs omap_mode_config_helper_funcs =
>  static const struct drm_mode_config_funcs omap_mode_config_funcs = {
>  	.fb_create = omap_framebuffer_create,
>  	.output_poll_changed = drm_fb_helper_output_poll_changed,
> -	.atomic_check = drm_atomic_helper_check,
> +	.atomic_check = omap_atomic_check,
>  	.atomic_commit = drm_atomic_helper_commit,
>  };
>  
> @@ -296,7 +383,7 @@ static int omap_modeset_init(struct drm_device *dev)
>  			return -EINVAL;
>  
>  		plane = omap_plane_init(dev, plane_idx, DRM_PLANE_TYPE_OVERLAY,
> -			plane_crtc_mask);
> +					plane_crtc_mask);
>  		if (IS_ERR(plane))
>  			return PTR_ERR(plane);
>  
> @@ -560,10 +647,18 @@ static int omapdrm_init(struct omap_drm_private *priv, struct device *dev)
>  
>  	omap_gem_init(ddev);
>  
> +	ret = omap_global_obj_init(priv);
> +	if (ret)
> +		goto err_free_drm_dev;
> +
> +	ret = omap_hwoverlays_init(priv);
> +	if (ret)
> +		goto err_free_priv_obj;
> +
>  	ret = omap_modeset_init(ddev);
>  	if (ret) {
>  		dev_err(priv->dev, "omap_modeset_init failed: ret=%d\n", ret);
> -		goto err_free_drm_dev;
> +		goto err_free_overlays;
>  	}
>  
>  	/* Initialize vblank handling, start with all CRTCs disabled. */
> @@ -577,7 +672,6 @@ static int omapdrm_init(struct omap_drm_private *priv, struct device *dev)
>  		drm_crtc_vblank_off(priv->crtcs[i]);
>  
>  	omap_fbdev_init(ddev);
> -

As this is a big patch already, try not to make any extra cleanups that
are not needed.

>  	drm_kms_helper_poll_init(ddev);
>  	omap_modeset_enable_external_hpd();
>  
> @@ -599,6 +693,10 @@ static int omapdrm_init(struct omap_drm_private *priv, struct device *dev)
>  err_cleanup_modeset:
>  	drm_mode_config_cleanup(ddev);
>  	omap_drm_irq_uninstall(ddev);
> +err_free_overlays:
> +	omap_hwoverlays_destroy(priv);
> +err_free_priv_obj:
> +	omap_global_obj_fini(priv);
>  err_free_drm_dev:
>  	omap_gem_deinit(ddev);
>  	drm_dev_unref(ddev);
> @@ -632,6 +730,9 @@ static void omapdrm_cleanup(struct omap_drm_private *priv)
>  
>  	drm_dev_unref(ddev);
>  
> +	omap_hwoverlays_destroy(priv);
> +	omap_global_obj_fini(priv);
> +
>  	destroy_workqueue(priv->wq);
>  
>  	omap_disconnect_dssdevs();
> diff --git a/drivers/gpu/drm/omapdrm/omap_drv.h b/drivers/gpu/drm/omapdrm/omap_drv.h
> index 6eaee4df4559..eb71ea8decee 100644
> --- a/drivers/gpu/drm/omapdrm/omap_drv.h
> +++ b/drivers/gpu/drm/omapdrm/omap_drv.h
> @@ -23,7 +23,10 @@
>  #include <linux/workqueue.h>
>  
>  #include <drm/drmP.h>
> +#include <drm/drm_atomic.h>
> +#include <drm/drm_atomic_helper.h>
>  #include <drm/drm_crtc_helper.h>
> +#include <drm/drm_fb_helper.h>
>  #include <drm/drm_gem.h>
>  #include <drm/omap_drm.h>
>  
> @@ -37,6 +40,7 @@
>  #include "omap_gem.h"
>  #include "omap_irq.h"
>  #include "omap_plane.h"
> +#include "omap_overlay.h"
>  
>  #define DBG(fmt, ...) DRM_DEBUG(fmt"\n", ##__VA_ARGS__)
>  #define VERB(fmt, ...) if (0) DRM_DEBUG(fmt, ##__VA_ARGS__) /* verbose debug */
> @@ -66,6 +70,16 @@ struct omap_drm_private {
>  	unsigned int num_connectors;
>  	struct drm_connector *connectors[8];
>  
> +	unsigned int num_ovls;
> +	struct omap_hw_overlay *overlays[8];
> +
> +        /*
> +         * Global private object state, Do not access directly, use
> +         * omap_global_get_state()
> +         */
> +        struct drm_modeset_lock glob_state_lock;
> +        struct drm_private_obj glob_state;
> +

You're using space indentation here.

>  	struct drm_fb_helper *fbdev;
>  
>  	struct workqueue_struct *wq;
> @@ -91,7 +105,6 @@ struct omap_drm_private {
>  	unsigned int max_bandwidth;
>  };
>  
> -
>  int omap_debugfs_init(struct drm_minor *minor);
>  
>  #endif /* __OMAPDRM_DRV_H__ */
> diff --git a/drivers/gpu/drm/omapdrm/omap_fb.c b/drivers/gpu/drm/omapdrm/omap_fb.c
> index 5fd22ca73913..b9573c163117 100644
> --- a/drivers/gpu/drm/omapdrm/omap_fb.c
> +++ b/drivers/gpu/drm/omapdrm/omap_fb.c
> @@ -153,7 +153,9 @@ static u32 drm_rotation_to_tiler(unsigned int drm_rot)
>  /* update ovl info for scanout, handles cases of multi-planar fb's, etc.
>   */
>  void omap_framebuffer_update_scanout(struct drm_framebuffer *fb,
> -		struct drm_plane_state *state, struct omap_overlay_info *info)
> +		struct drm_plane_state *state,
> +		struct omap_overlay_info *info,
> +		struct omap_overlay_info *r_info)
>  {
>  	struct omap_framebuffer *omap_fb = to_omap_framebuffer(fb);
>  	const struct drm_format_info *format = omap_fb->format;
> @@ -206,7 +208,8 @@ void omap_framebuffer_update_scanout(struct drm_framebuffer *fb,
>  		info->rotation_type = OMAP_DSS_ROT_TILER;
>  		info->rotation = state->rotation ?: DRM_MODE_ROTATE_0;
>  		/* Note: stride in TILER units, not pixels */
> -		info->screen_width  = omap_gem_tiled_stride(plane->bo, orient);
> +		info->screen_width  =
> +				omap_gem_tiled_stride(plane->bo, orient);
>  	} else {
>  		switch (state->rotation & DRM_MODE_ROTATE_MASK) {
>  		case 0:
> @@ -221,10 +224,10 @@ void omap_framebuffer_update_scanout(struct drm_framebuffer *fb,
>  			break;
>  		}
>  
> -		info->paddr         = get_linear_addr(plane, format, 0, x, y);
> +		info->paddr = get_linear_addr(plane, format, 0, x, y);
>  		info->rotation_type = OMAP_DSS_ROT_NONE;
> -		info->rotation      = DRM_MODE_ROTATE_0;
> -		info->screen_width  = plane->pitch;
> +		info->rotation = DRM_MODE_ROTATE_0;
> +		info->screen_width = plane->pitch;

These are also extra changes. There are other similar ones.

>  	}
>  
>  	/* convert to pixels: */
> @@ -238,11 +241,29 @@ void omap_framebuffer_update_scanout(struct drm_framebuffer *fb,
>  			omap_gem_rotated_dma_addr(plane->bo, orient, x/2, y/2,
>  						  &info->p_uv_addr);
>  		} else {
> -			info->p_uv_addr = get_linear_addr(plane, format, 1, x, y);
> +			info->p_uv_addr =
> +				get_linear_addr(plane, format, 1, x, y);
>  		}
>  	} else {
>  		info->p_uv_addr = 0;
>  	}
> +
> +	if (r_info) {
> +		info->width /= 2;
> +		info->out_width /= 2;
> +
> +		*r_info = *info;
> +
> +		r_info->pos_x = info->pos_x + info->out_width;
> +
> +		r_info->paddr =	get_linear_addr(&omap_fb->planes[0], format, 0,
> +						x + info->width, y);
> +		if (fb->format->format == DRM_FORMAT_NV12) {
> +			r_info->p_uv_addr =
> +				get_linear_addr(&omap_fb->planes[1], format, 1,
> +						x + info->width, y);
> +		}
> +	}
>  }
>  
>  /* pin, prepare for scanout: */
> diff --git a/drivers/gpu/drm/omapdrm/omap_fb.h b/drivers/gpu/drm/omapdrm/omap_fb.h
> index 94ad5f9e4404..8c116c1aac0d 100644
> --- a/drivers/gpu/drm/omapdrm/omap_fb.h
> +++ b/drivers/gpu/drm/omapdrm/omap_fb.h
> @@ -37,7 +37,9 @@ struct drm_framebuffer *omap_framebuffer_init(struct drm_device *dev,
>  int omap_framebuffer_pin(struct drm_framebuffer *fb);
>  void omap_framebuffer_unpin(struct drm_framebuffer *fb);
>  void omap_framebuffer_update_scanout(struct drm_framebuffer *fb,
> -		struct drm_plane_state *state, struct omap_overlay_info *info);
> +		struct drm_plane_state *state,
> +		struct omap_overlay_info *info,
> +		struct omap_overlay_info *r_info);
>  struct drm_connector *omap_framebuffer_get_next_connector(
>  		struct drm_framebuffer *fb, struct drm_connector *from);
>  bool omap_framebuffer_supports_rotation(struct drm_framebuffer *fb);
> diff --git a/drivers/gpu/drm/omapdrm/omap_overlay.c b/drivers/gpu/drm/omapdrm/omap_overlay.c
> new file mode 100644
> index 000000000000..0a1327c31b69
> --- /dev/null
> +++ b/drivers/gpu/drm/omapdrm/omap_overlay.c
> @@ -0,0 +1,366 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/*
> + * Copyright (C) 2018 Texas Instruments Incorporated -  http://www.ti.com/
> + * Author: Benoit Parrot, <bparrot@ti.com>
> + */
> +
> +#include <drm/drm_atomic.h>
> +#include <drm/drm_atomic_helper.h>
> +#include <drm/drm_plane_helper.h>
> +
> +#include "omap_dmm_tiler.h"
> +#include "omap_drv.h"
> +
> +/*
> + * overlay funcs
> + */
> +static void __maybe_unused
> +omap_overlay_atomic_print_state(struct drm_printer *p,
> +				const struct omap_global_state *state,
> +				struct omap_drm_private *priv)
> +{
> +	int i;
> +
> +	drm_printf(p, "\tomap_global_state=%p\n", state);
> +	if (state) {
> +		for (i = 0; i < priv->num_ovls; i++) {
> +			struct drm_plane *plane =
> +				state->overlay.hwoverlay_to_plane[i];
> +
> +			drm_printf(p, "\t\t[%d] plane=%p\n", i, plane);
> +			if (plane)
> +				drm_printf(p, "\t\t\t plane=%s\n", plane->name);
> +		}
> +	}
> +}
> +
> +/* Global/shared object state funcs */
> +
> +/*
> + * This is a helper that returns the private state currently in operation.
> + * Note that this would return the "old_state" if called in the atomic check
> + * path, and the "new_state" after the atomic swap has been done.
> + */
> +static struct omap_global_state *
> +omap_get_existing_global_state(struct omap_drm_private *priv)
> +{
> +	return to_omap_global_state(priv->glob_state.state);
> +}
> +
> +/*
> + * This acquires the modeset lock set aside for global state, creates
> + * a new duplicated private object state.
> + */
> +static struct omap_global_state *__must_check
> +omap_get_global_state(struct drm_atomic_state *s)
> +{
> +	struct omap_drm_private *priv = s->dev->dev_private;
> +	struct drm_private_state *priv_state;
> +	int ret;
> +
> +	while (1) {
> +		ret = drm_modeset_lock(&priv->glob_state_lock, s->acquire_ctx);
> +		if (ret != -EDEADLK)
> +			break;
> +
> +		drm_modeset_backoff(s->acquire_ctx);
> +	}
> +
> +	if (ret)
> +		return ERR_PTR(ret);
> +
> +	priv_state = drm_atomic_get_private_obj_state(s, &priv->glob_state);
> +	if (IS_ERR(priv_state))
> +		return ERR_CAST(priv_state);
> +
> +	return to_omap_global_state(priv_state);
> +}
> +
> +static struct drm_private_state *
> +omap_global_duplicate_state(struct drm_private_obj *obj)
> +{
> +	struct omap_global_state *state;
> +
> +	state = kmemdup(obj->state, sizeof(*state), GFP_KERNEL);
> +	if (!state)
> +		return NULL;
> +
> +	__drm_atomic_helper_private_obj_duplicate_state(obj, &state->base);
> +
> +	return &state->base;
> +}
> +
> +static void omap_global_destroy_state(struct drm_private_obj *obj,
> +				      struct drm_private_state *state)
> +{
> +	struct omap_global_state *omap_state = to_omap_global_state(state);
> +
> +	kfree(omap_state);
> +}
> +
> +static const struct drm_private_state_funcs omap_global_state_funcs = {
> +	.atomic_duplicate_state = omap_global_duplicate_state,
> +	.atomic_destroy_state = omap_global_destroy_state,
> +};
> +
> +int omap_global_obj_init(struct omap_drm_private *priv)
> +{
> +	struct omap_global_state *state;
> +
> +	drm_modeset_lock_init(&priv->glob_state_lock);
> +
> +	state = kzalloc(sizeof(*state), GFP_KERNEL);
> +	if (!state)
> +		return -ENOMEM;
> +
> +	drm_atomic_private_obj_init(&priv->glob_state,
> +				    &state->base,
> +				    &omap_global_state_funcs);
> +	return 0;
> +}
> +
> +void omap_global_obj_fini(struct omap_drm_private *priv)
> +{
> +	drm_atomic_private_obj_fini(&priv->glob_state);
> +	drm_modeset_lock_fini(&priv->glob_state_lock);
> +}
> +
> +static struct omap_hw_overlay *
> +omap_plane_find_free_overlay(struct drm_device *dev,
> +			     struct omap_hw_overlay_state *new_state,
> +			     u32 caps, u32 fourcc, u32 crtc_mask)
> +{
> +	struct omap_drm_private *priv = dev->dev_private;
> +	const struct dispc_ops *ops = priv->dispc_ops;
> +	int i;
> +
> +	DBG("caps: %x fourcc: %x crtc: %x\n", caps, fourcc, crtc_mask);
> +
> +	for (i = 0; i < priv->num_ovls; i++) {
> +		struct omap_hw_overlay *cur = priv->overlays[i];
> +	
> +		DBG("%d: id: %d cur->caps: %x cur->crtc: %x\n",
> +		    cur->idx, cur->overlay_id, cur->caps, cur->possible_crtcs);
> +
> +		/* skip if already in-use */
> +		if (new_state->hwoverlay_to_plane[cur->idx])
> +			continue;
> +
> +		/* check if allowed on crtc */
> +		if (!(cur->possible_crtcs & crtc_mask))
> +			continue;
> +
> +		/* skip if doesn't support some required caps: */
> +		if (caps & ~cur->caps)
> +			continue;
> +
> +		/* check supported format */
> +		if (!ops->ovl_color_mode_supported(priv->dispc,
> +						   cur->overlay_id,
> +						   fourcc))
> +			continue;
> +
> +		return cur;
> +	}
> +
> +	DBG("no match\n");
> +	return NULL;
> +}
> +
> +int omap_overlay_assign(struct drm_atomic_state *s, struct drm_plane *plane,
> +			u32 caps, u32 fourcc, u32 crtc_mask,
> +			struct omap_hw_overlay **overlay,
> +			struct omap_hw_overlay **r_overlay)
> +{
> +	struct omap_drm_private *priv = s->dev->dev_private;
> +	struct omap_global_state *new_global_state, *old_global_state;
> +	struct omap_hw_overlay_state *old_state, *new_state;
> +	struct omap_hw_overlay *ovl, *r_ovl;
> +
> +	new_global_state = omap_get_global_state(s);
> +	if (IS_ERR(new_global_state))
> +		return PTR_ERR(new_global_state);
> +
> +	/*
> +	 * grab old_state after omap_get_global_state(),
> +	 * since now we hold lock:
> +	 */
> +	old_global_state = omap_get_existing_global_state(priv);
> +	DBG("new_global_state: %p old_global_state: %p should be different (%d)",
> +	    new_global_state, old_global_state, new_global_state != old_global_state);
> +
> +	old_state = &old_global_state->overlay;
> +	new_state = &new_global_state->overlay;
> +
> +	if (!*overlay) {
> +		ovl = omap_plane_find_free_overlay(s->dev, new_state,
> +						   caps, fourcc, crtc_mask);
> +		if (!ovl)
> +			return -ENOMEM;
> +
> +		new_state->hwoverlay_to_plane[ovl->idx] = plane;
> +		*overlay = ovl;
> +
> +		if (r_overlay) {
> +			r_ovl = omap_plane_find_free_overlay(s->dev, new_state,
> +							     caps, fourcc,
> +							     crtc_mask);
> +			if (!r_ovl) {
> +				new_state->hwoverlay_to_plane[ovl->idx] = NULL;
> +				*overlay = NULL;
> +				return -ENOMEM;
> +			}
> +
> +			new_state->hwoverlay_to_plane[r_ovl->idx] = plane;
> +			*r_overlay = r_ovl;
> +		}
> +
> +
> +		DBG("%s: assign to plane %s for caps %x",
> +		    (*overlay)->name, plane->name, caps);
> +
> +		if (r_overlay) {
> +			DBG("%s: assign to right of plane %s for caps %x",
> +			    (*r_overlay)->name, plane->name, caps);
> +		}
> +	}
> +
> +	return 0;
> +}
> +
> +void omap_overlay_release(struct drm_atomic_state *s,
> +			  struct omap_hw_overlay *overlay)
> +{
> +	struct omap_global_state *state = omap_get_global_state(s);
> +	struct omap_hw_overlay_state *new_state = &state->overlay;
> +
> +	if (!overlay)
> +		return;
> +
> +	if (WARN_ON(!new_state->hwoverlay_to_plane[overlay->idx]))
> +		return;
> +
> +	DBG("%s: release from plane %s", overlay->name,
> +	    new_state->hwoverlay_to_plane[overlay->idx]->name);
> +
> +	new_state->hwoverlay_to_plane[overlay->idx] = NULL;
> +}
> +
> +/*
> + * This is called only from omap_atomic_commit_tail()
> + * as a cleanup step to make sure hw overlay which are no longer
> + * are disabled.
> + *
> + * I was originally taking the glob_state_lock here by calling
> + * omap_get_global_state(s) but doing so here was causing all kind
> + * lock related warnings, for instance:
> + *  WARNING: CPU: 0 PID: 68 at drivers/gpu/drm/drm_modeset_lock.c:241
> + * and
> + *  WARNING: CPU: 0 PID: 68 at drivers/gpu/drm/drm_modeset_lock.c:244
> + * As well as also generating these:
> + *  ==================================
> + *  WARNING: Nested lock was not taken
> + *  4.18.0-rc2-00055-g5d51e5159b0a #24 Tainted: G        W
> + *  ----------------------------------
> + *  kworker/u2:3/66 is trying to lock:
> + *  51abea2e (crtc_ww_class_mutex){+.+.}, at: drm_modeset_lock+0xd0/0x140
> + *
> + *  but this task is not holding:
> + *  �21
> + *
> + * The only thing that worked so far was to stop trying to take that lock
> + * in this particular case. It might the real solution but I would like
> + * to sure.
> + */
> +void omap_overlay_disable_unassigned(struct drm_atomic_state *s)
> +{
> +	struct omap_drm_private *priv = s->dev->dev_private;
> +	struct omap_hw_overlay_state *new_state;
> +	struct omap_global_state *old_state;
> +	int i;
> +
> +	old_state = omap_get_existing_global_state(priv);
> +	new_state = &old_state->overlay;
> +
> +	for (i = 0; i < priv->num_ovls; i++) {
> +		struct omap_hw_overlay *cur = priv->overlays[i];
> +
> +		if (!new_state->hwoverlay_to_plane[cur->idx]) {
> +			priv->dispc_ops->ovl_enable(priv->dispc,
> +						    cur->overlay_id,
> +						    false);
> +
> +			/*
> +			 * Since we are disabling this overlay in this
> +			 * atomic cycle we can reset the avalaible crtcs
> +			 * it can be used on
> +			 */
> +			cur->possible_crtcs = (1 << priv->num_crtcs) - 1;
> +		}
> +	}
> +}
> +
> +void omap_overlay_destroy(struct omap_hw_overlay *overlay)
> +{
> +	kfree(overlay);
> +}
> +
> +static struct omap_hw_overlay *omap_overlay_init(enum omap_plane_id overlay_id,
> +						 enum omap_overlay_caps caps)
> +{
> +	struct omap_hw_overlay *overlay;
> +
> +	overlay = kzalloc(sizeof(*overlay), GFP_KERNEL);
> +	if (!overlay)
> +		return ERR_PTR(-ENOMEM);
> +
> +	overlay->name = overlay2name(overlay_id);
> +	overlay->overlay_id = overlay_id;
> +	overlay->caps = caps;
> +	/* 
> +	 * When this is called priv->num_crtcs is not known yet.
> +	 * Use a safe mask value to start with, it will get updated to the
> +	 * proper value after the first use.
> +	 */
> +	overlay->possible_crtcs = 0xff;
> +
> +	return overlay;
> +}
> +
> +int omap_hwoverlays_init(struct omap_drm_private *priv)
> +{
> +	static const enum omap_plane_id overlays[] = {
> +			OMAP_DSS_GFX, OMAP_DSS_VIDEO1,
> +			OMAP_DSS_VIDEO2, OMAP_DSS_VIDEO3,
> +	};
> +	u32 num_overlays = priv->dispc_ops->get_num_ovls(priv->dispc);
> +	enum omap_overlay_caps caps;
> +	int i, ret;
> +
> +	for (i = 0; i < num_overlays; i++) {
> +		struct omap_hw_overlay *overlay;
> +
> +		caps = priv->dispc_ops->ovl_get_caps(priv->dispc, overlays[i]);
> +		overlay = omap_overlay_init(overlays[i], caps);
> +		if (IS_ERR(overlay)) {
> +			ret = PTR_ERR(overlay);
> +			dev_err(priv->dev, "failed to construct overlay for %s (%d)\n",
> +				overlay2name(i), ret);
> +			return ret;
> +		}
> +		overlay->idx = priv->num_ovls;
> +		priv->overlays[priv->num_ovls++] = overlay;
> +	}
> +
> +	return 0;
> +}
> +
> +void omap_hwoverlays_destroy(struct omap_drm_private *priv)
> +{
> +	int i;
> +
> +	for (i = 0; i < priv->num_ovls; i++) {
> +		omap_overlay_destroy(priv->overlays[i]);
> +		priv->overlays[i] = NULL;
> +	}
> +}
> diff --git a/drivers/gpu/drm/omapdrm/omap_overlay.h b/drivers/gpu/drm/omapdrm/omap_overlay.h
> new file mode 100644
> index 000000000000..ed94a260ba10
> --- /dev/null
> +++ b/drivers/gpu/drm/omapdrm/omap_overlay.h
> @@ -0,0 +1,80 @@
> +/* SPDX-License-Identifier: GPL-2.0 */
> +/*
> + * Copyright (C) 2018 Texas Instruments Incorporated -  http://www.ti.com/
> + * Author: Benoit Parrot, <bparrot@ti.com>
> + */
> +
> +#ifndef __OMAPDRM_OVERLAY_H__
> +#define __OMAPDRM_OVERLAY_H__
> +
> +#include <linux/types.h>
> + 
> +enum drm_plane_type;
> +
> +struct drm_device;
> +struct drm_mode_object;
> +struct drm_plane;
> +
> +/* Used to associate a HW overlay/plane to a plane */
> +struct omap_hw_overlay {
> +	int idx;
> +
> +	const char *name;
> +	enum omap_plane_id overlay_id;
> +
> +	enum omap_overlay_caps caps;
> +	/*
> +	 * The CRTC(s) this overlay is currently allowed on.
> +	 * When the overlay is unused and was not assigned to any crtc then
> +	 * this will be the equal to the plane possible_crtcs otherwise it
> +	 * will be the current crtc this overlay is displayed on.
> +	 * When clearing the overlay to plane assignemnt while going through
> +	 * an atomic_check sequence we need to remember which crtc the overlay
> +	 * was on as we do not want to create flicker. We want to be able to
> +	 * reassign the overlay to the same crtc it was previously on.
> +	 */
> +	u32 possible_crtcs;
> +	/* Reference to the associated drm_plane */
> +	struct drm_plane *plane;
> +};
> +
> +/* global atomic state of assignment between pipes and planes: */
> +struct omap_hw_overlay_state {
> +	struct drm_plane *hwoverlay_to_plane[8];
> +};
> +
> +/* Global private object state for tracking resources that are shared across
> + * multiple kms objects (planes/crtcs/etc).
> + */

This doesn't follow the kernel comment style.

> +#define to_omap_global_state(x) container_of(x, struct omap_global_state, base)
> +struct omap_global_state {
> +	struct drm_private_state base;
> +
> +	struct drm_atomic_state *state;
> +
> +	struct omap_hw_overlay_state overlay;
> +};
> +
> +static inline const char *overlay2name(enum omap_plane_id id)
> +{
> +	static const char *name[] = {
> +		[OMAP_DSS_GFX] = "gfx",
> +		[OMAP_DSS_VIDEO1] = "vid1",
> +		[OMAP_DSS_VIDEO2] = "vid2",
> +		[OMAP_DSS_VIDEO3] = "vid3",
> +	};
> +	return name[id];
> +}
> +
> +int omap_hwoverlays_init(struct omap_drm_private *priv);
> +void omap_global_obj_fini(struct omap_drm_private *priv);
> +void omap_hwoverlays_destroy(struct omap_drm_private *priv);
> +int omap_global_obj_init(struct omap_drm_private *priv);
> +int omap_overlay_assign(struct drm_atomic_state *s, struct drm_plane *plane,
> +			u32 caps, u32 fourcc, u32 crtc_mask,
> +			struct omap_hw_overlay **overlay,
> +			struct omap_hw_overlay **r_overlay);
> +void omap_overlay_release(struct drm_atomic_state *s, struct omap_hw_overlay *overlay);
> +void omap_overlay_disable_unassigned(struct drm_atomic_state *s);
> +
> +#endif /* __OMAPDRM_OVERLAY_H__ */
> diff --git a/drivers/gpu/drm/omapdrm/omap_plane.c b/drivers/gpu/drm/omapdrm/omap_plane.c
> index 161233cbc9a0..01f1da155994 100644
> --- a/drivers/gpu/drm/omapdrm/omap_plane.c
> +++ b/drivers/gpu/drm/omapdrm/omap_plane.c
> @@ -30,10 +30,12 @@
>  
>  struct omap_plane {
>  	struct drm_plane base;
> -	enum omap_plane_id id;
> +	enum omap_plane_id default_id;
>  	const char *name;
>  };
>  
> +static const char *plane_id_to_name[];
> +
>  static int omap_plane_prepare_fb(struct drm_plane *plane,
>  				 struct drm_plane_state *new_state)
>  {
> @@ -50,15 +52,26 @@ static void omap_plane_cleanup_fb(struct drm_plane *plane,
>  		omap_framebuffer_unpin(old_state->fb);
>  }
>  
> +static bool plane_enabled(struct drm_plane_state *state)
> +{
> +	return state->visible;
> +}
> +
>  static void omap_plane_atomic_update(struct drm_plane *plane,
>  				     struct drm_plane_state *old_state)
>  {
>  	struct omap_drm_private *priv = plane->dev->dev_private;
>  	struct omap_plane *omap_plane = to_omap_plane(plane);
>  	struct drm_plane_state *state = plane->state;
> -	struct omap_overlay_info info;
> +	struct omap_plane_state *omap_state = to_omap_plane_state(state);
> +	struct omap_overlay_info info, r_info;
> +	enum omap_plane_id ovl_id, r_ovl_id;
>  	int ret;
> +	bool dual_plane = !!omap_state->r_overlay;
>  
> +	ovl_id = omap_state->overlay->overlay_id;
> +	DBG("[PLANE:%d:%s] overlay_id: %d\n", plane->base.id, plane->name,
> +	    ovl_id);
>  	DBG("%s, crtc=%p fb=%p", omap_plane->name, state->crtc, state->fb);
>  
>  	memset(&info, 0, sizeof(info));
> @@ -67,75 +80,231 @@ static void omap_plane_atomic_update(struct drm_plane *plane,
>  	info.global_alpha = 0xff;
>  	info.zorder = state->normalized_zpos;
>  
> +	r_info = info;
> +
>  	/* update scanout: */
> -	omap_framebuffer_update_scanout(state->fb, state, &info);
> +	omap_framebuffer_update_scanout(state->fb, state, &info,
> +					dual_plane ? &r_info : NULL);
>  
> -	DBG("%dx%d -> %dx%d (%d)", info.width, info.height,
> -			info.out_width, info.out_height,
> -			info.screen_width);
> +	DBG("%s: %dx%d -> %dx%d (%d)",
> +	    overlay2name(ovl_id), info.width, info.height,
> +	    info.out_width, info.out_height, info.screen_width);
>  	DBG("%d,%d %pad %pad", info.pos_x, info.pos_y,
> -			&info.paddr, &info.p_uv_addr);
> +	    &info.paddr, &info.p_uv_addr);
> +
> +	if (dual_plane) {
> +		r_ovl_id = omap_state->r_overlay->overlay_id;
> +		/*
> +		 * If the current plane uses 2 hw planes the very next
> +		 * zorder is used by the r_overlay so we just use the
> +		 * main overlay zorder + 1
> +		 */
> +		r_info.zorder = info.zorder + 1;
> +
> +		DBG("%s: %dx%d -> %dx%d (%d)",
> +		    overlay2name(r_ovl_id), r_info.width, r_info.height,
> +		    r_info.out_width, r_info.out_height, r_info.screen_width);
> +		DBG("%d,%d %pad %pad", r_info.pos_x, r_info.pos_y,
> +		    &r_info.paddr, &r_info.p_uv_addr);
> +	}
>  
>  	/* and finally, update omapdss: */
> -	ret = priv->dispc_ops->ovl_setup(priv->dispc, omap_plane->id, &info,
> +	ret = priv->dispc_ops->ovl_setup(priv->dispc, ovl_id, &info,
>  			      omap_crtc_timings(state->crtc), false,
>  			      omap_crtc_channel(state->crtc));
>  	if (ret) {
> -		dev_err(plane->dev->dev, "Failed to setup plane %s\n",
> +		dev_err(plane->dev->dev, "Failed to setup plane1 %s\n",
>  			omap_plane->name);
> -		priv->dispc_ops->ovl_enable(priv->dispc, omap_plane->id, false);
> +		priv->dispc_ops->ovl_enable(priv->dispc, ovl_id, false);
>  		return;
>  	}
>  
> -	priv->dispc_ops->ovl_enable(priv->dispc, omap_plane->id, true);
> +	priv->dispc_ops->ovl_enable(priv->dispc, ovl_id, true);
> +
> +	if (dual_plane) {
> +		ret = priv->dispc_ops->ovl_setup(priv->dispc, r_ovl_id, &r_info,
> +				      omap_crtc_timings(state->crtc), false,
> +				      omap_crtc_channel(state->crtc));
> +		if (ret) {
> +			dev_err(plane->dev->dev, "Failed to setup plane2 %s\n",
> +				omap_plane->name);
> +			priv->dispc_ops->ovl_enable(priv->dispc, r_ovl_id, false);
> +			priv->dispc_ops->ovl_enable(priv->dispc, ovl_id, false);
> +			return;
> +		}
> +
> +		priv->dispc_ops->ovl_enable(priv->dispc, r_ovl_id, true);
> +	}
>  }
>  
>  static void omap_plane_atomic_disable(struct drm_plane *plane,
>  				      struct drm_plane_state *old_state)
>  {
>  	struct omap_drm_private *priv = plane->dev->dev_private;
> -	struct omap_plane *omap_plane = to_omap_plane(plane);
> +	struct omap_plane_state *omap_state = to_omap_plane_state(old_state);
> +	bool dual_plane = !!omap_state->r_overlay;
> +
> +	DBG("%s: check (overlay %p r_overlay %p)", plane->name,
> +	    omap_state->overlay, omap_state->r_overlay);
> +
> +	if (!omap_state->overlay)
> +		return;
>  
>  	plane->state->rotation = DRM_MODE_ROTATE_0;
>  	plane->state->zpos = plane->type == DRM_PLANE_TYPE_PRIMARY
> -			   ? 0 : omap_plane->id;
> -
> -	priv->dispc_ops->ovl_enable(priv->dispc, omap_plane->id, false);
> +			   ? 0 : omap_state->overlay->overlay_id;
> +
> +	priv->dispc_ops->ovl_enable(priv->dispc, omap_state->overlay->overlay_id, false);
> +	omap_overlay_release(old_state->state, omap_state->overlay);
> +	omap_state->overlay = NULL;
> +	if (dual_plane) {
> +		priv->dispc_ops->ovl_enable(priv->dispc, omap_state->r_overlay->overlay_id, false);
> +		omap_overlay_release(old_state->state, omap_state->r_overlay);
> +		omap_state->r_overlay = NULL;
> +	}
>  }
>  
> +#define FRAC_16_16(mult, div)    (((mult) << 16) / (div))
>  static int omap_plane_atomic_check(struct drm_plane *plane,
>  				   struct drm_plane_state *state)
>  {
> +	struct omap_drm_private *priv = plane->dev->dev_private;
> +	struct drm_crtc *crtc;	
>  	struct drm_crtc_state *crtc_state;
> +	struct drm_plane_state *old_state = plane->state;
> +	struct omap_plane_state *omap_state = to_omap_plane_state(state);
> +	const struct dispc_ops *ops = priv->dispc_ops;
> +	u16 width, height;
> +	u32 crtc_mask;
> +	u32 fourcc;
> +	u32 caps = 0;
> +	bool new_hw_overlay = false;
> +	bool new_r_hw_overlay = false;
> +	bool out_of_bounds = false;
> +	int min_scale, max_scale;
> +	u32 max_width, max_height;
> +	int ret;
>  
> -	if (!state->fb)
> -		return 0;
> +	DBG("%s: check (%d -> %d)", plane->name,
> +	    plane_enabled(old_state), plane_enabled(state));
> +
> +	priv->dispc_ops->ovl_get_max_size(priv->dispc, &width, &height);
> +	max_width = width << 16;
> +	max_height = height << 16;
>  
> -	/* crtc should only be NULL when disabling (i.e., !state->fb) */
> -	if (WARN_ON(!state->crtc))
> +	crtc = state->crtc ? state->crtc : plane->state->crtc;
> +	if (!crtc)
>  		return 0;
>  
> -	crtc_state = drm_atomic_get_existing_crtc_state(state->state, state->crtc);
> +	crtc_state = drm_atomic_get_existing_crtc_state(state->state, crtc);
>  	/* we should have a crtc state if the plane is attached to a crtc */
>  	if (WARN_ON(!crtc_state))
>  		return 0;
>  
> -	if (!crtc_state->enable)
> -		return 0;
> +	/* Make sure source dimensions are within bounds. */
> +	if (state->src_h > max_height)
> +		out_of_bounds = true;
>  
> -	if (state->crtc_x < 0 || state->crtc_y < 0)
> -		return -EINVAL;
> +	if (state->src_w > max_width) {
> +		if (state->src_w <= (2 * max_width))
> +			new_r_hw_overlay = true;
> +		else
> +			out_of_bounds = true;
> +	}
>  
> -	if (state->crtc_x + state->crtc_w > crtc_state->adjusted_mode.hdisplay)
> -		return -EINVAL;
> +	if (out_of_bounds) {
> +		struct drm_rect src = drm_plane_state_src(state);
> +		DBG("Invalid source size "DRM_RECT_FP_FMT,
> +		    DRM_RECT_FP_ARG(&src));
> +		return -ERANGE;
> +	}
>  
> -	if (state->crtc_y + state->crtc_h > crtc_state->adjusted_mode.vdisplay)
> -		return -EINVAL;
> +	min_scale = FRAC_16_16(1, 4);
> +	max_scale = FRAC_16_16(8, 1);
> +
> +	ret = drm_atomic_helper_check_plane_state(state, crtc_state,
> +						  min_scale, max_scale,
> +						  true, true);
> +	if (ret)
> +		return ret;
>  
>  	if (state->rotation != DRM_MODE_ROTATE_0 &&
>  	    !omap_framebuffer_supports_rotation(state->fb))
>  		return -EINVAL;
>  
> +	if (plane_enabled(state)) {
> +		if ((state->src_w >> 16) != state->crtc_w ||
> +		    (state->src_h >> 16) != state->crtc_h)
> +			caps |= OMAP_DSS_OVL_CAP_SCALE;
> +
> +		fourcc = state->fb->format->format;
> +		crtc_mask = drm_crtc_mask(state->crtc);
> +
> +		/* (re)allocate hw overlay if we don't have one or caps-mismatch: */
> +		if (!omap_state->overlay || (caps & ~omap_state->overlay->caps)) {
> +			new_hw_overlay = true;
> +		} else {
> +			/* check if allowed on crtc */
> +			if (!(omap_state->overlay->possible_crtcs & crtc_mask))
> +				new_hw_overlay = true;
> +
> +			/* check supported format */
> +			if (!ops->ovl_color_mode_supported(priv->dispc,
> +						omap_state->overlay->overlay_id,
> +						fourcc))
> +				new_hw_overlay = true;
> +		}
> +		/* 
> +		 * check if we need two overlays and only have 1 or
> +		 * if we had 2 overlays but will only need 1
> +		 */ 
> +		if ((new_r_hw_overlay && !omap_state->r_overlay) ||
> +		    (!new_r_hw_overlay && omap_state->r_overlay))
> +			new_hw_overlay = true;
> +
> +		if (new_hw_overlay) {
> +			struct omap_hw_overlay *old_ovl = 
> +						omap_state->overlay;
> +			struct omap_hw_overlay *old_r_ovl = 
> +						omap_state->r_overlay;
> +			struct omap_hw_overlay *new_ovl = NULL;
> +			struct omap_hw_overlay *new_r_ovl = NULL;
> +
> +			omap_overlay_release(state->state, old_ovl);
> +			omap_overlay_release(state->state, old_r_ovl);
> +
> +			ret = omap_overlay_assign(state->state, plane, caps,
> +						  fourcc, crtc_mask, &new_ovl,
> +						  new_r_hw_overlay ?
> +						  &new_r_ovl : NULL);
> +			if (ret) {
> +				DBG("%s: failed to assign hw_overlay(s)!",
> +				    plane->name);
> +				omap_state->overlay = NULL;
> +				omap_state->r_overlay = NULL;
> +				return ret;
> +			}
> +
> +			omap_state->overlay = new_ovl;
> +			if (new_r_hw_overlay)
> +				omap_state->r_overlay = new_r_ovl;
> +			else
> +				omap_state->r_overlay = NULL;
> +		}
> +	} else {
> +		omap_overlay_release(state->state, omap_state->overlay);
> +		omap_overlay_release(state->state, omap_state->r_overlay);
> +		omap_state->overlay = NULL;
> +		omap_state->r_overlay = NULL;
> +	}
> +
> +	if (omap_state->overlay)
> +		DBG("plane: %s overlay_id: %d", plane->name,
> +		    omap_state->overlay->overlay_id);
> +	if (omap_state->r_overlay)
> +		DBG("plane: %s r_overlay_id: %d", plane->name,
> +		    omap_state->r_overlay->overlay_id);
> +
>  	return 0;
>  }
>  
> @@ -182,20 +351,77 @@ void omap_plane_install_properties(struct drm_plane *plane,
>  	drm_object_attach_property(obj, priv->zorder_prop, 0);
>  }
>  
> +/* Add duplicate and destroy state helper */
> +static struct drm_plane_state *
> +omap_plane_atomic_duplicate_state(struct drm_plane *plane)
> +{
> +	struct omap_plane_state *state;
> +	struct omap_plane_state *copy;
> +
> +	if (WARN_ON(!plane->state))
> +		return NULL;
> +
> +	state = to_omap_plane_state(plane->state);
> +	copy = kmemdup(state, sizeof(*state), GFP_KERNEL);
> +	if (copy == NULL)
> +		return NULL;
> +
> +	__drm_atomic_helper_plane_duplicate_state(plane, &copy->base);
> +
> +	return &copy->base;
> +}
> +
> +static void omap_plane_atomic_destroy_state(struct drm_plane *plane,
> +					    struct drm_plane_state *state)
> +{
> +	__drm_atomic_helper_plane_destroy_state(state);
> +	kfree(to_omap_plane_state(state));
> +}
> +
>  static void omap_plane_reset(struct drm_plane *plane)
>  {
>  	struct omap_plane *omap_plane = to_omap_plane(plane);
> +	struct omap_plane_state *omap_state;
> +
> +	if (plane->state)
> +		omap_plane_atomic_destroy_state(plane, plane->state);
>  
> -	drm_atomic_helper_plane_reset(plane);
> -	if (!plane->state)
> +	omap_state = kzalloc(sizeof(*omap_state), GFP_KERNEL);
> +	if (!omap_state)
>  		return;
>  
> +	omap_state->base.plane = plane;
> +	plane->state = &omap_state->base;
> +	plane->state->plane = plane;
> +	plane->state->rotation = DRM_MODE_ROTATE_0;
>  	/*
>  	 * Set the zpos default depending on whether we are a primary or overlay
>  	 * plane.
>  	 */
>  	plane->state->zpos = plane->type == DRM_PLANE_TYPE_PRIMARY
> -			   ? 0 : omap_plane->id;
> +			   ? 0 : omap_plane->default_id;
> +}
> +
> +static void omap_plane_atomic_print_state(struct drm_printer *p,
> +		const struct drm_plane_state *state)
> +{
> +	struct omap_plane_state *omap_state = to_omap_plane_state(state);
> +
> +	drm_printf(p, "\toverlay=%p\n", omap_state->overlay);
> +	if (omap_state->overlay) {
> +		drm_printf(p, "\t\tidx=%d\n", omap_state->overlay->idx);
> +		drm_printf(p, "\t\toverlay_id=%d\n", omap_state->overlay->overlay_id);
> +		drm_printf(p, "\t\tcaps=0x%x\n", omap_state->overlay->caps);
> +		drm_printf(p, "\t\tpossible_crtcs=0x%x\n", omap_state->overlay->possible_crtcs);
> +	}
> +
> +	drm_printf(p, "\tr_overlay=%p\n", omap_state->r_overlay);
> +	if (omap_state->r_overlay) {
> +		drm_printf(p, "\t\tidx=%d\n", omap_state->r_overlay->idx);
> +		drm_printf(p, "\t\toverlay_id=%d\n", omap_state->r_overlay->overlay_id);
> +		drm_printf(p, "\t\tcaps=0x%x\n", omap_state->r_overlay->caps);
> +		drm_printf(p, "\t\tpossible_crtcs=0x%x\n", omap_state->r_overlay->possible_crtcs);
> +	}
>  }
>  
>  static int omap_plane_atomic_set_property(struct drm_plane *plane,
> @@ -233,10 +459,11 @@ static const struct drm_plane_funcs omap_plane_funcs = {
>  	.disable_plane = drm_atomic_helper_disable_plane,
>  	.reset = omap_plane_reset,
>  	.destroy = omap_plane_destroy,
> -	.atomic_duplicate_state = drm_atomic_helper_plane_duplicate_state,
> -	.atomic_destroy_state = drm_atomic_helper_plane_destroy_state,
> +	.atomic_duplicate_state = omap_plane_atomic_duplicate_state,
> +	.atomic_destroy_state = omap_plane_atomic_destroy_state,
>  	.atomic_set_property = omap_plane_atomic_set_property,
>  	.atomic_get_property = omap_plane_atomic_get_property,
> +	.atomic_print_state = omap_plane_atomic_print_state,
>  };
>  
>  static const char *plane_id_to_name[] = {
> @@ -246,14 +473,6 @@ static const char *plane_id_to_name[] = {
>  	[OMAP_DSS_VIDEO3] = "vid3",
>  };
>  
> -static const enum omap_plane_id plane_idx_to_id[] = {
> -	OMAP_DSS_GFX,
> -	OMAP_DSS_VIDEO1,
> -	OMAP_DSS_VIDEO2,
> -	OMAP_DSS_VIDEO3,
> -};
> -
> -/* initialize plane */
>  struct drm_plane *omap_plane_init(struct drm_device *dev,
>  		int idx, enum drm_plane_type type,
>  		u32 possible_crtcs)
> @@ -262,27 +481,28 @@ struct drm_plane *omap_plane_init(struct drm_device *dev,
>  	unsigned int num_planes = priv->dispc_ops->get_num_ovls(priv->dispc);
>  	struct drm_plane *plane;
>  	struct omap_plane *omap_plane;
> -	enum omap_plane_id id;
>  	int ret;
>  	u32 nformats;
>  	const u32 *formats;
>  
> -	if (WARN_ON(idx >= ARRAY_SIZE(plane_idx_to_id)))
> +	if (WARN_ON(idx >= num_planes))
>  		return ERR_PTR(-EINVAL);
>  
> -	id = plane_idx_to_id[idx];
> -
> -	DBG("%s: type=%d", plane_id_to_name[id], type);
> -
>  	omap_plane = kzalloc(sizeof(*omap_plane), GFP_KERNEL);
>  	if (!omap_plane)
>  		return ERR_PTR(-ENOMEM);
>  
> -	formats = priv->dispc_ops->ovl_get_color_modes(priv->dispc, id);
> +	omap_plane->default_id = idx;
> +	omap_plane->name = plane_id_to_name[idx];
> +
> +	DBG("%s: type=%d", omap_plane->name, type);
> +	DBG("	omap_plane->default_id: %d", omap_plane->default_id);
> +	DBG("	crtc_mask: 0x%04x", possible_crtcs);
> +
> +	formats = priv->dispc_ops->ovl_get_color_modes(priv->dispc,
> +						       omap_plane->default_id);
>  	for (nformats = 0; formats[nformats]; ++nformats)
>  		;
> -	omap_plane->id = id;
> -	omap_plane->name = plane_id_to_name[id];
>  
>  	plane = &omap_plane->base;
>  
> @@ -301,7 +521,7 @@ struct drm_plane *omap_plane_init(struct drm_device *dev,
>  
>  error:
>  	dev_err(dev->dev, "%s(): could not create plane: %s\n",
> -		__func__, plane_id_to_name[id]);
> +		__func__, omap_plane->name);
>  
>  	kfree(omap_plane);
>  	return NULL;
> diff --git a/drivers/gpu/drm/omapdrm/omap_plane.h b/drivers/gpu/drm/omapdrm/omap_plane.h
> index dc5e82ad061d..9000f45a9b65 100644
> --- a/drivers/gpu/drm/omapdrm/omap_plane.h
> +++ b/drivers/gpu/drm/omapdrm/omap_plane.h
> @@ -28,10 +28,30 @@ struct drm_device;
>  struct drm_mode_object;
>  struct drm_plane;
>  
> +/*
> + * Atomic plane state. Subclasses the base drm_plane_state in order to
> + * track assigned overlay and hw specific state.
> + */
> +struct omap_plane_state {
> +	struct drm_plane_state base;
> +
> +	struct omap_hw_overlay *overlay;
> +	struct omap_hw_overlay *r_overlay;  /* right overlay */
> +};
> +#define to_omap_plane_state(x) \
> +		container_of(x, struct omap_plane_state, base)
> +
>  struct drm_plane *omap_plane_init(struct drm_device *dev,
>  		int idx, enum drm_plane_type type,
>  		u32 possible_crtcs);
>  void omap_plane_install_properties(struct drm_plane *plane,
>  		struct drm_mode_object *obj);
>  
> +static inline bool is_omap_plane_dual_overlay(struct drm_plane_state *state)
> +{
> +	struct omap_plane_state *omap_state = to_omap_plane_state(state);
> +
> +	return !!omap_state->r_overlay;
> +}
> +
>  #endif /* __OMAPDRM_PLANE_H__ */
> 

-- 
Texas Instruments Finland Oy, Porkkalankatu 22, 00180 Helsinki.
Y-tunnus/Business ID: 0615521-4. Kotipaikka/Domicile: Helsinki
_______________________________________________
dri-devel mailing list
dri-devel@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/dri-devel