Linaro-mm-sig

linaro-mm-sig@lists.linaro.org

24 participants
2727 discussions

[PATCH 00/10] Integration of videobuf2 with dmabuf

by Tomasz Stanislawski

Hello everyone, This patchset is an incremental patch to patchset created by Sumit Semwal [1]. The patches are dedicated to help find a better solution for support of buffer sharing by V4L2 API. It is expected to start discussion on final installment for dma-buf in vb2-dma-contig allocator. Current version of the patches contain little documentation. It is going to be fixed after achieving consensus about design for buffer exporting. Moreover the API between vb2-core and the allocator should be revised. The amount of changes to vb2-dma-contig.c was significant making the difference patch very difficult to read. Therefore the patch was split into two parts. One removes old file, the next patch creates the version of the file. The patchset contains extension for DMA API and its implementation for ARM architecture. Therefore the patchset should be applied on the top of: http://git.infradead.org/users/kmpark/linux-2.6-samsung/shortlog/refs/heads… After applying patches from [2] and [1]. v1: List of changes since [1]. - support for DMA api extension dma_get_pages, the function is used to retrieve pages used to create DMA mapping. - small fixes/code cleanup to videobuf2 - added prepare and finish callbacks to vb2 allocators, it is used keep consistency between dma-cpu acess to the memory (by Marek Szyprowski) - support for exporting of DMABUF buffer in V4L2 and Videobuf2, originated from [3]. - support for dma-buf exporting in vb2-dma-contig allocator - support for DMABUF for s5p-tv and s5p-fimc (capture interface) drivers, originated from [3] - changed handling for userptr buffers (by Marek Szyprowski, Andrzej Pietrasiewicz) - let mmap method to use dma_mmap_writecombine call (by Marek Szyprowski) [1] http://thread.gmane.org/gmane.linux.drivers.video-input-infrastructure/4296… [2] https://lkml.org/lkml/2011/12/26/29 [3] http://thread.gmane.org/gmane.linux.drivers.video-input-infrastructure/3635… Marek Szyprowski (2): [media] media: vb2: remove plane argument from call_memop and cleanup mempriv usage media: vb2: add prepare/finish callbacks to allocators Tomasz Stanislawski (8): arm: dma: support for dma_get_pages v4l: vb2: fixes for DMABUF support v4l: add buffer exporting via dmabuf v4l: vb2: add buffer exporting via dmabuf v4l: vb2: remove dma-contig allocator v4l: vb2-dma-contig: code refactoring, support for DMABUF exporting v4l: fimc: integrate capture i-face with dmabuf v4l: s5p-tv: mixer: integrate with dmabuf arch/arm/include/asm/dma-mapping.h | 8 + arch/arm/mm/dma-mapping.c | 44 ++ drivers/media/video/s5p-fimc/fimc-capture.c | 11 +- drivers/media/video/s5p-tv/mixer_video.c | 11 +- drivers/media/video/v4l2-compat-ioctl32.c | 1 + drivers/media/video/v4l2-ioctl.c | 11 + drivers/media/video/videobuf2-core.c | 114 ++++- drivers/media/video/videobuf2-dma-contig.c | 754 +++++++++++++++++++++------ include/linux/dma-mapping.h | 2 + include/linux/videodev2.h | 1 + include/media/v4l2-ioctl.h | 1 + include/media/videobuf2-core.h | 10 +- 12 files changed, 789 insertions(+), 179 deletions(-) -- 1.7.5.4

13 years, 1 month

[PATCH v4 0/4] Add CMA heap for ION memory manager

by benjamin.gaignard＠stericsson.com

