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

   1 /* aha152x.c -- Adaptec AHA-152x driver
   2  * Author: Jürgen E. Fischer, fischer@norbit.de
   3  * Copyright 1993-2004 Jürgen E. Fischer
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License as published by the
   7  * Free Software Foundation; either version 2, or (at your option) any
   8  * later version.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  *
  16  * $Id: aha152x.c,v 2.7 2004/01/24 11:42:59 fischer Exp $
  17  *
  18  * $Log: aha152x.c,v $
  19  * Revision 2.7  2004/01/24 11:42:59  fischer
  20  * - gather code that is not used by PCMCIA at the end
  21  * - move request_region for !PCMCIA case to detection
  22  * - migration to new scsi host api (remove legacy code)
  23  * - free host scribble before scsi_done
  24  * - fix error handling
  25  * - one isapnp device added to id_table
  26  *
  27  * Revision 2.6  2003/10/30 20:52:47  fischer
  28  * - interfaces changes for kernel 2.6
  29  * - aha152x_probe_one introduced for pcmcia stub
  30  * - fixed pnpdev handling
  31  * - instead of allocation a new one, reuse command for request sense after check condition and reset
  32  * - fixes race in is_complete
  33  *
  34  * Revision 2.5  2002/04/14 11:24:53  fischer
  35  * - isapnp support
  36  * - abort fixed
  37  * - 2.5 support
  38  *
  39  * Revision 2.4  2000/12/16 12:53:56  fischer
  40  * - allow REQUEST SENSE to be queued
  41  * - handle shared PCI interrupts
  42  *
  43  * Revision 2.3  2000/11/04 16:40:26  fischer
  44  * - handle data overruns
  45  * - extend timeout for data phases
  46  *
  47  * Revision 2.2  2000/08/08 19:54:53  fischer
  48  * - minor changes
  49  *
  50  * Revision 2.1  2000/05/17 16:23:17  fischer
  51  * - signature update
  52  * - fix for data out w/o scatter gather
  53  *
  54  * Revision 2.0  1999/12/25 15:07:32  fischer
  55  * - interrupt routine completly reworked
  56  * - basic support for new eh code
  57  *
  58  * Revision 1.21  1999/11/10 23:46:36  fischer
  59  * - default to synchronous operation
  60  * - synchronous negotiation fixed
  61  * - added timeout to loops
  62  * - debugging output can be controlled through procfs
  63  *
  64  * Revision 1.20  1999/11/07 18:37:31  fischer
  65  * - synchronous operation works
  66  * - resid support for sg driver
  67  *
  68  * Revision 1.19  1999/11/02 22:39:59  fischer
  69  * - moved leading comments to README.aha152x
  70  * - new additional module parameters
  71  * - updates for 2.3
  72  * - support for the Tripace TC1550 controller
  73  * - interrupt handling changed
  74  *
  75  * Revision 1.18  1996/09/07 20:10:40  fischer
  76  * - fixed can_queue handling (multiple outstanding commands working again)
  77  *
  78  * Revision 1.17  1996/08/17 16:05:14  fischer
  79  * - biosparam improved
  80  * - interrupt verification
  81  * - updated documentation
  82  * - cleanups
  83  *
  84  * Revision 1.16  1996/06/09 00:04:56  root
  85  * - added configuration symbols for insmod (aha152x/aha152x1)
  86  *
  87  * Revision 1.15  1996/04/30 14:52:06  fischer
  88  * - proc info fixed
  89  * - support for extended translation for >1GB disks
  90  *
  91  * Revision 1.14  1996/01/17  15:11:20  fischer
  92  * - fixed lockup in MESSAGE IN phase after reconnection
  93  *
  94  * Revision 1.13  1996/01/09  02:15:53  fischer
  95  * - some cleanups
  96  * - moved request_irq behind controller initialization
  97  *   (to avoid spurious interrupts)
  98  *
  99  * Revision 1.12  1995/12/16  12:26:07  fischer
 100  * - barrier()s added
 101  * - configurable RESET delay added
 102  *
 103  * Revision 1.11  1995/12/06  21:18:35  fischer
 104  * - some minor updates
 105  *
 106  * Revision 1.10  1995/07/22  19:18:45  fischer
 107  * - support for 2 controllers
 108  * - started synchronous data transfers (not working yet)
 109  *
 110  * Revision 1.9  1995/03/18  09:20:24  root
 111  * - patches for PCMCIA and modules
 112  *
 113  * Revision 1.8  1995/01/21  22:07:19  root
 114  * - snarf_region => request_region
 115  * - aha152x_intr interface change
 116  *
 117  * Revision 1.7  1995/01/02  23:19:36  root
 118  * - updated COMMAND_SIZE to cmd_len
 119  * - changed sti() to restore_flags()
 120  * - fixed some #ifdef which generated warnings
 121  *
 122  * Revision 1.6  1994/11/24  20:35:27  root
 123  * - problem with odd number of bytes in fifo fixed
 124  *
 125  * Revision 1.5  1994/10/30  14:39:56  root
 126  * - abort code fixed
 127  * - debugging improved
 128  *
 129  * Revision 1.4  1994/09/12  11:33:01  root
 130  * - irqaction to request_irq
 131  * - abortion updated
 132  *
 133  * Revision 1.3  1994/08/04  13:53:05  root
 134  * - updates for mid-level-driver changes
 135  * - accept unexpected BUSFREE phase as error condition
 136  * - parity check now configurable
 137  *
 138  * Revision 1.2  1994/07/03  12:56:36  root
 139  * - cleaned up debugging code
 140  * - more tweaking on reset delays
 141  * - updated abort/reset code (pretty untested...)
 142  *
 143  * Revision 1.1  1994/05/28  21:18:49  root
 144  * - update for mid-level interface change (abort-reset)
 145  * - delays after resets adjusted for some slow devices
 146  *
 147  * Revision 1.0  1994/03/25  12:52:00  root
 148  * - Fixed "more data than expected" problem
 149  * - added new BIOS signatures
 150  *
 151  * Revision 0.102  1994/01/31  20:44:12  root
 152  * - minor changes in insw/outsw handling
 153  *
 154  * Revision 0.101  1993/12/13  01:16:27  root
 155  * - fixed STATUS phase (non-GOOD stati were dropped sometimes;
 156  *   fixes problems with CD-ROM sector size detection & media change)
 157  *
 158  * Revision 0.100  1993/12/10  16:58:47  root
 159  * - fix for unsuccessful selections in case of non-continuous id assignments
 160  *   on the scsi bus.
 161  *
 162  * Revision 0.99  1993/10/24  16:19:59  root
 163  * - fixed DATA IN (rare read errors gone)
 164  *
 165  * Revision 0.98  1993/10/17  12:54:44  root
 166  * - fixed some recent fixes (shame on me)
 167  * - moved initialization of scratch area to aha152x_queue
 168  *
 169  * Revision 0.97  1993/10/09  18:53:53  root
 170  * - DATA IN fixed. Rarely left data in the fifo.
 171  *
 172  * Revision 0.96  1993/10/03  00:53:59  root
 173  * - minor changes on DATA IN
 174  *
 175  * Revision 0.95  1993/09/24  10:36:01  root
 176  * - change handling of MSGI after reselection
 177  * - fixed sti/cli
 178  * - minor changes
 179  *
 180  * Revision 0.94  1993/09/18  14:08:22  root
 181  * - fixed bug in multiple outstanding command code
 182  * - changed detection
 183  * - support for kernel command line configuration
 184  * - reset corrected
 185  * - changed message handling
 186  *
 187  * Revision 0.93  1993/09/15  20:41:19  root
 188  * - fixed bugs with multiple outstanding commands
 189  *
 190  * Revision 0.92  1993/09/13  02:46:33  root
 191  * - multiple outstanding commands work (no problems with IBM drive)
 192  *
 193  * Revision 0.91  1993/09/12  20:51:46  root
 194  * added multiple outstanding commands
 195  * (some problem with this $%&? IBM device remain)
 196  *
 197  * Revision 0.9  1993/09/12  11:11:22  root
 198  * - corrected auto-configuration
 199  * - changed the auto-configuration (added some '#define's)
 200  * - added support for dis-/reconnection
 201  *
 202  * Revision 0.8  1993/09/06  23:09:39  root
 203  * - added support for the drive activity light
 204  * - minor changes
 205  *
 206  * Revision 0.7  1993/09/05  14:30:15  root
 207  * - improved phase detection
 208  * - now using the new snarf_region code of 0.99pl13
 209  *
 210  * Revision 0.6  1993/09/02  11:01:38  root
 211  * first public release; added some signatures and biosparam()
 212  *
 213  * Revision 0.5  1993/08/30  10:23:30  root
 214  * fixed timing problems with my IBM drive
 215  *
 216  * Revision 0.4  1993/08/29  14:06:52  root
 217  * fixed some problems with timeouts due incomplete commands
 218  *
 219  * Revision 0.3  1993/08/28  15:55:03  root
 220  * writing data works too.  mounted and worked on a dos partition
 221  *
 222  * Revision 0.2  1993/08/27  22:42:07  root
 223  * reading data works.  Mounted a msdos partition.
 224  *
 225  * Revision 0.1  1993/08/25  13:38:30  root
 226  * first "damn thing doesn't work" version
 227  *
 228  * Revision 0.0  1993/08/14  19:54:25  root
 229  * empty function bodies; detect() works.
 230  *
 231  *
 232  **************************************************************************
 233
 234  see Documentation/scsi/aha152x.txt for configuration details
 235
 236  **************************************************************************/
 237
 238 #include <linux/module.h>
 239 #include <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         return ret;
