#include "usbdex.h"

Include dependency graph for usbdex.c:

Classes
struct	_USBDEX_HANDLE_OBJECT

Macros
#define	USBDEX_HANDLE_SIGNATURE 'DBSU'

#define	USBDEX_MODE_UCX USBD_INTERFACE_VERSION_602

#define	USBDEX_MODE_LEGACY USBD_INTERFACE_VERSION_600

#define	USBDEX_MODE_NONE 0xFFFFFFFF

#define	USBDEX_NONPAGED_POOL_NX ((POOL_TYPE)0x200)

#define	USBDEX_PIPE_MAX_TRANSFER_DEFAULT 0xFFFFFFFF

#define	USBDEX_SELECT_INTERFACE_MAX_PIPES 32

#define	USBDEX_COMPOSITE_VERSION 0x0100

Typedefs
typedef NTSTATUS(NTAPI *	PFN_USBDEX_QUERY_REGISTRY) (_In_ ULONG RelativeTo, _In_ PCWSTR Path, _Inout_ PRTL_QUERY_REGISTRY_TABLE QueryTable, _In_opt_ PVOID Context, _In_opt_ PVOID Environment)

typedef struct _USBDEX_HANDLE_OBJECT	USBDEX_HANDLE_OBJECT

typedef struct _USBDEX_HANDLE_OBJECT *	PUSBDEX_HANDLE_OBJECT

Functions
FORCEINLINE PUSBDEX_HANDLE_OBJECT	UsbdexHandleObject (_In_opt_ USBD_HANDLE USBDHandle)

FORCEINLINE BOOLEAN	UsbdexIsUcxMode (_In_ PUSBDEX_HANDLE_OBJECT Handle)

static VOID	UsbdexDetectPoolType (VOID)

static NTSTATUS NTAPI	UsbdexSyncCompletion (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp, _In_reads_opt_(_Inexpressible_("varies")) PVOID Context)

static NTSTATUS	UsbdexCallAndWait (_In_ PDEVICE_OBJECT ClientDevice, _In_ PDEVICE_OBJECT Target, _In_ __drv_freesMem(Mem) PIRP Irp)

static NTSTATUS	UsbdexQueryInterface (_In_ PDEVICE_OBJECT ClientDevice, _In_ PDEVICE_OBJECT Target, _In_ const GUID *InterfaceType, _Inout_ PINTERFACE Interface)

static NTSTATUS	UsbdexSendCapabilityRequest (_In_ PDEVICE_OBJECT ClientDevice, _In_ PDEVICE_OBJECT Target, _Inout_ PUCXHUB_QUERY_CAPABILITY Request, _Out_opt_ PVOID OutputBuffer)

static NTSTATUS NTAPI	UsbdexVerifierValueCallback (_In_z_ PWSTR ValueName, _In_ ULONG ValueType, _In_reads_bytes_opt_(ValueLength) PVOID ValueData, _In_ ULONG ValueLength, _In_opt_ PVOID Context, _In_opt_ PVOID EntryContext)

static PWSTR	UsbdexBuildParametersPath (_In_ PDRIVER_OBJECT DriverObject, _In_ ULONG PoolTag)

static VOID	UsbdexReadVerifierSettings (_In_ PDRIVER_OBJECT DriverObject, _In_z_ PCWSTR ParametersPath, _In_ ULONG PoolTag, _Inout_ PUSBD_CLIENT_INTERFACE Client)

static ULONG	UsbdexProbeLegacyStack (_Inout_ PUSBDEX_HANDLE_OBJECT Handle)

static NTSTATUS	UsbdexReferenceHandle (_Inout_ PUSBDEX_HANDLE_OBJECT Handle)

static VOID	UsbdexDereferenceHandle (_Inout_ PUSBDEX_HANDLE_OBJECT Handle)

static NTSTATUS	UsbdexStartAllocation (_In_opt_ PUSBDEX_HANDLE_OBJECT Handle, _In_ BOOLEAN ArgumentsValid, _Out_opt_ PURB *Urb)

static NTSTATUS	UsbdexFinishAllocation (_Inout_ PUSBDEX_HANDLE_OBJECT Handle, _In_ NTSTATUS Status, _Inout_ PURB *Urb)

static PURB	UsbdexAllocatePoolUrb (_In_ PUSBDEX_HANDLE_OBJECT Handle, _In_ SIZE_T Size)

static VOID	UsbdexInitInterfaceInformation (_Out_ PUSBD_INTERFACE_INFORMATION Information, _In_ PUSB_INTERFACE_DESCRIPTOR Descriptor, _In_ UCHAR PipeCount)

static NTSTATUS	UsbdexBuildSelectConfigUrb (_In_ PUSBDEX_HANDLE_OBJECT Handle, _In_opt_ PUSB_CONFIGURATION_DESCRIPTOR ConfigurationDescriptor, _Inout_ PUSBD_INTERFACE_LIST_ENTRY InterfaceList, _Out_ PURB *Urb)

static NTSTATUS	UsbdexBuildSelectInterfaceUrb (_In_ PUSBDEX_HANDLE_OBJECT Handle, _In_ USBD_CONFIGURATION_HANDLE ConfigurationHandle, _Inout_ PUSBD_INTERFACE_LIST_ENTRY InterfaceListEntry, _Out_ PURB *Urb)