From: Benjamin Gaignard <benjamin.gaignard(a)linaro.org> The goal of those patches is to allow ION clients (drivers or userland applications) to use Contiguous Memory Allocator (CMA). To get more info about CMA: http://lists.linaro.org/pipermail/linaro-mm-sig/2012-February/001328.html patches version 4: - add ION_HEAP_TYPE_DMA heap type in ion_heap_type enum. - CMA heap is now a "native" ION heap. - add ion_heap_create_full function to keep backward compatibilty. - clean up included files in CMA heap - ux500-ion is using ion_heap_create_full instead of ion_heap_create patches version 3: - add a private field in ion_heap structure instead of expose ion_device structure to all heaps - ion_cma_heap is no more a platform driver - ion_cma_heap use ion_heap private field to store the device pointer and make the link with reserved CMA regions - provide ux500-ion driver and configuration file for snowball board to give an example of how use CMA heaps patches version 2: - fix comments done by Andy Green Benjamin Gaignard (4): fix ion_platform_data definition add private field in ion_heap structure add CMA heap add test/example driver for ux500 platform arch/arm/mach-ux500/board-mop500.c | 77 +++++++++++++++++++ drivers/gpu/ion/Kconfig | 6 ++ drivers/gpu/ion/Makefile | 4 +- drivers/gpu/ion/ion_cma_heap.c | 129 ++++++++++++++++++++++++++++++++ drivers/gpu/ion/ion_heap.c | 14 +++- drivers/gpu/ion/ion_priv.h | 11 +++ drivers/gpu/ion/ux500/Makefile | 1 + drivers/gpu/ion/ux500/ux500_ion.c | 142 ++++++++++++++++++++++++++++++++++++ include/linux/ion.h | 5 +- 9 files changed, 386 insertions(+), 3 deletions(-) create mode 100644 drivers/gpu/ion/ion_cma_heap.c create mode 100644 drivers/gpu/ion/ux500/Makefile create mode 100644 drivers/gpu/ion/ux500/ux500_ion.c

13 years, 1 month

Re: [Linaro-mm-sig] [PATCH] RFC: dma-buf: userspace mmap support

by Alan Cox

> If the API was to also be used for synchronization it would have to > include an atomic "prepare multiple" ioctl which blocked until all > the buffers listed by the application were available. In the same Too slow already. You are now serializing stuff while what we want to do really is nobody_else_gets_buffers_next([list]) on available(buffer) dispatch_work(buffer) so that you can maximise parallelism without allowing deadlocks. If you've got a high memory bandwith and 8+ cores the 'stop everything' model isn't great. > This might be a good argument for keeping synchronization and cache > maintenance separate, though even ignoring synchronization I would > think being able to issue cache maintenance operations for multiple > buffers in a single ioctl might present some small efficiency gains. > However as Rob points out, CPU access is already in slow/legacy > territory. Dangerous assumption. I do think they should be separate. For one it makes the case of synchronization needed but hardware cache management much easier to split cleanly. Assuming CPU access is slow/legacy reflects a certain model of relatively slow CPU and accelerators where falling off the acceleration path is bad. On a higher end processor falling off the acceleration path isn't a performance matter so much as a power concern. > KDS we differentiated jobs which needed "exclusive access" to a > buffer and jobs which needed "shared access" to a buffer. Multiple > jobs could access a buffer at the same time if those jobs all Makes sense as it's a reader/writer lock and it reflects MESI/MOESI caching and cache policy in some hardware/software assists. > display controller will be reading the front buffer, but the GPU > might also need to read that front buffer. So perhaps adding > "read-only" & "read-write" access flags to prepare could also be > interpreted as shared & exclusive accesses, if we went down this > route for synchronization that is. :-) mmap includes read/write info so probably using that works out. It also means that you have the stuff mapped in a way that will bus error or segfault anyone who goofs rather than give them the usual 'deep weirdness' behaviour you get with mishandling of caching bits. Alan

13 years, 1 month

Re: [Linaro-mm-sig] [PATCH] RFC: dma-buf: userspace mmap support

by Alan Cox

> > dma-buf file descriptor. Userspace access to the buffer should be > > bracketed with DMA_BUF_IOCTL_{PREPARE,FINISH}_ACCESS ioctl calls to > > give the exporting driver a chance to deal with cache synchronization > > and such for cached userspace mappings without resorting to page There should be flags indicating if this is necessary. We don't want extra syscalls on hardware that doesn't need it. The other question is what info is needed as you may only want to poke a few pages out of cache and the prepare/finish on its own gives no info. > E.g. If another device was writing to the buffer, the prepare ioctl > could block until that device had finished accessing that buffer. How do you avoid deadlocks on this ? We need very clear ways to ensure things always complete in some form given multiple buffer owner/requestors and the fact this API has no "prepare-multiple-buffers" support. Alan

13 years, 1 month

[PATCH] dma-buf: pass flags into dma_buf_fd.

by Dave Airlie

