Linaro-mm-sig

linaro-mm-sig@lists.linaro.org

15 participants
3030 discussions

[PATCH] dma-buf: propagate errors from dma_buf_describe() on debugfs read

by Mathias Krause

The callback function dma_buf_describe() returns an int not void so the function pointer cast in dma_buf_show() is wrong. dma_buf_describe() can also fail when acquiring the mutex gets interrupted so always returning 0 in dma_buf_show() is wrong, too. Fix both issues by casting the function pointer to the correct type and propagate its return value. This type mismatch was caught by the PaX RAP plugin. Signed-off-by: Mathias Krause <minipli(a)googlemail.com> Cc: Sumit Semwal <sumit.semwal(a)linaro.org> Cc: Daniel Vetter <daniel.vetter(a)ffwll.ch> Cc: PaX Team <pageexec(a)freemail.hu> --- drivers/dma-buf/dma-buf.c | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/drivers/dma-buf/dma-buf.c b/drivers/dma-buf/dma-buf.c index 6355ab38d630..0f2a4592fdd2 100644 --- a/drivers/dma-buf/dma-buf.c +++ b/drivers/dma-buf/dma-buf.c @@ -881,10 +881,9 @@ static int dma_buf_describe(struct seq_file *s) static int dma_buf_show(struct seq_file *s, void *unused) { - void (*func)(struct seq_file *) = s->private; + int (*func)(struct seq_file *) = s->private; - func(s); - return 0; + return func(s); } static int dma_buf_debug_open(struct inode *inode, struct file *file) -- 1.7.10.4

9 years, 2 months

[PATCH 0/5] Ion cleanup

by Laura Abbott

Hi, This is some clean up of old Ion interfaces and APIs. These are interfaces that mostly existed before dma_buf was well integrated into the kernel along with reservations for board files. If there are objections to deletion I expect it to turn into a discussion about what other APIs need to be extended. Thanks, Laura Laura Abbott (5): staging: android: ion: Get rid of ion_sg_table staging: android: ion: Drop ion_phys interface staging: android: ion: Get rid of map_dma/unmap_dma staging: android: ion: Drop ion_carveout_allocate definitions staging: android: ion: Get rid of ion_reserve drivers/staging/android/ion/ion.c | 103 ++---------------------- drivers/staging/android/ion/ion.h | 41 ---------- drivers/staging/android/ion/ion_carveout_heap.c | 33 +------- drivers/staging/android/ion/ion_chunk_heap.c | 17 +--- drivers/staging/android/ion/ion_cma_heap.c | 34 +------- drivers/staging/android/ion/ion_priv.h | 30 +------ drivers/staging/android/ion/ion_system_heap.c | 44 +--------- 7 files changed, 19 insertions(+), 283 deletions(-) -- 2.5.5

9 years, 3 months

Re: [Linaro-mm-sig] [RFC][PATCH 6/6] staging: android: ion: Introduce new ioctls for dynamic heaps

by Laura Abbott

