drivers/scsi/aha152x.c

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