kfifo: add kfifo_dma_out_prepare_mapped()

When the kfifo buffer is already dma-mapped, one cannot use the kfifo
API to fill in an SG list.

Add kfifo_dma_in_prepare_mapped() which allows exactly this. A mapped
dma_addr_t is passed and it is filled into provided sgl too. Including
the dma_len.

Signed-off-by: Jiri Slaby (SUSE) <jirislaby@kernel.org>
Cc: Stefani Seibold <stefani@seibold.net>
Cc: Andrew Morton <akpm@linux-foundation.org>
Link: https://lore.kernel.org/r/20240405060826.2521-8-jirislaby@kernel.org
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

diff --git a/include/linux/kfifo.h b/include/linux/kfifo.h
index 3def70e1a3e31c1b7b199c5fd57ee1672302feb4..c7cc25b2808b68212ad3335fc10bbcf0b3b6aa1b 100644 (file)
--- a/include/linux/kfifo.h
+++ b/include/linux/kfifo.h
@@ -36,6 +36,7 @@
  * to lock the reader.
  */
 
+#include <linux/dma-mapping.h>
 #include <linux/kernel.h>
 #include <linux/spinlock.h>
 #include <linux/stddef.h>
@@ -709,11 +710,12 @@ __kfifo_int_must_check_helper( \
 )
 
 /**
- * kfifo_dma_in_prepare - setup a scatterlist for DMA input
+ * kfifo_dma_in_prepare_mapped - setup a scatterlist for DMA input
  * @fifo: address of the fifo to be used
  * @sgl: pointer to the scatterlist array
  * @nents: number of entries in the scatterlist array
  * @len: number of elements to transfer
+ * @dma: mapped dma address to fill into @sgl
  *
  * This macro fills a scatterlist for DMA input.
  * It returns the number entries in the scatterlist array.
@@ -721,7 +723,7 @@ __kfifo_int_must_check_helper( \
  * Note that with only one concurrent reader and one concurrent
  * writer, you don't need extra locking to use these macros.
  */
