URL
https://opencores.org/ocsvn/or1k/or1k/trunk
Subversion Repositories or1k
[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [drivers/] [scsi/] [wd7000.c] - Rev 1765
Compare with Previous | Blame | View Log
/* $Id: wd7000.c,v 1.1.1.1 2004-04-15 02:08:28 phoenix Exp $ * linux/drivers/scsi/wd7000.c * * Copyright (C) 1992 Thomas Wuensche * closely related to the aha1542 driver from Tommy Thorn * ( as close as different hardware allows on a lowlevel-driver :-) ) * * Revised (and renamed) by John Boyd <boyd@cis.ohio-state.edu> to * accommodate Eric Youngdale's modifications to scsi.c. Nov 1992. * * Additional changes to support scatter/gather. Dec. 1992. tw/jb * * No longer tries to reset SCSI bus at boot (it wasn't working anyway). * Rewritten to support multiple host adapters. * Miscellaneous cleanup. * So far, still doesn't do reset or abort correctly, since I have no idea * how to do them with this board (8^(. Jan 1994 jb * * This driver now supports both of the two standard configurations (per * the 3.36 Owner's Manual, my latest reference) by the same method as * before; namely, by looking for a BIOS signature. Thus, the location of * the BIOS signature determines the board configuration. Until I have * time to do something more flexible, users should stick to one of the * following: * * Standard configuration for single-adapter systems: * - BIOS at CE00h * - I/O base address 350h * - IRQ level 15 * - DMA channel 6 * Standard configuration for a second adapter in a system: * - BIOS at C800h * - I/O base address 330h * - IRQ level 11 * - DMA channel 5 * * Anyone who can recompile the kernel is welcome to add others as need * arises, but unpredictable results may occur if there are conflicts. * In any event, if there are multiple adapters in a system, they MUST * use different I/O bases, IRQ levels, and DMA channels, since they will be * indistinguishable (and in direct conflict) otherwise. * * As a point of information, the NO_OP command toggles the CMD_RDY bit * of the status port, and this fact could be used as a test for the I/O * base address (or more generally, board detection). There is an interrupt * status port, so IRQ probing could also be done. I suppose the full * DMA diagnostic could be used to detect the DMA channel being used. I * haven't done any of this, though, because I think there's too much of * a chance that such explorations could be destructive, if some other * board's resources are used inadvertently. So, call me a wimp, but I * don't want to try it. The only kind of exploration I trust is memory * exploration, since it's more certain that reading memory won't be * destructive. * * More to my liking would be a LILO boot command line specification, such * as is used by the aha152x driver (and possibly others). I'll look into * it, as I have time... * * I get mail occasionally from people who either are using or are * considering using a WD7000 with Linux. There is a variety of * nomenclature describing WD7000's. To the best of my knowledge, the * following is a brief summary (from an old WD doc - I don't work for * them or anything like that): * * WD7000-FASST2: This is a WD7000 board with the real-mode SST ROM BIOS * installed. Last I heard, the BIOS was actually done by Columbia * Data Products. The BIOS is only used by this driver (and thus * by Linux) to identify the board; none of it can be executed under * Linux. * * WD7000-ASC: This is the original adapter board, with or without BIOS. * The board uses a WD33C93 or WD33C93A SBIC, which in turn is * controlled by an onboard Z80 processor. The board interface * visible to the host CPU is defined effectively by the Z80's * firmware, and it is this firmware's revision level that is * determined and reported by this driver. (The version of the * on-board BIOS is of no interest whatsoever.) The host CPU has * no access to the SBIC; hence the fact that it is a WD33C93 is * also of no interest to this driver. * * WD7000-AX: * WD7000-MX: * WD7000-EX: These are newer versions of the WD7000-ASC. The -ASC is * largely built from discrete components; these boards use more * integration. The -AX is an ISA bus board (like the -ASC), * the -MX is an MCA (i.e., PS/2) bus board), and the -EX is an * EISA bus board. * * At the time of my documentation, the -?X boards were "future" products, * and were not yet available. However, I vaguely recall that Thomas * Wuensche had an -AX, so I believe at least it is supported by this * driver. I have no personal knowledge of either -MX or -EX boards. * * P.S. Just recently, I've discovered (directly from WD and Future * Domain) that all but the WD7000-EX have been out of production for * two years now. FD has production rights to the 7000-EX, and are * producing it under a new name, and with a new BIOS. If anyone has * one of the FD boards, it would be nice to come up with a signature * for it. * J.B. Jan 1994. * * * Revisions by Miroslav Zagorac <zaga@fly.cc.fer.hr> * * 08/24/1996. * * Enhancement for wd7000_detect function has been made, so you don't have * to enter BIOS ROM address in initialisation data (see struct Config). * We cannot detect IRQ, DMA and I/O base address for now, so we have to * enter them as arguments while wd_7000 is detected. If someone has IRQ, * DMA or I/O base address set to some other value, he can enter them in * configuration without any problem. Also I wrote a function wd7000_setup, * so now you can enter WD-7000 definition as kernel arguments, * as in lilo.conf: * * append="wd7000=IRQ,DMA,IO" * * PS: If card BIOS ROM is disabled, function wd7000_detect now will recognize * adapter, unlike the old one. Anyway, BIOS ROM from WD7000 adapter is * useless for Linux. B^) * * * 09/06/1996. * * Autodetecting of I/O base address from wd7000_detect function is removed, * some little bugs removed, etc... * * Thanks to Roger Scott for driver debugging. * * 06/07/1997 * * Added support for /proc file system (/proc/scsi/wd7000/[0...] files). * Now, driver can handle hard disks with capacity >1GB. * * 01/15/1998 * * Added support for BUS_ON and BUS_OFF parameters in config line. * Miscellaneous cleanup. * * 03/01/1998 * * WD7000 driver now work on kernels >= 2.1.x */ #include <linux/module.h> #include <stdarg.h> #include <linux/kernel.h> #include <linux/types.h> #include <linux/string.h> #include <linux/sched.h> #include <linux/slab.h> #include <linux/spinlock.h> #include <asm/system.h> #include <asm/dma.h> #include <asm/io.h> #include <linux/ioport.h> #include <linux/proc_fs.h> #include <linux/blk.h> #include <linux/version.h> #include <linux/init.h> #include "scsi.h" #include "hosts.h" #include "sd.h" #include <scsi/scsicam.h> #define ANY2SCSI_INLINE /* undef this to use old macros */ #undef WD7000_DEBUG /* general debug */ #include "wd7000.h" #include <linux/stat.h> /* * Mailbox structure sizes. * I prefer to keep the number of ICMBs much larger than the number of * OGMBs. OGMBs are used very quickly by the driver to start one or * more commands, while ICMBs are used by the host adapter per command. */ #define OGMB_CNT 16 #define ICMB_CNT 32 /* * Scb's are shared by all active adapters. So, if they all become busy, * callers may be made to wait in alloc_scbs for them to free. That can * be avoided by setting MAX_SCBS to NUM_CONFIG * WD7000_Q. If you'd * rather conserve memory, use a smaller number (> 0, of course) - things * will should still work OK. */ #define MAX_SCBS 32 /* * WD7000-specific mailbox structure * */ typedef volatile struct mailbox { unchar status; unchar scbptr[3]; /* SCSI-style - MSB first (big endian) */ } Mailbox; /* * This structure should contain all per-adapter global data. I.e., any * new global per-adapter data should put in here. */ typedef struct adapter { struct Scsi_Host *sh; /* Pointer to Scsi_Host structure */ int iobase; /* This adapter's I/O base address */ int irq; /* This adapter's IRQ level */ int dma; /* This adapter's DMA channel */ int int_counter; /* This adapter's interrupt counter */ int bus_on; /* This adapter's BUS_ON time */ int bus_off; /* This adapter's BUS_OFF time */ struct { /* This adapter's mailboxes */ Mailbox ogmb[OGMB_CNT]; /* Outgoing mailboxes */ Mailbox icmb[ICMB_CNT]; /* Incoming mailboxes */ } mb; int next_ogmb; /* to reduce contention at mailboxes */ unchar control; /* shadows CONTROL port value */ unchar rev1, rev2; /* filled in by wd7000_revision */ } Adapter; /* * (linear) base address for ROM BIOS */ static const long wd7000_biosaddr[] = { 0xc0000, 0xc2000, 0xc4000, 0xc6000, 0xc8000, 0xca000, 0xcc000, 0xce000, 0xd0000, 0xd2000, 0xd4000, 0xd6000, 0xd8000, 0xda000, 0xdc000, 0xde000 }; #define NUM_ADDRS (sizeof(wd7000_biosaddr)/sizeof(long)) static const unsigned short wd7000_iobase[] = { 0x0300, 0x0308, 0x0310, 0x0318, 0x0320, 0x0328, 0x0330, 0x0338, 0x0340, 0x0348, 0x0350, 0x0358, 0x0360, 0x0368, 0x0370, 0x0378, 0x0380, 0x0388, 0x0390, 0x0398, 0x03a0, 0x03a8, 0x03b0, 0x03b8, 0x03c0, 0x03c8, 0x03d0, 0x03d8, 0x03e0, 0x03e8, 0x03f0, 0x03f8 }; #define NUM_IOPORTS (sizeof(wd7000_iobase)/sizeof(unsigned short)) static const short wd7000_irq[] = { 3, 4, 5, 7, 9, 10, 11, 12, 14, 15 }; #define NUM_IRQS (sizeof(wd7000_irq)/sizeof(short)) static const short wd7000_dma[] = { 5, 6, 7 }; #define NUM_DMAS (sizeof(wd7000_dma)/sizeof(short)) /* * possible irq range */ #define IRQ_MIN 3 #define IRQ_MAX 15 #define IRQS (IRQ_MAX - IRQ_MIN + 1) /* * The following is set up by wd7000_detect, and used thereafter by * wd7000_intr_handle to map the irq level to the corresponding Adapter. * Note that if SA_INTERRUPT is not used, wd7000_intr_handle must be * changed to pick up the IRQ level correctly. */ static struct Scsi_Host *wd7000_host[IRQS]; #define BUS_ON 64 /* x 125ns = 8000ns (BIOS default) */ #define BUS_OFF 15 /* x 125ns = 1875ns (BIOS default) */ /* * Standard Adapter Configurations - used by wd7000_detect */ typedef struct { short irq; /* IRQ level */ short dma; /* DMA channel */ unsigned iobase; /* I/O base address */ short bus_on; /* Time that WD7000 spends on the AT-bus when */ /* transferring data. BIOS default is 8000ns. */ short bus_off; /* Time that WD7000 spends OFF THE BUS after */ /* while it is transferring data. */ /* BIOS default is 1875ns */ } Config; /* * Add here your configuration... */ static Config configs[] = { { 15, 6, 0x350, BUS_ON, BUS_OFF }, /* defaults for single adapter */ { 11, 5, 0x320, BUS_ON, BUS_OFF }, /* defaults for second adapter */ { 7, 6, 0x350, BUS_ON, BUS_OFF }, /* My configuration (Zaga) */ { -1, -1, 0x0, BUS_ON, BUS_OFF } /* Empty slot */ }; #define NUM_CONFIGS (sizeof(configs)/sizeof(Config)) /* * The following list defines strings to look for in the BIOS that identify * it as the WD7000-FASST2 SST BIOS. I suspect that something should be * added for the Future Domain version. */ typedef struct signature { const char *sig; /* String to look for */ unsigned long ofs; /* offset from BIOS base address */ unsigned len; /* length of string */ } Signature; static const Signature signatures[] = { {"SSTBIOS", 0x0000d, 7} /* "SSTBIOS" @ offset 0x0000d */ }; #define NUM_SIGNATURES (sizeof(signatures)/sizeof(Signature)) /* * I/O Port Offsets and Bit Definitions * 4 addresses are used. Those not defined here are reserved. */ #define ASC_STAT 0 /* Status, Read */ #define ASC_COMMAND 0 /* Command, Write */ #define ASC_INTR_STAT 1 /* Interrupt Status, Read */ #define ASC_INTR_ACK 1 /* Acknowledge, Write */ #define ASC_CONTROL 2 /* Control, Write */ /* * ASC Status Port */ #define INT_IM 0x80 /* Interrupt Image Flag */ #define CMD_RDY 0x40 /* Command Port Ready */ #define CMD_REJ 0x20 /* Command Port Byte Rejected */ #define ASC_INIT 0x10 /* ASC Initialized Flag */ #define ASC_STATMASK 0xf0 /* The lower 4 Bytes are reserved */ /* * COMMAND opcodes * * Unfortunately, I have no idea how to properly use some of these commands, * as the OEM manual does not make it clear. I have not been able to use * enable/disable unsolicited interrupts or the reset commands with any * discernible effect whatsoever. I think they may be related to certain * ICB commands, but again, the OEM manual doesn't make that clear. */ #define NO_OP 0 /* NO-OP toggles CMD_RDY bit in ASC_STAT */ #define INITIALIZATION 1 /* initialization (10 bytes) */ #define DISABLE_UNS_INTR 2 /* disable unsolicited interrupts */ #define ENABLE_UNS_INTR 3 /* enable unsolicited interrupts */ #define INTR_ON_FREE_OGMB 4 /* interrupt on free OGMB */ #define SOFT_RESET 5 /* SCSI bus soft reset */ #define HARD_RESET_ACK 6 /* SCSI bus hard reset acknowledge */ #define START_OGMB 0x80 /* start command in OGMB (n) */ #define SCAN_OGMBS 0xc0 /* start multiple commands, signature (n) */ /* where (n) = lower 6 bits */ /* * For INITIALIZATION: */ typedef struct initCmd { unchar op; /* command opcode (= 1) */ unchar ID; /* Adapter's SCSI ID */ unchar bus_on; /* Bus on time, x 125ns (see below) */ unchar bus_off; /* Bus off time, "" "" */ unchar rsvd; /* Reserved */ unchar mailboxes[3]; /* Address of Mailboxes, MSB first */ unchar ogmbs; /* Number of outgoing MBs, max 64, 0,1 = 1 */ unchar icmbs; /* Number of incoming MBs, "" "" */ } InitCmd; /* * Interrupt Status Port - also returns diagnostic codes at ASC reset * * if msb is zero, the lower bits are diagnostic status * Diagnostics: * 01 No diagnostic error occurred * 02 RAM failure * 03 FIFO R/W failed * 04 SBIC register read/write failed * 05 Initialization D-FF failed * 06 Host IRQ D-FF failed * 07 ROM checksum error * Interrupt status (bitwise): * 10NNNNNN outgoing mailbox NNNNNN is free * 11NNNNNN incoming mailbox NNNNNN needs service */ #define MB_INTR 0xC0 /* Mailbox Service possible/required */ #define IMB_INTR 0x40 /* 1 Incoming / 0 Outgoing */ #define MB_MASK 0x3f /* mask for mailbox number */ /* * CONTROL port bits */ #define INT_EN 0x08 /* Interrupt Enable */ #define DMA_EN 0x04 /* DMA Enable */ #define SCSI_RES 0x02 /* SCSI Reset */ #define ASC_RES 0x01 /* ASC Reset */ /* * Driver data structures: * - mb and scbs are required for interfacing with the host adapter. * An SCB has extra fields not visible to the adapter; mb's * _cannot_ do this, since the adapter assumes they are contiguous in * memory, 4 bytes each, with ICMBs following OGMBs, and uses this fact * to access them. * - An icb is for host-only (non-SCSI) commands. ICBs are 16 bytes each; * the additional bytes are used only by the driver. * - For now, a pool of SCBs are kept in global storage by this driver, * and are allocated and freed as needed. * * The 7000-FASST2 marks OGMBs empty as soon as it has _started_ a command, * not when it has finished. Since the SCB must be around for completion, * problems arise when SCBs correspond to OGMBs, which may be reallocated * earlier (or delayed unnecessarily until a command completes). * Mailboxes are used as transient data structures, simply for * carrying SCB addresses to/from the 7000-FASST2. * * Note also since SCBs are not "permanently" associated with mailboxes, * there is no need to keep a global list of Scsi_Cmnd pointers indexed * by OGMB. Again, SCBs reference their Scsi_Cmnds directly, so mailbox * indices need not be involved. */ /* * WD7000-specific scatter/gather element structure */ typedef struct sgb { unchar len[3]; unchar ptr[3]; /* Also SCSI-style - MSB first */ } Sgb; typedef struct scb { /* Command Control Block 5.4.1 */ unchar op; /* Command Control Block Operation Code */ unchar idlun; /* op=0,2:Target Id, op=1:Initiator Id */ /* Outbound data transfer, length is checked */ /* Inbound data transfer, length is checked */ /* Logical Unit Number */ unchar cdb[12]; /* SCSI Command Block */ volatile unchar status; /* SCSI Return Status */ volatile unchar vue; /* Vendor Unique Error Code */ unchar maxlen[3]; /* Maximum Data Transfer Length */ unchar dataptr[3]; /* SCSI Data Block Pointer */ unchar linkptr[3]; /* Next Command Link Pointer */ unchar direc; /* Transfer Direction */ unchar reserved2[6]; /* SCSI Command Descriptor Block */ /* end of hardware SCB */ Scsi_Cmnd *SCpnt; /* Scsi_Cmnd using this SCB */ Sgb sgb[WD7000_SG]; /* Scatter/gather list for this SCB */ Adapter *host; /* host adapter */ struct scb *next; /* for lists of scbs */ } Scb; /* * This driver is written to allow host-only commands to be executed. * These use a 16-byte block called an ICB. The format is extended by the * driver to 18 bytes, to support the status returned in the ICMB and * an execution phase code. * * There are other formats besides these; these are the ones I've tried * to use. Formats for some of the defined ICB opcodes are not defined * (notably, get/set unsolicited interrupt status) in my copy of the OEM * manual, and others are ambiguous/hard to follow. */ #define ICB_OP_MASK 0x80 /* distinguishes scbs from icbs */ #define ICB_OP_OPEN_RBUF 0x80 /* open receive buffer */ #define ICB_OP_RECV_CMD 0x81 /* receive command from initiator */ #define ICB_OP_RECV_DATA 0x82 /* receive data from initiator */ #define ICB_OP_RECV_SDATA 0x83 /* receive data with status from init. */ #define ICB_OP_SEND_DATA 0x84 /* send data with status to initiator */ #define ICB_OP_SEND_STAT 0x86 /* send command status to initiator */ /* 0x87 is reserved */ #define ICB_OP_READ_INIT 0x88 /* read initialization bytes */ #define ICB_OP_READ_ID 0x89 /* read adapter's SCSI ID */ #define ICB_OP_SET_UMASK 0x8A /* set unsolicited interrupt mask */ #define ICB_OP_GET_UMASK 0x8B /* read unsolicited interrupt mask */ #define ICB_OP_GET_REVISION 0x8C /* read firmware revision level */ #define ICB_OP_DIAGNOSTICS 0x8D /* execute diagnostics */ #define ICB_OP_SET_EPARMS 0x8E /* set execution parameters */ #define ICB_OP_GET_EPARMS 0x8F /* read execution parameters */ typedef struct icbRecvCmd { unchar op; unchar IDlun; /* Initiator SCSI ID/lun */ unchar len[3]; /* command buffer length */ unchar ptr[3]; /* command buffer address */ unchar rsvd[7]; /* reserved */ volatile unchar vue; /* vendor-unique error code */ volatile unchar status; /* returned (icmb) status */ volatile unchar phase; /* used by interrupt handler */ } IcbRecvCmd; typedef struct icbSendStat { unchar op; unchar IDlun; /* Target SCSI ID/lun */ unchar stat; /* (outgoing) completion status byte 1 */ unchar rsvd[12]; /* reserved */ volatile unchar vue; /* vendor-unique error code */ volatile unchar status; /* returned (icmb) status */ volatile unchar phase; /* used by interrupt handler */ } IcbSendStat; typedef struct icbRevLvl { unchar op; volatile unchar primary; /* primary revision level (returned) */ volatile unchar secondary; /* secondary revision level (returned) */ unchar rsvd[12]; /* reserved */ volatile unchar vue; /* vendor-unique error code */ volatile unchar status; /* returned (icmb) status */ volatile unchar phase; /* used by interrupt handler */ } IcbRevLvl; typedef struct icbUnsMask { /* I'm totally guessing here */ unchar op; volatile unchar mask[14]; /* mask bits */ #if 0 unchar rsvd[12]; /* reserved */ #endif volatile unchar vue; /* vendor-unique error code */ volatile unchar status; /* returned (icmb) status */ volatile unchar phase; /* used by interrupt handler */ } IcbUnsMask; typedef struct icbDiag { unchar op; unchar type; /* diagnostics type code (0-3) */ unchar len[3]; /* buffer length */ unchar ptr[3]; /* buffer address */ unchar rsvd[7]; /* reserved */ volatile unchar vue; /* vendor-unique error code */ volatile unchar status; /* returned (icmb) status */ volatile unchar phase; /* used by interrupt handler */ } IcbDiag; #define ICB_DIAG_POWERUP 0 /* Power-up diags only */ #define ICB_DIAG_WALKING 1 /* walking 1's pattern */ #define ICB_DIAG_DMA 2 /* DMA - system memory diags */ #define ICB_DIAG_FULL 3 /* do both 1 & 2 */ typedef struct icbParms { unchar op; unchar rsvd1; /* reserved */ unchar len[3]; /* parms buffer length */ unchar ptr[3]; /* parms buffer address */ unchar idx[2]; /* index (MSB-LSB) */ unchar rsvd2[5]; /* reserved */ volatile unchar vue; /* vendor-unique error code */ volatile unchar status; /* returned (icmb) status */ volatile unchar phase; /* used by interrupt handler */ } IcbParms; typedef struct icbAny { unchar op; unchar data[14]; /* format-specific data */ volatile unchar vue; /* vendor-unique error code */ volatile unchar status; /* returned (icmb) status */ volatile unchar phase; /* used by interrupt handler */ } IcbAny; typedef union icb { unchar op; /* ICB opcode */ IcbRecvCmd recv_cmd; /* format for receive command */ IcbSendStat send_stat; /* format for send status */ IcbRevLvl rev_lvl; /* format for get revision level */ IcbDiag diag; /* format for execute diagnostics */ IcbParms eparms; /* format for get/set exec parms */ IcbAny icb; /* generic format */ unchar data[18]; } Icb; #ifdef MODULE static char * wd7000 = NULL; MODULE_PARM(wd7000, "s"); #endif /* * Driver SCB structure pool. * * The SCBs declared here are shared by all host adapters; hence, this * structure is not part of the Adapter structure. */ static Scb scbs[MAX_SCBS]; static Scb *scbfree = NULL; /* free list */ static int freescbs = MAX_SCBS; /* free list counter */ /* * END of data/declarations - code follows. */ static void setup_error (char *mesg, int *ints) { if (ints[0] == 3) printk ("wd7000_setup: \"wd7000=%d,%d,0x%x\" -> %s\n", ints[1], ints[2], ints[3], mesg); else if (ints[0] == 4) printk ("wd7000_setup: \"wd7000=%d,%d,0x%x,%d\" -> %s\n", ints[1], ints[2], ints[3], ints[4], mesg); else printk ("wd7000_setup: \"wd7000=%d,%d,0x%x,%d,%d\" -> %s\n", ints[1], ints[2], ints[3], ints[4], ints[5], mesg); } /* * Note: You can now set these options from the kernel's "command line". * The syntax is: * * wd7000=<IRQ>,<DMA>,<IO>[,<BUS_ON>[,<BUS_OFF>]] * * , where BUS_ON and BUS_OFF are in nanoseconds. BIOS default values * are 8000ns for BUS_ON and 1875ns for BUS_OFF. * eg: * wd7000=7,6,0x350 * * will configure the driver for a WD-7000 controller * using IRQ 15 with a DMA channel 6, at IO base address 0x350. */ static int __init wd7000_setup(char *str) { static short wd7000_card_num = 0; short i, j; int ints[6]; (void)get_options(str, ARRAY_SIZE(ints), ints); if (wd7000_card_num >= NUM_CONFIGS) { printk("wd7000_setup: Too many \"wd7000=\" configurations in " "command line!\n"); return 0; } if ((ints[0] < 3) || (ints[0] > 5)) { printk("wd7000_setup: Error in command line! " "Usage: wd7000=<IRQ>,<DMA>,IO>[,<BUS_ON>[,<BUS_OFF>]]\n"); } else { for (i = 0; i < NUM_IRQS; i++) if (ints[1] == wd7000_irq[i]) break; if (i == NUM_IRQS) { setup_error("invalid IRQ.", ints); return 0; } else configs[wd7000_card_num].irq = ints[1]; for (i = 0; i < NUM_DMAS; i++) if (ints[2] == wd7000_dma[i]) break; if (i == NUM_DMAS) { setup_error("invalid DMA channel.", ints); return 0; } else configs[wd7000_card_num].dma = ints[2]; for (i = 0; i < NUM_IOPORTS; i++) if (ints[3] == wd7000_iobase[i]) break; if (i == NUM_IOPORTS) { setup_error("invalid I/O base address.", ints); return 0; } else configs[wd7000_card_num].iobase = ints[3]; if (ints[0] > 3) { if ((ints[4] < 500) || (ints[4] > 31875)) { setup_error("BUS_ON value is out of range (500 to 31875 nanoseconds)!", ints); configs[wd7000_card_num].bus_on = BUS_ON; } else configs[wd7000_card_num].bus_on = ints[4] / 125; } else configs[wd7000_card_num].bus_on = BUS_ON; if (ints[0] > 4) { if ((ints[5] < 500) || (ints[5] > 31875)) { setup_error("BUS_OFF value is out of range (500 to 31875 nanoseconds)!", ints); configs[wd7000_card_num].bus_off = BUS_OFF; } else configs[wd7000_card_num].bus_off = ints[5] / 125; } else configs[wd7000_card_num].bus_off = BUS_OFF; if (wd7000_card_num) { for (i = 0; i < (wd7000_card_num - 1); i++) for (j = i + 1; j < wd7000_card_num; j++) if (configs[i].irq == configs[j].irq) { setup_error("duplicated IRQ!", ints); return 0; } else if (configs[i].dma == configs[j].dma) { setup_error("duplicated DMA channel!", ints); return 0; } else if (configs[i].iobase == configs[j].iobase) { setup_error ("duplicated I/O base address!", ints); return 0; } } #ifdef WD7000_DEBUG printk ("wd7000_setup: IRQ=%d, DMA=%d, I/O=0x%x, 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); #endif wd7000_card_num++; } return 1; } __setup("wd7000=", wd7000_setup); #ifdef ANY2SCSI_INLINE /* * Since they're used a lot, I've redone the following from the macros * formerly in wd7000.h, hopefully to speed them up by getting rid of * all the shifting (it may not matter; GCC might have done as well anyway). * * xany2scsi and xscsi2int were not being used, and are no longer defined. * (They were simply 4-byte versions of these routines). */ typedef union { /* let's cheat... */ int i; unchar u[sizeof (int)]; /* the sizeof(int) makes it more portable */ } i_u; static inline void any2scsi (unchar * scsi, int any) { *scsi++ = ((i_u) any).u[2]; *scsi++ = ((i_u) any).u[1]; *scsi++ = ((i_u) any).u[0]; } static inline int scsi2int (unchar * scsi) { i_u result; result.i = 0; /* clears unused bytes */ result.u[2] = *scsi++; result.u[1] = *scsi++; result.u[0] = *scsi++; return (result.i); } #else /* * These are the old ones - I've just moved them here... */ #undef any2scsi #define any2scsi(up, p) (up)[0] = (((unsigned long) (p)) >> 16); \ (up)[1] = ((unsigned long) (p)) >> 8; \ (up)[2] = ((unsigned long) (p)); #undef scsi2int #define scsi2int(up) ( (((unsigned long) *(up)) << 16) + \ (((unsigned long) (up)[1]) << 8) + \ ((unsigned long) (up)[2]) ) #endif static inline void wd7000_enable_intr (Adapter *host) { host->control |= INT_EN; outb (host->control, host->iobase + ASC_CONTROL); } static inline void wd7000_enable_dma (Adapter *host) { unsigned long flags; host->control |= DMA_EN; outb (host->control, host->iobase + ASC_CONTROL); flags = claim_dma_lock(); set_dma_mode (host->dma, DMA_MODE_CASCADE); enable_dma (host->dma); release_dma_lock(flags); } #define WAITnexttimeout 200 /* 2 seconds */ static inline short WAIT (unsigned port, unsigned mask, unsigned allof, unsigned noneof) { register unsigned WAITbits; register unsigned long WAITtimeout = jiffies + WAITnexttimeout; while (time_before_eq(jiffies, WAITtimeout)) { WAITbits = inb (port) & mask; if (((WAITbits & allof) == allof) && ((WAITbits & noneof) == 0)) return (0); } return (1); } static inline void delay (unsigned how_long) { register unsigned long time = jiffies + how_long; while (time_before(jiffies, time)); } static inline int command_out (Adapter * host, unchar * cmd, int len) { if (!WAIT (host->iobase + ASC_STAT, ASC_STATMASK, CMD_RDY, 0)) { while (len--) { do { outb (*cmd, host->iobase + ASC_COMMAND); WAIT (host->iobase + ASC_STAT, ASC_STATMASK, CMD_RDY, 0); } while (inb (host->iobase + ASC_STAT) & CMD_REJ); cmd++; } return (1); } printk ("wd7000 command_out: WAIT failed(%d)\n", len + 1); return (0); } /* * This version of alloc_scbs is in preparation for supporting multiple * commands per lun and command chaining, by queueing pending commands. * We will need to allocate Scbs in blocks since they will wait to be * executed so there is the possibility of deadlock otherwise. * Also, to keep larger requests from being starved by smaller requests, * we limit access to this routine with an internal busy flag, so that * the satisfiability of a request is not dependent on the size of the * request. */ static inline Scb *alloc_scbs (int needed) { register Scb *scb, *p; register unsigned long flags; register unsigned long timeout = jiffies + WAITnexttimeout; register unsigned long now; static int busy = 0; int i; if (needed <= 0) return (NULL); /* sanity check */ save_flags (flags); cli (); while (busy) { /* someone else is allocating */ spin_unlock_irq(&io_request_lock); for (now = jiffies; now == jiffies; ); /* wait a jiffy */ spin_lock_irq(&io_request_lock); } busy = 1; /* not busy now; it's our turn */ while (freescbs < needed) { timeout = jiffies + WAITnexttimeout; do { spin_unlock_irq(&io_request_lock); for (now = jiffies; now == jiffies; ); /* wait a jiffy */ spin_lock_irq(&io_request_lock); } while (freescbs < needed && time_before_eq(jiffies, timeout)); /* * If we get here with enough free Scbs, we can take them. * Otherwise, we timed out and didn't get enough. */ if (freescbs < needed) { busy = 0; printk (KERN_ERR "wd7000: can't get enough free SCBs.\n"); restore_flags (flags); return (NULL); } } scb = scbfree; freescbs -= needed; for (i = 0; i < needed; i++) { p = scbfree; scbfree = p->next; } p->next = NULL; busy = 0; /* we're done */ restore_flags (flags); return (scb); } static inline void free_scb (Scb *scb) { register unsigned long flags; save_flags (flags); cli (); memset (scb, 0, sizeof (Scb)); scb->next = scbfree; scbfree = scb; freescbs++; restore_flags (flags); } static inline void init_scbs (void) { int i; unsigned long flags; save_flags (flags); cli (); scbfree = &(scbs[0]); memset (scbs, 0, sizeof (scbs)); for (i = 0; i < MAX_SCBS - 1; i++) { scbs[i].next = &(scbs[i + 1]); scbs[i].SCpnt = NULL; } scbs[MAX_SCBS - 1].next = NULL; scbs[MAX_SCBS - 1].SCpnt = NULL; restore_flags (flags); } static int mail_out (Adapter *host, Scb *scbptr) /* * Note: this can also be used for ICBs; just cast to the parm type. */ { register int i, ogmb; register unsigned long flags; unchar start_ogmb; Mailbox *ogmbs = host->mb.ogmb; int *next_ogmb = &(host->next_ogmb); #ifdef WD7000_DEBUG printk ("wd7000_mail_out: 0x%06lx", (long) scbptr); #endif /* We first look for a free outgoing mailbox */ save_flags (flags); cli (); ogmb = *next_ogmb; for (i = 0; i < OGMB_CNT; i++) { if (ogmbs[ogmb].status == 0) { #ifdef WD7000_DEBUG printk (" using OGMB 0x%x", ogmb); #endif ogmbs[ogmb].status = 1; any2scsi ((unchar *) ogmbs[ogmb].scbptr, (int) scbptr); *next_ogmb = (ogmb + 1) % OGMB_CNT; break; } else ogmb = (ogmb + 1) % OGMB_CNT; } restore_flags (flags); #ifdef WD7000_DEBUG printk (", scb is 0x%06lx", (long) scbptr); #endif if (i >= OGMB_CNT) { /* * Alternatively, we might issue the "interrupt on free OGMB", * and sleep, but it must be ensured that it isn't the init * task running. Instead, this version assumes that the caller * will be persistent, and try again. Since it's the adapter * that marks OGMB's free, waiting even with interrupts off * should work, since they are freed very quickly in most cases. */ #ifdef WD7000_DEBUG printk (", no free OGMBs.\n"); #endif return (0); } wd7000_enable_intr (host); start_ogmb = START_OGMB | ogmb; command_out (host, &start_ogmb, 1); #ifdef WD7000_DEBUG printk (", awaiting interrupt.\n"); #endif return (1); } int make_code (unsigned hosterr, unsigned scsierr) { #ifdef WD7000_DEBUG int in_error = hosterr; #endif switch ((hosterr >> 8) & 0xff) { case 0: /* Reserved */ hosterr = DID_ERROR; break; case 1: /* Command Complete, no errors */ hosterr = DID_OK; break; case 2: /* Command complete, error logged in scb status (scsierr) */ hosterr = DID_OK; break; case 4: /* Command failed to complete - timeout */ hosterr = DID_TIME_OUT; break; case 5: /* Command terminated; Bus reset by external device */ hosterr = DID_RESET; break; case 6: /* Unexpected Command Received w/ host as target */ hosterr = DID_BAD_TARGET; break; case 80: /* Unexpected Reselection */ case 81: /* Unexpected Selection */ hosterr = DID_BAD_INTR; break; case 82: /* Abort Command Message */ hosterr = DID_ABORT; break; case 83: /* SCSI Bus Software Reset */ case 84: /* SCSI Bus Hardware Reset */ hosterr = DID_RESET; break; default: /* Reserved */ hosterr = DID_ERROR; } #ifdef WD7000_DEBUG if (scsierr || hosterr) printk ("\nSCSI command error: SCSI 0x%02x host 0x%04x return %d\n", scsierr, in_error, hosterr); #endif return (scsierr | (hosterr << 16)); } static void wd7000_scsi_done (Scsi_Cmnd *SCpnt) { #ifdef WD7000_DEBUG printk ("wd7000_scsi_done: 0x%06lx\n", (long) SCpnt); #endif SCpnt->SCp.phase = 0; } #define wd7000_intr_ack(host) outb (0, host->iobase + ASC_INTR_ACK) void wd7000_intr_handle (int irq, void *dev_id, struct pt_regs *regs) { register int flag, icmb, errstatus, icmb_status; register int host_error, scsi_error; register Scb *scb; /* for SCSI commands */ register IcbAny *icb; /* for host commands */ register Scsi_Cmnd *SCpnt; Adapter *host = (Adapter *) wd7000_host[irq - IRQ_MIN]->hostdata; /* This MUST be set!!! */ Mailbox *icmbs = host->mb.icmb; host->int_counter++; #ifdef WD7000_DEBUG printk ("wd7000_intr_handle: irq = %d, host = 0x%06lx\n", irq, (long) host); #endif flag = inb (host->iobase + ASC_INTR_STAT); #ifdef WD7000_DEBUG printk ("wd7000_intr_handle: intr stat = 0x%02x\n", flag); #endif if (!(inb (host->iobase + ASC_STAT) & INT_IM)) { /* NB: these are _very_ possible if IRQ 15 is being used, since * it's the "garbage collector" on the 2nd 8259 PIC. Specifically, * any interrupt signal into the 8259 which can't be identified * comes out as 7 from the 8259, which is 15 to the host. Thus, it * is a good thing the WD7000 has an interrupt status port, so we * can sort these out. Otherwise, electrical noise and other such * problems would be indistinguishable from valid interrupts... */ #ifdef WD7000_DEBUG printk ("wd7000_intr_handle: phantom interrupt...\n"); #endif wd7000_intr_ack (host); return; } if (flag & MB_INTR) { /* The interrupt is for a mailbox */ if (!(flag & IMB_INTR)) { #ifdef WD7000_DEBUG printk ("wd7000_intr_handle: free outgoing mailbox\n"); #endif /* * If sleep_on() and the "interrupt on free OGMB" command are * used in mail_out(), wake_up() should correspondingly be called * here. For now, we don't need to do anything special. */ wd7000_intr_ack (host); return; } else { /* The interrupt is for an incoming mailbox */ icmb = flag & MB_MASK; icmb_status = icmbs[icmb].status; if (icmb_status & 0x80) { /* unsolicited - result in ICMB */ #ifdef WD7000_DEBUG printk ("wd7000_intr_handle: unsolicited interrupt 0x%02x\n", icmb_status); #endif wd7000_intr_ack (host); return; } /* Aaaargh! (Zaga) */ scb = bus_to_virt(scsi2int ((unchar *) icmbs[icmb].scbptr)); icmbs[icmb].status = 0; if (!(scb->op & ICB_OP_MASK)) { /* an SCB is done */ SCpnt = scb->SCpnt; if (--(SCpnt->SCp.phase) <= 0) { /* all scbs are done */ host_error = scb->vue | (icmb_status << 8); scsi_error = scb->status; errstatus = make_code (host_error, scsi_error); SCpnt->result = errstatus; free_scb (scb); SCpnt->scsi_done (SCpnt); } } else { /* an ICB is done */ icb = (IcbAny *) scb; icb->status = icmb_status; icb->phase = 0; } } /* incoming mailbox */ } wd7000_intr_ack (host); #ifdef WD7000_DEBUG printk ("wd7000_intr_handle: return from interrupt handler\n"); #endif } void do_wd7000_intr_handle (int irq, void *dev_id, struct pt_regs *regs) { unsigned long flags; spin_lock_irqsave(&io_request_lock, flags); wd7000_intr_handle(irq, dev_id, regs); spin_unlock_irqrestore(&io_request_lock, flags); } int wd7000_queuecommand (Scsi_Cmnd *SCpnt, void (*done) (Scsi_Cmnd *)) { register Scb *scb; register Sgb *sgb; register unchar *cdb = (unchar *) SCpnt->cmnd; register unchar idlun; register short cdblen; Adapter *host = (Adapter *) SCpnt->host->hostdata; cdblen = SCpnt->cmd_len; idlun = ((SCpnt->target << 5) & 0xe0) | (SCpnt->lun & 7); SCpnt->scsi_done = done; SCpnt->SCp.phase = 1; scb = alloc_scbs (1); scb->idlun = idlun; memcpy (scb->cdb, cdb, cdblen); scb->direc = 0x40; /* Disable direction check */ scb->SCpnt = SCpnt; /* so we can find stuff later */ SCpnt->host_scribble = (unchar *) scb; scb->host = host; if (SCpnt->use_sg) { struct scatterlist *sg = (struct scatterlist *) SCpnt->request_buffer; unsigned i; if (SCpnt->host->sg_tablesize == SG_NONE) { panic ("wd7000_queuecommand: scatter/gather not supported.\n"); } #ifdef WD7000_DEBUG printk ("Using scatter/gather with %d elements.\n", SCpnt->use_sg); #endif sgb = scb->sgb; scb->op = 1; any2scsi (scb->dataptr, (int) sgb); any2scsi (scb->maxlen, SCpnt->use_sg * sizeof (Sgb)); for (i = 0; i < SCpnt->use_sg; i++) { any2scsi (sgb[i].ptr, (int) sg[i].address); any2scsi (sgb[i].len, sg[i].length); } } else { scb->op = 0; any2scsi (scb->dataptr, (int) SCpnt->request_buffer); any2scsi (scb->maxlen, SCpnt->request_bufflen); } while (!mail_out (host, scb)); /* keep trying */ return (1); } int wd7000_command (Scsi_Cmnd *SCpnt) { wd7000_queuecommand (SCpnt, wd7000_scsi_done); while (SCpnt->SCp.phase > 0) barrier (); /* phase counts scbs down to 0 */ return (SCpnt->result); } int wd7000_diagnostics (Adapter *host, int code) { static IcbDiag icb = {ICB_OP_DIAGNOSTICS}; static unchar buf[256]; unsigned long timeout; icb.type = code; any2scsi (icb.len, sizeof (buf)); any2scsi (icb.ptr, (int) &buf); icb.phase = 1; /* * This routine is only called at init, so there should be OGMBs * available. I'm assuming so here. If this is going to * fail, I can just let the timeout catch the failure. */ mail_out (host, (struct scb *) &icb); timeout = jiffies + WAITnexttimeout; /* wait up to 2 seconds */ while (icb.phase && time_before(jiffies, timeout)) barrier (); /* wait for completion */ if (icb.phase) { printk ("wd7000_diagnostics: timed out.\n"); return (0); } if (make_code (icb.vue | (icb.status << 8), 0)) { printk ("wd7000_diagnostics: failed (0x%02x,0x%02x)\n", icb.vue, icb.status); return (0); } return (1); } int wd7000_init (Adapter *host) { InitCmd init_cmd = { INITIALIZATION, 7, host->bus_on, host->bus_off, 0, { 0, 0, 0 }, OGMB_CNT, ICMB_CNT }; int diag; /* * Reset the adapter - only. The SCSI bus was initialized at power-up, * and we need to do this just so we control the mailboxes, etc. */ outb (ASC_RES, host->iobase + ASC_CONTROL); delay (1); /* reset pulse: this is 10ms, only need 25us */ outb (0, host->iobase + ASC_CONTROL); host->control = 0; /* this must always shadow ASC_CONTROL */ if (WAIT (host->iobase + ASC_STAT, ASC_STATMASK, CMD_RDY, 0)) { printk ("wd7000_init: WAIT timed out.\n"); return (0); /* 0 = not ok */ } if ((diag = inb (host->iobase + ASC_INTR_STAT)) != 1) { printk ("wd7000_init: "); switch (diag) { case 2: printk ("RAM failure.\n"); break; case 3: printk ("FIFO R/W failed\n"); break; case 4: printk ("SBIC register R/W failed\n"); break; case 5: printk ("Initialization D-FF failed.\n"); break; case 6: printk ("Host IRQ D-FF failed.\n"); break; case 7: printk ("ROM checksum error.\n"); break; default: printk ("diagnostic code 0x%02Xh received.\n", diag); } return (0); } /* Clear mailboxes */ memset (&(host->mb), 0, sizeof (host->mb)); /* Execute init command */ any2scsi ((unchar *) & (init_cmd.mailboxes), (int) &(host->mb)); if (!command_out (host, (unchar *) &init_cmd, sizeof (init_cmd))) { printk ("wd7000_init: adapter initialization failed.\n"); return (0); } if (WAIT (host->iobase + ASC_STAT, ASC_STATMASK, ASC_INIT, 0)) { printk ("wd7000_init: WAIT timed out.\n"); return (0); } if (request_irq (host->irq, do_wd7000_intr_handle, SA_INTERRUPT, "wd7000", NULL)) { printk ("wd7000_init: can't get IRQ %d.\n", host->irq); return (0); } if (request_dma (host->dma, "wd7000")) { printk ("wd7000_init: can't get DMA channel %d.\n", host->dma); free_irq (host->irq, NULL); return (0); } wd7000_enable_dma (host); wd7000_enable_intr (host); if (!wd7000_diagnostics (host, ICB_DIAG_FULL)) { free_dma (host->dma); free_irq (host->irq, NULL); return (0); } return (1); } void wd7000_revision (Adapter *host) { static IcbRevLvl icb = {ICB_OP_GET_REVISION}; icb.phase = 1; /* * Like diagnostics, this is only done at init time, in fact, from * wd7000_detect, so there should be OGMBs available. If it fails, * the only damage will be that the revision will show up as 0.0, * which in turn means that scatter/gather will be disabled. */ mail_out (host, (struct scb *) &icb); while (icb.phase) barrier (); /* wait for completion */ host->rev1 = icb.primary; host->rev2 = icb.secondary; } #undef SPRINTF #define SPRINTF(args...) { if (pos < (buffer + length)) pos += sprintf (pos, ## args); } int wd7000_set_info (char *buffer, int length, struct Scsi_Host *host) { unsigned long flags; save_flags (flags); cli (); #ifdef WD7000_DEBUG printk ("Buffer = <%.*s>, length = %d\n", length, buffer, length); #endif /* * Currently this is a no-op */ printk ("Sorry, this function is currently out of order...\n"); restore_flags (flags); return (length); } int wd7000_proc_info (char *buffer, char **start, off_t offset, int length, int hostno, int inout) { struct Scsi_Host *host = NULL; Scsi_Device *scd; Adapter *adapter; unsigned long flags; char *pos = buffer; short i; #ifdef WD7000_DEBUG Mailbox *ogmbs, *icmbs; short count; #endif /* * Find the specified host board. */ for (i = 0; i < IRQS; i++) if (wd7000_host[i] && (wd7000_host[i]->host_no == hostno)) { host = wd7000_host[i]; break; } /* * Host not found! */ if (! host) return (-ESRCH); /* * Has data been written to the file ? */ if (inout) return (wd7000_set_info (buffer, length, host)); adapter = (Adapter *) host->hostdata; save_flags (flags); cli (); SPRINTF ("Host scsi%d: Western Digital WD-7000 (rev %d.%d)\n", hostno, adapter->rev1, adapter->rev2); SPRINTF (" IO base: 0x%x\n", adapter->iobase); SPRINTF (" IRQ: %d\n", adapter->irq); SPRINTF (" DMA channel: %d\n", adapter->dma); SPRINTF (" Interrupts: %d\n", adapter->int_counter); SPRINTF (" BUS_ON time: %d nanoseconds\n", adapter->bus_on * 125); SPRINTF (" BUS_OFF time: %d nanoseconds\n", adapter->bus_off * 125); #ifdef WD7000_DEBUG ogmbs = adapter->mb.ogmb; icmbs = adapter->mb.icmb; SPRINTF ("\nControl port value: 0x%x\n", adapter->control); SPRINTF ("Incoming mailbox:\n"); SPRINTF (" size: %d\n", ICMB_CNT); SPRINTF (" queued messages: "); for (i = count = 0; i < ICMB_CNT; i++) if (icmbs[i].status) { count++; SPRINTF ("0x%x ", i); } SPRINTF (count ? "\n" : "none\n"); SPRINTF ("Outgoing mailbox:\n"); SPRINTF (" size: %d\n", OGMB_CNT); SPRINTF (" next message: 0x%x\n", adapter->next_ogmb); SPRINTF (" queued messages: "); for (i = count = 0; i < OGMB_CNT; i++) if (ogmbs[i].status) { count++; SPRINTF ("0x%x ", i); } SPRINTF (count ? "\n" : "none\n"); #endif /* * Display driver information for each device attached to the board. */ scd = host->host_queue; SPRINTF ("\nAttached devices: %s\n", scd ? "" : "none"); for ( ; scd; scd = scd->next) if (scd->host->host_no == hostno) { SPRINTF (" [Channel: %02d, Id: %02d, Lun: %02d] ", scd->channel, scd->id, scd->lun); SPRINTF ("%s ", (scd->type < MAX_SCSI_DEVICE_CODE) ? scsi_device_types[(short) scd->type] : "Unknown device"); for (i = 0; (i < 8) && (scd->vendor[i] >= 0x20); i++) SPRINTF ("%c", scd->vendor[i]); SPRINTF (" "); for (i = 0; (i < 16) && (scd->model[i] >= 0x20); i++) SPRINTF ("%c", scd->model[i]); SPRINTF ("\n"); } SPRINTF ("\n"); restore_flags (flags); /* * Calculate start of next buffer, and return value. */ *start = buffer + offset; if ((pos - buffer) < offset) return (0); else if ((pos - buffer - offset) < length) return (pos - buffer - offset); else return (length); } /* * Returns the number of adapters this driver is supporting. * * The source for hosts.c says to wait to call scsi_register until 100% * sure about an adapter. We need to do it a little sooner here; we * need the storage set up by scsi_register before wd7000_init, and * changing the location of an Adapter structure is more trouble than * calling scsi_unregister. * */ int wd7000_detect (Scsi_Host_Template *tpnt) { short present = 0, biosaddr_ptr, sig_ptr, i, pass; short biosptr[NUM_CONFIGS]; unsigned iobase; Adapter *host = NULL; struct Scsi_Host *sh; #ifdef WD7000_DEBUG printk ("wd7000_detect: started\n"); #endif #ifdef MODULE if (wd7000) wd7000_setup(wd7000); #endif for (i = 0; i < IRQS; wd7000_host[i++] = NULL) ; for (i = 0; i < NUM_CONFIGS; biosptr[i++] = -1) ; tpnt->proc_name = "wd7000"; tpnt->proc_info = &wd7000_proc_info; /* * Set up SCB free list, which is shared by all adapters */ init_scbs (); for (pass = 0; pass < NUM_CONFIGS; pass++) { /* * First, search for BIOS SIGNATURE... */ for (biosaddr_ptr = 0; biosaddr_ptr < NUM_ADDRS; biosaddr_ptr++) for (sig_ptr = 0; sig_ptr < NUM_SIGNATURES; sig_ptr++) { for (i = 0; i < pass; i++) if (biosptr[i] == biosaddr_ptr) break; if (i == pass) { void *biosaddr = ioremap (wd7000_biosaddr[biosaddr_ptr] + signatures[sig_ptr].ofs, signatures[sig_ptr].len); short bios_match=0; if(biosaddr) bios_match = memcmp ((char *) biosaddr, signatures[sig_ptr].sig, signatures[sig_ptr].len); iounmap (biosaddr); if (! bios_match) goto bios_matched; } } bios_matched: /* * BIOS SIGNATURE has been found. */ #ifdef WD7000_DEBUG printk ("wd7000_detect: pass %d\n", pass + 1); if (biosaddr_ptr == NUM_ADDRS) printk ("WD-7000 SST BIOS not detected...\n"); else printk ("WD-7000 SST BIOS detected at 0x%lx: checking...\n", wd7000_biosaddr[biosaddr_ptr]); #endif if (configs[pass].irq < 0) continue; iobase = configs[pass].iobase; #ifdef WD7000_DEBUG printk ("wd7000_detect: check IO 0x%x region...\n", iobase); #endif if (request_region (iobase, 4, "wd7000")) { #ifdef WD7000_DEBUG printk ("wd7000_detect: ASC reset (IO 0x%x) ...", iobase); #endif /* * ASC reset... */ outb (ASC_RES, iobase + ASC_CONTROL); delay (1); outb (0, iobase + ASC_CONTROL); if (WAIT (iobase + ASC_STAT, ASC_STATMASK, CMD_RDY, 0)) #ifdef WD7000_DEBUG { printk ("failed!\n"); goto err_release; } else printk ("ok!\n"); #else goto err_release; #endif if (inb (iobase + ASC_INTR_STAT) == 1) { /* * We register here, to get a pointer to the extra space, * which we'll use as the Adapter structure (host) for * this adapter. It is located just after the registered * Scsi_Host structure (sh), and is located by the empty * array hostdata. */ sh = scsi_register (tpnt, sizeof (Adapter)); if(sh==NULL) goto err_release; host = (Adapter *) sh->hostdata; #ifdef WD7000_DEBUG printk ("wd7000_detect: adapter allocated at 0x%x\n", (int) host); #endif memset (host, 0, sizeof (Adapter)); host->irq = configs[pass].irq; host->dma = configs[pass].dma; host->iobase = iobase; host->int_counter = 0; host->bus_on = configs[pass].bus_on; host->bus_off = configs[pass].bus_off; host->sh = wd7000_host[host->irq - IRQ_MIN] = sh; #ifdef WD7000_DEBUG printk ("wd7000_detect: Trying init WD-7000 card at IO " "0x%x, IRQ %d, DMA %d...\n", host->iobase, host->irq, host->dma); #endif if (!wd7000_init (host)) /* Initialization failed */ goto err_unregister; /* * OK from here - we'll use this adapter/configuration. */ wd7000_revision (host); /* important for scatter/gather */ /* * For boards before rev 6.0, scatter/gather isn't supported. */ if (host->rev1 < 6) sh->sg_tablesize = SG_NONE; present++; /* count it */ if (biosaddr_ptr != NUM_ADDRS) biosptr[pass] = biosaddr_ptr; printk ("Western Digital WD-7000 (rev %d.%d) ", host->rev1, host->rev2); printk ("using IO 0x%x, IRQ %d, DMA %d.\n", host->iobase, host->irq, host->dma); printk (" BUS_ON time: %dns, BUS_OFF time: %dns\n", host->bus_on * 125, host->bus_off * 125); } } #ifdef WD7000_DEBUG else printk ("wd7000_detect: IO 0x%x region already allocated!\n", iobase); #endif continue; err_unregister: scsi_unregister (sh); err_release: release_region(iobase, 4); } if (!present) printk ("Failed initialization of WD-7000 SCSI card!\n"); return (present); } /* * I have absolutely NO idea how to do an abort with the WD7000... */ int wd7000_abort (Scsi_Cmnd *SCpnt) { Adapter *host = (Adapter *) SCpnt->host->hostdata; if (inb (host->iobase + ASC_STAT) & INT_IM) { printk ("wd7000_abort: lost interrupt\n"); wd7000_intr_handle (host->irq, NULL, NULL); return (SCSI_ABORT_SUCCESS); } return (SCSI_ABORT_SNOOZE); } /* * I also have no idea how to do a reset... */ int wd7000_reset (Scsi_Cmnd *SCpnt, unsigned int unused) { return (SCSI_RESET_PUNT); } /* * This was borrowed directly from aha1542.c. (Zaga) */ int wd7000_biosparam (Disk *disk, kdev_t dev, int *ip) { #ifdef WD7000_DEBUG printk ("wd7000_biosparam: dev=%s, size=%d, ", kdevname (dev), disk->capacity); #endif /* * try default translation */ ip[0] = 64; ip[1] = 32; ip[2] = disk->capacity / (64 * 32); /* * for disks >1GB do some guessing */ if (ip[2] >= 1024) { int info[3]; /* * try to figure out the geometry from the partition table */ if ((scsicam_bios_param (disk, dev, info) < 0) || !(((info[0] == 64) && (info[1] == 32)) || ((info[0] == 255) && (info[1] == 63)))) { printk ("wd7000_biosparam: unable to verify geometry for disk with >1GB.\n" " using extended translation.\n"); ip[0] = 255; ip[1] = 63; ip[2] = disk->capacity / (255 * 63); } else { ip[0] = info[0]; ip[1] = info[1]; ip[2] = info[2]; if (info[0] == 255) printk ("wd7000_biosparam: current partition table is using extended translation.\n"); } } #ifdef WD7000_DEBUG printk ("bios geometry: head=%d, sec=%d, cyl=%d\n", ip[0], ip[1], ip[2]); printk ("WARNING: check, if the bios geometry is correct.\n"); #endif return (0); } MODULE_LICENSE("GPL"); /* Eventually this will go into an include file, but this will be later */ static Scsi_Host_Template driver_template = WD7000; #include "scsi_module.c"