PageRenderTime 95ms CodeModel.GetById 3ms app.highlight 80ms RepoModel.GetById 1ms app.codeStats 0ms

/drivers/scsi/wd7000.c

http://github.com/mirrors/linux
C | 1657 lines | 979 code | 235 blank | 443 comment | 141 complexity | d26c6e249b378527146c3214fddded24 MD5 | raw file

Large files files are truncated, but you can click here to view the full file

   1/* $Id: $
   2 *  linux/drivers/scsi/wd7000.c
   3 *
   4 *  Copyright (C) 1992  Thomas Wuensche
   5 *	closely related to the aha1542 driver from Tommy Thorn
   6 *	( as close as different hardware allows on a lowlevel-driver :-) )
   7 *
   8 *  Revised (and renamed) by John Boyd <boyd@cis.ohio-state.edu> to
   9 *  accommodate Eric Youngdale's modifications to scsi.c.  Nov 1992.
  10 *
  11 *  Additional changes to support scatter/gather.  Dec. 1992.  tw/jb
  12 *
  13 *  No longer tries to reset SCSI bus at boot (it wasn't working anyway).
  14 *  Rewritten to support multiple host adapters.
  15 *  Miscellaneous cleanup.
  16 *  So far, still doesn't do reset or abort correctly, since I have no idea
  17 *  how to do them with this board (8^(.                      Jan 1994 jb
  18 *
  19 * This driver now supports both of the two standard configurations (per
  20 * the 3.36 Owner's Manual, my latest reference) by the same method as
  21 * before; namely, by looking for a BIOS signature.  Thus, the location of
  22 * the BIOS signature determines the board configuration.  Until I have
  23 * time to do something more flexible, users should stick to one of the
  24 * following:
  25 *
  26 * Standard configuration for single-adapter systems:
  27 *    - BIOS at CE00h
  28 *    - I/O base address 350h
  29 *    - IRQ level 15
  30 *    - DMA channel 6
  31 * Standard configuration for a second adapter in a system:
  32 *    - BIOS at C800h
  33 *    - I/O base address 330h
  34 *    - IRQ level 11
  35 *    - DMA channel 5
  36 *
  37 * Anyone who can recompile the kernel is welcome to add others as need
  38 * arises, but unpredictable results may occur if there are conflicts.
  39 * In any event, if there are multiple adapters in a system, they MUST
  40 * use different I/O bases, IRQ levels, and DMA channels, since they will be
  41 * indistinguishable (and in direct conflict) otherwise.
  42 *
  43 *   As a point of information, the NO_OP command toggles the CMD_RDY bit
  44 * of the status port, and this fact could be used as a test for the I/O
  45 * base address (or more generally, board detection).  There is an interrupt
  46 * status port, so IRQ probing could also be done.  I suppose the full
  47 * DMA diagnostic could be used to detect the DMA channel being used.  I
  48 * haven't done any of this, though, because I think there's too much of
  49 * a chance that such explorations could be destructive, if some other
  50 * board's resources are used inadvertently.  So, call me a wimp, but I
  51 * don't want to try it.  The only kind of exploration I trust is memory
  52 * exploration, since it's more certain that reading memory won't be
  53 * destructive.
  54 *
  55 * More to my liking would be a LILO boot command line specification, such
  56 * as is used by the aha152x driver (and possibly others).  I'll look into
  57 * it, as I have time...
  58 *
  59 *   I get mail occasionally from people who either are using or are
  60 * considering using a WD7000 with Linux.  There is a variety of
  61 * nomenclature describing WD7000's.  To the best of my knowledge, the
  62 * following is a brief summary (from an old WD doc - I don't work for
  63 * them or anything like that):
  64 *
  65 * WD7000-FASST2: This is a WD7000 board with the real-mode SST ROM BIOS
  66 *        installed.  Last I heard, the BIOS was actually done by Columbia
  67 *        Data Products.  The BIOS is only used by this driver (and thus
  68 *        by Linux) to identify the board; none of it can be executed under
  69 *        Linux.
  70 *
  71 * WD7000-ASC: This is the original adapter board, with or without BIOS.
  72 *        The board uses a WD33C93 or WD33C93A SBIC, which in turn is
  73 *        controlled by an onboard Z80 processor.  The board interface
  74 *        visible to the host CPU is defined effectively by the Z80's
  75 *        firmware, and it is this firmware's revision level that is
  76 *        determined and reported by this driver.  (The version of the
  77 *        on-board BIOS is of no interest whatsoever.)  The host CPU has
  78 *        no access to the SBIC; hence the fact that it is a WD33C93 is
  79 *        also of no interest to this driver.
  80 *
  81 * WD7000-AX:
  82 * WD7000-MX:
  83 * WD7000-EX: These are newer versions of the WD7000-ASC.  The -ASC is
  84 *        largely built from discrete components; these boards use more
  85 *        integration.  The -AX is an ISA bus board (like the -ASC),
  86 *        the -MX is an MCA (i.e., PS/2) bus board), and the -EX is an
  87 *        EISA bus board.
  88 *
  89 *  At the time of my documentation, the -?X boards were "future" products,
  90 *  and were not yet available.  However, I vaguely recall that Thomas
  91 *  Wuensche had an -AX, so I believe at least it is supported by this
  92 *  driver.  I have no personal knowledge of either -MX or -EX boards.
  93 *
  94 *  P.S. Just recently, I've discovered (directly from WD and Future
  95 *  Domain) that all but the WD7000-EX have been out of production for
  96 *  two years now.  FD has production rights to the 7000-EX, and are
  97 *  producing it under a new name, and with a new BIOS.  If anyone has
  98 *  one of the FD boards, it would be nice to come up with a signature
  99 *  for it.
 100 *                                                           J.B. Jan 1994.
 101 *
 102 *
 103 *  Revisions by Miroslav Zagorac <zaga@fly.cc.fer.hr>
 104 *
 105 *  08/24/1996.
 106 *
 107 *  Enhancement for wd7000_detect function has been made, so you don't have
 108 *  to enter BIOS ROM address in initialisation data (see struct Config).
 109 *  We cannot detect IRQ, DMA and I/O base address for now, so we have to
 110 *  enter them as arguments while wd_7000 is detected. If someone has IRQ,
 111 *  DMA or I/O base address set to some other value, he can enter them in
 112 *  configuration without any problem. Also I wrote a function wd7000_setup,
 113 *  so now you can enter WD-7000 definition as kernel arguments,
 114 *  as in lilo.conf:
 115 *
 116 *     append="wd7000=IRQ,DMA,IO"
 117 *
 118 *  PS: If card BIOS ROM is disabled, function wd7000_detect now will recognize
 119 *      adapter, unlike the old one. Anyway, BIOS ROM from WD7000 adapter is
 120 *      useless for Linux. B^)
 121 *
 122 *
 123 *  09/06/1996.
 124 *
 125 *  Autodetecting of I/O base address from wd7000_detect function is removed,
 126 *  some little bugs removed, etc...
 127 *
 128 *  Thanks to Roger Scott for driver debugging.
 129 *
 130 *  06/07/1997
 131 *
 132 *  Added support for /proc file system (/proc/scsi/wd7000/[0...] files).
 133 *  Now, driver can handle hard disks with capacity >1GB.
 134 *
 135 *  01/15/1998
 136 *
 137 *  Added support for BUS_ON and BUS_OFF parameters in config line.
 138 *  Miscellaneous cleanup.
 139 *
 140 *  03/01/1998
 141 *
 142 *  WD7000 driver now work on kernels >= 2.1.x
 143 *
 144 *
 145 * 12/31/2001 - Arnaldo Carvalho de Melo <acme@conectiva.com.br>
 146 *
 147 * use host->host_lock, not io_request_lock, cleanups
 148 *
 149 * 2002/10/04 - Alan Cox <alan@lxorguk.ukuu.org.uk>
 150 *
 151 * Use dev_id for interrupts, kill __func__ pasting
 152 * Add a lock for the scb pool, clean up all other cli/sti usage stuff
 153 * Use the adapter lock for the other places we had the cli's
 154 *
 155 * 2002/10/06 - Alan Cox <alan@lxorguk.ukuu.org.uk>
 156 *
 157 * Switch to new style error handling
 158 * Clean up delay to udelay, and yielding sleeps
 159 * Make host reset actually reset the card
 160 * Make everything static
 161 *
 162 * 2003/02/12 - Christoph Hellwig <hch@infradead.org>
 163 *
 164 * Cleaned up host template definition
 165 * Removed now obsolete wd7000.h
 166 */
 167
 168#include <linux/delay.h>
 169#include <linux/module.h>
 170#include <linux/interrupt.h>
 171#include <linux/kernel.h>
 172#include <linux/types.h>
 173#include <linux/string.h>
 174#include <linux/spinlock.h>
 175#include <linux/ioport.h>
 176#include <linux/proc_fs.h>
 177#include <linux/blkdev.h>
 178#include <linux/init.h>
 179#include <linux/stat.h>
 180#include <linux/io.h>
 181
 182#include <asm/dma.h>
 183
 184#include <scsi/scsi.h>
 185#include <scsi/scsi_cmnd.h>
 186#include <scsi/scsi_device.h>
 187#include <scsi/scsi_host.h>
 188#include <scsi/scsicam.h>
 189
 190
 191#undef  WD7000_DEBUG		/* general debug                */
 192#ifdef WD7000_DEBUG
 193#define dprintk printk
 194#else
 195#define dprintk	no_printk
 196#endif
 197
 198/*
 199 *  Mailbox structure sizes.
 200 *  I prefer to keep the number of ICMBs much larger than the number of
 201 *  OGMBs.  OGMBs are used very quickly by the driver to start one or
 202 *  more commands, while ICMBs are used by the host adapter per command.
 203 */
 204#define OGMB_CNT	16
 205#define ICMB_CNT	32
 206
 207/*
 208 *  Scb's are shared by all active adapters.  So, if they all become busy,
 209 *  callers may be made to wait in alloc_scbs for them to free.  That can
 210 *  be avoided by setting MAX_SCBS to NUM_CONFIG * WD7000_Q.  If you'd
 211 *  rather conserve memory, use a smaller number (> 0, of course) - things
 212 *  will should still work OK.
 213 */
 214#define MAX_SCBS        32
 215
 216/*
 217 *  In this version, sg_tablesize now defaults to WD7000_SG, and will
 218 *  be set to SG_NONE for older boards.  This is the reverse of the
 219 *  previous default, and was changed so that the driver-level
 220 *  scsi_host_template would reflect the driver's support for scatter/
 221 *  gather.
 222 *
 223 *  Also, it has been reported that boards at Revision 6 support scatter/
 224 *  gather, so the new definition of an "older" board has been changed
 225 *  accordingly.
 226 */
 227#define WD7000_Q	16
 228#define WD7000_SG	16
 229
 230
 231/*
 232 *  WD7000-specific mailbox structure
 233 *
 234 */
 235typedef volatile struct mailbox {
 236	unchar status;
 237	unchar scbptr[3];	/* SCSI-style - MSB first (big endian) */
 238} Mailbox;
 239
 240/*
 241 *  This structure should contain all per-adapter global data.  I.e., any
 242 *  new global per-adapter data should put in here.
 243 */
 244typedef struct adapter {
 245	struct Scsi_Host *sh;	/* Pointer to Scsi_Host structure    */
 246	int iobase;		/* This adapter's I/O base address   */
 247	int irq;		/* This adapter's IRQ level          */
 248	int dma;		/* This adapter's DMA channel        */
 249	int int_counter;	/* This adapter's interrupt counter  */
 250	int bus_on;		/* This adapter's BUS_ON time        */
 251	int bus_off;		/* This adapter's BUS_OFF time       */
 252	struct {		/* This adapter's mailboxes          */
 253		Mailbox ogmb[OGMB_CNT];	/* Outgoing mailboxes                */
 254		Mailbox icmb[ICMB_CNT];	/* Incoming mailboxes                */
 255	} mb;
 256	int next_ogmb;		/* to reduce contention at mailboxes */
 257	unchar control;		/* shadows CONTROL port value        */
 258	unchar rev1, rev2;	/* filled in by wd7000_revision      */
 259} Adapter;
 260
 261/*
 262 * (linear) base address for ROM BIOS
 263 */
 264static const long wd7000_biosaddr[] = {
 265	0xc0000, 0xc2000, 0xc4000, 0xc6000, 0xc8000, 0xca000, 0xcc000, 0xce000,
 266	0xd0000, 0xd2000, 0xd4000, 0xd6000, 0xd8000, 0xda000, 0xdc000, 0xde000
 267};
 268#define NUM_ADDRS ARRAY_SIZE(wd7000_biosaddr)
 269
 270static const unsigned short wd7000_iobase[] = {
 271	0x0300, 0x0308, 0x0310, 0x0318, 0x0320, 0x0328, 0x0330, 0x0338,
 272	0x0340, 0x0348, 0x0350, 0x0358, 0x0360, 0x0368, 0x0370, 0x0378,
 273	0x0380, 0x0388, 0x0390, 0x0398, 0x03a0, 0x03a8, 0x03b0, 0x03b8,
 274	0x03c0, 0x03c8, 0x03d0, 0x03d8, 0x03e0, 0x03e8, 0x03f0, 0x03f8
 275};
 276#define NUM_IOPORTS ARRAY_SIZE(wd7000_iobase)
 277
 278static const short wd7000_irq[] = { 3, 4, 5, 7, 9, 10, 11, 12, 14, 15 };
 279#define NUM_IRQS ARRAY_SIZE(wd7000_irq)
 280
 281static const short wd7000_dma[] = { 5, 6, 7 };
 282#define NUM_DMAS ARRAY_SIZE(wd7000_dma)
 283
 284/*
 285 * The following is set up by wd7000_detect, and used thereafter for
 286 * proc and other global ookups
 287 */
 288
 289#define UNITS	8
 290static struct Scsi_Host *wd7000_host[UNITS];
 291
 292#define BUS_ON    64		/* x 125ns = 8000ns (BIOS default) */
 293#define BUS_OFF   15		/* x 125ns = 1875ns (BIOS default) */
 294
 295/*
 296 *  Standard Adapter Configurations - used by wd7000_detect
 297 */
 298typedef struct {
 299	short irq;		/* IRQ level                                  */
 300	short dma;		/* DMA channel                                */
 301	unsigned iobase;	/* I/O base address                           */
 302	short bus_on;		/* Time that WD7000 spends on the AT-bus when */
 303	/* transferring data. BIOS default is 8000ns. */
 304	short bus_off;		/* Time that WD7000 spends OFF THE BUS after  */
 305	/* while it is transferring data.             */
 306	/* BIOS default is 1875ns                     */
 307} Config;
 308
 309/*
 310 * Add here your configuration...
 311 */
 312static Config configs[] = {
 313	{15, 6, 0x350, BUS_ON, BUS_OFF},	/* defaults for single adapter */
 314	{11, 5, 0x320, BUS_ON, BUS_OFF},	/* defaults for second adapter */
 315	{7, 6, 0x350, BUS_ON, BUS_OFF},	/* My configuration (Zaga)     */
 316	{-1, -1, 0x0, BUS_ON, BUS_OFF}	/* Empty slot                  */
 317};
 318#define NUM_CONFIGS ARRAY_SIZE(configs)
 319
 320/*
 321 *  The following list defines strings to look for in the BIOS that identify
 322 *  it as the WD7000-FASST2 SST BIOS.  I suspect that something should be
 323 *  added for the Future Domain version.
 324 */
 325typedef struct signature {
 326	const char *sig;	/* String to look for            */
 327	unsigned long ofs;	/* offset from BIOS base address */
 328	unsigned len;		/* length of string              */
 329} Signature;
 330
 331static const Signature signatures[] = {
 332	{"SSTBIOS", 0x0000d, 7}	/* "SSTBIOS" @ offset 0x0000d */
 333};
 334#define NUM_SIGNATURES ARRAY_SIZE(signatures)
 335
 336
 337/*
 338 *  I/O Port Offsets and Bit Definitions
 339 *  4 addresses are used.  Those not defined here are reserved.
 340 */
 341#define ASC_STAT        0	/* Status,  Read          */
 342#define ASC_COMMAND     0	/* Command, Write         */
 343#define ASC_INTR_STAT   1	/* Interrupt Status, Read */
 344#define ASC_INTR_ACK    1	/* Acknowledge, Write     */
 345#define ASC_CONTROL     2	/* Control, Write         */
 346
 347/*
 348 * ASC Status Port
 349 */
 350#define INT_IM		0x80	/* Interrupt Image Flag           */
 351#define CMD_RDY		0x40	/* Command Port Ready             */
 352#define CMD_REJ		0x20	/* Command Port Byte Rejected     */
 353#define ASC_INIT        0x10	/* ASC Initialized Flag           */
 354#define ASC_STATMASK    0xf0	/* The lower 4 Bytes are reserved */
 355
 356/*
 357 * COMMAND opcodes
 358 *
 359 *  Unfortunately, I have no idea how to properly use some of these commands,
 360 *  as the OEM manual does not make it clear.  I have not been able to use
 361 *  enable/disable unsolicited interrupts or the reset commands with any
 362 *  discernible effect whatsoever.  I think they may be related to certain
 363 *  ICB commands, but again, the OEM manual doesn't make that clear.
 364 */
 365#define NO_OP             0	/* NO-OP toggles CMD_RDY bit in ASC_STAT  */
 366#define INITIALIZATION    1	/* initialization (10 bytes)              */
 367#define DISABLE_UNS_INTR  2	/* disable unsolicited interrupts         */
 368#define ENABLE_UNS_INTR   3	/* enable unsolicited interrupts          */
 369#define INTR_ON_FREE_OGMB 4	/* interrupt on free OGMB                 */
 370#define SOFT_RESET        5	/* SCSI bus soft reset                    */
 371#define HARD_RESET_ACK    6	/* SCSI bus hard reset acknowledge        */
 372#define START_OGMB        0x80	/* start command in OGMB (n)              */
 373#define SCAN_OGMBS        0xc0	/* start multiple commands, signature (n) */
 374				/*    where (n) = lower 6 bits            */
 375/*
 376 * For INITIALIZATION:
 377 */
 378typedef struct initCmd {
 379	unchar op;		/* command opcode (= 1)                    */
 380	unchar ID;		/* Adapter's SCSI ID                       */
 381	unchar bus_on;		/* Bus on time, x 125ns (see below)        */
 382	unchar bus_off;		/* Bus off time, ""         ""             */
 383	unchar rsvd;		/* Reserved                                */
 384	unchar mailboxes[3];	/* Address of Mailboxes, MSB first         */
 385	unchar ogmbs;		/* Number of outgoing MBs, max 64, 0,1 = 1 */
 386	unchar icmbs;		/* Number of incoming MBs,   ""       ""   */
 387} InitCmd;
 388
 389/*
 390 * Interrupt Status Port - also returns diagnostic codes at ASC reset
 391 *
 392 * if msb is zero, the lower bits are diagnostic status
 393 * Diagnostics:
 394 * 01   No diagnostic error occurred
 395 * 02   RAM failure
 396 * 03   FIFO R/W failed
 397 * 04   SBIC register read/write failed
 398 * 05   Initialization D-FF failed
 399 * 06   Host IRQ D-FF failed
 400 * 07   ROM checksum error
 401 * Interrupt status (bitwise):
 402 * 10NNNNNN   outgoing mailbox NNNNNN is free
 403 * 11NNNNNN   incoming mailbox NNNNNN needs service
 404 */
 405#define MB_INTR    0xC0		/* Mailbox Service possible/required */
 406#define IMB_INTR   0x40		/* 1 Incoming / 0 Outgoing           */
 407#define MB_MASK    0x3f		/* mask for mailbox number           */
 408
 409/*
 410 * CONTROL port bits
 411 */
 412#define INT_EN     0x08		/* Interrupt Enable */
 413#define DMA_EN     0x04		/* DMA Enable       */
 414#define SCSI_RES   0x02		/* SCSI Reset       */
 415#define ASC_RES    0x01		/* ASC Reset        */
 416
 417/*
 418 * Driver data structures:
 419 *   - mb and scbs are required for interfacing with the host adapter.
 420 *     An SCB has extra fields not visible to the adapter; mb's
 421 *     _cannot_ do this, since the adapter assumes they are contiguous in
 422 *     memory, 4 bytes each, with ICMBs following OGMBs, and uses this fact
 423 *     to access them.
 424 *   - An icb is for host-only (non-SCSI) commands.  ICBs are 16 bytes each;
 425 *     the additional bytes are used only by the driver.
 426 *   - For now, a pool of SCBs are kept in global storage by this driver,
 427 *     and are allocated and freed as needed.
 428 *
 429 *  The 7000-FASST2 marks OGMBs empty as soon as it has _started_ a command,
 430 *  not when it has finished.  Since the SCB must be around for completion,
 431 *  problems arise when SCBs correspond to OGMBs, which may be reallocated
 432 *  earlier (or delayed unnecessarily until a command completes).
 433 *  Mailboxes are used as transient data structures, simply for
 434 *  carrying SCB addresses to/from the 7000-FASST2.
 435 *
 436 *  Note also since SCBs are not "permanently" associated with mailboxes,
 437 *  there is no need to keep a global list of scsi_cmnd pointers indexed
 438 *  by OGMB.   Again, SCBs reference their scsi_cmnds directly, so mailbox
 439 *  indices need not be involved.
 440 */
 441
 442/*
 443 *  WD7000-specific scatter/gather element structure
 444 */
 445typedef struct sgb {
 446	unchar len[3];
 447	unchar ptr[3];		/* Also SCSI-style - MSB first */
 448} Sgb;
 449
 450typedef struct scb {		/* Command Control Block 5.4.1               */
 451	unchar op;		/* Command Control Block Operation Code      */
 452	unchar idlun;		/* op=0,2:Target Id, op=1:Initiator Id       */
 453	/* Outbound data transfer, length is checked */
 454	/* Inbound data transfer, length is checked  */
 455	/* Logical Unit Number                       */
 456	unchar cdb[12];		/* SCSI Command Block                        */
 457	volatile unchar status;	/* SCSI Return Status                        */
 458	volatile unchar vue;	/* Vendor Unique Error Code                  */
 459	unchar maxlen[3];	/* Maximum Data Transfer Length              */
 460	unchar dataptr[3];	/* SCSI Data Block Pointer                   */
 461	unchar linkptr[3];	/* Next Command Link Pointer                 */
 462	unchar direc;		/* Transfer Direction                        */
 463	unchar reserved2[6];	/* SCSI Command Descriptor Block             */
 464	/* end of hardware SCB                       */
 465	struct scsi_cmnd *SCpnt;/* scsi_cmnd using this SCB                  */
 466	Sgb sgb[WD7000_SG];	/* Scatter/gather list for this SCB          */
 467	Adapter *host;		/* host adapter                              */
 468	struct scb *next;	/* for lists of scbs                         */
 469} Scb;
 470
 471/*
 472 *  This driver is written to allow host-only commands to be executed.
 473 *  These use a 16-byte block called an ICB.  The format is extended by the
 474 *  driver to 18 bytes, to support the status returned in the ICMB and
 475 *  an execution phase code.
 476 *
 477 *  There are other formats besides these; these are the ones I've tried
 478 *  to use.  Formats for some of the defined ICB opcodes are not defined
 479 *  (notably, get/set unsolicited interrupt status) in my copy of the OEM
 480 *  manual, and others are ambiguous/hard to follow.
 481 */
 482#define ICB_OP_MASK           0x80	/* distinguishes scbs from icbs        */
 483#define ICB_OP_OPEN_RBUF      0x80	/* open receive buffer                 */
 484#define ICB_OP_RECV_CMD       0x81	/* receive command from initiator      */
 485#define ICB_OP_RECV_DATA      0x82	/* receive data from initiator         */
 486#define ICB_OP_RECV_SDATA     0x83	/* receive data with status from init. */
 487#define ICB_OP_SEND_DATA      0x84	/* send data with status to initiator  */
 488#define ICB_OP_SEND_STAT      0x86	/* send command status to initiator    */
 489					/* 0x87 is reserved                    */
 490#define ICB_OP_READ_INIT      0x88	/* read initialization bytes           */
 491#define ICB_OP_READ_ID        0x89	/* read adapter's SCSI ID              */
 492#define ICB_OP_SET_UMASK      0x8A	/* set unsolicited interrupt mask      */
 493#define ICB_OP_GET_UMASK      0x8B	/* read unsolicited interrupt mask     */
 494#define ICB_OP_GET_REVISION   0x8C	/* read firmware revision level        */
 495#define ICB_OP_DIAGNOSTICS    0x8D	/* execute diagnostics                 */
 496#define ICB_OP_SET_EPARMS     0x8E	/* set execution parameters            */
 497#define ICB_OP_GET_EPARMS     0x8F	/* read execution parameters           */
 498
 499typedef struct icbRecvCmd {
 500	unchar op;
 501	unchar IDlun;		/* Initiator SCSI ID/lun     */
 502	unchar len[3];		/* command buffer length     */
 503	unchar ptr[3];		/* command buffer address    */
 504	unchar rsvd[7];		/* reserved                  */
 505	volatile unchar vue;	/* vendor-unique error code  */
 506	volatile unchar status;	/* returned (icmb) status    */
 507	volatile unchar phase;	/* used by interrupt handler */
 508} IcbRecvCmd;
 509
 510typedef struct icbSendStat {
 511	unchar op;
 512	unchar IDlun;		/* Target SCSI ID/lun                  */
 513	unchar stat;		/* (outgoing) completion status byte 1 */
 514	unchar rsvd[12];	/* reserved                            */
 515	volatile unchar vue;	/* vendor-unique error code            */
 516	volatile unchar status;	/* returned (icmb) status              */
 517	volatile unchar phase;	/* used by interrupt handler           */
 518} IcbSendStat;
 519
 520typedef struct icbRevLvl {
 521	unchar op;
 522	volatile unchar primary;	/* primary revision level (returned)   */
 523	volatile unchar secondary;	/* secondary revision level (returned) */
 524	unchar rsvd[12];	/* reserved                            */
 525	volatile unchar vue;	/* vendor-unique error code            */
 526	volatile unchar status;	/* returned (icmb) status              */
 527	volatile unchar phase;	/* used by interrupt handler           */
 528} IcbRevLvl;
 529
 530typedef struct icbUnsMask {	/* I'm totally guessing here */
 531	unchar op;
 532	volatile unchar mask[14];	/* mask bits                 */
 533#if 0
 534	unchar rsvd[12];	/* reserved                  */
 535#endif
 536	volatile unchar vue;	/* vendor-unique error code  */
 537	volatile unchar status;	/* returned (icmb) status    */
 538	volatile unchar phase;	/* used by interrupt handler */
 539} IcbUnsMask;
 540
 541typedef struct icbDiag {
 542	unchar op;
 543	unchar type;		/* diagnostics type code (0-3) */
 544	unchar len[3];		/* buffer length               */
 545	unchar ptr[3];		/* buffer address              */
 546	unchar rsvd[7];		/* reserved                    */
 547	volatile unchar vue;	/* vendor-unique error code    */
 548	volatile unchar status;	/* returned (icmb) status      */
 549	volatile unchar phase;	/* used by interrupt handler   */
 550} IcbDiag;
 551
 552#define ICB_DIAG_POWERUP   0	/* Power-up diags only       */
 553#define ICB_DIAG_WALKING   1	/* walking 1's pattern       */
 554#define ICB_DIAG_DMA       2	/* DMA - system memory diags */
 555#define ICB_DIAG_FULL      3	/* do both 1 & 2             */
 556
 557typedef struct icbParms {
 558	unchar op;
 559	unchar rsvd1;		/* reserved                  */
 560	unchar len[3];		/* parms buffer length       */
 561	unchar ptr[3];		/* parms buffer address      */
 562	unchar idx[2];		/* index (MSB-LSB)           */
 563	unchar rsvd2[5];	/* reserved                  */
 564	volatile unchar vue;	/* vendor-unique error code  */
 565	volatile unchar status;	/* returned (icmb) status    */
 566	volatile unchar phase;	/* used by interrupt handler */
 567} IcbParms;
 568
 569typedef struct icbAny {
 570	unchar op;
 571	unchar data[14];	/* format-specific data      */
 572	volatile unchar vue;	/* vendor-unique error code  */
 573	volatile unchar status;	/* returned (icmb) status    */
 574	volatile unchar phase;	/* used by interrupt handler */
 575} IcbAny;
 576
 577typedef union icb {
 578	unchar op;		/* ICB opcode                     */
 579	IcbRecvCmd recv_cmd;	/* format for receive command     */
 580	IcbSendStat send_stat;	/* format for send status         */
 581	IcbRevLvl rev_lvl;	/* format for get revision level  */
 582	IcbDiag diag;		/* format for execute diagnostics */
 583	IcbParms eparms;	/* format for get/set exec parms  */
 584	IcbAny icb;		/* generic format                 */
 585	unchar data[18];
 586} Icb;
 587
 588#ifdef MODULE
 589static char *wd7000;
 590module_param(wd7000, charp, 0);
 591#endif
 592
 593/*
 594 *  Driver SCB structure pool.
 595 *
 596 *  The SCBs declared here are shared by all host adapters; hence, this
 597 *  structure is not part of the Adapter structure.
 598 */
 599static Scb scbs[MAX_SCBS];
 600static Scb *scbfree;		/* free list         */
 601static int freescbs = MAX_SCBS;	/* free list counter */
 602static spinlock_t scbpool_lock;	/* guards the scb free list and count */
 603
 604/*
 605 *  END of data/declarations - code follows.
 606 */
 607static void __init setup_error(char *mesg, int *ints)
 608{
 609	if (ints[0] == 3)
 610		printk(KERN_ERR "wd7000_setup: \"wd7000=%d,%d,0x%x\" -> %s\n", ints[1], ints[2], ints[3], mesg);
 611	else if (ints[0] == 4)
 612		printk(KERN_ERR "wd7000_setup: \"wd7000=%d,%d,0x%x,%d\" -> %s\n", ints[1], ints[2], ints[3], ints[4], mesg);
 613	else
 614		printk(KERN_ERR "wd7000_setup: \"wd7000=%d,%d,0x%x,%d,%d\" -> %s\n", ints[1], ints[2], ints[3], ints[4], ints[5], mesg);
 615}
 616
 617
 618/*
 619 * Note: You can now set these options from the kernel's "command line".
 620 * The syntax is:
 621 *
 622 *     wd7000=<IRQ>,<DMA>,<IO>[,<BUS_ON>[,<BUS_OFF>]]
 623 *
 624 * , where BUS_ON and BUS_OFF are in nanoseconds. BIOS default values
 625 * are 8000ns for BUS_ON and 1875ns for BUS_OFF.
 626 * eg:
 627 *     wd7000=7,6,0x350
 628 *
 629 * will configure the driver for a WD-7000 controller
 630 * using IRQ 15 with a DMA channel 6, at IO base address 0x350.
 631 */
 632static int __init wd7000_setup(char *str)
 633{
 634	static short wd7000_card_num;	/* .bss will zero this */
 635	short i;
 636	int ints[6];
 637
 638	(void) get_options(str, ARRAY_SIZE(ints), ints);
 639
 640	if (wd7000_card_num >= NUM_CONFIGS) {
 641		printk(KERN_ERR "%s: Too many \"wd7000=\" configurations in " "command line!\n", __func__);
 642		return 0;
 643	}
 644
 645	if ((ints[0] < 3) || (ints[0] > 5)) {
 646		printk(KERN_ERR "%s: Error in command line!  " "Usage: wd7000=<IRQ>,<DMA>,IO>[,<BUS_ON>" "[,<BUS_OFF>]]\n", __func__);
 647	} else {
 648		for (i = 0; i < NUM_IRQS; i++)
 649			if (ints[1] == wd7000_irq[i])
 650				break;
 651
 652		if (i == NUM_IRQS) {
 653			setup_error("invalid IRQ.", ints);
 654			return 0;
 655		} else
 656			configs[wd7000_card_num].irq = ints[1];
 657
 658		for (i = 0; i < NUM_DMAS; i++)
 659			if (ints[2] == wd7000_dma[i])
 660				break;
 661
 662		if (i == NUM_DMAS) {
 663			setup_error("invalid DMA channel.", ints);
 664			return 0;
 665		} else
 666			configs[wd7000_card_num].dma = ints[2];
 667
 668		for (i = 0; i < NUM_IOPORTS; i++)
 669			if (ints[3] == wd7000_iobase[i])
 670				break;
 671
 672		if (i == NUM_IOPORTS) {
 673			setup_error("invalid I/O base address.", ints);
 674			return 0;
 675		} else
 676			configs[wd7000_card_num].iobase = ints[3];
 677
 678		if (ints[0] > 3) {
 679			if ((ints[4] < 500) || (ints[4] > 31875)) {
 680				setup_error("BUS_ON value is out of range (500" " to 31875 nanoseconds)!", ints);
 681				configs[wd7000_card_num].bus_on = BUS_ON;
 682			} else
 683				configs[wd7000_card_num].bus_on = ints[4] / 125;
 684		} else
 685			configs[wd7000_card_num].bus_on = BUS_ON;
 686
 687		if (ints[0] > 4) {
 688			if ((ints[5] < 500) || (ints[5] > 31875)) {
 689				setup_error("BUS_OFF value is out of range (500" " to 31875 nanoseconds)!", ints);
 690				configs[wd7000_card_num].bus_off = BUS_OFF;
 691			} else
 692				configs[wd7000_card_num].bus_off = ints[5] / 125;
 693		} else
 694			configs[wd7000_card_num].bus_off = BUS_OFF;
 695
 696		if (wd7000_card_num) {
 697			for (i = 0; i < (wd7000_card_num - 1); i++) {
 698				int j = i + 1;
 699
 700				for (; j < wd7000_card_num; j++)
 701					if (configs[i].irq == configs[j].irq) {
 702						setup_error("duplicated IRQ!", ints);
 703						return 0;
 704					}
 705				if (configs[i].dma == configs[j].dma) {
 706					setup_error("duplicated DMA " "channel!", ints);
 707					return 0;
 708				}
 709				if (configs[i].iobase == configs[j].iobase) {
 710					setup_error("duplicated I/O " "base address!", ints);
 711					return 0;
 712				}
 713			}
 714		}
 715
 716		dprintk(KERN_DEBUG "wd7000_setup: IRQ=%d, DMA=%d, I/O=0x%x, "
 717			"BUS_ON=%dns, BUS_OFF=%dns\n", configs[wd7000_card_num].irq, configs[wd7000_card_num].dma, configs[wd7000_card_num].iobase, configs[wd7000_card_num].bus_on * 125, configs[wd7000_card_num].bus_off * 125);
 718
 719		wd7000_card_num++;
 720	}
 721	return 1;
 722}
 723
 724__setup("wd7000=", wd7000_setup);
 725
 726static inline void any2scsi(unchar * scsi, int any)
 727{
 728	*scsi++ = (unsigned)any >> 16;
 729	*scsi++ = (unsigned)any >> 8;
 730	*scsi++ = any;
 731}
 732
 733static inline int scsi2int(unchar * scsi)
 734{
 735	return (scsi[0] << 16) | (scsi[1] << 8) | scsi[2];
 736}
 737
 738static inline void wd7000_enable_intr(Adapter * host)
 739{
 740	host->control |= INT_EN;
 741	outb(host->control, host->iobase + ASC_CONTROL);
 742}
 743
 744
 745static inline void wd7000_enable_dma(Adapter * host)
 746{
 747	unsigned long flags;
 748	host->control |= DMA_EN;
 749	outb(host->control, host->iobase + ASC_CONTROL);
 750
 751	flags = claim_dma_lock();
 752	set_dma_mode(host->dma, DMA_MODE_CASCADE);
 753	enable_dma(host->dma);
 754	release_dma_lock(flags);
 755
 756}
 757
 758
 759#define WAITnexttimeout 200	/* 2 seconds */
 760
 761static inline short WAIT(unsigned port, unsigned mask, unsigned allof, unsigned noneof)
 762{
 763	unsigned WAITbits;
 764	unsigned long WAITtimeout = jiffies + WAITnexttimeout;
 765
 766	while (time_before_eq(jiffies, WAITtimeout)) {
 767		WAITbits = inb(port) & mask;
 768
 769		if (((WAITbits & allof) == allof) && ((WAITbits & noneof) == 0))
 770			return (0);
 771	}
 772
 773	return (1);
 774}
 775
 776
 777static inline int command_out(Adapter * host, unchar * cmd, int len)
 778{
 779	if (!WAIT(host->iobase + ASC_STAT, ASC_STATMASK, CMD_RDY, 0)) {
 780		while (len--) {
 781			do {
 782				outb(*cmd, host->iobase + ASC_COMMAND);
 783				WAIT(host->iobase + ASC_STAT, ASC_STATMASK, CMD_RDY, 0);
 784			} while (inb(host->iobase + ASC_STAT) & CMD_REJ);
 785
 786			cmd++;
 787		}
 788
 789		return (1);
 790	}
 791
 792	printk(KERN_WARNING "wd7000 command_out: WAIT failed(%d)\n", len + 1);
 793
 794	return (0);
 795}
 796
 797
 798/*
 799 *  This version of alloc_scbs is in preparation for supporting multiple
 800 *  commands per lun and command chaining, by queueing pending commands.
 801 *  We will need to allocate Scbs in blocks since they will wait to be
 802 *  executed so there is the possibility of deadlock otherwise.
 803 *  Also, to keep larger requests from being starved by smaller requests,
 804 *  we limit access to this routine with an internal busy flag, so that
 805 *  the satisfiability of a request is not dependent on the size of the
 806 *  request.
 807 */
 808static inline Scb *alloc_scbs(struct Scsi_Host *host, int needed)
 809{
 810	Scb *scb, *p = NULL;
 811	unsigned long flags;
 812	unsigned long timeout = jiffies + WAITnexttimeout;
 813	unsigned long now;
 814	int i;
 815
 816	if (needed <= 0)
 817		return (NULL);	/* sanity check */
 818
 819	spin_unlock_irq(host->host_lock);
 820
 821      retry:
 822	while (freescbs < needed) {
 823		timeout = jiffies + WAITnexttimeout;
 824		do {
 825			/* FIXME: can we actually just yield here ?? */
 826			for (now = jiffies; now == jiffies;)
 827				cpu_relax();	/* wait a jiffy */
 828		} while (freescbs < needed && time_before_eq(jiffies, timeout));
 829		/*
 830		 *  If we get here with enough free Scbs, we can take them.
 831		 *  Otherwise, we timed out and didn't get enough.
 832		 */
 833		if (freescbs < needed) {
 834			printk(KERN_ERR "wd7000: can't get enough free SCBs.\n");
 835			return (NULL);
 836		}
 837	}
 838
 839	/* Take the lock, then check we didn't get beaten, if so try again */
 840	spin_lock_irqsave(&scbpool_lock, flags);
 841	if (freescbs < needed) {
 842		spin_unlock_irqrestore(&scbpool_lock, flags);
 843		goto retry;
 844	}
 845
 846	scb = scbfree;
 847	freescbs -= needed;
 848	for (i = 0; i < needed; i++) {
 849		p = scbfree;
 850		scbfree = p->next;
 851	}
 852	p->next = NULL;
 853
 854	spin_unlock_irqrestore(&scbpool_lock, flags);
 855
 856	spin_lock_irq(host->host_lock);
 857	return (scb);
 858}
 859
 860
 861static inline void free_scb(Scb * scb)
 862{
 863	unsigned long flags;
 864
 865	spin_lock_irqsave(&scbpool_lock, flags);
 866
 867	memset(scb, 0, sizeof(Scb));
 868	scb->next = scbfree;
 869	scbfree = scb;
 870	freescbs++;
 871
 872	spin_unlock_irqrestore(&scbpool_lock, flags);
 873}
 874
 875
 876static inline void init_scbs(void)
 877{
 878	int i;
 879
 880	spin_lock_init(&scbpool_lock);
 881
 882	/* This is only ever called before the SCB pool is active */
 883
 884	scbfree = &(scbs[0]);
 885	memset(scbs, 0, sizeof(scbs));
 886	for (i = 0; i < MAX_SCBS - 1; i++) {
 887		scbs[i].next = &(scbs[i + 1]);
 888		scbs[i].SCpnt = NULL;
 889	}
 890	scbs[MAX_SCBS - 1].next = NULL;
 891	scbs[MAX_SCBS - 1].SCpnt = NULL;
 892}
 893
 894
 895static int mail_out(Adapter * host, Scb * scbptr)
 896/*
 897 *  Note: this can also be used for ICBs; just cast to the parm type.
 898 */
 899{
 900	int i, ogmb;
 901	unsigned long flags;
 902	unchar start_ogmb;
 903	Mailbox *ogmbs = host->mb.ogmb;
 904	int *next_ogmb = &(host->next_ogmb);
 905
 906	dprintk("wd7000_mail_out: 0x%06lx", (long) scbptr);
 907
 908	/* We first look for a free outgoing mailbox */
 909	spin_lock_irqsave(host->sh->host_lock, flags);
 910	ogmb = *next_ogmb;
 911	for (i = 0; i < OGMB_CNT; i++) {
 912		if (ogmbs[ogmb].status == 0) {
 913			dprintk(" using OGMB 0x%x", ogmb);
 914			ogmbs[ogmb].status = 1;
 915			any2scsi((unchar *) ogmbs[ogmb].scbptr, (int) scbptr);
 916
 917			*next_ogmb = (ogmb + 1) % OGMB_CNT;
 918			break;
 919		} else
 920			ogmb = (ogmb + 1) % OGMB_CNT;
 921	}
 922	spin_unlock_irqrestore(host->sh->host_lock, flags);
 923
 924	dprintk(", scb is 0x%06lx", (long) scbptr);
 925
 926	if (i >= OGMB_CNT) {
 927		/*
 928		 *  Alternatively, we might issue the "interrupt on free OGMB",
 929		 *  and sleep, but it must be ensured that it isn't the init
 930		 *  task running.  Instead, this version assumes that the caller
 931		 *  will be persistent, and try again.  Since it's the adapter
 932		 *  that marks OGMB's free, waiting even with interrupts off
 933		 *  should work, since they are freed very quickly in most cases.
 934		 */
 935		dprintk(", no free OGMBs.\n");
 936		return (0);
 937	}
 938
 939	wd7000_enable_intr(host);
 940
 941	start_ogmb = START_OGMB | ogmb;
 942	command_out(host, &start_ogmb, 1);
 943
 944	dprintk(", awaiting interrupt.\n");
 945
 946	return (1);
 947}
 948
 949
 950static int make_code(unsigned hosterr, unsigned scsierr)
 951{
 952#ifdef WD7000_DEBUG
 953	int in_error = hosterr;
 954#endif
 955
 956	switch ((hosterr >> 8) & 0xff) {
 957	case 0:		/* Reserved */
 958		hosterr = DID_ERROR;
 959		break;
 960	case 1:		/* Command Complete, no errors */
 961		hosterr = DID_OK;
 962		break;
 963	case 2:		/* Command complete, error logged in scb status (scsierr) */
 964		hosterr = DID_OK;
 965		break;
 966	case 4:		/* Command failed to complete - timeout */
 967		hosterr = DID_TIME_OUT;
 968		break;
 969	case 5:		/* Command terminated; Bus reset by external device */
 970		hosterr = DID_RESET;
 971		break;
 972	case 6:		/* Unexpected Command Received w/ host as target */
 973		hosterr = DID_BAD_TARGET;
 974		break;
 975	case 80:		/* Unexpected Reselection */
 976	case 81:		/* Unexpected Selection */
 977		hosterr = DID_BAD_INTR;
 978		break;
 979	case 82:		/* Abort Command Message  */
 980		hosterr = DID_ABORT;
 981		break;
 982	case 83:		/* SCSI Bus Software Reset */
 983	case 84:		/* SCSI Bus Hardware Reset */
 984		hosterr = DID_RESET;
 985		break;
 986	default:		/* Reserved */
 987		hosterr = DID_ERROR;
 988	}
 989#ifdef WD7000_DEBUG
 990	if (scsierr || hosterr)
 991		dprintk("\nSCSI command error: SCSI 0x%02x host 0x%04x return %d\n", scsierr, in_error, hosterr);
 992#endif
 993	return (scsierr | (hosterr << 16));
 994}
 995
 996#define wd7000_intr_ack(host)   outb (0, host->iobase + ASC_INTR_ACK)
 997
 998
 999static irqreturn_t wd7000_intr(int irq, void *dev_id)
