File: /usr/src/linux/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 then 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 DO_DETECT: This activates some old scan code which was needed before the
259 high level drivers got fixed. If you are having trouble with the driver,
260 turning this on should not hurt, and might help. Please let me know if
261 this is the case, since this code will be removed from future drivers.
262
263 RESELECTION: This is no longer an option, since I gave up trying to
264 implement it in version 4.x of this driver. It did not improve
265 performance at all and made the driver unstable (because I never found one
266 of the two race conditions which were introduced by the multiple
267 outstanding command code). The instability seems a very high price to pay
268 just so that you don't have to wait for the tape to rewind. If you want
269 this feature implemented, send me patches. I'll be happy to send a copy
270 of my (broken) driver to anyone who would like to see a copy.
271
272 **************************************************************************/
273
274 #include <linux/module.h>
275
276 #ifdef PCMCIA
277 #undef MODULE
278 #endif
279
280 #include <linux/init.h>
281 #include <linux/sched.h>
282 #include <asm/io.h>
283 #include <linux/blk.h>
284 #include "scsi.h"
285 #include "hosts.h"
286 #include "fdomain.h"
287 #include <asm/system.h>
288 #include <linux/spinlock.h>
289 #include <linux/errno.h>
290 #include <linux/string.h>
291 #include <linux/ioport.h>
292 #include <linux/proc_fs.h>
293 #include <linux/pci.h>
294 #include <linux/stat.h>
295 #include <linux/delay.h>
296
297 #include <linux/config.h> /* for CONFIG_PCI */
298
299 #define VERSION "$Revision: 5.50 $"
300
301 /* START OF USER DEFINABLE OPTIONS */
302
303 #define DEBUG 1 /* Enable debugging output */
304 #define ENABLE_PARITY 1 /* Enable SCSI Parity */
305 #define FIFO_COUNT 2 /* Number of 512 byte blocks before INTR */
306 #define DO_DETECT 0 /* Do device detection here (see scsi.c) */
307
308 /* END OF USER DEFINABLE OPTIONS */
309
310 #if DEBUG
311 #define EVERY_ACCESS 0 /* Write a line on every scsi access */
312 #define ERRORS_ONLY 1 /* Only write a line if there is an error */
313 #define DEBUG_DETECT 0 /* Debug fdomain_16x0_detect() */
314 #define DEBUG_MESSAGES 1 /* Debug MESSAGE IN phase */
315 #define DEBUG_ABORT 1 /* Debug abort() routine */
316 #define DEBUG_RESET 1 /* Debug reset() routine */
317 #define DEBUG_RACE 1 /* Debug interrupt-driven race condition */
318 #else
319 #define EVERY_ACCESS 0 /* LEAVE THESE ALONE--CHANGE THE ONES ABOVE */
320 #define ERRORS_ONLY 0
321 #define DEBUG_DETECT 0
322 #define DEBUG_MESSAGES 0
323 #define DEBUG_ABORT 0
324 #define DEBUG_RESET 0
325 #define DEBUG_RACE 0
326 #endif
327
328 /* Errors are reported on the line, so we don't need to report them again */
329 #if EVERY_ACCESS
330 #undef ERRORS_ONLY
331 #define ERRORS_ONLY 0
332 #endif
333
334 #if ENABLE_PARITY
335 #define PARITY_MASK 0x08
336 #else
337 #define PARITY_MASK 0x00
338 #endif
339
340 enum chip_type {
341 unknown = 0x00,
342 tmc1800 = 0x01,
343 tmc18c50 = 0x02,
344 tmc18c30 = 0x03,
345 };
346
347 enum {
348 in_arbitration = 0x02,
349 in_selection = 0x04,
350 in_other = 0x08,
351 disconnect = 0x10,
352 aborted = 0x20,
353 sent_ident = 0x40,
354 };
355
356 enum in_port_type {
357 Read_SCSI_Data = 0,
358 SCSI_Status = 1,
359 TMC_Status = 2,
360 FIFO_Status = 3, /* tmc18c50/tmc18c30 only */
361 Interrupt_Cond = 4, /* tmc18c50/tmc18c30 only */
362 LSB_ID_Code = 5,
363 MSB_ID_Code = 6,
364 Read_Loopback = 7,
365 SCSI_Data_NoACK = 8,
366 Interrupt_Status = 9,
367 Configuration1 = 10,
368 Configuration2 = 11, /* tmc18c50/tmc18c30 only */
369 Read_FIFO = 12,
370 FIFO_Data_Count = 14
371 };
372
373 enum out_port_type {
374 Write_SCSI_Data = 0,
375 SCSI_Cntl = 1,
376 Interrupt_Cntl = 2,
377 SCSI_Mode_Cntl = 3,
378 TMC_Cntl = 4,
379 Memory_Cntl = 5, /* tmc18c50/tmc18c30 only */
380 Write_Loopback = 7,
381 IO_Control = 11, /* tmc18c30 only */
382 Write_FIFO = 12
383 };
384
385 static int port_base = 0;
386 static unsigned long bios_base = 0;
387 static int bios_major = 0;
388 static int bios_minor = 0;
389 static int PCI_bus = 0;
390 static int Quantum = 0; /* Quantum board variant */
391 static int interrupt_level = 0;
392 static volatile int in_command = 0;
393 static Scsi_Cmnd *current_SC = NULL;
394 static enum chip_type chip = unknown;
395 static int adapter_mask = 0;
396 static int this_id = 0;
397 static int setup_called = 0;
398
399 #if DEBUG_RACE
400 static volatile int in_interrupt_flag = 0;
401 #endif
402
403 static int SCSI_Mode_Cntl_port;
404 static int FIFO_Data_Count_port;
405 static int Interrupt_Cntl_port;
406 static int Interrupt_Status_port;
407 static int Read_FIFO_port;
408 static int Read_SCSI_Data_port;
409 static int SCSI_Cntl_port;
410 static int SCSI_Data_NoACK_port;
411 static int SCSI_Status_port;
412 static int TMC_Cntl_port;
413 static int TMC_Status_port;
414 static int Write_FIFO_port;
415 static int Write_SCSI_Data_port;
416
417 static int FIFO_Size = 0x2000; /* 8k FIFO for
418 pre-tmc18c30 chips */
419
420 extern void do_fdomain_16x0_intr( int irq, void *dev_id,
421 struct pt_regs * regs );
422
423 #ifdef MODULE
424 /* Allow insmod parameters to be like LILO
425 parameters. For example:
426 insmod fdomain fdomain=0x140,11
427 */
428 static char * fdomain = NULL;
429 MODULE_PARM(fdomain, "s");
430 #endif
431
432 static unsigned long addresses[] = {
433 0xc8000,
434 0xca000,
435 0xce000,
436 0xde000,
437 0xcc000, /* Extra addresses for PCI boards */
438 0xd0000,
439 0xe0000,
440 };
441 #define ADDRESS_COUNT (sizeof( addresses ) / sizeof( unsigned ))
442
443 static unsigned short ports[] = { 0x140, 0x150, 0x160, 0x170 };
444 #define PORT_COUNT (sizeof( ports ) / sizeof( unsigned short ))
445
446 static unsigned short ints[] = { 3, 5, 10, 11, 12, 14, 15, 0 };
447
448 /*
449
450 READ THIS BEFORE YOU ADD A SIGNATURE!
451
452 READING THIS SHORT NOTE CAN SAVE YOU LOTS OF TIME!
453
454 READ EVERY WORD, ESPECIALLY THE WORD *NOT*
455
456 This driver works *ONLY* for Future Domain cards using the TMC-1800,
457 TMC-18C50, or TMC-18C30 chip. This includes models TMC-1650, 1660, 1670,
458 and 1680. These are all 16-bit cards.
459
460 The following BIOS signature signatures are for boards which do *NOT*
461 work with this driver (these TMC-8xx and TMC-9xx boards may work with the
462 Seagate driver):
463
464 FUTURE DOMAIN CORP. (C) 1986-1988 V4.0I 03/16/88
465 FUTURE DOMAIN CORP. (C) 1986-1989 V5.0C2/14/89
466 FUTURE DOMAIN CORP. (C) 1986-1989 V6.0A7/28/89
467 FUTURE DOMAIN CORP. (C) 1986-1990 V6.0105/31/90
468 FUTURE DOMAIN CORP. (C) 1986-1990 V6.0209/18/90
469 FUTURE DOMAIN CORP. (C) 1986-1990 V7.009/18/90
470 FUTURE DOMAIN CORP. (C) 1992 V8.00.004/02/92
471
472 (The cards which do *NOT* work are all 8-bit cards -- although some of
473 them have a 16-bit form-factor, the upper 8-bits are used only for IRQs
474 and are *NOT* used for data. You can tell the difference by following
475 the tracings on the circuit board -- if only the IRQ lines are involved,
476 you have a "8-bit" card, and should *NOT* use this driver.)
477
478 */
479
480 struct signature {
481 const char *signature;
482 int sig_offset;
483 int sig_length;
484 int major_bios_version;
485 int minor_bios_version;
486 int flag; /* 1 == PCI_bus, 2 == ISA_200S, 3 == ISA_250MG, 4 == ISA_200S */
487 } signatures[] = {
488 /* 1 2 3 4 5 6 */
489 /* 123456789012345678901234567890123456789012345678901234567890 */
490 { "FUTURE DOMAIN CORP. (C) 1986-1990 1800-V2.07/28/89", 5, 50, 2, 0, 0 },
491 { "FUTURE DOMAIN CORP. (C) 1986-1990 1800-V1.07/28/89", 5, 50, 2, 0, 0 },
492 { "FUTURE DOMAIN CORP. (C) 1986-1990 1800-V2.07/28/89", 72, 50, 2, 0, 2 },
493 { "FUTURE DOMAIN CORP. (C) 1986-1990 1800-V2.0", 73, 43, 2, 0, 3 },
494 { "FUTURE DOMAIN CORP. (C) 1991 1800-V2.0.", 72, 39, 2, 0, 4 },
495 { "FUTURE DOMAIN CORP. (C) 1992 V3.00.004/02/92", 5, 44, 3, 0, 0 },
496 { "FUTURE DOMAIN TMC-18XX (C) 1993 V3.203/12/93", 5, 44, 3, 2, 0 },
497 { "IBM F1 P2 BIOS v1.0104/29/93", 5, 28, 3, -1, 0 },
498 { "Future Domain Corp. V1.0008/18/93", 5, 33, 3, 4, 0 },
499 { "Future Domain Corp. V1.0008/18/93", 26, 33, 3, 4, 1 },
500 { "Adaptec AHA-2920 PCI-SCSI Card", 42, 31, 3, -1, 1 },
501 { "IBM F1 P264/32", 5, 14, 3, -1, 1 },
502 /* This next signature may not be a 3.5 bios */
503 { "Future Domain Corp. V2.0108/18/93", 5, 33, 3, 5, 0 },
504 { "FUTURE DOMAIN CORP. V3.5008/18/93", 5, 34, 3, 5, 0 },
505 { "FUTURE DOMAIN 18c30/18c50/1800 (C) 1994 V3.5", 5, 44, 3, 5, 0 },
506 { "FUTURE DOMAIN CORP. V3.6008/18/93", 5, 34, 3, 6, 0 },
507 { "FUTURE DOMAIN CORP. V3.6108/18/93", 5, 34, 3, 6, 0 },
508 { "FUTURE DOMAIN TMC-18XX", 5, 22, -1, -1, 0 },
509
510 /* READ NOTICE ABOVE *BEFORE* YOU WASTE YOUR TIME ADDING A SIGNATURE
511 Also, fix the disk geometry code for your signature and send your
512 changes for faith@cs.unc.edu. Above all, do *NOT* change any old
513 signatures!
514
515 Note that the last line will match a "generic" 18XX bios. Because
516 Future Domain has changed the host SCSI ID and/or the location of the
517 geometry information in the on-board RAM area for each of the first
518 three BIOS's, it is still important to enter a fully qualified
519 signature in the table for any new BIOS's (after the host SCSI ID and
520 geometry location are verified). */
521 };
522
523 #define SIGNATURE_COUNT (sizeof( signatures ) / sizeof( struct signature ))
524
525 static void print_banner( struct Scsi_Host *shpnt )
526 {
527 if (!shpnt) return; /* This won't ever happen */
528
529 if (bios_major < 0 && bios_minor < 0) {
530 printk( "scsi%d: <fdomain> No BIOS; using scsi id %d\n",
531 shpnt->host_no, shpnt->this_id );
532 } else {
533 printk( "scsi%d: <fdomain> BIOS version ", shpnt->host_no );
534
535 if (bios_major >= 0) printk( "%d.", bios_major );
536 else printk( "?." );
537
538 if (bios_minor >= 0) printk( "%d", bios_minor );
539 else printk( "?." );
540
541 printk( " at 0x%lx using scsi id %d\n",
542 bios_base, shpnt->this_id );
543 }
544
545 /* If this driver works for later FD PCI
546 boards, we will have to modify banner
547 for additional PCI cards, but for now if
548 it's PCI it's a TMC-3260 - JTM */
549 printk( "scsi%d: <fdomain> %s chip at 0x%x irq ",
550 shpnt->host_no,
551 chip == tmc1800 ? "TMC-1800"
552 : (chip == tmc18c50 ? "TMC-18C50"
553 : (chip == tmc18c30 ?
554 (PCI_bus ? "TMC-36C70 (PCI bus)" : "TMC-18C30")
555 : "Unknown")),
556 port_base );
557
558 if (interrupt_level) printk( "%d", interrupt_level );
559 else printk( "<none>" );
560
561 printk( "\n" );
562 }
563
564 static int __init fdomain_setup( char *str )
565 {
566 int ints[4];
567
568 (void)get_options(str, ARRAY_SIZE(ints), ints);
569
570 if (setup_called++ || ints[0] < 2 || ints[0] > 3) {
571 printk( "scsi: <fdomain>"
572 " Usage: fdomain=<PORT_BASE>,<IRQ>[,<ADAPTER_ID>]\n" );
573 printk( "scsi: <fdomain> Bad LILO/INSMOD parameters?\n" );
574 return 0;
575 }
576
577 port_base = ints[0] >= 1 ? ints[1] : 0;
578 interrupt_level = ints[0] >= 2 ? ints[2] : 0;
579 this_id = ints[0] >= 3 ? ints[3] : 0;
580
581 bios_major = bios_minor = -1; /* Use geometry for BIOS version >= 3.4 */
582 ++setup_called;
583 return 1;
584 }
585
586 __setup("fdomain=", fdomain_setup);
587
588
589 static void do_pause( unsigned amount ) /* Pause for amount*10 milliseconds */
590 {
591 mdelay(10*amount);
592 }
593
594 inline static void fdomain_make_bus_idle( void )
595 {
596 outb( 0, SCSI_Cntl_port );
597 outb( 0, SCSI_Mode_Cntl_port );
598 if (chip == tmc18c50 || chip == tmc18c30)
599 outb( 0x21 | PARITY_MASK, TMC_Cntl_port ); /* Clear forced intr. */
600 else
601 outb( 0x01 | PARITY_MASK, TMC_Cntl_port );
602 }
603
604 static int fdomain_is_valid_port( int port )
605 {
606 #if DEBUG_DETECT
607 printk( " (%x%x),",
608 inb( port + MSB_ID_Code ), inb( port + LSB_ID_Code ) );
609 #endif
610
611 /* The MCA ID is a unique id for each MCA compatible board. We
612 are using ISA boards, but Future Domain provides the MCA ID
613 anyway. We can use this ID to ensure that this is a Future
614 Domain TMC-1660/TMC-1680.
615 */
616
617 if (inb( port + LSB_ID_Code ) != 0xe9) { /* test for 0x6127 id */
618 if (inb( port + LSB_ID_Code ) != 0x27) return 0;
619 if (inb( port + MSB_ID_Code ) != 0x61) return 0;
620 chip = tmc1800;
621 } else { /* test for 0xe960 id */
622 if (inb( port + MSB_ID_Code ) != 0x60) return 0;
623 chip = tmc18c50;
624
625 /* Try to toggle 32-bit mode. This only
626 works on an 18c30 chip. (User reports
627 say this works, so we should switch to
628 it in the near future.) */
629
630 outb( 0x80, port + IO_Control );
631 if ((inb( port + Configuration2 ) & 0x80) == 0x80) {
632 outb( 0x00, port + IO_Control );
633 if ((inb( port + Configuration2 ) & 0x80) == 0x00) {
634 chip = tmc18c30;
635 FIFO_Size = 0x800; /* 2k FIFO */
636 }
637 }
638 /* If that failed, we are an 18c50. */
639 }
640
641 return 1;
642 }
643
644 static int fdomain_test_loopback( void )
645 {
646 int i;
647 int result;
648
649 for (i = 0; i < 255; i++) {
650 outb( i, port_base + Write_Loopback );
651 result = inb( port_base + Read_Loopback );
652 if (i != result)
653 return 1;
654 }
655 return 0;
656 }
657
658 /* fdomain_get_irq assumes that we have a valid MCA ID for a
659 TMC-1660/TMC-1680 Future Domain board. Now, check to be sure the
660 bios_base matches these ports. If someone was unlucky enough to have
661 purchased more than one Future Domain board, then they will have to
662 modify this code, as we only detect one board here. [The one with the
663 lowest bios_base.]
664
665 Note that this routine is only used for systems without a PCI BIOS32
666 (e.g., ISA bus). For PCI bus systems, this routine will likely fail
667 unless one of the IRQs listed in the ints array is used by the board.
668 Sometimes it is possible to use the computer's BIOS setup screen to
669 configure a PCI system so that one of these IRQs will be used by the
670 Future Domain card. */
671
672 static int fdomain_get_irq( int base )
673 {
674 int options = inb( base + Configuration1 );
675
676 #if DEBUG_DETECT
677 printk( "scsi: <fdomain> Options = %x\n", options );
678 #endif
679
680 /* Check for board with lowest bios_base --
681 this isn't valid for the 18c30 or for
682 boards on the PCI bus, so just assume we
683 have the right board. */
684
685 if (chip != tmc18c30
686 && !PCI_bus
687 && addresses[ (options & 0xc0) >> 6 ] != bios_base) return 0;
688
689 return ints[ (options & 0x0e) >> 1 ];
690 }
691
692 static int fdomain_isa_detect( int *irq, int *iobase )
693 {
694 int i, j;
695 int base = 0xdeadbeef;
696 int flag = 0;
697
698 #if DEBUG_DETECT
699 printk( "scsi: <fdomain> fdomain_isa_detect:" );
700 #endif
701
702
703 for (i = 0; !bios_base && i < ADDRESS_COUNT; i++) {
704 #if DEBUG_DETECT
705 printk( " %lx(%lx),", addresses[i], bios_base );
706 #endif
707 for (j = 0; !bios_base && j < SIGNATURE_COUNT; j++) {
708 if (isa_check_signature(addresses[i] + signatures[j].sig_offset,
709 signatures[j].signature,
710 signatures[j].sig_length )) {
711 bios_major = signatures[j].major_bios_version;
712 bios_minor = signatures[j].minor_bios_version;
713 PCI_bus = (signatures[j].flag == 1);
714 Quantum = (signatures[j].flag > 1) ? signatures[j].flag : 0;
715 bios_base = addresses[i];
716 }
717 }
718 }
719
720 if (bios_major == 2) {
721 /* The TMC-1660/TMC-1680 has a RAM area just after the BIOS ROM.
722 Assuming the ROM is enabled (otherwise we wouldn't have been
723 able to read the ROM signature :-), then the ROM sets up the
724 RAM area with some magic numbers, such as a list of port
725 base addresses and a list of the disk "geometry" reported to
726 DOS (this geometry has nothing to do with physical geometry).
727 */
728
729 switch (Quantum) {
730 case 2: /* ISA_200S */
731 case 3: /* ISA_250MG */
732 base = readb(bios_base + 0x1fa2) + (readb(bios_base + 0x1fa3) << 8);
733 break;
734 case 4: /* ISA_200S (another one) */
735 base = readb(bios_base + 0x1fa3) + (readb(bios_base + 0x1fa4) << 8);
736 break;
737 default:
738 base = readb(bios_base + 0x1fcc) + (readb(bios_base + 0x1fcd) << 8);
739 break;
740 }
741
742 #if DEBUG_DETECT
743 printk( " %x,", base );
744 #endif
745
746 for (flag = 0, i = 0; !flag && i < PORT_COUNT; i++) {
747 if (base == ports[i])
748 ++flag;
749 }
750
751 if (flag && fdomain_is_valid_port( base )) {
752 *irq = fdomain_get_irq( base );
753 *iobase = base;
754 return 1;
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 (check_region( base, 0x10 )) {
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 if ((flag = fdomain_is_valid_port( base ))) break;
787 }
788
789 #if DEBUG_DETECT
790 if (flag) printk( " SUCCESS\n" );
791 else printk( " FAILURE\n" );
792 #endif
793
794 if (!flag) return 0; /* iobase not found */
795
796 *irq = fdomain_get_irq( base );
797 *iobase = base;
798
799 return 1; /* success */
800 }
801
802 /* PCI detection function: int fdomain_pci_bios_detect(int* irq, int*
803 iobase) This function gets the Interrupt Level and I/O base address from
804 the PCI configuration registers. */
805
806 #ifdef CONFIG_PCI
807 static int fdomain_pci_bios_detect( int *irq, int *iobase, struct pci_dev **ret_pdev )
808 {
809 unsigned int pci_irq; /* PCI interrupt line */
810 unsigned long pci_base; /* PCI I/O base address */
811 struct pci_dev *pdev = NULL;
812
813 if (!pci_present()) return 0;
814
815 #if DEBUG_DETECT
816 /* Tell how to print a list of the known PCI devices from bios32 and
817 list vendor and device IDs being used if in debug mode. */
818
819 printk( "scsi: <fdomain> INFO: use lspci -v to see list of PCI devices\n" );
820 printk( "scsi: <fdomain> TMC-3260 detect:"
821 " Using Vendor ID: 0x%x and Device ID: 0x%x\n",
822 PCI_VENDOR_ID_FD,
823 PCI_DEVICE_ID_FD_36C70 );
824 #endif
825
826 if ((pdev = pci_find_device(PCI_VENDOR_ID_FD,
827 PCI_DEVICE_ID_FD_36C70,
828 pdev)) == NULL)
829 return 0;
830 if (pci_enable_device(pdev)) return 0;
831
832 #if DEBUG_DETECT
833 printk( "scsi: <fdomain> TMC-3260 detect:"
834 " PCI bus %u, device %u, function %u\n",
835 pdev->bus->number,
836 PCI_SLOT(pdev->devfn),
837 PCI_FUNC(pdev->devfn));
838 #endif
839
840 /* We now have the appropriate device function for the FD board so we
841 just read the PCI config info from the registers. */
842
843 pci_base = pci_resource_start(pdev, 0);
844 pci_irq = pdev->irq;
845
846 /* Now we have the I/O base address and interrupt from the PCI
847 configuration registers. */
848
849 *irq = pci_irq;
850 *iobase = pci_base;
851 *ret_pdev = pdev;
852
853 #if DEBUG_DETECT
854 printk( "scsi: <fdomain> TMC-3260 detect:"
855 " IRQ = %d, I/O base = 0x%x [0x%lx]\n", *irq, *iobase, pci_base );
856 #endif
857
858 if (!fdomain_is_valid_port( *iobase )) {
859 printk( "scsi: <fdomain>"
860 " PCI card detected, but driver not loaded (invalid port)\n" );
861 return 0;
862 }
863
864 /* Fill in a few global variables. Ugh. */
865 bios_major = bios_minor = -1;
866 PCI_bus = 1;
867 Quantum = 0;
868 bios_base = 0;
869
870 return 1;
871 }
872 #endif
873
874 int fdomain_16x0_detect( Scsi_Host_Template *tpnt )
875 {
876 int retcode;
877 struct Scsi_Host *shpnt;
878 struct pci_dev *pdev = NULL;
879 #if DO_DETECT
880 int i = 0;
881 int j = 0;
882 const int buflen = 255;
883 Scsi_Cmnd SCinit;
884 unsigned char do_inquiry[] = { INQUIRY, 0, 0, 0, buflen, 0 };
885 unsigned char do_request_sense[] = { REQUEST_SENSE, 0, 0, 0, buflen, 0 };
886 unsigned char do_read_capacity[] = { READ_CAPACITY,
887 0, 0, 0, 0, 0, 0, 0, 0, 0 };
888 unsigned char buf[buflen];
889 #endif
890
891 tpnt->proc_name = "fdomain";
892
893 #ifdef MODULE
894 if (fdomain)
895 fdomain_setup(fdomain);
896 #endif
897
898 if (setup_called) {
899 #if DEBUG_DETECT
900 printk( "scsi: <fdomain> No BIOS, using port_base = 0x%x, irq = %d\n",
901 port_base, interrupt_level );
902 #endif
903 if (!fdomain_is_valid_port( port_base )) {
904 printk( "scsi: <fdomain> Cannot locate chip at port base 0x%x\n",
905 port_base );
906 printk( "scsi: <fdomain> Bad LILO/INSMOD parameters?\n" );
907 return 0;
908 }
909 } else {
910 int flag = 0;
911
912 #ifdef CONFIG_PCI
913 /* Try PCI detection first */
914 flag = fdomain_pci_bios_detect( &interrupt_level, &port_base, &pdev );
915 #endif
916 if (!flag) {
917 /* Then try ISA bus detection */
918 flag = fdomain_isa_detect( &interrupt_level, &port_base );
919
920 if (!flag) {
921 printk( "scsi: <fdomain> Detection failed (no card)\n" );
922 return 0;
923 }
924 }
925 }
926
927 SCSI_Mode_Cntl_port = port_base + SCSI_Mode_Cntl;
928 FIFO_Data_Count_port = port_base + FIFO_Data_Count;
929 Interrupt_Cntl_port = port_base + Interrupt_Cntl;
930 Interrupt_Status_port = port_base + Interrupt_Status;
931 Read_FIFO_port = port_base + Read_FIFO;
932 Read_SCSI_Data_port = port_base + Read_SCSI_Data;
933 SCSI_Cntl_port = port_base + SCSI_Cntl;
934 SCSI_Data_NoACK_port = port_base + SCSI_Data_NoACK;
935 SCSI_Status_port = port_base + SCSI_Status;
936 TMC_Cntl_port = port_base + TMC_Cntl;
937 TMC_Status_port = port_base + TMC_Status;
938 Write_FIFO_port = port_base + Write_FIFO;
939 Write_SCSI_Data_port = port_base + Write_SCSI_Data;
940
941 fdomain_16x0_reset( NULL, 0 );
942
943 if (fdomain_test_loopback()) {
944 printk( "scsi: <fdomain> Detection failed"
945 " (loopback test failed at port base 0x%x)\n", port_base );
946 if (setup_called) {
947 printk( "scsi: <fdomain> Bad LILO/INSMOD parameters?\n" );
948 }
949 return 0;
950 }
951
952 if (this_id) {
953 tpnt->this_id = (this_id & 0x07);
954 adapter_mask = (1 << tpnt->this_id);
955 } else {
956 if (PCI_bus || (bios_major == 3 && bios_minor >= 2) || bios_major < 0) {
957 tpnt->this_id = 7;
958 adapter_mask = 0x80;
959 } else {
960 tpnt->this_id = 6;
961 adapter_mask = 0x40;
962 }
963 }
964
965 /* Print out a banner here in case we can't
966 get resources. */
967
968 shpnt = scsi_register( tpnt, 0 );
969 if(shpnt == NULL)
970 return 0;
971 shpnt->irq = interrupt_level;
972 shpnt->io_port = port_base;
973 scsi_set_pci_device(shpnt, pdev);
974 shpnt->n_io_port = 0x10;
975 print_banner( shpnt );
976
977 /* Log IRQ with kernel */
978 if (!interrupt_level) {
979 printk( "scsi: <fdomain>"
980 " Card Detected, but driver not loaded (no IRQ)\n" );
981 return 0;
982 } else {
983 /* Register the IRQ with the kernel */
984
985 retcode = request_irq( interrupt_level,
986 do_fdomain_16x0_intr, pdev?SA_SHIRQ:0, "fdomain", NULL);
987
988 if (retcode < 0) {
989 if (retcode == -EINVAL) {
990 printk( "scsi: <fdomain> IRQ %d is bad!\n", interrupt_level );
991 printk( " This shouldn't happen!\n" );
992 printk( " Send mail to faith@acm.org\n" );
993 } else if (retcode == -EBUSY) {
994 printk( "scsi: <fdomain> IRQ %d is already in use!\n",
995 interrupt_level );
996 printk( " Please use another IRQ!\n" );
997 } else {
998 printk( "scsi: <fdomain> Error getting IRQ %d\n",
999 interrupt_level );
1000 printk( " This shouldn't happen!\n" );
1001 printk( " Send mail to faith@acm.org\n" );
1002 }
1003 printk( "scsi: <fdomain> Detected, but driver not loaded (IRQ)\n" );
1004 return 0;
1005 }
1006 }
1007
1008 /* Log I/O ports with kernel */
1009 request_region( port_base, 0x10, "fdomain" );
1010
1011 #if DO_DETECT
1012
1013 /* These routines are here because of the way the SCSI bus behaves after
1014 a reset. This appropriate behavior was not handled correctly by the
1015 higher level SCSI routines when I first wrote this driver. Now,
1016 however, correct scan routines are part of scsi.c and these routines
1017 are no longer needed. However, this code is still good for
1018 debugging. */
1019
1020 SCinit.request_buffer = SCinit.buffer = buf;
1021 SCinit.request_bufflen = SCinit.bufflen = sizeof(buf)-1;
1022 SCinit.use_sg = 0;
1023 SCinit.lun = 0;
1024
1025 printk( "scsi: <fdomain> detection routine scanning for devices:\n" );
1026 for (i = 0; i < 8; i++) {
1027 SCinit.target = i;
1028 if (i == tpnt->this_id) /* Skip host adapter */
1029 continue;
1030 memcpy(SCinit.cmnd, do_request_sense, sizeof(do_request_sense));
1031 retcode = fdomain_16x0_command(&SCinit);
1032 if (!retcode) {
1033 memcpy(SCinit.cmnd, do_inquiry, sizeof(do_inquiry));
1034 retcode = fdomain_16x0_command(&SCinit);
1035 if (!retcode) {
1036 printk( " SCSI ID %d: ", i );
1037 for (j = 8; j < (buf[4] < 32 ? buf[4] : 32); j++)
1038 printk( "%c", buf[j] >= 20 ? buf[j] : ' ' );
1039 memcpy(SCinit.cmnd, do_read_capacity, sizeof(do_read_capacity));
1040 retcode = fdomain_16x0_command(&SCinit);
1041 if (!retcode) {
1042 unsigned long blocks, size, capacity;
1043
1044 blocks = (buf[0] << 24) | (buf[1] << 16)
1045 | (buf[2] << 8) | buf[3];
1046 size = (buf[4] << 24) | (buf[5] << 16) | (buf[6] << 8) | buf[7];
1047 capacity = +( +(blocks / 1024L) * +(size * 10L)) / 1024L;
1048
1049 printk( "%lu MB (%lu byte blocks)",
1050 ((capacity + 5L) / 10L), size );
1051 } else {
1052 memcpy(SCinit.cmnd, do_request_sense, sizeof(do_request_sense));
1053 retcode = fdomain_16x0_command(&SCinit);
1054 }
1055 printk ("\n" );
1056 } else {
1057 memcpy(SCinit.cmnd, do_request_sense, sizeof(do_request_sense));
1058 retcode = fdomain_16x0_command(&SCinit);
1059 }
1060 }
1061 }
1062 #endif
1063
1064 return 1; /* Maximum of one adapter will be detected. */
1065 }
1066
1067 const char *fdomain_16x0_info( struct Scsi_Host *ignore )
1068 {
1069 static char buffer[128];
1070 char *pt;
1071
1072 strcpy( buffer, "Future Domain 16-bit SCSI Driver Version" );
1073 if (strchr( VERSION, ':')) { /* Assume VERSION is an RCS Revision string */
1074 strcat( buffer, strchr( VERSION, ':' ) + 1 );
1075 pt = strrchr( buffer, '$') - 1;
1076 if (!pt) /* Stripped RCS Revision string? */
1077 pt = buffer + strlen( buffer ) - 1;
1078 if (*pt != ' ')
1079 ++pt;
1080 *pt = '\0';
1081 } else { /* Assume VERSION is a number */
1082 strcat( buffer, " " VERSION );
1083 }
1084
1085 return buffer;
1086 }
1087
1088 /* First pass at /proc information routine. */
1089 /*
1090 * inout : decides on the direction of the dataflow and the meaning of the
1091 * variables
1092 * buffer: If inout==FALSE data is being written to it else read from it
1093 * *start: If inout==FALSE start of the valid data in the buffer
1094 * offset: If inout==FALSE offset from the beginning of the imaginary file
1095 * from which we start writing into the buffer
1096 * length: If inout==FALSE max number of bytes to be written into the buffer
1097 * else number of bytes in the buffer
1098 */
1099 int fdomain_16x0_proc_info( char *buffer, char **start, off_t offset,
1100 int length, int hostno, int inout )
1101 {
1102 const char *info = fdomain_16x0_info( NULL );
1103 int len;
1104 int pos;
1105 int begin;
1106
1107 if (inout) return(-ENOSYS);
1108
1109 begin = 0;
1110 strcpy( buffer, info );
1111 strcat( buffer, "\n" );
1112
1113 pos = len = strlen( buffer );
1114
1115 if(pos < offset) {
1116 len = 0;
1117 begin = pos;
1118 }
1119
1120 *start = buffer + (offset - begin); /* Start of wanted data */
1121 len -= (offset - begin);
1122 if(len > length) len = length;
1123
1124 return(len);
1125 }
1126
1127 #if 0
1128 static int fdomain_arbitrate( void )
1129 {
1130 int status = 0;
1131 unsigned long timeout;
1132
1133 #if EVERY_ACCESS
1134 printk( "fdomain_arbitrate()\n" );
1135 #endif
1136
1137 outb( 0x00, SCSI_Cntl_port ); /* Disable data drivers */
1138 outb( adapter_mask, port_base + SCSI_Data_NoACK ); /* Set our id bit */
1139 outb( 0x04 | PARITY_MASK, TMC_Cntl_port ); /* Start arbitration */
1140
1141 timeout = 500;
1142 do {
1143 status = inb( TMC_Status_port ); /* Read adapter status */
1144 if (status & 0x02) /* Arbitration complete */
1145 return 0;
1146 mdelay(1); /* Wait one millisecond */
1147 } while (--timeout);
1148
1149 /* Make bus idle */
1150 fdomain_make_bus_idle();
1151
1152 #if EVERY_ACCESS
1153 printk( "Arbitration failed, status = %x\n", status );
1154 #endif
1155 #if ERRORS_ONLY
1156 printk( "scsi: <fdomain> Arbitration failed, status = %x\n", status );
1157 #endif
1158 return 1;
1159 }
1160 #endif
1161
1162 static int fdomain_select( int target )
1163 {
1164 int status;
1165 unsigned long timeout;
1166 static int flag = 0;
1167
1168
1169 outb( 0x82, SCSI_Cntl_port ); /* Bus Enable + Select */
1170 outb( adapter_mask | (1 << target), SCSI_Data_NoACK_port );
1171
1172 /* Stop arbitration and enable parity */
1173 outb( PARITY_MASK, TMC_Cntl_port );
1174
1175 timeout = 350; /* 350 msec */
1176
1177 do {
1178 status = inb( SCSI_Status_port ); /* Read adapter status */
1179 if (status & 1) { /* Busy asserted */
1180 /* Enable SCSI Bus (on error, should make bus idle with 0) */
1181 outb( 0x80, SCSI_Cntl_port );
1182 return 0;
1183 }
1184 mdelay(1); /* wait one msec */
1185 } while (--timeout);
1186 /* Make bus idle */
1187 fdomain_make_bus_idle();
1188 #if EVERY_ACCESS
1189 if (!target) printk( "Selection failed\n" );
1190 #endif
1191 #if ERRORS_ONLY
1192 if (!target) {
1193 if (!flag) /* Skip first failure for all chips. */
1194 ++flag;
1195 else
1196 printk( "scsi: <fdomain> Selection failed\n" );
1197 }
1198 #endif
1199 return 1;
1200 }
1201
1202 void my_done( int error )
1203 {
1204 if (in_command) {
1205 in_command = 0;
1206 outb( 0x00, Interrupt_Cntl_port );
1207 fdomain_make_bus_idle();
1208 current_SC->result = error;
1209 if (current_SC->scsi_done)
1210 current_SC->scsi_done( current_SC );
1211 else panic( "scsi: <fdomain> current_SC->scsi_done() == NULL" );
1212 } else {
1213 panic( "scsi: <fdomain> my_done() called outside of command\n" );
1214 }
1215 #if DEBUG_RACE
1216 in_interrupt_flag = 0;
1217 #endif
1218 }
1219
1220 void do_fdomain_16x0_intr( int irq, void *dev_id, struct pt_regs * regs )
1221 {
1222 unsigned long flags;
1223 int status;
1224 int done = 0;
1225 unsigned data_count;
1226
1227 /* The fdomain_16x0_intr is only called via
1228 the interrupt handler. The goal of the
1229 sti() here is to allow other
1230 interruptions while this routine is
1231 running. */
1232
1233 /* Check for other IRQ sources */
1234 if((inb(TMC_Status_port)&0x01)==0)
1235 return;
1236
1237 /* It is our IRQ */
1238 outb( 0x00, Interrupt_Cntl_port );
1239
1240 /* We usually have one spurious interrupt after each command. Ignore it. */
1241 if (!in_command || !current_SC) { /* Spurious interrupt */
1242 #if EVERY_ACCESS
1243 printk( "Spurious interrupt, in_command = %d, current_SC = %x\n",
1244 in_command, current_SC );
1245 #endif
1246 return;
1247 }
1248
1249 /* Abort calls my_done, so we do nothing here. */
1250 if (current_SC->SCp.phase & aborted) {
1251 #if DEBUG_ABORT
1252 printk( "scsi: <fdomain> Interrupt after abort, ignoring\n" );
1253 #endif
1254 /*
1255 return; */
1256 }
1257
1258 #if DEBUG_RACE
1259 ++in_interrupt_flag;
1260 #endif
1261
1262 if (current_SC->SCp.phase & in_arbitration) {
1263 status = inb( TMC_Status_port ); /* Read adapter status */
1264 if (!(status & 0x02)) {
1265 #if EVERY_ACCESS
1266 printk( " AFAIL " );
1267 #endif
1268 spin_lock_irqsave(&io_request_lock, flags);
1269 my_done( DID_BUS_BUSY << 16 );
1270 spin_unlock_irqrestore(&io_request_lock, flags);
1271 return;
1272 }
1273 current_SC->SCp.phase = in_selection;
1274
1275 outb( 0x40 | FIFO_COUNT, Interrupt_Cntl_port );
1276
1277 outb( 0x82, SCSI_Cntl_port ); /* Bus Enable + Select */
1278 outb( adapter_mask | (1 << current_SC->target), SCSI_Data_NoACK_port );
1279
1280 /* Stop arbitration and enable parity */
1281 outb( 0x10 | PARITY_MASK, TMC_Cntl_port );
1282 #if DEBUG_RACE
1283 in_interrupt_flag = 0;
1284 #endif
1285 return;
1286 } else if (current_SC->SCp.phase & in_selection) {
1287 status = inb( SCSI_Status_port );
1288 if (!(status & 0x01)) {
1289 /* Try again, for slow devices */
1290 if (fdomain_select( current_SC->target )) {
1291 #if EVERY_ACCESS
1292 printk( " SFAIL " );
1293 #endif
1294 spin_lock_irqsave(&io_request_lock, flags);
1295 my_done( DID_NO_CONNECT << 16 );
1296 spin_unlock_irqrestore(&io_request_lock, flags);
1297 return;
1298 } else {
1299 #if EVERY_ACCESS
1300 printk( " AltSel " );
1301 #endif
1302 /* Stop arbitration and enable parity */
1303 outb( 0x10 | PARITY_MASK, TMC_Cntl_port );
1304 }
1305 }
1306 current_SC->SCp.phase = in_other;
1307 outb( 0x90 | FIFO_COUNT, Interrupt_Cntl_port );
1308 outb( 0x80, SCSI_Cntl_port );
1309 #if DEBUG_RACE
1310 in_interrupt_flag = 0;
1311 #endif
1312 return;
1313 }
1314
1315 /* current_SC->SCp.phase == in_other: this is the body of the routine */
1316
1317 status = inb( SCSI_Status_port );
1318
1319 if (status & 0x10) { /* REQ */
1320
1321 switch (status & 0x0e) {
1322
1323 case 0x08: /* COMMAND OUT */
1324 outb( current_SC->cmnd[current_SC->SCp.sent_command++],
1325 Write_SCSI_Data_port );
1326 #if EVERY_ACCESS
1327 printk( "CMD = %x,",
1328 current_SC->cmnd[ current_SC->SCp.sent_command - 1] );
1329 #endif
1330 break;
1331 case 0x00: /* DATA OUT -- tmc18c50/tmc18c30 only */
1332 if (chip != tmc1800 && !current_SC->SCp.have_data_in) {
1333 current_SC->SCp.have_data_in = -1;
1334 outb( 0xd0 | PARITY_MASK, TMC_Cntl_port );
1335 }
1336 break;
1337 case 0x04: /* DATA IN -- tmc18c50/tmc18c30 only */
1338 if (chip != tmc1800 && !current_SC->SCp.have_data_in) {
1339 current_SC->SCp.have_data_in = 1;
1340 outb( 0x90 | PARITY_MASK, TMC_Cntl_port );
1341 }
1342 break;
1343 case 0x0c: /* STATUS IN */
1344 current_SC->SCp.Status = inb( Read_SCSI_Data_port );
1345 #if EVERY_ACCESS
1346 printk( "Status = %x, ", current_SC->SCp.Status );
1347 #endif
1348 #if ERRORS_ONLY
1349 if (current_SC->SCp.Status
1350 && current_SC->SCp.Status != 2
1351 && current_SC->SCp.Status != 8) {
1352 printk( "scsi: <fdomain> target = %d, command = %x, status = %x\n",
1353 current_SC->target,
1354 current_SC->cmnd[0],
1355 current_SC->SCp.Status );
1356 }
1357 #endif
1358 break;
1359 case 0x0a: /* MESSAGE OUT */
1360 outb( MESSAGE_REJECT, Write_SCSI_Data_port ); /* Reject */
1361 break;
1362 case 0x0e: /* MESSAGE IN */
1363 current_SC->SCp.Message = inb( Read_SCSI_Data_port );
1364 #if EVERY_ACCESS
1365 printk( "Message = %x, ", current_SC->SCp.Message );
1366 #endif
1367 if (!current_SC->SCp.Message) ++done;
1368 #if DEBUG_MESSAGES || EVERY_ACCESS
1369 if (current_SC->SCp.Message) {
1370 printk( "scsi: <fdomain> message = %x\n",
1371 current_SC->SCp.Message );
1372 }
1373 #endif
1374 break;
1375 }
1376 }
1377
1378 if (chip == tmc1800
1379 && !current_SC->SCp.have_data_in
1380 && (current_SC->SCp.sent_command
1381 >= current_SC->cmd_len)) {
1382 /* We have to get the FIFO direction
1383 correct, so I've made a table based
1384 on the SCSI Standard of which commands
1385 appear to require a DATA OUT phase.
1386 */
1387 /*
1388 p. 94: Command for all device types
1389 CHANGE DEFINITION 40 DATA OUT
1390 COMPARE 39 DATA OUT
1391 COPY 18 DATA OUT
1392 COPY AND VERIFY 3a DATA OUT
1393 INQUIRY 12
1394 LOG SELECT 4c DATA OUT
1395 LOG SENSE 4d
1396 MODE SELECT (6) 15 DATA OUT
1397 MODE SELECT (10) 55 DATA OUT
1398 MODE SENSE (6) 1a
1399 MODE SENSE (10) 5a
1400 READ BUFFER 3c
1401 RECEIVE DIAGNOSTIC RESULTS 1c
1402 REQUEST SENSE 03
1403 SEND DIAGNOSTIC 1d DATA OUT
1404 TEST UNIT READY 00
1405 WRITE BUFFER 3b DATA OUT
1406
1407 p.178: Commands for direct-access devices (not listed on p. 94)
1408 FORMAT UNIT 04 DATA OUT
1409 LOCK-UNLOCK CACHE 36
1410 PRE-FETCH 34
1411 PREVENT-ALLOW MEDIUM REMOVAL 1e
1412 READ (6)/RECEIVE 08
1413 READ (10) 3c
1414 READ CAPACITY 25
1415 READ DEFECT DATA (10) 37
1416 READ LONG 3e
1417 REASSIGN BLOCKS 07 DATA OUT
1418 RELEASE 17
1419 RESERVE 16 DATA OUT
1420 REZERO UNIT/REWIND 01
1421 SEARCH DATA EQUAL (10) 31 DATA OUT
1422 SEARCH DATA HIGH (10) 30 DATA OUT
1423 SEARCH DATA LOW (10) 32 DATA OUT
1424 SEEK (6) 0b
1425 SEEK (10) 2b
1426 SET LIMITS (10) 33
1427 START STOP UNIT 1b
1428 SYNCHRONIZE CACHE 35
1429 VERIFY (10) 2f
1430 WRITE (6)/PRINT/SEND 0a DATA OUT
1431 WRITE (10)/SEND 2a DATA OUT
1432 WRITE AND VERIFY (10) 2e DATA OUT
1433 WRITE LONG 3f DATA OUT
1434 WRITE SAME 41 DATA OUT ?
1435
1436 p. 261: Commands for sequential-access devices (not previously listed)
1437 ERASE 19
1438 LOAD UNLOAD 1b
1439 LOCATE 2b
1440 READ BLOCK LIMITS 05
1441 READ POSITION 34
1442 READ REVERSE 0f
1443 RECOVER BUFFERED DATA 14
1444 SPACE 11
1445 WRITE FILEMARKS 10 ?
1446
1447 p. 298: Commands for printer devices (not previously listed)
1448 ****** NOT SUPPORTED BY THIS DRIVER, since 0b is SEEK (6) *****
1449 SLEW AND PRINT 0b DATA OUT -- same as seek
1450 STOP PRINT 1b
1451 SYNCHRONIZE BUFFER 10
1452
1453 p. 315: Commands for processor devices (not previously listed)
1454
1455 p. 321: Commands for write-once devices (not previously listed)
1456 MEDIUM SCAN 38
1457 READ (12) a8
1458 SEARCH DATA EQUAL (12) b1 DATA OUT
1459 SEARCH DATA HIGH (12) b0 DATA OUT
1460 SEARCH DATA LOW (12) b2 DATA OUT
1461 SET LIMITS (12) b3
1462 VERIFY (12) af
1463 WRITE (12) aa DATA OUT
1464 WRITE AND VERIFY (12) ae DATA OUT
1465
1466 p. 332: Commands for CD-ROM devices (not previously listed)
1467 PAUSE/RESUME 4b
1468 PLAY AUDIO (10) 45
1469 PLAY AUDIO (12) a5
1470 PLAY AUDIO MSF 47
1471 PLAY TRACK RELATIVE (10) 49
1472 PLAY TRACK RELATIVE (12) a9
1473 READ HEADER 44
1474 READ SUB-CHANNEL 42
1475 READ TOC 43
1476
1477 p. 370: Commands for scanner devices (not previously listed)
1478 GET DATA BUFFER STATUS 34
1479 GET WINDOW 25
1480 OBJECT POSITION 31
1481 SCAN 1b
1482 SET WINDOW 24 DATA OUT
1483
1484 p. 391: Commands for optical memory devices (not listed)
1485 ERASE (10) 2c
1486 ERASE (12) ac
1487 MEDIUM SCAN 38 DATA OUT
1488 READ DEFECT DATA (12) b7
1489 READ GENERATION 29
1490 READ UPDATED BLOCK 2d
1491 UPDATE BLOCK 3d DATA OUT
1492
1493 p. 419: Commands for medium changer devices (not listed)
1494 EXCHANGE MEDIUM 46
1495 INITIALIZE ELEMENT STATUS 07
1496 MOVE MEDIUM a5
1497 POSITION TO ELEMENT 2b
1498 READ ELEMENT STATUS b8
1499 REQUEST VOL. ELEMENT ADDRESS b5
1500 SEND VOLUME TAG b6 DATA OUT
1501
1502 p. 454: Commands for communications devices (not listed previously)
1503 GET MESSAGE (6) 08
1504 GET MESSAGE (10) 28
1505 GET MESSAGE (12) a8
1506 */
1507
1508 switch (current_SC->cmnd[0]) {
1509 case CHANGE_DEFINITION: case COMPARE: case COPY:
1510 case COPY_VERIFY: case LOG_SELECT: case MODE_SELECT:
1511 case MODE_SELECT_10: case SEND_DIAGNOSTIC: case WRITE_BUFFER:
1512
1513 case FORMAT_UNIT: case REASSIGN_BLOCKS: case RESERVE:
1514 case SEARCH_EQUAL: case SEARCH_HIGH: case SEARCH_LOW:
1515 case WRITE_6: case WRITE_10: case WRITE_VERIFY:
1516 case 0x3f: case 0x41:
1517
1518 case 0xb1: case 0xb0: case 0xb2:
1519 case 0xaa: case 0xae:
1520
1521 case 0x24:
1522
1523 case 0x38: case 0x3d:
1524
1525 case 0xb6:
1526
1527 case 0xea: /* alternate number for WRITE LONG */
1528
1529 current_SC->SCp.have_data_in = -1;
1530 outb( 0xd0 | PARITY_MASK, TMC_Cntl_port );
1531 break;
1532
1533 case 0x00:
1534 default:
1535
1536 current_SC->SCp.have_data_in = 1;
1537 outb( 0x90 | PARITY_MASK, TMC_Cntl_port );
1538 break;
1539 }
1540 }
1541
1542 if (current_SC->SCp.have_data_in == -1) { /* DATA OUT */
1543 while ( (data_count = FIFO_Size - inw( FIFO_Data_Count_port )) > 512 ) {
1544 #if EVERY_ACCESS
1545 printk( "DC=%d, ", data_count ) ;
1546 #endif
1547 if (data_count > current_SC->SCp.this_residual)
1548 data_count = current_SC->SCp.this_residual;
1549 if (data_count > 0) {
1550 #if EVERY_ACCESS
1551 printk( "%d OUT, ", data_count );
1552 #endif
1553 if (data_count == 1) {
1554 outb( *current_SC->SCp.ptr++, Write_FIFO_port );
1555 --current_SC->SCp.this_residual;
1556 } else {
1557 data_count >>= 1;
1558 outsw( Write_FIFO_port, current_SC->SCp.ptr, data_count );
1559 current_SC->SCp.ptr += 2 * data_count;
1560 current_SC->SCp.this_residual -= 2 * data_count;
1561 }
1562 }
1563 if (!current_SC->SCp.this_residual) {
1564 if (current_SC->SCp.buffers_residual) {
1565 --current_SC->SCp.buffers_residual;
1566 ++current_SC->SCp.buffer;
1567 current_SC->SCp.ptr = current_SC->SCp.buffer->address;
1568 current_SC->SCp.this_residual = current_SC->SCp.buffer->length;
1569 } else
1570 break;
1571 }
1572 }
1573 }
1574
1575 if (current_SC->SCp.have_data_in == 1) { /* DATA IN */
1576 while ((data_count = inw( FIFO_Data_Count_port )) > 0) {
1577 #if EVERY_ACCESS
1578 printk( "DC=%d, ", data_count );
1579 #endif
1580 if (data_count > current_SC->SCp.this_residual)
1581 data_count = current_SC->SCp.this_residual;
1582 if (data_count) {
1583 #if EVERY_ACCESS
1584 printk( "%d IN, ", data_count );
1585 #endif
1586 if (data_count == 1) {
1587 *current_SC->SCp.ptr++ = inb( Read_FIFO_port );
1588 --current_SC->SCp.this_residual;
1589 } else {
1590 data_count >>= 1; /* Number of words */
1591 insw( Read_FIFO_port, current_SC->SCp.ptr, data_count );
1592 current_SC->SCp.ptr += 2 * data_count;
1593 current_SC->SCp.this_residual -= 2 * data_count;
1594 }
1595 }
1596 if (!current_SC->SCp.this_residual
1597 && current_SC->SCp.buffers_residual) {
1598 --current_SC->SCp.buffers_residual;
1599 ++current_SC->SCp.buffer;
1600 current_SC->SCp.ptr = current_SC->SCp.buffer->address;
1601 current_SC->SCp.this_residual = current_SC->SCp.buffer->length;
1602 }
1603 }
1604 }
1605
1606 if (done) {
1607 #if EVERY_ACCESS
1608 printk( " ** IN DONE %d ** ", current_SC->SCp.have_data_in );
1609 #endif
1610
1611 #if ERRORS_ONLY
1612 if (current_SC->cmnd[0] == REQUEST_SENSE && !current_SC->SCp.Status) {
1613 if ((unsigned char)(*((char *)current_SC->request_buffer+2)) & 0x0f) {
1614 unsigned char key;
1615 unsigned char code;
1616 unsigned char qualifier;
1617
1618 key = (unsigned char)(*((char *)current_SC->request_buffer + 2))
1619 & 0x0f;
1620 code = (unsigned char)(*((char *)current_SC->request_buffer + 12));
1621 qualifier = (unsigned char)(*((char *)current_SC->request_buffer
1622 + 13));
1623
1624 if (key != UNIT_ATTENTION
1625 && !(key == NOT_READY
1626 && code == 0x04
1627 && (!qualifier || qualifier == 0x02 || qualifier == 0x01))
1628 && !(key == ILLEGAL_REQUEST && (code == 0x25
1629 || code == 0x24
1630 || !code)))
1631
1632 printk( "scsi: <fdomain> REQUEST SENSE"
1633 " Key = %x, Code = %x, Qualifier = %x\n",
1634 key, code, qualifier );
1635 }
1636 }
1637 #endif
1638 #if EVERY_ACCESS
1639 printk( "BEFORE MY_DONE. . ." );
1640 #endif
1641 spin_lock_irqsave(&io_request_lock, flags);
1642 my_done( (current_SC->SCp.Status & 0xff)
1643 | ((current_SC->SCp.Message & 0xff) << 8) | (DID_OK << 16) );
1644 spin_unlock_irqrestore(&io_request_lock, flags);
1645 #if EVERY_ACCESS
1646 printk( "RETURNING.\n" );
1647 #endif
1648
1649 } else {
1650 if (current_SC->SCp.phase & disconnect) {
1651 outb( 0xd0 | FIFO_COUNT, Interrupt_Cntl_port );
1652 outb( 0x00, SCSI_Cntl_port );
1653 } else {
1654 outb( 0x90 | FIFO_COUNT, Interrupt_Cntl_port );
1655 }
1656 }
1657 #if DEBUG_RACE
1658 in_interrupt_flag = 0;
1659 #endif
1660 return;
1661 }
1662
1663 int fdomain_16x0_queue( Scsi_Cmnd * SCpnt, void (*done)(Scsi_Cmnd *))
1664 {
1665 if (in_command) {
1666 panic( "scsi: <fdomain> fdomain_16x0_queue() NOT REENTRANT!\n" );
1667 }
1668 #if EVERY_ACCESS
1669 printk( "queue: target = %d cmnd = 0x%02x pieces = %d size = %u\n",
1670 SCpnt->target,
1671 *(unsigned char *)SCpnt->cmnd,
1672 SCpnt->use_sg,
1673 SCpnt->request_bufflen );
1674 #endif
1675
1676 fdomain_make_bus_idle();
1677
1678 current_SC = SCpnt; /* Save this for the done function */
1679 current_SC->scsi_done = done;
1680
1681 /* Initialize static data */
1682
1683 if (current_SC->use_sg) {
1684 current_SC->SCp.buffer =
1685 (struct scatterlist *)current_SC->request_buffer;
1686 current_SC->SCp.ptr = current_SC->SCp.buffer->address;
1687 current_SC->SCp.this_residual = current_SC->SCp.buffer->length;
1688 current_SC->SCp.buffers_residual = current_SC->use_sg - 1;
1689 } else {
1690 current_SC->SCp.ptr = (char *)current_SC->request_buffer;
1691 current_SC->SCp.this_residual = current_SC->request_bufflen;
1692 current_SC->SCp.buffer = NULL;
1693 current_SC->SCp.buffers_residual = 0;
1694 }
1695
1696
1697 current_SC->SCp.Status = 0;
1698 current_SC->SCp.Message = 0;
1699 current_SC->SCp.have_data_in = 0;
1700 current_SC->SCp.sent_command = 0;
1701 current_SC->SCp.phase = in_arbitration;
1702
1703 /* Start arbitration */
1704 outb( 0x00, Interrupt_Cntl_port );
1705 outb( 0x00, SCSI_Cntl_port ); /* Disable data drivers */
1706 outb( adapter_mask, SCSI_Data_NoACK_port ); /* Set our id bit */
1707 ++in_command;
1708 outb( 0x20, Interrupt_Cntl_port );
1709 outb( 0x14 | PARITY_MASK, TMC_Cntl_port ); /* Start arbitration */
1710
1711 return 0;
1712 }
1713
1714 /* The following code, which simulates the old-style command function, was
1715 taken from Tommy Thorn's aha1542.c file. This code is Copyright (C)
1716 1992 Tommy Thorn. */
1717
1718 static volatile int internal_done_flag = 0;
1719 static volatile int internal_done_errcode = 0;
1720
1721 static void internal_done( Scsi_Cmnd *SCpnt )
1722 {
1723 internal_done_errcode = SCpnt->result;
1724 ++internal_done_flag;
1725 }
1726
1727 int fdomain_16x0_command( Scsi_Cmnd *SCpnt )
1728 {
1729 fdomain_16x0_queue( SCpnt, internal_done );
1730
1731 while (!internal_done_flag)
1732 ;
1733 internal_done_flag = 0;
1734 return internal_done_errcode;
1735 }
1736
1737 /* End of code derived from Tommy Thorn's work. */
1738
1739 void print_info( Scsi_Cmnd *SCpnt )
1740 {
1741 unsigned int imr;
1742 unsigned int irr;
1743 unsigned int isr;
1744
1745 if (!SCpnt || !SCpnt->host) {
1746 printk( "scsi: <fdomain> Cannot provide detailed information\n" );
1747 return;
1748 }
1749
1750 printk( "%s\n", fdomain_16x0_info( SCpnt->host ) );
1751 print_banner( SCpnt->host );
1752 switch (SCpnt->SCp.phase) {
1753 case in_arbitration: printk( "arbitration " ); break;
1754 case in_selection: printk( "selection " ); break;
1755 case in_other: printk( "other " ); break;
1756 default: printk( "unknown " ); break;
1757 }
1758
1759 printk( "(%d), target = %d cmnd = 0x%02x pieces = %d size = %u\n",
1760 SCpnt->SCp.phase,
1761 SCpnt->target,
1762 *(unsigned char *)SCpnt->cmnd,
1763 SCpnt->use_sg,
1764 SCpnt->request_bufflen );
1765 printk( "sent_command = %d, have_data_in = %d, timeout = %d\n",
1766 SCpnt->SCp.sent_command,
1767 SCpnt->SCp.have_data_in,
1768 SCpnt->timeout );
1769 #if DEBUG_RACE
1770 printk( "in_interrupt_flag = %d\n", in_interrupt_flag );
1771 #endif
1772
1773 imr = (inb( 0x0a1 ) << 8) + inb( 0x21 );
1774 outb( 0x0a, 0xa0 );
1775 irr = inb( 0xa0 ) << 8;
1776 outb( 0x0a, 0x20 );
1777 irr += inb( 0x20 );
1778 outb( 0x0b, 0xa0 );
1779 isr = inb( 0xa0 ) << 8;
1780 outb( 0x0b, 0x20 );
1781 isr += inb( 0x20 );
1782
1783 /* Print out interesting information */
1784 printk( "IMR = 0x%04x", imr );
1785 if (imr & (1 << interrupt_level))
1786 printk( " (masked)" );
1787 printk( ", IRR = 0x%04x, ISR = 0x%04x\n", irr, isr );
1788
1789 printk( "SCSI Status = 0x%02x\n", inb( SCSI_Status_port ) );
1790 printk( "TMC Status = 0x%02x", inb( TMC_Status_port ) );
1791 if (inb( TMC_Status_port & 1))
1792 printk( " (interrupt)" );
1793 printk( "\n" );
1794 printk( "Interrupt Status = 0x%02x", inb( Interrupt_Status_port ) );
1795 if (inb( Interrupt_Status_port ) & 0x08)
1796 printk( " (enabled)" );
1797 printk( "\n" );
1798 if (chip == tmc18c50 || chip == tmc18c30) {
1799 printk( "FIFO Status = 0x%02x\n", inb( port_base + FIFO_Status ) );
1800 printk( "Int. Condition = 0x%02x\n",
1801 inb( port_base + Interrupt_Cond ) );
1802 }
1803 printk( "Configuration 1 = 0x%02x\n", inb( port_base + Configuration1 ) );
1804 if (chip == tmc18c50 || chip == tmc18c30)
1805 printk( "Configuration 2 = 0x%02x\n",
1806 inb( port_base + Configuration2 ) );
1807 }
1808
1809 int fdomain_16x0_abort( Scsi_Cmnd *SCpnt)
1810 {
1811 unsigned long flags;
1812 #if EVERY_ACCESS || ERRORS_ONLY || DEBUG_ABORT
1813 printk( "scsi: <fdomain> abort " );
1814 #endif
1815
1816 save_flags( flags );
1817 cli();
1818 if (!in_command) {
1819 #if EVERY_ACCESS || ERRORS_ONLY
1820 printk( " (not in command)\n" );
1821 #endif
1822 restore_flags( flags );
1823 return SCSI_ABORT_NOT_RUNNING;
1824 } else printk( "\n" );
1825
1826 #if DEBUG_ABORT
1827 print_info( SCpnt );
1828 #endif
1829
1830 fdomain_make_bus_idle();
1831
1832 current_SC->SCp.phase |= aborted;
1833
1834 current_SC->result = DID_ABORT << 16;
1835
1836 restore_flags( flags );
1837
1838 /* Aborts are not done well. . . */
1839 my_done( DID_ABORT << 16 );
1840
1841 return SCSI_ABORT_SUCCESS;
1842 }
1843
1844 int fdomain_16x0_reset( Scsi_Cmnd *SCpnt, unsigned int ignored )
1845 {
1846 #if DEBUG_RESET
1847 static int called_once = 0;
1848 #endif
1849
1850 #if ERRORS_ONLY
1851 if (SCpnt) printk( "scsi: <fdomain> SCSI Bus Reset\n" );
1852 #endif
1853
1854 #if DEBUG_RESET
1855 if (called_once) print_info( current_SC );
1856 called_once = 1;
1857 #endif
1858
1859 outb( 1, SCSI_Cntl_port );
1860 do_pause( 2 );
1861 outb( 0, SCSI_Cntl_port );
1862 do_pause( 115 );
1863 outb( 0, SCSI_Mode_Cntl_port );
1864 outb( PARITY_MASK, TMC_Cntl_port );
1865
1866 /* Unless this is the very first call (i.e., SCPnt == NULL), everything
1867 is probably hosed at this point. We will, however, try to keep
1868 things going by informing the high-level code that we need help. */
1869
1870 return SCSI_RESET_WAKEUP;
1871 }
1872
1873 #include "sd.h"
1874 #include <scsi/scsi_ioctl.h>
1875
1876 int fdomain_16x0_biosparam( Scsi_Disk *disk, kdev_t dev, int *info_array )
1877 {
1878 int drive;
1879 unsigned char buf[512 + sizeof (Scsi_Ioctl_Command)];
1880 Scsi_Ioctl_Command *sic = (Scsi_Ioctl_Command *) buf;
1881 int size = disk->capacity;
1882 unsigned char *data = sic->data;
1883 unsigned char do_read[] = { READ_6, 0, 0, 0, 1, 0 };
1884 int retcode;
1885 unsigned long offset;
1886 struct drive_info {
1887 unsigned short cylinders;
1888 unsigned char heads;
1889 unsigned char sectors;
1890 } i;
1891
1892 /* NOTES:
1893 The RAM area starts at 0x1f00 from the bios_base address.
1894
1895 For BIOS Version 2.0:
1896
1897 The drive parameter table seems to start at 0x1f30.
1898 The first byte's purpose is not known.
1899 Next is the cylinder, head, and sector information.
1900 The last 4 bytes appear to be the drive's size in sectors.
1901 The other bytes in the drive parameter table are unknown.
1902 If anyone figures them out, please send me mail, and I will
1903 update these notes.
1904
1905 Tape drives do not get placed in this table.
1906
1907 There is another table at 0x1fea:
1908 If the byte is 0x01, then the SCSI ID is not in use.
1909 If the byte is 0x18 or 0x48, then the SCSI ID is in use,
1910 although tapes don't seem to be in this table. I haven't
1911 seen any other numbers (in a limited sample).
1912
1913 0x1f2d is a drive count (i.e., not including tapes)
1914
1915 The table at 0x1fcc are I/O ports addresses for the various
1916 operations. I calculate these by hand in this driver code.
1917
1918
1919
1920 For the ISA-200S version of BIOS Version 2.0:
1921
1922 The drive parameter table starts at 0x1f33.
1923
1924 WARNING: Assume that the table entry is 25 bytes long. Someone needs
1925 to check this for the Quantum ISA-200S card.
1926
1927
1928
1929 For BIOS Version 3.2:
1930
1931 The drive parameter table starts at 0x1f70. Each entry is
1932 0x0a bytes long. Heads are one less than we need to report.
1933 */
1934
1935 if (MAJOR(dev) != SCSI_DISK0_MAJOR) {
1936 printk("scsi: <fdomain> fdomain_16x0_biosparam: too many disks");
1937 return 0;
1938 }
1939 drive = MINOR(dev) >> 4;
1940
1941 if (bios_major == 2) {
1942 switch (Quantum) {
1943 case 2: /* ISA_200S */
1944 /* The value of 25 has never been verified.
1945 It should probably be 15. */
1946 offset = bios_base + 0x1f33 + drive * 25;
1947 break;
1948 case 3: /* ISA_250MG */
1949 offset = bios_base + 0x1f36 + drive * 15;
1950 break;
1951 case 4: /* ISA_200S (another one) */
1952 offset = bios_base + 0x1f34 + drive * 15;
1953 break;
1954 default:
1955 offset = bios_base + 0x1f31 + drive * 25;
1956 break;
1957 }
1958 memcpy_fromio( &i, offset, sizeof( struct drive_info ) );
1959 info_array[0] = i.heads;
1960 info_array[1] = i.sectors;
1961 info_array[2] = i.cylinders;
1962 } else if (bios_major == 3
1963 && bios_minor >= 0
1964 && bios_minor < 4) { /* 3.0 and 3.2 BIOS */
1965 memcpy_fromio( &i, bios_base + 0x1f71 + drive * 10,
1966 sizeof( struct drive_info ) );
1967 info_array[0] = i.heads + 1;
1968 info_array[1] = i.sectors;
1969 info_array[2] = i.cylinders;
1970 } else { /* 3.4 BIOS (and up?) */
1971 /* This algorithm was provided by Future Domain (much thanks!). */
1972
1973 sic->inlen = 0; /* zero bytes out */
1974 sic->outlen = 512; /* one sector in */
1975 memcpy( data, do_read, sizeof( do_read ) );
1976 retcode = kernel_scsi_ioctl( disk->device,
1977 SCSI_IOCTL_SEND_COMMAND,
1978 sic );
1979 if (!retcode /* SCSI command ok */
1980 && data[511] == 0xaa && data[510] == 0x55 /* Partition table valid */
1981 && data[0x1c2]) { /* Partition type */
1982
1983 /* The partition table layout is as follows:
1984
1985 Start: 0x1b3h
1986 Offset: 0 = partition status
1987 1 = starting head
1988 2 = starting sector and cylinder (word, encoded)
1989 4 = partition type
1990 5 = ending head
1991 6 = ending sector and cylinder (word, encoded)
1992 8 = starting absolute sector (double word)
1993 c = number of sectors (double word)
1994 Signature: 0x1fe = 0x55aa
1995
1996 So, this algorithm assumes:
1997 1) the first partition table is in use,
1998 2) the data in the first entry is correct, and
1999 3) partitions never divide cylinders
2000
2001 Note that (1) may be FALSE for NetBSD (and other BSD flavors),
2002 as well as for Linux. Note also, that Linux doesn't pay any
2003 attention to the fields that are used by this algorithm -- it
2004 only uses the absolute sector data. Recent versions of Linux's
2005 fdisk(1) will fill this data in correctly, and forthcoming
2006 versions will check for consistency.
2007
2008 Checking for a non-zero partition type is not part of the
2009 Future Domain algorithm, but it seemed to be a reasonable thing
2010 to do, especially in the Linux and BSD worlds. */
2011
2012 info_array[0] = data[0x1c3] + 1; /* heads */
2013 info_array[1] = data[0x1c4] & 0x3f; /* sectors */
2014 } else {
2015
2016 /* Note that this new method guarantees that there will always be
2017 less than 1024 cylinders on a platter. This is good for drives
2018 up to approximately 7.85GB (where 1GB = 1024 * 1024 kB). */
2019
2020 if ((unsigned int)size >= 0x7e0000U) {
2021 info_array[0] = 0xff; /* heads = 255 */
2022 info_array[1] = 0x3f; /* sectors = 63 */
2023 } else if ((unsigned int)size >= 0x200000U) {
2024 info_array[0] = 0x80; /* heads = 128 */
2025 info_array[1] = 0x3f; /* sectors = 63 */
2026 } else {
2027 info_array[0] = 0x40; /* heads = 64 */
2028 info_array[1] = 0x20; /* sectors = 32 */
2029 }
2030 }
2031 /* For both methods, compute the cylinders */
2032 info_array[2] = (unsigned int)size / (info_array[0] * info_array[1] );
2033 }
2034
2035 return 0;
2036 }
2037
2038 /* Eventually this will go into an include file, but this will be later */
2039 static Scsi_Host_Template driver_template = FDOMAIN_16X0;
2040
2041 #include "scsi_module.c"
2042