static NTSTATUS	UsbdexLegacyCapability (_In_ PUSBDEX_HANDLE_OBJECT Handle, _In_ const GUID *CapabilityType, _In_opt_ PUCHAR OutputBuffer)

_Must_inspect_result_	_IRQL_requires_ (PASSIVE_LEVEL)
	Sends a synchronous IOCTL to the specified device object.

	_IRQL_requires_max_ (DISPATCH_LEVEL)

Variables
static POOL_TYPE	UsbdexPoolType = NonPagedPool

static BOOLEAN	UsbdexPoolTypeKnown = FALSE

static IO_COMPLETION_ROUTINE	UsbdexSyncCompletion

static RTL_QUERY_REGISTRY_ROUTINE	UsbdexVerifierValueCallback

Macro Definition Documentation

◆ USBDEX_COMPOSITE_VERSION

#define USBDEX_COMPOSITE_VERSION 0x0100

Definition at line 22 of file usbdex.c.

◆ USBDEX_HANDLE_SIGNATURE

#define USBDEX_HANDLE_SIGNATURE 'DBSU'

Definition at line 10 of file usbdex.c.

◆ USBDEX_MODE_LEGACY

#define USBDEX_MODE_LEGACY USBD_INTERFACE_VERSION_600

Definition at line 14 of file usbdex.c.

◆ USBDEX_MODE_NONE

#define USBDEX_MODE_NONE 0xFFFFFFFF

Definition at line 15 of file usbdex.c.

◆ USBDEX_MODE_UCX

#define USBDEX_MODE_UCX USBD_INTERFACE_VERSION_602

Definition at line 13 of file usbdex.c.

◆ USBDEX_NONPAGED_POOL_NX

#define USBDEX_NONPAGED_POOL_NX ((POOL_TYPE)0x200)

Definition at line 18 of file usbdex.c.

◆ USBDEX_PIPE_MAX_TRANSFER_DEFAULT

#define USBDEX_PIPE_MAX_TRANSFER_DEFAULT 0xFFFFFFFF

Definition at line 20 of file usbdex.c.

◆ USBDEX_SELECT_INTERFACE_MAX_PIPES

#define USBDEX_SELECT_INTERFACE_MAX_PIPES 32

Definition at line 21 of file usbdex.c.

Typedef Documentation

◆ PFN_USBDEX_QUERY_REGISTRY

typedef NTSTATUS(NTAPI * PFN_USBDEX_QUERY_REGISTRY) (_In_ ULONG RelativeTo, _In_ PCWSTR Path, _Inout_ PRTL_QUERY_REGISTRY_TABLE QueryTable, _In_opt_ PVOID Context, _In_opt_ PVOID Environment)

Definition at line 25 of file usbdex.c.

◆ PUSBDEX_HANDLE_OBJECT

typedef struct _USBDEX_HANDLE_OBJECT * PUSBDEX_HANDLE_OBJECT

◆ USBDEX_HANDLE_OBJECT

typedef struct _USBDEX_HANDLE_OBJECT USBDEX_HANDLE_OBJECT

Function Documentation

◆ _IRQL_requires_()

_Must_inspect_result_ _IRQL_requires_ ( PASSIVE_LEVEL )

Sends a synchronous IOCTL to the specified device object.

Parameters

[in]	IoControlCode	The IOCTL to send to the device.
[in]	DeviceObject	Pointer to the device object that will handle the IOCTL.
[in]	InputBuffer	Optional pointer to a buffer containing input data for the IOCTL. When specified, the buffer should be at least of InputBufferLength size.
[in]	InputBufferLength	Size in bytes, of the buffer pointed by InputBuffer.
[out]	OutputBuffer	Optional pointer to a buffer that will receive output data from the IOCTL. When specified, the buffer should be at least of OutputBufferLength size.
[in]	OutputBufferLength	Size in bytes, of the buffer pointed by OutputBuffer.
[in]	FileObject	Optional pointer to a file object that may be necessary for the IOCTL.

Returns: An NTSTATUS code indicating success or failure of this function.

Note: Must be called at PASSIVE_LEVEL with all APCs enabled.

Nothing is found unless the PCI bus driver publishes the properties.

The root hub name without its prefix; NULL when the PDO has no name.

Grows a private buffer to what the helper asks for.

Lets KMDF handle the IRP, then hands it back here still uncompleted.

Waits for the device machine to answer a PnP or power event; returns the PnP status.

Deletes the UCX endpoints of the disabled pipes, then the interface record.

One 4 byte value; the registry type is not checked.

Reread whenever user experience settings change; the open status is returned.

Sends a synchronous IOCTL to the specified device object.

STATUS_SUCCESS when the caller's token is an administrator's.

Sends a synchronous IOCTL to the specified device object.

Reads one value of a walk. A missing value only clears Present; FALSE means stop.

Reads up to Size bytes of a value into a zeroed buffer; the type is not checked.

Writes a REG_BINARY value into the device's usbflags subkey.

Sets or clears ExtPropertiesInstalled from ExtPropDescSemaphore in the hardware key.

Fails only when a port cannot be bound to the USB4 host router its ACPI node names.

Assigns device, hardware, compatible, container and instance ids to a new child PDO.

Answers IRP_MN_QUERY_DEVICE_TEXT on a child PDO; always completes the IRP.

Takes the connector map lock, needed around HubConnectorFindCompanion.

