ReactOS 0.4.16-dev-1946-g52006dd
Classes | Macros | Typedefs | Functions
usbstor.h File Reference
#include <wdm.h>
#include <ntstrsafe.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  CBW
 
struct  CSW
 
struct  IRP_CONTEXT
 
struct  __COMMON_DEVICE_EXTENSION__
 
struct  FDO_DEVICE_EXTENSION
 
struct  PDO_DEVICE_EXTENSION
 
struct  _ERRORHANDLER_WORKITEM_DATA
 
struct  _STORAGE_ADAPTER_DESCRIPTOR_WIN8
 

Macros

#define USB_STOR_TAG   'sbsu'
 
#define BooleanFlagOn(Flags, SingleFlag)   ((BOOLEAN)((((Flags) & (SingleFlag)) != 0)))
 
#define SrbGetCdb(srb)   ((PCDB)(srb->Cdb))
 
#define USB_SUBCLASS_RBC   0x01
 
#define USB_SUBCLASS_8020   0x02
 
#define USB_SUBCLASS_QIC   0x03
 
#define USB_SUBCLASS_UFI   0x04
 
#define USB_SUBCLASS_8070   0x05
 
#define USB_SUBCLASS_SCSI   0x06
 
#define USB_SUBCLASS_LOCKABLE   0x07
 
#define USB_SUBCLASS_ISD200   0xF0
 
#define USB_SUBCLASS_CYP_ATACB   0xF1
 
#define USB_SUBCLASS_VENDOR   0xFF
 
#define USB_PROTOCOL_CBI   0x00
 
#define USB_PROTOCOL_CB   0x01
 
#define USB_PROTOCOL_BULK   0x50
 
#define USB_PROTOCOL_UAS   0x62
 
#define USB_PROTOCOL_USBAT   0x80
 
#define USB_PROTOCOL_EUSB_SDDR09   0x81
 
#define USB_PROTOCOL_SDDR55   0x82
 
#define USB_PROTOCOL_DPCM_USB   0xF0
 
#define USB_PROTOCOL_FREECOM   0xF1
 
#define USB_PROTOCOL_DATAFAB   0xF2
 
#define USB_PROTOCOL_JUMPSHOT   0xF3
 
#define USB_PROTOCOL_ALAUDA   0xF4
 
#define USB_PROTOCOL_KARMA   0xF5
 
#define USB_PROTOCOL_VENDOR   0xFF
 
#define USB_BULK_GET_MAX_LUN   0xFE
 
#define USB_BULK_RESET_DEVICE   0xFF
 
#define USB_RECOVERABLE_ERRORS
 
#define USB_MAXCHILDREN   16
 
#define MAX_LUN   0xF
 
#define USBSTOR_DEFAULT_MAX_TRANSFER_LENGTH   0x10000
 
#define CBW_SIGNATURE   0x43425355
 
#define CSW_SIGNATURE   0x53425355
 
#define CSW_STATUS_COMMAND_PASSED   0x00
 
#define CSW_STATUS_COMMAND_FAILED   0x01
 
#define CSW_STATUS_PHASE_ERROR   0x02
 
#define USBSTOR_FDO_FLAGS_DEVICE_RESETTING   0x00000001
 
#define USBSTOR_FDO_FLAGS_IRP_LIST_FREEZE   0x00000002
 

Typedefs

typedef struct CBW * PCBW
 
typedef struct CSW * PCSW
 
typedef struct IRP_CONTEXT * PIRP_CONTEXT
 
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 _ERRORHANDLER_WORKITEM_DATA ERRORHANDLER_WORKITEM_DATA
 
typedef struct _ERRORHANDLER_WORKITEM_DATA * PERRORHANDLER_WORKITEM_DATA
 
typedef struct _STORAGE_ADAPTER_DESCRIPTOR_WIN8 STORAGE_ADAPTER_DESCRIPTOR_WIN8
 
typedef struct _STORAGE_ADAPTER_DESCRIPTOR_WIN8 * PSTORAGE_ADAPTER_DESCRIPTOR_WIN8
 

Functions

 C_ASSERT (sizeof(CBW)==31)
 
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_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 USBSTOR_ResetDevice (IN PDEVICE_OBJECT DeviceObject, IN PFDO_DEVICE_EXTENSION DeviceExtension)
 
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)
 
NTSTATUS USBSTOR_SendCSWRequest (PFDO_DEVICE_EXTENSION FDODeviceExtension, 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 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)
 
VOID NTAPI USBSTOR_QueueResetPipe (IN PFDO_DEVICE_EXTENSION FDODeviceExtension)
 
VOID NTAPI USBSTOR_QueueResetDevice (IN PFDO_DEVICE_EXTENSION FDODeviceExtension)
 

Macro Definition Documentation

◆ BooleanFlagOn

#define BooleanFlagOn (   Flags,
  SingleFlag 
)    ((BOOLEAN)((((Flags) & (SingleFlag)) != 0)))

Definition at line 14 of file usbstor.h.

◆ CBW_SIGNATURE

#define CBW_SIGNATURE   0x43425355

Definition at line 65 of file usbstor.h.

◆ CSW_SIGNATURE

#define CSW_SIGNATURE   0x53425355

Definition at line 66 of file usbstor.h.

◆ CSW_STATUS_COMMAND_FAILED

#define CSW_STATUS_COMMAND_FAILED   0x01

Definition at line 84 of file usbstor.h.

◆ CSW_STATUS_COMMAND_PASSED

#define CSW_STATUS_COMMAND_PASSED   0x00

Definition at line 83 of file usbstor.h.

◆ CSW_STATUS_PHASE_ERROR

#define CSW_STATUS_PHASE_ERROR   0x02

Definition at line 85 of file usbstor.h.

◆ MAX_LUN

#define MAX_LUN   0xF

Definition at line 62 of file usbstor.h.

◆ SrbGetCdb

#define SrbGetCdb (   srb)    ((PCDB)(srb->Cdb))

Definition at line 18 of file usbstor.h.

◆ USB_BULK_GET_MAX_LUN

#define USB_BULK_GET_MAX_LUN   0xFE

Definition at line 55 of file usbstor.h.

◆ USB_BULK_RESET_DEVICE

#define USB_BULK_RESET_DEVICE   0xFF

Definition at line 56 of file usbstor.h.

◆ USB_MAXCHILDREN

#define USB_MAXCHILDREN   16

Definition at line 61 of file usbstor.h.

◆ USB_PROTOCOL_ALAUDA

#define USB_PROTOCOL_ALAUDA   0xF4

Definition at line 49 of file usbstor.h.

◆ USB_PROTOCOL_BULK

#define USB_PROTOCOL_BULK   0x50

Definition at line 39 of file usbstor.h.

◆ USB_PROTOCOL_CB

#define USB_PROTOCOL_CB   0x01

Definition at line 38 of file usbstor.h.

◆ USB_PROTOCOL_CBI

#define USB_PROTOCOL_CBI   0x00

Definition at line 37 of file usbstor.h.

◆ USB_PROTOCOL_DATAFAB

#define USB_PROTOCOL_DATAFAB   0xF2

Definition at line 47 of file usbstor.h.

◆ USB_PROTOCOL_DPCM_USB

#define USB_PROTOCOL_DPCM_USB   0xF0

Definition at line 45 of file usbstor.h.

◆ USB_PROTOCOL_EUSB_SDDR09

#define USB_PROTOCOL_EUSB_SDDR09   0x81

Definition at line 42 of file usbstor.h.

◆ USB_PROTOCOL_FREECOM

#define USB_PROTOCOL_FREECOM   0xF1

Definition at line 46 of file usbstor.h.

◆ USB_PROTOCOL_JUMPSHOT

#define USB_PROTOCOL_JUMPSHOT   0xF3

Definition at line 48 of file usbstor.h.

◆ USB_PROTOCOL_KARMA

#define USB_PROTOCOL_KARMA   0xF5

Definition at line 50 of file usbstor.h.

◆ USB_PROTOCOL_SDDR55

#define USB_PROTOCOL_SDDR55   0x82

Definition at line 43 of file usbstor.h.

◆ USB_PROTOCOL_UAS

#define USB_PROTOCOL_UAS   0x62

Definition at line 40 of file usbstor.h.

◆ USB_PROTOCOL_USBAT

#define USB_PROTOCOL_USBAT   0x80

Definition at line 41 of file usbstor.h.

◆ USB_PROTOCOL_VENDOR

#define USB_PROTOCOL_VENDOR   0xFF

Definition at line 51 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)
USBD_STATUS_NO_BANDWIDTH
#define USBD_STATUS_NO_BANDWIDTH
Definition: usb.h:195
USBD_STATUS_STALL_PID
#define USBD_STATUS_STALL_PID
Definition: usb.h:175
USBD_STATUS_DEV_NOT_RESPONDING
#define USBD_STATUS_DEV_NOT_RESPONDING
Definition: usb.h:176
USBD_STATUS_ENDPOINT_HALTED
#define USBD_STATUS_ENDPOINT_HALTED
Definition: usb.h:190

Definition at line 58 of file usbstor.h.

◆ USB_STOR_TAG

#define USB_STOR_TAG   'sbsu'

Definition at line 11 of file usbstor.h.

◆ USB_SUBCLASS_8020

#define USB_SUBCLASS_8020   0x02

Definition at line 24 of file usbstor.h.

◆ USB_SUBCLASS_8070

#define USB_SUBCLASS_8070   0x05

Definition at line 27 of file usbstor.h.

◆ USB_SUBCLASS_CYP_ATACB

#define USB_SUBCLASS_CYP_ATACB   0xF1

Definition at line 32 of file usbstor.h.

◆ USB_SUBCLASS_ISD200

#define USB_SUBCLASS_ISD200   0xF0

Definition at line 31 of file usbstor.h.

◆ USB_SUBCLASS_LOCKABLE

#define USB_SUBCLASS_LOCKABLE   0x07

Definition at line 29 of file usbstor.h.

◆ USB_SUBCLASS_QIC

#define USB_SUBCLASS_QIC   0x03

Definition at line 25 of file usbstor.h.

◆ USB_SUBCLASS_RBC

#define USB_SUBCLASS_RBC   0x01

Definition at line 23 of file usbstor.h.

◆ USB_SUBCLASS_SCSI

#define USB_SUBCLASS_SCSI   0x06

Definition at line 28 of file usbstor.h.

◆ USB_SUBCLASS_UFI

#define USB_SUBCLASS_UFI   0x04

Definition at line 26 of file usbstor.h.

◆ USB_SUBCLASS_VENDOR

#define USB_SUBCLASS_VENDOR   0xFF

Definition at line 33 of file usbstor.h.

◆ USBSTOR_DEFAULT_MAX_TRANSFER_LENGTH

#define USBSTOR_DEFAULT_MAX_TRANSFER_LENGTH   0x10000

Definition at line 63 of file usbstor.h.

◆ USBSTOR_FDO_FLAGS_DEVICE_RESETTING

#define USBSTOR_FDO_FLAGS_DEVICE_RESETTING   0x00000001

Definition at line 117 of file usbstor.h.

◆ USBSTOR_FDO_FLAGS_IRP_LIST_FREEZE

#define USBSTOR_FDO_FLAGS_IRP_LIST_FREEZE   0x00000002

Definition at line 118 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

◆ PSTORAGE_ADAPTER_DESCRIPTOR_WIN8

typedef struct _STORAGE_ADAPTER_DESCRIPTOR_WIN8 * PSTORAGE_ADAPTER_DESCRIPTOR_WIN8

◆ PUSBSTOR_COMMON_DEVICE_EXTENSION

typedef struct __COMMON_DEVICE_EXTENSION__ * PUSBSTOR_COMMON_DEVICE_EXTENSION

◆ STORAGE_ADAPTER_DESCRIPTOR_WIN8

typedef struct _STORAGE_ADAPTER_DESCRIPTOR_WIN8 STORAGE_ADAPTER_DESCRIPTOR_WIN8

◆ 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.

32{
33 return ExAllocatePoolZero(PoolType, NumberOfBytes, TAG_KS);
34}
TAG_KS
#define TAG_KS
Definition: misc.c:14
ExAllocatePoolZero
FORCEINLINE PVOID ExAllocatePoolZero(ULONG PoolType, SIZE_T NumberOfBytes, ULONG Tag)
Definition: precomp.h:45
PoolType
_Must_inspect_result_ _In_ WDFDEVICE _In_ DEVICE_REGISTRY_PROPERTY _In_ _Strict_type_match_ POOL_TYPE PoolType
Definition: wdfdevice.h:3821
NumberOfBytes
_Must_inspect_result_ typedef _In_ PHYSICAL_ADDRESS _Inout_ PLARGE_INTEGER NumberOfBytes
Definition: iotypes.h:1036

◆ C_ASSERT()

C_ASSERT ( sizeof(CBW)  = =31)

◆ FreeItem()

VOID FreeItem ( IN PVOID  Item)

Definition at line 37 of file misc.c.

39{
40 ExFreePoolWithTag(Item, TAG_KS);
41}
ExFreePoolWithTag
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1109
Item
_In_ WDFCOLLECTION _In_ WDFOBJECT Item
Definition: wdfcollection.h:153

◆ USBSTOR_CancelIo()

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

Definition at line 28 of file queue.c.

