drivers/scsi/aha152x.c

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