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