drivers/scsi/aha152x.c

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