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