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