31{
32 PFDO_DEVICE_EXTENSION FDODeviceExtension;
33
34 FDODeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
35 ASSERT_IRQL_EQUAL(DISPATCH_LEVEL);
36 ASSERT(FDODeviceExtension->Common.IsFDO);
37
38 // this IRP isn't in our list here
39 // now release the cancel lock
40 IoReleaseCancelSpinLock(Irp->CancelIrql);
41 Irp->IoStatus.Status = STATUS_CANCELLED;
42
43 USBSTOR_QueueTerminateRequest(DeviceObject, Irp);
44 IoCompleteRequest(Irp, IO_NO_INCREMENT);
45
46 USBSTOR_QueueNextRequest(DeviceObject);
47}
Irp
_In_ PIRP Irp
Definition: csq.h:116
PFDO_DEVICE_EXTENSION
struct _FDO_DEVICE_EXTENSION * PFDO_DEVICE_EXTENSION
ASSERT_IRQL_EQUAL
#define ASSERT_IRQL_EQUAL(x)
Definition: debug.h:43
USBSTOR_QueueTerminateRequest
VOID USBSTOR_QueueTerminateRequest(IN PDEVICE_OBJECT FDODeviceObject, IN PIRP Irp)
Definition: queue.c:186
USBSTOR_QueueNextRequest
VOID USBSTOR_QueueNextRequest(IN PDEVICE_OBJECT DeviceObject)
Definition: queue.c:220
DISPATCH_LEVEL
#define DISPATCH_LEVEL
Definition: env_spec_w32.h:696
ASSERT
#define ASSERT(a)
Definition: mode.c:44
IoCompleteRequest
#define IoCompleteRequest
Definition: irp.c:1240
IoReleaseCancelSpinLock
VOID NTAPI IoReleaseCancelSpinLock(IN KIRQL Irql)
Definition: util.c:150
COMMON_DEVICE_EXTENSION::IsFDO
BOOLEAN IsFDO
Definition: usbccgp.h:14
_FDO_DEVICE_EXTENSION
Definition: pci.h:82
_FDO_DEVICE_EXTENSION::Common
COMMON_DEVICE_EXTENSION Common
Definition: pci.h:84
STATUS_CANCELLED
#define STATUS_CANCELLED
Definition: udferr_usr.h:170
DeviceObject
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2061
IO_NO_INCREMENT
#define IO_NO_INCREMENT
Definition: iotypes.h:598

◆ USBSTOR_CreatePDO()

NTSTATUS USBSTOR_CreatePDO ( IN PDEVICE_OBJECT  DeviceObject,
IN UCHAR  LUN 
)

Definition at line 864 of file pdo.c.

867{
868 PDEVICE_OBJECT PDO;
869 NTSTATUS Status;
870 PPDO_DEVICE_EXTENSION PDODeviceExtension;
871 PFDO_DEVICE_EXTENSION FDODeviceExtension;
872 PINQUIRYDATA InquiryData;
873
874 FDODeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
875
876 // create child device object
877 Status = IoCreateDevice(DeviceObject->DriverObject, sizeof(PDO_DEVICE_EXTENSION), NULL, FILE_DEVICE_MASS_STORAGE, FILE_AUTOGENERATED_DEVICE_NAME | FILE_DEVICE_SECURE_OPEN, FALSE, &PDO);
878 if (!NT_SUCCESS(Status))
879 {
880 DPRINT1("Failed to create PDO, status %x\n", Status);
881 return Status;
882 }
883
884 // patch the stack size
885 PDO->StackSize = DeviceObject->StackSize;
886
887 PDODeviceExtension = (PPDO_DEVICE_EXTENSION)PDO->DeviceExtension;
888 InquiryData = (PINQUIRYDATA)&PDODeviceExtension->InquiryData;
889
890 // initialize device extension
891 RtlZeroMemory(PDODeviceExtension, sizeof(PDO_DEVICE_EXTENSION));
892 PDODeviceExtension->Common.IsFDO = FALSE;
893 PDODeviceExtension->LowerDeviceObject = DeviceObject;
894 PDODeviceExtension->PDODeviceObject = &FDODeviceExtension->ChildPDO[LUN];
895 PDODeviceExtension->Self = PDO;
896 PDODeviceExtension->LUN = LUN;
897
898 PDO->Flags |= DO_DIRECT_IO;
899
900 // device is initialized
901 PDO->Flags &= ~DO_DEVICE_INITIALIZING;
902
903 // output device object
904 FDODeviceExtension->ChildPDO[LUN] = PDO;
905
906 // send inquiry command by irp
907 Status = USBSTOR_FillInquiryData(PDO);
908
909 if (!NT_SUCCESS(Status))
910 {
911 return Status;
912 }
913
914 if (InquiryData->DeviceType != DIRECT_ACCESS_DEVICE &&
915 InquiryData->DeviceType != READ_ONLY_DIRECT_ACCESS_DEVICE)
916 {
917 return STATUS_NOT_SUPPORTED;
918 }
919
920 return Status;
921}
NTSTATUS
LONG NTSTATUS
Definition: precomp.h:26
DPRINT1
#define DPRINT1
Definition: precomp.h:8
DIRECT_ACCESS_DEVICE
#define DIRECT_ACCESS_DEVICE
Definition: cdrw_hw.h:1144
READ_ONLY_DIRECT_ACCESS_DEVICE
#define READ_ONLY_DIRECT_ACCESS_DEVICE
Definition: cdrw_hw.h:1149
FILE_DEVICE_SECURE_OPEN
#define FILE_DEVICE_SECURE_OPEN
Definition: cdrw_usr.h:46
STATUS_NOT_SUPPORTED
#define STATUS_NOT_SUPPORTED
Definition: d3dkmdt.h:48
NULL
#define NULL
Definition: types.h:112
FALSE
#define FALSE
Definition: types.h:117
NT_SUCCESS
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:33
PPDO_DEVICE_EXTENSION
struct _PDO_DEVICE_EXTENSION * PPDO_DEVICE_EXTENSION
DO_DIRECT_IO
#define DO_DIRECT_IO
Definition: env_spec_w32.h:396
Status
Status
Definition: gdiplustypes.h:25
FILE_DEVICE_MASS_STORAGE
#define FILE_DEVICE_MASS_STORAGE
Definition: imports.h:60
FILE_AUTOGENERATED_DEVICE_NAME
#define FILE_AUTOGENERATED_DEVICE_NAME
Definition: iotypes.h:138
IoCreateDevice
NTSTATUS NTAPI IoCreateDevice(IN PDRIVER_OBJECT DriverObject, IN ULONG DeviceExtensionSize, IN PUNICODE_STRING DeviceName, IN DEVICE_TYPE DeviceType, IN ULONG DeviceCharacteristics, IN BOOLEAN Exclusive, OUT PDEVICE_OBJECT *DeviceObject)
Definition: device.c:1031
PDO_DEVICE_EXTENSION
Definition: usbccgp.h:43
_DEVICE_OBJECT
Definition: env_spec_w32.h:413
_DEVICE_OBJECT::StackSize
UCHAR StackSize
Definition: env_spec_w32.h:421
_DEVICE_OBJECT::Flags
ULONG Flags
Definition: env_spec_w32.h:419
_DEVICE_OBJECT::DeviceExtension
PVOID DeviceExtension
Definition: env_spec_w32.h:418
_INQUIRYDATA
Definition: cdrw_hw.h:1115
_INQUIRYDATA::DeviceType
UCHAR DeviceType
Definition: cdrw_hw.h:1116
_PDO_DEVICE_EXTENSION
Definition: pci.h:57
_PDO_DEVICE_EXTENSION::Common
COMMON_DEVICE_EXTENSION Common
Definition: pci.h:59
RtlZeroMemory
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
USBSTOR_FillInquiryData
static NTSTATUS USBSTOR_FillInquiryData(IN PDEVICE_OBJECT PDODeviceObject)
Definition: pdo.c:824

◆ USBSTOR_FdoHandlePnp()

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

Definition at line 276 of file fdo.c.

279{
280 PIO_STACK_LOCATION IoStack;
281 PFDO_DEVICE_EXTENSION DeviceExtension;
282 NTSTATUS Status;
283
284 IoStack = IoGetCurrentIrpStackLocation(Irp);
285 DeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
286 ASSERT(DeviceExtension->Common.IsFDO);
287
288 switch(IoStack->MinorFunction)
289 {
290 case IRP_MN_SURPRISE_REMOVAL:
291 {
292 DPRINT("IRP_MN_SURPRISE_REMOVAL %p\n", DeviceObject);
293 Irp->IoStatus.Status = STATUS_SUCCESS;
294
295 // forward irp to next device object
296 IoSkipCurrentIrpStackLocation(Irp);
297 return IoCallDriver(DeviceExtension->LowerDeviceObject, Irp);
298 }
299 case IRP_MN_QUERY_DEVICE_RELATIONS:
300 {
301 DPRINT("IRP_MN_QUERY_DEVICE_RELATIONS %p Type: %u\n", DeviceObject, IoStack->Parameters.QueryDeviceRelations.Type);
302 return USBSTOR_FdoHandleDeviceRelations(DeviceExtension, Irp);
303 }
304 case IRP_MN_STOP_DEVICE:
305 {
306 DPRINT1("USBSTOR_FdoHandlePnp: IRP_MN_STOP_DEVICE unimplemented\n");
307 IoStopTimer(DeviceObject);
308 Irp->IoStatus.Status = STATUS_SUCCESS;
309
310 // forward irp to next device object
311 IoSkipCurrentIrpStackLocation(Irp);
312 return IoCallDriver(DeviceExtension->LowerDeviceObject, Irp);
313 }
314 case IRP_MN_REMOVE_DEVICE:
315 {
316 DPRINT("IRP_MN_REMOVE_DEVICE\n");
317
318 return USBSTOR_FdoHandleRemoveDevice(DeviceObject, DeviceExtension, Irp);
319 }
320 case IRP_MN_QUERY_CAPABILITIES:
321 {
322 // FIXME: set custom capabilities
323 IoSkipCurrentIrpStackLocation(Irp);
324 return IoCallDriver(DeviceExtension->LowerDeviceObject, Irp);
325 }
326 case IRP_MN_QUERY_STOP_DEVICE:
327 case IRP_MN_QUERY_REMOVE_DEVICE:
328 {
329 if (DeviceExtension->IrpPendingCount != 0 || DeviceExtension->ActiveSrb != NULL)
330 {
331 /* We have pending requests */
332 DPRINT1("Failing removal/stop request due to pending requests present\n");
333 Status = STATUS_UNSUCCESSFUL;
334 }
335 else
336 {
337 /* We're all clear */
338 Irp->IoStatus.Status = STATUS_SUCCESS;
339
340 IoSkipCurrentIrpStackLocation(Irp);
341 return IoCallDriver(DeviceExtension->LowerDeviceObject, Irp);
342 }
343 break;
344 }
345 case IRP_MN_START_DEVICE:
346 {
347 Status = USBSTOR_FdoHandleStartDevice(DeviceObject, DeviceExtension, Irp);
348 break;
349 }
350 default:
351 {
352 // forward irp to next device object
353 IoSkipCurrentIrpStackLocation(Irp);
354 return IoCallDriver(DeviceExtension->LowerDeviceObject, Irp);
355 }
356 }
357
358 if (Status != STATUS_PENDING)
359 {
360 Irp->IoStatus.Status = Status;
361 IoCompleteRequest(Irp, IO_NO_INCREMENT);
362 }
363
364 return Status;
365}
IoGetCurrentIrpStackLocation
static PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(PIRP Irp)
Definition: Bus_PDO_EvalMethod.c:150
IoStopTimer
VOID NTAPI IoStopTimer(PDEVICE_OBJECT DeviceObject)
Definition: iotimer.c:166
IRP_MN_SURPRISE_REMOVAL
#define IRP_MN_SURPRISE_REMOVAL
Definition: ntifs_ex.h:408
IoSkipCurrentIrpStackLocation
#define IoSkipCurrentIrpStackLocation(Irp)
Definition: ntifs_ex.h:421
IoCallDriver
#define IoCallDriver
Definition: irp.c:1225
STATUS_SUCCESS
#define STATUS_SUCCESS
Definition: shellext.h:65
DPRINT
#define DPRINT
Definition: sndvol32.h:73
_IO_STACK_LOCATION
Definition: Bus_PDO_EvalMethod.c:93
_IO_STACK_LOCATION::QueryDeviceRelations
struct _IO_STACK_LOCATION::@4278::@4303 QueryDeviceRelations
_IO_STACK_LOCATION::MinorFunction
UCHAR MinorFunction
Definition: iotypes.h:3114
_IO_STACK_LOCATION::Parameters
union _IO_STACK_LOCATION::@1694 Parameters
STATUS_PENDING
#define STATUS_PENDING
Definition: telnetd.h:14
STATUS_UNSUCCESSFUL
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
USBSTOR_FdoHandleRemoveDevice
NTSTATUS USBSTOR_FdoHandleRemoveDevice(IN PDEVICE_OBJECT DeviceObject, IN PFDO_DEVICE_EXTENSION DeviceExtension, IN OUT PIRP Irp)
Definition: fdo.c:100
USBSTOR_FdoHandleDeviceRelations
NTSTATUS USBSTOR_FdoHandleDeviceRelations(IN PFDO_DEVICE_EXTENSION DeviceExtension, IN OUT PIRP Irp)
Definition: fdo.c:41
USBSTOR_FdoHandleStartDevice
NTSTATUS USBSTOR_FdoHandleStartDevice(IN PDEVICE_OBJECT DeviceObject, IN PFDO_DEVICE_EXTENSION DeviceExtension, IN OUT PIRP Irp)
Definition: fdo.c:146
IRP_MN_START_DEVICE
#define IRP_MN_START_DEVICE
IRP_MN_REMOVE_DEVICE
#define IRP_MN_REMOVE_DEVICE
IRP_MN_QUERY_DEVICE_RELATIONS
#define IRP_MN_QUERY_DEVICE_RELATIONS
IRP_MN_QUERY_STOP_DEVICE
#define IRP_MN_QUERY_STOP_DEVICE
IRP_MN_QUERY_CAPABILITIES
#define IRP_MN_QUERY_CAPABILITIES
IRP_MN_STOP_DEVICE
#define IRP_MN_STOP_DEVICE
IRP_MN_QUERY_REMOVE_DEVICE
#define IRP_MN_QUERY_REMOVE_DEVICE

