This heap is basically a wrapper around DMA-API dma_alloc_attrs,
which will allocate memory suitable for the given device.
The implementation is mostly a port of the Contiguous Videobuf2
memory allocator (see videobuf2/videobuf2-dma-contig.c)
over to the DMA-BUF Heap interface.
The intention of this allocator is to provide applications
with a more system-agnostic API: the only thing the application
needs to know is which device to get the buffer for.
Whether the buffer is backed by CMA, IOMMU or a DMA Pool
is unknown to the application.
I'm not really expecting this patch to be correct or even
a good idea, but just submitting it to start a discussion on DMA-BUF
heap discovery and negotiation.
Given Plumbers is just a couple weeks from now, I've submitted
a BoF proposal to discuss this, as perhaps it would make
sense to discuss this live?
Not-signed-off-by: Ezequiel Garcia <ezequiel@xxxxxxxxxxxxx>
---
drivers/dma-buf/heaps/Kconfig | 9 +
drivers/dma-buf/heaps/Makefile | 1 +
drivers/dma-buf/heaps/device_heap.c | 268 ++++++++++++++++++++++++++++
include/linux/device.h | 5 +
include/linux/dma-heap.h | 6 +
5 files changed, 289 insertions(+)
create mode 100644 drivers/dma-buf/heaps/device_heap.c
diff --git a/drivers/dma-buf/heaps/Kconfig b/drivers/dma-buf/heaps/Kconfig
index a5eef06c4226..2bb3604184bd 100644
--- a/drivers/dma-buf/heaps/Kconfig
+++ b/drivers/dma-buf/heaps/Kconfig
@@ -12,3 +12,12 @@ config DMABUF_HEAPS_CMA
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.
+
+config DMABUF_HEAPS_DEVICES
+ bool "DMA-BUF Device DMA Heap (Experimental)"
+ depends on DMABUF_HEAPS
+ help
+ Choose this option to enable dma-buf per-device heap. This heap is backed
+ by the DMA-API and it's an Experimental feature, meant mostly for testing
+ and experimentation.
+ Just say N here.
diff --git a/drivers/dma-buf/heaps/Makefile b/drivers/dma-buf/heaps/Makefile
index 6e54cdec3da0..c691d85b3044 100644
--- a/drivers/dma-buf/heaps/Makefile
+++ b/drivers/dma-buf/heaps/Makefile
@@ -2,3 +2,4 @@
obj-y += heap-helpers.o
obj-$(CONFIG_DMABUF_HEAPS_SYSTEM) += system_heap.o
obj-$(CONFIG_DMABUF_HEAPS_CMA) += cma_heap.o
+obj-$(CONFIG_DMABUF_HEAPS_DEVICES) += device_heap.o
diff --git a/drivers/dma-buf/heaps/device_heap.c b/drivers/dma-buf/heaps/device_heap.c
new file mode 100644
index 000000000000..1803dc622dd8
--- /dev/null
+++ b/drivers/dma-buf/heaps/device_heap.c
@@ -0,0 +1,268 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * DMABUF Device DMA heap exporter
+ *
+ * Copyright (C) 2020, Collabora Ltd.
+ *
+ * Based on:
+ * videobuf2-dma-contig.c - DMA contig memory allocator for videobuf2
+ * Copyright (C) 2010 Samsung Electronics
+ */
+
+#include <linux/device.h>
+#include <linux/dma-buf.h>
+#include <linux/dma-heap.h>
+#include <linux/dma-mapping.h>
+#include <linux/scatterlist.h>
+#include <linux/slab.h>
+#include <linux/module.h>
+
+struct dev_dmabuf_attachment {
+ struct sg_table sgt;
+ enum dma_data_direction dma_dir;
+};
+
+struct dev_dmabuf {
+ struct dma_heap *heap;
+ struct dma_buf *dmabuf;
+ struct device *dev;
+ size_t size;
+ void *vaddr;
+ dma_addr_t dma_addr;
+ unsigned long attrs;
+
+ struct sg_table sgt;
+};
+
+static struct sg_table *dev_dmabuf_ops_map(struct dma_buf_attachment *db_attach,
+ enum dma_data_direction dma_dir)
+{
+ struct dev_dmabuf_attachment *attach = db_attach->priv;
+ /* stealing dmabuf mutex to serialize map/unmap operations */
+ struct mutex *lock = &db_attach->dmabuf->lock;
+ struct sg_table *sgt;
+
+ mutex_lock(lock);
+
+ sgt = &attach->sgt;
+ /* return previously mapped sg table */
+ if (attach->dma_dir == dma_dir) {
+ mutex_unlock(lock);
+ return sgt;
+ }
+
+ /* release any previous cache */
+ if (attach->dma_dir != DMA_NONE) {
+ dma_unmap_sg_attrs(db_attach->dev, sgt->sgl, sgt->orig_nents,
+ attach->dma_dir, DMA_ATTR_SKIP_CPU_SYNC);
+ attach->dma_dir = DMA_NONE;
+ }
+
+ /*
+ * mapping to the client with new direction, no cache sync
+ * required see comment in .dmabuf_ops_detach()
+ */
+ sgt->nents = dma_map_sg_attrs(db_attach->dev, sgt->sgl, sgt->orig_nents,
+ dma_dir, DMA_ATTR_SKIP_CPU_SYNC);
+ if (!sgt->nents) {
+ dev_err(db_attach->dev, "failed to map scatterlist\n");
+ mutex_unlock(lock);
+ return ERR_PTR(-EIO);
+ }
+
+ attach->dma_dir = dma_dir;
+
+ mutex_unlock(lock);
+
+ return sgt;
+}
+
+static void dev_dmabuf_ops_unmap(struct dma_buf_attachment *db_attach,
+ struct sg_table *sgt,
+ enum dma_data_direction dma_dir)
+{
+ /* nothing to be done here */
+}
+
+static int dev_dmabuf_ops_attach(struct dma_buf *dmabuf,
+ struct dma_buf_attachment *dbuf_attach)
+{
+ struct dev_dmabuf_attachment *attach;
+ unsigned int i;
+ struct scatterlist *rd, *wr;
+ struct sg_table *sgt;
+ struct dev_dmabuf *buf = dmabuf->priv;
+ int ret;
+
+ attach = kzalloc(sizeof(*attach), GFP_KERNEL);
+ if (!attach)
+ return -ENOMEM;
+ sgt = &attach->sgt;
+
+ /*
+ * Copy the buf->sgt scatter list to the attachment, as we can't
+ * map the same scatter list to multiple attachments at the same time.
+ */
+ ret = sg_alloc_table(sgt, buf->sgt.orig_nents, GFP_KERNEL);
+ if (ret) {
+ kfree(attach);
+ return -ENOMEM;
+ }
+
+ rd = buf->sgt.sgl;
+ wr = sgt->sgl;
+ for (i = 0; i < sgt->orig_nents; ++i) {
+ sg_set_page(wr, sg_page(rd), rd->length, rd->offset);
+ rd = sg_next(rd);
+ wr = sg_next(wr);
+ }
+
+ attach->dma_dir = DMA_NONE;
+ dbuf_attach->priv = attach;
+
+ return 0;
+}
+
+static void dev_dmabuf_ops_detach(struct dma_buf *dmabuf,
+ struct dma_buf_attachment *db_attach)
+{
+ struct dev_dmabuf_attachment *attach = db_attach->priv;
+ struct sg_table *sgt;
+
+ if (!attach)
+ return;
+ sgt = &attach->sgt;
+
+ /* release the scatterlist cache */
+ if (attach->dma_dir != DMA_NONE)
+ /*
+ * Cache sync can be skipped here, as the memory is
+ * allocated from device coherent memory, which means the
+ * memory locations do not require any explicit cache
+ * maintenance prior or after being used by the device.
+ *
+ * XXX: This needs a revisit.
+ */
+ dma_unmap_sg_attrs(db_attach->dev, sgt->sgl, sgt->orig_nents,
+ attach->dma_dir, DMA_ATTR_SKIP_CPU_SYNC);
+ sg_free_table(sgt);
+ kfree(attach);
+ db_attach->priv = NULL;
+}
+
+
+static void *dev_dmabuf_ops_vmap(struct dma_buf *dmabuf)
+{
+ struct dev_dmabuf *buf = dmabuf->priv;
+
+ return buf->vaddr;
+}
+
+static void dev_dmabuf_ops_release(struct dma_buf *dmabuf)
+{
+ struct dev_dmabuf *buf = dmabuf->priv;
+
+ sg_free_table(&buf->sgt);
+ dma_free_attrs(buf->dev, buf->size, buf->vaddr,
+ buf->dma_addr, buf->attrs);
+ put_device(buf->dev);
+ kfree(buf);
+}
+
+static int dev_dmabuf_ops_mmap(struct dma_buf *dmabuf,
+ struct vm_area_struct *vma)
+{
+ struct dev_dmabuf *buf = dmabuf->priv;
+ int ret;
+
+ ret = dma_mmap_attrs(buf->dev, vma, buf->vaddr,
+ buf->dma_addr, buf->size,
+ buf->attrs);
+ if (ret) {
+ dev_err(buf->dev, "remapping memory failed, error: %d\n", ret);
+ return ret;
+ }
+ vma->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP;
+
+ return 0;
+}
+
+static const struct dma_buf_ops dev_dmabuf_ops = {
+ .attach = dev_dmabuf_ops_attach,
+ .detach = dev_dmabuf_ops_detach,
+ .map_dma_buf = dev_dmabuf_ops_map,
+ .unmap_dma_buf = dev_dmabuf_ops_unmap,
+ .vmap = dev_dmabuf_ops_vmap,
+ .mmap = dev_dmabuf_ops_mmap,
+ .release = dev_dmabuf_ops_release,
+};
+
+static int dev_heap_allocate(struct dma_heap *heap,
+ unsigned long size,
+ unsigned long fd_flags,
+ unsigned long heap_flags)
+{
+ struct device *dev = dma_heap_get_drvdata(heap);
+ struct dev_dmabuf *buf;
+ struct dma_buf_export_info exp_info = {};
+ unsigned long attrs = 0;
+ int ret = -ENOMEM;
+
+ buf = kzalloc(sizeof(*buf), GFP_KERNEL);
+ if (!buf)
+ return -ENOMEM;
+
+ buf->vaddr = dma_alloc_attrs(dev, size, &buf->dma_addr,
+ GFP_KERNEL, attrs);
+ /* Prevent the device from being released while the buffer is used */
+ buf->dev = get_device(dev);
+ buf->heap = heap;
+ buf->size = size;
+ buf->attrs = attrs;
+
+ /* XXX: This call is documented as unsafe. See dma_get_sgtable_attrs(). */
+ ret = dma_get_sgtable_attrs(buf->dev, &buf->sgt,
+ buf->vaddr, buf->dma_addr,
+ buf->size, buf->attrs);
+ if (ret < 0) {
+ dev_err(buf->dev, "failed to get scatterlist from DMA API\n");
+ return ret;
+ }
+
+ exp_info.exp_name = dev_name(dev);
+ exp_info.owner = THIS_MODULE;
+ exp_info.ops = &dev_dmabuf_ops;
+ exp_info.size = size;
+ exp_info.flags = fd_flags;
+ exp_info.priv = buf;
+
+ buf->dmabuf = dma_buf_export(&exp_info);
+ if (IS_ERR(buf->dmabuf)) {
+ dev_err(buf->dev, "failed to export dmabuf\n");
+ return PTR_ERR(buf->dmabuf);
+ }
+
+ ret = dma_buf_fd(buf->dmabuf, fd_flags);
+ if (ret < 0) {
+ dev_err(buf->dev, "failed to get dmabuf fd: %d\n", ret);
+ return ret;
+ }
+
+ return ret;
+}
+
+static const struct dma_heap_ops dev_heap_ops = {
+ .allocate = dev_heap_allocate,
+};
+
+void dev_dma_heap_add(struct device *dev)
+{
+ struct dma_heap_export_info exp_info;
+
+ exp_info.name = dev_name(dev);
+ exp_info.ops = &dev_heap_ops;
+ exp_info.priv = dev;
+
+ dev->heap = dma_heap_add(&exp_info);
+}
+EXPORT_SYMBOL(dev_dma_heap_add);
diff --git a/include/linux/device.h b/include/linux/device.h
index ca18da4768e3..1fae95d55ea1 100644
--- a/include/linux/device.h
+++ b/include/linux/device.h
@@ -45,6 +45,7 @@ struct iommu_ops;
struct iommu_group;
struct dev_pin_info;
struct dev_iommu;
+struct dma_heap;
/**
* struct subsys_interface - interfaces to device functions
@@ -597,6 +598,10 @@ struct device {
struct iommu_group *iommu_group;
struct dev_iommu *iommu;
+#ifdef CONFIG_DMABUF_HEAPS_DEVICES
+ struct dma_heap *heap;
+#endif
+
bool offline_disabled:1;
bool offline:1;
bool of_node_reused:1;
diff --git a/include/linux/dma-heap.h b/include/linux/dma-heap.h
index 454e354d1ffb..dcf7cca2f487 100644
--- a/include/linux/dma-heap.h
+++ b/include/linux/dma-heap.h
@@ -56,4 +56,10 @@ void *dma_heap_get_drvdata(struct dma_heap *heap);
*/
struct dma_heap *dma_heap_add(const struct dma_heap_export_info *exp_info);
+#ifdef CONFIG_DMABUF_HEAPS_DEVICES
+void dev_dma_heap_add(struct device *dev);
+#else
+static inline void dev_dma_heap_add(struct device *dev) {}
+#endif
+
#endif /* _DMA_HEAPS_H */
--
2.27.0
