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