blob: 5d4ea6f77953f2fdeabf19d22eba31551bc2fae6 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* fdomain.c -- Future Domain TMC-16x0 SCSI driver
2 * Created: Sun May 3 18:53:19 1992 by faith@cs.unc.edu
3 * Revised: Mon Dec 28 21:59:02 1998 by faith@acm.org
4 * Author: Rickard E. Faith, faith@cs.unc.edu
5 * Copyright 1992-1996, 1998 Rickard E. Faith (faith@acm.org)
6 * Shared IRQ supported added 7/7/2001 Alan Cox <alan@redhat.com>
7
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the
10 * Free Software Foundation; either version 2, or (at your option) any
11 * later version.
12
13 * This program is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * General Public License for more details.
17
18 * You should have received a copy of the GNU General Public License along
19 * with this program; if not, write to the Free Software Foundation, Inc.,
20 * 675 Mass Ave, Cambridge, MA 02139, USA.
21
22 **************************************************************************
23
24 SUMMARY:
25
26 Future Domain BIOS versions supported for autodetect:
27 2.0, 3.0, 3.2, 3.4 (1.0), 3.5 (2.0), 3.6, 3.61
28 Chips are supported:
29 TMC-1800, TMC-18C50, TMC-18C30, TMC-36C70
30 Boards supported:
31 Future Domain TMC-1650, TMC-1660, TMC-1670, TMC-1680, TMC-1610M/MER/MEX
32 Future Domain TMC-3260 (PCI)
33 Quantum ISA-200S, ISA-250MG
34 Adaptec AHA-2920A (PCI) [BUT *NOT* AHA-2920C -- use aic7xxx instead]
35 IBM ?
36 LILO/INSMOD command-line options:
37 fdomain=<PORT_BASE>,<IRQ>[,<ADAPTER_ID>]
38
39
40
41 NOTE:
42
43 The Adaptec AHA-2920C has an Adaptec AIC-7850 chip on it.
44 Use the aic7xxx driver for this board.
45
46 The Adaptec AHA-2920A has a Future Domain chip on it, so this is the right
47 driver for that card. Unfortunately, the boxes will probably just say
48 "2920", so you'll have to look on the card for a Future Domain logo, or a
49 letter after the 2920.
50
51
52
53 THANKS:
54
55 Thanks to Adaptec for providing PCI boards for testing. This finally
56 enabled me to test the PCI detection and correct it for PCI boards that do
57 not have a BIOS at a standard ISA location. For PCI boards, LILO/INSMOD
58 command-line options should no longer be needed. --RF 18Nov98
59
60
61
62 DESCRIPTION:
63
64 This is the Linux low-level SCSI driver for Future Domain TMC-1660/1680
65 TMC-1650/1670, and TMC-3260 SCSI host adapters. The 1650 and 1670 have a
66 25-pin external connector, whereas the 1660 and 1680 have a SCSI-2 50-pin
67 high-density external connector. The 1670 and 1680 have floppy disk
68 controllers built in. The TMC-3260 is a PCI bus card.
69
70 Future Domain's older boards are based on the TMC-1800 chip, and this
71 driver was originally written for a TMC-1680 board with the TMC-1800 chip.
72 More recently, boards are being produced with the TMC-18C50 and TMC-18C30
73 chips. The latest and greatest board may not work with this driver. If
74 you have to patch this driver so that it will recognize your board's BIOS
75 signature, then the driver may fail to function after the board is
76 detected.
77
78 Please note that the drive ordering that Future Domain implemented in BIOS
79 versions 3.4 and 3.5 is the opposite of the order (currently) used by the
80 rest of the SCSI industry. If you have BIOS version 3.4 or 3.5, and have
81 more than one drive, then the drive ordering will be the reverse of that
82 which you see under DOS. For example, under DOS SCSI ID 0 will be D: and
83 SCSI ID 1 will be C: (the boot device). Under Linux, SCSI ID 0 will be
84 /dev/sda and SCSI ID 1 will be /dev/sdb. The Linux ordering is consistent
85 with that provided by all the other SCSI drivers for Linux. If you want
86 this changed, you will probably have to patch the higher level SCSI code.
87 If you do so, please send me patches that are protected by #ifdefs.
88
89 If you have a TMC-8xx or TMC-9xx board, then this is not the driver for
90 your board. Please refer to the Seagate driver for more information and
91 possible support.
92
93
94
95 HISTORY:
96
97 Linux Driver Driver
98 Version Version Date Support/Notes
99
100 0.0 3 May 1992 V2.0 BIOS; 1800 chip
101 0.97 1.9 28 Jul 1992
102 0.98.6 3.1 27 Nov 1992
103 0.99 3.2 9 Dec 1992
104
105 0.99.3 3.3 10 Jan 1993 V3.0 BIOS
106 0.99.5 3.5 18 Feb 1993
107 0.99.10 3.6 15 May 1993 V3.2 BIOS; 18C50 chip
108 0.99.11 3.17 3 Jul 1993 (now under RCS)
109 0.99.12 3.18 13 Aug 1993
110 0.99.14 5.6 31 Oct 1993 (reselection code removed)
111
112 0.99.15 5.9 23 Jan 1994 V3.4 BIOS (preliminary)
113 1.0.8/1.1.1 5.15 1 Apr 1994 V3.4 BIOS; 18C30 chip (preliminary)
114 1.0.9/1.1.3 5.16 7 Apr 1994 V3.4 BIOS; 18C30 chip
115 1.1.38 5.18 30 Jul 1994 36C70 chip (PCI version of 18C30)
116 1.1.62 5.20 2 Nov 1994 V3.5 BIOS
117 1.1.73 5.22 7 Dec 1994 Quantum ISA-200S board; V2.0 BIOS
118
119 1.1.82 5.26 14 Jan 1995 V3.5 BIOS; TMC-1610M/MER/MEX board
120 1.2.10 5.28 5 Jun 1995 Quantum ISA-250MG board; V2.0, V2.01 BIOS
121 1.3.4 5.31 23 Jun 1995 PCI BIOS-32 detection (preliminary)
122 1.3.7 5.33 4 Jul 1995 PCI BIOS-32 detection
123 1.3.28 5.36 17 Sep 1995 V3.61 BIOS; LILO command-line support
124 1.3.34 5.39 12 Oct 1995 V3.60 BIOS; /proc
125 1.3.72 5.39 8 Feb 1996 Adaptec AHA-2920 board
126 1.3.85 5.41 4 Apr 1996
127 2.0.12 5.44 8 Aug 1996 Use ID 7 for all PCI cards
128 2.1.1 5.45 2 Oct 1996 Update ROM accesses for 2.1.x
129 2.1.97 5.46 23 Apr 1998 Rewritten PCI detection routines [mj]
130 2.1.11x 5.47 9 Aug 1998 Touched for 8 SCSI disk majors support
131 5.48 18 Nov 1998 BIOS no longer needed for PCI detection
132 2.2.0 5.50 28 Dec 1998 Support insmod parameters
133
134
135 REFERENCES USED:
136
137 "TMC-1800 SCSI Chip Specification (FDC-1800T)", Future Domain Corporation,
138 1990.
139
140 "Technical Reference Manual: 18C50 SCSI Host Adapter Chip", Future Domain
141 Corporation, January 1992.
142
143 "LXT SCSI Products: Specifications and OEM Technical Manual (Revision
144 B/September 1991)", Maxtor Corporation, 1991.
145
146 "7213S product Manual (Revision P3)", Maxtor Corporation, 1992.
147
148 "Draft Proposed American National Standard: Small Computer System
149 Interface - 2 (SCSI-2)", Global Engineering Documents. (X3T9.2/86-109,
150 revision 10h, October 17, 1991)
151
152 Private communications, Drew Eckhardt (drew@cs.colorado.edu) and Eric
153 Youngdale (ericy@cais.com), 1992.
154
155 Private communication, Tuong Le (Future Domain Engineering department),
156 1994. (Disk geometry computations for Future Domain BIOS version 3.4, and
157 TMC-18C30 detection.)
158
159 Hogan, Thom. The Programmer's PC Sourcebook. Microsoft Press, 1988. Page
160 60 (2.39: Disk Partition Table Layout).
161
162 "18C30 Technical Reference Manual", Future Domain Corporation, 1993, page
163 6-1.
164
165
166
167 NOTES ON REFERENCES:
168
169 The Maxtor manuals were free. Maxtor telephone technical support is
170 great!
171
172 The Future Domain manuals were $25 and $35. They document the chip, not
173 the TMC-16x0 boards, so some information I had to guess at. In 1992,
174 Future Domain sold DOS BIOS source for $250 and the UN*X driver source was
175 $750, but these required a non-disclosure agreement, so even if I could
176 have afforded them, they would *not* have been useful for writing this
177 publically distributable driver. Future Domain technical support has
178 provided some information on the phone and have sent a few useful FAXs.
179 They have been much more helpful since they started to recognize that the
180 word "Linux" refers to an operating system :-).
181
182
183
184 ALPHA TESTERS:
185
186 There are many other alpha testers that come and go as the driver
187 develops. The people listed here were most helpful in times of greatest
188 need (mostly early on -- I've probably left out a few worthy people in
189 more recent times):
190
191 Todd Carrico (todd@wutc.wustl.edu), Dan Poirier (poirier@cs.unc.edu ), Ken
192 Corey (kenc@sol.acs.unt.edu), C. de Bruin (bruin@bruin@sterbbs.nl), Sakari
193 Aaltonen (sakaria@vipunen.hit.fi), John Rice (rice@xanth.cs.odu.edu), Brad
194 Yearwood (brad@optilink.com), and Ray Toy (toy@soho.crd.ge.com).
195
196 Special thanks to Tien-Wan Yang (twyang@cs.uh.edu), who graciously lent me
197 his 18C50-based card for debugging. He is the sole reason that this
198 driver works with the 18C50 chip.
199
200 Thanks to Dave Newman (dnewman@crl.com) for providing initial patches for
201 the version 3.4 BIOS.
202
203 Thanks to James T. McKinley (mckinley@msupa.pa.msu.edu) for providing
204 patches that support the TMC-3260, a PCI bus card with the 36C70 chip.
205 The 36C70 chip appears to be "completely compatible" with the 18C30 chip.
206
207 Thanks to Eric Kasten (tigger@petroglyph.cl.msu.edu) for providing the
208 patch for the version 3.5 BIOS.
209
210 Thanks for Stephen Henson (shenson@nyx10.cs.du.edu) for providing the
211 patch for the Quantum ISA-200S SCSI adapter.
212
213 Thanks to Adam Bowen for the signature to the 1610M/MER/MEX scsi cards, to
214 Martin Andrews (andrewm@ccfadm.eeg.ccf.org) for the signature to some
215 random TMC-1680 repackaged by IBM; and to Mintak Ng (mintak@panix.com) for
216 the version 3.61 BIOS signature.
217
218 Thanks for Mark Singer (elf@netcom.com) and Richard Simpson
219 (rsimpson@ewrcsdra.demon.co.uk) for more Quantum signatures and detective
220 work on the Quantum RAM layout.
221
222 Special thanks to James T. McKinley (mckinley@msupa.pa.msu.edu) for
223 providing patches for proper PCI BIOS32-mediated detection of the TMC-3260
224 card (a PCI bus card with the 36C70 chip). Please send James PCI-related
225 bug reports.
226
227 Thanks to Tom Cavin (tec@usa1.com) for preliminary command-line option
228 patches.
229
230 New PCI detection code written by Martin Mares <mj@atrey.karlin.mff.cuni.cz>
231
232 Insmod parameter code based on patches from Daniel Graham
233 <graham@balance.uoregon.edu>.
234
235 All of the alpha testers deserve much thanks.
236
237
238
239 NOTES ON USER DEFINABLE OPTIONS:
240
241 DEBUG: This turns on the printing of various debug information.
242
243 ENABLE_PARITY: This turns on SCSI parity checking. With the current
244 driver, all attached devices must support SCSI parity. If none of your
245 devices support parity, then you can probably get the driver to work by
246 turning this option off. I have no way of testing this, however, and it
247 would appear that no one ever uses this option.
248
249 FIFO_COUNT: The host adapter has an 8K cache (host adapters based on the
250 18C30 chip have a 2k cache). When this many 512 byte blocks are filled by
251 the SCSI device, an interrupt will be raised. Therefore, this could be as
252 low as 0, or as high as 16. Note, however, that values which are too high
253 or too low seem to prevent any interrupts from occurring, and thereby lock
254 up the machine. I have found that 2 is a good number, but throughput may
255 be increased by changing this value to values which are close to 2.
256 Please let me know if you try any different values.
257
258 RESELECTION: This is no longer an option, since I gave up trying to
259 implement it in version 4.x of this driver. It did not improve
260 performance at all and made the driver unstable (because I never found one
261 of the two race conditions which were introduced by the multiple
262 outstanding command code). The instability seems a very high price to pay
263 just so that you don't have to wait for the tape to rewind. If you want
264 this feature implemented, send me patches. I'll be happy to send a copy
265 of my (broken) driver to anyone who would like to see a copy.
266
267 **************************************************************************/
268
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269#include <linux/module.h>
270#include <linux/init.h>
271#include <linux/interrupt.h>
272#include <linux/blkdev.h>
273#include <linux/spinlock.h>
274#include <linux/errno.h>
275#include <linux/string.h>
276#include <linux/ioport.h>
277#include <linux/proc_fs.h>
278#include <linux/pci.h>
279#include <linux/stat.h>
280#include <linux/delay.h>
Matthew Wilcox53d5ed62006-10-11 01:22:01 -0700281#include <linux/io.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282#include <scsi/scsicam.h>
283
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284#include <asm/system.h>
285
286#include <scsi/scsi.h>
287#include <scsi/scsi_cmnd.h>
288#include <scsi/scsi_device.h>
289#include <scsi/scsi_host.h>
290#include <scsi/scsi_ioctl.h>
291#include "fdomain.h"
292
293MODULE_AUTHOR("Rickard E. Faith");
294MODULE_DESCRIPTION("Future domain SCSI driver");
295MODULE_LICENSE("GPL");
296
297
298#define VERSION "$Revision: 5.51 $"
299
300/* START OF USER DEFINABLE OPTIONS */
301
302#define DEBUG 0 /* Enable debugging output */
303#define ENABLE_PARITY 1 /* Enable SCSI Parity */
304#define FIFO_COUNT 2 /* Number of 512 byte blocks before INTR */
305
306/* END OF USER DEFINABLE OPTIONS */
307
308#if DEBUG
309#define EVERY_ACCESS 0 /* Write a line on every scsi access */
310#define ERRORS_ONLY 1 /* Only write a line if there is an error */
311#define DEBUG_DETECT 0 /* Debug fdomain_16x0_detect() */
312#define DEBUG_MESSAGES 1 /* Debug MESSAGE IN phase */
313#define DEBUG_ABORT 1 /* Debug abort() routine */
314#define DEBUG_RESET 1 /* Debug reset() routine */
315#define DEBUG_RACE 1 /* Debug interrupt-driven race condition */
316#else
317#define EVERY_ACCESS 0 /* LEAVE THESE ALONE--CHANGE THE ONES ABOVE */
318#define ERRORS_ONLY 0
319#define DEBUG_DETECT 0
320#define DEBUG_MESSAGES 0
321#define DEBUG_ABORT 0
322#define DEBUG_RESET 0
323#define DEBUG_RACE 0
324#endif
325
326/* Errors are reported on the line, so we don't need to report them again */
327#if EVERY_ACCESS
328#undef ERRORS_ONLY
329#define ERRORS_ONLY 0
330#endif
331
332#if ENABLE_PARITY
333#define PARITY_MASK 0x08
334#else
335#define PARITY_MASK 0x00
336#endif
337
338enum chip_type {
339 unknown = 0x00,
340 tmc1800 = 0x01,
341 tmc18c50 = 0x02,
342 tmc18c30 = 0x03,
343};
344
345enum {
346 in_arbitration = 0x02,
347 in_selection = 0x04,
348 in_other = 0x08,
349 disconnect = 0x10,
350 aborted = 0x20,
351 sent_ident = 0x40,
352};
353
354enum in_port_type {
355 Read_SCSI_Data = 0,
356 SCSI_Status = 1,
357 TMC_Status = 2,
358 FIFO_Status = 3, /* tmc18c50/tmc18c30 only */
359 Interrupt_Cond = 4, /* tmc18c50/tmc18c30 only */
360 LSB_ID_Code = 5,
361 MSB_ID_Code = 6,
362 Read_Loopback = 7,
363 SCSI_Data_NoACK = 8,
364 Interrupt_Status = 9,
365 Configuration1 = 10,
366 Configuration2 = 11, /* tmc18c50/tmc18c30 only */
367 Read_FIFO = 12,
368 FIFO_Data_Count = 14
369};
370
371enum out_port_type {
372 Write_SCSI_Data = 0,
373 SCSI_Cntl = 1,
374 Interrupt_Cntl = 2,
375 SCSI_Mode_Cntl = 3,
376 TMC_Cntl = 4,
377 Memory_Cntl = 5, /* tmc18c50/tmc18c30 only */
378 Write_Loopback = 7,
379 IO_Control = 11, /* tmc18c30 only */
380 Write_FIFO = 12
381};
382
383/* .bss will zero all the static variables below */
384static int port_base;
385static unsigned long bios_base;
386static void __iomem * bios_mem;
387static int bios_major;
388static int bios_minor;
389static int PCI_bus;
Alan Cox47bcd352006-10-16 16:55:46 +0100390static struct pci_dev *PCI_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391static int Quantum; /* Quantum board variant */
392static int interrupt_level;
393static volatile int in_command;
394static struct scsi_cmnd *current_SC;
395static enum chip_type chip = unknown;
396static int adapter_mask;
397static int this_id;
398static int setup_called;
399
400#if DEBUG_RACE
401static volatile int in_interrupt_flag;
402#endif
403
404static int FIFO_Size = 0x2000; /* 8k FIFO for
405 pre-tmc18c30 chips */
406
David Howells7d12e782006-10-05 14:55:46 +0100407static irqreturn_t do_fdomain_16x0_intr( int irq, void *dev_id );
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408/* Allow insmod parameters to be like LILO parameters. For example:
409 insmod fdomain fdomain=0x140,11 */
410static char * fdomain = NULL;
411module_param(fdomain, charp, 0);
412
413static unsigned long addresses[] = {
414 0xc8000,
415 0xca000,
416 0xce000,
417 0xde000,
418 0xcc000, /* Extra addresses for PCI boards */
419 0xd0000,
420 0xe0000,
421};
Tobias Klauser6391a112006-06-08 22:23:48 -0700422#define ADDRESS_COUNT ARRAY_SIZE(addresses)
423
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424static unsigned short ports[] = { 0x140, 0x150, 0x160, 0x170 };
Tobias Klauser6391a112006-06-08 22:23:48 -0700425#define PORT_COUNT ARRAY_SIZE(ports)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426
427static unsigned short ints[] = { 3, 5, 10, 11, 12, 14, 15, 0 };
428
429/*
430
431 READ THIS BEFORE YOU ADD A SIGNATURE!
432
433 READING THIS SHORT NOTE CAN SAVE YOU LOTS OF TIME!
434
435 READ EVERY WORD, ESPECIALLY THE WORD *NOT*
436
437 This driver works *ONLY* for Future Domain cards using the TMC-1800,
438 TMC-18C50, or TMC-18C30 chip. This includes models TMC-1650, 1660, 1670,
439 and 1680. These are all 16-bit cards.
440
441 The following BIOS signature signatures are for boards which do *NOT*
442 work with this driver (these TMC-8xx and TMC-9xx boards may work with the
443 Seagate driver):
444
445 FUTURE DOMAIN CORP. (C) 1986-1988 V4.0I 03/16/88
446 FUTURE DOMAIN CORP. (C) 1986-1989 V5.0C2/14/89
447 FUTURE DOMAIN CORP. (C) 1986-1989 V6.0A7/28/89
448 FUTURE DOMAIN CORP. (C) 1986-1990 V6.0105/31/90
449 FUTURE DOMAIN CORP. (C) 1986-1990 V6.0209/18/90
450 FUTURE DOMAIN CORP. (C) 1986-1990 V7.009/18/90
451 FUTURE DOMAIN CORP. (C) 1992 V8.00.004/02/92
452
453 (The cards which do *NOT* work are all 8-bit cards -- although some of
454 them have a 16-bit form-factor, the upper 8-bits are used only for IRQs
455 and are *NOT* used for data. You can tell the difference by following
456 the tracings on the circuit board -- if only the IRQ lines are involved,
457 you have a "8-bit" card, and should *NOT* use this driver.)
458
459*/
460
461static struct signature {
462 const char *signature;
463 int sig_offset;
464 int sig_length;
465 int major_bios_version;
466 int minor_bios_version;
467 int flag; /* 1 == PCI_bus, 2 == ISA_200S, 3 == ISA_250MG, 4 == ISA_200S */
468} signatures[] = {
469 /* 1 2 3 4 5 6 */
470 /* 123456789012345678901234567890123456789012345678901234567890 */
471 { "FUTURE DOMAIN CORP. (C) 1986-1990 1800-V2.07/28/89", 5, 50, 2, 0, 0 },
472 { "FUTURE DOMAIN CORP. (C) 1986-1990 1800-V1.07/28/89", 5, 50, 2, 0, 0 },
473 { "FUTURE DOMAIN CORP. (C) 1986-1990 1800-V2.07/28/89", 72, 50, 2, 0, 2 },
474 { "FUTURE DOMAIN CORP. (C) 1986-1990 1800-V2.0", 73, 43, 2, 0, 3 },
475 { "FUTURE DOMAIN CORP. (C) 1991 1800-V2.0.", 72, 39, 2, 0, 4 },
476 { "FUTURE DOMAIN CORP. (C) 1992 V3.00.004/02/92", 5, 44, 3, 0, 0 },
477 { "FUTURE DOMAIN TMC-18XX (C) 1993 V3.203/12/93", 5, 44, 3, 2, 0 },
478 { "IBM F1 P2 BIOS v1.0104/29/93", 5, 28, 3, -1, 0 },
479 { "Future Domain Corp. V1.0008/18/93", 5, 33, 3, 4, 0 },
480 { "Future Domain Corp. V1.0008/18/93", 26, 33, 3, 4, 1 },
481 { "Adaptec AHA-2920 PCI-SCSI Card", 42, 31, 3, -1, 1 },
482 { "IBM F1 P264/32", 5, 14, 3, -1, 1 },
483 /* This next signature may not be a 3.5 bios */
484 { "Future Domain Corp. V2.0108/18/93", 5, 33, 3, 5, 0 },
485 { "FUTURE DOMAIN CORP. V3.5008/18/93", 5, 34, 3, 5, 0 },
486 { "FUTURE DOMAIN 18c30/18c50/1800 (C) 1994 V3.5", 5, 44, 3, 5, 0 },
487 { "FUTURE DOMAIN CORP. V3.6008/18/93", 5, 34, 3, 6, 0 },
488 { "FUTURE DOMAIN CORP. V3.6108/18/93", 5, 34, 3, 6, 0 },
489 { "FUTURE DOMAIN TMC-18XX", 5, 22, -1, -1, 0 },
490
491 /* READ NOTICE ABOVE *BEFORE* YOU WASTE YOUR TIME ADDING A SIGNATURE
492 Also, fix the disk geometry code for your signature and send your
493 changes for faith@cs.unc.edu. Above all, do *NOT* change any old
494 signatures!
495
496 Note that the last line will match a "generic" 18XX bios. Because
497 Future Domain has changed the host SCSI ID and/or the location of the
498 geometry information in the on-board RAM area for each of the first
499 three BIOS's, it is still important to enter a fully qualified
500 signature in the table for any new BIOS's (after the host SCSI ID and
501 geometry location are verified). */
502};
503
Tobias Klauser6391a112006-06-08 22:23:48 -0700504#define SIGNATURE_COUNT ARRAY_SIZE(signatures)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505
506static void print_banner( struct Scsi_Host *shpnt )
507{
508 if (!shpnt) return; /* This won't ever happen */
509
510 if (bios_major < 0 && bios_minor < 0) {
511 printk(KERN_INFO "scsi%d: <fdomain> No BIOS; using scsi id %d\n",
512 shpnt->host_no, shpnt->this_id);
513 } else {
514 printk(KERN_INFO "scsi%d: <fdomain> BIOS version ", shpnt->host_no);
515
516 if (bios_major >= 0) printk("%d.", bios_major);
517 else printk("?.");
518
519 if (bios_minor >= 0) printk("%d", bios_minor);
520 else printk("?.");
Tobias Klauser6391a112006-06-08 22:23:48 -0700521
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 printk( " at 0x%lx using scsi id %d\n",
523 bios_base, shpnt->this_id );
524 }
525
526 /* If this driver works for later FD PCI
527 boards, we will have to modify banner
528 for additional PCI cards, but for now if
529 it's PCI it's a TMC-3260 - JTM */
530 printk(KERN_INFO "scsi%d: <fdomain> %s chip at 0x%x irq ",
531 shpnt->host_no,
532 chip == tmc1800 ? "TMC-1800" : (chip == tmc18c50 ? "TMC-18C50" : (chip == tmc18c30 ? (PCI_bus ? "TMC-36C70 (PCI bus)" : "TMC-18C30") : "Unknown")),
533 port_base);
534
535 if (interrupt_level)
536 printk("%d", interrupt_level);
537 else
538 printk("<none>");
539
540 printk( "\n" );
541}
542
543int fdomain_setup(char *str)
544{
545 int ints[4];
546
547 (void)get_options(str, ARRAY_SIZE(ints), ints);
548
549 if (setup_called++ || ints[0] < 2 || ints[0] > 3) {
550 printk(KERN_INFO "scsi: <fdomain> Usage: fdomain=<PORT_BASE>,<IRQ>[,<ADAPTER_ID>]\n");
551 printk(KERN_ERR "scsi: <fdomain> Bad LILO/INSMOD parameters?\n");
552 return 0;
553 }
554
555 port_base = ints[0] >= 1 ? ints[1] : 0;
556 interrupt_level = ints[0] >= 2 ? ints[2] : 0;
557 this_id = ints[0] >= 3 ? ints[3] : 0;
558
559 bios_major = bios_minor = -1; /* Use geometry for BIOS version >= 3.4 */
560 ++setup_called;
561 return 1;
562}
563
564__setup("fdomain=", fdomain_setup);
565
566
567static void do_pause(unsigned amount) /* Pause for amount*10 milliseconds */
568{
569 mdelay(10*amount);
570}
571
Jesper Juhl77933d72005-07-27 11:46:09 -0700572static inline void fdomain_make_bus_idle( void )
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573{
574 outb(0, port_base + SCSI_Cntl);
575 outb(0, port_base + SCSI_Mode_Cntl);
576 if (chip == tmc18c50 || chip == tmc18c30)
577 outb(0x21 | PARITY_MASK, port_base + TMC_Cntl); /* Clear forced intr. */
578 else
579 outb(0x01 | PARITY_MASK, port_base + TMC_Cntl);
580}
581
582static int fdomain_is_valid_port( int port )
583{
584#if DEBUG_DETECT
585 printk( " (%x%x),",
586 inb( port + MSB_ID_Code ), inb( port + LSB_ID_Code ) );
587#endif
588
589 /* The MCA ID is a unique id for each MCA compatible board. We
590 are using ISA boards, but Future Domain provides the MCA ID
591 anyway. We can use this ID to ensure that this is a Future
592 Domain TMC-1660/TMC-1680.
593 */
594
595 if (inb( port + LSB_ID_Code ) != 0xe9) { /* test for 0x6127 id */
596 if (inb( port + LSB_ID_Code ) != 0x27) return 0;
597 if (inb( port + MSB_ID_Code ) != 0x61) return 0;
598 chip = tmc1800;
599 } else { /* test for 0xe960 id */
600 if (inb( port + MSB_ID_Code ) != 0x60) return 0;
601 chip = tmc18c50;
602
603 /* Try to toggle 32-bit mode. This only
604 works on an 18c30 chip. (User reports
605 say this works, so we should switch to
606 it in the near future.) */
607
608 outb( 0x80, port + IO_Control );
609 if ((inb( port + Configuration2 ) & 0x80) == 0x80) {
610 outb( 0x00, port + IO_Control );
611 if ((inb( port + Configuration2 ) & 0x80) == 0x00) {
612 chip = tmc18c30;
613 FIFO_Size = 0x800; /* 2k FIFO */
614 }
615 }
616 /* If that failed, we are an 18c50. */
617 }
618
619 return 1;
620}
621
622static int fdomain_test_loopback( void )
623{
624 int i;
625 int result;
626
627 for (i = 0; i < 255; i++) {
628 outb( i, port_base + Write_Loopback );
629 result = inb( port_base + Read_Loopback );
630 if (i != result)
631 return 1;
632 }
633 return 0;
634}
635
636/* fdomain_get_irq assumes that we have a valid MCA ID for a
637 TMC-1660/TMC-1680 Future Domain board. Now, check to be sure the
638 bios_base matches these ports. If someone was unlucky enough to have
639 purchased more than one Future Domain board, then they will have to
640 modify this code, as we only detect one board here. [The one with the
641 lowest bios_base.]
642
643 Note that this routine is only used for systems without a PCI BIOS32
644 (e.g., ISA bus). For PCI bus systems, this routine will likely fail
645 unless one of the IRQs listed in the ints array is used by the board.
646 Sometimes it is possible to use the computer's BIOS setup screen to
647 configure a PCI system so that one of these IRQs will be used by the
648 Future Domain card. */
649
650static int fdomain_get_irq( int base )
651{
652 int options = inb(base + Configuration1);
653
654#if DEBUG_DETECT
655 printk("scsi: <fdomain> Options = %x\n", options);
656#endif
657
658 /* Check for board with lowest bios_base --
659 this isn't valid for the 18c30 or for
660 boards on the PCI bus, so just assume we
661 have the right board. */
662
663 if (chip != tmc18c30 && !PCI_bus && addresses[(options & 0xc0) >> 6 ] != bios_base)
664 return 0;
665 return ints[(options & 0x0e) >> 1];
666}
667
668static int fdomain_isa_detect( int *irq, int *iobase )
669{
670#ifndef PCMCIA
671 int i, j;
672 int base = 0xdeadbeef;
673 int flag = 0;
674
675#if DEBUG_DETECT
676 printk( "scsi: <fdomain> fdomain_isa_detect:" );
677#endif
678
679 for (i = 0; i < ADDRESS_COUNT; i++) {
680 void __iomem *p = ioremap(addresses[i], 0x2000);
681 if (!p)
682 continue;
683#if DEBUG_DETECT
684 printk( " %lx(%lx),", addresses[i], bios_base );
685#endif
686 for (j = 0; j < SIGNATURE_COUNT; j++) {
687 if (check_signature(p + signatures[j].sig_offset,
688 signatures[j].signature,
689 signatures[j].sig_length )) {
690 bios_major = signatures[j].major_bios_version;
691 bios_minor = signatures[j].minor_bios_version;
692 PCI_bus = (signatures[j].flag == 1);
693 Quantum = (signatures[j].flag > 1) ? signatures[j].flag : 0;
694 bios_base = addresses[i];
695 bios_mem = p;
696 goto found;
697 }
698 }
699 iounmap(p);
700 }
701
702found:
703 if (bios_major == 2) {
704 /* The TMC-1660/TMC-1680 has a RAM area just after the BIOS ROM.
705 Assuming the ROM is enabled (otherwise we wouldn't have been
706 able to read the ROM signature :-), then the ROM sets up the
707 RAM area with some magic numbers, such as a list of port
708 base addresses and a list of the disk "geometry" reported to
709 DOS (this geometry has nothing to do with physical geometry).
710 */
711
712 switch (Quantum) {
713 case 2: /* ISA_200S */
714 case 3: /* ISA_250MG */
715 base = readb(bios_mem + 0x1fa2) + (readb(bios_mem + 0x1fa3) << 8);
716 break;
717 case 4: /* ISA_200S (another one) */
718 base = readb(bios_mem + 0x1fa3) + (readb(bios_mem + 0x1fa4) << 8);
719 break;
720 default:
721 base = readb(bios_mem + 0x1fcc) + (readb(bios_mem + 0x1fcd) << 8);
722 break;
723 }
724
725#if DEBUG_DETECT
726 printk( " %x,", base );
727#endif
728
729 for (i = 0; i < PORT_COUNT; i++) {
730 if (base == ports[i]) {
731 if (!request_region(base, 0x10, "fdomain"))
732 break;
733 if (!fdomain_is_valid_port(base)) {
734 release_region(base, 0x10);
735 break;
736 }
737 *irq = fdomain_get_irq( base );
738 *iobase = base;
739 return 1;
740 }
741 }
742
743 /* This is a bad sign. It usually means that someone patched the
744 BIOS signature list (the signatures variable) to contain a BIOS
745 signature for a board *OTHER THAN* the TMC-1660/TMC-1680. */
746
747#if DEBUG_DETECT
748 printk( " RAM FAILED, " );
749#endif
750 }
751
752 /* Anyway, the alternative to finding the address in the RAM is to just
753 search through every possible port address for one that is attached
754 to the Future Domain card. Don't panic, though, about reading all
755 these random port addresses -- there are rumors that the Future
756 Domain BIOS does something very similar.
757
758 Do not, however, check ports which the kernel knows are being used by
759 another driver. */
760
761 for (i = 0; i < PORT_COUNT; i++) {
762 base = ports[i];
763 if (!request_region(base, 0x10, "fdomain")) {
764#if DEBUG_DETECT
765 printk( " (%x inuse),", base );
766#endif
767 continue;
768 }
769#if DEBUG_DETECT
770 printk( " %x,", base );
771#endif
772 flag = fdomain_is_valid_port(base);
773 if (flag)
774 break;
775 release_region(base, 0x10);
776 }
777
778#if DEBUG_DETECT
779 if (flag) printk( " SUCCESS\n" );
780 else printk( " FAILURE\n" );
781#endif
782
783 if (!flag) return 0; /* iobase not found */
784
785 *irq = fdomain_get_irq( base );
786 *iobase = base;
787
788 return 1; /* success */
789#else
790 return 0;
791#endif
792}
793
794/* PCI detection function: int fdomain_pci_bios_detect(int* irq, int*
795 iobase) This function gets the Interrupt Level and I/O base address from
796 the PCI configuration registers. */
797
798#ifdef CONFIG_PCI
799static int fdomain_pci_bios_detect( int *irq, int *iobase, struct pci_dev **ret_pdev )
800{
801 unsigned int pci_irq; /* PCI interrupt line */
802 unsigned long pci_base; /* PCI I/O base address */
803 struct pci_dev *pdev = NULL;
804
805#if DEBUG_DETECT
806 /* Tell how to print a list of the known PCI devices from bios32 and
807 list vendor and device IDs being used if in debug mode. */
808
809 printk( "scsi: <fdomain> INFO: use lspci -v to see list of PCI devices\n" );
810 printk( "scsi: <fdomain> TMC-3260 detect:"
811 " Using Vendor ID: 0x%x and Device ID: 0x%x\n",
812 PCI_VENDOR_ID_FD,
813 PCI_DEVICE_ID_FD_36C70 );
814#endif
815
Alan Cox47bcd352006-10-16 16:55:46 +0100816 if ((pdev = pci_get_device(PCI_VENDOR_ID_FD, PCI_DEVICE_ID_FD_36C70, pdev)) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817 return 0;
Alan Cox47bcd352006-10-16 16:55:46 +0100818 if (pci_enable_device(pdev))
819 goto fail;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820
821#if DEBUG_DETECT
822 printk( "scsi: <fdomain> TMC-3260 detect:"
823 " PCI bus %u, device %u, function %u\n",
824 pdev->bus->number,
825 PCI_SLOT(pdev->devfn),
826 PCI_FUNC(pdev->devfn));
827#endif
828
829 /* We now have the appropriate device function for the FD board so we
830 just read the PCI config info from the registers. */
831
832 pci_base = pci_resource_start(pdev, 0);
833 pci_irq = pdev->irq;
834
835 if (!request_region( pci_base, 0x10, "fdomain" ))
Alan Cox47bcd352006-10-16 16:55:46 +0100836 goto fail;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837
838 /* Now we have the I/O base address and interrupt from the PCI
839 configuration registers. */
840
841 *irq = pci_irq;
842 *iobase = pci_base;
843 *ret_pdev = pdev;
844
845#if DEBUG_DETECT
846 printk( "scsi: <fdomain> TMC-3260 detect:"
847 " IRQ = %d, I/O base = 0x%x [0x%lx]\n", *irq, *iobase, pci_base );
848#endif
849
850 if (!fdomain_is_valid_port(pci_base)) {
851 printk(KERN_ERR "scsi: <fdomain> PCI card detected, but driver not loaded (invalid port)\n" );
852 release_region(pci_base, 0x10);
Alan Cox47bcd352006-10-16 16:55:46 +0100853 goto fail;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700854 }
855
856 /* Fill in a few global variables. Ugh. */
857 bios_major = bios_minor = -1;
858 PCI_bus = 1;
Alan Cox47bcd352006-10-16 16:55:46 +0100859 PCI_dev = pdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860 Quantum = 0;
861 bios_base = 0;
862
863 return 1;
Alan Cox47bcd352006-10-16 16:55:46 +0100864fail:
865 pci_dev_put(pdev);
866 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867}
Alan Cox47bcd352006-10-16 16:55:46 +0100868
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869#endif
870
871struct Scsi_Host *__fdomain_16x0_detect(struct scsi_host_template *tpnt )
872{
873 int retcode;
874 struct Scsi_Host *shpnt;
875 struct pci_dev *pdev = NULL;
876
877 if (setup_called) {
878#if DEBUG_DETECT
879 printk( "scsi: <fdomain> No BIOS, using port_base = 0x%x, irq = %d\n",
880 port_base, interrupt_level );
881#endif
882 if (!request_region(port_base, 0x10, "fdomain")) {
883 printk( "scsi: <fdomain> port 0x%x is busy\n", port_base );
884 printk( "scsi: <fdomain> Bad LILO/INSMOD parameters?\n" );
885 return NULL;
886 }
887 if (!fdomain_is_valid_port( port_base )) {
888 printk( "scsi: <fdomain> Cannot locate chip at port base 0x%x\n",
889 port_base );
890 printk( "scsi: <fdomain> Bad LILO/INSMOD parameters?\n" );
891 release_region(port_base, 0x10);
892 return NULL;
893 }
894 } else {
895 int flag = 0;
896
897#ifdef CONFIG_PCI
898 /* Try PCI detection first */
899 flag = fdomain_pci_bios_detect( &interrupt_level, &port_base, &pdev );
900#endif
901 if (!flag) {
902 /* Then try ISA bus detection */
903 flag = fdomain_isa_detect( &interrupt_level, &port_base );
904
905 if (!flag) {
906 printk( "scsi: <fdomain> Detection failed (no card)\n" );
907 return NULL;
908 }
909 }
910 }
911
912 fdomain_16x0_bus_reset(NULL);
913
914 if (fdomain_test_loopback()) {
915 printk(KERN_ERR "scsi: <fdomain> Detection failed (loopback test failed at port base 0x%x)\n", port_base);
916 if (setup_called) {
917 printk(KERN_ERR "scsi: <fdomain> Bad LILO/INSMOD parameters?\n");
918 }
Alan Cox47bcd352006-10-16 16:55:46 +0100919 goto fail;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920 }
921
922 if (this_id) {
923 tpnt->this_id = (this_id & 0x07);
924 adapter_mask = (1 << tpnt->this_id);
925 } else {
926 if (PCI_bus || (bios_major == 3 && bios_minor >= 2) || bios_major < 0) {
927 tpnt->this_id = 7;
928 adapter_mask = 0x80;
929 } else {
930 tpnt->this_id = 6;
931 adapter_mask = 0x40;
932 }
933 }
934
935/* Print out a banner here in case we can't
936 get resources. */
937
938 shpnt = scsi_register( tpnt, 0 );
939 if(shpnt == NULL) {
940 release_region(port_base, 0x10);
941 return NULL;
942 }
943 shpnt->irq = interrupt_level;
944 shpnt->io_port = port_base;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945 shpnt->n_io_port = 0x10;
946 print_banner( shpnt );
947
948 /* Log IRQ with kernel */
949 if (!interrupt_level) {
950 printk(KERN_ERR "scsi: <fdomain> Card Detected, but driver not loaded (no IRQ)\n" );
Alan Cox47bcd352006-10-16 16:55:46 +0100951 goto fail;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952 } else {
953 /* Register the IRQ with the kernel */
954
955 retcode = request_irq( interrupt_level,
Thomas Gleixner1d6f3592006-07-01 19:29:42 -0700956 do_fdomain_16x0_intr, pdev?IRQF_SHARED:0, "fdomain", shpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700957
958 if (retcode < 0) {
959 if (retcode == -EINVAL) {
960 printk(KERN_ERR "scsi: <fdomain> IRQ %d is bad!\n", interrupt_level );
961 printk(KERN_ERR " This shouldn't happen!\n" );
962 printk(KERN_ERR " Send mail to faith@acm.org\n" );
963 } else if (retcode == -EBUSY) {
964 printk(KERN_ERR "scsi: <fdomain> IRQ %d is already in use!\n", interrupt_level );
965 printk(KERN_ERR " Please use another IRQ!\n" );
966 } else {
967 printk(KERN_ERR "scsi: <fdomain> Error getting IRQ %d\n", interrupt_level );
968 printk(KERN_ERR " This shouldn't happen!\n" );
969 printk(KERN_ERR " Send mail to faith@acm.org\n" );
970 }
971 printk(KERN_ERR "scsi: <fdomain> Detected, but driver not loaded (IRQ)\n" );
Alan Cox47bcd352006-10-16 16:55:46 +0100972 goto fail;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973 }
974 }
975 return shpnt;
Alan Cox47bcd352006-10-16 16:55:46 +0100976fail:
977 pci_dev_put(pdev);
978 release_region(port_base, 0x10);
979 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700980}
981
982static int fdomain_16x0_detect(struct scsi_host_template *tpnt)
983{
984 if (fdomain)
985 fdomain_setup(fdomain);
986 return (__fdomain_16x0_detect(tpnt) != NULL);
987}
988
989static const char *fdomain_16x0_info( struct Scsi_Host *ignore )
990{
991 static char buffer[128];
992 char *pt;
993
994 strcpy( buffer, "Future Domain 16-bit SCSI Driver Version" );
995 if (strchr( VERSION, ':')) { /* Assume VERSION is an RCS Revision string */
996 strcat( buffer, strchr( VERSION, ':' ) + 1 );
997 pt = strrchr( buffer, '$') - 1;
998 if (!pt) /* Stripped RCS Revision string? */
999 pt = buffer + strlen( buffer ) - 1;
1000 if (*pt != ' ')
1001 ++pt;
1002 *pt = '\0';
1003 } else { /* Assume VERSION is a number */
1004 strcat( buffer, " " VERSION );
1005 }
1006
1007 return buffer;
1008}
1009
1010#if 0
1011static int fdomain_arbitrate( void )
1012{
1013 int status = 0;
1014 unsigned long timeout;
1015
1016#if EVERY_ACCESS
1017 printk( "fdomain_arbitrate()\n" );
1018#endif
1019
1020 outb(0x00, port_base + SCSI_Cntl); /* Disable data drivers */
1021 outb(adapter_mask, port_base + SCSI_Data_NoACK); /* Set our id bit */
1022 outb(0x04 | PARITY_MASK, port_base + TMC_Cntl); /* Start arbitration */
1023
1024 timeout = 500;
1025 do {
1026 status = inb(port_base + TMC_Status); /* Read adapter status */
1027 if (status & 0x02) /* Arbitration complete */
1028 return 0;
1029 mdelay(1); /* Wait one millisecond */
1030 } while (--timeout);
1031
1032 /* Make bus idle */
1033 fdomain_make_bus_idle();
1034
1035#if EVERY_ACCESS
1036 printk( "Arbitration failed, status = %x\n", status );
1037#endif
1038#if ERRORS_ONLY
1039 printk( "scsi: <fdomain> Arbitration failed, status = %x\n", status );
1040#endif
1041 return 1;
1042}
1043#endif
1044
1045static int fdomain_select( int target )
1046{
1047 int status;
1048 unsigned long timeout;
1049#if ERRORS_ONLY
1050 static int flag = 0;
1051#endif
1052
1053 outb(0x82, port_base + SCSI_Cntl); /* Bus Enable + Select */
1054 outb(adapter_mask | (1 << target), port_base + SCSI_Data_NoACK);
1055
1056 /* Stop arbitration and enable parity */
1057 outb(PARITY_MASK, port_base + TMC_Cntl);
1058
1059 timeout = 350; /* 350 msec */
1060
1061 do {
1062 status = inb(port_base + SCSI_Status); /* Read adapter status */
1063 if (status & 1) { /* Busy asserted */
1064 /* Enable SCSI Bus (on error, should make bus idle with 0) */
1065 outb(0x80, port_base + SCSI_Cntl);
1066 return 0;
1067 }
1068 mdelay(1); /* wait one msec */
1069 } while (--timeout);
1070 /* Make bus idle */
1071 fdomain_make_bus_idle();
1072#if EVERY_ACCESS
1073 if (!target) printk( "Selection failed\n" );
1074#endif
1075#if ERRORS_ONLY
1076 if (!target) {
1077 if (!flag) /* Skip first failure for all chips. */
1078 ++flag;
1079 else
1080 printk( "scsi: <fdomain> Selection failed\n" );
1081 }
1082#endif
1083 return 1;
1084}
1085
1086static void my_done(int error)
1087{
1088 if (in_command) {
1089 in_command = 0;
1090 outb(0x00, port_base + Interrupt_Cntl);
1091 fdomain_make_bus_idle();
1092 current_SC->result = error;
1093 if (current_SC->scsi_done)
1094 current_SC->scsi_done( current_SC );
1095 else panic( "scsi: <fdomain> current_SC->scsi_done() == NULL" );
1096 } else {
1097 panic( "scsi: <fdomain> my_done() called outside of command\n" );
1098 }
1099#if DEBUG_RACE
1100 in_interrupt_flag = 0;
1101#endif
1102}
1103
David Howells7d12e782006-10-05 14:55:46 +01001104static irqreturn_t do_fdomain_16x0_intr(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001105{
1106 unsigned long flags;
1107 int status;
1108 int done = 0;
1109 unsigned data_count;
1110
1111 /* The fdomain_16x0_intr is only called via
1112 the interrupt handler. The goal of the
1113 sti() here is to allow other
1114 interruptions while this routine is
1115 running. */
1116
1117 /* Check for other IRQ sources */
1118 if ((inb(port_base + TMC_Status) & 0x01) == 0)
1119 return IRQ_NONE;
1120
1121 /* It is our IRQ */
1122 outb(0x00, port_base + Interrupt_Cntl);
1123
1124 /* We usually have one spurious interrupt after each command. Ignore it. */
1125 if (!in_command || !current_SC) { /* Spurious interrupt */
1126#if EVERY_ACCESS
1127 printk( "Spurious interrupt, in_command = %d, current_SC = %x\n",
1128 in_command, current_SC );
1129#endif
1130 return IRQ_NONE;
1131 }
1132
1133 /* Abort calls my_done, so we do nothing here. */
1134 if (current_SC->SCp.phase & aborted) {
1135#if DEBUG_ABORT
1136 printk( "scsi: <fdomain> Interrupt after abort, ignoring\n" );
1137#endif
1138 /*
1139 return IRQ_HANDLED; */
1140 }
1141
1142#if DEBUG_RACE
1143 ++in_interrupt_flag;
1144#endif
1145
1146 if (current_SC->SCp.phase & in_arbitration) {
1147 status = inb(port_base + TMC_Status); /* Read adapter status */
1148 if (!(status & 0x02)) {
1149#if EVERY_ACCESS
1150 printk( " AFAIL " );
1151#endif
1152 spin_lock_irqsave(current_SC->device->host->host_lock, flags);
1153 my_done( DID_BUS_BUSY << 16 );
1154 spin_unlock_irqrestore(current_SC->device->host->host_lock, flags);
1155 return IRQ_HANDLED;
1156 }
1157 current_SC->SCp.phase = in_selection;
1158
1159 outb(0x40 | FIFO_COUNT, port_base + Interrupt_Cntl);
1160
1161 outb(0x82, port_base + SCSI_Cntl); /* Bus Enable + Select */
Jeff Garzik422c0d62005-10-24 18:05:09 -04001162 outb(adapter_mask | (1 << scmd_id(current_SC)), port_base + SCSI_Data_NoACK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001163
1164 /* Stop arbitration and enable parity */
1165 outb(0x10 | PARITY_MASK, port_base + TMC_Cntl);
1166#if DEBUG_RACE
1167 in_interrupt_flag = 0;
1168#endif
1169 return IRQ_HANDLED;
1170 } else if (current_SC->SCp.phase & in_selection) {
1171 status = inb(port_base + SCSI_Status);
1172 if (!(status & 0x01)) {
1173 /* Try again, for slow devices */
Jeff Garzik422c0d62005-10-24 18:05:09 -04001174 if (fdomain_select( scmd_id(current_SC) )) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001175#if EVERY_ACCESS
1176 printk( " SFAIL " );
1177#endif
1178 spin_lock_irqsave(current_SC->device->host->host_lock, flags);
1179 my_done( DID_NO_CONNECT << 16 );
1180 spin_unlock_irqrestore(current_SC->device->host->host_lock, flags);
1181 return IRQ_HANDLED;
1182 } else {
1183#if EVERY_ACCESS
1184 printk( " AltSel " );
1185#endif
1186 /* Stop arbitration and enable parity */
1187 outb(0x10 | PARITY_MASK, port_base + TMC_Cntl);
1188 }
1189 }
1190 current_SC->SCp.phase = in_other;
1191 outb(0x90 | FIFO_COUNT, port_base + Interrupt_Cntl);
1192 outb(0x80, port_base + SCSI_Cntl);
1193#if DEBUG_RACE
1194 in_interrupt_flag = 0;
1195#endif
1196 return IRQ_HANDLED;
1197 }
1198
1199 /* current_SC->SCp.phase == in_other: this is the body of the routine */
1200
1201 status = inb(port_base + SCSI_Status);
1202
1203 if (status & 0x10) { /* REQ */
1204
1205 switch (status & 0x0e) {
1206
1207 case 0x08: /* COMMAND OUT */
1208 outb(current_SC->cmnd[current_SC->SCp.sent_command++],
1209 port_base + Write_SCSI_Data);
1210#if EVERY_ACCESS
1211 printk( "CMD = %x,",
1212 current_SC->cmnd[ current_SC->SCp.sent_command - 1] );
1213#endif
1214 break;
1215 case 0x00: /* DATA OUT -- tmc18c50/tmc18c30 only */
1216 if (chip != tmc1800 && !current_SC->SCp.have_data_in) {
1217 current_SC->SCp.have_data_in = -1;
1218 outb(0xd0 | PARITY_MASK, port_base + TMC_Cntl);
1219 }
1220 break;
1221 case 0x04: /* DATA IN -- tmc18c50/tmc18c30 only */
1222 if (chip != tmc1800 && !current_SC->SCp.have_data_in) {
1223 current_SC->SCp.have_data_in = 1;
1224 outb(0x90 | PARITY_MASK, port_base + TMC_Cntl);
1225 }
1226 break;
1227 case 0x0c: /* STATUS IN */
1228 current_SC->SCp.Status = inb(port_base + Read_SCSI_Data);
1229#if EVERY_ACCESS
1230 printk( "Status = %x, ", current_SC->SCp.Status );
1231#endif
1232#if ERRORS_ONLY
1233 if (current_SC->SCp.Status
1234 && current_SC->SCp.Status != 2
1235 && current_SC->SCp.Status != 8) {
1236 printk( "scsi: <fdomain> target = %d, command = %x, status = %x\n",
1237 current_SC->device->id,
1238 current_SC->cmnd[0],
1239 current_SC->SCp.Status );
1240 }
1241#endif
1242 break;
1243 case 0x0a: /* MESSAGE OUT */
1244 outb(MESSAGE_REJECT, port_base + Write_SCSI_Data); /* Reject */
1245 break;
1246 case 0x0e: /* MESSAGE IN */
1247 current_SC->SCp.Message = inb(port_base + Read_SCSI_Data);
1248#if EVERY_ACCESS
1249 printk( "Message = %x, ", current_SC->SCp.Message );
1250#endif
1251 if (!current_SC->SCp.Message) ++done;
1252#if DEBUG_MESSAGES || EVERY_ACCESS
1253 if (current_SC->SCp.Message) {
1254 printk( "scsi: <fdomain> message = %x\n",
1255 current_SC->SCp.Message );
1256 }
1257#endif
1258 break;
1259 }
1260 }
1261
1262 if (chip == tmc1800 && !current_SC->SCp.have_data_in
1263 && (current_SC->SCp.sent_command >= current_SC->cmd_len)) {
1264
1265 if(current_SC->sc_data_direction == DMA_TO_DEVICE)
1266 {
1267 current_SC->SCp.have_data_in = -1;
1268 outb(0xd0 | PARITY_MASK, port_base + TMC_Cntl);
1269 }
1270 else
1271 {
1272 current_SC->SCp.have_data_in = 1;
1273 outb(0x90 | PARITY_MASK, port_base + TMC_Cntl);
1274 }
1275 }
1276
1277 if (current_SC->SCp.have_data_in == -1) { /* DATA OUT */
1278 while ((data_count = FIFO_Size - inw(port_base + FIFO_Data_Count)) > 512) {
1279#if EVERY_ACCESS
1280 printk( "DC=%d, ", data_count ) ;
1281#endif
1282 if (data_count > current_SC->SCp.this_residual)
1283 data_count = current_SC->SCp.this_residual;
1284 if (data_count > 0) {
1285#if EVERY_ACCESS
1286 printk( "%d OUT, ", data_count );
1287#endif
1288 if (data_count == 1) {
1289 outb(*current_SC->SCp.ptr++, port_base + Write_FIFO);
1290 --current_SC->SCp.this_residual;
1291 } else {
1292 data_count >>= 1;
1293 outsw(port_base + Write_FIFO, current_SC->SCp.ptr, data_count);
1294 current_SC->SCp.ptr += 2 * data_count;
1295 current_SC->SCp.this_residual -= 2 * data_count;
1296 }
1297 }
1298 if (!current_SC->SCp.this_residual) {
1299 if (current_SC->SCp.buffers_residual) {
1300 --current_SC->SCp.buffers_residual;
1301 ++current_SC->SCp.buffer;
1302 current_SC->SCp.ptr = page_address(current_SC->SCp.buffer->page) + current_SC->SCp.buffer->offset;
1303 current_SC->SCp.this_residual = current_SC->SCp.buffer->length;
1304 } else
1305 break;
1306 }
1307 }
1308 }
1309
1310 if (current_SC->SCp.have_data_in == 1) { /* DATA IN */
1311 while ((data_count = inw(port_base + FIFO_Data_Count)) > 0) {
1312#if EVERY_ACCESS
1313 printk( "DC=%d, ", data_count );
1314#endif
1315 if (data_count > current_SC->SCp.this_residual)
1316 data_count = current_SC->SCp.this_residual;
1317 if (data_count) {
1318#if EVERY_ACCESS
1319 printk( "%d IN, ", data_count );
1320#endif
1321 if (data_count == 1) {
1322 *current_SC->SCp.ptr++ = inb(port_base + Read_FIFO);
1323 --current_SC->SCp.this_residual;
1324 } else {
1325 data_count >>= 1; /* Number of words */
1326 insw(port_base + Read_FIFO, current_SC->SCp.ptr, data_count);
1327 current_SC->SCp.ptr += 2 * data_count;
1328 current_SC->SCp.this_residual -= 2 * data_count;
1329 }
1330 }
1331 if (!current_SC->SCp.this_residual
1332 && current_SC->SCp.buffers_residual) {
1333 --current_SC->SCp.buffers_residual;
1334 ++current_SC->SCp.buffer;
1335 current_SC->SCp.ptr = page_address(current_SC->SCp.buffer->page) + current_SC->SCp.buffer->offset;
1336 current_SC->SCp.this_residual = current_SC->SCp.buffer->length;
1337 }
1338 }
1339 }
1340
1341 if (done) {
1342#if EVERY_ACCESS
1343 printk( " ** IN DONE %d ** ", current_SC->SCp.have_data_in );
1344#endif
1345
1346#if ERRORS_ONLY
1347 if (current_SC->cmnd[0] == REQUEST_SENSE && !current_SC->SCp.Status) {
1348 if ((unsigned char)(*((char *)current_SC->request_buffer+2)) & 0x0f) {
1349 unsigned char key;
1350 unsigned char code;
1351 unsigned char qualifier;
1352
1353 key = (unsigned char)(*((char *)current_SC->request_buffer + 2))
1354 & 0x0f;
1355 code = (unsigned char)(*((char *)current_SC->request_buffer + 12));
1356 qualifier = (unsigned char)(*((char *)current_SC->request_buffer
1357 + 13));
1358
1359 if (key != UNIT_ATTENTION
1360 && !(key == NOT_READY
1361 && code == 0x04
1362 && (!qualifier || qualifier == 0x02 || qualifier == 0x01))
1363 && !(key == ILLEGAL_REQUEST && (code == 0x25
1364 || code == 0x24
1365 || !code)))
1366
1367 printk( "scsi: <fdomain> REQUEST SENSE"
1368 " Key = %x, Code = %x, Qualifier = %x\n",
1369 key, code, qualifier );
1370 }
1371 }
1372#endif
1373#if EVERY_ACCESS
1374 printk( "BEFORE MY_DONE. . ." );
1375#endif
1376 spin_lock_irqsave(current_SC->device->host->host_lock, flags);
1377 my_done( (current_SC->SCp.Status & 0xff)
1378 | ((current_SC->SCp.Message & 0xff) << 8) | (DID_OK << 16) );
1379 spin_unlock_irqrestore(current_SC->device->host->host_lock, flags);
1380#if EVERY_ACCESS
1381 printk( "RETURNING.\n" );
1382#endif
1383
1384 } else {
1385 if (current_SC->SCp.phase & disconnect) {
1386 outb(0xd0 | FIFO_COUNT, port_base + Interrupt_Cntl);
1387 outb(0x00, port_base + SCSI_Cntl);
1388 } else {
1389 outb(0x90 | FIFO_COUNT, port_base + Interrupt_Cntl);
1390 }
1391 }
1392#if DEBUG_RACE
1393 in_interrupt_flag = 0;
1394#endif
1395 return IRQ_HANDLED;
1396}
1397
1398static int fdomain_16x0_queue(struct scsi_cmnd *SCpnt,
1399 void (*done)(struct scsi_cmnd *))
1400{
1401 if (in_command) {
1402 panic( "scsi: <fdomain> fdomain_16x0_queue() NOT REENTRANT!\n" );
1403 }
1404#if EVERY_ACCESS
1405 printk( "queue: target = %d cmnd = 0x%02x pieces = %d size = %u\n",
1406 SCpnt->target,
1407 *(unsigned char *)SCpnt->cmnd,
1408 SCpnt->use_sg,
1409 SCpnt->request_bufflen );
1410#endif
1411
1412 fdomain_make_bus_idle();
1413
1414 current_SC = SCpnt; /* Save this for the done function */
1415 current_SC->scsi_done = done;
1416
1417 /* Initialize static data */
1418
1419 if (current_SC->use_sg) {
1420 current_SC->SCp.buffer =
1421 (struct scatterlist *)current_SC->request_buffer;
1422 current_SC->SCp.ptr = page_address(current_SC->SCp.buffer->page) + current_SC->SCp.buffer->offset;
1423 current_SC->SCp.this_residual = current_SC->SCp.buffer->length;
1424 current_SC->SCp.buffers_residual = current_SC->use_sg - 1;
1425 } else {
1426 current_SC->SCp.ptr = (char *)current_SC->request_buffer;
1427 current_SC->SCp.this_residual = current_SC->request_bufflen;
1428 current_SC->SCp.buffer = NULL;
1429 current_SC->SCp.buffers_residual = 0;
1430 }
1431
1432
1433 current_SC->SCp.Status = 0;
1434 current_SC->SCp.Message = 0;
1435 current_SC->SCp.have_data_in = 0;
1436 current_SC->SCp.sent_command = 0;
1437 current_SC->SCp.phase = in_arbitration;
1438
1439 /* Start arbitration */
1440 outb(0x00, port_base + Interrupt_Cntl);
1441 outb(0x00, port_base + SCSI_Cntl); /* Disable data drivers */
1442 outb(adapter_mask, port_base + SCSI_Data_NoACK); /* Set our id bit */
1443 ++in_command;
1444 outb(0x20, port_base + Interrupt_Cntl);
1445 outb(0x14 | PARITY_MASK, port_base + TMC_Cntl); /* Start arbitration */
1446
1447 return 0;
1448}
1449
1450#if DEBUG_ABORT
1451static void print_info(struct scsi_cmnd *SCpnt)
1452{
1453 unsigned int imr;
1454 unsigned int irr;
1455 unsigned int isr;
1456
1457 if (!SCpnt || !SCpnt->device || !SCpnt->device->host) {
1458 printk(KERN_WARNING "scsi: <fdomain> Cannot provide detailed information\n");
1459 return;
1460 }
1461
1462 printk(KERN_INFO "%s\n", fdomain_16x0_info( SCpnt->device->host ) );
1463 print_banner(SCpnt->device->host);
1464 switch (SCpnt->SCp.phase) {
1465 case in_arbitration: printk("arbitration"); break;
1466 case in_selection: printk("selection"); break;
1467 case in_other: printk("other"); break;
1468 default: printk("unknown"); break;
1469 }
1470
1471 printk( " (%d), target = %d cmnd = 0x%02x pieces = %d size = %u\n",
1472 SCpnt->SCp.phase,
1473 SCpnt->device->id,
1474 *(unsigned char *)SCpnt->cmnd,
1475 SCpnt->use_sg,
1476 SCpnt->request_bufflen );
1477 printk( "sent_command = %d, have_data_in = %d, timeout = %d\n",
1478 SCpnt->SCp.sent_command,
1479 SCpnt->SCp.have_data_in,
1480 SCpnt->timeout );
1481#if DEBUG_RACE
1482 printk( "in_interrupt_flag = %d\n", in_interrupt_flag );
1483#endif
1484
1485 imr = (inb( 0x0a1 ) << 8) + inb( 0x21 );
1486 outb( 0x0a, 0xa0 );
1487 irr = inb( 0xa0 ) << 8;
1488 outb( 0x0a, 0x20 );
1489 irr += inb( 0x20 );
1490 outb( 0x0b, 0xa0 );
1491 isr = inb( 0xa0 ) << 8;
1492 outb( 0x0b, 0x20 );
1493 isr += inb( 0x20 );
1494
1495 /* Print out interesting information */
1496 printk( "IMR = 0x%04x", imr );
1497 if (imr & (1 << interrupt_level))
1498 printk( " (masked)" );
1499 printk( ", IRR = 0x%04x, ISR = 0x%04x\n", irr, isr );
1500
1501 printk( "SCSI Status = 0x%02x\n", inb(port_base + SCSI_Status));
1502 printk( "TMC Status = 0x%02x", inb(port_base + TMC_Status));
1503 if (inb((port_base + TMC_Status) & 1))
1504 printk( " (interrupt)" );
1505 printk( "\n" );
1506 printk("Interrupt Status = 0x%02x", inb(port_base + Interrupt_Status));
1507 if (inb(port_base + Interrupt_Status) & 0x08)
1508 printk( " (enabled)" );
1509 printk( "\n" );
1510 if (chip == tmc18c50 || chip == tmc18c30) {
1511 printk("FIFO Status = 0x%02x\n", inb(port_base + FIFO_Status));
1512 printk( "Int. Condition = 0x%02x\n",
1513 inb( port_base + Interrupt_Cond ) );
1514 }
1515 printk( "Configuration 1 = 0x%02x\n", inb( port_base + Configuration1 ) );
1516 if (chip == tmc18c50 || chip == tmc18c30)
1517 printk( "Configuration 2 = 0x%02x\n",
1518 inb( port_base + Configuration2 ) );
1519}
1520#endif
1521
1522static int fdomain_16x0_abort(struct scsi_cmnd *SCpnt)
1523{
1524#if EVERY_ACCESS || ERRORS_ONLY || DEBUG_ABORT
1525 printk( "scsi: <fdomain> abort " );
1526#endif
1527
1528 if (!in_command) {
1529#if EVERY_ACCESS || ERRORS_ONLY
1530 printk( " (not in command)\n" );
1531#endif
1532 return FAILED;
1533 } else printk( "\n" );
1534
1535#if DEBUG_ABORT
1536 print_info( SCpnt );
1537#endif
1538
1539 fdomain_make_bus_idle();
1540 current_SC->SCp.phase |= aborted;
1541 current_SC->result = DID_ABORT << 16;
1542
1543 /* Aborts are not done well. . . */
1544 my_done(DID_ABORT << 16);
1545 return SUCCESS;
1546}
1547
1548int fdomain_16x0_bus_reset(struct scsi_cmnd *SCpnt)
1549{
Jeff Garzik 68b3aa72005-05-28 07:56:31 -04001550 unsigned long flags;
1551
1552 local_irq_save(flags);
1553
Linus Torvalds1da177e2005-04-16 15:20:36 -07001554 outb(1, port_base + SCSI_Cntl);
1555 do_pause( 2 );
1556 outb(0, port_base + SCSI_Cntl);
1557 do_pause( 115 );
1558 outb(0, port_base + SCSI_Mode_Cntl);
1559 outb(PARITY_MASK, port_base + TMC_Cntl);
Jeff Garzik 68b3aa72005-05-28 07:56:31 -04001560
1561 local_irq_restore(flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001562 return SUCCESS;
1563}
1564
1565static int fdomain_16x0_biosparam(struct scsi_device *sdev,
1566 struct block_device *bdev,
1567 sector_t capacity, int *info_array)
1568{
1569 int drive;
1570 int size = capacity;
1571 unsigned long offset;
1572 struct drive_info {
1573 unsigned short cylinders;
1574 unsigned char heads;
1575 unsigned char sectors;
1576 } i;
1577
1578 /* NOTES:
1579 The RAM area starts at 0x1f00 from the bios_base address.
1580
1581 For BIOS Version 2.0:
1582
1583 The drive parameter table seems to start at 0x1f30.
1584 The first byte's purpose is not known.
1585 Next is the cylinder, head, and sector information.
1586 The last 4 bytes appear to be the drive's size in sectors.
1587 The other bytes in the drive parameter table are unknown.
1588 If anyone figures them out, please send me mail, and I will
1589 update these notes.
1590
1591 Tape drives do not get placed in this table.
1592
1593 There is another table at 0x1fea:
1594 If the byte is 0x01, then the SCSI ID is not in use.
1595 If the byte is 0x18 or 0x48, then the SCSI ID is in use,
1596 although tapes don't seem to be in this table. I haven't
1597 seen any other numbers (in a limited sample).
1598
1599 0x1f2d is a drive count (i.e., not including tapes)
1600
1601 The table at 0x1fcc are I/O ports addresses for the various
1602 operations. I calculate these by hand in this driver code.
1603
1604
1605
1606 For the ISA-200S version of BIOS Version 2.0:
1607
1608 The drive parameter table starts at 0x1f33.
1609
1610 WARNING: Assume that the table entry is 25 bytes long. Someone needs
1611 to check this for the Quantum ISA-200S card.
1612
1613
1614
1615 For BIOS Version 3.2:
1616
1617 The drive parameter table starts at 0x1f70. Each entry is
1618 0x0a bytes long. Heads are one less than we need to report.
1619 */
1620
1621 if (MAJOR(bdev->bd_dev) != SCSI_DISK0_MAJOR) {
1622 printk("scsi: <fdomain> fdomain_16x0_biosparam: too many disks");
1623 return 0;
1624 }
1625 drive = MINOR(bdev->bd_dev) >> 4;
1626
1627 if (bios_major == 2) {
1628 switch (Quantum) {
1629 case 2: /* ISA_200S */
1630 /* The value of 25 has never been verified.
1631 It should probably be 15. */
1632 offset = 0x1f33 + drive * 25;
1633 break;
1634 case 3: /* ISA_250MG */
1635 offset = 0x1f36 + drive * 15;
1636 break;
1637 case 4: /* ISA_200S (another one) */
1638 offset = 0x1f34 + drive * 15;
1639 break;
1640 default:
1641 offset = 0x1f31 + drive * 25;
1642 break;
1643 }
1644 memcpy_fromio( &i, bios_mem + offset, sizeof( struct drive_info ) );
1645 info_array[0] = i.heads;
1646 info_array[1] = i.sectors;
1647 info_array[2] = i.cylinders;
1648 } else if (bios_major == 3
1649 && bios_minor >= 0
1650 && bios_minor < 4) { /* 3.0 and 3.2 BIOS */
1651 memcpy_fromio( &i, bios_mem + 0x1f71 + drive * 10,
1652 sizeof( struct drive_info ) );
1653 info_array[0] = i.heads + 1;
1654 info_array[1] = i.sectors;
1655 info_array[2] = i.cylinders;
1656 } else { /* 3.4 BIOS (and up?) */
1657 /* This algorithm was provided by Future Domain (much thanks!). */
1658 unsigned char *p = scsi_bios_ptable(bdev);
1659
1660 if (p && p[65] == 0xaa && p[64] == 0x55 /* Partition table valid */
1661 && p[4]) { /* Partition type */
1662
1663 /* The partition table layout is as follows:
1664
1665 Start: 0x1b3h
1666 Offset: 0 = partition status
1667 1 = starting head
1668 2 = starting sector and cylinder (word, encoded)
1669 4 = partition type
1670 5 = ending head
1671 6 = ending sector and cylinder (word, encoded)
1672 8 = starting absolute sector (double word)
1673 c = number of sectors (double word)
1674 Signature: 0x1fe = 0x55aa
1675
1676 So, this algorithm assumes:
1677 1) the first partition table is in use,
1678 2) the data in the first entry is correct, and
1679 3) partitions never divide cylinders
1680
1681 Note that (1) may be FALSE for NetBSD (and other BSD flavors),
1682 as well as for Linux. Note also, that Linux doesn't pay any
1683 attention to the fields that are used by this algorithm -- it
1684 only uses the absolute sector data. Recent versions of Linux's
1685 fdisk(1) will fill this data in correctly, and forthcoming
1686 versions will check for consistency.
1687
1688 Checking for a non-zero partition type is not part of the
1689 Future Domain algorithm, but it seemed to be a reasonable thing
1690 to do, especially in the Linux and BSD worlds. */
1691
1692 info_array[0] = p[5] + 1; /* heads */
1693 info_array[1] = p[6] & 0x3f; /* sectors */
1694 } else {
1695
1696 /* Note that this new method guarantees that there will always be
1697 less than 1024 cylinders on a platter. This is good for drives
1698 up to approximately 7.85GB (where 1GB = 1024 * 1024 kB). */
1699
1700 if ((unsigned int)size >= 0x7e0000U) {
1701 info_array[0] = 0xff; /* heads = 255 */
1702 info_array[1] = 0x3f; /* sectors = 63 */
1703 } else if ((unsigned int)size >= 0x200000U) {
1704 info_array[0] = 0x80; /* heads = 128 */
1705 info_array[1] = 0x3f; /* sectors = 63 */
1706 } else {
1707 info_array[0] = 0x40; /* heads = 64 */
1708 info_array[1] = 0x20; /* sectors = 32 */
1709 }
1710 }
1711 /* For both methods, compute the cylinders */
1712 info_array[2] = (unsigned int)size / (info_array[0] * info_array[1] );
1713 kfree(p);
1714 }
1715
1716 return 0;
1717}
1718
1719static int fdomain_16x0_release(struct Scsi_Host *shpnt)
1720{
1721 if (shpnt->irq)
1722 free_irq(shpnt->irq, shpnt);
1723 if (shpnt->io_port && shpnt->n_io_port)
1724 release_region(shpnt->io_port, shpnt->n_io_port);
Alan Cox47bcd352006-10-16 16:55:46 +01001725 if (PCI_bus)
1726 pci_dev_put(PCI_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001727 return 0;
1728}
1729
1730struct scsi_host_template fdomain_driver_template = {
1731 .module = THIS_MODULE,
1732 .name = "fdomain",
1733 .proc_name = "fdomain",
1734 .detect = fdomain_16x0_detect,
1735 .info = fdomain_16x0_info,
1736 .queuecommand = fdomain_16x0_queue,
1737 .eh_abort_handler = fdomain_16x0_abort,
1738 .eh_bus_reset_handler = fdomain_16x0_bus_reset,
1739 .bios_param = fdomain_16x0_biosparam,
1740 .release = fdomain_16x0_release,
1741 .can_queue = 1,
1742 .this_id = 6,
1743 .sg_tablesize = 64,
1744 .cmd_per_lun = 1,
1745 .use_clustering = DISABLE_CLUSTERING,
1746};
1747
1748#ifndef PCMCIA
Ben Collins3985b972006-10-18 08:38:41 -04001749
1750static struct pci_device_id fdomain_pci_tbl[] __devinitdata = {
1751 { PCI_VENDOR_ID_FD, PCI_DEVICE_ID_FD_36C70,
1752 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
1753 { }
1754};
1755MODULE_DEVICE_TABLE(pci, fdomain_pci_tbl);
1756
Linus Torvalds1da177e2005-04-16 15:20:36 -07001757#define driver_template fdomain_driver_template
1758#include "scsi_module.c"
Ben Collins3985b972006-10-18 08:38:41 -04001759
Linus Torvalds1da177e2005-04-16 15:20:36 -07001760#endif