Commit 073900a2 authored by Daniel Mack's avatar Daniel Mack Committed by Greg Kroah-Hartman
Browse files

USB: rename usb_buffer_alloc() and usb_buffer_free() 



For more clearance what the functions actually do,

  usb_buffer_alloc() is renamed to usb_alloc_coherent()
  usb_buffer_free()  is renamed to usb_free_coherent()

They should only be used in code which really needs DMA coherency.

[added compatibility macros so we can convert things easier - gregkh]

Signed-off-by: default avatarDaniel Mack <daniel@caiaq.de>
Cc: Alan Stern <stern@rowland.harvard.edu>
Cc: Pedro Ribeiro <pedrib@gmail.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@suse.de>
parent 75181f38

drivers/usb/core/usb.c

+10 −10
Original line number Diff line number Diff line
@@ -718,7 +718,7 @@ int __usb_get_extra_descriptor(char *buffer, unsigned size, 
EXPORT_SYMBOL_GPL(__usb_get_extra_descriptor);



/**

 * usb_buffer_alloc - allocate dma-consistent buffer for URB_NO_xxx_DMA_MAP

 * usb_alloc_coherent - allocate dma-consistent 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
@@ -737,29 +737,29 @@ EXPORT_SYMBOL_GPL(__usb_get_extra_descriptor); 
 * architectures where CPU caches are not DMA-coherent.  On systems without

 * bus-snooping caches, these buffers are uncached.

 *

 * When the buffer is no longer used, free it with usb_buffer_free().

 * When the buffer is no longer used, free it with usb_free_coherent().

 */

void *usb_buffer_alloc(struct usb_device *dev, size_t size, gfp_t mem_flags,

void *usb_alloc_coherent(struct usb_device *dev, size_t size, gfp_t mem_flags,

			 dma_addr_t *dma)

{

	if (!dev || !dev->bus)

		return NULL;

	return hcd_buffer_alloc(dev->bus, size, mem_flags, dma);

}

EXPORT_SYMBOL_GPL(usb_buffer_alloc);

EXPORT_SYMBOL_GPL(usb_alloc_coherent);



/**

 * usb_buffer_free - free memory allocated with usb_buffer_alloc()

 * usb_free_coherent - free memory allocated with usb_alloc_coherent()

 * @dev: device the buffer was used with

 * @size: requested buffer size

 * @addr: CPU address of buffer

 * @dma: DMA address of buffer

 *

 * This reclaims an I/O buffer, letting it be reused.  The memory must have

 * been allocated using usb_buffer_alloc(), and the parameters must match

 * been allocated using usb_alloc_coherent(), and the parameters must match

 * those provided in that allocation request.

 */

void usb_buffer_free(struct usb_device *dev, size_t size, void *addr,

void usb_free_coherent(struct usb_device *dev, size_t size, void *addr,

		       dma_addr_t dma)

{

	if (!dev || !dev->bus)
@@ -768,7 +768,7 @@ void usb_buffer_free(struct usb_device *dev, size_t size, void *addr, 
		return;

	hcd_buffer_free(dev->bus, size, addr, dma);

}

EXPORT_SYMBOL_GPL(usb_buffer_free);

EXPORT_SYMBOL_GPL(usb_free_coherent);



/**

 * usb_buffer_map - create DMA mapping(s) for an urb

include/linux/usb.h

+15 −3
Original line number Diff line number Diff line
@@ -1085,7 +1085,7 @@ typedef void (*usb_complete_t)(struct urb *); 
 * Alternatively, drivers may pass the URB_NO_xxx_DMA_MAP transfer flags,

 * which tell the host controller driver that no such mapping is needed since

 * the device driver is DMA-aware.  For example, a device driver might

 * allocate a DMA buffer with usb_buffer_alloc() or call usb_buffer_map().

 * allocate a DMA buffer with usb_alloc_coherent() or call usb_buffer_map().

 * When these transfer flags are provided, host controller drivers will

 * attempt to use the dma addresses found in the transfer_dma and/or

 * setup_dma fields rather than determining a dma address themselves.
@@ -1366,11 +1366,23 @@ static inline int usb_urb_dir_out(struct urb *urb) 
	return (urb->transfer_flags & URB_DIR_MASK) == URB_DIR_OUT;

}



void *usb_buffer_alloc(struct usb_device *dev, size_t size,

void *usb_alloc_coherent(struct usb_device *dev, size_t size,

	gfp_t mem_flags, dma_addr_t *dma);

void usb_buffer_free(struct usb_device *dev, size_t size,

void usb_free_coherent(struct usb_device *dev, size_t size,

	void *addr, dma_addr_t dma);



/* Compatible macros while we switch over */

static inline void *usb_buffer_alloc(struct usb_device *dev, size_t size,

				     gfp_t mem_flags, dma_addr_t *dma)

{

	return usb_alloc_coherent(dev, size, mem_flags, dma);

}

static inline void usb_buffer_free(struct usb_device *dev, size_t size,

				   void *addr, dma_addr_t dma)

{

	return usb_free_coherent(dev, size, addr, dma);

}



#if 0

struct urb *usb_buffer_map(struct urb *urb);

void usb_buffer_dmasync(struct urb *urb);

CRA Git | Maintained and supported by SUSTech CRA and CCSE