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