#include <ntddk.h>#include <windef.h>#include <stdio.h>#include <wmistr.h>#include <wmilib.h>#include <wdmguid.h>#include <ntstrsafe.h>#include <usb.h>#include <usbioctl.h>#include <hubbusif.h>#include <usbbusif.h>#include <usbdlib.h>#include <ks.h>#include <drivers/usbport/usbmport.h>
Include dependency graph for usbhub.h:
This graph shows which files directly or indirectly include this file:
Go to the source code of this file.
Classes | |
| struct | _USBHUB_PORT_DATA |
| struct | _USBHUB_IO_WORK_ITEM |
| struct | _COMMON_DEVICE_EXTENSION |
| struct | _USBHUB_FDO_EXTENSION |
| struct | _USBHUB_PORT_PDO_EXTENSION |
| struct | _USBHUB_URB_TIMEOUT_CONTEXT |
| struct | _USBHUB_STATUS_CHANGE_CONTEXT |
| struct | _USBHUB_IDLE_HUB_CONTEXT |
| struct | _USBHUB_IDLE_PORT_CONTEXT |
| struct | _USBHUB_IDLE_PORT_CANCEL_CONTEXT |
| struct | _USBHUB_RESET_PORT_CONTEXT |
Variables | |
| PWSTR | GenericUSBDeviceString |
Macro Definition Documentation
◆ USB_HUB_TAG
◆ USBH_EXTENSION_TYPE_FUNCTION
◆ USBH_EXTENSION_TYPE_HUB
◆ USBH_EXTENSION_TYPE_PARENT
◆ USBH_EXTENSION_TYPE_PORT
◆ USBHUB_ENUM_FLAG_DEVICE_PRESENT
◆ USBHUB_ENUM_FLAG_GHOST_DEVICE
◆ USBHUB_FAIL_NESTED_TOO_DEEPLY
◆ USBHUB_FAIL_NO_FAIL
◆ USBHUB_FAIL_OVERCURRENT
◆ USBHUB_FDO_FLAG_CHECK_IDLE_LOCK
◆ USBHUB_FDO_FLAG_DEFER_CHECK_IDLE
◆ USBHUB_FDO_FLAG_DEVICE_FAILED
◆ USBHUB_FDO_FLAG_DEVICE_REMOVED
◆ USBHUB_FDO_FLAG_DEVICE_STARTED
◆ USBHUB_FDO_FLAG_DEVICE_STOPPED
◆ USBHUB_FDO_FLAG_DEVICE_STOPPING
◆ USBHUB_FDO_FLAG_DEVICE_SUSPENDED
◆ USBHUB_FDO_FLAG_DO_ENUMERATION
◆ USBHUB_FDO_FLAG_DO_SUSPENSE
◆ USBHUB_FDO_FLAG_ENUM_POST_RECOVER
◆ USBHUB_FDO_FLAG_ESD_RECOVERING
◆ USBHUB_FDO_FLAG_GOING_IDLE
◆ USBHUB_FDO_FLAG_HIBERNATE_STATE
◆ USBHUB_FDO_FLAG_HUB_BUSY
◆ USBHUB_FDO_FLAG_MULTIPLE_TTS
◆ USBHUB_FDO_FLAG_NOT_D0_STATE
◆ USBHUB_FDO_FLAG_NOT_ENUMERATED
◆ USBHUB_FDO_FLAG_PENDING_WAKE_IRP
◆ USBHUB_FDO_FLAG_REMOTE_WAKEUP
◆ USBHUB_FDO_FLAG_RESET_PORT_LOCK
◆ USBHUB_FDO_FLAG_SET_D0_STATE
◆ USBHUB_FDO_FLAG_STATE_CHANGING
◆ USBHUB_FDO_FLAG_USB20_HUB
◆ USBHUB_FDO_FLAG_WAIT_IDLE_REQUEST
◆ USBHUB_FDO_FLAG_WAKEUP_START
◆ USBHUB_FDO_FLAG_WITEM_INIT
◆ USBHUB_FEATURE_C_HUB_LOCAL_POWER
◆ USBHUB_FEATURE_C_HUB_OVER_CURRENT
◆ USBHUB_FEATURE_C_PORT_CONNECTION
◆ USBHUB_FEATURE_C_PORT_ENABLE
◆ USBHUB_FEATURE_C_PORT_OVER_CURRENT
◆ USBHUB_FEATURE_C_PORT_RESET
◆ USBHUB_FEATURE_C_PORT_SUSPEND
◆ USBHUB_FEATURE_PORT_CONNECTION
◆ USBHUB_FEATURE_PORT_ENABLE
◆ USBHUB_FEATURE_PORT_INDICATOR
◆ USBHUB_FEATURE_PORT_LOW_SPEED
◆ USBHUB_FEATURE_PORT_OVER_CURRENT
◆ USBHUB_FEATURE_PORT_POWER
◆ USBHUB_FEATURE_PORT_RESET
◆ USBHUB_FEATURE_PORT_SUSPEND
◆ USBHUB_FEATURE_PORT_TEST
◆ USBHUB_MAX_CASCADE_LEVELS
◆ USBHUB_MAX_REQUEST_ERRORS
◆ USBHUB_PDO_FLAG_ALLOC_BNDW_FAILED
◆ USBHUB_PDO_FLAG_DELETE_PENDING
◆ USBHUB_PDO_FLAG_DEVICE_STARTED
◆ USBHUB_PDO_FLAG_ENUMERATED
◆ USBHUB_PDO_FLAG_HS_USB1_DUALMODE
◆ USBHUB_PDO_FLAG_HUB_DEVICE
◆ USBHUB_PDO_FLAG_IDLE_NOTIFICATION
◆ USBHUB_PDO_FLAG_INIT_PORT_FAILED
◆ USBHUB_PDO_FLAG_INSUFFICIENT_PWR
◆ USBHUB_PDO_FLAG_MULTI_INTERFACE
◆ USBHUB_PDO_FLAG_NOT_CONNECTED
◆ USBHUB_PDO_FLAG_OVERCURRENT_PORT
◆ USBHUB_PDO_FLAG_PORT_HIGH_SPEED
◆ USBHUB_PDO_FLAG_PORT_LOW_SPEED
◆ USBHUB_PDO_FLAG_PORT_RESSETING
◆ USBHUB_PDO_FLAG_PORT_RESTORE_FAIL
◆ USBHUB_PDO_FLAG_POWER_D1_OR_D2
◆ USBHUB_PDO_FLAG_POWER_D3
◆ USBHUB_PDO_FLAG_REG_DEV_INTERFACE
◆ USBHUB_PDO_FLAG_REMOTE_WAKEUP
◆ USBHUB_PDO_FLAG_REMOVING_PORT_PDO
◆ USBHUB_PDO_FLAG_WAIT_WAKE
◆ USBHUB_RESET_PORT_MAX_RETRY
Typedef Documentation
◆ COMMON_DEVICE_EXTENSION
◆ PCOMMON_DEVICE_EXTENSION
◆ PUSBHUB_FDO_EXTENSION
| typedef struct _USBHUB_FDO_EXTENSION * PUSBHUB_FDO_EXTENSION |
◆ PUSBHUB_IDLE_HUB_CONTEXT
◆ PUSBHUB_IDLE_PORT_CANCEL_CONTEXT
◆ PUSBHUB_IDLE_PORT_CONTEXT
◆ PUSBHUB_IO_WORK_ITEM
| typedef struct _USBHUB_IO_WORK_ITEM * PUSBHUB_IO_WORK_ITEM |
◆ PUSBHUB_PORT_DATA
| typedef struct _USBHUB_PORT_DATA * PUSBHUB_PORT_DATA |
◆ PUSBHUB_PORT_PDO_EXTENSION
◆ PUSBHUB_RESET_PORT_CONTEXT
◆ PUSBHUB_STATUS_CHANGE_CONTEXT
◆ PUSBHUB_URB_TIMEOUT_CONTEXT
◆ PUSBHUB_WORKER_ROUTINE
◆ USBHUB_FDO_EXTENSION
◆ USBHUB_IDLE_HUB_CONTEXT
◆ USBHUB_IDLE_PORT_CANCEL_CONTEXT
◆ USBHUB_IDLE_PORT_CONTEXT
◆ USBHUB_IO_WORK_ITEM
◆ USBHUB_PORT_DATA
| typedef struct _USBHUB_PORT_DATA USBHUB_PORT_DATA |
◆ USBHUB_PORT_PDO_EXTENSION
◆ USBHUB_RESET_PORT_CONTEXT
◆ USBHUB_STATUS_CHANGE_CONTEXT
◆ USBHUB_URB_TIMEOUT_CONTEXT
Function Documentation
◆ DriverEntry()
| NTSTATUS NTAPI DriverEntry | ( | IN PDRIVER_OBJECT | DriverObject, |
| IN PUNICODE_STRING | RegistryPath | ||
| ) |
Definition at line 1604 of file cmbatt.c.
1606{
1610 UNICODE_STRING CallbackName;
1611
1612 /* Allocate registry path */
1617 'MtaB');
1619 {
1620 /* Fail if we're out of memory this early */
1624 }
1625
1626 /* Buffer allocated, copy the string */
1630 DriverObject,
1631 RegistryPath);
1632
1633 /* Setup the major dispatchers */
1640
1641 /* And the unload routine */
1643
1644 /* And the add device routine */
1647
1648 /* Create a power callback */
1651 &CallbackName,
1652 OBJ_KERNEL_HANDLE,
1653 NULL,
1654 NULL);
1657 {
1658 /* No callback, fail */
1659 CmBattPowerCallBackObject = 0;
1662 }
1663 else
1664 {
1665 /* Register the power callback now */
1668 DriverObject);
1670 {
1671 /* Last thing: setup our DPC and timer for battery wake */
1674 }
1675 else
1676 {
1680 }
1681
1682 /* All good */
1684 }
1685
1686 /* Return failure or success */
1688}
NTSTATUS NTAPI CmBattOpenClose(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: cmbatt.c:553
NTSTATUS NTAPI CmBattIoctl(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: cmbatt.c:616
VOID NTAPI CmBattWakeDpc(IN PKDPC Dpc, IN PCMBATT_DEVICE_EXTENSION FdoExtension, IN PVOID SystemArgument1, IN PVOID SystemArgument2)
Definition: cmbatt.c:75
VOID NTAPI CmBattPowerCallBack(IN PCMBATT_DEVICE_EXTENSION DeviceExtension, IN ULONG Action, IN ULONG Value)
Definition: cmbatt.c:30
NTSTATUS NTAPI CmBattPowerDispatch(PDEVICE_OBJECT DeviceObject, PIRP Irp)
NTSTATUS NTAPI CmBattPnpDispatch(PDEVICE_OBJECT DeviceObject, PIRP Irp)
NTSTATUS NTAPI CmBattAddDevice(PDRIVER_OBJECT DriverObject, PDEVICE_OBJECT DeviceObject)
NTSTATUS NTAPI CmBattSystemControl(PDEVICE_OBJECT DeviceObject, PIRP Irp)
VOID NTAPI KeInitializeDpc(IN PKDPC Dpc, IN PKDEFERRED_ROUTINE DeferredRoutine, IN PVOID DeferredContext)
Definition: dpc.c:712
Definition: nsiface.idl:2307
NTSYSAPI VOID NTAPI RtlCopyUnicodeString(PUNICODE_STRING DestinationString, PUNICODE_STRING SourceString)
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define UNICODE_NULL
PVOID NTAPI ExRegisterCallback(IN PCALLBACK_OBJECT CallbackObject, IN PCALLBACK_FUNCTION CallbackFunction, IN PVOID CallbackContext)
Definition: callback.c:556
NTSTATUS NTAPI ExCreateCallback(OUT PCALLBACK_OBJECT *CallbackObject, IN POBJECT_ATTRIBUTES ObjectAttributes, IN BOOLEAN Create, IN BOOLEAN AllowMultipleCallbacks)
Definition: callback.c:361
Definition: iotypes.h:2220
Definition: umtypes.h:184
Definition: env_spec_w32.h:368
_Must_inspect_result_ _In_ PDRIVER_OBJECT _In_ PCUNICODE_STRING RegistryPath
Definition: wdfdriver.h:215
#define IRP_MJ_SYSTEM_CONTROL
#define IRP_MJ_POWER
◆ PdoExt()
| PUSBHUB_PORT_PDO_EXTENSION NTAPI PdoExt | ( | IN PDEVICE_OBJECT | DeviceObject | ) |
Definition at line 133 of file usbhub.c.
Referenced by _Requires_lock_held_(), DrvTestResources(), IsaPdoFilterResourceRequirements(), IsaPdoPnp(), IsaPdoQueryBusInformation(), IsaPdoQueryCapabilities(), IsaPdoQueryDeviceRelations(), IsaPdoQueryDeviceText(), IsaPdoQueryDeviceUsageNotification(), IsaPdoQueryId(), IsaPdoQueryPnpDeviceState(), IsaPdoQueryResourceRequirements(), IsaPdoQueryResources(), IsaPdoRemoveDevice(), IsaPdoStartReadPort(), IsaPnpCreateLogicalDeviceRequirements(), IsaPnpCreateLogicalDeviceResources(), IsaPnpCreateReadPortDO(), IsaPnpFillDeviceRelations(), IsaPnpRemoveLogicalDeviceDO(), IsaReadPortRemoveDevice(), PcmciaPdoPlugPlay(), PcmciaPdoSetPowerState(), USBH_FdoQueryBusRelations(), USBH_FdoSurpriseRemoveDevice(), and USBH_PdoRemoveDevice().
◆ USBD_CreateDeviceEx()
| NTSTATUS NTAPI USBD_CreateDeviceEx | ( | IN PUSBHUB_FDO_EXTENSION | HubExtension, |
| IN PUSB_DEVICE_HANDLE * | OutDeviceHandle, | ||
| IN USB_PORT_STATUS | UsbPortStatus, | ||
| IN USHORT | Port | ||
| ) |
Definition at line 2523 of file usbhub.c.
2527{
2529 PUSB_BUSIFFN_CREATE_USB_DEVICE CreateUsbDevice;
2530
2532 Port,
2533 UsbPortStatus.AsUshort16);
2534
2535 CreateUsbDevice = HubExtension->BusInterface.CreateUsbDevice;
2536
2537 if (!CreateUsbDevice)
2538 {
2540 }
2541
2543
2544 return CreateUsbDevice(HubExtension->BusInterface.BusContext,
2545 OutDeviceHandle,
2546 HubDeviceHandle,
2547 UsbPortStatus.AsUshort16,
2548 Port);
2549}
_Outptr_ PUSB_DEVICE_HANDLE _In_ PUSB_DEVICE_HANDLE HubDeviceHandle
Definition: hubbusif.h:41
USB_BUSIFFN_CREATE_USB_DEVICE * PUSB_BUSIFFN_CREATE_USB_DEVICE
Definition: hubbusif.h:44
PUSB_DEVICE_HANDLE NTAPI USBH_SyncGetDeviceHandle(IN PDEVICE_OBJECT DeviceObject)
Definition: usbhub.c:832
Referenced by USBH_CreateDevice(), and USBH_ResetDevice().
◆ USBD_GetDeviceInformationEx()
| NTSTATUS NTAPI USBD_GetDeviceInformationEx | ( | IN PUSBHUB_PORT_PDO_EXTENSION | PortExtension, |
| IN PUSBHUB_FDO_EXTENSION | HubExtension, | ||
| IN PUSB_NODE_CONNECTION_INFORMATION_EX | Info, | ||
| IN ULONG | Length, | ||
| IN PUSB_DEVICE_HANDLE | DeviceHandle | ||
| ) |
Definition at line 2654 of file usbhub.c.
2659{
2662 SIZE_T DeviceInfoLength;
2663 PUSB_NODE_CONNECTION_INFORMATION_EX NodeInfo;
2664 SIZE_T NodeInfoLength;
2665 ULONG PipeNumber;
2668
2670
2671 QueryDeviceInformation = HubExtension->BusInterface.QueryDeviceInformation;
2672
2674 {
2677 }
2678
2680
2682 {
2684 DeviceInfoLength,
2685 USB_HUB_TAG);
2686
2688 {
2690 }
2691
2693
2694 DeviceInfo->InformationLevel = 0;
2695
2697 DeviceHandle,
2698 DeviceInfo,
2699 DeviceInfoLength,
2700 &dummy);
2701
2703 {
2704 break;
2705 }
2706
2707 DeviceInfoLength = DeviceInfo->ActualLength;
2708
2710 }
2711
2712 NodeInfo = NULL;
2713 NodeInfoLength = 0;
2714
2716 {
2719
2721
2722 if (!NodeInfo)
2723 {
2726 }
2727
2728 RtlZeroMemory(NodeInfo, NodeInfoLength);
2729
2730 NodeInfo->ConnectionIndex = Info->ConnectionIndex;
2731
2732 RtlCopyMemory(&NodeInfo->DeviceDescriptor,
2733 &DeviceInfo->DeviceDescriptor,
2735
2736 NodeInfo->CurrentConfigurationValue = DeviceInfo->CurrentConfigurationValue;
2737 NodeInfo->Speed = DeviceInfo->DeviceSpeed;
2738 NodeInfo->DeviceIsHub = PortExtension->PortPdoFlags & USBHUB_PDO_FLAG_HUB_DEVICE;
2739 NodeInfo->DeviceAddress = DeviceInfo->DeviceAddress;
2740 NodeInfo->NumberOfOpenPipes = DeviceInfo->NumberOfOpenPipes;
2741 NodeInfo->ConnectionStatus = Info->ConnectionStatus;
2742
2743 for (PipeNumber = 0;
2744 PipeNumber < DeviceInfo->NumberOfOpenPipes;
2745 PipeNumber++)
2746 {
2747 RtlCopyMemory(&NodeInfo->PipeList[PipeNumber],
2748 &DeviceInfo->PipeList[PipeNumber],
2750 }
2751 }
2752
2754
2755 if (NodeInfo)
2756 {
2758 {
2759 Length = NodeInfoLength;
2760 }
2761 else
2762 {
2764 }
2765
2767
2769 }
2770
2772}
BOOL NTAPI QueryDeviceInformation(_In_ PCWSTR DriveRoot, _Out_ PVOID DeviceInformation, _In_ ULONG BufferSize)
Retrieves disk device information.
Definition: query.c:79
struct _USB_DEVICE_INFORMATION_0 USB_DEVICE_INFORMATION_0
USB_BUSIFFN_GET_DEVICE_INFORMATION * PUSB_BUSIFFN_GET_DEVICE_INFORMATION
Definition: hubbusif.h:183
Definition: ndr_types.idl:28
Definition: setupapi_private.h:129
Definition: usb100.h:110
Definition: hubbusif.h:688
Definition: usbioctl.h:240
_Must_inspect_result_ _In_ WDFCHILDLIST _In_ PWDF_CHILD_LIST_ITERATOR _Out_ WDFDEVICE _Inout_opt_ PWDF_CHILD_RETRIEVE_INFO Info
Definition: wdfchildlist.h:690
Referenced by USBH_IoctlGetNodeConnectionInformation().
◆ USBD_InitializeDeviceEx()
| NTSTATUS NTAPI USBD_InitializeDeviceEx | ( | IN PUSBHUB_FDO_EXTENSION | HubExtension, |
| IN PUSB_DEVICE_HANDLE | DeviceHandle, | ||
| IN PUCHAR | DeviceDescriptorBuffer, | ||
| IN ULONG | DeviceDescriptorBufferLength, | ||
| IN PUCHAR | ConfigDescriptorBuffer, | ||
| IN ULONG | ConfigDescriptorBufferLength | ||
| ) |
Definition at line 2577 of file usbhub.c.
2583{
2585 PUSB_BUSIFFN_INITIALIZE_USB_DEVICE InitializeUsbDevice;
2586 PUSB_BUSIFFN_GET_USB_DESCRIPTORS GetUsbDescriptors;
2587
2589
2590 InitializeUsbDevice = HubExtension->BusInterface.InitializeUsbDevice;
2591 GetUsbDescriptors = HubExtension->BusInterface.GetUsbDescriptors;
2592
2593 if (!InitializeUsbDevice || !GetUsbDescriptors)
2594 {
2596 }
2597
2598 Status = InitializeUsbDevice(HubExtension->BusInterface.BusContext,
2599 DeviceHandle);
2600
2602 {
2604 }
2605
2606 return GetUsbDescriptors(HubExtension->BusInterface.BusContext,
2607 DeviceHandle,
2608 DeviceDescriptorBuffer,
2609 &DeviceDescriptorBufferLength,
2610 ConfigDescriptorBuffer,
2611 &ConfigDescriptorBufferLength);
2612}
USB_BUSIFFN_INITIALIZE_USB_DEVICE * PUSB_BUSIFFN_INITIALIZE_USB_DEVICE
Definition: hubbusif.h:122
USB_BUSIFFN_GET_USB_DESCRIPTORS * PUSB_BUSIFFN_GET_USB_DESCRIPTORS
Definition: hubbusif.h:154
_Inout_ PUSB_DEVICE_HANDLE _Out_writes_bytes_to_ DeviceDescriptorBufferLength PUCHAR _Inout_ PULONG _Out_writes_bytes_to_ ConfigDescriptorBufferLength PUCHAR _Inout_ PULONG ConfigDescriptorBufferLength
Definition: hubbusif.h:153
_Inout_ PUSB_DEVICE_HANDLE _Out_writes_bytes_to_ DeviceDescriptorBufferLength PUCHAR DeviceDescriptorBuffer
Definition: hubbusif.h:148
_Inout_ PUSB_DEVICE_HANDLE _Out_writes_bytes_to_ DeviceDescriptorBufferLength PUCHAR _Inout_ PULONG _Out_writes_bytes_to_ ConfigDescriptorBufferLength PUCHAR ConfigDescriptorBuffer
Definition: hubbusif.h:151
_Inout_ PUSB_DEVICE_HANDLE _Out_writes_bytes_to_ DeviceDescriptorBufferLength PUCHAR _Inout_ PULONG DeviceDescriptorBufferLength
Definition: hubbusif.h:150
Referenced by USBH_CreateDevice(), and USBH_ResetDevice().
◆ USBD_RegisterRootHubCallBack()
| NTSTATUS NTAPI USBD_RegisterRootHubCallBack | ( | IN PUSBHUB_FDO_EXTENSION | HubExtension | ) |
Definition at line 3001 of file usbhub.c.
3002{
3003 PUSB_BUSIFFN_ROOTHUB_INIT_NOTIFY RootHubInitNotification;
3004
3006
3007 RootHubInitNotification = HubExtension->BusInterface.RootHubInitNotification;
3008
3009 if (!RootHubInitNotification)
3010 {
3012 }
3013
3014 KeClearEvent(&HubExtension->RootHubNotificationEvent);
3015
3016 return RootHubInitNotification(HubExtension->BusInterface.BusContext,
3017 HubExtension,
3018 USBHUB_RootHubCallBack);
3019}
USB_BUSIFFN_ROOTHUB_INIT_NOTIFY * PUSB_BUSIFFN_ROOTHUB_INIT_NOTIFY
Definition: hubbusif.h:279
Referenced by USBH_StartHubFdoDevice().
◆ USBD_RemoveDeviceEx()
| NTSTATUS NTAPI USBD_RemoveDeviceEx | ( | IN PUSBHUB_FDO_EXTENSION | HubExtension, |
| IN PUSB_DEVICE_HANDLE | DeviceHandle, | ||
| IN ULONG | Flags | ||
| ) |
Definition at line 2553 of file usbhub.c.
2556{
2557 PUSB_BUSIFFN_REMOVE_USB_DEVICE RemoveUsbDevice;
2558
2560 DeviceHandle,
2561 Flags);
2562
2563 RemoveUsbDevice = HubExtension->BusInterface.RemoveUsbDevice;
2564
2565 if (!RemoveUsbDevice)
2566 {
2568 }
2569
2570 return RemoveUsbDevice(HubExtension->BusInterface.BusContext,
2571 DeviceHandle,
2572 Flags);
2573}
USB_BUSIFFN_REMOVE_USB_DEVICE * PUSB_BUSIFFN_REMOVE_USB_DEVICE
Definition: hubbusif.h:140
Referenced by USBH_CreateDevice(), USBH_FdoCleanup(), USBH_FdoQueryBusRelations(), USBH_PdoRemoveDevice(), USBH_ProcessPortStateChange(), USBH_ResetDevice(), and USBH_ResetPortWorker().
◆ USBD_RestoreDeviceEx()
| NTSTATUS NTAPI USBD_RestoreDeviceEx | ( | IN PUSBHUB_FDO_EXTENSION | HubExtension, |
| IN OUT PUSB_DEVICE_HANDLE | OldDeviceHandle, | ||
| IN OUT PUSB_DEVICE_HANDLE | NewDeviceHandle | ||
| ) |
Definition at line 2776 of file usbhub.c.
2779{
2780 PUSB_BUSIFFN_RESTORE_DEVICE RestoreUsbDevice;
2782
2783 DPRINT("USBD_RestoreDeviceEx: HubExtension - %p, OldDeviceHandle - %p, NewDeviceHandle - %p\n",
2784 HubExtension,
2785 OldDeviceHandle,
2786 NewDeviceHandle);
2787
2788 RestoreUsbDevice = HubExtension->BusInterface.RestoreUsbDevice;
2789
2790 if (RestoreUsbDevice)
2791 {
2792 Status = RestoreUsbDevice(HubExtension->BusInterface.BusContext,
2793 OldDeviceHandle,
2794 NewDeviceHandle);
2795 }
2796 else
2797 {
2799 }
2800
2802}
USB_BUSIFFN_RESTORE_DEVICE * PUSB_BUSIFFN_RESTORE_DEVICE
Definition: hubbusif.h:163
Referenced by USBH_ResetDevice().
◆ USBD_UnRegisterRootHubCallBack()
| NTSTATUS NTAPI USBD_UnRegisterRootHubCallBack | ( | IN PUSBHUB_FDO_EXTENSION | HubExtension | ) |
Definition at line 3023 of file usbhub.c.
3024{
3025 PUSB_BUSIFFN_ROOTHUB_INIT_NOTIFY RootHubInitNotification;
3027
3029
3030 RootHubInitNotification = HubExtension->BusInterface.RootHubInitNotification;
3031
3032 if (!RootHubInitNotification)
3033 {
3035 }
3036
3037 Status = RootHubInitNotification(HubExtension->BusInterface.BusContext,
3038 NULL,
3039 NULL);
3040
3042 {
3043 KeWaitForSingleObject(&HubExtension->RootHubNotificationEvent,
3044 Executive,
3045 KernelMode,
3046 FALSE,
3047 NULL);
3048 }
3049
3051}
#define KeWaitForSingleObject(pEvt, foo, a, b, c)
Definition: env_spec_w32.h:478
Referenced by USBH_FdoCleanup().
◆ USBH_AllocateWorkItem()
| NTSTATUS NTAPI USBH_AllocateWorkItem | ( | IN PUSBHUB_FDO_EXTENSION | HubExtension, |
| OUT PUSBHUB_IO_WORK_ITEM * | OutHubIoWorkItem, | ||
| IN PUSBHUB_WORKER_ROUTINE | WorkerRoutine, | ||
| IN SIZE_T | BufferLength, | ||
| OUT PVOID * | OutHubWorkItemBuffer, | ||
| IN WORK_QUEUE_TYPE | Type | ||
| ) |
◆ USBH_CheckDeviceLanguage()
Definition at line 4257 of file usbhub.c.
4259{
4262 ULONG NumSymbols;
4263 ULONG ix;
4264 PWCHAR pSymbol;
4266
4268
4271 USB_HUB_TAG);
4272
4274 {
4276 }
4277
4279
4281 0,
4282 0,
4283 Descriptor,
4285 &Length,
4286 TRUE);
4287
4290 {
4292 }
4293
4294 NumSymbols = (Length -
4296
4297 pSymbol = Descriptor->bString;
4298
4299 for (ix = 1; ix < NumSymbols; ix++)
4300 {
4302 {
4305 }
4306
4307 pSymbol++;
4308 }
4309
4311
4312Exit:
4315}
Definition: usb100.h:165
Definition: usb100.h:159
NTSTATUS NTAPI USBH_SyncGetStringDescriptor(IN PDEVICE_OBJECT DeviceObject, IN UCHAR Index, IN USHORT LanguageId, IN PUSB_STRING_DESCRIPTOR Descriptor, IN ULONG NumberOfBytes, IN PULONG OutLength, IN BOOLEAN IsValidateLength)
Definition: usbhub.c:1248
_Must_inspect_result_ _In_ WDFIORESLIST _In_ PIO_RESOURCE_DESCRIPTOR Descriptor
Definition: wdfresource.h:342
Referenced by USBH_GetSerialNumberString(), and USBH_PdoQueryDeviceText().
◆ USBH_CheckHubIdle()
| VOID NTAPI USBH_CheckHubIdle | ( | IN PUSBHUB_FDO_EXTENSION | HubExtension | ) |
Definition at line 3823 of file usbhub.c.
3824{
3825 PDEVICE_OBJECT PdoDevice;
3826 PUSBHUB_PORT_PDO_EXTENSION PortExtension;
3827 PUSBHUB_PORT_DATA PortData;
3828 ULONG HubFlags;
3832 BOOLEAN IsAllPortsIdle;
3834
3836
3837return; //HACK: delete it line after fixing Power Manager!!!
3838
3840
3842 {
3844 return;
3845 }
3846
3847 HubExtension->HubFlags |= USBHUB_FDO_FLAG_CHECK_IDLE_LOCK;
3849
3850 if (USBH_GetRootHubExtension(HubExtension)->SystemPowerState.SystemState != PowerSystemWorking)
3851 {
3853 HubExtension->HubFlags &= ~USBHUB_FDO_FLAG_CHECK_IDLE_LOCK;
3855 return;
3856 }
3857
3858 HubFlags = HubExtension->HubFlags;
3860
3862 !(HubFlags & USBHUB_FDO_FLAG_DO_ENUMERATION))
3863 {
3865 }
3866
3868 HubFlags & USBHUB_FDO_FLAG_ENUM_POST_RECOVER ||
3869 HubFlags & USBHUB_FDO_FLAG_DEVICE_FAILED ||
3870 HubFlags & USBHUB_FDO_FLAG_DEVICE_STOPPING ||
3871 HubFlags & USBHUB_FDO_FLAG_DEVICE_REMOVED ||
3872 HubFlags & USBHUB_FDO_FLAG_STATE_CHANGING ||
3873 HubFlags & USBHUB_FDO_FLAG_WAKEUP_START ||
3874 HubFlags & USBHUB_FDO_FLAG_ESD_RECOVERING)
3875 {
3877 }
3878
3879 if (HubExtension->ResetRequestCount)
3880 {
3881 HubExtension->HubFlags |= USBHUB_FDO_FLAG_DEFER_CHECK_IDLE;
3883 }
3884
3885 HubExtension->HubFlags &= ~USBHUB_FDO_FLAG_DEFER_CHECK_IDLE;
3886
3887 InterlockedIncrement(&HubExtension->PendingRequestCount);
3888
3889 KeWaitForSingleObject(&HubExtension->ResetDeviceSemaphore,
3890 Executive,
3891 KernelMode,
3892 FALSE,
3893 NULL);
3894
3896
3897 IsAllPortsIdle = TRUE;
3898
3899 PortData = HubExtension->PortData;
3900
3902 Port < HubExtension->HubDescriptor->bNumberOfPorts;
3903 Port++)
3904 {
3906
3907 if (PdoDevice)
3908 {
3909 PortExtension = PdoDevice->DeviceExtension;
3910
3912 {
3914 PortExtension);
3915
3916 IsAllPortsIdle = FALSE;
3917 IsHubCheck = FALSE;
3918
3919 break;
3920 }
3921 }
3922 }
3923
3924 if (IsHubCheck &&
3925 !(HubExtension->HubFlags & USBHUB_FDO_FLAG_WAIT_IDLE_REQUEST))
3926 {
3927 KeClearEvent(&HubExtension->IdleEvent);
3928 HubExtension->HubFlags |= USBHUB_FDO_FLAG_WAIT_IDLE_REQUEST;
3929 IsHubIdle = TRUE;
3930 }
3931
3933
3934 KeReleaseSemaphore(&HubExtension->ResetDeviceSemaphore,
3935 LOW_REALTIME_PRIORITY,
3936 1,
3937 FALSE);
3938
3940 {
3941 KeSetEvent(&HubExtension->PendingRequestEvent,
3942 EVENT_INCREMENT,
3943 FALSE);
3944 }
3945
3947 IsAllPortsIdle,
3948 IsHubIdle);
3949
3950 if (IsAllPortsIdle && IsHubIdle)
3951 {
3952 USBH_FdoSubmitIdleRequestIrp(HubExtension);
3953 }
3954
3955Exit:
3957 HubExtension->HubFlags &= ~USBHUB_FDO_FLAG_CHECK_IDLE_LOCK;
3959}
#define LOW_REALTIME_PRIORITY
LONG NTAPI KeReleaseSemaphore(IN PKSEMAPHORE Semaphore, IN KPRIORITY Increment, IN LONG Adjustment, IN BOOLEAN Wait)
Definition: semphobj.c:54
Definition: env_spec_w32.h:413
Definition: usbhub.h:117
PUSBHUB_FDO_EXTENSION NTAPI USBH_GetRootHubExtension(IN PUSBHUB_FDO_EXTENSION HubExtension)
Definition: usbhub.c:699
NTSTATUS NTAPI USBH_FdoSubmitIdleRequestIrp(IN PUSBHUB_FDO_EXTENSION HubExtension)
Definition: usbhub.c:3737
Referenced by USBH_ChangeIndicationWorker(), USBH_CheckIdleWorker(), and USBH_DeviceControl().
◆ USBH_CheckIdleAbort()
| BOOLEAN NTAPI USBH_CheckIdleAbort | ( | IN PUSBHUB_FDO_EXTENSION | HubExtension, |
| IN BOOLEAN | IsWait, | ||
| IN BOOLEAN | IsExtCheck | ||
| ) |
Definition at line 3236 of file usbhub.c.
3239{
3240 PDEVICE_OBJECT PdoDevice;
3241 PUSBHUB_PORT_PDO_EXTENSION PortExtension;
3242 PUSBHUB_PORT_DATA PortData;
3245
3247
3248 InterlockedIncrement(&HubExtension->PendingRequestCount);
3249
3251 {
3252 KeWaitForSingleObject(&HubExtension->ResetDeviceSemaphore,
3253 Executive,
3254 KernelMode,
3255 FALSE,
3256 NULL);
3257 }
3258
3259 PortData = HubExtension->PortData;
3260
3262 {
3264
3265 if (PdoDevice)
3266 {
3267 PortExtension = PdoDevice->DeviceExtension;
3268
3270 {
3273 }
3274 }
3275 }
3276
3278 {
3279 PortData = HubExtension->PortData;
3280
3282 Port < HubExtension->HubDescriptor->bNumberOfPorts;
3283 Port++)
3284 {
3286
3287 if (PdoDevice)
3288 {
3289 PortExtension = PdoDevice->DeviceExtension;
3291 }
3292 }
3293 }
3294
3295Wait:
3296
3298 {
3299 KeReleaseSemaphore(&HubExtension->ResetDeviceSemaphore,
3300 LOW_REALTIME_PRIORITY,
3301 1,
3302 FALSE);
3303 }
3304
3306 {
3307 KeSetEvent(&HubExtension->PendingRequestEvent,
3308 EVENT_INCREMENT,
3309 FALSE);
3310 }
3311
3313}
_At_(*)(_In_ PWSK_CLIENT Client, _In_opt_ PUNICODE_STRING NodeName, _In_opt_ PUNICODE_STRING ServiceName, _In_opt_ ULONG NameSpace, _In_opt_ GUID *Provider, _In_opt_ PADDRINFOEXW Hints, _Outptr_ PADDRINFOEXW *Result, _In_opt_ PEPROCESS OwningProcess, _In_opt_ PETHREAD OwningThread, _Inout_ PIRP Irp Result)(Mem)) NTSTATUS(WSKAPI *PFN_WSK_GET_ADDRESS_INFO
Definition: wsk.h:409
Referenced by USBH_FdoIdleNotificationCallback(), and USBH_FdoPower().
◆ USBH_CheckIdleDeferred()
| VOID NTAPI USBH_CheckIdleDeferred | ( | IN PUSBHUB_FDO_EXTENSION | HubExtension | ) |
Definition at line 3972 of file usbhub.c.
3973{
3974 PUSBHUB_IO_WORK_ITEM HubIoWorkItem;
3976
3978
3980 &HubIoWorkItem,
3981 USBH_CheckIdleWorker,
3982 0,
3983 NULL,
3984 DelayedWorkQueue);
3985
3987
3989 {
3990 USBH_QueueWorkItem(HubExtension, HubIoWorkItem);
3991 }
3992}
Definition: usbhub.h:131
VOID NTAPI USBH_CheckIdleWorker(IN PUSBHUB_FDO_EXTENSION HubExtension, IN PVOID Context)
Definition: usbhub.c:3963
NTSTATUS NTAPI USBH_AllocateWorkItem(PUSBHUB_FDO_EXTENSION HubExtension, PUSBHUB_IO_WORK_ITEM *OutHubIoWorkItem, PUSBHUB_WORKER_ROUTINE WorkerRoutine, SIZE_T BufferLength, PVOID *OutHubWorkItemBuffer, WORK_QUEUE_TYPE Type)
Definition: usbhub.c:2806
VOID NTAPI USBH_QueueWorkItem(IN PUSBHUB_FDO_EXTENSION HubExtension, IN PUSBHUB_IO_WORK_ITEM HubIoWorkItem)
Definition: usbhub.c:2932
Referenced by USBH_FdoDeferPoRequestCompletion(), USBH_FdoPnP(), USBH_FdoPower(), USBH_PdoRemoveDevice(), and USBH_PortIdleNotificationRequest().
◆ USBH_CompleteIrp()
Definition at line 63 of file usbhub.c.
Referenced by USBH_DeviceControl(), USBH_FdoDispatch(), USBH_FdoQueryBusRelations(), USBH_FdoStartDevice(), USBH_IoctlGetDescriptor(), USBH_IoctlGetHubCapabilities(), USBH_IoctlGetNodeConnectionAttributes(), USBH_IoctlGetNodeConnectionDriverKeyName(), USBH_IoctlGetNodeConnectionInformation(), USBH_IoctlGetNodeInformation(), USBH_IoctlGetNodeName(), USBH_PdoDispatch(), USBH_PdoInternalControl(), USBH_PdoIoctlGetPortStatus(), USBH_PdoIoctlResetPort(), USBH_PdoUrbFilter(), USBH_ResetPortWorker(), and USBH_StartHubFdoDevice().
◆ USBH_CompletePowerIrp()
| VOID NTAPI USBH_CompletePowerIrp | ( | IN PUSBHUB_FDO_EXTENSION | HubExtension, |
| IN PIRP | Irp, | ||
| IN NTSTATUS | NtStatus | ||
| ) |
Definition at line 18 of file power.c.
21{
23 HubExtension,
24 Irp,
25 NtStatus);
26
27 Irp->IoStatus.Status = NtStatus;
28
30
32 {
33 KeSetEvent(&HubExtension->PendingRequestEvent,
34 EVENT_INCREMENT,
35 FALSE);
36 }
37
39}
Referenced by USBH_FdoCleanup(), and USBH_PdoRemoveDevice().
◆ USBH_CreateDevice()
| NTSTATUS NTAPI USBH_CreateDevice | ( | IN PUSBHUB_FDO_EXTENSION | HubExtension, |
| IN USHORT | Port, | ||
| IN USB_PORT_STATUS | UsbPortStatus, | ||
| IN ULONG | IsWait | ||
| ) |
Definition at line 4394 of file usbhub.c.
4398{
4399 ULONG PdoNumber = 0;
4400 WCHAR CharDeviceName[64];
4403 PUSBHUB_PORT_PDO_EXTENSION PortExtension;
4405 LPWSTR SerialNumberBuffer;
4406 BOOLEAN IsHsDevice;
4407 BOOLEAN IsLsDevice;
4411
4413 Port,
4414 UsbPortStatus.AsUshort16);
4415
4416 do
4417 {
4418 RtlStringCbPrintfW(CharDeviceName,
4419 sizeof(CharDeviceName),
4421 PdoNumber);
4422
4424
4427 &DeviceName,
4428 FILE_DEVICE_USB,
4429 0,
4430 FALSE,
4431 &DeviceObject);
4432
4433 ++PdoNumber;
4434 }
4436
4438 {
4442 }
4443
4444 DeviceObject->StackSize = HubExtension->RootHubPdo2->StackSize;
4445
4446 PortExtension = DeviceObject->DeviceExtension;
4447
4450
4452
4455
4456 PortExtension->HubExtension = HubExtension;
4457 PortExtension->RootHubExtension = HubExtension;
4458
4462
4464
4467
4468 PortExtension->PoRequestCounter = 0;
4469 PortExtension->PendingSystemPoRequest = 0;
4470 PortExtension->PendingDevicePoRequest = 0;
4471 PortExtension->StateBehindD2 = 0;
4472
4473 SerialNumberBuffer = NULL;
4474
4475 IsHsDevice = UsbPortStatus.Usb20PortStatus.HighSpeedDeviceAttached;
4476 IsLsDevice = UsbPortStatus.Usb20PortStatus.LowSpeedDeviceAttached;
4477
4478 if (IsLsDevice == 0)
4479 {
4480 if (IsHsDevice)
4481 {
4483 }
4484 }
4485 else
4486 {
4488 }
4489
4490 /* Initialize PortExtension->InstanceID */
4494
4496 DeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
4497
4499 {
4502 }
4503
4505 &PortExtension->DeviceHandle,
4506 UsbPortStatus,
4507 Port);
4508
4510 {
4513 }
4514
4516
4518 {
4521 }
4522
4523 if (IsWait)
4524 {
4525 USBH_Wait(50);
4526 }
4527
4529 PortExtension->DeviceHandle,
4534
4536 {
4540 }
4541
4543 //Status = USBH_RegQueryDeviceIgnoreHWSerNumFlag(PortExtension->DeviceDescriptor.idVendor,
4544 // PortExtension->DeviceDescriptor.idProduct,
4545 // &IgnoringHwSerial);
4546
4548 {
4549 IgnoringHwSerial = FALSE;
4550 }
4551
4552 if (IgnoringHwSerial)
4553 {
4555 }
4556
4558 !PortExtension->IgnoringHwSerial)
4559 {
4561
4563 &SerialNumberBuffer,
4564 &PortExtension->SN_DescriptorLength,
4567
4568 if (SerialNumberBuffer)
4569 {
4571 {
4573 SerialNumberBuffer = NULL;
4574 }
4575
4576 if (SerialNumberBuffer &&
4577 !USBH_CheckDeviceIDUnique(HubExtension,
4580 SerialNumberBuffer,
4581 PortExtension->SN_DescriptorLength))
4582 {
4584 SerialNumberBuffer = NULL;
4585 }
4586 }
4587
4589 SerialNumberBuffer);
4590 }
4591
4593
4594 USBH_PdoSetCapabilities(PortExtension);
4595
4597 {
4599 }
4600
4601ErrorExit:
4602
4604
4606 NULL);
4607
4609 {
4611 }
4612
4614 NULL);
4615
4616 if (SerialNumberBuffer)
4617 {
4619 }
4620
4621Exit:
4622
4626}
NTSYSAPI NTSTATUS NTAPI RtlIntegerToUnicodeString(ULONG Value, ULONG Base, PUNICODE_STRING String)
NTSTATUS NTAPI IoCreateDevice(IN PDRIVER_OBJECT DriverObject, IN ULONG DeviceExtensionSize, IN PUNICODE_STRING DeviceName, IN DEVICE_TYPE DeviceType, IN ULONG DeviceCharacteristics, IN BOOLEAN Exclusive, OUT PDEVICE_OBJECT *DeviceObject)
Definition: device.c:1031
NTSTRSAFEVAPI RtlStringCbPrintfW(_Out_writes_bytes_(cbDest) _Always_(_Post_z_) NTSTRSAFE_PWSTR pszDest, _In_ size_t cbDest, _In_ _Printf_format_string_ NTSTRSAFE_PCWSTR pszFormat,...)
Definition: ntstrsafe.h:1173
KSPIN_LOCK PortPowerListSpinLock
Definition: usbhub.h:234
USB_DEVICE_DESCRIPTOR DeviceDescriptor
Definition: usbhub.h:216
LONG PendingDevicePoRequest
Definition: usbhub.h:230
PUSBHUB_FDO_EXTENSION RootHubExtension
Definition: usbhub.h:210
USB_CONFIGURATION_DESCRIPTOR ConfigDescriptor
Definition: usbhub.h:218
KSPIN_LOCK PortTimeoutSpinLock
Definition: usbhub.h:226
LONG PendingSystemPoRequest
Definition: usbhub.h:229
Definition: usb100.h:136
VOID NTAPI USBH_PdoSetCapabilities(IN PUSBHUB_PORT_PDO_EXTENSION PortExtension)
Definition: usbhub.c:3996
NTSTATUS NTAPI USBD_RemoveDeviceEx(IN PUSBHUB_FDO_EXTENSION HubExtension, IN PUSB_DEVICE_HANDLE DeviceHandle, IN ULONG Flags)
Definition: usbhub.c:2553
NTSTATUS NTAPI USBH_ProcessDeviceInformation(IN PUSBHUB_PORT_PDO_EXTENSION PortExtension)
Definition: usbhub.c:4071
NTSTATUS NTAPI USBD_InitializeDeviceEx(IN PUSBHUB_FDO_EXTENSION HubExtension, IN PUSB_DEVICE_HANDLE DeviceHandle, IN PUCHAR DeviceDescriptorBuffer, IN ULONG DeviceDescriptorBufferLength, IN PUCHAR ConfigDescriptorBuffer, IN ULONG ConfigDescriptorBufferLength)
Definition: usbhub.c:2577
BOOLEAN NTAPI USBH_ValidateSerialNumberString(IN PUSHORT SerialNumberString)
Definition: usbhub.c:4234
NTSTATUS NTAPI USBD_CreateDeviceEx(IN PUSBHUB_FDO_EXTENSION HubExtension, IN PUSB_DEVICE_HANDLE *OutDeviceHandle, IN USB_PORT_STATUS UsbPortStatus, IN USHORT Port)
Definition: usbhub.c:2523
NTSTATUS NTAPI USBH_SyncResetPort(IN PUSBHUB_FDO_EXTENSION HubExtension, IN USHORT Port)
Definition: usbhub.c:471
BOOLEAN NTAPI USBH_CheckDeviceIDUnique(IN PUSBHUB_FDO_EXTENSION HubExtension, IN USHORT idVendor, IN USHORT idProduct, IN PVOID SerialNumber, IN USHORT SN_DescriptorLength)
Definition: usbhub.c:4182
NTSTATUS NTAPI USBH_GetSerialNumberString(IN PDEVICE_OBJECT DeviceObject, IN LPWSTR *OutSerialNumber, IN PUSHORT OutDescriptorLength, IN USHORT LanguageId, IN UCHAR Index)
Definition: usbhub.c:4319
_Must_inspect_result_ _In_ PWDFDEVICE_INIT _In_opt_ PCUNICODE_STRING DeviceName
Definition: wdfdevice.h:3281
#define DO_POWER_PAGABLE
Referenced by USBH_FdoQueryBusRelations().
◆ USBH_DeviceControl()
Definition at line 1136 of file ioctl.c.
1138{
1140 PIO_STACK_LOCATION IoStack;
1143
1145 HubExtension,
1146 Irp);
1147
1151
1153 (HubExtension->HubFlags & USBHUB_FDO_FLAG_DEVICE_STARTED))
1154 {
1155 IsCheckHubIdle = TRUE;
1156 USBH_HubSetD0(HubExtension);
1157 }
1158
1160 {
1161 case IOCTL_USB_GET_HUB_CAPABILITIES:
1164 {
1166 break;
1167 }
1168
1170 break;
1171
1172 case IOCTL_USB_HUB_CYCLE_PORT:
1174 DbgBreakPoint();
1175 break;
1176
1180 {
1182 break;
1183 }
1184
1186 break;
1187
1191 {
1193 Irp,
1194 FALSE);
1195 break;
1196 }
1197
1199 break;
1200
1201 case IOCTL_USB_GET_NODE_CONNECTION_INFORMATION_EX:
1204 {
1206 Irp,
1207 TRUE);
1208 break;
1209 }
1210
1212 break;
1213
1214 case IOCTL_USB_GET_NODE_CONNECTION_ATTRIBUTES:
1217 {
1219 break;
1220 }
1221
1223 break;
1224
1228 {
1230 break;
1231 }
1232
1234 break;
1235
1239 {
1241 break;
1242 }
1243
1245 break;
1246
1250 {
1252 break;
1253 }
1254
1256 break;
1257
1262 break;
1263
1264 default:
1267 break;
1268 }
1269
1270 if (IsCheckHubIdle)
1271 {
1272 USBH_CheckHubIdle(HubExtension);
1273 }
1274
1276}
static PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(PIRP Irp)
Definition: Bus_PDO_EvalMethod.c:152
NTSTATUS NTAPI USBH_IoctlGetNodeName(IN PUSBHUB_FDO_EXTENSION HubExtension, IN PIRP Irp)
Definition: ioctl.c:563
NTSTATUS NTAPI USBH_IoctlGetNodeConnectionInformation(IN PUSBHUB_FDO_EXTENSION HubExtension, IN PIRP Irp, IN BOOLEAN IsExt)
Definition: ioctl.c:834
NTSTATUS NTAPI USBH_IoctlGetNodeConnectionAttributes(IN PUSBHUB_FDO_EXTENSION HubExtension, IN PIRP Irp)
Definition: ioctl.c:779
NTSTATUS NTAPI USBH_IoctlGetHubCapabilities(IN PUSBHUB_FDO_EXTENSION HubExtension, IN PIRP Irp)
Definition: ioctl.c:731
NTSTATUS NTAPI USBH_IoctlGetDescriptor(IN PUSBHUB_FDO_EXTENSION HubExtension, IN PIRP Irp)
Definition: ioctl.c:1024
NTSTATUS NTAPI USBH_IoctlGetNodeConnectionDriverKeyName(IN PUSBHUB_FDO_EXTENSION HubExtension, IN PIRP Irp)
Definition: ioctl.c:947
NTSTATUS NTAPI USBH_IoctlGetNodeInformation(IN PUSBHUB_FDO_EXTENSION HubExtension, IN PIRP Irp)
Definition: ioctl.c:684
NTSTATUS NTAPI USBH_HubSetD0(IN PUSBHUB_FDO_EXTENSION HubExtension)
Definition: power.c:104
NTSYSAPI void WINAPI DbgBreakPoint(void)
Definition: Bus_PDO_EvalMethod.c:95
struct _IO_STACK_LOCATION::@1710::@1711 DeviceIoControl
union _IO_STACK_LOCATION::@1710 Parameters
VOID NTAPI USBH_CheckHubIdle(IN PUSBHUB_FDO_EXTENSION HubExtension)
Definition: usbhub.c:3823
VOID NTAPI USBH_CompleteIrp(IN PIRP Irp, IN NTSTATUS CompleteStatus)
Definition: usbhub.c:63
NTSTATUS NTAPI USBH_PassIrp(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: usbhub.c:79
#define IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION
Definition: usbioctl.h:175
#define IOCTL_USB_GET_NODE_CONNECTION_DRIVERKEY_NAME
Definition: usbioctl.h:187
#define IOCTL_USB_GET_NODE_CONNECTION_INFORMATION
Definition: usbioctl.h:172
#define IOCTL_USB_GET_NODE_CONNECTION_NAME
Definition: usbioctl.h:178
Referenced by USBH_FdoDispatch().
◆ USBH_FdoPnP()
Definition at line 2362 of file pnp.c.
2365{
2367 PIO_STACK_LOCATION IoStack;
2368 DEVICE_RELATION_TYPE RelationsType;
2369 BOOLEAN IsCheckIdle;
2370
2372 HubExtension,
2373 Irp,
2374 Minor);
2375
2378 {
2379 HubExtension->HubFlags |= USBHUB_FDO_FLAG_DEVICE_SUSPENDED;
2380 }
2381
2382 KeWaitForSingleObject(&HubExtension->IdleSemaphore,
2383 Executive,
2384 KernelMode,
2385 FALSE,
2386 NULL);
2387
2389
2391 {
2392 HubExtension->HubFlags |= USBHUB_FDO_FLAG_DEVICE_SUSPENDED;
2393 }
2394
2397
2399 !(HubExtension->HubFlags & (USBHUB_FDO_FLAG_DEVICE_STOPPED | USBHUB_FDO_FLAG_DEVICE_STARTED)) ||
2401 {
2402 IsCheckIdle = FALSE;
2403 }
2404 else
2405 {
2407 IsCheckIdle = TRUE;
2408 USBH_HubSetD0(HubExtension);
2409 }
2410
2412 {
2415 IsCheckIdle = FALSE;
2418 break;
2419
2424 break;
2425
2428 IsCheckIdle = FALSE;
2429 HubExtension->HubFlags |= USBHUB_FDO_FLAG_DEVICE_REMOVED;
2432 break;
2433
2438 break;
2439
2442 IsCheckIdle = FALSE;
2445 break;
2446
2451 break;
2452
2457 break;
2458
2461
2463 {
2465 break;
2466 }
2467
2468 HubExtension->HubFlags |= USBHUB_FDO_FLAG_HUB_BUSY;
2469
2470 IsCheckIdle = TRUE;
2472
2474
2475 HubExtension->HubFlags &= ~USBHUB_FDO_FLAG_HUB_BUSY;
2476 break;
2477
2481 break;
2482
2486
2488 USBH_QueryCapsComplete,
2489 HubExtension,
2490 TRUE,
2491 FALSE,
2492 FALSE);
2493
2495 break;
2496
2500 break;
2501
2505 break;
2506
2510 break;
2511
2515 break;
2516
2520 break;
2521
2525 break;
2526
2530 break;
2531
2535 break;
2536
2540 break;
2541
2544
2546 {
2548 }
2549
2551 break;
2552
2556 break;
2557
2562 break;
2563
2568 break;
2569
2570 default:
2573 break;
2574 }
2575
2576 KeReleaseSemaphore(&HubExtension->IdleSemaphore,
2577 LOW_REALTIME_PRIORITY,
2578 1,
2579 FALSE);
2580
2581 if (IsCheckIdle)
2582 {
2584 USBH_CheckIdleDeferred(HubExtension);
2585 }
2586
2587 HubExtension->HubFlags &= ~USBHUB_FDO_FLAG_STATE_CHANGING;
2588
2590}
NTSTATUS NTAPI USBH_QueryCapsComplete(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context)
Definition: pnp.c:59
NTSTATUS NTAPI USBH_FdoStartDevice(IN PUSBHUB_FDO_EXTENSION HubExtension, IN PIRP Irp)
Definition: pnp.c:988
NTSTATUS NTAPI USBH_FdoRemoveDevice(IN PUSBHUB_FDO_EXTENSION HubExtension, IN PIRP Irp)
Definition: pnp.c:1463
NTSTATUS NTAPI USBH_FdoQueryBusRelations(IN PUSBHUB_FDO_EXTENSION HubExtension, IN PIRP Irp)
Definition: pnp.c:1027
NTSTATUS NTAPI USBH_FdoStopDevice(IN PUSBHUB_FDO_EXTENSION HubExtension, IN PIRP Irp)
Definition: pnp.c:1453
VOID NTAPI USBH_FdoSurpriseRemoveDevice(IN PUSBHUB_FDO_EXTENSION HubExtension, IN PIRP Irp)
Definition: pnp.c:1524
#define IoSetCompletionRoutine(_Irp, _CompletionRoutine, _Context, _InvokeOnSuccess, _InvokeOnError, _InvokeOnCancel)
Definition: irp.cpp:490
#define IoCopyCurrentIrpStackLocationToNext(Irp)
Definition: ntifs_ex.h:413
struct _IO_STACK_LOCATION::@4301::@4326 QueryDeviceRelations
VOID NTAPI USBH_CheckIdleDeferred(IN PUSBHUB_FDO_EXTENSION HubExtension)
Definition: usbhub.c:3972
#define IRP_MN_CANCEL_STOP_DEVICE
#define IRP_MN_QUERY_PNP_DEVICE_STATE
#define IRP_MN_EJECT
#define IRP_MN_QUERY_INTERFACE
#define IRP_MN_START_DEVICE
#define IRP_MN_DEVICE_USAGE_NOTIFICATION
#define IRP_MN_READ_CONFIG
#define IRP_MN_WRITE_CONFIG
#define IRP_MN_QUERY_RESOURCE_REQUIREMENTS
#define IRP_MN_QUERY_ID
#define IRP_MN_REMOVE_DEVICE
#define IRP_MN_FILTER_RESOURCE_REQUIREMENTS
#define IRP_MN_QUERY_DEVICE_RELATIONS
#define IRP_MN_QUERY_STOP_DEVICE
#define IRP_MN_QUERY_DEVICE_TEXT
#define IRP_MN_QUERY_CAPABILITIES
#define IRP_MN_QUERY_RESOURCES
#define IRP_MN_CANCEL_REMOVE_DEVICE
#define IRP_MN_STOP_DEVICE
#define IRP_MN_SET_LOCK
enum _DEVICE_RELATION_TYPE DEVICE_RELATION_TYPE
#define IRP_MN_QUERY_BUS_INFORMATION
#define IRP_MN_QUERY_REMOVE_DEVICE
Referenced by USBH_FdoDispatch().
◆ USBH_FdoPower()
Definition at line 551 of file power.c.
554{
556 PIO_STACK_LOCATION IoStack;
558 POWER_STATE DevicePwrState;
559 BOOLEAN IsAllPortsD3;
560 PUSBHUB_PORT_DATA PortData;
561 PDEVICE_OBJECT PdoDevice;
562 PUSBHUB_PORT_PDO_EXTENSION PortExtension;
564
566 HubExtension,
567 Irp,
568 Minor);
569
571 {
574
576
579 HubExtension,
580 TRUE,
581 TRUE,
582 TRUE);
583
586 PoCallDriver(HubExtension->LowerDevice, Irp);
587
589
592 break;
593
596
600
602 {
604 PowerState.DeviceState);
605
607 {
609
612 PoCallDriver(HubExtension->LowerDevice, Irp);
613
615 }
616
618 {
621 {
622 HubExtension->HubFlags &= ~(USBHUB_FDO_FLAG_NOT_D0_STATE |
624
625 HubExtension->HubFlags |= USBHUB_FDO_FLAG_SET_D0_STATE;
626
628
631 HubExtension,
632 TRUE,
633 TRUE,
634 TRUE);
635 }
636 else
637 {
640 }
641
643 PoCallDriver(HubExtension->LowerDevice, Irp);
645
649 if (HubExtension->ResetRequestCount)
650 {
651 IoCancelIrp(HubExtension->ResetPortIrp);
652
653 KeWaitForSingleObject(&HubExtension->ResetEvent,
654 Executive,
655 KernelMode,
656 FALSE,
657 NULL);
658 }
659
661 {
662 HubExtension->HubFlags |= (USBHUB_FDO_FLAG_NOT_D0_STATE |
664
665 IoCancelIrp(HubExtension->SCEIrp);
666
667 KeWaitForSingleObject(&HubExtension->StatusChangeEvent,
668 Executive,
669 KernelMode,
670 FALSE,
671 NULL);
672 }
673
674 HubExtension->CurrentPowerState.DeviceState = PowerState.DeviceState;
675
678 {
679 HubExtension->HubFlags &= ~(USBHUB_FDO_FLAG_NOT_D0_STATE |
681
682 HubExtension->CurrentPowerState.DeviceState = PowerDeviceD0;
683
684 USBH_SubmitStatusChangeTransfer(HubExtension);
685
687
690
691 HubExtension->HubFlags &= ~USBHUB_FDO_FLAG_DO_SUSPENSE;
692
693 KeReleaseSemaphore(&HubExtension->IdleSemaphore,
695 1,
696 FALSE);
697
699 }
700
702
705 HubExtension,
706 TRUE,
707 TRUE,
708 TRUE);
709
712 PoCallDriver(HubExtension->LowerDevice, Irp);
713
715 {
716 HubExtension->HubFlags &= ~USBHUB_FDO_FLAG_DO_SUSPENSE;
717
718 KeReleaseSemaphore(&HubExtension->IdleSemaphore,
720 1,
721 FALSE);
722 }
723
725
726 default:
728 DbgBreakPoint();
729 break;
730 }
731 }
732 else
733 {
735 {
737 PowerState.SystemState;
738 }
739
741 {
742 HubExtension->HubFlags |= USBHUB_FDO_FLAG_HIBERNATE_STATE;
743 }
744
745 PortData = HubExtension->PortData;
746
747 IsAllPortsD3 = TRUE;
748
749 if (PortData && HubExtension->HubDescriptor)
750 {
752 Port < HubExtension->HubDescriptor->bNumberOfPorts;
753 Port++)
754 {
756
757 if (PdoDevice)
758 {
759 PortExtension = PdoDevice->DeviceExtension;
760
762 {
763 IsAllPortsD3 = FALSE;
764 break;
765 }
766 }
767 }
768 }
769
771 {
773 }
775 !IsAllPortsD3)
776 {
778
780 {
782 }
783 }
784 else
785 {
787 }
788
790 HubExtension->HubFlags & USBHUB_FDO_FLAG_DEVICE_STARTED)
791 {
792 HubExtension->PowerIrp = Irp;
793
795
797 IRP_MN_SET_POWER,
798 DevicePwrState,
800 (PVOID)HubExtension,
802 {
804 }
805
808 PoCallDriver(HubExtension->LowerDevice, Irp);
809
811 }
812
813 Exit:
814
815 HubExtension->SystemPowerState.SystemState = PowerState.SystemState;
816
818 {
819 USBH_CheckIdleDeferred(HubExtension);
820 }
821
824
826 }
827
828 break;
829
832 break;
833
834 default:
836 break;
837 }
838
842
844}
NTSTATUS NTAPI USBH_PowerIrpCompletion(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context)
Definition: power.c:440
VOID NTAPI USBH_FdoDeferPoRequestCompletion(IN PDEVICE_OBJECT DeviceObject, IN UCHAR MinorFunction, IN POWER_STATE PowerState, IN PVOID Context, IN PIO_STATUS_BLOCK IoStatus)
Definition: power.c:513
NTSTATUS NTAPI USBH_FdoWWIrpIoCompletion(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context)
Definition: power.c:362
IoMarkIrpPending(Irp)
NTSTATUS NTAPI PoRequestPowerIrp(_In_ PDEVICE_OBJECT DeviceObject, _In_ UCHAR MinorFunction, _In_ POWER_STATE PowerState, _In_opt_ PREQUEST_POWER_COMPLETE CompletionFunction, _In_opt_ __drv_aliasesMem PVOID Context, _Outptr_opt_ PIRP *pIrp)
Definition: power.c:659
struct _IO_STACK_LOCATION::@4301::@4337 Power
Definition: ntpoapi.h:56
NTSTATUS NTAPI USBH_SubmitStatusChangeTransfer(IN PUSBHUB_FDO_EXTENSION HubExtension)
Definition: usbhub.c:2457
BOOLEAN NTAPI USBH_CheckIdleAbort(IN PUSBHUB_FDO_EXTENSION HubExtension, IN BOOLEAN IsWait, IN BOOLEAN IsExtCheck)
Definition: usbhub.c:3236
_Must_inspect_result_ _In_ PWDFDEVICE_INIT _In_ WDF_DEVICE_POWER_STATE PowerState
Definition: wdfdevice.h:3040
#define IRP_MN_WAIT_WAKE
#define IRP_MN_POWER_SEQUENCE
#define IRP_MN_SET_POWER
#define IRP_MN_QUERY_POWER
Referenced by USBH_FdoDispatch().
◆ USBH_FdoSyncSubmitUrb()
Definition at line 355 of file usbhub.c.
357{
358 PUSBHUB_FDO_EXTENSION HubExtension;
359
361 FdoDevice,
362 Urb);
363
364 HubExtension = FdoDevice->DeviceExtension;
366}
Definition: usbhub.h:147
NTSTATUS NTAPI USBH_SyncSubmitUrb(IN PDEVICE_OBJECT DeviceObject, IN PURB Urb)
Definition: usbhub.c:250
Referenced by USBH_AbortInterruptPipe(), USBH_GetDeviceDescriptor(), USBH_OpenConfiguration(), USBH_ResetInterruptPipe(), USBH_SyncGetDeviceConfigurationDescriptor(), USBH_SyncGetStatus(), and USBH_Transact().
◆ USBH_FreeWorkItem()
| VOID NTAPI USBH_FreeWorkItem | ( | IN PUSBHUB_IO_WORK_ITEM | HubIoWorkItem | ) |
Definition at line 2952 of file usbhub.c.
2953{
2955
2957
2958 WorkItem = HubIoWorkItem->HubWorkItem;
2959
2960 if (HubIoWorkItem->HubWorkItemBuffer)
2961 {
2963 }
2964
2966
2968}
Definition: io.h:311
_Must_inspect_result_ _In_ PWDF_WORKITEM_CONFIG _In_ PWDF_OBJECT_ATTRIBUTES _Out_ WDFWORKITEM * WorkItem
Definition: wdfworkitem.h:115
Referenced by USBH_ChangeIndicationProcessChange().
◆ USBH_GetConfigurationDescriptor()
| NTSTATUS NTAPI USBH_GetConfigurationDescriptor | ( | IN PDEVICE_OBJECT | DeviceObject, |
| IN PUSB_CONFIGURATION_DESCRIPTOR * | pConfigurationDescriptor | ||
| ) |
Definition at line 974 of file usbhub.c.
976{
978 ULONG ReturnedLen;
979 SIZE_T DescriptorLen;
981
983
984 DescriptorLen = MAXUCHAR;
985
987 {
989 DescriptorLen,
990 USB_HUB_TAG);
991
993 {
995 break;
996 }
997
999 ConfigDescriptor,
1000 DescriptorLen,
1001 &ReturnedLen);
1002
1004 {
1006 }
1007
1009 {
1010 break;
1011 }
1012
1013 *OutDescriptor = ConfigDescriptor;
1014
1016 {
1017 break;
1018 }
1019
1020 DescriptorLen = ConfigDescriptor->wTotalLength;
1021
1023 *OutDescriptor = NULL;
1024 }
1025
1027 {
1028 if (ReturnedLen < ConfigDescriptor->wTotalLength)
1029 {
1031 }
1032 }
1033 else
1034 {
1036 {
1038 }
1039
1040 *OutDescriptor = NULL;
1041 }
1042
1044}
NTSTATUS NTAPI USBH_SyncGetDeviceConfigurationDescriptor(IN PDEVICE_OBJECT DeviceObject, IN PUSB_CONFIGURATION_DESCRIPTOR ConfigDescriptor, IN ULONG NumberOfBytes, IN PULONG OutLength)
Definition: usbhub.c:913
_Must_inspect_result_ _In_ WDFUSBDEVICE _Out_writes_bytes_to_opt_ ConfigDescriptorLength PVOID ConfigDescriptor
Definition: wdfusb.h:1036
Referenced by USBH_ProcessDeviceInformation(), and USBH_StartHubFdoDevice().
◆ USBH_GetDeviceDescriptor()
| NTSTATUS NTAPI USBH_GetDeviceDescriptor | ( | IN PDEVICE_OBJECT | DeviceObject, |
| IN PUSB_DEVICE_DESCRIPTOR | HubDeviceDescriptor | ||
| ) |
Definition at line 877 of file usbhub.c.
879{
882
884
887 USB_HUB_TAG);
888
890 {
893 }
894
896
899
901 Urb->TransferBuffer = HubDeviceDescriptor;
903
905
907
909}
Definition: usb.h:340
struct _USB_DEVICE_DESCRIPTOR USB_DEVICE_DESCRIPTOR
#define URB_FUNCTION_GET_DESCRIPTOR_FROM_DEVICE
Definition: usb.h:97
NTSTATUS NTAPI USBH_FdoSyncSubmitUrb(IN PDEVICE_OBJECT FdoDevice, IN PURB Urb)
Definition: usbhub.c:355
Referenced by USBH_StartHubFdoDevice().
◆ USBH_GetDeviceType()
| NTSTATUS NTAPI USBH_GetDeviceType | ( | IN PUSBHUB_FDO_EXTENSION | HubExtension, |
| IN PUSB_DEVICE_HANDLE | DeviceHandle, | ||
| OUT USB_DEVICE_TYPE * | OutDeviceType | ||
| ) |
Definition at line 608 of file usbhub.c.
611{
618
620
621 QueryDeviceInformation = HubExtension->BusInterface.QueryDeviceInformation;
622
624 {
627 }
628
630
632 {
635 USB_HUB_TAG);
636
638 {
641 break;
642 }
643
645
646 DeviceInfo->InformationLevel = 0;
647
649 DeviceHandle,
650 DeviceInfo,
652 &dummy);
653
655 {
657 {
659 }
660
662 break;
663 }
664
667 }
668
669 if (OutDeviceType)
670 {
671 *OutDeviceType = DeviceType;
673 }
674
676}
_In_ PUSB_DEVICE_HANDLE _In_ ULONG DeviceInformationBufferLength
Definition: hubbusif.h:181
enum _USB_DEVICE_TYPE USB_DEVICE_TYPE
Referenced by USBH_StartHubFdoDevice().
◆ USBH_GetRootHubExtension()
| PUSBHUB_FDO_EXTENSION NTAPI USBH_GetRootHubExtension | ( | IN PUSBHUB_FDO_EXTENSION | HubExtension | ) |
Definition at line 699 of file usbhub.c.
700{
702 PUSBHUB_FDO_EXTENSION RootHubExtension;
703
705
706 RootHubExtension = HubExtension;
707
708 if (HubExtension->LowerPDO != HubExtension->RootHubPdo)
709 {
711
712 do
713 {
715 }
717
718 RootHubExtension = Device->DeviceExtension;
719 }
720
722
723 return RootHubExtension;
724}
Referenced by USBH_CheckHubIdle(), USBH_FdoPower(), USBH_HubSetD0(), and USBH_HubStartESDRecovery().
◆ USBH_HubCancelIdleIrp()
Definition at line 3221 of file usbhub.c.
Referenced by USBH_FdoCleanup(), USBH_FdoIdleNotificationCallback(), USBH_HubQueuePortIdleIrps(), and USBH_PortIdleNotificationCancelRoutine().
◆ USBH_HubCancelWakeIrp()
Definition at line 43 of file power.c.
Referenced by USBH_FdoCleanup().
◆ USBH_HubCompletePortWakeIrps()
| VOID NTAPI USBH_HubCompletePortWakeIrps | ( | IN PUSBHUB_FDO_EXTENSION | HubExtension, |
| IN NTSTATUS | NtStatus | ||
| ) |
Definition at line 308 of file power.c.
310{
311 LIST_ENTRY ListIrps;
312
314
316 {
317 USBH_HubQueuePortWakeIrps(HubExtension, &ListIrps);
318
319 USBH_HubCompleteQueuedPortWakeIrps(HubExtension,
320 &ListIrps,
321 NtStatus);
322 }
323}
VOID NTAPI USBH_HubQueuePortWakeIrps(IN PUSBHUB_FDO_EXTENSION HubExtension, IN PLIST_ENTRY ListIrps)
Definition: power.c:251
VOID NTAPI USBH_HubCompleteQueuedPortWakeIrps(IN PUSBHUB_FDO_EXTENSION HubExtension, IN PLIST_ENTRY ListIrps, IN NTSTATUS NtStatus)
Definition: power.c:293
Definition: typedefs.h:120
Referenced by USBH_FdoCleanup(), and USBH_FdoPoRequestD0Completion().
◆ USBH_HubIsBusPowered()
| BOOLEAN NTAPI USBH_HubIsBusPowered | ( | IN PDEVICE_OBJECT | DeviceObject, |
| IN PUSB_CONFIGURATION_DESCRIPTOR | HubConfigDescriptor | ||
| ) |
Definition at line 1589 of file usbhub.c.
1591{
1593 USHORT UsbStatus;
1595
1597
1599 &UsbStatus,
1601 0);
1602
1604 {
1606 == USB_CONFIG_BUS_POWERED;
1607 }
1608 else
1609 {
1611 }
1612
1614}
NTSTATUS NTAPI USBH_SyncGetStatus(IN PDEVICE_OBJECT DeviceObject, IN PUSHORT OutStatus, IN USHORT Function, IN USHORT RequestIndex)
Definition: usbhub.c:1323
Referenced by USBH_IoctlGetNodeInformation(), and USBH_StartHubFdoDevice().
◆ USBH_HubSetD0()
| NTSTATUS NTAPI USBH_HubSetD0 | ( | IN PUSBHUB_FDO_EXTENSION | HubExtension | ) |
Definition at line 104 of file power.c.
105{
106 PUSBHUB_FDO_EXTENSION RootHubDevExt;
110
112
113 RootHubDevExt = USBH_GetRootHubExtension(HubExtension);
114
116 {
119 }
120
122 {
124
125 KeWaitForSingleObject(&HubExtension->IdleEvent,
126 Suspended,
127 KernelMode,
128 FALSE,
129 NULL);
130 }
131
133
135
137 IRP_MN_SET_POWER,
138 PowerState,
140 &Event,
141 NULL);
142
144 {
146 Suspended,
147 KernelMode,
148 FALSE,
149 NULL);
150 }
151
153 {
154 USBH_Wait(10);
155 }
156
158}
VOID NTAPI USBH_HubESDRecoverySetD3Completion(IN PDEVICE_OBJECT DeviceObject, IN UCHAR MinorFunction, IN POWER_STATE PowerState, IN PVOID Context, IN PIO_STATUS_BLOCK IoStatus)
Definition: power.c:62
Definition: filtergraph.c:51
Definition: ketypes.h:863
Referenced by USBH_DeviceControl(), USBH_FdoPnP(), USBH_IdleCancelPowerHubWorker(), USBH_IdleCompletePowerHubWorker(), and USBH_PdoRemoveDevice().
◆ USBH_HubStartESDRecovery()
| NTSTATUS NTAPI USBH_HubStartESDRecovery | ( | IN PUSBHUB_FDO_EXTENSION | HubExtension | ) |
Definition at line 162 of file power.c.
163{
164 PUSBHUB_FDO_EXTENSION RootHubDevExt;
168
170
171 RootHubDevExt = USBH_GetRootHubExtension(HubExtension);
172
174 {
176 HubExtension->HubFlags &= ~USBHUB_FDO_FLAG_ESD_RECOVERING;
178 }
179
181
182 /* First, set the hub to D3 (power off) */
184
186 IRP_MN_SET_POWER,
187 PowerState,
189 &Event,
190 NULL);
192 {
194 Suspended,
195 KernelMode,
196 FALSE,
197 NULL);
198 }
200 {
202 HubExtension->HubFlags &= ~USBHUB_FDO_FLAG_ESD_RECOVERING;
204 }
205
206 /* Now set it back to D0 (power on) to complete the recovery */
208
210 IRP_MN_SET_POWER,
211 PowerState,
213 HubExtension,
214 NULL);
216 {
218 HubExtension->HubFlags &= ~USBHUB_FDO_FLAG_ESD_RECOVERING;
219 }
220
222}
VOID NTAPI USBH_HubESDRecoverySetD0Completion(IN PDEVICE_OBJECT DeviceObject, IN UCHAR MinorFunction, IN POWER_STATE PowerState, IN PVOID Context, IN PIO_STATUS_BLOCK IoStatus)
Definition: power.c:77
Referenced by USBH_ChangeIndicationWorker().
◆ USBH_IdleCancelPowerHubWorker()
| VOID NTAPI USBH_IdleCancelPowerHubWorker | ( | IN PUSBHUB_FDO_EXTENSION | HubExtension, |
| IN PVOID | Context | ||
| ) |
Definition at line 226 of file power.c.
228{
229 PUSBHUB_IDLE_PORT_CANCEL_CONTEXT WorkItemIdlePower;
231
233
234 WorkItemIdlePower = Context;
235
236 if (HubExtension &&
237 HubExtension->CurrentPowerState.DeviceState != PowerDeviceD0 &&
238 HubExtension->HubFlags & USBHUB_FDO_FLAG_DEVICE_STARTED)
239 {
240 USBH_HubSetD0(HubExtension);
241 }
242
245
247}
Definition: compobj.c:4795
Definition: Bus_PDO_EvalMethod.c:107
Definition: usbhub.h:263
Referenced by USBH_PortIdleNotificationCancelRoutine().
◆ USBH_PassIrp()
Definition at line 79 of file usbhub.c.
Referenced by USBH_DeviceControl(), USBH_FdoDispatch(), USBH_FdoPnP(), USBH_FdoQueryBusRelations(), USBH_FdoRemoveDevice(), USBH_PdoInternalControl(), USBH_PdoIoctlSubmitUrb(), USBH_PdoPnP(), and USBH_PdoUrbFilter().
◆ USBH_PdoInternalControl()
Definition at line 1280 of file ioctl.c.
1282{
1283 PUSBHUB_FDO_EXTENSION HubExtension;
1286 PIO_STACK_LOCATION IoStack;
1287 PULONG HubCount;
1288
1290 PortExtension,
1291 Irp);
1292
1293 HubExtension = PortExtension->HubExtension;
1294
1296 {
1299 }
1300
1302 {
1305 }
1306
1309
1311 {
1312 HubExtension = PortExtension->RootHubExtension;
1314 }
1315
1316 if (!HubExtension)
1317 {
1320 }
1321
1323 {
1326
1327 case IOCTL_INTERNAL_USB_SUBMIT_IDLE_NOTIFICATION:
1330
1334
1338
1341 DbgBreakPoint();
1342 break;
1343
1346 DbgBreakPoint();
1347 break;
1348
1349 case IOCTL_INTERNAL_USB_GET_DEVICE_HANDLE:
1353 break;
1354
1357 PortExtension->PortPdoFlags);
1358
1360 {
1362 break;
1363 }
1364
1366
1367 ++*HubCount;
1368
1370 HubCount);
1371
1373 break;
1374
1377 PortExtension->PortPdoFlags);
1378
1380 {
1381 DbgBreakPoint();
1383
1385
1387 break;
1388 }
1389
1392
1395 DbgBreakPoint();
1396 break;
1397
1400 DbgBreakPoint();
1401 break;
1402
1405 DbgBreakPoint();
1406 break;
1407
1410 DbgBreakPoint();
1411 break;
1412
1413 default:
1415 break;
1416 }
1417
1418Exit:
1421}
NTSTATUS NTAPI USBH_PdoIoctlGetPortStatus(IN PUSBHUB_PORT_PDO_EXTENSION PortExtension, IN PIRP Irp)
Definition: ioctl.c:239
NTSTATUS NTAPI USBH_PortIdleNotificationRequest(IN PUSBHUB_PORT_PDO_EXTENSION PortExtension, IN PIRP Irp)
Definition: ioctl.c:487
NTSTATUS NTAPI USBH_PdoIoctlSubmitUrb(IN PUSBHUB_PORT_PDO_EXTENSION PortExtension, IN PIRP Irp)
Definition: ioctl.c:210
NTSTATUS NTAPI USBH_PdoIoctlResetPort(IN PUSBHUB_PORT_PDO_EXTENSION PortExtension, IN PIRP Irp)
Definition: ioctl.c:379
struct _IO_STACK_LOCATION::@4301::@4340 Others
NTSTATUS NTAPI USBH_SyncGetHubCount(IN PDEVICE_OBJECT DeviceObject, IN OUT PULONG OutHubCount)
Definition: usbhub.c:781
#define IOCTL_INTERNAL_USB_GET_PARENT_HUB_INFO
Definition: usbioctl.h:68
#define IOCTL_INTERNAL_USB_GET_ROOTHUB_PDO
Definition: usbioctl.h:38
#define IOCTL_INTERNAL_USB_GET_PORT_STATUS
Definition: usbioctl.h:44
Referenced by USBH_PdoDispatch().
◆ USBH_PdoPnP()
| NTSTATUS NTAPI USBH_PdoPnP | ( | IN PUSBHUB_PORT_PDO_EXTENSION | PortExtension, |
| IN PIRP | Irp, | ||
| IN UCHAR | Minor, | ||
| OUT BOOLEAN * | IsCompleteIrp | ||
| ) |
Definition at line 2594 of file pnp.c.
2598{
2600 PIO_STACK_LOCATION IoStack;
2601 PPNP_BUS_INFORMATION BusInfo;
2605 PUSBHUB_FDO_EXTENSION HubExtension;
2606 PDEVICE_RELATIONS DeviceRelation;
2607
2609 PortExtension,
2610 Irp,
2611 Minor);
2612
2614
2615 *IsCompleteIrp = TRUE;
2616
2618 {
2622
2626
2630
2634
2638
2642
2646
2649
2651 {
2653 }
2654
2657 USB_HUB_TAG);
2658
2659 if (DeviceRelation)
2660 {
2662
2663 DeviceRelation->Count = 1;
2664 DeviceRelation->Objects[0] = PortExtension->Common.SelfDevice;
2665
2667
2669 }
2670 else
2671 {
2673 }
2674
2676 break;
2677
2680
2681 *IsCompleteIrp = 0;
2682
2684 &USB_BUS_INTERFACE_USBDI_GUID))
2685 {
2687 }
2688
2689 HubExtension = PortExtension->HubExtension;
2690
2691 if (!HubExtension)
2692 {
2693 HubExtension = PortExtension->RootHubExtension;
2694 }
2695
2697 break;
2698
2701
2703
2706
2708 &PortExtension->Capabilities,
2710
2713
2714 /* All devices connected to a hub are removable */
2715 DeviceCapabilities->Removable = 1;
2716
2718 break;
2719
2723 break;
2724
2727 PortExtension->PortPdoFlags |= USBHUB_PDO_FLAG_ENUMERATED;
2728
2729 /* FIXME HKEY_LOCAL_MACHINE\SYSTEM\ControlSetXXX\Enum\USB\
2730 Vid_????&Pid_????\????????????\Device Parameters\
2731 if (ExtPropDescSemaphore)
2732 */
2733
2735 break;
2736
2740
2744 break;
2745
2748 DbgBreakPoint();
2750 break;
2751
2754 DbgBreakPoint();
2756 break;
2757
2760 DbgBreakPoint();
2762 break;
2763
2766 DbgBreakPoint();
2768 break;
2769
2773
2780 {
2782 }
2783
2785 break;
2786
2789
2792 USB_HUB_TAG);
2793
2794 if (!BusInfo)
2795 {
2797 }
2798
2800
2802 &GUID_BUS_TYPE_USB,
2804
2806 BusInfo->BusNumber = 0;
2807
2810 break;
2811
2814 DbgBreakPoint();
2816 break;
2817
2821 {
2823
2825 {
2826 PortExtension->PortPdoFlags &= ~USBHUB_PDO_FLAG_REG_DEV_INTERFACE;
2827 }
2828 }
2829
2831 break;
2832
2833 default:
2836 break;
2837 }
2838
2840}
NTSTATUS NTAPI USBH_PdoStopDevice(IN PUSBHUB_PORT_PDO_EXTENSION PortExtension, IN PIRP Irp)
Definition: pnp.c:2352
NTSTATUS NTAPI USBH_PdoRemoveDevice(IN PUSBHUB_PORT_PDO_EXTENSION PortExtension, IN PUSBHUB_FDO_EXTENSION HubExtension)
Definition: pnp.c:2180
NTSTATUS NTAPI USBH_PdoStartDevice(IN PUSBHUB_PORT_PDO_EXTENSION PortExtension, IN PIRP Irp)
Definition: pnp.c:2124
NTSTATUS NTAPI USBH_PdoQueryDeviceText(IN PUSBHUB_PORT_PDO_EXTENSION PortExtension, IN PIRP Irp)
Definition: pnp.c:1853
NTSTATUS NTAPI USBH_SymbolicLink(IN PUSBHUB_PORT_PDO_EXTENSION PortExtension, IN const GUID *InterfaceClassGuid, IN BOOLEAN IsEnable)
Definition: pnp.c:2008
NTSTATUS NTAPI USBH_PdoQueryId(IN PUSBHUB_PORT_PDO_EXTENSION PortExtension, IN PIRP Irp)
Definition: pnp.c:1561
Definition: iotypes.h:2163
struct _IO_STACK_LOCATION::@4301::@4327 QueryInterface
struct _IO_STACK_LOCATION::@4301::@4328 DeviceCapabilities
Definition: cmtypes.h:363
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ DEVPROPTYPE _In_ ULONG Size
Definition: wdfdevice.h:4539
_Must_inspect_result_ _In_ WDFDEVICE _In_ LPCGUID _Out_ PINTERFACE _In_ USHORT _In_ USHORT Version
Definition: wdffdo.h:469
Referenced by USBH_PdoDispatch().
◆ USBH_PdoPower()
| NTSTATUS NTAPI USBH_PdoPower | ( | IN PUSBHUB_PORT_PDO_EXTENSION | PortExtension, |
| IN PIRP | Irp, | ||
| IN UCHAR | Minor | ||
| ) |
◆ USBH_PdoRemoveDevice()
| NTSTATUS NTAPI USBH_PdoRemoveDevice | ( | IN PUSBHUB_PORT_PDO_EXTENSION | PortExtension, |
| IN PUSBHUB_FDO_EXTENSION | HubExtension | ||
| ) |
Definition at line 2180 of file pnp.c.
2182{
2184 PDEVICE_OBJECT PortDevice;
2185 PUSBHUB_PORT_PDO_EXTENSION PortExt;
2186 PUSBHUB_PORT_DATA PortData;
2187 PIRP IdleNotificationIrp;
2188 PIRP WakeIrp;
2194
2196
2197 PortDevice = PortExtension->Common.SelfDevice;
2198 PortExtension->HubExtension = NULL;
2199
2200 Port = PortExtension->PortNumber;
2202
2203 if (HubExtension &&
2204 HubExtension->CurrentPowerState.DeviceState != PowerDeviceD0 &&
2205 (HubExtension->HubFlags & USBHUB_FDO_FLAG_DEVICE_STARTED) != 0)
2206 {
2207 USBH_HubSetD0(HubExtension);
2208 }
2209
2211 IdleNotificationIrp = PortExtension->IdleNotificationIrp;
2212
2213 if (IdleNotificationIrp)
2214 {
2215 PortExtension->IdleNotificationIrp = NULL;
2216 PortExtension->PortPdoFlags &= ~USBHUB_PDO_FLAG_IDLE_NOTIFICATION;
2217
2218 if (IdleNotificationIrp->Cancel)
2219 {
2220 IdleNotificationIrp = NULL;
2221 }
2222
2223 if (IdleNotificationIrp)
2224 {
2226 }
2227 }
2228
2229 WakeIrp = PortExtension->PdoWaitWakeIrp;
2230
2231 if (WakeIrp)
2232 {
2233 PortExtension->PdoWaitWakeIrp = NULL;
2234 PortExtension->PortPdoFlags &= ~USBHUB_PDO_FLAG_WAIT_WAKE;
2235
2237 {
2238 WakeIrp = NULL;
2239
2240 ASSERT(HubExtension);
2242 {
2243 KeSetEvent(&HubExtension->PendingRequestEvent,
2244 EVENT_INCREMENT,
2245 FALSE);
2246 }
2247 }
2248 }
2249
2251
2252 if (IdleNotificationIrp)
2253 {
2256 }
2257
2258 if (WakeIrp)
2259 {
2260 ASSERT(HubExtension);
2262 }
2263
2264 PortExtension->PortPdoFlags |= USBHUB_PDO_FLAG_POWER_D3;
2265
2267 {
2269
2271 {
2272 PortExtension->PortPdoFlags &= ~USBHUB_PDO_FLAG_REG_DEV_INTERFACE;
2273 }
2274 }
2275
2277 NULL);
2278
2280 {
2281 ASSERT(HubExtension);
2283
2284 if (HubExtension->PortData &&
2285 HubExtension->PortData[Port - 1].DeviceObject == PortDevice)
2286 {
2288 }
2289 }
2290
2292 {
2293 PortExtension->PortPdoFlags &= ~USBHUB_PDO_FLAG_DEVICE_STARTED;
2294
2295 if (HubExtension && HubExtension->PortData)
2296 {
2297 PortData = &HubExtension->PortData[Port - 1];
2298
2300 {
2302
2304 {
2307
2309 {
2311
2312 InsertTailList(&HubExtension->PdoList,
2313 &PortExt->PortLink);
2314 }
2315 }
2316 }
2317 }
2318
2320 !(PortExtension->PortPdoFlags & USBHUB_PDO_FLAG_NOT_CONNECTED))
2321 {
2322 PortExtension->PortPdoFlags |= USBHUB_PDO_FLAG_NOT_CONNECTED;
2323
2325 NULL);
2326
2328 {
2330 }
2331
2333
2334 if (HubExtension)
2335 USBHUB_FlushAllTransfers(HubExtension);
2336
2337 IoDeleteDevice(PortDevice);
2338 }
2339 }
2340
2341 if (HubExtension)
2342 {
2344 USBH_CheckIdleDeferred(HubExtension);
2345 }
2346
2348}
VOID NTAPI USBH_CompletePowerIrp(IN PUSBHUB_FDO_EXTENSION HubExtension, IN PIRP Irp, IN NTSTATUS NtStatus)
Definition: power.c:18
IoSetCancelRoutine(Irp, CancelRoutine)
PUSBHUB_PORT_PDO_EXTENSION NTAPI PdoExt(IN PDEVICE_OBJECT DeviceObject)
Definition: usbhub.c:133
VOID NTAPI USBHUB_FlushAllTransfers(IN PUSBHUB_FDO_EXTENSION HubExtension)
Definition: usbhub.c:2638
NTSTATUS NTAPI USBH_SyncDisablePort(IN PUSBHUB_FDO_EXTENSION HubExtension, IN USHORT Port)
Definition: usbhub.c:1553
WDF_EXTERN_C_START typedef _Must_inspect_result_ _In_ WDFDRIVER _In_opt_ PWDF_OBJECT_ATTRIBUTES _In_ PDEVICE_OBJECT _In_opt_ PDEVICE_OBJECT _In_opt_ PDEVICE_OBJECT Pdo
Definition: wdfminiport.h:72
Referenced by USBH_FdoRemoveDevice(), and USBH_PdoPnP().
◆ USBH_QueueWorkItem()
| VOID NTAPI USBH_QueueWorkItem | ( | IN PUSBHUB_FDO_EXTENSION | HubExtension, |
| IN PUSBHUB_IO_WORK_ITEM | HubIoWorkItem | ||
| ) |
Definition at line 2932 of file usbhub.c.
2934{
2936
2937 InterlockedIncrement(&HubExtension->PendingRequestCount);
2938 InterlockedIncrement(&HubIoWorkItem->HubWorkerQueued);
2939
2940 ExInterlockedInsertTailList(&HubExtension->WorkItemList,
2941 &HubIoWorkItem->HubWorkItemLink,
2942 &HubExtension->WorkItemSpinLock);
2943
2944 IoQueueWorkItem(HubIoWorkItem->HubWorkItem,
2945 USBH_Worker,
2946 HubIoWorkItem->HubWorkItemType,
2947 HubIoWorkItem);
2948}
PLIST_ENTRY NTAPI ExInterlockedInsertTailList(IN OUT PLIST_ENTRY ListHead, IN OUT PLIST_ENTRY ListEntry, IN OUT PKSPIN_LOCK Lock)
Definition: interlocked.c:140
VOID NTAPI IoQueueWorkItem(IN PIO_WORKITEM IoWorkItem, IN PIO_WORKITEM_ROUTINE WorkerRoutine, IN WORK_QUEUE_TYPE QueueType, IN PVOID Context)
Definition: iowork.c:40
VOID NTAPI USBH_Worker(IN PDEVICE_OBJECT DeviceObject, IN PVOID Context)
Definition: usbhub.c:2887
Referenced by USBH_ChangeIndicationProcessChange(), USBH_ChangeIndicationQueryChange(), USBH_CheckIdleDeferred(), USBH_FdoIdleNotificationRequestComplete(), USBH_PdoIoctlResetPort(), and USBH_PortIdleNotificationCancelRoutine().
◆ USBH_ResetDevice()
| NTSTATUS NTAPI USBH_ResetDevice | ( | IN PUSBHUB_FDO_EXTENSION | HubExtension, |
| IN USHORT | Port, | ||
| IN BOOLEAN | IsKeepDeviceData, | ||
| IN BOOLEAN | IsWait | ||
| ) |
Definition at line 4630 of file usbhub.c.
4634{
4636 PUSBHUB_PORT_DATA PortData;
4637 PDEVICE_OBJECT PortDevice;
4638 PUSBHUB_PORT_PDO_EXTENSION PortExtension;
4644
4646 HubExtension,
4647 Port,
4648 IsKeepDeviceData,
4649 IsWait);
4650
4652 Port,
4653 &PortStatus,
4655
4657 !(PortStatus.PortStatus.Usb20PortStatus.CurrentConnectStatus))
4658 {
4660 }
4661
4662 InterlockedIncrement(&HubExtension->PendingRequestCount);
4663
4664 KeWaitForSingleObject(&HubExtension->ResetDeviceSemaphore,
4665 Executive,
4666 KernelMode,
4667 FALSE,
4668 NULL);
4669
4671 PortData = &HubExtension->PortData[Port-1];
4672
4673 PortDevice = PortData->DeviceObject;
4674
4675 if (!PortDevice)
4676 {
4678
4679 KeReleaseSemaphore(&HubExtension->ResetDeviceSemaphore,
4680 LOW_REALTIME_PRIORITY,
4681 1,
4682 FALSE);
4683
4685 {
4686 KeSetEvent(&HubExtension->PendingRequestEvent,
4687 EVENT_INCREMENT,
4688 FALSE);
4689 }
4690
4692 }
4693
4694 PortExtension = PortDevice->DeviceExtension;
4696
4698 NULL);
4699
4701 {
4703 {
4705 OldDeviceHandle,
4706 IsKeepDeviceData);
4707
4709 }
4710 }
4711 else
4712 {
4714 }
4715
4717 {
4719 }
4720
4722
4724 {
4726 }
4727
4729 Port,
4730 &PortStatus,
4732
4734 {
4736 }
4737
4739 DeviceHandle,
4740 PortStatus.PortStatus,
4741 Port);
4742
4744 {
4746 }
4747
4749
4750 if (IsWait)
4751 {
4752 USBH_Wait(50);
4753 }
4754
4756 {
4758 }
4759
4761 *DeviceHandle,
4766
4768 {
4769 if (IsKeepDeviceData)
4770 {
4772 OldDeviceHandle,
4773 *DeviceHandle);
4774
4776 {
4778
4781
4783 }
4784 }
4785 else
4786 {
4787 PortExtension->PortPdoFlags &= ~USBHUB_PDO_FLAG_REMOVING_PORT_PDO;
4788 }
4789
4791 }
4792
4794
4795ErrorExit:
4796
4798 OldDeviceHandle);
4799
4801 {
4803 }
4804
4805Exit:
4806
4807 KeReleaseSemaphore(&HubExtension->ResetDeviceSemaphore,
4808 LOW_REALTIME_PRIORITY,
4809 1,
4810 FALSE);
4811
4813 {
4814 KeSetEvent(&HubExtension->PendingRequestEvent,
4815 EVENT_INCREMENT,
4816 FALSE);
4817 }
4818
4820}
_Outptr_ PUSB_DEVICE_HANDLE _In_ PUSB_DEVICE_HANDLE _In_ USHORT PortStatus
Definition: hubbusif.h:42
Definition: usb200.h:237
NTSTATUS NTAPI USBH_SyncGetPortStatus(IN PUSBHUB_FDO_EXTENSION HubExtension, IN USHORT Port, IN PUSB_PORT_STATUS_AND_CHANGE PortStatus, IN ULONG Length)
Definition: usbhub.c:1414
NTSTATUS NTAPI USBD_RestoreDeviceEx(IN PUSBHUB_FDO_EXTENSION HubExtension, IN OUT PUSB_DEVICE_HANDLE OldDeviceHandle, IN OUT PUSB_DEVICE_HANDLE NewDeviceHandle)
Definition: usbhub.c:2776
Referenced by USBH_ResetPortWorker(), and USBH_RestoreDevice().
◆ USBH_SetPdoRegistryParameter()
| NTSTATUS NTAPI USBH_SetPdoRegistryParameter | ( | IN PDEVICE_OBJECT | DeviceObject, |
| IN PCWSTR | SourceString, | ||
| IN PVOID | Data, | ||
| IN ULONG | DataSize, | ||
| IN ULONG | Type, | ||
| IN ULONG | DevInstKeyType | ||
| ) |
Definition at line 213 of file usbhub.c.
219{
221 UNICODE_STRING ValueNameString;
223
225
227
229 DevInstKeyType,
230 STANDARD_RIGHTS_ALL,
231 &KeyHandle);
232
234 {
235 ZwSetValueKey(KeyHandle,
236 &ValueNameString,
237 0,
238 Type,
239 Data,
240 DataSize);
241
243 }
244
246}
_In_ NDIS_STATUS _In_ ULONG _In_ USHORT _In_opt_ PVOID _In_ ULONG DataSize
Definition: ndis.h:4755
_Must_inspect_result_ _Out_ PNDIS_STATUS _In_ NDIS_HANDLE _In_ ULONG _Out_ PNDIS_STRING _Out_ PNDIS_HANDLE KeyHandle
Definition: ndis.h:4715
NTSYSAPI NTSTATUS NTAPI ZwClose(_In_ HANDLE Handle)
NTSTATUS NTAPI IoOpenDeviceRegistryKey(IN PDEVICE_OBJECT DeviceObject, IN ULONG DevInstKeyType, IN ACCESS_MASK DesiredAccess, OUT PHANDLE DevInstRegKey)
Definition: pnpmgr.c:1621
Definition: sort_test.cpp:77
_Must_inspect_result_ _In_ WDFKEY _In_ PCUNICODE_STRING ValueName
Definition: wdfregistry.h:243
Referenced by USBH_SymbolicLink().
◆ USBH_SubmitStatusChangeTransfer()
| NTSTATUS NTAPI USBH_SubmitStatusChangeTransfer | ( | IN PUSBHUB_FDO_EXTENSION | HubExtension | ) |
Definition at line 2457 of file usbhub.c.
2458{
2462 PIO_STACK_LOCATION IoStack;
2463
2465 HubExtension,
2466 HubExtension->SCEIrp);
2467
2469 {
2472 HubExtension->HubFlags);
2473
2475 }
2476
2477 Irp = HubExtension->SCEIrp;
2478
2480 {
2482 }
2483
2485
2489
2490 Urb->PipeHandle = HubExtension->PipeInfo.PipeHandle;
2492 Urb->TransferBuffer = HubExtension->SCEBitmap;
2493 Urb->TransferBufferLength = HubExtension->SCEBitmapLength;
2496
2498 IoSizeOfIrp(HubExtension->LowerDevice->StackSize),
2499 HubExtension->LowerDevice->StackSize);
2500
2502
2506
2508 USBH_ChangeIndication,
2509 HubExtension,
2510 TRUE,
2511 TRUE,
2512 TRUE);
2513
2514 KeClearEvent(&HubExtension->StatusChangeEvent);
2515
2517
2519}
VOID NTAPI IoInitializeIrp(IN PIRP Irp, IN USHORT PacketSize, IN CCHAR StackSize)
Definition: irp.c:1854
Definition: usb.h:497
#define URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER
Definition: usb.h:95
NTSTATUS NTAPI USBH_ChangeIndication(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context)
Definition: usbhub.c:2334
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetNextIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2695
#define IoSizeOfIrp(_StackSize)
#define IRP_MJ_INTERNAL_DEVICE_CONTROL
Referenced by USBH_ChangeIndicationAckChangeComplete(), USBH_ChangeIndicationWorker(), USBH_FdoPower(), USBH_PowerIrpCompletion(), USBH_StartHubFdoDevice(), and USBHUB_RootHubCallBack().
◆ USBH_SyncClearPortStatus()
| NTSTATUS NTAPI USBH_SyncClearPortStatus | ( | IN PUSBHUB_FDO_EXTENSION | HubExtension, |
| IN USHORT | Port, | ||
| IN USHORT | RequestValue | ||
| ) |
Definition at line 1442 of file usbhub.c.
1445{
1447
1449 Port,
1450 RequestValue);
1451
1452 RequestType.B = 0;
1456
1458 NULL,
1459 0,
1460 BMREQUEST_HOST_TO_DEVICE,
1461 URB_FUNCTION_CLASS_OTHER,
1462 RequestType,
1464 RequestValue,
1465 Port);
1466}
Definition: usb200.h:57
NTSTATUS NTAPI USBH_Transact(IN PUSBHUB_FDO_EXTENSION HubExtension, IN PVOID TransferBuffer, IN ULONG BufferLen, IN BOOLEAN IsDeviceToHost, IN USHORT Function, IN BM_REQUEST_TYPE RequestType, IN UCHAR Request, IN USHORT RequestValue, IN USHORT RequestIndex)
Definition: usbhub.c:370
_Must_inspect_result_ _In_ WDFDEVICE _In_ WDFQUEUE _In_ _Strict_type_match_ WDF_REQUEST_TYPE RequestType
Definition: wdfdevice.h:4239
Referenced by USBH_ProcessPortStateChange(), and USBH_StartHubFdoDevice().
◆ USBH_SyncDisablePort()
Definition at line 1553 of file usbhub.c.
1555{
1556 PUSBHUB_PORT_DATA PortData;
1559
1561
1562 PortData = &HubExtension->PortData[Port - 1];
1563
1564 RequestType.B = 0;
1568
1570 NULL,
1571 0,
1572 BMREQUEST_HOST_TO_DEVICE,
1573 URB_FUNCTION_CLASS_OTHER,
1574 RequestType,
1577 Port);
1578
1580 {
1582 }
1583
1585}
Referenced by USBH_FdoCleanup(), USBH_FdoQueryBusRelations(), USBH_PdoRemoveDevice(), USBH_ProcessPortStateChange(), and USBH_ResetDevice().
◆ USBH_SyncGetDeviceHandle()
| PUSB_DEVICE_HANDLE NTAPI USBH_SyncGetDeviceHandle | ( | IN PDEVICE_OBJECT | DeviceObject | ) |
Definition at line 832 of file usbhub.c.
833{
838 PIO_STACK_LOCATION IoStack;
839
841
843
845 DeviceObject,
846 NULL,
847 0,
848 NULL,
849 0,
850 TRUE,
851 &Event,
852 &IoStatusBlock);
853
855 {
858 }
859
862
864 {
866 Suspended,
867 KernelMode,
868 FALSE,
869 NULL);
870 }
871
873}
PIRP NTAPI IoBuildDeviceIoControlRequest(IN ULONG IoControlCode, IN PDEVICE_OBJECT DeviceObject, IN PVOID InputBuffer, IN ULONG InputBufferLength, IN PVOID OutputBuffer, IN ULONG OutputBufferLength, IN BOOLEAN InternalDeviceIoControl, IN PKEVENT Event, IN PIO_STATUS_BLOCK IoStatusBlock)
Definition: irp.c:881
Definition: env_spec_w32.h:870
Referenced by USBD_CreateDeviceEx(), USBD_Initialize20Hub(), and USBH_StartHubFdoDevice().
◆ USBH_SyncGetHubCount()
Definition at line 781 of file usbhub.c.
783{
787 PIO_STACK_LOCATION IoStack;
789
791
793
795 DeviceObject,
796 NULL,
797 0,
798 NULL,
799 0,
800 TRUE,
801 &Event,
802 &IoStatusBlock);
803
805 {
807 }
808
811
813
815 {
817 Suspended,
818 KernelMode,
819 FALSE,
820 NULL);
821 }
822 else
823 {
825 }
826
828}
Referenced by USBH_PdoInternalControl(), and USBH_StartHubFdoDevice().
◆ USBH_SyncGetHubDescriptor()
| NTSTATUS NTAPI USBH_SyncGetHubDescriptor | ( | IN PUSBHUB_FDO_EXTENSION | HubExtension | ) |
Definition at line 1048 of file usbhub.c.
1049{
1050 PUSB_EXTHUB_INFORMATION_0 ExtendedHubInfo;
1051 ULONG NumberPorts;
1052 PUSBHUB_PORT_DATA PortData;
1053 USHORT RequestValue;
1057 ULONG ix;
1059
1061
1064 USB_HUB_TAG);
1065
1066 if (!ExtendedHubInfo)
1067 {
1070 }
1071
1073
1075
1077 {
1079 ExtendedHubInfo = NULL;
1080 }
1081
1083
1085 NumberOfBytes,
1086 USB_HUB_TAG);
1087
1088 if (!HubDescriptor)
1089 {
1092 }
1093
1095
1096 RequestValue = 0;
1097 Retry = 0;
1098
1100 {
1102 {
1104
1105 RequestType.B = 0;
1109
1111 HubDescriptor,
1112 NumberOfBytes,
1113 BMREQUEST_DEVICE_TO_HOST,
1115 RequestType,
1117 RequestValue,
1118 0);
1119
1121 {
1122 break;
1123 }
1124
1125 RequestValue = 0x2900; // Hub DescriptorType - 0x29
1126
1127 Retry++;
1128 }
1129
1131 {
1132 break;
1133 }
1134
1137
1139 {
1141 HubDescriptor = NULL;
1143 }
1144
1146 NumberOfBytes,
1147 USB_HUB_TAG);
1148
1149 if (!HubDescriptor)
1150 {
1153 }
1154
1156 }
1157
1158 NumberPorts = HubDescriptor->bNumberOfPorts;
1159
1160 if (HubExtension->PortData)
1161 {
1162 PortData = HubExtension->PortData;
1163
1164 for (ix = 0; ix < NumberPorts; ix++)
1165 {
1167
1168 if (ExtendedHubInfo)
1169 {
1171 }
1172 else
1173 {
1174 PortData[ix].PortAttributes = 0;
1175 }
1176
1178
1180 {
1182 }
1183 }
1184 }
1185 else
1186 {
1187 PortData = NULL;
1188
1190 {
1193 USB_HUB_TAG);
1194 }
1195
1196 if (!PortData)
1197 {
1200 }
1201
1203
1204 for (ix = 0; ix < NumberPorts; ix++)
1205 {
1207
1208 if (ExtendedHubInfo)
1209 {
1211 }
1212 }
1213 }
1214
1216 {
1218 }
1219
1220 HubExtension->HubDescriptor = HubDescriptor;
1221
1222 HubExtension->PortData = PortData;
1223
1224 if (ExtendedHubInfo)
1225 {
1227 }
1228
1230
1231ErrorExit:
1232
1233 if (HubDescriptor)
1234 {
1236 }
1237
1238 if (ExtendedHubInfo)
1239 {
1241 }
1242
1244}
Definition: hubbusif.h:729
Definition: usb100.h:170
struct _USB_HUB_DESCRIPTOR USB_HUB_DESCRIPTOR
NTSTATUS NTAPI USBHUB_GetExtendedHubInfo(IN PUSBHUB_FDO_EXTENSION HubExtension, IN PUSB_EXTHUB_INFORMATION_0 HubInfoBuffer)
Definition: usbhub.c:680
_Must_inspect_result_ typedef _In_ PHYSICAL_ADDRESS _Inout_ PLARGE_INTEGER NumberOfBytes
Definition: iotypes.h:1036
Referenced by USBH_StartHubFdoDevice().
◆ USBH_SyncGetPortStatus()
| NTSTATUS NTAPI USBH_SyncGetPortStatus | ( | IN PUSBHUB_FDO_EXTENSION | HubExtension, |
| IN USHORT | Port, | ||
| IN PUSB_PORT_STATUS_AND_CHANGE | PortStatus, | ||
| IN ULONG | Length | ||
| ) |
Definition at line 1414 of file usbhub.c.
1418{
1420
1422
1423 RequestType.B = 0;
1427
1429 PortStatus,
1430 Length,
1431 BMREQUEST_DEVICE_TO_HOST,
1432 URB_FUNCTION_CLASS_OTHER,
1433 RequestType,
1434 USB_REQUEST_GET_STATUS,
1435 0,
1436 Port);
1437}
Referenced by USBH_ChangeIndicationWorker(), USBH_FdoQueryBusRelations(), USBH_PdoIoctlGetPortStatus(), USBH_ResetDevice(), USBH_RestoreDevice(), and USBH_SyncResetPort().
◆ USBH_SyncGetRootHubPdo()
| NTSTATUS NTAPI USBH_SyncGetRootHubPdo | ( | IN PDEVICE_OBJECT | DeviceObject, |
| IN OUT PDEVICE_OBJECT * | OutPdo1, | ||
| IN OUT PDEVICE_OBJECT * | OutPdo2 | ||
| ) |
Definition at line 728 of file usbhub.c.
731{
735 PIO_STACK_LOCATION IoStack;
737
739
741
743 DeviceObject,
744 NULL,
745 0,
746 NULL,
747 0,
748 TRUE,
749 &Event,
750 &IoStatusBlock);
751
753 {
755 }
756
760
762
764 {
766 Suspended,
767 KernelMode,
768 FALSE,
769 NULL);
770 }
771 else
772 {
774 }
775
777}
Referenced by USBH_FdoStartDevice(), and USBH_StartHubFdoDevice().
◆ USBH_SyncGetStringDescriptor()
| NTSTATUS NTAPI USBH_SyncGetStringDescriptor | ( | IN PDEVICE_OBJECT | DeviceObject, |
| IN UCHAR | Index, | ||
| IN USHORT | LanguageId, | ||
| IN PUSB_STRING_DESCRIPTOR | Descriptor, | ||
| IN ULONG | NumberOfBytes, | ||
| IN PULONG | OutLength, | ||
| IN BOOLEAN | IsValidateLength | ||
| ) |
Definition at line 1248 of file usbhub.c.
1255{
1257 ULONG TransferedLength;
1259
1261 Index,
1262 LanguageId);
1263
1266 USB_HUB_TAG);
1267
1269 {
1271 }
1272
1274
1277
1280
1284
1286
1288 {
1291 }
1292
1293 TransferedLength = Urb->TransferBufferLength;
1294
1296 {
1298 }
1299
1301 {
1304 }
1305
1306 if (OutLength)
1307 {
1308 *OutLength = TransferedLength;
1309 }
1310
1312 {
1314 }
1315
1317
1319}
Referenced by USBH_CheckDeviceLanguage(), USBH_GetSerialNumberString(), and USBH_PdoQueryDeviceText().
◆ USBH_SyncPowerOnPorts()
| NTSTATUS NTAPI USBH_SyncPowerOnPorts | ( | IN PUSBHUB_FDO_EXTENSION | HubExtension | ) |
Definition at line 1522 of file usbhub.c.
1523{
1524 PUSB_HUB_DESCRIPTOR HubDescriptor;
1528
1530
1531 HubDescriptor = HubExtension->HubDescriptor;
1533
1535 {
1537
1539 {
1541 Status);
1542 break;
1543 }
1544 }
1545
1547
1549}
NTSTATUS NTAPI USBH_SyncPowerOnPort(IN PUSBHUB_FDO_EXTENSION HubExtension, IN USHORT Port, IN BOOLEAN IsWait)
Definition: usbhub.c:1470
Referenced by USBH_StartHubFdoDevice().
◆ USBH_SyncResetPort()
Definition at line 471 of file usbhub.c.
473{
477 ULONG ResetRetry = 0;
479
481
482 InterlockedIncrement(&HubExtension->PendingRequestCount);
483
484 KeWaitForSingleObject(&HubExtension->HubPortSemaphore,
485 Executive,
486 KernelMode,
487 FALSE,
488 NULL);
489
491 Port,
492 &PortStatus,
494
496 (PortStatus.PortStatus.Usb20PortStatus.CurrentConnectStatus == 0))
497 {
500 }
501
502 HubExtension->HubFlags |= USBHUB_FDO_FLAG_RESET_PORT_LOCK;
503
505 {
507
509
511 &Event);
512
513 RequestType.B = 0;
517
519 NULL,
520 0,
523 RequestType,
526 Port);
527
528 Timeout.QuadPart = -5000 * 10000;
529
531 {
533 NULL);
534
535 USBH_Wait(10);
536 HubExtension->HubFlags &= ~USBHUB_FDO_FLAG_RESET_PORT_LOCK;
537
539 }
540
542 Suspended,
543 KernelMode,
544 FALSE,
545 &Timeout);
546
548 {
549 break;
550 }
551
553 Port,
554 &PortStatus,
556
558 (PortStatus.PortStatus.Usb20PortStatus.CurrentConnectStatus == 0) ||
559 ResetRetry >= USBHUB_RESET_PORT_MAX_RETRY)
560 {
562 NULL);
563
564 USBH_Wait(10);
565 HubExtension->HubFlags &= ~USBHUB_FDO_FLAG_RESET_PORT_LOCK;
566
569 }
570
571 ResetRetry++;
572 }
573
575 Port,
576 &PortStatus,
578
581 HubExtension->HubFlags & USBHUB_FDO_FLAG_USB20_HUB)
582 {
584 }
585
586 USBH_Wait(10);
587 HubExtension->HubFlags &= ~USBHUB_FDO_FLAG_RESET_PORT_LOCK;
588
589Exit:
590
591 KeReleaseSemaphore(&HubExtension->HubPortSemaphore,
593 1,
594 FALSE);
595
597 {
598 KeSetEvent(&HubExtension->PendingRequestEvent,
599 EVENT_INCREMENT,
600 FALSE);
601 }
602
604}
Definition: typedefs.h:103
Referenced by USBH_CreateDevice(), USBH_FdoQueryBusRelations(), and USBH_ResetDevice().
◆ USBH_SyncSubmitUrb()
Definition at line 250 of file usbhub.c.
252{
256 PIO_STACK_LOCATION IoStack;
257 PUSBHUB_URB_TIMEOUT_CONTEXT HubTimeoutContext;
261
263
265
267
269 DeviceObject,
270 NULL,
271 0,
272 NULL,
273 0,
274 TRUE,
275 &Event,
276 &IoStatusBlock);
277
279 {
281 }
282
285
288 USB_HUB_TAG);
289
290 if (HubTimeoutContext)
291 {
293
296
298 NotificationEvent,
299 FALSE);
300
303
305 USBH_UrbTimeoutDPC,
306 HubTimeoutContext);
307
309
311 DueTime,
312 &HubTimeoutContext->UrbTimeoutDPC);
313
315 USBH_SyncIrpComplete,
316 HubTimeoutContext,
317 TRUE,
318 TRUE,
319 TRUE);
320
321 IsWaitTimeout = TRUE;
322 }
323
325
327 {
329 Suspended,
330 KernelMode,
331 FALSE,
332 NULL);
333 }
334 else
335 {
337 }
338
339 if (IsWaitTimeout)
340 {
342 Suspended,
343 KernelMode,
344 FALSE,
345 NULL);
346
348 }
349
351}
Definition: usbhub.h:237
KSPIN_LOCK UrbTimeoutSpinLock
Definition: usbhub.h:242
BOOLEAN NTAPI KeSetTimer(IN OUT PKTIMER Timer, IN LARGE_INTEGER DueTime, IN PKDPC Dpc OPTIONAL)
Definition: timerobj.c:282
NTSTATUS NTAPI USBH_SyncIrpComplete(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context)
Definition: usbhub.c:92
VOID NTAPI USBH_UrbTimeoutDPC(IN PKDPC Dpc, IN PVOID DeferredContext, IN PVOID SystemArgument1, IN PVOID SystemArgument2)
Definition: usbhub.c:184
Referenced by USBH_FdoSyncSubmitUrb(), USBH_IoctlGetDescriptor(), USBH_SyncGetDeviceConfigurationDescriptor(), and USBH_SyncGetStringDescriptor().
◆ USBH_Wait()
Definition at line 23 of file usbhub.c.
24{
26
30}
Referenced by USBH_CreateDevice(), USBH_FdoQueryBusRelations(), USBH_HubSetD0(), USBH_ResetDevice(), USBH_RestoreDevice(), USBH_SyncPowerOnPort(), USBH_SyncPowerOnPorts(), and USBH_SyncResetPort().
◆ USBH_WriteFailReasonID()
Definition at line 153 of file usbhub.c.
155{
159
161
164 STANDARD_RIGHTS_ALL,
165 &KeyHandle);
166
168 {
169 ZwSetValueKey(KeyHandle,
170 &ValueName,
171 0,
172 REG_DWORD,
173 &FailReason,
174 sizeof(FailReason));
175
177 }
178
180}
Referenced by USBH_StartHubFdoDevice().
◆ USBHUB_DumpingConfiguration()
| VOID NTAPI USBHUB_DumpingConfiguration | ( | IN PUSB_CONFIGURATION_DESCRIPTOR | ConfigDescriptor | ) |
Definition at line 41 of file debug.c.
42{
44 PUSB_CONFIGURATION_DESCRIPTOR cDescriptor;
45 PUSB_INTERFACE_DESCRIPTOR iDescriptor;
46 PUSB_ENDPOINT_DESCRIPTOR eDescriptor;
47
49 {
50 return;
51 }
52
54
57 Descriptor->bLength)
58 {
60 {
62
72 }
74 {
76
87 }
89 {
91
99 }
100 else
101 {
103 }
104
106 Descriptor->bLength);
107 }
108}
Definition: usb100.h:127
Definition: usb100.h:147
struct _USB_CONFIGURATION_DESCRIPTOR * PUSB_CONFIGURATION_DESCRIPTOR
struct _USB_INTERFACE_DESCRIPTOR * PUSB_INTERFACE_DESCRIPTOR
struct _USB_COMMON_DESCRIPTOR * PUSB_COMMON_DESCRIPTOR
struct _USB_ENDPOINT_DESCRIPTOR * PUSB_ENDPOINT_DESCRIPTOR
Referenced by USBH_ProcessDeviceInformation().
◆ USBHUB_DumpingDeviceDescriptor()
| VOID NTAPI USBHUB_DumpingDeviceDescriptor | ( | IN PUSB_DEVICE_DESCRIPTOR | DeviceDescriptor | ) |
Definition at line 15 of file debug.c.
16{
18 {
19 return;
20 }
21
37}
Referenced by USBH_ProcessDeviceInformation().
◆ USBHUB_DumpingIDs()
Definition at line 112 of file debug.c.
113{
117
120
122 {
125
128 }
129
132}
Referenced by USBH_PdoQueryId().
◆ USBHUB_FlushAllTransfers()
| VOID NTAPI USBHUB_FlushAllTransfers | ( | IN PUSBHUB_FDO_EXTENSION | HubExtension | ) |
Definition at line 2638 of file usbhub.c.
2639{
2640 PUSB_BUSIFFN_FLUSH_TRANSFERS FlushTransfers;
2641
2643
2644 FlushTransfers = HubExtension->BusInterface.FlushTransfers;
2645
2646 if (FlushTransfers)
2647 {
2648 FlushTransfers(HubExtension->BusInterface.BusContext, NULL);
2649 }
2650}
USB_BUSIFFN_FLUSH_TRANSFERS * PUSB_BUSIFFN_FLUSH_TRANSFERS
Definition: hubbusif.h:287
Referenced by USBH_PdoRemoveDevice().
◆ USBHUB_SetDeviceHandleData()
| VOID NTAPI USBHUB_SetDeviceHandleData | ( | IN PUSBHUB_FDO_EXTENSION | HubExtension, |
| IN PDEVICE_OBJECT | UsbDevicePdo, | ||
| IN PVOID | DeviceHandle | ||
| ) |
Definition at line 2616 of file usbhub.c.
2619{
2620 PUSB_BUSIFFN_SET_DEVHANDLE_DATA SetDeviceHandleData;
2621
2623
2624 SetDeviceHandleData = HubExtension->BusInterface.SetDeviceHandleData;
2625
2626 if (!SetDeviceHandleData)
2627 {
2628 return;
2629 }
2630
2631 SetDeviceHandleData(HubExtension->BusInterface.BusContext,
2632 DeviceHandle,
2633 UsbDevicePdo);
2634}
USB_BUSIFFN_SET_DEVHANDLE_DATA * PUSB_BUSIFFN_SET_DEVHANDLE_DATA
Definition: hubbusif.h:323
Referenced by USBH_PdoStartDevice().
Variable Documentation
◆ GenericUSBDeviceString
|
extern |
Definition at line 19 of file usbhub.c.
Referenced by DriverEntry(), USBH_DriverUnload(), and USBH_PdoQueryDeviceText().
