drivers/scsi/aha152x.c

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