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