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