-#define        kfifo_dma_in_prepare(fifo, sgl, nents, len) \
+#define        kfifo_dma_in_prepare_mapped(fifo, sgl, nents, len, dma) \
 ({ \
        typeof((fifo) + 1) __tmp = (fifo); \
        struct scatterlist *__sgl = (sgl); \
@@ -730,10 +732,14 @@ __kfifo_int_must_check_helper( \
        const size_t __recsize = sizeof(*__tmp->rectype); \
        struct __kfifo *__kfifo = &__tmp->kfifo; \
        (__recsize) ? \
-       __kfifo_dma_in_prepare_r(__kfifo, __sgl, __nents, __len, __recsize) : \
-       __kfifo_dma_in_prepare(__kfifo, __sgl, __nents, __len); \
+       __kfifo_dma_in_prepare_r(__kfifo, __sgl, __nents, __len, __recsize, \
+                                dma) : \
+       __kfifo_dma_in_prepare(__kfifo, __sgl, __nents, __len, dma); \
 })
 
+#define kfifo_dma_in_prepare(fifo, sgl, nents, len) \
+       kfifo_dma_in_prepare_mapped(fifo, sgl, nents, len, DMA_MAPPING_ERROR)
+
 /**
  * kfifo_dma_in_finish - finish a DMA IN operation
  * @fifo: address of the fifo to be used
@@ -758,11 +764,12 @@ __kfifo_int_must_check_helper( \
 })
 
 /**
- * kfifo_dma_out_prepare - setup a scatterlist for DMA output
+ * kfifo_dma_out_prepare_mapped - setup a scatterlist for DMA output
  * @fifo: address of the fifo to be used
  * @sgl: pointer to the scatterlist array
  * @nents: number of entries in the scatterlist array
  * @len: number of elements to transfer
+ * @dma: mapped dma address to fill into @sgl
  *
  * This macro fills a scatterlist for DMA output which at most @len bytes
  * to transfer.
@@ -772,7 +779,7 @@ __kfifo_int_must_check_helper( \
  * Note that with only one concurrent reader and one concurrent
  * writer, you don't need extra locking to use these macros.
  */
-#define        kfifo_dma_out_prepare(fifo, sgl, nents, len) \
+#define        kfifo_dma_out_prepare_mapped(fifo, sgl, nents, len, dma) \
 ({ \
        typeof((fifo) + 1) __tmp = (fifo);  \
        struct scatterlist *__sgl = (sgl); \
@@ -781,10 +788,14 @@ __kfifo_int_must_check_helper( \
        const size_t __recsize = sizeof(*__tmp->rectype); \
        struct __kfifo *__kfifo = &__tmp->kfifo; \
        (__recsize) ? \
-       __kfifo_dma_out_prepare_r(__kfifo, __sgl, __nents, __len, __recsize) : \
-       __kfifo_dma_out_prepare(__kfifo, __sgl, __nents, __len); \
+       __kfifo_dma_out_prepare_r(__kfifo, __sgl, __nents, __len, __recsize, \
+                                 dma) : \
+       __kfifo_dma_out_prepare(__kfifo, __sgl, __nents, __len, dma); \
 })
 
+#define        kfifo_dma_out_prepare(fifo, sgl, nents, len) \
+       kfifo_dma_out_prepare_mapped(fifo, sgl, nents, len, DMA_MAPPING_ERROR)
+
 /**
  * kfifo_dma_out_finish - finish a DMA OUT operation
  * @fifo: address of the fifo to be used
@@ -905,10 +916,10 @@ extern int __kfifo_to_user(struct __kfifo *fifo,
        void __user *to, unsigned long len, unsigned int *copied);
 
 extern unsigned int __kfifo_dma_in_prepare(struct __kfifo *fifo,
-       struct scatterlist *sgl, int nents, unsigned int len);
+       struct scatterlist *sgl, int nents, unsigned int len, dma_addr_t dma);
 
 extern unsigned int __kfifo_dma_out_prepare(struct __kfifo *fifo,
-       struct scatterlist *sgl, int nents, unsigned int len);
+       struct scatterlist *sgl, int nents, unsigned int len, dma_addr_t dma);
 
 extern unsigned int __kfifo_out_peek(struct __kfifo *fifo,
        void *buf, unsigned int len);
@@ -930,13 +941,15 @@ extern int __kfifo_to_user_r(struct __kfifo *fifo, void __user *to,
        unsigned long len, unsigned int *copied, size_t recsize);
 
 extern unsigned int __kfifo_dma_in_prepare_r(struct __kfifo *fifo,
-       struct scatterlist *sgl, int nents, unsigned int len, size_t recsize);
+       struct scatterlist *sgl, int nents, unsigned int len, size_t recsize,
+       dma_addr_t dma);
 
 extern void __kfifo_dma_in_finish_r(struct __kfifo *fifo,
        unsigned int len, size_t recsize);
 
 extern unsigned int __kfifo_dma_out_prepare_r(struct __kfifo *fifo,
-       struct scatterlist *sgl, int nents, unsigned int len, size_t recsize);
+       struct scatterlist *sgl, int nents, unsigned int len, size_t recsize,
+       dma_addr_t dma);
 
 extern unsigned int __kfifo_len_r(struct __kfifo *fifo, size_t recsize);
 

diff --git a/lib/kfifo.c b/lib/kfifo.c
index 3a249ce4f2819984546001d7eae523a0ffd3d3e5..75ce9225548aa6a541afdb4751f42d96cc33e3e3 100644 (file)
--- a/lib/kfifo.c
+++ b/lib/kfifo.c
@@ -6,6 +6,7 @@
  */
 
 #include <linux/kernel.h>
+#include <linux/dma-mapping.h>
 #include <linux/export.h>
 #include <linux/slab.h>
 #include <linux/err.h>
@@ -307,7 +308,7 @@ EXPORT_SYMBOL(__kfifo_to_user);
 
 static unsigned int setup_sgl_buf(struct __kfifo *fifo, struct scatterlist *sgl,
                                  unsigned int data_offset, int nents,
-                                 unsigned int len)
+                                 unsigned int len, dma_addr_t dma)
 {
        const void *buf = fifo->data + data_offset;
 
@@ -316,11 +317,16 @@ static unsigned int setup_sgl_buf(struct __kfifo *fifo, struct scatterlist *sgl,
 
        sg_set_buf(sgl, buf, len);
 
+       if (dma != DMA_MAPPING_ERROR) {
+               sg_dma_address(sgl) = dma + data_offset;
+               sg_dma_len(sgl) = len;
+       }
+
        return 1;
 }
 
 static unsigned int setup_sgl(struct __kfifo *fifo, struct scatterlist *sgl,
-               int nents, unsigned int len, unsigned int off)
+               int nents, unsigned int len, unsigned int off, dma_addr_t dma)
 {
        unsigned int size = fifo->mask + 1;
        unsigned int esize = fifo->esize;
@@ -335,14 +341,15 @@ static unsigned int setup_sgl(struct __kfifo *fifo, struct scatterlist *sgl,
        }
        len_to_end = min(len, size - off);
 
-       n = setup_sgl_buf(fifo, sgl, off, nents, len_to_end);
-       n += setup_sgl_buf(fifo, sgl + n, 0, nents - n, len - len_to_end);
+       n = setup_sgl_buf(fifo, sgl, off, nents, len_to_end, dma);
+       n += setup_sgl_buf(fifo, sgl + n, 0, nents - n, len - len_to_end, dma);
 
        return n;
 }
 
 unsigned int __kfifo_dma_in_prepare(struct __kfifo *fifo,
-               struct scatterlist *sgl, int nents, unsigned int len)
+               struct scatterlist *sgl, int nents, unsigned int len,
+               dma_addr_t dma)
 {
        unsigned int l;
 
@@ -350,12 +357,13 @@ unsigned int __kfifo_dma_in_prepare(struct __kfifo *fifo,
        if (len > l)
                len = l;
 
-       return setup_sgl(fifo, sgl, nents, len, fifo->in);
+       return setup_sgl(fifo, sgl, nents, len, fifo->in, dma);
 }
 EXPORT_SYMBOL(__kfifo_dma_in_prepare);
 
 unsigned int __kfifo_dma_out_prepare(struct __kfifo *fifo,
-               struct scatterlist *sgl, int nents, unsigned int len)
+               struct scatterlist *sgl, int nents, unsigned int len,
+               dma_addr_t dma)
 {
        unsigned int l;
 
@@ -363,7 +371,7 @@ unsigned int __kfifo_dma_out_prepare(struct __kfifo *fifo,
        if (len > l)
                len = l;
 
-       return setup_sgl(fifo, sgl, nents, len, fifo->out);
+       return setup_sgl(fifo, sgl, nents, len, fifo->out, dma);
 }
 EXPORT_SYMBOL(__kfifo_dma_out_prepare);
 
@@ -547,7 +555,8 @@ int __kfifo_to_user_r(struct __kfifo *fifo, void __user *to,
 EXPORT_SYMBOL(__kfifo_to_user_r);
 
 unsigned int __kfifo_dma_in_prepare_r(struct __kfifo *fifo,
-       struct scatterlist *sgl, int nents, unsigned int len, size_t recsize)
+       struct scatterlist *sgl, int nents, unsigned int len, size_t recsize,
+       dma_addr_t dma)
 {
        BUG_ON(!nents);
 
@@ -556,7 +565,7 @@ unsigned int __kfifo_dma_in_prepare_r(struct __kfifo *fifo,
        if (len + recsize > kfifo_unused(fifo))
                return 0;
 
-       return setup_sgl(fifo, sgl, nents, len, fifo->in + recsize);
+       return setup_sgl(fifo, sgl, nents, len, fifo->in + recsize, dma);
 }
 EXPORT_SYMBOL(__kfifo_dma_in_prepare_r);
 
@@ -570,7 +579,8 @@ void __kfifo_dma_in_finish_r(struct __kfifo *fifo,
 EXPORT_SYMBOL(__kfifo_dma_in_finish_r);
 
 unsigned int __kfifo_dma_out_prepare_r(struct __kfifo *fifo,
-       struct scatterlist *sgl, int nents, unsigned int len, size_t recsize)
+       struct scatterlist *sgl, int nents, unsigned int len, size_t recsize,
+       dma_addr_t dma)
 {
        BUG_ON(!nents);
 
@@ -579,7 +589,7 @@ unsigned int __kfifo_dma_out_prepare_r(struct __kfifo *fifo,
        if (len + recsize > fifo->in - fifo->out)
                return 0;
 
-       return setup_sgl(fifo, sgl, nents, len, fifo->out + recsize);
+       return setup_sgl(fifo, sgl, nents, len, fifo->out + recsize, dma);
 }
 EXPORT_SYMBOL(__kfifo_dma_out_prepare_r);