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