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