Le mar. 5 mars 2019 à 21:54, John Stultz <john.stu...@linaro.org> a écrit : > > This adds a CMA heap, which allows userspace to allocate > a dma-buf of contiguous memory out of a CMA region. > > This code is an evolution of the Android ION implementation, so > thanks to its original author and maintainters: > Benjamin Gaignard, Laura Abbott, and others! > > Cc: Laura Abbott <labb...@redhat.com> > Cc: Benjamin Gaignard <benjamin.gaign...@linaro.org> > Cc: Greg KH <gre...@linuxfoundation.org> > Cc: Sumit Semwal <sumit.sem...@linaro.org> > Cc: Liam Mark <lm...@codeaurora.org> > Cc: Brian Starkey <brian.star...@arm.com> > Cc: Andrew F. Davis <a...@ti.com> > Cc: Chenbo Feng <fe...@google.com> > Cc: Alistair Strachan <astrac...@google.com> > Cc: dri-devel@lists.freedesktop.org > Signed-off-by: John Stultz <john.stu...@linaro.org> > --- > v2: > * Switch allocate to return dmabuf fd > * Simplify init code > * Checkpatch fixups > --- > drivers/dma-buf/heaps/Kconfig | 8 ++ > drivers/dma-buf/heaps/Makefile | 1 + > drivers/dma-buf/heaps/cma_heap.c | 164 > +++++++++++++++++++++++++++++++++++++++ > 3 files changed, 173 insertions(+) > create mode 100644 drivers/dma-buf/heaps/cma_heap.c > > diff --git a/drivers/dma-buf/heaps/Kconfig b/drivers/dma-buf/heaps/Kconfig > index 2050527..a5eef06 100644 > --- a/drivers/dma-buf/heaps/Kconfig > +++ b/drivers/dma-buf/heaps/Kconfig > @@ -4,3 +4,11 @@ config DMABUF_HEAPS_SYSTEM > help > Choose this option to enable the system dmabuf heap. The system heap > is backed by pages from the buddy allocator. If in doubt, say Y. > + > +config DMABUF_HEAPS_CMA > + bool "DMA-BUF CMA Heap" > + depends on DMABUF_HEAPS && DMA_CMA > + help > + Choose this option to enable dma-buf CMA heap. This heap is backed > + by the Contiguous Memory Allocator (CMA). If your system has these > + regions, you should say Y here. > diff --git a/drivers/dma-buf/heaps/Makefile b/drivers/dma-buf/heaps/Makefile > index d1808ec..6e54cde 100644 > --- a/drivers/dma-buf/heaps/Makefile > +++ b/drivers/dma-buf/heaps/Makefile > @@ -1,3 +1,4 @@ > # SPDX-License-Identifier: GPL-2.0 > obj-y += heap-helpers.o > obj-$(CONFIG_DMABUF_HEAPS_SYSTEM) += system_heap.o > +obj-$(CONFIG_DMABUF_HEAPS_CMA) += cma_heap.o > diff --git a/drivers/dma-buf/heaps/cma_heap.c > b/drivers/dma-buf/heaps/cma_heap.c > new file mode 100644 > index 0000000..33c18ec > --- /dev/null > +++ b/drivers/dma-buf/heaps/cma_heap.c > @@ -0,0 +1,164 @@ > +// SPDX-License-Identifier: GPL-2.0 > +/* > + * DMABUF CMA heap exporter > + * > + * Copyright (C) 2012, 2019 Linaro Ltd. > + * Author: <benjamin.gaign...@linaro.org> for ST-Ericsson. > + */ > + > +#include <linux/device.h> > +#include <linux/dma-buf.h> > +#include <linux/dma-heap.h> > +#include <linux/slab.h> > +#include <linux/errno.h> > +#include <linux/err.h> > +#include <linux/cma.h> > +#include <linux/scatterlist.h> > +#include <linux/highmem.h> > + > +#include "heap-helpers.h" > + > +struct cma_heap { > + struct dma_heap heap; > + struct cma *cma; > +}; > + > + > +#define to_cma_heap(x) container_of(x, struct cma_heap, heap)
Even if I had write this macro years ago, now I would prefer to have a static inline function to be able to check the types. with that: Reviewed-by: Benjamin Gaignard <benjamin.gaign...@linaro.org> > + > + > +static void cma_heap_free(struct heap_helper_buffer *buffer) > +{ > + struct cma_heap *cma_heap = to_cma_heap(buffer->heap_buffer.heap); > + struct page *pages = buffer->priv_virt; > + unsigned long nr_pages; > + > + nr_pages = PAGE_ALIGN(buffer->heap_buffer.size) >> PAGE_SHIFT; > + > + /* release memory */ > + cma_release(cma_heap->cma, pages, nr_pages); > + /* release sg table */ > + sg_free_table(buffer->sg_table); > + kfree(buffer->sg_table); > + kfree(buffer); > +} > + > +/* dmabuf heap CMA operations functions */ > +static int cma_heap_allocate(struct dma_heap *heap, > + unsigned long len, > + unsigned long flags) > +{ > + struct cma_heap *cma_heap = to_cma_heap(heap); > + struct heap_helper_buffer *helper_buffer; > + struct sg_table *table; > + struct page *pages; > + size_t size = PAGE_ALIGN(len); > + unsigned long nr_pages = size >> PAGE_SHIFT; > + unsigned long align = get_order(size); > + DEFINE_DMA_BUF_EXPORT_INFO(exp_info); > + struct dma_buf *dmabuf; > + int ret = -ENOMEM; > + > + if (align > CONFIG_CMA_ALIGNMENT) > + align = CONFIG_CMA_ALIGNMENT; > + > + helper_buffer = kzalloc(sizeof(*helper_buffer), GFP_KERNEL); > + if (!helper_buffer) > + return -ENOMEM; > + > + INIT_HEAP_HELPER_BUFFER(helper_buffer, cma_heap_free); > + helper_buffer->heap_buffer.flags = flags; > + helper_buffer->heap_buffer.heap = heap; > + helper_buffer->heap_buffer.size = len; > + > + > + pages = cma_alloc(cma_heap->cma, nr_pages, align, false); > + if (!pages) > + goto free_buf; > + > + if (PageHighMem(pages)) { > + unsigned long nr_clear_pages = nr_pages; > + struct page *page = pages; > + > + while (nr_clear_pages > 0) { > + void *vaddr = kmap_atomic(page); > + > + memset(vaddr, 0, PAGE_SIZE); > + kunmap_atomic(vaddr); > + page++; > + nr_clear_pages--; > + } > + } else { > + memset(page_address(pages), 0, size); > + } > + > + table = kmalloc(sizeof(*table), GFP_KERNEL); > + if (!table) > + goto free_cma; > + > + ret = sg_alloc_table(table, 1, GFP_KERNEL); > + if (ret) > + goto free_table; > + > + sg_set_page(table->sgl, pages, size, 0); > + > + /* create the dmabuf */ > + exp_info.ops = &heap_helper_ops; > + exp_info.size = len; > + exp_info.flags = O_RDWR; > + exp_info.priv = &helper_buffer->heap_buffer; > + dmabuf = dma_buf_export(&exp_info); > + if (IS_ERR(dmabuf)) { > + ret = PTR_ERR(dmabuf); > + goto free_table; > + } > + > + helper_buffer->heap_buffer.dmabuf = dmabuf; > + helper_buffer->priv_virt = pages; > + helper_buffer->sg_table = table; > + > + ret = dma_buf_fd(dmabuf, O_CLOEXEC); > + if (ret < 0) { > + dma_buf_put(dmabuf); > + /* just return, as put will call release and that will free */ > + return ret; > + } > + > + return ret; > +free_table: > + kfree(table); > +free_cma: > + cma_release(cma_heap->cma, pages, nr_pages); > +free_buf: > + kfree(helper_buffer); > + return ret; > +} > + > +static struct dma_heap_ops cma_heap_ops = { > + .allocate = cma_heap_allocate, > +}; > + > +static int __add_cma_heaps(struct cma *cma, void *data) > +{ > + struct cma_heap *cma_heap; > + > + cma_heap = kzalloc(sizeof(*cma_heap), GFP_KERNEL); > + > + if (!cma_heap) > + return -ENOMEM; > + > + cma_heap->heap.name = cma_get_name(cma); > + cma_heap->heap.ops = &cma_heap_ops; > + cma_heap->cma = cma; > + > + dma_heap_add(&cma_heap->heap); > + > + return 0; > +} > + > +static int add_cma_heaps(void) > +{ > + cma_for_each_area(__add_cma_heaps, NULL); > + return 0; > +} > +device_initcall(add_cma_heaps); > -- > 2.7.4 > -- Benjamin Gaignard Graphic Study Group Linaro.org │ Open source software for ARM SoCs Follow Linaro: Facebook | Twitter | Blog _______________________________________________ dri-devel mailing list dri-devel@lists.freedesktop.org https://lists.freedesktop.org/mailman/listinfo/dri-devel