rhubpdo.cpp File Reference

#include "ucx01000.h"
#include <debug.h>

Include dependency graph for rhubpdo.cpp:

Go to the source code of this file.

Macros
#define	NDEBUG
#define	UCX_ROOT_HUB_ID   L"USB\\ROOT_HUB30"
#define	UCX_HWID_FULL_CHARS   RTL_NUMBER_OF(UCX_ROOT_HUB_ID L"&VID0000&PID0000&REV0000")
#define	UCX_HWID_SHORT_CHARS   RTL_NUMBER_OF(UCX_ROOT_HUB_ID L"&VID0000&PID0000")
#define	UCX_HWID_PLAIN_CHARS   RTL_NUMBER_OF(UCX_ROOT_HUB_ID)
#define	UCX_HWID_BUFFER_CHARS   ((UCX_HWID_FULL_CHARS + UCX_HWID_SHORT_CHARS + UCX_HWID_PLAIN_CHARS + 1) * sizeof(WCHAR))

Enumerations
enum class	UcxStackSetup { Skip , DeviceMgmtCompletion , GetInfoCompletion }

Functions
	DECLARE_GLOBAL_CONST_UNICODE_STRING (UcxRootHubPdoSddl, L"D:P(A;;GA;;;SY)(A;;GRGWGX;;;BA)(A;;GRGW;;;WD)(A;;GR;;;RC)")