On 06/08/2016 08:34 AM, Brian Starkey wrote: > Hi, > > I'm finding "usage_id" a bit confusing - there's not a very clear > distinction between usage_id and heap ID. > > For instance, ION_IOC_USAGE_CNT claims to return the number of usage > IDs, but seems to return the number of heaps (i.e. number heap IDs, some > of which might be usage_ids). > > Similarly, alloc2 claims to allocate by usage_id, but will just as > happily allocate by heap ID. > > Maybe this should just be described as a single heap ID namespace, where > some IDs represent groups of heap IDs. > For now I'm just going to focus on comments not about the heap ID mapping because I'm leaning towards dropping the heap ID mapping. > I've a few inline comments below. > > -Brian > > On Mon, Jun 06, 2016 at 11:23:33AM -0700, Laura Abbott wrote: >> From: Laura Abbott <labbott(a)fedoraproject.org> >> >> >> The Ion ABI for heaps is limiting to work with for more complex systems. >> Heaps have to be registered at boot time with known ids available to >> userspace. This becomes a tight ABI which is prone to breakage. >> >> Introduce a new mechanism for registering heap ids dynamically. A base >> set of heap ids are registered at boot time but there is no knowledge >> of fallbacks. Fallback information can be remapped and changed >> dynamically. Information about available heaps can also be queried with >> an ioctl to avoid the need to have heap ids be an ABI with userspace. >> >> Signed-off-by: Laura Abbott <labbott(a)redhat.com> >> --- >> drivers/staging/android/ion/ion-ioctl.c | 109 +++++++++++++++++-- >> drivers/staging/android/ion/ion.c | 184 ++++++++++++++++++++++++++++++-- >> drivers/staging/android/ion/ion_priv.h | 15 +++ >> drivers/staging/android/uapi/ion.h | 135 +++++++++++++++++++++++ >> 4 files changed, 426 insertions(+), 17 deletions(-) >> >> diff --git a/drivers/staging/android/ion/ion-ioctl.c b/drivers/staging/android/ion/ion-ioctl.c >> index 45b89e8..169cad8 100644 >> --- a/drivers/staging/android/ion/ion-ioctl.c >> +++ b/drivers/staging/android/ion/ion-ioctl.c >> @@ -22,6 +22,49 @@ >> #include "ion_priv.h" >> #include "compat_ion.h" >> >> +union ion_ioctl_arg { >> + struct ion_fd_data fd; >> + struct ion_allocation_data allocation; >> + struct ion_handle_data handle; >> + struct ion_custom_data custom; >> + struct ion_abi_version abi_version; >> + struct ion_new_alloc_data allocation2; >> + struct ion_usage_id_map id_map; >> + struct ion_usage_cnt usage_cnt; >> + struct ion_heap_query query; >> +}; >> + >> +static int validate_ioctl_arg(unsigned int cmd, union ion_ioctl_arg *arg) >> +{ >> + int ret = 0; >> + >> + switch (cmd) { >> + case ION_IOC_ABI_VERSION: >> + ret = arg->abi_version.reserved != 0; >> + break; >> + case ION_IOC_ALLOC2: >> + ret = arg->allocation2.reserved0 != 0; >> + ret |= arg->allocation2.reserved1 != 0; >> + ret |= arg->allocation2.reserved2 != 0; >> + break; >> + case ION_IOC_ID_MAP: >> + ret = arg->id_map.reserved0 != 0; >> + ret |= arg->id_map.reserved1 != 0; >> + break; >> + case ION_IOC_USAGE_CNT: >> + ret = arg->usage_cnt.reserved != 0; >> + break; >> + case ION_IOC_HEAP_QUERY: >> + ret = arg->query.reserved0 != 0; >> + ret |= arg->query.reserved1 != 0; >> + ret |= arg->query.reserved2 != 0; >> + break; >> + default: >> + break; >> + } >> + return ret ? -EINVAL : 0; >> +} >> + >> /* fix up the cases where the ioctl direction bits are incorrect */ >> static unsigned int ion_ioctl_dir(unsigned int cmd) >> { >> @@ -42,14 +85,7 @@ long ion_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) >> struct ion_handle *cleanup_handle = NULL; >> int ret = 0; >> unsigned int dir; >> - >> - union { >> - struct ion_fd_data fd; >> - struct ion_allocation_data allocation; >> - struct ion_handle_data handle; >> - struct ion_custom_data custom; >> - struct ion_abi_version abi_version; >> - } data; >> + union ion_ioctl_arg data; >> >> dir = ion_ioctl_dir(cmd); >> >> @@ -60,7 +96,12 @@ long ion_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) >> if (copy_from_user(&data, (void __user *)arg, _IOC_SIZE(cmd))) >> return -EFAULT; >> >> + ret = validate_ioctl_arg(cmd, &data); >> + if (ret) >> + return ret; >> + >> switch (cmd) { >> + /* Old ioctl */ >> case ION_IOC_ALLOC: >> { >> struct ion_handle *handle; >> @@ -77,6 +118,7 @@ long ion_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) >> cleanup_handle = handle; >> break; >> } >> + /* Old ioctl */ >> case ION_IOC_FREE: >> { >> struct ion_handle *handle; >> @@ -92,6 +134,7 @@ long ion_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) >> mutex_unlock(&client->lock); >> break; >> } >> + /* Old ioctl */ >> case ION_IOC_SHARE: >> case ION_IOC_MAP: >> { >> @@ -106,6 +149,7 @@ long ion_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) >> ret = data.fd.fd; >> break; >> } >> + /* Old ioctl */ >> case ION_IOC_IMPORT: >> { >> struct ion_handle *handle; >> @@ -117,11 +161,13 @@ long ion_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) >> data.handle.handle = handle->id; >> break; >> } >> + /* Old ioctl */ >> case ION_IOC_SYNC: >> { >> ret = ion_sync_for_device(client, data.fd.fd); >> break; >> } >> + /* Old ioctl */ >> case ION_IOC_CUSTOM: >> { >> if (!dev->custom_ioctl) >> @@ -135,6 +181,53 @@ long ion_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) >> data.abi_version.abi_version = ION_ABI_VERSION; >> break; >> } >> + case ION_IOC_ALLOC2: >> + { >> + struct ion_handle *handle; >> + >> + handle = ion_alloc2(client, data.allocation2.len, >> + data.allocation2.align, >> + data.allocation2.usage_id, >> + data.allocation2.flags); >> + if (IS_ERR(handle)) >> + return PTR_ERR(handle); >> + >> + if (data.allocation2.flags & ION_FLAG_NO_HANDLE) { >> + data.allocation2.fd = ion_share_dma_buf_fd(client, >> + handle); >> + ion_handle_put(handle); >> + if (data.allocation2.fd < 0) >> + ret = data.allocation2.fd; >> + } else { >> + data.allocation2.handle = handle->id; >> + >> + cleanup_handle = handle; >> + } >> + break; >> + } >> + case ION_IOC_ID_MAP: >> + { >> + ret = ion_map_usage_ids(client, >> + (unsigned int __user *)data.id_map.usage_ids, >> + data.id_map.cnt); >> + if (ret > 0) >> + data.id_map.new_id = ret; >> + break; >> + } >> + case ION_IOC_USAGE_CNT: >> + { >> + down_read(&client->dev->lock); >> + data.usage_cnt.cnt = client->dev->heap_cnt; >> + up_read(&client->dev->lock); >> + break; >> + } >> + case ION_IOC_HEAP_QUERY: >> + { >> + ret = ion_query_heaps(client, >> + (struct ion_heap_data __user *)data.query.heaps, >> + data.query.cnt); >> + break; >> + } >> default: >> return -ENOTTY; >> } >> diff --git a/drivers/staging/android/ion/ion.c b/drivers/staging/android/ion/ion.c >> index 129707f..c096cb9 100644 >> --- a/drivers/staging/android/ion/ion.c >> +++ b/drivers/staging/android/ion/ion.c >> @@ -459,6 +459,48 @@ static struct ion_handle *__ion_alloc(struct ion_client *client, size_t len, >> return handle; >> } >> >> +struct ion_handle *ion_alloc2(struct ion_client *client, size_t len, >> + size_t align, unsigned int usage_id, >> + unsigned int flags) >> +{ >> + struct ion_device *dev = client->dev; >> + struct ion_heap *heap; >> + struct ion_handle *handle = ERR_PTR(-ENODEV); >> + >> + down_read(&dev->lock); >> + heap = idr_find(&dev->idr, usage_id); >> + if (!heap) { >> + handle = ERR_PTR(-EINVAL); >> + goto out; >> + } >> + >> + if (heap->type == ION_USAGE_ID_MAP) { >> + int i; >> + >> + for (i = 0; i < heap->fallback_cnt; i++){ >> + heap = idr_find(&dev->idr, heap->fallbacks[i]); >> + if (!heap) >> + continue; >> + >> + /* Don't recurse for now? */ >> + if (heap->type == ION_USAGE_ID_MAP) >> + continue; >> + >> + handle = __ion_alloc(client, len, align, heap, flags); >> + if (IS_ERR(handle)) >> + continue; >> + else >> + break; >> + } >> + } else { >> + handle = __ion_alloc(client, len, align, heap, flags); >> + } >> +out: >> + up_read(&dev->lock); >> + return handle; >> +} >> +EXPORT_SYMBOL(ion_alloc2); >> + >> struct ion_handle *ion_alloc(struct ion_client *client, size_t len, >> size_t align, unsigned int heap_mask, >> unsigned int flags) >> @@ -1243,6 +1285,55 @@ int ion_sync_for_device(struct ion_client *client, int fd) >> return 0; >> } >> >> +struct ion_query_data { >> + struct ion_heap_data __user *buffer; >> + int cnt; >> + int max_cnt; >> +}; >> + >> +int __ion_query(int id, void *p, void *data) >> +{ >> + struct ion_heap *heap = p; >> + struct ion_query_data *query = data; >> + struct ion_heap_data hdata = {0}; >> + >> + if (query->cnt >= query->max_cnt) >> + return -ENOSPC; >> + >> + strncpy(hdata.name, heap->name, 20); > > Why 20? > Arbitrary limit for a fixed size buffer. As noted below I need to make this a consistent #define. >> + hdata.name[sizeof(hdata.name) - 1] = '\0'; >> + hdata.type = heap->type; >> + hdata.usage_id = heap->id; >> + >> + return copy_to_user(&query->buffer[query->cnt++], &hdata, sizeof(hdata)); >> +} >> + >> +int ion_query_heaps(struct ion_client *client, >> + struct ion_heap_data __user *buffer, >> + int cnt) >> +{ >> + struct ion_device *dev = client->dev; >> + struct ion_query_data data; >> + int ret; >> + >> + data.buffer = buffer; >> + data.cnt = 0; >> + data.max_cnt = cnt; >> + >> + down_read(&dev->lock); >> + if (data.max_cnt < 0 || data.max_cnt > dev->heap_cnt) { > > Is the check against heap_cnt necessary? You could update the cnt > field in ion_heap_query to say how many were actually copied. > This was mostly a paranoid check to reduce risk of accidentally giving userspace access to something it shouldn't. Updating the count is still a good idea in case userspace wants fewer than are available. > I think you could probably drop ION_IOC_USAGE_COUNT by giving > ION_IOC_HEAP_QUERY similar semantics to the DRM ioctls: > - First call with buffer pointer = NULL, kernel sets cnt to space > required > - Userspace allocates buffer and calls the ioctl again, kernel fills > the buffer > I'm not that familiar with the DRM ioctls but this sounds like a good suggestion. One less ioctl to worry about. >> + ret = -EINVAL; >> + goto out; >> + } >> + ret = idr_for_each(&dev->idr, __ion_query, &data); >> +out: >> + up_read(&dev->lock); >> + >> + return ret; >> +} >> + >> + >> + >> static int ion_release(struct inode *inode, struct file *file) >> { >> struct ion_client *client = file->private_data; >> @@ -1407,13 +1498,69 @@ static int debug_shrink_get(void *data, u64 *val) >> DEFINE_SIMPLE_ATTRIBUTE(debug_shrink_fops, debug_shrink_get, >> debug_shrink_set, "%llu\n"); >> >> +int ion_map_usage_ids(struct ion_client *client, >> + unsigned int __user *usage_ids, >> + int cnt) >> +{ >> + struct ion_heap *heap = kzalloc(sizeof(*heap), GFP_KERNEL); >> + unsigned int *fallbacks; >> + int i; >> + int ret; >> + >> + if (!heap) >> + return -ENOMEM; >> + >> + fallbacks = kzalloc(sizeof(unsigned int)*cnt, GFP_KERNEL); >> + if (!fallbacks) { >> + ret = -ENOMEM; >> + goto out1; >> + } >> + >> + ret = copy_from_user(fallbacks, usage_ids, sizeof(unsigned int)*cnt); >> + if (ret) >> + goto out2; >> + >> + down_read(&client->dev->lock); >> + for (i = 0; i < cnt; i++) { >> + if (idr_find(&client->dev->idr, fallbacks[i]) == NULL) { >> + ret = -EINVAL; >> + goto out3; >> + } >> + } >> + up_read(&client->dev->lock); >> + >> + /* >> + * This is a racy check since the lock is dropped before the heap >> + * is actually added. It's okay though because ids are never actually >> + * deleted. Worst case some user gets an error back and an indication >> + * to fix races in their code. >> + */ >> + >> + heap->fallbacks = fallbacks; >> + heap->fallback_cnt = cnt; >> + heap->type = ION_USAGE_ID_MAP; >> + heap->id = ION_DYNAMIC_HEAP_ASSIGN; > > It would be nice for userspace to be able to give these usage heaps > meaningful names - That could be their intended usage ("camera", > "display") or their properties ("contiguous", "sram"). > >> + ion_device_add_heap(client->dev, heap); >> + return heap->id; >> +out3: >> + up_read(&client->dev->lock); >> +out2: >> + kfree(fallbacks); >> +out1: >> + kfree(heap); >> + return ret; >> +} >> + >> int ion_device_add_heap(struct ion_device *dev, struct ion_heap *heap) >> { >> struct dentry *debug_file; >> int ret; >> >> - if (!heap->ops->allocate || !heap->ops->free || !heap->ops->map_dma || >> - !heap->ops->unmap_dma) { >> + if (heap->type != ION_USAGE_ID_MAP && >> + (!heap->ops->allocate || >> + !heap->ops->free || >> + !heap->ops->map_dma || >> + !heap->ops->unmap_dma)) { >> pr_err("%s: can not add heap with invalid ops struct.\n", >> __func__); >> return -EINVAL; >> @@ -1425,18 +1572,36 @@ int ion_device_add_heap(struct ion_device *dev, struct ion_heap *heap) >> if (heap->flags & ION_HEAP_FLAG_DEFER_FREE) >> ion_heap_init_deferred_free(heap); >> >> - if ((heap->flags & ION_HEAP_FLAG_DEFER_FREE) || heap->ops->shrink) >> + if ((heap->flags & ION_HEAP_FLAG_DEFER_FREE) || (heap->ops && heap->ops->shrink)) >> ion_heap_init_shrinker(heap); >> >> heap->dev = dev; >> down_write(&dev->lock); >> >> - ret = idr_alloc(&dev->idr, heap, heap->id, heap->id + 1, GFP_KERNEL); >> - if (ret < 0 || ret != heap->id) { >> - pr_info("%s: Failed to add heap id, expected %d got %d\n", >> - __func__, heap->id, ret); >> - up_write(&dev->lock); >> - return ret < 0 ? ret : -EINVAL; >> + if (heap->id == ION_DYNAMIC_HEAP_ASSIGN) { >> + ret = idr_alloc(&dev->idr, heap, >> + ION_DYNAMIC_HEAP_ASSIGN + 1, 0, GFP_KERNEL); >> + if (ret < 0) >> + goto out_unlock; >> + >> + heap->id = ret; >> + } else { >> + ret = idr_alloc(&dev->idr, heap, heap->id, heap->id + 1, >> + GFP_KERNEL); >> + if (ret < 0 || ret != heap->id) { >> + pr_info("%s: Failed to add heap id, expected %d got %d\n", >> + __func__, heap->id, ret); >> + ret = ret < 0 ? ret : -EINVAL; >> + goto out_unlock; >> + } >> + } >> + >> + if (!heap->name) { >> + heap->name = kasprintf(GFP_KERNEL, "heap%d", heap->id); >> + if (!heap->name) { >> + ret = -ENOMEM; >> + goto out_unlock; >> + } >> } >> >> debug_file = debugfs_create_file(heap->name, 0664, >> @@ -1467,6 +1632,7 @@ int ion_device_add_heap(struct ion_device *dev, struct ion_heap *heap) >> } >> } >> dev->heap_cnt++; >> +out_unlock: >> up_write(&dev->lock); >> return 0; >> } >> diff --git a/drivers/staging/android/ion/ion_priv.h b/drivers/staging/android/ion/ion_priv.h >> index b09d751..e03e940 100644 >> --- a/drivers/staging/android/ion/ion_priv.h >> +++ b/drivers/staging/android/ion/ion_priv.h >> @@ -255,6 +255,9 @@ struct ion_heap { >> wait_queue_head_t waitqueue; >> struct task_struct *task; >> >> + unsigned int *fallbacks; >> + int fallback_cnt; >> + >> int (*debug_show)(struct ion_heap *heap, struct seq_file *, void *); >> }; >> >> @@ -381,6 +384,10 @@ size_t ion_heap_freelist_shrink(struct ion_heap *heap, >> size_t ion_heap_freelist_size(struct ion_heap *heap); >> >> >> +int ion_map_usage_ids(struct ion_client *client, >> + unsigned int __user *usage_ids, >> + int cnt); >> + >> /** >> * functions for creating and destroying the built in ion heaps. >> * architectures can add their own custom architecture specific >> @@ -495,4 +502,12 @@ struct ion_handle *ion_handle_get_by_id(struct ion_client *client, >> >> int ion_handle_put(struct ion_handle *handle); >> >> +struct ion_handle *ion_alloc2(struct ion_client *client, size_t len, >> + size_t align, unsigned int usage_id, >> + unsigned int flags); >> + >> +int ion_query_heaps(struct ion_client *client, >> + struct ion_heap_data __user *buffer, >> + int cnt); >> + >> #endif /* _ION_PRIV_H */ >> diff --git a/drivers/staging/android/uapi/ion.h b/drivers/staging/android/uapi/ion.h >> index 145005f..d36b4e4 100644 >> --- a/drivers/staging/android/uapi/ion.h >> +++ b/drivers/staging/android/uapi/ion.h >> @@ -45,10 +45,17 @@ enum ion_heap_type { >> * must be last so device specific heaps always >> * are at the end of this enum >> */ >> + ION_USAGE_ID_MAP, > > A short description for this would be nice > >> }; >> >> #define ION_NUM_HEAP_IDS (sizeof(unsigned int) * 8) >> >> +/* >> + * This isn't completely random. The old Ion heap ID namespace goes up to >> + * 32 bits so take the first one after that to use as a dynamic setting >> + */ >> +#define ION_DYNAMIC_HEAP_ASSIGN 33 >> + > > The old comment says 32, but the implementation looks like 16. > > Either way, shouldn't that be 32? If the previous max was 31, > 32 is next available - but in ion_device_add_heap() you use > ION_DYNAMIC_HEAP_ASSIGN + 1, which makes the first dynamically-assigned > ID 34. > >> /** >> * allocation flags - the lower 16 bits are used by core ion, the upper 16 >> * bits are reserved for use by the heaps themselves. >> @@ -65,6 +72,11 @@ enum ion_heap_type { >> * caches must be managed >> * manually >> */ >> +#define ION_FLAG_NO_HANDLE 3 /* >> + * Return only an fd associated with >> + * this buffer and not a handle >> + */ >> + >> >> /** >> * DOC: Ion Userspace API >> @@ -142,6 +154,96 @@ struct ion_abi_version { >> __u32 reserved; >> }; >> >> +/** >> + * struct ion_new_alloc_data - metadata to/from usersapce allocation v2 >> + * @len: size of the allocation >> + * @align: required alignment of the allocation >> + * @usage_id: mapping to heap id to allocate. Will try fallbacks >> + * if specified in the heap mapping >> + * @flags: flags passed to heap >> + * @handle: pointer that will be populated with a cookie to use to >> + * refer to this allocation >> + * @fd: optionally, may return just an fd with no handle >> + * reference >> + */ >> +struct ion_new_alloc_data { >> + __u64 len; >> + __u64 align; >> + __u32 usage_id; >> + __u32 flags; >> + /* >> + * I'd like to add a flag to just return the fd instead of just >> + * a handle for those who want to skip the next step. >> + */ >> + union { >> + __u32 fd; >> + __u32 handle; >> + }; >> + /* >> + * Allocation has a definite problem of 'creep' so give more than >> + * enough extra bits for expansion >> + */ >> + __u32 reserved0; >> + __u32 reserved1; >> + __u32 reserved2; >> +}; >> + >> +/** >> + * struct ion_usage_id_map - metadata to create a new usage map >> + * @usage_id - userspace allocated array of existing usage ids >> + * @cnt - number of ids to be mapped >> + * @new_id - will be populated with the new usage id >> + */ >> +struct ion_usage_id_map { >> + /* Array of usage ids provided by user */ >> + __u64 usage_ids; >> + __u32 cnt; >> + >> + /* Returned on success */ >> + __u32 new_id; >> + /* Fields for future growth */ >> + __u32 reserved0; >> + __u32 reserved1; >> +}; >> + >> +/** >> + * struct ion_usage_cnt - meta data for the count of heaps >> + * @cnt - returned count of number of heaps present >> + */ >> +struct ion_usage_cnt { >> + __u32 cnt; /* cnt returned */ >> + __u32 reserved; >> +}; >> + >> +/** >> + * struct ion_heap_data - data about a heap >> + * @name - first 32 characters of the heap name >> + * @type - heap type >> + * @usage_id - usage id for the heap >> + */ >> +struct ion_heap_data { >> + char name[32]; I realized I upped this to 32 and didn't update the code. I'm going to make this consistent. >> + __u32 type; >> + __u32 usage_id; > > For heaps with type ION_USAGE_ID_MAP I think userspace would want a way > to turn a usage_id back into a list of fallbacks to figure out that > usage_id == 34 means "only contiguous buffers" for instance. > Otherwise only the process that made the mapping can ever know what its > for. > >> + __u32 reserved0; >> + __u32 reserved1; >> + __u32 reserved2; >> +}; >> + >> +/** >> + * struct ion_heap_query - collection of data about all heaps >> + * @cnt - total number of heaps to be copied >> + * @heaps - buffer to copy heap data >> + */ >> +struct ion_heap_query { >> + __u32 cnt; /* Total number of heaps to be copied */ >> + __u64 heaps; /* buffer to be populated */ > > I guess this field needs explicit alignment to 64 bits > Yes, I was going by the suggestion in botching-up-ioctls.txt https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/tree/Docume… >> + __u32 reserved0; >> + __u32 reserved1; >> + __u32 reserved2; >> +}; >> + >> + >> #define ION_IOC_MAGIC 'I' >> >> /** >> @@ -216,5 +318,38 @@ struct ion_abi_version { >> #define ION_IOC_ABI_VERSION _IOR(ION_IOC_MAGIC, 8, \ >> struct ion_abi_version) >> >> +/** >> + * DOC: ION_IOC_ALLOC2 - allocate memory via new API >> + * >> + * Same concept as ION_IOC_ALLOC except with updated ABI. Can return an fd >> + * directly in addition to a handle >> + */ >> +#define ION_IOC_ALLOC2 _IOWR(ION_IOC_MAGIC, 9, \ >> + struct ion_new_alloc_data) >> + >> +/** >> + * DOC: ION_IOC_ID_MAP - remap an array of heap IDs >> + * >> + * Takes an ion_usage_id_map structure populated with information about >> + * fallback information. Returns a new usage id for use in allocation. > > Can you mention the implied priority of the fallbacks here? > >> + */ >> +#define ION_IOC_ID_MAP _IOWR(ION_IOC_MAGIC, 10, \ >> + struct ion_usage_id_map) >> +/** >> + * DOC: ION_IOC_USAGE_CNT - returns a count of the number of usage ids >> + * >> + * Takes an ion_usage_cnt structure and returns the total number of usage >> + * ids available. > > Number of usage IDs or number of heaps? > >> + */ >> +#define ION_IOC_USAGE_CNT _IOR(ION_IOC_MAGIC, 11, \ >> + struct ion_usage_cnt) >> +/** >> + * DOC: ION_IOC_HEAP_QUERY - information about available heaps >> + * >> + * Takes an ion_heap_query structure and populates information about >> + * availble Ion heaps. >> + */ >> +#define ION_IOC_HEAP_QUERY _IOWR(ION_IOC_MAGIC, 12, \ >> + struct ion_heap_query) >> >> #endif /* _UAPI_LINUX_ION_H */ >> -- >> 2.5.5 >>

9 years, 3 months

Re: [Linaro-mm-sig] [RFC][PATCH 0/6] ion: improved ABI

by Laura Abbott

On 06/08/2016 08:15 AM, Brian Starkey wrote: > Hi Laura, > > On Mon, Jun 06, 2016 at 11:23:27AM -0700, Laura Abbott wrote: >> The ABI for Ion's ioctl interface are a pain to work with. The heap IDs >> are a 32-bit non-discoverable namespace that form part of the ABI. There's >> no way to determine what ABI version is in use which leads to problems >> if the ABI changes or needs to be updated. >> >> This series is a first approach to give a better ABI for Ion. This includes: >> >> - Following the advice in botching-up-ioctls.txt >> - Ioctl for ABI version >> - Dynamic assignment of heap ids >> - queryable heap ids >> - Runtime mapping of heap ids, including fallbacks. This avoids the need to >> encode the fallbacks as an ABI. >> >> I'm most interested in feedback if this ABI is actually an improvement and >> usable. The heap id map/query interface seems error prone but I didn't have >> a cleaner solution. There aren't any kernel APIs for the new features as the >> focus was on a userspace API but I anticipate that following easily once >> the userspace API is established. >> > > If I understand it right, the big improvement here is that userspace can > find out what heap IDs are available, and what type of heap they > correspond to? This seems good. > > I'm not sure about how userspace is meant to use the usage mappings > though. Who calls ION_IOC_ID_MAP? > The thought was daemons (surfaceflinger, mediaserver etc.) would set this up. > (also, map/mapping is pretty overloaded. How about groups/groupings?) > That's a good suggestion. > If I assume that the thing calling ION_IOC_ID_MAP is the same thing > doing the allocating, then there doesn't seem to be much need for > creating mappings. The combined mapper/allocator would necessarily need > some knowledge about which types can satisfy which usage, and so could > follow something like this: > 1. The heaps can be queried, finding their IDs and types > 2. A mask of heap IDs can be created which satisfies a "usage", based > on the queried types > 3. Allocation operations can then simply use this constructed mask > > On the other hand, if I assume that the thing doing the allocating is > different to the thing doing the usage mapping (i.e. the allocator > doesn't need to know about heap _types_, only usages); then I can't see > a way for the allocator to figure out which usage_id it's meant to > allocate with - which puts it right back to the old problem of opaque > heap IDs (-> opaque usage_ids), except it's worse because they can > change dynamically. > I see your point about the mapping. My thought was that whoever was doing the mapping would have a way to pass information to the allocator or the allocator could do a query. Relying on the passing of information may not be plausible and I realize there isn't enough information from a query to determine what usage id to use. I like the suggestion of just using the query. One of the goals I initially had with this series was to get rid of the heap mask. The 32-bit heap mask became a name space that needed to be controlled across all targets and the fallbacks were difficult to change. The problem that actually wants to be solved is giving userspace enough information to determine what heap masks to allocate from. Just a query ioctl should be able to give that information as long as the requirement is that userspace clients match on the heap name + type only and not rely on the heap ids being constant (I don't think I made that clear with this version of the query ioctl so I'll make sure to clarify). The platform registration can adjust the priority order of the heap ids as necessary. Different names should be able to take care of any changes to the platform configuration. I'll think about this more when I work on v2. Thanks, Laura > Thanks, > Brian > >> >> Thanks, >> Laura >> >> P.S. Not to turn this into a bike shedding session but if you have suggestions >> for a name for this framework other than Ion I would be interested to hear >> them. Too many other things are already named Ion. >> >> Laura Abbott (6): >> staging: android: ion: return error value for ion_device_add_heap >> staging: android: ion: Switch to using an idr to manage heaps >> staging: android: ion: Drop heap type masks >> staging: android: ion: Pull out ion ioctls to a separate file >> staging: android: ion: Add an ioctl for ABI checking >> staging: android: ion: Introduce new ioctls for dynamic heaps >> >> drivers/staging/android/ion/Makefile | 3 +- >> drivers/staging/android/ion/ion-ioctl.c | 243 ++++++++++++++++++ >> drivers/staging/android/ion/ion.c | 438 ++++++++++++++++---------------- >> drivers/staging/android/ion/ion_priv.h | 109 +++++++- >> drivers/staging/android/uapi/ion.h | 164 +++++++++++- >> 5 files changed, 728 insertions(+), 229 deletions(-) >> create mode 100644 drivers/staging/android/ion/ion-ioctl.c >> >> -- 2.5.5

9 years, 3 months

[RFC][PATCH 0/6] ion: improved ABI

by Laura Abbott

The ABI for Ion's ioctl interface are a pain to work with. The heap IDs are a 32-bit non-discoverable namespace that form part of the ABI. There's no way to determine what ABI version is in use which leads to problems if the ABI changes or needs to be updated. This series is a first approach to give a better ABI for Ion. This includes: - Following the advice in botching-up-ioctls.txt - Ioctl for ABI version - Dynamic assignment of heap ids - queryable heap ids - Runtime mapping of heap ids, including fallbacks. This avoids the need to encode the fallbacks as an ABI. I'm most interested in feedback if this ABI is actually an improvement and usable. The heap id map/query interface seems error prone but I didn't have a cleaner solution. There aren't any kernel APIs for the new features as the focus was on a userspace API but I anticipate that following easily once the userspace API is established. Thanks, Laura P.S. Not to turn this into a bike shedding session but if you have suggestions for a name for this framework other than Ion I would be interested to hear them. Too many other things are already named Ion. Laura Abbott (6): staging: android: ion: return error value for ion_device_add_heap staging: android: ion: Switch to using an idr to manage heaps staging: android: ion: Drop heap type masks staging: android: ion: Pull out ion ioctls to a separate file staging: android: ion: Add an ioctl for ABI checking staging: android: ion: Introduce new ioctls for dynamic heaps drivers/staging/android/ion/Makefile | 3 +- drivers/staging/android/ion/ion-ioctl.c | 243 ++++++++++++++++++ drivers/staging/android/ion/ion.c | 438 ++++++++++++++++---------------- drivers/staging/android/ion/ion_priv.h | 109 +++++++- drivers/staging/android/uapi/ion.h | 164 +++++++++++- 5 files changed, 728 insertions(+), 229 deletions(-) create mode 100644 drivers/staging/android/ion/ion-ioctl.c -- 2.5.5

9 years, 3 months

Re: [Linaro-mm-sig] [RFC][PATCH 0/6] ion: improved ABI

by Laura Abbott

On 06/06/2016 11:59 PM, Chen Feng wrote: > The idea is good, define the heap ids in header file is inconvenient. > > But if we query the heaps information from user-space. > > It need to maintain this ids and name userspace one by one. The code may > be complicated in different module user-space. > > In android, the gralloc and other lib will all use ion to alloc memory. > > This will make it more difficult to maintain user-space code. > This was a concern I had had as well. Anything that involves dynamic probing is going to involve more tracking. Do you think some library code in libion would help? Thanks, Laura > > But beyond this, The new alloc2 with not-handle flag is good. > And the pull out of ioctl interface is also a good cleanup. > > On 2016/6/7 2:23, Laura Abbott wrote: >> >> The ABI for Ion's ioctl interface are a pain to work with. The heap IDs >> are a 32-bit non-discoverable namespace that form part of the ABI. There's >> no way to determine what ABI version is in use which leads to problems >> if the ABI changes or needs to be updated. >> >> This series is a first approach to give a better ABI for Ion. This includes: >> >> - Following the advice in botching-up-ioctls.txt >> - Ioctl for ABI version >> - Dynamic assignment of heap ids >> - queryable heap ids >> - Runtime mapping of heap ids, including fallbacks. This avoids the need to >> encode the fallbacks as an ABI. >> >> I'm most interested in feedback if this ABI is actually an improvement and >> usable. The heap id map/query interface seems error prone but I didn't have >> a cleaner solution. There aren't any kernel APIs for the new features as the >> focus was on a userspace API but I anticipate that following easily once >> the userspace API is established. >> >> >> Thanks, >> Laura >> >> P.S. Not to turn this into a bike shedding session but if you have suggestions >> for a name for this framework other than Ion I would be interested to hear >> them. Too many other things are already named Ion. >> >> Laura Abbott (6): >> staging: android: ion: return error value for ion_device_add_heap >> staging: android: ion: Switch to using an idr to manage heaps >> staging: android: ion: Drop heap type masks >> staging: android: ion: Pull out ion ioctls to a separate file >> staging: android: ion: Add an ioctl for ABI checking >> staging: android: ion: Introduce new ioctls for dynamic heaps >> >> drivers/staging/android/ion/Makefile | 3 +- >> drivers/staging/android/ion/ion-ioctl.c | 243 ++++++++++++++++++ >> drivers/staging/android/ion/ion.c | 438 ++++++++++++++++---------------- >> drivers/staging/android/ion/ion_priv.h | 109 +++++++- >> drivers/staging/android/uapi/ion.h | 164 +++++++++++- >> 5 files changed, 728 insertions(+), 229 deletions(-) >> create mode 100644 drivers/staging/android/ion/ion-ioctl.c >> >

9 years, 3 months

[RFC][PATCH 0/3] Clean up Ion mapping/caching

by Laura Abbott

Hi, This series cleans up Ion a bit to be more in line with existing standards for caching and dma mapping. The most controversial part of this is probably going to be the first patch. Ion takes quite a few liberties with how the DMA APIs are used for cache syncing. dma_sync_sg is used without calling dma_map first. There isn't a good way to get the cache synchronization with the DMA APIs. The behavior of Ion is closer to the DRM framework which uses its own private cache APIs for synchronization so I took that approach. Assuming the approach of the first patch is appropriate, the next two patches are fairly simple. dma_buf added support for a sync ioctl. Ion has a similar ioctl already so this fixes the Ion APIs to be compatible with the dma_buf ioctl. My plan would be to put a timeline on deprecation for the old Ion sync ioctl. The map_dma_buf calls were also missing calls to the underlying DMA APIs so the final patch in the series adds the appropriate calls. Feedback is appreciated. Thanks, Laura Laura Abbott (3): staging: ion: Move away from the DMA APIs for cache flushing staging: ion: Add support for syncing with DMA_BUF_IOCTL_SYNC staging: ion: Add dma_map/dma_unmap calls to dma_buf calls drivers/staging/android/ion/Kconfig | 14 ++++- drivers/staging/android/ion/Makefile | 3 + drivers/staging/android/ion/ion-arm.c | 83 ++++++++++++++++++++++++ drivers/staging/android/ion/ion-arm64.c | 46 ++++++++++++++ drivers/staging/android/ion/ion-x86.c | 34 ++++++++++ drivers/staging/android/ion/ion.c | 84 +++++++++++++------------ drivers/staging/android/ion/ion_carveout_heap.c | 5 +- drivers/staging/android/ion/ion_chunk_heap.c | 7 +-- drivers/staging/android/ion/ion_page_pool.c | 3 +- drivers/staging/android/ion/ion_priv.h | 14 ++--- drivers/staging/android/ion/ion_system_heap.c | 5 +- 11 files changed, 235 insertions(+), 63 deletions(-) create mode 100644 drivers/staging/android/ion/ion-arm.c create mode 100644 drivers/staging/android/ion/ion-arm64.c create mode 100644 drivers/staging/android/ion/ion-x86.c -- 2.5.5

9 years, 3 months

[GIT PULL]: minor dma-buf updates for 4.7

by Sumit Semwal

Hi Linus, A tiny pull request with mostly cosmetic changes in dma-buf for 4.7; may I request you to please pull? The following changes since commit 852f42a69b93dc71507adedeed876d57b8c2c2fa: Merge branch 'uuid' (lib/uuid fixes from Andy) (2016-05-30 15:27:07 -0700) are available in the git repository at: git://git.kernel.org/pub/scm/linux/kernel/git/sumits/dma-buf.git tags/dma-buf-for-4.7 for you to fetch changes up to b02da6f8236148009c22167cd7013d5ce04a2d37: dma-buf: use vma_pages() (2016-05-31 22:17:05 +0530) ---------------------------------------------------------------- Minor dma-buf updates for 4.7: - use of vma_pages instead of explicit computation. - DocBook and headerdoc updates for dma-buf. ---------------------------------------------------------------- Luis de Bethencourt (1): fence: add missing descriptions for fence Muhammad Falak R Wani (1): dma-buf: use vma_pages() Rob Clark (3): dma-buf: headerdoc fixes reservation: add headerdoc comments doc: update/fixup dma-buf related DocBook Documentation/DocBook/device-drivers.tmpl | 36 ++++++++++++++-- drivers/dma-buf/dma-buf.c | 7 +-- drivers/dma-buf/reservation.c | 72 +++++++++++++++++++++++++++++-- include/linux/dma-buf.h | 13 ++++-- include/linux/fence.h | 2 + include/linux/reservation.h | 53 +++++++++++++++++++++++ 6 files changed, 169 insertions(+), 14 deletions(-) Thanks and best regards, Sumit.

9 years, 3 months

[PATCH v3 0/4] Generic zpos property

by Benjamin Gaignard

version 3: use kmalloc_array instead of kmalloc. Correct normalize_zpos computation (comeback to Mareck original code) version 2: add a zpos property into drm_plane structure to simplify code. This allow to get/set zpos value in core and not in drivers code. Fix various remarks. version 1: refactor Marek's patches to have per plane zpos property instead of only one in core. Benjamin Gaignard (2): drm: sti: use generic zpos for plane drm: rcar: use generic code for managing zpos plane property Marek Szyprowski (2): drm: add generic zpos property drm/exynos: use generic code for managing zpos plane property Documentation/DocBook/gpu.tmpl | 10 ++ drivers/gpu/drm/Makefile | 2 +- drivers/gpu/drm/drm_atomic.c | 4 + drivers/gpu/drm/drm_atomic_helper.c | 6 + drivers/gpu/drm/drm_blend.c | 226 ++++++++++++++++++++++++++++++ drivers/gpu/drm/drm_crtc_internal.h | 3 + drivers/gpu/drm/exynos/exynos_drm_drv.h | 2 - drivers/gpu/drm/exynos/exynos_drm_plane.c | 67 ++------- drivers/gpu/drm/exynos/exynos_mixer.c | 6 +- drivers/gpu/drm/rcar-du/rcar_du_crtc.c | 2 +- drivers/gpu/drm/rcar-du/rcar_du_drv.h | 1 - drivers/gpu/drm/rcar-du/rcar_du_kms.c | 5 - drivers/gpu/drm/rcar-du/rcar_du_plane.c | 9 +- drivers/gpu/drm/rcar-du/rcar_du_plane.h | 2 - drivers/gpu/drm/sti/sti_mixer.c | 9 +- drivers/gpu/drm/sti/sti_plane.c | 80 ++++------- drivers/gpu/drm/sti/sti_plane.h | 2 - include/drm/drm_crtc.h | 28 ++++ 18 files changed, 325 insertions(+), 139 deletions(-) create mode 100644 drivers/gpu/drm/drm_blend.c Cc: Inki Dae <inki.dae(a)samsung.com> Cc: Daniel Vetter <daniel(a)ffwll.ch> Cc: Ville Syrjala <ville.syrjala(a)linux.intel.com> Cc: Joonyoung Shim <jy0922.shim(a)samsung.com> Cc: Seung-Woo Kim <sw0312.kim(a)samsung.com> Cc: Andrzej Hajda <a.hajda(a)samsung.com> Cc: Krzysztof Kozlowski <k.kozlowski(a)samsung.com> Cc: Bartlomiej Zolnierkiewicz <b.zolnierkie(a)samsung.com> Cc: Tobias Jakobi <tjakobi(a)math.uni-bielefeld.de> Cc: Gustavo Padovan <gustavo(a)padovan.org> Cc: vincent.abriou(a)st.com Cc: fabien.dessenne(a)st.com Cc: Laurent Pinchart <laurent.pinchart(a)ideasonboard.com> -- 1.9.1

9 years, 3 months

[PATCH 1/4] drm: add generic zpos property

by Benjamin Gaignard

From: Marek Szyprowski <m.szyprowski(a)samsung.com> This patch adds support for generic plane's zpos property property with well-defined semantics: - added zpos properties to plane and plane state structures - added helpers for normalizing zpos properties of given set of planes - well defined semantics: planes are sorted by zpos values and then plane id value if zpos equals Normalized zpos values are calculated automatically when generic muttable zpos property has been initialized. Drivers can simply use plane_state->normalized_zpos in their atomic_check and/or plane_update callbacks without any additional calls to DRM core. Signed-off-by: Marek Szyprowski <m.szyprowski(a)samsung.com> Compare to Marek's original patch zpos property is now specific to each plane and no more to the core. Normalize function take care of the range of per plane defined range before set normalized_zpos. Signed-off-by: Benjamin Gaignard <benjamin.gaignard(a)linaro.org> Cc: Inki Dae <inki.dae(a)samsung.com> Cc: Daniel Vetter <daniel(a)ffwll.ch> Cc: Ville Syrjala <ville.syrjala(a)linux.intel.com> Cc: Joonyoung Shim <jy0922.shim(a)samsung.com> Cc: Seung-Woo Kim <sw0312.kim(a)samsung.com> Cc: Andrzej Hajda <a.hajda(a)samsung.com> Cc: Krzysztof Kozlowski <k.kozlowski(a)samsung.com> Cc: Bartlomiej Zolnierkiewicz <b.zolnierkie(a)samsung.com> Cc: Tobias Jakobi <tjakobi(a)math.uni-bielefeld.de> Cc: Gustavo Padovan <gustavo(a)padovan.org> Cc: vincent.abriou(a)st.com Cc: fabien.dessenne(a)st.com Cc: Laurent Pinchart <laurent.pinchart(a)ideasonboard.com> --- Documentation/DocBook/gpu.tmpl | 10 ++ drivers/gpu/drm/Makefile | 2 +- drivers/gpu/drm/drm_atomic.c | 4 + drivers/gpu/drm/drm_atomic_helper.c | 6 + drivers/gpu/drm/drm_blend.c | 229 ++++++++++++++++++++++++++++++++++++ drivers/gpu/drm/drm_crtc_internal.h | 3 + include/drm/drm_crtc.h | 28 +++++ 7 files changed, 281 insertions(+), 1 deletion(-) create mode 100644 drivers/gpu/drm/drm_blend.c diff --git a/Documentation/DocBook/gpu.tmpl b/Documentation/DocBook/gpu.tmpl index 9dd48f7..0df6abb 100644 --- a/Documentation/DocBook/gpu.tmpl +++ b/Documentation/DocBook/gpu.tmpl @@ -2151,6 +2151,16 @@ void intel_crt_init(struct drm_device *dev) the underlying hardware).</td> </tr> <tr> + <td valign="top" > "zpos" </td> + <td valign="top" >RANGE</td> + <td valign="top" >Min= driver dependent, Max= driver dependent</td> + <td valign="top" >Plane</td> + <td valign="top" >Plane's 'z' position during blending operation (0 for background, highest for frontmost). + If two planes assigned to same CRTC have equal zpos values, the plane with higher plane + id is treated as closer to front. Can be IMMUTABLE if driver doesn't support changing + planes' order. Exact value range is driver dependent.</td> + </tr> + <tr> <td rowspan="20" valign="top" >i915</td> <td rowspan="2" valign="top" >Generic</td> <td valign="top" >"Broadcast RGB"</td> diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile index 2bd3e5a..df88253 100644 --- a/drivers/gpu/drm/Makefile +++ b/drivers/gpu/drm/Makefile @@ -2,7 +2,7 @@ # Makefile for the drm device driver. This driver provides support for the # Direct Rendering Infrastructure (DRI) in XFree86 4.1.0 and higher. -drm-y := drm_auth.o drm_bufs.o drm_cache.o \ +drm-y := drm_auth.o drm_bufs.o drm_blend.o drm_cache.o \ drm_context.o drm_dma.o \ drm_fops.o drm_gem.o drm_ioctl.o drm_irq.o \ drm_lock.o drm_memory.o drm_drv.o drm_vm.o \ diff --git a/drivers/gpu/drm/drm_atomic.c b/drivers/gpu/drm/drm_atomic.c index 86e89db..bd457ca 100644 --- a/drivers/gpu/drm/drm_atomic.c +++ b/drivers/gpu/drm/drm_atomic.c @@ -700,6 +700,8 @@ int drm_atomic_plane_set_property(struct drm_plane *plane, state->src_h = val; } else if (property == config->rotation_property) { state->rotation = val; + } else if (property == plane->zpos_property) { + state->zpos = val; } else if (plane->funcs->atomic_set_property) { return plane->funcs->atomic_set_property(plane, state, property, val); @@ -756,6 +758,8 @@ drm_atomic_plane_get_property(struct drm_plane *plane, *val = state->src_h; } else if (property == config->rotation_property) { *val = state->rotation; + } else if (property == plane->zpos_property) { + *val = state->zpos; } else if (plane->funcs->atomic_get_property) { return plane->funcs->atomic_get_property(plane, state, property, val); } else { diff --git a/drivers/gpu/drm/drm_atomic_helper.c b/drivers/gpu/drm/drm_atomic_helper.c index 997fd21..f10652f 100644 --- a/drivers/gpu/drm/drm_atomic_helper.c +++ b/drivers/gpu/drm/drm_atomic_helper.c @@ -32,6 +32,8 @@ #include <drm/drm_atomic_helper.h> #include <linux/fence.h> +#include "drm_crtc_internal.h" + /** * DOC: overview * @@ -587,6 +589,10 @@ drm_atomic_helper_check_planes(struct drm_device *dev, struct drm_plane_state *plane_state; int i, ret = 0; + ret = drm_atomic_helper_normalize_zpos(dev, state); + if (ret) + return ret; + for_each_plane_in_state(state, plane, plane_state, i) { const struct drm_plane_helper_funcs *funcs; diff --git a/drivers/gpu/drm/drm_blend.c b/drivers/gpu/drm/drm_blend.c new file mode 100644 index 0000000..eef59bb --- /dev/null +++ b/drivers/gpu/drm/drm_blend.c @@ -0,0 +1,229 @@ +/* + * Copyright (C) 2016 Samsung Electronics Co.Ltd + * Authors: + * Marek Szyprowski <m.szyprowski(a)samsung.com> + * + * DRM core plane blending related functions + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that copyright + * notice and this permission notice appear in supporting documentation, and + * that the name of the copyright holders not be used in advertising or + * publicity pertaining to distribution of the software without specific, + * written prior permission. The copyright holders make no representations + * about the suitability of this software for any purpose. It is provided "as + * is" without express or implied warranty. + * + * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE + * OF THIS SOFTWARE. + */ +#include <drm/drmP.h> +#include <drm/drm_atomic.h> +#include <drm/drm_crtc.h> +#include <linux/export.h> +#include <linux/slab.h> +#include <linux/sort.h> + +#include "drm_internal.h" + +/** + * drm_plane_create_zpos_property - create mutable zpos property + * @plane: drm plane + * @min: minimal possible value of zpos property + * @max: maximal possible value of zpos property + * + * This function initializes generic mutable zpos property and enables support + * for it in drm core. Drivers can then attach this property to planes to enable + * support for configurable planes arrangement during blending operation. + * Once mutable zpos property has been enabled, the DRM core will automatically + * calculate drm_plane_state->normalized_zpos values. Usually min should be set + * to 0 and max to maximal number of planes for given crtc - 1. + * + * If zpos of some planes cannot be changed (like fixed background or + * cursor/topmost planes), driver should adjust min/max values and assign those + * planes immutable zpos property with lower or higher values (for more + * information, see drm_mode_create_zpos_immutable_property() function). In such + * case driver should also assign proper initial zpos values for all planes in + * its plane_reset() callback, so the planes will be always sorted properly. + * + * Returns: + * Zero on success, negative errno on failure. + */ +int drm_plane_create_zpos_property(struct drm_plane *plane, + unsigned int min, unsigned int max) +{ + struct drm_property *prop; + + prop = drm_property_create_range(plane->dev, 0, "zpos", min, max); + if (!prop) + return -ENOMEM; + + drm_object_attach_property(&plane->base, prop, min); + + plane->zpos_property = prop; + return 0; +} +EXPORT_SYMBOL(drm_plane_create_zpos_property); + +/** + * drm_plane_create_zpos_immutable_property - create immuttable zpos property + * @plane: drm plane + * @min: minimal possible value of zpos property + * @max: maximal possible value of zpos property + * + * This function initializes generic immutable zpos property and enables + * support for it in drm core. Using this property driver lets userspace + * to get the arrangement of the planes for blending operation and notifies + * it that the hardware (or driver) doesn't support changing of the planes' + * order. + * + * Returns: + * Zero on success, negative errno on failure. + */ +int drm_plane_create_zpos_immutable_property(struct drm_plane *plane, + unsigned int min, unsigned int max) +{ + struct drm_property *prop; + + prop = drm_property_create_range(plane->dev, DRM_MODE_PROP_IMMUTABLE, + "zpos", min, max); + if (!prop) + return -ENOMEM; + + drm_object_attach_property(&plane->base, prop, min); + + plane->zpos_property = prop; + return 0; +} +EXPORT_SYMBOL(drm_plane_create_zpos_immutable_property); + +static int drm_atomic_state_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->zpos != sb->zpos) + return sa->zpos - sb->zpos; + else + return sa->plane->base.id - sb->plane->base.id; +} + +/** + * drm_atomic_helper_crtc_normalize_zpos - calculate normalized zpos values + * @crtc: crtc with planes, which have to be considered for normalization + * @crtc_state: new atomic state to apply + * + * This function checks new states of all planes assigned to given crtc and + * calculates normalized zpos value for them. Planes are compared first by their + * zpos values, then by plane id (if zpos equals). Plane with lowest zpos value + * is at the bottom. The plane_state->normalized_zpos is then filled with unique + * values from 0 to number of active planes in crtc minus one. + * + * RETURNS + * Zero for success or -errno + */ +int drm_atomic_helper_crtc_normalize_zpos(struct drm_crtc *crtc, + struct drm_crtc_state *crtc_state) +{ + struct drm_atomic_state *state = crtc_state->state; + struct drm_device *dev = crtc->dev; + int total_planes = dev->mode_config.num_total_plane; + struct drm_plane_state **states; + struct drm_plane *plane; + int i, zpos, n = 0; + int ret = 0; + + DRM_DEBUG_ATOMIC("[CRTC:%d:%s] calculating normalized zpos values\n", + crtc->base.id, crtc->name); + + states = kmalloc(total_planes * sizeof(*states), GFP_KERNEL); + if (!states) + return -ENOMEM; + + /* + * Normalization process might create new states for planes which + * normalized_zpos has to be recalculated. + */ + drm_for_each_plane_mask(plane, dev, crtc_state->plane_mask) { + struct drm_plane_state *plane_state = + drm_atomic_get_plane_state(state, plane); + if (IS_ERR(plane_state)) { + ret = PTR_ERR(plane_state); + goto done; + } + states[n++] = plane_state; + DRM_DEBUG_ATOMIC("[PLANE:%d:%s] processing zpos value %d\n", + plane->base.id, plane->name, + plane_state->zpos); + } + + sort(states, n, sizeof(*states), drm_atomic_state_zpos_cmp, NULL); + + for (i = 0, zpos = 0; i < n; i++, zpos++) { + plane = states[i]->plane; + + zpos = max_t(int, zpos, states[i]->zpos); + + states[i]->normalized_zpos = zpos; + DRM_DEBUG_ATOMIC("[PLANE:%d:%s] normalized zpos value %d\n", + plane->base.id, plane->name, zpos); + } + crtc_state->zpos_changed = true; + +done: + kfree(states); + return ret; +} +EXPORT_SYMBOL(drm_atomic_helper_crtc_normalize_zpos); + +/** + * drm_atomic_helper_normalize_zpos - calculate normalized zpos values for all + * crtcs + * @dev: DRM device + * @state: atomic state of DRM device + * + * This function calculates normalized zpos value for all modified planes in + * the provided atomic state of DRM device. For more information, see + * drm_atomic_helper_crtc_normalize_zpos() function. + * + * RETURNS + * Zero for success or -errno + */ +int drm_atomic_helper_normalize_zpos(struct drm_device *dev, + struct drm_atomic_state *state) +{ + struct drm_crtc *crtc; + struct drm_crtc_state *crtc_state; + struct drm_plane *plane; + struct drm_plane_state *plane_state; + int i, ret = 0; + + for_each_plane_in_state(state, plane, plane_state, i) { + crtc = plane_state->crtc; + if (!crtc) + continue; + if (plane->state->zpos != plane_state->zpos) { + crtc_state = + drm_atomic_get_existing_crtc_state(state, crtc); + crtc_state->zpos_changed = true; + } + } + + for_each_crtc_in_state(state, crtc, crtc_state, i) { + if (crtc_state->plane_mask != crtc->state->plane_mask || + crtc_state->zpos_changed) { + ret = drm_atomic_helper_crtc_normalize_zpos(crtc, + crtc_state); + if (ret) + return ret; + } + } + return 0; +} +EXPORT_SYMBOL(drm_atomic_helper_normalize_zpos); diff --git a/drivers/gpu/drm/drm_crtc_internal.h b/drivers/gpu/drm/drm_crtc_internal.h index a78c138..37d9068 100644 --- a/drivers/gpu/drm/drm_crtc_internal.h +++ b/drivers/gpu/drm/drm_crtc_internal.h @@ -42,3 +42,6 @@ int drm_atomic_get_property(struct drm_mode_object *obj, int drm_mode_atomic_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv); +/* drm_blend.c */ +int drm_atomic_helper_normalize_zpos(struct drm_device *dev, + struct drm_atomic_state *state); diff --git a/include/drm/drm_crtc.h b/include/drm/drm_crtc.h index d1559cd..921c93f 100644 --- a/include/drm/drm_crtc.h +++ b/include/drm/drm_crtc.h @@ -305,6 +305,7 @@ struct drm_plane_helper_funcs; * @mode_changed: crtc_state->mode or crtc_state->enable has been changed * @active_changed: crtc_state->active has been toggled. * @connectors_changed: connectors to this crtc have been updated + * @zpos_changed: zpos values of planes on this crtc have been updated * @color_mgmt_changed: color management properties have changed (degamma or * gamma LUT or CSC matrix) * @plane_mask: bitmask of (1 << drm_plane_index(plane)) of attached planes @@ -340,6 +341,7 @@ struct drm_crtc_state { bool mode_changed : 1; bool active_changed : 1; bool connectors_changed : 1; + bool zpos_changed : 1; bool color_mgmt_changed : 1; /* attached planes bitmask: @@ -1263,6 +1265,9 @@ struct drm_connector { * plane (in 16.16) * @src_w: width of visible portion of plane (in 16.16) * @src_h: height of visible portion of plane (in 16.16) + * @zpos: priority of the given plane on crtc (optional) + * @normalized_zpos: normalized value of zpos: unique, range from 0 to N-1 + * for given crtc * @state: backpointer to global drm_atomic_state */ struct drm_plane_state { @@ -1283,6 +1288,10 @@ struct drm_plane_state { /* Plane rotation */ unsigned int rotation; + /* Plane zpos */ + unsigned int zpos; + unsigned int normalized_zpos; + struct drm_atomic_state *state; }; @@ -1516,6 +1525,7 @@ enum drm_plane_type { * @properties: property tracking for this plane * @type: type of plane (overlay, primary, cursor) * @state: current atomic state for this plane + * @zpos_property: zpos property for this plane */ struct drm_plane { struct drm_device *dev; @@ -1546,6 +1556,8 @@ struct drm_plane { const struct drm_plane_helper_funcs *helper_private; struct drm_plane_state *state; + + struct drm_property *zpos_property; }; /** @@ -2554,6 +2566,22 @@ extern struct drm_property *drm_mode_create_rotation_property(struct drm_device extern unsigned int drm_rotation_simplify(unsigned int rotation, unsigned int supported_rotations); +int drm_plane_atomic_set_zpos_property(struct drm_plane *plane, + struct drm_plane_state *state, + struct drm_property *property, + uint64_t val); + +int drm_plane_atomic_get_zpos_property(struct drm_plane *plane, + const struct drm_plane_state *state, + struct drm_property *property, + uint64_t *val); + +int drm_plane_create_zpos_property(struct drm_plane *plane, + unsigned int min, unsigned int max); +int drm_plane_create_zpos_immutable_property(struct drm_plane *plane, + unsigned int min, + unsigned int max); + /* Helpers */ static inline struct drm_plane *drm_plane_find(struct drm_device *dev, -- 1.9.1

9 years, 3 months

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

Linaro-mm-sig