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