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 <[email protected]> > --- > 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, <[email protected]> > + */ > + > +#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, <[email protected]> > + */ > + > +#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, ©->base); > + > + return ©->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 [email protected] https://lists.freedesktop.org/mailman/listinfo/dri-devel
