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, regardless of bus type. 6 */ 7 8 #include <linux/module.h> 9 #include <linux/kernel.h> 10 #include <linux/slab.h> 11 #include <linux/device.h> 12 #include <linux/mm.h> 13 #include <linux/io.h> 14 #include <linux/dma-mapping.h> 15 #include <linux/dmapool.h> 16 #include <linux/usb.h> 17 #include <linux/usb/hcd.h> 18 19 20 /* 21 * DMA-Coherent Buffers 22 */ 23 24 /* FIXME tune these based on pool statistics ... */ 25 static size_t pool_max[HCD_BUFFER_POOLS] = { 26 32, 128, 512, 2048, 27 }; 28 29 void __init usb_init_pool_max(void) 30 { 31 /* 32 * The pool_max values must never be smaller than 33 * ARCH_KMALLOC_MINALIGN. 34 */ 35 if (ARCH_KMALLOC_MINALIGN <= 32) 36 ; /* Original value is okay */ 37 else if (ARCH_KMALLOC_MINALIGN <= 64) 38 pool_max[0] = 64; 39 else if (ARCH_KMALLOC_MINALIGN <= 128) 40 pool_max[0] = 0; /* Don't use this pool */ 41 else 42 BUILD_BUG(); /* We don't allow this */ 43 } 44 45 /* SETUP primitives */ 46 47 /** 48 * hcd_buffer_create - initialize buffer pools 49 * @hcd: the bus whose buffer pools are to be initialized 50 * Context: !in_interrupt() 51 * 52 * Call this as part of initializing a host controller that uses the dma 53 * memory allocators. It initializes some pools of dma-coherent memory that 54 * will be shared by all drivers using that controller. 55 * 56 * Call hcd_buffer_destroy() to clean up after using those pools. 57 * 58 * Return: 0 if successful. A negative errno value otherwise. 59 */ 60 int hcd_buffer_create(struct usb_hcd *hcd) 61 { 62 char name[16]; 63 int i, size; 64 65 if (!IS_ENABLED(CONFIG_HAS_DMA) || 66 (!hcd->self.controller->dma_mask && 67 !(hcd->driver->flags & HCD_LOCAL_MEM))) 68 return 0; 69 70 for (i = 0; i < HCD_BUFFER_POOLS; i++) { 71 size = pool_max[i]; 72 if (!size) 73 continue; 74 snprintf(name, sizeof(name), "buffer-%d", size); 75 hcd->pool[i] = dma_pool_create(name, hcd->self.controller, 76 size, size, 0); 77 if (!hcd->pool[i]) { 78 hcd_buffer_destroy(hcd); 79 return -ENOMEM; 80 } 81 } 82 return 0; 83 } 84 85 86 /** 87 * hcd_buffer_destroy - deallocate buffer pools 88 * @hcd: the bus whose buffer pools are to be destroyed 89 * Context: !in_interrupt() 90 * 91 * This frees the buffer pools created by hcd_buffer_create(). 92 */ 93 void hcd_buffer_destroy(struct usb_hcd *hcd) 94 { 95 int i; 96 97 if (!IS_ENABLED(CONFIG_HAS_DMA)) 98 return; 99 100 for (i = 0; i < HCD_BUFFER_POOLS; i++) { 101 struct dma_pool *pool = hcd->pool[i]; 102 103 if (pool) { 104 dma_pool_destroy(pool); 105 hcd->pool[i] = NULL; 106 } 107 } 108 } 109 110 111 /* sometimes alloc/free could use kmalloc with GFP_DMA, for 112 * better sharing and to leverage mm/slab.c intelligence. 113 */ 114 115 void *hcd_buffer_alloc( 116 struct usb_bus *bus, 117 size_t size, 118 gfp_t mem_flags, 119 dma_addr_t *dma 120 ) 121 { 122 struct usb_hcd *hcd = bus_to_hcd(bus); 123 int i; 124 125 /* some USB hosts just use PIO */ 126 if (!IS_ENABLED(CONFIG_HAS_DMA) || 127 (!bus->controller->dma_mask && 128 !(hcd->driver->flags & HCD_LOCAL_MEM))) { 129 *dma = ~(dma_addr_t) 0; 130 return kmalloc(size, mem_flags); 131 } 132 133 for (i = 0; i < HCD_BUFFER_POOLS; i++) { 134 if (size <= pool_max[i]) 135 return dma_pool_alloc(hcd->pool[i], mem_flags, dma); 136 } 137 return dma_alloc_coherent(hcd->self.controller, size, dma, mem_flags); 138 } 139 140 void hcd_buffer_free( 141 struct usb_bus *bus, 142 size_t size, 143 void *addr, 144 dma_addr_t dma 145 ) 146 { 147 struct usb_hcd *hcd = bus_to_hcd(bus); 148 int i; 149 150 if (!addr) 151 return; 152 153 if (!IS_ENABLED(CONFIG_HAS_DMA) || 154 (!bus->controller->dma_mask && 155 !(hcd->driver->flags & HCD_LOCAL_MEM))) { 156 kfree(addr); 157 return; 158 } 159 160 for (i = 0; i < HCD_BUFFER_POOLS; i++) { 161 if (size <= pool_max[i]) { 162 dma_pool_free(hcd->pool[i], addr, dma); 163 return; 164 } 165 } 166 dma_free_coherent(hcd->self.controller, size, addr, dma); 167 } 168