static VOID NTAPI	UcxBuildRootHubHardwareIds (_In_ const UCX_CONTROLLER_CONFIG *Config, _Out_writes_(BufferChars) PWCHAR Buffer, _In_ SIZE_T BufferChars, _Out_ PUNICODE_STRING Ids)
	_IRQL_requires_ (PASSIVE_LEVEL) static VOID NTAPI UcxRootHubCopyPciProperties(_In_ WDFDEVICE Controller
	Sends a synchronous IOCTL to the specified device object.
	if (!NT_SUCCESS(Status))
	if (Found)
	if (Attributes !=NULL) WdfObjectDelete(Attributes)
NTSTATUS NTAPI	UcxEvtRootHubPrepareHardware (_In_ WDFDEVICE Device, _In_ WDFCMRESLIST ResourcesRaw, _In_ WDFCMRESLIST ResourcesTranslated)
NTSTATUS NTAPI	UcxEvtRootHubReleaseHardware (_In_ WDFDEVICE Device, _In_ WDFCMRESLIST ResourcesTranslated)
NTSTATUS NTAPI	UcxEvtRootHubD0Entry (_In_ WDFDEVICE Device, _In_ WDF_POWER_DEVICE_STATE PreviousState)
NTSTATUS NTAPI	UcxEvtRootHubD0Exit (_In_ WDFDEVICE Device, _In_ WDF_POWER_DEVICE_STATE TargetState)
NTSTATUS NTAPI	UcxEvtRootHubEnableWakeAtBus (_In_ WDFDEVICE Device, _In_ SYSTEM_POWER_STATE PowerState)
VOID NTAPI	UcxEvtRootHubDisableWakeAtBus (_In_ WDFDEVICE Device)
VOID NTAPI	UcxEvtRootHubPdoIoDeviceControl (_In_ WDFQUEUE Queue, _In_ WDFREQUEST Request, _In_ size_t OutputBufferLength, _In_ size_t InputBufferLength, _In_ ULONG IoControlCode)
static WDFQUEUE NTAPI	UcxRouteHubIoctl (_In_ UcxController *Controller, _In_ ULONG IoControlCode, _Out_ UcxStackSetup *Setup)
static NTSTATUS NTAPI	UcxCompleteIrpWithStatus (_In_ PIRP Irp, _In_ NTSTATUS Status)
static VOID NTAPI	UcxSetCompletionRoutine (_In_ WDFDEVICE Device, _In_ PIRP Irp, _In_ PIO_COMPLETION_ROUTINE Routine, _In_ PVOID Context)
static NTSTATUS NTAPI	UcxQueueAsyncPortReset (_In_ UcxController *Controller, _In_ PIRP Irp)
NTSTATUS NTAPI	UcxEvtRootHubPreprocessInternalIoctl (_In_ WDFDEVICE Device, _Inout_ PIRP Irp)
NTSTATUS NTAPI	UcxEvtRootHubPreprocessQueryInterface (_In_ WDFDEVICE Device, _Inout_ PIRP Irp)
NTSTATUS NTAPI	UcxEvtRootHubPreprocessSetPower (_In_ WDFDEVICE Device, _Inout_ PIRP Irp)
static NTSTATUS NTAPI	UcxDeviceMgmtCompletion (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp, _In_reads_opt_(_Inexpressible_("varies")) PVOID Context)
static NTSTATUS NTAPI	UcxRootHubGetInfoCompletion (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp, _In_reads_opt_(_Inexpressible_("varies")) PVOID Context)

Variables
static IO_COMPLETION_ROUTINE	UcxDeviceMgmtCompletion
static IO_COMPLETION_ROUTINE	UcxRootHubGetInfoCompletion
static const WCHAR	UcxRootHubDeviceIdText [] = UCX_ROOT_HUB_ID L"\0"
static const SIZE_T	UcxHardwareIdSeparators []
static const DEVPROPKEY	UcxPciKeySerialNumber
static const DEVPROPKEY	UcxPciKeyUsb4PortAttributes
static const DEVPROPKEY	UcxPciKeyParentSerialNumber
_In_ WDFDEVICE	Pdo
WDFMEMORY	Attributes = NULL
PVOID	AttributesData = NULL
size_t	AttributesSize = 0
DEVPROPTYPE	AttributesType = DEVPROP_TYPE_UINT32
DEVPROPTYPE	SerialType = DEVPROP_TYPE_EMPTY
ULONG64	Serial = 0
ULONG	Required = 0
BOOLEAN	Found = NT_SUCCESS(Status)
NTSTATUS	Status = WdfDeviceQueryPropertyEx(Controller, &Property, sizeof(Serial), &Serial, &Required, &SerialType)
WDF_DEVICE_PROPERTY_DATA_INIT &	Property
	else

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 10 of file rhubpdo.cpp.

UCX_HWID_BUFFER_CHARS

#define UCX_HWID_BUFFER_CHARS   ((UCX_HWID_FULL_CHARS + UCX_HWID_SHORT_CHARS + UCX_HWID_PLAIN_CHARS + 1) * sizeof(WCHAR))

Definition at line 30 of file rhubpdo.cpp.

UCX_HWID_FULL_CHARS

#define UCX_HWID_FULL_CHARS   RTL_NUMBER_OF(UCX_ROOT_HUB_ID L"&VID0000&PID0000&REV0000")

Definition at line 27 of file rhubpdo.cpp.

UCX_HWID_PLAIN_CHARS

#define UCX_HWID_PLAIN_CHARS   RTL_NUMBER_OF(UCX_ROOT_HUB_ID)

Definition at line 29 of file rhubpdo.cpp.

UCX_HWID_SHORT_CHARS

#define UCX_HWID_SHORT_CHARS   RTL_NUMBER_OF(UCX_ROOT_HUB_ID L"&VID0000&PID0000")

Definition at line 28 of file rhubpdo.cpp.

UCX_ROOT_HUB_ID

#define UCX_ROOT_HUB_ID   L"USB\\ROOT_HUB30"

Definition at line 21 of file rhubpdo.cpp.

Enumeration Type Documentation

UcxStackSetup

enum class UcxStackSetup

strong

Enumerator
Skip
DeviceMgmtCompletion
GetInfoCompletion

Definition at line 588 of file rhubpdo.cpp.

{
    Skip,
    DeviceMgmtCompletion,
    GetInfoCompletion
};

Function Documentation

_IRQL_requires_()

_IRQL_requires_

(

PASSIVE_LEVEL

)

Sends a synchronous IOCTL to the specified device object.

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

Definition at line 2121 of file class.c.

{
    NTSTATUS status = STATUS_SUCCESS;
 
    PAGED_CODE();
 
    TracePrint((TRACE_LEVEL_VERBOSE,
                TRACE_FLAG_PNP,
                "ClassDetermineTokenOperationCommandSupport (%p): Entering function.\n",
                DeviceObject));
 
    //
    // Send down Inquiry for VPD_THIRD_PARTY_COPY_PAGE and cache away the device parameters
    // from WINDOWS_BLOCK_DEVICE_TOKEN_LIMITS_DESCRIPTOR.
    //
    status = ClasspGetBlockDeviceTokenLimitsInfo(DeviceObject);
 
    if (NT_SUCCESS(status)) {
 
        ULONG maxListIdentifier = MaxTokenOperationListIdentifier;
 
        //
        // Query the maximum list identifier to use for TokenOperation commands.
        //
        if (NT_SUCCESS(ClasspGetMaximumTokenListIdentifier(DeviceObject, REG_DISK_CLASS_CONTROL, &maxListIdentifier))) {
            if (maxListIdentifier >= MIN_TOKEN_LIST_IDENTIFIERS) {
 
                NT_ASSERT(maxListIdentifier <= MAX_TOKEN_LIST_IDENTIFIERS);
                MaxTokenOperationListIdentifier = maxListIdentifier;
            }
        }
 
    }
 
    TracePrint((TRACE_LEVEL_VERBOSE,
                TRACE_FLAG_PNP,
                "ClassDetermineTokenOperationCommandSupport (%p): Exiting function with status %x.\n",
                DeviceObject,
                status));
 
    return status;
}

DECLARE_GLOBAL_CONST_UNICODE_STRING()

DECLARE_GLOBAL_CONST_UNICODE_STRING	(	UcxRootHubPdoSddl	,
		L"D:P(A;;GA;;;SY)(A;;GRGWGX;;;BA)(A;;GRGW;;;WD)(A;;GR;;;RC)"
	)

if() [1/3]

if

(

!

NT_SUCCESSStatus

)

Definition at line 342 of file rhubpdo.cpp.

    {
        WDF_DEVICE_PROPERTY_DATA_INIT(&Property, &UcxPciKeyParentSerialNumber);
        Status = WdfDeviceQueryPropertyEx(Controller, &Property, sizeof(Serial), &Serial, &Required, &SerialType);
    }

if() [2/3]

if

(

Attributes !

= NULL

)

Definition at line 86 of file fxdmaenablerapi.cpp.

                                                                {
        FxObjectHandleGetPtr(pFxDriverGlobals,
                             Attributes->ParentObject,
                             FX_TYPE_OBJECT,
                             (PVOID*)&pParent);
 
        if (pFxDriverGlobals->IsVersionGreaterThanOrEqualTo(1,11)) {
            FxDeviceBase * pSearchDevice;
 
            //
            // If a parent object is passed-in it must be descendent of device.
            // DmaEnabler stores device and uses it during dispose
            // (to remove it from dmaenabler list maintained at device level),
            // so DmaEnabler cannot outlive device.
            //
 
            pSearchDevice = FxDeviceBase::_SearchForDevice(pParent, NULL);
 
            if (pSearchDevice == NULL) {
                status = STATUS_WDF_OBJECT_ATTRIBUTES_INVALID;
 
                DoTraceLevelMessage(
                    pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDMA,
                    "Attributes->ParentObject 0x%p must have WDFDEVICE as an "
                    "eventual ancestor, %!STATUS!",
                    Attributes->ParentObject, status);
 
                return status;
            }
            else if (pSearchDevice != pDevice) {
                status = STATUS_WDF_OBJECT_ATTRIBUTES_INVALID;
 
                DoTraceLevelMessage(
                    pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDMA,
                    "Attributes->ParentObject 0x%p ancestor is WDFDEVICE %p, but "
                    "not the same WDFDEVICE 0x%p passed to WdfDmaEnablerCreate, "
                    "%!STATUS!",
                    Attributes->ParentObject, pSearchDevice->GetHandle(),
                    Device, status);
 
                return status;
            }
        }
        else {
            //
            // For < 1.11 drivers we only allow pDevice to be the parent
            // since that is what we were blindly setting the parent to.
            //
            // Using the passed-in parent for such drivers could cause
            // side-effects such as earlier deletion of DmaEnabler object. So
            // we don't do that.
            //
            // We cause this verifier breakpoint to warn downlevel drivers
            // that the parent they passed in gets ignored.
            //
            if (pParent != pDevice) {
                DoTraceLevelMessage(
                    pFxDriverGlobals, TRACE_LEVEL_WARNING, TRACINGDMA,
                    "For drivers bound to version <= 1.9 "
                    "WdfDmaEnablerCreate uses WDFDEVICE as the "
                    "parent object for the dma enabler object. "
                    "Attributes->ParentObject 0x%p, which is different from "
                    "WDFDEVICE 0x%p, gets ignored. Please note that DmaEnabler "
                    "would be disposed only when device is disposed.",
                    Attributes->ParentObject, Device);
 
                if (pFxDriverGlobals->IsDownlevelVerificationEnabled()) {
                    FxVerifierDbgBreakPoint(pFxDriverGlobals);
                }
            }
 
            pParent = pDevice;
        }
    }

if() [3/3]

if

(

Found

)

Definition at line 349 of file rhubpdo.cpp.

    {
        WDF_DEVICE_PROPERTY_DATA_INIT(&Property, &UcxPciKeyUsb4PortAttributes);
        Status = WdfDeviceAllocAndQueryPropertyEx(Controller,
                                                  &Property,
                                                  PagedPool,
                                                  WDF_NO_OBJECT_ATTRIBUTES,
                                                  &Attributes,
                                                  &AttributesType);
        if (NT_SUCCESS(Status))
        {
            AttributesData = WdfMemoryGetBuffer(Attributes, &AttributesSize);
        }
        else
        {
            /* QUIRK: the serial number is dropped as well */
            DPRINT1("Controller %p USB4 port attributes query failed 0x%lx\n", Controller, Status);
            Attributes = NULL;
            Found = FALSE;
        }
    }

UcxBuildRootHubHardwareIds()

static VOID NTAPI UcxBuildRootHubHardwareIds ( _In_ const UCX_CONTROLLER_CONFIG *  Config, _Out_writes_(BufferChars) PWCHAR  Buffer, _In_ SIZE_T  BufferChars, _Out_ PUNICODE_STRING  Ids  )

static

Most specific ID first, ending with the plain root hub ID.

Definition at line 44 of file rhubpdo.cpp.

{
    const UCX_CONTROLLER_PCI_INFORMATION* Pci = &Config->PciDeviceInfo;
    const UCX_CONTROLLER_ACPI_INFORMATION* Acpi = &Config->AcpiDeviceInfo;
    ULONG Index;
 
    if (Config->ParentBusType != UcxControllerParentBusTypePci &&
        Config->ParentBusType != UcxControllerParentBusTypeAcpi)
    {
        Ids->Buffer = (PWCH)UcxRootHubDeviceIdText;
        Ids->Length = sizeof(UcxRootHubDeviceIdText) - sizeof(WCHAR);
        Ids->MaximumLength = sizeof(UcxRootHubDeviceIdText);
        return;
    }
 
    RtlInitEmptyUnicodeString(Ids, Buffer, (USHORT)(BufferChars * sizeof(WCHAR)));
 
    /* A truncated result is used as is */
    if (Config->ParentBusType == UcxControllerParentBusTypePci)
    {
        RtlUnicodeStringPrintf(Ids,
                               UCX_ROOT_HUB_ID L"&VID%04X&PID%04X&REV%04X#" UCX_ROOT_HUB_ID L"&VID%04X&PID%04X#" UCX_ROOT_HUB_ID L"#",
                               Pci->VendorId, Pci->DeviceId, Pci->RevisionId,
                               Pci->VendorId, Pci->DeviceId);
    }
    else
    {
        RtlUnicodeStringPrintf(Ids,
                               UCX_ROOT_HUB_ID L"&VID%S&PID%S&REV%S#" UCX_ROOT_HUB_ID L"&VID%S&PID%S#" UCX_ROOT_HUB_ID L"#",
                               Acpi->VendorId, Acpi->DeviceId, Acpi->RevisionId,
                               Acpi->VendorId, Acpi->DeviceId);
    }
 
    for (Index = 0; Index < RTL_NUMBER_OF(UcxHardwareIdSeparators); Index++)
        Buffer[UcxHardwareIdSeparators[Index]] = UNICODE_NULL;
}

Referenced by UcxRootHub::CreatePdo().

UcxCompleteIrpWithStatus()

static NTSTATUS NTAPI UcxCompleteIrpWithStatus ( _In_ PIRP  Irp, _In_ NTSTATUS  Status  )

static

Definition at line 656 of file rhubpdo.cpp.

{
    Irp->IoStatus.Status = Status;
    Irp->IoStatus.Information = 0;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
    return Status;
}

Referenced by UcxEvtRootHubPreprocessInternalIoctl(), and UcxQueueAsyncPortReset().

UcxDeviceMgmtCompletion()

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

static

Definition at line 820 of file rhubpdo.cpp.

{
    PIO_STACK_LOCATION Stack = IoGetCurrentIrpStackLocation(Irp);
    PVOID Payload = Stack->Parameters.Others.Argument1;
    UcxUsbDevice* Device;
 
    UNREFERENCED_PARAMETER(DeviceObject);
    UNREFERENCED_PARAMETER(Context);
 
    if (Irp->PendingReturned)
        IoMarkIrpPending(Irp);
 
    switch (Stack->Parameters.DeviceIoControl.IoControlCode)
    {
        case IOCTL_UCXHUB_ENDPOINTS_CONFIGURE:
            Device = UcxUsbDevice::FromHandle(((PENDPOINTS_CONFIGURE)Payload)->Header.UsbDevice);
            return Device->OnHcdEndpointsConfigureDone(Irp, (PENDPOINTS_CONFIGURE)Payload);
 
        case IOCTL_UCXHUB_DEVICE_ENABLE:
            Device = UcxUsbDevice::FromHandle(((PUSBDEVICE_ENABLE)Payload)->Header.UsbDevice);
            return Device->OnHcdEnableDone(Irp, (PUSBDEVICE_ENABLE)Payload);
 
        case IOCTL_UCXHUB_DEVICE_RESET:
            Device = UcxUsbDevice::FromHandle(((PUSBDEVICE_RESET)Payload)->Header.UsbDevice);
            if (Device->m_ResetFailedByControllerReset)
            {
                Device->m_ResetFailedByControllerReset = FALSE;
                return STATUS_CONTINUE_COMPLETION;
            }
            return Device->OnHcdResetDone(Irp, (PUSBDEVICE_RESET)Payload);
 
        case IOCTL_UCXHUB_ENDPOINT_RESET:
            Device = UcxUsbDevice::FromHandle(((PENDPOINT_RESET)Payload)->Header.UsbDevice);
            if (Device->m_EndpointResetFailedByControllerReset)
            {
                Device->m_EndpointResetFailedByControllerReset = FALSE;
                return STATUS_CONTINUE_COMPLETION;
            }
            return UcxEndpoint::FromHandle(((PENDPOINT_RESET)Payload)->Endpoint)->OnHcdResetDone(Irp);
 
        default:
            return STATUS_CONTINUE_COMPLETION;
    }
}

UcxEvtRootHubD0Entry()

NTSTATUS NTAPI UcxEvtRootHubD0Entry	(	_In_ WDFDEVICE	Device,
		_In_ WDF_POWER_DEVICE_STATE	PreviousState
	)

Definition at line 476 of file rhubpdo.cpp.

{
    UcxRootHubPdoContext* Context = UcxGetRootHubPdoContext(Device);
    UcxInterruptQueueState* State = Context->RootHub->m_InterruptState;
 
    UNREFERENCED_PARAMETER(PreviousState);
 
    DPRINT("Root hub PDO %p D0 entry, previous WDF state %d\n", Device, PreviousState);
 
    {
        SpinLockGuard Guard(&State->PortChangeLock);
 
        State->IndicateWakeEnabled = FALSE;
    }
 
    /* A port change may still be inside WdfDeviceIndicateWakeStatus */
    KeWaitForSingleObject(&State->NoIndicateWakeInProgress, Executive, KernelMode, FALSE, NULL);
 
    Context->Controller->PostResetEvent(CrEvent::RootHubPoweredUp);
    Context->Controller->m_RootHubInD0 = TRUE;
 
    return STATUS_SUCCESS;
}

UcxEvtRootHubD0Exit()

NTSTATUS NTAPI UcxEvtRootHubD0Exit	(	_In_ WDFDEVICE	Device,
		_In_ WDF_POWER_DEVICE_STATE	TargetState
	)

Definition at line 504 of file rhubpdo.cpp.

{
    UcxRootHubPdoContext* Context = UcxGetRootHubPdoContext(Device);
    UcxController* Controller = Context->Controller;
    UcxRootHub* RootHub = Context->RootHub;
    UcxInterruptQueueState* State = RootHub->m_InterruptState;
    BOOLEAN WakeNow = FALSE;
 
    UNREFERENCED_PARAMETER(TargetState);
 
    DPRINT("Root hub PDO %p D0 exit, target WDF state %d\n", Device, TargetState);
 
    /* Waits out any reset recovery that still needs the root hub */
    Controller->PostResetEvent(CrEvent::RootHubPoweringDown);
    KeWaitForSingleObject(&Controller->m_RootHubMayExitD0, Executive, KernelMode, FALSE, NULL);
    Controller->m_RootHubInD0 = FALSE;
 
    {
        SpinLockGuard Guard(&State->PortChangeLock);
 
        /* The hub may have dropped its last transfer; make the next one reach the HCD */
        if (!State->LastTransferCanceled)
            State->PortChangeGeneration++;
 
        /* S0 idle: changes from now on must wake the root hub */
        if (RootHub->m_SystemPowerAction == PowerActionNone)
        {
            State->IndicateWakeEnabled = TRUE;
            WakeNow = (State->PortChangeGeneration != State->PortChangeGenerationProcessed);
        }
    }
 
    if (WakeNow)
        WdfDeviceIndicateWakeStatus(Device, STATUS_SUCCESS);
 
    return STATUS_SUCCESS;
}

UcxEvtRootHubDisableWakeAtBus()

VOID NTAPI UcxEvtRootHubDisableWakeAtBus

(

_In_ WDFDEVICE

Device

)

Definition at line 564 of file rhubpdo.cpp.

{
    UNREFERENCED_PARAMETER(Device);
}

UcxEvtRootHubEnableWakeAtBus()

NTSTATUS NTAPI UcxEvtRootHubEnableWakeAtBus	(	_In_ WDFDEVICE	Device,
		_In_ SYSTEM_POWER_STATE	PowerState
	)

Definition at line 546 of file rhubpdo.cpp.

{
    UNREFERENCED_PARAMETER(PowerState);
 
    if (UcxGetRootHubPdoContext(Device)->Controller->IsResetInProgress())
    {
        DPRINT1("Root hub PDO %p wake arm failed, controller reset in progress\n", Device);
        return STATUS_NO_SUCH_DEVICE;
    }
 
    DPRINT("Root hub PDO %p wake armed\n", Device);
    return STATUS_SUCCESS;
}

UcxEvtRootHubPdoIoDeviceControl()

VOID NTAPI UcxEvtRootHubPdoIoDeviceControl	(	_In_ WDFQUEUE	Queue,
		_In_ WDFREQUEST	Request,
		_In_ size_t	OutputBufferLength,
		_In_ size_t	InputBufferLength,
		_In_ ULONG	IoControlCode
	)

Definition at line 572 of file rhubpdo.cpp.

{
    UNREFERENCED_PARAMETER(Queue);
    UNREFERENCED_PARAMETER(OutputBufferLength);
    UNREFERENCED_PARAMETER(InputBufferLength);
    DPRINT1("Root hub PDO user IOCTL 0x%lx not supported\n", IoControlCode);
    WdfRequestComplete(Request, STATUS_INVALID_DEVICE_REQUEST);
}

UcxEvtRootHubPrepareHardware()

NTSTATUS NTAPI UcxEvtRootHubPrepareHardware	(	_In_ WDFDEVICE	Device,
		_In_ WDFCMRESLIST	ResourcesRaw,
		_In_ WDFCMRESLIST	ResourcesTranslated
	)

Definition at line 398 of file rhubpdo.cpp.

{
    UcxRootHubPdoContext* Context = UcxGetRootHubPdoContext(Device);
    UcxRootHub* RootHub = Context->RootHub;
    WDF_OBJECT_ATTRIBUTES Attributes;
    WDFSTRING Name;
    NTSTATUS Status;
 
    UNREFERENCED_PARAMETER(ResourcesRaw);
    UNREFERENCED_PARAMETER(ResourcesTranslated);
 
    WDF_OBJECT_ATTRIBUTES_INIT(&Attributes);
    Attributes.ParentObject = Device;
 
    Status = WdfStringCreate(NULL, &Attributes, &Name);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Root hub PDO %p interface string create failed 0x%lx\n", Device, Status);
        return Status;
    }
 
    Status = WdfDeviceRetrieveDeviceInterfaceString(Device, &GUID_DEVINTERFACE_USB_HUB, NULL, Name);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Root hub PDO %p hub interface name query failed 0x%lx\n", Device, Status);
        WdfObjectDelete(Name);
        return Status;
    }
 
    /* Controller errata are known by now */
    Context->Controller->m_ClearTtBufferOnAsyncCancel = Context->Controller->QueryClearTtBufferOnCancel();
 
    {
        SpinLockGuard Guard(&RootHub->m_PdoInfoLock);
 
        RootHub->m_PdoStarted = TRUE;
        RootHub->m_SymbolicName = Name;
    }
 
    UcxRootHubCopyPciProperties(Context->Controller->m_Fdo, Device);
 
    /* Unknown until the first S IRP, as USBPORT reports it */
    RootHub->m_LastSystemSleepState = PowerSystemUnspecified;
    DPRINT("Root hub PDO %p prepared\n", Device);
    return STATUS_SUCCESS;
}

