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