drivers/scsi/aha152x.c

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