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