scsi.c File Reference

#include "usbstor.h"
#include <debug.h>

Include dependency graph for scsi.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
static NTSTATUS	USBSTOR_SrbStatusToNtStatus (IN PSCSI_REQUEST_BLOCK Srb)
static NTSTATUS	USBSTOR_IssueBulkOrInterruptRequest (IN PFDO_DEVICE_EXTENSION FDODeviceExtension, IN PIRP Irp, IN USBD_PIPE_HANDLE PipeHandle, IN ULONG TransferFlags, IN ULONG TransferBufferLength, IN PVOID TransferBuffer, IN PMDL TransferBufferMDL, IN PIO_COMPLETION_ROUTINE CompletionRoutine)
static BOOLEAN	USBSTOR_IsCSWValid (PIRP_CONTEXT Context)
static NTSTATUS	USBSTOR_IssueRequestSense (IN PFDO_DEVICE_EXTENSION FDODeviceExtension, IN PIRP Irp)
NTSTATUS NTAPI	USBSTOR_CSWCompletionRoutine (PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID Ctx)
NTSTATUS	USBSTOR_SendCSWRequest (PFDO_DEVICE_EXTENSION FDODeviceExtension, PIRP Irp)
NTSTATUS NTAPI	USBSTOR_DataCompletionRoutine (PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID Ctx)
NTSTATUS NTAPI	USBSTOR_CBWCompletionRoutine (PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID Ctx)
VOID	DumpCBW (PUCHAR Block)
static NTSTATUS	USBSTOR_SendCBWRequest (IN PFDO_DEVICE_EXTENSION FDODeviceExtension, IN PIRP Irp)
NTSTATUS	USBSTOR_HandleExecuteSCSI (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)

Variables
IO_COMPLETION_ROUTINE	USBSTOR_CSWCompletionRoutine
IO_COMPLETION_ROUTINE	USBSTOR_DataCompletionRoutine
IO_COMPLETION_ROUTINE	USBSTOR_CBWCompletionRoutine

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 14 of file scsi.c.

Function Documentation

DumpCBW()

VOID DumpCBW

(

PUCHAR

Block

)

Definition at line 444 of file scsi.c.

{
    DPRINT("%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
        Block[0] & 0xFF, Block[1] & 0xFF, Block[2] & 0xFF, Block[3] & 0xFF, Block[4] & 0xFF, Block[5] & 0xFF, Block[6] & 0xFF, Block[7] & 0xFF, Block[8] & 0xFF, Block[9] & 0xFF,
        Block[10] & 0xFF, Block[11] & 0xFF, Block[12] & 0xFF, Block[13] & 0xFF, Block[14] & 0xFF, Block[15] & 0xFF, Block[16] & 0xFF, Block[17] & 0xFF, Block[18] & 0xFF, Block[19] & 0xFF,
        Block[20] & 0xFF, Block[21] & 0xFF, Block[22] & 0xFF, Block[23] & 0xFF, Block[24] & 0xFF, Block[25] & 0xFF, Block[26] & 0xFF, Block[27] & 0xFF, Block[28] & 0xFF, Block[29] & 0xFF,
        Block[30] & 0xFF);
}

Referenced by USBSTOR_SendCBWRequest(), and USBSTOR_SendRequest().

USBSTOR_CBWCompletionRoutine()

NTSTATUS NTAPI USBSTOR_CBWCompletionRoutine	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp,
		PVOID	Ctx
	)

Definition at line 329 of file scsi.c.

