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