Expand PMF_FN_* macros.

[netbsd-mini2440.git] / dist / pdisk / DoSCSICommand.c

/*
 * DoScsiCommand.c
 *
 * This is the common entry to the original and asynchronous SCSI Manager calls:
 * if the asynchronous SCSI Manager is requested, it calls it. Otherwise, it
 * calls the original SCSI Manager and executes Request Sense if necessary.
 *
 * This function returns "autosense" in the SCSI_Sense_Data area. This will
 * be formatted in the senseMessage string.
 */

/*
 * Copyright 1992, 1993, 1997, 1998 by Apple Computer, Inc.
 *              All Rights Reserved 
 *  
 * Permission to use, copy, modify, and distribute this software and 
 * its documentation for any purpose and without fee is hereby granted, 
 * provided that the above copyright notice appears in all copies and 
 * that both the copyright notice and this permission notice appear in 
 * supporting documentation. 
 *  
 * APPLE COMPUTER DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE 
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
 * FOR A PARTICULAR PURPOSE. 
 *  
 * IN NO EVENT SHALL APPLE COMPUTER BE LIABLE FOR ANY SPECIAL, INDIRECT, OR 
 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM 
 * LOSS OF USE, DATA OR PROFITS, WHETHER IN ACTION OF CONTRACT, 
 * NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION 
 * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 
 */

#include "DoScsiCommand.h"
#include "util.h"


//
// Defines
//
#define kSCSICommandTimeout     (5 * 1000L)         /* Five seconds             */
/*
 * This is the maximum number of times we try to grab the SCSI Bus
 */
#define kMaxSCSIRetries         40                  /* 10 seconds, 4 times/sec  */
/*
 * This test is TRUE if the SCSI bus status indicates "busy" (which is the case
 * if either the BSY or SEL bit is set).
 */
#ifndef kScsiStatBSY
#define kScsiStatBSY            (1 << 6)
#endif
#ifndef kScsiStatSEL
#define kScsiStatSEL            (1 << 1)
#endif
#define ScsiBusBusy()       ((SCSIStat() & (kScsiStatBSY | kScsiStatSEL)) != 0)


//
// Types
//


//
// Global Constants
//


//
// Global Variables
//
int             gSCSIHiBusID;
SCSIExecIOPB    *gSCSIExecIOPBPtr;
UInt32          gSCSIExecIOPBPtrLen;


//
// Forward declarations
//
UInt16 GetCommandLength(const SCSI_CommandPtr cmdPtr);
Boolean IsVirtualMemoryRunning(void);

OSErr OriginalSCSI(
    DeviceIdent             scsiDevice,
    const SCSI_CommandPtr   scsiCommand,
    UInt8                   scsiCommandLen,
    Ptr                     dataBuffer,
    ByteCount               dataLength,
    UInt32                  scsiFlags,
    ByteCount               *actualTransferCount,
    UInt8                   *scsiStatusByte
);

OSErr DoOriginalSCSICommand(
    DeviceIdent             scsiDevice,
    const SCSI_CommandPtr   theSCSICommand,
    unsigned short          cmdBlockLength,
    Ptr                     dataBuffer,
    ByteCount               dataLength,
    UInt32                  scsiFlags,
    ByteCount               *actualTransferCount,
    SCSI_Sense_Data         *sensePtr
);


//
// Routines
//

/*
 * This returns TRUE if the command failed with "Illegal Request." We need this
 * so we can ignore LogSense or ReadDefectData if the device doesn't support
 * these functions.
 */
Boolean
IsIllegalRequest(
    OSErr                   scsiStatus,
    const SCSI_Sense_Data   *senseDataPtr
    )
{
    Boolean                 result;
#define SENSE   (*senseDataPtr)

    result = FALSE;
    if (scsiStatus == scsiNonZeroStatus
     && (SENSE.senseKey & kScsiSenseKeyMask) == kScsiSenseIllegalReq
     && SENSE.additionalSenseLength >= 4) {
        switch ((SENSE.additionalSenseCode << 8) | SENSE.additionalSenseQualifier) {
        case 0x0000:
        case 0x2000:
        case 0x2022:    /* Obsolete */
        result = TRUE;
        break;
        default:
        break;
        }
    }
    return (result);
#undef SENSE
}


/*
 * This returns TRUE if the command failed with Device Not Ready (No Media Present)
 */
