usbstor.h File Reference

#include <wdm.h>
#include <usbdi.h>
#include <usbbusif.h>
#include <usbdlib.h>
#include <classpnp.h>
#include <pshpack1.h>
#include <poppack.h>

Include dependency graph for usbstor.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	__COMMON_DEVICE_EXTENSION__
struct	FDO_DEVICE_EXTENSION
struct	PDO_DEVICE_EXTENSION
struct	CBW
struct	CSW
struct	UFI_INQUIRY_CMD
struct	UFI_INQUIRY_RESPONSE
struct	UFI_READ_WRITE_CMD
struct	UFI_CAPACITY_CMD
struct	UFI_CAPACITY_RESPONSE
struct	UFI_SENSE_CMD
struct	UFI_MODE_PARAMETER_HEADER
struct	UFI_TIMER_PROTECT_PAGE
struct	UFI_READ_FORMAT_CAPACITY
struct	UFI_CAPACITY_FORMAT_HEADER
struct	UFI_CAPACITY_DESCRIPTOR
struct	UFI_TEST_UNIT_CMD
struct	UFI_UNKNOWN_CMD
struct	IRP_CONTEXT
struct	_ERRORHANDLER_WORKITEM_DATA

Macros
#define	USB_STOR_TAG   'sbsu'
#define	USB_MAXCHILDREN   (16)
#define	HTONS(n)   (((((unsigned short)(n) & 0xFF)) << 8) | (((unsigned short)(n) & 0xFF00) >> 8))
#define	NTOHS(n)   (((((unsigned short)(n) & 0xFF)) << 8) | (((unsigned short)(n) & 0xFF00) >> 8))
#define	HTONL(n)
#define	NTOHL(n)
#define	USB_RECOVERABLE_ERRORS
#define	USB_BULK_GET_MAX_LUN   0xFE
#define	USB_BULK_RESET_DEVICE   0xFF
#define	CBW_SIGNATURE   0x43425355
#define	CSW_SIGNATURE   0x53425355
#define	MAX_LUN   0xF
#define	UFI_INQUIRY_CMD_LEN   0x6
#define	UFI_READ_WRITE_CMD_LEN   (0xA)
#define	UFI_CAPACITY_CMD_LEN   0xA
#define	UFI_READ_CAPACITY_CMD_LEN   0xA
#define	UFI_SENSE_CMD_LEN   (6)
#define	UFI_READ_FORMAT_CAPACITY_CMD_LEN   (10)
#define	UNFORMATTED_MEDIA_CODE_DESCRIPTORY_TYPE   (1)
#define	FORMAT_MEDIA_CODE_DESCRIPTOR_TYPE   (2)
#define	CARTRIDGE_MEDIA_CODE_DESCRIPTOR_TYPE   (3)
#define	UFI_TEST_UNIT_CMD_LEN   (6)

Typedefs
typedef struct __COMMON_DEVICE_EXTENSION__	USBSTOR_COMMON_DEVICE_EXTENSION
typedef struct __COMMON_DEVICE_EXTENSION__ *	PUSBSTOR_COMMON_DEVICE_EXTENSION
typedef struct FDO_DEVICE_EXTENSION *	PFDO_DEVICE_EXTENSION
typedef struct PDO_DEVICE_EXTENSION *	PPDO_DEVICE_EXTENSION
typedef struct CBW *	PCBW
typedef struct CSW *	PCSW
typedef struct UFI_INQUIRY_CMD *	PUFI_INQUIRY_CMD
typedef struct UFI_INQUIRY_RESPONSE *	PUFI_INQUIRY_RESPONSE
typedef struct UFI_CAPACITY_CMD *	PUFI_CAPACITY_CMD
typedef struct UFI_CAPACITY_RESPONSE *	PUFI_CAPACITY_RESPONSE
typedef struct UFI_SENSE_CMD *	PUFI_SENSE_CMD
typedef struct UFI_MODE_PARAMETER_HEADER *	PUFI_MODE_PARAMETER_HEADER
typedef struct UFI_TIMER_PROTECT_PAGE *	PUFI_TIMER_PROTECT_PAGE
typedef struct UFI_READ_FORMAT_CAPACITY *	PUFI_READ_FORMAT_CAPACITY
typedef struct UFI_CAPACITY_FORMAT_HEADER *	PUFI_CAPACITY_FORMAT_HEADER
typedef struct UFI_CAPACITY_DESCRIPTOR *	PUFI_CAPACITY_DESCRIPTOR
typedef struct UFI_TEST_UNIT_CMD *	PUFI_TEST_UNIT_CMD
typedef struct UFI_UNKNOWN_CMD *	PUFI_UNKNOWN_CMD
typedef struct IRP_CONTEXT *	PIRP_CONTEXT
typedef struct _ERRORHANDLER_WORKITEM_DATA	ERRORHANDLER_WORKITEM_DATA
typedef struct _ERRORHANDLER_WORKITEM_DATA *	PERRORHANDLER_WORKITEM_DATA

Functions
	C_ASSERT (sizeof(CBW)==31)
	C_ASSERT (sizeof(UFI_INQUIRY_CMD)==12)
	C_ASSERT (sizeof(UFI_INQUIRY_RESPONSE)==36)
	C_ASSERT (sizeof(UFI_READ_WRITE_CMD)==12)
	C_ASSERT (sizeof(UFI_CAPACITY_CMD)==12)
	C_ASSERT (sizeof(UFI_CAPACITY_RESPONSE)==8)
	C_ASSERT (sizeof(UFI_SENSE_CMD)==12)
	C_ASSERT (sizeof(UFI_MODE_PARAMETER_HEADER)==8)
	C_ASSERT (sizeof(UFI_TIMER_PROTECT_PAGE)==8)
	C_ASSERT (sizeof(UFI_READ_FORMAT_CAPACITY)==12)
	C_ASSERT (sizeof(UFI_CAPACITY_FORMAT_HEADER)==4)
	C_ASSERT (sizeof(UFI_TEST_UNIT_CMD)==12)
