Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /****************************************************************************** |
2 | ** High Performance device driver for the Symbios 53C896 controller. | |
3 | ** | |
4 | ** Copyright (C) 1998-2001 Gerard Roudier <groudier@free.fr> | |
5 | ** | |
6 | ** This driver also supports all the Symbios 53C8XX controller family, | |
7 | ** except 53C810 revisions < 16, 53C825 revisions < 16 and all | |
8 | ** revisions of 53C815 controllers. | |
9 | ** | |
10 | ** This driver is based on the Linux port of the FreeBSD ncr driver. | |
11 | ** | |
12 | ** Copyright (C) 1994 Wolfgang Stanglmeier | |
13 | ** | |
14 | **----------------------------------------------------------------------------- | |
15 | ** | |
16 | ** This program is free software; you can redistribute it and/or modify | |
17 | ** it under the terms of the GNU General Public License as published by | |
18 | ** the Free Software Foundation; either version 2 of the License, or | |
19 | ** (at your option) any later version. | |
20 | ** | |
21 | ** This program is distributed in the hope that it will be useful, | |
22 | ** but WITHOUT ANY WARRANTY; without even the implied warranty of | |
23 | ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
24 | ** GNU General Public License for more details. | |
25 | ** | |
26 | ** You should have received a copy of the GNU General Public License | |
27 | ** along with this program; if not, write to the Free Software | |
28 | ** Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | |
29 | ** | |
30 | **----------------------------------------------------------------------------- | |
31 | ** | |
32 | ** The Linux port of the FreeBSD ncr driver has been achieved in | |
33 | ** november 1995 by: | |
34 | ** | |
35 | ** Gerard Roudier <groudier@free.fr> | |
36 | ** | |
37 | ** Being given that this driver originates from the FreeBSD version, and | |
38 | ** in order to keep synergy on both, any suggested enhancements and corrections | |
39 | ** received on Linux are automatically a potential candidate for the FreeBSD | |
40 | ** version. | |
41 | ** | |
42 | ** The original driver has been written for 386bsd and FreeBSD by | |
43 | ** Wolfgang Stanglmeier <wolf@cologne.de> | |
44 | ** Stefan Esser <se@mi.Uni-Koeln.de> | |
45 | ** | |
46 | **----------------------------------------------------------------------------- | |
47 | ** | |
48 | ** Major contributions: | |
49 | ** -------------------- | |
50 | ** | |
51 | ** NVRAM detection and reading. | |
52 | ** Copyright (C) 1997 Richard Waltham <dormouse@farsrobt.demon.co.uk> | |
53 | ** | |
54 | ******************************************************************************* | |
55 | */ | |
56 | ||
57 | /*========================================================== | |
58 | ** | |
59 | ** Debugging tags | |
60 | ** | |
61 | **========================================================== | |
62 | */ | |
63 | ||
64 | #define DEBUG_ALLOC (0x0001) | |
65 | #define DEBUG_PHASE (0x0002) | |
66 | #define DEBUG_QUEUE (0x0008) | |
67 | #define DEBUG_RESULT (0x0010) | |
68 | #define DEBUG_POINTER (0x0020) | |
69 | #define DEBUG_SCRIPT (0x0040) | |
70 | #define DEBUG_TINY (0x0080) | |
71 | #define DEBUG_TIMING (0x0100) | |
72 | #define DEBUG_NEGO (0x0200) | |
73 | #define DEBUG_TAGS (0x0400) | |
74 | #define DEBUG_SCATTER (0x0800) | |
75 | #define DEBUG_IC (0x1000) | |
76 | ||
77 | /* | |
78 | ** Enable/Disable debug messages. | |
79 | ** Can be changed at runtime too. | |
80 | */ | |
81 | ||
82 | #ifdef SCSI_NCR_DEBUG_INFO_SUPPORT | |
83 | static int ncr_debug = SCSI_NCR_DEBUG_FLAGS; | |
84 | #define DEBUG_FLAGS ncr_debug | |
85 | #else | |
86 | #define DEBUG_FLAGS SCSI_NCR_DEBUG_FLAGS | |
87 | #endif | |
88 | ||
89 | static inline struct list_head *ncr_list_pop(struct list_head *head) | |
90 | { | |
91 | if (!list_empty(head)) { | |
92 | struct list_head *elem = head->next; | |
93 | ||
94 | list_del(elem); | |
95 | return elem; | |
96 | } | |
97 | ||
98 | return NULL; | |
99 | } | |
100 | ||
101 | #ifdef __sparc__ | |
102 | #include <asm/irq.h> | |
103 | #endif | |
104 | ||
105 | /*========================================================== | |
106 | ** | |
107 | ** Simple power of two buddy-like allocator. | |
108 | ** | |
109 | ** This simple code is not intended to be fast, but to | |
110 | ** provide power of 2 aligned memory allocations. | |
111 | ** Since the SCRIPTS processor only supplies 8 bit | |
112 | ** arithmetic, this allocator allows simple and fast | |
113 | ** address calculations from the SCRIPTS code. | |
114 | ** In addition, cache line alignment is guaranteed for | |
115 | ** power of 2 cache line size. | |
116 | ** Enhanced in linux-2.3.44 to provide a memory pool | |
117 | ** per pcidev to support dynamic dma mapping. (I would | |
118 | ** have preferred a real bus astraction, btw). | |
119 | ** | |
120 | **========================================================== | |
121 | */ | |
122 | ||
123 | #define MEMO_SHIFT 4 /* 16 bytes minimum memory chunk */ | |
124 | #if PAGE_SIZE >= 8192 | |
125 | #define MEMO_PAGE_ORDER 0 /* 1 PAGE maximum */ | |
126 | #else | |
127 | #define MEMO_PAGE_ORDER 1 /* 2 PAGES maximum */ | |
128 | #endif | |
129 | #define MEMO_FREE_UNUSED /* Free unused pages immediately */ | |
130 | #define MEMO_WARN 1 | |
131 | #define MEMO_GFP_FLAGS GFP_ATOMIC | |
132 | #define MEMO_CLUSTER_SHIFT (PAGE_SHIFT+MEMO_PAGE_ORDER) | |
133 | #define MEMO_CLUSTER_SIZE (1UL << MEMO_CLUSTER_SHIFT) | |
134 | #define MEMO_CLUSTER_MASK (MEMO_CLUSTER_SIZE-1) | |
135 | ||
136 | typedef u_long m_addr_t; /* Enough bits to bit-hack addresses */ | |
137 | typedef struct device *m_bush_t; /* Something that addresses DMAable */ | |
138 | ||
139 | typedef struct m_link { /* Link between free memory chunks */ | |
140 | struct m_link *next; | |
141 | } m_link_s; | |
142 | ||
143 | typedef struct m_vtob { /* Virtual to Bus address translation */ | |
144 | struct m_vtob *next; | |
145 | m_addr_t vaddr; | |
146 | m_addr_t baddr; | |
147 | } m_vtob_s; | |
148 | #define VTOB_HASH_SHIFT 5 | |
149 | #define VTOB_HASH_SIZE (1UL << VTOB_HASH_SHIFT) | |
150 | #define VTOB_HASH_MASK (VTOB_HASH_SIZE-1) | |
151 | #define VTOB_HASH_CODE(m) \ | |
152 | ((((m_addr_t) (m)) >> MEMO_CLUSTER_SHIFT) & VTOB_HASH_MASK) | |
153 | ||
154 | typedef struct m_pool { /* Memory pool of a given kind */ | |
155 | m_bush_t bush; | |
156 | m_addr_t (*getp)(struct m_pool *); | |
157 | void (*freep)(struct m_pool *, m_addr_t); | |
158 | int nump; | |
159 | m_vtob_s *(vtob[VTOB_HASH_SIZE]); | |
160 | struct m_pool *next; | |
161 | struct m_link h[PAGE_SHIFT-MEMO_SHIFT+MEMO_PAGE_ORDER+1]; | |
162 | } m_pool_s; | |
163 | ||
164 | static void *___m_alloc(m_pool_s *mp, int size) | |
165 | { | |
166 | int i = 0; | |
167 | int s = (1 << MEMO_SHIFT); | |
168 | int j; | |
169 | m_addr_t a; | |
170 | m_link_s *h = mp->h; | |
171 | ||
172 | if (size > (PAGE_SIZE << MEMO_PAGE_ORDER)) | |
173 | return NULL; | |
174 | ||
175 | while (size > s) { | |
176 | s <<= 1; | |
177 | ++i; | |
178 | } | |
179 | ||
180 | j = i; | |
181 | while (!h[j].next) { | |
182 | if (s == (PAGE_SIZE << MEMO_PAGE_ORDER)) { | |
183 | h[j].next = (m_link_s *)mp->getp(mp); | |
184 | if (h[j].next) | |
185 | h[j].next->next = NULL; | |
186 | break; | |
187 | } | |
188 | ++j; | |
189 | s <<= 1; | |
190 | } | |
191 | a = (m_addr_t) h[j].next; | |
192 | if (a) { | |
193 | h[j].next = h[j].next->next; | |
194 | while (j > i) { | |
195 | j -= 1; | |
196 | s >>= 1; | |
197 | h[j].next = (m_link_s *) (a+s); | |
198 | h[j].next->next = NULL; | |
199 | } | |
200 | } | |
201 | #ifdef DEBUG | |
202 | printk("___m_alloc(%d) = %p\n", size, (void *) a); | |
203 | #endif | |
204 | return (void *) a; | |
205 | } | |
206 | ||
207 | static void ___m_free(m_pool_s *mp, void *ptr, int size) | |
208 | { | |
209 | int i = 0; | |
210 | int s = (1 << MEMO_SHIFT); | |
211 | m_link_s *q; | |
212 | m_addr_t a, b; | |
213 | m_link_s *h = mp->h; | |
214 | ||
215 | #ifdef DEBUG | |
216 | printk("___m_free(%p, %d)\n", ptr, size); | |
217 | #endif | |
218 | ||
219 | if (size > (PAGE_SIZE << MEMO_PAGE_ORDER)) | |
220 | return; | |
221 | ||
222 | while (size > s) { | |
223 | s <<= 1; | |
224 | ++i; | |
225 | } | |
226 | ||
227 | a = (m_addr_t) ptr; | |
228 | ||
229 | while (1) { | |
230 | #ifdef MEMO_FREE_UNUSED | |
231 | if (s == (PAGE_SIZE << MEMO_PAGE_ORDER)) { | |
232 | mp->freep(mp, a); | |
233 | break; | |
234 | } | |
235 | #endif | |
236 | b = a ^ s; | |
237 | q = &h[i]; | |
238 | while (q->next && q->next != (m_link_s *) b) { | |
239 | q = q->next; | |
240 | } | |
241 | if (!q->next) { | |
242 | ((m_link_s *) a)->next = h[i].next; | |
243 | h[i].next = (m_link_s *) a; | |
244 | break; | |
245 | } | |
246 | q->next = q->next->next; | |
247 | a = a & b; | |
248 | s <<= 1; | |
249 | ++i; | |
250 | } | |
251 | } | |
252 | ||
253 | static DEFINE_SPINLOCK(ncr53c8xx_lock); | |
254 | ||
255 | static void *__m_calloc2(m_pool_s *mp, int size, char *name, int uflags) | |
256 | { | |
257 | void *p; | |
258 | ||
259 | p = ___m_alloc(mp, size); | |
260 | ||
261 | if (DEBUG_FLAGS & DEBUG_ALLOC) | |
262 | printk ("new %-10s[%4d] @%p.\n", name, size, p); | |
263 | ||
264 | if (p) | |
265 | memset(p, 0, size); | |
266 | else if (uflags & MEMO_WARN) | |
267 | printk (NAME53C8XX ": failed to allocate %s[%d]\n", name, size); | |
268 | ||
269 | return p; | |
270 | } | |
271 | ||
272 | #define __m_calloc(mp, s, n) __m_calloc2(mp, s, n, MEMO_WARN) | |
273 | ||
274 | static void __m_free(m_pool_s *mp, void *ptr, int size, char *name) | |
275 | { | |
276 | if (DEBUG_FLAGS & DEBUG_ALLOC) | |
277 | printk ("freeing %-10s[%4d] @%p.\n", name, size, ptr); | |
278 | ||
279 | ___m_free(mp, ptr, size); | |
280 | ||
281 | } | |
282 | ||
283 | /* | |
284 | * With pci bus iommu support, we use a default pool of unmapped memory | |
285 | * for memory we donnot need to DMA from/to and one pool per pcidev for | |
286 | * memory accessed by the PCI chip. `mp0' is the default not DMAable pool. | |
287 | */ | |
288 | ||
289 | static m_addr_t ___mp0_getp(m_pool_s *mp) | |
290 | { | |
291 | m_addr_t m = __get_free_pages(MEMO_GFP_FLAGS, MEMO_PAGE_ORDER); | |
292 | if (m) | |
293 | ++mp->nump; | |
294 | return m; | |
295 | } | |
296 | ||
297 | static void ___mp0_freep(m_pool_s *mp, m_addr_t m) | |
298 | { | |
299 | free_pages(m, MEMO_PAGE_ORDER); | |
300 | --mp->nump; | |
301 | } | |
302 | ||
303 | static m_pool_s mp0 = {NULL, ___mp0_getp, ___mp0_freep}; | |
304 | ||
305 | /* | |
306 | * DMAable pools. | |
307 | */ | |
308 | ||
309 | /* | |
310 | * With pci bus iommu support, we maintain one pool per pcidev and a | |
311 | * hashed reverse table for virtual to bus physical address translations. | |
312 | */ | |
313 | static m_addr_t ___dma_getp(m_pool_s *mp) | |
314 | { | |
315 | m_addr_t vp; | |
316 | m_vtob_s *vbp; | |
317 | ||
318 | vbp = __m_calloc(&mp0, sizeof(*vbp), "VTOB"); | |
319 | if (vbp) { | |
320 | dma_addr_t daddr; | |
321 | vp = (m_addr_t) dma_alloc_coherent(mp->bush, | |
322 | PAGE_SIZE<<MEMO_PAGE_ORDER, | |
323 | &daddr, GFP_ATOMIC); | |
324 | if (vp) { | |
325 | int hc = VTOB_HASH_CODE(vp); | |
326 | vbp->vaddr = vp; | |
327 | vbp->baddr = daddr; | |
328 | vbp->next = mp->vtob[hc]; | |
329 | mp->vtob[hc] = vbp; | |
330 | ++mp->nump; | |
331 | return vp; | |
332 | } | |
333 | } | |
334 | if (vbp) | |
335 | __m_free(&mp0, vbp, sizeof(*vbp), "VTOB"); | |
336 | return 0; | |
337 | } | |
338 | ||
339 | static void ___dma_freep(m_pool_s *mp, m_addr_t m) | |
340 | { | |
341 | m_vtob_s **vbpp, *vbp; | |
342 | int hc = VTOB_HASH_CODE(m); | |
343 | ||
344 | vbpp = &mp->vtob[hc]; | |
345 | while (*vbpp && (*vbpp)->vaddr != m) | |
346 | vbpp = &(*vbpp)->next; | |
347 | if (*vbpp) { | |
348 | vbp = *vbpp; | |
349 | *vbpp = (*vbpp)->next; | |
350 | dma_free_coherent(mp->bush, PAGE_SIZE<<MEMO_PAGE_ORDER, | |
351 | (void *)vbp->vaddr, (dma_addr_t)vbp->baddr); | |
352 | __m_free(&mp0, vbp, sizeof(*vbp), "VTOB"); | |
353 | --mp->nump; | |
354 | } | |
355 | } | |
356 | ||
357 | static inline m_pool_s *___get_dma_pool(m_bush_t bush) | |
358 | { | |
359 | m_pool_s *mp; | |
360 | for (mp = mp0.next; mp && mp->bush != bush; mp = mp->next); | |
361 | return mp; | |
362 | } | |
363 | ||
364 | static m_pool_s *___cre_dma_pool(m_bush_t bush) | |
365 | { | |
366 | m_pool_s *mp; | |
367 | mp = __m_calloc(&mp0, sizeof(*mp), "MPOOL"); | |
368 | if (mp) { | |
369 | memset(mp, 0, sizeof(*mp)); | |
370 | mp->bush = bush; | |
371 | mp->getp = ___dma_getp; | |
372 | mp->freep = ___dma_freep; | |
373 | mp->next = mp0.next; | |
374 | mp0.next = mp; | |
375 | } | |
376 | return mp; | |
377 | } | |
378 | ||
379 | static void ___del_dma_pool(m_pool_s *p) | |
380 | { | |
381 | struct m_pool **pp = &mp0.next; | |
382 | ||
383 | while (*pp && *pp != p) | |
384 | pp = &(*pp)->next; | |
385 | if (*pp) { | |
386 | *pp = (*pp)->next; | |
387 | __m_free(&mp0, p, sizeof(*p), "MPOOL"); | |
388 | } | |
389 | } | |
390 | ||
391 | static void *__m_calloc_dma(m_bush_t bush, int size, char *name) | |
392 | { | |
393 | u_long flags; | |
394 | struct m_pool *mp; | |
395 | void *m = NULL; | |
396 | ||
397 | spin_lock_irqsave(&ncr53c8xx_lock, flags); | |
398 | mp = ___get_dma_pool(bush); | |
399 | if (!mp) | |
400 | mp = ___cre_dma_pool(bush); | |
401 | if (mp) | |
402 | m = __m_calloc(mp, size, name); | |
403 | if (mp && !mp->nump) | |
404 | ___del_dma_pool(mp); | |
405 | spin_unlock_irqrestore(&ncr53c8xx_lock, flags); | |
406 | ||
407 | return m; | |
408 | } | |
409 | ||
410 | static void __m_free_dma(m_bush_t bush, void *m, int size, char *name) | |
411 | { | |
412 | u_long flags; | |
413 | struct m_pool *mp; | |
414 | ||
415 | spin_lock_irqsave(&ncr53c8xx_lock, flags); | |
416 | mp = ___get_dma_pool(bush); | |
417 | if (mp) | |
418 | __m_free(mp, m, size, name); | |
419 | if (mp && !mp->nump) | |
420 | ___del_dma_pool(mp); | |
421 | spin_unlock_irqrestore(&ncr53c8xx_lock, flags); | |
422 | } | |
423 | ||
424 | static m_addr_t __vtobus(m_bush_t bush, void *m) | |
425 | { | |
426 | u_long flags; | |
427 | m_pool_s *mp; | |
428 | int hc = VTOB_HASH_CODE(m); | |
429 | m_vtob_s *vp = NULL; | |
430 | m_addr_t a = ((m_addr_t) m) & ~MEMO_CLUSTER_MASK; | |
431 | ||
432 | spin_lock_irqsave(&ncr53c8xx_lock, flags); | |
433 | mp = ___get_dma_pool(bush); | |
434 | if (mp) { | |
435 | vp = mp->vtob[hc]; | |
436 | while (vp && (m_addr_t) vp->vaddr != a) | |
437 | vp = vp->next; | |
438 | } | |
439 | spin_unlock_irqrestore(&ncr53c8xx_lock, flags); | |
440 | return vp ? vp->baddr + (((m_addr_t) m) - a) : 0; | |
441 | } | |
442 | ||
443 | #define _m_calloc_dma(np, s, n) __m_calloc_dma(np->dev, s, n) | |
444 | #define _m_free_dma(np, p, s, n) __m_free_dma(np->dev, p, s, n) | |
445 | #define m_calloc_dma(s, n) _m_calloc_dma(np, s, n) | |
446 | #define m_free_dma(p, s, n) _m_free_dma(np, p, s, n) | |
447 | #define _vtobus(np, p) __vtobus(np->dev, p) | |
448 | #define vtobus(p) _vtobus(np, p) | |
449 | ||
450 | /* | |
451 | * Deal with DMA mapping/unmapping. | |
452 | */ | |
453 | ||
454 | /* To keep track of the dma mapping (sg/single) that has been set */ | |
455 | #define __data_mapped SCp.phase | |
456 | #define __data_mapping SCp.have_data_in | |
457 | ||
458 | static void __unmap_scsi_data(struct device *dev, struct scsi_cmnd *cmd) | |
459 | { | |
460 | switch(cmd->__data_mapped) { | |
461 | case 2: | |
462 | dma_unmap_sg(dev, cmd->buffer, cmd->use_sg, | |
463 | cmd->sc_data_direction); | |
464 | break; | |
465 | case 1: | |
466 | dma_unmap_single(dev, cmd->__data_mapping, | |
467 | cmd->request_bufflen, | |
468 | cmd->sc_data_direction); | |
469 | break; | |
470 | } | |
471 | cmd->__data_mapped = 0; | |
472 | } | |
473 | ||
474 | static u_long __map_scsi_single_data(struct device *dev, struct scsi_cmnd *cmd) | |
475 | { | |
476 | dma_addr_t mapping; | |
477 | ||
478 | if (cmd->request_bufflen == 0) | |
479 | return 0; | |
480 | ||
481 | mapping = dma_map_single(dev, cmd->request_buffer, | |
482 | cmd->request_bufflen, | |
483 | cmd->sc_data_direction); | |
484 | cmd->__data_mapped = 1; | |
485 | cmd->__data_mapping = mapping; | |
486 | ||
487 | return mapping; | |
488 | } | |
489 | ||
490 | static int __map_scsi_sg_data(struct device *dev, struct scsi_cmnd *cmd) | |
491 | { | |
492 | int use_sg; | |
493 | ||
494 | if (cmd->use_sg == 0) | |
495 | return 0; | |
496 | ||
497 | use_sg = dma_map_sg(dev, cmd->buffer, cmd->use_sg, | |
498 | cmd->sc_data_direction); | |
499 | cmd->__data_mapped = 2; | |
500 | cmd->__data_mapping = use_sg; | |
501 | ||
502 | return use_sg; | |
503 | } | |
504 | ||
505 | #define unmap_scsi_data(np, cmd) __unmap_scsi_data(np->dev, cmd) | |
506 | #define map_scsi_single_data(np, cmd) __map_scsi_single_data(np->dev, cmd) | |
507 | #define map_scsi_sg_data(np, cmd) __map_scsi_sg_data(np->dev, cmd) | |
508 | ||
509 | /*========================================================== | |
510 | ** | |
511 | ** Driver setup. | |
512 | ** | |
513 | ** This structure is initialized from linux config | |
514 | ** options. It can be overridden at boot-up by the boot | |
515 | ** command line. | |
516 | ** | |
517 | **========================================================== | |
518 | */ | |
519 | static struct ncr_driver_setup | |
520 | driver_setup = SCSI_NCR_DRIVER_SETUP; | |
521 | ||
522 | #ifdef SCSI_NCR_BOOT_COMMAND_LINE_SUPPORT | |
523 | static struct ncr_driver_setup | |
524 | driver_safe_setup __initdata = SCSI_NCR_DRIVER_SAFE_SETUP; | |
525 | #endif | |
526 | ||
527 | #define initverbose (driver_setup.verbose) | |
528 | #define bootverbose (np->verbose) | |
529 | ||
530 | ||
531 | /*=================================================================== | |
532 | ** | |
533 | ** Driver setup from the boot command line | |
534 | ** | |
535 | **=================================================================== | |
536 | */ | |
537 | ||
538 | #ifdef MODULE | |
539 | #define ARG_SEP ' ' | |
540 | #else | |
541 | #define ARG_SEP ',' | |
542 | #endif | |
543 | ||
544 | #define OPT_TAGS 1 | |
545 | #define OPT_MASTER_PARITY 2 | |
546 | #define OPT_SCSI_PARITY 3 | |
547 | #define OPT_DISCONNECTION 4 | |
548 | #define OPT_SPECIAL_FEATURES 5 | |
549 | #define OPT_UNUSED_1 6 | |
550 | #define OPT_FORCE_SYNC_NEGO 7 | |
551 | #define OPT_REVERSE_PROBE 8 | |
552 | #define OPT_DEFAULT_SYNC 9 | |
553 | #define OPT_VERBOSE 10 | |
554 | #define OPT_DEBUG 11 | |
555 | #define OPT_BURST_MAX 12 | |
556 | #define OPT_LED_PIN 13 | |
557 | #define OPT_MAX_WIDE 14 | |
558 | #define OPT_SETTLE_DELAY 15 | |
559 | #define OPT_DIFF_SUPPORT 16 | |
560 | #define OPT_IRQM 17 | |
561 | #define OPT_PCI_FIX_UP 18 | |
562 | #define OPT_BUS_CHECK 19 | |
563 | #define OPT_OPTIMIZE 20 | |
564 | #define OPT_RECOVERY 21 | |
565 | #define OPT_SAFE_SETUP 22 | |
566 | #define OPT_USE_NVRAM 23 | |
567 | #define OPT_EXCLUDE 24 | |
568 | #define OPT_HOST_ID 25 | |
569 | ||
570 | #ifdef SCSI_NCR_IARB_SUPPORT | |
571 | #define OPT_IARB 26 | |
572 | #endif | |
573 | ||
574 | static char setup_token[] __initdata = | |
575 | "tags:" "mpar:" | |
576 | "spar:" "disc:" | |
577 | "specf:" "ultra:" | |
578 | "fsn:" "revprob:" | |
579 | "sync:" "verb:" | |
580 | "debug:" "burst:" | |
581 | "led:" "wide:" | |
582 | "settle:" "diff:" | |
583 | "irqm:" "pcifix:" | |
584 | "buschk:" "optim:" | |
585 | "recovery:" | |
586 | "safe:" "nvram:" | |
587 | "excl:" "hostid:" | |
588 | #ifdef SCSI_NCR_IARB_SUPPORT | |
589 | "iarb:" | |
590 | #endif | |
591 | ; /* DONNOT REMOVE THIS ';' */ | |
592 | ||
593 | #ifdef MODULE | |
594 | #define ARG_SEP ' ' | |
595 | #else | |
596 | #define ARG_SEP ',' | |
597 | #endif | |
598 | ||
599 | static int __init get_setup_token(char *p) | |
600 | { | |
601 | char *cur = setup_token; | |
602 | char *pc; | |
603 | int i = 0; | |
604 | ||
605 | while (cur != NULL && (pc = strchr(cur, ':')) != NULL) { | |
606 | ++pc; | |
607 | ++i; | |
608 | if (!strncmp(p, cur, pc - cur)) | |
609 | return i; | |
610 | cur = pc; | |
611 | } | |
612 | return 0; | |
613 | } | |
614 | ||
615 | ||
616 | static int __init sym53c8xx__setup(char *str) | |
617 | { | |
618 | #ifdef SCSI_NCR_BOOT_COMMAND_LINE_SUPPORT | |
619 | char *cur = str; | |
620 | char *pc, *pv; | |
621 | int i, val, c; | |
622 | int xi = 0; | |
623 | ||
624 | while (cur != NULL && (pc = strchr(cur, ':')) != NULL) { | |
625 | char *pe; | |
626 | ||
627 | val = 0; | |
628 | pv = pc; | |
629 | c = *++pv; | |
630 | ||
631 | if (c == 'n') | |
632 | val = 0; | |
633 | else if (c == 'y') | |
634 | val = 1; | |
635 | else | |
636 | val = (int) simple_strtoul(pv, &pe, 0); | |
637 | ||
638 | switch (get_setup_token(cur)) { | |
639 | case OPT_TAGS: | |
640 | driver_setup.default_tags = val; | |
641 | if (pe && *pe == '/') { | |
642 | i = 0; | |
643 | while (*pe && *pe != ARG_SEP && | |
644 | i < sizeof(driver_setup.tag_ctrl)-1) { | |
645 | driver_setup.tag_ctrl[i++] = *pe++; | |
646 | } | |
647 | driver_setup.tag_ctrl[i] = '\0'; | |
648 | } | |
649 | break; | |
650 | case OPT_MASTER_PARITY: | |
651 | driver_setup.master_parity = val; | |
652 | break; | |
653 | case OPT_SCSI_PARITY: | |
654 | driver_setup.scsi_parity = val; | |
655 | break; | |
656 | case OPT_DISCONNECTION: | |
657 | driver_setup.disconnection = val; | |
658 | break; | |
659 | case OPT_SPECIAL_FEATURES: | |
660 | driver_setup.special_features = val; | |
661 | break; | |
662 | case OPT_FORCE_SYNC_NEGO: | |
663 | driver_setup.force_sync_nego = val; | |
664 | break; | |
665 | case OPT_REVERSE_PROBE: | |
666 | driver_setup.reverse_probe = val; | |
667 | break; | |
668 | case OPT_DEFAULT_SYNC: | |
669 | driver_setup.default_sync = val; | |
670 | break; | |
671 | case OPT_VERBOSE: | |
672 | driver_setup.verbose = val; | |
673 | break; | |
674 | case OPT_DEBUG: | |
675 | driver_setup.debug = val; | |
676 | break; | |
677 | case OPT_BURST_MAX: | |
678 | driver_setup.burst_max = val; | |
679 | break; | |
680 | case OPT_LED_PIN: | |
681 | driver_setup.led_pin = val; | |
682 | break; | |
683 | case OPT_MAX_WIDE: | |
684 | driver_setup.max_wide = val? 1:0; | |
685 | break; | |
686 | case OPT_SETTLE_DELAY: | |
687 | driver_setup.settle_delay = val; | |
688 | break; | |
689 | case OPT_DIFF_SUPPORT: | |
690 | driver_setup.diff_support = val; | |
691 | break; | |
692 | case OPT_IRQM: | |
693 | driver_setup.irqm = val; | |
694 | break; | |
695 | case OPT_PCI_FIX_UP: | |
696 | driver_setup.pci_fix_up = val; | |
697 | break; | |
698 | case OPT_BUS_CHECK: | |
699 | driver_setup.bus_check = val; | |
700 | break; | |
701 | case OPT_OPTIMIZE: | |
702 | driver_setup.optimize = val; | |
703 | break; | |
704 | case OPT_RECOVERY: | |
705 | driver_setup.recovery = val; | |
706 | break; | |
707 | case OPT_USE_NVRAM: | |
708 | driver_setup.use_nvram = val; | |
709 | break; | |
710 | case OPT_SAFE_SETUP: | |
711 | memcpy(&driver_setup, &driver_safe_setup, | |
712 | sizeof(driver_setup)); | |
713 | break; | |
714 | case OPT_EXCLUDE: | |
715 | if (xi < SCSI_NCR_MAX_EXCLUDES) | |
716 | driver_setup.excludes[xi++] = val; | |
717 | break; | |
718 | case OPT_HOST_ID: | |
719 | driver_setup.host_id = val; | |
720 | break; | |
721 | #ifdef SCSI_NCR_IARB_SUPPORT | |
722 | case OPT_IARB: | |
723 | driver_setup.iarb = val; | |
724 | break; | |
725 | #endif | |
726 | default: | |
727 | printk("sym53c8xx_setup: unexpected boot option '%.*s' ignored\n", (int)(pc-cur+1), cur); | |
728 | break; | |
729 | } | |
730 | ||
731 | if ((cur = strchr(cur, ARG_SEP)) != NULL) | |
732 | ++cur; | |
733 | } | |
734 | #endif /* SCSI_NCR_BOOT_COMMAND_LINE_SUPPORT */ | |
735 | return 1; | |
736 | } | |
737 | ||
738 | /*=================================================================== | |
739 | ** | |
740 | ** Get device queue depth from boot command line. | |
741 | ** | |
742 | **=================================================================== | |
743 | */ | |
744 | #define DEF_DEPTH (driver_setup.default_tags) | |
745 | #define ALL_TARGETS -2 | |
746 | #define NO_TARGET -1 | |
747 | #define ALL_LUNS -2 | |
748 | #define NO_LUN -1 | |
749 | ||
750 | static int device_queue_depth(int unit, int target, int lun) | |
751 | { | |
752 | int c, h, t, u, v; | |
753 | char *p = driver_setup.tag_ctrl; | |
754 | char *ep; | |
755 | ||
756 | h = -1; | |
757 | t = NO_TARGET; | |
758 | u = NO_LUN; | |
759 | while ((c = *p++) != 0) { | |
760 | v = simple_strtoul(p, &ep, 0); | |
761 | switch(c) { | |
762 | case '/': | |
763 | ++h; | |
764 | t = ALL_TARGETS; | |
765 | u = ALL_LUNS; | |
766 | break; | |
767 | case 't': | |
768 | if (t != target) | |
769 | t = (target == v) ? v : NO_TARGET; | |
770 | u = ALL_LUNS; | |
771 | break; | |
772 | case 'u': | |
773 | if (u != lun) | |
774 | u = (lun == v) ? v : NO_LUN; | |
775 | break; | |
776 | case 'q': | |
777 | if (h == unit && | |
778 | (t == ALL_TARGETS || t == target) && | |
779 | (u == ALL_LUNS || u == lun)) | |
780 | return v; | |
781 | break; | |
782 | case '-': | |
783 | t = ALL_TARGETS; | |
784 | u = ALL_LUNS; | |
785 | break; | |
786 | default: | |
787 | break; | |
788 | } | |
789 | p = ep; | |
790 | } | |
791 | return DEF_DEPTH; | |
792 | } |