Boolean
IsNoMedia(
    OSErr                   scsiStatus,
    const SCSI_Sense_Data   *senseDataPtr
    )
{
    Boolean                 result;
#define SENSE   (*senseDataPtr)

    result = FALSE;
    if (scsiStatus == scsiNonZeroStatus
     && (SENSE.senseKey & kScsiSenseKeyMask) == kScsiSenseNotReady
     && SENSE.additionalSenseLength >= 4) {
        switch ((SENSE.additionalSenseCode << 8) | SENSE.additionalSenseQualifier) {
        case 0x0000:
        case 0x3A00:
        result = TRUE;
        break;
        default:
        break;
        }
    }
    return (result);
#undef SENSE
}


/*
 * Do one SCSI Command. If the device returns Check Condition, issue Request Sense
 * (original SCSI Manager only) and interpret the sense data. The original SCSI
 * command status is in SCB.status. If it is statusErr or scsiNonZeroStatus,
 * the sense data is in SCB.sense and the Request Sense status is in
 * SCB.requestSenseStatus.
 *
 * If sensePtr[0] is non-zero, there is a message.
 */
OSErr
DoSCSICommand(
    DeviceIdent             scsiDevice,
    ConstStr255Param        currentAction,
    const SCSI_CommandPtr   callerSCSICommand,
    Ptr                     dataBuffer,
    ByteCount               dataLength,
    UInt32                  scsiFlags,
    ByteCount               *actualTransferCount,
    SCSI_Sense_Data         *sensePtr,
    StringPtr               senseMessage
    )
{
    OSErr                   status;
    SCSI_Command            theSCSICommand;
    unsigned short          cmdBlockLength;
        
//      SpinSpinner(&gCurrentInfoPtr->spinnerRecord);
//      ShowProgressAction(currentAction);
    /*
     * Store the LUN information in the command block - this is needed
     * for devices that only examine the command block for LUN values.
     * (On SCSI-II, the asynchronous SCSI Manager also includes the
     * LUN in the identify message).
     */
    theSCSICommand = *callerSCSICommand;
    theSCSICommand.scsi[1] &= ~0xE0;
    theSCSICommand.scsi[1] |= (scsiDevice.LUN & 0x03) << 5;
    cmdBlockLength = GetCommandLength(&theSCSICommand);
    if (senseMessage != NULL)
        senseMessage[0] = 0;
    if (sensePtr != NULL)
        sensePtr->errorCode = 0;
    if (scsiDevice.bus == kOriginalSCSIBusAdaptor) {
        status = DoOriginalSCSICommand(
            scsiDevice,
            &theSCSICommand,
            cmdBlockLength,
            dataBuffer,
            dataLength,
            scsiFlags,
            actualTransferCount,
            sensePtr
            );
    }
    else {
        clear_memory(gSCSIExecIOPBPtr, gSCSIExecIOPBPtrLen);
#define PB  (*gSCSIExecIOPBPtr)
        PB.scsiPBLength = gSCSIExecIOPBPtrLen;
        PB.scsiFunctionCode = SCSIExecIO;
        PB.scsiDevice = scsiDevice;
        PB.scsiTimeout = kSCSICommandTimeout;
        /*
         * Fiddle the flags so they're the least disruptive possible.
         */
        PB.scsiFlags = scsiFlags | (scsiSIMQNoFreeze | scsiDontDisconnect);
        if (sensePtr != NULL) {
        PB.scsiSensePtr = (UInt8 *) sensePtr;
        PB.scsiSenseLength = sizeof *sensePtr;
        }
        BlockMoveData(&theSCSICommand, &PB.scsiCDB.cdbBytes[0], cmdBlockLength);
        PB.scsiCDBLength = cmdBlockLength;
        if (dataBuffer != NULL) {
        PB.scsiDataPtr = (UInt8 *) dataBuffer;
        PB.scsiDataLength = dataLength;
        PB.scsiDataType = scsiDataBuffer;
        PB.scsiTransferType = scsiTransferPolled;
        }
        status = SCSIAction((SCSI_PB *) &PB);
        if (status == noErr)
        status = PB.scsiResult;
        if (status == scsiSelectTimeout)
        status = scsiDeviceNotThere;
        if (actualTransferCount != NULL) {
        /*
         * Make sure that the actual transfer count does not exceed
         * the allocation count (some devices spit extra data at us!)
         */
        *actualTransferCount = dataLength - PB.scsiDataResidual;
        if (*actualTransferCount > dataLength)
            *actualTransferCount = dataLength;
        }
#undef PB
    }
    if (status == scsiNonZeroStatus
     && sensePtr != NULL
     && sensePtr->errorCode != 0
     && senseMessage != NULL) {
//          FormatSenseMessage(sensePtr, senseMessage);
//          ShowProgressAction(senseMessage);
    }
    return (status);
}


