1711 lines
41 KiB
C
1711 lines
41 KiB
C
/*
|
|
* 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) */
|
|
|