lib/scatterlist: Add contiguous DMA chunks helpers
PATCH 1/6 lib/scatterlist: Add contiguous DMA chunks helpers
From: Thierry Reding <[email protected]>
Add a few helpers to count the number of contiguous DMA chunks found in an SG table. This is useful to determine whether or not a mapping can be used by drivers whose devices need contiguous memory.
--- include/linux/scatterlist.h | 11 +++++++++++ lib/scatterlist.c | 26 ++++++++++++++++++++++++++ 2 files changed, 37 insertions(+)
include/linux/scatterlist.h +11 -0
@@ -281,6 +281,7 @@ int sg_split(struct scatterlist *in, const int in_mapped_nents,const size_t *split_sizes, struct scatterlist **out, int *out_mapped_nents, gfp_t gfp_mask); +unsigned int sg_dma_count_chunks (struct scatterlist *sgl,unsigned int nents);typedef struct scatterlist *(sg_alloc_fn )(unsigned int ,gfp_t );typedef void (sg_free_fn )(struct scatterlist *,unsigned int );
@@ -358,6 +359,16 @@ size_t sg_pcopy_to_buffer(struct scatterlist *sgl, unsigned int nents,size_t sg_zero_buffer (struct scatterlist *sgl,unsigned int nents,size_t buflen,off_t skip); +static inline unsigned int sgt_dma_count_chunks (struct sg_table *sgt) +{ +return sg_dma_count_chunks (sgt->sgl, sgt->nents); +} + +static inline bool sgt_dma_contiguous (struct sg_table *sgt) +{ +return sgt_dma_count_chunks (sgt) ==1 ; +} +/* * Maximum number of entries that will be allocated in one piece, if * a list larger than this is required then chaining will be utilized.
lib/scatterlist.c +26 -0
@@ -142,6 +142,32 @@ void sg_init_one(struct scatterlist *sg, const void *buf, unsigned int buflen) }EXPORT_SYMBOL (sg_init_one); +/** +* sg_dma_count_chunks - return number of contiguous DMA chunks in scatterlist +* @sgl: SG table +* @nents: number of entries in SG table +*/ +unsigned int sg_dma_count_chunks (struct scatterlist *sgl,unsigned int nents) +{ +dma_addr_t next = ~(dma_addr_t )0 ; +unsigned int count =0 , i; +struct scatterlist *s; + +for_each_sg (sgl, s, nents, i) { +/* sg_dma_address(s) is only valid for entries that have sg_dma_len(s) != 0. */ +if (!sg_dma_len (s)) +continue ; + +if (sg_dma_address (s) != next) { + next =sg_dma_address (s) +sg_dma_len (s); + count++; + } + } + +return count; +} +EXPORT_SYMBOL (sg_dma_count_chunks); +/* * The default behaviour of sg_alloc_table() is to use these kmalloc/kfree * helpers.
Signature · 1 line
2.33.0
PATCH 2/6 drm/tegra: Implement correct DMA-BUF semantics
From: Thierry Reding <[email protected]>
DMA-BUF requires that each device that accesses a DMA-BUF attaches to it separately. To do so the host1x_bo_pin() and host1x_bo_unpin() functions need to be reimplemented so that they can return a mapping, which either represents an attachment or a map of the driver's own GEM object.
--- drivers/gpu/drm/tegra/gem.c | 138 +++++++++++++++------------- drivers/gpu/drm/tegra/plane.c | 60 ++++--------- drivers/gpu/drm/tegra/plane.h | 2 +- drivers/gpu/drm/tegra/submit.c | 63 +++++++++---- drivers/gpu/drm/tegra/uapi.c | 68 ++++++-------- drivers/gpu/drm/tegra/uapi.h | 5 +- drivers/gpu/host1x/job.c | 158 ++++++++++++--------------------- drivers/gpu/host1x/job.h | 6 +- include/linux/host1x.h | 30 ++++--- 9 files changed, 244 insertions(+), 286 deletions(-)
drivers/gpu/drm/tegra/gem.c +77 -61
@@ -27,79 +27,64 @@ static void tegra_bo_put(struct host1x_bo *bo)drm_gem_object_put (&obj->gem); } -/* XXX move this into lib/scatterlist.c? */ -static int sg_alloc_table_from_sg (struct sg_table *sgt,struct scatterlist *sg, -unsigned int nents,gfp_t gfp_mask) +static struct host1x_bo_mapping *tegra_bo_pin (struct device *dev,struct host1x_bo *bo, +enum dma_data_direction direction) { -struct scatterlist *dst; -unsigned int i; +struct tegra_bo *obj =host1x_to_tegra_bo (bo); +struct drm_gem_object *gem = &obj->gem; +struct host1x_bo_mapping *map;int err; - err =sg_alloc_table (sgt, nents, gfp_mask); -if (err <0 ) -return err; + map =kzalloc (sizeof (*map),GFP_KERNEL ); +if (!map) +return ERR_PTR (-ENOMEM ); - dst = sgt->sgl; + map->bo =host1x_bo_get (bo); + map->direction = direction; + map->dev = dev; -for (i =0 ; i < nents; i++) { -sg_set_page (dst,sg_page (sg), sg->length,0 ); - dst =sg_next (dst); - sg =sg_next (sg); - } +/* +* Imported buffers need special treatment to satisfy the semantics of DMA-BUF. +*/ +if (gem->import_attach) { +struct dma_buf *buf = gem->import_attach->dmabuf; -return 0 ; -} + map->attach =dma_buf_attach (buf, dev); +if (IS_ERR (map->attach)) { + err =PTR_ERR (map->attach); + goto free; + } -static struct sg_table *tegra_bo_pin (struct device *dev,struct host1x_bo *bo, -dma_addr_t *phys) -{ -struct tegra_bo *obj =host1x_to_tegra_bo (bo); -struct sg_table *sgt; -int err; + map->sgt =dma_buf_map_attachment (map->attach, direction); +if (IS_ERR (map->sgt)) { +dma_buf_detach (buf, map->attach); + err =PTR_ERR (map->sgt); + goto free; + } -/* -* If we've manually mapped the buffer object through the IOMMU, make -* sure to return the IOVA address of our mapping. -* -* Similarly, for buffers that have been allocated by the DMA API the -* physical address can be used for devices that are not attached to -* an IOMMU. For these devices, callers must pass a valid pointer via -* the @phys argument. -* -* Imported buffers were also already mapped at import time, so the -* existing mapping can be reused. -*/ -if (phys) { - *phys = obj->iova; -return NULL ; + err =sgt_dma_count_chunks (map->sgt); + map->size = gem->size; + + goto out; }/* * If we don't have a mapping for this buffer yet, return an SG table * so that host1x can do the mapping for us via the DMA API. */ - sgt =kzalloc (sizeof (*sgt),GFP_KERNEL ); -if (!sgt) -return ERR_PTR (-ENOMEM ); + map->sgt =kzalloc (sizeof (*map->sgt),GFP_KERNEL ); +if (!map->sgt) { + err = -ENOMEM ; + goto free; + }if (obj->pages) {/* * If the buffer object was allocated from the explicit IOMMU * API code paths, construct an SG table from the pages. */ - err =sg_alloc_table_from_pages (sgt, obj->pages, obj->num_pages, -0 , obj->gem.size,GFP_KERNEL ); -if (err <0 ) - goto free; - }else if (obj->sgt) { -/* -* If the buffer object already has an SG table but no pages -* were allocated for it, it means the buffer was imported and -* the SG table needs to be copied to avoid overwriting any -* other potential users of the original SG table. -*/ - err =sg_alloc_table_from_sg (sgt, obj->sgt->sgl, - obj->sgt->orig_nents,GFP_KERNEL ); + err =sg_alloc_table_from_pages (map->sgt, obj->pages, obj->num_pages,0 , gem->size, +GFP_KERNEL );if (err <0 ) goto free; }else {
@@ -108,25 +93,56 @@ static struct sg_table *tegra_bo_pin(struct device *dev, struct host1x_bo *bo,* not imported, it had to be allocated with the DMA API, so * the DMA API helper can be used. */ - err =dma_get_sgtable (dev, sgt, obj->vaddr, obj->iova, - obj->gem.size); + err =dma_get_sgtable (dev, map->sgt, obj->vaddr, obj->iova, gem->size);if (err <0 ) goto free; } -return sgt; + err =dma_map_sgtable (dev, map->sgt, direction,0 ); +if (err) + goto free_sgt; +out: +/* +* If we've manually mapped the buffer object through the IOMMU, make sure to return the +* existing IOVA address of our mapping. +*/ +if (!obj->mm) { + map->phys =sg_dma_address (map->sgt->sgl); + map->chunks = err; + }else { + map->phys = obj->iova; + map->chunks =1 ; + } + + map->size = gem->size; + +return map; + +free_sgt: +sg_free_table (map->sgt); free: -kfree (sgt); +kfree (map->sgt); +kfree (map);return ERR_PTR (err); } -static void tegra_bo_unpin (struct device *dev,struct sg_table *sgt) +static void tegra_bo_unpin (struct host1x_bo_mapping *map) { -if (sgt) { -sg_free_table (sgt); -kfree (sgt); +if (!map) +return ; + +if (map->attach) { +dma_buf_unmap_attachment (map->attach, map->sgt, map->direction); +dma_buf_detach (map->attach->dmabuf, map->attach); + }else { +dma_unmap_sgtable (map->dev, map->sgt, map->direction,0 ); +sg_free_table (map->sgt); +kfree (map->sgt); } + +host1x_bo_put (map->bo); +kfree (map); }static void *tegra_bo_mmap (struct host1x_bo *bo)
drivers/gpu/drm/tegra/plane.c +15 -45
107 lines not on this page · raw message
drivers/gpu/drm/tegra/plane.h +1 -1
@@ -43,7 +43,7 @@ struct tegra_plane_legacy_blending_state {struct tegra_plane_state {struct drm_plane_state base; -struct sg_table *sgt[3 ]; +struct host1x_bo_mapping *map[3 ];dma_addr_t iova[3 ];struct tegra_bo_tiling tiling;
drivers/gpu/drm/tegra/submit.c +46 -17
79 lines not on this page · raw message
drivers/gpu/drm/tegra/uapi.c +25 -43
110 lines not on this page · raw message
drivers/gpu/drm/tegra/uapi.h +2 -3
@@ -27,10 +27,9 @@ struct tegra_drm_file {struct tegra_drm_mapping {struct kref ref; -struct device *dev; +struct host1x_bo_mapping *map;struct host1x_bo *bo; -struct sg_table *sgt; -enum dma_data_direction direction; +dma_addr_t iova;dma_addr_t iova_end; };
drivers/gpu/host1x/job.c +57 -101
231 lines not on this page · raw message
drivers/gpu/host1x/job.h +1 -5
@@ -35,11 +35,7 @@ struct host1x_job_cmd { };struct host1x_job_unpin_data { -struct host1x_bo *bo; -struct sg_table *sgt; -struct device *dev; -size_t size; -enum dma_data_direction dir; +struct host1x_bo_mapping *map; };/*
include/linux/host1x.h +20 -10
@@ -7,6 +7,7 @@#define __LINUX_HOST1X_H#include <linux/device.h> +#include <linux/dma-direction.h> #include <linux/types.h> enum host1x_class {
@@ -84,12 +85,23 @@ struct host1x_client {struct host1x_bo ;struct sg_table ; +struct host1x_bo_mapping { +struct dma_buf_attachment *attach; +enum dma_data_direction direction; +struct host1x_bo *bo; +struct sg_table *sgt; +unsigned int chunks; +struct device *dev; +dma_addr_t phys; +size_t size; +}; +struct host1x_bo_ops {struct host1x_bo *(*get)(struct host1x_bo *bo);void (*put)(struct host1x_bo *bo); -struct sg_table *(*pin)(struct device *dev,struct host1x_bo *bo, -dma_addr_t *phys); -void (*unpin)(struct device *dev,struct sg_table *sgt); +struct host1x_bo_mapping *(*pin)(struct device *dev,struct host1x_bo *bo, +enum dma_data_direction dir); +void (*unpin)(struct host1x_bo_mapping *map);void *(*mmap)(struct host1x_bo *bo);void (*munmap)(struct host1x_bo *bo,void *addr); };
@@ -114,17 +126,15 @@ static inline void host1x_bo_put(struct host1x_bo *bo) bo->ops->put (bo); } -static inline struct sg_table *host1x_bo_pin (struct device *dev, -struct host1x_bo *bo, -dma_addr_t *phys) +static inline struct host1x_bo_mapping *host1x_bo_pin (struct device *dev,struct host1x_bo *bo, +enum dma_data_direction dir) { -return bo->ops->pin (dev, bo, phys); +return bo->ops->pin (dev, bo, dir); } -static inline void host1x_bo_unpin (struct device *dev,struct host1x_bo *bo, -struct sg_table *sgt) +static inline void host1x_bo_unpin (struct host1x_bo_mapping *map) { - bo->ops->unpin (dev, sgt); + map->bo->ops->unpin (map); }static inline void *host1x_bo_mmap (struct host1x_bo *bo)
Signature · 1 line
2.33.0
PATCH 3/6 drm/tegra: Implement buffer object cache
In reply to Thierry RedingFrom: Thierry Reding <[email protected]>
This cache is used to avoid mapping and unmapping buffer objects unnecessarily. Mappings are cached per client and stay hot until the buffer object is destroyed.
--- drivers/gpu/drm/tegra/gem.c | 14 +++++-- drivers/gpu/drm/tegra/plane.c | 2 +- drivers/gpu/drm/tegra/uapi.c | 3 +- drivers/gpu/host1x/bus.c | 78 +++++++++++++++++++++++++++++++++++ drivers/gpu/host1x/dev.c | 2 + drivers/gpu/host1x/dev.h | 2 + drivers/gpu/host1x/job.c | 4 +- include/linux/host1x.h | 53 +++++++++++++++++++----- 8 files changed, 141 insertions(+), 17 deletions(-)
drivers/gpu/drm/tegra/gem.c +11 -3
@@ -39,6 +39,7 @@ static struct host1x_bo_mapping *tegra_bo_pin(struct device *dev, struct host1x_if (!map)return ERR_PTR (-ENOMEM ); +kref_init (&map->ref); map->bo =host1x_bo_get (bo); map->direction = direction; map->dev = dev;
@@ -129,9 +130,6 @@ static struct host1x_bo_mapping *tegra_bo_pin(struct device *dev, struct host1x_static void tegra_bo_unpin (struct host1x_bo_mapping *map) { -if (!map) -return ; -if (map->attach) {dma_buf_unmap_attachment (map->attach, map->sgt, map->direction);dma_buf_detach (map->attach->dmabuf, map->attach);
@@ -465,8 +463,18 @@ static struct tegra_bo *tegra_bo_import(struct drm_device *drm,void tegra_bo_free_object (struct drm_gem_object *gem) {struct tegra_drm *tegra = gem->dev->dev_private; +struct host1x_bo_mapping *mapping, *tmp;struct tegra_bo *bo =to_tegra_bo (gem); +/* remove all mappings of this buffer object from any caches */ +list_for_each_entry_safe (mapping, tmp, &bo->base.mappings, list) { +if (mapping->cache) +host1x_bo_unpin (mapping); +else +dev_err (gem->dev->dev,"mapping %p stale for device %s\n" , mapping, +dev_name (mapping->dev)); + } +if (tegra->domain)tegra_bo_iommu_unmap (tegra, bo);
drivers/gpu/drm/tegra/plane.c +1 -1
@@ -145,7 +145,7 @@ static int tegra_dc_pin(struct tegra_dc *dc, struct tegra_plane_state *state)struct tegra_bo *bo =tegra_fb_get_plane (state->base.fb, i);struct host1x_bo_mapping *map; - map =host1x_bo_pin (dc->dev, &bo->base,DMA_TO_DEVICE ); + map =host1x_bo_pin (dc->dev, &bo->base,DMA_TO_DEVICE , &dc->client.cache);if (IS_ERR (map)) { err =PTR_ERR (map); goto unpin;
drivers/gpu/drm/tegra/uapi.c +2 -1
@@ -201,7 +201,8 @@ int tegra_drm_ioctl_channel_map(struct drm_device *drm, void *data, struct drm_f goto put_gem; } - mapping->map =host1x_bo_pin (context->client->base.dev, mapping->bo, direction); + mapping->map =host1x_bo_pin (context->client->base.dev, mapping->bo, direction, + &context->client->base.cache);if (IS_ERR (mapping->map)) { err =PTR_ERR (mapping->map); goto put_gem;
drivers/gpu/host1x/bus.c +78 -0
93 lines not on this page · raw message
drivers/gpu/host1x/dev.c +2 -0
@@ -404,6 +404,7 @@ static int host1x_probe(struct platform_device *pdev)if (syncpt_irq <0 )return syncpt_irq; +host1x_bo_cache_init (&host->cache);mutex_init (&host->devices_lock);INIT_LIST_HEAD (&host->devices);INIT_LIST_HEAD (&host->list);
@@ -530,6 +531,7 @@ static int host1x_remove(struct platform_device *pdev)reset_control_assert (host->rst);clk_disable_unprepare (host->clk);host1x_iommu_exit (host); +host1x_bo_cache_destroy (&host->cache);return 0 ; }
drivers/gpu/host1x/dev.h +2 -0
@@ -149,6 +149,8 @@ struct host1x {struct list_head list;struct device_dma_parameters dma_parms; + +struct host1x_bo_cache cache; };void host1x_hypervisor_writel (struct host1x *host1x,u32 r,u32 v);
drivers/gpu/host1x/job.c +2 -2
@@ -177,7 +177,7 @@ static unsigned int pin_job(struct host1x *host, struct host1x_job *job) goto unpin; } - map =host1x_bo_pin (dev, bo, direction); + map =host1x_bo_pin (dev, bo, direction, &client->cache);if (IS_ERR (map)) { err =PTR_ERR (map); goto unpin;
@@ -224,7 +224,7 @@ static unsigned int pin_job(struct host1x *host, struct host1x_job *job) goto unpin; } - map =host1x_bo_pin (host->dev, g->bo,DMA_TO_DEVICE ); + map =host1x_bo_pin (host->dev, g->bo,DMA_TO_DEVICE , &host->cache);if (IS_ERR (map)) { err =PTR_ERR (map); goto unpin;
include/linux/host1x.h +43 -10
104 lines not on this page · raw message
Signature · 1 line
2.33.0
Re: [PATCH 3/6] drm/tegra: Implement buffer object cache
drivers/gpu/drm/tegra/uapi.c int tegra_drm_ioctl_channel_map(struct drm_device *drm, void *data, struct drm_f · line 205
Quoted 13 lines · Thierry Reding
From: Thierry Reding <[email protected]>
...drivers/gpu/drm/tegra/uapi.c +2
-1@@ -201,7 +201,8 @@ int tegra_drm_ioctl_channel_map(struct drm_device *drm, void *data, struct drm_f goto put_gem; } - mapping->map =host1x_bo_pin (context->client->base.dev, mapping->bo, direction); + mapping->map =host1x_bo_pin (context->client->base.dev, mapping->bo, direction, + &context->client->base.cache);
Do we need caching here? The map/unmap operation is explicit and should not be on the hot path, and this will complicate context isolation support where we cannot have an engine-specific cache.
Mikko
Re: [PATCH 3/6] drm/tegra: Implement buffer object cache
Quoted 17 lines · Mikko Perttunen
drivers/gpu/drm/tegra/uapi.c int tegra_drm_ioctl_channel_map(struct drm_device *drm, void *data, struct drm_f · line 204
Quoted 12 lines · Thierry Reding
From: Thierry Reding <[email protected]>
...drivers/gpu/drm/tegra/uapi.c +2
-1@@ -201,7 +201,8 @@ int tegra_drm_ioctl_channel_map(struct drm_device *drm, void *data, struct drm_f goto put_gem; } - mapping->map =host1x_bo_pin (context->client->base.dev, mapping->bo, direction); + mapping->map =host1x_bo_pin (context->client->base.dev, mapping->bo, direction, + &context->client->base.cache);Do we need caching here? The map/unmap operation is explicit and should not be on the hot path, and this will complicate context isolation support where we cannot have an engine-specific cache.
Yeah, we can probably leave it out here. I more or less blindly added caches for everything, but really they're the most useful for cursors and large framebuffers that will otherwise get mapped/unmapped once every frame.
Thierry
PATCH 4/6 drm/tegra: Do not reference tegra_plane_funcs directly
In reply to Thierry RedingFrom: Thierry Reding <[email protected]>
Instead of referencing the tegra_plane_funcs struct directly, use each plane's vtable instead. This makes it more future-proof in case any of the planes ever use a different set of functions.
--- drivers/gpu/drm/tegra/dc.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
drivers/gpu/drm/tegra/dc.c +2 -2
@@ -1267,9 +1267,9 @@ static struct drm_plane *tegra_dc_add_planes(struct drm_device *drm, err =PTR_ERR (planes[i]);while (i--) - tegra_plane_funcs.destroy (planes[i]); + planes[i]->funcs->destroy (planes[i]); - tegra_plane_funcs.destroy (primary); + primary->funcs->destroy (primary);return ERR_PTR (err); } }
Signature · 1 line
2.33.0
PATCH 5/6 drm/tegra: Propagate errors from drm_gem_plane_helper_prepare_fb()
In reply to Thierry RedingFrom: Thierry Reding <[email protected]>
Currently this function doesn't return an error, but that may change in the future, so make sure to propagate any error codes that it might return.
--- drivers/gpu/drm/tegra/plane.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-)
drivers/gpu/drm/tegra/plane.c +4 -1
@@ -200,11 +200,14 @@ int tegra_plane_prepare_fb(struct drm_plane *plane, struct drm_plane_state *state) {struct tegra_dc *dc =to_tegra_dc (state->crtc); +int err;if (!state->fb)return 0 ; -drm_gem_plane_helper_prepare_fb (plane, state); + err =drm_gem_plane_helper_prepare_fb (plane, state); +if (err <0 ) +return err;return tegra_dc_pin (dc,to_tegra_plane_state (state)); }
Signature · 1 line
2.33.0
PATCH 6/6 drm/tegra: Support asynchronous commits for cursor
In reply to Thierry RedingFrom: Thierry Reding <[email protected]>
This adds support for asynchronously updating the cursor plane, which enables support for the legacy cursor IOCTLs.
--- drivers/gpu/drm/tegra/dc.c | 80 ++++++++++++++++++++++++++++++++++++-- 1 file changed, 76 insertions(+), 4 deletions(-)
drivers/gpu/drm/tegra/dc.c +76 -4
@@ -890,11 +890,9 @@ static int tegra_cursor_atomic_check(struct drm_plane *plane,return 0 ; } -static void tegra_cursor_atomic_update (struct drm_plane *plane, -struct drm_atomic_state *state) +static void __tegra_cursor_atomic_update (struct drm_plane *plane, +struct drm_plane_state *new_state) { -struct drm_plane_state *new_state =drm_atomic_get_new_plane_state (state, - plane);struct tegra_plane_state *tegra_plane_state =to_tegra_plane_state (new_state);struct tegra_dc *dc =to_tegra_dc (new_state->crtc);struct tegra_drm *tegra = plane->dev->dev_private;
@@ -990,6 +988,14 @@ static void tegra_cursor_atomic_update(struct drm_plane *plane,tegra_dc_writel (dc, value,DC_DISP_CURSOR_POSITION ); } +static void tegra_cursor_atomic_update (struct drm_plane *plane, +struct drm_atomic_state *state) +{ +struct drm_plane_state *new_state =drm_atomic_get_new_plane_state (state, plane); + +__tegra_cursor_atomic_update (plane, new_state); +} +static void tegra_cursor_atomic_disable (struct drm_plane *plane,struct drm_atomic_state *state) {
@@ -1009,12 +1015,78 @@ static void tegra_cursor_atomic_disable(struct drm_plane *plane,tegra_dc_writel (dc, value,DC_DISP_DISP_WIN_OPTIONS ); } +static int tegra_cursor_atomic_async_check (struct drm_plane *plane,struct drm_atomic_state *state) +{ +struct drm_plane_state *new_state =drm_atomic_get_new_plane_state (state, plane); +struct drm_crtc_state *crtc_state; +int min_scale, max_scale; +int err; + + crtc_state =drm_atomic_get_existing_crtc_state (state, new_state->crtc); +if (WARN_ON (!crtc_state)) +return -EINVAL ; + +if (!crtc_state->active) +return -EINVAL ; + +if (plane->state->crtc != new_state->crtc || + plane->state->src_w != new_state->src_w || + plane->state->src_h != new_state->src_h || + plane->state->crtc_w != new_state->crtc_w || + plane->state->crtc_h != new_state->crtc_h || + plane->state->fb != new_state->fb || + plane->state->fb ==NULL ) +return -EINVAL ; + + min_scale = (1 <<16 ) /8 ; + max_scale = (8 <<16 ) /1 ; + + err =drm_atomic_helper_check_plane_state (new_state, crtc_state, min_scale, max_scale, + true, true); +if (err <0 ) +return err; + +if (new_state->visible != plane->state->visible) +return -EINVAL ; + +return 0 ; +} + +static void tegra_cursor_atomic_async_update (struct drm_plane *plane, +struct drm_atomic_state *state) +{ +struct drm_plane_state *new_state =drm_atomic_get_new_plane_state (state, plane); +struct tegra_dc *dc =to_tegra_dc (new_state->crtc); + + plane->state->src_x = new_state->src_x; + plane->state->src_y = new_state->src_y; + plane->state->crtc_x = new_state->crtc_x; + plane->state->crtc_y = new_state->crtc_y; + +if (new_state->visible) { +struct tegra_plane *p =to_tegra_plane (plane); +u32 value; + +__tegra_cursor_atomic_update (plane, new_state); + + value = (WIN_A_ACT_REQ << p->index) <<8 |GENERAL_UPDATE ; +tegra_dc_writel (dc, value,DC_CMD_STATE_CONTROL ); + (void )tegra_dc_readl (dc,DC_CMD_STATE_CONTROL ); + + value = (WIN_A_ACT_REQ << p->index) |GENERAL_ACT_REQ ; +tegra_dc_writel (dc, value,DC_CMD_STATE_CONTROL ); + (void )tegra_dc_readl (dc,DC_CMD_STATE_CONTROL ); + } +} +static const struct drm_plane_helper_funcs tegra_cursor_plane_helper_funcs = { .prepare_fb = tegra_plane_prepare_fb, .cleanup_fb = tegra_plane_cleanup_fb, .atomic_check = tegra_cursor_atomic_check, .atomic_update = tegra_cursor_atomic_update, .atomic_disable = tegra_cursor_atomic_disable, + .atomic_async_check = tegra_cursor_atomic_async_check, + .atomic_async_update = tegra_cursor_atomic_async_update, };static const uint64_t linear_modifiers[] = {
Signature · 1 line
2.33.0
Quoted 5 lines · Thierry Reding
From: Thierry Reding <[email protected]>
Add a few helpers to count the number of contiguous DMA chunks found in an SG table. This is useful to determine whether or not a mapping can be used by drivers whose devices need contiguous memory.
[...]
Is the counting of all blocks necessary if all to be checked is whether there is more than one continuous block?
Best Regards
Michał Mirosław