{
    PIO_STACK_LOCATION IoStack;
    PSCSI_REQUEST_BLOCK Request;
    PPDO_DEVICE_EXTENSION PDODeviceExtension;
    PFDO_DEVICE_EXTENSION FDODeviceExtension;
    USBD_PIPE_HANDLE PipeHandle;
    ULONG TransferFlags;
    PMDL Mdl = NULL;
    PVOID TransferBuffer = NULL;
 
    DPRINT("USBSTOR_CBWCompletionRoutine Irp %p Ctx %p Status %x\n", Irp, Ctx, Irp->IoStatus.Status);
 
    FDODeviceExtension = (PFDO_DEVICE_EXTENSION)Ctx;
    IoStack = IoGetCurrentIrpStackLocation(Irp);
    Request = IoStack->Parameters.Scsi.Srb;
    PDODeviceExtension = (PPDO_DEVICE_EXTENSION)IoStack->DeviceObject->DeviceExtension;
 
    if (!NT_SUCCESS(Irp->IoStatus.Status))
    {
        goto ResetRecovery;
    }
 
    // a request without the buffer AND not a sense request
    // for a sense request we provide just a TransferBuffer, an Mdl will be allocated by usbport (see below)
    if (!Irp->MdlAddress && Request == FDODeviceExtension->ActiveSrb)
    {
        Request->SrbStatus = SRB_STATUS_SUCCESS;
        USBSTOR_SendCSWRequest(FDODeviceExtension, Irp);
        return STATUS_MORE_PROCESSING_REQUIRED;
    }
 
    // a request with the data buffer
 
    if ((Request->SrbFlags & SRB_FLAGS_UNSPECIFIED_DIRECTION) == SRB_FLAGS_DATA_IN)
    {
        PipeHandle = FDODeviceExtension->InterfaceInformation->Pipes[FDODeviceExtension->BulkInPipeIndex].PipeHandle;
        TransferFlags = USBD_TRANSFER_DIRECTION_IN | USBD_SHORT_TRANSFER_OK;
    }
    else if ((Request->SrbFlags & SRB_FLAGS_UNSPECIFIED_DIRECTION) == SRB_FLAGS_DATA_OUT)
    {
        PipeHandle = FDODeviceExtension->InterfaceInformation->Pipes[FDODeviceExtension->BulkOutPipeIndex].PipeHandle;
        TransferFlags = USBD_TRANSFER_DIRECTION_OUT;
    }
    else
    {
        // we check the validity of a request in disk.c so we should never be here
        DPRINT1("Warning: shouldn't be here\n");
        goto ResetRecovery;
    }
 
    // if it is not a Sense Request
    if (Request == FDODeviceExtension->ActiveSrb)
    {
        if (MmGetMdlVirtualAddress(Irp->MdlAddress) == Request->DataBuffer)
        {
            Mdl = Irp->MdlAddress;
        }
        else
        {
            Mdl = IoAllocateMdl(Request->DataBuffer,
                                Request->DataTransferLength,
                                FALSE,
                                FALSE,
                                NULL);
 
            if (Mdl)
            {
                IoBuildPartialMdl(Irp->MdlAddress,
                                  Mdl,
                                  Request->DataBuffer,
                                  Request->DataTransferLength);
            }
        }
 
        if (!Mdl)
        {
            DPRINT1("USBSTOR_CBWCompletionRoutine: Mdl - %p\n", Mdl);
            goto ResetRecovery;
        }
    }
    else
    {
        ASSERT(Request->DataBuffer);
        TransferBuffer = Request->DataBuffer;
    }
 
    USBSTOR_IssueBulkOrInterruptRequest(FDODeviceExtension,
                                        Irp,
                                        PipeHandle,
                                        TransferFlags,
                                        Request->DataTransferLength,
                                        TransferBuffer,
                                        Mdl,
                                        USBSTOR_DataCompletionRoutine);
 
    return STATUS_MORE_PROCESSING_REQUIRED;
 
ResetRecovery:
    Request = FDODeviceExtension->ActiveSrb;
    IoStack->Parameters.Scsi.Srb = Request;
    Irp->IoStatus.Information = 0;
    Irp->IoStatus.Status = STATUS_IO_DEVICE_ERROR;
    Request->SrbStatus = SRB_STATUS_BUS_RESET;
 
    USBSTOR_QueueTerminateRequest(PDODeviceExtension->LowerDeviceObject, Irp);
    USBSTOR_QueueResetDevice(FDODeviceExtension);
 
    return STATUS_CONTINUE_COMPLETION;
}

USBSTOR_CSWCompletionRoutine()

NTSTATUS NTAPI USBSTOR_CSWCompletionRoutine	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp,
		PVOID	Ctx
	)

Definition at line 129 of file scsi.c.

