drivers/scsi/aha152x.c

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