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: