git.oblomov.eu Git - linux-2.6/blob - drivers/scsi/aha152x.c

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