Device hardware key values read at PDO prepare hardware.

Saves the MS OS 2.0 set info in usbflags when the set asks for alternate enumeration.

MsOs20Flags and EnumerationRetryCount, written at PDO start.

Rereads the UXD record; UpdateRequired says whether the device id changes.

Replacement PnP id of a UXD reserved device, or an empty String. Always succeeds.

Telemetry values under the device's Ceip subkey.

BootPathSurpriseRemovalCount + 1.

This machine's dual role features for a dual role partner.

Tells UCX the WDM PDO of the device; call right after the child PDO was created.

IOCTL_INTERNAL_USB_GET_CONTROLLER_NAME: Argument1 and its length Argument2.

IOCTL_INTERNAL_USB_GET_BUS_INFO for the device: the 16 byte USB_BUS_NOTIFICATION at Argument1.

Registers the GUID_USB_WMI_NODE_INFO instance of a child PDO (not for hubs or composites).

Registers the boot device surprise removal event on an external, non hub boot PDO.

Fires the boot device surprise removal event, if one is registered.

Sends a synchronous IOCTL to the specified device object.

Publishes "<port>#<host>" for every bound port on the hub's PDO. QUIRK: with no bound port an older value is left in place.

Binds USB 3 ports to the host routers named by the USB4 DVSEC; an earlier ACPI mapping wins.

Waits on a PnP handshake event with no timeout, printing a watchdog line every minute so a stuck machine is visible in the debugger.

Copies up to Size bytes of a device property; a failed query leaves the field zero.

Only the controller name length is real; both bandwidth fields read 0.

The answer overlays a USB_HUB_NAME on TotalSize, so TotalSize comes back as the name length + 4.

Evaluates a method without arguments into Output.

Drops every MSI descriptor and keeps only lists that still offer a line interrupt.

Picks the list with the best MSI offer: MSI-X first, then the most messages.

Keeps message descriptors covering Wanted messages and removes the others.

Evaluates _DSM on the controller ACPI object with a buffer as Arg3; returns up to 8 result bytes, 0 on failure.

Lets UCX hook the controller device init. Call before WdfDeviceCreate.

Definition at line 571 of file usbdex.c.

