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 } 147