Commit | Line | Data |
---|---|---|
1da177e4 LT |
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 | * | |
fa195afe | 149 | * 2002/10/04 - Alan Cox <alan@lxorguk.ukuu.org.uk> |
1da177e4 | 150 | * |
cadbd4a5 | 151 | * Use dev_id for interrupts, kill __func__ pasting |
1da177e4 LT |
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 | * | |
fa195afe | 155 | * 2002/10/06 - Alan Cox <alan@lxorguk.ukuu.org.uk> |
1da177e4 LT |
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 | * | |
6070d81e | 164 | * Cleaned up host template definition |
1da177e4 LT |
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> | |
1da177e4 LT |
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> | |
53d5ed62 | 180 | #include <linux/io.h> |
1da177e4 | 181 | |
1da177e4 | 182 | #include <asm/dma.h> |
1da177e4 LT |
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 | }; | |
6391a113 | 268 | #define NUM_ADDRS ARRAY_SIZE(wd7000_biosaddr) |
1da177e4 LT |
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 | }; | |
6391a113 | 276 | #define NUM_IOPORTS ARRAY_SIZE(wd7000_iobase) |
1da177e4 LT |
277 | |
278 | static const short wd7000_irq[] = { 3, 4, 5, 7, 9, 10, 11, 12, 14, 15 }; | |
6391a113 | 279 | #define NUM_IRQS ARRAY_SIZE(wd7000_irq) |
1da177e4 LT |
280 | |
281 | static const short wd7000_dma[] = { 5, 6, 7 }; | |
6391a113 | 282 | #define NUM_DMAS ARRAY_SIZE(wd7000_dma) |
1da177e4 LT |
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 | }; | |
6391a113 | 318 | #define NUM_CONFIGS ARRAY_SIZE(configs) |
1da177e4 LT |
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 | }; | |
6391a113 | 334 | #define NUM_SIGNATURES ARRAY_SIZE(signatures) |
1da177e4 LT |
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) { | |
cadbd4a5 | 641 | printk(KERN_ERR "%s: Too many \"wd7000=\" configurations in " "command line!\n", __func__); |
1da177e4 LT |
642 | return 0; |
643 | } | |
644 | ||
645 | if ((ints[0] < 3) || (ints[0] > 5)) { | |
cadbd4a5 | 646 | printk(KERN_ERR "%s: Error in command line! " "Usage: wd7000=<IRQ>,<DMA>,IO>[,<BUS_ON>" "[,<BUS_OFF>]]\n", __func__); |
1da177e4 LT |
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 | ||
25985edc | 839 | /* Take the lock, then check we didn't get beaten, if so try again */ |
1da177e4 LT |
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 | ||
7d12e780 | 999 | static irqreturn_t wd7000_intr(int irq, void *dev_id) |
1da177e4 LT |
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 | ||
f281233d | 1084 | static int wd7000_queuecommand_lck(struct scsi_cmnd *SCpnt, |
1da177e4 LT |
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; | |
e7d6cf55 | 1092 | int nseg; |
1da177e4 LT |
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 | ||
e7d6cf55 | 1108 | nseg = scsi_sg_count(SCpnt); |
9a3dd65b | 1109 | if (nseg > 1) { |
e7d6cf55 | 1110 | struct scatterlist *sg; |
1da177e4 LT |
1111 | unsigned i; |
1112 | ||
e7d6cf55 | 1113 | dprintk("Using scatter/gather with %d elements.\n", nseg); |
1da177e4 LT |
1114 | |
1115 | sgb = scb->sgb; | |
1116 | scb->op = 1; | |
1117 | any2scsi(scb->dataptr, (int) sgb); | |
e7d6cf55 | 1118 | any2scsi(scb->maxlen, nseg * sizeof(Sgb)); |
1da177e4 | 1119 | |
e7d6cf55 | 1120 | scsi_for_each_sg(SCpnt, sg, nseg, i) { |
45711f1a | 1121 | any2scsi(sgb[i].ptr, isa_page_to_bus(sg_page(sg)) + sg->offset); |
e7d6cf55 | 1122 | any2scsi(sgb[i].len, sg->length); |
1da177e4 LT |
1123 | } |
1124 | } else { | |
1125 | scb->op = 0; | |
9a3dd65b BH |
1126 | if (nseg) { |
1127 | struct scatterlist *sg = scsi_sglist(SCpnt); | |
1128 | any2scsi(scb->dataptr, isa_page_to_bus(sg_page(sg)) + sg->offset); | |
1129 | } | |
e7d6cf55 | 1130 | any2scsi(scb->maxlen, scsi_bufflen(SCpnt)); |
1da177e4 LT |
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 | ||
f281233d JG |
1141 | static DEF_SCSI_QCMD(wd7000_queuecommand) |
1142 | ||
1da177e4 LT |
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 | ||
4909cc2b | 1255 | if (request_irq(host->irq, wd7000_intr, 0, "wd7000", host)) { |
1da177e4 LT |
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 | |
cab29b99 | 1299 | #define SPRINTF(args...) { seq_printf(m, ## args); } |
1da177e4 | 1300 | |
cab29b99 | 1301 | static int wd7000_set_info(struct Scsi_Host *host, char *buffer, int length) |
1da177e4 LT |
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 | ||
cab29b99 | 1313 | static int wd7000_show_info(struct seq_file *m, struct Scsi_Host *host) |
1da177e4 LT |
1314 | { |
1315 | Adapter *adapter = (Adapter *)host->hostdata; | |
1316 | unsigned long flags; | |
1da177e4 LT |
1317 | #ifdef WD7000_DEBUG |
1318 | Mailbox *ogmbs, *icmbs; | |
1319 | short count; | |
1320 | #endif | |
1321 | ||
1da177e4 LT |
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 | ||
cab29b99 | 1364 | return 0; |
1da177e4 LT |
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 | ||
b9bcf9c1 | 1379 | static __init int wd7000_detect(struct scsi_host_template *tpnt) |
1da177e4 LT |
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"; | |
cab29b99 AV |
1399 | tpnt->show_info = &wd7000_show_info; |
1400 | tpnt->write_info = wd7000_set_info; | |
1da177e4 LT |
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) | |
9a3dd65b | 1511 | sh->sg_tablesize = 1; |
1da177e4 LT |
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 | ||
a8f23b03 | 1575 | spin_lock_irq(SCpnt->device->host->host_lock); |
df0ae249 JG |
1576 | |
1577 | if (wd7000_adapter_reset(host) < 0) { | |
1578 | spin_unlock_irq(SCpnt->device->host->host_lock); | |
1da177e4 | 1579 | return FAILED; |
df0ae249 JG |
1580 | } |
1581 | ||
1da177e4 | 1582 | wd7000_enable_intr(host); |
df0ae249 JG |
1583 | |
1584 | spin_unlock_irq(SCpnt->device->host->host_lock); | |
1da177e4 LT |
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) | |
cadbd4a5 | 1629 | printk(KERN_INFO "%s: current partition table is " "using extended translation.\n", __func__); |
1da177e4 LT |
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", | |
cab29b99 AV |
1645 | .show_info = wd7000_show_info, |
1646 | .write_info = wd7000_set_info, | |
1da177e4 LT |
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, | |
1659 | }; | |
1660 | ||
1661 | #include "scsi_module.c" |