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