{
    PIRP_CONTEXT Context;
    PIO_STACK_LOCATION IoStack;
    PPDO_DEVICE_EXTENSION PDODeviceExtension;
    PFDO_DEVICE_EXTENSION FDODeviceExtension;
    PSCSI_REQUEST_BLOCK Request;
 
    DPRINT("USBSTOR_CSWCompletionRoutine Irp %p Ctx %p Status %x\n", Irp, Ctx, Irp->IoStatus.Status);
 
    IoStack = IoGetCurrentIrpStackLocation(Irp);
    PDODeviceExtension = (PPDO_DEVICE_EXTENSION)IoStack->DeviceObject->DeviceExtension;
    FDODeviceExtension = (PFDO_DEVICE_EXTENSION)Ctx;
    Context = &FDODeviceExtension->CurrentIrpContext;
    Request = IoStack->Parameters.Scsi.Srb;
    ASSERT(Request);
 
    // first check for Irp errors
    if (!NT_SUCCESS(Irp->IoStatus.Status))
    {
        if (USBD_STATUS(Context->Urb.UrbHeader.Status) == USBD_STATUS(USBD_STATUS_STALL_PID))
        {
            if (Context->StallRetryCount < 2)
            {
                ++Context->StallRetryCount;
 
                // clear stall and resend cbw
                USBSTOR_QueueResetPipe(FDODeviceExtension);
 
                return STATUS_MORE_PROCESSING_REQUIRED;
            }
        }
        else
        {
            DPRINT1("USBSTOR_CSWCompletionRoutine: Urb.Hdr.Status - %x\n", Context->Urb.UrbHeader.Status);
        }
 
        goto ResetRecovery;
    }
 
    // now check the CSW packet validity
    if (!USBSTOR_IsCSWValid(Context) || Context->csw.Status == CSW_STATUS_PHASE_ERROR)
    {
        goto ResetRecovery;
    }
 
    // finally check for CSW errors
    if (Context->csw.Status == CSW_STATUS_COMMAND_PASSED)
    {
        // should happen only when a sense request was sent
        if (Request != FDODeviceExtension->ActiveSrb)
        {
            ASSERT(IoStack->Parameters.Scsi.Srb == &Context->SenseSrb);
            FDODeviceExtension->ActiveSrb->SenseInfoBufferLength = Request->DataTransferLength;
            Request = FDODeviceExtension->ActiveSrb;
            IoStack->Parameters.Scsi.Srb = Request;
            Request->SrbStatus |= SRB_STATUS_AUTOSENSE_VALID;
        }
 
        Irp->IoStatus.Status = USBSTOR_SrbStatusToNtStatus(Request);
    }
    else if (Context->csw.Status == CSW_STATUS_COMMAND_FAILED)
    {
        // the command is correct but with failed status - issue request sense
        DPRINT("USBSTOR_CSWCompletionRoutine: CSW_STATUS_COMMAND_FAILED\n");
 
        ASSERT(FDODeviceExtension->ActiveSrb == Request);
 
        // setting a generic error status, additional information
        // should be read by higher-level driver from SenseInfoBuffer
        Request->SrbStatus = SRB_STATUS_ERROR;
        Request->ScsiStatus = 2;
        Request->DataTransferLength = 0;
 
        DPRINT("Flags: %x SBL: %x, buf: %p\n", Request->SrbFlags, Request->SenseInfoBufferLength, Request->SenseInfoBuffer);
 
        if (!(Request->SrbFlags & SRB_FLAGS_DISABLE_AUTOSENSE) &&
              Request->SenseInfoBufferLength &&
              Request->SenseInfoBuffer)
        {
            USBSTOR_IssueRequestSense(FDODeviceExtension, Irp);
            return STATUS_MORE_PROCESSING_REQUIRED;
        }
 
        Irp->IoStatus.Status = STATUS_IO_DEVICE_ERROR;
    }
 
    Irp->IoStatus.Information = Request->DataTransferLength;
 
    // terminate current request
    USBSTOR_QueueTerminateRequest(PDODeviceExtension->LowerDeviceObject, Irp);
    USBSTOR_QueueNextRequest(PDODeviceExtension->LowerDeviceObject);
 
    return STATUS_CONTINUE_COMPLETION;
 
ResetRecovery:
 
    Request = FDODeviceExtension->ActiveSrb;
    IoStack->Parameters.Scsi.Srb = Request;
    Irp->IoStatus.Information = 0;
    Irp->IoStatus.Status = STATUS_IO_DEVICE_ERROR;
    Request->SrbStatus = SRB_STATUS_BUS_RESET;
 
    USBSTOR_QueueTerminateRequest(PDODeviceExtension->LowerDeviceObject, Irp);
    USBSTOR_QueueResetDevice(FDODeviceExtension);
 
    return STATUS_CONTINUE_COMPLETION;
}

