drivers/scsi/aha152x.c

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