2 * DMA memory management for framework level HCD code (hc_driver)
4 * This implementation plugs in through generic "usb_bus" level methods,
5 * and should work with all USB controllers, regardles of bus type.
8 #include <linux/module.h>
9 #include <linux/kernel.h>
10 #include <linux/slab.h>
11 #include <linux/device.h>
14 #include <asm/scatterlist.h>
15 #include <linux/dma-mapping.h>
16 #include <linux/dmapool.h>
17 #include <linux/usb.h>
22 * DMA-Coherent Buffers
25 /* FIXME tune these based on pool statistics ... */
26 static const size_t pool_max
[HCD_BUFFER_POOLS
] = {
27 /* platforms without dma-friendly caches might need to
28 * prevent cacheline sharing...
34 /* bigger --> allocate pages */
38 /* SETUP primitives */
41 * hcd_buffer_create - initialize buffer pools
42 * @hcd: the bus whose buffer pools are to be initialized
43 * Context: !in_interrupt()
45 * Call this as part of initializing a host controller that uses the dma
46 * memory allocators. It initializes some pools of dma-coherent memory that
47 * will be shared by all drivers using that controller, or returns a negative
48 * errno value on error.
50 * Call hcd_buffer_destroy() to clean up after using those pools.
52 int hcd_buffer_create (struct usb_hcd
*hcd
)
57 if (!hcd
->self
.controller
->dma_mask
)
60 for (i
= 0; i
< HCD_BUFFER_POOLS
; i
++) {
61 if (!(size
= pool_max
[i
]))
63 snprintf (name
, sizeof name
, "buffer-%d", size
);
64 hcd
->pool
[i
] = dma_pool_create (name
, hcd
->self
.controller
,
67 hcd_buffer_destroy (hcd
);
76 * hcd_buffer_destroy - deallocate buffer pools
77 * @hcd: the bus whose buffer pools are to be destroyed
78 * Context: !in_interrupt()
80 * This frees the buffer pools created by hcd_buffer_create().
82 void hcd_buffer_destroy (struct usb_hcd
*hcd
)
86 for (i
= 0; i
< HCD_BUFFER_POOLS
; i
++) {
87 struct dma_pool
*pool
= hcd
->pool
[i
];
89 dma_pool_destroy (pool
);
96 /* sometimes alloc/free could use kmalloc with SLAB_DMA, for
97 * better sharing and to leverage mm/slab.c intelligence.
100 void *hcd_buffer_alloc (
107 struct usb_hcd
*hcd
= bus
->hcpriv
;
110 /* some USB hosts just use PIO */
111 if (!bus
->controller
->dma_mask
) {
112 *dma
= ~(dma_addr_t
) 0;
113 return kmalloc (size
, mem_flags
);
116 for (i
= 0; i
< HCD_BUFFER_POOLS
; i
++) {
117 if (size
<= pool_max
[i
])
118 return dma_pool_alloc (hcd
->pool
[i
], mem_flags
, dma
);
120 return dma_alloc_coherent (hcd
->self
.controller
, size
, dma
, 0);
123 void hcd_buffer_free (
130 struct usb_hcd
*hcd
= bus
->hcpriv
;
136 if (!bus
->controller
->dma_mask
) {
141 for (i
= 0; i
< HCD_BUFFER_POOLS
; i
++) {
142 if (size
<= pool_max
[i
]) {
143 dma_pool_free (hcd
->pool
[i
], addr
, dma
);
147 dma_free_coherent (hcd
->self
.controller
, size
, addr
, dma
);