USBSTOR_DataCompletionRoutine()

NTSTATUS NTAPI USBSTOR_DataCompletionRoutine	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp,
		PVOID	Ctx
	)

Definition at line 260 of file scsi.c.

{
    PIRP_CONTEXT Context;
    PIO_STACK_LOCATION IoStack;
    PSCSI_REQUEST_BLOCK Request;
    PFDO_DEVICE_EXTENSION FDODeviceExtension;
    PPDO_DEVICE_EXTENSION PDODeviceExtension;
 
    DPRINT("USBSTOR_DataCompletionRoutine Irp %p Ctx %p Status %x\n", Irp, Ctx, Irp->IoStatus.Status);
 
    FDODeviceExtension = (PFDO_DEVICE_EXTENSION)Ctx;
    Context = &FDODeviceExtension->CurrentIrpContext;
    IoStack = IoGetCurrentIrpStackLocation(Irp);
    Request = IoStack->Parameters.Scsi.Srb;
    PDODeviceExtension = (PPDO_DEVICE_EXTENSION)IoStack->DeviceObject->DeviceExtension;
 
    // for Sense Request a partial MDL was already freed (if existed)
    if (Request == FDODeviceExtension->ActiveSrb &&
        Context->Urb.UrbBulkOrInterruptTransfer.TransferBufferMDL != Irp->MdlAddress)
    {
        IoFreeMdl(Context->Urb.UrbBulkOrInterruptTransfer.TransferBufferMDL);
    }
 
    if (NT_SUCCESS(Irp->IoStatus.Status))
    {
        if (Context->Urb.UrbBulkOrInterruptTransfer.TransferBufferLength < Request->DataTransferLength)
        {
            Request->SrbStatus = SRB_STATUS_DATA_OVERRUN;
        }
        else
        {
            Request->SrbStatus = SRB_STATUS_SUCCESS;
        }
 
        Request->DataTransferLength = Context->Urb.UrbBulkOrInterruptTransfer.TransferBufferLength;
        USBSTOR_SendCSWRequest(FDODeviceExtension, Irp);
    }
    else if (USBD_STATUS(Context->Urb.UrbHeader.Status) == USBD_STATUS(USBD_STATUS_STALL_PID))
    {
        ++Context->StallRetryCount;
 
        Request->SrbStatus = SRB_STATUS_DATA_OVERRUN;
        Request->DataTransferLength = Context->Urb.UrbBulkOrInterruptTransfer.TransferBufferLength;
 
        // clear stall and resend cbw
        USBSTOR_QueueResetPipe(FDODeviceExtension);
    }
    else
    {
        Irp->IoStatus.Information = 0;
        Irp->IoStatus.Status = STATUS_IO_DEVICE_ERROR;
        Request->SrbStatus = SRB_STATUS_BUS_RESET;
 
        USBSTOR_QueueTerminateRequest(PDODeviceExtension->LowerDeviceObject, Irp);
        USBSTOR_QueueResetDevice(FDODeviceExtension);
 
        return STATUS_CONTINUE_COMPLETION;
    }
 
    return STATUS_MORE_PROCESSING_REQUIRED;
}

USBSTOR_HandleExecuteSCSI()

NTSTATUS USBSTOR_HandleExecuteSCSI	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 542 of file scsi.c.

