| /* |
| * 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" |
| * |
| * This card does all the I/O via memory mapped I/O, so there is no need |
| * to check or snarf a region of the I/O address space. |
| */ |
| |
| /* |
| * Configuration : |
| * To use without BIOS -DOVERRIDE=base_address -DCONTROLLER=FD or SEAGATE |
| * -DIRQ will overide 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. |
| * |
| * -DFAST or -DFAST32 will use blind transfers where possible |
| * |
| * -DARBITRATE will cause the host adapter to arbitrate for the |
| * bus for better SCSI-II compatability, 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. |
| * |
| * -DSLOW_HANDSHAKE will allow compatability with broken devices that don't |
| * handshake fast enough (ie, some CD ROM's) for the Seagate |
| * code. |
| * |
| * -DSLOW_RATE=x, x some number will let you specify a default |
| * transfer rate if handshaking isn't working correctly. |
| */ |
| |
| #include <linux/config.h> |
| |
| #if defined(CONFIG_SCSI_SEAGATE) || defined(CONFIG_SCSI_FD_8xx) |
| #include <asm/io.h> |
| #include <asm/system.h> |
| #include <linux/signal.h> |
| #include <linux/sched.h> |
| #include <linux/string.h> |
| #include "../block/blk.h" |
| #include "scsi.h" |
| #include "hosts.h" |
| #include "seagate.h" |
| #include "constants.h" |
| |
| |
| #ifndef IRQ |
| #define IRQ 5 |
| #endif |
| |
| #if (defined(FAST32) && !defined(FAST)) |
| #define FAST |
| #endif |
| |
| #if defined(SLOW_RATE) && !defined(SLOW_HANDSHAKE) |
| #define SLOW_HANDSHAKE |
| #endif |
| |
| #if defined(SLOW_HANDSHAKE) && !defined(SLOW_RATE) |
| #define SLOW_RATE 50 |
| #endif |
| |
| |
| #if defined(LINKED) |
| #undef LINKED /* Linked commands are currently broken ! */ |
| #endif |
| |
| 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 void *base_address = NULL; /* |
| Where the card ROM starts, |
| used to calculate memory mapped |
| register location. |
| */ |
| static volatile int abort_confirm = 0; |
| |
| static volatile void *st0x_cr_sr; /* |
| control register write, |
| status register read. |
| 256 bytes in length. |
| |
| Read is status of SCSI BUS, |
| as per STAT masks. |
| |
| */ |
| |
| |
| static volatile void *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 unsigned char irq = IRQ; |
| |
| #define retcode(result) (((result) << 16) | (message << 8) | status) |
| #define STATUS (*(volatile unsigned char *) st0x_cr_sr) |
| #define CONTROL STATUS |
| #define DATA (*(volatile unsigned char *) st0x_dr) |
| |
| void st0x_setup (char *str, int *ints) { |
| controller_type = SEAGATE; |
| base_address = (void *) ints[1]; |
| irq = ints[2]; |
| } |
| |
| void tmc8xx_setup (char *str, int *ints) { |
| controller_type = FD; |
| base_address = (void *) ints[1]; |
| irq = ints[2]; |
| } |
| |
| |
| #ifndef OVERRIDE |
| static const char * seagate_bases[] = { |
| (char *) 0xc8000, (char *) 0xca000, (char *) 0xcc000, |
| (char *) 0xce000, (char *) 0xdc000, (char *) 0xde000 |
| }; |
| |
| typedef struct { |
| char *signature ; |
| unsigned offset; |
| unsigned length; |
| unsigned char type; |
| } Signature; |
| |
| static const Signature signatures[] = { |
| #ifdef CONFIG_SCSI_SEAGATE |
| {"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 incompatable 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}, |
| {"FUTURE DOMAIN TMC-950", 5, 21, FD}, |
| #endif /* CONFIG_SCSI_SEAGATE */ |
| } |
| ; |
| |
| #define NUM_SIGNATURES (sizeof(signatures) / sizeof(Signature)) |
| #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); |
| |
| #ifdef FAST |
| static int fast = 1; |
| #endif |
| |
| #ifdef SLOW_HANDSHAKE |
| /* |
| * 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 recieved 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. |
| */ |
| |
| static int borken_calibration = 0; |
| static void borken_init (void) { |
| register int count = 0, start = jiffies + 1, stop = start + 25; |
| |
| while (jiffies < start); |
| for (;jiffies < stop; ++count); |
| |
| /* |
| * Ok, we now have a count for .25 seconds. Convert to a |
| * count per second and divide by transer rate in K. |
| */ |
| |
| borken_calibration = (count * 4) / (SLOW_RATE*1024); |
| |
| if (borken_calibration < 1) |
| borken_calibration = 1; |
| #if (DEBUG & DEBUG_BORKEN) |
| printk("scsi%d : borken calibrated to %dK/sec, %d cycles per transfer\n", |
| hostno, BORKEN_RATE, borken_calibration); |
| #endif |
| } |
| |
| static inline void borken_wait(void) { |
| register int count; |
| for (count = borken_calibration; count && (STATUS & STAT_REQ); |
| --count); |
| if (count) |
| #if (DEBUG & DEBUG_BORKEN) |
| printk("scsi%d : borken timeout\n", hostno); |
| #else |
| ; |
| #endif |
| } |
| |
| #endif /* def SLOW_HANDSHAKE */ |
| |
| int seagate_st0x_detect (int hostnum) |
| { |
| #ifndef OVERRIDE |
| int i,j; |
| #endif |
| static struct sigaction seagate_sigaction = { |
| &seagate_reconnect_intr, |
| 0, |
| SA_INTERRUPT, |
| NULL |
| }; |
| |
| /* |
| * First, we try for the manual override. |
| */ |
| #ifdef DEBUG |
| printk("Autodetecting seagate ST0x\n"); |
| #endif |
| |
| if (hostno != -1) |
| { |
| printk ("ERROR : 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 and detect one */ |
| |
| if (!controller_type) { |
| #ifdef OVERRIDE |
| base_address = (void *) OVERRIDE; |
| |
| /* CONTROLLER is used to override controller (SEAGATE or FD). PM: 07/01/93 */ |
| #ifdef CONTROLLER |
| controller_type = CONTROLLER; |
| #else |
| #error Please use -DCONTROLLER=SEAGATE or -DCONTROLLER=FD to override controller type |
| #endif /* CONTROLLER */ |
| #ifdef DEBUG |
| printk("Base address overridden to %x, controller type is %s\n", |
| base_address,controller_type == SEAGATE ? "SEAGATE" : "FD"); |
| #endif |
| #else /* OVERIDE */ |
| /* |
| * 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 sideeffect 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 < (sizeof (seagate_bases) / sizeof (char * )); ++i) |
| for (j = 0; !base_address && j < NUM_SIGNATURES; ++j) |
| if (!memcmp ((void *) (seagate_bases[i] + |
| signatures[j].offset), (void *) signatures[j].signature, |
| signatures[j].length)) { |
| base_address = (void *) seagate_bases[i]; |
| controller_type = signatures[j].type; |
| } |
| #endif /* OVERIDE */ |
| } /* (! controller_type) */ |
| |
| scsi_hosts[hostnum].this_id = (controller_type == SEAGATE) ? 7 : 6; |
| |
| if (base_address) |
| { |
| st0x_cr_sr =(void *) (((unsigned char *) base_address) + (controller_type == SEAGATE ? 0x1a00 : 0x1c00)); |
| st0x_dr = (void *) (((unsigned char *) base_address ) + (controller_type == SEAGATE ? 0x1c00 : 0x1e00)); |
| #ifdef DEBUG |
| printk("ST0x detected. Base address = %x, cr = %x, dr = %x\n", base_address, st0x_cr_sr, st0x_dr); |
| #endif |
| /* |
| * At all times, we will use IRQ 5. Should also check for IRQ3 if we |
| * loose our first interrupt. |
| */ |
| hostno = hostnum; |
| if (irqaction((int) irq, &seagate_sigaction)) { |
| printk("scsi%d : unable to allocate IRQ%d\n", |
| hostno, (int) irq); |
| return 0; |
| } |
| #ifdef SLOW_HANDSHAKE |
| borken_init(); |
| #endif |
| |
| return 1; |
| } |
| else |
| { |
| #ifdef DEBUG |
| printk("ST0x not detected.\n"); |
| #endif |
| return 0; |
| } |
| } |
| |
| const char *seagate_st0x_info(void) { |
| static char buffer[256]; |
| sprintf(buffer, "scsi%d : %s at irq %d address %p options :" |
| #ifdef ARBITRATE |
| " ARBITRATE" |
| #endif |
| #ifdef SLOW_HANDSHAKE |
| " SLOW_HANDSHAKE" |
| #endif |
| #ifdef FAST |
| #ifdef FAST32 |
| " FAST32" |
| #else |
| " FAST" |
| #endif |
| #endif |
| |
| #ifdef LINKED |
| " LINKED" |
| #endif |
| "\n", hostno, (controller_type == SEAGATE) ? "seagate" : |
| "FD TMC-8xx", 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 weather 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)(Scsi_Cmnd *) = NULL; |
| static 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 |
| |
| #ifdef LINKED |
| |
| /* |
| * 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. |
| */ |
| |
| #define LINKED_RIGHT 3 |
| #define LINKED_WRONG 4 |
| #endif |
| |
| /* |
| * 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 void seagate_reconnect_intr (int unused) |
| { |
| int temp; |
| Scsi_Cmnd * SCtmp; |
| |
| /* enable all other interrupts. */ |
| sti(); |
| #if (DEBUG & PHASE_RESELECT) |
| printk("scsi%d : seagate_reconnect_intr() called\n", hostno); |
| #endif |
| |
| if (!should_reconnect) |
| printk("scsi%d: unexpected interrupt.\n", hostno); |
| else { |
| should_reconnect = 0; |
| |
| #if (DEBUG & PHASE_RESELECT) |
| printk("scsi%d : internal_command(" |
| "%d, %08x, %08x, %d, RECONNECT_NOW\n", hostno, |
| current_target, current_data, current_bufflen); |
| #endif |
| |
| temp = internal_command (current_target, current_lun, |
| current_cmnd, current_data, current_bufflen, |
| RECONNECT_NOW); |
| |
| if (msg_byte(temp) != DISCONNECT) { |
| if (done_fn) { |
| #if (DEBUG & PHASE_RESELECT) |
| printk("scsi%d : done_fn(%d,%08x)", hostno, |
| hostno, temp); |
| #endif |
| if(!SCint) panic("SCint == NULL in seagate"); |
| SCtmp = SCint; |
| SCint = NULL; |
| SCtmp->result = temp; |
| done_fn (SCtmp); |
| } else |
| printk("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; |
| |
| int seagate_st0x_queue_command (Scsi_Cmnd * SCpnt, void (*done)(Scsi_Cmnd *)) |
| { |
| int result, reconnect; |
| Scsi_Cmnd * SCtmp; |
| |
| done_fn = done; |
| current_target = SCpnt->target; |
| current_lun = SCpnt->lun; |
| (const void *) current_cmnd = SCpnt->cmnd; |
| current_data = (unsigned char *) SCpnt->request_buffer; |
| current_bufflen = SCpnt->request_bufflen; |
| SCint = SCpnt; |
| if(recursion_depth) { |
| return 0; |
| }; |
| recursion_depth++; |
| do{ |
| #ifdef LINKED |
| /* |
| * Set linked command bit in control field of SCSI command. |
| */ |
| |
| current_cmnd[COMMAND_SIZE(current_cmnd[0])] |= 0x01; |
| if (linked_connected) { |
| #if (DEBUG & DEBUG_LINKED) |
| printk("scsi%d : using linked commands, current I_T_L nexus is ", |
| hostno); |
| #endif |
| if ((linked_target == current_target) && |
| (linked_lun == current_lun)) { |
| #if (DEBUG & DEBUG_LINKED) |
| printk("correct\n"); |
| #endif |
| reconnect = LINKED_RIGHT; |
| } else { |
| #if (DEBUG & DEBUG_LINKED) |
| printk("incorrect\n"); |
| #endif |
| reconnect = LINKED_WRONG; |
| } |
| } else |
| #endif /* LINKED */ |
| reconnect = CAN_RECONNECT; |
| |
| |
| |
| |
| |
| result = internal_command (SCint->target, SCint->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; |
| } |
| |
| int seagate_st0x_command (Scsi_Cmnd * SCpnt) { |
| return internal_command (SCpnt->target, SCpnt->lun, SCpnt->cmnd, SCpnt->request_buffer, |
| SCpnt->request_bufflen, |
| (int) NO_RECONNECT); |
| } |
| |
| static int internal_command(unsigned char target, unsigned char lun, const void *cmnd, |
| void *buff, int bufflen, int reselect) { |
| int len = 0; |
| unsigned char *data = NULL; |
| struct scatterlist *buffer = NULL; |
| int nobuffs = 0; |
| int clock; |
| int temp; |
| #ifdef SLOW_HANDSHAKE |
| int borken; /* Does the current target require Very Slow I/O ? */ |
| #endif |
| |
| |
| #if (DEBUG & PHASE_DATAIN) || (DEBUG & PHASE_DATOUT) |
| int transfered = 0; |
| #endif |
| |
| #if (((DEBUG & PHASE_ETC) == PHASE_ETC) || (DEBUG & PRINT_COMMAND) || \ |
| (DEBUG & PHASE_EXIT)) |
| int i; |
| #endif |
| |
| #if ((DEBUG & PHASE_ETC) == PHASE_ETC) |
| int phase=0, newphase; |
| #endif |
| |
| int done = 0; |
| unsigned char status = 0; |
| unsigned char message = 0; |
| register unsigned char status_read; |
| |
| unsigned transfersize = 0, underflow = 0; |
| |
| incommand = 0; |
| st0x_aborted = 0; |
| |
| #ifdef SLOW_HANDSHAKE |
| borken = (int) scsi_devices[SCint->index].borken; |
| #endif |
| |
| #if (DEBUG & PRINT_COMMAND) |
| printk ("scsi%d : target = %d, command = ", hostno, target); |
| print_command((unsigned char *) cmnd); |
| printk("\n"); |
| #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 reselct phase, then SEL will |
| * be asserted, and we must skip selection / arbitration phases. |
| */ |
| |
| switch (reselect) { |
| case RECONNECT_NOW: |
| #if (DEBUG & PHASE_RESELECT) |
| printk("scsi%d : phase RESELECT \n", hostno); |
| #endif |
| |
| /* |
| * 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 initator ID is not on the bus |
| * until IO is asserted, so we must wait for that. |
| */ |
| |
| for (clock = jiffies + 10, temp = 0; (jiffies < clock) && |
| !(STATUS & STAT_IO);); |
| |
| if (jiffies >= clock) |
| { |
| #if (DEBUG & PHASE_RESELECT) |
| printk("scsi%d : RESELECT timed out while waiting for IO .\n", |
| hostno); |
| #endif |
| 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))) |
| { |
| #if (DEBUG & PHASE_RESELECT) |
| printk("scsi%d : detected reconnect request to different target.\n" |
| "\tData bus = %d\n", hostno, temp); |
| #endif |
| return (DID_BAD_INTR << 16); |
| } |
| |
| if (!(temp & (1 << current_target))) |
| { |
| printk("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 |
| CONTROL = (BASE_CMD | CMD_DRVR_ENABLE | CMD_BSY); |
| #else |
| CONTROL = (BASE_CMD | CMD_BSY); |
| #endif |
| |
| /* |
| * The target will drop SEL, and raise BSY, at which time we must drop |
| * BSY. |
| */ |
| |
| for (clock = jiffies + 10; (jiffies < clock) && (STATUS & STAT_SEL);); |
| |
| if (jiffies >= clock) |
| { |
| CONTROL = (BASE_CMD | CMD_INTR); |
| #if (DEBUG & PHASE_RESELECT) |
| printk("scsi%d : RESELECT timed out while waiting for SEL.\n", |
| hostno); |
| #endif |
| return (DID_BAD_INTR << 16); |
| } |
| |
| 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 |
| |
| #if (DEBUG & PHASE_BUS_FREE) |
| printk ("scsi%d : phase = BUS FREE \n", hostno); |
| #endif |
| |
| /* |
| * 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. |
| */ |
| |
| clock = jiffies + ST0X_BUS_FREE_DELAY; |
| |
| #if !defined (ARBITRATE) |
| while (((STATUS | STATUS | STATUS) & |
| (STAT_BSY | STAT_SEL)) && |
| (!st0x_aborted) && (jiffies < clock)); |
| |
| if (jiffies > clock) |
| return retcode(DID_BUS_BUSY); |
| else if (st0x_aborted) |
| return retcode(st0x_aborted); |
| #endif |
| |
| #if (DEBUG & PHASE_SELECTION) |
| printk("scsi%d : phase = SELECTION\n", hostno); |
| #endif |
| |
| 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 |
| */ |
| |
| #if defined(ARBITRATE) |
| cli(); |
| CONTROL = 0; |
| DATA = (controller_type == SEAGATE) ? 0x80 : 0x40; |
| CONTROL = CMD_START_ARB; |
| sti(); |
| while (!((status_read = STATUS) & (STAT_ARB_CMPL | STAT_SEL)) && |
| (jiffies < clock) && !st0x_aborted); |
| |
| if (!(status_read & STAT_ARB_CMPL)) { |
| #if (DEBUG & PHASE_SELECTION) |
| if (status_read & STAT_SEL) |
| printk("scsi%d : arbitration lost\n", hostno); |
| else |
| printk("scsi%d : arbitration timeout.\n", hostno); |
| #endif |
| CONTROL = BASE_CMD; |
| return retcode(DID_NO_CONNECT); |
| }; |
| |
| #if (DEBUG & PHASE_SELECTION) |
| printk("scsi%d : arbitration complete\n", hostno); |
| #endif |
| #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 arround. |
| * |
| * 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. |
| */ |
| cli(); |
| DATA = (unsigned char) ((1 << target) | (controller_type == SEAGATE ? 0x80 : 0x40)); |
| CONTROL = BASE_CMD | CMD_DRVR_ENABLE | CMD_SEL | |
| (reselect ? CMD_ATTN : 0); |
| sti(); |
| while (!((status_read = STATUS) & STAT_BSY) && |
| (jiffies < clock) && !st0x_aborted) |
| |
| #if 0 && (DEBUG & PHASE_SELECTION) |
| { |
| temp = clock - jiffies; |
| |
| if (!(jiffies % 5)) |
| printk("seagate_st0x_timeout : %d \r",temp); |
| |
| } |
| printk("Done. \n"); |
| printk("scsi%d : status = %02x, seagate_st0x_timeout = %d, aborted = %02x \n", |
| hostno, status_read, temp, st0x_aborted); |
| #else |
| ; |
| #endif |
| |
| |
| if ((jiffies >= clock) && !(status_read & STAT_BSY)) |
| { |
| #if (DEBUG & PHASE_SELECTION) |
| printk ("scsi%d : NO CONNECT with target %d, status = %x \n", |
| hostno, target, STATUS); |
| #endif |
| return retcode(DID_NO_CONNECT); |
| } |
| |
| /* |
| * 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. |
| */ |
| |
| if (st0x_aborted) { |
| CONTROL = BASE_CMD; |
| if (STATUS & STAT_BSY) { |
| printk("scsi%d : BST asserted after we've been aborted.\n", |
| hostno); |
| seagate_st0x_reset(NULL); |
| return retcode(DID_RESET); |
| } |
| return retcode(st0x_aborted); |
| } |
| |
| /* 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 = %08x length = %d\n", |
| hostno, i, buffer[i].address, buffer[i].length); |
| } |
| #endif |
| |
| buffer = (struct scatterlist *) SCint->buffer; |
| len = buffer->length; |
| data = (unsigned char *) buffer->address; |
| } else { |
| #if (DEBUG & DEBUG_SG) |
| printk("scsi%d : scatter gather not requested.\n", hostno); |
| #endif |
| buffer = NULL; |
| len = SCint->request_bufflen; |
| data = (unsigned char *) SCint->request_buffer; |
| } |
| |
| #if (DEBUG & (PHASE_DATAIN | PHASE_DATAOUT)) |
| printk("scsi%d : len = %d\n", hostno, len); |
| #endif |
| |
| break; |
| #ifdef LINKED |
| case LINKED_RIGHT: |
| break; |
| case LINKED_WRONG: |
| break; |
| #endif |
| } |
| |
| /* |
| * 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. |
| */ |
| |
| |
| CONTROL = BASE_CMD | CMD_DRVR_ENABLE | |
| (((reselect == CAN_RECONNECT) |
| #ifdef LINKED |
| || (reselect == LINKED_WRONG) |
| #endif |
| ) ? CMD_ATTN : 0) ; |
| |
| /* |
| * 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. |
| */ |
| |
| #if ((DEBUG & PHASE_ETC) == PHASE_ETC) |
| printk("scsi%d : phase = INFORMATION TRANSFER\n", hostno); |
| #endif |
| |
| 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("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. |
| */ |
| |
| #ifdef FAST |
| 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 |
| ) { |
| #if (DEBUG & DEBUG_FAST) |
| printk("scsi%d : FAST transfer, underflow = %d, transfersize = %d\n" |
| " len = %d, data = %08x\n", hostno, SCint->underflow, |
| SCint->transfersize, len, data); |
| #endif |
| |
| __asm__(" |
| cld; |
| " |
| #ifdef FAST32 |
| " shr $2, %%ecx; |
| 1: lodsl; |
| movl %%eax, (%%edi); |
| " |
| #else |
| "1: lodsb; |
| movb %%al, (%%edi); |
| " |
| #endif |
| " loop 1b;" : : |
| /* input */ |
| "D" (st0x_dr), "S" (data), "c" (SCint->transfersize) : |
| /* clobbered */ |
| "eax", "ecx", "esi" ); |
| |
| len -= transfersize; |
| data += transfersize; |
| |
| #if (DEBUG & DEBUG_FAST) |
| printk("scsi%d : FAST transfer complete len = %d data = %08x\n", |
| hostno, len, data); |
| #endif |
| |
| |
| } else |
| #endif |
| |
| { |
| /* |
| * We loop as long as we are in a data out phase, there is data to send, |
| * and BSY is still active. |
| */ |
| __asm__ ( |
| |
| /* |
| Local variables : |
| len = ecx |
| data = esi |
| st0x_cr_sr = ebx |
| st0x_dr = edi |
| |
| Test for any data here at all. |
| */ |
| "\torl %%ecx, %%ecx |
| jz 2f |
| |
| cld |
| |
| movl _st0x_cr_sr, %%ebx |
| movl _st0x_dr, %%edi |
| |
| 1: movb (%%ebx), %%al\n" |
| /* |
| Test for BSY |
| */ |
| |
| "\ttest $1, %%al |
| jz 2f\n" |
| |
| /* |
| Test for data out phase - STATUS & REQ_MASK should be REQ_DATAOUT, which is 0. |
| */ |
| "\ttest $0xe, %%al |
| jnz 2f \n" |
| /* |
| Test for REQ |
| */ |
| "\ttest $0x10, %%al |
| jz 1b |
| lodsb |
| movb %%al, (%%edi) |
| loop 1b |
| |
| 2: |
| ": |
| /* output */ |
| "=S" (data), "=c" (len) : |
| /* input */ |
| "0" (data), "1" (len) : |
| /* clobbered */ |
| "eax", "ebx", "edi"); |
| } |
| |
| if (!len && nobuffs) { |
| --nobuffs; |
| ++buffer; |
| len = buffer->length; |
| data = (unsigned char *) buffer->address; |
| #if (DEBUG & DEBUG_SG) |
| printk("scsi%d : next scatter-gather buffer len = %d address = %08x\n", |
| hostno, len, data); |
| #endif |
| } |
| break; |
| |
| case REQ_DATAIN : |
| #ifdef SLOW_HANDSHAKE |
| 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 |
| #ifdef FAST |
| if (fast && transfersize && !(len % transfersize) && (len >= transfersize) |
| #ifdef FAST32 |
| && !(transfersize % 4) |
| #endif |
| ) { |
| #if (DEBUG & DEBUG_FAST) |
| printk("scsi%d : FAST transfer, underflow = %d, transfersize = %d\n" |
| " len = %d, data = %08x\n", hostno, SCint->underflow, |
| SCint->transfersize, len, data); |
| #endif |
| __asm__(" |
| cld; |
| " |
| #ifdef FAST32 |
| " shr $2, %%ecx; |
| 1: movl (%%esi), %%eax; |
| stosl; |
| " |
| #else |
| "1: movb (%%esi), %%al; |
| stosb; |
| " |
| #endif |
| |
| " loop 1b;" : : |
| /* input */ |
| "S" (st0x_dr), "D" (data), "c" (SCint->transfersize) : |
| /* clobbered */ |
| "eax", "ecx", "edi"); |
| |
| len -= transfersize; |
| data += transfersize; |
| |
| #if (DEBUG & PHASE_DATAIN) |
| printk("scsi%d: transfered += %d\n", hostno, transfersize); |
| transfered += transfersize; |
| #endif |
| |
| #if (DEBUG & DEBUG_FAST) |
| printk("scsi%d : FAST transfer complete len = %d data = %08x\n", |
| hostno, len, data); |
| #endif |
| |
| } else |
| #endif |
| { |
| |
| #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 |
| */ |
| |
| __asm__ ( |
| /* |
| Local variables : |
| ecx = len |
| edi = data |
| esi = st0x_cr_sr |
| ebx = st0x_dr |
| |
| Test for room to read |
| */ |
| "\torl %%ecx, %%ecx |
| jz 2f |
| |
| cld |
| movl _st0x_cr_sr, %%esi |
| movl _st0x_dr, %%ebx |
| |
| 1: movb (%%esi), %%al\n" |
| /* |
| Test for BSY |
| */ |
| |
| "\ttest $1, %%al |
| jz 2f\n" |
| |
| /* |
| Test for data in phase - STATUS & REQ_MASK should be REQ_DATAIN, = STAT_IO, which is 4. |
| */ |
| "\tmovb $0xe, %%ah |
| andb %%al, %%ah |
| cmpb $0x04, %%ah |
| jne 2f\n" |
| |
| /* |
| Test for REQ |
| */ |
| "\ttest $0x10, %%al |
| jz 1b |
| |
| movb (%%ebx), %%al |
| stosb |
| loop 1b\n" |
| |
| "2:\n" |
| : |
| /* output */ |
| "=D" (data), "=c" (len) : |
| /* input */ |
| "0" (data), "1" (len) : |
| /* clobbered */ |
| "eax","ebx", "esi"); |
| |
| #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 = (unsigned char *) buffer->address; |
| #if (DEBUG & DEBUG_SG) |
| printk("scsi%d : next scatter-gather buffer len = %d address = %08x\n", |
| hostno, len, data); |
| #endif |
| } |
| |
| break; |
| |
| case REQ_CMDOUT : |
| while (((status_read = STATUS) & STAT_BSY) && |
| ((status_read & REQ_MASK) == REQ_CMDOUT)) |
| if (status_read & STAT_REQ) { |
| DATA = *(unsigned char *) cmnd; |
| cmnd = 1+(unsigned char *) cmnd; |
| #ifdef SLOW_HANDSHAKE |
| 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. |
| */ |
| |
| CONTROL = BASE_CMD | CMD_DRVR_ENABLE; |
| /* |
| * If we are reconecting, then we must send an IDENTIFY message in |
| * response to MSGOUT. |
| */ |
| switch (reselect) { |
| case CAN_RECONNECT: |
| DATA = IDENTIFY(1, lun); |
| |
| #if (DEBUG & (PHASE_RESELECT | PHASE_MSGOUT)) |
| printk("scsi%d : sent IDENTIFY message.\n", hostno); |
| #endif |
| break; |
| #ifdef LINKED |
| case LINKED_WRONG: |
| DATA = ABORT; |
| linked_connected = 0; |
| reselect = CAN_RECONNECT; |
| goto connect_loop; |
| #if (DEBUG & (PHASE_MSGOUT | DEBUG_LINKED)) |
| printk("scsi%d : sent ABORT message to cancle incorrect I_T_L nexus.\n", hostno); |
| #endif |
| #endif /* LINKED */ |
| #if (DEBUG & DEBUG_LINKED) |
| printk("correct\n"); |
| #endif |
| default: |
| DATA = NOP; |
| printk("scsi%d : target %d requested MSGOUT, sent NOP message.\n", hostno, target); |
| } |
| break; |
| |
| case REQ_MSGIN : |
| switch (message = DATA) { |
| case DISCONNECT : |
| 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; |
| #if (DEBUG & (PHASE_RESELECT | PHASE_MSGIN)) |
| printk("scsi%d : disconnected.\n", hostno); |
| #endif |
| break; |
| |
| #ifdef LINKED |
| case LINKED_CMD_COMPLETE: |
| case LINKED_FLG_CMD_COMPLETE: |
| #endif |
| case COMMAND_COMPLETE : |
| /* |
| * Note : we should check for underflow here. |
| */ |
| #if (DEBUG & PHASE_MSGIN) |
| printk("scsi%d : command complete.\n", hostno); |
| #endif |
| done = 1; |
| break; |
| case ABORT : |
| #if (DEBUG & PHASE_MSGIN) |
| printk("scsi%d : abort message.\n", hostno); |
| #endif |
| done=1; |
| break; |
| case SAVE_POINTERS : |
| current_buffer = buffer; |
| current_bufflen = len; /* WDE add */ |
| current_data = data; /* WDE mod */ |
| current_nobuffs = nobuffs; |
| #if (DEBUG & PHASE_MSGIN) |
| printk("scsi%d : pointers saved.\n", hostno); |
| #endif |
| break; |
| case RESTORE_POINTERS: |
| buffer=current_buffer; |
| cmnd=current_cmnd; |
| data=current_data; /* WDE mod */ |
| len=current_bufflen; |
| nobuffs=current_nobuffs; |
| #if (DEBUG & PHASE_MSGIN) |
| printk("scsi%d : pointers restored.\n", hostno); |
| #endif |
| break; |
| default: |
| |
| /* |
| * IDENTIFY distinguishes itself from the other messages by setting the |
| * high byte. |
| * |
| * 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) { |
| #if (DEBUG & PHASE_MSGIN) |
| printk("scsi%d : IDENTIFY message received from id %d, lun %d.\n", |
| hostno, target, message & 7); |
| #endif |
| } 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. |
| */ |
| |
| #if (DEBUG & PHASE_MSGIN) |
| printk("scsi%d : unknown message %d from target %d.\n", |
| hostno, message, target); |
| #endif |
| } |
| } |
| break; |
| |
| default : |
| printk("scsi%d : unknown phase.\n", hostno); |
| st0x_aborted = DID_ERROR; |
| } |
| |
| #ifdef SLOW_HANDSHAKE |
| /* |
| * 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 ends */ |
| } /* while ends */ |
| |
| #if (DEBUG & (PHASE_DATAIN | PHASE_DATAOUT | PHASE_EXIT)) |
| printk("scsi%d : Transfered %d bytes\n", hostno, transfered); |
| #endif |
| |
| #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); |
| print_status(status); |
| printk("message = %02x\n", message); |
| #endif |
| |
| |
| /* We shouldn't reach this until *after* BSY has been deasserted */ |
| #ifdef notyet |
| if (st0x_aborted) { |
| if (STATUS & STAT_BSY) { |
| seagate_st0x_reset(NULL); |
| st0x_aborted = DID_RESET; |
| } |
| abort_confirm = 1; |
| } |
| #endif |
| |
| #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; |
| #if (DEBUG & DEBUG_LINKED) |
| printk("scsi%d : keeping I_T_L nexus established for linked command.\n", |
| hostno); |
| #endif |
| /* |
| * We also will need to adjust status to accomodate 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 : |
| #if (DEBUG & DEBUG_LINKED) |
| printk("scsi%d : closing I_T_L nexus.\n", hostno); |
| #endif |
| linked_connected = 0; |
| } |
| } |
| #endif /* LINKED */ |
| |
| |
| |
| |
| if (should_reconnect) { |
| #if (DEBUG & PHASE_RESELECT) |
| printk("scsi%d : exiting seagate_st0x_queue_command() with reconnect enabled.\n", |
| hostno); |
| #endif |
| CONTROL = BASE_CMD | CMD_INTR ; |
| } else |
| CONTROL = BASE_CMD; |
| |
| return retcode (st0x_aborted); |
| } |
| |
| int seagate_st0x_abort (Scsi_Cmnd * SCpnt, int code) |
| { |
| if (code) |
| st0x_aborted = code; |
| else |
| st0x_aborted = DID_ABORT; |
| |
| return 0; |
| } |
| |
| /* |
| the seagate_st0x_reset function resets the SCSI bus |
| */ |
| |
| int seagate_st0x_reset (Scsi_Cmnd * SCpnt) |
| { |
| unsigned clock; |
| /* |
| No timeouts - this command is going to fail because |
| it was reset. |
| */ |
| |
| #ifdef DEBUG |
| printk("In seagate_st0x_reset()\n"); |
| #endif |
| |
| |
| /* assert RESET signal on SCSI bus. */ |
| |
| CONTROL = BASE_CMD | CMD_RST; |
| clock=jiffies+2; |
| |
| |
| /* Wait. */ |
| |
| while (jiffies < clock); |
| |
| CONTROL = BASE_CMD; |
| |
| st0x_aborted = DID_RESET; |
| |
| #ifdef DEBUG |
| printk("SCSI bus reset.\n"); |
| #endif |
| if(SCpnt) SCpnt->flags |= NEEDS_JUMPSTART; |
| return 0; |
| } |
| |
| #ifdef CONFIG_BLK_DEV_SD |
| |
| #include <asm/segment.h> |
| #include "sd.h" |
| #include "scsi_ioctl.h" |
| |
| int seagate_st0x_biosparam(int size, int dev, int* ip) { |
| unsigned char buf[256 + sizeof(int) * 2], cmd[6], *data, *page; |
| int *sizes, result, formatted_sectors, total_sectors; |
| int cylinders, heads, sectors; |
| |
| Scsi_Device *disk; |
| |
| disk = rscsi_disks[MINOR(dev) >> 4].device; |
| |
| /* |
| * Only SCSI-I CCS drives and later implement the necessary mode sense |
| * pages. |
| */ |
| |
| if (disk->scsi_level < 2) |
| return -1; |
| |
| sizes = (int *) buf; |
| data = (unsigned char *) (sizes + 2); |
| |
| cmd[0] = MODE_SENSE; |
| cmd[1] = (disk->lun << 5) & 0xe5; |
| cmd[2] = 0x04; /* Read page 4, rigid disk geometry page current values */ |
| cmd[3] = 0; |
| cmd[4] = 255; |
| cmd[5] = 0; |
| |
| /* |
| * We are transfering 0 bytes in the out direction, and expect to get back |
| * 24 bytes for each mode page. |
| */ |
| |
| sizes[0] = 0; |
| sizes[1] = 256; |
| |
| memcpy (data, cmd, 6); |
| |
| if (!(result = kernel_scsi_ioctl (disk, SCSI_IOCTL_SEND_COMMAND, (void *) buf))) { |
| /* |
| * The mode page lies beyond the MODE SENSE header, with length 4, and |
| * the BLOCK DESCRIPTOR, with length header[3]. |
| */ |
| |
| page = data + 4 + data[3]; |
| heads = (int) page[5]; |
| cylinders = (page[2] << 16) | (page[3] << 8) | page[4]; |
| |
| cmd[2] = 0x03; /* Read page 3, format page current values */ |
| memcpy (data, cmd, 6); |
| |
| if (!(result = kernel_scsi_ioctl (disk, SCSI_IOCTL_SEND_COMMAND, (void *) buf))) { |
| page = data + 4 + data[3]; |
| sectors = (page[10] << 8) | page[11]; |
| |
| |
| /* |
| * Get the total number of formatted sectors from the block descriptor, |
| * so we can tell how many are being used for alternates. |
| */ |
| |
| formatted_sectors = (data[4 + 1] << 16) | (data[4 + 2] << 8) | |
| data[4 + 3] ; |
| |
| total_sectors = (heads * cylinders * sectors); |
| |
| /* |
| * Adjust the real geometry by subtracting |
| * (spare sectors / (heads * tracks)) cylinders from the number of cylinders. |
| * |
| * It appears that the CE cylinder CAN be a partial cylinder. |
| */ |
| |
| |
| printk("scsi%d : heads = %d cylinders = %d sectors = %d total = %d formatted = %d\n", |
| hostno, heads, cylinders, sectors, total_sectors, formatted_sectors); |
| |
| if (!heads || !sectors || !cylinders) |
| result = -1; |
| else |
| cylinders -= ((total_sectors - formatted_sectors) / (heads * sectors)); |
| |
| /* |
| * Now, we need to do a sanity check on the geometry to see if it is |
| * BIOS compatable. The maximum BIOS geometry is 1024 cylinders * |
| * 256 heads * 64 sectors. |
| */ |
| |
| if ((cylinders > 1024) || (sectors > 64)) |
| result = -1; |
| else { |
| ip[0] = heads; |
| ip[1] = sectors; |
| ip[2] = cylinders; |
| } |
| |
| /* |
| * There should be an alternate mapping for things the seagate doesn't |
| * understand, but I couldn't say what it is with reasonable certainty. |
| */ |
| |
| } |
| } |
| |
| return result; |
| } |
| #endif /* CONFIG_BLK_DEV_SD */ |
| |
| #endif /* defined(CONFIG_SCSI_SEGATE) */ |
| |