UcxEvtRootHubPreprocessInternalIoctl()

NTSTATUS NTAPI UcxEvtRootHubPreprocessInternalIoctl	(	_In_ WDFDEVICE	Device,
		_Inout_ PIRP	Irp
	)

Definition at line 721 of file rhubpdo.cpp.

{
    UcxController* Controller = UcxGetRootHubPdoContext(Device)->Controller;
    ULONG Code = IoGetCurrentIrpStackLocation(Irp)->Parameters.DeviceIoControl.IoControlCode;
    UcxStackSetup Setup;
    WDFQUEUE Queue;
 
    if (Code == IOCTL_INTERNAL_USB_SUBMIT_URB)
        return UcxProcessSubmitUrb(Device, Irp);
 
    if (Code == IOCTL_UCXHUB_RESET_PORT_ASYNC)
        return UcxQueueAsyncPortReset(Controller, Irp);
 
    Queue = UcxRouteHubIoctl(Controller, Code, &Setup);
    if (Queue == NULL)
    {
        DPRINT1("Root hub PDO internal IOCTL 0x%lx not supported, IRP %p\n", Code, Irp);
        return UcxCompleteIrpWithStatus(Irp, STATUS_NOT_SUPPORTED);
    }
 
    switch (Setup)
    {
        case UcxStackSetup::DeviceMgmtCompletion:
            IoCopyCurrentIrpStackLocationToNext(Irp);
            UcxSetCompletionRoutine(Device, Irp, UcxDeviceMgmtCompletion, Device);
            break;
 
        case UcxStackSetup::GetInfoCompletion:
            IoCopyCurrentIrpStackLocationToNext(Irp);
            UcxSetCompletionRoutine(Device, Irp, UcxRootHubGetInfoCompletion, Device);
            break;
 
        default:
            IoSkipCurrentIrpStackLocation(Irp);
            break;
    }
 
    return WdfDeviceWdmDispatchIrpToIoQueue(Device, Irp, Queue, WDF_DISPATCH_IRP_TO_IO_QUEUE_PREPROCESSED_IRP);
}

