USB: pegasus error path not resetting task's state
[linux-2.6] / drivers / scsi / sym53c8xx_2 / sym_malloc.c
1 /*
2  * Device driver for the SYMBIOS/LSILOGIC 53C8XX and 53C1010 family 
3  * of PCI-SCSI IO processors.
4  *
5  * Copyright (C) 1999-2001  Gerard Roudier <groudier@free.fr>
6  *
7  * This driver is derived from the Linux sym53c8xx driver.
8  * Copyright (C) 1998-2000  Gerard Roudier
9  *
10  * The sym53c8xx driver is derived from the ncr53c8xx driver that had been 
11  * a port of the FreeBSD ncr driver to Linux-1.2.13.
12  *
13  * The original ncr driver has been written for 386bsd and FreeBSD by
14  *         Wolfgang Stanglmeier        <wolf@cologne.de>
15  *         Stefan Esser                <se@mi.Uni-Koeln.de>
16  * Copyright (C) 1994  Wolfgang Stanglmeier
17  *
18  * Other major contributions:
19  *
20  * NVRAM detection and reading.
21  * Copyright (C) 1997 Richard Waltham <dormouse@farsrobt.demon.co.uk>
22  *
23  *-----------------------------------------------------------------------------
24  *
25  * This program is free software; you can redistribute it and/or modify
26  * it under the terms of the GNU General Public License as published by
27  * the Free Software Foundation; either version 2 of the License, or
28  * (at your option) any later version.
29  *
30  * This program is distributed in the hope that it will be useful,
31  * but WITHOUT ANY WARRANTY; without even the implied warranty of
32  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
33  * GNU General Public License for more details.
34  *
35  * You should have received a copy of the GNU General Public License
36  * along with this program; if not, write to the Free Software
37  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
38  */
39
40 #include "sym_glue.h"
41
42 /*
43  *  Simple power of two buddy-like generic allocator.
44  *  Provides naturally aligned memory chunks.
45  *
46  *  This simple code is not intended to be fast, but to 
47  *  provide power of 2 aligned memory allocations.
48  *  Since the SCRIPTS processor only supplies 8 bit arithmetic, 
49  *  this allocator allows simple and fast address calculations  
50  *  from the SCRIPTS code. In addition, cache line alignment 
51  *  is guaranteed for power of 2 cache line size.
52  *
53  *  This allocator has been developped for the Linux sym53c8xx  
54  *  driver, since this O/S does not provide naturally aligned 
55  *  allocations.
56  *  It has the advantage of allowing the driver to use private 
57  *  pages of memory that will be useful if we ever need to deal 
58  *  with IO MMUs for PCI.
59  */
60 static void *___sym_malloc(m_pool_p mp, int size)
61 {
62         int i = 0;
63         int s = (1 << SYM_MEM_SHIFT);
64         int j;
65         void *a;
66         m_link_p h = mp->h;
67
68         if (size > SYM_MEM_CLUSTER_SIZE)
69                 return NULL;
70
71         while (size > s) {
72                 s <<= 1;
73                 ++i;
74         }
75
76         j = i;
77         while (!h[j].next) {
78                 if (s == SYM_MEM_CLUSTER_SIZE) {
79                         h[j].next = (m_link_p) M_GET_MEM_CLUSTER();
80                         if (h[j].next)
81                                 h[j].next->next = NULL;
82                         break;
83                 }
84                 ++j;
85                 s <<= 1;
86         }
87         a = h[j].next;
88         if (a) {
89                 h[j].next = h[j].next->next;
90                 while (j > i) {
91                         j -= 1;
92                         s >>= 1;
93                         h[j].next = (m_link_p) (a+s);
94                         h[j].next->next = NULL;
95                 }
96         }
97 #ifdef DEBUG
98         printf("___sym_malloc(%d) = %p\n", size, (void *) a);
99 #endif
100         return a;
101 }
102
103 /*
104  *  Counter-part of the generic allocator.
105  */
106 static void ___sym_mfree(m_pool_p mp, void *ptr, int size)
107 {
108         int i = 0;
109         int s = (1 << SYM_MEM_SHIFT);
110         m_link_p q;
111         unsigned long a, b;
112         m_link_p h = mp->h;
113
114 #ifdef DEBUG
115         printf("___sym_mfree(%p, %d)\n", ptr, size);
116 #endif
117
118         if (size > SYM_MEM_CLUSTER_SIZE)
119                 return;
120
121         while (size > s) {
122                 s <<= 1;
123                 ++i;
124         }
125
126         a = (unsigned long)ptr;
127
128         while (1) {
129                 if (s == SYM_MEM_CLUSTER_SIZE) {
130 #ifdef SYM_MEM_FREE_UNUSED
131                         M_FREE_MEM_CLUSTER((void *)a);
132 #else
133                         ((m_link_p) a)->next = h[i].next;
134                         h[i].next = (m_link_p) a;
135 #endif
136                         break;
137                 }
138                 b = a ^ s;
139                 q = &h[i];
140                 while (q->next && q->next != (m_link_p) b) {
141                         q = q->next;
142                 }
143                 if (!q->next) {
144                         ((m_link_p) a)->next = h[i].next;
145                         h[i].next = (m_link_p) a;
146                         break;
147                 }
148                 q->next = q->next->next;
149                 a = a & b;
150                 s <<= 1;
151                 ++i;
152         }
153 }
154
155 /*
156  *  Verbose and zeroing allocator that wrapps to the generic allocator.
157  */
158 static void *__sym_calloc2(m_pool_p mp, int size, char *name, int uflags)
159 {
160         void *p;
161
162         p = ___sym_malloc(mp, size);
163
164         if (DEBUG_FLAGS & DEBUG_ALLOC) {
165                 printf ("new %-10s[%4d] @%p.\n", name, size, p);
166         }
167
168         if (p)
169                 memset(p, 0, size);
170         else if (uflags & SYM_MEM_WARN)
171                 printf ("__sym_calloc2: failed to allocate %s[%d]\n", name, size);
172         return p;
173 }
174 #define __sym_calloc(mp, s, n)  __sym_calloc2(mp, s, n, SYM_MEM_WARN)
175
176 /*
177  *  Its counter-part.
178  */
179 static void __sym_mfree(m_pool_p mp, void *ptr, int size, char *name)
180 {
181         if (DEBUG_FLAGS & DEBUG_ALLOC)
182                 printf ("freeing %-10s[%4d] @%p.\n", name, size, ptr);
183
184         ___sym_mfree(mp, ptr, size);
185 }
186
187 /*
188  *  Default memory pool we donnot need to involve in DMA.
189  *
190  *  With DMA abstraction, we use functions (methods), to 
191  *  distinguish between non DMAable memory and DMAable memory.
192  */
193 static void *___mp0_get_mem_cluster(m_pool_p mp)
194 {
195         void *m = sym_get_mem_cluster();
196         if (m)
197                 ++mp->nump;
198         return m;
199 }
200
201 #ifdef  SYM_MEM_FREE_UNUSED
202 static void ___mp0_free_mem_cluster(m_pool_p mp, void *m)
203 {
204         sym_free_mem_cluster(m);
205         --mp->nump;
206 }
207 #else
208 #define ___mp0_free_mem_cluster NULL
209 #endif
210
211 static struct sym_m_pool mp0 = {
212         NULL,
213         ___mp0_get_mem_cluster,
214         ___mp0_free_mem_cluster
215 };
216
217 /*
218  *  Methods that maintains DMAable pools according to user allocations.
219  *  New pools are created on the fly when a new pool id is provided.
220  *  They are deleted on the fly when they get emptied.
221  */
222 /* Get a memory cluster that matches the DMA constraints of a given pool */
223 static void * ___get_dma_mem_cluster(m_pool_p mp)
224 {
225         m_vtob_p vbp;
226         void *vaddr;
227
228         vbp = __sym_calloc(&mp0, sizeof(*vbp), "VTOB");
229         if (!vbp)
230                 goto out_err;
231
232         vaddr = sym_m_get_dma_mem_cluster(mp, vbp);
233         if (vaddr) {
234                 int hc = VTOB_HASH_CODE(vaddr);
235                 vbp->next = mp->vtob[hc];
236                 mp->vtob[hc] = vbp;
237                 ++mp->nump;
238         }
239         return vaddr;
240 out_err:
241         return NULL;
242 }
243
244 #ifdef  SYM_MEM_FREE_UNUSED
245 /* Free a memory cluster and associated resources for DMA */
246 static void ___free_dma_mem_cluster(m_pool_p mp, void *m)
247 {
248         m_vtob_p *vbpp, vbp;
249         int hc = VTOB_HASH_CODE(m);
250
251         vbpp = &mp->vtob[hc];
252         while (*vbpp && (*vbpp)->vaddr != m)
253                 vbpp = &(*vbpp)->next;
254         if (*vbpp) {
255                 vbp = *vbpp;
256                 *vbpp = (*vbpp)->next;
257                 sym_m_free_dma_mem_cluster(mp, vbp);
258                 __sym_mfree(&mp0, vbp, sizeof(*vbp), "VTOB");
259                 --mp->nump;
260         }
261 }
262 #endif
263
264 /* Fetch the memory pool for a given pool id (i.e. DMA constraints) */
265 static __inline m_pool_p ___get_dma_pool(m_pool_ident_t dev_dmat)
266 {
267         m_pool_p mp;
268         for (mp = mp0.next;
269                 mp && !sym_m_pool_match(mp->dev_dmat, dev_dmat);
270                         mp = mp->next);
271         return mp;
272 }
273
274 /* Create a new memory DMAable pool (when fetch failed) */
275 static m_pool_p ___cre_dma_pool(m_pool_ident_t dev_dmat)
276 {
277         m_pool_p mp = __sym_calloc(&mp0, sizeof(*mp), "MPOOL");
278         if (mp) {
279                 mp->dev_dmat = dev_dmat;
280                 mp->get_mem_cluster = ___get_dma_mem_cluster;
281 #ifdef  SYM_MEM_FREE_UNUSED
282                 mp->free_mem_cluster = ___free_dma_mem_cluster;
283 #endif
284                 mp->next = mp0.next;
285                 mp0.next = mp;
286                 return mp;
287         }
288         return NULL;
289 }
290
291 #ifdef  SYM_MEM_FREE_UNUSED
292 /* Destroy a DMAable memory pool (when got emptied) */
293 static void ___del_dma_pool(m_pool_p p)
294 {
295         m_pool_p *pp = &mp0.next;
296
297         while (*pp && *pp != p)
298                 pp = &(*pp)->next;
299         if (*pp) {
300                 *pp = (*pp)->next;
301                 __sym_mfree(&mp0, p, sizeof(*p), "MPOOL");
302         }
303 }
304 #endif
305
306 /* This lock protects only the memory allocation/free.  */
307 static DEFINE_SPINLOCK(sym53c8xx_lock);
308
309 /*
310  *  Actual allocator for DMAable memory.
311  */
312 void *__sym_calloc_dma(m_pool_ident_t dev_dmat, int size, char *name)
313 {
314         unsigned long flags;
315         m_pool_p mp;
316         void *m = NULL;
317
318         spin_lock_irqsave(&sym53c8xx_lock, flags);
319         mp = ___get_dma_pool(dev_dmat);
320         if (!mp)
321                 mp = ___cre_dma_pool(dev_dmat);
322         if (!mp)
323                 goto out;
324         m = __sym_calloc(mp, size, name);
325 #ifdef  SYM_MEM_FREE_UNUSED
326         if (!mp->nump)
327                 ___del_dma_pool(mp);
328 #endif
329
330  out:
331         spin_unlock_irqrestore(&sym53c8xx_lock, flags);
332         return m;
333 }
334
335 void __sym_mfree_dma(m_pool_ident_t dev_dmat, void *m, int size, char *name)
336 {
337         unsigned long flags;
338         m_pool_p mp;
339
340         spin_lock_irqsave(&sym53c8xx_lock, flags);
341         mp = ___get_dma_pool(dev_dmat);
342         if (!mp)
343                 goto out;
344         __sym_mfree(mp, m, size, name);
345 #ifdef  SYM_MEM_FREE_UNUSED
346         if (!mp->nump)
347                 ___del_dma_pool(mp);
348 #endif
349  out:
350         spin_unlock_irqrestore(&sym53c8xx_lock, flags);
351 }
352
353 /*
354  *  Actual virtual to bus physical address translator 
355  *  for 32 bit addressable DMAable memory.
356  */
357 dma_addr_t __vtobus(m_pool_ident_t dev_dmat, void *m)
358 {
359         unsigned long flags;
360         m_pool_p mp;
361         int hc = VTOB_HASH_CODE(m);
362         m_vtob_p vp = NULL;
363         void *a = (void *)((unsigned long)m & ~SYM_MEM_CLUSTER_MASK);
364         dma_addr_t b;
365
366         spin_lock_irqsave(&sym53c8xx_lock, flags);
367         mp = ___get_dma_pool(dev_dmat);
368         if (mp) {
369                 vp = mp->vtob[hc];
370                 while (vp && vp->vaddr != a)
371                         vp = vp->next;
372         }
373         if (!vp)
374                 panic("sym: VTOBUS FAILED!\n");
375         b = vp->baddr + (m - a);
376         spin_unlock_irqrestore(&sym53c8xx_lock, flags);
377         return b;
378 }