/*
 * Do a command with autosense using the original SCSI manager.
 */
OSErr
DoOriginalSCSICommand(
    DeviceIdent             scsiDevice,
    const SCSI_CommandPtr   theSCSICommand,
    unsigned short          cmdBlockLength,
    Ptr                     dataBuffer,
    ByteCount               dataLength,
    UInt32                  scsiFlags,
    ByteCount               *actualTransferCount,
    SCSI_Sense_Data         *sensePtr
    )
{
    OSErr                   status;
    UInt8                   scsiStatusByte;
    SCSI_Command            scsiStatusCommand;

    status = OriginalSCSI(
            scsiDevice,
            theSCSICommand,
            cmdBlockLength,
            dataBuffer,
            dataLength,
            scsiFlags,
            actualTransferCount,
            &scsiStatusByte
        );
    if (status == scsiNonZeroStatus
     && scsiStatusByte == kScsiStatusCheckCondition
     && sensePtr != NULL) {
        CLEAR(scsiStatusCommand);
        CLEAR(*sensePtr);
        scsiStatusCommand.scsi6.opcode = kScsiCmdRequestSense;
        scsiStatusCommand.scsi[1] |= (scsiDevice.LUN & 0x03) << 5;
        scsiStatusCommand.scsi6.len = sizeof *sensePtr;
        status = OriginalSCSI(
            scsiDevice,
            &scsiStatusCommand,
            sizeof scsiStatusCommand.scsi6,
            (Ptr) sensePtr,
            sizeof *sensePtr,
            scsiDirectionIn,
            NULL,
            &scsiStatusByte
            );
        if (status != noErr && status != scsiDataRunError) {
#ifdef notdef
        if (gDebugOnError && scsiStatusByte != kScsiStatusCheckCondition) {
            Str255          work;

            pstrcpy(work, "\pAutosense failed ");
            AppendSigned(work, status);
            AppendChar(work, ' ');
            AppendHexLeadingZeros(work, scsiStatusByte, 2);
            DebugStr(work);
        }
#endif
        sensePtr->errorCode = 0;
        status = scsiAutosenseFailed;
        }
        else {
        status = scsiNonZeroStatus;
        }
    }
    return (status);
}


