![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sym53c8xx_comm.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / linux / src / drivers / scsi|
Return to sym53c8xx_comm.h CVS log | Up to [GnuMach] / Gnu-Mach / linux / src / drivers / scsi |
1.1 root 1: /******************************************************************************
2: ** High Performance device driver for the Symbios 53C896 controller.
3: **
4: ** Copyright (C) 1998-2000 Gerard Roudier <[email protected]>
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 <[email protected]>
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 <[email protected]>
44: ** Stefan Esser <[email protected]>
45: **
46: **-----------------------------------------------------------------------------
47: **
48: ** Major contributions:
49: ** --------------------
50: **
51: ** NVRAM detection and reading.
52: ** Copyright (C) 1997 Richard Waltham <[email protected]>
53: **
54: *******************************************************************************
55: */
56:
57: /*
58: ** This file contains definitions and code that the
59: ** sym53c8xx and ncr53c8xx drivers should share.
60: ** The sharing will be achieved in a further version
61: ** of the driver bundle. For now, only the ncr53c8xx
62: ** driver includes this file.
63: */
64:
65: #define MIN(a,b) (((a) < (b)) ? (a) : (b))
66: #define MAX(a,b) (((a) > (b)) ? (a) : (b))
67:
68: /*==========================================================
69: **
70: ** Hmmm... What complex some PCI-HOST bridges actually
71: ** are, despite the fact that the PCI specifications
72: ** are looking so smart and simple! ;-)
73: **
74: **==========================================================
75: */
76:
77: #if LINUX_VERSION_CODE >= LinuxVersionCode(2,3,47)
78: #define SCSI_NCR_DYNAMIC_DMA_MAPPING
79: #endif
80:
81: /*==========================================================
82: **
83: ** Miscallaneous defines.
84: **
85: **==========================================================
86: */
87:
88: #define u_char unsigned char
89: #define u_short unsigned short
90: #define u_int unsigned int
91: #define u_long unsigned long
92:
93: #ifndef bcopy
94: #define bcopy(s, d, n) memcpy((d), (s), (n))
95: #endif
96:
97: #ifndef bcmp
98: #define bcmp(s, d, n) memcmp((d), (s), (n))
99: #endif
100:
101: #ifndef bzero
102: #define bzero(d, n) memset((d), 0, (n))
103: #endif
104:
105: #ifndef offsetof
106: #define offsetof(t, m) ((size_t) (&((t *)0)->m))
107: #endif
108:
109: /*==========================================================
110: **
111: ** assert ()
112: **
113: **==========================================================
114: **
115: ** modified copy from 386bsd:/usr/include/sys/assert.h
116: **
117: **----------------------------------------------------------
118: */
119:
120: #define assert(expression) { \
121: if (!(expression)) { \
122: (void)panic( \
123: "assertion \"%s\" failed: file \"%s\", line %d\n", \
124: #expression, \
125: __FILE__, __LINE__); \
126: } \
127: }
128:
129: /*==========================================================
130: **
131: ** Debugging tags
132: **
133: **==========================================================
134: */
135:
136: #define DEBUG_ALLOC (0x0001)
137: #define DEBUG_PHASE (0x0002)
138: #define DEBUG_QUEUE (0x0008)
139: #define DEBUG_RESULT (0x0010)
140: #define DEBUG_POINTER (0x0020)
141: #define DEBUG_SCRIPT (0x0040)
142: #define DEBUG_TINY (0x0080)
143: #define DEBUG_TIMING (0x0100)
144: #define DEBUG_NEGO (0x0200)
145: #define DEBUG_TAGS (0x0400)
146: #define DEBUG_SCATTER (0x0800)
147: #define DEBUG_IC (0x1000)
148:
149: /*
150: ** Enable/Disable debug messages.
151: ** Can be changed at runtime too.
152: */
153:
154: #ifdef SCSI_NCR_DEBUG_INFO_SUPPORT
155: static int ncr_debug = SCSI_NCR_DEBUG_FLAGS;
156: #define DEBUG_FLAGS ncr_debug
157: #else
158: #define DEBUG_FLAGS SCSI_NCR_DEBUG_FLAGS
159: #endif
160:
161: /*==========================================================
162: **
163: ** A la VMS/CAM-3 queue management.
164: ** Implemented from linux list management.
165: **
166: **==========================================================
167: */
168:
169: typedef struct xpt_quehead {
170: struct xpt_quehead *flink; /* Forward pointer */
171: struct xpt_quehead *blink; /* Backward pointer */
172: } XPT_QUEHEAD;
173:
174: #define xpt_que_init(ptr) do { \
175: (ptr)->flink = (ptr); (ptr)->blink = (ptr); \
176: } while (0)
177:
178: static inline void __xpt_que_add(struct xpt_quehead * new,
179: struct xpt_quehead * blink,
180: struct xpt_quehead * flink)
181: {
182: flink->blink = new;
183: new->flink = flink;
184: new->blink = blink;
185: blink->flink = new;
186: }
187:
188: static inline void __xpt_que_del(struct xpt_quehead * blink,
189: struct xpt_quehead * flink)
190: {
191: flink->blink = blink;
192: blink->flink = flink;
193: }
194:
195: static inline int xpt_que_empty(struct xpt_quehead *head)
196: {
197: return head->flink == head;
198: }
199:
200: static inline void xpt_que_splice(struct xpt_quehead *list,
201: struct xpt_quehead *head)
202: {
203: struct xpt_quehead *first = list->flink;
204:
205: if (first != list) {
206: struct xpt_quehead *last = list->blink;
207: struct xpt_quehead *at = head->flink;
208:
209: first->blink = head;
210: head->flink = first;
211:
212: last->flink = at;
213: at->blink = last;
214: }
215: }
216:
217: #define xpt_que_entry(ptr, type, member) \
218: ((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member)))
219:
220:
221: #define xpt_insque(new, pos) __xpt_que_add(new, pos, (pos)->flink)
222:
223: #define xpt_remque(el) __xpt_que_del((el)->blink, (el)->flink)
224:
225: #define xpt_insque_head(new, head) __xpt_que_add(new, head, (head)->flink)
226:
227: static inline struct xpt_quehead *xpt_remque_head(struct xpt_quehead *head)
228: {
229: struct xpt_quehead *elem = head->flink;
230:
231: if (elem != head)
232: __xpt_que_del(head, elem->flink);
233: else
234: elem = 0;
235: return elem;
236: }
237:
238: #define xpt_insque_tail(new, head) __xpt_que_add(new, (head)->blink, head)
239:
240: static inline struct xpt_quehead *xpt_remque_tail(struct xpt_quehead *head)
241: {
242: struct xpt_quehead *elem = head->blink;
243:
244: if (elem != head)
245: __xpt_que_del(elem->blink, head);
246: else
247: elem = 0;
248: return elem;
249: }
250:
251: /*==========================================================
252: **
253: ** Simple Wrapper to kernel PCI bus interface.
254: **
255: ** This wrapper allows to get rid of old kernel PCI
256: ** interface and still allows to preserve linux-2.0
257: ** compatibilty. In fact, it is mostly an incomplete
258: ** emulation of the new PCI code for pre-2.2 kernels.
259: ** When kernel-2.0 support will be dropped, we will
260: ** just have to remove most of this code.
261: **
262: **==========================================================
263: */
264:
265: #if LINUX_VERSION_CODE >= LinuxVersionCode(2,2,0)
266:
267: typedef struct pci_dev *pcidev_t;
268: #define PCIDEV_NULL (0)
269: #define PciBusNumber(d) (d)->bus->number
270: #define PciDeviceFn(d) (d)->devfn
271: #define PciVendorId(d) (d)->vendor
272: #define PciDeviceId(d) (d)->device
273: #define PciIrqLine(d) (d)->irq
274:
275: #if LINUX_VERSION_CODE > LinuxVersionCode(2,3,12)
276:
277: static int __init
278: pci_get_base_address(struct pci_dev *pdev, int index, u_long *base)
279: {
280: *base = pdev->resource[index].start;
281: if ((pdev->resource[index].flags & 0x7) == 0x4)
282: ++index;
283: return ++index;
284: }
285: #else
286: static int __init
287: pci_get_base_address(struct pci_dev *pdev, int index, u_long *base)
288: {
289: *base = pdev->base_address[index++];
290: if ((*base & 0x7) == 0x4) {
291: #if BITS_PER_LONG > 32
292: *base |= (((u_long)pdev->base_address[index]) << 32);
293: #endif
294: ++index;
295: }
296: return index;
297: }
298: #endif
299:
300: #else /* Incomplete emulation of current PCI code for pre-2.2 kernels */
301:
302: typedef unsigned int pcidev_t;
303: #define PCIDEV_NULL (~0u)
304: #define PciBusNumber(d) ((d)>>8)
305: #define PciDeviceFn(d) ((d)&0xff)
306: #define __PciDev(busn, devfn) (((busn)<<8)+(devfn))
307:
308: #define pci_present pcibios_present
309:
310: #define pci_read_config_byte(d, w, v) \
311: pcibios_read_config_byte(PciBusNumber(d), PciDeviceFn(d), w, v)
312: #define pci_read_config_word(d, w, v) \
313: pcibios_read_config_word(PciBusNumber(d), PciDeviceFn(d), w, v)
314: #define pci_read_config_dword(d, w, v) \
315: pcibios_read_config_dword(PciBusNumber(d), PciDeviceFn(d), w, v)
316:
317: #define pci_write_config_byte(d, w, v) \
318: pcibios_write_config_byte(PciBusNumber(d), PciDeviceFn(d), w, v)
319: #define pci_write_config_word(d, w, v) \
320: pcibios_write_config_word(PciBusNumber(d), PciDeviceFn(d), w, v)
321: #define pci_write_config_dword(d, w, v) \
322: pcibios_write_config_dword(PciBusNumber(d), PciDeviceFn(d), w, v)
323:
324: static pcidev_t __init
325: pci_find_device(unsigned int vendor, unsigned int device, pcidev_t prev)
326: {
327: static unsigned short pci_index;
328: int retv;
329: unsigned char bus_number, device_fn;
330:
331: if (prev == PCIDEV_NULL)
332: pci_index = 0;
333: else
334: ++pci_index;
335: retv = pcibios_find_device (vendor, device, pci_index,
336: &bus_number, &device_fn);
337: return retv ? PCIDEV_NULL : __PciDev(bus_number, device_fn);
338: }
339:
340: static u_short __init PciVendorId(pcidev_t dev)
341: {
342: u_short vendor_id;
343: pci_read_config_word(dev, PCI_VENDOR_ID, &vendor_id);
344: return vendor_id;
345: }
346:
347: static u_short __init PciDeviceId(pcidev_t dev)
348: {
349: u_short device_id;
350: pci_read_config_word(dev, PCI_DEVICE_ID, &device_id);
351: return device_id;
352: }
353:
354: static u_int __init PciIrqLine(pcidev_t dev)
355: {
356: u_char irq;
357: pci_read_config_byte(dev, PCI_INTERRUPT_LINE, &irq);
358: return irq;
359: }
360:
361: static int __init
362: pci_get_base_address(pcidev_t dev, int offset, u_long *base)
363: {
364: u_int32 tmp;
365:
366: pci_read_config_dword(dev, PCI_BASE_ADDRESS_0 + offset, &tmp);
367: *base = tmp;
368: offset += sizeof(u_int32);
369: if ((tmp & 0x7) == 0x4) {
370: #if BITS_PER_LONG > 32
371: pci_read_config_dword(dev, PCI_BASE_ADDRESS_0 + offset, &tmp);
372: *base |= (((u_long)tmp) << 32);
373: #endif
374: offset += sizeof(u_int32);
375: }
376: return offset;
377: }
378:
379: #endif /* LINUX_VERSION_CODE >= LinuxVersionCode(2,2,0) */
380:
381: /*==========================================================
382: **
383: ** SMP threading.
384: **
385: ** Assuming that SMP systems are generally high end
386: ** systems and may use several SCSI adapters, we are
387: ** using one lock per controller instead of some global
388: ** one. For the moment (linux-2.1.95), driver's entry
389: ** points are called with the 'io_request_lock' lock
390: ** held, so:
391: ** - We are uselessly loosing a couple of micro-seconds
392: ** to lock the controller data structure.
393: ** - But the driver is not broken by design for SMP and
394: ** so can be more resistant to bugs or bad changes in
395: ** the IO sub-system code.
396: ** - A small advantage could be that the interrupt code
397: ** is grained as wished (e.g.: by controller).
398: **
399: **==========================================================
400: */
401:
402: #if LINUX_VERSION_CODE >= LinuxVersionCode(2,1,93)
403: spinlock_t DRIVER_SMP_LOCK = SPIN_LOCK_UNLOCKED;
404: #define NCR_LOCK_DRIVER(flags) spin_lock_irqsave(&DRIVER_SMP_LOCK, flags)
405: #define NCR_UNLOCK_DRIVER(flags) \
406: spin_unlock_irqrestore(&DRIVER_SMP_LOCK, flags)
407:
408: #define NCR_INIT_LOCK_NCB(np) spin_lock_init(&np->smp_lock)
409: #define NCR_LOCK_NCB(np, flags) spin_lock_irqsave(&np->smp_lock, flags)
410: #define NCR_UNLOCK_NCB(np, flags) spin_unlock_irqrestore(&np->smp_lock, flags)
411:
412: #define NCR_LOCK_SCSI_DONE(np, flags) \
413: spin_lock_irqsave(&io_request_lock, flags)
414: #define NCR_UNLOCK_SCSI_DONE(np, flags) \
415: spin_unlock_irqrestore(&io_request_lock, flags)
416:
417: #else
418:
419: #define NCR_LOCK_DRIVER(flags) do { save_flags(flags); cli(); } while (0)
420: #define NCR_UNLOCK_DRIVER(flags) do { restore_flags(flags); } while (0)
421:
422: #define NCR_INIT_LOCK_NCB(np) do { } while (0)
423: #define NCR_LOCK_NCB(np, flags) do { save_flags(flags); cli(); } while (0)
424: #define NCR_UNLOCK_NCB(np, flags) do { restore_flags(flags); } while (0)
425:
426: #define NCR_LOCK_SCSI_DONE(np, flags) do {;} while (0)
427: #define NCR_UNLOCK_SCSI_DONE(np, flags) do {;} while (0)
428:
429: #endif
430:
431: /*==========================================================
432: **
433: ** Memory mapped IO
434: **
435: ** Since linux-2.1, we must use ioremap() to map the io
436: ** memory space and iounmap() to unmap it. This allows
437: ** portability. Linux 1.3.X and 2.0.X allow to remap
438: ** physical pages addresses greater than the highest
439: ** physical memory address to kernel virtual pages with
440: ** vremap() / vfree(). That was not portable but worked
441: ** with i386 architecture.
442: **
443: **==========================================================
444: */
445:
446: #if LINUX_VERSION_CODE < LinuxVersionCode(2,1,0)
447: #define ioremap vremap
448: #define iounmap vfree
449: #endif
450:
451: #ifdef __sparc__
452: # include <asm/irq.h>
453: # define pcivtobus(p) bus_dvma_to_mem(p)
454: # define memcpy_to_pci(a, b, c) memcpy_toio((a), (b), (c))
455: #elif defined(__alpha__)
456: # define pcivtobus(p) ((p) & 0xfffffffful)
457: # define memcpy_to_pci(a, b, c) memcpy_toio((a), (b), (c))
458: #else /* others */
459: # define pcivtobus(p) (p)
460: # define memcpy_to_pci(a, b, c) memcpy_toio((a), (b), (c))
461: #endif
462:
463: #ifndef SCSI_NCR_PCI_MEM_NOT_SUPPORTED
464: static u_long __init remap_pci_mem(u_long base, u_long size)
465: {
466: u_long page_base = ((u_long) base) & PAGE_MASK;
467: u_long page_offs = ((u_long) base) - page_base;
468: u_long page_remapped = (u_long) ioremap(page_base, page_offs+size);
469:
470: return page_remapped? (page_remapped + page_offs) : 0UL;
471: }
472:
473: static void __init unmap_pci_mem(u_long vaddr, u_long size)
474: {
475: if (vaddr)
476: iounmap((void *) (vaddr & PAGE_MASK));
477: }
478:
479: #endif /* not def SCSI_NCR_PCI_MEM_NOT_SUPPORTED */
480:
481: /*==========================================================
482: **
483: ** Insert a delay in micro-seconds and milli-seconds.
484: **
485: ** Under Linux, udelay() is restricted to delay <
486: ** 1 milli-second. In fact, it generally works for up
487: ** to 1 second delay. Since 2.1.105, the mdelay() function
488: ** is provided for delays in milli-seconds.
489: ** Under 2.0 kernels, udelay() is an inline function
490: ** that is very inaccurate on Pentium processors.
491: **
492: **==========================================================
493: */
494:
495: #if LINUX_VERSION_CODE >= LinuxVersionCode(2,1,105)
496: #define UDELAY udelay
497: #define MDELAY mdelay
498: #else
499: static void UDELAY(long us) { udelay(us); }
500: static void MDELAY(long ms) { while (ms--) UDELAY(1000); }
501: #endif
502:
503: /*==========================================================
504: **
505: ** Simple power of two buddy-like allocator.
506: **
507: ** This simple code is not intended to be fast, but to
508: ** provide power of 2 aligned memory allocations.
509: ** Since the SCRIPTS processor only supplies 8 bit
510: ** arithmetic, this allocator allows simple and fast
511: ** address calculations from the SCRIPTS code.
512: ** In addition, cache line alignment is guaranteed for
513: ** power of 2 cache line size.
514: ** Enhanced in linux-2.3.44 to provide a memory pool
515: ** per pcidev to support dynamic dma mapping. (I would
516: ** have preferred a real bus astraction, btw).
517: **
518: **==========================================================
519: */
520:
521: #if LINUX_VERSION_CODE >= LinuxVersionCode(2,1,0)
522: #define __GetFreePages(flags, order) __get_free_pages(flags, order)
523: #else
524: #define __GetFreePages(flags, order) __get_free_pages(flags, order, 0)
525: #endif
526:
527: #define MEMO_SHIFT 4 /* 16 bytes minimum memory chunk */
528: #if PAGE_SIZE >= 8192
529: #define MEMO_PAGE_ORDER 0 /* 1 PAGE maximum */
530: #else
531: #define MEMO_PAGE_ORDER 1 /* 2 PAGES maximum */
532: #endif
533: #define MEMO_FREE_UNUSED /* Free unused pages immediately */
534: #define MEMO_WARN 1
535: #define MEMO_GFP_FLAGS GFP_ATOMIC
536: #define MEMO_CLUSTER_SHIFT (PAGE_SHIFT+MEMO_PAGE_ORDER)
537: #define MEMO_CLUSTER_SIZE (1UL << MEMO_CLUSTER_SHIFT)
538: #define MEMO_CLUSTER_MASK (MEMO_CLUSTER_SIZE-1)
539:
540: typedef u_long m_addr_t; /* Enough bits to bit-hack addresses */
541: typedef pcidev_t m_bush_t; /* Something that addresses DMAable */
542:
543: typedef struct m_link { /* Link between free memory chunks */
544: struct m_link *next;
545: } m_link_s;
546:
547: #ifdef SCSI_NCR_DYNAMIC_DMA_MAPPING
548: typedef struct m_vtob { /* Virtual to Bus address translation */
549: struct m_vtob *next;
550: m_addr_t vaddr;
551: m_addr_t baddr;
552: } m_vtob_s;
553: #define VTOB_HASH_SHIFT 5
554: #define VTOB_HASH_SIZE (1UL << VTOB_HASH_SHIFT)
555: #define VTOB_HASH_MASK (VTOB_HASH_SIZE-1)
556: #define VTOB_HASH_CODE(m) \
557: ((((m_addr_t) (m)) >> MEMO_CLUSTER_SHIFT) & VTOB_HASH_MASK)
558: #endif
559:
560: typedef struct m_pool { /* Memory pool of a given kind */
561: #ifdef SCSI_NCR_DYNAMIC_DMA_MAPPING
562: m_bush_t bush;
563: m_addr_t (*getp)(struct m_pool *);
564: void (*freep)(struct m_pool *, m_addr_t);
565: #define M_GETP() mp->getp(mp)
566: #define M_FREEP(p) mp->freep(mp, p)
567: #define GetPages() __GetFreePages(MEMO_GFP_FLAGS, MEMO_PAGE_ORDER)
568: #define FreePages(p) free_pages(p, MEMO_PAGE_ORDER)
569: int nump;
570: m_vtob_s *(vtob[VTOB_HASH_SIZE]);
571: struct m_pool *next;
572: #else
573: #define M_GETP() __GetFreePages(MEMO_GFP_FLAGS, MEMO_PAGE_ORDER)
574: #define M_FREEP(p) free_pages(p, MEMO_PAGE_ORDER)
575: #endif /* SCSI_NCR_DYNAMIC_DMA_MAPPING */
576: struct m_link h[PAGE_SHIFT-MEMO_SHIFT+MEMO_PAGE_ORDER+1];
577: } m_pool_s;
578:
579: static void *___m_alloc(m_pool_s *mp, int size)
580: {
581: int i = 0;
582: int s = (1 << MEMO_SHIFT);
583: int j;
584: m_addr_t a;
585: m_link_s *h = mp->h;
586:
587: if (size > (PAGE_SIZE << MEMO_PAGE_ORDER))
588: return 0;
589:
590: while (size > s) {
591: s <<= 1;
592: ++i;
593: }
594:
595: j = i;
596: while (!h[j].next) {
597: if (s == (PAGE_SIZE << MEMO_PAGE_ORDER)) {
598: h[j].next = (m_link_s *) M_GETP();
599: if (h[j].next)
600: h[j].next->next = 0;
601: break;
602: }
603: ++j;
604: s <<= 1;
605: }
606: a = (m_addr_t) h[j].next;
607: if (a) {
608: h[j].next = h[j].next->next;
609: while (j > i) {
610: j -= 1;
611: s >>= 1;
612: h[j].next = (m_link_s *) (a+s);
613: h[j].next->next = 0;
614: }
615: }
616: #ifdef DEBUG
617: printk("___m_alloc(%d) = %p\n", size, (void *) a);
618: #endif
619: return (void *) a;
620: }
621:
622: static void ___m_free(m_pool_s *mp, void *ptr, int size)
623: {
624: int i = 0;
625: int s = (1 << MEMO_SHIFT);
626: m_link_s *q;
627: m_addr_t a, b;
628: m_link_s *h = mp->h;
629:
630: #ifdef DEBUG
631: printk("___m_free(%p, %d)\n", ptr, size);
632: #endif
633:
634: if (size > (PAGE_SIZE << MEMO_PAGE_ORDER))
635: return;
636:
637: while (size > s) {
638: s <<= 1;
639: ++i;
640: }
641:
642: a = (m_addr_t) ptr;
643:
644: while (1) {
645: #ifdef MEMO_FREE_UNUSED
646: if (s == (PAGE_SIZE << MEMO_PAGE_ORDER)) {
647: M_FREEP(a);
648: break;
649: }
650: #endif
651: b = a ^ s;
652: q = &h[i];
653: while (q->next && q->next != (m_link_s *) b) {
654: q = q->next;
655: }
656: if (!q->next) {
657: ((m_link_s *) a)->next = h[i].next;
658: h[i].next = (m_link_s *) a;
659: break;
660: }
661: q->next = q->next->next;
662: a = a & b;
663: s <<= 1;
664: ++i;
665: }
666: }
667:
668: static void *__m_calloc2(m_pool_s *mp, int size, char *name, int uflags)
669: {
670: void *p;
671:
672: p = ___m_alloc(mp, size);
673:
674: if (DEBUG_FLAGS & DEBUG_ALLOC)
675: printk ("new %-10s[%4d] @%p.\n", name, size, p);
676:
677: if (p)
678: bzero(p, size);
679: else if (uflags & MEMO_WARN)
680: printk (NAME53C8XX ": failed to allocate %s[%d]\n", name, size);
681:
682: return p;
683: }
684:
685: #define __m_calloc(mp, s, n) __m_calloc2(mp, s, n, MEMO_WARN)
686:
687: static void __m_free(m_pool_s *mp, void *ptr, int size, char *name)
688: {
689: if (DEBUG_FLAGS & DEBUG_ALLOC)
690: printk ("freeing %-10s[%4d] @%p.\n", name, size, ptr);
691:
692: ___m_free(mp, ptr, size);
693:
694: }
695:
696: /*
697: * With pci bus iommu support, we use a default pool of unmapped memory
698: * for memory we donnot need to DMA from/to and one pool per pcidev for
699: * memory accessed by the PCI chip. `mp0' is the default not DMAable pool.
700: */
701:
702: #ifndef SCSI_NCR_DYNAMIC_DMA_MAPPING
703:
704: static m_pool_s mp0;
705:
706: #else
707:
708: static m_addr_t ___mp0_getp(m_pool_s *mp)
709: {
710: m_addr_t m = GetPages();
711: if (m)
712: ++mp->nump;
713: return m;
714: }
715:
716: static void ___mp0_freep(m_pool_s *mp, m_addr_t m)
717: {
718: FreePages(m);
719: --mp->nump;
720: }
721:
722: static m_pool_s mp0 = {0, ___mp0_getp, ___mp0_freep};
723:
724: #endif /* SCSI_NCR_DYNAMIC_DMA_MAPPING */
725:
726: static void *m_calloc(int size, char *name)
727: {
728: u_long flags;
729: void *m;
730: NCR_LOCK_DRIVER(flags);
731: m = __m_calloc(&mp0, size, name);
732: NCR_UNLOCK_DRIVER(flags);
733: return m;
734: }
735:
736: static void m_free(void *ptr, int size, char *name)
737: {
738: u_long flags;
739: NCR_LOCK_DRIVER(flags);
740: __m_free(&mp0, ptr, size, name);
741: NCR_UNLOCK_DRIVER(flags);
742: }
743:
744: /*
745: * DMAable pools.
746: */
747:
748: #ifndef SCSI_NCR_DYNAMIC_DMA_MAPPING
749:
750: /* Without pci bus iommu support, all the memory is assumed DMAable */
751:
752: #define __m_calloc_dma(b, s, n) m_calloc(s, n)
753: #define __m_free_dma(b, p, s, n) m_free(p, s, n)
754: #define __vtobus(b, p) virt_to_bus(p)
755:
756: #else
757:
758: /*
759: * With pci bus iommu support, we maintain one pool per pcidev and a
760: * hashed reverse table for virtual to bus physical address translations.
761: */
762: static m_addr_t ___dma_getp(m_pool_s *mp)
763: {
764: m_addr_t vp;
765: m_vtob_s *vbp;
766:
767: vbp = __m_calloc(&mp0, sizeof(*vbp), "VTOB");
768: if (vbp) {
769: dma_addr_t daddr;
770: vp = (m_addr_t) pci_alloc_consistent(mp->bush,
771: PAGE_SIZE<<MEMO_PAGE_ORDER,
772: &daddr);
773: if (vp) {
774: int hc = VTOB_HASH_CODE(vp);
775: vbp->vaddr = vp;
776: vbp->baddr = daddr;
777: vbp->next = mp->vtob[hc];
778: mp->vtob[hc] = vbp;
779: ++mp->nump;
780: return vp;
781: }
782: }
783: if (vbp)
784: __m_free(&mp0, vbp, sizeof(*vbp), "VTOB");
785: return 0;
786: }
787:
788: static void ___dma_freep(m_pool_s *mp, m_addr_t m)
789: {
790: m_vtob_s **vbpp, *vbp;
791: int hc = VTOB_HASH_CODE(m);
792:
793: vbpp = &mp->vtob[hc];
794: while (*vbpp && (*vbpp)->vaddr != m)
795: vbpp = &(*vbpp)->next;
796: if (*vbpp) {
797: vbp = *vbpp;
798: *vbpp = (*vbpp)->next;
799: pci_free_consistent(mp->bush, PAGE_SIZE<<MEMO_PAGE_ORDER,
800: (void *)vbp->vaddr, (dma_addr_t)vbp->baddr);
801: __m_free(&mp0, vbp, sizeof(*vbp), "VTOB");
802: --mp->nump;
803: }
804: }
805:
806: static inline m_pool_s *___get_dma_pool(m_bush_t bush)
807: {
808: m_pool_s *mp;
809: for (mp = mp0.next; mp && mp->bush != bush; mp = mp->next);
810: return mp;
811: }
812:
813: static m_pool_s *___cre_dma_pool(m_bush_t bush)
814: {
815: m_pool_s *mp;
816: mp = __m_calloc(&mp0, sizeof(*mp), "MPOOL");
817: if (mp) {
818: bzero(mp, sizeof(*mp));
819: mp->bush = bush;
820: mp->getp = ___dma_getp;
821: mp->freep = ___dma_freep;
822: mp->next = mp0.next;
823: mp0.next = mp;
824: }
825: return mp;
826: }
827:
828: static void ___del_dma_pool(m_pool_s *p)
829: {
830: struct m_pool **pp = &mp0.next;
831:
832: while (*pp && *pp != p)
833: pp = &(*pp)->next;
834: if (*pp) {
835: *pp = (*pp)->next;
836: __m_free(&mp0, p, sizeof(*p), "MPOOL");
837: }
838: }
839:
840: static void *__m_calloc_dma(m_bush_t bush, int size, char *name)
841: {
842: u_long flags;
843: struct m_pool *mp;
844: void *m = 0;
845:
846: NCR_LOCK_DRIVER(flags);
847: mp = ___get_dma_pool(bush);
848: if (!mp)
849: mp = ___cre_dma_pool(bush);
850: if (mp)
851: m = __m_calloc(mp, size, name);
852: if (mp && !mp->nump)
853: ___del_dma_pool(mp);
854: NCR_UNLOCK_DRIVER(flags);
855:
856: return m;
857: }
858:
859: static void __m_free_dma(m_bush_t bush, void *m, int size, char *name)
860: {
861: u_long flags;
862: struct m_pool *mp;
863:
864: NCR_LOCK_DRIVER(flags);
865: mp = ___get_dma_pool(bush);
866: if (mp)
867: __m_free(mp, m, size, name);
868: if (mp && !mp->nump)
869: ___del_dma_pool(mp);
870: NCR_UNLOCK_DRIVER(flags);
871: }
872:
873: static m_addr_t __vtobus(m_bush_t bush, void *m)
874: {
875: u_long flags;
876: m_pool_s *mp;
877: int hc = VTOB_HASH_CODE(m);
878: m_vtob_s *vp = 0;
879: m_addr_t a = ((m_addr_t) m) & ~MEMO_CLUSTER_MASK;
880:
881: NCR_LOCK_DRIVER(flags);
882: mp = ___get_dma_pool(bush);
883: if (mp) {
884: vp = mp->vtob[hc];
885: while (vp && (m_addr_t) vp->vaddr != a)
886: vp = vp->next;
887: }
888: NCR_UNLOCK_DRIVER(flags);
889: return vp ? vp->baddr + (((m_addr_t) m) - a) : 0;
890: }
891:
892: #endif /* SCSI_NCR_DYNAMIC_DMA_MAPPING */
893:
894: #define _m_calloc_dma(np, s, n) __m_calloc_dma(np->pdev, s, n)
895: #define _m_free_dma(np, p, s, n) __m_free_dma(np->pdev, p, s, n)
896: #define m_calloc_dma(s, n) _m_calloc_dma(np, s, n)
897: #define m_free_dma(p, s, n) _m_free_dma(np, p, s, n)
898: #define _vtobus(np, p) __vtobus(np->pdev, p)
899: #define vtobus(p) _vtobus(np, p)
900:
901: /*
902: * Deal with DMA mapping/unmapping.
903: */
904:
905: #ifndef SCSI_NCR_DYNAMIC_DMA_MAPPING
906:
907: /* Linux versions prior to pci bus iommu kernel interface */
908:
909: #define __unmap_scsi_data(pdev, cmd) do {; } while (0)
910: #define __map_scsi_single_data(pdev, cmd) (__vtobus(pdev,(cmd)->request_buffer))
911: #define __map_scsi_sg_data(pdev, cmd) ((cmd)->use_sg)
912: #define __sync_scsi_data(pdev, cmd) do {; } while (0)
913:
914: #define scsi_sg_dma_address(sc) vtobus((sc)->address)
915: #define scsi_sg_dma_len(sc) ((sc)->length)
916:
917: #else
918:
919: /* Linux version with pci bus iommu kernel interface */
920:
921: /* To keep track of the dma mapping (sg/single) that has been set */
922: #define __data_mapped SCp.phase
923: #define __data_mapping SCp.have_data_in
924:
925: static void __unmap_scsi_data(pcidev_t pdev, Scsi_Cmnd *cmd)
926: {
927: int dma_dir = scsi_to_pci_dma_dir(cmd->sc_data_direction);
928:
929: switch(cmd->__data_mapped) {
930: case 2:
931: pci_unmap_sg(pdev, cmd->buffer, cmd->use_sg, dma_dir);
932: break;
933: case 1:
934: pci_unmap_single(pdev, cmd->__data_mapping,
935: cmd->request_bufflen, dma_dir);
936: break;
937: }
938: cmd->__data_mapped = 0;
939: }
940:
941: static u_long __map_scsi_single_data(pcidev_t pdev, Scsi_Cmnd *cmd)
942: {
943: dma_addr_t mapping;
944: int dma_dir = scsi_to_pci_dma_dir(cmd->sc_data_direction);
945:
946: if (cmd->request_bufflen == 0)
947: return 0;
948:
949: mapping = pci_map_single(pdev, cmd->request_buffer,
950: cmd->request_bufflen, dma_dir);
951: cmd->__data_mapped = 1;
952: cmd->__data_mapping = mapping;
953:
954: return mapping;
955: }
956:
957: static int __map_scsi_sg_data(pcidev_t pdev, Scsi_Cmnd *cmd)
958: {
959: int use_sg;
960: int dma_dir = scsi_to_pci_dma_dir(cmd->sc_data_direction);
961:
962: if (cmd->use_sg == 0)
963: return 0;
964:
965: use_sg = pci_map_sg(pdev, cmd->buffer, cmd->use_sg, dma_dir);
966: cmd->__data_mapped = 2;
967: cmd->__data_mapping = use_sg;
968:
969: return use_sg;
970: }
971:
972: static void __sync_scsi_data(pcidev_t pdev, Scsi_Cmnd *cmd)
973: {
974: int dma_dir = scsi_to_pci_dma_dir(cmd->sc_data_direction);
975:
976: switch(cmd->__data_mapped) {
977: case 2:
978: pci_dma_sync_sg(pdev, cmd->buffer, cmd->use_sg, dma_dir);
979: break;
980: case 1:
981: pci_dma_sync_single(pdev, cmd->__data_mapping,
982: cmd->request_bufflen, dma_dir);
983: break;
984: }
985: }
986:
987: #define scsi_sg_dma_address(sc) sg_dma_address(sc)
988: #define scsi_sg_dma_len(sc) sg_dma_len(sc)
989:
990: #endif /* SCSI_NCR_DYNAMIC_DMA_MAPPING */
991:
992: #define unmap_scsi_data(np, cmd) __unmap_scsi_data(np->pdev, cmd)
993: #define map_scsi_single_data(np, cmd) __map_scsi_single_data(np->pdev, cmd)
994: #define map_scsi_sg_data(np, cmd) __map_scsi_sg_data(np->pdev, cmd)
995: #define sync_scsi_data(np, cmd) __sync_scsi_data(np->pdev, cmd)
996:
997: /*==========================================================
998: **
999: ** SCSI data transfer direction
1000: **
1001: ** Until some linux kernel version near 2.3.40,
1002: ** low-level scsi drivers were not told about data
1003: ** transfer direction. We check the existence of this
1004: ** feature that has been expected for a _long_ time by
1005: ** all SCSI driver developers by just testing against
1006: ** the definition of SCSI_DATA_UNKNOWN. Indeed this is
1007: ** a hack, but testing against a kernel version would
1008: ** have been a shame. ;-)
1009: **
1010: **==========================================================
1011: */
1012: #ifdef SCSI_DATA_UNKNOWN
1013:
1014: #define scsi_data_direction(cmd) (cmd->sc_data_direction)
1015:
1016: #else
1017:
1018: #define SCSI_DATA_UNKNOWN 0
1019: #define SCSI_DATA_WRITE 1
1020: #define SCSI_DATA_READ 2
1021: #define SCSI_DATA_NONE 3
1022:
1023: static __inline__ int scsi_data_direction(Scsi_Cmnd *cmd)
1024: {
1025: int direction;
1026:
1027: switch((int) cmd->cmnd[0]) {
1028: case 0x08: /* READ(6) 08 */
1029: case 0x28: /* READ(10) 28 */
1030: case 0xA8: /* READ(12) A8 */
1031: direction = SCSI_DATA_READ;
1032: break;
1033: case 0x0A: /* WRITE(6) 0A */
1034: case 0x2A: /* WRITE(10) 2A */
1035: case 0xAA: /* WRITE(12) AA */
1036: direction = SCSI_DATA_WRITE;
1037: break;
1038: default:
1039: direction = SCSI_DATA_UNKNOWN;
1040: break;
1041: }
1042:
1043: return direction;
1044: }
1045:
1046: #endif /* SCSI_DATA_UNKNOWN */
1047:
1048: /*==========================================================
1049: **
1050: ** Driver setup.
1051: **
1052: ** This structure is initialized from linux config
1053: ** options. It can be overridden at boot-up by the boot
1054: ** command line.
1055: **
1056: **==========================================================
1057: */
1058: static struct ncr_driver_setup
1059: driver_setup = SCSI_NCR_DRIVER_SETUP;
1060:
1061: #ifdef SCSI_NCR_BOOT_COMMAND_LINE_SUPPORT
1062: static struct ncr_driver_setup
1063: driver_safe_setup __initdata = SCSI_NCR_DRIVER_SAFE_SETUP;
1064: #endif
1065:
1066: #define initverbose (driver_setup.verbose)
1067: #define bootverbose (np->verbose)
1068:
1069:
1070: /*==========================================================
1071: **
1072: ** Structures used by the detection routine to transmit
1073: ** device configuration to the attach function.
1074: **
1075: **==========================================================
1076: */
1077: typedef struct {
1078: int bus;
1079: u_char device_fn;
1080: u_long base;
1081: u_long base_2;
1082: u_long io_port;
1083: int irq;
1084: /* port and reg fields to use INB, OUTB macros */
1085: u_long base_io;
1086: volatile struct ncr_reg *reg;
1087: } ncr_slot;
1088:
1089: /*==========================================================
1090: **
1091: ** Structure used to store the NVRAM content.
1092: **
1093: **==========================================================
1094: */
1095: typedef struct {
1096: int type;
1097: #define SCSI_NCR_SYMBIOS_NVRAM (1)
1098: #define SCSI_NCR_TEKRAM_NVRAM (2)
1099: #ifdef SCSI_NCR_NVRAM_SUPPORT
1100: union {
1101: Symbios_nvram Symbios;
1102: Tekram_nvram Tekram;
1103: } data;
1104: #endif
1105: } ncr_nvram;
1106:
1107: /*==========================================================
1108: **
1109: ** Structure used by detection routine to save data on
1110: ** each detected board for attach.
1111: **
1112: **==========================================================
1113: */
1114: typedef struct {
1115: pcidev_t pdev;
1116: ncr_slot slot;
1117: ncr_chip chip;
1118: ncr_nvram *nvram;
1119: u_char host_id;
1120: #ifdef SCSI_NCR_PQS_PDS_SUPPORT
1121: u_char pqs_pds;
1122: #endif
1123: int attach_done;
1124: } ncr_device;
1125:
1126: static int ncr_attach (Scsi_Host_Template *tpnt, int unit, ncr_device *device);
1127:
1128: /*==========================================================
1129: **
1130: ** NVRAM detection and reading.
1131: **
1132: ** Currently supported:
1133: ** - 24C16 EEPROM with both Symbios and Tekram layout.
1134: ** - 93C46 EEPROM with Tekram layout.
1135: **
1136: **==========================================================
1137: */
1138:
1139: #ifdef SCSI_NCR_NVRAM_SUPPORT
1140: /*
1141: * 24C16 EEPROM reading.
1142: *
1143: * GPOI0 - data in/data out
1144: * GPIO1 - clock
1145: * Symbios NVRAM wiring now also used by Tekram.
1146: */
1147:
1148: #define SET_BIT 0
1149: #define CLR_BIT 1
1150: #define SET_CLK 2
1151: #define CLR_CLK 3
1152:
1153: /*
1154: * Set/clear data/clock bit in GPIO0
1155: */
1156: static void __init
1157: S24C16_set_bit(ncr_slot *np, u_char write_bit, u_char *gpreg, int bit_mode)
1158: {
1159: UDELAY (5);
1160: switch (bit_mode){
1161: case SET_BIT:
1162: *gpreg |= write_bit;
1163: break;
1164: case CLR_BIT:
1165: *gpreg &= 0xfe;
1166: break;
1167: case SET_CLK:
1168: *gpreg |= 0x02;
1169: break;
1170: case CLR_CLK:
1171: *gpreg &= 0xfd;
1172: break;
1173:
1174: }
1175: OUTB (nc_gpreg, *gpreg);
1176: UDELAY (5);
1177: }
1178:
1179: /*
1180: * Send START condition to NVRAM to wake it up.
1181: */
1182: static void __init S24C16_start(ncr_slot *np, u_char *gpreg)
1183: {
1184: S24C16_set_bit(np, 1, gpreg, SET_BIT);
1185: S24C16_set_bit(np, 0, gpreg, SET_CLK);
1186: S24C16_set_bit(np, 0, gpreg, CLR_BIT);
1187: S24C16_set_bit(np, 0, gpreg, CLR_CLK);
1188: }
1189:
1190: /*
1191: * Send STOP condition to NVRAM - puts NVRAM to sleep... ZZzzzz!!
1192: */
1193: static void __init S24C16_stop(ncr_slot *np, u_char *gpreg)
1194: {
1195: S24C16_set_bit(np, 0, gpreg, SET_CLK);
1196: S24C16_set_bit(np, 1, gpreg, SET_BIT);
1197: }
1198:
1199: /*
1200: * Read or write a bit to the NVRAM,
1201: * read if GPIO0 input else write if GPIO0 output
1202: */
1203: static void __init
1204: S24C16_do_bit(ncr_slot *np, u_char *read_bit, u_char write_bit, u_char *gpreg)
1205: {
1206: S24C16_set_bit(np, write_bit, gpreg, SET_BIT);
1207: S24C16_set_bit(np, 0, gpreg, SET_CLK);
1208: if (read_bit)
1209: *read_bit = INB (nc_gpreg);
1210: S24C16_set_bit(np, 0, gpreg, CLR_CLK);
1211: S24C16_set_bit(np, 0, gpreg, CLR_BIT);
1212: }
1213:
1214: /*
1215: * Output an ACK to the NVRAM after reading,
1216: * change GPIO0 to output and when done back to an input
1217: */
1218: static void __init
1219: S24C16_write_ack(ncr_slot *np, u_char write_bit, u_char *gpreg, u_char *gpcntl)
1220: {
1221: OUTB (nc_gpcntl, *gpcntl & 0xfe);
1222: S24C16_do_bit(np, 0, write_bit, gpreg);
1223: OUTB (nc_gpcntl, *gpcntl);
1224: }
1225:
1226: /*
1227: * Input an ACK from NVRAM after writing,
1228: * change GPIO0 to input and when done back to an output
1229: */
1230: static void __init
1231: S24C16_read_ack(ncr_slot *np, u_char *read_bit, u_char *gpreg, u_char *gpcntl)
1232: {
1233: OUTB (nc_gpcntl, *gpcntl | 0x01);
1234: S24C16_do_bit(np, read_bit, 1, gpreg);
1235: OUTB (nc_gpcntl, *gpcntl);
1236: }
1237:
1238: /*
1239: * WRITE a byte to the NVRAM and then get an ACK to see it was accepted OK,
1240: * GPIO0 must already be set as an output
1241: */
1242: static void __init
1243: S24C16_write_byte(ncr_slot *np, u_char *ack_data, u_char write_data,
1244: u_char *gpreg, u_char *gpcntl)
1245: {
1246: int x;
1247:
1248: for (x = 0; x < 8; x++)
1249: S24C16_do_bit(np, 0, (write_data >> (7 - x)) & 0x01, gpreg);
1250:
1251: S24C16_read_ack(np, ack_data, gpreg, gpcntl);
1252: }
1253:
1254: /*
1255: * READ a byte from the NVRAM and then send an ACK to say we have got it,
1256: * GPIO0 must already be set as an input
1257: */
1258: static void __init
1259: S24C16_read_byte(ncr_slot *np, u_char *read_data, u_char ack_data,
1260: u_char *gpreg, u_char *gpcntl)
1261: {
1262: int x;
1263: u_char read_bit;
1264:
1265: *read_data = 0;
1266: for (x = 0; x < 8; x++) {
1267: S24C16_do_bit(np, &read_bit, 1, gpreg);
1268: *read_data |= ((read_bit & 0x01) << (7 - x));
1269: }
1270:
1271: S24C16_write_ack(np, ack_data, gpreg, gpcntl);
1272: }
1273:
1274: /*
1275: * Read 'len' bytes starting at 'offset'.
1276: */
1277: static int __init
1278: sym_read_S24C16_nvram (ncr_slot *np, int offset, u_char *data, int len)
1279: {
1280: u_char gpcntl, gpreg;
1281: u_char old_gpcntl, old_gpreg;
1282: u_char ack_data;
1283: int retv = 1;
1284: int x;
1285:
1286: /* save current state of GPCNTL and GPREG */
1287: old_gpreg = INB (nc_gpreg);
1288: old_gpcntl = INB (nc_gpcntl);
1289: gpcntl = old_gpcntl & 0xfc;
1290:
1291: /* set up GPREG & GPCNTL to set GPIO0 and GPIO1 in to known state */
1292: OUTB (nc_gpreg, old_gpreg);
1293: OUTB (nc_gpcntl, gpcntl);
1294:
1295: /* this is to set NVRAM into a known state with GPIO0/1 both low */
1296: gpreg = old_gpreg;
1297: S24C16_set_bit(np, 0, &gpreg, CLR_CLK);
1298: S24C16_set_bit(np, 0, &gpreg, CLR_BIT);
1299:
1300: /* now set NVRAM inactive with GPIO0/1 both high */
1301: S24C16_stop(np, &gpreg);
1302:
1303: /* activate NVRAM */
1304: S24C16_start(np, &gpreg);
1305:
1306: /* write device code and random address MSB */
1307: S24C16_write_byte(np, &ack_data,
1308: 0xa0 | ((offset >> 7) & 0x0e), &gpreg, &gpcntl);
1309: if (ack_data & 0x01)
1310: goto out;
1311:
1312: /* write random address LSB */
1313: S24C16_write_byte(np, &ack_data,
1314: offset & 0xff, &gpreg, &gpcntl);
1315: if (ack_data & 0x01)
1316: goto out;
1317:
1318: /* regenerate START state to set up for reading */
1319: S24C16_start(np, &gpreg);
1320:
1321: /* rewrite device code and address MSB with read bit set (lsb = 0x01) */
1322: S24C16_write_byte(np, &ack_data,
1323: 0xa1 | ((offset >> 7) & 0x0e), &gpreg, &gpcntl);
1324: if (ack_data & 0x01)
1325: goto out;
1326:
1327: /* now set up GPIO0 for inputting data */
1328: gpcntl |= 0x01;
1329: OUTB (nc_gpcntl, gpcntl);
1330:
1331: /* input all requested data - only part of total NVRAM */
1332: for (x = 0; x < len; x++)
1333: S24C16_read_byte(np, &data[x], (x == (len-1)), &gpreg, &gpcntl);
1334:
1335: /* finally put NVRAM back in inactive mode */
1336: gpcntl &= 0xfe;
1337: OUTB (nc_gpcntl, gpcntl);
1338: S24C16_stop(np, &gpreg);
1339: retv = 0;
1340: out:
1341: /* return GPIO0/1 to original states after having accessed NVRAM */
1342: OUTB (nc_gpcntl, old_gpcntl);
1343: OUTB (nc_gpreg, old_gpreg);
1344:
1345: return retv;
1346: }
1347:
1348: #undef SET_BIT 0
1349: #undef CLR_BIT 1
1350: #undef SET_CLK 2
1351: #undef CLR_CLK 3
1352:
1353: /*
1354: * Try reading Symbios NVRAM.
1355: * Return 0 if OK.
1356: */
1357: static int __init sym_read_Symbios_nvram (ncr_slot *np, Symbios_nvram *nvram)
1358: {
1359: static u_char Symbios_trailer[6] = {0xfe, 0xfe, 0, 0, 0, 0};
1360: u_char *data = (u_char *) nvram;
1361: int len = sizeof(*nvram);
1362: u_short csum;
1363: int x;
1364:
1365: /* probe the 24c16 and read the SYMBIOS 24c16 area */
1366: if (sym_read_S24C16_nvram (np, SYMBIOS_NVRAM_ADDRESS, data, len))
1367: return 1;
1368:
1369: /* check valid NVRAM signature, verify byte count and checksum */
1370: if (nvram->type != 0 ||
1371: memcmp(nvram->trailer, Symbios_trailer, 6) ||
1372: nvram->byte_count != len - 12)
1373: return 1;
1374:
1375: /* verify checksum */
1376: for (x = 6, csum = 0; x < len - 6; x++)
1377: csum += data[x];
1378: if (csum != nvram->checksum)
1379: return 1;
1380:
1381: return 0;
1382: }
1383:
1384: /*
1385: * 93C46 EEPROM reading.
1386: *
1387: * GPOI0 - data in
1388: * GPIO1 - data out
1389: * GPIO2 - clock
1390: * GPIO4 - chip select
1391: *
1392: * Used by Tekram.
1393: */
1394:
1395: /*
1396: * Pulse clock bit in GPIO0
1397: */
1398: static void __init T93C46_Clk(ncr_slot *np, u_char *gpreg)
1399: {
1400: OUTB (nc_gpreg, *gpreg | 0x04);
1401: UDELAY (2);
1402: OUTB (nc_gpreg, *gpreg);
1403: }
1404:
1405: /*
1406: * Read bit from NVRAM
1407: */
1408: static void __init T93C46_Read_Bit(ncr_slot *np, u_char *read_bit, u_char *gpreg)
1409: {
1410: UDELAY (2);
1411: T93C46_Clk(np, gpreg);
1412: *read_bit = INB (nc_gpreg);
1413: }
1414:
1415: /*
1416: * Write bit to GPIO0
1417: */
1418: static void __init T93C46_Write_Bit(ncr_slot *np, u_char write_bit, u_char *gpreg)
1419: {
1420: if (write_bit & 0x01)
1421: *gpreg |= 0x02;
1422: else
1423: *gpreg &= 0xfd;
1424:
1425: *gpreg |= 0x10;
1426:
1427: OUTB (nc_gpreg, *gpreg);
1428: UDELAY (2);
1429:
1430: T93C46_Clk(np, gpreg);
1431: }
1432:
1433: /*
1434: * Send STOP condition to NVRAM - puts NVRAM to sleep... ZZZzzz!!
1435: */
1436: static void __init T93C46_Stop(ncr_slot *np, u_char *gpreg)
1437: {
1438: *gpreg &= 0xef;
1439: OUTB (nc_gpreg, *gpreg);
1440: UDELAY (2);
1441:
1442: T93C46_Clk(np, gpreg);
1443: }
1444:
1445: /*
1446: * Send read command and address to NVRAM
1447: */
1448: static void __init
1449: T93C46_Send_Command(ncr_slot *np, u_short write_data,
1450: u_char *read_bit, u_char *gpreg)
1451: {
1452: int x;
1453:
1454: /* send 9 bits, start bit (1), command (2), address (6) */
1455: for (x = 0; x < 9; x++)
1456: T93C46_Write_Bit(np, (u_char) (write_data >> (8 - x)), gpreg);
1457:
1458: *read_bit = INB (nc_gpreg);
1459: }
1460:
1461: /*
1462: * READ 2 bytes from the NVRAM
1463: */
1464: static void __init
1465: T93C46_Read_Word(ncr_slot *np, u_short *nvram_data, u_char *gpreg)
1466: {
1467: int x;
1468: u_char read_bit;
1469:
1470: *nvram_data = 0;
1471: for (x = 0; x < 16; x++) {
1472: T93C46_Read_Bit(np, &read_bit, gpreg);
1473:
1474: if (read_bit & 0x01)
1475: *nvram_data |= (0x01 << (15 - x));
1476: else
1477: *nvram_data &= ~(0x01 << (15 - x));
1478: }
1479: }
1480:
1481: /*
1482: * Read Tekram NvRAM data.
1483: */
1484: static int __init
1485: T93C46_Read_Data(ncr_slot *np, u_short *data,int len,u_char *gpreg)
1486: {
1487: u_char read_bit;
1488: int x;
1489:
1490: for (x = 0; x < len; x++) {
1491:
1492: /* output read command and address */
1493: T93C46_Send_Command(np, 0x180 | x, &read_bit, gpreg);
1494: if (read_bit & 0x01)
1495: return 1; /* Bad */
1496: T93C46_Read_Word(np, &data[x], gpreg);
1497: T93C46_Stop(np, gpreg);
1498: }
1499:
1500: return 0;
1501: }
1502:
1503: /*
1504: * Try reading 93C46 Tekram NVRAM.
1505: */
1506: static int __init
1507: sym_read_T93C46_nvram (ncr_slot *np, Tekram_nvram *nvram)
1508: {
1509: u_char gpcntl, gpreg;
1510: u_char old_gpcntl, old_gpreg;
1511: int retv = 1;
1512:
1513: /* save current state of GPCNTL and GPREG */
1514: old_gpreg = INB (nc_gpreg);
1515: old_gpcntl = INB (nc_gpcntl);
1516:
1517: /* set up GPREG & GPCNTL to set GPIO0/1/2/4 in to known state, 0 in,
1518: 1/2/4 out */
1519: gpreg = old_gpreg & 0xe9;
1520: OUTB (nc_gpreg, gpreg);
1521: gpcntl = (old_gpcntl & 0xe9) | 0x09;
1522: OUTB (nc_gpcntl, gpcntl);
1523:
1524: /* input all of NVRAM, 64 words */
1525: retv = T93C46_Read_Data(np, (u_short *) nvram,
1526: sizeof(*nvram) / sizeof(short), &gpreg);
1527:
1528: /* return GPIO0/1/2/4 to original states after having accessed NVRAM */
1529: OUTB (nc_gpcntl, old_gpcntl);
1530: OUTB (nc_gpreg, old_gpreg);
1531:
1532: return retv;
1533: }
1534:
1535: /*
1536: * Try reading Tekram NVRAM.
1537: * Return 0 if OK.
1538: */
1539: static int __init
1540: sym_read_Tekram_nvram (ncr_slot *np, u_short device_id, Tekram_nvram *nvram)
1541: {
1542: u_char *data = (u_char *) nvram;
1543: int len = sizeof(*nvram);
1544: u_short csum;
1545: int x;
1546:
1547: switch (device_id) {
1548: case PCI_DEVICE_ID_NCR_53C885:
1549: case PCI_DEVICE_ID_NCR_53C895:
1550: case PCI_DEVICE_ID_NCR_53C896:
1551: x = sym_read_S24C16_nvram(np, TEKRAM_24C16_NVRAM_ADDRESS,
1552: data, len);
1553: break;
1554: case PCI_DEVICE_ID_NCR_53C875:
1555: x = sym_read_S24C16_nvram(np, TEKRAM_24C16_NVRAM_ADDRESS,
1556: data, len);
1557: if (!x)
1558: break;
1559: default:
1560: x = sym_read_T93C46_nvram(np, nvram);
1561: break;
1562: }
1563: if (x)
1564: return 1;
1565:
1566: /* verify checksum */
1567: for (x = 0, csum = 0; x < len - 1; x += 2)
1568: csum += data[x] + (data[x+1] << 8);
1569: if (csum != 0x1234)
1570: return 1;
1571:
1572: return 0;
1573: }
1574:
1575: #endif /* SCSI_NCR_NVRAM_SUPPORT */
1576:
1577: /*===================================================================
1578: **
1579: ** Detect and try to read SYMBIOS and TEKRAM NVRAM.
1580: **
1581: ** Data can be used to order booting of boards.
1582: **
1583: ** Data is saved in ncr_device structure if NVRAM found. This
1584: ** is then used to find drive boot order for ncr_attach().
1585: **
1586: ** NVRAM data is passed to Scsi_Host_Template later during
1587: ** ncr_attach() for any device set up.
1588: **
1589: **===================================================================
1590: */
1591: #ifdef SCSI_NCR_NVRAM_SUPPORT
1592: static void __init ncr_get_nvram(ncr_device *devp, ncr_nvram *nvp)
1593: {
1594: devp->nvram = nvp;
1595: if (!nvp)
1596: return;
1597: /*
1598: ** Get access to chip IO registers
1599: */
1600: #ifdef SCSI_NCR_IOMAPPED
1601: request_region(devp->slot.io_port, 128, NAME53C8XX);
1602: devp->slot.base_io = devp->slot.io_port;
1603: #else
1604: devp->slot.reg = (struct ncr_reg *) remap_pci_mem(devp->slot.base, 128);
1605: if (!devp->slot.reg)
1606: return;
1607: #endif
1608:
1609: /*
1610: ** Try to read SYMBIOS nvram.
1611: ** Try to read TEKRAM nvram if Symbios nvram not found.
1612: */
1613: if (!sym_read_Symbios_nvram(&devp->slot, &nvp->data.Symbios))
1614: nvp->type = SCSI_NCR_SYMBIOS_NVRAM;
1615: else if (!sym_read_Tekram_nvram(&devp->slot, devp->chip.device_id,
1616: &nvp->data.Tekram))
1617: nvp->type = SCSI_NCR_TEKRAM_NVRAM;
1618: else {
1619: nvp->type = 0;
1620: devp->nvram = 0;
1621: }
1622:
1623: /*
1624: ** Release access to chip IO registers
1625: */
1626: #ifdef SCSI_NCR_IOMAPPED
1627: release_region(devp->slot.base_io, 128);
1628: #else
1629: unmap_pci_mem((u_long) devp->slot.reg, 128ul);
1630: #endif
1631:
1632: }
1633:
1634: /*===================================================================
1635: **
1636: ** Display the content of NVRAM for debugging purpose.
1637: **
1638: **===================================================================
1639: */
1640: #ifdef SCSI_NCR_DEBUG_NVRAM
1641: static void __init ncr_display_Symbios_nvram(Symbios_nvram *nvram)
1642: {
1643: int i;
1644:
1645: /* display Symbios nvram host data */
1646: printk(KERN_DEBUG NAME53C8XX ": HOST ID=%d%s%s%s%s%s\n",
1647: nvram->host_id & 0x0f,
1648: (nvram->flags & SYMBIOS_SCAM_ENABLE) ? " SCAM" :"",
1649: (nvram->flags & SYMBIOS_PARITY_ENABLE) ? " PARITY" :"",
1650: (nvram->flags & SYMBIOS_VERBOSE_MSGS) ? " VERBOSE" :"",
1651: (nvram->flags & SYMBIOS_CHS_MAPPING) ? " CHS_ALT" :"",
1652: (nvram->flags1 & SYMBIOS_SCAN_HI_LO) ? " HI_LO" :"");
1653:
1654: /* display Symbios nvram drive data */
1655: for (i = 0 ; i < 15 ; i++) {
1656: struct Symbios_target *tn = &nvram->target[i];
1657: printk(KERN_DEBUG NAME53C8XX
1658: "-%d:%s%s%s%s WIDTH=%d SYNC=%d TMO=%d\n",
1659: i,
1660: (tn->flags & SYMBIOS_DISCONNECT_ENABLE) ? " DISC" : "",
1661: (tn->flags & SYMBIOS_SCAN_AT_BOOT_TIME) ? " SCAN_BOOT" : "",
1662: (tn->flags & SYMBIOS_SCAN_LUNS) ? " SCAN_LUNS" : "",
1663: (tn->flags & SYMBIOS_QUEUE_TAGS_ENABLED)? " TCQ" : "",
1664: tn->bus_width,
1665: tn->sync_period / 4,
1666: tn->timeout);
1667: }
1668: }
1669:
1670: static u_char Tekram_boot_delay[7] __initdata = {3, 5, 10, 20, 30, 60, 120};
1671:
1672: static void __init ncr_display_Tekram_nvram(Tekram_nvram *nvram)
1673: {
1674: int i, tags, boot_delay;
1675: char *rem;
1676:
1677: /* display Tekram nvram host data */
1678: tags = 2 << nvram->max_tags_index;
1679: boot_delay = 0;
1680: if (nvram->boot_delay_index < 6)
1681: boot_delay = Tekram_boot_delay[nvram->boot_delay_index];
1682: switch((nvram->flags & TEKRAM_REMOVABLE_FLAGS) >> 6) {
1683: default:
1684: case 0: rem = ""; break;
1685: case 1: rem = " REMOVABLE=boot device"; break;
1686: case 2: rem = " REMOVABLE=all"; break;
1687: }
1688:
1689: printk(KERN_DEBUG NAME53C8XX
1690: ": HOST ID=%d%s%s%s%s%s%s%s%s%s BOOT DELAY=%d tags=%d\n",
1691: nvram->host_id & 0x0f,
1692: (nvram->flags1 & SYMBIOS_SCAM_ENABLE) ? " SCAM" :"",
1693: (nvram->flags & TEKRAM_MORE_THAN_2_DRIVES) ? " >2DRIVES":"",
1694: (nvram->flags & TEKRAM_DRIVES_SUP_1GB) ? " >1GB" :"",
1695: (nvram->flags & TEKRAM_RESET_ON_POWER_ON) ? " RESET" :"",
1696: (nvram->flags & TEKRAM_ACTIVE_NEGATION) ? " ACT_NEG" :"",
1697: (nvram->flags & TEKRAM_IMMEDIATE_SEEK) ? " IMM_SEEK" :"",
1698: (nvram->flags & TEKRAM_SCAN_LUNS) ? " SCAN_LUNS" :"",
1699: (nvram->flags1 & TEKRAM_F2_F6_ENABLED) ? " F2_F6" :"",
1700: rem, boot_delay, tags);
1701:
1702: /* display Tekram nvram drive data */
1703: for (i = 0; i <= 15; i++) {
1704: int sync, j;
1705: struct Tekram_target *tn = &nvram->target[i];
1706: j = tn->sync_index & 0xf;
1707: sync = Tekram_sync[j];
1708: printk(KERN_DEBUG NAME53C8XX "-%d:%s%s%s%s%s%s PERIOD=%d\n",
1709: i,
1710: (tn->flags & TEKRAM_PARITY_CHECK) ? " PARITY" : "",
1711: (tn->flags & TEKRAM_SYNC_NEGO) ? " SYNC" : "",
1712: (tn->flags & TEKRAM_DISCONNECT_ENABLE) ? " DISC" : "",
1713: (tn->flags & TEKRAM_START_CMD) ? " START" : "",
1714: (tn->flags & TEKRAM_TAGGED_COMMANDS) ? " TCQ" : "",
1715: (tn->flags & TEKRAM_WIDE_NEGO) ? " WIDE" : "",
1716: sync);
1717: }
1718: }
1719: #endif /* SCSI_NCR_DEBUG_NVRAM */
1720: #endif /* SCSI_NCR_NVRAM_SUPPORT */
1721:
1722:
1723: /*===================================================================
1724: **
1725: ** Utility routines that protperly return data through /proc FS.
1726: **
1727: **===================================================================
1728: */
1729: #ifdef SCSI_NCR_USER_INFO_SUPPORT
1730:
1731: struct info_str
1732: {
1733: char *buffer;
1734: int length;
1735: int offset;
1736: int pos;
1737: };
1738:
1739: static void copy_mem_info(struct info_str *info, char *data, int len)
1740: {
1741: if (info->pos + len > info->length)
1742: len = info->length - info->pos;
1743:
1744: if (info->pos + len < info->offset) {
1745: info->pos += len;
1746: return;
1747: }
1748: if (info->pos < info->offset) {
1749: data += (info->offset - info->pos);
1750: len -= (info->offset - info->pos);
1751: }
1752:
1753: if (len > 0) {
1754: memcpy(info->buffer + info->pos, data, len);
1755: info->pos += len;
1756: }
1757: }
1758:
1759: static int copy_info(struct info_str *info, char *fmt, ...)
1760: {
1761: va_list args;
1762: char buf[81];
1763: int len;
1764:
1765: va_start(args, fmt);
1766: len = vsprintf(buf, fmt, args);
1767: va_end(args);
1768:
1769: copy_mem_info(info, buf, len);
1770: return len;
1771: }
1772:
1773: #endif
1774:
1775: /*===================================================================
1776: **
1777: ** Driver setup from the boot command line
1778: **
1779: **===================================================================
1780: */
1781:
1782: #ifdef MODULE
1783: #define ARG_SEP ' '
1784: #else
1785: #define ARG_SEP ','
1786: #endif
1787:
1788: #define OPT_TAGS 1
1789: #define OPT_MASTER_PARITY 2
1790: #define OPT_SCSI_PARITY 3
1791: #define OPT_DISCONNECTION 4
1792: #define OPT_SPECIAL_FEATURES 5
1793: #define OPT_ULTRA_SCSI 6
1794: #define OPT_FORCE_SYNC_NEGO 7
1795: #define OPT_REVERSE_PROBE 8
1796: #define OPT_DEFAULT_SYNC 9
1797: #define OPT_VERBOSE 10
1798: #define OPT_DEBUG 11
1799: #define OPT_BURST_MAX 12
1800: #define OPT_LED_PIN 13
1801: #define OPT_MAX_WIDE 14
1802: #define OPT_SETTLE_DELAY 15
1803: #define OPT_DIFF_SUPPORT 16
1804: #define OPT_IRQM 17
1805: #define OPT_PCI_FIX_UP 18
1806: #define OPT_BUS_CHECK 19
1807: #define OPT_OPTIMIZE 20
1808: #define OPT_RECOVERY 21
1809: #define OPT_SAFE_SETUP 22
1810: #define OPT_USE_NVRAM 23
1811: #define OPT_EXCLUDE 24
1812: #define OPT_HOST_ID 25
1813:
1814: #ifdef SCSI_NCR_IARB_SUPPORT
1815: #define OPT_IARB 26
1816: #endif
1817:
1818: static char setup_token[] __initdata =
1819: "tags:" "mpar:"
1820: "spar:" "disc:"
1821: "specf:" "ultra:"
1822: "fsn:" "revprob:"
1823: "sync:" "verb:"
1824: "debug:" "burst:"
1825: "led:" "wide:"
1826: "settle:" "diff:"
1827: "irqm:" "pcifix:"
1828: "buschk:" "optim:"
1829: "recovery:"
1830: "safe:" "nvram:"
1831: "excl:" "hostid:"
1832: #ifdef SCSI_NCR_IARB_SUPPORT
1833: "iarb:"
1834: #endif
1835: ; /* DONNOT REMOVE THIS ';' */
1836:
1837: #ifdef MODULE
1838: #define ARG_SEP ' '
1839: #else
1840: #define ARG_SEP ','
1841: #endif
1842:
1843: static int __init get_setup_token(char *p)
1844: {
1845: char *cur = setup_token;
1846: char *pc;
1847: int i = 0;
1848:
1849: while (cur != NULL && (pc = strchr(cur, ':')) != NULL) {
1850: ++pc;
1851: ++i;
1852: if (!strncmp(p, cur, pc - cur))
1853: return i;
1854: cur = pc;
1855: }
1856: return 0;
1857: }
1858:
1859:
1860: static int __init sym53c8xx__setup(char *str)
1861: {
1862: #ifdef SCSI_NCR_BOOT_COMMAND_LINE_SUPPORT
1863: char *cur = str;
1864: char *pc, *pv;
1865: int i, val, c;
1866: int xi = 0;
1867:
1868: while (cur != NULL && (pc = strchr(cur, ':')) != NULL) {
1869: char *pe;
1870:
1871: val = 0;
1872: pv = pc;
1873: c = *++pv;
1874:
1875: if (c == 'n')
1876: val = 0;
1877: else if (c == 'y')
1878: val = 1;
1879: else
1880: val = (int) simple_strtoul(pv, &pe, 0);
1881:
1882: switch (get_setup_token(cur)) {
1883: case OPT_TAGS:
1884: driver_setup.default_tags = val;
1885: if (pe && *pe == '/') {
1886: i = 0;
1887: while (*pe && *pe != ARG_SEP &&
1888: i < sizeof(driver_setup.tag_ctrl)-1) {
1889: driver_setup.tag_ctrl[i++] = *pe++;
1890: }
1891: driver_setup.tag_ctrl[i] = '\0';
1892: }
1893: break;
1894: case OPT_MASTER_PARITY:
1895: driver_setup.master_parity = val;
1896: break;
1897: case OPT_SCSI_PARITY:
1898: driver_setup.scsi_parity = val;
1899: break;
1900: case OPT_DISCONNECTION:
1901: driver_setup.disconnection = val;
1902: break;
1903: case OPT_SPECIAL_FEATURES:
1904: driver_setup.special_features = val;
1905: break;
1906: case OPT_ULTRA_SCSI:
1907: driver_setup.ultra_scsi = val;
1908: break;
1909: case OPT_FORCE_SYNC_NEGO:
1910: driver_setup.force_sync_nego = val;
1911: break;
1912: case OPT_REVERSE_PROBE:
1913: driver_setup.reverse_probe = val;
1914: break;
1915: case OPT_DEFAULT_SYNC:
1916: driver_setup.default_sync = val;
1917: break;
1918: case OPT_VERBOSE:
1919: driver_setup.verbose = val;
1920: break;
1921: case OPT_DEBUG:
1922: driver_setup.debug = val;
1923: break;
1924: case OPT_BURST_MAX:
1925: driver_setup.burst_max = val;
1926: break;
1927: case OPT_LED_PIN:
1928: driver_setup.led_pin = val;
1929: break;
1930: case OPT_MAX_WIDE:
1931: driver_setup.max_wide = val? 1:0;
1932: break;
1933: case OPT_SETTLE_DELAY:
1934: driver_setup.settle_delay = val;
1935: break;
1936: case OPT_DIFF_SUPPORT:
1937: driver_setup.diff_support = val;
1938: break;
1939: case OPT_IRQM:
1940: driver_setup.irqm = val;
1941: break;
1942: case OPT_PCI_FIX_UP:
1943: driver_setup.pci_fix_up = val;
1944: break;
1945: case OPT_BUS_CHECK:
1946: driver_setup.bus_check = val;
1947: break;
1948: case OPT_OPTIMIZE:
1949: driver_setup.optimize = val;
1950: break;
1951: case OPT_RECOVERY:
1952: driver_setup.recovery = val;
1953: break;
1954: case OPT_USE_NVRAM:
1955: driver_setup.use_nvram = val;
1956: break;
1957: case OPT_SAFE_SETUP:
1958: memcpy(&driver_setup, &driver_safe_setup,
1959: sizeof(driver_setup));
1960: break;
1961: case OPT_EXCLUDE:
1962: if (xi < SCSI_NCR_MAX_EXCLUDES)
1963: driver_setup.excludes[xi++] = val;
1964: break;
1965: case OPT_HOST_ID:
1966: driver_setup.host_id = val;
1967: break;
1968: #ifdef SCSI_NCR_IARB_SUPPORT
1969: case OPT_IARB:
1970: driver_setup.iarb = val;
1971: break;
1972: #endif
1973: default:
1974: printk("sym53c8xx_setup: unexpected boot option '%.*s' ignored\n", (int)(pc-cur+1), cur);
1975: break;
1976: }
1977:
1978: if ((cur = strchr(cur, ARG_SEP)) != NULL)
1979: ++cur;
1980: }
1981: #endif /* SCSI_NCR_BOOT_COMMAND_LINE_SUPPORT */
1982: return 1;
1983: }
1984:
1985: /*===================================================================
1986: **
1987: ** Get device queue depth from boot command line.
1988: **
1989: **===================================================================
1990: */
1991: #define DEF_DEPTH (driver_setup.default_tags)
1992: #define ALL_TARGETS -2
1993: #define NO_TARGET -1
1994: #define ALL_LUNS -2
1995: #define NO_LUN -1
1996:
1997: static int device_queue_depth(int unit, int target, int lun)
1998: {
1999: int c, h, t, u, v;
2000: char *p = driver_setup.tag_ctrl;
2001: char *ep;
2002:
2003: h = -1;
2004: t = NO_TARGET;
2005: u = NO_LUN;
2006: while ((c = *p++) != 0) {
2007: v = simple_strtoul(p, &ep, 0);
2008: switch(c) {
2009: case '/':
2010: ++h;
2011: t = ALL_TARGETS;
2012: u = ALL_LUNS;
2013: break;
2014: case 't':
2015: if (t != target)
2016: t = (target == v) ? v : NO_TARGET;
2017: u = ALL_LUNS;
2018: break;
2019: case 'u':
2020: if (u != lun)
2021: u = (lun == v) ? v : NO_LUN;
2022: break;
2023: case 'q':
2024: if (h == unit &&
2025: (t == ALL_TARGETS || t == target) &&
2026: (u == ALL_LUNS || u == lun))
2027: return v;
2028: break;
2029: case '-':
2030: t = ALL_TARGETS;
2031: u = ALL_LUNS;
2032: break;
2033: default:
2034: break;
2035: }
2036: p = ep;
2037: }
2038: return DEF_DEPTH;
2039: }
2040:
2041: /*===================================================================
2042: **
2043: ** Print out information about driver configuration.
2044: **
2045: **===================================================================
2046: */
2047: static void __init ncr_print_driver_setup(void)
2048: {
2049: #define YesNo(y) y ? 'y' : 'n'
2050: printk (NAME53C8XX ": setup=disc:%c,specf:%d,ultra:%d,tags:%d,sync:%d,"
2051: "burst:%d,wide:%c,diff:%d,revprob:%c,buschk:0x%x\n",
2052: YesNo(driver_setup.disconnection),
2053: driver_setup.special_features,
2054: driver_setup.ultra_scsi,
2055: driver_setup.default_tags,
2056: driver_setup.default_sync,
2057: driver_setup.burst_max,
2058: YesNo(driver_setup.max_wide),
2059: driver_setup.diff_support,
2060: YesNo(driver_setup.reverse_probe),
2061: driver_setup.bus_check);
2062:
2063: printk (NAME53C8XX ": setup=mpar:%c,spar:%c,fsn=%c,verb:%d,debug:0x%x,"
2064: "led:%c,settle:%d,irqm:0x%x,nvram:0x%x,pcifix:0x%x\n",
2065: YesNo(driver_setup.master_parity),
2066: YesNo(driver_setup.scsi_parity),
2067: YesNo(driver_setup.force_sync_nego),
2068: driver_setup.verbose,
2069: driver_setup.debug,
2070: YesNo(driver_setup.led_pin),
2071: driver_setup.settle_delay,
2072: driver_setup.irqm,
2073: driver_setup.use_nvram,
2074: driver_setup.pci_fix_up);
2075: #undef YesNo
2076: }
2077:
2078: /*===================================================================
2079: **
2080: ** SYM53C8XX devices description table.
2081: **
2082: **===================================================================
2083: */
2084:
2085: static ncr_chip ncr_chip_table[] __initdata = SCSI_NCR_CHIP_TABLE;
2086:
2087: #ifdef SCSI_NCR_PQS_PDS_SUPPORT
2088: /*===================================================================
2089: **
2090: ** Detect all NCR PQS/PDS boards and keep track of their bus nr.
2091: **
2092: ** The NCR PQS or PDS card is constructed as a DEC bridge
2093: ** behind which sit a proprietary NCR memory controller and
2094: ** four or two 53c875s as separate devices. In its usual mode
2095: ** of operation, the 875s are slaved to the memory controller
2096: ** for all transfers. We can tell if an 875 is part of a
2097: ** PQS/PDS or not since if it is, it will be on the same bus
2098: ** as the memory controller. To operate with the Linux
2099: ** driver, the memory controller is disabled and the 875s
2100: ** freed to function independently. The only wrinkle is that
2101: ** the preset SCSI ID (which may be zero) must be read in from
2102: ** a special configuration space register of the 875.
2103: **
2104: **===================================================================
2105: */
2106: #define SCSI_NCR_MAX_PQS_BUS 16
2107: static int pqs_bus[SCSI_NCR_MAX_PQS_BUS] __initdata = { 0 };
2108:
2109: static void __init ncr_detect_pqs_pds(void)
2110: {
2111: short index;
2112: pcidev_t dev = PCIDEV_NULL;
2113:
2114: for(index=0; index < SCSI_NCR_MAX_PQS_BUS; index++) {
2115: u_char tmp;
2116:
2117: dev = pci_find_device(0x101a, 0x0009, dev);
2118: if (dev == PCIDEV_NULL) {
2119: pqs_bus[index] = -1;
2120: break;
2121: }
2122: printk(KERN_INFO NAME53C8XX ": NCR PQS/PDS memory controller detected on bus %d\n", PciBusNumber(dev));
2123: pci_read_config_byte(dev, 0x44, &tmp);
2124: /* bit 1: allow individual 875 configuration */
2125: tmp |= 0x2;
2126: pci_write_config_byte(dev, 0x44, tmp);
2127: pci_read_config_byte(dev, 0x45, &tmp);
2128: /* bit 2: drive individual 875 interrupts to the bus */
2129: tmp |= 0x4;
2130: pci_write_config_byte(dev, 0x45, tmp);
2131:
2132: pqs_bus[index] = PciBusNumber(dev);
2133: }
2134: }
2135: #endif /* SCSI_NCR_PQS_PDS_SUPPORT */
2136:
2137: /*===================================================================
2138: **
2139: ** Read and check the PCI configuration for any detected NCR
2140: ** boards and save data for attaching after all boards have
2141: ** been detected.
2142: **
2143: **===================================================================
2144: */
2145: static int __init
2146: sym53c8xx_pci_init(Scsi_Host_Template *tpnt, pcidev_t pdev, ncr_device *device)
2147: {
2148: u_short vendor_id, device_id, command;
2149: u_char cache_line_size, latency_timer;
2150: u_char suggested_cache_line_size = 0;
2151: u_char pci_fix_up = driver_setup.pci_fix_up;
2152: u_char revision;
2153: u_int irq;
2154: u_long base, base_2, io_port;
2155: int i;
2156: ncr_chip *chip;
2157:
2158: printk(KERN_INFO NAME53C8XX ": at PCI bus %d, device %d, function %d\n",
2159: PciBusNumber(pdev),
2160: (int) (PciDeviceFn(pdev) & 0xf8) >> 3,
2161: (int) (PciDeviceFn(pdev) & 7));
2162:
2163: #ifdef SCSI_NCR_DYNAMIC_DMA_MAPPING
2164: if (!pci_dma_supported(pdev, (dma_addr_t) (0xffffffffUL))) {
2165: printk(KERN_WARNING NAME53C8XX
2166: "32 BIT PCI BUS DMA ADDRESSING NOT SUPPORTED\n");
2167: return -1;
2168: }
2169: #endif
2170:
2171: /*
2172: ** Read info from the PCI config space.
2173: ** pci_read_config_xxx() functions are assumed to be used for
2174: ** successfully detected PCI devices.
2175: */
2176: vendor_id = PciVendorId(pdev);
2177: device_id = PciDeviceId(pdev);
2178: irq = PciIrqLine(pdev);
2179: i = 0;
2180: i = pci_get_base_address(pdev, i, &io_port);
2181: i = pci_get_base_address(pdev, i, &base);
2182: (void) pci_get_base_address(pdev, i, &base_2);
2183:
2184: pci_read_config_word(pdev, PCI_COMMAND, &command);
2185: pci_read_config_byte(pdev, PCI_CLASS_REVISION, &revision);
2186: pci_read_config_byte(pdev, PCI_CACHE_LINE_SIZE, &cache_line_size);
2187: pci_read_config_byte(pdev, PCI_LATENCY_TIMER, &latency_timer);
2188:
2189: #ifdef SCSI_NCR_PQS_PDS_SUPPORT
2190: /*
2191: ** Match the BUS number for PQS/PDS devices.
2192: ** Read the SCSI ID from a special register mapped
2193: ** into the configuration space of the individual
2194: ** 875s. This register is set up by the PQS bios
2195: */
2196: for(i = 0; i < SCSI_NCR_MAX_PQS_BUS && pqs_bus[i] != -1; i++) {
2197: u_char tmp;
2198: if (pqs_bus[i] == PciBusNumber(pdev)) {
2199: pci_read_config_byte(pdev, 0x84, &tmp);
2200: device->pqs_pds = 1;
2201: device->host_id = tmp;
2202: break;
2203: }
2204: }
2205: #endif /* SCSI_NCR_PQS_PDS_SUPPORT */
2206:
2207: /*
2208: ** If user excludes this chip, donnot initialize it.
2209: */
2210: for (i = 0 ; i < SCSI_NCR_MAX_EXCLUDES ; i++) {
2211: if (driver_setup.excludes[i] ==
2212: (io_port & PCI_BASE_ADDRESS_IO_MASK))
2213: return -1;
2214: }
2215: /*
2216: ** Check if the chip is supported
2217: */
2218: if ((device_id == PCI_DEVICE_ID_LSI_53C1010) ||
2219: (device_id == PCI_DEVICE_ID_LSI_53C1010_66)){
2220: printk(NAME53C8XX ": not initializing, device not supported\n");
2221: return -1;
2222: }
2223: chip = 0;
2224: for (i = 0; i < sizeof(ncr_chip_table)/sizeof(ncr_chip_table[0]); i++) {
2225: if (device_id != ncr_chip_table[i].device_id)
2226: continue;
2227: if (revision > ncr_chip_table[i].revision_id)
2228: continue;
2229: chip = &device->chip;
2230: memcpy(chip, &ncr_chip_table[i], sizeof(*chip));
2231: chip->revision_id = revision;
2232: break;
2233: }
2234:
2235: /*
2236: ** Ignore Symbios chips controlled by SISL RAID controller.
2237: ** This controller sets value 0x52414944 at RAM end - 16.
2238: */
2239: #if defined(__i386__) && !defined(SCSI_NCR_PCI_MEM_NOT_SUPPORTED)
2240: if (chip && (base_2 & PCI_BASE_ADDRESS_MEM_MASK)) {
2241: unsigned int ram_size, ram_val;
2242: u_long ram_ptr;
2243:
2244: if (chip->features & FE_RAM8K)
2245: ram_size = 8192;
2246: else
2247: ram_size = 4096;
2248:
2249: ram_ptr = remap_pci_mem(base_2 & PCI_BASE_ADDRESS_MEM_MASK,
2250: ram_size);
2251: if (ram_ptr) {
2252: ram_val = readl_raw(ram_ptr + ram_size - 16);
2253: unmap_pci_mem(ram_ptr, ram_size);
2254: if (ram_val == 0x52414944) {
2255: printk(NAME53C8XX": not initializing, "
2256: "driven by SISL RAID controller.\n");
2257: return -1;
2258: }
2259: }
2260: }
2261: #endif /* i386 and PCI MEMORY accessible */
2262:
2263: if (!chip) {
2264: printk(NAME53C8XX ": not initializing, device not supported\n");
2265: return -1;
2266: }
2267:
2268: #ifdef __powerpc__
2269: /*
2270: ** Fix-up for power/pc.
2271: ** Should not be performed by the driver.
2272: */
2273: if ((command & (PCI_COMMAND_IO | PCI_COMMAND_MEMORY))
2274: != (PCI_COMMAND_IO | PCI_COMMAND_MEMORY)) {
2275: printk(NAME53C8XX ": setting%s%s...\n",
2276: (command & PCI_COMMAND_IO) ? "" : " PCI_COMMAND_IO",
2277: (command & PCI_COMMAND_MEMORY) ? "" : " PCI_COMMAND_MEMORY");
2278: command |= (PCI_COMMAND_IO | PCI_COMMAND_MEMORY);
2279: pci_write_config_word(pdev, PCI_COMMAND, command);
2280: }
2281:
2282: #if LINUX_VERSION_CODE < LinuxVersionCode(2,2,0)
2283: if ( is_prep ) {
2284: if (io_port >= 0x10000000) {
2285: printk(NAME53C8XX ": reallocating io_port (Wacky IBM)");
2286: io_port = (io_port & 0x00FFFFFF) | 0x01000000;
2287: pci_write_config_dword(pdev,
2288: PCI_BASE_ADDRESS_0, io_port);
2289: }
2290: if (base >= 0x10000000) {
2291: printk(NAME53C8XX ": reallocating base (Wacky IBM)");
2292: base = (base & 0x00FFFFFF) | 0x01000000;
2293: pci_write_config_dword(pdev,
2294: PCI_BASE_ADDRESS_1, base);
2295: }
2296: if (base_2 >= 0x10000000) {
2297: printk(NAME53C8XX ": reallocating base2 (Wacky IBM)");
2298: base_2 = (base_2 & 0x00FFFFFF) | 0x01000000;
2299: pci_write_config_dword(pdev,
2300: PCI_BASE_ADDRESS_2, base_2);
2301: }
2302: }
2303: #endif
2304: #endif /* __powerpc__ */
2305:
2306: #if defined(__sparc__) && (LINUX_VERSION_CODE < LinuxVersionCode(2,3,0))
2307: /*
2308: * Severall fix-ups for sparc.
2309: *
2310: * Should not be performed by the driver, which is why all
2311: * this crap is cleaned up in 2.4.x
2312: */
2313:
2314: base = __pa(base);
2315: base_2 = __pa(base_2);
2316:
2317: if (!(command & PCI_COMMAND_MASTER)) {
2318: if (initverbose >= 2)
2319: printk("ncr53c8xx: setting PCI_COMMAND_MASTER bit (fixup)\n");
2320: command |= PCI_COMMAND_MASTER;
2321: pcibios_write_config_word(bus, device_fn, PCI_COMMAND, command);
2322: pcibios_read_config_word(bus, device_fn, PCI_COMMAND, &command);
2323: }
2324:
2325: if ((chip->features & FE_WRIE) && !(command & PCI_COMMAND_INVALIDATE)) {
2326: if (initverbose >= 2)
2327: printk("ncr53c8xx: setting PCI_COMMAND_INVALIDATE bit (fixup)\n");
2328: command |= PCI_COMMAND_INVALIDATE;
2329: pcibios_write_config_word(bus, device_fn, PCI_COMMAND, command);
2330: pcibios_read_config_word(bus, device_fn, PCI_COMMAND, &command);
2331: }
2332:
2333: if ((chip->features & FE_CLSE) && !cache_line_size) {
2334: /* PCI_CACHE_LINE_SIZE value is in 32-bit words. */
2335: cache_line_size = 64 / sizeof(u_int32);
2336: if (initverbose >= 2)
2337: printk("ncr53c8xx: setting PCI_CACHE_LINE_SIZE to %d (fixup)\n",
2338: cache_line_size);
2339: pcibios_write_config_byte(bus, device_fn,
2340: PCI_CACHE_LINE_SIZE, cache_line_size);
2341: pcibios_read_config_byte(bus, device_fn,
2342: PCI_CACHE_LINE_SIZE, &cache_line_size);
2343: }
2344:
2345: if (!latency_timer) {
2346: unsigned char min_gnt;
2347:
2348: pcibios_read_config_byte(bus, device_fn,
2349: PCI_MIN_GNT, &min_gnt);
2350: if (min_gnt == 0)
2351: latency_timer = 128;
2352: else
2353: latency_timer = ((min_gnt << 3) & 0xff);
2354: printk("ncr53c8xx: setting PCI_LATENCY_TIMER to %d bus clocks (fixup)\n", latency_timer);
2355: pcibios_write_config_byte(bus, device_fn,
2356: PCI_LATENCY_TIMER, latency_timer);
2357: pcibios_read_config_byte(bus, device_fn,
2358: PCI_LATENCY_TIMER, &latency_timer);
2359: }
2360: #endif /* __sparc__ && (LINUX_VERSION_CODE < LinuxVersionCode(2,3,0)) */
2361:
2362: #if defined(__i386__) && !defined(MODULE)
2363: if (!cache_line_size) {
2364: #if LINUX_VERSION_CODE < LinuxVersionCode(2,1,75)
2365: extern char x86;
2366: switch(x86) {
2367: #else
2368: switch(boot_cpu_data.x86) {
2369: #endif
2370: case 4: suggested_cache_line_size = 4; break;
2371: case 6:
2372: case 5: suggested_cache_line_size = 8; break;
2373: }
2374: }
2375: #endif /* __i386__ */
2376:
2377: /*
2378: ** Check availability of IO space, memory space.
2379: ** Enable master capability if not yet.
2380: **
2381: ** We shouldn't have to care about the IO region when
2382: ** we are using MMIO. But calling check_region() from
2383: ** both the ncr53c8xx and the sym53c8xx drivers prevents
2384: ** from attaching devices from the both drivers.
2385: ** If you have a better idea, let me know.
2386: */
2387: /* #ifdef SCSI_NCR_IOMAPPED */
2388: #if 1
2389: if (!(command & PCI_COMMAND_IO)) {
2390: printk(NAME53C8XX ": I/O base address (0x%lx) disabled.\n",
2391: (long) io_port);
2392: io_port = 0;
2393: }
2394: #endif
2395: if (!(command & PCI_COMMAND_MEMORY)) {
2396: printk(NAME53C8XX ": PCI_COMMAND_MEMORY not set.\n");
2397: base = 0;
2398: base_2 = 0;
2399: }
2400: io_port &= PCI_BASE_ADDRESS_IO_MASK;
2401: base &= PCI_BASE_ADDRESS_MEM_MASK;
2402: base_2 &= PCI_BASE_ADDRESS_MEM_MASK;
2403:
2404: /* #ifdef SCSI_NCR_IOMAPPED */
2405: #if 1
2406: if (io_port && check_region (io_port, 128)) {
2407: printk(NAME53C8XX ": IO region 0x%lx[0..127] is in use\n",
2408: (long) io_port);
2409: io_port = 0;
2410: }
2411: if (!io_port)
2412: return -1;
2413: #endif
2414: #ifndef SCSI_NCR_IOMAPPED
2415: if (!base) {
2416: printk(NAME53C8XX ": MMIO base address disabled.\n");
2417: return -1;
2418: }
2419: #endif
2420:
2421: /* The ncr53c8xx driver never did set the PCI parity bit. */
2422: /* Since setting this bit is known to trigger spurious MDPE */
2423: /* errors on some 895 controllers when noise on power lines is */
2424: /* too high, I donnot want to change previous ncr53c8xx driver */
2425: /* behaviour on that point (the sym53c8xx driver set this bit). */
2426: #if 0
2427: /*
2428: ** Set MASTER capable and PARITY bit, if not yet.
2429: */
2430: if ((command & (PCI_COMMAND_MASTER | PCI_COMMAND_PARITY))
2431: != (PCI_COMMAND_MASTER | PCI_COMMAND_PARITY)) {
2432: printk(NAME53C8XX ": setting%s%s...(fix-up)\n",
2433: (command & PCI_COMMAND_MASTER) ? "" : " PCI_COMMAND_MASTER",
2434: (command & PCI_COMMAND_PARITY) ? "" : " PCI_COMMAND_PARITY");
2435: command |= (PCI_COMMAND_MASTER | PCI_COMMAND_PARITY);
2436: pci_write_config_word(pdev, PCI_COMMAND, command);
2437: }
2438: #else
2439: /*
2440: ** Set MASTER capable if not yet.
2441: */
2442: if ((command & PCI_COMMAND_MASTER) != PCI_COMMAND_MASTER) {
2443: printk(NAME53C8XX ": setting PCI_COMMAND_MASTER...(fix-up)\n");
2444: command |= PCI_COMMAND_MASTER;
2445: pci_write_config_word(pdev, PCI_COMMAND, command);
2446: }
2447: #endif
2448:
2449: /*
2450: ** Fix some features according to driver setup.
2451: */
2452: if (!(driver_setup.special_features & 1))
2453: chip->features &= ~FE_SPECIAL_SET;
2454: else {
2455: if (driver_setup.special_features & 2)
2456: chip->features &= ~FE_WRIE;
2457: if (driver_setup.special_features & 4)
2458: chip->features &= ~FE_NOPM;
2459: }
2460: if (driver_setup.ultra_scsi < 2 && (chip->features & FE_ULTRA2)) {
2461: chip->features |= FE_ULTRA;
2462: chip->features &= ~FE_ULTRA2;
2463: }
2464: if (driver_setup.ultra_scsi < 1)
2465: chip->features &= ~FE_ULTRA;
2466: if (!driver_setup.max_wide)
2467: chip->features &= ~FE_WIDE;
2468:
2469: /*
2470: ** Some features are required to be enabled in order to
2471: ** work around some chip problems. :) ;)
2472: ** (ITEM 12 of a DEL about the 896 I haven't yet).
2473: ** We must ensure the chip will use WRITE AND INVALIDATE.
2474: ** The revision number limit is for now arbitrary.
2475: */
2476: if (device_id == PCI_DEVICE_ID_NCR_53C896 && revision <= 0x10) {
2477: chip->features |= (FE_WRIE | FE_CLSE);
2478: pci_fix_up |= 3; /* Force appropriate PCI fix-up */
2479: }
2480:
2481: #ifdef SCSI_NCR_PCI_FIX_UP_SUPPORT
2482: /*
2483: ** Try to fix up PCI config according to wished features.
2484: */
2485: if ((pci_fix_up & 1) && (chip->features & FE_CLSE) &&
2486: !cache_line_size && suggested_cache_line_size) {
2487: cache_line_size = suggested_cache_line_size;
2488: pci_write_config_byte(pdev,
2489: PCI_CACHE_LINE_SIZE, cache_line_size);
2490: printk(NAME53C8XX ": PCI_CACHE_LINE_SIZE set to %d (fix-up).\n",
2491: cache_line_size);
2492: }
2493:
2494: if ((pci_fix_up & 2) && cache_line_size &&
2495: (chip->features & FE_WRIE) && !(command & PCI_COMMAND_INVALIDATE)) {
2496: printk(NAME53C8XX": setting PCI_COMMAND_INVALIDATE (fix-up)\n");
2497: command |= PCI_COMMAND_INVALIDATE;
2498: pci_write_config_word(pdev, PCI_COMMAND, command);
2499: }
2500:
2501: /*
2502: ** Tune PCI LATENCY TIMER according to burst max length transfer.
2503: ** (latency timer >= burst length + 6, we add 10 to be quite sure)
2504: */
2505:
2506: if (chip->burst_max && (latency_timer == 0 || (pci_fix_up & 4))) {
2507: u_char lt = (1 << chip->burst_max) + 6 + 10;
2508: if (latency_timer < lt) {
2509: printk(NAME53C8XX
2510: ": changing PCI_LATENCY_TIMER from %d to %d.\n",
2511: (int) latency_timer, (int) lt);
2512: latency_timer = lt;
2513: pci_write_config_byte(pdev,
2514: PCI_LATENCY_TIMER, latency_timer);
2515: }
2516: }
2517:
2518: #endif /* SCSI_NCR_PCI_FIX_UP_SUPPORT */
2519:
2520: /*
2521: ** Initialise ncr_device structure with items required by ncr_attach.
2522: */
2523: device->pdev = pdev;
2524: device->slot.bus = PciBusNumber(pdev);
2525: device->slot.device_fn = PciDeviceFn(pdev);
2526: device->slot.base = base;
2527: device->slot.base_2 = base_2;
2528: device->slot.io_port = io_port;
2529: device->slot.irq = irq;
2530: device->attach_done = 0;
2531:
2532: return 0;
2533: }
2534:
2535: /*===================================================================
2536: **
2537: ** Detect all 53c8xx hosts and then attach them.
2538: **
2539: ** If we are using NVRAM, once all hosts are detected, we need to
2540: ** check any NVRAM for boot order in case detect and boot order
2541: ** differ and attach them using the order in the NVRAM.
2542: **
2543: ** If no NVRAM is found or data appears invalid attach boards in
2544: ** the the order they are detected.
2545: **
2546: **===================================================================
2547: */
2548: static int __init
2549: sym53c8xx__detect(Scsi_Host_Template *tpnt, u_short ncr_chip_ids[], int chips)
2550: {
2551: pcidev_t pcidev;
2552: int i, j, hosts, count;
2553: int attach_count = 0;
2554: ncr_device *devtbl, *devp;
2555: #ifdef SCSI_NCR_NVRAM_SUPPORT
2556: ncr_nvram nvram0, nvram, *nvp;
2557: #endif
2558:
2559: /*
2560: ** PCI is required.
2561: */
2562: if (!pci_present())
2563: return 0;
2564:
2565: #ifdef SCSI_NCR_DEBUG_INFO_SUPPORT
2566: ncr_debug = driver_setup.debug;
2567: #endif
2568: if (initverbose >= 2)
2569: ncr_print_driver_setup();
2570:
2571: /*
2572: ** Allocate the device table since we donnot want to
2573: ** overflow the kernel stack.
2574: ** 1 x 4K PAGE is enough for more than 40 devices for i386.
2575: */
2576: devtbl = m_calloc(PAGE_SIZE, "devtbl");
2577: if (!devtbl)
2578: return 0;
2579:
2580: /*
2581: ** Detect all NCR PQS/PDS memory controllers.
2582: */
2583: #ifdef SCSI_NCR_PQS_PDS_SUPPORT
2584: ncr_detect_pqs_pds();
2585: #endif
2586:
2587: /*
2588: ** Detect all 53c8xx hosts.
2589: ** Save the first Symbios NVRAM content if any
2590: ** for the boot order.
2591: */
2592: hosts = PAGE_SIZE / sizeof(*devtbl);
2593: #ifdef SCSI_NCR_NVRAM_SUPPORT
2594: nvp = (driver_setup.use_nvram & 0x1) ? &nvram0 : 0;
2595: #endif
2596: j = 0;
2597: count = 0;
2598: pcidev = PCIDEV_NULL;
2599: while (1) {
2600: char *msg = "";
2601: if (count >= hosts)
2602: break;
2603: if (j >= chips)
2604: break;
2605: i = driver_setup.reverse_probe ? chips - 1 - j : j;
2606: pcidev = pci_find_device(PCI_VENDOR_ID_NCR, ncr_chip_ids[i],
2607: pcidev);
2608: if (pcidev == PCIDEV_NULL) {
2609: ++j;
2610: continue;
2611: }
2612: /* Some HW as the HP LH4 may report twice PCI devices */
2613: for (i = 0; i < count ; i++) {
2614: if (devtbl[i].slot.bus == PciBusNumber(pcidev) &&
2615: devtbl[i].slot.device_fn == PciDeviceFn(pcidev))
2616: break;
2617: }
2618: if (i != count) /* Ignore this device if we already have it */
2619: continue;
2620: devp = &devtbl[count];
2621: devp->host_id = driver_setup.host_id;
2622: devp->attach_done = 0;
2623: if (sym53c8xx_pci_init(tpnt, pcidev, devp)) {
2624: continue;
2625: }
2626: ++count;
2627: #ifdef SCSI_NCR_NVRAM_SUPPORT
2628: if (nvp) {
2629: ncr_get_nvram(devp, nvp);
2630: switch(nvp->type) {
2631: case SCSI_NCR_SYMBIOS_NVRAM:
2632: /*
2633: * Switch to the other nvram buffer, so that
2634: * nvram0 will contain the first Symbios
2635: * format NVRAM content with boot order.
2636: */
2637: nvp = &nvram;
2638: msg = "with Symbios NVRAM";
2639: break;
2640: case SCSI_NCR_TEKRAM_NVRAM:
2641: msg = "with Tekram NVRAM";
2642: break;
2643: }
2644: }
2645: #endif
2646: #ifdef SCSI_NCR_PQS_PDS_SUPPORT
2647: if (devp->pqs_pds)
2648: msg = "(NCR PQS/PDS)";
2649: #endif
2650: printk(KERN_INFO NAME53C8XX ": 53c%s detected %s\n",
2651: devp->chip.name, msg);
2652: }
2653:
2654: /*
2655: ** If we have found a SYMBIOS NVRAM, use first the NVRAM boot
2656: ** sequence as device boot order.
2657: ** check devices in the boot record against devices detected.
2658: ** attach devices if we find a match. boot table records that
2659: ** do not match any detected devices will be ignored.
2660: ** devices that do not match any boot table will not be attached
2661: ** here but will attempt to be attached during the device table
2662: ** rescan.
2663: */
2664: #ifdef SCSI_NCR_NVRAM_SUPPORT
2665: if (!nvp || nvram0.type != SCSI_NCR_SYMBIOS_NVRAM)
2666: goto next;
2667: for (i = 0; i < 4; i++) {
2668: Symbios_host *h = &nvram0.data.Symbios.host[i];
2669: for (j = 0 ; j < count ; j++) {
2670: devp = &devtbl[j];
2671: if (h->device_fn != devp->slot.device_fn ||
2672: h->bus_nr != devp->slot.bus ||
2673: h->device_id != devp->chip.device_id)
2674: continue;
2675: if (devp->attach_done)
2676: continue;
2677: if (h->flags & SYMBIOS_INIT_SCAN_AT_BOOT) {
2678: ncr_get_nvram(devp, nvp);
2679: if (!ncr_attach (tpnt, attach_count, devp))
2680: attach_count++;
2681: }
2682: #if 0 /* Restore previous behaviour of ncr53c8xx driver */
2683: else if (!(driver_setup.use_nvram & 0x80))
2684: printk(KERN_INFO NAME53C8XX
2685: ": 53c%s state OFF thus not attached\n",
2686: devp->chip.name);
2687: #endif
2688: else
2689: continue;
2690:
2691: devp->attach_done = 1;
2692: break;
2693: }
2694: }
2695: next:
2696: #endif
2697:
2698: /*
2699: ** Rescan device list to make sure all boards attached.
2700: ** Devices without boot records will not be attached yet
2701: ** so try to attach them here.
2702: */
2703: for (i= 0; i < count; i++) {
2704: devp = &devtbl[i];
2705: if (!devp->attach_done) {
2706: #ifdef SCSI_NCR_NVRAM_SUPPORT
2707: ncr_get_nvram(devp, nvp);
2708: #endif
2709: if (!ncr_attach (tpnt, attach_count, devp))
2710: attach_count++;
2711: }
2712: }
2713:
2714: m_free(devtbl, PAGE_SIZE, "devtbl");
2715:
2716: return attach_count;
2717: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.