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