uio: introduce UIO_MEM_DMA_COHERENT type

Add a UIO memtype specifically for sharing dma_alloc_coherent
memory with userspace, backed by dma_mmap_coherent.

This is mainly for the bnx2/bnx2x/bnx2i "cnic" interface, although there
are a few other uio drivers which map dma_alloc_coherent memory and will
be converted to use dma_mmap_coherent as well.

Signed-off-by: Nilesh Javali <njavali@marvell.com>
Signed-off-by: Chris Leech <cleech@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Link: https://lore.kernel.org/r/20240205200137.138302-1-cleech@redhat.com
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

diff --git a/drivers/uio/uio.c b/drivers/uio/uio.c
index 2d572f6c8ec833023450136e3e2278d46d8937ae..bb77de6fa067efe26280b24b0f62b54ba75bcbca 100644 (file)
--- a/drivers/uio/uio.c
+++ b/drivers/uio/uio.c
@@ -24,6 +24,7 @@
 #include <linux/kobject.h>
 #include <linux/cdev.h>
 #include <linux/uio_driver.h>
+#include <linux/dma-mapping.h>
 
 #define UIO_MAX_DEVICES                (1U << MINORBITS)
 
@@ -759,6 +760,49 @@ static int uio_mmap_physical(struct vm_area_struct *vma)
                               vma->vm_page_prot);
 }
 
+static int uio_mmap_dma_coherent(struct vm_area_struct *vma)
+{
+       struct uio_device *idev = vma->vm_private_data;
+       struct uio_mem *mem;
+       void *addr;
+       int ret = 0;
+       int mi;
+
+       mi = uio_find_mem_index(vma);
+       if (mi < 0)
+               return -EINVAL;
+
+       mem = idev->info->mem + mi;
+
+       if (mem->addr & ~PAGE_MASK)
+               return -ENODEV;
+       if (mem->dma_addr & ~PAGE_MASK)
+               return -ENODEV;
+       if (!mem->dma_device)
+               return -ENODEV;
+       if (vma->vm_end - vma->vm_start > mem->size)
+               return -EINVAL;
+
+       dev_warn(mem->dma_device,
+                "use of UIO_MEM_DMA_COHERENT is highly discouraged");
+
+       /*
+        * UIO uses offset to index into the maps for a device.
+        * We need to clear vm_pgoff for dma_mmap_coherent.
+        */
+       vma->vm_pgoff = 0;
+
+       addr = (void *)mem->addr;
+       ret = dma_mmap_coherent(mem->dma_device,
+                               vma,
+                               addr,
+                               mem->dma_addr,
+                               vma->vm_end - vma->vm_start);
+       vma->vm_pgoff = mi;
+
+       return ret;
+}
+
 static int uio_mmap(struct file *filep, struct vm_area_struct *vma)
 {
        struct uio_listener *listener = filep->private_data;
@@ -806,6 +850,9 @@ static int uio_mmap(struct file *filep, struct vm_area_struct *vma)
        case UIO_MEM_VIRTUAL:
                ret = uio_mmap_logical(vma);
                break;
+       case UIO_MEM_DMA_COHERENT:
+               ret = uio_mmap_dma_coherent(vma);
+               break;
        default:
                ret = -EINVAL;
        }

diff --git a/include/linux/uio_driver.h b/include/linux/uio_driver.h
index 47c5962b876b027e2ea935c4003b37f7a1bfdca3..18238dc8bfd356a20996ba6cd84f1ff508bbb81c 100644 (file)
--- a/include/linux/uio_driver.h
+++ b/include/linux/uio_driver.h
@@ -28,19 +28,26 @@ struct uio_map;
  *                     logical, virtual, or physical & phys_addr_t
  *                     should always be large enough to handle any of
  *                     the address types)
+ * @dma_addr:          DMA handle set by dma_alloc_coherent, used with
+ *                     UIO_MEM_DMA_COHERENT only (@addr should be the
+ *                     void * returned from the same dma_alloc_coherent call)
  * @offs:               offset of device memory within the page
  * @size:              size of IO (multiple of page size)
  * @memtype:           type of memory addr points to
  * @internal_addr:     ioremap-ped version of addr, for driver internal use
+ * @dma_device:                device struct that was passed to dma_alloc_coherent,
+ *                     used with UIO_MEM_DMA_COHERENT only
  * @map:               for use by the UIO core only.
  */
 struct uio_mem {
        const char              *name;
        phys_addr_t             addr;
+       dma_addr_t              dma_addr;
        unsigned long           offs;
        resource_size_t         size;
        int                     memtype;
        void __iomem            *internal_addr;
+       struct device           *dma_device;
        struct uio_map          *map;
 };
 
@@ -158,6 +165,12 @@ extern int __must_check
 #define UIO_MEM_LOGICAL        2
 #define UIO_MEM_VIRTUAL 3
 #define UIO_MEM_IOVA   4
+/*
+ * UIO_MEM_DMA_COHERENT exists for legacy drivers that had been getting by with
+ * improperly mapping DMA coherent allocations through the other modes.
+ * Do not use in new drivers.
+ */
+#define UIO_MEM_DMA_COHERENT   5
 
 /* defines for uio_port->porttype */
 #define UIO_PORT_NONE  0