mirror of https://github.com/lianthony/NT4.0
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
586 lines
15 KiB
586 lines
15 KiB
//---------------------------------------------------------------------
|
|
//
|
|
// File: SCSIFNC.C
|
|
//
|
|
// N5380 Scsi Functions file. Contains higher level scsi functions.
|
|
//
|
|
// Revisions:
|
|
// 09-01-92 KJB First.
|
|
// 03-02-93 KJB/JAP Wait for phase change before doing i/o.
|
|
// 03-11-93 JAP Changed retcode equates to reflect new names.
|
|
// 03-12-93 KJB FinishCommandInterrupt now calls CardDisableInterrupt
|
|
// 03-19-93 JAP Implemented condition build FAR and NEAR pointers
|
|
// 03-23-93 KJB Changed for new functional interface.
|
|
// 03-24-93 KJB ScsiStartCommandInterrupt can now return
|
|
// RET_STATUS_MISSED_INTERRUPT, in which case caller
|
|
// should pretend interrupt happened and call
|
|
// FinishCommandInterrupt.
|
|
// 03-25-93 JAP Fixed up typedef and prototype inconsistencies
|
|
// 03-31-93 JAP/KJB Added code to handle data overflow:
|
|
// DATAIN: target sends more bytes than we have
|
|
// been asked to receive
|
|
// DATAOUT: target requests more bytes than we have
|
|
// been asked to send
|
|
// 04-05-93 KJB DEBUG_LEVEL used by DebugPrint for NT.
|
|
// 04-05-93 KJB Changed DoIo, now it will not return
|
|
// DATA_OVERRUN when there is no data to transfer.
|
|
// 04-09-93 KJB Check for phase mismatch before returning that
|
|
// we missed an interrupt.
|
|
// 05-13-93 KJB Added CardParseCommandString for card specific
|
|
// standard string parsing across platforms.
|
|
// Changed CardCheckAdapter to accept an
|
|
// Initialization info from command line, ie
|
|
// force bi-directional ports, etc.
|
|
// All functions that used to take an PBASE_REGISTER
|
|
// parameter now take PWORKSPACE. CardCheckAdapter
|
|
// takes the both the PBASE_REGISTER and the
|
|
// PWORKSPACE parameters. Auto Request Sense is
|
|
// now supported.
|
|
// 05-13-93 KJB Added RequestSenseValid field to TSRB.
|
|
// 05-16-93 KJB Fixed bug: finishcommandinterrupt was returning
|
|
// RET_STATUS_PENDING when length of xfer was 0.
|
|
// Now return RET_STATUS_ERROR when Status != 0.
|
|
//
|
|
//---------------------------------------------------------------------
|
|
|
|
#include CARDTXXX_H
|
|
|
|
//
|
|
// Local functions
|
|
//
|
|
void ScsiDoRequestSense(PTSRB t);
|
|
|
|
//
|
|
// ScsiSendCommand
|
|
//
|
|
// Selects a target and sends a scsi command during command phase.
|
|
//
|
|
|
|
USHORT ScsiSendCommand (PADAPTER_INFO g, UCHAR target,
|
|
UCHAR lun, PUCHAR pcmd, UCHAR cmdlen)
|
|
{
|
|
USHORT rval;
|
|
ULONG tmp;
|
|
|
|
// select the target
|
|
|
|
if (rval = N5380Select (g, target, lun)) {
|
|
if (rval != RET_STATUS_SELECTION_TIMEOUT) {
|
|
DebugPrint((DEBUG_LEVEL,"ScsiSendCommand-0 Error: %x\n",rval));
|
|
}
|
|
return rval;
|
|
}
|
|
|
|
// set the phase to Command
|
|
|
|
if (rval = N5380SetPhase (g, PHASE_COMMAND)) {
|
|
DebugPrint((DEBUG_LEVEL,"ScsiSendCommand-1 Error: %x\n",rval));
|
|
return rval;
|
|
}
|
|
|
|
// send the command bytes
|
|
|
|
if (rval = CardWriteBytesCommand (g, pcmd, (ULONG)cmdlen,
|
|
&tmp, PHASE_COMMAND)) {
|
|
DebugPrint((DEBUG_LEVEL,"ScsiSendCommand-2 Error: %x\n",rval));
|
|
return rval;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
//
|
|
// ScsiDoCommand
|
|
//
|
|
// Executes a complete scsi command: all phase sequences without using
|
|
// interrupts.
|
|
//
|
|
|
|
USHORT ScsiDoCommand (PTSRB t)
|
|
{
|
|
USHORT rval;
|
|
PADAPTER_INFO g = t->pWorkspace;
|
|
|
|
// select the target and send the command bytes
|
|
|
|
if (rval = ScsiSendCommand (g, t->Target, t->Lun, t->pCommand,
|
|
t->CommandLen)) {
|
|
DebugPrint((DEBUG_LEVEL,"ScsiDoCommand-0 Error: %x\n",rval));
|
|
goto done;
|
|
}
|
|
|
|
if (rval = ScsiFinishCommandInterrupt (t)) {
|
|
if (rval!=RET_STATUS_SUCCESS) {
|
|
DebugPrint((DEBUG_LEVEL,"ScsiDoCommand-1 Error: %x\n",rval));
|
|
}
|
|
}
|
|
|
|
done:
|
|
t->ReturnCode = rval;
|
|
|
|
return rval;
|
|
}
|
|
|
|
|
|
//
|
|
// ScsiStartCommandInterrupt
|
|
//
|
|
// Executes a scsi command up to the end of command phase. After this, the
|
|
// interrupt will come in and ScsiFinishCommandInterrupt should be called to
|
|
// complete the data, status, and message phases.
|
|
//
|
|
|
|
USHORT ScsiStartCommandInterrupt (PTSRB t)
|
|
{
|
|
USHORT rval;
|
|
PADAPTER_INFO g = t->pWorkspace;
|
|
|
|
// select the target and send the command bytes
|
|
|
|
if (rval = ScsiSendCommand (g, t->Target, t->Lun, t->pCommand,
|
|
t->CommandLen)) {
|
|
DebugPrint((DEBUG_LEVEL,"ScsiStartCommandInterrupt-0 Error: %x\n",rval));
|
|
goto done;
|
|
}
|
|
|
|
// enable the interrupt
|
|
|
|
CardEnableInterrupt (g);
|
|
|
|
// if request is already up, we may have missed the interrupt, it is done
|
|
|
|
if (N5380PortTest (g, N5380_CURRENT_STATUS, CS_REQ)) {
|
|
|
|
// and we are not still in command phase
|
|
|
|
if (!N5380PortTest(g, N5380_DMA_STATUS, DS_PHASE_MATCH)) {
|
|
rval = RET_STATUS_MISSED_INTERRUPT;
|
|
goto done;
|
|
}
|
|
}
|
|
|
|
rval = RET_STATUS_PENDING;
|
|
|
|
done:
|
|
t->ReturnCode = rval;
|
|
return rval;
|
|
}
|
|
|
|
//
|
|
// ScsiFinishComamndInterrupt
|
|
//
|
|
// Called to finish a command that has been started by ScsiStartCommandInterupt.
|
|
// This function completes the data, status, and message phases.
|
|
//
|
|
|
|
USHORT ScsiFinishCommandInterrupt (PTSRB t)
|
|
{
|
|
USHORT rval = 0;
|
|
USHORT rval_stat = 0;
|
|
PADAPTER_INFO g = t->pWorkspace;
|
|
|
|
|
|
// set actual transfer length to 0
|
|
|
|
t->ActualDataLen = 0;
|
|
|
|
// set request sense valid flag to FALSE
|
|
|
|
t->Flags.RequestSenseValid = FALSE;
|
|
|
|
// is there a data phase??
|
|
|
|
if (t->DataLen) {
|
|
|
|
// read/write the data if there is a data phase
|
|
|
|
rval = ScsiDoIo (t);
|
|
|
|
}
|
|
|
|
// if no errors, return RET_STATUS_SUCCESS.
|
|
|
|
if (!rval) {
|
|
rval = RET_STATUS_SUCCESS;
|
|
}
|
|
|
|
// get the stat and message bytes
|
|
|
|
if (rval_stat = ScsiGetStat (g, &t->Status)) {
|
|
DebugPrint((DEBUG_LEVEL,"ScsiFinishCommandInterrupt-0 Error: %x\n",rval_stat));
|
|
rval = rval_stat;
|
|
goto done;
|
|
}
|
|
|
|
// if not any other error, return a general status error to indicate
|
|
// that the status byte was bad.
|
|
|
|
if (!rval_stat) {
|
|
|
|
// no errors get status, was there a status check condition?
|
|
|
|
if (t->Status == 0x02) {
|
|
|
|
if (t->Flags.DoRequestSense) {
|
|
ScsiDoRequestSense(t);
|
|
}
|
|
|
|
}
|
|
|
|
if (t->Status) {
|
|
|
|
// return with error when there was a non-zero status
|
|
|
|
rval = RET_STATUS_ERROR;
|
|
}
|
|
|
|
}
|
|
|
|
if (rval!=RET_STATUS_SUCCESS) {
|
|
DebugPrint((DEBUG_LEVEL,"ScsiFinishCommandInterrupt-1 Error: %x\n",rval));
|
|
}
|
|
|
|
done:
|
|
// disable the interrupt
|
|
|
|
CardDisableInterrupt(g);
|
|
|
|
// for now, we never return pending
|
|
|
|
t->ReturnCode = rval;
|
|
return rval;
|
|
}
|
|
|
|
//
|
|
// ScsiDoRequestSense
|
|
//
|
|
// Do a request sense and store the information in the current tsrb.
|
|
// Works on the stack, does not harm the current tsrb.
|
|
//
|
|
VOID ScsiDoRequestSense(PTSRB t)
|
|
{
|
|
PADAPTER_INFO g = t->pWorkspace;
|
|
// allocate on stack ok, since we don't use interrupt for the sense cmd
|
|
TSRB tsrb;
|
|
PTSRB t0 = &tsrb;
|
|
UCHAR pSenseCmd[6];
|
|
USHORT rval;
|
|
|
|
pSenseCmd[0] = 0x03;
|
|
pSenseCmd[1] = 0x00;
|
|
pSenseCmd[2] = 0x00;
|
|
pSenseCmd[3] = 0x00;
|
|
pSenseCmd[4] = t->SenseDataLen;
|
|
pSenseCmd[5] = 0x00;
|
|
|
|
// copy most of the tsrb information from the current tsrb
|
|
|
|
*t0 = *t;
|
|
|
|
// get the sense information
|
|
|
|
t0->Flags.DoRequestSense = FALSE; // don't request sense info here
|
|
t0->pCommand = pSenseCmd;
|
|
t0->CommandLen = 6;
|
|
t0->Dir = TSRB_DIR_IN;
|
|
t0->pData = t->pSenseData;
|
|
t0->DataLen = t->SenseDataLen;
|
|
|
|
rval = CardDoCommand(t0); // don't use interrupts
|
|
|
|
if (rval == RET_STATUS_SUCCESS) {
|
|
t->Flags.RequestSenseValid = TRUE;
|
|
}
|
|
}
|
|
|
|
//
|
|
// ScsiWriteBytesSlow
|
|
//
|
|
// This functions writes bytes to the scsi bus using the slow req/ack
|
|
// handshake. Faster methods are generally avaiable, but they are dependent
|
|
// on how the card inplements the dma capabilities of the 5380. This
|
|
// is a sure-fire slow method that works. It is great to bring up new cards.
|
|
//
|
|
|
|
USHORT ScsiWriteBytesSlow (PADAPTER_INFO g, PUCHAR pbytes,
|
|
ULONG len, PULONG pActualLen, UCHAR phase)
|
|
{
|
|
ULONG i;
|
|
USHORT rval = 0;
|
|
UCHAR tmp;
|
|
|
|
for (i=0;i<len;i++) {
|
|
|
|
// wait for request to be asserted
|
|
|
|
if (rval = N5380GetPhase (g, &tmp)) {
|
|
DebugPrint((DEBUG_LEVEL,"ScsiWriteBytesSlow-0 Error: %x\n",rval));
|
|
goto done;
|
|
}
|
|
|
|
// see if phase match
|
|
|
|
if (phase != tmp) {
|
|
rval = RET_STATUS_DATA_OVERRUN;
|
|
goto done;
|
|
}
|
|
|
|
if (rval = N5380PutByte (g, TIMEOUT_REQUEST, pbytes[i])) {
|
|
DebugPrint((DEBUG_LEVEL,"ScsiWriteBytesSlow-1 Error: %x\n",rval));
|
|
goto done;
|
|
}
|
|
}
|
|
|
|
done:
|
|
*pActualLen = i;
|
|
return rval;
|
|
}
|
|
|
|
|
|
//
|
|
// ScsiReadBytesSlow
|
|
//
|
|
// This functions reads bytes to the scsi bus using the slow req/ack
|
|
// handshake. Faster methods are generally avaiable, but they are dependent
|
|
// on how the card inplements the dma capabilities of the 5380. This
|
|
// is a sure-fire slow method that works. It is great to bring up new cards.
|
|
//
|
|
|
|
USHORT ScsiReadBytesSlow (PADAPTER_INFO g, PUCHAR pbytes,
|
|
ULONG len, PULONG pActualLen, UCHAR phase)
|
|
{
|
|
ULONG i;
|
|
USHORT rval = 0;
|
|
UCHAR tmp;
|
|
|
|
for (i = 0; i < len; i++) {
|
|
|
|
// wait for request to be asserted
|
|
|
|
if (rval = N5380GetPhase (g, &tmp)) {
|
|
DebugPrint((DEBUG_LEVEL,"ScsiReadBytesSlow-0 Error: %x\n",rval));
|
|
goto done;
|
|
}
|
|
|
|
// see if phase match
|
|
|
|
if (phase != tmp) {
|
|
rval = RET_STATUS_DATA_OVERRUN;
|
|
goto done;
|
|
}
|
|
|
|
if (rval = N5380GetByte (g, TIMEOUT_REQUEST, &pbytes[i])) {
|
|
DebugPrint((DEBUG_LEVEL,"ScsiReadBytesSlow-1 Error: %x\n",rval));
|
|
goto done;
|
|
}
|
|
}
|
|
|
|
done:
|
|
*pActualLen = i;
|
|
return rval;
|
|
}
|
|
|
|
|
|
//
|
|
// ScsiDoIo
|
|
//
|
|
// This function does the I/O during a data phase.
|
|
//
|
|
|
|
USHORT ScsiDoIo (PTSRB t)
|
|
{
|
|
USHORT rval;
|
|
UCHAR tmp;
|
|
UCHAR phase;
|
|
PADAPTER_INFO g = t->pWorkspace;
|
|
|
|
// wait for next phase, errors in phase will be caught below
|
|
|
|
if (rval = N5380GetPhase (g, &tmp)) {
|
|
goto done;
|
|
}
|
|
|
|
if (t->DataLen && tmp != PHASE_DATAIN && tmp != PHASE_DATAOUT) {
|
|
|
|
// phase is not data in/out and we were expecting data, len !=0
|
|
|
|
rval = RET_STATUS_DATA_OVERRUN;
|
|
goto done;
|
|
}
|
|
|
|
|
|
// phase is now either data in or data out
|
|
|
|
if (t->Dir == TSRB_DIR_UNKNOWN) {
|
|
|
|
// must be read/write, use phase bits to determine it
|
|
|
|
if (tmp == PHASE_DATAOUT) {
|
|
t->Dir = TSRB_DIR_OUT;
|
|
}
|
|
else if (tmp == PHASE_DATAIN) {
|
|
t->Dir = TSRB_DIR_IN;
|
|
}
|
|
|
|
// else: pass thru, don't transfer any data, must be in status phase
|
|
|
|
}
|
|
|
|
|
|
if (t->Dir == TSRB_DIR_OUT) {
|
|
|
|
// data write
|
|
|
|
// set the phase to data out
|
|
|
|
if (rval = N5380SetPhase (g, PHASE_DATAOUT)) {
|
|
return RET_STATUS_ERROR;
|
|
}
|
|
|
|
// send the bytes
|
|
|
|
if (rval = CardWriteBytesFast (g, t->pData, t->DataLen,
|
|
&t->ActualDataLen, PHASE_DATAOUT)) {
|
|
DebugPrint((DEBUG_LEVEL,"ScsiDoIo-0 Error: %x\n",rval));
|
|
return rval;
|
|
}
|
|
|
|
// Check for Data Overflow.
|
|
|
|
while ((N5380GetPhase (g,&phase) == 0) &&
|
|
(phase == PHASE_DATAOUT)) {
|
|
|
|
// DATA OVERFLOW:
|
|
// Target requests more bytes than we have been asked to send.
|
|
// Send a dummy byte of 0 until we are out of DATAOUT phase.
|
|
|
|
ULONG tmpDataLen;
|
|
UCHAR dummy = 0;
|
|
|
|
if (rval = ScsiWriteBytesSlow (g, &dummy, 1,
|
|
&tmpDataLen, PHASE_DATAOUT)) {
|
|
DebugPrint((DEBUG_LEVEL,"ScsiDoIo-2 Error: %x\n",rval));
|
|
return rval;
|
|
}
|
|
}
|
|
}
|
|
|
|
else if (t->Dir == TSRB_DIR_IN) {
|
|
|
|
// data read
|
|
|
|
// set the phase to data in
|
|
|
|
if (rval = N5380SetPhase (g, PHASE_DATAIN)) {
|
|
return RET_STATUS_ERROR;
|
|
}
|
|
|
|
// read the bytes
|
|
|
|
if (rval = CardReadBytesFast (g, t->pData, t->DataLen,
|
|
&t->ActualDataLen, PHASE_DATAIN)) {
|
|
DebugPrint((DEBUG_LEVEL,"ScsiDoIo-1 Error: %x\n",rval));
|
|
return rval;
|
|
}
|
|
|
|
// Check for Data Overflow.
|
|
|
|
while ((N5380GetPhase(g,&phase) == 0) &&
|
|
phase == PHASE_DATAIN) {
|
|
|
|
// DATA OVERFLOW:
|
|
// Target sends more bytes than we have been asked to receive.
|
|
// Swallow up extra bytes until we are out of DATAIN phase.
|
|
|
|
ULONG tmpDataLen;
|
|
UCHAR dummy;
|
|
|
|
if (rval = ScsiReadBytesSlow (g, &dummy, 1,
|
|
&tmpDataLen, PHASE_DATAIN)) {
|
|
DebugPrint((DEBUG_LEVEL,"ScsiDoIo-3 Error: %x\n",rval));
|
|
return rval;
|
|
}
|
|
}
|
|
}
|
|
|
|
done:
|
|
return rval;
|
|
}
|
|
|
|
|
|
//
|
|
// ScsiGetStat
|
|
//
|
|
// This function gets the status and message bytes.
|
|
//
|
|
|
|
USHORT ScsiGetStat (PADAPTER_INFO g, PUCHAR pstatus)
|
|
{
|
|
UCHAR tmp;
|
|
USHORT rval;
|
|
|
|
// set the phase to Status Phase
|
|
|
|
if (rval = N5380SetPhase (g, PHASE_STATUS)) {
|
|
DebugPrint((DEBUG_LEVEL,"ScsiGetStat-0 Error: %x\n",rval));
|
|
return rval;
|
|
}
|
|
|
|
// wait for request to be asserted
|
|
|
|
if (rval = N5380GetPhase (g,&tmp)) {
|
|
DebugPrint((DEBUG_LEVEL,"ScsiGetStat-1 Error: %x\n",rval));
|
|
return rval;
|
|
}
|
|
|
|
// see if phase match
|
|
|
|
if (PHASE_STATUS != tmp) {
|
|
return RET_STATUS_PHASE_SEQ_FAILURE;
|
|
}
|
|
|
|
// get the status byte
|
|
|
|
if (rval = N5380GetByte (g, TIMEOUT_REQUEST, pstatus)) {
|
|
DebugPrint((DEBUG_LEVEL,"ScsiGetStat-2 Error: %x\n",rval));
|
|
return rval;
|
|
}
|
|
|
|
// set the phase to Message In Phase
|
|
|
|
if (rval = N5380SetPhase (g, PHASE_MSGIN)) {
|
|
DebugPrint((DEBUG_LEVEL,"ScsiGetStat-3 Error: %x\n",rval));
|
|
return rval;
|
|
}
|
|
|
|
// wait for request to be asserted
|
|
|
|
if (rval = N5380GetPhase (g,&tmp)) {
|
|
DebugPrint((DEBUG_LEVEL,"ScsiGetStat-4 Error: %x\n",rval));
|
|
return rval;
|
|
}
|
|
|
|
// see if phase match
|
|
|
|
if (PHASE_MSGIN != tmp) {
|
|
return RET_STATUS_PHASE_SEQ_FAILURE;
|
|
}
|
|
|
|
// get the msg byte, throw it away
|
|
|
|
if (rval = N5380GetByte (g, TIMEOUT_REQUEST, &tmp)) {
|
|
DebugPrint((DEBUG_LEVEL,"ScsiGetStat-5 Error: %x\n",rval));
|
|
return rval;
|
|
}
|
|
|
|
// set the phase to NULL to up N5380 back to normal
|
|
|
|
if (rval = N5380SetPhase (g, PHASE_NULL)) {
|
|
DebugPrint((DEBUG_LEVEL,"ScsiGetStat-6 Error: %x\n",rval));
|
|
return rval;
|
|
}
|
|
|
|
return rval;
|
|
}
|
|
|