usbport.h File Reference

#include <ntifs.h>
#include <windef.h>
#include <stdio.h>
#include <wdmguid.h>
#include <ntstrsafe.h>
#include <usb.h>
#include <hubbusif.h>
#include <usbbusif.h>
#include <usbdlib.h>
#include <usbuser.h>
#include <drivers/usbport/usbmport.h>

Include dependency graph for usbport.h:

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

Go to the source code of this file.

Classes
struct	_USBPORT_COMMON_BUFFER_HEADER
struct	_USBPORT_PIPE_HANDLE
struct	_USBPORT_CONFIGURATION_HANDLE
struct	_USBPORT_INTERFACE_HANDLE
struct	_USBPORT_DEVICE_HANDLE
struct	_USBPORT_ENDPOINT
struct	_USBPORT_TRANSFER
struct	_USBPORT_IRP_TABLE
struct	_USBPORT_COMMON_DEVICE_EXTENSION
struct	_USBPORT_DEVICE_EXTENSION
struct	_USBPORT_RH_DESCRIPTORS
struct	_USBPORT_RHDEVICE_EXTENSION
struct	_USBPORT_ASYNC_CALLBACK_DATA
struct	_TIMER_WORK_QUEUE_ITEM
union	_USB2_TT_ENDPOINT_PARAMS
union	_USB2_TT_ENDPOINT_NUMS
struct	_USB2_TT_ENDPOINT
struct	_USB2_FRAME_BUDGET
struct	_USB2_TT
struct	_USB2_TT_EXTENSION
struct	_USB2_HC_EXTENSION
struct	_USB2_REBALANCE

Macros
#define	PCI_INTERFACE_USB_ID_UHCI   0x00
#define	PCI_INTERFACE_USB_ID_OHCI   0x10
#define	PCI_INTERFACE_USB_ID_EHCI   0x20
#define	PCI_INTERFACE_USB_ID_XHCI   0x30
#define	USBPORT_RECIPIENT_HUB   BMREQUEST_TO_DEVICE
#define	USBPORT_RECIPIENT_PORT   BMREQUEST_TO_OTHER
#define	INVALIDATE_ENDPOINT_ONLY   0
#define	INVALIDATE_ENDPOINT_WORKER_THREAD   1
#define	INVALIDATE_ENDPOINT_WORKER_DPC   2
#define	INVALIDATE_ENDPOINT_INT_NEXT_SOF   3
#define	USBPORT_DMA_DIRECTION_FROM_DEVICE   1
#define	USBPORT_DMA_DIRECTION_TO_DEVICE   2
#define	USB_PORT_TAG   'pbsu'
#define	URB_FUNCTION_MAX   0x31
#define	FEATURE_PORT_CONNECTION   0
#define	FEATURE_PORT_ENABLE   1
#define	FEATURE_PORT_SUSPEND   2
#define	FEATURE_PORT_OVER_CURRENT   3
#define	FEATURE_PORT_RESET   4
#define	FEATURE_PORT_POWER   8
#define	FEATURE_PORT_LOW_SPEED   9
#define	FEATURE_C_PORT_CONNECTION   16
#define	FEATURE_C_PORT_ENABLE   17
#define	FEATURE_C_PORT_SUSPEND   18
#define	FEATURE_C_PORT_OVER_CURRENT   19
#define	FEATURE_C_PORT_RESET   20
#define	FEATURE_C_HUB_LOCAL_POWER   0
#define	FEATURE_C_HUB_OVER_CURRENT   1
#define	USBPORT_FLAG_INT_CONNECTED   0x00000001
#define	USBPORT_FLAG_HC_STARTED   0x00000002
#define	USBPORT_FLAG_HC_POLLING   0x00000004
#define	USBPORT_FLAG_WORKER_THREAD_ON   0x00000008
#define	USBPORT_FLAG_WORKER_THREAD_EXIT   0x00000010
#define	USBPORT_FLAG_HC_SUSPEND   0x00000100
#define	USBPORT_FLAG_INTERRUPT_ENABLED   0x00000400
#define	USBPORT_FLAG_SELECTIVE_SUSPEND   0x00000800
#define	USBPORT_FLAG_DOS_SYMBOLIC_NAME   0x00010000
#define	USBPORT_FLAG_LEGACY_SUPPORT   0x00080000
#define	USBPORT_FLAG_HC_WAKE_SUPPORT   0x00200000
#define	USBPORT_FLAG_DIAGNOSTIC_MODE   0x00800000
#define	USBPORT_FLAG_COMPANION_HC   0x01000000
#define	USBPORT_FLAG_REGISTERED_FDO   0x02000000
#define	USBPORT_FLAG_NO_HACTION   0x04000000
#define	USBPORT_FLAG_BIOS_DISABLE_SS   0x08000000
#define	USBPORT_FLAG_PWR_AND_CHIRP_LOCK   0x10000000
#define	USBPORT_FLAG_POWER_AND_CHIRP_OK   0x40000000
#define	USBPORT_FLAG_RH_INIT_CALLBACK   0x80000000
#define	USBPORT_PNP_STATE_NOT_INIT   0x00000001
#define	USBPORT_PNP_STATE_STARTED   0x00000002
#define	USBPORT_PNP_STATE_FAILED   0x00000004
#define	USBPORT_PNP_STATE_STOPPED   0x00000008
#define	USBPORT_TMFLAG_TIMER_QUEUED   0x00000001
#define	USBPORT_TMFLAG_HC_SUSPENDED   0x00000002
#define	USBPORT_TMFLAG_HC_RESUME   0x00000004
#define	USBPORT_TMFLAG_RH_SUSPENDED   0x00000008
#define	USBPORT_TMFLAG_TIMER_STARTED   0x00000010
#define	USBPORT_TMFLAG_WAKE   0x00000020
#define	USBPORT_TMFLAG_IDLE_QUEUEITEM_ON   0x00000040
#define	USBPORT_MPFLAG_INTERRUPTS_ENABLED   0x00000001
#define	USBPORT_MPFLAG_SUSPENDED   0x00000002
#define	DEVICE_HANDLE_FLAG_ROOTHUB   0x00000002
#define	DEVICE_HANDLE_FLAG_REMOVED   0x00000008
#define	DEVICE_HANDLE_FLAG_USB2HUB   0x00000010
#define	ENDPOINT_FLAG_DMA_TYPE   0x00000001
#define	ENDPOINT_FLAG_ROOTHUB_EP0   0x00000002
#define	ENDPOINT_FLAG_NUKE   0x00000008
#define	ENDPOINT_FLAG_QUEUENE_EMPTY   0x00000010
#define	ENDPOINT_FLAG_ABORTING   0x00000020
#define	ENDPOINT_FLAG_IDLE   0x00000100
#define	ENDPOINT_FLAG_OPENED   0x00000200
#define	ENDPOINT_FLAG_CLOSED   0x00000400
#define	USBD_FLAG_ALLOCATED_MDL   0x00000002
#define	USBD_FLAG_NOT_ISO_TRANSFER   0x00000010
#define	USBD_FLAG_ALLOCATED_TRANSFER   0x00000020
#define	PIPE_HANDLE_FLAG_CLOSED   0x00000001
#define	PIPE_HANDLE_FLAG_NULL_PACKET_SIZE   0x00000002
#define	TRANSFER_FLAG_CANCELED   0x00000001
#define	TRANSFER_FLAG_DMA_MAPPED   0x00000002
#define	TRANSFER_FLAG_HIGH_SPEED   0x00000004
#define	TRANSFER_FLAG_SUBMITED   0x00000008
#define	TRANSFER_FLAG_ABORTED   0x00000010
#define	TRANSFER_FLAG_ISO   0x00000020
#define	TRANSFER_FLAG_DEVICE_GONE   0x00000080
#define	TRANSFER_FLAG_SPLITED   0x00000100
#define	TRANSFER_FLAG_COMPLETED   0x00000200
#define	TRANSFER_FLAG_PARENT   0x00000400
#define	USB2_FRAMES   32
#define	USB2_MICROFRAMES   8
#define	USB2_MAX_MICROFRAMES   (USB2_FRAMES * USB2_MICROFRAMES)
#define	USB2_PREV_MICROFRAME   0xFF
#define	USB2_MAX_MICROFRAME_ALLOCATION   7000
#define	USB2_CONTROLLER_DELAY   100
#define	USB2_FS_MAX_PERIODIC_ALLOCATION   1157
#define	USB2_FS_SOF_TIME   6
#define	USB2_HUB_DELAY   30
#define	USB2_MAX_FS_LS_TRANSACTIONS_IN_UFRAME   16
#define	USB2_FS_RAW_BYTES_IN_MICROFRAME   188
#define	USB2_LS_INTERRUPT_OVERHEAD   117
#define	USB2_FS_INTERRUPT_OVERHEAD   13
#define	USB2_HS_INTERRUPT_OUT_OVERHEAD   45
#define	USB2_HS_INTERRUPT_IN_OVERHEAD   25
#define	USB2_FS_ISOCHRONOUS_OVERHEAD   9
#define	USB2_HS_ISOCHRONOUS_OUT_OVERHEAD   38
#define	USB2_HS_ISOCHRONOUS_IN_OVERHEAD   18
#define	USB2_HS_SS_INTERRUPT_OUT_OVERHEAD   58
#define	USB2_HS_CS_INTERRUPT_OUT_OVERHEAD   36
#define	USB2_HS_SS_INTERRUPT_IN_OVERHEAD   39
#define	USB2_HS_CS_INTERRUPT_IN_OVERHEAD   38
#define	USB2_HS_SS_ISOCHRONOUS_OUT_OVERHEAD   58
#define	USB2_HS_SS_ISOCHRONOUS_IN_OVERHEAD   39
#define	USB2_HS_CS_ISOCHRONOUS_IN_OVERHEAD   38
#define	USB2_BIT_STUFFING_OVERHEAD   (8 * (7/6))
#define	USB2_TT_EXTENSION_FLAG_DELETED   1

Typedefs
typedef USBD_STATUS *	PUSBD_STATUS
typedef struct _USBPORT_COMMON_BUFFER_HEADER	USBPORT_COMMON_BUFFER_HEADER
typedef struct _USBPORT_COMMON_BUFFER_HEADER *	PUSBPORT_COMMON_BUFFER_HEADER
typedef struct _USBPORT_ENDPOINT *	PUSBPORT_ENDPOINT
typedef struct _USB2_HC_EXTENSION *	PUSB2_HC_EXTENSION
typedef struct _USB2_TT_EXTENSION *	PUSB2_TT_EXTENSION
typedef struct _USB2_TT *	PUSB2_TT
typedef struct _USB2_TT_ENDPOINT *	PUSB2_TT_ENDPOINT
typedef struct _USBPORT_PIPE_HANDLE	USBPORT_PIPE_HANDLE
typedef struct _USBPORT_PIPE_HANDLE *	PUSBPORT_PIPE_HANDLE
typedef struct _USBPORT_CONFIGURATION_HANDLE	USBPORT_CONFIGURATION_HANDLE
typedef struct _USBPORT_CONFIGURATION_HANDLE *	PUSBPORT_CONFIGURATION_HANDLE
typedef struct _USBPORT_INTERFACE_HANDLE	USBPORT_INTERFACE_HANDLE
typedef struct _USBPORT_INTERFACE_HANDLE *	PUSBPORT_INTERFACE_HANDLE
typedef struct _USBPORT_DEVICE_HANDLE	USBPORT_DEVICE_HANDLE
typedef struct _USBPORT_DEVICE_HANDLE *	PUSBPORT_DEVICE_HANDLE
typedef struct _USBPORT_ENDPOINT	USBPORT_ENDPOINT
typedef struct _USBPORT_ISO_BLOCK *	PUSBPORT_ISO_BLOCK
typedef struct _USBPORT_TRANSFER	USBPORT_TRANSFER
typedef struct _USBPORT_TRANSFER *	PUSBPORT_TRANSFER
typedef struct _USBPORT_IRP_TABLE	USBPORT_IRP_TABLE
typedef struct _USBPORT_IRP_TABLE *	PUSBPORT_IRP_TABLE
typedef struct _USBPORT_COMMON_DEVICE_EXTENSION	USBPORT_COMMON_DEVICE_EXTENSION
typedef struct _USBPORT_COMMON_DEVICE_EXTENSION *	PUSBPORT_COMMON_DEVICE_EXTENSION
typedef struct _USBPORT_DEVICE_EXTENSION	USBPORT_DEVICE_EXTENSION
typedef struct _USBPORT_DEVICE_EXTENSION *	PUSBPORT_DEVICE_EXTENSION
typedef struct _USBPORT_RH_DESCRIPTORS	USBPORT_RH_DESCRIPTORS
typedef struct _USBPORT_RH_DESCRIPTORS *	PUSBPORT_RH_DESCRIPTORS
typedef struct _USBPORT_RHDEVICE_EXTENSION	USBPORT_RHDEVICE_EXTENSION
typedef struct _USBPORT_RHDEVICE_EXTENSION *	PUSBPORT_RHDEVICE_EXTENSION
typedef struct _USBPORT_ASYNC_CALLBACK_DATA	USBPORT_ASYNC_CALLBACK_DATA
typedef struct _USBPORT_ASYNC_CALLBACK_DATA *	PUSBPORT_ASYNC_CALLBACK_DATA
typedef struct _TIMER_WORK_QUEUE_ITEM	TIMER_WORK_QUEUE_ITEM
typedef struct _TIMER_WORK_QUEUE_ITEM *	PTIMER_WORK_QUEUE_ITEM
typedef union _USB2_TT_ENDPOINT_PARAMS	USB2_TT_ENDPOINT_PARAMS
typedef union _USB2_TT_ENDPOINT_NUMS	USB2_TT_ENDPOINT_NUMS
typedef struct _USB2_TT_ENDPOINT	USB2_TT_ENDPOINT
typedef struct _USB2_FRAME_BUDGET	USB2_FRAME_BUDGET
typedef struct _USB2_FRAME_BUDGET *	PUSB2_FRAME_BUDGET
typedef struct _USB2_TT	USB2_TT
typedef struct _USB2_TT_EXTENSION	USB2_TT_EXTENSION
typedef struct _USB2_HC_EXTENSION	USB2_HC_EXTENSION
typedef struct _USB2_REBALANCE	USB2_REBALANCE
typedef struct _USB2_REBALANCE *	PUSB2_REBALANCE

Functions
	C_ASSERT (sizeof(USBPORT_DEVICE_EXTENSION)==0x500)
	C_ASSERT (sizeof(USBPORT_ASYNC_CALLBACK_DATA)==16+18 *sizeof(PVOID))
	C_ASSERT (sizeof(USB2_TT_ENDPOINT_PARAMS)==sizeof(ULONG))
	C_ASSERT (sizeof(USB2_TT_ENDPOINT_NUMS)==sizeof(ULONG))
NTSTATUS NTAPI	USBPORT_USBDStatusToNtStatus (IN PURB Urb, IN USBD_STATUS USBDStatus)
NTSTATUS NTAPI	USBPORT_Wait (IN PVOID MiniPortExtension, IN ULONG Milliseconds)
VOID NTAPI	USBPORT_TransferFlushDpc (IN PRKDPC Dpc, IN PVOID DeferredContext, IN PVOID SystemArgument1, IN PVOID SystemArgument2)
NTSTATUS NTAPI	USBPORT_CreateWorkerThread (IN PDEVICE_OBJECT FdoDevice)
VOID NTAPI	USBPORT_StopWorkerThread (IN PDEVICE_OBJECT FdoDevice)
BOOLEAN NTAPI	USBPORT_StartTimer (IN PDEVICE_OBJECT FdoDevice, IN ULONG Time)
PUSBPORT_COMMON_BUFFER_HEADER NTAPI	USBPORT_AllocateCommonBuffer (IN PDEVICE_OBJECT FdoDevice, IN SIZE_T BufferLength)
VOID NTAPI	USBPORT_FreeCommonBuffer (IN PDEVICE_OBJECT FdoDevice, IN PUSBPORT_COMMON_BUFFER_HEADER HeaderBuffer)
USBD_STATUS NTAPI	USBPORT_AllocateTransfer (IN PDEVICE_OBJECT FdoDevice, IN PURB Urb, IN PUSBPORT_DEVICE_HANDLE DeviceHandle, IN PIRP Irp, IN PRKEVENT Event)
VOID NTAPI	USBPORT_FlushMapTransfers (IN PDEVICE_OBJECT FdoDevice)
VOID NTAPI	USBPORT_IsrDpc (IN PRKDPC Dpc, IN PVOID DeferredContext, IN PVOID SystemArgument1, IN PVOID SystemArgument2)
BOOLEAN NTAPI	USBPORT_InterruptService (IN PKINTERRUPT Interrupt, IN PVOID ServiceContext)
VOID NTAPI	USBPORT_SignalWorkerThread (IN PDEVICE_OBJECT FdoDevice)
VOID NTAPI	USBPORT_CompleteTransfer (IN PURB Urb, IN USBD_STATUS TransferStatus)
VOID NTAPI	USBPORT_DpcHandler (IN PDEVICE_OBJECT FdoDevice)
VOID NTAPI	USBPORT_WorkerRequestDpc (IN PRKDPC Dpc, IN PVOID DeferredContext, IN PVOID SystemArgument1, IN PVOID SystemArgument2)
BOOLEAN NTAPI	USBPORT_QueueDoneTransfer (IN PUSBPORT_TRANSFER Transfer, IN USBD_STATUS USBDStatus)
VOID NTAPI	USBPORT_MiniportInterrupts (IN PDEVICE_OBJECT FdoDevice, IN BOOLEAN IsEnable)
NTSTATUS NTAPI	USBPORT_SetRegistryKeyValue (IN PDEVICE_OBJECT DeviceObject, IN BOOL UseDriverKey, IN ULONG Type, IN PCWSTR ValueNameString, IN PVOID Data, IN ULONG DataSize)
NTSTATUS NTAPI	USBPORT_GetRegistryKeyValueFullInfo (IN PDEVICE_OBJECT FdoDevice, IN PDEVICE_OBJECT PdoDevice, IN BOOL UseDriverKey, IN PCWSTR SourceString, IN ULONG LengthStr, IN PVOID Buffer, IN ULONG NumberOfBytes)
VOID NTAPI	USBPORT_AddUSB1Fdo (IN PDEVICE_OBJECT FdoDevice)
VOID NTAPI	USBPORT_AddUSB2Fdo (IN PDEVICE_OBJECT FdoDevice)
VOID NTAPI	USBPORT_RemoveUSBxFdo (IN PDEVICE_OBJECT FdoDevice)
PDEVICE_OBJECT NTAPI	USBPORT_FindUSB2Controller (IN PDEVICE_OBJECT FdoDevice)
PDEVICE_RELATIONS NTAPI	USBPORT_FindCompanionControllers (IN PDEVICE_OBJECT USB2FdoDevice, IN BOOLEAN IsObRefer, IN BOOLEAN IsFDOsReturned)
VOID NTAPI	USBPORT_InvalidateControllerHandler (IN PDEVICE_OBJECT FdoDevice, IN ULONG Type)
VOID NTAPI	USBPORT_DoneTransfer (IN PUSBPORT_TRANSFER Transfer)
ULONG	USBPORT_DbgPrint (IN PVOID MiniPortExtension, IN ULONG Level, IN PCH Format,...)
ULONG NTAPI	USBPORT_TestDebugBreak (IN PVOID MiniPortExtension)
ULONG NTAPI	USBPORT_AssertFailure (PVOID MiniPortExtension, PVOID FailedAssertion, PVOID FileName, ULONG LineNumber, PCHAR Message)
VOID NTAPI	USBPORT_BugCheck (IN PVOID MiniPortExtension)
ULONG NTAPI	USBPORT_LogEntry (IN PVOID MiniPortExtension, IN ULONG DriverTag, IN ULONG EnumTag, IN ULONG P1, IN ULONG P2, IN ULONG P3)
VOID NTAPI	USBPORT_DumpingDeviceDescriptor (IN PUSB_DEVICE_DESCRIPTOR DeviceDescriptor)
VOID NTAPI	USBPORT_DumpingConfiguration (IN PUSB_CONFIGURATION_DESCRIPTOR ConfigDescriptor)
VOID NTAPI	USBPORT_DumpingCapabilities (IN PDEVICE_CAPABILITIES Capabilities)
VOID NTAPI	USBPORT_DumpingSetupPacket (IN PUSB_DEFAULT_PIPE_SETUP_PACKET SetupPacket)
VOID NTAPI	USBPORT_DumpingURB (IN PURB Urb)
VOID NTAPI	USBPORT_DumpingIDs (IN PVOID Buffer)
NTSTATUS NTAPI	USBPORT_HandleSelectConfiguration (IN PDEVICE_OBJECT FdoDevice, IN PIRP Irp, IN PURB Urb)
VOID NTAPI	USBPORT_AddDeviceHandle (IN PDEVICE_OBJECT FdoDevice, IN PUSBPORT_DEVICE_HANDLE DeviceHandle)
VOID NTAPI	USBPORT_RemoveDeviceHandle (IN PDEVICE_OBJECT FdoDevice, IN PUSBPORT_DEVICE_HANDLE DeviceHandle)
BOOLEAN NTAPI	USBPORT_ValidateDeviceHandle (IN PDEVICE_OBJECT FdoDevice, IN PUSBPORT_DEVICE_HANDLE DeviceHandle)
NTSTATUS NTAPI	USBPORT_CreateDevice (IN OUT PUSB_DEVICE_HANDLE *pUsbdDeviceHandle, IN PDEVICE_OBJECT FdoDevice, IN PUSBPORT_DEVICE_HANDLE HubDeviceHandle, IN USHORT PortStatus, IN USHORT Port)
NTSTATUS NTAPI	USBPORT_InitializeDevice (IN PUSBPORT_DEVICE_HANDLE DeviceHandle, IN PDEVICE_OBJECT FdoDevice)
NTSTATUS NTAPI	USBPORT_GetUsbDescriptor (IN PUSBPORT_DEVICE_HANDLE DeviceHandle, IN PDEVICE_OBJECT FdoDevice, IN UCHAR Type, IN PUCHAR ConfigDesc, IN PULONG ConfigDescSize)
NTSTATUS NTAPI	USBPORT_HandleSelectInterface (IN PDEVICE_OBJECT FdoDevice, IN PIRP Irp, IN PURB Urb)
NTSTATUS NTAPI	USBPORT_RemoveDevice (IN PDEVICE_OBJECT FdoDevice, IN OUT PUSBPORT_DEVICE_HANDLE DeviceHandle, IN ULONG Flags)
NTSTATUS NTAPI	USBPORT_SendSetupPacket (IN PUSBPORT_DEVICE_HANDLE DeviceHandle, IN PDEVICE_OBJECT FdoDevice, IN PUSB_DEFAULT_PIPE_SETUP_PACKET SetupPacket, IN PVOID Buffer, IN ULONG Length, IN OUT PULONG TransferedLen, IN OUT PUSBD_STATUS pUSBDStatus)
NTSTATUS NTAPI	USBPORT_RestoreDevice (IN PDEVICE_OBJECT FdoDevice, IN OUT PUSBPORT_DEVICE_HANDLE OldDeviceHandle, IN OUT PUSBPORT_DEVICE_HANDLE NewDeviceHandle)
NTSTATUS NTAPI	USBPORT_Initialize20Hub (IN PDEVICE_OBJECT FdoDevice, IN PUSBPORT_DEVICE_HANDLE HubDeviceHandle, IN ULONG TtCount)
NTSTATUS NTAPI	USBPORT_OpenPipe (IN PDEVICE_OBJECT FdoDevice, IN PUSBPORT_DEVICE_HANDLE DeviceHandle, IN PUSBPORT_PIPE_HANDLE PipeHandle, IN PUSBD_STATUS UsbdStatus)
MPSTATUS NTAPI	MiniportOpenEndpoint (IN PDEVICE_OBJECT FdoDevice, IN PUSBPORT_ENDPOINT Endpoint)
NTSTATUS NTAPI	USBPORT_ReopenPipe (IN PDEVICE_OBJECT FdoDevice, IN PUSBPORT_ENDPOINT Endpoint)
VOID NTAPI	USBPORT_ClosePipe (IN PUSBPORT_DEVICE_HANDLE DeviceHandle, IN PDEVICE_OBJECT FdoDevice, IN PUSBPORT_PIPE_HANDLE PipeHandle)
VOID NTAPI	MiniportCloseEndpoint (IN PDEVICE_OBJECT FdoDevice, IN PUSBPORT_ENDPOINT Endpoint)
VOID NTAPI	USBPORT_AddPipeHandle (IN PUSBPORT_DEVICE_HANDLE DeviceHandle, IN PUSBPORT_PIPE_HANDLE PipeHandle)
VOID NTAPI	USBPORT_RemovePipeHandle (IN PUSBPORT_DEVICE_HANDLE DeviceHandle, IN PUSBPORT_PIPE_HANDLE PipeHandle)
BOOLEAN NTAPI	USBPORT_ValidatePipeHandle (IN PUSBPORT_DEVICE_HANDLE DeviceHandle, IN PUSBPORT_PIPE_HANDLE PipeHandle)
VOID NTAPI	USBPORT_FlushClosedEndpointList (IN PDEVICE_OBJECT FdoDevice)
VOID NTAPI	USBPORT_SetEndpointState (IN PUSBPORT_ENDPOINT Endpoint, IN ULONG State)
ULONG NTAPI	USBPORT_GetEndpointState (IN PUSBPORT_ENDPOINT Endpoint)
VOID NTAPI	USBPORT_InvalidateEndpointHandler (IN PDEVICE_OBJECT FdoDevice, IN PUSBPORT_ENDPOINT Endpoint, IN ULONG Type)
BOOLEAN NTAPI	USBPORT_EndpointWorker (IN PUSBPORT_ENDPOINT Endpoint, IN BOOLEAN Flag)
VOID NTAPI	USBPORT_NukeAllEndpoints (IN PDEVICE_OBJECT FdoDevice)
BOOLEAN NTAPI	USBPORT_EndpointHasQueuedTransfers (IN PDEVICE_OBJECT FdoDevice, IN PUSBPORT_ENDPOINT Endpoint, IN PULONG TransferCount)
NTSTATUS NTAPI	USBPORT_PdoQueryInterface (IN PDEVICE_OBJECT FdoDevice, IN PDEVICE_OBJECT PdoDevice, IN PIRP Irp)
NTSTATUS NTAPI	USBPORT_PdoDeviceControl (PDEVICE_OBJECT PdoDevice, PIRP Irp)
NTSTATUS NTAPI	USBPORT_FdoDeviceControl (PDEVICE_OBJECT FdoDevice, PIRP Irp)
NTSTATUS NTAPI	USBPORT_FdoInternalDeviceControl (IN PDEVICE_OBJECT FdoDevice, IN PIRP Irp)
NTSTATUS NTAPI	USBPORT_PdoInternalDeviceControl (IN PDEVICE_OBJECT FdoDevice, IN PIRP Irp)
NTSTATUS NTAPI	USBPORT_GetSymbolicName (IN PDEVICE_OBJECT RootHubPdo, IN PUNICODE_STRING DestinationString)
USBD_STATUS NTAPI	USBPORT_InitializeIsoTransfer (IN PDEVICE_OBJECT FdoDevice, IN struct _URB_ISOCH_TRANSFER *Urb, IN PUSBPORT_TRANSFER Transfer)
ULONG NTAPI	USBPORT_CompleteIsoTransfer (IN PVOID MiniPortExtension, IN PVOID MiniPortEndpoint, IN PVOID TransferParameters, IN ULONG TransferLength)
NTSTATUS NTAPI	USBPORT_FdoPnP (IN PDEVICE_OBJECT FdoDevice, IN PIRP Irp)
NTSTATUS NTAPI	USBPORT_PdoPnP (IN PDEVICE_OBJECT FdoDevice, IN PIRP Irp)
NTSTATUS NTAPI	USBPORT_PdoPower (IN PDEVICE_OBJECT PdoDevice, IN PIRP Irp)
NTSTATUS NTAPI	USBPORT_FdoPower (IN PDEVICE_OBJECT FdoDevice, IN PIRP Irp)
NTSTATUS NTAPI	USBPORT_IdleNotification (IN PDEVICE_OBJECT PdoDevice, IN PIRP Irp)
VOID NTAPI	USBPORT_AdjustDeviceCapabilities (IN PDEVICE_OBJECT FdoDevice, IN PDEVICE_OBJECT PdoDevice)
VOID NTAPI	USBPORT_DoIdleNotificationCallback (IN PVOID Context)
VOID NTAPI	USBPORT_CompletePdoWaitWake (IN PDEVICE_OBJECT FdoDevice)
VOID NTAPI	USBPORT_DoSetPowerD0 (IN PDEVICE_OBJECT FdoDevice)
VOID NTAPI	USBPORT_HcWakeDpc (IN PRKDPC Dpc, IN PVOID DeferredContext, IN PVOID SystemArgument1, IN PVOID SystemArgument2)
VOID NTAPI	USBPORT_HcQueueWakeDpc (IN PDEVICE_OBJECT FdoDevice)
VOID NTAPI	USBPORT_InsertIdleIrp (IN PIO_CSQ Csq, IN PIRP Irp)
VOID NTAPI	USBPORT_RemoveIdleIrp (IN PIO_CSQ Csq, IN PIRP Irp)
PIRP NTAPI	USBPORT_PeekNextIdleIrp (IN PIO_CSQ Csq, IN PIRP Irp, IN PVOID PeekContext)
VOID NTAPI	USBPORT_AcquireIdleLock (IN PIO_CSQ Csq, IN PKIRQL Irql)
VOID NTAPI	USBPORT_ReleaseIdleLock (IN PIO_CSQ Csq, IN KIRQL Irql)
VOID NTAPI	USBPORT_CompleteCanceledIdleIrp (IN PIO_CSQ Csq, IN PIRP Irp)
VOID NTAPI	USBPORT_InsertBadRequest (IN PIO_CSQ Csq, IN PIRP Irp)
VOID NTAPI	USBPORT_RemoveBadRequest (IN PIO_CSQ Csq, IN PIRP Irp)
PIRP NTAPI	USBPORT_PeekNextBadRequest (IN PIO_CSQ Csq, IN PIRP Irp, IN PVOID PeekContext)
VOID NTAPI	USBPORT_AcquireBadRequestLock (IN PIO_CSQ Csq, IN PKIRQL Irql)
VOID NTAPI	USBPORT_ReleaseBadRequestLock (IN PIO_CSQ Csq, IN KIRQL Irql)
VOID NTAPI	USBPORT_CompleteCanceledBadRequest (IN PIO_CSQ Csq, IN PIRP Irp)
VOID NTAPI	USBPORT_InsertIrpInTable (IN PUSBPORT_IRP_TABLE IrpTable, IN PIRP Irp)
PIRP NTAPI	USBPORT_RemovePendingTransferIrp (IN PDEVICE_OBJECT FdoDevice, IN PIRP Irp)
PIRP NTAPI	USBPORT_RemoveActiveTransferIrp (IN PDEVICE_OBJECT FdoDevice, IN PIRP Irp)
VOID NTAPI	USBPORT_FindUrbInIrpTable (IN PUSBPORT_IRP_TABLE IrpTable, IN PURB Urb, IN PIRP Irp)
VOID NTAPI	USBPORT_CancelActiveTransferIrp (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
VOID NTAPI	USBPORT_FlushAbortList (IN PUSBPORT_ENDPOINT Endpoint)
VOID NTAPI	USBPORT_FlushCancelList (IN PUSBPORT_ENDPOINT Endpoint)
VOID NTAPI	USBPORT_QueueTransferUrb (IN PURB Urb)
VOID NTAPI	USBPORT_FlushAllEndpoints (IN PDEVICE_OBJECT FdoDevice)
VOID NTAPI	USBPORT_FlushPendingTransfers (IN PUSBPORT_ENDPOINT Endpoint)
BOOLEAN NTAPI	USBPORT_QueueActiveUrbToEndpoint (IN PUSBPORT_ENDPOINT Endpoint, IN PURB Urb)
VOID NTAPI	USBPORT_FlushController (IN PDEVICE_OBJECT FdoDevice)
VOID NTAPI	USBPORT_BadRequestFlush (IN PDEVICE_OBJECT FdoDevice)
VOID NTAPI	USBPORT_AbortEndpoint (IN PDEVICE_OBJECT FdoDevice, IN PUSBPORT_ENDPOINT Endpoint, IN PIRP Irp)
VOID NTAPI	USBPORT_RootHubEndpointWorker (PUSBPORT_ENDPOINT Endpoint)
NTSTATUS NTAPI	USBPORT_RootHubCreateDevice (IN PDEVICE_OBJECT FdoDevice, IN PDEVICE_OBJECT PdoDevice)
ULONG NTAPI	USBPORT_InvalidateRootHub (PVOID MiniPortExtension)
VOID NTAPI	USBPORT_RootHubPowerAndChirpAllCcPorts (IN PDEVICE_OBJECT FdoDevice)
VOID NTAPI	USBPORT_SplitTransfer (IN PDEVICE_OBJECT FdoDevice, IN PUSBPORT_ENDPOINT Endpoint, IN PUSBPORT_TRANSFER Transfer, IN PLIST_ENTRY List)
VOID NTAPI	USBPORT_DoneSplitTransfer (IN PUSBPORT_TRANSFER SplitTransfer)
VOID NTAPI	USBPORT_CancelSplitTransfer (IN PUSBPORT_TRANSFER SplitTransfer)
NTSTATUS NTAPI	USBPORT_HandleSubmitURB (IN PDEVICE_OBJECT PdoDevice, IN PIRP Irp, IN PURB Urb)
BOOLEAN NTAPI	USBPORT_AllocateBandwidthUSB2 (IN PDEVICE_OBJECT FdoDevice, IN PUSBPORT_ENDPOINT Endpoint)
VOID NTAPI	USBPORT_FreeBandwidthUSB2 (IN PDEVICE_OBJECT FdoDevice, IN PUSBPORT_ENDPOINT Endpoint)
VOID NTAPI	USBPORT_UpdateAllocatedBwTt (IN PUSB2_TT_EXTENSION TtExtension)
VOID NTAPI	USB2_InitTT (IN PUSB2_HC_EXTENSION HcExtension, IN PUSB2_TT Tt)
VOID NTAPI	USB2_InitController (IN PUSB2_HC_EXTENSION HcExtension)
VOID NTAPI	USBPORT_DumpingEndpointProperties (IN PUSBPORT_ENDPOINT_PROPERTIES EndpointProperties)
VOID NTAPI	USBPORT_DumpingTtEndpoint (IN PUSB2_TT_ENDPOINT TtEndpoint)

Variables
KSPIN_LOCK	USBPORT_SpinLock
LIST_ENTRY	USBPORT_MiniPortDrivers

Macro Definition Documentation

DEVICE_HANDLE_FLAG_REMOVED

#define DEVICE_HANDLE_FLAG_REMOVED   0x00000008

Definition at line 107 of file usbport.h.

DEVICE_HANDLE_FLAG_ROOTHUB

#define DEVICE_HANDLE_FLAG_ROOTHUB   0x00000002

Definition at line 106 of file usbport.h.

DEVICE_HANDLE_FLAG_USB2HUB

#define DEVICE_HANDLE_FLAG_USB2HUB   0x00000010

Definition at line 108 of file usbport.h.

ENDPOINT_FLAG_ABORTING

#define ENDPOINT_FLAG_ABORTING   0x00000020

Definition at line 115 of file usbport.h.

ENDPOINT_FLAG_CLOSED

#define ENDPOINT_FLAG_CLOSED   0x00000400

Definition at line 118 of file usbport.h.

ENDPOINT_FLAG_DMA_TYPE

#define ENDPOINT_FLAG_DMA_TYPE   0x00000001

Definition at line 111 of file usbport.h.

ENDPOINT_FLAG_IDLE

#define ENDPOINT_FLAG_IDLE   0x00000100

Definition at line 116 of file usbport.h.

ENDPOINT_FLAG_NUKE

#define ENDPOINT_FLAG_NUKE   0x00000008

Definition at line 113 of file usbport.h.

ENDPOINT_FLAG_OPENED

#define ENDPOINT_FLAG_OPENED   0x00000200

Definition at line 117 of file usbport.h.

ENDPOINT_FLAG_QUEUENE_EMPTY

#define ENDPOINT_FLAG_QUEUENE_EMPTY   0x00000010

Definition at line 114 of file usbport.h.

ENDPOINT_FLAG_ROOTHUB_EP0

#define ENDPOINT_FLAG_ROOTHUB_EP0   0x00000002

Definition at line 112 of file usbport.h.

FEATURE_C_HUB_LOCAL_POWER

#define FEATURE_C_HUB_LOCAL_POWER   0

Definition at line 62 of file usbport.h.

FEATURE_C_HUB_OVER_CURRENT

#define FEATURE_C_HUB_OVER_CURRENT   1

Definition at line 63 of file usbport.h.

FEATURE_C_PORT_CONNECTION

#define FEATURE_C_PORT_CONNECTION   16

Definition at line 55 of file usbport.h.

FEATURE_C_PORT_ENABLE

#define FEATURE_C_PORT_ENABLE   17

Definition at line 56 of file usbport.h.

FEATURE_C_PORT_OVER_CURRENT

#define FEATURE_C_PORT_OVER_CURRENT   19

Definition at line 58 of file usbport.h.

FEATURE_C_PORT_RESET

#define FEATURE_C_PORT_RESET   20

Definition at line 59 of file usbport.h.

FEATURE_C_PORT_SUSPEND

#define FEATURE_C_PORT_SUSPEND   18

Definition at line 57 of file usbport.h.

FEATURE_PORT_CONNECTION

#define FEATURE_PORT_CONNECTION   0

Definition at line 48 of file usbport.h.

FEATURE_PORT_ENABLE

#define FEATURE_PORT_ENABLE   1

Definition at line 49 of file usbport.h.

FEATURE_PORT_LOW_SPEED

#define FEATURE_PORT_LOW_SPEED   9

Definition at line 54 of file usbport.h.

FEATURE_PORT_OVER_CURRENT

#define FEATURE_PORT_OVER_CURRENT   3

Definition at line 51 of file usbport.h.

FEATURE_PORT_POWER

#define FEATURE_PORT_POWER   8

Definition at line 53 of file usbport.h.

FEATURE_PORT_RESET

#define FEATURE_PORT_RESET   4

Definition at line 52 of file usbport.h.

FEATURE_PORT_SUSPEND

#define FEATURE_PORT_SUSPEND   2

Definition at line 50 of file usbport.h.

INVALIDATE_ENDPOINT_INT_NEXT_SOF

#define INVALIDATE_ENDPOINT_INT_NEXT_SOF   3

Definition at line 39 of file usbport.h.

INVALIDATE_ENDPOINT_ONLY

#define INVALIDATE_ENDPOINT_ONLY   0

Definition at line 36 of file usbport.h.

INVALIDATE_ENDPOINT_WORKER_DPC

#define INVALIDATE_ENDPOINT_WORKER_DPC   2

Definition at line 38 of file usbport.h.

INVALIDATE_ENDPOINT_WORKER_THREAD

#define INVALIDATE_ENDPOINT_WORKER_THREAD   1

Definition at line 37 of file usbport.h.

PCI_INTERFACE_USB_ID_EHCI

#define PCI_INTERFACE_USB_ID_EHCI   0x20

Definition at line 25 of file usbport.h.

PCI_INTERFACE_USB_ID_OHCI

#define PCI_INTERFACE_USB_ID_OHCI   0x10

Definition at line 24 of file usbport.h.

PCI_INTERFACE_USB_ID_UHCI

#define PCI_INTERFACE_USB_ID_UHCI   0x00

Definition at line 23 of file usbport.h.

PCI_INTERFACE_USB_ID_XHCI

#define PCI_INTERFACE_USB_ID_XHCI   0x30

Definition at line 26 of file usbport.h.

PIPE_HANDLE_FLAG_CLOSED

#define PIPE_HANDLE_FLAG_CLOSED   0x00000001

Definition at line 126 of file usbport.h.

PIPE_HANDLE_FLAG_NULL_PACKET_SIZE

#define PIPE_HANDLE_FLAG_NULL_PACKET_SIZE   0x00000002

Definition at line 127 of file usbport.h.

TRANSFER_FLAG_ABORTED

#define TRANSFER_FLAG_ABORTED   0x00000010

Definition at line 134 of file usbport.h.

TRANSFER_FLAG_CANCELED

#define TRANSFER_FLAG_CANCELED   0x00000001

Definition at line 130 of file usbport.h.

TRANSFER_FLAG_COMPLETED

#define TRANSFER_FLAG_COMPLETED   0x00000200

Definition at line 138 of file usbport.h.

TRANSFER_FLAG_DEVICE_GONE

#define TRANSFER_FLAG_DEVICE_GONE   0x00000080

Definition at line 136 of file usbport.h.

TRANSFER_FLAG_DMA_MAPPED

#define TRANSFER_FLAG_DMA_MAPPED   0x00000002

Definition at line 131 of file usbport.h.

TRANSFER_FLAG_HIGH_SPEED

#define TRANSFER_FLAG_HIGH_SPEED   0x00000004

Definition at line 132 of file usbport.h.

TRANSFER_FLAG_ISO

#define TRANSFER_FLAG_ISO   0x00000020

Definition at line 135 of file usbport.h.

TRANSFER_FLAG_PARENT

#define TRANSFER_FLAG_PARENT   0x00000400

Definition at line 139 of file usbport.h.

TRANSFER_FLAG_SPLITED

#define TRANSFER_FLAG_SPLITED   0x00000100

Definition at line 137 of file usbport.h.

TRANSFER_FLAG_SUBMITED

#define TRANSFER_FLAG_SUBMITED   0x00000008

Definition at line 133 of file usbport.h.

URB_FUNCTION_MAX

#define URB_FUNCTION_MAX   0x31

Definition at line 45 of file usbport.h.

USB2_BIT_STUFFING_OVERHEAD

#define USB2_BIT_STUFFING_OVERHEAD   (8 * (7/6))

Definition at line 483 of file usbport.h.

USB2_CONTROLLER_DELAY

#define USB2_CONTROLLER_DELAY   100

Definition at line 458 of file usbport.h.

USB2_FRAMES

#define USB2_FRAMES   32

Definition at line 452 of file usbport.h.

USB2_FS_INTERRUPT_OVERHEAD

#define USB2_FS_INTERRUPT_OVERHEAD   13

Definition at line 467 of file usbport.h.

USB2_FS_ISOCHRONOUS_OVERHEAD

#define USB2_FS_ISOCHRONOUS_OVERHEAD   9

Definition at line 470 of file usbport.h.

USB2_FS_MAX_PERIODIC_ALLOCATION

#define USB2_FS_MAX_PERIODIC_ALLOCATION   1157

Definition at line 459 of file usbport.h.

USB2_FS_RAW_BYTES_IN_MICROFRAME

#define USB2_FS_RAW_BYTES_IN_MICROFRAME   188

Definition at line 463 of file usbport.h.

USB2_FS_SOF_TIME

#define USB2_FS_SOF_TIME   6

Definition at line 460 of file usbport.h.

USB2_HS_CS_INTERRUPT_IN_OVERHEAD

#define USB2_HS_CS_INTERRUPT_IN_OVERHEAD   38

Definition at line 477 of file usbport.h.

USB2_HS_CS_INTERRUPT_OUT_OVERHEAD

#define USB2_HS_CS_INTERRUPT_OUT_OVERHEAD   36

Definition at line 475 of file usbport.h.

USB2_HS_CS_ISOCHRONOUS_IN_OVERHEAD

#define USB2_HS_CS_ISOCHRONOUS_IN_OVERHEAD   38

Definition at line 481 of file usbport.h.

USB2_HS_INTERRUPT_IN_OVERHEAD

#define USB2_HS_INTERRUPT_IN_OVERHEAD   25

Definition at line 469 of file usbport.h.

USB2_HS_INTERRUPT_OUT_OVERHEAD

#define USB2_HS_INTERRUPT_OUT_OVERHEAD   45

Definition at line 468 of file usbport.h.

USB2_HS_ISOCHRONOUS_IN_OVERHEAD

#define USB2_HS_ISOCHRONOUS_IN_OVERHEAD   18

Definition at line 472 of file usbport.h.

USB2_HS_ISOCHRONOUS_OUT_OVERHEAD

#define USB2_HS_ISOCHRONOUS_OUT_OVERHEAD   38

Definition at line 471 of file usbport.h.

USB2_HS_SS_INTERRUPT_IN_OVERHEAD

#define USB2_HS_SS_INTERRUPT_IN_OVERHEAD   39

Definition at line 476 of file usbport.h.

USB2_HS_SS_INTERRUPT_OUT_OVERHEAD

#define USB2_HS_SS_INTERRUPT_OUT_OVERHEAD   58

Definition at line 474 of file usbport.h.

USB2_HS_SS_ISOCHRONOUS_IN_OVERHEAD

#define USB2_HS_SS_ISOCHRONOUS_IN_OVERHEAD   39

Definition at line 480 of file usbport.h.

USB2_HS_SS_ISOCHRONOUS_OUT_OVERHEAD

#define USB2_HS_SS_ISOCHRONOUS_OUT_OVERHEAD   58

Definition at line 479 of file usbport.h.

USB2_HUB_DELAY

#define USB2_HUB_DELAY   30

Definition at line 461 of file usbport.h.

USB2_LS_INTERRUPT_OVERHEAD

#define USB2_LS_INTERRUPT_OVERHEAD   117

Definition at line 466 of file usbport.h.

USB2_MAX_FS_LS_TRANSACTIONS_IN_UFRAME

#define USB2_MAX_FS_LS_TRANSACTIONS_IN_UFRAME   16

Definition at line 462 of file usbport.h.

USB2_MAX_MICROFRAME_ALLOCATION

#define USB2_MAX_MICROFRAME_ALLOCATION   7000

Definition at line 457 of file usbport.h.

USB2_MAX_MICROFRAMES

#define USB2_MAX_MICROFRAMES   (USB2_FRAMES * USB2_MICROFRAMES)

Definition at line 454 of file usbport.h.

USB2_MICROFRAMES

#define USB2_MICROFRAMES   8

Definition at line 453 of file usbport.h.

USB2_PREV_MICROFRAME

#define USB2_PREV_MICROFRAME   0xFF

Definition at line 455 of file usbport.h.

USB2_TT_EXTENSION_FLAG_DELETED

#define USB2_TT_EXTENSION_FLAG_DELETED   1

Definition at line 546 of file usbport.h.

USB_PORT_TAG

#define USB_PORT_TAG   'pbsu'

Definition at line 44 of file usbport.h.

USBD_FLAG_ALLOCATED_MDL

#define USBD_FLAG_ALLOCATED_MDL   0x00000002

Definition at line 121 of file usbport.h.

USBD_FLAG_ALLOCATED_TRANSFER

#define USBD_FLAG_ALLOCATED_TRANSFER   0x00000020

Definition at line 123 of file usbport.h.

USBD_FLAG_NOT_ISO_TRANSFER

#define USBD_FLAG_NOT_ISO_TRANSFER   0x00000010

Definition at line 122 of file usbport.h.

USBPORT_DMA_DIRECTION_FROM_DEVICE

#define USBPORT_DMA_DIRECTION_FROM_DEVICE   1

Definition at line 41 of file usbport.h.

USBPORT_DMA_DIRECTION_TO_DEVICE

#define USBPORT_DMA_DIRECTION_TO_DEVICE   2

Definition at line 42 of file usbport.h.

USBPORT_FLAG_BIOS_DISABLE_SS

#define USBPORT_FLAG_BIOS_DISABLE_SS   0x08000000

Definition at line 81 of file usbport.h.

USBPORT_FLAG_COMPANION_HC

#define USBPORT_FLAG_COMPANION_HC   0x01000000

Definition at line 78 of file usbport.h.

USBPORT_FLAG_DIAGNOSTIC_MODE

#define USBPORT_FLAG_DIAGNOSTIC_MODE   0x00800000

Definition at line 77 of file usbport.h.

USBPORT_FLAG_DOS_SYMBOLIC_NAME

#define USBPORT_FLAG_DOS_SYMBOLIC_NAME   0x00010000

Definition at line 74 of file usbport.h.

USBPORT_FLAG_HC_POLLING

#define USBPORT_FLAG_HC_POLLING   0x00000004

Definition at line 68 of file usbport.h.

USBPORT_FLAG_HC_STARTED

#define USBPORT_FLAG_HC_STARTED   0x00000002

Definition at line 67 of file usbport.h.

USBPORT_FLAG_HC_SUSPEND

#define USBPORT_FLAG_HC_SUSPEND   0x00000100

Definition at line 71 of file usbport.h.

USBPORT_FLAG_HC_WAKE_SUPPORT

#define USBPORT_FLAG_HC_WAKE_SUPPORT   0x00200000

Definition at line 76 of file usbport.h.

USBPORT_FLAG_INT_CONNECTED

#define USBPORT_FLAG_INT_CONNECTED   0x00000001

Definition at line 66 of file usbport.h.

USBPORT_FLAG_INTERRUPT_ENABLED

#define USBPORT_FLAG_INTERRUPT_ENABLED   0x00000400

Definition at line 72 of file usbport.h.

USBPORT_FLAG_LEGACY_SUPPORT

#define USBPORT_FLAG_LEGACY_SUPPORT   0x00080000

Definition at line 75 of file usbport.h.

USBPORT_FLAG_NO_HACTION

#define USBPORT_FLAG_NO_HACTION   0x04000000

Definition at line 80 of file usbport.h.

USBPORT_FLAG_POWER_AND_CHIRP_OK

#define USBPORT_FLAG_POWER_AND_CHIRP_OK   0x40000000

Definition at line 83 of file usbport.h.

USBPORT_FLAG_PWR_AND_CHIRP_LOCK

#define USBPORT_FLAG_PWR_AND_CHIRP_LOCK   0x10000000

Definition at line 82 of file usbport.h.

USBPORT_FLAG_REGISTERED_FDO

#define USBPORT_FLAG_REGISTERED_FDO   0x02000000

Definition at line 79 of file usbport.h.

USBPORT_FLAG_RH_INIT_CALLBACK

#define USBPORT_FLAG_RH_INIT_CALLBACK   0x80000000

Definition at line 84 of file usbport.h.

USBPORT_FLAG_SELECTIVE_SUSPEND

#define USBPORT_FLAG_SELECTIVE_SUSPEND   0x00000800

Definition at line 73 of file usbport.h.

USBPORT_FLAG_WORKER_THREAD_EXIT

#define USBPORT_FLAG_WORKER_THREAD_EXIT   0x00000010

Definition at line 70 of file usbport.h.

USBPORT_FLAG_WORKER_THREAD_ON

#define USBPORT_FLAG_WORKER_THREAD_ON   0x00000008

Definition at line 69 of file usbport.h.

USBPORT_MPFLAG_INTERRUPTS_ENABLED

#define USBPORT_MPFLAG_INTERRUPTS_ENABLED   0x00000001

Definition at line 102 of file usbport.h.

USBPORT_MPFLAG_SUSPENDED

#define USBPORT_MPFLAG_SUSPENDED   0x00000002

Definition at line 103 of file usbport.h.

USBPORT_PNP_STATE_FAILED

#define USBPORT_PNP_STATE_FAILED   0x00000004

Definition at line 89 of file usbport.h.

USBPORT_PNP_STATE_NOT_INIT

#define USBPORT_PNP_STATE_NOT_INIT   0x00000001

Definition at line 87 of file usbport.h.

USBPORT_PNP_STATE_STARTED

#define USBPORT_PNP_STATE_STARTED   0x00000002

Definition at line 88 of file usbport.h.

USBPORT_PNP_STATE_STOPPED

#define USBPORT_PNP_STATE_STOPPED   0x00000008

Definition at line 90 of file usbport.h.

USBPORT_RECIPIENT_HUB

#define USBPORT_RECIPIENT_HUB   BMREQUEST_TO_DEVICE

Definition at line 33 of file usbport.h.

USBPORT_RECIPIENT_PORT

#define USBPORT_RECIPIENT_PORT   BMREQUEST_TO_OTHER

Definition at line 34 of file usbport.h.

USBPORT_TMFLAG_HC_RESUME

#define USBPORT_TMFLAG_HC_RESUME   0x00000004

Definition at line 95 of file usbport.h.

USBPORT_TMFLAG_HC_SUSPENDED

#define USBPORT_TMFLAG_HC_SUSPENDED   0x00000002

Definition at line 94 of file usbport.h.

USBPORT_TMFLAG_IDLE_QUEUEITEM_ON

#define USBPORT_TMFLAG_IDLE_QUEUEITEM_ON   0x00000040

Definition at line 99 of file usbport.h.

USBPORT_TMFLAG_RH_SUSPENDED

#define USBPORT_TMFLAG_RH_SUSPENDED   0x00000008

Definition at line 96 of file usbport.h.

USBPORT_TMFLAG_TIMER_QUEUED

#define USBPORT_TMFLAG_TIMER_QUEUED   0x00000001

Definition at line 93 of file usbport.h.

USBPORT_TMFLAG_TIMER_STARTED

#define USBPORT_TMFLAG_TIMER_STARTED   0x00000010

Definition at line 97 of file usbport.h.

USBPORT_TMFLAG_WAKE

#define USBPORT_TMFLAG_WAKE   0x00000020

Definition at line 98 of file usbport.h.

Typedef Documentation

PTIMER_WORK_QUEUE_ITEM

typedef struct _TIMER_WORK_QUEUE_ITEM * PTIMER_WORK_QUEUE_ITEM

PUSB2_FRAME_BUDGET

typedef struct _USB2_FRAME_BUDGET * PUSB2_FRAME_BUDGET

PUSB2_HC_EXTENSION

typedef struct _USB2_HC_EXTENSION * PUSB2_HC_EXTENSION

Definition at line 157 of file usbport.h.

PUSB2_REBALANCE

typedef struct _USB2_REBALANCE * PUSB2_REBALANCE

PUSB2_TT

typedef struct _USB2_TT * PUSB2_TT

Definition at line 159 of file usbport.h.

PUSB2_TT_ENDPOINT

typedef struct _USB2_TT_ENDPOINT * PUSB2_TT_ENDPOINT

Definition at line 160 of file usbport.h.

PUSB2_TT_EXTENSION

typedef struct _USB2_TT_EXTENSION * PUSB2_TT_EXTENSION

Definition at line 158 of file usbport.h.

PUSBD_STATUS

typedef USBD_STATUS* PUSBD_STATUS

Definition at line 144 of file usbport.h.

PUSBPORT_ASYNC_CALLBACK_DATA

typedef struct _USBPORT_ASYNC_CALLBACK_DATA * PUSBPORT_ASYNC_CALLBACK_DATA

PUSBPORT_COMMON_BUFFER_HEADER

typedef struct _USBPORT_COMMON_BUFFER_HEADER * PUSBPORT_COMMON_BUFFER_HEADER

PUSBPORT_COMMON_DEVICE_EXTENSION

typedef struct _USBPORT_COMMON_DEVICE_EXTENSION * PUSBPORT_COMMON_DEVICE_EXTENSION

PUSBPORT_CONFIGURATION_HANDLE

typedef struct _USBPORT_CONFIGURATION_HANDLE * PUSBPORT_CONFIGURATION_HANDLE

PUSBPORT_DEVICE_EXTENSION

typedef struct _USBPORT_DEVICE_EXTENSION * PUSBPORT_DEVICE_EXTENSION

PUSBPORT_DEVICE_HANDLE

typedef struct _USBPORT_DEVICE_HANDLE * PUSBPORT_DEVICE_HANDLE

PUSBPORT_ENDPOINT

typedef struct _USBPORT_ENDPOINT * PUSBPORT_ENDPOINT

Definition at line 155 of file usbport.h.

PUSBPORT_INTERFACE_HANDLE

typedef struct _USBPORT_INTERFACE_HANDLE * PUSBPORT_INTERFACE_HANDLE

PUSBPORT_IRP_TABLE

typedef struct _USBPORT_IRP_TABLE * PUSBPORT_IRP_TABLE

PUSBPORT_ISO_BLOCK

typedef struct _USBPORT_ISO_BLOCK* PUSBPORT_ISO_BLOCK

Definition at line 243 of file usbport.h.

PUSBPORT_PIPE_HANDLE

typedef struct _USBPORT_PIPE_HANDLE * PUSBPORT_PIPE_HANDLE

PUSBPORT_RH_DESCRIPTORS

typedef struct _USBPORT_RH_DESCRIPTORS * PUSBPORT_RH_DESCRIPTORS

PUSBPORT_RHDEVICE_EXTENSION

typedef struct _USBPORT_RHDEVICE_EXTENSION * PUSBPORT_RHDEVICE_EXTENSION

PUSBPORT_TRANSFER

typedef struct _USBPORT_TRANSFER * PUSBPORT_TRANSFER

TIMER_WORK_QUEUE_ITEM

typedef struct _TIMER_WORK_QUEUE_ITEM TIMER_WORK_QUEUE_ITEM

USB2_FRAME_BUDGET

typedef struct _USB2_FRAME_BUDGET USB2_FRAME_BUDGET

USB2_HC_EXTENSION

typedef struct _USB2_HC_EXTENSION USB2_HC_EXTENSION

USB2_REBALANCE

typedef struct _USB2_REBALANCE USB2_REBALANCE

USB2_TT

typedef struct _USB2_TT USB2_TT

USB2_TT_ENDPOINT

typedef struct _USB2_TT_ENDPOINT USB2_TT_ENDPOINT

USB2_TT_ENDPOINT_NUMS

typedef union _USB2_TT_ENDPOINT_NUMS USB2_TT_ENDPOINT_NUMS

USB2_TT_ENDPOINT_PARAMS

typedef union _USB2_TT_ENDPOINT_PARAMS USB2_TT_ENDPOINT_PARAMS

USB2_TT_EXTENSION

typedef struct _USB2_TT_EXTENSION USB2_TT_EXTENSION

USBPORT_ASYNC_CALLBACK_DATA

typedef struct _USBPORT_ASYNC_CALLBACK_DATA USBPORT_ASYNC_CALLBACK_DATA

USBPORT_COMMON_BUFFER_HEADER

typedef struct _USBPORT_COMMON_BUFFER_HEADER USBPORT_COMMON_BUFFER_HEADER

USBPORT_COMMON_DEVICE_EXTENSION

typedef struct _USBPORT_COMMON_DEVICE_EXTENSION USBPORT_COMMON_DEVICE_EXTENSION

USBPORT_CONFIGURATION_HANDLE

typedef struct _USBPORT_CONFIGURATION_HANDLE USBPORT_CONFIGURATION_HANDLE

USBPORT_DEVICE_EXTENSION

typedef struct _USBPORT_DEVICE_EXTENSION USBPORT_DEVICE_EXTENSION

USBPORT_DEVICE_HANDLE

typedef struct _USBPORT_DEVICE_HANDLE USBPORT_DEVICE_HANDLE

USBPORT_ENDPOINT

typedef struct _USBPORT_ENDPOINT USBPORT_ENDPOINT

USBPORT_INTERFACE_HANDLE

typedef struct _USBPORT_INTERFACE_HANDLE USBPORT_INTERFACE_HANDLE

USBPORT_IRP_TABLE

typedef struct _USBPORT_IRP_TABLE USBPORT_IRP_TABLE

USBPORT_PIPE_HANDLE

typedef struct _USBPORT_PIPE_HANDLE USBPORT_PIPE_HANDLE

USBPORT_RH_DESCRIPTORS

typedef struct _USBPORT_RH_DESCRIPTORS USBPORT_RH_DESCRIPTORS

USBPORT_RHDEVICE_EXTENSION

typedef struct _USBPORT_RHDEVICE_EXTENSION USBPORT_RHDEVICE_EXTENSION

USBPORT_TRANSFER

typedef struct _USBPORT_TRANSFER USBPORT_TRANSFER

Function Documentation

C_ASSERT() [1/4]

C_ASSERT

(

sizeof(USB2_TT_ENDPOINT_NUMS)

= =sizeof(ULONG)

)

C_ASSERT() [2/4]

C_ASSERT

(

sizeof(USB2_TT_ENDPOINT_PARAMS)

= =sizeof(ULONG)

)

C_ASSERT() [3/4]

C_ASSERT

(

sizeof(USBPORT_ASYNC_CALLBACK_DATA)

= =16+18 *sizeof(PVOID)

)

C_ASSERT() [4/4]

C_ASSERT

(

sizeof(USBPORT_DEVICE_EXTENSION)

= =0x500

)

MiniportCloseEndpoint()

VOID NTAPI MiniportCloseEndpoint	(	IN PDEVICE_OBJECT	FdoDevice,
		IN PUSBPORT_ENDPOINT	Endpoint
	)

Definition at line 549 of file endpoint.c.

{
    PUSBPORT_DEVICE_EXTENSION  FdoExtension;
    PUSBPORT_REGISTRATION_PACKET Packet;
    BOOLEAN IsDoDisablePeriodic;
    ULONG TransferType;
    KIRQL OldIrql;
 
    DPRINT("MiniportCloseEndpoint: Endpoint - %p\n", Endpoint);
 
    FdoExtension = FdoDevice->DeviceExtension;
    Packet = &FdoExtension->MiniPortInterface->Packet;
 
    KeAcquireSpinLock(&FdoExtension->MiniportSpinLock, &OldIrql);
 
    if (Endpoint->Flags & ENDPOINT_FLAG_OPENED)
    {
        TransferType = Endpoint->EndpointProperties.TransferType;
 
        if (TransferType == USBPORT_TRANSFER_TYPE_INTERRUPT ||
            TransferType == USBPORT_TRANSFER_TYPE_ISOCHRONOUS)
        {
            --FdoExtension->PeriodicEndpoints;
        }
 
        IsDoDisablePeriodic = FdoExtension->PeriodicEndpoints == 0;
 
        Packet->CloseEndpoint(FdoExtension->MiniPortExt,
                              Endpoint + 1,
                              IsDoDisablePeriodic);
 
        Endpoint->Flags &= ~ENDPOINT_FLAG_OPENED;
        Endpoint->Flags |= ENDPOINT_FLAG_CLOSED;
    }
 
    KeReleaseSpinLock(&FdoExtension->MiniportSpinLock, OldIrql);
}

Referenced by USBPORT_DeleteEndpoint(), USBPORT_ReopenPipe(), and USBPORT_RestoreDevice().

MiniportOpenEndpoint()

MPSTATUS NTAPI MiniportOpenEndpoint	(	IN PDEVICE_OBJECT	FdoDevice,
		IN PUSBPORT_ENDPOINT	Endpoint
	)

Definition at line 722 of file endpoint.c.

{
    PUSBPORT_DEVICE_EXTENSION  FdoExtension;
    PUSBPORT_REGISTRATION_PACKET Packet;
    KIRQL OldIrql;
    ULONG TransferType;
    MPSTATUS MpStatus;
 
    DPRINT("MiniportOpenEndpoint: Endpoint - %p\n", Endpoint);
 
    FdoExtension = FdoDevice->DeviceExtension;
    Packet = &FdoExtension->MiniPortInterface->Packet;
 
    KeAcquireSpinLock(&FdoExtension->MiniportSpinLock, &OldIrql);
 
    Endpoint->Flags &= ~ENDPOINT_FLAG_CLOSED;
 
    MpStatus = Packet->OpenEndpoint(FdoExtension->MiniPortExt,
                                    &Endpoint->EndpointProperties,
                                    Endpoint + 1);
 
    if (!MpStatus)
    {
        TransferType = Endpoint->EndpointProperties.TransferType;
 
        if (TransferType == USBPORT_TRANSFER_TYPE_INTERRUPT ||
            TransferType == USBPORT_TRANSFER_TYPE_ISOCHRONOUS)
        {
            ++FdoExtension->PeriodicEndpoints;
        }
 
        Endpoint->Flags |= ENDPOINT_FLAG_OPENED;
    }
 
    KeReleaseSpinLock(&FdoExtension->MiniportSpinLock, OldIrql);
    return MpStatus;
}

Referenced by USBPORT_OpenPipe(), USBPORT_ReopenPipe(), and USBPORT_RestoreDevice().

USB2_InitController()

VOID NTAPI USB2_InitController

(

IN PUSB2_HC_EXTENSION

HcExtension

)

Definition at line 2217 of file usb2.c.

{
    ULONG ix;
    ULONG jx;
 
    DPRINT("USB2_InitController: HcExtension - %p\n", HcExtension);
 
    HcExtension->MaxHsBusAllocation = USB2_MAX_MICROFRAME_ALLOCATION;
 
    for (ix = 0; ix < USB2_FRAMES; ix++)
    {
        for (jx = 0; jx < USB2_MICROFRAMES; jx++)
        {
            HcExtension->TimeUsed[ix][jx] = 0;
        }
    }
 
    HcExtension->HcDelayTime = USB2_CONTROLLER_DELAY;
 
    USB2_InitTT(HcExtension, &HcExtension->HcTt);
}

Referenced by USBPORT_AddDevice().

USB2_InitTT()

VOID NTAPI USB2_InitTT	(	IN PUSB2_HC_EXTENSION	HcExtension,
		IN PUSB2_TT	Tt
	)

Definition at line 2160 of file usb2.c.

{
    ULONG ix;
    ULONG jx;
 
    DPRINT("USB2_InitTT: HcExtension - %p, Tt - %p\n", HcExtension, Tt);
 
    Tt->HcExtension = HcExtension;
    Tt->DelayTime = 1;
    Tt->MaxTime = USB2_FS_MAX_PERIODIC_ALLOCATION;
 
    for (ix = 0; ix < USB2_FRAMES; ix++)
    {
        Tt->FrameBudget[ix].TimeUsed = USB2_MAX_MICROFRAMES;
        Tt->FrameBudget[ix].AltEndpoint = NULL;
 
        for (jx = 0; jx < USB2_MICROFRAMES; jx++)
        {
            Tt->TimeCS[ix][jx] = 0;
            Tt->NumStartSplits[ix][jx] = 0;
        }
 
        Tt->FrameBudget[ix].IsoEndpoint = &Tt->IsoEndpoint[ix];
 
        USB2_InitTtEndpoint(&Tt->IsoEndpoint[ix],
                            USBPORT_TRANSFER_TYPE_ISOCHRONOUS,
                            USBPORT_TRANSFER_DIRECTION_OUT,
                            UsbFullSpeed,
                            USB2_FRAMES,
                            0,
                            Tt);
 
        Tt->IsoEndpoint[ix].ActualPeriod = USB2_FRAMES;
        Tt->IsoEndpoint[ix].CalcBusTime = USB2_FS_SOF_TIME + USB2_HUB_DELAY;
        Tt->IsoEndpoint[ix].StartFrame = ix;
        Tt->IsoEndpoint[ix].StartMicroframe = USB2_PREV_MICROFRAME;
 
        Tt->FrameBudget[ix].IntEndpoint = &Tt->IntEndpoint[ix];
 
        USB2_InitTtEndpoint(&Tt->IntEndpoint[ix],
                            USBPORT_TRANSFER_TYPE_INTERRUPT,
                            USBPORT_TRANSFER_DIRECTION_OUT,
                            UsbFullSpeed,
                            USB2_FRAMES,
                            0,
                            Tt);
 
        Tt->IntEndpoint[ix].ActualPeriod = USB2_FRAMES;
        Tt->IntEndpoint[ix].CalcBusTime = USB2_FS_SOF_TIME + USB2_HUB_DELAY;
        Tt->IntEndpoint[ix].StartFrame = ix;
        Tt->IntEndpoint[ix].StartMicroframe = USB2_PREV_MICROFRAME;
    }
}

Referenced by USB2_InitController(), and USBPORT_InitializeTT().

USBPORT_AbortEndpoint()

VOID NTAPI USBPORT_AbortEndpoint	(	IN PDEVICE_OBJECT	FdoDevice,
		IN PUSBPORT_ENDPOINT	Endpoint,
		IN PIRP	Irp
	)

Definition at line 1354 of file queue.c.

{
    PLIST_ENTRY PendingList;
    PUSBPORT_TRANSFER PendingTransfer;
    PLIST_ENTRY ActiveList;
    PUSBPORT_TRANSFER ActiveTransfer;
 
    DPRINT_CORE("USBPORT_AbortEndpoint: Irp - %p\n", Irp);
 
    KeAcquireSpinLock(&Endpoint->EndpointSpinLock, &Endpoint->EndpointOldIrql);
 
    if (Irp)
    {
        InsertTailList(&Endpoint->AbortList, &Irp->Tail.Overlay.ListEntry);
    }
 
    PendingList = Endpoint->PendingTransferList.Flink;
 
    while (PendingList && PendingList != &Endpoint->PendingTransferList)
    {
        PendingTransfer = CONTAINING_RECORD(PendingList,
                                            USBPORT_TRANSFER,
                                            TransferLink);
 
        DPRINT_CORE("USBPORT_AbortEndpoint: Abort PendingTransfer - %p\n",
                    PendingTransfer);
 
        PendingTransfer->Flags |= TRANSFER_FLAG_ABORTED;
 
        PendingList = PendingTransfer->TransferLink.Flink;
    }
 
    ActiveList = Endpoint->TransferList.Flink;
 
    while (ActiveList && ActiveList != &Endpoint->TransferList)
    {
        ActiveTransfer = CONTAINING_RECORD(ActiveList,
                                           USBPORT_TRANSFER,
                                           TransferLink);
 
        DPRINT_CORE("USBPORT_AbortEndpoint: Abort ActiveTransfer - %p\n",
                    ActiveTransfer);
 
        ActiveTransfer->Flags |= TRANSFER_FLAG_ABORTED;
 
        if (Endpoint->Flags & ENDPOINT_FLAG_ABORTING)
        {
            ActiveTransfer->Flags |= TRANSFER_FLAG_DEVICE_GONE;
        }
 
        ActiveList = ActiveTransfer->TransferLink.Flink;
    }
 
    KeReleaseSpinLock(&Endpoint->EndpointSpinLock, Endpoint->EndpointOldIrql);
 
    USBPORT_InvalidateEndpointHandler(FdoDevice,
                                      Endpoint,
                                      INVALIDATE_ENDPOINT_INT_NEXT_SOF);
 
    USBPORT_FlushPendingTransfers(Endpoint);
    USBPORT_FlushCancelList(Endpoint);
}

Referenced by USBPORT_AbortPipe(), and USBPORT_AbortTransfers().

USBPORT_AcquireBadRequestLock()

VOID NTAPI USBPORT_AcquireBadRequestLock	(	IN PIO_CSQ	Csq,
		IN PKIRQL	Irql
	)

Definition at line 214 of file queue.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
 
    DPRINT_QUEUE("USBPORT_AcquireBadRequestLock: ... \n");
 
    FdoExtension = CONTAINING_RECORD(Csq,
                                     USBPORT_DEVICE_EXTENSION,
                                     BadRequestIoCsq);
 
    KeAcquireSpinLock(&FdoExtension->BadRequestIoCsqSpinLock, Irql);
}

Referenced by USBPORT_StartDevice().

USBPORT_AcquireIdleLock()

VOID NTAPI USBPORT_AcquireIdleLock	(	IN PIO_CSQ	Csq,
		IN PKIRQL	Irql
	)

Definition at line 91 of file queue.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
 
    DPRINT_QUEUE("USBPORT_AcquireIdleLock: ... \n");
 
    FdoExtension = CONTAINING_RECORD(Csq,
                                     USBPORT_DEVICE_EXTENSION,
                                     IdleIoCsq);
 
    KeAcquireSpinLock(&FdoExtension->IdleIoCsqSpinLock, Irql);
}

Referenced by USBPORT_StartDevice().

USBPORT_AddDeviceHandle()

VOID NTAPI USBPORT_AddDeviceHandle	(	IN PDEVICE_OBJECT	FdoDevice,
		IN PUSBPORT_DEVICE_HANDLE	DeviceHandle
	)

Definition at line 769 of file device.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
 
    DPRINT("USBPORT_AddDeviceHandle: ... \n");
 
    FdoExtension = FdoDevice->DeviceExtension;
 
    InsertTailList(&FdoExtension->DeviceHandleList,
                   &DeviceHandle->DeviceHandleLink);
}

Referenced by USBPORT_CreateDevice(), and USBPORT_RootHubCreateDevice().

USBPORT_AddPipeHandle()

VOID NTAPI USBPORT_AddPipeHandle	(	IN PUSBPORT_DEVICE_HANDLE	DeviceHandle,
		IN PUSBPORT_PIPE_HANDLE	PipeHandle
	)

Definition at line 444 of file endpoint.c.

{
    DPRINT("USBPORT_AddPipeHandle: DeviceHandle - %p, PipeHandle - %p\n",
           DeviceHandle,
           PipeHandle);
 
    InsertTailList(&DeviceHandle->PipeHandleList, &PipeHandle->PipeLink);
}

Referenced by USBPORT_OpenPipe(), and USBPORT_RestoreDevice().

USBPORT_AddUSB1Fdo()

VOID NTAPI USBPORT_AddUSB1Fdo

(

IN PDEVICE_OBJECT

FdoDevice

)

Definition at line 66 of file usbport.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
 
    DPRINT("USBPORT_AddUSB1Fdo: FdoDevice - %p\n", FdoDevice);
 
    FdoExtension = FdoDevice->DeviceExtension;
    FdoExtension->Flags |= USBPORT_FLAG_REGISTERED_FDO;
 
    ExInterlockedInsertTailList(&USBPORT_USB1FdoList,
                                &FdoExtension->ControllerLink,
                                &USBPORT_SpinLock);
}

Referenced by USBPORT_FdoPnP().

USBPORT_AddUSB2Fdo()

VOID NTAPI USBPORT_AddUSB2Fdo

(

IN PDEVICE_OBJECT

FdoDevice

)

Definition at line 82 of file usbport.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
 
    DPRINT("USBPORT_AddUSB2Fdo: FdoDevice - %p\n", FdoDevice);
 
    FdoExtension = FdoDevice->DeviceExtension;
    FdoExtension->Flags |= USBPORT_FLAG_REGISTERED_FDO;
 
    ExInterlockedInsertTailList(&USBPORT_USB2FdoList,
                                &FdoExtension->ControllerLink,
                                &USBPORT_SpinLock);
}

Referenced by USBPORT_FdoPnP().

USBPORT_AdjustDeviceCapabilities()

VOID NTAPI USBPORT_AdjustDeviceCapabilities	(	IN PDEVICE_OBJECT	FdoDevice,
		IN PDEVICE_OBJECT	PdoDevice
	)

Definition at line 668 of file power.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    PUSBPORT_RHDEVICE_EXTENSION PdoExtension;
    PDEVICE_CAPABILITIES Capabilities;
 
    DPRINT("USBPORT_AdjustDeviceCapabilities: ... \n");
 
    FdoExtension = FdoDevice->DeviceExtension;
    PdoExtension = PdoDevice->DeviceExtension;
    Capabilities = &PdoExtension->Capabilities;
 
    RtlCopyMemory(Capabilities,
                  &FdoExtension->Capabilities,
                  sizeof(DEVICE_CAPABILITIES));
 
    Capabilities->DeviceD1 = FALSE;
    Capabilities->DeviceD2 = TRUE;
 
    Capabilities->Removable = FALSE;
    Capabilities->UniqueID = FALSE;
 
    Capabilities->WakeFromD0 = TRUE;
    Capabilities->WakeFromD1 = FALSE;
    Capabilities->WakeFromD2 = TRUE;
    Capabilities->WakeFromD3 = FALSE;
 
    Capabilities->Address = 0;
    Capabilities->UINumber = 0;
 
    if (Capabilities->SystemWake == PowerSystemUnspecified)
        Capabilities->SystemWake = PowerSystemWorking;
 
    Capabilities->DeviceWake = PowerDeviceD2;
 
    Capabilities->DeviceState[PowerSystemSleeping1] = PowerDeviceD3;
    Capabilities->DeviceState[PowerSystemSleeping2] = PowerDeviceD3;
    Capabilities->DeviceState[PowerSystemSleeping3] = PowerDeviceD3;
    Capabilities->DeviceState[PowerSystemHibernate] = PowerDeviceD3;
}

Referenced by USBPORT_CreatePdo().

USBPORT_AllocateBandwidthUSB2()

BOOLEAN NTAPI USBPORT_AllocateBandwidthUSB2	(	IN PDEVICE_OBJECT	FdoDevice,
		IN PUSBPORT_ENDPOINT	Endpoint
	)

Definition at line 1799 of file usb2.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    PUSBPORT_ENDPOINT_PROPERTIES EndpointProperties;
    PUSB2_TT_EXTENSION TtExtension;
    ULONG TransferType;
    PUSB2_REBALANCE Rebalance;
    LIST_ENTRY RebalanceList;
    ULONG RebalanceListEntries;
    PUSB2_TT_ENDPOINT TtEndpoint;
    PUSB2_TT_ENDPOINT RebalanceTtEndpoint;
    PUSB2_TT Tt;
    USB_DEVICE_SPEED DeviceSpeed;
    ULONG Period;
    ULONG AllocedBusTime;
    ULONG EndpointBandwidth;
    ULONG ScheduleOffset;
    ULONG Factor;
    ULONG ix;
    ULONG n;
    BOOLEAN Direction;
    UCHAR SMask;
    UCHAR CMask;
    UCHAR ActualPeriod;
    BOOLEAN Result;
 
    DPRINT("USBPORT_AllocateBandwidthUSB2: FdoDevice - %p, Endpoint - %p\n",
           FdoDevice,
           Endpoint);
 
    EndpointProperties = &Endpoint->EndpointProperties;
    EndpointProperties->ScheduleOffset = 0;
 
    if (Endpoint->Flags & ENDPOINT_FLAG_ROOTHUB_EP0)
    {
        DPRINT("USBPORT_AllocateBandwidthUSB2: ENDPOINT_FLAG_ROOTHUB_EP0\n");
        return TRUE;
    }
 
    FdoExtension = FdoDevice->DeviceExtension;
 
    TransferType = EndpointProperties->TransferType;
    DPRINT("USBPORT_AllocateBandwidthUSB2: TransferType - %X\n", TransferType);
 
    if (TransferType == USBPORT_TRANSFER_TYPE_CONTROL ||
        TransferType == USBPORT_TRANSFER_TYPE_BULK)
    {
        return TRUE;
    }
 
    if (Endpoint->TtExtension)
        TtExtension = Endpoint->TtExtension;
    else
        TtExtension = NULL;
 
    InitializeListHead(&RebalanceList);
 
    Rebalance = ExAllocatePoolWithTag(NonPagedPool,
                                      sizeof(USB2_REBALANCE),
                                      USB_PORT_TAG);
 
    DPRINT("USBPORT_AllocateBandwidthUSB2: Rebalance - %p, TtExtension - %p\n",
           Rebalance,
           TtExtension);
 
    if (Rebalance)
    {
        RtlZeroMemory(Rebalance, sizeof(USB2_REBALANCE));
 
        TtEndpoint = Endpoint->TtEndpoint;
        TtEndpoint->Endpoint = Endpoint;
 
        Direction = EndpointProperties->Direction == USBPORT_TRANSFER_DIRECTION_OUT;
        DeviceSpeed = EndpointProperties->DeviceSpeed;
 
        switch (DeviceSpeed)
        {
            case UsbLowSpeed:
            case UsbFullSpeed:
            {
                Tt = &TtExtension->Tt;
                Period = USB2_FRAMES;
 
                while (Period > 0 && Period > EndpointProperties->Period)
                {
                    Period >>= 1;
                }
 
                DPRINT("USBPORT_AllocateBandwidthUSB2: Period - %X\n", Period);
                break;
            }
 
            case UsbHighSpeed:
            {
                Tt = &FdoExtension->Usb2Extension->HcTt;
                Period = EndpointProperties->Period;
 
                break;
            }
 
            default:
            {
                DPRINT1("USBPORT_AllocateBandwidthUSB2: DeviceSpeed - %X!\n",
                        DeviceSpeed);
 
                DbgBreakPoint();
 
                Tt = &TtExtension->Tt;
                break;
            }
        }
 
        USB2_InitTtEndpoint(TtEndpoint,
                            TransferType,
                            Direction,
                            DeviceSpeed,
                            Period,
                            EndpointProperties->MaxPacketSize,
                            Tt);
 
        RebalanceListEntries = USB2_FRAMES - 2;
 
        Result = USB2_AllocateTimeForEndpoint(TtEndpoint,
                                              Rebalance,
                                              &RebalanceListEntries);
 
        if (Result)
        {
            Result = USB2_PromotePeriods(TtEndpoint,
                                         Rebalance,
                                         &RebalanceListEntries);
        }
 
        RebalanceListEntries = 0;
 
        for (ix = 0; Rebalance->RebalanceEndpoint[ix]; ix++)
        {
            RebalanceListEntries = ix + 1;
        }
    }
    else
    {
        RebalanceListEntries = 0;
        Result = FALSE;
    }
 
    DPRINT("USBPORT_AllocateBandwidthUSB2: RebalanceListEntries - %X, Result - %X\n",
           RebalanceListEntries,
           Result);
 
    for (ix = 0; ix < RebalanceListEntries; ix++)
    {
        RebalanceTtEndpoint = Rebalance->RebalanceEndpoint[ix];
 
        DPRINT("USBPORT_AllocateBandwidthUSB2: RebalanceTtEndpoint[%X] - %p, RebalanceTtEndpoint - %p, RebalanceLink - %p\n",
               ix,
               RebalanceTtEndpoint,
               &RebalanceTtEndpoint->Endpoint->RebalanceLink);
 
        InsertTailList(&RebalanceList,
                       &RebalanceTtEndpoint->Endpoint->RebalanceLink);
    }
 
    if (Rebalance)
        ExFreePoolWithTag(Rebalance, USB_PORT_TAG);
 
    if (Result)
    {
        SMask = USB2_GetSMASK(Endpoint->TtEndpoint);
        EndpointProperties->InterruptScheduleMask = SMask;
 
        CMask = USB2_GetCMASK(Endpoint->TtEndpoint);
        EndpointProperties->SplitCompletionMask = CMask;
 
        AllocedBusTime = TtEndpoint->CalcBusTime;
 
        EndpointBandwidth = USB2_MICROFRAMES * AllocedBusTime;
        EndpointProperties->UsbBandwidth = EndpointBandwidth;
 
        ActualPeriod = Endpoint->TtEndpoint->ActualPeriod;
        EndpointProperties->Period = ActualPeriod;
 
        ScheduleOffset = Endpoint->TtEndpoint->StartFrame;
        EndpointProperties->ScheduleOffset = ScheduleOffset;
 
        ASSERT(ActualPeriod);
        Factor = USB2_FRAMES / ActualPeriod;
        n = ScheduleOffset * Factor;
 
        if (TtExtension)
        {
            for (ix = 0; ix < Factor; ix++)
            {
                TtExtension->Bandwidth[n + ix] -= EndpointBandwidth;
            }
        }
        else
        {
            for (ix = 1; ix < Factor; ix++)
            {
                FdoExtension->Bandwidth[n + ix] -= EndpointBandwidth;
            }
        }
 
        USBPORT_DumpingEndpointProperties(EndpointProperties);
        USBPORT_DumpingTtEndpoint(Endpoint->TtEndpoint);
 
        if (AllocedBusTime >= (USB2_FS_MAX_PERIODIC_ALLOCATION / 2))
        {
            DPRINT1("USBPORT_AllocateBandwidthUSB2: AllocedBusTime >= 0.5 * MAX_ALLOCATION \n");
        }
    }
 
    USB2_Rebalance(FdoDevice, &RebalanceList);
 
    if (!TtExtension)
    {
        DPRINT("USBPORT_AllocateBandwidthUSB2: Result - %X\n", Result);
        return Result;
    }
 
    for (ix = 0; ix < USB2_FRAMES; ix++)
    {
        FdoExtension->Bandwidth[ix] += TtExtension->MaxBandwidth;
    }
 
    USBPORT_UpdateAllocatedBwTt(TtExtension);
 
    for (ix = 0; ix < USB2_FRAMES; ix++)
    {
        FdoExtension->Bandwidth[ix] -= TtExtension->MaxBandwidth;
    }
 
    DPRINT("USBPORT_AllocateBandwidthUSB2: Result - %X\n", Result);
 
    return Result;
}

Referenced by USBPORT_OpenPipe().

USBPORT_AllocateCommonBuffer()

PUSBPORT_COMMON_BUFFER_HEADER NTAPI USBPORT_AllocateCommonBuffer	(	IN PDEVICE_OBJECT	FdoDevice,
		IN SIZE_T	BufferLength
	)

Definition at line 1708 of file usbport.c.

{
    PUSBPORT_COMMON_BUFFER_HEADER HeaderBuffer = NULL;
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    PDMA_ADAPTER DmaAdapter;
    PDMA_OPERATIONS DmaOperations;
    SIZE_T HeaderSize;
    ULONG Length = 0;
    ULONG LengthPadded;
    PHYSICAL_ADDRESS LogicalAddress;
    ULONG_PTR BaseVA;
    ULONG_PTR StartBufferVA;
    ULONG StartBufferPA;
 
    DPRINT("USBPORT_AllocateCommonBuffer: FdoDevice - %p, BufferLength - %p\n",
           FdoDevice,
           BufferLength);
 
    if (BufferLength == 0)
        goto Exit;
 
    FdoExtension = FdoDevice->DeviceExtension;
 
    DmaAdapter = FdoExtension->DmaAdapter;
    DmaOperations = DmaAdapter->DmaOperations;
 
    HeaderSize = sizeof(USBPORT_COMMON_BUFFER_HEADER);
    Length = ROUND_TO_PAGES(BufferLength + HeaderSize);
    LengthPadded = Length - (BufferLength + HeaderSize);
 
    BaseVA = (ULONG_PTR)DmaOperations->AllocateCommonBuffer(DmaAdapter,
                                                            Length,
                                                            &LogicalAddress,
                                                            TRUE);
 
    if (!BaseVA)
        goto Exit;
 
    StartBufferVA = BaseVA & ~(PAGE_SIZE - 1);
    StartBufferPA = LogicalAddress.LowPart & ~(PAGE_SIZE - 1);
 
    HeaderBuffer = (PUSBPORT_COMMON_BUFFER_HEADER)(StartBufferVA +
                                                   BufferLength +
                                                   LengthPadded);
 
    HeaderBuffer->Length = Length;
    HeaderBuffer->BaseVA = BaseVA;
    HeaderBuffer->LogicalAddress = LogicalAddress;
 
    HeaderBuffer->BufferLength = BufferLength + LengthPadded;
    HeaderBuffer->VirtualAddress = StartBufferVA;
    HeaderBuffer->PhysicalAddress = StartBufferPA;
 
    RtlZeroMemory((PVOID)StartBufferVA, BufferLength + LengthPadded);
 
Exit:
    return HeaderBuffer;
}

Referenced by USBPORT_OpenPipe(), USBPORT_ReopenPipe(), and USBPORT_StartDevice().

USBPORT_AllocateTransfer()

USBD_STATUS NTAPI USBPORT_AllocateTransfer	(	IN PDEVICE_OBJECT	FdoDevice,
		IN PURB	Urb,
		IN PUSBPORT_DEVICE_HANDLE	DeviceHandle,
		IN PIRP	Irp,
		IN PRKEVENT	Event
	)

Definition at line 2543 of file usbport.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    SIZE_T TransferLength;
    PMDL Mdl;
    ULONG_PTR VirtualAddr;
    ULONG PagesNeed = 0;
    SIZE_T PortTransferLength;
    SIZE_T FullTransferLength;
    PUSBPORT_TRANSFER Transfer;
    PUSBPORT_PIPE_HANDLE PipeHandle;
    USBD_STATUS USBDStatus;
    SIZE_T IsoBlockLen = 0;
 
    DPRINT_CORE("USBPORT_AllocateTransfer: FdoDevice - %p, Urb - %p, DeviceHandle - %p, Irp - %p, Event - %p\n",
           FdoDevice,
           Urb,
           DeviceHandle,
           Irp,
           Event);
 
    FdoExtension = FdoDevice->DeviceExtension;
 
    TransferLength = Urb->UrbControlTransfer.TransferBufferLength;
    PipeHandle = Urb->UrbControlTransfer.PipeHandle;
 
    if (TransferLength)
    {
        Mdl = Urb->UrbControlTransfer.TransferBufferMDL;
        VirtualAddr = (ULONG_PTR)MmGetMdlVirtualAddress(Mdl);
 
        PagesNeed = ADDRESS_AND_SIZE_TO_SPAN_PAGES(VirtualAddr,
                                                   TransferLength);
        if (PagesNeed > 0)
        {
            PagesNeed--;
        }
    }
 
    if (Urb->UrbHeader.Function == URB_FUNCTION_ISOCH_TRANSFER)
    {
        DPRINT1("USBPORT_AllocateTransfer: ISOCH_TRANSFER UNIMPLEMENTED. FIXME\n");
 
        //IsoBlockLen = sizeof(USBPORT_ISO_BLOCK) +
        //              Urb->UrbIsochronousTransfer.NumberOfPackets *
        //              sizeof(USBPORT_ISO_BLOCK_PACKET);
    }
 
    PortTransferLength = sizeof(USBPORT_TRANSFER) +
                         PagesNeed * sizeof(USBPORT_SCATTER_GATHER_ELEMENT) +
                         IsoBlockLen;
 
    FullTransferLength = PortTransferLength +
                         FdoExtension->MiniPortInterface->Packet.MiniPortTransferSize;
 
    Transfer = ExAllocatePoolWithTag(NonPagedPool,
                                     FullTransferLength,
                                     USB_PORT_TAG);
 
    if (!Transfer)
    {
        DPRINT1("USBPORT_AllocateTransfer: Transfer not allocated!\n");
        return USBD_STATUS_INSUFFICIENT_RESOURCES;
    }
 
    RtlZeroMemory(Transfer, FullTransferLength);
 
    Transfer->Irp = Irp;
    Transfer->Urb = Urb;
    Transfer->Endpoint = PipeHandle->Endpoint;
    Transfer->Event = Event;
    Transfer->PortTransferLength = PortTransferLength;
    Transfer->FullTransferLength = FullTransferLength;
    Transfer->IsoBlockPtr = NULL;
    Transfer->Period = 0;
    Transfer->ParentTransfer = Transfer;
 
    if (IsoBlockLen)
    {
        Transfer->IsoBlockPtr = (PVOID)((ULONG_PTR)Transfer +
                                 PortTransferLength - IsoBlockLen);
 
        Transfer->Period = PipeHandle->Endpoint->EndpointProperties.Period;
        Transfer->Flags |= TRANSFER_FLAG_ISO;
    }
 
    Transfer->MiniportTransfer = (PVOID)((ULONG_PTR)Transfer +
                                                    PortTransferLength);
 
    KeInitializeSpinLock(&Transfer->TransferSpinLock);
 
    Urb->UrbControlTransfer.hca.Reserved8[0] = Transfer;
    Urb->UrbHeader.UsbdFlags |= USBD_FLAG_ALLOCATED_TRANSFER;
 
    USBDStatus = USBD_STATUS_SUCCESS;
 
    DPRINT_CORE("USBPORT_AllocateTransfer: return USBDStatus - %x\n",
                USBDStatus);
 
    return USBDStatus;
}

Referenced by USBPORT_SendSetupPacket(), and USBPORT_ValidateURB().

USBPORT_AssertFailure()

ULONG NTAPI USBPORT_AssertFailure	(	PVOID	MiniPortExtension,
		PVOID	FailedAssertion,
		PVOID	FileName,
		ULONG	LineNumber,
		PCHAR	Message
	)

Definition at line 38 of file debug.c.

{
    DPRINT("USBPORT_AssertFailure: ... \n");
    RtlAssert(FailedAssertion, FileName, LineNumber, Message);
    return 0;
}

Referenced by USBPORT_RegisterUSBPortDriver().

USBPORT_BadRequestFlush()

VOID NTAPI USBPORT_BadRequestFlush

(

IN PDEVICE_OBJECT

FdoDevice

)

Definition at line 1328 of file queue.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    PIRP Irp;
 
    DPRINT_QUEUE("USBPORT_BadRequestFlush: ... \n");
 
    FdoExtension = FdoDevice->DeviceExtension;
 
    while (TRUE)
    {
        Irp = IoCsqRemoveNextIrp(&FdoExtension->BadRequestIoCsq, 0);
 
        if (!Irp)
            break;
 
        DPRINT1("USBPORT_BadRequestFlush: Irp - %p\n", Irp);
 
        Irp->IoStatus.Status = STATUS_DEVICE_NOT_CONNECTED;
        Irp->IoStatus.Information = 0;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
    }
}

Referenced by USBHI_FlushTransfers(), and USBPORT_TimerDpc().

USBPORT_BugCheck()

VOID NTAPI USBPORT_BugCheck

(

IN PVOID

MiniPortExtension

)

Definition at line 51 of file debug.c.

{
    DPRINT1("USBPORT_BugCheck: FIXME \n");
    //KeBugCheckEx(BUGCODE_USB_DRIVER, ...);
    ASSERT(FALSE);
}

Referenced by USBPORT_RegisterUSBPortDriver().

USBPORT_CancelActiveTransferIrp()

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

Definition at line 529 of file queue.c.

{
    PUSBPORT_RHDEVICE_EXTENSION PdoExtension;
    PDEVICE_OBJECT FdoDevice;
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    PURB Urb;
    PUSBPORT_TRANSFER Transfer;
    PUSBPORT_ENDPOINT Endpoint;
    PIRP irp;
    PUSBPORT_TRANSFER SplitTransfer;
    PLIST_ENTRY Entry;
    KIRQL OldIrql;
 
    DPRINT_CORE("USBPORT_CancelActiveTransferIrp: Irp - %p\n", Irp);
 
    PdoExtension = DeviceObject->DeviceExtension;
    FdoDevice = PdoExtension->FdoDevice;
    FdoExtension = FdoDevice->DeviceExtension;
 
    IoReleaseCancelSpinLock(Irp->CancelIrql);
 
    KeAcquireSpinLock(&FdoExtension->FlushTransferSpinLock, &OldIrql);
 
    irp = USBPORT_FindActiveTransferIrp(FdoDevice, Irp);
 
    if (!irp)
    {
        KeReleaseSpinLock(&FdoExtension->FlushTransferSpinLock, OldIrql);
        return;
    }
 
    Urb = URB_FROM_IRP(irp);
    Transfer = Urb->UrbControlTransfer.hca.Reserved8[0];
    Endpoint = Transfer->Endpoint;
 
    DPRINT_CORE("USBPORT_CancelActiveTransferIrp: irp - %p, Urb - %p, Transfer - %p\n",
                irp,
                Urb,
                Transfer);
 
    KeAcquireSpinLockAtDpcLevel(&Endpoint->EndpointSpinLock);
 
    Transfer->Flags |= TRANSFER_FLAG_CANCELED;
 
    if (Transfer->Flags & TRANSFER_FLAG_PARENT)
    {
        KeAcquireSpinLockAtDpcLevel(&Transfer->TransferSpinLock);
 
        Entry = Transfer->SplitTransfersList.Flink;
 
        while (Entry && Entry != &Transfer->SplitTransfersList)
        {
            SplitTransfer = CONTAINING_RECORD(Entry,
                                              USBPORT_TRANSFER,
                                              SplitLink);
 
            SplitTransfer->Flags |= TRANSFER_FLAG_CANCELED;
 
            Entry = Entry->Flink;
        }
 
        KeReleaseSpinLockFromDpcLevel(&Transfer->TransferSpinLock);
    }
 
    KeReleaseSpinLockFromDpcLevel(&Endpoint->EndpointSpinLock);
    KeReleaseSpinLock(&FdoExtension->FlushTransferSpinLock, OldIrql);
 
    USBPORT_InvalidateEndpointHandler(FdoDevice,
                                      Endpoint,
                                      INVALIDATE_ENDPOINT_WORKER_THREAD);
    return;
}

Referenced by USBPORT_FlushPendingTransfers().

USBPORT_CancelSplitTransfer()

VOID NTAPI USBPORT_CancelSplitTransfer

(

IN PUSBPORT_TRANSFER

SplitTransfer

)

Definition at line 314 of file trfsplit.c.

{
    PUSBPORT_TRANSFER ParentTransfer;
    PUSBPORT_ENDPOINT Endpoint;
    KIRQL OldIrql;
 
    DPRINT("USBPORT_CancelSplitTransfer \n");
 
    Endpoint = SplitTransfer->Endpoint;
    ParentTransfer = SplitTransfer->ParentTransfer;
    ParentTransfer->CompletedTransferLen += SplitTransfer->CompletedTransferLen;
 
    KeAcquireSpinLock(&ParentTransfer->TransferSpinLock, &OldIrql);
    RemoveEntryList(&SplitTransfer->SplitLink);
    KeReleaseSpinLock(&ParentTransfer->TransferSpinLock, OldIrql);
 
    ExFreePool(SplitTransfer);
 
    if (IsListEmpty(&ParentTransfer->SplitTransfersList))
    {
        InsertTailList(&Endpoint->CancelList, &ParentTransfer->TransferLink);
    }
}

Referenced by USBPORT_DmaEndpointPaused().

USBPORT_ClosePipe()

VOID NTAPI USBPORT_ClosePipe	(	IN PUSBPORT_DEVICE_HANDLE	DeviceHandle,
		IN PDEVICE_OBJECT	FdoDevice,
		IN PUSBPORT_PIPE_HANDLE	PipeHandle
	)

Definition at line 590 of file endpoint.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    PUSBPORT_RHDEVICE_EXTENSION PdoExtension;
    PUSBPORT_ENDPOINT Endpoint;
    PUSBPORT_REGISTRATION_PACKET Packet;
    PUSB2_TT_EXTENSION TtExtension;
    ULONG ix;
    BOOLEAN IsReady;
    KIRQL OldIrql;
 
    DPRINT1("USBPORT_ClosePipe \n");
 
    FdoExtension = FdoDevice->DeviceExtension;
 
    if (PipeHandle->Flags & PIPE_HANDLE_FLAG_CLOSED)
        return;
 
    USBPORT_RemovePipeHandle(DeviceHandle, PipeHandle);
 
    PipeHandle->Flags |= PIPE_HANDLE_FLAG_CLOSED;
 
    if (PipeHandle->Flags & PIPE_HANDLE_FLAG_NULL_PACKET_SIZE)
    {
        PipeHandle->Flags &= ~PIPE_HANDLE_FLAG_NULL_PACKET_SIZE;
        return;
    }
 
    Endpoint = PipeHandle->Endpoint;
 
    KeAcquireSpinLock(&FdoExtension->EndpointListSpinLock, &OldIrql);
 
    if ((Endpoint->Flags & ENDPOINT_FLAG_ROOTHUB_EP0) &&
        (Endpoint->EndpointProperties.TransferType == USBPORT_TRANSFER_TYPE_INTERRUPT))
    {
        PdoExtension = FdoExtension->RootHubPdo->DeviceExtension;
        PdoExtension->Endpoint = NULL;
    }
 
    KeReleaseSpinLock(&FdoExtension->EndpointListSpinLock, OldIrql);
 
    while (TRUE)
    {
        IsReady = TRUE;
 
        KeAcquireSpinLock(&Endpoint->EndpointSpinLock,
                          &Endpoint->EndpointOldIrql);
 
        if (!IsListEmpty(&Endpoint->PendingTransferList))
            IsReady = FALSE;
 
        if (!IsListEmpty(&Endpoint->TransferList))
            IsReady = FALSE;
 
        if (!IsListEmpty(&Endpoint->CancelList))
            IsReady = FALSE;
 
        if (!IsListEmpty(&Endpoint->AbortList))
            IsReady = FALSE;
 
        KeAcquireSpinLockAtDpcLevel(&Endpoint->StateChangeSpinLock);
        if (Endpoint->StateLast != Endpoint->StateNext)
            IsReady = FALSE;
        KeReleaseSpinLockFromDpcLevel(&Endpoint->StateChangeSpinLock);
 
        KeReleaseSpinLock(&Endpoint->EndpointSpinLock,
                          Endpoint->EndpointOldIrql);
 
        if (InterlockedIncrement(&Endpoint->LockCounter))
            IsReady = FALSE;
        InterlockedDecrement(&Endpoint->LockCounter);
 
        if (IsReady == TRUE)
            break;
 
        USBPORT_Wait(FdoDevice, 1);
    }
 
    Endpoint->DeviceHandle = NULL;
    Packet = &FdoExtension->MiniPortInterface->Packet;
 
    if (Packet->MiniPortFlags & USB_MINIPORT_FLAGS_USB2)
    {
        USBPORT_FreeBandwidthUSB2(FdoDevice, Endpoint);
 
        KeAcquireSpinLock(&FdoExtension->TtSpinLock, &OldIrql);
 
        TtExtension = Endpoint->TtExtension;
        DPRINT1("USBPORT_ClosePipe: TtExtension - %p\n", TtExtension);
 
        if (TtExtension)
        {
            RemoveEntryList(&Endpoint->TtLink);
 
            Endpoint->TtLink.Flink = NULL;
            Endpoint->TtLink.Blink = NULL;
 
            if (TtExtension->Flags & USB2_TT_EXTENSION_FLAG_DELETED)
            {
                if (IsListEmpty(&TtExtension->EndpointList))
                {
                    USBPORT_UpdateAllocatedBwTt(TtExtension);
 
                    for (ix = 0; ix < USB2_FRAMES; ix++)
                    {
                        FdoExtension->Bandwidth[ix] += TtExtension->MaxBandwidth;
                    }
 
                    DPRINT1("USBPORT_ClosePipe: ExFreePoolWithTag TtExtension - %p\n", TtExtension);
                    ExFreePoolWithTag(TtExtension, USB_PORT_TAG);
                }
            }
        }
 
        KeReleaseSpinLock(&FdoExtension->TtSpinLock, OldIrql);
    }
    else
    {
        USBPORT_FreeBandwidth(FdoDevice, Endpoint);
    }
 
    KeAcquireSpinLock(&Endpoint->EndpointSpinLock, &Endpoint->EndpointOldIrql);
    USBPORT_SetEndpointState(Endpoint, USBPORT_ENDPOINT_REMOVE);
    KeReleaseSpinLock(&Endpoint->EndpointSpinLock, Endpoint->EndpointOldIrql);
 
    USBPORT_SignalWorkerThread(FdoDevice);
}

Referenced by USBPORT_CloseConfiguration(), USBPORT_CreateDevice(), USBPORT_HandleSelectInterface(), USBPORT_RemoveDevice(), and USBPORT_RestoreDevice().

USBPORT_CompleteCanceledBadRequest()

VOID NTAPI USBPORT_CompleteCanceledBadRequest	(	IN PIO_CSQ	Csq,
		IN PIRP	Irp
	)

Definition at line 246 of file queue.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
 
    DPRINT_QUEUE("USBPORT_CompleteCanceledBadRequest: Irp - %p\n", Irp);
 
    FdoExtension = CONTAINING_RECORD(Csq,
                                     USBPORT_DEVICE_EXTENSION,
                                     BadRequestIoCsq);
 
    InterlockedDecrement(&FdoExtension->BadRequestLockCounter);
 
    Irp->IoStatus.Status = STATUS_CANCELLED;
    Irp->IoStatus.Information = 0;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
}

Referenced by USBPORT_StartDevice().

USBPORT_CompleteCanceledIdleIrp()

VOID NTAPI USBPORT_CompleteCanceledIdleIrp	(	IN PIO_CSQ	Csq,
		IN PIRP	Irp
	)

Definition at line 123 of file queue.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
 
    DPRINT_QUEUE("USBPORT_CompleteCanceledIdleIrp: ... \n");
 
    FdoExtension = CONTAINING_RECORD(Csq,
                                     USBPORT_DEVICE_EXTENSION,
                                     IdleIoCsq);
 
    InterlockedDecrement(&FdoExtension->IdleLockCounter);
 
    Irp->IoStatus.Status = STATUS_CANCELLED;
    Irp->IoStatus.Information = 0;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
}

Referenced by USBPORT_StartDevice().

USBPORT_CompleteIsoTransfer()

ULONG NTAPI USBPORT_CompleteIsoTransfer	(	IN PVOID	MiniPortExtension,
		IN PVOID	MiniPortEndpoint,
		IN PVOID	TransferParameters,
		IN ULONG	TransferLength
	)

Definition at line 25 of file iso.c.

{
    DPRINT1("USBPORT_CompleteIsoTransfer: UNIMPLEMENTED. FIXME.\n");
    return 0;
}

Referenced by USBPORT_RegisterUSBPortDriver().

USBPORT_CompletePdoWaitWake()

VOID NTAPI USBPORT_CompletePdoWaitWake

(

IN PDEVICE_OBJECT

FdoDevice

)

Definition at line 15 of file power.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    PDEVICE_OBJECT PdoDevice;
    PUSBPORT_RHDEVICE_EXTENSION PdoExtension;
    PIRP Irp;
    KIRQL OldIrql;
 
    DPRINT("USBPORT_CompletePdoWaitWake: ... \n");
 
    FdoExtension = FdoDevice->DeviceExtension;
    PdoDevice = FdoExtension->RootHubPdo;
    PdoExtension = PdoDevice->DeviceExtension;
 
    KeAcquireSpinLock(&FdoExtension->PowerWakeSpinLock, &OldIrql);
 
    Irp = PdoExtension->WakeIrp;
 
    if (Irp && IoSetCancelRoutine(Irp, NULL))
    {
        PdoExtension->WakeIrp = NULL;
        KeReleaseSpinLock(&FdoExtension->PowerWakeSpinLock, OldIrql);
 
        DPRINT("USBPORT_CompletePdoWaitWake: Complete Irp - %p\n", Irp);
 
        Irp->IoStatus.Status = STATUS_SUCCESS;
        Irp->IoStatus.Information = 0;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
        return;
    }
 
    KeReleaseSpinLock(&FdoExtension->PowerWakeSpinLock, OldIrql);
}

Referenced by USBPORT_HcWakeDpc(), USBPORT_IsrDpc(), and USBPORT_PdoDevicePowerState().

USBPORT_CompleteTransfer()

VOID NTAPI USBPORT_CompleteTransfer	(	IN PURB	Urb,
		IN USBD_STATUS	TransferStatus
	)

Definition at line 2198 of file usbport.c.

{
    struct _URB_CONTROL_TRANSFER *UrbTransfer;
    PUSBPORT_TRANSFER Transfer;
    NTSTATUS Status;
    PIRP Irp;
    KIRQL OldIrql;
    PRKEVENT Event;
    BOOLEAN WriteToDevice;
    BOOLEAN IsFlushSuccess;
    PMDL Mdl;
    ULONG_PTR CurrentVa;
    SIZE_T TransferLength;
    PUSBPORT_ENDPOINT Endpoint;
    PDEVICE_OBJECT FdoDevice;
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    PDMA_OPERATIONS DmaOperations;
 
    DPRINT("USBPORT_CompleteTransfer: Urb - %p, TransferStatus - %X\n",
           Urb,
           TransferStatus);
 
    UrbTransfer = &Urb->UrbControlTransfer;
    Transfer = UrbTransfer->hca.Reserved8[0];
 
    Transfer->USBDStatus = TransferStatus;
    Status = USBPORT_USBDStatusToNtStatus(Urb, TransferStatus);
 
    UrbTransfer->TransferBufferLength = Transfer->CompletedTransferLen;
 
    if (Transfer->Flags & TRANSFER_FLAG_DMA_MAPPED)
    {
        Endpoint = Transfer->Endpoint;
        FdoDevice = Endpoint->FdoDevice;
        FdoExtension = FdoDevice->DeviceExtension;
        DmaOperations = FdoExtension->DmaAdapter->DmaOperations;
 
        WriteToDevice = Transfer->Direction == USBPORT_DMA_DIRECTION_TO_DEVICE;
        Mdl = UrbTransfer->TransferBufferMDL;
        CurrentVa = (ULONG_PTR)MmGetMdlVirtualAddress(Mdl);
        TransferLength = UrbTransfer->TransferBufferLength;
 
        IsFlushSuccess = DmaOperations->FlushAdapterBuffers(FdoExtension->DmaAdapter,
                                                            Mdl,
                                                            Transfer->MapRegisterBase,
                                                            (PVOID)CurrentVa,
                                                            TransferLength,
                                                            WriteToDevice);
 
        if (!IsFlushSuccess)
        {
            DPRINT("USBPORT_CompleteTransfer: no FlushAdapterBuffers !!!\n");
            ASSERT(FALSE);
        }
 
        KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
 
        DmaOperations->FreeMapRegisters(FdoExtension->DmaAdapter,
                                        Transfer->MapRegisterBase,
                                        Transfer->NumberOfMapRegisters);
 
        KeLowerIrql(OldIrql);
    }
 
    if (Urb->UrbHeader.UsbdFlags & USBD_FLAG_ALLOCATED_MDL)
    {
        IoFreeMdl(Transfer->TransferBufferMDL);
        Urb->UrbHeader.UsbdFlags |= ~USBD_FLAG_ALLOCATED_MDL;
    }
 
    Urb->UrbControlTransfer.hca.Reserved8[0] = NULL;
    Urb->UrbHeader.UsbdFlags |= ~USBD_FLAG_ALLOCATED_TRANSFER;
 
    Irp = Transfer->Irp;
 
    if (Irp)
    {
        if (!NT_SUCCESS(Status))
        {
            //DbgBreakPoint();
            DPRINT1("USBPORT_CompleteTransfer: Irp - %p complete with Status - %lx\n",
                    Irp,
                    Status);
 
            USBPORT_DumpingURB(Urb);
        }
 
        Irp->IoStatus.Status = Status;
        Irp->IoStatus.Information = 0;
 
        KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        KeLowerIrql(OldIrql);
    }
 
    Event = Transfer->Event;
 
    if (Event)
    {
        KeSetEvent(Event, EVENT_INCREMENT, FALSE);
    }
 
    ExFreePoolWithTag(Transfer, USB_PORT_TAG);
 
    DPRINT_CORE("USBPORT_CompleteTransfer: exit\n");
}

Referenced by USBPORT_CancelPendingTransferIrp(), USBPORT_DoneTransfer(), USBPORT_FlushCancelList(), USBPORT_FlushPendingTransfers(), and USBPORT_QueuePendingTransferIrp().

USBPORT_CreateDevice()

NTSTATUS NTAPI USBPORT_CreateDevice	(	IN OUT PUSB_DEVICE_HANDLE *	pUsbdDeviceHandle,
		IN PDEVICE_OBJECT	FdoDevice,
		IN PUSBPORT_DEVICE_HANDLE	HubDeviceHandle,
		IN USHORT	PortStatus,
		IN USHORT	Port
	)

Definition at line 982 of file device.c.

{
    PUSBPORT_DEVICE_HANDLE TtDeviceHandle = NULL;
    PUSB2_TT_EXTENSION TtExtension = NULL;
    USHORT port;
    PUSBPORT_DEVICE_HANDLE DeviceHandle;
    PUSBPORT_PIPE_HANDLE PipeHandle;
    BOOL IsOpenedPipe;
    PVOID DeviceDescriptor;
    USB_DEFAULT_PIPE_SETUP_PACKET SetupPacket;
    ULONG TransferedLen;
    ULONG DescriptorMinSize;
    UCHAR MaxPacketSize;
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    PUSBPORT_REGISTRATION_PACKET Packet;
    NTSTATUS Status;
 
    DPRINT("USBPORT_CreateDevice: PortStatus - %p, Port - %x\n",
           PortStatus,
           Port);
 
    FdoExtension = FdoDevice->DeviceExtension;
    Packet = &FdoExtension->MiniPortInterface->Packet;
 
    KeWaitForSingleObject(&FdoExtension->DeviceSemaphore,
                          Executive,
                          KernelMode,
                          FALSE,
                          NULL);
 
    if (!USBPORT_ValidateDeviceHandle(FdoDevice, HubDeviceHandle))
    {
        KeReleaseSemaphore(&FdoExtension->DeviceSemaphore,
                           LOW_REALTIME_PRIORITY,
                           1,
                           FALSE);
 
        DPRINT1("USBPORT_CreateDevice: Not valid hub DeviceHandle\n");
        return STATUS_DEVICE_NOT_CONNECTED;
    }
 
    port = Port;
 
    if (Packet->MiniPortFlags & USB_MINIPORT_FLAGS_USB2 &&
        !(PortStatus & USB_PORT_STATUS_HIGH_SPEED))
    {
        DPRINT1("USBPORT_CreateDevice: USB1 device connected to USB2 port\n");
 
        TtExtension = USBPORT_GetTt(FdoDevice,
                                    HubDeviceHandle,
                                    &port,
                                    &TtDeviceHandle);
 
        DPRINT("USBPORT_CreateDevice: TtDeviceHandle - %p, port - %x\n",
               TtDeviceHandle,
               port);
    }
 
    KeReleaseSemaphore(&FdoExtension->DeviceSemaphore,
                       LOW_REALTIME_PRIORITY,
                       1,
                       FALSE);
 
    DeviceHandle = ExAllocatePoolWithTag(NonPagedPool,
                                         sizeof(USBPORT_DEVICE_HANDLE),
                                         USB_PORT_TAG);
 
    if (!DeviceHandle)
    {
        DPRINT1("USBPORT_CreateDevice: Not allocated DeviceHandle\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    RtlZeroMemory(DeviceHandle, sizeof(USBPORT_DEVICE_HANDLE));
 
    *pUsbdDeviceHandle = NULL;
 
    DeviceHandle->TtExtension = TtExtension;
    DeviceHandle->PortNumber = Port;
    DeviceHandle->HubDeviceHandle = HubDeviceHandle;
 
    if (PortStatus & USB_PORT_STATUS_LOW_SPEED)
    {
        DeviceHandle->DeviceSpeed = UsbLowSpeed;
    }
    else if (PortStatus & USB_PORT_STATUS_HIGH_SPEED)
    {
        DeviceHandle->DeviceSpeed = UsbHighSpeed;
    }
    else
    {
        DeviceHandle->DeviceSpeed = UsbFullSpeed;
    }
 
    KeWaitForSingleObject(&FdoExtension->DeviceSemaphore,
                          Executive,
                          KernelMode,
                          FALSE,
                          NULL);
 
    PipeHandle = &DeviceHandle->PipeHandle;
 
    PipeHandle->Flags = PIPE_HANDLE_FLAG_CLOSED;
 
    PipeHandle->EndpointDescriptor.bLength = sizeof(PipeHandle->EndpointDescriptor);
    PipeHandle->EndpointDescriptor.bDescriptorType = USB_ENDPOINT_DESCRIPTOR_TYPE;
 
    if (DeviceHandle->DeviceSpeed == UsbLowSpeed)
    {
        PipeHandle->EndpointDescriptor.wMaxPacketSize = 8;
    }
    else
    {
        PipeHandle->EndpointDescriptor.wMaxPacketSize = USB_DEFAULT_MAX_PACKET;
    }
 
    InitializeListHead(&DeviceHandle->PipeHandleList);
    InitializeListHead(&DeviceHandle->TtList);
 
    Status = USBPORT_OpenPipe(FdoDevice,
                              DeviceHandle,
                              PipeHandle,
                              NULL);
 
    IsOpenedPipe = NT_SUCCESS(Status);
 
    if (NT_ERROR(Status))
    {
        DPRINT1("USBPORT_CreateDevice: USBPORT_OpenPipe return - %lx\n", Status);
 
        KeReleaseSemaphore(&FdoExtension->DeviceSemaphore,
                           LOW_REALTIME_PRIORITY,
                           1,
                           FALSE);
 
        ExFreePoolWithTag(DeviceHandle, USB_PORT_TAG);
 
        return Status;
    }
 
    DeviceDescriptor = ExAllocatePoolWithTag(NonPagedPool,
                                             USB_DEFAULT_MAX_PACKET,
                                             USB_PORT_TAG);
 
    if (!DeviceDescriptor)
    {
        DPRINT1("USBPORT_CreateDevice: Not allocated DeviceDescriptor\n");
        goto ErrorExit;
    }
 
    RtlZeroMemory(DeviceDescriptor, USB_DEFAULT_MAX_PACKET);
    RtlZeroMemory(&SetupPacket, sizeof(USB_DEFAULT_PIPE_SETUP_PACKET));
 
    SetupPacket.bmRequestType.Dir = BMREQUEST_DEVICE_TO_HOST;
    SetupPacket.bRequest = USB_REQUEST_GET_DESCRIPTOR;
    SetupPacket.wValue.HiByte = USB_DEVICE_DESCRIPTOR_TYPE;
    SetupPacket.wLength = USB_DEFAULT_MAX_PACKET;
 
    TransferedLen = 0;
 
    Status = USBPORT_SendSetupPacket(DeviceHandle,
                                     FdoDevice,
                                     &SetupPacket,
                                     DeviceDescriptor,
                                     USB_DEFAULT_MAX_PACKET,
                                     &TransferedLen,
                                     NULL);
 
    RtlCopyMemory(&DeviceHandle->DeviceDescriptor,
                  DeviceDescriptor,
                  sizeof(USB_DEVICE_DESCRIPTOR));
 
    ExFreePoolWithTag(DeviceDescriptor, USB_PORT_TAG);
 
    DescriptorMinSize = RTL_SIZEOF_THROUGH_FIELD(USB_DEVICE_DESCRIPTOR,
                                                 bMaxPacketSize0);
 
    if ((TransferedLen == DescriptorMinSize) && !NT_SUCCESS(Status))
    {
        Status = STATUS_SUCCESS;
    }
 
    if (NT_SUCCESS(Status) && (TransferedLen >= DescriptorMinSize))
    {
        if ((DeviceHandle->DeviceDescriptor.bLength >= sizeof(USB_DEVICE_DESCRIPTOR)) &&
            (DeviceHandle->DeviceDescriptor.bDescriptorType == USB_DEVICE_DESCRIPTOR_TYPE))
        {
            MaxPacketSize = DeviceHandle->DeviceDescriptor.bMaxPacketSize0;
 
            if (MaxPacketSize == 8 ||
                MaxPacketSize == 16 ||
                MaxPacketSize == 32 ||
                MaxPacketSize == 64)
            {
                USBPORT_AddDeviceHandle(FdoDevice, DeviceHandle);
 
                *pUsbdDeviceHandle = DeviceHandle;
 
                KeReleaseSemaphore(&FdoExtension->DeviceSemaphore,
                                   LOW_REALTIME_PRIORITY,
                                   1,
                                   FALSE);
 
                return Status;
            }
        }
    }
 
    DPRINT1("USBPORT_CreateDevice: ERROR!!! TransferedLen - %x, Status - %lx\n",
            TransferedLen,
            Status);
 
ErrorExit:
 
    if (TtExtension && TtDeviceHandle)
    {
        SetupPacket.bmRequestType.Recipient = BMREQUEST_TO_OTHER;
        SetupPacket.bmRequestType.Reserved = 0;
        SetupPacket.bmRequestType.Type = BMREQUEST_CLASS;
        SetupPacket.bmRequestType.Dir = BMREQUEST_HOST_TO_DEVICE;
 
        /* Table 11-15.  Hub Class Requests */
        if (TtDeviceHandle == HubDeviceHandle)
        {
            SetupPacket.bRequest = USB_REQUEST_RESET_TT;
        }
        else
        {
            SetupPacket.bRequest = USB_REQUEST_CLEAR_TT_BUFFER;
        }
 
        SetupPacket.wValue.LowByte = 0;
        SetupPacket.wValue.HiByte = 0;
        SetupPacket.wIndex.W = port;
        SetupPacket.wLength = 0;
 
        USBPORT_SendSetupPacket(TtDeviceHandle,
                                FdoDevice,
                                &SetupPacket,
                                NULL,
                                0,
                                NULL,
                                NULL);
    }
 
    Status = STATUS_DEVICE_DATA_ERROR;
 
    if (IsOpenedPipe)
    {
        USBPORT_ClosePipe(DeviceHandle, FdoDevice, PipeHandle);
    }
 
    KeReleaseSemaphore(&FdoExtension->DeviceSemaphore,
                       LOW_REALTIME_PRIORITY,
                       1,
                       FALSE);
 
    ExFreePoolWithTag(DeviceHandle, USB_PORT_TAG);
 
    return Status;
}

Referenced by USBHI_CreateUsbDevice().

USBPORT_CreateWorkerThread()

NTSTATUS NTAPI USBPORT_CreateWorkerThread

(

IN PDEVICE_OBJECT

FdoDevice

)

Definition at line 1427 of file usbport.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    NTSTATUS Status;
 
    DPRINT("USBPORT_CreateWorkerThread ...\n");
 
    FdoExtension = FdoDevice->DeviceExtension;
 
    FdoExtension->Flags &= ~USBPORT_FLAG_WORKER_THREAD_ON;
 
    KeInitializeEvent(&FdoExtension->WorkerThreadEvent,
                      NotificationEvent,
                      FALSE);
 
    Status = PsCreateSystemThread(&FdoExtension->WorkerThreadHandle,
                                  THREAD_ALL_ACCESS,
                                  NULL,
                                  NULL,
                                  NULL,
                                  USBPORT_WorkerThread,
                                  (PVOID)FdoDevice);
 
    return Status;
}

Referenced by USBPORT_StartDevice().

USBPORT_DbgPrint()

ULONG USBPORT_DbgPrint	(	IN PVOID	MiniPortExtension,
		IN ULONG	Level,
		IN PCH	Format,
			...
	)

Definition at line 19 of file debug.c.

{
    DPRINT("USBPORT_DbgPrint: UNIMPLEMENTED. FIXME. \n");
    return 0;
}

Referenced by USBPORT_RegisterUSBPortDriver().

USBPORT_DoIdleNotificationCallback()

VOID NTAPI USBPORT_DoIdleNotificationCallback

(

IN PVOID

Context

)

Definition at line 545 of file power.c.

{
    PIO_STACK_LOCATION IoStack;
    PDEVICE_OBJECT FdoDevice;
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    PUSBPORT_RHDEVICE_EXTENSION PdoExtension;
    PIRP NextIrp;
    LARGE_INTEGER CurrentTime = {{0, 0}};
    PTIMER_WORK_QUEUE_ITEM IdleQueueItem;
    PDEVICE_OBJECT PdoDevice;
    PUSB_IDLE_CALLBACK_INFO IdleCallbackInfo;
    KIRQL OldIrql;
 
    DPRINT("USBPORT_DoIdleNotificationCallback \n");
 
    IdleQueueItem = Context;
 
    FdoDevice = IdleQueueItem->FdoDevice;
    FdoExtension = FdoDevice->DeviceExtension;
    PdoDevice = FdoExtension->RootHubPdo;
    PdoExtension = PdoDevice->DeviceExtension;
 
    KeQuerySystemTime(&CurrentTime);
 
    if ((FdoExtension->IdleTime.QuadPart == 0) ||
        (((CurrentTime.QuadPart - FdoExtension->IdleTime.QuadPart) / 10000) >= 500))
    {
        if (PdoExtension->CommonExtension.DevicePowerState == PowerDeviceD0 &&
            FdoExtension->CommonExtension.DevicePowerState == PowerDeviceD0)
        {
            NextIrp = IoCsqRemoveNextIrp(&FdoExtension->IdleIoCsq, NULL);
 
            if (NextIrp)
            {
                IoStack = IoGetCurrentIrpStackLocation(NextIrp);
                IdleCallbackInfo = IoStack->Parameters.DeviceIoControl.Type3InputBuffer;
 
                if (IdleCallbackInfo && IdleCallbackInfo->IdleCallback)
                {
                    IdleCallbackInfo->IdleCallback(IdleCallbackInfo->IdleContext);
                }
 
                if (NextIrp->Cancel)
                {
                    InterlockedDecrement(&FdoExtension->IdleLockCounter);
 
                    NextIrp->IoStatus.Status = STATUS_CANCELLED;
                    NextIrp->IoStatus.Information = 0;
                    IoCompleteRequest(NextIrp, IO_NO_INCREMENT);
                }
                else
                {
                    IoCsqInsertIrp(&FdoExtension->IdleIoCsq, NextIrp, NULL);
                }
            }
        }
    }
 
    KeAcquireSpinLock(&FdoExtension->TimerFlagsSpinLock, &OldIrql);
    FdoExtension->TimerFlags &= ~USBPORT_TMFLAG_IDLE_QUEUEITEM_ON;
    KeReleaseSpinLock(&FdoExtension->TimerFlagsSpinLock, OldIrql);
 
    ExFreePoolWithTag(IdleQueueItem, USB_PORT_TAG);
}

Referenced by USBPORT_TimerDpc().

USBPORT_DoneSplitTransfer()

VOID NTAPI USBPORT_DoneSplitTransfer

(

IN PUSBPORT_TRANSFER

SplitTransfer

)

Definition at line 278 of file trfsplit.c.

{
    PUSBPORT_TRANSFER ParentTransfer;
    KIRQL OldIrql;
 
    DPRINT("USBPORT_DoneSplitTransfer: ... \n");
 
    ParentTransfer = SplitTransfer->ParentTransfer;
    ParentTransfer->CompletedTransferLen += SplitTransfer->CompletedTransferLen;
 
    if (SplitTransfer->USBDStatus != USBD_STATUS_SUCCESS)
    {
        DPRINT1("USBPORT_DoneSplitTransfer: SplitTransfer->USBDStatus - %X\n",
                SplitTransfer->USBDStatus);
 
        ParentTransfer->USBDStatus = SplitTransfer->USBDStatus;
    }
 
    KeAcquireSpinLock(&ParentTransfer->TransferSpinLock, &OldIrql);
 
    RemoveEntryList(&SplitTransfer->SplitLink);
    ExFreePoolWithTag(SplitTransfer, USB_PORT_TAG);
 
    if (IsListEmpty(&ParentTransfer->SplitTransfersList))
    {
        KeReleaseSpinLock(&ParentTransfer->TransferSpinLock, OldIrql);
        USBPORT_DoneTransfer(ParentTransfer);
    }
    else
    {
        KeReleaseSpinLock(&ParentTransfer->TransferSpinLock, OldIrql);
    }
}

Referenced by USBPORT_FlushDoneTransfers().

USBPORT_DoneTransfer()

VOID NTAPI USBPORT_DoneTransfer

(

IN PUSBPORT_TRANSFER

Transfer

)

Definition at line 724 of file usbport.c.

{
    PUSBPORT_ENDPOINT          Endpoint;
    PDEVICE_OBJECT             FdoDevice;
    PUSBPORT_DEVICE_EXTENSION  FdoExtension;
    PURB                       Urb;
    PIRP                       Irp;
    KIRQL                      CancelIrql;
    KIRQL                      OldIrql;
 
    DPRINT_CORE("USBPORT_DoneTransfer: Transfer - %p\n", Transfer);
 
    Endpoint = Transfer->Endpoint;
    FdoDevice = Endpoint->FdoDevice;
    FdoExtension = FdoDevice->DeviceExtension;
 
    Urb = Transfer->Urb;
    Irp = Transfer->Irp;
 
    KeAcquireSpinLock(&FdoExtension->FlushTransferSpinLock, &OldIrql);
 
    if (Irp)
    {
        IoAcquireCancelSpinLock(&CancelIrql);
        IoSetCancelRoutine(Irp, NULL);
        IoReleaseCancelSpinLock(CancelIrql);
 
        USBPORT_RemoveActiveTransferIrp(FdoDevice, Irp);
    }
 
    KeReleaseSpinLock(&FdoExtension->FlushTransferSpinLock, OldIrql);
 
    USBPORT_USBDStatusToNtStatus(Transfer->Urb, Transfer->USBDStatus);
    USBPORT_CompleteTransfer(Urb, Urb->UrbHeader.Status);
 
    DPRINT_CORE("USBPORT_DoneTransfer: exit\n");
}

Referenced by USBPORT_DoneSplitTransfer(), and USBPORT_FlushDoneTransfers().

USBPORT_DoSetPowerD0()

VOID NTAPI USBPORT_DoSetPowerD0

(

IN PDEVICE_OBJECT

FdoDevice

)

Definition at line 104 of file power.c.

{
    DPRINT("USBPORT_DoSetPowerD0: FIXME!\n");
    return;
}

Referenced by USBPORT_WorkerThread().

USBPORT_DpcHandler()

VOID NTAPI USBPORT_DpcHandler

(

IN PDEVICE_OBJECT

FdoDevice

)

Definition at line 864 of file usbport.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    PUSBPORT_ENDPOINT Endpoint;
    PLIST_ENTRY Entry;
    LIST_ENTRY List;
    LONG LockCounter;
 
    DPRINT_CORE("USBPORT_DpcHandler: ...\n");
 
    FdoExtension = FdoDevice->DeviceExtension;
 
    InitializeListHead(&List);
 
    KeAcquireSpinLockAtDpcLevel(&FdoExtension->EndpointListSpinLock);
    Entry = FdoExtension->EndpointList.Flink;
 
    while (Entry && Entry != &FdoExtension->EndpointList)
    {
        Endpoint = CONTAINING_RECORD(Entry,
                                     USBPORT_ENDPOINT,
                                     EndpointLink);
 
        LockCounter = InterlockedIncrement(&Endpoint->LockCounter);
 
        if (USBPORT_GetEndpointState(Endpoint) != USBPORT_ENDPOINT_ACTIVE ||
            LockCounter ||
            Endpoint->Flags & ENDPOINT_FLAG_ROOTHUB_EP0)
        {
            InterlockedDecrement(&Endpoint->LockCounter);
        }
        else
        {
            InsertTailList(&List, &Endpoint->DispatchLink);
 
            if (Endpoint->WorkerLink.Flink && Endpoint->WorkerLink.Blink)
            {
                RemoveEntryList(&Endpoint->WorkerLink);
 
                Endpoint->WorkerLink.Flink = NULL;
                Endpoint->WorkerLink.Blink = NULL;
            }
        }
 
        Entry = Endpoint->EndpointLink.Flink;
    }
 
    KeReleaseSpinLockFromDpcLevel(&FdoExtension->EndpointListSpinLock);
 
    while (!IsListEmpty(&List))
    {
        Endpoint = CONTAINING_RECORD(List.Flink,
                                     USBPORT_ENDPOINT,
                                     DispatchLink);
 
        RemoveEntryList(List.Flink);
        Endpoint->DispatchLink.Flink = NULL;
        Endpoint->DispatchLink.Blink = NULL;
 
        USBPORT_EndpointWorker(Endpoint, TRUE);
        USBPORT_FlushPendingTransfers(Endpoint);
    }
 
    KeAcquireSpinLockAtDpcLevel(&FdoExtension->EndpointListSpinLock);
 
    if (!IsListEmpty(&FdoExtension->WorkerList))
    {
        USBPORT_SignalWorkerThread(FdoDevice);
    }
 
    KeReleaseSpinLockFromDpcLevel(&FdoExtension->EndpointListSpinLock);
 
    USBPORT_FlushDoneTransfers(FdoDevice);
}

Referenced by USBPORT_IsrDpcHandler(), and USBPORT_WorkerRequestDpc().

USBPORT_DumpingCapabilities()

VOID NTAPI USBPORT_DumpingCapabilities

(

IN PDEVICE_CAPABILITIES

Capabilities

)

Definition at line 170 of file debug.c.

{
    if (!Capabilities)
    {
        return;
    }
 
    DPRINT("Capabilities->Size              - %x\n", Capabilities->Size);
    DPRINT("Capabilities->Version           - %x\n", Capabilities->Version);
 
    DPRINT("Capabilities->DeviceD1          - %x\n", Capabilities->DeviceD1);
    DPRINT("Capabilities->DeviceD2          - %x\n", Capabilities->DeviceD2);
    DPRINT("Capabilities->LockSupported     - %x\n", Capabilities->LockSupported);
    DPRINT("Capabilities->EjectSupported    - %x\n", Capabilities->EjectSupported);
    DPRINT("Capabilities->Removable         - %x\n", Capabilities->Removable);
    DPRINT("Capabilities->DockDevice        - %x\n", Capabilities->DockDevice);
    DPRINT("Capabilities->UniqueID          - %x\n", Capabilities->UniqueID);
    DPRINT("Capabilities->SilentInstall     - %x\n", Capabilities->SilentInstall);
    DPRINT("Capabilities->RawDeviceOK       - %x\n", Capabilities->RawDeviceOK);
    DPRINT("Capabilities->SurpriseRemovalOK - %x\n", Capabilities->SurpriseRemovalOK);
 
    DPRINT("Capabilities->Address           - %x\n", Capabilities->Address);
    DPRINT("Capabilities->UINumber          - %x\n", Capabilities->UINumber);
 
    DPRINT("Capabilities->DeviceState[0]    - %x\n", Capabilities->DeviceState[0]);
    DPRINT("Capabilities->DeviceState[1]    - %x\n", Capabilities->DeviceState[1]);
    DPRINT("Capabilities->DeviceState[2]    - %x\n", Capabilities->DeviceState[2]);
    DPRINT("Capabilities->DeviceState[3]    - %x\n", Capabilities->DeviceState[3]);
    DPRINT("Capabilities->DeviceState[4]    - %x\n", Capabilities->DeviceState[4]);
    DPRINT("Capabilities->DeviceState[5]    - %x\n", Capabilities->DeviceState[5]);
    DPRINT("Capabilities->DeviceState[6]    - %x\n", Capabilities->DeviceState[6]);
 
    DPRINT("Capabilities->SystemWake        - %x\n", Capabilities->SystemWake);
    DPRINT("Capabilities->DeviceWake        - %x\n", Capabilities->DeviceWake);
 
    DPRINT("Capabilities->D1Latency         - %x\n", Capabilities->D1Latency);
    DPRINT("Capabilities->D2Latency         - %x\n", Capabilities->D2Latency);
    DPRINT("Capabilities->D3Latency         - %x\n", Capabilities->D3Latency);
}

Referenced by USBPORT_QueryCapabilities().

USBPORT_DumpingConfiguration()

VOID NTAPI USBPORT_DumpingConfiguration

(

IN PUSB_CONFIGURATION_DESCRIPTOR

ConfigDescriptor

)

Definition at line 105 of file debug.c.

{
    PUSB_INTERFACE_DESCRIPTOR iDescriptor;
    PUSB_ENDPOINT_DESCRIPTOR Descriptor;
    ULONG ix;
 
    if (!ConfigDescriptor ||
        ConfigDescriptor->bLength < sizeof(USB_CONFIGURATION_DESCRIPTOR))
    {
        return;
    }
 
    DPRINT_URB("Dumping ConfigDescriptor - %p\n", ConfigDescriptor);
    DPRINT_URB("bLength             - %x\n", ConfigDescriptor->bLength);
    DPRINT_URB("bDescriptorType     - %x\n", ConfigDescriptor->bDescriptorType);
    DPRINT_URB("wTotalLength        - %x\n", ConfigDescriptor->wTotalLength);
    DPRINT_URB("bNumInterfaces      - %x\n", ConfigDescriptor->bNumInterfaces);
    DPRINT_URB("bConfigurationValue - %x\n", ConfigDescriptor->bConfigurationValue);
    DPRINT_URB("iConfiguration      - %x\n", ConfigDescriptor->iConfiguration);
    DPRINT_URB("bmAttributes        - %x\n", ConfigDescriptor->bmAttributes);
    DPRINT_URB("MaxPower            - %x\n", ConfigDescriptor->MaxPower);
 
    iDescriptor = (PUSB_INTERFACE_DESCRIPTOR)((ULONG_PTR)ConfigDescriptor +
                                                         ConfigDescriptor->bLength);
 
    if (iDescriptor->bLength < sizeof(USB_INTERFACE_DESCRIPTOR))
    {
        return;
    }
 
    DPRINT_URB("Dumping iDescriptor - %p\n", iDescriptor);
    DPRINT_URB("bLength             - %x\n", iDescriptor->bLength);
    DPRINT_URB("bDescriptorType     - %x\n", iDescriptor->bDescriptorType);
    DPRINT_URB("bInterfaceNumber    - %x\n", iDescriptor->bInterfaceNumber);
    DPRINT_URB("bAlternateSetting   - %x\n", iDescriptor->bAlternateSetting);
    DPRINT_URB("bNumEndpoints       - %x\n", iDescriptor->bNumEndpoints);
    DPRINT_URB("bInterfaceClass     - %x\n", iDescriptor->bInterfaceClass);
    DPRINT_URB("bInterfaceSubClass  - %x\n", iDescriptor->bInterfaceSubClass);
    DPRINT_URB("bInterfaceProtocol  - %x\n", iDescriptor->bInterfaceProtocol);
    DPRINT_URB("iInterface          - %x\n", iDescriptor->iInterface);
 
    Descriptor = (PUSB_ENDPOINT_DESCRIPTOR)((ULONG_PTR)iDescriptor +
                                                       iDescriptor->bLength);
 
    for (ix = 0; ix < iDescriptor->bNumEndpoints; ix++)
    {
        if (Descriptor->bLength < sizeof(USB_ENDPOINT_DESCRIPTOR))
        {
            return;
        }
 
        DPRINT_URB("Dumping Descriptor  - %p\n", Descriptor);
        DPRINT_URB("bLength             - %x\n", Descriptor->bLength);
        DPRINT_URB("bDescriptorType     - %x\n", Descriptor->bDescriptorType);
        DPRINT_URB("bEndpointAddress    - %x\n", Descriptor->bEndpointAddress);
        DPRINT_URB("bmAttributes        - %x\n", Descriptor->bmAttributes);
        DPRINT_URB("wMaxPacketSize      - %x\n", Descriptor->wMaxPacketSize);
        DPRINT_URB("bInterval           - %x\n", Descriptor->bInterval);
 
        Descriptor += 1;
    }
}

Referenced by USBPORT_HandleSelectConfiguration().

USBPORT_DumpingDeviceDescriptor()

VOID NTAPI USBPORT_DumpingDeviceDescriptor

(

IN PUSB_DEVICE_DESCRIPTOR

DeviceDescriptor

)

Definition at line 79 of file debug.c.

{
    if (!DeviceDescriptor)
    {
        return;
    }
 
    DPRINT_URB("Dumping Device Descriptor - %p\n", DeviceDescriptor);
    DPRINT_URB("bLength             - %x\n", DeviceDescriptor->bLength);
    DPRINT_URB("bDescriptorType     - %x\n", DeviceDescriptor->bDescriptorType);
    DPRINT_URB("bcdUSB              - %x\n", DeviceDescriptor->bcdUSB);
    DPRINT_URB("bDeviceClass        - %x\n", DeviceDescriptor->bDeviceClass);
    DPRINT_URB("bDeviceSubClass     - %x\n", DeviceDescriptor->bDeviceSubClass);
    DPRINT_URB("bDeviceProtocol     - %x\n", DeviceDescriptor->bDeviceProtocol);
    DPRINT_URB("bMaxPacketSize0     - %x\n", DeviceDescriptor->bMaxPacketSize0);
    DPRINT_URB("idVendor            - %x\n", DeviceDescriptor->idVendor);
    DPRINT_URB("idProduct           - %x\n", DeviceDescriptor->idProduct);
    DPRINT_URB("bcdDevice           - %x\n", DeviceDescriptor->bcdDevice);
    DPRINT_URB("iManufacturer       - %x\n", DeviceDescriptor->iManufacturer);
    DPRINT_URB("iProduct            - %x\n", DeviceDescriptor->iProduct);
    DPRINT_URB("iSerialNumber       - %x\n", DeviceDescriptor->iSerialNumber);
    DPRINT_URB("bNumConfigurations  - %x\n", DeviceDescriptor->bNumConfigurations);
}

Referenced by USBHI_GetUsbDescriptors(), and USBHI_QueryDeviceInformation().

USBPORT_DumpingEndpointProperties()

VOID NTAPI USBPORT_DumpingEndpointProperties

(

IN PUSBPORT_ENDPOINT_PROPERTIES

EndpointProperties

)

Definition at line 280 of file debug.c.

{
    DPRINT_USB2("DeviceAddress         - %X\n", EndpointProperties->DeviceAddress);
    DPRINT_USB2("EndpointAddress       - %X\n", EndpointProperties->EndpointAddress);
    DPRINT_USB2("TotalMaxPacketSize    - %X\n", EndpointProperties->TotalMaxPacketSize);
    DPRINT_USB2("Period                - %X\n", EndpointProperties->Period);
    DPRINT_USB2("DeviceSpeed           - %X\n", EndpointProperties->DeviceSpeed);
    DPRINT_USB2("UsbBandwidth          - %X\n", EndpointProperties->UsbBandwidth);
    DPRINT_USB2("ScheduleOffset        - %X\n", EndpointProperties->ScheduleOffset);
    DPRINT_USB2("TransferType          - %X\n", EndpointProperties->TransferType);
    DPRINT_USB2("MaxTransferSize       - %X\n", EndpointProperties->MaxTransferSize);
    DPRINT_USB2("HubAddr               - %X\n", EndpointProperties->HubAddr);
    DPRINT_USB2("PortNumber            - %X\n", EndpointProperties->PortNumber);
    DPRINT_USB2("InterruptScheduleMask - %X\n", EndpointProperties->InterruptScheduleMask);
    DPRINT_USB2("SplitCompletionMask   - %X\n", EndpointProperties->SplitCompletionMask);
    DPRINT_USB2("MaxPacketSize         - %X\n", EndpointProperties->MaxPacketSize);
}

Referenced by USBPORT_AllocateBandwidthUSB2().

USBPORT_DumpingIDs()

VOID NTAPI USBPORT_DumpingIDs

(

IN PVOID

Buffer

)

Definition at line 257 of file debug.c.

{
    PWSTR Ptr;
    ULONG Length;
    ULONG TotalLength = 0;
 
    Ptr = (PWSTR)Buffer;
 
    while (*Ptr)
    {
        DPRINT("  %S\n", Ptr);
        Length = (ULONG)wcslen(Ptr) + 1;
 
        Ptr += Length;
        TotalLength += Length;
    }
 
    DPRINT("TotalLength: %hu\n", TotalLength);
    DPRINT("\n");
}

Referenced by USBPORT_GetDeviceHwIds().

USBPORT_DumpingSetupPacket()

VOID NTAPI USBPORT_DumpingSetupPacket

(

IN PUSB_DEFAULT_PIPE_SETUP_PACKET

SetupPacket

)

Definition at line 212 of file debug.c.

{
    DPRINT("SetupPacket->bmRequestType.B - %x\n", SetupPacket->bmRequestType.B);
    DPRINT("SetupPacket->bRequest        - %x\n", SetupPacket->bRequest);
    DPRINT("SetupPacket->wValue.LowByte  - %x\n", SetupPacket->wValue.LowByte);
    DPRINT("SetupPacket->wValue.HiByte   - %x\n", SetupPacket->wValue.HiByte);
    DPRINT("SetupPacket->wIndex.W        - %x\n", SetupPacket->wIndex.W);
    DPRINT("SetupPacket->wLength         - %x\n", SetupPacket->wLength);
}

Referenced by USBPORT_DumpingURB(), USBPORT_HandleGetConfiguration(), USBPORT_HandleGetSetDescriptor(), USBPORT_HandleGetStatus(), USBPORT_HandleSetOrClearFeature(), and USBPORT_HandleVendorOrClass().

USBPORT_DumpingTtEndpoint()

VOID NTAPI USBPORT_DumpingTtEndpoint

(

IN PUSB2_TT_ENDPOINT

TtEndpoint

)

Definition at line 300 of file debug.c.

{
    DPRINT_USB2("MaxPacketSize   - %X\n", TtEndpoint->MaxPacketSize);
    DPRINT_USB2("Period          - %X\n", TtEndpoint->Period);
    DPRINT_USB2("TtEndpointParams- %X\n", TtEndpoint->TtEndpointParams.AsULONG);
    DPRINT_USB2("CalcBusTime     - %X\n", TtEndpoint->CalcBusTime);
    DPRINT_USB2("StartTime       - %X\n", TtEndpoint->StartTime);
    DPRINT_USB2("ActualPeriod    - %X\n", TtEndpoint->ActualPeriod);
    DPRINT_USB2("StartFrame      - %X\n", TtEndpoint->StartFrame);
    DPRINT_USB2("StartMicroframe - %X\n", TtEndpoint->StartMicroframe);
    DPRINT_USB2("Nums            - %X\n", TtEndpoint->Nums.AsULONG);
    DPRINT_USB2("nextTtEndpoint  - %X\n", TtEndpoint->NextTtEndpoint);
}

Referenced by USBPORT_AllocateBandwidthUSB2().

USBPORT_DumpingURB()

VOID NTAPI USBPORT_DumpingURB

(

IN PURB

Urb

)

Definition at line 224 of file debug.c.

{
    PUSB_DEFAULT_PIPE_SETUP_PACKET SetupPacket;
 
    DPRINT_URB("UrbHeader.Length           - %x\n", Urb->UrbHeader.Length);
    DPRINT_URB("UrbHeader.Function         - %x\n", Urb->UrbHeader.Function);
    DPRINT_URB("UrbHeader.Status           - %x\n", Urb->UrbHeader.Status);
    DPRINT_URB("UrbHeader.UsbdDeviceHandle - %p\n", Urb->UrbHeader.UsbdDeviceHandle);
    DPRINT_URB("UrbHeader.UsbdFlags        - %x\n", Urb->UrbHeader.UsbdFlags);
 
    if (Urb->UrbHeader.Length < 0x48)
    {
        return;
    }
 
    DPRINT_URB("PipeHandle                - %p\n", Urb->UrbControlTransfer.PipeHandle);
    DPRINT_URB("TransferFlags             - %x\n", Urb->UrbControlTransfer.TransferFlags);
    DPRINT_URB("TransferBufferLength      - %x\n", Urb->UrbControlTransfer.TransferBufferLength);
    DPRINT_URB("TransferBuffer            - %p\n", Urb->UrbControlTransfer.TransferBuffer);
    DPRINT_URB("TransferBufferMDL         - %p\n", Urb->UrbControlTransfer.TransferBufferMDL);
    DPRINT_URB("UrbLink                   - %p\n", Urb->UrbControlTransfer.UrbLink);
 
    if (Urb->UrbHeader.Length < 0x50)
    {
        return;
    }
 
    SetupPacket = (PUSB_DEFAULT_PIPE_SETUP_PACKET)&Urb->UrbControlTransfer.SetupPacket;
    USBPORT_DumpingSetupPacket(SetupPacket);
}

Referenced by USBPORT_CompleteTransfer(), USBPORT_ValidateTransferParametersURB(), and USBPORT_ValidateURB().

USBPORT_EndpointHasQueuedTransfers()

BOOLEAN NTAPI USBPORT_EndpointHasQueuedTransfers	(	IN PDEVICE_OBJECT	FdoDevice,
		IN PUSBPORT_ENDPOINT	Endpoint,
		IN PULONG	TransferCount
	)

Definition at line 254 of file endpoint.c.

{
    PLIST_ENTRY Entry;
    PUSBPORT_TRANSFER Transfer;
    BOOLEAN Result = FALSE;
 
    DPRINT_CORE("USBPORT_EndpointHasQueuedTransfers: ... \n");
 
    KeAcquireSpinLock(&Endpoint->EndpointSpinLock, &Endpoint->EndpointOldIrql);
 
    if (!IsListEmpty(&Endpoint->PendingTransferList))
        Result = TRUE;
 
    if (!IsListEmpty(&Endpoint->TransferList))
    {
        Result = TRUE;
 
        if (TransferCount)
        {
            *TransferCount = 0;
 
            for (Entry = Endpoint->TransferList.Flink;
                 Entry && Entry != &Endpoint->TransferList;
                 Entry = Transfer->TransferLink.Flink)
            {
                Transfer = CONTAINING_RECORD(Entry,
                                             USBPORT_TRANSFER,
                                             TransferLink);
 
                if (Transfer->Flags & TRANSFER_FLAG_SUBMITED)
                {
                    ++*TransferCount;
                }
            }
        }
    }
 
    KeReleaseSpinLock(&Endpoint->EndpointSpinLock, Endpoint->EndpointOldIrql);
 
    return Result;
}

Referenced by USBPORT_DeviceHasTransfers(), and USBPORT_FlushDoneTransfers().

USBPORT_EndpointWorker()

BOOLEAN NTAPI USBPORT_EndpointWorker	(	IN PUSBPORT_ENDPOINT	Endpoint,
		IN BOOLEAN	Flag
	)

Definition at line 1656 of file endpoint.c.

{
    PDEVICE_OBJECT FdoDevice;
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    PUSBPORT_REGISTRATION_PACKET Packet;
    ULONG EndpointState;
 
    DPRINT_CORE("USBPORT_EndpointWorker: Endpoint - %p, LockNotChecked - %x\n",
           Endpoint,
           LockNotChecked);
 
    FdoDevice = Endpoint->FdoDevice;
    FdoExtension = FdoDevice->DeviceExtension;
    Packet = &FdoExtension->MiniPortInterface->Packet;
 
    if (LockNotChecked == FALSE)
    {
        if (InterlockedIncrement(&Endpoint->LockCounter))
        {
            InterlockedDecrement(&Endpoint->LockCounter);
            DPRINT_CORE("USBPORT_EndpointWorker: LockCounter > 0\n");
            return TRUE;
        }
    }
 
    ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
 
    KeAcquireSpinLockAtDpcLevel(&Endpoint->EndpointSpinLock);
 
    if (USBPORT_GetEndpointState(Endpoint) == USBPORT_ENDPOINT_CLOSED)
    {
        KeReleaseSpinLockFromDpcLevel(&Endpoint->EndpointSpinLock);
        InterlockedDecrement(&Endpoint->LockCounter);
        DPRINT_CORE("USBPORT_EndpointWorker: State == USBPORT_ENDPOINT_CLOSED. return FALSE\n");
        return FALSE;
    }
 
    if ((Endpoint->Flags & (ENDPOINT_FLAG_ROOTHUB_EP0 | ENDPOINT_FLAG_NUKE)) == 0)
    {
        KeAcquireSpinLockAtDpcLevel(&FdoExtension->MiniportSpinLock);
        Packet->PollEndpoint(FdoExtension->MiniPortExt, Endpoint + 1);
        KeReleaseSpinLockFromDpcLevel(&FdoExtension->MiniportSpinLock);
    }
 
    EndpointState = USBPORT_GetEndpointState(Endpoint);
 
    if (EndpointState == USBPORT_ENDPOINT_REMOVE)
    {
        KeAcquireSpinLockAtDpcLevel(&Endpoint->StateChangeSpinLock);
        Endpoint->StateLast = USBPORT_ENDPOINT_CLOSED;
        Endpoint->StateNext = USBPORT_ENDPOINT_CLOSED;
        KeReleaseSpinLockFromDpcLevel(&Endpoint->StateChangeSpinLock);
 
        KeReleaseSpinLockFromDpcLevel(&Endpoint->EndpointSpinLock);
 
        KeAcquireSpinLockAtDpcLevel(&FdoExtension->EndpointListSpinLock);
 
        ExInterlockedInsertTailList(&FdoExtension->EndpointClosedList,
                                    &Endpoint->CloseLink,
                                    &FdoExtension->EndpointClosedSpinLock);
 
        KeReleaseSpinLockFromDpcLevel(&FdoExtension->EndpointListSpinLock);
 
        InterlockedDecrement(&Endpoint->LockCounter);
        DPRINT_CORE("USBPORT_EndpointWorker: State == USBPORT_ENDPOINT_REMOVE. return FALSE\n");
        return FALSE;
    }
 
    if (!IsListEmpty(&Endpoint->PendingTransferList) ||
        !IsListEmpty(&Endpoint->TransferList) ||
        !IsListEmpty(&Endpoint->CancelList))
    {
        KeReleaseSpinLockFromDpcLevel(&Endpoint->EndpointSpinLock);
 
        EndpointState = USBPORT_GetEndpointState(Endpoint);
 
        KeAcquireSpinLockAtDpcLevel(&Endpoint->StateChangeSpinLock);
        if (EndpointState == Endpoint->StateNext)
        {
            KeReleaseSpinLockFromDpcLevel(&Endpoint->StateChangeSpinLock);
 
            if (Endpoint->EndpointWorker)
            {
                USBPORT_DmaEndpointWorker(Endpoint);
            }
            else
            {
                USBPORT_RootHubEndpointWorker(Endpoint);
            }
 
            USBPORT_FlushAbortList(Endpoint);
 
            InterlockedDecrement(&Endpoint->LockCounter);
            DPRINT_CORE("USBPORT_EndpointWorker: return FALSE\n");
            return FALSE;
        }
 
        KeReleaseSpinLockFromDpcLevel(&Endpoint->StateChangeSpinLock);
        InterlockedDecrement(&Endpoint->LockCounter);
 
        DPRINT_CORE("USBPORT_EndpointWorker: return TRUE\n");
        return TRUE;
    }
 
    KeReleaseSpinLockFromDpcLevel(&Endpoint->EndpointSpinLock);
 
    USBPORT_FlushAbortList(Endpoint);
 
    InterlockedDecrement(&Endpoint->LockCounter);
    DPRINT_CORE("USBPORT_EndpointWorker: return FALSE\n");
    return FALSE;
}

Referenced by USBPORT_DpcHandler(), USBPORT_FlushPendingTransfers(), USBPORT_MapTransfer(), and USBPORT_WorkerThreadHandler().

USBPORT_FdoDeviceControl()

NTSTATUS NTAPI USBPORT_FdoDeviceControl	(	PDEVICE_OBJECT	FdoDevice,
		PIRP	Irp
	)

USBPORT_FdoInternalDeviceControl()

NTSTATUS NTAPI USBPORT_FdoInternalDeviceControl	(	IN PDEVICE_OBJECT	FdoDevice,
		IN PIRP	Irp
	)

Definition at line 454 of file ioctl.c.

{
    DPRINT1("USBPORT_FdoInternalDeviceControl: UNIMPLEMENTED. FIXME. \n");
    return 0;
}

Referenced by USBPORT_Dispatch().

USBPORT_FdoPnP()

NTSTATUS NTAPI USBPORT_FdoPnP	(	IN PDEVICE_OBJECT	FdoDevice,
		IN PIRP	Irp
	)

Definition at line 1110 of file pnp.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    PUSBPORT_COMMON_DEVICE_EXTENSION FdoCommonExtension;
    PUSBPORT_REGISTRATION_PACKET Packet;
    PUSBPORT_RESOURCES UsbPortResources;
    PIO_STACK_LOCATION IoStack;
    UCHAR Minor;
    KEVENT Event;
    NTSTATUS Status;
    DEVICE_RELATION_TYPE RelationType;
    PDEVICE_RELATIONS DeviceRelations;
    PDEVICE_OBJECT RootHubPdo;
 
    FdoExtension = FdoDevice->DeviceExtension;
    FdoCommonExtension = &FdoExtension->CommonExtension;
    UsbPortResources = &FdoExtension->UsbPortResources;
    Packet = &FdoExtension->MiniPortInterface->Packet;
 
    IoStack = IoGetCurrentIrpStackLocation(Irp);
    Minor = IoStack->MinorFunction;
 
    DPRINT("USBPORT_FdoPnP: FdoDevice - %p, Minor - %x\n", FdoDevice, Minor);
 
    RelationType = IoStack->Parameters.QueryDeviceRelations.Type;
 
    switch (Minor)
    {
        case IRP_MN_START_DEVICE:
            DPRINT("IRP_MN_START_DEVICE\n");
 
            KeInitializeEvent(&Event, NotificationEvent, FALSE);
 
            IoCopyCurrentIrpStackLocationToNext(Irp);
 
            IoSetCompletionRoutine(Irp,
                                   USBPORT_FdoStartCompletion,
                                   &Event,
                                   TRUE,
                                   TRUE,
                                   TRUE);
 
            Status = IoCallDriver(FdoCommonExtension->LowerDevice,
                                  Irp);
 
            if (Status == STATUS_PENDING)
            {
                KeWaitForSingleObject(&Event,
                                      Suspended,
                                      KernelMode,
                                      FALSE,
                                      NULL);
 
                Status = Irp->IoStatus.Status;
            }
 
            if (!NT_SUCCESS(Status))
            {
                goto Exit;
            }
 
            Status = USBPORT_ParseResources(FdoDevice,
                                            Irp,
                                            UsbPortResources);
 
            if (!NT_SUCCESS(Status))
            {
                FdoCommonExtension->PnpStateFlags |= USBPORT_PNP_STATE_STOPPED;
                goto Exit;
            }
 
            Status = USBPORT_StartDevice(FdoDevice, UsbPortResources);
 
            if (!NT_SUCCESS(Status))
            {
                FdoCommonExtension->PnpStateFlags |= USBPORT_PNP_STATE_STOPPED;
                goto Exit;
            }
 
            FdoCommonExtension->PnpStateFlags &= ~USBPORT_PNP_STATE_NOT_INIT;
            FdoCommonExtension->PnpStateFlags |= USBPORT_PNP_STATE_STARTED;
 
            FdoCommonExtension->DevicePowerState = PowerDeviceD0;
 
            if (Packet->MiniPortFlags & USB_MINIPORT_FLAGS_USB2)
            {
                USBPORT_AddUSB2Fdo(FdoDevice);
            }
            else
            {
                USBPORT_AddUSB1Fdo(FdoDevice);
            }
 
Exit:
            Irp->IoStatus.Status = Status;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
            return Status;
 
        case IRP_MN_QUERY_REMOVE_DEVICE:
            DPRINT("IRP_MN_QUERY_REMOVE_DEVICE\n");
            if (Packet->MiniPortFlags & USB_MINIPORT_FLAGS_USB2)
            {
                DPRINT1("USBPORT_FdoPnP: Haction registry write FIXME\n");
            }
 
            Irp->IoStatus.Status = STATUS_SUCCESS;
            goto ForwardIrp;
 
        case IRP_MN_REMOVE_DEVICE:
            DPRINT("USBPORT_FdoPnP: IRP_MN_REMOVE_DEVICE\n");
            FdoCommonExtension->PnpStateFlags |= USBPORT_PNP_STATE_FAILED;
 
            if (FdoCommonExtension->PnpStateFlags & USBPORT_PNP_STATE_STARTED &&
               !(FdoCommonExtension->PnpStateFlags & USBPORT_PNP_STATE_NOT_INIT))
            {
                DPRINT1("USBPORT_FdoPnP: stop fdo FIXME\n");
                FdoCommonExtension->PnpStateFlags |= USBPORT_PNP_STATE_NOT_INIT;
            }
 
            Irp->IoStatus.Status = STATUS_SUCCESS;
            IoSkipCurrentIrpStackLocation(Irp);
            Status = IoCallDriver(FdoCommonExtension->LowerDevice, Irp);
 
            IoDetachDevice(FdoCommonExtension->LowerDevice);
 
            RootHubPdo = FdoExtension->RootHubPdo;
 
            IoDeleteDevice(FdoDevice);
 
            if (RootHubPdo)
            {
                IoDeleteDevice(RootHubPdo);
            }
 
            return Status;
 
        case IRP_MN_CANCEL_REMOVE_DEVICE:
            DPRINT("IRP_MN_CANCEL_REMOVE_DEVICE\n");
            Irp->IoStatus.Status = STATUS_SUCCESS;
            goto ForwardIrp;
 
        case IRP_MN_STOP_DEVICE:
            DPRINT("IRP_MN_STOP_DEVICE\n");
            if (FdoCommonExtension->PnpStateFlags & USBPORT_PNP_STATE_STARTED)
            {
                DPRINT1("USBPORT_FdoPnP: stop fdo FIXME\n");
 
                FdoCommonExtension->PnpStateFlags &= ~USBPORT_PNP_STATE_STARTED;
                FdoCommonExtension->PnpStateFlags |= USBPORT_PNP_STATE_NOT_INIT;
            }
 
            Irp->IoStatus.Status = STATUS_SUCCESS;
            goto ForwardIrp;
 
        case IRP_MN_QUERY_STOP_DEVICE:
            DPRINT("IRP_MN_QUERY_STOP_DEVICE\n");
            Irp->IoStatus.Status = STATUS_SUCCESS;
            goto ForwardIrp;
 
        case IRP_MN_CANCEL_STOP_DEVICE:
            DPRINT("IRP_MN_CANCEL_STOP_DEVICE\n");
            Irp->IoStatus.Status = STATUS_SUCCESS;
            goto ForwardIrp;
 
        case IRP_MN_QUERY_DEVICE_RELATIONS:
            DPRINT("IRP_MN_QUERY_DEVICE_RELATIONS\n");
            if (RelationType == BusRelations)
            {
                DeviceRelations = ExAllocatePoolWithTag(PagedPool,
                                                        sizeof(DEVICE_RELATIONS),
                                                        USB_PORT_TAG);
 
                if (!DeviceRelations)
                {
                    Status = STATUS_INSUFFICIENT_RESOURCES;
                    Irp->IoStatus.Status = Status;
                    IoCompleteRequest(Irp, IO_NO_INCREMENT);
                    return Status;
                }
 
                DeviceRelations->Count = 0;
                DeviceRelations->Objects[0] = NULL;
 
                if (!FdoExtension->RootHubPdo)
                {
                    Status = USBPORT_CreatePdo(FdoDevice,
                                               &FdoExtension->RootHubPdo);
 
                    if (!NT_SUCCESS(Status))
                    {
                        ExFreePoolWithTag(DeviceRelations, USB_PORT_TAG);
                        goto ForwardIrp;
                    }
                }
                else
                {
                    Status = STATUS_SUCCESS;
                }
 
                DeviceRelations->Count = 1;
                DeviceRelations->Objects[0] = FdoExtension->RootHubPdo;
 
                ObReferenceObject(FdoExtension->RootHubPdo);
                Irp->IoStatus.Information = (ULONG_PTR)DeviceRelations;
            }
            else
            {
                if (RelationType == RemovalRelations)
                {
                    DPRINT1("USBPORT_FdoPnP: FIXME IRP_MN_QUERY_DEVICE_RELATIONS/RemovalRelations\n");
                }
 
                goto ForwardIrp;
            }
 
            Irp->IoStatus.Status = Status;
            goto ForwardIrp;
 
        case IRP_MN_QUERY_INTERFACE:
            DPRINT("IRP_MN_QUERY_INTERFACE\n");
            goto ForwardIrp;
 
        case IRP_MN_QUERY_CAPABILITIES:
            DPRINT("IRP_MN_QUERY_CAPABILITIES\n");
            goto ForwardIrp;
 
        case IRP_MN_QUERY_RESOURCES:
            DPRINT("IRP_MN_QUERY_RESOURCES\n");
            goto ForwardIrp;
 
        case IRP_MN_QUERY_RESOURCE_REQUIREMENTS:
            DPRINT("IRP_MN_QUERY_RESOURCE_REQUIREMENTS\n");
            goto ForwardIrp;
 
        case IRP_MN_QUERY_DEVICE_TEXT:
            DPRINT("IRP_MN_QUERY_DEVICE_TEXT\n");
            goto ForwardIrp;
 
        case IRP_MN_FILTER_RESOURCE_REQUIREMENTS:
            DPRINT("IRP_MN_FILTER_RESOURCE_REQUIREMENTS\n");
            goto ForwardIrp;
 
        case IRP_MN_READ_CONFIG:
            DPRINT("IRP_MN_READ_CONFIG\n");
            goto ForwardIrp;
 
        case IRP_MN_WRITE_CONFIG:
            DPRINT("IRP_MN_WRITE_CONFIG\n");
            goto ForwardIrp;
 
        case IRP_MN_EJECT:
            DPRINT("IRP_MN_EJECT\n");
            goto ForwardIrp;
 
        case IRP_MN_SET_LOCK:
            DPRINT("IRP_MN_SET_LOCK\n");
            goto ForwardIrp;
 
        case IRP_MN_QUERY_ID:
            DPRINT("IRP_MN_QUERY_ID\n");
            goto ForwardIrp;
 
        case IRP_MN_QUERY_PNP_DEVICE_STATE:
            DPRINT("IRP_MN_QUERY_PNP_DEVICE_STATE\n");
            goto ForwardIrp;
 
        case IRP_MN_QUERY_BUS_INFORMATION:
            DPRINT("IRP_MN_QUERY_BUS_INFORMATION\n");
            goto ForwardIrp;
 
        case IRP_MN_DEVICE_USAGE_NOTIFICATION:
            DPRINT("IRP_MN_DEVICE_USAGE_NOTIFICATION\n");
            goto ForwardIrp;
 
        case IRP_MN_SURPRISE_REMOVAL:
            DPRINT1("IRP_MN_SURPRISE_REMOVAL\n");
            if (!(FdoCommonExtension->PnpStateFlags & USBPORT_PNP_STATE_FAILED))
            {
                USBPORT_InvalidateControllerHandler(FdoDevice,
                                                    USBPORT_INVALIDATE_CONTROLLER_SURPRISE_REMOVE);
            }
            goto ForwardIrp;
 
        default:
            DPRINT("unknown IRP_MN_???\n");
ForwardIrp:
            /* forward irp to next device object */
            IoSkipCurrentIrpStackLocation(Irp);
            break;
    }
 
    return IoCallDriver(FdoCommonExtension->LowerDevice, Irp);
}

Referenced by USBPORT_Dispatch().

USBPORT_FdoPower()

NTSTATUS NTAPI USBPORT_FdoPower	(	IN PDEVICE_OBJECT	FdoDevice,
		IN PIRP	Irp
	)

Definition at line 489 of file power.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    PIO_STACK_LOCATION IoStack;
    NTSTATUS Status;
 
    DPRINT("USBPORT_FdoPower: ... \n");
 
    FdoExtension = FdoDevice->DeviceExtension;
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    switch (IoStack->MinorFunction)
    {
      case IRP_MN_WAIT_WAKE:
          DPRINT("USBPORT_FdoPower: IRP_MN_WAIT_WAKE\n");
          Status = USBPORT_HcWake(FdoDevice, Irp);
          return Status;
 
      case IRP_MN_POWER_SEQUENCE:
          DPRINT("USBPORT_FdoPower: IRP_MN_POWER_SEQUENCE\n");
          break;
 
      case IRP_MN_SET_POWER:
          DPRINT("USBPORT_FdoPower: IRP_MN_SET_POWER\n");
          if (IoStack->Parameters.Power.Type == DevicePowerState)
          {
              Status = USBPORT_DevicePowerState(FdoDevice, Irp);
          }
          else
          {
              Status = USBPORT_SystemPowerState(FdoDevice, Irp);
          }
 
          if (Status != STATUS_PENDING)
              break;
 
          return Status;
 
      case IRP_MN_QUERY_POWER:
          DPRINT("USBPORT_FdoPower: IRP_MN_QUERY_POWER\n");
          Irp->IoStatus.Status = STATUS_SUCCESS;
          break;
 
      default:
          DPRINT1("USBPORT_FdoPower: unknown IRP_MN_POWER!\n");
          break;
    }
 
    IoCopyCurrentIrpStackLocationToNext(Irp);
    PoStartNextPowerIrp(Irp);
    return PoCallDriver(FdoExtension->CommonExtension.LowerDevice, Irp);
}

Referenced by USBPORT_Dispatch().

USBPORT_FindCompanionControllers()

PDEVICE_RELATIONS NTAPI USBPORT_FindCompanionControllers	(	IN PDEVICE_OBJECT	USB2FdoDevice,
		IN BOOLEAN	IsObRefer,
		IN BOOLEAN	IsFDOsReturned
	)

Definition at line 136 of file usbport.c.

{
    PLIST_ENTRY USB1FdoList;
    PUSBPORT_DEVICE_EXTENSION USB1FdoExtension;
    ULONG NumControllers = 0;
    PDEVICE_OBJECT * Entry;
    PDEVICE_RELATIONS ControllersList = NULL;
    KIRQL OldIrql;
 
    DPRINT("USBPORT_FindCompanionControllers: USB2Fdo - %p, IsObRefer - %x, IsFDOs - %x\n",
           USB2FdoDevice,
           IsObRefer,
           IsFDOsReturned);
 
    KeAcquireSpinLock(&USBPORT_SpinLock, &OldIrql);
 
    USB1FdoList = USBPORT_USB1FdoList.Flink;
 
    while (USB1FdoList && USB1FdoList != &USBPORT_USB1FdoList)
    {
        USB1FdoExtension = CONTAINING_RECORD(USB1FdoList,
                                             USBPORT_DEVICE_EXTENSION,
                                             ControllerLink);
 
        if (USB1FdoExtension->Flags & USBPORT_FLAG_COMPANION_HC &&
            USBPORT_IsCompanionFdoExtension(USB2FdoDevice, USB1FdoExtension))
        {
            ++NumControllers;
        }
 
        USB1FdoList = USB1FdoExtension->ControllerLink.Flink;
    }
 
    DPRINT("USBPORT_FindCompanionControllers: NumControllers - %x\n",
           NumControllers);
 
    if (!NumControllers)
    {
        goto Exit;
    }
 
    ControllersList = ExAllocatePoolWithTag(NonPagedPool,
                                            NumControllers * sizeof(DEVICE_RELATIONS),
                                            USB_PORT_TAG);
 
    if (!ControllersList)
    {
        goto Exit;
    }
 
    RtlZeroMemory(ControllersList, NumControllers * sizeof(DEVICE_RELATIONS));
 
    ControllersList->Count = NumControllers;
 
    USB1FdoList = USBPORT_USB1FdoList.Flink;
 
    Entry = &ControllersList->Objects[0];
 
    while (USB1FdoList && USB1FdoList != &USBPORT_USB1FdoList)
    {
        USB1FdoExtension = CONTAINING_RECORD(USB1FdoList,
                                             USBPORT_DEVICE_EXTENSION,
                                             ControllerLink);
 
        if (USB1FdoExtension->Flags & USBPORT_FLAG_COMPANION_HC &&
            USBPORT_IsCompanionFdoExtension(USB2FdoDevice, USB1FdoExtension))
        {
            *Entry = USB1FdoExtension->CommonExtension.LowerPdoDevice;
 
            if (IsObRefer)
            {
                ObReferenceObject(USB1FdoExtension->CommonExtension.LowerPdoDevice);
            }
 
            if (IsFDOsReturned)
            {
                *Entry = USB1FdoExtension->CommonExtension.SelfDevice;
            }
 
            ++Entry;
        }
 
        USB1FdoList = USB1FdoExtension->ControllerLink.Flink;
    }
 
Exit:
 
    KeReleaseSpinLock(&USBPORT_SpinLock, OldIrql);
 
    return ControllersList;
}

Referenced by USBPORT_RH_SetFeatureUSB2PortPower(), USBPORT_RootHubPowerAndChirpAllCcPorts(), and USBPORT_SynchronizeRootHubCallback().

USBPORT_FindUrbInIrpTable()

VOID NTAPI USBPORT_FindUrbInIrpTable	(	IN PUSBPORT_IRP_TABLE	IrpTable,
		IN PURB	Urb,
		IN PIRP	Irp
	)

Definition at line 381 of file queue.c.

{
    ULONG ix;
    PIRP irp;
    PURB urbIn;
 
    DPRINT_CORE("USBPORT_FindUrbInIrpTable: IrpTable - %p, Urb - %p, Irp - %p\n",
                IrpTable,
                Urb,
                Irp);
 
    ASSERT(IrpTable != NULL);
 
    do
    {
        for (ix = 0; ix < 0x200; ix++)
        {
            irp = IrpTable->irp[ix];
 
            if (irp)
            {
                urbIn = URB_FROM_IRP(irp);
 
                if (urbIn == Urb)
                {
                    if (irp == Irp)
                    {
                        KeBugCheckEx(BUGCODE_USB_DRIVER,
                                     4,
                                     (ULONG_PTR)irp,
                                     (ULONG_PTR)urbIn,
                                     0);
                    }
 
                    KeBugCheckEx(BUGCODE_USB_DRIVER,
                                 2,
                                 (ULONG_PTR)irp,
                                 (ULONG_PTR)Irp,
                                 (ULONG_PTR)urbIn);
                }
            }
        }
 
        IrpTable = IrpTable->LinkNextTable;
    }
    while (IrpTable);
}

Referenced by USBPORT_FlushPendingTransfers().

USBPORT_FindUSB2Controller()

PDEVICE_OBJECT NTAPI USBPORT_FindUSB2Controller

(

IN PDEVICE_OBJECT

FdoDevice

)

Definition at line 27 of file usbport.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    PUSBPORT_DEVICE_EXTENSION USB2FdoExtension;
    KIRQL OldIrql;
    PLIST_ENTRY USB2FdoEntry;
    PDEVICE_OBJECT USB2FdoDevice = NULL;
 
    DPRINT("USBPORT_FindUSB2Controller: FdoDevice - %p\n", FdoDevice);
 
    FdoExtension = FdoDevice->DeviceExtension;
 
    KeAcquireSpinLock(&USBPORT_SpinLock, &OldIrql);
 
    USB2FdoEntry = USBPORT_USB2FdoList.Flink;
 
    while (USB2FdoEntry && USB2FdoEntry != &USBPORT_USB2FdoList)
    {
        USB2FdoExtension = CONTAINING_RECORD(USB2FdoEntry,
                                             USBPORT_DEVICE_EXTENSION,
                                             ControllerLink);
 
        if (USB2FdoExtension->BusNumber == FdoExtension->BusNumber &&
            USB2FdoExtension->PciDeviceNumber == FdoExtension->PciDeviceNumber)
        {
            USB2FdoDevice = USB2FdoExtension->CommonExtension.SelfDevice;
            break;
        }
 
        USB2FdoEntry = USB2FdoEntry->Flink;
    }
 
    KeReleaseSpinLock(&USBPORT_SpinLock, OldIrql);
 
    return USB2FdoDevice;
}

Referenced by USBHI_GetExtendedHubInformation(), USBPORT_SynchronizeControllersStart(), and USBPORT_WorkerThread().

USBPORT_FlushAbortList()

VOID NTAPI USBPORT_FlushAbortList

(

IN PUSBPORT_ENDPOINT

Endpoint

)

Definition at line 605 of file queue.c.

{
    PLIST_ENTRY Entry;
    PUSBPORT_TRANSFER Transfer;
    PLIST_ENTRY AbortList;
    LIST_ENTRY List;
    NTSTATUS Status;
    PIRP Irp;
    PURB Urb;
    PUSBPORT_DEVICE_HANDLE DeviceHandle = NULL;
 
    DPRINT_CORE("USBPORT_FlushAbortList: Endpoint - %p\n", Endpoint);
 
    InitializeListHead(&List);
 
    KeAcquireSpinLock(&Endpoint->EndpointSpinLock, &Endpoint->EndpointOldIrql);
 
    if (IsListEmpty(&Endpoint->AbortList))
    {
        KeReleaseSpinLock(&Endpoint->EndpointSpinLock,
                          Endpoint->EndpointOldIrql);
        return;
    }
 
    Entry = Endpoint->PendingTransferList.Flink;
 
    while (Entry && Entry != &Endpoint->PendingTransferList)
    {
        Transfer = CONTAINING_RECORD(Entry,
                                     USBPORT_TRANSFER,
                                     TransferLink);
 
        if (Transfer->Flags & TRANSFER_FLAG_ABORTED)
        {
            DPRINT_CORE("USBPORT_FlushAbortList: Aborted PendingTransfer  - %p\n",
                        Transfer);
 
            KeReleaseSpinLock(&Endpoint->EndpointSpinLock,
                              Endpoint->EndpointOldIrql);
            return;
        }
 
        Entry = Transfer->TransferLink.Flink;
    }
 
    Entry = Endpoint->TransferList.Flink;
 
    while (Entry && Entry != &Endpoint->TransferList)
    {
        Transfer = CONTAINING_RECORD(Entry,
                                     USBPORT_TRANSFER,
                                     TransferLink);
 
        if (Transfer->Flags & TRANSFER_FLAG_ABORTED)
        {
            DPRINT_CORE("USBPORT_FlushAbortList: Aborted ActiveTransfer - %p\n",
                        Transfer);
 
            KeReleaseSpinLock(&Endpoint->EndpointSpinLock,
                              Endpoint->EndpointOldIrql);
            return;
        }
 
        Entry = Transfer->TransferLink.Flink;
    }
 
    AbortList = &Endpoint->AbortList;
 
    while (!IsListEmpty(AbortList))
    {
        //DbgBreakPoint();
 
        Irp = CONTAINING_RECORD(AbortList->Flink,
                                IRP,
                                Tail.Overlay.ListEntry);
 
        RemoveHeadList(AbortList);
        InsertTailList(&List, &Irp->Tail.Overlay.ListEntry);
    }
 
    KeReleaseSpinLock(&Endpoint->EndpointSpinLock, Endpoint->EndpointOldIrql);
 
    while (!IsListEmpty(&List))
    {
        //DbgBreakPoint();
 
        Irp = CONTAINING_RECORD(List.Flink,
                                IRP,
                                Tail.Overlay.ListEntry);
 
        RemoveHeadList(&List);
 
        Urb = URB_FROM_IRP(Irp);
 
        DeviceHandle = Urb->UrbHeader.UsbdDeviceHandle;
        InterlockedDecrement(&DeviceHandle->DeviceHandleLock);
 
        Status = USBPORT_USBDStatusToNtStatus(Urb, USBD_STATUS_SUCCESS);
 
        DPRINT_CORE("USBPORT_FlushAbortList: complete Irp - %p\n", Irp);
 
        Irp->IoStatus.Status = Status;
        Irp->IoStatus.Information = 0;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
    }
}

Referenced by USBPORT_EndpointWorker(), and USBPORT_FlushCancelList().

USBPORT_FlushAllEndpoints()

VOID NTAPI USBPORT_FlushAllEndpoints

(

IN PDEVICE_OBJECT

FdoDevice

)

Definition at line 1171 of file queue.c.

{
    PUSBPORT_DEVICE_EXTENSION  FdoExtension;
    PLIST_ENTRY Entry;
    PUSBPORT_ENDPOINT Endpoint;
    LIST_ENTRY List;
    KIRQL OldIrql;
 
    DPRINT_CORE("USBPORT_FlushAllEndpoints: ... \n");
 
    FdoExtension = FdoDevice->DeviceExtension;
 
    KeAcquireSpinLock(&FdoExtension->EndpointListSpinLock, &OldIrql);
 
    InitializeListHead(&List);
 
    Entry = FdoExtension->EndpointList.Flink;
 
    while (Entry && Entry != &FdoExtension->EndpointList)
    {
        Endpoint = CONTAINING_RECORD(Entry,
                                     USBPORT_ENDPOINT,
                                     EndpointLink);
 
        if (USBPORT_GetEndpointState(Endpoint) != USBPORT_ENDPOINT_CLOSED)
        {
            InsertTailList(&List, &Endpoint->FlushLink);
        }
 
        Entry = Endpoint->EndpointLink.Flink;
    }
 
    KeReleaseSpinLock(&FdoExtension->EndpointListSpinLock, OldIrql);
 
    while (!IsListEmpty(&List))
    {
        Endpoint = CONTAINING_RECORD(List.Flink,
                                     USBPORT_ENDPOINT,
                                     FlushLink);
 
        RemoveHeadList(&List);
 
        Endpoint->FlushLink.Flink = NULL;
        Endpoint->FlushLink.Blink = NULL;
 
        if (!IsListEmpty(&Endpoint->PendingTransferList))
        {
            USBPORT_FlushPendingTransfers(Endpoint);
        }
    }
 
    DPRINT_CORE("USBPORT_FlushAllEndpoints: exit\n");
}

Referenced by USBPORT_WorkerThreadHandler().

USBPORT_FlushCancelList()

VOID NTAPI USBPORT_FlushCancelList

(

IN PUSBPORT_ENDPOINT

Endpoint

)

Definition at line 714 of file queue.c.

{
    PDEVICE_OBJECT FdoDevice;
    PUSBPORT_DEVICE_EXTENSION  FdoExtension;
    PUSBPORT_TRANSFER Transfer;
    PIRP Irp;
    KIRQL OldIrql;
    KIRQL PrevIrql;
 
    DPRINT_CORE("USBPORT_FlushCancelList: ... \n");
 
    FdoDevice = Endpoint->FdoDevice;
    FdoExtension = FdoDevice->DeviceExtension;
 
    KeAcquireSpinLock(&FdoExtension->FlushTransferSpinLock, &OldIrql);
    KeAcquireSpinLockAtDpcLevel(&Endpoint->EndpointSpinLock);
 
    while (!IsListEmpty(&Endpoint->CancelList))
    {
        Transfer = CONTAINING_RECORD(Endpoint->CancelList.Flink,
                                     USBPORT_TRANSFER,
                                     TransferLink);
 
        RemoveHeadList(&Endpoint->CancelList);
 
        Irp = Transfer->Irp;
 
        if (Irp)
        {
            DPRINT("USBPORT_FlushCancelList: Irp - %p\n", Irp);
 
            IoAcquireCancelSpinLock(&PrevIrql);
            IoSetCancelRoutine(Irp, NULL);
            IoReleaseCancelSpinLock(PrevIrql);
 
            USBPORT_RemoveActiveTransferIrp(FdoDevice, Irp);
        }
 
        KeReleaseSpinLockFromDpcLevel(&Endpoint->EndpointSpinLock);
        KeReleaseSpinLock(&FdoExtension->FlushTransferSpinLock, OldIrql);
 
        if (Endpoint->Flags & ENDPOINT_FLAG_NUKE)
        {
            USBPORT_CompleteTransfer(Transfer->Urb, USBD_STATUS_DEVICE_GONE);
        }
        else
        {
            if (Transfer->Flags & TRANSFER_FLAG_DEVICE_GONE)
            {
                USBPORT_CompleteTransfer(Transfer->Urb,
                                         USBD_STATUS_DEVICE_GONE);
            }
            else
            {
                USBPORT_CompleteTransfer(Transfer->Urb,
                                         USBD_STATUS_CANCELED);
            }
        }
 
        KeAcquireSpinLock(&FdoExtension->FlushTransferSpinLock, &OldIrql);
        KeAcquireSpinLockAtDpcLevel(&Endpoint->EndpointSpinLock);
    }
 
    KeReleaseSpinLockFromDpcLevel(&Endpoint->EndpointSpinLock);
    KeReleaseSpinLock(&FdoExtension->FlushTransferSpinLock, OldIrql);
 
    USBPORT_FlushAbortList(Endpoint);
}

Referenced by USBPORT_AbortEndpoint(), USBPORT_DmaEndpointWorker(), USBPORT_KillEndpointActiveTransfers(), and USBPORT_RootHubEndpointWorker().

USBPORT_FlushClosedEndpointList()

VOID NTAPI USBPORT_FlushClosedEndpointList

(

IN PDEVICE_OBJECT

FdoDevice

)

Definition at line 1281 of file endpoint.c.

{
    PUSBPORT_DEVICE_EXTENSION  FdoExtension;
    KIRQL OldIrql;
    PLIST_ENTRY ClosedList;
    PUSBPORT_ENDPOINT Endpoint;
 
    DPRINT_CORE("USBPORT_FlushClosedEndpointList: ... \n");
 
    FdoExtension = FdoDevice->DeviceExtension;
 
    KeAcquireSpinLock(&FdoExtension->EndpointClosedSpinLock, &OldIrql);
    ClosedList = &FdoExtension->EndpointClosedList;
 
    while (!IsListEmpty(ClosedList))
    {
        Endpoint = CONTAINING_RECORD(ClosedList->Flink,
                                     USBPORT_ENDPOINT,
                                     CloseLink);
 
        RemoveHeadList(ClosedList);
        Endpoint->CloseLink.Flink = NULL;
        Endpoint->CloseLink.Blink = NULL;
 
        KeReleaseSpinLock(&FdoExtension->EndpointClosedSpinLock, OldIrql);
 
        USBPORT_DeleteEndpoint(FdoDevice, Endpoint);
 
        KeAcquireSpinLock(&FdoExtension->EndpointClosedSpinLock, &OldIrql);
    }
 
    KeReleaseSpinLock(&FdoExtension->EndpointClosedSpinLock, OldIrql);
}

Referenced by USBPORT_WorkerThreadHandler().

USBPORT_FlushController()

VOID NTAPI USBPORT_FlushController

(

IN PDEVICE_OBJECT

FdoDevice

)

Definition at line 1259 of file queue.c.

{
    PUSBPORT_DEVICE_EXTENSION  FdoExtension;
    PLIST_ENTRY Entry;
    PUSBPORT_ENDPOINT Endpoint;
    ULONG KilledTransfers;
    PLIST_ENTRY EndpointList;
    KIRQL OldIrql;
    LIST_ENTRY FlushList;
 
    DPRINT_CORE("USBPORT_FlushController \n");
 
    FdoExtension = FdoDevice->DeviceExtension;
 
    EndpointList = &FdoExtension->EndpointList;
 
    while (TRUE)
    {
        KeAcquireSpinLock(&FdoExtension->EndpointListSpinLock, &OldIrql);
 
        InitializeListHead(&FlushList);
 
        Entry = EndpointList->Flink;
 
        if (!IsListEmpty(EndpointList))
        {
            while (Entry && Entry != EndpointList)
            {
                Endpoint = CONTAINING_RECORD(Entry,
                                             USBPORT_ENDPOINT,
                                             EndpointLink);
 
                if (Endpoint->StateLast != USBPORT_ENDPOINT_REMOVE &&
                    Endpoint->StateLast != USBPORT_ENDPOINT_CLOSED)
                {
                    InterlockedIncrement(&Endpoint->LockCounter);
                    InsertTailList(&FlushList, &Endpoint->FlushControllerLink);
                }
 
                Entry = Endpoint->EndpointLink.Flink;
            }
        }
 
        KeReleaseSpinLock(&FdoExtension->EndpointListSpinLock, OldIrql);
 
        KilledTransfers = 0;
        while (!IsListEmpty(&FlushList))
        {
            Endpoint = CONTAINING_RECORD(FlushList.Flink,
                                         USBPORT_ENDPOINT,
                                         FlushControllerLink);
 
            RemoveHeadList(&FlushList);
 
            KilledTransfers += USBPORT_KillEndpointActiveTransfers(FdoDevice,
                                                                   Endpoint);
 
            InterlockedDecrement(&Endpoint->LockCounter);
        }
 
        if (!KilledTransfers)
            break;
 
        USBPORT_Wait(FdoDevice, 100);
    }
}

Referenced by USBPORT_SuspendController().

USBPORT_FlushMapTransfers()

VOID NTAPI USBPORT_FlushMapTransfers

(

IN PDEVICE_OBJECT

FdoDevice

)

Definition at line 2483 of file usbport.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    PLIST_ENTRY MapTransferList;
    PUSBPORT_TRANSFER Transfer;
    ULONG NumMapRegisters;
    PMDL Mdl;
    SIZE_T TransferBufferLength;
    ULONG_PTR VirtualAddr;
    KIRQL OldIrql;
    NTSTATUS Status;
    PDMA_OPERATIONS DmaOperations;
 
    DPRINT_CORE("USBPORT_FlushMapTransfers: ...\n");
 
    FdoExtension = FdoDevice->DeviceExtension;
    DmaOperations = FdoExtension->DmaAdapter->DmaOperations;
 
    KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
 
    while (TRUE)
    {
        MapTransferList = &FdoExtension->MapTransferList;
 
        if (IsListEmpty(&FdoExtension->MapTransferList))
        {
            KeLowerIrql(OldIrql);
            return;
        }
 
        Transfer = CONTAINING_RECORD(MapTransferList->Flink,
                                     USBPORT_TRANSFER,
                                     TransferLink);
 
        RemoveHeadList(MapTransferList);
 
        Mdl = Transfer->Urb->UrbControlTransfer.TransferBufferMDL;
        TransferBufferLength = Transfer->TransferParameters.TransferBufferLength;
        VirtualAddr = (ULONG_PTR)MmGetMdlVirtualAddress(Mdl);
 
        NumMapRegisters = ADDRESS_AND_SIZE_TO_SPAN_PAGES(VirtualAddr,
                                                         TransferBufferLength);
 
        Transfer->NumberOfMapRegisters = NumMapRegisters;
 
        Status = DmaOperations->AllocateAdapterChannel(FdoExtension->DmaAdapter,
                                                       FdoDevice,
                                                       NumMapRegisters,
                                                       USBPORT_MapTransfer,
                                                       Transfer);
 
        if (!NT_SUCCESS(Status))
            ASSERT(FALSE);
    }
 
    KeLowerIrql(OldIrql);
}

Referenced by USBPORT_AbortTransfers(), and USBPORT_FlushPendingTransfers().

USBPORT_FlushPendingTransfers()

VOID NTAPI USBPORT_FlushPendingTransfers

(

IN PUSBPORT_ENDPOINT

Endpoint

)

Definition at line 785 of file queue.c.

{
    PDEVICE_OBJECT FdoDevice;
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    BOOLEAN IsMapTransfer;
    BOOLEAN IsEnd = FALSE;
    PLIST_ENTRY List;
    PUSBPORT_TRANSFER Transfer;
    PURB Urb;
    PIRP Irp;
    KIRQL OldIrql;
    BOOLEAN Result;
 
    DPRINT_CORE("USBPORT_FlushPendingTransfers: Endpoint - %p\n", Endpoint);
 
    FdoDevice = Endpoint->FdoDevice;
    FdoExtension = FdoDevice->DeviceExtension;
 
    if (InterlockedCompareExchange(&Endpoint->FlushPendingLock, 1, 0))
    {
        DPRINT_CORE("USBPORT_FlushPendingTransfers: Endpoint Locked \n");
        return;
    }
 
    while (TRUE)
    {
        IsMapTransfer = 0;
 
        KeAcquireSpinLock(&FdoExtension->FlushPendingTransferSpinLock,
                          &OldIrql);
 
        KeAcquireSpinLockAtDpcLevel(&Endpoint->EndpointSpinLock);
 
        if (FdoExtension->Flags & USBPORT_FLAG_HC_SUSPEND)
        {
            IsEnd = TRUE;
 
            KeReleaseSpinLockFromDpcLevel(&Endpoint->EndpointSpinLock);
            KeReleaseSpinLock(&FdoExtension->FlushPendingTransferSpinLock,
                              OldIrql);
            goto Next;
        }
 
        if (!(Endpoint->Flags & ENDPOINT_FLAG_ROOTHUB_EP0))
        {
            if (!IsListEmpty(&Endpoint->TransferList))
            {
                List = Endpoint->TransferList.Flink;
 
                while (List && List != &Endpoint->TransferList)
                {
                    Transfer = CONTAINING_RECORD(List,
                                                 USBPORT_TRANSFER,
                                                 TransferLink);
 
                    if (!(Transfer->Flags & TRANSFER_FLAG_SUBMITED))
                    {
                        KeReleaseSpinLockFromDpcLevel(&Endpoint->EndpointSpinLock);
                        KeReleaseSpinLock(&FdoExtension->FlushPendingTransferSpinLock,
                                          OldIrql);
 
                        IsEnd = TRUE;
                        goto Worker;
                    }
 
                    List = Transfer->TransferLink.Flink;
                }
            }
        }
 
        List = Endpoint->PendingTransferList.Flink;
 
        if (List == NULL || IsListEmpty(&Endpoint->PendingTransferList))
        {
            KeReleaseSpinLockFromDpcLevel(&Endpoint->EndpointSpinLock);
            KeReleaseSpinLock(&FdoExtension->FlushPendingTransferSpinLock,
                              OldIrql);
 
            IsEnd = TRUE;
            goto Worker;
        }
 
        Transfer = CONTAINING_RECORD(List,
                                     USBPORT_TRANSFER,
                                     TransferLink);
 
        if (Transfer->Irp)
        {
            DPRINT_CORE("USBPORT_FlushPendingTransfers: Transfer->Irp->CancelRoutine - %p\n",
                        Transfer->Irp->CancelRoutine);
        }
 
        if (Transfer->Irp &&
            (IoSetCancelRoutine(Transfer->Irp, NULL) == NULL))
        {
            DPRINT_CORE("USBPORT_FlushPendingTransfers: Transfer->Irp - %p\n",
                        Transfer->Irp);
 
            Transfer = NULL;
            IsEnd = TRUE;
        }
 
        if (!Transfer)
        {
            KeReleaseSpinLockFromDpcLevel(&Endpoint->EndpointSpinLock);
            KeReleaseSpinLock(&FdoExtension->FlushPendingTransferSpinLock,
                              OldIrql);
 
            if (IsMapTransfer)
            {
                USBPORT_FlushMapTransfers(FdoDevice);
                goto Next;
            }
 
            goto Worker;
        }
 
        Irp = Transfer->Irp;
        Urb = Transfer->Urb;
 
        RemoveEntryList(&Transfer->TransferLink);
        Transfer->TransferLink.Flink = NULL;
        Transfer->TransferLink.Blink = NULL;
 
        if (Irp)
        {
            Irp = USBPORT_RemovePendingTransferIrp(FdoDevice, Irp);
        }
 
        KeReleaseSpinLockFromDpcLevel(&Endpoint->EndpointSpinLock);
        KeReleaseSpinLock(&FdoExtension->FlushPendingTransferSpinLock,
                          OldIrql);
 
        KeAcquireSpinLock(&FdoExtension->FlushTransferSpinLock, &OldIrql);
 
        if (Irp)
        {
            IoSetCancelRoutine(Irp, USBPORT_CancelActiveTransferIrp);
 
            if (Irp->Cancel && IoSetCancelRoutine(Irp, NULL))
            {
                DPRINT_CORE("USBPORT_FlushPendingTransfers: irp - %p\n", Irp);
 
                KeReleaseSpinLock(&FdoExtension->FlushTransferSpinLock,
                                  OldIrql);
 
                USBPORT_CompleteTransfer(Transfer->Urb, USBD_STATUS_CANCELED);
                goto Worker;
            }
 
            USBPORT_FindUrbInIrpTable(FdoExtension->ActiveIrpTable, Urb, Irp);
            USBPORT_InsertIrpInTable(FdoExtension->ActiveIrpTable, Irp);
        }
 
        IsMapTransfer = USBPORT_QueueActiveUrbToEndpoint(Endpoint, Urb);
 
        KeReleaseSpinLock(&FdoExtension->FlushTransferSpinLock, OldIrql);
 
        if (IsMapTransfer)
        {
            USBPORT_FlushMapTransfers(FdoDevice);
            goto Next;
        }
 
Worker:
        KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
        Result = USBPORT_EndpointWorker(Endpoint, FALSE);
        KeLowerIrql(OldIrql);
 
        if (Result)
            USBPORT_InvalidateEndpointHandler(FdoDevice,
                                              Endpoint,
                                              INVALIDATE_ENDPOINT_WORKER_THREAD);
 
Next:
        if (IsEnd)
        {
            InterlockedDecrement(&Endpoint->FlushPendingLock);
            DPRINT_CORE("USBPORT_FlushPendingTransfers: Endpoint Unlocked. Exit\n");
            return;
        }
    }
}

Referenced by USBPORT_AbortEndpoint(), USBPORT_DpcHandler(), USBPORT_FlushAllEndpoints(), USBPORT_KillEndpointActiveTransfers(), and USBPORT_QueueTransferUrb().

USBPORT_FreeBandwidthUSB2()

VOID NTAPI USBPORT_FreeBandwidthUSB2	(	IN PDEVICE_OBJECT	FdoDevice,
		IN PUSBPORT_ENDPOINT	Endpoint
	)

Definition at line 2040 of file usb2.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    ULONG Period;
    ULONG ScheduleOffset;
    ULONG EndpointBandwidth;
    LIST_ENTRY RebalanceList;
    ULONG TransferType;
    PUSB2_REBALANCE Rebalance;
    ULONG RebalanceListEntries;
    ULONG Factor;
    ULONG ix;
    ULONG n;
    PUSB2_TT_EXTENSION TtExtension;
    PUSB2_TT_ENDPOINT RebalanceTtEndpoint;
 
    DPRINT("USBPORT_FreeBandwidthUSB2: Endpoint - %p\n", Endpoint);
 
    FdoExtension = FdoDevice->DeviceExtension;
 
    Period = Endpoint->EndpointProperties.Period;
    ScheduleOffset = Endpoint->EndpointProperties.ScheduleOffset;
    EndpointBandwidth = Endpoint->EndpointProperties.UsbBandwidth;
 
    InitializeListHead(&RebalanceList);
 
    TransferType = Endpoint->EndpointProperties.TransferType;
 
    if (TransferType == USBPORT_TRANSFER_TYPE_CONTROL ||
        TransferType == USBPORT_TRANSFER_TYPE_BULK ||
        (Endpoint->Flags & ENDPOINT_FLAG_ROOTHUB_EP0))
    {
        return;
    }
 
    Rebalance = ExAllocatePoolWithTag(NonPagedPool,
                                      sizeof(USB2_REBALANCE),
                                      USB_PORT_TAG);
 
    if (!Rebalance)
    {
        DPRINT1("USBPORT_FreeBandwidthUSB2: Rebalance == NULL!\n");
        return;
    }
 
    RtlZeroMemory(Rebalance, sizeof(USB2_REBALANCE));
 
    ASSERT(Period != 0);
    Factor = USB2_FRAMES / Period;
    n = ScheduleOffset * Factor;
 
    TtExtension = Endpoint->TtExtension;
 
    if (TtExtension)
    {
        for (ix = 0; ix < Factor; ix++)
        {
            TtExtension->Bandwidth[n + ix] += EndpointBandwidth;
        }
    }
    else
    {
        for (ix = 1; ix < Factor; ix++)
        {
            FdoExtension->Bandwidth[n + ix] += EndpointBandwidth;
        }
    }
 
    RebalanceListEntries = USB2_FRAMES - 2;
 
    USB2_DeallocateEndpointBudget(Endpoint->TtEndpoint,
                                  Rebalance,
                                  &RebalanceListEntries,
                                  USB2_FRAMES);
 
    RebalanceListEntries = 0;
 
    for (ix = 0; Rebalance->RebalanceEndpoint[ix]; ix++)
    {
        RebalanceListEntries = ix + 1;
    }
 
    for (ix = 0; ix < RebalanceListEntries; ix++)
    {
        RebalanceTtEndpoint = Rebalance->RebalanceEndpoint[ix];
 
        DPRINT("USBPORT_AllocateBandwidthUSB2: RebalanceTtEndpoint[%X] - %p, RebalanceTtEndpoint - %p, RebalanceLink - %p\n",
               ix,
               RebalanceTtEndpoint,
               &RebalanceTtEndpoint->Endpoint->RebalanceLink);
 
        InsertTailList(&RebalanceList,
                       &RebalanceTtEndpoint->Endpoint->RebalanceLink);
    }
 
    ExFreePoolWithTag(Rebalance, USB_PORT_TAG);
 
    USB2_Rebalance(FdoDevice, &RebalanceList);
 
    if (!TtExtension)
        return;
 
    for (ix = 0; ix < USB2_FRAMES; ix++)
    {
        FdoExtension->Bandwidth[ix] += TtExtension->MaxBandwidth;
    }
 
    USBPORT_UpdateAllocatedBwTt(TtExtension);
 
    for (ix = 0; ix < USB2_FRAMES; ix++)
    {
        FdoExtension->Bandwidth[ix] -= TtExtension->MaxBandwidth;
    }
 
    DPRINT1("USBPORT_FreeBandwidthUSB2: exit\n");
}

Referenced by USBPORT_ClosePipe(), and USBPORT_OpenPipe().

USBPORT_FreeCommonBuffer()

VOID NTAPI USBPORT_FreeCommonBuffer	(	IN PDEVICE_OBJECT	FdoDevice,
		IN PUSBPORT_COMMON_BUFFER_HEADER	HeaderBuffer
	)

Definition at line 1770 of file usbport.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    PDMA_ADAPTER DmaAdapter;
    PDMA_OPERATIONS DmaOperations;
 
    DPRINT("USBPORT_FreeCommonBuffer: ...\n");
 
    FdoExtension = FdoDevice->DeviceExtension;
 
    DmaAdapter = FdoExtension->DmaAdapter;
    DmaOperations = DmaAdapter->DmaOperations;
 
    DmaOperations->FreeCommonBuffer(FdoExtension->DmaAdapter,
                                    HeaderBuffer->Length,
                                    HeaderBuffer->LogicalAddress,
                                    (PVOID)HeaderBuffer->VirtualAddress,
                                    TRUE);
}

Referenced by USBPORT_DeleteEndpoint(), USBPORT_ReopenPipe(), and USBPORT_StartDevice().

USBPORT_GetEndpointState()

ULONG NTAPI USBPORT_GetEndpointState

(

IN PUSBPORT_ENDPOINT

Endpoint

)

Definition at line 332 of file endpoint.c.

{
    ULONG State;
 
    //DPRINT("USBPORT_GetEndpointState \n");
 
    KeAcquireSpinLockAtDpcLevel(&Endpoint->StateChangeSpinLock);
 
    if (Endpoint->StateLast != Endpoint->StateNext)
    {
        State = USBPORT_ENDPOINT_UNKNOWN;
    }
    else
    {
        State = Endpoint->StateLast;
    }
 
    KeReleaseSpinLockFromDpcLevel(&Endpoint->StateChangeSpinLock);
 
    if (State != USBPORT_ENDPOINT_ACTIVE)
    {
        DPRINT("USBPORT_GetEndpointState: Endpoint - %p, State - %x\n",
               Endpoint,
               State);
    }
 
    return State;
}

Referenced by USBPORT_DmaEndpointPaused(), USBPORT_DmaEndpointWorker(), USBPORT_DpcHandler(), USBPORT_EndpointWorker(), USBPORT_FlushAllEndpoints(), USBPORT_InvalidateEndpointHandler(), USBPORT_OpenPipe(), and USBPORT_SyncResetPipeAndClearStall().

USBPORT_GetRegistryKeyValueFullInfo()

NTSTATUS NTAPI USBPORT_GetRegistryKeyValueFullInfo	(	IN PDEVICE_OBJECT	FdoDevice,
		IN PDEVICE_OBJECT	PdoDevice,
		IN BOOL	UseDriverKey,
		IN PCWSTR	SourceString,
		IN ULONG	LengthStr,
		IN PVOID	Buffer,
		IN ULONG	NumberOfBytes
	)

Definition at line 296 of file usbport.c.

{
    NTSTATUS Status;
    PKEY_VALUE_FULL_INFORMATION KeyValue;
    UNICODE_STRING ValueName;
    HANDLE KeyHandle;
    ULONG LengthKey;
 
    DPRINT("USBPORT_GetRegistryKeyValue: UseDriverKey - %x, SourceString - %S, LengthStr - %x, Buffer - %p, BufferLength - %x\n",
           UseDriverKey,
           SourceString,
           LengthStr,
           Buffer,
           BufferLength);
 
    if (UseDriverKey)
    {
        Status = IoOpenDeviceRegistryKey(PdoDevice,
                                         PLUGPLAY_REGKEY_DRIVER,
                                         STANDARD_RIGHTS_ALL,
                                         &KeyHandle);
    }
    else
    {
        Status = IoOpenDeviceRegistryKey(PdoDevice,
                                         PLUGPLAY_REGKEY_DEVICE,
                                         STANDARD_RIGHTS_ALL,
                                         &KeyHandle);
    }
 
    if (NT_SUCCESS(Status))
    {
        RtlInitUnicodeString(&ValueName, SourceString);
 
        LengthKey = sizeof(KEY_VALUE_FULL_INFORMATION) +
                    LengthStr +
                    BufferLength;
 
        KeyValue = ExAllocatePoolWithTag(PagedPool,
                                         LengthKey,
                                         USB_PORT_TAG);
 
        if (KeyValue)
        {
            RtlZeroMemory(KeyValue, LengthKey);
 
            Status = ZwQueryValueKey(KeyHandle,
                                     &ValueName,
                                     KeyValueFullInformation,
                                     KeyValue,
                                     LengthKey,
                                     &LengthKey);
 
            if (NT_SUCCESS(Status))
            {
                RtlCopyMemory(Buffer,
                              (PUCHAR)KeyValue + KeyValue->DataOffset,
                              BufferLength);
            }
 
            ExFreePoolWithTag(KeyValue, USB_PORT_TAG);
        }
 
        ZwClose(KeyHandle);
    }
 
    return Status;
}

Referenced by USBHI_GetExtendedHubInformation(), USBPORT_GetMiniportRegistryKeyValue(), USBPORT_IsSelectiveSuspendEnabled(), and USBPORT_StartDevice().

USBPORT_GetSymbolicName()

NTSTATUS NTAPI USBPORT_GetSymbolicName	(	IN PDEVICE_OBJECT	RootHubPdo,
		IN PUNICODE_STRING	DestinationString
	)

Definition at line 62 of file ioctl.c.

{
    PUSBPORT_RHDEVICE_EXTENSION PdoExtension;
    PUNICODE_STRING RootHubName;
    PWCHAR Buffer;
    SIZE_T LengthName;
    SIZE_T Length;
    PWSTR SourceString;
    WCHAR Character;
 
    DPRINT("USBPORT_GetSymbolicName: ... \n");
 
    PdoExtension = RootHubPdo->DeviceExtension;
    RootHubName = &PdoExtension->CommonExtension.SymbolicLinkName;
    Buffer = RootHubName->Buffer;
 
    if (!Buffer)
    {
        return STATUS_UNSUCCESSFUL;
    }
 
    LengthName = RootHubName->Length;
 
    SourceString = ExAllocatePoolWithTag(PagedPool, LengthName, USB_PORT_TAG);
 
    if (!SourceString)
    {
        RtlInitUnicodeString(DestinationString, NULL);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    RtlZeroMemory(SourceString, LengthName);
 
    if (*Buffer == L'\\')
    {
         Buffer += 1;
 
        if (*Buffer == L'\\')
        {
            Buffer += 1;
            goto Exit;
        }
 
        Character = *Buffer;
 
        do
        {
            if (Character == UNICODE_NULL)
            {
                break;
            }
 
            Buffer += 1;
            Character = *Buffer;
        }
        while (*Buffer != L'\\');
 
        if (*Buffer == L'\\')
        {
            Buffer += 1;
        }
 
Exit:
        Length = (ULONG_PTR)Buffer - (ULONG_PTR)RootHubName->Buffer;
    }
    else
    {
        Length = 0;
    }
 
    RtlCopyMemory(SourceString,
                  (PVOID)((ULONG_PTR)RootHubName->Buffer + Length),
                  RootHubName->Length - Length);
 
    RtlInitUnicodeString(DestinationString, SourceString);
 
    DPRINT("USBPORT_RegisterDeviceInterface: DestinationString  - %wZ\n",
           DestinationString);
 
    return STATUS_SUCCESS;
}

Referenced by USBHI_GetRootHubSymbolicName(), and USBPORT_UserGetRootHubName().

USBPORT_GetUsbDescriptor()

NTSTATUS NTAPI USBPORT_GetUsbDescriptor	(	IN PUSBPORT_DEVICE_HANDLE	DeviceHandle,
		IN PDEVICE_OBJECT	FdoDevice,
		IN UCHAR	Type,
		IN PUCHAR	ConfigDesc,
		IN PULONG	ConfigDescSize
	)

Definition at line 1425 of file device.c.

{
    USB_DEFAULT_PIPE_SETUP_PACKET SetupPacket;
 
    DPRINT("USBPORT_GetUsbDescriptor: Type - %x\n");
 
    RtlZeroMemory(&SetupPacket, sizeof(USB_DEFAULT_PIPE_SETUP_PACKET));
 
    SetupPacket.bmRequestType.Dir = BMREQUEST_DEVICE_TO_HOST;
    SetupPacket.bRequest = USB_REQUEST_GET_DESCRIPTOR;
    SetupPacket.wValue.HiByte = Type;
    SetupPacket.wLength = (USHORT)*ConfigDescSize;
 
    return USBPORT_SendSetupPacket(DeviceHandle,
                                   FdoDevice,
                                   &SetupPacket,
                                   ConfigDesc,
                                   *ConfigDescSize,
                                   ConfigDescSize,
                                   NULL);
}

Referenced by USBHI_GetUsbDescriptors().

USBPORT_HandleSelectConfiguration()

NTSTATUS NTAPI USBPORT_HandleSelectConfiguration	(	IN PDEVICE_OBJECT	FdoDevice,
		IN PIRP	Irp,
		IN PURB	Urb
	)

Definition at line 574 of file device.c.

{
    PUSB_CONFIGURATION_DESCRIPTOR ConfigDescriptor;
    PUSBPORT_DEVICE_HANDLE DeviceHandle;
    PUSBPORT_CONFIGURATION_HANDLE ConfigHandle = NULL;
    PUSBD_INTERFACE_INFORMATION InterfaceInfo;
    PUSBPORT_INTERFACE_HANDLE InterfaceHandle;
    ULONG iNumber;
    ULONG ix;
    USB_DEFAULT_PIPE_SETUP_PACKET SetupPacket;
    NTSTATUS Status;
    USBD_STATUS USBDStatus;
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
 
    DPRINT("USBPORT_HandleSelectConfiguration: ConfigDescriptor %p\n",
           Urb->UrbSelectConfiguration.ConfigurationDescriptor);
 
    FdoExtension = FdoDevice->DeviceExtension;
 
    KeWaitForSingleObject(&FdoExtension->DeviceSemaphore,
                          Executive,
                          KernelMode,
                          FALSE,
                          NULL);
 
    DeviceHandle = Urb->UrbHeader.UsbdDeviceHandle;
    ConfigDescriptor = Urb->UrbSelectConfiguration.ConfigurationDescriptor;
 
    if (!ConfigDescriptor)
    {
        DPRINT("USBPORT_HandleSelectConfiguration: ConfigDescriptor == NULL\n");
 
        RtlZeroMemory(&SetupPacket, sizeof(USB_DEFAULT_PIPE_SETUP_PACKET));
 
        SetupPacket.bmRequestType.B = 0;
        SetupPacket.bRequest = USB_REQUEST_SET_CONFIGURATION;
        SetupPacket.wValue.W = 0;
        SetupPacket.wIndex.W = 0;
        SetupPacket.wLength = 0;
 
        USBPORT_SendSetupPacket(DeviceHandle,
                                FdoDevice,
                                &SetupPacket,
                                NULL,
                                0,
                                NULL,
                                NULL);
 
        Status = USBPORT_USBDStatusToNtStatus(Urb, USBD_STATUS_SUCCESS);
        goto Exit;
    }
 
    USBPORT_DumpingConfiguration(ConfigDescriptor);
 
    InterfaceInfo = &Urb->UrbSelectConfiguration.Interface;
 
    iNumber = 0;
 
    do
    {
        ++iNumber;
        InterfaceInfo = (PUSBD_INTERFACE_INFORMATION)
                        ((ULONG_PTR)InterfaceInfo +
                         InterfaceInfo->Length);
    }
    while ((ULONG_PTR)InterfaceInfo < (ULONG_PTR)Urb + Urb->UrbHeader.Length);
 
    if ((iNumber <= 0) || (iNumber != ConfigDescriptor->bNumInterfaces))
    {
        Status = USBPORT_USBDStatusToNtStatus(Urb,
                                              USBD_STATUS_INVALID_CONFIGURATION_DESCRIPTOR);
        goto Exit;
    }
 
    ConfigHandle = ExAllocatePoolWithTag(NonPagedPool,
                                         ConfigDescriptor->wTotalLength + sizeof(USBPORT_CONFIGURATION_HANDLE),
                                         USB_PORT_TAG);
 
    if (!ConfigHandle)
    {
        Status = USBPORT_USBDStatusToNtStatus(Urb,
                                              USBD_STATUS_INSUFFICIENT_RESOURCES);
        goto Exit;
    }
 
    RtlZeroMemory(ConfigHandle,
                  ConfigDescriptor->wTotalLength + sizeof(USBPORT_CONFIGURATION_HANDLE));
 
    InitializeListHead(&ConfigHandle->InterfaceHandleList);
 
    ConfigHandle->ConfigurationDescriptor = (PUSB_CONFIGURATION_DESCRIPTOR)(ConfigHandle + 1);
 
    RtlCopyMemory(ConfigHandle->ConfigurationDescriptor,
                  ConfigDescriptor,
                  ConfigDescriptor->wTotalLength);
 
    RtlZeroMemory(&SetupPacket, sizeof(USB_DEFAULT_PIPE_SETUP_PACKET));
 
    SetupPacket.bmRequestType.B = 0;
    SetupPacket.bRequest = USB_REQUEST_SET_CONFIGURATION;
    SetupPacket.wValue.W = ConfigDescriptor->bConfigurationValue;
    SetupPacket.wIndex.W = 0;
    SetupPacket.wLength = 0;
 
    USBPORT_SendSetupPacket(DeviceHandle,
                            FdoDevice,
                            &SetupPacket,
                            NULL,
                            0,
                            NULL,
                            &USBDStatus);
 
    if (USBD_ERROR(USBDStatus))
    {
        Status = USBPORT_USBDStatusToNtStatus(Urb,
                                              USBD_STATUS_SET_CONFIG_FAILED);
        goto Exit;
    }
 
    if (iNumber <= 0)
    {
        Status = USBPORT_USBDStatusToNtStatus(Urb,
                                              USBD_STATUS_SUCCESS);
 
        goto Exit;
    }
 
    InterfaceInfo = &Urb->UrbSelectConfiguration.Interface;
 
    for (ix = 0; ix < iNumber; ++ix)
    {
        USBDStatus = USBPORT_InitInterfaceInfo(InterfaceInfo,
                                               ConfigHandle);
 
        InterfaceHandle = NULL;
 
        if (USBD_SUCCESS(USBDStatus))
        {
            USBDStatus = USBPORT_OpenInterface(Urb,
                                               DeviceHandle,
                                               FdoDevice,
                                               ConfigHandle,
                                               InterfaceInfo,
                                               &InterfaceHandle,
                                               TRUE);
        }
 
        if (InterfaceHandle)
        {
            InsertTailList(&ConfigHandle->InterfaceHandleList,
                           &InterfaceHandle->InterfaceLink);
        }
 
        if (USBD_ERROR(USBDStatus))
            break;
 
        InterfaceInfo = (PUSBD_INTERFACE_INFORMATION)
                         ((ULONG_PTR)InterfaceInfo +
                          InterfaceInfo->Length);
    }
 
    if (ix >= iNumber)
    {
        Status = USBPORT_USBDStatusToNtStatus(Urb,
                                              USBD_STATUS_SUCCESS);
    }
    else
    {
        Status = USBPORT_USBDStatusToNtStatus(Urb, USBDStatus);
    }
 
Exit:
 
    if (NT_SUCCESS(Status))
    {
        Urb->UrbSelectConfiguration.ConfigurationHandle = ConfigHandle;
        DeviceHandle->ConfigHandle = ConfigHandle;
    }
    else
    {
        DPRINT1("USBPORT_HandleSelectConfiguration: Status %x\n", Status);
    }
 
    KeReleaseSemaphore(&FdoExtension->DeviceSemaphore,
                       LOW_REALTIME_PRIORITY,
                       1,
                       FALSE);
 
    return Status;
}

Referenced by USBPORT_HandleSubmitURB().

USBPORT_HandleSelectInterface()

NTSTATUS NTAPI USBPORT_HandleSelectInterface	(	IN PDEVICE_OBJECT	FdoDevice,
		IN PIRP	Irp,
		IN PURB	Urb
	)

Definition at line 1486 of file device.c.

{
    PUSBPORT_DEVICE_HANDLE DeviceHandle;
    PUSBPORT_CONFIGURATION_HANDLE ConfigurationHandle;
    PUSBD_INTERFACE_INFORMATION Interface;
    PUSBPORT_INTERFACE_HANDLE InterfaceHandle;
    PUSBPORT_INTERFACE_HANDLE iHandle;
    PUSBPORT_PIPE_HANDLE PipeHandle;
    USBD_STATUS USBDStatus;
    USHORT Length;
    ULONG ix;
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
 
    DPRINT("USBPORT_HandleSelectInterface: ... \n");
 
    FdoExtension = FdoDevice->DeviceExtension;
 
    KeWaitForSingleObject(&FdoExtension->DeviceSemaphore,
                          Executive,
                          KernelMode,
                          FALSE,
                          NULL);
 
    ConfigurationHandle = Urb->UrbSelectInterface.ConfigurationHandle;
 
    Interface = &Urb->UrbSelectInterface.Interface;
 
    Length = Interface->Length + sizeof(USBD_PIPE_INFORMATION);
    Urb->UrbHeader.Length = Length;
 
    USBDStatus = USBPORT_InitInterfaceInfo(Interface, ConfigurationHandle);
 
    if (USBDStatus)
    {
        Interface->InterfaceHandle = (USBD_INTERFACE_HANDLE)-1;
        return USBPORT_USBDStatusToNtStatus(Urb, USBDStatus);
    }
 
    DeviceHandle = Urb->UrbHeader.UsbdDeviceHandle;
 
    InterfaceHandle = USBPORT_GetInterfaceHandle(ConfigurationHandle,
                                                 Interface->InterfaceNumber);
 
    if (InterfaceHandle)
    {
        RemoveEntryList(&InterfaceHandle->InterfaceLink);
 
        if (InterfaceHandle->InterfaceDescriptor.bNumEndpoints)
        {
            PipeHandle = &InterfaceHandle->PipeHandle[0];
 
            for (ix = 0;
                 ix < InterfaceHandle->InterfaceDescriptor.bNumEndpoints;
                 ix++)
            {
                USBPORT_ClosePipe(DeviceHandle, FdoDevice, PipeHandle);
                PipeHandle += 1;
            }
        }
    }
 
    iHandle = 0;
 
    USBDStatus = USBPORT_OpenInterface(Urb,
                                       DeviceHandle,
                                       FdoDevice,
                                       ConfigurationHandle,
                                       Interface,
                                       &iHandle,
                                       TRUE);
 
    if (USBDStatus)
    {
        Interface->InterfaceHandle = (USBD_INTERFACE_HANDLE)-1;
    }
    else
    {
        if (InterfaceHandle)
            ExFreePoolWithTag(InterfaceHandle, USB_PORT_TAG);
 
        Interface->InterfaceHandle = iHandle;
 
        InsertTailList(&ConfigurationHandle->InterfaceHandleList,
                       &iHandle->InterfaceLink);
    }
 
    KeReleaseSemaphore(&FdoExtension->DeviceSemaphore,
                       LOW_REALTIME_PRIORITY,
                       1,
                       FALSE);
 
    return USBPORT_USBDStatusToNtStatus(Urb, USBDStatus);
}

Referenced by USBPORT_HandleSubmitURB().

USBPORT_HandleSubmitURB()

NTSTATUS NTAPI USBPORT_HandleSubmitURB	(	IN PDEVICE_OBJECT	PdoDevice,
		IN PIRP	Irp,
		IN PURB	Urb
	)

Definition at line 791 of file urb.c.

{
    PUSBPORT_RHDEVICE_EXTENSION PdoExtension;
    PDEVICE_OBJECT FdoDevice;
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    USHORT Function;
    PUSBPORT_DEVICE_HANDLE DeviceHandle;
    NTSTATUS Status = STATUS_NOT_IMPLEMENTED;
 
    ASSERT(Urb);
 
    PdoExtension = PdoDevice->DeviceExtension;
    FdoDevice = PdoExtension->FdoDevice;
    FdoExtension = FdoDevice->DeviceExtension;
 
    Urb->UrbHeader.Status = USBD_STATUS_SUCCESS;
    Urb->UrbHeader.UsbdFlags = 0;
 
    Function = Urb->UrbHeader.Function;
 
    if (Function > URB_FUNCTION_MAX)
    {
        Status = USBPORT_USBDStatusToNtStatus(Urb,
                                              USBD_STATUS_INVALID_URB_FUNCTION);
 
        DPRINT1("USBPORT_HandleSubmitURB: Unknown URB function - %x !!!\n",
               Function);
 
        return Status;
    }
 
    if (FdoExtension->TimerFlags & USBPORT_TMFLAG_RH_SUSPENDED)
    {
        DPRINT1("USBPORT_HandleSubmitURB: Bad Request\n");
 
        USBPORT_USBDStatusToNtStatus(Urb, USBD_STATUS_DEVICE_GONE);
 
        Irp->IoStatus.Status = STATUS_PENDING;
        IoMarkIrpPending(Irp);
        IoCsqInsertIrp(&FdoExtension->BadRequestIoCsq, Irp, NULL);
 
        return STATUS_PENDING;
    }
 
    DeviceHandle = Urb->UrbHeader.UsbdDeviceHandle;
 
    if (!DeviceHandle)
    {
        DeviceHandle = &PdoExtension->DeviceHandle;
        Urb->UrbHeader.UsbdDeviceHandle = DeviceHandle;
    }
 
    if (!USBPORT_ValidateDeviceHandle(PdoExtension->FdoDevice,
                                      DeviceHandle))
    {
        DPRINT1("USBPORT_HandleSubmitURB: Not valid device handle\n");
 
        Irp->IoStatus.Status = STATUS_PENDING;
        IoMarkIrpPending(Irp);
        IoCsqInsertIrp(&FdoExtension->BadRequestIoCsq, Irp, NULL);
 
        return STATUS_PENDING;
    }
 
    InterlockedIncrement(&DeviceHandle->DeviceHandleLock);
 
    DPRINT_URB("USBPORT_HandleSubmitURB: Function - 0x%02X, DeviceHandle - %p\n",
               Function,
               Urb->UrbHeader.UsbdDeviceHandle);
 
    switch (Function)
    {
        case URB_FUNCTION_ISOCH_TRANSFER:
            DPRINT1("USBPORT_HandleSubmitURB: URB_FUNCTION_ISOCH_TRANSFER UNIMPLEMENTED. FIXME. \n");
            break;
 
        case URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER:
        case URB_FUNCTION_CONTROL_TRANSFER:
            Status = USBPORT_ValidateURB(FdoDevice, Irp, Urb, FALSE, FALSE);
 
            if (!NT_SUCCESS(Status))
            {
                DPRINT1("USBPORT_HandleSubmitURB: Not valid URB\n");
                break;
            }
 
            Status = USBPORT_HandleDataTransfers(Urb);
            break;
 
        case URB_FUNCTION_VENDOR_DEVICE:
        case URB_FUNCTION_VENDOR_INTERFACE:
        case URB_FUNCTION_VENDOR_ENDPOINT:
        case URB_FUNCTION_CLASS_DEVICE:
        case URB_FUNCTION_CLASS_INTERFACE:
        case URB_FUNCTION_CLASS_ENDPOINT:
        case URB_FUNCTION_CLASS_OTHER:
        case URB_FUNCTION_VENDOR_OTHER:
            Status = USBPORT_ValidateURB(FdoDevice, Irp, Urb, TRUE, FALSE);
 
            if (!NT_SUCCESS(Status))
            {
                DPRINT1("USBPORT_HandleSubmitURB: Not valid URB\n");
                break;
            }
 
            Status = USBPORT_HandleVendorOrClass(Irp, Urb);
            break;
 
        case URB_FUNCTION_GET_DESCRIPTOR_FROM_DEVICE:
        case URB_FUNCTION_SET_DESCRIPTOR_TO_DEVICE:
        case URB_FUNCTION_GET_DESCRIPTOR_FROM_ENDPOINT:
        case URB_FUNCTION_SET_DESCRIPTOR_TO_ENDPOINT:
        case URB_FUNCTION_GET_DESCRIPTOR_FROM_INTERFACE:
        case URB_FUNCTION_SET_DESCRIPTOR_TO_INTERFACE:
            Status = USBPORT_ValidateURB(FdoDevice, Irp, Urb, TRUE, FALSE);
 
            if (!NT_SUCCESS(Status))
            {
                DPRINT1("USBPORT_HandleSubmitURB: Not valid URB\n");
                break;
            }
 
            Status = USBPORT_HandleGetSetDescriptor(Irp, Urb);
            break;
 
        case URB_FUNCTION_GET_MS_FEATURE_DESCRIPTOR:
            DPRINT1("USBPORT_HandleSubmitURB: URB_FUNCTION_GET_MS_FEATURE_DESCRIPTOR (0x2A) NOT_SUPPORTED\n");
            return USBPORT_USBDStatusToNtStatus(Urb,
                                                USBD_STATUS_INVALID_URB_FUNCTION);
 
        case URB_FUNCTION_GET_STATUS_FROM_DEVICE:
        case URB_FUNCTION_GET_STATUS_FROM_INTERFACE:
        case URB_FUNCTION_GET_STATUS_FROM_ENDPOINT:
        case URB_FUNCTION_GET_STATUS_FROM_OTHER:
            Status = USBPORT_ValidateURB(FdoDevice, Irp, Urb, TRUE, FALSE);
 
            if (!NT_SUCCESS(Status))
            {
                DPRINT1("USBPORT_HandleSubmitURB: Not valid URB\n");
                break;
            }
 
            Status = USBPORT_HandleGetStatus(Irp, Urb);
            break;
 
        case URB_FUNCTION_SELECT_CONFIGURATION:
            Status = USBPORT_HandleSelectConfiguration(PdoExtension->FdoDevice,
                                                       Irp,
                                                       Urb);
            break;
 
        case URB_FUNCTION_SELECT_INTERFACE:
            Status = USBPORT_HandleSelectInterface(PdoExtension->FdoDevice,
                                                   Irp,
                                                   Urb);
            break;
 
        case URB_FUNCTION_GET_CONFIGURATION:
            Status = USBPORT_ValidateURB(FdoDevice, Irp, Urb, TRUE, FALSE);
 
            if (!NT_SUCCESS(Status))
            {
                DPRINT1("USBPORT_HandleSubmitURB: Not valid URB\n");
                break;
            }
 
            Status = USBPORT_HandleGetConfiguration(Urb);
            break;
 
        case URB_FUNCTION_GET_INTERFACE:
            DPRINT1("USBPORT_HandleSubmitURB: URB_FUNCTION_GET_INTERFACE (0x27) NOT_SUPPORTED\n");
            return USBPORT_USBDStatusToNtStatus(Urb,
                                                USBD_STATUS_INVALID_URB_FUNCTION);
 
        case URB_FUNCTION_SYNC_RESET_PIPE_AND_CLEAR_STALL:
            Status = USBPORT_SyncResetPipeAndClearStall(PdoExtension->FdoDevice,
                                                        Irp,
                                                        Urb);
            break;
 
        case URB_FUNCTION_SYNC_RESET_PIPE:
            Status = USBPORT_ResetPipe(PdoExtension->FdoDevice,
                                       Irp,
                                       Urb);
            break;
 
        case URB_FUNCTION_SYNC_CLEAR_STALL:
            Status = USBPORT_ClearStall(PdoExtension->FdoDevice,
                                        Irp,
                                        Urb);
            break;
 
        case URB_FUNCTION_ABORT_PIPE:
            Status = USBPORT_AbortPipe(PdoExtension->FdoDevice,
                                       Irp,
                                       Urb);
            break;
 
        case URB_FUNCTION_SET_FEATURE_TO_DEVICE:
        case URB_FUNCTION_SET_FEATURE_TO_INTERFACE:
        case URB_FUNCTION_SET_FEATURE_TO_ENDPOINT:
        case URB_FUNCTION_CLEAR_FEATURE_TO_INTERFACE:
        case URB_FUNCTION_CLEAR_FEATURE_TO_ENDPOINT:
        case URB_FUNCTION_CLEAR_FEATURE_TO_OTHER:
        case URB_FUNCTION_SET_FEATURE_TO_OTHER:
            Status = USBPORT_ValidateURB(FdoDevice, Irp, Urb, TRUE, TRUE);
 
            if (!NT_SUCCESS(Status))
            {
                DPRINT1("USBPORT_HandleSubmitURB: Not valid URB\n");
                break;
            }
 
            Status = USBPORT_HandleSetOrClearFeature(Urb);
            break;
 
        case URB_FUNCTION_GET_CURRENT_FRAME_NUMBER:
            Status = USBPORT_HandleGetCurrentFrame(PdoExtension->FdoDevice,
                                                   Irp,
                                                   Urb);
            break;
 
        case URB_FUNCTION_TAKE_FRAME_LENGTH_CONTROL:
            DPRINT1("USBPORT_HandleSubmitURB: URB_FUNCTION_TAKE_FRAME_LENGTH_CONTROL (0x03) NOT_SUPPORTED\n");
            return USBPORT_USBDStatusToNtStatus(Urb, USBD_STATUS_NOT_SUPPORTED);
 
        case URB_FUNCTION_RELEASE_FRAME_LENGTH_CONTROL:
            DPRINT1("USBPORT_HandleSubmitURB: URB_FUNCTION_RELEASE_FRAME_LENGTH_CONTROL (0x04) NOT_SUPPORTED\n");
            return USBPORT_USBDStatusToNtStatus(Urb, USBD_STATUS_NOT_SUPPORTED);
 
        case URB_FUNCTION_GET_FRAME_LENGTH:
            DPRINT1("USBPORT_HandleSubmitURB: URB_FUNCTION_GET_FRAME_LENGTH (0x05) NOT_SUPPORTED\n");
            return USBPORT_USBDStatusToNtStatus(Urb, USBD_STATUS_NOT_SUPPORTED);
 
        case URB_FUNCTION_SET_FRAME_LENGTH:
            DPRINT1("USBPORT_HandleSubmitURB: URB_FUNCTION_SET_FRAME_LENGTH (0x06) NOT_SUPPORTED\n");
            return USBPORT_USBDStatusToNtStatus(Urb, USBD_STATUS_NOT_SUPPORTED);
 
        default:
            DPRINT1("USBPORT_HandleSubmitURB: Unknown URB Function - %x\n",
                    Function);
            //URB_FUNCTION_RESERVED_0X0016
            //URB_FUNCTION_RESERVE_0X001D
            //URB_FUNCTION_RESERVE_0X002B
            //URB_FUNCTION_RESERVE_0X002C
            //URB_FUNCTION_RESERVE_0X002D
            //URB_FUNCTION_RESERVE_0X002E
            //URB_FUNCTION_RESERVE_0X002F
            break;
    }
 
    if (Status == STATUS_PENDING)
    {
        return Status;
    }
 
    if (Urb->UrbHeader.UsbdFlags & USBD_FLAG_ALLOCATED_TRANSFER)
    {
        PUSBPORT_TRANSFER Transfer;
 
        Transfer = Urb->UrbControlTransfer.hca.Reserved8[0];
        Urb->UrbControlTransfer.hca.Reserved8[0] = NULL;
        Urb->UrbHeader.UsbdFlags |= ~USBD_FLAG_ALLOCATED_TRANSFER;
        ExFreePoolWithTag(Transfer, USB_PORT_TAG);
    }
 
    InterlockedDecrement(&DeviceHandle->DeviceHandleLock);
 
    Irp->IoStatus.Status = Status;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    return Status;
}

Referenced by USBPORT_PdoInternalDeviceControl().

USBPORT_HcQueueWakeDpc()

VOID NTAPI USBPORT_HcQueueWakeDpc

(

IN PDEVICE_OBJECT

FdoDevice

)

Definition at line 63 of file power.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
 
    DPRINT("USBPORT_HcQueueWakeDpc: ... \n");
 
    FdoExtension = FdoDevice->DeviceExtension;
    KeInsertQueueDpc(&FdoExtension->HcWakeDpc, NULL, NULL);
}

Referenced by USBPORT_InvalidateRootHub().

USBPORT_HcWakeDpc()

VOID NTAPI USBPORT_HcWakeDpc	(	IN PRKDPC	Dpc,
		IN PVOID	DeferredContext,
		IN PVOID	SystemArgument1,
		IN PVOID	SystemArgument2
	)

Definition at line 52 of file power.c.

{
    DPRINT("USBPORT_HcWakeDpc: ... \n");
    USBPORT_CompletePdoWaitWake((PDEVICE_OBJECT)DeferredContext);
}

Referenced by USBPORT_StartDevice().

USBPORT_IdleNotification()

NTSTATUS NTAPI USBPORT_IdleNotification	(	IN PDEVICE_OBJECT	PdoDevice,
		IN PIRP	Irp
	)

Definition at line 612 of file power.c.

{
    PUSBPORT_RHDEVICE_EXTENSION PdoExtension;
    PDEVICE_OBJECT FdoDevice;
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    LONG LockCounter;
    NTSTATUS Status = STATUS_PENDING;
 
    DPRINT("USBPORT_IdleNotification: Irp - %p\n", Irp);
 
    PdoExtension = PdoDevice->DeviceExtension;
    FdoDevice = PdoExtension->FdoDevice;
    FdoExtension = FdoDevice->DeviceExtension;
 
    LockCounter = InterlockedIncrement(&FdoExtension->IdleLockCounter);
 
    if (LockCounter != 0)
    {
        if (Status != STATUS_PENDING)
        {
            InterlockedDecrement(&FdoExtension->IdleLockCounter);
 
            Irp->IoStatus.Status = Status;
            Irp->IoStatus.Information = 0;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
            return Status;
        }
 
        Status = STATUS_DEVICE_BUSY;
    }
 
    if (Status != STATUS_PENDING)
    {
        InterlockedDecrement(&FdoExtension->IdleLockCounter);
 
        Irp->IoStatus.Status = Status;
        Irp->IoStatus.Information = 0;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
        return Status;
    }
 
    Irp->IoStatus.Status = STATUS_PENDING;
    IoMarkIrpPending(Irp);
 
    KeQuerySystemTime(&FdoExtension->IdleTime);
 
    IoCsqInsertIrp(&FdoExtension->IdleIoCsq, Irp, 0);
 
    return Status;
}

Referenced by USBPORT_PdoInternalDeviceControl().

USBPORT_Initialize20Hub()

NTSTATUS NTAPI USBPORT_Initialize20Hub	(	IN PDEVICE_OBJECT	FdoDevice,
		IN PUSBPORT_DEVICE_HANDLE	HubDeviceHandle,
		IN ULONG	TtCount
	)

Definition at line 2012 of file device.c.

{
    NTSTATUS Status;
    ULONG ix;
 
    DPRINT("USBPORT_Initialize20Hub: TtCount - %X\n", TtCount);
 
    if (!HubDeviceHandle)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    if (HubDeviceHandle->Flags & DEVICE_HANDLE_FLAG_ROOTHUB)
    {
        return STATUS_SUCCESS;
    }
 
    if (TtCount == 0)
    {
        HubDeviceHandle->TtCount = 0;
        return STATUS_SUCCESS;
    }
 
    for (ix = 0; ix < TtCount; ++ix)
    {
        Status = USBPORT_InitializeTT(FdoDevice, HubDeviceHandle, ix + 1);
 
        if (!NT_SUCCESS(Status))
            break;
    }
 
    HubDeviceHandle->TtCount = TtCount;
 
    return Status;
}

Referenced by USBHI_Initialize20Hub().

USBPORT_InitializeDevice()

NTSTATUS NTAPI USBPORT_InitializeDevice	(	IN PUSBPORT_DEVICE_HANDLE	DeviceHandle,
		IN PDEVICE_OBJECT	FdoDevice
	)

Definition at line 1316 of file device.c.

{
    PUSBPORT_ENDPOINT Endpoint;
    USB_DEFAULT_PIPE_SETUP_PACKET CtrlSetup;
    ULONG TransferedLen;
    USHORT DeviceAddress = 0;
    UCHAR MaxPacketSize;
    NTSTATUS Status;
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
 
    DPRINT("USBPORT_InitializeDevice: ... \n");
 
    ASSERT(DeviceHandle != NULL);
 
    FdoExtension = FdoDevice->DeviceExtension;
 
    KeWaitForSingleObject(&FdoExtension->DeviceSemaphore,
                          Executive,
                          KernelMode,
                          FALSE,
                          NULL);
 
    DeviceAddress = USBPORT_AllocateUsbAddress(FdoDevice);
    ASSERT(DeviceHandle->DeviceAddress == USB_DEFAULT_DEVICE_ADDRESS);
 
    RtlZeroMemory(&CtrlSetup, sizeof(USB_DEFAULT_PIPE_SETUP_PACKET));
 
    CtrlSetup.bRequest = USB_REQUEST_SET_ADDRESS;
    CtrlSetup.wValue.W = DeviceAddress;
 
    Status = USBPORT_SendSetupPacket(DeviceHandle,
                                     FdoDevice,
                                     &CtrlSetup,
                                     NULL,
                                     0,
                                     NULL,
                                     NULL);
 
    DPRINT("USBPORT_InitializeDevice: DeviceAddress - %x. SendSetupPacket Status - %x\n",
           DeviceAddress,
           Status);
 
    if (!NT_SUCCESS(Status))
        goto ExitError;
 
    DeviceHandle->DeviceAddress = DeviceAddress;
    Endpoint = DeviceHandle->PipeHandle.Endpoint;
 
    Endpoint->EndpointProperties.TotalMaxPacketSize = DeviceHandle->DeviceDescriptor.bMaxPacketSize0;
    Endpoint->EndpointProperties.DeviceAddress = DeviceAddress;
 
    Status = USBPORT_ReopenPipe(FdoDevice, Endpoint);
 
    if (!NT_SUCCESS(Status))
        goto ExitError;
 
    USBPORT_Wait(FdoDevice, 10);
 
    RtlZeroMemory(&CtrlSetup, sizeof(USB_DEFAULT_PIPE_SETUP_PACKET));
 
    CtrlSetup.bRequest = USB_REQUEST_GET_DESCRIPTOR;
    CtrlSetup.wValue.HiByte = USB_DEVICE_DESCRIPTOR_TYPE;
    CtrlSetup.wLength = sizeof(USB_DEVICE_DESCRIPTOR);
    CtrlSetup.bmRequestType.B = 0x80;
 
    Status = USBPORT_SendSetupPacket(DeviceHandle,
                                     FdoDevice,
                                     &CtrlSetup,
                                     &DeviceHandle->DeviceDescriptor,
                                     sizeof(USB_DEVICE_DESCRIPTOR),
                                     &TransferedLen,
                                     NULL);
 
    if (NT_SUCCESS(Status))
    {
        ASSERT(TransferedLen == sizeof(USB_DEVICE_DESCRIPTOR));
        ASSERT(DeviceHandle->DeviceDescriptor.bLength >= sizeof(USB_DEVICE_DESCRIPTOR));
        ASSERT(DeviceHandle->DeviceDescriptor.bDescriptorType == USB_DEVICE_DESCRIPTOR_TYPE);
 
        MaxPacketSize = DeviceHandle->DeviceDescriptor.bMaxPacketSize0;
 
        ASSERT((MaxPacketSize == 8) ||
               (MaxPacketSize == 16) ||
               (MaxPacketSize == 32) ||
               (MaxPacketSize == 64));
 
        if (DeviceHandle->DeviceSpeed == UsbHighSpeed &&
            DeviceHandle->DeviceDescriptor.bDeviceClass == USB_DEVICE_CLASS_HUB)
        {
            DeviceHandle->Flags |= DEVICE_HANDLE_FLAG_USB2HUB;
        }
    }
    else
    {
ExitError:
        DPRINT1("USBPORT_InitializeDevice: ExitError. Status - %x\n", Status);
    }
 
    KeReleaseSemaphore(&FdoExtension->DeviceSemaphore,
                       LOW_REALTIME_PRIORITY,
                       1,
                       FALSE);
 
    return Status;
}

Referenced by USBHI_InitializeUsbDevice().

USBPORT_InitializeIsoTransfer()

USBD_STATUS NTAPI USBPORT_InitializeIsoTransfer	(	IN PDEVICE_OBJECT	FdoDevice,
		IN struct _URB_ISOCH_TRANSFER *	Urb,
		IN PUSBPORT_TRANSFER	Transfer
	)

USBPORT_InsertBadRequest()

VOID NTAPI USBPORT_InsertBadRequest	(	IN PIO_CSQ	Csq,
		IN PIRP	Irp
	)

Definition at line 143 of file queue.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
 
    DPRINT_QUEUE("USBPORT_InsertBadRequest: Irp - %p\n", Irp);
 
    FdoExtension = CONTAINING_RECORD(Csq,
                                     USBPORT_DEVICE_EXTENSION,
                                     BadRequestIoCsq);
 
    InsertTailList(&FdoExtension->BadRequestList,
                   &Irp->Tail.Overlay.ListEntry);
}

Referenced by USBPORT_StartDevice().

USBPORT_InsertIdleIrp()

VOID NTAPI USBPORT_InsertIdleIrp	(	IN PIO_CSQ	Csq,
		IN PIRP	Irp
	)

Definition at line 20 of file queue.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
 
    DPRINT_QUEUE("USBPORT_InsertIdleIrp: Irp - %p\n", Irp);
 
    FdoExtension = CONTAINING_RECORD(Csq,
                                     USBPORT_DEVICE_EXTENSION,
                                     IdleIoCsq);
 
    InsertTailList(&FdoExtension->IdleIrpList,
                   &Irp->Tail.Overlay.ListEntry);
}

Referenced by USBPORT_StartDevice().

USBPORT_InsertIrpInTable()

VOID NTAPI USBPORT_InsertIrpInTable	(	IN PUSBPORT_IRP_TABLE	IrpTable,
		IN PIRP	Irp
	)

Definition at line 266 of file queue.c.

{
    ULONG ix;
 
    DPRINT_CORE("USBPORT_InsertIrpInTable: IrpTable - %p, Irp - %p\n",
                IrpTable,
                Irp);
 
    ASSERT(IrpTable != NULL);
 
    while (TRUE)
    {
        for (ix = 0; ix < 0x200; ix++)
        {
            if (IrpTable->irp[ix] == NULL)
            {
                IrpTable->irp[ix] = Irp;
 
                if (ix > 0)
                {
                    DPRINT_CORE("USBPORT_InsertIrpInTable: ix - %x\n", ix);
                }
 
                return;
            }
        }
 
        if (ix != 0x200)
        {
            KeBugCheckEx(BUGCODE_USB_DRIVER, 1, 0, 0, 0);
        }
 
        IrpTable->LinkNextTable = ExAllocatePoolWithTag(NonPagedPool,
                                                        sizeof(USBPORT_IRP_TABLE),
                                                        USB_PORT_TAG);
 
        if (IrpTable->LinkNextTable == NULL)
        {
            KeBugCheckEx(BUGCODE_USB_DRIVER, 1, 0, 0, 0);
        }
 
        RtlZeroMemory(IrpTable->LinkNextTable, sizeof(USBPORT_IRP_TABLE));
 
        IrpTable = IrpTable->LinkNextTable;
    }
}

Referenced by USBPORT_FlushPendingTransfers(), and USBPORT_QueuePendingTransferIrp().

USBPORT_InterruptService()

BOOLEAN NTAPI USBPORT_InterruptService	(	IN PKINTERRUPT	Interrupt,
		IN PVOID	ServiceContext
	)

Definition at line 1077 of file usbport.c.

{
    PDEVICE_OBJECT FdoDevice;
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    PUSBPORT_REGISTRATION_PACKET Packet;
    BOOLEAN Result = FALSE;
 
    FdoDevice = ServiceContext;
    FdoExtension = FdoDevice->DeviceExtension;
    Packet = &FdoExtension->MiniPortInterface->Packet;
 
    DPRINT_INT("USBPORT_InterruptService: FdoExtension[%p]->Flags - %08X\n",
           FdoExtension,
           FdoExtension->Flags);
 
    if (FdoExtension->Flags & USBPORT_FLAG_INTERRUPT_ENABLED &&
        FdoExtension->MiniPortFlags & USBPORT_MPFLAG_INTERRUPTS_ENABLED)
    {
        Result = Packet->InterruptService(FdoExtension->MiniPortExt);
 
        if (Result)
        {
            KeInsertQueueDpc(&FdoExtension->IsrDpc, NULL, NULL);
        }
    }
 
    DPRINT_INT("USBPORT_InterruptService: return - %x\n", Result);
 
    return Result;
}

Referenced by USBPORT_StartDevice().

USBPORT_InvalidateControllerHandler()

VOID NTAPI USBPORT_InvalidateControllerHandler	(	IN PDEVICE_OBJECT	FdoDevice,
		IN ULONG	Type
	)

Definition at line 635 of file usbport.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
 
    DPRINT_CORE("USBPORT_InvalidateControllerHandler: Invalidate Type - %x\n",
                Type);
 
    FdoExtension = FdoDevice->DeviceExtension;
 
    switch (Type)
    {
        case USBPORT_INVALIDATE_CONTROLLER_RESET:
            DPRINT1("USBPORT_InvalidateControllerHandler: INVALIDATE_CONTROLLER_RESET UNIMPLEMENTED. FIXME.\n");
            break;
 
        case USBPORT_INVALIDATE_CONTROLLER_SURPRISE_REMOVE:
            DPRINT1("USBPORT_InvalidateControllerHandler: INVALIDATE_CONTROLLER_SURPRISE_REMOVE UNIMPLEMENTED. FIXME.\n");
            break;
 
        case USBPORT_INVALIDATE_CONTROLLER_SOFT_INTERRUPT:
            if (InterlockedIncrement(&FdoExtension->IsrDpcCounter))
            {
                InterlockedDecrement(&FdoExtension->IsrDpcCounter);
            }
            else
            {
                USBPORT_SoftInterrupt(FdoDevice);
            }
            break;
    }
}

Referenced by USBPORT_FdoPnP(), and USBPORT_InvalidateController().

USBPORT_InvalidateEndpointHandler()

VOID NTAPI USBPORT_InvalidateEndpointHandler	(	IN PDEVICE_OBJECT	FdoDevice,
		IN PUSBPORT_ENDPOINT	Endpoint,
		IN ULONG	Type
	)

Definition at line 1317 of file endpoint.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    PUSBPORT_REGISTRATION_PACKET Packet;
    PLIST_ENTRY Entry;
    PLIST_ENTRY WorkerLink;
    PUSBPORT_ENDPOINT endpoint;
    KIRQL OldIrql;
    BOOLEAN IsAddEntry = FALSE;
 
    DPRINT_CORE("USBPORT_InvalidateEndpointHandler: Endpoint - %p, Type - %x\n",
                Endpoint,
                Type);
 
    FdoExtension = FdoDevice->DeviceExtension;
    Packet = &FdoExtension->MiniPortInterface->Packet;
 
    if (Endpoint)
    {
        WorkerLink = &Endpoint->WorkerLink;
        KeAcquireSpinLock(&FdoExtension->EndpointListSpinLock, &OldIrql);
        DPRINT_CORE("USBPORT_InvalidateEndpointHandler: KeAcquireSpinLock \n");
 
        if ((!WorkerLink->Flink || !WorkerLink->Blink) &&
            !(Endpoint->Flags & ENDPOINT_FLAG_IDLE) &&
            USBPORT_GetEndpointState(Endpoint) != USBPORT_ENDPOINT_CLOSED)
        {
            DPRINT_CORE("USBPORT_InvalidateEndpointHandler: InsertTailList \n");
            InsertTailList(&FdoExtension->WorkerList, WorkerLink);
            IsAddEntry = TRUE;
        }
 
        KeReleaseSpinLock(&FdoExtension->EndpointListSpinLock, OldIrql);
 
        if (Endpoint->Flags & ENDPOINT_FLAG_ROOTHUB_EP0)
            Type = INVALIDATE_ENDPOINT_WORKER_THREAD;
    }
    else
    {
        KeAcquireSpinLock(&FdoExtension->EndpointListSpinLock, &OldIrql);
 
        for (Entry = FdoExtension->EndpointList.Flink;
             Entry && Entry != &FdoExtension->EndpointList;
             Entry = Entry->Flink)
        {
            endpoint = CONTAINING_RECORD(Entry,
                                         USBPORT_ENDPOINT,
                                         EndpointLink);
 
            if (!endpoint->WorkerLink.Flink || !endpoint->WorkerLink.Blink)
            {
                if (!(endpoint->Flags & ENDPOINT_FLAG_IDLE) &&
                    !(endpoint->Flags & ENDPOINT_FLAG_ROOTHUB_EP0) &&
                    USBPORT_GetEndpointState(endpoint) != USBPORT_ENDPOINT_CLOSED)
                {
                    DPRINT_CORE("USBPORT_InvalidateEndpointHandler: InsertTailList \n");
                    InsertTailList(&FdoExtension->WorkerList, &endpoint->WorkerLink);
                    IsAddEntry = TRUE;
                }
            }
        }
 
        KeReleaseSpinLock(&FdoExtension->EndpointListSpinLock, OldIrql);
    }
 
    if (FdoExtension->Flags & USBPORT_FLAG_HC_SUSPEND)
    {
        Type = INVALIDATE_ENDPOINT_WORKER_THREAD;
    }
    else if (IsAddEntry == FALSE && Type == INVALIDATE_ENDPOINT_INT_NEXT_SOF)
    {
        Type = INVALIDATE_ENDPOINT_ONLY;
    }
 
    switch (Type)
    {
        case INVALIDATE_ENDPOINT_WORKER_THREAD:
            USBPORT_SignalWorkerThread(FdoDevice);
            break;
 
        case INVALIDATE_ENDPOINT_WORKER_DPC:
            KeInsertQueueDpc(&FdoExtension->WorkerRequestDpc, NULL, NULL);
            break;
 
        case INVALIDATE_ENDPOINT_INT_NEXT_SOF:
            KeAcquireSpinLock(&FdoExtension->MiniportSpinLock, &OldIrql);
            Packet->InterruptNextSOF(FdoExtension->MiniPortExt);
            KeReleaseSpinLock(&FdoExtension->MiniportSpinLock, OldIrql);
            break;
    }
}

Referenced by USBPORT_AbortEndpoint(), USBPORT_CancelActiveTransferIrp(), USBPORT_DmaEndpointWorker(), USBPORT_FlushDoneTransfers(), USBPORT_FlushPendingTransfers(), USBPORT_InvalidateEndpoint(), USBPORT_InvalidateRootHub(), USBPORT_IsrDpcHandler(), USBPORT_MapTransfer(), and USBPORT_SetEndpointState().

USBPORT_InvalidateRootHub()

ULONG NTAPI USBPORT_InvalidateRootHub

(

PVOID

MiniPortExtension

)

Definition at line 917 of file roothub.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    PDEVICE_OBJECT FdoDevice;
    PDEVICE_OBJECT PdoDevice;
    PUSBPORT_RHDEVICE_EXTENSION PdoExtension;
    PUSBPORT_ENDPOINT Endpoint = NULL;
 
    DPRINT("USBPORT_InvalidateRootHub ... \n");
 
    FdoExtension = (PUSBPORT_DEVICE_EXTENSION)((ULONG_PTR)MiniPortExtension -
                                               sizeof(USBPORT_DEVICE_EXTENSION));
 
    FdoDevice = FdoExtension->CommonExtension.SelfDevice;
 
    if (FdoExtension->Flags & USBPORT_FLAG_HC_SUSPEND &&
        FdoExtension->Flags & USBPORT_FLAG_HC_WAKE_SUPPORT &&
        FdoExtension->MiniPortFlags & USBPORT_MPFLAG_SUSPENDED &&
        FdoExtension->TimerFlags & USBPORT_TMFLAG_WAKE)
    {
        USBPORT_HcQueueWakeDpc(FdoDevice);
        return 0;
    }
 
    FdoExtension->MiniPortInterface->Packet.RH_DisableIrq(FdoExtension->MiniPortExt);
 
    PdoDevice = FdoExtension->RootHubPdo;
 
    if (PdoDevice)
    {
        PdoExtension = PdoDevice->DeviceExtension;
        Endpoint = PdoExtension->Endpoint;
 
        if (Endpoint)
        {
            USBPORT_InvalidateEndpointHandler(FdoDevice,
                                              PdoExtension->Endpoint,
                                              INVALIDATE_ENDPOINT_WORKER_THREAD);
        }
    }
 
    return 0;
}

Referenced by USBPORT_RegisterUSBPortDriver().

USBPORT_IsrDpc()

VOID NTAPI USBPORT_IsrDpc	(	IN PRKDPC	Dpc,
		IN PVOID	DeferredContext,
		IN PVOID	SystemArgument1,
		IN PVOID	SystemArgument2
	)

Definition at line 1031 of file usbport.c.

{
    PDEVICE_OBJECT FdoDevice;
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    PUSBPORT_REGISTRATION_PACKET Packet;
    BOOLEAN InterruptEnable;
 
    DPRINT_INT("USBPORT_IsrDpc: DeferredContext - %p, SystemArgument2 - %p\n",
               DeferredContext,
               SystemArgument2);
 
    FdoDevice = DeferredContext;
    FdoExtension = FdoDevice->DeviceExtension;
    Packet = &FdoExtension->MiniPortInterface->Packet;
 
    if (SystemArgument2)
    {
        InterlockedDecrement(&FdoExtension->IsrDpcCounter);
    }
 
    KeAcquireSpinLockAtDpcLevel(&FdoExtension->MiniportInterruptsSpinLock);
    InterruptEnable = (FdoExtension->Flags & USBPORT_FLAG_INTERRUPT_ENABLED) ==
                       USBPORT_FLAG_INTERRUPT_ENABLED;
 
    Packet->InterruptDpc(FdoExtension->MiniPortExt, InterruptEnable);
 
    KeReleaseSpinLockFromDpcLevel(&FdoExtension->MiniportInterruptsSpinLock);
 
    if (FdoExtension->Flags & USBPORT_FLAG_HC_SUSPEND &&
        FdoExtension->TimerFlags & USBPORT_TMFLAG_WAKE)
    {
        USBPORT_CompletePdoWaitWake(FdoDevice);
    }
    else
    {
        USBPORT_IsrDpcHandler(FdoDevice, TRUE);
    }
 
    DPRINT_INT("USBPORT_IsrDpc: exit\n");
}

Referenced by USBPORT_StartDevice().

USBPORT_LogEntry()

ULONG NTAPI USBPORT_LogEntry	(	IN PVOID	MiniPortExtension,
		IN ULONG	DriverTag,
		IN ULONG	EnumTag,
		IN ULONG	P1,
		IN ULONG	P2,
		IN ULONG	P3
	)

Definition at line 60 of file debug.c.

{
    DPRINT_MINIPORT("USBPORT_LogEntry: MiniPortExtension - %p, EnumTag - %lx, P1 - %lx, P2 - %lx, P3 - %lx\n",
           MiniPortExtension,
           EnumTag,
           P1,
           P2,
           P3);
 
    return 0;
}

Referenced by USBPORT_RegisterUSBPortDriver().

USBPORT_MiniportInterrupts()

VOID NTAPI USBPORT_MiniportInterrupts	(	IN PDEVICE_OBJECT	FdoDevice,
		IN BOOLEAN	IsEnable
	)

Definition at line 555 of file usbport.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    PUSBPORT_REGISTRATION_PACKET Packet;
    BOOLEAN IsLock;
    KIRQL OldIrql;
 
    DPRINT_INT("USBPORT_MiniportInterrupts: IsEnable - %p\n", IsEnable);
 
    FdoExtension = FdoDevice->DeviceExtension;
    Packet = &FdoExtension->MiniPortInterface->Packet;
 
    IsLock = (Packet->MiniPortFlags & USB_MINIPORT_FLAGS_NOT_LOCK_INT) == 0;
 
    if (IsLock)
        KeAcquireSpinLock(&FdoExtension->MiniportSpinLock, &OldIrql);
 
    if (IsEnable)
    {
        FdoExtension->Flags |= USBPORT_FLAG_INTERRUPT_ENABLED;
        Packet->EnableInterrupts(FdoExtension->MiniPortExt);
    }
    else
    {
        Packet->DisableInterrupts(FdoExtension->MiniPortExt);
        FdoExtension->Flags &= ~USBPORT_FLAG_INTERRUPT_ENABLED;
    }
 
    if (IsLock)
        KeReleaseSpinLock(&FdoExtension->MiniportSpinLock, OldIrql);
}

Referenced by USBPORT_ResumeController(), and USBPORT_StartDevice().

USBPORT_NukeAllEndpoints()

VOID NTAPI USBPORT_NukeAllEndpoints

(

IN PDEVICE_OBJECT

FdoDevice

)

Definition at line 300 of file endpoint.c.

{
    PUSBPORT_DEVICE_EXTENSION  FdoExtension;
    PLIST_ENTRY EndpointList;
    PUSBPORT_ENDPOINT Endpoint;
    KIRQL OldIrql;
 
    DPRINT("USBPORT_NukeAllEndpoints \n");
 
    FdoExtension = FdoDevice->DeviceExtension;
 
    KeAcquireSpinLock(&FdoExtension->EndpointListSpinLock, &OldIrql);
 
    EndpointList = FdoExtension->EndpointList.Flink;
 
    while (EndpointList && (EndpointList != &FdoExtension->EndpointList))
    {
        Endpoint = CONTAINING_RECORD(EndpointList,
                                     USBPORT_ENDPOINT,
                                     EndpointLink);
 
        if (!(Endpoint->Flags & ENDPOINT_FLAG_ROOTHUB_EP0))
            Endpoint->Flags |= ENDPOINT_FLAG_NUKE;
 
        EndpointList = Endpoint->EndpointLink.Flink;
    }
 
    KeReleaseSpinLock(&FdoExtension->EndpointListSpinLock, OldIrql);
}

Referenced by USBPORT_ResumeController().

USBPORT_OpenPipe()

NTSTATUS NTAPI USBPORT_OpenPipe	(	IN PDEVICE_OBJECT	FdoDevice,
		IN PUSBPORT_DEVICE_HANDLE	DeviceHandle,
		IN PUSBPORT_PIPE_HANDLE	PipeHandle,
		IN PUSBD_STATUS	UsbdStatus
	)

USBPORT_PdoDeviceControl()

NTSTATUS NTAPI USBPORT_PdoDeviceControl	(	PDEVICE_OBJECT	PdoDevice,
		PIRP	Irp
	)

USBPORT_PdoInternalDeviceControl()

NTSTATUS NTAPI USBPORT_PdoInternalDeviceControl	(	IN PDEVICE_OBJECT	FdoDevice,
		IN PIRP	Irp
	)

Definition at line 317 of file ioctl.c.

{
    PUSBPORT_RHDEVICE_EXTENSION PdoExtension;
    PIO_STACK_LOCATION IoStack;
    ULONG IoCtl;
    NTSTATUS Status;
 
    PdoExtension = PdoDevice->DeviceExtension;
    IoStack = IoGetCurrentIrpStackLocation(Irp);
    IoCtl = IoStack->Parameters.DeviceIoControl.IoControlCode;
 
    //DPRINT("USBPORT_PdoInternalDeviceControl: PdoDevice - %p, Irp - %p, IoCtl - %x\n",
    //       PdoDevice,
    //       Irp,
    //       IoCtl);
 
    if (IoCtl == IOCTL_INTERNAL_USB_SUBMIT_URB)
    {
        return USBPORT_HandleSubmitURB(PdoDevice, Irp, URB_FROM_IRP(Irp));
    }
 
    if (IoCtl == IOCTL_INTERNAL_USB_GET_ROOTHUB_PDO)
    {
        DPRINT("USBPORT_PdoInternalDeviceControl: IOCTL_INTERNAL_USB_GET_ROOTHUB_PDO\n");
 
        if (IoStack->Parameters.Others.Argument1)
            *(PVOID *)IoStack->Parameters.Others.Argument1 = PdoDevice;
 
        if (IoStack->Parameters.Others.Argument2)
            *(PVOID *)IoStack->Parameters.Others.Argument2 = PdoDevice;
 
        Status = STATUS_SUCCESS;
        goto Exit;
    }
 
    if (IoCtl == IOCTL_INTERNAL_USB_GET_HUB_COUNT)
    {
        DPRINT("USBPORT_PdoInternalDeviceControl: IOCTL_INTERNAL_USB_GET_HUB_COUNT\n");
 
        if (IoStack->Parameters.Others.Argument1)
        {
            ++*(PULONG)IoStack->Parameters.Others.Argument1;
        }
 
        Status = STATUS_SUCCESS;
        goto Exit;
    }
 
    if (IoCtl == IOCTL_INTERNAL_USB_GET_DEVICE_HANDLE)
    {
        DPRINT("USBPORT_PdoInternalDeviceControl: IOCTL_INTERNAL_USB_GET_DEVICE_HANDLE\n");
 
        if (IoStack->Parameters.Others.Argument1)
        {
            *(PVOID *)IoStack->Parameters.Others.Argument1 = &PdoExtension->DeviceHandle;
        }
 
        Status = STATUS_SUCCESS;
        goto Exit;
    }
 
    if (IoCtl == IOCTL_INTERNAL_USB_SUBMIT_IDLE_NOTIFICATION)
    {
        DPRINT("USBPORT_PdoInternalDeviceControl: IOCTL_INTERNAL_USB_SUBMIT_IDLE_NOTIFICATION\n");
        return USBPORT_IdleNotification(PdoDevice, Irp);
    }
 
    DPRINT("USBPORT_PdoInternalDeviceControl: INVALID INTERNAL DEVICE CONTROL\n");
    Status = STATUS_INVALID_DEVICE_REQUEST;
 
Exit:
    Irp->IoStatus.Status = Status;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
    return Status;
}

Referenced by USBPORT_Dispatch().

USBPORT_PdoPnP()

NTSTATUS NTAPI USBPORT_PdoPnP	(	IN PDEVICE_OBJECT	FdoDevice,
		IN PIRP	Irp
	)

Definition at line 1517 of file pnp.c.

{
    PUSBPORT_RHDEVICE_EXTENSION PdoExtension;
    PUSBPORT_COMMON_DEVICE_EXTENSION PdoCommonExtension;
    PDEVICE_OBJECT FdoDevice;
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    PIO_STACK_LOCATION IoStack;
    UCHAR Minor;
    NTSTATUS Status;
    PPNP_BUS_INFORMATION BusInformation;
    PDEVICE_CAPABILITIES DeviceCapabilities;
 
    PdoExtension = PdoDevice->DeviceExtension;
    PdoCommonExtension = &PdoExtension->CommonExtension;
 
    FdoDevice = PdoExtension->FdoDevice;
    FdoExtension = FdoDevice->DeviceExtension;
 
    IoStack = IoGetCurrentIrpStackLocation(Irp);
    Minor = IoStack->MinorFunction;
 
    Status = Irp->IoStatus.Status;
 
    DPRINT("USBPORT_PdoPnP: PdoDevice - %p, Minor - %x\n", PdoDevice, Minor);
 
    switch (Minor)
    {
        case IRP_MN_START_DEVICE:
            DPRINT("IRP_MN_START_DEVICE\n");
 
            Status = USBPORT_RootHubCreateDevice(FdoDevice, PdoDevice);
 
            if (NT_SUCCESS(Status))
            {
                Status = USBPORT_RegisterDeviceInterface(PdoDevice,
                                                         PdoDevice,
                                                         &GUID_DEVINTERFACE_USB_HUB,
                                                         TRUE);
 
                if (NT_SUCCESS(Status))
                {
                    PdoCommonExtension->DevicePowerState = PowerDeviceD0;
                    PdoCommonExtension->PnpStateFlags = USBPORT_PNP_STATE_STARTED;
                }
            }
 
            break;
 
        case IRP_MN_QUERY_REMOVE_DEVICE:
            DPRINT("USBPORT_PdoPnP: IRP_MN_QUERY_REMOVE_DEVICE\n");
            Status = STATUS_SUCCESS;
            break;
 
        case IRP_MN_REMOVE_DEVICE:
            DPRINT1("USBPORT_PdoPnP: IRP_MN_REMOVE_DEVICE UNIMPLEMENTED. FIXME. \n");
            //USBPORT_StopRootHub();
            Status = STATUS_SUCCESS;
            break;
 
        case IRP_MN_CANCEL_REMOVE_DEVICE:
            DPRINT("IRP_MN_CANCEL_REMOVE_DEVICE\n");
            Status = STATUS_SUCCESS;
            break;
 
        case IRP_MN_STOP_DEVICE:
            DPRINT1("USBPORT_PdoPnP: IRP_MN_STOP_DEVICE UNIMPLEMENTED. FIXME. \n");
            //USBPORT_StopRootHub();
            Status = STATUS_SUCCESS;
            break;
 
        case IRP_MN_QUERY_STOP_DEVICE:
            DPRINT("IRP_MN_QUERY_STOP_DEVICE\n");
            Status = STATUS_SUCCESS;
            break;
 
        case IRP_MN_CANCEL_STOP_DEVICE:
            DPRINT("IRP_MN_CANCEL_STOP_DEVICE\n");
            Status = STATUS_SUCCESS;
            break;
 
        case IRP_MN_QUERY_DEVICE_RELATIONS:
        {
            PDEVICE_RELATIONS DeviceRelations;
 
            DPRINT("IRP_MN_QUERY_DEVICE_RELATIONS\n");
            if (IoStack->Parameters.QueryDeviceRelations.Type != TargetDeviceRelation)
            {
                break;
            }
 
            DeviceRelations = ExAllocatePoolWithTag(PagedPool,
                                                    sizeof(DEVICE_RELATIONS),
                                                    USB_PORT_TAG);
 
            if (!DeviceRelations)
            {
                Status = STATUS_INSUFFICIENT_RESOURCES;
                Irp->IoStatus.Information = 0;
                break;
            }
 
            DeviceRelations->Count = 1;
            DeviceRelations->Objects[0] = PdoDevice;
 
            ObReferenceObject(PdoDevice);
 
            Status = STATUS_SUCCESS;
            Irp->IoStatus.Information = (ULONG_PTR)DeviceRelations;
            break;
        }
 
        case IRP_MN_QUERY_INTERFACE:
            DPRINT("IRP_MN_QUERY_INTERFACE\n");
            Status = USBPORT_PdoQueryInterface(FdoDevice, PdoDevice, Irp);
            break;
 
        case IRP_MN_QUERY_CAPABILITIES:
            DPRINT("IRP_MN_QUERY_CAPABILITIES\n");
 
            DeviceCapabilities = IoStack->Parameters.DeviceCapabilities.Capabilities;
 
            RtlCopyMemory(DeviceCapabilities,
                          &PdoExtension->Capabilities,
                          sizeof(DEVICE_CAPABILITIES));
 
            Status = STATUS_SUCCESS;
            break;
 
        case IRP_MN_QUERY_RESOURCES:
            DPRINT("USBPORT_PdoPnP: IRP_MN_QUERY_RESOURCES\n");
            break;
 
        case IRP_MN_QUERY_RESOURCE_REQUIREMENTS:
            DPRINT("IRP_MN_QUERY_RESOURCE_REQUIREMENTS\n");
            break;
 
        case IRP_MN_QUERY_DEVICE_TEXT:
            DPRINT("IRP_MN_QUERY_DEVICE_TEXT\n");
            break;
 
        case IRP_MN_FILTER_RESOURCE_REQUIREMENTS:
            DPRINT("IRP_MN_FILTER_RESOURCE_REQUIREMENTS\n");
            break;
 
        case IRP_MN_READ_CONFIG:
            DPRINT("IRP_MN_READ_CONFIG\n");
            ASSERT(FALSE);
            break;
 
        case IRP_MN_WRITE_CONFIG:
            DPRINT("IRP_MN_WRITE_CONFIG\n");
            ASSERT(FALSE);
            break;
 
        case IRP_MN_EJECT:
            DPRINT("IRP_MN_EJECT\n");
            ASSERT(FALSE);
            break;
 
        case IRP_MN_SET_LOCK:
            DPRINT("IRP_MN_SET_LOCK\n");
            ASSERT(FALSE);
            break;
 
        case IRP_MN_QUERY_ID:
        {
            ULONG IdType;
            LONG Length;
            WCHAR Buffer[64] = {0};
            PVOID Id;
 
            Status = STATUS_SUCCESS;
            IdType = IoStack->Parameters.QueryId.IdType;
 
            DPRINT("IRP_MN_QUERY_ID/Type %x\n", IdType);
 
            if (IdType == BusQueryDeviceID)
            {
                PUSBPORT_REGISTRATION_PACKET Packet;
                Packet = &FdoExtension->MiniPortInterface->Packet;
 
                if (Packet->MiniPortFlags & USB_MINIPORT_FLAGS_USB2)
                {
                    RtlStringCbPrintfW(Buffer,
                                       sizeof(Buffer),
                                       L"USB\\ROOT_HUB20");
                }
                else
                {
                    RtlStringCbPrintfW(Buffer,
                                       sizeof(Buffer),
                                       L"USB\\ROOT_HUB");
                }
 
                Length = (LONG)(wcslen(Buffer) + 1);
 
                Id = ExAllocatePoolWithTag(PagedPool,
                                           Length * sizeof(WCHAR),
                                           USB_PORT_TAG);
 
                if (Id)
                {
                    RtlZeroMemory(Id, Length * sizeof(WCHAR));
                    RtlStringCbCopyW(Id, Length * sizeof(WCHAR), Buffer);
 
                    DPRINT("BusQueryDeviceID - %S, TotalLength - %hu\n",
                           Id,
                           Length);
                }
 
                Irp->IoStatus.Information = (ULONG_PTR)Id;
                break;
            }
 
            if (IdType == BusQueryHardwareIDs)
            {
                Id = USBPORT_GetDeviceHwIds(FdoDevice,
                                            FdoExtension->VendorID,
                                            FdoExtension->DeviceID,
                                            FdoExtension->RevisionID);
 
                Irp->IoStatus.Information = (ULONG_PTR)Id;
                break;
            }
 
            if (IdType == BusQueryCompatibleIDs ||
                IdType == BusQueryInstanceID)
            {
                Irp->IoStatus.Information = 0;
                break;
            }
 
            /* IdType == BusQueryDeviceSerialNumber */
            Status = Irp->IoStatus.Status;
            break;
        }
 
        case IRP_MN_QUERY_PNP_DEVICE_STATE:
            DPRINT("IRP_MN_QUERY_PNP_DEVICE_STATE\n");
            Status = STATUS_SUCCESS;
            break;
 
        case IRP_MN_QUERY_BUS_INFORMATION:
            DPRINT("IRP_MN_QUERY_BUS_INFORMATION\n");
 
            /* Allocate buffer for bus information */
            BusInformation = ExAllocatePoolWithTag(PagedPool,
                                                   sizeof(PNP_BUS_INFORMATION),
                                                   USB_PORT_TAG);
 
            if (!BusInformation)
            {
                /* No memory */
                Status = STATUS_INSUFFICIENT_RESOURCES;
                break;
            }
 
            RtlZeroMemory(BusInformation, sizeof(PNP_BUS_INFORMATION));
 
            /* Copy BUS GUID */
            RtlMoveMemory(&BusInformation->BusTypeGuid,
                          &GUID_BUS_TYPE_USB,
                          sizeof(GUID));
 
            /* Set bus type */
            BusInformation->LegacyBusType = PNPBus;
            BusInformation->BusNumber = 0;
 
            Status = STATUS_SUCCESS;
            Irp->IoStatus.Information = (ULONG_PTR)BusInformation;
            break;
 
        case IRP_MN_DEVICE_USAGE_NOTIFICATION:
            DPRINT("IRP_MN_DEVICE_USAGE_NOTIFICATION\n");
            break;
 
        case IRP_MN_SURPRISE_REMOVAL:
            DPRINT("USBPORT_PdoPnP: IRP_MN_SURPRISE_REMOVAL\n");
            Status = STATUS_SUCCESS;
            break;
 
        default:
            DPRINT("unknown IRP_MN_???\n");
            break;
    }
 
    Irp->IoStatus.Status = Status;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
    return Status;
}

Referenced by USBPORT_Dispatch().

USBPORT_PdoPower()

NTSTATUS NTAPI USBPORT_PdoPower	(	IN PDEVICE_OBJECT	PdoDevice,
		IN PIRP	Irp
	)

Definition at line 322 of file power.c.

{
    PUSBPORT_RHDEVICE_EXTENSION PdoExtension;
    PDEVICE_OBJECT FdoDevice;
    PIO_STACK_LOCATION IoStack;
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    NTSTATUS Status;
    KIRQL OldIrql;
 
    DPRINT("USBPORT_PdoPower: Irp - %p\n", Irp);
 
    PdoExtension = PdoDevice->DeviceExtension;
    FdoDevice = PdoExtension->FdoDevice;
    FdoExtension = FdoDevice->DeviceExtension;
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    Status = Irp->IoStatus.Status;
 
    switch (IoStack->MinorFunction)
    {
      case IRP_MN_WAIT_WAKE:
          DPRINT("USBPORT_PdoPower: IRP_MN_WAIT_WAKE\n");
 
          if (!(FdoExtension->Flags & USBPORT_FLAG_HC_STARTED))
          {
              /* The device does not support wake-up */
              Status = STATUS_NOT_SUPPORTED;
              break;
          }
 
          KeAcquireSpinLock(&FdoExtension->PowerWakeSpinLock, &OldIrql);
 
          IoSetCancelRoutine(Irp, USBPORT_CancelPendingWakeIrp);
 
          /* Check if the IRP has been cancelled */
          if (Irp->Cancel)
          {
              if (IoSetCancelRoutine(Irp, NULL))
              {
                  /* IRP has been cancelled, release cancel spinlock */
                  KeReleaseSpinLock(&FdoExtension->PowerWakeSpinLock, OldIrql);
 
                  DPRINT("USBPORT_PdoPower: IRP_MN_WAIT_WAKE - STATUS_CANCELLED\n");
 
                  /* IRP is cancelled */
                  Status = STATUS_CANCELLED;
                  break;
              }
          }
 
          if (!PdoExtension->WakeIrp)
          {
              /* The driver received the IRP
                 and is waiting for the device to signal wake-up. */
 
              DPRINT("USBPORT_PdoPower: IRP_MN_WAIT_WAKE - No WakeIrp\n");
 
              IoMarkIrpPending(Irp);
              PdoExtension->WakeIrp = Irp;
 
              KeReleaseSpinLock(&FdoExtension->PowerWakeSpinLock, OldIrql);
              return STATUS_PENDING;
          }
          else
          {
              /* An IRP_MN_WAIT_WAKE request is already pending and must be
                 completed or canceled before another IRP_MN_WAIT_WAKE request
                 can be issued. */
 
              if (IoSetCancelRoutine(Irp, NULL))
              {
                  DPRINT("USBPORT_PdoPower: IRP_MN_WAIT_WAKE - STATUS_DEVICE_BUSY\n");
 
                  KeReleaseSpinLock(&FdoExtension->PowerWakeSpinLock, OldIrql);
                  PoStartNextPowerIrp(Irp);
                  Status = STATUS_DEVICE_BUSY;
                  break;
              }
              else
              {
                  ASSERT(FALSE);
                  KeReleaseSpinLock(&FdoExtension->PowerWakeSpinLock, OldIrql);
                  return Status;
              }
          }
 
      case IRP_MN_POWER_SEQUENCE:
          DPRINT("USBPORT_PdoPower: IRP_MN_POWER_SEQUENCE\n");
          PoStartNextPowerIrp(Irp);
          break;
 
      case IRP_MN_SET_POWER:
          DPRINT("USBPORT_PdoPower: IRP_MN_SET_POWER\n");
 
          if (IoStack->Parameters.Power.Type == DevicePowerState)
          {
              DPRINT("USBPORT_PdoPower: IRP_MN_SET_POWER/DevicePowerState\n");
              Status = USBPORT_PdoDevicePowerState(PdoDevice, Irp);
              PoStartNextPowerIrp(Irp);
              break;
          }
 
          DPRINT("USBPORT_PdoPower: IRP_MN_SET_POWER/SystemPowerState \n");
 
          if (IoStack->Parameters.Power.State.SystemState == PowerSystemWorking)
          {
              FdoExtension->TimerFlags |= USBPORT_TMFLAG_WAKE;
          }
          else
          {
              FdoExtension->TimerFlags &= ~USBPORT_TMFLAG_WAKE;
          }
 
          Status = STATUS_SUCCESS;
 
          PoStartNextPowerIrp(Irp);
          break;
 
      case IRP_MN_QUERY_POWER:
          DPRINT("USBPORT_PdoPower: IRP_MN_QUERY_POWER\n");
          Status = STATUS_SUCCESS;
          PoStartNextPowerIrp(Irp);
          break;
 
      default:
          DPRINT1("USBPORT_PdoPower: unknown IRP_MN_POWER!\n");
          PoStartNextPowerIrp(Irp);
          break;
    }
 
    Irp->IoStatus.Status = Status;
    Irp->IoStatus.Information = 0;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    return Status;
}

Referenced by USBPORT_Dispatch().

USBPORT_PdoQueryInterface()

NTSTATUS NTAPI USBPORT_PdoQueryInterface	(	IN PDEVICE_OBJECT	FdoDevice,
		IN PDEVICE_OBJECT	PdoDevice,
		IN PIRP	Irp
	)

Definition at line 782 of file iface.c.

{
    PIO_STACK_LOCATION IoStack = IoGetCurrentIrpStackLocation(Irp);
    PUSB_BUS_INTERFACE_HUB_V5 InterfaceHub;
    PUSB_BUS_INTERFACE_USBDI_V2 InterfaceDI;
    UNICODE_STRING GuidBuffer;
    NTSTATUS Status;
 
    DPRINT("USBPORT_PdoQueryInterface: ...\n");
 
    if (IsEqualGUIDAligned(IoStack->Parameters.QueryInterface.InterfaceType,
                           &USB_BUS_INTERFACE_HUB_GUID))
    {
        /* Get request parameters */
        InterfaceHub = (PUSB_BUS_INTERFACE_HUB_V5)IoStack->Parameters.QueryInterface.Interface;
        InterfaceHub->Version = IoStack->Parameters.QueryInterface.Version;
 
        /* Check version */
        if (IoStack->Parameters.QueryInterface.Version >= 6)
        {
            DPRINT1("USB_BUS_INTERFACE_HUB_GUID version %x not supported!\n",
                    IoStack->Parameters.QueryInterface.Version);
 
            return Irp->IoStatus.Status; // Version not supported
        }
 
        /* Interface version 0 */
        InterfaceHub->Size = IoStack->Parameters.QueryInterface.Size;
        InterfaceHub->BusContext = PdoDevice;
 
        InterfaceHub->InterfaceReference = USBI_InterfaceReference;
        InterfaceHub->InterfaceDereference = USBI_InterfaceDereference;
 
        /* Interface version 1 */
        if (IoStack->Parameters.QueryInterface.Version >= 1)
        {
            InterfaceHub->CreateUsbDevice = USBHI_CreateUsbDevice;
            InterfaceHub->InitializeUsbDevice = USBHI_InitializeUsbDevice;
            InterfaceHub->GetUsbDescriptors = USBHI_GetUsbDescriptors;
            InterfaceHub->RemoveUsbDevice = USBHI_RemoveUsbDevice;
            InterfaceHub->RestoreUsbDevice = USBHI_RestoreUsbDevice;
            InterfaceHub->QueryDeviceInformation = USBHI_QueryDeviceInformation;
        }
 
        /* Interface version 2 */
        if (IoStack->Parameters.QueryInterface.Version >= 2)
        {
            InterfaceHub->GetControllerInformation = USBHI_GetControllerInformation;
            InterfaceHub->ControllerSelectiveSuspend = USBHI_ControllerSelectiveSuspend;
            InterfaceHub->GetExtendedHubInformation = USBHI_GetExtendedHubInformation;
            InterfaceHub->GetRootHubSymbolicName = USBHI_GetRootHubSymbolicName;
            InterfaceHub->GetDeviceBusContext = USBHI_GetDeviceBusContext;
            InterfaceHub->Initialize20Hub = USBHI_Initialize20Hub;
        }
 
        /* Interface version 3 */
        if (IoStack->Parameters.QueryInterface.Version >= 3)
            InterfaceHub->RootHubInitNotification = USBHI_RootHubInitNotification;
 
        /* Interface version 4 */
        if (IoStack->Parameters.QueryInterface.Version >= 4)
            InterfaceHub->FlushTransfers = USBHI_FlushTransfers;
 
        /* Interface version 5 */
        if (IoStack->Parameters.QueryInterface.Version >= 5)
            InterfaceHub->SetDeviceHandleData = USBHI_SetDeviceHandleData;
 
        /* Request completed */
        return STATUS_SUCCESS;
    }
    else if (IsEqualGUIDAligned(IoStack->Parameters.QueryInterface.InterfaceType,
                                &USB_BUS_INTERFACE_USBDI_GUID))
    {
        /* Get request parameters */
        InterfaceDI = (PUSB_BUS_INTERFACE_USBDI_V2)IoStack->Parameters.QueryInterface.Interface;
        InterfaceDI->Version = IoStack->Parameters.QueryInterface.Version;
 
        /* Check version */
        if (IoStack->Parameters.QueryInterface.Version >= 3)
        {
            DPRINT1("USB_BUS_INTERFACE_USBDI_GUID version %x not supported!\n",
                    IoStack->Parameters.QueryInterface.Version);
 
            return Irp->IoStatus.Status; // Version not supported
        }
 
        /* Interface version 0 */
        InterfaceDI->Size = IoStack->Parameters.QueryInterface.Size;
        InterfaceDI->BusContext = PdoDevice;
        InterfaceDI->InterfaceReference = USBI_InterfaceReference;
        InterfaceDI->InterfaceDereference = USBI_InterfaceDereference;
        InterfaceDI->GetUSBDIVersion = USBDI_GetUSBDIVersion;
        InterfaceDI->QueryBusTime = USBDI_QueryBusTime;
        InterfaceDI->SubmitIsoOutUrb = USBDI_SubmitIsoOutUrb;
        InterfaceDI->QueryBusInformation = USBDI_QueryBusInformation;
 
        /* Interface version 1 */
        if (IoStack->Parameters.QueryInterface.Version >= 1)
            InterfaceDI->IsDeviceHighSpeed = USBDI_IsDeviceHighSpeed;
 
        /* Interface version 2 */
        if (IoStack->Parameters.QueryInterface.Version >= 2)
            InterfaceDI->EnumLogEntry = USBDI_EnumLogEntry;
 
        return STATUS_SUCCESS;
    }
    else
    {
        /* Convert GUID to string */
        Status = RtlStringFromGUID(IoStack->Parameters.QueryInterface.InterfaceType,
                                   &GuidBuffer);
 
        if (NT_SUCCESS(Status))
        {
            /* Print interface */
            DPRINT1("HandleQueryInterface UNKNOWN INTERFACE GUID: %wZ Version %x\n",
                    &GuidBuffer,
                    IoStack->Parameters.QueryInterface.Version);
 
            RtlFreeUnicodeString(&GuidBuffer); // Free GUID buffer
        }
    }
 
    return Irp->IoStatus.Status;
}

Referenced by USBPORT_PdoPnP().

USBPORT_PeekNextBadRequest()

PIRP NTAPI USBPORT_PeekNextBadRequest	(	IN PIO_CSQ	Csq,
		IN PIRP	Irp,
		IN PVOID	PeekContext
	)

Definition at line 169 of file queue.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    PLIST_ENTRY NextEntry;
    PLIST_ENTRY ListHead;
    PIRP NextIrp = NULL;
 
    DPRINT_QUEUE("USBPORT_PeekNextBadRequest: Irp - %p, PeekContext - %p\n",
                 Irp,
                 PeekContext);
 
    FdoExtension = CONTAINING_RECORD(Csq,
                                     USBPORT_DEVICE_EXTENSION,
                                     BadRequestIoCsq);
 
    ListHead = &FdoExtension->BadRequestList;
 
    if (Irp)
    {
        NextEntry = Irp->Tail.Overlay.ListEntry.Flink;
    }
    else
    {
        NextEntry = ListHead->Flink;
    }
 
    while (NextEntry != ListHead)
    {
        NextIrp = CONTAINING_RECORD(NextEntry,
                                    IRP,
                                    Tail.Overlay.ListEntry);
 
        if (!PeekContext)
            break;
 
        NextEntry = NextEntry->Flink;
    }
 
    return NextIrp;
}

Referenced by USBPORT_StartDevice().

USBPORT_PeekNextIdleIrp()

PIRP NTAPI USBPORT_PeekNextIdleIrp	(	IN PIO_CSQ	Csq,
		IN PIRP	Irp,
		IN PVOID	PeekContext
	)

Definition at line 46 of file queue.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    PLIST_ENTRY NextEntry;
    PLIST_ENTRY ListHead;
    PIRP NextIrp = NULL;
 
    DPRINT_QUEUE("USBPORT_PeekNextIdleIrp: Irp - %p, PeekContext - %p\n",
                 Irp,
                 PeekContext);
 
    FdoExtension = CONTAINING_RECORD(Csq,
                                     USBPORT_DEVICE_EXTENSION,
                                     IdleIoCsq);
 
    ListHead = &FdoExtension->IdleIrpList;
 
    if (Irp)
    {
        NextEntry = Irp->Tail.Overlay.ListEntry.Flink;
    }
    else
    {
        NextEntry = ListHead->Flink;
    }
 
    while (NextEntry != ListHead)
    {
        NextIrp = CONTAINING_RECORD(NextEntry,
                                    IRP,
                                    Tail.Overlay.ListEntry);
 
        if (!PeekContext)
            break;
 
        NextEntry = NextEntry->Flink;
    }
 
    return NextIrp;
}

Referenced by USBPORT_StartDevice().

USBPORT_QueueActiveUrbToEndpoint()

BOOLEAN NTAPI USBPORT_QueueActiveUrbToEndpoint	(	IN PUSBPORT_ENDPOINT	Endpoint,
		IN PURB	Urb
	)

Definition at line 988 of file queue.c.

{
    PUSBPORT_TRANSFER Transfer;
    PDEVICE_OBJECT FdoDevice;
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    PUSBPORT_DEVICE_HANDLE DeviceHandle;
    KIRQL OldIrql;
 
    DPRINT_CORE("USBPORT_QueueActiveUrbToEndpoint: Endpoint - %p, Urb - %p\n",
                Endpoint,
                Urb);
 
    Transfer = Urb->UrbControlTransfer.hca.Reserved8[0];
    FdoDevice = Endpoint->FdoDevice;
    FdoExtension = FdoDevice->DeviceExtension;
 
    KeAcquireSpinLock(&Endpoint->EndpointSpinLock,
                      &Endpoint->EndpointOldIrql);
 
    if ((Endpoint->Flags & ENDPOINT_FLAG_NUKE) ||
        (Transfer->Flags & TRANSFER_FLAG_ABORTED))
    {
        InsertTailList(&Endpoint->CancelList, &Transfer->TransferLink);
 
        KeReleaseSpinLock(&Endpoint->EndpointSpinLock,
                          Endpoint->EndpointOldIrql);
 
        //DPRINT_CORE("USBPORT_QueueActiveUrbToEndpoint: return FALSE\n");
        return FALSE;
    }
 
    if (Transfer->TransferParameters.TransferBufferLength == 0 ||
        !(Endpoint->Flags & ENDPOINT_FLAG_DMA_TYPE))
    {
        InsertTailList(&Endpoint->TransferList, &Transfer->TransferLink);
 
        KeReleaseSpinLock(&Endpoint->EndpointSpinLock,
                          Endpoint->EndpointOldIrql);
 
        //DPRINT_CORE("USBPORT_QueueActiveUrbToEndpoint: return FALSE\n");
        return FALSE;
    }
 
    KeReleaseSpinLock(&Endpoint->EndpointSpinLock, Endpoint->EndpointOldIrql);
 
    KeAcquireSpinLock(&FdoExtension->MapTransferSpinLock, &OldIrql);
 
    InsertTailList(&FdoExtension->MapTransferList, &Transfer->TransferLink);
 
    DeviceHandle = Transfer->Urb->UrbHeader.UsbdDeviceHandle;
    InterlockedIncrement(&DeviceHandle->DeviceHandleLock);
 
    KeReleaseSpinLock(&FdoExtension->MapTransferSpinLock, OldIrql);
 
    //DPRINT_CORE("USBPORT_QueueActiveUrbToEndpoint: return TRUE\n");
    return TRUE;
}

Referenced by USBPORT_FlushPendingTransfers().

USBPORT_QueueDoneTransfer()

BOOLEAN NTAPI USBPORT_QueueDoneTransfer	(	IN PUSBPORT_TRANSFER	Transfer,
		IN USBD_STATUS	USBDStatus
	)

Definition at line 839 of file usbport.c.

{
    PDEVICE_OBJECT FdoDevice;
    PUSBPORT_DEVICE_EXTENSION  FdoExtension;
 
    DPRINT_CORE("USBPORT_QueueDoneTransfer: Transfer - %p, USBDStatus - %p\n",
                Transfer,
                USBDStatus);
 
    FdoDevice = Transfer->Endpoint->FdoDevice;
    FdoExtension = FdoDevice->DeviceExtension;
 
    RemoveEntryList(&Transfer->TransferLink);
    Transfer->USBDStatus = USBDStatus;
 
    ExInterlockedInsertTailList(&FdoExtension->DoneTransferList,
                                &Transfer->TransferLink,
                                &FdoExtension->DoneTransferSpinLock);
 
    return KeInsertQueueDpc(&FdoExtension->TransferFlushDpc, NULL, NULL);
}

Referenced by USBPORT_MapTransfer(), USBPORT_MiniportCompleteTransfer(), and USBPORT_RootHubEndpointWorker().

USBPORT_QueueTransferUrb()

VOID NTAPI USBPORT_QueueTransferUrb

(

IN PURB

Urb

)

Definition at line 1085 of file queue.c.

{
    PUSBPORT_TRANSFER Transfer;
    PUSBPORT_ENDPOINT Endpoint;
    PIRP Irp;
    PUSBPORT_DEVICE_HANDLE DeviceHandle;
    PUSBPORT_TRANSFER_PARAMETERS Parameters;
 
    DPRINT_CORE("USBPORT_QueueTransferUrb: Urb - %p\n", Urb);
 
    if (Urb->UrbControlTransfer.TransferFlags & USBD_DEFAULT_PIPE_TRANSFER)
        Urb->UrbHeader.Function = URB_FUNCTION_CONTROL_TRANSFER;
 
    Transfer = Urb->UrbControlTransfer.hca.Reserved8[0];
    Parameters = &Transfer->TransferParameters;
 
    Endpoint = Transfer->Endpoint;
    Endpoint->Flags &= ~ENDPOINT_FLAG_QUEUENE_EMPTY;
 
    Parameters->TransferBufferLength = Urb->UrbControlTransfer.TransferBufferLength;
    Parameters->TransferFlags = Urb->UrbControlTransfer.TransferFlags;
 
    Transfer->TransferBufferMDL = Urb->UrbControlTransfer.TransferBufferMDL;
 
    if (Urb->UrbControlTransfer.TransferFlags & USBD_TRANSFER_DIRECTION_IN)
    {
        Transfer->Direction = USBPORT_DMA_DIRECTION_FROM_DEVICE;
    }
    else
    {
        Transfer->Direction = USBPORT_DMA_DIRECTION_TO_DEVICE;
    }
 
    if (Endpoint->EndpointProperties.TransferType == USBPORT_TRANSFER_TYPE_CONTROL)
    {
        RtlCopyMemory(&Parameters->SetupPacket,
                      Urb->UrbControlTransfer.SetupPacket,
                      sizeof(USB_DEFAULT_PIPE_SETUP_PACKET));
    }
 
    DPRINT_URB("... URB TransferBufferLength - %x\n",
           Urb->UrbControlTransfer.TransferBufferLength);
 
    Urb->UrbControlTransfer.TransferBufferLength = 0;
 
    Irp = Transfer->Irp;
 
    if (Irp)
    {
        USBPORT_QueuePendingTransferIrp(Irp);
    }
    else
    {
        USBPORT_QueuePendingUrbToEndpoint(Endpoint, Urb);
    }
 
    DeviceHandle = Urb->UrbHeader.UsbdDeviceHandle;
    InterlockedDecrement(&DeviceHandle->DeviceHandleLock);
 
    USBPORT_FlushPendingTransfers(Endpoint);
 
    DPRINT_URB("... URB TransferBufferLength - %x\n",
           Urb->UrbControlTransfer.TransferBufferLength);
 
    if (Urb->UrbControlTransfer.TransferBufferLength)
    {
        PULONG Buffer;
        ULONG BufferLength;
        ULONG_PTR BufferEnd;
        ULONG ix;
 
        Buffer = Urb->UrbControlTransfer.TransferBuffer;
        BufferLength = Urb->UrbControlTransfer.TransferBufferLength;
        BufferEnd = (ULONG_PTR)Buffer + BufferLength;
 
        DPRINT_URB("URB TransferBuffer - %p\n", Buffer);
 
        for (ix = 0; (ULONG_PTR)(Buffer + ix) < BufferEnd; ix++)
        {
            DPRINT_URB("Buffer[%02X] - %p\n", ix, Buffer[ix]);
        }
    }
}

Referenced by USBPORT_HandleDataTransfers(), USBPORT_HandleGetConfiguration(), USBPORT_HandleGetSetDescriptor(), USBPORT_HandleGetStatus(), USBPORT_HandleSetOrClearFeature(), USBPORT_HandleVendorOrClass(), and USBPORT_SendSetupPacket().

USBPORT_ReleaseBadRequestLock()

VOID NTAPI USBPORT_ReleaseBadRequestLock	(	IN PIO_CSQ	Csq,
		IN KIRQL	Irql
	)

Definition at line 230 of file queue.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
 
    DPRINT_QUEUE("USBPORT_ReleaseBadRequestLock: ... \n");
 
    FdoExtension = CONTAINING_RECORD(Csq,
                                     USBPORT_DEVICE_EXTENSION,
                                     BadRequestIoCsq);
 
    KeReleaseSpinLock(&FdoExtension->BadRequestIoCsqSpinLock, Irql);
}

Referenced by USBPORT_StartDevice().

USBPORT_ReleaseIdleLock()

VOID NTAPI USBPORT_ReleaseIdleLock	(	IN PIO_CSQ	Csq,
		IN KIRQL	Irql
	)

Definition at line 107 of file queue.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
 
    DPRINT_QUEUE("USBPORT_ReleaseIdleLock: ... \n");
 
    FdoExtension = CONTAINING_RECORD(Csq,
                                     USBPORT_DEVICE_EXTENSION,
                                     IdleIoCsq);
 
    KeReleaseSpinLock(&FdoExtension->IdleIoCsqSpinLock, Irql);
}

Referenced by USBPORT_StartDevice().

USBPORT_RemoveActiveTransferIrp()

PIRP NTAPI USBPORT_RemoveActiveTransferIrp	(	IN PDEVICE_OBJECT	FdoDevice,
		IN PIRP	Irp
	)

Definition at line 357 of file queue.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
 
    DPRINT_CORE("USBPORT_RemoveActiveTransferIrp: Irp - %p\n", Irp);
    FdoExtension = FdoDevice->DeviceExtension;
    return USBPORT_RemoveIrpFromTable(FdoExtension->ActiveIrpTable, Irp);
}

Referenced by USBPORT_DoneTransfer(), and USBPORT_FlushCancelList().

USBPORT_RemoveBadRequest()

VOID NTAPI USBPORT_RemoveBadRequest	(	IN PIO_CSQ	Csq,
		IN PIRP	Irp
	)

Definition at line 160 of file queue.c.

{
    DPRINT_QUEUE("USBPORT_RemoveBadRequest: Irp - %p\n", Irp);
    RemoveEntryList(&Irp->Tail.Overlay.ListEntry);
}

Referenced by USBPORT_StartDevice().

USBPORT_RemoveDevice()

NTSTATUS NTAPI USBPORT_RemoveDevice	(	IN PDEVICE_OBJECT	FdoDevice,
		IN OUT PUSBPORT_DEVICE_HANDLE	DeviceHandle,
		IN ULONG	Flags
	)

Definition at line 1584 of file device.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    PUSB2_TT_EXTENSION TtExtension;
    ULONG ix;
    KIRQL OldIrql;
 
    DPRINT("USBPORT_RemoveDevice: DeviceHandle - %p, Flags - %x\n",
           DeviceHandle,
           Flags);
 
    FdoExtension = FdoDevice->DeviceExtension;
 
    if ((Flags & USBD_KEEP_DEVICE_DATA) ||
        (Flags & USBD_MARK_DEVICE_BUSY))
    {
        return STATUS_SUCCESS;
    }
 
    KeWaitForSingleObject(&FdoExtension->DeviceSemaphore,
                          Executive,
                          KernelMode,
                          FALSE,
                          NULL);
 
    if (!USBPORT_ValidateDeviceHandle(FdoDevice, DeviceHandle))
    {
        KeReleaseSemaphore(&FdoExtension->DeviceSemaphore,
                           LOW_REALTIME_PRIORITY,
                           1,
                           FALSE);
 
        DPRINT1("USBPORT_RemoveDevice: Not valid device handle\n");
        return STATUS_DEVICE_NOT_CONNECTED;
    }
 
    USBPORT_RemoveDeviceHandle(FdoDevice, DeviceHandle);
 
    DeviceHandle->Flags |= DEVICE_HANDLE_FLAG_REMOVED;
 
    USBPORT_AbortTransfers(FdoDevice, DeviceHandle);
 
    DPRINT("USBPORT_RemoveDevice: DeviceHandleLock - %x\n",
           DeviceHandle->DeviceHandleLock);
 
    while (InterlockedDecrement(&DeviceHandle->DeviceHandleLock) >= 0)
    {
        InterlockedIncrement(&DeviceHandle->DeviceHandleLock);
        USBPORT_Wait(FdoDevice, 100);
    }
 
    DPRINT("USBPORT_RemoveDevice: DeviceHandleLock ok\n");
 
    if (DeviceHandle->ConfigHandle)
    {
        USBPORT_CloseConfiguration(DeviceHandle, FdoDevice);
    }
 
    USBPORT_ClosePipe(DeviceHandle, FdoDevice, &DeviceHandle->PipeHandle);
 
    if (DeviceHandle->DeviceAddress)
    {
        USBPORT_FreeUsbAddress(FdoDevice, DeviceHandle->DeviceAddress);
    }
 
    if (!IsListEmpty(&DeviceHandle->TtList))
    {
        DPRINT1("USBPORT_RemoveDevice: DeviceHandle->TtList not empty\n");
    }
 
    while (!IsListEmpty(&DeviceHandle->TtList))
    {
        TtExtension = CONTAINING_RECORD(DeviceHandle->TtList.Flink,
                                        USB2_TT_EXTENSION,
                                        Link);
 
        RemoveHeadList(&DeviceHandle->TtList);
 
        DPRINT("USBPORT_RemoveDevice: TtExtension - %p\n", TtExtension);
 
        KeAcquireSpinLock(&FdoExtension->TtSpinLock, &OldIrql);
 
        TtExtension->Flags |= USB2_TT_EXTENSION_FLAG_DELETED;
 
        if (IsListEmpty(&TtExtension->EndpointList))
        {
            USBPORT_UpdateAllocatedBwTt(TtExtension);
 
            for (ix = 0; ix < USB2_FRAMES; ix++)
            {
                FdoExtension->Bandwidth[ix] += TtExtension->MaxBandwidth;
            }
 
            DPRINT("USBPORT_RemoveDevice: ExFreePoolWithTag TtExtension - %p\n", TtExtension);
            ExFreePoolWithTag(TtExtension, USB_PORT_TAG);
        }
 
        KeReleaseSpinLock(&FdoExtension->TtSpinLock, OldIrql);
    }
 
    KeReleaseSemaphore(&FdoExtension->DeviceSemaphore,
                       LOW_REALTIME_PRIORITY,
                       1,
                       FALSE);
 
    if (!(DeviceHandle->Flags & DEVICE_HANDLE_FLAG_ROOTHUB))
    {
        ExFreePoolWithTag(DeviceHandle, USB_PORT_TAG);
    }
 
    return STATUS_SUCCESS;
}

Referenced by USBHI_RemoveUsbDevice().

USBPORT_RemoveDeviceHandle()

VOID NTAPI USBPORT_RemoveDeviceHandle	(	IN PDEVICE_OBJECT	FdoDevice,
		IN PUSBPORT_DEVICE_HANDLE	DeviceHandle
	)

Definition at line 784 of file device.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    KIRQL OldIrql;
 
    DPRINT("USBPORT_RemoveDeviceHandle \n");
 
    FdoExtension = FdoDevice->DeviceExtension;
 
    KeAcquireSpinLock(&FdoExtension->DeviceHandleSpinLock, &OldIrql);
    RemoveEntryList(&DeviceHandle->DeviceHandleLink);
    KeReleaseSpinLock(&FdoExtension->DeviceHandleSpinLock, OldIrql);
}

Referenced by USBPORT_RemoveDevice(), and USBPORT_RestoreDevice().

USBPORT_RemoveIdleIrp()

VOID NTAPI USBPORT_RemoveIdleIrp	(	IN PIO_CSQ	Csq,
		IN PIRP	Irp
	)

Definition at line 37 of file queue.c.

{
    DPRINT_QUEUE("USBPORT_RemoveIdleIrp: Irp - %p\n", Irp);
    RemoveEntryList(&Irp->Tail.Overlay.ListEntry);
}

Referenced by USBPORT_StartDevice().

USBPORT_RemovePendingTransferIrp()

PIRP NTAPI USBPORT_RemovePendingTransferIrp	(	IN PDEVICE_OBJECT	FdoDevice,
		IN PIRP	Irp
	)

Definition at line 369 of file queue.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
 
    DPRINT_CORE("USBPORT_RemovePendingTransferIrp: Irp - %p\n", Irp);
    FdoExtension = FdoDevice->DeviceExtension;
    return USBPORT_RemoveIrpFromTable(FdoExtension->PendingIrpTable, Irp);
}

Referenced by USBPORT_CancelPendingTransferIrp(), and USBPORT_FlushPendingTransfers().

USBPORT_RemovePipeHandle()

VOID NTAPI USBPORT_RemovePipeHandle	(	IN PUSBPORT_DEVICE_HANDLE	DeviceHandle,
		IN PUSBPORT_PIPE_HANDLE	PipeHandle
	)

Definition at line 456 of file endpoint.c.

{
    DPRINT("USBPORT_RemovePipeHandle: PipeHandle - %p\n", PipeHandle);
 
    RemoveEntryList(&PipeHandle->PipeLink);
 
    PipeHandle->PipeLink.Flink = NULL;
    PipeHandle->PipeLink.Blink = NULL;
}

Referenced by USBPORT_ClosePipe(), and USBPORT_RestoreDevice().

USBPORT_RemoveUSBxFdo()

VOID NTAPI USBPORT_RemoveUSBxFdo

(

IN PDEVICE_OBJECT

FdoDevice

)

Definition at line 98 of file usbport.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    KIRQL OldIrql;
 
    DPRINT("USBPORT_RemoveUSBxFdo: FdoDevice - %p\n", FdoDevice);
 
    FdoExtension = FdoDevice->DeviceExtension;
 
    KeAcquireSpinLock(&USBPORT_SpinLock, &OldIrql);
    RemoveEntryList(&FdoExtension->ControllerLink);
    KeReleaseSpinLock(&USBPORT_SpinLock, OldIrql);
 
    FdoExtension->Flags &= ~USBPORT_FLAG_REGISTERED_FDO;
 
    FdoExtension->ControllerLink.Flink = NULL;
    FdoExtension->ControllerLink.Blink = NULL;
}

USBPORT_ReopenPipe()

NTSTATUS NTAPI USBPORT_ReopenPipe	(	IN PDEVICE_OBJECT	FdoDevice,
		IN PUSBPORT_ENDPOINT	Endpoint
	)

Definition at line 1165 of file endpoint.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    PUSBPORT_COMMON_BUFFER_HEADER HeaderBuffer;
    USBPORT_ENDPOINT_REQUIREMENTS EndpointRequirements = {0};
    PUSBPORT_REGISTRATION_PACKET Packet;
    KIRQL MiniportOldIrql;
    NTSTATUS Status;
 
    DPRINT1("USBPORT_ReopenPipe ... \n");
 
    FdoExtension = FdoDevice->DeviceExtension;
    Packet = &FdoExtension->MiniPortInterface->Packet;
 
    while (TRUE)
    {
        if (!InterlockedIncrement(&Endpoint->LockCounter))
            break;
 
        InterlockedDecrement(&Endpoint->LockCounter);
        USBPORT_Wait(FdoDevice, 1);
    }
 
    KeAcquireSpinLock(&Endpoint->EndpointSpinLock, &Endpoint->EndpointOldIrql);
    KeAcquireSpinLockAtDpcLevel(&FdoExtension->MiniportSpinLock);
 
    Packet->SetEndpointState(FdoExtension->MiniPortExt,
                             Endpoint + 1,
                             USBPORT_ENDPOINT_REMOVE);
 
    KeReleaseSpinLockFromDpcLevel(&FdoExtension->MiniportSpinLock);
    KeReleaseSpinLock(&Endpoint->EndpointSpinLock, Endpoint->EndpointOldIrql);
 
    USBPORT_Wait(FdoDevice, 2);
 
    MiniportCloseEndpoint(FdoDevice, Endpoint);
 
    RtlZeroMemory(Endpoint + 1,
                  Packet->MiniPortEndpointSize);
 
    if (Endpoint->HeaderBuffer)
    {
        USBPORT_FreeCommonBuffer(FdoDevice, Endpoint->HeaderBuffer);
        Endpoint->HeaderBuffer = NULL;
    }
 
    KeAcquireSpinLock(&FdoExtension->MiniportSpinLock, &MiniportOldIrql);
 
    Packet->QueryEndpointRequirements(FdoExtension->MiniPortExt,
                                      &Endpoint->EndpointProperties,
                                      &EndpointRequirements);
 
    KeReleaseSpinLock(&FdoExtension->MiniportSpinLock, MiniportOldIrql);
 
    if (EndpointRequirements.HeaderBufferSize)
    {
        HeaderBuffer = USBPORT_AllocateCommonBuffer(FdoDevice,
                                                    EndpointRequirements.HeaderBufferSize);
    }
    else
    {
        HeaderBuffer = NULL;
    }
 
    if (HeaderBuffer || EndpointRequirements.HeaderBufferSize == 0)
    {
        Endpoint->HeaderBuffer = HeaderBuffer;
        Status = STATUS_SUCCESS;
    }
    else
    {
        Endpoint->HeaderBuffer = 0;
        Status = STATUS_INSUFFICIENT_RESOURCES;
    }
 
    if (Endpoint->HeaderBuffer && HeaderBuffer)
    {
        Endpoint->EndpointProperties.BufferVA = HeaderBuffer->VirtualAddress;
        Endpoint->EndpointProperties.BufferPA = HeaderBuffer->PhysicalAddress;
        Endpoint->EndpointProperties.BufferLength = HeaderBuffer->BufferLength;
    }
 
    if (NT_SUCCESS(Status))
    {
        MiniportOpenEndpoint(FdoDevice, Endpoint);
 
        KeAcquireSpinLock(&Endpoint->EndpointSpinLock, &Endpoint->EndpointOldIrql);
        KeAcquireSpinLockAtDpcLevel(&Endpoint->StateChangeSpinLock);
 
        if (Endpoint->StateLast == USBPORT_ENDPOINT_ACTIVE)
        {
            KeReleaseSpinLockFromDpcLevel(&Endpoint->StateChangeSpinLock);
            KeAcquireSpinLockAtDpcLevel(&FdoExtension->MiniportSpinLock);
 
            Packet->SetEndpointState(FdoExtension->MiniPortExt,
                                     Endpoint + 1,
                                     USBPORT_ENDPOINT_ACTIVE);
 
            KeReleaseSpinLockFromDpcLevel(&FdoExtension->MiniportSpinLock);
        }
        else
        {
            KeReleaseSpinLockFromDpcLevel(&Endpoint->StateChangeSpinLock);
        }
 
        KeReleaseSpinLock(&Endpoint->EndpointSpinLock, Endpoint->EndpointOldIrql);
    }
 
    InterlockedDecrement(&Endpoint->LockCounter);
 
    return Status;
}

Referenced by USBPORT_InitializeDevice().

USBPORT_RestoreDevice()

NTSTATUS NTAPI USBPORT_RestoreDevice	(	IN PDEVICE_OBJECT	FdoDevice,
		IN OUT PUSBPORT_DEVICE_HANDLE	OldDeviceHandle,
		IN OUT PUSBPORT_DEVICE_HANDLE	NewDeviceHandle
	)

Definition at line 1701 of file device.c.

{
    PUSBPORT_DEVICE_EXTENSION  FdoExtension;
    PLIST_ENTRY iHandleList;
    PUSBPORT_ENDPOINT Endpoint;
    USBPORT_ENDPOINT_REQUIREMENTS EndpointRequirements = {0};
    USB_DEFAULT_PIPE_SETUP_PACKET SetupPacket;
    NTSTATUS Status = STATUS_SUCCESS;
    USBD_STATUS USBDStatus;
    KIRQL OldIrql;
    PUSBPORT_INTERFACE_HANDLE InterfaceHandle;
    PUSBPORT_PIPE_HANDLE PipeHandle;
    PUSBPORT_REGISTRATION_PACKET Packet;
 
    DPRINT("USBPORT_RestoreDevice: OldDeviceHandle - %p, NewDeviceHandle - %p\n",
           OldDeviceHandle,
           NewDeviceHandle);
 
    FdoExtension = FdoDevice->DeviceExtension;
 
    KeWaitForSingleObject(&FdoExtension->DeviceSemaphore,
                          Executive,
                          KernelMode,
                          FALSE,
                          NULL);
 
    if (!USBPORT_ValidateDeviceHandle(FdoDevice, OldDeviceHandle))
    {
        KeReleaseSemaphore(&FdoExtension->DeviceSemaphore,
                           LOW_REALTIME_PRIORITY,
                           1,
                           FALSE);
 
#ifndef NDEBUG
        DPRINT("USBPORT_RestoreDevice: OldDeviceHandle not valid\n");
        DbgBreakPoint();
#endif
        return STATUS_DEVICE_NOT_CONNECTED;
    }
 
    if (!USBPORT_ValidateDeviceHandle(FdoDevice, NewDeviceHandle))
    {
        KeReleaseSemaphore(&FdoExtension->DeviceSemaphore,
                           LOW_REALTIME_PRIORITY,
                           1,
                           FALSE);
#ifndef NDEBUG
        DPRINT("USBPORT_RestoreDevice: NewDeviceHandle not valid\n");
        DbgBreakPoint();
#endif
        return STATUS_DEVICE_NOT_CONNECTED;
    }
 
    USBPORT_RemoveDeviceHandle(FdoDevice, OldDeviceHandle);
    USBPORT_AbortTransfers(FdoDevice, OldDeviceHandle);
 
    while (InterlockedDecrement(&OldDeviceHandle->DeviceHandleLock) >= 0)
    {
        InterlockedIncrement(&OldDeviceHandle->DeviceHandleLock);
        USBPORT_Wait(FdoDevice, 100);
    }
 
    if (sizeof(USB_DEVICE_DESCRIPTOR) == RtlCompareMemory(&NewDeviceHandle->DeviceDescriptor,
                                                          &OldDeviceHandle->DeviceDescriptor,
                                                          sizeof(USB_DEVICE_DESCRIPTOR)))
    {
        NewDeviceHandle->ConfigHandle = OldDeviceHandle->ConfigHandle;
 
        if (OldDeviceHandle->ConfigHandle)
        {
            RtlZeroMemory(&SetupPacket, sizeof(USB_DEFAULT_PIPE_SETUP_PACKET));
 
            SetupPacket.bmRequestType.Dir = BMREQUEST_HOST_TO_DEVICE;
            SetupPacket.bRequest = USB_REQUEST_SET_CONFIGURATION;
            SetupPacket.wValue.W = OldDeviceHandle->ConfigHandle->ConfigurationDescriptor->bConfigurationValue;
            SetupPacket.wIndex.W = 0;
            SetupPacket.wLength = 0;
 
            USBPORT_SendSetupPacket(NewDeviceHandle,
                                    FdoDevice,
                                    &SetupPacket,
                                    NULL,
                                    0,
                                    NULL,
                                    &USBDStatus);
 
            if (USBD_ERROR(USBDStatus))
                Status = USBPORT_USBDStatusToNtStatus(NULL, USBDStatus);
 
            if (NT_SUCCESS(Status))
            {
                iHandleList = NewDeviceHandle->ConfigHandle->InterfaceHandleList.Flink;
 
                while (iHandleList &&
                       iHandleList != &NewDeviceHandle->ConfigHandle->InterfaceHandleList)
                {
                    InterfaceHandle = CONTAINING_RECORD(iHandleList,
                                                        USBPORT_INTERFACE_HANDLE,
                                                        InterfaceLink);
 
                    if (InterfaceHandle->AlternateSetting)
                    {
                        RtlZeroMemory(&SetupPacket, sizeof(USB_DEFAULT_PIPE_SETUP_PACKET));
 
                        SetupPacket.bmRequestType.Dir = BMREQUEST_HOST_TO_DEVICE;
                        SetupPacket.bmRequestType.Type = BMREQUEST_STANDARD;
                        SetupPacket.bmRequestType.Recipient = BMREQUEST_TO_INTERFACE;
 
                        SetupPacket.bRequest = USB_REQUEST_SET_INTERFACE;
                        SetupPacket.wValue.W = InterfaceHandle->InterfaceDescriptor.bAlternateSetting;
                        SetupPacket.wIndex.W = InterfaceHandle->InterfaceDescriptor.bInterfaceNumber;
                        SetupPacket.wLength = 0;
 
                        USBPORT_SendSetupPacket(NewDeviceHandle,
                                                FdoDevice,
                                                &SetupPacket,
                                                NULL,
                                                0,
                                                NULL,
                                                &USBDStatus);
                    }
 
                    iHandleList = iHandleList->Flink;
                }
            }
        }
 
        if (NewDeviceHandle->Flags & DEVICE_HANDLE_FLAG_USB2HUB)
        {
            DPRINT1("USBPORT_RestoreDevice: FIXME Transaction Translator\n");
            NewDeviceHandle->TtCount = OldDeviceHandle->TtCount;
 
#ifndef NDEBUG
            DbgBreakPoint();
#endif
        }
 
        while (!IsListEmpty(&OldDeviceHandle->PipeHandleList))
        {
            PipeHandle = CONTAINING_RECORD(OldDeviceHandle->PipeHandleList.Flink,
                                           USBPORT_PIPE_HANDLE,
                                           PipeLink);
 
            DPRINT("USBPORT_RestoreDevice: PipeHandle - %p\n", PipeHandle);
 
            USBPORT_RemovePipeHandle(OldDeviceHandle, PipeHandle);
 
            if (PipeHandle != &OldDeviceHandle->PipeHandle)
            {
                USBPORT_AddPipeHandle(NewDeviceHandle, PipeHandle);
 
                if (!(PipeHandle->Flags & PIPE_HANDLE_FLAG_NULL_PACKET_SIZE))
                {
                    Endpoint = PipeHandle->Endpoint;
                    Endpoint->DeviceHandle = NewDeviceHandle;
                    Endpoint->EndpointProperties.DeviceAddress = NewDeviceHandle->DeviceAddress;
 
                    Packet = &FdoExtension->MiniPortInterface->Packet;
 
                    if (!(Endpoint->Flags & ENDPOINT_FLAG_NUKE))
                    {
                        KeAcquireSpinLock(&FdoExtension->MiniportSpinLock,
                                          &OldIrql);
 
                        Packet->ReopenEndpoint(FdoExtension->MiniPortExt,
                                               &Endpoint->EndpointProperties,
                                               Endpoint + 1);
 
                        Packet->SetEndpointDataToggle(FdoExtension->MiniPortExt,
                                                      Endpoint + 1,
                                                      0);
 
                        Packet->SetEndpointStatus(FdoExtension->MiniPortExt,
                                                  Endpoint + 1,
                                                  USBPORT_ENDPOINT_RUN);
 
                        KeReleaseSpinLock(&FdoExtension->MiniportSpinLock,
                                          OldIrql);
                    }
                    else
                    {
                        MiniportCloseEndpoint(FdoDevice, Endpoint);
 
                        RtlZeroMemory(Endpoint + 1, Packet->MiniPortEndpointSize);
 
                        RtlZeroMemory((PVOID)Endpoint->EndpointProperties.BufferVA,
                                      Endpoint->EndpointProperties.BufferLength);
 
                        KeAcquireSpinLock(&FdoExtension->MiniportSpinLock, &OldIrql);
 
                        Packet->QueryEndpointRequirements(FdoExtension->MiniPortExt,
                                                          &Endpoint->EndpointProperties,
                                                          &EndpointRequirements);
 
                        KeReleaseSpinLock(&FdoExtension->MiniportSpinLock,
                                          OldIrql);
 
                        MiniportOpenEndpoint(FdoDevice, Endpoint);
 
                        Endpoint->Flags &= ~(ENDPOINT_FLAG_NUKE |
                                             ENDPOINT_FLAG_ABORTING);
 
                        KeAcquireSpinLock(&Endpoint->EndpointSpinLock,
                                          &Endpoint->EndpointOldIrql);
 
                        if (Endpoint->StateLast == USBPORT_ENDPOINT_ACTIVE)
                        {
                            KeAcquireSpinLockAtDpcLevel(&FdoExtension->MiniportSpinLock);
 
                            Packet->SetEndpointState(FdoExtension->MiniPortExt,
                                                     Endpoint + 1,
                                                     USBPORT_ENDPOINT_ACTIVE);
 
                            KeReleaseSpinLockFromDpcLevel(&FdoExtension->MiniportSpinLock);
                        }
 
                        KeReleaseSpinLock(&Endpoint->EndpointSpinLock,
                                          Endpoint->EndpointOldIrql);
                    }
                }
            }
        }
 
        USBPORT_AddPipeHandle(OldDeviceHandle, &OldDeviceHandle->PipeHandle);
    }
    else
    {
#ifndef NDEBUG
        DPRINT("USBPORT_RestoreDevice: New DeviceDescriptor != Old DeviceDescriptor\n");
        DbgBreakPoint();
#endif
        Status = STATUS_UNSUCCESSFUL;
    }
 
    USBPORT_ClosePipe(OldDeviceHandle, FdoDevice, &OldDeviceHandle->PipeHandle);
 
    if (OldDeviceHandle->DeviceAddress != 0)
        USBPORT_FreeUsbAddress(FdoDevice, OldDeviceHandle->DeviceAddress);
 
    KeReleaseSemaphore(&FdoExtension->DeviceSemaphore,
                       LOW_REALTIME_PRIORITY,
                       1,
                       FALSE);
 
    ExFreePoolWithTag(OldDeviceHandle, USB_PORT_TAG);
 
    return Status;
}

Referenced by USBHI_RestoreUsbDevice().

USBPORT_RootHubCreateDevice()

NTSTATUS NTAPI USBPORT_RootHubCreateDevice	(	IN PDEVICE_OBJECT	FdoDevice,
		IN PDEVICE_OBJECT	PdoDevice
	)

Definition at line 747 of file roothub.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    PUSBPORT_RHDEVICE_EXTENSION PdoExtension;
    PUSBPORT_REGISTRATION_PACKET Packet;
    PUSBPORT_DEVICE_HANDLE DeviceHandle;
    USBPORT_ROOT_HUB_DATA RootHubData;
    ULONG NumMaskByte;
    ULONG DescriptorsLength;
    PUSBPORT_RH_DESCRIPTORS Descriptors;
    PUSB_DEVICE_DESCRIPTOR RH_DeviceDescriptor;
    PUSB_CONFIGURATION_DESCRIPTOR RH_ConfigurationDescriptor;
    PUSB_INTERFACE_DESCRIPTOR RH_InterfaceDescriptor;
    PUSB_ENDPOINT_DESCRIPTOR RH_EndPointDescriptor;
    PUSB_HUB_DESCRIPTOR RH_HubDescriptor;
    ULONG ix;
    PUSB_ENDPOINT_DESCRIPTOR EndpointDescriptor;
    NTSTATUS Status;
 
    DPRINT("USBPORT_RootHubCreateDevice: FdoDevice - %p, PdoDevice - %p\n",
           FdoDevice,
           PdoDevice);
 
    FdoExtension = FdoDevice->DeviceExtension;
    PdoExtension = PdoDevice->DeviceExtension;
    Packet = &FdoExtension->MiniPortInterface->Packet;
 
    DeviceHandle = &PdoExtension->DeviceHandle;
    USBPORT_AddDeviceHandle(FdoDevice, DeviceHandle);
 
    InitializeListHead(&DeviceHandle->PipeHandleList);
 
    DeviceHandle->IsRootHub = TRUE;
    DeviceHandle->DeviceSpeed = UsbFullSpeed;
    DeviceHandle->Flags = DEVICE_HANDLE_FLAG_ROOTHUB;
 
    RtlZeroMemory(&RootHubData, sizeof(RootHubData));
 
    Packet->RH_GetRootHubData(FdoExtension->MiniPortExt, &RootHubData);
 
    ASSERT(RootHubData.NumberOfPorts != 0);
    NumMaskByte = (RootHubData.NumberOfPorts - 1) / 8 + 1;
 
    DescriptorsLength = sizeof(USB_DEVICE_DESCRIPTOR) +
                        sizeof(USB_CONFIGURATION_DESCRIPTOR) +
                        sizeof(USB_INTERFACE_DESCRIPTOR) +
                        sizeof(USB_ENDPOINT_DESCRIPTOR) +
                        (sizeof(USB_HUB_DESCRIPTOR) + 2 * NumMaskByte);
 
    Descriptors = ExAllocatePoolWithTag(NonPagedPool,
                                        DescriptorsLength,
                                        USB_PORT_TAG);
 
    if (Descriptors)
    {
        RtlZeroMemory(Descriptors, DescriptorsLength);
 
        PdoExtension->RootHubDescriptors = Descriptors;
 
        RH_DeviceDescriptor = &PdoExtension->RootHubDescriptors->DeviceDescriptor;
 
        RH_DeviceDescriptor->bLength = sizeof(USB_DEVICE_DESCRIPTOR);
        RH_DeviceDescriptor->bDescriptorType = USB_DEVICE_DESCRIPTOR_TYPE;
        RH_DeviceDescriptor->bcdUSB = 0x100;
        RH_DeviceDescriptor->bDeviceClass = USB_DEVICE_CLASS_HUB;
        RH_DeviceDescriptor->bDeviceSubClass = 0x01;
        RH_DeviceDescriptor->bDeviceProtocol = 0x00;
        RH_DeviceDescriptor->bMaxPacketSize0 = 0x08;
        RH_DeviceDescriptor->idVendor = FdoExtension->VendorID;
        RH_DeviceDescriptor->idProduct = FdoExtension->DeviceID;
        RH_DeviceDescriptor->bcdDevice = FdoExtension->RevisionID;
        RH_DeviceDescriptor->iManufacturer = 0x00;
        RH_DeviceDescriptor->iProduct = 0x00;
        RH_DeviceDescriptor->iSerialNumber = 0x00;
        RH_DeviceDescriptor->bNumConfigurations = 0x01;
 
        RH_ConfigurationDescriptor = &PdoExtension->RootHubDescriptors->ConfigDescriptor;
 
        RH_ConfigurationDescriptor->bLength = sizeof(USB_CONFIGURATION_DESCRIPTOR);
        RH_ConfigurationDescriptor->bDescriptorType = USB_CONFIGURATION_DESCRIPTOR_TYPE;
 
        RH_ConfigurationDescriptor->wTotalLength = sizeof(USB_CONFIGURATION_DESCRIPTOR) +
                                                   sizeof(USB_INTERFACE_DESCRIPTOR) +
                                                   sizeof(USB_ENDPOINT_DESCRIPTOR);
 
        RH_ConfigurationDescriptor->bNumInterfaces = 0x01;
        RH_ConfigurationDescriptor->bConfigurationValue = 0x01;
        RH_ConfigurationDescriptor->iConfiguration = 0x00;
        RH_ConfigurationDescriptor->bmAttributes = USB_CONFIG_SELF_POWERED;
        RH_ConfigurationDescriptor->MaxPower = 0x00;
 
        RH_InterfaceDescriptor = &PdoExtension->RootHubDescriptors->InterfaceDescriptor;
 
        RH_InterfaceDescriptor->bLength = sizeof(USB_INTERFACE_DESCRIPTOR);
        RH_InterfaceDescriptor->bDescriptorType = USB_INTERFACE_DESCRIPTOR_TYPE;
        RH_InterfaceDescriptor->bInterfaceNumber = 0x00;
        RH_InterfaceDescriptor->bAlternateSetting = 0x00;
        RH_InterfaceDescriptor->bNumEndpoints = 0x01;
        RH_InterfaceDescriptor->bInterfaceClass = USB_DEVICE_CLASS_HUB;
        RH_InterfaceDescriptor->bInterfaceSubClass = 0x01;
        RH_InterfaceDescriptor->bInterfaceProtocol = 0x00;
        RH_InterfaceDescriptor->iInterface = 0x00;
 
        RH_EndPointDescriptor = &PdoExtension->RootHubDescriptors->EndPointDescriptor;
 
        RH_EndPointDescriptor->bLength = sizeof(USB_ENDPOINT_DESCRIPTOR);
        RH_EndPointDescriptor->bDescriptorType = USB_ENDPOINT_DESCRIPTOR_TYPE;
        RH_EndPointDescriptor->bEndpointAddress = 0x81;
        RH_EndPointDescriptor->bmAttributes = USB_ENDPOINT_TYPE_INTERRUPT; // SCE endpoint
        RH_EndPointDescriptor->wMaxPacketSize = 0x0008;
        RH_EndPointDescriptor->bInterval = 0x0C; // 12 msec
 
        RH_HubDescriptor = &PdoExtension->RootHubDescriptors->Descriptor;
 
        RH_HubDescriptor->bDescriptorLength = FIELD_OFFSET(USB_HUB_DESCRIPTOR, bRemoveAndPowerMask) + 2 * NumMaskByte;
 
        if (Packet->MiniPortVersion == USB_MINIPORT_VERSION_OHCI ||
            Packet->MiniPortVersion == USB_MINIPORT_VERSION_UHCI ||
            Packet->MiniPortVersion == USB_MINIPORT_VERSION_EHCI)
        {
            RH_HubDescriptor->bDescriptorType = USB_20_HUB_DESCRIPTOR_TYPE;
        }
        else if (Packet->MiniPortVersion == USB_MINIPORT_VERSION_XHCI)
        {
            RH_HubDescriptor->bDescriptorType = USB_30_HUB_DESCRIPTOR_TYPE;
        }
        else
        {
            DPRINT1("USBPORT_RootHubCreateDevice: Unknown MiniPortVersion - %x\n",
                    Packet->MiniPortVersion);
 
            DbgBreakPoint();
        }
 
        RH_HubDescriptor->bNumberOfPorts = RootHubData.NumberOfPorts;
        RH_HubDescriptor->wHubCharacteristics = RootHubData.HubCharacteristics.AsUSHORT;
        RH_HubDescriptor->bPowerOnToPowerGood = RootHubData.PowerOnToPowerGood;
        RH_HubDescriptor->bHubControlCurrent = RootHubData.HubControlCurrent;
 
        for (ix = 0; ix < NumMaskByte; ix += 2)
        {
            RH_HubDescriptor->bRemoveAndPowerMask[ix] = 0;
            RH_HubDescriptor->bRemoveAndPowerMask[ix + 1] = -1;
        }
 
        EndpointDescriptor = &DeviceHandle->PipeHandle.EndpointDescriptor;
 
        EndpointDescriptor->bLength = sizeof(USB_ENDPOINT_DESCRIPTOR);
        EndpointDescriptor->bDescriptorType = USB_ENDPOINT_DESCRIPTOR_TYPE;
        EndpointDescriptor->bEndpointAddress = 0x00;
        EndpointDescriptor->bmAttributes = USB_ENDPOINT_TYPE_CONTROL;
        EndpointDescriptor->wMaxPacketSize = 0x0040;
        EndpointDescriptor->bInterval = 0x00;
 
        Status = USBPORT_OpenPipe(FdoDevice,
                                  DeviceHandle,
                                  &DeviceHandle->PipeHandle,
                                  NULL);
    }
    else
    {
        Status = STATUS_INSUFFICIENT_RESOURCES;
    }
 
    return Status;
}

Referenced by USBPORT_PdoPnP().

USBPORT_RootHubEndpointWorker()

VOID NTAPI USBPORT_RootHubEndpointWorker

(

PUSBPORT_ENDPOINT

Endpoint

)

USBPORT_RootHubPowerAndChirpAllCcPorts()

VOID NTAPI USBPORT_RootHubPowerAndChirpAllCcPorts

(

IN PDEVICE_OBJECT

FdoDevice

)

Definition at line 963 of file roothub.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    PUSBPORT_REGISTRATION_PACKET Packet;
    USBPORT_ROOT_HUB_DATA RootHubData;
    ULONG Port;
    PDEVICE_RELATIONS CompanionControllersList;
    PUSBPORT_DEVICE_EXTENSION CompanionFdoExtension;
    PUSBPORT_REGISTRATION_PACKET CompanionPacket;
    ULONG CompanionPorts;
    ULONG NumController;
    PDEVICE_OBJECT * Entry;
    ULONG NumPorts;
 
    DPRINT("USBPORT_RootHub_PowerAndChirpAllCcPorts: FdoDevice - %p\n",
           FdoDevice);
 
    FdoExtension = FdoDevice->DeviceExtension;
 
    Packet = &FdoExtension->MiniPortInterface->Packet;
 
    RtlZeroMemory(&RootHubData, sizeof(RootHubData));
 
    Packet->RH_GetRootHubData(FdoExtension->MiniPortExt,
                              &RootHubData);
 
    NumPorts = RootHubData.NumberOfPorts;
 
    for (Port = 1; Port <= NumPorts; ++Port)
    {
        Packet->RH_SetFeaturePortPower(FdoExtension->MiniPortExt, Port);
    }
 
    USBPORT_Wait(FdoDevice, 10);
 
    CompanionControllersList = USBPORT_FindCompanionControllers(FdoDevice,
                                                                FALSE,
                                                                TRUE);
 
    if (CompanionControllersList)
    {
        Entry = &CompanionControllersList->Objects[0];
 
        for (NumController = 0;
             NumController < CompanionControllersList->Count;
             NumController++)
        {
            CompanionPacket = &FdoExtension->MiniPortInterface->Packet;
 
            CompanionFdoExtension = (*Entry)->DeviceExtension;
 
            CompanionPacket->RH_GetRootHubData(CompanionFdoExtension->MiniPortExt,
                                               &RootHubData);
 
            CompanionPorts = RootHubData.NumberOfPorts;
 
            for (Port = 1; Port <= CompanionPorts; ++Port)
            {
                CompanionPacket->RH_SetFeaturePortPower(CompanionFdoExtension->MiniPortExt,
                                                        Port);
            }
 
            ++Entry;
        }
 
        ExFreePoolWithTag(CompanionControllersList, USB_PORT_TAG);
    }
 
    USBPORT_Wait(FdoDevice, 100);
 
    for (Port = 1; Port <= NumPorts; ++Port)
    {
        if (FdoExtension->MiniPortInterface->Version < 200)
        {
            break;
        }
 
        InterlockedIncrement((PLONG)&FdoExtension->ChirpRootPortLock);
        Packet->RH_ChirpRootPort(FdoExtension->MiniPortExt, Port);
        InterlockedDecrement((PLONG)&FdoExtension->ChirpRootPortLock);
    }
}

Referenced by USBPORT_SynchronizeRootHubCallback().

USBPORT_SendSetupPacket()

NTSTATUS NTAPI USBPORT_SendSetupPacket	(	IN PUSBPORT_DEVICE_HANDLE	DeviceHandle,
		IN PDEVICE_OBJECT	FdoDevice,
		IN PUSB_DEFAULT_PIPE_SETUP_PACKET	SetupPacket,
		IN PVOID	Buffer,
		IN ULONG	Length,
		IN OUT PULONG	TransferedLen,
		IN OUT PUSBD_STATUS	pUSBDStatus
	)

Definition at line 15 of file device.c.

{
    PURB Urb;
    PMDL Mdl;
    USBD_STATUS USBDStatus;
    KEVENT Event;
    NTSTATUS Status;
 
    DPRINT("USBPORT_SendSetupPacket: DeviceHandle - %p, FdoDevice - %p, SetupPacket - %p, Buffer - %p, Length - %x, TransferedLen - %x, pUSBDStatus - %x\n",
           DeviceHandle,
           FdoDevice,
           SetupPacket,
           Buffer,
           Length,
           TransferedLen,
           pUSBDStatus);
 
    KeInitializeEvent(&Event, NotificationEvent, FALSE);
 
    Urb = ExAllocatePoolWithTag(NonPagedPool,
                                sizeof(struct _URB_CONTROL_TRANSFER),
                                USB_PORT_TAG);
 
    if (Urb)
    {
        InterlockedIncrement(&DeviceHandle->DeviceHandleLock);
 
        RtlZeroMemory(Urb, sizeof(struct _URB_CONTROL_TRANSFER));
 
        RtlCopyMemory(Urb->UrbControlTransfer.SetupPacket,
                      SetupPacket,
                      sizeof(USB_DEFAULT_PIPE_SETUP_PACKET));
 
        Urb->UrbHeader.Length = sizeof(struct _URB_CONTROL_TRANSFER);
        Urb->UrbHeader.Function = URB_FUNCTION_CONTROL_TRANSFER;
        Urb->UrbHeader.UsbdDeviceHandle = DeviceHandle;
        Urb->UrbHeader.UsbdFlags = 0;
 
        Urb->UrbControlTransfer.PipeHandle = &DeviceHandle->PipeHandle;
        Urb->UrbControlTransfer.TransferBufferLength = Length;
        Urb->UrbControlTransfer.TransferBuffer = Buffer;
        Urb->UrbControlTransfer.TransferBufferMDL = NULL;
 
        Urb->UrbControlTransfer.TransferFlags = USBD_SHORT_TRANSFER_OK |
                                                USBD_TRANSFER_DIRECTION;
 
        if (SetupPacket->bmRequestType.Dir != BMREQUEST_DEVICE_TO_HOST)
        {
            Urb->UrbControlTransfer.TransferFlags &= ~USBD_TRANSFER_DIRECTION_IN;
        }
 
        Status = STATUS_SUCCESS;
 
        if (Length)
        {
            Mdl = IoAllocateMdl(Buffer, Length, FALSE, FALSE, NULL);
 
            Urb->UrbControlTransfer.TransferBufferMDL = Mdl;
 
            if (Mdl)
            {
                Urb->UrbHeader.UsbdFlags |= USBD_FLAG_ALLOCATED_MDL;
                MmBuildMdlForNonPagedPool(Mdl);
            }
            else
            {
                Status = USBPORT_USBDStatusToNtStatus(NULL,
                                                      USBD_STATUS_INSUFFICIENT_RESOURCES);
            }
        }
 
        if (NT_SUCCESS(Status))
        {
            USBDStatus = USBPORT_AllocateTransfer(FdoDevice,
                                                  Urb,
                                                  NULL,
                                                  NULL,
                                                  &Event);
 
            if (USBD_SUCCESS(USBDStatus))
            {
                InterlockedIncrement(&DeviceHandle->DeviceHandleLock);
 
                USBPORT_QueueTransferUrb(Urb);
 
                KeWaitForSingleObject(&Event,
                                      Suspended,
                                      KernelMode,
                                      FALSE,
                                      NULL);
 
                USBDStatus = Urb->UrbHeader.Status;
            }
 
            Status = USBPORT_USBDStatusToNtStatus(Urb, USBDStatus);
 
            if (TransferedLen)
                *TransferedLen = Urb->UrbControlTransfer.TransferBufferLength;
 
            if (pUSBDStatus)
                *pUSBDStatus = USBDStatus;
        }
 
        InterlockedDecrement(&DeviceHandle->DeviceHandleLock);
        ExFreePoolWithTag(Urb, USB_PORT_TAG);
    }
    else
    {
        if (pUSBDStatus)
            *pUSBDStatus = USBD_STATUS_INSUFFICIENT_RESOURCES;
 
        Status = USBPORT_USBDStatusToNtStatus(NULL,
                                              USBD_STATUS_INSUFFICIENT_RESOURCES);
    }
 
    DPRINT("USBPORT_SendSetupPacket: Status - %x\n", Status);
    return Status;
}

Referenced by USBPORT_ClearStall(), USBPORT_CreateDevice(), USBPORT_GetUsbDescriptor(), USBPORT_HandleSelectConfiguration(), USBPORT_InitializeDevice(), USBPORT_OpenInterface(), and USBPORT_RestoreDevice().

USBPORT_SetEndpointState()

VOID NTAPI USBPORT_SetEndpointState	(	IN PUSBPORT_ENDPOINT	Endpoint,
		IN ULONG	State
	)

Definition at line 363 of file endpoint.c.

{
    PDEVICE_OBJECT FdoDevice;
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    PUSBPORT_REGISTRATION_PACKET Packet;
    KIRQL OldIrql;
 
    DPRINT("USBPORT_SetEndpointState: Endpoint - %p, State - %x\n",
           Endpoint,
           State);
 
    FdoDevice = Endpoint->FdoDevice;
    FdoExtension = FdoDevice->DeviceExtension;
    Packet = &FdoExtension->MiniPortInterface->Packet;
 
    KeAcquireSpinLock(&Endpoint->StateChangeSpinLock,
                      &Endpoint->EndpointStateOldIrql);
 
    if (!(Endpoint->Flags & ENDPOINT_FLAG_ROOTHUB_EP0))
    {
        if (Endpoint->Flags & ENDPOINT_FLAG_NUKE)
        {
            Endpoint->StateLast = State;
            Endpoint->StateNext = State;
 
            KeReleaseSpinLock(&Endpoint->StateChangeSpinLock,
                              Endpoint->EndpointStateOldIrql);
 
            USBPORT_InvalidateEndpointHandler(FdoDevice,
                                              Endpoint,
                                              INVALIDATE_ENDPOINT_WORKER_THREAD);
            return;
        }
 
        KeReleaseSpinLock(&Endpoint->StateChangeSpinLock,
                          Endpoint->EndpointStateOldIrql);
 
        KeAcquireSpinLock(&FdoExtension->MiniportSpinLock, &OldIrql);
        Packet->SetEndpointState(FdoExtension->MiniPortExt,
                                 Endpoint + 1,
                                 State);
        KeReleaseSpinLock(&FdoExtension->MiniportSpinLock, OldIrql);
 
        Endpoint->StateNext = State;
 
        KeAcquireSpinLock(&FdoExtension->MiniportSpinLock, &OldIrql);
        Endpoint->FrameNumber = Packet->Get32BitFrameNumber(FdoExtension->MiniPortExt);
        KeReleaseSpinLock(&FdoExtension->MiniportSpinLock, OldIrql);
 
        ExInterlockedInsertTailList(&FdoExtension->EpStateChangeList,
                                    &Endpoint->StateChangeLink,
                                    &FdoExtension->EpStateChangeSpinLock);
 
        KeAcquireSpinLock(&FdoExtension->MiniportSpinLock, &OldIrql);
        Packet->InterruptNextSOF(FdoExtension->MiniPortExt);
        KeReleaseSpinLock(&FdoExtension->MiniportSpinLock, OldIrql);
    }
    else
    {
        Endpoint->StateLast = State;
        Endpoint->StateNext = State;
 
        if (State == USBPORT_ENDPOINT_REMOVE)
        {
            KeReleaseSpinLock(&Endpoint->StateChangeSpinLock,
                              Endpoint->EndpointStateOldIrql);
 
            USBPORT_InvalidateEndpointHandler(FdoDevice,
                                              Endpoint,
                                              INVALIDATE_ENDPOINT_WORKER_THREAD);
            return;
        }
 
        KeReleaseSpinLock(&Endpoint->StateChangeSpinLock,
                          Endpoint->EndpointStateOldIrql);
    }
}

Referenced by USBPORT_ClosePipe(), USBPORT_DmaEndpointWorker(), USBPORT_OpenPipe(), and USBPORT_SyncResetPipeAndClearStall().

USBPORT_SetRegistryKeyValue()

NTSTATUS NTAPI USBPORT_SetRegistryKeyValue	(	IN PDEVICE_OBJECT	DeviceObject,
		IN BOOL	UseDriverKey,
		IN ULONG	Type,
		IN PCWSTR	ValueNameString,
		IN PVOID	Data,
		IN ULONG	DataSize
	)

Definition at line 248 of file usbport.c.

{
    UNICODE_STRING ValueName;
    HANDLE KeyHandle;
    NTSTATUS Status;
 
    DPRINT("USBPORT_SetRegistryKeyValue: ValueNameString - %S\n",
           ValueNameString);
 
    if (UseDriverKey)
    {
        Status = IoOpenDeviceRegistryKey(DeviceObject,
                                         PLUGPLAY_REGKEY_DRIVER,
                                         STANDARD_RIGHTS_ALL,
                                         &KeyHandle);
    }
    else
    {
        Status = IoOpenDeviceRegistryKey(DeviceObject,
                                         PLUGPLAY_REGKEY_DEVICE,
                                         STANDARD_RIGHTS_ALL,
                                         &KeyHandle);
    }
 
    if (NT_SUCCESS(Status))
    {
        RtlInitUnicodeString(&ValueName, ValueNameString);
 
        Status = ZwSetValueKey(KeyHandle,
                               &ValueName,
                               0,
                               Type,
                               Data,
                               DataSize);
 
        ZwClose(KeyHandle);
    }
 
    return Status;
}

Referenced by USBHI_ControllerSelectiveSuspend(), USBPORT_RegisterDeviceInterface(), and USBPORT_StartDevice().

USBPORT_SignalWorkerThread()

VOID NTAPI USBPORT_SignalWorkerThread

(

IN PDEVICE_OBJECT

FdoDevice

)

Definition at line 1111 of file usbport.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    KIRQL OldIrql;
 
    DPRINT_CORE("USBPORT_SignalWorkerThread ...\n");
 
    FdoExtension = FdoDevice->DeviceExtension;
 
    KeAcquireSpinLock(&FdoExtension->WorkerThreadEventSpinLock, &OldIrql);
    KeSetEvent(&FdoExtension->WorkerThreadEvent, EVENT_INCREMENT, FALSE);
    KeReleaseSpinLock(&FdoExtension->WorkerThreadEventSpinLock, OldIrql);
}

Referenced by USBPORT_ClosePipe(), USBPORT_DpcHandler(), USBPORT_InvalidateEndpointHandler(), USBPORT_StopWorkerThread(), USBPORT_SynchronizeControllersStart(), USBPORT_SynchronizeRootHubCallback(), and USBPORT_WorkerThreadHandler().

USBPORT_SplitTransfer()

VOID NTAPI USBPORT_SplitTransfer	(	IN PDEVICE_OBJECT	FdoDevice,
		IN PUSBPORT_ENDPOINT	Endpoint,
		IN PUSBPORT_TRANSFER	Transfer,
		IN PLIST_ENTRY	List
	)

Definition at line 232 of file trfsplit.c.

{
    ULONG TransferType;
 
    DPRINT("USBPORT_SplitTransfer ... \n");
 
    InitializeListHead(List);
    InitializeListHead(&Transfer->SplitTransfersList);
 
    Transfer->USBDStatus = USBD_STATUS_SUCCESS;
 
    if (Transfer->TransferParameters.TransferBufferLength >
        Endpoint->EndpointProperties.MaxTransferSize)
    {
        TransferType = Endpoint->EndpointProperties.TransferType;
 
        if (TransferType == USBPORT_TRANSFER_TYPE_BULK ||
            TransferType == USBPORT_TRANSFER_TYPE_INTERRUPT)
        {
            USBPORT_SplitBulkInterruptTransfer(FdoDevice,
                                               Endpoint,
                                               Transfer,
                                               List);
        }
        else if (TransferType == USBPORT_TRANSFER_TYPE_ISOCHRONOUS ||
                 TransferType == USBPORT_TRANSFER_TYPE_CONTROL)
        {
            KeBugCheckEx(BUGCODE_USB_DRIVER, 1, 0, 0, 0);
        }
        else
        {
            DPRINT1("USBPORT_SplitTransfer: Unknown TransferType - %x\n",
                    TransferType);
        }
    }
    else
    {
        InsertTailList(List, &Transfer->TransferLink);
    }
}

Referenced by USBPORT_MapTransfer().

USBPORT_StartTimer()

BOOLEAN NTAPI USBPORT_StartTimer	(	IN PDEVICE_OBJECT	FdoDevice,
		IN ULONG	Time
	)

Definition at line 1675 of file usbport.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    LARGE_INTEGER DueTime = {{0, 0}};
    ULONG TimeIncrement;
    BOOLEAN Result;
 
    DPRINT_TIMER("USBPORT_StartTimer: FdoDevice - %p, Time - %x\n",
           FdoDevice,
           Time);
 
    FdoExtension = FdoDevice->DeviceExtension;
 
    TimeIncrement = KeQueryTimeIncrement();
 
    FdoExtension->TimerFlags |= USBPORT_TMFLAG_TIMER_QUEUED;
    FdoExtension->TimerValue = Time;
 
    KeInitializeTimer(&FdoExtension->TimerObject);
    KeInitializeDpc(&FdoExtension->TimerDpc, USBPORT_TimerDpc, FdoDevice);
 
    DueTime.QuadPart -= 10000 * Time + (TimeIncrement - 1);
 
    Result = KeSetTimer(&FdoExtension->TimerObject,
                        DueTime,
                        &FdoExtension->TimerDpc);
 
    return Result;
}

Referenced by USBPORT_StartDevice().

USBPORT_StopWorkerThread()

VOID NTAPI USBPORT_StopWorkerThread

(

IN PDEVICE_OBJECT

FdoDevice

)

Definition at line 1455 of file usbport.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    NTSTATUS Status;
 
    DPRINT("USBPORT_StopWorkerThread ...\n");
 
    FdoExtension = FdoDevice->DeviceExtension;
 
    FdoExtension->Flags |= USBPORT_FLAG_WORKER_THREAD_EXIT;
    USBPORT_SignalWorkerThread(FdoDevice);
    Status = ZwWaitForSingleObject(FdoExtension->WorkerThreadHandle, FALSE, NULL);
    NT_ASSERT(Status == STATUS_SUCCESS);
}

Referenced by USBPORT_StartDevice().

USBPORT_TestDebugBreak()

ULONG NTAPI USBPORT_TestDebugBreak

(

IN PVOID

MiniPortExtension

)

Definition at line 30 of file debug.c.

{
    DPRINT("USBPORT_TestDebugBreak: UNIMPLEMENTED. FIXME. \n");
    return 0;
}

Referenced by USBPORT_RegisterUSBPortDriver().

USBPORT_TransferFlushDpc()

VOID NTAPI USBPORT_TransferFlushDpc	(	IN PRKDPC	Dpc,
		IN PVOID	DeferredContext,
		IN PVOID	SystemArgument1,
		IN PVOID	SystemArgument2
	)

Definition at line 825 of file usbport.c.

{
    PDEVICE_OBJECT FdoDevice;
 
    DPRINT_CORE("USBPORT_TransferFlushDpc: ...\n");
    FdoDevice = DeferredContext;
    USBPORT_FlushDoneTransfers(FdoDevice);
}

Referenced by USBPORT_StartDevice().

USBPORT_UpdateAllocatedBwTt()

VOID NTAPI USBPORT_UpdateAllocatedBwTt

(

IN PUSB2_TT_EXTENSION

TtExtension

)

Definition at line 1768 of file usb2.c.

{
    ULONG BusBandwidth;
    ULONG NewBusBandwidth;
    ULONG MaxBusBandwidth = 0;
    ULONG MinBusBandwidth;
    ULONG ix;
 
    DPRINT("USBPORT_UpdateAllocatedBwTt: TtExtension - %p\n", TtExtension);
 
    BusBandwidth = TtExtension->BusBandwidth;
    MinBusBandwidth = BusBandwidth;
 
    for (ix = 0; ix < USB2_FRAMES; ix++)
    {
        NewBusBandwidth = BusBandwidth - TtExtension->Bandwidth[ix];
 
        MaxBusBandwidth = max(MaxBusBandwidth, NewBusBandwidth);
        MinBusBandwidth = min(MinBusBandwidth, NewBusBandwidth);
    }
 
    TtExtension->MaxBandwidth = MaxBusBandwidth;
 
    if (MinBusBandwidth == BusBandwidth)
        TtExtension->MinBandwidth = 0;
    else
        TtExtension->MinBandwidth = MinBusBandwidth;
}

Referenced by USBPORT_AllocateBandwidthUSB2(), USBPORT_ClosePipe(), USBPORT_FreeBandwidthUSB2(), USBPORT_InitializeTT(), and USBPORT_RemoveDevice().

USBPORT_USBDStatusToNtStatus()

NTSTATUS NTAPI USBPORT_USBDStatusToNtStatus	(	IN PURB	Urb,
		IN USBD_STATUS	USBDStatus
	)

Definition at line 485 of file usbport.c.

{
    NTSTATUS Status;
 
    if (USBD_ERROR(USBDStatus))
    {
        DPRINT1("USBPORT_USBDStatusToNtStatus: Urb - %p, USBDStatus - %x\n",
                Urb,
                USBDStatus);
    }
 
    if (Urb)
        Urb->UrbHeader.Status = USBDStatus;
 
    switch (USBDStatus)
    {
        case USBD_STATUS_SUCCESS:
            Status = STATUS_SUCCESS;
            break;
 
        case USBD_STATUS_INSUFFICIENT_RESOURCES:
            Status = STATUS_INSUFFICIENT_RESOURCES;
            break;
 
        case USBD_STATUS_DEVICE_GONE:
            Status = STATUS_DEVICE_NOT_CONNECTED;
            break;
 
        case USBD_STATUS_CANCELED:
            Status = STATUS_CANCELLED;
            break;
 
        case USBD_STATUS_NOT_SUPPORTED:
            Status = STATUS_NOT_SUPPORTED;
            break;
 
        case USBD_STATUS_INVALID_URB_FUNCTION:
        case USBD_STATUS_INVALID_PARAMETER:
        case USBD_STATUS_INVALID_PIPE_HANDLE:
        case USBD_STATUS_BAD_START_FRAME:
            Status = STATUS_INVALID_PARAMETER;
            break;
 
        default:
            if (USBD_ERROR(USBDStatus))
                Status = STATUS_UNSUCCESSFUL;
            else
                Status = STATUS_SUCCESS;
 
            break;
    }
 
    return Status;
}

Referenced by USBPORT_AbortPipe(), USBPORT_ClearStall(), USBPORT_CompleteTransfer(), USBPORT_DoneTransfer(), USBPORT_FlushAbortList(), USBPORT_HandleGetCurrentFrame(), USBPORT_HandleGetStatus(), USBPORT_HandleSelectConfiguration(), USBPORT_HandleSelectInterface(), USBPORT_HandleSubmitURB(), USBPORT_OpenInterface(), USBPORT_OpenPipe(), USBPORT_ResetPipe(), USBPORT_RestoreDevice(), USBPORT_SendSetupPacket(), USBPORT_SyncResetPipeAndClearStall(), and USBPORT_ValidateURB().

USBPORT_ValidateDeviceHandle()

BOOLEAN NTAPI USBPORT_ValidateDeviceHandle	(	IN PDEVICE_OBJECT	FdoDevice,
		IN PUSBPORT_DEVICE_HANDLE	DeviceHandle
	)

Definition at line 801 of file device.c.

{
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    KIRQL OldIrql;
    PLIST_ENTRY HandleList;
    PUSBPORT_DEVICE_HANDLE CurrentHandle;
    BOOLEAN Result = FALSE;
 
    //DPRINT("USBPORT_ValidateDeviceHandle: DeviceHandle - %p\n", DeviceHandle \n");
 
    FdoExtension = FdoDevice->DeviceExtension;
 
    KeAcquireSpinLock(&FdoExtension->DeviceHandleSpinLock, &OldIrql);
    if (DeviceHandle)
    {
        HandleList = FdoExtension->DeviceHandleList.Flink;
 
        while (HandleList != &FdoExtension->DeviceHandleList)
        {
            CurrentHandle = CONTAINING_RECORD(HandleList,
                                              USBPORT_DEVICE_HANDLE,
                                              DeviceHandleLink);
 
            if (CurrentHandle == DeviceHandle)
            {
                Result = TRUE;
                break;
            }
 
            HandleList = HandleList->Flink;
        }
    }
    KeReleaseSpinLock(&FdoExtension->DeviceHandleSpinLock, OldIrql);
 
    return Result;
}

Referenced by USBPORT_CreateDevice(), USBPORT_HandleSubmitURB(), USBPORT_RemoveDevice(), and USBPORT_RestoreDevice().

USBPORT_ValidatePipeHandle()

BOOLEAN NTAPI USBPORT_ValidatePipeHandle	(	IN PUSBPORT_DEVICE_HANDLE	DeviceHandle,
		IN PUSBPORT_PIPE_HANDLE	PipeHandle
	)

Definition at line 469 of file endpoint.c.

{
    PLIST_ENTRY HandleList;
    PUSBPORT_PIPE_HANDLE CurrentHandle;
 
    //DPRINT("USBPORT_ValidatePipeHandle: DeviceHandle - %p, PipeHandle - %p\n",
    //       DeviceHandle,
    //       PipeHandle);
 
    HandleList = DeviceHandle->PipeHandleList.Flink;
 
    while (HandleList != &DeviceHandle->PipeHandleList)
    {
        CurrentHandle = CONTAINING_RECORD(HandleList,
                                          USBPORT_PIPE_HANDLE,
                                          PipeLink);
 
        HandleList = HandleList->Flink;
 
        if (CurrentHandle == PipeHandle)
            return TRUE;
    }
 
    return FALSE;
}

Referenced by USBPORT_AbortPipe(), USBPORT_ClearStall(), USBPORT_ResetPipe(), USBPORT_SyncResetPipeAndClearStall(), and USBPORT_ValidateURB().

USBPORT_Wait()

NTSTATUS NTAPI USBPORT_Wait	(	IN PVOID	MiniPortExtension,
		IN ULONG	Milliseconds
	)

Definition at line 543 of file usbport.c.

{
    LARGE_INTEGER Interval = {{0, 0}};
 
    DPRINT("USBPORT_Wait: Milliseconds - %x\n", Milliseconds);
    Interval.QuadPart -= 10000 * Milliseconds + (KeQueryTimeIncrement() - 1);
    return KeDelayExecutionThread(KernelMode, FALSE, &Interval);
}

Referenced by USBPORT_AbortTransfers(), USBPORT_ClosePipe(), USBPORT_FlushController(), USBPORT_InitializeDevice(), USBPORT_OpenPipe(), USBPORT_PdoDevicePowerState(), USBPORT_RegisterUSBPortDriver(), USBPORT_RemoveDevice(), USBPORT_ReopenPipe(), USBPORT_RestoreDevice(), USBPORT_ResumeController(), USBPORT_RootHubPowerAndChirpAllCcPorts(), USBPORT_SuspendController(), USBPORT_SynchronizeRootHubCallback(), and USBPORT_SyncResetPipeAndClearStall().

USBPORT_WorkerRequestDpc()

VOID NTAPI USBPORT_WorkerRequestDpc	(	IN PRKDPC	Dpc,
		IN PVOID	DeferredContext,
		IN PVOID	SystemArgument1,
		IN PVOID	SystemArgument2
	)

Definition at line 701 of file usbport.c.

{
    PDEVICE_OBJECT FdoDevice;
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
 
    DPRINT("USBPORT_WorkerRequestDpc: ...\n");
 
    FdoDevice = DeferredContext;
    FdoExtension = FdoDevice->DeviceExtension;
 
    if (!InterlockedIncrement(&FdoExtension->IsrDpcHandlerCounter))
    {
        USBPORT_DpcHandler(FdoDevice);
    }
 
    InterlockedDecrement(&FdoExtension->IsrDpcHandlerCounter);
}

Referenced by USBPORT_StartDevice().

Variable Documentation

USBPORT_MiniPortDrivers

LIST_ENTRY USBPORT_MiniPortDrivers

extern

Definition at line 18 of file usbport.c.

Referenced by USBPORT_FindMiniPort(), and USBPORT_RegisterUSBPortDriver().

USBPORT_SpinLock

KSPIN_LOCK USBPORT_SpinLock

extern

Definition at line 22 of file usbport.c.

Referenced by USBPORT_AddUSB1Fdo(), USBPORT_AddUSB2Fdo(), USBPORT_FindCompanionControllers(), USBPORT_FindMiniPort(), USBPORT_FindUSB2Controller(), USBPORT_RegisterUSBPortDriver(), and USBPORT_RemoveUSBxFdo().