From: Dave Airlie <airlied(a)redhat.com> We need to pass the flags into dma_buf_fd at this point, so the flags end up doing the right thing for O_CLOEXEC. Signed-off-by: Dave Airlie <airlied(a)redhat.com> --- drivers/base/dma-buf.c | 5 +++-- include/linux/dma-buf.h | 2 +- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/drivers/base/dma-buf.c b/drivers/base/dma-buf.c index c9a945f..3c8c023 100644 --- a/drivers/base/dma-buf.c +++ b/drivers/base/dma-buf.c @@ -107,17 +107,18 @@ EXPORT_SYMBOL_GPL(dma_buf_export); /** * dma_buf_fd - returns a file descriptor for the given dma_buf * @dmabuf: [in] pointer to dma_buf for which fd is required. + * @flags: [in] flags to give to fd * * On success, returns an associated 'fd'. Else, returns error. */ -int dma_buf_fd(struct dma_buf *dmabuf) +int dma_buf_fd(struct dma_buf *dmabuf, int flags) { int error, fd; if (!dmabuf || !dmabuf->file) return -EINVAL; - error = get_unused_fd(); + error = get_unused_fd_flags(flags); if (error < 0) return error; fd = error; diff --git a/include/linux/dma-buf.h b/include/linux/dma-buf.h index a885b26..891457a 100644 --- a/include/linux/dma-buf.h +++ b/include/linux/dma-buf.h @@ -117,7 +117,7 @@ void dma_buf_detach(struct dma_buf *dmabuf, struct dma_buf_attachment *dmabuf_attach); struct dma_buf *dma_buf_export(void *priv, const struct dma_buf_ops *ops, size_t size, int flags); -int dma_buf_fd(struct dma_buf *dmabuf); +int dma_buf_fd(struct dma_buf *dmabuf, int flags); struct dma_buf *dma_buf_get(int fd); void dma_buf_put(struct dma_buf *dmabuf); -- 1.7.6

13 years, 1 month

[PATCH] dma-buf: add get_dma_buf()

by Rob Clark

From: Rob Clark <rob(a)ti.com> Works in a similar way to get_file(), and is needed in cases such as when the exporter needs to also keep a reference to the dmabuf (that is later released with a dma_buf_put()), and possibly other similar cases. Signed-off-by: Rob Clark <rob(a)ti.com> --- Minor update on original to add a missing #include include/linux/dma-buf.h | 15 +++++++++++++++ 1 files changed, 15 insertions(+), 0 deletions(-) diff --git a/include/linux/dma-buf.h b/include/linux/dma-buf.h index 891457a..bc4203dc 100644 --- a/include/linux/dma-buf.h +++ b/include/linux/dma-buf.h @@ -30,6 +30,7 @@ #include <linux/scatterlist.h> #include <linux/list.h> #include <linux/dma-mapping.h> +#include <linux/fs.h> struct dma_buf; struct dma_buf_attachment; @@ -110,6 +111,20 @@ struct dma_buf_attachment { void *priv; }; +/** + * get_dma_buf - convenience wrapper for get_file. + * @dmabuf: [in] pointer to dma_buf + * + * Increments the reference count on the dma-buf, needed in case of drivers + * that either need to create additional references to the dmabuf on the + * kernel side. For example, an exporter that needs to keep a dmabuf ptr + * so that subsequent exports don't create a new dmabuf. + */ +static inline void get_dma_buf(struct dma_buf *dmabuf) +{ + get_file(dmabuf->file); +} + #ifdef CONFIG_DMA_SHARED_BUFFER struct dma_buf_attachment *dma_buf_attach(struct dma_buf *dmabuf, struct device *dev); -- 1.7.5.4

13 years, 1 month

Re: [Linaro-mm-sig] [PATCH] RFC: dma-buf: userspace mmap support

by Rob Clark

On Fri, Mar 16, 2012 at 12:24 PM, Tom Cooksey <tom.cooksey(a)arm.com> wrote: > >> From: Rob Clark <rob(a)ti.com> >> >> Enable optional userspace access to dma-buf buffers via mmap() on the >> dma-buf file descriptor. Userspace access to the buffer should be >> bracketed with DMA_BUF_IOCTL_{PREPARE,FINISH}_ACCESS ioctl calls to >> give the exporting driver a chance to deal with cache synchronization >> and such for cached userspace mappings without resorting to page >> faulting tricks. The reasoning behind this is that, while drm >> drivers tend to have all the mechanisms in place for dealing with >> page faulting tricks, other driver subsystems may not. And in >> addition, while page faulting tricks make userspace simpler, there >> are some associated overheads. > > Speaking for the ARM Mali T6xx driver point of view, this API looks > good for us. Our use-case for mmap is glReadPixels and > glTex[Sub]Image2D on buffers the driver has imported via dma_buf. In > the case of glReadPixels, the finish ioctl isn't strictly necessary > as the CPU won't have written to the buffer and so doesn't need > flushing. As such, we'd get an additional cache flush which isn't > really necessary. But hey, it's glReadPixels - it's supposed to be > slow. :-) > > I think requiring the finish ioctl in the API contract is a good > idea, even if the CPU has only done a ro access as it allows future > enhancements*. To "fix" the unnecessary flush in glReadPixels, I > think we'd like to keep the finish but see an "access type" > parameter added to prepare ioctl indicating if the access is ro or > rw to allow the cache flush in finish to be skipped if the access > was ro. As Rebecca says, a debug feature could even be added to > re-map the pages as ro in prepare(ro) to catch naughty accesses. I'd > also go as far as to say the debug feature should completely unmap > the pages after finish too. Though for us, both the access-type > parameter and debug features are "nice to haves" - we can make > progress with the code as it currently stands (assuming exporters > start using the API that is). Perhaps it isn't a bad idea to include access-type bitmask in the first version. It would help optimize a bit the cache operations. > Something which also came up when discussing internally is the topic > of mmap APIs of the importing device driver. For example, I believe > DRM has an mmap API on GEM buffer objects. If a new dma_buf import > ioctl was added to GEM (maybe the PRIME patches already add this), > how would GEM's bo mmap API work? My first thought is maybe we should just dis-allow this for now until we have a chance to see if there are any possible issues with an importer mmap'ing the buffer to userspace. We could possible have a helper dma_buf_mmap() fxn which in turn calls dmabuf ops->mmap() so the mmap'ing is actually performed by the exporter on behalf of the importer. > > * Future enhancements: The prepare/finish bracketing could be used > as part of a wider synchronization scheme with other devices. > E.g. If another device was writing to the buffer, the prepare ioctl > could block until that device had finished accessing that buffer. > In the same way, another device could be blocked from accessing that > buffer until the client process called finish. We have already > started playing with such a scheme in the T6xx driver stack we're > terming "kernel dependency system". In this scheme each buffer has a > FIFO of "buffer consumers" waiting to access a buffer. The idea > being that a "buffer consumer" is fairly abstract and could be any > device or userspace process participating in the synchronization > scheme. Examples would be GPU jobs, display controller "scan-out" > jobs, etc. > > So for example, a userspace application could dispatch a GPU > fragment shading job into the GPU's kernel driver which will write > to a KMS scanout buffer. The application then immediately issues a > drm_mode_crtc_page_flip ioctl on the display controller's DRM driver > to display the soon-to-be-rendered buffer. Inside the kernel, the > GPU driver adds the fragment job to the dma_buf's FIFO. As the FIFO > was empty, dma_buf calls into the GPU kernel driver to tell it it > "owns" access to the buffer and the GPU driver schedules the job to > run on the GPU. Upon receiving the drm_mode_crtc_page_flip ioctl, > the DRM/KMS driver adds a scan-out job to the buffer's FIFO. > However, the FIFO already has the GPU's fragment shading job in it > so nothing happens until the GPU job completes. When the GPU job > completes, the GPU driver calls into dma_buf to mark its job > complete. dma_buf then takes the next job in its FIFO which the KMS > driver's scanout job, calls into the KMS driver to schedule the > pageflip. The result? A buffer gets scanned out as soon as it has > finished being rendered without needing a round-trip to userspace. > Sure, there are easier ways to achieve that goal, but the idea is > that the mechanism can be used to synchronize access across multiple > devices, which makes it useful for lots of other use-cases too. > > > As I say, we have already implemented something which works as I > describe but where the buffers are abstract resources not linked to > dma_buf. I'd like to discuss the finer points of the mechanisms > further, but if it's looking like there's interest in this approach > we'll start re-writing the code we have to sit on-top of dma_buf > and posting it as RFCs to the various lists. The intention is to get > this to mainline, if mainline wants it. :-) I think we do need some sort of 'sync object' (which might really just be a 'synchronization queue' object) in the kernel. It probably shouldn't be built-in to dma-buf, but I expect we'd want the dma_buf struct to have a 'struct sync_queue *' (or whatever it ends up being called). The sync-queue seems like a reasonable approach for pure cpu-sw based synchronization. The only thing I'm not sure is how to also deal with hw that supports any sort of auto synchronization without cpu sw involvement. BR, -R > Personally, what I particularly like about this approach to > synchronization is that it doesn't require any interfaces to be > modified. I think/hope that makes it easier to port existing drivers > and sub-systems to take advantage of it. The buffer itself is the > synchronization object and interfaces already pass buffers around so > don't need modification. There are of course some limitations with > this approach, the main one we can think of being that it can't > really be used for A/V sync. It kinda assumes "jobs" in the FIFO > should be run as soon as the preceding job completes, which isn't > the case when streaming real-time video. Though nothing precludes > more explicit sync objects being used in conjunction with this > approach. > > > Cheers, > > Tom > > > > > > _______________________________________________ > dri-devel mailing list > dri-devel(a)lists.freedesktop.org > http://lists.freedesktop.org/mailman/listinfo/dri-devel

