drivers/scsi/aha152x.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /* aha152x.c -- Adaptec AHA-152x driver
0003  * Author: Jürgen E. Fischer, fischer@norbit.de
0004  * Copyright 1993-2004 Jürgen E. Fischer
0005  *
0006  * $Id: aha152x.c,v 2.7 2004/01/24 11:42:59 fischer Exp $
0007  *
0008  * $Log: aha152x.c,v $
0009  * Revision 2.7  2004/01/24 11:42:59  fischer
0010  * - gather code that is not used by PCMCIA at the end
0011  * - move request_region for !PCMCIA case to detection
0012  * - migration to new scsi host api (remove legacy code)
0013  * - free host scribble before scsi_done
0014  * - fix error handling
0015  * - one isapnp device added to id_table
0016  *
0017  * Revision 2.6  2003/10/30 20:52:47  fischer
0018  * - interfaces changes for kernel 2.6
0019  * - aha152x_probe_one introduced for pcmcia stub
0020  * - fixed pnpdev handling
0021  * - instead of allocation a new one, reuse command for request sense after check condition and reset
0022  * - fixes race in is_complete
0023  *
0024  * Revision 2.5  2002/04/14 11:24:53  fischer
0025  * - isapnp support
0026  * - abort fixed
0027  * - 2.5 support
0028  *
0029  * Revision 2.4  2000/12/16 12:53:56  fischer
0030  * - allow REQUEST SENSE to be queued
0031  * - handle shared PCI interrupts
0032  *
0033  * Revision 2.3  2000/11/04 16:40:26  fischer
0034  * - handle data overruns
0035  * - extend timeout for data phases
0036  *
0037  * Revision 2.2  2000/08/08 19:54:53  fischer
0038  * - minor changes
0039  *
0040  * Revision 2.1  2000/05/17 16:23:17  fischer
0041  * - signature update
0042  * - fix for data out w/o scatter gather
0043  *
0044  * Revision 2.0  1999/12/25 15:07:32  fischer
0045  * - interrupt routine completly reworked
0046  * - basic support for new eh code
0047  *
0048  * Revision 1.21  1999/11/10 23:46:36  fischer
0049  * - default to synchronous operation
0050  * - synchronous negotiation fixed
0051  * - added timeout to loops
0052  * - debugging output can be controlled through procfs
0053  *
0054  * Revision 1.20  1999/11/07 18:37:31  fischer
0055  * - synchronous operation works
0056  * - resid support for sg driver
0057  *
0058  * Revision 1.19  1999/11/02 22:39:59  fischer
0059  * - moved leading comments to README.aha152x
0060  * - new additional module parameters
0061  * - updates for 2.3
0062  * - support for the Tripace TC1550 controller
0063  * - interrupt handling changed
0064  *
0065  * Revision 1.18  1996/09/07 20:10:40  fischer
0066  * - fixed can_queue handling (multiple outstanding commands working again)
0067  *
0068  * Revision 1.17  1996/08/17 16:05:14  fischer
0069  * - biosparam improved
0070  * - interrupt verification
0071  * - updated documentation
0072  * - cleanups
0073  *
0074  * Revision 1.16  1996/06/09 00:04:56  root
0075  * - added configuration symbols for insmod (aha152x/aha152x1)
0076  *
0077  * Revision 1.15  1996/04/30 14:52:06  fischer
0078  * - proc info fixed
0079  * - support for extended translation for >1GB disks
0080  *
0081  * Revision 1.14  1996/01/17  15:11:20  fischer
0082  * - fixed lockup in MESSAGE IN phase after reconnection
0083  *
0084  * Revision 1.13  1996/01/09  02:15:53  fischer
0085  * - some cleanups
0086  * - moved request_irq behind controller initialization
0087  *   (to avoid spurious interrupts)
0088  *
0089  * Revision 1.12  1995/12/16  12:26:07  fischer
0090  * - barrier()s added
0091  * - configurable RESET delay added
0092  *
0093  * Revision 1.11  1995/12/06  21:18:35  fischer
0094  * - some minor updates
0095  *
0096  * Revision 1.10  1995/07/22  19:18:45  fischer
0097  * - support for 2 controllers
0098  * - started synchronous data transfers (not working yet)
0099  *
0100  * Revision 1.9  1995/03/18  09:20:24  root
0101  * - patches for PCMCIA and modules
0102  *
0103  * Revision 1.8  1995/01/21  22:07:19  root
0104  * - snarf_region => request_region
0105  * - aha152x_intr interface change
0106  *
0107  * Revision 1.7  1995/01/02  23:19:36  root
0108  * - updated COMMAND_SIZE to cmd_len
0109  * - changed sti() to restore_flags()
0110  * - fixed some #ifdef which generated warnings
0111  *
0112  * Revision 1.6  1994/11/24  20:35:27  root
0113  * - problem with odd number of bytes in fifo fixed
0114  *
0115  * Revision 1.5  1994/10/30  14:39:56  root
0116  * - abort code fixed
0117  * - debugging improved
0118  *
0119  * Revision 1.4  1994/09/12  11:33:01  root
0120  * - irqaction to request_irq
0121  * - abortion updated
0122  *
0123  * Revision 1.3  1994/08/04  13:53:05  root
0124  * - updates for mid-level-driver changes
0125  * - accept unexpected BUSFREE phase as error condition
0126  * - parity check now configurable
0127  *
0128  * Revision 1.2  1994/07/03  12:56:36  root
0129  * - cleaned up debugging code
0130  * - more tweaking on reset delays
0131  * - updated abort/reset code (pretty untested...)
0132  *
0133  * Revision 1.1  1994/05/28  21:18:49  root
0134  * - update for mid-level interface change (abort-reset)
0135  * - delays after resets adjusted for some slow devices
0136  *
0137  * Revision 1.0  1994/03/25  12:52:00  root
0138  * - Fixed "more data than expected" problem
0139  * - added new BIOS signatures
0140  *
0141  * Revision 0.102  1994/01/31  20:44:12  root
0142  * - minor changes in insw/outsw handling
0143  *
0144  * Revision 0.101  1993/12/13  01:16:27  root
0145  * - fixed STATUS phase (non-GOOD stati were dropped sometimes;
0146  *   fixes problems with CD-ROM sector size detection & media change)
0147  *
0148  * Revision 0.100  1993/12/10  16:58:47  root
0149  * - fix for unsuccessful selections in case of non-continuous id assignments
0150  *   on the scsi bus.
0151  *
0152  * Revision 0.99  1993/10/24  16:19:59  root
0153  * - fixed DATA IN (rare read errors gone)
0154  *
0155  * Revision 0.98  1993/10/17  12:54:44  root
0156  * - fixed some recent fixes (shame on me)
0157  * - moved initialization of scratch area to aha152x_queue
0158  *
0159  * Revision 0.97  1993/10/09  18:53:53  root
0160  * - DATA IN fixed. Rarely left data in the fifo.
0161  *
0162  * Revision 0.96  1993/10/03  00:53:59  root
0163  * - minor changes on DATA IN
0164  *
0165  * Revision 0.95  1993/09/24  10:36:01  root
0166  * - change handling of MSGI after reselection
0167  * - fixed sti/cli
0168  * - minor changes
0169  *
0170  * Revision 0.94  1993/09/18  14:08:22  root
0171  * - fixed bug in multiple outstanding command code
0172  * - changed detection
0173  * - support for kernel command line configuration
0174  * - reset corrected
0175  * - changed message handling
0176  *
0177  * Revision 0.93  1993/09/15  20:41:19  root
0178  * - fixed bugs with multiple outstanding commands
0179  *
0180  * Revision 0.92  1993/09/13  02:46:33  root
0181  * - multiple outstanding commands work (no problems with IBM drive)
0182  *
0183  * Revision 0.91  1993/09/12  20:51:46  root
0184  * added multiple outstanding commands
0185  * (some problem with this $%&? IBM device remain)
0186  *
0187  * Revision 0.9  1993/09/12  11:11:22  root
0188  * - corrected auto-configuration
0189  * - changed the auto-configuration (added some '#define's)
0190  * - added support for dis-/reconnection
0191  *
0192  * Revision 0.8  1993/09/06  23:09:39  root
0193  * - added support for the drive activity light
0194  * - minor changes
0195  *
0196  * Revision 0.7  1993/09/05  14:30:15  root
0197  * - improved phase detection
0198  * - now using the new snarf_region code of 0.99pl13
0199  *
0200  * Revision 0.6  1993/09/02  11:01:38  root
0201  * first public release; added some signatures and biosparam()
0202  *
0203  * Revision 0.5  1993/08/30  10:23:30  root
0204  * fixed timing problems with my IBM drive
0205  *
0206  * Revision 0.4  1993/08/29  14:06:52  root
0207  * fixed some problems with timeouts due incomplete commands
0208  *
0209  * Revision 0.3  1993/08/28  15:55:03  root
0210  * writing data works too.  mounted and worked on a dos partition
0211  *
0212  * Revision 0.2  1993/08/27  22:42:07  root
0213  * reading data works.  Mounted a msdos partition.
0214  *
0215  * Revision 0.1  1993/08/25  13:38:30  root
0216  * first "damn thing doesn't work" version
0217  *
0218  * Revision 0.0  1993/08/14  19:54:25  root
0219  * empty function bodies; detect() works.
0220  *
0221  **************************************************************************
0222
0223  see Documentation/scsi/aha152x.rst for configuration details
0224
0225  **************************************************************************/
0226
0227 #include <linux/module.h>
0228 #include <asm/irq.h>
0229 #include <linux/io.h>
0230 #include <linux/blkdev.h>
0231 #include <linux/completion.h>
0232 #include <linux/errno.h>
0233 #include <linux/string.h>
0234 #include <linux/wait.h>
0235 #include <linux/ioport.h>
0236 #include <linux/delay.h>
0237 #include <linux/proc_fs.h>
0238 #include <linux/interrupt.h>
0239 #include <linux/init.h>
0240 #include <linux/kernel.h>
0241 #include <linux/isapnp.h>
0242 #include <linux/spinlock.h>
0243 #include <linux/workqueue.h>
0244 #include <linux/list.h>
0245 #include <linux/slab.h>
0246
0247 #include <scsi/scsi.h>
0248 #include <scsi/scsi_cmnd.h>
0249 #include <scsi/scsi_dbg.h>
0250 #include <scsi/scsi_device.h>
0251 #include <scsi/scsi_eh.h>
0252 #include <scsi/scsi_host.h>
0253 #include <scsi/scsi_tcq.h>
0254 #include <scsi/scsi_transport_spi.h>
0255 #include <scsi/scsicam.h>
0256 #include "aha152x.h"
0257
0258 static LIST_HEAD(aha152x_host_list);
0259
0260
0261 /* DEFINES */
0262
0263 /* For PCMCIA cards, always use AUTOCONF */
0264 #if defined(AHA152X_PCMCIA) || defined(MODULE)
0265 #if !defined(AUTOCONF)
0266 #define AUTOCONF
0267 #endif
0268 #endif
0269
0270 #if !defined(AUTOCONF) && !defined(SETUP0)
0271 #error define AUTOCONF or SETUP0
0272 #endif
0273
0274 #define DO_LOCK(flags)      spin_lock_irqsave(&QLOCK,flags)
0275 #define DO_UNLOCK(flags)    spin_unlock_irqrestore(&QLOCK,flags)
0276
0277 #define LEAD        "(scsi%d:%d:%d) "
0278 #define INFO_LEAD   KERN_INFO   LEAD
0279 #define CMDINFO(cmd) \
0280             (cmd) ? ((cmd)->device->host->host_no) : -1, \
0281                         (cmd) ? ((cmd)->device->id & 0x0f) : -1, \
0282             (cmd) ? ((u8)(cmd)->device->lun & 0x07) : -1
0283
0284 static inline void
0285 CMD_INC_RESID(struct scsi_cmnd *cmd, int inc)
0286 {
0287     scsi_set_resid(cmd, scsi_get_resid(cmd) + inc);
0288 }
0289
0290 #define DELAY_DEFAULT 1000
0291
0292 #if defined(AHA152X_PCMCIA)
0293 #define IRQ_MIN 0
0294 #define IRQ_MAX 16
0295 #else
0296 #define IRQ_MIN 9
0297 #if defined(__PPC)
0298 #define IRQ_MAX (nr_irqs-1)
0299 #else
0300 #define IRQ_MAX 12
0301 #endif
0302 #endif
0303
0304 enum {
0305     not_issued  = 0x0001,   /* command not yet issued */
0306     selecting   = 0x0002,   /* target is being selected */
0307     identified  = 0x0004,   /* IDENTIFY was sent */
0308     disconnected    = 0x0008,   /* target disconnected */
0309     completed   = 0x0010,   /* target sent COMMAND COMPLETE */
0310     aborted     = 0x0020,   /* ABORT was sent */
0311     resetted    = 0x0040,   /* BUS DEVICE RESET was sent */
0312     spiordy     = 0x0080,   /* waiting for SPIORDY to raise */
0313     syncneg     = 0x0100,   /* synchronous negotiation in progress */
0314     aborting    = 0x0200,   /* ABORT is pending */
0315     resetting   = 0x0400,   /* BUS DEVICE RESET is pending */
0316     check_condition = 0x0800,   /* requesting sense after CHECK CONDITION */
0317 };
0318
0319 struct aha152x_cmd_priv {
0320     char *ptr;
0321     int this_residual;
0322     struct scatterlist *buffer;
0323     int status;
0324     int message;
0325     int sent_command;
0326     int phase;
0327 };
0328
0329 static struct aha152x_cmd_priv *aha152x_priv(struct scsi_cmnd *cmd)
0330 {
0331     return scsi_cmd_priv(cmd);
0332 }
0333
0334 MODULE_AUTHOR("Jürgen Fischer");
0335 MODULE_DESCRIPTION(AHA152X_REVID);
0336 MODULE_LICENSE("GPL");
0337
0338 #if !defined(AHA152X_PCMCIA)
0339 #if defined(MODULE)
0340 static int io[] = {0, 0};
0341 module_param_hw_array(io, int, ioport, NULL, 0);
0342 MODULE_PARM_DESC(io,"base io address of controller");
0343
0344 static int irq[] = {0, 0};
0345 module_param_hw_array(irq, int, irq, NULL, 0);
0346 MODULE_PARM_DESC(irq,"interrupt for controller");
0347
0348 static int scsiid[] = {7, 7};
0349 module_param_array(scsiid, int, NULL, 0);
0350 MODULE_PARM_DESC(scsiid,"scsi id of controller");
0351
0352 static int reconnect[] = {1, 1};
0353 module_param_array(reconnect, int, NULL, 0);
0354 MODULE_PARM_DESC(reconnect,"allow targets to disconnect");
0355
0356 static int parity[] = {1, 1};
0357 module_param_array(parity, int, NULL, 0);
0358 MODULE_PARM_DESC(parity,"use scsi parity");
0359
0360 static int sync[] = {1, 1};
0361 module_param_array(sync, int, NULL, 0);
0362 MODULE_PARM_DESC(sync,"use synchronous transfers");
0363
0364 static int delay[] = {DELAY_DEFAULT, DELAY_DEFAULT};
0365 module_param_array(delay, int, NULL, 0);
0366 MODULE_PARM_DESC(delay,"scsi reset delay");
0367
0368 static int exttrans[] = {0, 0};
0369 module_param_array(exttrans, int, NULL, 0);
0370 MODULE_PARM_DESC(exttrans,"use extended translation");
0371
0372 static int aha152x[] = {0, 11, 7, 1, 1, 0, DELAY_DEFAULT, 0};
0373 module_param_array(aha152x, int, NULL, 0);
0374 MODULE_PARM_DESC(aha152x, "parameters for first controller");
0375
0376 static int aha152x1[] = {0, 11, 7, 1, 1, 0, DELAY_DEFAULT, 0};
0377 module_param_array(aha152x1, int, NULL, 0);
0378 MODULE_PARM_DESC(aha152x1, "parameters for second controller");
0379 #endif /* MODULE */
0380
0381 #ifdef __ISAPNP__
0382 static struct isapnp_device_id id_table[] = {
0383     { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1502), 0 },
0384     { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1505), 0 },
0385     { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1510), 0 },
0386     { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1515), 0 },
0387     { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1520), 0 },
0388     { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x2015), 0 },
0389     { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1522), 0 },
0390     { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x2215), 0 },
0391     { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1530), 0 },
0392     { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x3015), 0 },
0393     { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1532), 0 },
0394     { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x3215), 0 },
0395     { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x6360), 0 },
0396     { ISAPNP_DEVICE_SINGLE_END, }
0397 };
0398 MODULE_DEVICE_TABLE(isapnp, id_table);
0399 #endif /* ISAPNP */
0400
0401 #endif /* !AHA152X_PCMCIA */
0402
0403 static struct scsi_host_template aha152x_driver_template;
0404
0405 /*
0406  * internal states of the host
0407  *
0408  */
0409 enum aha152x_state {
0410     idle=0,
0411     unknown,
0412     seldo,
0413     seldi,
0414     selto,
0415     busfree,
0416     msgo,
0417     cmd,
0418     msgi,
0419     status,
0420     datai,
0421     datao,
0422     parerr,
0423     rsti,
0424     maxstate
0425 };
0426
0427 /*
0428  * current state information of the host
0429  *
0430  */
0431 struct aha152x_hostdata {
0432     struct scsi_cmnd *issue_SC;
0433         /* pending commands to issue */
0434
0435     struct scsi_cmnd *current_SC;
0436         /* current command on the bus */
0437
0438     struct scsi_cmnd *disconnected_SC;
0439         /* commands that disconnected */
0440
0441     struct scsi_cmnd *done_SC;
0442         /* command that was completed */
0443
0444     spinlock_t lock;
0445         /* host lock */
0446
0447 #if defined(AHA152X_STAT)
0448     int       total_commands;
0449     int       disconnections;
0450     int       busfree_without_any_action;
0451     int       busfree_without_old_command;
0452     int       busfree_without_new_command;
0453     int       busfree_without_done_command;
0454     int       busfree_with_check_condition;
0455     int       count[maxstate];
0456     int       count_trans[maxstate];
0457     unsigned long time[maxstate];
0458 #endif
0459
0460     int commands;       /* current number of commands */
0461
0462     int reconnect;      /* disconnection allowed */
0463     int parity;     /* parity checking enabled */
0464     int synchronous;    /* synchronous transferes enabled */
0465     int delay;      /* reset out delay */
0466     int ext_trans;      /* extended translation enabled */
0467
0468     int swint;      /* software-interrupt was fired during detect() */
0469     int service;        /* bh needs to be run */
0470     int in_intr;        /* bh is running */
0471
0472     /* current state,
0473        previous state,
0474        last state different from current state */
0475     enum aha152x_state state, prevstate, laststate;
0476
0477     int target;
0478         /* reconnecting target */
0479
0480     unsigned char syncrate[8];
0481         /* current synchronous transfer agreements */
0482
0483     unsigned char syncneg[8];
0484         /* 0: no negotiation;
0485          * 1: negotiation in progress;
0486          * 2: negotiation completed
0487          */
0488
0489     int cmd_i;
0490         /* number of sent bytes of current command */
0491
0492     int msgi_len;
0493         /* number of received message bytes */
0494     unsigned char msgi[256];
0495         /* received message bytes */
0496
0497     int msgo_i, msgo_len;
0498         /* number of sent bytes and length of current messages */
0499     unsigned char msgo[256];
0500         /* pending messages */
0501
0502     int data_len;
0503         /* number of sent/received bytes in dataphase */
0504
0505     unsigned long io_port0;
0506     unsigned long io_port1;
0507
0508 #ifdef __ISAPNP__
0509     struct pnp_dev *pnpdev;
0510 #endif
0511     struct list_head host_list;
0512 };
0513
0514
0515 /*
0516  * host specific command extension
0517  *
0518  */
0519 struct aha152x_scdata {
0520     struct scsi_cmnd *next; /* next sc in queue */
0521     struct completion *done;/* semaphore to block on */
0522     struct scsi_eh_save ses;
0523 };
0524
0525 /* access macros for hostdata */
0526
0527 #define HOSTDATA(shpnt)     ((struct aha152x_hostdata *) &shpnt->hostdata)
0528
0529 #define HOSTNO          ((shpnt)->host_no)
0530
0531 #define CURRENT_SC      (HOSTDATA(shpnt)->current_SC)
0532 #define DONE_SC         (HOSTDATA(shpnt)->done_SC)
0533 #define ISSUE_SC        (HOSTDATA(shpnt)->issue_SC)
0534 #define DISCONNECTED_SC     (HOSTDATA(shpnt)->disconnected_SC)
0535 #define QLOCK           (HOSTDATA(shpnt)->lock)
0536 #define QLOCKER         (HOSTDATA(shpnt)->locker)
0537 #define QLOCKERL        (HOSTDATA(shpnt)->lockerl)
0538
0539 #define STATE           (HOSTDATA(shpnt)->state)
0540 #define PREVSTATE       (HOSTDATA(shpnt)->prevstate)
0541 #define LASTSTATE       (HOSTDATA(shpnt)->laststate)
0542
0543 #define RECONN_TARGET       (HOSTDATA(shpnt)->target)
0544
0545 #define CMD_I           (HOSTDATA(shpnt)->cmd_i)
0546
0547 #define MSGO(i)         (HOSTDATA(shpnt)->msgo[i])
0548 #define MSGO_I          (HOSTDATA(shpnt)->msgo_i)
0549 #define MSGOLEN         (HOSTDATA(shpnt)->msgo_len)
0550 #define ADDMSGO(x)      (MSGOLEN<256 ? (void)(MSGO(MSGOLEN++)=x) : aha152x_error(shpnt,"MSGO overflow"))
0551
0552 #define MSGI(i)         (HOSTDATA(shpnt)->msgi[i])
0553 #define MSGILEN         (HOSTDATA(shpnt)->msgi_len)
0554 #define ADDMSGI(x)      (MSGILEN<256 ? (void)(MSGI(MSGILEN++)=x) : aha152x_error(shpnt,"MSGI overflow"))
0555
0556 #define DATA_LEN        (HOSTDATA(shpnt)->data_len)
0557
0558 #define SYNCRATE        (HOSTDATA(shpnt)->syncrate[CURRENT_SC->device->id])
0559 #define SYNCNEG         (HOSTDATA(shpnt)->syncneg[CURRENT_SC->device->id])
0560
0561 #define DELAY           (HOSTDATA(shpnt)->delay)
0562 #define EXT_TRANS       (HOSTDATA(shpnt)->ext_trans)
0563 #define TC1550          (HOSTDATA(shpnt)->tc1550)
0564 #define RECONNECT       (HOSTDATA(shpnt)->reconnect)
0565 #define PARITY          (HOSTDATA(shpnt)->parity)
0566 #define SYNCHRONOUS     (HOSTDATA(shpnt)->synchronous)
0567
0568 #define HOSTIOPORT0     (HOSTDATA(shpnt)->io_port0)
0569 #define HOSTIOPORT1     (HOSTDATA(shpnt)->io_port1)
0570
0571 #define SCDATA(SCpnt)       ((struct aha152x_scdata *) (SCpnt)->host_scribble)
0572 #define SCNEXT(SCpnt)       SCDATA(SCpnt)->next
0573 #define SCSEM(SCpnt)        SCDATA(SCpnt)->done
0574
0575 #define SG_ADDRESS(buffer)  ((char *) sg_virt((buffer)))
0576
0577 /* state handling */
0578 static void seldi_run(struct Scsi_Host *shpnt);
0579 static void seldo_run(struct Scsi_Host *shpnt);
0580 static void selto_run(struct Scsi_Host *shpnt);
0581 static void busfree_run(struct Scsi_Host *shpnt);
0582
0583 static void msgo_init(struct Scsi_Host *shpnt);
0584 static void msgo_run(struct Scsi_Host *shpnt);
0585 static void msgo_end(struct Scsi_Host *shpnt);
0586
0587 static void cmd_init(struct Scsi_Host *shpnt);
0588 static void cmd_run(struct Scsi_Host *shpnt);
0589 static void cmd_end(struct Scsi_Host *shpnt);
0590
0591 static void datai_init(struct Scsi_Host *shpnt);
0592 static void datai_run(struct Scsi_Host *shpnt);
0593 static void datai_end(struct Scsi_Host *shpnt);
0594
0595 static void datao_init(struct Scsi_Host *shpnt);
0596 static void datao_run(struct Scsi_Host *shpnt);
0597 static void datao_end(struct Scsi_Host *shpnt);
0598
0599 static void status_run(struct Scsi_Host *shpnt);
0600
0601 static void msgi_run(struct Scsi_Host *shpnt);
0602 static void msgi_end(struct Scsi_Host *shpnt);
0603
0604 static void parerr_run(struct Scsi_Host *shpnt);
0605 static void rsti_run(struct Scsi_Host *shpnt);
0606
0607 static void is_complete(struct Scsi_Host *shpnt);
0608
0609 /*
0610  * driver states
0611  *
0612  */
0613 static struct {
0614     char        *name;
0615     void        (*init)(struct Scsi_Host *);
0616     void        (*run)(struct Scsi_Host *);
0617     void        (*end)(struct Scsi_Host *);
0618     int     spio;
0619 } states[] = {
0620     { "idle",   NULL,       NULL,       NULL,       0},
0621     { "unknown",    NULL,       NULL,       NULL,       0},
0622     { "seldo",  NULL,       seldo_run,  NULL,       0},
0623     { "seldi",  NULL,       seldi_run,  NULL,       0},
0624     { "selto",  NULL,       selto_run,  NULL,       0},
0625     { "busfree",    NULL,       busfree_run,    NULL,       0},
0626     { "msgo",   msgo_init,  msgo_run,   msgo_end,   1},
0627     { "cmd",    cmd_init,   cmd_run,    cmd_end,    1},
0628     { "msgi",   NULL,       msgi_run,   msgi_end,   1},
0629     { "status", NULL,       status_run, NULL,       1},
0630     { "datai",  datai_init, datai_run,  datai_end,  0},
0631     { "datao",  datao_init, datao_run,  datao_end,  0},
0632     { "parerr", NULL,       parerr_run, NULL,       0},
0633     { "rsti",   NULL,       rsti_run,   NULL,       0},
0634 };
0635
0636 /* setup & interrupt */
0637 static irqreturn_t intr(int irq, void *dev_id);
0638 static void reset_ports(struct Scsi_Host *shpnt);
0639 static void aha152x_error(struct Scsi_Host *shpnt, char *msg);
0640 static void done(struct Scsi_Host *shpnt, unsigned char status_byte,
0641          unsigned char host_byte);
0642
0643 /* diagnostics */
0644 static void show_command(struct scsi_cmnd * ptr);
0645 static void show_queues(struct Scsi_Host *shpnt);
0646 static void disp_enintr(struct Scsi_Host *shpnt);
0647
0648
0649 /*
0650  *  queue services:
0651  *
0652  */
0653 static inline void append_SC(struct scsi_cmnd **SC, struct scsi_cmnd *new_SC)
0654 {
0655     struct scsi_cmnd *end;
0656
0657     SCNEXT(new_SC) = NULL;
0658     if (!*SC)
0659         *SC = new_SC;
0660     else {
0661         for (end = *SC; SCNEXT(end); end = SCNEXT(end))
0662             ;
0663         SCNEXT(end) = new_SC;
0664     }
0665 }
0666
0667 static inline struct scsi_cmnd *remove_first_SC(struct scsi_cmnd ** SC)
0668 {
0669     struct scsi_cmnd *ptr;
0670
0671     ptr = *SC;
0672     if (ptr) {
0673         *SC = SCNEXT(*SC);
0674         SCNEXT(ptr)=NULL;
0675     }
0676     return ptr;
0677 }
0678
0679 static inline struct scsi_cmnd *remove_lun_SC(struct scsi_cmnd ** SC,
0680                           int target, int lun)
0681 {
0682     struct scsi_cmnd *ptr, *prev;
0683
0684     for (ptr = *SC, prev = NULL;
0685          ptr && ((ptr->device->id != target) || (ptr->device->lun != lun));
0686          prev = ptr, ptr = SCNEXT(ptr))
0687          ;
0688
0689     if (ptr) {
0690         if (prev)
0691             SCNEXT(prev) = SCNEXT(ptr);
0692         else
0693             *SC = SCNEXT(ptr);
0694
0695         SCNEXT(ptr)=NULL;
0696     }
0697
0698     return ptr;
0699 }
0700
0701 static inline struct scsi_cmnd *remove_SC(struct scsi_cmnd **SC,
0702                       struct scsi_cmnd *SCp)
0703 {
0704     struct scsi_cmnd *ptr, *prev;
0705
0706     for (ptr = *SC, prev = NULL;
0707          ptr && SCp!=ptr;
0708          prev = ptr, ptr = SCNEXT(ptr))
0709          ;
0710
0711     if (ptr) {
0712         if (prev)
0713             SCNEXT(prev) = SCNEXT(ptr);
0714         else
0715             *SC = SCNEXT(ptr);
0716
0717         SCNEXT(ptr)=NULL;
0718     }
0719
0720     return ptr;
0721 }
0722
0723 static irqreturn_t swintr(int irqno, void *dev_id)
0724 {
0725     struct Scsi_Host *shpnt = dev_id;
0726
0727     HOSTDATA(shpnt)->swint++;
0728
0729     SETPORT(DMACNTRL0, INTEN);
0730     return IRQ_HANDLED;
0731 }
0732
0733 struct Scsi_Host *aha152x_probe_one(struct aha152x_setup *setup)
0734 {
0735     struct Scsi_Host *shpnt;
0736
0737     shpnt = scsi_host_alloc(&aha152x_driver_template, sizeof(struct aha152x_hostdata));
0738     if (!shpnt) {
0739         printk(KERN_ERR "aha152x: scsi_host_alloc failed\n");
0740         return NULL;
0741     }
0742
0743     memset(HOSTDATA(shpnt), 0, sizeof *HOSTDATA(shpnt));
0744     INIT_LIST_HEAD(&HOSTDATA(shpnt)->host_list);
0745
0746     /* need to have host registered before triggering any interrupt */
0747     list_add_tail(&HOSTDATA(shpnt)->host_list, &aha152x_host_list);
0748
0749     shpnt->io_port   = setup->io_port;
0750     shpnt->n_io_port = IO_RANGE;
0751     shpnt->irq       = setup->irq;
0752
0753     if (!setup->tc1550) {
0754         HOSTIOPORT0 = setup->io_port;
0755         HOSTIOPORT1 = setup->io_port;
0756     } else {
0757         HOSTIOPORT0 = setup->io_port+0x10;
0758         HOSTIOPORT1 = setup->io_port-0x10;
0759     }
0760
0761     spin_lock_init(&QLOCK);
0762     RECONNECT   = setup->reconnect;
0763     SYNCHRONOUS = setup->synchronous;
0764     PARITY      = setup->parity;
0765     DELAY       = setup->delay;
0766     EXT_TRANS   = setup->ext_trans;
0767
0768     SETPORT(SCSIID, setup->scsiid << 4);
0769     shpnt->this_id = setup->scsiid;
0770
0771     if (setup->reconnect)
0772         shpnt->can_queue = AHA152X_MAXQUEUE;
0773
0774     /* RESET OUT */
0775     printk("aha152x: resetting bus...\n");
0776     SETPORT(SCSISEQ, SCSIRSTO);
0777     mdelay(256);
0778     SETPORT(SCSISEQ, 0);
0779     mdelay(DELAY);
0780
0781     reset_ports(shpnt);
0782
0783     printk(KERN_INFO
0784            "aha152x%d%s: "
0785            "vital data: rev=%x, "
0786            "io=0x%03lx (0x%03lx/0x%03lx), "
0787            "irq=%d, "
0788            "scsiid=%d, "
0789            "reconnect=%s, "
0790            "parity=%s, "
0791            "synchronous=%s, "
0792            "delay=%d, "
0793            "extended translation=%s\n",
0794            shpnt->host_no, setup->tc1550 ? " (tc1550 mode)" : "",
0795            GETPORT(REV) & 0x7,
0796            shpnt->io_port, HOSTIOPORT0, HOSTIOPORT1,
0797            shpnt->irq,
0798            shpnt->this_id,
0799            RECONNECT ? "enabled" : "disabled",
0800            PARITY ? "enabled" : "disabled",
0801            SYNCHRONOUS ? "enabled" : "disabled",
0802            DELAY,
0803            EXT_TRANS ? "enabled" : "disabled");
0804
0805     /* not expecting any interrupts */
0806     SETPORT(SIMODE0, 0);
0807     SETPORT(SIMODE1, 0);
0808
0809     if (request_irq(shpnt->irq, swintr, IRQF_SHARED, "aha152x", shpnt)) {
0810         printk(KERN_ERR "aha152x%d: irq %d busy.\n", shpnt->host_no, shpnt->irq);
0811         goto out_host_put;
0812     }
0813
0814     HOSTDATA(shpnt)->swint = 0;
0815
0816     printk(KERN_INFO "aha152x%d: trying software interrupt, ", shpnt->host_no);
0817
0818     mb();
0819     SETPORT(DMACNTRL0, SWINT|INTEN);
0820     mdelay(1000);
0821     free_irq(shpnt->irq, shpnt);
0822
0823     if (!HOSTDATA(shpnt)->swint) {
0824         if (TESTHI(DMASTAT, INTSTAT)) {
0825             printk("lost.\n");
0826         } else {
0827             printk("failed.\n");
0828         }
0829
0830         SETPORT(DMACNTRL0, INTEN);
0831
0832         printk(KERN_ERR "aha152x%d: irq %d possibly wrong.  "
0833                 "Please verify.\n", shpnt->host_no, shpnt->irq);
0834         goto out_host_put;
0835     }
0836     printk("ok.\n");
0837
0838
0839     /* clear interrupts */
0840     SETPORT(SSTAT0, 0x7f);
0841     SETPORT(SSTAT1, 0xef);
0842
0843     if (request_irq(shpnt->irq, intr, IRQF_SHARED, "aha152x", shpnt)) {
0844         printk(KERN_ERR "aha152x%d: failed to reassign irq %d.\n", shpnt->host_no, shpnt->irq);
0845         goto out_host_put;
0846     }
0847
0848     if( scsi_add_host(shpnt, NULL) ) {
0849         free_irq(shpnt->irq, shpnt);
0850         printk(KERN_ERR "aha152x%d: failed to add host.\n", shpnt->host_no);
0851         goto out_host_put;
0852     }
0853
0854     scsi_scan_host(shpnt);
0855
0856     return shpnt;
0857
0858 out_host_put:
0859     list_del(&HOSTDATA(shpnt)->host_list);
0860     scsi_host_put(shpnt);
0861
0862     return NULL;
0863 }
0864
0865 void aha152x_release(struct Scsi_Host *shpnt)
0866 {
0867     if (!shpnt)
0868         return;
0869
0870     scsi_remove_host(shpnt);
0871     if (shpnt->irq)
0872         free_irq(shpnt->irq, shpnt);
0873
0874 #if !defined(AHA152X_PCMCIA)
0875     if (shpnt->io_port)
0876         release_region(shpnt->io_port, IO_RANGE);
0877 #endif
0878
0879 #ifdef __ISAPNP__
0880     if (HOSTDATA(shpnt)->pnpdev)
0881         pnp_device_detach(HOSTDATA(shpnt)->pnpdev);
0882 #endif
0883
0884     list_del(&HOSTDATA(shpnt)->host_list);
0885     scsi_host_put(shpnt);
0886 }
0887
0888
0889 /*
0890  * setup controller to generate interrupts depending
0891  * on current state (lock has to be acquired)
0892  *
0893  */
0894 static int setup_expected_interrupts(struct Scsi_Host *shpnt)
0895 {
0896     if(CURRENT_SC) {
0897         struct aha152x_cmd_priv *acp = aha152x_priv(CURRENT_SC);
0898
0899         acp->phase |= 1 << 16;
0900
0901         if (acp->phase & selecting) {
0902             SETPORT(SSTAT1, SELTO);
0903             SETPORT(SIMODE0, ENSELDO | (DISCONNECTED_SC ? ENSELDI : 0));
0904             SETPORT(SIMODE1, ENSELTIMO);
0905         } else {
0906             SETPORT(SIMODE0, (acp->phase & spiordy) ? ENSPIORDY : 0);
0907             SETPORT(SIMODE1, ENPHASEMIS | ENSCSIRST | ENSCSIPERR | ENBUSFREE);
0908         }
0909     } else if(STATE==seldi) {
0910         SETPORT(SIMODE0, 0);
0911         SETPORT(SIMODE1, ENPHASEMIS | ENSCSIRST | ENSCSIPERR | ENBUSFREE);
0912     } else {
0913         SETPORT(SIMODE0, DISCONNECTED_SC ? ENSELDI : 0);
0914         SETPORT(SIMODE1, ENSCSIRST | ( (ISSUE_SC||DONE_SC) ? ENBUSFREE : 0));
0915     }
0916
0917     if(!HOSTDATA(shpnt)->in_intr)
0918         SETBITS(DMACNTRL0, INTEN);
0919
0920     return TESTHI(DMASTAT, INTSTAT);
0921 }
0922
0923
0924 /*
0925  *  Queue a command and setup interrupts for a free bus.
0926  */
0927 static int aha152x_internal_queue(struct scsi_cmnd *SCpnt,
0928                   struct completion *complete, int phase)
0929 {
0930     struct aha152x_cmd_priv *acp = aha152x_priv(SCpnt);
0931     struct Scsi_Host *shpnt = SCpnt->device->host;
0932     unsigned long flags;
0933
0934     acp->phase        = not_issued | phase;
0935     acp->status       = 0x1; /* Illegal status by SCSI standard */
0936     acp->message      = 0;
0937     acp->sent_command = 0;
0938
0939     if (acp->phase & (resetting | check_condition)) {
0940         if (!SCpnt->host_scribble || SCSEM(SCpnt) || SCNEXT(SCpnt)) {
0941             scmd_printk(KERN_ERR, SCpnt, "cannot reuse command\n");
0942             return FAILED;
0943         }
0944     } else {
0945         SCpnt->host_scribble = kmalloc(sizeof(struct aha152x_scdata), GFP_ATOMIC);
0946         if(!SCpnt->host_scribble) {
0947             scmd_printk(KERN_ERR, SCpnt, "allocation failed\n");
0948             return FAILED;
0949         }
0950     }
0951
0952     SCNEXT(SCpnt)       = NULL;
0953     SCSEM(SCpnt)        = complete;
0954
0955     /* setup scratch area
0956        SCp.ptr              : buffer pointer
0957        SCp.this_residual    : buffer length
0958        SCp.buffer           : next buffer
0959        SCp.phase            : current state of the command */
0960
0961     if ((phase & resetting) || !scsi_sglist(SCpnt)) {
0962         acp->ptr           = NULL;
0963         acp->this_residual = 0;
0964         scsi_set_resid(SCpnt, 0);
0965         acp->buffer        = NULL;
0966     } else {
0967         scsi_set_resid(SCpnt, scsi_bufflen(SCpnt));
0968         acp->buffer        = scsi_sglist(SCpnt);
0969         acp->ptr           = SG_ADDRESS(acp->buffer);
0970         acp->this_residual = acp->buffer->length;
0971     }
0972
0973     DO_LOCK(flags);
0974
0975 #if defined(AHA152X_STAT)
0976     HOSTDATA(shpnt)->total_commands++;
0977 #endif
0978
0979     /* Turn led on, when this is the first command. */
0980     HOSTDATA(shpnt)->commands++;
0981     if (HOSTDATA(shpnt)->commands==1)
0982         SETPORT(PORTA, 1);
0983
0984     append_SC(&ISSUE_SC, SCpnt);
0985
0986     if(!HOSTDATA(shpnt)->in_intr)
0987         setup_expected_interrupts(shpnt);
0988
0989     DO_UNLOCK(flags);
0990
0991     return 0;
0992 }
0993
0994 /*
0995  *  queue a command
0996  *
0997  */
0998 static int aha152x_queue_lck(struct scsi_cmnd *SCpnt)
0999 {
1000     return aha152x_internal_queue(SCpnt, NULL, 0);
1001 }
1002
1003 static DEF_SCSI_QCMD(aha152x_queue)
1004
1005
1006 /*
1007  *
1008  */
1009 static void reset_done(struct scsi_cmnd *SCpnt)
1010 {
1011     if(SCSEM(SCpnt)) {
1012         complete(SCSEM(SCpnt));
1013     } else {
1014         printk(KERN_ERR "aha152x: reset_done w/o completion\n");
1015     }
1016 }
1017
1018 static void aha152x_scsi_done(struct scsi_cmnd *SCpnt)
1019 {
1020     if (aha152x_priv(SCpnt)->phase & resetting)
1021         reset_done(SCpnt);
1022     else
1023         scsi_done(SCpnt);
1024 }
1025
1026 /*
1027  *  Abort a command
1028  *
1029  */
1030 static int aha152x_abort(struct scsi_cmnd *SCpnt)
1031 {
1032     struct Scsi_Host *shpnt = SCpnt->device->host;
1033     struct scsi_cmnd *ptr;
1034     unsigned long flags;
1035
1036     DO_LOCK(flags);
1037
1038     ptr=remove_SC(&ISSUE_SC, SCpnt);
1039
1040     if(ptr) {
1041         HOSTDATA(shpnt)->commands--;
1042         if (!HOSTDATA(shpnt)->commands)
1043             SETPORT(PORTA, 0);
1044         DO_UNLOCK(flags);
1045
1046         kfree(SCpnt->host_scribble);
1047         SCpnt->host_scribble=NULL;
1048
1049         return SUCCESS;
1050     }
1051
1052     DO_UNLOCK(flags);
1053
1054     /*
1055      * FIXME:
1056      * for current command: queue ABORT for message out and raise ATN
1057      * for disconnected command: pseudo SC with ABORT message or ABORT on reselection?
1058      *
1059      */
1060
1061     scmd_printk(KERN_ERR, SCpnt,
1062             "cannot abort running or disconnected command\n");
1063
1064     return FAILED;
1065 }
1066
1067 /*
1068  * Reset a device
1069  *
1070  */
1071 static int aha152x_device_reset(struct scsi_cmnd * SCpnt)
1072 {
1073     struct Scsi_Host *shpnt = SCpnt->device->host;
1074     DECLARE_COMPLETION(done);
1075     int ret, issued, disconnected;
1076     unsigned char old_cmd_len = SCpnt->cmd_len;
1077     unsigned long flags;
1078     unsigned long timeleft;
1079
1080     if(CURRENT_SC==SCpnt) {
1081         scmd_printk(KERN_ERR, SCpnt, "cannot reset current device\n");
1082         return FAILED;
1083     }
1084
1085     DO_LOCK(flags);
1086     issued       = remove_SC(&ISSUE_SC, SCpnt) == NULL;
1087     disconnected = issued && remove_SC(&DISCONNECTED_SC, SCpnt);
1088     DO_UNLOCK(flags);
1089
1090     SCpnt->cmd_len         = 0;
1091
1092     aha152x_internal_queue(SCpnt, &done, resetting);
1093
1094     timeleft = wait_for_completion_timeout(&done, 100*HZ);
1095     if (!timeleft) {
1096         /* remove command from issue queue */
1097         DO_LOCK(flags);
1098         remove_SC(&ISSUE_SC, SCpnt);
1099         DO_UNLOCK(flags);
1100     }
1101
1102     SCpnt->cmd_len         = old_cmd_len;
1103
1104     DO_LOCK(flags);
1105
1106     if (aha152x_priv(SCpnt)->phase & resetted) {
1107         HOSTDATA(shpnt)->commands--;
1108         if (!HOSTDATA(shpnt)->commands)
1109             SETPORT(PORTA, 0);
1110         kfree(SCpnt->host_scribble);
1111         SCpnt->host_scribble=NULL;
1112
1113         ret = SUCCESS;
1114     } else {
1115         /* requeue */
1116         if(!issued) {
1117             append_SC(&ISSUE_SC, SCpnt);
1118         } else if(disconnected) {
1119             append_SC(&DISCONNECTED_SC, SCpnt);
1120         }
1121
1122         ret = FAILED;
1123     }
1124
1125     DO_UNLOCK(flags);
1126     return ret;
1127 }
1128
1129 static void free_hard_reset_SCs(struct Scsi_Host *shpnt,
1130                 struct scsi_cmnd **SCs)
1131 {
1132     struct scsi_cmnd *ptr;
1133
1134     ptr=*SCs;
1135     while(ptr) {
1136         struct scsi_cmnd *next;
1137
1138         if(SCDATA(ptr)) {
1139             next = SCNEXT(ptr);
1140         } else {
1141             scmd_printk(KERN_DEBUG, ptr,
1142                     "queue corrupted at %p\n", ptr);
1143             next = NULL;
1144         }
1145
1146         if (!ptr->device->soft_reset) {
1147             remove_SC(SCs, ptr);
1148             HOSTDATA(shpnt)->commands--;
1149             kfree(ptr->host_scribble);
1150             ptr->host_scribble=NULL;
1151         }
1152
1153         ptr = next;
1154     }
1155 }
1156
1157 /*
1158  * Reset the bus
1159  *
1160  * AIC-6260 has a hard reset (MRST signal), but apparently
1161  * one cannot trigger it via software. So live with
1162  * a soft reset; no-one seemed to have cared.
1163  */
1164 static int aha152x_bus_reset_host(struct Scsi_Host *shpnt)
1165 {
1166     unsigned long flags;
1167
1168     DO_LOCK(flags);
1169
1170     free_hard_reset_SCs(shpnt, &ISSUE_SC);
1171     free_hard_reset_SCs(shpnt, &DISCONNECTED_SC);
1172
1173     SETPORT(SCSISEQ, SCSIRSTO);
1174     mdelay(256);
1175     SETPORT(SCSISEQ, 0);
1176     mdelay(DELAY);
1177
1178     setup_expected_interrupts(shpnt);
1179     if(HOSTDATA(shpnt)->commands==0)
1180         SETPORT(PORTA, 0);
1181
1182     DO_UNLOCK(flags);
1183
1184     return SUCCESS;
1185 }
1186
1187 /*
1188  * Reset the bus
1189  *
1190  */
1191 static int aha152x_bus_reset(struct scsi_cmnd *SCpnt)
1192 {
1193     return aha152x_bus_reset_host(SCpnt->device->host);
1194 }
1195
1196 /*
1197  *  Restore default values to the AIC-6260 registers and reset the fifos
1198  *
1199  */
1200 static void reset_ports(struct Scsi_Host *shpnt)
1201 {
1202     unsigned long flags;
1203
1204     /* disable interrupts */
1205     SETPORT(DMACNTRL0, RSTFIFO);
1206
1207     SETPORT(SCSISEQ, 0);
1208
1209     SETPORT(SXFRCTL1, 0);
1210     SETPORT(SCSISIG, 0);
1211     SETRATE(0);
1212
1213     /* clear all interrupt conditions */
1214     SETPORT(SSTAT0, 0x7f);
1215     SETPORT(SSTAT1, 0xef);
1216
1217     SETPORT(SSTAT4, SYNCERR | FWERR | FRERR);
1218
1219     SETPORT(DMACNTRL0, 0);
1220     SETPORT(DMACNTRL1, 0);
1221
1222     SETPORT(BRSTCNTRL, 0xf1);
1223
1224     /* clear SCSI fifos and transfer count */
1225     SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
1226     SETPORT(SXFRCTL0, CH1);
1227
1228     DO_LOCK(flags);
1229     setup_expected_interrupts(shpnt);
1230     DO_UNLOCK(flags);
1231 }
1232
1233 /*
1234  * Reset the host (bus and controller)
1235  *
1236  */
1237 int aha152x_host_reset_host(struct Scsi_Host *shpnt)
1238 {
1239     aha152x_bus_reset_host(shpnt);
1240     reset_ports(shpnt);
1241
1242     return SUCCESS;
1243 }
1244
1245 /*
1246  * Return the "logical geometry"
1247  *
1248  */
1249 static int aha152x_biosparam(struct scsi_device *sdev, struct block_device *bdev,
1250         sector_t capacity, int *info_array)
1251 {
1252     struct Scsi_Host *shpnt = sdev->host;
1253
1254     /* try default translation */
1255     info_array[0] = 64;
1256     info_array[1] = 32;
1257     info_array[2] = (unsigned long)capacity / (64 * 32);
1258
1259     /* for disks >1GB do some guessing */
1260     if (info_array[2] >= 1024) {
1261         int info[3];
1262
1263         /* try to figure out the geometry from the partition table */
1264         if (scsicam_bios_param(bdev, capacity, info) < 0 ||
1265             !((info[0] == 64 && info[1] == 32) || (info[0] == 255 && info[1] == 63))) {
1266             if (EXT_TRANS) {
1267                 printk(KERN_NOTICE
1268                        "aha152x: unable to verify geometry for disk with >1GB.\n"
1269                        "         using extended translation.\n");
1270                 info_array[0] = 255;
1271                 info_array[1] = 63;
1272                 info_array[2] = (unsigned long)capacity / (255 * 63);
1273             } else {
1274                 printk(KERN_NOTICE
1275                        "aha152x: unable to verify geometry for disk with >1GB.\n"
1276                        "         Using default translation. Please verify yourself.\n"
1277                        "         Perhaps you need to enable extended translation in the driver.\n"
1278                        "         See Documentation/scsi/aha152x.rst for details.\n");
1279             }
1280         } else {
1281             info_array[0] = info[0];
1282             info_array[1] = info[1];
1283             info_array[2] = info[2];
1284
1285             if (info[0] == 255 && !EXT_TRANS) {
1286                 printk(KERN_NOTICE
1287                        "aha152x: current partition table is using extended translation.\n"
1288                        "         using it also, although it's not explicitly enabled.\n");
1289             }
1290         }
1291     }
1292
1293     return 0;
1294 }
1295
1296 /*
1297  *  Internal done function
1298  *
1299  */
1300 static void done(struct Scsi_Host *shpnt, unsigned char status_byte,
1301          unsigned char host_byte)
1302 {
1303     if (CURRENT_SC) {
1304         if(DONE_SC)
1305             scmd_printk(KERN_ERR, CURRENT_SC,
1306                     "there's already a completed command %p "
1307                     "- will cause abort\n", DONE_SC);
1308
1309         DONE_SC = CURRENT_SC;
1310         CURRENT_SC = NULL;
1311         set_status_byte(DONE_SC, status_byte);
1312         set_host_byte(DONE_SC, host_byte);
1313     } else
1314         printk(KERN_ERR "aha152x: done() called outside of command\n");
1315 }
1316
1317 static struct work_struct aha152x_tq;
1318
1319 /*
1320  * Run service completions on the card with interrupts enabled.
1321  *
1322  */
1323 static void run(struct work_struct *work)
1324 {
1325     struct aha152x_hostdata *hd;
1326
1327     list_for_each_entry(hd, &aha152x_host_list, host_list) {
1328         struct Scsi_Host *shost = container_of((void *)hd, struct Scsi_Host, hostdata);
1329
1330         is_complete(shost);
1331     }
1332 }
1333
1334 /*
1335  * Interrupt handler
1336  *
1337  */
1338 static irqreturn_t intr(int irqno, void *dev_id)
1339 {
1340     struct Scsi_Host *shpnt = dev_id;
1341     unsigned long flags;
1342     unsigned char rev, dmacntrl0;
1343
1344     /*
1345      * Read a couple of registers that are known to not be all 1's. If
1346      * we read all 1's (-1), that means that either:
1347      *
1348      * a. The host adapter chip has gone bad, and we cannot control it,
1349      *  OR
1350      * b. The host adapter is a PCMCIA card that has been ejected
1351      *
1352      * In either case, we cannot do anything with the host adapter at
1353      * this point in time. So just ignore the interrupt and return.
1354      * In the latter case, the interrupt might actually be meant for
1355      * someone else sharing this IRQ, and that driver will handle it.
1356      */
1357     rev = GETPORT(REV);
1358     dmacntrl0 = GETPORT(DMACNTRL0);
1359     if ((rev == 0xFF) && (dmacntrl0 == 0xFF))
1360         return IRQ_NONE;
1361
1362     if( TESTLO(DMASTAT, INTSTAT) )
1363         return IRQ_NONE;
1364
1365     /* no more interrupts from the controller, while we're busy.
1366        INTEN is restored by the BH handler */
1367     CLRBITS(DMACNTRL0, INTEN);
1368
1369     DO_LOCK(flags);
1370     if( HOSTDATA(shpnt)->service==0 ) {
1371         HOSTDATA(shpnt)->service=1;
1372
1373         /* Poke the BH handler */
1374         INIT_WORK(&aha152x_tq, run);
1375         schedule_work(&aha152x_tq);
1376     }
1377     DO_UNLOCK(flags);
1378
1379     return IRQ_HANDLED;
1380 }
1381
1382 /*
1383  * busfree phase
1384  * - handle completition/disconnection/error of current command
1385  * - start selection for next command (if any)
1386  */
1387 static void busfree_run(struct Scsi_Host *shpnt)
1388 {
1389     unsigned long flags;
1390 #if defined(AHA152X_STAT)
1391     int action=0;
1392 #endif
1393
1394     SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
1395     SETPORT(SXFRCTL0, CH1);
1396
1397     SETPORT(SSTAT1, CLRBUSFREE);
1398
1399     if(CURRENT_SC) {
1400         struct aha152x_cmd_priv *acp = aha152x_priv(CURRENT_SC);
1401
1402 #if defined(AHA152X_STAT)
1403         action++;
1404 #endif
1405         acp->phase &= ~syncneg;
1406
1407         if (acp->phase & completed) {
1408             /* target sent COMMAND COMPLETE */
1409             done(shpnt, acp->status, DID_OK);
1410
1411         } else if (acp->phase & aborted) {
1412             done(shpnt, acp->status, DID_ABORT);
1413
1414         } else if (acp->phase & resetted) {
1415             done(shpnt, acp->status, DID_RESET);
1416
1417         } else if (acp->phase & disconnected) {
1418             /* target sent DISCONNECT */
1419 #if defined(AHA152X_STAT)
1420             HOSTDATA(shpnt)->disconnections++;
1421 #endif
1422             append_SC(&DISCONNECTED_SC, CURRENT_SC);
1423             acp->phase |= 1 << 16;
1424             CURRENT_SC = NULL;
1425
1426         } else {
1427             done(shpnt, SAM_STAT_GOOD, DID_ERROR);
1428         }
1429 #if defined(AHA152X_STAT)
1430     } else {
1431         HOSTDATA(shpnt)->busfree_without_old_command++;
1432 #endif
1433     }
1434
1435     DO_LOCK(flags);
1436
1437     if(DONE_SC) {
1438 #if defined(AHA152X_STAT)
1439         action++;
1440 #endif
1441
1442         if (aha152x_priv(DONE_SC)->phase & check_condition) {
1443             struct scsi_cmnd *cmd = HOSTDATA(shpnt)->done_SC;
1444             struct aha152x_scdata *sc = SCDATA(cmd);
1445
1446             scsi_eh_restore_cmnd(cmd, &sc->ses);
1447
1448             aha152x_priv(cmd)->status = SAM_STAT_CHECK_CONDITION;
1449
1450             HOSTDATA(shpnt)->commands--;
1451             if (!HOSTDATA(shpnt)->commands)
1452                 SETPORT(PORTA, 0);  /* turn led off */
1453         } else if (aha152x_priv(DONE_SC)->status == SAM_STAT_CHECK_CONDITION) {
1454 #if defined(AHA152X_STAT)
1455             HOSTDATA(shpnt)->busfree_with_check_condition++;
1456 #endif
1457
1458             if (!(aha152x_priv(DONE_SC)->phase & not_issued)) {
1459                 struct aha152x_scdata *sc;
1460                 struct scsi_cmnd *ptr = DONE_SC;
1461                 DONE_SC=NULL;
1462
1463                 sc = SCDATA(ptr);
1464                 /* It was allocated in aha152x_internal_queue? */
1465                 BUG_ON(!sc);
1466                 scsi_eh_prep_cmnd(ptr, &sc->ses, NULL, 0, ~0);
1467
1468                 DO_UNLOCK(flags);
1469                 aha152x_internal_queue(ptr, NULL, check_condition);
1470                 DO_LOCK(flags);
1471             }
1472         }
1473
1474         if (DONE_SC) {
1475             struct scsi_cmnd *ptr = DONE_SC;
1476             DONE_SC=NULL;
1477
1478             /* turn led off, when no commands are in the driver */
1479             HOSTDATA(shpnt)->commands--;
1480             if (!HOSTDATA(shpnt)->commands)
1481                 SETPORT(PORTA, 0);  /* turn led off */
1482
1483             if (!(aha152x_priv(ptr)->phase & resetting)) {
1484                 kfree(ptr->host_scribble);
1485                 ptr->host_scribble=NULL;
1486             }
1487
1488             DO_UNLOCK(flags);
1489             aha152x_scsi_done(ptr);
1490             DO_LOCK(flags);
1491         }
1492
1493         DONE_SC=NULL;
1494 #if defined(AHA152X_STAT)
1495     } else {
1496         HOSTDATA(shpnt)->busfree_without_done_command++;
1497 #endif
1498     }
1499
1500     if(ISSUE_SC)
1501         CURRENT_SC = remove_first_SC(&ISSUE_SC);
1502
1503     DO_UNLOCK(flags);
1504
1505     if(CURRENT_SC) {
1506         struct aha152x_cmd_priv *acp = aha152x_priv(CURRENT_SC);
1507
1508 #if defined(AHA152X_STAT)
1509         action++;
1510 #endif
1511         acp->phase |= selecting;
1512
1513         /* clear selection timeout */
1514         SETPORT(SSTAT1, SELTO);
1515
1516         SETPORT(SCSIID, (shpnt->this_id << OID_) | CURRENT_SC->device->id);
1517         SETPORT(SXFRCTL1, (PARITY ? ENSPCHK : 0 ) | ENSTIMER);
1518         SETPORT(SCSISEQ, ENSELO | ENAUTOATNO | (DISCONNECTED_SC ? ENRESELI : 0));
1519     } else {
1520 #if defined(AHA152X_STAT)
1521         HOSTDATA(shpnt)->busfree_without_new_command++;
1522 #endif
1523         SETPORT(SCSISEQ, DISCONNECTED_SC ? ENRESELI : 0);
1524     }
1525
1526 #if defined(AHA152X_STAT)
1527     if(!action)
1528         HOSTDATA(shpnt)->busfree_without_any_action++;
1529 #endif
1530 }
1531
1532 /*
1533  * Selection done (OUT)
1534  * - queue IDENTIFY message and SDTR to selected target for message out
1535  *   (ATN asserted automagically via ENAUTOATNO in busfree())
1536  */
1537 static void seldo_run(struct Scsi_Host *shpnt)
1538 {
1539     struct aha152x_cmd_priv *acp = aha152x_priv(CURRENT_SC);
1540
1541     SETPORT(SCSISIG, 0);
1542     SETPORT(SSTAT1, CLRBUSFREE);
1543     SETPORT(SSTAT1, CLRPHASECHG);
1544
1545     acp->phase &= ~(selecting | not_issued);
1546
1547     SETPORT(SCSISEQ, 0);
1548
1549     if (TESTLO(SSTAT0, SELDO)) {
1550         scmd_printk(KERN_ERR, CURRENT_SC,
1551                 "aha152x: passing bus free condition\n");
1552         done(shpnt, SAM_STAT_GOOD, DID_NO_CONNECT);
1553         return;
1554     }
1555
1556     SETPORT(SSTAT0, CLRSELDO);
1557
1558     ADDMSGO(IDENTIFY(RECONNECT, CURRENT_SC->device->lun));
1559
1560     if (acp->phase & aborting) {
1561         ADDMSGO(ABORT);
1562     } else if (acp->phase & resetting) {
1563         ADDMSGO(BUS_DEVICE_RESET);
1564     } else if (SYNCNEG==0 && SYNCHRONOUS) {
1565         acp->phase |= syncneg;
1566         MSGOLEN += spi_populate_sync_msg(&MSGO(MSGOLEN), 50, 8);
1567         SYNCNEG=1;      /* negotiation in progress */
1568     }
1569
1570     SETRATE(SYNCRATE);
1571 }
1572
1573 /*
1574  * Selection timeout
1575  * - return command to mid-level with failure cause
1576  *
1577  */
1578 static void selto_run(struct Scsi_Host *shpnt)
1579 {
1580     struct aha152x_cmd_priv *acp;
1581
1582     SETPORT(SCSISEQ, 0);
1583     SETPORT(SSTAT1, CLRSELTIMO);
1584
1585     if (!CURRENT_SC)
1586         return;
1587
1588     acp = aha152x_priv(CURRENT_SC);
1589     acp->phase &= ~selecting;
1590
1591     if (acp->phase & aborted)
1592         done(shpnt, SAM_STAT_GOOD, DID_ABORT);
1593     else if (TESTLO(SSTAT0, SELINGO))
1594         done(shpnt, SAM_STAT_GOOD, DID_BUS_BUSY);
1595     else
1596         /* ARBITRATION won, but SELECTION failed */
1597         done(shpnt, SAM_STAT_GOOD, DID_NO_CONNECT);
1598 }
1599
1600 /*
1601  * Selection in done
1602  * - put current command back to issue queue
1603  *   (reconnection of a disconnected nexus instead
1604  *    of successful selection out)
1605  *
1606  */
1607 static void seldi_run(struct Scsi_Host *shpnt)
1608 {
1609     int selid;
1610     int target;
1611     unsigned long flags;
1612
1613     SETPORT(SCSISIG, 0);
1614     SETPORT(SSTAT0, CLRSELDI);
1615     SETPORT(SSTAT1, CLRBUSFREE);
1616     SETPORT(SSTAT1, CLRPHASECHG);
1617
1618     if(CURRENT_SC) {
1619         struct aha152x_cmd_priv *acp = aha152x_priv(CURRENT_SC);
1620
1621         if (!(acp->phase & not_issued))
1622             scmd_printk(KERN_ERR, CURRENT_SC,
1623                     "command should not have been issued yet\n");
1624
1625         DO_LOCK(flags);
1626         append_SC(&ISSUE_SC, CURRENT_SC);
1627         DO_UNLOCK(flags);
1628
1629         CURRENT_SC = NULL;
1630     }
1631
1632     if (!DISCONNECTED_SC)
1633         return;
1634
1635     RECONN_TARGET=-1;
1636
1637     selid = GETPORT(SELID) & ~(1 << shpnt->this_id);
1638
1639     if (selid==0) {
1640         shost_printk(KERN_INFO, shpnt,
1641                  "target id unknown (%02x)\n", selid);
1642         return;
1643     }
1644
1645     for(target=7; !(selid & (1 << target)); target--)
1646         ;
1647
1648     if(selid & ~(1 << target)) {
1649         shost_printk(KERN_INFO, shpnt,
1650                  "multiple targets reconnected (%02x)\n", selid);
1651     }
1652
1653
1654     SETPORT(SCSIID, (shpnt->this_id << OID_) | target);
1655     SETPORT(SCSISEQ, 0);
1656
1657     SETRATE(HOSTDATA(shpnt)->syncrate[target]);
1658
1659     RECONN_TARGET=target;
1660 }
1661
1662 /*
1663  * message in phase
1664  * - handle initial message after reconnection to identify
1665  *   reconnecting nexus
1666  * - queue command on DISCONNECTED_SC on DISCONNECT message
1667  * - set completed flag on COMMAND COMPLETE
1668  *   (other completition code moved to busfree_run)
1669  * - handle response to SDTR
1670  * - clear synchronous transfer agreements on BUS RESET
1671  *
1672  * FIXME: what about SAVE POINTERS, RESTORE POINTERS?
1673  *
1674  */
1675 static void msgi_run(struct Scsi_Host *shpnt)
1676 {
1677     for(;;) {
1678         struct aha152x_cmd_priv *acp;
1679         int sstat1 = GETPORT(SSTAT1);
1680
1681         if(sstat1 & (PHASECHG|PHASEMIS|BUSFREE) || !(sstat1 & REQINIT))
1682             return;
1683
1684         if (TESTLO(SSTAT0, SPIORDY))
1685             return;
1686
1687         ADDMSGI(GETPORT(SCSIDAT));
1688
1689         if(!CURRENT_SC) {
1690             if(LASTSTATE!=seldi) {
1691                 shost_printk(KERN_ERR, shpnt,
1692                          "message in w/o current command"
1693                          " not after reselection\n");
1694             }
1695
1696             /*
1697              * Handle reselection
1698              */
1699             if(!(MSGI(0) & IDENTIFY_BASE)) {
1700                 shost_printk(KERN_ERR, shpnt,
1701                          "target didn't identify after reselection\n");
1702                 continue;
1703             }
1704
1705             CURRENT_SC = remove_lun_SC(&DISCONNECTED_SC, RECONN_TARGET, MSGI(0) & 0x3f);
1706
1707             if (!CURRENT_SC) {
1708                 show_queues(shpnt);
1709                 shost_printk(KERN_ERR, shpnt,
1710                          "no disconnected command"
1711                          " for target %d/%d\n",
1712                          RECONN_TARGET, MSGI(0) & 0x3f);
1713                 continue;
1714             }
1715
1716             acp = aha152x_priv(CURRENT_SC);
1717             acp->message = MSGI(0);
1718             acp->phase &= ~disconnected;
1719
1720             MSGILEN=0;
1721
1722             /* next message if any */
1723             continue;
1724         }
1725
1726         acp = aha152x_priv(CURRENT_SC);
1727         acp->message = MSGI(0);
1728
1729         switch (MSGI(0)) {
1730         case DISCONNECT:
1731             if (!RECONNECT)
1732                 scmd_printk(KERN_WARNING, CURRENT_SC,
1733                         "target was not allowed to disconnect\n");
1734
1735             acp->phase |= disconnected;
1736             break;
1737
1738         case COMMAND_COMPLETE:
1739             acp->phase |= completed;
1740             break;
1741
1742         case MESSAGE_REJECT:
1743             if (SYNCNEG==1) {
1744                 scmd_printk(KERN_INFO, CURRENT_SC,
1745                         "Synchronous Data Transfer Request"
1746                         " was rejected\n");
1747                 SYNCNEG=2;  /* negotiation completed */
1748             } else
1749                 scmd_printk(KERN_INFO, CURRENT_SC,
1750                         "inbound message (MESSAGE REJECT)\n");
1751             break;
1752
1753         case SAVE_POINTERS:
1754             break;
1755
1756         case RESTORE_POINTERS:
1757             break;
1758
1759         case EXTENDED_MESSAGE:
1760             if(MSGILEN<2 || MSGILEN<MSGI(1)+2) {
1761                 /* not yet completed */
1762                 continue;
1763             }
1764
1765             switch (MSGI(2)) {
1766             case EXTENDED_SDTR:
1767                 {
1768                     long ticks;
1769
1770                     if (MSGI(1) != 3) {
1771                         scmd_printk(KERN_ERR, CURRENT_SC,
1772                                 "SDTR message length!=3\n");
1773                         break;
1774                     }
1775
1776                     if (!HOSTDATA(shpnt)->synchronous)
1777                         break;
1778
1779                     printk(INFO_LEAD, CMDINFO(CURRENT_SC));
1780                     spi_print_msg(&MSGI(0));
1781                     printk("\n");
1782
1783                     ticks = (MSGI(3) * 4 + 49) / 50;
1784
1785                     if (syncneg) {
1786                         /* negotiation in progress */
1787                         if (ticks > 9 || MSGI(4) < 1 || MSGI(4) > 8) {
1788                             ADDMSGO(MESSAGE_REJECT);
1789                             scmd_printk(KERN_INFO,
1790                                     CURRENT_SC,
1791                                     "received Synchronous Data Transfer Request invalid - rejected\n");
1792                             break;
1793                         }
1794
1795                         SYNCRATE |= ((ticks - 2) << 4) + MSGI(4);
1796                     } else if (ticks <= 9 && MSGI(4) >= 1) {
1797                         ADDMSGO(EXTENDED_MESSAGE);
1798                         ADDMSGO(3);
1799                         ADDMSGO(EXTENDED_SDTR);
1800                         if (ticks < 4) {
1801                             ticks = 4;
1802                             ADDMSGO(50);
1803                         } else
1804                             ADDMSGO(MSGI(3));
1805
1806                         if (MSGI(4) > 8)
1807                             MSGI(4) = 8;
1808
1809                         ADDMSGO(MSGI(4));
1810
1811                         SYNCRATE |= ((ticks - 2) << 4) + MSGI(4);
1812                     } else {
1813                         /* requested SDTR is too slow, do it asynchronously */
1814                         scmd_printk(KERN_INFO,
1815                                 CURRENT_SC,
1816                                 "Synchronous Data Transfer Request too slow - Rejecting\n");
1817                         ADDMSGO(MESSAGE_REJECT);
1818                     }
1819
1820                     /* negotiation completed */
1821                     SYNCNEG=2;
1822                     SETRATE(SYNCRATE);
1823                 }
1824                 break;
1825
1826             case BUS_DEVICE_RESET:
1827                 {
1828                     int i;
1829
1830                     for(i=0; i<8; i++) {
1831                         HOSTDATA(shpnt)->syncrate[i]=0;
1832                         HOSTDATA(shpnt)->syncneg[i]=0;
1833                     }
1834
1835                 }
1836                 break;
1837
1838             case EXTENDED_MODIFY_DATA_POINTER:
1839             case EXTENDED_EXTENDED_IDENTIFY:
1840             case EXTENDED_WDTR:
1841             default:
1842                 ADDMSGO(MESSAGE_REJECT);
1843                 break;
1844             }
1845             break;
1846         }
1847
1848         MSGILEN=0;
1849     }
1850 }
1851
1852 static void msgi_end(struct Scsi_Host *shpnt)
1853 {
1854     if(MSGILEN>0)
1855         scmd_printk(KERN_WARNING, CURRENT_SC,
1856                 "target left before message completed (%d)\n",
1857                 MSGILEN);
1858
1859     if (MSGOLEN > 0 && !(GETPORT(SSTAT1) & BUSFREE))
1860         SETPORT(SCSISIG, P_MSGI | SIG_ATNO);
1861 }
1862
1863 /*
1864  * message out phase
1865  *
1866  */
1867 static void msgo_init(struct Scsi_Host *shpnt)
1868 {
1869     if(MSGOLEN==0) {
1870         if ((aha152x_priv(CURRENT_SC)->phase & syncneg) &&
1871             SYNCNEG == 2 && SYNCRATE == 0) {
1872             ADDMSGO(IDENTIFY(RECONNECT, CURRENT_SC->device->lun));
1873         } else {
1874             scmd_printk(KERN_INFO, CURRENT_SC,
1875                     "unexpected MESSAGE OUT phase; rejecting\n");
1876             ADDMSGO(MESSAGE_REJECT);
1877         }
1878     }
1879
1880 }
1881
1882 /*
1883  * message out phase
1884  *
1885  */
1886 static void msgo_run(struct Scsi_Host *shpnt)
1887 {
1888     struct aha152x_cmd_priv *acp = aha152x_priv(CURRENT_SC);
1889
1890     while(MSGO_I<MSGOLEN) {
1891         if (TESTLO(SSTAT0, SPIORDY))
1892             return;
1893
1894         if (MSGO_I==MSGOLEN-1) {
1895             /* Leave MESSAGE OUT after transfer */
1896             SETPORT(SSTAT1, CLRATNO);
1897         }
1898
1899
1900         if (MSGO(MSGO_I) & IDENTIFY_BASE)
1901             acp->phase |= identified;
1902
1903         if (MSGO(MSGO_I)==ABORT)
1904             acp->phase |= aborted;
1905
1906         if (MSGO(MSGO_I)==BUS_DEVICE_RESET)
1907             acp->phase |= resetted;
1908
1909         SETPORT(SCSIDAT, MSGO(MSGO_I++));
1910     }
1911 }
1912
1913 static void msgo_end(struct Scsi_Host *shpnt)
1914 {
1915     if(MSGO_I<MSGOLEN) {
1916         scmd_printk(KERN_ERR, CURRENT_SC,
1917                 "message sent incompletely (%d/%d)\n",
1918                 MSGO_I, MSGOLEN);
1919         if(SYNCNEG==1) {
1920             scmd_printk(KERN_INFO, CURRENT_SC,
1921                     "Synchronous Data Transfer Request was rejected\n");
1922             SYNCNEG=2;
1923         }
1924     }
1925
1926     MSGO_I  = 0;
1927     MSGOLEN = 0;
1928 }
1929
1930 /*
1931  * command phase
1932  *
1933  */
1934 static void cmd_init(struct Scsi_Host *shpnt)
1935 {
1936     if (aha152x_priv(CURRENT_SC)->sent_command) {
1937         scmd_printk(KERN_ERR, CURRENT_SC,
1938                 "command already sent\n");
1939         done(shpnt, SAM_STAT_GOOD, DID_ERROR);
1940         return;
1941     }
1942
1943     CMD_I=0;
1944 }
1945
1946 /*
1947  * command phase
1948  *
1949  */
1950 static void cmd_run(struct Scsi_Host *shpnt)
1951 {
1952     while(CMD_I<CURRENT_SC->cmd_len) {
1953         if (TESTLO(SSTAT0, SPIORDY))
1954             return;
1955
1956         SETPORT(SCSIDAT, CURRENT_SC->cmnd[CMD_I++]);
1957     }
1958 }
1959
1960 static void cmd_end(struct Scsi_Host *shpnt)
1961 {
1962     if(CMD_I<CURRENT_SC->cmd_len)
1963         scmd_printk(KERN_ERR, CURRENT_SC,
1964                 "command sent incompletely (%d/%d)\n",
1965                 CMD_I, CURRENT_SC->cmd_len);
1966     else
1967         aha152x_priv(CURRENT_SC)->sent_command++;
1968 }
1969
1970 /*
1971  * status phase
1972  *
1973  */
1974 static void status_run(struct Scsi_Host *shpnt)
1975 {
1976     if (TESTLO(SSTAT0, SPIORDY))
1977         return;
1978
1979     aha152x_priv(CURRENT_SC)->status = GETPORT(SCSIDAT);
1980
1981 }
1982
1983 /*
1984  * data in phase
1985  *
1986  */
1987 static void datai_init(struct Scsi_Host *shpnt)
1988 {
1989     SETPORT(DMACNTRL0, RSTFIFO);
1990     SETPORT(DMACNTRL0, RSTFIFO|ENDMA);
1991
1992     SETPORT(SXFRCTL0, CH1|CLRSTCNT);
1993     SETPORT(SXFRCTL0, CH1|SCSIEN|DMAEN);
1994
1995     SETPORT(SIMODE0, 0);
1996     SETPORT(SIMODE1, ENSCSIPERR | ENSCSIRST | ENPHASEMIS | ENBUSFREE);
1997
1998     DATA_LEN=0;
1999 }
2000
2001 static void datai_run(struct Scsi_Host *shpnt)
2002 {
2003     struct aha152x_cmd_priv *acp;
2004     unsigned long the_time;
2005     int fifodata, data_count;
2006
2007     /*
2008      * loop while the phase persists or the fifos are not empty
2009      *
2010      */
2011     while(TESTLO(DMASTAT, INTSTAT) || TESTLO(DMASTAT, DFIFOEMP) || TESTLO(SSTAT2, SEMPTY)) {
2012         /* FIXME: maybe this should be done by setting up
2013          * STCNT to trigger ENSWRAP interrupt, instead of
2014          * polling for DFIFOFULL
2015          */
2016         the_time=jiffies + 100*HZ;
2017         while(TESTLO(DMASTAT, DFIFOFULL|INTSTAT) && time_before(jiffies,the_time))
2018             barrier();
2019
2020         if(TESTLO(DMASTAT, DFIFOFULL|INTSTAT)) {
2021             scmd_printk(KERN_ERR, CURRENT_SC, "datai timeout\n");
2022             break;
2023         }
2024
2025         if(TESTHI(DMASTAT, DFIFOFULL)) {
2026             fifodata = 128;
2027         } else {
2028             the_time=jiffies + 100*HZ;
2029             while(TESTLO(SSTAT2, SEMPTY) && time_before(jiffies,the_time))
2030                 barrier();
2031
2032             if(TESTLO(SSTAT2, SEMPTY)) {
2033                 scmd_printk(KERN_ERR, CURRENT_SC,
2034                         "datai sempty timeout");
2035                 break;
2036             }
2037
2038             fifodata = GETPORT(FIFOSTAT);
2039         }
2040
2041         acp = aha152x_priv(CURRENT_SC);
2042         if (acp->this_residual > 0) {
2043             while (fifodata > 0 && acp->this_residual > 0) {
2044                 data_count = fifodata > acp->this_residual ?
2045                         acp->this_residual : fifodata;
2046                 fifodata -= data_count;
2047
2048                 if (data_count & 1) {
2049                     SETPORT(DMACNTRL0, ENDMA|_8BIT);
2050                     *acp->ptr++ = GETPORT(DATAPORT);
2051                     acp->this_residual--;
2052                     DATA_LEN++;
2053                     SETPORT(DMACNTRL0, ENDMA);
2054                 }
2055
2056                 if (data_count > 1) {
2057                     data_count >>= 1;
2058                     insw(DATAPORT, acp->ptr, data_count);
2059                     acp->ptr += 2 * data_count;
2060                     acp->this_residual -= 2 * data_count;
2061                     DATA_LEN += 2 * data_count;
2062                 }
2063
2064                 if (acp->this_residual == 0 &&
2065                     !sg_is_last(acp->buffer)) {
2066                     /* advance to next buffer */
2067                     acp->buffer = sg_next(acp->buffer);
2068                     acp->ptr = SG_ADDRESS(acp->buffer);
2069                     acp->this_residual = acp->buffer->length;
2070                 }
2071             }
2072         } else if (fifodata > 0) {
2073             scmd_printk(KERN_ERR, CURRENT_SC,
2074                     "no buffers left for %d(%d) bytes"
2075                     " (data overrun!?)\n",
2076                     fifodata, GETPORT(FIFOSTAT));
2077             SETPORT(DMACNTRL0, ENDMA|_8BIT);
2078             while(fifodata>0) {
2079                 GETPORT(DATAPORT);
2080                 fifodata--;
2081                 DATA_LEN++;
2082             }
2083             SETPORT(DMACNTRL0, ENDMA|_8BIT);
2084         }
2085     }
2086
2087     if(TESTLO(DMASTAT, INTSTAT) ||
2088        TESTLO(DMASTAT, DFIFOEMP) ||
2089        TESTLO(SSTAT2, SEMPTY) ||
2090        GETPORT(FIFOSTAT)>0) {
2091         /*
2092          * something went wrong, if there's something left in the fifos
2093          * or the phase didn't change
2094          */
2095         scmd_printk(KERN_ERR, CURRENT_SC,
2096                 "fifos should be empty and phase should have changed\n");
2097     }
2098
2099     if(DATA_LEN!=GETSTCNT()) {
2100         scmd_printk(KERN_ERR, CURRENT_SC,
2101                 "manual transfer count differs from automatic "
2102                 "(count=%d;stcnt=%d;diff=%d;fifostat=%d)",
2103                 DATA_LEN, GETSTCNT(), GETSTCNT()-DATA_LEN,
2104                 GETPORT(FIFOSTAT));
2105         mdelay(10000);
2106     }
2107 }
2108
2109 static void datai_end(struct Scsi_Host *shpnt)
2110 {
2111     CMD_INC_RESID(CURRENT_SC, -GETSTCNT());
2112
2113     SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2114     SETPORT(DMACNTRL0, 0);
2115 }
2116
2117 /*
2118  * data out phase
2119  *
2120  */
2121 static void datao_init(struct Scsi_Host *shpnt)
2122 {
2123     SETPORT(DMACNTRL0, WRITE_READ | RSTFIFO);
2124     SETPORT(DMACNTRL0, WRITE_READ | ENDMA);
2125
2126     SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2127     SETPORT(SXFRCTL0, CH1|SCSIEN|DMAEN);
2128
2129     SETPORT(SIMODE0, 0);
2130     SETPORT(SIMODE1, ENSCSIPERR | ENSCSIRST | ENPHASEMIS | ENBUSFREE );
2131
2132     DATA_LEN = scsi_get_resid(CURRENT_SC);
2133 }
2134
2135 static void datao_run(struct Scsi_Host *shpnt)
2136 {
2137     struct aha152x_cmd_priv *acp = aha152x_priv(CURRENT_SC);
2138     unsigned long the_time;
2139     int data_count;
2140
2141     /* until phase changes or all data sent */
2142     while (TESTLO(DMASTAT, INTSTAT) && acp->this_residual > 0) {
2143         data_count = 128;
2144         if (data_count > acp->this_residual)
2145             data_count = acp->this_residual;
2146
2147         if(TESTLO(DMASTAT, DFIFOEMP)) {
2148             scmd_printk(KERN_ERR, CURRENT_SC,
2149                     "datao fifo not empty (%d)",
2150                     GETPORT(FIFOSTAT));
2151             break;
2152         }
2153
2154         if(data_count & 1) {
2155             SETPORT(DMACNTRL0,WRITE_READ|ENDMA|_8BIT);
2156             SETPORT(DATAPORT, *acp->ptr++);
2157             acp->this_residual--;
2158             CMD_INC_RESID(CURRENT_SC, -1);
2159             SETPORT(DMACNTRL0,WRITE_READ|ENDMA);
2160         }
2161
2162         if(data_count > 1) {
2163             data_count >>= 1;
2164             outsw(DATAPORT, acp->ptr, data_count);
2165             acp->ptr += 2 * data_count;
2166             acp->this_residual -= 2 * data_count;
2167             CMD_INC_RESID(CURRENT_SC, -2 * data_count);
2168         }
2169
2170         if (acp->this_residual == 0 && !sg_is_last(acp->buffer)) {
2171             /* advance to next buffer */
2172             acp->buffer = sg_next(acp->buffer);
2173             acp->ptr = SG_ADDRESS(acp->buffer);
2174             acp->this_residual = acp->buffer->length;
2175         }
2176
2177         the_time=jiffies + 100*HZ;
2178         while(TESTLO(DMASTAT, DFIFOEMP|INTSTAT) && time_before(jiffies,the_time))
2179             barrier();
2180
2181         if(TESTLO(DMASTAT, DFIFOEMP|INTSTAT)) {
2182             scmd_printk(KERN_ERR, CURRENT_SC, "dataout timeout\n");
2183             break;
2184         }
2185     }
2186 }
2187
2188 static void datao_end(struct Scsi_Host *shpnt)
2189 {
2190     struct aha152x_cmd_priv *acp = aha152x_priv(CURRENT_SC);
2191
2192     if(TESTLO(DMASTAT, DFIFOEMP)) {
2193         u32 datao_cnt = GETSTCNT();
2194         int datao_out = DATA_LEN - scsi_get_resid(CURRENT_SC);
2195         int done;
2196         struct scatterlist *sg = scsi_sglist(CURRENT_SC);
2197
2198         CMD_INC_RESID(CURRENT_SC, datao_out - datao_cnt);
2199
2200         done = scsi_bufflen(CURRENT_SC) - scsi_get_resid(CURRENT_SC);
2201         /* Locate the first SG entry not yet sent */
2202         while (done > 0 && !sg_is_last(sg)) {
2203             if (done < sg->length)
2204                 break;
2205             done -= sg->length;
2206             sg = sg_next(sg);
2207         }
2208
2209         acp->buffer = sg;
2210         acp->ptr = SG_ADDRESS(acp->buffer) + done;
2211         acp->this_residual = acp->buffer->length - done;
2212     }
2213
2214     SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
2215     SETPORT(SXFRCTL0, CH1);
2216
2217     SETPORT(DMACNTRL0, 0);
2218 }
2219
2220 /*
2221  * figure out what state we're in
2222  *
2223  */
2224 static int update_state(struct Scsi_Host *shpnt)
2225 {
2226     int dataphase=0;
2227     unsigned int stat0 = GETPORT(SSTAT0);
2228     unsigned int stat1 = GETPORT(SSTAT1);
2229
2230     PREVSTATE = STATE;
2231     STATE=unknown;
2232
2233     if(stat1 & SCSIRSTI) {
2234         STATE=rsti;
2235         SETPORT(SCSISEQ,0);
2236         SETPORT(SSTAT1,SCSIRSTI);
2237     } else if (stat0 & SELDI && PREVSTATE == busfree) {
2238         STATE=seldi;
2239     } else if (stat0 & SELDO && CURRENT_SC &&
2240            (aha152x_priv(CURRENT_SC)->phase & selecting)) {
2241         STATE=seldo;
2242     } else if(stat1 & SELTO) {
2243         STATE=selto;
2244     } else if(stat1 & BUSFREE) {
2245         STATE=busfree;
2246         SETPORT(SSTAT1,BUSFREE);
2247     } else if(stat1 & SCSIPERR) {
2248         STATE=parerr;
2249         SETPORT(SSTAT1,SCSIPERR);
2250     } else if(stat1 & REQINIT) {
2251         switch(GETPORT(SCSISIG) & P_MASK) {
2252         case P_MSGI:    STATE=msgi; break;
2253         case P_MSGO:    STATE=msgo; break;
2254         case P_DATAO:   STATE=datao;    break;
2255         case P_DATAI:   STATE=datai;    break;
2256         case P_STATUS:  STATE=status;   break;
2257         case P_CMD: STATE=cmd;  break;
2258         }
2259         dataphase=1;
2260     }
2261
2262     if((stat0 & SELDI) && STATE!=seldi && !dataphase) {
2263         scmd_printk(KERN_INFO, CURRENT_SC, "reselection missed?");
2264     }
2265
2266     if(STATE!=PREVSTATE) {
2267         LASTSTATE=PREVSTATE;
2268     }
2269
2270     return dataphase;
2271 }
2272
2273 /*
2274  * handle parity error
2275  *
2276  * FIXME: in which phase?
2277  *
2278  */
2279 static void parerr_run(struct Scsi_Host *shpnt)
2280 {
2281     scmd_printk(KERN_ERR, CURRENT_SC, "parity error\n");
2282     done(shpnt, SAM_STAT_GOOD, DID_PARITY);
2283 }
2284
2285 /*
2286  * handle reset in
2287  *
2288  */
2289 static void rsti_run(struct Scsi_Host *shpnt)
2290 {
2291     struct scsi_cmnd *ptr;
2292
2293     shost_printk(KERN_NOTICE, shpnt, "scsi reset in\n");
2294
2295     ptr=DISCONNECTED_SC;
2296     while(ptr) {
2297         struct scsi_cmnd *next = SCNEXT(ptr);
2298
2299         if (!ptr->device->soft_reset) {
2300             remove_SC(&DISCONNECTED_SC, ptr);
2301
2302             kfree(ptr->host_scribble);
2303             ptr->host_scribble=NULL;
2304
2305             set_host_byte(ptr, DID_RESET);
2306             aha152x_scsi_done(ptr);
2307         }
2308
2309         ptr = next;
2310     }
2311
2312     if(CURRENT_SC && !CURRENT_SC->device->soft_reset)
2313         done(shpnt, SAM_STAT_GOOD, DID_RESET);
2314 }
2315
2316
2317 /*
2318  * bottom-half handler
2319  *
2320  */
2321 static void is_complete(struct Scsi_Host *shpnt)
2322 {
2323     int dataphase;
2324     unsigned long flags;
2325     int pending;
2326
2327     if(!shpnt)
2328         return;
2329
2330     DO_LOCK(flags);
2331
2332     if( HOSTDATA(shpnt)->service==0 )  {
2333         DO_UNLOCK(flags);
2334         return;
2335     }
2336
2337     HOSTDATA(shpnt)->service = 0;
2338
2339     if(HOSTDATA(shpnt)->in_intr) {
2340         DO_UNLOCK(flags);
2341         /* aha152x_error never returns.. */
2342         aha152x_error(shpnt, "bottom-half already running!?");
2343     }
2344     HOSTDATA(shpnt)->in_intr++;
2345
2346     /*
2347      * loop while there are interrupt conditions pending
2348      *
2349      */
2350     do {
2351         unsigned long start = jiffies;
2352         DO_UNLOCK(flags);
2353
2354         dataphase=update_state(shpnt);
2355
2356         /*
2357          * end previous state
2358          *
2359          */
2360         if(PREVSTATE!=STATE && states[PREVSTATE].end)
2361             states[PREVSTATE].end(shpnt);
2362
2363         /*
2364          * disable SPIO mode if previous phase used it
2365          * and this one doesn't
2366          *
2367          */
2368         if(states[PREVSTATE].spio && !states[STATE].spio) {
2369             SETPORT(SXFRCTL0, CH1);
2370             SETPORT(DMACNTRL0, 0);
2371             if(CURRENT_SC)
2372                 aha152x_priv(CURRENT_SC)->phase &= ~spiordy;
2373         }
2374
2375         /*
2376          * accept current dataphase phase
2377          *
2378          */
2379         if(dataphase) {
2380             SETPORT(SSTAT0, REQINIT);
2381             SETPORT(SCSISIG, GETPORT(SCSISIG) & P_MASK);
2382             SETPORT(SSTAT1, PHASECHG);
2383         }
2384
2385         /*
2386          * enable SPIO mode if previous didn't use it
2387          * and this one does
2388          *
2389          */
2390         if(!states[PREVSTATE].spio && states[STATE].spio) {
2391             SETPORT(DMACNTRL0, 0);
2392             SETPORT(SXFRCTL0, CH1|SPIOEN);
2393             if(CURRENT_SC)
2394                 aha152x_priv(CURRENT_SC)->phase |= spiordy;
2395         }
2396
2397         /*
2398          * initialize for new state
2399          *
2400          */
2401         if(PREVSTATE!=STATE && states[STATE].init)
2402             states[STATE].init(shpnt);
2403
2404         /*
2405          * handle current state
2406          *
2407          */
2408         if(states[STATE].run)
2409             states[STATE].run(shpnt);
2410         else
2411             scmd_printk(KERN_ERR, CURRENT_SC,
2412                     "unexpected state (%x)\n", STATE);
2413
2414         /*
2415          * setup controller to interrupt on
2416          * the next expected condition and
2417          * loop if it's already there
2418          *
2419          */
2420         DO_LOCK(flags);
2421         pending=setup_expected_interrupts(shpnt);
2422 #if defined(AHA152X_STAT)
2423         HOSTDATA(shpnt)->count[STATE]++;
2424         if(PREVSTATE!=STATE)
2425             HOSTDATA(shpnt)->count_trans[STATE]++;
2426         HOSTDATA(shpnt)->time[STATE] += jiffies-start;
2427 #endif
2428
2429     } while(pending);
2430
2431     /*
2432      * enable interrupts and leave bottom-half
2433      *
2434      */
2435     HOSTDATA(shpnt)->in_intr--;
2436     SETBITS(DMACNTRL0, INTEN);
2437     DO_UNLOCK(flags);
2438 }
2439
2440
2441 /*
2442  * Dump the current driver status and panic
2443  */
2444 static void aha152x_error(struct Scsi_Host *shpnt, char *msg)
2445 {
2446     shost_printk(KERN_EMERG, shpnt, "%s\n", msg);
2447     show_queues(shpnt);
2448     panic("aha152x panic\n");
2449 }
2450
2451 /*
2452  * display enabled interrupts
2453  */
2454 static void disp_enintr(struct Scsi_Host *shpnt)
2455 {
2456     int s0, s1;
2457
2458     s0 = GETPORT(SIMODE0);
2459     s1 = GETPORT(SIMODE1);
2460
2461     shost_printk(KERN_DEBUG, shpnt,
2462              "enabled interrupts (%s%s%s%s%s%s%s%s%s%s%s%s%s%s)\n",
2463              (s0 & ENSELDO) ? "ENSELDO " : "",
2464              (s0 & ENSELDI) ? "ENSELDI " : "",
2465              (s0 & ENSELINGO) ? "ENSELINGO " : "",
2466              (s0 & ENSWRAP) ? "ENSWRAP " : "",
2467              (s0 & ENSDONE) ? "ENSDONE " : "",
2468              (s0 & ENSPIORDY) ? "ENSPIORDY " : "",
2469              (s0 & ENDMADONE) ? "ENDMADONE " : "",
2470              (s1 & ENSELTIMO) ? "ENSELTIMO " : "",
2471              (s1 & ENATNTARG) ? "ENATNTARG " : "",
2472              (s1 & ENPHASEMIS) ? "ENPHASEMIS " : "",
2473              (s1 & ENBUSFREE) ? "ENBUSFREE " : "",
2474              (s1 & ENSCSIPERR) ? "ENSCSIPERR " : "",
2475              (s1 & ENPHASECHG) ? "ENPHASECHG " : "",
2476              (s1 & ENREQINIT) ? "ENREQINIT " : "");
2477 }
2478
2479 /*
2480  * Show the command data of a command
2481  */
2482 static void show_command(struct scsi_cmnd *ptr)
2483 {
2484     const int phase = aha152x_priv(ptr)->phase;
2485
2486     scsi_print_command(ptr);
2487     scmd_printk(KERN_DEBUG, ptr,
2488             "request_bufflen=%d; resid=%d; "
2489             "phase |%s%s%s%s%s%s%s%s%s; next=0x%p",
2490             scsi_bufflen(ptr), scsi_get_resid(ptr),
2491             phase & not_issued ? "not issued|" : "",
2492             phase & selecting ? "selecting|" : "",
2493             phase & identified ? "identified|" : "",
2494             phase & disconnected ? "disconnected|" : "",
2495             phase & completed ? "completed|" : "",
2496             phase & spiordy ? "spiordy|" : "",
2497             phase & syncneg ? "syncneg|" : "",
2498             phase & aborted ? "aborted|" : "",
2499             phase & resetted ? "resetted|" : "",
2500             SCDATA(ptr) ? SCNEXT(ptr) : NULL);
2501 }
2502
2503 /*
2504  * Dump the queued data
2505  */
2506 static void show_queues(struct Scsi_Host *shpnt)
2507 {
2508     struct scsi_cmnd *ptr;
2509     unsigned long flags;
2510
2511     DO_LOCK(flags);
2512     printk(KERN_DEBUG "\nqueue status:\nissue_SC:\n");
2513     for (ptr = ISSUE_SC; ptr; ptr = SCNEXT(ptr))
2514         show_command(ptr);
2515     DO_UNLOCK(flags);
2516
2517     printk(KERN_DEBUG "current_SC:\n");
2518     if (CURRENT_SC)
2519         show_command(CURRENT_SC);
2520     else
2521         printk(KERN_DEBUG "none\n");
2522
2523     printk(KERN_DEBUG "disconnected_SC:\n");
2524     for (ptr = DISCONNECTED_SC; ptr; ptr = SCDATA(ptr) ? SCNEXT(ptr) : NULL)
2525         show_command(ptr);
2526
2527     disp_enintr(shpnt);
2528 }
2529
2530 static void get_command(struct seq_file *m, struct scsi_cmnd * ptr)
2531 {
2532     struct aha152x_cmd_priv *acp = aha152x_priv(ptr);
2533     const int phase = acp->phase;
2534     int i;
2535
2536     seq_printf(m, "%p: target=%d; lun=%d; cmnd=( ",
2537         ptr, ptr->device->id, (u8)ptr->device->lun);
2538
2539     for (i = 0; i < COMMAND_SIZE(ptr->cmnd[0]); i++)
2540         seq_printf(m, "0x%02x ", ptr->cmnd[i]);
2541
2542     seq_printf(m, "); resid=%d; residual=%d; buffers=%d; phase |",
2543         scsi_get_resid(ptr), acp->this_residual,
2544         sg_nents(acp->buffer) - 1);
2545
2546     if (phase & not_issued)
2547         seq_puts(m, "not issued|");
2548     if (phase & selecting)
2549         seq_puts(m, "selecting|");
2550     if (phase & disconnected)
2551         seq_puts(m, "disconnected|");
2552     if (phase & aborted)
2553         seq_puts(m, "aborted|");
2554     if (phase & identified)
2555         seq_puts(m, "identified|");
2556     if (phase & completed)
2557         seq_puts(m, "completed|");
2558     if (phase & spiordy)
2559         seq_puts(m, "spiordy|");
2560     if (phase & syncneg)
2561         seq_puts(m, "syncneg|");
2562     seq_printf(m, "; next=0x%p\n", SCNEXT(ptr));
2563 }
2564
2565 static void get_ports(struct seq_file *m, struct Scsi_Host *shpnt)
2566 {
2567     int s;
2568
2569     seq_printf(m, "\n%s: %s(%s) ", CURRENT_SC ? "on bus" : "waiting", states[STATE].name, states[PREVSTATE].name);
2570
2571     s = GETPORT(SCSISEQ);
2572     seq_puts(m, "SCSISEQ( ");
2573     if (s & TEMODEO)
2574         seq_puts(m, "TARGET MODE ");
2575     if (s & ENSELO)
2576         seq_puts(m, "SELO ");
2577     if (s & ENSELI)
2578         seq_puts(m, "SELI ");
2579     if (s & ENRESELI)
2580         seq_puts(m, "RESELI ");
2581     if (s & ENAUTOATNO)
2582         seq_puts(m, "AUTOATNO ");
2583     if (s & ENAUTOATNI)
2584         seq_puts(m, "AUTOATNI ");
2585     if (s & ENAUTOATNP)
2586         seq_puts(m, "AUTOATNP ");
2587     if (s & SCSIRSTO)
2588         seq_puts(m, "SCSIRSTO ");
2589     seq_puts(m, ");");
2590
2591     seq_puts(m, " SCSISIG(");
2592     s = GETPORT(SCSISIG);
2593     switch (s & P_MASK) {
2594     case P_DATAO:
2595         seq_puts(m, "DATA OUT");
2596         break;
2597     case P_DATAI:
2598         seq_puts(m, "DATA IN");
2599         break;
2600     case P_CMD:
2601         seq_puts(m, "COMMAND");
2602         break;
2603     case P_STATUS:
2604         seq_puts(m, "STATUS");
2605         break;
2606     case P_MSGO:
2607         seq_puts(m, "MESSAGE OUT");
2608         break;
2609     case P_MSGI:
2610         seq_puts(m, "MESSAGE IN");
2611         break;
2612     default:
2613         seq_puts(m, "*invalid*");
2614         break;
2615     }
2616
2617     seq_puts(m, "); ");
2618
2619     seq_printf(m, "INTSTAT (%s); ", TESTHI(DMASTAT, INTSTAT) ? "hi" : "lo");
2620
2621     seq_puts(m, "SSTAT( ");
2622     s = GETPORT(SSTAT0);
2623     if (s & TARGET)
2624         seq_puts(m, "TARGET ");
2625     if (s & SELDO)
2626         seq_puts(m, "SELDO ");
2627     if (s & SELDI)
2628         seq_puts(m, "SELDI ");
2629     if (s & SELINGO)
2630         seq_puts(m, "SELINGO ");
2631     if (s & SWRAP)
2632         seq_puts(m, "SWRAP ");
2633     if (s & SDONE)
2634         seq_puts(m, "SDONE ");
2635     if (s & SPIORDY)
2636         seq_puts(m, "SPIORDY ");
2637     if (s & DMADONE)
2638         seq_puts(m, "DMADONE ");
2639
2640     s = GETPORT(SSTAT1);
2641     if (s & SELTO)
2642         seq_puts(m, "SELTO ");
2643     if (s & ATNTARG)
2644         seq_puts(m, "ATNTARG ");
2645     if (s & SCSIRSTI)
2646         seq_puts(m, "SCSIRSTI ");
2647     if (s & PHASEMIS)
2648         seq_puts(m, "PHASEMIS ");
2649     if (s & BUSFREE)
2650         seq_puts(m, "BUSFREE ");
2651     if (s & SCSIPERR)
2652         seq_puts(m, "SCSIPERR ");
2653     if (s & PHASECHG)
2654         seq_puts(m, "PHASECHG ");
2655     if (s & REQINIT)
2656         seq_puts(m, "REQINIT ");
2657     seq_puts(m, "); ");
2658
2659
2660     seq_puts(m, "SSTAT( ");
2661
2662     s = GETPORT(SSTAT0) & GETPORT(SIMODE0);
2663
2664     if (s & TARGET)
2665         seq_puts(m, "TARGET ");
2666     if (s & SELDO)
2667         seq_puts(m, "SELDO ");
2668     if (s & SELDI)
2669         seq_puts(m, "SELDI ");
2670     if (s & SELINGO)
2671         seq_puts(m, "SELINGO ");
2672     if (s & SWRAP)
2673         seq_puts(m, "SWRAP ");
2674     if (s & SDONE)
2675         seq_puts(m, "SDONE ");
2676     if (s & SPIORDY)
2677         seq_puts(m, "SPIORDY ");
2678     if (s & DMADONE)
2679         seq_puts(m, "DMADONE ");
2680
2681     s = GETPORT(SSTAT1) & GETPORT(SIMODE1);
2682
2683     if (s & SELTO)
2684         seq_puts(m, "SELTO ");
2685     if (s & ATNTARG)
2686         seq_puts(m, "ATNTARG ");
2687     if (s & SCSIRSTI)
2688         seq_puts(m, "SCSIRSTI ");
2689     if (s & PHASEMIS)
2690         seq_puts(m, "PHASEMIS ");
2691     if (s & BUSFREE)
2692         seq_puts(m, "BUSFREE ");
2693     if (s & SCSIPERR)
2694         seq_puts(m, "SCSIPERR ");
2695     if (s & PHASECHG)
2696         seq_puts(m, "PHASECHG ");
2697     if (s & REQINIT)
2698         seq_puts(m, "REQINIT ");
2699     seq_puts(m, "); ");
2700
2701     seq_puts(m, "SXFRCTL0( ");
2702
2703     s = GETPORT(SXFRCTL0);
2704     if (s & SCSIEN)
2705         seq_puts(m, "SCSIEN ");
2706     if (s & DMAEN)
2707         seq_puts(m, "DMAEN ");
2708     if (s & CH1)
2709         seq_puts(m, "CH1 ");
2710     if (s & CLRSTCNT)
2711         seq_puts(m, "CLRSTCNT ");
2712     if (s & SPIOEN)
2713         seq_puts(m, "SPIOEN ");
2714     if (s & CLRCH1)
2715         seq_puts(m, "CLRCH1 ");
2716     seq_puts(m, "); ");
2717
2718     seq_puts(m, "SIGNAL( ");
2719
2720     s = GETPORT(SCSISIG);
2721     if (s & SIG_ATNI)
2722         seq_puts(m, "ATNI ");
2723     if (s & SIG_SELI)
2724         seq_puts(m, "SELI ");
2725     if (s & SIG_BSYI)
2726         seq_puts(m, "BSYI ");
2727     if (s & SIG_REQI)
2728         seq_puts(m, "REQI ");
2729     if (s & SIG_ACKI)
2730         seq_puts(m, "ACKI ");
2731     seq_puts(m, "); ");
2732
2733     seq_printf(m, "SELID(%02x), ", GETPORT(SELID));
2734
2735     seq_printf(m, "STCNT(%d), ", GETSTCNT());
2736
2737     seq_puts(m, "SSTAT2( ");
2738
2739     s = GETPORT(SSTAT2);
2740     if (s & SOFFSET)
2741         seq_puts(m, "SOFFSET ");
2742     if (s & SEMPTY)
2743         seq_puts(m, "SEMPTY ");
2744     if (s & SFULL)
2745         seq_puts(m, "SFULL ");
2746     seq_printf(m, "); SFCNT (%d); ", s & (SFULL | SFCNT));
2747
2748     s = GETPORT(SSTAT3);
2749     seq_printf(m, "SCSICNT (%d), OFFCNT(%d), ", (s & 0xf0) >> 4, s & 0x0f);
2750
2751     seq_puts(m, "SSTAT4( ");
2752     s = GETPORT(SSTAT4);
2753     if (s & SYNCERR)
2754         seq_puts(m, "SYNCERR ");
2755     if (s & FWERR)
2756         seq_puts(m, "FWERR ");
2757     if (s & FRERR)
2758         seq_puts(m, "FRERR ");
2759     seq_puts(m, "); ");
2760
2761     seq_puts(m, "DMACNTRL0( ");
2762     s = GETPORT(DMACNTRL0);
2763     seq_printf(m, "%s ", s & _8BIT ? "8BIT" : "16BIT");
2764     seq_printf(m, "%s ", s & DMA ? "DMA" : "PIO");
2765     seq_printf(m, "%s ", s & WRITE_READ ? "WRITE" : "READ");
2766     if (s & ENDMA)
2767         seq_puts(m, "ENDMA ");
2768     if (s & INTEN)
2769         seq_puts(m, "INTEN ");
2770     if (s & RSTFIFO)
2771         seq_puts(m, "RSTFIFO ");
2772     if (s & SWINT)
2773         seq_puts(m, "SWINT ");
2774     seq_puts(m, "); ");
2775
2776     seq_puts(m, "DMASTAT( ");
2777     s = GETPORT(DMASTAT);
2778     if (s & ATDONE)
2779         seq_puts(m, "ATDONE ");
2780     if (s & WORDRDY)
2781         seq_puts(m, "WORDRDY ");
2782     if (s & DFIFOFULL)
2783         seq_puts(m, "DFIFOFULL ");
2784     if (s & DFIFOEMP)
2785         seq_puts(m, "DFIFOEMP ");
2786     seq_puts(m, ")\n");
2787
2788     seq_puts(m, "enabled interrupts( ");
2789
2790     s = GETPORT(SIMODE0);
2791     if (s & ENSELDO)
2792         seq_puts(m, "ENSELDO ");
2793     if (s & ENSELDI)
2794         seq_puts(m, "ENSELDI ");
2795     if (s & ENSELINGO)
2796         seq_puts(m, "ENSELINGO ");
2797     if (s & ENSWRAP)
2798         seq_puts(m, "ENSWRAP ");
2799     if (s & ENSDONE)
2800         seq_puts(m, "ENSDONE ");
2801     if (s & ENSPIORDY)
2802         seq_puts(m, "ENSPIORDY ");
2803     if (s & ENDMADONE)
2804         seq_puts(m, "ENDMADONE ");
2805
2806     s = GETPORT(SIMODE1);
2807     if (s & ENSELTIMO)
2808         seq_puts(m, "ENSELTIMO ");
2809     if (s & ENATNTARG)
2810         seq_puts(m, "ENATNTARG ");
2811     if (s & ENPHASEMIS)
2812         seq_puts(m, "ENPHASEMIS ");
2813     if (s & ENBUSFREE)
2814         seq_puts(m, "ENBUSFREE ");
2815     if (s & ENSCSIPERR)
2816         seq_puts(m, "ENSCSIPERR ");
2817     if (s & ENPHASECHG)
2818         seq_puts(m, "ENPHASECHG ");
2819     if (s & ENREQINIT)
2820         seq_puts(m, "ENREQINIT ");
2821     seq_puts(m, ")\n");
2822 }
2823
2824 static int aha152x_set_info(struct Scsi_Host *shpnt, char *buffer, int length)
2825 {
2826     if(!shpnt || !buffer || length<8 || strncmp("aha152x ", buffer, 8)!=0)
2827         return -EINVAL;
2828
2829 #if defined(AHA152X_STAT)
2830     if(length>13 && strncmp("reset", buffer+8, 5)==0) {
2831         int i;
2832
2833         HOSTDATA(shpnt)->total_commands=0;
2834         HOSTDATA(shpnt)->disconnections=0;
2835         HOSTDATA(shpnt)->busfree_without_any_action=0;
2836         HOSTDATA(shpnt)->busfree_without_old_command=0;
2837         HOSTDATA(shpnt)->busfree_without_new_command=0;
2838         HOSTDATA(shpnt)->busfree_without_done_command=0;
2839         HOSTDATA(shpnt)->busfree_with_check_condition=0;
2840         for (i = idle; i<maxstate; i++) {
2841             HOSTDATA(shpnt)->count[i]=0;
2842             HOSTDATA(shpnt)->count_trans[i]=0;
2843             HOSTDATA(shpnt)->time[i]=0;
2844         }
2845
2846         shost_printk(KERN_INFO, shpnt, "aha152x: stats reset.\n");
2847
2848     } else
2849 #endif
2850     {
2851         return -EINVAL;
2852     }
2853
2854
2855     return length;
2856 }
2857
2858 static int aha152x_show_info(struct seq_file *m, struct Scsi_Host *shpnt)
2859 {
2860     int i;
2861     struct scsi_cmnd *ptr;
2862     unsigned long flags;
2863
2864     seq_puts(m, AHA152X_REVID "\n");
2865
2866     seq_printf(m, "ioports 0x%04lx to 0x%04lx\n",
2867         shpnt->io_port, shpnt->io_port + shpnt->n_io_port - 1);
2868     seq_printf(m, "interrupt 0x%02x\n", shpnt->irq);
2869     seq_printf(m, "disconnection/reconnection %s\n",
2870         RECONNECT ? "enabled" : "disabled");
2871     seq_printf(m, "parity checking %s\n",
2872         PARITY ? "enabled" : "disabled");
2873     seq_printf(m, "synchronous transfers %s\n",
2874         SYNCHRONOUS ? "enabled" : "disabled");
2875     seq_printf(m, "%d commands currently queued\n", HOSTDATA(shpnt)->commands);
2876
2877     if(SYNCHRONOUS) {
2878         seq_puts(m, "synchronously operating targets (tick=50 ns):\n");
2879         for (i = 0; i < 8; i++)
2880             if (HOSTDATA(shpnt)->syncrate[i] & 0x7f)
2881                 seq_printf(m, "target %d: period %dT/%dns; req/ack offset %d\n",
2882                     i,
2883                     (((HOSTDATA(shpnt)->syncrate[i] & 0x70) >> 4) + 2),
2884                     (((HOSTDATA(shpnt)->syncrate[i] & 0x70) >> 4) + 2) * 50,
2885                     HOSTDATA(shpnt)->syncrate[i] & 0x0f);
2886     }
2887     seq_puts(m, "\nqueue status:\n");
2888     DO_LOCK(flags);
2889     if (ISSUE_SC) {
2890         seq_puts(m, "not yet issued commands:\n");
2891         for (ptr = ISSUE_SC; ptr; ptr = SCNEXT(ptr))
2892             get_command(m, ptr);
2893     } else
2894         seq_puts(m, "no not yet issued commands\n");
2895     DO_UNLOCK(flags);
2896
2897     if (CURRENT_SC) {
2898         seq_puts(m, "current command:\n");
2899         get_command(m, CURRENT_SC);
2900     } else
2901         seq_puts(m, "no current command\n");
2902
2903     if (DISCONNECTED_SC) {
2904         seq_puts(m, "disconnected commands:\n");
2905         for (ptr = DISCONNECTED_SC; ptr; ptr = SCNEXT(ptr))
2906             get_command(m, ptr);
2907     } else
2908         seq_puts(m, "no disconnected commands\n");
2909
2910     get_ports(m, shpnt);
2911
2912 #if defined(AHA152X_STAT)
2913     seq_printf(m, "statistics:\n"
2914         "total commands:               %d\n"
2915         "disconnections:               %d\n"
2916         "busfree with check condition: %d\n"
2917         "busfree without old command:  %d\n"
2918         "busfree without new command:  %d\n"
2919         "busfree without done command: %d\n"
2920         "busfree without any action:   %d\n"
2921         "state      "
2922         "transitions  "
2923         "count        "
2924         "time\n",
2925         HOSTDATA(shpnt)->total_commands,
2926         HOSTDATA(shpnt)->disconnections,
2927         HOSTDATA(shpnt)->busfree_with_check_condition,
2928         HOSTDATA(shpnt)->busfree_without_old_command,
2929         HOSTDATA(shpnt)->busfree_without_new_command,
2930         HOSTDATA(shpnt)->busfree_without_done_command,
2931         HOSTDATA(shpnt)->busfree_without_any_action);
2932     for(i=0; i<maxstate; i++) {
2933         seq_printf(m, "%-10s %-12d %-12d %-12ld\n",
2934             states[i].name,
2935             HOSTDATA(shpnt)->count_trans[i],
2936             HOSTDATA(shpnt)->count[i],
2937             HOSTDATA(shpnt)->time[i]);
2938     }
2939 #endif
2940     return 0;
2941 }
2942
2943 static int aha152x_adjust_queue(struct scsi_device *device)
2944 {
2945     blk_queue_bounce_limit(device->request_queue, BLK_BOUNCE_HIGH);
2946     return 0;
2947 }
2948
2949 static struct scsi_host_template aha152x_driver_template = {
2950     .module             = THIS_MODULE,
2951     .name               = AHA152X_REVID,
2952     .proc_name          = "aha152x",
2953     .show_info          = aha152x_show_info,
2954     .write_info         = aha152x_set_info,
2955     .queuecommand           = aha152x_queue,
2956     .eh_abort_handler       = aha152x_abort,
2957     .eh_device_reset_handler    = aha152x_device_reset,
2958     .eh_bus_reset_handler       = aha152x_bus_reset,
2959     .bios_param         = aha152x_biosparam,
2960     .can_queue          = 1,
2961     .this_id            = 7,
2962     .sg_tablesize           = SG_ALL,
2963     .dma_boundary           = PAGE_SIZE - 1,
2964     .slave_alloc            = aha152x_adjust_queue,
2965     .cmd_size           = sizeof(struct aha152x_cmd_priv),
2966 };
2967
2968 #if !defined(AHA152X_PCMCIA)
2969 static int setup_count;
2970 static struct aha152x_setup setup[2];
2971
2972 /* possible i/o addresses for the AIC-6260; default first */
2973 static unsigned short ports[] = { 0x340, 0x140 };
2974
2975 #if !defined(SKIP_BIOSTEST)
2976 /* possible locations for the Adaptec BIOS; defaults first */
2977 static unsigned int addresses[] =
2978 {
2979     0xdc000,        /* default first */
2980     0xc8000,
2981     0xcc000,
2982     0xd0000,
2983     0xd4000,
2984     0xd8000,
2985     0xe0000,
2986     0xeb800,        /* VTech Platinum SMP */
2987     0xf0000,
2988 };
2989
2990 /* signatures for various AIC-6[23]60 based controllers.
2991    The point in detecting signatures is to avoid useless and maybe
2992    harmful probes on ports. I'm not sure that all listed boards pass
2993    auto-configuration. For those which fail the BIOS signature is
2994    obsolete, because user intervention to supply the configuration is
2995    needed anyway.  May be an information whether or not the BIOS supports
2996    extended translation could be also useful here. */
2997 static struct signature {
2998     unsigned char *signature;
2999     int sig_offset;
3000     int sig_length;
3001 } signatures[] =
3002 {
3003     { "Adaptec AHA-1520 BIOS",  0x102e, 21 },
3004         /* Adaptec 152x */
3005     { "Adaptec AHA-1520B",      0x000b, 17 },
3006         /* Adaptec 152x rev B */
3007     { "Adaptec AHA-1520B",      0x0026, 17 },
3008         /* Iomega Jaz Jet ISA (AIC6370Q) */
3009     { "Adaptec ASW-B626 BIOS",  0x1029, 21 },
3010         /* on-board controller */
3011     { "Adaptec BIOS: ASW-B626", 0x000f, 22 },
3012         /* on-board controller */
3013     { "Adaptec ASW-B626 S2",    0x2e6c, 19 },
3014         /* on-board controller */
3015     { "Adaptec BIOS:AIC-6360",  0x000c, 21 },
3016         /* on-board controller */
3017     { "ScsiPro SP-360 BIOS",    0x2873, 19 },
3018         /* ScsiPro-Controller  */
3019     { "GA-400 LOCAL BUS SCSI BIOS", 0x102e, 26 },
3020         /* Gigabyte Local-Bus-SCSI */
3021     { "Adaptec BIOS:AVA-282X",  0x000c, 21 },
3022         /* Adaptec 282x */
3023     { "Adaptec IBM Dock II SCSI",   0x2edd, 24 },
3024         /* IBM Thinkpad Dock II */
3025     { "Adaptec BIOS:AHA-1532P",     0x001c, 22 },
3026         /* IBM Thinkpad Dock II SCSI */
3027     { "DTC3520A Host Adapter BIOS", 0x318a, 26 },
3028         /* DTC 3520A ISA SCSI */
3029 };
3030 #endif /* !SKIP_BIOSTEST */
3031
3032 /*
3033  * Test, if port_base is valid.
3034  *
3035  */
3036 static int aha152x_porttest(int io_port)
3037 {
3038     int i;
3039
3040     SETPORT(io_port + O_DMACNTRL1, 0);  /* reset stack pointer */
3041     for (i = 0; i < 16; i++)
3042         SETPORT(io_port + O_STACK, i);
3043
3044     SETPORT(io_port + O_DMACNTRL1, 0);  /* reset stack pointer */
3045     for (i = 0; i < 16 && GETPORT(io_port + O_STACK) == i; i++)
3046         ;
3047
3048     return (i == 16);
3049 }
3050
3051 static int tc1550_porttest(int io_port)
3052 {
3053     int i;
3054
3055     SETPORT(io_port + O_TC_DMACNTRL1, 0);   /* reset stack pointer */
3056     for (i = 0; i < 16; i++)
3057         SETPORT(io_port + O_STACK, i);
3058
3059     SETPORT(io_port + O_TC_DMACNTRL1, 0);   /* reset stack pointer */
3060     for (i = 0; i < 16 && GETPORT(io_port + O_TC_STACK) == i; i++)
3061         ;
3062
3063     return (i == 16);
3064 }
3065
3066
3067 static int checksetup(struct aha152x_setup *setup)
3068 {
3069     int i;
3070     for (i = 0; i < ARRAY_SIZE(ports) && (setup->io_port != ports[i]); i++)
3071         ;
3072
3073     if (i == ARRAY_SIZE(ports))
3074         return 0;
3075
3076     if (!request_region(setup->io_port, IO_RANGE, "aha152x")) {
3077         printk(KERN_ERR "aha152x: io port 0x%x busy.\n", setup->io_port);
3078         return 0;
3079     }
3080
3081     if( aha152x_porttest(setup->io_port) ) {
3082         setup->tc1550=0;
3083     } else if( tc1550_porttest(setup->io_port) ) {
3084         setup->tc1550=1;
3085     } else {
3086         release_region(setup->io_port, IO_RANGE);
3087         return 0;
3088     }
3089
3090     release_region(setup->io_port, IO_RANGE);
3091
3092     if ((setup->irq < IRQ_MIN) || (setup->irq > IRQ_MAX))
3093         return 0;
3094
3095     if ((setup->scsiid < 0) || (setup->scsiid > 7))
3096         return 0;
3097
3098     if ((setup->reconnect < 0) || (setup->reconnect > 1))
3099         return 0;
3100
3101     if ((setup->parity < 0) || (setup->parity > 1))
3102         return 0;
3103
3104     if ((setup->synchronous < 0) || (setup->synchronous > 1))
3105         return 0;
3106
3107     if ((setup->ext_trans < 0) || (setup->ext_trans > 1))
3108         return 0;
3109
3110
3111     return 1;
3112 }
3113
3114
3115 static int __init aha152x_init(void)
3116 {
3117     int i, j, ok;
3118 #if defined(AUTOCONF)
3119     aha152x_config conf;
3120 #endif
3121 #ifdef __ISAPNP__
3122     struct pnp_dev *dev=NULL, *pnpdev[2] = {NULL, NULL};
3123 #endif
3124
3125     if ( setup_count ) {
3126         printk(KERN_INFO "aha152x: processing commandline: ");
3127
3128         for (i = 0; i<setup_count; i++) {
3129             if (!checksetup(&setup[i])) {
3130                 printk(KERN_ERR "\naha152x: %s\n", setup[i].conf);
3131                 printk(KERN_ERR "aha152x: invalid line\n");
3132             }
3133         }
3134         printk("ok\n");
3135     }
3136
3137 #if defined(SETUP0)
3138     if (setup_count < ARRAY_SIZE(setup)) {
3139         struct aha152x_setup override = SETUP0;
3140
3141         if (setup_count == 0 || (override.io_port != setup[0].io_port)) {
3142             if (!checksetup(&override)) {
3143                 printk(KERN_ERR "\naha152x: invalid override SETUP0={0x%x,%d,%d,%d,%d,%d,%d,%d}\n",
3144                        override.io_port,
3145                        override.irq,
3146                        override.scsiid,
3147                        override.reconnect,
3148                        override.parity,
3149                        override.synchronous,
3150                        override.delay,
3151                        override.ext_trans);
3152             } else
3153                 setup[setup_count++] = override;
3154         }
3155     }
3156 #endif
3157
3158 #if defined(SETUP1)
3159     if (setup_count < ARRAY_SIZE(setup)) {
3160         struct aha152x_setup override = SETUP1;
3161
3162         if (setup_count == 0 || (override.io_port != setup[0].io_port)) {
3163             if (!checksetup(&override)) {
3164                 printk(KERN_ERR "\naha152x: invalid override SETUP1={0x%x,%d,%d,%d,%d,%d,%d,%d}\n",
3165                        override.io_port,
3166                        override.irq,
3167                        override.scsiid,
3168                        override.reconnect,
3169                        override.parity,
3170                        override.synchronous,
3171                        override.delay,
3172                        override.ext_trans);
3173             } else
3174                 setup[setup_count++] = override;
3175         }
3176     }
3177 #endif
3178
3179 #if defined(MODULE)
3180     if (setup_count<ARRAY_SIZE(setup) && (aha152x[0]!=0 || io[0]!=0 || irq[0]!=0)) {
3181         if(aha152x[0]!=0) {
3182             setup[setup_count].conf        = "";
3183             setup[setup_count].io_port     = aha152x[0];
3184             setup[setup_count].irq         = aha152x[1];
3185             setup[setup_count].scsiid      = aha152x[2];
3186             setup[setup_count].reconnect   = aha152x[3];
3187             setup[setup_count].parity      = aha152x[4];
3188             setup[setup_count].synchronous = aha152x[5];
3189             setup[setup_count].delay       = aha152x[6];
3190             setup[setup_count].ext_trans   = aha152x[7];
3191         } else if (io[0] != 0 || irq[0] != 0) {
3192             if(io[0]!=0)  setup[setup_count].io_port = io[0];
3193             if(irq[0]!=0) setup[setup_count].irq     = irq[0];
3194
3195             setup[setup_count].scsiid      = scsiid[0];
3196             setup[setup_count].reconnect   = reconnect[0];
3197             setup[setup_count].parity      = parity[0];
3198             setup[setup_count].synchronous = sync[0];
3199             setup[setup_count].delay       = delay[0];
3200             setup[setup_count].ext_trans   = exttrans[0];
3201         }
3202
3203         if (checksetup(&setup[setup_count]))
3204             setup_count++;
3205         else
3206             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",
3207                    setup[setup_count].io_port,
3208                    setup[setup_count].irq,
3209                    setup[setup_count].scsiid,
3210                    setup[setup_count].reconnect,
3211                    setup[setup_count].parity,
3212                    setup[setup_count].synchronous,
3213                    setup[setup_count].delay,
3214                    setup[setup_count].ext_trans);
3215     }
3216
3217     if (setup_count<ARRAY_SIZE(setup) && (aha152x1[0]!=0 || io[1]!=0 || irq[1]!=0)) {
3218         if(aha152x1[0]!=0) {
3219             setup[setup_count].conf        = "";
3220             setup[setup_count].io_port     = aha152x1[0];
3221             setup[setup_count].irq         = aha152x1[1];
3222             setup[setup_count].scsiid      = aha152x1[2];
3223             setup[setup_count].reconnect   = aha152x1[3];
3224             setup[setup_count].parity      = aha152x1[4];
3225             setup[setup_count].synchronous = aha152x1[5];
3226             setup[setup_count].delay       = aha152x1[6];
3227             setup[setup_count].ext_trans   = aha152x1[7];
3228         } else if (io[1] != 0 || irq[1] != 0) {
3229             if(io[1]!=0)  setup[setup_count].io_port = io[1];
3230             if(irq[1]!=0) setup[setup_count].irq     = irq[1];
3231
3232             setup[setup_count].scsiid      = scsiid[1];
3233             setup[setup_count].reconnect   = reconnect[1];
3234             setup[setup_count].parity      = parity[1];
3235             setup[setup_count].synchronous = sync[1];
3236             setup[setup_count].delay       = delay[1];
3237             setup[setup_count].ext_trans   = exttrans[1];
3238         }
3239         if (checksetup(&setup[setup_count]))
3240             setup_count++;
3241         else
3242             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",
3243                    setup[setup_count].io_port,
3244                    setup[setup_count].irq,
3245                    setup[setup_count].scsiid,
3246                    setup[setup_count].reconnect,
3247                    setup[setup_count].parity,
3248                    setup[setup_count].synchronous,
3249                    setup[setup_count].delay,
3250                    setup[setup_count].ext_trans);
3251     }
3252 #endif
3253
3254 #ifdef __ISAPNP__
3255     for(i=0; setup_count<ARRAY_SIZE(setup) && id_table[i].vendor; i++) {
3256         while ( setup_count<ARRAY_SIZE(setup) &&
3257             (dev=pnp_find_dev(NULL, id_table[i].vendor, id_table[i].function, dev)) ) {
3258             if (pnp_device_attach(dev) < 0)
3259                 continue;
3260
3261             if (pnp_activate_dev(dev) < 0) {
3262                 pnp_device_detach(dev);
3263                 continue;
3264             }
3265
3266             if (!pnp_port_valid(dev, 0)) {
3267                 pnp_device_detach(dev);
3268                 continue;
3269             }
3270
3271             if (setup_count==1 && pnp_port_start(dev, 0)==setup[0].io_port) {
3272                 pnp_device_detach(dev);
3273                 continue;
3274             }
3275
3276             setup[setup_count].io_port     = pnp_port_start(dev, 0);
3277             setup[setup_count].irq         = pnp_irq(dev, 0);
3278             setup[setup_count].scsiid      = 7;
3279             setup[setup_count].reconnect   = 1;
3280             setup[setup_count].parity      = 1;
3281             setup[setup_count].synchronous = 1;
3282             setup[setup_count].delay       = DELAY_DEFAULT;
3283             setup[setup_count].ext_trans   = 0;
3284 #if defined(__ISAPNP__)
3285             pnpdev[setup_count]            = dev;
3286 #endif
3287             printk (KERN_INFO
3288                 "aha152x: found ISAPnP adapter at io=0x%03x, irq=%d\n",
3289                 setup[setup_count].io_port, setup[setup_count].irq);
3290             setup_count++;
3291         }
3292     }
3293 #endif
3294
3295 #if defined(AUTOCONF)
3296     if (setup_count<ARRAY_SIZE(setup)) {
3297 #if !defined(SKIP_BIOSTEST)
3298         ok = 0;
3299         for (i = 0; i < ARRAY_SIZE(addresses) && !ok; i++) {
3300             void __iomem *p = ioremap(addresses[i], 0x4000);
3301             if (!p)
3302                 continue;
3303             for (j = 0; j<ARRAY_SIZE(signatures) && !ok; j++)
3304                 ok = check_signature(p + signatures[j].sig_offset,
3305                                 signatures[j].signature, signatures[j].sig_length);
3306             iounmap(p);
3307         }
3308         if (!ok && setup_count == 0)
3309             return -ENODEV;
3310
3311         printk(KERN_INFO "aha152x: BIOS test: passed, ");
3312 #else
3313         printk(KERN_INFO "aha152x: ");
3314 #endif              /* !SKIP_BIOSTEST */
3315
3316         ok = 0;
3317         for (i = 0; i < ARRAY_SIZE(ports) && setup_count < 2; i++) {
3318             if ((setup_count == 1) && (setup[0].io_port == ports[i]))
3319                 continue;
3320
3321             if (!request_region(ports[i], IO_RANGE, "aha152x")) {
3322                 printk(KERN_ERR "aha152x: io port 0x%x busy.\n", ports[i]);
3323                 continue;
3324             }
3325
3326             if (aha152x_porttest(ports[i])) {
3327                 setup[setup_count].tc1550  = 0;
3328
3329                 conf.cf_port =
3330                     (GETPORT(ports[i] + O_PORTA) << 8) + GETPORT(ports[i] + O_PORTB);
3331             } else if (tc1550_porttest(ports[i])) {
3332                 setup[setup_count].tc1550  = 1;
3333
3334                 conf.cf_port =
3335                     (GETPORT(ports[i] + O_TC_PORTA) << 8) + GETPORT(ports[i] + O_TC_PORTB);
3336             } else {
3337                 release_region(ports[i], IO_RANGE);
3338                 continue;
3339             }
3340
3341             release_region(ports[i], IO_RANGE);
3342
3343             ok++;
3344             setup[setup_count].io_port = ports[i];
3345             setup[setup_count].irq = IRQ_MIN + conf.cf_irq;
3346             setup[setup_count].scsiid = conf.cf_id;
3347             setup[setup_count].reconnect = conf.cf_tardisc;
3348             setup[setup_count].parity = !conf.cf_parity;
3349             setup[setup_count].synchronous = conf.cf_syncneg;
3350             setup[setup_count].delay = DELAY_DEFAULT;
3351             setup[setup_count].ext_trans = 0;
3352             setup_count++;
3353
3354         }
3355
3356         if (ok)
3357             printk("auto configuration: ok, ");
3358     }
3359 #endif
3360
3361     printk("%d controller(s) configured\n", setup_count);
3362
3363     for (i=0; i<setup_count; i++) {
3364         if ( request_region(setup[i].io_port, IO_RANGE, "aha152x") ) {
3365             struct Scsi_Host *shpnt = aha152x_probe_one(&setup[i]);
3366
3367             if( !shpnt ) {
3368                 release_region(setup[i].io_port, IO_RANGE);
3369 #if defined(__ISAPNP__)
3370             } else if( pnpdev[i] ) {
3371                 HOSTDATA(shpnt)->pnpdev=pnpdev[i];
3372                 pnpdev[i]=NULL;
3373 #endif
3374             }
3375         } else {
3376             printk(KERN_ERR "aha152x: io port 0x%x busy.\n", setup[i].io_port);
3377         }
3378
3379 #if defined(__ISAPNP__)
3380         if( pnpdev[i] )
3381             pnp_device_detach(pnpdev[i]);
3382 #endif
3383     }
3384
3385     return 0;
3386 }
3387
3388 static void __exit aha152x_exit(void)
3389 {
3390     struct aha152x_hostdata *hd, *tmp;
3391
3392     list_for_each_entry_safe(hd, tmp, &aha152x_host_list, host_list) {
3393         struct Scsi_Host *shost = container_of((void *)hd, struct Scsi_Host, hostdata);
3394
3395         aha152x_release(shost);
3396     }
3397 }
3398
3399 module_init(aha152x_init);
3400 module_exit(aha152x_exit);
3401
3402 #if !defined(MODULE)
3403 static int __init aha152x_setup(char *str)
3404 {
3405     int ints[10];
3406
3407     get_options(str, ARRAY_SIZE(ints), ints);
3408
3409     if(setup_count>=ARRAY_SIZE(setup)) {
3410         printk(KERN_ERR "aha152x: you can only configure up to two controllers\n");
3411         return 1;
3412     }
3413
3414     setup[setup_count].conf        = str;
3415     setup[setup_count].io_port     = ints[0] >= 1 ? ints[1] : 0x340;
3416     setup[setup_count].irq         = ints[0] >= 2 ? ints[2] : 11;
3417     setup[setup_count].scsiid      = ints[0] >= 3 ? ints[3] : 7;
3418     setup[setup_count].reconnect   = ints[0] >= 4 ? ints[4] : 1;
3419     setup[setup_count].parity      = ints[0] >= 5 ? ints[5] : 1;
3420     setup[setup_count].synchronous = ints[0] >= 6 ? ints[6] : 1;
3421     setup[setup_count].delay       = ints[0] >= 7 ? ints[7] : DELAY_DEFAULT;
3422     setup[setup_count].ext_trans   = ints[0] >= 8 ? ints[8] : 0;
3423     if (ints[0] > 8)
3424         printk(KERN_NOTICE "aha152x: usage: aha152x=<IOBASE>[,<IRQ>[,<SCSI ID>"
3425                "[,<RECONNECT>[,<PARITY>[,<SYNCHRONOUS>[,<DELAY>[,<EXT_TRANS>]]]]]]]\n");
3426     else
3427         setup_count++;
3428
3429     return 1;
3430 }
3431 __setup("aha152x=", aha152x_setup);
3432 #endif
3433
3434 #endif /* !AHA152X_PCMCIA */