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

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