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, IRQF_DISABLED|IRQF_SHARED, "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, IRQF_DISABLED|IRQF_SHARED, "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                 MSGOLEN += spi_populate_sync_msg(&MSGO(MSGOLEN), 50, 8);
1720                 SYNCNEG=1;              /* negotiation in progress */
1721         }
1722
1723         SETRATE(SYNCRATE);
1724 }
1725
1726 /*
1727  * Selection timeout
1728  * - return command to mid-level with failure cause
1729  *
1730  */
1731 static void selto_run(struct Scsi_Host *shpnt)
1732 {
1733         SETPORT(SCSISEQ, 0);
1734         SETPORT(SSTAT1, CLRSELTIMO);
1735
1736         DPRINTK(debug_selection, DEBUG_LEAD "selection timeout\n", CMDINFO(CURRENT_SC));
1737
1738         if(!CURRENT_SC) {
1739                 DPRINTK(debug_selection, DEBUG_LEAD "!CURRENT_SC\n", CMDINFO(CURRENT_SC));
1740                 return;
1741         }
1742
1743         CURRENT_SC->SCp.phase &= ~selecting;
1744
1745         if (CURRENT_SC->SCp.phase & aborted) {
1746                 DPRINTK(debug_selection, DEBUG_LEAD "aborted\n", CMDINFO(CURRENT_SC));
1747                 done(shpnt, DID_ABORT << 16);
1748         } else if (TESTLO(SSTAT0, SELINGO)) {
1749                 DPRINTK(debug_selection, DEBUG_LEAD "arbitration not won\n", CMDINFO(CURRENT_SC));
1750                 done(shpnt, DID_BUS_BUSY << 16);
1751         } else {
1752                 /* ARBITRATION won, but SELECTION failed */
1753                 DPRINTK(debug_selection, DEBUG_LEAD "selection failed\n", CMDINFO(CURRENT_SC));
1754                 done(shpnt, DID_NO_CONNECT << 16);
1755         }
1756 }
1757
1758 /*
1759  * Selection in done
1760  * - put current command back to issue queue
1761  *   (reconnection of a disconnected nexus instead
1762  *    of successful selection out)
1763  *
1764  */
1765 static void seldi_run(struct Scsi_Host *shpnt)
1766 {
1767         int selid;
1768         int target;
1769         unsigned long flags;
1770
1771         SETPORT(SCSISIG, 0);
1772         SETPORT(SSTAT0, CLRSELDI);
1773         SETPORT(SSTAT1, CLRBUSFREE);
1774         SETPORT(SSTAT1, CLRPHASECHG);
1775
1776         if(CURRENT_SC) {
1777                 if(!(CURRENT_SC->SCp.phase & not_issued))
1778                         printk(ERR_LEAD "command should not have been issued yet\n", CMDINFO(CURRENT_SC));
1779
1780                 DPRINTK(debug_selection, ERR_LEAD "command requeued - reselection\n", CMDINFO(CURRENT_SC));
1781
1782                 DO_LOCK(flags);
1783                 append_SC(&ISSUE_SC, CURRENT_SC);
1784                 DO_UNLOCK(flags);
1785
1786                 CURRENT_SC = NULL;
1787         }
1788
1789         if(!DISCONNECTED_SC) {
1790                 DPRINTK(debug_selection, DEBUG_LEAD "unexpected SELDI ", CMDINFO(CURRENT_SC));
1791                 return;
1792         }
1793
1794         RECONN_TARGET=-1;
1795
1796         selid = GETPORT(SELID) & ~(1 << shpnt->this_id);
1797
1798         if (selid==0) {
1799                 printk("aha152x%d: target id unknown (%02x)\n", HOSTNO, selid);
1800                 return;
1801         }
1802
1803         for(target=7; !(selid & (1 << target)); target--)
1804                 ;
1805
1806         if(selid & ~(1 << target)) {
1807                 printk("aha152x%d: multiple targets reconnected (%02x)\n",
1808                        HOSTNO, selid);
1809         }
1810
1811
1812         SETPORT(SCSIID, (shpnt->this_id << OID_) | target);
1813         SETPORT(SCSISEQ, 0);
1814
1815         SETRATE(HOSTDATA(shpnt)->syncrate[target]);
1816
1817         RECONN_TARGET=target;
1818         DPRINTK(debug_selection, DEBUG_LEAD "target %d reselected (%02x).\n", CMDINFO(CURRENT_SC), target, selid);
1819 }
1820
1821 /*
1822  * message in phase
1823  * - handle initial message after reconnection to identify
1824  *   reconnecting nexus
1825  * - queue command on DISCONNECTED_SC on DISCONNECT message
1826  * - set completed flag on COMMAND COMPLETE
1827  *   (other completition code moved to busfree_run)
1828  * - handle response to SDTR
1829  * - clear synchronous transfer agreements on BUS RESET
1830  *
1831  * FIXME: what about SAVE POINTERS, RESTORE POINTERS?
1832  *
1833  */
1834 static void msgi_run(struct Scsi_Host *shpnt)
1835 {
1836         for(;;) {
1837                 int sstat1 = GETPORT(SSTAT1);
1838
1839                 if(sstat1 & (PHASECHG|PHASEMIS|BUSFREE) || !(sstat1 & REQINIT))
1840                         return;
1841
1842                 if(TESTLO(SSTAT0,SPIORDY)) {
1843                         DPRINTK(debug_msgi, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
1844                         return;
1845                 }
1846
1847                 ADDMSGI(GETPORT(SCSIDAT));
1848
1849 #if defined(AHA152X_DEBUG)
1850                 if (HOSTDATA(shpnt)->debug & debug_msgi) {
1851                         printk(INFO_LEAD "inbound message %02x ", CMDINFO(CURRENT_SC), MSGI(0));
1852                         spi_print_msg(&MSGI(0));
1853                         printk("\n");
1854                 }
1855 #endif
1856
1857                 if(!CURRENT_SC) {
1858                         if(LASTSTATE!=seldi) {
1859                                 printk(KERN_ERR "aha152x%d: message in w/o current command not after reselection\n", HOSTNO);
1860                         }
1861
1862                         /*
1863                          * Handle reselection
1864                          */
1865                         if(!(MSGI(0) & IDENTIFY_BASE)) {
1866                                 printk(KERN_ERR "aha152x%d: target didn't identify after reselection\n", HOSTNO);
1867                                 continue;
1868                         }
1869
1870                         CURRENT_SC = remove_lun_SC(&DISCONNECTED_SC, RECONN_TARGET, MSGI(0) & 0x3f);
1871
1872                         if (!CURRENT_SC) {
1873                                 show_queues(shpnt);
1874                                 printk(KERN_ERR "aha152x%d: no disconnected command for target %d/%d\n", HOSTNO, RECONN_TARGET, MSGI(0) & 0x3f);
1875                                 continue;
1876                         }
1877
1878                         DPRINTK(debug_msgi, DEBUG_LEAD "target reconnected\n", CMDINFO(CURRENT_SC));
1879
1880                         CURRENT_SC->SCp.Message = MSGI(0);
1881                         CURRENT_SC->SCp.phase &= ~disconnected;
1882
1883                         MSGILEN=0;
1884
1885                         /* next message if any */
1886                         continue;
1887                 }
1888
1889                 CURRENT_SC->SCp.Message = MSGI(0);
1890
1891                 switch (MSGI(0)) {
1892                 case DISCONNECT:
1893                         if (!RECONNECT)
1894                                 printk(WARN_LEAD "target was not allowed to disconnect\n", CMDINFO(CURRENT_SC));
1895
1896                         CURRENT_SC->SCp.phase |= disconnected;
1897                         break;
1898
1899                 case COMMAND_COMPLETE:
1900                         if(CURRENT_SC->SCp.phase & completed)
1901                                 DPRINTK(debug_msgi, DEBUG_LEAD "again COMMAND COMPLETE\n", CMDINFO(CURRENT_SC));
1902
1903                         CURRENT_SC->SCp.phase |= completed;
1904                         break;
1905
1906                 case MESSAGE_REJECT:
1907                         if (SYNCNEG==1) {
1908                                 printk(INFO_LEAD "Synchronous Data Transfer Request was rejected\n", CMDINFO(CURRENT_SC));
1909                                 SYNCNEG=2;      /* negotiation completed */
1910                         } else
1911                                 printk(INFO_LEAD "inbound message (MESSAGE REJECT)\n", CMDINFO(CURRENT_SC));
1912                         break;
1913
1914                 case SAVE_POINTERS:
1915                         break;
1916
1917                 case RESTORE_POINTERS:
1918                         break;
1919
1920                 case EXTENDED_MESSAGE:
1921                         if(MSGILEN<2 || MSGILEN<MSGI(1)+2) {
1922                                 /* not yet completed */
1923                                 continue;
1924                         }
1925
1926                         switch (MSGI(2)) {
1927                         case EXTENDED_SDTR:
1928                                 {
1929                                         long ticks;
1930
1931                                         if (MSGI(1) != 3) {
1932                                                 printk(ERR_LEAD "SDTR message length!=3\n", CMDINFO(CURRENT_SC));
1933                                                 break;
1934                                         }
1935
1936                                         if (!HOSTDATA(shpnt)->synchronous)
1937                                                 break;
1938
1939                                         printk(INFO_LEAD, CMDINFO(CURRENT_SC));
1940                                         spi_print_msg(&MSGI(0));
1941                                         printk("\n");
1942
1943                                         ticks = (MSGI(3) * 4 + 49) / 50;
1944
1945                                         if (syncneg) {
1946                                                 /* negotiation in progress */
1947                                                 if (ticks > 9 || MSGI(4) < 1 || MSGI(4) > 8) {
1948                                                         ADDMSGO(MESSAGE_REJECT);
1949                                                         printk(INFO_LEAD "received Synchronous Data Transfer Request invalid - rejected\n", CMDINFO(CURRENT_SC));
1950                                                         break;
1951                                                 }
1952
1953                                                 SYNCRATE |= ((ticks - 2) << 4) + MSGI(4);
1954                                         } else if (ticks <= 9 && MSGI(4) >= 1) {
1955                                                 ADDMSGO(EXTENDED_MESSAGE);
1956                                                 ADDMSGO(3);
1957                                                 ADDMSGO(EXTENDED_SDTR);
1958                                                 if (ticks < 4) {
1959                                                         ticks = 4;
1960                                                         ADDMSGO(50);
1961                                                 } else
1962                                                         ADDMSGO(MSGI(3));
1963
1964                                                 if (MSGI(4) > 8)
1965                                                         MSGI(4) = 8;
1966
1967                                                 ADDMSGO(MSGI(4));
1968
1969                                                 SYNCRATE |= ((ticks - 2) << 4) + MSGI(4);
1970                                         } else {
1971                                                 /* requested SDTR is too slow, do it asynchronously */
1972                                                 printk(INFO_LEAD "Synchronous Data Transfer Request too slow - Rejecting\n", CMDINFO(CURRENT_SC));
1973                                                 ADDMSGO(MESSAGE_REJECT);
1974                                         }
1975
1976                                         SYNCNEG=2;              /* negotiation completed */
1977                                         SETRATE(SYNCRATE);
1978                                 }
1979                                 break;
1980
1981                         case BUS_DEVICE_RESET:
1982                                 {
1983                                         int i;
1984
1985                                         for(i=0; i<8; i++) {
1986                                                 HOSTDATA(shpnt)->syncrate[i]=0;
1987                                                 HOSTDATA(shpnt)->syncneg[i]=0;
1988                                         }
1989
1990                                 }
1991                                 break;
1992
1993                         case EXTENDED_MODIFY_DATA_POINTER:
1994                         case EXTENDED_EXTENDED_IDENTIFY:
1995                         case EXTENDED_WDTR:
1996                         default:
1997                                 ADDMSGO(MESSAGE_REJECT);
1998                                 break;
1999                         }
2000                         break;
2001                 }
2002
2003                 MSGILEN=0;
2004         }
2005 }
2006
2007 static void msgi_end(struct Scsi_Host *shpnt)
2008 {
2009         if(MSGILEN>0)
2010                 printk(WARN_LEAD "target left before message completed (%d)\n", CMDINFO(CURRENT_SC), MSGILEN);
2011
2012         if (MSGOLEN > 0 && !(GETPORT(SSTAT1) & BUSFREE)) {
2013                 DPRINTK(debug_msgi, DEBUG_LEAD "msgo pending\n", CMDINFO(CURRENT_SC));
2014                 SETPORT(SCSISIG, P_MSGI | SIG_ATNO);
2015         }
2016 }
2017
2018 /*
2019  * message out phase
2020  *
2021  */
2022 static void msgo_init(struct Scsi_Host *shpnt)
2023 {
2024         if(MSGOLEN==0) {
2025                 if((CURRENT_SC->SCp.phase & syncneg) && SYNCNEG==2 && SYNCRATE==0) {
2026                         ADDMSGO(IDENTIFY(RECONNECT, CURRENT_SC->device->lun));
2027                 } else {
2028                         printk(INFO_LEAD "unexpected MESSAGE OUT phase; rejecting\n", CMDINFO(CURRENT_SC));
2029                         ADDMSGO(MESSAGE_REJECT);
2030                 }
2031         }
2032
2033 #if defined(AHA152X_DEBUG)
2034         if(HOSTDATA(shpnt)->debug & debug_msgo) {
2035                 int i;
2036
2037                 printk(DEBUG_LEAD "messages( ", CMDINFO(CURRENT_SC));
2038                 for (i=0; i<MSGOLEN; i+=spi_print_msg(&MSGO(i)), printk(" "))
2039                         ;
2040                 printk(")\n");
2041         }
2042 #endif
2043 }
2044
2045 /*
2046  * message out phase
2047  *
2048  */
2049 static void msgo_run(struct Scsi_Host *shpnt)
2050 {
2051         if(MSGO_I==MSGOLEN)
2052                 DPRINTK(debug_msgo, DEBUG_LEAD "messages all sent (%d/%d)\n", CMDINFO(CURRENT_SC), MSGO_I, MSGOLEN);
2053
2054         while(MSGO_I<MSGOLEN) {
2055                 DPRINTK(debug_msgo, DEBUG_LEAD "message byte %02x (%d/%d)\n", CMDINFO(CURRENT_SC), MSGO(MSGO_I), MSGO_I, MSGOLEN);
2056
2057                 if(TESTLO(SSTAT0, SPIORDY)) {
2058                         DPRINTK(debug_msgo, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
2059                         return;
2060                 }
2061
2062                 if (MSGO_I==MSGOLEN-1) {
2063                         /* Leave MESSAGE OUT after transfer */
2064                         SETPORT(SSTAT1, CLRATNO);
2065                 }
2066
2067
2068                 if (MSGO(MSGO_I) & IDENTIFY_BASE)
2069                         CURRENT_SC->SCp.phase |= identified;
2070
2071                 if (MSGO(MSGO_I)==ABORT)
2072                         CURRENT_SC->SCp.phase |= aborted;
2073
2074                 if (MSGO(MSGO_I)==BUS_DEVICE_RESET)
2075                         CURRENT_SC->SCp.phase |= resetted;
2076
2077                 SETPORT(SCSIDAT, MSGO(MSGO_I++));
2078         }
2079 }
2080
2081 static void msgo_end(struct Scsi_Host *shpnt)
2082 {
2083         if(MSGO_I<MSGOLEN) {
2084                 printk(ERR_LEAD "message sent incompletely (%d/%d)\n", CMDINFO(CURRENT_SC), MSGO_I, MSGOLEN);
2085                 if(SYNCNEG==1) {
2086                         printk(INFO_LEAD "Synchronous Data Transfer Request was rejected\n", CMDINFO(CURRENT_SC));
2087                         SYNCNEG=2;
2088                 }
2089         }
2090
2091         MSGO_I  = 0;
2092         MSGOLEN = 0;
2093 }
2094
2095 /*
2096  * command phase
2097  *
2098  */
2099 static void cmd_init(struct Scsi_Host *shpnt)
2100 {
2101         if (CURRENT_SC->SCp.sent_command) {
2102                 printk(ERR_LEAD "command already sent\n", CMDINFO(CURRENT_SC));
2103                 done(shpnt, DID_ERROR << 16);
2104                 return;
2105         }
2106
2107 #if defined(AHA152X_DEBUG)
2108         if (HOSTDATA(shpnt)->debug & debug_cmd) {
2109                 printk(DEBUG_LEAD "cmd_init: ", CMDINFO(CURRENT_SC));
2110                 __scsi_print_command(CURRENT_SC->cmnd);
2111         }
2112 #endif
2113
2114         CMD_I=0;
2115 }
2116
2117 /*
2118  * command phase
2119  *
2120  */
2121 static void cmd_run(struct Scsi_Host *shpnt)
2122 {
2123         if(CMD_I==CURRENT_SC->cmd_len) {
2124                 DPRINTK(debug_cmd, DEBUG_LEAD "command already completely sent (%d/%d)", CMDINFO(CURRENT_SC), CMD_I, CURRENT_SC->cmd_len);
2125                 disp_ports(shpnt);
2126         }
2127
2128         while(CMD_I<CURRENT_SC->cmd_len) {
2129                 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);
2130
2131                 if(TESTLO(SSTAT0, SPIORDY)) {
2132                         DPRINTK(debug_cmd, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
2133                         return;
2134                 }
2135
2136                 SETPORT(SCSIDAT, CURRENT_SC->cmnd[CMD_I++]);
2137         }
2138 }
2139
2140 static void cmd_end(struct Scsi_Host *shpnt)
2141 {
2142         if(CMD_I<CURRENT_SC->cmd_len)
2143                 printk(ERR_LEAD "command sent incompletely (%d/%d)\n", CMDINFO(CURRENT_SC), CMD_I, CURRENT_SC->cmd_len);
2144         else
2145                 CURRENT_SC->SCp.sent_command++;
2146 }
2147
2148 /*
2149  * status phase
2150  *
2151  */
2152 static void status_run(struct Scsi_Host *shpnt)
2153 {
2154         if(TESTLO(SSTAT0,SPIORDY)) {
2155                 DPRINTK(debug_status, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
2156                 return;
2157         }
2158
2159         CURRENT_SC->SCp.Status = GETPORT(SCSIDAT);
2160
2161 #if defined(AHA152X_DEBUG)
2162         if (HOSTDATA(shpnt)->debug & debug_status) {
2163                 printk(DEBUG_LEAD "inbound status %02x ", CMDINFO(CURRENT_SC), CURRENT_SC->SCp.Status);
2164                 scsi_print_status(CURRENT_SC->SCp.Status);
2165                 printk("\n");
2166         }
2167 #endif
2168 }
2169
2170 /*
2171  * data in phase
2172  *
2173  */
2174 static void datai_init(struct Scsi_Host *shpnt)
2175 {
2176         SETPORT(DMACNTRL0, RSTFIFO);
2177         SETPORT(DMACNTRL0, RSTFIFO|ENDMA);
2178
2179         SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2180         SETPORT(SXFRCTL0, CH1|SCSIEN|DMAEN);
2181
2182         SETPORT(SIMODE0, 0);
2183         SETPORT(SIMODE1, ENSCSIPERR | ENSCSIRST | ENPHASEMIS | ENBUSFREE);
2184
2185         DATA_LEN=0;
2186         DPRINTK(debug_datai,
2187                 DEBUG_LEAD "datai_init: request_bufflen=%d resid=%d\n",
2188                 CMDINFO(CURRENT_SC), CURRENT_SC->request_bufflen, CURRENT_SC->resid);
2189 }
2190
2191 static void datai_run(struct Scsi_Host *shpnt)
2192 {
2193         unsigned long the_time;
2194         int fifodata, data_count;
2195
2196         /*
2197          * loop while the phase persists or the fifos are not empty
2198          *
2199          */
2200         while(TESTLO(DMASTAT, INTSTAT) || TESTLO(DMASTAT, DFIFOEMP) || TESTLO(SSTAT2, SEMPTY)) {
2201                 /* FIXME: maybe this should be done by setting up
2202                  * STCNT to trigger ENSWRAP interrupt, instead of
2203                  * polling for DFIFOFULL
2204                  */
2205                 the_time=jiffies + 100*HZ;
2206                 while(TESTLO(DMASTAT, DFIFOFULL|INTSTAT) && time_before(jiffies,the_time))
2207                         barrier();
2208
2209                 if(TESTLO(DMASTAT, DFIFOFULL|INTSTAT)) {
2210                         printk(ERR_LEAD "datai timeout", CMDINFO(CURRENT_SC));
2211                         disp_ports(shpnt);
2212                         break;
2213                 }
2214
2215                 if(TESTHI(DMASTAT, DFIFOFULL)) {
2216                         fifodata = 128;
2217                 } else {
2218                         the_time=jiffies + 100*HZ;
2219                         while(TESTLO(SSTAT2, SEMPTY) && time_before(jiffies,the_time))
2220                                 barrier();
2221
2222                         if(TESTLO(SSTAT2, SEMPTY)) {
2223                                 printk(ERR_LEAD "datai sempty timeout", CMDINFO(CURRENT_SC));
2224                                 disp_ports(shpnt);
2225                                 break;
2226                         }
2227
2228                         fifodata = GETPORT(FIFOSTAT);
2229                 }
2230
2231                 if(CURRENT_SC->SCp.this_residual>0) {
2232                         while(fifodata>0 && CURRENT_SC->SCp.this_residual>0) {
2233                                 data_count = fifodata>CURRENT_SC->SCp.this_residual ?
2234                                                 CURRENT_SC->SCp.this_residual :
2235                                                 fifodata;
2236                                 fifodata -= data_count;
2237
2238                                 if(data_count & 1) {
2239                                         DPRINTK(debug_datai, DEBUG_LEAD "8bit\n", CMDINFO(CURRENT_SC));
2240                                         SETPORT(DMACNTRL0, ENDMA|_8BIT);
2241                                         *CURRENT_SC->SCp.ptr++ = GETPORT(DATAPORT);
2242                                         CURRENT_SC->SCp.this_residual--;
2243                                         DATA_LEN++;
2244                                         SETPORT(DMACNTRL0, ENDMA);
2245                                 }
2246
2247                                 if(data_count > 1) {
2248                                         DPRINTK(debug_datai, DEBUG_LEAD "16bit(%d)\n", CMDINFO(CURRENT_SC), data_count);
2249                                         data_count >>= 1;
2250                                         insw(DATAPORT, CURRENT_SC->SCp.ptr, data_count);
2251                                         CURRENT_SC->SCp.ptr           += 2 * data_count;
2252                                         CURRENT_SC->SCp.this_residual -= 2 * data_count;
2253                                         DATA_LEN                      += 2 * data_count;
2254                                 }
2255
2256                                 if(CURRENT_SC->SCp.this_residual==0 && CURRENT_SC->SCp.buffers_residual>0) {
2257                                         /* advance to next buffer */
2258                                         CURRENT_SC->SCp.buffers_residual--;
2259                                         CURRENT_SC->SCp.buffer++;
2260                                         CURRENT_SC->SCp.ptr           = SG_ADDRESS(CURRENT_SC->SCp.buffer);
2261                                         CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length;
2262                                 }
2263                         }
2264                 } else if(fifodata>0) {
2265                         printk(ERR_LEAD "no buffers left for %d(%d) bytes (data overrun!?)\n", CMDINFO(CURRENT_SC), fifodata, GETPORT(FIFOSTAT));
2266                         SETPORT(DMACNTRL0, ENDMA|_8BIT);
2267                         while(fifodata>0) {
2268                                 int data;
2269                                 data=GETPORT(DATAPORT);
2270                                 DPRINTK(debug_datai, DEBUG_LEAD "data=%02x\n", CMDINFO(CURRENT_SC), data);
2271                                 fifodata--;
2272                                 DATA_LEN++;
2273                         }
2274                         SETPORT(DMACNTRL0, ENDMA|_8BIT);
2275                 }
2276         }
2277
2278         if(TESTLO(DMASTAT, INTSTAT) ||
2279            TESTLO(DMASTAT, DFIFOEMP) ||
2280            TESTLO(SSTAT2, SEMPTY) ||
2281            GETPORT(FIFOSTAT)>0) {
2282                 /*
2283                  * something went wrong, if there's something left in the fifos
2284                  * or the phase didn't change
2285                  */
2286                 printk(ERR_LEAD "fifos should be empty and phase should have changed\n", CMDINFO(CURRENT_SC));
2287                 disp_ports(shpnt);
2288         }
2289
2290         if(DATA_LEN!=GETSTCNT()) {
2291                 printk(ERR_LEAD
2292                        "manual transfer count differs from automatic (count=%d;stcnt=%d;diff=%d;fifostat=%d)",
2293                        CMDINFO(CURRENT_SC), DATA_LEN, GETSTCNT(), GETSTCNT()-DATA_LEN, GETPORT(FIFOSTAT));
2294                 disp_ports(shpnt);
2295                 mdelay(10000);
2296         }
2297 }
2298
2299 static void datai_end(struct Scsi_Host *shpnt)
2300 {
2301         CURRENT_SC->resid -= GETSTCNT();
2302
2303         DPRINTK(debug_datai,
2304                 DEBUG_LEAD "datai_end: request_bufflen=%d resid=%d stcnt=%d\n",
2305                 CMDINFO(CURRENT_SC), CURRENT_SC->request_bufflen, CURRENT_SC->resid, GETSTCNT());
2306
2307         SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2308         SETPORT(DMACNTRL0, 0);
2309 }
2310
2311 /*
2312  * data out phase
2313  *
2314  */
2315 static void datao_init(struct Scsi_Host *shpnt)
2316 {
2317         SETPORT(DMACNTRL0, WRITE_READ | RSTFIFO);
2318         SETPORT(DMACNTRL0, WRITE_READ | ENDMA);
2319
2320         SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2321         SETPORT(SXFRCTL0, CH1|SCSIEN|DMAEN);
2322
2323         SETPORT(SIMODE0, 0);
2324         SETPORT(SIMODE1, ENSCSIPERR | ENSCSIRST | ENPHASEMIS | ENBUSFREE );
2325
2326         DATA_LEN = CURRENT_SC->resid;
2327
2328         DPRINTK(debug_datao,
2329                 DEBUG_LEAD "datao_init: request_bufflen=%d; resid=%d\n",
2330                 CMDINFO(CURRENT_SC), CURRENT_SC->request_bufflen, CURRENT_SC->resid);
2331 }
2332
2333 static void datao_run(struct Scsi_Host *shpnt)
2334 {
2335         unsigned long the_time;
2336         int data_count;
2337
2338         /* until phase changes or all data sent */
2339         while(TESTLO(DMASTAT, INTSTAT) && CURRENT_SC->SCp.this_residual>0) {
2340                 data_count = 128;
2341                 if(data_count > CURRENT_SC->SCp.this_residual)
2342                         data_count=CURRENT_SC->SCp.this_residual;
2343
2344                 if(TESTLO(DMASTAT, DFIFOEMP)) {
2345                         printk(ERR_LEAD "datao fifo not empty (%d)", CMDINFO(CURRENT_SC), GETPORT(FIFOSTAT));
2346                         disp_ports(shpnt);
2347                         break;
2348                 }
2349
2350                 if(data_count & 1) {
2351                         SETPORT(DMACNTRL0,WRITE_READ|ENDMA|_8BIT);
2352                         SETPORT(DATAPORT, *CURRENT_SC->SCp.ptr++);
2353                         CURRENT_SC->SCp.this_residual--;
2354                         CURRENT_SC->resid--;
2355                         SETPORT(DMACNTRL0,WRITE_READ|ENDMA);
2356                 }
2357
2358                 if(data_count > 1) {
2359                         data_count >>= 1;
2360                         outsw(DATAPORT, CURRENT_SC->SCp.ptr, data_count);
2361                         CURRENT_SC->SCp.ptr           += 2 * data_count;
2362                         CURRENT_SC->SCp.this_residual -= 2 * data_count;
2363                         CURRENT_SC->resid             -= 2 * data_count;
2364                 }
2365
2366                 if(CURRENT_SC->SCp.this_residual==0 && CURRENT_SC->SCp.buffers_residual>0) {
2367                         /* advance to next buffer */
2368                         CURRENT_SC->SCp.buffers_residual--;
2369                         CURRENT_SC->SCp.buffer++;
2370                         CURRENT_SC->SCp.ptr           = SG_ADDRESS(CURRENT_SC->SCp.buffer);
2371                         CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length;
2372                 }
2373
2374                 the_time=jiffies + 100*HZ;
2375                 while(TESTLO(DMASTAT, DFIFOEMP|INTSTAT) && time_before(jiffies,the_time))
2376                         barrier();
2377
2378                 if(TESTLO(DMASTAT, DFIFOEMP|INTSTAT)) {
2379                         printk(ERR_LEAD "dataout timeout", CMDINFO(CURRENT_SC));
2380                         disp_ports(shpnt);
2381                         break;
2382                 }
2383         }
2384 }
2385
2386 static void datao_end(struct Scsi_Host *shpnt)
2387 {
2388         if(TESTLO(DMASTAT, DFIFOEMP)) {
2389                 int data_count = (DATA_LEN - CURRENT_SC->resid) - GETSTCNT();
2390
2391                 DPRINTK(debug_datao, DEBUG_LEAD "datao: %d bytes to resend (%d written, %d transferred)\n",
2392                         CMDINFO(CURRENT_SC),
2393                         data_count,
2394                         DATA_LEN-CURRENT_SC->resid,
2395                         GETSTCNT());
2396
2397                 CURRENT_SC->resid += data_count;
2398
2399                 if(CURRENT_SC->use_sg) {
2400                         data_count -= CURRENT_SC->SCp.ptr - SG_ADDRESS(CURRENT_SC->SCp.buffer);
2401                         while(data_count>0) {
2402                                 CURRENT_SC->SCp.buffer--;
2403                                 CURRENT_SC->SCp.buffers_residual++;
2404                                 data_count -= CURRENT_SC->SCp.buffer->length;
2405                         }
2406                         CURRENT_SC->SCp.ptr           = SG_ADDRESS(CURRENT_SC->SCp.buffer) - data_count;
2407                         CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length + data_count;
2408                 } else {
2409                         CURRENT_SC->SCp.ptr           -= data_count;
2410                         CURRENT_SC->SCp.this_residual += data_count;
2411                 }
2412         }
2413
2414         DPRINTK(debug_datao, DEBUG_LEAD "datao_end: request_bufflen=%d; resid=%d; stcnt=%d\n",
2415                 CMDINFO(CURRENT_SC),
2416                 CURRENT_SC->request_bufflen,
2417                 CURRENT_SC->resid,
2418                 GETSTCNT());
2419
2420         SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
2421         SETPORT(SXFRCTL0, CH1);
2422
2423         SETPORT(DMACNTRL0, 0);
2424 }
2425
2426 /*
2427  * figure out what state we're in
2428  *
2429  */
2430 static int update_state(struct Scsi_Host *shpnt)
2431 {
2432         int dataphase=0;
2433         unsigned int stat0 = GETPORT(SSTAT0);
2434         unsigned int stat1 = GETPORT(SSTAT1);
2435
2436         PREVSTATE = STATE;
2437         STATE=unknown;
2438
2439         if(stat1 & SCSIRSTI) {
2440                 STATE=rsti;
2441                 SETPORT(SCSISEQ,0);
2442                 SETPORT(SSTAT1,SCSIRSTI);
2443         } else if(stat0 & SELDI && PREVSTATE==busfree) {
2444                 STATE=seldi;
2445         } else if(stat0 & SELDO && CURRENT_SC && (CURRENT_SC->SCp.phase & selecting)) {
2446                 STATE=seldo;
2447         } else if(stat1 & SELTO) {
2448                 STATE=selto;
2449         } else if(stat1 & BUSFREE) {
2450                 STATE=busfree;
2451                 SETPORT(SSTAT1,BUSFREE);
2452         } else if(stat1 & SCSIPERR) {
2453                 STATE=parerr;
2454                 SETPORT(SSTAT1,SCSIPERR);
2455         } else if(stat1 & REQINIT) {
2456                 switch(GETPORT(SCSISIG) & P_MASK) {
2457                 case P_MSGI:    STATE=msgi;     break;
2458                 case P_MSGO:    STATE=msgo;     break;
2459                 case P_DATAO:   STATE=datao;    break;
2460                 case P_DATAI:   STATE=datai;    break;
2461                 case P_STATUS:  STATE=status;   break;
2462                 case P_CMD:     STATE=cmd;      break;
2463                 }
2464                 dataphase=1;
2465         }
2466
2467         if((stat0 & SELDI) && STATE!=seldi && !dataphase) {
2468                 printk(INFO_LEAD "reselection missed?", CMDINFO(CURRENT_SC));
2469                 disp_ports(shpnt);
2470         }
2471
2472         if(STATE!=PREVSTATE) {
2473                 LASTSTATE=PREVSTATE;
2474         }
2475
2476         return dataphase;
2477 }
2478
2479 /*
2480  * handle parity error
2481  *
2482  * FIXME: in which phase?
2483  *
2484  */
2485 static void parerr_run(struct Scsi_Host *shpnt)
2486 {
2487         printk(ERR_LEAD "parity error\n", CMDINFO(CURRENT_SC));
2488         done(shpnt, DID_PARITY << 16);
2489 }
2490
2491 /*
2492  * handle reset in
2493  *
2494  */
2495 static void rsti_run(struct Scsi_Host *shpnt)
2496 {
2497         Scsi_Cmnd *ptr;
2498
2499         printk(KERN_NOTICE "aha152x%d: scsi reset in\n", HOSTNO);
2500
2501         ptr=DISCONNECTED_SC;
2502         while(ptr) {
2503                 Scsi_Cmnd *next = SCNEXT(ptr);
2504
2505                 if (!ptr->device->soft_reset) {
2506                         remove_SC(&DISCONNECTED_SC, ptr);
2507
2508                         kfree(ptr->host_scribble);
2509                         ptr->host_scribble=NULL;
2510
2511                         ptr->result =  DID_RESET << 16;
2512                         ptr->scsi_done(ptr);
2513                 }
2514
2515                 ptr = next;
2516         }
2517
2518         if(CURRENT_SC && !CURRENT_SC->device->soft_reset)
2519                 done(shpnt, DID_RESET << 16 );
2520 }
2521
2522
2523 /*
2524  * bottom-half handler
2525  *
2526  */
2527 static void is_complete(struct Scsi_Host *shpnt)
2528 {
2529         int dataphase;
2530         unsigned long flags;
2531         int pending;
2532
2533         if(!shpnt)
2534                 return;
2535
2536         DO_LOCK(flags);
2537
2538         if( HOSTDATA(shpnt)->service==0 )  {
2539                 DO_UNLOCK(flags);
2540                 return;
2541         }
2542
2543         HOSTDATA(shpnt)->service = 0;
2544
2545         if(HOSTDATA(shpnt)->in_intr) {
2546                 DO_UNLOCK(flags);
2547                 /* aha152x_error never returns.. */
2548                 aha152x_error(shpnt, "bottom-half already running!?");
2549         }
2550         HOSTDATA(shpnt)->in_intr++;
2551
2552         /*
2553          * loop while there are interrupt conditions pending
2554          *
2555          */
2556         do {
2557                 unsigned long start = jiffies;
2558                 DO_UNLOCK(flags);
2559
2560                 dataphase=update_state(shpnt);
2561
2562                 DPRINTK(debug_phases, LEAD "start %s %s(%s)\n", CMDINFO(CURRENT_SC), states[STATE].name, states[PREVSTATE].name, states[LASTSTATE].name);
2563
2564                 /*
2565                  * end previous state
2566                  *
2567                  */
2568                 if(PREVSTATE!=STATE && states[PREVSTATE].end)
2569                         states[PREVSTATE].end(shpnt);
2570
2571                 /*
2572                  * disable SPIO mode if previous phase used it
2573                  * and this one doesn't
2574                  *
2575                  */
2576                 if(states[PREVSTATE].spio && !states[STATE].spio) {
2577                         SETPORT(SXFRCTL0, CH1);
2578                         SETPORT(DMACNTRL0, 0);
2579                         if(CURRENT_SC)
2580                                 CURRENT_SC->SCp.phase &= ~spiordy;
2581                 }
2582
2583                 /*
2584                  * accept current dataphase phase
2585                  *
2586                  */
2587                 if(dataphase) {
2588                         SETPORT(SSTAT0, REQINIT);
2589                         SETPORT(SCSISIG, GETPORT(SCSISIG) & P_MASK);
2590                         SETPORT(SSTAT1, PHASECHG);
2591                 }
2592
2593                 /*
2594                  * enable SPIO mode if previous didn't use it
2595                  * and this one does
2596                  *
2597                  */
2598                 if(!states[PREVSTATE].spio && states[STATE].spio) {
2599                         SETPORT(DMACNTRL0, 0);
2600                         SETPORT(SXFRCTL0, CH1|SPIOEN);
2601                         if(CURRENT_SC)
2602                                 CURRENT_SC->SCp.phase |= spiordy;
2603                 }
2604
2605                 /*
2606                  * initialize for new state
2607                  *
2608                  */
2609                 if(PREVSTATE!=STATE && states[STATE].init)
2610                         states[STATE].init(shpnt);
2611
2612                 /*
2613                  * handle current state
2614                  *
2615                  */
2616                 if(states[STATE].run)
2617                         states[STATE].run(shpnt);
2618                 else
2619                         printk(ERR_LEAD "unexpected state (%x)\n", CMDINFO(CURRENT_SC), STATE);
2620
2621                 /*
2622                  * setup controller to interrupt on
2623                  * the next expected condition and
2624                  * loop if it's already there
2625                  *
2626                  */
2627                 DO_LOCK(flags);
2628                 pending=setup_expected_interrupts(shpnt);
2629 #if defined(AHA152X_STAT)
2630                 HOSTDATA(shpnt)->count[STATE]++;
2631                 if(PREVSTATE!=STATE)
2632                         HOSTDATA(shpnt)->count_trans[STATE]++;
2633                 HOSTDATA(shpnt)->time[STATE] += jiffies-start;
2634 #endif
2635
2636                 DPRINTK(debug_phases, LEAD "end %s %s(%s)\n", CMDINFO(CURRENT_SC), states[STATE].name, states[PREVSTATE].name, states[LASTSTATE].name);
2637         } while(pending);
2638
2639         /*
2640          * enable interrupts and leave bottom-half
2641          *
2642          */
2643         HOSTDATA(shpnt)->in_intr--;
2644         SETBITS(DMACNTRL0, INTEN);
2645         DO_UNLOCK(flags);
2646 }
2647
2648
2649 /*
2650  * Dump the current driver status and panic
2651  */
2652 static void aha152x_error(struct Scsi_Host *shpnt, char *msg)
2653 {
2654         printk(KERN_EMERG "\naha152x%d: %s\n", HOSTNO, msg);
2655         show_queues(shpnt);
2656         panic("aha152x panic\n");
2657 }
2658
2659 /*
2660  * Display registers of AIC-6260
2661  */
2662 static void disp_ports(struct Scsi_Host *shpnt)
2663 {
2664 #if defined(AHA152X_DEBUG)
2665         int s;
2666
2667         printk("\n%s: %s(%s) ",
2668                 CURRENT_SC ? "busy" : "waiting",
2669                 states[STATE].name,
2670                 states[PREVSTATE].name);
2671
2672         s = GETPORT(SCSISEQ);
2673         printk("SCSISEQ( ");
2674         if (s & TEMODEO)
2675                 printk("TARGET MODE ");
2676         if (s & ENSELO)
2677                 printk("SELO ");
2678         if (s & ENSELI)
2679                 printk("SELI ");
2680         if (s & ENRESELI)
2681                 printk("RESELI ");
2682         if (s & ENAUTOATNO)
2683                 printk("AUTOATNO ");
2684         if (s & ENAUTOATNI)
2685                 printk("AUTOATNI ");
2686         if (s & ENAUTOATNP)
2687                 printk("AUTOATNP ");
2688         if (s & SCSIRSTO)
2689                 printk("SCSIRSTO ");
2690         printk(");");
2691
2692         printk(" SCSISIG(");
2693         s = GETPORT(SCSISIG);
2694         switch (s & P_MASK) {
2695         case P_DATAO:
2696                 printk("DATA OUT");
2697                 break;
2698         case P_DATAI:
2699                 printk("DATA IN");
2700                 break;
2701         case P_CMD:
2702                 printk("COMMAND");
2703                 break;
2704         case P_STATUS:
2705                 printk("STATUS");
2706                 break;
2707         case P_MSGO:
2708                 printk("MESSAGE OUT");
2709                 break;
2710         case P_MSGI:
2711                 printk("MESSAGE IN");
2712                 break;
2713         default:
2714                 printk("*invalid*");
2715                 break;
2716         }
2717
2718         printk("); ");
2719
2720         printk("INTSTAT (%s); ", TESTHI(DMASTAT, INTSTAT) ? "hi" : "lo");
2721
2722         printk("SSTAT( ");
2723         s = GETPORT(SSTAT0);
2724         if (s & TARGET)
2725                 printk("TARGET ");
2726         if (s & SELDO)
2727                 printk("SELDO ");
2728         if (s & SELDI)
2729                 printk("SELDI ");
2730         if (s & SELINGO)
2731                 printk("SELINGO ");
2732         if (s & SWRAP)
2733                 printk("SWRAP ");
2734         if (s & SDONE)
2735                 printk("SDONE ");
2736         if (s & SPIORDY)
2737                 printk("SPIORDY ");
2738         if (s & DMADONE)
2739                 printk("DMADONE ");
2740
2741         s = GETPORT(SSTAT1);
2742         if (s & SELTO)
2743                 printk("SELTO ");
2744         if (s & ATNTARG)
2745                 printk("ATNTARG ");
2746         if (s & SCSIRSTI)
2747                 printk("SCSIRSTI ");
2748         if (s & PHASEMIS)
2749                 printk("PHASEMIS ");
2750         if (s & BUSFREE)
2751                 printk("BUSFREE ");
2752         if (s & SCSIPERR)
2753                 printk("SCSIPERR ");
2754         if (s & PHASECHG)
2755                 printk("PHASECHG ");
2756         if (s & REQINIT)
2757                 printk("REQINIT ");
2758         printk("); ");
2759
2760
2761         printk("SSTAT( ");
2762
2763         s = GETPORT(SSTAT0) & GETPORT(SIMODE0);
2764
2765         if (s & TARGET)
2766                 printk("TARGET ");
2767         if (s & SELDO)
2768                 printk("SELDO ");
2769         if (s & SELDI)
2770                 printk("SELDI ");
2771         if (s & SELINGO)
2772                 printk("SELINGO ");
2773         if (s & SWRAP)
2774                 printk("SWRAP ");
2775         if (s & SDONE)
2776                 printk("SDONE ");
2777         if (s & SPIORDY)
2778                 printk("SPIORDY ");
2779         if (s & DMADONE)
2780                 printk("DMADONE ");
2781
2782         s = GETPORT(SSTAT1) & GETPORT(SIMODE1);
2783
2784         if (s & SELTO)
2785                 printk("SELTO ");
2786         if (s & ATNTARG)
2787                 printk("ATNTARG ");
2788         if (s & SCSIRSTI)
2789                 printk("SCSIRSTI ");
2790         if (s & PHASEMIS)
2791                 printk("PHASEMIS ");
2792         if (s & BUSFREE)
2793                 printk("BUSFREE ");
2794         if (s & SCSIPERR)
2795                 printk("SCSIPERR ");
2796         if (s & PHASECHG)
2797                 printk("PHASECHG ");
2798         if (s & REQINIT)
2799                 printk("REQINIT ");
2800         printk("); ");
2801
2802         printk("SXFRCTL0( ");
2803
2804         s = GETPORT(SXFRCTL0);
2805         if (s & SCSIEN)
2806                 printk("SCSIEN ");
2807         if (s & DMAEN)
2808                 printk("DMAEN ");
2809         if (s & CH1)
2810                 printk("CH1 ");
2811         if (s & CLRSTCNT)
2812                 printk("CLRSTCNT ");
2813         if (s & SPIOEN)
2814                 printk("SPIOEN ");
2815         if (s & CLRCH1)
2816                 printk("CLRCH1 ");
2817         printk("); ");
2818
2819         printk("SIGNAL( ");
2820
2821         s = GETPORT(SCSISIG);
2822         if (s & SIG_ATNI)
2823                 printk("ATNI ");
2824         if (s & SIG_SELI)
2825                 printk("SELI ");
2826         if (s & SIG_BSYI)
2827                 printk("BSYI ");
2828         if (s & SIG_REQI)
2829                 printk("REQI ");
2830         if (s & SIG_ACKI)
2831                 printk("ACKI ");
2832         printk("); ");
2833
2834         printk("SELID (%02x), ", GETPORT(SELID));
2835
2836         printk("STCNT (%d), ", GETSTCNT());
2837
2838         printk("SSTAT2( ");
2839
2840         s = GETPORT(SSTAT2);
2841         if (s & SOFFSET)
2842                 printk("SOFFSET ");
2843         if (s & SEMPTY)
2844                 printk("SEMPTY ");
2845         if (s & SFULL)
2846                 printk("SFULL ");
2847         printk("); SFCNT (%d); ", s & (SFULL | SFCNT));
2848
2849         s = GETPORT(SSTAT3);
2850         printk("SCSICNT (%d), OFFCNT(%d), ", (s & 0xf0) >> 4, s & 0x0f);
2851
2852         printk("SSTAT4( ");
2853         s = GETPORT(SSTAT4);
2854         if (s & SYNCERR)
2855                 printk("SYNCERR ");
2856         if (s & FWERR)
2857                 printk("FWERR ");
2858         if (s & FRERR)
2859                 printk("FRERR ");
2860         printk("); ");
2861
2862         printk("DMACNTRL0( ");
2863         s = GETPORT(DMACNTRL0);
2864         printk("%s ", s & _8BIT ? "8BIT" : "16BIT");
2865         printk("%s ", s & DMA ? "DMA" : "PIO");
2866         printk("%s ", s & WRITE_READ ? "WRITE" : "READ");
2867         if (s & ENDMA)
2868                 printk("ENDMA ");
2869         if (s & INTEN)
2870                 printk("INTEN ");
2871         if (s & RSTFIFO)
2872                 printk("RSTFIFO ");
2873         if (s & SWINT)
2874                 printk("SWINT ");
2875         printk("); ");
2876
2877         printk("DMASTAT( ");
2878         s = GETPORT(DMASTAT);
2879         if (s & ATDONE)
2880                 printk("ATDONE ");
2881         if (s & WORDRDY)
2882                 printk("WORDRDY ");
2883         if (s & DFIFOFULL)
2884                 printk("DFIFOFULL ");
2885         if (s & DFIFOEMP)
2886                 printk("DFIFOEMP ");
2887         printk(")\n");
2888 #endif
2889 }
2890
2891 /*
2892  * display enabled interrupts
2893  */
2894 static void disp_enintr(struct Scsi_Host *shpnt)
2895 {
2896         int s;
2897
2898         printk(KERN_DEBUG "enabled interrupts ( ");
2899
2900         s = GETPORT(SIMODE0);
2901         if (s & ENSELDO)
2902                 printk("ENSELDO ");
2903         if (s & ENSELDI)
2904                 printk("ENSELDI ");
2905         if (s & ENSELINGO)
2906                 printk("ENSELINGO ");
2907         if (s & ENSWRAP)
2908                 printk("ENSWRAP ");
2909         if (s & ENSDONE)
2910                 printk("ENSDONE ");
2911         if (s & ENSPIORDY)
2912                 printk("ENSPIORDY ");
2913         if (s & ENDMADONE)
2914                 printk("ENDMADONE ");
2915
2916         s = GETPORT(SIMODE1);
2917         if (s & ENSELTIMO)
2918                 printk("ENSELTIMO ");
2919         if (s & ENATNTARG)
2920                 printk("ENATNTARG ");
2921         if (s & ENPHASEMIS)
2922                 printk("ENPHASEMIS ");
2923         if (s & ENBUSFREE)
2924                 printk("ENBUSFREE ");
2925         if (s & ENSCSIPERR)
2926                 printk("ENSCSIPERR ");
2927         if (s & ENPHASECHG)
2928                 printk("ENPHASECHG ");
2929         if (s & ENREQINIT)
2930                 printk("ENREQINIT ");
2931         printk(")\n");
2932 }
2933
2934 /*
2935  * Show the command data of a command
2936  */
2937 static void show_command(Scsi_Cmnd *ptr)
2938 {
2939         scmd_printk(KERN_DEBUG, ptr, "%p: cmnd=(", ptr);
2940
2941         __scsi_print_command(ptr->cmnd);
2942
2943         printk(KERN_DEBUG "); request_bufflen=%d; resid=%d; phase |",
2944                ptr->request_bufflen, ptr->resid);
2945
2946         if (ptr->SCp.phase & not_issued)
2947                 printk("not issued|");
2948         if (ptr->SCp.phase & selecting)
2949                 printk("selecting|");
2950         if (ptr->SCp.phase & identified)
2951                 printk("identified|");
2952         if (ptr->SCp.phase & disconnected)
2953                 printk("disconnected|");
2954         if (ptr->SCp.phase & completed)
2955                 printk("completed|");
2956         if (ptr->SCp.phase & spiordy)
2957                 printk("spiordy|");
2958         if (ptr->SCp.phase & syncneg)
2959                 printk("syncneg|");
2960         if (ptr->SCp.phase & aborted)
2961                 printk("aborted|");
2962         if (ptr->SCp.phase & resetted)
2963                 printk("resetted|");
2964         if( SCDATA(ptr) ) {
2965                 printk("; next=0x%p\n", SCNEXT(ptr));
2966         } else {
2967                 printk("; next=(host scribble NULL)\n");
2968         }
2969 }
2970
2971 /*
2972  * Dump the queued data
2973  */
2974 static void show_queues(struct Scsi_Host *shpnt)
2975 {
2976         Scsi_Cmnd *ptr;
2977         unsigned long flags;
2978
2979         DO_LOCK(flags);
2980         printk(KERN_DEBUG "\nqueue status:\nissue_SC:\n");
2981         for (ptr = ISSUE_SC; ptr; ptr = SCNEXT(ptr))
2982                 show_command(ptr);
2983         DO_UNLOCK(flags);
2984
2985         printk(KERN_DEBUG "current_SC:\n");
2986         if (CURRENT_SC)
2987                 show_command(CURRENT_SC);
2988         else
2989                 printk(KERN_DEBUG "none\n");
2990
2991         printk(KERN_DEBUG "disconnected_SC:\n");
2992         for (ptr = DISCONNECTED_SC; ptr; ptr = SCDATA(ptr) ? SCNEXT(ptr) : NULL)
2993                 show_command(ptr);
2994
2995         disp_ports(shpnt);
2996         disp_enintr(shpnt);
2997 }
2998
2999 #undef SPRINTF
3000 #define SPRINTF(args...) pos += sprintf(pos, ## args)
3001
3002 static int get_command(char *pos, Scsi_Cmnd * ptr)
3003 {
3004         char *start = pos;
3005         int i;
3006
3007         SPRINTF("0x%08x: target=%d; lun=%d; cmnd=( ",
3008                 (unsigned int) ptr, ptr->device->id, ptr->device->lun);
3009
3010         for (i = 0; i < COMMAND_SIZE(ptr->cmnd[0]); i++)
3011                 SPRINTF("0x%02x ", ptr->cmnd[i]);
3012
3013         SPRINTF("); resid=%d; residual=%d; buffers=%d; phase |",
3014                 ptr->resid, ptr->SCp.this_residual, ptr->SCp.buffers_residual);
3015
3016         if (ptr->SCp.phase & not_issued)
3017                 SPRINTF("not issued|");
3018         if (ptr->SCp.phase & selecting)
3019                 SPRINTF("selecting|");
3020         if (ptr->SCp.phase & disconnected)
3021                 SPRINTF("disconnected|");
3022         if (ptr->SCp.phase & aborted)
3023                 SPRINTF("aborted|");
3024         if (ptr->SCp.phase & identified)
3025                 SPRINTF("identified|");
3026         if (ptr->SCp.phase & completed)
3027                 SPRINTF("completed|");
3028         if (ptr->SCp.phase & spiordy)
3029                 SPRINTF("spiordy|");
3030         if (ptr->SCp.phase & syncneg)
3031                 SPRINTF("syncneg|");
3032         SPRINTF("; next=0x%p\n", SCNEXT(ptr));
3033
3034         return (pos - start);
3035 }
3036
3037 static int get_ports(struct Scsi_Host *shpnt, char *pos)
3038 {
3039         char *start = pos;
3040         int s;
3041
3042         SPRINTF("\n%s: %s(%s) ", CURRENT_SC ? "on bus" : "waiting", states[STATE].name, states[PREVSTATE].name);
3043
3044         s = GETPORT(SCSISEQ);
3045         SPRINTF("SCSISEQ( ");
3046         if (s & TEMODEO)
3047                 SPRINTF("TARGET MODE ");
3048         if (s & ENSELO)
3049                 SPRINTF("SELO ");
3050         if (s & ENSELI)
3051                 SPRINTF("SELI ");
3052         if (s & ENRESELI)
3053                 SPRINTF("RESELI ");
3054         if (s & ENAUTOATNO)
3055                 SPRINTF("AUTOATNO ");
3056         if (s & ENAUTOATNI)
3057                 SPRINTF("AUTOATNI ");
3058         if (s & ENAUTOATNP)
3059                 SPRINTF("AUTOATNP ");
3060         if (s & SCSIRSTO)
3061                 SPRINTF("SCSIRSTO ");
3062         SPRINTF(");");
3063
3064         SPRINTF(" SCSISIG(");
3065         s = GETPORT(SCSISIG);
3066         switch (s & P_MASK) {
3067         case P_DATAO:
3068                 SPRINTF("DATA OUT");
3069                 break;
3070         case P_DATAI:
3071                 SPRINTF("DATA IN");
3072                 break;
3073         case P_CMD:
3074                 SPRINTF("COMMAND");
3075                 break;
3076         case P_STATUS:
3077                 SPRINTF("STATUS");
3078                 break;
3079         case P_MSGO:
3080                 SPRINTF("MESSAGE OUT");
3081                 break;
3082         case P_MSGI:
3083                 SPRINTF("MESSAGE IN");
3084                 break;
3085         default:
3086                 SPRINTF("*invalid*");
3087                 break;
3088         }
3089
3090         SPRINTF("); ");
3091
3092         SPRINTF("INTSTAT (%s); ", TESTHI(DMASTAT, INTSTAT) ? "hi" : "lo");
3093
3094         SPRINTF("SSTAT( ");
3095         s = GETPORT(SSTAT0);
3096         if (s & TARGET)
3097                 SPRINTF("TARGET ");
3098         if (s & SELDO)
3099                 SPRINTF("SELDO ");
3100         if (s & SELDI)
3101                 SPRINTF("SELDI ");
3102         if (s & SELINGO)
3103                 SPRINTF("SELINGO ");
3104         if (s & SWRAP)
3105                 SPRINTF("SWRAP ");
3106         if (s & SDONE)
3107                 SPRINTF("SDONE ");
3108         if (s & SPIORDY)
3109                 SPRINTF("SPIORDY ");
3110         if (s & DMADONE)
3111                 SPRINTF("DMADONE ");
3112
3113         s = GETPORT(SSTAT1);
3114         if (s & SELTO)
3115                 SPRINTF("SELTO ");
3116         if (s & ATNTARG)
3117                 SPRINTF("ATNTARG ");
3118         if (s & SCSIRSTI)
3119                 SPRINTF("SCSIRSTI ");
3120         if (s & PHASEMIS)
3121                 SPRINTF("PHASEMIS ");
3122         if (s & BUSFREE)
3123                 SPRINTF("BUSFREE ");
3124         if (s & SCSIPERR)
3125                 SPRINTF("SCSIPERR ");
3126         if (s & PHASECHG)
3127                 SPRINTF("PHASECHG ");
3128         if (s & REQINIT)
3129                 SPRINTF("REQINIT ");
3130         SPRINTF("); ");
3131
3132
3133         SPRINTF("SSTAT( ");
3134
3135         s = GETPORT(SSTAT0) & GETPORT(SIMODE0);
3136
3137         if (s & TARGET)
3138                 SPRINTF("TARGET ");
3139         if (s & SELDO)
3140                 SPRINTF("SELDO ");
3141         if (s & SELDI)
3142                 SPRINTF("SELDI ");
3143         if (s & SELINGO)
3144                 SPRINTF("SELINGO ");
3145         if (s & SWRAP)
3146                 SPRINTF("SWRAP ");
3147         if (s & SDONE)
3148                 SPRINTF("SDONE ");
3149         if (s & SPIORDY)
3150                 SPRINTF("SPIORDY ");
3151         if (s & DMADONE)
3152                 SPRINTF("DMADONE ");
3153
3154         s = GETPORT(SSTAT1) & GETPORT(SIMODE1);
3155
3156         if (s & SELTO)
3157                 SPRINTF("SELTO ");
3158         if (s & ATNTARG)
3159                 SPRINTF("ATNTARG ");
3160         if (s & SCSIRSTI)
3161                 SPRINTF("SCSIRSTI ");
3162         if (s & PHASEMIS)
3163                 SPRINTF("PHASEMIS ");
3164         if (s & BUSFREE)
3165                 SPRINTF("BUSFREE ");
3166         if (s & SCSIPERR)
3167                 SPRINTF("SCSIPERR ");
3168         if (s & PHASECHG)
3169                 SPRINTF("PHASECHG ");
3170         if (s & REQINIT)
3171                 SPRINTF("REQINIT ");
3172         SPRINTF("); ");
3173
3174         SPRINTF("SXFRCTL0( ");
3175
3176         s = GETPORT(SXFRCTL0);
3177         if (s & SCSIEN)
3178                 SPRINTF("SCSIEN ");
3179         if (s & DMAEN)
3180                 SPRINTF("DMAEN ");
3181         if (s & CH1)
3182                 SPRINTF("CH1 ");
3183         if (s & CLRSTCNT)
3184                 SPRINTF("CLRSTCNT ");
3185         if (s & SPIOEN)
3186                 SPRINTF("SPIOEN ");
3187         if (s & CLRCH1)
3188                 SPRINTF("CLRCH1 ");
3189         SPRINTF("); ");
3190
3191         SPRINTF("SIGNAL( ");
3192
3193         s = GETPORT(SCSISIG);
3194         if (s & SIG_ATNI)
3195                 SPRINTF("ATNI ");
3196         if (s & SIG_SELI)
3197                 SPRINTF("SELI ");
3198         if (s & SIG_BSYI)
3199                 SPRINTF("BSYI ");
3200         if (s & SIG_REQI)
3201                 SPRINTF("REQI ");
3202         if (s & SIG_ACKI)
3203                 SPRINTF("ACKI ");
3204         SPRINTF("); ");
3205
3206         SPRINTF("SELID(%02x), ", GETPORT(SELID));
3207
3208         SPRINTF("STCNT(%d), ", GETSTCNT());
3209
3210         SPRINTF("SSTAT2( ");
3211
3212         s = GETPORT(SSTAT2);
3213         if (s & SOFFSET)
3214                 SPRINTF("SOFFSET ");
3215         if (s & SEMPTY)
3216                 SPRINTF("SEMPTY ");
3217         if (s & SFULL)
3218                 SPRINTF("SFULL ");
3219         SPRINTF("); SFCNT (%d); ", s & (SFULL | SFCNT));
3220
3221         s = GETPORT(SSTAT3);
3222         SPRINTF("SCSICNT (%d), OFFCNT(%d), ", (s & 0xf0) >> 4, s & 0x0f);
3223
3224         SPRINTF("SSTAT4( ");
3225         s = GETPORT(SSTAT4);
3226         if (s & SYNCERR)
3227                 SPRINTF("SYNCERR ");
3228         if (s & FWERR)
3229                 SPRINTF("FWERR ");
3230         if (s & FRERR)
3231                 SPRINTF("FRERR ");
3232         SPRINTF("); ");
3233
3234         SPRINTF("DMACNTRL0( ");
3235         s = GETPORT(DMACNTRL0);
3236         SPRINTF("%s ", s & _8BIT ? "8BIT" : "16BIT");
3237         SPRINTF("%s ", s & DMA ? "DMA" : "PIO");
3238         SPRINTF("%s ", s & WRITE_READ ? "WRITE" : "READ");
3239         if (s & ENDMA)
3240                 SPRINTF("ENDMA ");
3241         if (s & INTEN)
3242                 SPRINTF("INTEN ");
3243         if (s & RSTFIFO)
3244                 SPRINTF("RSTFIFO ");
3245         if (s & SWINT)
3246                 SPRINTF("SWINT ");
3247         SPRINTF("); ");
3248
3249         SPRINTF("DMASTAT( ");
3250         s = GETPORT(DMASTAT);
3251         if (s & ATDONE)
3252                 SPRINTF("ATDONE ");
3253         if (s & WORDRDY)
3254                 SPRINTF("WORDRDY ");
3255         if (s & DFIFOFULL)
3256                 SPRINTF("DFIFOFULL ");
3257         if (s & DFIFOEMP)
3258                 SPRINTF("DFIFOEMP ");
3259         SPRINTF(")\n");
3260
3261         SPRINTF("enabled interrupts( ");
3262
3263         s = GETPORT(SIMODE0);
3264         if (s & ENSELDO)
3265                 SPRINTF("ENSELDO ");
3266         if (s & ENSELDI)
3267                 SPRINTF("ENSELDI ");
3268         if (s & ENSELINGO)
3269                 SPRINTF("ENSELINGO ");
3270         if (s & ENSWRAP)
3271                 SPRINTF("ENSWRAP ");
3272         if (s & ENSDONE)
3273                 SPRINTF("ENSDONE ");
3274         if (s & ENSPIORDY)
3275                 SPRINTF("ENSPIORDY ");
3276         if (s & ENDMADONE)
3277                 SPRINTF("ENDMADONE ");
3278
3279         s = GETPORT(SIMODE1);
3280         if (s & ENSELTIMO)
3281                 SPRINTF("ENSELTIMO ");
3282         if (s & ENATNTARG)
3283                 SPRINTF("ENATNTARG ");
3284         if (s & ENPHASEMIS)
3285                 SPRINTF("ENPHASEMIS ");
3286         if (s & ENBUSFREE)
3287                 SPRINTF("ENBUSFREE ");
3288         if (s & ENSCSIPERR)
3289                 SPRINTF("ENSCSIPERR ");
3290         if (s & ENPHASECHG)
3291                 SPRINTF("ENPHASECHG ");
3292         if (s & ENREQINIT)
3293                 SPRINTF("ENREQINIT ");
3294         SPRINTF(")\n");
3295
3296         return (pos - start);
3297 }
3298
3299 static int aha152x_set_info(char *buffer, int length, struct Scsi_Host *shpnt)
3300 {
3301         if(!shpnt || !buffer || length<8 || strncmp("aha152x ", buffer, 8)!=0)
3302                 return -EINVAL;
3303
3304 #if defined(AHA152X_DEBUG)
3305         if(length>14 && strncmp("debug ", buffer+8, 6)==0) {
3306                 int debug = HOSTDATA(shpnt)->debug;
3307
3308                 HOSTDATA(shpnt)->debug = simple_strtoul(buffer+14, NULL, 0);
3309
3310                 printk(KERN_INFO "aha152x%d: debugging options set to 0x%04x (were 0x%04x)\n", HOSTNO, HOSTDATA(shpnt)->debug, debug);
3311         } else
3312 #endif
3313 #if defined(AHA152X_STAT)
3314         if(length>13 && strncmp("reset", buffer+8, 5)==0) {
3315                 int i;
3316
3317                 HOSTDATA(shpnt)->total_commands=0;
3318                 HOSTDATA(shpnt)->disconnections=0;
3319                 HOSTDATA(shpnt)->busfree_without_any_action=0;
3320                 HOSTDATA(shpnt)->busfree_without_old_command=0;
3321                 HOSTDATA(shpnt)->busfree_without_new_command=0;
3322                 HOSTDATA(shpnt)->busfree_without_done_command=0;
3323                 HOSTDATA(shpnt)->busfree_with_check_condition=0;
3324                 for (i = idle; i<maxstate; i++) {
3325                         HOSTDATA(shpnt)->count[i]=0;
3326                         HOSTDATA(shpnt)->count_trans[i]=0;
3327                         HOSTDATA(shpnt)->time[i]=0;
3328                 }
3329
3330                 printk(KERN_INFO "aha152x%d: stats reseted.\n", HOSTNO);
3331
3332         } else
3333 #endif
3334         {
3335                 return -EINVAL;
3336         }
3337
3338
3339         return length;
3340 }
3341
3342 #undef SPRINTF
3343 #define SPRINTF(args...) \
3344         do { if(pos < buffer + length) pos += sprintf(pos, ## args); } while(0)
3345
3346 static int aha152x_proc_info(struct Scsi_Host *shpnt, char *buffer, char **start,
3347                       off_t offset, int length, int inout)
3348 {
3349         int i;
3350         char *pos = buffer;
3351         Scsi_Cmnd *ptr;
3352         unsigned long flags;
3353         int thislength;
3354
3355         DPRINTK(debug_procinfo,
3356                KERN_DEBUG "aha152x_proc_info: buffer=%p offset=%ld length=%d hostno=%d inout=%d\n",
3357                buffer, offset, length, shpnt->host_no, inout);
3358
3359
3360         if (inout)
3361                 return aha152x_set_info(buffer, length, shpnt);
3362
3363         SPRINTF(AHA152X_REVID "\n");
3364
3365         SPRINTF("ioports 0x%04lx to 0x%04lx\n",
3366                 shpnt->io_port, shpnt->io_port + shpnt->n_io_port - 1);
3367         SPRINTF("interrupt 0x%02x\n", shpnt->irq);
3368         SPRINTF("disconnection/reconnection %s\n",
3369                 RECONNECT ? "enabled" : "disabled");
3370         SPRINTF("parity checking %s\n",
3371                 PARITY ? "enabled" : "disabled");
3372         SPRINTF("synchronous transfers %s\n",
3373                 SYNCHRONOUS ? "enabled" : "disabled");
3374         SPRINTF("%d commands currently queued\n", HOSTDATA(shpnt)->commands);
3375
3376         if(SYNCHRONOUS) {
3377                 SPRINTF("synchronously operating targets (tick=50 ns):\n");
3378                 for (i = 0; i < 8; i++)
3379                         if (HOSTDATA(shpnt)->syncrate[i] & 0x7f)
3380                                 SPRINTF("target %d: period %dT/%dns; req/ack offset %d\n",
3381                                         i,
3382                                         (((HOSTDATA(shpnt)->syncrate[i] & 0x70) >> 4) + 2),
3383                                         (((HOSTDATA(shpnt)->syncrate[i] & 0x70) >> 4) + 2) * 50,
3384                                     HOSTDATA(shpnt)->syncrate[i] & 0x0f);
3385         }
3386 #if defined(AHA152X_DEBUG)
3387 #define PDEBUG(flags,txt) \
3388         if(HOSTDATA(shpnt)->debug & flags) SPRINTF("(%s) ", txt);
3389
3390         SPRINTF("enabled debugging options: ");
3391
3392         PDEBUG(debug_procinfo, "procinfo");
3393         PDEBUG(debug_queue, "queue");
3394         PDEBUG(debug_intr, "interrupt");
3395         PDEBUG(debug_selection, "selection");
3396         PDEBUG(debug_msgo, "message out");
3397         PDEBUG(debug_msgi, "message in");
3398         PDEBUG(debug_status, "status");
3399         PDEBUG(debug_cmd, "command");
3400         PDEBUG(debug_datai, "data in");
3401         PDEBUG(debug_datao, "data out");
3402         PDEBUG(debug_eh, "eh");
3403         PDEBUG(debug_locks, "locks");
3404         PDEBUG(debug_phases, "phases");
3405
3406         SPRINTF("\n");
3407 #endif
3408
3409         SPRINTF("\nqueue status:\n");
3410         DO_LOCK(flags);
3411         if (ISSUE_SC) {
3412                 SPRINTF("not yet issued commands:\n");
3413                 for (ptr = ISSUE_SC; ptr; ptr = SCNEXT(ptr))
3414                         pos += get_command(pos, ptr);
3415         } else
3416                 SPRINTF("no not yet issued commands\n");
3417         DO_UNLOCK(flags);
3418
3419         if (CURRENT_SC) {
3420                 SPRINTF("current command:\n");
3421                 pos += get_command(pos, CURRENT_SC);
3422         } else
3423                 SPRINTF("no current command\n");
3424
3425         if (DISCONNECTED_SC) {
3426                 SPRINTF("disconnected commands:\n");
3427                 for (ptr = DISCONNECTED_SC; ptr; ptr = SCNEXT(ptr))
3428                         pos += get_command(pos, ptr);
3429         } else
3430                 SPRINTF("no disconnected commands\n");
3431
3432         pos += get_ports(shpnt, pos);
3433
3434 #if defined(AHA152X_STAT)
3435         SPRINTF("statistics:\n"
3436                 "total commands:               %d\n"
3437                 "disconnections:               %d\n"
3438                 "busfree with check condition: %d\n"
3439                 "busfree without old command:  %d\n"
3440                 "busfree without new command:  %d\n"
3441                 "busfree without done command: %d\n"
3442                 "busfree without any action:   %d\n"
3443                 "state      "
3444                 "transitions  "
3445                 "count        "
3446                 "time\n",
3447                 HOSTDATA(shpnt)->total_commands,
3448                 HOSTDATA(shpnt)->disconnections,
3449                 HOSTDATA(shpnt)->busfree_with_check_condition,
3450                 HOSTDATA(shpnt)->busfree_without_old_command,
3451                 HOSTDATA(shpnt)->busfree_without_new_command,
3452                 HOSTDATA(shpnt)->busfree_without_done_command,
3453                 HOSTDATA(shpnt)->busfree_without_any_action);
3454         for(i=0; i<maxstate; i++) {
3455                 SPRINTF("%-10s %-12d %-12d %-12ld\n",
3456                         states[i].name,
3457                         HOSTDATA(shpnt)->count_trans[i],
3458                         HOSTDATA(shpnt)->count[i],
3459                         HOSTDATA(shpnt)->time[i]);
3460         }
3461 #endif
3462
3463         DPRINTK(debug_procinfo, KERN_DEBUG "aha152x_proc_info: pos=%p\n", pos);
3464
3465         thislength = pos - (buffer + offset);
3466         DPRINTK(debug_procinfo, KERN_DEBUG "aha152x_proc_info: length=%d thislength=%d\n", length, thislength);
3467
3468         if(thislength<0) {
3469                 DPRINTK(debug_procinfo, KERN_DEBUG "aha152x_proc_info: output too short\n");
3470                 *start = NULL;
3471                 return 0;
3472         }
3473
3474         thislength = thislength<length ? thislength : length;
3475
3476         DPRINTK(debug_procinfo, KERN_DEBUG "aha152x_proc_info: return %d\n", thislength);
3477
3478         *start = buffer + offset;
3479         return thislength < length ? thislength : length;
3480 }
3481
3482 static struct scsi_host_template aha152x_driver_template = {
3483         .module                         = THIS_MODULE,
3484         .name                           = AHA152X_REVID,
3485         .proc_name                      = "aha152x",
3486         .proc_info                      = aha152x_proc_info,
3487         .queuecommand                   = aha152x_queue,
3488         .eh_abort_handler               = aha152x_abort,
3489         .eh_device_reset_handler        = aha152x_device_reset,
3490         .eh_bus_reset_handler           = aha152x_bus_reset,
3491         .eh_host_reset_handler          = aha152x_host_reset,
3492         .bios_param                     = aha152x_biosparam,
3493         .can_queue                      = 1,
3494         .this_id                        = 7,
3495         .sg_tablesize                   = SG_ALL,
3496         .cmd_per_lun                    = 1,
3497         .use_clustering                 = DISABLE_CLUSTERING,
3498 };
3499
3500 #if !defined(PCMCIA)
3501 static int setup_count;
3502 static struct aha152x_setup setup[2];
3503
3504 /* possible i/o addresses for the AIC-6260; default first */
3505 static unsigned short ports[] = { 0x340, 0x140 };
3506
3507 #if !defined(SKIP_BIOSTEST)
3508 /* possible locations for the Adaptec BIOS; defaults first */
3509 static unsigned int addresses[] =
3510 {
3511         0xdc000,                /* default first */
3512         0xc8000,
3513         0xcc000,
3514         0xd0000,
3515         0xd4000,
3516         0xd8000,
3517         0xe0000,
3518         0xeb800,                /* VTech Platinum SMP */
3519         0xf0000,
3520 };
3521
3522 /* signatures for various AIC-6[23]60 based controllers.
3523    The point in detecting signatures is to avoid useless and maybe
3524    harmful probes on ports. I'm not sure that all listed boards pass
3525    auto-configuration. For those which fail the BIOS signature is
3526    obsolete, because user intervention to supply the configuration is
3527    needed anyway.  May be an information whether or not the BIOS supports
3528    extended translation could be also useful here. */
3529 static struct signature {
3530         unsigned char *signature;
3531         int sig_offset;
3532         int sig_length;
3533 } signatures[] =
3534 {
3535         { "Adaptec AHA-1520 BIOS",      0x102e, 21 },
3536                 /* Adaptec 152x */
3537         { "Adaptec AHA-1520B",          0x000b, 17 },
3538                 /* Adaptec 152x rev B */
3539         { "Adaptec AHA-1520B",          0x0026, 17 },
3540                 /* Iomega Jaz Jet ISA (AIC6370Q) */
3541         { "Adaptec ASW-B626 BIOS",      0x1029, 21 },
3542                 /* on-board controller */
3543         { "Adaptec BIOS: ASW-B626",     0x000f, 22 },
3544                 /* on-board controller */
3545         { "Adaptec ASW-B626 S2",        0x2e6c, 19 },
3546                 /* on-board controller */
3547         { "Adaptec BIOS:AIC-6360",      0x000c, 21 },
3548                 /* on-board controller */
3549         { "ScsiPro SP-360 BIOS",        0x2873, 19 },
3550                 /* ScsiPro-Controller  */
3551         { "GA-400 LOCAL BUS SCSI BIOS", 0x102e, 26 },
3552                 /* Gigabyte Local-Bus-SCSI */
3553         { "Adaptec BIOS:AVA-282X",      0x000c, 21 },
3554                 /* Adaptec 282x */
3555         { "Adaptec IBM Dock II SCSI",   0x2edd, 24 },
3556                 /* IBM Thinkpad Dock II */
3557         { "Adaptec BIOS:AHA-1532P",     0x001c, 22 },
3558                 /* IBM Thinkpad Dock II SCSI */
3559         { "DTC3520A Host Adapter BIOS", 0x318a, 26 },
3560                 /* DTC 3520A ISA SCSI */
3561 };
3562 #endif /* !SKIP_BIOSTEST */
3563
3564 /*
3565  * Test, if port_base is valid.
3566  *
3567  */
3568 static int aha152x_porttest(int io_port)
3569 {
3570         int i;
3571
3572         SETPORT(io_port + O_DMACNTRL1, 0);      /* reset stack pointer */
3573         for (i = 0; i < 16; i++)
3574                 SETPORT(io_port + O_STACK, i);
3575
3576         SETPORT(io_port + O_DMACNTRL1, 0);      /* reset stack pointer */
3577         for (i = 0; i < 16 && GETPORT(io_port + O_STACK) == i; i++)
3578                 ;
3579
3580         return (i == 16);
3581 }
3582
3583 static int tc1550_porttest(int io_port)
3584 {
3585         int i;
3586
3587         SETPORT(io_port + O_TC_DMACNTRL1, 0);   /* reset stack pointer */
3588         for (i = 0; i < 16; i++)
3589                 SETPORT(io_port + O_STACK, i);
3590
3591         SETPORT(io_port + O_TC_DMACNTRL1, 0);   /* reset stack pointer */
3592         for (i = 0; i < 16 && GETPORT(io_port + O_TC_STACK) == i; i++)
3593                 ;
3594
3595         return (i == 16);
3596 }
3597
3598
3599 static int checksetup(struct aha152x_setup *setup)
3600 {
3601         int i;
3602         for (i = 0; i < ARRAY_SIZE(ports) && (setup->io_port != ports[i]); i++)
3603                 ;
3604
3605         if (i == ARRAY_SIZE(ports))
3606                 return 0;
3607
3608         if ( request_region(setup->io_port, IO_RANGE, "aha152x")==0 ) {
3609                 printk(KERN_ERR "aha152x: io port 0x%x busy.\n", setup->io_port);
3610                 return 0;
3611         }
3612
3613         if( aha152x_porttest(setup->io_port) ) {
3614                 setup->tc1550=0;
3615         } else if( tc1550_porttest(setup->io_port) ) {
3616                 setup->tc1550=1;
3617         } else {
3618                 release_region(setup->io_port, IO_RANGE);
3619                 return 0;
3620         }
3621
3622         release_region(setup->io_port, IO_RANGE);
3623
3624         if ((setup->irq < IRQ_MIN) || (setup->irq > IRQ_MAX))
3625                 return 0;
3626
3627         if ((setup->scsiid < 0) || (setup->scsiid > 7))
3628                 return 0;
3629
3630         if ((setup->reconnect < 0) || (setup->reconnect > 1))
3631                 return 0;
3632
3633         if ((setup->parity < 0) || (setup->parity > 1))
3634                 return 0;
3635
3636         if ((setup->synchronous < 0) || (setup->synchronous > 1))
3637                 return 0;
3638
3639         if ((setup->ext_trans < 0) || (setup->ext_trans > 1))
3640                 return 0;
3641
3642
3643         return 1;
3644 }
3645
3646
3647 static int __init aha152x_init(void)
3648 {
3649         int i, j, ok;
3650 #if defined(AUTOCONF)
3651         aha152x_config conf;
3652 #endif
3653 #ifdef __ISAPNP__
3654         struct pnp_dev *dev=NULL, *pnpdev[2] = {NULL, NULL};
3655 #endif
3656
3657         if ( setup_count ) {
3658                 printk(KERN_INFO "aha152x: processing commandline: ");
3659
3660                 for (i = 0; i<setup_count; i++) {
3661                         if (!checksetup(&setup[i])) {
3662                                 printk(KERN_ERR "\naha152x: %s\n", setup[i].conf);
3663                                 printk(KERN_ERR "aha152x: invalid line\n");
3664                         }
3665                 }
3666                 printk("ok\n");
3667         }
3668
3669 #if defined(SETUP0)
3670         if (setup_count < ARRAY_SIZE(setup)) {
3671                 struct aha152x_setup override = SETUP0;
3672
3673                 if (setup_count == 0 || (override.io_port != setup[0].io_port)) {
3674                         if (!checksetup(&override)) {
3675                                 printk(KERN_ERR "\naha152x: invalid override SETUP0={0x%x,%d,%d,%d,%d,%d,%d,%d}\n",
3676                                        override.io_port,
3677                                        override.irq,
3678                                        override.scsiid,
3679                                        override.reconnect,
3680                                        override.parity,
3681                                        override.synchronous,
3682                                        override.delay,
3683                                        override.ext_trans);
3684                         } else
3685                                 setup[setup_count++] = override;
3686                 }
3687         }
3688 #endif
3689
3690 #if defined(SETUP1)
3691         if (setup_count < ARRAY_SIZE(setup)) {
3692                 struct aha152x_setup override = SETUP1;
3693
3694                 if (setup_count == 0 || (override.io_port != setup[0].io_port)) {
3695                         if (!checksetup(&override)) {
3696                                 printk(KERN_ERR "\naha152x: invalid override SETUP1={0x%x,%d,%d,%d,%d,%d,%d,%d}\n",
3697                                        override.io_port,
3698                                        override.irq,
3699                                        override.scsiid,
3700                                        override.reconnect,
3701                                        override.parity,
3702                                        override.synchronous,
3703                                        override.delay,
3704                                        override.ext_trans);
3705                         } else
3706                                 setup[setup_count++] = override;
3707                 }
3708         }
3709 #endif
3710
3711 #if defined(MODULE)
3712         if (setup_count<ARRAY_SIZE(setup) && (aha152x[0]!=0 || io[0]!=0 || irq[0]!=0)) {
3713                 if(aha152x[0]!=0) {
3714                         setup[setup_count].conf        = "";
3715                         setup[setup_count].io_port     = aha152x[0];
3716                         setup[setup_count].irq         = aha152x[1];
3717                         setup[setup_count].scsiid      = aha152x[2];
3718                         setup[setup_count].reconnect   = aha152x[3];
3719                         setup[setup_count].parity      = aha152x[4];
3720                         setup[setup_count].synchronous = aha152x[5];
3721                         setup[setup_count].delay       = aha152x[6];
3722                         setup[setup_count].ext_trans   = aha152x[7];
3723 #if defined(AHA152X_DEBUG)
3724                         setup[setup_count].debug       = aha152x[8];
3725 #endif
3726                 } else if(io[0]!=0 || irq[0]!=0) {
3727                         if(io[0]!=0)  setup[setup_count].io_port = io[0];
3728                         if(irq[0]!=0) setup[setup_count].irq     = irq[0];
3729
3730                         setup[setup_count].scsiid      = scsiid[0];
3731                         setup[setup_count].reconnect   = reconnect[0];
3732                         setup[setup_count].parity      = parity[0];
3733                         setup[setup_count].synchronous = sync[0];
3734                         setup[setup_count].delay       = delay[0];
3735                         setup[setup_count].ext_trans   = exttrans[0];
3736 #if defined(AHA152X_DEBUG)
3737                         setup[setup_count].debug       = debug[0];
3738 #endif
3739                 }
3740
3741                 if (checksetup(&setup[setup_count]))
3742                         setup_count++;
3743                 else
3744                         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",
3745                                setup[setup_count].io_port,
3746                                setup[setup_count].irq,
3747                                setup[setup_count].scsiid,
3748                                setup[setup_count].reconnect,
3749                                setup[setup_count].parity,
3750                                setup[setup_count].synchronous,
3751                                setup[setup_count].delay,
3752                                setup[setup_count].ext_trans);
3753         }
3754
3755         if (setup_count<ARRAY_SIZE(setup) && (aha152x1[0]!=0 || io[1]!=0 || irq[1]!=0)) {
3756                 if(aha152x1[0]!=0) {
3757                         setup[setup_count].conf        = "";
3758                         setup[setup_count].io_port     = aha152x1[0];
3759                         setup[setup_count].irq         = aha152x1[1];
3760                         setup[setup_count].scsiid      = aha152x1[2];
3761                         setup[setup_count].reconnect   = aha152x1[3];
3762                         setup[setup_count].parity      = aha152x1[4];
3763                         setup[setup_count].synchronous = aha152x1[5];
3764                         setup[setup_count].delay       = aha152x1[6];
3765                         setup[setup_count].ext_trans   = aha152x1[7];
3766 #if defined(AHA152X_DEBUG)
3767                         setup[setup_count].debug       = aha152x1[8];
3768 #endif
3769                 } else if(io[1]!=0 || irq[1]!=0) {
3770                         if(io[1]!=0)  setup[setup_count].io_port = io[1];
3771                         if(irq[1]!=0) setup[setup_count].irq     = irq[1];
3772
3773                         setup[setup_count].scsiid      = scsiid[1];
3774                         setup[setup_count].reconnect   = reconnect[1];
3775                         setup[setup_count].parity      = parity[1];
3776                         setup[setup_count].synchronous = sync[1];
3777                         setup[setup_count].delay       = delay[1];
3778                         setup[setup_count].ext_trans   = exttrans[1];
3779 #if defined(AHA152X_DEBUG)
3780                         setup[setup_count].debug       = debug[1];
3781 #endif
3782                 }
3783                 if (checksetup(&setup[setup_count]))
3784                         setup_count++;
3785                 else
3786                         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",
3787                                setup[setup_count].io_port,
3788                                setup[setup_count].irq,
3789                                setup[setup_count].scsiid,
3790                                setup[setup_count].reconnect,
3791                                setup[setup_count].parity,
3792                                setup[setup_count].synchronous,
3793                                setup[setup_count].delay,
3794                                setup[setup_count].ext_trans);
3795         }
3796 #endif
3797
3798 #ifdef __ISAPNP__
3799         for(i=0; setup_count<ARRAY_SIZE(setup) && id_table[i].vendor; i++) {
3800                 while ( setup_count<ARRAY_SIZE(setup) &&
3801                         (dev=pnp_find_dev(NULL, id_table[i].vendor, id_table[i].function, dev)) ) {
3802                         if (pnp_device_attach(dev) < 0)
3803                                 continue;
3804
3805                         if (pnp_activate_dev(dev) < 0) {
3806                                 pnp_device_detach(dev);
3807                                 continue;
3808                         }
3809
3810                         if (!pnp_port_valid(dev, 0)) {
3811                                 pnp_device_detach(dev);
3812                                 continue;
3813                         }
3814
3815                         if (setup_count==1 && pnp_port_start(dev, 0)==setup[0].io_port) {
3816                                 pnp_device_detach(dev);
3817                                 continue;
3818                         }
3819
3820                         setup[setup_count].io_port     = pnp_port_start(dev, 0);
3821                         setup[setup_count].irq         = pnp_irq(dev, 0);
3822                         setup[setup_count].scsiid      = 7;
3823                         setup[setup_count].reconnect   = 1;
3824                         setup[setup_count].parity      = 1;
3825                         setup[setup_count].synchronous = 1;
3826                         setup[setup_count].delay       = DELAY_DEFAULT;
3827                         setup[setup_count].ext_trans   = 0;
3828 #if defined(AHA152X_DEBUG)
3829                         setup[setup_count].debug       = DEBUG_DEFAULT;
3830 #endif
3831 #if defined(__ISAPNP__)
3832                         pnpdev[setup_count]            = dev;
3833 #endif
3834                         printk (KERN_INFO
3835                                 "aha152x: found ISAPnP adapter at io=0x%03x, irq=%d\n",
3836                                 setup[setup_count].io_port, setup[setup_count].irq);
3837                         setup_count++;
3838                 }
3839         }
3840 #endif
3841
3842 #if defined(AUTOCONF)
3843         if (setup_count<ARRAY_SIZE(setup)) {
3844 #if !defined(SKIP_BIOSTEST)
3845                 ok = 0;
3846                 for (i = 0; i < ARRAY_SIZE(addresses) && !ok; i++) {
3847                         void __iomem *p = ioremap(addresses[i], 0x4000);
3848                         if (!p)
3849                                 continue;
3850                         for (j = 0; j<ARRAY_SIZE(signatures) && !ok; j++)
3851                                 ok = check_signature(p + signatures[j].sig_offset,
3852                                                                 signatures[j].signature, signatures[j].sig_length);
3853                         iounmap(p);
3854                 }
3855                 if (!ok && setup_count == 0)
3856                         return 0;
3857
3858                 printk(KERN_INFO "aha152x: BIOS test: passed, ");
3859 #else
3860                 printk(KERN_INFO "aha152x: ");
3861 #endif                          /* !SKIP_BIOSTEST */
3862
3863                 ok = 0;
3864                 for (i = 0; i < ARRAY_SIZE(ports) && setup_count < 2; i++) {
3865                         if ((setup_count == 1) && (setup[0].io_port == ports[i]))
3866                                 continue;
3867
3868                         if ( request_region(ports[i], IO_RANGE, "aha152x")==0 ) {
3869                                 printk(KERN_ERR "aha152x: io port 0x%x busy.\n", ports[i]);
3870                                 continue;
3871                         }
3872
3873                         if (aha152x_porttest(ports[i])) {
3874                                 setup[setup_count].tc1550  = 0;
3875
3876                                 conf.cf_port =
3877                                     (GETPORT(ports[i] + O_PORTA) << 8) + GETPORT(ports[i] + O_PORTB);
3878                         } else if (tc1550_porttest(ports[i])) {
3879                                 setup[setup_count].tc1550  = 1;
3880
3881                                 conf.cf_port =
3882                                     (GETPORT(ports[i] + O_TC_PORTA) << 8) + GETPORT(ports[i] + O_TC_PORTB);
3883                         } else {
3884                                 release_region(ports[i], IO_RANGE);
3885                                 continue;
3886                         }
3887
3888                         release_region(ports[i], IO_RANGE);
3889
3890                         ok++;
3891                         setup[setup_count].io_port = ports[i];
3892                         setup[setup_count].irq = IRQ_MIN + conf.cf_irq;
3893                         setup[setup_count].scsiid = conf.cf_id;
3894                         setup[setup_count].reconnect = conf.cf_tardisc;
3895                         setup[setup_count].parity = !conf.cf_parity;
3896                         setup[setup_count].synchronous = conf.cf_syncneg;
3897                         setup[setup_count].delay = DELAY_DEFAULT;
3898                         setup[setup_count].ext_trans = 0;
3899 #if defined(AHA152X_DEBUG)
3900                         setup[setup_count].debug = DEBUG_DEFAULT;
3901 #endif
3902                         setup_count++;
3903
3904                 }
3905
3906                 if (ok)
3907                         printk("auto configuration: ok, ");
3908         }
3909 #endif
3910
3911         printk("%d controller(s) configured\n", setup_count);
3912
3913         for (i=0; i<setup_count; i++) {
3914                 if ( request_region(setup[i].io_port, IO_RANGE, "aha152x") ) {
3915                         struct Scsi_Host *shpnt = aha152x_probe_one(&setup[i]);
3916
3917                         if( !shpnt ) {
3918                                 release_region(setup[i].io_port, IO_RANGE);
3919 #if defined(__ISAPNP__)
3920                         } else if( pnpdev[i] ) {
3921                                 HOSTDATA(shpnt)->pnpdev=pnpdev[i];
3922                                 pnpdev[i]=NULL;
3923 #endif
3924                         }
3925                 } else {
3926                         printk(KERN_ERR "aha152x: io port 0x%x busy.\n", setup[i].io_port);
3927                 }
3928
3929 #if defined(__ISAPNP__)
3930                 if( pnpdev[i] )
3931                         pnp_device_detach(pnpdev[i]);
3932 #endif
3933         }
3934
3935         return registered_count>0;
3936 }
3937
3938 static void __exit aha152x_exit(void)
3939 {
3940         int i;
3941
3942         for(i=0; i<ARRAY_SIZE(setup); i++) {
3943                 aha152x_release(aha152x_host[i]);
3944                 aha152x_host[i]=NULL;
3945         }
3946 }
3947
3948 module_init(aha152x_init);
3949 module_exit(aha152x_exit);
3950
3951 #if !defined(MODULE)
3952 static int __init aha152x_setup(char *str)
3953 {
3954 #if defined(AHA152X_DEBUG)
3955         int ints[11];
3956 #else
3957         int ints[10];
3958 #endif
3959         get_options(str, ARRAY_SIZE(ints), ints);
3960
3961         if(setup_count>=ARRAY_SIZE(setup)) {
3962                 printk(KERN_ERR "aha152x: you can only configure up to two controllers\n");
3963                 return 1;
3964         }
3965
3966         setup[setup_count].conf        = str;
3967         setup[setup_count].io_port     = ints[0] >= 1 ? ints[1] : 0x340;
3968         setup[setup_count].irq         = ints[0] >= 2 ? ints[2] : 11;
3969         setup[setup_count].scsiid      = ints[0] >= 3 ? ints[3] : 7;
3970         setup[setup_count].reconnect   = ints[0] >= 4 ? ints[4] : 1;
3971         setup[setup_count].parity      = ints[0] >= 5 ? ints[5] : 1;
3972         setup[setup_count].synchronous = ints[0] >= 6 ? ints[6] : 1;
3973         setup[setup_count].delay       = ints[0] >= 7 ? ints[7] : DELAY_DEFAULT;
3974         setup[setup_count].ext_trans   = ints[0] >= 8 ? ints[8] : 0;
3975 #if defined(AHA152X_DEBUG)
3976         setup[setup_count].debug       = ints[0] >= 9 ? ints[9] : DEBUG_DEFAULT;
3977         if (ints[0] > 9) {
3978                 printk(KERN_NOTICE "aha152x: usage: aha152x=<IOBASE>[,<IRQ>[,<SCSI ID>"
3979                        "[,<RECONNECT>[,<PARITY>[,<SYNCHRONOUS>[,<DELAY>[,<EXT_TRANS>[,<DEBUG>]]]]]]]]\n");
3980 #else
3981         if (ints[0] > 8) {                                                /*}*/
3982                 printk(KERN_NOTICE "aha152x: usage: aha152x=<IOBASE>[,<IRQ>[,<SCSI ID>"
3983                        "[,<RECONNECT>[,<PARITY>[,<SYNCHRONOUS>[,<DELAY>[,<EXT_TRANS>]]]]]]]\n");
3984 #endif
3985         } else {
3986                 setup_count++;
3987                 return 0;
3988         }
3989
3990         return 1;
3991 }
3992 __setup("aha152x=", aha152x_setup);
3993 #endif
3994
3995 #endif /* !PCMCIA */