13 years, 1 month

[PATCH] RFC: dma-buf: userspace mmap support

by Rob Clark

From: Rob Clark <rob(a)ti.com> Enable optional userspace access to dma-buf buffers via mmap() on the dma-buf file descriptor. Userspace access to the buffer should be bracketed with DMA_BUF_IOCTL_{PREPARE,FINISH}_ACCESS ioctl calls to give the exporting driver a chance to deal with cache synchronization and such for cached userspace mappings without resorting to page faulting tricks. The reasoning behind this is that, while drm drivers tend to have all the mechanisms in place for dealing with page faulting tricks, other driver subsystems may not. And in addition, while page faulting tricks make userspace simpler, there are some associated overheads. In all cases, the mmap() call is allowed to fail, and the associated dma_buf_ops are optional (mmap() will fail if at least the mmap() op is not implemented by the exporter, but in either case the {prepare,finish}_access() ops are optional). For now the prepare/finish access ioctls are kept simple with no argument, although there is possibility to add additional ioctls (or simply change the existing ioctls from _IO() to _IOW()) later to provide optimization to allow userspace to specify a region of interest. For a final patch, dma-buf.h would need to be split into what is exported to userspace, and what is kernel private, but I wanted to get feedback on the idea of requiring userspace to bracket access first (vs. limiting this to coherent mappings or exporters who play page faltings plus PTE shoot-down games) before I split the header which would cause conflicts with other pending dma-buf patches. So flame-on! --- drivers/base/dma-buf.c | 42 ++++++++++++++++++++++++++++++++++++++++++ include/linux/dma-buf.h | 22 ++++++++++++++++++++++ 2 files changed, 64 insertions(+), 0 deletions(-) diff --git a/drivers/base/dma-buf.c b/drivers/base/dma-buf.c index c9a945f..382b78a 100644 --- a/drivers/base/dma-buf.c +++ b/drivers/base/dma-buf.c @@ -30,6 +30,46 @@ static inline int is_dma_buf_file(struct file *); +static int dma_buf_mmap(struct file *file, struct vm_area_struct *vma) +{ + struct dma_buf *dmabuf; + + if (!is_dma_buf_file(file)) + return -EINVAL; + + dmabuf = file->private_data; + + if (dmabuf->ops->mmap) + return dmabuf->ops->mmap(dmabuf, file, vma); + + return -ENODEV; +} + +static long dma_buf_ioctl(struct file *file, unsigned int cmd, + unsigned long arg) +{ + struct dma_buf *dmabuf; + + if (!is_dma_buf_file(file)) + return -EINVAL; + + dmabuf = file->private_data; + + switch (_IOC_NR(cmd)) { + case _IOC_NR(DMA_BUF_IOCTL_PREPARE_ACCESS): + if (dmabuf->ops->prepare_access) + return dmabuf->ops->prepare_access(dmabuf); + return 0; + case _IOC_NR(DMA_BUF_IOCTL_FINISH_ACCESS): + if (dmabuf->ops->finish_access) + return dmabuf->ops->finish_access(dmabuf); + return 0; + default: + return -EINVAL; + } +} + + static int dma_buf_release(struct inode *inode, struct file *file) { struct dma_buf *dmabuf; @@ -45,6 +85,8 @@ static int dma_buf_release(struct inode *inode, struct file *file) } static const struct file_operations dma_buf_fops = { + .mmap = dma_buf_mmap, + .unlocked_ioctl = dma_buf_ioctl, .release = dma_buf_release, }; diff --git a/include/linux/dma-buf.h b/include/linux/dma-buf.h index a885b26..cbdff81 100644 --- a/include/linux/dma-buf.h +++ b/include/linux/dma-buf.h @@ -34,6 +34,17 @@ struct dma_buf; struct dma_buf_attachment; +/* TODO: dma-buf.h should be the userspace visible header, and dma-buf-priv.h (?) + * the kernel internal header.. for now just stuff these here to avoid conflicting + * with other patches.. + * + * For now, no arg to keep things simple, but we could consider adding an + * optional region of interest later. + */ +#define DMA_BUF_IOCTL_PREPARE_ACCESS _IO('Z', 0) +#define DMA_BUF_IOCTL_FINISH_ACCESS _IO('Z', 1) + + /** * struct dma_buf_ops - operations possible on struct dma_buf * @attach: [optional] allows different devices to 'attach' themselves to the @@ -49,6 +60,13 @@ struct dma_buf_attachment; * @unmap_dma_buf: decreases usecount of buffer, might deallocate scatter * pages. * @release: release this buffer; to be called after the last dma_buf_put. + * @mmap: [optional, allowed to fail] operation called if userspace calls + * mmap() on the dmabuf fd. Note that userspace should use the + * DMA_BUF_PREPARE_ACCESS / DMA_BUF_FINISH_ACCESS ioctls before/after + * sw access to the buffer, to give the exporter an opportunity to + * deal with cache maintenance. + * @prepare_access: [optional] handler for PREPARE_ACCESS ioctl. + * @finish_access: [optional] handler for FINISH_ACCESS ioctl. */ struct dma_buf_ops { int (*attach)(struct dma_buf *, struct device *, @@ -72,6 +90,10 @@ struct dma_buf_ops { /* after final dma_buf_put() */ void (*release)(struct dma_buf *); + int (*mmap)(struct dma_buf *, struct file *, struct vm_area_struct *); + int (*prepare_access)(struct dma_buf *); + int (*finish_access)(struct dma_buf *); + }; /** -- 1.7.5.4