UcxEvtRootHubPreprocessQueryInterface()

NTSTATUS NTAPI UcxEvtRootHubPreprocessQueryInterface	(	_In_ WDFDEVICE	Device,
		_Inout_ PIRP	Irp
	)

Definition at line 766 of file rhubpdo.cpp.

{
    PIO_STACK_LOCATION Stack = IoGetCurrentIrpStackLocation(Irp);
    const GUID* Type = Stack->Parameters.QueryInterface.InterfaceType;
 
    if (IsEqualGUID(*Type, USB_BUS_INTERFACE_USBDI_GUID) ||
        IsEqualGUID(*Type, GUID_UCXHUB_PARENT_INTERFACE) ||
        IsEqualGUID(*Type, GUID_UCXHUB_STACK_INTERFACE))
    {
        Stack->Parameters.QueryInterface.Interface->Size = Stack->Parameters.QueryInterface.Size;
        Stack->Parameters.QueryInterface.Interface->Version = Stack->Parameters.QueryInterface.Version;
    }
 
    IoSkipCurrentIrpStackLocation(Irp);
    return WdfDeviceWdmDispatchPreprocessedIrp(Device, Irp);
}

UcxEvtRootHubPreprocessSetPower()

NTSTATUS NTAPI UcxEvtRootHubPreprocessSetPower	(	_In_ WDFDEVICE	Device,
		_Inout_ PIRP	Irp
	)

