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

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



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@xxxxxx>
> ---
>  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@xxxxxx>
> + */
> +
> +#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@xxxxxx>
> + */
> +
> +#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@xxxxxxxxxxxxxxxxxxxxx
https://lists.freedesktop.org/mailman/listinfo/dri-devel





[Index of Archives]     [Linux DRI Users]     [Linux Intel Graphics]     [Linux USB Devel]     [Video for Linux]     [Linux Audio Users]     [Yosemite News]     [Linux Kernel]     [Linux SCSI]     [XFree86]     [Linux USB Devel]     [Video for Linux]     [Linux Audio Users]     [Linux Kernel]     [Linux SCSI]     [XFree86]
  Powered by Linux