drivers/scsi/aha152x.c

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