Definition at line 788 of file rhubpdo.cpp.

{
    PIO_STACK_LOCATION Stack = IoGetCurrentIrpStackLocation(Irp);
    UcxRootHub* RootHub = UcxGetRootHubPdoContext(Device)->RootHub;
    SYSTEM_POWER_STATE Target;
 
    if (Stack->Parameters.Power.Type == SystemPowerState)
    {
        Target = (SYSTEM_POWER_STATE)Stack->Parameters.Power.SystemPowerStateContext.TargetSystemState;
 
        if (Target != PowerSystemWorking)
        {
            RootHub->m_LastSystemSleepState = Target;
            RootHub->m_SystemPowerAction = Stack->Parameters.Power.ShutdownType;
        }
        else
        {
            RootHub->m_SystemPowerAction = PowerActionNone;
        }
    }
 
    IoSkipCurrentIrpStackLocation(Irp);
    return WdfDeviceWdmDispatchPreprocessedIrp(Device, Irp);
}

UcxEvtRootHubReleaseHardware()

NTSTATUS NTAPI UcxEvtRootHubReleaseHardware	(	_In_ WDFDEVICE	Device,
		_In_ WDFCMRESLIST	ResourcesTranslated
	)

Definition at line 450 of file rhubpdo.cpp.

{
    UcxRootHub* RootHub = UcxGetRootHubPdoContext(Device)->RootHub;
    WDFSTRING Name;
 
    UNREFERENCED_PARAMETER(ResourcesTranslated);
 
    {
        SpinLockGuard Guard(&RootHub->m_PdoInfoLock);
 
        RootHub->m_PdoStarted = FALSE;
        Name = RootHub->m_SymbolicName;
        RootHub->m_SymbolicName = NULL;
    }
 
    if (Name != NULL)
        WdfObjectDelete(Name);
 
    DPRINT("Root hub PDO %p released\n", Device);
    return STATUS_SUCCESS;
}