◆ 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.

36{
37 KEVENT Event;
38 NTSTATUS Status;
39 PIRP Irp;
40 IO_STATUS_BLOCK IoStatus;
41 PIO_STACK_LOCATION Stack;
42
43 ASSERT(DeviceObject);
44 ASSERT(BusInterface);
45
46 KeInitializeEvent(&Event, NotificationEvent, FALSE);
47
48 Irp = IoBuildSynchronousFsdRequest(IRP_MJ_PNP,
49 DeviceObject,
50 NULL,
51 0,
52 NULL,
53 &Event,
54 &IoStatus);
55 if (Irp == NULL)
56 {
57 return STATUS_INSUFFICIENT_RESOURCES;
58 }
59
60 // initialize request
61 Stack = IoGetNextIrpStackLocation(Irp);
62 Stack->MajorFunction = IRP_MJ_PNP;
63 Stack->MinorFunction = IRP_MN_QUERY_INTERFACE;
64 Stack->Parameters.QueryInterface.Size = sizeof(BUS_INTERFACE_STANDARD);
65 Stack->Parameters.QueryInterface.InterfaceType = (LPGUID)&USB_BUS_INTERFACE_USBDI_GUID;
66 Stack->Parameters.QueryInterface.Version = 2;
67 Stack->Parameters.QueryInterface.Interface = (PINTERFACE)BusInterface;
68 Stack->Parameters.QueryInterface.InterfaceSpecificData = NULL;
69 Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
70
71 Status = IoCallDriver(DeviceObject, Irp);
72
73 if (Status == STATUS_PENDING)
74 {
75 KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
76 Status = IoStatus.Status;
77 }
78
79 return Status;
80}
IRP_MJ_PNP
#define IRP_MJ_PNP
Definition: cdrw_usr.h:52
KeWaitForSingleObject
#define KeWaitForSingleObject(pEvt, foo, a, b, c)
Definition: env_spec_w32.h:478
KeInitializeEvent
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
IoStatus
__in UCHAR __in POWER_STATE __in_opt PVOID __in PIO_STATUS_BLOCK IoStatus
Definition: mxum.h:159
KernelMode
#define KernelMode
Definition: asm.h:38
NotificationEvent
@ NotificationEvent
Definition: ntdef.template.h:365
IoBuildSynchronousFsdRequest
PIRP NTAPI IoBuildSynchronousFsdRequest(IN ULONG MajorFunction, IN PDEVICE_OBJECT DeviceObject, IN PVOID Buffer, IN ULONG Length, IN PLARGE_INTEGER StartingOffset, IN PKEVENT Event, IN PIO_STATUS_BLOCK IoStatusBlock)
Definition: irp.c:1069
LPGUID
GUID * LPGUID
Definition: guiddef.h:81
PINTERFACE
struct _INTERFACE * PINTERFACE
_IO_STATUS_BLOCK
Definition: env_spec_w32.h:870
_IRP
Definition: Bus_PDO_EvalMethod.c:105
_KEVENT
Definition: ketypes.h:863
STATUS_INSUFFICIENT_RESOURCES
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
Stack
_In_ WDFREQUEST _In_ PIO_STACK_LOCATION Stack
Definition: wdfrequest.h:639
IoGetNextIrpStackLocation
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetNextIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2695
IRP_MN_QUERY_INTERFACE
#define IRP_MN_QUERY_INTERFACE
BUS_INTERFACE_STANDARD
struct _BUS_INTERFACE_STANDARD BUS_INTERFACE_STANDARD
Executive
@ Executive
Definition: ketypes.h:467

◆ USBSTOR_GetDescriptors()

NTSTATUS USBSTOR_GetDescriptors ( IN PDEVICE_OBJECT  DeviceObject)

Definition at line 75 of file descriptor.c.

77{
78 NTSTATUS Status;
79 PFDO_DEVICE_EXTENSION DeviceExtension;
80 USHORT DescriptorLength;
81
82 DeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
83
84 // first get device descriptor
85 Status = USBSTOR_GetDescriptor(DeviceExtension->LowerDeviceObject, USB_DEVICE_DESCRIPTOR_TYPE, sizeof(USB_DEVICE_DESCRIPTOR), 0, 0, (PVOID*)&DeviceExtension->DeviceDescriptor);
86 if (!NT_SUCCESS(Status))
87 {
88 DeviceExtension->DeviceDescriptor = NULL;
89 return Status;
90 }
91
92 // now get basic configuration descriptor
93 Status = USBSTOR_GetDescriptor(DeviceExtension->LowerDeviceObject, USB_CONFIGURATION_DESCRIPTOR_TYPE, sizeof(USB_CONFIGURATION_DESCRIPTOR), 0, 0, (PVOID*)&DeviceExtension->ConfigurationDescriptor);
94 if (!NT_SUCCESS(Status))
95 {
96 FreeItem(DeviceExtension->DeviceDescriptor);
97 DeviceExtension->DeviceDescriptor = NULL;
98 return Status;
99 }
100
101 // backup length
102 DescriptorLength = DeviceExtension->ConfigurationDescriptor->wTotalLength;
103
104 // release basic descriptor
105 FreeItem(DeviceExtension->ConfigurationDescriptor);
106 DeviceExtension->ConfigurationDescriptor = NULL;
107
108 // allocate full descriptor
109 Status = USBSTOR_GetDescriptor(DeviceExtension->LowerDeviceObject, USB_CONFIGURATION_DESCRIPTOR_TYPE, DescriptorLength, 0, 0, (PVOID*)&DeviceExtension->ConfigurationDescriptor);
110 if (!NT_SUCCESS(Status))
111 {
112 FreeItem(DeviceExtension->DeviceDescriptor);
113 DeviceExtension->DeviceDescriptor = NULL;
114 return Status;
115 }
116
117 // check if there is a serial number provided
118 if (DeviceExtension->DeviceDescriptor->iSerialNumber)
119 {
120 // get serial number
121 Status = USBSTOR_GetDescriptor(DeviceExtension->LowerDeviceObject, USB_STRING_DESCRIPTOR_TYPE, MAXIMUM_USB_STRING_LENGTH, DeviceExtension->DeviceDescriptor->iSerialNumber, 0x0409, (PVOID*)&DeviceExtension->SerialNumber);
122 if (!NT_SUCCESS(Status))
123 {
124 FreeItem(DeviceExtension->DeviceDescriptor);
125 DeviceExtension->DeviceDescriptor = NULL;
126
127 FreeItem(DeviceExtension->ConfigurationDescriptor);
128 DeviceExtension->ConfigurationDescriptor = NULL;
129
130 DeviceExtension->SerialNumber = NULL;
131 return Status;
132 }
133 }
134
135 return Status;
136}
USBSTOR_GetDescriptor
NTSTATUS NTAPI USBSTOR_GetDescriptor(IN PDEVICE_OBJECT DeviceObject, IN UCHAR DescriptorType, IN ULONG DescriptorLength, IN UCHAR DescriptorIndex, IN LANGID LanguageId, OUT PVOID *OutDescriptor)
Definition: descriptor.c:18
FreeItem
VOID FreeItem(IN PVOID Item)
Definition: misc.c:37
USHORT
unsigned short USHORT
Definition: pedump.c:61
_USB_CONFIGURATION_DESCRIPTOR
Definition: usb100.h:136
_USB_DEVICE_DESCRIPTOR
Definition: usb100.h:110
USB_CONFIGURATION_DESCRIPTOR_TYPE
#define USB_CONFIGURATION_DESCRIPTOR_TYPE
Definition: usb100.h:50
MAXIMUM_USB_STRING_LENGTH
#define MAXIMUM_USB_STRING_LENGTH
Definition: usb100.h:43
USB_DEVICE_DESCRIPTOR_TYPE
#define USB_DEVICE_DESCRIPTOR_TYPE
Definition: usb100.h:49
USB_STRING_DESCRIPTOR_TYPE
#define USB_STRING_DESCRIPTOR_TYPE
Definition: usb100.h:51

◆ USBSTOR_GetEndpointStatus()

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

Definition at line 18 of file error.c.

22{
23 PURB Urb;
24 NTSTATUS Status;
25
26 DPRINT("Allocating URB\n");
27 Urb = (PURB)AllocateItem(NonPagedPool, sizeof(struct _URB_CONTROL_VENDOR_OR_CLASS_REQUEST));
28 if (!Urb)
29 {
30 DPRINT1("OutofMemory!\n");
31 return STATUS_INSUFFICIENT_RESOURCES;
32 }
33
34 // build status
35 UsbBuildGetStatusRequest(Urb, URB_FUNCTION_GET_STATUS_FROM_ENDPOINT, bEndpointAddress & 0x0F, Value, NULL, NULL);
36
37 // send the request
38 DPRINT1("Sending Request DeviceObject %p, Urb %p\n", DeviceObject, Urb);
39 Status = USBSTOR_SyncUrbRequest(DeviceObject, Urb);
40
41 FreeItem(Urb);
42 return Status;
43}
USBSTOR_SyncUrbRequest
NTSTATUS USBSTOR_SyncUrbRequest(IN PDEVICE_OBJECT DeviceObject, OUT PURB UrbRequest)
Definition: misc.c:83
NonPagedPool
#define NonPagedPool
Definition: env_spec_w32.h:307
AllocateItem
PVOID AllocateItem(IN POOL_TYPE PoolType, IN SIZE_T NumberOfBytes)
Definition: misc.c:29
_URB_CONTROL_VENDOR_OR_CLASS_REQUEST
Definition: usb.h:385
_URB
Definition: usb.h:529
PURB
struct _URB * PURB
URB_FUNCTION_GET_STATUS_FROM_ENDPOINT
#define URB_FUNCTION_GET_STATUS_FROM_ENDPOINT
Definition: usb.h:107
UsbBuildGetStatusRequest
#define UsbBuildGetStatusRequest(urb, op, index, transferBuffer, transferBufferMDL, link)
Definition: usbdlib.h:35
Urb
_In_ PIO_STACK_LOCATION _In_ PURB Urb
Definition: usbdlib.h:267
Value
_Must_inspect_result_ _In_ WDFKEY _In_ PCUNICODE_STRING _Out_opt_ PUSHORT _Inout_opt_ PUNICODE_STRING Value
Definition: wdfregistry.h:413

◆ USBSTOR_GetMaxLUN()

NTSTATUS USBSTOR_GetMaxLUN ( IN PDEVICE_OBJECT  DeviceObject,
IN PFDO_DEVICE_EXTENSION  DeviceExtension 
)

Definition at line 173 of file misc.c.

176{
177 PUCHAR Buffer;
178 NTSTATUS Status;
179
180 Buffer = (PUCHAR)ExAllocatePoolWithTag(NonPagedPool, sizeof(UCHAR), USB_STOR_TAG);
181 if (!Buffer)
182 {
183 return STATUS_INSUFFICIENT_RESOURCES;
184 }
185
186 Status = USBSTOR_ClassRequest(DeviceObject, DeviceExtension, USB_BULK_GET_MAX_LUN, DeviceExtension->InterfaceInformation->InterfaceNumber, USBD_TRANSFER_DIRECTION_IN, sizeof(UCHAR), Buffer);
187
188 DPRINT("MaxLUN: %x\n", *Buffer);
189
190 if (NT_SUCCESS(Status))
191 {
192 if (*Buffer > MAX_LUN)
193 {
194 // invalid response documented in usb mass storage specification
195 Status = STATUS_DEVICE_DATA_ERROR;
196 }
197 else
198 {
199 // store maxlun
200 DeviceExtension->MaxLUN = *Buffer;
201 }
202 }
203 else
204 {
205 // "USB Mass Storage Class. Bulk-Only Transport. Revision 1.0"
206 // 3.2 Get Max LUN (class-specific request) :
207 // Devices that do not support multiple LUNs may STALL this command.
208 USBSTOR_ResetDevice(DeviceExtension->LowerDeviceObject, DeviceExtension);
209
210 DeviceExtension->MaxLUN = 0;
211 Status = STATUS_SUCCESS;
212 }
213
214 ExFreePoolWithTag(Buffer, USB_STOR_TAG);
215 return Status;
216}
Buffer
Definition: bufpool.h:45
USBSTOR_ResetDevice
NTSTATUS USBSTOR_ResetDevice(IN PDEVICE_OBJECT DeviceObject, IN PFDO_DEVICE_EXTENSION DeviceExtension)
Definition: misc.c:219
USBSTOR_ClassRequest
NTSTATUS USBSTOR_ClassRequest(IN PDEVICE_OBJECT DeviceObject, IN PFDO_DEVICE_EXTENSION DeviceExtension, IN UCHAR RequestType, IN USHORT Index, IN ULONG TransferFlags, IN ULONG TransferBufferLength, IN PVOID TransferBuffer)
Definition: misc.c:139
ExAllocatePoolWithTag
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
PUCHAR
unsigned char * PUCHAR
Definition: typedefs.h:53
STATUS_DEVICE_DATA_ERROR
#define STATUS_DEVICE_DATA_ERROR
Definition: udferr_usr.h:159
USBD_TRANSFER_DIRECTION_IN
#define USBD_TRANSFER_DIRECTION_IN
Definition: usb.h:160
USB_BULK_GET_MAX_LUN
#define USB_BULK_GET_MAX_LUN
Definition: usbstor.h:55
MAX_LUN
#define MAX_LUN
Definition: usbstor.h:62
USB_STOR_TAG
#define USB_STOR_TAG
Definition: usbstor.h:11
UCHAR
unsigned char UCHAR
Definition: xmlstorage.h:181

