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

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