FreeBSD/Linux Kernel Cross Reference
sys/dev/usb/usb_mem.c
1 /* $NetBSD: usb_mem.c,v 1.27 2004/01/05 13:30:45 augustss Exp $ */
2
3 /*
4 * Copyright (c) 1998 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Lennart Augustsson (lennart@augustsson.net) at
9 * Carlstedt Research & Technology.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 * 3. All advertising materials mentioning features or use of this software
20 * must display the following acknowledgement:
21 * This product includes software developed by the NetBSD
22 * Foundation, Inc. and its contributors.
23 * 4. Neither the name of The NetBSD Foundation nor the names of its
24 * contributors may be used to endorse or promote products derived
25 * from this software without specific prior written permission.
26 *
27 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
28 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
29 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
30 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
31 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
32 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
33 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
34 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
35 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
36 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
37 * POSSIBILITY OF SUCH DAMAGE.
38 */
39
40 /*
41 * USB DMA memory allocation.
42 * We need to allocate a lot of small (many 8 byte, some larger)
43 * memory blocks that can be used for DMA. Using the bus_dma
44 * routines directly would incur large overheads in space and time.
45 */
46
47 #include <sys/cdefs.h>
48 __KERNEL_RCSID(0, "$NetBSD: usb_mem.c,v 1.27 2004/01/05 13:30:45 augustss Exp $");
49
50 #include <sys/param.h>
51 #include <sys/systm.h>
52 #include <sys/kernel.h>
53 #include <sys/malloc.h>
54 #include <sys/queue.h>
55 #include <sys/device.h> /* for usbdivar.h */
56 #include <machine/bus.h>
57
58 #ifdef DIAGNOSTIC
59 #include <sys/proc.h>
60 #endif
61
62 #include <dev/usb/usb.h>
63 #include <dev/usb/usbdi.h>
64 #include <dev/usb/usbdivar.h> /* just for usb_dma_t */
65 #include <dev/usb/usb_mem.h>
66
67 #ifdef USB_DEBUG
68 #define DPRINTF(x) if (usbdebug) logprintf x
69 #define DPRINTFN(n,x) if (usbdebug>(n)) logprintf x
70 extern int usbdebug;
71 #else
72 #define DPRINTF(x)
73 #define DPRINTFN(n,x)
74 #endif
75
76 MALLOC_DEFINE(M_USB, "USB", "USB misc. memory");
77 MALLOC_DEFINE(M_USBDEV, "USB device", "USB device driver");
78 MALLOC_DEFINE(M_USBHC, "USB HC", "USB host controller");
79
80 #define USB_MEM_SMALL 64
81 #define USB_MEM_CHUNKS 64
82 #define USB_MEM_BLOCK (USB_MEM_SMALL * USB_MEM_CHUNKS)
83
84 /* This struct is overlayed on free fragments. */
85 struct usb_frag_dma {
86 usb_dma_block_t *block;
87 u_int offs;
88 LIST_ENTRY(usb_frag_dma) next;
89 };
90
91 Static usbd_status usb_block_allocmem(bus_dma_tag_t, size_t, size_t,
92 usb_dma_block_t **);
93 Static void usb_block_freemem(usb_dma_block_t *);
94
95 Static LIST_HEAD(, usb_dma_block) usb_blk_freelist =
96 LIST_HEAD_INITIALIZER(usb_blk_freelist);
97 Static int usb_blk_nfree = 0;
98 /* XXX should have different free list for different tags (for speed) */
99 Static LIST_HEAD(, usb_frag_dma) usb_frag_freelist =
100 LIST_HEAD_INITIALIZER(usb_frag_freelist);
101
102 Static usbd_status
103 usb_block_allocmem(bus_dma_tag_t tag, size_t size, size_t align,
104 usb_dma_block_t **dmap)
105 {
106 int error;
107 usb_dma_block_t *p;
108 int s;
109
110 DPRINTFN(5, ("usb_block_allocmem: size=%lu align=%lu\n",
111 (u_long)size, (u_long)align));
112
113 #ifdef DIAGNOSTIC
114 if (!curproc) {
115 printf("usb_block_allocmem: in interrupt context, size=%lu\n",
116 (unsigned long) size);
117 }
118 #endif
119
120 s = splusb();
121 /* First check the free list. */
122 for (p = LIST_FIRST(&usb_blk_freelist); p; p = LIST_NEXT(p, next)) {
123 if (p->tag == tag && p->size >= size && p->align >= align) {
124 LIST_REMOVE(p, next);
125 usb_blk_nfree--;
126 splx(s);
127 *dmap = p;
128 DPRINTFN(6,("usb_block_allocmem: free list size=%lu\n",
129 (u_long)p->size));
130 return (USBD_NORMAL_COMPLETION);
131 }
132 }
133 splx(s);
134
135 #ifdef DIAGNOSTIC
136 if (!curproc) {
137 printf("usb_block_allocmem: in interrupt context, failed\n");
138 return (USBD_NOMEM);
139 }
140 #endif
141
142 DPRINTFN(6, ("usb_block_allocmem: no free\n"));
143 p = malloc(sizeof *p, M_USB, M_NOWAIT);
144 if (p == NULL)
145 return (USBD_NOMEM);
146
147 p->tag = tag;
148 p->size = size;
149 p->align = align;
150 error = bus_dmamem_alloc(tag, p->size, align, 0,
151 p->segs, sizeof(p->segs)/sizeof(p->segs[0]),
152 &p->nsegs, BUS_DMA_NOWAIT);
153 if (error)
154 goto free0;
155
156 error = bus_dmamem_map(tag, p->segs, p->nsegs, p->size,
157 &p->kaddr, BUS_DMA_NOWAIT|BUS_DMA_COHERENT);
158 if (error)
159 goto free1;
160
161 error = bus_dmamap_create(tag, p->size, 1, p->size,
162 0, BUS_DMA_NOWAIT, &p->map);
163 if (error)
164 goto unmap;
165
166 error = bus_dmamap_load(tag, p->map, p->kaddr, p->size, NULL,
167 BUS_DMA_NOWAIT);
168 if (error)
169 goto destroy;
170
171 *dmap = p;
172 return (USBD_NORMAL_COMPLETION);
173
174 destroy:
175 bus_dmamap_destroy(tag, p->map);
176 unmap:
177 bus_dmamem_unmap(tag, p->kaddr, p->size);
178 free1:
179 bus_dmamem_free(tag, p->segs, p->nsegs);
180 free0:
181 free(p, M_USB);
182 return (USBD_NOMEM);
183 }
184
185 #if 0
186 void
187 usb_block_real_freemem(usb_dma_block_t *p)
188 {
189 #ifdef DIAGNOSTIC
190 if (!curproc) {
191 printf("usb_block_real_freemem: in interrupt context\n");
192 return;
193 }
194 #endif
195 bus_dmamap_unload(p->tag, p->map);
196 bus_dmamap_destroy(p->tag, p->map);
197 bus_dmamem_unmap(p->tag, p->kaddr, p->size);
198 bus_dmamem_free(p->tag, p->segs, p->nsegs);
199 free(p, M_USB);
200 }
201 #endif
202
203 /*
204 * Do not free the memory unconditionally since we might be called
205 * from an interrupt context and that is BAD.
206 * XXX when should we really free?
207 */
208 Static void
209 usb_block_freemem(usb_dma_block_t *p)
210 {
211 int s;
212
213 DPRINTFN(6, ("usb_block_freemem: size=%lu\n", (u_long)p->size));
214 s = splusb();
215 LIST_INSERT_HEAD(&usb_blk_freelist, p, next);
216 usb_blk_nfree++;
217 splx(s);
218 }
219
220 usbd_status
221 usb_allocmem(usbd_bus_handle bus, size_t size, size_t align, usb_dma_t *p)
222 {
223 bus_dma_tag_t tag = bus->dmatag;
224 usbd_status err;
225 struct usb_frag_dma *f;
226 usb_dma_block_t *b;
227 int i;
228 int s;
229
230 /* If the request is large then just use a full block. */
231 if (size > USB_MEM_SMALL || align > USB_MEM_SMALL) {
232 DPRINTFN(1, ("usb_allocmem: large alloc %d\n", (int)size));
233 size = (size + USB_MEM_BLOCK - 1) & ~(USB_MEM_BLOCK - 1);
234 err = usb_block_allocmem(tag, size, align, &p->block);
235 if (!err) {
236 p->block->fullblock = 1;
237 p->offs = 0;
238 }
239 return (err);
240 }
241
242 s = splusb();
243 /* Check for free fragments. */
244 for (f = LIST_FIRST(&usb_frag_freelist); f; f = LIST_NEXT(f, next))
245 if (f->block->tag == tag)
246 break;
247 if (f == NULL) {
248 DPRINTFN(1, ("usb_allocmem: adding fragments\n"));
249 err = usb_block_allocmem(tag, USB_MEM_BLOCK, USB_MEM_SMALL,&b);
250 if (err) {
251 splx(s);
252 return (err);
253 }
254 b->fullblock = 0;
255 for (i = 0; i < USB_MEM_BLOCK; i += USB_MEM_SMALL) {
256 f = (struct usb_frag_dma *)(b->kaddr + i);
257 f->block = b;
258 f->offs = i;
259 LIST_INSERT_HEAD(&usb_frag_freelist, f, next);
260 }
261 f = LIST_FIRST(&usb_frag_freelist);
262 }
263 p->block = f->block;
264 p->offs = f->offs;
265 LIST_REMOVE(f, next);
266 splx(s);
267 DPRINTFN(5, ("usb_allocmem: use frag=%p size=%d\n", f, (int)size));
268 return (USBD_NORMAL_COMPLETION);
269 }
270
271 void
272 usb_freemem(usbd_bus_handle bus, usb_dma_t *p)
273 {
274 struct usb_frag_dma *f;
275 int s;
276
277 if (p->block->fullblock) {
278 DPRINTFN(1, ("usb_freemem: large free\n"));
279 usb_block_freemem(p->block);
280 return;
281 }
282 f = KERNADDR(p, 0);
283 f->block = p->block;
284 f->offs = p->offs;
285 s = splusb();
286 LIST_INSERT_HEAD(&usb_frag_freelist, f, next);
287 splx(s);
288 DPRINTFN(5, ("usb_freemem: frag=%p\n", f));
289 }
Cache object: 77145658d3eaddc62a1b5b13620e3391
|