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