![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ncr53c8xx.c 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 ncr53c8xx.c CVS log | Up to [GnuMach] / Gnu-Mach / linux / src / drivers / scsi |
1.1 root 1: /******************************************************************************
2: ** Device driver for the PCI-SCSI NCR538XX controller family.
3: **
4: ** Copyright (C) 1994 Wolfgang Stanglmeier
5: **
6: ** This program is free software; you can redistribute it and/or modify
7: ** it under the terms of the GNU General Public License as published by
8: ** the Free Software Foundation; either version 2 of the License, or
9: ** (at your option) any later version.
10: **
11: ** This program is distributed in the hope that it will be useful,
12: ** but WITHOUT ANY WARRANTY; without even the implied warranty of
13: ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14: ** GNU General Public License for more details.
15: **
16: ** You should have received a copy of the GNU General Public License
17: ** along with this program; if not, write to the Free Software
18: ** Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19: **
20: **-----------------------------------------------------------------------------
21: **
22: ** This driver has been ported to Linux from the FreeBSD NCR53C8XX driver
23: ** and is currently maintained by
24: **
25: ** Gerard Roudier <[email protected]>
26: **
27: ** Being given that this driver originates from the FreeBSD version, and
28: ** in order to keep synergy on both, any suggested enhancements and corrections
29: ** received on Linux are automatically a potential candidate for the FreeBSD
30: ** version.
31: **
32: ** The original driver has been written for 386bsd and FreeBSD by
33: ** Wolfgang Stanglmeier <[email protected]>
34: ** Stefan Esser <[email protected]>
35: **
36: ** And has been ported to NetBSD by
37: ** Charles M. Hannum <[email protected]>
38: **
39: **-----------------------------------------------------------------------------
40: **
41: ** Brief history
42: **
43: ** December 10 1995 by Gerard Roudier:
44: ** Initial port to Linux.
45: **
46: ** June 23 1996 by Gerard Roudier:
47: ** Support for 64 bits architectures (Alpha).
48: **
49: ** November 30 1996 by Gerard Roudier:
50: ** Support for Fast-20 scsi.
51: ** Support for large DMA fifo and 128 dwords bursting.
52: **
53: ** February 27 1997 by Gerard Roudier:
54: ** Support for Fast-40 scsi.
55: ** Support for on-Board RAM.
56: **
57: ** May 3 1997 by Gerard Roudier:
58: ** Full support for scsi scripts instructions pre-fetching.
59: **
60: ** May 19 1997 by Richard Waltham <[email protected]>:
61: ** Support for NvRAM detection and reading.
62: **
63: ** August 18 1997 by Cort <[email protected]>:
64: ** Support for Power/PC (Big Endian).
65: **
66: *******************************************************************************
67: */
68:
69: /*
70: ** 30 January 1998, version 2.5f.1
71: **
72: ** Supported SCSI-II features:
73: ** Synchronous negotiation
74: ** Wide negotiation (depends on the NCR Chip)
75: ** Enable disconnection
76: ** Tagged command queuing
77: ** Parity checking
78: ** Etc...
79: **
80: ** Supported NCR chips:
81: ** 53C810 (8 bits, Fast SCSI-2, no rom BIOS)
82: ** 53C815 (8 bits, Fast SCSI-2, on board rom BIOS)
83: ** 53C820 (Wide, Fast SCSI-2, no rom BIOS)
84: ** 53C825 (Wide, Fast SCSI-2, on board rom BIOS)
85: ** 53C860 (8 bits, Fast 20, no rom BIOS)
86: ** 53C875 (Wide, Fast 20, on board rom BIOS)
87: ** 53C895 (Wide, Fast 40, on board rom BIOS)
88: **
89: ** Other features:
90: ** Memory mapped IO (linux-1.3.X and above only)
91: ** Module
92: ** Shared IRQ (since linux-1.3.72)
93: */
94:
95: #define SCSI_NCR_DEBUG_FLAGS (0)
96:
97: #define NCR_GETCC_WITHMSG
98:
99: /*==========================================================
100: **
101: ** Include files
102: **
103: **==========================================================
104: */
105:
106: #define LinuxVersionCode(v, p, s) (((v)<<16)+((p)<<8)+(s))
107:
108: #ifdef MODULE
109: #include <linux/module.h>
110: #endif
111:
112: #include <asm/dma.h>
113: #include <asm/io.h>
114: #include <asm/system.h>
115: #include <linux/delay.h>
116: #include <linux/signal.h>
117: #include <linux/sched.h>
118: #include <linux/errno.h>
119: #include <linux/bios32.h>
120: #include <linux/pci.h>
121: #include <linux/string.h>
122: #include <linux/malloc.h>
123: #include <linux/mm.h>
124: #include <linux/ioport.h>
125: #include <linux/time.h>
126: #include <linux/timer.h>
127: #include <linux/stat.h>
128:
129: #include <linux/version.h>
130: #if LINUX_VERSION_CODE >= LinuxVersionCode(1,3,0)
131: #include <linux/blk.h>
132: #else
133: #include "../block/blk.h"
134: #endif
135:
136: #if LINUX_VERSION_CODE >= LinuxVersionCode(2,1,35)
137: #include <linux/init.h>
138: #else
139: #ifndef __initdata
140: #define __initdata
141: #endif
142: #ifndef __initfunc
143: #define __initfunc(__arginit) __arginit
144: #endif
145: #endif
146:
147: #include "scsi.h"
148: #include "hosts.h"
149: #include "constants.h"
150: #include "sd.h"
151:
152: #include <linux/types.h>
153:
154: /*
155: ** Define the BSD style u_int32 type
156: */
157: typedef u32 u_int32;
158:
159: #include "ncr53c8xx.h"
160:
161: /*==========================================================
162: **
163: ** Configuration and Debugging
164: **
165: **==========================================================
166: */
167:
168: /*
169: ** SCSI address of this device.
170: ** The boot routines should have set it.
171: ** If not, use this.
172: */
173:
174: #ifndef SCSI_NCR_MYADDR
175: #define SCSI_NCR_MYADDR (7)
176: #endif
177:
178: /*
179: ** The maximum number of tags per logic unit.
180: ** Used only for disk devices that support tags.
181: */
182:
183: #ifndef SCSI_NCR_MAX_TAGS
184: #define SCSI_NCR_MAX_TAGS (4)
185: #endif
186:
187: /*
188: ** Number of targets supported by the driver.
189: ** n permits target numbers 0..n-1.
190: ** Default is 7, meaning targets #0..#6.
191: ** #7 .. is myself.
192: */
193:
194: #ifdef SCSI_NCR_MAX_TARGET
195: #define MAX_TARGET (SCSI_NCR_MAX_TARGET)
196: #else
197: #define MAX_TARGET (16)
198: #endif
199:
200: /*
201: ** Number of logic units supported by the driver.
202: ** n enables logic unit numbers 0..n-1.
203: ** The common SCSI devices require only
204: ** one lun, so take 1 as the default.
205: */
206:
207: #ifdef SCSI_NCR_MAX_LUN
208: #define MAX_LUN SCSI_NCR_MAX_LUN
209: #else
210: #define MAX_LUN (1)
211: #endif
212:
213: /*
214: ** Asynchronous pre-scaler (ns). Shall be 40
215: */
216:
217: #ifndef SCSI_NCR_MIN_ASYNC
218: #define SCSI_NCR_MIN_ASYNC (40)
219: #endif
220:
221: /*
222: ** The maximum number of jobs scheduled for starting.
223: ** There should be one slot per target, and one slot
224: ** for each tag of each target in use.
225: ** The calculation below is actually quite silly ...
226: */
227:
228: #ifdef SCSI_NCR_CAN_QUEUE
229: #define MAX_START (SCSI_NCR_CAN_QUEUE + 4)
230: #else
231: #define MAX_START (MAX_TARGET + 7 * SCSI_NCR_MAX_TAGS)
232: #endif
233:
234: /*
235: ** The maximum number of segments a transfer is split into.
236: */
237:
238: #define MAX_SCATTER (SCSI_NCR_MAX_SCATTER)
239:
240: /*
241: ** Io mapped or memory mapped.
242: */
243:
244: #if defined(SCSI_NCR_IOMAPPED)
245: #define NCR_IOMAPPED
246: #endif
247:
248: /*
249: ** other
250: */
251:
252: #define NCR_SNOOP_TIMEOUT (1000000)
253:
254: /*==========================================================
255: **
256: ** Defines for Linux.
257: **
258: ** Linux and Bsd kernel functions are quite different.
259: ** These defines allow a minimum change of the original
260: ** code.
261: **
262: **==========================================================
263: */
264:
265: /*
266: ** Obvious definitions
267: */
268:
269: #define printf printk
270: #define u_char unsigned char
271: #define u_short unsigned short
272: #define u_int unsigned int
273: #define u_long unsigned long
274:
275: typedef u_long vm_offset_t;
276: typedef int vm_size_t;
277:
278: #define bcopy(s, d, n) memcpy((d), (s), (n))
279: #define bzero(d, n) memset((d), 0, (n))
280:
281: #ifndef offsetof
282: #define offsetof(t, m) ((size_t) (&((t *)0)->m))
283: #endif
284:
285: /*
286: ** Address translation
287: **
288: ** On Linux 1.3.X, virt_to_bus() must be used to translate
289: ** virtual memory addresses of the kernel data segment into
290: ** IO bus adresses.
291: ** On i386 architecture, IO bus addresses match the physical
292: ** addresses. But on other architectures they can be different.
293: ** In the original Bsd driver, vtophys() is called to translate
294: ** data addresses to IO bus addresses. In order to minimize
295: ** change, I decide to define vtophys() as virt_to_bus().
296: */
297:
298: #if LINUX_VERSION_CODE >= LinuxVersionCode(1,3,0)
299: #define vtophys(p) virt_to_bus(p)
300:
301: /*
302: ** Memory mapped IO
303: **
304: ** Since linux-2.1, we must use ioremap() to map the io memory space.
305: ** iounmap() to unmap it. That allows portability.
306: ** Linux 1.3.X and 2.0.X allow to remap physical pages addresses greater
307: ** than the highest physical memory address to kernel virtual pages with
308: ** vremap() / vfree(). That was not portable but worked with i386
309: ** architecture.
310: */
311:
312: #ifndef NCR_IOMAPPED
313: __initfunc(
314: static vm_offset_t remap_pci_mem(u_long base, u_long size)
315: )
316: {
317: u_long page_base = ((u_long) base) & PAGE_MASK;
318: u_long page_offs = ((u_long) base) - page_base;
319: #if LINUX_VERSION_CODE >= LinuxVersionCode(2,1,0)
320: u_long page_remapped = (u_long) ioremap(page_base, page_offs+size);
321: #else
322: u_long page_remapped = (u_long) vremap(page_base, page_offs+size);
323: #endif
324:
325: return (vm_offset_t) (page_remapped ? (page_remapped + page_offs) : 0UL);
326: }
327:
328: __initfunc(
329: static void unmap_pci_mem(vm_offset_t vaddr, u_long size)
330: )
331: {
332: if (vaddr)
333: #if LINUX_VERSION_CODE >= LinuxVersionCode(2,1,0)
334: iounmap((void *) (vaddr & PAGE_MASK));
335: #else
336: vfree((void *) (vaddr & PAGE_MASK));
337: #endif
338: }
339: #endif /* !NCR_IOMAPPED */
340:
341: #else /* linux-1.2.13 */
342:
343: /*
344: ** Linux 1.2.X assumes that addresses (virtual, physical, bus)
345: ** are the same.
346: **
347: ** I have not found how to do MMIO. It seems that only processes can
348: ** map high physical pages to virtual (Xservers can do MMIO).
349: */
350:
351: #define vtophys(p) ((u_long) (p))
352: #endif
353:
354: /*
355: ** Insert a delay in micro-seconds.
356: */
357:
358: static void DELAY(long us)
359: {
360: for (;us>1000;us-=1000) udelay(1000);
361: if (us) udelay(us);
362: }
363:
364: /*
365: ** Internal data structure allocation.
366: **
367: ** Linux scsi memory poor pool is adjusted for the need of
368: ** middle-level scsi driver.
369: ** We allocate our control blocks in the kernel memory pool
370: ** to avoid scsi pool shortage.
371: ** I notice that kmalloc() returns NULL during host attach under
372: ** Linux 1.2.13. But this ncr driver is reliable enough to
373: ** accomodate with this joke.
374: **
375: ** kmalloc() only ensure 8 bytes boundary alignment.
376: ** The NCR need better alignment for cache line bursting.
377: ** The global header is moved betewen the NCB and CCBs and need
378: ** origin and destination addresses to have same lower four bits.
379: **
380: ** We use 32 boundary alignment for NCB and CCBs and offset multiple
381: ** of 32 for global header fields. That's too much but at least enough.
382: */
383:
384: #define ALIGN_SIZE(shift) (1UL << shift)
385: #define ALIGN_MASK(shift) (~(ALIGN_SIZE(shift)-1))
386:
387: #define NCB_ALIGN_SHIFT 5
388: #define CCB_ALIGN_SHIFT 5
389: #define LCB_ALIGN_SHIFT 5
390: #define SCR_ALIGN_SHIFT 5
391:
392: #define NCB_ALIGN_SIZE ALIGN_SIZE(NCB_ALIGN_SHIFT)
393: #define NCB_ALIGN_MASK ALIGN_MASK(NCB_ALIGN_SHIFT)
394: #define CCB_ALIGN_SIZE ALIGN_SIZE(CCB_ALIGN_SHIFT)
395: #define CCB_ALIGN_MASK ALIGN_MASK(CCB_ALIGN_SHIFT)
396: #define SCR_ALIGN_SIZE ALIGN_SIZE(SCR_ALIGN_SHIFT)
397: #define SCR_ALIGN_MASK ALIGN_MASK(SCR_ALIGN_SHIFT)
398:
399: static void *m_alloc(int size, int a_shift)
400: {
401: u_long addr;
402: void *ptr;
403: u_long a_size, a_mask;
404:
405: if (a_shift < 3)
406: a_shift = 3;
407:
408: a_size = ALIGN_SIZE(a_shift);
409: a_mask = ALIGN_MASK(a_shift);
410:
411: ptr = (void *) kmalloc(size + a_size, GFP_ATOMIC);
412: if (ptr) {
413: addr = (((u_long) ptr) + a_size) & a_mask;
414: *((void **) (addr - sizeof(void *))) = ptr;
415: ptr = (void *) addr;
416: }
417:
418: return ptr;
419: }
420:
421: #ifdef MODULE
422: static void m_free(void *ptr, int size)
423: {
424: u_long addr;
425:
426: if (ptr) {
427: addr = (u_long) ptr;
428: ptr = *((void **) (addr - sizeof(void *)));
429:
430: kfree(ptr);
431: }
432: }
433: #endif
434:
435: /*
436: ** Transfer direction
437: **
438: ** Low-level scsi drivers under Linux do not receive the expected
439: ** data transfer direction from upper scsi drivers.
440: ** The driver will only check actual data direction for common
441: ** scsi opcodes. Other ones may cause problem, since they may
442: ** depend on device type or be vendor specific.
443: ** I would prefer to never trust the device for data direction,
444: ** but that is not possible.
445: **
446: ** The original driver requires the expected direction to be known.
447: ** The Linux version of the driver has been enhanced in order to
448: ** be able to transfer data in the direction choosen by the target.
449: */
450:
451: #define XferNone 0
452: #define XferIn 1
453: #define XferOut 2
454: #define XferBoth 3
455: static int guess_xfer_direction(int opcode);
456:
457: /*
458: ** Head of list of NCR boards
459: **
460: ** For kernel version < 1.3.70, host is retrieved by its irq level.
461: ** For later kernels, the internal host control block address
462: ** (struct ncb) is used as device id parameter of the irq stuff.
463: */
464:
465: static struct Scsi_Host *first_host = NULL;
466: static Scsi_Host_Template *the_template = NULL;
467:
468:
469: /*
470: ** /proc directory entry and proc_info function
471: */
472:
473: #if LINUX_VERSION_CODE >= LinuxVersionCode(1,3,0)
474: struct proc_dir_entry proc_scsi_ncr53c8xx = {
475: PROC_SCSI_NCR53C8XX, 9, "ncr53c8xx",
476: S_IFDIR | S_IRUGO | S_IXUGO, 2
477: };
478: # ifdef SCSI_NCR_PROC_INFO_SUPPORT
479: int ncr53c8xx_proc_info(char *buffer, char **start, off_t offset,
480: int length, int hostno, int func);
481: # endif
482: #endif
483:
484: /*
485: ** Table of target capabilities.
486: **
487: ** This bitmap is anded with the byte 7 of inquiry data on completion of
488: ** INQUIRY command.
489: ** The driver never see zeroed bits and will ignore the corresponding
490: ** capabilities of the target.
491: */
492:
493: static struct {
494: unsigned char and_map[MAX_TARGET];
495: } target_capabilities[SCSI_NCR_MAX_HOST] = { NCR53C8XX_TARGET_CAPABILITIES };
496:
497: /*
498: ** Driver setup.
499: **
500: ** This structure is initialized from linux config options.
501: ** It can be overridden at boot-up by the boot command line.
502: */
503: struct ncr_driver_setup {
504: unsigned master_parity : 1;
505: unsigned scsi_parity : 1;
506: unsigned disconnection : 1;
507: unsigned special_features : 2;
508: unsigned ultra_scsi : 2;
509: unsigned force_sync_nego: 1;
510: unsigned reverse_probe: 1;
511: unsigned pci_fix_up: 4;
512: u_char use_nvram;
513: u_char verbose;
514: u_char default_tags;
515: u_short default_sync;
516: u_short debug;
517: u_char burst_max;
518: u_char led_pin;
519: u_char max_wide;
520: u_char settle_delay;
521: u_char diff_support;
522: u_char irqm;
523: u_char bus_check;
524: };
525:
526: static struct ncr_driver_setup
527: driver_setup = SCSI_NCR_DRIVER_SETUP;
528:
529: #ifdef SCSI_NCR_BOOT_COMMAND_LINE_SUPPORT
530: static struct ncr_driver_setup
531: driver_safe_setup __initdata = SCSI_NCR_DRIVER_SAFE_SETUP;
532: #ifdef MODULE
533: char *ncr53c8xx = 0; /* command line passed by insmod */
534: #endif
535: #endif
536:
537: /*
538: ** Other Linux definitions
539: */
540:
541: #define ScsiResult(host_code, scsi_code) (((host_code) << 16) + ((scsi_code) & 0x7f))
542:
543: #if LINUX_VERSION_CODE >= LinuxVersionCode(2,0,0)
544: static void ncr53c8xx_select_queue_depths(struct Scsi_Host *host, struct scsi_device *devlist);
545: #endif
546:
547: #if LINUX_VERSION_CODE >= LinuxVersionCode(1,3,70)
548: static void ncr53c8xx_intr(int irq, void *dev_id, struct pt_regs * regs);
549: #else
550: static void ncr53c8xx_intr(int irq, struct pt_regs * regs);
551: #endif
552:
553: static void ncr53c8xx_timeout(unsigned long np);
554:
555: #define initverbose (driver_setup.verbose)
556: #define bootverbose (np->verbose)
557:
558: #ifdef SCSI_NCR_NVRAM_SUPPORT
559: /*
560: ** Symbios NvRAM data format
561: */
562: #define SYMBIOS_NVRAM_SIZE 368
563: #define SYMBIOS_NVRAM_ADDRESS 0x100
564:
565: struct Symbios_nvram {
566: /* Header 6 bytes */
567: u_short start_marker; /* 0x0000 */
568: u_short byte_count; /* excluding header/trailer */
569: u_short checksum;
570:
571: /* Controller set up 20 bytes */
572: u_short word0; /* 0x3000 */
573: u_short word2; /* 0x0000 */
574: u_short word4; /* 0x0000 */
575: u_short flags;
576: #define SYMBIOS_SCAM_ENABLE (1)
577: #define SYMBIOS_PARITY_ENABLE (1<<1)
578: #define SYMBIOS_VERBOSE_MSGS (1<<2)
579: u_short flags1;
580: #define SYMBIOS_SCAN_HI_LO (1)
581: u_short word10; /* 0x00 */
582: u_short flags3; /* 0x00 */
583: #define SYMBIOS_REMOVABLE_FLAGS (3) /* 0=none, 1=bootable, 2=all */
584: u_char host_id;
585: u_char byte15; /* 0x04 */
586: u_short word16; /* 0x0410 */
587: u_short word18; /* 0x0000 */
588:
589: /* Boot order 14 bytes * 4 */
590: struct Symbios_host{
591: u_char word0; /* 0x0004:ok / 0x0000:nok */
592: u_short device_id; /* PCI device id */
593: u_short vendor_id; /* PCI vendor id */
594: u_char byte6; /* 0x00 */
595: u_char device_fn; /* PCI device/function number << 3*/
596: u_short word8;
597: u_short flags;
598: #define SYMBIOS_INIT_SCAN_AT_BOOT (1)
599: u_short io_port; /* PCI io_port address */
600: } host[4];
601:
602: /* Targets 8 bytes * 16 */
603: struct Symbios_target {
604: u_short flags;
605: #define SYMBIOS_DISCONNECT_ENABLE (1)
606: #define SYMBIOS_SCAN_AT_BOOT_TIME (1<<1)
607: #define SYMBIOS_SCAN_LUNS (1<<2)
608: #define SYMBIOS_QUEUE_TAGS_ENABLED (1<<3)
609: u_char bus_width; /* 0x08/0x10 */
610: u_char sync_offset;
611: u_char sync_period; /* 4*period factor */
612: u_char byte6; /* 0x00 */
613: u_short timeout;
614: } target[16];
615: u_char spare_devices[19*8];
616: u_char trailer[6]; /* 0xfe 0xfe 0x00 0x00 0x00 0x00 */
617: };
618: typedef struct Symbios_nvram Symbios_nvram;
619: typedef struct Symbios_host Symbios_host;
620: typedef struct Symbios_target Symbios_target;
621:
622: /*
623: ** Tekram NvRAM data format.
624: */
625: #define TEKRAM_NVRAM_SIZE 64
626: #define TEKRAM_NVRAM_ADDRESS 0
627:
628: struct Tekram_nvram {
629: struct Tekram_target {
630: u_char flags;
631: #define TEKRAM_PARITY_CHECK (1)
632: #define TEKRAM_SYNC_NEGO (1<<1)
633: #define TEKRAM_DISCONNECT_ENABLE (1<<2)
634: #define TEKRAM_START_CMD (1<<3)
635: #define TEKRAM_TAGGED_COMMANDS (1<<4)
636: #define TEKRAM_WIDE_NEGO (1<<5)
637: u_char sync_index;
638: u_short word2;
639: } target[16];
640: u_char host_id;
641: u_char flags;
642: #define TEKRAM_MORE_THAN_2_DRIVES (1)
643: #define TEKRAM_DRIVES_SUP_1GB (1<<1)
644: #define TEKRAM_RESET_ON_POWER_ON (1<<2)
645: #define TEKRAM_ACTIVE_NEGATION (1<<3)
646: #define TEKRAM_IMMEDIATE_SEEK (1<<4)
647: #define TEKRAM_SCAN_LUNS (1<<5)
648: #define TEKRAM_REMOVABLE_FLAGS (3<<6) /* 0: disable; 1: boot device; 2:all */
649: u_char boot_delay_index;
650: u_char max_tags_index;
651: u_short flags1;
652: #define TEKRAM_F2_F6_ENABLED (1)
653: u_short spare[29];
654: };
655: typedef struct Tekram_nvram Tekram_nvram;
656: typedef struct Tekram_target Tekram_target;
657:
658: static u_char Tekram_sync[12] __initdata = {25,31,37,43,50,62,75,125,12,15,18,21};
659:
660: #endif /* SCSI_NCR_NVRAM_SUPPORT */
661:
662: /*
663: ** Structures used by ncr53c8xx_detect/ncr53c8xx_pci_init to
664: ** transmit device configuration to the ncr_attach() function.
665: */
666: typedef struct {
667: int bus;
668: u_char device_fn;
669: u_int base;
670: u_int base_2;
671: u_int io_port;
672: int irq;
673: /* port and reg fields to use INB, OUTB macros */
674: u_int port;
675: volatile struct ncr_reg *reg;
676: } ncr_slot;
677:
678: typedef struct {
679: int type;
680: #define SCSI_NCR_SYMBIOS_NVRAM (1)
681: #define SCSI_NCR_TEKRAM_NVRAM (2)
682: #ifdef SCSI_NCR_NVRAM_SUPPORT
683: union {
684: Symbios_nvram Symbios;
685: Tekram_nvram Tekram;
686: } data;
687: #endif
688: } ncr_nvram;
689:
690: /*
691: ** Structure used by ncr53c8xx_detect/ncr53c8xx_pci_init
692: ** to save data on each detected board for ncr_attach().
693: */
694: typedef struct {
695: ncr_slot slot;
696: ncr_chip chip;
697: ncr_nvram *nvram;
698: int attach_done;
699: } ncr_device;
700:
701: /*==========================================================
702: **
703: ** Debugging tags
704: **
705: **==========================================================
706: */
707:
708: #define DEBUG_ALLOC (0x0001)
709: #define DEBUG_PHASE (0x0002)
710: #define DEBUG_POLL (0x0004)
711: #define DEBUG_QUEUE (0x0008)
712: #define DEBUG_RESULT (0x0010)
713: #define DEBUG_SCATTER (0x0020)
714: #define DEBUG_SCRIPT (0x0040)
715: #define DEBUG_TINY (0x0080)
716: #define DEBUG_TIMING (0x0100)
717: #define DEBUG_NEGO (0x0200)
718: #define DEBUG_TAGS (0x0400)
719: #define DEBUG_FREEZE (0x0800)
720: #define DEBUG_RESTART (0x1000)
721:
722: /*
723: ** Enable/Disable debug messages.
724: ** Can be changed at runtime too.
725: */
726:
727: #ifdef SCSI_NCR_DEBUG_INFO_SUPPORT
728: #define DEBUG_FLAGS ncr_debug
729: #else
730: #define DEBUG_FLAGS SCSI_NCR_DEBUG_FLAGS
731: #endif
732:
733:
734:
735: /*==========================================================
736: **
737: ** assert ()
738: **
739: **==========================================================
740: **
741: ** modified copy from 386bsd:/usr/include/sys/assert.h
742: **
743: **----------------------------------------------------------
744: */
745:
746: #define assert(expression) { \
747: if (!(expression)) { \
748: (void)printf(\
749: "assertion \"%s\" failed: file \"%s\", line %d\n", \
750: #expression, \
751: __FILE__, __LINE__); \
752: } \
753: }
754:
755: /*==========================================================
756: **
757: ** Big/Little endian support.
758: **
759: **==========================================================
760: */
761:
762: /*
763: ** If the NCR uses big endian addressing mode over the
764: ** PCI, actual io register addresses for byte and word
765: ** accesses must be changed according to lane routing.
766: ** Btw, ncr_offb() and ncr_offw() macros only apply to
767: ** constants and so donnot generate bloated code.
768: */
769:
770: #if defined(SCSI_NCR_BIG_ENDIAN)
771:
772: #define ncr_offb(o) (((o)&~3)+((~((o)&3))&3))
773: #define ncr_offw(o) (((o)&~3)+((~((o)&3))&2))
774:
775: #else
776:
777: #define ncr_offb(o) (o)
778: #define ncr_offw(o) (o)
779:
780: #endif
781:
782: /*
783: ** If the CPU and the NCR use same endian-ness adressing,
784: ** no byte reordering is needed for script patching.
785: ** Macro cpu_to_scr() is to be used for script patching.
786: ** Macro scr_to_cpu() is to be used for getting a DWORD
787: ** from the script.
788: */
789:
790: #if defined(__BIG_ENDIAN) && !defined(SCSI_NCR_BIG_ENDIAN)
791:
792: #define cpu_to_scr(dw) cpu_to_le32(dw)
793: #define scr_to_cpu(dw) le32_to_cpu(dw)
794:
795: #elif defined(__LITTLE_ENDIAN) && defined(SCSI_NCR_BIG_ENDIAN)
796:
797: #define cpu_to_scr(dw) cpu_to_be32(dw)
798: #define scr_to_cpu(dw) be32_to_cpu(dw)
799:
800: #else
801:
802: #define cpu_to_scr(dw) (dw)
803: #define scr_to_cpu(dw) (dw)
804:
805: #endif
806:
807: /*==========================================================
808: **
809: ** Access to the controller chip.
810: **
811: ** If NCR_IOMAPPED is defined, only IO are used by the driver.
812: **
813: **==========================================================
814: */
815:
816: /*
817: ** If the CPU and the NCR use same endian-ness adressing,
818: ** no byte reordering is needed for accessing chip io
819: ** registers. Functions suffixed by '_raw' are assumed
820: ** to access the chip over the PCI without doing byte
821: ** reordering. Functions suffixed by '_l2b' are
822: ** assumed to perform little-endian to big-endian byte
823: ** reordering, those suffixed by '_b2l' blah, blah,
824: ** blah, ...
825: */
826:
827: #if defined(NCR_IOMAPPED)
828:
829: /*
830: ** IO mapped only input / ouput
831: */
832:
833: #define INB_OFF(o) inb (np->port + ncr_offb(o))
834: #define OUTB_OFF(o, val) outb ((val), np->port + ncr_offb(o))
835:
836: #if defined(__BIG_ENDIAN) && !defined(SCSI_NCR_BIG_ENDIAN)
837:
838: #define INW_OFF(o) inw_l2b (np->port + ncr_offw(o))
839: #define INL_OFF(o) inl_l2b (np->port + (o))
840:
841: #define OUTW_OFF(o, val) outw_b2l ((val), np->port + ncr_offw(o))
842: #define OUTL_OFF(o, val) outl_b2l ((val), np->port + (o))
843:
844: #elif defined(__LITTLE_ENDIAN) && defined(SCSI_NCR_BIG_ENDIAN)
845:
846: #define INW_OFF(o) inw_b2l (np->port + ncr_offw(o))
847: #define INL_OFF(o) inl_b2l (np->port + (o))
848:
849: #define OUTW_OFF(o, val) outw_l2b ((val), np->port + ncr_offw(o))
850: #define OUTL_OFF(o, val) outl_l2b ((val), np->port + (o))
851:
852: #else
853:
854: #define INW_OFF(o) inw_raw (np->port + ncr_offw(o))
855: #define INL_OFF(o) inl_raw (np->port + (o))
856:
857: #define OUTW_OFF(o, val) outw_raw ((val), np->port + ncr_offw(o))
858: #define OUTL_OFF(o, val) outl_raw ((val), np->port + (o))
859:
860: #endif /* ENDIANs */
861:
862: #else /* defined NCR_IOMAPPED */
863:
864: /*
865: ** MEMORY mapped IO input / output
866: */
867:
868: #define INB_OFF(o) readb((char *)np->reg + ncr_offb(o))
869: #define OUTB_OFF(o, val) writeb((val), (char *)np->reg + ncr_offb(o))
870:
871: #if defined(__BIG_ENDIAN) && !defined(SCSI_NCR_BIG_ENDIAN)
872:
873: #define INW_OFF(o) readw_l2b((char *)np->reg + ncr_offw(o))
874: #define INL_OFF(o) readl_l2b((char *)np->reg + (o))
875:
876: #define OUTW_OFF(o, val) writew_b2l((val), (char *)np->reg + ncr_offw(o))
877: #define OUTL_OFF(o, val) writel_b2l((val), (char *)np->reg + (o))
878:
879: #elif defined(__LITTLE_ENDIAN) && defined(SCSI_NCR_BIG_ENDIAN)
880:
881: #define INW_OFF(o) readw_b2l((char *)np->reg + ncr_offw(o))
882: #define INL_OFF(o) readl_b2l((char *)np->reg + (o))
883:
884: #define OUTW_OFF(o, val) writew_l2b((val), (char *)np->reg + ncr_offw(o))
885: #define OUTL_OFF(o, val) writel_l2b((val), (char *)np->reg + (o))
886:
887: #else
888:
889: #define INW_OFF(o) readw_raw((char *)np->reg + ncr_offw(o))
890: #define INL_OFF(o) readl_raw((char *)np->reg + (o))
891:
892: #define OUTW_OFF(o, val) writew_raw((val), (char *)np->reg + ncr_offw(o))
893: #define OUTL_OFF(o, val) writel_raw((val), (char *)np->reg + (o))
894:
895: #endif
896:
897: #endif /* defined NCR_IOMAPPED */
898:
899: #define INB(r) INB_OFF (offsetof(struct ncr_reg,r))
900: #define INW(r) INW_OFF (offsetof(struct ncr_reg,r))
901: #define INL(r) INL_OFF (offsetof(struct ncr_reg,r))
902:
903: #define OUTB(r, val) OUTB_OFF (offsetof(struct ncr_reg,r), (val))
904: #define OUTW(r, val) OUTW_OFF (offsetof(struct ncr_reg,r), (val))
905: #define OUTL(r, val) OUTL_OFF (offsetof(struct ncr_reg,r), (val))
906:
907: /*
908: ** Set bit field ON, OFF
909: */
910:
911: #define OUTONB(r, m) OUTB(r, INB(r) | (m))
912: #define OUTOFFB(r, m) OUTB(r, INB(r) & ~(m))
913: #define OUTONW(r, m) OUTW(r, INW(r) | (m))
914: #define OUTOFFW(r, m) OUTW(r, INW(r) & ~(m))
915: #define OUTONL(r, m) OUTL(r, INL(r) | (m))
916: #define OUTOFFL(r, m) OUTL(r, INL(r) & ~(m))
917:
918:
919: /*==========================================================
920: **
921: ** Command control block states.
922: **
923: **==========================================================
924: */
925:
926: #define HS_IDLE (0)
927: #define HS_BUSY (1)
928: #define HS_NEGOTIATE (2) /* sync/wide data transfer*/
929: #define HS_DISCONNECT (3) /* Disconnected by target */
930:
931: #define HS_COMPLETE (4)
932: #define HS_SEL_TIMEOUT (5) /* Selection timeout */
933: #define HS_RESET (6) /* SCSI reset */
934: #define HS_ABORTED (7) /* Transfer aborted */
935: #define HS_TIMEOUT (8) /* Software timeout */
936: #define HS_FAIL (9) /* SCSI or PCI bus errors */
937: #define HS_UNEXPECTED (10) /* Unexpected disconnect */
938:
939: #define HS_DONEMASK (0xfc)
940:
941: /*==========================================================
942: **
943: ** Software Interrupt Codes
944: **
945: **==========================================================
946: */
947:
948: #define SIR_SENSE_RESTART (1)
949: #define SIR_SENSE_FAILED (2)
950: #define SIR_STALL_RESTART (3)
951: #define SIR_STALL_QUEUE (4)
952: #define SIR_NEGO_SYNC (5)
953: #define SIR_NEGO_WIDE (6)
954: #define SIR_NEGO_FAILED (7)
955: #define SIR_NEGO_PROTO (8)
956: #define SIR_REJECT_RECEIVED (9)
957: #define SIR_REJECT_SENT (10)
958: #define SIR_IGN_RESIDUE (11)
959: #define SIR_MISSING_SAVE (12)
960: #define SIR_DATA_IO_IS_OUT (13)
961: #define SIR_DATA_IO_IS_IN (14)
962: #define SIR_MAX (14)
963:
964: /*==========================================================
965: **
966: ** Extended error codes.
967: ** xerr_status field of struct ccb.
968: **
969: **==========================================================
970: */
971:
972: #define XE_OK (0)
973: #define XE_EXTRA_DATA (1) /* unexpected data phase */
974: #define XE_BAD_PHASE (2) /* illegal phase (4/5) */
975:
976: /*==========================================================
977: **
978: ** Negotiation status.
979: ** nego_status field of struct ccb.
980: **
981: **==========================================================
982: */
983:
984: #define NS_SYNC (1)
985: #define NS_WIDE (2)
986:
987: /*==========================================================
988: **
989: ** "Special features" of targets.
990: ** quirks field of struct tcb.
991: ** actualquirks field of struct ccb.
992: **
993: **==========================================================
994: */
995:
996: #define QUIRK_AUTOSAVE (0x01)
997: #define QUIRK_NOMSG (0x02)
998: #define QUIRK_NOSYNC (0x10)
999: #define QUIRK_NOWIDE16 (0x20)
1000: #define QUIRK_UPDATE (0x80)
1001:
1002: /*==========================================================
1003: **
1004: ** Capability bits in Inquire response byte 7.
1005: **
1006: **==========================================================
1007: */
1008:
1009: #define INQ7_QUEUE (0x02)
1010: #define INQ7_SYNC (0x10)
1011: #define INQ7_WIDE16 (0x20)
1012:
1013: /*==========================================================
1014: **
1015: ** Misc.
1016: **
1017: **==========================================================
1018: */
1019:
1020: #define CCB_MAGIC (0xf2691ad2)
1021:
1022: /*==========================================================
1023: **
1024: ** Declaration of structs.
1025: **
1026: **==========================================================
1027: */
1028:
1029: struct tcb;
1030: struct lcb;
1031: struct ccb;
1032: struct ncb;
1033: struct script;
1034:
1035: typedef struct ncb * ncb_p;
1036: typedef struct tcb * tcb_p;
1037: typedef struct lcb * lcb_p;
1038: typedef struct ccb * ccb_p;
1039:
1040: struct link {
1041: ncrcmd l_cmd;
1042: ncrcmd l_paddr;
1043: };
1044:
1045: struct usrcmd {
1046: u_long target;
1047: u_long lun;
1048: u_long data;
1049: u_long cmd;
1050: };
1051:
1052: #define UC_SETSYNC 10
1053: #define UC_SETTAGS 11
1054: #define UC_SETDEBUG 12
1055: #define UC_SETORDER 13
1056: #define UC_SETWIDE 14
1057: #define UC_SETFLAG 15
1058: #define UC_CLEARPROF 16
1059:
1060: #ifdef SCSI_NCR_DEBUG_ERROR_RECOVERY_SUPPORT
1061: #define UC_DEBUG_ERROR_RECOVERY 17
1062: #endif
1063:
1064: #define UF_TRACE (0x01)
1065: #define UF_NODISC (0x02)
1066: #define UF_NOSCAN (0x04)
1067:
1068: /*---------------------------------------
1069: **
1070: ** Timestamps for profiling
1071: **
1072: **---------------------------------------
1073: */
1074:
1075: struct tstamp {
1076: u_long start;
1077: u_long end;
1078: u_long select;
1079: u_long command;
1080: u_long status;
1081: u_long disconnect;
1082: u_long reselect;
1083: };
1084:
1085: /*
1086: ** profiling data (per device)
1087: */
1088:
1089: struct profile {
1090: u_long num_trans;
1091: u_long num_kbytes;
1092: u_long rest_bytes;
1093: u_long num_disc;
1094: u_long num_break;
1095: u_long num_int;
1096: u_long num_fly;
1097: u_long ms_setup;
1098: u_long ms_data;
1099: u_long ms_disc;
1100: u_long ms_post;
1101: };
1102:
1103: /*==========================================================
1104: **
1105: ** Declaration of structs: target control block
1106: **
1107: **==========================================================
1108: */
1109:
1110: struct tcb {
1111: /*
1112: ** during reselection the ncr jumps to this point
1113: ** with SFBR set to the encoded target number
1114: ** with bit 7 set.
1115: ** if it's not this target, jump to the next.
1116: **
1117: ** JUMP IF (SFBR != #target#)
1118: ** @(next tcb)
1119: */
1120:
1121: struct link jump_tcb;
1122:
1123: /*
1124: ** load the actual values for the sxfer and the scntl3
1125: ** register (sync/wide mode).
1126: **
1127: ** SCR_COPY (1);
1128: ** @(sval field of this tcb)
1129: ** @(sxfer register)
1130: ** SCR_COPY (1);
1131: ** @(wval field of this tcb)
1132: ** @(scntl3 register)
1133: */
1134:
1135: ncrcmd getscr[6];
1136:
1137: /*
1138: ** if next message is "identify"
1139: ** then load the message to SFBR,
1140: ** else load 0 to SFBR.
1141: **
1142: ** CALL
1143: ** <RESEL_LUN>
1144: */
1145:
1146: struct link call_lun;
1147:
1148: /*
1149: ** now look for the right lun.
1150: **
1151: ** JUMP
1152: ** @(first ccb of this lun)
1153: */
1154:
1155: struct link jump_lcb;
1156:
1157: /*
1158: ** pointer to interrupted getcc ccb
1159: */
1160:
1161: ccb_p hold_cp;
1162:
1163: /*
1164: ** pointer to ccb used for negotiating.
1165: ** Avoid to start a nego for all queued commands
1166: ** when tagged command queuing is enabled.
1167: */
1168:
1169: ccb_p nego_cp;
1170:
1171: /*
1172: ** statistical data
1173: */
1174:
1175: u_long transfers;
1176: u_long bytes;
1177:
1178: /*
1179: ** user settable limits for sync transfer
1180: ** and tagged commands.
1181: ** These limits are read from the NVRAM if present.
1182: */
1183:
1184: u_char usrsync;
1185: u_char usrwide;
1186: u_char usrtags;
1187: u_char usrflag;
1188:
1189: u_char numtags;
1190: u_char maxtags;
1191: u_short num_good;
1192:
1193: /*
1194: ** negotiation of wide and synch transfer.
1195: ** device quirks.
1196: */
1197:
1198: /*0*/ u_char minsync;
1199: /*1*/ u_char sval;
1200: /*2*/ u_short period;
1201: /*0*/ u_char maxoffs;
1202:
1203: /*1*/ u_char quirks;
1204:
1205: /*2*/ u_char widedone;
1206: /*3*/ u_char wval;
1207: /*
1208: ** inquire data
1209: */
1210: #define MAX_INQUIRE 36
1211: u_char inqdata[MAX_INQUIRE];
1212:
1213: /*
1214: ** the lcb's of this tcb
1215: */
1216:
1217: lcb_p lp[MAX_LUN];
1218: };
1219:
1220: /*==========================================================
1221: **
1222: ** Declaration of structs: lun control block
1223: **
1224: **==========================================================
1225: */
1226:
1227: struct lcb {
1228: /*
1229: ** during reselection the ncr jumps to this point
1230: ** with SFBR set to the "Identify" message.
1231: ** if it's not this lun, jump to the next.
1232: **
1233: ** JUMP IF (SFBR != #lun#)
1234: ** @(next lcb of this target)
1235: */
1236:
1237: struct link jump_lcb;
1238:
1239: /*
1240: ** if next message is "simple tag",
1241: ** then load the tag to SFBR,
1242: ** else load 0 to SFBR.
1243: **
1244: ** CALL
1245: ** <RESEL_TAG>
1246: */
1247:
1248: struct link call_tag;
1249:
1250: /*
1251: ** now look for the right ccb.
1252: **
1253: ** JUMP
1254: ** @(first ccb of this lun)
1255: */
1256:
1257: struct link jump_ccb;
1258:
1259: /*
1260: ** start of the ccb chain
1261: */
1262:
1263: ccb_p next_ccb;
1264:
1265: /*
1266: ** Control of tagged queueing
1267: */
1268:
1269: u_char reqccbs;
1270: u_char actccbs;
1271: u_char reqlink;
1272: u_char actlink;
1273: u_char usetags;
1274: u_char lasttag;
1275:
1276: /*
1277: ** Linux specific fields:
1278: ** Number of active commands and current credit.
1279: ** Should be managed by the generic scsi driver
1280: */
1281:
1282: u_char active;
1283: u_char opennings;
1284:
1285: /*-----------------------------------------------
1286: ** Flag to force M_ORDERED_TAG on next command
1287: ** in order to avoid spurious timeout when
1288: ** M_SIMPLE_TAG is used for all operations.
1289: **-----------------------------------------------
1290: */
1291: u_char force_ordered_tag;
1292: #define NCR_TIMEOUT_INCREASE (5*HZ)
1293: };
1294:
1295: /*==========================================================
1296: **
1297: ** Declaration of structs: COMMAND control block
1298: **
1299: **==========================================================
1300: **
1301: ** This substructure is copied from the ccb to a
1302: ** global address after selection (or reselection)
1303: ** and copied back before disconnect.
1304: **
1305: ** These fields are accessible to the script processor.
1306: **
1307: **----------------------------------------------------------
1308: */
1309:
1310: struct head {
1311: /*
1312: ** Execution of a ccb starts at this point.
1313: ** It's a jump to the "SELECT" label
1314: ** of the script.
1315: **
1316: ** After successful selection the script
1317: ** processor overwrites it with a jump to
1318: ** the IDLE label of the script.
1319: */
1320:
1321: struct link launch;
1322:
1323: /*
1324: ** Saved data pointer.
1325: ** Points to the position in the script
1326: ** responsible for the actual transfer
1327: ** of data.
1328: ** It's written after reception of a
1329: ** "SAVE_DATA_POINTER" message.
1330: ** The goalpointer points after
1331: ** the last transfer command.
1332: */
1333:
1334: u_int32 savep;
1335: u_int32 lastp;
1336: u_int32 goalp;
1337:
1338: /*
1339: ** The virtual address of the ccb
1340: ** containing this header.
1341: */
1342:
1343: ccb_p cp;
1344:
1345: /*
1346: ** space for some timestamps to gather
1347: ** profiling data about devices and this driver.
1348: */
1349:
1350: struct tstamp stamp;
1351:
1352: /*
1353: ** status fields.
1354: */
1355:
1356: u_char scr_st[4]; /* script status */
1357: u_char status[4]; /* host status. Must be the last */
1358: /* DWORD of the CCB header */
1359: };
1360:
1361: /*
1362: ** The status bytes are used by the host and the script processor.
1363: **
1364: ** The byte corresponding to the host_status must be stored in the
1365: ** last DWORD of the CCB header since it is used for command
1366: ** completion (ncr_wakeup()). Doing so, we are sure that the header
1367: ** has been entirely copied back to the CCB when the host_status is
1368: ** seen complete by the CPU.
1369: **
1370: ** The last four bytes (status[4]) are copied to the scratchb register
1371: ** (declared as scr0..scr3 in ncr_reg.h) just after the select/reselect,
1372: ** and copied back just after disconnecting.
1373: ** Inside the script the XX_REG are used.
1374: **
1375: ** The first four bytes (scr_st[4]) are used inside the script by
1376: ** "COPY" commands.
1377: ** Because source and destination must have the same alignment
1378: ** in a DWORD, the fields HAVE to be at the choosen offsets.
1379: ** xerr_st 0 (0x34) scratcha
1380: ** sync_st 1 (0x05) sxfer
1381: ** wide_st 3 (0x03) scntl3
1382: */
1383:
1384: /*
1385: ** Last four bytes (script)
1386: */
1387: #define QU_REG scr0
1388: #define HS_REG scr1
1389: #define HS_PRT nc_scr1
1390: #define SS_REG scr2
1391: #define PS_REG scr3
1392:
1393: /*
1394: ** Last four bytes (host)
1395: */
1396: #define actualquirks phys.header.status[0]
1397: #define host_status phys.header.status[1]
1398: #define scsi_status phys.header.status[2]
1399: #define parity_status phys.header.status[3]
1400:
1401: /*
1402: ** First four bytes (script)
1403: */
1404: #define xerr_st header.scr_st[0]
1405: #define sync_st header.scr_st[1]
1406: #define nego_st header.scr_st[2]
1407: #define wide_st header.scr_st[3]
1408:
1409: /*
1410: ** First four bytes (host)
1411: */
1412: #define xerr_status phys.xerr_st
1413: #define sync_status phys.sync_st
1414: #define nego_status phys.nego_st
1415: #define wide_status phys.wide_st
1416:
1417: /*==========================================================
1418: **
1419: ** Declaration of structs: Data structure block
1420: **
1421: **==========================================================
1422: **
1423: ** During execution of a ccb by the script processor,
1424: ** the DSA (data structure address) register points
1425: ** to this substructure of the ccb.
1426: ** This substructure contains the header with
1427: ** the script-processor-changable data and
1428: ** data blocks for the indirect move commands.
1429: **
1430: **----------------------------------------------------------
1431: */
1432:
1433: struct dsb {
1434:
1435: /*
1436: ** Header.
1437: ** Has to be the first entry,
1438: ** because it's jumped to by the
1439: ** script processor
1440: */
1441:
1442: struct head header;
1443:
1444: /*
1445: ** Table data for Script
1446: */
1447:
1448: struct scr_tblsel select;
1449: struct scr_tblmove smsg ;
1450: struct scr_tblmove smsg2 ;
1451: struct scr_tblmove cmd ;
1452: struct scr_tblmove scmd ;
1453: struct scr_tblmove sense ;
1454: struct scr_tblmove data [MAX_SCATTER];
1455: };
1456:
1457: /*==========================================================
1458: **
1459: ** Declaration of structs: Command control block.
1460: **
1461: **==========================================================
1462: **
1463: ** During execution of a ccb by the script processor,
1464: ** the DSA (data structure address) register points
1465: ** to this substructure of the ccb.
1466: ** This substructure contains the header with
1467: ** the script-processor-changable data and then
1468: ** data blocks for the indirect move commands.
1469: **
1470: **----------------------------------------------------------
1471: */
1472:
1473:
1474: struct ccb {
1475: /*
1476: ** This field forces 32 bytes alignement for phys.header,
1477: ** in order to use cache line bursting when copying it
1478: ** to the ncb.
1479: */
1480:
1481: struct link filler[2];
1482:
1483: /*
1484: ** during reselection the ncr jumps to this point.
1485: ** If a "SIMPLE_TAG" message was received,
1486: ** then SFBR is set to the tag.
1487: ** else SFBR is set to 0
1488: ** If looking for another tag, jump to the next ccb.
1489: **
1490: ** JUMP IF (SFBR != #TAG#)
1491: ** @(next ccb of this lun)
1492: */
1493:
1494: struct link jump_ccb;
1495:
1496: /*
1497: ** After execution of this call, the return address
1498: ** (in the TEMP register) points to the following
1499: ** data structure block.
1500: ** So copy it to the DSA register, and start
1501: ** processing of this data structure.
1502: **
1503: ** CALL
1504: ** <RESEL_TMP>
1505: */
1506:
1507: struct link call_tmp;
1508:
1509: /*
1510: ** This is the data structure which is
1511: ** to be executed by the script processor.
1512: */
1513:
1514: struct dsb phys;
1515:
1516: /*
1517: ** If a data transfer phase is terminated too early
1518: ** (after reception of a message (i.e. DISCONNECT)),
1519: ** we have to prepare a mini script to transfer
1520: ** the rest of the data.
1521: */
1522:
1523: ncrcmd patch[8];
1524:
1525: /*
1526: ** The general SCSI driver provides a
1527: ** pointer to a control block.
1528: */
1529:
1530: Scsi_Cmnd *cmd;
1531: int data_len;
1532:
1533: /*
1534: ** We prepare a message to be sent after selection,
1535: ** and a second one to be sent after getcc selection.
1536: ** Contents are IDENTIFY and SIMPLE_TAG.
1537: ** While negotiating sync or wide transfer,
1538: ** a SDTM or WDTM message is appended.
1539: */
1540:
1541: u_char scsi_smsg [8];
1542: u_char scsi_smsg2[8];
1543:
1544: /*
1545: ** Lock this ccb.
1546: ** Flag is used while looking for a free ccb.
1547: */
1548:
1549: u_long magic;
1550:
1551: /*
1552: ** Physical address of this instance of ccb
1553: */
1554:
1555: u_long p_ccb;
1556:
1557: /*
1558: ** Completion time out for this job.
1559: ** It's set to time of start + allowed number of seconds.
1560: */
1561:
1562: u_long tlimit;
1563:
1564: /*
1565: ** All ccbs of one hostadapter are chained.
1566: */
1567:
1568: ccb_p link_ccb;
1569:
1570: /*
1571: ** All ccbs of one target/lun are chained.
1572: */
1573:
1574: ccb_p next_ccb;
1575:
1576: /*
1577: ** Sense command
1578: */
1579:
1580: u_char sensecmd[6];
1581:
1582: /*
1583: ** Tag for this transfer.
1584: ** It's patched into jump_ccb.
1585: ** If it's not zero, a SIMPLE_TAG
1586: ** message is included in smsg.
1587: */
1588:
1589: u_char tag;
1590:
1591: /*
1592: ** Number of segments of the scatter list.
1593: ** Used for recalculation of savep/goalp/lastp on
1594: ** SIR_DATA_IO_IS_OUT interrupt.
1595: */
1596:
1597: u_char segments;
1598: };
1599:
1600: #define CCB_PHYS(cp,lbl) (cp->p_ccb + offsetof(struct ccb, lbl))
1601:
1602: /*==========================================================
1603: **
1604: ** Declaration of structs: NCR device descriptor
1605: **
1606: **==========================================================
1607: */
1608:
1609: struct ncb {
1610: /*
1611: ** The global header.
1612: ** Accessible to both the host and the
1613: ** script-processor.
1614: ** Is 32 bytes aligned since ncb is, in order to
1615: ** allow cache line bursting when copying it from or
1616: ** to ccbs.
1617: */
1618: struct head header;
1619:
1620: /*-----------------------------------------------
1621: ** Specific Linux fields
1622: **-----------------------------------------------
1623: */
1624: int unit; /* Unit number */
1625: char chip_name[8]; /* Chip name */
1626: char inst_name[16]; /* Instance name */
1627: struct timer_list timer; /* Timer link header */
1628: int ncr_cache; /* Cache test variable */
1629: Scsi_Cmnd *waiting_list; /* Waiting list header for commands */
1630: /* that we can't put into the squeue */
1631: u_long settle_time; /* Reset in progess */
1632: u_char release_stage; /* Synchronisation stage on release */
1633: u_char verbose; /* Boot verbosity for this controller*/
1634: #ifdef SCSI_NCR_DEBUG_ERROR_RECOVERY_SUPPORT
1635: u_char debug_error_recovery;
1636: u_char stalling;
1637: u_char assert_atn;
1638: #endif
1639:
1640: /*-----------------------------------------------
1641: ** Added field to support differences
1642: ** between ncr chips.
1643: ** sv_xxx are some io register bit value at start-up and
1644: ** so assumed to have been set by the sdms bios.
1645: ** rv_xxx are the bit fields of io register that will keep
1646: ** the features used by the driver.
1647: **-----------------------------------------------
1648: */
1649: u_short device_id;
1650: u_char revision_id;
1651:
1652: u_char sv_scntl0;
1653: u_char sv_scntl3;
1654: u_char sv_dmode;
1655: u_char sv_dcntl;
1656: u_char sv_ctest3;
1657: u_char sv_ctest4;
1658: u_char sv_ctest5;
1659: u_char sv_gpcntl;
1660: u_char sv_stest2;
1661: u_char sv_stest4;
1662:
1663: u_char rv_scntl0;
1664: u_char rv_scntl3;
1665: u_char rv_dmode;
1666: u_char rv_dcntl;
1667: u_char rv_ctest3;
1668: u_char rv_ctest4;
1669: u_char rv_ctest5;
1670: u_char rv_stest2;
1671:
1672: u_char scsi_mode;
1673:
1674: /*-----------------------------------------------
1675: ** Scripts ..
1676: **-----------------------------------------------
1677: **
1678: ** During reselection the ncr jumps to this point.
1679: ** The SFBR register is loaded with the encoded target id.
1680: **
1681: ** Jump to the first target.
1682: **
1683: ** JUMP
1684: ** @(next tcb)
1685: */
1686: struct link jump_tcb;
1687:
1688: /*-----------------------------------------------
1689: ** Configuration ..
1690: **-----------------------------------------------
1691: **
1692: ** virtual and physical addresses
1693: ** of the 53c810 chip.
1694: */
1695: vm_offset_t vaddr;
1696: vm_offset_t paddr;
1697:
1698: vm_offset_t vaddr2;
1699: vm_offset_t paddr2;
1700:
1701: /*
1702: ** pointer to the chip's registers.
1703: */
1704: volatile
1705: struct ncr_reg* reg;
1706:
1707: /*
1708: ** A copy of the scripts, relocated for this ncb.
1709: */
1710: struct script *script0;
1711: struct scripth *scripth0;
1712:
1713: /*
1714: ** Scripts instance virtual address.
1715: */
1716: struct script *script;
1717: struct scripth *scripth;
1718:
1719: /*
1720: ** Scripts instance physical address.
1721: */
1722: u_long p_script;
1723: u_long p_scripth;
1724:
1725: /*
1726: ** The SCSI address of the host adapter.
1727: */
1728: u_char myaddr;
1729:
1730: /*
1731: ** Max dwords burst supported by the adapter.
1732: */
1733: u_char maxburst; /* log base 2 of dwords burst */
1734:
1735: /*
1736: ** timing parameters
1737: */
1738: u_char minsync; /* Minimum sync period factor */
1739: u_char maxsync; /* Maximum sync period factor */
1740: u_char maxoffs; /* Max scsi offset */
1741: u_char multiplier; /* Clock multiplier (1,2,4) */
1742: u_char clock_divn; /* Number of clock divisors */
1743: u_long clock_khz; /* SCSI clock frequency in KHz */
1744: u_int features; /* Chip features map */
1745:
1746:
1747: /*-----------------------------------------------
1748: ** Link to the generic SCSI driver
1749: **-----------------------------------------------
1750: */
1751:
1752: /* struct scsi_link sc_link; */
1753:
1754: /*-----------------------------------------------
1755: ** Job control
1756: **-----------------------------------------------
1757: **
1758: ** Commands from user
1759: */
1760: struct usrcmd user;
1761: u_char order;
1762:
1763: /*
1764: ** Target data
1765: */
1766: struct tcb target[MAX_TARGET];
1767:
1768: /*
1769: ** Start queue.
1770: */
1771: u_int32 squeue [MAX_START];
1772: u_short squeueput;
1773: u_short actccbs;
1774:
1775: /*
1776: ** Timeout handler
1777: */
1778: #if 0
1779: u_long heartbeat;
1780: u_short ticks;
1781: u_short latetime;
1782: #endif
1783: u_long lasttime;
1784:
1785: /*-----------------------------------------------
1786: ** Debug and profiling
1787: **-----------------------------------------------
1788: **
1789: ** register dump
1790: */
1791: struct ncr_reg regdump;
1792: u_long regtime;
1793:
1794: /*
1795: ** Profiling data
1796: */
1797: struct profile profile;
1798: u_long disc_phys;
1799: u_long disc_ref;
1800:
1801: /*
1802: ** The global control block.
1803: ** It's used only during the configuration phase.
1804: ** A target control block will be created
1805: ** after the first successful transfer.
1806: */
1807: struct ccb *ccb;
1808:
1809: /*
1810: ** message buffers.
1811: ** Should be longword aligned,
1812: ** because they're written with a
1813: ** COPY script command.
1814: */
1815: u_char msgout[8];
1816: u_char msgin [8];
1817: u_int32 lastmsg;
1818:
1819: /*
1820: ** Buffer for STATUS_IN phase.
1821: */
1822: u_char scratch;
1823:
1824: /*
1825: ** controller chip dependent maximal transfer width.
1826: */
1827: u_char maxwide;
1828:
1829: /*
1830: ** option for M_IDENTIFY message: enables disconnecting
1831: */
1832: u_char disc;
1833:
1834: /*
1835: ** address of the ncr control registers in io space
1836: */
1837: u_int port;
1838:
1839: /*
1840: ** irq level
1841: */
1842: u_short irq;
1843: };
1844:
1845: #define NCB_SCRIPT_PHYS(np,lbl) (np->p_script + offsetof (struct script, lbl))
1846: #define NCB_SCRIPTH_PHYS(np,lbl) (np->p_scripth + offsetof (struct scripth, lbl))
1847:
1848: /*==========================================================
1849: **
1850: **
1851: ** Script for NCR-Processor.
1852: **
1853: ** Use ncr_script_fill() to create the variable parts.
1854: ** Use ncr_script_copy_and_bind() to make a copy and
1855: ** bind to physical addresses.
1856: **
1857: **
1858: **==========================================================
1859: **
1860: ** We have to know the offsets of all labels before
1861: ** we reach them (for forward jumps).
1862: ** Therefore we declare a struct here.
1863: ** If you make changes inside the script,
1864: ** DON'T FORGET TO CHANGE THE LENGTHS HERE!
1865: **
1866: **----------------------------------------------------------
1867: */
1868:
1869: /*
1870: ** Script fragments which are loaded into the on-board RAM
1871: ** of 825A, 875 and 895 chips.
1872: */
1873: struct script {
1874: ncrcmd start [ 4];
1875: ncrcmd start0 [ 2];
1876: ncrcmd start1 [ 3];
1877: ncrcmd startpos [ 1];
1878: ncrcmd trysel [ 8];
1879: ncrcmd skip [ 8];
1880: ncrcmd skip2 [ 3];
1881: ncrcmd idle [ 2];
1882: ncrcmd select [ 22];
1883: ncrcmd prepare [ 4];
1884: ncrcmd loadpos [ 14];
1885: ncrcmd prepare2 [ 24];
1886: ncrcmd setmsg [ 5];
1887: ncrcmd clrack [ 2];
1888: ncrcmd dispatch [ 38];
1889: ncrcmd no_data [ 17];
1890: ncrcmd checkatn [ 10];
1891: ncrcmd command [ 15];
1892: ncrcmd status [ 27];
1893: ncrcmd msg_in [ 26];
1894: ncrcmd msg_bad [ 6];
1895: ncrcmd complete [ 13];
1896: ncrcmd cleanup [ 12];
1897: ncrcmd cleanup0 [ 11];
1898: ncrcmd signal [ 10];
1899: ncrcmd save_dp [ 5];
1900: ncrcmd restore_dp [ 5];
1901: ncrcmd disconnect [ 12];
1902: ncrcmd disconnect0 [ 5];
1903: ncrcmd disconnect1 [ 23];
1904: ncrcmd msg_out [ 9];
1905: ncrcmd msg_out_done [ 7];
1906: ncrcmd badgetcc [ 6];
1907: ncrcmd reselect [ 8];
1908: ncrcmd reselect1 [ 8];
1909: ncrcmd reselect2 [ 8];
1910: ncrcmd resel_tmp [ 5];
1911: ncrcmd resel_lun [ 18];
1912: ncrcmd resel_tag [ 24];
1913: ncrcmd data_io [ 6];
1914: ncrcmd data_in [MAX_SCATTER * 4 + 4];
1915: };
1916:
1917: /*
1918: ** Script fragments which stay in main memory for all chips.
1919: */
1920: struct scripth {
1921: ncrcmd tryloop [MAX_START*5+2];
1922: ncrcmd msg_parity [ 6];
1923: ncrcmd msg_reject [ 8];
1924: ncrcmd msg_ign_residue [ 32];
1925: ncrcmd msg_extended [ 18];
1926: ncrcmd msg_ext_2 [ 18];
1927: ncrcmd msg_wdtr [ 27];
1928: ncrcmd msg_ext_3 [ 18];
1929: ncrcmd msg_sdtr [ 27];
1930: ncrcmd msg_out_abort [ 10];
1931: ncrcmd getcc [ 4];
1932: ncrcmd getcc1 [ 5];
1933: #ifdef NCR_GETCC_WITHMSG
1934: ncrcmd getcc2 [ 33];
1935: #else
1936: ncrcmd getcc2 [ 14];
1937: #endif
1938: ncrcmd getcc3 [ 10];
1939: ncrcmd data_out [MAX_SCATTER * 4 + 4];
1940: ncrcmd aborttag [ 4];
1941: ncrcmd abort [ 22];
1942: ncrcmd snooptest [ 9];
1943: ncrcmd snoopend [ 2];
1944: };
1945:
1946: /*==========================================================
1947: **
1948: **
1949: ** Function headers.
1950: **
1951: **
1952: **==========================================================
1953: */
1954:
1955: static void ncr_alloc_ccb (ncb_p np, u_long t, u_long l);
1956: static void ncr_complete (ncb_p np, ccb_p cp);
1957: static void ncr_exception (ncb_p np);
1958: static void ncr_free_ccb (ncb_p np, ccb_p cp, u_long t, u_long l);
1959: static void ncr_getclock (ncb_p np, int mult);
1960: static void ncr_selectclock (ncb_p np, u_char scntl3);
1961: static ccb_p ncr_get_ccb (ncb_p np, u_long t,u_long l);
1962: static void ncr_init (ncb_p np, int reset, char * msg, u_long code);
1963: static int ncr_int_sbmc (ncb_p np);
1964: static int ncr_int_par (ncb_p np);
1965: static void ncr_int_ma (ncb_p np);
1966: static void ncr_int_sir (ncb_p np);
1967: static void ncr_int_sto (ncb_p np);
1968: static u_long ncr_lookup (char* id);
1969: static void ncr_negotiate (struct ncb* np, struct tcb* tp);
1970: static void ncr_opennings (ncb_p np, lcb_p lp, Scsi_Cmnd * xp);
1971:
1972: #ifdef SCSI_NCR_PROFILE_SUPPORT
1973: static void ncb_profile (ncb_p np, ccb_p cp);
1974: #endif
1975:
1976: static void ncr_script_copy_and_bind
1977: (ncb_p np, ncrcmd *src, ncrcmd *dst, int len);
1978: static void ncr_script_fill (struct script * scr, struct scripth * scripth);
1979: static int ncr_scatter (ccb_p cp, Scsi_Cmnd *cmd);
1980: static void ncr_setmaxtags (ncb_p np, tcb_p tp, u_long numtags);
1981: static void ncr_getsync (ncb_p np, u_char sfac, u_char *fakp, u_char *scntl3p);
1982: static void ncr_setsync (ncb_p np, ccb_p cp, u_char scntl3, u_char sxfer);
1983: static void ncr_settags (tcb_p tp, lcb_p lp);
1984: static void ncr_setwide (ncb_p np, ccb_p cp, u_char wide, u_char ack);
1985: static int ncr_show_msg (u_char * msg);
1986: static int ncr_snooptest (ncb_p np);
1987: static void ncr_timeout (ncb_p np);
1988: static void ncr_wakeup (ncb_p np, u_long code);
1989: static void ncr_start_reset (ncb_p np, int settle_delay);
1990: static int ncr_reset_scsi_bus (ncb_p np, int enab_int, int settle_delay);
1991:
1992: #ifdef SCSI_NCR_USER_COMMAND_SUPPORT
1993: static void ncr_usercmd (ncb_p np);
1994: #endif
1995:
1996: static int ncr_attach (Scsi_Host_Template *tpnt, int unit, ncr_device *device);
1997:
1998: static void insert_into_waiting_list(ncb_p np, Scsi_Cmnd *cmd);
1999: static Scsi_Cmnd *retrieve_from_waiting_list(int to_remove, ncb_p np, Scsi_Cmnd *cmd);
2000: static void process_waiting_list(ncb_p np, int sts);
2001:
2002: #define remove_from_waiting_list(np, cmd) \
2003: retrieve_from_waiting_list(1, (np), (cmd))
2004: #define requeue_waiting_list(np) process_waiting_list((np), DID_OK)
2005: #define reset_waiting_list(np) process_waiting_list((np), DID_RESET)
2006:
2007: #ifdef SCSI_NCR_NVRAM_SUPPORT
2008: static int ncr_get_Symbios_nvram (ncr_slot *np, Symbios_nvram *nvram);
2009: static int ncr_get_Tekram_nvram (ncr_slot *np, Tekram_nvram *nvram);
2010: #endif
2011:
2012: /*==========================================================
2013: **
2014: **
2015: ** Global static data.
2016: **
2017: **
2018: **==========================================================
2019: */
2020:
2021: #ifdef SCSI_NCR_DEBUG_INFO_SUPPORT
2022: static int ncr_debug = SCSI_NCR_DEBUG_FLAGS;
2023: #endif
2024:
2025: static inline char *ncr_name (ncb_p np)
2026: {
2027: return np->inst_name;
2028: }
2029:
2030:
2031: /*==========================================================
2032: **
2033: **
2034: ** Scripts for NCR-Processor.
2035: **
2036: ** Use ncr_script_bind for binding to physical addresses.
2037: **
2038: **
2039: **==========================================================
2040: **
2041: ** NADDR generates a reference to a field of the controller data.
2042: ** PADDR generates a reference to another part of the script.
2043: ** RADDR generates a reference to a script processor register.
2044: ** FADDR generates a reference to a script processor register
2045: ** with offset.
2046: **
2047: **----------------------------------------------------------
2048: */
2049:
2050: #define RELOC_SOFTC 0x40000000
2051: #define RELOC_LABEL 0x50000000
2052: #define RELOC_REGISTER 0x60000000
2053: #define RELOC_KVAR 0x70000000
2054: #define RELOC_LABELH 0x80000000
2055: #define RELOC_MASK 0xf0000000
2056:
2057: #define NADDR(label) (RELOC_SOFTC | offsetof(struct ncb, label))
2058: #define PADDR(label) (RELOC_LABEL | offsetof(struct script, label))
2059: #define PADDRH(label) (RELOC_LABELH | offsetof(struct scripth, label))
2060: #define RADDR(label) (RELOC_REGISTER | REG(label))
2061: #define FADDR(label,ofs)(RELOC_REGISTER | ((REG(label))+(ofs)))
2062: #define KVAR(which) (RELOC_KVAR | (which))
2063:
2064: #define SCRIPT_KVAR_JIFFIES (0)
2065:
2066: #define SCRIPT_KVAR_FIRST SCRIPT_KVAR_JIFFIES
2067: #define SCRIPT_KVAR_LAST SCRIPT_KVAR_JIFFIES
2068:
2069: /*
2070: * Kernel variables referenced in the scripts.
2071: * THESE MUST ALL BE ALIGNED TO A 4-BYTE BOUNDARY.
2072: */
2073: static void *script_kvars[] __initdata =
2074: { (void *)&jiffies };
2075:
2076: static struct script script0 __initdata = {
2077: /*--------------------------< START >-----------------------*/ {
2078: #if 0
2079: /*
2080: ** Claim to be still alive ...
2081: */
2082: SCR_COPY (sizeof (((struct ncb *)0)->heartbeat)),
2083: KVAR(SCRIPT_KVAR_JIFFIES),
2084: NADDR (heartbeat),
2085: #endif
2086: /*
2087: ** Make data structure address invalid.
2088: ** clear SIGP.
2089: */
2090: SCR_LOAD_REG (dsa, 0xff),
2091: 0,
2092: SCR_FROM_REG (ctest2),
2093: 0,
2094: }/*-------------------------< START0 >----------------------*/,{
2095: /*
2096: ** Hook for interrupted GetConditionCode.
2097: ** Will be patched to ... IFTRUE by
2098: ** the interrupt handler.
2099: */
2100: SCR_INT ^ IFFALSE (0),
2101: SIR_SENSE_RESTART,
2102:
2103: }/*-------------------------< START1 >----------------------*/,{
2104: /*
2105: ** Hook for stalled start queue.
2106: ** Will be patched to IFTRUE by the interrupt handler.
2107: */
2108: SCR_INT ^ IFFALSE (0),
2109: SIR_STALL_RESTART,
2110: /*
2111: ** Then jump to a certain point in tryloop.
2112: ** Due to the lack of indirect addressing the code
2113: ** is self modifying here.
2114: */
2115: SCR_JUMP,
2116: }/*-------------------------< STARTPOS >--------------------*/,{
2117: PADDRH(tryloop),
2118: }/*-------------------------< TRYSEL >----------------------*/,{
2119: /*
2120: ** Now:
2121: ** DSA: Address of a Data Structure
2122: ** or Address of the IDLE-Label.
2123: **
2124: ** TEMP: Address of a script, which tries to
2125: ** start the NEXT entry.
2126: **
2127: ** Save the TEMP register into the SCRATCHA register.
2128: ** Then copy the DSA to TEMP and RETURN.
2129: ** This is kind of an indirect jump.
2130: ** (The script processor has NO stack, so the
2131: ** CALL is actually a jump and link, and the
2132: ** RETURN is an indirect jump.)
2133: **
2134: ** If the slot was empty, DSA contains the address
2135: ** of the IDLE part of this script. The processor
2136: ** jumps to IDLE and waits for a reselect.
2137: ** It will wake up and try the same slot again
2138: ** after the SIGP bit becomes set by the host.
2139: **
2140: ** If the slot was not empty, DSA contains
2141: ** the address of the phys-part of a ccb.
2142: ** The processor jumps to this address.
2143: ** phys starts with head,
2144: ** head starts with launch,
2145: ** so actually the processor jumps to
2146: ** the lauch part.
2147: ** If the entry is scheduled for execution,
2148: ** then launch contains a jump to SELECT.
2149: ** If it's not scheduled, it contains a jump to IDLE.
2150: */
2151: SCR_COPY (4),
2152: RADDR (temp),
2153: RADDR (scratcha),
2154: SCR_COPY (4),
2155: RADDR (dsa),
2156: RADDR (temp),
2157: SCR_RETURN,
2158: 0
2159:
2160: }/*-------------------------< SKIP >------------------------*/,{
2161: /*
2162: ** This entry has been canceled.
2163: ** Next time use the next slot.
2164: */
2165: SCR_COPY (4),
2166: RADDR (scratcha),
2167: PADDR (startpos),
2168: /*
2169: ** patch the launch field.
2170: ** should look like an idle process.
2171: */
2172: SCR_COPY_F (4),
2173: RADDR (dsa),
2174: PADDR (skip2),
2175: SCR_COPY (8),
2176: PADDR (idle),
2177: }/*-------------------------< SKIP2 >-----------------------*/,{
2178: 0,
2179: SCR_JUMP,
2180: PADDR(start),
2181: }/*-------------------------< IDLE >------------------------*/,{
2182: /*
2183: ** Nothing to do?
2184: ** Wait for reselect.
2185: */
2186: SCR_JUMP,
2187: PADDR(reselect),
2188:
2189: }/*-------------------------< SELECT >----------------------*/,{
2190: /*
2191: ** DSA contains the address of a scheduled
2192: ** data structure.
2193: **
2194: ** SCRATCHA contains the address of the script,
2195: ** which starts the next entry.
2196: **
2197: ** Set Initiator mode.
2198: **
2199: ** (Target mode is left as an exercise for the reader)
2200: */
2201:
2202: SCR_CLR (SCR_TRG),
2203: 0,
2204: SCR_LOAD_REG (HS_REG, 0xff),
2205: 0,
2206:
2207: /*
2208: ** And try to select this target.
2209: */
2210: SCR_SEL_TBL_ATN ^ offsetof (struct dsb, select),
2211: PADDR (reselect),
2212:
2213: /*
2214: ** Now there are 4 possibilities:
2215: **
2216: ** (1) The ncr looses arbitration.
2217: ** This is ok, because it will try again,
2218: ** when the bus becomes idle.
2219: ** (But beware of the timeout function!)
2220: **
2221: ** (2) The ncr is reselected.
2222: ** Then the script processor takes the jump
2223: ** to the RESELECT label.
2224: **
2225: ** (3) The ncr completes the selection.
2226: ** Then it will execute the next statement.
2227: **
2228: ** (4) There is a selection timeout.
2229: ** Then the ncr should interrupt the host and stop.
2230: ** Unfortunately, it seems to continue execution
2231: ** of the script. But it will fail with an
2232: ** IID-interrupt on the next WHEN.
2233: */
2234:
2235: SCR_JUMPR ^ IFTRUE (WHEN (SCR_MSG_IN)),
2236: 0,
2237:
2238: /*
2239: ** Save target id to ctest0 register
2240: */
2241:
2242: SCR_FROM_REG (sdid),
2243: 0,
2244: SCR_TO_REG (ctest0),
2245: 0,
2246: /*
2247: ** Send the IDENTIFY and SIMPLE_TAG messages
2248: ** (and the M_X_SYNC_REQ message)
2249: */
2250: SCR_MOVE_TBL ^ SCR_MSG_OUT,
2251: offsetof (struct dsb, smsg),
2252: #ifdef undef /* XXX better fail than try to deal with this ... */
2253: SCR_JUMPR ^ IFTRUE (WHEN (SCR_MSG_OUT)),
2254: -16,
2255: #endif
2256: SCR_CLR (SCR_ATN),
2257: 0,
2258: SCR_COPY (1),
2259: RADDR (sfbr),
2260: NADDR (lastmsg),
2261: /*
2262: ** Selection complete.
2263: ** Next time use the next slot.
2264: */
2265: SCR_COPY (4),
2266: RADDR (scratcha),
2267: PADDR (startpos),
2268: }/*-------------------------< PREPARE >----------------------*/,{
2269: /*
2270: ** The ncr doesn't have an indirect load
2271: ** or store command. So we have to
2272: ** copy part of the control block to a
2273: ** fixed place, where we can access it.
2274: **
2275: ** We patch the address part of a
2276: ** COPY command with the DSA-register.
2277: */
2278: SCR_COPY_F (4),
2279: RADDR (dsa),
2280: PADDR (loadpos),
2281: /*
2282: ** then we do the actual copy.
2283: */
2284: SCR_COPY (sizeof (struct head)),
2285: /*
2286: ** continued after the next label ...
2287: */
2288:
2289: }/*-------------------------< LOADPOS >---------------------*/,{
2290: 0,
2291: NADDR (header),
2292: /*
2293: ** Mark this ccb as not scheduled.
2294: */
2295: SCR_COPY (8),
2296: PADDR (idle),
2297: NADDR (header.launch),
2298: /*
2299: ** Set a time stamp for this selection
2300: */
2301: SCR_COPY (sizeof (u_long)),
2302: KVAR(SCRIPT_KVAR_JIFFIES),
2303: NADDR (header.stamp.select),
2304: /*
2305: ** load the savep (saved pointer) into
2306: ** the TEMP register (actual pointer)
2307: */
2308: SCR_COPY (4),
2309: NADDR (header.savep),
2310: RADDR (temp),
2311: /*
2312: ** Initialize the status registers
2313: */
2314: SCR_COPY (4),
2315: NADDR (header.status),
2316: RADDR (scr0),
2317:
2318: }/*-------------------------< PREPARE2 >---------------------*/,{
2319: /*
2320: ** Load the synchronous mode register
2321: */
2322: SCR_COPY (1),
2323: NADDR (sync_st),
2324: RADDR (sxfer),
2325: /*
2326: ** Load the wide mode and timing register
2327: */
2328: SCR_COPY (1),
2329: NADDR (wide_st),
2330: RADDR (scntl3),
2331: /*
2332: ** Initialize the msgout buffer with a NOOP message.
2333: */
2334: SCR_LOAD_REG (scratcha, M_NOOP),
2335: 0,
2336: SCR_COPY (1),
2337: RADDR (scratcha),
2338: NADDR (msgout),
2339: SCR_COPY (1),
2340: RADDR (scratcha),
2341: NADDR (msgin),
2342: /*
2343: ** Message in phase ?
2344: */
2345: SCR_JUMP ^ IFFALSE (WHEN (SCR_MSG_IN)),
2346: PADDR (dispatch),
2347: /*
2348: ** Extended or reject message ?
2349: */
2350: SCR_FROM_REG (sbdl),
2351: 0,
2352: SCR_JUMP ^ IFTRUE (DATA (M_EXTENDED)),
2353: PADDR (msg_in),
2354: SCR_JUMP ^ IFTRUE (DATA (M_REJECT)),
2355: PADDRH (msg_reject),
2356: /*
2357: ** normal processing
2358: */
2359: SCR_JUMP,
2360: PADDR (dispatch),
2361: }/*-------------------------< SETMSG >----------------------*/,{
2362: SCR_COPY (1),
2363: RADDR (scratcha),
2364: NADDR (msgout),
2365: SCR_SET (SCR_ATN),
2366: 0,
2367: }/*-------------------------< CLRACK >----------------------*/,{
2368: /*
2369: ** Terminate possible pending message phase.
2370: */
2371: SCR_CLR (SCR_ACK),
2372: 0,
2373:
2374: }/*-----------------------< DISPATCH >----------------------*/,{
2375: SCR_FROM_REG (HS_REG),
2376: 0,
2377: SCR_INT ^ IFTRUE (DATA (HS_NEGOTIATE)),
2378: SIR_NEGO_FAILED,
2379: /*
2380: ** remove bogus output signals
2381: */
2382: SCR_REG_REG (socl, SCR_AND, CACK|CATN),
2383: 0,
2384: SCR_RETURN ^ IFTRUE (WHEN (SCR_DATA_OUT)),
2385: 0,
2386: /*
2387: ** DEL 397 - 53C875 Rev 3 - Part Number 609-0392410 - ITEM 4.
2388: ** Possible data corruption during Memory Write and Invalidate.
2389: ** This work-around resets the addressing logic prior to the
2390: ** start of the first MOVE of a DATA IN phase.
2391: ** (See README.ncr53c8xx for more information)
2392: */
2393: SCR_JUMPR ^ IFFALSE (IF (SCR_DATA_IN)),
2394: 20,
2395: SCR_COPY (4),
2396: RADDR (scratcha),
2397: RADDR (scratcha),
2398: SCR_RETURN,
2399: 0,
2400:
2401: SCR_JUMP ^ IFTRUE (IF (SCR_MSG_OUT)),
2402: PADDR (msg_out),
2403: SCR_JUMP ^ IFTRUE (IF (SCR_MSG_IN)),
2404: PADDR (msg_in),
2405: SCR_JUMP ^ IFTRUE (IF (SCR_COMMAND)),
2406: PADDR (command),
2407: SCR_JUMP ^ IFTRUE (IF (SCR_STATUS)),
2408: PADDR (status),
2409: /*
2410: ** Discard one illegal phase byte, if required.
2411: */
2412: SCR_LOAD_REG (scratcha, XE_BAD_PHASE),
2413: 0,
2414: SCR_COPY (1),
2415: RADDR (scratcha),
2416: NADDR (xerr_st),
2417: SCR_JUMPR ^ IFFALSE (IF (SCR_ILG_OUT)),
2418: 8,
2419: SCR_MOVE_ABS (1) ^ SCR_ILG_OUT,
2420: NADDR (scratch),
2421: SCR_JUMPR ^ IFFALSE (IF (SCR_ILG_IN)),
2422: 8,
2423: SCR_MOVE_ABS (1) ^ SCR_ILG_IN,
2424: NADDR (scratch),
2425: SCR_JUMP,
2426: PADDR (dispatch),
2427:
2428: }/*-------------------------< NO_DATA >--------------------*/,{
2429: /*
2430: ** The target wants to tranfer too much data
2431: ** or in the wrong direction.
2432: ** Remember that in extended error.
2433: */
2434: SCR_LOAD_REG (scratcha, XE_EXTRA_DATA),
2435: 0,
2436: SCR_COPY (1),
2437: RADDR (scratcha),
2438: NADDR (xerr_st),
2439: /*
2440: ** Discard one data byte, if required.
2441: */
2442: SCR_JUMPR ^ IFFALSE (WHEN (SCR_DATA_OUT)),
2443: 8,
2444: SCR_MOVE_ABS (1) ^ SCR_DATA_OUT,
2445: NADDR (scratch),
2446: SCR_JUMPR ^ IFFALSE (IF (SCR_DATA_IN)),
2447: 8,
2448: SCR_MOVE_ABS (1) ^ SCR_DATA_IN,
2449: NADDR (scratch),
2450: /*
2451: ** .. and repeat as required.
2452: */
2453: SCR_CALL,
2454: PADDR (dispatch),
2455: SCR_JUMP,
2456: PADDR (no_data),
2457: }/*-------------------------< CHECKATN >--------------------*/,{
2458: /*
2459: ** If AAP (bit 1 of scntl0 register) is set
2460: ** and a parity error is detected,
2461: ** the script processor asserts ATN.
2462: **
2463: ** The target should switch to a MSG_OUT phase
2464: ** to get the message.
2465: */
2466: SCR_FROM_REG (socl),
2467: 0,
2468: SCR_JUMP ^ IFFALSE (MASK (CATN, CATN)),
2469: PADDR (dispatch),
2470: /*
2471: ** count it
2472: */
2473: SCR_REG_REG (PS_REG, SCR_ADD, 1),
2474: 0,
2475: /*
2476: ** Prepare a M_ID_ERROR message
2477: ** (initiator detected error).
2478: ** The target should retry the transfer.
2479: */
2480: SCR_LOAD_REG (scratcha, M_ID_ERROR),
2481: 0,
2482: SCR_JUMP,
2483: PADDR (setmsg),
2484:
2485: }/*-------------------------< COMMAND >--------------------*/,{
2486: /*
2487: ** If this is not a GETCC transfer ...
2488: */
2489: SCR_FROM_REG (SS_REG),
2490: 0,
2491: /*<<<*/ SCR_JUMPR ^ IFTRUE (DATA (S_CHECK_COND)),
2492: 28,
2493: /*
2494: ** ... set a timestamp ...
2495: */
2496: SCR_COPY (sizeof (u_long)),
2497: KVAR(SCRIPT_KVAR_JIFFIES),
2498: NADDR (header.stamp.command),
2499: /*
2500: ** ... and send the command
2501: */
2502: SCR_MOVE_TBL ^ SCR_COMMAND,
2503: offsetof (struct dsb, cmd),
2504: SCR_JUMP,
2505: PADDR (dispatch),
2506: /*
2507: ** Send the GETCC command
2508: */
2509: /*>>>*/ SCR_MOVE_TBL ^ SCR_COMMAND,
2510: offsetof (struct dsb, scmd),
2511: SCR_JUMP,
2512: PADDR (dispatch),
2513:
2514: }/*-------------------------< STATUS >--------------------*/,{
2515: /*
2516: ** set the timestamp.
2517: */
2518: SCR_COPY (sizeof (u_long)),
2519: KVAR(SCRIPT_KVAR_JIFFIES),
2520: NADDR (header.stamp.status),
2521: /*
2522: ** If this is a GETCC transfer,
2523: */
2524: SCR_FROM_REG (SS_REG),
2525: 0,
2526: /*<<<*/ SCR_JUMPR ^ IFFALSE (DATA (S_CHECK_COND)),
2527: 40,
2528: /*
2529: ** get the status
2530: */
2531: SCR_MOVE_ABS (1) ^ SCR_STATUS,
2532: NADDR (scratch),
2533: /*
2534: ** Save status to scsi_status.
2535: ** Mark as complete.
2536: ** And wait for disconnect.
2537: */
2538: SCR_TO_REG (SS_REG),
2539: 0,
2540: SCR_REG_REG (SS_REG, SCR_OR, S_SENSE),
2541: 0,
2542: SCR_LOAD_REG (HS_REG, HS_COMPLETE),
2543: 0,
2544: SCR_JUMP,
2545: PADDR (checkatn),
2546: /*
2547: ** If it was no GETCC transfer,
2548: ** save the status to scsi_status.
2549: */
2550: /*>>>*/ SCR_MOVE_ABS (1) ^ SCR_STATUS,
2551: NADDR (scratch),
2552: SCR_TO_REG (SS_REG),
2553: 0,
2554: /*
2555: ** if it was no check condition ...
2556: */
2557: SCR_JUMP ^ IFTRUE (DATA (S_CHECK_COND)),
2558: PADDR (checkatn),
2559: /*
2560: ** ... mark as complete.
2561: */
2562: SCR_LOAD_REG (HS_REG, HS_COMPLETE),
2563: 0,
2564: SCR_JUMP,
2565: PADDR (checkatn),
2566:
2567: }/*-------------------------< MSG_IN >--------------------*/,{
2568: /*
2569: ** Get the first byte of the message
2570: ** and save it to SCRATCHA.
2571: **
2572: ** The script processor doesn't negate the
2573: ** ACK signal after this transfer.
2574: */
2575: SCR_MOVE_ABS (1) ^ SCR_MSG_IN,
2576: NADDR (msgin[0]),
2577: /*
2578: ** Check for message parity error.
2579: */
2580: SCR_TO_REG (scratcha),
2581: 0,
2582: SCR_FROM_REG (socl),
2583: 0,
2584: SCR_JUMP ^ IFTRUE (MASK (CATN, CATN)),
2585: PADDRH (msg_parity),
2586: SCR_FROM_REG (scratcha),
2587: 0,
2588: /*
2589: ** Parity was ok, handle this message.
2590: */
2591: SCR_JUMP ^ IFTRUE (DATA (M_COMPLETE)),
2592: PADDR (complete),
2593: SCR_JUMP ^ IFTRUE (DATA (M_SAVE_DP)),
2594: PADDR (save_dp),
2595: SCR_JUMP ^ IFTRUE (DATA (M_RESTORE_DP)),
2596: PADDR (restore_dp),
2597: SCR_JUMP ^ IFTRUE (DATA (M_DISCONNECT)),
2598: PADDR (disconnect),
2599: SCR_JUMP ^ IFTRUE (DATA (M_EXTENDED)),
2600: PADDRH (msg_extended),
2601: SCR_JUMP ^ IFTRUE (DATA (M_NOOP)),
2602: PADDR (clrack),
2603: SCR_JUMP ^ IFTRUE (DATA (M_REJECT)),
2604: PADDRH (msg_reject),
2605: SCR_JUMP ^ IFTRUE (DATA (M_IGN_RESIDUE)),
2606: PADDRH (msg_ign_residue),
2607: /*
2608: ** Rest of the messages left as
2609: ** an exercise ...
2610: **
2611: ** Unimplemented messages:
2612: ** fall through to MSG_BAD.
2613: */
2614: }/*-------------------------< MSG_BAD >------------------*/,{
2615: /*
2616: ** unimplemented message - reject it.
2617: */
2618: SCR_INT,
2619: SIR_REJECT_SENT,
2620: SCR_LOAD_REG (scratcha, M_REJECT),
2621: 0,
2622: SCR_JUMP,
2623: PADDR (setmsg),
2624:
2625: }/*-------------------------< COMPLETE >-----------------*/,{
2626: /*
2627: ** Complete message.
2628: **
2629: ** If it's not the get condition code,
2630: ** copy TEMP register to LASTP in header.
2631: */
2632: SCR_FROM_REG (SS_REG),
2633: 0,
2634: /*<<<*/ SCR_JUMPR ^ IFTRUE (MASK (S_SENSE, S_SENSE)),
2635: 12,
2636: SCR_COPY (4),
2637: RADDR (temp),
2638: NADDR (header.lastp),
2639: /*>>>*/ /*
2640: ** When we terminate the cycle by clearing ACK,
2641: ** the target may disconnect immediately.
2642: **
2643: ** We don't want to be told of an
2644: ** "unexpected disconnect",
2645: ** so we disable this feature.
2646: */
2647: SCR_REG_REG (scntl2, SCR_AND, 0x7f),
2648: 0,
2649: /*
2650: ** Terminate cycle ...
2651: */
2652: SCR_CLR (SCR_ACK|SCR_ATN),
2653: 0,
2654: /*
2655: ** ... and wait for the disconnect.
2656: */
2657: SCR_WAIT_DISC,
2658: 0,
2659: }/*-------------------------< CLEANUP >-------------------*/,{
2660: /*
2661: ** dsa: Pointer to ccb
2662: ** or xxxxxxFF (no ccb)
2663: **
2664: ** HS_REG: Host-Status (<>0!)
2665: */
2666: SCR_FROM_REG (dsa),
2667: 0,
2668: SCR_JUMP ^ IFTRUE (DATA (0xff)),
2669: PADDR (signal),
2670: /*
2671: ** dsa is valid.
2672: ** save the status registers
2673: */
2674: SCR_COPY (4),
2675: RADDR (scr0),
2676: NADDR (header.status),
2677: /*
2678: ** and copy back the header to the ccb.
2679: */
2680: SCR_COPY_F (4),
2681: RADDR (dsa),
2682: PADDR (cleanup0),
2683: SCR_COPY (sizeof (struct head)),
2684: NADDR (header),
2685: }/*-------------------------< CLEANUP0 >--------------------*/,{
2686: 0,
2687:
2688: /*
2689: ** If command resulted in "check condition"
2690: ** status and is not yet completed,
2691: ** try to get the condition code.
2692: */
2693: SCR_FROM_REG (HS_REG),
2694: 0,
2695: /*<<<*/ SCR_JUMPR ^ IFFALSE (MASK (0, HS_DONEMASK)),
2696: 16,
2697: SCR_FROM_REG (SS_REG),
2698: 0,
2699: SCR_JUMP ^ IFTRUE (DATA (S_CHECK_COND)),
2700: PADDRH(getcc2),
2701: /*
2702: ** And make the DSA register invalid.
2703: */
2704: /*>>>*/ SCR_LOAD_REG (dsa, 0xff), /* invalid */
2705: 0,
2706: }/*-------------------------< SIGNAL >----------------------*/,{
2707: /*
2708: ** if status = queue full,
2709: ** reinsert in startqueue and stall queue.
2710: */
2711: SCR_FROM_REG (SS_REG),
2712: 0,
2713: SCR_INT ^ IFTRUE (DATA (S_QUEUE_FULL)),
2714: SIR_STALL_QUEUE,
2715: /*
2716: ** if job completed ...
2717: */
2718: SCR_FROM_REG (HS_REG),
2719: 0,
2720: /*
2721: ** ... signal completion to the host
2722: */
2723: SCR_INT_FLY ^ IFFALSE (MASK (0, HS_DONEMASK)),
2724: 0,
2725: /*
2726: ** Auf zu neuen Schandtaten!
2727: */
2728: SCR_JUMP,
2729: PADDR(start),
2730:
2731: }/*-------------------------< SAVE_DP >------------------*/,{
2732: /*
2733: ** SAVE_DP message:
2734: ** Copy TEMP register to SAVEP in header.
2735: */
2736: SCR_COPY (4),
2737: RADDR (temp),
2738: NADDR (header.savep),
2739: SCR_JUMP,
2740: PADDR (clrack),
2741: }/*-------------------------< RESTORE_DP >---------------*/,{
2742: /*
2743: ** RESTORE_DP message:
2744: ** Copy SAVEP in header to TEMP register.
2745: */
2746: SCR_COPY (4),
2747: NADDR (header.savep),
2748: RADDR (temp),
2749: SCR_JUMP,
2750: PADDR (clrack),
2751:
2752: }/*-------------------------< DISCONNECT >---------------*/,{
2753: /*
2754: ** If QUIRK_AUTOSAVE is set,
2755: ** do an "save pointer" operation.
2756: */
2757: SCR_FROM_REG (QU_REG),
2758: 0,
2759: /*<<<*/ SCR_JUMPR ^ IFFALSE (MASK (QUIRK_AUTOSAVE, QUIRK_AUTOSAVE)),
2760: 12,
2761: /*
2762: ** like SAVE_DP message:
2763: ** Copy TEMP register to SAVEP in header.
2764: */
2765: SCR_COPY (4),
2766: RADDR (temp),
2767: NADDR (header.savep),
2768: /*>>>*/ /*
2769: ** Check if temp==savep or temp==goalp:
2770: ** if not, log a missing save pointer message.
2771: ** In fact, it's a comparison mod 256.
2772: **
2773: ** Hmmm, I hadn't thought that I would be urged to
2774: ** write this kind of ugly self modifying code.
2775: **
2776: ** It's unbelievable, but the ncr53c8xx isn't able
2777: ** to subtract one register from another.
2778: */
2779: SCR_FROM_REG (temp),
2780: 0,
2781: /*
2782: ** You are not expected to understand this ..
2783: **
2784: ** CAUTION: only little endian architectures supported! XXX
2785: */
2786: SCR_COPY_F (1),
2787: NADDR (header.savep),
2788: PADDR (disconnect0),
2789: }/*-------------------------< DISCONNECT0 >--------------*/,{
2790: /*<<<*/ SCR_JUMPR ^ IFTRUE (DATA (1)),
2791: 20,
2792: /*
2793: ** neither this
2794: */
2795: SCR_COPY_F (1),
2796: NADDR (header.goalp),
2797: PADDR (disconnect1),
2798: }/*-------------------------< DISCONNECT1 >--------------*/,{
2799: SCR_INT ^ IFFALSE (DATA (1)),
2800: SIR_MISSING_SAVE,
2801: /*>>>*/
2802:
2803: /*
2804: ** DISCONNECTing ...
2805: **
2806: ** disable the "unexpected disconnect" feature,
2807: ** and remove the ACK signal.
2808: */
2809: SCR_REG_REG (scntl2, SCR_AND, 0x7f),
2810: 0,
2811: SCR_CLR (SCR_ACK|SCR_ATN),
2812: 0,
2813: /*
2814: ** Wait for the disconnect.
2815: */
2816: SCR_WAIT_DISC,
2817: 0,
2818: /*
2819: ** Profiling:
2820: ** Set a time stamp,
2821: ** and count the disconnects.
2822: */
2823: SCR_COPY (sizeof (u_long)),
2824: KVAR(SCRIPT_KVAR_JIFFIES),
2825: NADDR (header.stamp.disconnect),
2826: SCR_COPY (4),
2827: NADDR (disc_phys),
2828: RADDR (temp),
2829: SCR_REG_REG (temp, SCR_ADD, 0x01),
2830: 0,
2831: SCR_COPY (4),
2832: RADDR (temp),
2833: NADDR (disc_phys),
2834: /*
2835: ** Status is: DISCONNECTED.
2836: */
2837: SCR_LOAD_REG (HS_REG, HS_DISCONNECT),
2838: 0,
2839: SCR_JUMP,
2840: PADDR (cleanup),
2841:
2842: }/*-------------------------< MSG_OUT >-------------------*/,{
2843: /*
2844: ** The target requests a message.
2845: */
2846: SCR_MOVE_ABS (1) ^ SCR_MSG_OUT,
2847: NADDR (msgout),
2848: SCR_COPY (1),
2849: RADDR (sfbr),
2850: NADDR (lastmsg),
2851: /*
2852: ** If it was no ABORT message ...
2853: */
2854: SCR_JUMP ^ IFTRUE (DATA (M_ABORT)),
2855: PADDRH (msg_out_abort),
2856: /*
2857: ** ... wait for the next phase
2858: ** if it's a message out, send it again, ...
2859: */
2860: SCR_JUMP ^ IFTRUE (WHEN (SCR_MSG_OUT)),
2861: PADDR (msg_out),
2862: }/*-------------------------< MSG_OUT_DONE >--------------*/,{
2863: /*
2864: ** ... else clear the message ...
2865: */
2866: SCR_LOAD_REG (scratcha, M_NOOP),
2867: 0,
2868: SCR_COPY (4),
2869: RADDR (scratcha),
2870: NADDR (msgout),
2871: /*
2872: ** ... and process the next phase
2873: */
2874: SCR_JUMP,
2875: PADDR (dispatch),
2876: }/*------------------------< BADGETCC >---------------------*/,{
2877: /*
2878: ** If SIGP was set, clear it and try again.
2879: */
2880: SCR_FROM_REG (ctest2),
2881: 0,
2882: SCR_JUMP ^ IFTRUE (MASK (CSIGP,CSIGP)),
2883: PADDRH (getcc2),
2884: SCR_INT,
2885: SIR_SENSE_FAILED,
2886: }/*-------------------------< RESELECT >--------------------*/,{
2887: /*
2888: ** This NOP will be patched with LED OFF
2889: ** SCR_REG_REG (gpreg, SCR_OR, 0x01)
2890: */
2891: SCR_NO_OP,
2892: 0,
2893: /*
2894: ** make the DSA invalid.
2895: */
2896: SCR_LOAD_REG (dsa, 0xff),
2897: 0,
2898: SCR_CLR (SCR_TRG),
2899: 0,
2900: /*
2901: ** Sleep waiting for a reselection.
2902: ** If SIGP is set, special treatment.
2903: **
2904: ** Zu allem bereit ..
2905: */
2906: SCR_WAIT_RESEL,
2907: PADDR(reselect2),
2908: }/*-------------------------< RESELECT1 >--------------------*/,{
2909: /*
2910: ** This NOP will be patched with LED ON
2911: ** SCR_REG_REG (gpreg, SCR_AND, 0xfe)
2912: */
2913: SCR_NO_OP,
2914: 0,
2915: /*
2916: ** ... zu nichts zu gebrauchen ?
2917: **
2918: ** load the target id into the SFBR
2919: ** and jump to the control block.
2920: **
2921: ** Look at the declarations of
2922: ** - struct ncb
2923: ** - struct tcb
2924: ** - struct lcb
2925: ** - struct ccb
2926: ** to understand what's going on.
2927: */
2928: SCR_REG_SFBR (ssid, SCR_AND, 0x8F),
2929: 0,
2930: SCR_TO_REG (ctest0),
2931: 0,
2932: SCR_JUMP,
2933: NADDR (jump_tcb),
2934: }/*-------------------------< RESELECT2 >-------------------*/,{
2935: /*
2936: ** This NOP will be patched with LED ON
2937: ** SCR_REG_REG (gpreg, SCR_AND, 0xfe)
2938: */
2939: SCR_NO_OP,
2940: 0,
2941: /*
2942: ** If it's not connected :(
2943: ** -> interrupted by SIGP bit.
2944: ** Jump to start.
2945: */
2946: SCR_FROM_REG (ctest2),
2947: 0,
2948: SCR_JUMP ^ IFTRUE (MASK (CSIGP,CSIGP)),
2949: PADDR (start),
2950: SCR_JUMP,
2951: PADDR (reselect),
2952:
2953: }/*-------------------------< RESEL_TMP >-------------------*/,{
2954: /*
2955: ** The return address in TEMP
2956: ** is in fact the data structure address,
2957: ** so copy it to the DSA register.
2958: */
2959: SCR_COPY (4),
2960: RADDR (temp),
2961: RADDR (dsa),
2962: SCR_JUMP,
2963: PADDR (prepare),
2964:
2965: }/*-------------------------< RESEL_LUN >-------------------*/,{
2966: /*
2967: ** come back to this point
2968: ** to get an IDENTIFY message
2969: ** Wait for a msg_in phase.
2970: */
2971: /*<<<*/ SCR_JUMPR ^ IFFALSE (WHEN (SCR_MSG_IN)),
2972: 48,
2973: /*
2974: ** message phase
2975: ** It's not a sony, it's a trick:
2976: ** read the data without acknowledging it.
2977: */
2978: SCR_FROM_REG (sbdl),
2979: 0,
2980: /*<<<*/ SCR_JUMPR ^ IFFALSE (MASK (M_IDENTIFY, 0x98)),
2981: 32,
2982: /*
2983: ** It WAS an Identify message.
2984: ** get it and ack it!
2985: */
2986: SCR_MOVE_ABS (1) ^ SCR_MSG_IN,
2987: NADDR (msgin),
2988: SCR_CLR (SCR_ACK),
2989: 0,
2990: /*
2991: ** Mask out the lun.
2992: */
2993: SCR_REG_REG (sfbr, SCR_AND, 0x07),
2994: 0,
2995: SCR_RETURN,
2996: 0,
2997: /*
2998: ** No message phase or no IDENTIFY message:
2999: ** return 0.
3000: */
3001: /*>>>*/ SCR_LOAD_SFBR (0),
3002: 0,
3003: SCR_RETURN,
3004: 0,
3005:
3006: }/*-------------------------< RESEL_TAG >-------------------*/,{
3007: /*
3008: ** come back to this point
3009: ** to get a SIMPLE_TAG message
3010: ** Wait for a MSG_IN phase.
3011: */
3012: /*<<<*/ SCR_JUMPR ^ IFFALSE (WHEN (SCR_MSG_IN)),
3013: 64,
3014: /*
3015: ** message phase
3016: ** It's a trick - read the data
3017: ** without acknowledging it.
3018: */
3019: SCR_FROM_REG (sbdl),
3020: 0,
3021: /*<<<*/ SCR_JUMPR ^ IFFALSE (DATA (M_SIMPLE_TAG)),
3022: 48,
3023: /*
3024: ** It WAS a SIMPLE_TAG message.
3025: ** get it and ack it!
3026: */
3027: SCR_MOVE_ABS (1) ^ SCR_MSG_IN,
3028: NADDR (msgin),
3029: SCR_CLR (SCR_ACK),
3030: 0,
3031: /*
3032: ** Wait for the second byte (the tag)
3033: */
3034: /*<<<*/ SCR_JUMPR ^ IFFALSE (WHEN (SCR_MSG_IN)),
3035: 24,
3036: /*
3037: ** Get it and ack it!
3038: */
3039: SCR_MOVE_ABS (1) ^ SCR_MSG_IN,
3040: NADDR (msgin),
3041: SCR_CLR (SCR_ACK|SCR_CARRY),
3042: 0,
3043: SCR_RETURN,
3044: 0,
3045: /*
3046: ** No message phase or no SIMPLE_TAG message
3047: ** or no second byte: return 0.
3048: */
3049: /*>>>*/ SCR_LOAD_SFBR (0),
3050: 0,
3051: SCR_SET (SCR_CARRY),
3052: 0,
3053: SCR_RETURN,
3054: 0,
3055:
3056: }/*-------------------------< DATA_IO >--------------------*/,{
3057: /*
3058: ** Because Linux does not provide xfer data direction
3059: ** to low-level scsi drivers, we must trust the target
3060: ** for actual data direction when we cannot guess it.
3061: ** The programmed interrupt patches savep, lastp, goalp,
3062: ** etc.., and restarts the scsi script at data_out/in.
3063: */
3064: SCR_INT ^ IFTRUE (WHEN (SCR_DATA_OUT)),
3065: SIR_DATA_IO_IS_OUT,
3066: SCR_INT ^ IFTRUE (WHEN (SCR_DATA_IN)),
3067: SIR_DATA_IO_IS_IN,
3068: SCR_JUMP,
3069: PADDR (no_data),
3070:
3071: }/*-------------------------< DATA_IN >--------------------*/,{
3072: /*
3073: ** Because the size depends on the
3074: ** #define MAX_SCATTER parameter,
3075: ** it is filled in at runtime.
3076: **
3077: ** ##===========< i=0; i<MAX_SCATTER >=========
3078: ** || SCR_CALL ^ IFFALSE (WHEN (SCR_DATA_IN)),
3079: ** || PADDR (checkatn),
3080: ** || SCR_MOVE_TBL ^ SCR_DATA_IN,
3081: ** || offsetof (struct dsb, data[ i]),
3082: ** ##==========================================
3083: **
3084: ** SCR_CALL,
3085: ** PADDR (checkatn),
3086: ** SCR_JUMP,
3087: ** PADDR (no_data),
3088: */
3089: 0
3090: }/*--------------------------------------------------------*/
3091: };
3092:
3093: static struct scripth scripth0 __initdata = {
3094: /*-------------------------< TRYLOOP >---------------------*/{
3095: /*
3096: ** Load an entry of the start queue into dsa
3097: ** and try to start it by jumping to TRYSEL.
3098: **
3099: ** Because the size depends on the
3100: ** #define MAX_START parameter, it is filled
3101: ** in at runtime.
3102: **
3103: **-----------------------------------------------------------
3104: **
3105: ** ##===========< I=0; i<MAX_START >===========
3106: ** || SCR_COPY (4),
3107: ** || NADDR (squeue[i]),
3108: ** || RADDR (dsa),
3109: ** || SCR_CALL,
3110: ** || PADDR (trysel),
3111: ** ##==========================================
3112: **
3113: ** SCR_JUMP,
3114: ** PADDRH(tryloop),
3115: **
3116: **-----------------------------------------------------------
3117: */
3118: 0
3119: },/*-------------------------< MSG_PARITY >---------------*/{
3120: /*
3121: ** count it
3122: */
3123: SCR_REG_REG (PS_REG, SCR_ADD, 0x01),
3124: 0,
3125: /*
3126: ** send a "message parity error" message.
3127: */
3128: SCR_LOAD_REG (scratcha, M_PARITY),
3129: 0,
3130: SCR_JUMP,
3131: PADDR (setmsg),
3132: }/*-------------------------< MSG_REJECT >---------------*/,{
3133: /*
3134: ** If a negotiation was in progress,
3135: ** negotiation failed.
3136: */
3137: SCR_FROM_REG (HS_REG),
3138: 0,
3139: SCR_INT ^ IFTRUE (DATA (HS_NEGOTIATE)),
3140: SIR_NEGO_FAILED,
3141: /*
3142: ** else make host log this message
3143: */
3144: SCR_INT ^ IFFALSE (DATA (HS_NEGOTIATE)),
3145: SIR_REJECT_RECEIVED,
3146: SCR_JUMP,
3147: PADDR (clrack),
3148:
3149: }/*-------------------------< MSG_IGN_RESIDUE >----------*/,{
3150: /*
3151: ** Terminate cycle
3152: */
3153: SCR_CLR (SCR_ACK),
3154: 0,
3155: SCR_JUMP ^ IFFALSE (WHEN (SCR_MSG_IN)),
3156: PADDR (dispatch),
3157: /*
3158: ** get residue size.
3159: */
3160: SCR_MOVE_ABS (1) ^ SCR_MSG_IN,
3161: NADDR (msgin[1]),
3162: /*
3163: ** Check for message parity error.
3164: */
3165: SCR_TO_REG (scratcha),
3166: 0,
3167: SCR_FROM_REG (socl),
3168: 0,
3169: SCR_JUMP ^ IFTRUE (MASK (CATN, CATN)),
3170: PADDRH (msg_parity),
3171: SCR_FROM_REG (scratcha),
3172: 0,
3173: /*
3174: ** Size is 0 .. ignore message.
3175: */
3176: SCR_JUMP ^ IFTRUE (DATA (0)),
3177: PADDR (clrack),
3178: /*
3179: ** Size is not 1 .. have to interrupt.
3180: */
3181: /*<<<*/ SCR_JUMPR ^ IFFALSE (DATA (1)),
3182: 40,
3183: /*
3184: ** Check for residue byte in swide register
3185: */
3186: SCR_FROM_REG (scntl2),
3187: 0,
3188: /*<<<*/ SCR_JUMPR ^ IFFALSE (MASK (WSR, WSR)),
3189: 16,
3190: /*
3191: ** There IS data in the swide register.
3192: ** Discard it.
3193: */
3194: SCR_REG_REG (scntl2, SCR_OR, WSR),
3195: 0,
3196: SCR_JUMP,
3197: PADDR (clrack),
3198: /*
3199: ** Load again the size to the sfbr register.
3200: */
3201: /*>>>*/ SCR_FROM_REG (scratcha),
3202: 0,
3203: /*>>>*/ SCR_INT,
3204: SIR_IGN_RESIDUE,
3205: SCR_JUMP,
3206: PADDR (clrack),
3207:
3208: }/*-------------------------< MSG_EXTENDED >-------------*/,{
3209: /*
3210: ** Terminate cycle
3211: */
3212: SCR_CLR (SCR_ACK),
3213: 0,
3214: SCR_JUMP ^ IFFALSE (WHEN (SCR_MSG_IN)),
3215: PADDR (dispatch),
3216: /*
3217: ** get length.
3218: */
3219: SCR_MOVE_ABS (1) ^ SCR_MSG_IN,
3220: NADDR (msgin[1]),
3221: /*
3222: ** Check for message parity error.
3223: */
3224: SCR_TO_REG (scratcha),
3225: 0,
3226: SCR_FROM_REG (socl),
3227: 0,
3228: SCR_JUMP ^ IFTRUE (MASK (CATN, CATN)),
3229: PADDRH (msg_parity),
3230: SCR_FROM_REG (scratcha),
3231: 0,
3232: /*
3233: */
3234: SCR_JUMP ^ IFTRUE (DATA (3)),
3235: PADDRH (msg_ext_3),
3236: SCR_JUMP ^ IFFALSE (DATA (2)),
3237: PADDR (msg_bad),
3238: }/*-------------------------< MSG_EXT_2 >----------------*/,{
3239: SCR_CLR (SCR_ACK),
3240: 0,
3241: SCR_JUMP ^ IFFALSE (WHEN (SCR_MSG_IN)),
3242: PADDR (dispatch),
3243: /*
3244: ** get extended message code.
3245: */
3246: SCR_MOVE_ABS (1) ^ SCR_MSG_IN,
3247: NADDR (msgin[2]),
3248: /*
3249: ** Check for message parity error.
3250: */
3251: SCR_TO_REG (scratcha),
3252: 0,
3253: SCR_FROM_REG (socl),
3254: 0,
3255: SCR_JUMP ^ IFTRUE (MASK (CATN, CATN)),
3256: PADDRH (msg_parity),
3257: SCR_FROM_REG (scratcha),
3258: 0,
3259: SCR_JUMP ^ IFTRUE (DATA (M_X_WIDE_REQ)),
3260: PADDRH (msg_wdtr),
3261: /*
3262: ** unknown extended message
3263: */
3264: SCR_JUMP,
3265: PADDR (msg_bad)
3266: }/*-------------------------< MSG_WDTR >-----------------*/,{
3267: SCR_CLR (SCR_ACK),
3268: 0,
3269: SCR_JUMP ^ IFFALSE (WHEN (SCR_MSG_IN)),
3270: PADDR (dispatch),
3271: /*
3272: ** get data bus width
3273: */
3274: SCR_MOVE_ABS (1) ^ SCR_MSG_IN,
3275: NADDR (msgin[3]),
3276: SCR_FROM_REG (socl),
3277: 0,
3278: SCR_JUMP ^ IFTRUE (MASK (CATN, CATN)),
3279: PADDRH (msg_parity),
3280: /*
3281: ** let the host do the real work.
3282: */
3283: SCR_INT,
3284: SIR_NEGO_WIDE,
3285: /*
3286: ** let the target fetch our answer.
3287: */
3288: SCR_SET (SCR_ATN),
3289: 0,
3290: SCR_CLR (SCR_ACK),
3291: 0,
3292:
3293: SCR_INT ^ IFFALSE (WHEN (SCR_MSG_OUT)),
3294: SIR_NEGO_PROTO,
3295: /*
3296: ** Send the M_X_WIDE_REQ
3297: */
3298: SCR_MOVE_ABS (4) ^ SCR_MSG_OUT,
3299: NADDR (msgout),
3300: SCR_CLR (SCR_ATN),
3301: 0,
3302: SCR_COPY (1),
3303: RADDR (sfbr),
3304: NADDR (lastmsg),
3305: SCR_JUMP,
3306: PADDR (msg_out_done),
3307:
3308: }/*-------------------------< MSG_EXT_3 >----------------*/,{
3309: SCR_CLR (SCR_ACK),
3310: 0,
3311: SCR_JUMP ^ IFFALSE (WHEN (SCR_MSG_IN)),
3312: PADDR (dispatch),
3313: /*
3314: ** get extended message code.
3315: */
3316: SCR_MOVE_ABS (1) ^ SCR_MSG_IN,
3317: NADDR (msgin[2]),
3318: /*
3319: ** Check for message parity error.
3320: */
3321: SCR_TO_REG (scratcha),
3322: 0,
3323: SCR_FROM_REG (socl),
3324: 0,
3325: SCR_JUMP ^ IFTRUE (MASK (CATN, CATN)),
3326: PADDRH (msg_parity),
3327: SCR_FROM_REG (scratcha),
3328: 0,
3329: SCR_JUMP ^ IFTRUE (DATA (M_X_SYNC_REQ)),
3330: PADDRH (msg_sdtr),
3331: /*
3332: ** unknown extended message
3333: */
3334: SCR_JUMP,
3335: PADDR (msg_bad)
3336:
3337: }/*-------------------------< MSG_SDTR >-----------------*/,{
3338: SCR_CLR (SCR_ACK),
3339: 0,
3340: SCR_JUMP ^ IFFALSE (WHEN (SCR_MSG_IN)),
3341: PADDR (dispatch),
3342: /*
3343: ** get period and offset
3344: */
3345: SCR_MOVE_ABS (2) ^ SCR_MSG_IN,
3346: NADDR (msgin[3]),
3347: SCR_FROM_REG (socl),
3348: 0,
3349: SCR_JUMP ^ IFTRUE (MASK (CATN, CATN)),
3350: PADDRH (msg_parity),
3351: /*
3352: ** let the host do the real work.
3353: */
3354: SCR_INT,
3355: SIR_NEGO_SYNC,
3356: /*
3357: ** let the target fetch our answer.
3358: */
3359: SCR_SET (SCR_ATN),
3360: 0,
3361: SCR_CLR (SCR_ACK),
3362: 0,
3363:
3364: SCR_INT ^ IFFALSE (WHEN (SCR_MSG_OUT)),
3365: SIR_NEGO_PROTO,
3366: /*
3367: ** Send the M_X_SYNC_REQ
3368: */
3369: SCR_MOVE_ABS (5) ^ SCR_MSG_OUT,
3370: NADDR (msgout),
3371: SCR_CLR (SCR_ATN),
3372: 0,
3373: SCR_COPY (1),
3374: RADDR (sfbr),
3375: NADDR (lastmsg),
3376: SCR_JUMP,
3377: PADDR (msg_out_done),
3378:
3379: }/*-------------------------< MSG_OUT_ABORT >-------------*/,{
3380: /*
3381: ** After ABORT message,
3382: **
3383: ** expect an immediate disconnect, ...
3384: */
3385: SCR_REG_REG (scntl2, SCR_AND, 0x7f),
3386: 0,
3387: SCR_CLR (SCR_ACK|SCR_ATN),
3388: 0,
3389: SCR_WAIT_DISC,
3390: 0,
3391: /*
3392: ** ... and set the status to "ABORTED"
3393: */
3394: SCR_LOAD_REG (HS_REG, HS_ABORTED),
3395: 0,
3396: SCR_JUMP,
3397: PADDR (cleanup),
3398:
3399: }/*-------------------------< GETCC >-----------------------*/,{
3400: /*
3401: ** The ncr doesn't have an indirect load
3402: ** or store command. So we have to
3403: ** copy part of the control block to a
3404: ** fixed place, where we can modify it.
3405: **
3406: ** We patch the address part of a COPY command
3407: ** with the address of the dsa register ...
3408: */
3409: SCR_COPY_F (4),
3410: RADDR (dsa),
3411: PADDRH (getcc1),
3412: /*
3413: ** ... then we do the actual copy.
3414: */
3415: SCR_COPY (sizeof (struct head)),
3416: }/*-------------------------< GETCC1 >----------------------*/,{
3417: 0,
3418: NADDR (header),
3419: /*
3420: ** Initialize the status registers
3421: */
3422: SCR_COPY (4),
3423: NADDR (header.status),
3424: RADDR (scr0),
3425: }/*-------------------------< GETCC2 >----------------------*/,{
3426: /*
3427: ** Get the condition code from a target.
3428: **
3429: ** DSA points to a data structure.
3430: ** Set TEMP to the script location
3431: ** that receives the condition code.
3432: **
3433: ** Because there is no script command
3434: ** to load a longword into a register,
3435: ** we use a CALL command.
3436: */
3437: /*<<<*/ SCR_CALLR,
3438: 24,
3439: /*
3440: ** Get the condition code.
3441: */
3442: SCR_MOVE_TBL ^ SCR_DATA_IN,
3443: offsetof (struct dsb, sense),
3444: /*
3445: ** No data phase may follow!
3446: */
3447: SCR_CALL,
3448: PADDR (checkatn),
3449: SCR_JUMP,
3450: PADDR (no_data),
3451: /*>>>*/
3452:
3453: /*
3454: ** The CALL jumps to this point.
3455: ** Prepare for a RESTORE_POINTER message.
3456: ** Save the TEMP register into the saved pointer.
3457: */
3458: SCR_COPY (4),
3459: RADDR (temp),
3460: NADDR (header.savep),
3461: /*
3462: ** Load scratcha, because in case of a selection timeout,
3463: ** the host will expect a new value for startpos in
3464: ** the scratcha register.
3465: */
3466: SCR_COPY (4),
3467: PADDR (startpos),
3468: RADDR (scratcha),
3469: #ifdef NCR_GETCC_WITHMSG
3470: /*
3471: ** If QUIRK_NOMSG is set, select without ATN.
3472: ** and don't send a message.
3473: */
3474: SCR_FROM_REG (QU_REG),
3475: 0,
3476: SCR_JUMP ^ IFTRUE (MASK (QUIRK_NOMSG, QUIRK_NOMSG)),
3477: PADDRH(getcc3),
3478: /*
3479: ** Then try to connect to the target.
3480: ** If we are reselected, special treatment
3481: ** of the current job is required before
3482: ** accepting the reselection.
3483: */
3484: SCR_SEL_TBL_ATN ^ offsetof (struct dsb, select),
3485: PADDR(badgetcc),
3486: /*
3487: ** save target id.
3488: */
3489: SCR_FROM_REG (sdid),
3490: 0,
3491: SCR_TO_REG (ctest0),
3492: 0,
3493: /*
3494: ** Send the IDENTIFY message.
3495: ** In case of short transfer, remove ATN.
3496: */
3497: SCR_MOVE_TBL ^ SCR_MSG_OUT,
3498: offsetof (struct dsb, smsg2),
3499: SCR_CLR (SCR_ATN),
3500: 0,
3501: /*
3502: ** save the first byte of the message.
3503: */
3504: SCR_COPY (1),
3505: RADDR (sfbr),
3506: NADDR (lastmsg),
3507: SCR_JUMP,
3508: PADDR (prepare2),
3509:
3510: #endif
3511: }/*-------------------------< GETCC3 >----------------------*/,{
3512: /*
3513: ** Try to connect to the target.
3514: ** If we are reselected, special treatment
3515: ** of the current job is required before
3516: ** accepting the reselection.
3517: **
3518: ** Silly target won't accept a message.
3519: ** Select without ATN.
3520: */
3521: SCR_SEL_TBL ^ offsetof (struct dsb, select),
3522: PADDR(badgetcc),
3523: /*
3524: ** save target id.
3525: */
3526: SCR_FROM_REG (sdid),
3527: 0,
3528: SCR_TO_REG (ctest0),
3529: 0,
3530: /*
3531: ** Force error if selection timeout
3532: */
3533: SCR_JUMPR ^ IFTRUE (WHEN (SCR_MSG_IN)),
3534: 0,
3535: /*
3536: ** don't negotiate.
3537: */
3538: SCR_JUMP,
3539: PADDR (prepare2),
3540:
3541: }/*-------------------------< DATA_OUT >-------------------*/,{
3542: /*
3543: ** Because the size depends on the
3544: ** #define MAX_SCATTER parameter,
3545: ** it is filled in at runtime.
3546: **
3547: ** ##===========< i=0; i<MAX_SCATTER >=========
3548: ** || SCR_CALL ^ IFFALSE (WHEN (SCR_DATA_OUT)),
3549: ** || PADDR (dispatch),
3550: ** || SCR_MOVE_TBL ^ SCR_DATA_OUT,
3551: ** || offsetof (struct dsb, data[ i]),
3552: ** ##==========================================
3553: **
3554: ** SCR_CALL,
3555: ** PADDR (dispatch),
3556: ** SCR_JUMP,
3557: ** PADDR (no_data),
3558: **
3559: **---------------------------------------------------------
3560: */
3561: 0
3562: }/*-------------------------< ABORTTAG >-------------------*/,{
3563: /*
3564: ** Abort a bad reselection.
3565: ** Set the message to ABORT vs. ABORT_TAG
3566: */
3567: SCR_LOAD_REG (scratcha, M_ABORT_TAG),
3568: 0,
3569: SCR_JUMPR ^ IFFALSE (CARRYSET),
3570: 8,
3571: }/*-------------------------< ABORT >----------------------*/,{
3572: SCR_LOAD_REG (scratcha, M_ABORT),
3573: 0,
3574: SCR_COPY (1),
3575: RADDR (scratcha),
3576: NADDR (msgout),
3577: SCR_SET (SCR_ATN),
3578: 0,
3579: SCR_CLR (SCR_ACK),
3580: 0,
3581: /*
3582: ** and send it.
3583: ** we expect an immediate disconnect
3584: */
3585: SCR_REG_REG (scntl2, SCR_AND, 0x7f),
3586: 0,
3587: SCR_MOVE_ABS (1) ^ SCR_MSG_OUT,
3588: NADDR (msgout),
3589: SCR_COPY (1),
3590: RADDR (sfbr),
3591: NADDR (lastmsg),
3592: SCR_CLR (SCR_ACK|SCR_ATN),
3593: 0,
3594: SCR_WAIT_DISC,
3595: 0,
3596: SCR_JUMP,
3597: PADDR (start),
3598: }/*-------------------------< SNOOPTEST >-------------------*/,{
3599: /*
3600: ** Read the variable.
3601: */
3602: SCR_COPY (4),
3603: NADDR(ncr_cache),
3604: RADDR (scratcha),
3605: /*
3606: ** Write the variable.
3607: */
3608: SCR_COPY (4),
3609: RADDR (temp),
3610: NADDR(ncr_cache),
3611: /*
3612: ** Read back the variable.
3613: */
3614: SCR_COPY (4),
3615: NADDR(ncr_cache),
3616: RADDR (temp),
3617: }/*-------------------------< SNOOPEND >-------------------*/,{
3618: /*
3619: ** And stop.
3620: */
3621: SCR_INT,
3622: 99,
3623: }/*--------------------------------------------------------*/
3624: };
3625:
3626: /*==========================================================
3627: **
3628: **
3629: ** Fill in #define dependent parts of the script
3630: **
3631: **
3632: **==========================================================
3633: */
3634:
3635: __initfunc(
3636: void ncr_script_fill (struct script * scr, struct scripth * scrh)
3637: )
3638: {
3639: int i;
3640: ncrcmd *p;
3641:
3642: p = scrh->tryloop;
3643: for (i=0; i<MAX_START; i++) {
3644: *p++ =SCR_COPY (4);
3645: *p++ =NADDR (squeue[i]);
3646: *p++ =RADDR (dsa);
3647: *p++ =SCR_CALL;
3648: *p++ =PADDR (trysel);
3649: };
3650: *p++ =SCR_JUMP;
3651: *p++ =PADDRH(tryloop);
3652:
3653: assert ((u_long)p == (u_long)&scrh->tryloop + sizeof (scrh->tryloop));
3654:
3655: p = scr->data_in;
3656:
3657: for (i=0; i<MAX_SCATTER; i++) {
3658: *p++ =SCR_CALL ^ IFFALSE (WHEN (SCR_DATA_IN));
3659: *p++ =PADDR (checkatn);
3660: *p++ =SCR_MOVE_TBL ^ SCR_DATA_IN;
3661: *p++ =offsetof (struct dsb, data[i]);
3662: };
3663:
3664: *p++ =SCR_CALL;
3665: *p++ =PADDR (checkatn);
3666: *p++ =SCR_JUMP;
3667: *p++ =PADDR (no_data);
3668:
3669: assert ((u_long)p == (u_long)&scr->data_in + sizeof (scr->data_in));
3670:
3671: p = scrh->data_out;
3672:
3673: for (i=0; i<MAX_SCATTER; i++) {
3674: *p++ =SCR_CALL ^ IFFALSE (WHEN (SCR_DATA_OUT));
3675: *p++ =PADDR (dispatch);
3676: *p++ =SCR_MOVE_TBL ^ SCR_DATA_OUT;
3677: *p++ =offsetof (struct dsb, data[i]);
3678: };
3679:
3680: *p++ =SCR_CALL;
3681: *p++ =PADDR (dispatch);
3682: *p++ =SCR_JUMP;
3683: *p++ =PADDR (no_data);
3684:
3685: assert ((u_long)p == (u_long)&scrh->data_out + sizeof (scrh->data_out));
3686: }
3687:
3688: /*==========================================================
3689: **
3690: **
3691: ** Copy and rebind a script.
3692: **
3693: **
3694: **==========================================================
3695: */
3696:
3697: __initfunc(
3698: static void ncr_script_copy_and_bind (ncb_p np, ncrcmd *src, ncrcmd *dst, int len)
3699: )
3700: {
3701: ncrcmd opcode, new, old, tmp1, tmp2;
3702: ncrcmd *start, *end;
3703: int relocs;
3704: int opchanged = 0;
3705:
3706: start = src;
3707: end = src + len/4;
3708:
3709: while (src < end) {
3710:
3711: opcode = *src++;
3712: *dst++ = cpu_to_scr(opcode);
3713:
3714: /*
3715: ** If we forget to change the length
3716: ** in struct script, a field will be
3717: ** padded with 0. This is an illegal
3718: ** command.
3719: */
3720:
3721: if (opcode == 0) {
3722: printf ("%s: ERROR0 IN SCRIPT at %d.\n",
3723: ncr_name(np), (int) (src-start-1));
3724: DELAY (1000000);
3725: };
3726:
3727: if (DEBUG_FLAGS & DEBUG_SCRIPT)
3728: printf ("%p: <%x>\n",
3729: (src-1), (unsigned)opcode);
3730:
3731: /*
3732: ** We don't have to decode ALL commands
3733: */
3734: switch (opcode >> 28) {
3735:
3736: case 0xc:
3737: /*
3738: ** COPY has TWO arguments.
3739: */
3740: relocs = 2;
3741: tmp1 = src[0];
3742: if ((tmp1 & RELOC_MASK) == RELOC_KVAR)
3743: tmp1 = 0;
3744: tmp2 = src[1];
3745: if ((tmp2 & RELOC_MASK) == RELOC_KVAR)
3746: tmp2 = 0;
3747: if ((tmp1 ^ tmp2) & 3) {
3748: printf ("%s: ERROR1 IN SCRIPT at %d.\n",
3749: ncr_name(np), (int) (src-start-1));
3750: DELAY (1000000);
3751: }
3752: /*
3753: ** If PREFETCH feature not enabled, remove
3754: ** the NO FLUSH bit if present.
3755: */
3756: if ((opcode & SCR_NO_FLUSH) && !(np->features & FE_PFEN)) {
3757: dst[-1] = cpu_to_scr(opcode & ~SCR_NO_FLUSH);
3758: ++opchanged;
3759: }
3760: break;
3761:
3762: case 0x0:
3763: /*
3764: ** MOVE (absolute address)
3765: */
3766: relocs = 1;
3767: break;
3768:
3769: case 0x8:
3770: /*
3771: ** JUMP / CALL
3772: ** don't relocate if relative :-)
3773: */
3774: if (opcode & 0x00800000)
3775: relocs = 0;
3776: else
3777: relocs = 1;
3778: break;
3779:
3780: case 0x4:
3781: case 0x5:
3782: case 0x6:
3783: case 0x7:
3784: relocs = 1;
3785: break;
3786:
3787: default:
3788: relocs = 0;
3789: break;
3790: };
3791:
3792: if (relocs) {
3793: while (relocs--) {
3794: old = *src++;
3795:
3796: switch (old & RELOC_MASK) {
3797: case RELOC_REGISTER:
3798: new = (old & ~RELOC_MASK) + np->paddr;
3799: break;
3800: case RELOC_LABEL:
3801: new = (old & ~RELOC_MASK) + np->p_script;
3802: break;
3803: case RELOC_LABELH:
3804: new = (old & ~RELOC_MASK) + np->p_scripth;
3805: break;
3806: case RELOC_SOFTC:
3807: new = (old & ~RELOC_MASK) + vtophys(np);
3808: break;
3809: case RELOC_KVAR:
3810: if (((old & ~RELOC_MASK) <
3811: SCRIPT_KVAR_FIRST) ||
3812: ((old & ~RELOC_MASK) >
3813: SCRIPT_KVAR_LAST))
3814: panic("ncr KVAR out of range");
3815: new = vtophys(script_kvars[old &
3816: ~RELOC_MASK]);
3817: break;
3818: case 0:
3819: /* Don't relocate a 0 address. */
3820: if (old == 0) {
3821: new = old;
3822: break;
3823: }
3824: /* fall through */
3825: default:
3826: panic("ncr_script_copy_and_bind: weird relocation %x\n", old);
3827: break;
3828: }
3829:
3830: *dst++ = cpu_to_scr(new);
3831: }
3832: } else
3833: *dst++ = cpu_to_scr(*src++);
3834:
3835: };
3836: if (bootverbose > 1 && opchanged)
3837: printf("%s: NO FLUSH bit removed from %d script instructions\n",
3838: ncr_name(np), opchanged);
3839: }
3840:
3841: /*==========================================================
3842: **
3843: **
3844: ** Auto configuration: attach and init a host adapter.
3845: **
3846: **
3847: **==========================================================
3848: */
3849:
3850: /*
3851: ** Linux host data structure
3852: **
3853: ** The script area is allocated in the host data structure
3854: ** because kmalloc() returns NULL during scsi initialisations
3855: ** with Linux 1.2.X
3856: */
3857:
3858: struct host_data {
3859: struct ncb *ncb;
3860:
3861: char ncb_align[NCB_ALIGN_SIZE-1]; /* Filler for alignment */
3862: struct ncb _ncb_data;
3863:
3864: char ccb_align[CCB_ALIGN_SIZE-1]; /* Filler for alignment */
3865: struct ccb _ccb_data;
3866:
3867: char scr_align[SCR_ALIGN_SIZE-1]; /* Filler for alignment */
3868: struct script script_data;
3869:
3870: struct scripth scripth_data;
3871: };
3872:
3873: /*
3874: ** Print something which allow to retrieve the controler type, unit,
3875: ** target, lun concerned by a kernel message.
3876: */
3877:
3878: #define PRINT_LUN(np, target, lun) \
3879: printf(KERN_INFO "%s-<%d,%d>: ", ncr_name(np), (int) (target), (int) (lun))
3880:
3881: static void PRINT_ADDR(Scsi_Cmnd *cmd)
3882: {
3883: struct host_data *host_data = (struct host_data *) cmd->host->hostdata;
3884: ncb_p np = host_data->ncb;
3885: if (np) PRINT_LUN(np, cmd->target, cmd->lun);
3886: }
3887:
3888: /*==========================================================
3889: **
3890: ** NCR chip clock divisor table.
3891: ** Divisors are multiplied by 10,000,000 in order to make
3892: ** calculations more simple.
3893: **
3894: **==========================================================
3895: */
3896:
3897: #define _5M 5000000
3898: static u_long div_10M[] =
3899: {2*_5M, 3*_5M, 4*_5M, 6*_5M, 8*_5M, 12*_5M, 16*_5M};
3900:
3901:
3902: /*===============================================================
3903: **
3904: ** Prepare io register values used by ncr_init() according
3905: ** to selected and supported features.
3906: **
3907: ** NCR chips allow burst lengths of 2, 4, 8, 16, 32, 64, 128
3908: ** transfers. 32,64,128 are only supported by 875 and 895 chips.
3909: ** We use log base 2 (burst length) as internal code, with
3910: ** value 0 meaning "burst disabled".
3911: **
3912: **===============================================================
3913: */
3914:
3915: /*
3916: * Burst length from burst code.
3917: */
3918: #define burst_length(bc) (!(bc))? 0 : 1 << (bc)
3919:
3920: /*
3921: * Burst code from io register bits.
3922: */
3923: #define burst_code(dmode, ctest4, ctest5) \
3924: (ctest4) & 0x80? 0 : (((dmode) & 0xc0) >> 6) + ((ctest5) & 0x04) + 1
3925:
3926: /*
3927: * Set initial io register bits from burst code.
3928: */
3929: static inline void ncr_init_burst(ncb_p np, u_char bc)
3930: {
3931: np->rv_ctest4 &= ~0x80;
3932: np->rv_dmode &= ~(0x3 << 6);
3933: np->rv_ctest5 &= ~0x4;
3934:
3935: if (!bc) {
3936: np->rv_ctest4 |= 0x80;
3937: }
3938: else {
3939: --bc;
3940: np->rv_dmode |= ((bc & 0x3) << 6);
3941: np->rv_ctest5 |= (bc & 0x4);
3942: }
3943: }
3944:
3945: #ifdef SCSI_NCR_NVRAM_SUPPORT
3946:
3947: /*
3948: ** Get target set-up from Symbios format NVRAM.
3949: */
3950:
3951: __initfunc(
3952: static void
3953: ncr_Symbios_setup_target(ncb_p np, int target, Symbios_nvram *nvram)
3954: )
3955: {
3956: tcb_p tp = &np->target[target];
3957: Symbios_target *tn = &nvram->target[target];
3958:
3959: tp->usrsync = tn->sync_period ? (tn->sync_period + 3) / 4 : 255;
3960: tp->usrwide = tn->bus_width == 0x10 ? 1 : 0;
3961: tp->usrtags =
3962: (tn->flags & SYMBIOS_QUEUE_TAGS_ENABLED)? SCSI_NCR_MAX_TAGS : 0;
3963:
3964: if (!(tn->flags & SYMBIOS_DISCONNECT_ENABLE))
3965: tp->usrflag |= UF_NODISC;
3966: if (!(tn->flags & SYMBIOS_SCAN_AT_BOOT_TIME))
3967: tp->usrflag |= UF_NOSCAN;
3968: }
3969:
3970: /*
3971: ** Get target set-up from Tekram format NVRAM.
3972: */
3973:
3974: __initfunc(
3975: static void
3976: ncr_Tekram_setup_target(ncb_p np, int target, Tekram_nvram *nvram)
3977: )
3978: {
3979: tcb_p tp = &np->target[target];
3980: struct Tekram_target *tn = &nvram->target[target];
3981: int i;
3982:
3983: if (tn->flags & TEKRAM_SYNC_NEGO) {
3984: i = tn->sync_index & 0xf;
3985: tp->usrsync = i < 12 ? Tekram_sync[i] : 255;
3986: }
3987:
3988: tp->usrwide = (tn->flags & TEKRAM_WIDE_NEGO) ? 1 : 0;
3989:
3990: if (tn->flags & TEKRAM_TAGGED_COMMANDS) {
3991: tp->usrtags = 2 << nvram->max_tags_index;
3992: if (tp->usrtags > SCSI_NCR_MAX_TAGS)
3993: tp->usrtags = SCSI_NCR_MAX_TAGS;
3994: }
3995:
3996: if (!(tn->flags & TEKRAM_DISCONNECT_ENABLE))
3997: tp->usrflag = UF_NODISC;
3998:
3999: /* If any device does not support parity, we will not use this option */
4000: if (!(tn->flags & TEKRAM_PARITY_CHECK))
4001: np->rv_scntl0 &= ~0x0a; /* SCSI parity checking disabled */
4002: }
4003: #endif /* SCSI_NCR_NVRAM_SUPPORT */
4004:
4005: __initfunc(
4006: static int ncr_prepare_setting(ncb_p np, ncr_nvram *nvram)
4007: )
4008: {
4009: u_char burst_max;
4010: u_long period;
4011: int i;
4012:
4013: /*
4014: ** Save assumed BIOS setting
4015: */
4016:
4017: np->sv_scntl0 = INB(nc_scntl0) & 0x0a;
4018: np->sv_scntl3 = INB(nc_scntl3) & 0x07;
4019: np->sv_dmode = INB(nc_dmode) & 0xce;
4020: np->sv_dcntl = INB(nc_dcntl) & 0xa8;
4021: np->sv_ctest3 = INB(nc_ctest3) & 0x01;
4022: np->sv_ctest4 = INB(nc_ctest4) & 0x80;
4023: np->sv_ctest5 = INB(nc_ctest5) & 0x24;
4024: np->sv_gpcntl = INB(nc_gpcntl);
4025: np->sv_stest2 = INB(nc_stest2) & 0x20;
4026: np->sv_stest4 = INB(nc_stest4);
4027:
4028: /*
4029: ** Wide ?
4030: */
4031:
4032: np->maxwide = (np->features & FE_WIDE)? 1 : 0;
4033:
4034: /*
4035: ** Get the frequency of the chip's clock.
4036: ** Find the right value for scntl3.
4037: */
4038:
4039: if (np->features & FE_QUAD)
4040: np->multiplier = 4;
4041: else if (np->features & FE_DBLR)
4042: np->multiplier = 2;
4043: else
4044: np->multiplier = 1;
4045:
4046: np->clock_khz = (np->features & FE_CLK80)? 80000 : 40000;
4047: np->clock_khz *= np->multiplier;
4048:
4049: if (np->clock_khz != 40000)
4050: ncr_getclock(np, np->multiplier);
4051:
4052: /*
4053: * Divisor to be used for async (timer pre-scaler).
4054: */
4055: i = np->clock_divn - 1;
4056: while (i >= 0) {
4057: --i;
4058: if (10ul * SCSI_NCR_MIN_ASYNC * np->clock_khz > div_10M[i]) {
4059: ++i;
4060: break;
4061: }
4062: }
4063: np->rv_scntl3 = i+1;
4064:
4065: /*
4066: * Minimum synchronous period factor supported by the chip.
4067: * Btw, 'period' is in tenths of nanoseconds.
4068: */
4069:
4070: period = (4 * div_10M[0] + np->clock_khz - 1) / np->clock_khz;
4071: if (period <= 250) np->minsync = 10;
4072: else if (period <= 303) np->minsync = 11;
4073: else if (period <= 500) np->minsync = 12;
4074: else np->minsync = (period + 40 - 1) / 40;
4075:
4076: /*
4077: * Check against chip SCSI standard support (SCSI-2,ULTRA,ULTRA2).
4078: */
4079:
4080: if (np->minsync < 25 && !(np->features & (FE_ULTRA|FE_ULTRA2)))
4081: np->minsync = 25;
4082: else if (np->minsync < 12 && !(np->features & FE_ULTRA2))
4083: np->minsync = 12;
4084:
4085: /*
4086: * Maximum synchronous period factor supported by the chip.
4087: */
4088:
4089: period = (11 * div_10M[np->clock_divn - 1]) / (4 * np->clock_khz);
4090: np->maxsync = period > 2540 ? 254 : period / 10;
4091:
4092: /*
4093: ** Prepare initial value of other IO registers
4094: */
4095: #if defined SCSI_NCR_TRUST_BIOS_SETTING
4096: np->rv_scntl0 = np->sv_scntl0;
4097: np->rv_dmode = np->sv_dmode;
4098: np->rv_dcntl = np->sv_dcntl;
4099: np->rv_ctest3 = np->sv_ctest3;
4100: np->rv_ctest4 = np->sv_ctest4;
4101: np->rv_ctest5 = np->sv_ctest5;
4102: burst_max = burst_code(np->sv_dmode, np->sv_ctest4, np->sv_ctest5);
4103: #else
4104:
4105: /*
4106: ** Select burst length (dwords)
4107: */
4108: burst_max = driver_setup.burst_max;
4109: if (burst_max == 255)
4110: burst_max = burst_code(np->sv_dmode, np->sv_ctest4, np->sv_ctest5);
4111: if (burst_max > 7)
4112: burst_max = 7;
4113: if (burst_max > np->maxburst)
4114: burst_max = np->maxburst;
4115:
4116: /*
4117: ** Select all supported special features
4118: */
4119: if (np->features & FE_ERL)
4120: np->rv_dmode |= ERL; /* Enable Read Line */
4121: if (np->features & FE_BOF)
4122: np->rv_dmode |= BOF; /* Burst Opcode Fetch */
4123: if (np->features & FE_ERMP)
4124: np->rv_dmode |= ERMP; /* Enable Read Multiple */
4125: if (np->features & FE_PFEN)
4126: np->rv_dcntl |= PFEN; /* Prefetch Enable */
4127: if (np->features & FE_CLSE)
4128: np->rv_dcntl |= CLSE; /* Cache Line Size Enable */
4129: if (np->features & FE_WRIE)
4130: np->rv_ctest3 |= WRIE; /* Write and Invalidate */
4131: if (np->features & FE_DFS)
4132: np->rv_ctest5 |= DFS; /* Dma Fifo Size */
4133:
4134: /*
4135: ** Select some other
4136: */
4137: if (driver_setup.master_parity)
4138: np->rv_ctest4 |= MPEE; /* Master parity checking */
4139: if (driver_setup.scsi_parity)
4140: np->rv_scntl0 |= 0x0a; /* full arb., ena parity, par->ATN */
4141:
4142: #ifdef SCSI_NCR_NVRAM_SUPPORT
4143: /*
4144: ** Get parity checking, host ID and verbose mode from NVRAM
4145: **/
4146: if (nvram) {
4147: switch(nvram->type) {
4148: case SCSI_NCR_TEKRAM_NVRAM:
4149: np->myaddr = nvram->data.Tekram.host_id & 0x0f;
4150: break;
4151: case SCSI_NCR_SYMBIOS_NVRAM:
4152: if (!(nvram->data.Symbios.flags & SYMBIOS_PARITY_ENABLE))
4153: np->rv_scntl0 &= ~0x0a;
4154: np->myaddr = nvram->data.Symbios.host_id & 0x0f;
4155: if (nvram->data.Symbios.flags & SYMBIOS_VERBOSE_MSGS)
4156: np->verbose += 1;
4157: break;
4158: }
4159: }
4160: #endif
4161: /*
4162: ** Get SCSI addr of host adapter (set by bios?).
4163: */
4164: if (!np->myaddr) np->myaddr = INB(nc_scid) & 0x07;
4165: if (!np->myaddr) np->myaddr = SCSI_NCR_MYADDR;
4166:
4167:
4168: #endif /* SCSI_NCR_TRUST_BIOS_SETTING */
4169:
4170: /*
4171: * Prepare initial io register bits for burst length
4172: */
4173: ncr_init_burst(np, burst_max);
4174:
4175: /*
4176: ** Set differential mode and LED support.
4177: ** Ignore these features for boards known to use a
4178: ** specific GPIO wiring (Tekram only for now).
4179: ** Probe initial setting of GPREG and GPCNTL for
4180: ** other ones.
4181: */
4182: if (!nvram || nvram->type != SCSI_NCR_TEKRAM_NVRAM) {
4183: switch(driver_setup.diff_support) {
4184: case 3:
4185: if (INB(nc_gpreg) & 0x08)
4186: break;
4187: case 2:
4188: np->rv_stest2 |= 0x20;
4189: break;
4190: case 1:
4191: np->rv_stest2 |= (np->sv_stest2 & 0x20);
4192: break;
4193: default:
4194: break;
4195: }
4196: }
4197: if ((driver_setup.led_pin ||
4198: (nvram && nvram->type == SCSI_NCR_SYMBIOS_NVRAM)) &&
4199: !(np->sv_gpcntl & 0x01))
4200: np->features |= FE_LED0;
4201:
4202: /*
4203: ** Set irq mode.
4204: */
4205: switch(driver_setup.irqm) {
4206: case 2:
4207: np->rv_dcntl |= IRQM;
4208: break;
4209: case 1:
4210: np->rv_dcntl |= (np->sv_dcntl & IRQM);
4211: break;
4212: default:
4213: break;
4214: }
4215:
4216: /*
4217: ** Configure targets according to driver setup.
4218: ** If NVRAM present get targets setup from NVRAM.
4219: ** Allow to override sync, wide and NOSCAN from
4220: ** boot command line.
4221: */
4222: for (i = 0 ; i < MAX_TARGET ; i++) {
4223: tcb_p tp = &np->target[i];
4224:
4225: tp->usrsync = 255;
4226: #ifdef SCSI_NCR_NVRAM_SUPPORT
4227: if (nvram) {
4228: switch(nvram->type) {
4229: case SCSI_NCR_TEKRAM_NVRAM:
4230: ncr_Tekram_setup_target(np, i, &nvram->data.Tekram);
4231: break;
4232: case SCSI_NCR_SYMBIOS_NVRAM:
4233: ncr_Symbios_setup_target(np, i, &nvram->data.Symbios);
4234: break;
4235: }
4236: if (driver_setup.use_nvram & 0x2)
4237: tp->usrsync = driver_setup.default_sync;
4238: if (driver_setup.use_nvram & 0x4)
4239: tp->usrwide = driver_setup.max_wide;
4240: if (driver_setup.use_nvram & 0x8)
4241: tp->usrflag &= ~UF_NOSCAN;
4242: }
4243: else {
4244: #else
4245: if (1) {
4246: #endif
4247: tp->usrsync = driver_setup.default_sync;
4248: tp->usrwide = driver_setup.max_wide;
4249: tp->usrtags = driver_setup.default_tags;
4250: if (!driver_setup.disconnection)
4251: np->target[i].usrflag = UF_NODISC;
4252: }
4253: }
4254:
4255: /*
4256: ** Announce all that stuff to user.
4257: */
4258:
4259: i = nvram ? nvram->type : 0;
4260: printf(KERN_INFO "%s: %sID %d, Fast-%d%s%s\n", ncr_name(np),
4261: i == SCSI_NCR_SYMBIOS_NVRAM ? "Symbios format NVRAM, " :
4262: (i == SCSI_NCR_TEKRAM_NVRAM ? "Tekram format NVRAM, " : ""),
4263: np->myaddr,
4264: np->minsync < 12 ? 40 : (np->minsync < 25 ? 20 : 10),
4265: (np->rv_scntl0 & 0xa) ? ", Parity Checking" : ", NO Parity",
4266: (np->rv_stest2 & 0x20) ? ", Differential" : "");
4267:
4268: if (bootverbose > 1) {
4269: printf ("%s: initial SCNTL3/DMODE/DCNTL/CTEST3/4/5 = "
4270: "(hex) %02x/%02x/%02x/%02x/%02x/%02x\n",
4271: ncr_name(np), np->sv_scntl3, np->sv_dmode, np->sv_dcntl,
4272: np->sv_ctest3, np->sv_ctest4, np->sv_ctest5);
4273:
4274: printf ("%s: final SCNTL3/DMODE/DCNTL/CTEST3/4/5 = "
4275: "(hex) %02x/%02x/%02x/%02x/%02x/%02x\n",
4276: ncr_name(np), np->rv_scntl3, np->rv_dmode, np->rv_dcntl,
4277: np->rv_ctest3, np->rv_ctest4, np->rv_ctest5);
4278: }
4279:
4280: if (bootverbose && np->paddr2)
4281: printf (KERN_INFO "%s: on-board RAM at 0x%lx\n",
4282: ncr_name(np), np->paddr2);
4283:
4284: return 0;
4285: }
4286:
4287:
4288: #ifdef SCSI_NCR_DEBUG_NVRAM
4289:
4290: __initfunc(
4291: void ncr_display_Symbios_nvram(ncb_p np, Symbios_nvram *nvram)
4292: )
4293: {
4294: int i;
4295:
4296: /* display Symbios nvram host data */
4297: printf("%s: HOST ID=%d%s%s%s%s\n",
4298: ncr_name(np), nvram->host_id & 0x0f,
4299: (nvram->flags & SYMBIOS_SCAM_ENABLE) ? " SCAM" :"",
4300: (nvram->flags & SYMBIOS_PARITY_ENABLE) ? " PARITY" :"",
4301: (nvram->flags & SYMBIOS_VERBOSE_MSGS) ? " VERSBOSE" :"",
4302: (nvram->flags1 & SYMBIOS_SCAN_HI_LO) ? " HI_LO" :"");
4303:
4304: /* display Symbios nvram drive data */
4305: for (i = 0 ; i < 15 ; i++) {
4306: struct Symbios_target *tn = &nvram->target[i];
4307: printf("%s-%d:%s%s%s%s WIDTH=%d SYNC=%d TMO=%d\n",
4308: ncr_name(np), i,
4309: (tn->flags & SYMBIOS_DISCONNECT_ENABLE) ? " DISC" : "",
4310: (tn->flags & SYMBIOS_SCAN_AT_BOOT_TIME) ? " SCAN_BOOT" : "",
4311: (tn->flags & SYMBIOS_SCAN_LUNS) ? " SCAN_LUNS" : "",
4312: (tn->flags & SYMBIOS_QUEUE_TAGS_ENABLED)? " TCQ" : "",
4313: tn->bus_width,
4314: tn->sync_period / 4,
4315: tn->timeout);
4316: }
4317: }
4318:
4319: static u_char Tekram_boot_delay[7] __initdata = {3, 5, 10, 20, 30, 60, 120};
4320:
4321: __initfunc(
4322: void ncr_display_Tekram_nvram(ncb_p np, Tekram_nvram *nvram)
4323: )
4324: {
4325: int i, tags, boot_delay;
4326: char *rem;
4327:
4328: /* display Tekram nvram host data */
4329: tags = 2 << nvram->max_tags_index;
4330: boot_delay = 0;
4331: if (nvram->boot_delay_index < 6)
4332: boot_delay = Tekram_boot_delay[nvram->boot_delay_index];
4333: switch((nvram->flags & TEKRAM_REMOVABLE_FLAGS) >> 6) {
4334: default:
4335: case 0: rem = ""; break;
4336: case 1: rem = " REMOVABLE=boot device"; break;
4337: case 2: rem = " REMOVABLE=all"; break;
4338: }
4339:
4340: printf("%s: HOST ID=%d%s%s%s%s%s%s%s%s%s BOOT DELAY=%d tags=%d\n",
4341: ncr_name(np), nvram->host_id & 0x0f,
4342: (nvram->flags1 & SYMBIOS_SCAM_ENABLE) ? " SCAM" :"",
4343: (nvram->flags & TEKRAM_MORE_THAN_2_DRIVES) ? " >2DRIVES" :"",
4344: (nvram->flags & TEKRAM_DRIVES_SUP_1GB) ? " >1GB" :"",
4345: (nvram->flags & TEKRAM_RESET_ON_POWER_ON) ? " RESET" :"",
4346: (nvram->flags & TEKRAM_ACTIVE_NEGATION) ? " ACT_NEG" :"",
4347: (nvram->flags & TEKRAM_IMMEDIATE_SEEK) ? " IMM_SEEK" :"",
4348: (nvram->flags & TEKRAM_SCAN_LUNS) ? " SCAN_LUNS" :"",
4349: (nvram->flags1 & TEKRAM_F2_F6_ENABLED) ? " F2_F6" :"",
4350: rem, boot_delay, tags);
4351:
4352: /* display Tekram nvram drive data */
4353: for (i = 0; i <= 15; i++) {
4354: int sync, j;
4355: struct Tekram_target *tn = &nvram->target[i];
4356: j = tn->sync_index & 0xf;
4357: sync = j < 12 ? Tekram_sync[j] : 255;
4358: printf("%s-%d:%s%s%s%s%s%s PERIOD=%d\n",
4359: ncr_name(np), i,
4360: (tn->flags & TEKRAM_PARITY_CHECK) ? " PARITY" : "",
4361: (tn->flags & TEKRAM_SYNC_NEGO) ? " SYNC" : "",
4362: (tn->flags & TEKRAM_DISCONNECT_ENABLE) ? " DISC" : "",
4363: (tn->flags & TEKRAM_START_CMD) ? " START" : "",
4364: (tn->flags & TEKRAM_TAGGED_COMMANDS) ? " TCQ" : "",
4365: (tn->flags & TEKRAM_WIDE_NEGO) ? " WIDE" : "",
4366: sync);
4367: }
4368: }
4369: #endif /* SCSI_NCR_DEBUG_NVRAM */
4370:
4371: /*
4372: ** Host attach and initialisations.
4373: **
4374: ** Allocate host data and ncb structure.
4375: ** Request IO region and remap MMIO region.
4376: ** Do chip initialization.
4377: ** If all is OK, install interrupt handling and
4378: ** start the timer daemon.
4379: */
4380:
4381: __initfunc(
4382: static int ncr_attach (Scsi_Host_Template *tpnt, int unit, ncr_device *device)
4383: )
4384: {
4385: struct host_data *host_data;
4386: ncb_p np;
4387: struct Scsi_Host *instance = 0;
4388: u_long flags = 0;
4389: ncr_nvram *nvram = device->nvram;
4390:
4391: printf(KERN_INFO "ncr53c%s-%d: rev=0x%02x, base=0x%x, io_port=0x%x, irq=%d\n",
4392: device->chip.name, unit, device->chip.revision_id, device->slot.base,
4393: device->slot.io_port, device->slot.irq);
4394:
4395: /*
4396: ** Allocate host_data structure
4397: */
4398: if (!(instance = scsi_register(tpnt, sizeof(*host_data))))
4399: goto attach_error;
4400:
4401: /*
4402: ** Initialize structure.
4403: */
4404: host_data = (struct host_data *) instance->hostdata;
4405:
4406: /*
4407: ** Align np and first ccb to 32 boundary for cache line
4408: ** bursting when copying the global header.
4409: */
4410: np = (ncb_p) (((u_long) &host_data->_ncb_data) & NCB_ALIGN_MASK);
4411: host_data->ncb = np;
4412: bzero (np, sizeof (*np));
4413:
4414: np->ccb = (ccb_p) (((u_long) &host_data->_ccb_data) & CCB_ALIGN_MASK);
4415: bzero (np->ccb, sizeof (*np->ccb));
4416:
4417: /*
4418: ** Store input informations in the host data structure.
4419: */
4420: strncpy(np->chip_name, device->chip.name, sizeof(np->chip_name) - 1);
4421: np->unit = unit;
4422: np->verbose = driver_setup.verbose;
4423: sprintf(np->inst_name, "ncr53c%s-%d", np->chip_name, np->unit);
4424: np->device_id = device->chip.device_id;
4425: np->revision_id = device->chip.revision_id;
4426: np->features = device->chip.features;
4427: np->clock_divn = device->chip.nr_divisor;
4428: np->maxoffs = device->chip.offset_max;
4429: np->maxburst = device->chip.burst_max;
4430:
4431: np->script0 =
4432: (struct script *) (((u_long) &host_data->script_data) & SCR_ALIGN_MASK);
4433: np->scripth0 = &host_data->scripth_data;
4434:
4435: /*
4436: ** Initialize timer structure
4437: **
4438: */
4439: init_timer(&np->timer);
4440: np->timer.data = (unsigned long) np;
4441: np->timer.function = ncr53c8xx_timeout;
4442:
4443: /*
4444: ** Try to map the controller chip to
4445: ** virtual and physical memory.
4446: */
4447:
4448: np->paddr = device->slot.base;
4449: np->paddr2 = (np->features & FE_RAM)? device->slot.base_2 : 0;
4450:
4451: #ifndef NCR_IOMAPPED
4452: np->vaddr = remap_pci_mem((u_long) np->paddr, (u_long) 128);
4453: if (!np->vaddr) {
4454: printf("%s: can't map memory mapped IO region\n", ncr_name(np));
4455: goto attach_error;
4456: }
4457: else
4458: if (bootverbose > 1)
4459: printf("%s: using memory mapped IO at virtual address 0x%lx\n", ncr_name(np), (u_long) np->vaddr);
4460:
4461: /*
4462: ** Make the controller's registers available.
4463: ** Now the INB INW INL OUTB OUTW OUTL macros
4464: ** can be used safely.
4465: */
4466:
4467: np->reg = (struct ncr_reg*) np->vaddr;
4468:
4469: #endif /* !defined NCR_IOMAPPED */
4470:
4471: /*
4472: ** Try to map the controller chip into iospace.
4473: */
4474:
4475: request_region(device->slot.io_port, 128, "ncr53c8xx");
4476: np->port = device->slot.io_port;
4477:
4478: #ifdef SCSI_NCR_NVRAM_SUPPORT
4479: if (nvram) {
4480: switch(nvram->type) {
4481: case SCSI_NCR_SYMBIOS_NVRAM:
4482: #ifdef SCSI_NCR_DEBUG_NVRAM
4483: ncr_display_Symbios_nvram(np, &nvram->data.Symbios);
4484: #endif
4485: break;
4486: case SCSI_NCR_TEKRAM_NVRAM:
4487: #ifdef SCSI_NCR_DEBUG_NVRAM
4488: ncr_display_Tekram_nvram(np, &nvram->data.Tekram);
4489: #endif
4490: break;
4491: default:
4492: nvram = 0;
4493: #ifdef SCSI_NCR_DEBUG_NVRAM
4494: printf("%s: NVRAM: None or invalid data.\n", ncr_name(np));
4495: #endif
4496: }
4497: }
4498: #endif
4499:
4500: /*
4501: ** Do chip dependent initialization.
4502: */
4503: (void)ncr_prepare_setting(np, nvram);
4504:
4505: #ifndef NCR_IOMAPPED
4506: if (np->paddr2 && sizeof(struct script) <= 4096) {
4507: np->vaddr2 = remap_pci_mem((u_long) np->paddr2, (u_long) 4096);
4508: if (!np->vaddr2) {
4509: printf("%s: can't map memory mapped IO region\n", ncr_name(np));
4510: goto attach_error;
4511: }
4512: else
4513: if (bootverbose > 1)
4514: printf("%s: on-board ram mapped at virtual address 0x%lx\n", ncr_name(np), (u_long) np->vaddr2);
4515: }
4516: #endif /* !defined NCR_IOMAPPED */
4517:
4518: /*
4519: ** Fill Linux host instance structure
4520: */
4521: #if LINUX_VERSION_CODE >= LinuxVersionCode(1,3,0)
4522: instance->max_channel = 0;
4523: instance->max_id = np->maxwide ? 16 : 8;
4524: instance->max_lun = SCSI_NCR_MAX_LUN;
4525: #endif
4526: #ifndef NCR_IOMAPPED
4527: instance->base = (char *) np->reg;
4528: #endif
4529: instance->irq = device->slot.irq;
4530: instance->io_port = device->slot.io_port;
4531: instance->n_io_port = 128;
4532: instance->dma_channel = 0;
4533: #if LINUX_VERSION_CODE >= LinuxVersionCode(2,0,0)
4534: instance->select_queue_depths = ncr53c8xx_select_queue_depths;
4535: #endif
4536:
4537: /*
4538: ** Patch script to physical addresses
4539: */
4540: ncr_script_fill (&script0, &scripth0);
4541:
4542: np->scripth = np->scripth0;
4543: np->p_scripth = vtophys(np->scripth);
4544:
4545: np->script = (np->vaddr2) ? (struct script *) np->vaddr2 : np->script0;
4546: np->p_script = (np->vaddr2) ? np->paddr2 : vtophys(np->script0);
4547:
4548: ncr_script_copy_and_bind (np, (ncrcmd *) &script0, (ncrcmd *) np->script0, sizeof(struct script));
4549: ncr_script_copy_and_bind (np, (ncrcmd *) &scripth0, (ncrcmd *) np->scripth0, sizeof(struct scripth));
4550: np->ccb->p_ccb = vtophys (np->ccb);
4551:
4552: /*
4553: ** Patch the script for LED support.
4554: */
4555:
4556: if (np->features & FE_LED0) {
4557: np->script0->reselect[0] =
4558: cpu_to_scr(SCR_REG_REG(gpreg, SCR_OR, 0x01));
4559: np->script0->reselect1[0] =
4560: cpu_to_scr(SCR_REG_REG(gpreg, SCR_AND, 0xfe));
4561: np->script0->reselect2[0] =
4562: cpu_to_scr(SCR_REG_REG(gpreg, SCR_AND, 0xfe));
4563: }
4564:
4565: /*
4566: ** init data structure
4567: */
4568:
4569: np->jump_tcb.l_cmd = cpu_to_scr(SCR_JUMP);
4570: np->jump_tcb.l_paddr = cpu_to_scr(NCB_SCRIPTH_PHYS (np, abort));
4571:
4572: /*
4573: ** Reset chip.
4574: */
4575:
4576: OUTB (nc_istat, SRST);
4577: DELAY (1000);
4578: OUTB (nc_istat, 0 );
4579:
4580: /*
4581: ** Now check the cache handling of the pci chipset.
4582: */
4583:
4584: if (ncr_snooptest (np)) {
4585: printf ("CACHE INCORRECTLY CONFIGURED.\n");
4586: goto attach_error;
4587: };
4588:
4589: /*
4590: ** Install the interrupt handler.
4591: */
4592: #if LINUX_VERSION_CODE >= LinuxVersionCode(1,3,70)
4593: #ifdef SCSI_NCR_SHARE_IRQ
4594: if (bootverbose > 1)
4595: printf("%s: requesting shared irq %d (dev_id=0x%lx)\n",
4596: ncr_name(np), device->slot.irq, (u_long) np);
4597: if (request_irq(device->slot.irq, ncr53c8xx_intr,
4598: SA_INTERRUPT|SA_SHIRQ, "ncr53c8xx", np)) {
4599: #else
4600: if (request_irq(device->slot.irq, ncr53c8xx_intr,
4601: SA_INTERRUPT, "ncr53c8xx", np)) {
4602: #endif
4603: #else
4604: if (request_irq(device->slot.irq, ncr53c8xx_intr,
4605: SA_INTERRUPT, "ncr53c8xx")) {
4606: #endif
4607: printf("%s: request irq %d failure\n", ncr_name(np), device->slot.irq);
4608: goto attach_error;
4609: }
4610: np->irq = device->slot.irq;
4611:
4612: /*
4613: ** After SCSI devices have been opened, we cannot
4614: ** reset the bus safely, so we do it here.
4615: ** Interrupt handler does the real work.
4616: ** Process the reset exception,
4617: ** if interrupts are not enabled yet.
4618: ** Then enable disconnects.
4619: */
4620: save_flags(flags); cli();
4621: if (ncr_reset_scsi_bus(np, 0, driver_setup.settle_delay) != 0) {
4622: printf("%s: FATAL ERROR: CHECK SCSI BUS - CABLES, TERMINATION, DEVICE POWER etc.!\n", ncr_name(np));
4623: restore_flags(flags);
4624: goto attach_error;
4625: }
4626: ncr_exception (np);
4627: restore_flags(flags);
4628:
4629: np->disc = 1;
4630:
4631: /*
4632: ** The middle-level SCSI driver does not
4633: ** wait devices to settle.
4634: ** Wait synchronously if more than 2 seconds.
4635: */
4636: if (driver_setup.settle_delay > 2) {
4637: printf("%s: waiting %d seconds for scsi devices to settle...\n",
4638: ncr_name(np), driver_setup.settle_delay);
4639: DELAY(1000000UL * driver_setup.settle_delay);
4640: }
4641:
4642: /*
4643: ** Now let the generic SCSI driver
4644: ** look for the SCSI devices on the bus ..
4645: */
4646:
4647: /*
4648: ** start the timeout daemon
4649: */
4650: np->lasttime=0;
4651: ncr_timeout (np);
4652:
4653: /*
4654: ** use SIMPLE TAG messages by default
4655: */
4656: #ifdef SCSI_NCR_ALWAYS_SIMPLE_TAG
4657: np->order = M_SIMPLE_TAG;
4658: #endif
4659:
4660: /*
4661: ** Done.
4662: */
4663: if (!the_template) {
4664: the_template = instance->hostt;
4665: first_host = instance;
4666: }
4667:
4668: return 0;
4669:
4670: attach_error:
4671: if (!instance) return -1;
4672: printf("%s: detaching...\n", ncr_name(np));
4673: #ifndef NCR_IOMAPPED
4674: if (np->vaddr) {
4675: #ifdef DEBUG_NCR53C8XX
4676: printf("%s: releasing memory mapped IO region %lx[%d]\n", ncr_name(np), (u_long) np->vaddr, 128);
4677: #endif
4678: unmap_pci_mem((vm_offset_t) np->vaddr, (u_long) 128);
4679: }
4680: if (np->vaddr2) {
4681: #ifdef DEBUG_NCR53C8XX
4682: printf("%s: releasing memory mapped IO region %lx[%d]\n", ncr_name(np), (u_long) np->vaddr2, 4096);
4683: #endif
4684: unmap_pci_mem((vm_offset_t) np->vaddr2, (u_long) 4096);
4685: }
4686: #endif
4687: if (np->port) {
4688: #ifdef DEBUG_NCR53C8XX
4689: printf("%s: releasing IO region %x[%d]\n", ncr_name(np), np->port, 128);
4690: #endif
4691: release_region(np->port, 128);
4692: }
4693: if (np->irq) {
4694: #ifdef DEBUG_NCR53C8XX
4695: printf("%s: freeing irq %d\n", ncr_name(np), np->irq);
4696: #endif
4697: #if LINUX_VERSION_CODE >= LinuxVersionCode(1,3,70)
4698: free_irq(np->irq, np);
4699: #else
4700: free_irq(np->irq);
4701: #endif
4702: }
4703: scsi_unregister(instance);
4704:
4705: return -1;
4706: }
4707:
4708: /*==========================================================
4709: **
4710: **
4711: ** Start execution of a SCSI command.
4712: ** This is called from the generic SCSI driver.
4713: **
4714: **
4715: **==========================================================
4716: */
4717: int ncr_queue_command (Scsi_Cmnd *cmd, void (* done)(Scsi_Cmnd *))
4718: {
4719: struct Scsi_Host *host = cmd->host;
4720: /* Scsi_Device *device = cmd->device; */
4721: struct host_data *host_data = (struct host_data *) host->hostdata;
4722: ncb_p np = host_data->ncb;
4723: tcb_p tp = &np->target[cmd->target];
4724:
4725: ccb_p cp;
4726: lcb_p lp;
4727:
4728: int segments;
4729: u_char qidx, nego, idmsg, *msgptr;
4730: u_int msglen, msglen2;
4731: u_long flags;
4732: int xfer_direction;
4733:
4734: cmd->scsi_done = done;
4735: cmd->host_scribble = NULL;
4736: cmd->SCp.ptr = NULL;
4737: cmd->SCp.buffer = NULL;
4738:
4739: /*---------------------------------------------
4740: **
4741: ** Some shortcuts ...
4742: **
4743: **---------------------------------------------
4744: */
4745: if ((cmd->target == np->myaddr ) ||
4746: (cmd->target >= MAX_TARGET) ||
4747: (cmd->lun >= MAX_LUN )) {
4748: return(DID_BAD_TARGET);
4749: }
4750:
4751: /*---------------------------------------------
4752: **
4753: ** Complete the 1st TEST UNIT READY command
4754: ** with error condition if the device is
4755: ** flagged NOSCAN, in order to speed up
4756: ** the boot.
4757: **
4758: **---------------------------------------------
4759: */
4760: if (cmd->cmnd[0] == 0 && (tp->usrflag & UF_NOSCAN)) {
4761: tp->usrflag &= ~UF_NOSCAN;
4762: return DID_BAD_TARGET;
4763: }
4764:
4765: if (DEBUG_FLAGS & DEBUG_TINY) {
4766: PRINT_ADDR(cmd);
4767: printf ("CMD=%x ", cmd->cmnd[0]);
4768: }
4769:
4770: /*---------------------------------------------------
4771: **
4772: ** Assign a ccb / bind cmd.
4773: ** If resetting, shorten settle_time if necessary
4774: ** in order to avoid spurious timeouts.
4775: ** If resetting or no free ccb,
4776: ** insert cmd into the waiting list.
4777: **
4778: **----------------------------------------------------
4779: */
4780: save_flags(flags); cli();
4781:
4782: if (np->settle_time && cmd->timeout_per_command >= HZ &&
4783: np->settle_time > jiffies + cmd->timeout_per_command - HZ) {
4784: np->settle_time = jiffies + cmd->timeout_per_command - HZ;
4785: }
4786:
4787: if (np->settle_time || !(cp=ncr_get_ccb (np, cmd->target, cmd->lun))) {
4788: insert_into_waiting_list(np, cmd);
4789: restore_flags(flags);
4790: return(DID_OK);
4791: }
4792: cp->cmd = cmd;
4793:
4794: /*---------------------------------------------------
4795: **
4796: ** Enable tagged queue if asked by scsi ioctl
4797: **
4798: **----------------------------------------------------
4799: */
4800: if (!tp->usrtags && cmd->device && cmd->device->tagged_queue) {
4801: tp->usrtags = SCSI_NCR_MAX_TAGS;
4802: ncr_setmaxtags (np, tp, SCSI_NCR_MAX_TAGS);
4803: }
4804:
4805: /*---------------------------------------------------
4806: **
4807: ** timestamp
4808: **
4809: **----------------------------------------------------
4810: */
4811: #ifdef SCSI_NCR_PROFILE_SUPPORT
4812: bzero (&cp->phys.header.stamp, sizeof (struct tstamp));
4813: cp->phys.header.stamp.start = jiffies;
4814: #endif
4815:
4816: /*----------------------------------------------------
4817: **
4818: ** Get device quirks from a speciality table.
4819: **
4820: ** @GENSCSI@
4821: ** This should be a part of the device table
4822: ** in "scsi_conf.c".
4823: **
4824: **----------------------------------------------------
4825: */
4826: if (tp->quirks & QUIRK_UPDATE) {
4827: tp->quirks = ncr_lookup ((char*) &tp->inqdata[0]);
4828: #ifndef NCR_GETCC_WITHMSG
4829: if (tp->quirks) {
4830: PRINT_ADDR(cmd);
4831: printf ("quirks=%x.\n", tp->quirks);
4832: }
4833: #endif
4834: }
4835:
4836: /*---------------------------------------------------
4837: **
4838: ** negotiation required?
4839: **
4840: ** Only SCSI-II devices.
4841: ** To negotiate with SCSI-I devices is dangerous, since
4842: ** Synchronous Negotiation protocol is optional, and
4843: ** INQUIRY data do not contains capabilities in byte 7.
4844: **----------------------------------------------------
4845: */
4846:
4847: nego = 0;
4848:
4849: if (cmd->lun == 0 && !tp->nego_cp &&
4850: (tp->inqdata[2] & 0x7) >= 2 && tp->inqdata[7]) {
4851: /*
4852: ** negotiate wide transfers ?
4853: */
4854:
4855: if (!tp->widedone) {
4856: if (tp->inqdata[7] & INQ7_WIDE16) {
4857: nego = NS_WIDE;
4858: } else
4859: tp->widedone=1;
4860: };
4861:
4862: /*
4863: ** negotiate synchronous transfers?
4864: */
4865:
4866: if (!nego && !tp->period) {
4867: if ( 1
4868: #if defined (CDROM_ASYNC)
4869: && ((tp->inqdata[0] & 0x1f) != 5)
4870: #endif
4871: && (tp->inqdata[7] & INQ7_SYNC)) {
4872: nego = NS_SYNC;
4873: } else {
4874: tp->period =0xffff;
4875: tp->sval = 0xe0;
4876: PRINT_ADDR(cmd);
4877: printf ("asynchronous.\n");
4878: };
4879: };
4880:
4881: /*
4882: ** remember nego is pending for the target.
4883: ** Avoid to start a nego for all queued commands
4884: ** when tagged command queuing is enabled.
4885: */
4886:
4887: if (nego)
4888: tp->nego_cp = cp;
4889: };
4890:
4891: /*---------------------------------------------------
4892: **
4893: ** choose a new tag ...
4894: **
4895: **----------------------------------------------------
4896: */
4897:
4898: if ((lp = tp->lp[cmd->lun]) && (lp->usetags)) {
4899: /*
4900: ** assign a tag to this ccb!
4901: */
4902: while (!cp->tag) {
4903: ccb_p cp2 = lp->next_ccb;
4904: lp->lasttag = lp->lasttag % 255 + 1;
4905: while (cp2 && cp2->tag != lp->lasttag)
4906: cp2 = cp2->next_ccb;
4907: if (cp2) continue;
4908: cp->tag=lp->lasttag;
4909: if (DEBUG_FLAGS & DEBUG_TAGS) {
4910: PRINT_ADDR(cmd);
4911: printf ("using tag #%d.\n", cp->tag);
4912: }
4913: }
4914: } else {
4915: cp->tag=0;
4916: }
4917:
4918: /*----------------------------------------------------
4919: **
4920: ** Build the identify / tag / sdtr message
4921: **
4922: **----------------------------------------------------
4923: */
4924:
4925: idmsg = M_IDENTIFY | cmd->lun;
4926:
4927: if (cp != np->ccb && ((np->disc && !(tp->usrflag & UF_NODISC)) || cp->tag))
4928: idmsg |= 0x40;
4929:
4930: msgptr = cp->scsi_smsg;
4931: msglen = 0;
4932: msgptr[msglen++] = idmsg;
4933:
4934: if (cp->tag) {
4935: char tag;
4936:
4937: tag = np->order;
4938: if (tag == 0) {
4939: /*
4940: ** Ordered write ops, unordered read ops.
4941: */
4942: switch (cmd->cmnd[0]) {
4943: case 0x08: /* READ_SMALL (6) */
4944: case 0x28: /* READ_BIG (10) */
4945: case 0xa8: /* READ_HUGE (12) */
4946: tag = M_SIMPLE_TAG;
4947: break;
4948: default:
4949: tag = M_ORDERED_TAG;
4950: }
4951: }
4952: /*
4953: ** Have to force ordered tag to avoid timeouts
4954: */
4955: if ((lp = tp->lp[cmd->lun]) && (lp->force_ordered_tag)) {
4956: tag = M_ORDERED_TAG;
4957: lp->force_ordered_tag = 0;
4958: if (DEBUG_FLAGS & DEBUG_TAGS) {
4959: PRINT_ADDR(cmd);
4960: printf ("Ordered Queue Tag forced\n");
4961: }
4962: }
4963: msgptr[msglen++] = tag;
4964: msgptr[msglen++] = cp -> tag;
4965: }
4966:
4967: switch (nego) {
4968: case NS_SYNC:
4969: msgptr[msglen++] = M_EXTENDED;
4970: msgptr[msglen++] = 3;
4971: msgptr[msglen++] = M_X_SYNC_REQ;
4972: msgptr[msglen++] = tp->maxoffs ? tp->minsync : 0;
4973: msgptr[msglen++] = tp->maxoffs;
4974: if (DEBUG_FLAGS & DEBUG_NEGO) {
4975: PRINT_ADDR(cp->cmd);
4976: printf ("sync msgout: ");
4977: ncr_show_msg (&cp->scsi_smsg [msglen-5]);
4978: printf (".\n");
4979: };
4980: break;
4981: case NS_WIDE:
4982: msgptr[msglen++] = M_EXTENDED;
4983: msgptr[msglen++] = 2;
4984: msgptr[msglen++] = M_X_WIDE_REQ;
4985: msgptr[msglen++] = tp->usrwide;
4986: if (DEBUG_FLAGS & DEBUG_NEGO) {
4987: PRINT_ADDR(cp->cmd);
4988: printf ("wide msgout: ");
4989: ncr_show_msg (&cp->scsi_smsg [msglen-4]);
4990: printf (".\n");
4991: };
4992: break;
4993: };
4994:
4995: /*----------------------------------------------------
4996: **
4997: ** Build the identify message for getcc.
4998: **
4999: **----------------------------------------------------
5000: */
5001:
5002: cp -> scsi_smsg2 [0] = idmsg;
5003: msglen2 = 1;
5004:
5005: /*----------------------------------------------------
5006: **
5007: ** Build the data descriptors
5008: **
5009: **----------------------------------------------------
5010: */
5011:
5012: segments = ncr_scatter (cp, cp->cmd);
5013:
5014: if (segments < 0) {
5015: ncr_free_ccb(np, cp, cmd->target, cmd->lun);
5016: restore_flags(flags);
5017: return(DID_ERROR);
5018: }
5019:
5020: /*----------------------------------------------------
5021: **
5022: ** Guess xfer direction.
5023: ** Spare some CPU by testing here frequently opcode.
5024: **
5025: **----------------------------------------------------
5026: */
5027: switch((int) cmd->cmnd[0]) {
5028: case 0x08: /* READ(6) 08 */
5029: case 0x28: /* READ(10) 28 */
5030: case 0xA8: /* READ(12) A8 */
5031: xfer_direction = XferIn;
5032: break;
5033: case 0x0A: /* WRITE(6) 0A */
5034: case 0x2A: /* WRITE(10) 2A */
5035: case 0xAA: /* WRITE(12) AA */
5036: xfer_direction = XferOut;
5037: break;
5038: default:
5039: xfer_direction = guess_xfer_direction((int) cmd->cmnd[0]);
5040: break;
5041: }
5042:
5043: /*----------------------------------------------------
5044: **
5045: ** Set the SAVED_POINTER.
5046: **
5047: **----------------------------------------------------
5048: */
5049:
5050: cp->segments = segments;
5051: if (!cp->data_len)
5052: xfer_direction = XferNone;
5053:
5054: switch (xfer_direction) {
5055: u_long endp;
5056: default:
5057: case XferBoth:
5058: cp->phys.header.savep =
5059: cpu_to_scr(NCB_SCRIPT_PHYS (np, data_io));
5060: cp->phys.header.goalp = cp->phys.header.savep;
5061: break;
5062: case XferIn:
5063: endp = NCB_SCRIPT_PHYS (np, data_in) + MAX_SCATTER*16;
5064: cp->phys.header.goalp = cpu_to_scr(endp + 8);
5065: cp->phys.header.savep = cpu_to_scr(endp - segments*16);
5066: break;
5067: case XferOut:
5068: endp = NCB_SCRIPTH_PHYS (np, data_out) + MAX_SCATTER*16;
5069: cp->phys.header.goalp = cpu_to_scr(endp + 8);
5070: cp->phys.header.savep = cpu_to_scr(endp - segments*16);
5071: break;
5072: case XferNone:
5073: cp->phys.header.savep =
5074: cpu_to_scr(NCB_SCRIPT_PHYS (np, no_data));
5075: cp->phys.header.goalp = cp->phys.header.savep;
5076: break;
5077: }
5078:
5079: cp->phys.header.lastp = cp->phys.header.savep;
5080:
5081: /*----------------------------------------------------
5082: **
5083: ** fill in ccb
5084: **
5085: **----------------------------------------------------
5086: **
5087: **
5088: ** physical -> virtual backlink
5089: ** Generic SCSI command
5090: */
5091: cp->phys.header.cp = cp;
5092: /*
5093: ** Startqueue
5094: */
5095: cp->phys.header.launch.l_paddr =
5096: cpu_to_scr(NCB_SCRIPT_PHYS (np, select));
5097: cp->phys.header.launch.l_cmd = cpu_to_scr(SCR_JUMP);
5098: /*
5099: ** select
5100: */
5101: cp->phys.select.sel_id = cmd->target;
5102: cp->phys.select.sel_scntl3 = tp->wval;
5103: cp->phys.select.sel_sxfer = tp->sval;
5104: /*
5105: ** message
5106: */
5107: cp->phys.smsg.addr = cpu_to_scr(CCB_PHYS (cp, scsi_smsg));
5108: cp->phys.smsg.size = cpu_to_scr(msglen);
5109:
5110: cp->phys.smsg2.addr = cpu_to_scr(CCB_PHYS (cp, scsi_smsg2));
5111: cp->phys.smsg2.size = cpu_to_scr(msglen2);
5112: /*
5113: ** command
5114: */
5115: cp->phys.cmd.addr = cpu_to_scr(vtophys (&cmd->cmnd[0]));
5116: cp->phys.cmd.size = cpu_to_scr(cmd->cmd_len);
5117: /*
5118: ** sense command
5119: */
5120: cp->phys.scmd.addr = cpu_to_scr(CCB_PHYS (cp, sensecmd));
5121: cp->phys.scmd.size = cpu_to_scr(6);
5122: /*
5123: ** patch requested size into sense command
5124: */
5125: cp->sensecmd[0] = 0x03;
5126: cp->sensecmd[1] = cmd->lun << 5;
5127: cp->sensecmd[4] = sizeof(cmd->sense_buffer);
5128: /*
5129: ** sense data
5130: */
5131: cp->phys.sense.addr =
5132: cpu_to_scr(vtophys (&cmd->sense_buffer[0]));
5133: cp->phys.sense.size = cpu_to_scr(sizeof(cmd->sense_buffer));
5134: /*
5135: ** status
5136: */
5137: cp->actualquirks = tp->quirks;
5138: cp->host_status = nego ? HS_NEGOTIATE : HS_BUSY;
5139: cp->scsi_status = S_ILLEGAL;
5140: cp->parity_status = 0;
5141:
5142: cp->xerr_status = XE_OK;
5143: cp->sync_status = tp->sval;
5144: cp->nego_status = nego;
5145: cp->wide_status = tp->wval;
5146:
5147: /*----------------------------------------------------
5148: **
5149: ** Critical region: start this job.
5150: **
5151: **----------------------------------------------------
5152: */
5153:
5154: /*
5155: ** reselect pattern and activate this job.
5156: */
5157:
5158: cp->jump_ccb.l_cmd =
5159: cpu_to_scr((SCR_JUMP ^ IFFALSE (DATA (cp->tag))));
5160:
5161: /* Compute a time limit greater than the middle-level driver one */
5162: if (cmd->timeout_per_command > 0)
5163: cp->tlimit = jiffies + cmd->timeout_per_command + NCR_TIMEOUT_INCREASE;
5164: else
5165: cp->tlimit = jiffies + 3600 * HZ; /* No timeout=one hour */
5166: cp->magic = CCB_MAGIC;
5167:
5168: /*
5169: ** insert into start queue.
5170: */
5171:
5172: qidx = np->squeueput + 1;
5173: if (qidx >= MAX_START) qidx=0;
5174: np->squeue [qidx ] = cpu_to_scr(NCB_SCRIPT_PHYS (np, idle));
5175: np->squeue [np->squeueput] = cpu_to_scr(CCB_PHYS (cp, phys));
5176: np->squeueput = qidx;
5177:
5178: if(DEBUG_FLAGS & DEBUG_QUEUE)
5179: printf ("%s: queuepos=%d tryoffset=%d.\n", ncr_name (np),
5180: np->squeueput,
5181: (unsigned)(scr_to_cpu(np->script->startpos[0]) -
5182: (NCB_SCRIPTH_PHYS (np, tryloop))));
5183:
5184: /*
5185: ** Script processor may be waiting for reselect.
5186: ** Wake it up.
5187: */
5188: #ifdef SCSI_NCR_DEBUG_ERROR_RECOVERY_SUPPORT
5189: if (!np->stalling)
5190: #endif
5191: OUTB (nc_istat, SIGP);
5192:
5193: /*
5194: ** and reenable interrupts
5195: */
5196: restore_flags(flags);
5197:
5198: /*
5199: ** Command is successfully queued.
5200: */
5201:
5202: return(DID_OK);
5203: }
5204:
5205: /*==========================================================
5206: **
5207: **
5208: ** Start reset process.
5209: ** If reset in progress do nothing.
5210: ** The interrupt handler will reinitialize the chip.
5211: ** The timeout handler will wait for settle_time before
5212: ** clearing it and so resuming command processing.
5213: **
5214: **
5215: **==========================================================
5216: */
5217: static void ncr_start_reset(ncb_p np, int settle_delay)
5218: {
5219: u_long flags;
5220:
5221: save_flags(flags); cli();
5222:
5223: if (!np->settle_time) {
5224: (void) ncr_reset_scsi_bus(np, 1, settle_delay);
5225: }
5226: restore_flags(flags);
5227: }
5228:
5229: static int ncr_reset_scsi_bus(ncb_p np, int enab_int, int settle_delay)
5230: {
5231: u_int32 term;
5232: int retv = 0;
5233:
5234: np->settle_time = jiffies + settle_delay * HZ;
5235:
5236: if (bootverbose > 1)
5237: printf("%s: resetting, "
5238: "command processing suspended for %d seconds\n",
5239: ncr_name(np), settle_delay);
5240:
5241: OUTB (nc_istat, SRST);
5242: DELAY (1000);
5243: OUTB (nc_istat, 0);
5244: if (enab_int)
5245: OUTW (nc_sien, RST);
5246: /*
5247: ** Enable Tolerant, reset IRQD if present and
5248: ** properly set IRQ mode, prior to resetting the bus.
5249: */
5250: OUTB (nc_stest3, TE);
5251: OUTB (nc_dcntl, (np->rv_dcntl & IRQM));
5252: OUTB (nc_scntl1, CRST);
5253: DELAY (100);
5254:
5255: if (!driver_setup.bus_check)
5256: goto out;
5257: /*
5258: ** Check for no terminators or SCSI bus shorts to ground.
5259: ** Read SCSI data bus, data parity bits and control signals.
5260: ** We are expecting RESET to be TRUE and other signals to be
5261: ** FALSE.
5262: */
5263: term = INB(nc_sstat0); /* rst, sdp0 */
5264: term = ((term & 2) << 7) + ((term & 1) << 16);
5265: term |= ((INB(nc_sstat2) & 0x01) << 25) | /* sdp1 */
5266: (INW(nc_sbdl) << 9) | /* d15-0 */
5267: INB(nc_sbcl); /* req, ack, bsy, sel, atn, msg, cd, io */
5268:
5269: if (!(np->features & FE_WIDE))
5270: term &= 0x3ffff;
5271:
5272: if (term != (2<<7)) {
5273: printf("%s: suspicious SCSI data while resetting the BUS.\n",
5274: ncr_name(np));
5275: printf("%s: %sdp0,d7-0,rst,req,ack,bsy,sel,atn,msg,c/d,i/o = "
5276: "0x%lx, expecting 0x%lx\n",
5277: ncr_name(np),
5278: (np->features & FE_WIDE) ? "dp1,d15-8," : "",
5279: (u_long)term, (u_long)(2<<7));
5280: if (driver_setup.bus_check == 1)
5281: retv = 1;
5282: }
5283: out:
5284: OUTB (nc_scntl1, 0);
5285: return retv;
5286: }
5287:
5288: /*==========================================================
5289: **
5290: **
5291: ** Reset the SCSI BUS.
5292: ** This is called from the generic SCSI driver.
5293: **
5294: **
5295: **==========================================================
5296: */
5297: int ncr_reset_bus (Scsi_Cmnd *cmd, int sync_reset)
5298: {
5299: struct Scsi_Host *host = cmd->host;
5300: /* Scsi_Device *device = cmd->device; */
5301: struct host_data *host_data = (struct host_data *) host->hostdata;
5302: ncb_p np = host_data->ncb;
5303: ccb_p cp;
5304: u_long flags;
5305: int found;
5306:
5307: #ifdef SCSI_NCR_DEBUG_ERROR_RECOVERY_SUPPORT
5308: if (np->stalling)
5309: np->stalling = 0;
5310: #endif
5311:
5312: save_flags(flags); cli();
5313: /*
5314: * Return immediately if reset is in progress.
5315: */
5316: if (np->settle_time) {
5317: restore_flags(flags);
5318: return SCSI_RESET_PUNT;
5319: }
5320: /*
5321: * Start the reset process.
5322: * The script processor is then assumed to be stopped.
5323: * Commands will now be queued in the waiting list until a settle
5324: * delay of 2 seconds will be completed.
5325: */
5326: ncr_start_reset(np, driver_setup.settle_delay);
5327: /*
5328: * First, look in the wakeup list
5329: */
5330: for (found=0, cp=np->ccb; cp; cp=cp->link_ccb) {
5331: /*
5332: ** look for the ccb of this command.
5333: */
5334: if (cp->host_status == HS_IDLE) continue;
5335: if (cp->cmd == cmd) {
5336: found = 1;
5337: break;
5338: }
5339: }
5340: /*
5341: * Then, look in the waiting list
5342: */
5343: if (!found && retrieve_from_waiting_list(0, np, cmd))
5344: found = 1;
5345: /*
5346: * Wake-up all awaiting commands with DID_RESET.
5347: */
5348: reset_waiting_list(np);
5349: /*
5350: * Wake-up all pending commands with HS_RESET -> DID_RESET.
5351: */
5352: ncr_wakeup(np, HS_RESET);
5353: /*
5354: * If the involved command was not in a driver queue, and the
5355: * scsi driver told us reset is synchronous, and the command is not
5356: * currently in the waiting list, complete it with DID_RESET status,
5357: * in order to keep it alive.
5358: */
5359: if (!found && sync_reset && !retrieve_from_waiting_list(0, np, cmd)) {
5360: cmd->result = ScsiResult(DID_RESET, 0);
5361: cmd->scsi_done(cmd);
5362: }
5363:
5364: restore_flags(flags);
5365:
5366: return SCSI_RESET_SUCCESS;
5367: }
5368:
5369: /*==========================================================
5370: **
5371: **
5372: ** Abort an SCSI command.
5373: ** This is called from the generic SCSI driver.
5374: **
5375: **
5376: **==========================================================
5377: */
5378: static int ncr_abort_command (Scsi_Cmnd *cmd)
5379: {
5380: struct Scsi_Host *host = cmd->host;
5381: /* Scsi_Device *device = cmd->device; */
5382: struct host_data *host_data = (struct host_data *) host->hostdata;
5383: ncb_p np = host_data->ncb;
5384: ccb_p cp;
5385: u_long flags;
5386: int found;
5387: int retv;
5388:
5389: #ifdef SCSI_NCR_DEBUG_ERROR_RECOVERY_SUPPORT
5390: if (np->stalling == 2)
5391: np->stalling = 0;
5392: #endif
5393:
5394: save_flags(flags); cli();
5395: /*
5396: * First, look for the scsi command in the waiting list
5397: */
5398: if (remove_from_waiting_list(np, cmd)) {
5399: cmd->result = ScsiResult(DID_ABORT, 0);
5400: cmd->scsi_done(cmd);
5401: restore_flags(flags);
5402: return SCSI_ABORT_SUCCESS;
5403: }
5404:
5405: /*
5406: * Then, look in the wakeup list
5407: */
5408: for (found=0, cp=np->ccb; cp; cp=cp->link_ccb) {
5409: /*
5410: ** look for the ccb of this command.
5411: */
5412: if (cp->host_status == HS_IDLE) continue;
5413: if (cp->cmd == cmd) {
5414: found = 1;
5415: break;
5416: }
5417: }
5418:
5419: if (!found) {
5420: restore_flags(flags);
5421: return SCSI_ABORT_NOT_RUNNING;
5422: }
5423:
5424: if (np->settle_time) {
5425: restore_flags(flags);
5426: return SCSI_ABORT_SNOOZE;
5427: }
5428:
5429: /*
5430: ** Disable reselect.
5431: ** Remove it from startqueue.
5432: ** Set cp->tlimit to 0. The ncr_timeout() handler will use
5433: ** this condition in order to complete the canceled command
5434: ** after the script skipped the ccb, if necessary.
5435: */
5436: cp->jump_ccb.l_cmd = cpu_to_scr(SCR_JUMP);
5437: if (cp->phys.header.launch.l_paddr ==
5438: cpu_to_scr(NCB_SCRIPT_PHYS (np, select))) {
5439: printf ("%s: abort ccb=%p (skip)\n", ncr_name (np), cp);
5440: cp->phys.header.launch.l_paddr =
5441: cpu_to_scr(NCB_SCRIPT_PHYS (np, skip));
5442: }
5443:
5444: cp->tlimit = 0;
5445: retv = SCSI_ABORT_PENDING;
5446:
5447: /*
5448: ** If there are no requests, the script
5449: ** processor will sleep on SEL_WAIT_RESEL.
5450: ** Let's wake it up, since it may have to work.
5451: */
5452: #ifdef SCSI_NCR_DEBUG_ERROR_RECOVERY_SUPPORT
5453: if (!np->stalling)
5454: #endif
5455: OUTB (nc_istat, SIGP);
5456:
5457: restore_flags(flags);
5458:
5459: return retv;
5460: }
5461:
5462: /*==========================================================
5463: **
5464: ** Linux release module stuff.
5465: **
5466: ** Called before unloading the module
5467: ** Detach the host.
5468: ** We have to free resources and halt the NCR chip
5469: **
5470: **==========================================================
5471: */
5472:
5473: #ifdef MODULE
5474: static int ncr_detach(ncb_p np)
5475: {
5476: ccb_p cp;
5477: tcb_p tp;
5478: lcb_p lp;
5479: int target, lun;
5480: int i;
5481:
5482: printf("%s: releasing host resources\n", ncr_name(np));
5483:
5484: /*
5485: ** Stop the ncr_timeout process
5486: ** Set release_stage to 1 and wait that ncr_timeout() set it to 2.
5487: */
5488:
5489: #ifdef DEBUG_NCR53C8XX
5490: printf("%s: stopping the timer\n", ncr_name(np));
5491: #endif
5492: np->release_stage = 1;
5493: for (i = 50 ; i && np->release_stage != 2 ; i--) DELAY(100000);
5494: if (np->release_stage != 2)
5495: printf("%s: the timer seems to be already stopped\n", ncr_name(np));
5496: else np->release_stage = 2;
5497:
5498: /*
5499: ** Disable chip interrupts
5500: */
5501:
5502: #ifdef DEBUG_NCR53C8XX
5503: printf("%s: disabling chip interrupts\n", ncr_name(np));
5504: #endif
5505: OUTW (nc_sien , 0);
5506: OUTB (nc_dien , 0);
5507:
5508: /*
5509: ** Free irq
5510: */
5511:
5512: #ifdef DEBUG_NCR53C8XX
5513: printf("%s: freeing irq %d\n", ncr_name(np), np->irq);
5514: #endif
5515: #if LINUX_VERSION_CODE >= LinuxVersionCode(1,3,70)
5516: free_irq(np->irq, np);
5517: #else
5518: free_irq(np->irq);
5519: #endif
5520:
5521: /*
5522: ** Reset NCR chip
5523: ** Restore bios setting for automatic clock detection.
5524: */
5525:
5526: printf("%s: resetting chip\n", ncr_name(np));
5527: OUTB (nc_istat, SRST);
5528: DELAY (1000);
5529: OUTB (nc_istat, 0 );
5530:
5531: OUTB(nc_dmode, np->sv_dmode);
5532: OUTB(nc_dcntl, np->sv_dcntl);
5533: OUTB(nc_ctest3, np->sv_ctest3);
5534: OUTB(nc_ctest4, np->sv_ctest4);
5535: OUTB(nc_ctest5, np->sv_ctest5);
5536: OUTB(nc_gpcntl, np->sv_gpcntl);
5537: OUTB(nc_stest2, np->sv_stest2);
5538:
5539: ncr_selectclock(np, np->sv_scntl3);
5540:
5541: /*
5542: ** Release Memory mapped IO region and IO mapped region
5543: */
5544:
5545: #ifndef NCR_IOMAPPED
5546: #ifdef DEBUG_NCR53C8XX
5547: printf("%s: releasing memory mapped IO region %lx[%d]\n", ncr_name(np), (u_long) np->vaddr, 128);
5548: #endif
5549: unmap_pci_mem((vm_offset_t) np->vaddr, (u_long) 128);
5550: #ifdef DEBUG_NCR53C8XX
5551: printf("%s: releasing memory mapped IO region %lx[%d]\n", ncr_name(np), (u_long) np->vaddr2, 4096);
5552: #endif
5553: unmap_pci_mem((vm_offset_t) np->vaddr2, (u_long) 4096);
5554: #endif
5555:
5556: #ifdef DEBUG_NCR53C8XX
5557: printf("%s: releasing IO region %x[%d]\n", ncr_name(np), np->port, 128);
5558: #endif
5559: release_region(np->port, 128);
5560:
5561: /*
5562: ** Free allocated ccb(s)
5563: */
5564:
5565: while ((cp=np->ccb->link_ccb) != NULL) {
5566: np->ccb->link_ccb = cp->link_ccb;
5567: if (cp->host_status) {
5568: printf("%s: shall free an active ccb (host_status=%d)\n",
5569: ncr_name(np), cp->host_status);
5570: }
5571: #ifdef DEBUG_NCR53C8XX
5572: printf("%s: freeing ccb (%lx)\n", ncr_name(np), (u_long) cp);
5573: #endif
5574: m_free(cp, sizeof(*cp));
5575: }
5576:
5577: /*
5578: ** Free allocated tp(s)
5579: */
5580:
5581: for (target = 0; target < MAX_TARGET ; target++) {
5582: tp=&np->target[target];
5583: for (lun = 0 ; lun < MAX_LUN ; lun++) {
5584: lp = tp->lp[lun];
5585: if (lp) {
5586: #ifdef DEBUG_NCR53C8XX
5587: printf("%s: freeing lp (%lx)\n", ncr_name(np), (u_long) lp);
5588: #endif
5589: m_free(lp, sizeof(*lp));
5590: }
5591: }
5592: }
5593:
5594: printf("%s: host resources successfully released\n", ncr_name(np));
5595:
5596: return 1;
5597: }
5598: #endif
5599:
5600: /*==========================================================
5601: **
5602: **
5603: ** Complete execution of a SCSI command.
5604: ** Signal completion to the generic SCSI driver.
5605: **
5606: **
5607: **==========================================================
5608: */
5609:
5610: void ncr_complete (ncb_p np, ccb_p cp)
5611: {
5612: Scsi_Cmnd *cmd;
5613: tcb_p tp;
5614: lcb_p lp;
5615:
5616: /*
5617: ** Sanity check
5618: */
5619:
5620: if (!cp || (cp->magic!=CCB_MAGIC) || !cp->cmd) return;
5621: cp->magic = 1;
5622: cp->tlimit= 0;
5623: cmd = cp->cmd;
5624:
5625: /*
5626: ** No Reselect anymore.
5627: */
5628: cp->jump_ccb.l_cmd = cpu_to_scr(SCR_JUMP);
5629:
5630: /*
5631: ** No starting.
5632: */
5633: cp->phys.header.launch.l_paddr = cpu_to_scr(NCB_SCRIPT_PHYS (np, idle));
5634:
5635: /*
5636: ** timestamp
5637: ** Optional, spare some CPU time
5638: */
5639: #ifdef SCSI_NCR_PROFILE_SUPPORT
5640: ncb_profile (np, cp);
5641: #endif
5642:
5643: if (DEBUG_FLAGS & DEBUG_TINY)
5644: printf ("CCB=%lx STAT=%x/%x\n", (unsigned long)cp & 0xfff,
5645: cp->host_status,cp->scsi_status);
5646:
5647: cmd = cp->cmd;
5648: cp->cmd = NULL;
5649: tp = &np->target[cmd->target];
5650: lp = tp->lp[cmd->lun];
5651:
5652: /*
5653: ** We donnot queue more than 1 ccb per target
5654: ** with negotiation at any time. If this ccb was
5655: ** used for negotiation, clear this info in the tcb.
5656: */
5657:
5658: if (cp == tp->nego_cp)
5659: tp->nego_cp = 0;
5660:
5661: /*
5662: ** Check for parity errors.
5663: */
5664:
5665: if (cp->parity_status) {
5666: PRINT_ADDR(cmd);
5667: printf ("%d parity error(s), fallback.\n", cp->parity_status);
5668: /*
5669: ** fallback to asynch transfer.
5670: */
5671: tp->usrsync=255;
5672: tp->period = 0;
5673: }
5674:
5675: /*
5676: ** Check for extended errors.
5677: */
5678:
5679: if (cp->xerr_status != XE_OK) {
5680: PRINT_ADDR(cmd);
5681: switch (cp->xerr_status) {
5682: case XE_EXTRA_DATA:
5683: printf ("extraneous data discarded.\n");
5684: break;
5685: case XE_BAD_PHASE:
5686: printf ("illegal scsi phase (4/5).\n");
5687: break;
5688: default:
5689: printf ("extended error %d.\n", cp->xerr_status);
5690: break;
5691: }
5692: if (cp->host_status==HS_COMPLETE)
5693: cp->host_status = HS_FAIL;
5694: }
5695:
5696: /*
5697: ** Check the status.
5698: */
5699: if ( (cp->host_status == HS_COMPLETE)
5700: && (cp->scsi_status == S_GOOD ||
5701: cp->scsi_status == S_COND_MET)) {
5702: /*
5703: ** All went well (GOOD status).
5704: ** CONDITION MET status is returned on
5705: ** `Pre-Fetch' or `Search data' success.
5706: */
5707: cmd->result = ScsiResult(DID_OK, cp->scsi_status);
5708:
5709: /*
5710: ** if (cp->phys.header.lastp != cp->phys.header.goalp)...
5711: **
5712: ** @RESID@
5713: ** Could dig out the correct value for resid,
5714: ** but it would be quite complicated.
5715: **
5716: ** The ah1542.c driver sets it to 0 too ...
5717: */
5718:
5719: /*
5720: ** Try to assign a ccb to this nexus
5721: */
5722: ncr_alloc_ccb (np, cmd->target, cmd->lun);
5723:
5724: /*
5725: ** On inquire cmd (0x12) save some data.
5726: ** Clear questionnable capacities.
5727: */
5728: if (cmd->lun == 0 && cmd->cmnd[0] == 0x12) {
5729: if (np->unit < SCSI_NCR_MAX_HOST) {
5730: if (driver_setup.force_sync_nego)
5731: ((char *) cmd->request_buffer)[7] |= INQ7_SYNC;
5732: else
5733: ((char *) cmd->request_buffer)[7] &=
5734: (target_capabilities[np->unit].and_map[cmd->target]);
5735: }
5736: bcopy ( cmd->request_buffer,
5737: &tp->inqdata,
5738: sizeof (tp->inqdata));
5739:
5740: /*
5741: ** set number of tags
5742: */
5743: ncr_setmaxtags (np, tp, driver_setup.default_tags);
5744: /*
5745: ** prepare negotiation of synch and wide.
5746: */
5747: ncr_negotiate (np, tp);
5748:
5749: /*
5750: ** force quirks update before next command start
5751: */
5752: tp->quirks |= QUIRK_UPDATE;
5753: }
5754:
5755: /*
5756: ** Announce changes to the generic driver.
5757: */
5758: if (lp) {
5759: ncr_settags (tp, lp);
5760: if (lp->reqlink != lp->actlink)
5761: ncr_opennings (np, lp, cmd);
5762: };
5763:
5764: tp->bytes += cp->data_len;
5765: tp->transfers ++;
5766:
5767: /*
5768: ** If tags was reduced due to queue full,
5769: ** increase tags if 100 good status received.
5770: */
5771: if (tp->numtags < tp->maxtags) {
5772: ++tp->num_good;
5773: if (tp->num_good >= 100) {
5774: tp->num_good = 0;
5775: ++tp->numtags;
5776: if (tp->numtags == 1) {
5777: PRINT_ADDR(cmd);
5778: printf("tagged command queueing resumed\n");
5779: }
5780: }
5781: }
5782: } else if ((cp->host_status == HS_COMPLETE)
5783: && (cp->scsi_status == (S_SENSE|S_GOOD) ||
5784: cp->scsi_status == (S_SENSE|S_CHECK_COND))) {
5785:
5786: /*
5787: ** Check condition code
5788: */
5789: cmd->result = ScsiResult(DID_OK, S_CHECK_COND);
5790:
5791: if (DEBUG_FLAGS & (DEBUG_RESULT|DEBUG_TINY)) {
5792: u_char * p = (u_char*) & cmd->sense_buffer;
5793: int i;
5794: printf ("\n%s: sense data:", ncr_name (np));
5795: for (i=0; i<14; i++) printf (" %x", *p++);
5796: printf (".\n");
5797: }
5798:
5799: } else if ((cp->host_status == HS_COMPLETE)
5800: && (cp->scsi_status == S_BUSY ||
5801: cp->scsi_status == S_CONFLICT)) {
5802:
5803: /*
5804: ** Target is busy.
5805: */
5806: cmd->result = ScsiResult(DID_OK, cp->scsi_status);
5807:
5808: } else if ((cp->host_status == HS_COMPLETE)
5809: && (cp->scsi_status == S_QUEUE_FULL)) {
5810:
5811: /*
5812: ** Target is stuffed.
5813: */
5814: cmd->result = ScsiResult(DID_OK, cp->scsi_status);
5815:
5816: /*
5817: ** Suspend tagged queuing and start good status counter.
5818: ** Announce changes to the generic driver.
5819: */
5820: if (tp->numtags) {
5821: PRINT_ADDR(cmd);
5822: printf("QUEUE FULL! suspending tagged command queueing\n");
5823: tp->numtags = 0;
5824: tp->num_good = 0;
5825: if (lp) {
5826: ncr_settags (tp, lp);
5827: if (lp->reqlink != lp->actlink)
5828: ncr_opennings (np, lp, cmd);
5829: };
5830: }
5831: } else if ((cp->host_status == HS_SEL_TIMEOUT)
5832: || (cp->host_status == HS_TIMEOUT)) {
5833:
5834: /*
5835: ** No response
5836: */
5837: cmd->result = ScsiResult(DID_TIME_OUT, cp->scsi_status);
5838:
5839: } else if (cp->host_status == HS_RESET) {
5840:
5841: /*
5842: ** SCSI bus reset
5843: */
5844: cmd->result = ScsiResult(DID_RESET, cp->scsi_status);
5845:
5846: } else if (cp->host_status == HS_ABORTED) {
5847:
5848: /*
5849: ** Transfer aborted
5850: */
5851: cmd->result = ScsiResult(DID_ABORT, cp->scsi_status);
5852:
5853: } else {
5854:
5855: /*
5856: ** Other protocol messes
5857: */
5858: PRINT_ADDR(cmd);
5859: printf ("COMMAND FAILED (%x %x) @%p.\n",
5860: cp->host_status, cp->scsi_status, cp);
5861:
5862: cmd->result = ScsiResult(DID_ERROR, cp->scsi_status);
5863: }
5864:
5865: /*
5866: ** trace output
5867: */
5868:
5869: if (tp->usrflag & UF_TRACE) {
5870: u_char * p;
5871: int i;
5872: PRINT_ADDR(cmd);
5873: printf (" CMD:");
5874: p = (u_char*) &cmd->cmnd[0];
5875: for (i=0; i<cmd->cmd_len; i++) printf (" %x", *p++);
5876:
5877: if (cp->host_status==HS_COMPLETE) {
5878: switch (cp->scsi_status) {
5879: case S_GOOD:
5880: printf (" GOOD");
5881: break;
5882: case S_CHECK_COND:
5883: printf (" SENSE:");
5884: p = (u_char*) &cmd->sense_buffer;
5885: for (i=0; i<14; i++)
5886: printf (" %x", *p++);
5887: break;
5888: default:
5889: printf (" STAT: %x\n", cp->scsi_status);
5890: break;
5891: }
5892: } else printf (" HOSTERROR: %x", cp->host_status);
5893: printf ("\n");
5894: }
5895:
5896: /*
5897: ** Free this ccb
5898: */
5899: ncr_free_ccb (np, cp, cmd->target, cmd->lun);
5900:
5901: /*
5902: ** requeue awaiting scsi commands
5903: */
5904: if (np->waiting_list) requeue_waiting_list(np);
5905:
5906: /*
5907: ** signal completion to generic driver.
5908: */
5909: cmd->scsi_done (cmd);
5910: }
5911:
5912: /*==========================================================
5913: **
5914: **
5915: ** Signal all (or one) control block done.
5916: **
5917: **
5918: **==========================================================
5919: */
5920:
5921: void ncr_wakeup (ncb_p np, u_long code)
5922: {
5923: /*
5924: ** Starting at the default ccb and following
5925: ** the links, complete all jobs with a
5926: ** host_status greater than "disconnect".
5927: **
5928: ** If the "code" parameter is not zero,
5929: ** complete all jobs that are not IDLE.
5930: */
5931:
5932: ccb_p cp = np->ccb;
5933: while (cp) {
5934: switch (cp->host_status) {
5935:
5936: case HS_IDLE:
5937: break;
5938:
5939: case HS_DISCONNECT:
5940: if(DEBUG_FLAGS & DEBUG_TINY) printf ("D");
5941: /* fall through */
5942:
5943: case HS_BUSY:
5944: case HS_NEGOTIATE:
5945: if (!code) break;
5946: cp->host_status = code;
5947:
5948: /* fall through */
5949:
5950: default:
5951: ncr_complete (np, cp);
5952: break;
5953: };
5954: cp = cp -> link_ccb;
5955: };
5956: }
5957:
5958: /*==========================================================
5959: **
5960: **
5961: ** Start NCR chip.
5962: **
5963: **
5964: **==========================================================
5965: */
5966:
5967: void ncr_init (ncb_p np, int reset, char * msg, u_long code)
5968: {
5969: int i;
5970:
5971: /*
5972: ** Reset chip if asked, otherwise just clear fifos.
5973: */
5974: if (reset) {
5975: OUTB (nc_istat, SRST);
5976: DELAY (10000);
5977: }
5978: else {
5979: OUTB (nc_stest3, TE|CSF);
5980: OUTONB (nc_ctest3, CLF);
5981: }
5982:
5983: /*
5984: ** Message.
5985: */
5986:
5987: if (msg) printf (KERN_INFO "%s: restart (%s).\n", ncr_name (np), msg);
5988:
5989: /*
5990: ** Clear Start Queue
5991: */
5992: for (i=0;i<MAX_START;i++)
5993: np -> squeue [i] = cpu_to_scr(NCB_SCRIPT_PHYS (np, idle));
5994:
5995: /*
5996: ** Start at first entry.
5997: */
5998: np->squeueput = 0;
5999: np->script0->startpos[0] = cpu_to_scr(NCB_SCRIPTH_PHYS (np, tryloop));
6000: np->script0->start0 [0] = cpu_to_scr(SCR_INT ^ IFFALSE (0));
6001:
6002: /*
6003: ** Wakeup all pending jobs.
6004: */
6005: ncr_wakeup (np, code);
6006:
6007: /*
6008: ** Init chip.
6009: */
6010:
6011: OUTB (nc_istat, 0x00 ); /* Remove Reset, abort */
6012: OUTB (nc_scntl0, np->rv_scntl0 | 0xc0);
6013: /* full arb., ena parity, par->ATN */
6014: OUTB (nc_scntl1, 0x00); /* odd parity, and remove CRST!! */
6015:
6016: ncr_selectclock(np, np->rv_scntl3); /* Select SCSI clock */
6017:
6018: OUTB (nc_scid , RRE|np->myaddr); /* Adapter SCSI address */
6019: OUTW (nc_respid, 1ul<<np->myaddr); /* Id to respond to */
6020: OUTB (nc_istat , SIGP ); /* Signal Process */
6021: OUTB (nc_dmode , np->rv_dmode); /* Burst length, dma mode */
6022: OUTB (nc_ctest5, np->rv_ctest5); /* Large fifo + large burst */
6023:
6024: OUTB (nc_dcntl , NOCOM|np->rv_dcntl); /* Protect SFBR */
6025: OUTB (nc_ctest3, np->rv_ctest3); /* Write and invalidate */
6026: OUTB (nc_ctest4, np->rv_ctest4); /* Master parity checking */
6027:
6028: OUTB (nc_stest2, EXT|np->rv_stest2); /* Extended Sreq/Sack filtering */
6029: OUTB (nc_stest3, TE); /* TolerANT enable */
6030: OUTB (nc_stime0, 0x0d ); /* HTH disabled STO 0.4 sec. */
6031:
6032: /*
6033: ** Disable disconnects.
6034: */
6035:
6036: np->disc = 0;
6037:
6038: /*
6039: ** Enable GPIO0 pin for writing if LED support.
6040: */
6041:
6042: if (np->features & FE_LED0) {
6043: OUTOFFB (nc_gpcntl, 0x01);
6044: }
6045:
6046: /*
6047: ** Upload the script into on-board RAM
6048: */
6049: if (np->vaddr2) {
6050: if (bootverbose)
6051: printf ("%s: copying script fragments into the on-board RAM ...\n", ncr_name(np));
6052: #if LINUX_VERSION_CODE >= LinuxVersionCode(2,0,0)
6053: memcpy_toio(np->script, np->script0, sizeof(struct script));
6054: #else
6055: memcpy(np->script, np->script0, sizeof(struct script));
6056: #endif
6057: }
6058:
6059: /*
6060: ** enable ints
6061: */
6062:
6063: OUTW (nc_sien , STO|HTH|MA|SGE|UDC|RST);
6064: OUTB (nc_dien , MDPE|BF|ABRT|SSI|SIR|IID);
6065:
6066: /*
6067: ** For 895/6 enable SBMC interrupt and save current SCSI bus mode.
6068: */
6069: if (np->features & FE_ULTRA2) {
6070: OUTONW (nc_sien, SBMC);
6071: np->scsi_mode = INB (nc_stest4) & SMODE;
6072: }
6073:
6074: /*
6075: ** Fill in target structure.
6076: ** Reinitialize usrsync.
6077: ** Reinitialize usrwide.
6078: ** Prepare sync negotiation according to actual SCSI bus mode.
6079: */
6080:
6081: for (i=0;i<MAX_TARGET;i++) {
6082: tcb_p tp = &np->target[i];
6083:
6084: tp->sval = 0;
6085: tp->wval = np->rv_scntl3;
6086:
6087: if (tp->usrsync != 255) {
6088: if (tp->usrsync <= np->maxsync) {
6089: if (tp->usrsync < np->minsync) {
6090: tp->usrsync = np->minsync;
6091: }
6092: }
6093: else
6094: tp->usrsync = 255;
6095: };
6096:
6097: if (tp->usrwide > np->maxwide)
6098: tp->usrwide = np->maxwide;
6099:
6100: ncr_negotiate (np, tp);
6101: }
6102:
6103: /*
6104: ** Start script processor.
6105: */
6106:
6107: OUTL (nc_dsp, NCB_SCRIPT_PHYS (np, start));
6108: }
6109:
6110: /*==========================================================
6111: **
6112: ** Prepare the negotiation values for wide and
6113: ** synchronous transfers.
6114: **
6115: **==========================================================
6116: */
6117:
6118: static void ncr_negotiate (struct ncb* np, struct tcb* tp)
6119: {
6120: /*
6121: ** minsync unit is 4ns !
6122: */
6123:
6124: u_long minsync = tp->usrsync;
6125:
6126: /*
6127: ** SCSI bus mode limit
6128: */
6129:
6130: if (np->scsi_mode && np->scsi_mode == SMODE_SE) {
6131: if (minsync < 12) minsync = 12;
6132: }
6133:
6134: /*
6135: ** if not scsi 2
6136: ** don't believe FAST!
6137: */
6138:
6139: if ((minsync < 50) && (tp->inqdata[2] & 0x0f) < 2)
6140: minsync=50;
6141:
6142: /*
6143: ** our limit ..
6144: */
6145:
6146: if (minsync < np->minsync)
6147: minsync = np->minsync;
6148:
6149: /*
6150: ** divider limit
6151: */
6152:
6153: if (minsync > np->maxsync)
6154: minsync = 255;
6155:
6156: tp->minsync = minsync;
6157: tp->maxoffs = (minsync<255 ? np->maxoffs : 0);
6158:
6159: /*
6160: ** period=0: has to negotiate sync transfer
6161: */
6162:
6163: tp->period=0;
6164:
6165: /*
6166: ** widedone=0: has to negotiate wide transfer
6167: */
6168: tp->widedone=0;
6169: }
6170:
6171: /*==========================================================
6172: **
6173: ** Get clock factor and sync divisor for a given
6174: ** synchronous factor period.
6175: ** Returns the clock factor (in sxfer) and scntl3
6176: ** synchronous divisor field.
6177: **
6178: **==========================================================
6179: */
6180:
6181: static void ncr_getsync(ncb_p np, u_char sfac, u_char *fakp, u_char *scntl3p)
6182: {
6183: u_long clk = np->clock_khz; /* SCSI clock frequency in kHz */
6184: int div = np->clock_divn; /* Number of divisors supported */
6185: u_long fak; /* Sync factor in sxfer */
6186: u_long per; /* Period in tenths of ns */
6187: u_long kpc; /* (per * clk) */
6188:
6189: /*
6190: ** Compute the synchronous period in tenths of nano-seconds
6191: */
6192: if (sfac <= 10) per = 250;
6193: else if (sfac == 11) per = 303;
6194: else if (sfac == 12) per = 500;
6195: else per = 40 * sfac;
6196:
6197: /*
6198: ** Look for the greatest clock divisor that allows an
6199: ** input speed faster than the period.
6200: */
6201: kpc = per * clk;
6202: while (--div >= 0)
6203: if (kpc >= (div_10M[div] << 2)) break;
6204:
6205: /*
6206: ** Calculate the lowest clock factor that allows an output
6207: ** speed not faster than the period.
6208: */
6209: fak = (kpc - 1) / div_10M[div] + 1;
6210:
6211: #if 0 /* This optimization does not seem very usefull */
6212:
6213: per = (fak * div_10M[div]) / clk;
6214:
6215: /*
6216: ** Why not to try the immediate lower divisor and to choose
6217: ** the one that allows the fastest output speed ?
6218: ** We don't want input speed too much greater than output speed.
6219: */
6220: if (div >= 1 && fak < 8) {
6221: u_long fak2, per2;
6222: fak2 = (kpc - 1) / div_10M[div-1] + 1;
6223: per2 = (fak2 * div_10M[div-1]) / clk;
6224: if (per2 < per && fak2 <= 8) {
6225: fak = fak2;
6226: per = per2;
6227: --div;
6228: }
6229: }
6230: #endif
6231:
6232: if (fak < 4) fak = 4; /* Should never happen, too bad ... */
6233:
6234: /*
6235: ** Compute and return sync parameters for the ncr
6236: */
6237: *fakp = fak - 4;
6238: *scntl3p = ((div+1) << 4) + (sfac < 25 ? 0x80 : 0);
6239: }
6240:
6241:
6242: /*==========================================================
6243: **
6244: ** Set actual values, sync status and patch all ccbs of
6245: ** a target according to new sync/wide agreement.
6246: **
6247: **==========================================================
6248: */
6249:
6250: static void ncr_set_sync_wide_status (ncb_p np, u_char target)
6251: {
6252: ccb_p cp;
6253: tcb_p tp = &np->target[target];
6254:
6255: /*
6256: ** set actual value and sync_status
6257: */
6258: OUTB (nc_sxfer, tp->sval);
6259: np->sync_st = tp->sval;
6260: OUTB (nc_scntl3, tp->wval);
6261: np->wide_st = tp->wval;
6262:
6263: /*
6264: ** patch ALL ccbs of this target.
6265: */
6266: for (cp = np->ccb; cp; cp = cp->link_ccb) {
6267: if (!cp->cmd) continue;
6268: if (cp->cmd->target != target) continue;
6269: cp->sync_status = tp->sval;
6270: cp->wide_status = tp->wval;
6271: };
6272: }
6273:
6274: /*==========================================================
6275: **
6276: ** Switch sync mode for current job and it's target
6277: **
6278: **==========================================================
6279: */
6280:
6281: static void ncr_setsync (ncb_p np, ccb_p cp, u_char scntl3, u_char sxfer)
6282: {
6283: Scsi_Cmnd *cmd;
6284: tcb_p tp;
6285: u_char target = INB (nc_ctest0) & 0x0f;
6286: u_char idiv;
6287:
6288: assert (cp);
6289: if (!cp) return;
6290:
6291: cmd = cp->cmd;
6292: assert (cmd);
6293: if (!cmd) return;
6294: assert (target == (cmd->target & 0xf));
6295:
6296: tp = &np->target[target];
6297:
6298: if (!scntl3 || !(sxfer & 0x1f))
6299: scntl3 = np->rv_scntl3;
6300: scntl3 = (scntl3 & 0xf0) | (tp->wval & EWS) | (np->rv_scntl3 & 0x07);
6301:
6302: /*
6303: ** Deduce the value of controller sync period from scntl3.
6304: ** period is in tenths of nano-seconds.
6305: */
6306:
6307: idiv = ((scntl3 >> 4) & 0x7);
6308: if ((sxfer & 0x1f) && idiv)
6309: tp->period = (((sxfer>>5)+4)*div_10M[idiv-1])/np->clock_khz;
6310: else
6311: tp->period = 0xffff;
6312:
6313: /*
6314: ** Stop there if sync parameters are unchanged
6315: */
6316: if (tp->sval == sxfer && tp->wval == scntl3) return;
6317: tp->sval = sxfer;
6318: tp->wval = scntl3;
6319:
6320: /*
6321: ** Bells and whistles ;-)
6322: */
6323: PRINT_ADDR(cmd);
6324: if (sxfer & 0x01f) {
6325: unsigned f10 = 100000 << (tp->widedone ? tp->widedone -1 : 0);
6326: unsigned mb10 = (f10 + tp->period/2) / tp->period;
6327: char *scsi;
6328:
6329: /*
6330: ** Disable extended Sreq/Sack filtering
6331: */
6332: if (tp->period <= 2000) OUTOFFB (nc_stest2, EXT);
6333:
6334: /*
6335: ** Bells and whistles ;-)
6336: */
6337: if (tp->period < 500) scsi = "FAST-40";
6338: else if (tp->period < 1000) scsi = "FAST-20";
6339: else if (tp->period < 2000) scsi = "FAST-10";
6340: else scsi = "FAST-5";
6341:
6342: printf ("%s %sSCSI %d.%d MB/s (%d ns, offset %d)\n", scsi,
6343: tp->widedone > 1 ? "WIDE " : "",
6344: mb10 / 10, mb10 % 10, tp->period / 10, sxfer & 0x1f);
6345: } else
6346: printf ("%sasynchronous.\n", tp->widedone > 1 ? "wide " : "");
6347:
6348: /*
6349: ** set actual value and sync_status
6350: ** patch ALL ccbs of this target.
6351: */
6352: ncr_set_sync_wide_status(np, target);
6353: }
6354:
6355: /*==========================================================
6356: **
6357: ** Switch wide mode for current job and it's target
6358: ** SCSI specs say: a SCSI device that accepts a WDTR
6359: ** message shall reset the synchronous agreement to
6360: ** asynchronous mode.
6361: **
6362: **==========================================================
6363: */
6364:
6365: static void ncr_setwide (ncb_p np, ccb_p cp, u_char wide, u_char ack)
6366: {
6367: Scsi_Cmnd *cmd;
6368: u_short target = INB (nc_ctest0) & 0x0f;
6369: tcb_p tp;
6370: u_char scntl3;
6371: u_char sxfer;
6372:
6373: assert (cp);
6374: if (!cp) return;
6375:
6376: cmd = cp->cmd;
6377: assert (cmd);
6378: if (!cmd) return;
6379: assert (target == (cmd->target & 0xf));
6380:
6381: tp = &np->target[target];
6382: tp->widedone = wide+1;
6383: scntl3 = (tp->wval & (~EWS)) | (wide ? EWS : 0);
6384:
6385: sxfer = ack ? 0 : tp->sval;
6386:
6387: /*
6388: ** Stop there if sync/wide parameters are unchanged
6389: */
6390: if (tp->sval == sxfer && tp->wval == scntl3) return;
6391: tp->sval = sxfer;
6392: tp->wval = scntl3;
6393:
6394: /*
6395: ** Bells and whistles ;-)
6396: */
6397: if (bootverbose >= 2) {
6398: PRINT_ADDR(cmd);
6399: if (scntl3 & EWS)
6400: printf ("WIDE SCSI (16 bit) enabled.\n");
6401: else
6402: printf ("WIDE SCSI disabled.\n");
6403: }
6404:
6405: /*
6406: ** set actual value and sync_status
6407: ** patch ALL ccbs of this target.
6408: */
6409: ncr_set_sync_wide_status(np, target);
6410: }
6411:
6412: /*==========================================================
6413: **
6414: ** Switch tagged mode for a target.
6415: **
6416: **==========================================================
6417: */
6418:
6419: static void ncr_setmaxtags (ncb_p np, tcb_p tp, u_long numtags)
6420: {
6421: int l;
6422: if (numtags > tp->usrtags)
6423: numtags = tp->usrtags;
6424: tp->numtags = numtags;
6425: tp->maxtags = numtags;
6426:
6427: for (l=0; l<MAX_LUN; l++) {
6428: lcb_p lp;
6429: u_char wastags;
6430:
6431: if (!tp) break;
6432: lp=tp->lp[l];
6433: if (!lp) continue;
6434:
6435: wastags = lp->usetags;
6436: ncr_settags (tp, lp);
6437:
6438: if (numtags > 1 && lp->reqccbs > 1) {
6439: PRINT_LUN(np, tp - np->target, l);
6440: printf("using tagged command queueing, up to %ld cmds/lun\n", numtags);
6441: }
6442: else if (numtags <= 1 && wastags) {
6443: PRINT_LUN(np, tp - np->target, l);
6444: printf("disabling tagged command queueing\n");
6445: }
6446: };
6447: }
6448:
6449: static void ncr_settags (tcb_p tp, lcb_p lp)
6450: {
6451: u_char reqtags, tmp;
6452:
6453: if ((!tp) || (!lp)) return;
6454:
6455: /*
6456: ** only devices conformant to ANSI Version >= 2
6457: ** only devices capable of tagges commands
6458: ** only disk devices
6459: ** only if enabled by user ..
6460: */
6461: if (( tp->inqdata[2] & 0x7) >= 2 &&
6462: ( tp->inqdata[7] & INQ7_QUEUE) && ((tp->inqdata[0] & 0x1f)==0x00)
6463: && tp->numtags > 1) {
6464: reqtags = tp->numtags;
6465: if (lp->actlink <= 1)
6466: lp->usetags=reqtags;
6467: } else {
6468: reqtags = 1;
6469: if (lp->actlink <= 1)
6470: lp->usetags=0;
6471: };
6472:
6473: /*
6474: ** don't announce more than available.
6475: */
6476: tmp = lp->actccbs;
6477: if (tmp > reqtags) tmp = reqtags;
6478: lp->reqlink = tmp;
6479:
6480: /*
6481: ** don't discard if announced.
6482: */
6483: tmp = lp->actlink;
6484: if (tmp < reqtags) tmp = reqtags;
6485: lp->reqccbs = tmp;
6486: }
6487:
6488: /*----------------------------------------------------
6489: **
6490: ** handle user commands
6491: **
6492: **----------------------------------------------------
6493: */
6494:
6495: #ifdef SCSI_NCR_USER_COMMAND_SUPPORT
6496:
6497: static void ncr_usercmd (ncb_p np)
6498: {
6499: u_char t;
6500: tcb_p tp;
6501:
6502: switch (np->user.cmd) {
6503:
6504: case 0: return;
6505:
6506: case UC_SETSYNC:
6507: for (t=0; t<MAX_TARGET; t++) {
6508: if (!((np->user.target>>t)&1)) continue;
6509: tp = &np->target[t];
6510: tp->usrsync = np->user.data;
6511: ncr_negotiate (np, tp);
6512: };
6513: break;
6514:
6515: case UC_SETTAGS:
6516: if (np->user.data > SCSI_NCR_MAX_TAGS)
6517: np->user.data = SCSI_NCR_MAX_TAGS;
6518: for (t=0; t<MAX_TARGET; t++) {
6519: if (!((np->user.target>>t)&1)) continue;
6520: np->target[t].usrtags = np->user.data;
6521: ncr_setmaxtags (np, &np->target[t], np->user.data);
6522: };
6523: break;
6524:
6525: case UC_SETDEBUG:
6526: #ifdef SCSI_NCR_DEBUG_INFO_SUPPORT
6527: ncr_debug = np->user.data;
6528: #endif
6529: break;
6530:
6531: case UC_SETORDER:
6532: np->order = np->user.data;
6533: break;
6534:
6535: case UC_SETWIDE:
6536: for (t=0; t<MAX_TARGET; t++) {
6537: u_long size;
6538: if (!((np->user.target>>t)&1)) continue;
6539: tp = &np->target[t];
6540: size = np->user.data;
6541: if (size > np->maxwide) size=np->maxwide;
6542: tp->usrwide = size;
6543: ncr_negotiate (np, tp);
6544: };
6545: break;
6546:
6547: case UC_SETFLAG:
6548: for (t=0; t<MAX_TARGET; t++) {
6549: if (!((np->user.target>>t)&1)) continue;
6550: tp = &np->target[t];
6551: tp->usrflag = np->user.data;
6552: };
6553: break;
6554:
6555: case UC_CLEARPROF:
6556: bzero(&np->profile, sizeof(np->profile));
6557: break;
6558: #ifdef UC_DEBUG_ERROR_RECOVERY
6559: case UC_DEBUG_ERROR_RECOVERY:
6560: np->debug_error_recovery = np->user.data;
6561: break;
6562: #endif
6563: }
6564: np->user.cmd=0;
6565: }
6566: #endif
6567:
6568:
6569: /*=====================================================================
6570: **
6571: ** Embedded error recovery debugging code.
6572: **
6573: **=====================================================================
6574: **
6575: ** This code is conditionned by SCSI_NCR_DEBUG_ERROR_RECOVERY_SUPPORT.
6576: ** It only can be enabled after boot-up with a control command.
6577: **
6578: ** Every 30 seconds the timer handler of the driver decides to
6579: ** change the behaviour of the driver in order to trigger errors.
6580: **
6581: ** If last command was "debug_error_recovery sge", the driver
6582: ** sets sync offset of all targets that use sync transfers to 2,
6583: ** and so hopes a SCSI gross error at the next read operation.
6584: **
6585: ** If last command was "debug_error_recovery abort", the driver
6586: ** does not signal new scsi commands to the script processor, until
6587: ** it is asked to abort or reset a command by the mid-level driver.
6588: **
6589: ** If last command was "debug_error_recovery reset", the driver
6590: ** does not signal new scsi commands to the script processor, until
6591: ** it is asked to reset a command by the mid-level driver.
6592: **
6593: ** If last command was "debug_error_recovery parity", the driver
6594: ** will assert ATN on the next DATA IN phase mismatch, and so will
6595: ** behave as if a parity error had been detected.
6596: **
6597: ** The command "debug_error_recovery none" makes the driver behave
6598: ** normaly.
6599: **
6600: **=====================================================================
6601: */
6602:
6603: #ifdef SCSI_NCR_DEBUG_ERROR_RECOVERY_SUPPORT
6604: static void ncr_trigger_errors (ncb_p np)
6605: {
6606: /*
6607: ** If np->debug_error_recovery is not zero, we want to
6608: ** simulate common errors in order to test error recovery.
6609: */
6610: do {
6611: static u_long last = 0l;
6612:
6613: if (!np->debug_error_recovery)
6614: break;
6615: if (!last)
6616: last = jiffies;
6617: else if (jiffies < last + 30*HZ)
6618: break;
6619: last = jiffies;
6620: /*
6621: * This one triggers SCSI gross errors.
6622: */
6623: if (np->debug_error_recovery == 1) {
6624: int i;
6625: printf("%s: testing error recovery from SCSI gross error...\n", ncr_name(np));
6626: for (i = 0 ; i < MAX_TARGET ; i++) {
6627: if (np->target[i].sval & 0x1f) {
6628: np->target[i].sval &= ~0x1f;
6629: np->target[i].sval += 2;
6630: }
6631: }
6632: }
6633: /*
6634: * This one triggers abort from the mid-level driver.
6635: */
6636: else if (np->debug_error_recovery == 2) {
6637: printf("%s: testing error recovery from mid-level driver abort()...\n", ncr_name(np));
6638: np->stalling = 2;
6639: }
6640: /*
6641: * This one triggers reset from the mid-level driver.
6642: */
6643: else if (np->debug_error_recovery == 3) {
6644: printf("%s: testing error recovery from mid-level driver reset()...\n", ncr_name(np));
6645: np->stalling = 3;
6646: }
6647: /*
6648: * This one set ATN on phase mismatch in DATA IN phase and so
6649: * will behave as on scsi parity error detected.
6650: */
6651: else if (np->debug_error_recovery == 4) {
6652: printf("%s: testing data in parity error...\n", ncr_name(np));
6653: np->assert_atn = 1;
6654: }
6655: } while (0);
6656: }
6657: #endif
6658:
6659: /*==========================================================
6660: **
6661: **
6662: ** ncr timeout handler.
6663: **
6664: **
6665: **==========================================================
6666: **
6667: ** Misused to keep the driver running when
6668: ** interrupts are not configured correctly.
6669: **
6670: **----------------------------------------------------------
6671: */
6672:
6673: static void ncr_timeout (ncb_p np)
6674: {
6675: u_long thistime = jiffies;
6676: u_long count = 0;
6677: ccb_p cp;
6678: u_long flags;
6679:
6680: /*
6681: ** If release process in progress, let's go
6682: ** Set the release stage from 1 to 2 to synchronize
6683: ** with the release process.
6684: */
6685:
6686: if (np->release_stage) {
6687: if (np->release_stage == 1) np->release_stage = 2;
6688: return;
6689: }
6690:
6691: np->timer.expires =
6692: #if LINUX_VERSION_CODE >= LinuxVersionCode(1,3,0)
6693: jiffies +
6694: #endif
6695: SCSI_NCR_TIMER_INTERVAL;
6696:
6697: add_timer(&np->timer);
6698:
6699: #ifdef SCSI_NCR_DEBUG_ERROR_RECOVERY_SUPPORT
6700: ncr_trigger_errors (np);
6701: #endif
6702:
6703: /*
6704: ** If we are resetting the ncr, wait for settle_time before
6705: ** clearing it. Then command processing will be resumed.
6706: */
6707: if (np->settle_time) {
6708: if (np->settle_time <= thistime) {
6709: if (bootverbose > 1)
6710: printf("%s: command processing resumed\n", ncr_name(np));
6711: save_flags(flags); cli();
6712: np->settle_time = 0;
6713: np->disc = 1;
6714: requeue_waiting_list(np);
6715: restore_flags(flags);
6716: }
6717: return;
6718: }
6719:
6720: /*
6721: ** Since the generic scsi driver only allows us 0.5 second
6722: ** to perform abort of a command, we must look at ccbs about
6723: ** every 0.25 second.
6724: */
6725: if (np->lasttime + (HZ>>2) <= thistime) {
6726: /*
6727: ** block ncr interrupts
6728: */
6729: save_flags(flags); cli();
6730:
6731: np->lasttime = thistime;
6732:
6733: /*
6734: ** Reset profile data to avoid ugly overflow
6735: ** (Limited to 1024 GB for 32 bit architecture)
6736: */
6737: if (np->profile.num_kbytes > (~0UL >> 2))
6738: bzero(&np->profile, sizeof(np->profile));
6739:
6740: /*----------------------------------------------------
6741: **
6742: ** handle ncr chip timeouts
6743: **
6744: ** Assumption:
6745: ** We have a chance to arbitrate for the
6746: ** SCSI bus at least every 10 seconds.
6747: **
6748: **----------------------------------------------------
6749: */
6750: #if 0
6751: if (thistime < np->heartbeat + HZ + HZ)
6752: np->latetime = 0;
6753: else
6754: np->latetime++;
6755: #endif
6756:
6757: /*----------------------------------------------------
6758: **
6759: ** handle ccb timeouts
6760: **
6761: **----------------------------------------------------
6762: */
6763:
6764: for (cp=np->ccb; cp; cp=cp->link_ccb) {
6765: /*
6766: ** look for timed out ccbs.
6767: */
6768: if (!cp->host_status) continue;
6769: count++;
6770: /*
6771: ** Have to force ordered tag to avoid timeouts
6772: */
6773: if (cp->cmd && cp->tlimit && cp->tlimit <=
6774: thistime + NCR_TIMEOUT_INCREASE + SCSI_NCR_TIMEOUT_ALERT) {
6775: lcb_p lp;
6776: lp = np->target[cp->cmd->target].lp[cp->cmd->lun];
6777: if (lp && !lp->force_ordered_tag) {
6778: lp->force_ordered_tag = 1;
6779: }
6780: }
6781: /*
6782: ** ncr_abort_command() cannot complete canceled
6783: ** commands immediately. It sets tlimit to zero
6784: ** and ask the script to skip the scsi process if
6785: ** necessary. We have to complete this work here.
6786: */
6787:
6788: if (cp->tlimit) continue;
6789:
6790: switch (cp->host_status) {
6791:
6792: case HS_BUSY:
6793: case HS_NEGOTIATE:
6794: /*
6795: ** still in start queue ?
6796: */
6797: if (cp->phys.header.launch.l_paddr ==
6798: cpu_to_scr(NCB_SCRIPT_PHYS (np, skip)))
6799: continue;
6800:
6801: /* fall through */
6802: case HS_DISCONNECT:
6803: cp->host_status=HS_ABORTED;
6804: };
6805: cp->tag = 0;
6806:
6807: /*
6808: ** wakeup this ccb.
6809: */
6810: ncr_complete (np, cp);
6811:
6812: #ifdef SCSI_NCR_DEBUG_ERROR_RECOVERY_SUPPORT
6813: if (!np->stalling)
6814: #endif
6815: OUTB (nc_istat, SIGP);
6816: }
6817: restore_flags(flags);
6818: }
6819:
6820: #ifdef SCSI_NCR_BROKEN_INTR
6821: if (INB(nc_istat) & (INTF|SIP|DIP)) {
6822:
6823: /*
6824: ** Process pending interrupts.
6825: */
6826: save_flags(flags); cli();
6827: if (DEBUG_FLAGS & DEBUG_TINY) printf ("{");
6828: ncr_exception (np);
6829: if (DEBUG_FLAGS & DEBUG_TINY) printf ("}");
6830: restore_flags(flags);
6831: }
6832: #endif /* SCSI_NCR_BROKEN_INTR */
6833: }
6834:
6835: /*==========================================================
6836: **
6837: ** log message for real hard errors
6838: **
6839: ** "ncr0 targ 0?: ERROR (ds:si) (so-si-sd) (sxfer/scntl3) @ name (dsp:dbc)."
6840: ** " reg: r0 r1 r2 r3 r4 r5 r6 ..... rf."
6841: **
6842: ** exception register:
6843: ** ds: dstat
6844: ** si: sist
6845: **
6846: ** SCSI bus lines:
6847: ** so: control lines as driver by NCR.
6848: ** si: control lines as seen by NCR.
6849: ** sd: scsi data lines as seen by NCR.
6850: **
6851: ** wide/fastmode:
6852: ** sxfer: (see the manual)
6853: ** scntl3: (see the manual)
6854: **
6855: ** current script command:
6856: ** dsp: script adress (relative to start of script).
6857: ** dbc: first word of script command.
6858: **
6859: ** First 16 register of the chip:
6860: ** r0..rf
6861: **
6862: **==========================================================
6863: */
6864:
6865: static void ncr_log_hard_error(ncb_p np, u_short sist, u_char dstat)
6866: {
6867: u_int32 dsp;
6868: int script_ofs;
6869: int script_size;
6870: char *script_name;
6871: u_char *script_base;
6872: int i;
6873:
6874: dsp = INL (nc_dsp);
6875:
6876: if (dsp > np->p_script && dsp <= np->p_script + sizeof(struct script)) {
6877: script_ofs = dsp - np->p_script;
6878: script_size = sizeof(struct script);
6879: script_base = (u_char *) np->script;
6880: script_name = "script";
6881: }
6882: else if (np->p_scripth < dsp &&
6883: dsp <= np->p_scripth + sizeof(struct scripth)) {
6884: script_ofs = dsp - np->p_scripth;
6885: script_size = sizeof(struct scripth);
6886: script_base = (u_char *) np->scripth;
6887: script_name = "scripth";
6888: } else {
6889: script_ofs = dsp;
6890: script_size = 0;
6891: script_base = 0;
6892: script_name = "mem";
6893: }
6894:
6895: printf ("%s:%d: ERROR (%x:%x) (%x-%x-%x) (%x/%x) @ (%s %x:%08x).\n",
6896: ncr_name (np), (unsigned)INB (nc_ctest0)&0x0f, dstat, sist,
6897: (unsigned)INB (nc_socl), (unsigned)INB (nc_sbcl), (unsigned)INB (nc_sbdl),
6898: (unsigned)INB (nc_sxfer),(unsigned)INB (nc_scntl3), script_name, script_ofs,
6899: (unsigned)INL (nc_dbc));
6900:
6901: if (((script_ofs & 3) == 0) &&
6902: (unsigned)script_ofs < script_size) {
6903: printf ("%s: script cmd = %08x\n", ncr_name(np),
6904: (int) *(ncrcmd *)(script_base + script_ofs));
6905: }
6906:
6907: printf ("%s: regdump:", ncr_name(np));
6908: for (i=0; i<16;i++)
6909: printf (" %02x", (unsigned)INB_OFF(i));
6910: printf (".\n");
6911: }
6912:
6913: /*============================================================
6914: **
6915: ** ncr chip exception handler.
6916: **
6917: **============================================================
6918: **
6919: ** In normal cases, interrupt conditions occur one at a
6920: ** time. The ncr is able to stack in some extra registers
6921: ** other interrupts that will occurs after the first one.
6922: ** But severall interrupts may occur at the same time.
6923: **
6924: ** We probably should only try to deal with the normal
6925: ** case, but it seems that multiple interrupts occur in
6926: ** some cases that are not abnormal at all.
6927: **
6928: ** The most frequent interrupt condition is Phase Mismatch.
6929: ** We should want to service this interrupt quickly.
6930: ** A SCSI parity error may be delivered at the same time.
6931: ** The SIR interrupt is not very frequent in this driver,
6932: ** since the INTFLY is likely used for command completion
6933: ** signaling.
6934: ** The Selection Timeout interrupt may be triggered with
6935: ** IID and/or UDC.
6936: ** The SBMC interrupt (SCSI Bus Mode Change) may probably
6937: ** occur at any time.
6938: **
6939: ** This handler try to deal as cleverly as possible with all
6940: ** the above.
6941: **
6942: **============================================================
6943: */
6944:
6945: void ncr_exception (ncb_p np)
6946: {
6947: u_char istat, dstat;
6948: u_short sist;
6949: int i;
6950:
6951: /*
6952: ** interrupt on the fly ?
6953: ** Since the global header may be copied back to a CCB
6954: ** using a posted PCI memory write, the last operation on
6955: ** the istat register is a READ in order to flush posted
6956: ** PCI commands (Btw, the 'do' loop is probably useless).
6957: */
6958: istat = INB (nc_istat);
6959: if (istat & INTF) {
6960: do {
6961: OUTB (nc_istat, (istat & SIGP) | INTF);
6962: istat = INB (nc_istat);
6963: } while (istat & INTF);
6964: if (DEBUG_FLAGS & DEBUG_TINY) printf ("F ");
6965: np->profile.num_fly++;
6966: ncr_wakeup (np, 0);
6967: };
6968:
6969: if (!(istat & (SIP|DIP)))
6970: return;
6971:
6972: np->profile.num_int++;
6973:
6974: if (istat & CABRT)
6975: OUTB (nc_istat, CABRT);
6976:
6977: /*
6978: ** Steinbach's Guideline for Systems Programming:
6979: ** Never test for an error condition you don't know how to handle.
6980: */
6981:
6982: sist = (istat & SIP) ? INW (nc_sist) : 0;
6983: dstat = (istat & DIP) ? INB (nc_dstat) : 0;
6984:
6985: if (DEBUG_FLAGS & DEBUG_TINY)
6986: printf ("<%d|%x:%x|%x:%x>",
6987: (int)INB(nc_scr0),
6988: dstat,sist,
6989: (unsigned)INL(nc_dsp),
6990: (unsigned)INL(nc_dbc));
6991:
6992: /*========================================================
6993: ** First, interrupts we want to service cleanly.
6994: **
6995: ** Phase mismatch is the most frequent interrupt, and
6996: ** so we have to service it as quickly and as cleanly
6997: ** as possible.
6998: ** Programmed interrupts are rarely used in this driver,
6999: ** but we must handle them cleanly anyway.
7000: ** We try to deal with PAR and SBMC combined with
7001: ** some other interrupt(s).
7002: **=========================================================
7003: */
7004:
7005: if (!(sist & (STO|GEN|HTH|SGE|UDC|RST)) &&
7006: !(dstat & (MDPE|BF|ABRT|IID))) {
7007: if ((sist & SBMC) && ncr_int_sbmc (np))
7008: return;
7009: if ((sist & PAR) && ncr_int_par (np))
7010: return;
7011: if (sist & MA) {
7012: ncr_int_ma (np);
7013: return;
7014: }
7015: if (dstat & SIR) {
7016: ncr_int_sir (np);
7017: return;
7018: }
7019: /*
7020: ** DEL 397 - 53C875 Rev 3 - Part Number 609-0392410 - ITEM 2.
7021: */
7022: if (!(sist & (SBMC|PAR)) && !(dstat & SSI)) {
7023: printf( "%s: unknown interrupt(s) ignored, "
7024: "ISTAT=%x DSTAT=%x SIST=%x\n",
7025: ncr_name(np), istat, dstat, sist);
7026: return;
7027: }
7028:
7029: OUTONB (nc_dcntl, (STD|NOCOM));
7030: return;
7031: };
7032:
7033: /*========================================================
7034: ** Now, interrupts that need some fixing up.
7035: ** Order and multiple interrupts is so less important.
7036: **
7037: ** If SRST has been asserted, we just reset the chip.
7038: **
7039: ** Selection is intirely handled by the chip. If the
7040: ** chip says STO, we trust it. Seems some other
7041: ** interrupts may occur at the same time (UDC, IID), so
7042: ** we ignore them. In any case we do enough fix-up
7043: ** in the service routine.
7044: ** We just exclude some fatal dma errors.
7045: **=========================================================
7046: */
7047:
7048: if (sist & RST) {
7049: ncr_init (np, 1, bootverbose ? "scsi reset" : NULL, HS_RESET);
7050: return;
7051: };
7052:
7053: if ((sist & STO) &&
7054: !(dstat & (MDPE|BF|ABRT))) {
7055: /*
7056: ** DEL 397 - 53C875 Rev 3 - Part Number 609-0392410 - ITEM 1.
7057: */
7058: OUTONB (nc_ctest3, CLF);
7059:
7060: ncr_int_sto (np);
7061: return;
7062: };
7063:
7064: /*=========================================================
7065: ** Now, interrupts we are not able to recover cleanly.
7066: ** (At least for the moment).
7067: **
7068: ** Do the register dump.
7069: ** Log message for real hard errors.
7070: ** Clear all fifos.
7071: ** For MDPE, BF, ABORT, IID, SGE and HTH we reset the
7072: ** BUS and the chip.
7073: ** We are more soft for UDC.
7074: **=========================================================
7075: */
7076: if (jiffies - np->regtime > 10*HZ) {
7077: np->regtime = jiffies;
7078: for (i = 0; i<sizeof(np->regdump); i++)
7079: ((char*)&np->regdump)[i] = INB_OFF(i);
7080: np->regdump.nc_dstat = dstat;
7081: np->regdump.nc_sist = sist;
7082: };
7083:
7084: ncr_log_hard_error(np, sist, dstat);
7085:
7086: printf ("%s: have to clear fifos.\n", ncr_name (np));
7087: OUTB (nc_stest3, TE|CSF);
7088: OUTONB (nc_ctest3, CLF);
7089:
7090: if ((sist & (SGE)) ||
7091: (dstat & (MDPE|BF|ABORT|IID))) {
7092: ncr_start_reset(np, driver_setup.settle_delay);
7093: return;
7094: };
7095:
7096: if (sist & HTH) {
7097: printf ("%s: handshake timeout\n", ncr_name(np));
7098: ncr_start_reset(np, driver_setup.settle_delay);
7099: return;
7100: };
7101:
7102: if (sist & UDC) {
7103: printf ("%s: unexpected disconnect\n", ncr_name(np));
7104: if (INB (nc_scr1) != 0xff) {
7105: OUTB (nc_scr1, HS_UNEXPECTED);
7106: OUTL (nc_dsp, NCB_SCRIPT_PHYS (np, cleanup));
7107: };
7108: ncr_start_reset(np, driver_setup.settle_delay);
7109: return;
7110: };
7111:
7112: /*=========================================================
7113: ** We just miss the cause of the interrupt. :(
7114: ** Print a message. The timeout will do the real work.
7115: **=========================================================
7116: */
7117: printf ("%s: unknown interrupt\n", ncr_name(np));
7118: }
7119:
7120: /*==========================================================
7121: **
7122: ** ncr chip exception handler for selection timeout
7123: **
7124: **==========================================================
7125: **
7126: ** There seems to be a bug in the 53c810.
7127: ** Although a STO-Interrupt is pending,
7128: ** it continues executing script commands.
7129: ** But it will fail and interrupt (IID) on
7130: ** the next instruction where it's looking
7131: ** for a valid phase.
7132: **
7133: **----------------------------------------------------------
7134: */
7135:
7136: void ncr_int_sto (ncb_p np)
7137: {
7138: u_long dsa, scratcha, diff;
7139: ccb_p cp;
7140: if (DEBUG_FLAGS & DEBUG_TINY) printf ("T");
7141:
7142: /*
7143: ** look for ccb and set the status.
7144: */
7145:
7146: dsa = INL (nc_dsa);
7147: cp = np->ccb;
7148: while (cp && (CCB_PHYS (cp, phys) != dsa))
7149: cp = cp->link_ccb;
7150:
7151: if (cp) {
7152: cp-> host_status = HS_SEL_TIMEOUT;
7153: ncr_complete (np, cp);
7154: };
7155:
7156: /*
7157: ** repair start queue
7158: */
7159:
7160: scratcha = INL (nc_scratcha);
7161: diff = scratcha - NCB_SCRIPTH_PHYS (np, tryloop);
7162:
7163: /* assert ((diff <= MAX_START * 20) && !(diff % 20));*/
7164:
7165: if ((diff <= MAX_START * 20) && !(diff % 20)) {
7166: np->script->startpos[0] = cpu_to_scr(scratcha);
7167: OUTL (nc_dsp, NCB_SCRIPT_PHYS (np, start));
7168: return;
7169: };
7170: ncr_init (np, 1, "selection timeout", HS_FAIL);
7171: np->disc = 1;
7172: }
7173:
7174: /*==========================================================
7175: **
7176: ** ncr chip exception handler for SCSI bus mode change
7177: **
7178: **==========================================================
7179: **
7180: ** spi2-r12 11.2.3 says a transceiver mode change must
7181: ** generate a reset event and a device that detects a reset
7182: ** event shall initiate a hard reset. It says also that a
7183: ** device that detects a mode change shall set data transfer
7184: ** mode to eight bit asynchronous, etc...
7185: ** So, just resetting should be enough.
7186: **
7187: **
7188: **----------------------------------------------------------
7189: */
7190:
7191: static int ncr_int_sbmc (ncb_p np)
7192: {
7193: u_char scsi_mode = INB (nc_stest4) & SMODE;
7194:
7195: printf("%s: SCSI bus mode change from %x to %x.\n",
7196: ncr_name(np), np->scsi_mode, scsi_mode);
7197:
7198: np->scsi_mode = scsi_mode;
7199:
7200: /*
7201: ** Suspend command processing for 1 second and
7202: ** reinitialize all except the chip.
7203: */
7204: np->settle_time = jiffies + HZ;
7205: ncr_init (np, 0, bootverbose ? "scsi mode change" : NULL, HS_RESET);
7206:
7207: return 1;
7208: }
7209:
7210: /*==========================================================
7211: **
7212: ** ncr chip exception handler for SCSI parity error.
7213: **
7214: **==========================================================
7215: **
7216: ** SCSI parity errors are handled by the SCSI script.
7217: ** So, we just print some message.
7218: **
7219: **----------------------------------------------------------
7220: */
7221:
7222: static int ncr_int_par (ncb_p np)
7223: {
7224: printf("%s: SCSI parity error detected\n", ncr_name(np));
7225: return 0;
7226: }
7227:
7228: /*==========================================================
7229: **
7230: **
7231: ** ncr chip exception handler for phase errors.
7232: **
7233: **
7234: **==========================================================
7235: **
7236: ** We have to construct a new transfer descriptor,
7237: ** to transfer the rest of the current block.
7238: **
7239: **----------------------------------------------------------
7240: */
7241:
7242: static void ncr_int_ma (ncb_p np)
7243: {
7244: u_int32 dbc;
7245: u_int32 rest;
7246: u_int32 dsp;
7247: u_int32 dsa;
7248: u_int32 nxtdsp;
7249: u_int32 *vdsp;
7250: u_int32 oadr, olen;
7251: u_int32 *tblp;
7252: ncrcmd *newcmd;
7253: u_char cmd, sbcl;
7254: ccb_p cp;
7255:
7256: dsp = INL (nc_dsp);
7257: dbc = INL (nc_dbc);
7258: sbcl = INB (nc_sbcl);
7259:
7260: cmd = dbc >> 24;
7261: rest = dbc & 0xffffff;
7262:
7263: /*
7264: ** Take into account dma fifo and various buffers and latches,
7265: ** only if the interrupted phase is an OUTPUT phase.
7266: */
7267:
7268: if ((cmd & 1) == 0) {
7269: u_char ctest5, ss0, ss2;
7270: u_short delta;
7271:
7272: ctest5 = (np->rv_ctest5 & DFS) ? INB (nc_ctest5) : 0;
7273: if (ctest5 & DFS)
7274: delta=(((ctest5 << 8) | (INB (nc_dfifo) & 0xff)) - rest) & 0x3ff;
7275: else
7276: delta=(INB (nc_dfifo) - rest) & 0x7f;
7277:
7278: /*
7279: ** The data in the dma fifo has not been transfered to
7280: ** the target -> add the amount to the rest
7281: ** and clear the data.
7282: ** Check the sstat2 register in case of wide transfer.
7283: */
7284:
7285: rest += delta;
7286: ss0 = INB (nc_sstat0);
7287: if (ss0 & OLF) rest++;
7288: if (ss0 & ORF) rest++;
7289: if (INB(nc_scntl3) & EWS) {
7290: ss2 = INB (nc_sstat2);
7291: if (ss2 & OLF1) rest++;
7292: if (ss2 & ORF1) rest++;
7293: };
7294:
7295: OUTONB (nc_ctest3, CLF ); /* clear dma fifo */
7296: OUTB (nc_stest3, TE|CSF); /* clear scsi fifo */
7297:
7298: if (DEBUG_FLAGS & (DEBUG_TINY|DEBUG_PHASE))
7299: printf ("P%x%x RL=%d D=%d SS0=%x ", cmd&7, sbcl&7,
7300: (unsigned) rest, (unsigned) delta, ss0);
7301:
7302: } else {
7303: if (DEBUG_FLAGS & (DEBUG_TINY|DEBUG_PHASE))
7304: printf ("P%x%x RL=%d ", cmd&7, sbcl&7, rest);
7305: if ((cmd & 7) != 1) {
7306: OUTONB (nc_ctest3, CLF );
7307: OUTB (nc_stest3, TE|CSF);
7308: }
7309: }
7310:
7311: /*
7312: ** locate matching cp
7313: */
7314: dsa = INL (nc_dsa);
7315: cp = np->ccb;
7316: while (cp && (CCB_PHYS (cp, phys) != dsa))
7317: cp = cp->link_ccb;
7318:
7319: if (!cp) {
7320: printf ("%s: SCSI phase error fixup: CCB already dequeued (0x%08lx)\n",
7321: ncr_name (np), (u_long) np->header.cp);
7322: return;
7323: }
7324: if (cp != np->header.cp) {
7325: printf ("%s: SCSI phase error fixup: CCB address mismatch (0x%08lx != 0x%08lx)\n",
7326: ncr_name (np), (u_long) cp, (u_long) np->header.cp);
7327: /* return;*/
7328: }
7329:
7330: /*
7331: ** find the interrupted script command,
7332: ** and the address at which to continue.
7333: */
7334:
7335: if (dsp == vtophys (&cp->patch[2])) {
7336: vdsp = &cp->patch[0];
7337: nxtdsp = vdsp[3];
7338: } else if (dsp == vtophys (&cp->patch[6])) {
7339: vdsp = &cp->patch[4];
7340: nxtdsp = vdsp[3];
7341: } else if (dsp > np->p_script && dsp <= np->p_script + sizeof(struct script)) {
7342: vdsp = (u_int32 *) ((char*)np->script - np->p_script + dsp -8);
7343: nxtdsp = dsp;
7344: } else {
7345: vdsp = (u_int32 *) ((char*)np->scripth - np->p_scripth + dsp -8);
7346: nxtdsp = dsp;
7347: };
7348:
7349: /*
7350: ** log the information
7351: */
7352:
7353: if (DEBUG_FLAGS & DEBUG_PHASE) {
7354: printf ("\nCP=%p CP2=%p DSP=%x NXT=%x VDSP=%p CMD=%x ",
7355: cp, np->header.cp,
7356: (unsigned)dsp,
7357: (unsigned)nxtdsp, vdsp, cmd);
7358: };
7359:
7360: /*
7361: ** get old startaddress and old length.
7362: */
7363:
7364: oadr = scr_to_cpu(vdsp[1]);
7365:
7366: if (cmd & 0x10) { /* Table indirect */
7367: tblp = (u_int32 *) ((char*) &cp->phys + oadr);
7368: olen = scr_to_cpu(tblp[0]);
7369: oadr = scr_to_cpu(tblp[1]);
7370: } else {
7371: tblp = (u_int32 *) 0;
7372: olen = scr_to_cpu(vdsp[0]) & 0xffffff;
7373: };
7374:
7375: if (DEBUG_FLAGS & DEBUG_PHASE) {
7376: printf ("OCMD=%x\nTBLP=%p OLEN=%x OADR=%x\n",
7377: (unsigned) (scr_to_cpu(vdsp[0]) >> 24),
7378: tblp,
7379: (unsigned) olen,
7380: (unsigned) oadr);
7381: };
7382:
7383: /*
7384: ** check cmd against assumed interrupted script command.
7385: */
7386:
7387: if (cmd != (scr_to_cpu(vdsp[0]) >> 24)) {
7388: PRINT_ADDR(cp->cmd);
7389: printf ("internal error: cmd=%02x != %02x=(vdsp[0] >> 24)\n",
7390: (unsigned)cmd, (unsigned)scr_to_cpu(vdsp[0]) >> 24);
7391:
7392: return;
7393: }
7394:
7395: #ifdef SCSI_NCR_DEBUG_ERROR_RECOVERY_SUPPORT
7396: if ((cmd & 7) == 1 && np->assert_atn) {
7397: np->assert_atn = 0;
7398: OUTONB(nc_socl, CATN);
7399: }
7400: #endif
7401:
7402: /*
7403: ** if old phase not dataphase, leave here.
7404: */
7405:
7406: if (cmd & 0x06) {
7407: PRINT_ADDR(cp->cmd);
7408: printf ("phase change %x-%x %d@%08x resid=%d.\n",
7409: cmd&7, sbcl&7, (unsigned)olen,
7410: (unsigned)oadr, (unsigned)rest);
7411:
7412: OUTONB (nc_dcntl, (STD|NOCOM));
7413: return;
7414: };
7415:
7416: /*
7417: ** choose the correct patch area.
7418: ** if savep points to one, choose the other.
7419: */
7420:
7421: newcmd = cp->patch;
7422: if (cp->phys.header.savep == cpu_to_scr(vtophys (newcmd))) newcmd+=4;
7423:
7424: /*
7425: ** fillin the commands
7426: */
7427:
7428: newcmd[0] = cpu_to_scr(((cmd & 0x0f) << 24) | rest);
7429: newcmd[1] = cpu_to_scr(oadr + olen - rest);
7430: newcmd[2] = cpu_to_scr(SCR_JUMP);
7431: newcmd[3] = cpu_to_scr(nxtdsp);
7432:
7433: if (DEBUG_FLAGS & DEBUG_PHASE) {
7434: PRINT_ADDR(cp->cmd);
7435: printf ("newcmd[%d] %x %x %x %x.\n",
7436: (int) (newcmd - cp->patch),
7437: (unsigned)scr_to_cpu(newcmd[0]),
7438: (unsigned)scr_to_cpu(newcmd[1]),
7439: (unsigned)scr_to_cpu(newcmd[2]),
7440: (unsigned)scr_to_cpu(newcmd[3]));
7441: }
7442: /*
7443: ** fake the return address (to the patch).
7444: ** and restart script processor at dispatcher.
7445: */
7446: np->profile.num_break++;
7447: OUTL (nc_temp, vtophys (newcmd));
7448: if ((cmd & 7) == 0)
7449: OUTL (nc_dsp, NCB_SCRIPT_PHYS (np, dispatch));
7450: else
7451: OUTL (nc_dsp, NCB_SCRIPT_PHYS (np, checkatn));
7452: }
7453:
7454: /*==========================================================
7455: **
7456: **
7457: ** ncr chip exception handler for programmed interrupts.
7458: **
7459: **
7460: **==========================================================
7461: */
7462:
7463: static int ncr_show_msg (u_char * msg)
7464: {
7465: u_char i;
7466: printf ("%x",*msg);
7467: if (*msg==M_EXTENDED) {
7468: for (i=1;i<8;i++) {
7469: if (i-1>msg[1]) break;
7470: printf ("-%x",msg[i]);
7471: };
7472: return (i+1);
7473: } else if ((*msg & 0xf0) == 0x20) {
7474: printf ("-%x",msg[1]);
7475: return (2);
7476: };
7477: return (1);
7478: }
7479:
7480: void ncr_int_sir (ncb_p np)
7481: {
7482: u_char scntl3;
7483: u_char chg, ofs, per, fak, wide;
7484: u_char num = INB (nc_dsps);
7485: ccb_p cp=0;
7486: u_long dsa;
7487: u_char target = INB (nc_ctest0) & 0x0f;
7488: tcb_p tp = &np->target[target];
7489: int i;
7490: if (DEBUG_FLAGS & DEBUG_TINY) printf ("I#%d", num);
7491:
7492: switch (num) {
7493: case SIR_SENSE_RESTART:
7494: case SIR_STALL_RESTART:
7495: break;
7496: case SIR_STALL_QUEUE: /* Ignore, just restart the script */
7497: goto out;
7498:
7499: default:
7500: /*
7501: ** lookup the ccb
7502: */
7503: dsa = INL (nc_dsa);
7504: cp = np->ccb;
7505: while (cp && (CCB_PHYS (cp, phys) != dsa))
7506: cp = cp->link_ccb;
7507:
7508: assert (cp);
7509: if (!cp)
7510: goto out;
7511: assert (cp == np->header.cp);
7512: if (cp != np->header.cp)
7513: goto out;
7514: }
7515:
7516: switch (num) {
7517: u_long endp;
7518: case SIR_DATA_IO_IS_OUT:
7519: case SIR_DATA_IO_IS_IN:
7520: /*
7521: ** We did not guess the direction of transfer. We have to wait for
7522: ** actual data direction driven by the target before setting
7523: ** pointers. We must patch the global header too.
7524: */
7525: if (num == SIR_DATA_IO_IS_OUT) {
7526: endp = NCB_SCRIPTH_PHYS (np, data_out) + MAX_SCATTER*16;
7527: cp->phys.header.goalp = cpu_to_scr(endp + 8);
7528: cp->phys.header.savep =
7529: cpu_to_scr(endp - cp->segments*16);
7530: } else {
7531: endp = NCB_SCRIPT_PHYS (np, data_in) + MAX_SCATTER*16;
7532: cp->phys.header.goalp = cpu_to_scr(endp + 8);
7533: cp->phys.header.savep =
7534: cpu_to_scr(endp - cp->segments*16);
7535: }
7536:
7537: cp->phys.header.lastp = cp->phys.header.savep;
7538: np->header.savep = cp->phys.header.savep;
7539: np->header.goalp = cp->phys.header.goalp;
7540: np->header.lastp = cp->phys.header.lastp;
7541:
7542: OUTL (nc_temp, scr_to_cpu(np->header.savep));
7543: OUTL (nc_dsp, scr_to_cpu(np->header.savep));
7544: return;
7545: /* break; */
7546:
7547: /*--------------------------------------------------------------------
7548: **
7549: ** Processing of interrupted getcc selects
7550: **
7551: **--------------------------------------------------------------------
7552: */
7553:
7554: case SIR_SENSE_RESTART:
7555: /*------------------------------------------
7556: ** Script processor is idle.
7557: ** Look for interrupted "check cond"
7558: **------------------------------------------
7559: */
7560:
7561: if (DEBUG_FLAGS & DEBUG_RESTART)
7562: printf ("%s: int#%d",ncr_name (np),num);
7563: cp = (ccb_p) 0;
7564: for (i=0; i<MAX_TARGET; i++) {
7565: if (DEBUG_FLAGS & DEBUG_RESTART) printf (" t%d", i);
7566: tp = &np->target[i];
7567: if (DEBUG_FLAGS & DEBUG_RESTART) printf ("+");
7568: cp = tp->hold_cp;
7569: if (!cp) continue;
7570: if (DEBUG_FLAGS & DEBUG_RESTART) printf ("+");
7571: if ((cp->host_status==HS_BUSY) &&
7572: (cp->scsi_status==S_CHECK_COND))
7573: break;
7574: if (DEBUG_FLAGS & DEBUG_RESTART) printf ("- (remove)");
7575: tp->hold_cp = cp = (ccb_p) 0;
7576: };
7577:
7578: if (cp) {
7579: if (DEBUG_FLAGS & DEBUG_RESTART)
7580: printf ("+ restart job ..\n");
7581: OUTL (nc_dsa, CCB_PHYS (cp, phys));
7582: OUTL (nc_dsp, NCB_SCRIPTH_PHYS (np, getcc));
7583: return;
7584: };
7585:
7586: /*
7587: ** no job, resume normal processing
7588: */
7589: if (DEBUG_FLAGS & DEBUG_RESTART) printf (" -- remove trap\n");
7590: np->script->start0[0] = cpu_to_scr(SCR_INT ^ IFFALSE (0));
7591: break;
7592:
7593: case SIR_SENSE_FAILED:
7594: /*-------------------------------------------
7595: ** While trying to select for
7596: ** getting the condition code,
7597: ** a target reselected us.
7598: **-------------------------------------------
7599: */
7600: if (DEBUG_FLAGS & DEBUG_RESTART) {
7601: PRINT_ADDR(cp->cmd);
7602: printf ("in getcc reselect by t%d.\n",
7603: (int)INB(nc_ssid) & 0x0f);
7604: }
7605:
7606: /*
7607: ** Mark this job
7608: */
7609: cp->host_status = HS_BUSY;
7610: cp->scsi_status = S_CHECK_COND;
7611: np->target[cp->cmd->target].hold_cp = cp;
7612:
7613: /*
7614: ** And patch code to restart it.
7615: */
7616: np->script->start0[0] = cpu_to_scr(SCR_INT);
7617: break;
7618:
7619: /*-----------------------------------------------------------------------------
7620: **
7621: ** Was Sie schon immer ueber transfermode negotiation wissen wollten ...
7622: **
7623: ** We try to negotiate sync and wide transfer only after
7624: ** a successfull inquire command. We look at byte 7 of the
7625: ** inquire data to determine the capabilities of the target.
7626: **
7627: ** When we try to negotiate, we append the negotiation message
7628: ** to the identify and (maybe) simple tag message.
7629: ** The host status field is set to HS_NEGOTIATE to mark this
7630: ** situation.
7631: **
7632: ** If the target doesn't answer this message immidiately
7633: ** (as required by the standard), the SIR_NEGO_FAIL interrupt
7634: ** will be raised eventually.
7635: ** The handler removes the HS_NEGOTIATE status, and sets the
7636: ** negotiated value to the default (async / nowide).
7637: **
7638: ** If we receive a matching answer immediately, we check it
7639: ** for validity, and set the values.
7640: **
7641: ** If we receive a Reject message immediately, we assume the
7642: ** negotiation has failed, and fall back to standard values.
7643: **
7644: ** If we receive a negotiation message while not in HS_NEGOTIATE
7645: ** state, it's a target initiated negotiation. We prepare a
7646: ** (hopefully) valid answer, set our parameters, and send back
7647: ** this answer to the target.
7648: **
7649: ** If the target doesn't fetch the answer (no message out phase),
7650: ** we assume the negotiation has failed, and fall back to default
7651: ** settings.
7652: **
7653: ** When we set the values, we adjust them in all ccbs belonging
7654: ** to this target, in the controller's register, and in the "phys"
7655: ** field of the controller's struct ncb.
7656: **
7657: ** Possible cases: hs sir msg_in value send goto
7658: ** We try to negotiate:
7659: ** -> target doesnt't msgin NEG FAIL noop defa. - dispatch
7660: ** -> target rejected our msg NEG FAIL reject defa. - dispatch
7661: ** -> target answered (ok) NEG SYNC sdtr set - clrack
7662: ** -> target answered (!ok) NEG SYNC sdtr defa. REJ--->msg_bad
7663: ** -> target answered (ok) NEG WIDE wdtr set - clrack
7664: ** -> target answered (!ok) NEG WIDE wdtr defa. REJ--->msg_bad
7665: ** -> any other msgin NEG FAIL noop defa. - dispatch
7666: **
7667: ** Target tries to negotiate:
7668: ** -> incoming message --- SYNC sdtr set SDTR -
7669: ** -> incoming message --- WIDE wdtr set WDTR -
7670: ** We sent our answer:
7671: ** -> target doesn't msgout --- PROTO ? defa. - dispatch
7672: **
7673: **-----------------------------------------------------------------------------
7674: */
7675:
7676: case SIR_NEGO_FAILED:
7677: /*-------------------------------------------------------
7678: **
7679: ** Negotiation failed.
7680: ** Target doesn't send an answer message,
7681: ** or target rejected our message.
7682: **
7683: ** Remove negotiation request.
7684: **
7685: **-------------------------------------------------------
7686: */
7687: OUTB (HS_PRT, HS_BUSY);
7688:
7689: /* fall through */
7690:
7691: case SIR_NEGO_PROTO:
7692: /*-------------------------------------------------------
7693: **
7694: ** Negotiation failed.
7695: ** Target doesn't fetch the answer message.
7696: **
7697: **-------------------------------------------------------
7698: */
7699:
7700: if (DEBUG_FLAGS & DEBUG_NEGO) {
7701: PRINT_ADDR(cp->cmd);
7702: printf ("negotiation failed sir=%x status=%x.\n",
7703: num, cp->nego_status);
7704: };
7705:
7706: /*
7707: ** any error in negotiation:
7708: ** fall back to default mode.
7709: */
7710: switch (cp->nego_status) {
7711:
7712: case NS_SYNC:
7713: ncr_setsync (np, cp, 0, 0xe0);
7714: break;
7715:
7716: case NS_WIDE:
7717: ncr_setwide (np, cp, 0, 0);
7718: break;
7719:
7720: };
7721: np->msgin [0] = M_NOOP;
7722: np->msgout[0] = M_NOOP;
7723: cp->nego_status = 0;
7724: OUTL (nc_dsp, NCB_SCRIPT_PHYS (np, dispatch));
7725: break;
7726:
7727: case SIR_NEGO_SYNC:
7728: /*
7729: ** Synchronous request message received.
7730: */
7731:
7732: if (DEBUG_FLAGS & DEBUG_NEGO) {
7733: PRINT_ADDR(cp->cmd);
7734: printf ("sync msgin: ");
7735: (void) ncr_show_msg (np->msgin);
7736: printf (".\n");
7737: };
7738:
7739: /*
7740: ** get requested values.
7741: */
7742:
7743: chg = 0;
7744: per = np->msgin[3];
7745: ofs = np->msgin[4];
7746: if (ofs==0) per=255;
7747:
7748: /*
7749: ** if target sends SDTR message,
7750: ** it CAN transfer synch.
7751: */
7752:
7753: if (ofs)
7754: tp->inqdata[7] |= INQ7_SYNC;
7755:
7756: /*
7757: ** check values against driver limits.
7758: */
7759:
7760: if (per < np->minsync)
7761: {chg = 1; per = np->minsync;}
7762: if (per < tp->minsync)
7763: {chg = 1; per = tp->minsync;}
7764: if (ofs > tp->maxoffs)
7765: {chg = 1; ofs = tp->maxoffs;}
7766:
7767: /*
7768: ** Check against controller limits.
7769: */
7770: fak = 7;
7771: scntl3 = 0;
7772: if (ofs != 0) {
7773: ncr_getsync(np, per, &fak, &scntl3);
7774: if (fak > 7) {
7775: chg = 1;
7776: ofs = 0;
7777: }
7778: }
7779: if (ofs == 0) {
7780: fak = 7;
7781: per = 0;
7782: scntl3 = 0;
7783: tp->minsync = 0;
7784: }
7785:
7786: if (DEBUG_FLAGS & DEBUG_NEGO) {
7787: PRINT_ADDR(cp->cmd);
7788: printf ("sync: per=%d scntl3=0x%x ofs=%d fak=%d chg=%d.\n",
7789: per, scntl3, ofs, fak, chg);
7790: }
7791:
7792: if (INB (HS_PRT) == HS_NEGOTIATE) {
7793: OUTB (HS_PRT, HS_BUSY);
7794: switch (cp->nego_status) {
7795:
7796: case NS_SYNC:
7797: /*
7798: ** This was an answer message
7799: */
7800: if (chg) {
7801: /*
7802: ** Answer wasn't acceptable.
7803: */
7804: ncr_setsync (np, cp, 0, 0xe0);
7805: OUTL (nc_dsp, NCB_SCRIPT_PHYS (np, msg_bad));
7806: } else {
7807: /*
7808: ** Answer is ok.
7809: */
7810: ncr_setsync (np, cp, scntl3, (fak<<5)|ofs);
7811: OUTL (nc_dsp, NCB_SCRIPT_PHYS (np, clrack));
7812: };
7813: return;
7814:
7815: case NS_WIDE:
7816: ncr_setwide (np, cp, 0, 0);
7817: break;
7818: };
7819: };
7820:
7821: /*
7822: ** It was a request.
7823: ** Check against the table of target capabilities.
7824: ** If target not capable force M_REJECT and asynchronous.
7825: */
7826: if (np->unit < SCSI_NCR_MAX_HOST) {
7827: tp->inqdata[7] &=
7828: (target_capabilities[np->unit].and_map[target]);
7829: if (!(tp->inqdata[7] & INQ7_SYNC)) {
7830: ofs = 0;
7831: fak = 7;
7832: }
7833: }
7834:
7835: /*
7836: ** It was a request. Set value and
7837: ** prepare an answer message
7838: */
7839:
7840: ncr_setsync (np, cp, scntl3, (fak<<5)|ofs);
7841:
7842: np->msgout[0] = M_EXTENDED;
7843: np->msgout[1] = 3;
7844: np->msgout[2] = M_X_SYNC_REQ;
7845: np->msgout[3] = per;
7846: np->msgout[4] = ofs;
7847:
7848: cp->nego_status = NS_SYNC;
7849:
7850: if (DEBUG_FLAGS & DEBUG_NEGO) {
7851: PRINT_ADDR(cp->cmd);
7852: printf ("sync msgout: ");
7853: (void) ncr_show_msg (np->msgout);
7854: printf (".\n");
7855: }
7856:
7857: if (!ofs) {
7858: OUTL (nc_dsp, NCB_SCRIPT_PHYS (np, msg_bad));
7859: return;
7860: }
7861: np->msgin [0] = M_NOOP;
7862:
7863: break;
7864:
7865: case SIR_NEGO_WIDE:
7866: /*
7867: ** Wide request message received.
7868: */
7869: if (DEBUG_FLAGS & DEBUG_NEGO) {
7870: PRINT_ADDR(cp->cmd);
7871: printf ("wide msgin: ");
7872: (void) ncr_show_msg (np->msgin);
7873: printf (".\n");
7874: };
7875:
7876: /*
7877: ** get requested values.
7878: */
7879:
7880: chg = 0;
7881: wide = np->msgin[3];
7882:
7883: /*
7884: ** if target sends WDTR message,
7885: ** it CAN transfer wide.
7886: */
7887:
7888: if (wide)
7889: tp->inqdata[7] |= INQ7_WIDE16;
7890:
7891: /*
7892: ** check values against driver limits.
7893: */
7894:
7895: if (wide > tp->usrwide)
7896: {chg = 1; wide = tp->usrwide;}
7897:
7898: if (DEBUG_FLAGS & DEBUG_NEGO) {
7899: PRINT_ADDR(cp->cmd);
7900: printf ("wide: wide=%d chg=%d.\n", wide, chg);
7901: }
7902:
7903: if (INB (HS_PRT) == HS_NEGOTIATE) {
7904: OUTB (HS_PRT, HS_BUSY);
7905: switch (cp->nego_status) {
7906:
7907: case NS_WIDE:
7908: /*
7909: ** This was an answer message
7910: */
7911: if (chg) {
7912: /*
7913: ** Answer wasn't acceptable.
7914: */
7915: ncr_setwide (np, cp, 0, 1);
7916: OUTL (nc_dsp, NCB_SCRIPT_PHYS (np, msg_bad));
7917: } else {
7918: /*
7919: ** Answer is ok.
7920: */
7921: ncr_setwide (np, cp, wide, 1);
7922: OUTL (nc_dsp, NCB_SCRIPT_PHYS (np, clrack));
7923: };
7924: return;
7925:
7926: case NS_SYNC:
7927: ncr_setsync (np, cp, 0, 0xe0);
7928: break;
7929: };
7930: };
7931:
7932: /*
7933: ** It was a request, set value and
7934: ** prepare an answer message
7935: */
7936:
7937: ncr_setwide (np, cp, wide, 1);
7938:
7939: np->msgout[0] = M_EXTENDED;
7940: np->msgout[1] = 2;
7941: np->msgout[2] = M_X_WIDE_REQ;
7942: np->msgout[3] = wide;
7943:
7944: np->msgin [0] = M_NOOP;
7945:
7946: cp->nego_status = NS_WIDE;
7947:
7948: if (DEBUG_FLAGS & DEBUG_NEGO) {
7949: PRINT_ADDR(cp->cmd);
7950: printf ("wide msgout: ");
7951: (void) ncr_show_msg (np->msgin);
7952: printf (".\n");
7953: }
7954: break;
7955:
7956: /*--------------------------------------------------------------------
7957: **
7958: ** Processing of special messages
7959: **
7960: **--------------------------------------------------------------------
7961: */
7962:
7963: case SIR_REJECT_RECEIVED:
7964: /*-----------------------------------------------
7965: **
7966: ** We received a M_REJECT message.
7967: **
7968: **-----------------------------------------------
7969: */
7970:
7971: PRINT_ADDR(cp->cmd);
7972: printf ("M_REJECT received (%x:%x).\n",
7973: (unsigned)scr_to_cpu(np->lastmsg), np->msgout[0]);
7974: break;
7975:
7976: case SIR_REJECT_SENT:
7977: /*-----------------------------------------------
7978: **
7979: ** We received an unknown message
7980: **
7981: **-----------------------------------------------
7982: */
7983:
7984: PRINT_ADDR(cp->cmd);
7985: printf ("M_REJECT sent for ");
7986: (void) ncr_show_msg (np->msgin);
7987: printf (".\n");
7988: break;
7989:
7990: /*--------------------------------------------------------------------
7991: **
7992: ** Processing of special messages
7993: **
7994: **--------------------------------------------------------------------
7995: */
7996:
7997: case SIR_IGN_RESIDUE:
7998: /*-----------------------------------------------
7999: **
8000: ** We received an IGNORE RESIDUE message,
8001: ** which couldn't be handled by the script.
8002: **
8003: **-----------------------------------------------
8004: */
8005:
8006: PRINT_ADDR(cp->cmd);
8007: printf ("M_IGN_RESIDUE received, but not yet implemented.\n");
8008: break;
8009:
8010: case SIR_MISSING_SAVE:
8011: /*-----------------------------------------------
8012: **
8013: ** We received an DISCONNECT message,
8014: ** but the datapointer wasn't saved before.
8015: **
8016: **-----------------------------------------------
8017: */
8018:
8019: PRINT_ADDR(cp->cmd);
8020: printf ("M_DISCONNECT received, but datapointer not saved: "
8021: "data=%x save=%x goal=%x.\n",
8022: (unsigned) INL (nc_temp),
8023: (unsigned) scr_to_cpu(np->header.savep),
8024: (unsigned) scr_to_cpu(np->header.goalp));
8025: break;
8026:
8027: #if 0 /* This stuff does not work */
8028: /*--------------------------------------------------------------------
8029: **
8030: ** Processing of a "S_QUEUE_FULL" status.
8031: **
8032: ** The current command has been rejected,
8033: ** because there are too many in the command queue.
8034: ** We have started too many commands for that target.
8035: **
8036: ** If possible, reinsert at head of queue.
8037: ** Stall queue until there are no disconnected jobs
8038: ** (ncr is REALLY idle). Then restart processing.
8039: **
8040: ** We should restart the current job after the controller
8041: ** has become idle. But this is not yet implemented.
8042: **
8043: **--------------------------------------------------------------------
8044: */
8045: case SIR_STALL_QUEUE:
8046: /*-----------------------------------------------
8047: **
8048: ** Stall the start queue.
8049: **
8050: **-----------------------------------------------
8051: */
8052: PRINT_ADDR(cp->cmd);
8053: printf ("queue full.\n");
8054:
8055: np->script->start1[0] = cpu_to_scr(SCR_INT);
8056:
8057: /*
8058: ** Try to disable tagged transfers.
8059: */
8060: ncr_setmaxtags (np, &np->target[target], 0);
8061:
8062: /*
8063: ** @QUEUE@
8064: **
8065: ** Should update the launch field of the
8066: ** current job to be able to restart it.
8067: ** Then prepend it to the start queue.
8068: */
8069:
8070: /* fall through */
8071:
8072: case SIR_STALL_RESTART:
8073: /*-----------------------------------------------
8074: **
8075: ** Enable selecting again,
8076: ** if NO disconnected jobs.
8077: **
8078: **-----------------------------------------------
8079: */
8080: /*
8081: ** Look for a disconnected job.
8082: */
8083: cp = np->ccb;
8084: while (cp && cp->host_status != HS_DISCONNECT)
8085: cp = cp->link_ccb;
8086:
8087: /*
8088: ** if there is one, ...
8089: */
8090: if (cp) {
8091: /*
8092: ** wait for reselection
8093: */
8094: OUTL (nc_dsp, NCB_SCRIPT_PHYS (np, reselect));
8095: return;
8096: };
8097:
8098: /*
8099: ** else remove the interrupt.
8100: */
8101:
8102: printf ("%s: queue empty.\n", ncr_name (np));
8103: np->script->start1[0] = cpu_to_scr(SCR_INT ^ IFFALSE (0));
8104: break;
8105: #endif /* This stuff does not work */
8106: };
8107:
8108: out:
8109: OUTONB (nc_dcntl, (STD|NOCOM));
8110: }
8111:
8112: /*==========================================================
8113: **
8114: **
8115: ** Aquire a control block
8116: **
8117: **
8118: **==========================================================
8119: */
8120:
8121: static ccb_p ncr_get_ccb
8122: (ncb_p np, u_long target, u_long lun)
8123: {
8124: lcb_p lp;
8125: ccb_p cp = (ccb_p) 0;
8126:
8127: /*
8128: ** Lun structure available ?
8129: */
8130:
8131: lp = np->target[target].lp[lun];
8132:
8133: if (lp && lp->opennings && (!lp->active || lp->active < lp->reqlink)) {
8134:
8135: cp = lp->next_ccb;
8136:
8137: /*
8138: ** Look for free CCB
8139: */
8140:
8141: while (cp && cp->magic) cp = cp->next_ccb;
8142:
8143: /*
8144: ** Increment active commands and decrement credit.
8145: */
8146:
8147: if (cp) {
8148: ++lp->active;
8149: --lp->opennings;
8150: }
8151: }
8152:
8153: /*
8154: ** if nothing available, take the default.
8155: ** DANGEROUS, because this ccb is not suitable for
8156: ** reselection.
8157: ** If lp->actccbs > 0 wait for a suitable ccb to be free.
8158: */
8159: if ((!cp) && lp && lp->actccbs > 0)
8160: return ((ccb_p) 0);
8161:
8162: if (!cp) cp = np->ccb;
8163:
8164: /*
8165: ** Wait until available.
8166: */
8167: #if 0
8168: while (cp->magic) {
8169: if (flags & SCSI_NOSLEEP) break;
8170: if (tsleep ((caddr_t)cp, PRIBIO|PCATCH, "ncr", 0))
8171: break;
8172: };
8173: #endif
8174:
8175: if (cp->magic)
8176: return ((ccb_p) 0);
8177:
8178: cp->magic = 1;
8179: return (cp);
8180: }
8181:
8182: /*==========================================================
8183: **
8184: **
8185: ** Release one control block
8186: **
8187: **
8188: **==========================================================
8189: */
8190:
8191: void ncr_free_ccb (ncb_p np, ccb_p cp, u_long target, u_long lun)
8192: {
8193: lcb_p lp;
8194:
8195: /*
8196: ** sanity
8197: */
8198:
8199: assert (cp != NULL);
8200:
8201: /*
8202: ** Decrement active commands and increment credit.
8203: */
8204:
8205: lp = np->target[target].lp[lun];
8206: if (lp) {
8207: --lp->active;
8208: ++lp->opennings;
8209: }
8210:
8211: cp -> host_status = HS_IDLE;
8212: cp -> magic = 0;
8213: #if 0
8214: if (cp == np->ccb)
8215: wakeup ((caddr_t) cp);
8216: #endif
8217: }
8218:
8219: /*==========================================================
8220: **
8221: **
8222: ** Allocation of resources for Targets/Luns/Tags.
8223: **
8224: **
8225: **==========================================================
8226: */
8227:
8228: static void ncr_alloc_ccb (ncb_p np, u_long target, u_long lun)
8229: {
8230: tcb_p tp;
8231: lcb_p lp;
8232: ccb_p cp;
8233:
8234: assert (np != NULL);
8235:
8236: if (target>=MAX_TARGET) return;
8237: if (lun >=MAX_LUN ) return;
8238:
8239: tp=&np->target[target];
8240:
8241: if (!tp->jump_tcb.l_cmd) {
8242: /*
8243: ** initialize it.
8244: */
8245: tp->jump_tcb.l_cmd =
8246: cpu_to_scr((SCR_JUMP^IFFALSE (DATA (0x80 + target))));
8247: tp->jump_tcb.l_paddr = np->jump_tcb.l_paddr;
8248:
8249: tp->getscr[0] = (np->features & FE_PFEN) ?
8250: cpu_to_scr(SCR_COPY(1)):cpu_to_scr(SCR_COPY_F(1));
8251: tp->getscr[1] = cpu_to_scr(vtophys (&tp->sval));
8252: tp->getscr[2] =
8253: cpu_to_scr(np->paddr + offsetof (struct ncr_reg, nc_sxfer));
8254:
8255: tp->getscr[3] = (np->features & FE_PFEN) ?
8256: cpu_to_scr(SCR_COPY(1)):cpu_to_scr(SCR_COPY_F(1));
8257: tp->getscr[4] = cpu_to_scr(vtophys (&tp->wval));
8258: tp->getscr[5] =
8259: cpu_to_scr(np->paddr + offsetof (struct ncr_reg, nc_scntl3));
8260:
8261: assert (( (offsetof(struct ncr_reg, nc_sxfer) ^
8262: offsetof(struct tcb , sval )) &3) == 0);
8263: assert (( (offsetof(struct ncr_reg, nc_scntl3) ^
8264: offsetof(struct tcb , wval )) &3) == 0);
8265:
8266: tp->call_lun.l_cmd = cpu_to_scr(SCR_CALL);
8267: tp->call_lun.l_paddr =
8268: cpu_to_scr(NCB_SCRIPT_PHYS (np, resel_lun));
8269:
8270: tp->jump_lcb.l_cmd = cpu_to_scr(SCR_JUMP);
8271: tp->jump_lcb.l_paddr = cpu_to_scr(NCB_SCRIPTH_PHYS (np, abort));
8272: np->jump_tcb.l_paddr = cpu_to_scr(vtophys (&tp->jump_tcb));
8273: }
8274:
8275: /*
8276: ** Logic unit control block
8277: */
8278: lp = tp->lp[lun];
8279: if (!lp) {
8280: /*
8281: ** Allocate a lcb
8282: */
8283: lp = (lcb_p) m_alloc (sizeof (struct lcb), LCB_ALIGN_SHIFT);
8284: if (!lp) return;
8285:
8286: if (DEBUG_FLAGS & DEBUG_ALLOC) {
8287: PRINT_LUN(np, target, lun);
8288: printf ("new lcb @%p.\n", lp);
8289: }
8290:
8291: /*
8292: ** Initialize it
8293: */
8294: bzero (lp, sizeof (*lp));
8295: lp->jump_lcb.l_cmd =
8296: cpu_to_scr(SCR_JUMP ^ IFFALSE (DATA (lun)));
8297: lp->jump_lcb.l_paddr = tp->jump_lcb.l_paddr;
8298:
8299: lp->call_tag.l_cmd = cpu_to_scr(SCR_CALL);
8300: lp->call_tag.l_paddr =
8301: cpu_to_scr(NCB_SCRIPT_PHYS (np, resel_tag));
8302:
8303: lp->jump_ccb.l_cmd = cpu_to_scr(SCR_JUMP);
8304: lp->jump_ccb.l_paddr =
8305: cpu_to_scr(NCB_SCRIPTH_PHYS (np, aborttag));
8306:
8307: lp->actlink = 1;
8308:
8309: lp->active = 1;
8310:
8311: /*
8312: ** Chain into LUN list
8313: */
8314: tp->jump_lcb.l_paddr = cpu_to_scr(vtophys (&lp->jump_lcb));
8315: tp->lp[lun] = lp;
8316:
8317: ncr_setmaxtags (np, tp, driver_setup.default_tags);
8318: }
8319:
8320: /*
8321: ** Allocate ccbs up to lp->reqccbs.
8322: */
8323:
8324: /*
8325: ** Limit possible number of ccbs.
8326: **
8327: ** If tagged command queueing is enabled,
8328: ** can use more than one ccb.
8329: */
8330: if (np->actccbs >= MAX_START-2) return;
8331: if (lp->actccbs && (lp->actccbs >= lp->reqccbs))
8332: return;
8333:
8334: /*
8335: ** Allocate a ccb
8336: */
8337: cp = (ccb_p) m_alloc (sizeof (struct ccb), CCB_ALIGN_SHIFT);
8338: if (!cp)
8339: return;
8340:
8341: if (DEBUG_FLAGS & DEBUG_ALLOC) {
8342: PRINT_LUN(np, target, lun);
8343: printf ("new ccb @%p.\n", cp);
8344: }
8345:
8346: /*
8347: ** Count it
8348: */
8349: lp->actccbs++;
8350: np->actccbs++;
8351:
8352: /*
8353: ** Initialize it
8354: */
8355: bzero (cp, sizeof (*cp));
8356:
8357: /*
8358: ** Fill in physical addresses
8359: */
8360:
8361: cp->p_ccb = vtophys (cp);
8362:
8363: /*
8364: ** Chain into reselect list
8365: */
8366: cp->jump_ccb.l_cmd = cpu_to_scr(SCR_JUMP);
8367: cp->jump_ccb.l_paddr = lp->jump_ccb.l_paddr;
8368: lp->jump_ccb.l_paddr = cpu_to_scr(CCB_PHYS (cp, jump_ccb));
8369: cp->call_tmp.l_cmd = cpu_to_scr(SCR_CALL);
8370: cp->call_tmp.l_paddr = cpu_to_scr(NCB_SCRIPT_PHYS (np, resel_tmp));
8371:
8372: /*
8373: ** Chain into wakeup list
8374: */
8375: cp->link_ccb = np->ccb->link_ccb;
8376: np->ccb->link_ccb = cp;
8377:
8378: /*
8379: ** Chain into CCB list
8380: */
8381: cp->next_ccb = lp->next_ccb;
8382: lp->next_ccb = cp;
8383: }
8384:
8385: /*==========================================================
8386: **
8387: **
8388: ** Announce the number of ccbs/tags to the scsi driver.
8389: **
8390: **
8391: **==========================================================
8392: */
8393:
8394: static void ncr_opennings (ncb_p np, lcb_p lp, Scsi_Cmnd * cmd)
8395: {
8396: /*
8397: ** want to reduce the number ...
8398: */
8399: if (lp->actlink > lp->reqlink) {
8400:
8401: /*
8402: ** Try to reduce the count.
8403: ** We assume to run at splbio ..
8404: */
8405: u_char diff = lp->actlink - lp->reqlink;
8406:
8407: if (!diff) return;
8408:
8409: if (diff > lp->opennings)
8410: diff = lp->opennings;
8411:
8412: lp->opennings -= diff;
8413:
8414: lp->actlink -= diff;
8415: if (DEBUG_FLAGS & DEBUG_TAGS)
8416: printf ("%s: actlink: diff=%d, new=%d, req=%d\n",
8417: ncr_name(np), diff, lp->actlink, lp->reqlink);
8418: return;
8419: };
8420:
8421: /*
8422: ** want to increase the number ?
8423: */
8424: if (lp->reqlink > lp->actlink) {
8425: u_char diff = lp->reqlink - lp->actlink;
8426:
8427: lp->opennings += diff;
8428:
8429: lp->actlink += diff;
8430: #if 0
8431: wakeup ((caddr_t) xp->sc_link);
8432: #endif
8433: if (DEBUG_FLAGS & DEBUG_TAGS)
8434: printf ("%s: actlink: diff=%d, new=%d, req=%d\n",
8435: ncr_name(np), diff, lp->actlink, lp->reqlink);
8436: };
8437: }
8438:
8439: /*==========================================================
8440: **
8441: **
8442: ** Build Scatter Gather Block
8443: **
8444: **
8445: **==========================================================
8446: **
8447: ** The transfer area may be scattered among
8448: ** several non adjacent physical pages.
8449: **
8450: ** We may use MAX_SCATTER blocks.
8451: **
8452: **----------------------------------------------------------
8453: */
8454:
8455: /*
8456: ** We try to reduce the number of interrupts caused
8457: ** by unexpected phase changes due to disconnects.
8458: ** A typical harddisk may disconnect before ANY block.
8459: ** If we wanted to avoid unexpected phase changes at all
8460: ** we had to use a break point every 512 bytes.
8461: ** Of course the number of scatter/gather blocks is
8462: ** limited.
8463: ** Under Linux, the scatter/gatter blocks are provided by
8464: ** the generic driver. We just have to copy addresses and
8465: ** sizes to the data segment array.
8466: */
8467:
8468: static int ncr_scatter(ccb_p cp, Scsi_Cmnd *cmd)
8469: {
8470: struct scr_tblmove *data;
8471: int segment = 0;
8472: int use_sg = (int) cmd->use_sg;
8473:
8474: #if 0
8475: bzero (cp->phys.data, sizeof (cp->phys.data));
8476: #endif
8477: data = cp->phys.data;
8478: cp->data_len = 0;
8479:
8480: if (!use_sg) {
8481: if (cmd->request_bufflen) {
8482: data = &data[MAX_SCATTER - 1];
8483: data[0].addr = cpu_to_scr(vtophys(cmd->request_buffer));
8484: data[0].size = cpu_to_scr(cmd->request_bufflen);
8485: cp->data_len = cmd->request_bufflen;
8486: segment = 1;
8487: }
8488: }
8489: else if (use_sg <= MAX_SCATTER) {
8490: struct scatterlist *scatter = (struct scatterlist *)cmd->buffer;
8491:
8492: data = &data[MAX_SCATTER - use_sg];
8493: while (segment < use_sg) {
8494: data[segment].addr =
8495: cpu_to_scr(vtophys(scatter[segment].address));
8496: data[segment].size =
8497: cpu_to_scr(scatter[segment].length);
8498: cp->data_len += scatter[segment].length;
8499: ++segment;
8500: }
8501: }
8502: else {
8503: return -1;
8504: }
8505:
8506: return segment;
8507: }
8508:
8509: /*==========================================================
8510: **
8511: **
8512: ** Test the pci bus snoop logic :-(
8513: **
8514: ** Has to be called with interrupts disabled.
8515: **
8516: **
8517: **==========================================================
8518: */
8519:
8520: #ifndef NCR_IOMAPPED
8521: __initfunc(
8522: static int ncr_regtest (struct ncb* np)
8523: )
8524: {
8525: register volatile u_long data;
8526: /*
8527: ** ncr registers may NOT be cached.
8528: ** write 0xffffffff to a read only register area,
8529: ** and try to read it back.
8530: */
8531: data = 0xffffffff;
8532: OUTL_OFF(offsetof(struct ncr_reg, nc_dstat), data);
8533: data = INL_OFF(offsetof(struct ncr_reg, nc_dstat));
8534: #if 1
8535: if (data == 0xffffffff) {
8536: #else
8537: if ((data & 0xe2f0fffd) != 0x02000080) {
8538: #endif
8539: printf ("CACHE TEST FAILED: reg dstat-sstat2 readback %x.\n",
8540: (unsigned) data);
8541: return (0x10);
8542: };
8543: return (0);
8544: }
8545: #endif
8546:
8547: __initfunc(
8548: static int ncr_snooptest (struct ncb* np)
8549: )
8550: {
8551: u_long ncr_rd, ncr_wr, ncr_bk, host_rd, host_wr, pc, err=0;
8552: int i;
8553: #ifndef NCR_IOMAPPED
8554: if (np->reg) {
8555: err |= ncr_regtest (np);
8556: if (err) return (err);
8557: }
8558: #endif
8559: /*
8560: ** init
8561: */
8562: pc = NCB_SCRIPTH_PHYS (np, snooptest);
8563: host_wr = 1;
8564: ncr_wr = 2;
8565: /*
8566: ** Set memory and register.
8567: */
8568: np->ncr_cache = cpu_to_scr(host_wr);
8569: OUTL (nc_temp, ncr_wr);
8570: /*
8571: ** Start script (exchange values)
8572: */
8573: OUTL (nc_dsp, pc);
8574: /*
8575: ** Wait 'til done (with timeout)
8576: */
8577: for (i=0; i<NCR_SNOOP_TIMEOUT; i++)
8578: if (INB(nc_istat) & (INTF|SIP|DIP))
8579: break;
8580: /*
8581: ** Save termination position.
8582: */
8583: pc = INL (nc_dsp);
8584: /*
8585: ** Read memory and register.
8586: */
8587: host_rd = scr_to_cpu(np->ncr_cache);
8588: ncr_rd = INL (nc_scratcha);
8589: ncr_bk = INL (nc_temp);
8590: /*
8591: ** Reset ncr chip
8592: */
8593: OUTB (nc_istat, SRST);
8594: DELAY (1000);
8595: OUTB (nc_istat, 0 );
8596: /*
8597: ** check for timeout
8598: */
8599: if (i>=NCR_SNOOP_TIMEOUT) {
8600: printf ("CACHE TEST FAILED: timeout.\n");
8601: return (0x20);
8602: };
8603: /*
8604: ** Check termination position.
8605: */
8606: if (pc != NCB_SCRIPTH_PHYS (np, snoopend)+8) {
8607: printf ("CACHE TEST FAILED: script execution failed.\n");
8608: printf ("start=%08lx, pc=%08lx, end=%08lx\n",
8609: (u_long) NCB_SCRIPTH_PHYS (np, snooptest), pc,
8610: (u_long) NCB_SCRIPTH_PHYS (np, snoopend) +8);
8611: return (0x40);
8612: };
8613: /*
8614: ** Show results.
8615: */
8616: if (host_wr != ncr_rd) {
8617: printf ("CACHE TEST FAILED: host wrote %d, ncr read %d.\n",
8618: (int) host_wr, (int) ncr_rd);
8619: err |= 1;
8620: };
8621: if (host_rd != ncr_wr) {
8622: printf ("CACHE TEST FAILED: ncr wrote %d, host read %d.\n",
8623: (int) ncr_wr, (int) host_rd);
8624: err |= 2;
8625: };
8626: if (ncr_bk != ncr_wr) {
8627: printf ("CACHE TEST FAILED: ncr wrote %d, read back %d.\n",
8628: (int) ncr_wr, (int) ncr_bk);
8629: err |= 4;
8630: };
8631: return (err);
8632: }
8633:
8634: /*==========================================================
8635: **
8636: **
8637: ** Profiling the drivers and targets performance.
8638: **
8639: **
8640: **==========================================================
8641: */
8642:
8643: #ifdef SCSI_NCR_PROFILE_SUPPORT
8644:
8645: /*
8646: ** Compute the difference in jiffies ticks.
8647: */
8648:
8649: #define ncr_delta(from, to) \
8650: ( ((to) && (from))? (to) - (from) : -1 )
8651:
8652: #define PROFILE cp->phys.header.stamp
8653: static void ncb_profile (ncb_p np, ccb_p cp)
8654: {
8655: int co, st, en, di, se, post,work,disc;
8656: u_long diff;
8657:
8658: PROFILE.end = jiffies;
8659:
8660: st = ncr_delta (PROFILE.start,PROFILE.status);
8661: if (st<0) return; /* status not reached */
8662:
8663: co = ncr_delta (PROFILE.start,PROFILE.command);
8664: if (co<0) return; /* command not executed */
8665:
8666: en = ncr_delta (PROFILE.start,PROFILE.end),
8667: di = ncr_delta (PROFILE.start,PROFILE.disconnect),
8668: se = ncr_delta (PROFILE.start,PROFILE.select);
8669: post = en - st;
8670:
8671: /*
8672: ** @PROFILE@ Disconnect time invalid if multiple disconnects
8673: */
8674:
8675: if (di>=0) disc = se-di; else disc = 0;
8676:
8677: work = (st - co) - disc;
8678:
8679: diff = (np->disc_phys - np->disc_ref) & 0xff;
8680: np->disc_ref += diff;
8681:
8682: np->profile.num_trans += 1;
8683: if (cp->cmd) {
8684: np->profile.num_kbytes += (cp->cmd->request_bufflen >> 10);
8685: np->profile.rest_bytes += (cp->cmd->request_bufflen & (0x400-1));
8686: if (np->profile.rest_bytes >= 0x400) {
8687: ++np->profile.num_kbytes;
8688: np->profile.rest_bytes -= 0x400;
8689: }
8690: }
8691: np->profile.num_disc += diff;
8692: np->profile.ms_setup += co;
8693: np->profile.ms_data += work;
8694: np->profile.ms_disc += disc;
8695: np->profile.ms_post += post;
8696: }
8697: #undef PROFILE
8698:
8699: #endif /* SCSI_NCR_PROFILE_SUPPORT */
8700:
8701: /*==========================================================
8702: **
8703: **
8704: ** Device lookup.
8705: **
8706: ** @GENSCSI@ should be integrated to scsiconf.c
8707: **
8708: **
8709: **==========================================================
8710: */
8711:
8712: struct table_entry {
8713: char * manufacturer;
8714: char * model;
8715: char * version;
8716: u_long info;
8717: };
8718:
8719: static struct table_entry device_tab[] =
8720: {
8721: #ifdef NCR_GETCC_WITHMSG
8722: {"", "", "", QUIRK_NOMSG},
8723: {"SONY", "SDT-5000", "3.17", QUIRK_NOMSG},
8724: {"WangDAT", "Model 2600", "01.7", QUIRK_NOMSG},
8725: {"WangDAT", "Model 3200", "02.2", QUIRK_NOMSG},
8726: {"WangDAT", "Model 1300", "02.4", QUIRK_NOMSG},
8727: #endif
8728: {"", "", "", 0} /* catch all: must be last entry. */
8729: };
8730:
8731: static u_long ncr_lookup(char * id)
8732: {
8733: struct table_entry * p = device_tab;
8734: char *d, *r, c;
8735:
8736: for (;;p++) {
8737:
8738: d = id+8;
8739: r = p->manufacturer;
8740: while ((c=*r++)) if (c!=*d++) break;
8741: if (c) continue;
8742:
8743: d = id+16;
8744: r = p->model;
8745: while ((c=*r++)) if (c!=*d++) break;
8746: if (c) continue;
8747:
8748: d = id+32;
8749: r = p->version;
8750: while ((c=*r++)) if (c!=*d++) break;
8751: if (c) continue;
8752:
8753: return (p->info);
8754: }
8755: }
8756:
8757: /*==========================================================
8758: **
8759: ** Determine the ncr's clock frequency.
8760: ** This is essential for the negotiation
8761: ** of the synchronous transfer rate.
8762: **
8763: **==========================================================
8764: **
8765: ** Note: we have to return the correct value.
8766: ** THERE IS NO SAVE DEFAULT VALUE.
8767: **
8768: ** Most NCR/SYMBIOS boards are delivered with a 40 Mhz clock.
8769: ** 53C860 and 53C875 rev. 1 support fast20 transfers but
8770: ** do not have a clock doubler and so are provided with a
8771: ** 80 MHz clock. All other fast20 boards incorporate a doubler
8772: ** and so should be delivered with a 40 MHz clock.
8773: ** The future fast40 chips (895/895) use a 40 Mhz base clock
8774: ** and provide a clock quadrupler (160 Mhz). The code below
8775: ** tries to deal as cleverly as possible with all this stuff.
8776: **
8777: **----------------------------------------------------------
8778: */
8779:
8780: /*
8781: * Select NCR SCSI clock frequency
8782: */
8783: static void ncr_selectclock(ncb_p np, u_char scntl3)
8784: {
8785: if (np->multiplier < 2) {
8786: OUTB(nc_scntl3, scntl3);
8787: return;
8788: }
8789:
8790: if (bootverbose >= 2)
8791: printf ("%s: enabling clock multiplier\n", ncr_name(np));
8792:
8793: OUTB(nc_stest1, DBLEN); /* Enable clock multiplier */
8794: if (np->multiplier > 2) { /* Poll bit 5 of stest4 for quadrupler */
8795: int i = 20;
8796: while (!(INB(nc_stest4) & LCKFRQ) && --i > 0)
8797: DELAY(20);
8798: if (!i)
8799: printf("%s: the chip cannot lock the frequency\n", ncr_name(np));
8800: } else /* Wait 20 micro-seconds for doubler */
8801: DELAY(20);
8802: OUTB(nc_stest3, HSC); /* Halt the scsi clock */
8803: OUTB(nc_scntl3, scntl3);
8804: OUTB(nc_stest1, (DBLEN|DBLSEL));/* Select clock multiplier */
8805: OUTB(nc_stest3, 0x00|TE); /* Restart scsi clock */
8806: }
8807:
8808:
8809: /*
8810: * calculate NCR SCSI clock frequency (in KHz)
8811: */
8812: __initfunc(
8813: static unsigned ncrgetfreq (ncb_p np, int gen)
8814: )
8815: {
8816: unsigned ms = 0;
8817:
8818: /*
8819: * Measure GEN timer delay in order
8820: * to calculate SCSI clock frequency
8821: *
8822: * This code will never execute too
8823: * many loop iterations (if DELAY is
8824: * reasonably correct). It could get
8825: * too low a delay (too high a freq.)
8826: * if the CPU is slow executing the
8827: * loop for some reason (an NMI, for
8828: * example). For this reason we will
8829: * if multiple measurements are to be
8830: * performed trust the higher delay
8831: * (lower frequency returned).
8832: */
8833: OUTB (nc_stest1, 0); /* make sure clock doubler is OFF */
8834: OUTW (nc_sien , 0); /* mask all scsi interrupts */
8835: (void) INW (nc_sist); /* clear pending scsi interrupt */
8836: OUTB (nc_dien , 0); /* mask all dma interrupts */
8837: (void) INW (nc_sist); /* another one, just to be sure :) */
8838: OUTB (nc_scntl3, 4); /* set pre-scaler to divide by 3 */
8839: OUTB (nc_stime1, 0); /* disable general purpose timer */
8840: OUTB (nc_stime1, gen); /* set to nominal delay of 1<<gen * 125us */
8841: while (!(INW(nc_sist) & GEN) && ms++ < 100000)
8842: DELAY(1000); /* count ms */
8843: OUTB (nc_stime1, 0); /* disable general purpose timer */
8844: /*
8845: * set prescaler to divide by whatever 0 means
8846: * 0 ought to choose divide by 2, but appears
8847: * to set divide by 3.5 mode in my 53c810 ...
8848: */
8849: OUTB (nc_scntl3, 0);
8850:
8851: if (bootverbose >= 2)
8852: printf ("%s: Delay (GEN=%d): %u msec\n", ncr_name(np), gen, ms);
8853: /*
8854: * adjust for prescaler, and convert into KHz
8855: */
8856: return ms ? ((1 << gen) * 4340) / ms : 0;
8857: }
8858:
8859: /*
8860: * Get/probe NCR SCSI clock frequency
8861: */
8862: __initfunc(
8863: static void ncr_getclock (ncb_p np, int mult)
8864: )
8865: {
8866: unsigned char scntl3 = INB(nc_scntl3);
8867: unsigned char stest1 = INB(nc_stest1);
8868: unsigned f1;
8869:
8870: np->multiplier = 1;
8871: f1 = 40000;
8872:
8873: /*
8874: ** True with 875 or 895 with clock multiplier selected
8875: */
8876: if (mult > 1 && (stest1 & (DBLEN+DBLSEL)) == DBLEN+DBLSEL) {
8877: if (bootverbose >= 2)
8878: printf ("%s: clock multiplier found\n", ncr_name(np));
8879: np->multiplier = mult;
8880: }
8881:
8882: /*
8883: ** If multiplier not found or scntl3 not 7,5,3,
8884: ** reset chip and get frequency from general purpose timer.
8885: ** Otherwise trust scntl3 BIOS setting.
8886: */
8887: if (np->multiplier != mult || (scntl3 & 7) < 3 || !(scntl3 & 1)) {
8888: unsigned f2;
8889:
8890: OUTB(nc_istat, SRST); DELAY(5); OUTB(nc_istat, 0);
8891:
8892: (void) ncrgetfreq (np, 11); /* throw away first result */
8893: f1 = ncrgetfreq (np, 11);
8894: f2 = ncrgetfreq (np, 11);
8895:
8896: if (bootverbose)
8897: printf ("%s: NCR clock is %uKHz, %uKHz\n", ncr_name(np), f1, f2);
8898:
8899: if (f1 > f2) f1 = f2; /* trust lower result */
8900:
8901: if (f1 < 45000) f1 = 40000;
8902: else if (f1 < 55000) f1 = 50000;
8903: else f1 = 80000;
8904:
8905: if (f1 < 80000 && mult > 1) {
8906: if (bootverbose >= 2)
8907: printf ("%s: clock multiplier assumed\n", ncr_name(np));
8908: np->multiplier = mult;
8909: }
8910: } else {
8911: if ((scntl3 & 7) == 3) f1 = 40000;
8912: else if ((scntl3 & 7) == 5) f1 = 80000;
8913: else f1 = 160000;
8914:
8915: f1 /= np->multiplier;
8916: }
8917:
8918: /*
8919: ** Compute controller synchronous parameters.
8920: */
8921: f1 *= np->multiplier;
8922: np->clock_khz = f1;
8923: }
8924:
8925: /*===================== LINUX ENTRY POINTS SECTION ==========================*/
8926:
8927: #ifndef uchar
8928: #define uchar unsigned char
8929: #endif
8930:
8931: #ifndef ushort
8932: #define ushort unsigned short
8933: #endif
8934:
8935: #ifndef ulong
8936: #define ulong unsigned long
8937: #endif
8938:
8939: /* ---------------------------------------------------------------------
8940: **
8941: ** Driver setup from the boot command line
8942: **
8943: ** ---------------------------------------------------------------------
8944: */
8945:
8946: __initfunc(
8947: void ncr53c8xx_setup(char *str, int *ints)
8948: )
8949: {
8950: #ifdef SCSI_NCR_BOOT_COMMAND_LINE_SUPPORT
8951: char *cur = str;
8952: char *pc, *pv;
8953: int val;
8954: int base;
8955: int c;
8956:
8957: while (cur != NULL && (pc = strchr(cur, ':')) != NULL) {
8958: val = 0;
8959: pv = pc;
8960: c = *++pv;
8961: if (c == 'n')
8962: val = 0;
8963: else if (c == 'y')
8964: val = 1;
8965: else {
8966: base = 0;
8967: #if 0
8968: if (c == '0') {
8969: c = *pv++;
8970: base = 8;
8971: }
8972: if (c == 'x') {
8973: ++pv;
8974: base = 16;
8975: }
8976: else if (c >= '0' && c <= '9')
8977: base = 10;
8978: else
8979: break;
8980: #endif
8981: val = (int) simple_strtoul(pv, NULL, base);
8982: }
8983:
8984: if (!strncmp(cur, "mpar:", 5))
8985: driver_setup.master_parity = val;
8986: else if (!strncmp(cur, "spar:", 5))
8987: driver_setup.scsi_parity = val;
8988: else if (!strncmp(cur, "disc:", 5))
8989: driver_setup.disconnection = val;
8990: else if (!strncmp(cur, "specf:", 6))
8991: driver_setup.special_features = val;
8992: else if (!strncmp(cur, "ultra:", 6))
8993: driver_setup.ultra_scsi = val;
8994: else if (!strncmp(cur, "fsn:", 4))
8995: driver_setup.force_sync_nego = val;
8996: else if (!strncmp(cur, "revprob:", 8))
8997: driver_setup.reverse_probe = val;
8998: else if (!strncmp(cur, "tags:", 5)) {
8999: if (val > SCSI_NCR_MAX_TAGS)
9000: val = SCSI_NCR_MAX_TAGS;
9001: driver_setup.default_tags = val;
9002: }
9003: else if (!strncmp(cur, "sync:", 5))
9004: driver_setup.default_sync = val;
9005: else if (!strncmp(cur, "verb:", 5))
9006: driver_setup.verbose = val;
9007: else if (!strncmp(cur, "debug:", 6))
9008: driver_setup.debug = val;
9009: else if (!strncmp(cur, "burst:", 6))
9010: driver_setup.burst_max = val;
9011: else if (!strncmp(cur, "led:", 4))
9012: driver_setup.led_pin = val;
9013: else if (!strncmp(cur, "wide:", 5))
9014: driver_setup.max_wide = val? 1:0;
9015: else if (!strncmp(cur, "settle:", 7))
9016: driver_setup.settle_delay= val;
9017: else if (!strncmp(cur, "diff:", 5))
9018: driver_setup.diff_support= val;
9019: else if (!strncmp(cur, "irqm:", 5))
9020: driver_setup.irqm = val;
9021: else if (!strncmp(cur, "pcifix:", 7))
9022: driver_setup.pci_fix_up = val;
9023: else if (!strncmp(cur, "buschk:", 7))
9024: driver_setup.bus_check = val;
9025: #ifdef SCSI_NCR_NVRAM_SUPPORT
9026: else if (!strncmp(cur, "nvram:", 6))
9027: driver_setup.use_nvram = val;
9028: #endif
9029:
9030: else if (!strncmp(cur, "safe:", 5) && val)
9031: memcpy(&driver_setup, &driver_safe_setup, sizeof(driver_setup));
9032: else
9033: printf("ncr53c8xx_setup: unexpected boot option '%.*s' ignored\n", (int)(pc-cur+1), cur);
9034:
9035: #ifdef MODULE
9036: if ((cur = strchr(cur, ' ')) != NULL)
9037: #else
9038: if ((cur = strchr(cur, ',')) != NULL)
9039: #endif
9040: ++cur;
9041: }
9042: #endif /* SCSI_NCR_BOOT_COMMAND_LINE_SUPPORT */
9043: }
9044:
9045: static int ncr53c8xx_pci_init(Scsi_Host_Template *tpnt,
9046: uchar bus, uchar device_fn, ncr_device *device);
9047:
9048: /*
9049: ** Linux entry point for NCR53C8XX devices detection routine.
9050: **
9051: ** Called by the middle-level scsi drivers at initialization time,
9052: ** or at module installation.
9053: **
9054: ** Read the PCI configuration and try to attach each
9055: ** detected NCR board.
9056: **
9057: ** If NVRAM is present, try to attach boards according to
9058: ** the used defined boot order.
9059: **
9060: ** Returns the number of boards successfully attached.
9061: */
9062:
9063: __initfunc(
9064: static void ncr_print_driver_setup(void)
9065: )
9066: {
9067: #define YesNo(y) y ? 'y' : 'n'
9068: printk("ncr53c8xx: setup=disc:%c,specf:%d,ultra:%c,tags:%d,sync:%d,burst:%d,wide:%c,diff:%d\n",
9069: YesNo(driver_setup.disconnection),
9070: driver_setup.special_features,
9071: YesNo(driver_setup.ultra_scsi),
9072: driver_setup.default_tags,
9073: driver_setup.default_sync,
9074: driver_setup.burst_max,
9075: YesNo(driver_setup.max_wide),
9076: driver_setup.diff_support);
9077: printk("ncr53c8xx: setup=mpar:%c,spar:%c,fsn=%c,verb:%d,debug:0x%x,led:%c,settle:%d,irqm:%d\n",
9078: YesNo(driver_setup.master_parity),
9079: YesNo(driver_setup.scsi_parity),
9080: YesNo(driver_setup.force_sync_nego),
9081: driver_setup.verbose,
9082: driver_setup.debug,
9083: YesNo(driver_setup.led_pin),
9084: driver_setup.settle_delay,
9085: driver_setup.irqm);
9086: #undef YesNo
9087: }
9088:
9089: /*
9090: ** NCR53C8XX devices description table and chip ids list.
9091: */
9092:
9093: static ncr_chip ncr_chip_table[] __initdata = SCSI_NCR_CHIP_TABLE;
9094: static ushort ncr_chip_ids[] __initdata = SCSI_NCR_CHIP_IDS;
9095:
9096: #ifdef SCSI_NCR_NVRAM_SUPPORT
9097: __initfunc(
9098: static int
9099: ncr_attach_using_nvram(Scsi_Host_Template *tpnt, int nvram_index, int count, ncr_device device[])
9100: )
9101: {
9102: int i, j;
9103: int attach_count = 0;
9104: ncr_nvram *nvram;
9105: ncr_device *devp;
9106:
9107: if (!nvram_index)
9108: return 0;
9109:
9110: /* find first Symbios NVRAM if there is one as we need to check it for host boot order */
9111: for (i = 0, nvram_index = -1; i < count; i++) {
9112: devp = &device[i];
9113: nvram = devp->nvram;
9114: if (!nvram)
9115: continue;
9116: if (nvram->type == SCSI_NCR_SYMBIOS_NVRAM) {
9117: if (nvram_index == -1)
9118: nvram_index = i;
9119: #ifdef SCSI_NCR_DEBUG_NVRAM
9120: printf("ncr53c8xx: NVRAM: Symbios format Boot Block, 53c%s, PCI bus %d, device %d, function %d\n",
9121: devp->chip.name, devp->slot.bus,
9122: (int) (devp->slot.device_fn & 0xf8) >> 3,
9123: (int) devp->slot.device_fn & 7);
9124: for (j = 0 ; j < 4 ; j++) {
9125: Symbios_host *h = &nvram->data.Symbios.host[j];
9126: printf("ncr53c8xx: BOOT[%d] device_id=%04x vendor_id=%04x device_fn=%02x io_port=%04x %s\n",
9127: j, h->device_id, h->vendor_id,
9128: h->device_fn, h->io_port,
9129: (h->flags & SYMBIOS_INIT_SCAN_AT_BOOT) ? "SCAN AT BOOT" : "");
9130: }
9131: }
9132: else if (nvram->type == SCSI_NCR_TEKRAM_NVRAM) {
9133: /* display Tekram nvram data */
9134: printf("ncr53c8xx: NVRAM: Tekram format data, 53c%s, PCI bus %d, device %d, function %d\n",
9135: devp->chip.name, devp->slot.bus,
9136: (int) (devp->slot.device_fn & 0xf8) >> 3,
9137: (int) devp->slot.device_fn & 7);
9138: #endif
9139: }
9140: }
9141:
9142: if (nvram_index >= 0 && nvram_index < count)
9143: nvram = device[nvram_index].nvram;
9144: else
9145: nvram = 0;
9146:
9147: if (!nvram)
9148: goto out;
9149:
9150: /*
9151: ** check devices in the boot record against devices detected.
9152: ** attach devices if we find a match. boot table records that
9153: ** do not match any detected devices will be ignored.
9154: ** devices that do not match any boot table will not be attached
9155: ** here but will attempt to be attached during the device table
9156: ** rescan.
9157: */
9158: for (i = 0; i < 4; i++) {
9159: Symbios_host *h = &nvram->data.Symbios.host[i];
9160: for (j = 0 ; j < count ; j++) {
9161: devp = &device[j];
9162: if (h->device_fn == devp->slot.device_fn &&
9163: #if 0 /* bus number location in nvram ? */
9164: h->bus == devp->slot.bus &&
9165: #endif
9166: h->device_id == devp->chip.device_id)
9167: break;
9168: }
9169: if (j < count && !devp->attach_done) {
9170: if (!ncr_attach (tpnt, attach_count, devp))
9171: attach_count++;
9172: devp->attach_done = 1;
9173: }
9174: }
9175:
9176: out:
9177: return attach_count;
9178: }
9179: #endif /* SCSI_NCR_NVRAM_SUPPORT */
9180:
9181: __initfunc(
9182: int ncr53c8xx_detect(Scsi_Host_Template *tpnt)
9183: )
9184: {
9185: int i, j;
9186: int chips;
9187: int count = 0;
9188: uchar bus, device_fn;
9189: short index;
9190: int attach_count = 0;
9191: ncr_device device[8];
9192: #ifdef SCSI_NCR_NVRAM_SUPPORT
9193: ncr_nvram nvram[4];
9194: int k, nvrams;
9195: #endif
9196: int hosts;
9197:
9198: #ifdef SCSI_NCR_NVRAM_SUPPORT
9199: int nvram_index = 0;
9200: #endif
9201: if (initverbose >= 2)
9202: ncr_print_driver_setup();
9203:
9204: #ifdef SCSI_NCR_DEBUG_INFO_SUPPORT
9205: ncr_debug = driver_setup.debug;
9206: #endif
9207:
9208: #if LINUX_VERSION_CODE >= LinuxVersionCode(1,3,0)
9209: tpnt->proc_dir = &proc_scsi_ncr53c8xx;
9210: # ifdef SCSI_NCR_PROC_INFO_SUPPORT
9211: tpnt->proc_info = ncr53c8xx_proc_info;
9212: # endif
9213: #endif
9214:
9215: #if defined(SCSI_NCR_BOOT_COMMAND_LINE_SUPPORT) && defined(MODULE)
9216: if (ncr53c8xx)
9217: ncr53c8xx_setup(ncr53c8xx, (int *) 0);
9218: #endif
9219:
9220: /*
9221: ** Detect all 53c8xx hosts and then attach them.
9222: **
9223: ** If we are using NVRAM, once all hosts are detected, we need to check
9224: ** any NVRAM for boot order in case detect and boot order differ and
9225: ** attach them using the order in the NVRAM.
9226: **
9227: ** If no NVRAM is found or data appears invalid attach boards in the
9228: ** the order they are detected.
9229: */
9230:
9231: if (!pcibios_present())
9232: return 0;
9233:
9234: chips = sizeof(ncr_chip_ids) / sizeof(ncr_chip_ids[0]);
9235: hosts = sizeof(device) / sizeof(device[0]);
9236: #ifdef SCSI_NCR_NVRAM_SUPPORT
9237: k = 0;
9238: if (driver_setup.use_nvram & 0x1)
9239: nvrams = sizeof(nvram) / sizeof(nvram[0]);
9240: else
9241: nvrams = 0;
9242: #endif
9243:
9244: for (j = 0; j < chips ; ++j) {
9245: i = driver_setup.reverse_probe ? chips-1 - j : j;
9246: for (index = 0; ; index++) {
9247: char *msg = "";
9248: if ((pcibios_find_device(PCI_VENDOR_ID_NCR, ncr_chip_ids[i],
9249: index, &bus, &device_fn)) ||
9250: (count == hosts))
9251: break;
9252: #ifdef SCSI_NCR_NVRAM_SUPPORT
9253: device[count].nvram = k < nvrams ? &nvram[k] : 0;
9254: #else
9255: device[count].nvram = 0;
9256: #endif
9257: if (ncr53c8xx_pci_init(tpnt, bus, device_fn, &device[count])) {
9258: device[count].nvram = 0;
9259: continue;
9260: }
9261: #ifdef SCSI_NCR_NVRAM_SUPPORT
9262: if (device[count].nvram) {
9263: ++k;
9264: nvram_index |= device[count].nvram->type;
9265: switch (device[count].nvram->type) {
9266: case SCSI_NCR_TEKRAM_NVRAM:
9267: msg = "with Tekram NVRAM";
9268: break;
9269: case SCSI_NCR_SYMBIOS_NVRAM:
9270: msg = "with Symbios NVRAM";
9271: break;
9272: default:
9273: msg = "";
9274: device[count].nvram = 0;
9275: --k;
9276: }
9277: }
9278: #endif
9279: printf(KERN_INFO "ncr53c8xx: 53c%s detected %s\n",
9280: device[count].chip.name, msg);
9281: ++count;
9282: }
9283: }
9284: #ifdef SCSI_NCR_NVRAM_SUPPORT
9285: attach_count = ncr_attach_using_nvram(tpnt, nvram_index, count, device);
9286: #endif
9287: /*
9288: ** rescan device list to make sure all boards attached.
9289: ** devices without boot records will not be attached yet
9290: ** so try to attach them here.
9291: */
9292: for (i= 0; i < count; i++) {
9293: if (!device[i].attach_done &&
9294: !ncr_attach (tpnt, attach_count, &device[i])) {
9295: attach_count++;
9296: }
9297: }
9298:
9299: return attach_count;
9300: }
9301:
9302: /*
9303: ** Read and check the PCI configuration for any detected NCR
9304: ** boards and save data for attaching after all boards have
9305: ** been detected.
9306: */
9307:
9308: __initfunc(
9309: static int ncr53c8xx_pci_init(Scsi_Host_Template *tpnt,
9310: uchar bus, uchar device_fn, ncr_device *device)
9311: )
9312: {
9313: ushort vendor_id, device_id, command;
9314: uchar cache_line_size, latency_timer;
9315: uchar irq, revision;
9316: #if LINUX_VERSION_CODE >= LinuxVersionCode(1,3,0)
9317: uint base, base_2, io_port;
9318: #else
9319: ulong base, base_2;
9320: #endif
9321: int i;
9322:
9323: #ifdef SCSI_NCR_NVRAM_SUPPORT
9324: ncr_nvram *nvram = device->nvram;
9325: #endif
9326: ncr_chip *chip;
9327:
9328: printk(KERN_INFO "ncr53c8xx: at PCI bus %d, device %d, function %d\n",
9329: bus, (int) (device_fn & 0xf8) >> 3, (int) device_fn & 7);
9330: /*
9331: * Read info from the PCI config space.
9332: * pcibios_read_config_xxx() functions are assumed to be used for
9333: * successfully detected PCI devices.
9334: * Expecting error conditions from them is just paranoia,
9335: * thus void cast.
9336: */
9337: (void) pcibios_read_config_word(bus, device_fn,
9338: PCI_VENDOR_ID, &vendor_id);
9339: (void) pcibios_read_config_word(bus, device_fn,
9340: PCI_DEVICE_ID, &device_id);
9341: (void) pcibios_read_config_word(bus, device_fn,
9342: PCI_COMMAND, &command);
9343: (void) pcibios_read_config_dword(bus, device_fn,
9344: PCI_BASE_ADDRESS_0, &io_port);
9345: (void) pcibios_read_config_dword(bus, device_fn,
9346: PCI_BASE_ADDRESS_1, &base);
9347: (void) pcibios_read_config_dword(bus, device_fn,
9348: PCI_BASE_ADDRESS_2, &base_2);
9349: (void) pcibios_read_config_byte(bus, device_fn,
9350: PCI_CLASS_REVISION,&revision);
9351: (void) pcibios_read_config_byte(bus, device_fn,
9352: PCI_INTERRUPT_LINE, &irq);
9353: (void) pcibios_read_config_byte(bus, device_fn,
9354: PCI_CACHE_LINE_SIZE, &cache_line_size);
9355: (void) pcibios_read_config_byte(bus, device_fn,
9356: PCI_LATENCY_TIMER, &latency_timer);
9357:
9358: /*
9359: * Check if the chip is supported
9360: */
9361: chip = 0;
9362: for (i = 0; i < sizeof(ncr_chip_table)/sizeof(ncr_chip_table[0]); i++) {
9363: if (device_id != ncr_chip_table[i].device_id)
9364: continue;
9365: if (revision > ncr_chip_table[i].revision_id)
9366: continue;
9367: chip = &device->chip;
9368: memcpy(chip, &ncr_chip_table[i], sizeof(*chip));
9369: chip->revision_id = revision;
9370: break;
9371: }
9372: if (!chip) {
9373: printk("ncr53c8xx: not initializing, device not supported\n");
9374: return -1;
9375: }
9376:
9377: #ifdef __powerpc__
9378: /*
9379: * Severall fix-up for power/pc.
9380: * Should not be performed by the driver.
9381: */
9382: if ((command &
9383: (PCI_COMMAND_MASTER|PCI_COMMAND_IO|PCI_COMMAND_MEMORY)) !=
9384: (PCI_COMMAND_MASTER|PCI_COMMAND_IO|PCI_COMMAND_MEMORY)) {
9385: printk("ncr53c8xx : setting PCI master/io/command bit\n");
9386: command |= PCI_COMMAND_MASTER|PCI_COMMAND_IO|PCI_COMMAND_MEMORY;
9387: pcibios_write_config_word(bus, device_fn, PCI_COMMAND, command);
9388: }
9389: if (io_port >= 0x10000000) {
9390: io_port = (io_port & 0x00FFFFFF) | 0x01000000;
9391: pcibios_write_config_dword(bus, device_fn, PCI_BASE_ADDRESS_0, io_port);
9392: }
9393: if (base >= 0x10000000) {
9394: base = (base & 0x00FFFFFF) | 0x01000000;
9395: pcibios_write_config_dword(bus, device_fn, PCI_BASE_ADDRESS_1, base);
9396: }
9397: #endif
9398:
9399: /*
9400: * Check availability of IO space, memory space and master capability.
9401: */
9402: if (command & PCI_COMMAND_IO) {
9403: if ((io_port & 3) != 1) {
9404: printk("ncr53c8xx: disabling I/O mapping since base address 0 (0x%x)\n"
9405: " bits 0..1 indicate a non-IO mapping\n", (int) io_port);
9406: io_port = 0;
9407: }
9408: else
9409: io_port &= PCI_BASE_ADDRESS_IO_MASK;
9410: }
9411: else
9412: io_port = 0;
9413:
9414: if (command & PCI_COMMAND_MEMORY) {
9415: if ((base & PCI_BASE_ADDRESS_SPACE) != PCI_BASE_ADDRESS_SPACE_MEMORY) {
9416: printk("ncr53c8xx: disabling memory mapping since base address 1\n"
9417: " contains a non-memory mapping\n");
9418: base = 0;
9419: }
9420: else
9421: base &= PCI_BASE_ADDRESS_MEM_MASK;
9422: }
9423: else
9424: base = 0;
9425:
9426: if (!io_port && !base) {
9427: printk("ncr53c8xx: not initializing, both I/O and memory mappings disabled\n");
9428: return -1;
9429: }
9430:
9431: base_2 &= PCI_BASE_ADDRESS_MEM_MASK;
9432:
9433: if (io_port && check_region (io_port, 128)) {
9434: printk("ncr53c8xx: IO region 0x%x to 0x%x is in use\n",
9435: (int) io_port, (int) (io_port + 127));
9436: return -1;
9437: }
9438:
9439: if (!(command & PCI_COMMAND_MASTER)) {
9440: printk("ncr53c8xx: not initializing, BUS MASTERING was disabled\n");
9441: return -1;
9442: }
9443:
9444: /*
9445: * Fix some features according to driver setup.
9446: */
9447: if (!(driver_setup.special_features & 1))
9448: chip->features &= ~FE_SPECIAL_SET;
9449: else {
9450: if (driver_setup.special_features & 2)
9451: chip->features &= ~FE_WRIE;
9452: }
9453: if (driver_setup.ultra_scsi < 2 && (chip->features & FE_ULTRA2)) {
9454: chip->features |= FE_ULTRA;
9455: chip->features &= ~FE_ULTRA2;
9456: }
9457: if (driver_setup.ultra_scsi < 1)
9458: chip->features &= ~FE_ULTRA;
9459: if (!driver_setup.max_wide)
9460: chip->features &= ~FE_WIDE;
9461:
9462:
9463: #ifdef SCSI_NCR_PCI_FIX_UP_SUPPORT
9464:
9465: /*
9466: * Try to fix up PCI config according to wished features.
9467: */
9468: #if defined(__i386) && !defined(MODULE)
9469: if ((driver_setup.pci_fix_up & 1) &&
9470: (chip->features & FE_CLSE) && cache_line_size == 0) {
9471: #if LINUX_VERSION_CODE < LinuxVersionCode(2,1,75)
9472: extern char x86;
9473: switch(x86) {
9474: #else
9475: switch(boot_cpu_data.x86) {
9476: #endif
9477: case 4: cache_line_size = 4; break;
9478: case 5: cache_line_size = 8; break;
9479: }
9480: if (cache_line_size)
9481: (void) pcibios_write_config_byte(bus, device_fn,
9482: PCI_CACHE_LINE_SIZE, cache_line_size);
9483: if (initverbose)
9484: printk("ncr53c8xx: setting PCI_CACHE_LINE_SIZE to %d (fix-up).\n", cache_line_size);
9485: }
9486:
9487: if ((driver_setup.pci_fix_up & 2) && cache_line_size &&
9488: (chip->features & FE_WRIE) && !(command & PCI_COMMAND_INVALIDATE)) {
9489: command |= PCI_COMMAND_INVALIDATE;
9490: (void) pcibios_write_config_word(bus, device_fn,
9491: PCI_COMMAND, command);
9492: if (initverbose)
9493: printk("ncr53c8xx: setting PCI_COMMAND_INVALIDATE bit (fix-up).\n");
9494: }
9495: #endif
9496: /*
9497: * Fix up for old chips that support READ LINE but not CACHE LINE SIZE.
9498: * - If CACHE LINE SIZE is unknown, set burst max to 32 bytes = 8 dwords
9499: * and donnot enable READ LINE.
9500: * - Otherwise set it to the CACHE LINE SIZE (power of 2 assumed).
9501: */
9502:
9503: if (!(chip->features & FE_CLSE)) {
9504: int burst_max = chip->burst_max;
9505: if (cache_line_size == 0) {
9506: chip->features &= ~FE_ERL;
9507: if (burst_max > 3)
9508: burst_max = 3;
9509: }
9510: else {
9511: while (cache_line_size < (1 << burst_max))
9512: --burst_max;
9513: }
9514: chip->burst_max = burst_max;
9515: }
9516:
9517: /*
9518: * Tune PCI LATENCY TIMER according to burst max length transfer.
9519: * (latency timer >= burst length + 6, we add 10 to be quite sure)
9520: * If current value is zero, the device has probably been configured
9521: * for no bursting due to some broken hardware.
9522: */
9523:
9524: if (latency_timer == 0 && chip->burst_max)
9525: printk("ncr53c8xx: PCI_LATENCY_TIMER=0, bursting should'nt be allowed.\n");
9526:
9527: if ((driver_setup.pci_fix_up & 4) && chip->burst_max) {
9528: uchar lt = (1 << chip->burst_max) + 6 + 10;
9529: if (latency_timer < lt) {
9530: latency_timer = lt;
9531: if (initverbose)
9532: printk("ncr53c8xx: setting PCI_LATENCY_TIMER to %d bus clocks (fix-up).\n", latency_timer);
9533: (void) pcibios_write_config_byte(bus, device_fn,
9534: PCI_LATENCY_TIMER, latency_timer);
9535: }
9536: }
9537:
9538: /*
9539: * Fix up for recent chips that support CACHE LINE SIZE.
9540: * If PCI config space is not OK, remove features that shall not be
9541: * used by the chip. No need to trigger possible chip bugs.
9542: */
9543:
9544: if ((chip->features & FE_CLSE) && cache_line_size == 0) {
9545: chip->features &= ~FE_CACHE_SET;
9546: printk("ncr53c8xx: PCI_CACHE_LINE_SIZE not set, features based on CACHE LINE SIZE not used.\n");
9547: }
9548:
9549: if ((chip->features & FE_WRIE) && !(command & PCI_COMMAND_INVALIDATE)) {
9550: chip->features &= ~FE_WRIE;
9551: printk("ncr53c8xx: PCI_COMMAND_INVALIDATE not set, WRITE AND INVALIDATE not used\n");
9552: }
9553:
9554: #endif /* SCSI_NCR_PCI_FIX_UP_SUPPORT */
9555:
9556: /* initialise ncr_device structure with items required by ncr_attach */
9557: device->slot.bus = bus;
9558: device->slot.device_fn = device_fn;
9559: device->slot.base = base;
9560: device->slot.base_2 = base_2;
9561: device->slot.io_port = io_port;
9562: device->slot.irq = irq;
9563: device->attach_done = 0;
9564: #ifdef SCSI_NCR_NVRAM_SUPPORT
9565: if (!nvram)
9566: goto out;
9567:
9568: /*
9569: ** Get access to chip IO registers
9570: */
9571: #ifdef NCR_IOMAPPED
9572: request_region(io_port, 128, "ncr53c8xx");
9573: device->slot.port = io_port;
9574: #else
9575: device->slot.reg = (struct ncr_reg *) remap_pci_mem((ulong) base, 128);
9576: if (!device->slot.reg)
9577: goto out;
9578: #endif
9579:
9580: /*
9581: ** Try to read SYMBIOS nvram.
9582: ** Data can be used to order booting of boards.
9583: **
9584: ** Data is saved in ncr_device structure if NVRAM found. This
9585: ** is then used to find drive boot order for ncr_attach().
9586: **
9587: ** NVRAM data is passed to Scsi_Host_Template later during ncr_attach()
9588: ** for any device set up.
9589: **
9590: ** Try to read TEKRAM nvram if Symbios nvram not found.
9591: */
9592:
9593: if (!ncr_get_Symbios_nvram(&device->slot, &nvram->data.Symbios))
9594: nvram->type = SCSI_NCR_SYMBIOS_NVRAM;
9595: else if (!ncr_get_Tekram_nvram(&device->slot, &nvram->data.Tekram))
9596: nvram->type = SCSI_NCR_TEKRAM_NVRAM;
9597: else
9598: nvram->type = 0;
9599: out:
9600: /*
9601: ** Release access to chip IO registers
9602: */
9603: #ifdef NCR_IOMAPPED
9604: release_region(device->slot.port, 128);
9605: #else
9606: unmap_pci_mem((vm_offset_t) device->slot.reg, (u_long) 128);
9607: #endif
9608:
9609: #endif /* SCSI_NCR_NVRAM_SUPPORT */
9610: return 0;
9611: }
9612:
9613: #if LINUX_VERSION_CODE >= LinuxVersionCode(2,0,0)
9614: /*
9615: ** Linux select queue depths function
9616: */
9617: static void ncr53c8xx_select_queue_depths(struct Scsi_Host *host, struct scsi_device *devlist)
9618: {
9619: struct scsi_device *device;
9620:
9621: for (device = devlist; device; device = device->next) {
9622: if (device->host == host) {
9623: #if SCSI_NCR_MAX_TAGS > 1
9624: if (device->tagged_supported) {
9625: device->queue_depth = SCSI_NCR_MAX_TAGS;
9626: }
9627: else {
9628: device->queue_depth = 2;
9629: }
9630: #else
9631: device->queue_depth = 1;
9632: #endif
9633:
9634: #ifdef DEBUG_NCR53C8XX
9635: printk("ncr53c8xx_select_queue_depth: id=%d, lun=%d, queue_depth=%d\n",
9636: device->id, device->lun, device->queue_depth);
9637: #endif
9638: }
9639: }
9640: }
9641: #endif
9642:
9643: /*
9644: ** Linux entry point of queuecommand() function
9645: */
9646:
9647: int ncr53c8xx_queue_command (Scsi_Cmnd *cmd, void (* done)(Scsi_Cmnd *))
9648: {
9649: int sts;
9650: #ifdef DEBUG_NCR53C8XX
9651: printk("ncr53c8xx_queue_command\n");
9652: #endif
9653:
9654: if ((sts = ncr_queue_command(cmd, done)) != DID_OK) {
9655: cmd->result = ScsiResult(sts, 0);
9656: done(cmd);
9657: #ifdef DEBUG_NCR53C8XX
9658: printk("ncr53c8xx : command not queued - result=%d\n", sts);
9659: #endif
9660: return sts;
9661: }
9662: #ifdef DEBUG_NCR53C8XX
9663: printk("ncr53c8xx : command successfully queued\n");
9664: #endif
9665: return sts;
9666: }
9667:
9668: /*
9669: ** Linux entry point of the interrupt handler.
9670: ** Fort linux versions > 1.3.70, we trust the kernel for
9671: ** passing the internal host descriptor as 'dev_id'.
9672: ** Otherwise, we scan the host list and call the interrupt
9673: ** routine for each host that uses this IRQ.
9674: */
9675:
9676: #if LINUX_VERSION_CODE >= LinuxVersionCode(1,3,70)
9677: static void ncr53c8xx_intr(int irq, void *dev_id, struct pt_regs * regs)
9678: {
9679: #ifdef DEBUG_NCR53C8XX
9680: printk("ncr53c8xx : interrupt received\n");
9681: #endif
9682:
9683: if (DEBUG_FLAGS & DEBUG_TINY) printf ("[");
9684: ncr_exception((ncb_p) dev_id);
9685: if (DEBUG_FLAGS & DEBUG_TINY) printf ("]\n");
9686: }
9687:
9688: #else
9689: static void ncr53c8xx_intr(int irq, struct pt_regs * regs)
9690: {
9691: struct Scsi_Host *host;
9692: struct host_data *host_data;
9693:
9694: for (host = first_host; host; host = host->next) {
9695: if (host->hostt == the_template && host->irq == irq) {
9696: host_data = (struct host_data *) host->hostdata;
9697: if (DEBUG_FLAGS & DEBUG_TINY) printf ("[");
9698: ncr_exception(host_data->ncb);
9699: if (DEBUG_FLAGS & DEBUG_TINY) printf ("]\n");
9700: }
9701: }
9702: }
9703: #endif
9704:
9705: /*
9706: ** Linux entry point of the timer handler
9707: */
9708:
9709: static void ncr53c8xx_timeout(unsigned long np)
9710: {
9711: ncr_timeout((ncb_p) np);
9712: }
9713:
9714: /*
9715: ** Linux entry point of reset() function
9716: */
9717:
9718: #if defined SCSI_RESET_SYNCHRONOUS && defined SCSI_RESET_ASYNCHRONOUS
9719:
9720: int ncr53c8xx_reset(Scsi_Cmnd *cmd, unsigned int reset_flags)
9721: {
9722: int sts;
9723: unsigned long flags;
9724:
9725: printk("ncr53c8xx_reset: pid=%lu reset_flags=%x serial_number=%ld serial_number_at_timeout=%ld\n",
9726: cmd->pid, reset_flags, cmd->serial_number, cmd->serial_number_at_timeout);
9727:
9728: save_flags(flags); cli();
9729:
9730: /*
9731: * We have to just ignore reset requests in some situations.
9732: */
9733: #if defined SCSI_RESET_NOT_RUNNING
9734: if (cmd->serial_number != cmd->serial_number_at_timeout) {
9735: sts = SCSI_RESET_NOT_RUNNING;
9736: goto out;
9737: }
9738: #endif
9739: /*
9740: * If the mid-level driver told us reset is synchronous, it seems
9741: * that we must call the done() callback for the involved command,
9742: * even if this command was not queued to the low-level driver,
9743: * before returning SCSI_RESET_SUCCESS.
9744: */
9745:
9746: sts = ncr_reset_bus(cmd,
9747: (reset_flags & (SCSI_RESET_SYNCHRONOUS | SCSI_RESET_ASYNCHRONOUS)) == SCSI_RESET_SYNCHRONOUS);
9748: /*
9749: * Since we always reset the controller, when we return success,
9750: * we add this information to the return code.
9751: */
9752: #if defined SCSI_RESET_HOST_RESET
9753: if (sts == SCSI_RESET_SUCCESS)
9754: sts |= SCSI_RESET_HOST_RESET;
9755: #endif
9756:
9757: out:
9758: restore_flags(flags);
9759: return sts;
9760: }
9761: #else
9762: int ncr53c8xx_reset(Scsi_Cmnd *cmd)
9763: {
9764: printk("ncr53c8xx_reset: command pid %lu\n", cmd->pid);
9765: return ncr_reset_bus(cmd, 1);
9766: }
9767: #endif
9768:
9769: /*
9770: ** Linux entry point of abort() function
9771: */
9772:
9773: #if defined SCSI_RESET_SYNCHRONOUS && defined SCSI_RESET_ASYNCHRONOUS
9774:
9775: int ncr53c8xx_abort(Scsi_Cmnd *cmd)
9776: {
9777: int sts;
9778: unsigned long flags;
9779:
9780: printk("ncr53c8xx_abort: pid=%lu serial_number=%ld serial_number_at_timeout=%ld\n",
9781: cmd->pid, cmd->serial_number, cmd->serial_number_at_timeout);
9782:
9783: save_flags(flags); cli();
9784:
9785: /*
9786: * We have to just ignore abort requests in some situations.
9787: */
9788: if (cmd->serial_number != cmd->serial_number_at_timeout) {
9789: sts = SCSI_ABORT_NOT_RUNNING;
9790: goto out;
9791: }
9792:
9793: sts = ncr_abort_command(cmd);
9794: out:
9795: restore_flags(flags);
9796: return sts;
9797: }
9798: #else
9799: int ncr53c8xx_abort(Scsi_Cmnd *cmd)
9800: {
9801: printk("ncr53c8xx_abort: command pid %lu\n", cmd->pid);
9802: return ncr_abort_command(cmd);
9803: }
9804: #endif
9805:
9806: #ifdef MODULE
9807: int ncr53c8xx_release(struct Scsi_Host *host)
9808: {
9809: #ifdef DEBUG_NCR53C8XX
9810: printk("ncr53c8xx : release\n");
9811: #endif
9812: ncr_detach(((struct host_data *) host->hostdata)->ncb);
9813:
9814: return 1;
9815: }
9816: #endif
9817:
9818:
9819: /*
9820: ** Scsi command waiting list management.
9821: **
9822: ** It may happen that we cannot insert a scsi command into the start queue,
9823: ** in the following circumstances.
9824: ** Too few preallocated ccb(s),
9825: ** maxtags < cmd_per_lun of the Linux host control block,
9826: ** etc...
9827: ** Such scsi commands are inserted into a waiting list.
9828: ** When a scsi command complete, we try to requeue the commands of the
9829: ** waiting list.
9830: */
9831:
9832: #define next_wcmd host_scribble
9833:
9834: static void insert_into_waiting_list(ncb_p np, Scsi_Cmnd *cmd)
9835: {
9836: Scsi_Cmnd *wcmd;
9837:
9838: #ifdef DEBUG_WAITING_LIST
9839: printf("%s: cmd %lx inserted into waiting list\n", ncr_name(np), (u_long) cmd);
9840: #endif
9841: cmd->next_wcmd = 0;
9842: if (!(wcmd = np->waiting_list)) np->waiting_list = cmd;
9843: else {
9844: while ((wcmd->next_wcmd) != 0)
9845: wcmd = (Scsi_Cmnd *) wcmd->next_wcmd;
9846: wcmd->next_wcmd = (char *) cmd;
9847: }
9848: }
9849:
9850: static Scsi_Cmnd *retrieve_from_waiting_list(int to_remove, ncb_p np, Scsi_Cmnd *cmd)
9851: {
9852: Scsi_Cmnd *wcmd;
9853:
9854: if (!(wcmd = np->waiting_list)) return 0;
9855: while (wcmd->next_wcmd) {
9856: if (cmd == (Scsi_Cmnd *) wcmd->next_wcmd) {
9857: if (to_remove) {
9858: wcmd->next_wcmd = cmd->next_wcmd;
9859: cmd->next_wcmd = 0;
9860: }
9861: #ifdef DEBUG_WAITING_LIST
9862: printf("%s: cmd %lx retrieved from waiting list\n", ncr_name(np), (u_long) cmd);
9863: #endif
9864: return cmd;
9865: }
9866: }
9867: return 0;
9868: }
9869:
9870: static void process_waiting_list(ncb_p np, int sts)
9871: {
9872: Scsi_Cmnd *waiting_list, *wcmd;
9873:
9874: waiting_list = np->waiting_list;
9875: np->waiting_list = 0;
9876:
9877: #ifdef DEBUG_WAITING_LIST
9878: if (waiting_list) printf("%s: waiting_list=%lx processing sts=%d\n", ncr_name(np), (u_long) waiting_list, sts);
9879: #endif
9880: while ((wcmd = waiting_list) != 0) {
9881: waiting_list = (Scsi_Cmnd *) wcmd->next_wcmd;
9882: wcmd->next_wcmd = 0;
9883: if (sts == DID_OK) {
9884: #ifdef DEBUG_WAITING_LIST
9885: printf("%s: cmd %lx trying to requeue\n", ncr_name(np), (u_long) wcmd);
9886: #endif
9887: sts = ncr_queue_command(wcmd, wcmd->scsi_done);
9888: }
9889: if (sts != DID_OK) {
9890: #ifdef DEBUG_WAITING_LIST
9891: printf("%s: cmd %lx done forced sts=%d\n", ncr_name(np), (u_long) wcmd, sts);
9892: #endif
9893: wcmd->result = ScsiResult(sts, 0);
9894: wcmd->scsi_done(wcmd);
9895: }
9896: }
9897: }
9898:
9899: #undef next_wcmd
9900:
9901: /*
9902: ** Returns data transfer direction for common op-codes.
9903: */
9904:
9905: static int guess_xfer_direction(int opcode)
9906: {
9907: int d;
9908:
9909: switch(opcode) {
9910: case 0x12: /* INQUIRY 12 */
9911: case 0x4D: /* LOG SENSE 4D */
9912: case 0x5A: /* MODE SENSE(10) 5A */
9913: case 0x1A: /* MODE SENSE(6) 1A */
9914: case 0x3C: /* READ BUFFER 3C */
9915: case 0x1C: /* RECEIVE DIAGNOSTIC RESULTS 1C */
9916: case 0x03: /* REQUEST SENSE 03 */
9917: d = XferIn;
9918: break;
9919: case 0x39: /* COMPARE 39 */
9920: case 0x3A: /* COPY AND VERIFY 3A */
9921: case 0x18: /* COPY 18 */
9922: case 0x4C: /* LOG SELECT 4C */
9923: case 0x55: /* MODE SELECT(10) 55 */
9924: case 0x3B: /* WRITE BUFFER 3B */
9925: case 0x1D: /* SEND DIAGNOSTIC 1D */
9926: case 0x40: /* CHANGE DEFINITION 40 */
9927: case 0x15: /* MODE SELECT(6) 15 */
9928: d = XferOut;
9929: break;
9930: case 0x00: /* TEST UNIT READY 00 */
9931: d = XferNone;
9932: break;
9933: default:
9934: d = XferBoth;
9935: break;
9936: }
9937:
9938: return d;
9939: }
9940:
9941:
9942: #ifdef SCSI_NCR_PROC_INFO_SUPPORT
9943:
9944: /*=========================================================================
9945: ** Proc file system stuff
9946: **
9947: ** A read operation returns profile information.
9948: ** A write operation is a control command.
9949: ** The string is parsed in the driver code and the command is passed
9950: ** to the ncr_usercmd() function.
9951: **=========================================================================
9952: */
9953:
9954: #ifdef SCSI_NCR_USER_COMMAND_SUPPORT
9955:
9956: #define is_digit(c) ((c) >= '0' && (c) <= '9')
9957: #define digit_to_bin(c) ((c) - '0')
9958: #define is_space(c) ((c) == ' ' || (c) == '\t')
9959:
9960: static int skip_spaces(char *ptr, int len)
9961: {
9962: int cnt, c;
9963:
9964: for (cnt = len; cnt > 0 && (c = *ptr++) && is_space(c); cnt--);
9965:
9966: return (len - cnt);
9967: }
9968:
9969: static int get_int_arg(char *ptr, int len, u_long *pv)
9970: {
9971: int cnt, c;
9972: u_long v;
9973:
9974: for (v = 0, cnt = len; cnt > 0 && (c = *ptr++) && is_digit(c); cnt--) {
9975: v = (v * 10) + digit_to_bin(c);
9976: }
9977:
9978: if (pv)
9979: *pv = v;
9980:
9981: return (len - cnt);
9982: }
9983:
9984: static int is_keyword(char *ptr, int len, char *verb)
9985: {
9986: int verb_len = strlen(verb);
9987:
9988: if (len >= strlen(verb) && !memcmp(verb, ptr, verb_len))
9989: return verb_len;
9990: else
9991: return 0;
9992:
9993: }
9994:
9995: #define SKIP_SPACES(min_spaces) \
9996: if ((arg_len = skip_spaces(ptr, len)) < (min_spaces)) \
9997: return -EINVAL; \
9998: ptr += arg_len; len -= arg_len;
9999:
10000: #define GET_INT_ARG(v) \
10001: if (!(arg_len = get_int_arg(ptr, len, &(v)))) \
10002: return -EINVAL; \
10003: ptr += arg_len; len -= arg_len;
10004:
10005:
10006: /*
10007: ** Parse a control command
10008: */
10009:
10010: static int ncr_user_command(ncb_p np, char *buffer, int length)
10011: {
10012: char *ptr = buffer;
10013: int len = length;
10014: struct usrcmd *uc = &np->user;
10015: int arg_len;
10016: u_long target;
10017:
10018: bzero(uc, sizeof(*uc));
10019:
10020: if (len > 0 && ptr[len-1] == '\n')
10021: --len;
10022:
10023: if ((arg_len = is_keyword(ptr, len, "setsync")) != 0)
10024: uc->cmd = UC_SETSYNC;
10025: else if ((arg_len = is_keyword(ptr, len, "settags")) != 0)
10026: uc->cmd = UC_SETTAGS;
10027: else if ((arg_len = is_keyword(ptr, len, "setorder")) != 0)
10028: uc->cmd = UC_SETORDER;
10029: else if ((arg_len = is_keyword(ptr, len, "setwide")) != 0)
10030: uc->cmd = UC_SETWIDE;
10031: else if ((arg_len = is_keyword(ptr, len, "setdebug")) != 0)
10032: uc->cmd = UC_SETDEBUG;
10033: else if ((arg_len = is_keyword(ptr, len, "setflag")) != 0)
10034: uc->cmd = UC_SETFLAG;
10035: else if ((arg_len = is_keyword(ptr, len, "clearprof")) != 0)
10036: uc->cmd = UC_CLEARPROF;
10037: #ifdef UC_DEBUG_ERROR_RECOVERY
10038: else if ((arg_len = is_keyword(ptr, len, "debug_error_recovery")) != 0)
10039: uc->cmd = UC_DEBUG_ERROR_RECOVERY;
10040: #endif
10041: else
10042: arg_len = 0;
10043:
10044: #ifdef DEBUG_PROC_INFO
10045: printf("ncr_user_command: arg_len=%d, cmd=%ld\n", arg_len, uc->cmd);
10046: #endif
10047:
10048: if (!arg_len)
10049: return -EINVAL;
10050: ptr += arg_len; len -= arg_len;
10051:
10052: switch(uc->cmd) {
10053: case UC_SETSYNC:
10054: case UC_SETTAGS:
10055: case UC_SETWIDE:
10056: case UC_SETFLAG:
10057: SKIP_SPACES(1);
10058: if ((arg_len = is_keyword(ptr, len, "all")) != 0) {
10059: ptr += arg_len; len -= arg_len;
10060: uc->target = ~0;
10061: } else {
10062: GET_INT_ARG(target);
10063: uc->target = (1<<target);
10064: #ifdef DEBUG_PROC_INFO
10065: printf("ncr_user_command: target=%ld\n", target);
10066: #endif
10067: }
10068: break;
10069: }
10070:
10071: switch(uc->cmd) {
10072: case UC_SETSYNC:
10073: case UC_SETTAGS:
10074: case UC_SETWIDE:
10075: SKIP_SPACES(1);
10076: GET_INT_ARG(uc->data);
10077: #ifdef DEBUG_PROC_INFO
10078: printf("ncr_user_command: data=%ld\n", uc->data);
10079: #endif
10080: break;
10081: case UC_SETORDER:
10082: SKIP_SPACES(1);
10083: if ((arg_len = is_keyword(ptr, len, "simple")))
10084: uc->data = M_SIMPLE_TAG;
10085: else if ((arg_len = is_keyword(ptr, len, "ordered")))
10086: uc->data = M_ORDERED_TAG;
10087: else if ((arg_len = is_keyword(ptr, len, "default")))
10088: uc->data = 0;
10089: else
10090: return -EINVAL;
10091: break;
10092: case UC_SETDEBUG:
10093: while (len > 0) {
10094: SKIP_SPACES(1);
10095: if ((arg_len = is_keyword(ptr, len, "alloc")))
10096: uc->data |= DEBUG_ALLOC;
10097: else if ((arg_len = is_keyword(ptr, len, "phase")))
10098: uc->data |= DEBUG_PHASE;
10099: else if ((arg_len = is_keyword(ptr, len, "poll")))
10100: uc->data |= DEBUG_POLL;
10101: else if ((arg_len = is_keyword(ptr, len, "queue")))
10102: uc->data |= DEBUG_QUEUE;
10103: else if ((arg_len = is_keyword(ptr, len, "result")))
10104: uc->data |= DEBUG_RESULT;
10105: else if ((arg_len = is_keyword(ptr, len, "scatter")))
10106: uc->data |= DEBUG_SCATTER;
10107: else if ((arg_len = is_keyword(ptr, len, "script")))
10108: uc->data |= DEBUG_SCRIPT;
10109: else if ((arg_len = is_keyword(ptr, len, "tiny")))
10110: uc->data |= DEBUG_TINY;
10111: else if ((arg_len = is_keyword(ptr, len, "timing")))
10112: uc->data |= DEBUG_TIMING;
10113: else if ((arg_len = is_keyword(ptr, len, "nego")))
10114: uc->data |= DEBUG_NEGO;
10115: else if ((arg_len = is_keyword(ptr, len, "tags")))
10116: uc->data |= DEBUG_TAGS;
10117: else if ((arg_len = is_keyword(ptr, len, "freeze")))
10118: uc->data |= DEBUG_FREEZE;
10119: else if ((arg_len = is_keyword(ptr, len, "restart")))
10120: uc->data |= DEBUG_RESTART;
10121: else
10122: return -EINVAL;
10123: ptr += arg_len; len -= arg_len;
10124: }
10125: #ifdef DEBUG_PROC_INFO
10126: printf("ncr_user_command: data=%ld\n", uc->data);
10127: #endif
10128: break;
10129: case UC_SETFLAG:
10130: while (len > 0) {
10131: SKIP_SPACES(1);
10132: if ((arg_len = is_keyword(ptr, len, "trace")))
10133: uc->data |= UF_TRACE;
10134: else if ((arg_len = is_keyword(ptr, len, "no_disc")))
10135: uc->data |= UF_NODISC;
10136: else
10137: return -EINVAL;
10138: ptr += arg_len; len -= arg_len;
10139: }
10140: break;
10141: #ifdef UC_DEBUG_ERROR_RECOVERY
10142: case UC_DEBUG_ERROR_RECOVERY:
10143: SKIP_SPACES(1);
10144: if ((arg_len = is_keyword(ptr, len, "sge")))
10145: uc->data = 1;
10146: else if ((arg_len = is_keyword(ptr, len, "abort")))
10147: uc->data = 2;
10148: else if ((arg_len = is_keyword(ptr, len, "reset")))
10149: uc->data = 3;
10150: else if ((arg_len = is_keyword(ptr, len, "parity")))
10151: uc->data = 4;
10152: else if ((arg_len = is_keyword(ptr, len, "none")))
10153: uc->data = 0;
10154: else
10155: return -EINVAL;
10156: ptr += arg_len; len -= arg_len;
10157: break;
10158: #endif
10159: default:
10160: break;
10161: }
10162:
10163: if (len)
10164: return -EINVAL;
10165: else {
10166: long flags;
10167:
10168: save_flags(flags); cli();
10169: ncr_usercmd (np);
10170: restore_flags(flags);
10171: }
10172: return length;
10173: }
10174:
10175: #endif /* SCSI_NCR_USER_COMMAND_SUPPORT */
10176:
10177: #ifdef SCSI_NCR_USER_INFO_SUPPORT
10178:
10179: struct info_str
10180: {
10181: char *buffer;
10182: int length;
10183: int offset;
10184: int pos;
10185: };
10186:
10187: static void copy_mem_info(struct info_str *info, char *data, int len)
10188: {
10189: if (info->pos + len > info->length)
10190: len = info->length - info->pos;
10191:
10192: if (info->pos + len < info->offset) {
10193: info->pos += len;
10194: return;
10195: }
10196: if (info->pos < info->offset) {
10197: data += (info->offset - info->pos);
10198: len -= (info->offset - info->pos);
10199: }
10200:
10201: if (len > 0) {
10202: memcpy(info->buffer + info->pos, data, len);
10203: info->pos += len;
10204: }
10205: }
10206:
10207: static int copy_info(struct info_str *info, char *fmt, ...)
10208: {
10209: va_list args;
10210: char buf[81];
10211: int len;
10212:
10213: va_start(args, fmt);
10214: len = vsprintf(buf, fmt, args);
10215: va_end(args);
10216:
10217: copy_mem_info(info, buf, len);
10218: return len;
10219: }
10220:
10221: /*
10222: ** Copy formatted profile information into the input buffer.
10223: */
10224:
10225: #define to_ms(t) ((t) * 1000 / HZ)
10226:
10227: static int ncr_host_info(ncb_p np, char *ptr, off_t offset, int len)
10228: {
10229: struct info_str info;
10230:
10231: info.buffer = ptr;
10232: info.length = len;
10233: info.offset = offset;
10234: info.pos = 0;
10235:
10236: copy_info(&info, "General information:\n");
10237: copy_info(&info, " Chip NCR53C%s, ", np->chip_name);
10238: copy_info(&info, "device id 0x%x, ", np->device_id);
10239: copy_info(&info, "revision id 0x%x\n", np->revision_id);
10240:
10241: copy_info(&info, " IO port address 0x%lx, ", (u_long) np->port);
10242: copy_info(&info, "IRQ number %d\n", (int) np->irq);
10243:
10244: #ifndef NCR_IOMAPPED
10245: if (np->reg)
10246: copy_info(&info, " Using memory mapped IO at virtual address 0x%lx\n",
10247: (u_long) np->reg);
10248: #endif
10249: copy_info(&info, " Synchronous period factor %d, ", (int) np->minsync);
10250: copy_info(&info, "max commands per lun %d\n", SCSI_NCR_MAX_TAGS);
10251:
10252: if (driver_setup.debug || driver_setup.verbose > 1) {
10253: copy_info(&info, " Debug flags 0x%x, ", driver_setup.debug);
10254: copy_info(&info, "verbosity level %d\n", driver_setup.verbose);
10255: }
10256:
10257: #ifdef SCSI_NCR_PROFILE_SUPPORT
10258: copy_info(&info, "Profiling information:\n");
10259: copy_info(&info, " %-12s = %lu\n", "num_trans",np->profile.num_trans);
10260: copy_info(&info, " %-12s = %lu\n", "num_kbytes",np->profile.num_kbytes);
10261: copy_info(&info, " %-12s = %lu\n", "num_disc", np->profile.num_disc);
10262: copy_info(&info, " %-12s = %lu\n", "num_break",np->profile.num_break);
10263: copy_info(&info, " %-12s = %lu\n", "num_int", np->profile.num_int);
10264: copy_info(&info, " %-12s = %lu\n", "num_fly", np->profile.num_fly);
10265: copy_info(&info, " %-12s = %lu\n", "ms_setup", to_ms(np->profile.ms_setup));
10266: copy_info(&info, " %-12s = %lu\n", "ms_data", to_ms(np->profile.ms_data));
10267: copy_info(&info, " %-12s = %lu\n", "ms_disc", to_ms(np->profile.ms_disc));
10268: copy_info(&info, " %-12s = %lu\n", "ms_post", to_ms(np->profile.ms_post));
10269: #endif
10270:
10271: return info.pos > info.offset? info.pos - info.offset : 0;
10272: }
10273:
10274: #endif /* SCSI_NCR_USER_INFO_SUPPORT */
10275:
10276: /*
10277: ** Entry point of the scsi proc fs of the driver.
10278: ** - func = 0 means read (returns profile data)
10279: ** - func = 1 means write (parse user control command)
10280: */
10281:
10282: int ncr53c8xx_proc_info(char *buffer, char **start, off_t offset,
10283: int length, int hostno, int func)
10284: {
10285: struct Scsi_Host *host;
10286: struct host_data *host_data;
10287: ncb_p ncb = 0;
10288: int retv;
10289:
10290: #ifdef DEBUG_PROC_INFO
10291: printf("ncr53c8xx_proc_info: hostno=%d, func=%d\n", hostno, func);
10292: #endif
10293:
10294: for (host = first_host; host; host = host->next) {
10295: if (host->hostt == the_template && host->host_no == hostno) {
10296: host_data = (struct host_data *) host->hostdata;
10297: ncb = host_data->ncb;
10298: break;
10299: }
10300: }
10301:
10302: if (!ncb)
10303: return -EINVAL;
10304:
10305: if (func) {
10306: #ifdef SCSI_NCR_USER_COMMAND_SUPPORT
10307: retv = ncr_user_command(ncb, buffer, length);
10308: #else
10309: retv = -EINVAL;
10310: #endif
10311: }
10312: else {
10313: if (start)
10314: *start = buffer;
10315: #ifdef SCSI_NCR_USER_INFO_SUPPORT
10316: retv = ncr_host_info(ncb, buffer, offset, length);
10317: #else
10318: retv = -EINVAL;
10319: #endif
10320: }
10321:
10322: return retv;
10323: }
10324:
10325:
10326: /*=========================================================================
10327: ** End of proc file system stuff
10328: **=========================================================================
10329: */
10330: #endif
10331:
10332:
10333: #ifdef SCSI_NCR_NVRAM_SUPPORT
10334:
10335: /* ---------------------------------------------------------------------
10336: **
10337: ** Try reading Symbios format nvram
10338: **
10339: ** ---------------------------------------------------------------------
10340: **
10341: ** GPOI0 - data in/data out
10342: ** GPIO1 - clock
10343: **
10344: ** return 0 if NVRAM data OK, 1 if NVRAM data not OK
10345: ** ---------------------------------------------------------------------
10346: */
10347:
10348: #define SET_BIT 0
10349: #define CLR_BIT 1
10350: #define SET_CLK 2
10351: #define CLR_CLK 3
10352:
10353: static u_short nvram_read_data(ncr_slot *np, u_char *data, int len, u_char *gpreg, u_char *gpcntl);
10354: static void nvram_start(ncr_slot *np, u_char *gpreg);
10355: static void nvram_write_byte(ncr_slot *np, u_char *ack_data, u_char write_data, u_char *gpreg, u_char *gpcntl);
10356: static void nvram_read_byte(ncr_slot *np, u_char *read_data, u_char ack_data, u_char *gpreg, u_char *gpcntl);
10357: static void nvram_readAck(ncr_slot *np, u_char *read_bit, u_char *gpreg, u_char *gpcntl);
10358: static void nvram_writeAck(ncr_slot *np, u_char write_bit, u_char *gpreg, u_char *gpcntl);
10359: static void nvram_doBit(ncr_slot *np, u_char *read_bit, u_char write_bit, u_char *gpreg);
10360: static void nvram_stop(ncr_slot *np, u_char *gpreg);
10361: static void nvram_setBit(ncr_slot *np, u_char write_bit, u_char *gpreg, int bit_mode);
10362:
10363: __initfunc(
10364: static int ncr_get_Symbios_nvram (ncr_slot *np, Symbios_nvram *nvram)
10365: )
10366: {
10367: static u_char Symbios_trailer[6] = {0xfe, 0xfe, 0, 0, 0, 0};
10368: u_char gpcntl, gpreg;
10369: u_char old_gpcntl, old_gpreg;
10370: u_short csum;
10371: u_char ack_data;
10372: int retv = 1;
10373:
10374: /* save current state of GPCNTL and GPREG */
10375: old_gpreg = INB (nc_gpreg);
10376: old_gpcntl = INB (nc_gpcntl);
10377: gpcntl = old_gpcntl & 0xfc;
10378:
10379: /* set up GPREG & GPCNTL to set GPIO0 and GPIO1 in to known state */
10380: OUTB (nc_gpreg, old_gpreg);
10381: OUTB (nc_gpcntl, gpcntl);
10382:
10383: /* this is to set NVRAM into a known state with GPIO0/1 both low */
10384: gpreg = old_gpreg;
10385: nvram_setBit(np, 0, &gpreg, CLR_CLK);
10386: nvram_setBit(np, 0, &gpreg, CLR_BIT);
10387:
10388: /* now set NVRAM inactive with GPIO0/1 both high */
10389: nvram_stop(np, &gpreg);
10390:
10391: /* activate NVRAM */
10392: nvram_start(np, &gpreg);
10393:
10394: /* write device code and random address MSB */
10395: nvram_write_byte(np, &ack_data,
10396: 0xa0 | ((SYMBIOS_NVRAM_ADDRESS >> 7) & 0x0e), &gpreg, &gpcntl);
10397: if (ack_data & 0x01)
10398: goto out;
10399:
10400: /* write random address LSB */
10401: nvram_write_byte(np, &ack_data,
10402: (SYMBIOS_NVRAM_ADDRESS & 0x7f) << 1, &gpreg, &gpcntl);
10403: if (ack_data & 0x01)
10404: goto out;
10405:
10406: /* regenerate START state to set up for reading */
10407: nvram_start(np, &gpreg);
10408:
10409: /* rewrite device code and address MSB with read bit set (lsb = 0x01) */
10410: nvram_write_byte(np, &ack_data,
10411: 0xa1 | ((SYMBIOS_NVRAM_ADDRESS >> 7) & 0x0e), &gpreg, &gpcntl);
10412: if (ack_data & 0x01)
10413: goto out;
10414:
10415: /* now set up GPIO0 for inputting data */
10416: gpcntl |= 0x01;
10417: OUTB (nc_gpcntl, gpcntl);
10418:
10419: /* input all active data - only part of total NVRAM */
10420: csum = nvram_read_data(np,
10421: (u_char *) nvram, sizeof(*nvram), &gpreg, &gpcntl);
10422:
10423: /* finally put NVRAM back in inactive mode */
10424: gpcntl &= 0xfe;
10425: OUTB (nc_gpcntl, gpcntl);
10426: nvram_stop(np, &gpreg);
10427:
10428: #ifdef SCSI_NCR_DEBUG_NVRAM
10429: printf("ncr53c8xx: NvRAM marker=%x trailer=%x %x %x %x %x %x byte_count=%d/%d checksum=%x/%x\n",
10430: nvram->start_marker,
10431: nvram->trailer[0], nvram->trailer[1], nvram->trailer[2],
10432: nvram->trailer[3], nvram->trailer[4], nvram->trailer[5],
10433: nvram->byte_count, sizeof(*nvram) - 12,
10434: nvram->checksum, csum);
10435: #endif
10436:
10437: /* check valid NVRAM signature, verify byte count and checksum */
10438: if (nvram->start_marker == 0 &&
10439: !memcmp(nvram->trailer, Symbios_trailer, 6) &&
10440: nvram->byte_count == sizeof(*nvram) - 12 &&
10441: csum == nvram->checksum)
10442: retv = 0;
10443: out:
10444: /* return GPIO0/1 to original states after having accessed NVRAM */
10445: OUTB (nc_gpcntl, old_gpcntl);
10446: OUTB (nc_gpreg, old_gpreg);
10447:
10448: return retv;
10449: }
10450:
10451: /*
10452: * Read Symbios NvRAM data and compute checksum.
10453: */
10454: __initfunc(
10455: static u_short nvram_read_data(ncr_slot *np, u_char *data, int len, u_char *gpreg, u_char *gpcntl)
10456: )
10457: {
10458: int x;
10459: u_short csum;
10460:
10461: for (x = 0; x < len; x++)
10462: nvram_read_byte(np, &data[x], (x == (len - 1)), gpreg, gpcntl);
10463:
10464: for (x = 6, csum = 0; x < len - 6; x++)
10465: csum += data[x];
10466:
10467: return csum;
10468: }
10469:
10470: /*
10471: * Send START condition to NVRAM to wake it up.
10472: */
10473: __initfunc(
10474: static void nvram_start(ncr_slot *np, u_char *gpreg)
10475: )
10476: {
10477: nvram_setBit(np, 1, gpreg, SET_BIT);
10478: nvram_setBit(np, 0, gpreg, SET_CLK);
10479: nvram_setBit(np, 0, gpreg, CLR_BIT);
10480: nvram_setBit(np, 0, gpreg, CLR_CLK);
10481: }
10482:
10483: /*
10484: * WRITE a byte to the NVRAM and then get an ACK to see it was accepted OK,
10485: * GPIO0 must already be set as an output
10486: */
10487: __initfunc(
10488: static void nvram_write_byte(ncr_slot *np, u_char *ack_data, u_char write_data, u_char *gpreg, u_char *gpcntl)
10489: )
10490: {
10491: int x;
10492:
10493: for (x = 0; x < 8; x++)
10494: nvram_doBit(np, 0, (write_data >> (7 - x)) & 0x01, gpreg);
10495:
10496: nvram_readAck(np, ack_data, gpreg, gpcntl);
10497: }
10498:
10499: /*
10500: * READ a byte from the NVRAM and then send an ACK to say we have got it,
10501: * GPIO0 must already be set as an input
10502: */
10503: __initfunc(
10504: static void nvram_read_byte(ncr_slot *np, u_char *read_data, u_char ack_data, u_char *gpreg, u_char *gpcntl)
10505: )
10506: {
10507: int x;
10508: u_char read_bit;
10509:
10510: *read_data = 0;
10511: for (x = 0; x < 8; x++) {
10512: nvram_doBit(np, &read_bit, 1, gpreg);
10513: *read_data |= ((read_bit & 0x01) << (7 - x));
10514: }
10515:
10516: nvram_writeAck(np, ack_data, gpreg, gpcntl);
10517: }
10518:
10519: /*
10520: * Output an ACK to the NVRAM after reading,
10521: * change GPIO0 to output and when done back to an input
10522: */
10523: __initfunc(
10524: static void nvram_writeAck(ncr_slot *np, u_char write_bit, u_char *gpreg, u_char *gpcntl)
10525: )
10526: {
10527: OUTB (nc_gpcntl, *gpcntl & 0xfe);
10528: nvram_doBit(np, 0, write_bit, gpreg);
10529: OUTB (nc_gpcntl, *gpcntl);
10530: }
10531:
10532: /*
10533: * Input an ACK from NVRAM after writing,
10534: * change GPIO0 to input and when done back to an output
10535: */
10536: __initfunc(
10537: static void nvram_readAck(ncr_slot *np, u_char *read_bit, u_char *gpreg, u_char *gpcntl)
10538: )
10539: {
10540: OUTB (nc_gpcntl, *gpcntl | 0x01);
10541: nvram_doBit(np, read_bit, 1, gpreg);
10542: OUTB (nc_gpcntl, *gpcntl);
10543: }
10544:
10545: /*
10546: * Read or write a bit to the NVRAM,
10547: * read if GPIO0 input else write if GPIO0 output
10548: */
10549: __initfunc(
10550: static void nvram_doBit(ncr_slot *np, u_char *read_bit, u_char write_bit, u_char *gpreg)
10551: )
10552: {
10553: nvram_setBit(np, write_bit, gpreg, SET_BIT);
10554: nvram_setBit(np, 0, gpreg, SET_CLK);
10555: if (read_bit)
10556: *read_bit = INB (nc_gpreg);
10557: nvram_setBit(np, 0, gpreg, CLR_CLK);
10558: nvram_setBit(np, 0, gpreg, CLR_BIT);
10559: }
10560:
10561: /*
10562: * Send STOP condition to NVRAM - puts NVRAM to sleep... ZZzzzz!!
10563: */
10564: __initfunc(
10565: static void nvram_stop(ncr_slot *np, u_char *gpreg)
10566: )
10567: {
10568: nvram_setBit(np, 0, gpreg, SET_CLK);
10569: nvram_setBit(np, 1, gpreg, SET_BIT);
10570: }
10571:
10572: /*
10573: * Set/clear data/clock bit in GPIO0
10574: */
10575: __initfunc(
10576: static void nvram_setBit(ncr_slot *np, u_char write_bit, u_char *gpreg, int bit_mode)
10577: )
10578: {
10579: DELAY(5);
10580: switch (bit_mode){
10581: case SET_BIT:
10582: *gpreg |= write_bit;
10583: break;
10584: case CLR_BIT:
10585: *gpreg &= 0xfe;
10586: break;
10587: case SET_CLK:
10588: *gpreg |= 0x02;
10589: break;
10590: case CLR_CLK:
10591: *gpreg &= 0xfd;
10592: break;
10593:
10594: }
10595: OUTB (nc_gpreg, *gpreg);
10596: DELAY(5);
10597: }
10598:
10599: #undef SET_BIT 0
10600: #undef CLR_BIT 1
10601: #undef SET_CLK 2
10602: #undef CLR_CLK 3
10603:
10604:
10605: /* ---------------------------------------------------------------------
10606: **
10607: ** Try reading Tekram format nvram
10608: **
10609: ** ---------------------------------------------------------------------
10610: **
10611: ** GPOI0 - data in
10612: ** GPIO1 - data out
10613: ** GPIO2 - clock
10614: ** GPIO4 - chip select
10615: **
10616: ** return 0 if NVRAM data OK, 1 if NVRAM data not OK
10617: ** ---------------------------------------------------------------------
10618: */
10619:
10620: static u_short Tnvram_read_data(ncr_slot *np, u_short *data, int len, u_char *gpreg);
10621: static void Tnvram_Send_Command(ncr_slot *np, u_short write_data, u_char *read_bit, u_char *gpreg);
10622: static void Tnvram_Read_Word(ncr_slot *np, u_short *nvram_data, u_char *gpreg);
10623: static void Tnvram_Read_Bit(ncr_slot *np, u_char *read_bit, u_char *gpreg);
10624: static void Tnvram_Write_Bit(ncr_slot *np, u_char write_bit, u_char *gpreg);
10625: static void Tnvram_Stop(ncr_slot *np, u_char *gpreg);
10626: static void Tnvram_Clk(ncr_slot *np, u_char *gpreg);
10627:
10628: __initfunc(
10629: static int ncr_get_Tekram_nvram (ncr_slot *np, Tekram_nvram *nvram)
10630: )
10631: {
10632: u_char gpcntl, gpreg;
10633: u_char old_gpcntl, old_gpreg;
10634: u_short csum;
10635:
10636: /* save current state of GPCNTL and GPREG */
10637: old_gpreg = INB (nc_gpreg);
10638: old_gpcntl = INB (nc_gpcntl);
10639:
10640: /* set up GPREG & GPCNTL to set GPIO0/1/2/4 in to known state, 0 in,
10641: 1/2/4 out */
10642: gpreg = old_gpreg & 0xe9;
10643: OUTB (nc_gpreg, gpreg);
10644: gpcntl = (old_gpcntl & 0xe9) | 0x09;
10645: OUTB (nc_gpcntl, gpcntl);
10646:
10647: /* input all of NVRAM, 64 words */
10648: csum = Tnvram_read_data(np, (u_short *) nvram,
10649: sizeof(*nvram) / sizeof(short), &gpreg);
10650:
10651: /* return GPIO0/1/2/4 to original states after having accessed NVRAM */
10652: OUTB (nc_gpcntl, old_gpcntl);
10653: OUTB (nc_gpreg, old_gpreg);
10654:
10655: /* check data valid */
10656: if (csum != 0x1234)
10657: return 1;
10658:
10659: return 0;
10660: }
10661:
10662: /*
10663: * Read Tekram NvRAM data and compute checksum.
10664: */
10665: __initfunc(
10666: static u_short Tnvram_read_data(ncr_slot *np, u_short *data, int len, u_char *gpreg)
10667: )
10668: {
10669: u_char read_bit;
10670: u_short csum;
10671: int x;
10672:
10673: for (x = 0, csum = 0; x < len; x++) {
10674:
10675: /* output read command and address */
10676: Tnvram_Send_Command(np, 0x180 | x, &read_bit, gpreg);
10677: if (read_bit & 0x01)
10678: return 0; /* Force bad checksum */
10679:
10680: Tnvram_Read_Word(np, &data[x], gpreg);
10681: csum += data[x];
10682:
10683: Tnvram_Stop(np, gpreg);
10684: }
10685:
10686: return csum;
10687: }
10688:
10689: /*
10690: * Send read command and address to NVRAM
10691: */
10692: __initfunc(
10693: static void Tnvram_Send_Command(ncr_slot *np, u_short write_data, u_char *read_bit, u_char *gpreg)
10694: )
10695: {
10696: int x;
10697:
10698: /* send 9 bits, start bit (1), command (2), address (6) */
10699: for (x = 0; x < 9; x++)
10700: Tnvram_Write_Bit(np, (u_char) (write_data >> (8 - x)), gpreg);
10701:
10702: *read_bit = INB (nc_gpreg);
10703: }
10704:
10705: /*
10706: * READ a byte from the NVRAM
10707: */
10708: __initfunc(
10709: static void Tnvram_Read_Word(ncr_slot *np, u_short *nvram_data, u_char *gpreg)
10710: )
10711: {
10712: int x;
10713: u_char read_bit;
10714:
10715: *nvram_data = 0;
10716: for (x = 0; x < 16; x++) {
10717: Tnvram_Read_Bit(np, &read_bit, gpreg);
10718:
10719: if (read_bit & 0x01)
10720: *nvram_data |= (0x01 << (15 - x));
10721: else
10722: *nvram_data &= ~(0x01 << (15 - x));
10723: }
10724: }
10725:
10726: /*
10727: * Read bit from NVRAM
10728: */
10729: __initfunc(
10730: static void Tnvram_Read_Bit(ncr_slot *np, u_char *read_bit, u_char *gpreg)
10731: )
10732: {
10733: DELAY(2);
10734: Tnvram_Clk(np, gpreg);
10735: *read_bit = INB (nc_gpreg);
10736: }
10737:
10738: /*
10739: * Write bit to GPIO0
10740: */
10741: __initfunc(
10742: static void Tnvram_Write_Bit(ncr_slot *np, u_char write_bit, u_char *gpreg)
10743: )
10744: {
10745: if (write_bit & 0x01)
10746: *gpreg |= 0x02;
10747: else
10748: *gpreg &= 0xfd;
10749:
10750: *gpreg |= 0x10;
10751:
10752: OUTB (nc_gpreg, *gpreg);
10753: DELAY(2);
10754:
10755: Tnvram_Clk(np, gpreg);
10756: }
10757:
10758: /*
10759: * Send STOP condition to NVRAM - puts NVRAM to sleep... ZZZzzz!!
10760: */
10761: __initfunc(
10762: static void Tnvram_Stop(ncr_slot *np, u_char *gpreg)
10763: )
10764: {
10765: *gpreg &= 0xef;
10766: OUTB (nc_gpreg, *gpreg);
10767: DELAY(2);
10768:
10769: Tnvram_Clk(np, gpreg);
10770: }
10771:
10772: /*
10773: * Pulse clock bit in GPIO0
10774: */
10775: __initfunc(
10776: static void Tnvram_Clk(ncr_slot *np, u_char *gpreg)
10777: )
10778: {
10779: OUTB (nc_gpreg, *gpreg | 0x04);
10780: DELAY(2);
10781: OUTB (nc_gpreg, *gpreg);
10782: }
10783:
10784: #endif /* SCSI_NCR_NVRAM_SUPPORT */
10785:
10786: /*
10787: ** Module stuff
10788: */
10789:
10790: #ifdef MODULE
10791: Scsi_Host_Template driver_template = NCR53C8XX;
10792: #include "scsi_module.c"
10793: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.