1229 }
1230
1231 static void free_hard_reset_SCs(struct Scsi_Host *shpnt, Scsi_Cmnd **SCs)
1232 {
1233         Scsi_Cmnd *ptr;
1234
1235         ptr=*SCs;
1236         while(ptr) {
1237                 Scsi_Cmnd *next;
1238
1239                 if(SCDATA(ptr)) {
1240                         next = SCNEXT(ptr);
1241                 } else {
1242                         printk(DEBUG_LEAD "queue corrupted at %p\n", CMDINFO(ptr), ptr);
1243                         next = NULL;
1244                 }
1245
1246                 if (!ptr->device->soft_reset) {
1247                         DPRINTK(debug_eh, DEBUG_LEAD "disconnected command %p removed\n", CMDINFO(ptr), ptr);
1248                         remove_SC(SCs, ptr);
1249                         HOSTDATA(shpnt)->commands--;
1250                         kfree(ptr->host_scribble);
1251                         ptr->host_scribble=NULL;
1252                 }
1253
1254                 ptr = next;
1255         }
1256 }
1257
1258 /*
1259  * Reset the bus
1260  *
1261  */
1262 static int aha152x_bus_reset(Scsi_Cmnd *SCpnt)
1263 {
1264         struct Scsi_Host *shpnt = SCpnt->device->host;
1265         unsigned long flags;
1266
1267         DO_LOCK(flags);
1268
1269 #if defined(AHA152X_DEBUG)
1270         if(HOSTDATA(shpnt)->debug & debug_eh) {
1271                 printk(DEBUG_LEAD "aha152x_bus_reset(%p)", CMDINFO(SCpnt), SCpnt);
1272                 show_queues(shpnt);
1273         }
1274 #endif
1275
1276         free_hard_reset_SCs(shpnt, &ISSUE_SC);
1277         free_hard_reset_SCs(shpnt, &DISCONNECTED_SC);
1278
1279         DPRINTK(debug_eh, DEBUG_LEAD "resetting bus\n", CMDINFO(SCpnt));
1280
1281         SETPORT(SCSISEQ, SCSIRSTO);
1282         mdelay(256);
1283         SETPORT(SCSISEQ, 0);
1284         mdelay(DELAY);
1285
1286         DPRINTK(debug_eh, DEBUG_LEAD "bus resetted\n", CMDINFO(SCpnt));
1287
1288         setup_expected_interrupts(shpnt);
1289         if(HOSTDATA(shpnt)->commands==0)
1290                 SETPORT(PORTA, 0);
1291
1292         DO_UNLOCK(flags);
1293
1294         return SUCCESS;
1295 }
1296
1297
1298 /*
1299  *  Restore default values to the AIC-6260 registers and reset the fifos
1300  *
1301  */
1302 static void reset_ports(struct Scsi_Host *shpnt)
1303 {
1304         unsigned long flags;
1305
1306         /* disable interrupts */
1307         SETPORT(DMACNTRL0, RSTFIFO);
1308
1309         SETPORT(SCSISEQ, 0);
1310
1311         SETPORT(SXFRCTL1, 0);
1312         SETPORT(SCSISIG, 0);
1313         SETRATE(0);
1314
1315         /* clear all interrupt conditions */
1316         SETPORT(SSTAT0, 0x7f);
1317         SETPORT(SSTAT1, 0xef);
1318
1319         SETPORT(SSTAT4, SYNCERR | FWERR | FRERR);
1320
1321         SETPORT(DMACNTRL0, 0);
1322         SETPORT(DMACNTRL1, 0);
1323
1324         SETPORT(BRSTCNTRL, 0xf1);
1325
1326         /* clear SCSI fifos and transfer count */
1327         SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
1328         SETPORT(SXFRCTL0, CH1);
1329
1330         DO_LOCK(flags);
1331         setup_expected_interrupts(shpnt);
1332         DO_UNLOCK(flags);
1333 }
1334
1335 /*
1336  * Reset the host (bus and controller)
1337  *
1338  */
1339 int aha152x_host_reset(Scsi_Cmnd * SCpnt)
1340 {
1341 #if defined(AHA152X_DEBUG)
1342         struct Scsi_Host *shpnt = SCpnt->device->host;
1343 #endif
1344
1345         DPRINTK(debug_eh, DEBUG_LEAD "aha152x_host_reset(%p)\n", CMDINFO(SCpnt), SCpnt);
1346
1347         aha152x_bus_reset(SCpnt);
1348
1349         DPRINTK(debug_eh, DEBUG_LEAD "resetting ports\n", CMDINFO(SCpnt));
1350         reset_ports(SCpnt->device->host);
1351
1352         return SUCCESS;
1353 }
1354
1355 /*
1356  * Return the "logical geometry"
1357  *
1358  */
1359 static int aha152x_biosparam(struct scsi_device *sdev, struct block_device *bdev,
1360                 sector_t capacity, int *info_array)
1361 {
1362         struct Scsi_Host *shpnt = sdev->host;
1363
1364         /* try default translation */
1365         info_array[0] = 64;
1366         info_array[1] = 32;
1367         info_array[2] = (unsigned long)capacity / (64 * 32);
1368
1369         /* for disks >1GB do some guessing */
1370         if (info_array[2] >= 1024) {
1371                 int info[3];
1372
1373                 /* try to figure out the geometry from the partition table */
1374                 if (scsicam_bios_param(bdev, capacity, info) < 0 ||
1375                     !((info[0] == 64 && info[1] == 32) || (info[0] == 255 && info[1] == 63))) {
1376                         if (EXT_TRANS) {
1377                                 printk(KERN_NOTICE
1378                                        "aha152x: unable to verify geometry for disk with >1GB.\n"
1379                                        "         using extended translation.\n");
1380                                 info_array[0] = 255;
1381                                 info_array[1] = 63;
1382                                 info_array[2] = (unsigned long)capacity / (255 * 63);
1383                         } else {
1384                                 printk(KERN_NOTICE
1385                                        "aha152x: unable to verify geometry for disk with >1GB.\n"
1386                                        "         Using default translation. Please verify yourself.\n"
1387                                        "         Perhaps you need to enable extended translation in the driver.\n"
1388                                        "         See Documentation/scsi/aha152x.txt for details.\n");
1389                         }
1390                 } else {
1391                         info_array[0] = info[0];
1392                         info_array[1] = info[1];
1393                         info_array[2] = info[2];
1394
1395                         if (info[0] == 255 && !EXT_TRANS) {
1396                                 printk(KERN_NOTICE
1397                                        "aha152x: current partition table is using extended translation.\n"
1398                                        "         using it also, although it's not explicitly enabled.\n");
1399                         }
1400                 }
1401         }
1402
1403         return 0;
1404 }
1405
1406 /*
1407  *  Internal done function
1408  *
1409  */
1410 static void done(struct Scsi_Host *shpnt, int error)
1411 {
1412         if (CURRENT_SC) {
1413                 if(DONE_SC)
1414                         printk(ERR_LEAD "there's already a completed command %p - will cause abort\n", CMDINFO(CURRENT_SC), DONE_SC);
1415
1416                 DONE_SC = CURRENT_SC;
1417                 CURRENT_SC = NULL;
1418                 DONE_SC->result = error;
1419         } else
1420                 printk(KERN_ERR "aha152x: done() called outside of command\n");
1421 }
1422
1423 static struct work_struct aha152x_tq;
1424
1425 /*
1426  * Run service completions on the card with interrupts enabled.
1427  *
1428  */
1429 static void run(void)
1430 {
1431         int i;
1432         for (i = 0; i<ARRAY_SIZE(aha152x_host); i++) {
1433                 struct Scsi_Host *shpnt = aha152x_host[i];
1434                 if (shpnt && HOSTDATA(shpnt)->service) {
1435                         HOSTDATA(shpnt)->service=0;
1436                         is_complete(shpnt);
1437                 }
1438         }
1439 }
1440
1441 /*
1442  *    Interrupts handler
1443  *
1444  */
1445
1446 static irqreturn_t intr(int irqno, void *dev_id, struct pt_regs *regs)
1447 {
1448         struct Scsi_Host *shpnt = lookup_irq(irqno);
1449         unsigned char rev, dmacntrl0;
1450
1451         if (!shpnt) {
1452                 printk(KERN_ERR "aha152x: catched interrupt %d for unknown controller.\n", irqno);
1453                 return IRQ_NONE;
1454         }
1455
1456         /*
1457          * Read a couple of registers that are known to not be all 1's. If
1458          * we read all 1's (-1), that means that either:
1459          *
1460          * a. The host adapter chip has gone bad, and we cannot control it,
1461          *      OR
1462          * b. The host adapter is a PCMCIA card that has been ejected
1463          *
1464          * In either case, we cannot do anything with the host adapter at
1465          * this point in time. So just ignore the interrupt and return.
1466          * In the latter case, the interrupt might actually be meant for
1467          * someone else sharing this IRQ, and that driver will handle it.
1468          */
1469         rev = GETPORT(REV);
1470         dmacntrl0 = GETPORT(DMACNTRL0);
1471         if ((rev == 0xFF) && (dmacntrl0 == 0xFF))
1472                 return IRQ_NONE;
1473
1474         /* no more interrupts from the controller, while we're busy.
1475            INTEN is restored by the BH handler */
1476         CLRBITS(DMACNTRL0, INTEN);
1477
1478 #if 0
1479         /* check if there is already something to be
1480            serviced; should not happen */
1481         if(HOSTDATA(shpnt)->service) {
1482                 printk(KERN_ERR "aha152x%d: lost interrupt (%d)\n", HOSTNO, HOSTDATA(shpnt)->service);
1483                 show_queues(shpnt);
1484         }
1485 #endif
1486
1487         /* Poke the BH handler */
1488         HOSTDATA(shpnt)->service++;
1489         INIT_WORK(&aha152x_tq, (void *) run, NULL);
1490         schedule_work(&aha152x_tq);
1491         return IRQ_HANDLED;
1492 }
1493
1494 /*
1495  * busfree phase
1496  * - handle completition/disconnection/error of current command
1497  * - start selection for next command (if any)
1498  */
1499 static void busfree_run(struct Scsi_Host *shpnt)
1500 {
1501         unsigned long flags;
1502 #if defined(AHA152X_STAT)
1503         int action=0;
1504 #endif
1505
1506         SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
1507         SETPORT(SXFRCTL0, CH1);
1508
1509         SETPORT(SSTAT1, CLRBUSFREE);
1510
1511         if(CURRENT_SC) {
1512 #if defined(AHA152X_STAT)
1513                 action++;
1514 #endif
1515                 CURRENT_SC->SCp.phase &= ~syncneg;
1516
1517                 if(CURRENT_SC->SCp.phase & completed) {
1518                         /* target sent COMMAND COMPLETE */
1519                         done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_OK << 16));
1520
1521                 } else if(CURRENT_SC->SCp.phase & aborted) {
1522                         DPRINTK(debug_eh, DEBUG_LEAD "ABORT sent\n", CMDINFO(CURRENT_SC));
1523                         done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_ABORT << 16));
1524
1525                 } else if(CURRENT_SC->SCp.phase & resetted) {
1526                         DPRINTK(debug_eh, DEBUG_LEAD "BUS DEVICE RESET sent\n", CMDINFO(CURRENT_SC));
1527                         done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_RESET << 16));
1528
1529                 } else if(CURRENT_SC->SCp.phase & disconnected) {
1530                         /* target sent DISCONNECT */
1531                         DPRINTK(debug_selection, DEBUG_LEAD "target disconnected at %d/%d\n",
1532                                 CMDINFO(CURRENT_SC),
1533                                 CURRENT_SC->resid,
1534                                 CURRENT_SC->request_bufflen);
1535 #if defined(AHA152X_STAT)
1536                         HOSTDATA(shpnt)->disconnections++;
1537 #endif
1538                         append_SC(&DISCONNECTED_SC, CURRENT_SC);
1539                         CURRENT_SC->SCp.phase |= 1 << 16;
1540                         CURRENT_SC = NULL;
1541
1542                 } else {
1543                         done(shpnt, DID_ERROR << 16);
1544                 }
1545 #if defined(AHA152X_STAT)
1546         } else {
1547                 HOSTDATA(shpnt)->busfree_without_old_command++;
1548 #endif
1549         }
1550
1551         DO_LOCK(flags);
1552
1553         if(DONE_SC) {
1554 #if defined(AHA152X_STAT)
1555                 action++;
1556 #endif
1557
1558                 if(DONE_SC->SCp.phase & check_condition) {
1559 #if 0
1560                         if(HOSTDATA(shpnt)->debug & debug_eh) {
1561                                 printk(ERR_LEAD "received sense: ", CMDINFO(DONE_SC));
1562                                 scsi_print_sense("bh", DONE_SC);
1563                         }
1564 #endif
1565
1566                         /* restore old command */
1567                         memcpy((void *) DONE_SC->cmnd, (void *) DONE_SC->data_cmnd, sizeof(DONE_SC->data_cmnd));
1568                         DONE_SC->request_buffer  = DONE_SC->buffer;
1569                         DONE_SC->request_bufflen = DONE_SC->bufflen;
1570                         DONE_SC->use_sg          = DONE_SC->old_use_sg;
1571                         DONE_SC->cmd_len         = DONE_SC->old_cmd_len;
1572
1573                         DONE_SC->SCp.Status = 0x02;
1574
1575                         HOSTDATA(shpnt)->commands--;
1576                         if (!HOSTDATA(shpnt)->commands)
1577                                 SETPORT(PORTA, 0);      /* turn led off */
1578                 } else if(DONE_SC->SCp.Status==0x02) {
1579 #if defined(AHA152X_STAT)
1580                         HOSTDATA(shpnt)->busfree_with_check_condition++;
1581 #endif
1582 #if 0
1583                         DPRINTK(debug_eh, ERR_LEAD "CHECK CONDITION found\n", CMDINFO(DONE_SC));
1584 #endif
1585
1586                         if(!(DONE_SC->SCp.Status & not_issued)) {
1587                                 Scsi_Cmnd *ptr = DONE_SC;
1588                                 DONE_SC=NULL;
1589 #if 0
1590                                 DPRINTK(debug_eh, ERR_LEAD "requesting sense\n", CMDINFO(ptr));
1591 #endif
1592
1593                                 ptr->cmnd[0]         = REQUEST_SENSE;
1594                                 ptr->cmnd[1]         = 0;
1595                                 ptr->cmnd[2]         = 0;
1596                                 ptr->cmnd[3]         = 0;
1597                                 ptr->cmnd[4]         = sizeof(ptr->sense_buffer);
1598                                 ptr->cmnd[5]         = 0;
1599                                 ptr->cmd_len         = 6;
1600                                 ptr->use_sg          = 0;
1601                                 ptr->request_buffer  = ptr->sense_buffer;
1602                                 ptr->request_bufflen = sizeof(ptr->sense_buffer);
1603
1604                                 DO_UNLOCK(flags);
1605                                 aha152x_internal_queue(ptr, NULL, check_condition, ptr->scsi_done);
1606                                 DO_LOCK(flags);
1607 #if 0
1608                         } else {
1609                                 DPRINTK(debug_eh, ERR_LEAD "command not issued - CHECK CONDITION ignored\n", CMDINFO(DONE_SC));
1610 #endif
1611                         }
1612                 }
1613
1614                 if(DONE_SC && DONE_SC->scsi_done) {
1615 #if defined(AHA152X_DEBUG)
1616                         int hostno=DONE_SC->device->host->host_no;
1617                         int id=DONE_SC->device->id & 0xf;
1618                         int lun=DONE_SC->device->lun & 0x7;
1619 #endif
1620                         Scsi_Cmnd *ptr = DONE_SC;
1621                         DONE_SC=NULL;
1622
1623                         /* turn led off, when no commands are in the driver */
1624                         HOSTDATA(shpnt)->commands--;
1625                         if (!HOSTDATA(shpnt)->commands)
1626                                 SETPORT(PORTA, 0);      /* turn led off */
1627
1628                         if(ptr->scsi_done != reset_done) {
1629                                 kfree(ptr->host_scribble);
1630                                 ptr->host_scribble=NULL;
1631                         }
1632
1633                         DO_UNLOCK(flags);
1634                         DPRINTK(debug_done, DEBUG_LEAD "calling scsi_done(%p)\n", hostno, id, lun, ptr);
1635                         ptr->scsi_done(ptr);
1636                         DPRINTK(debug_done, DEBUG_LEAD "scsi_done(%p) returned\n", hostno, id, lun, ptr);
1637                         DO_LOCK(flags);
1638                 }
1639
1640                 DONE_SC=NULL;
1641 #if defined(AHA152X_STAT)
1642         } else {
1643                 HOSTDATA(shpnt)->busfree_without_done_command++;
1644 #endif
1645         }
1646
1647         if(ISSUE_SC)
1648                 CURRENT_SC = remove_first_SC(&ISSUE_SC);
1649
1650         DO_UNLOCK(flags);
1651
1652         if(CURRENT_SC) {
1653 #if defined(AHA152X_STAT)
1654                 action++;
1655 #endif
1656                 CURRENT_SC->SCp.phase |= selecting;
1657
1658                 DPRINTK(debug_selection, DEBUG_LEAD "selecting target\n", CMDINFO(CURRENT_SC));
1659
1660                 /* clear selection timeout */
1661                 SETPORT(SSTAT1, SELTO);
1662
1663                 SETPORT(SCSIID, (shpnt->this_id << OID_) | CURRENT_SC->device->id);
1664                 SETPORT(SXFRCTL1, (PARITY ? ENSPCHK : 0 ) | ENSTIMER);
1665                 SETPORT(SCSISEQ, ENSELO | ENAUTOATNO | (DISCONNECTED_SC ? ENRESELI : 0));
1666         } else {
1667 #if defined(AHA152X_STAT)
1668                 HOSTDATA(shpnt)->busfree_without_new_command++;
1669 #endif
1670                 SETPORT(SCSISEQ, DISCONNECTED_SC ? ENRESELI : 0);
1671         }
1672
1673 #if defined(AHA152X_STAT)
1674         if(!action)
1675                 HOSTDATA(shpnt)->busfree_without_any_action++;
1676 #endif
1677 }
1678
1679 /*
1680  * Selection done (OUT)
1681  * - queue IDENTIFY message and SDTR to selected target for message out
1682  *   (ATN asserted automagically via ENAUTOATNO in busfree())
1683  */
1684 static void seldo_run(struct Scsi_Host *shpnt)
1685 {
1686         SETPORT(SCSISIG, 0);
1687         SETPORT(SSTAT1, CLRBUSFREE);
1688         SETPORT(SSTAT1, CLRPHASECHG);
1689
1690         CURRENT_SC->SCp.phase &= ~(selecting|not_issued);
1691
1692         SETPORT(SCSISEQ, 0);
1693
1694         if (TESTLO(SSTAT0, SELDO)) {
1695                 printk(ERR_LEAD "aha152x: passing bus free condition\n", CMDINFO(CURRENT_SC));
1696                 done(shpnt, DID_NO_CONNECT << 16);
1697                 return;
1698         }
1699
1700         SETPORT(SSTAT0, CLRSELDO);
1701
1702         ADDMSGO(IDENTIFY(RECONNECT, CURRENT_SC->device->lun));
1703
1704         if (CURRENT_SC->SCp.phase & aborting) {
1705                 ADDMSGO(ABORT);
1706         } else if (CURRENT_SC->SCp.phase & resetting) {
1707                 ADDMSGO(BUS_DEVICE_RESET);
1708         } else if (SYNCNEG==0 && SYNCHRONOUS) {
1709                 CURRENT_SC->SCp.phase |= syncneg;
1710                 ADDMSGO(EXTENDED_MESSAGE);
1711                 ADDMSGO(3);
1712                 ADDMSGO(EXTENDED_SDTR);
1713                 ADDMSGO(50);            /* 200ns */
1714                 ADDMSGO(8);             /* 8 byte req/ack offset */
1715
1716                 SYNCNEG=1;              /* negotiation in progress */
1717         }
1718
1719         SETRATE(SYNCRATE);
1720 }
1721
1722 /*
1723  * Selection timeout
1724  * - return command to mid-level with failure cause
1725  *
1726  */
1727 static void selto_run(struct Scsi_Host *shpnt)
1728 {
1729         SETPORT(SCSISEQ, 0);
1730         SETPORT(SSTAT1, CLRSELTIMO);
1731
1732         DPRINTK(debug_selection, DEBUG_LEAD "selection timeout\n", CMDINFO(CURRENT_SC));
1733
1734         if(!CURRENT_SC) {
1735                 DPRINTK(debug_selection, DEBUG_LEAD "!CURRENT_SC\n", CMDINFO(CURRENT_SC));
1736                 return;
1737         }
1738
1739         CURRENT_SC->SCp.phase &= ~selecting;
1740
1741         if (CURRENT_SC->SCp.phase & aborted) {
1742                 DPRINTK(debug_selection, DEBUG_LEAD "aborted\n", CMDINFO(CURRENT_SC));
1743                 done(shpnt, DID_ABORT << 16);
1744         } else if (TESTLO(SSTAT0, SELINGO)) {
1745                 DPRINTK(debug_selection, DEBUG_LEAD "arbitration not won\n", CMDINFO(CURRENT_SC));
1746                 done(shpnt, DID_BUS_BUSY << 16);
1747         } else {
1748                 /* ARBITRATION won, but SELECTION failed */
1749                 DPRINTK(debug_selection, DEBUG_LEAD "selection failed\n", CMDINFO(CURRENT_SC));
1750                 done(shpnt, DID_NO_CONNECT << 16);
1751         }
1752 }
1753
1754 /*
1755  * Selection in done
1756  * - put current command back to issue queue
1757  *   (reconnection of a disconnected nexus instead
1758  *    of successful selection out)
1759  *
1760  */
1761 static void seldi_run(struct Scsi_Host *shpnt)
1762 {
1763         int selid;
1764         int target;
1765         unsigned long flags;
1766
1767         SETPORT(SCSISIG, 0);
1768         SETPORT(SSTAT0, CLRSELDI);
1769         SETPORT(SSTAT1, CLRBUSFREE);
1770         SETPORT(SSTAT1, CLRPHASECHG);
1771
1772         if(CURRENT_SC) {
1773                 if(!(CURRENT_SC->SCp.phase & not_issued))
1774                         printk(ERR_LEAD "command should not have been issued yet\n", CMDINFO(CURRENT_SC));
1775
1776                 DPRINTK(debug_selection, ERR_LEAD "command requeued - reselection\n", CMDINFO(CURRENT_SC));
1777
1778                 DO_LOCK(flags);
1779                 append_SC(&ISSUE_SC, CURRENT_SC);
1780                 DO_UNLOCK(flags);
1781
1782                 CURRENT_SC = NULL;
1783         }
1784
1785         if(!DISCONNECTED_SC) {
1786                 DPRINTK(debug_selection, DEBUG_LEAD "unexpected SELDI ", CMDINFO(CURRENT_SC));
1787                 return;
1788         }
1789
1790         RECONN_TARGET=-1;
1791
1792         selid = GETPORT(SELID) & ~(1 << shpnt->this_id);
1793
1794         if (selid==0) {
1795                 printk("aha152x%d: target id unknown (%02x)\n", HOSTNO, selid);
1796                 return;
1797         }
1798
1799         for(target=7; !(selid & (1 << target)); target--)
1800                 ;
1801
1802         if(selid & ~(1 << target)) {
1803                 printk("aha152x%d: multiple targets reconnected (%02x)\n",
1804                        HOSTNO, selid);
1805         }
1806
1807
1808         SETPORT(SCSIID, (shpnt->this_id << OID_) | target);
1809         SETPORT(SCSISEQ, 0);
1810
1811         SETRATE(HOSTDATA(shpnt)->syncrate[target]);
1812
1813         RECONN_TARGET=target;
1814         DPRINTK(debug_selection, DEBUG_LEAD "target %d reselected (%02x).\n", CMDINFO(CURRENT_SC), target, selid);
1815 }
1816
1817 /*
1818  * message in phase
1819  * - handle initial message after reconnection to identify
1820  *   reconnecting nexus
1821  * - queue command on DISCONNECTED_SC on DISCONNECT message
1822  * - set completed flag on COMMAND COMPLETE
1823  *   (other completition code moved to busfree_run)
1824  * - handle response to SDTR
1825  * - clear synchronous transfer agreements on BUS RESET
1826  *
1827  * FIXME: what about SAVE POINTERS, RESTORE POINTERS?
1828  *
1829  */
1830 static void msgi_run(struct Scsi_Host *shpnt)
1831 {
1832         for(;;) {
1833                 int sstat1 = GETPORT(SSTAT1);
1834
1835                 if(sstat1 & (PHASECHG|PHASEMIS|BUSFREE) || !(sstat1 & REQINIT))
1836                         return;
1837
1838                 if(TESTLO(SSTAT0,SPIORDY)) {
1839                         DPRINTK(debug_msgi, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
1840                         return;
1841                 }
1842
1843                 ADDMSGI(GETPORT(SCSIDAT));
1844
1845 #if defined(AHA152X_DEBUG)
1846                 if (HOSTDATA(shpnt)->debug & debug_msgi) {
1847                         printk(INFO_LEAD "inbound message %02x ", CMDINFO(CURRENT_SC), MSGI(0));
1848                         scsi_print_msg(&MSGI(0));
1849                         printk("\n");
1850                 }
1851 #endif
1852
1853                 if(!CURRENT_SC) {
1854                         if(LASTSTATE!=seldi) {
1855                                 printk(KERN_ERR "aha152x%d: message in w/o current command not after reselection\n", HOSTNO);
1856                         }
1857
1858                         /*
1859                          * Handle reselection
1860                          */
1861                         if(!(MSGI(0) & IDENTIFY_BASE)) {
1862                                 printk(KERN_ERR "aha152x%d: target didn't identify after reselection\n", HOSTNO);
1863                                 continue;
1864                         }
1865
1866                         CURRENT_SC = remove_lun_SC(&DISCONNECTED_SC, RECONN_TARGET, MSGI(0) & 0x3f);
1867
1868                         if (!CURRENT_SC) {
1869                                 show_queues(shpnt);
1870                                 printk(KERN_ERR "aha152x%d: no disconnected command for target %d/%d\n", HOSTNO, RECONN_TARGET, MSGI(0) & 0x3f);
1871                                 continue;
1872                         }
1873
1874                         DPRINTK(debug_msgi, DEBUG_LEAD "target reconnected\n", CMDINFO(CURRENT_SC));
1875
1876                         CURRENT_SC->SCp.Message = MSGI(0);
1877                         CURRENT_SC->SCp.phase &= ~disconnected;
1878
1879                         MSGILEN=0;
1880
1881                         /* next message if any */
1882                         continue;
1883                 }
1884
1885                 CURRENT_SC->SCp.Message = MSGI(0);
1886
1887                 switch (MSGI(0)) {
1888                 case DISCONNECT:
1889                         if (!RECONNECT)
1890                                 printk(WARN_LEAD "target was not allowed to disconnect\n", CMDINFO(CURRENT_SC));
1891
1892                         CURRENT_SC->SCp.phase |= disconnected;
1893                         break;
1894
1895                 case COMMAND_COMPLETE:
1896                         if(CURRENT_SC->SCp.phase & completed)
1897                                 DPRINTK(debug_msgi, DEBUG_LEAD "again COMMAND COMPLETE\n", CMDINFO(CURRENT_SC));
1898
1899                         CURRENT_SC->SCp.phase |= completed;
1900                         break;
1901
1902                 case MESSAGE_REJECT:
1903                         if (SYNCNEG==1) {
1904                                 printk(INFO_LEAD "Synchronous Data Transfer Request was rejected\n", CMDINFO(CURRENT_SC));
1905                                 SYNCNEG=2;      /* negotiation completed */
1906                         } else
1907                                 printk(INFO_LEAD "inbound message (MESSAGE REJECT)\n", CMDINFO(CURRENT_SC));
1908                         break;
1909
1910                 case SAVE_POINTERS:
1911                         break;
1912
1913                 case RESTORE_POINTERS:
1914                         break;
1915
1916                 case EXTENDED_MESSAGE:
1917                         if(MSGILEN<2 || MSGILEN<MSGI(1)+2) {
1918                                 /* not yet completed */
1919                                 continue;
1920                         }
1921
1922                         switch (MSGI(2)) {
1923                         case EXTENDED_SDTR:
1924                                 {
1925                                         long ticks;
1926
1927                                         if (MSGI(1) != 3) {
1928                                                 printk(ERR_LEAD "SDTR message length!=3\n", CMDINFO(CURRENT_SC));
1929                                                 break;
1930                                         }
1931
1932                                         if (!HOSTDATA(shpnt)->synchronous)
1933                                                 break;
1934
1935                                         printk(INFO_LEAD, CMDINFO(CURRENT_SC));
1936                                         scsi_print_msg(&MSGI(0));
1937                                         printk("\n");
1938
1939                                         ticks = (MSGI(3) * 4 + 49) / 50;
1940
1941                                         if (syncneg) {
1942                                                 /* negotiation in progress */
1943                                                 if (ticks > 9 || MSGI(4) < 1 || MSGI(4) > 8) {
1944                                                         ADDMSGO(MESSAGE_REJECT);
1945                                                         printk(INFO_LEAD "received Synchronous Data Transfer Request invalid - rejected\n", CMDINFO(CURRENT_SC));
1946                                                         break;
1947                                                 }
1948
1949                                                 SYNCRATE |= ((ticks - 2) << 4) + MSGI(4);
1950                                         } else if (ticks <= 9 && MSGI(4) >= 1) {
1951                                                 ADDMSGO(EXTENDED_MESSAGE);
1952                                                 ADDMSGO(3);
1953                                                 ADDMSGO(EXTENDED_SDTR);
1954                                                 if (ticks < 4) {
1955                                                         ticks = 4;
1956                                                         ADDMSGO(50);
1957                                                 } else
1958                                                         ADDMSGO(MSGI(3));
1959
1960                                                 if (MSGI(4) > 8)
1961                                                         MSGI(4) = 8;
1962
1963                                                 ADDMSGO(MSGI(4));
1964
1965                                                 SYNCRATE |= ((ticks - 2) << 4) + MSGI(4);
1966                                         } else {
1967                                                 /* requested SDTR is too slow, do it asynchronously */
1968                                                 printk(INFO_LEAD "Synchronous Data Transfer Request too slow - Rejecting\n", CMDINFO(CURRENT_SC));
1969                                                 ADDMSGO(MESSAGE_REJECT);
1970                                         }
1971
1972                                         SYNCNEG=2;              /* negotiation completed */
1973                                         SETRATE(SYNCRATE);
1974                                 }
1975                                 break;
1976
1977                         case BUS_DEVICE_RESET:
1978                                 {
1979                                         int i;
1980
1981                                         for(i=0; i<8; i++) {
1982                                                 HOSTDATA(shpnt)->syncrate[i]=0;
1983                                                 HOSTDATA(shpnt)->syncneg[i]=0;
1984                                         }
1985
1986                                 }
1987                                 break;
1988
1989                         case EXTENDED_MODIFY_DATA_POINTER:
1990                         case EXTENDED_EXTENDED_IDENTIFY:
1991                         case EXTENDED_WDTR:
1992                         default:
1993                                 ADDMSGO(MESSAGE_REJECT);
1994                                 break;
1995                         }
1996                         break;
1997                 }
1998
1999                 MSGILEN=0;
2000         }
2001 }
2002
2003 static void msgi_end(struct Scsi_Host *shpnt)
2004 {
2005         if(MSGILEN>0)
2006                 printk(WARN_LEAD "target left before message completed (%d)\n", CMDINFO(CURRENT_SC), MSGILEN);
2007
2008         if (MSGOLEN > 0 && !(GETPORT(SSTAT1) & BUSFREE)) {
2009                 DPRINTK(debug_msgi, DEBUG_LEAD "msgo pending\n", CMDINFO(CURRENT_SC));
2010                 SETPORT(SCSISIG, P_MSGI | SIG_ATNO);
2011         }
2012 }
2013
2014 /*
2015  * message out phase
2016  *
2017  */
2018 static void msgo_init(struct Scsi_Host *shpnt)
2019 {
2020         if(MSGOLEN==0) {
2021                 if((CURRENT_SC->SCp.phase & syncneg) && SYNCNEG==2 && SYNCRATE==0) {
2022                         ADDMSGO(IDENTIFY(RECONNECT, CURRENT_SC->device->lun));
2023                 } else {
2024                         printk(INFO_LEAD "unexpected MESSAGE OUT phase; rejecting\n", CMDINFO(CURRENT_SC));
2025                         ADDMSGO(MESSAGE_REJECT);
2026                 }
2027         }
2028
2029 #if defined(AHA152X_DEBUG)
2030         if(HOSTDATA(shpnt)->debug & debug_msgo) {
2031                 int i;
2032
2033                 printk(DEBUG_LEAD "messages( ", CMDINFO(CURRENT_SC));
2034                 for (i=0; i<MSGOLEN; i+=scsi_print_msg(&MSGO(i)), printk(" "))
2035                         ;
2036                 printk(")\n");
2037         }
2038 #endif
2039 }
2040
2041 /*
2042  * message out phase
2043  *
2044  */
2045 static void msgo_run(struct Scsi_Host *shpnt)
2046 {
2047         if(MSGO_I==MSGOLEN)
2048                 DPRINTK(debug_msgo, DEBUG_LEAD "messages all sent (%d/%d)\n", CMDINFO(CURRENT_SC), MSGO_I, MSGOLEN);
2049
2050         while(MSGO_I<MSGOLEN) {
2051                 DPRINTK(debug_msgo, DEBUG_LEAD "message byte %02x (%d/%d)\n", CMDINFO(CURRENT_SC), MSGO(MSGO_I), MSGO_I, MSGOLEN);
2052
2053                 if(TESTLO(SSTAT0, SPIORDY)) {
2054                         DPRINTK(debug_msgo, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
2055                         return;
2056                 }
2057
2058                 if (MSGO_I==MSGOLEN-1) {
2059                         /* Leave MESSAGE OUT after transfer */
2060                         SETPORT(SSTAT1, CLRATNO);
2061                 }
2062
2063
2064                 if (MSGO(MSGO_I) & IDENTIFY_BASE)
2065                         CURRENT_SC->SCp.phase |= identified;
2066
2067                 if (MSGO(MSGO_I)==ABORT)
2068                         CURRENT_SC->SCp.phase |= aborted;
2069
2070                 if (MSGO(MSGO_I)==BUS_DEVICE_RESET)
2071                         CURRENT_SC->SCp.phase |= resetted;
2072
2073                 SETPORT(SCSIDAT, MSGO(MSGO_I++));
2074         }
2075 }
2076
2077 static void msgo_end(struct Scsi_Host *shpnt)
2078 {
2079         if(MSGO_I<MSGOLEN) {
2080                 printk(ERR_LEAD "message sent incompletely (%d/%d)\n", CMDINFO(CURRENT_SC), MSGO_I, MSGOLEN);
2081                 if(SYNCNEG==1) {
2082                         printk(INFO_LEAD "Synchronous Data Transfer Request was rejected\n", CMDINFO(CURRENT_SC));
2083                         SYNCNEG=2;
2084                 }
2085         }
2086
2087         MSGO_I  = 0;
2088         MSGOLEN = 0;
2089 }
2090
2091 /*
2092  * command phase
2093  *
2094  */
2095 static void cmd_init(struct Scsi_Host *shpnt)
2096 {
2097         if (CURRENT_SC->SCp.sent_command) {
2098                 printk(ERR_LEAD "command already sent\n", CMDINFO(CURRENT_SC));
2099                 done(shpnt, DID_ERROR << 16);
2100                 return;
2101         }
2102
2103 #if defined(AHA152X_DEBUG)
2104         if (HOSTDATA(shpnt)->debug & debug_cmd) {
2105                 printk(DEBUG_LEAD "cmd_init: ", CMDINFO(CURRENT_SC));
2106                 __scsi_print_command(CURRENT_SC->cmnd);
2107         }
2108 #endif
2109
2110         CMD_I=0;
2111 }
2112
2113 /*
2114  * command phase
2115  *
2116  */
2117 static void cmd_run(struct Scsi_Host *shpnt)
2118 {
2119         if(CMD_I==CURRENT_SC->cmd_len) {
2120                 DPRINTK(debug_cmd, DEBUG_LEAD "command already completely sent (%d/%d)", CMDINFO(CURRENT_SC), CMD_I, CURRENT_SC->cmd_len);
2121                 disp_ports(shpnt);
2122         }
2123
2124         while(CMD_I<CURRENT_SC->cmd_len) {
2125                 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);
2126
2127                 if(TESTLO(SSTAT0, SPIORDY)) {
2128                         DPRINTK(debug_cmd, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
2129                         return;
2130                 }
2131
2132                 SETPORT(SCSIDAT, CURRENT_SC->cmnd[CMD_I++]);
2133         }
2134 }
2135
2136 static void cmd_end(struct Scsi_Host *shpnt)
2137 {
2138         if(CMD_I<CURRENT_SC->cmd_len)
2139                 printk(ERR_LEAD "command sent incompletely (%d/%d)\n", CMDINFO(CURRENT_SC), CMD_I, CURRENT_SC->cmd_len);
2140         else
2141                 CURRENT_SC->SCp.sent_command++;
2142 }
2143
2144 /*
2145  * status phase
2146  *
2147  */
2148 static void status_run(struct Scsi_Host *shpnt)
2149 {
2150         if(TESTLO(SSTAT0,SPIORDY)) {
2151                 DPRINTK(debug_status, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
2152                 return;
2153         }
2154
2155         CURRENT_SC->SCp.Status = GETPORT(SCSIDAT);
2156
2157 #if defined(AHA152X_DEBUG)
2158         if (HOSTDATA(shpnt)->debug & debug_status) {
2159                 printk(DEBUG_LEAD "inbound status %02x ", CMDINFO(CURRENT_SC), CURRENT_SC->SCp.Status);
2160                 scsi_print_status(CURRENT_SC->SCp.Status);
2161                 printk("\n");
2162         }
2163 #endif
2164 }
2165
2166 /*
2167  * data in phase
2168  *
2169  */
2170 static void datai_init(struct Scsi_Host *shpnt)
2171 {
2172         SETPORT(DMACNTRL0, RSTFIFO);
2173         SETPORT(DMACNTRL0, RSTFIFO|ENDMA);
2174
2175         SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2176         SETPORT(SXFRCTL0, CH1|SCSIEN|DMAEN);
2177
2178         SETPORT(SIMODE0, 0);
2179         SETPORT(SIMODE1, ENSCSIPERR | ENSCSIRST | ENPHASEMIS | ENBUSFREE);
2180
2181         DATA_LEN=0;
2182         DPRINTK(debug_datai,
2183                 DEBUG_LEAD "datai_init: request_bufflen=%d resid=%d\n",
2184                 CMDINFO(CURRENT_SC), CURRENT_SC->request_bufflen, CURRENT_SC->resid);
2185 }
2186
2187 static void datai_run(struct Scsi_Host *shpnt)
2188 {
2189         unsigned long the_time;
2190         int fifodata, data_count;
2191
2192         /*
2193          * loop while the phase persists or the fifos are not empty
2194          *
2195          */
2196         while(TESTLO(DMASTAT, INTSTAT) || TESTLO(DMASTAT, DFIFOEMP) || TESTLO(SSTAT2, SEMPTY)) {
2197                 /* FIXME: maybe this should be done by setting up
2198                  * STCNT to trigger ENSWRAP interrupt, instead of
2199                  * polling for DFIFOFULL
2200                  */
2201                 the_time=jiffies + 100*HZ;
2202                 while(TESTLO(DMASTAT, DFIFOFULL|INTSTAT) && time_before(jiffies,the_time))
2203                         barrier();
2204
2205                 if(TESTLO(DMASTAT, DFIFOFULL|INTSTAT)) {
2206                         printk(ERR_LEAD "datai timeout", CMDINFO(CURRENT_SC));
2207                         disp_ports(shpnt);
2208                         break;
2209                 }
2210
2211                 if(TESTHI(DMASTAT, DFIFOFULL)) {
2212                         fifodata = 128;
2213                 } else {
2214                         the_time=jiffies + 100*HZ;
2215                         while(TESTLO(SSTAT2, SEMPTY) && time_before(jiffies,the_time))
2216                                 barrier();
2217
2218                         if(TESTLO(SSTAT2, SEMPTY)) {
2219                                 printk(ERR_LEAD "datai sempty timeout", CMDINFO(CURRENT_SC));
2220                                 disp_ports(shpnt);
2221                                 break;
2222                         }
2223
2224                         fifodata = GETPORT(FIFOSTAT);
2225                 }
2226
2227                 if(CURRENT_SC->SCp.this_residual>0) {
2228                         while(fifodata>0 && CURRENT_SC->SCp.this_residual>0) {
2229                                 data_count = fifodata>CURRENT_SC->SCp.this_residual ?
2230                                                 CURRENT_SC->SCp.this_residual :
2231                                                 fifodata;
2232                                 fifodata -= data_count;
2233
2234                                 if(data_count & 1) {
2235                                         DPRINTK(debug_datai, DEBUG_LEAD "8bit\n", CMDINFO(CURRENT_SC));
2236                                         SETPORT(DMACNTRL0, ENDMA|_8BIT);
2237                                         *CURRENT_SC->SCp.ptr++ = GETPORT(DATAPORT);
2238                                         CURRENT_SC->SCp.this_residual--;
2239                                         DATA_LEN++;
2240                                         SETPORT(DMACNTRL0, ENDMA);
2241                                 }
2242
2243                                 if(data_count > 1) {
2244                                         DPRINTK(debug_datai, DEBUG_LEAD "16bit(%d)\n", CMDINFO(CURRENT_SC), data_count);
2245                                         data_count >>= 1;
2246                                         insw(DATAPORT, CURRENT_SC->SCp.ptr, data_count);
2247                                         CURRENT_SC->SCp.ptr           += 2 * data_count;
2248                                         CURRENT_SC->SCp.this_residual -= 2 * data_count;
2249                                         DATA_LEN                      += 2 * data_count;
2250                                 }
2251
2252                                 if(CURRENT_SC->SCp.this_residual==0 && CURRENT_SC->SCp.buffers_residual>0) {
2253                                         /* advance to next buffer */
2254                                         CURRENT_SC->SCp.buffers_residual--;
2255                                         CURRENT_SC->SCp.buffer++;
2256                                         CURRENT_SC->SCp.ptr           = SG_ADDRESS(CURRENT_SC->SCp.buffer);
2257                                         CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length;
2258                                 }
2259                         }
2260                 } else if(fifodata>0) {
2261                         printk(ERR_LEAD "no buffers left for %d(%d) bytes (data overrun!?)\n", CMDINFO(CURRENT_SC), fifodata, GETPORT(FIFOSTAT));
2262                         SETPORT(DMACNTRL0, ENDMA|_8BIT);
2263                         while(fifodata>0) {
2264                                 int data;
2265                                 data=GETPORT(DATAPORT);
2266                                 DPRINTK(debug_datai, DEBUG_LEAD "data=%02x\n", CMDINFO(CURRENT_SC), data);
2267                                 fifodata--;
2268                                 DATA_LEN++;
2269                         }
2270                         SETPORT(DMACNTRL0, ENDMA|_8BIT);
2271                 }
2272         }
2273
2274         if(TESTLO(DMASTAT, INTSTAT) ||
2275            TESTLO(DMASTAT, DFIFOEMP) ||
2276            TESTLO(SSTAT2, SEMPTY) ||
2277            GETPORT(FIFOSTAT)>0) {
2278                 /*
2279                  * something went wrong, if there's something left in the fifos
2280                  * or the phase didn't change
2281                  */
2282                 printk(ERR_LEAD "fifos should be empty and phase should have changed\n", CMDINFO(CURRENT_SC));
2283                 disp_ports(shpnt);
2284         }
2285
2286         if(DATA_LEN!=GETSTCNT()) {
2287                 printk(ERR_LEAD
2288                        "manual transfer count differs from automatic (count=%d;stcnt=%d;diff=%d;fifostat=%d)",
2289                        CMDINFO(CURRENT_SC), DATA_LEN, GETSTCNT(), GETSTCNT()-DATA_LEN, GETPORT(FIFOSTAT));
2290                 disp_ports(shpnt);
2291                 mdelay(10000);
2292         }
2293 }
2294
2295 static void datai_end(struct Scsi_Host *shpnt)
2296 {
2297         CURRENT_SC->resid -= GETSTCNT();
2298
2299         DPRINTK(debug_datai,
2300                 DEBUG_LEAD "datai_end: request_bufflen=%d resid=%d stcnt=%d\n",
2301                 CMDINFO(CURRENT_SC), CURRENT_SC->request_bufflen, CURRENT_SC->resid, GETSTCNT());
2302
2303         SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2304         SETPORT(DMACNTRL0, 0);
2305 }
2306
2307 /*
2308  * data out phase
2309  *
2310  */
2311 static void datao_init(struct Scsi_Host *shpnt)
2312 {
2313         SETPORT(DMACNTRL0, WRITE_READ | RSTFIFO);
2314         SETPORT(DMACNTRL0, WRITE_READ | ENDMA);
2315
2316         SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2317         SETPORT(SXFRCTL0, CH1|SCSIEN|DMAEN);
2318
2319         SETPORT(SIMODE0, 0);
2320         SETPORT(SIMODE1, ENSCSIPERR | ENSCSIRST | ENPHASEMIS | ENBUSFREE );
2321
2322         DATA_LEN = CURRENT_SC->resid;
2323
2324         DPRINTK(debug_datao,
2325                 DEBUG_LEAD "datao_init: request_bufflen=%d; resid=%d\n",
2326                 CMDINFO(CURRENT_SC), CURRENT_SC->request_bufflen, CURRENT_SC->resid);
2327 }
2328
2329 static void datao_run(struct Scsi_Host *shpnt)
2330 {
2331         unsigned long the_time;
2332         int data_count;
2333
2334         /* until phase changes or all data sent */
2335         while(TESTLO(DMASTAT, INTSTAT) && CURRENT_SC->SCp.this_residual>0) {
2336                 data_count = 128;
2337                 if(data_count > CURRENT_SC->SCp.this_residual)
2338                         data_count=CURRENT_SC->SCp.this_residual;
2339
2340                 if(TESTLO(DMASTAT, DFIFOEMP)) {
2341                         printk(ERR_LEAD "datao fifo not empty (%d)", CMDINFO(CURRENT_SC), GETPORT(FIFOSTAT));
2342                         disp_ports(shpnt);
2343                         break;
2344                 }
2345
2346                 if(data_count & 1) {
2347                         SETPORT(DMACNTRL0,WRITE_READ|ENDMA|_8BIT);
2348                         SETPORT(DATAPORT, *CURRENT_SC->SCp.ptr++);
2349                         CURRENT_SC->SCp.this_residual--;
2350                         CURRENT_SC->resid--;
2351                         SETPORT(DMACNTRL0,WRITE_READ|ENDMA);
2352                 }
2353
2354                 if(data_count > 1) {
2355                         data_count >>= 1;
2356                         outsw(DATAPORT, CURRENT_SC->SCp.ptr, data_count);
2357                         CURRENT_SC->SCp.ptr           += 2 * data_count;
2358                         CURRENT_SC->SCp.this_residual -= 2 * data_count;
2359                         CURRENT_SC->resid             -= 2 * data_count;
2360                 }
2361
2362                 if(CURRENT_SC->SCp.this_residual==0 && CURRENT_SC->SCp.buffers_residual>0) {
2363                         /* advance to next buffer */
2364                         CURRENT_SC->SCp.buffers_residual--;
2365                         CURRENT_SC->SCp.buffer++;
2366                         CURRENT_SC->SCp.ptr           = SG_ADDRESS(CURRENT_SC->SCp.buffer);
2367                         CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length;
2368                 }
2369
2370                 the_time=jiffies + 100*HZ;
2371                 while(TESTLO(DMASTAT, DFIFOEMP|INTSTAT) && time_before(jiffies,the_time))
2372                         barrier();
2373
2374                 if(TESTLO(DMASTAT, DFIFOEMP|INTSTAT)) {
2375                         printk(ERR_LEAD "dataout timeout", CMDINFO(CURRENT_SC));
2376                         disp_ports(shpnt);
2377                         break;
2378                 }
2379         }
2380 }
2381
2382 static void datao_end(struct Scsi_Host *shpnt)
2383 {
2384         if(TESTLO(DMASTAT, DFIFOEMP)) {
2385                 int data_count = (DATA_LEN - CURRENT_SC->resid) - GETSTCNT();
2386
2387                 DPRINTK(debug_datao, DEBUG_LEAD "datao: %d bytes to resend (%d written, %d transferred)\n",
2388                         CMDINFO(CURRENT_SC),
2389                         data_count,
2390                         DATA_LEN-CURRENT_SC->resid,
2391                         GETSTCNT());
2392
2393                 CURRENT_SC->resid += data_count;
2394
2395                 if(CURRENT_SC->use_sg) {
2396                         data_count -= CURRENT_SC->SCp.ptr - SG_ADDRESS(CURRENT_SC->SCp.buffer);
2397                         while(data_count>0) {
2398                                 CURRENT_SC->SCp.buffer--;
2399                                 CURRENT_SC->SCp.buffers_residual++;
2400                                 data_count -= CURRENT_SC->SCp.buffer->length;
2401                         }
2402                         CURRENT_SC->SCp.ptr           = SG_ADDRESS(CURRENT_SC->SCp.buffer) - data_count;
2403                         CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length + data_count;
2404                 } else {
2405                         CURRENT_SC->SCp.ptr           -= data_count;
2406                         CURRENT_SC->SCp.this_residual += data_count;
2407                 }
2408         }
2409
2410         DPRINTK(debug_datao, DEBUG_LEAD "datao_end: request_bufflen=%d; resid=%d; stcnt=%d\n",
2411                 CMDINFO(CURRENT_SC),
2412                 CURRENT_SC->request_bufflen,
2413                 CURRENT_SC->resid,
2414                 GETSTCNT());
2415
2416         SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
2417         SETPORT(SXFRCTL0, CH1);
2418
2419         SETPORT(DMACNTRL0, 0);
2420 }
2421
2422 /*
2423  * figure out what state we're in
2424  *
2425  */
2426 static int update_state(struct Scsi_Host *shpnt)
2427 {
2428         int dataphase=0;
2429         unsigned int stat0 = GETPORT(SSTAT0);
2430         unsigned int stat1 = GETPORT(SSTAT1);
2431
2432         PREVSTATE = STATE;
2433         STATE=unknown;
2434
2435         if(stat1 & SCSIRSTI) {
2436                 STATE=rsti;
2437                 SETPORT(SCSISEQ,0);
2438                 SETPORT(SSTAT1,SCSIRSTI);
2439         } else if(stat0 & SELDI && PREVSTATE==busfree) {
2440                 STATE=seldi;
2441         } else if(stat0 & SELDO && CURRENT_SC && (CURRENT_SC->SCp.phase & selecting)) {
2442                 STATE=seldo;
2443         } else if(stat1 & SELTO) {
2444                 STATE=selto;
2445         } else if(stat1 & BUSFREE) {
2446                 STATE=busfree;
2447                 SETPORT(SSTAT1,BUSFREE);
2448         } else if(stat1 & SCSIPERR) {
2449                 STATE=parerr;
2450                 SETPORT(SSTAT1,SCSIPERR);
2451         } else if(stat1 & REQINIT) {
2452                 switch(GETPORT(SCSISIG) & P_MASK) {
2453                 case P_MSGI:    STATE=msgi;     break;
2454                 case P_MSGO:    STATE=msgo;     break;
2455                 case P_DATAO:   STATE=datao;    break;
2456                 case P_DATAI:   STATE=datai;    break;
2457                 case P_STATUS:  STATE=status;   break;
2458                 case P_CMD:     STATE=cmd;      break;
2459                 }
2460                 dataphase=1;
2461         }
2462
2463         if((stat0 & SELDI) && STATE!=seldi && !dataphase) {
2464                 printk(INFO_LEAD "reselection missed?", CMDINFO(CURRENT_SC));
2465                 disp_ports(shpnt);
2466         }
2467
2468         if(STATE!=PREVSTATE) {
2469                 LASTSTATE=PREVSTATE;
2470         }
2471
2472         return dataphase;
2473 }
2474
2475 /*
2476  * handle parity error
2477  *
2478  * FIXME: in which phase?
2479  *
2480  */
2481 static void parerr_run(struct Scsi_Host *shpnt)
2482 {
2483         printk(ERR_LEAD "parity error\n", CMDINFO(CURRENT_SC));
2484         done(shpnt, DID_PARITY << 16);
2485 }
2486
2487 /*
2488  * handle reset in
2489  *
2490  */
2491 static void rsti_run(struct Scsi_Host *shpnt)
2492 {
2493         Scsi_Cmnd *ptr;
2494
2495         printk(KERN_NOTICE "aha152x%d: scsi reset in\n", HOSTNO);
2496
2497         ptr=DISCONNECTED_SC;
2498         while(ptr) {
2499                 Scsi_Cmnd *next = SCNEXT(ptr);
2500
2501                 if (!ptr->device->soft_reset) {
2502                         remove_SC(&DISCONNECTED_SC, ptr);
2503
2504                         kfree(ptr->host_scribble);
2505                         ptr->host_scribble=NULL;
2506
2507                         ptr->result =  DID_RESET << 16;
2508                         ptr->scsi_done(ptr);
2509                 }
2510
2511                 ptr = next;
2512         }
2513
2514         if(CURRENT_SC && !CURRENT_SC->device->soft_reset)
2515                 done(shpnt, DID_RESET << 16 );
2516 }
2517
2518
2519 /*
2520  * bottom-half handler
2521  *
2522  */
2523 static void is_complete(struct Scsi_Host *shpnt)
2524 {
2525         int dataphase;
2526         unsigned long flags;
2527         int pending;
2528
2529         DO_LOCK(flags);
2530         if(HOSTDATA(shpnt)->in_intr) {
2531                 DO_UNLOCK(flags);
2532                 /* aha152x_error never returns.. */
2533                 aha152x_error(shpnt, "bottom-half already running!?");
2534         }
2535         HOSTDATA(shpnt)->in_intr++;
2536
2537         /*
2538          * loop while there are interrupt conditions pending
2539          *
2540          */
2541         do {
2542                 unsigned long start = jiffies;
2543                 DO_UNLOCK(flags);
2544
2545                 dataphase=update_state(shpnt);
2546
2547                 DPRINTK(debug_phases, LEAD "start %s %s(%s)\n", CMDINFO(CURRENT_SC), states[STATE].name, states[PREVSTATE].name, states[LASTSTATE].name);
2548
2549                 /*
2550                  * end previous state
2551                  *
2552                  */
2553                 if(PREVSTATE!=STATE && states[PREVSTATE].end)
2554                         states[PREVSTATE].end(shpnt);
2555
2556                 /*
2557                  * disable SPIO mode if previous phase used it
2558                  * and this one doesn't
2559                  *
2560                  */
2561                 if(states[PREVSTATE].spio && !states[STATE].spio) {
2562                         SETPORT(SXFRCTL0, CH1);
2563                         SETPORT(DMACNTRL0, 0);
2564                         if(CURRENT_SC)
2565                                 CURRENT_SC->SCp.phase &= ~spiordy;
2566                 }
2567
2568                 /*
2569                  * accept current dataphase phase
2570                  *
2571                  */
2572                 if(dataphase) {
2573                         SETPORT(SSTAT0, REQINIT);
2574                         SETPORT(SCSISIG, GETPORT(SCSISIG) & P_MASK);
2575                         SETPORT(SSTAT1, PHASECHG);
2576                 }
2577
2578                 /*
2579                  * enable SPIO mode if previous didn't use it
2580                  * and this one does
2581                  *
2582                  */
2583                 if(!states[PREVSTATE].spio && states[STATE].spio) {
2584                         SETPORT(DMACNTRL0, 0);
2585                         SETPORT(SXFRCTL0, CH1|SPIOEN);
2586                         if(CURRENT_SC)
2587                                 CURRENT_SC->SCp.phase |= spiordy;
2588                 }
2589
2590                 /*
2591                  * initialize for new state
2592                  *
2593                  */
2594                 if(PREVSTATE!=STATE && states[STATE].init)
2595                         states[STATE].init(shpnt);
2596
2597                 /*
2598                  * handle current state
2599                  *
2600                  */
2601                 if(states[STATE].run)
2602                         states[STATE].run(shpnt);
2603                 else
2604                         printk(ERR_LEAD "unexpected state (%x)\n", CMDINFO(CURRENT_SC), STATE);
2605
2606                 /*
2607                  * setup controller to interrupt on
2608                  * the next expected condition and
2609                  * loop if it's already there
2610                  *
2611                  */
2612                 DO_LOCK(flags);
2613                 pending=setup_expected_interrupts(shpnt);
2614 #if defined(AHA152X_STAT)
2615                 HOSTDATA(shpnt)->count[STATE]++;
2616                 if(PREVSTATE!=STATE)
2617                         HOSTDATA(shpnt)->count_trans[STATE]++;
2618                 HOSTDATA(shpnt)->time[STATE] += jiffies-start;
2619 #endif
2620
2621                 DPRINTK(debug_phases, LEAD "end %s %s(%s)\n", CMDINFO(CURRENT_SC), states[STATE].name, states[PREVSTATE].name, states[LASTSTATE].name);
2622         } while(pending);
2623
2624         /*
2625          * enable interrupts and leave bottom-half
2626          *
2627          */
2628         HOSTDATA(shpnt)->in_intr--;
2629         SETBITS(DMACNTRL0, INTEN);
2630         DO_UNLOCK(flags);
2631 }
2632
2633
2634 /*
2635  * Dump the current driver status and panic
2636  */
2637 static void aha152x_error(struct Scsi_Host *shpnt, char *msg)
2638 {
2639         printk(KERN_EMERG "\naha152x%d: %s\n", HOSTNO, msg);
2640         show_queues(shpnt);
2641         panic("aha152x panic\n");
2642 }
2643
2644 /*
2645  * Display registers of AIC-6260
2646  */
2647 static void disp_ports(struct Scsi_Host *shpnt)
2648 {
2649 #if defined(AHA152X_DEBUG)
2650         int s;
2651
2652         printk("\n%s: %s(%s) ",
2653                 CURRENT_SC ? "busy" : "waiting",
2654                 states[STATE].name,
2655                 states[PREVSTATE].name);
2656
2657         s = GETPORT(SCSISEQ);
2658         printk("SCSISEQ( ");
2659         if (s & TEMODEO)
2660                 printk("TARGET MODE ");
2661         if (s & ENSELO)
2662                 printk("SELO ");
2663         if (s & ENSELI)
2664                 printk("SELI ");
2665         if (s & ENRESELI)
2666                 printk("RESELI ");
2667         if (s & ENAUTOATNO)
2668                 printk("AUTOATNO ");
2669         if (s & ENAUTOATNI)
2670                 printk("AUTOATNI ");
2671         if (s & ENAUTOATNP)
2672                 printk("AUTOATNP ");
2673         if (s & SCSIRSTO)
2674                 printk("SCSIRSTO ");
2675         printk(");");
2676
2677         printk(" SCSISIG(");
2678         s = GETPORT(SCSISIG);
2679         switch (s & P_MASK) {
2680         case P_DATAO:
2681                 printk("DATA OUT");
2682                 break;
2683         case P_DATAI:
2684                 printk("DATA IN");
2685                 break;
2686         case P_CMD:
2687                 printk("COMMAND");
2688                 break;
2689         case P_STATUS:
2690                 printk("STATUS");
2691                 break;
2692         case P_MSGO:
2693                 printk("MESSAGE OUT");
2694                 break;
2695         case P_MSGI:
2696                 printk("MESSAGE IN");
2697                 break;
2698         default:
2699                 printk("*invalid*");
2700                 break;
2701         }
2702
2703         printk("); ");
2704
2705         printk("INTSTAT (%s); ", TESTHI(DMASTAT, INTSTAT) ? "hi" : "lo");
2706
2707         printk("SSTAT( ");
2708         s = GETPORT(SSTAT0);
2709         if (s & TARGET)
2710                 printk("TARGET ");
2711         if (s & SELDO)
2712                 printk("SELDO ");
2713         if (s & SELDI)
2714                 printk("SELDI ");
2715         if (s & SELINGO)
2716                 printk("SELINGO ");
2717         if (s & SWRAP)
2718                 printk("SWRAP ");
2719         if (s & SDONE)
2720                 printk("SDONE ");
2721         if (s & SPIORDY)
2722                 printk("SPIORDY ");
2723         if (s & DMADONE)
2724                 printk("DMADONE ");
2725
2726         s = GETPORT(SSTAT1);
2727         if (s & SELTO)
2728                 printk("SELTO ");
2729         if (s & ATNTARG)
2730                 printk("ATNTARG ");
2731         if (s & SCSIRSTI)
2732                 printk("SCSIRSTI ");
2733         if (s & PHASEMIS)
2734                 printk("PHASEMIS ");
2735         if (s & BUSFREE)
2736                 printk("BUSFREE ");
2737         if (s & SCSIPERR)
2738                 printk("SCSIPERR ");
2739         if (s & PHASECHG)
2740                 printk("PHASECHG ");
2741         if (s & REQINIT)
2742                 printk("REQINIT ");
2743         printk("); ");
2744
2745
2746         printk("SSTAT( ");
2747
2748         s = GETPORT(SSTAT0) & GETPORT(SIMODE0);
2749
2750         if (s & TARGET)
2751                 printk("TARGET ");
2752         if (s & SELDO)
2753                 printk("SELDO ");
2754         if (s & SELDI)
2755                 printk("SELDI ");
2756         if (s & SELINGO)
2757                 printk("SELINGO ");
2758         if (s & SWRAP)
2759                 printk("SWRAP ");
2760         if (s & SDONE)
2761                 printk("SDONE ");
2762         if (s & SPIORDY)
2763                 printk("SPIORDY ");
2764         if (s & DMADONE)
2765                 printk("DMADONE ");
2766
2767         s = GETPORT(SSTAT1) & GETPORT(SIMODE1);
2768
2769         if (s & SELTO)
2770                 printk("SELTO ");
2771         if (s & ATNTARG)
2772                 printk("ATNTARG ");
2773         if (s & SCSIRSTI)
2774                 printk("SCSIRSTI ");
2775         if (s & PHASEMIS)
2776                 printk("PHASEMIS ");
2777         if (s & BUSFREE)
2778                 printk("BUSFREE ");
2779         if (s & SCSIPERR)
2780                 printk("SCSIPERR ");
2781         if (s & PHASECHG)
2782                 printk("PHASECHG ");
2783         if (s & REQINIT)
2784                 printk("REQINIT ");
2785         printk("); ");
2786
2787         printk("SXFRCTL0( ");
2788
2789         s = GETPORT(SXFRCTL0);
2790         if (s & SCSIEN)
2791                 printk("SCSIEN ");
2792         if (s & DMAEN)
2793                 printk("DMAEN ");
2794         if (s & CH1)
2795                 printk("CH1 ");
2796         if (s & CLRSTCNT)
2797                 printk("CLRSTCNT ");
2798         if (s & SPIOEN)
2799                 printk("SPIOEN ");
2800         if (s & CLRCH1)
2801                 printk("CLRCH1 ");
2802         printk("); ");
2803
2804         printk("SIGNAL( ");
2805
2806         s = GETPORT(SCSISIG);
2807         if (s & SIG_ATNI)
2808                 printk("ATNI ");
2809         if (s & SIG_SELI)
2810                 printk("SELI ");
2811         if (s & SIG_BSYI)
2812                 printk("BSYI ");
2813         if (s & SIG_REQI)
2814                 printk("REQI ");
2815         if (s & SIG_ACKI)
2816                 printk("ACKI ");
2817         printk("); ");
2818
2819         printk("SELID (%02x), ", GETPORT(SELID));
2820
2821         printk("STCNT (%d), ", GETSTCNT());
2822
2823         printk("SSTAT2( ");
2824
2825         s = GETPORT(SSTAT2);
2826         if (s & SOFFSET)
2827                 printk("SOFFSET ");
2828         if (s & SEMPTY)
2829                 printk("SEMPTY ");
2830         if (s & SFULL)
2831                 printk("SFULL ");
2832         printk("); SFCNT (%d); ", s & (SFULL | SFCNT));
2833
2834         s = GETPORT(SSTAT3);
2835         printk("SCSICNT (%d), OFFCNT(%d), ", (s & 0xf0) >> 4, s & 0x0f);
2836
2837         printk("SSTAT4( ");
2838         s = GETPORT(SSTAT4);
2839         if (s & SYNCERR)
2840                 printk("SYNCERR ");
2841         if (s & FWERR)
2842                 printk("FWERR ");
2843         if (s & FRERR)
2844                 printk("FRERR ");
2845         printk("); ");
2846
2847         printk("DMACNTRL0( ");
2848         s = GETPORT(DMACNTRL0);
2849         printk("%s ", s & _8BIT ? "8BIT" : "16BIT");
2850         printk("%s ", s & DMA ? "DMA" : "PIO");
2851         printk("%s ", s & WRITE_READ ? "WRITE" : "READ");
2852         if (s & ENDMA)
2853                 printk("ENDMA ");
2854         if (s & INTEN)
2855                 printk("INTEN ");
2856         if (s & RSTFIFO)
2857                 printk("RSTFIFO ");
2858         if (s & SWINT)
2859                 printk("SWINT ");
2860         printk("); ");
2861
2862         printk("DMASTAT( ");
2863         s = GETPORT(DMASTAT);
2864         if (s & ATDONE)
2865                 printk("ATDONE ");
2866         if (s & WORDRDY)
2867                 printk("WORDRDY ");
2868         if (s & DFIFOFULL)
2869                 printk("DFIFOFULL ");
2870         if (s & DFIFOEMP)
2871                 printk("DFIFOEMP ");
2872         printk(")\n");
2873 #endif
2874 }
2875
2876 /*
2877  * display enabled interrupts
2878  */
2879 static void disp_enintr(struct Scsi_Host *shpnt)
2880 {
2881         int s;
2882
2883         printk(KERN_DEBUG "enabled interrupts ( ");
2884
2885         s = GETPORT(SIMODE0);
2886         if (s & ENSELDO)
2887                 printk("ENSELDO ");
2888         if (s & ENSELDI)
2889                 printk("ENSELDI ");
2890         if (s & ENSELINGO)
2891                 printk("ENSELINGO ");
2892         if (s & ENSWRAP)
2893                 printk("ENSWRAP ");
2894         if (s & ENSDONE)
2895                 printk("ENSDONE ");
2896         if (s & ENSPIORDY)
2897                 printk("ENSPIORDY ");
2898         if (s & ENDMADONE)
2899                 printk("ENDMADONE ");
2900
2901         s = GETPORT(SIMODE1);
2902         if (s & ENSELTIMO)
2903                 printk("ENSELTIMO ");
2904         if (s & ENATNTARG)
2905                 printk("ENATNTARG ");
2906         if (s & ENPHASEMIS)
2907                 printk("ENPHASEMIS ");
2908         if (s & ENBUSFREE)
2909                 printk("ENBUSFREE ");
2910         if (s & ENSCSIPERR)
2911                 printk("ENSCSIPERR ");
2912         if (s & ENPHASECHG)
2913                 printk("ENPHASECHG ");
2914         if (s & ENREQINIT)
2915                 printk("ENREQINIT ");
2916         printk(")\n");
2917 }
2918
2919 /*
2920  * Show the command data of a command
2921  */
2922 static void show_command(Scsi_Cmnd *ptr)
2923 {
2924         printk(KERN_DEBUG "0x%08x: target=%d; lun=%d; cmnd=(",
2925                (unsigned int) ptr, ptr->device->id, ptr->device->lun);
2926
2927         __scsi_print_command(ptr->cmnd);
2928
2929         printk(KERN_DEBUG "); request_bufflen=%d; resid=%d; phase |",
2930                ptr->request_bufflen, ptr->resid);
2931
2932         if (ptr->SCp.phase & not_issued)
2933                 printk("not issued|");
2934         if (ptr->SCp.phase & selecting)
2935                 printk("selecting|");
2936         if (ptr->SCp.phase & identified)
2937                 printk("identified|");
2938         if (ptr->SCp.phase & disconnected)
2939                 printk("disconnected|");
2940         if (ptr->SCp.phase & completed)
2941                 printk("completed|");
2942         if (ptr->SCp.phase & spiordy)
2943                 printk("spiordy|");
2944         if (ptr->SCp.phase & syncneg)
2945                 printk("syncneg|");
2946         if (ptr->SCp.phase & aborted)
2947                 printk("aborted|");
2948         if (ptr->SCp.phase & resetted)
2949                 printk("resetted|");
2950         if( SCDATA(ptr) ) {
2951                 printk("; next=0x%p\n", SCNEXT(ptr));
2952         } else {
2953                 printk("; next=(host scribble NULL)\n");
2954         }
2955 }
2956
2957 /*
2958  * Dump the queued data
2959  */
2960 static void show_queues(struct Scsi_Host *shpnt)
2961 {
2962         Scsi_Cmnd *ptr;
2963         unsigned long flags;
2964
2965         DO_LOCK(flags);
2966         printk(KERN_DEBUG "\nqueue status:\nissue_SC:\n");
2967         for (ptr = ISSUE_SC; ptr; ptr = SCNEXT(ptr))
2968                 show_command(ptr);
2969         DO_UNLOCK(flags);
2970
2971         printk(KERN_DEBUG "current_SC:\n");
2972         if (CURRENT_SC)
2973                 show_command(CURRENT_SC);
2974         else
2975                 printk(KERN_DEBUG "none\n");
2976
2977         printk(KERN_DEBUG "disconnected_SC:\n");
2978         for (ptr = DISCONNECTED_SC; ptr; ptr = SCDATA(ptr) ? SCNEXT(ptr) : NULL)
2979                 show_command(ptr);
2980
2981         disp_ports(shpnt);
2982         disp_enintr(shpnt);
2983 }
2984
2985 #undef SPRINTF
2986 #define SPRINTF(args...) pos += sprintf(pos, ## args)
2987
2988 static int get_command(char *pos, Scsi_Cmnd * ptr)
2989 {
2990         char *start = pos;
2991         int i;
2992
2993         SPRINTF("0x%08x: target=%d; lun=%d; cmnd=( ",
2994                 (unsigned int) ptr, ptr->device->id, ptr->device->lun);
2995
2996         for (i = 0; i < COMMAND_SIZE(ptr->cmnd[0]); i++)
2997                 SPRINTF("0x%02x ", ptr->cmnd[i]);
2998
2999         SPRINTF("); resid=%d; residual=%d; buffers=%d; phase |",
3000                 ptr->resid, ptr->SCp.this_residual, ptr->SCp.buffers_residual);
3001
3002         if (ptr->SCp.phase & not_issued)
3003                 SPRINTF("not issued|");
3004         if (ptr->SCp.phase & selecting)
3005                 SPRINTF("selecting|");
3006         if (ptr->SCp.phase & disconnected)
3007                 SPRINTF("disconnected|");
3008         if (ptr->SCp.phase & aborted)
3009                 SPRINTF("aborted|");
3010         if (ptr->SCp.phase & identified)
3011                 SPRINTF("identified|");
3012         if (ptr->SCp.phase & completed)
3013                 SPRINTF("completed|");
3014         if (ptr->SCp.phase & spiordy)
3015                 SPRINTF("spiordy|");
3016         if (ptr->SCp.phase & syncneg)
3017                 SPRINTF("syncneg|");
3018         SPRINTF("; next=0x%p\n", SCNEXT(ptr));
3019
3020         return (pos - start);
3021 }
3022
3023 static int get_ports(struct Scsi_Host *shpnt, char *pos)
3024 {
3025         char *start = pos;
3026         int s;
3027
3028         SPRINTF("\n%s: %s(%s) ", CURRENT_SC ? "on bus" : "waiting", states[STATE].name, states[PREVSTATE].name);
3029
3030         s = GETPORT(SCSISEQ);
3031         SPRINTF("SCSISEQ( ");
3032         if (s & TEMODEO)
3033                 SPRINTF("TARGET MODE ");
3034         if (s & ENSELO)
3035                 SPRINTF("SELO ");
3036         if (s & ENSELI)
3037                 SPRINTF("SELI ");
3038         if (s & ENRESELI)
3039                 SPRINTF("RESELI ");
3040         if (s & ENAUTOATNO)
3041                 SPRINTF("AUTOATNO ");
3042         if (s & ENAUTOATNI)
3043                 SPRINTF("AUTOATNI ");
3044         if (s & ENAUTOATNP)
3045                 SPRINTF("AUTOATNP ");
3046         if (s & SCSIRSTO)
3047                 SPRINTF("SCSIRSTO ");
3048         SPRINTF(");");
3049
3050         SPRINTF(" SCSISIG(");
3051         s = GETPORT(SCSISIG);
3052         switch (s & P_MASK) {
3053         case P_DATAO:
3054                 SPRINTF("DATA OUT");
3055                 break;
3056         case P_DATAI:
3057                 SPRINTF("DATA IN");
3058                 break;
3059         case P_CMD:
3060                 SPRINTF("COMMAND");
3061                 break;
3062         case P_STATUS:
3063                 SPRINTF("STATUS");
3064                 break;
3065         case P_MSGO:
3066                 SPRINTF("MESSAGE OUT");
3067                 break;
3068         case P_MSGI:
3069                 SPRINTF("MESSAGE IN");
3070                 break;
3071         default:
3072                 SPRINTF("*invalid*");
3073                 break;
3074         }
3075
3076         SPRINTF("); ");
3077
3078         SPRINTF("INTSTAT (%s); ", TESTHI(DMASTAT, INTSTAT) ? "hi" : "lo");
3079
3080         SPRINTF("SSTAT( ");
3081         s = GETPORT(SSTAT0);
3082         if (s & TARGET)
3083                 SPRINTF("TARGET ");
3084         if (s & SELDO)
3085                 SPRINTF("SELDO ");
3086         if (s & SELDI)
3087                 SPRINTF("SELDI ");
3088         if (s & SELINGO)
3089                 SPRINTF("SELINGO ");
3090         if (s & SWRAP)
3091                 SPRINTF("SWRAP ");
3092         if (s & SDONE)
3093                 SPRINTF("SDONE ");
3094         if (s & SPIORDY)
3095                 SPRINTF("SPIORDY ");
3096         if (s & DMADONE)
3097                 SPRINTF("DMADONE ");
3098
3099         s = GETPORT(SSTAT1);
3100         if (s & SELTO)
3101                 SPRINTF("SELTO ");
3102         if (s & ATNTARG)
3103                 SPRINTF("ATNTARG ");
3104         if (s & SCSIRSTI)
3105                 SPRINTF("SCSIRSTI ");
3106         if (s & PHASEMIS)
3107                 SPRINTF("PHASEMIS ");
3108         if (s & BUSFREE)
3109                 SPRINTF("BUSFREE ");
3110         if (s & SCSIPERR)
3111                 SPRINTF("SCSIPERR ");
3112         if (s & PHASECHG)
3113                 SPRINTF("PHASECHG ");
3114         if (s & REQINIT)
3115                 SPRINTF("REQINIT ");
3116         SPRINTF("); ");
3117
3118
3119         SPRINTF("SSTAT( ");
3120
3121         s = GETPORT(SSTAT0) & GETPORT(SIMODE0);
3122
3123         if (s & TARGET)
3124                 SPRINTF("TARGET ");
3125         if (s & SELDO)
3126                 SPRINTF("SELDO ");
3127         if (s & SELDI)
3128                 SPRINTF("SELDI ");
3129         if (s & SELINGO)
3130                 SPRINTF("SELINGO ");
3131         if (s & SWRAP)
3132                 SPRINTF("SWRAP ");
3133         if (s & SDONE)
3134                 SPRINTF("SDONE ");
3135         if (s & SPIORDY)
3136                 SPRINTF("SPIORDY ");
3137         if (s & DMADONE)
3138                 SPRINTF("DMADONE ");
3139
3140         s = GETPORT(SSTAT1) & GETPORT(SIMODE1);
3141
3142         if (s & SELTO)
3143                 SPRINTF("SELTO ");
3144         if (s & ATNTARG)
3145                 SPRINTF("ATNTARG ");
3146         if (s & SCSIRSTI)
3147                 SPRINTF("SCSIRSTI ");
3148         if (s & PHASEMIS)
3149                 SPRINTF("PHASEMIS ");
3150         if (s & BUSFREE)
3151                 SPRINTF("BUSFREE ");
3152         if (s & SCSIPERR)
3153                 SPRINTF("SCSIPERR ");
3154         if (s & PHASECHG)
3155                 SPRINTF("PHASECHG ");
3156         if (s & REQINIT)
3157                 SPRINTF("REQINIT ");
3158         SPRINTF("); ");
3159
3160         SPRINTF("SXFRCTL0( ");
3161
3162         s = GETPORT(SXFRCTL0);
3163         if (s & SCSIEN)
3164                 SPRINTF("SCSIEN ");
3165         if (s & DMAEN)
3166                 SPRINTF("DMAEN ");
3167         if (s & CH1)
3168                 SPRINTF("CH1 ");
3169         if (s & CLRSTCNT)
3170                 SPRINTF("CLRSTCNT ");
3171         if (s & SPIOEN)
3172                 SPRINTF("SPIOEN ");
3173         if (s & CLRCH1)
3174                 SPRINTF("CLRCH1 ");
3175         SPRINTF("); ");
3176
3177         SPRINTF("SIGNAL( ");
3178
3179         s = GETPORT(SCSISIG);
3180         if (s & SIG_ATNI)
3181                 SPRINTF("ATNI ");
3182         if (s & SIG_SELI)
3183                 SPRINTF("SELI ");
3184         if (s & SIG_BSYI)
3185                 SPRINTF("BSYI ");
3186         if (s & SIG_REQI)
3187                 SPRINTF("REQI ");
3188         if (s & SIG_ACKI)
3189                 SPRINTF("ACKI ");
3190         SPRINTF("); ");
3191
3192         SPRINTF("SELID(%02x), ", GETPORT(SELID));
3193
3194         SPRINTF("STCNT(%d), ", GETSTCNT());
3195
3196         SPRINTF("SSTAT2( ");
3197
3198         s = GETPORT(SSTAT2);
3199         if (s & SOFFSET)
3200                 SPRINTF("SOFFSET ");
3201         if (s & SEMPTY)
3202                 SPRINTF("SEMPTY ");
3203         if (s & SFULL)
3204                 SPRINTF("SFULL ");
3205         SPRINTF("); SFCNT (%d); ", s & (SFULL | SFCNT));
3206
3207         s = GETPORT(SSTAT3);
3208         SPRINTF("SCSICNT (%d), OFFCNT(%d), ", (s & 0xf0) >> 4, s & 0x0f);
3209
3210         SPRINTF("SSTAT4( ");
3211         s = GETPORT(SSTAT4);
3212         if (s & SYNCERR)
3213                 SPRINTF("SYNCERR ");
3214         if (s & FWERR)
3215                 SPRINTF("FWERR ");
3216         if (s & FRERR)
3217                 SPRINTF("FRERR ");
3218         SPRINTF("); ");
3219
3220         SPRINTF("DMACNTRL0( ");
3221         s = GETPORT(DMACNTRL0);
3222         SPRINTF("%s ", s & _8BIT ? "8BIT" : "16BIT");
3223         SPRINTF("%s ", s & DMA ? "DMA" : "PIO");
3224         SPRINTF("%s ", s & WRITE_READ ? "WRITE" : "READ");
3225         if (s & ENDMA)
3226                 SPRINTF("ENDMA ");
3227         if (s & INTEN)
3228                 SPRINTF("INTEN ");
3229         if (s & RSTFIFO)
3230                 SPRINTF("RSTFIFO ");
3231         if (s & SWINT)
3232                 SPRINTF("SWINT ");
3233         SPRINTF("); ");
3234
3235         SPRINTF("DMASTAT( ");
3236         s = GETPORT(DMASTAT);
3237         if (s & ATDONE)
3238                 SPRINTF("ATDONE ");
3239         if (s & WORDRDY)
3240                 SPRINTF("WORDRDY ");
3241         if (s & DFIFOFULL)
3242                 SPRINTF("DFIFOFULL ");
3243         if (s & DFIFOEMP)
3244                 SPRINTF("DFIFOEMP ");
3245         SPRINTF(")\n");
3246
3247         SPRINTF("enabled interrupts( ");
3248
3249         s = GETPORT(SIMODE0);
3250         if (s & ENSELDO)
3251                 SPRINTF("ENSELDO ");
3252         if (s & ENSELDI)
3253                 SPRINTF("ENSELDI ");
3254         if (s & ENSELINGO)
3255                 SPRINTF("ENSELINGO ");
3256         if (s & ENSWRAP)
3257                 SPRINTF("ENSWRAP ");
3258         if (s & ENSDONE)
3259                 SPRINTF("ENSDONE ");
3260         if (s & ENSPIORDY)
3261                 SPRINTF("ENSPIORDY ");
3262         if (s & ENDMADONE)
3263                 SPRINTF("ENDMADONE ");
3264
3265         s = GETPORT(SIMODE1);
3266         if (s & ENSELTIMO)
3267                 SPRINTF("ENSELTIMO ");
3268         if (s & ENATNTARG)
3269                 SPRINTF("ENATNTARG ");
3270         if (s & ENPHASEMIS)
3271                 SPRINTF("ENPHASEMIS ");
3272         if (s & ENBUSFREE)
3273                 SPRINTF("ENBUSFREE ");
3274         if (s & ENSCSIPERR)
3275                 SPRINTF("ENSCSIPERR ");
3276         if (s & ENPHASECHG)
3277                 SPRINTF("ENPHASECHG ");
3278         if (s & ENREQINIT)
3279                 SPRINTF("ENREQINIT ");
3280         SPRINTF(")\n");
3281
3282         return (pos - start);
3283 }
3284
3285 static int aha152x_set_info(char *buffer, int length, struct Scsi_Host *shpnt)
3286 {
3287         if(!shpnt || !buffer || length<8 || strncmp("aha152x ", buffer, 8)!=0)
3288                 return -EINVAL;
3289
3290 #if defined(AHA152X_DEBUG)
3291         if(length>14 && strncmp("debug ", buffer+8, 6)==0) {
3292                 int debug = HOSTDATA(shpnt)->debug;
3293
3294                 HOSTDATA(shpnt)->debug = simple_strtoul(buffer+14, NULL, 0);
3295
3296                 printk(KERN_INFO "aha152x%d: debugging options set to 0x%04x (were 0x%04x)\n", HOSTNO, HOSTDATA(shpnt)->debug, debug);
3297         } else
3298 #endif
3299 #if defined(AHA152X_STAT)
3300         if(length>13 && strncmp("reset", buffer+8, 5)==0) {
3301                 int i;
3302
3303                 HOSTDATA(shpnt)->total_commands=0;
3304                 HOSTDATA(shpnt)->disconnections=0;
3305                 HOSTDATA(shpnt)->busfree_without_any_action=0;
3306                 HOSTDATA(shpnt)->busfree_without_old_command=0;
3307                 HOSTDATA(shpnt)->busfree_without_new_command=0;
3308                 HOSTDATA(shpnt)->busfree_without_done_command=0;
3309                 HOSTDATA(shpnt)->busfree_with_check_condition=0;
3310                 for (i = idle; i<maxstate; i++) {
3311                         HOSTDATA(shpnt)->count[i]=0;
3312                         HOSTDATA(shpnt)->count_trans[i]=0;
3313                         HOSTDATA(shpnt)->time[i]=0;
3314                 }
3315
3316                 printk(KERN_INFO "aha152x%d: stats reseted.\n", HOSTNO);
3317
3318         } else
3319 #endif
3320         {
3321                 return -EINVAL;
3322         }
3323
3324
3325         return length;
3326 }
3327
3328 #undef SPRINTF
3329 #define SPRINTF(args...) \
3330         do { if(pos < buffer + length) pos += sprintf(pos, ## args); } while(0)
3331
3332 static int aha152x_proc_info(struct Scsi_Host *shpnt, char *buffer, char **start,
3333                       off_t offset, int length, int inout)
3334 {
3335         int i;
3336         char *pos = buffer;
3337         Scsi_Cmnd *ptr;
3338         unsigned long flags;
3339         int thislength;
3340
3341         DPRINTK(debug_procinfo,
3342                KERN_DEBUG "aha152x_proc_info: buffer=%p offset=%ld length=%d hostno=%d inout=%d\n",
3343                buffer, offset, length, shpnt->host_no, inout);
3344
3345
3346         if (inout)
3347                 return aha152x_set_info(buffer, length, shpnt);
3348
3349         SPRINTF(AHA152X_REVID "\n");
3350
3351         SPRINTF("ioports 0x%04lx to 0x%04lx\n",
3352                 shpnt->io_port, shpnt->io_port + shpnt->n_io_port - 1);
3353         SPRINTF("interrupt 0x%02x\n", shpnt->irq);
3354         SPRINTF("disconnection/reconnection %s\n",
3355                 RECONNECT ? "enabled" : "disabled");
3356         SPRINTF("parity checking %s\n",
3357                 PARITY ? "enabled" : "disabled");
3358         SPRINTF("synchronous transfers %s\n",
3359                 SYNCHRONOUS ? "enabled" : "disabled");
3360         SPRINTF("%d commands currently queued\n", HOSTDATA(shpnt)->commands);
3361
3362         if(SYNCHRONOUS) {
3363                 SPRINTF("synchronously operating targets (tick=50 ns):\n");
3364                 for (i = 0; i < 8; i++)
3365                         if (HOSTDATA(shpnt)->syncrate[i] & 0x7f)
3366                                 SPRINTF("target %d: period %dT/%dns; req/ack offset %d\n",
3367                                         i,
3368                                         (((HOSTDATA(shpnt)->syncrate[i] & 0x70) >> 4) + 2),
3369                                         (((HOSTDATA(shpnt)->syncrate[i] & 0x70) >> 4) + 2) * 50,
3370                                     HOSTDATA(shpnt)->syncrate[i] & 0x0f);
3371         }
3372 #if defined(AHA152X_DEBUG)
3373 #define PDEBUG(flags,txt) \
3374         if(HOSTDATA(shpnt)->debug & flags) SPRINTF("(%s) ", txt);
3375
3376         SPRINTF("enabled debugging options: ");
3377
3378         PDEBUG(debug_procinfo, "procinfo");
3379         PDEBUG(debug_queue, "queue");
3380         PDEBUG(debug_intr, "interrupt");
3381         PDEBUG(debug_selection, "selection");
3382         PDEBUG(debug_msgo, "message out");
3383         PDEBUG(debug_msgi, "message in");
3384         PDEBUG(debug_status, "status");
3385         PDEBUG(debug_cmd, "command");
3386         PDEBUG(debug_datai, "data in");
3387         PDEBUG(debug_datao, "data out");
3388         PDEBUG(debug_eh, "eh");
3389         PDEBUG(debug_locks, "locks");
3390         PDEBUG(debug_phases, "phases");
3391
3392         SPRINTF("\n");
3393 #endif
3394
3395         SPRINTF("\nqueue status:\n");
3396         DO_LOCK(flags);
3397         if (ISSUE_SC) {
3398                 SPRINTF("not yet issued commands:\n");
3399                 for (ptr = ISSUE_SC; ptr; ptr = SCNEXT(ptr))
3400                         pos += get_command(pos, ptr);
3401         } else
3402                 SPRINTF("no not yet issued commands\n");
3403         DO_UNLOCK(flags);
3404
3405         if (CURRENT_SC) {
3406                 SPRINTF("current command:\n");
3407                 pos += get_command(pos, CURRENT_SC);
3408         } else
3409                 SPRINTF("no current command\n");
3410
3411         if (DISCONNECTED_SC) {
3412                 SPRINTF("disconnected commands:\n");
3413                 for (ptr = DISCONNECTED_SC; ptr; ptr = SCNEXT(ptr))
3414                         pos += get_command(pos, ptr);
3415         } else
3416                 SPRINTF("no disconnected commands\n");
3417
3418         pos += get_ports(shpnt, pos);
3419
3420 #if defined(AHA152X_STAT)
3421         SPRINTF("statistics:\n"
3422                 "total commands:               %d\n"
3423                 "disconnections:               %d\n"
3424                 "busfree with check condition: %d\n"
3425                 "busfree without old command:  %d\n"
3426                 "busfree without new command:  %d\n"
3427                 "busfree without done command: %d\n"
3428                 "busfree without any action:   %d\n"
3429                 "state      "
3430                 "transitions  "
3431                 "count        "
3432                 "time\n",
3433                 HOSTDATA(shpnt)->total_commands,
3434                 HOSTDATA(shpnt)->disconnections,
3435                 HOSTDATA(shpnt)->busfree_with_check_condition,
3436                 HOSTDATA(shpnt)->busfree_without_old_command,
3437                 HOSTDATA(shpnt)->busfree_without_new_command,
3438                 HOSTDATA(shpnt)->busfree_without_done_command,
3439                 HOSTDATA(shpnt)->busfree_without_any_action);
3440         for(i=0; i<maxstate; i++) {
3441                 SPRINTF("%-10s %-12d %-12d %-12ld\n",
3442                         states[i].name,
3443                         HOSTDATA(shpnt)->count_trans[i],
3444                         HOSTDATA(shpnt)->count[i],
3445                         HOSTDATA(shpnt)->time[i]);
3446         }
3447 #endif
3448
3449         DPRINTK(debug_procinfo, KERN_DEBUG "aha152x_proc_info: pos=%p\n", pos);
3450
3451         thislength = pos - (buffer + offset);
3452         DPRINTK(debug_procinfo, KERN_DEBUG "aha152x_proc_info: length=%d thislength=%d\n", length, thislength);
3453
3454         if(thislength<0) {
3455                 DPRINTK(debug_procinfo, KERN_DEBUG "aha152x_proc_info: output too short\n");
3456                 *start = NULL;
3457                 return 0;
3458         }
3459
3460         thislength = thislength<length ? thislength : length;
3461
3462         DPRINTK(debug_procinfo, KERN_DEBUG "aha152x_proc_info: return %d\n", thislength);
3463
3464         *start = buffer + offset;
3465         return thislength < length ? thislength : length;
3466 }
3467
3468 static Scsi_Host_Template aha152x_driver_template = {
3469         .module                         = THIS_MODULE,
3470         .name                           = AHA152X_REVID,
3471         .proc_name                      = "aha152x",
3472         .proc_info                      = aha152x_proc_info,
3473         .queuecommand                   = aha152x_queue,
3474         .eh_abort_handler               = aha152x_abort,
3475         .eh_device_reset_handler        = aha152x_device_reset,
3476         .eh_bus_reset_handler           = aha152x_bus_reset,
3477         .eh_host_reset_handler          = aha152x_host_reset,
3478         .bios_param                     = aha152x_biosparam,
3479         .can_queue                      = 1,
3480         .this_id                        = 7,
3481         .sg_tablesize                   = SG_ALL,
3482         .cmd_per_lun                    = 1,
3483         .use_clustering                 = DISABLE_CLUSTERING,
3484 };
3485
3486 #if !defined(PCMCIA)
3487 static int setup_count;
3488 static struct aha152x_setup setup[2];
3489
3490 /* possible i/o addresses for the AIC-6260; default first */
3491 static unsigned short ports[] = { 0x340, 0x140 };
3492
3493 #if !defined(SKIP_BIOSTEST)
3494 /* possible locations for the Adaptec BIOS; defaults first */
3495 static unsigned int addresses[] =
3496 {
3497         0xdc000,                /* default first */
3498         0xc8000,
3499         0xcc000,
3500         0xd0000,
3501         0xd4000,
3502         0xd8000,
3503         0xe0000,
3504         0xeb800,                /* VTech Platinum SMP */
3505         0xf0000,
3506 };
3507
3508 /* signatures for various AIC-6[23]60 based controllers.
3509    The point in detecting signatures is to avoid useless and maybe
3510    harmful probes on ports. I'm not sure that all listed boards pass
3511    auto-configuration. For those which fail the BIOS signature is
3512    obsolete, because user intervention to supply the configuration is
3513    needed anyway.  May be an information whether or not the BIOS supports
3514    extended translation could be also useful here. */
3515 static struct signature {
3516         unsigned char *signature;
3517         int sig_offset;
3518         int sig_length;
3519 } signatures[] =
3520 {
3521         { "Adaptec AHA-1520 BIOS",      0x102e, 21 },
3522                 /* Adaptec 152x */
3523         { "Adaptec AHA-1520B",          0x000b, 17 },
3524                 /* Adaptec 152x rev B */
3525         { "Adaptec AHA-1520B",          0x0026, 17 },
3526                 /* Iomega Jaz Jet ISA (AIC6370Q) */
3527         { "Adaptec ASW-B626 BIOS",      0x1029, 21 },
3528                 /* on-board controller */
3529         { "Adaptec BIOS: ASW-B626",     0x000f, 22 },
3530                 /* on-board controller */
3531         { "Adaptec ASW-B626 S2",        0x2e6c, 19 },
3532                 /* on-board controller */
3533         { "Adaptec BIOS:AIC-6360",      0x000c, 21 },
3534                 /* on-board controller */
3535         { "ScsiPro SP-360 BIOS",        0x2873, 19 },
3536                 /* ScsiPro-Controller  */
3537         { "GA-400 LOCAL BUS SCSI BIOS", 0x102e, 26 },
3538                 /* Gigabyte Local-Bus-SCSI */
3539         { "Adaptec BIOS:AVA-282X",      0x000c, 21 },
3540                 /* Adaptec 282x */
3541         { "Adaptec IBM Dock II SCSI",   0x2edd, 24 },
3542                 /* IBM Thinkpad Dock II */
3543         { "Adaptec BIOS:AHA-1532P",     0x001c, 22 },
3544                 /* IBM Thinkpad Dock II SCSI */
3545         { "DTC3520A Host Adapter BIOS", 0x318a, 26 },
3546                 /* DTC 3520A ISA SCSI */
3547 };
3548 #endif /* !SKIP_BIOSTEST */
3549
3550 /*
3551  * Test, if port_base is valid.
3552  *
3553  */
3554 static int aha152x_porttest(int io_port)
3555 {
3556         int i;
3557
3558         SETPORT(io_port + O_DMACNTRL1, 0);      /* reset stack pointer */
3559         for (i = 0; i < 16; i++)
3560                 SETPORT(io_port + O_STACK, i);
3561
3562         SETPORT(io_port + O_DMACNTRL1, 0);      /* reset stack pointer */
3563         for (i = 0; i < 16 && GETPORT(io_port + O_STACK) == i; i++)
3564                 ;
3565
3566         return (i == 16);
3567 }
3568
3569 static int tc1550_porttest(int io_port)
3570 {
3571         int i;
3572
3573         SETPORT(io_port + O_TC_DMACNTRL1, 0);   /* reset stack pointer */
3574         for (i = 0; i < 16; i++)
3575                 SETPORT(io_port + O_STACK, i);
3576
3577         SETPORT(io_port + O_TC_DMACNTRL1, 0);   /* reset stack pointer */
3578         for (i = 0; i < 16 && GETPORT(io_port + O_TC_STACK) == i; i++)
3579                 ;
3580
3581         return (i == 16);
3582 }
3583
3584
3585 static int checksetup(struct aha152x_setup *setup)
3586 {
3587         int i;
3588         for (i = 0; i < ARRAY_SIZE(ports) && (setup->io_port != ports[i]); i++)
3589                 ;
3590
3591         if (i == ARRAY_SIZE(ports))
3592                 return 0;
3593
3594         if ( request_region(setup->io_port, IO_RANGE, "aha152x")==0 ) {
3595                 printk(KERN_ERR "aha152x: io port 0x%x busy.\n", setup->io_port);
3596                 return 0;
3597         }
3598
3599         if( aha152x_porttest(setup->io_port) ) {
3600                 setup->tc1550=0;
3601         } else if( tc1550_porttest(setup->io_port) ) {
3602                 setup->tc1550=1;
3603         } else {
3604                 release_region(setup->io_port, IO_RANGE);
3605                 return 0;
3606         }
3607
3608         release_region(setup->io_port, IO_RANGE);
3609
3610         if ((setup->irq < IRQ_MIN) || (setup->irq > IRQ_MAX))
3611                 return 0;
3612
3613         if ((setup->scsiid < 0) || (setup->scsiid > 7))
3614                 return 0;
3615
3616         if ((setup->reconnect < 0) || (setup->reconnect > 1))
3617                 return 0;
3618
3619         if ((setup->parity < 0) || (setup->parity > 1))
3620                 return 0;
3621
3622         if ((setup->synchronous < 0) || (setup->synchronous > 1))
3623                 return 0;
3624
3625         if ((setup->ext_trans < 0) || (setup->ext_trans > 1))
3626                 return 0;
3627
3628
3629         return 1;
3630 }
3631
3632
3633 static int __init aha152x_init(void)
3634 {
3635         int i, j, ok;
3636 #if defined(AUTOCONF)
3637         aha152x_config conf;
3638 #endif
3639 #ifdef __ISAPNP__
3640         struct pnp_dev *dev=NULL, *pnpdev[2] = {NULL, NULL};
3641 #endif
3642
3643         if ( setup_count ) {
3644                 printk(KERN_INFO "aha152x: processing commandline: ");
3645
3646                 for (i = 0; i<setup_count; i++) {
3647                         if (!checksetup(&setup[i])) {
3648                                 printk(KERN_ERR "\naha152x: %s\n", setup[i].conf);
3649                                 printk(KERN_ERR "aha152x: invalid line\n");
3650                         }
3651                 }
3652                 printk("ok\n");
3653         }
3654
3655 #if defined(SETUP0)
3656         if (setup_count < ARRAY_SIZE(setup)) {
3657                 struct aha152x_setup override = SETUP0;
3658
3659                 if (setup_count == 0 || (override.io_port != setup[0].io_port)) {
3660                         if (!checksetup(&override)) {
3661                                 printk(KERN_ERR "\naha152x: invalid override SETUP0={0x%x,%d,%d,%d,%d,%d,%d,%d}\n",
3662                                        override.io_port,
3663                                        override.irq,
3664                                        override.scsiid,
3665                                        override.reconnect,
3666                                        override.parity,
3667                                        override.synchronous,
3668                                        override.delay,
3669                                        override.ext_trans);
3670                         } else
3671                                 setup[setup_count++] = override;
3672                 }
3673         }
3674 #endif
3675
3676 #if defined(SETUP1)
3677         if (setup_count < ARRAY_SIZE(setup)) {
3678                 struct aha152x_setup override = SETUP1;
3679
3680                 if (setup_count == 0 || (override.io_port != setup[0].io_port)) {
3681                         if (!checksetup(&override)) {
3682                                 printk(KERN_ERR "\naha152x: invalid override SETUP1={0x%x,%d,%d,%d,%d,%d,%d,%d}\n",
3683                                        override.io_port,
3684                                        override.irq,
3685                                        override.scsiid,
3686                                        override.reconnect,
3687                                        override.parity,
3688                                        override.synchronous,
3689                                        override.delay,
3690                                        override.ext_trans);
3691                         } else
3692                                 setup[setup_count++] = override;
3693                 }
3694         }
3695 #endif
3696
3697 #if defined(MODULE)
3698         if (setup_count<ARRAY_SIZE(setup) && (aha152x[0]!=0 || io[0]!=0 || irq[0]!=0)) {
3699                 if(aha152x[0]!=0) {
3700                         setup[setup_count].conf        = "";
3701                         setup[setup_count].io_port     = aha152x[0];
3702                         setup[setup_count].irq         = aha152x[1];
3703                         setup[setup_count].scsiid      = aha152x[2];
3704                         setup[setup_count].reconnect   = aha152x[3];
3705                         setup[setup_count].parity      = aha152x[4];
3706                         setup[setup_count].synchronous = aha152x[5];
3707                         setup[setup_count].delay       = aha152x[6];
3708                         setup[setup_count].ext_trans   = aha152x[7];
3709 #if defined(AHA152X_DEBUG)
3710                         setup[setup_count].debug       = aha152x[8];
3711 #endif
3712                 } else if(io[0]!=0 || irq[0]!=0) {
3713                         if(io[0]!=0)  setup[setup_count].io_port = io[0];
3714                         if(irq[0]!=0) setup[setup_count].irq     = irq[0];
3715
3716                         setup[setup_count].scsiid      = scsiid[0];
3717                         setup[setup_count].reconnect   = reconnect[0];
3718                         setup[setup_count].parity      = parity[0];
3719                         setup[setup_count].synchronous = sync[0];
3720                         setup[setup_count].delay       = delay[0];
3721                         setup[setup_count].ext_trans   = exttrans[0];
3722 #if defined(AHA152X_DEBUG)
3723                         setup[setup_count].debug       = debug[0];
3724 #endif
3725                 }
3726
3727                 if (checksetup(&setup[setup_count]))
3728                         setup_count++;
3729                 else
3730                         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",
3731                                setup[setup_count].io_port,
3732                                setup[setup_count].irq,
3733                                setup[setup_count].scsiid,
3734                                setup[setup_count].reconnect,
3735                                setup[setup_count].parity,
3736                                setup[setup_count].synchronous,
3737                                setup[setup_count].delay,
3738                                setup[setup_count].ext_trans);
3739         }
3740
3741         if (setup_count<ARRAY_SIZE(setup) && (aha152x1[0]!=0 || io[1]!=0 || irq[1]!=0)) {
3742                 if(aha152x1[0]!=0) {
3743                         setup[setup_count].conf        = "";
3744                         setup[setup_count].io_port     = aha152x1[0];
3745                         setup[setup_count].irq         = aha152x1[1];
3746                         setup[setup_count].scsiid      = aha152x1[2];
3747                         setup[setup_count].reconnect   = aha152x1[3];
3748                         setup[setup_count].parity      = aha152x1[4];
3749                         setup[setup_count].synchronous = aha152x1[5];
3750                         setup[setup_count].delay       = aha152x1[6];
3751                         setup[setup_count].ext_trans   = aha152x1[7];
3752 #if defined(AHA152X_DEBUG)
3753                         setup[setup_count].debug       = aha152x1[8];
3754 #endif
3755                 } else if(io[1]!=0 || irq[1]!=0) {
3756                         if(io[1]!=0)  setup[setup_count].io_port = io[1];
3757                         if(irq[1]!=0) setup[setup_count].irq     = irq[1];
3758
3759                         setup[setup_count].scsiid      = scsiid[1];
3760                         setup[setup_count].reconnect   = reconnect[1];
3761                         setup[setup_count].parity      = parity[1];
3762                         setup[setup_count].synchronous = sync[1];
3763                         setup[setup_count].delay       = delay[1];
3764                         setup[setup_count].ext_trans   = exttrans[1];
3765 #if defined(AHA152X_DEBUG)
3766                         setup[setup_count].debug       = debug[1];
3767 #endif
3768                 }
3769                 if (checksetup(&setup[setup_count]))
3770                         setup_count++;
3771                 else
3772                         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",
3773                                setup[setup_count].io_port,
3774                                setup[setup_count].irq,
3775                                setup[setup_count].scsiid,
3776                                setup[setup_count].reconnect,
3777                                setup[setup_count].parity,
3778                                setup[setup_count].synchronous,
3779                                setup[setup_count].delay,
3780                                setup[setup_count].ext_trans);
3781         }
3782 #endif
3783
3784 #ifdef __ISAPNP__
3785         for(i=0; setup_count<ARRAY_SIZE(setup) && id_table[i].vendor; i++) {
3786                 while ( setup_count<ARRAY_SIZE(setup) &&
3787                         (dev=pnp_find_dev(NULL, id_table[i].vendor, id_table[i].function, dev)) ) {
3788                         if (pnp_device_attach(dev) < 0)
3789                                 continue;
3790
3791                         if (pnp_activate_dev(dev) < 0) {
3792                                 pnp_device_detach(dev);
3793                                 continue;
3794                         }
3795
3796                         if (!pnp_port_valid(dev, 0)) {
3797                                 pnp_device_detach(dev);
3798                                 continue;
3799                         }
3800
3801                         if (setup_count==1 && pnp_port_start(dev, 0)==setup[0].io_port) {
3802                                 pnp_device_detach(dev);
3803                                 continue;
3804                         }
3805
3806                         setup[setup_count].io_port     = pnp_port_start(dev, 0);
3807                         setup[setup_count].irq         = pnp_irq(dev, 0);
3808                         setup[setup_count].scsiid      = 7;
3809                         setup[setup_count].reconnect   = 1;
3810                         setup[setup_count].parity      = 1;
3811                         setup[setup_count].synchronous = 1;
3812                         setup[setup_count].delay       = DELAY_DEFAULT;
3813                         setup[setup_count].ext_trans   = 0;
3814 #if defined(AHA152X_DEBUG)
3815                         setup[setup_count].debug       = DEBUG_DEFAULT;
3816 #endif
3817 #if defined(__ISAPNP__)
3818                         pnpdev[setup_count]            = dev;
3819 #endif
3820                         printk (KERN_INFO
3821                                 "aha152x: found ISAPnP adapter at io=0x%03x, irq=%d\n",
3822                                 setup[setup_count].io_port, setup[setup_count].irq);
3823                         setup_count++;
3824                 }
3825         }
3826 #endif
3827
3828 #if defined(AUTOCONF)
3829         if (setup_count<ARRAY_SIZE(setup)) {
3830 #if !defined(SKIP_BIOSTEST)
3831                 ok = 0;
3832                 for (i = 0; i < ARRAY_SIZE(addresses) && !ok; i++) {
3833                         void __iomem *p = ioremap(addresses[i], 0x4000);
3834                         if (!p)
3835                                 continue;
3836                         for (j = 0; j<ARRAY_SIZE(signatures) && !ok; j++)
3837                                 ok = check_signature(p + signatures[j].sig_offset,
3838                                                                 signatures[j].signature, signatures[j].sig_length);
3839                         iounmap(p);
3840                 }
3841                 if (!ok && setup_count == 0)
3842                         return 0;
3843
3844                 printk(KERN_INFO "aha152x: BIOS test: passed, ");
3845 #else
3846                 printk(KERN_INFO "aha152x: ");
3847 #endif                          /* !SKIP_BIOSTEST */
3848
3849                 ok = 0;
3850                 for (i = 0; i < ARRAY_SIZE(ports) && setup_count < 2; i++) {
3851                         if ((setup_count == 1) && (setup[0].io_port == ports[i]))
3852                                 continue;
3853
3854                         if ( request_region(ports[i], IO_RANGE, "aha152x")==0 ) {
3855                                 printk(KERN_ERR "aha152x: io port 0x%x busy.\n", ports[i]);
3856                                 continue;
3857                         }
3858
3859                         if (aha152x_porttest(ports[i])) {
3860                                 setup[setup_count].tc1550  = 0;
3861
3862                                 conf.cf_port =
3863                                     (GETPORT(ports[i] + O_PORTA) << 8) + GETPORT(ports[i] + O_PORTB);
3864                         } else if (tc1550_porttest(ports[i])) {
3865                                 setup[setup_count].tc1550  = 1;
3866
3867                                 conf.cf_port =
3868                                     (GETPORT(ports[i] + O_TC_PORTA) << 8) + GETPORT(ports[i] + O_TC_PORTB);
3869                         } else {
3870                                 release_region(ports[i], IO_RANGE);
3871                                 continue;
3872                         }
3873
3874                         release_region(ports[i], IO_RANGE);
3875
3876                         ok++;
3877                         setup[setup_count].io_port = ports[i];
3878                         setup[setup_count].irq = IRQ_MIN + conf.cf_irq;
3879                         setup[setup_count].scsiid = conf.cf_id;
3880                         setup[setup_count].reconnect = conf.cf_tardisc;
3881                         setup[setup_count].parity = !conf.cf_parity;
3882                         setup[setup_count].synchronous = conf.cf_syncneg;
3883                         setup[setup_count].delay = DELAY_DEFAULT;
3884                         setup[setup_count].ext_trans = 0;
3885 #if defined(AHA152X_DEBUG)
3886                         setup[setup_count].debug = DEBUG_DEFAULT;
3887 #endif
3888                         setup_count++;
3889
3890                 }
3891
3892                 if (ok)
3893                         printk("auto configuration: ok, ");
3894         }
3895 #endif
3896
3897         printk("%d controller(s) configured\n", setup_count);
3898
3899         for (i=0; i<setup_count; i++) {
3900                 if ( request_region(setup[i].io_port, IO_RANGE, "aha152x") ) {
3901                         struct Scsi_Host *shpnt = aha152x_probe_one(&setup[i]);
3902
3903                         if( !shpnt ) {
3904                                 release_region(setup[i].io_port, IO_RANGE);
3905 #if defined(__ISAPNP__)
3906                         } else if( pnpdev[i] ) {
3907                                 HOSTDATA(shpnt)->pnpdev=pnpdev[i];
3908                                 pnpdev[i]=NULL;
3909 #endif
3910                         }
3911                 } else {
3912                         printk(KERN_ERR "aha152x: io port 0x%x busy.\n", setup[i].io_port);
3913                 }
3914
3915 #if defined(__ISAPNP__)
3916                 if( pnpdev[i] )
3917                         pnp_device_detach(pnpdev[i]);
3918 #endif
3919         }
3920
3921         return registered_count>0;
3922 }
3923
3924 static void __exit aha152x_exit(void)
3925 {
3926         int i;
3927
3928         for(i=0; i<ARRAY_SIZE(setup); i++) {
3929                 aha152x_release(aha152x_host[i]);
3930                 aha152x_host[i]=NULL;
3931         }
3932 }
3933
3934 module_init(aha152x_init);
3935 module_exit(aha152x_exit);
3936
3937 #if !defined(MODULE)
3938 static int __init aha152x_setup(char *str)
3939 {
3940 #if defined(AHA152X_DEBUG)
3941         int ints[11];
3942 #else
3943         int ints[10];
3944 #endif
3945         get_options(str, ARRAY_SIZE(ints), ints);
3946
3947         if(setup_count>=ARRAY_SIZE(setup)) {
3948                 printk(KERN_ERR "aha152x: you can only configure up to two controllers\n");
3949                 return 1;
3950         }
3951
3952         setup[setup_count].conf        = str;
3953         setup[setup_count].io_port     = ints[0] >= 1 ? ints[1] : 0x340;
3954         setup[setup_count].irq         = ints[0] >= 2 ? ints[2] : 11;
3955         setup[setup_count].scsiid      = ints[0] >= 3 ? ints[3] : 7;
3956         setup[setup_count].reconnect   = ints[0] >= 4 ? ints[4] : 1;
3957         setup[setup_count].parity      = ints[0] >= 5 ? ints[5] : 1;
3958         setup[setup_count].synchronous = ints[0] >= 6 ? ints[6] : 1;
3959         setup[setup_count].delay       = ints[0] >= 7 ? ints[7] : DELAY_DEFAULT;
3960         setup[setup_count].ext_trans   = ints[0] >= 8 ? ints[8] : 0;
3961 #if defined(AHA152X_DEBUG)
3962         setup[setup_count].debug       = ints[0] >= 9 ? ints[9] : DEBUG_DEFAULT;
3963         if (ints[0] > 9) {
3964                 printk(KERN_NOTICE "aha152x: usage: aha152x=<IOBASE>[,<IRQ>[,<SCSI ID>"
3965                        "[,<RECONNECT>[,<PARITY>[,<SYNCHRONOUS>[,<DELAY>[,<EXT_TRANS>[,<DEBUG>]]]]]]]]\n");
3966 #else
3967         if (ints[0] > 8) {                                                /*}*/
3968                 printk(KERN_NOTICE "aha152x: usage: aha152x=<IOBASE>[,<IRQ>[,<SCSI ID>"
3969                        "[,<RECONNECT>[,<PARITY>[,<SYNCHRONOUS>[,<DELAY>[,<EXT_TRANS>]]]]]]]\n");
3970 #endif
3971         } else {
3972                 setup_count++;
3973                 return 0;
3974         }
3975
3976         return 1;
3977 }
3978 __setup("aha152x=", aha152x_setup);
3979 #endif
3980
3981 #endif /* !PCMCIA */