UcxQueueAsyncPortReset()

static NTSTATUS NTAPI UcxQueueAsyncPortReset ( _In_ UcxController *  Controller, _In_ PIRP  Irp  )

static

Definition at line 692 of file rhubpdo.cpp.

{
    if (Controller->m_Config.EvtControllerReset == NULL)
    {
        DPRINT1("Controller %p has no reset callback, failing async port reset\n", Controller);
        return UcxCompleteIrpWithStatus(Irp, STATUS_NOT_SUPPORTED);
    }
 
    if (Controller->HasFailed())
    {
        DPRINT1("Controller %p has failed, refusing async port reset\n", Controller);
        return UcxCompleteIrpWithStatus(Irp, STATUS_UNSUCCESSFUL);
    }
 
    DPRINT("Controller %p async port reset requested by hub\n", Controller);
 
    IoMarkIrpPending(Irp);
 
    NT_ASSERT(Controller->m_RootHub->m_PendingAsyncReset == NULL);
    Controller->m_RootHub->m_PendingAsyncReset = Irp;
 
    Controller->PostResetEvent(CrEvent::HubRequestsReset);
    return STATUS_PENDING;
}

Referenced by UcxEvtRootHubPreprocessInternalIoctl().

UcxRootHubGetInfoCompletion()

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

