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