/* * seagate.c Copyright (C) 1992, 1993 Drew Eckhardt * low level scsi driver for ST01/ST02, Future Domain TMC-885, * TMC-950 by Drew Eckhardt <drew@colorado.edu> * * Note : TMC-880 boards don't work because they have two bits in * the status register flipped, I'll fix this "RSN" * [why do I have strong feeling that above message is from 1993? :-) * pavel@ucw.cz] * * This card does all the I/O via memory mapped I/O, so there is no need * to check or allocate a region of the I/O address space. */ /* 1996 - to use new read{b,w,l}, write{b,w,l}, and phys_to_virt * macros, replaced assembler routines with C. There's probably a * performance hit, but I only have a cdrom and can't tell. Define * SEAGATE_USE_ASM if you want the old assembler code -- SJT * * 1998-jul-29 - created DPRINTK macros and made it work under * linux 2.1.112, simplified some #defines etc. <pavel@ucw.cz> * * Aug 2000 - aeb - deleted seagate_st0x_biosparam(). It would try to * read the physical disk geometry, a bad mistake. Of course it doesn't * matter much what geometry one invents, but on large disks it * returned 256 (or more) heads, causing all kind of failures. * Of course this means that people might see a different geometry now, * so boot parameters may be necessary in some cases. */ /* * Configuration : * To use without BIOS -DOVERRIDE=base_address -DCONTROLLER=FD or SEAGATE * -DIRQ will override the default of 5. * Note: You can now set these options from the kernel's "command line". * The syntax is: * * st0x=ADDRESS,IRQ (for a Seagate controller) * or: * tmc8xx=ADDRESS,IRQ (for a TMC-8xx or TMC-950 controller) * eg: * tmc8xx=0xC8000,15 * * will configure the driver for a TMC-8xx style controller using IRQ 15 * with a base address of 0xC8000. * * -DARBITRATE * Will cause the host adapter to arbitrate for the * bus for better SCSI-II compatibility, rather than just * waiting for BUS FREE and then doing its thing. Should * let us do one command per Lun when I integrate my * reorganization changes into the distribution sources. * * -DDEBUG=65535 * Will activate debug code. * * -DFAST or -DFAST32 * Will use blind transfers where possible * * -DPARITY * This will enable parity. * * -DSEAGATE_USE_ASM * Will use older seagate assembly code. should be (very small amount) * Faster. * * -DSLOW_RATE=50 * Will allow compatibility with broken devices that don't * handshake fast enough (ie, some CD ROM's) for the Seagate * code. * * 50 is some number, It will let you specify a default * transfer rate if handshaking isn't working correctly. * * -DOLDCNTDATASCEME There is a new sceme to set the CONTROL * and DATA reigsters which complies more closely * with the SCSI2 standard. This hopefully eliminates * the need to swap the order these registers are * 'messed' with. It makes the following two options * obsolete. To reenable the old sceme define this. * * The following to options are patches from the SCSI.HOWTO * * -DSWAPSTAT This will swap the definitions for STAT_MSG and STAT_CD. * * -DSWAPCNTDATA This will swap the order that seagate.c messes with * the CONTROL an DATA registers. */ #include <linux/module.h> #include <linux/interrupt.h> #include <linux/spinlock.h> #include <linux/signal.h> #include <linux/string.h> #include <linux/proc_fs.h> #include <linux/init.h> #include <linux/blkdev.h> #include <linux/stat.h> #include <linux/delay.h> #include <linux/io.h> #include <asm/system.h> #include <asm/uaccess.h> #include <scsi/scsi_cmnd.h> #include <scsi/scsi_device.h> #include <scsi/scsi.h> #include <scsi/scsi_dbg.h> #include <scsi/scsi_host.h> #ifdef DEBUG #define DPRINTK( when, msg... ) do { if ( (DEBUG & (when)) == (when) ) printk( msg ); } while (0) #else #define DPRINTK( when, msg... ) do { } while (0) #define DEBUG 0 #endif #define DANY( msg... ) DPRINTK( 0xffff, msg ); #ifndef IRQ #define IRQ 5 #endif #ifdef FAST32 #define FAST #endif #undef LINKED /* Linked commands are currently broken! */ #if defined(OVERRIDE) && !defined(CONTROLLER) #error Please use -DCONTROLLER=SEAGATE or -DCONTROLLER=FD to override controller type #endif #ifndef __i386__ #undef SEAGATE_USE_ASM #endif /* Thanks to Brian Antoine for the example code in his Messy-Loss ST-01 driver, and Mitsugu Suzuki for information on the ST-01 SCSI host. */ /* CONTROL defines */ #define CMD_RST 0x01 #define CMD_SEL 0x02 #define CMD_BSY 0x04 #define CMD_ATTN 0x08 #define CMD_START_ARB 0x10 #define CMD_EN_PARITY 0x20 #define CMD_INTR 0x40 #define CMD_DRVR_ENABLE 0x80 /* STATUS */ #ifdef SWAPSTAT #define STAT_MSG 0x08 #define STAT_CD 0x02 #else #define STAT_MSG 0x02 #define STAT_CD 0x08 #endif #define STAT_BSY 0x01 #define STAT_IO 0x04 #define STAT_REQ 0x10 #define STAT_SEL 0x20 #define STAT_PARITY 0x40 #define STAT_ARB_CMPL 0x80 /* REQUESTS */ #define REQ_MASK (STAT_CD | STAT_IO | STAT_MSG) #define REQ_DATAOUT 0 #define REQ_DATAIN STAT_IO #define REQ_CMDOUT STAT_CD #define REQ_STATIN (STAT_CD | STAT_IO) #define REQ_MSGOUT (STAT_MSG | STAT_CD) #define REQ_MSGIN (STAT_MSG | STAT_CD | STAT_IO) extern volatile int seagate_st0x_timeout; #ifdef PARITY #define BASE_CMD CMD_EN_PARITY #else #define BASE_CMD 0 #endif /* Debugging code */ #define PHASE_BUS_FREE 1 #define PHASE_ARBITRATION 2 #define PHASE_SELECTION 4 #define PHASE_DATAIN 8 #define PHASE_DATAOUT 0x10 #define PHASE_CMDOUT 0x20 #define PHASE_MSGIN 0x40 #define PHASE_MSGOUT 0x80 #define PHASE_STATUSIN 0x100 #define PHASE_ETC (PHASE_DATAIN | PHASE_DATAOUT | PHASE_CMDOUT | PHASE_MSGIN | PHASE_MSGOUT | PHASE_STATUSIN) #define PRINT_COMMAND 0x200 #define PHASE_EXIT 0x400 #define PHASE_RESELECT 0x800 #define DEBUG_FAST 0x1000 #define DEBUG_SG 0x2000 #define DEBUG_LINKED 0x4000 #define DEBUG_BORKEN 0x8000 /* * Control options - these are timeouts specified in .01 seconds. */ /* 30, 20 work */ #define ST0X_BUS_FREE_DELAY 25 #define ST0X_SELECTION_DELAY 25 #define SEAGATE 1 /* these determine the type of the controller */ #define FD 2 #define ST0X_ID_STR "Seagate ST-01/ST-02" #define FD_ID_STR "TMC-8XX/TMC-950" static int internal_command (unsigned char target, unsigned char lun, const void *cmnd, void *buff, int bufflen, int reselect); static int incommand; /* set if arbitration has finished and we are in some command phase. */ static unsigned int base_address = 0; /* Where the card ROM starts, used to calculate memory mapped register location. */ static void __iomem *st0x_cr_sr; /* control register write, status register read. 256 bytes in length. Read is status of SCSI BUS, as per STAT masks. */ static void __iomem *st0x_dr; /* data register, read write 256 bytes in length. */ static volatile int st0x_aborted = 0; /* set when we are aborted, ie by a time out, etc. */ static unsigned char controller_type = 0; /* set to SEAGATE for ST0x boards or FD for TMC-8xx boards */ static int irq = IRQ; module_param(base_address, uint, 0); module_param(controller_type, byte, 0); module_param(irq, int, 0); MODULE_LICENSE("GPL"); #define retcode(result) (((result) << 16) | (message << 8) | status) #define STATUS ((u8) readb(st0x_cr_sr)) #define DATA ((u8) readb(st0x_dr)) #define WRITE_CONTROL(d) { writeb((d), st0x_cr_sr); } #define WRITE_DATA(d) { writeb((d), st0x_dr); } #ifndef OVERRIDE static unsigned int seagate_bases[] = { 0xc8000, 0xca000, 0xcc000, 0xce000, 0xdc000, 0xde000 }; typedef struct { const unsigned char *signature; unsigned offset; unsigned length; unsigned char type; } Signature; static Signature __initdata signatures[] = { {"ST01 v1.7 (C) Copyright 1987 Seagate", 15, 37, SEAGATE}, {"SCSI BIOS 2.00 (C) Copyright 1987 Seagate", 15, 40, SEAGATE}, /* * The following two lines are NOT mistakes. One detects ROM revision * 3.0.0, the other 3.2. Since seagate has only one type of SCSI adapter, * and this is not going to change, the "SEAGATE" and "SCSI" together * are probably "good enough" */ {"SEAGATE SCSI BIOS ", 16, 17, SEAGATE}, {"SEAGATE SCSI BIOS ", 17, 17, SEAGATE}, /* * However, future domain makes several incompatible SCSI boards, so specific * signatures must be used. */ {"FUTURE DOMAIN CORP. (C) 1986-1989 V5.0C2/14/89", 5, 46, FD}, {"FUTURE DOMAIN CORP. (C) 1986-1989 V6.0A7/28/89", 5, 46, FD}, {"FUTURE DOMAIN CORP. (C) 1986-1990 V6.0105/31/90", 5, 47, FD}, {"FUTURE DOMAIN CORP. (C) 1986-1990 V6.0209/18/90", 5, 47, FD}, {"FUTURE DOMAIN CORP. (C) 1986-1990 V7.009/18/90", 5, 46, FD}, {"FUTURE DOMAIN CORP. (C) 1992 V8.00.004/02/92", 5, 44, FD}, {"IBM F1 BIOS V1.1004/30/92", 5, 25, FD}, {"FUTURE DOMAIN TMC-950", 5, 21, FD}, /* Added for 2.2.16 by Matthias_Heidbrink@b.maus.de */ {"IBM F1 V1.2009/22/93", 5, 25, FD}, }; #define NUM_SIGNATURES ARRAY_SIZE(signatures) #endif /* n OVERRIDE */ /* * hostno stores the hostnumber, as told to us by the init routine. */ static int hostno = -1; static void seagate_reconnect_intr (int, void *); static irqreturn_t do_seagate_reconnect_intr (int, void *); static int seagate_st0x_bus_reset(struct scsi_cmnd *); #ifdef FAST static int fast = 1; #else #define fast 0 #endif #ifdef SLOW_RATE /* * Support for broken devices : * The Seagate board has a handshaking problem. Namely, a lack * thereof for slow devices. You can blast 600K/second through * it if you are polling for each byte, more if you do a blind * transfer. In the first case, with a fast device, REQ will * transition high-low or high-low-high before your loop restarts * and you'll have no problems. In the second case, the board * will insert wait states for up to 13.2 usecs for REQ to * transition low->high, and everything will work. * * However, there's nothing in the state machine that says * you *HAVE* to see a high-low-high set of transitions before * sending the next byte, and slow things like the Trantor CD ROMS * will break because of this. * * So, we need to slow things down, which isn't as simple as it * seems. We can't slow things down period, because then people * who don't recompile their kernels will shoot me for ruining * their performance. We need to do it on a case per case basis. * * The best for performance will be to, only for borken devices * (this is stored on a per-target basis in the scsi_devices array) * * Wait for a low->high transition before continuing with that * transfer. If we timeout, continue anyways. We don't need * a long timeout, because REQ should only be asserted until the * corresponding ACK is received and processed. * * Note that we can't use the system timer for this, because of * resolution, and we *really* can't use the timer chip since * gettimeofday() and the beeper routines use that. So, * the best thing for us to do will be to calibrate a timing * loop in the initialization code using the timer chip before * gettimeofday() can screw with it. * * FIXME: this is broken (not borken :-). Empty loop costs less than * loop with ISA access in it! -- pavel@ucw.cz */ static int borken_calibration = 0; static void __init borken_init (void) { register int count = 0, start = jiffies + 1, stop = start + 25; /* FIXME: There may be a better approach, this is a straight port for now */ preempt_disable(); while (time_before (jiffies, start)) cpu_relax(); for (; time_before (jiffies, stop); ++count) cpu_relax(); preempt_enable(); /* * Ok, we now have a count for .25 seconds. Convert to a * count per second and divide by transfer rate in K. */ borken_calibration = (count * 4) / (SLOW_RATE * 1024); if (borken_calibration < 1) borken_calibration = 1; } static inline void borken_wait (void) { register int count; for (count = borken_calibration; count && (STATUS & STAT_REQ); --count) cpu_relax(); #if (DEBUG & DEBUG_BORKEN) if (count) printk ("scsi%d : borken timeout\n", hostno); #endif } #endif /* def SLOW_RATE */ /* These beasts only live on ISA, and ISA means 8MHz. Each ULOOP() * contains at least one ISA access, which takes more than 0.125 * usec. So if we loop 8 times time in usec, we are safe. */ #define ULOOP( i ) for (clock = i*8;;) #define TIMEOUT (!(clock--)) static int __init seagate_st0x_detect (struct scsi_host_template * tpnt) { struct Scsi_Host *instance; int i, j; unsigned long cr, dr; tpnt->proc_name = "seagate"; /* * First, we try for the manual override. */ DANY ("Autodetecting ST0x / TMC-8xx\n"); if (hostno != -1) { printk (KERN_ERR "seagate_st0x_detect() called twice?!\n"); return 0; } /* If the user specified the controller type from the command line, controller_type will be non-zero, so don't try to detect one */ if (!controller_type) { #ifdef OVERRIDE base_address = OVERRIDE; controller_type = CONTROLLER; DANY ("Base address overridden to %x, controller type is %s\n", base_address, controller_type == SEAGATE ? "SEAGATE" : "FD"); #else /* OVERRIDE */ /* * To detect this card, we simply look for the signature * from the BIOS version notice in all the possible locations * of the ROM's. This has a nice side effect of not trashing * any register locations that might be used by something else. * * XXX - note that we probably should be probing the address * space for the on-board RAM instead. */ for (i = 0; i < ARRAY_SIZE(seagate_bases); ++i) { void __iomem *p = ioremap(seagate_bases[i], 0x2000); if (!p) continue; for (j = 0; j < NUM_SIGNATURES; ++j) if (check_signature(p + signatures[j].offset, signatures[j].signature, signatures[j].length)) { base_address = seagate_bases[i]; controller_type = signatures[j].type; break; } iounmap(p); } #endif /* OVERRIDE */ } /* (! controller_type) */ tpnt->this_id = (controller_type == SEAGATE) ? 7 : 6; tpnt->name = (controller_type == SEAGATE) ? ST0X_ID_STR : FD_ID_STR; if (!base_address) { printk(KERN_INFO "seagate: ST0x/TMC-8xx not detected.\n"); return 0; } cr = base_address + (controller_type == SEAGATE ? 0x1a00 : 0x1c00); dr = cr + 0x200; st0x_cr_sr = ioremap(cr, 0x100); st0x_dr = ioremap(dr, 0x100); DANY("%s detected. Base address = %x, cr = %x, dr = %x\n", tpnt->name, base_address, cr, dr); /* * At all times, we will use IRQ 5. Should also check for IRQ3 * if we lose our first interrupt. */ instance = scsi_register (tpnt, 0); if (instance == NULL) return 0; hostno = instance->host_no; if (request_irq (irq, do_seagate_reconnect_intr, IRQF_DISABLED, (controller_type == SEAGATE) ? "seagate" : "tmc-8xx", instance)) { printk(KERN_ERR "scsi%d : unable to allocate IRQ%d\n", hostno, irq); return 0; } instance->irq = irq; instance->io_port = base_address; #ifdef SLOW_RATE printk(KERN_INFO "Calibrating borken timer... "); borken_init(); printk(" %d cycles per transfer\n", borken_calibration); #endif printk (KERN_INFO "This is one second... "); { int clock; ULOOP (1 * 1000 * 1000) { STATUS; if (TIMEOUT) break; } } printk ("done, %s options:" #ifdef ARBITRATE " ARBITRATE" #endif #if DEBUG " DEBUG" #endif #ifdef FAST " FAST" #ifdef FAST32 "32" #endif #endif #ifdef LINKED " LINKED" #endif #ifdef PARITY " PARITY" #endif #ifdef SEAGATE_USE_ASM " SEAGATE_USE_ASM" #endif #ifdef SLOW_RATE " SLOW_RATE" #endif #ifdef SWAPSTAT " SWAPSTAT" #endif #ifdef SWAPCNTDATA " SWAPCNTDATA" #endif "\n", tpnt->name); return 1; } static const char *seagate_st0x_info (struct Scsi_Host *shpnt) { static char buffer[64]; snprintf(buffer, 64, "%s at irq %d, address 0x%05X", (controller_type == SEAGATE) ? ST0X_ID_STR : FD_ID_STR, irq, base_address); return buffer; } /* * These are our saved pointers for the outstanding command that is * waiting for a reconnect */ static unsigned char current_target, current_lun; static unsigned char *current_cmnd, *current_data; static int current_nobuffs; static struct scatterlist *current_buffer; static int current_bufflen; #ifdef LINKED /* * linked_connected indicates whether or not we are currently connected to * linked_target, linked_lun and in an INFORMATION TRANSFER phase, * using linked commands. */ static int linked_connected = 0; static unsigned char linked_target, linked_lun; #endif static void (*done_fn) (struct scsi_cmnd *) = NULL; static struct scsi_cmnd *SCint = NULL; /* * These control whether or not disconnect / reconnect will be attempted, * or are being attempted. */ #define NO_RECONNECT 0 #define RECONNECT_NOW 1 #define CAN_RECONNECT 2 /* * LINKED_RIGHT indicates that we are currently connected to the correct target * for this command, LINKED_WRONG indicates that we are connected to the wrong * target. Note that these imply CAN_RECONNECT and require defined(LINKED). */ #define LINKED_RIGHT 3 #define LINKED_WRONG 4 /* * This determines if we are expecting to reconnect or not. */ static int should_reconnect = 0; /* * The seagate_reconnect_intr routine is called when a target reselects the * host adapter. This occurs on the interrupt triggered by the target * asserting SEL. */ static irqreturn_t do_seagate_reconnect_intr(int irq, void *dev_id) { unsigned long flags; struct Scsi_Host *dev = dev_id; spin_lock_irqsave (dev->host_lock, flags); seagate_reconnect_intr (irq, dev_id); spin_unlock_irqrestore (dev->host_lock, flags); return IRQ_HANDLED; } static void seagate_reconnect_intr (int irq, void *dev_id) { int temp; struct scsi_cmnd *SCtmp; DPRINTK (PHASE_RESELECT, "scsi%d : seagate_reconnect_intr() called\n", hostno); if (!should_reconnect) printk(KERN_WARNING "scsi%d: unexpected interrupt.\n", hostno); else { should_reconnect = 0; DPRINTK (PHASE_RESELECT, "scsi%d : internal_command(%d, %08x, %08x, RECONNECT_NOW\n", hostno, current_target, current_data, current_bufflen); temp = internal_command (current_target, current_lun, current_cmnd, current_data, current_bufflen, RECONNECT_NOW); if (msg_byte(temp) != DISCONNECT) { if (done_fn) { DPRINTK(PHASE_RESELECT, "scsi%d : done_fn(%d,%08x)", hostno, hostno, temp); if (!SCint) panic ("SCint == NULL in seagate"); SCtmp = SCint; SCint = NULL; SCtmp->result = temp; done_fn(SCtmp); } else printk(KERN_ERR "done_fn() not defined.\n"); } } } /* * The seagate_st0x_queue_command() function provides a queued interface * to the seagate SCSI driver. Basically, it just passes control onto the * seagate_command() function, after fixing it so that the done_fn() * is set to the one passed to the function. We have to be very careful, * because there are some commands on some devices that do not disconnect, * and if we simply call the done_fn when the command is done then another * command is started and queue_command is called again... We end up * overflowing the kernel stack, and this tends not to be such a good idea. */ static int recursion_depth = 0; static int seagate_st0x_queue_command(struct scsi_cmnd * SCpnt, void (*done) (struct scsi_cmnd *)) { int result, reconnect; struct scsi_cmnd *SCtmp; DANY ("seagate: que_command"); done_fn = done; current_target = SCpnt->device->id; current_lun = SCpnt->device->lun; current_cmnd = SCpnt->cmnd; current_data = (unsigned char *) SCpnt->request_buffer; current_bufflen = SCpnt->request_bufflen; SCint = SCpnt; if (recursion_depth) return 1; recursion_depth++; do { #ifdef LINKED /* * Set linked command bit in control field of SCSI command. */ current_cmnd[SCpnt->cmd_len] |= 0x01; if (linked_connected) { DPRINTK (DEBUG_LINKED, "scsi%d : using linked commands, current I_T_L nexus is ", hostno); if (linked_target == current_target && linked_lun == current_lun) { DPRINTK(DEBUG_LINKED, "correct\n"); reconnect = LINKED_RIGHT; } else { DPRINTK(DEBUG_LINKED, "incorrect\n"); reconnect = LINKED_WRONG; } } else #endif /* LINKED */ reconnect = CAN_RECONNECT; result = internal_command(SCint->device->id, SCint->device->lun, SCint->cmnd, SCint->request_buffer, SCint->request_bufflen, reconnect); if (msg_byte(result) == DISCONNECT) break; SCtmp = SCint; SCint = NULL; SCtmp->result = result; done_fn(SCtmp); } while (SCint); recursion_depth--; return 0; } static int internal_command (unsigned char target, unsigned char lun, const void *cmnd, void *buff, int bufflen, int reselect) { unsigned char *data = NULL; struct scatterlist *buffer = NULL; int clock, temp, nobuffs = 0, done = 0, len = 0; #if DEBUG int transfered = 0, phase = 0, newphase; #endif register unsigned char status_read; unsigned char tmp_data, tmp_control, status = 0, message = 0; unsigned transfersize = 0, underflow = 0; #ifdef SLOW_RATE int borken = (int) SCint->device->borken; /* Does the current target require Very Slow I/O ? */ #endif incommand = 0; st0x_aborted = 0; #if (DEBUG & PRINT_COMMAND) printk("scsi%d : target = %d, command = ", hostno, target); __scsi_print_command((unsigned char *) cmnd); #endif #if (DEBUG & PHASE_RESELECT) switch (reselect) { case RECONNECT_NOW: printk("scsi%d : reconnecting\n", hostno); break; #ifdef LINKED case LINKED_RIGHT: printk("scsi%d : connected, can reconnect\n", hostno); break; case LINKED_WRONG: printk("scsi%d : connected to wrong target, can reconnect\n", hostno); break; #endif case CAN_RECONNECT: printk("scsi%d : allowed to reconnect\n", hostno); break; default: printk("scsi%d : not allowed to reconnect\n", hostno); } #endif if (target == (controller_type == SEAGATE ? 7 : 6)) return DID_BAD_TARGET; /* * We work it differently depending on if this is is "the first time," * or a reconnect. If this is a reselect phase, then SEL will * be asserted, and we must skip selection / arbitration phases. */ switch (reselect) { case RECONNECT_NOW: DPRINTK (PHASE_RESELECT, "scsi%d : phase RESELECT \n", hostno); /* * At this point, we should find the logical or of our ID * and the original target's ID on the BUS, with BSY, SEL, * and I/O signals asserted. * * After ARBITRATION phase is completed, only SEL, BSY, * and the target ID are asserted. A valid initiator ID * is not on the bus until IO is asserted, so we must wait * for that. */ ULOOP (100 * 1000) { temp = STATUS; if ((temp & STAT_IO) && !(temp & STAT_BSY)) break; if (TIMEOUT) { DPRINTK (PHASE_RESELECT, "scsi%d : RESELECT timed out while waiting for IO .\n", hostno); return (DID_BAD_INTR << 16); } } /* * After I/O is asserted by the target, we can read our ID * and its ID off of the BUS. */ if (!((temp = DATA) & (controller_type == SEAGATE ? 0x80 : 0x40))) { DPRINTK (PHASE_RESELECT, "scsi%d : detected reconnect request to different target.\n\tData bus = %d\n", hostno, temp); return (DID_BAD_INTR << 16); } if (!(temp & (1 << current_target))) { printk(KERN_WARNING "scsi%d : Unexpected reselect interrupt. Data bus = %d\n", hostno, temp); return (DID_BAD_INTR << 16); } buffer = current_buffer; cmnd = current_cmnd; /* WDE add */ data = current_data; /* WDE add */ len = current_bufflen; /* WDE add */ nobuffs = current_nobuffs; /* * We have determined that we have been selected. At this * point, we must respond to the reselection by asserting * BSY ourselves */ #if 1 WRITE_CONTROL (BASE_CMD | CMD_DRVR_ENABLE | CMD_BSY); #else WRITE_CONTROL (BASE_CMD | CMD_BSY); #endif /* * The target will drop SEL, and raise BSY, at which time * we must drop BSY. */ ULOOP (100 * 1000) { if (!(STATUS & STAT_SEL)) break; if (TIMEOUT) { WRITE_CONTROL (BASE_CMD | CMD_INTR); DPRINTK (PHASE_RESELECT, "scsi%d : RESELECT timed out while waiting for SEL.\n", hostno); return (DID_BAD_INTR << 16); } } WRITE_CONTROL (BASE_CMD); /* * At this point, we have connected with the target * and can get on with our lives. */ break; case CAN_RECONNECT: #ifdef LINKED /* * This is a bletcherous hack, just as bad as the Unix #! * interpreter stuff. If it turns out we are using the wrong * I_T_L nexus, the easiest way to deal with it is to go into * our INFORMATION TRANSFER PHASE code, send a ABORT * message on MESSAGE OUT phase, and then loop back to here. */ connect_loop: #endif DPRINTK (PHASE_BUS_FREE, "scsi%d : phase = BUS FREE \n", hostno); /* * BUS FREE PHASE * * On entry, we make sure that the BUS is in a BUS FREE * phase, by insuring that both BSY and SEL are low for * at least one bus settle delay. Several reads help * eliminate wire glitch. */ #ifndef ARBITRATE #error FIXME: this is broken: we may not use jiffies here - we are under cli(). It will hardlock. clock = jiffies + ST0X_BUS_FREE_DELAY; while (((STATUS | STATUS | STATUS) & (STAT_BSY | STAT_SEL)) && (!st0x_aborted) && time_before (jiffies, clock)) cpu_relax(); if (time_after (jiffies, clock)) return retcode (DID_BUS_BUSY); else if (st0x_aborted) return retcode (st0x_aborted); #endif DPRINTK (PHASE_SELECTION, "scsi%d : phase = SELECTION\n", hostno); clock = jiffies + ST0X_SELECTION_DELAY; /* * Arbitration/selection procedure : * 1. Disable drivers * 2. Write HOST adapter address bit * 3. Set start arbitration. * 4. We get either ARBITRATION COMPLETE or SELECT at this * point. * 5. OR our ID and targets on bus. * 6. Enable SCSI drivers and asserted SEL and ATTN */ #ifdef ARBITRATE /* FIXME: verify host lock is always held here */ WRITE_CONTROL(0); WRITE_DATA((controller_type == SEAGATE) ? 0x80 : 0x40); WRITE_CONTROL(CMD_START_ARB); ULOOP (ST0X_SELECTION_DELAY * 10000) { status_read = STATUS; if (status_read & STAT_ARB_CMPL) break; if (st0x_aborted) /* FIXME: What? We are going to do something even after abort? */ break; if (TIMEOUT || (status_read & STAT_SEL)) { printk(KERN_WARNING "scsi%d : arbitration lost or timeout.\n", hostno); WRITE_CONTROL (BASE_CMD); return retcode (DID_NO_CONNECT); } } DPRINTK (PHASE_SELECTION, "scsi%d : arbitration complete\n", hostno); #endif /* * When the SCSI device decides that we're gawking at it, * it will respond by asserting BUSY on the bus. * * Note : the Seagate ST-01/02 product manual says that we * should twiddle the DATA register before the control * register. However, this does not work reliably so we do * it the other way around. * * Probably could be a problem with arbitration too, we * really should try this with a SCSI protocol or logic * analyzer to see what is going on. */ tmp_data = (unsigned char) ((1 << target) | (controller_type == SEAGATE ? 0x80 : 0x40)); tmp_control = BASE_CMD | CMD_DRVR_ENABLE | CMD_SEL | (reselect ? CMD_ATTN : 0); /* FIXME: verify host lock is always held here */ #ifdef OLDCNTDATASCEME #ifdef SWAPCNTDATA WRITE_CONTROL (tmp_control); WRITE_DATA (tmp_data); #else WRITE_DATA (tmp_data); WRITE_CONTROL (tmp_control); #endif #else tmp_control ^= CMD_BSY; /* This is guesswork. What used to be in driver */ WRITE_CONTROL (tmp_control); /* could never work: it sent data into control */ WRITE_DATA (tmp_data); /* register and control info into data. Hopefully */ tmp_control ^= CMD_BSY; /* fixed, but order of first two may be wrong. */ WRITE_CONTROL (tmp_control); /* -- pavel@ucw.cz */ #endif ULOOP (250 * 1000) { if (st0x_aborted) { /* * If we have been aborted, and we have a * command in progress, IE the target * still has BSY asserted, then we will * reset the bus, and notify the midlevel * driver to expect sense. */ WRITE_CONTROL (BASE_CMD); if (STATUS & STAT_BSY) { printk(KERN_WARNING "scsi%d : BST asserted after we've been aborted.\n", hostno); seagate_st0x_bus_reset(NULL); return retcode (DID_RESET); } return retcode (st0x_aborted); } if (STATUS & STAT_BSY) break; if (TIMEOUT) { DPRINTK (PHASE_SELECTION, "scsi%d : NO CONNECT with target %d, stat = %x \n", hostno, target, STATUS); return retcode (DID_NO_CONNECT); } } /* Establish current pointers. Take into account scatter / gather */ if ((nobuffs = SCint->use_sg)) { #if (DEBUG & DEBUG_SG) { int i; printk("scsi%d : scatter gather requested, using %d buffers.\n", hostno, nobuffs); for (i = 0; i < nobuffs; ++i) printk("scsi%d : buffer %d address = %p length = %d\n", hostno, i, sg_virt(&buffer[i]), buffer[i].length); } #endif buffer = (struct scatterlist *) SCint->request_buffer; len = buffer->length; data = sg_virt(buffer); } else { DPRINTK (DEBUG_SG, "scsi%d : scatter gather not requested.\n", hostno); buffer = NULL; len = SCint->request_bufflen; data = (unsigned char *) SCint->request_buffer; } DPRINTK (PHASE_DATAIN | PHASE_DATAOUT, "scsi%d : len = %d\n", hostno, len); break; #ifdef LINKED case LINKED_RIGHT: break; case LINKED_WRONG: break; #endif } /* end of switch(reselect) */ /* * There are several conditions under which we wish to send a message : * 1. When we are allowing disconnect / reconnect, and need to * establish the I_T_L nexus via an IDENTIFY with the DiscPriv bit * set. * * 2. When we are doing linked commands, are have the wrong I_T_L * nexus established and want to send an ABORT message. */ /* GCC does not like an ifdef inside a macro, so do it the hard way. */ #ifdef LINKED WRITE_CONTROL (BASE_CMD | CMD_DRVR_ENABLE | (((reselect == CAN_RECONNECT)|| (reselect == LINKED_WRONG))? CMD_ATTN : 0)); #else WRITE_CONTROL (BASE_CMD | CMD_DRVR_ENABLE | (((reselect == CAN_RECONNECT))? CMD_ATTN : 0)); #endif /* * INFORMATION TRANSFER PHASE * * The nasty looking read / write inline assembler loops we use for * DATAIN and DATAOUT phases are approximately 4-5 times as fast as * the 'C' versions - since we're moving 1024 bytes of data, this * really adds up. * * SJT: The nasty-looking assembler is gone, so it's slower. * */ DPRINTK (PHASE_ETC, "scsi%d : phase = INFORMATION TRANSFER\n", hostno); incommand = 1; transfersize = SCint->transfersize; underflow = SCint->underflow; /* * Now, we poll the device for status information, * and handle any requests it makes. Note that since we are unsure * of how much data will be flowing across the system, etc and * cannot make reasonable timeouts, that we will instead have the * midlevel driver handle any timeouts that occur in this phase. */ while (((status_read = STATUS) & STAT_BSY) && !st0x_aborted && !done) { #ifdef PARITY if (status_read & STAT_PARITY) { printk(KERN_ERR "scsi%d : got parity error\n", hostno); st0x_aborted = DID_PARITY; } #endif if (status_read & STAT_REQ) { #if ((DEBUG & PHASE_ETC) == PHASE_ETC) if ((newphase = (status_read & REQ_MASK)) != phase) { phase = newphase; switch (phase) { case REQ_DATAOUT: printk ("scsi%d : phase = DATA OUT\n", hostno); break; case REQ_DATAIN: printk ("scsi%d : phase = DATA IN\n", hostno); break; case REQ_CMDOUT: printk ("scsi%d : phase = COMMAND OUT\n", hostno); break; case REQ_STATIN: printk ("scsi%d : phase = STATUS IN\n", hostno); break; case REQ_MSGOUT: printk ("scsi%d : phase = MESSAGE OUT\n", hostno); break; case REQ_MSGIN: printk ("scsi%d : phase = MESSAGE IN\n", hostno); break; default: printk ("scsi%d : phase = UNKNOWN\n", hostno); st0x_aborted = DID_ERROR; } } #endif switch (status_read & REQ_MASK) { case REQ_DATAOUT: /* * If we are in fast mode, then we simply splat * the data out in word-sized chunks as fast as * we can. */ if (!len) { #if 0 printk("scsi%d: underflow to target %d lun %d \n", hostno, target, lun); st0x_aborted = DID_ERROR; fast = 0; #endif break; } if (fast && transfersize && !(len % transfersize) && (len >= transfersize) #ifdef FAST32 && !(transfersize % 4) #endif ) { DPRINTK (DEBUG_FAST, "scsi%d : FAST transfer, underflow = %d, transfersize = %d\n" " len = %d, data = %08x\n", hostno, SCint->underflow, SCint->transfersize, len, data); /* SJT: Start. Fast Write */ #ifdef SEAGATE_USE_ASM __asm__ ("cld\n\t" #ifdef FAST32 "shr $2, %%ecx\n\t" "1:\t" "lodsl\n\t" "movl %%eax, (%%edi)\n\t" #else "1:\t" "lodsb\n\t" "movb %%al, (%%edi)\n\t" #endif "loop 1b;" /* output */ : /* input */ :"D" (st0x_dr), "S" (data), "c" (SCint->transfersize) /* clobbered */ : "eax", "ecx", "esi"); #else /* SEAGATE_USE_ASM */ memcpy_toio(st0x_dr, data, transfersize); #endif /* SEAGATE_USE_ASM */ /* SJT: End */ len -= transfersize; data += transfersize; DPRINTK (DEBUG_FAST, "scsi%d : FAST transfer complete len = %d data = %08x\n", hostno, len, data); } else { /* * We loop as long as we are in a * data out phase, there is data to * send, and BSY is still active. */ /* SJT: Start. Slow Write. */ #ifdef SEAGATE_USE_ASM int __dummy_1, __dummy_2; /* * We loop as long as we are in a data out phase, there is data to send, * and BSY is still active. */ /* Local variables : len = ecx , data = esi, st0x_cr_sr = ebx, st0x_dr = edi */ __asm__ ( /* Test for any data here at all. */ "orl %%ecx, %%ecx\n\t" "jz 2f\n\t" "cld\n\t" /* "movl st0x_cr_sr, %%ebx\n\t" */ /* "movl st0x_dr, %%edi\n\t" */ "1:\t" "movb (%%ebx), %%al\n\t" /* Test for BSY */ "test $1, %%al\n\t" "jz 2f\n\t" /* Test for data out phase - STATUS & REQ_MASK should be REQ_DATAOUT, which is 0. */ "test $0xe, %%al\n\t" "jnz 2f\n\t" /* Test for REQ */ "test $0x10, %%al\n\t" "jz 1b\n\t" "lodsb\n\t" "movb %%al, (%%edi)\n\t" "loop 1b\n\t" "2:\n" /* output */ :"=S" (data), "=c" (len), "=b" (__dummy_1), "=D" (__dummy_2) /* input */ : "0" (data), "1" (len), "2" (st0x_cr_sr), "3" (st0x_dr) /* clobbered */ : "eax"); #else /* SEAGATE_USE_ASM */ while (len) { unsigned char stat; stat = STATUS; if (!(stat & STAT_BSY) || ((stat & REQ_MASK) != REQ_DATAOUT)) break; if (stat & STAT_REQ) { WRITE_DATA (*data++); --len; } } #endif /* SEAGATE_USE_ASM */ /* SJT: End. */ } if (!len && nobuffs) { --nobuffs; ++buffer; len = buffer->length; data = sg_virt(buffer); DPRINTK (DEBUG_SG, "scsi%d : next scatter-gather buffer len = %d address = %08x\n", hostno, len, data); } break; case REQ_DATAIN: #ifdef SLOW_RATE if (borken) { #if (DEBUG & (PHASE_DATAIN)) transfered += len; #endif for (; len && (STATUS & (REQ_MASK | STAT_REQ)) == (REQ_DATAIN | STAT_REQ); --len) { *data++ = DATA; borken_wait(); } #if (DEBUG & (PHASE_DATAIN)) transfered -= len; #endif } else #endif if (fast && transfersize && !(len % transfersize) && (len >= transfersize) #ifdef FAST32 && !(transfersize % 4) #endif ) { DPRINTK (DEBUG_FAST, "scsi%d : FAST transfer, underflow = %d, transfersize = %d\n" " len = %d, data = %08x\n", hostno, SCint->underflow, SCint->transfersize, len, data); /* SJT: Start. Fast Read */ #ifdef SEAGATE_USE_ASM __asm__ ("cld\n\t" #ifdef FAST32 "shr $2, %%ecx\n\t" "1:\t" "movl (%%esi), %%eax\n\t" "stosl\n\t" #else "1:\t" "movb (%%esi), %%al\n\t" "stosb\n\t" #endif "loop 1b\n\t" /* output */ : /* input */ :"S" (st0x_dr), "D" (data), "c" (SCint->transfersize) /* clobbered */ : "eax", "ecx", "edi"); #else /* SEAGATE_USE_ASM */ memcpy_fromio(data, st0x_dr, len); #endif /* SEAGATE_USE_ASM */ /* SJT: End */ len -= transfersize; data += transfersize; #if (DEBUG & PHASE_DATAIN) printk ("scsi%d: transfered += %d\n", hostno, transfersize); transfered += transfersize; #endif DPRINTK (DEBUG_FAST, "scsi%d : FAST transfer complete len = %d data = %08x\n", hostno, len, data); } else { #if (DEBUG & PHASE_DATAIN) printk ("scsi%d: transfered += %d\n", hostno, len); transfered += len; /* Assume we'll transfer it all, then subtract what we *didn't* transfer */ #endif /* * We loop as long as we are in a data in phase, there is room to read, * and BSY is still active */ /* SJT: Start. */ #ifdef SEAGATE_USE_ASM int __dummy_3, __dummy_4; /* Dummy clobbering variables for the new gcc-2.95 */ /* * We loop as long as we are in a data in phase, there is room to read, * and BSY is still active */ /* Local variables : ecx = len, edi = data esi = st0x_cr_sr, ebx = st0x_dr */ __asm__ ( /* Test for room to read */ "orl %%ecx, %%ecx\n\t" "jz 2f\n\t" "cld\n\t" /* "movl st0x_cr_sr, %%esi\n\t" */ /* "movl st0x_dr, %%ebx\n\t" */ "1:\t" "movb (%%esi), %%al\n\t" /* Test for BSY */ "test $1, %%al\n\t" "jz 2f\n\t" /* Test for data in phase - STATUS & REQ_MASK should be REQ_DATAIN, = STAT_IO, which is 4. */ "movb $0xe, %%ah\n\t" "andb %%al, %%ah\n\t" "cmpb $0x04, %%ah\n\t" "jne 2f\n\t" /* Test for REQ */ "test $0x10, %%al\n\t" "jz 1b\n\t" "movb (%%ebx), %%al\n\t" "stosb\n\t" "loop 1b\n\t" "2:\n" /* output */ :"=D" (data), "=c" (len), "=S" (__dummy_3), "=b" (__dummy_4) /* input */ : "0" (data), "1" (len), "2" (st0x_cr_sr), "3" (st0x_dr) /* clobbered */ : "eax"); #else /* SEAGATE_USE_ASM */ while (len) { unsigned char stat; stat = STATUS; if (!(stat & STAT_BSY) || ((stat & REQ_MASK) != REQ_DATAIN)) break; if (stat & STAT_REQ) { *data++ = DATA; --len; } } #endif /* SEAGATE_USE_ASM */ /* SJT: End. */ #if (DEBUG & PHASE_DATAIN) printk ("scsi%d: transfered -= %d\n", hostno, len); transfered -= len; /* Since we assumed all of Len got * transfered, correct our mistake */ #endif } if (!len && nobuffs) { --nobuffs; ++buffer; len = buffer->length; data = sg_virt(buffer); DPRINTK (DEBUG_SG, "scsi%d : next scatter-gather buffer len = %d address = %08x\n", hostno, len, data); } break; case REQ_CMDOUT: while (((status_read = STATUS) & STAT_BSY) && ((status_read & REQ_MASK) == REQ_CMDOUT)) if (status_read & STAT_REQ) { WRITE_DATA (*(const unsigned char *) cmnd); cmnd = 1 + (const unsigned char *)cmnd; #ifdef SLOW_RATE if (borken) borken_wait (); #endif } break; case REQ_STATIN: status = DATA; break; case REQ_MSGOUT: /* * We can only have sent a MSG OUT if we * requested to do this by raising ATTN. * So, we must drop ATTN. */ WRITE_CONTROL (BASE_CMD | CMD_DRVR_ENABLE); /* * If we are reconnecting, then we must * send an IDENTIFY message in response * to MSGOUT. */ switch (reselect) { case CAN_RECONNECT: WRITE_DATA (IDENTIFY (1, lun)); DPRINTK (PHASE_RESELECT | PHASE_MSGOUT, "scsi%d : sent IDENTIFY message.\n", hostno); break; #ifdef LINKED case LINKED_WRONG: WRITE_DATA (ABORT); linked_connected = 0; reselect = CAN_RECONNECT; goto connect_loop; DPRINTK (PHASE_MSGOUT | DEBUG_LINKED, "scsi%d : sent ABORT message to cancel incorrect I_T_L nexus.\n", hostno); #endif /* LINKED */ DPRINTK (DEBUG_LINKED, "correct\n"); default: WRITE_DATA (NOP); printk("scsi%d : target %d requested MSGOUT, sent NOP message.\n", hostno, target); } break; case REQ_MSGIN: switch (message = DATA) { case DISCONNECT: DANY("seagate: deciding to disconnect\n"); should_reconnect = 1; current_data = data; /* WDE add */ current_buffer = buffer; current_bufflen = len; /* WDE add */ current_nobuffs = nobuffs; #ifdef LINKED linked_connected = 0; #endif done = 1; DPRINTK ((PHASE_RESELECT | PHASE_MSGIN), "scsi%d : disconnected.\n", hostno); break; #ifdef LINKED case LINKED_CMD_COMPLETE: case LINKED_FLG_CMD_COMPLETE: #endif case COMMAND_COMPLETE: /* * Note : we should check for underflow here. */ DPRINTK(PHASE_MSGIN, "scsi%d : command complete.\n", hostno); done = 1; break; case ABORT: DPRINTK(PHASE_MSGIN, "scsi%d : abort message.\n", hostno); done = 1; break; case SAVE_POINTERS: current_buffer = buffer; current_bufflen = len; /* WDE add */ current_data = data; /* WDE mod */ current_nobuffs = nobuffs; DPRINTK (PHASE_MSGIN, "scsi%d : pointers saved.\n", hostno); break; case RESTORE_POINTERS: buffer = current_buffer; cmnd = current_cmnd; data = current_data; /* WDE mod */ len = current_bufflen; nobuffs = current_nobuffs; DPRINTK(PHASE_MSGIN, "scsi%d : pointers restored.\n", hostno); break; default: /* * IDENTIFY distinguishes itself * from the other messages by * setting the high bit. * * Note : we need to handle at * least one outstanding command * per LUN, and need to hash the * SCSI command for that I_T_L * nexus based on the known ID * (at this point) and LUN. */ if (message & 0x80) { DPRINTK (PHASE_MSGIN, "scsi%d : IDENTIFY message received from id %d, lun %d.\n", hostno, target, message & 7); } else { /* * We should go into a * MESSAGE OUT phase, and * send a MESSAGE_REJECT * if we run into a message * that we don't like. The * seagate driver needs * some serious * restructuring first * though. */ DPRINTK (PHASE_MSGIN, "scsi%d : unknown message %d from target %d.\n", hostno, message, target); } } break; default: printk(KERN_ERR "scsi%d : unknown phase.\n", hostno); st0x_aborted = DID_ERROR; } /* end of switch (status_read & REQ_MASK) */ #ifdef SLOW_RATE /* * I really don't care to deal with borken devices in * each single byte transfer case (ie, message in, * message out, status), so I'll do the wait here if * necessary. */ if(borken) borken_wait(); #endif } /* if(status_read & STAT_REQ) ends */ } /* while(((status_read = STATUS)...) ends */ DPRINTK(PHASE_DATAIN | PHASE_DATAOUT | PHASE_EXIT, "scsi%d : Transfered %d bytes\n", hostno, transfered); #if (DEBUG & PHASE_EXIT) #if 0 /* Doesn't work for scatter/gather */ printk("Buffer : \n"); for(i = 0; i < 20; ++i) printk("%02x ", ((unsigned char *) data)[i]); /* WDE mod */ printk("\n"); #endif printk("scsi%d : status = ", hostno); scsi_print_status(status); printk(" message = %02x\n", message); #endif /* We shouldn't reach this until *after* BSY has been deasserted */ #ifdef LINKED else { /* * Fix the message byte so that unsuspecting high level drivers * don't puke when they see a LINKED COMMAND message in place of * the COMMAND COMPLETE they may be expecting. Shouldn't be * necessary, but it's better to be on the safe side. * * A non LINKED* message byte will indicate that the command * completed, and we are now disconnected. */ switch (message) { case LINKED_CMD_COMPLETE: case LINKED_FLG_CMD_COMPLETE: message = COMMAND_COMPLETE; linked_target = current_target; linked_lun = current_lun; linked_connected = 1; DPRINTK (DEBUG_LINKED, "scsi%d : keeping I_T_L nexus established for linked command.\n", hostno); /* We also will need to adjust status to accommodate intermediate conditions. */ if ((status == INTERMEDIATE_GOOD) || (status == INTERMEDIATE_C_GOOD)) status = GOOD; break; /* * We should also handle what are "normal" termination * messages here (ABORT, BUS_DEVICE_RESET?, and * COMMAND_COMPLETE individually, and flake if things * aren't right. */ default: DPRINTK (DEBUG_LINKED, "scsi%d : closing I_T_L nexus.\n", hostno); linked_connected = 0; } } #endif /* LINKED */ if (should_reconnect) { DPRINTK (PHASE_RESELECT, "scsi%d : exiting seagate_st0x_queue_command() with reconnect enabled.\n", hostno); WRITE_CONTROL (BASE_CMD | CMD_INTR); } else WRITE_CONTROL (BASE_CMD); return retcode (st0x_aborted); } /* end of internal_command */ static int seagate_st0x_abort(struct scsi_cmnd * SCpnt) { st0x_aborted = DID_ABORT; return SUCCESS; } #undef ULOOP #undef TIMEOUT /* * the seagate_st0x_reset function resets the SCSI bus * * May be called with SCpnt = NULL */ static int seagate_st0x_bus_reset(struct scsi_cmnd * SCpnt) { /* No timeouts - this command is going to fail because it was reset. */ DANY ("scsi%d: Reseting bus... ", hostno); /* assert RESET signal on SCSI bus. */ WRITE_CONTROL (BASE_CMD | CMD_RST); mdelay (20); WRITE_CONTROL (BASE_CMD); st0x_aborted = DID_RESET; DANY ("done.\n"); return SUCCESS; } static int seagate_st0x_release(struct Scsi_Host *shost) { if (shost->irq) free_irq(shost->irq, shost); release_region(shost->io_port, shost->n_io_port); return 0; } static struct scsi_host_template driver_template = { .detect = seagate_st0x_detect, .release = seagate_st0x_release, .info = seagate_st0x_info, .queuecommand = seagate_st0x_queue_command, .eh_abort_handler = seagate_st0x_abort, .eh_bus_reset_handler = seagate_st0x_bus_reset, .can_queue = 1, .this_id = 7, .sg_tablesize = SG_ALL, .cmd_per_lun = 1, .use_clustering = DISABLE_CLUSTERING, }; #include "scsi_module.c"