static

Definition at line 872 of file rhubpdo.cpp.

{
    PIO_STACK_LOCATION Stack = IoGetCurrentIrpStackLocation(Irp);
    ULONG Code = Stack->Parameters.DeviceIoControl.IoControlCode;
    PUCXHUB_ROOTHUB_INFO Info;
    UcxRootHub* RootHub;
 
    UNREFERENCED_PARAMETER(DeviceObject);
 
    if (Irp->PendingReturned)
        IoMarkIrpPending(Irp);
 
    if (!NT_SUCCESS(Irp->IoStatus.Status))
    {
        DPRINT1("Root hub PDO %p IOCTL 0x%lx failed by HCD 0x%lx\n",
                Context, Code, Irp->IoStatus.Status);
        return STATUS_CONTINUE_COMPLETION;
    }
 
    if (Code != IOCTL_UCXHUB_ROOTHUB_GET_INFO)
        return STATUS_CONTINUE_COMPLETION;
 
    Info = (PUCXHUB_ROOTHUB_INFO)Stack->Parameters.Others.Argument1;
    RootHub = UcxGetRootHubPdoContext((WDFDEVICE)Context)->RootHub;
 
    Info->Info.Size = sizeof(*Info);
    RootHub->m_NumberOf20Ports = Info->Info.NumberOf20Ports;
    RootHub->m_NumberOf30Ports = Info->Info.NumberOf30Ports;
 
    DPRINT("Root hub %p has %lu USB 2 and %lu USB 3 ports\n",
           RootHub, (ULONG)Info->Info.NumberOf20Ports, (ULONG)Info->Info.NumberOf30Ports);
 
    return STATUS_CONTINUE_COMPLETION;
}

UcxRouteHubIoctl()

static WDFQUEUE NTAPI UcxRouteHubIoctl ( _In_ UcxController *  Controller, _In_ ULONG  IoControlCode, _Out_ UcxStackSetup *  Setup  )

static

The controller queue a hub IOCTL goes to, or NULL when the root hub does not serve it.

Definition at line 599 of file rhubpdo.cpp.

{
    *Setup = UcxStackSetup::Skip;
 
    switch (IoControlCode)
    {
        case IOCTL_UCXHUB_ENDPOINTS_CONFIGURE:
        case IOCTL_UCXHUB_DEVICE_ENABLE:
        case IOCTL_UCXHUB_DEVICE_RESET:
        case IOCTL_UCXHUB_ENDPOINT_RESET:
            *Setup = UcxStackSetup::DeviceMgmtCompletion;
            return Controller->m_DeviceMgmtQueue;
 
        case IOCTL_UCXHUB_DEVICE_ADDRESS:
        case IOCTL_UCXHUB_DEVICE_UPDATE:
        case IOCTL_UCXHUB_DEVICE_HUB_INFO:
        case IOCTL_UCXHUB_DEVICE_DISABLE:
        case IOCTL_UCXHUB_DEVICE_PURGE_IO:
        case IOCTL_UCXHUB_DEVICE_START_IO:
        case IOCTL_UCXHUB_DEFAULT_ENDPOINT_UPDATE:
        case IOCTL_UCXHUB_DEVICE_ABORT_IO:
            return Controller->m_DeviceMgmtQueue;
 
        case IOCTL_UCXHUB_DEVICE_TREE_PURGE_IO:
            return Controller->m_TreePurgeQueue;
 
        case IOCTL_UCXHUB_ADDRESS0_OWNERSHIP_ACQUIRE:
            return Controller->m_Address0Queue;
 
        /* The port info IOCTLs get the completion routine only so HCD failures print */
        case IOCTL_UCXHUB_ROOTHUB_GET_INFO:
        case IOCTL_UCXHUB_ROOTHUB_GET_20PORT_INFO:
        case IOCTL_UCXHUB_ROOTHUB_GET_30PORT_INFO:
            *Setup = UcxStackSetup::GetInfoCompletion;
            return Controller->m_DefaultQueue;
 
        case IOCTL_INTERNAL_USB_REGISTER_COMPOSITE_DEVICE:
        case IOCTL_INTERNAL_USB_UNREGISTER_COMPOSITE_DEVICE:
        case IOCTL_INTERNAL_USB_REQUEST_REMOTE_WAKE_NOTIFICATION:
        case IOCTL_UCXHUB_QUERY_USB_CAPABILITY:
        case IOCTL_UCXHUB_SET_FUNCTION_HANDLE_DATA:
        case IOCTL_UCXHUB_GET_DUMP_DATA:
        case IOCTL_UCXHUB_FREE_DUMP_DATA:
        case IOCTL_UCXHUB_NOTIFY_FORWARD_PROGRESS:
            return Controller->m_DefaultQueue;
 
        default:
            return NULL;
    }
}

Referenced by UcxEvtRootHubPreprocessInternalIoctl().

UcxSetCompletionRoutine()

static VOID NTAPI UcxSetCompletionRoutine ( _In_ WDFDEVICE  Device, _In_ PIRP  Irp, _In_ PIO_COMPLETION_ROUTINE  Routine, _In_ PVOID  Context  )

static

Keeps ucx01000 loaded until the routine ran when the system allows it.

Definition at line 670 of file rhubpdo.cpp.

{
    NTSTATUS Status;
 
    Status = IoSetCompletionRoutineEx(WdfDeviceWdmGetDeviceObject(Device),
                                      Irp,
                                      Routine,
                                      Context,
                                      TRUE,
                                      TRUE,
                                      TRUE);
    if (!NT_SUCCESS(Status))
        IoSetCompletionRoutine(Irp, Routine, Context, TRUE, TRUE, TRUE);
}

