drivers/scsi/aha152x.c

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