◆ USBSTOR_GetPipeHandles()

NTSTATUS USBSTOR_GetPipeHandles ( IN PFDO_DEVICE_EXTENSION  DeviceExtension)

Definition at line 319 of file descriptor.c.

321{
322 ULONG Index;
323 BOOLEAN BulkInFound = FALSE, BulkOutFound = FALSE;
324
325 // enumerate all pipes and extract bulk-in / bulk-out pipe handle
326 for (Index = 0; Index < DeviceExtension->InterfaceInformation->NumberOfPipes; Index++)
327 {
328 if (DeviceExtension->InterfaceInformation->Pipes[Index].PipeType == UsbdPipeTypeBulk)
329 {
330 if (USB_ENDPOINT_DIRECTION_IN(DeviceExtension->InterfaceInformation->Pipes[Index].EndpointAddress))
331 {
332 DeviceExtension->BulkInPipeIndex = Index;
333
334 // there should not be another bulk in pipe
335 ASSERT(BulkInFound == FALSE);
336 BulkInFound = TRUE;
337 }
338 else
339 {
340 DeviceExtension->BulkOutPipeIndex = Index;
341
342 // there should not be another bulk out pipe
343 ASSERT(BulkOutFound == FALSE);
344 BulkOutFound = TRUE;
345 }
346 }
347 }
348
349 if (!BulkInFound || !BulkOutFound)
350 {
351 // WTF? usb port driver does not give us bulk pipe access
352 DPRINT1("USBSTOR_GetPipeHandles> BulkInFound %c BulkOutFound %c missing!!!\n", BulkInFound, BulkOutFound);
353 return STATUS_DEVICE_CONFIGURATION_ERROR;
354 }
355
356 return STATUS_SUCCESS;
357}
BOOLEAN
unsigned char BOOLEAN
Definition: ProcessorBind.h:185
TRUE
#define TRUE
Definition: types.h:120
STATUS_DEVICE_CONFIGURATION_ERROR
#define STATUS_DEVICE_CONFIGURATION_ERROR
Definition: ntstatus.h:713
ULONG
uint32_t ULONG
Definition: typedefs.h:59
USB_ENDPOINT_DIRECTION_IN
#define USB_ENDPOINT_DIRECTION_IN(x)
Definition: usb100.h:76
UsbdPipeTypeBulk
@ UsbdPipeTypeBulk
Definition: usb.h:247
Index
_In_ WDFCOLLECTION _In_ ULONG Index
Definition: wdfcollection.h:182

◆ USBSTOR_HandleDeviceControl()

NTSTATUS USBSTOR_HandleDeviceControl ( IN PDEVICE_OBJECT  DeviceObject,
IN PIRP  Irp 
)

Definition at line 416 of file disk.c.

