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