OSErr
OriginalSCSI(
    DeviceIdent             scsiDevice,
    const SCSI_CommandPtr   scsiCommand,
    UInt8                   scsiCommandLen,
    Ptr                     dataBuffer,
    ByteCount               dataLength,
    UInt32                  scsiFlags,
    ByteCount               *actualTransferCount,
    UInt8                   *scsiStatusBytePtr
    )
{
    OSErr                   status;             /* Final status             */
    OSErr                   completionStatus;   /* Status from ScsiComplete */
    short                   totalTries;         /* Get/Select retries       */
    short                   getTries;           /* Get retries              */
    short                   iCount;             /* Bus free counter         */
    unsigned long           watchdog;           /* Timeout after this       */
    unsigned long           myTransferCount;    /* Gets TIB loop counter    */
    short                   scsiStatusByte;     /* Gets SCSIComplete result */
    short                   scsiMsgByte;        /* Gets SCSIComplete result */
    Boolean                 bufferHoldFlag;
    /*
     * The TIB has the following format:
     *  [0] scInc   user buffer         transferQuantum or transferSize
     *  [1] scAdd   &theTransferCount   1
     *  [2] scLoop  -> tib[0]           transferSize / transferQuantum
     *  [3] scStop
     * The intent of this is to return, in actualTransferCount, the number
     * of times we cycled through the tib[] loop. This will be the actual
     * transfer count if transferQuantum equals one, or the number of
     * "blocks" if transferQuantum is the length of one sector.
     */
    SCSIInstr               tib[4];             /* Current TIB              */

    status = noErr;
    bufferHoldFlag = FALSE;
    scsiStatusByte = 0xFF;
    scsiMsgByte = 0xFF;
    myTransferCount = 0;
    /*
     * If there is a data transfer, setup the tib.
     */
    if (dataBuffer != NULL) {
        tib[0].scOpcode = scInc;
        tib[0].scParam1 = (unsigned long) dataBuffer;
        tib[0].scParam2 = 1;
        tib[1].scOpcode = scAdd;
        tib[1].scParam1 = (unsigned long) &myTransferCount;
        tib[1].scParam2 = 1;
        tib[2].scOpcode = scLoop;
        tib[2].scParam1 = (-2 * sizeof (SCSIInstr));
        tib[2].scParam2 = dataLength / tib[0].scParam2;
        tib[3].scOpcode = scStop;
        tib[3].scParam1 = 0;
        tib[3].scParam2 = 0;
    }
    if (IsVirtualMemoryRunning() && dataBuffer != NULL) {
        /*
         * Lock down the user buffer, if any. In a real-world application
         * or driver, this would be done before calling the SCSI interface.
         */
#ifdef notdef
        FailOSErr(
        HoldMemory(dataBuffer, dataLength),
        "\pCan't lock data buffer in physical memory"
        );
#else
        HoldMemory(dataBuffer, dataLength);
#endif
        bufferHoldFlag = TRUE;
    }
    /*
     * Arbitrate for the scsi bus.  This will fail if some other device is
     * accessing the bus at this time (which is unlikely).
     *
     *** Do not set breakpoints or call any functions that may require device
     *** I/O (such as display code that accesses font resources between
     *** SCSIGet and SCSIComplete,
     *
     */
    for (totalTries = 0; totalTries < kMaxSCSIRetries; totalTries++) {
        for (getTries = 0; getTries < 4; getTries++) {
            /*
             * Wait for the bus to go free.
             */
            watchdog = TickCount() + 300;       /* 5 second timeout         */
            while (ScsiBusBusy()) {
                if (/*gStopNow || StopNow() ||*/ TickCount() > watchdog) {
                    status = scsiBusy;
                    goto exit;
                }
            }
            /*
             * The bus is free, try to grab it
             */
            for (iCount = 0; iCount < 4; iCount++) {
                if ((status = SCSIGet()) == noErr)
                    break;
            }
            if (status == noErr) {
                break;                          /* Success: we have the bus */
            }
            /*
             * The bus became busy again. Try to wait for it to go free.
             */
            for (iCount = 0;
                /*gStopNow == FALSE && StopNow() == FALSE &&*/ iCount < 100 && ScsiBusBusy();
                iCount++)
                ;
        } /* The getTries loop */
        if (status != noErr) {
            /*
             * The SCSI Manager thinks the bus is not busy and not selected,
             * but "someone" has set its internal semaphore that signals
             * that the SCSI Manager itself is busy. The application will have
             * to handle this problem. (We tried getTries * 4 times).
             */
            status = scsiBusy;
            goto exit;
        }
        /*
         * We now own the SCSI bus. Try to select the device.
         */
        if ((status = SCSISelect(scsiDevice.targetID)) != noErr) {
            switch (status) {
            /*
             * We get scBadParmsErr if we try to arbitrate for the initiator.
             */
            case scBadParmsErr: status = scsiTIDInvalid;        break;
            case scCommErr:     status = scsiDeviceNotThere;    break;
            case scArbNBErr:    status = scsiBusy;              break;
            case scSequenceErr: status = scsiRequestInvalid;    break;
            }
            goto exit;
        }
        /*
         * From this point on, we must exit through SCSIComplete() even if an
         * error is detected. Send a command to the selected device. There are
         * several failure modes, including an illegal command (such as a
         * write to a read-only device). If the command failed because of
         * "device busy", we will try it again.
         */
        status = SCSICmd((Ptr) scsiCommand, scsiCommandLen);
        if (status != noErr) {
            switch (status) {
            case scCommErr:     status = scsiCommandTimeout;    break;
            case scPhaseErr:    status = scsiSequenceFailed;    break;
            }
        }
        if (status == noErr && dataBuffer != NULL) {
            /*
             * This command requires a data transfer.
             */
            if (scsiFlags == scsiDirectionOut) {
                status = SCSIWrite((Ptr) tib);
            } else {
                status = SCSIRead((Ptr) tib);
            }
            switch (status) {
            case scCommErr:     status = scsiCommandTimeout;        break;
            case scBadParmsErr: status = scsiRequestInvalid;        break;
            case scPhaseErr:    status = noErr; /* Don't care */    break;
            case scCompareErr:                  /* Can't happen */  break;
            }
        }
        /*
         * SCSIComplete "runs" the bus-phase algorithm until the bitter end,
         * returning the status and command-completion message bytes..
         */
        completionStatus = SCSIComplete(
            &scsiStatusByte,
            &scsiMsgByte,
            5 * 60L
            );
        if (status == noErr && completionStatus != noErr) {
            switch (completionStatus) {
            case scCommErr:         status = scsiCommandTimeout;    break;
            case scPhaseErr:        status = scsiSequenceFailed;    break;
            case scComplPhaseErr:   status = scsiSequenceFailed;    break;
            }
        }
        if (completionStatus == noErr && scsiStatusByte == kScsiStatusBusy) {
            /*
             * ScsiComplete is happy. If the device is busy,
             * pause for 1/4 second and try again.
             */
            watchdog = TickCount() + 15;
            while (TickCount() < watchdog)
                ;
            continue;               /* Do next totalTries attempt       */
        }
        /*
         * This is the normal exit (success) or final failure exit.
         */
        break;
    } /* totalTries loop */
exit:

    if (bufferHoldFlag) {
        (void) UnholdMemory(dataBuffer, dataLength);
    }
    /*
     * Return the number of bytes transferred to the caller. If the caller
     * supplied an actual count and the count is no greater than the maximum,
     * ignore any phase errors.
     */
    if (actualTransferCount != NULL) {
        *actualTransferCount = myTransferCount;
        if (*actualTransferCount > dataLength) {
            *actualTransferCount = dataLength;
        }
    }
    /*
     * Also, there is a bug in the combination of System 7.0.1 and the 53C96
     * that may cause the real SCSI Status Byte to be in the Message byte.
     */
    if (scsiStatusByte == kScsiStatusGood
            && scsiMsgByte == kScsiStatusCheckCondition) {
        scsiStatusByte = kScsiStatusCheckCondition;
    }
    if (status == noErr) {
        switch (scsiStatusByte) {
        case kScsiStatusGood:                               break;
        case kScsiStatusBusy:   status = scsiBusy;          break;
        case 0xFF:              status = scsiProvideFail;   break;
        default:                status = scsiNonZeroStatus; break;
        }
    }
    if (status == noErr
            && (scsiFlags & scsiDirectionMask) != scsiDirectionNone
            && myTransferCount != dataLength) {
        status = scsiDataRunError;
    }        
    if (scsiStatusBytePtr != NULL) {
        *scsiStatusBytePtr = scsiStatusByte;
    }
    return (status);
}