419{
420 PIO_STACK_LOCATION IoStack;
421 NTSTATUS Status;
422 PPDO_DEVICE_EXTENSION PDODeviceExtension;
423 PSCSI_ADAPTER_BUS_INFO BusInfo;
424 PSCSI_INQUIRY_DATA ScsiInquiryData;
425 PINQUIRYDATA InquiryData;
426
427 IoStack = IoGetCurrentIrpStackLocation(Irp);
428
429 switch (IoStack->Parameters.DeviceIoControl.IoControlCode)
430 {
431 case IOCTL_STORAGE_QUERY_PROPERTY:
432 Status = USBSTOR_HandleQueryProperty(DeviceObject, Irp);
433 break;
434 case IOCTL_SCSI_PASS_THROUGH:
435 case IOCTL_SCSI_PASS_THROUGH_DIRECT:
436 {
437 PDODeviceExtension = DeviceObject->DeviceExtension;
438
439 ASSERT(KeGetCurrentIrql() < DISPATCH_LEVEL);
440 ASSERT(PDODeviceExtension);
441 ASSERT(PDODeviceExtension->Common.IsFDO == FALSE);
442
443 /* Skip requests that bypassed the class driver. See also cdrom!RequestHandleScsiPassThrough */
444 if ((IoGetCurrentIrpStackLocation(Irp)->MinorFunction == 0) && PDODeviceExtension->Claimed)
445 {
446 Status = STATUS_INVALID_DEVICE_REQUEST;
447 break;
448 }
449
450 Status = SptiHandleScsiPassthru(DeviceObject,
451 Irp,
452 USBSTOR_DEFAULT_MAX_TRANSFER_LENGTH,
453 USBSTOR_DEFAULT_MAX_PHYS_PAGES);
454 break;
455 }
456 case IOCTL_STORAGE_GET_MEDIA_SERIAL_NUMBER:
457 DPRINT1("USBSTOR_HandleDeviceControl IOCTL_STORAGE_GET_MEDIA_SERIAL_NUMBER NOT implemented\n");
458 Status = STATUS_NOT_SUPPORTED;
459 break;
460 case IOCTL_SCSI_GET_CAPABILITIES:
461 {
462 PIO_SCSI_CAPABILITIES Capabilities;
463
464 // Legacy port capability query
465 if (IoStack->Parameters.DeviceIoControl.OutputBufferLength == sizeof(PVOID))
466 {
467 Capabilities = *((PVOID *)Irp->AssociatedIrp.SystemBuffer) = ExAllocatePoolWithTag(NonPagedPool,
468 sizeof(IO_SCSI_CAPABILITIES),
469 USB_STOR_TAG);
470 Irp->IoStatus.Information = sizeof(PVOID);
471 }
472 else
473 {
474 Capabilities = Irp->AssociatedIrp.SystemBuffer;
475 Irp->IoStatus.Information = sizeof(IO_SCSI_CAPABILITIES);
476 }
477
478 if (Capabilities)
479 {
480 Capabilities->MaximumTransferLength = USBSTOR_DEFAULT_MAX_TRANSFER_LENGTH;
481 Capabilities->MaximumPhysicalPages = USBSTOR_DEFAULT_MAX_PHYS_PAGES;
482 Capabilities->SupportedAsynchronousEvents = 0;
483 Capabilities->AlignmentMask = 0;
484 Capabilities->TaggedQueuing = FALSE;
485 Capabilities->AdapterScansDown = FALSE;
486 Capabilities->AdapterUsesPio = FALSE;
487 Status = STATUS_SUCCESS;
488 }
489 else
490 {
491 Status = STATUS_INSUFFICIENT_RESOURCES;
492 }
493
494 break;
495 }
496 case IOCTL_SCSI_GET_INQUIRY_DATA:
497 {
498 PDODeviceExtension = (PPDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
499 ASSERT(PDODeviceExtension);
500 ASSERT(PDODeviceExtension->Common.IsFDO == FALSE);
501
502 // get parameters
503 BusInfo = Irp->AssociatedIrp.SystemBuffer;
504 ScsiInquiryData = (PSCSI_INQUIRY_DATA)(BusInfo + 1);
505 InquiryData = (PINQUIRYDATA)ScsiInquiryData->InquiryData;
506
507
508 BusInfo->NumberOfBuses = 1;
509 BusInfo->BusData[0].NumberOfLogicalUnits = 1; //FIXME
510 BusInfo->BusData[0].InitiatorBusId = 0;
511 BusInfo->BusData[0].InquiryDataOffset = sizeof(SCSI_ADAPTER_BUS_INFO);
512
513 ScsiInquiryData->PathId = 0;
514 ScsiInquiryData->TargetId = 0;
515 ScsiInquiryData->Lun = PDODeviceExtension->LUN & MAX_LUN;
516 ScsiInquiryData->DeviceClaimed = PDODeviceExtension->Claimed;
517 ScsiInquiryData->InquiryDataLength = sizeof(INQUIRYDATA);
518 ScsiInquiryData->NextInquiryDataOffset = 0;
519
520 // Note: INQUIRYDATA structure is larger than INQUIRYDATABUFFERSIZE
521 RtlZeroMemory(InquiryData, sizeof(INQUIRYDATA));
522 RtlCopyMemory(InquiryData, &PDODeviceExtension->InquiryData, sizeof(PDODeviceExtension->InquiryData));
523
524 InquiryData->Versions = 0x04;
525 InquiryData->ResponseDataFormat = 0x02; // some devices set this to 1
526
527 Irp->IoStatus.Information = sizeof(SCSI_ADAPTER_BUS_INFO) + sizeof(SCSI_INQUIRY_DATA) + sizeof(INQUIRYDATA) - 1;
528 Status = STATUS_SUCCESS;
529
530 break;
531 }
532 case IOCTL_SCSI_GET_ADDRESS:
533 {
534 PSCSI_ADDRESS Address = Irp->AssociatedIrp.SystemBuffer;
535
536 Address->Length = sizeof(SCSI_ADDRESS);
537 Address->PortNumber = 0;
538 Address->PathId = 0;
539 Address->TargetId = 0;
540 Address->Lun = (((PPDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->LUN & MAX_LUN);
541 Irp->IoStatus.Information = sizeof(SCSI_ADDRESS);
542
543 Status = STATUS_SUCCESS;
544
545 break;
546 }
547 default:
548 DPRINT("USBSTOR_HandleDeviceControl IoControl %x not supported\n", IoStack->Parameters.DeviceIoControl.IoControlCode);
549 Status = STATUS_NOT_SUPPORTED;
550 break;
551 }
552
553 return Status;
554}
PINQUIRYDATA
struct _INQUIRYDATA * PINQUIRYDATA
INQUIRYDATA
struct _INQUIRYDATA INQUIRYDATA
USBSTOR_HandleQueryProperty
NTSTATUS USBSTOR_HandleQueryProperty(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: disk.c:224
USBSTOR_DEFAULT_MAX_PHYS_PAGES
#define USBSTOR_DEFAULT_MAX_PHYS_PAGES
Definition: disk.c:18
KeGetCurrentIrql
#define KeGetCurrentIrql()
Definition: env_spec_w32.h:706
Capabilities
_Must_inspect_result_ typedef _Out_ PHIDP_CAPS Capabilities
Definition: hidclass.h:103
Address
static WCHAR Address[46]
Definition: ping.c:68
IOCTL_STORAGE_QUERY_PROPERTY
#define IOCTL_STORAGE_QUERY_PROPERTY
Definition: ntddstor.h:178
IOCTL_STORAGE_GET_MEDIA_SERIAL_NUMBER
#define IOCTL_STORAGE_GET_MEDIA_SERIAL_NUMBER
Definition: ntddstor.h:151
IOCTL_SCSI_PASS_THROUGH
#define IOCTL_SCSI_PASS_THROUGH
Definition: scsi_port.h:47
IOCTL_SCSI_GET_ADDRESS
#define IOCTL_SCSI_GET_ADDRESS
Definition: scsi_port.h:52
IOCTL_SCSI_GET_CAPABILITIES
#define IOCTL_SCSI_GET_CAPABILITIES
Definition: scsi_port.h:50
SCSI_ADAPTER_BUS_INFO
struct _SCSI_ADAPTER_BUS_INFO SCSI_ADAPTER_BUS_INFO
IOCTL_SCSI_PASS_THROUGH_DIRECT
#define IOCTL_SCSI_PASS_THROUGH_DIRECT
Definition: scsi_port.h:51
PSCSI_INQUIRY_DATA
struct _SCSI_INQUIRY_DATA * PSCSI_INQUIRY_DATA
SCSI_ADDRESS
struct _SCSI_ADDRESS SCSI_ADDRESS
IOCTL_SCSI_GET_INQUIRY_DATA
#define IOCTL_SCSI_GET_INQUIRY_DATA
Definition: scsi_port.h:49
IO_SCSI_CAPABILITIES
struct _IO_SCSI_CAPABILITIES IO_SCSI_CAPABILITIES
SptiHandleScsiPassthru
NTSTATUS SptiHandleScsiPassthru(_In_ PDEVICE_OBJECT DeviceObject, _Inout_ PIRP Irp, _In_ ULONG MaximumTransferLength, _In_ ULONG MaximumPhysicalPages)
Handler for the IOCTL_SCSI_PASS_THROUGH and IOCTL_SCSI_PASS_THROUGH_DIRECT requests.
Definition: sptilib.c:888
_INQUIRYDATA::Versions
UCHAR Versions
Definition: cdrw_hw.h:1120
_INQUIRYDATA::ResponseDataFormat
UCHAR ResponseDataFormat
Definition: cdrw_hw.h:1121
_IO_SCSI_CAPABILITIES
Definition: scsi_port.h:135
_IO_STACK_LOCATION::DeviceIoControl
struct _IO_STACK_LOCATION::@1694::@1695 DeviceIoControl
_SCSI_ADAPTER_BUS_INFO
Definition: scsi_port.h:104
_SCSI_ADAPTER_BUS_INFO::BusData
SCSI_BUS_DATA BusData[1]
Definition: scsi_port.h:106
_SCSI_ADAPTER_BUS_INFO::NumberOfBuses
UCHAR NumberOfBuses
Definition: scsi_port.h:105
_SCSI_ADDRESS
Definition: scsi_port.h:146
_SCSI_BUS_DATA::InquiryDataOffset
ULONG InquiryDataOffset
Definition: scsi_port.h:98
_SCSI_BUS_DATA::NumberOfLogicalUnits
UCHAR NumberOfLogicalUnits
Definition: scsi_port.h:96
_SCSI_BUS_DATA::InitiatorBusId
UCHAR InitiatorBusId
Definition: scsi_port.h:97
_SCSI_INQUIRY_DATA
Definition: scsi_port.h:112
_SCSI_INQUIRY_DATA::TargetId
UCHAR TargetId
Definition: scsi_port.h:114
_SCSI_INQUIRY_DATA::InquiryData
UCHAR InquiryData[1]
Definition: scsi_port.h:119
_SCSI_INQUIRY_DATA::NextInquiryDataOffset
ULONG NextInquiryDataOffset
Definition: scsi_port.h:118
_SCSI_INQUIRY_DATA::Lun
UCHAR Lun
Definition: scsi_port.h:115
_SCSI_INQUIRY_DATA::PathId
UCHAR PathId
Definition: scsi_port.h:113
_SCSI_INQUIRY_DATA::InquiryDataLength
ULONG InquiryDataLength
Definition: scsi_port.h:117
_SCSI_INQUIRY_DATA::DeviceClaimed
BOOLEAN DeviceClaimed
Definition: scsi_port.h:116
PVOID
void * PVOID
Definition: typedefs.h:50
RtlCopyMemory
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
STATUS_INVALID_DEVICE_REQUEST
#define STATUS_INVALID_DEVICE_REQUEST
Definition: udferr_usr.h:138
USBSTOR_DEFAULT_MAX_TRANSFER_LENGTH
#define USBSTOR_DEFAULT_MAX_TRANSFER_LENGTH
Definition: usbstor.h:63
MinorFunction
_In_ UCHAR _In_ UCHAR MinorFunction
Definition: wdfdevice.h:1705

◆ USBSTOR_HandleExecuteSCSI()

NTSTATUS USBSTOR_HandleExecuteSCSI ( IN PDEVICE_OBJECT  DeviceObject,
IN PIRP  Irp 
)

Definition at line 542 of file scsi.c.

545{
546 PIO_STACK_LOCATION IoStack;
547 PSCSI_REQUEST_BLOCK Request;
548 PPDO_DEVICE_EXTENSION PDODeviceExtension = (PPDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
549
550 ASSERT(PDODeviceExtension->Common.IsFDO == FALSE);
551
552 IoStack = IoGetCurrentIrpStackLocation(Irp);
553 Request = IoStack->Parameters.Scsi.Srb;
554
555 DPRINT("USBSTOR_HandleExecuteSCSI Operation Code %x, Length %lu\n", SrbGetCdb(Request)->CDB10.OperationCode, Request->DataTransferLength);
556
557 /*
558 * Some stacks/devices don’t propagate the LUN in the CDB10 header bits.
559 * USB BOT uses CBW.bCBWLUN for addressing.
560 *
561 * TODO: There's actually a bigger bug here though,
562 * while the above CAN HAPPPEN:
563 * Card Readers multiplex their card slots for example, but we can deal with
564 * that as we put more effort into fixing the USB stack.
565 */
566 if (SrbGetCdb(Request)->CDB10.LogicalUnitNumber != PDODeviceExtension->LUN)
567 {
568 DPRINT1("USBSTOR_HandleExecuteSCSI: CDB LUN %lu != PDO LUN %lu (using CBW LUN)\n",
569 (ULONG)SrbGetCdb(Request)->CDB10.LogicalUnitNumber,
570 (ULONG)PDODeviceExtension->LUN);
571 }
572
573 return USBSTOR_SendCBWRequest(PDODeviceExtension->LowerDeviceObject->DeviceExtension, Irp);
574}
_IO_STACK_LOCATION::Scsi
struct _IO_STACK_LOCATION::@4278::@4300 Scsi
_SCSI_REQUEST_BLOCK
Definition: srb.h:248
USBSTOR_SendCBWRequest
static NTSTATUS USBSTOR_SendCBWRequest(IN PFDO_DEVICE_EXTENSION FDODeviceExtension, IN PIRP Irp)
Definition: scsi.c:456
SrbGetCdb
#define SrbGetCdb(srb)
Definition: usbstor.h:18
Request
_In_ WDFREQUEST Request
Definition: wdfdevice.h:547

Referenced by USBSTOR_HandleTransferError(), and USBSTOR_StartIo().

◆ USBSTOR_HandleInternalDeviceControl()

NTSTATUS USBSTOR_HandleInternalDeviceControl ( IN PDEVICE_OBJECT  DeviceObject,
IN PIRP  Irp 
)

Definition at line 84 of file disk.c.

87{
88 PIO_STACK_LOCATION IoStack;
89 PSCSI_REQUEST_BLOCK Request;
90 PPDO_DEVICE_EXTENSION PDODeviceExtension;
91 NTSTATUS Status;
92
93 IoStack = IoGetCurrentIrpStackLocation(Irp);
94 Request = (PSCSI_REQUEST_BLOCK)IoStack->Parameters.Others.Argument1;
95 ASSERT(Request);
96 PDODeviceExtension = (PPDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
97 ASSERT(PDODeviceExtension->Common.IsFDO == FALSE);
98
99 switch(Request->Function)
100 {
101 case SRB_FUNCTION_EXECUTE_SCSI:
102 {
103 DPRINT("SRB_FUNCTION_EXECUTE_SCSI\n");
104
105 if (!IsRequestValid(Irp))
106 {
107 Status = STATUS_INVALID_PARAMETER;
108 break;
109 }
110
111 if (Request->Cdb[0] == SCSIOP_MODE_SENSE)
112 {
113 DPRINT("USBSTOR_Scsi: SRB_FUNCTION_EXECUTE_SCSI - FIXME SCSIOP_MODE_SENSE\n");
114 // FIXME Get from registry WriteProtect for StorageDevicePolicies;
115 // L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\StorageDevicePolicies"
116 // QueryTable[0].Name = L"WriteProtect"
117 }
118
119 IoMarkIrpPending(Irp);
120 Request->SrbStatus = SRB_STATUS_PENDING;
121
122 // add the request
123 if (!USBSTOR_QueueAddIrp(PDODeviceExtension->LowerDeviceObject, Irp))
124 {
125 IoStartPacket(PDODeviceExtension->LowerDeviceObject, Irp, &Request->QueueSortKey, USBSTOR_CancelIo);
126 }
127
128 return STATUS_PENDING;
129 }
130 case SRB_FUNCTION_RELEASE_DEVICE:
131 {
132 DPRINT1("SRB_FUNCTION_RELEASE_DEVICE\n");
133 ASSERT(PDODeviceExtension->Claimed == TRUE);
134
135 // release claim
136 PDODeviceExtension->Claimed = FALSE;
137 Status = STATUS_SUCCESS;
138 break;
139 }
140 case SRB_FUNCTION_CLAIM_DEVICE:
141 {
142 DPRINT1("SRB_FUNCTION_CLAIM_DEVICE\n");
143
144 // check if the device has been claimed
145 if (PDODeviceExtension->Claimed)
146 {
147 // device has already been claimed
148 Status = STATUS_DEVICE_BUSY;
149 Request->SrbStatus = SRB_STATUS_BUSY;
150 break;
151 }
152
153 // claim device
154 PDODeviceExtension->Claimed = TRUE;
155
156 // output device object
157 Request->DataBuffer = DeviceObject;
158
159 Status = STATUS_SUCCESS;
160 break;
161 }
162 case SRB_FUNCTION_RELEASE_QUEUE:
163 {
164 DPRINT1("SRB_FUNCTION_RELEASE_QUEUE\n");
165
166 USBSTOR_QueueRelease(PDODeviceExtension->LowerDeviceObject);
167
168 Request->SrbStatus = SRB_STATUS_SUCCESS;
169 Status = STATUS_SUCCESS;
170 break;
171 }
172
173 case SRB_FUNCTION_SHUTDOWN:
174 case SRB_FUNCTION_FLUSH:
175 case SRB_FUNCTION_FLUSH_QUEUE:
176 {
177 DPRINT1("SRB_FUNCTION_FLUSH / SRB_FUNCTION_FLUSH_QUEUE / SRB_FUNCTION_SHUTDOWN\n");
178
179 // wait for pending requests to finish
180 USBSTOR_QueueWaitForPendingRequests(PDODeviceExtension->LowerDeviceObject);
181
182 Request->SrbStatus = SRB_STATUS_SUCCESS;
183 Status = STATUS_SUCCESS;
184 break;
185 }
186 default:
187 {
188 //
189 // not supported
190 //
191 Status = STATUS_NOT_SUPPORTED;
192 Request->SrbStatus = SRB_STATUS_ERROR;
193 }
194 }
195
196 Irp->IoStatus.Status = Status;
197 IoCompleteRequest(Irp, IO_NO_INCREMENT);
198 return Status;
199}
SCSIOP_MODE_SENSE
#define SCSIOP_MODE_SENSE
Definition: cdrw_hw.h:896
SRB_FUNCTION_RELEASE_DEVICE
#define SRB_FUNCTION_RELEASE_DEVICE
Definition: srb.h:321
SRB_FUNCTION_CLAIM_DEVICE
#define SRB_FUNCTION_CLAIM_DEVICE
Definition: srb.h:316
SRB_FUNCTION_RELEASE_QUEUE
#define SRB_FUNCTION_RELEASE_QUEUE
Definition: srb.h:319
SRB_FUNCTION_EXECUTE_SCSI
#define SRB_FUNCTION_EXECUTE_SCSI
Definition: srb.h:315
SRB_STATUS_PENDING
#define SRB_STATUS_PENDING
Definition: srb.h:340
SRB_FUNCTION_FLUSH
#define SRB_FUNCTION_FLUSH
Definition: srb.h:323
SRB_FUNCTION_FLUSH_QUEUE
#define SRB_FUNCTION_FLUSH_QUEUE
Definition: srb.h:329
SRB_FUNCTION_SHUTDOWN
#define SRB_FUNCTION_SHUTDOWN
Definition: srb.h:322
PSCSI_REQUEST_BLOCK
struct _SCSI_REQUEST_BLOCK * PSCSI_REQUEST_BLOCK
SRB_STATUS_ERROR
#define SRB_STATUS_ERROR
Definition: srb.h:344
SRB_STATUS_BUSY
#define SRB_STATUS_BUSY
Definition: srb.h:345
SRB_STATUS_SUCCESS
#define SRB_STATUS_SUCCESS
Definition: srb.h:341
IsRequestValid
static BOOLEAN IsRequestValid(PIRP Irp)
Definition: disk.c:22
USBSTOR_QueueAddIrp
BOOLEAN USBSTOR_QueueAddIrp(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: queue.c:75
USBSTOR_QueueRelease
VOID USBSTOR_QueueRelease(IN PDEVICE_OBJECT DeviceObject)
Definition: queue.c:262
USBSTOR_QueueWaitForPendingRequests
VOID USBSTOR_QueueWaitForPendingRequests(IN PDEVICE_OBJECT DeviceObject)
Definition: queue.c:171
USBSTOR_CancelIo
VOID NTAPI USBSTOR_CancelIo(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: queue.c:28
IoMarkIrpPending
IoMarkIrpPending(Irp)
IoStartPacket
VOID NTAPI IoStartPacket(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PULONG Key, IN PDRIVER_CANCEL CancelFunction)
Definition: device.c:1876
_IO_STACK_LOCATION::Others
struct _IO_STACK_LOCATION::@4278::@4317 Others
STATUS_INVALID_PARAMETER
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
STATUS_DEVICE_BUSY
#define STATUS_DEVICE_BUSY
Definition: udferr_usr.h:129

◆ USBSTOR_PdoHandlePnp()

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

Definition at line 534 of file pdo.c.

537{
538 PIO_STACK_LOCATION IoStack;
539 PPDO_DEVICE_EXTENSION DeviceExtension;
540 NTSTATUS Status;
541 PDEVICE_CAPABILITIES Caps;
542 ULONG bDelete;
543
544 IoStack = IoGetCurrentIrpStackLocation(Irp);
545 DeviceExtension = (PPDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
546 ASSERT(DeviceExtension->Common.IsFDO == FALSE);
547
548 switch(IoStack->MinorFunction)
549 {
550 case IRP_MN_QUERY_DEVICE_RELATIONS:
551 {
552 Status = USBSTOR_PdoHandleDeviceRelations(DeviceObject, Irp);
553 break;
554 }
555 case IRP_MN_QUERY_DEVICE_TEXT:
556 {
557 Status = USBSTOR_PdoHandleQueryDeviceText(DeviceObject, Irp);
558 break;
559 }
560 case IRP_MN_QUERY_ID:
561 {
562 if (IoStack->Parameters.QueryId.IdType == BusQueryDeviceID)
563 {
564 Status = USBSTOR_PdoHandleQueryDeviceId(DeviceObject, Irp);
565 break;
566 }
567 else if (IoStack->Parameters.QueryId.IdType == BusQueryHardwareIDs)
568 {
569 Status = USBSTOR_PdoHandleQueryHardwareId(DeviceObject, Irp);
570 break;
571 }
572 else if (IoStack->Parameters.QueryId.IdType == BusQueryInstanceID)
573 {
574 Status = USBSTOR_PdoHandleQueryInstanceId(DeviceObject, Irp);
575 break;
576 }
577 else if (IoStack->Parameters.QueryId.IdType == BusQueryCompatibleIDs)
578 {
579 Status = USBSTOR_PdoHandleQueryCompatibleId(DeviceObject, Irp);
580 break;
581 }
582
583 DPRINT1("USBSTOR_PdoHandlePnp: IRP_MN_QUERY_ID IdType %x unimplemented\n", IoStack->Parameters.QueryId.IdType);
584 Status = STATUS_NOT_SUPPORTED;
585 Irp->IoStatus.Information = 0;
586 break;
587 }
588 case IRP_MN_REMOVE_DEVICE:
589 {
590 DPRINT("IRP_MN_REMOVE_DEVICE\n");
591
592 if(*DeviceExtension->PDODeviceObject != NULL)
593 {
594 *DeviceExtension->PDODeviceObject = NULL;
595 bDelete = TRUE;
596 }
597 else
598 {
599 // device object already marked for deletion
600 bDelete = FALSE;
601 }
602
603 Irp->IoStatus.Status = STATUS_SUCCESS;
604 IoCompleteRequest(Irp, IO_NO_INCREMENT);
605
606 if (bDelete)
607 {
608 IoDeleteDevice(DeviceObject);
609 }
610 return STATUS_SUCCESS;
611 }
612 case IRP_MN_QUERY_CAPABILITIES:
613 {
614 // just forward irp to lower device
615 Status = STATUS_UNSUCCESSFUL;
616
617 if (IoForwardIrpSynchronously(DeviceExtension->LowerDeviceObject, Irp))
618 {
619 Status = Irp->IoStatus.Status;
620 ASSERT(Status == STATUS_SUCCESS);
621
622 if (NT_SUCCESS(Status))
623 {
624 // check if no unique id
625 Caps = (PDEVICE_CAPABILITIES)IoStack->Parameters.DeviceCapabilities.Capabilities;
626 Caps->UniqueID = FALSE; // no unique id is supported
627 Caps->Removable = TRUE; //FIXME
628 }
629 }
630 break;
631 }
632 case IRP_MN_QUERY_REMOVE_DEVICE:
633 case IRP_MN_QUERY_STOP_DEVICE:
634 {
635 if (DeviceExtension->Claimed)
636 {
637 Status = STATUS_UNSUCCESSFUL;
638 DPRINT1("[USBSTOR] Request %x fails because device is still claimed\n", IoStack->MinorFunction);
639 }
640 else
641 Status = STATUS_SUCCESS;
642 break;
643 }
644 case IRP_MN_START_DEVICE:
645 {
646 // no-op for PDO
647 Status = STATUS_SUCCESS;
648 break;
649 }
650 case IRP_MN_SURPRISE_REMOVAL:
651 {
652 Status = STATUS_SUCCESS;
653 break;
654 }
655 default:
656 {
657 // do nothing
658 Status = Irp->IoStatus.Status;
659 }
660 }
661
662 if (Status != STATUS_PENDING)
663 {
664 Irp->IoStatus.Status = Status;
665 IoCompleteRequest(Irp, IO_NO_INCREMENT);
666 }
667
668 return Status;
669}
IoDeleteDevice
VOID NTAPI IoDeleteDevice(IN PDEVICE_OBJECT DeviceObject)
Definition: device.c:1251
IoForwardIrpSynchronously
BOOLEAN NTAPI IoForwardIrpSynchronously(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: irp.c:1625
_IO_STACK_LOCATION::DeviceCapabilities
struct _IO_STACK_LOCATION::@4278::@4305 DeviceCapabilities
_IO_STACK_LOCATION::QueryId
struct _IO_STACK_LOCATION::@4278::@4309 QueryId
USBSTOR_PdoHandleQueryInstanceId
NTSTATUS USBSTOR_PdoHandleQueryInstanceId(IN PDEVICE_OBJECT DeviceObject, IN OUT PIRP Irp)
Definition: pdo.c:434
USBSTOR_PdoHandleQueryCompatibleId
NTSTATUS USBSTOR_PdoHandleQueryCompatibleId(IN PDEVICE_OBJECT DeviceObject, IN OUT PIRP Irp)
Definition: pdo.c:394
USBSTOR_PdoHandleQueryDeviceId
NTSTATUS USBSTOR_PdoHandleQueryDeviceId(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: pdo.c:179
USBSTOR_PdoHandleQueryHardwareId
NTSTATUS USBSTOR_PdoHandleQueryHardwareId(IN PDEVICE_OBJECT DeviceObject, IN OUT PIRP Irp)
Definition: pdo.c:267
USBSTOR_PdoHandleDeviceRelations
NTSTATUS USBSTOR_PdoHandleDeviceRelations(IN PDEVICE_OBJECT DeviceObject, IN OUT PIRP Irp)
Definition: pdo.c:500
USBSTOR_PdoHandleQueryDeviceText
NTSTATUS USBSTOR_PdoHandleQueryDeviceText(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: pdo.c:125
IRP_MN_QUERY_ID
#define IRP_MN_QUERY_ID
IRP_MN_QUERY_DEVICE_TEXT
#define IRP_MN_QUERY_DEVICE_TEXT
PDEVICE_CAPABILITIES
* PDEVICE_CAPABILITIES
Definition: iotypes.h:965
BusQueryCompatibleIDs
@ BusQueryCompatibleIDs
Definition: iotypes.h:2940
BusQueryInstanceID
@ BusQueryInstanceID
Definition: iotypes.h:2941
BusQueryDeviceID
@ BusQueryDeviceID
Definition: iotypes.h:2938
BusQueryHardwareIDs
@ BusQueryHardwareIDs
Definition: iotypes.h:2939

◆ USBSTOR_QueueAddIrp()

BOOLEAN USBSTOR_QueueAddIrp ( IN PDEVICE_OBJECT  DeviceObject,
IN PIRP  Irp 
)

Definition at line 75 of file queue.c.

78{
79 PDRIVER_CANCEL OldDriverCancel;
80 KIRQL OldLevel;
81 PFDO_DEVICE_EXTENSION FDODeviceExtension;
82 BOOLEAN IrpListFreeze;
83 BOOLEAN SrbProcessing;
84 PIO_STACK_LOCATION IoStack = IoGetCurrentIrpStackLocation(Irp);
85 PSCSI_REQUEST_BLOCK Request = (PSCSI_REQUEST_BLOCK)IoStack->Parameters.Others.Argument1;
86
87 FDODeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
88 ASSERT(FDODeviceExtension->Common.IsFDO);
89
90 IoMarkIrpPending(Irp);
91
92 KeAcquireSpinLock(&FDODeviceExtension->IrpListLock, &OldLevel);
93
94 SrbProcessing = FDODeviceExtension->IrpPendingCount != 0;
95
96 if (SrbProcessing)
97 {
98 // add irp to queue
99 InsertTailList(&FDODeviceExtension->IrpListHead, &Irp->Tail.Overlay.ListEntry);
100 }
101
102 FDODeviceExtension->IrpPendingCount++;
103 KeClearEvent(&FDODeviceExtension->NoPendingRequests);
104
105 // check if queue is freezed
106 IrpListFreeze = BooleanFlagOn(FDODeviceExtension->Flags, USBSTOR_FDO_FLAGS_IRP_LIST_FREEZE);
107
108 KeReleaseSpinLock(&FDODeviceExtension->IrpListLock, OldLevel);
109
110 // synchronize with cancellations by holding the cancel lock
111 IoAcquireCancelSpinLock(&Irp->CancelIrql);
112
113 if (SrbProcessing)
114 {
115 ASSERT(FDODeviceExtension->ActiveSrb != NULL);
116
117 OldDriverCancel = IoSetCancelRoutine(Irp, USBSTOR_Cancel);
118 }
119 else
120 {
121 ASSERT(FDODeviceExtension->ActiveSrb == NULL);
122
123 FDODeviceExtension->ActiveSrb = Request;
124 OldDriverCancel = IoSetCancelRoutine(Irp, USBSTOR_CancelIo);
125 }
126
127 // check if the irp has already been cancelled
128 if (Irp->Cancel && OldDriverCancel == NULL)
129 {
130 // cancel irp
131 Irp->CancelRoutine(DeviceObject, Irp);
132 return FALSE;
133 }
134
135 IoReleaseCancelSpinLock(Irp->CancelIrql);
136
137 // if list is freezed, dont start this packet
138 DPRINT("IrpListFreeze: %lu IrpPendingCount %lu\n", IrpListFreeze, FDODeviceExtension->IrpPendingCount);
139
140 return (IrpListFreeze || SrbProcessing);
141}
USBSTOR_Cancel
VOID NTAPI USBSTOR_Cancel(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: queue.c:51
InsertTailList
#define InsertTailList(ListHead, Entry)
Definition: env_spec_w32.h:1003
KIRQL
UCHAR KIRQL
Definition: env_spec_w32.h:591
KeReleaseSpinLock
#define KeReleaseSpinLock(sl, irql)
Definition: env_spec_w32.h:627
KeAcquireSpinLock
#define KeAcquireSpinLock(sl, irql)
Definition: env_spec_w32.h:609
KeClearEvent
VOID NTAPI KeClearEvent(IN PKEVENT Event)
Definition: eventobj.c:22
BooleanFlagOn
#define BooleanFlagOn(F, SF)
Definition: ext2fs.h:183
IoSetCancelRoutine
IoSetCancelRoutine(Irp, CancelRoutine)
IoAcquireCancelSpinLock
VOID NTAPI IoAcquireCancelSpinLock(OUT PKIRQL Irql)
Definition: util.c:56
_FDO_DEVICE_EXTENSION::ListEntry
LIST_ENTRY ListEntry
Definition: pci.h:86
_FDO_DEVICE_EXTENSION::Flags
ULONG Flags
Definition: serenum.h:42
USBSTOR_FDO_FLAGS_IRP_LIST_FREEZE
#define USBSTOR_FDO_FLAGS_IRP_LIST_FREEZE
Definition: usbstor.h:118
PDRIVER_CANCEL
DRIVER_CANCEL * PDRIVER_CANCEL
Definition: iotypes.h:2761

◆ USBSTOR_QueueInitialize()

VOID USBSTOR_QueueInitialize ( PFDO_DEVICE_EXTENSION  FDODeviceExtension)

Definition at line 17 of file queue.c.

19{
20 ASSERT(FDODeviceExtension->Common.IsFDO);
21 KeInitializeSpinLock(&FDODeviceExtension->IrpListLock);
22 InitializeListHead(&FDODeviceExtension->IrpListHead);
23 KeInitializeEvent(&FDODeviceExtension->NoPendingRequests, NotificationEvent, TRUE);
24}
InitializeListHead
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
KeInitializeSpinLock
#define KeInitializeSpinLock(sl)
Definition: env_spec_w32.h:604

◆ USBSTOR_QueueNextRequest()

VOID USBSTOR_QueueNextRequest ( IN PDEVICE_OBJECT  DeviceObject)

Definition at line 220 of file queue.c.

222{
223 PFDO_DEVICE_EXTENSION FDODeviceExtension;
224 PIRP Irp;
225 PIO_STACK_LOCATION IoStack;
226 PSCSI_REQUEST_BLOCK Request;
227
228 FDODeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
229 ASSERT(FDODeviceExtension->Common.IsFDO);
230
231 // check first if there's already a request pending or the queue is frozen
232 if (FDODeviceExtension->ActiveSrb != NULL ||
233 BooleanFlagOn(FDODeviceExtension->Flags, USBSTOR_FDO_FLAGS_IRP_LIST_FREEZE))
234 {
235 // no work to do yet
236 return;
237 }
238
239 // remove first irp from list
240 Irp = USBSTOR_RemoveIrp(DeviceObject);
241
242 // is there an irp pending
243 if (!Irp)
244 {
245 // no work to do
246 IoStartNextPacket(DeviceObject, TRUE);
247 return;
248 }
249
250 IoStack = IoGetCurrentIrpStackLocation(Irp);
251 Request = (PSCSI_REQUEST_BLOCK)IoStack->Parameters.Others.Argument1;
252 ASSERT(Request);
253
254 FDODeviceExtension->ActiveSrb = Request;
255
256 // start next packet
257 IoStartPacket(DeviceObject, Irp, &Request->QueueSortKey, USBSTOR_CancelIo);
258 IoStartNextPacket(DeviceObject, TRUE);
259}
USBSTOR_RemoveIrp
PIRP USBSTOR_RemoveIrp(IN PDEVICE_OBJECT DeviceObject)
Definition: queue.c:144
IoStartNextPacket
VOID NTAPI IoStartNextPacket(IN PDEVICE_OBJECT DeviceObject, IN BOOLEAN Cancelable)
Definition: device.c:1847

◆ USBSTOR_QueueRelease()

VOID USBSTOR_QueueRelease ( IN PDEVICE_OBJECT  DeviceObject)

Definition at line 262 of file queue.c.

264{
265 PFDO_DEVICE_EXTENSION FDODeviceExtension;
266 PIRP Irp;
267 KIRQL OldLevel;
268 PIO_STACK_LOCATION IoStack;
269 PSCSI_REQUEST_BLOCK Request;
270
271 FDODeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
272 ASSERT(FDODeviceExtension->Common.IsFDO);
273
274 KeAcquireSpinLock(&FDODeviceExtension->IrpListLock, &OldLevel);
275
276 // clear freezed status
277 FDODeviceExtension->Flags &= ~USBSTOR_FDO_FLAGS_IRP_LIST_FREEZE;
278
279 KeReleaseSpinLock(&FDODeviceExtension->IrpListLock, OldLevel);
280
281 // grab newest irp
282 Irp = USBSTOR_RemoveIrp(DeviceObject);
283
284 if (!Irp)
285 {
286 return;
287 }
288
289 IoStack = IoGetCurrentIrpStackLocation(Irp);
290 Request = (PSCSI_REQUEST_BLOCK)IoStack->Parameters.Others.Argument1;
291
292 IoStartPacket(DeviceObject,
293 Irp,
294 &Request->QueueSortKey,
295 USBSTOR_CancelIo);
296}

◆ USBSTOR_QueueResetDevice()

VOID NTAPI USBSTOR_QueueResetDevice ( IN PFDO_DEVICE_EXTENSION  FDODeviceExtension)

Definition at line 148 of file error.c.

150{
151 KIRQL OldIrql;
152
153 DPRINT("USBSTOR_QueueResetDevice\n");
154
155 KeAcquireSpinLock(&FDODeviceExtension->CommonLock, &OldIrql);
156 FDODeviceExtension->Flags |= USBSTOR_FDO_FLAGS_DEVICE_RESETTING;
157 KeReleaseSpinLock(&FDODeviceExtension->CommonLock, OldIrql);
158
159 IoQueueWorkItem(FDODeviceExtension->ResetDeviceWorkItem,
160 USBSTOR_ResetDeviceWorkItemRoutine,
161 CriticalWorkQueue,
162 NULL);
163}
USBSTOR_ResetDeviceWorkItemRoutine
VOID NTAPI USBSTOR_ResetDeviceWorkItemRoutine(IN PDEVICE_OBJECT FdoDevice, IN PVOID Context)
Definition: error.c:93
IoQueueWorkItem
VOID NTAPI IoQueueWorkItem(IN PIO_WORKITEM IoWorkItem, IN PIO_WORKITEM_ROUTINE WorkerRoutine, IN WORK_QUEUE_TYPE QueueType, IN PVOID Context)
Definition: iowork.c:40
USBSTOR_FDO_FLAGS_DEVICE_RESETTING
#define USBSTOR_FDO_FLAGS_DEVICE_RESETTING
Definition: usbstor.h:117
CriticalWorkQueue
@ CriticalWorkQueue
Definition: extypes.h:189
OldIrql
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:778

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

◆ USBSTOR_QueueResetPipe()

VOID NTAPI USBSTOR_QueueResetPipe ( IN PFDO_DEVICE_EXTENSION  FDODeviceExtension)

Definition at line 135 of file error.c.

137{
138 DPRINT("USBSTOR_QueueResetPipe\n");
139
140 IoQueueWorkItem(FDODeviceExtension->ResetDeviceWorkItem,
141 USBSTOR_ResetPipeWorkItemRoutine,
142 CriticalWorkQueue,
143 FDODeviceExtension);
144}
USBSTOR_ResetPipeWorkItemRoutine
VOID NTAPI USBSTOR_ResetPipeWorkItemRoutine(IN PDEVICE_OBJECT FdoDevice, IN PVOID Ctx)
Definition: error.c:75

Referenced by USBSTOR_CSWCompletionRoutine(), and USBSTOR_DataCompletionRoutine().

◆ USBSTOR_QueueTerminateRequest()

VOID USBSTOR_QueueTerminateRequest ( IN PDEVICE_OBJECT  DeviceObject,
IN PIRP  Irp 
)

Definition at line 186 of file queue.c.

189{
190 KIRQL OldLevel;
191 PFDO_DEVICE_EXTENSION FDODeviceExtension;
192 PIO_STACK_LOCATION IoStack = IoGetCurrentIrpStackLocation(Irp);
193 PSCSI_REQUEST_BLOCK Request = (PSCSI_REQUEST_BLOCK)IoStack->Parameters.Others.Argument1;
194
195 FDODeviceExtension = (PFDO_DEVICE_EXTENSION)FDODeviceObject->DeviceExtension;
196 ASSERT(FDODeviceExtension->Common.IsFDO);
197
198 KeAcquireSpinLock(&FDODeviceExtension->IrpListLock, &OldLevel);
199
200 FDODeviceExtension->IrpPendingCount--;
201
202 // check if this was our current active SRB
203 if (FDODeviceExtension->ActiveSrb == Request)
204 {
205 // indicate processing is completed
206 FDODeviceExtension->ActiveSrb = NULL;
207 }
208
209 // Set the event if nothing else is pending
210 if (FDODeviceExtension->IrpPendingCount == 0 &&
211 FDODeviceExtension->ActiveSrb == NULL)
212 {
213 KeSetEvent(&FDODeviceExtension->NoPendingRequests, IO_NO_INCREMENT, FALSE);
214 }
215
216 KeReleaseSpinLock(&FDODeviceExtension->IrpListLock, OldLevel);
217}
KeSetEvent
#define KeSetEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:476

◆ USBSTOR_QueueWaitForPendingRequests()

VOID USBSTOR_QueueWaitForPendingRequests ( IN PDEVICE_OBJECT  DeviceObject)

Definition at line 171 of file queue.c.

173{
174 PFDO_DEVICE_EXTENSION FDODeviceExtension;
175
176 FDODeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
177
178 KeWaitForSingleObject(&FDODeviceExtension->NoPendingRequests,
179 Executive,
180 KernelMode,
181 FALSE,
182 NULL);
183}

◆ USBSTOR_ResetDevice()

NTSTATUS USBSTOR_ResetDevice ( IN PDEVICE_OBJECT  DeviceObject,
IN PFDO_DEVICE_EXTENSION  DeviceExtension 
)

Definition at line 219 of file misc.c.

222{
223 NTSTATUS Status;
224
225 Status = USBSTOR_ClassRequest(DeviceObject, DeviceExtension, USB_BULK_RESET_DEVICE, DeviceExtension->InterfaceInformation->InterfaceNumber, USBD_TRANSFER_DIRECTION_OUT, 0, NULL);
226 return Status;
227}
USBD_TRANSFER_DIRECTION_OUT
#define USBD_TRANSFER_DIRECTION_OUT
Definition: usb.h:159
USB_BULK_RESET_DEVICE
#define USB_BULK_RESET_DEVICE
Definition: usbstor.h:56

◆ USBSTOR_ResetPipeWithHandle()

NTSTATUS USBSTOR_ResetPipeWithHandle ( IN PDEVICE_OBJECT  DeviceObject,
IN USBD_PIPE_HANDLE  PipeHandle 
)

Definition at line 46 of file error.c.

49{
50 PURB Urb;
51 NTSTATUS Status;
52
53 DPRINT("Allocating URB\n");
54 Urb = (PURB)AllocateItem(NonPagedPool, sizeof(struct _URB_PIPE_REQUEST));
55 if (!Urb)
56 {
57 DPRINT1("OutofMemory!\n");
58 return STATUS_INSUFFICIENT_RESOURCES;
59 }
60
61 Urb->UrbPipeRequest.Hdr.Length = sizeof(struct _URB_PIPE_REQUEST);
62 Urb->UrbPipeRequest.Hdr.Function = URB_FUNCTION_SYNC_RESET_PIPE_AND_CLEAR_STALL;
63 Urb->UrbPipeRequest.PipeHandle = PipeHandle;
64
65 // send the request
66 DPRINT1("Sending Request DeviceObject %p, Urb %p\n", DeviceObject, Urb);
67 Status = USBSTOR_SyncUrbRequest(DeviceObject, Urb);
68
69 FreeItem(Urb);
70 return Status;
71}
_IO_STACK_LOCATION::Length
ULONG Length
Definition: iotypes.h:3140
_URB_PIPE_REQUEST
Definition: usb.h:314
_URB_PIPE_REQUEST::PipeHandle
USBD_PIPE_HANDLE PipeHandle
Definition: usb.h:316
URB_FUNCTION_SYNC_RESET_PIPE_AND_CLEAR_STALL
#define URB_FUNCTION_SYNC_RESET_PIPE_AND_CLEAR_STALL
Definition: usb.h:116

◆ USBSTOR_SelectConfigurationAndInterface()

NTSTATUS USBSTOR_SelectConfigurationAndInterface ( IN PDEVICE_OBJECT  DeviceObject,
IN PFDO_DEVICE_EXTENSION  DeviceExtension 
)

Definition at line 234 of file descriptor.c.

237{
238 PUSB_INTERFACE_DESCRIPTOR InterfaceDescriptor;
239 PUSB_ENDPOINT_DESCRIPTOR InEndpointDescriptor, OutEndpointDescriptor;
240 NTSTATUS Status;
241 PURB Urb;
242 PUSBD_INTERFACE_LIST_ENTRY InterfaceList;
243
244 Status = USBSTOR_ScanConfigurationDescriptor(DeviceExtension->ConfigurationDescriptor, &InterfaceDescriptor, &InEndpointDescriptor, &OutEndpointDescriptor);
245 if (!NT_SUCCESS(Status))
246 {
247 return Status;
248 }
249
250 // now allocate one interface entry and terminating null entry
251 InterfaceList = (PUSBD_INTERFACE_LIST_ENTRY)AllocateItem(PagedPool, sizeof(USBD_INTERFACE_LIST_ENTRY) * 2);
252 if (!InterfaceList)
253 {
254 return STATUS_INSUFFICIENT_RESOURCES;
255 }
256
257 // initialize interface list entry
258 InterfaceList[0].InterfaceDescriptor = InterfaceDescriptor;
259
260 // now allocate the urb
261 Urb = USBD_CreateConfigurationRequestEx(DeviceExtension->ConfigurationDescriptor, InterfaceList);
262 if (!Urb)
263 {
264 FreeItem(InterfaceList);
265 return STATUS_INSUFFICIENT_RESOURCES;
266 }
267
268
269 ASSERT(InterfaceList[0].Interface);
270
271 // submit urb
272 Status = USBSTOR_SyncUrbRequest(DeviceExtension->LowerDeviceObject, Urb);
273 if (!NT_SUCCESS(Status))
274 {
275 // failed to set configuration
276 DPRINT1("USBSTOR_SelectConfiguration failed to set interface %x\n", Status);
277 FreeItem(InterfaceList);
278 ExFreePoolWithTag(Urb, 0);
279 return Status;
280 }
281
282 // backup interface information
283 DeviceExtension->InterfaceInformation = (PUSBD_INTERFACE_INFORMATION)AllocateItem(NonPagedPool, Urb->UrbSelectConfiguration.Interface.Length);
284 if (!DeviceExtension->InterfaceInformation)
285 {
286 FreeItem(InterfaceList);
287 ExFreePoolWithTag(Urb, 0);
288 return STATUS_INSUFFICIENT_RESOURCES;
289 }
290
291 // copy interface information
292 RtlCopyMemory(DeviceExtension->InterfaceInformation, &Urb->UrbSelectConfiguration.Interface, Urb->UrbSelectConfiguration.Interface.Length);
293
294 // store pipe handle
295 DeviceExtension->ConfigurationHandle = Urb->UrbSelectConfiguration.ConfigurationHandle;
296
297 // now prepare interface urb
298 UsbBuildSelectInterfaceRequest(Urb, GET_SELECT_INTERFACE_REQUEST_SIZE(InterfaceDescriptor->bNumEndpoints), DeviceExtension->ConfigurationHandle, InterfaceDescriptor->bInterfaceNumber, InterfaceDescriptor->bAlternateSetting);
299
300 // copy interface information structure back - as offset for SelectConfiguration / SelectInterface request do differ
301 RtlCopyMemory(&Urb->UrbSelectInterface.Interface, DeviceExtension->InterfaceInformation, DeviceExtension->InterfaceInformation->Length);
302
303 // now select the interface
304 Status = USBSTOR_SyncUrbRequest(DeviceExtension->LowerDeviceObject, Urb);
305 if (NT_SUCCESS(Status))
306 {
307 // update configuration info
308 ASSERT(Urb->UrbSelectInterface.Interface.Length == DeviceExtension->InterfaceInformation->Length);
309 RtlCopyMemory(DeviceExtension->InterfaceInformation, &Urb->UrbSelectInterface.Interface, Urb->UrbSelectInterface.Interface.Length);
310 }
311
312 FreeItem(InterfaceList);
313 ExFreePoolWithTag(Urb, 0);
314
315 return Status;
316}
USBSTOR_ScanConfigurationDescriptor
NTSTATUS NTAPI USBSTOR_ScanConfigurationDescriptor(IN PUSB_CONFIGURATION_DESCRIPTOR ConfigurationDescriptor, OUT PUSB_INTERFACE_DESCRIPTOR *OutInterfaceDescriptor, OUT PUSB_ENDPOINT_DESCRIPTOR *InEndpointDescriptor, OUT PUSB_ENDPOINT_DESCRIPTOR *OutEndpointDescriptor)
Definition: descriptor.c:140
PagedPool
#define PagedPool
Definition: env_spec_w32.h:308
_IO_STACK_LOCATION::Interface
PINTERFACE Interface
Definition: iotypes.h:3250
_USBD_INTERFACE_LIST_ENTRY
Definition: usbdlib.h:7
_USBD_INTERFACE_LIST_ENTRY::InterfaceDescriptor
PUSB_INTERFACE_DESCRIPTOR InterfaceDescriptor
Definition: usbdlib.h:8
_USB_ENDPOINT_DESCRIPTOR
Definition: usb100.h:127
_USB_INTERFACE_DESCRIPTOR
Definition: usb100.h:147
PUSBD_INTERFACE_INFORMATION
struct _USBD_INTERFACE_INFORMATION * PUSBD_INTERFACE_INFORMATION
USBD_CreateConfigurationRequestEx
PURB NTAPI USBD_CreateConfigurationRequestEx(PUSB_CONFIGURATION_DESCRIPTOR ConfigurationDescriptor, PUSBD_INTERFACE_LIST_ENTRY InterfaceList)
Definition: usbd.c:329
UsbBuildSelectInterfaceRequest
#define UsbBuildSelectInterfaceRequest(urb, length, configurationHandle, interfaceNumber, alternateSetting)
Definition: usbdlib.h:59
InterfaceList
_In_ PUSBD_INTERFACE_LIST_ENTRY InterfaceList
Definition: usbdlib.h:181
GET_SELECT_INTERFACE_REQUEST_SIZE
#define GET_SELECT_INTERFACE_REQUEST_SIZE(totalPipes)
Definition: usbdlib.h:117
PUSBD_INTERFACE_LIST_ENTRY
struct _USBD_INTERFACE_LIST_ENTRY * PUSBD_INTERFACE_LIST_ENTRY
Interface
_Must_inspect_result_ _In_ WDFDEVICE _In_ LPCGUID _Out_ PINTERFACE Interface
Definition: wdffdo.h:465
InterfaceDescriptor
_In_ WDFUSBINTERFACE _In_ UCHAR _Out_ PUSB_INTERFACE_DESCRIPTOR InterfaceDescriptor
Definition: wdfusb.h:2334

◆ USBSTOR_SendCSWRequest()

NTSTATUS USBSTOR_SendCSWRequest ( PFDO_DEVICE_EXTENSION  FDODeviceExtension,
PIRP  Irp 
)

Definition at line 242 of file scsi.c.

245{
246 return USBSTOR_IssueBulkOrInterruptRequest(FDODeviceExtension,
247 Irp,
248 FDODeviceExtension->InterfaceInformation->Pipes[FDODeviceExtension->BulkInPipeIndex].PipeHandle,
249 USBD_TRANSFER_DIRECTION_IN,
250 sizeof(CSW),
251 &FDODeviceExtension->CurrentIrpContext.csw,
252 NULL,
253 USBSTOR_CSWCompletionRoutine);
254}
CSW
Definition: usbstor.h:88
USBSTOR_CSWCompletionRoutine
IO_COMPLETION_ROUTINE USBSTOR_CSWCompletionRoutine
Definition: scsi.c:125
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)
Definition: scsi.c:60

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

◆ USBSTOR_StartIo()

VOID NTAPI USBSTOR_StartIo ( PDEVICE_OBJECT  DeviceObject,
PIRP  Irp 
)

Definition at line 300 of file queue.c.

303{
304 PIO_STACK_LOCATION IoStack;
305 PSCSI_REQUEST_BLOCK Request;
306 PFDO_DEVICE_EXTENSION FDODeviceExtension;
307 PPDO_DEVICE_EXTENSION PDODeviceExtension;
308 KIRQL OldLevel;
309 BOOLEAN ResetInProgress;
310
311 DPRINT("USBSTOR_StartIo\n");
312
313 FDODeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
314 ASSERT(FDODeviceExtension->Common.IsFDO);
315
316 IoAcquireCancelSpinLock(&OldLevel);
317
318 IoSetCancelRoutine(Irp, NULL);
319
320 // check if the irp has been cancelled
321 if (Irp->Cancel)
322 {
323 IoReleaseCancelSpinLock(OldLevel);
324
325 Irp->IoStatus.Status = STATUS_CANCELLED;
326 Irp->IoStatus.Information = 0;
327
328 USBSTOR_QueueTerminateRequest(DeviceObject, Irp);
329 IoCompleteRequest(Irp, IO_NO_INCREMENT);
330 USBSTOR_QueueNextRequest(DeviceObject);
331 return;
332 }
333
334 IoReleaseCancelSpinLock(OldLevel);
335
336 KeAcquireSpinLock(&FDODeviceExtension->CommonLock, &OldLevel);
337 ResetInProgress = BooleanFlagOn(FDODeviceExtension->Flags, USBSTOR_FDO_FLAGS_DEVICE_RESETTING);
338 KeReleaseSpinLock(&FDODeviceExtension->CommonLock, OldLevel);
339
340 IoStack = IoGetCurrentIrpStackLocation(Irp);
341
342 PDODeviceExtension = (PPDO_DEVICE_EXTENSION)IoStack->DeviceObject->DeviceExtension;
343 Request = IoStack->Parameters.Scsi.Srb;
344 ASSERT(PDODeviceExtension->Common.IsFDO == FALSE);
345
346 if (ResetInProgress)
347 {
348 // hard reset is in progress
349 Request->SrbStatus = SRB_STATUS_NO_DEVICE;
350 Request->DataTransferLength = 0;
351 Irp->IoStatus.Information = 0;
352 Irp->IoStatus.Status = STATUS_DEVICE_DOES_NOT_EXIST;
353 USBSTOR_QueueTerminateRequest(DeviceObject, Irp);
354 IoCompleteRequest(Irp, IO_NO_INCREMENT);
355 USBSTOR_QueueNextRequest(DeviceObject);
356 return;
357 }
358
359 USBSTOR_HandleExecuteSCSI(IoStack->DeviceObject, Irp);
360
361 // FIXME: handle error
362}
SRB_STATUS_NO_DEVICE
#define SRB_STATUS_NO_DEVICE
Definition: srb.h:348
STATUS_DEVICE_DOES_NOT_EXIST
#define STATUS_DEVICE_DOES_NOT_EXIST
Definition: ntstatus.h:522
_IO_STACK_LOCATION::DeviceObject
PDEVICE_OBJECT DeviceObject
Definition: iotypes.h:3225
USBSTOR_HandleExecuteSCSI
NTSTATUS USBSTOR_HandleExecuteSCSI(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: scsi.c:542

◆ USBSTOR_SyncUrbRequest()

NTSTATUS USBSTOR_SyncUrbRequest ( IN PDEVICE_OBJECT  DeviceObject,
OUT PURB  UrbRequest 
)

Definition at line 83 of file misc.c.

86{
87 PIRP Irp;
88 PIO_STACK_LOCATION IoStack;
89 KEVENT Event;
90 NTSTATUS Status;
91
92 Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
93 if (!Irp)
94 {
95 return STATUS_INSUFFICIENT_RESOURCES;
96 }
97
98 KeInitializeEvent(&Event, NotificationEvent, FALSE);
99
100 IoStack = IoGetNextIrpStackLocation(Irp);
101
102 // initialize stack location
103 IoStack->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL;
104 IoStack->Parameters.DeviceIoControl.IoControlCode = IOCTL_INTERNAL_USB_SUBMIT_URB;
105 IoStack->Parameters.Others.Argument1 = (PVOID)UrbRequest;
106 IoStack->Parameters.DeviceIoControl.InputBufferLength = UrbRequest->UrbHeader.Length;
107 Irp->IoStatus.Status = STATUS_SUCCESS;
108
109 IoSetCompletionRoutine(Irp, USBSTOR_SyncForwardIrpCompletionRoutine, &Event, TRUE, TRUE, TRUE);
110
111 Status = IoCallDriver(DeviceObject, Irp);
112
113 if (Status == STATUS_PENDING)
114 {
115 KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
116 Status = Irp->IoStatus.Status;
117 }
118
119 IoFreeIrp(Irp);
120 return Status;
121}
USBSTOR_SyncForwardIrpCompletionRoutine
NTSTATUS NTAPI USBSTOR_SyncForwardIrpCompletionRoutine(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID Context)
Definition: misc.c:22
IoSetCompletionRoutine
#define IoSetCompletionRoutine(_Irp, _CompletionRoutine, _Context, _InvokeOnSuccess, _InvokeOnError, _InvokeOnCancel)
Definition: irp.cpp:490
IoAllocateIrp
PIRP NTAPI IoAllocateIrp(IN CCHAR StackSize, IN BOOLEAN ChargeQuota)
Definition: irp.c:615
IoFreeIrp
VOID NTAPI IoFreeIrp(IN PIRP Irp)
Definition: irp.c:1666
_IO_STACK_LOCATION::MajorFunction
UCHAR MajorFunction
Definition: iotypes.h:3113
IOCTL_INTERNAL_USB_SUBMIT_URB
#define IOCTL_INTERNAL_USB_SUBMIT_URB
Definition: usbioctl.h:32
IRP_MJ_INTERNAL_DEVICE_CONTROL
#define IRP_MJ_INTERNAL_DEVICE_CONTROL

◆ USBSTOR_TimerRoutine()

VOID NTAPI USBSTOR_TimerRoutine ( PDEVICE_OBJECT  DeviceObject,
PVOID  Context 
)

Definition at line 205 of file error.c.

208{
209 PFDO_DEVICE_EXTENSION FDODeviceExtension;
210 BOOLEAN ResetDevice = FALSE;
211 PERRORHANDLER_WORKITEM_DATA WorkItemData;
212
213 FDODeviceExtension = (PFDO_DEVICE_EXTENSION)Context;
214 DPRINT1("[USBSTOR] TimerRoutine entered\n");
215 // DPRINT1("[USBSTOR] ActiveSrb %p ResetInProgress %x LastTimerActiveSrb %p\n", FDODeviceExtension->ActiveSrb, FDODeviceExtension->ResetInProgress, FDODeviceExtension->LastTimerActiveSrb);
216
217 KeAcquireSpinLockAtDpcLevel(&FDODeviceExtension->IrpListLock);
218
219 // is there an active srb and no global reset is in progress
220 if (FDODeviceExtension->ActiveSrb && /* FDODeviceExtension->ResetInProgress == FALSE && */ FDODeviceExtension->TimerWorkQueueEnabled)
221 {
222 if (FDODeviceExtension->LastTimerActiveSrb != NULL && FDODeviceExtension->LastTimerActiveSrb == FDODeviceExtension->ActiveSrb)
223 {
224 // check if empty
225 DPRINT1("[USBSTOR] ActiveSrb %p hang detected\n", FDODeviceExtension->ActiveSrb);
226 ResetDevice = TRUE;
227 }
228 else
229 {
230 // update pointer
231 FDODeviceExtension->LastTimerActiveSrb = FDODeviceExtension->ActiveSrb;
232 }
233 }
234 else
235 {
236 // reset srb
237 FDODeviceExtension->LastTimerActiveSrb = NULL;
238 }
239
240 KeReleaseSpinLockFromDpcLevel(&FDODeviceExtension->IrpListLock);
241
242
243 if (ResetDevice && FDODeviceExtension->TimerWorkQueueEnabled && FDODeviceExtension->SrbErrorHandlingActive == FALSE)
244 {
245 WorkItemData = ExAllocatePoolWithTag(NonPagedPool,
246 sizeof(ERRORHANDLER_WORKITEM_DATA),
247 USB_STOR_TAG);
248 if (WorkItemData)
249 {
250 // Initialize and queue the work item to handle the error
251 ExInitializeWorkItem(&WorkItemData->WorkQueueItem,
252 USBSTOR_TimerWorkerRoutine,
253 WorkItemData);
254
255 WorkItemData->DeviceObject = FDODeviceExtension->FunctionalDeviceObject;
256
257 DPRINT1("[USBSTOR] Queing Timer WorkItem\n");
258 ExQueueWorkItem(&WorkItemData->WorkQueueItem, DelayedWorkQueue);
259 }
260 }
261}
USBSTOR_TimerWorkerRoutine
VOID NTAPI USBSTOR_TimerWorkerRoutine(IN PVOID Context)
Definition: error.c:167
ResetDevice
DWORD ResetDevice(DWORD private_handle)
KeAcquireSpinLockAtDpcLevel
#define KeAcquireSpinLockAtDpcLevel(SpinLock)
Definition: ke.h:125
KeReleaseSpinLockFromDpcLevel
#define KeReleaseSpinLockFromDpcLevel(SpinLock)
Definition: ke.h:135
_ERRORHANDLER_WORKITEM_DATA
Definition: usbstor.h:166
_ERRORHANDLER_WORKITEM_DATA::DeviceObject
PDEVICE_OBJECT DeviceObject
Definition: usbstor.h:167
_ERRORHANDLER_WORKITEM_DATA::WorkQueueItem
WORK_QUEUE_ITEM WorkQueueItem
Definition: usbstor.h:169
ExQueueWorkItem
VOID NTAPI ExQueueWorkItem(IN PWORK_QUEUE_ITEM WorkItem, IN WORK_QUEUE_TYPE QueueType)
Definition: work.c:723
ExInitializeWorkItem
#define ExInitializeWorkItem(Item, Routine, Context)
Definition: exfuncs.h:265
DelayedWorkQueue
@ DelayedWorkQueue
Definition: extypes.h:190