Referenced by UcxEvtRootHubPreprocessInternalIoctl().

Variable Documentation

Attributes

WDFMEMORY Attributes = NULL

Definition at line 330 of file rhubpdo.cpp.

Referenced by UcxEvtRootHubPrepareHardware().

AttributesData

PVOID AttributesData = NULL

Definition at line 331 of file rhubpdo.cpp.

Referenced by if().

AttributesSize

size_t AttributesSize = 0

Definition at line 332 of file rhubpdo.cpp.

Referenced by if().

AttributesType

DEVPROPTYPE AttributesType = DEVPROP_TYPE_UINT32

Definition at line 333 of file rhubpdo.cpp.

Referenced by if().

else

else

Initial value:

{
        
        WDF_DEVICE_PROPERTY_DATA_INIT(&Property, &UcxPciKeySerialNumber)

Definition at line 377 of file rhubpdo.cpp.

Found

Found = NT_SUCCESS(Status)

Definition at line 337 of file rhubpdo.cpp.

Referenced by if().

Pdo

Pdo

Initial value:

{
    WDF_DEVICE_PROPERTY_DATA Property

Definition at line 327 of file rhubpdo.cpp.

Property

_In_ DWORD Property

Definition at line 340 of file rhubpdo.cpp.

Required

_In_ MEMORY_AREA _In_ PVOID _In_ BOOLEAN _Inout_ PMM_REQUIRED_RESOURCES Required = 0

Definition at line 336 of file rhubpdo.cpp.

Referenced by ExpectNoProperty(), ExpectProperty(), HubUsb4InterfaceChange(), if(), MiGetOnePage(), MiWriteFilePage(), MmPageOutCacheSection(), profile_items_callback(), SepPrivilegeCheck(), SetupDiGetActualModelsSectionA(), START_TEST(), Test_DeviceBuiltins(), Test_InterfaceBuiltins(), Test_InterfaceParameters(), test_SetupDiGetActualModelsSectionA(), and test_SetupDiGetActualModelsSectionW().

Serial

ULONG64 Serial = 0

Definition at line 335 of file rhubpdo.cpp.

Referenced by DeviceMachine::AddChildToHub(), CalcVolumeSerialNumber(), HubIoGetDescriptor(), if(), ScreenDeviceControl(), ScreenWrite(), and VolumeInfoMain().

SerialType

DEVPROPTYPE SerialType = DEVPROP_TYPE_EMPTY

Definition at line 334 of file rhubpdo.cpp.

Referenced by if().

Status

Status = WdfDeviceQueryPropertyEx(Controller, &Property, sizeof(Serial), &Serial, &Required, &SerialType)

Definition at line 338 of file rhubpdo.cpp.

Referenced by UcxCompleteIrpWithStatus(), UcxEvtRootHubPrepareHardware(), and UcxSetCompletionRoutine().

UcxDeviceMgmtCompletion

IO_COMPLETION_ROUTINE UcxDeviceMgmtCompletion

static

Definition at line 18 of file rhubpdo.cpp.

Referenced by UcxEvtRootHubPreprocessInternalIoctl().

UcxHardwareIdSeparators

const SIZE_T UcxHardwareIdSeparators[]

static

Initial value:

=
{
    UCX_HWID_FULL_CHARS - 1,
    UCX_HWID_FULL_CHARS + UCX_HWID_SHORT_CHARS - 1,
    UCX_HWID_FULL_CHARS + UCX_HWID_SHORT_CHARS + UCX_HWID_PLAIN_CHARS - 1
}

Definition at line 33 of file rhubpdo.cpp.

Referenced by UcxBuildRootHubHardwareIds().

UcxPciKeyParentSerialNumber

const DEVPROPKEY UcxPciKeyParentSerialNumber

static

Initial value:

=
    { { 0x3ab22e31, 0x8264, 0x4b4e, { 0x9a, 0xf5, 0xa8, 0xd2, 0xd8, 0xe3, 0x3e, 0x62 } }, 45 }

Definition at line 317 of file rhubpdo.cpp.

Referenced by if().

UcxPciKeySerialNumber

const DEVPROPKEY UcxPciKeySerialNumber

static

Initial value:

=
    { { 0x3ab22e31, 0x8264, 0x4b4e, { 0x9a, 0xf5, 0xa8, 0xd2, 0xd8, 0xe3, 0x3e, 0x62 } }, 40 }

Definition at line 313 of file rhubpdo.cpp.

UcxPciKeyUsb4PortAttributes

const DEVPROPKEY UcxPciKeyUsb4PortAttributes

static

Initial value:

=
    { { 0x3ab22e31, 0x8264, 0x4b4e, { 0x9a, 0xf5, 0xa8, 0xd2, 0xd8, 0xe3, 0x3e, 0x62 } }, 42 }

Definition at line 315 of file rhubpdo.cpp.

Referenced by if().

UcxRootHubDeviceIdText

const WCHAR UcxRootHubDeviceIdText[] = UCX_ROOT_HUB_ID L"\0"

static

Definition at line 24 of file rhubpdo.cpp.

Referenced by UcxBuildRootHubHardwareIds().

UcxRootHubGetInfoCompletion

IO_COMPLETION_ROUTINE UcxRootHubGetInfoCompletion

static

Definition at line 19 of file rhubpdo.cpp.

Referenced by UcxEvtRootHubPreprocessInternalIoctl().