UInt16
GetCommandLength(
    const SCSI_CommandPtr   cmdPtr
    )
{
    unsigned short          result;
    /*
     * Look at the "group code" in the command operation. Return zero
     * error for the reserved (3, 4) and vendor-specific command (6, 7)
     * command groups. Otherwise, set the command length from the group code
     * value as specified in the SCSI-II spec.
     */
    switch (cmdPtr->scsi6.opcode & 0xE0) {
    case (0 << 5):  result = 6;     break;
    case (1 << 5):
    case (2 << 5):  result = 10;    break;
    case (5 << 5):  result = 12;    break;
    default:        result = 0;     break;
    }
    return (result);
}


Boolean
IsVirtualMemoryRunning(void)
{
    OSErr                       status;
    long                        response;
    
    status = Gestalt(gestaltVMAttr, &response);
    /*
     * VM is active iff Gestalt succeeded and the response is appropriate.
     */
    return (status == noErr && ((response & (1 << gestaltVMPresent)) != 0));
}


void
AllocatePB()
{
    OSErr           status;
    SCSIBusInquiryPB    busInquiryPB;
#define PB          (busInquiryPB)

    if (gSCSIExecIOPBPtr == NULL) {
        CLEAR(PB);
        PB.scsiPBLength = sizeof PB;
        PB.scsiFunctionCode = SCSIBusInquiry;
        PB.scsiDevice.bus = 0xFF;       /* Get info about the XPT */
        status = SCSIAction((SCSI_PB *) &PB);
        if (status == noErr)
            status = PB.scsiResult;
        if (PB.scsiHiBusID == 0xFF) {
            gSCSIHiBusID = -1;
        } else {
            gSCSIHiBusID = PB.scsiHiBusID;
        }
        gSCSIExecIOPBPtrLen = PB.scsiMaxIOpbSize;
        if (gSCSIExecIOPBPtrLen != 0)
            gSCSIExecIOPBPtr = (SCSIExecIOPB *) NewPtrClear(gSCSIExecIOPBPtrLen);
    }
#undef PB
}