{
    PUSBDEX_HANDLE_OBJECT Handle;
    PWSTR ParametersPath;
    NTSTATUS Status;
 
    if (KeGetCurrentIrql() != PASSIVE_LEVEL)
    {
        if (USBDHandle)
            *USBDHandle = NULL;
        return STATUS_INVALID_LEVEL;
    }
 
    UsbdexDetectPoolType();
 
    if (!DeviceObject ||
        !TargetDeviceObject ||
        USBDClientContractVersion < USBD_CLIENT_CONTRACT_VERSION_602 ||
        PoolTag == 0)
    {
        if (USBDHandle)
            *USBDHandle = NULL;
        return STATUS_INVALID_PARAMETER;
    }
 
    if (!USBDHandle)
        return STATUS_INVALID_PARAMETER;
 
    ParametersPath = UsbdexBuildParametersPath(DeviceObject->DriverObject, PoolTag);
 
    Handle = ExAllocatePoolZero(UsbdexPoolType, sizeof(*Handle), PoolTag);
    if (!Handle)
    {
        if (ParametersPath)
            ExFreePoolWithTag(ParametersPath, PoolTag);
        *USBDHandle = NULL;
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    if (ParametersPath)
        UsbdexReadVerifierSettings(DeviceObject->DriverObject, ParametersPath, PoolTag, &Handle->Client);
 
    Handle->Signature = USBDEX_HANDLE_SIGNATURE;
    Handle->Client.Header.Size = sizeof(Handle->Client);
    Handle->Client.Header.Version = USBD_CLIENT_INTERFACE_VERSION;
    Handle->Client.ClientContractVersion = USBDClientContractVersion;
    Handle->Client.DeviceObject = DeviceObject;
    Handle->Client.PoolTag = PoolTag;
    Handle->Client.ClientContext = Handle;
    Handle->TargetDeviceObject = TargetDeviceObject;
    Handle->Mode = USBDEX_MODE_UCX;
    Handle->ReferenceCount = 1;
 
    Status = UsbdexQueryInterface(DeviceObject,
                                  TargetDeviceObject,
                                  &GUID_USBD_CLIENT_INTERFACE,
                                  (PINTERFACE)&Handle->Client);
    if (!NT_SUCCESS(Status))
    {
        /* Nothing the lower stack may have left in the answer part is usable */
        Handle->Client.Handle = NULL;
        Handle->Client.Unregister = NULL;
        Handle->Client.AllocUrb = NULL;
        Handle->Client.AllocIsochUrb = NULL;
        Handle->Client.AllocSelectConfigUrb = NULL;
        Handle->Client.AllocSelectInterfaceUrb = NULL;
        Handle->Client.ReleaseUrb = NULL;
 
        /* Not a UCX stack; the handle still works, with pool URBs */
        Handle->Mode = UsbdexProbeLegacyStack(Handle);
    }
 
    if (ParametersPath)
        ExFreePoolWithTag(ParametersPath, PoolTag);
 
    *USBDHandle = (USBD_HANDLE)Handle;
    return STATUS_SUCCESS;
}

◆ _IRQL_requires_max_()

_IRQL_requires_max_ ( DISPATCH_LEVEL )

IOCTL_INTERNAL_USB_SUBMIT_IDLE_NOTIFICATION; the idle machine owns the IRP afterwards.

Records hub over current in the hub hardware key, once per devnode.

First selective suspend of the device; the registry write runs in a work item.

"USB device not recognized" popup for a port.

A hub was attached beyond the allowed tier depth.

The selected configuration draws more power than the port can give.

The controller ran out of bandwidth for the device; fired by the out of bandwidth timer.

Priority 1 to 3, forwarded to the HCD's EvtEndpointSetCharacteristic.

Tells apart devices that claim the same VID, PID and serial number.

Definition at line 658 of file usbdex.c.

{
    PUSBDEX_HANDLE_OBJECT Handle = UsbdexHandleObject(USBDHandle);
 
    if (!Handle)
        return;
 
    /* Outstanding URBs keep the handle alive until their USBD_UrbFree */
    Handle->CloseRequested = TRUE;
    UsbdexDereferenceHandle(Handle);
}

◆ UsbdexAllocatePoolUrb()

static PURB UsbdexAllocatePoolUrb	(	_In_ PUSBDEX_HANDLE_OBJECT	Handle,
		_In_ SIZE_T	Size
	)

static

Definition at line 420 of file usbdex.c.

{
    return ExAllocatePoolZero(UsbdexPoolType, Size, Handle->Client.PoolTag);
}

Referenced by UsbdexBuildSelectConfigUrb(), and UsbdexBuildSelectInterfaceUrb().

◆ UsbdexBuildParametersPath()

static PWSTR UsbdexBuildParametersPath	(	_In_ PDRIVER_OBJECT	DriverObject,
		_In_ ULONG	PoolTag
	)

static

Turns "\Driver\Name" into "Name\Parameters"; NULL for any other form.

Definition at line 221 of file usbdex.c.

{
    static const WCHAR DriverPrefix[] = L"\\Driver\\";
    static const WCHAR ParametersSuffix[] = L"\\Parameters";
    const SIZE_T PrefixBytes = sizeof(DriverPrefix) - sizeof(WCHAR);
    PUNICODE_STRING DriverName = &DriverObject->DriverName;
    SIZE_T ServiceBytes;
    SIZE_T PathBytes;
    PWSTR Path;
 
    if (DriverName->Length <= PrefixBytes)
        return NULL;
 
    if (!RtlEqualMemory(DriverName->Buffer, DriverPrefix, PrefixBytes))
        return NULL;
 
    ServiceBytes = DriverName->Length - PrefixBytes;
    PathBytes = ServiceBytes + sizeof(ParametersSuffix);
 
    Path = ExAllocatePoolZero(UsbdexPoolType, PathBytes, PoolTag);
    if (!Path)
        return NULL;
 
    RtlCopyMemory(Path, (PUCHAR)DriverName->Buffer + PrefixBytes, ServiceBytes);
    RtlCopyMemory((PUCHAR)Path + ServiceBytes, ParametersSuffix, sizeof(ParametersSuffix));
    return Path;
}

Referenced by _IRQL_requires_().

◆ UsbdexBuildSelectConfigUrb()

static NTSTATUS UsbdexBuildSelectConfigUrb	(	_In_ PUSBDEX_HANDLE_OBJECT	Handle,
		_In_opt_ PUSB_CONFIGURATION_DESCRIPTOR	ConfigurationDescriptor,
		_Inout_ PUSBD_INTERFACE_LIST_ENTRY	InterfaceList,
		_Out_ PURB *	Urb
	)

static

Definition at line 453 of file usbdex.c.

{
    PUSBD_INTERFACE_LIST_ENTRY Entry;
    PUCHAR Cursor;
    PUCHAR End;
    PURB NewUrb;
    ULONG TotalSize;
    ULONG BlockSize;
    UCHAR PipeCount;
 
    /* The URB Length field is 16 bits, so the whole request has to fit */
    TotalSize = FIELD_OFFSET(struct _URB_SELECT_CONFIGURATION, Interface);
    for (Entry = InterfaceList; Entry->InterfaceDescriptor; Entry++)
    {
        TotalSize += (ULONG)GET_USBD_INTERFACE_SIZE(Entry->InterfaceDescriptor->bNumEndpoints);
        if (TotalSize > MAXUSHORT)
            return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    NewUrb = UsbdexAllocatePoolUrb(Handle, TotalSize);
    if (!NewUrb)
        return STATUS_INSUFFICIENT_RESOURCES;
 
    Cursor = (PUCHAR)&NewUrb->UrbSelectConfiguration.Interface;
    End = (PUCHAR)NewUrb + TotalSize;
 
    /* The descriptors may change under us, so every block is checked against the buffer again */
    for (Entry = InterfaceList; Entry->InterfaceDescriptor; Entry++)
    {
        PipeCount = Entry->InterfaceDescriptor->bNumEndpoints;
        BlockSize = (ULONG)GET_USBD_INTERFACE_SIZE(PipeCount);
        if (BlockSize > (ULONG)(End - Cursor))
        {
            ExFreePoolWithTag(NewUrb, Handle->Client.PoolTag);
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        UsbdexInitInterfaceInformation((PUSBD_INTERFACE_INFORMATION)Cursor,
                                       Entry->InterfaceDescriptor,
                                       PipeCount);
        Entry->Interface = (PUSBD_INTERFACE_INFORMATION)Cursor;
        Cursor += BlockSize;
    }
 
    NewUrb->UrbSelectConfiguration.Hdr.Length = (USHORT)TotalSize;
    NewUrb->UrbSelectConfiguration.Hdr.Function = URB_FUNCTION_SELECT_CONFIGURATION;
    NewUrb->UrbSelectConfiguration.ConfigurationDescriptor = ConfigurationDescriptor;
 
    *Urb = NewUrb;
    return STATUS_SUCCESS;
}

◆ UsbdexBuildSelectInterfaceUrb()

static NTSTATUS UsbdexBuildSelectInterfaceUrb	(	_In_ PUSBDEX_HANDLE_OBJECT	Handle,
		_In_ USBD_CONFIGURATION_HANDLE	ConfigurationHandle,
		_Inout_ PUSBD_INTERFACE_LIST_ENTRY	InterfaceListEntry,
		_Out_ PURB *	Urb
	)

static

Definition at line 511 of file usbdex.c.

{
    PUSB_INTERFACE_DESCRIPTOR Descriptor;
    PURB NewUrb;
    ULONG TotalSize;
    UCHAR PipeCount;
 
    Descriptor = InterfaceListEntry->InterfaceDescriptor;
    if (!Descriptor)
        return STATUS_INVALID_PARAMETER;
 
    PipeCount = Descriptor->bNumEndpoints;
    if (PipeCount > USBDEX_SELECT_INTERFACE_MAX_PIPES)
        return STATUS_INVALID_PARAMETER;
 
    TotalSize = FIELD_OFFSET(struct _URB_SELECT_INTERFACE, Interface) +
                (ULONG)GET_USBD_INTERFACE_SIZE(PipeCount);
 
    NewUrb = UsbdexAllocatePoolUrb(Handle, TotalSize);
    if (!NewUrb)
        return STATUS_INSUFFICIENT_RESOURCES;
 
    UsbdexInitInterfaceInformation(&NewUrb->UrbSelectInterface.Interface, Descriptor, PipeCount);
    InterfaceListEntry->Interface = &NewUrb->UrbSelectInterface.Interface;
 
    NewUrb->UrbSelectInterface.Hdr.Length = (USHORT)TotalSize;
    NewUrb->UrbSelectInterface.Hdr.Function = URB_FUNCTION_SELECT_INTERFACE;
    NewUrb->UrbSelectInterface.ConfigurationHandle = ConfigurationHandle;
 
    *Urb = NewUrb;
    return STATUS_SUCCESS;
}

◆ UsbdexCallAndWait()

static NTSTATUS UsbdexCallAndWait	(	_In_ PDEVICE_OBJECT	ClientDevice,
		_In_ PDEVICE_OBJECT	Target,
		_In_ __drv_freesMem(Mem) PIRP	Irp
	)

static

Definition at line 110 of file usbdex.c.

{
    KEVENT Done;
    NTSTATUS Status;
 
    KeInitializeEvent(&Done, NotificationEvent, FALSE);
 
    Status = IoSetCompletionRoutineEx(ClientDevice, Irp, UsbdexSyncCompletion, &Done, TRUE, TRUE, TRUE);
    if (!NT_SUCCESS(Status))
        IoSetCompletionRoutine(Irp, UsbdexSyncCompletion, &Done, TRUE, TRUE, TRUE);
 
    Status = IoCallDriver(Target, Irp);
    if (Status == STATUS_PENDING)
    {
        KeWaitForSingleObject(&Done, Executive, KernelMode, FALSE, NULL);
        Status = Irp->IoStatus.Status;
    }
 
    IoFreeIrp(Irp);
    return Status;
}

Referenced by UsbdexQueryInterface(), and UsbdexSendCapabilityRequest().

◆ UsbdexDereferenceHandle()

static VOID UsbdexDereferenceHandle ( _Inout_ PUSBDEX_HANDLE_OBJECT Handle )

static

Definition at line 359 of file usbdex.c.

{
    if (InterlockedDecrement(&Handle->ReferenceCount) > 0)
        return;
 
    /* Only a closed handle goes away; anything else is a client imbalance */
    if (!Handle->CloseRequested)
        return;
 
    if (Handle->Client.Unregister)
        Handle->Client.Unregister(Handle->Client.Handle);
 
    ExFreePoolWithTag(Handle, Handle->Client.PoolTag);
}

Referenced by _IRQL_requires_max_(), and UsbdexFinishAllocation().

◆ UsbdexDetectPoolType()

static VOID UsbdexDetectPoolType ( VOID )

static

Definition at line 69 of file usbdex.c.

{
    RTL_OSVERSIONINFOW OsVersion;
 
    if (UsbdexPoolTypeKnown)
        return;
 
    UsbdexPoolType = NonPagedPool;
 
    RtlZeroMemory(&OsVersion, sizeof(OsVersion));
    OsVersion.dwOSVersionInfoSize = sizeof(OsVersion);
    if (NT_SUCCESS(RtlGetVersion(&OsVersion)))
    {
        if (OsVersion.dwMajorVersion > 6 ||
            (OsVersion.dwMajorVersion == 6 && OsVersion.dwMinorVersion >= 2))
        {
            UsbdexPoolType = USBDEX_NONPAGED_POOL_NX;
        }
    }
 
    UsbdexPoolTypeKnown = TRUE;
}

Referenced by _IRQL_requires_().

◆ UsbdexFinishAllocation()

static NTSTATUS UsbdexFinishAllocation	(	_Inout_ PUSBDEX_HANDLE_OBJECT	Handle,
		_In_ NTSTATUS	Status,
		_Inout_ PURB *	Urb
	)

static

Definition at line 404 of file usbdex.c.

{
    if (!NT_SUCCESS(Status))
    {
        *Urb = NULL;
        UsbdexDereferenceHandle(Handle);
    }
 
    return Status;
}

◆ UsbdexHandleObject()

FORCEINLINE PUSBDEX_HANDLE_OBJECT UsbdexHandleObject ( _In_opt_ USBD_HANDLE USBDHandle )

Definition at line 53 of file usbdex.c.

{
    return (PUSBDEX_HANDLE_OBJECT)USBDHandle;
}

Referenced by _IRQL_requires_max_().

◆ UsbdexInitInterfaceInformation()

static VOID UsbdexInitInterfaceInformation	(	_Out_ PUSBD_INTERFACE_INFORMATION	Information,
		_In_ PUSB_INTERFACE_DESCRIPTOR	Descriptor,
		_In_ UCHAR	PipeCount
	)

static

Definition at line 430 of file usbdex.c.

{
    PUSBD_PIPE_INFORMATION Pipe;
    ULONG Index;
 
    Information->Length = (USHORT)GET_USBD_INTERFACE_SIZE(PipeCount);
    Information->InterfaceNumber = Descriptor->bInterfaceNumber;
    Information->AlternateSetting = Descriptor->bAlternateSetting;
    Information->NumberOfPipes = PipeCount;
 
    Pipe = Information->Pipes;
    for (Index = 0; Index < PipeCount; Index++)
    {
        Pipe[Index].MaximumTransferSize = USBDEX_PIPE_MAX_TRANSFER_DEFAULT;
        Pipe[Index].PipeFlags = 0;
    }
}

Referenced by UsbdexBuildSelectConfigUrb(), and UsbdexBuildSelectInterfaceUrb().

◆ UsbdexIsUcxMode()

FORCEINLINE BOOLEAN UsbdexIsUcxMode ( _In_ PUSBDEX_HANDLE_OBJECT Handle )

Definition at line 61 of file usbdex.c.

{
    return Handle->Mode != USBDEX_MODE_NONE && Handle->Mode >= USBDEX_MODE_UCX;
}

◆ UsbdexLegacyCapability()

static NTSTATUS UsbdexLegacyCapability	(	_In_ PUSBDEX_HANDLE_OBJECT	Handle,
		_In_ const GUID *	CapabilityType,
		_In_opt_ PUCHAR	OutputBuffer
	)

static

Definition at line 551 of file usbdex.c.

{
    if (IsEqualGUID(CapabilityType, &GUID_USB_CAPABILITY_DEVICE_CONNECTION_HIGH_SPEED_COMPATIBLE))
    {
        if (OutputBuffer)
            return STATUS_INVALID_PARAMETER;
 
        return Handle->HighSpeed ? STATUS_SUCCESS : STATUS_NOT_SUPPORTED;
    }
 
    if (IsEqualGUID(CapabilityType, &GUID_USB_CAPABILITY_SELECTIVE_SUSPEND))
        return OutputBuffer ? STATUS_INVALID_PARAMETER : STATUS_SUCCESS;
 
    return STATUS_NOT_IMPLEMENTED;
}

◆ UsbdexProbeLegacyStack()

static ULONG UsbdexProbeLegacyStack ( _Inout_ PUSBDEX_HANDLE_OBJECT Handle )

static

Definition at line 318 of file usbdex.c.

{
    USB_BUS_INTERFACE_USBDI_V1 BusInterface;
    NTSTATUS Status;
 
    RtlZeroMemory(&BusInterface, sizeof(BusInterface));
    BusInterface.Size = sizeof(BusInterface);
    BusInterface.Version = USB_BUSIF_USBDI_VERSION_1;
 
    Status = UsbdexQueryInterface(Handle->Client.DeviceObject,
                                  Handle->TargetDeviceObject,
                                  &USB_BUS_INTERFACE_USBDI_GUID,
                                  (PINTERFACE)&BusInterface);
    if (!NT_SUCCESS(Status))
        return USBDEX_MODE_NONE;
 
    if (BusInterface.IsDeviceHighSpeed)
        Handle->HighSpeed = BusInterface.IsDeviceHighSpeed(BusInterface.BusContext);
 
    /* The bus driver referenced the interface while answering; this is the only use of it */
    if (BusInterface.InterfaceDereference)
        BusInterface.InterfaceDereference(BusInterface.BusContext);
 
    return USBDEX_MODE_LEGACY;
}

Referenced by _IRQL_requires_().

◆ UsbdexQueryInterface()

static NTSTATUS UsbdexQueryInterface	(	_In_ PDEVICE_OBJECT	ClientDevice,
		_In_ PDEVICE_OBJECT	Target,
		_In_ const GUID *	InterfaceType,
		_Inout_ PINTERFACE	Interface
	)

static

Definition at line 137 of file usbdex.c.

{
    PIO_STACK_LOCATION Stack;
    PIRP Irp;
 
    Irp = IoAllocateIrp(Target->StackSize, FALSE);
    if (!Irp)
        return STATUS_INSUFFICIENT_RESOURCES;
 
    /* PnP IRPs must start out as not supported */
    Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
 
    Stack = IoGetNextIrpStackLocation(Irp);
    Stack->MajorFunction = IRP_MJ_PNP;
    Stack->MinorFunction = IRP_MN_QUERY_INTERFACE;
    Stack->Parameters.QueryInterface.InterfaceType = InterfaceType;
    Stack->Parameters.QueryInterface.Size = Interface->Size;
    Stack->Parameters.QueryInterface.Version = Interface->Version;
    Stack->Parameters.QueryInterface.Interface = Interface;
    Stack->Parameters.QueryInterface.InterfaceSpecificData = NULL;
 
    return UsbdexCallAndWait(ClientDevice, Target, Irp);
}

Referenced by _IRQL_requires_(), and UsbdexProbeLegacyStack().

◆ UsbdexReadVerifierSettings()

static VOID UsbdexReadVerifierSettings	(	_In_ PDRIVER_OBJECT	DriverObject,
		_In_z_ PCWSTR	ParametersPath,
		_In_ ULONG	PoolTag,
		_Inout_ PUSBD_CLIENT_INTERFACE	Client
	)

static

Definition at line 254 of file usbdex.c.

{
    PCWSTR ValueNames[] =
    {
        L"UsbVerifierEnabled",
        L"UsbVerifierFailRegistration",
        L"UsbVerifierFailChainedMdlSupport",
        L"UsbVerifierFailStaticStreamSupport",
        L"UsbVerifierStaticStreamCountOverride",
        L"UsbVerifierFailEnableStaticStreams",
    };
    PULONG Fields[] =
    {
        &Client->VerifierEnabled,
        &Client->VerifierFailRegistration,
        &Client->VerifierFailChainedMdlSupport,
        &Client->VerifierFailStaticStreamSupport,
        &Client->VerifierStaticStreamCountOverride,
        &Client->VerifierFailEnableStaticStreams,
    };
    PRTL_QUERY_REGISTRY_TABLE Table;
    PFN_USBDEX_QUERY_REGISTRY QueryValues;
    UNICODE_STRING RoutineName;
    SIZE_T TableBytes;
    ULONG Index;
 
    C_ASSERT(RTL_NUMBER_OF(ValueNames) == RTL_NUMBER_OF(Fields));
 
    Client->VerifierEnabled = MmIsDriverVerifying(DriverObject) ? 1 : 0;
 
    /* One extra zeroed entry terminates the table */
    TableBytes = (RTL_NUMBER_OF(ValueNames) + 1) * sizeof(*Table);
    Table = ExAllocatePoolZero(UsbdexPoolType, TableBytes, PoolTag);
    if (!Table)
        return;
 
    for (Index = 0; Index < RTL_NUMBER_OF(ValueNames); Index++)
    {
        Table[Index].QueryRoutine = UsbdexVerifierValueCallback;
        Table[Index].Flags = 0;
        Table[Index].Name = (PWSTR)ValueNames[Index];
        Table[Index].EntryContext = Fields[Index];
        Table[Index].DefaultType = REG_DWORD;
        Table[Index].DefaultData = Fields[Index];
        Table[Index].DefaultLength = sizeof(ULONG);
    }
 
    RtlInitUnicodeString(&RoutineName, L"RtlQueryRegistryValuesEx");
    QueryValues = (PFN_USBDEX_QUERY_REGISTRY)MmGetSystemRoutineAddress(&RoutineName);
    if (!QueryValues)
        QueryValues = RtlQueryRegistryValues;
 
    (VOID)QueryValues(RTL_REGISTRY_SERVICES, ParametersPath, Table, NULL, NULL);
 
    ExFreePoolWithTag(Table, PoolTag);
}

Referenced by _IRQL_requires_().

◆ UsbdexReferenceHandle()

static NTSTATUS UsbdexReferenceHandle ( _Inout_ PUSBDEX_HANDLE_OBJECT Handle )

static

Definition at line 347 of file usbdex.c.

{
    if (Handle->CloseRequested || Handle->ReferenceCount < 1)
        return STATUS_INVALID_DEVICE_STATE;
 
    InterlockedIncrement(&Handle->ReferenceCount);
    return STATUS_SUCCESS;
}

Referenced by UsbdexStartAllocation().

◆ UsbdexSendCapabilityRequest()

static NTSTATUS UsbdexSendCapabilityRequest	(	_In_ PDEVICE_OBJECT	ClientDevice,
		_In_ PDEVICE_OBJECT	Target,
		_Inout_ PUCXHUB_QUERY_CAPABILITY	Request,
		_Out_opt_ PVOID	OutputBuffer
	)

static

Definition at line 167 of file usbdex.c.

{
    PIO_STACK_LOCATION Stack;
    PIRP Irp;
 
    Irp = IoAllocateIrp(Target->StackSize, FALSE);
    if (!Irp)
        return STATUS_INSUFFICIENT_RESOURCES;
 
    Irp->AssociatedIrp.SystemBuffer = OutputBuffer;
 
    Stack = IoGetNextIrpStackLocation(Irp);
    Stack->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL;
    Stack->MinorFunction = 0;
    Stack->Parameters.DeviceIoControl.IoControlCode = IOCTL_UCXHUB_QUERY_USB_CAPABILITY;
    Stack->Parameters.Others.Argument1 = Request;
 
    return UsbdexCallAndWait(ClientDevice, Target, Irp);
}

◆ UsbdexStartAllocation()

static NTSTATUS UsbdexStartAllocation	(	_In_opt_ PUSBDEX_HANDLE_OBJECT	Handle,
		_In_ BOOLEAN	ArgumentsValid,
		_Out_opt_ PURB *	Urb
	)

static

Definition at line 378 of file usbdex.c.

{
    if (!Handle || !ArgumentsValid)
    {
        if (Urb)
            *Urb = NULL;
        return STATUS_INVALID_PARAMETER;
    }
 
    if (!Urb)
        return STATUS_INVALID_PARAMETER;
 
    *Urb = NULL;
 
    if (!NT_SUCCESS(UsbdexReferenceHandle(Handle)))
        return STATUS_INVALID_DEVICE_STATE;
 
    return STATUS_SUCCESS;
}

◆ UsbdexSyncCompletion()

static NTSTATUS NTAPI UsbdexSyncCompletion	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_In_ PIRP	Irp,
		_In_reads_opt_(_Inexpressible_("varies")) PVOID	Context
	)

static

Definition at line 95 of file usbdex.c.

{
    UNREFERENCED_PARAMETER(DeviceObject);
    UNREFERENCED_PARAMETER(Irp);
 
    KeSetEvent((PKEVENT)Context, IO_NO_INCREMENT, FALSE);
    return STATUS_MORE_PROCESSING_REQUIRED;
}

◆ UsbdexVerifierValueCallback()

static NTSTATUS NTAPI UsbdexVerifierValueCallback	(	_In_z_ PWSTR	ValueName,
		_In_ ULONG	ValueType,
		_In_reads_bytes_opt_(ValueLength) PVOID	ValueData,
		_In_ ULONG	ValueLength,
		_In_opt_ PVOID	Context,
		_In_opt_ PVOID	EntryContext
	)

static

Definition at line 194 of file usbdex.c.

{
    UNREFERENCED_PARAMETER(ValueName);
    UNREFERENCED_PARAMETER(Context);
 
    if (ValueType != REG_DWORD)
        return STATUS_INVALID_PARAMETER;
 
    if (ValueLength != sizeof(ULONG))
        return STATUS_INTERNAL_ERROR;
 
    /* A missing value comes back as the default, which already is the destination */
    if (ValueData != EntryContext)
        *(PULONG)EntryContext = *(PULONG)ValueData;
 
    return STATUS_SUCCESS;
}

Variable Documentation

◆ UsbdexPoolType

POOL_TYPE UsbdexPoolType = NonPagedPool

static

Definition at line 45 of file usbdex.c.

Referenced by _IRQL_requires_(), UsbdexAllocatePoolUrb(), UsbdexBuildParametersPath(), UsbdexDetectPoolType(), and UsbdexReadVerifierSettings().

◆ UsbdexPoolTypeKnown

BOOLEAN UsbdexPoolTypeKnown = FALSE

static

Definition at line 46 of file usbdex.c.

Referenced by UsbdexDetectPoolType().

◆ UsbdexSyncCompletion

IO_COMPLETION_ROUTINE UsbdexSyncCompletion

static

Definition at line 48 of file usbdex.c.

Referenced by UsbdexCallAndWait().

◆ UsbdexVerifierValueCallback

RTL_QUERY_REGISTRY_ROUTINE UsbdexVerifierValueCallback

static

Definition at line 49 of file usbdex.c.

Referenced by UsbdexReadVerifierSettings().

Classes

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ USBDEX_COMPOSITE_VERSION

◆ USBDEX_HANDLE_SIGNATURE

◆ USBDEX_MODE_LEGACY

◆ USBDEX_MODE_NONE

◆ USBDEX_MODE_UCX

◆ USBDEX_NONPAGED_POOL_NX

◆ USBDEX_PIPE_MAX_TRANSFER_DEFAULT

◆ USBDEX_SELECT_INTERFACE_MAX_PIPES

Typedef Documentation

◆ PFN_USBDEX_QUERY_REGISTRY

◆ PUSBDEX_HANDLE_OBJECT

◆ USBDEX_HANDLE_OBJECT

Function Documentation

◆ _IRQL_requires_()

◆ _IRQL_requires_max_()

◆ UsbdexAllocatePoolUrb()

◆ UsbdexBuildParametersPath()

◆ UsbdexBuildSelectConfigUrb()

◆ UsbdexBuildSelectInterfaceUrb()

◆ UsbdexCallAndWait()

◆ UsbdexDereferenceHandle()

◆ UsbdexDetectPoolType()

◆ UsbdexFinishAllocation()

◆ UsbdexHandleObject()

◆ UsbdexInitInterfaceInformation()

◆ UsbdexIsUcxMode()

◆ UsbdexLegacyCapability()

◆ UsbdexProbeLegacyStack()

◆ UsbdexQueryInterface()

◆ UsbdexReadVerifierSettings()

◆ UsbdexReferenceHandle()

◆ UsbdexSendCapabilityRequest()

◆ UsbdexStartAllocation()

◆ UsbdexSyncCompletion()

◆ UsbdexVerifierValueCallback()

Variable Documentation

◆ UsbdexPoolType

◆ UsbdexPoolTypeKnown

◆ UsbdexSyncCompletion

◆ UsbdexVerifierValueCallback