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