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