[PATCH] remove outdated print_* functions
[linux-2.6.git] / drivers / scsi / aha152x.c
1 /* aha152x.c -- Adaptec AHA-152x driver
2  * Author: Jürgen E. Fischer, fischer@norbit.de
3  * Copyright 1993-2004 Jürgen E. Fischer
4  *
5  * This program is free software; you can redistribute it and/or modify it
6  * under the terms of the GNU General Public License as published by the
7  * Free Software Foundation; either version 2, or (at your option) any
8  * later version.
9  *
10  * This program is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * General Public License for more details.
14  *
15  *
16  * $Id: aha152x.c,v 2.7 2004/01/24 11:42:59 fischer Exp $
17  *
18  * $Log: aha152x.c,v $
19  * Revision 2.7  2004/01/24 11:42:59  fischer
20  * - gather code that is not used by PCMCIA at the end
21  * - move request_region for !PCMCIA case to detection
22  * - migration to new scsi host api (remove legacy code)
23  * - free host scribble before scsi_done
24  * - fix error handling
25  * - one isapnp device added to id_table
26  *
27  * Revision 2.6  2003/10/30 20:52:47  fischer
28  * - interfaces changes for kernel 2.6
29  * - aha152x_probe_one introduced for pcmcia stub
30  * - fixed pnpdev handling
31  * - instead of allocation a new one, reuse command for request sense after check condition and reset
32  * - fixes race in is_complete
33  *
34  * Revision 2.5  2002/04/14 11:24:53  fischer
35  * - isapnp support
36  * - abort fixed
37  * - 2.5 support
38  *
39  * Revision 2.4  2000/12/16 12:53:56  fischer
40  * - allow REQUEST SENSE to be queued
41  * - handle shared PCI interrupts
42  *
43  * Revision 2.3  2000/11/04 16:40:26  fischer
44  * - handle data overruns
45  * - extend timeout for data phases
46  *
47  * Revision 2.2  2000/08/08 19:54:53  fischer
48  * - minor changes
49  *
50  * Revision 2.1  2000/05/17 16:23:17  fischer
51  * - signature update
52  * - fix for data out w/o scatter gather
53  *
54  * Revision 2.0  1999/12/25 15:07:32  fischer
55  * - interrupt routine completly reworked
56  * - basic support for new eh code
57  *
58  * Revision 1.21  1999/11/10 23:46:36  fischer
59  * - default to synchronous operation
60  * - synchronous negotiation fixed
61  * - added timeout to loops
62  * - debugging output can be controlled through procfs
63  *
64  * Revision 1.20  1999/11/07 18:37:31  fischer
65  * - synchronous operation works
66  * - resid support for sg driver
67  *
68  * Revision 1.19  1999/11/02 22:39:59  fischer
69  * - moved leading comments to README.aha152x
70  * - new additional module parameters
71  * - updates for 2.3
72  * - support for the Tripace TC1550 controller
73  * - interrupt handling changed
74  *
75  * Revision 1.18  1996/09/07 20:10:40  fischer
76  * - fixed can_queue handling (multiple outstanding commands working again)
77  *
78  * Revision 1.17  1996/08/17 16:05:14  fischer
79  * - biosparam improved
80  * - interrupt verification
81  * - updated documentation
82  * - cleanups
83  *
84  * Revision 1.16  1996/06/09 00:04:56  root
85  * - added configuration symbols for insmod (aha152x/aha152x1)
86  *
87  * Revision 1.15  1996/04/30 14:52:06  fischer
88  * - proc info fixed
89  * - support for extended translation for >1GB disks
90  *
91  * Revision 1.14  1996/01/17  15:11:20  fischer
92  * - fixed lockup in MESSAGE IN phase after reconnection
93  *
94  * Revision 1.13  1996/01/09  02:15:53  fischer
95  * - some cleanups
96  * - moved request_irq behind controller initialization
97  *   (to avoid spurious interrupts)
98  *
99  * Revision 1.12  1995/12/16  12:26:07  fischer
100  * - barrier()s added
101  * - configurable RESET delay added
102  *
103  * Revision 1.11  1995/12/06  21:18:35  fischer
104  * - some minor updates
105  *
106  * Revision 1.10  1995/07/22  19:18:45  fischer
107  * - support for 2 controllers
108  * - started synchronous data transfers (not working yet)
109  *
110  * Revision 1.9  1995/03/18  09:20:24  root
111  * - patches for PCMCIA and modules
112  *
113  * Revision 1.8  1995/01/21  22:07:19  root
114  * - snarf_region => request_region
115  * - aha152x_intr interface change
116  *
117  * Revision 1.7  1995/01/02  23:19:36  root
118  * - updated COMMAND_SIZE to cmd_len
119  * - changed sti() to restore_flags()
120  * - fixed some #ifdef which generated warnings
121  *
122  * Revision 1.6  1994/11/24  20:35:27  root
123  * - problem with odd number of bytes in fifo fixed
124  *
125  * Revision 1.5  1994/10/30  14:39:56  root
126  * - abort code fixed
127  * - debugging improved
128  *
129  * Revision 1.4  1994/09/12  11:33:01  root
130  * - irqaction to request_irq
131  * - abortion updated
132  *
133  * Revision 1.3  1994/08/04  13:53:05  root
134  * - updates for mid-level-driver changes
135  * - accept unexpected BUSFREE phase as error condition
136  * - parity check now configurable
137  *
138  * Revision 1.2  1994/07/03  12:56:36  root
139  * - cleaned up debugging code
140  * - more tweaking on reset delays
141  * - updated abort/reset code (pretty untested...)
142  *
143  * Revision 1.1  1994/05/28  21:18:49  root
144  * - update for mid-level interface change (abort-reset)
145  * - delays after resets adjusted for some slow devices
146  *
147  * Revision 1.0  1994/03/25  12:52:00  root
148  * - Fixed "more data than expected" problem
149  * - added new BIOS signatures
150  *
151  * Revision 0.102  1994/01/31  20:44:12  root
152  * - minor changes in insw/outsw handling
153  *
154  * Revision 0.101  1993/12/13  01:16:27  root
155  * - fixed STATUS phase (non-GOOD stati were dropped sometimes;
156  *   fixes problems with CD-ROM sector size detection & media change)
157  *
158  * Revision 0.100  1993/12/10  16:58:47  root
159  * - fix for unsuccessful selections in case of non-continuous id assignments
160  *   on the scsi bus.
161  *
162  * Revision 0.99  1993/10/24  16:19:59  root
163  * - fixed DATA IN (rare read errors gone)
164  *
165  * Revision 0.98  1993/10/17  12:54:44  root
166  * - fixed some recent fixes (shame on me)
167  * - moved initialization of scratch area to aha152x_queue
168  *
169  * Revision 0.97  1993/10/09  18:53:53  root
170  * - DATA IN fixed. Rarely left data in the fifo.
171  *
172  * Revision 0.96  1993/10/03  00:53:59  root
173  * - minor changes on DATA IN
174  *
175  * Revision 0.95  1993/09/24  10:36:01  root
176  * - change handling of MSGI after reselection
177  * - fixed sti/cli
178  * - minor changes
179  *
180  * Revision 0.94  1993/09/18  14:08:22  root
181  * - fixed bug in multiple outstanding command code
182  * - changed detection
183  * - support for kernel command line configuration
184  * - reset corrected
185  * - changed message handling
186  *
187  * Revision 0.93  1993/09/15  20:41:19  root
188  * - fixed bugs with multiple outstanding commands
189  *
190  * Revision 0.92  1993/09/13  02:46:33  root
191  * - multiple outstanding commands work (no problems with IBM drive)
192  *
193  * Revision 0.91  1993/09/12  20:51:46  root
194  * added multiple outstanding commands
195  * (some problem with this $%&? IBM device remain)
196  *
197  * Revision 0.9  1993/09/12  11:11:22  root
198  * - corrected auto-configuration
199  * - changed the auto-configuration (added some '#define's)
200  * - added support for dis-/reconnection
201  *
202  * Revision 0.8  1993/09/06  23:09:39  root
203  * - added support for the drive activity light
204  * - minor changes
205  *
206  * Revision 0.7  1993/09/05  14:30:15  root
207  * - improved phase detection
208  * - now using the new snarf_region code of 0.99pl13
209  *
210  * Revision 0.6  1993/09/02  11:01:38  root
211  * first public release; added some signatures and biosparam()
212  *
213  * Revision 0.5  1993/08/30  10:23:30  root
214  * fixed timing problems with my IBM drive
215  *
216  * Revision 0.4  1993/08/29  14:06:52  root
217  * fixed some problems with timeouts due incomplete commands
218  *
219  * Revision 0.3  1993/08/28  15:55:03  root
220  * writing data works too.  mounted and worked on a dos partition
221  *
222  * Revision 0.2  1993/08/27  22:42:07  root
223  * reading data works.  Mounted a msdos partition.
224  *
225  * Revision 0.1  1993/08/25  13:38:30  root
226  * first "damn thing doesn't work" version
227  *
228  * Revision 0.0  1993/08/14  19:54:25  root
229  * empty function bodies; detect() works.
230  *
231  *
232  **************************************************************************
233  
234  see Documentation/scsi/aha152x.txt for configuration details
235
236  **************************************************************************/
237
238 #include <linux/module.h>
239 #include <linux/sched.h>
240 #include <asm/irq.h>
241 #include <asm/io.h>
242 #include <linux/blkdev.h>
243 #include <asm/system.h>
244 #include <linux/errno.h>
245 #include <linux/string.h>
246 #include <linux/wait.h>
247 #include <linux/ioport.h>
248 #include <linux/delay.h>
249 #include <linux/proc_fs.h>
250 #include <linux/interrupt.h>
251 #include <linux/init.h>
252 #include <linux/kernel.h>
253 #include <linux/isapnp.h>
254 #include <linux/spinlock.h>
255 #include <linux/workqueue.h>
256 #include <asm/semaphore.h>
257 #include <scsi/scsicam.h>
258
259 #include "scsi.h"
260 #include <scsi/scsi_dbg.h>
261 #include <scsi/scsi_host.h>
262 #include "aha152x.h"
263
264
265 /* DEFINES */
266
267 /* For PCMCIA cards, always use AUTOCONF */
268 #if defined(PCMCIA) || defined(MODULE)
269 #if !defined(AUTOCONF)
270 #define AUTOCONF
271 #endif
272 #endif
273
274 #if !defined(AUTOCONF) && !defined(SETUP0)
275 #error define AUTOCONF or SETUP0
276 #endif
277
278 #if defined(AHA152X_DEBUG)
279 #define DEBUG_DEFAULT debug_eh
280
281 #define DPRINTK(when,msgs...) \
282         do { if(HOSTDATA(shpnt)->debug & (when)) printk(msgs); } while(0)
283
284 #define DO_LOCK(flags)  \
285         do { \
286                 if(spin_is_locked(&QLOCK)) { \
287                         DPRINTK(debug_intr, DEBUG_LEAD "(%s:%d) already locked at %s:%d\n", CMDINFO(CURRENT_SC), __FUNCTION__, __LINE__, QLOCKER, QLOCKERL); \
288                 } \
289                 DPRINTK(debug_locks, DEBUG_LEAD "(%s:%d) locking\n", CMDINFO(CURRENT_SC), __FUNCTION__, __LINE__); \
290                 spin_lock_irqsave(&QLOCK,flags); \
291                 DPRINTK(debug_locks, DEBUG_LEAD "(%s:%d) locked\n", CMDINFO(CURRENT_SC), __FUNCTION__, __LINE__); \
292                 QLOCKER=__FUNCTION__; \
293                 QLOCKERL=__LINE__; \
294         } while(0)
295
296 #define DO_UNLOCK(flags)        \
297         do { \
298                 DPRINTK(debug_locks, DEBUG_LEAD "(%s:%d) unlocking (locked at %s:%d)\n", CMDINFO(CURRENT_SC), __FUNCTION__, __LINE__, QLOCKER, QLOCKERL); \
299                 spin_unlock_irqrestore(&QLOCK,flags); \
300                 DPRINTK(debug_locks, DEBUG_LEAD "(%s:%d) unlocked\n", CMDINFO(CURRENT_SC), __FUNCTION__, __LINE__); \
301                 QLOCKER="(not locked)"; \
302                 QLOCKERL=0; \
303         } while(0)
304
305 #else
306 #define DPRINTK(when,msgs...)
307 #define DO_LOCK(flags)          spin_lock_irqsave(&QLOCK,flags)
308 #define DO_UNLOCK(flags)        spin_unlock_irqrestore(&QLOCK,flags)
309 #endif
310
311 #define LEAD            "(scsi%d:%d:%d) "
312 #define WARN_LEAD       KERN_WARNING    LEAD
313 #define INFO_LEAD       KERN_INFO       LEAD
314 #define NOTE_LEAD       KERN_NOTICE     LEAD
315 #define ERR_LEAD        KERN_ERR        LEAD
316 #define DEBUG_LEAD      KERN_DEBUG      LEAD
317 #define CMDINFO(cmd) \
318                         (cmd) ? ((cmd)->device->host->host_no) : -1, \
319                         (cmd) ? ((cmd)->device->id & 0x0f) : -1, \
320                         (cmd) ? ((cmd)->device->lun & 0x07) : -1
321
322 #define DELAY_DEFAULT 1000
323
324 #if defined(PCMCIA)
325 #define IRQ_MIN 0
326 #define IRQ_MAX 16
327 #else
328 #define IRQ_MIN 9
329 #if defined(__PPC)
330 #define IRQ_MAX (NR_IRQS-1)
331 #else
332 #define IRQ_MAX 12
333 #endif
334 #endif
335
336 enum {
337         not_issued      = 0x0001,       /* command not yet issued */
338         selecting       = 0x0002,       /* target is beeing selected */
339         identified      = 0x0004,       /* IDENTIFY was sent */
340         disconnected    = 0x0008,       /* target disconnected */
341         completed       = 0x0010,       /* target sent COMMAND COMPLETE */ 
342         aborted         = 0x0020,       /* ABORT was sent */
343         resetted        = 0x0040,       /* BUS DEVICE RESET was sent */
344         spiordy         = 0x0080,       /* waiting for SPIORDY to raise */
345         syncneg         = 0x0100,       /* synchronous negotiation in progress */
346         aborting        = 0x0200,       /* ABORT is pending */
347         resetting       = 0x0400,       /* BUS DEVICE RESET is pending */
348         check_condition = 0x0800,       /* requesting sense after CHECK CONDITION */
349 };
350
351 MODULE_AUTHOR("Jürgen Fischer");
352 MODULE_DESCRIPTION(AHA152X_REVID);
353 MODULE_LICENSE("GPL");
354
355 #if !defined(PCMCIA)
356 #if defined(MODULE)
357 static int io[] = {0, 0};
358 module_param_array(io, int, NULL, 0);
359 MODULE_PARM_DESC(io,"base io address of controller");
360
361 static int irq[] = {0, 0};
362 module_param_array(irq, int, NULL, 0);
363 MODULE_PARM_DESC(irq,"interrupt for controller");
364
365 static int scsiid[] = {7, 7};
366 module_param_array(scsiid, int, NULL, 0);
367 MODULE_PARM_DESC(scsiid,"scsi id of controller");
368
369 static int reconnect[] = {1, 1};
370 module_param_array(reconnect, int, NULL, 0);
371 MODULE_PARM_DESC(reconnect,"allow targets to disconnect");
372
373 static int parity[] = {1, 1};
374 module_param_array(parity, int, NULL, 0);
375 MODULE_PARM_DESC(parity,"use scsi parity");
376
377 static int sync[] = {1, 1};
378 module_param_array(sync, int, NULL, 0);
379 MODULE_PARM_DESC(sync,"use synchronous transfers");
380
381 static int delay[] = {DELAY_DEFAULT, DELAY_DEFAULT};
382 module_param_array(delay, int, NULL, 0);
383 MODULE_PARM_DESC(delay,"scsi reset delay");
384
385 static int exttrans[] = {0, 0};
386 module_param_array(exttrans, int, NULL, 0);
387 MODULE_PARM_DESC(exttrans,"use extended translation");
388
389 #if !defined(AHA152X_DEBUG)
390 static int aha152x[] = {0, 11, 7, 1, 1, 0, DELAY_DEFAULT, 0};
391 module_param_array(aha152x, int, NULL, 0);
392 MODULE_PARM_DESC(aha152x, "parameters for first controller");
393
394 static int aha152x1[] = {0, 11, 7, 1, 1, 0, DELAY_DEFAULT, 0};
395 module_param_array(aha152x1, int, NULL, 0);
396 MODULE_PARM_DESC(aha152x1, "parameters for second controller");
397 #else
398 static int debug[] = {DEBUG_DEFAULT, DEBUG_DEFAULT};
399 module_param_array(debug, int, NULL, 0);
400 MODULE_PARM_DESC(debug, "flags for driver debugging");
401
402 static int aha152x[]   = {0, 11, 7, 1, 1, 1, DELAY_DEFAULT, 0, DEBUG_DEFAULT};
403 module_param_array(aha152x, int, NULL, 0);
404 MODULE_PARM_DESC(aha152x, "parameters for first controller");
405
406 static int aha152x1[]  = {0, 11, 7, 1, 1, 1, DELAY_DEFAULT, 0, DEBUG_DEFAULT};
407 module_param_array(aha152x1, int, NULL, 0);
408 MODULE_PARM_DESC(aha152x1, "parameters for second controller");
409 #endif /* !defined(AHA152X_DEBUG) */
410 #endif /* MODULE */
411
412 #ifdef __ISAPNP__
413 static struct isapnp_device_id id_table[] __devinitdata = {
414         { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
415                 ISAPNP_VENDOR('A','D','P'), ISAPNP_FUNCTION(0x1505), 0 },
416         { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
417                 ISAPNP_VENDOR('A','D','P'), ISAPNP_FUNCTION(0x1530), 0 },
418         { ISAPNP_DEVICE_SINGLE_END, }
419 };
420 MODULE_DEVICE_TABLE(isapnp, id_table);
421 #endif /* ISAPNP */
422
423 #endif /* !PCMCIA */
424
425 static int registered_count=0;
426 static struct Scsi_Host *aha152x_host[2];
427 static Scsi_Host_Template aha152x_driver_template;
428
429 /*
430  * internal states of the host
431  *
432  */ 
433 enum aha152x_state {
434         idle=0,
435         unknown,
436         seldo,
437         seldi,
438         selto,
439         busfree,
440         msgo,
441         cmd,
442         msgi,
443         status,
444         datai,
445         datao,
446         parerr,
447         rsti,
448         maxstate
449 };
450
451 /*
452  * current state information of the host
453  *
454  */
455 struct aha152x_hostdata {
456         Scsi_Cmnd *issue_SC;
457                 /* pending commands to issue */
458
459         Scsi_Cmnd *current_SC;
460                 /* current command on the bus */
461
462         Scsi_Cmnd *disconnected_SC;
463                 /* commands that disconnected */
464
465         Scsi_Cmnd *done_SC;
466                 /* command that was completed */
467
468         spinlock_t lock;
469                 /* host lock */
470
471 #if defined(AHA152X_DEBUG)
472         const char *locker;
473                 /* which function has the lock */
474         int lockerl;    /* where did it get it */
475
476         int debug;      /* current debugging setting */
477 #endif
478
479 #if defined(AHA152X_STAT)
480         int           total_commands;
481         int           disconnections;
482         int           busfree_without_any_action;
483         int           busfree_without_old_command;
484         int           busfree_without_new_command;
485         int           busfree_without_done_command;
486         int           busfree_with_check_condition;
487         int           count[maxstate];
488         int           count_trans[maxstate];
489         unsigned long time[maxstate];
490 #endif
491
492         int commands;           /* current number of commands */
493
494         int reconnect;          /* disconnection allowed */
495         int parity;             /* parity checking enabled */
496         int synchronous;        /* synchronous transferes enabled */
497         int delay;              /* reset out delay */
498         int ext_trans;          /* extended translation enabled */
499
500         int swint;              /* software-interrupt was fired during detect() */
501         int service;            /* bh needs to be run */
502         int in_intr;            /* bh is running */
503
504         /* current state,
505            previous state,
506            last state different from current state */
507         enum aha152x_state state, prevstate, laststate;
508
509         int target;
510                 /* reconnecting target */
511
512         unsigned char syncrate[8];
513                 /* current synchronous transfer agreements */
514
515         unsigned char syncneg[8];
516                 /* 0: no negotiation;
517                  * 1: negotiation in progress;
518                  * 2: negotiation completed
519                  */
520
521         int cmd_i;
522                 /* number of sent bytes of current command */
523
524         int msgi_len;
525                 /* number of received message bytes */
526         unsigned char msgi[256];
527                 /* received message bytes */
528
529         int msgo_i, msgo_len;   
530                 /* number of sent bytes and length of current messages */
531         unsigned char msgo[256];
532                 /* pending messages */
533
534         int data_len;
535                 /* number of sent/received bytes in dataphase */
536
537         unsigned long io_port0;
538         unsigned long io_port1;
539
540 #ifdef __ISAPNP__
541         struct pnp_dev *pnpdev;
542 #endif
543 };
544
545
546 /*
547  * host specific command extension
548  *
549  */
550 struct aha152x_scdata {
551         Scsi_Cmnd *next;        /* next sc in queue */
552         struct semaphore *sem;  /* semaphore to block on */
553 };
554
555
556 /* access macros for hostdata */
557
558 #define HOSTDATA(shpnt)         ((struct aha152x_hostdata *) &shpnt->hostdata)
559
560 #define HOSTNO                  ((shpnt)->host_no)
561
562 #define CURRENT_SC              (HOSTDATA(shpnt)->current_SC)
563 #define DONE_SC                 (HOSTDATA(shpnt)->done_SC)
564 #define ISSUE_SC                (HOSTDATA(shpnt)->issue_SC)
565 #define DISCONNECTED_SC         (HOSTDATA(shpnt)->disconnected_SC)
566 #define QLOCK                   (HOSTDATA(shpnt)->lock)
567 #define QLOCKER                 (HOSTDATA(shpnt)->locker)
568 #define QLOCKERL                (HOSTDATA(shpnt)->lockerl)
569
570 #define STATE                   (HOSTDATA(shpnt)->state)
571 #define PREVSTATE               (HOSTDATA(shpnt)->prevstate)
572 #define LASTSTATE               (HOSTDATA(shpnt)->laststate)
573
574 #define RECONN_TARGET           (HOSTDATA(shpnt)->target)
575
576 #define CMD_I                   (HOSTDATA(shpnt)->cmd_i)
577
578 #define MSGO(i)                 (HOSTDATA(shpnt)->msgo[i])
579 #define MSGO_I                  (HOSTDATA(shpnt)->msgo_i)
580 #define MSGOLEN                 (HOSTDATA(shpnt)->msgo_len)
581 #define ADDMSGO(x)              (MSGOLEN<256 ? (void)(MSGO(MSGOLEN++)=x) : aha152x_error(shpnt,"MSGO overflow"))
582
583 #define MSGI(i)                 (HOSTDATA(shpnt)->msgi[i])
584 #define MSGILEN                 (HOSTDATA(shpnt)->msgi_len)
585 #define ADDMSGI(x)              (MSGILEN<256 ? (void)(MSGI(MSGILEN++)=x) : aha152x_error(shpnt,"MSGI overflow"))
586
587 #define DATA_LEN                (HOSTDATA(shpnt)->data_len)
588
589 #define SYNCRATE                (HOSTDATA(shpnt)->syncrate[CURRENT_SC->device->id])
590 #define SYNCNEG                 (HOSTDATA(shpnt)->syncneg[CURRENT_SC->device->id])
591
592 #define DELAY                   (HOSTDATA(shpnt)->delay)
593 #define EXT_TRANS               (HOSTDATA(shpnt)->ext_trans)
594 #define TC1550                  (HOSTDATA(shpnt)->tc1550)
595 #define RECONNECT               (HOSTDATA(shpnt)->reconnect)
596 #define PARITY                  (HOSTDATA(shpnt)->parity)
597 #define SYNCHRONOUS             (HOSTDATA(shpnt)->synchronous)
598
599 #define HOSTIOPORT0             (HOSTDATA(shpnt)->io_port0)
600 #define HOSTIOPORT1             (HOSTDATA(shpnt)->io_port1)
601
602 #define SCDATA(SCpnt)           ((struct aha152x_scdata *) (SCpnt)->host_scribble)
603 #define SCNEXT(SCpnt)           SCDATA(SCpnt)->next
604 #define SCSEM(SCpnt)            SCDATA(SCpnt)->sem
605
606 #define SG_ADDRESS(buffer)      ((char *) (page_address((buffer)->page)+(buffer)->offset))
607
608 /* state handling */
609 static void seldi_run(struct Scsi_Host *shpnt);
610 static void seldo_run(struct Scsi_Host *shpnt);
611 static void selto_run(struct Scsi_Host *shpnt);
612 static void busfree_run(struct Scsi_Host *shpnt);
613
614 static void msgo_init(struct Scsi_Host *shpnt);
615 static void msgo_run(struct Scsi_Host *shpnt);
616 static void msgo_end(struct Scsi_Host *shpnt);
617
618 static void cmd_init(struct Scsi_Host *shpnt);
619 static void cmd_run(struct Scsi_Host *shpnt);
620 static void cmd_end(struct Scsi_Host *shpnt);
621
622 static void datai_init(struct Scsi_Host *shpnt);
623 static void datai_run(struct Scsi_Host *shpnt);
624 static void datai_end(struct Scsi_Host *shpnt);
625
626 static void datao_init(struct Scsi_Host *shpnt);
627 static void datao_run(struct Scsi_Host *shpnt);
628 static void datao_end(struct Scsi_Host *shpnt);
629
630 static void status_run(struct Scsi_Host *shpnt);
631
632 static void msgi_run(struct Scsi_Host *shpnt);
633 static void msgi_end(struct Scsi_Host *shpnt);
634
635 static void parerr_run(struct Scsi_Host *shpnt);
636 static void rsti_run(struct Scsi_Host *shpnt);
637
638 static void is_complete(struct Scsi_Host *shpnt);
639
640 /*
641  * driver states
642  *
643  */
644 static struct {
645         char            *name;
646         void            (*init)(struct Scsi_Host *);
647         void            (*run)(struct Scsi_Host *);
648         void            (*end)(struct Scsi_Host *);
649         int             spio;
650 } states[] = {
651         { "idle",       NULL,           NULL,           NULL,           0},
652         { "unknown",    NULL,           NULL,           NULL,           0},
653         { "seldo",      NULL,           seldo_run,      NULL,           0},
654         { "seldi",      NULL,           seldi_run,      NULL,           0},
655         { "selto",      NULL,           selto_run,      NULL,           0},
656         { "busfree",    NULL,           busfree_run,    NULL,           0},
657         { "msgo",       msgo_init,      msgo_run,       msgo_end,       1},
658         { "cmd",        cmd_init,       cmd_run,        cmd_end,        1},
659         { "msgi",       NULL,           msgi_run,       msgi_end,       1},
660         { "status",     NULL,           status_run,     NULL,           1},
661         { "datai",      datai_init,     datai_run,      datai_end,      0},
662         { "datao",      datao_init,     datao_run,      datao_end,      0},
663         { "parerr",     NULL,           parerr_run,     NULL,           0},
664         { "rsti",       NULL,           rsti_run,       NULL,           0},
665 };
666
667 /* setup & interrupt */
668 static irqreturn_t intr(int irq, void *dev_id, struct pt_regs *);
669 static void reset_ports(struct Scsi_Host *shpnt);
670 static void aha152x_error(struct Scsi_Host *shpnt, char *msg);
671 static void done(struct Scsi_Host *shpnt, int error);
672
673 /* diagnostics */
674 static void disp_ports(struct Scsi_Host *shpnt);
675 static void show_command(Scsi_Cmnd * ptr);
676 static void show_queues(struct Scsi_Host *shpnt);
677 static void disp_enintr(struct Scsi_Host *shpnt);
678
679
680 /*
681  *  queue services:
682  *
683  */
684 static inline void append_SC(Scsi_Cmnd **SC, Scsi_Cmnd *new_SC)
685 {
686         Scsi_Cmnd *end;
687
688         SCNEXT(new_SC) = NULL;
689         if (!*SC)
690                 *SC = new_SC;
691         else {
692                 for (end = *SC; SCNEXT(end); end = SCNEXT(end))
693                         ;
694                 SCNEXT(end) = new_SC;
695         }
696 }
697
698 static inline Scsi_Cmnd *remove_first_SC(Scsi_Cmnd ** SC)
699 {
700         Scsi_Cmnd *ptr;
701
702         ptr = *SC;
703         if (ptr) {
704                 *SC = SCNEXT(*SC);
705                 SCNEXT(ptr)=NULL;
706         }
707         return ptr;
708 }
709
710 static inline Scsi_Cmnd *remove_lun_SC(Scsi_Cmnd ** SC, int target, int lun)
711 {
712         Scsi_Cmnd *ptr, *prev;
713
714         for (ptr = *SC, prev = NULL;
715              ptr && ((ptr->device->id != target) || (ptr->device->lun != lun));
716              prev = ptr, ptr = SCNEXT(ptr))
717              ;
718
719         if (ptr) {
720                 if (prev)
721                         SCNEXT(prev) = SCNEXT(ptr);
722                 else
723                         *SC = SCNEXT(ptr);
724
725                 SCNEXT(ptr)=NULL;
726         }
727
728         return ptr;
729 }
730
731 static inline Scsi_Cmnd *remove_SC(Scsi_Cmnd **SC, Scsi_Cmnd *SCp)
732 {
733         Scsi_Cmnd *ptr, *prev;
734
735         for (ptr = *SC, prev = NULL;
736              ptr && SCp!=ptr;
737              prev = ptr, ptr = SCNEXT(ptr))
738              ;
739
740         if (ptr) {
741                 if (prev)
742                         SCNEXT(prev) = SCNEXT(ptr);
743                 else
744                         *SC = SCNEXT(ptr);
745
746                 SCNEXT(ptr)=NULL;
747         }
748
749         return ptr;
750 }
751
752 static inline struct Scsi_Host *lookup_irq(int irqno)
753 {
754         int i;
755
756         for(i=0; i<ARRAY_SIZE(aha152x_host); i++)
757                 if(aha152x_host[i] && aha152x_host[i]->irq==irqno)
758                         return aha152x_host[i];
759
760         return NULL;
761 }
762
763 static irqreturn_t swintr(int irqno, void *dev_id, struct pt_regs *regs)
764 {
765         struct Scsi_Host *shpnt = lookup_irq(irqno);
766
767         if (!shpnt) {
768                 printk(KERN_ERR "aha152x: catched software interrupt %d for unknown controller.\n", irqno);
769                 return IRQ_NONE;
770         }
771
772         HOSTDATA(shpnt)->swint++;
773
774         SETPORT(DMACNTRL0, INTEN);
775         return IRQ_HANDLED;
776 }
777
778 struct Scsi_Host *aha152x_probe_one(struct aha152x_setup *setup)
779 {
780         struct Scsi_Host *shpnt;
781
782         shpnt = scsi_host_alloc(&aha152x_driver_template, sizeof(struct aha152x_hostdata));
783         if (!shpnt) {
784                 printk(KERN_ERR "aha152x: scsi_host_alloc failed\n");
785                 return NULL;
786         }
787
788         /* need to have host registered before triggering any interrupt */
789         aha152x_host[registered_count] = shpnt;
790
791         memset(HOSTDATA(shpnt), 0, sizeof *HOSTDATA(shpnt));
792
793         shpnt->io_port   = setup->io_port;
794         shpnt->n_io_port = IO_RANGE;
795         shpnt->irq       = setup->irq;
796
797         if (!setup->tc1550) {
798                 HOSTIOPORT0 = setup->io_port;
799                 HOSTIOPORT1 = setup->io_port;
800         } else {
801                 HOSTIOPORT0 = setup->io_port+0x10;
802                 HOSTIOPORT1 = setup->io_port-0x10;
803         }
804
805         spin_lock_init(&QLOCK);
806         RECONNECT   = setup->reconnect;
807         SYNCHRONOUS = setup->synchronous;
808         PARITY      = setup->parity;
809         DELAY       = setup->delay;
810         EXT_TRANS   = setup->ext_trans;
811
812 #if defined(AHA152X_DEBUG)
813         HOSTDATA(shpnt)->debug = setup->debug;
814 #endif
815
816         SETPORT(SCSIID, setup->scsiid << 4);
817         shpnt->this_id = setup->scsiid;
818
819         if (setup->reconnect)
820                 shpnt->can_queue = AHA152X_MAXQUEUE;
821
822         /* RESET OUT */
823         printk("aha152x: resetting bus...\n");
824         SETPORT(SCSISEQ, SCSIRSTO);
825         mdelay(256);
826         SETPORT(SCSISEQ, 0);
827         mdelay(DELAY);
828
829         reset_ports(shpnt);
830
831         printk(KERN_INFO
832                "aha152x%d%s: "
833                "vital data: rev=%x, "
834                "io=0x%03lx (0x%03lx/0x%03lx), "
835                "irq=%d, "
836                "scsiid=%d, "
837                "reconnect=%s, "
838                "parity=%s, "
839                "synchronous=%s, "
840                "delay=%d, "
841                "extended translation=%s\n",
842                shpnt->host_no, setup->tc1550 ? " (tc1550 mode)" : "",
843                GETPORT(REV) & 0x7,
844                shpnt->io_port, HOSTIOPORT0, HOSTIOPORT1,
845                shpnt->irq,
846                shpnt->this_id,
847                RECONNECT ? "enabled" : "disabled",
848                PARITY ? "enabled" : "disabled",
849                SYNCHRONOUS ? "enabled" : "disabled",
850                DELAY,
851                EXT_TRANS ? "enabled" : "disabled");
852
853         /* not expecting any interrupts */
854         SETPORT(SIMODE0, 0);
855         SETPORT(SIMODE1, 0);
856
857         if( request_irq(shpnt->irq, swintr, SA_INTERRUPT|SA_SHIRQ, "aha152x", shpnt) ) {
858                 printk(KERN_ERR "aha152x%d: irq %d busy.\n", shpnt->host_no, shpnt->irq);
859                 goto out_host_put;
860         }
861
862         HOSTDATA(shpnt)->swint = 0;
863
864         printk(KERN_INFO "aha152x%d: trying software interrupt, ", shpnt->host_no);
865
866         mb();
867         SETPORT(DMACNTRL0, SWINT|INTEN);
868         mdelay(1000);
869         free_irq(shpnt->irq, shpnt);
870
871         if (!HOSTDATA(shpnt)->swint) {
872                 if (TESTHI(DMASTAT, INTSTAT)) {
873                         printk("lost.\n");
874                 } else {
875                         printk("failed.\n");
876                 }
877
878                 SETPORT(DMACNTRL0, INTEN);
879
880                 printk(KERN_ERR "aha152x%d: irq %d possibly wrong.  "
881                                 "Please verify.\n", shpnt->host_no, shpnt->irq);
882                 goto out_host_put;
883         }
884         printk("ok.\n");
885
886
887         /* clear interrupts */
888         SETPORT(SSTAT0, 0x7f);
889         SETPORT(SSTAT1, 0xef);
890
891         if ( request_irq(shpnt->irq, intr, SA_INTERRUPT|SA_SHIRQ, "aha152x", shpnt) ) {
892                 printk(KERN_ERR "aha152x%d: failed to reassign irq %d.\n", shpnt->host_no, shpnt->irq);
893                 goto out_host_put;
894         }
895
896         if( scsi_add_host(shpnt, NULL) ) {
897                 free_irq(shpnt->irq, shpnt);
898                 printk(KERN_ERR "aha152x%d: failed to add host.\n", shpnt->host_no);
899                 goto out_host_put;
900         }
901
902         scsi_scan_host(shpnt);
903
904         registered_count++;
905
906         return shpnt;
907
908 out_host_put:
909         aha152x_host[registered_count]=NULL;
910         scsi_host_put(shpnt);
911
912         return NULL;
913 }
914
915 void aha152x_release(struct Scsi_Host *shpnt)
916 {
917         if(!shpnt)
918                 return;
919
920         if (shpnt->irq)
921                 free_irq(shpnt->irq, shpnt);
922
923 #if !defined(PCMCIA)
924         if (shpnt->io_port)
925                 release_region(shpnt->io_port, IO_RANGE);
926 #endif
927
928 #ifdef __ISAPNP__
929         if (HOSTDATA(shpnt)->pnpdev)
930                 pnp_device_detach(HOSTDATA(shpnt)->pnpdev);
931 #endif
932
933         scsi_remove_host(shpnt);
934         scsi_host_put(shpnt);
935 }
936
937
938 /*
939  * setup controller to generate interrupts depending
940  * on current state (lock has to be acquired)
941  *
942  */ 
943 static int setup_expected_interrupts(struct Scsi_Host *shpnt)
944 {
945         if(CURRENT_SC) {
946                 CURRENT_SC->SCp.phase |= 1 << 16;
947         
948                 if(CURRENT_SC->SCp.phase & selecting) {
949                         DPRINTK(debug_intr, DEBUG_LEAD "expecting: (seldo) (seltimo) (seldi)\n", CMDINFO(CURRENT_SC));
950                         SETPORT(SSTAT1, SELTO);
951                         SETPORT(SIMODE0, ENSELDO | (DISCONNECTED_SC ? ENSELDI : 0));
952                         SETPORT(SIMODE1, ENSELTIMO);
953                 } else {
954                         DPRINTK(debug_intr, DEBUG_LEAD "expecting: (phase change) (busfree) %s\n", CMDINFO(CURRENT_SC), CURRENT_SC->SCp.phase & spiordy ? "(spiordy)" : "");
955                         SETPORT(SIMODE0, (CURRENT_SC->SCp.phase & spiordy) ? ENSPIORDY : 0);
956                         SETPORT(SIMODE1, ENPHASEMIS | ENSCSIRST | ENSCSIPERR | ENBUSFREE); 
957                 }
958         } else if(STATE==seldi) {
959                 DPRINTK(debug_intr, DEBUG_LEAD "expecting: (phase change) (identify)\n", CMDINFO(CURRENT_SC));
960                 SETPORT(SIMODE0, 0);
961                 SETPORT(SIMODE1, ENPHASEMIS | ENSCSIRST | ENSCSIPERR | ENBUSFREE); 
962         } else {
963                 DPRINTK(debug_intr, DEBUG_LEAD "expecting: %s %s\n",
964                         CMDINFO(CURRENT_SC),
965                         DISCONNECTED_SC ? "(reselection)" : "",
966                         ISSUE_SC ? "(busfree)" : "");
967                 SETPORT(SIMODE0, DISCONNECTED_SC ? ENSELDI : 0);
968                 SETPORT(SIMODE1, ENSCSIRST | ( (ISSUE_SC||DONE_SC) ? ENBUSFREE : 0));
969         }
970
971         if(!HOSTDATA(shpnt)->in_intr)
972                 SETBITS(DMACNTRL0, INTEN);
973
974         return TESTHI(DMASTAT, INTSTAT);
975 }
976
977
978 /* 
979  *  Queue a command and setup interrupts for a free bus.
980  */
981 static int aha152x_internal_queue(Scsi_Cmnd *SCpnt, struct semaphore *sem, int phase, void (*done)(Scsi_Cmnd *))
982 {
983         struct Scsi_Host *shpnt = SCpnt->device->host;
984         unsigned long flags;
985
986 #if defined(AHA152X_DEBUG)
987         if (HOSTDATA(shpnt)->debug & debug_queue) {
988                 printk(INFO_LEAD "queue: %p; cmd_len=%d pieces=%d size=%u cmnd=",
989                        CMDINFO(SCpnt), SCpnt, SCpnt->cmd_len, SCpnt->use_sg, SCpnt->request_bufflen);
990                 __scsi_print_command(SCpnt->cmnd);
991         }
992 #endif
993
994         SCpnt->scsi_done        = done;
995         SCpnt->resid            = SCpnt->request_bufflen;
996         SCpnt->SCp.phase        = not_issued | phase;
997         SCpnt->SCp.Status       = CHECK_CONDITION;
998         SCpnt->SCp.Message      = 0;
999         SCpnt->SCp.have_data_in = 0;
1000         SCpnt->SCp.sent_command = 0;
1001
1002         if(SCpnt->SCp.phase & (resetting|check_condition)) {
1003                 if(SCpnt->host_scribble==0 || SCSEM(SCpnt) || SCNEXT(SCpnt)) {
1004                         printk(ERR_LEAD "cannot reuse command\n", CMDINFO(SCpnt));
1005                         return FAILED;
1006                 }
1007         } else {
1008                 SCpnt->host_scribble = kmalloc(sizeof(struct aha152x_scdata), GFP_ATOMIC);
1009                 if(SCpnt->host_scribble==0) {
1010                         printk(ERR_LEAD "allocation failed\n", CMDINFO(SCpnt));
1011                         return FAILED;
1012                 }
1013         }
1014
1015         SCNEXT(SCpnt)           = NULL;
1016         SCSEM(SCpnt)            = sem;
1017
1018         /* setup scratch area
1019            SCp.ptr              : buffer pointer
1020            SCp.this_residual    : buffer length
1021            SCp.buffer           : next buffer
1022            SCp.buffers_residual : left buffers in list
1023            SCp.phase            : current state of the command */
1024         if (SCpnt->use_sg) {
1025                 SCpnt->SCp.buffer           = (struct scatterlist *) SCpnt->request_buffer;
1026                 SCpnt->SCp.ptr              = SG_ADDRESS(SCpnt->SCp.buffer);
1027                 SCpnt->SCp.this_residual    = SCpnt->SCp.buffer->length;
1028                 SCpnt->SCp.buffers_residual = SCpnt->use_sg - 1;
1029         } else {
1030                 SCpnt->SCp.ptr              = (char *) SCpnt->request_buffer;
1031                 SCpnt->SCp.this_residual    = SCpnt->request_bufflen;
1032                 SCpnt->SCp.buffer           = NULL;
1033                 SCpnt->SCp.buffers_residual = 0;
1034         }
1035
1036         DO_LOCK(flags);
1037
1038 #if defined(AHA152X_STAT)
1039         HOSTDATA(shpnt)->total_commands++;
1040 #endif
1041
1042         /* Turn led on, when this is the first command. */
1043         HOSTDATA(shpnt)->commands++;
1044         if (HOSTDATA(shpnt)->commands==1)
1045                 SETPORT(PORTA, 1);
1046
1047         append_SC(&ISSUE_SC, SCpnt);
1048
1049         if(!HOSTDATA(shpnt)->in_intr)
1050                 setup_expected_interrupts(shpnt);
1051
1052         DO_UNLOCK(flags);
1053
1054         return 0;
1055 }
1056
1057 /*
1058  *  queue a command
1059  *
1060  */
1061 static int aha152x_queue(Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *))
1062 {
1063 #if 0
1064         if(*SCpnt->cmnd == REQUEST_SENSE) {
1065                 SCpnt->result = 0;
1066                 done(SCpnt);
1067
1068                 return 0;
1069         }
1070 #endif
1071
1072         return aha152x_internal_queue(SCpnt, NULL, 0, done);
1073 }
1074
1075
1076 /*
1077  *  
1078  *
1079  */
1080 static void reset_done(Scsi_Cmnd *SCpnt)
1081 {
1082 #if 0
1083         struct Scsi_Host *shpnt = SCpnt->host;
1084         DPRINTK(debug_eh, INFO_LEAD "reset_done called\n", CMDINFO(SCpnt));
1085 #endif
1086         if(SCSEM(SCpnt)) {
1087                 up(SCSEM(SCpnt));
1088         } else {
1089                 printk(KERN_ERR "aha152x: reset_done w/o semaphore\n");
1090         }
1091 }
1092
1093 /*
1094  *  Abort a command
1095  *
1096  */
1097 static int aha152x_abort(Scsi_Cmnd *SCpnt)
1098 {
1099         struct Scsi_Host *shpnt = SCpnt->device->host;
1100         Scsi_Cmnd *ptr;
1101         unsigned long flags;
1102
1103 #if defined(AHA152X_DEBUG)
1104         if(HOSTDATA(shpnt)->debug & debug_eh) {
1105                 printk(DEBUG_LEAD "abort(%p)", CMDINFO(SCpnt), SCpnt);
1106                 show_queues(shpnt);
1107         }
1108 #endif
1109
1110         DO_LOCK(flags);
1111
1112         ptr=remove_SC(&ISSUE_SC, SCpnt);
1113
1114         if(ptr) {
1115                 DPRINTK(debug_eh, DEBUG_LEAD "not yet issued - SUCCESS\n", CMDINFO(SCpnt));
1116
1117                 HOSTDATA(shpnt)->commands--;
1118                 if (!HOSTDATA(shpnt)->commands)
1119                         SETPORT(PORTA, 0);
1120                 DO_UNLOCK(flags);
1121
1122                 kfree(SCpnt->host_scribble);
1123                 SCpnt->host_scribble=NULL;
1124
1125                 return SUCCESS;
1126         } 
1127
1128         DO_UNLOCK(flags);
1129
1130         /*
1131          * FIXME:
1132          * for current command: queue ABORT for message out and raise ATN
1133          * for disconnected command: pseudo SC with ABORT message or ABORT on reselection?
1134          *
1135          */
1136
1137         printk(ERR_LEAD "cannot abort running or disconnected command\n", CMDINFO(SCpnt));
1138
1139         return FAILED;
1140 }
1141
1142 static void timer_expired(unsigned long p)
1143 {
1144         Scsi_Cmnd        *SCp   = (Scsi_Cmnd *)p;
1145         struct semaphore *sem   = SCSEM(SCp);
1146         struct Scsi_Host *shpnt = SCp->device->host;
1147         unsigned long flags;
1148
1149         /* remove command from issue queue */
1150         DO_LOCK(flags);
1151         remove_SC(&ISSUE_SC, SCp);
1152         DO_UNLOCK(flags);
1153
1154         up(sem);
1155 }
1156
1157 /*
1158  * Reset a device
1159  *
1160  */
1161 static int aha152x_device_reset(Scsi_Cmnd * SCpnt)
1162 {
1163         struct Scsi_Host *shpnt = SCpnt->device->host;
1164         DECLARE_MUTEX_LOCKED(sem);
1165         struct timer_list timer;
1166         int ret, issued, disconnected;
1167         unsigned long flags;
1168
1169 #if defined(AHA152X_DEBUG)
1170         if(HOSTDATA(shpnt)->debug & debug_eh) {
1171                 printk(INFO_LEAD "aha152x_device_reset(%p)", CMDINFO(SCpnt), SCpnt);
1172                 show_queues(shpnt);
1173         }
1174 #endif
1175
1176         if(CURRENT_SC==SCpnt) {
1177                 printk(ERR_LEAD "cannot reset current device\n", CMDINFO(SCpnt));
1178                 return FAILED;
1179         }
1180
1181         DO_LOCK(flags);
1182         issued       = remove_SC(&ISSUE_SC, SCpnt)==0;
1183         disconnected = issued && remove_SC(&DISCONNECTED_SC, SCpnt);
1184         DO_UNLOCK(flags);
1185
1186         SCpnt->cmd_len         = 0;
1187         SCpnt->use_sg          = 0;
1188         SCpnt->request_buffer  = NULL;
1189         SCpnt->request_bufflen = 0;
1190
1191         init_timer(&timer);
1192         timer.data     = (unsigned long) SCpnt;
1193         timer.expires  = jiffies + 100*HZ;   /* 10s */
1194         timer.function = (void (*)(unsigned long)) timer_expired;
1195
1196         aha152x_internal_queue(SCpnt, &sem, resetting, reset_done);
1197         add_timer(&timer);
1198         down(&sem);
1199         del_timer(&timer);
1200         
1201         SCpnt->cmd_len         = SCpnt->old_cmd_len;
1202         SCpnt->use_sg          = SCpnt->old_use_sg;
1203         SCpnt->request_buffer  = SCpnt->buffer;
1204         SCpnt->request_bufflen = SCpnt->bufflen;
1205
1206         DO_LOCK(flags);
1207
1208         if(SCpnt->SCp.phase & resetted) {
1209                 HOSTDATA(shpnt)->commands--;
1210                 if (!HOSTDATA(shpnt)->commands)
1211                         SETPORT(PORTA, 0);
1212                 kfree(SCpnt->host_scribble);
1213                 SCpnt->host_scribble=NULL;
1214
1215                 ret = SUCCESS;
1216         } else {
1217                 /* requeue */
1218                 if(!issued) {
1219                         append_SC(&ISSUE_SC, SCpnt);
1220                 } else if(disconnected) {
1221                         append_SC(&DISCONNECTED_SC, SCpnt);
1222                 }
1223         
1224                 ret = FAILED;
1225         }
1226
1227         DO_UNLOCK(flags);
1228
1229         spin_lock_irq(shpnt->host_lock);
1230         return ret;
1231 }
1232
1233 static void free_hard_reset_SCs(struct Scsi_Host *shpnt, Scsi_Cmnd **SCs)
1234 {
1235         Scsi_Cmnd *ptr;
1236
1237         ptr=*SCs;
1238         while(ptr) {
1239                 Scsi_Cmnd *next;
1240
1241                 if(SCDATA(ptr)) {
1242                         next = SCNEXT(ptr);
1243                 } else {
1244                         printk(DEBUG_LEAD "queue corrupted at %p\n", CMDINFO(ptr), ptr);
1245                         next = NULL;
1246                 }
1247
1248                 if (!ptr->device->soft_reset) {
1249                         DPRINTK(debug_eh, DEBUG_LEAD "disconnected command %p removed\n", CMDINFO(ptr), ptr);
1250                         remove_SC(SCs, ptr);
1251                         HOSTDATA(shpnt)->commands--;
1252                         kfree(ptr->host_scribble);
1253                         ptr->host_scribble=NULL;
1254                 }
1255
1256                 ptr = next;
1257         }
1258 }
1259
1260 /*
1261  * Reset the bus
1262  *
1263  */
1264 static int aha152x_bus_reset(Scsi_Cmnd *SCpnt)
1265 {
1266         struct Scsi_Host *shpnt = SCpnt->device->host;
1267         unsigned long flags;
1268
1269         DO_LOCK(flags);
1270
1271 #if defined(AHA152X_DEBUG)
1272         if(HOSTDATA(shpnt)->debug & debug_eh) {
1273                 printk(DEBUG_LEAD "aha152x_bus_reset(%p)", CMDINFO(SCpnt), SCpnt);
1274                 show_queues(shpnt);
1275         }
1276 #endif
1277
1278         free_hard_reset_SCs(shpnt, &ISSUE_SC);
1279         free_hard_reset_SCs(shpnt, &DISCONNECTED_SC);
1280
1281         DPRINTK(debug_eh, DEBUG_LEAD "resetting bus\n", CMDINFO(SCpnt));
1282
1283         SETPORT(SCSISEQ, SCSIRSTO);
1284         mdelay(256);
1285         SETPORT(SCSISEQ, 0);
1286         mdelay(DELAY);
1287
1288         DPRINTK(debug_eh, DEBUG_LEAD "bus resetted\n", CMDINFO(SCpnt));
1289
1290         setup_expected_interrupts(shpnt);
1291         if(HOSTDATA(shpnt)->commands==0)
1292                 SETPORT(PORTA, 0);
1293
1294         DO_UNLOCK(flags);
1295
1296         return SUCCESS;
1297 }
1298
1299
1300 /*
1301  *  Restore default values to the AIC-6260 registers and reset the fifos
1302  *
1303  */
1304 static void reset_ports(struct Scsi_Host *shpnt)
1305 {
1306         unsigned long flags;
1307
1308         /* disable interrupts */
1309         SETPORT(DMACNTRL0, RSTFIFO);
1310
1311         SETPORT(SCSISEQ, 0);
1312
1313         SETPORT(SXFRCTL1, 0);
1314         SETPORT(SCSISIG, 0);
1315         SETRATE(0);
1316
1317         /* clear all interrupt conditions */
1318         SETPORT(SSTAT0, 0x7f);
1319         SETPORT(SSTAT1, 0xef);
1320
1321         SETPORT(SSTAT4, SYNCERR | FWERR | FRERR);
1322
1323         SETPORT(DMACNTRL0, 0);
1324         SETPORT(DMACNTRL1, 0);
1325
1326         SETPORT(BRSTCNTRL, 0xf1);
1327
1328         /* clear SCSI fifos and transfer count */
1329         SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
1330         SETPORT(SXFRCTL0, CH1);
1331
1332         DO_LOCK(flags);
1333         setup_expected_interrupts(shpnt);
1334         DO_UNLOCK(flags);
1335 }
1336
1337 /*
1338  * Reset the host (bus and controller)
1339  *
1340  */
1341 int aha152x_host_reset(Scsi_Cmnd * SCpnt)
1342 {
1343 #if defined(AHA152X_DEBUG)
1344         struct Scsi_Host *shpnt = SCpnt->device->host;
1345 #endif
1346
1347         DPRINTK(debug_eh, DEBUG_LEAD "aha152x_host_reset(%p)\n", CMDINFO(SCpnt), SCpnt);
1348
1349         aha152x_bus_reset(SCpnt);
1350
1351         DPRINTK(debug_eh, DEBUG_LEAD "resetting ports\n", CMDINFO(SCpnt));
1352         reset_ports(SCpnt->device->host);
1353
1354         return SUCCESS;
1355 }
1356
1357 /*
1358  * Return the "logical geometry"
1359  *
1360  */
1361 static int aha152x_biosparam(struct scsi_device *sdev, struct block_device *bdev,
1362                 sector_t capacity, int *info_array)
1363 {
1364         struct Scsi_Host *shpnt = sdev->host;
1365
1366         /* try default translation */
1367         info_array[0] = 64;
1368         info_array[1] = 32;
1369         info_array[2] = (unsigned long)capacity / (64 * 32);
1370
1371         /* for disks >1GB do some guessing */
1372         if (info_array[2] >= 1024) {
1373                 int info[3];
1374
1375                 /* try to figure out the geometry from the partition table */
1376                 if (scsicam_bios_param(bdev, capacity, info) < 0 ||
1377                     !((info[0] == 64 && info[1] == 32) || (info[0] == 255 && info[1] == 63))) {
1378                         if (EXT_TRANS) {
1379                                 printk(KERN_NOTICE
1380                                        "aha152x: unable to verify geometry for disk with >1GB.\n"
1381                                        "         using extended translation.\n");
1382                                 info_array[0] = 255;
1383                                 info_array[1] = 63;
1384                                 info_array[2] = (unsigned long)capacity / (255 * 63);
1385                         } else {
1386                                 printk(KERN_NOTICE
1387                                        "aha152x: unable to verify geometry for disk with >1GB.\n"
1388                                        "         Using default translation. Please verify yourself.\n"
1389                                        "         Perhaps you need to enable extended translation in the driver.\n"
1390                                        "         See Documentation/scsi/aha152x.txt for details.\n");
1391                         }
1392                 } else {
1393                         info_array[0] = info[0];
1394                         info_array[1] = info[1];
1395                         info_array[2] = info[2];
1396
1397                         if (info[0] == 255 && !EXT_TRANS) {
1398                                 printk(KERN_NOTICE
1399                                        "aha152x: current partition table is using extended translation.\n"
1400                                        "         using it also, although it's not explicitly enabled.\n");
1401                         }
1402                 }
1403         }
1404
1405         return 0;
1406 }
1407
1408 /*
1409  *  Internal done function
1410  *
1411  */
1412 static void done(struct Scsi_Host *shpnt, int error)
1413 {
1414         if (CURRENT_SC) {
1415                 if(DONE_SC)
1416                         printk(ERR_LEAD "there's already a completed command %p - will cause abort\n", CMDINFO(CURRENT_SC), DONE_SC);
1417
1418                 DONE_SC = CURRENT_SC;
1419                 CURRENT_SC = NULL;
1420                 DONE_SC->result = error;
1421         } else
1422                 printk(KERN_ERR "aha152x: done() called outside of command\n");
1423 }
1424
1425 static struct work_struct aha152x_tq;
1426
1427 /*
1428  * Run service completions on the card with interrupts enabled.
1429  *
1430  */
1431 static void run(void)
1432 {
1433         int i;
1434         for (i = 0; i<ARRAY_SIZE(aha152x_host); i++) {
1435                 struct Scsi_Host *shpnt = aha152x_host[i];
1436                 if (shpnt && HOSTDATA(shpnt)->service) {
1437                         HOSTDATA(shpnt)->service=0;
1438                         is_complete(shpnt);
1439                 }
1440         }
1441 }
1442
1443 /*
1444  *    Interrupts handler
1445  *
1446  */
1447
1448 static irqreturn_t intr(int irqno, void *dev_id, struct pt_regs *regs)
1449 {
1450         struct Scsi_Host *shpnt = lookup_irq(irqno);
1451         unsigned char rev, dmacntrl0;
1452
1453         if (!shpnt) {
1454                 printk(KERN_ERR "aha152x: catched interrupt %d for unknown controller.\n", irqno);
1455                 return IRQ_NONE;
1456         }
1457
1458         /*
1459          * Read a couple of registers that are known to not be all 1's. If
1460          * we read all 1's (-1), that means that either:
1461          *
1462          * a. The host adapter chip has gone bad, and we cannot control it,
1463          *      OR
1464          * b. The host adapter is a PCMCIA card that has been ejected
1465          *
1466          * In either case, we cannot do anything with the host adapter at
1467          * this point in time. So just ignore the interrupt and return.
1468          * In the latter case, the interrupt might actually be meant for
1469          * someone else sharing this IRQ, and that driver will handle it.
1470          */
1471         rev = GETPORT(REV);
1472         dmacntrl0 = GETPORT(DMACNTRL0);
1473         if ((rev == 0xFF) && (dmacntrl0 == 0xFF))
1474                 return IRQ_NONE;
1475
1476         /* no more interrupts from the controller, while we're busy.
1477            INTEN is restored by the BH handler */
1478         CLRBITS(DMACNTRL0, INTEN);
1479
1480 #if 0
1481         /* check if there is already something to be
1482            serviced; should not happen */
1483         if(HOSTDATA(shpnt)->service) {
1484                 printk(KERN_ERR "aha152x%d: lost interrupt (%d)\n", HOSTNO, HOSTDATA(shpnt)->service);
1485                 show_queues(shpnt);
1486         }
1487 #endif
1488         
1489         /* Poke the BH handler */
1490         HOSTDATA(shpnt)->service++;
1491         INIT_WORK(&aha152x_tq, (void *) run, NULL);
1492         schedule_work(&aha152x_tq);
1493         return IRQ_HANDLED;
1494 }
1495
1496 /*
1497  * busfree phase
1498  * - handle completition/disconnection/error of current command
1499  * - start selection for next command (if any)
1500  */
1501 static void busfree_run(struct Scsi_Host *shpnt)
1502 {
1503         unsigned long flags;
1504 #if defined(AHA152X_STAT)
1505         int action=0;
1506 #endif
1507
1508         SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
1509         SETPORT(SXFRCTL0, CH1);
1510
1511         SETPORT(SSTAT1, CLRBUSFREE);
1512         
1513         if(CURRENT_SC) {
1514 #if defined(AHA152X_STAT)
1515                 action++;
1516 #endif
1517                 CURRENT_SC->SCp.phase &= ~syncneg;
1518
1519                 if(CURRENT_SC->SCp.phase & completed) {
1520                         /* target sent COMMAND COMPLETE */
1521                         done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_OK << 16));
1522
1523                 } else if(CURRENT_SC->SCp.phase & aborted) {
1524                         DPRINTK(debug_eh, DEBUG_LEAD "ABORT sent\n", CMDINFO(CURRENT_SC));
1525                         done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_ABORT << 16));
1526
1527                 } else if(CURRENT_SC->SCp.phase & resetted) {
1528                         DPRINTK(debug_eh, DEBUG_LEAD "BUS DEVICE RESET sent\n", CMDINFO(CURRENT_SC));
1529                         done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_RESET << 16));
1530
1531                 } else if(CURRENT_SC->SCp.phase & disconnected) {
1532                         /* target sent DISCONNECT */
1533                         DPRINTK(debug_selection, DEBUG_LEAD "target disconnected at %d/%d\n",
1534                                 CMDINFO(CURRENT_SC),
1535                                 CURRENT_SC->resid,
1536                                 CURRENT_SC->request_bufflen);
1537 #if defined(AHA152X_STAT)
1538                         HOSTDATA(shpnt)->disconnections++;
1539 #endif
1540                         append_SC(&DISCONNECTED_SC, CURRENT_SC);
1541                         CURRENT_SC->SCp.phase |= 1 << 16;
1542                         CURRENT_SC = NULL;
1543
1544                 } else {
1545                         done(shpnt, DID_ERROR << 16);
1546                 }
1547 #if defined(AHA152X_STAT)
1548         } else {
1549                 HOSTDATA(shpnt)->busfree_without_old_command++;
1550 #endif
1551         }
1552
1553         DO_LOCK(flags);
1554
1555         if(DONE_SC) {
1556 #if defined(AHA152X_STAT)
1557                 action++;
1558 #endif
1559
1560                 if(DONE_SC->SCp.phase & check_condition) {
1561 #if 0
1562                         if(HOSTDATA(shpnt)->debug & debug_eh) {
1563                                 printk(ERR_LEAD "received sense: ", CMDINFO(DONE_SC));
1564                                 scsi_print_sense("bh", DONE_SC);
1565                         }
1566 #endif
1567
1568                         /* restore old command */
1569                         memcpy((void *) DONE_SC->cmnd, (void *) DONE_SC->data_cmnd, sizeof(DONE_SC->data_cmnd));
1570                         DONE_SC->request_buffer  = DONE_SC->buffer;
1571                         DONE_SC->request_bufflen = DONE_SC->bufflen;
1572                         DONE_SC->use_sg          = DONE_SC->old_use_sg;
1573                         DONE_SC->cmd_len         = DONE_SC->old_cmd_len;
1574
1575                         DONE_SC->SCp.Status = 0x02;
1576
1577                         HOSTDATA(shpnt)->commands--;
1578                         if (!HOSTDATA(shpnt)->commands)
1579                                 SETPORT(PORTA, 0);      /* turn led off */
1580                 } else if(DONE_SC->SCp.Status==0x02) {
1581 #if defined(AHA152X_STAT)
1582                         HOSTDATA(shpnt)->busfree_with_check_condition++;
1583 #endif
1584 #if 0
1585                         DPRINTK(debug_eh, ERR_LEAD "CHECK CONDITION found\n", CMDINFO(DONE_SC));
1586 #endif
1587
1588                         if(!(DONE_SC->SCp.Status & not_issued)) {
1589                                 Scsi_Cmnd *ptr = DONE_SC;
1590                                 DONE_SC=NULL;
1591 #if 0
1592                                 DPRINTK(debug_eh, ERR_LEAD "requesting sense\n", CMDINFO(ptr));
1593 #endif
1594
1595                                 ptr->cmnd[0]         = REQUEST_SENSE;
1596                                 ptr->cmnd[1]         = 0;
1597                                 ptr->cmnd[2]         = 0;
1598                                 ptr->cmnd[3]         = 0;
1599                                 ptr->cmnd[4]         = sizeof(ptr->sense_buffer);
1600                                 ptr->cmnd[5]         = 0;
1601                                 ptr->cmd_len         = 6;
1602                                 ptr->use_sg          = 0; 
1603                                 ptr->request_buffer  = ptr->sense_buffer;
1604                                 ptr->request_bufflen = sizeof(ptr->sense_buffer);
1605                         
1606                                 DO_UNLOCK(flags);
1607                                 aha152x_internal_queue(ptr, NULL, check_condition, ptr->scsi_done);
1608                                 DO_LOCK(flags);
1609 #if 0
1610                         } else {
1611                                 DPRINTK(debug_eh, ERR_LEAD "command not issued - CHECK CONDITION ignored\n", CMDINFO(DONE_SC));
1612 #endif
1613                         }
1614                 }
1615
1616                 if(DONE_SC && DONE_SC->scsi_done) {
1617 #if defined(AHA152X_DEBUG)
1618                         int hostno=DONE_SC->device->host->host_no;
1619                         int id=DONE_SC->device->id & 0xf;
1620                         int lun=DONE_SC->device->lun & 0x7;
1621 #endif
1622                         Scsi_Cmnd *ptr = DONE_SC;
1623                         DONE_SC=NULL;
1624
1625                         /* turn led off, when no commands are in the driver */
1626                         HOSTDATA(shpnt)->commands--;
1627                         if (!HOSTDATA(shpnt)->commands)
1628                                 SETPORT(PORTA, 0);      /* turn led off */
1629
1630                         if(ptr->scsi_done != reset_done) {
1631                                 kfree(ptr->host_scribble);
1632                                 ptr->host_scribble=NULL;
1633                         }
1634
1635                         DO_UNLOCK(flags);
1636                         DPRINTK(debug_done, DEBUG_LEAD "calling scsi_done(%p)\n", hostno, id, lun, ptr);
1637                         ptr->scsi_done(ptr);
1638                         DPRINTK(debug_done, DEBUG_LEAD "scsi_done(%p) returned\n", hostno, id, lun, ptr);
1639                         DO_LOCK(flags);
1640                 }
1641
1642                 DONE_SC=NULL;
1643 #if defined(AHA152X_STAT)
1644         } else {
1645                 HOSTDATA(shpnt)->busfree_without_done_command++;
1646 #endif
1647         }
1648
1649         if(ISSUE_SC)
1650                 CURRENT_SC = remove_first_SC(&ISSUE_SC);
1651
1652         DO_UNLOCK(flags);
1653
1654         if(CURRENT_SC) {
1655 #if defined(AHA152X_STAT)
1656                 action++;
1657 #endif
1658                 CURRENT_SC->SCp.phase |= selecting;
1659
1660                 DPRINTK(debug_selection, DEBUG_LEAD "selecting target\n", CMDINFO(CURRENT_SC));
1661
1662                 /* clear selection timeout */
1663                 SETPORT(SSTAT1, SELTO);
1664
1665                 SETPORT(SCSIID, (shpnt->this_id << OID_) | CURRENT_SC->device->id);
1666                 SETPORT(SXFRCTL1, (PARITY ? ENSPCHK : 0 ) | ENSTIMER);
1667                 SETPORT(SCSISEQ, ENSELO | ENAUTOATNO | (DISCONNECTED_SC ? ENRESELI : 0));
1668         } else {
1669 #if defined(AHA152X_STAT)
1670                 HOSTDATA(shpnt)->busfree_without_new_command++;
1671 #endif
1672                 SETPORT(SCSISEQ, DISCONNECTED_SC ? ENRESELI : 0);
1673         }
1674
1675 #if defined(AHA152X_STAT)
1676         if(!action)
1677                 HOSTDATA(shpnt)->busfree_without_any_action++;
1678 #endif
1679 }
1680
1681 /*
1682  * Selection done (OUT)
1683  * - queue IDENTIFY message and SDTR to selected target for message out
1684  *   (ATN asserted automagically via ENAUTOATNO in busfree())
1685  */
1686 static void seldo_run(struct Scsi_Host *shpnt)
1687 {
1688         SETPORT(SCSISIG, 0);
1689         SETPORT(SSTAT1, CLRBUSFREE);
1690         SETPORT(SSTAT1, CLRPHASECHG);
1691
1692         CURRENT_SC->SCp.phase &= ~(selecting|not_issued);
1693
1694         SETPORT(SCSISEQ, 0);
1695
1696         if (TESTLO(SSTAT0, SELDO)) {
1697                 printk(ERR_LEAD "aha152x: passing bus free condition\n", CMDINFO(CURRENT_SC));
1698                 done(shpnt, DID_NO_CONNECT << 16);
1699                 return;
1700         }
1701
1702         SETPORT(SSTAT0, CLRSELDO);
1703         
1704         ADDMSGO(IDENTIFY(RECONNECT, CURRENT_SC->device->lun));
1705
1706         if (CURRENT_SC->SCp.phase & aborting) {
1707                 ADDMSGO(ABORT);
1708         } else if (CURRENT_SC->SCp.phase & resetting) {
1709                 ADDMSGO(BUS_DEVICE_RESET);
1710         } else if (SYNCNEG==0 && SYNCHRONOUS) {
1711                 CURRENT_SC->SCp.phase |= syncneg;
1712                 ADDMSGO(EXTENDED_MESSAGE);
1713                 ADDMSGO(3);
1714                 ADDMSGO(EXTENDED_SDTR);
1715                 ADDMSGO(50);            /* 200ns */
1716                 ADDMSGO(8);             /* 8 byte req/ack offset */
1717
1718                 SYNCNEG=1;              /* negotiation in progress */
1719         }
1720
1721         SETRATE(SYNCRATE);
1722 }
1723
1724 /*
1725  * Selection timeout
1726  * - return command to mid-level with failure cause
1727  *
1728  */
1729 static void selto_run(struct Scsi_Host *shpnt)
1730 {
1731         SETPORT(SCSISEQ, 0);            
1732         SETPORT(SSTAT1, CLRSELTIMO);
1733
1734         DPRINTK(debug_selection, DEBUG_LEAD "selection timeout\n", CMDINFO(CURRENT_SC));
1735
1736         if(!CURRENT_SC) {
1737                 DPRINTK(debug_selection, DEBUG_LEAD "!CURRENT_SC\n", CMDINFO(CURRENT_SC));
1738                 return;
1739         }
1740
1741         CURRENT_SC->SCp.phase &= ~selecting;
1742
1743         if (CURRENT_SC->SCp.phase & aborted) {
1744                 DPRINTK(debug_selection, DEBUG_LEAD "aborted\n", CMDINFO(CURRENT_SC));
1745                 done(shpnt, DID_ABORT << 16);
1746         } else if (TESTLO(SSTAT0, SELINGO)) {
1747                 DPRINTK(debug_selection, DEBUG_LEAD "arbitration not won\n", CMDINFO(CURRENT_SC));
1748                 done(shpnt, DID_BUS_BUSY << 16);
1749         } else {
1750                 /* ARBITRATION won, but SELECTION failed */
1751                 DPRINTK(debug_selection, DEBUG_LEAD "selection failed\n", CMDINFO(CURRENT_SC));
1752                 done(shpnt, DID_NO_CONNECT << 16);
1753         }
1754 }
1755
1756 /*
1757  * Selection in done
1758  * - put current command back to issue queue
1759  *   (reconnection of a disconnected nexus instead
1760  *    of successful selection out)
1761  *
1762  */
1763 static void seldi_run(struct Scsi_Host *shpnt)
1764 {
1765         int selid;
1766         int target;
1767         unsigned long flags;
1768
1769         SETPORT(SCSISIG, 0);
1770         SETPORT(SSTAT0, CLRSELDI);
1771         SETPORT(SSTAT1, CLRBUSFREE);
1772         SETPORT(SSTAT1, CLRPHASECHG);
1773
1774         if(CURRENT_SC) {
1775                 if(!(CURRENT_SC->SCp.phase & not_issued))
1776                         printk(ERR_LEAD "command should not have been issued yet\n", CMDINFO(CURRENT_SC));
1777
1778                 DPRINTK(debug_selection, ERR_LEAD "command requeued - reselection\n", CMDINFO(CURRENT_SC));
1779
1780                 DO_LOCK(flags);
1781                 append_SC(&ISSUE_SC, CURRENT_SC);
1782                 DO_UNLOCK(flags);
1783
1784                 CURRENT_SC = NULL;
1785         }
1786
1787         if(!DISCONNECTED_SC) {
1788                 DPRINTK(debug_selection, DEBUG_LEAD "unexpected SELDI ", CMDINFO(CURRENT_SC));
1789                 return;
1790         }
1791
1792         RECONN_TARGET=-1;
1793
1794         selid = GETPORT(SELID) & ~(1 << shpnt->this_id);
1795
1796         if (selid==0) {
1797                 printk("aha152x%d: target id unknown (%02x)\n", HOSTNO, selid);
1798                 return;
1799         }
1800
1801         for(target=7; !(selid & (1 << target)); target--)
1802                 ;
1803
1804         if(selid & ~(1 << target)) {
1805                 printk("aha152x%d: multiple targets reconnected (%02x)\n",
1806                        HOSTNO, selid);
1807         }
1808
1809
1810         SETPORT(SCSIID, (shpnt->this_id << OID_) | target);
1811         SETPORT(SCSISEQ, 0);
1812
1813         SETRATE(HOSTDATA(shpnt)->syncrate[target]);
1814
1815         RECONN_TARGET=target;
1816         DPRINTK(debug_selection, DEBUG_LEAD "target %d reselected (%02x).\n", CMDINFO(CURRENT_SC), target, selid);
1817 }
1818
1819 /*
1820  * message in phase
1821  * - handle initial message after reconnection to identify
1822  *   reconnecting nexus
1823  * - queue command on DISCONNECTED_SC on DISCONNECT message
1824  * - set completed flag on COMMAND COMPLETE
1825  *   (other completition code moved to busfree_run)
1826  * - handle response to SDTR
1827  * - clear synchronous transfer agreements on BUS RESET
1828  *
1829  * FIXME: what about SAVE POINTERS, RESTORE POINTERS?
1830  *
1831  */
1832 static void msgi_run(struct Scsi_Host *shpnt)
1833 {
1834         for(;;) {
1835                 int sstat1 = GETPORT(SSTAT1);
1836
1837                 if(sstat1 & (PHASECHG|PHASEMIS|BUSFREE) || !(sstat1 & REQINIT))
1838                         return;
1839
1840                 if(TESTLO(SSTAT0,SPIORDY)) {
1841                         DPRINTK(debug_msgi, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
1842                         return;
1843                 }       
1844
1845                 ADDMSGI(GETPORT(SCSIDAT));
1846
1847 #if defined(AHA152X_DEBUG)
1848                 if (HOSTDATA(shpnt)->debug & debug_msgi) {
1849                         printk(INFO_LEAD "inbound message %02x ", CMDINFO(CURRENT_SC), MSGI(0));
1850                         scsi_print_msg(&MSGI(0));
1851                         printk("\n");
1852                 }
1853 #endif
1854
1855                 if(!CURRENT_SC) {
1856                         if(LASTSTATE!=seldi) {
1857                                 printk(KERN_ERR "aha152x%d: message in w/o current command not after reselection\n", HOSTNO);
1858                         }
1859
1860                         /*
1861                          * Handle reselection
1862                          */
1863                         if(!(MSGI(0) & IDENTIFY_BASE)) {
1864                                 printk(KERN_ERR "aha152x%d: target didn't identify after reselection\n", HOSTNO);
1865                                 continue;
1866                         }
1867
1868                         CURRENT_SC = remove_lun_SC(&DISCONNECTED_SC, RECONN_TARGET, MSGI(0) & 0x3f);
1869
1870                         if (!CURRENT_SC) {
1871                                 show_queues(shpnt);
1872                                 printk(KERN_ERR "aha152x%d: no disconnected command for target %d/%d\n", HOSTNO, RECONN_TARGET, MSGI(0) & 0x3f);
1873                                 continue;
1874                         }
1875
1876                         DPRINTK(debug_msgi, DEBUG_LEAD "target reconnected\n", CMDINFO(CURRENT_SC));
1877
1878                         CURRENT_SC->SCp.Message = MSGI(0);
1879                         CURRENT_SC->SCp.phase &= ~disconnected;
1880
1881                         MSGILEN=0;
1882
1883                         /* next message if any */
1884                         continue;
1885                 } 
1886
1887                 CURRENT_SC->SCp.Message = MSGI(0);
1888
1889                 switch (MSGI(0)) {
1890                 case DISCONNECT:
1891                         if (!RECONNECT)
1892                                 printk(WARN_LEAD "target was not allowed to disconnect\n", CMDINFO(CURRENT_SC));
1893
1894                         CURRENT_SC->SCp.phase |= disconnected;
1895                         break;
1896
1897                 case COMMAND_COMPLETE:
1898                         if(CURRENT_SC->SCp.phase & completed)
1899                                 DPRINTK(debug_msgi, DEBUG_LEAD "again COMMAND COMPLETE\n", CMDINFO(CURRENT_SC));
1900
1901                         CURRENT_SC->SCp.phase |= completed;
1902                         break;
1903
1904                 case MESSAGE_REJECT:
1905                         if (SYNCNEG==1) {
1906                                 printk(INFO_LEAD "Synchronous Data Transfer Request was rejected\n", CMDINFO(CURRENT_SC));
1907                                 SYNCNEG=2;      /* negotiation completed */
1908                         } else
1909                                 printk(INFO_LEAD "inbound message (MESSAGE REJECT)\n", CMDINFO(CURRENT_SC));
1910                         break;
1911
1912                 case SAVE_POINTERS:
1913                         break;
1914
1915                 case RESTORE_POINTERS:
1916                         break;
1917
1918                 case EXTENDED_MESSAGE:
1919                         if(MSGILEN<2 || MSGILEN<MSGI(1)+2) {
1920                                 /* not yet completed */
1921                                 continue;
1922                         }
1923
1924                         switch (MSGI(2)) {
1925                         case EXTENDED_SDTR:
1926                                 {
1927                                         long ticks;
1928
1929                                         if (MSGI(1) != 3) {
1930                                                 printk(ERR_LEAD "SDTR message length!=3\n", CMDINFO(CURRENT_SC));
1931                                                 break;
1932                                         }
1933
1934                                         if (!HOSTDATA(shpnt)->synchronous)
1935                                                 break;
1936
1937                                         printk(INFO_LEAD, CMDINFO(CURRENT_SC));
1938                                         scsi_print_msg(&MSGI(0));
1939                                         printk("\n");
1940
1941                                         ticks = (MSGI(3) * 4 + 49) / 50;
1942
1943                                         if (syncneg) {
1944                                                 /* negotiation in progress */
1945                                                 if (ticks > 9 || MSGI(4) < 1 || MSGI(4) > 8) {
1946                                                         ADDMSGO(MESSAGE_REJECT);
1947                                                         printk(INFO_LEAD "received Synchronous Data Transfer Request invalid - rejected\n", CMDINFO(CURRENT_SC));
1948                                                         break;
1949                                                 }
1950                                                 
1951                                                 SYNCRATE |= ((ticks - 2) << 4) + MSGI(4);
1952                                         } else if (ticks <= 9 && MSGI(4) >= 1) {
1953                                                 ADDMSGO(EXTENDED_MESSAGE);
1954                                                 ADDMSGO(3);
1955                                                 ADDMSGO(EXTENDED_SDTR);
1956                                                 if (ticks < 4) {
1957                                                         ticks = 4;
1958                                                         ADDMSGO(50);
1959                                                 } else
1960                                                         ADDMSGO(MSGI(3));
1961
1962                                                 if (MSGI(4) > 8)
1963                                                         MSGI(4) = 8;
1964
1965                                                 ADDMSGO(MSGI(4));
1966
1967                                                 SYNCRATE |= ((ticks - 2) << 4) + MSGI(4);
1968                                         } else {
1969                                                 /* requested SDTR is too slow, do it asynchronously */
1970                                                 printk(INFO_LEAD "Synchronous Data Transfer Request too slow - Rejecting\n", CMDINFO(CURRENT_SC));
1971                                                 ADDMSGO(MESSAGE_REJECT);
1972                                         }
1973
1974                                         SYNCNEG=2;              /* negotiation completed */
1975                                         SETRATE(SYNCRATE);
1976                                 }
1977                                 break;
1978
1979                         case BUS_DEVICE_RESET:
1980                                 {
1981                                         int i;
1982
1983                                         for(i=0; i<8; i++) {
1984                                                 HOSTDATA(shpnt)->syncrate[i]=0;
1985                                                 HOSTDATA(shpnt)->syncneg[i]=0;
1986                                         }
1987
1988                                 }
1989                                 break;
1990
1991                         case EXTENDED_MODIFY_DATA_POINTER:
1992                         case EXTENDED_EXTENDED_IDENTIFY:
1993                         case EXTENDED_WDTR:
1994                         default:
1995                                 ADDMSGO(MESSAGE_REJECT);
1996                                 break;
1997                         }
1998                         break;
1999                 }
2000
2001                 MSGILEN=0;
2002         }
2003 }
2004
2005 static void msgi_end(struct Scsi_Host *shpnt)
2006 {
2007         if(MSGILEN>0)
2008                 printk(WARN_LEAD "target left before message completed (%d)\n", CMDINFO(CURRENT_SC), MSGILEN);
2009
2010         if (MSGOLEN > 0 && !(GETPORT(SSTAT1) & BUSFREE)) {
2011                 DPRINTK(debug_msgi, DEBUG_LEAD "msgo pending\n", CMDINFO(CURRENT_SC));
2012                 SETPORT(SCSISIG, P_MSGI | SIG_ATNO);
2013         } 
2014 }
2015
2016 /*
2017  * message out phase
2018  *
2019  */
2020 static void msgo_init(struct Scsi_Host *shpnt)
2021 {
2022         if(MSGOLEN==0) {
2023                 if((CURRENT_SC->SCp.phase & syncneg) && SYNCNEG==2 && SYNCRATE==0) {
2024                         ADDMSGO(IDENTIFY(RECONNECT, CURRENT_SC->device->lun));
2025                 } else {
2026                         printk(INFO_LEAD "unexpected MESSAGE OUT phase; rejecting\n", CMDINFO(CURRENT_SC));
2027                         ADDMSGO(MESSAGE_REJECT);
2028                 }
2029         }
2030
2031 #if defined(AHA152X_DEBUG)
2032         if(HOSTDATA(shpnt)->debug & debug_msgo) {
2033                 int i;
2034
2035                 printk(DEBUG_LEAD "messages( ", CMDINFO(CURRENT_SC));
2036                 for (i=0; i<MSGOLEN; i+=scsi_print_msg(&MSGO(i)), printk(" "))
2037                         ;
2038                 printk(")\n");
2039         }
2040 #endif
2041 }
2042
2043 /*
2044  * message out phase
2045  *
2046  */
2047 static void msgo_run(struct Scsi_Host *shpnt)
2048 {
2049         if(MSGO_I==MSGOLEN)
2050                 DPRINTK(debug_msgo, DEBUG_LEAD "messages all sent (%d/%d)\n", CMDINFO(CURRENT_SC), MSGO_I, MSGOLEN);
2051
2052         while(MSGO_I<MSGOLEN) {
2053                 DPRINTK(debug_msgo, DEBUG_LEAD "message byte %02x (%d/%d)\n", CMDINFO(CURRENT_SC), MSGO(MSGO_I), MSGO_I, MSGOLEN);
2054
2055                 if(TESTLO(SSTAT0, SPIORDY)) {
2056                         DPRINTK(debug_msgo, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
2057                         return;
2058                 }
2059
2060                 if (MSGO_I==MSGOLEN-1) {
2061                         /* Leave MESSAGE OUT after transfer */
2062                         SETPORT(SSTAT1, CLRATNO);
2063                 }
2064
2065
2066                 if (MSGO(MSGO_I) & IDENTIFY_BASE)
2067                         CURRENT_SC->SCp.phase |= identified;
2068
2069                 if (MSGO(MSGO_I)==ABORT)
2070                         CURRENT_SC->SCp.phase |= aborted;
2071
2072                 if (MSGO(MSGO_I)==BUS_DEVICE_RESET)
2073                         CURRENT_SC->SCp.phase |= resetted;
2074
2075                 SETPORT(SCSIDAT, MSGO(MSGO_I++));
2076         }
2077 }
2078
2079 static void msgo_end(struct Scsi_Host *shpnt)
2080 {
2081         if(MSGO_I<MSGOLEN) {
2082                 printk(ERR_LEAD "message sent incompletely (%d/%d)\n", CMDINFO(CURRENT_SC), MSGO_I, MSGOLEN);
2083                 if(SYNCNEG==1) {
2084                         printk(INFO_LEAD "Synchronous Data Transfer Request was rejected\n", CMDINFO(CURRENT_SC));
2085                         SYNCNEG=2;
2086                 }
2087         }
2088                 
2089         MSGO_I  = 0;
2090         MSGOLEN = 0;
2091 }
2092
2093 /* 
2094  * command phase
2095  *
2096  */
2097 static void cmd_init(struct Scsi_Host *shpnt)
2098 {
2099         if (CURRENT_SC->SCp.sent_command) {
2100                 printk(ERR_LEAD "command already sent\n", CMDINFO(CURRENT_SC));
2101                 done(shpnt, DID_ERROR << 16);
2102                 return;
2103         }
2104
2105 #if defined(AHA152X_DEBUG)
2106         if (HOSTDATA(shpnt)->debug & debug_cmd) {
2107                 printk(DEBUG_LEAD "cmd_init: ", CMDINFO(CURRENT_SC));
2108                 __scsi_print_command(CURRENT_SC->cmnd);
2109         }
2110 #endif
2111
2112         CMD_I=0;
2113 }
2114
2115 /*
2116  * command phase
2117  *
2118  */
2119 static void cmd_run(struct Scsi_Host *shpnt)
2120 {
2121         if(CMD_I==CURRENT_SC->cmd_len) {
2122                 DPRINTK(debug_cmd, DEBUG_LEAD "command already completely sent (%d/%d)", CMDINFO(CURRENT_SC), CMD_I, CURRENT_SC->cmd_len);
2123                 disp_ports(shpnt);
2124         }
2125
2126         while(CMD_I<CURRENT_SC->cmd_len) {
2127                 DPRINTK(debug_cmd, DEBUG_LEAD "command byte %02x (%d/%d)\n", CMDINFO(CURRENT_SC), CURRENT_SC->cmnd[CMD_I], CMD_I, CURRENT_SC->cmd_len);
2128
2129                 if(TESTLO(SSTAT0, SPIORDY)) {
2130                         DPRINTK(debug_cmd, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
2131                         return;
2132                 }
2133
2134                 SETPORT(SCSIDAT, CURRENT_SC->cmnd[CMD_I++]);
2135         }
2136 }
2137
2138 static void cmd_end(struct Scsi_Host *shpnt)
2139 {
2140         if(CMD_I<CURRENT_SC->cmd_len)
2141                 printk(ERR_LEAD "command sent incompletely (%d/%d)\n", CMDINFO(CURRENT_SC), CMD_I, CURRENT_SC->cmd_len);
2142         else
2143                 CURRENT_SC->SCp.sent_command++;
2144 }
2145
2146 /*
2147  * status phase
2148  *
2149  */
2150 static void status_run(struct Scsi_Host *shpnt)
2151 {
2152         if(TESTLO(SSTAT0,SPIORDY)) {
2153                 DPRINTK(debug_status, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
2154                 return;
2155         }
2156
2157         CURRENT_SC->SCp.Status = GETPORT(SCSIDAT);
2158
2159 #if defined(AHA152X_DEBUG)
2160         if (HOSTDATA(shpnt)->debug & debug_status) {
2161                 printk(DEBUG_LEAD "inbound status %02x ", CMDINFO(CURRENT_SC), CURRENT_SC->SCp.Status);
2162                 scsi_print_status(CURRENT_SC->SCp.Status);
2163                 printk("\n");
2164         }
2165 #endif
2166 }
2167
2168 /*
2169  * data in phase
2170  *
2171  */
2172 static void datai_init(struct Scsi_Host *shpnt)
2173 {
2174         SETPORT(DMACNTRL0, RSTFIFO);
2175         SETPORT(DMACNTRL0, RSTFIFO|ENDMA);
2176
2177         SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2178         SETPORT(SXFRCTL0, CH1|SCSIEN|DMAEN);
2179
2180         SETPORT(SIMODE0, 0);
2181         SETPORT(SIMODE1, ENSCSIPERR | ENSCSIRST | ENPHASEMIS | ENBUSFREE);
2182
2183         DATA_LEN=0;
2184         DPRINTK(debug_datai,
2185                 DEBUG_LEAD "datai_init: request_bufflen=%d resid=%d\n",
2186                 CMDINFO(CURRENT_SC), CURRENT_SC->request_bufflen, CURRENT_SC->resid);
2187 }
2188
2189 static void datai_run(struct Scsi_Host *shpnt)
2190 {
2191         unsigned long the_time;
2192         int fifodata, data_count;
2193
2194         /*
2195          * loop while the phase persists or the fifos are not empty
2196          *
2197          */
2198         while(TESTLO(DMASTAT, INTSTAT) || TESTLO(DMASTAT, DFIFOEMP) || TESTLO(SSTAT2, SEMPTY)) {
2199                 /* FIXME: maybe this should be done by setting up
2200                  * STCNT to trigger ENSWRAP interrupt, instead of
2201                  * polling for DFIFOFULL
2202                  */
2203                 the_time=jiffies + 100*HZ;
2204                 while(TESTLO(DMASTAT, DFIFOFULL|INTSTAT) && time_before(jiffies,the_time))
2205                         barrier();
2206
2207                 if(TESTLO(DMASTAT, DFIFOFULL|INTSTAT)) {
2208                         printk(ERR_LEAD "datai timeout", CMDINFO(CURRENT_SC));
2209                         disp_ports(shpnt);
2210                         break;
2211                 }
2212
2213                 if(TESTHI(DMASTAT, DFIFOFULL)) {
2214                         fifodata = 128;
2215                 } else {
2216                         the_time=jiffies + 100*HZ;
2217                         while(TESTLO(SSTAT2, SEMPTY) && time_before(jiffies,the_time))
2218                                 barrier();
2219
2220                         if(TESTLO(SSTAT2, SEMPTY)) {
2221                                 printk(ERR_LEAD "datai sempty timeout", CMDINFO(CURRENT_SC));
2222                                 disp_ports(shpnt);
2223                                 break;
2224                         }
2225
2226                         fifodata = GETPORT(FIFOSTAT);
2227                 }
2228
2229                 if(CURRENT_SC->SCp.this_residual>0) {
2230                         while(fifodata>0 && CURRENT_SC->SCp.this_residual>0) {
2231                                 data_count = fifodata>CURRENT_SC->SCp.this_residual ?
2232                                                 CURRENT_SC->SCp.this_residual :
2233                                                 fifodata;
2234                                 fifodata -= data_count;
2235
2236                                 if(data_count & 1) {
2237                                         DPRINTK(debug_datai, DEBUG_LEAD "8bit\n", CMDINFO(CURRENT_SC));
2238                                         SETPORT(DMACNTRL0, ENDMA|_8BIT);
2239                                         *CURRENT_SC->SCp.ptr++ = GETPORT(DATAPORT);
2240                                         CURRENT_SC->SCp.this_residual--;
2241                                         DATA_LEN++;
2242                                         SETPORT(DMACNTRL0, ENDMA);
2243                                 }
2244         
2245                                 if(data_count > 1) {
2246                                         DPRINTK(debug_datai, DEBUG_LEAD "16bit(%d)\n", CMDINFO(CURRENT_SC), data_count);
2247                                         data_count >>= 1;
2248                                         insw(DATAPORT, CURRENT_SC->SCp.ptr, data_count);
2249                                         CURRENT_SC->SCp.ptr           += 2 * data_count;
2250                                         CURRENT_SC->SCp.this_residual -= 2 * data_count;
2251                                         DATA_LEN                      += 2 * data_count;
2252                                 }
2253         
2254                                 if(CURRENT_SC->SCp.this_residual==0 && CURRENT_SC->SCp.buffers_residual>0) {
2255                                         /* advance to next buffer */
2256                                         CURRENT_SC->SCp.buffers_residual--;
2257                                         CURRENT_SC->SCp.buffer++;
2258                                         CURRENT_SC->SCp.ptr           = SG_ADDRESS(CURRENT_SC->SCp.buffer);
2259                                         CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length;
2260                                 } 
2261                         }
2262                 } else if(fifodata>0) { 
2263                         printk(ERR_LEAD "no buffers left for %d(%d) bytes (data overrun!?)\n", CMDINFO(CURRENT_SC), fifodata, GETPORT(FIFOSTAT));
2264                         SETPORT(DMACNTRL0, ENDMA|_8BIT);
2265                         while(fifodata>0) {
2266                                 int data;
2267                                 data=GETPORT(DATAPORT);
2268                                 DPRINTK(debug_datai, DEBUG_LEAD "data=%02x\n", CMDINFO(CURRENT_SC), data);
2269                                 fifodata--;
2270                                 DATA_LEN++;
2271                         }
2272                         SETPORT(DMACNTRL0, ENDMA|_8BIT);
2273                 }
2274         }
2275
2276         if(TESTLO(DMASTAT, INTSTAT) ||
2277            TESTLO(DMASTAT, DFIFOEMP) ||
2278            TESTLO(SSTAT2, SEMPTY) ||
2279            GETPORT(FIFOSTAT)>0) {
2280                 /*
2281                  * something went wrong, if there's something left in the fifos
2282                  * or the phase didn't change
2283                  */
2284                 printk(ERR_LEAD "fifos should be empty and phase should have changed\n", CMDINFO(CURRENT_SC));
2285                 disp_ports(shpnt);
2286         }
2287
2288         if(DATA_LEN!=GETSTCNT()) {
2289                 printk(ERR_LEAD
2290                        "manual transfer count differs from automatic (count=%d;stcnt=%d;diff=%d;fifostat=%d)",
2291                        CMDINFO(CURRENT_SC), DATA_LEN, GETSTCNT(), GETSTCNT()-DATA_LEN, GETPORT(FIFOSTAT));
2292                 disp_ports(shpnt);
2293                 mdelay(10000);
2294         }
2295 }
2296
2297 static void datai_end(struct Scsi_Host *shpnt)
2298 {
2299         CURRENT_SC->resid -= GETSTCNT();
2300
2301         DPRINTK(debug_datai,
2302                 DEBUG_LEAD "datai_end: request_bufflen=%d resid=%d stcnt=%d\n",
2303                 CMDINFO(CURRENT_SC), CURRENT_SC->request_bufflen, CURRENT_SC->resid, GETSTCNT());
2304
2305         SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2306         SETPORT(DMACNTRL0, 0);
2307 }
2308
2309 /*
2310  * data out phase
2311  *
2312  */
2313 static void datao_init(struct Scsi_Host *shpnt)
2314 {
2315         SETPORT(DMACNTRL0, WRITE_READ | RSTFIFO);
2316         SETPORT(DMACNTRL0, WRITE_READ | ENDMA);
2317
2318         SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2319         SETPORT(SXFRCTL0, CH1|SCSIEN|DMAEN);
2320
2321         SETPORT(SIMODE0, 0);
2322         SETPORT(SIMODE1, ENSCSIPERR | ENSCSIRST | ENPHASEMIS | ENBUSFREE );
2323
2324         DATA_LEN = CURRENT_SC->resid;
2325
2326         DPRINTK(debug_datao,
2327                 DEBUG_LEAD "datao_init: request_bufflen=%d; resid=%d\n",
2328                 CMDINFO(CURRENT_SC), CURRENT_SC->request_bufflen, CURRENT_SC->resid);
2329 }
2330
2331 static void datao_run(struct Scsi_Host *shpnt)
2332 {
2333         unsigned long the_time;
2334         int data_count;
2335
2336         /* until phase changes or all data sent */
2337         while(TESTLO(DMASTAT, INTSTAT) && CURRENT_SC->SCp.this_residual>0) {
2338                 data_count = 128;
2339                 if(data_count > CURRENT_SC->SCp.this_residual)
2340                         data_count=CURRENT_SC->SCp.this_residual;
2341
2342                 if(TESTLO(DMASTAT, DFIFOEMP)) {
2343                         printk(ERR_LEAD "datao fifo not empty (%d)", CMDINFO(CURRENT_SC), GETPORT(FIFOSTAT));
2344                         disp_ports(shpnt);
2345                         break;
2346                 }
2347
2348                 if(data_count & 1) {
2349                         SETPORT(DMACNTRL0,WRITE_READ|ENDMA|_8BIT);
2350                         SETPORT(DATAPORT, *CURRENT_SC->SCp.ptr++);
2351                         CURRENT_SC->SCp.this_residual--;
2352                         CURRENT_SC->resid--;
2353                         SETPORT(DMACNTRL0,WRITE_READ|ENDMA);
2354                 }
2355
2356                 if(data_count > 1) {
2357                         data_count >>= 1;
2358                         outsw(DATAPORT, CURRENT_SC->SCp.ptr, data_count);
2359                         CURRENT_SC->SCp.ptr           += 2 * data_count;
2360                         CURRENT_SC->SCp.this_residual -= 2 * data_count;
2361                         CURRENT_SC->resid             -= 2 * data_count;
2362                 }
2363
2364                 if(CURRENT_SC->SCp.this_residual==0 && CURRENT_SC->SCp.buffers_residual>0) {
2365                         /* advance to next buffer */
2366                         CURRENT_SC->SCp.buffers_residual--;
2367                         CURRENT_SC->SCp.buffer++;
2368                         CURRENT_SC->SCp.ptr           = SG_ADDRESS(CURRENT_SC->SCp.buffer);
2369                         CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length;
2370                 }
2371
2372                 the_time=jiffies + 100*HZ;
2373                 while(TESTLO(DMASTAT, DFIFOEMP|INTSTAT) && time_before(jiffies,the_time))
2374                         barrier();
2375
2376                 if(TESTLO(DMASTAT, DFIFOEMP|INTSTAT)) {
2377                         printk(ERR_LEAD "dataout timeout", CMDINFO(CURRENT_SC));
2378                         disp_ports(shpnt);
2379                         break;
2380                 }
2381         }
2382 }
2383
2384 static void datao_end(struct Scsi_Host *shpnt)
2385 {
2386         if(TESTLO(DMASTAT, DFIFOEMP)) {
2387                 int data_count = (DATA_LEN - CURRENT_SC->resid) - GETSTCNT();
2388
2389                 DPRINTK(debug_datao, DEBUG_LEAD "datao: %d bytes to resend (%d written, %d transferred)\n",
2390                         CMDINFO(CURRENT_SC),
2391                         data_count,
2392                         DATA_LEN-CURRENT_SC->resid,
2393                         GETSTCNT());
2394
2395                 CURRENT_SC->resid += data_count;
2396
2397                 if(CURRENT_SC->use_sg) {
2398                         data_count -= CURRENT_SC->SCp.ptr - SG_ADDRESS(CURRENT_SC->SCp.buffer);
2399                         while(data_count>0) {
2400                                 CURRENT_SC->SCp.buffer--;
2401                                 CURRENT_SC->SCp.buffers_residual++;
2402                                 data_count -= CURRENT_SC->SCp.buffer->length;
2403                         }
2404                         CURRENT_SC->SCp.ptr           = SG_ADDRESS(CURRENT_SC->SCp.buffer) - data_count;
2405                         CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length + data_count;
2406                 } else {
2407                         CURRENT_SC->SCp.ptr           -= data_count;
2408                         CURRENT_SC->SCp.this_residual += data_count;
2409                 }
2410         }
2411
2412         DPRINTK(debug_datao, DEBUG_LEAD "datao_end: request_bufflen=%d; resid=%d; stcnt=%d\n",
2413                 CMDINFO(CURRENT_SC),
2414                 CURRENT_SC->request_bufflen,
2415                 CURRENT_SC->resid,
2416                 GETSTCNT());
2417
2418         SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
2419         SETPORT(SXFRCTL0, CH1);
2420
2421         SETPORT(DMACNTRL0, 0);
2422 }
2423
2424 /*
2425  * figure out what state we're in
2426  *
2427  */
2428 static int update_state(struct Scsi_Host *shpnt)
2429 {
2430         int dataphase=0;
2431         unsigned int stat0 = GETPORT(SSTAT0);
2432         unsigned int stat1 = GETPORT(SSTAT1);
2433
2434         PREVSTATE = STATE;
2435         STATE=unknown;
2436
2437         if(stat1 & SCSIRSTI) {
2438                 STATE=rsti;
2439                 SETPORT(SCSISEQ,0);
2440                 SETPORT(SSTAT1,SCSIRSTI);
2441         } else if(stat0 & SELDI && PREVSTATE==busfree) {
2442                 STATE=seldi;
2443         } else if(stat0 & SELDO && CURRENT_SC && (CURRENT_SC->SCp.phase & selecting)) {
2444                 STATE=seldo;
2445         } else if(stat1 & SELTO) {
2446                 STATE=selto;
2447         } else if(stat1 & BUSFREE) {
2448                 STATE=busfree;
2449                 SETPORT(SSTAT1,BUSFREE);
2450         } else if(stat1 & SCSIPERR) {
2451                 STATE=parerr;
2452                 SETPORT(SSTAT1,SCSIPERR);
2453         } else if(stat1 & REQINIT) {
2454                 switch(GETPORT(SCSISIG) & P_MASK) {
2455                 case P_MSGI:    STATE=msgi;     break;
2456                 case P_MSGO:    STATE=msgo;     break;
2457                 case P_DATAO:   STATE=datao;    break;
2458                 case P_DATAI:   STATE=datai;    break;
2459                 case P_STATUS:  STATE=status;   break;
2460                 case P_CMD:     STATE=cmd;      break;
2461                 }
2462                 dataphase=1;
2463         }
2464
2465         if((stat0 & SELDI) && STATE!=seldi && !dataphase) {
2466                 printk(INFO_LEAD "reselection missed?", CMDINFO(CURRENT_SC));
2467                 disp_ports(shpnt);
2468         }
2469
2470         if(STATE!=PREVSTATE) {
2471                 LASTSTATE=PREVSTATE;
2472         }
2473
2474         return dataphase;
2475 }
2476
2477 /*
2478  * handle parity error
2479  *
2480  * FIXME: in which phase?
2481  *
2482  */
2483 static void parerr_run(struct Scsi_Host *shpnt)
2484 {
2485         printk(ERR_LEAD "parity error\n", CMDINFO(CURRENT_SC));
2486         done(shpnt, DID_PARITY << 16);
2487 }
2488
2489 /*
2490  * handle reset in
2491  *
2492  */
2493 static void rsti_run(struct Scsi_Host *shpnt)
2494 {
2495         Scsi_Cmnd *ptr;
2496
2497         printk(KERN_NOTICE "aha152x%d: scsi reset in\n", HOSTNO);
2498         
2499         ptr=DISCONNECTED_SC;
2500         while(ptr) {
2501                 Scsi_Cmnd *next = SCNEXT(ptr);
2502
2503                 if (!ptr->device->soft_reset) {
2504                         remove_SC(&DISCONNECTED_SC, ptr);
2505
2506                         kfree(ptr->host_scribble);
2507                         ptr->host_scribble=NULL;
2508
2509                         ptr->result =  DID_RESET << 16;
2510                         ptr->scsi_done(ptr);
2511                 }
2512
2513                 ptr = next;
2514         }
2515
2516         if(CURRENT_SC && !CURRENT_SC->device->soft_reset)
2517                 done(shpnt, DID_RESET << 16 );
2518 }
2519
2520
2521 /*
2522  * bottom-half handler
2523  *
2524  */
2525 static void is_complete(struct Scsi_Host *shpnt)
2526 {
2527         int dataphase;
2528         unsigned long flags;
2529         int pending;
2530
2531         DO_LOCK(flags);
2532         if(HOSTDATA(shpnt)->in_intr) {
2533                 DO_UNLOCK(flags);
2534                 /* aha152x_error never returns.. */
2535                 aha152x_error(shpnt, "bottom-half already running!?");
2536         }
2537         HOSTDATA(shpnt)->in_intr++;
2538
2539         /*
2540          * loop while there are interrupt conditions pending
2541          *
2542          */
2543         do {
2544                 unsigned long start = jiffies;
2545                 DO_UNLOCK(flags);
2546
2547                 dataphase=update_state(shpnt);
2548
2549                 DPRINTK(debug_phases, LEAD "start %s %s(%s)\n", CMDINFO(CURRENT_SC), states[STATE].name, states[PREVSTATE].name, states[LASTSTATE].name);
2550
2551                 /*
2552                  * end previous state
2553                  *
2554                  */
2555                 if(PREVSTATE!=STATE && states[PREVSTATE].end)
2556                         states[PREVSTATE].end(shpnt);
2557
2558                 /*
2559                  * disable SPIO mode if previous phase used it
2560                  * and this one doesn't
2561                  *
2562                  */
2563                 if(states[PREVSTATE].spio && !states[STATE].spio) {
2564                         SETPORT(SXFRCTL0, CH1);
2565                         SETPORT(DMACNTRL0, 0);
2566                         if(CURRENT_SC)
2567                                 CURRENT_SC->SCp.phase &= ~spiordy;
2568                 }
2569
2570                 /*
2571                  * accept current dataphase phase
2572                  *
2573                  */
2574                 if(dataphase) {
2575                         SETPORT(SSTAT0, REQINIT);
2576                         SETPORT(SCSISIG, GETPORT(SCSISIG) & P_MASK);
2577                         SETPORT(SSTAT1, PHASECHG);  
2578                 }
2579                 
2580                 /*
2581                  * enable SPIO mode if previous didn't use it
2582                  * and this one does
2583                  *
2584                  */
2585                 if(!states[PREVSTATE].spio && states[STATE].spio) {
2586                         SETPORT(DMACNTRL0, 0);
2587                         SETPORT(SXFRCTL0, CH1|SPIOEN);
2588                         if(CURRENT_SC)
2589                                 CURRENT_SC->SCp.phase |= spiordy;
2590                 }
2591                 
2592                 /*
2593                  * initialize for new state
2594                  *
2595                  */
2596                 if(PREVSTATE!=STATE && states[STATE].init)
2597                         states[STATE].init(shpnt);
2598                 
2599                 /*
2600                  * handle current state
2601                  *
2602                  */
2603                 if(states[STATE].run)
2604                         states[STATE].run(shpnt);
2605                 else
2606                         printk(ERR_LEAD "unexpected state (%x)\n", CMDINFO(CURRENT_SC), STATE);
2607                 
2608                 /*
2609                  * setup controller to interrupt on
2610                  * the next expected condition and
2611                  * loop if it's already there
2612                  *
2613                  */
2614                 DO_LOCK(flags);
2615                 pending=setup_expected_interrupts(shpnt);
2616 #if defined(AHA152X_STAT)
2617                 HOSTDATA(shpnt)->count[STATE]++;
2618                 if(PREVSTATE!=STATE)
2619                         HOSTDATA(shpnt)->count_trans[STATE]++;
2620                 HOSTDATA(shpnt)->time[STATE] += jiffies-start;
2621 #endif
2622
2623                 DPRINTK(debug_phases, LEAD "end %s %s(%s)\n", CMDINFO(CURRENT_SC), states[STATE].name, states[PREVSTATE].name, states[LASTSTATE].name);
2624         } while(pending);
2625
2626         /*
2627          * enable interrupts and leave bottom-half
2628          *
2629          */
2630         HOSTDATA(shpnt)->in_intr--;
2631         SETBITS(DMACNTRL0, INTEN);
2632         DO_UNLOCK(flags);
2633 }
2634
2635
2636 /* 
2637  * Dump the current driver status and panic
2638  */
2639 static void aha152x_error(struct Scsi_Host *shpnt, char *msg)
2640 {
2641         printk(KERN_EMERG "\naha152x%d: %s\n", HOSTNO, msg);
2642         show_queues(shpnt);
2643         panic("aha152x panic\n");
2644 }
2645
2646 /*
2647  * Display registers of AIC-6260
2648  */
2649 static void disp_ports(struct Scsi_Host *shpnt)
2650 {
2651 #if defined(AHA152X_DEBUG)
2652         int s;
2653
2654         printk("\n%s: %s(%s) ",
2655                 CURRENT_SC ? "busy" : "waiting",
2656                 states[STATE].name,
2657                 states[PREVSTATE].name);
2658
2659         s = GETPORT(SCSISEQ);
2660         printk("SCSISEQ( ");
2661         if (s & TEMODEO)
2662                 printk("TARGET MODE ");
2663         if (s & ENSELO)
2664                 printk("SELO ");
2665         if (s & ENSELI)
2666                 printk("SELI ");
2667         if (s & ENRESELI)
2668                 printk("RESELI ");
2669         if (s & ENAUTOATNO)
2670                 printk("AUTOATNO ");
2671         if (s & ENAUTOATNI)
2672                 printk("AUTOATNI ");
2673         if (s & ENAUTOATNP)
2674                 printk("AUTOATNP ");
2675         if (s & SCSIRSTO)
2676                 printk("SCSIRSTO ");
2677         printk(");");
2678
2679         printk(" SCSISIG(");
2680         s = GETPORT(SCSISIG);
2681         switch (s & P_MASK) {
2682         case P_DATAO:
2683                 printk("DATA OUT");
2684                 break;
2685         case P_DATAI:
2686                 printk("DATA IN");
2687                 break;
2688         case P_CMD:
2689                 printk("COMMAND");
2690                 break;
2691         case P_STATUS:
2692                 printk("STATUS");
2693                 break;
2694         case P_MSGO:
2695                 printk("MESSAGE OUT");
2696                 break;
2697         case P_MSGI:
2698                 printk("MESSAGE IN");
2699                 break;
2700         default:
2701                 printk("*invalid*");
2702                 break;
2703         }
2704
2705         printk("); ");
2706
2707         printk("INTSTAT (%s); ", TESTHI(DMASTAT, INTSTAT) ? "hi" : "lo");
2708
2709         printk("SSTAT( ");
2710         s = GETPORT(SSTAT0);
2711         if (s & TARGET)
2712                 printk("TARGET ");
2713         if (s & SELDO)
2714                 printk("SELDO ");
2715         if (s & SELDI)
2716                 printk("SELDI ");
2717         if (s & SELINGO)
2718                 printk("SELINGO ");
2719         if (s & SWRAP)
2720                 printk("SWRAP ");
2721         if (s & SDONE)
2722                 printk("SDONE ");
2723         if (s & SPIORDY)
2724                 printk("SPIORDY ");
2725         if (s & DMADONE)
2726                 printk("DMADONE ");
2727
2728         s = GETPORT(SSTAT1);
2729         if (s & SELTO)
2730                 printk("SELTO ");
2731         if (s & ATNTARG)
2732                 printk("ATNTARG ");
2733         if (s & SCSIRSTI)
2734                 printk("SCSIRSTI ");
2735         if (s & PHASEMIS)
2736                 printk("PHASEMIS ");
2737         if (s & BUSFREE)
2738                 printk("BUSFREE ");
2739         if (s & SCSIPERR)
2740                 printk("SCSIPERR ");
2741         if (s & PHASECHG)
2742                 printk("PHASECHG ");
2743         if (s & REQINIT)
2744                 printk("REQINIT ");
2745         printk("); ");
2746
2747
2748         printk("SSTAT( ");
2749
2750         s = GETPORT(SSTAT0) & GETPORT(SIMODE0);
2751
2752         if (s & TARGET)
2753                 printk("TARGET ");
2754         if (s & SELDO)
2755                 printk("SELDO ");
2756         if (s & SELDI)
2757                 printk("SELDI ");
2758         if (s & SELINGO)
2759                 printk("SELINGO ");
2760         if (s & SWRAP)
2761                 printk("SWRAP ");
2762         if (s & SDONE)
2763                 printk("SDONE ");
2764         if (s & SPIORDY)
2765                 printk("SPIORDY ");
2766         if (s & DMADONE)
2767                 printk("DMADONE ");
2768
2769         s = GETPORT(SSTAT1) & GETPORT(SIMODE1);
2770
2771         if (s & SELTO)
2772                 printk("SELTO ");
2773         if (s & ATNTARG)
2774                 printk("ATNTARG ");
2775         if (s & SCSIRSTI)
2776                 printk("SCSIRSTI ");
2777         if (s & PHASEMIS)
2778                 printk("PHASEMIS ");
2779         if (s & BUSFREE)
2780                 printk("BUSFREE ");
2781         if (s & SCSIPERR)
2782                 printk("SCSIPERR ");
2783         if (s & PHASECHG)
2784                 printk("PHASECHG ");
2785         if (s & REQINIT)
2786                 printk("REQINIT ");
2787         printk("); ");
2788
2789         printk("SXFRCTL0( ");
2790
2791         s = GETPORT(SXFRCTL0);
2792         if (s & SCSIEN)
2793                 printk("SCSIEN ");
2794         if (s & DMAEN)
2795                 printk("DMAEN ");
2796         if (s & CH1)
2797                 printk("CH1 ");
2798         if (s & CLRSTCNT)
2799                 printk("CLRSTCNT ");
2800         if (s & SPIOEN)
2801                 printk("SPIOEN ");
2802         if (s & CLRCH1)
2803                 printk("CLRCH1 ");
2804         printk("); ");
2805
2806         printk("SIGNAL( ");
2807
2808         s = GETPORT(SCSISIG);
2809         if (s & SIG_ATNI)
2810                 printk("ATNI ");
2811         if (s & SIG_SELI)
2812                 printk("SELI ");
2813         if (s & SIG_BSYI)
2814                 printk("BSYI ");
2815         if (s & SIG_REQI)
2816                 printk("REQI ");
2817         if (s & SIG_ACKI)
2818                 printk("ACKI ");
2819         printk("); ");
2820
2821         printk("SELID (%02x), ", GETPORT(SELID));
2822
2823         printk("STCNT (%d), ", GETSTCNT());
2824         
2825         printk("SSTAT2( ");
2826
2827         s = GETPORT(SSTAT2);
2828         if (s & SOFFSET)
2829                 printk("SOFFSET ");
2830         if (s & SEMPTY)
2831                 printk("SEMPTY ");
2832         if (s & SFULL)
2833                 printk("SFULL ");
2834         printk("); SFCNT (%d); ", s & (SFULL | SFCNT));
2835
2836         s = GETPORT(SSTAT3);
2837         printk("SCSICNT (%d), OFFCNT(%d), ", (s & 0xf0) >> 4, s & 0x0f);
2838
2839         printk("SSTAT4( ");
2840         s = GETPORT(SSTAT4);
2841         if (s & SYNCERR)
2842                 printk("SYNCERR ");
2843         if (s & FWERR)
2844                 printk("FWERR ");
2845         if (s & FRERR)
2846                 printk("FRERR ");
2847         printk("); ");
2848
2849         printk("DMACNTRL0( ");
2850         s = GETPORT(DMACNTRL0);
2851         printk("%s ", s & _8BIT ? "8BIT" : "16BIT");
2852         printk("%s ", s & DMA ? "DMA" : "PIO");
2853         printk("%s ", s & WRITE_READ ? "WRITE" : "READ");
2854         if (s & ENDMA)
2855                 printk("ENDMA ");
2856         if (s & INTEN)
2857                 printk("INTEN ");
2858         if (s & RSTFIFO)
2859                 printk("RSTFIFO ");
2860         if (s & SWINT)
2861                 printk("SWINT ");
2862         printk("); ");
2863
2864         printk("DMASTAT( ");
2865         s = GETPORT(DMASTAT);
2866         if (s & ATDONE)
2867                 printk("ATDONE ");
2868         if (s & WORDRDY)
2869                 printk("WORDRDY ");
2870         if (s & DFIFOFULL)
2871                 printk("DFIFOFULL ");
2872         if (s & DFIFOEMP)
2873                 printk("DFIFOEMP ");
2874         printk(")\n");
2875 #endif
2876 }
2877
2878 /*
2879  * display enabled interrupts
2880  */
2881 static void disp_enintr(struct Scsi_Host *shpnt)
2882 {
2883         int s;
2884
2885         printk(KERN_DEBUG "enabled interrupts ( ");
2886
2887         s = GETPORT(SIMODE0);
2888         if (s & ENSELDO)
2889                 printk("ENSELDO ");
2890         if (s & ENSELDI)
2891                 printk("ENSELDI ");
2892         if (s & ENSELINGO)
2893                 printk("ENSELINGO ");
2894         if (s & ENSWRAP)
2895                 printk("ENSWRAP ");
2896         if (s & ENSDONE)
2897                 printk("ENSDONE ");
2898         if (s & ENSPIORDY)
2899                 printk("ENSPIORDY ");
2900         if (s & ENDMADONE)
2901                 printk("ENDMADONE ");
2902
2903         s = GETPORT(SIMODE1);
2904         if (s & ENSELTIMO)
2905                 printk("ENSELTIMO ");
2906         if (s & ENATNTARG)
2907                 printk("ENATNTARG ");
2908         if (s & ENPHASEMIS)
2909                 printk("ENPHASEMIS ");
2910         if (s & ENBUSFREE)
2911                 printk("ENBUSFREE ");
2912         if (s & ENSCSIPERR)
2913                 printk("ENSCSIPERR ");
2914         if (s & ENPHASECHG)
2915                 printk("ENPHASECHG ");
2916         if (s & ENREQINIT)
2917                 printk("ENREQINIT ");
2918         printk(")\n");
2919 }
2920
2921 /*
2922  * Show the command data of a command
2923  */
2924 static void show_command(Scsi_Cmnd *ptr)
2925 {
2926         printk(KERN_DEBUG "0x%08x: target=%d; lun=%d; cmnd=(",
2927                (unsigned int) ptr, ptr->device->id, ptr->device->lun);
2928
2929         __scsi_print_command(ptr->cmnd);
2930
2931         printk(KERN_DEBUG "); request_bufflen=%d; resid=%d; phase |",
2932                ptr->request_bufflen, ptr->resid);
2933
2934         if (ptr->SCp.phase & not_issued)
2935                 printk("not issued|");
2936         if (ptr->SCp.phase & selecting)
2937                 printk("selecting|");
2938         if (ptr->SCp.phase & identified)
2939                 printk("identified|");
2940         if (ptr->SCp.phase & disconnected)
2941                 printk("disconnected|");
2942         if (ptr->SCp.phase & completed)
2943                 printk("completed|");
2944         if (ptr->SCp.phase & spiordy)
2945                 printk("spiordy|");
2946         if (ptr->SCp.phase & syncneg)
2947                 printk("syncneg|");
2948         if (ptr->SCp.phase & aborted)
2949                 printk("aborted|");
2950         if (ptr->SCp.phase & resetted)
2951                 printk("resetted|");
2952         if( SCDATA(ptr) ) {
2953                 printk("; next=0x%p\n", SCNEXT(ptr));
2954         } else {
2955                 printk("; next=(host scribble NULL)\n");
2956         }
2957 }
2958
2959 /*
2960  * Dump the queued data
2961  */
2962 static void show_queues(struct Scsi_Host *shpnt)
2963 {
2964         Scsi_Cmnd *ptr;
2965         unsigned long flags;
2966
2967         DO_LOCK(flags);
2968         printk(KERN_DEBUG "\nqueue status:\nissue_SC:\n");
2969         for (ptr = ISSUE_SC; ptr; ptr = SCNEXT(ptr))
2970                 show_command(ptr);
2971         DO_UNLOCK(flags);
2972
2973         printk(KERN_DEBUG "current_SC:\n");
2974         if (CURRENT_SC)
2975                 show_command(CURRENT_SC);
2976         else
2977                 printk(KERN_DEBUG "none\n");
2978
2979         printk(KERN_DEBUG "disconnected_SC:\n");
2980         for (ptr = DISCONNECTED_SC; ptr; ptr = SCDATA(ptr) ? SCNEXT(ptr) : NULL)
2981                 show_command(ptr);
2982
2983         disp_ports(shpnt);
2984         disp_enintr(shpnt);
2985 }
2986
2987 #undef SPRINTF
2988 #define SPRINTF(args...) pos += sprintf(pos, ## args)
2989
2990 static int get_command(char *pos, Scsi_Cmnd * ptr)
2991 {
2992         char *start = pos;
2993         int i;
2994
2995         SPRINTF("0x%08x: target=%d; lun=%d; cmnd=( ",
2996                 (unsigned int) ptr, ptr->device->id, ptr->device->lun);
2997
2998         for (i = 0; i < COMMAND_SIZE(ptr->cmnd[0]); i++)
2999                 SPRINTF("0x%02x ", ptr->cmnd[i]);
3000
3001         SPRINTF("); resid=%d; residual=%d; buffers=%d; phase |",
3002                 ptr->resid, ptr->SCp.this_residual, ptr->SCp.buffers_residual);
3003
3004         if (ptr->SCp.phase & not_issued)
3005                 SPRINTF("not issued|");
3006         if (ptr->SCp.phase & selecting)
3007                 SPRINTF("selecting|");
3008         if (ptr->SCp.phase & disconnected)
3009                 SPRINTF("disconnected|");
3010         if (ptr->SCp.phase & aborted)
3011                 SPRINTF("aborted|");
3012         if (ptr->SCp.phase & identified)
3013                 SPRINTF("identified|");
3014         if (ptr->SCp.phase & completed)
3015                 SPRINTF("completed|");
3016         if (ptr->SCp.phase & spiordy)
3017                 SPRINTF("spiordy|");
3018         if (ptr->SCp.phase & syncneg)
3019                 SPRINTF("syncneg|");
3020         SPRINTF("; next=0x%p\n", SCNEXT(ptr));
3021
3022         return (pos - start);
3023 }
3024
3025 static int get_ports(struct Scsi_Host *shpnt, char *pos)
3026 {
3027         char *start = pos;
3028         int s;
3029
3030         SPRINTF("\n%s: %s(%s) ", CURRENT_SC ? "on bus" : "waiting", states[STATE].name, states[PREVSTATE].name);
3031
3032         s = GETPORT(SCSISEQ);
3033         SPRINTF("SCSISEQ( ");
3034         if (s & TEMODEO)
3035                 SPRINTF("TARGET MODE ");
3036         if (s & ENSELO)
3037                 SPRINTF("SELO ");
3038         if (s & ENSELI)
3039                 SPRINTF("SELI ");
3040         if (s & ENRESELI)
3041                 SPRINTF("RESELI ");
3042         if (s & ENAUTOATNO)
3043                 SPRINTF("AUTOATNO ");
3044         if (s & ENAUTOATNI)
3045                 SPRINTF("AUTOATNI ");
3046         if (s & ENAUTOATNP)
3047                 SPRINTF("AUTOATNP ");
3048         if (s & SCSIRSTO)
3049                 SPRINTF("SCSIRSTO ");
3050         SPRINTF(");");
3051
3052         SPRINTF(" SCSISIG(");
3053         s = GETPORT(SCSISIG);
3054         switch (s & P_MASK) {
3055         case P_DATAO:
3056                 SPRINTF("DATA OUT");
3057                 break;
3058         case P_DATAI:
3059                 SPRINTF("DATA IN");
3060                 break;
3061         case P_CMD:
3062                 SPRINTF("COMMAND");
3063                 break;
3064         case P_STATUS:
3065                 SPRINTF("STATUS");
3066                 break;
3067         case P_MSGO:
3068                 SPRINTF("MESSAGE OUT");
3069                 break;
3070         case P_MSGI:
3071                 SPRINTF("MESSAGE IN");
3072                 break;
3073         default:
3074                 SPRINTF("*invalid*");
3075                 break;
3076         }
3077
3078         SPRINTF("); ");
3079
3080         SPRINTF("INTSTAT (%s); ", TESTHI(DMASTAT, INTSTAT) ? "hi" : "lo");
3081
3082         SPRINTF("SSTAT( ");
3083         s = GETPORT(SSTAT0);
3084         if (s & TARGET)
3085                 SPRINTF("TARGET ");
3086         if (s & SELDO)
3087                 SPRINTF("SELDO ");
3088         if (s & SELDI)
3089                 SPRINTF("SELDI ");
3090         if (s & SELINGO)
3091                 SPRINTF("SELINGO ");
3092         if (s & SWRAP)
3093                 SPRINTF("SWRAP ");
3094         if (s & SDONE)
3095                 SPRINTF("SDONE ");
3096         if (s & SPIORDY)
3097                 SPRINTF("SPIORDY ");
3098         if (s & DMADONE)
3099                 SPRINTF("DMADONE ");
3100
3101         s = GETPORT(SSTAT1);
3102         if (s & SELTO)
3103                 SPRINTF("SELTO ");
3104         if (s & ATNTARG)
3105                 SPRINTF("ATNTARG ");
3106         if (s & SCSIRSTI)
3107                 SPRINTF("SCSIRSTI ");
3108         if (s & PHASEMIS)
3109                 SPRINTF("PHASEMIS ");
3110         if (s & BUSFREE)
3111                 SPRINTF("BUSFREE ");
3112         if (s & SCSIPERR)
3113                 SPRINTF("SCSIPERR ");
3114         if (s & PHASECHG)
3115                 SPRINTF("PHASECHG ");
3116         if (s & REQINIT)
3117                 SPRINTF("REQINIT ");
3118         SPRINTF("); ");
3119
3120
3121         SPRINTF("SSTAT( ");
3122
3123         s = GETPORT(SSTAT0) & GETPORT(SIMODE0);
3124
3125         if (s & TARGET)
3126                 SPRINTF("TARGET ");
3127         if (s & SELDO)
3128                 SPRINTF("SELDO ");
3129         if (s & SELDI)
3130                 SPRINTF("SELDI ");
3131         if (s & SELINGO)
3132                 SPRINTF("SELINGO ");
3133         if (s & SWRAP)
3134                 SPRINTF("SWRAP ");
3135         if (s & SDONE)
3136                 SPRINTF("SDONE ");
3137         if (s & SPIORDY)
3138                 SPRINTF("SPIORDY ");
3139         if (s & DMADONE)
3140                 SPRINTF("DMADONE ");
3141
3142         s = GETPORT(SSTAT1) & GETPORT(SIMODE1);
3143
3144         if (s & SELTO)
3145                 SPRINTF("SELTO ");
3146         if (s & ATNTARG)
3147                 SPRINTF("ATNTARG ");
3148         if (s & SCSIRSTI)
3149                 SPRINTF("SCSIRSTI ");
3150         if (s & PHASEMIS)
3151                 SPRINTF("PHASEMIS ");
3152         if (s & BUSFREE)
3153                 SPRINTF("BUSFREE ");
3154         if (s & SCSIPERR)
3155                 SPRINTF("SCSIPERR ");
3156         if (s & PHASECHG)
3157                 SPRINTF("PHASECHG ");
3158         if (s & REQINIT)
3159                 SPRINTF("REQINIT ");
3160         SPRINTF("); ");
3161
3162         SPRINTF("SXFRCTL0( ");
3163
3164         s = GETPORT(SXFRCTL0);
3165         if (s & SCSIEN)
3166                 SPRINTF("SCSIEN ");
3167         if (s & DMAEN)
3168                 SPRINTF("DMAEN ");
3169         if (s & CH1)
3170                 SPRINTF("CH1 ");
3171         if (s & CLRSTCNT)
3172                 SPRINTF("CLRSTCNT ");
3173         if (s & SPIOEN)
3174                 SPRINTF("SPIOEN ");
3175         if (s & CLRCH1)
3176                 SPRINTF("CLRCH1 ");
3177         SPRINTF("); ");
3178
3179         SPRINTF("SIGNAL( ");
3180
3181         s = GETPORT(SCSISIG);
3182         if (s & SIG_ATNI)
3183                 SPRINTF("ATNI ");
3184         if (s & SIG_SELI)
3185                 SPRINTF("SELI ");
3186         if (s & SIG_BSYI)
3187                 SPRINTF("BSYI ");
3188         if (s & SIG_REQI)
3189                 SPRINTF("REQI ");
3190         if (s & SIG_ACKI)
3191                 SPRINTF("ACKI ");
3192         SPRINTF("); ");
3193
3194         SPRINTF("SELID(%02x), ", GETPORT(SELID));
3195
3196         SPRINTF("STCNT(%d), ", GETSTCNT());
3197
3198         SPRINTF("SSTAT2( ");
3199
3200         s = GETPORT(SSTAT2);
3201         if (s & SOFFSET)
3202                 SPRINTF("SOFFSET ");
3203         if (s & SEMPTY)
3204                 SPRINTF("SEMPTY ");
3205         if (s & SFULL)
3206                 SPRINTF("SFULL ");
3207         SPRINTF("); SFCNT (%d); ", s & (SFULL | SFCNT));
3208
3209         s = GETPORT(SSTAT3);
3210         SPRINTF("SCSICNT (%d), OFFCNT(%d), ", (s & 0xf0) >> 4, s & 0x0f);
3211
3212         SPRINTF("SSTAT4( ");
3213         s = GETPORT(SSTAT4);
3214         if (s & SYNCERR)
3215                 SPRINTF("SYNCERR ");
3216         if (s & FWERR)
3217                 SPRINTF("FWERR ");
3218         if (s & FRERR)
3219                 SPRINTF("FRERR ");
3220         SPRINTF("); ");
3221
3222         SPRINTF("DMACNTRL0( ");
3223         s = GETPORT(DMACNTRL0);
3224         SPRINTF("%s ", s & _8BIT ? "8BIT" : "16BIT");
3225         SPRINTF("%s ", s & DMA ? "DMA" : "PIO");
3226         SPRINTF("%s ", s & WRITE_READ ? "WRITE" : "READ");
3227         if (s & ENDMA)
3228                 SPRINTF("ENDMA ");
3229         if (s & INTEN)
3230                 SPRINTF("INTEN ");
3231         if (s & RSTFIFO)
3232                 SPRINTF("RSTFIFO ");
3233         if (s & SWINT)
3234                 SPRINTF("SWINT ");
3235         SPRINTF("); ");
3236
3237         SPRINTF("DMASTAT( ");
3238         s = GETPORT(DMASTAT);
3239         if (s & ATDONE)
3240                 SPRINTF("ATDONE ");
3241         if (s & WORDRDY)
3242                 SPRINTF("WORDRDY ");
3243         if (s & DFIFOFULL)
3244                 SPRINTF("DFIFOFULL ");
3245         if (s & DFIFOEMP)
3246                 SPRINTF("DFIFOEMP ");
3247         SPRINTF(")\n");
3248
3249         SPRINTF("enabled interrupts( ");
3250
3251         s = GETPORT(SIMODE0);
3252         if (s & ENSELDO)
3253                 SPRINTF("ENSELDO ");
3254         if (s & ENSELDI)
3255                 SPRINTF("ENSELDI ");
3256         if (s & ENSELINGO)
3257                 SPRINTF("ENSELINGO ");
3258         if (s & ENSWRAP)
3259                 SPRINTF("ENSWRAP ");
3260         if (s & ENSDONE)
3261                 SPRINTF("ENSDONE ");
3262         if (s & ENSPIORDY)
3263                 SPRINTF("ENSPIORDY ");
3264         if (s & ENDMADONE)
3265                 SPRINTF("ENDMADONE ");
3266
3267         s = GETPORT(SIMODE1);
3268         if (s & ENSELTIMO)
3269                 SPRINTF("ENSELTIMO ");
3270         if (s & ENATNTARG)
3271                 SPRINTF("ENATNTARG ");
3272         if (s & ENPHASEMIS)
3273                 SPRINTF("ENPHASEMIS ");
3274         if (s & ENBUSFREE)
3275                 SPRINTF("ENBUSFREE ");
3276         if (s & ENSCSIPERR)
3277                 SPRINTF("ENSCSIPERR ");
3278         if (s & ENPHASECHG)
3279                 SPRINTF("ENPHASECHG ");
3280         if (s & ENREQINIT)
3281                 SPRINTF("ENREQINIT ");
3282         SPRINTF(")\n");
3283
3284         return (pos - start);
3285 }
3286
3287 static int aha152x_set_info(char *buffer, int length, struct Scsi_Host *shpnt)
3288 {
3289         if(!shpnt || !buffer || length<8 || strncmp("aha152x ", buffer, 8)!=0)
3290                 return -EINVAL;
3291
3292 #if defined(AHA152X_DEBUG)
3293         if(length>14 && strncmp("debug ", buffer+8, 6)==0) {
3294                 int debug = HOSTDATA(shpnt)->debug;
3295
3296                 HOSTDATA(shpnt)->debug = simple_strtoul(buffer+14, NULL, 0);
3297
3298                 printk(KERN_INFO "aha152x%d: debugging options set to 0x%04x (were 0x%04x)\n", HOSTNO, HOSTDATA(shpnt)->debug, debug);
3299         } else
3300 #endif
3301 #if defined(AHA152X_STAT)
3302         if(length>13 && strncmp("reset", buffer+8, 5)==0) {
3303                 int i;
3304
3305                 HOSTDATA(shpnt)->total_commands=0;
3306                 HOSTDATA(shpnt)->disconnections=0;
3307                 HOSTDATA(shpnt)->busfree_without_any_action=0;
3308                 HOSTDATA(shpnt)->busfree_without_old_command=0;
3309                 HOSTDATA(shpnt)->busfree_without_new_command=0;
3310                 HOSTDATA(shpnt)->busfree_without_done_command=0;
3311                 HOSTDATA(shpnt)->busfree_with_check_condition=0;
3312                 for (i = idle; i<maxstate; i++) {
3313                         HOSTDATA(shpnt)->count[i]=0;
3314                         HOSTDATA(shpnt)->count_trans[i]=0;
3315                         HOSTDATA(shpnt)->time[i]=0;
3316                 }
3317
3318                 printk(KERN_INFO "aha152x%d: stats reseted.\n", HOSTNO);
3319
3320         } else
3321 #endif
3322         {
3323                 return -EINVAL;
3324         }
3325
3326
3327         return length;
3328 }
3329
3330 #undef SPRINTF
3331 #define SPRINTF(args...) \
3332         do { if(pos < buffer + length) pos += sprintf(pos, ## args); } while(0)
3333
3334 static int aha152x_proc_info(struct Scsi_Host *shpnt, char *buffer, char **start,
3335                       off_t offset, int length, int inout)
3336 {
3337         int i;
3338         char *pos = buffer;
3339         Scsi_Cmnd *ptr;
3340         unsigned long flags;
3341         int thislength;
3342
3343         DPRINTK(debug_procinfo, 
3344                KERN_DEBUG "aha152x_proc_info: buffer=%p offset=%ld length=%d hostno=%d inout=%d\n",
3345                buffer, offset, length, shpnt->host_no, inout);
3346
3347
3348         if (inout)
3349                 return aha152x_set_info(buffer, length, shpnt);
3350
3351         SPRINTF(AHA152X_REVID "\n");
3352
3353         SPRINTF("ioports 0x%04lx to 0x%04lx\n",
3354                 shpnt->io_port, shpnt->io_port + shpnt->n_io_port - 1);
3355         SPRINTF("interrupt 0x%02x\n", shpnt->irq);
3356         SPRINTF("disconnection/reconnection %s\n",
3357                 RECONNECT ? "enabled" : "disabled");
3358         SPRINTF("parity checking %s\n",
3359         &