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.txt 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, int error);
 623
 624 /* diagnostics */
 625 static void show_command(struct scsi_cmnd * ptr);
 626 static void show_queues(struct Scsi_Host *shpnt);
 627 static void disp_enintr(struct Scsi_Host *shpnt);
 628
 629
 630 /*
 631  *  queue services:
 632  *
 633  */
 634 static inline void append_SC(struct scsi_cmnd **SC, struct scsi_cmnd *new_SC)
 635 {
 636         struct scsi_cmnd *end;
 637
 638         SCNEXT(new_SC) = NULL;
 639         if (!*SC)
 640                 *SC = new_SC;
 641         else {
 642                 for (end = *SC; SCNEXT(end); end = SCNEXT(end))
 643                         ;
 644                 SCNEXT(end) = new_SC;
 645         }
 646 }
 647
 648 static inline struct scsi_cmnd *remove_first_SC(struct scsi_cmnd ** SC)
 649 {
 650         struct scsi_cmnd *ptr;
 651
 652         ptr = *SC;
 653         if (ptr) {
 654                 *SC = SCNEXT(*SC);
 655                 SCNEXT(ptr)=NULL;
 656         }
 657         return ptr;
 658 }
 659
 660 static inline struct scsi_cmnd *remove_lun_SC(struct scsi_cmnd ** SC,
 661                                               int target, int lun)
 662 {
 663         struct scsi_cmnd *ptr, *prev;
 664
 665         for (ptr = *SC, prev = NULL;
 666              ptr && ((ptr->device->id != target) || (ptr->device->lun != lun));
 667              prev = ptr, ptr = SCNEXT(ptr))
 668              ;
 669
 670         if (ptr) {
 671                 if (prev)
 672                         SCNEXT(prev) = SCNEXT(ptr);
 673                 else
 674                         *SC = SCNEXT(ptr);
 675
 676                 SCNEXT(ptr)=NULL;
 677         }
 678
 679         return ptr;
 680 }
 681
 682 static inline struct scsi_cmnd *remove_SC(struct scsi_cmnd **SC,
 683                                           struct scsi_cmnd *SCp)
 684 {
 685         struct scsi_cmnd *ptr, *prev;
 686
 687         for (ptr = *SC, prev = NULL;
 688              ptr && SCp!=ptr;
 689              prev = ptr, ptr = SCNEXT(ptr))
 690              ;
 691
 692         if (ptr) {
 693                 if (prev)
 694                         SCNEXT(prev) = SCNEXT(ptr);
 695                 else
 696                         *SC = SCNEXT(ptr);
 697
 698                 SCNEXT(ptr)=NULL;
 699         }
 700
 701         return ptr;
 702 }
 703
 704 static irqreturn_t swintr(int irqno, void *dev_id)
 705 {
 706         struct Scsi_Host *shpnt = dev_id;
 707
 708         HOSTDATA(shpnt)->swint++;
 709
 710         SETPORT(DMACNTRL0, INTEN);
 711         return IRQ_HANDLED;
 712 }
 713
 714 struct Scsi_Host *aha152x_probe_one(struct aha152x_setup *setup)
 715 {
 716         struct Scsi_Host *shpnt;
 717
 718         shpnt = scsi_host_alloc(&aha152x_driver_template, sizeof(struct aha152x_hostdata));
 719         if (!shpnt) {
 720                 printk(KERN_ERR "aha152x: scsi_host_alloc failed\n");
 721                 return NULL;
 722         }
 723
 724         memset(HOSTDATA(shpnt), 0, sizeof *HOSTDATA(shpnt));
 725         INIT_LIST_HEAD(&HOSTDATA(shpnt)->host_list);
 726
 727         /* need to have host registered before triggering any interrupt */
 728         list_add_tail(&HOSTDATA(shpnt)->host_list, &aha152x_host_list);
 729
 730         shpnt->io_port   = setup->io_port;
 731         shpnt->n_io_port = IO_RANGE;
 732         shpnt->irq       = setup->irq;
 733
 734         if (!setup->tc1550) {
 735                 HOSTIOPORT0 = setup->io_port;
 736                 HOSTIOPORT1 = setup->io_port;
 737         } else {
 738                 HOSTIOPORT0 = setup->io_port+0x10;
 739                 HOSTIOPORT1 = setup->io_port-0x10;
 740         }
 741
 742         spin_lock_init(&QLOCK);
 743         RECONNECT   = setup->reconnect;
 744         SYNCHRONOUS = setup->synchronous;
 745         PARITY      = setup->parity;
 746         DELAY       = setup->delay;
 747         EXT_TRANS   = setup->ext_trans;
 748
 749         SETPORT(SCSIID, setup->scsiid << 4);
 750         shpnt->this_id = setup->scsiid;
 751
 752         if (setup->reconnect)
 753                 shpnt->can_queue = AHA152X_MAXQUEUE;
 754
 755         /* RESET OUT */
 756         printk("aha152x: resetting bus...\n");
 757         SETPORT(SCSISEQ, SCSIRSTO);
 758         mdelay(256);
 759         SETPORT(SCSISEQ, 0);
 760         mdelay(DELAY);
 761
 762         reset_ports(shpnt);
 763
 764         printk(KERN_INFO
 765                "aha152x%d%s: "
 766                "vital data: rev=%x, "
 767                "io=0x%03lx (0x%03lx/0x%03lx), "
 768                "irq=%d, "
 769                "scsiid=%d, "
 770                "reconnect=%s, "
 771                "parity=%s, "
 772                "synchronous=%s, "
 773                "delay=%d, "
 774                "extended translation=%s\n",
 775                shpnt->host_no, setup->tc1550 ? " (tc1550 mode)" : "",
 776                GETPORT(REV) & 0x7,
 777                shpnt->io_port, HOSTIOPORT0, HOSTIOPORT1,
 778                shpnt->irq,
 779                shpnt->this_id,
 780                RECONNECT ? "enabled" : "disabled",
 781                PARITY ? "enabled" : "disabled",
 782                SYNCHRONOUS ? "enabled" : "disabled",
 783                DELAY,
 784                EXT_TRANS ? "enabled" : "disabled");
 785
 786         /* not expecting any interrupts */
 787         SETPORT(SIMODE0, 0);
 788         SETPORT(SIMODE1, 0);
 789
 790         if (request_irq(shpnt->irq, swintr, IRQF_SHARED, "aha152x", shpnt)) {
 791                 printk(KERN_ERR "aha152x%d: irq %d busy.\n", shpnt->host_no, shpnt->irq);
 792                 goto out_host_put;
 793         }
 794
 795         HOSTDATA(shpnt)->swint = 0;
 796
 797         printk(KERN_INFO "aha152x%d: trying software interrupt, ", shpnt->host_no);
 798
 799         mb();
 800         SETPORT(DMACNTRL0, SWINT|INTEN);
 801         mdelay(1000);
 802         free_irq(shpnt->irq, shpnt);
 803
 804         if (!HOSTDATA(shpnt)->swint) {
 805                 if (TESTHI(DMASTAT, INTSTAT)) {
 806                         printk("lost.\n");
 807                 } else {
 808                         printk("failed.\n");
 809                 }
 810
 811                 SETPORT(DMACNTRL0, INTEN);
 812
 813                 printk(KERN_ERR "aha152x%d: irq %d possibly wrong.  "
 814                                 "Please verify.\n", shpnt->host_no, shpnt->irq);
 815                 goto out_host_put;
 816         }
 817         printk("ok.\n");
 818
 819
 820         /* clear interrupts */
 821         SETPORT(SSTAT0, 0x7f);
 822         SETPORT(SSTAT1, 0xef);
 823
 824         if (request_irq(shpnt->irq, intr, IRQF_SHARED, "aha152x", shpnt)) {
 825                 printk(KERN_ERR "aha152x%d: failed to reassign irq %d.\n", shpnt->host_no, shpnt->irq);
 826                 goto out_host_put;
 827         }
 828
 829         if( scsi_add_host(shpnt, NULL) ) {
 830                 free_irq(shpnt->irq, shpnt);
 831                 printk(KERN_ERR "aha152x%d: failed to add host.\n", shpnt->host_no);
 832                 goto out_host_put;
 833         }
 834
 835         scsi_scan_host(shpnt);
 836
 837         return shpnt;
 838
 839 out_host_put:
 840         list_del(&HOSTDATA(shpnt)->host_list);
 841         scsi_host_put(shpnt);
 842
 843         return NULL;
 844 }
 845
 846 void aha152x_release(struct Scsi_Host *shpnt)
 847 {
 848         if (!shpnt)
 849                 return;
 850
 851         scsi_remove_host(shpnt);
 852         if (shpnt->irq)
 853                 free_irq(shpnt->irq, shpnt);
 854
 855 #if !defined(AHA152X_PCMCIA)
 856         if (shpnt->io_port)
 857                 release_region(shpnt->io_port, IO_RANGE);
 858 #endif
 859
 860 #ifdef __ISAPNP__
 861         if (HOSTDATA(shpnt)->pnpdev)
 862                 pnp_device_detach(HOSTDATA(shpnt)->pnpdev);
 863 #endif
 864
 865         list_del(&HOSTDATA(shpnt)->host_list);
 866         scsi_host_put(shpnt);
 867 }
 868
 869
 870 /*
 871  * setup controller to generate interrupts depending
 872  * on current state (lock has to be acquired)
 873  *
 874  */
 875 static int setup_expected_interrupts(struct Scsi_Host *shpnt)
 876 {
 877         if(CURRENT_SC) {
 878                 CURRENT_SC->SCp.phase |= 1 << 16;
 879
 880                 if(CURRENT_SC->SCp.phase & selecting) {
 881                         SETPORT(SSTAT1, SELTO);
 882                         SETPORT(SIMODE0, ENSELDO | (DISCONNECTED_SC ? ENSELDI : 0));
 883                         SETPORT(SIMODE1, ENSELTIMO);
 884                 } else {
 885                         SETPORT(SIMODE0, (CURRENT_SC->SCp.phase & spiordy) ? ENSPIORDY : 0);
 886                         SETPORT(SIMODE1, ENPHASEMIS | ENSCSIRST | ENSCSIPERR | ENBUSFREE);
 887                 }
 888         } else if(STATE==seldi) {
 889                 SETPORT(SIMODE0, 0);
 890                 SETPORT(SIMODE1, ENPHASEMIS | ENSCSIRST | ENSCSIPERR | ENBUSFREE);
 891         } else {
 892                 SETPORT(SIMODE0, DISCONNECTED_SC ? ENSELDI : 0);
 893                 SETPORT(SIMODE1, ENSCSIRST | ( (ISSUE_SC||DONE_SC) ? ENBUSFREE : 0));
 894         }
 895
 896         if(!HOSTDATA(shpnt)->in_intr)
 897                 SETBITS(DMACNTRL0, INTEN);
 898
 899         return TESTHI(DMASTAT, INTSTAT);
 900 }
 901
 902
 903 /*
 904  *  Queue a command and setup interrupts for a free bus.
 905  */
 906 static int aha152x_internal_queue(struct scsi_cmnd *SCpnt,
 907                                   struct completion *complete,
 908                                   int phase, void (*done)(struct scsi_cmnd *))
 909 {
 910         struct Scsi_Host *shpnt = SCpnt->device->host;
 911         unsigned long flags;
 912
 913         SCpnt->scsi_done        = done;
 914         SCpnt->SCp.phase        = not_issued | phase;
 915         SCpnt->SCp.Status       = 0x1; /* Ilegal status by SCSI standard */
 916         SCpnt->SCp.Message      = 0;
 917         SCpnt->SCp.have_data_in = 0;
 918         SCpnt->SCp.sent_command = 0;
 919
 920         if(SCpnt->SCp.phase & (resetting|check_condition)) {
 921                 if (!SCpnt->host_scribble || SCSEM(SCpnt) || SCNEXT(SCpnt)) {
 922                         scmd_printk(KERN_ERR, SCpnt, "cannot reuse command\n");
 923                         return FAILED;
 924                 }
 925         } else {
 926                 SCpnt->host_scribble = kmalloc(sizeof(struct aha152x_scdata), GFP_ATOMIC);
 927                 if(!SCpnt->host_scribble) {
 928                         scmd_printk(KERN_ERR, SCpnt, "allocation failed\n");
 929                         return FAILED;
 930                 }
 931         }
 932
 933         SCNEXT(SCpnt)           = NULL;
 934         SCSEM(SCpnt)            = complete;
 935
 936         /* setup scratch area
 937            SCp.ptr              : buffer pointer
 938            SCp.this_residual    : buffer length
 939            SCp.buffer           : next buffer
 940            SCp.buffers_residual : left buffers in list
 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                 SCpnt->SCp.buffers_residual = 0;
 949         } else {
 950                 scsi_set_resid(SCpnt, scsi_bufflen(SCpnt));
 951                 SCpnt->SCp.buffer           = scsi_sglist(SCpnt);
 952                 SCpnt->SCp.ptr              = SG_ADDRESS(SCpnt->SCp.buffer);
 953                 SCpnt->SCp.this_residual    = SCpnt->SCp.buffer->length;
 954                 SCpnt->SCp.buffers_residual = scsi_sg_count(SCpnt) - 1;
 955         }
 956
 957         DO_LOCK(flags);
 958
 959 #if defined(AHA152X_STAT)
 960         HOSTDATA(shpnt)->total_commands++;
 961 #endif
 962
 963         /* Turn led on, when this is the first command. */
 964         HOSTDATA(shpnt)->commands++;
 965         if (HOSTDATA(shpnt)->commands==1)
 966                 SETPORT(PORTA, 1);
 967
 968         append_SC(&ISSUE_SC, SCpnt);
 969
 970         if(!HOSTDATA(shpnt)->in_intr)
 971                 setup_expected_interrupts(shpnt);
 972
 973         DO_UNLOCK(flags);
 974
 975         return 0;
 976 }
 977
 978 /*
 979  *  queue a command
 980  *
 981  */
 982 static int aha152x_queue_lck(struct scsi_cmnd *SCpnt,
 983                              void (*done)(struct scsi_cmnd *))
 984 {
 985         return aha152x_internal_queue(SCpnt, NULL, 0, done);
 986 }
 987
 988 static DEF_SCSI_QCMD(aha152x_queue)
 989
 990
 991 /*
 992  *
 993  */
 994 static void reset_done(struct scsi_cmnd *SCpnt)
 995 {
 996         if(SCSEM(SCpnt)) {
 997                 complete(SCSEM(SCpnt));
 998         } else {
 999                 printk(KERN_ERR "aha152x: reset_done w/o completion\n");
1000         }
1001 }
1002
1003 /*
1004  *  Abort a command
1005  *
1006  */
1007 static int aha152x_abort(struct scsi_cmnd *SCpnt)
1008 {
1009         struct Scsi_Host *shpnt = SCpnt->device->host;
1010         struct scsi_cmnd *ptr;
1011         unsigned long flags;
1012
1013         DO_LOCK(flags);
1014
1015         ptr=remove_SC(&ISSUE_SC, SCpnt);
1016
1017         if(ptr) {
1018                 HOSTDATA(shpnt)->commands--;
1019                 if (!HOSTDATA(shpnt)->commands)
1020                         SETPORT(PORTA, 0);
1021                 DO_UNLOCK(flags);
1022
1023                 kfree(SCpnt->host_scribble);
1024                 SCpnt->host_scribble=NULL;
1025
1026                 return SUCCESS;
1027         }
1028
1029         DO_UNLOCK(flags);
1030
1031         /*
1032          * FIXME:
1033          * for current command: queue ABORT for message out and raise ATN
1034          * for disconnected command: pseudo SC with ABORT message or ABORT on reselection?
1035          *
1036          */
1037
1038         scmd_printk(KERN_ERR, SCpnt,
1039                     "cannot abort running or disconnected command\n");
1040
1041         return FAILED;
1042 }
1043
1044 /*
1045  * Reset a device
1046  *
1047  */
1048 static int aha152x_device_reset(struct scsi_cmnd * SCpnt)
1049 {
1050         struct Scsi_Host *shpnt = SCpnt->device->host;
1051         DECLARE_COMPLETION(done);
1052         int ret, issued, disconnected;
1053         unsigned char old_cmd_len = SCpnt->cmd_len;
1054         unsigned long flags;
1055         unsigned long timeleft;
1056
1057         if(CURRENT_SC==SCpnt) {
1058                 scmd_printk(KERN_ERR, SCpnt, "cannot reset current device\n");
1059                 return FAILED;
1060         }
1061
1062         DO_LOCK(flags);
1063         issued       = remove_SC(&ISSUE_SC, SCpnt) == NULL;
1064         disconnected = issued && remove_SC(&DISCONNECTED_SC, SCpnt);
1065         DO_UNLOCK(flags);
1066
1067         SCpnt->cmd_len         = 0;
1068
1069         aha152x_internal_queue(SCpnt, &done, resetting, reset_done);
1070
1071         timeleft = wait_for_completion_timeout(&done, 100*HZ);
1072         if (!timeleft) {
1073                 /* remove command from issue queue */
1074                 DO_LOCK(flags);
1075                 remove_SC(&ISSUE_SC, SCpnt);
1076                 DO_UNLOCK(flags);
1077         }
1078
1079         SCpnt->cmd_len         = old_cmd_len;
1080
1081         DO_LOCK(flags);
1082
1083         if(SCpnt->SCp.phase & resetted) {
1084                 HOSTDATA(shpnt)->commands--;
1085                 if (!HOSTDATA(shpnt)->commands)
1086                         SETPORT(PORTA, 0);
1087                 kfree(SCpnt->host_scribble);
1088                 SCpnt->host_scribble=NULL;
1089
1090                 ret = SUCCESS;
1091         } else {
1092                 /* requeue */
1093                 if(!issued) {
1094                         append_SC(&ISSUE_SC, SCpnt);
1095                 } else if(disconnected) {
1096                         append_SC(&DISCONNECTED_SC, SCpnt);
1097                 }
1098
1099                 ret = FAILED;
1100         }
1101
1102         DO_UNLOCK(flags);
1103         return ret;
1104 }
1105
1106 static void free_hard_reset_SCs(struct Scsi_Host *shpnt,
1107                                 struct scsi_cmnd **SCs)
1108 {
1109         struct scsi_cmnd *ptr;
1110
1111         ptr=*SCs;
1112         while(ptr) {
1113                 struct scsi_cmnd *next;
1114
1115                 if(SCDATA(ptr)) {
1116                         next = SCNEXT(ptr);
1117                 } else {
1118                         scmd_printk(KERN_DEBUG, ptr,
1119                                     "queue corrupted at %p\n", ptr);
1120                         next = NULL;
1121                 }
1122
1123                 if (!ptr->device->soft_reset) {
1124                         remove_SC(SCs, ptr);
1125                         HOSTDATA(shpnt)->commands--;
1126                         kfree(ptr->host_scribble);
1127                         ptr->host_scribble=NULL;
1128                 }
1129
1130                 ptr = next;
1131         }
1132 }
1133
1134 /*
1135  * Reset the bus
1136  *
1137  * AIC-6260 has a hard reset (MRST signal), but apparently
1138  * one cannot trigger it via software. So live with
1139  * a soft reset; no-one seemed to have cared.
1140  */
1141 static int aha152x_bus_reset_host(struct Scsi_Host *shpnt)
1142 {
1143         unsigned long flags;
1144
1145         DO_LOCK(flags);
1146
1147         free_hard_reset_SCs(shpnt, &ISSUE_SC);
1148         free_hard_reset_SCs(shpnt, &DISCONNECTED_SC);
1149
1150         SETPORT(SCSISEQ, SCSIRSTO);
1151         mdelay(256);
1152         SETPORT(SCSISEQ, 0);
1153         mdelay(DELAY);
1154
1155         setup_expected_interrupts(shpnt);
1156         if(HOSTDATA(shpnt)->commands==0)
1157                 SETPORT(PORTA, 0);
1158
1159         DO_UNLOCK(flags);
1160
1161         return SUCCESS;
1162 }
1163
1164 /*
1165  * Reset the bus
1166  *
1167  */
1168 static int aha152x_bus_reset(struct scsi_cmnd *SCpnt)
1169 {
1170         return aha152x_bus_reset_host(SCpnt->device->host);
1171 }
1172
1173 /*
1174  *  Restore default values to the AIC-6260 registers and reset the fifos
1175  *
1176  */
1177 static void reset_ports(struct Scsi_Host *shpnt)
1178 {
1179         unsigned long flags;
1180
1181         /* disable interrupts */
1182         SETPORT(DMACNTRL0, RSTFIFO);
1183
1184         SETPORT(SCSISEQ, 0);
1185
1186         SETPORT(SXFRCTL1, 0);
1187         SETPORT(SCSISIG, 0);
1188         SETRATE(0);
1189
1190         /* clear all interrupt conditions */
1191         SETPORT(SSTAT0, 0x7f);
1192         SETPORT(SSTAT1, 0xef);
1193
1194         SETPORT(SSTAT4, SYNCERR | FWERR | FRERR);
1195
1196         SETPORT(DMACNTRL0, 0);
1197         SETPORT(DMACNTRL1, 0);
1198
1199         SETPORT(BRSTCNTRL, 0xf1);
1200
1201         /* clear SCSI fifos and transfer count */
1202         SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
1203         SETPORT(SXFRCTL0, CH1);
1204
1205         DO_LOCK(flags);
1206         setup_expected_interrupts(shpnt);
1207         DO_UNLOCK(flags);
1208 }
1209
1210 /*
1211  * Reset the host (bus and controller)
1212  *
1213  */
1214 int aha152x_host_reset_host(struct Scsi_Host *shpnt)
1215 {
1216         aha152x_bus_reset_host(shpnt);
1217         reset_ports(shpnt);
1218
1219         return SUCCESS;
1220 }
1221
1222 /*
1223  * Return the "logical geometry"
1224  *
1225  */
1226 static int aha152x_biosparam(struct scsi_device *sdev, struct block_device *bdev,
1227                 sector_t capacity, int *info_array)
1228 {
1229         struct Scsi_Host *shpnt = sdev->host;
1230
1231         /* try default translation */
1232         info_array[0] = 64;
1233         info_array[1] = 32;
1234         info_array[2] = (unsigned long)capacity / (64 * 32);
1235
1236         /* for disks >1GB do some guessing */
1237         if (info_array[2] >= 1024) {
1238                 int info[3];
1239
1240                 /* try to figure out the geometry from the partition table */
1241                 if (scsicam_bios_param(bdev, capacity, info) < 0 ||
1242                     !((info[0] == 64 && info[1] == 32) || (info[0] == 255 && info[1] == 63))) {
1243                         if (EXT_TRANS) {
1244                                 printk(KERN_NOTICE
1245                                        "aha152x: unable to verify geometry for disk with >1GB.\n"
1246                                        "         using extended translation.\n");
1247                                 info_array[0] = 255;
1248                                 info_array[1] = 63;
1249                                 info_array[2] = (unsigned long)capacity / (255 * 63);
1250                         } else {
1251                                 printk(KERN_NOTICE
1252                                        "aha152x: unable to verify geometry for disk with >1GB.\n"
1253                                        "         Using default translation. Please verify yourself.\n"
1254                                        "         Perhaps you need to enable extended translation in the driver.\n"
1255                                        "         See Documentation/scsi/aha152x.txt for details.\n");
1256                         }
1257                 } else {
1258                         info_array[0] = info[0];
1259                         info_array[1] = info[1];
1260                         info_array[2] = info[2];
1261
1262                         if (info[0] == 255 && !EXT_TRANS) {
1263                                 printk(KERN_NOTICE
1264                                        "aha152x: current partition table is using extended translation.\n"
1265                                        "         using it also, although it's not explicitly enabled.\n");
1266                         }
1267                 }
1268         }
1269
1270         return 0;
1271 }
1272
1273 /*
1274  *  Internal done function
1275  *
1276  */
1277 static void done(struct Scsi_Host *shpnt, int error)
1278 {
1279         if (CURRENT_SC) {
1280                 if(DONE_SC)
1281                         scmd_printk(KERN_ERR, CURRENT_SC,
1282                                     "there's already a completed command %p "
1283                                     "- will cause abort\n", DONE_SC);
1284
1285                 DONE_SC = CURRENT_SC;
1286                 CURRENT_SC = NULL;
1287                 DONE_SC->result = error;
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 & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_OK << 16));
1383
1384                 } else if(CURRENT_SC->SCp.phase & aborted) {
1385                         done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_ABORT << 16));
1386
1387                 } else if(CURRENT_SC->SCp.phase & resetted) {
1388                         done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_RESET << 16));
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, DID_ERROR << 16);
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, DID_NO_CONNECT << 16);
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, DID_ABORT << 16);
1559         else if (TESTLO(SSTAT0, SELINGO))
1560                 done(shpnt, DID_BUS_BUSY << 16);
1561         else
1562                 /* ARBITRATION won, but SELECTION failed */
1563                 done(shpnt, DID_NO_CONNECT << 16);
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, DID_ERROR << 16);
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                                     CURRENT_SC->SCp.buffers_residual > 0) {
2023                                         /* advance to next buffer */
2024                                         CURRENT_SC->SCp.buffers_residual--;
2025                                         CURRENT_SC->SCp.buffer++;
2026                                         CURRENT_SC->SCp.ptr           = SG_ADDRESS(CURRENT_SC->SCp.buffer);
2027                                         CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length;
2028                                 }
2029                         }
2030                 } else if (fifodata > 0) {
2031                         scmd_printk(KERN_ERR, CURRENT_SC,
2032                                     "no buffers left for %d(%d) bytes"
2033                                     " (data overrun!?)\n",
2034                                     fifodata, GETPORT(FIFOSTAT));
2035                         SETPORT(DMACNTRL0, ENDMA|_8BIT);
2036                         while(fifodata>0) {
2037                                 int data;
2038                                 data=GETPORT(DATAPORT);
2039                                 fifodata--;
2040                                 DATA_LEN++;
2041                         }
2042                         SETPORT(DMACNTRL0, ENDMA|_8BIT);
2043                 }
2044         }
2045
2046         if(TESTLO(DMASTAT, INTSTAT) ||
2047            TESTLO(DMASTAT, DFIFOEMP) ||
2048            TESTLO(SSTAT2, SEMPTY) ||
2049            GETPORT(FIFOSTAT)>0) {
2050                 /*
2051                  * something went wrong, if there's something left in the fifos
2052                  * or the phase didn't change
2053                  */
2054                 scmd_printk(KERN_ERR, CURRENT_SC,
2055                             "fifos should be empty and phase should have changed\n");
2056         }
2057
2058         if(DATA_LEN!=GETSTCNT()) {
2059                 scmd_printk(KERN_ERR, CURRENT_SC,
2060                             "manual transfer count differs from automatic "
2061                             "(count=%d;stcnt=%d;diff=%d;fifostat=%d)",
2062                             DATA_LEN, GETSTCNT(), GETSTCNT()-DATA_LEN,
2063                             GETPORT(FIFOSTAT));
2064                 mdelay(10000);
2065         }
2066 }
2067
2068 static void datai_end(struct Scsi_Host *shpnt)
2069 {
2070         CMD_INC_RESID(CURRENT_SC, -GETSTCNT());
2071
2072         SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2073         SETPORT(DMACNTRL0, 0);
2074 }
2075
2076 /*
2077  * data out phase
2078  *
2079  */
2080 static void datao_init(struct Scsi_Host *shpnt)
2081 {
2082         SETPORT(DMACNTRL0, WRITE_READ | RSTFIFO);
2083         SETPORT(DMACNTRL0, WRITE_READ | ENDMA);
2084
2085         SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2086         SETPORT(SXFRCTL0, CH1|SCSIEN|DMAEN);
2087
2088         SETPORT(SIMODE0, 0);
2089         SETPORT(SIMODE1, ENSCSIPERR | ENSCSIRST | ENPHASEMIS | ENBUSFREE );
2090
2091         DATA_LEN = scsi_get_resid(CURRENT_SC);
2092 }
2093
2094 static void datao_run(struct Scsi_Host *shpnt)
2095 {
2096         unsigned long the_time;
2097         int data_count;
2098
2099         /* until phase changes or all data sent */
2100         while(TESTLO(DMASTAT, INTSTAT) && CURRENT_SC->SCp.this_residual>0) {
2101                 data_count = 128;
2102                 if(data_count > CURRENT_SC->SCp.this_residual)
2103                         data_count=CURRENT_SC->SCp.this_residual;
2104
2105                 if(TESTLO(DMASTAT, DFIFOEMP)) {
2106                         scmd_printk(KERN_ERR, CURRENT_SC,
2107                                     "datao fifo not empty (%d)",
2108                                     GETPORT(FIFOSTAT));
2109                         break;
2110                 }
2111
2112                 if(data_count & 1) {
2113                         SETPORT(DMACNTRL0,WRITE_READ|ENDMA|_8BIT);
2114                         SETPORT(DATAPORT, *CURRENT_SC->SCp.ptr++);
2115                         CURRENT_SC->SCp.this_residual--;
2116                         CMD_INC_RESID(CURRENT_SC, -1);
2117                         SETPORT(DMACNTRL0,WRITE_READ|ENDMA);
2118                 }
2119
2120                 if(data_count > 1) {
2121                         data_count >>= 1;
2122                         outsw(DATAPORT, CURRENT_SC->SCp.ptr, data_count);
2123                         CURRENT_SC->SCp.ptr           += 2 * data_count;
2124                         CURRENT_SC->SCp.this_residual -= 2 * data_count;
2125                         CMD_INC_RESID(CURRENT_SC, -2 * data_count);
2126                 }
2127
2128                 if(CURRENT_SC->SCp.this_residual==0 && CURRENT_SC->SCp.buffers_residual>0) {
2129                         /* advance to next buffer */
2130                         CURRENT_SC->SCp.buffers_residual--;
2131                         CURRENT_SC->SCp.buffer++;
2132                         CURRENT_SC->SCp.ptr           = SG_ADDRESS(CURRENT_SC->SCp.buffer);
2133                         CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length;
2134                 }
2135
2136                 the_time=jiffies + 100*HZ;
2137                 while(TESTLO(DMASTAT, DFIFOEMP|INTSTAT) && time_before(jiffies,the_time))
2138                         barrier();
2139
2140                 if(TESTLO(DMASTAT, DFIFOEMP|INTSTAT)) {
2141                         scmd_printk(KERN_ERR, CURRENT_SC, "dataout timeout\n");
2142                         break;
2143                 }
2144         }
2145 }
2146
2147 static void datao_end(struct Scsi_Host *shpnt)
2148 {
2149         if(TESTLO(DMASTAT, DFIFOEMP)) {
2150                 int data_count = (DATA_LEN - scsi_get_resid(CURRENT_SC)) -
2151                         GETSTCNT();
2152
2153                 CMD_INC_RESID(CURRENT_SC, data_count);
2154
2155                 data_count -= CURRENT_SC->SCp.ptr -
2156                         SG_ADDRESS(CURRENT_SC->SCp.buffer);
2157                 while(data_count>0) {
2158                         CURRENT_SC->SCp.buffer--;
2159                         CURRENT_SC->SCp.buffers_residual++;
2160                         data_count -= CURRENT_SC->SCp.buffer->length;
2161                 }
2162                 CURRENT_SC->SCp.ptr = SG_ADDRESS(CURRENT_SC->SCp.buffer) -
2163                         data_count;
2164                 CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length +
2165                         data_count;
2166         }
2167
2168         SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
2169         SETPORT(SXFRCTL0, CH1);
2170
2171         SETPORT(DMACNTRL0, 0);
2172 }
2173
2174 /*
2175  * figure out what state we're in
2176  *
2177  */
2178 static int update_state(struct Scsi_Host *shpnt)
2179 {
2180         int dataphase=0;
2181         unsigned int stat0 = GETPORT(SSTAT0);
2182         unsigned int stat1 = GETPORT(SSTAT1);
2183
2184         PREVSTATE = STATE;
2185         STATE=unknown;
2186
2187         if(stat1 & SCSIRSTI) {
2188                 STATE=rsti;
2189                 SETPORT(SCSISEQ,0);
2190                 SETPORT(SSTAT1,SCSIRSTI);
2191         } else if (stat0 & SELDI && PREVSTATE == busfree) {
2192                 STATE=seldi;
2193         } else if(stat0 & SELDO && CURRENT_SC && (CURRENT_SC->SCp.phase & selecting)) {
2194                 STATE=seldo;
2195         } else if(stat1 & SELTO) {
2196                 STATE=selto;
2197         } else if(stat1 & BUSFREE) {
2198                 STATE=busfree;
2199                 SETPORT(SSTAT1,BUSFREE);
2200         } else if(stat1 & SCSIPERR) {
2201                 STATE=parerr;
2202                 SETPORT(SSTAT1,SCSIPERR);
2203         } else if(stat1 & REQINIT) {
2204                 switch(GETPORT(SCSISIG) & P_MASK) {
2205                 case P_MSGI:    STATE=msgi;     break;
2206                 case P_MSGO:    STATE=msgo;     break;
2207                 case P_DATAO:   STATE=datao;    break;
2208                 case P_DATAI:   STATE=datai;    break;
2209                 case P_STATUS:  STATE=status;   break;
2210                 case P_CMD:     STATE=cmd;      break;
2211                 }
2212                 dataphase=1;
2213         }
2214
2215         if((stat0 & SELDI) && STATE!=seldi && !dataphase) {
2216                 scmd_printk(KERN_INFO, CURRENT_SC, "reselection missed?");
2217         }
2218
2219         if(STATE!=PREVSTATE) {
2220                 LASTSTATE=PREVSTATE;
2221         }
2222
2223         return dataphase;
2224 }
2225
2226 /*
2227  * handle parity error
2228  *
2229  * FIXME: in which phase?
2230  *
2231  */
2232 static void parerr_run(struct Scsi_Host *shpnt)
2233 {
2234         scmd_printk(KERN_ERR, CURRENT_SC, "parity error\n");
2235         done(shpnt, DID_PARITY << 16);
2236 }
2237
2238 /*
2239  * handle reset in
2240  *
2241  */
2242 static void rsti_run(struct Scsi_Host *shpnt)
2243 {
2244         struct scsi_cmnd *ptr;
2245
2246         shost_printk(KERN_NOTICE, shpnt, "scsi reset in\n");
2247
2248         ptr=DISCONNECTED_SC;
2249         while(ptr) {
2250                 struct scsi_cmnd *next = SCNEXT(ptr);
2251
2252                 if (!ptr->device->soft_reset) {
2253                         remove_SC(&DISCONNECTED_SC, ptr);
2254
2255                         kfree(ptr->host_scribble);
2256                         ptr->host_scribble=NULL;
2257
2258                         ptr->result =  DID_RESET << 16;
2259                         ptr->scsi_done(ptr);
2260                 }
2261
2262                 ptr = next;
2263         }
2264
2265         if(CURRENT_SC && !CURRENT_SC->device->soft_reset)
2266                 done(shpnt, DID_RESET << 16 );
2267 }
2268
2269
2270 /*
2271  * bottom-half handler
2272  *
2273  */
2274 static void is_complete(struct Scsi_Host *shpnt)
2275 {
2276         int dataphase;
2277         unsigned long flags;
2278         int pending;
2279
2280         if(!shpnt)
2281                 return;
2282
2283         DO_LOCK(flags);
2284
2285         if( HOSTDATA(shpnt)->service==0 )  {
2286                 DO_UNLOCK(flags);
2287                 return;
2288         }
2289
2290         HOSTDATA(shpnt)->service = 0;
2291
2292         if(HOSTDATA(shpnt)->in_intr) {
2293                 DO_UNLOCK(flags);
2294                 /* aha152x_error never returns.. */
2295                 aha152x_error(shpnt, "bottom-half already running!?");
2296         }
2297         HOSTDATA(shpnt)->in_intr++;
2298
2299         /*
2300          * loop while there are interrupt conditions pending
2301          *
2302          */
2303         do {
2304                 unsigned long start = jiffies;
2305                 DO_UNLOCK(flags);
2306
2307                 dataphase=update_state(shpnt);
2308
2309                 /*
2310                  * end previous state
2311                  *
2312                  */
2313                 if(PREVSTATE!=STATE && states[PREVSTATE].end)
2314                         states[PREVSTATE].end(shpnt);
2315
2316                 /*
2317                  * disable SPIO mode if previous phase used it
2318                  * and this one doesn't
2319                  *
2320                  */
2321                 if(states[PREVSTATE].spio && !states[STATE].spio) {
2322                         SETPORT(SXFRCTL0, CH1);
2323                         SETPORT(DMACNTRL0, 0);
2324                         if(CURRENT_SC)
2325                                 CURRENT_SC->SCp.phase &= ~spiordy;
2326                 }
2327
2328                 /*
2329                  * accept current dataphase phase
2330                  *
2331                  */
2332                 if(dataphase) {
2333                         SETPORT(SSTAT0, REQINIT);
2334                         SETPORT(SCSISIG, GETPORT(SCSISIG) & P_MASK);
2335                         SETPORT(SSTAT1, PHASECHG);
2336                 }
2337
2338                 /*
2339                  * enable SPIO mode if previous didn't use it
2340                  * and this one does
2341                  *
2342                  */
2343                 if(!states[PREVSTATE].spio && states[STATE].spio) {
2344                         SETPORT(DMACNTRL0, 0);
2345                         SETPORT(SXFRCTL0, CH1|SPIOEN);
2346                         if(CURRENT_SC)
2347                                 CURRENT_SC->SCp.phase |= spiordy;
2348                 }
2349
2350                 /*
2351                  * initialize for new state
2352                  *
2353                  */
2354                 if(PREVSTATE!=STATE && states[STATE].init)
2355                         states[STATE].init(shpnt);
2356
2357                 /*
2358                  * handle current state
2359                  *
2360                  */
2361                 if(states[STATE].run)
2362                         states[STATE].run(shpnt);
2363                 else
2364                         scmd_printk(KERN_ERR, CURRENT_SC,
2365                                     "unexpected state (%x)\n", STATE);
2366
2367                 /*
2368                  * setup controller to interrupt on
2369                  * the next expected condition and
2370                  * loop if it's already there
2371                  *
2372                  */
2373                 DO_LOCK(flags);
2374                 pending=setup_expected_interrupts(shpnt);
2375 #if defined(AHA152X_STAT)
2376                 HOSTDATA(shpnt)->count[STATE]++;
2377                 if(PREVSTATE!=STATE)
2378                         HOSTDATA(shpnt)->count_trans[STATE]++;
2379                 HOSTDATA(shpnt)->time[STATE] += jiffies-start;
2380 #endif
2381
2382         } while(pending);
2383
2384         /*
2385          * enable interrupts and leave bottom-half
2386          *
2387          */
2388         HOSTDATA(shpnt)->in_intr--;
2389         SETBITS(DMACNTRL0, INTEN);
2390         DO_UNLOCK(flags);
2391 }
2392
2393
2394 /*
2395  * Dump the current driver status and panic
2396  */
2397 static void aha152x_error(struct Scsi_Host *shpnt, char *msg)
2398 {
2399         shost_printk(KERN_EMERG, shpnt, "%s\n", msg);
2400         show_queues(shpnt);
2401         panic("aha152x panic\n");
2402 }
2403
2404 /*
2405  * display enabled interrupts
2406  */
2407 static void disp_enintr(struct Scsi_Host *shpnt)
2408 {
2409         int s0, s1;
2410
2411         s0 = GETPORT(SIMODE0);
2412         s1 = GETPORT(SIMODE1);
2413
2414         shost_printk(KERN_DEBUG, shpnt,
2415                      "enabled interrupts (%s%s%s%s%s%s%s%s%s%s%s%s%s%s)\n",
2416                      (s0 & ENSELDO) ? "ENSELDO " : "",
2417                      (s0 & ENSELDI) ? "ENSELDI " : "",
2418                      (s0 & ENSELINGO) ? "ENSELINGO " : "",
2419                      (s0 & ENSWRAP) ? "ENSWRAP " : "",
2420                      (s0 & ENSDONE) ? "ENSDONE " : "",
2421                      (s0 & ENSPIORDY) ? "ENSPIORDY " : "",
2422                      (s0 & ENDMADONE) ? "ENDMADONE " : "",
2423                      (s1 & ENSELTIMO) ? "ENSELTIMO " : "",
2424                      (s1 & ENATNTARG) ? "ENATNTARG " : "",
2425                      (s1 & ENPHASEMIS) ? "ENPHASEMIS " : "",
2426                      (s1 & ENBUSFREE) ? "ENBUSFREE " : "",
2427                      (s1 & ENSCSIPERR) ? "ENSCSIPERR " : "",
2428                      (s1 & ENPHASECHG) ? "ENPHASECHG " : "",
2429                      (s1 & ENREQINIT) ? "ENREQINIT " : "");
2430 }
2431
2432 /*
2433  * Show the command data of a command
2434  */
2435 static void show_command(struct scsi_cmnd *ptr)
2436 {
2437         scsi_print_command(ptr);
2438         scmd_printk(KERN_DEBUG, ptr,
2439                     "request_bufflen=%d; resid=%d; "
2440                     "phase |%s%s%s%s%s%s%s%s%s; next=0x%p",
2441                     scsi_bufflen(ptr), scsi_get_resid(ptr),
2442                     (ptr->SCp.phase & not_issued) ? "not issued|" : "",
2443                     (ptr->SCp.phase & selecting) ? "selecting|" : "",
2444                     (ptr->SCp.phase & identified) ? "identified|" : "",
2445                     (ptr->SCp.phase & disconnected) ? "disconnected|" : "",
2446                     (ptr->SCp.phase & completed) ? "completed|" : "",
2447                     (ptr->SCp.phase & spiordy) ? "spiordy|" : "",
2448                     (ptr->SCp.phase & syncneg) ? "syncneg|" : "",
2449                     (ptr->SCp.phase & aborted) ? "aborted|" : "",
2450                     (ptr->SCp.phase & resetted) ? "resetted|" : "",
2451                     (SCDATA(ptr)) ? SCNEXT(ptr) : NULL);
2452 }
2453
2454 /*
2455  * Dump the queued data
2456  */
2457 static void show_queues(struct Scsi_Host *shpnt)
2458 {
2459         struct scsi_cmnd *ptr;
2460         unsigned long flags;
2461
2462         DO_LOCK(flags);
2463         printk(KERN_DEBUG "\nqueue status:\nissue_SC:\n");
2464         for (ptr = ISSUE_SC; ptr; ptr = SCNEXT(ptr))
2465                 show_command(ptr);
2466         DO_UNLOCK(flags);
2467
2468         printk(KERN_DEBUG "current_SC:\n");
2469         if (CURRENT_SC)
2470                 show_command(CURRENT_SC);
2471         else
2472                 printk(KERN_DEBUG "none\n");
2473
2474         printk(KERN_DEBUG "disconnected_SC:\n");
2475         for (ptr = DISCONNECTED_SC; ptr; ptr = SCDATA(ptr) ? SCNEXT(ptr) : NULL)
2476                 show_command(ptr);
2477
2478         disp_enintr(shpnt);
2479 }
2480
2481 static void get_command(struct seq_file *m, struct scsi_cmnd * ptr)
2482 {
2483         int i;
2484
2485         seq_printf(m, "%p: target=%d; lun=%d; cmnd=( ",
2486                 ptr, ptr->device->id, (u8)ptr->device->lun);
2487
2488         for (i = 0; i < COMMAND_SIZE(ptr->cmnd[0]); i++)
2489                 seq_printf(m, "0x%02x ", ptr->cmnd[i]);
2490
2491         seq_printf(m, "); resid=%d; residual=%d; buffers=%d; phase |",
2492                 scsi_get_resid(ptr), ptr->SCp.this_residual,
2493                 ptr->SCp.buffers_residual);
2494
2495         if (ptr->SCp.phase & not_issued)
2496                 seq_puts(m, "not issued|");
2497         if (ptr->SCp.phase & selecting)
2498                 seq_puts(m, "selecting|");
2499         if (ptr->SCp.phase & disconnected)
2500                 seq_puts(m, "disconnected|");
2501         if (ptr->SCp.phase & aborted)
2502                 seq_puts(m, "aborted|");
2503         if (ptr->SCp.phase & identified)
2504                 seq_puts(m, "identified|");
2505         if (ptr->SCp.phase & completed)
2506                 seq_puts(m, "completed|");
2507         if (ptr->SCp.phase & spiordy)
2508                 seq_puts(m, "spiordy|");
2509         if (ptr->SCp.phase & syncneg)
2510                 seq_puts(m, "syncneg|");
2511         seq_printf(m, "; next=0x%p\n", SCNEXT(ptr));
2512 }
2513
2514 static void get_ports(struct seq_file *m, struct Scsi_Host *shpnt)
2515 {
2516         int s;
2517
2518         seq_printf(m, "\n%s: %s(%s) ", CURRENT_SC ? "on bus" : "waiting", states[STATE].name, states[PREVSTATE].name);
2519
2520         s = GETPORT(SCSISEQ);
2521         seq_puts(m, "SCSISEQ( ");
2522         if (s & TEMODEO)
2523                 seq_puts(m, "TARGET MODE ");
2524         if (s & ENSELO)
2525                 seq_puts(m, "SELO ");
2526         if (s & ENSELI)
2527                 seq_puts(m, "SELI ");
2528         if (s & ENRESELI)
2529                 seq_puts(m, "RESELI ");
2530         if (s & ENAUTOATNO)
2531                 seq_puts(m, "AUTOATNO ");
2532         if (s & ENAUTOATNI)
2533                 seq_puts(m, "AUTOATNI ");
2534         if (s & ENAUTOATNP)
2535                 seq_puts(m, "AUTOATNP ");
2536         if (s & SCSIRSTO)
2537                 seq_puts(m, "SCSIRSTO ");
2538         seq_puts(m, ");");
2539
2540         seq_puts(m, " SCSISIG(");
2541         s = GETPORT(SCSISIG);
2542         switch (s & P_MASK) {
2543         case P_DATAO:
2544                 seq_puts(m, "DATA OUT");
2545                 break;
2546         case P_DATAI:
2547                 seq_puts(m, "DATA IN");
2548                 break;
2549         case P_CMD:
2550                 seq_puts(m, "COMMAND");
2551                 break;
2552         case P_STATUS:
2553                 seq_puts(m, "STATUS");
2554                 break;
2555         case P_MSGO:
2556                 seq_puts(m, "MESSAGE OUT");
2557                 break;
2558         case P_MSGI:
2559                 seq_puts(m, "MESSAGE IN");
2560                 break;
2561         default:
2562                 seq_puts(m, "*invalid*");
2563                 break;
2564         }
2565
2566         seq_puts(m, "); ");
2567
2568         seq_printf(m, "INTSTAT (%s); ", TESTHI(DMASTAT, INTSTAT) ? "hi" : "lo");
2569
2570         seq_puts(m, "SSTAT( ");
2571         s = GETPORT(SSTAT0);
2572         if (s & TARGET)
2573                 seq_puts(m, "TARGET ");
2574         if (s & SELDO)
2575                 seq_puts(m, "SELDO ");
2576         if (s & SELDI)
2577                 seq_puts(m, "SELDI ");
2578         if (s & SELINGO)
2579                 seq_puts(m, "SELINGO ");
2580         if (s & SWRAP)
2581                 seq_puts(m, "SWRAP ");
2582         if (s & SDONE)
2583                 seq_puts(m, "SDONE ");
2584         if (s & SPIORDY)
2585                 seq_puts(m, "SPIORDY ");
2586         if (s & DMADONE)
2587                 seq_puts(m, "DMADONE ");
2588
2589         s = GETPORT(SSTAT1);
2590         if (s & SELTO)
2591                 seq_puts(m, "SELTO ");
2592         if (s & ATNTARG)
2593                 seq_puts(m, "ATNTARG ");
2594         if (s & SCSIRSTI)
2595                 seq_puts(m, "SCSIRSTI ");
2596         if (s & PHASEMIS)
2597                 seq_puts(m, "PHASEMIS ");
2598         if (s & BUSFREE)
2599                 seq_puts(m, "BUSFREE ");
2600         if (s & SCSIPERR)
2601                 seq_puts(m, "SCSIPERR ");
2602         if (s & PHASECHG)
2603                 seq_puts(m, "PHASECHG ");
2604         if (s & REQINIT)
2605                 seq_puts(m, "REQINIT ");
2606         seq_puts(m, "); ");
2607
2608
2609         seq_puts(m, "SSTAT( ");
2610
2611         s = GETPORT(SSTAT0) & GETPORT(SIMODE0);
2612
2613         if (s & TARGET)
2614                 seq_puts(m, "TARGET ");
2615         if (s & SELDO)
2616                 seq_puts(m, "SELDO ");
2617         if (s & SELDI)
2618                 seq_puts(m, "SELDI ");
2619         if (s & SELINGO)
2620                 seq_puts(m, "SELINGO ");
2621         if (s & SWRAP)
2622                 seq_puts(m, "SWRAP ");
2623         if (s & SDONE)
2624                 seq_puts(m, "SDONE ");
2625         if (s & SPIORDY)
2626                 seq_puts(m, "SPIORDY ");
2627         if (s & DMADONE)
2628                 seq_puts(m, "DMADONE ");
2629
2630         s = GETPORT(SSTAT1) & GETPORT(SIMODE1);
2631
2632         if (s & SELTO)
2633                 seq_puts(m, "SELTO ");
2634         if (s & ATNTARG)
2635                 seq_puts(m, "ATNTARG ");
2636         if (s & SCSIRSTI)
2637                 seq_puts(m, "SCSIRSTI ");
2638         if (s & PHASEMIS)
2639                 seq_puts(m, "PHASEMIS ");
2640         if (s & BUSFREE)
2641                 seq_puts(m, "BUSFREE ");
2642         if (s & SCSIPERR)
2643                 seq_puts(m, "SCSIPERR ");
2644         if (s & PHASECHG)
2645                 seq_puts(m, "PHASECHG ");
2646         if (s & REQINIT)
2647                 seq_puts(m, "REQINIT ");
2648         seq_puts(m, "); ");
2649
2650         seq_puts(m, "SXFRCTL0( ");
2651
2652         s = GETPORT(SXFRCTL0);
2653         if (s & SCSIEN)
2654                 seq_puts(m, "SCSIEN ");
2655         if (s & DMAEN)
2656                 seq_puts(m, "DMAEN ");
2657         if (s & CH1)
2658                 seq_puts(m, "CH1 ");
2659         if (s & CLRSTCNT)
2660                 seq_puts(m, "CLRSTCNT ");
2661         if (s & SPIOEN)
2662                 seq_puts(m, "SPIOEN ");
2663         if (s & CLRCH1)
2664                 seq_puts(m, "CLRCH1 ");
2665         seq_puts(m, "); ");
2666
2667         seq_puts(m, "SIGNAL( ");
2668
2669         s = GETPORT(SCSISIG);
2670         if (s & SIG_ATNI)
2671                 seq_puts(m, "ATNI ");
2672         if (s & SIG_SELI)
2673                 seq_puts(m, "SELI ");
2674         if (s & SIG_BSYI)
2675                 seq_puts(m, "BSYI ");
2676         if (s & SIG_REQI)
2677                 seq_puts(m, "REQI ");
2678         if (s & SIG_ACKI)
2679                 seq_puts(m, "ACKI ");
2680         seq_puts(m, "); ");
2681
2682         seq_printf(m, "SELID(%02x), ", GETPORT(SELID));
2683
2684         seq_printf(m, "STCNT(%d), ", GETSTCNT());
2685
2686         seq_puts(m, "SSTAT2( ");
2687
2688         s = GETPORT(SSTAT2);
2689         if (s & SOFFSET)
2690                 seq_puts(m, "SOFFSET ");
2691         if (s & SEMPTY)
2692                 seq_puts(m, "SEMPTY ");
2693         if (s & SFULL)
2694                 seq_puts(m, "SFULL ");
2695         seq_printf(m, "); SFCNT (%d); ", s & (SFULL | SFCNT));
2696
2697         s = GETPORT(SSTAT3);
2698         seq_printf(m, "SCSICNT (%d), OFFCNT(%d), ", (s & 0xf0) >> 4, s & 0x0f);
2699
2700         seq_puts(m, "SSTAT4( ");
2701         s = GETPORT(SSTAT4);
2702         if (s & SYNCERR)
2703                 seq_puts(m, "SYNCERR ");
2704         if (s & FWERR)
2705                 seq_puts(m, "FWERR ");
2706         if (s & FRERR)
2707                 seq_puts(m, "FRERR ");
2708         seq_puts(m, "); ");
2709
2710         seq_puts(m, "DMACNTRL0( ");
2711         s = GETPORT(DMACNTRL0);
2712         seq_printf(m, "%s ", s & _8BIT ? "8BIT" : "16BIT");
2713         seq_printf(m, "%s ", s & DMA ? "DMA" : "PIO");
2714         seq_printf(m, "%s ", s & WRITE_READ ? "WRITE" : "READ");
2715         if (s & ENDMA)
2716                 seq_puts(m, "ENDMA ");
2717         if (s & INTEN)
2718                 seq_puts(m, "INTEN ");
2719         if (s & RSTFIFO)
2720                 seq_puts(m, "RSTFIFO ");
2721         if (s & SWINT)
2722                 seq_puts(m, "SWINT ");
2723         seq_puts(m, "); ");
2724
2725         seq_puts(m, "DMASTAT( ");
2726         s = GETPORT(DMASTAT);
2727         if (s & ATDONE)
2728                 seq_puts(m, "ATDONE ");
2729         if (s & WORDRDY)
2730                 seq_puts(m, "WORDRDY ");
2731         if (s & DFIFOFULL)
2732                 seq_puts(m, "DFIFOFULL ");
2733         if (s & DFIFOEMP)
2734                 seq_puts(m, "DFIFOEMP ");
2735         seq_puts(m, ")\n");
2736
2737         seq_puts(m, "enabled interrupts( ");
2738
2739         s = GETPORT(SIMODE0);
2740         if (s & ENSELDO)
2741                 seq_puts(m, "ENSELDO ");
2742         if (s & ENSELDI)
2743                 seq_puts(m, "ENSELDI ");
2744         if (s & ENSELINGO)
2745                 seq_puts(m, "ENSELINGO ");
2746         if (s & ENSWRAP)
2747                 seq_puts(m, "ENSWRAP ");
2748         if (s & ENSDONE)
2749                 seq_puts(m, "ENSDONE ");
2750         if (s & ENSPIORDY)
2751                 seq_puts(m, "ENSPIORDY ");
2752         if (s & ENDMADONE)
2753                 seq_puts(m, "ENDMADONE ");
2754
2755         s = GETPORT(SIMODE1);
2756         if (s & ENSELTIMO)
2757                 seq_puts(m, "ENSELTIMO ");
2758         if (s & ENATNTARG)
2759                 seq_puts(m, "ENATNTARG ");
2760         if (s & ENPHASEMIS)
2761                 seq_puts(m, "ENPHASEMIS ");
2762         if (s & ENBUSFREE)
2763                 seq_puts(m, "ENBUSFREE ");
2764         if (s & ENSCSIPERR)
2765                 seq_puts(m, "ENSCSIPERR ");
2766         if (s & ENPHASECHG)
2767                 seq_puts(m, "ENPHASECHG ");
2768         if (s & ENREQINIT)
2769                 seq_puts(m, "ENREQINIT ");
2770         seq_puts(m, ")\n");
2771 }
2772
2773 static int aha152x_set_info(struct Scsi_Host *shpnt, char *buffer, int length)
2774 {
2775         if(!shpnt || !buffer || length<8 || strncmp("aha152x ", buffer, 8)!=0)
2776                 return -EINVAL;
2777
2778 #if defined(AHA152X_STAT)
2779         if(length>13 && strncmp("reset", buffer+8, 5)==0) {
2780                 int i;
2781
2782                 HOSTDATA(shpnt)->total_commands=0;
2783                 HOSTDATA(shpnt)->disconnections=0;
2784                 HOSTDATA(shpnt)->busfree_without_any_action=0;
2785                 HOSTDATA(shpnt)->busfree_without_old_command=0;
2786                 HOSTDATA(shpnt)->busfree_without_new_command=0;
2787                 HOSTDATA(shpnt)->busfree_without_done_command=0;
2788                 HOSTDATA(shpnt)->busfree_with_check_condition=0;
2789                 for (i = idle; i<maxstate; i++) {
2790                         HOSTDATA(shpnt)->count[i]=0;
2791                         HOSTDATA(shpnt)->count_trans[i]=0;
2792                         HOSTDATA(shpnt)->time[i]=0;
2793                 }
2794
2795                 shost_printk(KERN_INFO, shpnt, "aha152x: stats reset.\n");
2796
2797         } else
2798 #endif
2799         {
2800                 return -EINVAL;
2801         }
2802
2803
2804         return length;
2805 }
2806
2807 static int aha152x_show_info(struct seq_file *m, struct Scsi_Host *shpnt)
2808 {
2809         int i;
2810         struct scsi_cmnd *ptr;
2811         unsigned long flags;
2812
2813         seq_puts(m, AHA152X_REVID "\n");
2814
2815         seq_printf(m, "ioports 0x%04lx to 0x%04lx\n",
2816                 shpnt->io_port, shpnt->io_port + shpnt->n_io_port - 1);
2817         seq_printf(m, "interrupt 0x%02x\n", shpnt->irq);
2818         seq_printf(m, "disconnection/reconnection %s\n",
2819                 RECONNECT ? "enabled" : "disabled");
2820         seq_printf(m, "parity checking %s\n",
2821                 PARITY ? "enabled" : "disabled");
2822         seq_printf(m, "synchronous transfers %s\n",
2823                 SYNCHRONOUS ? "enabled" : "disabled");
2824         seq_printf(m, "%d commands currently queued\n", HOSTDATA(shpnt)->commands);
2825
2826         if(SYNCHRONOUS) {
2827                 seq_puts(m, "synchronously operating targets (tick=50 ns):\n");
2828                 for (i = 0; i < 8; i++)
2829                         if (HOSTDATA(shpnt)->syncrate[i] & 0x7f)
2830                                 seq_printf(m, "target %d: period %dT/%dns; req/ack offset %d\n",
2831                                         i,
2832                                         (((HOSTDATA(shpnt)->syncrate[i] & 0x70) >> 4) + 2),
2833                                         (((HOSTDATA(shpnt)->syncrate[i] & 0x70) >> 4) + 2) * 50,
2834                                     HOSTDATA(shpnt)->syncrate[i] & 0x0f);
2835         }
2836         seq_puts(m, "\nqueue status:\n");
2837         DO_LOCK(flags);
2838         if (ISSUE_SC) {
2839                 seq_puts(m, "not yet issued commands:\n");
2840                 for (ptr = ISSUE_SC; ptr; ptr = SCNEXT(ptr))
2841                         get_command(m, ptr);
2842         } else
2843                 seq_puts(m, "no not yet issued commands\n");
2844         DO_UNLOCK(flags);
2845
2846         if (CURRENT_SC) {
2847                 seq_puts(m, "current command:\n");
2848                 get_command(m, CURRENT_SC);
2849         } else
2850                 seq_puts(m, "no current command\n");
2851
2852         if (DISCONNECTED_SC) {
2853                 seq_puts(m, "disconnected commands:\n");
2854                 for (ptr = DISCONNECTED_SC; ptr; ptr = SCNEXT(ptr))
2855                         get_command(m, ptr);
2856         } else
2857                 seq_puts(m, "no disconnected commands\n");
2858
2859         get_ports(m, shpnt);
2860
2861 #if defined(AHA152X_STAT)
2862         seq_printf(m, "statistics:\n"
2863                 "total commands:               %d\n"
2864                 "disconnections:               %d\n"
2865                 "busfree with check condition: %d\n"
2866                 "busfree without old command:  %d\n"
2867                 "busfree without new command:  %d\n"
2868                 "busfree without done command: %d\n"
2869                 "busfree without any action:   %d\n"
2870                 "state      "
2871                 "transitions  "
2872                 "count        "
2873                 "time\n",
2874                 HOSTDATA(shpnt)->total_commands,
2875                 HOSTDATA(shpnt)->disconnections,
2876                 HOSTDATA(shpnt)->busfree_with_check_condition,
2877                 HOSTDATA(shpnt)->busfree_without_old_command,
2878                 HOSTDATA(shpnt)->busfree_without_new_command,
2879                 HOSTDATA(shpnt)->busfree_without_done_command,
2880                 HOSTDATA(shpnt)->busfree_without_any_action);
2881         for(i=0; i<maxstate; i++) {
2882                 seq_printf(m, "%-10s %-12d %-12d %-12ld\n",
2883                         states[i].name,
2884                         HOSTDATA(shpnt)->count_trans[i],
2885                         HOSTDATA(shpnt)->count[i],
2886                         HOSTDATA(shpnt)->time[i]);
2887         }
2888 #endif
2889         return 0;
2890 }
2891
2892 static int aha152x_adjust_queue(struct scsi_device *device)
2893 {
2894         blk_queue_bounce_limit(device->request_queue, BLK_BOUNCE_HIGH);
2895         return 0;
2896 }
2897
2898 static struct scsi_host_template aha152x_driver_template = {
2899         .module                         = THIS_MODULE,
2900         .name                           = AHA152X_REVID,
2901         .proc_name                      = "aha152x",
2902         .show_info                      = aha152x_show_info,
2903         .write_info                     = aha152x_set_info,
2904         .queuecommand                   = aha152x_queue,
2905         .eh_abort_handler               = aha152x_abort,
2906         .eh_device_reset_handler        = aha152x_device_reset,
2907         .eh_bus_reset_handler           = aha152x_bus_reset,
2908         .bios_param                     = aha152x_biosparam,
2909         .can_queue                      = 1,
2910         .this_id                        = 7,
2911         .sg_tablesize                   = SG_ALL,
2912         .dma_boundary                   = PAGE_SIZE - 1,
2913         .slave_alloc                    = aha152x_adjust_queue,
2914 };
2915
2916 #if !defined(AHA152X_PCMCIA)
2917 static int setup_count;
2918 static struct aha152x_setup setup[2];
2919
2920 /* possible i/o addresses for the AIC-6260; default first */
2921 static unsigned short ports[] = { 0x340, 0x140 };
2922
2923 #if !defined(SKIP_BIOSTEST)
2924 /* possible locations for the Adaptec BIOS; defaults first */
2925 static unsigned int addresses[] =
2926 {
2927         0xdc000,                /* default first */
2928         0xc8000,
2929         0xcc000,
2930         0xd0000,
2931         0xd4000,
2932         0xd8000,
2933         0xe0000,
2934         0xeb800,                /* VTech Platinum SMP */
2935         0xf0000,
2936 };
2937
2938 /* signatures for various AIC-6[23]60 based controllers.
2939    The point in detecting signatures is to avoid useless and maybe
2940    harmful probes on ports. I'm not sure that all listed boards pass
2941    auto-configuration. For those which fail the BIOS signature is
2942    obsolete, because user intervention to supply the configuration is
2943    needed anyway.  May be an information whether or not the BIOS supports
2944    extended translation could be also useful here. */
2945 static struct signature {
2946         unsigned char *signature;
2947         int sig_offset;
2948         int sig_length;
2949 } signatures[] =
2950 {
2951         { "Adaptec AHA-1520 BIOS",      0x102e, 21 },
2952                 /* Adaptec 152x */
2953         { "Adaptec AHA-1520B",          0x000b, 17 },
2954                 /* Adaptec 152x rev B */
2955         { "Adaptec AHA-1520B",          0x0026, 17 },
2956                 /* Iomega Jaz Jet ISA (AIC6370Q) */
2957         { "Adaptec ASW-B626 BIOS",      0x1029, 21 },
2958                 /* on-board controller */
2959         { "Adaptec BIOS: ASW-B626",     0x000f, 22 },
2960                 /* on-board controller */
2961         { "Adaptec ASW-B626 S2",        0x2e6c, 19 },
2962                 /* on-board controller */
2963         { "Adaptec BIOS:AIC-6360",      0x000c, 21 },
2964                 /* on-board controller */
2965         { "ScsiPro SP-360 BIOS",        0x2873, 19 },
2966                 /* ScsiPro-Controller  */
2967         { "GA-400 LOCAL BUS SCSI BIOS", 0x102e, 26 },
2968                 /* Gigabyte Local-Bus-SCSI */
2969         { "Adaptec BIOS:AVA-282X",      0x000c, 21 },
2970                 /* Adaptec 282x */
2971         { "Adaptec IBM Dock II SCSI",   0x2edd, 24 },
2972                 /* IBM Thinkpad Dock II */
2973         { "Adaptec BIOS:AHA-1532P",     0x001c, 22 },
2974                 /* IBM Thinkpad Dock II SCSI */
2975         { "DTC3520A Host Adapter BIOS", 0x318a, 26 },
2976                 /* DTC 3520A ISA SCSI */
2977 };
2978 #endif /* !SKIP_BIOSTEST */
2979
2980 /*
2981  * Test, if port_base is valid.
2982  *
2983  */
2984 static int aha152x_porttest(int io_port)
2985 {
2986         int i;
2987
2988         SETPORT(io_port + O_DMACNTRL1, 0);      /* reset stack pointer */
2989         for (i = 0; i < 16; i++)
2990                 SETPORT(io_port + O_STACK, i);
2991
2992         SETPORT(io_port + O_DMACNTRL1, 0);      /* reset stack pointer */
2993         for (i = 0; i < 16 && GETPORT(io_port + O_STACK) == i; i++)
2994                 ;
2995
2996         return (i == 16);
2997 }
2998
2999 static int tc1550_porttest(int io_port)
3000 {
3001         int i;
3002
3003         SETPORT(io_port + O_TC_DMACNTRL1, 0);   /* reset stack pointer */
3004         for (i = 0; i < 16; i++)
3005                 SETPORT(io_port + O_STACK, i);
3006
3007         SETPORT(io_port + O_TC_DMACNTRL1, 0);   /* reset stack pointer */
3008         for (i = 0; i < 16 && GETPORT(io_port + O_TC_STACK) == i; i++)
3009                 ;
3010
3011         return (i == 16);
3012 }
3013
3014
3015 static int checksetup(struct aha152x_setup *setup)
3016 {
3017         int i;
3018         for (i = 0; i < ARRAY_SIZE(ports) && (setup->io_port != ports[i]); i++)
3019                 ;
3020
3021         if (i == ARRAY_SIZE(ports))
3022                 return 0;
3023
3024         if (!request_region(setup->io_port, IO_RANGE, "aha152x")) {
3025                 printk(KERN_ERR "aha152x: io port 0x%x busy.\n", setup->io_port);
3026                 return 0;
3027         }
3028
3029         if( aha152x_porttest(setup->io_port) ) {
3030                 setup->tc1550=0;
3031         } else if( tc1550_porttest(setup->io_port) ) {
3032                 setup->tc1550=1;
3033         } else {
3034                 release_region(setup->io_port, IO_RANGE);
3035                 return 0;
3036         }
3037
3038         release_region(setup->io_port, IO_RANGE);
3039
3040         if ((setup->irq < IRQ_MIN) || (setup->irq > IRQ_MAX))
3041                 return 0;
3042
3043         if ((setup->scsiid < 0) || (setup->scsiid > 7))
3044                 return 0;
3045
3046         if ((setup->reconnect < 0) || (setup->reconnect > 1))
3047                 return 0;
3048
3049         if ((setup->parity < 0) || (setup->parity > 1))
3050                 return 0;
3051
3052         if ((setup->synchronous < 0) || (setup->synchronous > 1))
3053                 return 0;
3054
3055         if ((setup->ext_trans < 0) || (setup->ext_trans > 1))
3056                 return 0;
3057
3058
3059         return 1;
3060 }
3061
3062
3063 static int __init aha152x_init(void)
3064 {
3065         int i, j, ok;
3066 #if defined(AUTOCONF)
3067         aha152x_config conf;
3068 #endif
3069 #ifdef __ISAPNP__
3070         struct pnp_dev *dev=NULL, *pnpdev[2] = {NULL, NULL};
3071 #endif
3072
3073         if ( setup_count ) {
3074                 printk(KERN_INFO "aha152x: processing commandline: ");
3075
3076                 for (i = 0; i<setup_count; i++) {
3077                         if (!checksetup(&setup[i])) {
3078                                 printk(KERN_ERR "\naha152x: %s\n", setup[i].conf);
3079                                 printk(KERN_ERR "aha152x: invalid line\n");
3080                         }
3081                 }
3082                 printk("ok\n");
3083         }
3084
3085 #if defined(SETUP0)
3086         if (setup_count < ARRAY_SIZE(setup)) {
3087                 struct aha152x_setup override = SETUP0;
3088
3089                 if (setup_count == 0 || (override.io_port != setup[0].io_port)) {
3090                         if (!checksetup(&override)) {
3091                                 printk(KERN_ERR "\naha152x: invalid override SETUP0={0x%x,%d,%d,%d,%d,%d,%d,%d}\n",
3092                                        override.io_port,
3093                                        override.irq,
3094                                        override.scsiid,
3095                                        override.reconnect,
3096                                        override.parity,
3097                                        override.synchronous,
3098                                        override.delay,
3099                                        override.ext_trans);
3100                         } else
3101                                 setup[setup_count++] = override;
3102                 }
3103         }
3104 #endif
3105
3106 #if defined(SETUP1)
3107         if (setup_count < ARRAY_SIZE(setup)) {
3108                 struct aha152x_setup override = SETUP1;
3109
3110                 if (setup_count == 0 || (override.io_port != setup[0].io_port)) {
3111                         if (!checksetup(&override)) {
3112                                 printk(KERN_ERR "\naha152x: invalid override SETUP1={0x%x,%d,%d,%d,%d,%d,%d,%d}\n",
3113                                        override.io_port,
3114                                        override.irq,
3115                                        override.scsiid,
3116                                        override.reconnect,
3117                                        override.parity,
3118                                        override.synchronous,
3119                                        override.delay,
3120                                        override.ext_trans);
3121                         } else
3122                                 setup[setup_count++] = override;
3123                 }
3124         }
3125 #endif
3126
3127 #if defined(MODULE)
3128         if (setup_count<ARRAY_SIZE(setup) && (aha152x[0]!=0 || io[0]!=0 || irq[0]!=0)) {
3129                 if(aha152x[0]!=0) {
3130                         setup[setup_count].conf        = "";
3131                         setup[setup_count].io_port     = aha152x[0];
3132                         setup[setup_count].irq         = aha152x[1];
3133                         setup[setup_count].scsiid      = aha152x[2];
3134                         setup[setup_count].reconnect   = aha152x[3];
3135                         setup[setup_count].parity      = aha152x[4];
3136                         setup[setup_count].synchronous = aha152x[5];
3137                         setup[setup_count].delay       = aha152x[6];
3138                         setup[setup_count].ext_trans   = aha152x[7];
3139                 } else if (io[0] != 0 || irq[0] != 0) {
3140                         if(io[0]!=0)  setup[setup_count].io_port = io[0];
3141                         if(irq[0]!=0) setup[setup_count].irq     = irq[0];
3142
3143                         setup[setup_count].scsiid      = scsiid[0];
3144                         setup[setup_count].reconnect   = reconnect[0];
3145                         setup[setup_count].parity      = parity[0];
3146                         setup[setup_count].synchronous = sync[0];
3147                         setup[setup_count].delay       = delay[0];
3148                         setup[setup_count].ext_trans   = exttrans[0];
3149                 }
3150
3151                 if (checksetup(&setup[setup_count]))
3152                         setup_count++;
3153                 else
3154                         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",
3155                                setup[setup_count].io_port,
3156                                setup[setup_count].irq,
3157                                setup[setup_count].scsiid,
3158                                setup[setup_count].reconnect,
3159                                setup[setup_count].parity,
3160                                setup[setup_count].synchronous,
3161                                setup[setup_count].delay,
3162                                setup[setup_count].ext_trans);
3163         }
3164
3165         if (setup_count<ARRAY_SIZE(setup) && (aha152x1[0]!=0 || io[1]!=0 || irq[1]!=0)) {
3166                 if(aha152x1[0]!=0) {
3167                         setup[setup_count].conf        = "";
3168                         setup[setup_count].io_port     = aha152x1[0];
3169                         setup[setup_count].irq         = aha152x1[1];
3170                         setup[setup_count].scsiid      = aha152x1[2];
3171                         setup[setup_count].reconnect   = aha152x1[3];
3172                         setup[setup_count].parity      = aha152x1[4];
3173                         setup[setup_count].synchronous = aha152x1[5];
3174                         setup[setup_count].delay       = aha152x1[6];
3175                         setup[setup_count].ext_trans   = aha152x1[7];
3176                 } else if (io[1] != 0 || irq[1] != 0) {
3177                         if(io[1]!=0)  setup[setup_count].io_port = io[1];
3178                         if(irq[1]!=0) setup[setup_count].irq     = irq[1];
3179
3180                         setup[setup_count].scsiid      = scsiid[1];
3181                         setup[setup_count].reconnect   = reconnect[1];
3182                         setup[setup_count].parity      = parity[1];
3183                         setup[setup_count].synchronous = sync[1];
3184                         setup[setup_count].delay       = delay[1];
3185                         setup[setup_count].ext_trans   = exttrans[1];
3186                 }
3187                 if (checksetup(&setup[setup_count]))
3188                         setup_count++;
3189                 else
3190                         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",
3191                                setup[setup_count].io_port,
3192                                setup[setup_count].irq,
3193                                setup[setup_count].scsiid,
3194                                setup[setup_count].reconnect,
3195                                setup[setup_count].parity,
3196                                setup[setup_count].synchronous,
3197                                setup[setup_count].delay,
3198                                setup[setup_count].ext_trans);
3199         }
3200 #endif
3201
3202 #ifdef __ISAPNP__
3203         for(i=0; setup_count<ARRAY_SIZE(setup) && id_table[i].vendor; i++) {
3204                 while ( setup_count<ARRAY_SIZE(setup) &&
3205                         (dev=pnp_find_dev(NULL, id_table[i].vendor, id_table[i].function, dev)) ) {
3206                         if (pnp_device_attach(dev) < 0)
3207                                 continue;
3208
3209                         if (pnp_activate_dev(dev) < 0) {
3210                                 pnp_device_detach(dev);
3211                                 continue;
3212                         }
3213
3214                         if (!pnp_port_valid(dev, 0)) {
3215                                 pnp_device_detach(dev);
3216                                 continue;
3217                         }
3218
3219                         if (setup_count==1 && pnp_port_start(dev, 0)==setup[0].io_port) {
3220                                 pnp_device_detach(dev);
3221                                 continue;
3222                         }
3223
3224                         setup[setup_count].io_port     = pnp_port_start(dev, 0);
3225                         setup[setup_count].irq         = pnp_irq(dev, 0);
3226                         setup[setup_count].scsiid      = 7;
3227                         setup[setup_count].reconnect   = 1;
3228                         setup[setup_count].parity      = 1;
3229                         setup[setup_count].synchronous = 1;
3230                         setup[setup_count].delay       = DELAY_DEFAULT;
3231                         setup[setup_count].ext_trans   = 0;
3232 #if defined(__ISAPNP__)
3233                         pnpdev[setup_count]            = dev;
3234 #endif
3235                         printk (KERN_INFO
3236                                 "aha152x: found ISAPnP adapter at io=0x%03x, irq=%d\n",
3237                                 setup[setup_count].io_port, setup[setup_count].irq);
3238                         setup_count++;
3239                 }
3240         }
3241 #endif
3242
3243 #if defined(AUTOCONF)
3244         if (setup_count<ARRAY_SIZE(setup)) {
3245 #if !defined(SKIP_BIOSTEST)
3246                 ok = 0;
3247                 for (i = 0; i < ARRAY_SIZE(addresses) && !ok; i++) {
3248                         void __iomem *p = ioremap(addresses[i], 0x4000);
3249                         if (!p)
3250                                 continue;
3251                         for (j = 0; j<ARRAY_SIZE(signatures) && !ok; j++)
3252                                 ok = check_signature(p + signatures[j].sig_offset,
3253                                                                 signatures[j].signature, signatures[j].sig_length);
3254                         iounmap(p);
3255                 }
3256                 if (!ok && setup_count == 0)
3257                         return -ENODEV;
3258
3259                 printk(KERN_INFO "aha152x: BIOS test: passed, ");
3260 #else
3261                 printk(KERN_INFO "aha152x: ");
3262 #endif                          /* !SKIP_BIOSTEST */
3263
3264                 ok = 0;
3265                 for (i = 0; i < ARRAY_SIZE(ports) && setup_count < 2; i++) {
3266                         if ((setup_count == 1) && (setup[0].io_port == ports[i]))
3267                                 continue;
3268
3269                         if (!request_region(ports[i], IO_RANGE, "aha152x")) {
3270                                 printk(KERN_ERR "aha152x: io port 0x%x busy.\n", ports[i]);
3271                                 continue;
3272                         }
3273
3274                         if (aha152x_porttest(ports[i])) {
3275                                 setup[setup_count].tc1550  = 0;
3276
3277                                 conf.cf_port =
3278                                     (GETPORT(ports[i] + O_PORTA) << 8) + GETPORT(ports[i] + O_PORTB);
3279                         } else if (tc1550_porttest(ports[i])) {
3280                                 setup[setup_count].tc1550  = 1;
3281
3282                                 conf.cf_port =
3283                                     (GETPORT(ports[i] + O_TC_PORTA) << 8) + GETPORT(ports[i] + O_TC_PORTB);
3284                         } else {
3285                                 release_region(ports[i], IO_RANGE);
3286                                 continue;
3287                         }
3288
3289                         release_region(ports[i], IO_RANGE);
3290
3291                         ok++;
3292                         setup[setup_count].io_port = ports[i];
3293                         setup[setup_count].irq = IRQ_MIN + conf.cf_irq;
3294                         setup[setup_count].scsiid = conf.cf_id;
3295                         setup[setup_count].reconnect = conf.cf_tardisc;
3296                         setup[setup_count].parity = !conf.cf_parity;
3297                         setup[setup_count].synchronous = conf.cf_syncneg;
3298                         setup[setup_count].delay = DELAY_DEFAULT;
3299                         setup[setup_count].ext_trans = 0;
3300                         setup_count++;
3301
3302                 }
3303
3304                 if (ok)
3305                         printk("auto configuration: ok, ");
3306         }
3307 #endif
3308
3309         printk("%d controller(s) configured\n", setup_count);
3310
3311         for (i=0; i<setup_count; i++) {
3312                 if ( request_region(setup[i].io_port, IO_RANGE, "aha152x") ) {
3313                         struct Scsi_Host *shpnt = aha152x_probe_one(&setup[i]);
3314
3315                         if( !shpnt ) {
3316                                 release_region(setup[i].io_port, IO_RANGE);
3317 #if defined(__ISAPNP__)
3318                         } else if( pnpdev[i] ) {
3319                                 HOSTDATA(shpnt)->pnpdev=pnpdev[i];
3320                                 pnpdev[i]=NULL;
3321 #endif
3322                         }
3323                 } else {
3324                         printk(KERN_ERR "aha152x: io port 0x%x busy.\n", setup[i].io_port);
3325                 }
3326
3327 #if defined(__ISAPNP__)
3328                 if( pnpdev[i] )
3329                         pnp_device_detach(pnpdev[i]);
3330 #endif
3331         }
3332
3333         return 0;
3334 }
3335
3336 static void __exit aha152x_exit(void)
3337 {
3338         struct aha152x_hostdata *hd, *tmp;
3339
3340         list_for_each_entry_safe(hd, tmp, &aha152x_host_list, host_list) {
3341                 struct Scsi_Host *shost = container_of((void *)hd, struct Scsi_Host, hostdata);
3342
3343                 aha152x_release(shost);
3344         }
3345 }
3346
3347 module_init(aha152x_init);
3348 module_exit(aha152x_exit);
3349
3350 #if !defined(MODULE)
3351 static int __init aha152x_setup(char *str)
3352 {
3353         int ints[10];
3354
3355         get_options(str, ARRAY_SIZE(ints), ints);
3356
3357         if(setup_count>=ARRAY_SIZE(setup)) {
3358                 printk(KERN_ERR "aha152x: you can only configure up to two controllers\n");
3359                 return 1;
3360         }
3361
3362         setup[setup_count].conf        = str;
3363         setup[setup_count].io_port     = ints[0] >= 1 ? ints[1] : 0x340;
3364         setup[setup_count].irq         = ints[0] >= 2 ? ints[2] : 11;
3365         setup[setup_count].scsiid      = ints[0] >= 3 ? ints[3] : 7;
3366         setup[setup_count].reconnect   = ints[0] >= 4 ? ints[4] : 1;
3367         setup[setup_count].parity      = ints[0] >= 5 ? ints[5] : 1;
3368         setup[setup_count].synchronous = ints[0] >= 6 ? ints[6] : 1;
3369         setup[setup_count].delay       = ints[0] >= 7 ? ints[7] : DELAY_DEFAULT;
3370         setup[setup_count].ext_trans   = ints[0] >= 8 ? ints[8] : 0;
3371         if (ints[0] > 8) {                                                /*}*/
3372                 printk(KERN_NOTICE "aha152x: usage: aha152x=<IOBASE>[,<IRQ>[,<SCSI ID>"
3373                        "[,<RECONNECT>[,<PARITY>[,<SYNCHRONOUS>[,<DELAY>[,<EXT_TRANS>]]]]]]]\n");
3374         } else {
3375                 setup_count++;
3376                 return 0;
3377         }
3378
3379         return 1;
3380 }
3381 __setup("aha152x=", aha152x_setup);
3382 #endif
3383
3384 #endif /* !AHA152X_PCMCIA */