drivers/scsi/aha152x.c

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