![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to aha152x.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 aha152x.c CVS log | Up to [GnuMach] / Gnu-Mach / linux / src / drivers / scsi |
1.1 root 1: /* aha152x.c -- Adaptec AHA-152x driver
2: * Author: J�rgen E. Fischer, [email protected]
3: * Copyright 1993, 1994, 1995, 1996 J�rgen E. Fischer
4: *
5: *
6: * This driver is based on
7: * fdomain.c -- Future Domain TMC-16x0 driver
8: * which is
9: * Copyright 1992, 1993 Rickard E. Faith ([email protected])
10: *
11: *
12: * This program is free software; you can redistribute it and/or modify it
13: * under the terms of the GNU General Public License as published by the
14: * Free Software Foundation; either version 2, or (at your option) any
15: * later version.
16: *
17: * This program is distributed in the hope that it will be useful, but
18: * WITHOUT ANY WARRANTY; without even the implied warranty of
19: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20: * General Public License for more details.
21: *
22: *
23: * $Id: aha152x.c,v 1.1 1999/04/26 05:54:09 tb Exp $
24: *
25: * $Log: aha152x.c,v $
26: * Revision 1.1 1999/04/26 05:54:09 tb
27: * 1998-11-30 OKUJI Yoshinori <[email protected]>
28: *
29: * Clean up linux emulation code to make it architecture-independent
30: * as much as possible.
31: *
32: * * linux: Renamed from linuxdev.
33: * * Makefile.in (objfiles): Add linux.o instead of linuxdev.o.
34: * (MAKE): New variable. Used for the linux.o target.
35: * * configure.in: Add AC_CHECK_TOOL(MAKE, make).
36: * * i386/i386/spl.h: Include <i386/ipl.h>, for compatibility with
37: * OSF Mach 3.0. Suggested by Elgin Lee <[email protected]>.
38: * * linux/src: Renamed from linux/linux.
39: * * linux/dev: Renamed from linux/mach.
40: * * linux/Drivers.in (AC_INIT): Use dev/include/linux/autoconf.h,
41: * instead of mach/include/linux/autoconf.h.
42: * * Makefile.in (all): Target ../linux.o instead of ../linuxdev.o.
43: * * linux/dev/drivers/block/genhd.c: Include <machine/spl.h> instead
44: * of <i386/ipl.h>.
45: * * linux/dev/drivers/net/auto_irq.c: Remove unneeded header files,
46: * <i386/ipl.h> and <i386/pic.h>.
47: * * linux/dev/init/main.c: Many i386-dependent codes moved to ...
48: * * linux/dev/arch/i386/irq.c: ... here.
49: * * linux/dev/arch/i386/setup.c: New file.
50: * * linux/dev/arch/i386/linux_emul.h: Likewise.
51: * * linux/dev/arch/i386/glue/timer.c: Merged into sched.c.
52: * * linux/dev/arch/i386/glue/sched.c: Include <machine/spl.h> instead
53: * of <i386/ipl.h>, and moved to ...
54: * * linux/dev/kernel/sched.c: ... here.
55: * * linux/dev/arch/i386/glue/block.c: Include <machine/spl.h> and
56: * <linux_emul.h>, instead of i386-dependent header files, and
57: * moved to ...
58: * * linux/dev/glue/blocl.c: ... here.
59: * * linux/dev/arch/i386/glue/net.c: Include <machine/spl.h> and
60: * <linux_emul.h>, instead of i386-dependent header files, and
61: * moved to ...
62: * * linux/dev/glue/net.c: ... here.
63: * * linux/dev/arch/i386/glue/misc.c: Remove `x86' and moved to ...
64: * * linux/dev/glue/misc.c: ... here.
65: * * linux/dev/arch/i386/glue/kmem.c: Moved to ...
66: * * linux/dev/glue/kmem.c: ... here.
67: *
68: * Revision 1.18 1996/09/07 20:10:40 fischer
69: * - fixed can_queue handling (multiple outstanding commands working again)
70: *
71: * Revision 1.17 1996/08/17 16:05:14 fischer
72: * - biosparam improved
73: * - interrupt verification
74: * - updated documentation
75: * - cleanups
76: *
77: * Revision 1.16 1996/06/09 00:04:56 root
78: * - added configuration symbols for insmod (aha152x/aha152x1)
79: *
80: * Revision 1.15 1996/04/30 14:52:06 fischer
81: * - proc info fixed
82: * - support for extended translation for >1GB disks
83: *
84: * Revision 1.14 1996/01/17 15:11:20 fischer
85: * - fixed lockup in MESSAGE IN phase after reconnection
86: *
87: * Revision 1.13 1996/01/09 02:15:53 fischer
88: * - some cleanups
89: * - moved request_irq behind controller initialization
90: * (to avoid spurious interrupts)
91: *
92: * Revision 1.12 1995/12/16 12:26:07 fischer
93: * - barrier()s added
94: * - configurable RESET delay added
95: *
96: * Revision 1.11 1995/12/06 21:18:35 fischer
97: * - some minor updates
98: *
99: * Revision 1.10 1995/07/22 19:18:45 fischer
100: * - support for 2 controllers
101: * - started synchronous data transfers (not working yet)
102: *
103: * Revision 1.9 1995/03/18 09:20:24 root
104: * - patches for PCMCIA and modules
105: *
106: * Revision 1.8 1995/01/21 22:07:19 root
107: * - snarf_region => request_region
108: * - aha152x_intr interface change
109: *
110: * Revision 1.7 1995/01/02 23:19:36 root
111: * - updated COMMAND_SIZE to cmd_len
112: * - changed sti() to restore_flags()
113: * - fixed some #ifdef which generated warnings
114: *
115: * Revision 1.6 1994/11/24 20:35:27 root
116: * - problem with odd number of bytes in fifo fixed
117: *
118: * Revision 1.5 1994/10/30 14:39:56 root
119: * - abort code fixed
120: * - debugging improved
121: *
122: * Revision 1.4 1994/09/12 11:33:01 root
123: * - irqaction to request_irq
124: * - abortion updated
125: *
126: * Revision 1.3 1994/08/04 13:53:05 root
127: * - updates for mid-level-driver changes
128: * - accept unexpected BUSFREE phase as error condition
129: * - parity check now configurable
130: *
131: * Revision 1.2 1994/07/03 12:56:36 root
132: * - cleaned up debugging code
133: * - more tweaking on reset delays
134: * - updated abort/reset code (pretty untested...)
135: *
136: * Revision 1.1 1994/05/28 21:18:49 root
137: * - update for mid-level interface change (abort-reset)
138: * - delays after resets adjusted for some slow devices
139: *
140: * Revision 1.0 1994/03/25 12:52:00 root
141: * - Fixed "more data than expected" problem
142: * - added new BIOS signatures
143: *
144: * Revision 0.102 1994/01/31 20:44:12 root
145: * - minor changes in insw/outsw handling
146: *
147: * Revision 0.101 1993/12/13 01:16:27 root
148: * - fixed STATUS phase (non-GOOD stati were dropped sometimes;
149: * fixes problems with CD-ROM sector size detection & media change)
150: *
151: * Revision 0.100 1993/12/10 16:58:47 root
152: * - fix for unsuccessful selections in case of non-continuous id assignments
153: * on the scsi bus.
154: *
155: * Revision 0.99 1993/10/24 16:19:59 root
156: * - fixed DATA IN (rare read errors gone)
157: *
158: * Revision 0.98 1993/10/17 12:54:44 root
159: * - fixed some recent fixes (shame on me)
160: * - moved initialization of scratch area to aha152x_queue
161: *
162: * Revision 0.97 1993/10/09 18:53:53 root
163: * - DATA IN fixed. Rarely left data in the fifo.
164: *
165: * Revision 0.96 1993/10/03 00:53:59 root
166: * - minor changes on DATA IN
167: *
168: * Revision 0.95 1993/09/24 10:36:01 root
169: * - change handling of MSGI after reselection
170: * - fixed sti/cli
171: * - minor changes
172: *
173: * Revision 0.94 1993/09/18 14:08:22 root
174: * - fixed bug in multiple outstanding command code
175: * - changed detection
176: * - support for kernel command line configuration
177: * - reset corrected
178: * - changed message handling
179: *
180: * Revision 0.93 1993/09/15 20:41:19 root
181: * - fixed bugs with multiple outstanding commands
182: *
183: * Revision 0.92 1993/09/13 02:46:33 root
184: * - multiple outstanding commands work (no problems with IBM drive)
185: *
186: * Revision 0.91 1993/09/12 20:51:46 root
187: * added multiple outstanding commands
188: * (some problem with this $%&? IBM device remain)
189: *
190: * Revision 0.9 1993/09/12 11:11:22 root
191: * - corrected auto-configuration
192: * - changed the auto-configuration (added some '#define's)
193: * - added support for dis-/reconnection
194: *
195: * Revision 0.8 1993/09/06 23:09:39 root
196: * - added support for the drive activity light
197: * - minor changes
198: *
199: * Revision 0.7 1993/09/05 14:30:15 root
200: * - improved phase detection
201: * - now using the new snarf_region code of 0.99pl13
202: *
203: * Revision 0.6 1993/09/02 11:01:38 root
204: * first public release; added some signatures and biosparam()
205: *
206: * Revision 0.5 1993/08/30 10:23:30 root
207: * fixed timing problems with my IBM drive
208: *
209: * Revision 0.4 1993/08/29 14:06:52 root
210: * fixed some problems with timeouts due incomplete commands
211: *
212: * Revision 0.3 1993/08/28 15:55:03 root
213: * writing data works too. mounted and worked on a dos partition
214: *
215: * Revision 0.2 1993/08/27 22:42:07 root
216: * reading data works. Mounted a msdos partition.
217: *
218: * Revision 0.1 1993/08/25 13:38:30 root
219: * first "damn thing doesn't work" version
220: *
221: * Revision 0.0 1993/08/14 19:54:25 root
222: * empty function bodies; detect() works.
223: *
224: *
225: **************************************************************************
226:
227:
228:
229: DESCRIPTION:
230:
231: This is the Linux low-level SCSI driver for Adaptec AHA-1520/1522 SCSI
232: host adapters.
233:
234:
235: CONFIGURATION ARGUMENTS:
236:
237: IOPORT base io address (0x340/0x140)
238: IRQ interrupt level (9-12; default 11)
239: SCSI_ID scsi id of controller (0-7; default 7)
240: RECONNECT allow targets to disconnect from the bus (0/1; default 1 [on])
241: PARITY enable parity checking (0/1; default 1 [on])
242: SYNCHRONOUS enable synchronous transfers (0/1; default 0 [off])
243: (NOT WORKING YET)
244: DELAY: bus reset delay (default 100)
245: EXT_TRANS: enable extended translation (0/1: default 0 [off])
246: (see NOTES below)
247:
248: COMPILE TIME CONFIGURATION (put into AHA152X in drivers/scsi/Makefile):
249:
250: -DAUTOCONF
251: use configuration the controller reports (AHA-152x only)
252:
253: -DSKIP_BIOSTEST
254: Don't test for BIOS signature (AHA-1510 or disabled BIOS)
255:
256: -DSETUP0="{ IOPORT, IRQ, SCSI_ID, RECONNECT, PARITY, SYNCHRONOUS, DELAY, EXT_TRANS }"
257: override for the first controller
258:
259: -DSETUP1="{ IOPORT, IRQ, SCSI_ID, RECONNECT, PARITY, SYNCHRONOUS, DELAY, EXT_TRANS }"
260: override for the second controller
261:
262:
263: LILO COMMAND LINE OPTIONS:
264:
265: aha152x=<IOPORT>[,<IRQ>[,<SCSI-ID>[,<RECONNECT>[,<PARITY>[,<SYNCHRONOUS>[,<DELAY> [,<EXT_TRANS]]]]]]]
266:
267: The normal configuration can be overridden by specifying a command line.
268: When you do this, the BIOS test is skipped. Entered values have to be
269: valid (known). Don't use values that aren't supported under normal
270: operation. If you think that you need other values: contact me.
271: For two controllers use the aha152x statement twice.
272:
273:
274: SYMBOLS FOR MODULE CONFIGURATION:
275:
276: aha152x=IOPORT,IRQ,SCSI_ID,RECONNECT,PARITY,SYNCHRONOUS,DELAY,EXT_TRANS
277: configuration override of first controller
278:
279:
280: aha152x1=IOPORT,IRQ,SCSI_ID,RECONNECT,PARITY,SYNCHRONOUS,DELAY,EXT_TRANS
281: configuration override of second controller
282:
283:
284: NOTES ON EXT_TRANS:
285:
286: SCSI uses block numbers to address blocks/sectors on a device.
287: The BIOS uses a cylinder/head/sector addressing scheme (C/H/S)
288: scheme instead. DOS expects a BIOS or driver that understands this
289: C/H/S addressing.
290:
291: The number of cylinders/heads/sectors is called geometry and is required
292: as base for requests in C/H/S adressing. SCSI only knows about the
293: total capacity of disks in blocks (sectors).
294:
295: Therefore the SCSI BIOS/DOS driver has to calculate a logical/virtual
296: geometry just to be able to support that addressing scheme. The geometry
297: returned by the SCSI BIOS is a pure calculation and has nothing to
298: do with the real/physical geometry of the disk (which is usually
299: irrelevant anyway).
300:
301: Basically this has no impact at all on Linux, because it also uses block
302: instead of C/H/S addressing. Unfortunately C/H/S addressing is also used
303: in the partition table and therefore every operating system has to know
304: the right geometry to be able to interpret it.
305:
306: Moreover there are certain limitations to the C/H/S addressing scheme,
307: namely the address space is limited to upto 255 heads, upto 63 sectors
308: and a maximum of 1023 cylinders.
309:
310: The AHA-1522 BIOS calculates the geometry by fixing the number of heads
311: to 64, the number of sectors to 32 and by calculating the number of
312: cylinders by dividing the capacity reported by the disk by 64*32 (1 MB).
313: This is considered to be the default translation.
314:
315: With respect to the limit of 1023 cylinders using C/H/S you can only
316: address the first GB of your disk in the partition table. Therefore
317: BIOSes of some newer controllers based on the AIC-6260/6360 support
318: extended translation. This means that the BIOS uses 255 for heads,
319: 63 for sectors and then divides the capacity of the disk by 255*63
320: (about 8 MB), as soon it sees a disk greater than 1 GB. That results
321: in a maximum of about 8 GB adressable diskspace in the partition table
322: (but there are already bigger disks out there today).
323:
324: To make it even more complicated the translation mode might/might
325: not be configurable in certain BIOS setups.
326:
327: This driver does some more or less failsafe guessing to get the
328: geometry right in most cases:
329:
330: - for disks<1GB: use default translation (C/32/64)
331: - for disks>1GB:
332: - take current geometry from the partition table
333: (using scsicam_bios_param and accept only `valid' geometries,
334: ie. either (C/32/64) or (C/63/255)). This can be extended
335: translation even if it's not enabled in the driver.
336: - if that fails, take extended translation if enabled by override,
337: kernel or module parameter, otherwise take default translation and
338: ask the user for verification. This might on not yet partitioned
339: disks or
340:
341:
342: REFERENCES USED:
343:
344: "AIC-6260 SCSI Chip Specification", Adaptec Corporation.
345:
346: "SCSI COMPUTER SYSTEM INTERFACE - 2 (SCSI-2)", X3T9.2/86-109 rev. 10h
347:
348: "Writing a SCSI device driver for Linux", Rik Faith ([email protected])
349:
350: "Kernel Hacker's Guide", Michael K. Johnson ([email protected])
351:
352: "Adaptec 1520/1522 User's Guide", Adaptec Corporation.
353:
354: Michael K. Johnson ([email protected])
355:
356: Drew Eckhardt ([email protected])
357:
358: Eric Youngdale ([email protected])
359:
360: special thanks to Eric Youngdale for the free(!) supplying the
361: documentation on the chip.
362:
363: **************************************************************************/
364:
365: #ifdef PCMCIA
366: #define MODULE
367: #endif
368:
369: #include <linux/module.h>
370:
371: #ifdef PCMCIA
372: #undef MODULE
373: #endif
374:
375: #include <linux/sched.h>
376: #include <asm/io.h>
377: #include <linux/blk.h>
378: #include "scsi.h"
379: #include "sd.h"
380: #include "hosts.h"
381: #include "constants.h"
382: #include <asm/system.h>
383: #include <linux/errno.h>
384: #include <linux/string.h>
385: #include <linux/wait.h>
386: #include <linux/ioport.h>
387: #include <linux/proc_fs.h>
388:
389: #include "aha152x.h"
390: #include <linux/stat.h>
391:
392: #include <scsi/scsicam.h>
393:
394: struct proc_dir_entry proc_scsi_aha152x = {
395: PROC_SCSI_AHA152X, 7, "aha152x",
396: S_IFDIR | S_IRUGO | S_IXUGO, 2
397: };
398:
399: /* DEFINES */
400:
401: /* For PCMCIA cards, always use AUTOCONF */
402: #if defined(PCMCIA) || defined(MODULE)
403: #if !defined(AUTOCONF)
404: #define AUTOCONF
405: #endif
406: #endif
407:
408: #if !defined(AUTOCONF) && !defined(SETUP0)
409: #error define AUTOCONF or SETUP0
410: #endif
411:
412: #if defined(DEBUG_AHA152X)
413:
414: #undef SKIP_PORTS /* don't display ports */
415:
416: #undef DEBUG_QUEUE /* debug queue() */
417: #undef DEBUG_RESET /* debug reset() */
418: #undef DEBUG_INTR /* debug intr() */
419: #undef DEBUG_SELECTION /* debug selection part in intr() */
420: #undef DEBUG_MSGO /* debug message out phase in intr() */
421: #undef DEBUG_MSGI /* debug message in phase in intr() */
422: #undef DEBUG_STATUS /* debug status phase in intr() */
423: #undef DEBUG_CMD /* debug command phase in intr() */
424: #undef DEBUG_DATAI /* debug data in phase in intr() */
425: #undef DEBUG_DATAO /* debug data out phase in intr() */
426: #undef DEBUG_ABORT /* debug abort() */
427: #undef DEBUG_DONE /* debug done() */
428: #undef DEBUG_BIOSPARAM /* debug biosparam() */
429:
430: #undef DEBUG_RACE /* debug race conditions */
431: #undef DEBUG_PHASES /* debug phases (useful to trace) */
432: #undef DEBUG_QUEUES /* debug reselection */
433:
434: /* recently used for debugging */
435: #if 0
436: #endif
437:
438: #define DEBUG_SELECTION
439: #define DEBUG_PHASES
440: #define DEBUG_RESET
441: #define DEBUG_ABORT
442:
443: #define DEBUG_DEFAULT (debug_reset|debug_abort)
444:
445: #endif
446:
447: /* END OF DEFINES */
448:
449: extern unsigned long loops_per_sec;
450:
451: #define DELAY_DEFAULT 100
452:
453: /* some additional "phases" for getphase() */
454: #define P_BUSFREE 1
455: #define P_PARITY 2
456:
457: /* possible irq range */
458: #define IRQ_MIN 9
459: #define IRQ_MAX 12
460: #define IRQS IRQ_MAX-IRQ_MIN+1
461:
462: enum {
463: not_issued = 0x0001,
464: in_selection = 0x0002,
465: disconnected = 0x0004,
466: aborted = 0x0008,
467: sent_ident = 0x0010,
468: in_other = 0x0020,
469: in_sync = 0x0040,
470: sync_ok = 0x0080,
471: };
472:
473: #if defined(MODULE)
474: #if defined(DEBUG_AHA152X)
475: int aha152x[] = { 0, 11, 7, 1, 1, 0, DELAY_DEFAULT, 0, DEBUG_DEFAULT };
476: int aha152x1[] = { 0, 11, 7, 1, 1, 0, DELAY_DEFAULT, 0, DEBUG_DEFAULT };
477: #else
478: int aha152x[] = { 0, 11, 7, 1, 1, 0, DELAY_DEFAULT, 0 };
479: int aha152x1[] = { 0, 11, 7, 1, 1, 0, DELAY_DEFAULT, 0 };
480: #endif
481: #endif
482:
483: /* set by aha152x_setup according to the command line */
484: static int setup_count=0;
485: static struct aha152x_setup {
486: int io_port;
487: int irq;
488: int scsiid;
489: int reconnect;
490: int parity;
491: int synchronous;
492: int delay;
493: int ext_trans;
494: #ifdef DEBUG_AHA152X
495: int debug;
496: #endif
497: char *conf;
498: } setup[2];
499:
500: static struct Scsi_Host *aha152x_host[IRQS];
501:
502: #define HOSTDATA(shpnt) ((struct aha152x_hostdata *) &shpnt->hostdata)
503: #define CURRENT_SC (HOSTDATA(shpnt)->current_SC)
504: #define ISSUE_SC (HOSTDATA(shpnt)->issue_SC)
505: #define DISCONNECTED_SC (HOSTDATA(shpnt)->disconnected_SC)
506: #define DELAY (HOSTDATA(shpnt)->delay)
507: #define EXT_TRANS (HOSTDATA(shpnt)->ext_trans)
508: #define SYNCRATE (HOSTDATA(shpnt)->syncrate[CURRENT_SC->target])
509: #define MSG(i) (HOSTDATA(shpnt)->message[i])
510: #define MSGLEN (HOSTDATA(shpnt)->message_len)
511: #define ADDMSG(x) (MSG(MSGLEN++)=x)
512:
513: struct aha152x_hostdata {
514: Scsi_Cmnd *issue_SC;
515: Scsi_Cmnd *current_SC;
516: Scsi_Cmnd *disconnected_SC;
517: int aborting;
518: int abortion_complete;
519: int abort_result;
520: int commands;
521:
522: int reconnect;
523: int parity;
524: int synchronous;
525: int delay;
526: int ext_trans;
527:
528: int swint;
529:
530: unsigned char syncrate[8];
531:
532: unsigned char message[256];
533: int message_len;
534:
535: #ifdef DEBUG_AHA152X
536: int debug;
537: #endif
538: };
539:
540: void aha152x_intr(int irq, void *dev_id, struct pt_regs *);
541: void aha152x_done(struct Scsi_Host *shpnt, int error);
542: void aha152x_setup(char *str, int *ints);
543: int aha152x_checksetup(struct aha152x_setup *setup);
544:
545: static void aha152x_reset_ports(struct Scsi_Host *shpnt);
546: static void aha152x_panic(struct Scsi_Host *shpnt, char *msg);
547:
548: static void disp_ports(struct Scsi_Host *shpnt);
549: static void show_command(Scsi_Cmnd *ptr);
550: static void show_queues(struct Scsi_Host *shpnt);
551: static void disp_enintr(struct Scsi_Host *shpnt);
552:
553: #if defined(DEBUG_RACE)
554: static void enter_driver(const char *);
555: static void leave_driver(const char *);
556: #endif
557:
558: /* possible i/o addresses for the AIC-6260 */
559: static unsigned short ports[] =
560: {
561: 0x340, /* default first */
562: 0x140
563: };
564: #define PORT_COUNT (sizeof(ports) / sizeof(unsigned short))
565:
566: #if !defined(SKIP_BIOSTEST)
567: /* possible locations for the Adaptec BIOS */
568: static void *addresses[] =
569: {
570: (void *) 0xdc000, /* default first */
571: (void *) 0xc8000,
572: (void *) 0xcc000,
573: (void *) 0xd0000,
574: (void *) 0xd4000,
575: (void *) 0xd8000,
576: (void *) 0xe0000,
577: (void *) 0xeb800, /* VTech Platinum SMP */
578: (void *) 0xf0000,
579: };
580: #define ADDRESS_COUNT (sizeof(addresses) / sizeof(void *))
581:
582: /* signatures for various AIC-6[23]60 based controllers.
583: The point in detecting signatures is to avoid useless and maybe
584: harmful probes on ports. I'm not sure that all listed boards pass
585: auto-configuration. For those which fail the BIOS signature is
586: obsolete, because user intervention to supply the configuration is
587: needed anyway. May be an information whether or not the BIOS supports
588: extended translation could be also useful here. */
589: static struct signature {
590: char *signature;
591: int sig_offset;
592: int sig_length;
593: } signatures[] =
594: {
595: { "Adaptec AHA-1520 BIOS", 0x102e, 21 }, /* Adaptec 152x */
596: { "Adaptec AHA-1520B", 0x0b, 17 }, /* Adaptec 152x rev B */
597: { "Adaptec AHA-1520B/1522B", 0x3e20, 23 }, /* Adaptec 1520B/1522B */
598: { "Adaptec ASW-B626 BIOS", 0x1029, 21 }, /* on-board controller */
599: { "Adaptec BIOS: ASW-B626", 0x0f, 22 }, /* on-board controller */
600: { "Adaptec ASW-B626 S2", 0x2e6c, 19 }, /* on-board controller */
601: { "Adaptec BIOS:AIC-6360", 0xc, 21 }, /* on-board controller */
602: { "ScsiPro SP-360 BIOS", 0x2873, 19 }, /* ScsiPro-Controller */
603: { "GA-400 LOCAL BUS SCSI BIOS", 0x102e, 26 }, /* Gigabyte Local-Bus-SCSI */
604: { "Adaptec BIOS:AVA-282X", 0xc, 21 }, /* Adaptec 282x */
605: { "Adaptec IBM Dock II SCSI", 0x2edd, 24 }, /* IBM Thinkpad Dock II */
606: { "Adaptec BIOS:AHA-1532P", 0x1c, 22 }, /* IBM Thinkpad Dock II SCSI */
607: };
608: #define SIGNATURE_COUNT (sizeof(signatures) / sizeof(struct signature))
609: #endif
610:
611:
612: static void do_pause(unsigned amount) /* Pause for amount*10 milliseconds */
613: {
614: unsigned long the_time = jiffies + amount; /* 0.01 seconds per jiffy */
615:
616: while (jiffies < the_time)
617: barrier();
618: }
619:
620: /*
621: * queue services:
622: */
623: static inline void append_SC(Scsi_Cmnd **SC, Scsi_Cmnd *new_SC)
624: {
625: Scsi_Cmnd *end;
626:
627: new_SC->host_scribble = (unsigned char *) NULL;
628: if(!*SC)
629: *SC=new_SC;
630: else {
631: for(end=*SC; end->host_scribble; end = (Scsi_Cmnd *) end->host_scribble)
632: ;
633: end->host_scribble = (unsigned char *) new_SC;
634: }
635: }
636:
637: static inline Scsi_Cmnd *remove_first_SC(Scsi_Cmnd **SC)
638: {
639: Scsi_Cmnd *ptr;
640:
641: ptr=*SC;
642: if(ptr)
643: *SC= (Scsi_Cmnd *) (*SC)->host_scribble;
644: return ptr;
645: }
646:
647: static inline Scsi_Cmnd *remove_SC(Scsi_Cmnd **SC, int target, int lun)
648: {
649: Scsi_Cmnd *ptr, *prev;
650:
651: for(ptr=*SC, prev=NULL;
652: ptr && ((ptr->target!=target) || (ptr->lun!=lun));
653: prev = ptr, ptr = (Scsi_Cmnd *) ptr->host_scribble)
654: ;
655:
656: if(ptr){
657: if(prev)
658: prev->host_scribble = ptr->host_scribble;
659: else
660: *SC= (Scsi_Cmnd *) ptr->host_scribble;
661: }
662:
663: return ptr;
664: }
665:
666: /*
667: * read inbound byte and wait for ACK to get low
668: */
669: static void make_acklow(struct Scsi_Host *shpnt)
670: {
671: SETPORT(SXFRCTL0, CH1|SPIOEN);
672: GETPORT(SCSIDAT);
673: SETPORT(SXFRCTL0, CH1);
674:
675: while(TESTHI(SCSISIG, ACKI))
676: barrier();
677: }
678:
679: /*
680: * detect current phase more reliable:
681: * phase is valid, when the target asserts REQ after we've deasserted ACK.
682: *
683: * return value is a valid phase or an error code.
684: *
685: * errorcodes:
686: * P_BUSFREE BUS FREE phase detected
687: * P_PARITY parity error in DATA phase
688: */
689: static int getphase(struct Scsi_Host *shpnt)
690: {
691: int phase, sstat1;
692:
693: while(1) {
694: do {
695: while(!((sstat1 = GETPORT(SSTAT1)) & (BUSFREE|SCSIRSTI|REQINIT)))
696: barrier();
697: if(sstat1 & BUSFREE)
698: return P_BUSFREE;
699: if(sstat1 & SCSIRSTI) {
700: printk("aha152x: RESET IN\n");
701: SETPORT(SSTAT1, SCSIRSTI);
702: }
703: } while(TESTHI(SCSISIG, ACKI) || TESTLO(SSTAT1, REQINIT));
704:
705: SETPORT(SSTAT1, CLRSCSIPERR);
706:
707: phase = GETPORT(SCSISIG) & P_MASK ;
708:
709: if(TESTHI(SSTAT1, SCSIPERR)) {
710: if((phase & (CDO|MSGO))==0) /* DATA phase */
711: return P_PARITY;
712:
713: make_acklow(shpnt);
714: } else
715: return phase;
716: }
717: }
718:
719: /* called from init/main.c */
720: void aha152x_setup(char *str, int *ints)
721: {
722: if(setup_count>2)
723: panic("aha152x: you can only configure up to two controllers\n");
724:
725: setup[setup_count].conf = str;
726: setup[setup_count].io_port = ints[0] >= 1 ? ints[1] : 0x340;
727: setup[setup_count].irq = ints[0] >= 2 ? ints[2] : 11;
728: setup[setup_count].scsiid = ints[0] >= 3 ? ints[3] : 7;
729: setup[setup_count].reconnect = ints[0] >= 4 ? ints[4] : 1;
730: setup[setup_count].parity = ints[0] >= 5 ? ints[5] : 1;
731: setup[setup_count].synchronous = ints[0] >= 6 ? ints[6] : 0 /* FIXME: 1 */;
732: setup[setup_count].delay = ints[0] >= 7 ? ints[7] : DELAY_DEFAULT;
733: setup[setup_count].ext_trans = ints[0] >= 8 ? ints[8] : 0;
734: #ifdef DEBUG_AHA152X
735: setup[setup_count].debug = ints[0] >= 9 ? ints[9] : DEBUG_DEFAULT;
736: if(ints[0]>9) {
737: printk("aha152x: usage: aha152x=<IOBASE>[,<IRQ>[,<SCSI ID>"
738: "[,<RECONNECT>[,<PARITY>[,<SYNCHRONOUS>[,<DELAY>[,<EXT_TRANS>[,<DEBUG>]]]]]]]]\n");
739: #else
740: if(ints[0]>8) {
741: printk("aha152x: usage: aha152x=<IOBASE>[,<IRQ>[,<SCSI ID>"
742: "[,<RECONNECT>[,<PARITY>[,<SYNCHRONOUS>[,<DELAY>[,<EXT_TRANS>]]]]]]]\n");
743: #endif
744: } else
745: setup_count++;
746: }
747:
748: /*
749: * Test, if port_base is valid.
750: */
751: static int aha152x_porttest(int io_port)
752: {
753: int i;
754:
755: if(check_region(io_port, IO_RANGE))
756: return 0;
757:
758: SETPORT(io_port+O_DMACNTRL1, 0); /* reset stack pointer */
759: for(i=0; i<16; i++)
760: SETPORT(io_port+O_STACK, i);
761:
762: SETPORT(io_port+O_DMACNTRL1, 0); /* reset stack pointer */
763: for(i=0; i<16 && GETPORT(io_port+O_STACK)==i; i++)
764: ;
765:
766: return(i==16);
767: }
768:
769: int aha152x_checksetup(struct aha152x_setup *setup)
770: {
771: int i;
772:
773: #ifndef PCMCIA
774: for(i=0; i<PORT_COUNT && (setup->io_port != ports[i]); i++)
775: ;
776:
777: if(i==PORT_COUNT)
778: return 0;
779: #endif
780:
781: if(!aha152x_porttest(setup->io_port))
782: return 0;
783:
784: if(setup->irq<IRQ_MIN && setup->irq>IRQ_MAX)
785: return 0;
786:
787: if((setup->scsiid < 0) || (setup->scsiid > 7))
788: return 0;
789:
790: if((setup->reconnect < 0) || (setup->reconnect > 1))
791: return 0;
792:
793: if((setup->parity < 0) || (setup->parity > 1))
794: return 0;
795:
796: if((setup->synchronous < 0) || (setup->synchronous > 1))
797: return 0;
798:
799: if((setup->ext_trans < 0) || (setup->ext_trans > 1))
800: return 0;
801:
802:
803: return 1;
804: }
805:
806: void aha152x_swintr(int irqno, void *dev_id, struct pt_regs * regs)
807: {
808: struct Scsi_Host *shpnt = aha152x_host[irqno-IRQ_MIN];
809:
810: if(!shpnt)
811: panic("aha152x: catched software interrupt for unknown controller.\n");
812:
813: HOSTDATA(shpnt)->swint++;
814: }
815:
816:
817: int aha152x_detect(Scsi_Host_Template * tpnt)
818: {
819: int i, j, ok;
820: #if defined(AUTOCONF)
821: aha152x_config conf;
822: #endif
823:
824: tpnt->proc_dir = &proc_scsi_aha152x;
825:
826: for(i=0; i<IRQS; i++)
827: aha152x_host[i] = (struct Scsi_Host *) NULL;
828:
829: if(setup_count) {
830: printk("aha152x: processing commandline: ");
831:
832: for(i=0; i<setup_count; i++)
833: if(!aha152x_checksetup(&setup[i])) {
834: printk("\naha152x: %s\n", setup[i].conf);
835: printk("aha152x: invalid line (controller=%d)\n", i+1);
836: }
837:
838: printk("ok\n");
839: }
840:
841: #ifdef SETUP0
842: if(setup_count<2) {
843: struct aha152x_setup override = SETUP0;
844:
845: if(setup_count==0 || (override.io_port != setup[0].io_port))
846: if(!aha152x_checksetup(&override)) {
847: printk("\naha152x: invalid override SETUP0={0x%x,%d,%d,%d,%d,%d,%d,%d}\n",
848: override.io_port,
849: override.irq,
850: override.scsiid,
851: override.reconnect,
852: override.parity,
853: override.synchronous,
854: override.delay,
855: override.ext_trans);
856: } else
857: setup[setup_count++] = override;
858: }
859: #endif
860:
861: #ifdef SETUP1
862: if(setup_count<2) {
863: struct aha152x_setup override = SETUP1;
864:
865: if(setup_count==0 || (override.io_port != setup[0].io_port))
866: if(!aha152x_checksetup(&override)) {
867: printk("\naha152x: invalid override SETUP1={0x%x,%d,%d,%d,%d,%d,%d,%d}\n",
868: override.io_port,
869: override.irq,
870: override.scsiid,
871: override.reconnect,
872: override.parity,
873: override.synchronous,
874: override.delay,
875: override.ext_trans);
876: } else
877: setup[setup_count++] = override;
878: }
879: #endif
880:
881: #if defined(MODULE)
882: if(setup_count<2 && aha152x[0]!=0) {
883: setup[setup_count].conf = "";
884: setup[setup_count].io_port = aha152x[0];
885: setup[setup_count].irq = aha152x[1];
886: setup[setup_count].scsiid = aha152x[2];
887: setup[setup_count].reconnect = aha152x[3];
888: setup[setup_count].parity = aha152x[4];
889: setup[setup_count].synchronous = aha152x[5];
890: setup[setup_count].delay = aha152x[6];
891: setup[setup_count].ext_trans = aha152x[7];
892: #ifdef DEBUG_AHA152X
893: setup[setup_count].debug = aha152x[8];
894: #endif
895: if(aha152x_checksetup(&setup[setup_count]))
896: setup_count++;
897: else
898: printk("\naha152x: invalid module argument aha152x=0x%x,%d,%d,%d,%d,%d,%d,%d\n",
899: setup[setup_count].io_port,
900: setup[setup_count].irq,
901: setup[setup_count].scsiid,
902: setup[setup_count].reconnect,
903: setup[setup_count].parity,
904: setup[setup_count].synchronous,
905: setup[setup_count].delay,
906: setup[setup_count].ext_trans);
907: }
908:
909: if(setup_count<2 && aha152x1[0]!=0) {
910: setup[setup_count].conf = "";
911: setup[setup_count].io_port = aha152x1[0];
912: setup[setup_count].irq = aha152x1[1];
913: setup[setup_count].scsiid = aha152x1[2];
914: setup[setup_count].reconnect = aha152x1[3];
915: setup[setup_count].parity = aha152x1[4];
916: setup[setup_count].synchronous = aha152x1[5];
917: setup[setup_count].delay = aha152x1[6];
918: setup[setup_count].ext_trans = aha152x1[7];
919: #ifdef DEBUG_AHA152X
920: setup[setup_count].debug = aha152x1[8];
921: #endif
922: if(aha152x_checksetup(&setup[setup_count]))
923: setup_count++;
924: else
925: printk("\naha152x: invalid module argument aha152x1=0x%x,%d,%d,%d,%d,%d,%d,%d\n",
926: setup[setup_count].io_port,
927: setup[setup_count].irq,
928: setup[setup_count].scsiid,
929: setup[setup_count].reconnect,
930: setup[setup_count].parity,
931: setup[setup_count].synchronous,
932: setup[setup_count].delay,
933: setup[setup_count].ext_trans);
934: }
935: #endif
936:
937: #if defined(AUTOCONF)
938: if(setup_count<2) {
939: #if !defined(SKIP_BIOSTEST)
940: ok=0;
941: for(i=0; i < ADDRESS_COUNT && !ok; i++)
942: for(j=0; (j < SIGNATURE_COUNT) && !ok; j++)
943: ok=!memcmp((void *) addresses[i]+signatures[j].sig_offset,
944: (void *) signatures[j].signature,
945: (int) signatures[j].sig_length);
946:
947: if(!ok && setup_count==0)
948: return 0;
949:
950: printk("aha152x: BIOS test: passed, ");
951: #else
952: printk("aha152x: ");
953: #endif /* !SKIP_BIOSTEST */
954:
955: ok=0;
956: for(i=0; i<PORT_COUNT && setup_count<2; i++) {
957: if((setup_count==1) && (setup[0].io_port == ports[i]))
958: continue;
959:
960: if(aha152x_porttest(ports[i])) {
961: ok++;
962: setup[setup_count].io_port = ports[i];
963:
964: conf.cf_port =
965: (GETPORT(ports[i]+O_PORTA)<<8) + GETPORT(ports[i]+O_PORTB);
966:
967: setup[setup_count].irq = IRQ_MIN + conf.cf_irq;
968: setup[setup_count].scsiid = conf.cf_id;
969: setup[setup_count].reconnect = conf.cf_tardisc;
970: setup[setup_count].parity = !conf.cf_parity;
971: setup[setup_count].synchronous = 0 /* FIXME: conf.cf_syncneg */;
972: setup[setup_count].delay = DELAY_DEFAULT;
973: setup[setup_count].ext_trans = 0;
974: #ifdef DEBUG_AHA152X
975: setup[setup_count].debug = DEBUG_DEFAULT;
976: #endif
977: setup_count++;
978: }
979: }
980:
981: if(ok)
982: printk("auto configuration: ok, ");
983: }
984: #endif
985:
986: printk("detected %d controller(s)\n", setup_count);
987:
988: for(i=0; i<setup_count; i++) {
989: struct Scsi_Host *shpnt;
990: unsigned long int the_time;
991:
992: shpnt = aha152x_host[setup[i].irq-IRQ_MIN] =
993: scsi_register(tpnt, sizeof(struct aha152x_hostdata));
994:
995: shpnt->io_port = setup[i].io_port;
996: shpnt->n_io_port = IO_RANGE;
997: shpnt->irq = setup[i].irq;
998:
999: ISSUE_SC = (Scsi_Cmnd *) NULL;
1000: CURRENT_SC = (Scsi_Cmnd *) NULL;
1001: DISCONNECTED_SC = (Scsi_Cmnd *) NULL;
1002:
1003: HOSTDATA(shpnt)->reconnect = setup[i].reconnect;
1004: HOSTDATA(shpnt)->parity = setup[i].parity;
1005: HOSTDATA(shpnt)->synchronous = setup[i].synchronous;
1006: HOSTDATA(shpnt)->delay = setup[i].delay;
1007: HOSTDATA(shpnt)->ext_trans = setup[i].ext_trans;
1008: #ifdef DEBUG_AHA152X
1009: HOSTDATA(shpnt)->debug = setup[i].debug;
1010: #endif
1011:
1012: HOSTDATA(shpnt)->aborting = 0;
1013: HOSTDATA(shpnt)->abortion_complete = 0;
1014: HOSTDATA(shpnt)->abort_result = 0;
1015: HOSTDATA(shpnt)->commands = 0;
1016:
1017: HOSTDATA(shpnt)->message_len = 0;
1018:
1019: for(j=0; j<8; j++)
1020: HOSTDATA(shpnt)->syncrate[j] = 0;
1021:
1022: SETPORT(SCSIID, setup[i].scsiid << 4);
1023: shpnt->this_id=setup[i].scsiid;
1024:
1025: if(setup[i].reconnect)
1026: shpnt->can_queue=AHA152X_MAXQUEUE;
1027:
1028: /* RESET OUT */
1029: SETBITS(SCSISEQ, SCSIRSTO);
1030: do_pause(30);
1031: CLRBITS(SCSISEQ, SCSIRSTO);
1032: do_pause(setup[i].delay);
1033:
1034: aha152x_reset_ports(shpnt);
1035:
1036: printk("aha152x%d: vital data: PORTBASE=0x%03x, IRQ=%d, SCSI ID=%d,"
1037: " reconnect=%s, parity=%s, synchronous=%s, delay=%d, extended translation=%s\n",
1038: i,
1039: shpnt->io_port,
1040: shpnt->irq,
1041: shpnt->this_id,
1042: HOSTDATA(shpnt)->reconnect ? "enabled" : "disabled",
1043: HOSTDATA(shpnt)->parity ? "enabled" : "disabled",
1044: HOSTDATA(shpnt)->synchronous ? "enabled" : "disabled",
1045: HOSTDATA(shpnt)->delay,
1046: HOSTDATA(shpnt)->ext_trans ? "enabled" : "disabled");
1047:
1048: request_region(shpnt->io_port, IO_RANGE, "aha152x"); /* Register */
1049:
1050: /* not expecting any interrupts */
1051: SETPORT(SIMODE0, 0);
1052: SETPORT(SIMODE1, 0);
1053:
1054: SETBITS(DMACNTRL0, INTEN);
1055:
1056: ok = request_irq(shpnt->irq, aha152x_swintr, SA_INTERRUPT, "aha152x", NULL);
1057: if(ok<0) {
1058: if(ok == -EINVAL)
1059: printk("aha152x%d: bad IRQ %d.\n", i, shpnt->irq);
1060: else if(ok == -EBUSY)
1061: printk("aha152x%d: IRQ %d already in use.\n", i, shpnt->irq);
1062: else
1063: printk("\naha152x%d: Unexpected error code %d on requesting IRQ %d.\n", i, ok, shpnt->irq);
1064: printk("aha152x: driver needs an IRQ.\n");
1065:
1066: scsi_unregister(shpnt);
1067: shpnt=aha152x_host[shpnt->irq-IRQ_MIN]=0;
1068: continue;
1069: }
1070:
1071: HOSTDATA(shpnt)->swint=0;
1072:
1073: printk("aha152x: trying software interrupt, ");
1074: SETBITS(DMACNTRL0, SWINT);
1075:
1076: the_time=jiffies+100;
1077: while(!HOSTDATA(shpnt)->swint && jiffies<the_time)
1078: barrier();
1079:
1080: free_irq(shpnt->irq,0);
1081:
1082: if(!HOSTDATA(shpnt)->swint) {
1083: if(TESTHI(DMASTAT, INTSTAT)) {
1084: printk("lost.\n");
1085: } else {
1086: printk("failed.\n");
1087: }
1088:
1089: printk("aha152x: IRQ %d possibly wrong. Please verify.\n", shpnt->irq);
1090:
1091: scsi_unregister(shpnt);
1092: shpnt=aha152x_host[shpnt->irq-IRQ_MIN]=0;
1093: continue;
1094: }
1095:
1096: printk("ok.\n");
1097:
1098: CLRBITS(DMACNTRL0, SWINT);
1099:
1100: /* clear interrupts */
1101: SETPORT(SSTAT0, 0x7f);
1102: SETPORT(SSTAT1, 0xef);
1103:
1104: if(request_irq(shpnt->irq,aha152x_intr,SA_INTERRUPT,"aha152x",NULL)<0) {
1105: printk("aha152x: failed to reassign interrupt.\n");
1106: }
1107: }
1108:
1109: return (setup_count>0);
1110: }
1111:
1112: /*
1113: * Queue a command and setup interrupts for a free bus.
1114: */
1115: int aha152x_queue(Scsi_Cmnd * SCpnt, void (*done)(Scsi_Cmnd *))
1116: {
1117: struct Scsi_Host *shpnt = SCpnt->host;
1118: unsigned long flags;
1119:
1120: #if defined(DEBUG_RACE)
1121: enter_driver("queue");
1122: #else
1123: #if defined(DEBUG_QUEUE)
1124: if(HOSTDATA(shpnt)->debug & debug_queue)
1125: printk("aha152x: queue(), ");
1126: #endif
1127: #endif
1128:
1129: #if defined(DEBUG_QUEUE)
1130: if(HOSTDATA(shpnt)->debug & debug_queue) {
1131: printk("SCpnt (target = %d lun = %d cmnd = ",
1132: SCpnt->target, SCpnt->lun);
1133: print_command(SCpnt->cmnd);
1134: printk(", cmd_len=%d, pieces = %d size = %u), ",
1135: SCpnt->cmd_len, SCpnt->use_sg, SCpnt->request_bufflen);
1136: disp_ports(shpnt);
1137: }
1138: #endif
1139:
1140: SCpnt->scsi_done = done;
1141:
1142: /* setup scratch area
1143: SCp.ptr : buffer pointer
1144: SCp.this_residual : buffer length
1145: SCp.buffer : next buffer
1146: SCp.buffers_residual : left buffers in list
1147: SCp.phase : current state of the command */
1148: SCpnt->SCp.phase = not_issued;
1149: if (SCpnt->use_sg) {
1150: SCpnt->SCp.buffer = (struct scatterlist *) SCpnt->request_buffer;
1151: SCpnt->SCp.ptr = SCpnt->SCp.buffer->address;
1152: SCpnt->SCp.this_residual = SCpnt->SCp.buffer->length;
1153: SCpnt->SCp.buffers_residual = SCpnt->use_sg - 1;
1154: } else {
1155: SCpnt->SCp.ptr = (char *)SCpnt->request_buffer;
1156: SCpnt->SCp.this_residual = SCpnt->request_bufflen;
1157: SCpnt->SCp.buffer = NULL;
1158: SCpnt->SCp.buffers_residual = 0;
1159: }
1160:
1161: SCpnt->SCp.Status = CHECK_CONDITION;
1162: SCpnt->SCp.Message = 0;
1163: SCpnt->SCp.have_data_in = 0;
1164: SCpnt->SCp.sent_command = 0;
1165:
1166: /* Turn led on, when this is the first command. */
1167: save_flags(flags);
1168: cli();
1169: HOSTDATA(shpnt)->commands++;
1170: if(HOSTDATA(shpnt)->commands==1)
1171: SETPORT(PORTA, 1);
1172:
1173: #if defined(DEBUG_QUEUES)
1174: if(HOSTDATA(shpnt)->debug & debug_queues)
1175: printk("i+ (%d), ", HOSTDATA(shpnt)->commands);
1176: #endif
1177: append_SC(&ISSUE_SC, SCpnt);
1178:
1179: /* Enable bus free interrupt, when we aren't currently on the bus */
1180: if(!CURRENT_SC) {
1181: SETPORT(SIMODE0, DISCONNECTED_SC ? ENSELDI : 0);
1182: SETPORT(SIMODE1, ISSUE_SC ? ENBUSFREE : 0);
1183: }
1184: restore_flags(flags);
1185:
1186: #if defined(DEBUG_RACE)
1187: leave_driver("queue");
1188: #endif
1189:
1190: return 0;
1191: }
1192:
1193: /*
1194: * We only support commands in interrupt-driven fashion
1195: */
1196: int aha152x_command(Scsi_Cmnd *SCpnt)
1197: {
1198: printk("aha152x: interrupt driven driver; use aha152x_queue()\n");
1199: return -1;
1200: }
1201:
1202: /*
1203: * Abort a queued command
1204: * (commands that are on the bus can't be aborted easily)
1205: */
1206: int aha152x_abort(Scsi_Cmnd *SCpnt)
1207: {
1208: struct Scsi_Host *shpnt = SCpnt->host;
1209: unsigned long flags;
1210: Scsi_Cmnd *ptr, *prev;
1211:
1212: save_flags(flags);
1213: cli();
1214:
1215: #if defined(DEBUG_ABORT)
1216: if(HOSTDATA(shpnt)->debug & debug_abort) {
1217: printk("aha152x: abort(), SCpnt=0x%08x, ", (unsigned int) SCpnt);
1218: show_queues(shpnt);
1219: }
1220: #endif
1221:
1222: /* look for command in issue queue */
1223: for(ptr=ISSUE_SC, prev=NULL;
1224: ptr && ptr!=SCpnt;
1225: prev=ptr, ptr=(Scsi_Cmnd *) ptr->host_scribble)
1226: ;
1227:
1228: if(ptr) {
1229: /* dequeue */
1230: if(prev)
1231: prev->host_scribble = ptr->host_scribble;
1232: else
1233: ISSUE_SC = (Scsi_Cmnd *) ptr->host_scribble;
1234:
1235: HOSTDATA(shpnt)->commands--;
1236:
1237: restore_flags(flags);
1238:
1239: ptr->host_scribble = NULL;
1240: ptr->result = DID_ABORT << 16;
1241: ptr->scsi_done(ptr);
1242:
1243: return SCSI_ABORT_SUCCESS;
1244: }
1245:
1246: /* if the bus is busy or a command is currently processed,
1247: we can't do anything more */
1248: if (TESTLO(SSTAT1, BUSFREE) || (CURRENT_SC && CURRENT_SC!=SCpnt)) {
1249: /* fail abortion, if bus is busy */
1250:
1251: if(!CURRENT_SC)
1252: printk("bus busy w/o current command, ");
1253:
1254: restore_flags(flags);
1255:
1256: return SCSI_ABORT_BUSY;
1257: }
1258:
1259: /* bus is free */
1260:
1261: if(CURRENT_SC) {
1262: HOSTDATA(shpnt)->commands--;
1263:
1264: /* target entered bus free before COMMAND COMPLETE, nothing to abort */
1265: restore_flags(flags);
1266: CURRENT_SC->result = DID_ERROR << 16;
1267: CURRENT_SC->scsi_done(CURRENT_SC);
1268: CURRENT_SC = (Scsi_Cmnd *) NULL;
1269:
1270: return SCSI_ABORT_SUCCESS;
1271: }
1272:
1273: /* look for command in disconnected queue */
1274: for(ptr=DISCONNECTED_SC, prev=NULL;
1275: ptr && ptr!=SCpnt;
1276: prev=ptr, ptr=(Scsi_Cmnd *) ptr->host_scribble)
1277: ;
1278:
1279: if(!ptr) {
1280: /* command wasn't found */
1281: printk("command not found\n");
1282: restore_flags(flags);
1283:
1284: return SCSI_ABORT_NOT_RUNNING;
1285: }
1286:
1287: if(!HOSTDATA(shpnt)->aborting) {
1288: /* dequeue */
1289: if(prev)
1290: prev->host_scribble = ptr->host_scribble;
1291: else
1292: DISCONNECTED_SC = (Scsi_Cmnd *) ptr->host_scribble;
1293:
1294: HOSTDATA(shpnt)->commands--;
1295:
1296: /* set command current and initiate selection,
1297: let the interrupt routine take care of the abortion */
1298: CURRENT_SC = ptr;
1299: ptr->SCp.phase = in_selection|aborted;
1300: SETPORT(SCSIID, (shpnt->this_id << OID_) | CURRENT_SC->target);
1301:
1302: ADDMSG(ABORT);
1303:
1304: /* enable interrupts for SELECTION OUT DONE and SELECTION TIME OUT */
1305: SETPORT(SIMODE0, ENSELDO | (DISCONNECTED_SC ? ENSELDI : 0));
1306: SETPORT(SIMODE1, ENSELTIMO);
1307:
1308: /* Enable SELECTION OUT sequence */
1309: SETBITS(SCSISEQ, ENSELO | ENAUTOATNO);
1310:
1311: SETBITS(DMACNTRL0, INTEN);
1312: HOSTDATA(shpnt)->abort_result=SCSI_ABORT_SUCCESS;
1313: HOSTDATA(shpnt)->aborting++;
1314: HOSTDATA(shpnt)->abortion_complete=0;
1315:
1316: sti(); /* Hi Eric, guess what ;-) */
1317:
1318: /* sleep until the abortion is complete */
1319: while(!HOSTDATA(shpnt)->abortion_complete)
1320: barrier();
1321: HOSTDATA(shpnt)->aborting=0;
1322:
1323: return HOSTDATA(shpnt)->abort_result;
1324: } else {
1325: /* we're already aborting a command */
1326: restore_flags(flags);
1327:
1328: return SCSI_ABORT_BUSY;
1329: }
1330: }
1331:
1332: /*
1333: * Restore default values to the AIC-6260 registers and reset the fifos
1334: */
1335: static void aha152x_reset_ports(struct Scsi_Host *shpnt)
1336: {
1337: /* disable interrupts */
1338: SETPORT(DMACNTRL0, RSTFIFO);
1339:
1340: SETPORT(SCSISEQ, 0);
1341:
1342: SETPORT(SXFRCTL1, 0);
1343: SETPORT(SCSISIG, 0);
1344: SETPORT(SCSIRATE, 0);
1345:
1346: /* clear all interrupt conditions */
1347: SETPORT(SSTAT0, 0x7f);
1348: SETPORT(SSTAT1, 0xef);
1349:
1350: SETPORT(SSTAT4, SYNCERR|FWERR|FRERR);
1351:
1352: SETPORT(DMACNTRL0, 0);
1353: SETPORT(DMACNTRL1, 0);
1354:
1355: SETPORT(BRSTCNTRL, 0xf1);
1356:
1357: /* clear SCSI fifo and transfer count */
1358: SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
1359: SETPORT(SXFRCTL0, CH1);
1360:
1361: /* enable interrupts */
1362: SETPORT(SIMODE0, DISCONNECTED_SC ? ENSELDI : 0);
1363: SETPORT(SIMODE1, ISSUE_SC ? ENBUSFREE : 0);
1364: }
1365:
1366: /*
1367: * Reset registers, reset a hanging bus and
1368: * kill active and disconnected commands for target w/o soft reset
1369: */
1370: int aha152x_reset(Scsi_Cmnd *SCpnt, unsigned int unused)
1371: {
1372: struct Scsi_Host *shpnt = SCpnt->host;
1373: unsigned long flags;
1374: Scsi_Cmnd *ptr, *prev, *next;
1375:
1376: aha152x_reset_ports(shpnt);
1377:
1378: /* Reset, if bus hangs */
1379: if(TESTLO(SSTAT1, BUSFREE)) {
1380: CLRBITS(DMACNTRL0, INTEN);
1381:
1382: #if defined(DEBUG_RESET)
1383: if(HOSTDATA(shpnt)->debug & debug_reset) {
1384: printk("aha152x: reset(), bus not free: SCSI RESET OUT\n");
1385: show_queues(shpnt);
1386: }
1387: #endif
1388:
1389: ptr=CURRENT_SC;
1390: if(ptr && !ptr->device->soft_reset) {
1391: ptr->host_scribble = NULL;
1392: ptr->result = DID_RESET << 16;
1393: ptr->scsi_done(CURRENT_SC);
1394: CURRENT_SC=NULL;
1395: }
1396:
1397: save_flags(flags);
1398: cli();
1399: prev=NULL; ptr=DISCONNECTED_SC;
1400: while(ptr) {
1401: if(!ptr->device->soft_reset) {
1402: if(prev)
1403: prev->host_scribble = ptr->host_scribble;
1404: else
1405: DISCONNECTED_SC = (Scsi_Cmnd *) ptr->host_scribble;
1406:
1407: next = (Scsi_Cmnd *) ptr->host_scribble;
1408:
1409: ptr->host_scribble = NULL;
1410: ptr->result = DID_RESET << 16;
1411: ptr->scsi_done(ptr);
1412:
1413: ptr = next;
1414: } else {
1415: prev=ptr;
1416: ptr = (Scsi_Cmnd *) ptr->host_scribble;
1417: }
1418: }
1419: restore_flags(flags);
1420:
1421: #if defined(DEBUG_RESET)
1422: if(HOSTDATA(shpnt)->debug & debug_reset) {
1423: printk("commands on targets w/ soft-resets:\n");
1424: show_queues(shpnt);
1425: }
1426: #endif
1427:
1428: /* RESET OUT */
1429: SETPORT(SCSISEQ, SCSIRSTO);
1430: do_pause(30);
1431: SETPORT(SCSISEQ, 0);
1432: do_pause(DELAY);
1433:
1434: SETPORT(SIMODE0, DISCONNECTED_SC ? ENSELDI : 0);
1435: SETPORT(SIMODE1, ISSUE_SC ? ENBUSFREE : 0);
1436:
1437: SETPORT(DMACNTRL0, INTEN);
1438: }
1439:
1440: return SCSI_RESET_SUCCESS;
1441: }
1442:
1443: /*
1444: * Return the "logical geometry"
1445: */
1446: int aha152x_biosparam(Scsi_Disk * disk, kdev_t dev, int *info_array)
1447: {
1448: struct Scsi_Host *shpnt=disk->device->host;
1449:
1450: #if defined(DEBUG_BIOSPARAM)
1451: if(HOSTDATA(shpnt)->debug & debug_biosparam)
1452: printk("aha152x_biosparam: dev=%s, size=%d, ",
1453: kdevname(dev), disk->capacity);
1454: #endif
1455:
1456: /* try default translation */
1457: info_array[0]=64;
1458: info_array[1]=32;
1459: info_array[2]=disk->capacity / (64 * 32);
1460:
1461: /* for disks >1GB do some guessing */
1462: if(info_array[2]>=1024) {
1463: int info[3];
1464:
1465: /* try to figure out the geometry from the partition table */
1466: if(scsicam_bios_param(disk, dev, info)<0 ||
1467: !((info[0]==64 && info[1]==32) || (info[0]==255 && info[1]==63))) {
1468: if(EXT_TRANS) {
1469: printk("aha152x: unable to verify geometry for disk with >1GB.\n"
1470: " using extended translation.\n");
1471: info_array[0] = 255;
1472: info_array[1] = 63;
1473: info_array[2] = disk->capacity / (255 * 63);
1474: } else {
1475: printk("aha152x: unable to verify geometry for disk with >1GB.\n"
1476: " Using default translation. Please verify yourself.\n"
1477: " Perhaps you need to enable extended translation in the driver.\n"
1478: " See /usr/src/linux/drivers/scsi/aha152x.c for details.\n");
1479: }
1480: } else {
1481: info_array[0]=info[0];
1482: info_array[1]=info[1];
1483: info_array[2]=info[2];
1484:
1485: if(info[0]==255 && !EXT_TRANS) {
1486: printk("aha152x: current partition table is using extended translation.\n"
1487: " using it also, although it's not explicty enabled.\n");
1488: }
1489: }
1490: }
1491:
1492: #if defined(DEBUG_BIOSPARAM)
1493: if(HOSTDATA(shpnt)->debug & debug_biosparam) {
1494: printk("bios geometry: head=%d, sec=%d, cyl=%d\n",
1495: info_array[0], info_array[1], info_array[2]);
1496: printk("WARNING: check, if the bios geometry is correct.\n");
1497: }
1498: #endif
1499:
1500: return 0;
1501: }
1502:
1503: /*
1504: * Internal done function
1505: */
1506: void aha152x_done(struct Scsi_Host *shpnt, int error)
1507: {
1508: unsigned long flags;
1509: Scsi_Cmnd *done_SC;
1510:
1511: #if defined(DEBUG_DONE)
1512: if(HOSTDATA(shpnt)->debug & debug_done) {
1513: printk("\naha152x: done(), ");
1514: disp_ports(shpnt);
1515: }
1516: #endif
1517:
1518: if(CURRENT_SC) {
1519: #if defined(DEBUG_DONE)
1520: if(HOSTDATA(shpnt)->debug & debug_done)
1521: printk("done(%x), ", error);
1522: #endif
1523:
1524: save_flags(flags);
1525: cli();
1526:
1527: done_SC = CURRENT_SC;
1528: CURRENT_SC = NULL;
1529:
1530: /* turn led off, when no commands are in the driver */
1531: HOSTDATA(shpnt)->commands--;
1532: if(!HOSTDATA(shpnt)->commands)
1533: SETPORT(PORTA, 0); /* turn led off */
1534:
1535: #if defined(DEBUG_QUEUES)
1536: if(HOSTDATA(shpnt)->debug & debug_queues)
1537: printk("ok (%d), ", HOSTDATA(shpnt)->commands);
1538: #endif
1539: restore_flags(flags);
1540:
1541: SETPORT(SIMODE0, DISCONNECTED_SC ? ENSELDI : 0);
1542: SETPORT(SIMODE1, ISSUE_SC ? ENBUSFREE : 0);
1543:
1544: #if 0
1545: /* Why poll for the BUS FREE phase, when we have setup the interrupt!? */
1546: #if defined(DEBUG_PHASES)
1547: if(HOSTDATA(shpnt)->debug & debug_phases)
1548: printk("BUS FREE loop, ");
1549: #endif
1550: while(TESTLO(SSTAT1, BUSFREE))
1551: barrier();
1552: #if defined(DEBUG_PHASES)
1553: if(HOSTDATA(shpnt)->debug & debug_phases)
1554: printk("BUS FREE\n");
1555: #endif
1556: #endif
1557:
1558: done_SC->result = error;
1559: if(done_SC->scsi_done) {
1560: #if defined(DEBUG_DONE)
1561: if(HOSTDATA(shpnt)->debug & debug_done)
1562: printk("calling scsi_done, ");
1563: #endif
1564: done_SC->scsi_done(done_SC);
1565: #if defined(DEBUG_DONE)
1566: if(HOSTDATA(shpnt)->debug & debug_done)
1567: printk("done returned, ");
1568: #endif
1569: } else
1570: panic("aha152x: current_SC->scsi_done() == NULL");
1571: } else
1572: aha152x_panic(shpnt, "done() called outside of command");
1573: }
1574:
1575: /*
1576: * Interrupts handler (main routine of the driver)
1577: */
1578: void aha152x_intr(int irqno, void *dev_id, struct pt_regs * regs)
1579: {
1580: struct Scsi_Host *shpnt = aha152x_host[irqno-IRQ_MIN];
1581: unsigned int flags;
1582: int done=0, phase;
1583:
1584: #if defined(DEBUG_RACE)
1585: enter_driver("intr");
1586: #else
1587: #if defined(DEBUG_INTR)
1588: if(HOSTDATA(shpnt)->debug & debug_intr)
1589: printk("\naha152x: intr(), ");
1590: #endif
1591: #endif
1592:
1593: if(!shpnt)
1594: panic("aha152x: catched interrupt for unknown controller.\n");
1595:
1596: /* no more interrupts from the controller, while we're busy.
1597: INTEN has to be restored, when we're ready to leave
1598: intr(). To avoid race conditions, we have to return
1599: immediately afterwards. */
1600: CLRBITS(DMACNTRL0, INTEN);
1601: sti(); /* Yes, sti() really needs to be here */
1602:
1603: /* disconnected target is trying to reconnect.
1604: Only possible, if we have disconnected nexuses and
1605: nothing is occupying the bus.
1606: */
1607: if(TESTHI(SSTAT0, SELDI) &&
1608: DISCONNECTED_SC &&
1609: (!CURRENT_SC || (CURRENT_SC->SCp.phase & in_selection)) ) {
1610: int identify_msg, target, i;
1611:
1612: /* Avoid conflicts when a target reconnects
1613: while we are trying to connect to another. */
1614: if(CURRENT_SC) {
1615: #if defined(DEBUG_QUEUES)
1616: if(HOSTDATA(shpnt)->debug & debug_queues)
1617: printk("i+, ");
1618: #endif
1619: save_flags(flags);
1620: cli();
1621: append_SC(&ISSUE_SC, CURRENT_SC);
1622: CURRENT_SC=NULL;
1623: restore_flags(flags);
1624: }
1625:
1626: /* disable sequences */
1627: SETPORT(SCSISEQ, 0);
1628: SETPORT(SSTAT0, CLRSELDI);
1629: SETPORT(SSTAT1, CLRBUSFREE);
1630:
1631: #if defined(DEBUG_QUEUES) || defined(DEBUG_PHASES)
1632: if(HOSTDATA(shpnt)->debug & (debug_queues|debug_phases))
1633: printk("reselected, ");
1634: #endif
1635:
1636: i = GETPORT(SELID) & ~(1 << shpnt->this_id);
1637: target=0;
1638:
1639: if(i==0)
1640: aha152x_panic(shpnt, "reconnecting target unknown");
1641:
1642: for(; (i & 1)==0; target++, i>>=1)
1643: ;
1644:
1645: #if defined(DEBUG_QUEUES)
1646: if(HOSTDATA(shpnt)->debug & debug_queues)
1647: printk("SELID=%02x, target=%d, ", GETPORT(SELID), target);
1648: #endif
1649: SETPORT(SCSIID, (shpnt->this_id << OID_) | target);
1650: SETPORT(SCSISEQ, ENRESELI);
1651:
1652: if(TESTLO(SSTAT0, SELDI))
1653: aha152x_panic(shpnt, "RESELI failed");
1654:
1655: SETPORT(SCSIRATE, HOSTDATA(shpnt)->syncrate[target]&0x7f);
1656:
1657: SETPORT(SCSISIG, P_MSGI);
1658:
1659: /* Get identify message */
1660: if((i=getphase(shpnt))!=P_MSGI) {
1661: printk("target doesn't enter MSGI to identify (phase=%02x)\n", i);
1662: aha152x_panic(shpnt, "unknown lun");
1663: }
1664: SETPORT(SCSISEQ, 0);
1665:
1666: SETPORT(SXFRCTL0, CH1);
1667:
1668: identify_msg = GETPORT(SCSIBUS);
1669:
1670: if(!(identify_msg & IDENTIFY_BASE)) {
1671: printk("target=%d, inbound message (%02x) != IDENTIFY\n",
1672: target, identify_msg);
1673: aha152x_panic(shpnt, "unknown lun");
1674: }
1675:
1676:
1677: #if defined(DEBUG_QUEUES)
1678: if(HOSTDATA(shpnt)->debug & debug_queues)
1679: printk("identify=%02x, lun=%d, ", identify_msg, identify_msg & 0x3f);
1680: #endif
1681:
1682: save_flags(flags);
1683: cli();
1684:
1685: #if defined(DEBUG_QUEUES)
1686: if(HOSTDATA(shpnt)->debug & debug_queues)
1687: printk("d-, ");
1688: #endif
1689: CURRENT_SC = remove_SC(&DISCONNECTED_SC, target, identify_msg & 0x3f);
1690:
1691: if(!CURRENT_SC) {
1692: printk("lun=%d, ", identify_msg & 0x3f);
1693: aha152x_panic(shpnt, "no disconnected command for that lun");
1694: }
1695:
1696: CURRENT_SC->SCp.phase &= ~disconnected;
1697: restore_flags(flags);
1698:
1699: make_acklow(shpnt);
1700: if(getphase(shpnt)!=P_MSGI) {
1701: SETPORT(SIMODE0, 0);
1702: SETPORT(SIMODE1, ENPHASEMIS|ENBUSFREE);
1703: #if defined(DEBUG_RACE)
1704: leave_driver("(reselected) intr");
1705: #endif
1706: SETBITS(DMACNTRL0, INTEN);
1707: return;
1708: }
1709: }
1710:
1711: /* Check, if we aren't busy with a command */
1712: if(!CURRENT_SC) {
1713: /* bus is free to issue a queued command */
1714: if(TESTHI(SSTAT1, BUSFREE) && ISSUE_SC) {
1715: save_flags(flags);
1716: cli();
1717: #if defined(DEBUG_QUEUES)
1718: if(HOSTDATA(shpnt)->debug & debug_queues)
1719: printk("i-, ");
1720: #endif
1721: CURRENT_SC = remove_first_SC(&ISSUE_SC);
1722: restore_flags(flags);
1723:
1724: #if defined(DEBUG_INTR) || defined(DEBUG_SELECTION) || defined(DEBUG_PHASES)
1725: if(HOSTDATA(shpnt)->debug & (debug_intr|debug_selection|debug_phases))
1726: printk("issuing command, ");
1727: #endif
1728: CURRENT_SC->SCp.phase = in_selection;
1729:
1730: #if defined(DEBUG_INTR) || defined(DEBUG_SELECTION) || defined(DEBUG_PHASES)
1731: if(HOSTDATA(shpnt)->debug & (debug_intr|debug_selection|debug_phases))
1732: printk("selecting %d, ", CURRENT_SC->target);
1733: #endif
1734: SETPORT(SCSIID, (shpnt->this_id << OID_) | CURRENT_SC->target);
1735:
1736: /* Enable interrupts for SELECTION OUT DONE and SELECTION OUT INITIATED */
1737: SETPORT(SXFRCTL1, HOSTDATA(shpnt)->parity ? (ENSPCHK|ENSTIMER) : ENSTIMER);
1738:
1739: /* enable interrupts for SELECTION OUT DONE and SELECTION TIME OUT */
1740: SETPORT(SIMODE0, ENSELDO | (DISCONNECTED_SC ? ENSELDI : 0));
1741: SETPORT(SIMODE1, ENSELTIMO);
1742:
1743: /* Enable SELECTION OUT sequence */
1744: SETBITS(SCSISEQ, ENSELO | ENAUTOATNO);
1745:
1746: } else {
1747: /* No command we are busy with and no new to issue */
1748: printk("aha152x: ignoring spurious interrupt, nothing to do\n");
1749: if(TESTHI(DMACNTRL0, SWINT)) {
1750: printk("aha152x: SWINT is set! Why?\n");
1751: CLRBITS(DMACNTRL0, SWINT);
1752: }
1753: show_queues(shpnt);
1754: }
1755:
1756: #if defined(DEBUG_RACE)
1757: leave_driver("(selecting) intr");
1758: #endif
1759: SETBITS(DMACNTRL0, INTEN);
1760: return;
1761: }
1762:
1763: /* the bus is busy with something */
1764:
1765: #if defined(DEBUG_INTR)
1766: if(HOSTDATA(shpnt)->debug & debug_intr)
1767: disp_ports(shpnt);
1768: #endif
1769:
1770: /* we are waiting for the result of a selection attempt */
1771: if(CURRENT_SC->SCp.phase & in_selection) {
1772: if(TESTLO(SSTAT1, SELTO)) {
1773: /* no timeout */
1774: if(TESTHI(SSTAT0, SELDO)) {
1775: /* clear BUS FREE interrupt */
1776: SETPORT(SSTAT1, CLRBUSFREE);
1777:
1778: /* Disable SELECTION OUT sequence */
1779: CLRBITS(SCSISEQ, ENSELO|ENAUTOATNO);
1780:
1781: /* Disable SELECTION OUT DONE interrupt */
1782: CLRBITS(SIMODE0, ENSELDO);
1783: CLRBITS(SIMODE1, ENSELTIMO);
1784:
1785: if(TESTLO(SSTAT0, SELDO)) {
1786: printk("aha152x: passing bus free condition\n");
1787:
1788: #if defined(DEBUG_RACE)
1789: leave_driver("(passing bus free) intr");
1790: #endif
1791: SETBITS(DMACNTRL0, INTEN);
1792:
1793: if(CURRENT_SC->SCp.phase & aborted) {
1794: HOSTDATA(shpnt)->abort_result=SCSI_ABORT_ERROR;
1795: HOSTDATA(shpnt)->abortion_complete++;
1796: }
1797:
1798: aha152x_done(shpnt, DID_NO_CONNECT << 16);
1799:
1800: return;
1801: }
1802: #if defined(DEBUG_SELECTION) || defined(DEBUG_PHASES)
1803: if(HOSTDATA(shpnt)->debug & (debug_selection|debug_phases))
1804: printk("SELDO (SELID=%x), ", GETPORT(SELID));
1805: #endif
1806:
1807: /* selection was done */
1808: SETPORT(SSTAT0, CLRSELDO);
1809:
1810: #if defined(DEBUG_ABORT)
1811: if((HOSTDATA(shpnt)->debug & debug_abort) && (CURRENT_SC->SCp.phase & aborted))
1812: printk("(ABORT) target selected, ");
1813: #endif
1814:
1815: CURRENT_SC->SCp.phase &= ~in_selection;
1816: CURRENT_SC->SCp.phase |= in_other;
1817:
1818: ADDMSG(IDENTIFY(HOSTDATA(shpnt)->reconnect,CURRENT_SC->lun));
1819:
1820: if(!(SYNCRATE&0x80) && HOSTDATA(shpnt)->synchronous) {
1821: ADDMSG(EXTENDED_MESSAGE);
1822: ADDMSG(3);
1823: ADDMSG(EXTENDED_SDTR);
1824: ADDMSG(50);
1825: ADDMSG(8);
1826:
1827: printk("outbound SDTR: ");
1828: print_msg(&MSG(MSGLEN-5));
1829:
1830: SYNCRATE=0x80;
1831: CURRENT_SC->SCp.phase |= in_sync;
1832: }
1833:
1834: #if defined(DEBUG_RACE)
1835: leave_driver("(SELDO) intr");
1836: #endif
1837: SETPORT(SCSIRATE, SYNCRATE&0x7f);
1838:
1839: SETPORT(SCSISIG, P_MSGO);
1840:
1841: SETPORT(SIMODE0, 0);
1842: SETPORT(SIMODE1, ENREQINIT|ENBUSFREE);
1843: SETBITS(DMACNTRL0, INTEN);
1844:
1845: return;
1846: } else
1847: aha152x_panic(shpnt, "neither timeout nor selection\007");
1848: } else {
1849: #if defined(DEBUG_SELECTION) || defined(DEBUG_PHASES)
1850: if(HOSTDATA(shpnt)->debug & (debug_selection|debug_phases))
1851: printk("SELTO, ");
1852: #endif
1853: /* end selection attempt */
1854: CLRBITS(SCSISEQ, ENSELO|ENAUTOATNO);
1855:
1856: /* timeout */
1857: SETPORT(SSTAT1, CLRSELTIMO);
1858:
1859: SETPORT(SIMODE0, DISCONNECTED_SC ? ENSELDI : 0);
1860: SETPORT(SIMODE1, ISSUE_SC ? ENBUSFREE : 0);
1861: SETBITS(DMACNTRL0, INTEN);
1862: #if defined(DEBUG_RACE)
1863: leave_driver("(SELTO) intr");
1864: #endif
1865:
1866: if(CURRENT_SC->SCp.phase & aborted) {
1867: #if defined(DEBUG_ABORT)
1868: if(HOSTDATA(shpnt)->debug & debug_abort)
1869: printk("(ABORT) selection timeout, ");
1870: #endif
1871: HOSTDATA(shpnt)->abort_result=SCSI_ABORT_ERROR;
1872: HOSTDATA(shpnt)->abortion_complete++;
1873: }
1874:
1875: if(TESTLO(SSTAT0, SELINGO))
1876: /* ARBITRATION not won */
1877: aha152x_done(shpnt, DID_BUS_BUSY << 16);
1878: else
1879: /* ARBITRATION won, but SELECTION failed */
1880: aha152x_done(shpnt, DID_NO_CONNECT << 16);
1881:
1882: return;
1883: }
1884: }
1885:
1886: /* enable interrupt, when target leaves current phase */
1887: phase = getphase(shpnt);
1888: if(!(phase & ~P_MASK)) /* "real" phase */
1889: SETPORT(SCSISIG, phase);
1890: SETPORT(SSTAT1, CLRPHASECHG);
1891: CURRENT_SC->SCp.phase =
1892: (CURRENT_SC->SCp.phase & ~((P_MASK|1)<<16)) | (phase << 16);
1893:
1894: /* information transfer phase */
1895: switch(phase) {
1896: case P_MSGO: /* MESSAGE OUT */
1897: {
1898: int i, identify=0, abort=0;
1899:
1900: #if defined(DEBUG_INTR) || defined(DEBUG_MSGO) || defined(DEBUG_PHASES)
1901: if(HOSTDATA(shpnt)->debug & (debug_intr|debug_msgo|debug_phases))
1902: printk("MESSAGE OUT, ");
1903: #endif
1904: if(MSGLEN==0) {
1905: ADDMSG(MESSAGE_REJECT);
1906: #if defined(DEBUG_MSGO)
1907: if(HOSTDATA(shpnt)->debug & debug_msgo)
1908: printk("unexpected MESSAGE OUT phase; rejecting, ");
1909: #endif
1910: }
1911:
1912: CLRBITS(SXFRCTL0, ENDMA);
1913:
1914: SETPORT(SIMODE0, 0);
1915: SETPORT(SIMODE1, ENPHASEMIS|ENREQINIT|ENBUSFREE);
1916:
1917: /* wait for data latch to become ready or a phase change */
1918: while(TESTLO(DMASTAT, INTSTAT))
1919: barrier();
1920:
1921: #if defined(DEBUG_MSGO)
1922: if(HOSTDATA(shpnt)->debug & debug_msgo) {
1923: int i;
1924:
1925: printk("messages (");
1926: for(i=0; i<MSGLEN; i+=print_msg(&MSG(i)), printk(" "))
1927: ;
1928: printk("), ");
1929: }
1930: #endif
1931:
1932: for(i=0; i<MSGLEN && TESTLO(SSTAT1, PHASEMIS); i++) {
1933: #if defined(DEBUG_MSGO)
1934: if(HOSTDATA(shpnt)->debug & debug_msgo)
1935: printk("%x ", MSG(i));
1936: #endif
1937: if(i==MSGLEN-1) {
1938: /* Leave MESSAGE OUT after transfer */
1939: SETPORT(SSTAT1, CLRATNO);
1940: }
1941:
1942: SETPORT(SCSIDAT, MSG(i));
1943:
1944: make_acklow(shpnt);
1945: getphase(shpnt);
1946:
1947: if(MSG(i)==IDENTIFY(HOSTDATA(shpnt)->reconnect,CURRENT_SC->lun))
1948: identify++;
1949:
1950: if(MSG(i)==ABORT)
1951: abort++;
1952:
1953: }
1954:
1955: MSGLEN=0;
1956:
1957: if(identify)
1958: CURRENT_SC->SCp.phase |= sent_ident;
1959:
1960: if(abort) {
1961: /* revive abort(); abort() enables interrupts */
1962: HOSTDATA(shpnt)->abort_result=SCSI_ABORT_SUCCESS;
1963: HOSTDATA(shpnt)->abortion_complete++;
1964:
1965: CURRENT_SC->SCp.phase &= ~(P_MASK<<16);
1966:
1967: /* exit */
1968: SETBITS(DMACNTRL0, INTEN);
1969: #if defined(DEBUG_RACE)
1970: leave_driver("(ABORT) intr");
1971: #endif
1972: aha152x_done(shpnt, DID_ABORT<<16);
1973:
1974: return;
1975: }
1976: }
1977: break;
1978:
1979: case P_CMD: /* COMMAND phase */
1980: #if defined(DEBUG_INTR) || defined(DEBUG_CMD) || defined(DEBUG_PHASES)
1981: if(HOSTDATA(shpnt)->debug & (debug_intr|debug_cmd|debug_phases))
1982: printk("COMMAND, ");
1983: #endif
1984: if(!(CURRENT_SC->SCp.sent_command)) {
1985: int i;
1986:
1987: CLRBITS(SXFRCTL0, ENDMA);
1988:
1989: SETPORT(SIMODE0, 0);
1990: SETPORT(SIMODE1, ENPHASEMIS|ENREQINIT|ENBUSFREE);
1991:
1992: /* wait for data latch to become ready or a phase change */
1993: while(TESTLO(DMASTAT, INTSTAT))
1994: barrier();
1995:
1996: for(i=0; i<CURRENT_SC->cmd_len && TESTLO(SSTAT1, PHASEMIS); i++) {
1997: SETPORT(SCSIDAT, CURRENT_SC->cmnd[i]);
1998:
1999: make_acklow(shpnt);
2000: getphase(shpnt);
2001: }
2002:
2003: if(i<CURRENT_SC->cmd_len && TESTHI(SSTAT1, PHASEMIS))
2004: aha152x_panic(shpnt, "target left COMMAND");
2005:
2006: CURRENT_SC->SCp.sent_command++;
2007: } else
2008: aha152x_panic(shpnt, "Nothing to send while in COMMAND");
2009: break;
2010:
2011: case P_MSGI: /* MESSAGE IN phase */
2012: {
2013: int start_sync=0;
2014:
2015: #if defined(DEBUG_INTR) || defined(DEBUG_MSGI) || defined(DEBUG_PHASES)
2016: if(HOSTDATA(shpnt)->debug & (debug_intr|debug_msgi|debug_phases))
2017: printk("MESSAGE IN, ");
2018: #endif
2019: SETPORT(SXFRCTL0, CH1);
2020:
2021: SETPORT(SIMODE0, 0);
2022: SETPORT(SIMODE1, ENBUSFREE);
2023:
2024: while(phase == P_MSGI) {
2025: CURRENT_SC->SCp.Message = GETPORT(SCSIDAT);
2026: switch(CURRENT_SC->SCp.Message) {
2027: case DISCONNECT:
2028: #if defined(DEBUG_MSGI) || defined(DEBUG_PHASES)
2029: if(HOSTDATA(shpnt)->debug & (debug_msgi|debug_phases))
2030: printk("target disconnected, ");
2031: #endif
2032: CURRENT_SC->SCp.Message = 0;
2033: CURRENT_SC->SCp.phase |= disconnected;
2034: if(!HOSTDATA(shpnt)->reconnect)
2035: aha152x_panic(shpnt, "target was not allowed to disconnect");
2036:
2037: break;
2038:
2039: case COMMAND_COMPLETE:
2040: #if defined(DEBUG_MSGI) || defined(DEBUG_PHASES)
2041: if(HOSTDATA(shpnt)->debug & (debug_msgi|debug_phases))
2042: printk("inbound message (COMMAND COMPLETE), ");
2043: #endif
2044: done++;
2045: break;
2046:
2047: case MESSAGE_REJECT:
2048: if(CURRENT_SC->SCp.phase & in_sync) {
2049: CURRENT_SC->SCp.phase &= ~in_sync;
2050: SYNCRATE=0x80;
2051: printk("synchronous rejected, ");
2052: } else
2053: printk("inbound message (MESSAGE REJECT), ");
2054: #if defined(DEBUG_MSGI)
2055: if(HOSTDATA(shpnt)->debug & debug_msgi)
2056: printk("inbound message (MESSAGE REJECT), ");
2057: #endif
2058: break;
2059:
2060: case SAVE_POINTERS:
2061: #if defined(DEBUG_MSGI)
2062: if(HOSTDATA(shpnt)->debug & debug_msgi)
2063: printk("inbound message (SAVE DATA POINTERS), ");
2064: #endif
2065: break;
2066:
2067: case RESTORE_POINTERS:
2068: #if defined(DEBUG_MSGI)
2069: if(HOSTDATA(shpnt)->debug & debug_msgi)
2070: printk("inbound message (RESTORE DATA POINTERS), ");
2071: #endif
2072: break;
2073:
2074: case EXTENDED_MESSAGE:
2075: {
2076: char buffer[16];
2077: int i;
2078:
2079: #if defined(DEBUG_MSGI)
2080: if(HOSTDATA(shpnt)->debug & debug_msgi)
2081: printk("inbound message (EXTENDED MESSAGE), ");
2082: #endif
2083: make_acklow(shpnt);
2084: if(getphase(shpnt)!=P_MSGI)
2085: break;
2086:
2087: buffer[0]=EXTENDED_MESSAGE;
2088: buffer[1]=GETPORT(SCSIDAT);
2089:
2090: for(i=0; i<buffer[1] &&
2091: (make_acklow(shpnt), getphase(shpnt)==P_MSGI); i++)
2092: buffer[2+i]=GETPORT(SCSIDAT);
2093:
2094: #if defined(DEBUG_MSGI)
2095: if(HOSTDATA(shpnt)->debug & debug_msgi)
2096: print_msg(buffer);
2097: #endif
2098:
2099: switch(buffer [2]) {
2100: case EXTENDED_SDTR:
2101: {
2102: long ticks;
2103:
2104: if(buffer[1]!=3)
2105: aha152x_panic(shpnt, "SDTR message length != 3");
2106:
2107: if(!HOSTDATA(shpnt)->synchronous)
2108: break;
2109:
2110: printk("inbound SDTR: "); print_msg(buffer);
2111:
2112: ticks=(buffer[3]*4+49)/50;
2113:
2114: if(CURRENT_SC->SCp.phase & in_sync) {
2115: /* we initiated SDTR */
2116: if(ticks>9 || buffer[4]<1 || buffer[4]>8)
2117: aha152x_panic(shpnt, "received SDTR invalid");
2118:
2119: SYNCRATE |= ((ticks-2)<<4) + buffer[4];
2120: } else if(ticks<=9 && buffer[4]>=1) {
2121: if(buffer[4]>8)
2122: buffer[4]=8;
2123:
2124: ADDMSG(EXTENDED_MESSAGE);
2125: ADDMSG(3);
2126: ADDMSG(EXTENDED_SDTR);
2127: if(ticks<4) {
2128: ticks=4;
2129: ADDMSG(50);
2130: } else
2131: ADDMSG(buffer[3]);
2132:
2133: ADDMSG(buffer[4]);
2134:
2135: printk("outbound SDTR: ");
2136: print_msg(&MSG(MSGLEN-5));
2137:
2138: CURRENT_SC->SCp.phase |= in_sync;
2139:
2140: SYNCRATE |= ((ticks-2)<<4) + buffer[4];
2141:
2142: start_sync++;
2143: } else {
2144: /* requested SDTR is too slow, do it asynchronously */
2145: ADDMSG(MESSAGE_REJECT);
2146: SYNCRATE = 0;
2147: }
2148:
2149: SETPORT(SCSIRATE, SYNCRATE&0x7f);
2150: }
2151: break;
2152:
2153: case EXTENDED_MODIFY_DATA_POINTER:
2154: case EXTENDED_EXTENDED_IDENTIFY:
2155: case EXTENDED_WDTR:
2156: default:
2157: ADDMSG(MESSAGE_REJECT);
2158: break;
2159: }
2160: }
2161: break;
2162:
2163: default:
2164: printk("unsupported inbound message %x, ", CURRENT_SC->SCp.Message);
2165: break;
2166:
2167: }
2168:
2169: make_acklow(shpnt);
2170: phase=getphase(shpnt);
2171: }
2172:
2173: if(start_sync)
2174: CURRENT_SC->SCp.phase |= in_sync;
2175: else
2176: CURRENT_SC->SCp.phase &= ~in_sync;
2177:
2178: if(MSGLEN>0)
2179: SETPORT(SCSISIG, P_MSGI|ATNO);
2180:
2181: /* clear SCSI fifo on BUSFREE */
2182: if(phase==P_BUSFREE)
2183: SETPORT(SXFRCTL0, CH1|CLRCH1);
2184:
2185: if(CURRENT_SC->SCp.phase & disconnected) {
2186: save_flags(flags);
2187: cli();
2188: #if defined(DEBUG_QUEUES)
2189: if(HOSTDATA(shpnt)->debug & debug_queues)
2190: printk("d+, ");
2191: #endif
2192: append_SC(&DISCONNECTED_SC, CURRENT_SC);
2193: CURRENT_SC->SCp.phase |= 1<<16;
2194: CURRENT_SC = NULL;
2195: restore_flags(flags);
2196:
2197: SETBITS(SCSISEQ, ENRESELI);
2198:
2199: SETPORT(SIMODE0, DISCONNECTED_SC ? ENSELDI : 0);
2200: SETPORT(SIMODE1, ISSUE_SC ? ENBUSFREE : 0);
2201:
2202: SETBITS(DMACNTRL0, INTEN);
2203:
2204: return;
2205: }
2206: }
2207: break;
2208:
2209: case P_STATUS: /* STATUS IN phase */
2210: #if defined(DEBUG_STATUS) || defined(DEBUG_INTR) || defined(DEBUG_PHASES)
2211: if(HOSTDATA(shpnt)->debug & (debug_status|debug_intr|debug_phases))
2212: printk("STATUS, ");
2213: #endif
2214: SETPORT(SXFRCTL0, CH1);
2215:
2216: SETPORT(SIMODE0, 0);
2217: SETPORT(SIMODE1, ENREQINIT|ENBUSFREE);
2218:
2219: if(TESTHI(SSTAT1, PHASEMIS))
2220: printk("aha152x: passing STATUS phase");
2221:
2222: CURRENT_SC->SCp.Status = GETPORT(SCSIBUS);
2223: make_acklow(shpnt);
2224: getphase(shpnt);
2225:
2226: #if defined(DEBUG_STATUS)
2227: if(HOSTDATA(shpnt)->debug & debug_status) {
2228: printk("inbound status ");
2229: print_status(CURRENT_SC->SCp.Status);
2230: printk(", ");
2231: }
2232: #endif
2233: break;
2234:
2235: case P_DATAI: /* DATA IN phase */
2236: {
2237: int fifodata, data_count, done;
2238:
2239: #if defined(DEBUG_DATAI) || defined(DEBUG_INTR) || defined(DEBUG_PHASES)
2240: if(HOSTDATA(shpnt)->debug & (debug_datai|debug_intr|debug_phases))
2241: printk("DATA IN, ");
2242: #endif
2243:
2244: #if 0
2245: if(GETPORT(FIFOSTAT) || GETPORT(SSTAT2) & (SFULL|SFCNT))
2246: printk("aha152x: P_DATAI: %d(%d) bytes left in FIFO, resetting\n",
2247: GETPORT(FIFOSTAT), GETPORT(SSTAT2) & (SFULL|SFCNT));
2248: #endif
2249:
2250: /* reset host fifo */
2251: SETPORT(DMACNTRL0, RSTFIFO);
2252: SETPORT(DMACNTRL0, RSTFIFO|ENDMA);
2253:
2254: SETPORT(SXFRCTL0, CH1|SCSIEN|DMAEN);
2255:
2256: SETPORT(SIMODE0, 0);
2257: SETPORT(SIMODE1, ENPHASEMIS|ENBUSFREE);
2258:
2259: /* done is set when the FIFO is empty after the target left DATA IN */
2260: done=0;
2261:
2262: /* while the target stays in DATA to transfer data */
2263: while (!done) {
2264: #if defined(DEBUG_DATAI)
2265: if(HOSTDATA(shpnt)->debug & debug_datai)
2266: printk("expecting data, ");
2267: #endif
2268: /* wait for PHASEMIS or full FIFO */
2269: while(TESTLO(DMASTAT, DFIFOFULL|INTSTAT))
2270: barrier();
2271:
2272: #if defined(DEBUG_DATAI)
2273: if(HOSTDATA(shpnt)->debug & debug_datai)
2274: printk("ok, ");
2275: #endif
2276:
2277: if(TESTHI(DMASTAT, DFIFOFULL))
2278: fifodata=GETPORT(FIFOSTAT);
2279: else {
2280: /* wait for SCSI fifo to get empty */
2281: while(TESTLO(SSTAT2, SEMPTY))
2282: barrier();
2283:
2284: /* rest of data in FIFO */
2285: fifodata=GETPORT(FIFOSTAT);
2286: #if defined(DEBUG_DATAI)
2287: if(HOSTDATA(shpnt)->debug & debug_datai)
2288: printk("last transfer, ");
2289: #endif
2290: done=1;
2291: }
2292:
2293: #if defined(DEBUG_DATAI)
2294: if(HOSTDATA(shpnt)->debug & debug_datai)
2295: printk("fifodata=%d, ", fifodata);
2296: #endif
2297:
2298: while(fifodata && CURRENT_SC->SCp.this_residual) {
2299: data_count=fifodata;
2300:
2301: /* limit data transfer to size of first sg buffer */
2302: if(data_count > CURRENT_SC->SCp.this_residual)
2303: data_count = CURRENT_SC->SCp.this_residual;
2304:
2305: fifodata -= data_count;
2306:
2307: #if defined(DEBUG_DATAI)
2308: if(HOSTDATA(shpnt)->debug & debug_datai)
2309: printk("data_count=%d, ", data_count);
2310: #endif
2311:
2312: if(data_count&1) {
2313: /* get a single byte in byte mode */
2314: SETBITS(DMACNTRL0, _8BIT);
2315: *CURRENT_SC->SCp.ptr++ = GETPORT(DATAPORT);
2316: CURRENT_SC->SCp.this_residual--;
2317: }
2318:
2319: if(data_count>1) {
2320: CLRBITS(DMACNTRL0, _8BIT);
2321: data_count >>= 1; /* Number of words */
2322: insw(DATAPORT, CURRENT_SC->SCp.ptr, data_count);
2323: #if defined(DEBUG_DATAI)
2324: if(HOSTDATA(shpnt)->debug & debug_datai)
2325: /* show what comes with the last transfer */
2326: if(done) {
2327: #if 0
2328: int i;
2329: unsigned char *data;
2330: #endif
2331:
2332: printk("data on last transfer (%d bytes) ",
2333: 2*data_count);
2334: #if 0
2335: printk("data on last transfer (%d bytes: ",
2336: 2*data_count);
2337: data = (unsigned char *) CURRENT_SC->SCp.ptr;
2338: for(i=0; i<2*data_count; i++)
2339: printk("%2x ", *data++);
2340: printk("), ");
2341: #endif
2342: }
2343: #endif
2344: CURRENT_SC->SCp.ptr += 2 * data_count;
2345: CURRENT_SC->SCp.this_residual -= 2 * data_count;
2346: }
2347:
2348: /* if this buffer is full and there are more buffers left */
2349: if(!CURRENT_SC->SCp.this_residual &&
2350: CURRENT_SC->SCp.buffers_residual) {
2351: /* advance to next buffer */
2352: CURRENT_SC->SCp.buffers_residual--;
2353: CURRENT_SC->SCp.buffer++;
2354: CURRENT_SC->SCp.ptr = CURRENT_SC->SCp.buffer->address;
2355: CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length;
2356: }
2357: }
2358:
2359: /*
2360: * FIFO should be empty
2361: */
2362: if(fifodata>0) {
2363: printk("aha152x: more data than expected (%d bytes)\n",
2364: GETPORT(FIFOSTAT));
2365: SETBITS(DMACNTRL0, _8BIT);
2366: printk("aha152x: data (");
2367: while(fifodata--)
2368: printk("%2x ", GETPORT(DATAPORT));
2369: printk(")\n");
2370: }
2371:
2372: #if defined(DEBUG_DATAI)
2373: if(HOSTDATA(shpnt)->debug & debug_datai)
2374: if(!fifodata)
2375: printk("fifo empty, ");
2376: else
2377: printk("something left in fifo, ");
2378: #endif
2379: }
2380:
2381: #if defined(DEBUG_DATAI)
2382: if((HOSTDATA(shpnt)->debug & debug_datai) &&
2383: (CURRENT_SC->SCp.buffers_residual ||
2384: CURRENT_SC->SCp.this_residual))
2385: printk("left buffers (buffers=%d, bytes=%d), ",
2386: CURRENT_SC->SCp.buffers_residual, CURRENT_SC->SCp.this_residual);
2387: #endif
2388: /* transfer can be considered ended, when SCSIEN reads back zero */
2389: CLRBITS(SXFRCTL0, SCSIEN|DMAEN);
2390: while(TESTHI(SXFRCTL0, SCSIEN))
2391: barrier();
2392: CLRBITS(DMACNTRL0, ENDMA);
2393:
2394: #if defined(DEBUG_DATAI) || defined(DEBUG_INTR)
2395: if(HOSTDATA(shpnt)->debug & (debug_datai|debug_intr))
2396: printk("got %d bytes, ", GETSTCNT());
2397: #endif
2398:
2399: CURRENT_SC->SCp.have_data_in++;
2400: }
2401: break;
2402:
2403: case P_DATAO: /* DATA OUT phase */
2404: {
2405: int data_count;
2406:
2407: #if defined(DEBUG_DATAO) || defined(DEBUG_INTR) || defined(DEBUG_PHASES)
2408: if(HOSTDATA(shpnt)->debug & (debug_datao|debug_intr|debug_phases))
2409: printk("DATA OUT, ");
2410: #endif
2411: #if defined(DEBUG_DATAO)
2412: if(HOSTDATA(shpnt)->debug & debug_datao)
2413: printk("got data to send (bytes=%d, buffers=%d), ",
2414: CURRENT_SC->SCp.this_residual,
2415: CURRENT_SC->SCp.buffers_residual);
2416: #endif
2417:
2418: if(GETPORT(FIFOSTAT) || GETPORT(SSTAT2) & (SFULL|SFCNT)) {
2419: printk("%d(%d) left in FIFO, ",
2420: GETPORT(FIFOSTAT), GETPORT(SSTAT2) & (SFULL|SFCNT));
2421: aha152x_panic(shpnt, "FIFO should be empty");
2422: }
2423:
2424: SETPORT(SXFRCTL0, CH1|CLRSTCNT|CLRCH1);
2425: SETPORT(SXFRCTL0, SCSIEN|DMAEN|CH1);
2426:
2427: SETPORT(DMACNTRL0, WRITE_READ|RSTFIFO);
2428: SETPORT(DMACNTRL0, ENDMA|WRITE_READ);
2429:
2430: SETPORT(SIMODE0, 0);
2431: SETPORT(SIMODE1, ENPHASEMIS|ENBUSFREE);
2432:
2433: /* while current buffer is not empty or
2434: there are more buffers to transfer */
2435: while(TESTLO(SSTAT1, PHASEMIS) &&
2436: (CURRENT_SC->SCp.this_residual ||
2437: CURRENT_SC->SCp.buffers_residual)) {
2438: #if defined(DEBUG_DATAO)
2439: if(HOSTDATA(shpnt)->debug & debug_datao)
2440: printk("sending data (left: bytes=%d, buffers=%d), waiting, ",
2441: CURRENT_SC->SCp.this_residual,
2442: CURRENT_SC->SCp.buffers_residual);
2443: #endif
2444: /* transfer rest of buffer, but max. 128 byte */
2445: data_count =
2446: CURRENT_SC->SCp.this_residual > 128 ?
2447: 128 : CURRENT_SC->SCp.this_residual ;
2448:
2449: #if defined(DEBUG_DATAO)
2450: if(HOSTDATA(shpnt)->debug & debug_datao)
2451: printk("data_count=%d, ", data_count);
2452: #endif
2453:
2454: if(data_count&1) {
2455: /* put a single byte in byte mode */
2456: SETBITS(DMACNTRL0, _8BIT);
2457: SETPORT(DATAPORT, *CURRENT_SC->SCp.ptr++);
2458: CURRENT_SC->SCp.this_residual--;
2459: }
2460: if(data_count>1) {
2461: CLRBITS(DMACNTRL0, _8BIT);
2462: data_count >>= 1; /* number of words */
2463: outsw(DATAPORT, CURRENT_SC->SCp.ptr, data_count);
2464: CURRENT_SC->SCp.ptr += 2 * data_count;
2465: CURRENT_SC->SCp.this_residual -= 2 * data_count;
2466: }
2467:
2468: /* wait for FIFO to get empty */
2469: while(TESTLO(DMASTAT, DFIFOEMP|INTSTAT))
2470: barrier();
2471:
2472: #if defined(DEBUG_DATAO)
2473: if(HOSTDATA(shpnt)->debug & debug_datao)
2474: printk("fifo (%d bytes), transfered (%d bytes), ",
2475: GETPORT(FIFOSTAT), GETSTCNT());
2476: #endif
2477:
2478: /* if this buffer is empty and there are more buffers left */
2479: if(TESTLO(SSTAT1, PHASEMIS) &&
2480: !CURRENT_SC->SCp.this_residual &&
2481: CURRENT_SC->SCp.buffers_residual) {
2482: /* advance to next buffer */
2483: CURRENT_SC->SCp.buffers_residual--;
2484: CURRENT_SC->SCp.buffer++;
2485: CURRENT_SC->SCp.ptr = CURRENT_SC->SCp.buffer->address;
2486: CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length;
2487: }
2488: }
2489:
2490: if(CURRENT_SC->SCp.this_residual || CURRENT_SC->SCp.buffers_residual) {
2491: /* target leaves DATA OUT for an other phase (perhaps disconnect) */
2492:
2493: /* data in fifos has to be resend */
2494: data_count = GETPORT(SSTAT2) & (SFULL|SFCNT);
2495:
2496: data_count += GETPORT(FIFOSTAT) ;
2497: CURRENT_SC->SCp.ptr -= data_count;
2498: CURRENT_SC->SCp.this_residual += data_count;
2499: #if defined(DEBUG_DATAO)
2500: if(HOSTDATA(shpnt)->debug & debug_datao)
2501: printk("left data (bytes=%d, buffers=%d), fifos (bytes=%d), "
2502: "transfer incomplete, resetting fifo, ",
2503: CURRENT_SC->SCp.this_residual,
2504: CURRENT_SC->SCp.buffers_residual,
2505: data_count);
2506: #endif
2507: SETPORT(DMACNTRL0, WRITE_READ|RSTFIFO);
2508: CLRBITS(SXFRCTL0, SCSIEN|DMAEN);
2509: CLRBITS(DMACNTRL0, ENDMA);
2510: } else {
2511: #if defined(DEBUG_DATAO)
2512: if(HOSTDATA(shpnt)->debug & debug_datao)
2513: printk("waiting for SCSI fifo to get empty, ");
2514: #endif
2515: /* wait for SCSI fifo to get empty */
2516: while(TESTLO(SSTAT2, SEMPTY))
2517: barrier();
2518: #if defined(DEBUG_DATAO)
2519: if(HOSTDATA(shpnt)->debug & debug_datao)
2520: printk("ok, left data (bytes=%d, buffers=%d) ",
2521: CURRENT_SC->SCp.this_residual,
2522: CURRENT_SC->SCp.buffers_residual);
2523: #endif
2524: CLRBITS(SXFRCTL0, SCSIEN|DMAEN);
2525:
2526: /* transfer can be considered ended, when SCSIEN reads back zero */
2527: while(TESTHI(SXFRCTL0, SCSIEN))
2528: barrier();
2529:
2530: CLRBITS(DMACNTRL0, ENDMA);
2531: }
2532:
2533: #if defined(DEBUG_DATAO) || defined(DEBUG_INTR)
2534: if(HOSTDATA(shpnt)->debug & (debug_datao|debug_intr))
2535: printk("sent %d data bytes, ", GETSTCNT());
2536: #endif
2537: }
2538: break;
2539:
2540: case P_BUSFREE: /* BUSFREE */
2541: #if defined(DEBUG_RACE)
2542: leave_driver("(BUSFREE) intr");
2543: #endif
2544: #if defined(DEBUG_PHASES)
2545: if(HOSTDATA(shpnt)->debug & debug_phases)
2546: printk("unexpected BUS FREE, ");
2547: #endif
2548: CURRENT_SC->SCp.phase &= ~(P_MASK<<16);
2549:
2550: aha152x_done(shpnt, DID_ERROR << 16); /* Don't know any better */
2551: return;
2552: break;
2553:
2554: case P_PARITY: /* parity error in DATA phase */
2555: #if defined(DEBUG_RACE)
2556: leave_driver("(DID_PARITY) intr");
2557: #endif
2558: printk("PARITY error in DATA phase, ");
2559:
2560: CURRENT_SC->SCp.phase &= ~(P_MASK<<16);
2561:
2562: SETBITS(DMACNTRL0, INTEN);
2563: aha152x_done(shpnt, DID_PARITY << 16);
2564: return;
2565: break;
2566:
2567: default:
2568: printk("aha152x: unexpected phase\n");
2569: break;
2570: }
2571:
2572: if(done) {
2573: #if defined(DEBUG_INTR)
2574: if(HOSTDATA(shpnt)->debug & debug_intr)
2575: printk("command done.\n");
2576: #endif
2577: #if defined(DEBUG_RACE)
2578: leave_driver("(done) intr");
2579: #endif
2580:
2581: SETPORT(SIMODE0, DISCONNECTED_SC ? ENSELDI : 0);
2582: SETPORT(SIMODE1, ISSUE_SC ? ENBUSFREE : 0);
2583: SETPORT(SCSISEQ, DISCONNECTED_SC ? ENRESELI : 0);
2584:
2585: SETBITS(DMACNTRL0, INTEN);
2586:
2587: aha152x_done(shpnt,
2588: (CURRENT_SC->SCp.Status & 0xff)
2589: | ((CURRENT_SC->SCp.Message & 0xff) << 8)
2590: | (DID_OK << 16));
2591:
2592: #if defined(DEBUG_RACE)
2593: printk("done returned (DID_OK: Status=%x; Message=%x).\n",
2594: CURRENT_SC->SCp.Status, CURRENT_SC->SCp.Message);
2595: #endif
2596: return;
2597: }
2598:
2599: if(CURRENT_SC)
2600: CURRENT_SC->SCp.phase |= 1<<16;
2601:
2602: SETPORT(SIMODE0, 0);
2603: SETPORT(SIMODE1, ENPHASEMIS|ENBUSFREE);
2604: #if defined(DEBUG_INTR)
2605: if(HOSTDATA(shpnt)->debug & debug_intr)
2606: disp_enintr(shpnt);
2607: #endif
2608: #if defined(DEBUG_RACE)
2609: leave_driver("(PHASEEND) intr");
2610: #endif
2611:
2612: SETBITS(DMACNTRL0, INTEN);
2613: return;
2614: }
2615:
2616: /*
2617: * Dump the current driver status and panic...
2618: */
2619: static void aha152x_panic(struct Scsi_Host *shpnt, char *msg)
2620: {
2621: printk("\naha152x: %s\n", msg);
2622: show_queues(shpnt);
2623: panic("aha152x panic");
2624: }
2625:
2626: /*
2627: * Display registers of AIC-6260
2628: */
2629: static void disp_ports(struct Scsi_Host *shpnt)
2630: {
2631: #ifdef DEBUG_AHA152X
2632: int s;
2633:
2634: #ifdef SKIP_PORTS
2635: if(HOSTDATA(shpnt)->debug & debug_skipports)
2636: return;
2637: #endif
2638:
2639: printk("\n%s: ", CURRENT_SC ? "on bus" : "waiting");
2640:
2641: s=GETPORT(SCSISEQ);
2642: printk("SCSISEQ (");
2643: if(s & TEMODEO) printk("TARGET MODE ");
2644: if(s & ENSELO) printk("SELO ");
2645: if(s & ENSELI) printk("SELI ");
2646: if(s & ENRESELI) printk("RESELI ");
2647: if(s & ENAUTOATNO) printk("AUTOATNO ");
2648: if(s & ENAUTOATNI) printk("AUTOATNI ");
2649: if(s & ENAUTOATNP) printk("AUTOATNP ");
2650: if(s & SCSIRSTO) printk("SCSIRSTO ");
2651: printk(");");
2652:
2653: printk(" SCSISIG (");
2654: s=GETPORT(SCSISIG);
2655: switch(s & P_MASK) {
2656: case P_DATAO:
2657: printk("DATA OUT");
2658: break;
2659: case P_DATAI:
2660: printk("DATA IN");
2661: break;
2662: case P_CMD:
2663: printk("COMMAND");
2664: break;
2665: case P_STATUS:
2666: printk("STATUS");
2667: break;
2668: case P_MSGO:
2669: printk("MESSAGE OUT");
2670: break;
2671: case P_MSGI:
2672: printk("MESSAGE IN");
2673: break;
2674: default:
2675: printk("*illegal*");
2676: break;
2677: }
2678:
2679: printk("); ");
2680:
2681: printk("INTSTAT (%s); ", TESTHI(DMASTAT, INTSTAT) ? "hi" : "lo");
2682:
2683: printk("SSTAT (");
2684: s=GETPORT(SSTAT0);
2685: if(s & TARGET) printk("TARGET ");
2686: if(s & SELDO) printk("SELDO ");
2687: if(s & SELDI) printk("SELDI ");
2688: if(s & SELINGO) printk("SELINGO ");
2689: if(s & SWRAP) printk("SWRAP ");
2690: if(s & SDONE) printk("SDONE ");
2691: if(s & SPIORDY) printk("SPIORDY ");
2692: if(s & DMADONE) printk("DMADONE ");
2693:
2694: s=GETPORT(SSTAT1);
2695: if(s & SELTO) printk("SELTO ");
2696: if(s & ATNTARG) printk("ATNTARG ");
2697: if(s & SCSIRSTI) printk("SCSIRSTI ");
2698: if(s & PHASEMIS) printk("PHASEMIS ");
2699: if(s & BUSFREE) printk("BUSFREE ");
2700: if(s & SCSIPERR) printk("SCSIPERR ");
2701: if(s & PHASECHG) printk("PHASECHG ");
2702: if(s & REQINIT) printk("REQINIT ");
2703: printk("); ");
2704:
2705:
2706: printk("SSTAT (");
2707:
2708: s=GETPORT(SSTAT0) & GETPORT(SIMODE0);
2709:
2710: if(s & TARGET) printk("TARGET ");
2711: if(s & SELDO) printk("SELDO ");
2712: if(s & SELDI) printk("SELDI ");
2713: if(s & SELINGO) printk("SELINGO ");
2714: if(s & SWRAP) printk("SWRAP ");
2715: if(s & SDONE) printk("SDONE ");
2716: if(s & SPIORDY) printk("SPIORDY ");
2717: if(s & DMADONE) printk("DMADONE ");
2718:
2719: s=GETPORT(SSTAT1) & GETPORT(SIMODE1);
2720:
2721: if(s & SELTO) printk("SELTO ");
2722: if(s & ATNTARG) printk("ATNTARG ");
2723: if(s & SCSIRSTI) printk("SCSIRSTI ");
2724: if(s & PHASEMIS) printk("PHASEMIS ");
2725: if(s & BUSFREE) printk("BUSFREE ");
2726: if(s & SCSIPERR) printk("SCSIPERR ");
2727: if(s & PHASECHG) printk("PHASECHG ");
2728: if(s & REQINIT) printk("REQINIT ");
2729: printk("); ");
2730:
2731: printk("SXFRCTL0 (");
2732:
2733: s=GETPORT(SXFRCTL0);
2734: if(s & SCSIEN) printk("SCSIEN ");
2735: if(s & DMAEN) printk("DMAEN ");
2736: if(s & CH1) printk("CH1 ");
2737: if(s & CLRSTCNT) printk("CLRSTCNT ");
2738: if(s & SPIOEN) printk("SPIOEN ");
2739: if(s & CLRCH1) printk("CLRCH1 ");
2740: printk("); ");
2741:
2742: printk("SIGNAL (");
2743:
2744: s=GETPORT(SCSISIG);
2745: if(s & ATNI) printk("ATNI ");
2746: if(s & SELI) printk("SELI ");
2747: if(s & BSYI) printk("BSYI ");
2748: if(s & REQI) printk("REQI ");
2749: if(s & ACKI) printk("ACKI ");
2750: printk("); ");
2751:
2752: printk("SELID (%02x), ", GETPORT(SELID));
2753:
2754: printk("SSTAT2 (");
2755:
2756: s=GETPORT(SSTAT2);
2757: if(s & SOFFSET) printk("SOFFSET ");
2758: if(s & SEMPTY) printk("SEMPTY ");
2759: if(s & SFULL) printk("SFULL ");
2760: printk("); SFCNT (%d); ", s & (SFULL|SFCNT));
2761:
2762: s=GETPORT(SSTAT3);
2763: printk("SCSICNT (%d), OFFCNT(%d), ", (s&0xf0)>>4, s&0x0f);
2764:
2765: printk("SSTAT4 (");
2766: s=GETPORT(SSTAT4);
2767: if(s & SYNCERR) printk("SYNCERR ");
2768: if(s & FWERR) printk("FWERR ");
2769: if(s & FRERR) printk("FRERR ");
2770: printk("); ");
2771:
2772: printk("DMACNTRL0 (");
2773: s=GETPORT(DMACNTRL0);
2774: printk("%s ", s & _8BIT ? "8BIT" : "16BIT");
2775: printk("%s ", s & DMA ? "DMA" : "PIO" );
2776: printk("%s ", s & WRITE_READ ? "WRITE" : "READ" );
2777: if(s & ENDMA) printk("ENDMA ");
2778: if(s & INTEN) printk("INTEN ");
2779: if(s & RSTFIFO) printk("RSTFIFO ");
2780: if(s & SWINT) printk("SWINT ");
2781: printk("); ");
2782:
2783: printk("DMASTAT (");
2784: s=GETPORT(DMASTAT);
2785: if(s & ATDONE) printk("ATDONE ");
2786: if(s & WORDRDY) printk("WORDRDY ");
2787: if(s & DFIFOFULL) printk("DFIFOFULL ");
2788: if(s & DFIFOEMP) printk("DFIFOEMP ");
2789: printk(")");
2790:
2791: printk("\n");
2792: #endif
2793: }
2794:
2795: /*
2796: * display enabled interrupts
2797: */
2798: static void disp_enintr(struct Scsi_Host *shpnt)
2799: {
2800: int s;
2801:
2802: printk("enabled interrupts (");
2803:
2804: s=GETPORT(SIMODE0);
2805: if(s & ENSELDO) printk("ENSELDO ");
2806: if(s & ENSELDI) printk("ENSELDI ");
2807: if(s & ENSELINGO) printk("ENSELINGO ");
2808: if(s & ENSWRAP) printk("ENSWRAP ");
2809: if(s & ENSDONE) printk("ENSDONE ");
2810: if(s & ENSPIORDY) printk("ENSPIORDY ");
2811: if(s & ENDMADONE) printk("ENDMADONE ");
2812:
2813: s=GETPORT(SIMODE1);
2814: if(s & ENSELTIMO) printk("ENSELTIMO ");
2815: if(s & ENATNTARG) printk("ENATNTARG ");
2816: if(s & ENPHASEMIS) printk("ENPHASEMIS ");
2817: if(s & ENBUSFREE) printk("ENBUSFREE ");
2818: if(s & ENSCSIPERR) printk("ENSCSIPERR ");
2819: if(s & ENPHASECHG) printk("ENPHASECHG ");
2820: if(s & ENREQINIT) printk("ENREQINIT ");
2821: printk(")\n");
2822: }
2823:
2824: #if defined(DEBUG_RACE)
2825:
2826: static const char *should_leave;
2827: static int in_driver=0;
2828:
2829: /*
2830: * Only one routine can be in the driver at once.
2831: */
2832: static void enter_driver(const char *func)
2833: {
2834: unsigned long flags;
2835:
2836: save_flags(flags);
2837: cli();
2838: printk("aha152x: entering %s() (%x)\n", func, jiffies);
2839: if(in_driver) {
2840: printk("%s should leave first.\n", should_leave);
2841: panic("aha152x: already in driver\n");
2842: }
2843:
2844: in_driver++;
2845: should_leave=func;
2846: restore_flags(flags);
2847: }
2848:
2849: static void leave_driver(const char *func)
2850: {
2851: unsigned long flags;
2852:
2853: save_flags(flags);
2854: cli();
2855: printk("\naha152x: leaving %s() (%x)\n", func, jiffies);
2856: if(!in_driver) {
2857: printk("aha152x: %s already left.\n", should_leave);
2858: panic("aha152x: %s already left driver.\n");
2859: }
2860:
2861: in_driver--;
2862: should_leave=func;
2863: restore_flags(flags);
2864: }
2865: #endif
2866:
2867: /*
2868: * Show the command data of a command
2869: */
2870: static void show_command(Scsi_Cmnd *ptr)
2871: {
2872: printk("0x%08x: target=%d; lun=%d; cmnd=(",
2873: (unsigned int) ptr, ptr->target, ptr->lun);
2874:
2875: print_command(ptr->cmnd);
2876:
2877: printk("); residual=%d; buffers=%d; phase |",
2878: ptr->SCp.this_residual, ptr->SCp.buffers_residual);
2879:
2880: if(ptr->SCp.phase & not_issued ) printk("not issued|");
2881: if(ptr->SCp.phase & in_selection) printk("in selection|");
2882: if(ptr->SCp.phase & disconnected) printk("disconnected|");
2883: if(ptr->SCp.phase & aborted ) printk("aborted|");
2884: if(ptr->SCp.phase & sent_ident ) printk("send_ident|");
2885: if(ptr->SCp.phase & in_other) {
2886: printk("; in other(");
2887: switch((ptr->SCp.phase >> 16) & P_MASK) {
2888: case P_DATAO:
2889: printk("DATA OUT");
2890: break;
2891: case P_DATAI:
2892: printk("DATA IN");
2893: break;
2894: case P_CMD:
2895: printk("COMMAND");
2896: break;
2897: case P_STATUS:
2898: printk("STATUS");
2899: break;
2900: case P_MSGO:
2901: printk("MESSAGE OUT");
2902: break;
2903: case P_MSGI:
2904: printk("MESSAGE IN");
2905: break;
2906: default:
2907: printk("*illegal*");
2908: break;
2909: }
2910: printk(")");
2911: if(ptr->SCp.phase & (1<<16))
2912: printk("; phaseend");
2913: }
2914: printk("; next=0x%08x\n", (unsigned int) ptr->host_scribble);
2915: }
2916:
2917: /*
2918: * Dump the queued data
2919: */
2920: static void show_queues(struct Scsi_Host *shpnt)
2921: {
2922: unsigned long flags;
2923: Scsi_Cmnd *ptr;
2924:
2925: save_flags(flags);
2926: cli();
2927: printk("QUEUE STATUS:\nissue_SC:\n");
2928: for(ptr=ISSUE_SC; ptr; ptr = (Scsi_Cmnd *) ptr->host_scribble)
2929: show_command(ptr);
2930:
2931: printk("current_SC:\n");
2932: if(CURRENT_SC)
2933: show_command(CURRENT_SC);
2934: else
2935: printk("none\n");
2936:
2937: printk("disconnected_SC:\n");
2938: for(ptr=DISCONNECTED_SC; ptr; ptr = (Scsi_Cmnd *) ptr->host_scribble)
2939: show_command(ptr);
2940:
2941: disp_ports(shpnt);
2942: disp_enintr(shpnt);
2943: restore_flags(flags);
2944: }
2945:
2946: int aha152x_set_info(char *buffer, int length, struct Scsi_Host *shpnt)
2947: {
2948: return(-ENOSYS); /* Currently this is a no-op */
2949: }
2950:
2951: #undef SPRINTF
2952: #define SPRINTF(args...) pos += sprintf(pos, ## args)
2953:
2954: static int get_command(char *pos, Scsi_Cmnd *ptr)
2955: {
2956: char *start = pos;
2957: int i;
2958:
2959: SPRINTF("0x%08x: target=%d; lun=%d; cmnd=( ",
2960: (unsigned int) ptr, ptr->target, ptr->lun);
2961:
2962: for(i=0; i<COMMAND_SIZE(ptr->cmnd[0]); i++)
2963: SPRINTF("0x%02x ", ptr->cmnd[i]);
2964:
2965: SPRINTF("); residual=%d; buffers=%d; phase |",
2966: ptr->SCp.this_residual, ptr->SCp.buffers_residual);
2967:
2968: if(ptr->SCp.phase & not_issued ) SPRINTF("not issued|");
2969: if(ptr->SCp.phase & in_selection) SPRINTF("in selection|");
2970: if(ptr->SCp.phase & disconnected) SPRINTF("disconnected|");
2971: if(ptr->SCp.phase & aborted ) SPRINTF("aborted|");
2972: if(ptr->SCp.phase & sent_ident ) SPRINTF("send_ident|");
2973: if(ptr->SCp.phase & in_other) {
2974: SPRINTF("; in other(");
2975: switch((ptr->SCp.phase >> 16) & P_MASK) {
2976: case P_DATAO:
2977: SPRINTF("DATA OUT");
2978: break;
2979: case P_DATAI:
2980: SPRINTF("DATA IN");
2981: break;
2982: case P_CMD:
2983: SPRINTF("COMMAND");
2984: break;
2985: case P_STATUS:
2986: SPRINTF("STATUS");
2987: break;
2988: case P_MSGO:
2989: SPRINTF("MESSAGE OUT");
2990: break;
2991: case P_MSGI:
2992: SPRINTF("MESSAGE IN");
2993: break;
2994: default:
2995: SPRINTF("*illegal*");
2996: break;
2997: }
2998: SPRINTF(")");
2999: if(ptr->SCp.phase & (1<<16))
3000: SPRINTF("; phaseend");
3001: }
3002: SPRINTF("; next=0x%08x\n", (unsigned int) ptr->host_scribble);
3003:
3004: return(pos-start);
3005: }
3006:
3007: static int get_ports(struct Scsi_Host *shpnt, char *pos)
3008: {
3009: char *start = pos;
3010: int s;
3011:
3012: #ifdef SKIP_PORTS
3013: if(HOSTDATA(shpnt)->debug & debug_skipports)
3014: return;
3015: #endif
3016:
3017: SPRINTF("\n%s: ", CURRENT_SC ? "on bus" : "waiting");
3018:
3019: s=GETPORT(SCSISEQ);
3020: SPRINTF("SCSISEQ (");
3021: if(s & TEMODEO) SPRINTF("TARGET MODE ");
3022: if(s & ENSELO) SPRINTF("SELO ");
3023: if(s & ENSELI) SPRINTF("SELI ");
3024: if(s & ENRESELI) SPRINTF("RESELI ");
3025: if(s & ENAUTOATNO) SPRINTF("AUTOATNO ");
3026: if(s & ENAUTOATNI) SPRINTF("AUTOATNI ");
3027: if(s & ENAUTOATNP) SPRINTF("AUTOATNP ");
3028: if(s & SCSIRSTO) SPRINTF("SCSIRSTO ");
3029: SPRINTF(");");
3030:
3031: SPRINTF(" SCSISIG (");
3032: s=GETPORT(SCSISIG);
3033: switch(s & P_MASK) {
3034: case P_DATAO:
3035: SPRINTF("DATA OUT");
3036: break;
3037: case P_DATAI:
3038: SPRINTF("DATA IN");
3039: break;
3040: case P_CMD:
3041: SPRINTF("COMMAND");
3042: break;
3043: case P_STATUS:
3044: SPRINTF("STATUS");
3045: break;
3046: case P_MSGO:
3047: SPRINTF("MESSAGE OUT");
3048: break;
3049: case P_MSGI:
3050: SPRINTF("MESSAGE IN");
3051: break;
3052: default:
3053: SPRINTF("*illegal*");
3054: break;
3055: }
3056:
3057: SPRINTF("); ");
3058:
3059: SPRINTF("INTSTAT (%s); ", TESTHI(DMASTAT, INTSTAT) ? "hi" : "lo");
3060:
3061: SPRINTF("SSTAT (");
3062: s=GETPORT(SSTAT0);
3063: if(s & TARGET) SPRINTF("TARGET ");
3064: if(s & SELDO) SPRINTF("SELDO ");
3065: if(s & SELDI) SPRINTF("SELDI ");
3066: if(s & SELINGO) SPRINTF("SELINGO ");
3067: if(s & SWRAP) SPRINTF("SWRAP ");
3068: if(s & SDONE) SPRINTF("SDONE ");
3069: if(s & SPIORDY) SPRINTF("SPIORDY ");
3070: if(s & DMADONE) SPRINTF("DMADONE ");
3071:
3072: s=GETPORT(SSTAT1);
3073: if(s & SELTO) SPRINTF("SELTO ");
3074: if(s & ATNTARG) SPRINTF("ATNTARG ");
3075: if(s & SCSIRSTI) SPRINTF("SCSIRSTI ");
3076: if(s & PHASEMIS) SPRINTF("PHASEMIS ");
3077: if(s & BUSFREE) SPRINTF("BUSFREE ");
3078: if(s & SCSIPERR) SPRINTF("SCSIPERR ");
3079: if(s & PHASECHG) SPRINTF("PHASECHG ");
3080: if(s & REQINIT) SPRINTF("REQINIT ");
3081: SPRINTF("); ");
3082:
3083:
3084: SPRINTF("SSTAT (");
3085:
3086: s=GETPORT(SSTAT0) & GETPORT(SIMODE0);
3087:
3088: if(s & TARGET) SPRINTF("TARGET ");
3089: if(s & SELDO) SPRINTF("SELDO ");
3090: if(s & SELDI) SPRINTF("SELDI ");
3091: if(s & SELINGO) SPRINTF("SELINGO ");
3092: if(s & SWRAP) SPRINTF("SWRAP ");
3093: if(s & SDONE) SPRINTF("SDONE ");
3094: if(s & SPIORDY) SPRINTF("SPIORDY ");
3095: if(s & DMADONE) SPRINTF("DMADONE ");
3096:
3097: s=GETPORT(SSTAT1) & GETPORT(SIMODE1);
3098:
3099: if(s & SELTO) SPRINTF("SELTO ");
3100: if(s & ATNTARG) SPRINTF("ATNTARG ");
3101: if(s & SCSIRSTI) SPRINTF("SCSIRSTI ");
3102: if(s & PHASEMIS) SPRINTF("PHASEMIS ");
3103: if(s & BUSFREE) SPRINTF("BUSFREE ");
3104: if(s & SCSIPERR) SPRINTF("SCSIPERR ");
3105: if(s & PHASECHG) SPRINTF("PHASECHG ");
3106: if(s & REQINIT) SPRINTF("REQINIT ");
3107: SPRINTF("); ");
3108:
3109: SPRINTF("SXFRCTL0 (");
3110:
3111: s=GETPORT(SXFRCTL0);
3112: if(s & SCSIEN) SPRINTF("SCSIEN ");
3113: if(s & DMAEN) SPRINTF("DMAEN ");
3114: if(s & CH1) SPRINTF("CH1 ");
3115: if(s & CLRSTCNT) SPRINTF("CLRSTCNT ");
3116: if(s & SPIOEN) SPRINTF("SPIOEN ");
3117: if(s & CLRCH1) SPRINTF("CLRCH1 ");
3118: SPRINTF("); ");
3119:
3120: SPRINTF("SIGNAL (");
3121:
3122: s=GETPORT(SCSISIG);
3123: if(s & ATNI) SPRINTF("ATNI ");
3124: if(s & SELI) SPRINTF("SELI ");
3125: if(s & BSYI) SPRINTF("BSYI ");
3126: if(s & REQI) SPRINTF("REQI ");
3127: if(s & ACKI) SPRINTF("ACKI ");
3128: SPRINTF("); ");
3129:
3130: SPRINTF("SELID (%02x), ", GETPORT(SELID));
3131:
3132: SPRINTF("SSTAT2 (");
3133:
3134: s=GETPORT(SSTAT2);
3135: if(s & SOFFSET) SPRINTF("SOFFSET ");
3136: if(s & SEMPTY) SPRINTF("SEMPTY ");
3137: if(s & SFULL) SPRINTF("SFULL ");
3138: SPRINTF("); SFCNT (%d); ", s & (SFULL|SFCNT));
3139:
3140: s=GETPORT(SSTAT3);
3141: SPRINTF("SCSICNT (%d), OFFCNT(%d), ", (s&0xf0)>>4, s&0x0f);
3142:
3143: SPRINTF("SSTAT4 (");
3144: s=GETPORT(SSTAT4);
3145: if(s & SYNCERR) SPRINTF("SYNCERR ");
3146: if(s & FWERR) SPRINTF("FWERR ");
3147: if(s & FRERR) SPRINTF("FRERR ");
3148: SPRINTF("); ");
3149:
3150: SPRINTF("DMACNTRL0 (");
3151: s=GETPORT(DMACNTRL0);
3152: SPRINTF("%s ", s & _8BIT ? "8BIT" : "16BIT");
3153: SPRINTF("%s ", s & DMA ? "DMA" : "PIO" );
3154: SPRINTF("%s ", s & WRITE_READ ? "WRITE" : "READ" );
3155: if(s & ENDMA) SPRINTF("ENDMA ");
3156: if(s & INTEN) SPRINTF("INTEN ");
3157: if(s & RSTFIFO) SPRINTF("RSTFIFO ");
3158: if(s & SWINT) SPRINTF("SWINT ");
3159: SPRINTF("); ");
3160:
3161: SPRINTF("DMASTAT (");
3162: s=GETPORT(DMASTAT);
3163: if(s & ATDONE) SPRINTF("ATDONE ");
3164: if(s & WORDRDY) SPRINTF("WORDRDY ");
3165: if(s & DFIFOFULL) SPRINTF("DFIFOFULL ");
3166: if(s & DFIFOEMP) SPRINTF("DFIFOEMP ");
3167: SPRINTF(")\n\n");
3168:
3169: SPRINTF("enabled interrupts (");
3170:
3171: s=GETPORT(SIMODE0);
3172: if(s & ENSELDO) SPRINTF("ENSELDO ");
3173: if(s & ENSELDI) SPRINTF("ENSELDI ");
3174: if(s & ENSELINGO) SPRINTF("ENSELINGO ");
3175: if(s & ENSWRAP) SPRINTF("ENSWRAP ");
3176: if(s & ENSDONE) SPRINTF("ENSDONE ");
3177: if(s & ENSPIORDY) SPRINTF("ENSPIORDY ");
3178: if(s & ENDMADONE) SPRINTF("ENDMADONE ");
3179:
3180: s=GETPORT(SIMODE1);
3181: if(s & ENSELTIMO) SPRINTF("ENSELTIMO ");
3182: if(s & ENATNTARG) SPRINTF("ENATNTARG ");
3183: if(s & ENPHASEMIS) SPRINTF("ENPHASEMIS ");
3184: if(s & ENBUSFREE) SPRINTF("ENBUSFREE ");
3185: if(s & ENSCSIPERR) SPRINTF("ENSCSIPERR ");
3186: if(s & ENPHASECHG) SPRINTF("ENPHASECHG ");
3187: if(s & ENREQINIT) SPRINTF("ENREQINIT ");
3188: SPRINTF(")\n");
3189:
3190: return (pos-start);
3191: }
3192:
3193: #undef SPRINTF
3194: #define SPRINTF(args...) do { if(pos < buffer + length) pos += sprintf(pos, ## args); } while(0)
3195:
3196: int aha152x_proc_info(char *buffer, char **start,
3197: off_t offset, int length, int hostno, int inout)
3198: {
3199: int i;
3200: char *pos = buffer;
3201: struct Scsi_Host *shpnt;
3202: unsigned long flags;
3203: Scsi_Cmnd *ptr;
3204:
3205: for(i=0, shpnt= (struct Scsi_Host *) NULL; i<IRQS; i++)
3206: if(aha152x_host[i] && aha152x_host[i]->host_no == hostno)
3207: shpnt=aha152x_host[i];
3208:
3209: if(!shpnt)
3210: return(-ESRCH);
3211:
3212: if(inout) /* Has data been written to the file ? */
3213: return(aha152x_set_info(buffer, length, shpnt));
3214:
3215: SPRINTF(AHA152X_REVID "\n");
3216:
3217: save_flags(flags);
3218: cli();
3219:
3220: SPRINTF("ioports 0x%04x to 0x%04x\n",
3221: shpnt->io_port, shpnt->io_port+shpnt->n_io_port-1);
3222: SPRINTF("interrupt 0x%02x\n", shpnt->irq);
3223: SPRINTF("disconnection/reconnection %s\n",
3224: HOSTDATA(shpnt)->reconnect ? "enabled" : "disabled");
3225: SPRINTF("parity checking %s\n",
3226: HOSTDATA(shpnt)->parity ? "enabled" : "disabled");
3227: SPRINTF("synchronous transfers %s\n",
3228: HOSTDATA(shpnt)->synchronous ? "enabled" : "disabled");
3229: SPRINTF("%d commands currently queued\n", HOSTDATA(shpnt)->commands);
3230:
3231: if(HOSTDATA(shpnt)->synchronous) {
3232: #if 0
3233: SPRINTF("synchronously operating targets (tick=%ld ns):\n",
3234: 250000000/loops_per_sec);
3235: for(i=0; i<8; i++)
3236: if(HOSTDATA(shpnt)->syncrate[i]&0x7f)
3237: SPRINTF("target %d: period %dT/%ldns; req/ack offset %d\n",
3238: i,
3239: (((HOSTDATA(shpnt)->syncrate[i]&0x70)>>4)+2),
3240: (((HOSTDATA(shpnt)->syncrate[i]&0x70)>>4)+2)*
3241: 250000000/loops_per_sec,
3242: HOSTDATA(shpnt)->syncrate[i]&0x0f);
3243: #else
3244: SPRINTF("synchronously operating targets (tick=50 ns):\n");
3245: for(i=0; i<8; i++)
3246: if(HOSTDATA(shpnt)->syncrate[i]&0x7f)
3247: SPRINTF("target %d: period %dT/%dns; req/ack offset %d\n",
3248: i,
3249: (((HOSTDATA(shpnt)->syncrate[i]&0x70)>>4)+2),
3250: (((HOSTDATA(shpnt)->syncrate[i]&0x70)>>4)+2)*50,
3251: HOSTDATA(shpnt)->syncrate[i]&0x0f);
3252: #endif
3253: }
3254:
3255: #ifdef DEBUG_AHA152X
3256: #define PDEBUG(flags,txt) if(HOSTDATA(shpnt)->debug & flags) SPRINTF("(%s) ", txt);
3257:
3258: SPRINTF("enabled debugging options: ");
3259:
3260: PDEBUG(debug_skipports, "skip ports");
3261: PDEBUG(debug_queue, "queue");
3262: PDEBUG(debug_intr, "interrupt");
3263: PDEBUG(debug_selection, "selection");
3264: PDEBUG(debug_msgo, "message out");
3265: PDEBUG(debug_msgi, "message in");
3266: PDEBUG(debug_status, "status");
3267: PDEBUG(debug_cmd, "command");
3268: PDEBUG(debug_datai, "data in");
3269: PDEBUG(debug_datao, "data out");
3270: PDEBUG(debug_abort, "abort");
3271: PDEBUG(debug_done, "done");
3272: PDEBUG(debug_biosparam, "bios parameters");
3273: PDEBUG(debug_phases, "phases");
3274: PDEBUG(debug_queues, "queues");
3275: PDEBUG(debug_reset, "reset");
3276:
3277: SPRINTF("\n");
3278: #endif
3279:
3280: SPRINTF("\nqueue status:\n");
3281: if(ISSUE_SC) {
3282: SPRINTF("not yet issued commands:\n");
3283: for(ptr=ISSUE_SC; ptr; ptr = (Scsi_Cmnd *) ptr->host_scribble)
3284: pos += get_command(pos, ptr);
3285: } else
3286: SPRINTF("no not yet issued commands\n");
3287:
3288: if(CURRENT_SC) {
3289: SPRINTF("current command:\n");
3290: pos += get_command(pos, CURRENT_SC);
3291: } else
3292: SPRINTF("no current command\n");
3293:
3294: if(DISCONNECTED_SC) {
3295: SPRINTF("disconnected commands:\n");
3296: for(ptr=DISCONNECTED_SC; ptr; ptr = (Scsi_Cmnd *) ptr->host_scribble)
3297: pos += get_command(pos, ptr);
3298: } else
3299: SPRINTF("no disconnected commands\n");
3300:
3301: restore_flags(flags);
3302:
3303: pos += get_ports(shpnt, pos);
3304:
3305: *start=buffer+offset;
3306: if (pos - buffer < offset)
3307: return 0;
3308: else if (pos - buffer - offset < length)
3309: return pos - buffer - offset;
3310: else
3311: return length;
3312: }
3313:
3314: #ifdef MODULE
3315: /* Eventually this will go into an include file, but this will be later */
3316: Scsi_Host_Template driver_template = AHA152X;
3317:
3318: #include "scsi_module.c"
3319: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.