drivers/usb/core/buffer.c

   1 /*
   2  * DMA memory management for framework level HCD code (hc_driver)
   3  *
   4  * This implementation plugs in through generic "usb_bus" level methods,
   5  * and should work with all USB controllers, regardles of bus type.
   6  */
   7
   8 #include <linux/config.h>
   9 #include <linux/module.h>
  10 #include <linux/kernel.h>
  11 #include <linux/slab.h>
  12 #include <linux/device.h>
  13 #include <linux/mm.h>
  14 #include <asm/io.h>
  15 #include <asm/scatterlist.h>
  16 #include <linux/dma-mapping.h>
  17 #include <linux/dmapool.h>
  18 #include <linux/usb.h>
  19 #include "hcd.h"
  20
  21
  22 /*
  23  * DMA-Coherent Buffers
  24  */
  25
  26 /* FIXME tune these based on pool statistics ... */
  27 static const size_t     pool_max [HCD_BUFFER_POOLS] = {
  28         /* platforms without dma-friendly caches might need to
  29          * prevent cacheline sharing...
  30          */
  31         32,
  32         128,
  33         512,
  34         PAGE_SIZE / 2
  35         /* bigger --> allocate pages */
  36 };
  37
  38
  39 /* SETUP primitives */
  40
  41 /**
  42  * hcd_buffer_create - initialize buffer pools
  43  * @hcd: the bus whose buffer pools are to be initialized
  44  * Context: !in_interrupt()
  45  *
  46  * Call this as part of initializing a host controller that uses the dma
  47  * memory allocators.  It initializes some pools of dma-coherent memory that
  48  * will be shared by all drivers using that controller, or returns a negative
  49  * errno value on error.
  50  *
  51  * Call hcd_buffer_destroy() to clean up after using those pools.
  52  */
  53 int hcd_buffer_create (struct usb_hcd *hcd)
  54 {
  55         char            name [16];
  56         int             i, size;
  57
  58         for (i = 0; i < HCD_BUFFER_POOLS; i++) {
  59                 if (!(size = pool_max [i]))
  60                         continue;
  61                 snprintf (name, sizeof name, "buffer-%d", size);
  62                 hcd->pool [i] = dma_pool_create (name, hcd->self.controller,
  63                                 size, size, 0);
  64                 if (!hcd->pool [i]) {
  65                         hcd_buffer_destroy (hcd);
  66                         return -ENOMEM;
  67                 }
  68         }
  69         return 0;
  70 }
  71
  72
  73 /**
  74  * hcd_buffer_destroy - deallocate buffer pools
  75  * @hcd: the bus whose buffer pools are to be destroyed
  76  * Context: !in_interrupt()
  77  *
  78  * This frees the buffer pools created by hcd_buffer_create().
  79  */
  80 void hcd_buffer_destroy (struct usb_hcd *hcd)
  81 {
  82         int             i;
  83
  84         for (i = 0; i < HCD_BUFFER_POOLS; i++) {
  85                 struct dma_pool         *pool = hcd->pool [i];
  86                 if (pool) {
  87                         dma_pool_destroy (pool);
  88                         hcd->pool[i] = NULL;
  89                 }
  90         }
  91 }
  92
  93
  94 /* sometimes alloc/free could use kmalloc with SLAB_DMA, for
  95  * better sharing and to leverage mm/slab.c intelligence.
  96  */
  97
  98 void *hcd_buffer_alloc (
  99         struct usb_bus          *bus,
 100         size_t                  size,
 101         gfp_t                   mem_flags,
 102         dma_addr_t              *dma
 103 )
 104 {
 105         struct usb_hcd          *hcd = bus->hcpriv;
 106         int                     i;
 107
 108         /* some USB hosts just use PIO */
 109         if (!bus->controller->dma_mask) {
 110                 *dma = ~(dma_addr_t) 0;
 111                 return kmalloc (size, mem_flags);
 112         }
 113
 114         for (i = 0; i < HCD_BUFFER_POOLS; i++) {
 115                 if (size <= pool_max [i])
 116                         return dma_pool_alloc (hcd->pool [i], mem_flags, dma);
 117         }
 118         return dma_alloc_coherent (hcd->self.controller, size, dma, 0);
 119 }
 120
 121 void hcd_buffer_free (
 122         struct usb_bus          *bus,
 123         size_t                  size,
 124         void                    *addr,
 125         dma_addr_t              dma
 126 )
 127 {
 128         struct usb_hcd          *hcd = bus->hcpriv;
 129         int                     i;
 130
 131         if (!addr)
 132                 return;
 133
 134         if (!bus->controller->dma_mask) {
 135                 kfree (addr);
 136                 return;
 137         }
 138
 139         for (i = 0; i < HCD_BUFFER_POOLS; i++) {
 140                 if (size <= pool_max [i]) {
 141                         dma_pool_free (hcd->pool [i], addr, dma);
 142                         return;
 143                 }
 144         }
 145         dma_free_coherent (hcd->self.controller, size, addr, dma);
 146 }