1000{
1001	Adapter *host = (Adapter *) dev_id;
1002	int flag, icmb, errstatus, icmb_status;
1003	int host_error, scsi_error;
1004	Scb *scb;	/* for SCSI commands */
1005	IcbAny *icb;	/* for host commands */
1006	struct scsi_cmnd *SCpnt;
1007	Mailbox *icmbs = host->mb.icmb;
1008	unsigned long flags;
1009
1010	spin_lock_irqsave(host->sh->host_lock, flags);
1011	host->int_counter++;
1012
1013	dprintk("wd7000_intr: irq = %d, host = 0x%06lx\n", irq, (long) host);
1014
1015	flag = inb(host->iobase + ASC_INTR_STAT);
1016
1017	dprintk("wd7000_intr: intr stat = 0x%02x\n", flag);
1018
1019	if (!(inb(host->iobase + ASC_STAT) & INT_IM)) {
1020		/* NB: these are _very_ possible if IRQ 15 is being used, since
1021		 * it's the "garbage collector" on the 2nd 8259 PIC.  Specifically,
1022		 * any interrupt signal into the 8259 which can't be identified
1023		 * comes out as 7 from the 8259, which is 15 to the host.  Thus, it
1024		 * is a good thing the WD7000 has an interrupt status port, so we
1025		 * can sort these out.  Otherwise, electrical noise and other such
1026		 * problems would be indistinguishable from valid interrupts...
1027		 */
1028		dprintk("wd7000_intr: phantom interrupt...\n");
1029		goto ack;
1030	}
1031
1032	if (!(flag & MB_INTR))
1033		goto ack;
1034
1035	/* The interrupt is for a mailbox */
1036	if (!(flag & IMB_INTR)) {
1037		dprintk("wd7000_intr: free outgoing mailbox\n");
1038		/*
1039		 * If sleep_on() and the "interrupt on free OGMB" command are
1040		 * used in mail_out(), wake_up() should correspondingly be called
1041		 * here.  For now, we don't need to do anything special.
1042		 */
1043		goto ack;
1044	}
1045
1046	/* The interrupt is for an incoming mailbox */
1047	icmb = flag & MB_MASK;
1048	icmb_status = icmbs[icmb].status;
1049	if (icmb_status & 0x80) {	/* unsolicited - result in ICMB */
1050		dprintk("wd7000_intr: unsolicited interrupt 0x%02x\n", icmb_status);
1051		goto ack;
1052	}
1053
1054	/* Aaaargh! (Zaga) */
1055	scb = isa_bus_to_virt(scsi2int((unchar *) icmbs[icmb].scbptr));
1056	icmbs[icmb].status = 0;
1057	if (scb->op & ICB_OP_MASK) {	/* an SCB is done */
1058		icb = (IcbAny *) scb;
1059		icb->status = icmb_status;
1060		icb->phase = 0;
1061		goto ack;
1062	}
1063
1064	SCpnt = scb->SCpnt;
1065	if (--(SCpnt->SCp.phase) <= 0) {	/* all scbs are done */
1066		host_error = scb->vue | (icmb_status << 8);
1067		scsi_error = scb->status;
1068		errstatus = make_code(host_error, scsi_error);
1069		SCpnt->result = errstatus;
1070
1071		free_scb(scb);
1072
1073		SCpnt->scsi_done(SCpnt);
1074	}
1075
1076 ack:
1077	dprintk("wd7000_intr: return from interrupt handler\n");
1078	wd7000_intr_ack(host);
1079
1080	spin_unlock_irqrestore(host->sh->host_lock, flags);
1081	return IRQ_HANDLED;
1082}
1083
1084static int wd7000_queuecommand_lck(struct scsi_cmnd *SCpnt,
1085		void (*done)(struct scsi_cmnd *))
1086{
1087	Scb *scb;
1088	Sgb *sgb;
1089	unchar *cdb = (unchar *) SCpnt->cmnd;
1090	unchar idlun;
1091	short cdblen;
1092	int nseg;
1093	Adapter *host = (Adapter *) SCpnt->device->host->hostdata;
1094
1095	cdblen = SCpnt->cmd_len;
1096	idlun = ((SCpnt->device->id << 5) & 0xe0) | (SCpnt->device->lun & 7);
1097	SCpnt->scsi_done = done;
1098	SCpnt->SCp.phase = 1;
1099	scb = alloc_scbs(SCpnt->device->host, 1);
1100	scb->idlun = idlun;
1101	memcpy(scb->cdb, cdb, cdblen);
1102	scb->direc = 0x40;	/* Disable direction check */
1103
1104	scb->SCpnt = SCpnt;	/* so we can find stuff later */
1105	SCpnt->host_scribble = (unchar *) scb;
1106	scb->host = host;
1107
1108	nseg = scsi_sg_count(SCpnt);
1109	if (nseg > 1) {
1110		struct scatterlist *sg;
1111		unsigned i;
1112
1113		dprintk("Using scatter/gather with %d elements.\n", nseg);
1114
1115		sgb = scb->sgb;
1116		scb->op = 1;
1117		any2scsi(scb->dataptr, (int) sgb);
1118		any2scsi(scb->maxlen, nseg * sizeof(Sgb));
1119
1120		scsi_for_each_sg(SCpnt, sg, nseg, i) {
1121			any2scsi(sgb[i].ptr, isa_page_to_bus(sg_page(sg)) + sg->offset);
1122			any2scsi(sgb[i].len, sg->length);
1123		}
1124	} else {
1125		scb->op = 0;
1126		if (nseg) {
1127			struct scatterlist *sg = scsi_sglist(SCpnt);
1128			any2scsi(scb->dataptr, isa_page_to_bus(sg_page(sg)) + sg->offset);
1129		}
1130		any2scsi(scb->maxlen, scsi_bufflen(SCpnt));
1131	}
1132
1133	/* FIXME: drop lock and yield here ? */
1134
1135	while (!mail_out(host, scb))
1136		cpu_relax();	/* keep trying */
1137
1138	return 0;
1139}
1140
1141static DEF_SCSI_QCMD(wd7000_queuecommand)
1142
1143static int wd7000_diagnostics(Adapter * host, int code)
1144{
1145	static IcbDiag icb = { ICB_OP_DIAGNOSTICS };
1146	static unchar buf[256];
1147	unsigned long timeout;
1148
1149	icb.type = code;
1150	any2scsi(icb.len, sizeof(buf));
1151	any2scsi(icb.ptr, (int) &buf);
1152	icb.phase = 1;
1153	/*
1154	 * This routine is only called at init, so there should be OGMBs
1155	 * available.  I'm assuming so here.  If this is going to
1156	 * fail, I can just let the timeout catch the failure.
1157	 */
1158	mail_out(host, (struct scb *) &icb);
1159	timeout = jiffies + WAITnexttimeout;	/* wait up to 2 seconds */
1160	while (icb.phase && time_before(jiffies, timeout)) {
1161		cpu_relax();	/* wait for completion */
1162		barrier();
1163	}
1164
1165	if (icb.phase) {
1166		printk("wd7000_diagnostics: timed out.\n");
1167		return (0);
1168	}
1169	if (make_code(icb.vue | (icb.status << 8), 0)) {
1170		printk("wd7000_diagnostics: failed (0x%02x,0x%02x)\n", icb.vue, icb.status);
1171		return (0);
1172	}
1173
1174	return (1);
1175}
1176
1177
1178static int wd7000_adapter_reset(Adapter * host)
1179{
1180	InitCmd init_cmd = {
1181		INITIALIZATION,
1182		7,
1183		host->bus_on,
1184		host->bus_off,
1185		0,
1186		{0, 0, 0},
1187		OGMB_CNT,
1188		ICMB_CNT
1189	};
1190	int diag;
1191	/*
1192	 *  Reset the adapter - only.  The SCSI bus was initialized at power-up,
1193	 *  and we need to do this just so we control the mailboxes, etc.
1194	 */
1195	outb(ASC_RES, host->iobase + ASC_CONTROL);
1196	udelay(40);		/* reset pulse: this is 40us, only need 25us */
1197	outb(0, host->iobase + ASC_CONTROL);
1198	host->control = 0;	/* this must always shadow ASC_CONTROL */
1199
1200	if (WAIT(host->iobase + ASC_STAT, ASC_STATMASK, CMD_RDY, 0)) {
1201		printk(KERN_ERR "wd7000_init: WAIT timed out.\n");
1202		return -1;	/* -1 = not ok */
1203	}
1204
1205	if ((diag = inb(host->iobase + ASC_INTR_STAT)) != 1) {
1206		printk("wd7000_init: ");
1207
1208		switch (diag) {
1209		case 2:
1210			printk(KERN_ERR "RAM failure.\n");
1211			break;
1212		case 3:
1213			printk(KERN_ERR "FIFO R/W failed\n");
1214			break;
1215		case 4:
1216			printk(KERN_ERR "SBIC register R/W failed\n");
1217			break;
1218		case 5:
1219			printk(KERN_ERR "Initialization D-FF failed.\n");
1220			break;
1221		case 6:
1222			printk(KERN_ERR "Host IRQ D-FF failed.\n");
1223			break;
1224		case 7:
1225			printk(KERN_ERR "ROM checksum error.\n");
1226			break;
1227		default:
1228			printk(KERN_ERR "diagnostic code 0x%02Xh received.\n", diag);
1229		}
1230		return -1;
1231	}
1232	/* Clear mailboxes */
1233	memset(&(host->mb), 0, sizeof(host->mb));
1234
1235	/* Execute init command */
1236	any2scsi((unchar *) & (init_cmd.mailboxes), (int) &(host->mb));
1237	if (!command_out(host, (unchar *) & init_cmd, sizeof(init_cmd))) {
1238		printk(KERN_ERR "wd7000_adapter_reset: adapter initialization failed.\n");
1239		return -1;
1240	}
1241
1242	if (WAIT(host->iobase + ASC_STAT, ASC_STATMASK, ASC_INIT, 0)) {
1243		printk("wd7000_adapter_reset: WAIT timed out.\n");
1244		return -1;
1245	}
1246	return 0;
1247}
1248
1249static int wd7000_init(Adapter * host)
1250{
1251	if (wd7000_adapter_reset(host) == -1)
1252		return 0;
1253
1254
1255	if (request_irq(host->irq, wd7000_intr, 0, "wd7000", host)) {
1256		printk("wd7000_init: can't get IRQ %d.\n", host->irq);
1257		return (0);
1258	}
1259	if (request_dma(host->dma, "wd7000")) {
1260		printk("wd7000_init: can't get DMA channel %d.\n", host->dma);
1261		free_irq(host->irq, host);
1262		return (0);
1263	}
1264	wd7000_enable_dma(host);
1265	wd7000_enable_intr(host);
1266
1267	if (!wd7000_diagnostics(host, ICB_DIAG_FULL)) {
1268		free_dma(host->dma);
1269		free_irq(host->irq, NULL);
1270		return (0);
1271	}
1272
1273	return (1);
1274}
1275
1276
1277static void wd7000_revision(Adapter * host)
1278{
1279	static IcbRevLvl icb = { ICB_OP_GET_REVISION };
1280
1281	icb.phase = 1;
1282	/*
1283	 * Like diagnostics, this is only done at init time, in fact, from
1284	 * wd7000_detect, so there should be OGMBs available.  If it fails,
1285	 * the only damage will be that the revision will show up as 0.0,
1286	 * which in turn means that scatter/gather will be disabled.
1287	 */
1288	mail_out(host, (struct scb *) &icb);
1289	while (icb.phase) {
1290		cpu_relax();	/* wait for completion */
1291		barrier();
1292	}
1293	host->rev1 = icb.primary;
1294	host->rev2 = icb.secondary;
1295}
1296
1297
1298static int wd7000_set_info(struct Scsi_Host *host, char *buffer, int length)
1299{
1300	dprintk("Buffer = <%.*s>, length = %d\n", length, buffer, length);
1301
1302	/*
1303	 * Currently this is a no-op
1304	 */
1305	dprintk("Sorry, this function is currently out of order...\n");
1306	return (length);
1307}
1308
1309
1310static int wd7000_show_info(struct seq_file *m, struct Scsi_Host *host)
1311{
1312	Adapter *adapter = (Adapter *)host->hostdata;
1313	unsigned long flags;
1314#ifdef WD7000_DEBUG
1315	Mailbox *ogmbs, *icmbs;
1316	short count;
1317#endif
1318
1319	spin_lock_irqsave(host->host_lock, flags);
1320	seq_printf(m, "Host scsi%d: Western Digital WD-7000 (rev %d.%d)\n", host->host_no, adapter->rev1, adapter->rev2);
1321	seq_printf(m, "  IO base:      0x%x\n", adapter->iobase);
1322	seq_printf(m, "  IRQ:          %d\n", adapter->irq);
1323	seq_printf(m, "  DMA channel:  %d\n", adapter->dma);
1324	seq_printf(m, "  Interrupts:   %d\n", adapter->int_counter);
1325	seq_printf(m, "  BUS_ON time:  %d nanoseconds\n", adapter->bus_on * 125);
1326	seq_printf(m, "  BUS_OFF time: %d nanoseconds\n", adapter->bus_off * 125);
1327
1328#ifdef WD7000_DEBUG
1329	ogmbs = adapter->mb.ogmb;
1330	icmbs = adapter->mb.icmb;
1331
1332	seq_printf(m, "\nControl port value: 0x%x\n", adapter->control);
1333	seq_puts(m, "Incoming mailbox:\n");
1334	seq_printf(m, "  size: %d\n", ICMB_CNT);
1335	seq_puts(m, "  queued messages: ");
1336
1337	for (i = count = 0; i < ICMB_CNT; i++)
1338		if (icmbs[i].status) {
1339			count++;
1340			seq_printf(m, "0x%x ", i);
1341		}
1342
1343	seq_puts(m, count ? "\n" : "none\n");
1344
1345	seq_puts(m, "Outgoing mailbox:\n");
1346	seq_printf(m, "  size: %d\n", OGMB_CNT);
1347	seq_printf(m, "  next message: 0x%x\n", adapter->next_ogmb);
1348	seq_puts(m, "  queued messages: ");
1349
1350	for (i = count = 0; i < OGMB_CNT; i++)
1351		if (ogmbs[i].status) {
1352			count++;
1353			seq_printf(m, "0x%x ", i);
1354		}
1355
1356	seq_puts(m, count ? "\n" : "none\n");
1357#endif
1358
1359	spin_unlock_irqrestore(host->host_lock, flags);
1360
1361	return 0;
1362}
1363
1364
1365/*
1366 *  Returns the number of adapters this driver is supporting.
1367 *
1368 *  The source for hosts.c says to wait to call scsi_register until 100%
1369 *  sure about an adapter.  We need to do it a little sooner here; we
1370 *  need the storage set up by scsi_register before wd7000_init, and
1371 *  changing the location of an Adapter structure is more trouble than
1372 *  calling scsi_unregister.
1373 *
1374 */
1375
1376static __init int wd7000_detect(struct scsi_host_template *tpnt)
1377{
1378	short present = 0, biosaddr_ptr, sig_ptr, i, pass;
1379	short biosptr[NUM_CONFIGS];
1380	unsigned iobase;
1381	Adapter *host = NULL;
1382	struct Scsi_Host *sh;
1383	int unit = 0;
1384
1385	dprintk("wd7000_detect: started\n");
1386
1387#ifdef MODULE
1388	if (wd7000)
1389		wd7000_setup(wd7000);
1390#endif
1391
1392	for (i = 0; i < UNITS; wd7000_host[i++] = NULL);
1393	for (i = 0; i < NUM_CONFIGS; biosptr[i++] = -1);
1394
1395	tpnt->proc_name = "wd7000";
1396	tpnt->show_info = &wd7000_show_info;
1397	tpnt->write_info = wd7000_set_info;
1398
1399	/*
1400	 * Set up SCB free list, which is shared by all adapters
1401	 */
1402	init_scbs();
1403
1404	for (pass = 0; pass < NUM_CONFIGS; pass++) {
1405		/*
1406		 * First, search for BIOS SIGNATURE...
1407		 */
1408		for (biosaddr_ptr = 0; biosaddr_ptr < NUM_ADDRS; biosaddr_ptr++)
1409			for (sig_ptr = 0; sig_ptr < NUM_SIGNATURES; sig_ptr++) {
1410				for (i = 0; i < pass; i++)
1411					if (biosptr[i] == biosaddr_ptr)
1412						break;
1413
1414				if (i == pass) {
1415					void __iomem *biosaddr = ioremap(wd7000_biosaddr[biosaddr_ptr] + signatures[sig_ptr].ofs,
1416								 signatures[sig_ptr].len);
1417					short bios_match = 1;
1418
1419					if (biosaddr)
1420						bios_match = check_signature(biosaddr, signatures[sig_ptr].sig, signatures[sig_ptr].len);
1421
1422					iounmap(biosaddr);
1423
1424					if (bios_match)
1425						goto bios_matched;
1426				}
1427			}
1428
1429	      bios_matched:
1430		/*
1431		 * BIOS SIGNATURE has been found.
1432		 */
1433#ifdef WD7000_DEBUG
1434		dprintk("wd7000_detect: pass %d\n", pass + 1);
1435
1436		if (biosaddr_ptr == NUM_ADDRS)
1437			dprintk("WD-7000 SST BIOS not detected...\n");
1438		else
1439			dprintk("WD-7000 SST BIOS detected at 0x%lx: checking...\n", wd7000_biosaddr[biosaddr_ptr]);
1440#endif
1441
1442		if (configs[pass].irq < 0)
1443			continue;
1444
1445		if (unit == UNITS)
1446			continue;
1447
1448		iobase = configs[pass].iobase;
1449
1450		dprintk("wd7000_detect: check IO 0x%x region...\n", iobase);
1451
1452		if (request_region(iobase, 4, "wd7000")) {
1453
1454			dprintk("wd7000_detect: ASC reset (IO 0x%x) ...", iobase);
1455			/*
1456			 * ASC reset...
1457			 */
1458			outb(ASC_RES, iobase + ASC_CONTROL);
1459			msleep(10);
1460			outb(0, iobase + ASC_CONTROL);
1461
1462			if (WAIT(iobase + ASC_STAT, ASC_STATMASK, CMD_RDY, 0)) {
1463				dprintk("failed!\n");
1464				goto err_release;
1465			} else
1466				dprintk("ok!\n");
1467
1468			if (inb(iobase + ASC_INTR_STAT) == 1) {
1469				/*
1470				 *  We register here, to get a pointer to the extra space,
1471				 *  which we'll use as the Adapter structure (host) for
1472				 *  this adapter.  It is located just after the registered
1473				 *  Scsi_Host structure (sh), and is located by the empty
1474				 *  array hostdata.
1475				 */
1476				sh = scsi_register(tpnt, sizeof(Adapter));
1477				if (sh == NULL)
1478					goto err_release;
1479
1480				host = (Adapter *) sh->hostdata;
1481
1482				dprintk("wd7000_detect: adapter allocated at 0x%x\n", (int) host);
1483				memset(host, 0, sizeof(Adapter));
1484
1485				host->irq = configs[pass].irq;
1486				host->dma = configs[pass].dma;
1487				host->iobase = iobase;
1488				host->int_counter = 0;
1489				host->bus_on = configs[pass].bus_on;
1490				host->bus_off = configs[pass].bus_off;
1491				host->sh = wd7000_host[unit] = sh;
1492				unit++;
1493
1494				dprintk("wd7000_detect: Trying init WD-7000 card at IO " "0x%x, IRQ %d, DMA %d...\n", host->iobase, host->irq, host->dma);
1495
1496				if (!wd7000_init(host))	/* Initialization failed */
1497					goto err_unregister;
1498
1499				/*
1500				 *  OK from here - we'll use this adapter/configuration.
1501				 */
1502				wd7000_revision(host);	/* important for scatter/gather */
1503
1504				/*
1505				 *  For boards before rev 6.0, scatter/gather isn't supported.
1506				 */
1507				if (host->rev1 < 6)
1508					sh->sg_tablesize = 1;
1509
1510				present++;	/* count it */
1511
1512				if (biosaddr_ptr != NUM_ADDRS)
1513					biosptr[pass] = biosaddr_ptr;
1514
1515				printk(KERN_INFO "Western Digital WD-7000 (rev %d.%d) ", host->rev1, host->rev2);
1516				printk("using IO 0x%x, IRQ %d, DMA %d.\n", host->iobase, host->irq, host->dma);
1517				printk("  BUS_ON time: %dns, BUS_OFF time: %dns\n", host->bus_on * 125, host->bus_off * 125);
1518			}
1519		} else
1520			dprintk("wd7000_detect: IO 0x%x region already allocated!\n", iobase);
1521
1522		continue;
1523
1524	      err_unregister:
1525		scsi_unregister(sh);
1526	      err_release:
1527		release_region(iobase, 4);
1528
1529	}
1530
1531	if (!present)
1532		printk("Failed initialization of WD-7000 SCSI card!\n");
1533
1534	return (present);
1535}
1536
1537static int wd7000_release(struct Scsi_Host *shost)
1538{
1539	if (shost->irq)
1540		free_irq(shost->irq, NULL);
1541	if (shost->io_port && shost->n_io_port)
1542		release_region(shost->io_port, shost->n_io_port);
1543	scsi_unregister(shost);
1544	return 0;
1545}
1546
1547#if 0
1548/*
1549 *  I have absolutely NO idea how to do an abort with the WD7000...
1550 */
1551static int wd7000_abort(Scsi_Cmnd * SCpnt)
1552{
1553	Adapter *host = (Adapter *) SCpnt->device->host->hostdata;
1554
1555	if (inb(host->iobase + ASC_STAT) & INT_IM) {
1556		printk("wd7000_abort: lost interrupt\n");
1557		wd7000_intr_handle(host->irq, NULL, NULL);
1558		return FAILED;
1559	}
1560	return FAILED;
1561}
1562#endif
1563
1564/*
1565 *  Last resort. Reinitialize the board.
1566 */
1567
1568static int wd7000_host_reset(struct scsi_cmnd *SCpnt)
1569{
1570	Adapter *host = (Adapter *) SCpnt->device->host->hostdata;
1571
1572	spin_lock_irq(SCpnt->device->host->host_lock);
1573
1574	if (wd7000_adapter_reset(host) < 0) {
1575		spin_unlock_irq(SCpnt->device->host->host_lock);
1576		return FAILED;
1577	}
1578
1579	wd7000_enable_intr(host);
1580
1581	spin_unlock_irq(SCpnt->device->host->host_lock);
1582	return SUCCESS;
1583}
1584
1585/*
1586 *  This was borrowed directly from aha1542.c. (Zaga)
1587 */
1588
1589static int wd7000_biosparam(struct scsi_device *sdev,
1590		struct block_device *bdev, sector_t capacity, int *ip)
1591{
1592	char b[BDEVNAME_SIZE];
1593
1594	dprintk("wd7000_biosparam: dev=%s, size=%llu, ",
1595		bdevname(bdev, b), (u64)capacity);
1596	(void)b;	/* unused var warning? */
1597
1598	/*
1599	 * try default translation
1600	 */
1601	ip[0] = 64;
1602	ip[1] = 32;
1603	ip[2] = capacity >> 11;
1604
1605	/*
1606	 * for disks >1GB do some guessing
1607	 */
1608	if (ip[2] >= 1024) {
1609		int info

Large files files are truncated, but you can click here to view the full file