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_hw_array(io, int, ioport, NULL, 0);
 335 MODULE_PARM_DESC(io,"base io address of controller");
 336
 337 static int irq[] = {0, 0};
 338 module_param_hw_array(irq, int, irq, 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  * AIC-6260 has a hard reset (MRST signal), but apparently
1144  * one cannot trigger it via software. So live with
1145  * a soft reset; no-one seemed to have cared.
1146  */
1147 static int aha152x_bus_reset_host(struct Scsi_Host *shpnt)
1148 {
1149         unsigned long flags;
1150
1151         DO_LOCK(flags);
1152
1153         free_hard_reset_SCs(shpnt, &ISSUE_SC);
1154         free_hard_reset_SCs(shpnt, &DISCONNECTED_SC);
1155
1156         SETPORT(SCSISEQ, SCSIRSTO);
1157         mdelay(256);
1158         SETPORT(SCSISEQ, 0);
1159         mdelay(DELAY);
1160
1161         setup_expected_interrupts(shpnt);
1162         if(HOSTDATA(shpnt)->commands==0)
1163                 SETPORT(PORTA, 0);
1164
1165         DO_UNLOCK(flags);
1166
1167         return SUCCESS;
1168 }
1169
1170 /*
1171  * Reset the bus
1172  *
1173  */
1174 static int aha152x_bus_reset(Scsi_Cmnd *SCpnt)
1175 {
1176         return aha152x_bus_reset_host(SCpnt->device->host);
1177 }
1178
1179 /*
1180  *  Restore default values to the AIC-6260 registers and reset the fifos
1181  *
1182  */
1183 static void reset_ports(struct Scsi_Host *shpnt)
1184 {
1185         unsigned long flags;
1186
1187         /* disable interrupts */
1188         SETPORT(DMACNTRL0, RSTFIFO);
1189
1190         SETPORT(SCSISEQ, 0);
1191
1192         SETPORT(SXFRCTL1, 0);
1193         SETPORT(SCSISIG, 0);
1194         SETRATE(0);
1195
1196         /* clear all interrupt conditions */
1197         SETPORT(SSTAT0, 0x7f);
1198         SETPORT(SSTAT1, 0xef);
1199
1200         SETPORT(SSTAT4, SYNCERR | FWERR | FRERR);
1201
1202         SETPORT(DMACNTRL0, 0);
1203         SETPORT(DMACNTRL1, 0);
1204
1205         SETPORT(BRSTCNTRL, 0xf1);
1206
1207         /* clear SCSI fifos and transfer count */
1208         SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
1209         SETPORT(SXFRCTL0, CH1);
1210
1211         DO_LOCK(flags);
1212         setup_expected_interrupts(shpnt);
1213         DO_UNLOCK(flags);
1214 }
1215
1216 /*
1217  * Reset the host (bus and controller)
1218  *
1219  */
1220 int aha152x_host_reset_host(struct Scsi_Host *shpnt)
1221 {
1222         aha152x_bus_reset_host(shpnt);
1223         reset_ports(shpnt);
1224
1225         return SUCCESS;
1226 }
1227
1228 /*
1229  * Return the "logical geometry"
1230  *
1231  */
1232 static int aha152x_biosparam(struct scsi_device *sdev, struct block_device *bdev,
1233                 sector_t capacity, int *info_array)
1234 {
1235         struct Scsi_Host *shpnt = sdev->host;
1236
1237         /* try default translation */
1238         info_array[0] = 64;
1239         info_array[1] = 32;
1240         info_array[2] = (unsigned long)capacity / (64 * 32);
1241
1242         /* for disks >1GB do some guessing */
1243         if (info_array[2] >= 1024) {
1244                 int info[3];
1245
1246                 /* try to figure out the geometry from the partition table */
1247                 if (scsicam_bios_param(bdev, capacity, info) < 0 ||
1248                     !((info[0] == 64 && info[1] == 32) || (info[0] == 255 && info[1] == 63))) {
1249                         if (EXT_TRANS) {
1250                                 printk(KERN_NOTICE
1251                                        "aha152x: unable to verify geometry for disk with >1GB.\n"
1252                                        "         using extended translation.\n");
1253                                 info_array[0] = 255;
1254                                 info_array[1] = 63;
1255                                 info_array[2] = (unsigned long)capacity / (255 * 63);
1256                         } else {
1257                                 printk(KERN_NOTICE
1258                                        "aha152x: unable to verify geometry for disk with >1GB.\n"
1259                                        "         Using default translation. Please verify yourself.\n"
1260                                        "         Perhaps you need to enable extended translation in the driver.\n"
1261                                        "         See Documentation/scsi/aha152x.txt for details.\n");
1262                         }
1263                 } else {
1264                         info_array[0] = info[0];
1265                         info_array[1] = info[1];
1266                         info_array[2] = info[2];
1267
1268                         if (info[0] == 255 && !EXT_TRANS) {
1269                                 printk(KERN_NOTICE
1270                                        "aha152x: current partition table is using extended translation.\n"
1271                                        "         using it also, although it's not explicitly enabled.\n");
1272                         }
1273                 }
1274         }
1275
1276         return 0;
1277 }
1278
1279 /*
1280  *  Internal done function
1281  *
1282  */
1283 static void done(struct Scsi_Host *shpnt, int error)
1284 {
1285         if (CURRENT_SC) {
1286                 if(DONE_SC)
1287                         scmd_printk(KERN_ERR, CURRENT_SC,
1288                                     "there's already a completed command %p "
1289                                     "- will cause abort\n", DONE_SC);
1290
1291                 DONE_SC = CURRENT_SC;
1292                 CURRENT_SC = NULL;
1293                 DONE_SC->result = error;
1294         } else
1295                 printk(KERN_ERR "aha152x: done() called outside of command\n");
1296 }
1297
1298 static struct work_struct aha152x_tq;
1299
1300 /*
1301  * Run service completions on the card with interrupts enabled.
1302  *
1303  */
1304 static void run(struct work_struct *work)
1305 {
1306         struct aha152x_hostdata *hd;
1307
1308         list_for_each_entry(hd, &aha152x_host_list, host_list) {
1309                 struct Scsi_Host *shost = container_of((void *)hd, struct Scsi_Host, hostdata);
1310
1311                 is_complete(shost);
1312         }
1313 }
1314
1315 /*
1316  * Interrupt handler
1317  *
1318  */
1319 static irqreturn_t intr(int irqno, void *dev_id)
1320 {
1321         struct Scsi_Host *shpnt = dev_id;
1322         unsigned long flags;
1323         unsigned char rev, dmacntrl0;
1324
1325         /*
1326          * Read a couple of registers that are known to not be all 1's. If
1327          * we read all 1's (-1), that means that either:
1328          *
1329          * a. The host adapter chip has gone bad, and we cannot control it,
1330          *      OR
1331          * b. The host adapter is a PCMCIA card that has been ejected
1332          *
1333          * In either case, we cannot do anything with the host adapter at
1334          * this point in time. So just ignore the interrupt and return.
1335          * In the latter case, the interrupt might actually be meant for
1336          * someone else sharing this IRQ, and that driver will handle it.
1337          */
1338         rev = GETPORT(REV);
1339         dmacntrl0 = GETPORT(DMACNTRL0);
1340         if ((rev == 0xFF) && (dmacntrl0 == 0xFF))
1341                 return IRQ_NONE;
1342
1343         if( TESTLO(DMASTAT, INTSTAT) )
1344                 return IRQ_NONE;
1345
1346         /* no more interrupts from the controller, while we're busy.
1347            INTEN is restored by the BH handler */
1348         CLRBITS(DMACNTRL0, INTEN);
1349
1350         DO_LOCK(flags);
1351         if( HOSTDATA(shpnt)->service==0 ) {
1352                 HOSTDATA(shpnt)->service=1;
1353
1354                 /* Poke the BH handler */
1355                 INIT_WORK(&aha152x_tq, run);
1356                 schedule_work(&aha152x_tq);
1357         }
1358         DO_UNLOCK(flags);
1359
1360         return IRQ_HANDLED;
1361 }
1362
1363 /*
1364  * busfree phase
1365  * - handle completition/disconnection/error of current command
1366  * - start selection for next command (if any)
1367  */
1368 static void busfree_run(struct Scsi_Host *shpnt)
1369 {
1370         unsigned long flags;
1371 #if defined(AHA152X_STAT)
1372         int action=0;
1373 #endif
1374
1375         SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
1376         SETPORT(SXFRCTL0, CH1);
1377
1378         SETPORT(SSTAT1, CLRBUSFREE);
1379
1380         if(CURRENT_SC) {
1381 #if defined(AHA152X_STAT)
1382                 action++;
1383 #endif
1384                 CURRENT_SC->SCp.phase &= ~syncneg;
1385
1386                 if(CURRENT_SC->SCp.phase & completed) {
1387                         /* target sent COMMAND COMPLETE */
1388                         done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_OK << 16));
1389
1390                 } else if(CURRENT_SC->SCp.phase & aborted) {
1391                         done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_ABORT << 16));
1392
1393                 } else if(CURRENT_SC->SCp.phase & resetted) {
1394                         done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_RESET << 16));
1395
1396                 } else if(CURRENT_SC->SCp.phase & disconnected) {
1397                         /* target sent DISCONNECT */
1398 #if defined(AHA152X_STAT)
1399                         HOSTDATA(shpnt)->disconnections++;
1400 #endif
1401                         append_SC(&DISCONNECTED_SC, CURRENT_SC);
1402                         CURRENT_SC->SCp.phase |= 1 << 16;
1403                         CURRENT_SC = NULL;
1404
1405                 } else {
1406                         done(shpnt, DID_ERROR << 16);
1407                 }
1408 #if defined(AHA152X_STAT)
1409         } else {
1410                 HOSTDATA(shpnt)->busfree_without_old_command++;
1411 #endif
1412         }
1413
1414         DO_LOCK(flags);
1415
1416         if(DONE_SC) {
1417 #if defined(AHA152X_STAT)
1418                 action++;
1419 #endif
1420
1421                 if(DONE_SC->SCp.phase & check_condition) {
1422                         struct scsi_cmnd *cmd = HOSTDATA(shpnt)->done_SC;
1423                         struct aha152x_scdata *sc = SCDATA(cmd);
1424
1425                         scsi_eh_restore_cmnd(cmd, &sc->ses);
1426
1427                         cmd->SCp.Status = SAM_STAT_CHECK_CONDITION;
1428
1429                         HOSTDATA(shpnt)->commands--;
1430                         if (!HOSTDATA(shpnt)->commands)
1431                                 SETPORT(PORTA, 0);      /* turn led off */
1432                 } else if(DONE_SC->SCp.Status==SAM_STAT_CHECK_CONDITION) {
1433 #if defined(AHA152X_STAT)
1434                         HOSTDATA(shpnt)->busfree_with_check_condition++;
1435 #endif
1436
1437                         if(!(DONE_SC->SCp.phase & not_issued)) {
1438                                 struct aha152x_scdata *sc;
1439                                 Scsi_Cmnd *ptr = DONE_SC;
1440                                 DONE_SC=NULL;
1441
1442                                 sc = SCDATA(ptr);
1443                                 /* It was allocated in aha152x_internal_queue? */
1444                                 BUG_ON(!sc);
1445                                 scsi_eh_prep_cmnd(ptr, &sc->ses, NULL, 0, ~0);
1446
1447                                 DO_UNLOCK(flags);
1448                                 aha152x_internal_queue(ptr, NULL, check_condition, ptr->scsi_done);
1449                                 DO_LOCK(flags);
1450                         }
1451                 }
1452
1453                 if(DONE_SC && DONE_SC->scsi_done) {
1454                         Scsi_Cmnd *ptr = DONE_SC;
1455                         DONE_SC=NULL;
1456
1457                         /* turn led off, when no commands are in the driver */
1458                         HOSTDATA(shpnt)->commands--;
1459                         if (!HOSTDATA(shpnt)->commands)
1460                                 SETPORT(PORTA, 0);      /* turn led off */
1461
1462                         if(ptr->scsi_done != reset_done) {
1463                                 kfree(ptr->host_scribble);
1464                                 ptr->host_scribble=NULL;
1465                         }
1466
1467                         DO_UNLOCK(flags);
1468                         ptr->scsi_done(ptr);
1469                         DO_LOCK(flags);
1470                 }
1471
1472                 DONE_SC=NULL;
1473 #if defined(AHA152X_STAT)
1474         } else {
1475                 HOSTDATA(shpnt)->busfree_without_done_command++;
1476 #endif
1477         }
1478
1479         if(ISSUE_SC)
1480                 CURRENT_SC = remove_first_SC(&ISSUE_SC);
1481
1482         DO_UNLOCK(flags);
1483
1484         if(CURRENT_SC) {
1485 #if defined(AHA152X_STAT)
1486                 action++;
1487 #endif
1488                 CURRENT_SC->SCp.phase |= selecting;
1489
1490                 /* clear selection timeout */
1491                 SETPORT(SSTAT1, SELTO);
1492
1493                 SETPORT(SCSIID, (shpnt->this_id << OID_) | CURRENT_SC->device->id);
1494                 SETPORT(SXFRCTL1, (PARITY ? ENSPCHK : 0 ) | ENSTIMER);
1495                 SETPORT(SCSISEQ, ENSELO | ENAUTOATNO | (DISCONNECTED_SC ? ENRESELI : 0));
1496         } else {
1497 #if defined(AHA152X_STAT)
1498                 HOSTDATA(shpnt)->busfree_without_new_command++;
1499 #endif
1500                 SETPORT(SCSISEQ, DISCONNECTED_SC ? ENRESELI : 0);
1501         }
1502
1503 #if defined(AHA152X_STAT)
1504         if(!action)
1505                 HOSTDATA(shpnt)->busfree_without_any_action++;
1506 #endif
1507 }
1508
1509 /*
1510  * Selection done (OUT)
1511  * - queue IDENTIFY message and SDTR to selected target for message out
1512  *   (ATN asserted automagically via ENAUTOATNO in busfree())
1513  */
1514 static void seldo_run(struct Scsi_Host *shpnt)
1515 {
1516         SETPORT(SCSISIG, 0);
1517         SETPORT(SSTAT1, CLRBUSFREE);
1518         SETPORT(SSTAT1, CLRPHASECHG);
1519
1520         CURRENT_SC->SCp.phase &= ~(selecting|not_issued);
1521
1522         SETPORT(SCSISEQ, 0);
1523
1524         if (TESTLO(SSTAT0, SELDO)) {
1525                 scmd_printk(KERN_ERR, CURRENT_SC,
1526                             "aha152x: passing bus free condition\n");
1527                 done(shpnt, DID_NO_CONNECT << 16);
1528                 return;
1529         }
1530
1531         SETPORT(SSTAT0, CLRSELDO);
1532
1533         ADDMSGO(IDENTIFY(RECONNECT, CURRENT_SC->device->lun));
1534
1535         if (CURRENT_SC->SCp.phase & aborting) {
1536                 ADDMSGO(ABORT);
1537         } else if (CURRENT_SC->SCp.phase & resetting) {
1538                 ADDMSGO(BUS_DEVICE_RESET);
1539         } else if (SYNCNEG==0 && SYNCHRONOUS) {
1540                 CURRENT_SC->SCp.phase |= syncneg;
1541                 MSGOLEN += spi_populate_sync_msg(&MSGO(MSGOLEN), 50, 8);
1542                 SYNCNEG=1;              /* negotiation in progress */
1543         }
1544
1545         SETRATE(SYNCRATE);
1546 }
1547
1548 /*
1549  * Selection timeout
1550  * - return command to mid-level with failure cause
1551  *
1552  */
1553 static void selto_run(struct Scsi_Host *shpnt)
1554 {
1555         SETPORT(SCSISEQ, 0);
1556         SETPORT(SSTAT1, CLRSELTIMO);
1557
1558         if (!CURRENT_SC)
1559                 return;
1560
1561         CURRENT_SC->SCp.phase &= ~selecting;
1562
1563         if (CURRENT_SC->SCp.phase & aborted)
1564                 done(shpnt, DID_ABORT << 16);
1565         else if (TESTLO(SSTAT0, SELINGO))
1566                 done(shpnt, DID_BUS_BUSY << 16);
1567         else
1568                 /* ARBITRATION won, but SELECTION failed */
1569                 done(shpnt, DID_NO_CONNECT << 16);
1570 }
1571
1572 /*
1573  * Selection in done
1574  * - put current command back to issue queue
1575  *   (reconnection of a disconnected nexus instead
1576  *    of successful selection out)
1577  *
1578  */
1579 static void seldi_run(struct Scsi_Host *shpnt)
1580 {
1581         int selid;
1582         int target;
1583         unsigned long flags;
1584
1585         SETPORT(SCSISIG, 0);
1586         SETPORT(SSTAT0, CLRSELDI);
1587         SETPORT(SSTAT1, CLRBUSFREE);
1588         SETPORT(SSTAT1, CLRPHASECHG);
1589
1590         if(CURRENT_SC) {
1591                 if(!(CURRENT_SC->SCp.phase & not_issued))
1592                         scmd_printk(KERN_ERR, CURRENT_SC,
1593                                     "command should not have been issued yet\n");
1594
1595                 DO_LOCK(flags);
1596                 append_SC(&ISSUE_SC, CURRENT_SC);
1597                 DO_UNLOCK(flags);
1598
1599                 CURRENT_SC = NULL;
1600         }
1601
1602         if (!DISCONNECTED_SC)
1603                 return;
1604
1605         RECONN_TARGET=-1;
1606
1607         selid = GETPORT(SELID) & ~(1 << shpnt->this_id);
1608
1609         if (selid==0) {
1610                 shost_printk(KERN_INFO, shpnt,
1611                              "target id unknown (%02x)\n", selid);
1612                 return;
1613         }
1614
1615         for(target=7; !(selid & (1 << target)); target--)
1616                 ;
1617
1618         if(selid & ~(1 << target)) {
1619                 shost_printk(KERN_INFO, shpnt,
1620                              "multiple targets reconnected (%02x)\n", selid);
1621         }
1622
1623
1624         SETPORT(SCSIID, (shpnt->this_id << OID_) | target);
1625         SETPORT(SCSISEQ, 0);
1626
1627         SETRATE(HOSTDATA(shpnt)->syncrate[target]);
1628
1629         RECONN_TARGET=target;
1630 }
1631
1632 /*
1633  * message in phase
1634  * - handle initial message after reconnection to identify
1635  *   reconnecting nexus
1636  * - queue command on DISCONNECTED_SC on DISCONNECT message
1637  * - set completed flag on COMMAND COMPLETE
1638  *   (other completition code moved to busfree_run)
1639  * - handle response to SDTR
1640  * - clear synchronous transfer agreements on BUS RESET
1641  *
1642  * FIXME: what about SAVE POINTERS, RESTORE POINTERS?
1643  *
1644  */
1645 static void msgi_run(struct Scsi_Host *shpnt)
1646 {
1647         for(;;) {
1648                 int sstat1 = GETPORT(SSTAT1);
1649
1650                 if(sstat1 & (PHASECHG|PHASEMIS|BUSFREE) || !(sstat1 & REQINIT))
1651                         return;
1652
1653                 if (TESTLO(SSTAT0, SPIORDY))
1654                         return;
1655
1656                 ADDMSGI(GETPORT(SCSIDAT));
1657
1658                 if(!CURRENT_SC) {
1659                         if(LASTSTATE!=seldi) {
1660                                 shost_printk(KERN_ERR, shpnt,
1661                                              "message in w/o current command"
1662                                              " not after reselection\n");
1663                         }
1664
1665                         /*
1666                          * Handle reselection
1667                          */
1668                         if(!(MSGI(0) & IDENTIFY_BASE)) {
1669                                 shost_printk(KERN_ERR, shpnt,
1670                                              "target didn't identify after reselection\n");
1671                                 continue;
1672                         }
1673
1674                         CURRENT_SC = remove_lun_SC(&DISCONNECTED_SC, RECONN_TARGET, MSGI(0) & 0x3f);
1675
1676                         if (!CURRENT_SC) {
1677                                 show_queues(shpnt);
1678                                 shost_printk(KERN_ERR, shpnt,
1679                                              "no disconnected command"
1680                                              " for target %d/%d\n",
1681                                              RECONN_TARGET, MSGI(0) & 0x3f);
1682                                 continue;
1683                         }
1684
1685                         CURRENT_SC->SCp.Message = MSGI(0);
1686                         CURRENT_SC->SCp.phase &= ~disconnected;
1687
1688                         MSGILEN=0;
1689
1690                         /* next message if any */
1691                         continue;
1692                 }
1693
1694                 CURRENT_SC->SCp.Message = MSGI(0);
1695
1696                 switch (MSGI(0)) {
1697                 case DISCONNECT:
1698                         if (!RECONNECT)
1699                                 scmd_printk(KERN_WARNING, CURRENT_SC,
1700                                             "target was not allowed to disconnect\n");
1701
1702                         CURRENT_SC->SCp.phase |= disconnected;
1703                         break;
1704
1705                 case COMMAND_COMPLETE:
1706                         CURRENT_SC->SCp.phase |= completed;
1707                         break;
1708
1709                 case MESSAGE_REJECT:
1710                         if (SYNCNEG==1) {
1711                                 scmd_printk(KERN_INFO, CURRENT_SC,
1712                                             "Synchronous Data Transfer Request"
1713                                             " was rejected\n");
1714                                 SYNCNEG=2;      /* negotiation completed */
1715                         } else
1716                                 scmd_printk(KERN_INFO, CURRENT_SC,
1717                                             "inbound message (MESSAGE REJECT)\n");
1718                         break;
1719
1720                 case SAVE_POINTERS:
1721                         break;
1722
1723                 case RESTORE_POINTERS:
1724                         break;
1725
1726                 case EXTENDED_MESSAGE:
1727                         if(MSGILEN<2 || MSGILEN<MSGI(1)+2) {
1728                                 /* not yet completed */
1729                                 continue;
1730                         }
1731
1732                         switch (MSGI(2)) {
1733                         case EXTENDED_SDTR:
1734                                 {
1735                                         long ticks;
1736
1737                                         if (MSGI(1) != 3) {
1738                                                 scmd_printk(KERN_ERR, CURRENT_SC,
1739                                                             "SDTR message length!=3\n");
1740                                                 break;
1741                                         }
1742
1743                                         if (!HOSTDATA(shpnt)->synchronous)
1744                                                 break;
1745
1746                                         printk(INFO_LEAD, CMDINFO(CURRENT_SC));
1747                                         spi_print_msg(&MSGI(0));
1748                                         printk("\n");
1749
1750                                         ticks = (MSGI(3) * 4 + 49) / 50;
1751
1752                                         if (syncneg) {
1753                                                 /* negotiation in progress */
1754                                                 if (ticks > 9 || MSGI(4) < 1 || MSGI(4) > 8) {
1755                                                         ADDMSGO(MESSAGE_REJECT);
1756                                                         scmd_printk(KERN_INFO,
1757                                                                     CURRENT_SC,
1758                                                                     "received Synchronous Data Transfer Request invalid - rejected\n");
1759                                                         break;
1760                                                 }
1761
1762                                                 SYNCRATE |= ((ticks - 2) << 4) + MSGI(4);
1763                                         } else if (ticks <= 9 && MSGI(4) >= 1) {
1764                                                 ADDMSGO(EXTENDED_MESSAGE);
1765                                                 ADDMSGO(3);
1766                                                 ADDMSGO(EXTENDED_SDTR);
1767                                                 if (ticks < 4) {
1768                                                         ticks = 4;
1769                                                         ADDMSGO(50);
1770                                                 } else
1771                                                         ADDMSGO(MSGI(3));
1772
1773                                                 if (MSGI(4) > 8)
1774                                                         MSGI(4) = 8;
1775
1776                                                 ADDMSGO(MSGI(4));
1777
1778                                                 SYNCRATE |= ((ticks - 2) << 4) + MSGI(4);
1779                                         } else {
1780                                                 /* requested SDTR is too slow, do it asynchronously */
1781                                                 scmd_printk(KERN_INFO,
1782                                                             CURRENT_SC,
1783                                                             "Synchronous Data Transfer Request too slow - Rejecting\n");
1784                                                 ADDMSGO(MESSAGE_REJECT);
1785                                         }
1786
1787                                         /* negotiation completed */
1788                                         SYNCNEG=2;
1789                                         SETRATE(SYNCRATE);
1790                                 }
1791                                 break;
1792
1793                         case BUS_DEVICE_RESET:
1794                                 {
1795                                         int i;
1796
1797                                         for(i=0; i<8; i++) {
1798                                                 HOSTDATA(shpnt)->syncrate[i]=0;
1799                                                 HOSTDATA(shpnt)->syncneg[i]=0;
1800                                         }
1801
1802                                 }
1803                                 break;
1804
1805                         case EXTENDED_MODIFY_DATA_POINTER:
1806                         case EXTENDED_EXTENDED_IDENTIFY:
1807                         case EXTENDED_WDTR:
1808                         default:
1809                                 ADDMSGO(MESSAGE_REJECT);
1810                                 break;
1811                         }
1812                         break;
1813                 }
1814
1815                 MSGILEN=0;
1816         }
1817 }
1818
1819 static void msgi_end(struct Scsi_Host *shpnt)
1820 {
1821         if(MSGILEN>0)
1822                 scmd_printk(KERN_WARNING, CURRENT_SC,
1823                             "target left before message completed (%d)\n",
1824                             MSGILEN);
1825
1826         if (MSGOLEN > 0 && !(GETPORT(SSTAT1) & BUSFREE))
1827                 SETPORT(SCSISIG, P_MSGI | SIG_ATNO);
1828 }
1829
1830 /*
1831  * message out phase
1832  *
1833  */
1834 static void msgo_init(struct Scsi_Host *shpnt)
1835 {
1836         if(MSGOLEN==0) {
1837                 if((CURRENT_SC->SCp.phase & syncneg) && SYNCNEG==2 && SYNCRATE==0) {
1838                         ADDMSGO(IDENTIFY(RECONNECT, CURRENT_SC->device->lun));
1839                 } else {
1840                         scmd_printk(KERN_INFO, CURRENT_SC,
1841                                     "unexpected MESSAGE OUT phase; rejecting\n");
1842                         ADDMSGO(MESSAGE_REJECT);
1843                 }
1844         }
1845
1846 }
1847
1848 /*
1849  * message out phase
1850  *
1851  */
1852 static void msgo_run(struct Scsi_Host *shpnt)
1853 {
1854         while(MSGO_I<MSGOLEN) {
1855                 if (TESTLO(SSTAT0, SPIORDY))
1856                         return;
1857
1858                 if (MSGO_I==MSGOLEN-1) {
1859                         /* Leave MESSAGE OUT after transfer */
1860                         SETPORT(SSTAT1, CLRATNO);
1861                 }
1862
1863
1864                 if (MSGO(MSGO_I) & IDENTIFY_BASE)
1865                         CURRENT_SC->SCp.phase |= identified;
1866
1867                 if (MSGO(MSGO_I)==ABORT)
1868                         CURRENT_SC->SCp.phase |= aborted;
1869
1870                 if (MSGO(MSGO_I)==BUS_DEVICE_RESET)
1871                         CURRENT_SC->SCp.phase |= resetted;
1872
1873                 SETPORT(SCSIDAT, MSGO(MSGO_I++));
1874         }
1875 }
1876
1877 static void msgo_end(struct Scsi_Host *shpnt)
1878 {
1879         if(MSGO_I<MSGOLEN) {
1880                 scmd_printk(KERN_ERR, CURRENT_SC,
1881                             "message sent incompletely (%d/%d)\n",
1882                             MSGO_I, MSGOLEN);
1883                 if(SYNCNEG==1) {
1884                         scmd_printk(KERN_INFO, CURRENT_SC,
1885                                     "Synchronous Data Transfer Request was rejected\n");
1886                         SYNCNEG=2;
1887                 }
1888         }
1889
1890         MSGO_I  = 0;
1891         MSGOLEN = 0;
1892 }
1893
1894 /*
1895  * command phase
1896  *
1897  */
1898 static void cmd_init(struct Scsi_Host *shpnt)
1899 {
1900         if (CURRENT_SC->SCp.sent_command) {
1901                 scmd_printk(KERN_ERR, CURRENT_SC,
1902                             "command already sent\n");
1903                 done(shpnt, DID_ERROR << 16);
1904                 return;
1905         }
1906
1907         CMD_I=0;
1908 }
1909
1910 /*
1911  * command phase
1912  *
1913  */
1914 static void cmd_run(struct Scsi_Host *shpnt)
1915 {
1916         while(CMD_I<CURRENT_SC->cmd_len) {
1917                 if (TESTLO(SSTAT0, SPIORDY))
1918                         return;
1919
1920                 SETPORT(SCSIDAT, CURRENT_SC->cmnd[CMD_I++]);
1921         }
1922 }
1923
1924 static void cmd_end(struct Scsi_Host *shpnt)
1925 {
1926         if(CMD_I<CURRENT_SC->cmd_len)
1927                 scmd_printk(KERN_ERR, CURRENT_SC,
1928                             "command sent incompletely (%d/%d)\n",
1929                             CMD_I, CURRENT_SC->cmd_len);
1930         else
1931                 CURRENT_SC->SCp.sent_command++;
1932 }
1933
1934 /*
1935  * status phase
1936  *
1937  */
1938 static void status_run(struct Scsi_Host *shpnt)
1939 {
1940         if (TESTLO(SSTAT0, SPIORDY))
1941                 return;
1942
1943         CURRENT_SC->SCp.Status = GETPORT(SCSIDAT);
1944
1945 }
1946
1947 /*
1948  * data in phase
1949  *
1950  */
1951 static void datai_init(struct Scsi_Host *shpnt)
1952 {
1953         SETPORT(DMACNTRL0, RSTFIFO);
1954         SETPORT(DMACNTRL0, RSTFIFO|ENDMA);
1955
1956         SETPORT(SXFRCTL0, CH1|CLRSTCNT);
1957         SETPORT(SXFRCTL0, CH1|SCSIEN|DMAEN);
1958
1959         SETPORT(SIMODE0, 0);
1960         SETPORT(SIMODE1, ENSCSIPERR | ENSCSIRST | ENPHASEMIS | ENBUSFREE);
1961
1962         DATA_LEN=0;
1963 }
1964
1965 static void datai_run(struct Scsi_Host *shpnt)
1966 {
1967         unsigned long the_time;
1968         int fifodata, data_count;
1969
1970         /*
1971          * loop while the phase persists or the fifos are not empty
1972          *
1973          */
1974         while(TESTLO(DMASTAT, INTSTAT) || TESTLO(DMASTAT, DFIFOEMP) || TESTLO(SSTAT2, SEMPTY)) {
1975                 /* FIXME: maybe this should be done by setting up
1976                  * STCNT to trigger ENSWRAP interrupt, instead of
1977                  * polling for DFIFOFULL
1978                  */
1979                 the_time=jiffies + 100*HZ;
1980                 while(TESTLO(DMASTAT, DFIFOFULL|INTSTAT) && time_before(jiffies,the_time))
1981                         barrier();
1982
1983                 if(TESTLO(DMASTAT, DFIFOFULL|INTSTAT)) {
1984                         scmd_printk(KERN_ERR, CURRENT_SC, "datai timeout\n");
1985                         break;
1986                 }
1987
1988                 if(TESTHI(DMASTAT, DFIFOFULL)) {
1989                         fifodata = 128;
1990                 } else {
1991                         the_time=jiffies + 100*HZ;
1992                         while(TESTLO(SSTAT2, SEMPTY) && time_before(jiffies,the_time))
1993                                 barrier();
1994
1995                         if(TESTLO(SSTAT2, SEMPTY)) {
1996                                 scmd_printk(KERN_ERR, CURRENT_SC,
1997                                             "datai sempty timeout");
1998                                 break;
1999                         }
2000
2001                         fifodata = GETPORT(FIFOSTAT);
2002                 }
2003
2004                 if(CURRENT_SC->SCp.this_residual>0) {
2005                         while(fifodata>0 && CURRENT_SC->SCp.this_residual>0) {
2006                                 data_count = fifodata > CURRENT_SC->SCp.this_residual ?
2007                                                 CURRENT_SC->SCp.this_residual :
2008                                                 fifodata;
2009                                 fifodata -= data_count;
2010
2011                                 if (data_count & 1) {
2012                                         SETPORT(DMACNTRL0, ENDMA|_8BIT);
2013                                         *CURRENT_SC->SCp.ptr++ = GETPORT(DATAPORT);
2014                                         CURRENT_SC->SCp.this_residual--;
2015                                         DATA_LEN++;
2016                                         SETPORT(DMACNTRL0, ENDMA);
2017                                 }
2018
2019                                 if (data_count > 1) {
2020                                         data_count >>= 1;
2021                                         insw(DATAPORT, CURRENT_SC->SCp.ptr, data_count);
2022                                         CURRENT_SC->SCp.ptr += 2 * data_count;
2023                                         CURRENT_SC->SCp.this_residual -= 2 * data_count;
2024                                         DATA_LEN += 2 * data_count;
2025                                 }
2026
2027                                 if (CURRENT_SC->SCp.this_residual == 0 &&
2028                                     CURRENT_SC->SCp.buffers_residual > 0) {
2029                                         /* advance to next buffer */
2030                                         CURRENT_SC->SCp.buffers_residual--;
2031                                         CURRENT_SC->SCp.buffer++;
2032                                         CURRENT_SC->SCp.ptr           = SG_ADDRESS(CURRENT_SC->SCp.buffer);
2033                                         CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length;
2034                                 }
2035                         }
2036                 } else if (fifodata > 0) {
2037                         scmd_printk(KERN_ERR, CURRENT_SC,
2038                                     "no buffers left for %d(%d) bytes"
2039                                     " (data overrun!?)\n",
2040                                     fifodata, GETPORT(FIFOSTAT));
2041                         SETPORT(DMACNTRL0, ENDMA|_8BIT);
2042                         while(fifodata>0) {
2043                                 int data;
2044                                 data=GETPORT(DATAPORT);
2045                                 fifodata--;
2046                                 DATA_LEN++;
2047                         }
2048                         SETPORT(DMACNTRL0, ENDMA|_8BIT);
2049                 }
2050         }
2051
2052         if(TESTLO(DMASTAT, INTSTAT) ||
2053            TESTLO(DMASTAT, DFIFOEMP) ||
2054            TESTLO(SSTAT2, SEMPTY) ||
2055            GETPORT(FIFOSTAT)>0) {
2056                 /*
2057                  * something went wrong, if there's something left in the fifos
2058                  * or the phase didn't change
2059                  */
2060                 scmd_printk(KERN_ERR, CURRENT_SC,
2061                             "fifos should be empty and phase should have changed\n");
2062         }
2063
2064         if(DATA_LEN!=GETSTCNT()) {
2065                 scmd_printk(KERN_ERR, CURRENT_SC,
2066                             "manual transfer count differs from automatic "
2067                             "(count=%d;stcnt=%d;diff=%d;fifostat=%d)",
2068                             DATA_LEN, GETSTCNT(), GETSTCNT()-DATA_LEN,
2069                             GETPORT(FIFOSTAT));
2070                 mdelay(10000);
2071         }
2072 }
2073
2074 static void datai_end(struct Scsi_Host *shpnt)
2075 {
2076         CMD_INC_RESID(CURRENT_SC, -GETSTCNT());
2077
2078         SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2079         SETPORT(DMACNTRL0, 0);
2080 }
2081
2082 /*
2083  * data out phase
2084  *
2085  */
2086 static void datao_init(struct Scsi_Host *shpnt)
2087 {
2088         SETPORT(DMACNTRL0, WRITE_READ | RSTFIFO);
2089         SETPORT(DMACNTRL0, WRITE_READ | ENDMA);
2090
2091         SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2092         SETPORT(SXFRCTL0, CH1|SCSIEN|DMAEN);
2093
2094         SETPORT(SIMODE0, 0);
2095         SETPORT(SIMODE1, ENSCSIPERR | ENSCSIRST | ENPHASEMIS | ENBUSFREE );
2096
2097         DATA_LEN = scsi_get_resid(CURRENT_SC);
2098 }
2099
2100 static void datao_run(struct Scsi_Host *shpnt)
2101 {
2102         unsigned long the_time;
2103         int data_count;
2104
2105         /* until phase changes or all data sent */
2106         while(TESTLO(DMASTAT, INTSTAT) && CURRENT_SC->SCp.this_residual>0) {
2107                 data_count = 128;
2108                 if(data_count > CURRENT_SC->SCp.this_residual)
2109                         data_count=CURRENT_SC->SCp.this_residual;
2110
2111                 if(TESTLO(DMASTAT, DFIFOEMP)) {
2112                         scmd_printk(KERN_ERR, CURRENT_SC,
2113                                     "datao fifo not empty (%d)",
2114                                     GETPORT(FIFOSTAT));
2115                         break;
2116                 }
2117
2118                 if(data_count & 1) {
2119                         SETPORT(DMACNTRL0,WRITE_READ|ENDMA|_8BIT);
2120                         SETPORT(DATAPORT, *CURRENT_SC->SCp.ptr++);
2121                         CURRENT_SC->SCp.this_residual--;
2122                         CMD_INC_RESID(CURRENT_SC, -1);
2123                         SETPORT(DMACNTRL0,WRITE_READ|ENDMA);
2124                 }
2125
2126                 if(data_count > 1) {
2127                         data_count >>= 1;
2128                         outsw(DATAPORT, CURRENT_SC->SCp.ptr, data_count);
2129                         CURRENT_SC->SCp.ptr           += 2 * data_count;
2130                         CURRENT_SC->SCp.this_residual -= 2 * data_count;
2131                         CMD_INC_RESID(CURRENT_SC, -2 * data_count);
2132                 }
2133
2134                 if(CURRENT_SC->SCp.this_residual==0 && CURRENT_SC->SCp.buffers_residual>0) {
2135                         /* advance to next buffer */
2136                         CURRENT_SC->SCp.buffers_residual--;
2137                         CURRENT_SC->SCp.buffer++;
2138                         CURRENT_SC->SCp.ptr           = SG_ADDRESS(CURRENT_SC->SCp.buffer);
2139                         CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length;
2140                 }
2141
2142                 the_time=jiffies + 100*HZ;
2143                 while(TESTLO(DMASTAT, DFIFOEMP|INTSTAT) && time_before(jiffies,the_time))
2144                         barrier();
2145
2146                 if(TESTLO(DMASTAT, DFIFOEMP|INTSTAT)) {
2147                         scmd_printk(KERN_ERR, CURRENT_SC, "dataout timeout\n");
2148                         break;
2149                 }
2150         }
2151 }
2152
2153 static void datao_end(struct Scsi_Host *shpnt)
2154 {
2155         if(TESTLO(DMASTAT, DFIFOEMP)) {
2156                 int data_count = (DATA_LEN - scsi_get_resid(CURRENT_SC)) -
2157                         GETSTCNT();
2158
2159                 CMD_INC_RESID(CURRENT_SC, data_count);
2160
2161                 data_count -= CURRENT_SC->SCp.ptr -
2162                         SG_ADDRESS(CURRENT_SC->SCp.buffer);
2163                 while(data_count>0) {
2164                         CURRENT_SC->SCp.buffer--;
2165                         CURRENT_SC->SCp.buffers_residual++;
2166                         data_count -= CURRENT_SC->SCp.buffer->length;
2167                 }
2168                 CURRENT_SC->SCp.ptr = SG_ADDRESS(CURRENT_SC->SCp.buffer) -
2169                         data_count;
2170                 CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length +
2171                         data_count;
2172         }
2173
2174         SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
2175         SETPORT(SXFRCTL0, CH1);
2176
2177         SETPORT(DMACNTRL0, 0);
2178 }
2179
2180 /*
2181  * figure out what state we're in
2182  *
2183  */
2184 static int update_state(struct Scsi_Host *shpnt)
2185 {
2186         int dataphase=0;
2187         unsigned int stat0 = GETPORT(SSTAT0);
2188         unsigned int stat1 = GETPORT(SSTAT1);
2189
2190         PREVSTATE = STATE;
2191         STATE=unknown;
2192
2193         if(stat1 & SCSIRSTI) {
2194                 STATE=rsti;
2195                 SETPORT(SCSISEQ,0);
2196                 SETPORT(SSTAT1,SCSIRSTI);
2197         } else if (stat0 & SELDI && PREVSTATE == busfree) {
2198                 STATE=seldi;
2199         } else if(stat0 & SELDO && CURRENT_SC && (CURRENT_SC->SCp.phase & selecting)) {
2200                 STATE=seldo;
2201         } else if(stat1 & SELTO) {
2202                 STATE=selto;
2203         } else if(stat1 & BUSFREE) {
2204                 STATE=busfree;
2205                 SETPORT(SSTAT1,BUSFREE);
2206         } else if(stat1 & SCSIPERR) {
2207                 STATE=parerr;
2208                 SETPORT(SSTAT1,SCSIPERR);
2209         } else if(stat1 & REQINIT) {
2210                 switch(GETPORT(SCSISIG) & P_MASK) {
2211                 case P_MSGI:    STATE=msgi;     break;
2212                 case P_MSGO:    STATE=msgo;     break;
2213                 case P_DATAO:   STATE=datao;    break;
2214                 case P_DATAI:   STATE=datai;    break;
2215                 case P_STATUS:  STATE=status;   break;
2216                 case P_CMD:     STATE=cmd;      break;
2217                 }
2218                 dataphase=1;
2219         }
2220
2221         if((stat0 & SELDI) && STATE!=seldi && !dataphase) {
2222                 scmd_printk(KERN_INFO, CURRENT_SC, "reselection missed?");
2223         }
2224
2225         if(STATE!=PREVSTATE) {
2226                 LASTSTATE=PREVSTATE;
2227         }
2228
2229         return dataphase;
2230 }
2231
2232 /*
2233  * handle parity error
2234  *
2235  * FIXME: in which phase?
2236  *
2237  */
2238 static void parerr_run(struct Scsi_Host *shpnt)
2239 {
2240         scmd_printk(KERN_ERR, CURRENT_SC, "parity error\n");
2241         done(shpnt, DID_PARITY << 16);
2242 }
2243
2244 /*
2245  * handle reset in
2246  *
2247  */
2248 static void rsti_run(struct Scsi_Host *shpnt)
2249 {
2250         Scsi_Cmnd *ptr;
2251
2252         shost_printk(KERN_NOTICE, shpnt, "scsi reset in\n");
2253
2254         ptr=DISCONNECTED_SC;
2255         while(ptr) {
2256                 Scsi_Cmnd *next = SCNEXT(ptr);
2257
2258                 if (!ptr->device->soft_reset) {
2259                         remove_SC(&DISCONNECTED_SC, ptr);
2260
2261                         kfree(ptr->host_scribble);
2262                         ptr->host_scribble=NULL;
2263
2264                         ptr->result =  DID_RESET << 16;
2265                         ptr->scsi_done(ptr);
2266                 }
2267
2268                 ptr = next;
2269         }
2270
2271         if(CURRENT_SC && !CURRENT_SC->device->soft_reset)
2272                 done(shpnt, DID_RESET << 16 );
2273 }
2274
2275
2276 /*
2277  * bottom-half handler
2278  *
2279  */
2280 static void is_complete(struct Scsi_Host *shpnt)
2281 {
2282         int dataphase;
2283         unsigned long flags;
2284         int pending;
2285
2286         if(!shpnt)
2287                 return;
2288
2289         DO_LOCK(flags);
2290
2291         if( HOSTDATA(shpnt)->service==0 )  {
2292                 DO_UNLOCK(flags);
2293                 return;
2294         }
2295
2296         HOSTDATA(shpnt)->service = 0;
2297
2298         if(HOSTDATA(shpnt)->in_intr) {
2299                 DO_UNLOCK(flags);
2300                 /* aha152x_error never returns.. */
2301                 aha152x_error(shpnt, "bottom-half already running!?");
2302         }
2303         HOSTDATA(shpnt)->in_intr++;
2304
2305         /*
2306          * loop while there are interrupt conditions pending
2307          *
2308          */
2309         do {
2310                 unsigned long start = jiffies;
2311                 DO_UNLOCK(flags);
2312
2313                 dataphase=update_state(shpnt);
2314
2315                 /*
2316                  * end previous state
2317                  *
2318                  */
2319                 if(PREVSTATE!=STATE && states[PREVSTATE].end)
2320                         states[PREVSTATE].end(shpnt);
2321
2322                 /*
2323                  * disable SPIO mode if previous phase used it
2324                  * and this one doesn't
2325                  *
2326                  */
2327                 if(states[PREVSTATE].spio && !states[STATE].spio) {
2328                         SETPORT(SXFRCTL0, CH1);
2329                         SETPORT(DMACNTRL0, 0);
2330                         if(CURRENT_SC)
2331                                 CURRENT_SC->SCp.phase &= ~spiordy;
2332                 }
2333
2334                 /*
2335                  * accept current dataphase phase
2336                  *
2337                  */
2338                 if(dataphase) {
2339                         SETPORT(SSTAT0, REQINIT);
2340                         SETPORT(SCSISIG, GETPORT(SCSISIG) & P_MASK);
2341                         SETPORT(SSTAT1, PHASECHG);
2342                 }
2343
2344                 /*
2345                  * enable SPIO mode if previous didn't use it
2346                  * and this one does
2347                  *
2348                  */
2349                 if(!states[PREVSTATE].spio && states[STATE].spio) {
2350                         SETPORT(DMACNTRL0, 0);
2351                         SETPORT(SXFRCTL0, CH1|SPIOEN);
2352                         if(CURRENT_SC)
2353                                 CURRENT_SC->SCp.phase |= spiordy;
2354                 }
2355
2356                 /*
2357                  * initialize for new state
2358                  *
2359                  */
2360                 if(PREVSTATE!=STATE && states[STATE].init)
2361                         states[STATE].init(shpnt);
2362
2363                 /*
2364                  * handle current state
2365                  *
2366                  */
2367                 if(states[STATE].run)
2368                         states[STATE].run(shpnt);
2369                 else
2370                         scmd_printk(KERN_ERR, CURRENT_SC,
2371                                     "unexpected state (%x)\n", STATE);
2372
2373                 /*
2374                  * setup controller to interrupt on
2375                  * the next expected condition and
2376                  * loop if it's already there
2377                  *
2378                  */
2379                 DO_LOCK(flags);
2380                 pending=setup_expected_interrupts(shpnt);
2381 #if defined(AHA152X_STAT)
2382                 HOSTDATA(shpnt)->count[STATE]++;
2383                 if(PREVSTATE!=STATE)
2384                         HOSTDATA(shpnt)->count_trans[STATE]++;
2385                 HOSTDATA(shpnt)->time[STATE] += jiffies-start;
2386 #endif
2387
2388         } while(pending);
2389
2390         /*
2391          * enable interrupts and leave bottom-half
2392          *
2393          */
2394         HOSTDATA(shpnt)->in_intr--;
2395         SETBITS(DMACNTRL0, INTEN);
2396         DO_UNLOCK(flags);
2397 }
2398
2399
2400 /*
2401  * Dump the current driver status and panic
2402  */
2403 static void aha152x_error(struct Scsi_Host *shpnt, char *msg)
2404 {
2405         shost_printk(KERN_EMERG, shpnt, "%s\n", msg);
2406         show_queues(shpnt);
2407         panic("aha152x panic\n");
2408 }
2409
2410 /*
2411  * display enabled interrupts
2412  */
2413 static void disp_enintr(struct Scsi_Host *shpnt)
2414 {
2415         int s0, s1;
2416
2417         s0 = GETPORT(SIMODE0);
2418         s1 = GETPORT(SIMODE1);
2419
2420         shost_printk(KERN_DEBUG, shpnt,
2421                      "enabled interrupts (%s%s%s%s%s%s%s%s%s%s%s%s%s%s)\n",
2422                      (s0 & ENSELDO) ? "ENSELDO " : "",
2423                      (s0 & ENSELDI) ? "ENSELDI " : "",
2424                      (s0 & ENSELINGO) ? "ENSELINGO " : "",
2425                      (s0 & ENSWRAP) ? "ENSWRAP " : "",
2426                      (s0 & ENSDONE) ? "ENSDONE " : "",
2427                      (s0 & ENSPIORDY) ? "ENSPIORDY " : "",
2428                      (s0 & ENDMADONE) ? "ENDMADONE " : "",
2429                      (s1 & ENSELTIMO) ? "ENSELTIMO " : "",
2430                      (s1 & ENATNTARG) ? "ENATNTARG " : "",
2431                      (s1 & ENPHASEMIS) ? "ENPHASEMIS " : "",
2432                      (s1 & ENBUSFREE) ? "ENBUSFREE " : "",
2433                      (s1 & ENSCSIPERR) ? "ENSCSIPERR " : "",
2434                      (s1 & ENPHASECHG) ? "ENPHASECHG " : "",
2435                      (s1 & ENREQINIT) ? "ENREQINIT " : "");
2436 }
2437
2438 /*
2439  * Show the command data of a command
2440  */
2441 static void show_command(Scsi_Cmnd *ptr)
2442 {
2443         scsi_print_command(ptr);
2444         scmd_printk(KERN_DEBUG, ptr,
2445                     "request_bufflen=%d; resid=%d; "
2446                     "phase |%s%s%s%s%s%s%s%s%s; next=0x%p",
2447                     scsi_bufflen(ptr), scsi_get_resid(ptr),
2448                     (ptr->SCp.phase & not_issued) ? "not issued|" : "",
2449                     (ptr->SCp.phase & selecting) ? "selecting|" : "",
2450                     (ptr->SCp.phase & identified) ? "identified|" : "",
2451                     (ptr->SCp.phase & disconnected) ? "disconnected|" : "",
2452                     (ptr->SCp.phase & completed) ? "completed|" : "",
2453                     (ptr->SCp.phase & spiordy) ? "spiordy|" : "",
2454                     (ptr->SCp.phase & syncneg) ? "syncneg|" : "",
2455                     (ptr->SCp.phase & aborted) ? "aborted|" : "",
2456                     (ptr->SCp.phase & resetted) ? "resetted|" : "",
2457                     (SCDATA(ptr)) ? SCNEXT(ptr) : NULL);
2458 }
2459
2460 /*
2461  * Dump the queued data
2462  */
2463 static void show_queues(struct Scsi_Host *shpnt)
2464 {
2465         Scsi_Cmnd *ptr;
2466         unsigned long flags;
2467
2468         DO_LOCK(flags);
2469         printk(KERN_DEBUG "\nqueue status:\nissue_SC:\n");
2470         for (ptr = ISSUE_SC; ptr; ptr = SCNEXT(ptr))
2471                 show_command(ptr);
2472         DO_UNLOCK(flags);
2473
2474         printk(KERN_DEBUG "current_SC:\n");
2475         if (CURRENT_SC)
2476                 show_command(CURRENT_SC);
2477         else
2478                 printk(KERN_DEBUG "none\n");
2479
2480         printk(KERN_DEBUG "disconnected_SC:\n");
2481         for (ptr = DISCONNECTED_SC; ptr; ptr = SCDATA(ptr) ? SCNEXT(ptr) : NULL)
2482                 show_command(ptr);
2483
2484         disp_enintr(shpnt);
2485 }
2486
2487 static void get_command(struct seq_file *m, Scsi_Cmnd * ptr)
2488 {
2489         int i;
2490
2491         seq_printf(m, "%p: target=%d; lun=%d; cmnd=( ",
2492                 ptr, ptr->device->id, (u8)ptr->device->lun);
2493
2494         for (i = 0; i < COMMAND_SIZE(ptr->cmnd[0]); i++)
2495                 seq_printf(m, "0x%02x ", ptr->cmnd[i]);
2496
2497         seq_printf(m, "); resid=%d; residual=%d; buffers=%d; phase |",
2498                 scsi_get_resid(ptr), ptr->SCp.this_residual,
2499                 ptr->SCp.buffers_residual);
2500
2501         if (ptr->SCp.phase & not_issued)
2502                 seq_puts(m, "not issued|");
2503         if (ptr->SCp.phase & selecting)
2504                 seq_puts(m, "selecting|");
2505         if (ptr->SCp.phase & disconnected)
2506                 seq_puts(m, "disconnected|");
2507         if (ptr->SCp.phase & aborted)
2508                 seq_puts(m, "aborted|");
2509         if (ptr->SCp.phase & identified)
2510                 seq_puts(m, "identified|");
2511         if (ptr->SCp.phase & completed)
2512                 seq_puts(m, "completed|");
2513         if (ptr->SCp.phase & spiordy)
2514                 seq_puts(m, "spiordy|");
2515         if (ptr->SCp.phase & syncneg)
2516                 seq_puts(m, "syncneg|");
2517         seq_printf(m, "; next=0x%p\n", SCNEXT(ptr));
2518 }
2519
2520 static void get_ports(struct seq_file *m, struct Scsi_Host *shpnt)
2521 {
2522         int s;
2523
2524         seq_printf(m, "\n%s: %s(%s) ", CURRENT_SC ? "on bus" : "waiting", states[STATE].name, states[PREVSTATE].name);
2525
2526         s = GETPORT(SCSISEQ);
2527         seq_puts(m, "SCSISEQ( ");
2528         if (s & TEMODEO)
2529                 seq_puts(m, "TARGET MODE ");
2530         if (s & ENSELO)
2531                 seq_puts(m, "SELO ");
2532         if (s & ENSELI)
2533                 seq_puts(m, "SELI ");
2534         if (s & ENRESELI)
2535                 seq_puts(m, "RESELI ");
2536         if (s & ENAUTOATNO)
2537                 seq_puts(m, "AUTOATNO ");
2538         if (s & ENAUTOATNI)
2539                 seq_puts(m, "AUTOATNI ");
2540         if (s & ENAUTOATNP)
2541                 seq_puts(m, "AUTOATNP ");
2542         if (s & SCSIRSTO)
2543                 seq_puts(m, "SCSIRSTO ");
2544         seq_puts(m, ");");
2545
2546         seq_puts(m, " SCSISIG(");
2547         s = GETPORT(SCSISIG);
2548         switch (s & P_MASK) {
2549         case P_DATAO:
2550                 seq_puts(m, "DATA OUT");
2551                 break;
2552         case P_DATAI:
2553                 seq_puts(m, "DATA IN");
2554                 break;
2555         case P_CMD:
2556                 seq_puts(m, "COMMAND");
2557                 break;
2558         case P_STATUS:
2559                 seq_puts(m, "STATUS");
2560                 break;
2561         case P_MSGO:
2562                 seq_puts(m, "MESSAGE OUT");
2563                 break;
2564         case P_MSGI:
2565                 seq_puts(m, "MESSAGE IN");
2566                 break;
2567         default:
2568                 seq_puts(m, "*invalid*");
2569                 break;
2570         }
2571
2572         seq_puts(m, "); ");
2573
2574         seq_printf(m, "INTSTAT (%s); ", TESTHI(DMASTAT, INTSTAT) ? "hi" : "lo");
2575
2576         seq_puts(m, "SSTAT( ");
2577         s = GETPORT(SSTAT0);
2578         if (s & TARGET)
2579                 seq_puts(m, "TARGET ");
2580         if (s & SELDO)
2581                 seq_puts(m, "SELDO ");
2582         if (s & SELDI)
2583                 seq_puts(m, "SELDI ");
2584         if (s & SELINGO)
2585                 seq_puts(m, "SELINGO ");
2586         if (s & SWRAP)
2587                 seq_puts(m, "SWRAP ");
2588         if (s & SDONE)
2589                 seq_puts(m, "SDONE ");
2590         if (s & SPIORDY)
2591                 seq_puts(m, "SPIORDY ");
2592         if (s & DMADONE)
2593                 seq_puts(m, "DMADONE ");
2594
2595         s = GETPORT(SSTAT1);
2596         if (s & SELTO)
2597                 seq_puts(m, "SELTO ");
2598         if (s & ATNTARG)
2599                 seq_puts(m, "ATNTARG ");
2600         if (s & SCSIRSTI)
2601                 seq_puts(m, "SCSIRSTI ");
2602         if (s & PHASEMIS)
2603                 seq_puts(m, "PHASEMIS ");
2604         if (s & BUSFREE)
2605                 seq_puts(m, "BUSFREE ");
2606         if (s & SCSIPERR)
2607                 seq_puts(m, "SCSIPERR ");
2608         if (s & PHASECHG)
2609                 seq_puts(m, "PHASECHG ");
2610         if (s & REQINIT)
2611                 seq_puts(m, "REQINIT ");
2612         seq_puts(m, "); ");
2613
2614
2615         seq_puts(m, "SSTAT( ");
2616
2617         s = GETPORT(SSTAT0) & GETPORT(SIMODE0);
2618
2619         if (s & TARGET)
2620                 seq_puts(m, "TARGET ");
2621         if (s & SELDO)
2622                 seq_puts(m, "SELDO ");
2623         if (s & SELDI)
2624                 seq_puts(m, "SELDI ");
2625         if (s & SELINGO)
2626                 seq_puts(m, "SELINGO ");
2627         if (s & SWRAP)
2628                 seq_puts(m, "SWRAP ");
2629         if (s & SDONE)
2630                 seq_puts(m, "SDONE ");
2631         if (s & SPIORDY)
2632                 seq_puts(m, "SPIORDY ");
2633         if (s & DMADONE)
2634                 seq_puts(m, "DMADONE ");
2635
2636         s = GETPORT(SSTAT1) & GETPORT(SIMODE1);
2637
2638         if (s & SELTO)
2639                 seq_puts(m, "SELTO ");
2640         if (s & ATNTARG)
2641                 seq_puts(m, "ATNTARG ");
2642         if (s & SCSIRSTI)
2643                 seq_puts(m, "SCSIRSTI ");
2644         if (s & PHASEMIS)
2645                 seq_puts(m, "PHASEMIS ");
2646         if (s & BUSFREE)
2647                 seq_puts(m, "BUSFREE ");
2648         if (s & SCSIPERR)
2649                 seq_puts(m, "SCSIPERR ");
2650         if (s & PHASECHG)
2651                 seq_puts(m, "PHASECHG ");
2652         if (s & REQINIT)
2653                 seq_puts(m, "REQINIT ");
2654         seq_puts(m, "); ");
2655
2656         seq_puts(m, "SXFRCTL0( ");
2657
2658         s = GETPORT(SXFRCTL0);
2659         if (s & SCSIEN)
2660                 seq_puts(m, "SCSIEN ");
2661         if (s & DMAEN)
2662                 seq_puts(m, "DMAEN ");
2663         if (s & CH1)
2664                 seq_puts(m, "CH1 ");
2665         if (s & CLRSTCNT)
2666                 seq_puts(m, "CLRSTCNT ");
2667         if (s & SPIOEN)
2668                 seq_puts(m, "SPIOEN ");
2669         if (s & CLRCH1)
2670                 seq_puts(m, "CLRCH1 ");
2671         seq_puts(m, "); ");
2672
2673         seq_puts(m, "SIGNAL( ");
2674
2675         s = GETPORT(SCSISIG);
2676         if (s & SIG_ATNI)
2677                 seq_puts(m, "ATNI ");
2678         if (s & SIG_SELI)
2679                 seq_puts(m, "SELI ");
2680         if (s & SIG_BSYI)
2681                 seq_puts(m, "BSYI ");
2682         if (s & SIG_REQI)
2683                 seq_puts(m, "REQI ");
2684         if (s & SIG_ACKI)
2685                 seq_puts(m, "ACKI ");
2686         seq_puts(m, "); ");
2687
2688         seq_printf(m, "SELID(%02x), ", GETPORT(SELID));
2689
2690         seq_printf(m, "STCNT(%d), ", GETSTCNT());
2691
2692         seq_puts(m, "SSTAT2( ");
2693
2694         s = GETPORT(SSTAT2);
2695         if (s & SOFFSET)
2696                 seq_puts(m, "SOFFSET ");
2697         if (s & SEMPTY)
2698                 seq_puts(m, "SEMPTY ");
2699         if (s & SFULL)
2700                 seq_puts(m, "SFULL ");
2701         seq_printf(m, "); SFCNT (%d); ", s & (SFULL | SFCNT));
2702
2703         s = GETPORT(SSTAT3);
2704         seq_printf(m, "SCSICNT (%d), OFFCNT(%d), ", (s & 0xf0) >> 4, s & 0x0f);
2705
2706         seq_puts(m, "SSTAT4( ");
2707         s = GETPORT(SSTAT4);
2708         if (s & SYNCERR)
2709                 seq_puts(m, "SYNCERR ");
2710         if (s & FWERR)
2711                 seq_puts(m, "FWERR ");
2712         if (s & FRERR)
2713                 seq_puts(m, "FRERR ");
2714         seq_puts(m, "); ");
2715
2716         seq_puts(m, "DMACNTRL0( ");
2717         s = GETPORT(DMACNTRL0);
2718         seq_printf(m, "%s ", s & _8BIT ? "8BIT" : "16BIT");
2719         seq_printf(m, "%s ", s & DMA ? "DMA" : "PIO");
2720         seq_printf(m, "%s ", s & WRITE_READ ? "WRITE" : "READ");
2721         if (s & ENDMA)
2722                 seq_puts(m, "ENDMA ");
2723         if (s & INTEN)
2724                 seq_puts(m, "INTEN ");
2725         if (s & RSTFIFO)
2726                 seq_puts(m, "RSTFIFO ");
2727         if (s & SWINT)
2728                 seq_puts(m, "SWINT ");
2729         seq_puts(m, "); ");
2730
2731         seq_puts(m, "DMASTAT( ");
2732         s = GETPORT(DMASTAT);
2733         if (s & ATDONE)
2734                 seq_puts(m, "ATDONE ");
2735         if (s & WORDRDY)
2736                 seq_puts(m, "WORDRDY ");
2737         if (s & DFIFOFULL)
2738                 seq_puts(m, "DFIFOFULL ");
2739         if (s & DFIFOEMP)
2740                 seq_puts(m, "DFIFOEMP ");
2741         seq_puts(m, ")\n");
2742
2743         seq_puts(m, "enabled interrupts( ");
2744
2745         s = GETPORT(SIMODE0);
2746         if (s & ENSELDO)
2747                 seq_puts(m, "ENSELDO ");
2748         if (s & ENSELDI)
2749                 seq_puts(m, "ENSELDI ");
2750         if (s & ENSELINGO)
2751                 seq_puts(m, "ENSELINGO ");
2752         if (s & ENSWRAP)
2753                 seq_puts(m, "ENSWRAP ");
2754         if (s & ENSDONE)
2755                 seq_puts(m, "ENSDONE ");
2756         if (s & ENSPIORDY)
2757                 seq_puts(m, "ENSPIORDY ");
2758         if (s & ENDMADONE)
2759                 seq_puts(m, "ENDMADONE ");
2760
2761         s = GETPORT(SIMODE1);
2762         if (s & ENSELTIMO)
2763                 seq_puts(m, "ENSELTIMO ");
2764         if (s & ENATNTARG)
2765                 seq_puts(m, "ENATNTARG ");
2766         if (s & ENPHASEMIS)
2767                 seq_puts(m, "ENPHASEMIS ");
2768         if (s & ENBUSFREE)
2769                 seq_puts(m, "ENBUSFREE ");
2770         if (s & ENSCSIPERR)
2771                 seq_puts(m, "ENSCSIPERR ");
2772         if (s & ENPHASECHG)
2773                 seq_puts(m, "ENPHASECHG ");
2774         if (s & ENREQINIT)
2775                 seq_puts(m, "ENREQINIT ");
2776         seq_puts(m, ")\n");
2777 }
2778
2779 static int aha152x_set_info(struct Scsi_Host *shpnt, char *buffer, int length)
2780 {
2781         if(!shpnt || !buffer || length<8 || strncmp("aha152x ", buffer, 8)!=0)
2782                 return -EINVAL;
2783
2784 #if defined(AHA152X_STAT)
2785         if(length>13 && strncmp("reset", buffer+8, 5)==0) {
2786                 int i;
2787
2788                 HOSTDATA(shpnt)->total_commands=0;
2789                 HOSTDATA(shpnt)->disconnections=0;
2790                 HOSTDATA(shpnt)->busfree_without_any_action=0;
2791                 HOSTDATA(shpnt)->busfree_without_old_command=0;
2792                 HOSTDATA(shpnt)->busfree_without_new_command=0;
2793                 HOSTDATA(shpnt)->busfree_without_done_command=0;
2794                 HOSTDATA(shpnt)->busfree_with_check_condition=0;
2795                 for (i = idle; i<maxstate; i++) {
2796                         HOSTDATA(shpnt)->count[i]=0;
2797                         HOSTDATA(shpnt)->count_trans[i]=0;
2798                         HOSTDATA(shpnt)->time[i]=0;
2799                 }
2800
2801                 shost_printk(KERN_INFO, shpnt, "aha152x: stats reset.\n");
2802
2803         } else
2804 #endif
2805         {
2806                 return -EINVAL;
2807         }
2808
2809
2810         return length;
2811 }
2812
2813 static int aha152x_show_info(struct seq_file *m, struct Scsi_Host *shpnt)
2814 {
2815         int i;
2816         Scsi_Cmnd *ptr;
2817         unsigned long flags;
2818
2819         seq_puts(m, AHA152X_REVID "\n");
2820
2821         seq_printf(m, "ioports 0x%04lx to 0x%04lx\n",
2822                 shpnt->io_port, shpnt->io_port + shpnt->n_io_port - 1);
2823         seq_printf(m, "interrupt 0x%02x\n", shpnt->irq);
2824         seq_printf(m, "disconnection/reconnection %s\n",
2825                 RECONNECT ? "enabled" : "disabled");
2826         seq_printf(m, "parity checking %s\n",
2827                 PARITY ? "enabled" : "disabled");
2828         seq_printf(m, "synchronous transfers %s\n",
2829                 SYNCHRONOUS ? "enabled" : "disabled");
2830         seq_printf(m, "%d commands currently queued\n", HOSTDATA(shpnt)->commands);
2831
2832         if(SYNCHRONOUS) {
2833                 seq_puts(m, "synchronously operating targets (tick=50 ns):\n");
2834                 for (i = 0; i < 8; i++)
2835                         if (HOSTDATA(shpnt)->syncrate[i] & 0x7f)
2836                                 seq_printf(m, "target %d: period %dT/%dns; req/ack offset %d\n",
2837                                         i,
2838                                         (((HOSTDATA(shpnt)->syncrate[i] & 0x70) >> 4) + 2),
2839                                         (((HOSTDATA(shpnt)->syncrate[i] & 0x70) >> 4) + 2) * 50,
2840                                     HOSTDATA(shpnt)->syncrate[i] & 0x0f);
2841         }
2842         seq_puts(m, "\nqueue status:\n");
2843         DO_LOCK(flags);
2844         if (ISSUE_SC) {
2845                 seq_puts(m, "not yet issued commands:\n");
2846                 for (ptr = ISSUE_SC; ptr; ptr = SCNEXT(ptr))
2847                         get_command(m, ptr);
2848         } else
2849                 seq_puts(m, "no not yet issued commands\n");
2850         DO_UNLOCK(flags);
2851
2852         if (CURRENT_SC) {
2853                 seq_puts(m, "current command:\n");
2854                 get_command(m, CURRENT_SC);
2855         } else
2856                 seq_puts(m, "no current command\n");
2857
2858         if (DISCONNECTED_SC) {
2859                 seq_puts(m, "disconnected commands:\n");
2860                 for (ptr = DISCONNECTED_SC; ptr; ptr = SCNEXT(ptr))
2861                         get_command(m, ptr);
2862         } else
2863                 seq_puts(m, "no disconnected commands\n");
2864
2865         get_ports(m, shpnt);
2866
2867 #if defined(AHA152X_STAT)
2868         seq_printf(m, "statistics:\n"
2869                 "total commands:               %d\n"
2870                 "disconnections:               %d\n"
2871                 "busfree with check condition: %d\n"
2872                 "busfree without old command:  %d\n"
2873                 "busfree without new command:  %d\n"
2874                 "busfree without done command: %d\n"
2875                 "busfree without any action:   %d\n"
2876                 "state      "
2877                 "transitions  "
2878                 "count        "
2879                 "time\n",
2880                 HOSTDATA(shpnt)->total_commands,
2881                 HOSTDATA(shpnt)->disconnections,
2882                 HOSTDATA(shpnt)->busfree_with_check_condition,
2883                 HOSTDATA(shpnt)->busfree_without_old_command,
2884                 HOSTDATA(shpnt)->busfree_without_new_command,
2885                 HOSTDATA(shpnt)->busfree_without_done_command,
2886                 HOSTDATA(shpnt)->busfree_without_any_action);
2887         for(i=0; i<maxstate; i++) {
2888                 seq_printf(m, "%-10s %-12d %-12d %-12ld\n",
2889                         states[i].name,
2890                         HOSTDATA(shpnt)->count_trans[i],
2891                         HOSTDATA(shpnt)->count[i],
2892                         HOSTDATA(shpnt)->time[i]);
2893         }
2894 #endif
2895         return 0;
2896 }
2897
2898 static int aha152x_adjust_queue(struct scsi_device *device)
2899 {
2900         blk_queue_bounce_limit(device->request_queue, BLK_BOUNCE_HIGH);
2901         return 0;
2902 }
2903
2904 static struct scsi_host_template aha152x_driver_template = {
2905         .module                         = THIS_MODULE,
2906         .name                           = AHA152X_REVID,
2907         .proc_name                      = "aha152x",
2908         .show_info                      = aha152x_show_info,
2909         .write_info                     = aha152x_set_info,
2910         .queuecommand                   = aha152x_queue,
2911         .eh_abort_handler               = aha152x_abort,
2912         .eh_device_reset_handler        = aha152x_device_reset,
2913         .eh_bus_reset_handler           = aha152x_bus_reset,
2914         .bios_param                     = aha152x_biosparam,
2915         .can_queue                      = 1,
2916         .this_id                        = 7,
2917         .sg_tablesize                   = SG_ALL,
2918         .use_clustering                 = DISABLE_CLUSTERING,
2919         .slave_alloc                    = aha152x_adjust_queue,
2920 };
2921
2922 #if !defined(PCMCIA)
2923 static int setup_count;
2924 static struct aha152x_setup setup[2];
2925
2926 /* possible i/o addresses for the AIC-6260; default first */
2927 static unsigned short ports[] = { 0x340, 0x140 };
2928
2929 #if !defined(SKIP_BIOSTEST)
2930 /* possible locations for the Adaptec BIOS; defaults first */
2931 static unsigned int addresses[] =
2932 {
2933         0xdc000,                /* default first */
2934         0xc8000,
2935         0xcc000,
2936         0xd0000,
2937         0xd4000,
2938         0xd8000,
2939         0xe0000,
2940         0xeb800,                /* VTech Platinum SMP */
2941         0xf0000,
2942 };
2943
2944 /* signatures for various AIC-6[23]60 based controllers.
2945    The point in detecting signatures is to avoid useless and maybe
2946    harmful probes on ports. I'm not sure that all listed boards pass
2947    auto-configuration. For those which fail the BIOS signature is
2948    obsolete, because user intervention to supply the configuration is
2949    needed anyway.  May be an information whether or not the BIOS supports
2950    extended translation could be also useful here. */
2951 static struct signature {
2952         unsigned char *signature;
2953         int sig_offset;
2954         int sig_length;
2955 } signatures[] =
2956 {
2957         { "Adaptec AHA-1520 BIOS",      0x102e, 21 },
2958                 /* Adaptec 152x */
2959         { "Adaptec AHA-1520B",          0x000b, 17 },
2960                 /* Adaptec 152x rev B */
2961         { "Adaptec AHA-1520B",          0x0026, 17 },
2962                 /* Iomega Jaz Jet ISA (AIC6370Q) */
2963         { "Adaptec ASW-B626 BIOS",      0x1029, 21 },
2964                 /* on-board controller */
2965         { "Adaptec BIOS: ASW-B626",     0x000f, 22 },
2966                 /* on-board controller */
2967         { "Adaptec ASW-B626 S2",        0x2e6c, 19 },
2968                 /* on-board controller */
2969         { "Adaptec BIOS:AIC-6360",      0x000c, 21 },
2970                 /* on-board controller */
2971         { "ScsiPro SP-360 BIOS",        0x2873, 19 },
2972                 /* ScsiPro-Controller  */
2973         { "GA-400 LOCAL BUS SCSI BIOS", 0x102e, 26 },
2974                 /* Gigabyte Local-Bus-SCSI */
2975         { "Adaptec BIOS:AVA-282X",      0x000c, 21 },
2976                 /* Adaptec 282x */
2977         { "Adaptec IBM Dock II SCSI",   0x2edd, 24 },
2978                 /* IBM Thinkpad Dock II */
2979         { "Adaptec BIOS:AHA-1532P",     0x001c, 22 },
2980                 /* IBM Thinkpad Dock II SCSI */
2981         { "DTC3520A Host Adapter BIOS", 0x318a, 26 },
2982                 /* DTC 3520A ISA SCSI */
2983 };
2984 #endif /* !SKIP_BIOSTEST */
2985
2986 /*
2987  * Test, if port_base is valid.
2988  *
2989  */
2990 static int aha152x_porttest(int io_port)
2991 {
2992         int i;
2993
2994         SETPORT(io_port + O_DMACNTRL1, 0);      /* reset stack pointer */
2995         for (i = 0; i < 16; i++)
2996                 SETPORT(io_port + O_STACK, i);
2997
2998         SETPORT(io_port + O_DMACNTRL1, 0);      /* reset stack pointer */
2999         for (i = 0; i < 16 && GETPORT(io_port + O_STACK) == i; i++)
3000                 ;
3001
3002         return (i == 16);
3003 }
3004
3005 static int tc1550_porttest(int io_port)
3006 {
3007         int i;
3008
3009         SETPORT(io_port + O_TC_DMACNTRL1, 0);   /* reset stack pointer */
3010         for (i = 0; i < 16; i++)
3011                 SETPORT(io_port + O_STACK, i);
3012
3013         SETPORT(io_port + O_TC_DMACNTRL1, 0);   /* reset stack pointer */
3014         for (i = 0; i < 16 && GETPORT(io_port + O_TC_STACK) == i; i++)
3015                 ;
3016
3017         return (i == 16);
3018 }
3019
3020
3021 static int checksetup(struct aha152x_setup *setup)
3022 {
3023         int i;
3024         for (i = 0; i < ARRAY_SIZE(ports) && (setup->io_port != ports[i]); i++)
3025                 ;
3026
3027         if (i == ARRAY_SIZE(ports))
3028                 return 0;
3029
3030         if (!request_region(setup->io_port, IO_RANGE, "aha152x")) {
3031                 printk(KERN_ERR "aha152x: io port 0x%x busy.\n", setup->io_port);
3032                 return 0;
3033         }
3034
3035         if( aha152x_porttest(setup->io_port) ) {
3036                 setup->tc1550=0;
3037         } else if( tc1550_porttest(setup->io_port) ) {
3038                 setup->tc1550=1;
3039         } else {
3040                 release_region(setup->io_port, IO_RANGE);
3041                 return 0;
3042         }
3043
3044         release_region(setup->io_port, IO_RANGE);
3045
3046         if ((setup->irq < IRQ_MIN) || (setup->irq > IRQ_MAX))
3047                 return 0;
3048
3049         if ((setup->scsiid < 0) || (setup->scsiid > 7))
3050                 return 0;
3051
3052         if ((setup->reconnect < 0) || (setup->reconnect > 1))
3053                 return 0;
3054
3055         if ((setup->parity < 0) || (setup->parity > 1))
3056                 return 0;
3057
3058         if ((setup->synchronous < 0) || (setup->synchronous > 1))
3059                 return 0;
3060
3061         if ((setup->ext_trans < 0) || (setup->ext_trans > 1))
3062                 return 0;
3063
3064
3065         return 1;
3066 }
3067
3068
3069 static int __init aha152x_init(void)
3070 {
3071         int i, j, ok;
3072 #if defined(AUTOCONF)
3073         aha152x_config conf;
3074 #endif
3075 #ifdef __ISAPNP__
3076         struct pnp_dev *dev=NULL, *pnpdev[2] = {NULL, NULL};
3077 #endif
3078
3079         if ( setup_count ) {
3080                 printk(KERN_INFO "aha152x: processing commandline: ");
3081
3082                 for (i = 0; i<setup_count; i++) {
3083                         if (!checksetup(&setup[i])) {
3084                                 printk(KERN_ERR "\naha152x: %s\n", setup[i].conf);
3085                                 printk(KERN_ERR "aha152x: invalid line\n");
3086                         }
3087                 }
3088                 printk("ok\n");
3089         }
3090
3091 #if defined(SETUP0)
3092         if (setup_count < ARRAY_SIZE(setup)) {
3093                 struct aha152x_setup override = SETUP0;
3094
3095                 if (setup_count == 0 || (override.io_port != setup[0].io_port)) {
3096                         if (!checksetup(&override)) {
3097                                 printk(KERN_ERR "\naha152x: invalid override SETUP0={0x%x,%d,%d,%d,%d,%d,%d,%d}\n",
3098                                        override.io_port,
3099                                        override.irq,
3100                                        override.scsiid,
3101                                        override.reconnect,
3102                                        override.parity,
3103                                        override.synchronous,
3104                                        override.delay,
3105                                        override.ext_trans);
3106                         } else
3107                                 setup[setup_count++] = override;
3108                 }
3109         }
3110 #endif
3111
3112 #if defined(SETUP1)
3113         if (setup_count < ARRAY_SIZE(setup)) {
3114                 struct aha152x_setup override = SETUP1;
3115
3116                 if (setup_count == 0 || (override.io_port != setup[0].io_port)) {
3117                         if (!checksetup(&override)) {
3118                                 printk(KERN_ERR "\naha152x: invalid override SETUP1={0x%x,%d,%d,%d,%d,%d,%d,%d}\n",
3119                                        override.io_port,
3120                                        override.irq,
3121                                        override.scsiid,
3122                                        override.reconnect,
3123                                        override.parity,
3124                                        override.synchronous,
3125                                        override.delay,
3126                                        override.ext_trans);
3127                         } else
3128                                 setup[setup_count++] = override;
3129                 }
3130         }
3131 #endif
3132
3133 #if defined(MODULE)
3134         if (setup_count<ARRAY_SIZE(setup) && (aha152x[0]!=0 || io[0]!=0 || irq[0]!=0)) {
3135                 if(aha152x[0]!=0) {
3136                         setup[setup_count].conf        = "";
3137                         setup[setup_count].io_port     = aha152x[0];
3138                         setup[setup_count].irq         = aha152x[1];
3139                         setup[setup_count].scsiid      = aha152x[2];
3140                         setup[setup_count].reconnect   = aha152x[3];
3141                         setup[setup_count].parity      = aha152x[4];
3142                         setup[setup_count].synchronous = aha152x[5];
3143                         setup[setup_count].delay       = aha152x[6];
3144                         setup[setup_count].ext_trans   = aha152x[7];
3145                 } else if (io[0] != 0 || irq[0] != 0) {
3146                         if(io[0]!=0)  setup[setup_count].io_port = io[0];
3147                         if(irq[0]!=0) setup[setup_count].irq     = irq[0];
3148
3149                         setup[setup_count].scsiid      = scsiid[0];
3150                         setup[setup_count].reconnect   = reconnect[0];
3151                         setup[setup_count].parity      = parity[0];
3152                         setup[setup_count].synchronous = sync[0];
3153                         setup[setup_count].delay       = delay[0];
3154                         setup[setup_count].ext_trans   = exttrans[0];
3155                 }
3156
3157                 if (checksetup(&setup[setup_count]))
3158                         setup_count++;
3159                 else
3160                         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",
3161                                setup[setup_count].io_port,
3162                                setup[setup_count].irq,
3163                                setup[setup_count].scsiid,
3164                                setup[setup_count].reconnect,
3165                                setup[setup_count].parity,
3166                                setup[setup_count].synchronous,
3167                                setup[setup_count].delay,
3168                                setup[setup_count].ext_trans);
3169         }
3170
3171         if (setup_count<ARRAY_SIZE(setup) && (aha152x1[0]!=0 || io[1]!=0 || irq[1]!=0)) {
3172                 if(aha152x1[0]!=0) {
3173                         setup[setup_count].conf        = "";
3174                         setup[setup_count].io_port     = aha152x1[0];
3175                         setup[setup_count].irq         = aha152x1[1];
3176                         setup[setup_count].scsiid      = aha152x1[2];
3177                         setup[setup_count].reconnect   = aha152x1[3];
3178                         setup[setup_count].parity      = aha152x1[4];
3179                         setup[setup_count].synchronous = aha152x1[5];
3180                         setup[setup_count].delay       = aha152x1[6];
3181                         setup[setup_count].ext_trans   = aha152x1[7];
3182                 } else if (io[1] != 0 || irq[1] != 0) {
3183                         if(io[1]!=0)  setup[setup_count].io_port = io[1];
3184                         if(irq[1]!=0) setup[setup_count].irq     = irq[1];
3185
3186                         setup[setup_count].scsiid      = scsiid[1];
3187                         setup[setup_count].reconnect   = reconnect[1];
3188                         setup[setup_count].parity      = parity[1];
3189                         setup[setup_count].synchronous = sync[1];
3190                         setup[setup_count].delay       = delay[1];
3191                         setup[setup_count].ext_trans   = exttrans[1];
3192                 }
3193                 if (checksetup(&setup[setup_count]))
3194                         setup_count++;
3195                 else
3196                         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",
3197                                setup[setup_count].io_port,
3198                                setup[setup_count].irq,
3199                                setup[setup_count].scsiid,
3200                                setup[setup_count].reconnect,
3201                                setup[setup_count].parity,
3202                                setup[setup_count].synchronous,
3203                                setup[setup_count].delay,
3204                                setup[setup_count].ext_trans);
3205         }
3206 #endif
3207
3208 #ifdef __ISAPNP__
3209         for(i=0; setup_count<ARRAY_SIZE(setup) && id_table[i].vendor; i++) {
3210                 while ( setup_count<ARRAY_SIZE(setup) &&
3211                         (dev=pnp_find_dev(NULL, id_table[i].vendor, id_table[i].function, dev)) ) {
3212                         if (pnp_device_attach(dev) < 0)
3213                                 continue;
3214
3215                         if (pnp_activate_dev(dev) < 0) {
3216                                 pnp_device_detach(dev);
3217                                 continue;
3218                         }
3219
3220                         if (!pnp_port_valid(dev, 0)) {
3221                                 pnp_device_detach(dev);
3222                                 continue;
3223                         }
3224
3225                         if (setup_count==1 && pnp_port_start(dev, 0)==setup[0].io_port) {
3226                                 pnp_device_detach(dev);
3227                                 continue;
3228                         }
3229
3230                         setup[setup_count].io_port     = pnp_port_start(dev, 0);
3231                         setup[setup_count].irq         = pnp_irq(dev, 0);
3232                         setup[setup_count].scsiid      = 7;
3233                         setup[setup_count].reconnect   = 1;
3234                         setup[setup_count].parity      = 1;
3235                         setup[setup_count].synchronous = 1;
3236                         setup[setup_count].delay       = DELAY_DEFAULT;
3237                         setup[setup_count].ext_trans   = 0;
3238 #if defined(__ISAPNP__)
3239                         pnpdev[setup_count]            = dev;
3240 #endif
3241                         printk (KERN_INFO
3242                                 "aha152x: found ISAPnP adapter at io=0x%03x, irq=%d\n",
3243                                 setup[setup_count].io_port, setup[setup_count].irq);
3244                         setup_count++;
3245                 }
3246         }
3247 #endif
3248
3249 #if defined(AUTOCONF)
3250         if (setup_count<ARRAY_SIZE(setup)) {
3251 #if !defined(SKIP_BIOSTEST)
3252                 ok = 0;
3253                 for (i = 0; i < ARRAY_SIZE(addresses) && !ok; i++) {
3254                         void __iomem *p = ioremap(addresses[i], 0x4000);
3255                         if (!p)
3256                                 continue;
3257                         for (j = 0; j<ARRAY_SIZE(signatures) && !ok; j++)
3258                                 ok = check_signature(p + signatures[j].sig_offset,
3259                                                                 signatures[j].signature, signatures[j].sig_length);
3260                         iounmap(p);
3261                 }
3262                 if (!ok && setup_count == 0)
3263                         return -ENODEV;
3264
3265                 printk(KERN_INFO "aha152x: BIOS test: passed, ");
3266 #else
3267                 printk(KERN_INFO "aha152x: ");
3268 #endif                          /* !SKIP_BIOSTEST */
3269
3270                 ok = 0;
3271                 for (i = 0; i < ARRAY_SIZE(ports) && setup_count < 2; i++) {
3272                         if ((setup_count == 1) && (setup[0].io_port == ports[i]))
3273                                 continue;
3274
3275                         if (!request_region(ports[i], IO_RANGE, "aha152x")) {
3276                                 printk(KERN_ERR "aha152x: io port 0x%x busy.\n", ports[i]);
3277                                 continue;
3278                         }
3279
3280                         if (aha152x_porttest(ports[i])) {
3281                                 setup[setup_count].tc1550  = 0;
3282
3283                                 conf.cf_port =
3284                                     (GETPORT(ports[i] + O_PORTA) << 8) + GETPORT(ports[i] + O_PORTB);
3285                         } else if (tc1550_porttest(ports[i])) {
3286                                 setup[setup_count].tc1550  = 1;
3287
3288                                 conf.cf_port =
3289                                     (GETPORT(ports[i] + O_TC_PORTA) << 8) + GETPORT(ports[i] + O_TC_PORTB);
3290                         } else {
3291                                 release_region(ports[i], IO_RANGE);
3292                                 continue;
3293                         }
3294
3295                         release_region(ports[i], IO_RANGE);
3296
3297                         ok++;
3298                         setup[setup_count].io_port = ports[i];
3299                         setup[setup_count].irq = IRQ_MIN + conf.cf_irq;
3300                         setup[setup_count].scsiid = conf.cf_id;
3301                         setup[setup_count].reconnect = conf.cf_tardisc;
3302                         setup[setup_count].parity = !conf.cf_parity;
3303                         setup[setup_count].synchronous = conf.cf_syncneg;
3304                         setup[setup_count].delay = DELAY_DEFAULT;
3305                         setup[setup_count].ext_trans = 0;
3306                         setup_count++;
3307
3308                 }
3309
3310                 if (ok)
3311                         printk("auto configuration: ok, ");
3312         }
3313 #endif
3314
3315         printk("%d controller(s) configured\n", setup_count);
3316
3317         for (i=0; i<setup_count; i++) {
3318                 if ( request_region(setup[i].io_port, IO_RANGE, "aha152x") ) {
3319                         struct Scsi_Host *shpnt = aha152x_probe_one(&setup[i]);
3320
3321                         if( !shpnt ) {
3322                                 release_region(setup[i].io_port, IO_RANGE);
3323 #if defined(__ISAPNP__)
3324                         } else if( pnpdev[i] ) {
3325                                 HOSTDATA(shpnt)->pnpdev=pnpdev[i];
3326                                 pnpdev[i]=NULL;
3327 #endif
3328                         }
3329                 } else {
3330                         printk(KERN_ERR "aha152x: io port 0x%x busy.\n", setup[i].io_port);
3331                 }
3332
3333 #if defined(__ISAPNP__)
3334                 if( pnpdev[i] )
3335                         pnp_device_detach(pnpdev[i]);
3336 #endif
3337         }
3338
3339         return 0;
3340 }
3341
3342 static void __exit aha152x_exit(void)
3343 {
3344         struct aha152x_hostdata *hd, *tmp;
3345
3346         list_for_each_entry_safe(hd, tmp, &aha152x_host_list, host_list) {
3347                 struct Scsi_Host *shost = container_of((void *)hd, struct Scsi_Host, hostdata);
3348
3349                 aha152x_release(shost);
3350         }
3351 }
3352
3353 module_init(aha152x_init);
3354 module_exit(aha152x_exit);
3355
3356 #if !defined(MODULE)
3357 static int __init aha152x_setup(char *str)
3358 {
3359         int ints[10];
3360
3361         get_options(str, ARRAY_SIZE(ints), ints);
3362
3363         if(setup_count>=ARRAY_SIZE(setup)) {
3364                 printk(KERN_ERR "aha152x: you can only configure up to two controllers\n");
3365                 return 1;
3366         }
3367
3368         setup[setup_count].conf        = str;
3369         setup[setup_count].io_port     = ints[0] >= 1 ? ints[1] : 0x340;
3370         setup[setup_count].irq         = ints[0] >= 2 ? ints[2] : 11;
3371         setup[setup_count].scsiid      = ints[0] >= 3 ? ints[3] : 7;
3372         setup[setup_count].reconnect   = ints[0] >= 4 ? ints[4] : 1;
3373         setup[setup_count].parity      = ints[0] >= 5 ? ints[5] : 1;
3374         setup[setup_count].synchronous = ints[0] >= 6 ? ints[6] : 1;
3375         setup[setup_count].delay       = ints[0] >= 7 ? ints[7] : DELAY_DEFAULT;
3376         setup[setup_count].ext_trans   = ints[0] >= 8 ? ints[8] : 0;
3377         if (ints[0] > 8) {                                                /*}*/
3378                 printk(KERN_NOTICE "aha152x: usage: aha152x=<IOBASE>[,<IRQ>[,<SCSI ID>"
3379                        "[,<RECONNECT>[,<PARITY>[,<SYNCHRONOUS>[,<DELAY>[,<EXT_TRANS>]]]]]]]\n");
3380         } else {
3381                 setup_count++;
3382                 return 0;
3383         }
3384
3385         return 1;
3386 }
3387 __setup("aha152x=", aha152x_setup);
3388 #endif
3389
3390 #endif /* !PCMCIA */