1 /* fd_mcs.c -- Future Domain MCS 600/700 (or IBM OEM) driver
3 * FutureDomain MCS-600/700 v0.2 03/11/1998 by ZP Gu (zpg@castle.net)
5 * This driver is cloned from fdomain.* to specifically support
6 * the Future Domain MCS 600/700 MCA SCSI adapters. Some PS/2s
7 * also equipped with IBM Fast SCSI Adapter/A which is an OEM
10 * This driver also supports Reply SB16/SCSI card (the SCSI part).
12 * What makes this driver different is that this driver is MCA only
13 * and it supports multiple adapters in the same system, IRQ
14 * sharing, some driver statistics, and maps highest SCSI id to sda.
15 * All cards are auto-detected.
17 * Assumptions: TMC-1800/18C50/18C30, BIOS >= 3.4
19 * LILO command-line options:
20 * fd_mcs=<FIFO_COUNT>[,<FIFO_SIZE>]
22 * ********************************************************
23 * Please see Copyrights/Comments in fdomain.* for credits.
24 * Following is from fdomain.c for acknowledgement:
26 * Created: Sun May 3 18:53:19 1992 by faith@cs.unc.edu
27 * Revised: Wed Oct 2 11:10:55 1996 by r.faith@ieee.org
28 * Author: Rickard E. Faith, faith@cs.unc.edu
29 * Copyright 1992, 1993, 1994, 1995, 1996 Rickard E. Faith
31 * $Id: fdomain.c,v 5.45 1996/10/02 15:13:06 root Exp $
33 * This program is free software; you can redistribute it and/or modify it
34 * under the terms of the GNU General Public License as published by the
35 * Free Software Foundation; either version 2, or (at your option) any
38 * This program is distributed in the hope that it will be useful, but
39 * WITHOUT ANY WARRANTY; without even the implied warranty of
40 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
41 * General Public License for more details.
43 * You should have received a copy of the GNU General Public License along
44 * with this program; if not, write to the Free Software Foundation, Inc.,
45 * 675 Mass Ave, Cambridge, MA 02139, USA.
47 **************************************************************************
49 NOTES ON USER DEFINABLE OPTIONS:
51 DEBUG: This turns on the printing of various debug information.
53 ENABLE_PARITY: This turns on SCSI parity checking. With the current
54 driver, all attached devices must support SCSI parity. If none of your
55 devices support parity, then you can probably get the driver to work by
56 turning this option off. I have no way of testing this, however, and it
57 would appear that no one ever uses this option.
59 FIFO_COUNT: The host adapter has an 8K cache (host adapters based on the
60 18C30 chip have a 2k cache). When this many 512 byte blocks are filled by
61 the SCSI device, an interrupt will be raised. Therefore, this could be as
62 low as 0, or as high as 16. Note, however, that values which are too high
63 or too low seem to prevent any interrupts from occurring, and thereby lock
64 up the machine. I have found that 2 is a good number, but throughput may
65 be increased by changing this value to values which are close to 2.
66 Please let me know if you try any different values.
67 [*****Now a runtime option*****]
69 RESELECTION: This is no longer an option, since I gave up trying to
70 implement it in version 4.x of this driver. It did not improve
71 performance at all and made the driver unstable (because I never found one
72 of the two race conditions which were introduced by the multiple
73 outstanding command code). The instability seems a very high price to pay
74 just so that you don't have to wait for the tape to rewind. If you want
75 this feature implemented, send me patches. I'll be happy to send a copy
76 of my (broken) driver to anyone who would like to see a copy.
78 **************************************************************************/
80 #include <linux/module.h>
81 #include <linux/interrupt.h>
82 #include <linux/blkdev.h>
83 #include <linux/errno.h>
84 #include <linux/string.h>
85 #include <linux/ioport.h>
86 #include <linux/proc_fs.h>
87 #include <linux/delay.h>
88 #include <linux/mca.h>
89 #include <linux/spinlock.h>
90 #include <linux/mca-legacy.h>
93 #include <asm/system.h>
99 #define DRIVER_VERSION "v0.2 by ZP Gu<zpg@castle.net>"
101 /* START OF USER DEFINABLE OPTIONS */
103 #define DEBUG 0 /* Enable debugging output */
104 #define ENABLE_PARITY 1 /* Enable SCSI Parity */
105 #define DO_DETECT 0 /* Do device detection here (see scsi.c) */
107 /* END OF USER DEFINABLE OPTIONS */
110 #define EVERY_ACCESS 0 /* Write a line on every scsi access */
111 #define ERRORS_ONLY 1 /* Only write a line if there is an error */
112 #define DEBUG_DETECT 1 /* Debug fd_mcs_detect() */
113 #define DEBUG_MESSAGES 1 /* Debug MESSAGE IN phase */
114 #define DEBUG_ABORT 1 /* Debug abort() routine */
115 #define DEBUG_RESET 1 /* Debug reset() routine */
116 #define DEBUG_RACE 1 /* Debug interrupt-driven race condition */
118 #define EVERY_ACCESS 0 /* LEAVE THESE ALONE--CHANGE THE ONES ABOVE */
119 #define ERRORS_ONLY 0
120 #define DEBUG_DETECT 0
121 #define DEBUG_MESSAGES 0
122 #define DEBUG_ABORT 0
123 #define DEBUG_RESET 0
127 /* Errors are reported on the line, so we don't need to report them again */
130 #define ERRORS_ONLY 0
134 #define PARITY_MASK 0x08
136 #define PARITY_MASK 0x00
147 in_arbitration = 0x02,
159 FIFO_Status = 3, /* tmc18c50/tmc18c30 only */
160 Interrupt_Cond = 4, /* tmc18c50/tmc18c30 only */
165 Interrupt_Status = 9,
167 Configuration2 = 11, /* tmc18c50/tmc18c30 only */
178 Memory_Cntl = 5, /* tmc18c50/tmc18c30 only */
180 IO_Control = 11, /* tmc18c30 only */
185 unsigned long _bios_base;
188 volatile int _in_command;
189 Scsi_Cmnd *_current_SC;
190 enum chip_type _chip;
192 int _fifo_count; /* Number of 512 byte blocks before INTR */
194 char _adapter_name[64];
196 volatile int _in_interrupt_flag;
199 int _SCSI_Mode_Cntl_port;
200 int _FIFO_Data_Count_port;
201 int _Interrupt_Cntl_port;
202 int _Interrupt_Status_port;
203 int _Interrupt_Cond_port;
205 int _Read_SCSI_Data_port;
207 int _SCSI_Data_NoACK_port;
208 int _SCSI_Status_port;
210 int _TMC_Status_port;
211 int _Write_FIFO_port;
212 int _Write_SCSI_Data_port;
214 int _FIFO_Size; /* = 0x2000; 8k FIFO for
215 pre-tmc18c30 chips */
222 #define FD_MAX_HOSTS 3 /* enough? */
224 #define HOSTDATA(shpnt) ((struct fd_hostdata *) shpnt->hostdata)
225 #define bios_base (HOSTDATA(shpnt)->_bios_base)
226 #define bios_major (HOSTDATA(shpnt)->_bios_major)
227 #define bios_minor (HOSTDATA(shpnt)->_bios_minor)
228 #define in_command (HOSTDATA(shpnt)->_in_command)
229 #define current_SC (HOSTDATA(shpnt)->_current_SC)
230 #define chip (HOSTDATA(shpnt)->_chip)
231 #define adapter_mask (HOSTDATA(shpnt)->_adapter_mask)
232 #define FIFO_COUNT (HOSTDATA(shpnt)->_fifo_count)
233 #define adapter_name (HOSTDATA(shpnt)->_adapter_name)
235 #define in_interrupt_flag (HOSTDATA(shpnt)->_in_interrupt_flag)
237 #define SCSI_Mode_Cntl_port (HOSTDATA(shpnt)->_SCSI_Mode_Cntl_port)
238 #define FIFO_Data_Count_port (HOSTDATA(shpnt)->_FIFO_Data_Count_port)
239 #define Interrupt_Cntl_port (HOSTDATA(shpnt)->_Interrupt_Cntl_port)
240 #define Interrupt_Status_port (HOSTDATA(shpnt)->_Interrupt_Status_port)
241 #define Interrupt_Cond_port (HOSTDATA(shpnt)->_Interrupt_Cond_port)
242 #define Read_FIFO_port (HOSTDATA(shpnt)->_Read_FIFO_port)
243 #define Read_SCSI_Data_port (HOSTDATA(shpnt)->_Read_SCSI_Data_port)
244 #define SCSI_Cntl_port (HOSTDATA(shpnt)->_SCSI_Cntl_port)
245 #define SCSI_Data_NoACK_port (HOSTDATA(shpnt)->_SCSI_Data_NoACK_port)
246 #define SCSI_Status_port (HOSTDATA(shpnt)->_SCSI_Status_port)
247 #define TMC_Cntl_port (HOSTDATA(shpnt)->_TMC_Cntl_port)
248 #define TMC_Status_port (HOSTDATA(shpnt)->_TMC_Status_port)
249 #define Write_FIFO_port (HOSTDATA(shpnt)->_Write_FIFO_port)
250 #define Write_SCSI_Data_port (HOSTDATA(shpnt)->_Write_SCSI_Data_port)
251 #define FIFO_Size (HOSTDATA(shpnt)->_FIFO_Size)
252 #define Bytes_Read (HOSTDATA(shpnt)->_Bytes_Read)
253 #define Bytes_Written (HOSTDATA(shpnt)->_Bytes_Written)
254 #define INTR_Processed (HOSTDATA(shpnt)->_INTR_Processed)
256 struct fd_mcs_adapters_struct {
259 enum chip_type fd_chip;
264 #define REPLY_ID 0x5137
266 static struct fd_mcs_adapters_struct fd_mcs_adapters[] = {
267 {"Future Domain SCSI Adapter MCS-700(18C50)",
272 {"Future Domain SCSI Adapter MCS-600/700(TMC-1800)",
277 {"Reply Sound Blaster/SCSI Adapter",
284 #define FD_BRDS sizeof(fd_mcs_adapters)/sizeof(struct fd_mcs_adapters_struct)
286 static irqreturn_t fd_mcs_intr(int irq, void *dev_id, struct pt_regs *regs);
288 static unsigned long addresses[] = { 0xc8000, 0xca000, 0xce000, 0xde000 };
289 static unsigned short ports[] = { 0x140, 0x150, 0x160, 0x170 };
290 static unsigned short ints[] = { 3, 5, 10, 11, 12, 14, 15, 0 };
292 /* host information */
293 static int found = 0;
294 static struct Scsi_Host *hosts[FD_MAX_HOSTS + 1] = { NULL };
296 static int user_fifo_count = 0;
297 static int user_fifo_size = 0;
299 static void fd_mcs_setup(char *str, int *ints)
301 static int done_setup = 0;
303 if (done_setup++ || ints[0] < 1 || ints[0] > 2 || ints[1] < 1 || ints[1] > 16) {
304 printk("fd_mcs: usage: fd_mcs=FIFO_COUNT, FIFO_SIZE\n");
307 user_fifo_count = ints[0] >= 1 ? ints[1] : 0;
308 user_fifo_size = ints[0] >= 2 ? ints[2] : 0;
311 __setup("fd_mcs=", fd_mcs_setup);
313 static void print_banner(struct Scsi_Host *shpnt)
315 printk("scsi%d <fd_mcs>: ", shpnt->host_no);
318 printk("BIOS at 0x%lX", bios_base);
323 printk(", HostID %d, %s Chip, IRQ %d, IO 0x%lX\n", shpnt->this_id, chip == tmc18c50 ? "TMC-18C50" : (chip == tmc18c30 ? "TMC-18C30" : (chip == tmc1800 ? "TMC-1800" : "Unknown")), shpnt->irq, shpnt->io_port);
327 static void do_pause(unsigned amount)
328 { /* Pause for amount*10 milliseconds */
334 static void fd_mcs_make_bus_idle(struct Scsi_Host *shpnt)
336 outb(0, SCSI_Cntl_port);
337 outb(0, SCSI_Mode_Cntl_port);
338 if (chip == tmc18c50 || chip == tmc18c30)
339 outb(0x21 | PARITY_MASK, TMC_Cntl_port); /* Clear forced intr. */
341 outb(0x01 | PARITY_MASK, TMC_Cntl_port);
344 static int fd_mcs_detect(Scsi_Host_Template * tpnt)
347 struct Scsi_Host *shpnt;
349 /* get id, port, bios, irq */
351 u_char pos2, pos3, pos4;
355 /* if not MCA machine, return */
362 for (loop = 0; loop < FD_BRDS; loop++) {
364 while (MCA_NOTFOUND != (slot = mca_find_adapter(fd_mcs_adapters[loop].id, slot))) {
366 /* if we get this far, an adapter has been detected and is
369 printk(KERN_INFO "scsi <fd_mcs>: %s at slot %d\n", fd_mcs_adapters[loop].name, slot + 1);
371 pos2 = mca_read_stored_pos(slot, 2);
372 pos3 = mca_read_stored_pos(slot, 3);
373 pos4 = mca_read_stored_pos(slot, 4);
375 /* ready for next probe */
378 if (fd_mcs_adapters[loop].id == REPLY_ID) { /* reply card */
379 static int reply_irq[] = { 10, 11, 14, 15 };
381 bios = 0; /* no bios */
384 port = ports[pos4 & 0x3];
388 /* can't really disable it, same as irq=10 */
389 irq = reply_irq[((pos4 >> 2) & 0x1) + 2 * ((pos4 >> 4) & 0x1)];
391 bios = addresses[pos2 >> 6];
392 port = ports[(pos2 >> 4) & 0x03];
393 irq = ints[(pos2 >> 1) & 0x07];
398 mca_set_adapter_name(slot - 1, fd_mcs_adapters[loop].name);
400 /* check irq/region */
401 if (request_irq(irq, fd_mcs_intr, SA_SHIRQ, "fd_mcs", hosts)) {
402 printk(KERN_ERR "fd_mcs: interrupt is not available, skipping...\n");
406 /* request I/O region */
407 if (request_region(port, 0x10, "fd_mcs")) {
408 printk(KERN_ERR "fd_mcs: I/O region is already in use, skipping...\n");
412 if (!(shpnt = scsi_register(tpnt, sizeof(struct fd_hostdata)))) {
413 printk(KERN_ERR "fd_mcs: scsi_register() failed\n");
414 release_region(port, 0x10);
415 free_irq(irq, hosts);
421 strcpy(adapter_name, fd_mcs_adapters[loop].name);
424 chip = fd_mcs_adapters[loop].fd_chip;
425 /* use boot time value if available */
426 FIFO_COUNT = user_fifo_count ? user_fifo_count : fd_mcs_adapters[loop].fifo_count;
427 FIFO_Size = user_fifo_size ? user_fifo_size : fd_mcs_adapters[loop].fifo_size;
430 /* *************************************************** */
431 /* Try to toggle 32-bit mode. This only
432 works on an 18c30 chip. (User reports
433 say this works, so we should switch to
434 it in the near future.) */
435 outb(0x80, port + IO_Control);
436 if ((inb(port + Configuration2) & 0x80) == 0x80) {
437 outb(0x00, port + IO_Control);
438 if ((inb(port + Configuration2) & 0x80) == 0x00) {
440 FIFO_Size = 0x800; /* 2k FIFO */
442 printk("FIRST: chip=%s, fifo_size=0x%x\n", (chip == tmc18c30) ? "tmc18c30" : "tmc18c50", FIFO_Size);
446 /* That should have worked, but appears to
447 have problems. Let's assume it is an
448 18c30 if the RAM is disabled. */
450 if (inb(port + Configuration2) & 0x02) {
452 FIFO_Size = 0x800; /* 2k FIFO */
454 printk("SECOND: chip=%s, fifo_size=0x%x\n", (chip == tmc18c30) ? "tmc18c30" : "tmc18c50", FIFO_Size);
456 /* *************************************************** */
459 /* IBM/ANSI scsi scan ordering */
460 /* Stick this back in when the scsi.c changes are there */
461 shpnt->reverse_ordering = 1;
465 hosts[found++] = shpnt;
469 shpnt->io_port = port;
470 shpnt->n_io_port = 0x10;
474 adapter_mask = (1 << id);
477 SCSI_Mode_Cntl_port = port + SCSI_Mode_Cntl;
478 FIFO_Data_Count_port = port + FIFO_Data_Count;
479 Interrupt_Cntl_port = port + Interrupt_Cntl;
480 Interrupt_Status_port = port + Interrupt_Status;
481 Interrupt_Cond_port = port + Interrupt_Cond;
482 Read_FIFO_port = port + Read_FIFO;
483 Read_SCSI_Data_port = port + Read_SCSI_Data;
484 SCSI_Cntl_port = port + SCSI_Cntl;
485 SCSI_Data_NoACK_port = port + SCSI_Data_NoACK;
486 SCSI_Status_port = port + SCSI_Status;
487 TMC_Cntl_port = port + TMC_Cntl;
488 TMC_Status_port = port + TMC_Status;
489 Write_FIFO_port = port + Write_FIFO;
490 Write_SCSI_Data_port = port + Write_SCSI_Data;
500 outb(1, SCSI_Cntl_port);
502 outb(0, SCSI_Cntl_port);
504 outb(0, SCSI_Mode_Cntl_port);
505 outb(PARITY_MASK, TMC_Cntl_port);
509 /* scan devices attached */
511 const int buflen = 255;
514 unsigned char do_inquiry[] = { INQUIRY, 0, 0, 0, buflen, 0 };
515 unsigned char do_request_sense[] = { REQUEST_SENSE,
518 unsigned char do_read_capacity[] = { READ_CAPACITY,
519 0, 0, 0, 0, 0, 0, 0, 0, 0
521 unsigned char buf[buflen];
523 SCinit.request_buffer = SCinit.buffer = buf;
524 SCinit.request_bufflen = SCinit.bufflen = sizeof(buf) - 1;
529 printk("fd_mcs: detection routine scanning for devices:\n");
530 for (i = 0; i < 8; i++) {
531 if (i == shpnt->this_id) /* Skip host adapter */
534 memcpy(SCinit.cmnd, do_request_sense, sizeof(do_request_sense));
535 retcode = fd_mcs_command(&SCinit);
537 memcpy(SCinit.cmnd, do_inquiry, sizeof(do_inquiry));
538 retcode = fd_mcs_command(&SCinit);
540 printk(" SCSI ID %d: ", i);
541 for (j = 8; j < (buf[4] < 32 ? buf[4] : 32); j++)
542 printk("%c", buf[j] >= 20 ? buf[j] : ' ');
543 memcpy(SCinit.cmnd, do_read_capacity, sizeof(do_read_capacity));
544 retcode = fd_mcs_command(&SCinit);
546 unsigned long blocks, size, capacity;
548 blocks = (buf[0] << 24) | (buf[1] << 16)
549 | (buf[2] << 8) | buf[3];
550 size = (buf[4] << 24) | (buf[5] << 16) | (buf[6] << 8) | buf[7];
551 capacity = +(+(blocks / 1024L) * +(size * 10L)) / 1024L;
553 printk("%lu MB (%lu byte blocks)\n", ((capacity + 5L) / 10L), size);
563 if (found == FD_MAX_HOSTS) {
564 printk("fd_mcs: detecting reached max=%d host adapters.\n", FD_MAX_HOSTS);
572 static const char *fd_mcs_info(struct Scsi_Host *shpnt)
577 static int TOTAL_INTR = 0;
580 * inout : decides on the direction of the dataflow and the meaning of the
582 * buffer: If inout==FALSE data is being written to it else read from it
583 * *start: If inout==FALSE start of the valid data in the buffer
584 * offset: If inout==FALSE offset from the beginning of the imaginary file
585 * from which we start writing into the buffer
586 * length: If inout==FALSE max number of bytes to be written into the buffer
587 * else number of bytes in the buffer
589 static int fd_mcs_proc_info(struct Scsi_Host *shpnt, char *buffer, char **start, off_t offset, int length, int inout)
596 *start = buffer + offset;
598 len += sprintf(buffer + len, "Future Domain MCS-600/700 Driver %s\n", DRIVER_VERSION);
599 len += sprintf(buffer + len, "HOST #%d: %s\n", shpnt->host_no, adapter_name);
600 len += sprintf(buffer + len, "FIFO Size=0x%x, FIFO Count=%d\n", FIFO_Size, FIFO_COUNT);
601 len += sprintf(buffer + len, "DriverCalls=%d, Interrupts=%d, BytesRead=%d, BytesWrite=%d\n\n", TOTAL_INTR, INTR_Processed, Bytes_Read, Bytes_Written);
603 if ((len -= offset) <= 0)
610 static int fd_mcs_select(struct Scsi_Host *shpnt, int target)
613 unsigned long timeout;
615 outb(0x82, SCSI_Cntl_port); /* Bus Enable + Select */
616 outb(adapter_mask | (1 << target), SCSI_Data_NoACK_port);
618 /* Stop arbitration and enable parity */
619 outb(PARITY_MASK, TMC_Cntl_port);
621 timeout = 350; /* 350mS -- because of timeouts
625 status = inb(SCSI_Status_port); /* Read adapter status */
626 if (status & 1) { /* Busy asserted */
627 /* Enable SCSI Bus (on error, should make bus idle with 0) */
628 outb(0x80, SCSI_Cntl_port);
631 udelay(1000); /* wait one msec */
635 fd_mcs_make_bus_idle(shpnt);
638 printk("Selection failed\n");
644 if (!flag) /* Skip first failure for all chips. */
647 printk("fd_mcs: Selection failed\n");
653 static void my_done(struct Scsi_Host *shpnt, int error)
657 outb(0x00, Interrupt_Cntl_port);
658 fd_mcs_make_bus_idle(shpnt);
659 current_SC->result = error;
660 current_SC->scsi_done(current_SC);
662 panic("fd_mcs: my_done() called outside of command\n");
665 in_interrupt_flag = 0;
669 /* only my_done needs to be protected */
670 static irqreturn_t fd_mcs_intr(int irq, void *dev_id, struct pt_regs *regs)
675 unsigned data_count, tmp_count;
678 struct Scsi_Host *shpnt;
682 /* search for one adapter-response on shared interrupt */
683 while ((shpnt = hosts[i++])) {
684 if ((inb(TMC_Status_port)) & 1)
688 /* return if some other device on this IRQ caused the interrupt */
695 outb(0x00, Interrupt_Cntl_port);
697 /* Abort calls my_done, so we do nothing here. */
698 if (current_SC->SCp.phase & aborted) {
700 printk("Interrupt after abort, ignoring\n");
702 /* return IRQ_HANDLED; */
708 if (current_SC->SCp.phase & in_arbitration) {
709 status = inb(TMC_Status_port); /* Read adapter status */
710 if (!(status & 0x02)) {
714 spin_lock_irqsave(shpnt->host_lock, flags);
715 my_done(shpnt, DID_BUS_BUSY << 16);
716 spin_unlock_irqrestore(shpnt->host_lock, flags);
719 current_SC->SCp.phase = in_selection;
721 outb(0x40 | FIFO_COUNT, Interrupt_Cntl_port);
723 outb(0x82, SCSI_Cntl_port); /* Bus Enable + Select */
724 outb(adapter_mask | (1 << current_SC->device->id), SCSI_Data_NoACK_port);
726 /* Stop arbitration and enable parity */
727 outb(0x10 | PARITY_MASK, TMC_Cntl_port);
729 in_interrupt_flag = 0;
732 } else if (current_SC->SCp.phase & in_selection) {
733 status = inb(SCSI_Status_port);
734 if (!(status & 0x01)) {
735 /* Try again, for slow devices */
736 if (fd_mcs_select(shpnt, current_SC->device->id)) {
740 spin_lock_irqsave(shpnt->host_lock, flags);
741 my_done(shpnt, DID_NO_CONNECT << 16);
742 spin_unlock_irqrestore(shpnt->host_lock, flags);
748 /* Stop arbitration and enable parity */
749 outb(0x10 | PARITY_MASK, TMC_Cntl_port);
752 current_SC->SCp.phase = in_other;
753 outb(0x90 | FIFO_COUNT, Interrupt_Cntl_port);
754 outb(0x80, SCSI_Cntl_port);
756 in_interrupt_flag = 0;
761 /* current_SC->SCp.phase == in_other: this is the body of the routine */
763 status = inb(SCSI_Status_port);
765 if (status & 0x10) { /* REQ */
767 switch (status & 0x0e) {
769 case 0x08: /* COMMAND OUT */
770 outb(current_SC->cmnd[current_SC->SCp.sent_command++], Write_SCSI_Data_port);
772 printk("CMD = %x,", current_SC->cmnd[current_SC->SCp.sent_command - 1]);
775 case 0x00: /* DATA OUT -- tmc18c50/tmc18c30 only */
776 if (chip != tmc1800 && !current_SC->SCp.have_data_in) {
777 current_SC->SCp.have_data_in = -1;
778 outb(0xd0 | PARITY_MASK, TMC_Cntl_port);
781 case 0x04: /* DATA IN -- tmc18c50/tmc18c30 only */
782 if (chip != tmc1800 && !current_SC->SCp.have_data_in) {
783 current_SC->SCp.have_data_in = 1;
784 outb(0x90 | PARITY_MASK, TMC_Cntl_port);
787 case 0x0c: /* STATUS IN */
788 current_SC->SCp.Status = inb(Read_SCSI_Data_port);
790 printk("Status = %x, ", current_SC->SCp.Status);
793 if (current_SC->SCp.Status && current_SC->SCp.Status != 2 && current_SC->SCp.Status != 8) {
794 printk("ERROR fd_mcs: target = %d, command = %x, status = %x\n", current_SC->device->id, current_SC->cmnd[0], current_SC->SCp.Status);
798 case 0x0a: /* MESSAGE OUT */
799 outb(MESSAGE_REJECT, Write_SCSI_Data_port); /* Reject */
801 case 0x0e: /* MESSAGE IN */
802 current_SC->SCp.Message = inb(Read_SCSI_Data_port);
804 printk("Message = %x, ", current_SC->SCp.Message);
806 if (!current_SC->SCp.Message)
808 #if DEBUG_MESSAGES || EVERY_ACCESS
809 if (current_SC->SCp.Message) {
810 printk("fd_mcs: message = %x\n", current_SC->SCp.Message);
817 if (chip == tmc1800 && !current_SC->SCp.have_data_in && (current_SC->SCp.sent_command >= current_SC->cmd_len)) {
818 /* We have to get the FIFO direction
819 correct, so I've made a table based
820 on the SCSI Standard of which commands
821 appear to require a DATA OUT phase.
824 p. 94: Command for all device types
825 CHANGE DEFINITION 40 DATA OUT
828 COPY AND VERIFY 3a DATA OUT
830 LOG SELECT 4c DATA OUT
832 MODE SELECT (6) 15 DATA OUT
833 MODE SELECT (10) 55 DATA OUT
837 RECEIVE DIAGNOSTIC RESULTS 1c
839 SEND DIAGNOSTIC 1d DATA OUT
841 WRITE BUFFER 3b DATA OUT
843 p.178: Commands for direct-access devices (not listed on p. 94)
844 FORMAT UNIT 04 DATA OUT
847 PREVENT-ALLOW MEDIUM REMOVAL 1e
851 READ DEFECT DATA (10) 37
853 REASSIGN BLOCKS 07 DATA OUT
856 REZERO UNIT/REWIND 01
857 SEARCH DATA EQUAL (10) 31 DATA OUT
858 SEARCH DATA HIGH (10) 30 DATA OUT
859 SEARCH DATA LOW (10) 32 DATA OUT
866 WRITE (6)/PRINT/SEND 0a DATA OUT
867 WRITE (10)/SEND 2a DATA OUT
868 WRITE AND VERIFY (10) 2e DATA OUT
869 WRITE LONG 3f DATA OUT
870 WRITE SAME 41 DATA OUT ?
872 p. 261: Commands for sequential-access devices (not previously listed)
879 RECOVER BUFFERED DATA 14
883 p. 298: Commands for printer devices (not previously listed)
884 ****** NOT SUPPORTED BY THIS DRIVER, since 0b is SEEK (6) *****
885 SLEW AND PRINT 0b DATA OUT -- same as seek
887 SYNCHRONIZE BUFFER 10
889 p. 315: Commands for processor devices (not previously listed)
891 p. 321: Commands for write-once devices (not previously listed)
894 SEARCH DATA EQUAL (12) b1 DATA OUT
895 SEARCH DATA HIGH (12) b0 DATA OUT
896 SEARCH DATA LOW (12) b2 DATA OUT
899 WRITE (12) aa DATA OUT
900 WRITE AND VERIFY (12) ae DATA OUT
902 p. 332: Commands for CD-ROM devices (not previously listed)
907 PLAY TRACK RELATIVE (10) 49
908 PLAY TRACK RELATIVE (12) a9
913 p. 370: Commands for scanner devices (not previously listed)
914 GET DATA BUFFER STATUS 34
918 SET WINDOW 24 DATA OUT
920 p. 391: Commands for optical memory devices (not listed)
923 MEDIUM SCAN 38 DATA OUT
924 READ DEFECT DATA (12) b7
926 READ UPDATED BLOCK 2d
927 UPDATE BLOCK 3d DATA OUT
929 p. 419: Commands for medium changer devices (not listed)
931 INITIALIZE ELEMENT STATUS 07
933 POSITION TO ELEMENT 2b
934 READ ELEMENT STATUS b8
935 REQUEST VOL. ELEMENT ADDRESS b5
936 SEND VOLUME TAG b6 DATA OUT
938 p. 454: Commands for communications devices (not listed previously)
944 switch (current_SC->cmnd[0]) {
945 case CHANGE_DEFINITION:
952 case SEND_DIAGNOSTIC:
956 case REASSIGN_BLOCKS:
980 case 0xea: /* alternate number for WRITE LONG */
982 current_SC->SCp.have_data_in = -1;
983 outb(0xd0 | PARITY_MASK, TMC_Cntl_port);
989 current_SC->SCp.have_data_in = 1;
990 outb(0x90 | PARITY_MASK, TMC_Cntl_port);
995 if (current_SC->SCp.have_data_in == -1) { /* DATA OUT */
996 while ((data_count = FIFO_Size - inw(FIFO_Data_Count_port)) > 512) {
998 printk("DC=%d, ", data_count);
1000 if (data_count > current_SC->SCp.this_residual)
1001 data_count = current_SC->SCp.this_residual;
1002 if (data_count > 0) {
1004 printk("%d OUT, ", data_count);
1006 if (data_count == 1) {
1009 outb(*current_SC->SCp.ptr++, Write_FIFO_port);
1010 --current_SC->SCp.this_residual;
1013 tmp_count = data_count << 1;
1014 outsw(Write_FIFO_port, current_SC->SCp.ptr, data_count);
1015 current_SC->SCp.ptr += tmp_count;
1016 Bytes_Written += tmp_count;
1017 current_SC->SCp.this_residual -= tmp_count;
1020 if (!current_SC->SCp.this_residual) {
1021 if (current_SC->SCp.buffers_residual) {
1022 --current_SC->SCp.buffers_residual;
1023 ++current_SC->SCp.buffer;
1024 current_SC->SCp.ptr = page_address(current_SC->SCp.buffer->page) + current_SC->SCp.buffer->offset;
1025 current_SC->SCp.this_residual = current_SC->SCp.buffer->length;
1030 } else if (current_SC->SCp.have_data_in == 1) { /* DATA IN */
1031 while ((data_count = inw(FIFO_Data_Count_port)) > 0) {
1033 printk("DC=%d, ", data_count);
1035 if (data_count > current_SC->SCp.this_residual)
1036 data_count = current_SC->SCp.this_residual;
1039 printk("%d IN, ", data_count);
1041 if (data_count == 1) {
1043 *current_SC->SCp.ptr++ = inb(Read_FIFO_port);
1044 --current_SC->SCp.this_residual;
1046 data_count >>= 1; /* Number of words */
1047 tmp_count = data_count << 1;
1048 insw(Read_FIFO_port, current_SC->SCp.ptr, data_count);
1049 current_SC->SCp.ptr += tmp_count;
1050 Bytes_Read += tmp_count;
1051 current_SC->SCp.this_residual -= tmp_count;
1054 if (!current_SC->SCp.this_residual && current_SC->SCp.buffers_residual) {
1055 --current_SC->SCp.buffers_residual;
1056 ++current_SC->SCp.buffer;
1057 current_SC->SCp.ptr = page_address(current_SC->SCp.buffer->page) + current_SC->SCp.buffer->offset;
1058 current_SC->SCp.this_residual = current_SC->SCp.buffer->length;
1065 printk(" ** IN DONE %d ** ", current_SC->SCp.have_data_in);
1069 if (current_SC->cmnd[0] == REQUEST_SENSE && !current_SC->SCp.Status) {
1070 if ((unsigned char) (*((char *) current_SC->request_buffer + 2)) & 0x0f) {
1073 unsigned char qualifier;
1075 key = (unsigned char) (*((char *) current_SC->request_buffer + 2)) & 0x0f;
1076 code = (unsigned char) (*((char *) current_SC->request_buffer + 12));
1077 qualifier = (unsigned char) (*((char *) current_SC->request_buffer + 13));
1079 if (key != UNIT_ATTENTION && !(key == NOT_READY && code == 0x04 && (!qualifier || qualifier == 0x02 || qualifier == 0x01))
1080 && !(key == ILLEGAL_REQUEST && (code == 0x25 || code == 0x24 || !code)))
1082 printk("fd_mcs: REQUEST SENSE " "Key = %x, Code = %x, Qualifier = %x\n", key, code, qualifier);
1087 printk("BEFORE MY_DONE. . .");
1089 spin_lock_irqsave(shpnt->host_lock, flags);
1090 my_done(shpnt, (current_SC->SCp.Status & 0xff)
1091 | ((current_SC->SCp.Message & 0xff) << 8) | (DID_OK << 16));
1092 spin_unlock_irqrestore(shpnt->host_lock, flags);
1094 printk("RETURNING.\n");
1098 if (current_SC->SCp.phase & disconnect) {
1099 outb(0xd0 | FIFO_COUNT, Interrupt_Cntl_port);
1100 outb(0x00, SCSI_Cntl_port);
1102 outb(0x90 | FIFO_COUNT, Interrupt_Cntl_port);
1106 in_interrupt_flag = 0;
1111 static int fd_mcs_release(struct Scsi_Host *shpnt)
1113 int i, this_host, irq_usage;
1115 release_region(shpnt->io_port, shpnt->n_io_port);
1119 for (i = 0; i < found; i++) {
1120 if (shpnt == hosts[i])
1122 if (shpnt->irq == hosts[i]->irq)
1126 /* only for the last one */
1128 free_irq(shpnt->irq, hosts);
1132 for (i = this_host; i < found; i++)
1133 hosts[i] = hosts[i + 1];
1135 hosts[found] = NULL;
1140 static int fd_mcs_queue(Scsi_Cmnd * SCpnt, void (*done) (Scsi_Cmnd *))
1142 struct Scsi_Host *shpnt = SCpnt->device->host;
1145 panic("fd_mcs: fd_mcs_queue() NOT REENTRANT!\n");
1148 printk("queue: target = %d cmnd = 0x%02x pieces = %d size = %u\n", SCpnt->target, *(unsigned char *) SCpnt->cmnd, SCpnt->use_sg, SCpnt->request_bufflen);
1151 fd_mcs_make_bus_idle(shpnt);
1153 SCpnt->scsi_done = done; /* Save this for the done function */
1156 /* Initialize static data */
1158 if (current_SC->use_sg) {
1159 current_SC->SCp.buffer = (struct scatterlist *) current_SC->request_buffer;
1160 current_SC->SCp.ptr = page_address(current_SC->SCp.buffer->page) + current_SC->SCp.buffer->offset;
1161 current_SC->SCp.this_residual = current_SC->SCp.buffer->length;
1162 current_SC->SCp.buffers_residual = current_SC->use_sg - 1;
1164 current_SC->SCp.ptr = (char *) current_SC->request_buffer;
1165 current_SC->SCp.this_residual = current_SC->request_bufflen;
1166 current_SC->SCp.buffer = NULL;
1167 current_SC->SCp.buffers_residual = 0;
1171 current_SC->SCp.Status = 0;
1172 current_SC->SCp.Message = 0;
1173 current_SC->SCp.have_data_in = 0;
1174 current_SC->SCp.sent_command = 0;
1175 current_SC->SCp.phase = in_arbitration;
1177 /* Start arbitration */
1178 outb(0x00, Interrupt_Cntl_port);
1179 outb(0x00, SCSI_Cntl_port); /* Disable data drivers */
1180 outb(adapter_mask, SCSI_Data_NoACK_port); /* Set our id bit */
1182 outb(0x20, Interrupt_Cntl_port);
1183 outb(0x14 | PARITY_MASK, TMC_Cntl_port); /* Start arbitration */
1188 #if DEBUG_ABORT || DEBUG_RESET
1189 static void fd_mcs_print_info(Scsi_Cmnd * SCpnt)
1194 struct Scsi_Host *shpnt = SCpnt->host;
1196 if (!SCpnt || !SCpnt->host) {
1197 printk("fd_mcs: cannot provide detailed information\n");
1200 printk("%s\n", fd_mcs_info(SCpnt->host));
1201 print_banner(SCpnt->host);
1202 switch (SCpnt->SCp.phase) {
1203 case in_arbitration:
1204 printk("arbitration ");
1207 printk("selection ");
1217 printk("(%d), target = %d cmnd = 0x%02x pieces = %d size = %u\n", SCpnt->SCp.phase, SCpnt->device->id, *(unsigned char *) SCpnt->cmnd, SCpnt->use_sg, SCpnt->request_bufflen);
1218 printk("sent_command = %d, have_data_in = %d, timeout = %d\n", SCpnt->SCp.sent_command, SCpnt->SCp.have_data_in, SCpnt->timeout);
1220 printk("in_interrupt_flag = %d\n", in_interrupt_flag);
1223 imr = (inb(0x0a1) << 8) + inb(0x21);
1225 irr = inb(0xa0) << 8;
1229 isr = inb(0xa0) << 8;
1233 /* Print out interesting information */
1234 printk("IMR = 0x%04x", imr);
1235 if (imr & (1 << shpnt->irq))
1236 printk(" (masked)");
1237 printk(", IRR = 0x%04x, ISR = 0x%04x\n", irr, isr);
1239 printk("SCSI Status = 0x%02x\n", inb(SCSI_Status_port));
1240 printk("TMC Status = 0x%02x", inb(TMC_Status_port));
1241 if (inb(TMC_Status_port) & 1)
1242 printk(" (interrupt)");
1244 printk("Interrupt Status = 0x%02x", inb(Interrupt_Status_port));
1245 if (inb(Interrupt_Status_port) & 0x08)
1246 printk(" (enabled)");
1248 if (chip == tmc18c50 || chip == tmc18c30) {
1249 printk("FIFO Status = 0x%02x\n", inb(shpnt->io_port + FIFO_Status));
1250 printk("Int. Condition = 0x%02x\n", inb(shpnt->io_port + Interrupt_Cond));
1252 printk("Configuration 1 = 0x%02x\n", inb(shpnt->io_port + Configuration1));
1253 if (chip == tmc18c50 || chip == tmc18c30)
1254 printk("Configuration 2 = 0x%02x\n", inb(shpnt->io_port + Configuration2));
1258 static int fd_mcs_abort(Scsi_Cmnd * SCpnt)
1260 struct Scsi_Host *shpnt = SCpnt->device->host;
1262 unsigned long flags;
1263 #if EVERY_ACCESS || ERRORS_ONLY || DEBUG_ABORT
1264 printk("fd_mcs: abort ");
1267 spin_lock_irqsave(shpnt->host_lock, flags);
1269 #if EVERY_ACCESS || ERRORS_ONLY
1270 printk(" (not in command)\n");
1272 spin_unlock_irqrestore(shpnt->host_lock, flags);
1278 fd_mcs_print_info(SCpnt);
1281 fd_mcs_make_bus_idle(shpnt);
1283 current_SC->SCp.phase |= aborted;
1285 current_SC->result = DID_ABORT << 16;
1287 /* Aborts are not done well. . . */
1288 my_done(shpnt, DID_ABORT << 16);
1290 spin_unlock_irqrestore(shpnt->host_lock, flags);
1294 static int fd_mcs_host_reset(Scsi_Cmnd * SCpnt)
1299 static int fd_mcs_device_reset(Scsi_Cmnd * SCpnt)
1304 static int fd_mcs_bus_reset(Scsi_Cmnd * SCpnt) {
1305 struct Scsi_Host *shpnt = SCpnt->device->host;
1308 static int called_once = 0;
1313 printk("fd_mcs: SCSI Bus Reset\n");
1318 fd_mcs_print_info(current_SC);
1322 outb(1, SCSI_Cntl_port);
1324 outb(0, SCSI_Cntl_port);
1326 outb(0, SCSI_Mode_Cntl_port);
1327 outb(PARITY_MASK, TMC_Cntl_port);
1329 /* Unless this is the very first call (i.e., SCPnt == NULL), everything
1330 is probably hosed at this point. We will, however, try to keep
1331 things going by informing the high-level code that we need help. */
1335 #include <scsi/scsi_ioctl.h>
1337 static int fd_mcs_biosparam(struct scsi_device * disk, struct block_device *bdev,
1338 sector_t capacity, int *info_array)
1340 unsigned char buf[512 + sizeof(int) * 2];
1341 int size = capacity;
1342 int *sizes = (int *) buf;
1343 unsigned char *data = (unsigned char *) (sizes + 2);
1344 unsigned char do_read[] = { READ_6, 0, 0, 0, 1, 0 };
1347 /* BIOS >= 3.4 for MCA cards */
1348 /* This algorithm was provided by Future Domain (much thanks!). */
1350 sizes[0] = 0; /* zero bytes out */
1351 sizes[1] = 512; /* one sector in */
1352 memcpy(data, do_read, sizeof(do_read));
1353 retcode = kernel_scsi_ioctl(disk, SCSI_IOCTL_SEND_COMMAND, (void *) buf);
1354 if (!retcode /* SCSI command ok */
1355 && data[511] == 0xaa && data[510] == 0x55 /* Partition table valid */
1356 && data[0x1c2]) { /* Partition type */
1357 /* The partition table layout is as follows:
1360 Offset: 0 = partition status
1362 2 = starting sector and cylinder (word, encoded)
1365 6 = ending sector and cylinder (word, encoded)
1366 8 = starting absolute sector (double word)
1367 c = number of sectors (double word)
1368 Signature: 0x1fe = 0x55aa
1370 So, this algorithm assumes:
1371 1) the first partition table is in use,
1372 2) the data in the first entry is correct, and
1373 3) partitions never divide cylinders
1375 Note that (1) may be FALSE for NetBSD (and other BSD flavors),
1376 as well as for Linux. Note also, that Linux doesn't pay any
1377 attention to the fields that are used by this algorithm -- it
1378 only uses the absolute sector data. Recent versions of Linux's
1379 fdisk(1) will fill this data in correctly, and forthcoming
1380 versions will check for consistency.
1382 Checking for a non-zero partition type is not part of the
1383 Future Domain algorithm, but it seemed to be a reasonable thing
1384 to do, especially in the Linux and BSD worlds. */
1386 info_array[0] = data[0x1c3] + 1; /* heads */
1387 info_array[1] = data[0x1c4] & 0x3f; /* sectors */
1389 /* Note that this new method guarantees that there will always be
1390 less than 1024 cylinders on a platter. This is good for drives
1391 up to approximately 7.85GB (where 1GB = 1024 * 1024 kB). */
1392 if ((unsigned int) size >= 0x7e0000U)
1394 info_array[0] = 0xff; /* heads = 255 */
1395 info_array[1] = 0x3f; /* sectors = 63 */
1396 } else if ((unsigned int) size >= 0x200000U) {
1397 info_array[0] = 0x80; /* heads = 128 */
1398 info_array[1] = 0x3f; /* sectors = 63 */
1400 info_array[0] = 0x40; /* heads = 64 */
1401 info_array[1] = 0x20; /* sectors = 32 */
1404 /* For both methods, compute the cylinders */
1405 info_array[2] = (unsigned int) size / (info_array[0] * info_array[1]);
1409 static Scsi_Host_Template driver_template = {
1410 .proc_name = "fd_mcs",
1411 .proc_info = fd_mcs_proc_info,
1412 .detect = fd_mcs_detect,
1413 .release = fd_mcs_release,
1414 .info = fd_mcs_info,
1415 .queuecommand = fd_mcs_queue,
1416 .eh_abort_handler = fd_mcs_abort,
1417 .eh_bus_reset_handler = fd_mcs_bus_reset,
1418 .eh_host_reset_handler = fd_mcs_host_reset,
1419 .eh_device_reset_handler = fd_mcs_device_reset,
1420 .bios_param = fd_mcs_biosparam,
1425 .use_clustering = DISABLE_CLUSTERING,
1427 #include "scsi_module.c"