xref: /openbmc/linux/drivers/scsi/aha152x.c (revision 4800cd83)
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 <asm/irq.h>
240 #include <linux/io.h>
241 #include <linux/blkdev.h>
242 #include <asm/system.h>
243 #include <linux/completion.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 <linux/list.h>
257 #include <linux/slab.h>
258 #include <scsi/scsicam.h>
259 
260 #include "scsi.h"
261 #include <scsi/scsi_dbg.h>
262 #include <scsi/scsi_host.h>
263 #include <scsi/scsi_transport_spi.h>
264 #include <scsi/scsi_eh.h>
265 #include "aha152x.h"
266 
267 static LIST_HEAD(aha152x_host_list);
268 
269 
270 /* DEFINES */
271 
272 /* For PCMCIA cards, always use AUTOCONF */
273 #if defined(PCMCIA) || defined(MODULE)
274 #if !defined(AUTOCONF)
275 #define AUTOCONF
276 #endif
277 #endif
278 
279 #if !defined(AUTOCONF) && !defined(SETUP0)
280 #error define AUTOCONF or SETUP0
281 #endif
282 
283 #if defined(AHA152X_DEBUG)
284 #define DEBUG_DEFAULT debug_eh
285 
286 #define DPRINTK(when,msgs...) \
287 	do { if(HOSTDATA(shpnt)->debug & (when)) printk(msgs); } while(0)
288 
289 #define DO_LOCK(flags)	\
290 	do { \
291 		if(spin_is_locked(&QLOCK)) { \
292 			DPRINTK(debug_intr, DEBUG_LEAD "(%s:%d) already locked at %s:%d\n", CMDINFO(CURRENT_SC), __func__, __LINE__, QLOCKER, QLOCKERL); \
293 		} \
294 		DPRINTK(debug_locking, DEBUG_LEAD "(%s:%d) locking\n", CMDINFO(CURRENT_SC), __func__, __LINE__); \
295 		spin_lock_irqsave(&QLOCK,flags); \
296 		DPRINTK(debug_locking, DEBUG_LEAD "(%s:%d) locked\n", CMDINFO(CURRENT_SC), __func__, __LINE__); \
297 		QLOCKER=__func__; \
298 		QLOCKERL=__LINE__; \
299 	} while(0)
300 
301 #define DO_UNLOCK(flags)	\
302 	do { \
303 		DPRINTK(debug_locking, DEBUG_LEAD "(%s:%d) unlocking (locked at %s:%d)\n", CMDINFO(CURRENT_SC), __func__, __LINE__, QLOCKER, QLOCKERL); \
304 		spin_unlock_irqrestore(&QLOCK,flags); \
305 		DPRINTK(debug_locking, DEBUG_LEAD "(%s:%d) unlocked\n", CMDINFO(CURRENT_SC), __func__, __LINE__); \
306 		QLOCKER="(not locked)"; \
307 		QLOCKERL=0; \
308 	} while(0)
309 
310 #else
311 #define DPRINTK(when,msgs...)
312 #define	DO_LOCK(flags)		spin_lock_irqsave(&QLOCK,flags)
313 #define	DO_UNLOCK(flags)	spin_unlock_irqrestore(&QLOCK,flags)
314 #endif
315 
316 #define LEAD		"(scsi%d:%d:%d) "
317 #define WARN_LEAD	KERN_WARNING	LEAD
318 #define INFO_LEAD	KERN_INFO	LEAD
319 #define NOTE_LEAD	KERN_NOTICE	LEAD
320 #define ERR_LEAD	KERN_ERR	LEAD
321 #define DEBUG_LEAD	KERN_DEBUG	LEAD
322 #define CMDINFO(cmd) \
323 			(cmd) ? ((cmd)->device->host->host_no) : -1, \
324                         (cmd) ? ((cmd)->device->id & 0x0f) : -1, \
325 			(cmd) ? ((cmd)->device->lun & 0x07) : -1
326 
327 static inline void
328 CMD_INC_RESID(struct scsi_cmnd *cmd, int inc)
329 {
330 	scsi_set_resid(cmd, scsi_get_resid(cmd) + inc);
331 }
332 
333 #define DELAY_DEFAULT 1000
334 
335 #if defined(PCMCIA)
336 #define IRQ_MIN 0
337 #define IRQ_MAX 16
338 #else
339 #define IRQ_MIN 9
340 #if defined(__PPC)
341 #define IRQ_MAX (nr_irqs-1)
342 #else
343 #define IRQ_MAX 12
344 #endif
345 #endif
346 
347 enum {
348 	not_issued	= 0x0001,	/* command not yet issued */
349 	selecting	= 0x0002, 	/* target is beeing selected */
350 	identified	= 0x0004,	/* IDENTIFY was sent */
351 	disconnected	= 0x0008,	/* target disconnected */
352 	completed	= 0x0010,	/* target sent COMMAND COMPLETE */
353 	aborted		= 0x0020,	/* ABORT was sent */
354 	resetted	= 0x0040,	/* BUS DEVICE RESET was sent */
355 	spiordy		= 0x0080,	/* waiting for SPIORDY to raise */
356 	syncneg		= 0x0100,	/* synchronous negotiation in progress */
357 	aborting	= 0x0200,	/* ABORT is pending */
358 	resetting	= 0x0400,	/* BUS DEVICE RESET is pending */
359 	check_condition = 0x0800,	/* requesting sense after CHECK CONDITION */
360 };
361 
362 MODULE_AUTHOR("Jürgen Fischer");
363 MODULE_DESCRIPTION(AHA152X_REVID);
364 MODULE_LICENSE("GPL");
365 
366 #if !defined(PCMCIA)
367 #if defined(MODULE)
368 static int io[] = {0, 0};
369 module_param_array(io, int, NULL, 0);
370 MODULE_PARM_DESC(io,"base io address of controller");
371 
372 static int irq[] = {0, 0};
373 module_param_array(irq, int, NULL, 0);
374 MODULE_PARM_DESC(irq,"interrupt for controller");
375 
376 static int scsiid[] = {7, 7};
377 module_param_array(scsiid, int, NULL, 0);
378 MODULE_PARM_DESC(scsiid,"scsi id of controller");
379 
380 static int reconnect[] = {1, 1};
381 module_param_array(reconnect, int, NULL, 0);
382 MODULE_PARM_DESC(reconnect,"allow targets to disconnect");
383 
384 static int parity[] = {1, 1};
385 module_param_array(parity, int, NULL, 0);
386 MODULE_PARM_DESC(parity,"use scsi parity");
387 
388 static int sync[] = {1, 1};
389 module_param_array(sync, int, NULL, 0);
390 MODULE_PARM_DESC(sync,"use synchronous transfers");
391 
392 static int delay[] = {DELAY_DEFAULT, DELAY_DEFAULT};
393 module_param_array(delay, int, NULL, 0);
394 MODULE_PARM_DESC(delay,"scsi reset delay");
395 
396 static int exttrans[] = {0, 0};
397 module_param_array(exttrans, int, NULL, 0);
398 MODULE_PARM_DESC(exttrans,"use extended translation");
399 
400 #if !defined(AHA152X_DEBUG)
401 static int aha152x[] = {0, 11, 7, 1, 1, 0, DELAY_DEFAULT, 0};
402 module_param_array(aha152x, int, NULL, 0);
403 MODULE_PARM_DESC(aha152x, "parameters for first controller");
404 
405 static int aha152x1[] = {0, 11, 7, 1, 1, 0, DELAY_DEFAULT, 0};
406 module_param_array(aha152x1, int, NULL, 0);
407 MODULE_PARM_DESC(aha152x1, "parameters for second controller");
408 #else
409 static int debug[] = {DEBUG_DEFAULT, DEBUG_DEFAULT};
410 module_param_array(debug, int, NULL, 0);
411 MODULE_PARM_DESC(debug, "flags for driver debugging");
412 
413 static int aha152x[]   = {0, 11, 7, 1, 1, 1, DELAY_DEFAULT, 0, DEBUG_DEFAULT};
414 module_param_array(aha152x, int, NULL, 0);
415 MODULE_PARM_DESC(aha152x, "parameters for first controller");
416 
417 static int aha152x1[]  = {0, 11, 7, 1, 1, 1, DELAY_DEFAULT, 0, DEBUG_DEFAULT};
418 module_param_array(aha152x1, int, NULL, 0);
419 MODULE_PARM_DESC(aha152x1, "parameters for second controller");
420 #endif /* !defined(AHA152X_DEBUG) */
421 #endif /* MODULE */
422 
423 #ifdef __ISAPNP__
424 static struct isapnp_device_id id_table[] __devinitdata = {
425 	{ ISAPNP_ANY_ID, ISAPNP_ANY_ID,
426 		ISAPNP_VENDOR('A','D','P'), ISAPNP_FUNCTION(0x1505), 0 },
427 	{ ISAPNP_ANY_ID, ISAPNP_ANY_ID,
428 		ISAPNP_VENDOR('A','D','P'), ISAPNP_FUNCTION(0x1530), 0 },
429 	{ ISAPNP_DEVICE_SINGLE_END, }
430 };
431 MODULE_DEVICE_TABLE(isapnp, id_table);
432 #endif /* ISAPNP */
433 
434 #endif /* !PCMCIA */
435 
436 static struct scsi_host_template aha152x_driver_template;
437 
438 /*
439  * internal states of the host
440  *
441  */
442 enum aha152x_state {
443 	idle=0,
444 	unknown,
445 	seldo,
446 	seldi,
447 	selto,
448 	busfree,
449 	msgo,
450 	cmd,
451 	msgi,
452 	status,
453 	datai,
454 	datao,
455 	parerr,
456 	rsti,
457 	maxstate
458 };
459 
460 /*
461  * current state information of the host
462  *
463  */
464 struct aha152x_hostdata {
465 	Scsi_Cmnd *issue_SC;
466 		/* pending commands to issue */
467 
468 	Scsi_Cmnd *current_SC;
469 		/* current command on the bus */
470 
471 	Scsi_Cmnd *disconnected_SC;
472 		/* commands that disconnected */
473 
474 	Scsi_Cmnd *done_SC;
475 		/* command that was completed */
476 
477 	spinlock_t lock;
478 		/* host lock */
479 
480 #if defined(AHA152X_DEBUG)
481 	const char *locker;
482 		/* which function has the lock */
483 	int lockerl;	/* where did it get it */
484 
485 	int debug;	/* current debugging setting */
486 #endif
487 
488 #if defined(AHA152X_STAT)
489 	int           total_commands;
490 	int	      disconnections;
491 	int	      busfree_without_any_action;
492 	int	      busfree_without_old_command;
493 	int	      busfree_without_new_command;
494 	int	      busfree_without_done_command;
495 	int	      busfree_with_check_condition;
496 	int           count[maxstate];
497 	int           count_trans[maxstate];
498 	unsigned long time[maxstate];
499 #endif
500 
501 	int commands;		/* current number of commands */
502 
503 	int reconnect;		/* disconnection allowed */
504 	int parity;		/* parity checking enabled */
505 	int synchronous;	/* synchronous transferes enabled */
506 	int delay;		/* reset out delay */
507 	int ext_trans;		/* extended translation enabled */
508 
509 	int swint; 		/* software-interrupt was fired during detect() */
510 	int service;		/* bh needs to be run */
511 	int in_intr;		/* bh is running */
512 
513 	/* current state,
514 	   previous state,
515 	   last state different from current state */
516 	enum aha152x_state state, prevstate, laststate;
517 
518 	int target;
519 		/* reconnecting target */
520 
521 	unsigned char syncrate[8];
522 		/* current synchronous transfer agreements */
523 
524 	unsigned char syncneg[8];
525 		/* 0: no negotiation;
526 		 * 1: negotiation in progress;
527 		 * 2: negotiation completed
528 		 */
529 
530 	int cmd_i;
531 		/* number of sent bytes of current command */
532 
533 	int msgi_len;
534 		/* number of received message bytes */
535 	unsigned char msgi[256];
536 		/* received message bytes */
537 
538 	int msgo_i, msgo_len;
539 		/* number of sent bytes and length of current messages */
540 	unsigned char msgo[256];
541 		/* pending messages */
542 
543 	int data_len;
544 		/* number of sent/received bytes in dataphase */
545 
546 	unsigned long io_port0;
547 	unsigned long io_port1;
548 
549 #ifdef __ISAPNP__
550 	struct pnp_dev *pnpdev;
551 #endif
552 	struct list_head host_list;
553 };
554 
555 
556 /*
557  * host specific command extension
558  *
559  */
560 struct aha152x_scdata {
561 	Scsi_Cmnd *next;	/* next sc in queue */
562 	struct completion *done;/* semaphore to block on */
563 	struct scsi_eh_save ses;
564 };
565 
566 /* access macros for hostdata */
567 
568 #define HOSTDATA(shpnt)		((struct aha152x_hostdata *) &shpnt->hostdata)
569 
570 #define HOSTNO			((shpnt)->host_no)
571 
572 #define CURRENT_SC		(HOSTDATA(shpnt)->current_SC)
573 #define DONE_SC			(HOSTDATA(shpnt)->done_SC)
574 #define ISSUE_SC		(HOSTDATA(shpnt)->issue_SC)
575 #define DISCONNECTED_SC		(HOSTDATA(shpnt)->disconnected_SC)
576 #define QLOCK			(HOSTDATA(shpnt)->lock)
577 #define QLOCKER			(HOSTDATA(shpnt)->locker)
578 #define QLOCKERL		(HOSTDATA(shpnt)->lockerl)
579 
580 #define STATE			(HOSTDATA(shpnt)->state)
581 #define PREVSTATE		(HOSTDATA(shpnt)->prevstate)
582 #define LASTSTATE		(HOSTDATA(shpnt)->laststate)
583 
584 #define RECONN_TARGET		(HOSTDATA(shpnt)->target)
585 
586 #define CMD_I			(HOSTDATA(shpnt)->cmd_i)
587 
588 #define MSGO(i)			(HOSTDATA(shpnt)->msgo[i])
589 #define MSGO_I			(HOSTDATA(shpnt)->msgo_i)
590 #define MSGOLEN			(HOSTDATA(shpnt)->msgo_len)
591 #define ADDMSGO(x)		(MSGOLEN<256 ? (void)(MSGO(MSGOLEN++)=x) : aha152x_error(shpnt,"MSGO overflow"))
592 
593 #define MSGI(i)			(HOSTDATA(shpnt)->msgi[i])
594 #define MSGILEN			(HOSTDATA(shpnt)->msgi_len)
595 #define ADDMSGI(x)		(MSGILEN<256 ? (void)(MSGI(MSGILEN++)=x) : aha152x_error(shpnt,"MSGI overflow"))
596 
597 #define DATA_LEN		(HOSTDATA(shpnt)->data_len)
598 
599 #define SYNCRATE		(HOSTDATA(shpnt)->syncrate[CURRENT_SC->device->id])
600 #define SYNCNEG			(HOSTDATA(shpnt)->syncneg[CURRENT_SC->device->id])
601 
602 #define DELAY			(HOSTDATA(shpnt)->delay)
603 #define EXT_TRANS		(HOSTDATA(shpnt)->ext_trans)
604 #define TC1550			(HOSTDATA(shpnt)->tc1550)
605 #define RECONNECT		(HOSTDATA(shpnt)->reconnect)
606 #define PARITY			(HOSTDATA(shpnt)->parity)
607 #define SYNCHRONOUS		(HOSTDATA(shpnt)->synchronous)
608 
609 #define HOSTIOPORT0		(HOSTDATA(shpnt)->io_port0)
610 #define HOSTIOPORT1		(HOSTDATA(shpnt)->io_port1)
611 
612 #define SCDATA(SCpnt)		((struct aha152x_scdata *) (SCpnt)->host_scribble)
613 #define SCNEXT(SCpnt)		SCDATA(SCpnt)->next
614 #define SCSEM(SCpnt)		SCDATA(SCpnt)->done
615 
616 #define SG_ADDRESS(buffer)	((char *) sg_virt((buffer)))
617 
618 /* state handling */
619 static void seldi_run(struct Scsi_Host *shpnt);
620 static void seldo_run(struct Scsi_Host *shpnt);
621 static void selto_run(struct Scsi_Host *shpnt);
622 static void busfree_run(struct Scsi_Host *shpnt);
623 
624 static void msgo_init(struct Scsi_Host *shpnt);
625 static void msgo_run(struct Scsi_Host *shpnt);
626 static void msgo_end(struct Scsi_Host *shpnt);
627 
628 static void cmd_init(struct Scsi_Host *shpnt);
629 static void cmd_run(struct Scsi_Host *shpnt);
630 static void cmd_end(struct Scsi_Host *shpnt);
631 
632 static void datai_init(struct Scsi_Host *shpnt);
633 static void datai_run(struct Scsi_Host *shpnt);
634 static void datai_end(struct Scsi_Host *shpnt);
635 
636 static void datao_init(struct Scsi_Host *shpnt);
637 static void datao_run(struct Scsi_Host *shpnt);
638 static void datao_end(struct Scsi_Host *shpnt);
639 
640 static void status_run(struct Scsi_Host *shpnt);
641 
642 static void msgi_run(struct Scsi_Host *shpnt);
643 static void msgi_end(struct Scsi_Host *shpnt);
644 
645 static void parerr_run(struct Scsi_Host *shpnt);
646 static void rsti_run(struct Scsi_Host *shpnt);
647 
648 static void is_complete(struct Scsi_Host *shpnt);
649 
650 /*
651  * driver states
652  *
653  */
654 static struct {
655 	char		*name;
656 	void		(*init)(struct Scsi_Host *);
657 	void		(*run)(struct Scsi_Host *);
658 	void		(*end)(struct Scsi_Host *);
659 	int		spio;
660 } states[] = {
661 	{ "idle",	NULL,		NULL,		NULL,		0},
662 	{ "unknown",	NULL,		NULL,		NULL,		0},
663 	{ "seldo",	NULL,		seldo_run,	NULL,		0},
664 	{ "seldi",	NULL,		seldi_run,	NULL,		0},
665 	{ "selto",	NULL,		selto_run,	NULL,		0},
666 	{ "busfree",	NULL,		busfree_run,	NULL,		0},
667 	{ "msgo",	msgo_init,	msgo_run,	msgo_end,	1},
668 	{ "cmd",	cmd_init,	cmd_run,	cmd_end,	1},
669 	{ "msgi",	NULL,		msgi_run,	msgi_end,	1},
670 	{ "status",	NULL,		status_run,	NULL,		1},
671 	{ "datai",	datai_init,	datai_run,	datai_end,	0},
672 	{ "datao",	datao_init,	datao_run,	datao_end,	0},
673 	{ "parerr",	NULL,		parerr_run,	NULL,		0},
674 	{ "rsti",	NULL,		rsti_run,	NULL,		0},
675 };
676 
677 /* setup & interrupt */
678 static irqreturn_t intr(int irq, void *dev_id);
679 static void reset_ports(struct Scsi_Host *shpnt);
680 static void aha152x_error(struct Scsi_Host *shpnt, char *msg);
681 static void done(struct Scsi_Host *shpnt, int error);
682 
683 /* diagnostics */
684 static void disp_ports(struct Scsi_Host *shpnt);
685 static void show_command(Scsi_Cmnd * ptr);
686 static void show_queues(struct Scsi_Host *shpnt);
687 static void disp_enintr(struct Scsi_Host *shpnt);
688 
689 
690 /*
691  *  queue services:
692  *
693  */
694 static inline void append_SC(Scsi_Cmnd **SC, Scsi_Cmnd *new_SC)
695 {
696 	Scsi_Cmnd *end;
697 
698 	SCNEXT(new_SC) = NULL;
699 	if (!*SC)
700 		*SC = new_SC;
701 	else {
702 		for (end = *SC; SCNEXT(end); end = SCNEXT(end))
703 			;
704 		SCNEXT(end) = new_SC;
705 	}
706 }
707 
708 static inline Scsi_Cmnd *remove_first_SC(Scsi_Cmnd ** SC)
709 {
710 	Scsi_Cmnd *ptr;
711 
712 	ptr = *SC;
713 	if (ptr) {
714 		*SC = SCNEXT(*SC);
715 		SCNEXT(ptr)=NULL;
716 	}
717 	return ptr;
718 }
719 
720 static inline Scsi_Cmnd *remove_lun_SC(Scsi_Cmnd ** SC, int target, int lun)
721 {
722 	Scsi_Cmnd *ptr, *prev;
723 
724 	for (ptr = *SC, prev = NULL;
725 	     ptr && ((ptr->device->id != target) || (ptr->device->lun != lun));
726 	     prev = ptr, ptr = SCNEXT(ptr))
727 	     ;
728 
729 	if (ptr) {
730 		if (prev)
731 			SCNEXT(prev) = SCNEXT(ptr);
732 		else
733 			*SC = SCNEXT(ptr);
734 
735 		SCNEXT(ptr)=NULL;
736 	}
737 
738 	return ptr;
739 }
740 
741 static inline Scsi_Cmnd *remove_SC(Scsi_Cmnd **SC, Scsi_Cmnd *SCp)
742 {
743 	Scsi_Cmnd *ptr, *prev;
744 
745 	for (ptr = *SC, prev = NULL;
746 	     ptr && SCp!=ptr;
747 	     prev = ptr, ptr = SCNEXT(ptr))
748 	     ;
749 
750 	if (ptr) {
751 		if (prev)
752 			SCNEXT(prev) = SCNEXT(ptr);
753 		else
754 			*SC = SCNEXT(ptr);
755 
756 		SCNEXT(ptr)=NULL;
757 	}
758 
759 	return ptr;
760 }
761 
762 static irqreturn_t swintr(int irqno, void *dev_id)
763 {
764 	struct Scsi_Host *shpnt = dev_id;
765 
766 	HOSTDATA(shpnt)->swint++;
767 
768 	SETPORT(DMACNTRL0, INTEN);
769 	return IRQ_HANDLED;
770 }
771 
772 struct Scsi_Host *aha152x_probe_one(struct aha152x_setup *setup)
773 {
774 	struct Scsi_Host *shpnt;
775 
776 	shpnt = scsi_host_alloc(&aha152x_driver_template, sizeof(struct aha152x_hostdata));
777 	if (!shpnt) {
778 		printk(KERN_ERR "aha152x: scsi_host_alloc failed\n");
779 		return NULL;
780 	}
781 
782 	memset(HOSTDATA(shpnt), 0, sizeof *HOSTDATA(shpnt));
783 	INIT_LIST_HEAD(&HOSTDATA(shpnt)->host_list);
784 
785 	/* need to have host registered before triggering any interrupt */
786 	list_add_tail(&HOSTDATA(shpnt)->host_list, &aha152x_host_list);
787 
788 	shpnt->io_port   = setup->io_port;
789 	shpnt->n_io_port = IO_RANGE;
790 	shpnt->irq       = setup->irq;
791 
792 	if (!setup->tc1550) {
793 		HOSTIOPORT0 = setup->io_port;
794 		HOSTIOPORT1 = setup->io_port;
795 	} else {
796 		HOSTIOPORT0 = setup->io_port+0x10;
797 		HOSTIOPORT1 = setup->io_port-0x10;
798 	}
799 
800 	spin_lock_init(&QLOCK);
801 	RECONNECT   = setup->reconnect;
802 	SYNCHRONOUS = setup->synchronous;
803 	PARITY      = setup->parity;
804 	DELAY       = setup->delay;
805 	EXT_TRANS   = setup->ext_trans;
806 
807 #if defined(AHA152X_DEBUG)
808 	HOSTDATA(shpnt)->debug = setup->debug;
809 #endif
810 
811 	SETPORT(SCSIID, setup->scsiid << 4);
812 	shpnt->this_id = setup->scsiid;
813 
814 	if (setup->reconnect)
815 		shpnt->can_queue = AHA152X_MAXQUEUE;
816 
817 	/* RESET OUT */
818 	printk("aha152x: resetting bus...\n");
819 	SETPORT(SCSISEQ, SCSIRSTO);
820 	mdelay(256);
821 	SETPORT(SCSISEQ, 0);
822 	mdelay(DELAY);
823 
824 	reset_ports(shpnt);
825 
826 	printk(KERN_INFO
827 	       "aha152x%d%s: "
828 	       "vital data: rev=%x, "
829 	       "io=0x%03lx (0x%03lx/0x%03lx), "
830 	       "irq=%d, "
831 	       "scsiid=%d, "
832 	       "reconnect=%s, "
833 	       "parity=%s, "
834 	       "synchronous=%s, "
835 	       "delay=%d, "
836 	       "extended translation=%s\n",
837 	       shpnt->host_no, setup->tc1550 ? " (tc1550 mode)" : "",
838 	       GETPORT(REV) & 0x7,
839 	       shpnt->io_port, HOSTIOPORT0, HOSTIOPORT1,
840 	       shpnt->irq,
841 	       shpnt->this_id,
842 	       RECONNECT ? "enabled" : "disabled",
843 	       PARITY ? "enabled" : "disabled",
844 	       SYNCHRONOUS ? "enabled" : "disabled",
845 	       DELAY,
846 	       EXT_TRANS ? "enabled" : "disabled");
847 
848 	/* not expecting any interrupts */
849 	SETPORT(SIMODE0, 0);
850 	SETPORT(SIMODE1, 0);
851 
852 	if( request_irq(shpnt->irq, swintr, IRQF_DISABLED|IRQF_SHARED, "aha152x", shpnt) ) {
853 		printk(KERN_ERR "aha152x%d: irq %d busy.\n", shpnt->host_no, shpnt->irq);
854 		goto out_host_put;
855 	}
856 
857 	HOSTDATA(shpnt)->swint = 0;
858 
859 	printk(KERN_INFO "aha152x%d: trying software interrupt, ", shpnt->host_no);
860 
861 	mb();
862 	SETPORT(DMACNTRL0, SWINT|INTEN);
863 	mdelay(1000);
864 	free_irq(shpnt->irq, shpnt);
865 
866 	if (!HOSTDATA(shpnt)->swint) {
867 		if (TESTHI(DMASTAT, INTSTAT)) {
868 			printk("lost.\n");
869 		} else {
870 			printk("failed.\n");
871 		}
872 
873 		SETPORT(DMACNTRL0, INTEN);
874 
875 		printk(KERN_ERR "aha152x%d: irq %d possibly wrong.  "
876 				"Please verify.\n", shpnt->host_no, shpnt->irq);
877 		goto out_host_put;
878 	}
879 	printk("ok.\n");
880 
881 
882 	/* clear interrupts */
883 	SETPORT(SSTAT0, 0x7f);
884 	SETPORT(SSTAT1, 0xef);
885 
886 	if ( request_irq(shpnt->irq, intr, IRQF_DISABLED|IRQF_SHARED, "aha152x", shpnt) ) {
887 		printk(KERN_ERR "aha152x%d: failed to reassign irq %d.\n", shpnt->host_no, shpnt->irq);
888 		goto out_host_put;
889 	}
890 
891 	if( scsi_add_host(shpnt, NULL) ) {
892 		free_irq(shpnt->irq, shpnt);
893 		printk(KERN_ERR "aha152x%d: failed to add host.\n", shpnt->host_no);
894 		goto out_host_put;
895 	}
896 
897 	scsi_scan_host(shpnt);
898 
899 	return shpnt;
900 
901 out_host_put:
902 	list_del(&HOSTDATA(shpnt)->host_list);
903 	scsi_host_put(shpnt);
904 
905 	return NULL;
906 }
907 
908 void aha152x_release(struct Scsi_Host *shpnt)
909 {
910 	if (!shpnt)
911 		return;
912 
913 	scsi_remove_host(shpnt);
914 	if (shpnt->irq)
915 		free_irq(shpnt->irq, shpnt);
916 
917 #if !defined(PCMCIA)
918 	if (shpnt->io_port)
919 		release_region(shpnt->io_port, IO_RANGE);
920 #endif
921 
922 #ifdef __ISAPNP__
923 	if (HOSTDATA(shpnt)->pnpdev)
924 		pnp_device_detach(HOSTDATA(shpnt)->pnpdev);
925 #endif
926 
927 	list_del(&HOSTDATA(shpnt)->host_list);
928 	scsi_host_put(shpnt);
929 }
930 
931 
932 /*
933  * setup controller to generate interrupts depending
934  * on current state (lock has to be acquired)
935  *
936  */
937 static int setup_expected_interrupts(struct Scsi_Host *shpnt)
938 {
939 	if(CURRENT_SC) {
940 		CURRENT_SC->SCp.phase |= 1 << 16;
941 
942 		if(CURRENT_SC->SCp.phase & selecting) {
943 			DPRINTK(debug_intr, DEBUG_LEAD "expecting: (seldo) (seltimo) (seldi)\n", CMDINFO(CURRENT_SC));
944 			SETPORT(SSTAT1, SELTO);
945 			SETPORT(SIMODE0, ENSELDO | (DISCONNECTED_SC ? ENSELDI : 0));
946 			SETPORT(SIMODE1, ENSELTIMO);
947 		} else {
948 			DPRINTK(debug_intr, DEBUG_LEAD "expecting: (phase change) (busfree) %s\n", CMDINFO(CURRENT_SC), CURRENT_SC->SCp.phase & spiordy ? "(spiordy)" : "");
949 			SETPORT(SIMODE0, (CURRENT_SC->SCp.phase & spiordy) ? ENSPIORDY : 0);
950 			SETPORT(SIMODE1, ENPHASEMIS | ENSCSIRST | ENSCSIPERR | ENBUSFREE);
951 		}
952 	} else if(STATE==seldi) {
953 		DPRINTK(debug_intr, DEBUG_LEAD "expecting: (phase change) (identify)\n", CMDINFO(CURRENT_SC));
954 		SETPORT(SIMODE0, 0);
955 		SETPORT(SIMODE1, ENPHASEMIS | ENSCSIRST | ENSCSIPERR | ENBUSFREE);
956 	} else {
957 		DPRINTK(debug_intr, DEBUG_LEAD "expecting: %s %s\n",
958 			CMDINFO(CURRENT_SC),
959 			DISCONNECTED_SC ? "(reselection)" : "",
960 			ISSUE_SC ? "(busfree)" : "");
961 		SETPORT(SIMODE0, DISCONNECTED_SC ? ENSELDI : 0);
962 		SETPORT(SIMODE1, ENSCSIRST | ( (ISSUE_SC||DONE_SC) ? ENBUSFREE : 0));
963 	}
964 
965 	if(!HOSTDATA(shpnt)->in_intr)
966 		SETBITS(DMACNTRL0, INTEN);
967 
968 	return TESTHI(DMASTAT, INTSTAT);
969 }
970 
971 
972 /*
973  *  Queue a command and setup interrupts for a free bus.
974  */
975 static int aha152x_internal_queue(Scsi_Cmnd *SCpnt, struct completion *complete,
976 		int phase, void (*done)(Scsi_Cmnd *))
977 {
978 	struct Scsi_Host *shpnt = SCpnt->device->host;
979 	unsigned long flags;
980 
981 #if defined(AHA152X_DEBUG)
982 	if (HOSTDATA(shpnt)->debug & debug_queue) {
983 		printk(INFO_LEAD "queue: %p; cmd_len=%d pieces=%d size=%u cmnd=",
984 		       CMDINFO(SCpnt), SCpnt, SCpnt->cmd_len,
985 		       scsi_sg_count(SCpnt), scsi_bufflen(SCpnt));
986 		__scsi_print_command(SCpnt->cmnd);
987 	}
988 #endif
989 
990 	SCpnt->scsi_done	= done;
991 	SCpnt->SCp.phase	= not_issued | phase;
992 	SCpnt->SCp.Status	= 0x1; /* Ilegal status by SCSI standard */
993 	SCpnt->SCp.Message	= 0;
994 	SCpnt->SCp.have_data_in	= 0;
995 	SCpnt->SCp.sent_command	= 0;
996 
997 	if(SCpnt->SCp.phase & (resetting|check_condition)) {
998 		if (!SCpnt->host_scribble || SCSEM(SCpnt) || SCNEXT(SCpnt)) {
999 			printk(ERR_LEAD "cannot reuse command\n", CMDINFO(SCpnt));
1000 			return FAILED;
1001 		}
1002 	} else {
1003 		SCpnt->host_scribble = kmalloc(sizeof(struct aha152x_scdata), GFP_ATOMIC);
1004 		if(!SCpnt->host_scribble) {
1005 			printk(ERR_LEAD "allocation failed\n", CMDINFO(SCpnt));
1006 			return FAILED;
1007 		}
1008 	}
1009 
1010 	SCNEXT(SCpnt)		= NULL;
1011 	SCSEM(SCpnt)		= complete;
1012 
1013 	/* setup scratch area
1014 	   SCp.ptr              : buffer pointer
1015 	   SCp.this_residual    : buffer length
1016 	   SCp.buffer           : next buffer
1017 	   SCp.buffers_residual : left buffers in list
1018 	   SCp.phase            : current state of the command */
1019 
1020 	if ((phase & resetting) || !scsi_sglist(SCpnt)) {
1021 		SCpnt->SCp.ptr           = NULL;
1022 		SCpnt->SCp.this_residual = 0;
1023 		scsi_set_resid(SCpnt, 0);
1024 		SCpnt->SCp.buffer           = NULL;
1025 		SCpnt->SCp.buffers_residual = 0;
1026 	} else {
1027 		scsi_set_resid(SCpnt, scsi_bufflen(SCpnt));
1028 		SCpnt->SCp.buffer           = scsi_sglist(SCpnt);
1029 		SCpnt->SCp.ptr              = SG_ADDRESS(SCpnt->SCp.buffer);
1030 		SCpnt->SCp.this_residual    = SCpnt->SCp.buffer->length;
1031 		SCpnt->SCp.buffers_residual = scsi_sg_count(SCpnt) - 1;
1032 	}
1033 
1034 	DO_LOCK(flags);
1035 
1036 #if defined(AHA152X_STAT)
1037 	HOSTDATA(shpnt)->total_commands++;
1038 #endif
1039 
1040 	/* Turn led on, when this is the first command. */
1041 	HOSTDATA(shpnt)->commands++;
1042 	if (HOSTDATA(shpnt)->commands==1)
1043 		SETPORT(PORTA, 1);
1044 
1045 	append_SC(&ISSUE_SC, SCpnt);
1046 
1047 	if(!HOSTDATA(shpnt)->in_intr)
1048 		setup_expected_interrupts(shpnt);
1049 
1050 	DO_UNLOCK(flags);
1051 
1052 	return 0;
1053 }
1054 
1055 /*
1056  *  queue a command
1057  *
1058  */
1059 static int aha152x_queue_lck(Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *))
1060 {
1061 #if 0
1062 	if(*SCpnt->cmnd == REQUEST_SENSE) {
1063 		SCpnt->result = 0;
1064 		done(SCpnt);
1065 
1066 		return 0;
1067 	}
1068 #endif
1069 
1070 	return aha152x_internal_queue(SCpnt, NULL, 0, done);
1071 }
1072 
1073 static DEF_SCSI_QCMD(aha152x_queue)
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 		complete(SCSEM(SCpnt));
1088 	} else {
1089 		printk(KERN_ERR "aha152x: reset_done w/o completion\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 /*
1143  * Reset a device
1144  *
1145  */
1146 static int aha152x_device_reset(Scsi_Cmnd * SCpnt)
1147 {
1148 	struct Scsi_Host *shpnt = SCpnt->device->host;
1149 	DECLARE_COMPLETION(done);
1150 	int ret, issued, disconnected;
1151 	unsigned char old_cmd_len = SCpnt->cmd_len;
1152 	unsigned long flags;
1153 	unsigned long timeleft;
1154 
1155 #if defined(AHA152X_DEBUG)
1156 	if(HOSTDATA(shpnt)->debug & debug_eh) {
1157 		printk(INFO_LEAD "aha152x_device_reset(%p)", CMDINFO(SCpnt), SCpnt);
1158 		show_queues(shpnt);
1159 	}
1160 #endif
1161 
1162 	if(CURRENT_SC==SCpnt) {
1163 		printk(ERR_LEAD "cannot reset current device\n", CMDINFO(SCpnt));
1164 		return FAILED;
1165 	}
1166 
1167 	DO_LOCK(flags);
1168 	issued       = remove_SC(&ISSUE_SC, SCpnt) == NULL;
1169 	disconnected = issued && remove_SC(&DISCONNECTED_SC, SCpnt);
1170 	DO_UNLOCK(flags);
1171 
1172 	SCpnt->cmd_len         = 0;
1173 
1174 	aha152x_internal_queue(SCpnt, &done, resetting, reset_done);
1175 
1176 	timeleft = wait_for_completion_timeout(&done, 100*HZ);
1177 	if (!timeleft) {
1178 		/* remove command from issue queue */
1179 		DO_LOCK(flags);
1180 		remove_SC(&ISSUE_SC, SCpnt);
1181 		DO_UNLOCK(flags);
1182 	}
1183 
1184 	SCpnt->cmd_len         = old_cmd_len;
1185 
1186 	DO_LOCK(flags);
1187 
1188 	if(SCpnt->SCp.phase & resetted) {
1189 		HOSTDATA(shpnt)->commands--;
1190 		if (!HOSTDATA(shpnt)->commands)
1191 			SETPORT(PORTA, 0);
1192 		kfree(SCpnt->host_scribble);
1193 		SCpnt->host_scribble=NULL;
1194 
1195 		ret = SUCCESS;
1196 	} else {
1197 		/* requeue */
1198 		if(!issued) {
1199 			append_SC(&ISSUE_SC, SCpnt);
1200 		} else if(disconnected) {
1201 			append_SC(&DISCONNECTED_SC, SCpnt);
1202 		}
1203 
1204 		ret = FAILED;
1205 	}
1206 
1207 	DO_UNLOCK(flags);
1208 	return ret;
1209 }
1210 
1211 static void free_hard_reset_SCs(struct Scsi_Host *shpnt, Scsi_Cmnd **SCs)
1212 {
1213 	Scsi_Cmnd *ptr;
1214 
1215 	ptr=*SCs;
1216 	while(ptr) {
1217 		Scsi_Cmnd *next;
1218 
1219 		if(SCDATA(ptr)) {
1220 			next = SCNEXT(ptr);
1221 		} else {
1222 			printk(DEBUG_LEAD "queue corrupted at %p\n", CMDINFO(ptr), ptr);
1223 			next = NULL;
1224 		}
1225 
1226 		if (!ptr->device->soft_reset) {
1227 			DPRINTK(debug_eh, DEBUG_LEAD "disconnected command %p removed\n", CMDINFO(ptr), ptr);
1228 			remove_SC(SCs, ptr);
1229 			HOSTDATA(shpnt)->commands--;
1230 			kfree(ptr->host_scribble);
1231 			ptr->host_scribble=NULL;
1232 		}
1233 
1234 		ptr = next;
1235 	}
1236 }
1237 
1238 /*
1239  * Reset the bus
1240  *
1241  */
1242 static int aha152x_bus_reset_host(struct Scsi_Host *shpnt)
1243 {
1244 	unsigned long flags;
1245 
1246 	DO_LOCK(flags);
1247 
1248 #if defined(AHA152X_DEBUG)
1249 	if(HOSTDATA(shpnt)->debug & debug_eh) {
1250 		printk(KERN_DEBUG "scsi%d: bus reset", shpnt->host_no);
1251 		show_queues(shpnt);
1252 	}
1253 #endif
1254 
1255 	free_hard_reset_SCs(shpnt, &ISSUE_SC);
1256 	free_hard_reset_SCs(shpnt, &DISCONNECTED_SC);
1257 
1258 	DPRINTK(debug_eh, KERN_DEBUG "scsi%d: resetting bus\n", shpnt->host_no);
1259 
1260 	SETPORT(SCSISEQ, SCSIRSTO);
1261 	mdelay(256);
1262 	SETPORT(SCSISEQ, 0);
1263 	mdelay(DELAY);
1264 
1265 	DPRINTK(debug_eh, KERN_DEBUG "scsi%d: bus resetted\n", shpnt->host_no);
1266 
1267 	setup_expected_interrupts(shpnt);
1268 	if(HOSTDATA(shpnt)->commands==0)
1269 		SETPORT(PORTA, 0);
1270 
1271 	DO_UNLOCK(flags);
1272 
1273 	return SUCCESS;
1274 }
1275 
1276 /*
1277  * Reset the bus
1278  *
1279  */
1280 static int aha152x_bus_reset(Scsi_Cmnd *SCpnt)
1281 {
1282 	return aha152x_bus_reset_host(SCpnt->device->host);
1283 }
1284 
1285 /*
1286  *  Restore default values to the AIC-6260 registers and reset the fifos
1287  *
1288  */
1289 static void reset_ports(struct Scsi_Host *shpnt)
1290 {
1291 	unsigned long flags;
1292 
1293 	/* disable interrupts */
1294 	SETPORT(DMACNTRL0, RSTFIFO);
1295 
1296 	SETPORT(SCSISEQ, 0);
1297 
1298 	SETPORT(SXFRCTL1, 0);
1299 	SETPORT(SCSISIG, 0);
1300 	SETRATE(0);
1301 
1302 	/* clear all interrupt conditions */
1303 	SETPORT(SSTAT0, 0x7f);
1304 	SETPORT(SSTAT1, 0xef);
1305 
1306 	SETPORT(SSTAT4, SYNCERR | FWERR | FRERR);
1307 
1308 	SETPORT(DMACNTRL0, 0);
1309 	SETPORT(DMACNTRL1, 0);
1310 
1311 	SETPORT(BRSTCNTRL, 0xf1);
1312 
1313 	/* clear SCSI fifos and transfer count */
1314 	SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
1315 	SETPORT(SXFRCTL0, CH1);
1316 
1317 	DO_LOCK(flags);
1318 	setup_expected_interrupts(shpnt);
1319 	DO_UNLOCK(flags);
1320 }
1321 
1322 /*
1323  * Reset the host (bus and controller)
1324  *
1325  */
1326 int aha152x_host_reset_host(struct Scsi_Host *shpnt)
1327 {
1328 	DPRINTK(debug_eh, KERN_DEBUG "scsi%d: host reset\n", shpnt->host_no);
1329 
1330 	aha152x_bus_reset_host(shpnt);
1331 
1332 	DPRINTK(debug_eh, KERN_DEBUG "scsi%d: resetting ports\n", shpnt->host_no);
1333 	reset_ports(shpnt);
1334 
1335 	return SUCCESS;
1336 }
1337 
1338 /*
1339  * Reset the host (bus and controller)
1340  *
1341  */
1342 static int aha152x_host_reset(Scsi_Cmnd *SCpnt)
1343 {
1344 	return aha152x_host_reset_host(SCpnt->device->host);
1345 }
1346 
1347 /*
1348  * Return the "logical geometry"
1349  *
1350  */
1351 static int aha152x_biosparam(struct scsi_device *sdev, struct block_device *bdev,
1352 		sector_t capacity, int *info_array)
1353 {
1354 	struct Scsi_Host *shpnt = sdev->host;
1355 
1356 	/* try default translation */
1357 	info_array[0] = 64;
1358 	info_array[1] = 32;
1359 	info_array[2] = (unsigned long)capacity / (64 * 32);
1360 
1361 	/* for disks >1GB do some guessing */
1362 	if (info_array[2] >= 1024) {
1363 		int info[3];
1364 
1365 		/* try to figure out the geometry from the partition table */
1366 		if (scsicam_bios_param(bdev, capacity, info) < 0 ||
1367 		    !((info[0] == 64 && info[1] == 32) || (info[0] == 255 && info[1] == 63))) {
1368 			if (EXT_TRANS) {
1369 				printk(KERN_NOTICE
1370 				       "aha152x: unable to verify geometry for disk with >1GB.\n"
1371 				       "         using extended translation.\n");
1372 				info_array[0] = 255;
1373 				info_array[1] = 63;
1374 				info_array[2] = (unsigned long)capacity / (255 * 63);
1375 			} else {
1376 				printk(KERN_NOTICE
1377 				       "aha152x: unable to verify geometry for disk with >1GB.\n"
1378 				       "         Using default translation. Please verify yourself.\n"
1379 				       "         Perhaps you need to enable extended translation in the driver.\n"
1380 				       "         See Documentation/scsi/aha152x.txt for details.\n");
1381 			}
1382 		} else {
1383 			info_array[0] = info[0];
1384 			info_array[1] = info[1];
1385 			info_array[2] = info[2];
1386 
1387 			if (info[0] == 255 && !EXT_TRANS) {
1388 				printk(KERN_NOTICE
1389 				       "aha152x: current partition table is using extended translation.\n"
1390 				       "         using it also, although it's not explicitly enabled.\n");
1391 			}
1392 		}
1393 	}
1394 
1395 	return 0;
1396 }
1397 
1398 /*
1399  *  Internal done function
1400  *
1401  */
1402 static void done(struct Scsi_Host *shpnt, int error)
1403 {
1404 	if (CURRENT_SC) {
1405 		if(DONE_SC)
1406 			printk(ERR_LEAD "there's already a completed command %p - will cause abort\n", CMDINFO(CURRENT_SC), DONE_SC);
1407 
1408 		DONE_SC = CURRENT_SC;
1409 		CURRENT_SC = NULL;
1410 		DONE_SC->result = error;
1411 	} else
1412 		printk(KERN_ERR "aha152x: done() called outside of command\n");
1413 }
1414 
1415 static struct work_struct aha152x_tq;
1416 
1417 /*
1418  * Run service completions on the card with interrupts enabled.
1419  *
1420  */
1421 static void run(struct work_struct *work)
1422 {
1423 	struct aha152x_hostdata *hd;
1424 
1425 	list_for_each_entry(hd, &aha152x_host_list, host_list) {
1426 		struct Scsi_Host *shost = container_of((void *)hd, struct Scsi_Host, hostdata);
1427 
1428 		is_complete(shost);
1429 	}
1430 }
1431 
1432 /*
1433  * Interrupt handler
1434  *
1435  */
1436 static irqreturn_t intr(int irqno, void *dev_id)
1437 {
1438 	struct Scsi_Host *shpnt = dev_id;
1439 	unsigned long flags;
1440 	unsigned char rev, dmacntrl0;
1441 
1442 	/*
1443 	 * Read a couple of registers that are known to not be all 1's. If
1444 	 * we read all 1's (-1), that means that either:
1445 	 *
1446 	 * a. The host adapter chip has gone bad, and we cannot control it,
1447 	 *	OR
1448 	 * b. The host adapter is a PCMCIA card that has been ejected
1449 	 *
1450 	 * In either case, we cannot do anything with the host adapter at
1451 	 * this point in time. So just ignore the interrupt and return.
1452 	 * In the latter case, the interrupt might actually be meant for
1453 	 * someone else sharing this IRQ, and that driver will handle it.
1454 	 */
1455 	rev = GETPORT(REV);
1456 	dmacntrl0 = GETPORT(DMACNTRL0);
1457 	if ((rev == 0xFF) && (dmacntrl0 == 0xFF))
1458 		return IRQ_NONE;
1459 
1460 	if( TESTLO(DMASTAT, INTSTAT) )
1461 		return IRQ_NONE;
1462 
1463 	/* no more interrupts from the controller, while we're busy.
1464 	   INTEN is restored by the BH handler */
1465 	CLRBITS(DMACNTRL0, INTEN);
1466 
1467 	DO_LOCK(flags);
1468 	if( HOSTDATA(shpnt)->service==0 ) {
1469 		HOSTDATA(shpnt)->service=1;
1470 
1471 		/* Poke the BH handler */
1472 		INIT_WORK(&aha152x_tq, run);
1473 		schedule_work(&aha152x_tq);
1474 	}
1475 	DO_UNLOCK(flags);
1476 
1477 	return IRQ_HANDLED;
1478 }
1479 
1480 /*
1481  * busfree phase
1482  * - handle completition/disconnection/error of current command
1483  * - start selection for next command (if any)
1484  */
1485 static void busfree_run(struct Scsi_Host *shpnt)
1486 {
1487 	unsigned long flags;
1488 #if defined(AHA152X_STAT)
1489 	int action=0;
1490 #endif
1491 
1492 	SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
1493 	SETPORT(SXFRCTL0, CH1);
1494 
1495 	SETPORT(SSTAT1, CLRBUSFREE);
1496 
1497 	if(CURRENT_SC) {
1498 #if defined(AHA152X_STAT)
1499 		action++;
1500 #endif
1501 		CURRENT_SC->SCp.phase &= ~syncneg;
1502 
1503 		if(CURRENT_SC->SCp.phase & completed) {
1504 			/* target sent COMMAND COMPLETE */
1505 			done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_OK << 16));
1506 
1507 		} else if(CURRENT_SC->SCp.phase & aborted) {
1508 			DPRINTK(debug_eh, DEBUG_LEAD "ABORT sent\n", CMDINFO(CURRENT_SC));
1509 			done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_ABORT << 16));
1510 
1511 		} else if(CURRENT_SC->SCp.phase & resetted) {
1512 			DPRINTK(debug_eh, DEBUG_LEAD "BUS DEVICE RESET sent\n", CMDINFO(CURRENT_SC));
1513 			done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_RESET << 16));
1514 
1515 		} else if(CURRENT_SC->SCp.phase & disconnected) {
1516 			/* target sent DISCONNECT */
1517 			DPRINTK(debug_selection, DEBUG_LEAD "target disconnected at %d/%d\n",
1518 				CMDINFO(CURRENT_SC),
1519 				scsi_get_resid(CURRENT_SC),
1520 				scsi_bufflen(CURRENT_SC));
1521 #if defined(AHA152X_STAT)
1522 			HOSTDATA(shpnt)->disconnections++;
1523 #endif
1524 			append_SC(&DISCONNECTED_SC, CURRENT_SC);
1525 			CURRENT_SC->SCp.phase |= 1 << 16;
1526 			CURRENT_SC = NULL;
1527 
1528 		} else {
1529 			done(shpnt, DID_ERROR << 16);
1530 		}
1531 #if defined(AHA152X_STAT)
1532 	} else {
1533 		HOSTDATA(shpnt)->busfree_without_old_command++;
1534 #endif
1535 	}
1536 
1537 	DO_LOCK(flags);
1538 
1539 	if(DONE_SC) {
1540 #if defined(AHA152X_STAT)
1541 		action++;
1542 #endif
1543 
1544 		if(DONE_SC->SCp.phase & check_condition) {
1545 			struct scsi_cmnd *cmd = HOSTDATA(shpnt)->done_SC;
1546 			struct aha152x_scdata *sc = SCDATA(cmd);
1547 
1548 #if 0
1549 			if(HOSTDATA(shpnt)->debug & debug_eh) {
1550 				printk(ERR_LEAD "received sense: ", CMDINFO(DONE_SC));
1551 				scsi_print_sense("bh", DONE_SC);
1552 			}
1553 #endif
1554 
1555 			scsi_eh_restore_cmnd(cmd, &sc->ses);
1556 
1557 			cmd->SCp.Status = SAM_STAT_CHECK_CONDITION;
1558 
1559 			HOSTDATA(shpnt)->commands--;
1560 			if (!HOSTDATA(shpnt)->commands)
1561 				SETPORT(PORTA, 0);	/* turn led off */
1562 		} else if(DONE_SC->SCp.Status==SAM_STAT_CHECK_CONDITION) {
1563 #if defined(AHA152X_STAT)
1564 			HOSTDATA(shpnt)->busfree_with_check_condition++;
1565 #endif
1566 #if 0
1567 			DPRINTK(debug_eh, ERR_LEAD "CHECK CONDITION found\n", CMDINFO(DONE_SC));
1568 #endif
1569 
1570 			if(!(DONE_SC->SCp.phase & not_issued)) {
1571 				struct aha152x_scdata *sc;
1572 				Scsi_Cmnd *ptr = DONE_SC;
1573 				DONE_SC=NULL;
1574 #if 0
1575 				DPRINTK(debug_eh, ERR_LEAD "requesting sense\n", CMDINFO(ptr));
1576 #endif
1577 
1578 				sc = SCDATA(ptr);
1579 				/* It was allocated in aha152x_internal_queue? */
1580 				BUG_ON(!sc);
1581 				scsi_eh_prep_cmnd(ptr, &sc->ses, NULL, 0, ~0);
1582 
1583 				DO_UNLOCK(flags);
1584 				aha152x_internal_queue(ptr, NULL, check_condition, ptr->scsi_done);
1585 				DO_LOCK(flags);
1586 #if 0
1587 			} else {
1588 				DPRINTK(debug_eh, ERR_LEAD "command not issued - CHECK CONDITION ignored\n", CMDINFO(DONE_SC));
1589 #endif
1590 			}
1591 		}
1592 
1593 		if(DONE_SC && DONE_SC->scsi_done) {
1594 #if defined(AHA152X_DEBUG)
1595 			int hostno=DONE_SC->device->host->host_no;
1596 			int id=DONE_SC->device->id & 0xf;
1597 			int lun=DONE_SC->device->lun & 0x7;
1598 #endif
1599 			Scsi_Cmnd *ptr = DONE_SC;
1600 			DONE_SC=NULL;
1601 
1602 			/* turn led off, when no commands are in the driver */
1603 			HOSTDATA(shpnt)->commands--;
1604 			if (!HOSTDATA(shpnt)->commands)
1605 				SETPORT(PORTA, 0);	/* turn led off */
1606 
1607 			if(ptr->scsi_done != reset_done) {
1608 				kfree(ptr->host_scribble);
1609 				ptr->host_scribble=NULL;
1610 			}
1611 
1612 			DO_UNLOCK(flags);
1613 			DPRINTK(debug_done, DEBUG_LEAD "calling scsi_done(%p)\n", hostno, id, lun, ptr);
1614                 	ptr->scsi_done(ptr);
1615 			DPRINTK(debug_done, DEBUG_LEAD "scsi_done(%p) returned\n", hostno, id, lun, ptr);
1616 			DO_LOCK(flags);
1617 		}
1618 
1619 		DONE_SC=NULL;
1620 #if defined(AHA152X_STAT)
1621 	} else {
1622 		HOSTDATA(shpnt)->busfree_without_done_command++;
1623 #endif
1624 	}
1625 
1626 	if(ISSUE_SC)
1627 		CURRENT_SC = remove_first_SC(&ISSUE_SC);
1628 
1629 	DO_UNLOCK(flags);
1630 
1631 	if(CURRENT_SC) {
1632 #if defined(AHA152X_STAT)
1633 		action++;
1634 #endif
1635 	    	CURRENT_SC->SCp.phase |= selecting;
1636 
1637 		DPRINTK(debug_selection, DEBUG_LEAD "selecting target\n", CMDINFO(CURRENT_SC));
1638 
1639 		/* clear selection timeout */
1640 		SETPORT(SSTAT1, SELTO);
1641 
1642 		SETPORT(SCSIID, (shpnt->this_id << OID_) | CURRENT_SC->device->id);
1643 		SETPORT(SXFRCTL1, (PARITY ? ENSPCHK : 0 ) | ENSTIMER);
1644 		SETPORT(SCSISEQ, ENSELO | ENAUTOATNO | (DISCONNECTED_SC ? ENRESELI : 0));
1645 	} else {
1646 #if defined(AHA152X_STAT)
1647 		HOSTDATA(shpnt)->busfree_without_new_command++;
1648 #endif
1649 		SETPORT(SCSISEQ, DISCONNECTED_SC ? ENRESELI : 0);
1650 	}
1651 
1652 #if defined(AHA152X_STAT)
1653 	if(!action)
1654 		HOSTDATA(shpnt)->busfree_without_any_action++;
1655 #endif
1656 }
1657 
1658 /*
1659  * Selection done (OUT)
1660  * - queue IDENTIFY message and SDTR to selected target for message out
1661  *   (ATN asserted automagically via ENAUTOATNO in busfree())
1662  */
1663 static void seldo_run(struct Scsi_Host *shpnt)
1664 {
1665 	SETPORT(SCSISIG, 0);
1666 	SETPORT(SSTAT1, CLRBUSFREE);
1667 	SETPORT(SSTAT1, CLRPHASECHG);
1668 
1669     	CURRENT_SC->SCp.phase &= ~(selecting|not_issued);
1670 
1671 	SETPORT(SCSISEQ, 0);
1672 
1673 	if (TESTLO(SSTAT0, SELDO)) {
1674 		printk(ERR_LEAD "aha152x: passing bus free condition\n", CMDINFO(CURRENT_SC));
1675 		done(shpnt, DID_NO_CONNECT << 16);
1676 		return;
1677 	}
1678 
1679 	SETPORT(SSTAT0, CLRSELDO);
1680 
1681 	ADDMSGO(IDENTIFY(RECONNECT, CURRENT_SC->device->lun));
1682 
1683 	if (CURRENT_SC->SCp.phase & aborting) {
1684 		ADDMSGO(ABORT);
1685 	} else if (CURRENT_SC->SCp.phase & resetting) {
1686 		ADDMSGO(BUS_DEVICE_RESET);
1687 	} else if (SYNCNEG==0 && SYNCHRONOUS) {
1688     		CURRENT_SC->SCp.phase |= syncneg;
1689 		MSGOLEN += spi_populate_sync_msg(&MSGO(MSGOLEN), 50, 8);
1690 		SYNCNEG=1;		/* negotiation in progress */
1691 	}
1692 
1693 	SETRATE(SYNCRATE);
1694 }
1695 
1696 /*
1697  * Selection timeout
1698  * - return command to mid-level with failure cause
1699  *
1700  */
1701 static void selto_run(struct Scsi_Host *shpnt)
1702 {
1703 	SETPORT(SCSISEQ, 0);
1704 	SETPORT(SSTAT1, CLRSELTIMO);
1705 
1706 	DPRINTK(debug_selection, DEBUG_LEAD "selection timeout\n", CMDINFO(CURRENT_SC));
1707 
1708 	if(!CURRENT_SC) {
1709 		DPRINTK(debug_selection, DEBUG_LEAD "!CURRENT_SC\n", CMDINFO(CURRENT_SC));
1710 		return;
1711 	}
1712 
1713     	CURRENT_SC->SCp.phase &= ~selecting;
1714 
1715 	if (CURRENT_SC->SCp.phase & aborted) {
1716 		DPRINTK(debug_selection, DEBUG_LEAD "aborted\n", CMDINFO(CURRENT_SC));
1717 		done(shpnt, DID_ABORT << 16);
1718 	} else if (TESTLO(SSTAT0, SELINGO)) {
1719 		DPRINTK(debug_selection, DEBUG_LEAD "arbitration not won\n", CMDINFO(CURRENT_SC));
1720 		done(shpnt, DID_BUS_BUSY << 16);
1721 	} else {
1722 		/* ARBITRATION won, but SELECTION failed */
1723 		DPRINTK(debug_selection, DEBUG_LEAD "selection failed\n", CMDINFO(CURRENT_SC));
1724 		done(shpnt, DID_NO_CONNECT << 16);
1725 	}
1726 }
1727 
1728 /*
1729  * Selection in done
1730  * - put current command back to issue queue
1731  *   (reconnection of a disconnected nexus instead
1732  *    of successful selection out)
1733  *
1734  */
1735 static void seldi_run(struct Scsi_Host *shpnt)
1736 {
1737 	int selid;
1738 	int target;
1739 	unsigned long flags;
1740 
1741 	SETPORT(SCSISIG, 0);
1742 	SETPORT(SSTAT0, CLRSELDI);
1743 	SETPORT(SSTAT1, CLRBUSFREE);
1744 	SETPORT(SSTAT1, CLRPHASECHG);
1745 
1746 	if(CURRENT_SC) {
1747 		if(!(CURRENT_SC->SCp.phase & not_issued))
1748 			printk(ERR_LEAD "command should not have been issued yet\n", CMDINFO(CURRENT_SC));
1749 
1750 		DPRINTK(debug_selection, ERR_LEAD "command requeued - reselection\n", CMDINFO(CURRENT_SC));
1751 
1752 		DO_LOCK(flags);
1753 		append_SC(&ISSUE_SC, CURRENT_SC);
1754 		DO_UNLOCK(flags);
1755 
1756 		CURRENT_SC = NULL;
1757 	}
1758 
1759 	if(!DISCONNECTED_SC) {
1760 		DPRINTK(debug_selection, DEBUG_LEAD "unexpected SELDI ", CMDINFO(CURRENT_SC));
1761 		return;
1762 	}
1763 
1764 	RECONN_TARGET=-1;
1765 
1766 	selid = GETPORT(SELID) & ~(1 << shpnt->this_id);
1767 
1768 	if (selid==0) {
1769 		printk("aha152x%d: target id unknown (%02x)\n", HOSTNO, selid);
1770 		return;
1771 	}
1772 
1773 	for(target=7; !(selid & (1 << target)); target--)
1774 		;
1775 
1776 	if(selid & ~(1 << target)) {
1777 		printk("aha152x%d: multiple targets reconnected (%02x)\n",
1778 		       HOSTNO, selid);
1779 	}
1780 
1781 
1782 	SETPORT(SCSIID, (shpnt->this_id << OID_) | target);
1783 	SETPORT(SCSISEQ, 0);
1784 
1785 	SETRATE(HOSTDATA(shpnt)->syncrate[target]);
1786 
1787 	RECONN_TARGET=target;
1788 	DPRINTK(debug_selection, DEBUG_LEAD "target %d reselected (%02x).\n", CMDINFO(CURRENT_SC), target, selid);
1789 }
1790 
1791 /*
1792  * message in phase
1793  * - handle initial message after reconnection to identify
1794  *   reconnecting nexus
1795  * - queue command on DISCONNECTED_SC on DISCONNECT message
1796  * - set completed flag on COMMAND COMPLETE
1797  *   (other completition code moved to busfree_run)
1798  * - handle response to SDTR
1799  * - clear synchronous transfer agreements on BUS RESET
1800  *
1801  * FIXME: what about SAVE POINTERS, RESTORE POINTERS?
1802  *
1803  */
1804 static void msgi_run(struct Scsi_Host *shpnt)
1805 {
1806 	for(;;) {
1807 		int sstat1 = GETPORT(SSTAT1);
1808 
1809 		if(sstat1 & (PHASECHG|PHASEMIS|BUSFREE) || !(sstat1 & REQINIT))
1810 			return;
1811 
1812 		if(TESTLO(SSTAT0,SPIORDY)) {
1813 			DPRINTK(debug_msgi, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
1814 			return;
1815 		}
1816 
1817 		ADDMSGI(GETPORT(SCSIDAT));
1818 
1819 #if defined(AHA152X_DEBUG)
1820 		if (HOSTDATA(shpnt)->debug & debug_msgi) {
1821 			printk(INFO_LEAD "inbound message %02x ", CMDINFO(CURRENT_SC), MSGI(0));
1822 			spi_print_msg(&MSGI(0));
1823 			printk("\n");
1824 		}
1825 #endif
1826 
1827 		if(!CURRENT_SC) {
1828 			if(LASTSTATE!=seldi) {
1829 				printk(KERN_ERR "aha152x%d: message in w/o current command not after reselection\n", HOSTNO);
1830 			}
1831 
1832 			/*
1833 	 	 	 * Handle reselection
1834 	 		 */
1835 			if(!(MSGI(0) & IDENTIFY_BASE)) {
1836 				printk(KERN_ERR "aha152x%d: target didn't identify after reselection\n", HOSTNO);
1837 				continue;
1838 			}
1839 
1840 			CURRENT_SC = remove_lun_SC(&DISCONNECTED_SC, RECONN_TARGET, MSGI(0) & 0x3f);
1841 
1842 			if (!CURRENT_SC) {
1843 				show_queues(shpnt);
1844 				printk(KERN_ERR "aha152x%d: no disconnected command for target %d/%d\n", HOSTNO, RECONN_TARGET, MSGI(0) & 0x3f);
1845 				continue;
1846 			}
1847 
1848 			DPRINTK(debug_msgi, DEBUG_LEAD "target reconnected\n", CMDINFO(CURRENT_SC));
1849 
1850 			CURRENT_SC->SCp.Message = MSGI(0);
1851 			CURRENT_SC->SCp.phase &= ~disconnected;
1852 
1853 			MSGILEN=0;
1854 
1855 			/* next message if any */
1856 			continue;
1857 		}
1858 
1859 		CURRENT_SC->SCp.Message = MSGI(0);
1860 
1861 		switch (MSGI(0)) {
1862 		case DISCONNECT:
1863 			if (!RECONNECT)
1864 				printk(WARN_LEAD "target was not allowed to disconnect\n", CMDINFO(CURRENT_SC));
1865 
1866 			CURRENT_SC->SCp.phase |= disconnected;
1867 			break;
1868 
1869 		case COMMAND_COMPLETE:
1870 			if(CURRENT_SC->SCp.phase & completed)
1871 				DPRINTK(debug_msgi, DEBUG_LEAD "again COMMAND COMPLETE\n", CMDINFO(CURRENT_SC));
1872 
1873 			CURRENT_SC->SCp.phase |= completed;
1874 			break;
1875 
1876 		case MESSAGE_REJECT:
1877 			if (SYNCNEG==1) {
1878 				printk(INFO_LEAD "Synchronous Data Transfer Request was rejected\n", CMDINFO(CURRENT_SC));
1879 				SYNCNEG=2;	/* negotiation completed */
1880 			} else
1881 				printk(INFO_LEAD "inbound message (MESSAGE REJECT)\n", CMDINFO(CURRENT_SC));
1882 			break;
1883 
1884 		case SAVE_POINTERS:
1885 			break;
1886 
1887 		case RESTORE_POINTERS:
1888 			break;
1889 
1890 		case EXTENDED_MESSAGE:
1891 			if(MSGILEN<2 || MSGILEN<MSGI(1)+2) {
1892 				/* not yet completed */
1893 				continue;
1894 			}
1895 
1896 			switch (MSGI(2)) {
1897 			case EXTENDED_SDTR:
1898 				{
1899 					long ticks;
1900 
1901 					if (MSGI(1) != 3) {
1902 						printk(ERR_LEAD "SDTR message length!=3\n", CMDINFO(CURRENT_SC));
1903 						break;
1904 					}
1905 
1906 					if (!HOSTDATA(shpnt)->synchronous)
1907 						break;
1908 
1909 					printk(INFO_LEAD, CMDINFO(CURRENT_SC));
1910 					spi_print_msg(&MSGI(0));
1911 					printk("\n");
1912 
1913 					ticks = (MSGI(3) * 4 + 49) / 50;
1914 
1915 					if (syncneg) {
1916 						/* negotiation in progress */
1917 						if (ticks > 9 || MSGI(4) < 1 || MSGI(4) > 8) {
1918 							ADDMSGO(MESSAGE_REJECT);
1919 							printk(INFO_LEAD "received Synchronous Data Transfer Request invalid - rejected\n", CMDINFO(CURRENT_SC));
1920 							break;
1921 						}
1922 
1923 						SYNCRATE |= ((ticks - 2) << 4) + MSGI(4);
1924 					} else if (ticks <= 9 && MSGI(4) >= 1) {
1925 						ADDMSGO(EXTENDED_MESSAGE);
1926 						ADDMSGO(3);
1927 						ADDMSGO(EXTENDED_SDTR);
1928 						if (ticks < 4) {
1929 							ticks = 4;
1930 							ADDMSGO(50);
1931 						} else
1932 							ADDMSGO(MSGI(3));
1933 
1934 						if (MSGI(4) > 8)
1935 							MSGI(4) = 8;
1936 
1937 						ADDMSGO(MSGI(4));
1938 
1939 						SYNCRATE |= ((ticks - 2) << 4) + MSGI(4);
1940 					} else {
1941 						/* requested SDTR is too slow, do it asynchronously */
1942 						printk(INFO_LEAD "Synchronous Data Transfer Request too slow - Rejecting\n", CMDINFO(CURRENT_SC));
1943 						ADDMSGO(MESSAGE_REJECT);
1944 					}
1945 
1946 					SYNCNEG=2;		/* negotiation completed */
1947 					SETRATE(SYNCRATE);
1948 				}
1949 				break;
1950 
1951 			case BUS_DEVICE_RESET:
1952 				{
1953 					int i;
1954 
1955 					for(i=0; i<8; i++) {
1956 						HOSTDATA(shpnt)->syncrate[i]=0;
1957 						HOSTDATA(shpnt)->syncneg[i]=0;
1958 					}
1959 
1960 				}
1961 				break;
1962 
1963 			case EXTENDED_MODIFY_DATA_POINTER:
1964 			case EXTENDED_EXTENDED_IDENTIFY:
1965 			case EXTENDED_WDTR:
1966 			default:
1967 				ADDMSGO(MESSAGE_REJECT);
1968 				break;
1969 			}
1970 			break;
1971 		}
1972 
1973 		MSGILEN=0;
1974 	}
1975 }
1976 
1977 static void msgi_end(struct Scsi_Host *shpnt)
1978 {
1979 	if(MSGILEN>0)
1980 		printk(WARN_LEAD "target left before message completed (%d)\n", CMDINFO(CURRENT_SC), MSGILEN);
1981 
1982 	if (MSGOLEN > 0 && !(GETPORT(SSTAT1) & BUSFREE)) {
1983 		DPRINTK(debug_msgi, DEBUG_LEAD "msgo pending\n", CMDINFO(CURRENT_SC));
1984 		SETPORT(SCSISIG, P_MSGI | SIG_ATNO);
1985 	}
1986 }
1987 
1988 /*
1989  * message out phase
1990  *
1991  */
1992 static void msgo_init(struct Scsi_Host *shpnt)
1993 {
1994 	if(MSGOLEN==0) {
1995 		if((CURRENT_SC->SCp.phase & syncneg) && SYNCNEG==2 && SYNCRATE==0) {
1996 			ADDMSGO(IDENTIFY(RECONNECT, CURRENT_SC->device->lun));
1997 		} else {
1998 			printk(INFO_LEAD "unexpected MESSAGE OUT phase; rejecting\n", CMDINFO(CURRENT_SC));
1999 			ADDMSGO(MESSAGE_REJECT);
2000 		}
2001 	}
2002 
2003 #if defined(AHA152X_DEBUG)
2004 	if(HOSTDATA(shpnt)->debug & debug_msgo) {
2005 		int i;
2006 
2007 		printk(DEBUG_LEAD "messages( ", CMDINFO(CURRENT_SC));
2008 		for (i=0; i<MSGOLEN; i+=spi_print_msg(&MSGO(i)), printk(" "))
2009 			;
2010 		printk(")\n");
2011 	}
2012 #endif
2013 }
2014 
2015 /*
2016  * message out phase
2017  *
2018  */
2019 static void msgo_run(struct Scsi_Host *shpnt)
2020 {
2021 	if(MSGO_I==MSGOLEN)
2022 		DPRINTK(debug_msgo, DEBUG_LEAD "messages all sent (%d/%d)\n", CMDINFO(CURRENT_SC), MSGO_I, MSGOLEN);
2023 
2024 	while(MSGO_I<MSGOLEN) {
2025 		DPRINTK(debug_msgo, DEBUG_LEAD "message byte %02x (%d/%d)\n", CMDINFO(CURRENT_SC), MSGO(MSGO_I), MSGO_I, MSGOLEN);
2026 
2027 		if(TESTLO(SSTAT0, SPIORDY)) {
2028 			DPRINTK(debug_msgo, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
2029 			return;
2030 		}
2031 
2032 		if (MSGO_I==MSGOLEN-1) {
2033 			/* Leave MESSAGE OUT after transfer */
2034 			SETPORT(SSTAT1, CLRATNO);
2035 		}
2036 
2037 
2038 		if (MSGO(MSGO_I) & IDENTIFY_BASE)
2039 			CURRENT_SC->SCp.phase |= identified;
2040 
2041 		if (MSGO(MSGO_I)==ABORT)
2042 			CURRENT_SC->SCp.phase |= aborted;
2043 
2044 		if (MSGO(MSGO_I)==BUS_DEVICE_RESET)
2045 			CURRENT_SC->SCp.phase |= resetted;
2046 
2047 		SETPORT(SCSIDAT, MSGO(MSGO_I++));
2048 	}
2049 }
2050 
2051 static void msgo_end(struct Scsi_Host *shpnt)
2052 {
2053 	if(MSGO_I<MSGOLEN) {
2054 		printk(ERR_LEAD "message sent incompletely (%d/%d)\n", CMDINFO(CURRENT_SC), MSGO_I, MSGOLEN);
2055 		if(SYNCNEG==1) {
2056 			printk(INFO_LEAD "Synchronous Data Transfer Request was rejected\n", CMDINFO(CURRENT_SC));
2057 			SYNCNEG=2;
2058 		}
2059 	}
2060 
2061 	MSGO_I  = 0;
2062 	MSGOLEN = 0;
2063 }
2064 
2065 /*
2066  * command phase
2067  *
2068  */
2069 static void cmd_init(struct Scsi_Host *shpnt)
2070 {
2071 	if (CURRENT_SC->SCp.sent_command) {
2072 		printk(ERR_LEAD "command already sent\n", CMDINFO(CURRENT_SC));
2073 		done(shpnt, DID_ERROR << 16);
2074 		return;
2075 	}
2076 
2077 #if defined(AHA152X_DEBUG)
2078 	if (HOSTDATA(shpnt)->debug & debug_cmd) {
2079 		printk(DEBUG_LEAD "cmd_init: ", CMDINFO(CURRENT_SC));
2080 		__scsi_print_command(CURRENT_SC->cmnd);
2081 	}
2082 #endif
2083 
2084 	CMD_I=0;
2085 }
2086 
2087 /*
2088  * command phase
2089  *
2090  */
2091 static void cmd_run(struct Scsi_Host *shpnt)
2092 {
2093 	if(CMD_I==CURRENT_SC->cmd_len) {
2094 		DPRINTK(debug_cmd, DEBUG_LEAD "command already completely sent (%d/%d)", CMDINFO(CURRENT_SC), CMD_I, CURRENT_SC->cmd_len);
2095 		disp_ports(shpnt);
2096 	}
2097 
2098 	while(CMD_I<CURRENT_SC->cmd_len) {
2099 		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);
2100 
2101 		if(TESTLO(SSTAT0, SPIORDY)) {
2102 			DPRINTK(debug_cmd, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
2103 			return;
2104 		}
2105 
2106 		SETPORT(SCSIDAT, CURRENT_SC->cmnd[CMD_I++]);
2107 	}
2108 }
2109 
2110 static void cmd_end(struct Scsi_Host *shpnt)
2111 {
2112 	if(CMD_I<CURRENT_SC->cmd_len)
2113 		printk(ERR_LEAD "command sent incompletely (%d/%d)\n", CMDINFO(CURRENT_SC), CMD_I, CURRENT_SC->cmd_len);
2114 	else
2115 		CURRENT_SC->SCp.sent_command++;
2116 }
2117 
2118 /*
2119  * status phase
2120  *
2121  */
2122 static void status_run(struct Scsi_Host *shpnt)
2123 {
2124 	if(TESTLO(SSTAT0,SPIORDY)) {
2125 		DPRINTK(debug_status, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
2126 		return;
2127 	}
2128 
2129 	CURRENT_SC->SCp.Status = GETPORT(SCSIDAT);
2130 
2131 #if defined(AHA152X_DEBUG)
2132 	if (HOSTDATA(shpnt)->debug & debug_status) {
2133 		printk(DEBUG_LEAD "inbound status %02x ", CMDINFO(CURRENT_SC), CURRENT_SC->SCp.Status);
2134 		scsi_print_status(CURRENT_SC->SCp.Status);
2135 		printk("\n");
2136 	}
2137 #endif
2138 }
2139 
2140 /*
2141  * data in phase
2142  *
2143  */
2144 static void datai_init(struct Scsi_Host *shpnt)
2145 {
2146 	SETPORT(DMACNTRL0, RSTFIFO);
2147 	SETPORT(DMACNTRL0, RSTFIFO|ENDMA);
2148 
2149 	SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2150 	SETPORT(SXFRCTL0, CH1|SCSIEN|DMAEN);
2151 
2152 	SETPORT(SIMODE0, 0);
2153 	SETPORT(SIMODE1, ENSCSIPERR | ENSCSIRST | ENPHASEMIS | ENBUSFREE);
2154 
2155 	DATA_LEN=0;
2156 	DPRINTK(debug_datai,
2157 		DEBUG_LEAD "datai_init: request_bufflen=%d resid=%d\n",
2158 		CMDINFO(CURRENT_SC), scsi_bufflen(CURRENT_SC),
2159 		scsi_get_resid(CURRENT_SC));
2160 }
2161 
2162 static void datai_run(struct Scsi_Host *shpnt)
2163 {
2164 	unsigned long the_time;
2165 	int fifodata, data_count;
2166 
2167 	/*
2168 	 * loop while the phase persists or the fifos are not empty
2169 	 *
2170 	 */
2171 	while(TESTLO(DMASTAT, INTSTAT) || TESTLO(DMASTAT, DFIFOEMP) || TESTLO(SSTAT2, SEMPTY)) {
2172 		/* FIXME: maybe this should be done by setting up
2173 		 * STCNT to trigger ENSWRAP interrupt, instead of
2174 		 * polling for DFIFOFULL
2175 		 */
2176 		the_time=jiffies + 100*HZ;
2177 		while(TESTLO(DMASTAT, DFIFOFULL|INTSTAT) && time_before(jiffies,the_time))
2178 			barrier();
2179 
2180 		if(TESTLO(DMASTAT, DFIFOFULL|INTSTAT)) {
2181 			printk(ERR_LEAD "datai timeout", CMDINFO(CURRENT_SC));
2182 			disp_ports(shpnt);
2183 			break;
2184 		}
2185 
2186 		if(TESTHI(DMASTAT, DFIFOFULL)) {
2187 			fifodata = 128;
2188 		} else {
2189 			the_time=jiffies + 100*HZ;
2190 			while(TESTLO(SSTAT2, SEMPTY) && time_before(jiffies,the_time))
2191 				barrier();
2192 
2193 			if(TESTLO(SSTAT2, SEMPTY)) {
2194 				printk(ERR_LEAD "datai sempty timeout", CMDINFO(CURRENT_SC));
2195 				disp_ports(shpnt);
2196 				break;
2197 			}
2198 
2199 			fifodata = GETPORT(FIFOSTAT);
2200 		}
2201 
2202 		if(CURRENT_SC->SCp.this_residual>0) {
2203 			while(fifodata>0 && CURRENT_SC->SCp.this_residual>0) {
2204                         	data_count = fifodata>CURRENT_SC->SCp.this_residual ?
2205 						CURRENT_SC->SCp.this_residual :
2206 						fifodata;
2207 				fifodata -= data_count;
2208 
2209                         	if(data_count & 1) {
2210 					DPRINTK(debug_datai, DEBUG_LEAD "8bit\n", CMDINFO(CURRENT_SC));
2211                                 	SETPORT(DMACNTRL0, ENDMA|_8BIT);
2212                                 	*CURRENT_SC->SCp.ptr++ = GETPORT(DATAPORT);
2213                                 	CURRENT_SC->SCp.this_residual--;
2214                                 	DATA_LEN++;
2215                                 	SETPORT(DMACNTRL0, ENDMA);
2216                         	}
2217 
2218                         	if(data_count > 1) {
2219 					DPRINTK(debug_datai, DEBUG_LEAD "16bit(%d)\n", CMDINFO(CURRENT_SC), data_count);
2220                                 	data_count >>= 1;
2221                                 	insw(DATAPORT, CURRENT_SC->SCp.ptr, data_count);
2222                                 	CURRENT_SC->SCp.ptr           += 2 * data_count;
2223                                 	CURRENT_SC->SCp.this_residual -= 2 * data_count;
2224                                 	DATA_LEN                      += 2 * data_count;
2225                         	}
2226 
2227                         	if(CURRENT_SC->SCp.this_residual==0 && CURRENT_SC->SCp.buffers_residual>0) {
2228                                		/* advance to next buffer */
2229                                		CURRENT_SC->SCp.buffers_residual--;
2230                                		CURRENT_SC->SCp.buffer++;
2231                                		CURRENT_SC->SCp.ptr           = SG_ADDRESS(CURRENT_SC->SCp.buffer);
2232                                		CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length;
2233 				}
2234                 	}
2235 		} else if(fifodata>0) {
2236 			printk(ERR_LEAD "no buffers left for %d(%d) bytes (data overrun!?)\n", CMDINFO(CURRENT_SC), fifodata, GETPORT(FIFOSTAT));
2237                         SETPORT(DMACNTRL0, ENDMA|_8BIT);
2238 			while(fifodata>0) {
2239 				int data;
2240 				data=GETPORT(DATAPORT);
2241 				DPRINTK(debug_datai, DEBUG_LEAD "data=%02x\n", CMDINFO(CURRENT_SC), data);
2242 				fifodata--;
2243 				DATA_LEN++;
2244 			}
2245                         SETPORT(DMACNTRL0, ENDMA|_8BIT);
2246 		}
2247 	}
2248 
2249 	if(TESTLO(DMASTAT, INTSTAT) ||
2250 	   TESTLO(DMASTAT, DFIFOEMP) ||
2251 	   TESTLO(SSTAT2, SEMPTY) ||
2252 	   GETPORT(FIFOSTAT)>0) {
2253 	   	/*
2254 		 * something went wrong, if there's something left in the fifos
2255 		 * or the phase didn't change
2256 		 */
2257 		printk(ERR_LEAD "fifos should be empty and phase should have changed\n", CMDINFO(CURRENT_SC));
2258 		disp_ports(shpnt);
2259 	}
2260 
2261 	if(DATA_LEN!=GETSTCNT()) {
2262 		printk(ERR_LEAD
2263 		       "manual transfer count differs from automatic (count=%d;stcnt=%d;diff=%d;fifostat=%d)",
2264 		       CMDINFO(CURRENT_SC), DATA_LEN, GETSTCNT(), GETSTCNT()-DATA_LEN, GETPORT(FIFOSTAT));
2265 		disp_ports(shpnt);
2266 		mdelay(10000);
2267 	}
2268 }
2269 
2270 static void datai_end(struct Scsi_Host *shpnt)
2271 {
2272 	CMD_INC_RESID(CURRENT_SC, -GETSTCNT());
2273 
2274 	DPRINTK(debug_datai,
2275 		DEBUG_LEAD "datai_end: request_bufflen=%d resid=%d stcnt=%d\n",
2276 		CMDINFO(CURRENT_SC), scsi_bufflen(CURRENT_SC),
2277 		scsi_get_resid(CURRENT_SC), GETSTCNT());
2278 
2279 	SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2280 	SETPORT(DMACNTRL0, 0);
2281 }
2282 
2283 /*
2284  * data out phase
2285  *
2286  */
2287 static void datao_init(struct Scsi_Host *shpnt)
2288 {
2289 	SETPORT(DMACNTRL0, WRITE_READ | RSTFIFO);
2290 	SETPORT(DMACNTRL0, WRITE_READ | ENDMA);
2291 
2292 	SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2293 	SETPORT(SXFRCTL0, CH1|SCSIEN|DMAEN);
2294 
2295 	SETPORT(SIMODE0, 0);
2296 	SETPORT(SIMODE1, ENSCSIPERR | ENSCSIRST | ENPHASEMIS | ENBUSFREE );
2297 
2298 	DATA_LEN = scsi_get_resid(CURRENT_SC);
2299 
2300 	DPRINTK(debug_datao,
2301 		DEBUG_LEAD "datao_init: request_bufflen=%d; resid=%d\n",
2302 		CMDINFO(CURRENT_SC), scsi_bufflen(CURRENT_SC),
2303 		scsi_get_resid(CURRENT_SC));
2304 }
2305 
2306 static void datao_run(struct Scsi_Host *shpnt)
2307 {
2308 	unsigned long the_time;
2309 	int data_count;
2310 
2311 	/* until phase changes or all data sent */
2312 	while(TESTLO(DMASTAT, INTSTAT) && CURRENT_SC->SCp.this_residual>0) {
2313 		data_count = 128;
2314 		if(data_count > CURRENT_SC->SCp.this_residual)
2315 			data_count=CURRENT_SC->SCp.this_residual;
2316 
2317 		if(TESTLO(DMASTAT, DFIFOEMP)) {
2318 			printk(ERR_LEAD "datao fifo not empty (%d)", CMDINFO(CURRENT_SC), GETPORT(FIFOSTAT));
2319 			disp_ports(shpnt);
2320 			break;
2321 		}
2322 
2323 		if(data_count & 1) {
2324 			SETPORT(DMACNTRL0,WRITE_READ|ENDMA|_8BIT);
2325 			SETPORT(DATAPORT, *CURRENT_SC->SCp.ptr++);
2326 			CURRENT_SC->SCp.this_residual--;
2327 			CMD_INC_RESID(CURRENT_SC, -1);
2328 			SETPORT(DMACNTRL0,WRITE_READ|ENDMA);
2329 		}
2330 
2331 		if(data_count > 1) {
2332 			data_count >>= 1;
2333 			outsw(DATAPORT, CURRENT_SC->SCp.ptr, data_count);
2334 			CURRENT_SC->SCp.ptr           += 2 * data_count;
2335 			CURRENT_SC->SCp.this_residual -= 2 * data_count;
2336 			CMD_INC_RESID(CURRENT_SC, -2 * data_count);
2337 	  	}
2338 
2339 		if(CURRENT_SC->SCp.this_residual==0 && CURRENT_SC->SCp.buffers_residual>0) {
2340 			/* advance to next buffer */
2341 			CURRENT_SC->SCp.buffers_residual--;
2342 			CURRENT_SC->SCp.buffer++;
2343 			CURRENT_SC->SCp.ptr           = SG_ADDRESS(CURRENT_SC->SCp.buffer);
2344 			CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length;
2345 		}
2346 
2347 		the_time=jiffies + 100*HZ;
2348 		while(TESTLO(DMASTAT, DFIFOEMP|INTSTAT) && time_before(jiffies,the_time))
2349 			barrier();
2350 
2351 		if(TESTLO(DMASTAT, DFIFOEMP|INTSTAT)) {
2352 			printk(ERR_LEAD "dataout timeout", CMDINFO(CURRENT_SC));
2353 			disp_ports(shpnt);
2354 			break;
2355 		}
2356 	}
2357 }
2358 
2359 static void datao_end(struct Scsi_Host *shpnt)
2360 {
2361 	if(TESTLO(DMASTAT, DFIFOEMP)) {
2362 		int data_count = (DATA_LEN - scsi_get_resid(CURRENT_SC)) -
2363 		                                                    GETSTCNT();
2364 
2365 		DPRINTK(debug_datao, DEBUG_LEAD "datao: %d bytes to resend (%d written, %d transferred)\n",
2366 			CMDINFO(CURRENT_SC),
2367 			data_count,
2368 			DATA_LEN - scsi_get_resid(CURRENT_SC),
2369 			GETSTCNT());
2370 
2371 		CMD_INC_RESID(CURRENT_SC, data_count);
2372 
2373 		data_count -= CURRENT_SC->SCp.ptr -
2374 		                             SG_ADDRESS(CURRENT_SC->SCp.buffer);
2375 		while(data_count>0) {
2376 			CURRENT_SC->SCp.buffer--;
2377 			CURRENT_SC->SCp.buffers_residual++;
2378 			data_count -= CURRENT_SC->SCp.buffer->length;
2379 		}
2380 		CURRENT_SC->SCp.ptr = SG_ADDRESS(CURRENT_SC->SCp.buffer) -
2381 		                                                     data_count;
2382 		CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length +
2383 		                                                     data_count;
2384 	}
2385 
2386 	DPRINTK(debug_datao, DEBUG_LEAD "datao_end: request_bufflen=%d; resid=%d; stcnt=%d\n",
2387 		CMDINFO(CURRENT_SC),
2388 		scsi_bufflen(CURRENT_SC),
2389 		scsi_get_resid(CURRENT_SC),
2390 		GETSTCNT());
2391 
2392 	SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
2393 	SETPORT(SXFRCTL0, CH1);
2394 
2395 	SETPORT(DMACNTRL0, 0);
2396 }
2397 
2398 /*
2399  * figure out what state we're in
2400  *
2401  */
2402 static int update_state(struct Scsi_Host *shpnt)
2403 {
2404 	int dataphase=0;
2405 	unsigned int stat0 = GETPORT(SSTAT0);
2406 	unsigned int stat1 = GETPORT(SSTAT1);
2407 
2408 	PREVSTATE = STATE;
2409 	STATE=unknown;
2410 
2411 	if(stat1 & SCSIRSTI) {
2412 		STATE=rsti;
2413 		SETPORT(SCSISEQ,0);
2414 		SETPORT(SSTAT1,SCSIRSTI);
2415   	} else if(stat0 & SELDI && PREVSTATE==busfree) {
2416 		STATE=seldi;
2417 	} else if(stat0 & SELDO && CURRENT_SC && (CURRENT_SC->SCp.phase & selecting)) {
2418 		STATE=seldo;
2419 	} else if(stat1 & SELTO) {
2420 		STATE=selto;
2421 	} else if(stat1 & BUSFREE) {
2422 		STATE=busfree;
2423 		SETPORT(SSTAT1,BUSFREE);
2424 	} else if(stat1 & SCSIPERR) {
2425 		STATE=parerr;
2426 		SETPORT(SSTAT1,SCSIPERR);
2427 	} else if(stat1 & REQINIT) {
2428 		switch(GETPORT(SCSISIG) & P_MASK) {
2429 		case P_MSGI:	STATE=msgi;	break;
2430 		case P_MSGO:	STATE=msgo;	break;
2431 		case P_DATAO:	STATE=datao;	break;
2432 		case P_DATAI:	STATE=datai;	break;
2433 		case P_STATUS:	STATE=status;	break;
2434 		case P_CMD:	STATE=cmd;	break;
2435 		}
2436 		dataphase=1;
2437 	}
2438 
2439 	if((stat0 & SELDI) && STATE!=seldi && !dataphase) {
2440 		printk(INFO_LEAD "reselection missed?", CMDINFO(CURRENT_SC));
2441 		disp_ports(shpnt);
2442 	}
2443 
2444 	if(STATE!=PREVSTATE) {
2445 		LASTSTATE=PREVSTATE;
2446 	}
2447 
2448 	return dataphase;
2449 }
2450 
2451 /*
2452  * handle parity error
2453  *
2454  * FIXME: in which phase?
2455  *
2456  */
2457 static void parerr_run(struct Scsi_Host *shpnt)
2458 {
2459 	printk(ERR_LEAD "parity error\n", CMDINFO(CURRENT_SC));
2460 	done(shpnt, DID_PARITY << 16);
2461 }
2462 
2463 /*
2464  * handle reset in
2465  *
2466  */
2467 static void rsti_run(struct Scsi_Host *shpnt)
2468 {
2469 	Scsi_Cmnd *ptr;
2470 
2471 	printk(KERN_NOTICE "aha152x%d: scsi reset in\n", HOSTNO);
2472 
2473 	ptr=DISCONNECTED_SC;
2474 	while(ptr) {
2475 		Scsi_Cmnd *next = SCNEXT(ptr);
2476 
2477 		if (!ptr->device->soft_reset) {
2478 			remove_SC(&DISCONNECTED_SC, ptr);
2479 
2480 			kfree(ptr->host_scribble);
2481 			ptr->host_scribble=NULL;
2482 
2483 			ptr->result =  DID_RESET << 16;
2484 			ptr->scsi_done(ptr);
2485 		}
2486 
2487 		ptr = next;
2488 	}
2489 
2490 	if(CURRENT_SC && !CURRENT_SC->device->soft_reset)
2491 		done(shpnt, DID_RESET << 16 );
2492 }
2493 
2494 
2495 /*
2496  * bottom-half handler
2497  *
2498  */
2499 static void is_complete(struct Scsi_Host *shpnt)
2500 {
2501 	int dataphase;
2502 	unsigned long flags;
2503 	int pending;
2504 
2505 	if(!shpnt)
2506 		return;
2507 
2508 	DO_LOCK(flags);
2509 
2510 	if( HOSTDATA(shpnt)->service==0 )  {
2511 		DO_UNLOCK(flags);
2512 		return;
2513 	}
2514 
2515 	HOSTDATA(shpnt)->service = 0;
2516 
2517 	if(HOSTDATA(shpnt)->in_intr) {
2518 		DO_UNLOCK(flags);
2519 		/* aha152x_error never returns.. */
2520 		aha152x_error(shpnt, "bottom-half already running!?");
2521 	}
2522 	HOSTDATA(shpnt)->in_intr++;
2523 
2524 	/*
2525 	 * loop while there are interrupt conditions pending
2526 	 *
2527 	 */
2528 	do {
2529 		unsigned long start = jiffies;
2530 		DO_UNLOCK(flags);
2531 
2532 		dataphase=update_state(shpnt);
2533 
2534 		DPRINTK(debug_phases, LEAD "start %s %s(%s)\n", CMDINFO(CURRENT_SC), states[STATE].name, states[PREVSTATE].name, states[LASTSTATE].name);
2535 
2536 		/*
2537 		 * end previous state
2538 		 *
2539 		 */
2540 		if(PREVSTATE!=STATE && states[PREVSTATE].end)
2541 			states[PREVSTATE].end(shpnt);
2542 
2543 		/*
2544 		 * disable SPIO mode if previous phase used it
2545 		 * and this one doesn't
2546 		 *
2547 		 */
2548 		if(states[PREVSTATE].spio && !states[STATE].spio) {
2549 			SETPORT(SXFRCTL0, CH1);
2550 			SETPORT(DMACNTRL0, 0);
2551 			if(CURRENT_SC)
2552 				CURRENT_SC->SCp.phase &= ~spiordy;
2553 		}
2554 
2555 		/*
2556 		 * accept current dataphase phase
2557 		 *
2558 		 */
2559 		if(dataphase) {
2560 			SETPORT(SSTAT0, REQINIT);
2561 			SETPORT(SCSISIG, GETPORT(SCSISIG) & P_MASK);
2562 			SETPORT(SSTAT1, PHASECHG);
2563 		}
2564 
2565 		/*
2566 		 * enable SPIO mode if previous didn't use it
2567 		 * and this one does
2568 		 *
2569 		 */
2570 		if(!states[PREVSTATE].spio && states[STATE].spio) {
2571 			SETPORT(DMACNTRL0, 0);
2572 			SETPORT(SXFRCTL0, CH1|SPIOEN);
2573 			if(CURRENT_SC)
2574 				CURRENT_SC->SCp.phase |= spiordy;
2575 		}
2576 
2577 		/*
2578 		 * initialize for new state
2579 		 *
2580 		 */
2581 		if(PREVSTATE!=STATE && states[STATE].init)
2582 			states[STATE].init(shpnt);
2583 
2584 		/*
2585 		 * handle current state
2586 		 *
2587 		 */
2588 		if(states[STATE].run)
2589 			states[STATE].run(shpnt);
2590 		else
2591 			printk(ERR_LEAD "unexpected state (%x)\n", CMDINFO(CURRENT_SC), STATE);
2592 
2593 		/*
2594 		 * setup controller to interrupt on
2595 		 * the next expected condition and
2596 		 * loop if it's already there
2597 		 *
2598 		 */
2599 		DO_LOCK(flags);
2600 		pending=setup_expected_interrupts(shpnt);
2601 #if defined(AHA152X_STAT)
2602 		HOSTDATA(shpnt)->count[STATE]++;
2603 		if(PREVSTATE!=STATE)
2604 			HOSTDATA(shpnt)->count_trans[STATE]++;
2605 		HOSTDATA(shpnt)->time[STATE] += jiffies-start;
2606 #endif
2607 
2608 		DPRINTK(debug_phases, LEAD "end %s %s(%s)\n", CMDINFO(CURRENT_SC), states[STATE].name, states[PREVSTATE].name, states[LASTSTATE].name);
2609 	} while(pending);
2610 
2611 	/*
2612 	 * enable interrupts and leave bottom-half
2613 	 *
2614 	 */
2615 	HOSTDATA(shpnt)->in_intr--;
2616 	SETBITS(DMACNTRL0, INTEN);
2617 	DO_UNLOCK(flags);
2618 }
2619 
2620 
2621 /*
2622  * Dump the current driver status and panic
2623  */
2624 static void aha152x_error(struct Scsi_Host *shpnt, char *msg)
2625 {
2626 	printk(KERN_EMERG "\naha152x%d: %s\n", HOSTNO, msg);
2627 	show_queues(shpnt);
2628 	panic("aha152x panic\n");
2629 }
2630 
2631 /*
2632  * Display registers of AIC-6260
2633  */
2634 static void disp_ports(struct Scsi_Host *shpnt)
2635 {
2636 #if defined(AHA152X_DEBUG)
2637 	int s;
2638 
2639 	printk("\n%s: %s(%s) ",
2640 		CURRENT_SC ? "busy" : "waiting",
2641 		states[STATE].name,
2642 		states[PREVSTATE].name);
2643 
2644 	s = GETPORT(SCSISEQ);
2645 	printk("SCSISEQ( ");
2646 	if (s & TEMODEO)
2647 		printk("TARGET MODE ");
2648 	if (s & ENSELO)
2649 		printk("SELO ");
2650 	if (s & ENSELI)
2651 		printk("SELI ");
2652 	if (s & ENRESELI)
2653 		printk("RESELI ");
2654 	if (s & ENAUTOATNO)
2655 		printk("AUTOATNO ");
2656 	if (s & ENAUTOATNI)
2657 		printk("AUTOATNI ");
2658 	if (s & ENAUTOATNP)
2659 		printk("AUTOATNP ");
2660 	if (s & SCSIRSTO)
2661 		printk("SCSIRSTO ");
2662 	printk(");");
2663 
2664 	printk(" SCSISIG(");
2665 	s = GETPORT(SCSISIG);
2666 	switch (s & P_MASK) {
2667 	case P_DATAO:
2668 		printk("DATA OUT");
2669 		break;
2670 	case P_DATAI:
2671 		printk("DATA IN");
2672 		break;
2673 	case P_CMD:
2674 		printk("COMMAND");
2675 		break;
2676 	case P_STATUS:
2677 		printk("STATUS");
2678 		break;
2679 	case P_MSGO:
2680 		printk("MESSAGE OUT");
2681 		break;
2682 	case P_MSGI:
2683 		printk("MESSAGE IN");
2684 		break;
2685 	default:
2686 		printk("*invalid*");
2687 		break;
2688 	}
2689 
2690 	printk("); ");
2691 
2692 	printk("INTSTAT (%s); ", TESTHI(DMASTAT, INTSTAT) ? "hi" : "lo");
2693 
2694 	printk("SSTAT( ");
2695 	s = GETPORT(SSTAT0);
2696 	if (s & TARGET)
2697 		printk("TARGET ");
2698 	if (s & SELDO)
2699 		printk("SELDO ");
2700 	if (s & SELDI)
2701 		printk("SELDI ");
2702 	if (s & SELINGO)
2703 		printk("SELINGO ");
2704 	if (s & SWRAP)
2705 		printk("SWRAP ");
2706 	if (s & SDONE)
2707 		printk("SDONE ");
2708 	if (s & SPIORDY)
2709 		printk("SPIORDY ");
2710 	if (s & DMADONE)
2711 		printk("DMADONE ");
2712 
2713 	s = GETPORT(SSTAT1);
2714 	if (s & SELTO)
2715 		printk("SELTO ");
2716 	if (s & ATNTARG)
2717 		printk("ATNTARG ");
2718 	if (s & SCSIRSTI)
2719 		printk("SCSIRSTI ");
2720 	if (s & PHASEMIS)
2721 		printk("PHASEMIS ");
2722 	if (s & BUSFREE)
2723 		printk("BUSFREE ");
2724 	if (s & SCSIPERR)
2725 		printk("SCSIPERR ");
2726 	if (s & PHASECHG)
2727 		printk("PHASECHG ");
2728 	if (s & REQINIT)
2729 		printk("REQINIT ");
2730 	printk("); ");
2731 
2732 
2733 	printk("SSTAT( ");
2734 
2735 	s = GETPORT(SSTAT0) & GETPORT(SIMODE0);
2736 
2737 	if (s & TARGET)
2738 		printk("TARGET ");
2739 	if (s & SELDO)
2740 		printk("SELDO ");
2741 	if (s & SELDI)
2742 		printk("SELDI ");
2743 	if (s & SELINGO)
2744 		printk("SELINGO ");
2745 	if (s & SWRAP)
2746 		printk("SWRAP ");
2747 	if (s & SDONE)
2748 		printk("SDONE ");
2749 	if (s & SPIORDY)
2750 		printk("SPIORDY ");
2751 	if (s & DMADONE)
2752 		printk("DMADONE ");
2753 
2754 	s = GETPORT(SSTAT1) & GETPORT(SIMODE1);
2755 
2756 	if (s & SELTO)
2757 		printk("SELTO ");
2758 	if (s & ATNTARG)
2759 		printk("ATNTARG ");
2760 	if (s & SCSIRSTI)
2761 		printk("SCSIRSTI ");
2762 	if (s & PHASEMIS)
2763 		printk("PHASEMIS ");
2764 	if (s & BUSFREE)
2765 		printk("BUSFREE ");
2766 	if (s & SCSIPERR)
2767 		printk("SCSIPERR ");
2768 	if (s & PHASECHG)
2769 		printk("PHASECHG ");
2770 	if (s & REQINIT)
2771 		printk("REQINIT ");
2772 	printk("); ");
2773 
2774 	printk("SXFRCTL0( ");
2775 
2776 	s = GETPORT(SXFRCTL0);
2777 	if (s & SCSIEN)
2778 		printk("SCSIEN ");
2779 	if (s & DMAEN)
2780 		printk("DMAEN ");
2781 	if (s & CH1)
2782 		printk("CH1 ");
2783 	if (s & CLRSTCNT)
2784 		printk("CLRSTCNT ");
2785 	if (s & SPIOEN)
2786 		printk("SPIOEN ");
2787 	if (s & CLRCH1)
2788 		printk("CLRCH1 ");
2789 	printk("); ");
2790 
2791 	printk("SIGNAL( ");
2792 
2793 	s = GETPORT(SCSISIG);
2794 	if (s & SIG_ATNI)
2795 		printk("ATNI ");
2796 	if (s & SIG_SELI)
2797 		printk("SELI ");
2798 	if (s & SIG_BSYI)
2799 		printk("BSYI ");
2800 	if (s & SIG_REQI)
2801 		printk("REQI ");
2802 	if (s & SIG_ACKI)
2803 		printk("ACKI ");
2804 	printk("); ");
2805 
2806 	printk("SELID (%02x), ", GETPORT(SELID));
2807 
2808 	printk("STCNT (%d), ", GETSTCNT());
2809 
2810 	printk("SSTAT2( ");
2811 
2812 	s = GETPORT(SSTAT2);
2813 	if (s & SOFFSET)
2814 		printk("SOFFSET ");
2815 	if (s & SEMPTY)
2816 		printk("SEMPTY ");
2817 	if (s & SFULL)
2818 		printk("SFULL ");
2819 	printk("); SFCNT (%d); ", s & (SFULL | SFCNT));
2820 
2821 	s = GETPORT(SSTAT3);
2822 	printk("SCSICNT (%d), OFFCNT(%d), ", (s & 0xf0) >> 4, s & 0x0f);
2823 
2824 	printk("SSTAT4( ");
2825 	s = GETPORT(SSTAT4);
2826 	if (s & SYNCERR)
2827 		printk("SYNCERR ");
2828 	if (s & FWERR)
2829 		printk("FWERR ");
2830 	if (s & FRERR)
2831 		printk("FRERR ");
2832 	printk("); ");
2833 
2834 	printk("DMACNTRL0( ");
2835 	s = GETPORT(DMACNTRL0);
2836 	printk("%s ", s & _8BIT ? "8BIT" : "16BIT");
2837 	printk("%s ", s & DMA ? "DMA" : "PIO");
2838 	printk("%s ", s & WRITE_READ ? "WRITE" : "READ");
2839 	if (s & ENDMA)
2840 		printk("ENDMA ");
2841 	if (s & INTEN)
2842 		printk("INTEN ");
2843 	if (s & RSTFIFO)
2844 		printk("RSTFIFO ");
2845 	if (s & SWINT)
2846 		printk("SWINT ");
2847 	printk("); ");
2848 
2849 	printk("DMASTAT( ");
2850 	s = GETPORT(DMASTAT);
2851 	if (s & ATDONE)
2852 		printk("ATDONE ");
2853 	if (s & WORDRDY)
2854 		printk("WORDRDY ");
2855 	if (s & DFIFOFULL)
2856 		printk("DFIFOFULL ");
2857 	if (s & DFIFOEMP)
2858 		printk("DFIFOEMP ");
2859 	printk(")\n");
2860 #endif
2861 }
2862 
2863 /*
2864  * display enabled interrupts
2865  */
2866 static void disp_enintr(struct Scsi_Host *shpnt)
2867 {
2868 	int s;
2869 
2870 	printk(KERN_DEBUG "enabled interrupts ( ");
2871 
2872 	s = GETPORT(SIMODE0);
2873 	if (s & ENSELDO)
2874 		printk("ENSELDO ");
2875 	if (s & ENSELDI)
2876 		printk("ENSELDI ");
2877 	if (s & ENSELINGO)
2878 		printk("ENSELINGO ");
2879 	if (s & ENSWRAP)
2880 		printk("ENSWRAP ");
2881 	if (s & ENSDONE)
2882 		printk("ENSDONE ");
2883 	if (s & ENSPIORDY)
2884 		printk("ENSPIORDY ");
2885 	if (s & ENDMADONE)
2886 		printk("ENDMADONE ");
2887 
2888 	s = GETPORT(SIMODE1);
2889 	if (s & ENSELTIMO)
2890 		printk("ENSELTIMO ");
2891 	if (s & ENATNTARG)
2892 		printk("ENATNTARG ");
2893 	if (s & ENPHASEMIS)
2894 		printk("ENPHASEMIS ");
2895 	if (s & ENBUSFREE)
2896 		printk("ENBUSFREE ");
2897 	if (s & ENSCSIPERR)
2898 		printk("ENSCSIPERR ");
2899 	if (s & ENPHASECHG)
2900 		printk("ENPHASECHG ");
2901 	if (s & ENREQINIT)
2902 		printk("ENREQINIT ");
2903 	printk(")\n");
2904 }
2905 
2906 /*
2907  * Show the command data of a command
2908  */
2909 static void show_command(Scsi_Cmnd *ptr)
2910 {
2911 	scmd_printk(KERN_DEBUG, ptr, "%p: cmnd=(", ptr);
2912 
2913 	__scsi_print_command(ptr->cmnd);
2914 
2915 	printk(KERN_DEBUG "); request_bufflen=%d; resid=%d; phase |",
2916 	       scsi_bufflen(ptr), scsi_get_resid(ptr));
2917 
2918 	if (ptr->SCp.phase & not_issued)
2919 		printk("not issued|");
2920 	if (ptr->SCp.phase & selecting)
2921 		printk("selecting|");
2922 	if (ptr->SCp.phase & identified)
2923 		printk("identified|");
2924 	if (ptr->SCp.phase & disconnected)
2925 		printk("disconnected|");
2926 	if (ptr->SCp.phase & completed)
2927 		printk("completed|");
2928 	if (ptr->SCp.phase & spiordy)
2929 		printk("spiordy|");
2930 	if (ptr->SCp.phase & syncneg)
2931 		printk("syncneg|");
2932 	if (ptr->SCp.phase & aborted)
2933 		printk("aborted|");
2934 	if (ptr->SCp.phase & resetted)
2935 		printk("resetted|");
2936 	if( SCDATA(ptr) ) {
2937 		printk("; next=0x%p\n", SCNEXT(ptr));
2938 	} else {
2939 		printk("; next=(host scribble NULL)\n");
2940 	}
2941 }
2942 
2943 /*
2944  * Dump the queued data
2945  */
2946 static void show_queues(struct Scsi_Host *shpnt)
2947 {
2948 	Scsi_Cmnd *ptr;
2949 	unsigned long flags;
2950 
2951 	DO_LOCK(flags);
2952 	printk(KERN_DEBUG "\nqueue status:\nissue_SC:\n");
2953 	for (ptr = ISSUE_SC; ptr; ptr = SCNEXT(ptr))
2954 		show_command(ptr);
2955 	DO_UNLOCK(flags);
2956 
2957 	printk(KERN_DEBUG "current_SC:\n");
2958 	if (CURRENT_SC)
2959 		show_command(CURRENT_SC);
2960 	else
2961 		printk(KERN_DEBUG "none\n");
2962 
2963 	printk(KERN_DEBUG "disconnected_SC:\n");
2964 	for (ptr = DISCONNECTED_SC; ptr; ptr = SCDATA(ptr) ? SCNEXT(ptr) : NULL)
2965 		show_command(ptr);
2966 
2967 	disp_ports(shpnt);
2968 	disp_enintr(shpnt);
2969 }
2970 
2971 #undef SPRINTF
2972 #define SPRINTF(args...) pos += sprintf(pos, ## args)
2973 
2974 static int get_command(char *pos, Scsi_Cmnd * ptr)
2975 {
2976 	char *start = pos;
2977 	int i;
2978 
2979 	SPRINTF("0x%08x: target=%d; lun=%d; cmnd=( ",
2980 		(unsigned int) ptr, ptr->device->id, ptr->device->lun);
2981 
2982 	for (i = 0; i < COMMAND_SIZE(ptr->cmnd[0]); i++)
2983 		SPRINTF("0x%02x ", ptr->cmnd[i]);
2984 
2985 	SPRINTF("); resid=%d; residual=%d; buffers=%d; phase |",
2986 		scsi_get_resid(ptr), ptr->SCp.this_residual,
2987 		ptr->SCp.buffers_residual);
2988 
2989 	if (ptr->SCp.phase & not_issued)
2990 		SPRINTF("not issued|");
2991 	if (ptr->SCp.phase & selecting)
2992 		SPRINTF("selecting|");
2993 	if (ptr->SCp.phase & disconnected)
2994 		SPRINTF("disconnected|");
2995 	if (ptr->SCp.phase & aborted)
2996 		SPRINTF("aborted|");
2997 	if (ptr->SCp.phase & identified)
2998 		SPRINTF("identified|");
2999 	if (ptr->SCp.phase & completed)
3000 		SPRINTF("completed|");
3001 	if (ptr->SCp.phase & spiordy)
3002 		SPRINTF("spiordy|");
3003 	if (ptr->SCp.phase & syncneg)
3004 		SPRINTF("syncneg|");
3005 	SPRINTF("; next=0x%p\n", SCNEXT(ptr));
3006 
3007 	return (pos - start);
3008 }
3009 
3010 static int get_ports(struct Scsi_Host *shpnt, char *pos)
3011 {
3012 	char *start = pos;
3013 	int s;
3014 
3015 	SPRINTF("\n%s: %s(%s) ", CURRENT_SC ? "on bus" : "waiting", states[STATE].name, states[PREVSTATE].name);
3016 
3017 	s = GETPORT(SCSISEQ);
3018 	SPRINTF("SCSISEQ( ");
3019 	if (s & TEMODEO)
3020 		SPRINTF("TARGET MODE ");
3021 	if (s & ENSELO)
3022 		SPRINTF("SELO ");
3023 	if (s & ENSELI)
3024 		SPRINTF("SELI ");
3025 	if (s & ENRESELI)
3026 		SPRINTF("RESELI ");
3027 	if (s & ENAUTOATNO)
3028 		SPRINTF("AUTOATNO ");
3029 	if (s & ENAUTOATNI)
3030 		SPRINTF("AUTOATNI ");
3031 	if (s & ENAUTOATNP)
3032 		SPRINTF("AUTOATNP ");
3033 	if (s & SCSIRSTO)
3034 		SPRINTF("SCSIRSTO ");
3035 	SPRINTF(");");
3036 
3037 	SPRINTF(" SCSISIG(");
3038 	s = GETPORT(SCSISIG);
3039 	switch (s & P_MASK) {
3040 	case P_DATAO:
3041 		SPRINTF("DATA OUT");
3042 		break;
3043 	case P_DATAI:
3044 		SPRINTF("DATA IN");
3045 		break;
3046 	case P_CMD:
3047 		SPRINTF("COMMAND");
3048 		break;
3049 	case P_STATUS:
3050 		SPRINTF("STATUS");
3051 		break;
3052 	case P_MSGO:
3053 		SPRINTF("MESSAGE OUT");
3054 		break;
3055 	case P_MSGI:
3056 		SPRINTF("MESSAGE IN");
3057 		break;
3058 	default:
3059 		SPRINTF("*invalid*");
3060 		break;
3061 	}
3062 
3063 	SPRINTF("); ");
3064 
3065 	SPRINTF("INTSTAT (%s); ", TESTHI(DMASTAT, INTSTAT) ? "hi" : "lo");
3066 
3067 	SPRINTF("SSTAT( ");
3068 	s = GETPORT(SSTAT0);
3069 	if (s & TARGET)
3070 		SPRINTF("TARGET ");
3071 	if (s & SELDO)
3072 		SPRINTF("SELDO ");
3073 	if (s & SELDI)
3074 		SPRINTF("SELDI ");
3075 	if (s & SELINGO)
3076 		SPRINTF("SELINGO ");
3077 	if (s & SWRAP)
3078 		SPRINTF("SWRAP ");
3079 	if (s & SDONE)
3080 		SPRINTF("SDONE ");
3081 	if (s & SPIORDY)
3082 		SPRINTF("SPIORDY ");
3083 	if (s & DMADONE)
3084 		SPRINTF("DMADONE ");
3085 
3086 	s = GETPORT(SSTAT1);
3087 	if (s & SELTO)
3088 		SPRINTF("SELTO ");
3089 	if (s & ATNTARG)
3090 		SPRINTF("ATNTARG ");
3091 	if (s & SCSIRSTI)
3092 		SPRINTF("SCSIRSTI ");
3093 	if (s & PHASEMIS)
3094 		SPRINTF("PHASEMIS ");
3095 	if (s & BUSFREE)
3096 		SPRINTF("BUSFREE ");
3097 	if (s & SCSIPERR)
3098 		SPRINTF("SCSIPERR ");
3099 	if (s & PHASECHG)
3100 		SPRINTF("PHASECHG ");
3101 	if (s & REQINIT)
3102 		SPRINTF("REQINIT ");
3103 	SPRINTF("); ");
3104 
3105 
3106 	SPRINTF("SSTAT( ");
3107 
3108 	s = GETPORT(SSTAT0) & GETPORT(SIMODE0);
3109 
3110 	if (s & TARGET)
3111 		SPRINTF("TARGET ");
3112 	if (s & SELDO)
3113 		SPRINTF("SELDO ");
3114 	if (s & SELDI)
3115 		SPRINTF("SELDI ");
3116 	if (s & SELINGO)
3117 		SPRINTF("SELINGO ");
3118 	if (s & SWRAP)
3119 		SPRINTF("SWRAP ");
3120 	if (s & SDONE)
3121 		SPRINTF("SDONE ");
3122 	if (s & SPIORDY)
3123 		SPRINTF("SPIORDY ");
3124 	if (s & DMADONE)
3125 		SPRINTF("DMADONE ");
3126 
3127 	s = GETPORT(SSTAT1) & GETPORT(SIMODE1);
3128 
3129 	if (s & SELTO)
3130 		SPRINTF("SELTO ");
3131 	if (s & ATNTARG)
3132 		SPRINTF("ATNTARG ");
3133 	if (s & SCSIRSTI)
3134 		SPRINTF("SCSIRSTI ");
3135 	if (s & PHASEMIS)
3136 		SPRINTF("PHASEMIS ");
3137 	if (s & BUSFREE)
3138 		SPRINTF("BUSFREE ");
3139 	if (s & SCSIPERR)
3140 		SPRINTF("SCSIPERR ");
3141 	if (s & PHASECHG)
3142 		SPRINTF("PHASECHG ");
3143 	if (s & REQINIT)
3144 		SPRINTF("REQINIT ");
3145 	SPRINTF("); ");
3146 
3147 	SPRINTF("SXFRCTL0( ");
3148 
3149 	s = GETPORT(SXFRCTL0);
3150 	if (s & SCSIEN)
3151 		SPRINTF("SCSIEN ");
3152 	if (s & DMAEN)
3153 		SPRINTF("DMAEN ");
3154 	if (s & CH1)
3155 		SPRINTF("CH1 ");
3156 	if (s & CLRSTCNT)
3157 		SPRINTF("CLRSTCNT ");
3158 	if (s & SPIOEN)
3159 		SPRINTF("SPIOEN ");
3160 	if (s & CLRCH1)
3161 		SPRINTF("CLRCH1 ");
3162 	SPRINTF("); ");
3163 
3164 	SPRINTF("SIGNAL( ");
3165 
3166 	s = GETPORT(SCSISIG);
3167 	if (s & SIG_ATNI)
3168 		SPRINTF("ATNI ");
3169 	if (s & SIG_SELI)
3170 		SPRINTF("SELI ");
3171 	if (s & SIG_BSYI)
3172 		SPRINTF("BSYI ");
3173 	if (s & SIG_REQI)
3174 		SPRINTF("REQI ");
3175 	if (s & SIG_ACKI)
3176 		SPRINTF("ACKI ");
3177 	SPRINTF("); ");
3178 
3179 	SPRINTF("SELID(%02x), ", GETPORT(SELID));
3180 
3181 	SPRINTF("STCNT(%d), ", GETSTCNT());
3182 
3183 	SPRINTF("SSTAT2( ");
3184 
3185 	s = GETPORT(SSTAT2);
3186 	if (s & SOFFSET)
3187 		SPRINTF("SOFFSET ");
3188 	if (s & SEMPTY)
3189 		SPRINTF("SEMPTY ");
3190 	if (s & SFULL)
3191 		SPRINTF("SFULL ");
3192 	SPRINTF("); SFCNT (%d); ", s & (SFULL | SFCNT));
3193 
3194 	s = GETPORT(SSTAT3);
3195 	SPRINTF("SCSICNT (%d), OFFCNT(%d), ", (s & 0xf0) >> 4, s & 0x0f);
3196 
3197 	SPRINTF("SSTAT4( ");
3198 	s = GETPORT(SSTAT4);
3199 	if (s & SYNCERR)
3200 		SPRINTF("SYNCERR ");
3201 	if (s & FWERR)
3202 		SPRINTF("FWERR ");
3203 	if (s & FRERR)
3204 		SPRINTF("FRERR ");
3205 	SPRINTF("); ");
3206 
3207 	SPRINTF("DMACNTRL0( ");
3208 	s = GETPORT(DMACNTRL0);
3209 	SPRINTF("%s ", s & _8BIT ? "8BIT" : "16BIT");
3210 	SPRINTF("%s ", s & DMA ? "DMA" : "PIO");
3211 	SPRINTF("%s ", s & WRITE_READ ? "WRITE" : "READ");
3212 	if (s & ENDMA)
3213 		SPRINTF("ENDMA ");
3214 	if (s & INTEN)
3215 		SPRINTF("INTEN ");
3216 	if (s & RSTFIFO)
3217 		SPRINTF("RSTFIFO ");
3218 	if (s & SWINT)
3219 		SPRINTF("SWINT ");
3220 	SPRINTF("); ");
3221 
3222 	SPRINTF("DMASTAT( ");
3223 	s = GETPORT(DMASTAT);
3224 	if (s & ATDONE)
3225 		SPRINTF("ATDONE ");
3226 	if (s & WORDRDY)
3227 		SPRINTF("WORDRDY ");
3228 	if (s & DFIFOFULL)
3229 		SPRINTF("DFIFOFULL ");
3230 	if (s & DFIFOEMP)
3231 		SPRINTF("DFIFOEMP ");
3232 	SPRINTF(")\n");
3233 
3234 	SPRINTF("enabled interrupts( ");
3235 
3236 	s = GETPORT(SIMODE0);
3237 	if (s & ENSELDO)
3238 		SPRINTF("ENSELDO ");
3239 	if (s & ENSELDI)
3240 		SPRINTF("ENSELDI ");
3241 	if (s & ENSELINGO)
3242 		SPRINTF("ENSELINGO ");
3243 	if (s & ENSWRAP)
3244 		SPRINTF("ENSWRAP ");
3245 	if (s & ENSDONE)
3246 		SPRINTF("ENSDONE ");
3247 	if (s & ENSPIORDY)
3248 		SPRINTF("ENSPIORDY ");
3249 	if (s & ENDMADONE)
3250 		SPRINTF("ENDMADONE ");
3251 
3252 	s = GETPORT(SIMODE1);
3253 	if (s & ENSELTIMO)
3254 		SPRINTF("ENSELTIMO ");
3255 	if (s & ENATNTARG)
3256 		SPRINTF("ENATNTARG ");
3257 	if (s & ENPHASEMIS)
3258 		SPRINTF("ENPHASEMIS ");
3259 	if (s & ENBUSFREE)
3260 		SPRINTF("ENBUSFREE ");
3261 	if (s & ENSCSIPERR)
3262 		SPRINTF("ENSCSIPERR ");
3263 	if (s & ENPHASECHG)
3264 		SPRINTF("ENPHASECHG ");
3265 	if (s & ENREQINIT)
3266 		SPRINTF("ENREQINIT ");
3267 	SPRINTF(")\n");
3268 
3269 	return (pos - start);
3270 }
3271 
3272 static int aha152x_set_info(char *buffer, int length, struct Scsi_Host *shpnt)
3273 {
3274 	if(!shpnt || !buffer || length<8 || strncmp("aha152x ", buffer, 8)!=0)
3275 		return -EINVAL;
3276 
3277 #if defined(AHA152X_DEBUG)
3278 	if(length>14 && strncmp("debug ", buffer+8, 6)==0) {
3279 		int debug = HOSTDATA(shpnt)->debug;
3280 
3281 		HOSTDATA(shpnt)->debug = simple_strtoul(buffer+14, NULL, 0);
3282 
3283 		printk(KERN_INFO "aha152x%d: debugging options set to 0x%04x (were 0x%04x)\n", HOSTNO, HOSTDATA(shpnt)->debug, debug);
3284 	} else
3285 #endif
3286 #if defined(AHA152X_STAT)
3287 	if(length>13 && strncmp("reset", buffer+8, 5)==0) {
3288 		int i;
3289 
3290 		HOSTDATA(shpnt)->total_commands=0;
3291 		HOSTDATA(shpnt)->disconnections=0;
3292 		HOSTDATA(shpnt)->busfree_without_any_action=0;
3293 		HOSTDATA(shpnt)->busfree_without_old_command=0;
3294 		HOSTDATA(shpnt)->busfree_without_new_command=0;
3295 		HOSTDATA(shpnt)->busfree_without_done_command=0;
3296 		HOSTDATA(shpnt)->busfree_with_check_condition=0;
3297 		for (i = idle; i<maxstate; i++) {
3298 			HOSTDATA(shpnt)->count[i]=0;
3299 			HOSTDATA(shpnt)->count_trans[i]=0;
3300 			HOSTDATA(shpnt)->time[i]=0;
3301 		}
3302 
3303 		printk(KERN_INFO "aha152x%d: stats reseted.\n", HOSTNO);
3304 
3305 	} else
3306 #endif
3307 	{
3308 		return -EINVAL;
3309 	}
3310 
3311 
3312 	return length;
3313 }
3314 
3315 #undef SPRINTF
3316 #define SPRINTF(args...) \
3317 	do { if(pos < buffer + length) pos += sprintf(pos, ## args); } while(0)
3318 
3319 static int aha152x_proc_info(struct Scsi_Host *shpnt, char *buffer, char **start,
3320 		      off_t offset, int length, int inout)
3321 {
3322 	int i;
3323 	char *pos = buffer;
3324 	Scsi_Cmnd *ptr;
3325 	unsigned long flags;
3326 	int thislength;
3327 
3328 	DPRINTK(debug_procinfo,
3329 	       KERN_DEBUG "aha152x_proc_info: buffer=%p offset=%ld length=%d hostno=%d inout=%d\n",
3330 	       buffer, offset, length, shpnt->host_no, inout);
3331 
3332 
3333 	if (inout)
3334 		return aha152x_set_info(buffer, length, shpnt);
3335 
3336 	SPRINTF(AHA152X_REVID "\n");
3337 
3338 	SPRINTF("ioports 0x%04lx to 0x%04lx\n",
3339 		shpnt->io_port, shpnt->io_port + shpnt->n_io_port - 1);
3340 	SPRINTF("interrupt 0x%02x\n", shpnt->irq);
3341 	SPRINTF("disconnection/reconnection %s\n",
3342 		RECONNECT ? "enabled" : "disabled");
3343 	SPRINTF("parity checking %s\n",
3344 		PARITY ? "enabled" : "disabled");
3345 	SPRINTF("synchronous transfers %s\n",
3346 		SYNCHRONOUS ? "enabled" : "disabled");
3347 	SPRINTF("%d commands currently queued\n", HOSTDATA(shpnt)->commands);
3348 
3349 	if(SYNCHRONOUS) {
3350 		SPRINTF("synchronously operating targets (tick=50 ns):\n");
3351 		for (i = 0; i < 8; i++)
3352 			if (HOSTDATA(shpnt)->syncrate[i] & 0x7f)
3353 				SPRINTF("target %d: period %dT/%dns; req/ack offset %d\n",
3354 					i,
3355 					(((HOSTDATA(shpnt)->syncrate[i] & 0x70) >> 4) + 2),
3356 					(((HOSTDATA(shpnt)->syncrate[i] & 0x70) >> 4) + 2) * 50,
3357 				    HOSTDATA(shpnt)->syncrate[i] & 0x0f);
3358 	}
3359 #if defined(AHA152X_DEBUG)
3360 #define PDEBUG(flags,txt) \
3361 	if(HOSTDATA(shpnt)->debug & flags) SPRINTF("(%s) ", txt);
3362 
3363 	SPRINTF("enabled debugging options: ");
3364 
3365 	PDEBUG(debug_procinfo, "procinfo");
3366 	PDEBUG(debug_queue, "queue");
3367 	PDEBUG(debug_intr, "interrupt");
3368 	PDEBUG(debug_selection, "selection");
3369 	PDEBUG(debug_msgo, "message out");
3370 	PDEBUG(debug_msgi, "message in");
3371 	PDEBUG(debug_status, "status");
3372 	PDEBUG(debug_cmd, "command");
3373 	PDEBUG(debug_datai, "data in");
3374 	PDEBUG(debug_datao, "data out");
3375 	PDEBUG(debug_eh, "eh");
3376 	PDEBUG(debug_locking, "locks");
3377 	PDEBUG(debug_phases, "phases");
3378 
3379 	SPRINTF("\n");
3380 #endif
3381 
3382 	SPRINTF("\nqueue status:\n");
3383 	DO_LOCK(flags);
3384 	if (ISSUE_SC) {
3385 		SPRINTF("not yet issued commands:\n");
3386 		for (ptr = ISSUE_SC; ptr; ptr = SCNEXT(ptr))
3387 			pos += get_command(pos, ptr);
3388 	} else
3389 		SPRINTF("no not yet issued commands\n");
3390 	DO_UNLOCK(flags);
3391 
3392 	if (CURRENT_SC) {
3393 		SPRINTF("current command:\n");
3394 		pos += get_command(pos, CURRENT_SC);
3395 	} else
3396 		SPRINTF("no current command\n");
3397 
3398 	if (DISCONNECTED_SC) {
3399 		SPRINTF("disconnected commands:\n");
3400 		for (ptr = DISCONNECTED_SC; ptr; ptr = SCNEXT(ptr))
3401 			pos += get_command(pos, ptr);
3402 	} else
3403 		SPRINTF("no disconnected commands\n");
3404 
3405 	pos += get_ports(shpnt, pos);
3406 
3407 #if defined(AHA152X_STAT)
3408 	SPRINTF("statistics:\n"
3409 	        "total commands:               %d\n"
3410 	        "disconnections:               %d\n"
3411 		"busfree with check condition: %d\n"
3412 		"busfree without old command:  %d\n"
3413 		"busfree without new command:  %d\n"
3414 		"busfree without done command: %d\n"
3415 		"busfree without any action:   %d\n"
3416 		"state      "
3417 		"transitions  "
3418 		"count        "
3419 		"time\n",
3420 		HOSTDATA(shpnt)->total_commands,
3421 		HOSTDATA(shpnt)->disconnections,
3422 		HOSTDATA(shpnt)->busfree_with_check_condition,
3423 		HOSTDATA(shpnt)->busfree_without_old_command,
3424 		HOSTDATA(shpnt)->busfree_without_new_command,
3425 		HOSTDATA(shpnt)->busfree_without_done_command,
3426 		HOSTDATA(shpnt)->busfree_without_any_action);
3427 	for(i=0; i<maxstate; i++) {
3428 		SPRINTF("%-10s %-12d %-12d %-12ld\n",
3429 		        states[i].name,
3430 			HOSTDATA(shpnt)->count_trans[i],
3431 			HOSTDATA(shpnt)->count[i],
3432 			HOSTDATA(shpnt)->time[i]);
3433 	}
3434 #endif
3435 
3436 	DPRINTK(debug_procinfo, KERN_DEBUG "aha152x_proc_info: pos=%p\n", pos);
3437 
3438 	thislength = pos - (buffer + offset);
3439 	DPRINTK(debug_procinfo, KERN_DEBUG "aha152x_proc_info: length=%d thislength=%d\n", length, thislength);
3440 
3441 	if(thislength<0) {
3442 		DPRINTK(debug_procinfo, KERN_DEBUG "aha152x_proc_info: output too short\n");
3443 		*start = NULL;
3444 		return 0;
3445 	}
3446 
3447 	thislength = thislength<length ? thislength : length;
3448 
3449 	DPRINTK(debug_procinfo, KERN_DEBUG "aha152x_proc_info: return %d\n", thislength);
3450 
3451 	*start = buffer + offset;
3452 	return thislength < length ? thislength : length;
3453 }
3454 
3455 static int aha152x_adjust_queue(struct scsi_device *device)
3456 {
3457 	blk_queue_bounce_limit(device->request_queue, BLK_BOUNCE_HIGH);
3458 	return 0;
3459 }
3460 
3461 static struct scsi_host_template aha152x_driver_template = {
3462 	.module				= THIS_MODULE,
3463 	.name				= AHA152X_REVID,
3464 	.proc_name			= "aha152x",
3465 	.proc_info			= aha152x_proc_info,
3466 	.queuecommand			= aha152x_queue,
3467 	.eh_abort_handler		= aha152x_abort,
3468 	.eh_device_reset_handler	= aha152x_device_reset,
3469 	.eh_bus_reset_handler		= aha152x_bus_reset,
3470 	.eh_host_reset_handler		= aha152x_host_reset,
3471 	.bios_param			= aha152x_biosparam,
3472 	.can_queue			= 1,
3473 	.this_id			= 7,
3474 	.sg_tablesize			= SG_ALL,
3475 	.cmd_per_lun			= 1,
3476 	.use_clustering			= DISABLE_CLUSTERING,
3477 	.slave_alloc			= aha152x_adjust_queue,
3478 };
3479 
3480 #if !defined(PCMCIA)
3481 static int setup_count;
3482 static struct aha152x_setup setup[2];
3483 
3484 /* possible i/o addresses for the AIC-6260; default first */
3485 static unsigned short ports[] = { 0x340, 0x140 };
3486 
3487 #if !defined(SKIP_BIOSTEST)
3488 /* possible locations for the Adaptec BIOS; defaults first */
3489 static unsigned int addresses[] =
3490 {
3491 	0xdc000,		/* default first */
3492 	0xc8000,
3493 	0xcc000,
3494 	0xd0000,
3495 	0xd4000,
3496 	0xd8000,
3497 	0xe0000,
3498 	0xeb800,		/* VTech Platinum SMP */
3499 	0xf0000,
3500 };
3501 
3502 /* signatures for various AIC-6[23]60 based controllers.
3503    The point in detecting signatures is to avoid useless and maybe
3504    harmful probes on ports. I'm not sure that all listed boards pass
3505    auto-configuration. For those which fail the BIOS signature is
3506    obsolete, because user intervention to supply the configuration is
3507    needed anyway.  May be an information whether or not the BIOS supports
3508    extended translation could be also useful here. */
3509 static struct signature {
3510 	unsigned char *signature;
3511 	int sig_offset;
3512 	int sig_length;
3513 } signatures[] =
3514 {
3515 	{ "Adaptec AHA-1520 BIOS",	0x102e, 21 },
3516 		/* Adaptec 152x */
3517 	{ "Adaptec AHA-1520B",		0x000b, 17 },
3518 		/* Adaptec 152x rev B */
3519 	{ "Adaptec AHA-1520B",		0x0026, 17 },
3520 		/* Iomega Jaz Jet ISA (AIC6370Q) */
3521 	{ "Adaptec ASW-B626 BIOS",	0x1029, 21 },
3522 		/* on-board controller */
3523 	{ "Adaptec BIOS: ASW-B626",	0x000f, 22 },
3524 		/* on-board controller */
3525 	{ "Adaptec ASW-B626 S2",	0x2e6c, 19 },
3526 		/* on-board controller */
3527 	{ "Adaptec BIOS:AIC-6360",	0x000c, 21 },
3528 		/* on-board controller */
3529 	{ "ScsiPro SP-360 BIOS",	0x2873, 19 },
3530 		/* ScsiPro-Controller  */
3531 	{ "GA-400 LOCAL BUS SCSI BIOS", 0x102e, 26 },
3532 		/* Gigabyte Local-Bus-SCSI */
3533 	{ "Adaptec BIOS:AVA-282X",	0x000c, 21 },
3534 		/* Adaptec 282x */
3535 	{ "Adaptec IBM Dock II SCSI",   0x2edd, 24 },
3536 		/* IBM Thinkpad Dock II */
3537 	{ "Adaptec BIOS:AHA-1532P",     0x001c, 22 },
3538 		/* IBM Thinkpad Dock II SCSI */
3539 	{ "DTC3520A Host Adapter BIOS", 0x318a, 26 },
3540 		/* DTC 3520A ISA SCSI */
3541 };
3542 #endif /* !SKIP_BIOSTEST */
3543 
3544 /*
3545  * Test, if port_base is valid.
3546  *
3547  */
3548 static int aha152x_porttest(int io_port)
3549 {
3550 	int i;
3551 
3552 	SETPORT(io_port + O_DMACNTRL1, 0);	/* reset stack pointer */
3553 	for (i = 0; i < 16; i++)
3554 		SETPORT(io_port + O_STACK, i);
3555 
3556 	SETPORT(io_port + O_DMACNTRL1, 0);	/* reset stack pointer */
3557 	for (i = 0; i < 16 && GETPORT(io_port + O_STACK) == i; i++)
3558 		;
3559 
3560 	return (i == 16);
3561 }
3562 
3563 static int tc1550_porttest(int io_port)
3564 {
3565 	int i;
3566 
3567 	SETPORT(io_port + O_TC_DMACNTRL1, 0);	/* reset stack pointer */
3568 	for (i = 0; i < 16; i++)
3569 		SETPORT(io_port + O_STACK, i);
3570 
3571 	SETPORT(io_port + O_TC_DMACNTRL1, 0);	/* reset stack pointer */
3572 	for (i = 0; i < 16 && GETPORT(io_port + O_TC_STACK) == i; i++)
3573 		;
3574 
3575 	return (i == 16);
3576 }
3577 
3578 
3579 static int checksetup(struct aha152x_setup *setup)
3580 {
3581 	int i;
3582 	for (i = 0; i < ARRAY_SIZE(ports) && (setup->io_port != ports[i]); i++)
3583 		;
3584 
3585 	if (i == ARRAY_SIZE(ports))
3586 		return 0;
3587 
3588 	if (!request_region(setup->io_port, IO_RANGE, "aha152x")) {
3589 		printk(KERN_ERR "aha152x: io port 0x%x busy.\n", setup->io_port);
3590 		return 0;
3591 	}
3592 
3593 	if( aha152x_porttest(setup->io_port) ) {
3594 		setup->tc1550=0;
3595 	} else if( tc1550_porttest(setup->io_port) ) {
3596 		setup->tc1550=1;
3597 	} else {
3598 		release_region(setup->io_port, IO_RANGE);
3599 		return 0;
3600 	}
3601 
3602 	release_region(setup->io_port, IO_RANGE);
3603 
3604 	if ((setup->irq < IRQ_MIN) || (setup->irq > IRQ_MAX))
3605 		return 0;
3606 
3607 	if ((setup->scsiid < 0) || (setup->scsiid > 7))
3608 		return 0;
3609 
3610 	if ((setup->reconnect < 0) || (setup->reconnect > 1))
3611 		return 0;
3612 
3613 	if ((setup->parity < 0) || (setup->parity > 1))
3614 		return 0;
3615 
3616 	if ((setup->synchronous < 0) || (setup->synchronous > 1))
3617 		return 0;
3618 
3619 	if ((setup->ext_trans < 0) || (setup->ext_trans > 1))
3620 		return 0;
3621 
3622 
3623 	return 1;
3624 }
3625 
3626 
3627 static int __init aha152x_init(void)
3628 {
3629 	int i, j, ok;
3630 #if defined(AUTOCONF)
3631 	aha152x_config conf;
3632 #endif
3633 #ifdef __ISAPNP__
3634 	struct pnp_dev *dev=NULL, *pnpdev[2] = {NULL, NULL};
3635 #endif
3636 
3637 	if ( setup_count ) {
3638 		printk(KERN_INFO "aha152x: processing commandline: ");
3639 
3640 		for (i = 0; i<setup_count; i++) {
3641 			if (!checksetup(&setup[i])) {
3642 				printk(KERN_ERR "\naha152x: %s\n", setup[i].conf);
3643 				printk(KERN_ERR "aha152x: invalid line\n");
3644 			}
3645 		}
3646 		printk("ok\n");
3647 	}
3648 
3649 #if defined(SETUP0)
3650 	if (setup_count < ARRAY_SIZE(setup)) {
3651 		struct aha152x_setup override = SETUP0;
3652 
3653 		if (setup_count == 0 || (override.io_port != setup[0].io_port)) {
3654 			if (!checksetup(&override)) {
3655 				printk(KERN_ERR "\naha152x: invalid override SETUP0={0x%x,%d,%d,%d,%d,%d,%d,%d}\n",
3656 				       override.io_port,
3657 				       override.irq,
3658 				       override.scsiid,
3659 				       override.reconnect,
3660 				       override.parity,
3661 				       override.synchronous,
3662 				       override.delay,
3663 				       override.ext_trans);
3664 			} else
3665 				setup[setup_count++] = override;
3666 		}
3667 	}
3668 #endif
3669 
3670 #if defined(SETUP1)
3671 	if (setup_count < ARRAY_SIZE(setup)) {
3672 		struct aha152x_setup override = SETUP1;
3673 
3674 		if (setup_count == 0 || (override.io_port != setup[0].io_port)) {
3675 			if (!checksetup(&override)) {
3676 				printk(KERN_ERR "\naha152x: invalid override SETUP1={0x%x,%d,%d,%d,%d,%d,%d,%d}\n",
3677 				       override.io_port,
3678 				       override.irq,
3679 				       override.scsiid,
3680 				       override.reconnect,
3681 				       override.parity,
3682 				       override.synchronous,
3683 				       override.delay,
3684 				       override.ext_trans);
3685 			} else
3686 				setup[setup_count++] = override;
3687 		}
3688 	}
3689 #endif
3690 
3691 #if defined(MODULE)
3692 	if (setup_count<ARRAY_SIZE(setup) && (aha152x[0]!=0 || io[0]!=0 || irq[0]!=0)) {
3693 		if(aha152x[0]!=0) {
3694 			setup[setup_count].conf        = "";
3695 			setup[setup_count].io_port     = aha152x[0];
3696 			setup[setup_count].irq         = aha152x[1];
3697 			setup[setup_count].scsiid      = aha152x[2];
3698 			setup[setup_count].reconnect   = aha152x[3];
3699 			setup[setup_count].parity      = aha152x[4];
3700 			setup[setup_count].synchronous = aha152x[5];
3701 			setup[setup_count].delay       = aha152x[6];
3702 			setup[setup_count].ext_trans   = aha152x[7];
3703 #if defined(AHA152X_DEBUG)
3704 			setup[setup_count].debug       = aha152x[8];
3705 #endif
3706 	  	} else if(io[0]!=0 || irq[0]!=0) {
3707 			if(io[0]!=0)  setup[setup_count].io_port = io[0];
3708 			if(irq[0]!=0) setup[setup_count].irq     = irq[0];
3709 
3710 	    		setup[setup_count].scsiid      = scsiid[0];
3711 	    		setup[setup_count].reconnect   = reconnect[0];
3712 	    		setup[setup_count].parity      = parity[0];
3713 	    		setup[setup_count].synchronous = sync[0];
3714 	    		setup[setup_count].delay       = delay[0];
3715 	    		setup[setup_count].ext_trans   = exttrans[0];
3716 #if defined(AHA152X_DEBUG)
3717 			setup[setup_count].debug       = debug[0];
3718 #endif
3719 		}
3720 
3721           	if (checksetup(&setup[setup_count]))
3722 			setup_count++;
3723 		else
3724 			printk(KERN_ERR "aha152x: invalid module params io=0x%x, irq=%d,scsiid=%d,reconnect=%d,parity=%d,sync=%d,delay=%d,exttrans=%d\n",
3725 			       setup[setup_count].io_port,
3726 			       setup[setup_count].irq,
3727 			       setup[setup_count].scsiid,
3728 			       setup[setup_count].reconnect,
3729 			       setup[setup_count].parity,
3730 			       setup[setup_count].synchronous,
3731 			       setup[setup_count].delay,
3732 			       setup[setup_count].ext_trans);
3733 	}
3734 
3735 	if (setup_count<ARRAY_SIZE(setup) && (aha152x1[0]!=0 || io[1]!=0 || irq[1]!=0)) {
3736 		if(aha152x1[0]!=0) {
3737 			setup[setup_count].conf        = "";
3738 			setup[setup_count].io_port     = aha152x1[0];
3739 			setup[setup_count].irq         = aha152x1[1];
3740 			setup[setup_count].scsiid      = aha152x1[2];
3741 			setup[setup_count].reconnect   = aha152x1[3];
3742 			setup[setup_count].parity      = aha152x1[4];
3743 			setup[setup_count].synchronous = aha152x1[5];
3744 			setup[setup_count].delay       = aha152x1[6];
3745 			setup[setup_count].ext_trans   = aha152x1[7];
3746 #if defined(AHA152X_DEBUG)
3747 			setup[setup_count].debug       = aha152x1[8];
3748 #endif
3749 	  	} else if(io[1]!=0 || irq[1]!=0) {
3750 			if(io[1]!=0)  setup[setup_count].io_port = io[1];
3751 			if(irq[1]!=0) setup[setup_count].irq     = irq[1];
3752 
3753 	    		setup[setup_count].scsiid      = scsiid[1];
3754 	    		setup[setup_count].reconnect   = reconnect[1];
3755 	    		setup[setup_count].parity      = parity[1];
3756 	    		setup[setup_count].synchronous = sync[1];
3757 	    		setup[setup_count].delay       = delay[1];
3758 	    		setup[setup_count].ext_trans   = exttrans[1];
3759 #if defined(AHA152X_DEBUG)
3760 			setup[setup_count].debug       = debug[1];
3761 #endif
3762 		}
3763 		if (checksetup(&setup[setup_count]))
3764 			setup_count++;
3765 		else
3766 			printk(KERN_ERR "aha152x: invalid module params io=0x%x, irq=%d,scsiid=%d,reconnect=%d,parity=%d,sync=%d,delay=%d,exttrans=%d\n",
3767 			       setup[setup_count].io_port,
3768 			       setup[setup_count].irq,
3769 			       setup[setup_count].scsiid,
3770 			       setup[setup_count].reconnect,
3771 			       setup[setup_count].parity,
3772 			       setup[setup_count].synchronous,
3773 			       setup[setup_count].delay,
3774 			       setup[setup_count].ext_trans);
3775 	}
3776 #endif
3777 
3778 #ifdef __ISAPNP__
3779 	for(i=0; setup_count<ARRAY_SIZE(setup) && id_table[i].vendor; i++) {
3780 		while ( setup_count<ARRAY_SIZE(setup) &&
3781 			(dev=pnp_find_dev(NULL, id_table[i].vendor, id_table[i].function, dev)) ) {
3782 			if (pnp_device_attach(dev) < 0)
3783 				continue;
3784 
3785 			if (pnp_activate_dev(dev) < 0) {
3786 				pnp_device_detach(dev);
3787 				continue;
3788 			}
3789 
3790 			if (!pnp_port_valid(dev, 0)) {
3791 				pnp_device_detach(dev);
3792 				continue;
3793 			}
3794 
3795 			if (setup_count==1 && pnp_port_start(dev, 0)==setup[0].io_port) {
3796 				pnp_device_detach(dev);
3797 				continue;
3798 			}
3799 
3800 			setup[setup_count].io_port     = pnp_port_start(dev, 0);
3801 			setup[setup_count].irq         = pnp_irq(dev, 0);
3802 			setup[setup_count].scsiid      = 7;
3803 			setup[setup_count].reconnect   = 1;
3804 			setup[setup_count].parity      = 1;
3805 			setup[setup_count].synchronous = 1;
3806 			setup[setup_count].delay       = DELAY_DEFAULT;
3807 			setup[setup_count].ext_trans   = 0;
3808 #if defined(AHA152X_DEBUG)
3809 			setup[setup_count].debug       = DEBUG_DEFAULT;
3810 #endif
3811 #if defined(__ISAPNP__)
3812 			pnpdev[setup_count]            = dev;
3813 #endif
3814 			printk (KERN_INFO
3815 				"aha152x: found ISAPnP adapter at io=0x%03x, irq=%d\n",
3816 				setup[setup_count].io_port, setup[setup_count].irq);
3817 			setup_count++;
3818 		}
3819 	}
3820 #endif
3821 
3822 #if defined(AUTOCONF)
3823 	if (setup_count<ARRAY_SIZE(setup)) {
3824 #if !defined(SKIP_BIOSTEST)
3825 		ok = 0;
3826 		for (i = 0; i < ARRAY_SIZE(addresses) && !ok; i++) {
3827 			void __iomem *p = ioremap(addresses[i], 0x4000);
3828 			if (!p)
3829 				continue;
3830 			for (j = 0; j<ARRAY_SIZE(signatures) && !ok; j++)
3831 				ok = check_signature(p + signatures[j].sig_offset,
3832 								signatures[j].signature, signatures[j].sig_length);
3833 			iounmap(p);
3834 		}
3835 		if (!ok && setup_count == 0)
3836 			return -ENODEV;
3837 
3838 		printk(KERN_INFO "aha152x: BIOS test: passed, ");
3839 #else
3840 		printk(KERN_INFO "aha152x: ");
3841 #endif				/* !SKIP_BIOSTEST */
3842 
3843 		ok = 0;
3844 		for (i = 0; i < ARRAY_SIZE(ports) && setup_count < 2; i++) {
3845 			if ((setup_count == 1) && (setup[0].io_port == ports[i]))
3846 				continue;
3847 
3848 			if (!request_region(ports[i], IO_RANGE, "aha152x")) {
3849 				printk(KERN_ERR "aha152x: io port 0x%x busy.\n", ports[i]);
3850 				continue;
3851 			}
3852 
3853 			if (aha152x_porttest(ports[i])) {
3854 				setup[setup_count].tc1550  = 0;
3855 
3856 				conf.cf_port =
3857 				    (GETPORT(ports[i] + O_PORTA) << 8) + GETPORT(ports[i] + O_PORTB);
3858 			} else if (tc1550_porttest(ports[i])) {
3859 				setup[setup_count].tc1550  = 1;
3860 
3861 				conf.cf_port =
3862 				    (GETPORT(ports[i] + O_TC_PORTA) << 8) + GETPORT(ports[i] + O_TC_PORTB);
3863 			} else {
3864 				release_region(ports[i], IO_RANGE);
3865 				continue;
3866 			}
3867 
3868 			release_region(ports[i], IO_RANGE);
3869 
3870 			ok++;
3871 			setup[setup_count].io_port = ports[i];
3872 			setup[setup_count].irq = IRQ_MIN + conf.cf_irq;
3873 			setup[setup_count].scsiid = conf.cf_id;
3874 			setup[setup_count].reconnect = conf.cf_tardisc;
3875 			setup[setup_count].parity = !conf.cf_parity;
3876 			setup[setup_count].synchronous = conf.cf_syncneg;
3877 			setup[setup_count].delay = DELAY_DEFAULT;
3878 			setup[setup_count].ext_trans = 0;
3879 #if defined(AHA152X_DEBUG)
3880 			setup[setup_count].debug = DEBUG_DEFAULT;
3881 #endif
3882 			setup_count++;
3883 
3884 		}
3885 
3886 		if (ok)
3887 			printk("auto configuration: ok, ");
3888 	}
3889 #endif
3890 
3891 	printk("%d controller(s) configured\n", setup_count);
3892 
3893 	for (i=0; i<setup_count; i++) {
3894 		if ( request_region(setup[i].io_port, IO_RANGE, "aha152x") ) {
3895 			struct Scsi_Host *shpnt = aha152x_probe_one(&setup[i]);
3896 
3897 			if( !shpnt ) {
3898 				release_region(setup[i].io_port, IO_RANGE);
3899 #if defined(__ISAPNP__)
3900 			} else if( pnpdev[i] ) {
3901 				HOSTDATA(shpnt)->pnpdev=pnpdev[i];
3902 				pnpdev[i]=NULL;
3903 #endif
3904 			}
3905 		} else {
3906 			printk(KERN_ERR "aha152x: io port 0x%x busy.\n", setup[i].io_port);
3907 		}
3908 
3909 #if defined(__ISAPNP__)
3910 		if( pnpdev[i] )
3911 			pnp_device_detach(pnpdev[i]);
3912 #endif
3913 	}
3914 
3915 	return 0;
3916 }
3917 
3918 static void __exit aha152x_exit(void)
3919 {
3920 	struct aha152x_hostdata *hd, *tmp;
3921 
3922 	list_for_each_entry_safe(hd, tmp, &aha152x_host_list, host_list) {
3923 		struct Scsi_Host *shost = container_of((void *)hd, struct Scsi_Host, hostdata);
3924 
3925 		aha152x_release(shost);
3926 	}
3927 }
3928 
3929 module_init(aha152x_init);
3930 module_exit(aha152x_exit);
3931 
3932 #if !defined(MODULE)
3933 static int __init aha152x_setup(char *str)
3934 {
3935 #if defined(AHA152X_DEBUG)
3936 	int ints[11];
3937 #else
3938 	int ints[10];
3939 #endif
3940 	get_options(str, ARRAY_SIZE(ints), ints);
3941 
3942 	if(setup_count>=ARRAY_SIZE(setup)) {
3943 		printk(KERN_ERR "aha152x: you can only configure up to two controllers\n");
3944 		return 1;
3945 	}
3946 
3947 	setup[setup_count].conf        = str;
3948 	setup[setup_count].io_port     = ints[0] >= 1 ? ints[1] : 0x340;
3949 	setup[setup_count].irq         = ints[0] >= 2 ? ints[2] : 11;
3950 	setup[setup_count].scsiid      = ints[0] >= 3 ? ints[3] : 7;
3951 	setup[setup_count].reconnect   = ints[0] >= 4 ? ints[4] : 1;
3952 	setup[setup_count].parity      = ints[0] >= 5 ? ints[5] : 1;
3953 	setup[setup_count].synchronous = ints[0] >= 6 ? ints[6] : 1;
3954 	setup[setup_count].delay       = ints[0] >= 7 ? ints[7] : DELAY_DEFAULT;
3955 	setup[setup_count].ext_trans   = ints[0] >= 8 ? ints[8] : 0;
3956 #if defined(AHA152X_DEBUG)
3957 	setup[setup_count].debug       = ints[0] >= 9 ? ints[9] : DEBUG_DEFAULT;
3958 	if (ints[0] > 9) {
3959 		printk(KERN_NOTICE "aha152x: usage: aha152x=<IOBASE>[,<IRQ>[,<SCSI ID>"
3960 		       "[,<RECONNECT>[,<PARITY>[,<SYNCHRONOUS>[,<DELAY>[,<EXT_TRANS>[,<DEBUG>]]]]]]]]\n");
3961 #else
3962 	if (ints[0] > 8) {                                                /*}*/
3963 		printk(KERN_NOTICE "aha152x: usage: aha152x=<IOBASE>[,<IRQ>[,<SCSI ID>"
3964 		       "[,<RECONNECT>[,<PARITY>[,<SYNCHRONOUS>[,<DELAY>[,<EXT_TRANS>]]]]]]]\n");
3965 #endif
3966 	} else {
3967 		setup_count++;
3968 		return 0;
3969 	}
3970 
3971 	return 1;
3972 }
3973 __setup("aha152x=", aha152x_setup);
3974 #endif
3975 
3976 #endif /* !PCMCIA */
3977