{
    PIO_STACK_LOCATION IoStack;
    PSCSI_REQUEST_BLOCK Request;
    PPDO_DEVICE_EXTENSION PDODeviceExtension = (PPDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
 
    ASSERT(PDODeviceExtension->Common.IsFDO == FALSE);
 
    IoStack = IoGetCurrentIrpStackLocation(Irp);
    Request = IoStack->Parameters.Scsi.Srb;
 
    DPRINT("USBSTOR_HandleExecuteSCSI Operation Code %x, Length %lu\n", SrbGetCdb(Request)->CDB10.OperationCode, Request->DataTransferLength);
 
    /*
     * Some stacks/devices don’t propagate the LUN in the CDB10 header bits.
     * USB BOT uses CBW.bCBWLUN for addressing.
     *
     * TODO: There's actually a bigger bug here though,
     * while the above CAN HAPPPEN:
     * Card Readers multiplex their card slots for example, but we can deal with
     * that as we put more effort into fixing the USB stack.
     */
    if (SrbGetCdb(Request)->CDB10.LogicalUnitNumber != PDODeviceExtension->LUN)
    {
        DPRINT1("USBSTOR_HandleExecuteSCSI: CDB LUN %lu != PDO LUN %lu (using CBW LUN)\n",
                (ULONG)SrbGetCdb(Request)->CDB10.LogicalUnitNumber,
                (ULONG)PDODeviceExtension->LUN);
    }
 
    return USBSTOR_SendCBWRequest(PDODeviceExtension->LowerDeviceObject->DeviceExtension, Irp);
}

Referenced by USBSTOR_HandleTransferError(), and USBSTOR_StartIo().

USBSTOR_IsCSWValid()

static BOOLEAN USBSTOR_IsCSWValid ( PIRP_CONTEXT  Context )

static

Definition at line 101 of file scsi.c.

{
    if (Context->csw.Signature != CSW_SIGNATURE)
    {
        DPRINT1("[USBSTOR] Expected Signature %x but got %x\n", CSW_SIGNATURE, Context->csw.Signature);
        return FALSE;
    }
 
    if (Context->csw.Tag != PtrToUlong(Context->Irp))
    {
        DPRINT1("[USBSTOR] Expected Tag %Ix but got %x\n", PtrToUlong(Context->Irp), Context->csw.Tag);
        return FALSE;
    }
 
    return TRUE;
}

Referenced by USBSTOR_CSWCompletionRoutine().

USBSTOR_IssueBulkOrInterruptRequest()

static NTSTATUS USBSTOR_IssueBulkOrInterruptRequest ( IN PFDO_DEVICE_EXTENSION  FDODeviceExtension, IN PIRP  Irp, IN USBD_PIPE_HANDLE  PipeHandle, IN ULONG  TransferFlags, IN ULONG  TransferBufferLength, IN PVOID  TransferBuffer, IN PMDL  TransferBufferMDL, IN PIO_COMPLETION_ROUTINE  CompletionRoutine  )

static

Definition at line 60 of file scsi.c.

{
    PIO_STACK_LOCATION NextStack;
    PIRP_CONTEXT Context = &FDODeviceExtension->CurrentIrpContext;
 
    RtlZeroMemory(&Context->Urb, sizeof(struct _URB_BULK_OR_INTERRUPT_TRANSFER));
 
    Context->Urb.UrbHeader.Length = sizeof(struct _URB_BULK_OR_INTERRUPT_TRANSFER);
    Context->Urb.UrbHeader.Function = URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER;
 
    Context->Urb.UrbBulkOrInterruptTransfer.PipeHandle = PipeHandle;
    Context->Urb.UrbBulkOrInterruptTransfer.TransferFlags = TransferFlags;
    Context->Urb.UrbBulkOrInterruptTransfer.TransferBufferLength = TransferBufferLength;
    Context->Urb.UrbBulkOrInterruptTransfer.TransferBuffer = TransferBuffer;
    Context->Urb.UrbBulkOrInterruptTransfer.TransferBufferMDL = TransferBufferMDL;
 
    NextStack = IoGetNextIrpStackLocation(Irp);
    NextStack->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL;
    NextStack->Parameters.DeviceIoControl.IoControlCode = IOCTL_INTERNAL_USB_SUBMIT_URB;
    NextStack->Parameters.Others.Argument1 = &Context->Urb;
 
    IoSetCompletionRoutine(Irp,
                           CompletionRoutine,
                           FDODeviceExtension,
                           TRUE,
                           TRUE,
                           TRUE);
 
    return IoCallDriver(FDODeviceExtension->LowerDeviceObject, Irp);
}

Referenced by USBSTOR_CBWCompletionRoutine(), USBSTOR_SendCBWRequest(), and USBSTOR_SendCSWRequest().

USBSTOR_IssueRequestSense()

static NTSTATUS USBSTOR_IssueRequestSense ( IN PFDO_DEVICE_EXTENSION  FDODeviceExtension, IN PIRP  Irp  )

static

Definition at line 504 of file scsi.c.

{
    PIO_STACK_LOCATION IoStack;
    PSCSI_REQUEST_BLOCK CurrentSrb;
    PSCSI_REQUEST_BLOCK SenseSrb;
 
    DPRINT("USBSTOR_IssueRequestSense: \n");
 
    CurrentSrb = FDODeviceExtension->ActiveSrb;
    SenseSrb = &FDODeviceExtension->CurrentIrpContext.SenseSrb;
    IoStack = IoGetCurrentIrpStackLocation(Irp);
    IoStack->Parameters.Scsi.Srb = SenseSrb;
 
    RtlZeroMemory(SenseSrb, sizeof(*SenseSrb));
 
    SenseSrb->Function = SRB_FUNCTION_EXECUTE_SCSI;
    SenseSrb->Length = sizeof(*SenseSrb);
    SenseSrb->CdbLength = CDB6GENERIC_LENGTH;
    SenseSrb->SrbFlags = SRB_FLAGS_DATA_IN |
                         SRB_FLAGS_NO_QUEUE_FREEZE |
                         SRB_FLAGS_DISABLE_AUTOSENSE;
 
    ASSERT(CurrentSrb->SenseInfoBufferLength);
    ASSERT(CurrentSrb->SenseInfoBuffer);
    DPRINT("SenseInfoBuffer %x, SenseInfoBufferLength %x\n", CurrentSrb->SenseInfoBuffer, CurrentSrb->SenseInfoBufferLength);
 
    SenseSrb->DataTransferLength = CurrentSrb->SenseInfoBufferLength;
    SenseSrb->DataBuffer = CurrentSrb->SenseInfoBuffer;
 
    SrbGetCdb(SenseSrb)->CDB6GENERIC.OperationCode = SCSIOP_REQUEST_SENSE;
    SrbGetCdb(SenseSrb)->AsByte[4] = CurrentSrb->SenseInfoBufferLength;
 
    return USBSTOR_SendCBWRequest(FDODeviceExtension, Irp);
}

Referenced by USBSTOR_CSWCompletionRoutine().

USBSTOR_SendCBWRequest()

static NTSTATUS USBSTOR_SendCBWRequest ( IN PFDO_DEVICE_EXTENSION  FDODeviceExtension, IN PIRP  Irp  )

static

Definition at line 456 of file scsi.c.

{
    PPDO_DEVICE_EXTENSION PDODeviceExtension;
    PIO_STACK_LOCATION IoStack;
    PSCSI_REQUEST_BLOCK Request;
    PIRP_CONTEXT Context = &FDODeviceExtension->CurrentIrpContext;
 
    RtlZeroMemory(&Context->cbw, sizeof(CBW));
    RtlZeroMemory(&Context->Urb, sizeof(URB));
 
    IoStack = IoGetCurrentIrpStackLocation(Irp);
    PDODeviceExtension = IoStack->DeviceObject->DeviceExtension;
    Request = IoStack->Parameters.Scsi.Srb;
 
    // Make a CBW structure from SCSI request block
    Context->cbw.Signature = CBW_SIGNATURE;
    Context->cbw.Tag = PtrToUlong(Irp);
    Context->cbw.DataTransferLength = Request->DataTransferLength;
    Context->cbw.Flags = ((UCHAR)Request->SrbFlags & SRB_FLAGS_UNSPECIFIED_DIRECTION) << 1;
 
    // Per Bulk Only Transfer, LUN is 4 bits; clamp just in case
    Context->cbw.LUN = (UCHAR)(PDODeviceExtension->LUN & 0x0F);
    Context->cbw.CommandBlockLength = Request->CdbLength;
 
    RtlCopyMemory(&Context->cbw.CommandBlock, Request->Cdb, Request->CdbLength);
 
    DPRINT("CBW for IRP %p\n", Irp);
    DumpCBW((PUCHAR)&Context->cbw);
 
    // initialize rest of context
    Context->Irp = Irp;
    Context->StallRetryCount = 0;
 
    return USBSTOR_IssueBulkOrInterruptRequest(
        FDODeviceExtension,
        Irp,
        FDODeviceExtension->InterfaceInformation->Pipes[FDODeviceExtension->BulkOutPipeIndex].PipeHandle,
        USBD_TRANSFER_DIRECTION_OUT,
        sizeof(CBW),
        &Context->cbw,
        NULL,
        USBSTOR_CBWCompletionRoutine);
}

Referenced by USBSTOR_HandleExecuteSCSI(), and USBSTOR_IssueRequestSense().

USBSTOR_SendCSWRequest()

NTSTATUS USBSTOR_SendCSWRequest	(	PFDO_DEVICE_EXTENSION	FDODeviceExtension,
		PIRP	Irp
	)

Definition at line 242 of file scsi.c.

{
    return USBSTOR_IssueBulkOrInterruptRequest(FDODeviceExtension,
                                               Irp,
                                               FDODeviceExtension->InterfaceInformation->Pipes[FDODeviceExtension->BulkInPipeIndex].PipeHandle,
                                               USBD_TRANSFER_DIRECTION_IN,
                                               sizeof(CSW),
                                               &FDODeviceExtension->CurrentIrpContext.csw,
                                               NULL,
                                               USBSTOR_CSWCompletionRoutine);
}

Referenced by USBSTOR_CBWCompletionRoutine(), USBSTOR_DataCompletionRoutine(), and USBSTOR_ResetPipeWorkItemRoutine().

USBSTOR_SrbStatusToNtStatus()

static NTSTATUS USBSTOR_SrbStatusToNtStatus ( IN PSCSI_REQUEST_BLOCK  Srb )

static

Definition at line 20 of file scsi.c.

{
    UCHAR SrbStatus;
 
    SrbStatus = SRB_STATUS(Srb->SrbStatus);
 
    switch (SrbStatus)
    {
        case SRB_STATUS_SUCCESS:
            return STATUS_SUCCESS;
 
        case SRB_STATUS_DATA_OVERRUN:
            return STATUS_BUFFER_OVERFLOW;
 
        case SRB_STATUS_BAD_FUNCTION:
        case SRB_STATUS_BAD_SRB_BLOCK_LENGTH:
            return STATUS_INVALID_DEVICE_REQUEST;
 
        case SRB_STATUS_INVALID_LUN:
        case SRB_STATUS_INVALID_TARGET_ID:
        case SRB_STATUS_NO_HBA:
        case SRB_STATUS_NO_DEVICE:
            return STATUS_DEVICE_DOES_NOT_EXIST;
 
        case SRB_STATUS_TIMEOUT:
            return STATUS_IO_TIMEOUT;
 
        case SRB_STATUS_BUS_RESET:
        case SRB_STATUS_COMMAND_TIMEOUT:
        case SRB_STATUS_SELECTION_TIMEOUT:
            return STATUS_DEVICE_NOT_CONNECTED;
 
        default:
            return STATUS_IO_DEVICE_ERROR;
    }
}

Referenced by USBSTOR_CSWCompletionRoutine().

Variable Documentation

USBSTOR_CBWCompletionRoutine

IO_COMPLETION_ROUTINE USBSTOR_CBWCompletionRoutine

Definition at line 325 of file scsi.c.

Referenced by USBSTOR_SendCBW(), and USBSTOR_SendCBWRequest().

USBSTOR_CSWCompletionRoutine

IO_COMPLETION_ROUTINE USBSTOR_CSWCompletionRoutine

Definition at line 125 of file scsi.c.

Referenced by USBSTOR_CBWCompletionRoutine(), USBSTOR_SendCSW(), and USBSTOR_SendCSWRequest().

USBSTOR_DataCompletionRoutine

IO_COMPLETION_ROUTINE USBSTOR_DataCompletionRoutine

Definition at line 256 of file scsi.c.

Referenced by USBSTOR_CBWCompletionRoutine().