13 years, 1 month

expected userspace prime/dma-buf usage

by Dave Airlie

Just wondering how we expect userspace to use dma-buf/prime interfaces. Currently I see one driver in sharing the buffer with handle->fd, then passing the fd to the other driver and it using fd->handle, do we then expect the importing driver to close the fd? Dave.

13 years, 1 month

[PATCH v3 0/4] Add CMA heap for ION memory manager

by benjamin.gaignard＠stericsson.com

From: benjamin gaignard <benjamin.gaignard(a)linaro.org> The goal of those patches is to allow ION clients (drivers or userland applications) to use Contiguous Memory Allocator (CMA). To get more info about CMA: http://lists.linaro.org/pipermail/linaro-mm-sig/2012-February/001328.html patches version 3: - add a private field in ion_heap structure instead of expose ion_device structure to all heaps - ion_cma_heap is no more a platform driver - ion_cma_heap use ion_heap private field to store the device pointer and make the link with reserved CMA regions - provide ux500-ion driver and configuration file for snowball board to give an example of how use CMA heaps patches version 2: - fix comments done by Andy Green Benjamin Gaignard (1): fix ion_platform_data definition add private field in ion_heap structure add CMA heap add test/example driver for ux500 platform arch/arm/mach-ux500/board-mop500.c | 80 +++++++++++++++++++ drivers/gpu/ion/Kconfig | 6 ++ drivers/gpu/ion/Makefile | 2 + drivers/gpu/ion/cma/Makefile | 1 + drivers/gpu/ion/cma/ion_cma_heap.c | 126 ++++++++++++++++++++++++++++++ drivers/gpu/ion/cma/ion_cma_heap.h | 11 +++ drivers/gpu/ion/ion_priv.h | 2 + drivers/gpu/ion/ux500/Makefile | 1 + drivers/gpu/ion/ux500/ux500_ion.c | 147 ++++++++++++++++++++++++++++++++++++ include/linux/ion.h | 2 +- 10 files changed, 377 insertions(+), 1 deletions(-) create mode 100644 drivers/gpu/ion/cma/Makefile create mode 100644 drivers/gpu/ion/cma/ion_cma_heap.c create mode 100644 drivers/gpu/ion/cma/ion_cma_heap.h create mode 100644 drivers/gpu/ion/ux500/Makefile create mode 100644 drivers/gpu/ion/ux500/ux500_ion.c

13 years, 1 month

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

Linaro-mm-sig