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/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 const size_t	pool_max[HCD_BUFFER_POOLS] = {
26 	/* platforms without dma-friendly caches might need to
27 	 * prevent cacheline sharing...
28 	 */
29 	32,
30 	128,
31 	512,
32 	PAGE_SIZE / 2
33 	/* bigger --> allocate pages */
34 };
35 
36 
37 /* SETUP primitives */
38 
39 /**
40  * hcd_buffer_create - initialize buffer pools
41  * @hcd: the bus whose buffer pools are to be initialized
42  * Context: !in_interrupt()
43  *
44  * Call this as part of initializing a host controller that uses the dma
45  * memory allocators.  It initializes some pools of dma-coherent memory that
46  * will be shared by all drivers using that controller, or returns a negative
47  * errno value on error.
48  *
49  * Call hcd_buffer_destroy() to clean up after using those pools.
50  */
hcd_buffer_create(struct usb_hcd * hcd)51 int hcd_buffer_create(struct usb_hcd *hcd)
52 {
53 	char		name[16];
54 	int		i, size;
55 
56 	if (!hcd->self.controller->dma_mask &&
57 	    !(hcd->driver->flags & HCD_LOCAL_MEM))
58 		return 0;
59 
60 	for (i = 0; i < HCD_BUFFER_POOLS; i++) {
61 		size = pool_max[i];
62 		if (!size)
63 			continue;
64 		snprintf(name, sizeof name, "buffer-%d", size);
65 		hcd->pool[i] = dma_pool_create(name, hcd->self.controller,
66 				size, size, 0);
67 		if (!hcd->pool[i]) {
68 			hcd_buffer_destroy(hcd);
69 			return -ENOMEM;
70 		}
71 	}
72 	return 0;
73 }
74 
75 
76 /**
77  * hcd_buffer_destroy - deallocate buffer pools
78  * @hcd: the bus whose buffer pools are to be destroyed
79  * Context: !in_interrupt()
80  *
81  * This frees the buffer pools created by hcd_buffer_create().
82  */
hcd_buffer_destroy(struct usb_hcd * hcd)83 void hcd_buffer_destroy(struct usb_hcd *hcd)
84 {
85 	int i;
86 
87 	for (i = 0; i < HCD_BUFFER_POOLS; i++) {
88 		struct dma_pool *pool = hcd->pool[i];
89 		if (pool) {
90 			dma_pool_destroy(pool);
91 			hcd->pool[i] = NULL;
92 		}
93 	}
94 }
95 
96 
97 /* sometimes alloc/free could use kmalloc with GFP_DMA, for
98  * better sharing and to leverage mm/slab.c intelligence.
99  */
100 
hcd_buffer_alloc(struct usb_bus * bus,size_t size,gfp_t mem_flags,dma_addr_t * dma)101 void *hcd_buffer_alloc(
102 	struct usb_bus		*bus,
103 	size_t			size,
104 	gfp_t			mem_flags,
105 	dma_addr_t		*dma
106 )
107 {
108 	struct usb_hcd		*hcd = bus_to_hcd(bus);
109 	int			i;
110 
111 	/* some USB hosts just use PIO */
112 	if (!bus->controller->dma_mask &&
113 	    !(hcd->driver->flags & HCD_LOCAL_MEM)) {
114 		*dma = ~(dma_addr_t) 0;
115 		return kmalloc(size, mem_flags);
116 	}
117 
118 	for (i = 0; i < HCD_BUFFER_POOLS; i++) {
119 		if (size <= pool_max[i])
120 			return dma_pool_alloc(hcd->pool[i], mem_flags, dma);
121 	}
122 	return dma_alloc_coherent(hcd->self.controller, size, dma, mem_flags);
123 }
124 
hcd_buffer_free(struct usb_bus * bus,size_t size,void * addr,dma_addr_t dma)125 void hcd_buffer_free(
126 	struct usb_bus		*bus,
127 	size_t			size,
128 	void			*addr,
129 	dma_addr_t		dma
130 )
131 {
132 	struct usb_hcd		*hcd = bus_to_hcd(bus);
133 	int			i;
134 
135 	if (!addr)
136 		return;
137 
138 	if (!bus->controller->dma_mask &&
139 	    !(hcd->driver->flags & HCD_LOCAL_MEM)) {
140 		kfree(addr);
141 		return;
142 	}
143 
144 	for (i = 0; i < HCD_BUFFER_POOLS; i++) {
145 		if (size <= pool_max[i]) {
146 			dma_pool_free(hcd->pool[i], addr, dma);
147 			return;
148 		}
149 	}
150 	dma_free_coherent(hcd->self.controller, size, addr, dma);
151 }
152