This will add usb_alloc_noncoherent() and usb_free_noncoherent()
functions to support alloc and free buffer in a dma-noncoherent way.
To explicit manage the memory ownership for the kernel and device,
this will also add usb_dma_noncoherent_sync_for_cpu/device() functions
and call it at proper time. The management requires the user save
sg_table returned by usb_alloc_noncoherent() to urb->sgt.
Signed-off-by: Xu Yang <xu.yang_2@nxp.com>
---
Changes in v3:
- put Return section at the end of description
- correct some abbreviations
- remove usb_dma_noncoherent_sync_for_cpu() and
usb_dma_noncoherent_sync_for_device()
- do DMA sync in usb_hcd_map_urb_for_dma() and
usb_hcd_unmap_urb_for_dma()
- call flush_kernel_vmap_range() for OUT transfers
and invalidate_kernel_vmap_range() for IN transfers
---
drivers/usb/core/hcd.c | 19 ++++++++++
drivers/usb/core/usb.c | 80 ++++++++++++++++++++++++++++++++++++++++++
include/linux/usb.h | 11 ++++++
3 files changed, 110 insertions(+)
diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c
index c22de97432a0..e0fa6d6d273b 100644
--- a/drivers/usb/core/hcd.c
+++ b/drivers/usb/core/hcd.c
@@ -1366,6 +1366,14 @@ void usb_hcd_unmap_urb_for_dma(struct usb_hcd *hcd, struct urb *urb)
urb->transfer_buffer_length,
dir);
+ if ((urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP) &&
+ urb->sgt) {
+ dma_sync_sgtable_for_cpu(hcd->self.sysdev, urb->sgt, dir);
+ if (dir == DMA_FROM_DEVICE)
+ invalidate_kernel_vmap_range(urb->transfer_buffer,
+ urb->transfer_buffer_length);
+ }
+
/* Make it safe to call this routine more than once */
urb->transfer_flags &= ~(URB_DMA_MAP_SG | URB_DMA_MAP_PAGE |
URB_DMA_MAP_SINGLE | URB_MAP_LOCAL);
@@ -1491,7 +1499,18 @@ int usb_hcd_map_urb_for_dma(struct usb_hcd *hcd, struct urb *urb,
if (ret && (urb->transfer_flags & (URB_SETUP_MAP_SINGLE |
URB_SETUP_MAP_LOCAL)))
usb_hcd_unmap_urb_for_dma(hcd, urb);
+
+ return ret;
}
+
+ if ((urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP) &&
+ urb->sgt) {
+ if (dir == DMA_TO_DEVICE)
+ flush_kernel_vmap_range(urb->transfer_buffer,
+ urb->transfer_buffer_length);
+ dma_sync_sgtable_for_device(hcd->self.sysdev, urb->sgt, dir);
+ }
+
return ret;
}
EXPORT_SYMBOL_GPL(usb_hcd_map_urb_for_dma);
diff --git a/drivers/usb/core/usb.c b/drivers/usb/core/usb.c
index 118fa4c93a79..fca7735fc660 100644
--- a/drivers/usb/core/usb.c
+++ b/drivers/usb/core/usb.c
@@ -1030,6 +1030,86 @@ void usb_free_coherent(struct usb_device *dev, size_t size, void *addr,
}
EXPORT_SYMBOL_GPL(usb_free_coherent);
+/**
+ * usb_alloc_noncoherent - allocate dma-noncoherent buffer for URB_NO_xxx_DMA_MAP
+ * @dev: device the buffer will be used with
+ * @size: requested buffer size
+ * @mem_flags: affect whether allocation may block
+ * @dma: used to return DMA address of buffer
+ * @dir: DMA transfer direction
+ * @table: used to return sg_table of allocated memory
+ *
+ * To explicit manage the memory ownership for the kernel vs the device by
+ * USB core, the user needs save sg_table to urb->sgt. Then USB core will
+ * do DMA sync for CPU and device properly.
+ *
+ * When the buffer is no longer used, free it with usb_free_noncoherent().
+ *
+ * Return: Either null (indicating no buffer could be allocated), or the
+ * cpu-space pointer to a buffer that may be used to perform DMA to the
+ * specified device. Such cpu-space buffers are returned along with the DMA
+ * address (through the pointer provided).
+ */
+void *usb_alloc_noncoherent(struct usb_device *dev, size_t size,
+ gfp_t mem_flags, dma_addr_t *dma,
+ enum dma_data_direction dir,
+ struct sg_table **table)
+{
+ struct device *dmadev;
+ struct sg_table *sgt;
+ void *buffer;
+
+ if (!dev || !dev->bus)
+ return NULL;
+
+ dmadev = bus_to_hcd(dev->bus)->self.sysdev;
+
+ sgt = dma_alloc_noncontiguous(dmadev, size, dir, mem_flags, 0);
+ if (!sgt)
+ return NULL;
+
+ buffer = dma_vmap_noncontiguous(dmadev, size, sgt);
+ if (!buffer) {
+ dma_free_noncontiguous(dmadev, size, sgt, dir);
+ return NULL;
+ }
+
+ *table = sgt;
+ *dma = sg_dma_address(sgt->sgl);
+
+ return buffer;
+}
+EXPORT_SYMBOL_GPL(usb_alloc_noncoherent);
+
+/**
+ * usb_free_noncoherent - free memory allocated with usb_alloc_noncoherent()
+ * @dev: device the buffer was used with
+ * @size: requested buffer size
+ * @addr: CPU address of buffer
+ * @dir: DMA transfer direction
+ * @table: describe the allocated and DMA mapped memory,
+ *
+ * This reclaims an I/O buffer, letting it be reused. The memory must have
+ * been allocated using usb_alloc_noncoherent(), and the parameters must match
+ * those provided in that allocation request.
+ */
+void usb_free_noncoherent(struct usb_device *dev, size_t size,
+ void *addr, enum dma_data_direction dir,
+ struct sg_table *table)
+{
+ struct device *dmadev;
+
+ if (!dev || !dev->bus)
+ return;
+ if (!addr)
+ return;
+
+ dmadev = bus_to_hcd(dev->bus)->self.sysdev;
+ dma_vunmap_noncontiguous(dmadev, addr);
+ dma_free_noncontiguous(dmadev, size, table, dir);
+}
+EXPORT_SYMBOL_GPL(usb_free_noncoherent);
+
/*
* Notifications of device and interface registration
*/
diff --git a/include/linux/usb.h b/include/linux/usb.h
index e8662843e68c..9ade441ab4c8 100644
--- a/include/linux/usb.h
+++ b/include/linux/usb.h
@@ -1619,6 +1619,7 @@ struct urb {
void *transfer_buffer; /* (in) associated data buffer */
dma_addr_t transfer_dma; /* (in) dma addr for transfer_buffer */
struct scatterlist *sg; /* (in) scatter gather buffer list */
+ struct sg_table *sgt; /* (in) scatter gather table for noncoherent buffer */
int num_mapped_sgs; /* (internal) mapped sg entries */
int num_sgs; /* (in) number of entries in the sg list */
u32 transfer_buffer_length; /* (in) data buffer length */
@@ -1824,6 +1825,16 @@ void *usb_alloc_coherent(struct usb_device *dev, size_t size,
void usb_free_coherent(struct usb_device *dev, size_t size,
void *addr, dma_addr_t dma);
+enum dma_data_direction;
+
+void *usb_alloc_noncoherent(struct usb_device *dev, size_t size,
+ gfp_t mem_flags, dma_addr_t *dma,
+ enum dma_data_direction dir,
+ struct sg_table **table);
+void usb_free_noncoherent(struct usb_device *dev, size_t size,
+ void *addr, enum dma_data_direction dir,
+ struct sg_table *table);
+
/*-------------------------------------------------------------------*
* SYNCHRONOUS CALL SUPPORT *
*-------------------------------------------------------------------*/
--
2.34.1On Wed, Jul 02, 2025 at 07:02:20PM +0800, Xu Yang wrote:
> This will add usb_alloc_noncoherent() and usb_free_noncoherent()
> functions to support alloc and free buffer in a dma-noncoherent way.
>
> To explicit manage the memory ownership for the kernel and device,
> this will also add usb_dma_noncoherent_sync_for_cpu/device() functions
> and call it at proper time. The management requires the user save
> sg_table returned by usb_alloc_noncoherent() to urb->sgt.
>
> Signed-off-by: Xu Yang <xu.yang_2@nxp.com>
>
> ---
> Changes in v3:
> - put Return section at the end of description
> - correct some abbreviations
> - remove usb_dma_noncoherent_sync_for_cpu() and
> usb_dma_noncoherent_sync_for_device()
> - do DMA sync in usb_hcd_map_urb_for_dma() and
> usb_hcd_unmap_urb_for_dma()
> - call flush_kernel_vmap_range() for OUT transfers
> and invalidate_kernel_vmap_range() for IN transfers
> ---
> drivers/usb/core/hcd.c | 19 ++++++++++
> drivers/usb/core/usb.c | 80 ++++++++++++++++++++++++++++++++++++++++++
> include/linux/usb.h | 11 ++++++
> 3 files changed, 110 insertions(+)
>
> diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c
> index c22de97432a0..e0fa6d6d273b 100644
> --- a/drivers/usb/core/hcd.c
> +++ b/drivers/usb/core/hcd.c
> @@ -1366,6 +1366,14 @@ void usb_hcd_unmap_urb_for_dma(struct usb_hcd *hcd, struct urb *urb)
> urb->transfer_buffer_length,
> dir);
>
> + if ((urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP) &&
> + urb->sgt) {
Shouldn't this be "else if"? There aren't any circumstances where a
driver might want to do two DMA mappings for the same buffer, are there?
> + dma_sync_sgtable_for_cpu(hcd->self.sysdev, urb->sgt, dir);
> + if (dir == DMA_FROM_DEVICE)
> + invalidate_kernel_vmap_range(urb->transfer_buffer,
> + urb->transfer_buffer_length);
> + }
> +
Alan Stern
On Wed, Jul 02, 2025 at 10:32:01AM -0400, Alan Stern wrote:
> On Wed, Jul 02, 2025 at 07:02:20PM +0800, Xu Yang wrote:
> > This will add usb_alloc_noncoherent() and usb_free_noncoherent()
> > functions to support alloc and free buffer in a dma-noncoherent way.
> >
> > To explicit manage the memory ownership for the kernel and device,
> > this will also add usb_dma_noncoherent_sync_for_cpu/device() functions
> > and call it at proper time. The management requires the user save
> > sg_table returned by usb_alloc_noncoherent() to urb->sgt.
> >
> > Signed-off-by: Xu Yang <xu.yang_2@nxp.com>
> >
> > ---
> > Changes in v3:
> > - put Return section at the end of description
> > - correct some abbreviations
> > - remove usb_dma_noncoherent_sync_for_cpu() and
> > usb_dma_noncoherent_sync_for_device()
> > - do DMA sync in usb_hcd_map_urb_for_dma() and
> > usb_hcd_unmap_urb_for_dma()
> > - call flush_kernel_vmap_range() for OUT transfers
> > and invalidate_kernel_vmap_range() for IN transfers
> > ---
> > drivers/usb/core/hcd.c | 19 ++++++++++
> > drivers/usb/core/usb.c | 80 ++++++++++++++++++++++++++++++++++++++++++
> > include/linux/usb.h | 11 ++++++
> > 3 files changed, 110 insertions(+)
> >
> > diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c
> > index c22de97432a0..e0fa6d6d273b 100644
> > --- a/drivers/usb/core/hcd.c
> > +++ b/drivers/usb/core/hcd.c
> > @@ -1366,6 +1366,14 @@ void usb_hcd_unmap_urb_for_dma(struct usb_hcd *hcd, struct urb *urb)
> > urb->transfer_buffer_length,
> > dir);
> >
> > + if ((urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP) &&
> > + urb->sgt) {
>
> Shouldn't this be "else if"? There aren't any circumstances where a
> driver might want to do two DMA mappings for the same buffer, are there?
Yes, right. I'll put these line to "else if".
Thanks,
Xu Yang
>
> > + dma_sync_sgtable_for_cpu(hcd->self.sysdev, urb->sgt, dir);
> > + if (dir == DMA_FROM_DEVICE)
> > + invalidate_kernel_vmap_range(urb->transfer_buffer,
> > + urb->transfer_buffer_length);
> > + }
> > +
>
> Alan Stern
On Wed, Jul 02, 2025 at 07:02:20PM +0800, Xu Yang wrote:
> This will add usb_alloc_noncoherent() and usb_free_noncoherent()
> functions to support alloc and free buffer in a dma-noncoherent way.
>
> To explicit manage the memory ownership for the kernel and device,
> this will also add usb_dma_noncoherent_sync_for_cpu/device() functions
> and call it at proper time. The management requires the user save
> sg_table returned by usb_alloc_noncoherent() to urb->sgt.
...
> + if ((urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP) &&
> + urb->sgt) {
Something weird with the indentation. Here you wrapped, but the very next line
is not, and they both satisfy 80 limit (even though we have it relaxed now).
> + dma_sync_sgtable_for_cpu(hcd->self.sysdev, urb->sgt, dir);
> + if (dir == DMA_FROM_DEVICE)
> + invalidate_kernel_vmap_range(urb->transfer_buffer,
> + urb->transfer_buffer_length);
> + }
...
> +
> + return ret;
> }
> +
> + if ((urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP) &&
> + urb->sgt) {
Why not
} else if {
and drop the above return ret; ?
> + if (dir == DMA_TO_DEVICE)
> + flush_kernel_vmap_range(urb->transfer_buffer,
> + urb->transfer_buffer_length);
> + dma_sync_sgtable_for_device(hcd->self.sysdev, urb->sgt, dir);
> + }
> +
> return ret;
--
With Best Regards,
Andy Shevchenko
On Wed, Jul 02, 2025 at 03:20:33PM +0300, Andy Shevchenko wrote:
> On Wed, Jul 02, 2025 at 07:02:20PM +0800, Xu Yang wrote:
> > This will add usb_alloc_noncoherent() and usb_free_noncoherent()
> > functions to support alloc and free buffer in a dma-noncoherent way.
> >
> > To explicit manage the memory ownership for the kernel and device,
> > this will also add usb_dma_noncoherent_sync_for_cpu/device() functions
> > and call it at proper time. The management requires the user save
> > sg_table returned by usb_alloc_noncoherent() to urb->sgt.
>
> ...
>
> > + if ((urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP) &&
> > + urb->sgt) {
>
> Something weird with the indentation. Here you wrapped, but the very next line
> is not, and they both satisfy 80 limit (even though we have it relaxed now).
Indeed. Okay, I'll not wrap this line.
>
> > + dma_sync_sgtable_for_cpu(hcd->self.sysdev, urb->sgt, dir);
> > + if (dir == DMA_FROM_DEVICE)
> > + invalidate_kernel_vmap_range(urb->transfer_buffer,
> > + urb->transfer_buffer_length);
> > + }
>
> ...
>
> > +
> > + return ret;
> > }
> > +
> > + if ((urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP) &&
> > + urb->sgt) {
>
> Why not
>
> } else if {
>
> and drop the above return ret; ?
Okay.
Thanks,
Xu Yang
>
> > + if (dir == DMA_TO_DEVICE)
> > + flush_kernel_vmap_range(urb->transfer_buffer,
> > + urb->transfer_buffer_length);
> > + dma_sync_sgtable_for_device(hcd->self.sysdev, urb->sgt, dir);
> > + }
> > +
> > return ret;
>
> --
> With Best Regards,
> Andy Shevchenko
>
>
© 2016 - 2026 Red Hat, Inc.