drivers/scsi/aha152x.c

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