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