NTSTATUS	USBSTOR_FdoHandlePnp (IN PDEVICE_OBJECT DeviceObject, IN OUT PIRP Irp)
NTSTATUS	USBSTOR_PdoHandlePnp (IN PDEVICE_OBJECT DeviceObject, IN OUT PIRP Irp)
NTSTATUS	USBSTOR_CreatePDO (IN PDEVICE_OBJECT DeviceObject, IN UCHAR LUN)
NTSTATUS NTAPI	USBSTOR_SyncForwardIrp (IN PDEVICE_OBJECT DeviceObject, IN OUT PIRP Irp)
NTSTATUS NTAPI	USBSTOR_GetBusInterface (IN PDEVICE_OBJECT DeviceObject, OUT PUSB_BUS_INTERFACE_USBDI_V2 BusInterface)
PVOID	AllocateItem (IN POOL_TYPE PoolType, IN ULONG ItemSize)
VOID	FreeItem (IN PVOID Item)
NTSTATUS	USBSTOR_SyncUrbRequest (IN PDEVICE_OBJECT DeviceObject, OUT PURB UrbRequest)
NTSTATUS	USBSTOR_GetMaxLUN (IN PDEVICE_OBJECT DeviceObject, IN PFDO_DEVICE_EXTENSION DeviceExtension)
NTSTATUS NTAPI	USBSTOR_SyncForwardIrpCompletionRoutine (PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID Context)
NTSTATUS	USBSTOR_ResetDevice (IN PDEVICE_OBJECT DeviceObject, IN PFDO_DEVICE_EXTENSION DeviceExtension)
BOOLEAN	USBSTOR_IsFloppy (IN PUCHAR Buffer, IN ULONG BufferLength, OUT PUCHAR MediumTypeCode)
NTSTATUS	USBSTOR_GetDescriptors (IN PDEVICE_OBJECT DeviceObject)
NTSTATUS	USBSTOR_SelectConfigurationAndInterface (IN PDEVICE_OBJECT DeviceObject, IN PFDO_DEVICE_EXTENSION DeviceExtension)
NTSTATUS	USBSTOR_GetPipeHandles (IN PFDO_DEVICE_EXTENSION DeviceExtension)
NTSTATUS	USBSTOR_HandleExecuteSCSI (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN ULONG RetryCount)
NTSTATUS NTAPI	USBSTOR_CSWCompletionRoutine (PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID Ctx)
NTSTATUS	USBSTOR_SendCBW (PIRP_CONTEXT Context, PIRP Irp)
VOID	USBSTOR_SendCSW (PIRP_CONTEXT Context, PIRP Irp)
NTSTATUS	USBSTOR_HandleInternalDeviceControl (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	USBSTOR_HandleDeviceControl (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
VOID NTAPI	USBSTOR_StartIo (PDEVICE_OBJECT DeviceObject, PIRP Irp)
VOID	USBSTOR_QueueWaitForPendingRequests (IN PDEVICE_OBJECT DeviceObject)
VOID	USBSTOR_QueueRelease (IN PDEVICE_OBJECT DeviceObject)
BOOLEAN	USBSTOR_QueueAddIrp (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
VOID NTAPI	USBSTOR_CancelIo (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
VOID	USBSTOR_QueueInitialize (PFDO_DEVICE_EXTENSION FDODeviceExtension)
VOID NTAPI	ErrorHandlerWorkItemRoutine (PVOID Context)
VOID NTAPI	ResetHandlerWorkItemRoutine (PVOID Context)
VOID	USBSTOR_QueueNextRequest (IN PDEVICE_OBJECT DeviceObject)
VOID	USBSTOR_QueueTerminateRequest (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	USBSTOR_GetEndpointStatus (IN PDEVICE_OBJECT DeviceObject, IN UCHAR bEndpointAddress, OUT PUSHORT Value)
NTSTATUS	USBSTOR_ResetPipeWithHandle (IN PDEVICE_OBJECT DeviceObject, IN USBD_PIPE_HANDLE PipeHandle)
VOID NTAPI	USBSTOR_TimerRoutine (PDEVICE_OBJECT DeviceObject, PVOID Context)

Macro Definition Documentation

CARTRIDGE_MEDIA_CODE_DESCRIPTOR_TYPE

#define CARTRIDGE_MEDIA_CODE_DESCRIPTOR_TYPE   (3)

Definition at line 288 of file usbstor.h.

CBW_SIGNATURE

#define CBW_SIGNATURE   0x43425355

Definition at line 103 of file usbstor.h.

CSW_SIGNATURE

#define CSW_SIGNATURE   0x53425355

Definition at line 104 of file usbstor.h.

FORMAT_MEDIA_CODE_DESCRIPTOR_TYPE

#define FORMAT_MEDIA_CODE_DESCRIPTOR_TYPE   (2)

Definition at line 287 of file usbstor.h.

HTONL

#define HTONL

(

n

)

Value:

                  (((((unsigned long)(n) & 0xFF)) << 24) | \
                  ((((unsigned long)(n) & 0xFF00)) << 8) | \
                  ((((unsigned long)(n) & 0xFF0000)) >> 8) | \
                  ((((unsigned long)(n) & 0xFF000000)) >> 24))

Definition at line 16 of file usbstor.h.

HTONS

#define HTONS

(

n

)

(((((unsigned short)(n) & 0xFF)) << 8) | (((unsigned short)(n) & 0xFF00) >> 8))

Definition at line 13 of file usbstor.h.

MAX_LUN

#define MAX_LUN   0xF

Definition at line 106 of file usbstor.h.

NTOHL

#define NTOHL

(

n

)

Value:

                  (((((unsigned long)(n) & 0xFF)) << 24) | \
                  ((((unsigned long)(n) & 0xFF00)) << 8) | \
                  ((((unsigned long)(n) & 0xFF0000)) >> 8) | \
                  ((((unsigned long)(n) & 0xFF000000)) >> 24))

Definition at line 22 of file usbstor.h.

NTOHS

#define NTOHS

(

n

)

(((((unsigned short)(n) & 0xFF)) << 8) | (((unsigned short)(n) & 0xFF00) >> 8))

Definition at line 14 of file usbstor.h.

UFI_CAPACITY_CMD_LEN

#define UFI_CAPACITY_CMD_LEN   0xA

Definition at line 190 of file usbstor.h.

UFI_INQUIRY_CMD_LEN

#define UFI_INQUIRY_CMD_LEN   0x6

Definition at line 132 of file usbstor.h.

UFI_READ_CAPACITY_CMD_LEN

#define UFI_READ_CAPACITY_CMD_LEN   0xA

Definition at line 201 of file usbstor.h.

UFI_READ_FORMAT_CAPACITY_CMD_LEN

#define UFI_READ_FORMAT_CAPACITY_CMD_LEN   (10)

Definition at line 265 of file usbstor.h.

UFI_READ_WRITE_CMD_LEN

#define UFI_READ_WRITE_CMD_LEN   (0xA)

Definition at line 172 of file usbstor.h.

UFI_SENSE_CMD_LEN

#define UFI_SENSE_CMD_LEN   (6)

Definition at line 221 of file usbstor.h.

UFI_TEST_UNIT_CMD_LEN

#define UFI_TEST_UNIT_CMD_LEN   (6)

Definition at line 307 of file usbstor.h.

UNFORMATTED_MEDIA_CODE_DESCRIPTORY_TYPE

#define UNFORMATTED_MEDIA_CODE_DESCRIPTORY_TYPE   (1)

Definition at line 286 of file usbstor.h.

USB_BULK_GET_MAX_LUN

#define USB_BULK_GET_MAX_LUN   0xFE

Definition at line 85 of file usbstor.h.

USB_BULK_RESET_DEVICE

#define USB_BULK_RESET_DEVICE   0xFF

Definition at line 86 of file usbstor.h.

USB_MAXCHILDREN

#define USB_MAXCHILDREN   (16)

Definition at line 11 of file usbstor.h.

USB_RECOVERABLE_ERRORS

#define USB_RECOVERABLE_ERRORS

Value:

    (USBD_STATUS_STALL_PID | USBD_STATUS_DEV_NOT_RESPONDING \
    | USBD_STATUS_ENDPOINT_HALTED | USBD_STATUS_NO_BANDWIDTH)

Definition at line 27 of file usbstor.h.

USB_STOR_TAG

#define USB_STOR_TAG   'sbsu'

Definition at line 10 of file usbstor.h.

Typedef Documentation

ERRORHANDLER_WORKITEM_DATA

typedef struct _ERRORHANDLER_WORKITEM_DATA ERRORHANDLER_WORKITEM_DATA

PCBW

typedef struct CBW * PCBW

PCSW

typedef struct CSW * PCSW

PERRORHANDLER_WORKITEM_DATA

typedef struct _ERRORHANDLER_WORKITEM_DATA * PERRORHANDLER_WORKITEM_DATA

PFDO_DEVICE_EXTENSION

typedef struct FDO_DEVICE_EXTENSION * PFDO_DEVICE_EXTENSION

PIRP_CONTEXT

typedef struct IRP_CONTEXT * PIRP_CONTEXT

PPDO_DEVICE_EXTENSION

typedef struct PDO_DEVICE_EXTENSION * PPDO_DEVICE_EXTENSION

PUFI_CAPACITY_CMD

typedef struct UFI_CAPACITY_CMD * PUFI_CAPACITY_CMD

PUFI_CAPACITY_DESCRIPTOR

typedef struct UFI_CAPACITY_DESCRIPTOR * PUFI_CAPACITY_DESCRIPTOR

PUFI_CAPACITY_FORMAT_HEADER

typedef struct UFI_CAPACITY_FORMAT_HEADER * PUFI_CAPACITY_FORMAT_HEADER

PUFI_CAPACITY_RESPONSE

typedef struct UFI_CAPACITY_RESPONSE * PUFI_CAPACITY_RESPONSE

PUFI_INQUIRY_CMD

typedef struct UFI_INQUIRY_CMD * PUFI_INQUIRY_CMD

PUFI_INQUIRY_RESPONSE

typedef struct UFI_INQUIRY_RESPONSE * PUFI_INQUIRY_RESPONSE

PUFI_MODE_PARAMETER_HEADER

typedef struct UFI_MODE_PARAMETER_HEADER * PUFI_MODE_PARAMETER_HEADER

PUFI_READ_FORMAT_CAPACITY

typedef struct UFI_READ_FORMAT_CAPACITY * PUFI_READ_FORMAT_CAPACITY

PUFI_SENSE_CMD

typedef struct UFI_SENSE_CMD * PUFI_SENSE_CMD

PUFI_TEST_UNIT_CMD

typedef struct UFI_TEST_UNIT_CMD * PUFI_TEST_UNIT_CMD

PUFI_TIMER_PROTECT_PAGE

typedef struct UFI_TIMER_PROTECT_PAGE * PUFI_TIMER_PROTECT_PAGE

PUFI_UNKNOWN_CMD

typedef struct UFI_UNKNOWN_CMD * PUFI_UNKNOWN_CMD

PUSBSTOR_COMMON_DEVICE_EXTENSION

typedef struct __COMMON_DEVICE_EXTENSION__ * PUSBSTOR_COMMON_DEVICE_EXTENSION

USBSTOR_COMMON_DEVICE_EXTENSION

typedef struct __COMMON_DEVICE_EXTENSION__ USBSTOR_COMMON_DEVICE_EXTENSION

Function Documentation

AllocateItem()

PVOID AllocateItem	(	IN POOL_TYPE	PoolType,
		IN ULONG	ItemSize
	)

Definition at line 29 of file misc.c.

{
    return ExAllocatePoolZero(PoolType, NumberOfBytes, TAG_KS);
}

C_ASSERT() [1/12]

C_ASSERT

(

sizeof(CBW)

= =31

)

C_ASSERT() [2/12]

C_ASSERT

(

sizeof(UFI_CAPACITY_CMD)

= =12

)

C_ASSERT() [3/12]

C_ASSERT

(

sizeof(UFI_CAPACITY_FORMAT_HEADER)

= =4

)

C_ASSERT() [4/12]

C_ASSERT

(

sizeof(UFI_CAPACITY_RESPONSE)

= =8

)

C_ASSERT() [5/12]

C_ASSERT

(

sizeof(UFI_INQUIRY_CMD)

= =12

)

C_ASSERT() [6/12]

C_ASSERT

(

sizeof(UFI_INQUIRY_RESPONSE)

= =36

)

C_ASSERT() [7/12]

C_ASSERT

(

sizeof(UFI_MODE_PARAMETER_HEADER)

= =8

)

C_ASSERT() [8/12]

C_ASSERT

(

sizeof(UFI_READ_FORMAT_CAPACITY)

= =12

)

C_ASSERT() [9/12]

C_ASSERT

(

sizeof(UFI_READ_WRITE_CMD)

= =12

)

C_ASSERT() [10/12]

C_ASSERT

(

sizeof(UFI_SENSE_CMD)

= =12

)

C_ASSERT() [11/12]

C_ASSERT

(

sizeof(UFI_TEST_UNIT_CMD)

= =12

)

C_ASSERT() [12/12]

C_ASSERT

(

sizeof(UFI_TIMER_PROTECT_PAGE)

= =8

)

ErrorHandlerWorkItemRoutine()

VOID NTAPI ErrorHandlerWorkItemRoutine

(

PVOID

Context

)

Definition at line 248 of file error.c.

{
    PERRORHANDLER_WORKITEM_DATA WorkItemData = (PERRORHANDLER_WORKITEM_DATA)Context;
 
    if (WorkItemData->Context->ErrorIndex == 2)
    {
        //
        // reset device
        //
        USBSTOR_HandleTransferError(WorkItemData->DeviceObject, WorkItemData->Context);
    }
    else
    {
        //
        // clear stall
        //
        USBSTOR_ResetHandlerWorkItemRoutine(WorkItemData);
    }
 
    //
    // Free Work Item Data
    //
    ExFreePoolWithTag(WorkItemData, USB_STOR_TAG);
}

Referenced by USBSTOR_QueueWorkItem().

FreeItem()

VOID FreeItem

(

IN PVOID

Item

)

Definition at line 37 of file misc.c.

{
    ExFreePoolWithTag(Item, TAG_KS);
}

ResetHandlerWorkItemRoutine()

VOID NTAPI ResetHandlerWorkItemRoutine

(

PVOID

Context

)

USBSTOR_CancelIo()

VOID NTAPI USBSTOR_CancelIo	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 28 of file queue.c.

{
    PFDO_DEVICE_EXTENSION FDODeviceExtension;
 
    FDODeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    ASSERT_IRQL_EQUAL(DISPATCH_LEVEL);
    ASSERT(FDODeviceExtension->Common.IsFDO);
 
    // this IRP isn't in our list here
    // now release the cancel lock
    IoReleaseCancelSpinLock(Irp->CancelIrql);
    Irp->IoStatus.Status = STATUS_CANCELLED;
 
    USBSTOR_QueueTerminateRequest(DeviceObject, Irp);
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    USBSTOR_QueueNextRequest(DeviceObject);
}

Referenced by USBSTOR_HandleInternalDeviceControl(), USBSTOR_QueueAddIrp(), USBSTOR_QueueNextRequest(), and USBSTOR_QueueRelease().

USBSTOR_CreatePDO()

NTSTATUS USBSTOR_CreatePDO	(	IN PDEVICE_OBJECT	DeviceObject,
		IN UCHAR	LUN
	)

Definition at line 864 of file pdo.c.

{
    PDEVICE_OBJECT PDO;
    NTSTATUS Status;
    PPDO_DEVICE_EXTENSION PDODeviceExtension;
    PFDO_DEVICE_EXTENSION FDODeviceExtension;
    PINQUIRYDATA InquiryData;
 
    FDODeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
 
    // create child device object
    Status = IoCreateDevice(DeviceObject->DriverObject, sizeof(PDO_DEVICE_EXTENSION), NULL, FILE_DEVICE_MASS_STORAGE, FILE_AUTOGENERATED_DEVICE_NAME | FILE_DEVICE_SECURE_OPEN, FALSE, &PDO);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to create PDO, status %x\n", Status);
        return Status;
    }
 
    // patch the stack size
    PDO->StackSize = DeviceObject->StackSize;
 
    PDODeviceExtension = (PPDO_DEVICE_EXTENSION)PDO->DeviceExtension;
    InquiryData = (PINQUIRYDATA)&PDODeviceExtension->InquiryData;
 
    // initialize device extension
    RtlZeroMemory(PDODeviceExtension, sizeof(PDO_DEVICE_EXTENSION));
    PDODeviceExtension->Common.IsFDO = FALSE;
    PDODeviceExtension->LowerDeviceObject = DeviceObject;
    PDODeviceExtension->PDODeviceObject = &FDODeviceExtension->ChildPDO[LUN];
    PDODeviceExtension->Self = PDO;
    PDODeviceExtension->LUN = LUN;
 
    PDO->Flags |= DO_DIRECT_IO;
 
    // device is initialized
    PDO->Flags &= ~DO_DEVICE_INITIALIZING;
 
    // output device object
    FDODeviceExtension->ChildPDO[LUN] = PDO;
 
    // send inquiry command by irp
    Status = USBSTOR_FillInquiryData(PDO);
 
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    if (InquiryData->DeviceType != DIRECT_ACCESS_DEVICE &&
        InquiryData->DeviceType != READ_ONLY_DIRECT_ACCESS_DEVICE)
    {
        return STATUS_NOT_SUPPORTED;
    }
 
    return Status;
}

Referenced by USBSTOR_FdoHandleStartDevice().

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_FdoHandlePnp()

NTSTATUS USBSTOR_FdoHandlePnp	(	IN PDEVICE_OBJECT	DeviceObject,
		IN OUT PIRP	Irp
	)

Definition at line 282 of file fdo.c.

{
    PIO_STACK_LOCATION IoStack;
    PFDO_DEVICE_EXTENSION DeviceExtension;
    NTSTATUS Status;
 
    IoStack = IoGetCurrentIrpStackLocation(Irp);
    DeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    ASSERT(DeviceExtension->Common.IsFDO);
 
    switch(IoStack->MinorFunction)
    {
        case IRP_MN_SURPRISE_REMOVAL:
        {
            DPRINT("IRP_MN_SURPRISE_REMOVAL %p\n", DeviceObject);
            Irp->IoStatus.Status = STATUS_SUCCESS;
 
            // forward irp to next device object
            IoSkipCurrentIrpStackLocation(Irp);
            return IoCallDriver(DeviceExtension->LowerDeviceObject, Irp);
        }
        case IRP_MN_QUERY_DEVICE_RELATIONS:
        {
            DPRINT("IRP_MN_QUERY_DEVICE_RELATIONS %p Type: %u\n", DeviceObject, IoStack->Parameters.QueryDeviceRelations.Type);
            return USBSTOR_FdoHandleDeviceRelations(DeviceExtension, Irp);
        }
        case IRP_MN_STOP_DEVICE:
        {
            DPRINT1("USBSTOR_FdoHandlePnp: IRP_MN_STOP_DEVICE unimplemented\n");
            IoStopTimer(DeviceObject);
            Irp->IoStatus.Status = STATUS_SUCCESS;
 
            // forward irp to next device object
            IoSkipCurrentIrpStackLocation(Irp);
            return IoCallDriver(DeviceExtension->LowerDeviceObject, Irp);
        }
        case IRP_MN_REMOVE_DEVICE:
        {
            DPRINT("IRP_MN_REMOVE_DEVICE\n");
 
            return USBSTOR_FdoHandleRemoveDevice(DeviceObject, DeviceExtension, Irp);
        }
        case IRP_MN_QUERY_CAPABILITIES:
        {
            // FIXME: set custom capabilities
            IoSkipCurrentIrpStackLocation(Irp);
            return IoCallDriver(DeviceExtension->LowerDeviceObject, Irp);
        }
        case IRP_MN_QUERY_STOP_DEVICE:
        case IRP_MN_QUERY_REMOVE_DEVICE:
        {
            if (DeviceExtension->IrpPendingCount != 0 || DeviceExtension->ActiveSrb != NULL)
            {
                /* We have pending requests */
                DPRINT1("Failing removal/stop request due to pending requests present\n");
                Status = STATUS_UNSUCCESSFUL;
            }
            else
            {
                /* We're all clear */
                Irp->IoStatus.Status = STATUS_SUCCESS;
 
                IoSkipCurrentIrpStackLocation(Irp);
                return IoCallDriver(DeviceExtension->LowerDeviceObject, Irp);
            }
            break;
        }
        case IRP_MN_START_DEVICE:
        {
            Status = USBSTOR_FdoHandleStartDevice(DeviceObject, DeviceExtension, Irp);
            break;
        }
        default:
        {
            // forward irp to next device object
            IoSkipCurrentIrpStackLocation(Irp);
            return IoCallDriver(DeviceExtension->LowerDeviceObject, Irp);
        }
    }
 
    if (Status != STATUS_PENDING)
    {
        Irp->IoStatus.Status = Status;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
    }
 
    return Status;
}

Referenced by USBSTOR_DispatchPnp().

USBSTOR_GetBusInterface()

NTSTATUS NTAPI USBSTOR_GetBusInterface	(	IN PDEVICE_OBJECT	DeviceObject,
		OUT PUSB_BUS_INTERFACE_USBDI_V2	BusInterface
	)

Definition at line 33 of file misc.c.

{
    KEVENT Event;
    NTSTATUS Status;
    PIRP Irp;
    IO_STATUS_BLOCK IoStatus;
    PIO_STACK_LOCATION Stack;
 
    ASSERT(DeviceObject);
    ASSERT(BusInterface);
 
    KeInitializeEvent(&Event, NotificationEvent, FALSE);
 
    Irp = IoBuildSynchronousFsdRequest(IRP_MJ_PNP,
                                       DeviceObject,
                                       NULL,
                                       0,
                                       NULL,
                                       &Event,
                                       &IoStatus);
    if (Irp == NULL)
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    // initialize request
    Stack = IoGetNextIrpStackLocation(Irp);
    Stack->MajorFunction = IRP_MJ_PNP;
    Stack->MinorFunction = IRP_MN_QUERY_INTERFACE;
    Stack->Parameters.QueryInterface.Size = sizeof(BUS_INTERFACE_STANDARD);
    Stack->Parameters.QueryInterface.InterfaceType = (LPGUID)&USB_BUS_INTERFACE_USBDI_GUID;
    Stack->Parameters.QueryInterface.Version = 2;
    Stack->Parameters.QueryInterface.Interface = (PINTERFACE)BusInterface;
    Stack->Parameters.QueryInterface.InterfaceSpecificData = NULL;
    Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
 
    Status = IoCallDriver(DeviceObject, Irp);
 
    if (Status == STATUS_PENDING)
    {
        KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
        Status = IoStatus.Status;
    }
 
    return Status;
}

Referenced by USBSTOR_FdoHandleStartDevice().

USBSTOR_GetDescriptors()

NTSTATUS USBSTOR_GetDescriptors

(

IN PDEVICE_OBJECT

DeviceObject

)

Definition at line 75 of file descriptor.c.

{
    NTSTATUS Status;
    PFDO_DEVICE_EXTENSION DeviceExtension;
    USHORT DescriptorLength;
 
    DeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
 
     // first get device descriptor
     Status = USBSTOR_GetDescriptor(DeviceExtension->LowerDeviceObject, USB_DEVICE_DESCRIPTOR_TYPE, sizeof(USB_DEVICE_DESCRIPTOR), 0, 0, (PVOID*)&DeviceExtension->DeviceDescriptor);
     if (!NT_SUCCESS(Status))
     {
         DeviceExtension->DeviceDescriptor = NULL;
         return Status;
     }
 
     // now get basic configuration descriptor
     Status = USBSTOR_GetDescriptor(DeviceExtension->LowerDeviceObject, USB_CONFIGURATION_DESCRIPTOR_TYPE, sizeof(USB_CONFIGURATION_DESCRIPTOR), 0, 0, (PVOID*)&DeviceExtension->ConfigurationDescriptor);
     if (!NT_SUCCESS(Status))
     {
         FreeItem(DeviceExtension->DeviceDescriptor);
         DeviceExtension->DeviceDescriptor = NULL;
         return Status;
     }
 
     // backup length
     DescriptorLength = DeviceExtension->ConfigurationDescriptor->wTotalLength;
 
     // release basic descriptor
     FreeItem(DeviceExtension->ConfigurationDescriptor);
     DeviceExtension->ConfigurationDescriptor = NULL;
 
     // allocate full descriptor
     Status = USBSTOR_GetDescriptor(DeviceExtension->LowerDeviceObject, USB_CONFIGURATION_DESCRIPTOR_TYPE, DescriptorLength, 0, 0, (PVOID*)&DeviceExtension->ConfigurationDescriptor);
     if (!NT_SUCCESS(Status))
     {
         FreeItem(DeviceExtension->DeviceDescriptor);
         DeviceExtension->DeviceDescriptor = NULL;
         return Status;
     }
 
     // check if there is a serial number provided
     if (DeviceExtension->DeviceDescriptor->iSerialNumber)
     {
         // get serial number
         Status = USBSTOR_GetDescriptor(DeviceExtension->LowerDeviceObject, USB_STRING_DESCRIPTOR_TYPE, MAXIMUM_USB_STRING_LENGTH, DeviceExtension->DeviceDescriptor->iSerialNumber, 0x0409, (PVOID*)&DeviceExtension->SerialNumber);
         if (!NT_SUCCESS(Status))
         {
             FreeItem(DeviceExtension->DeviceDescriptor);
             DeviceExtension->DeviceDescriptor = NULL;
 
             FreeItem(DeviceExtension->ConfigurationDescriptor);
             DeviceExtension->ConfigurationDescriptor = NULL;
 
             DeviceExtension->SerialNumber = NULL;
             return Status;
          }
     }
 
     return Status;
}

Referenced by USBSTOR_FdoHandleStartDevice().

USBSTOR_GetEndpointStatus()

NTSTATUS USBSTOR_GetEndpointStatus	(	IN PDEVICE_OBJECT	DeviceObject,
		IN UCHAR	bEndpointAddress,
		OUT PUSHORT	Value
	)

Definition at line 18 of file error.c.

{
    PURB Urb;
    NTSTATUS Status;
 
    DPRINT("Allocating URB\n");
    Urb = (PURB)AllocateItem(NonPagedPool, sizeof(struct _URB_CONTROL_VENDOR_OR_CLASS_REQUEST));
    if (!Urb)
    {
        DPRINT1("OutofMemory!\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    // build status
    UsbBuildGetStatusRequest(Urb, URB_FUNCTION_GET_STATUS_FROM_ENDPOINT, bEndpointAddress & 0x0F, Value, NULL, NULL);
 
    // send the request
    DPRINT1("Sending Request DeviceObject %p, Urb %p\n", DeviceObject, Urb);
    Status = USBSTOR_SyncUrbRequest(DeviceObject, Urb);
 
    FreeItem(Urb);
    return Status;
}

USBSTOR_GetMaxLUN()

NTSTATUS USBSTOR_GetMaxLUN	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PFDO_DEVICE_EXTENSION	DeviceExtension
	)

Definition at line 173 of file misc.c.

{
    PUCHAR Buffer;
    NTSTATUS Status;
 
    Buffer = (PUCHAR)ExAllocatePoolWithTag(NonPagedPool, sizeof(UCHAR), USB_STOR_TAG);
    if (!Buffer)
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    Status = USBSTOR_ClassRequest(DeviceObject, DeviceExtension, USB_BULK_GET_MAX_LUN, DeviceExtension->InterfaceInformation->InterfaceNumber, USBD_TRANSFER_DIRECTION_IN, sizeof(UCHAR), Buffer);
 
    DPRINT("MaxLUN: %x\n", *Buffer);
 
    if (NT_SUCCESS(Status))
    {
        if (*Buffer > MAX_LUN)
        {
            // invalid response documented in usb mass storage specification
            Status = STATUS_DEVICE_DATA_ERROR;
        }
        else
        {
            // store maxlun
            DeviceExtension->MaxLUN = *Buffer;
        }
    }
    else
    {
        // "USB Mass Storage Class. Bulk-Only Transport. Revision 1.0"
        // 3.2  Get Max LUN (class-specific request) :
        // Devices that do not support multiple LUNs may STALL this command.
        USBSTOR_ResetDevice(DeviceExtension->LowerDeviceObject, DeviceExtension);
 
        DeviceExtension->MaxLUN = 0;
        Status = STATUS_SUCCESS;
    }
 
    ExFreePoolWithTag(Buffer, USB_STOR_TAG);
    return Status;
}

Referenced by USBSTOR_FdoHandleStartDevice().

USBSTOR_GetPipeHandles()

NTSTATUS USBSTOR_GetPipeHandles

(

IN PFDO_DEVICE_EXTENSION

DeviceExtension

)

Definition at line 319 of file descriptor.c.

{
    ULONG Index;
    BOOLEAN BulkInFound = FALSE, BulkOutFound = FALSE;
 
    // enumerate all pipes and extract bulk-in / bulk-out pipe handle
    for (Index = 0; Index < DeviceExtension->InterfaceInformation->NumberOfPipes; Index++)
    {
        if (DeviceExtension->InterfaceInformation->Pipes[Index].PipeType == UsbdPipeTypeBulk)
        {
            if (USB_ENDPOINT_DIRECTION_IN(DeviceExtension->InterfaceInformation->Pipes[Index].EndpointAddress))
            {
                DeviceExtension->BulkInPipeIndex = Index;
 
                // there should not be another bulk in pipe
                ASSERT(BulkInFound == FALSE);
                BulkInFound = TRUE;
            }
            else
            {
                DeviceExtension->BulkOutPipeIndex = Index;
 
                // there should not be another bulk out pipe
                ASSERT(BulkOutFound == FALSE);
                BulkOutFound = TRUE;
            }
        }
    }
 
    if (!BulkInFound || !BulkOutFound)
    {
        // WTF? usb port driver does not give us bulk pipe access
        DPRINT1("USBSTOR_GetPipeHandles> BulkInFound %c BulkOutFound %c missing!!!\n", BulkInFound, BulkOutFound);
        return STATUS_DEVICE_CONFIGURATION_ERROR;
    }
 
    return STATUS_SUCCESS;
}

Referenced by USBSTOR_FdoHandleStartDevice().

USBSTOR_HandleDeviceControl()

NTSTATUS USBSTOR_HandleDeviceControl	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 413 of file disk.c.

{
    PIO_STACK_LOCATION IoStack;
    NTSTATUS Status;
    PPDO_DEVICE_EXTENSION PDODeviceExtension;
    PSCSI_ADAPTER_BUS_INFO BusInfo;
    PSCSI_INQUIRY_DATA ScsiInquiryData;
    PINQUIRYDATA InquiryData;
 
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    switch (IoStack->Parameters.DeviceIoControl.IoControlCode)
    {
        case IOCTL_STORAGE_QUERY_PROPERTY:
            Status = USBSTOR_HandleQueryProperty(DeviceObject, Irp);
            break;
        case IOCTL_SCSI_PASS_THROUGH:
            DPRINT1("USBSTOR_HandleDeviceControl IOCTL_SCSI_PASS_THROUGH NOT implemented\n");
            Status = STATUS_NOT_SUPPORTED;
            break;
        case IOCTL_SCSI_PASS_THROUGH_DIRECT:
            DPRINT1("USBSTOR_HandleDeviceControl IOCTL_SCSI_PASS_THROUGH_DIRECT NOT implemented\n");
            Status = STATUS_NOT_SUPPORTED;
            break;
        case IOCTL_STORAGE_GET_MEDIA_SERIAL_NUMBER:
            DPRINT1("USBSTOR_HandleDeviceControl IOCTL_STORAGE_GET_MEDIA_SERIAL_NUMBER NOT implemented\n");
            Status = STATUS_NOT_SUPPORTED;
            break;
        case IOCTL_SCSI_GET_CAPABILITIES:
        {
            PIO_SCSI_CAPABILITIES Capabilities;
 
            // Legacy port capability query
            if (IoStack->Parameters.DeviceIoControl.OutputBufferLength == sizeof(PVOID))
            {
                Capabilities = *((PVOID *)Irp->AssociatedIrp.SystemBuffer) = ExAllocatePoolWithTag(NonPagedPool,
                                                                                                   sizeof(IO_SCSI_CAPABILITIES),
                                                                                                   USB_STOR_TAG);
                Irp->IoStatus.Information = sizeof(PVOID);
            }
            else
            {
                Capabilities = Irp->AssociatedIrp.SystemBuffer;
                Irp->IoStatus.Information = sizeof(IO_SCSI_CAPABILITIES);
            }
 
            if (Capabilities)
            {
                Capabilities->MaximumTransferLength = USBSTOR_DEFAULT_MAX_TRANSFER_LENGTH;
                Capabilities->MaximumPhysicalPages = USBSTOR_DEFAULT_MAX_TRANSFER_LENGTH / PAGE_SIZE + 1; // See CORE-10515 and CORE-10755
                Capabilities->SupportedAsynchronousEvents = 0;
                Capabilities->AlignmentMask = 0;
                Capabilities->TaggedQueuing = FALSE;
                Capabilities->AdapterScansDown = FALSE;
                Capabilities->AdapterUsesPio = FALSE;
                Status = STATUS_SUCCESS;
            }
            else
            {
                Status = STATUS_INSUFFICIENT_RESOURCES;
            }
 
            break;
        }
        case IOCTL_SCSI_GET_INQUIRY_DATA:
        {
            PDODeviceExtension = (PPDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
            ASSERT(PDODeviceExtension);
            ASSERT(PDODeviceExtension->Common.IsFDO == FALSE);
 
            // get parameters
            BusInfo = Irp->AssociatedIrp.SystemBuffer;
            ScsiInquiryData = (PSCSI_INQUIRY_DATA)(BusInfo + 1);
            InquiryData = (PINQUIRYDATA)ScsiInquiryData->InquiryData;
 
 
            BusInfo->NumberOfBuses = 1;
            BusInfo->BusData[0].NumberOfLogicalUnits = 1; //FIXME
            BusInfo->BusData[0].InitiatorBusId = 0;
            BusInfo->BusData[0].InquiryDataOffset = sizeof(SCSI_ADAPTER_BUS_INFO);
 
            ScsiInquiryData->PathId = 0;
            ScsiInquiryData->TargetId = 0;
            ScsiInquiryData->Lun = PDODeviceExtension->LUN & MAX_LUN;
            ScsiInquiryData->DeviceClaimed = PDODeviceExtension->Claimed;
            ScsiInquiryData->InquiryDataLength = sizeof(INQUIRYDATA);
            ScsiInquiryData->NextInquiryDataOffset = 0;
 
            // Note: INQUIRYDATA structure is larger than INQUIRYDATABUFFERSIZE
            RtlZeroMemory(InquiryData, sizeof(INQUIRYDATA));
            RtlCopyMemory(InquiryData, &PDODeviceExtension->InquiryData, sizeof(PDODeviceExtension->InquiryData));
 
            InquiryData->Versions = 0x04;
            InquiryData->ResponseDataFormat = 0x02; // some devices set this to 1
 
            Irp->IoStatus.Information = sizeof(SCSI_ADAPTER_BUS_INFO) + sizeof(SCSI_INQUIRY_DATA) + sizeof(INQUIRYDATA) - 1;
            Status = STATUS_SUCCESS;
 
            break;
        }
        case IOCTL_SCSI_GET_ADDRESS:
        {
            PSCSI_ADDRESS Address = Irp->AssociatedIrp.SystemBuffer;
 
            Address->Length = sizeof(SCSI_ADDRESS);
            Address->PortNumber = 0;
            Address->PathId = 0;
            Address->TargetId = 0;
            Address->Lun = (((PPDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->LUN & MAX_LUN);
            Irp->IoStatus.Information = sizeof(SCSI_ADDRESS);
 
            Status = STATUS_SUCCESS;
 
            break;
        }
        default:
            DPRINT("USBSTOR_HandleDeviceControl IoControl %x not supported\n", IoStack->Parameters.DeviceIoControl.IoControlCode);
            Status = STATUS_NOT_SUPPORTED;
            break;
    }
 
    return Status;
}

Referenced by USBSTOR_DispatchDeviceControl().

USBSTOR_HandleExecuteSCSI()

NTSTATUS USBSTOR_HandleExecuteSCSI	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp,
		IN ULONG	RetryCount
	)

Definition at line 1306 of file scsi.c.

{
    PCDB pCDB;
    NTSTATUS Status;
    PIO_STACK_LOCATION IoStack;
    PSCSI_REQUEST_BLOCK Request;
    PPDO_DEVICE_EXTENSION PDODeviceExtension;
 
    //
    // get PDO device extension
    //
    PDODeviceExtension = (PPDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
 
    //
    // sanity check
    //
    ASSERT(PDODeviceExtension->Common.IsFDO == FALSE);
 
    //
    // get current stack location
    //
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    //
    // get request block
    //
    Request = (PSCSI_REQUEST_BLOCK)IoStack->Parameters.Others.Argument1;
 
    //
    // get SCSI command data block
    //
    pCDB = (PCDB)Request->Cdb;
 
    DPRINT("USBSTOR_HandleExecuteSCSI Operation Code %x\n", pCDB->AsByte[0]);
 
    if (pCDB->AsByte[0] == SCSIOP_READ_CAPACITY)
    {
        //
        // sanity checks
        //
        ASSERT(Request->DataBuffer);
 
        DPRINT("SCSIOP_READ_CAPACITY Length %lu\n", Request->DataTransferLength);
        Status = USBSTOR_SendCapacity(DeviceObject, Irp, RetryCount);
    }
    else if (pCDB->MODE_SENSE.OperationCode == SCSIOP_MODE_SENSE)
    {
        DPRINT("SCSIOP_MODE_SENSE DataTransferLength %lu\n", Request->DataTransferLength);
        ASSERT(pCDB->MODE_SENSE.AllocationLength == Request->DataTransferLength);
        ASSERT(Request->DataBuffer);
 
        //
        // send mode sense command
        //
        Status = USBSTOR_SendModeSense(DeviceObject, Irp, RetryCount);
    }
    else if (pCDB->AsByte[0] == SCSIOP_READ_FORMATTED_CAPACITY)
    {
        DPRINT("SCSIOP_READ_FORMATTED_CAPACITY DataTransferLength %lu\n", Request->DataTransferLength);
 
        //
        // send read format capacity
        //
        Status = USBSTOR_SendFormatCapacity(DeviceObject, Irp, RetryCount);
    }
    else if (pCDB->AsByte[0] == SCSIOP_INQUIRY)
    {
        DPRINT("SCSIOP_INQUIRY DataTransferLength %lu\n", Request->DataTransferLength);
 
        //
        // send read format capacity
        //
        Status = USBSTOR_SendInquiry(DeviceObject, Irp, RetryCount);
    }
    else if (pCDB->MODE_SENSE.OperationCode == SCSIOP_READ ||  pCDB->MODE_SENSE.OperationCode == SCSIOP_WRITE)
    {
        DPRINT("SCSIOP_READ / SCSIOP_WRITE DataTransferLength %lu\n", Request->DataTransferLength);
 
        //
        // send read / write command
        //
        Status = USBSTOR_SendReadWrite(DeviceObject, Irp, RetryCount);
    }
    else if (pCDB->AsByte[0] == SCSIOP_MEDIUM_REMOVAL)
    {
        DPRINT("SCSIOP_MEDIUM_REMOVAL\n");
 
        //
        // just complete the request
        //
        Request->SrbStatus = SRB_STATUS_SUCCESS;
        Irp->IoStatus.Status = STATUS_SUCCESS;
        Irp->IoStatus.Information = Request->DataTransferLength;
        USBSTOR_QueueTerminateRequest(PDODeviceExtension->LowerDeviceObject, Irp);
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
        //
        // start next request
        //
        USBSTOR_QueueNextRequest(PDODeviceExtension->LowerDeviceObject);
 
        return STATUS_SUCCESS;
    }
    else if (pCDB->MODE_SENSE.OperationCode == SCSIOP_TEST_UNIT_READY)
    {
        DPRINT("SCSIOP_TEST_UNIT_READY\n");
 
        //
        // send test unit command
        //
        Status = USBSTOR_SendTestUnit(DeviceObject, Irp, RetryCount);
    }
    else
    {
        // Unknown request. Simply forward
        DPRINT1("Forwarding unknown Operation Code %x\n", pCDB->AsByte[0]);
        Status = USBSTOR_SendUnknownRequest(DeviceObject, Irp, RetryCount);
    }
 
    return Status;
}

USBSTOR_HandleInternalDeviceControl()

NTSTATUS USBSTOR_HandleInternalDeviceControl	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 81 of file disk.c.

{
    PIO_STACK_LOCATION IoStack;
    PSCSI_REQUEST_BLOCK Request;
    PPDO_DEVICE_EXTENSION PDODeviceExtension;
    NTSTATUS Status;
 
    IoStack = IoGetCurrentIrpStackLocation(Irp);
    Request = (PSCSI_REQUEST_BLOCK)IoStack->Parameters.Others.Argument1;
    ASSERT(Request);
    PDODeviceExtension = (PPDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    ASSERT(PDODeviceExtension->Common.IsFDO == FALSE);
 
    switch(Request->Function)
    {
        case SRB_FUNCTION_EXECUTE_SCSI:
        {
            DPRINT("SRB_FUNCTION_EXECUTE_SCSI\n");
 
            if (!IsRequestValid(Irp))
            {
                Status = STATUS_INVALID_PARAMETER;
                break;
            }
 
            if (Request->Cdb[0] == SCSIOP_MODE_SENSE)
            {
                DPRINT("USBSTOR_Scsi: SRB_FUNCTION_EXECUTE_SCSI - FIXME SCSIOP_MODE_SENSE\n");
                // FIXME Get from registry WriteProtect for StorageDevicePolicies;
                // L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\StorageDevicePolicies"
                // QueryTable[0].Name = L"WriteProtect"
            }
 
            IoMarkIrpPending(Irp);
            Request->SrbStatus = SRB_STATUS_PENDING;
 
            // add the request
            if (!USBSTOR_QueueAddIrp(PDODeviceExtension->LowerDeviceObject, Irp))
            {
                IoStartPacket(PDODeviceExtension->LowerDeviceObject, Irp, &Request->QueueSortKey, USBSTOR_CancelIo);
            }
 
            return STATUS_PENDING;
        }
        case SRB_FUNCTION_RELEASE_DEVICE:
        {
            DPRINT1("SRB_FUNCTION_RELEASE_DEVICE\n");
            ASSERT(PDODeviceExtension->Claimed == TRUE);
 
            // release claim
            PDODeviceExtension->Claimed = FALSE;
            Status = STATUS_SUCCESS;
            break;
        }
        case SRB_FUNCTION_CLAIM_DEVICE:
        {
            DPRINT1("SRB_FUNCTION_CLAIM_DEVICE\n");
 
            // check if the device has been claimed
            if (PDODeviceExtension->Claimed)
            {
                // device has already been claimed
                Status = STATUS_DEVICE_BUSY;
                Request->SrbStatus = SRB_STATUS_BUSY;
                break;
            }
 
            // claim device
            PDODeviceExtension->Claimed = TRUE;
 
            // output device object
            Request->DataBuffer = DeviceObject;
 
            Status = STATUS_SUCCESS;
            break;
        }
        case SRB_FUNCTION_RELEASE_QUEUE:
        {
            DPRINT1("SRB_FUNCTION_RELEASE_QUEUE\n");
 
            USBSTOR_QueueRelease(PDODeviceExtension->LowerDeviceObject);
 
            Request->SrbStatus = SRB_STATUS_SUCCESS;
            Status = STATUS_SUCCESS;
            break;
        }
 
        case SRB_FUNCTION_SHUTDOWN:
        case SRB_FUNCTION_FLUSH:
        case SRB_FUNCTION_FLUSH_QUEUE:
        {
            DPRINT1("SRB_FUNCTION_FLUSH / SRB_FUNCTION_FLUSH_QUEUE / SRB_FUNCTION_SHUTDOWN\n");
 
            // wait for pending requests to finish
            USBSTOR_QueueWaitForPendingRequests(PDODeviceExtension->LowerDeviceObject);
 
            Request->SrbStatus = SRB_STATUS_SUCCESS;
            Status = STATUS_SUCCESS;
            break;
        }
        default:
        {
            //
            // not supported
            //
            Status = STATUS_NOT_SUPPORTED;
            Request->SrbStatus = SRB_STATUS_ERROR;
        }
    }
 
    Irp->IoStatus.Status = Status;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
    return Status;
}

Referenced by USBSTOR_DispatchScsi().

USBSTOR_IsFloppy()

BOOLEAN USBSTOR_IsFloppy	(	IN PUCHAR	Buffer,
		IN ULONG	BufferLength,
		OUT PUCHAR	MediumTypeCode
	)

Definition at line 409 of file misc.c.

{
    PUFI_CAPACITY_FORMAT_HEADER FormatHeader;
    PUFI_CAPACITY_DESCRIPTOR Descriptor;
    ULONG Length, Index, BlockCount, BlockLength;
 
    //
    // get format header
    //
    FormatHeader = (PUFI_CAPACITY_FORMAT_HEADER)Buffer;
 
    //
    // sanity checks
    //
    ASSERT(FormatHeader->Reserved1 == 0x00);
    ASSERT(FormatHeader->Reserved2 == 0x00);
    ASSERT(FormatHeader->Reserved3 == 0x00);
 
    //
    // is there capacity data
    //
    if (!FormatHeader->CapacityLength)
    {
        //
        // no data provided
        //
        DPRINT1("[USBSTOR] No capacity length\n");
        return FALSE;
    }
 
    //
    // the format header are always 8 bytes in length
    //
    ASSERT((FormatHeader->CapacityLength & 0x7) == 0);
    DPRINT1("CapacityLength %x\n", FormatHeader->CapacityLength);
 
    //
    // grab length and locate first descriptor
    //
    Length = FormatHeader->CapacityLength;
    Descriptor = (PUFI_CAPACITY_DESCRIPTOR)(FormatHeader + 1);
    for(Index = 0; Index < Length / sizeof(UFI_CAPACITY_DESCRIPTOR); Index++)
    {
        //
        // blocks are little endian format
        //
        BlockCount = NTOHL(Descriptor->BlockCount);
 
        //
        // get block length
        //
        BlockLength = NTOHL((Descriptor->BlockLengthByte0 << 24 | Descriptor->BlockLengthByte1 << 16 | Descriptor->BlockLengthByte2 << 8));
 
        DPRINT1("BlockCount %x BlockLength %x Code %x\n", BlockCount, BlockLength, Descriptor->Code);
 
        if (BlockLength == 512 && BlockCount == 1440)
        {
            //
            // 720 KB DD
            //
            *MediumTypeCode = 0x1E;
            return TRUE;
        }
        else if (BlockLength == 1024 && BlockCount == 1232)
        {
            //
            // 1,25 MB
            //
            *MediumTypeCode = 0x93;
            return TRUE;
        }
        else if (BlockLength == 512 && BlockCount == 2880)
        {
            //
            // 1,44MB KB DD
            //
            *MediumTypeCode = 0x94;
            return TRUE;
        }
 
        //
        // move to next descriptor
        //
        Descriptor = (Descriptor + 1);
    }
 
    //
    // no floppy detected
    //
    return FALSE;
}

Referenced by USBSTOR_SendFormatCapacityIrp().

USBSTOR_PdoHandlePnp()

NTSTATUS USBSTOR_PdoHandlePnp	(	IN PDEVICE_OBJECT	DeviceObject,
		IN OUT PIRP	Irp
	)

Definition at line 534 of file pdo.c.

{
    PIO_STACK_LOCATION IoStack;
    PPDO_DEVICE_EXTENSION DeviceExtension;
    NTSTATUS Status;
    PDEVICE_CAPABILITIES Caps;
    ULONG bDelete;
 
    IoStack = IoGetCurrentIrpStackLocation(Irp);
    DeviceExtension = (PPDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    ASSERT(DeviceExtension->Common.IsFDO == FALSE);
 
    switch(IoStack->MinorFunction)
    {
       case IRP_MN_QUERY_DEVICE_RELATIONS:
       {
           Status = USBSTOR_PdoHandleDeviceRelations(DeviceObject, Irp);
           break;
       }
       case IRP_MN_QUERY_DEVICE_TEXT:
       {
           Status = USBSTOR_PdoHandleQueryDeviceText(DeviceObject, Irp);
           break;
       }
       case IRP_MN_QUERY_ID:
       {
           if (IoStack->Parameters.QueryId.IdType == BusQueryDeviceID)
           {
               Status = USBSTOR_PdoHandleQueryDeviceId(DeviceObject, Irp);
               break;
           }
           else if (IoStack->Parameters.QueryId.IdType == BusQueryHardwareIDs)
           {
               Status = USBSTOR_PdoHandleQueryHardwareId(DeviceObject, Irp);
               break;
           }
           else if (IoStack->Parameters.QueryId.IdType == BusQueryInstanceID)
           {
               Status = USBSTOR_PdoHandleQueryInstanceId(DeviceObject, Irp);
               break;
           }
           else if (IoStack->Parameters.QueryId.IdType == BusQueryCompatibleIDs)
           {
               Status = USBSTOR_PdoHandleQueryCompatibleId(DeviceObject, Irp);
               break;
           }
 
           DPRINT1("USBSTOR_PdoHandlePnp: IRP_MN_QUERY_ID IdType %x unimplemented\n", IoStack->Parameters.QueryId.IdType);
           Status = STATUS_NOT_SUPPORTED;
           Irp->IoStatus.Information = 0;
           break;
       }
       case IRP_MN_REMOVE_DEVICE:
       {
           DPRINT("IRP_MN_REMOVE_DEVICE\n");
 
           if(*DeviceExtension->PDODeviceObject != NULL)
           {
               *DeviceExtension->PDODeviceObject = NULL;
               bDelete = TRUE;
           }
           else
           {
               // device object already marked for deletion
               bDelete = FALSE;
           }
 
           Irp->IoStatus.Status = STATUS_SUCCESS;
           IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
           if (bDelete)
           {
               IoDeleteDevice(DeviceObject);
           }
           return STATUS_SUCCESS;
       }
       case IRP_MN_QUERY_CAPABILITIES:
       {
           // just forward irp to lower device
            Status = STATUS_UNSUCCESSFUL;
 
            if (IoForwardIrpSynchronously(DeviceExtension->LowerDeviceObject, Irp))
            {
                Status = Irp->IoStatus.Status;
                ASSERT(Status == STATUS_SUCCESS);
                
                if (NT_SUCCESS(Status))
                {
                    // check if no unique id
                    Caps = (PDEVICE_CAPABILITIES)IoStack->Parameters.DeviceCapabilities.Capabilities;
                    Caps->UniqueID = FALSE; // no unique id is supported
                    Caps->Removable = TRUE; //FIXME
                }
            }
           break;
       }
       case IRP_MN_QUERY_REMOVE_DEVICE:
       case IRP_MN_QUERY_STOP_DEVICE:
       {
           if (DeviceExtension->Claimed)
           {
               Status = STATUS_UNSUCCESSFUL;
               DPRINT1("[USBSTOR] Request %x fails because device is still claimed\n", IoStack->MinorFunction);
           }
           else
               Status = STATUS_SUCCESS;
           break;
       }
       case IRP_MN_START_DEVICE:
       {
           // no-op for PDO
           Status = STATUS_SUCCESS;
           break;
       }
       case IRP_MN_SURPRISE_REMOVAL:
       {
           Status = STATUS_SUCCESS;
           break;
       }
       default:
        {
            // do nothing
            Status = Irp->IoStatus.Status;
        }
    }
 
    if (Status != STATUS_PENDING)
    {
        Irp->IoStatus.Status = Status;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
    }
 
    return Status;
}

Referenced by USBSTOR_DispatchPnp().

USBSTOR_QueueAddIrp()

BOOLEAN USBSTOR_QueueAddIrp	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 75 of file queue.c.

{
    PDRIVER_CANCEL OldDriverCancel;
    KIRQL OldLevel;
    PFDO_DEVICE_EXTENSION FDODeviceExtension;
    BOOLEAN IrpListFreeze;
    BOOLEAN SrbProcessing;
    PIO_STACK_LOCATION IoStack = IoGetCurrentIrpStackLocation(Irp);
    PSCSI_REQUEST_BLOCK Request = (PSCSI_REQUEST_BLOCK)IoStack->Parameters.Others.Argument1;
 
    FDODeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    ASSERT(FDODeviceExtension->Common.IsFDO);
 
    IoMarkIrpPending(Irp);
 
    KeAcquireSpinLock(&FDODeviceExtension->IrpListLock, &OldLevel);
 
    SrbProcessing = FDODeviceExtension->IrpPendingCount != 0;
 
    if (SrbProcessing)
    {
        // add irp to queue
        InsertTailList(&FDODeviceExtension->IrpListHead, &Irp->Tail.Overlay.ListEntry);
    }
 
    FDODeviceExtension->IrpPendingCount++;
    KeClearEvent(&FDODeviceExtension->NoPendingRequests);
 
    // check if queue is freezed
    IrpListFreeze = BooleanFlagOn(FDODeviceExtension->Flags, USBSTOR_FDO_FLAGS_IRP_LIST_FREEZE);
 
    KeReleaseSpinLock(&FDODeviceExtension->IrpListLock, OldLevel);
 
    // synchronize with cancellations by holding the cancel lock
    IoAcquireCancelSpinLock(&Irp->CancelIrql);
 
    if (SrbProcessing)
    {
        ASSERT(FDODeviceExtension->ActiveSrb != NULL);
 
        OldDriverCancel = IoSetCancelRoutine(Irp, USBSTOR_Cancel);
    }
    else
    {
        ASSERT(FDODeviceExtension->ActiveSrb == NULL);
 
        FDODeviceExtension->ActiveSrb = Request;
        OldDriverCancel = IoSetCancelRoutine(Irp, USBSTOR_CancelIo);
    }
 
    // check if the irp has already been cancelled
    if (Irp->Cancel && OldDriverCancel == NULL)
    {
        // cancel irp
        Irp->CancelRoutine(DeviceObject, Irp);
        return FALSE;
    }
 
    IoReleaseCancelSpinLock(Irp->CancelIrql);
 
    // if list is freezed, dont start this packet
    DPRINT("IrpListFreeze: %lu IrpPendingCount %lu\n", IrpListFreeze, FDODeviceExtension->IrpPendingCount);
 
    return (IrpListFreeze || SrbProcessing);
}

Referenced by USBSTOR_HandleInternalDeviceControl().

USBSTOR_QueueInitialize()

VOID USBSTOR_QueueInitialize

(

PFDO_DEVICE_EXTENSION

FDODeviceExtension

)

Definition at line 17 of file queue.c.

{
    ASSERT(FDODeviceExtension->Common.IsFDO);
    KeInitializeSpinLock(&FDODeviceExtension->IrpListLock);
    InitializeListHead(&FDODeviceExtension->IrpListHead);
    KeInitializeEvent(&FDODeviceExtension->NoPendingRequests, NotificationEvent, TRUE);
}

Referenced by USBSTOR_FdoHandleStartDevice().

USBSTOR_QueueNextRequest()

VOID USBSTOR_QueueNextRequest

(

IN PDEVICE_OBJECT

DeviceObject

)

Definition at line 220 of file queue.c.

{
    PFDO_DEVICE_EXTENSION FDODeviceExtension;
    PIRP Irp;
    PIO_STACK_LOCATION IoStack;
    PSCSI_REQUEST_BLOCK Request;
 
    FDODeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    ASSERT(FDODeviceExtension->Common.IsFDO);
 
    // check first if there's already a request pending or the queue is frozen
    if (FDODeviceExtension->ActiveSrb != NULL ||
        BooleanFlagOn(FDODeviceExtension->Flags, USBSTOR_FDO_FLAGS_IRP_LIST_FREEZE))
    {
        // no work to do yet
        return;
    }
 
    // remove first irp from list
    Irp = USBSTOR_RemoveIrp(DeviceObject);
 
    // is there an irp pending
    if (!Irp)
    {
        // no work to do
        IoStartNextPacket(DeviceObject, TRUE);
        return;
    }
 
    IoStack = IoGetCurrentIrpStackLocation(Irp);
    Request = (PSCSI_REQUEST_BLOCK)IoStack->Parameters.Others.Argument1;
    ASSERT(Request);
 
    FDODeviceExtension->ActiveSrb = Request;
 
    // start next packet
    IoStartPacket(DeviceObject, Irp, &Request->QueueSortKey, USBSTOR_CancelIo);
    IoStartNextPacket(DeviceObject, TRUE);
}

Referenced by USBSTOR_Cancel(), USBSTOR_CancelIo(), USBSTOR_CSWCompletionRoutine(), USBSTOR_HandleExecuteSCSI(), USBSTOR_HandleTransferError(), USBSTOR_ResetDeviceWorkItemRoutine(), USBSTOR_SendModeSense(), and USBSTOR_StartIo().

USBSTOR_QueueRelease()

VOID USBSTOR_QueueRelease

(

IN PDEVICE_OBJECT

DeviceObject

)

Definition at line 262 of file queue.c.

{
    PFDO_DEVICE_EXTENSION FDODeviceExtension;
    PIRP Irp;
    KIRQL OldLevel;
    PIO_STACK_LOCATION IoStack;
    PSCSI_REQUEST_BLOCK Request;
 
    FDODeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    ASSERT(FDODeviceExtension->Common.IsFDO);
 
    KeAcquireSpinLock(&FDODeviceExtension->IrpListLock, &OldLevel);
 
    // clear freezed status
    FDODeviceExtension->Flags &= ~USBSTOR_FDO_FLAGS_IRP_LIST_FREEZE;
 
    KeReleaseSpinLock(&FDODeviceExtension->IrpListLock, OldLevel);
 
    // grab newest irp
    Irp = USBSTOR_RemoveIrp(DeviceObject);
 
    if (!Irp)
    {
        return;
    }
 
    IoStack = IoGetCurrentIrpStackLocation(Irp);
    Request = (PSCSI_REQUEST_BLOCK)IoStack->Parameters.Others.Argument1;
 
    IoStartPacket(DeviceObject,
                  Irp,
                  &Request->QueueSortKey,
                  USBSTOR_CancelIo);
}

Referenced by USBSTOR_HandleInternalDeviceControl().

USBSTOR_QueueTerminateRequest()

VOID USBSTOR_QueueTerminateRequest	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 186 of file queue.c.

{
    KIRQL OldLevel;
    PFDO_DEVICE_EXTENSION FDODeviceExtension;
    PIO_STACK_LOCATION IoStack = IoGetCurrentIrpStackLocation(Irp);
    PSCSI_REQUEST_BLOCK Request = (PSCSI_REQUEST_BLOCK)IoStack->Parameters.Others.Argument1;
 
    FDODeviceExtension = (PFDO_DEVICE_EXTENSION)FDODeviceObject->DeviceExtension;
    ASSERT(FDODeviceExtension->Common.IsFDO);
 
    KeAcquireSpinLock(&FDODeviceExtension->IrpListLock, &OldLevel);
 
    FDODeviceExtension->IrpPendingCount--;
 
    // check if this was our current active SRB
    if (FDODeviceExtension->ActiveSrb == Request)
    {
        // indicate processing is completed
        FDODeviceExtension->ActiveSrb = NULL;
    }
 
    // Set the event if nothing else is pending
    if (FDODeviceExtension->IrpPendingCount == 0 &&
        FDODeviceExtension->ActiveSrb == NULL)
    {
        KeSetEvent(&FDODeviceExtension->NoPendingRequests, IO_NO_INCREMENT, FALSE);
    }
 
    KeReleaseSpinLock(&FDODeviceExtension->IrpListLock, OldLevel);
}

Referenced by USBSTOR_Cancel(), USBSTOR_CancelIo(), USBSTOR_CBWCompletionRoutine(), USBSTOR_CSWCompletionRoutine(), USBSTOR_DataCompletionRoutine(), USBSTOR_HandleExecuteSCSI(), USBSTOR_HandleTransferError(), USBSTOR_SendModeSense(), and USBSTOR_StartIo().

USBSTOR_QueueWaitForPendingRequests()

VOID USBSTOR_QueueWaitForPendingRequests

(

IN PDEVICE_OBJECT

DeviceObject

)

Definition at line 171 of file queue.c.

{
    PFDO_DEVICE_EXTENSION FDODeviceExtension;
 
    FDODeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
 
    KeWaitForSingleObject(&FDODeviceExtension->NoPendingRequests,
                          Executive,
                          KernelMode,
                          FALSE,
                          NULL);
}

Referenced by USBSTOR_HandleInternalDeviceControl().

USBSTOR_ResetDevice()

NTSTATUS USBSTOR_ResetDevice	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PFDO_DEVICE_EXTENSION	DeviceExtension
	)

Definition at line 219 of file misc.c.

{
    NTSTATUS Status;
 
    Status = USBSTOR_ClassRequest(DeviceObject, DeviceExtension, USB_BULK_RESET_DEVICE, DeviceExtension->InterfaceInformation->InterfaceNumber, USBD_TRANSFER_DIRECTION_OUT, 0, NULL);
    return Status;
}

Referenced by USBSTOR_GetMaxLUN(), USBSTOR_HandleTransferError(), USBSTOR_ResetDeviceWorkItemRoutine(), and USBSTOR_TimerWorkerRoutine().

USBSTOR_ResetPipeWithHandle()

NTSTATUS USBSTOR_ResetPipeWithHandle	(	IN PDEVICE_OBJECT	DeviceObject,
		IN USBD_PIPE_HANDLE	PipeHandle
	)

Definition at line 46 of file error.c.

{
    PURB Urb;
    NTSTATUS Status;
 
    DPRINT("Allocating URB\n");
    Urb = (PURB)AllocateItem(NonPagedPool, sizeof(struct _URB_PIPE_REQUEST));
    if (!Urb)
    {
        DPRINT1("OutofMemory!\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    Urb->UrbPipeRequest.Hdr.Length = sizeof(struct _URB_PIPE_REQUEST);
    Urb->UrbPipeRequest.Hdr.Function = URB_FUNCTION_SYNC_RESET_PIPE_AND_CLEAR_STALL;
    Urb->UrbPipeRequest.PipeHandle = PipeHandle;
 
    // send the request
    DPRINT1("Sending Request DeviceObject %p, Urb %p\n", DeviceObject, Urb);
    Status = USBSTOR_SyncUrbRequest(DeviceObject, Urb);
 
    FreeItem(Urb);
    return Status;
}

Referenced by USBSTOR_HandleTransferError(), USBSTOR_ResetDeviceWorkItemRoutine(), USBSTOR_ResetHandlerWorkItemRoutine(), USBSTOR_ResetPipeWorkItemRoutine(), and USBSTOR_TimerWorkerRoutine().

USBSTOR_SelectConfigurationAndInterface()

NTSTATUS USBSTOR_SelectConfigurationAndInterface	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PFDO_DEVICE_EXTENSION	DeviceExtension
	)

Definition at line 234 of file descriptor.c.

{
    PUSB_INTERFACE_DESCRIPTOR InterfaceDescriptor;
    PUSB_ENDPOINT_DESCRIPTOR InEndpointDescriptor, OutEndpointDescriptor;
    NTSTATUS Status;
    PURB Urb;
    PUSBD_INTERFACE_LIST_ENTRY InterfaceList;
 
    Status = USBSTOR_ScanConfigurationDescriptor(DeviceExtension->ConfigurationDescriptor, &InterfaceDescriptor, &InEndpointDescriptor, &OutEndpointDescriptor);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    // now allocate one interface entry and terminating null entry
    InterfaceList = (PUSBD_INTERFACE_LIST_ENTRY)AllocateItem(PagedPool, sizeof(USBD_INTERFACE_LIST_ENTRY) * 2);
    if (!InterfaceList)
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    // initialize interface list entry
    InterfaceList[0].InterfaceDescriptor = InterfaceDescriptor;
 
    // now allocate the urb
    Urb = USBD_CreateConfigurationRequestEx(DeviceExtension->ConfigurationDescriptor, InterfaceList);
    if (!Urb)
    {
        FreeItem(InterfaceList);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
 
    ASSERT(InterfaceList[0].Interface);
 
    // submit urb
    Status = USBSTOR_SyncUrbRequest(DeviceExtension->LowerDeviceObject, Urb);
    if (!NT_SUCCESS(Status))
    {
        // failed to set configuration
        DPRINT1("USBSTOR_SelectConfiguration failed to set interface %x\n", Status);
        FreeItem(InterfaceList);
        ExFreePoolWithTag(Urb, 0);
        return Status;
    }
 
    // backup interface information
    DeviceExtension->InterfaceInformation = (PUSBD_INTERFACE_INFORMATION)AllocateItem(NonPagedPool, Urb->UrbSelectConfiguration.Interface.Length);
    if (!DeviceExtension->InterfaceInformation)
    {
        FreeItem(InterfaceList);
        ExFreePoolWithTag(Urb, 0);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    // copy interface information
    RtlCopyMemory(DeviceExtension->InterfaceInformation, &Urb->UrbSelectConfiguration.Interface, Urb->UrbSelectConfiguration.Interface.Length);
 
    // store pipe handle
    DeviceExtension->ConfigurationHandle = Urb->UrbSelectConfiguration.ConfigurationHandle;
 
    // now prepare interface urb
    UsbBuildSelectInterfaceRequest(Urb, GET_SELECT_INTERFACE_REQUEST_SIZE(InterfaceDescriptor->bNumEndpoints), DeviceExtension->ConfigurationHandle, InterfaceDescriptor->bInterfaceNumber, InterfaceDescriptor->bAlternateSetting);
 
    // copy interface information structure back - as offset for SelectConfiguration / SelectInterface request do differ
    RtlCopyMemory(&Urb->UrbSelectInterface.Interface, DeviceExtension->InterfaceInformation, DeviceExtension->InterfaceInformation->Length);
 
    // now select the interface
    Status = USBSTOR_SyncUrbRequest(DeviceExtension->LowerDeviceObject, Urb);
    if (NT_SUCCESS(Status))
    {
        // update configuration info
        ASSERT(Urb->UrbSelectInterface.Interface.Length == DeviceExtension->InterfaceInformation->Length);
        RtlCopyMemory(DeviceExtension->InterfaceInformation, &Urb->UrbSelectInterface.Interface, Urb->UrbSelectInterface.Interface.Length);
    }
 
    FreeItem(InterfaceList);
    ExFreePoolWithTag(Urb, 0);
 
    return Status;
}

Referenced by USBSTOR_FdoHandleStartDevice().

USBSTOR_SendCBW()

NTSTATUS USBSTOR_SendCBW	(	PIRP_CONTEXT	Context,
		PIRP	Irp
	)

Definition at line 591 of file scsi.c.

{
    PIO_STACK_LOCATION IoStack;
 
    //
    // get next stack location
    //
    IoStack = IoGetNextIrpStackLocation(Irp);
 
    //
    // initialize stack location
    //
    IoStack->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL;
    IoStack->Parameters.DeviceIoControl.IoControlCode = IOCTL_INTERNAL_USB_SUBMIT_URB;
    IoStack->Parameters.Others.Argument1 = (PVOID)&Context->Urb;
    IoStack->Parameters.DeviceIoControl.InputBufferLength = Context->Urb.UrbHeader.Length;
    Irp->IoStatus.Status = STATUS_SUCCESS;
 
    //
    // setup completion routine
    //
    IoSetCompletionRoutine(Irp, USBSTOR_CBWCompletionRoutine, Context, TRUE, TRUE, TRUE);
 
    //
    // call driver
    //
    return IoCallDriver(Context->FDODeviceExtension->LowerDeviceObject, Irp);
}

Referenced by USBSTOR_SendModeSense(), and USBSTOR_SendRequest().

USBSTOR_SendCSW()

VOID USBSTOR_SendCSW	(	PIRP_CONTEXT	Context,
		PIRP	Irp
	)

Definition at line 379 of file scsi.c.

{
    PIO_STACK_LOCATION IoStack;
 
    //
    // get next irp stack location
    //
    IoStack = IoGetNextIrpStackLocation(Irp);
 
    //
    // now initialize the urb for sending the csw
    //
    UsbBuildInterruptOrBulkTransferRequest(&Context->Urb,
                                           sizeof(struct _URB_BULK_OR_INTERRUPT_TRANSFER),
                                           Context->FDODeviceExtension->InterfaceInformation->Pipes[Context->FDODeviceExtension->BulkInPipeIndex].PipeHandle,
                                           Context->csw,
                                           NULL,
                                           512, //FIXME
                                           USBD_TRANSFER_DIRECTION_IN | USBD_SHORT_TRANSFER_OK,
                                           NULL);
 
    //
    // initialize stack location
    //
    IoStack->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL;
    IoStack->Parameters.DeviceIoControl.IoControlCode = IOCTL_INTERNAL_USB_SUBMIT_URB;
    IoStack->Parameters.Others.Argument1 = (PVOID)&Context->Urb;
    IoStack->Parameters.DeviceIoControl.InputBufferLength = Context->Urb.UrbHeader.Length;
    Irp->IoStatus.Status = STATUS_SUCCESS;
 
 
    //
    // setup completion routine
    //
    IoSetCompletionRoutine(Irp, USBSTOR_CSWCompletionRoutine, Context, TRUE, TRUE, TRUE);
 
    //
    // call driver
    //
    IoCallDriver(Context->FDODeviceExtension->LowerDeviceObject, Irp);
}

Referenced by USBSTOR_DataCompletionRoutine(), USBSTOR_ResetHandlerWorkItemRoutine(), and USBSTOR_SendModeSense().

USBSTOR_StartIo()

VOID NTAPI USBSTOR_StartIo	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Definition at line 300 of file queue.c.

{
    PIO_STACK_LOCATION IoStack;
    PSCSI_REQUEST_BLOCK Request;
    PFDO_DEVICE_EXTENSION FDODeviceExtension;
    PPDO_DEVICE_EXTENSION PDODeviceExtension;
    KIRQL OldLevel;
    BOOLEAN ResetInProgress;
 
    DPRINT("USBSTOR_StartIo\n");
 
    FDODeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    ASSERT(FDODeviceExtension->Common.IsFDO);
 
    IoAcquireCancelSpinLock(&OldLevel);
 
    IoSetCancelRoutine(Irp, NULL);
 
    // check if the irp has been cancelled
    if (Irp->Cancel)
    {
        IoReleaseCancelSpinLock(OldLevel);
 
        Irp->IoStatus.Status = STATUS_CANCELLED;
        Irp->IoStatus.Information = 0;
 
        USBSTOR_QueueTerminateRequest(DeviceObject, Irp);
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        USBSTOR_QueueNextRequest(DeviceObject);
        return;
    }
 
    IoReleaseCancelSpinLock(OldLevel);
 
    KeAcquireSpinLock(&FDODeviceExtension->CommonLock, &OldLevel);
    ResetInProgress = BooleanFlagOn(FDODeviceExtension->Flags, USBSTOR_FDO_FLAGS_DEVICE_RESETTING);
    KeReleaseSpinLock(&FDODeviceExtension->CommonLock, OldLevel);
 
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    PDODeviceExtension = (PPDO_DEVICE_EXTENSION)IoStack->DeviceObject->DeviceExtension;
    Request = IoStack->Parameters.Scsi.Srb;
    ASSERT(PDODeviceExtension->Common.IsFDO == FALSE);
 
    if (ResetInProgress)
    {
        // hard reset is in progress
        Request->SrbStatus = SRB_STATUS_NO_DEVICE;
        Request->DataTransferLength = 0;
        Irp->IoStatus.Information = 0;
        Irp->IoStatus.Status = STATUS_DEVICE_DOES_NOT_EXIST;
        USBSTOR_QueueTerminateRequest(DeviceObject, Irp);
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        USBSTOR_QueueNextRequest(DeviceObject);
        return;
    }
 
    USBSTOR_HandleExecuteSCSI(IoStack->DeviceObject, Irp);
 
    // FIXME: handle error
}

Referenced by DriverEntry().

USBSTOR_SyncForwardIrp()

NTSTATUS NTAPI USBSTOR_SyncForwardIrp	(	IN PDEVICE_OBJECT	DeviceObject,
		IN OUT PIRP	Irp
	)

USBSTOR_SyncForwardIrpCompletionRoutine()

NTSTATUS NTAPI USBSTOR_SyncForwardIrpCompletionRoutine	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp,
		PVOID	Context
	)

Definition at line 22 of file misc.c.

{
    if (Irp->PendingReturned)
    {
        KeSetEvent((PKEVENT)Context, IO_NO_INCREMENT, FALSE);
    }
    return STATUS_MORE_PROCESSING_REQUIRED;
}

Referenced by USBCCGP_SyncUrbRequest(), USBSTOR_SyncForwardIrp(), and USBSTOR_SyncUrbRequest().

USBSTOR_SyncUrbRequest()

NTSTATUS USBSTOR_SyncUrbRequest	(	IN PDEVICE_OBJECT	DeviceObject,
		OUT PURB	UrbRequest
	)

Definition at line 83 of file misc.c.

{
    PIRP Irp;
    PIO_STACK_LOCATION IoStack;
    KEVENT Event;
    NTSTATUS Status;
 
    Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
    if (!Irp)
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    KeInitializeEvent(&Event, NotificationEvent, FALSE);
 
    IoStack = IoGetNextIrpStackLocation(Irp);
 
    // initialize stack location
    IoStack->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL;
    IoStack->Parameters.DeviceIoControl.IoControlCode = IOCTL_INTERNAL_USB_SUBMIT_URB;
    IoStack->Parameters.Others.Argument1 = (PVOID)UrbRequest;
    IoStack->Parameters.DeviceIoControl.InputBufferLength = UrbRequest->UrbHeader.Length;
    Irp->IoStatus.Status = STATUS_SUCCESS;
 
    IoSetCompletionRoutine(Irp, USBSTOR_SyncForwardIrpCompletionRoutine, &Event, TRUE, TRUE, TRUE);
 
    Status = IoCallDriver(DeviceObject, Irp);
 
    if (Status == STATUS_PENDING)
    {
        KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
        Status = Irp->IoStatus.Status;
    }
 
    IoFreeIrp(Irp);
    return Status;
}

Referenced by USBSTOR_ClassRequest(), USBSTOR_GetDescriptor(), USBSTOR_GetEndpointStatus(), USBSTOR_ResetPipeWithHandle(), and USBSTOR_SelectConfigurationAndInterface().

USBSTOR_TimerRoutine()

VOID NTAPI USBSTOR_TimerRoutine	(	PDEVICE_OBJECT	DeviceObject,
		PVOID	Context
	)

Definition at line 205 of file error.c.

{
    PFDO_DEVICE_EXTENSION FDODeviceExtension;
    BOOLEAN ResetDevice = FALSE;
    PERRORHANDLER_WORKITEM_DATA WorkItemData;
 
    FDODeviceExtension = (PFDO_DEVICE_EXTENSION)Context;
    DPRINT1("[USBSTOR] TimerRoutine entered\n");
    // DPRINT1("[USBSTOR] ActiveSrb %p ResetInProgress %x LastTimerActiveSrb %p\n", FDODeviceExtension->ActiveSrb, FDODeviceExtension->ResetInProgress, FDODeviceExtension->LastTimerActiveSrb);
 
    KeAcquireSpinLockAtDpcLevel(&FDODeviceExtension->IrpListLock);
 
    // is there an active srb and no global reset is in progress
    if (FDODeviceExtension->ActiveSrb && /* FDODeviceExtension->ResetInProgress == FALSE && */ FDODeviceExtension->TimerWorkQueueEnabled)
    {
        if (FDODeviceExtension->LastTimerActiveSrb != NULL && FDODeviceExtension->LastTimerActiveSrb == FDODeviceExtension->ActiveSrb)
        {
            // check if empty
            DPRINT1("[USBSTOR] ActiveSrb %p hang detected\n", FDODeviceExtension->ActiveSrb);
            ResetDevice = TRUE;
        }
        else
        {
            // update pointer
            FDODeviceExtension->LastTimerActiveSrb = FDODeviceExtension->ActiveSrb;
        }
    }
    else
    {
        // reset srb
        FDODeviceExtension->LastTimerActiveSrb = NULL;
    }
 
    KeReleaseSpinLockFromDpcLevel(&FDODeviceExtension->IrpListLock);
 
 
    if (ResetDevice && FDODeviceExtension->TimerWorkQueueEnabled && FDODeviceExtension->SrbErrorHandlingActive == FALSE)
    {
        WorkItemData = ExAllocatePoolWithTag(NonPagedPool,
                                             sizeof(ERRORHANDLER_WORKITEM_DATA),
                                             USB_STOR_TAG);
        if (WorkItemData)
        {
           // Initialize and queue the work item to handle the error
           ExInitializeWorkItem(&WorkItemData->WorkQueueItem,
                                 USBSTOR_TimerWorkerRoutine,
                                 WorkItemData);
 
           WorkItemData->DeviceObject = FDODeviceExtension->FunctionalDeviceObject;
 
           DPRINT1("[USBSTOR] Queing Timer WorkItem\n");
           ExQueueWorkItem(&WorkItemData->WorkQueueItem, DelayedWorkQueue);
        }
     }
}

Referenced by USBSTOR_AddDevice().