UcxRootHub Class Reference

#include <rhub.h>

Collaboration diagram for UcxRootHub:

Public Member Functions
VOID	PortChanged ()
UcxUsbDevice *	Device () const
VOID	FailIo ()
VOID	ResumeIo ()
VOID	FinishPortResetRequest (_In_ BOOLEAN Succeeded)
NTSTATUS	EnableForwardProgress ()
VOID	DispatchGetInfo (_In_ WDFREQUEST Request, _Inout_ PUCXHUB_ROOTHUB_INFO Info)
NTSTATUS	ReferenceSymbolicName (_Out_ WDFSTRING *Name)
WDFDEVICE	Pdo () const

Static Public Member Functions
static _Must_inspect_result_ NTSTATUS	Create (_In_ UCXCONTROLLER Controller, _In_ PUCX_ROOTHUB_CONFIG Config, _In_opt_ PWDF_OBJECT_ATTRIBUTES Attributes, _Out_ UCXROOTHUB *RootHub)
static UcxRootHub *	FromHandle (_In_ UCXROOTHUB Handle)

Public Attributes
UCXROOTHUB	m_Handle
UcxController *	m_Controller
UCX_ROOTHUB_CONFIG	m_Config
UcxUsbDevice *	m_Device
UcxEndpoint *	m_ControlEndpoint
UcxEndpoint *	m_InterruptEndpoint
WDFQUEUE	m_ControlQueue
WDFQUEUE	m_InterruptQueue
UcxInterruptQueueState *	m_InterruptState
USHORT	m_NumberOf20Ports
USHORT	m_NumberOf30Ports
WDF_DEVICE_PNP_CAPABILITIES	m_PnpCaps
WDF_DEVICE_POWER_CAPABILITIES	m_PowerCaps
KSPIN_LOCK	m_PdoInfoLock
WDFDEVICE	m_Pdo
BOOLEAN	m_PdoStarted
WDFSTRING	m_SymbolicName
PIRP	m_PendingAsyncReset
SYSTEM_POWER_STATE	m_LastSystemSleepState
POWER_ACTION	m_SystemPowerAction

Private Member Functions
NTSTATUS	Initialize (_In_ UcxController *Controller, _In_ PUCX_ROOTHUB_CONFIG Config)
NTSTATUS	CreateEndpoint (_In_ BOOLEAN Interrupt)
NTSTATUS	CreatePdo ()
VOID	BuildPowerCapabilities ()
NTSTATUS	AddQueryInterfaces ()

Static Private Attributes
static EVT_WDF_OBJECT_CONTEXT_CLEANUP	EvtCleanup

Friends
class	UcxRootHubPdo

Detailed Description

Definition at line 47 of file rhub.h.

Member Function Documentation

AddQueryInterfaces()

NTSTATUS UcxRootHub::AddQueryInterfaces ( )

private

Definition at line 518 of file hubinterface.cpp.

{
    WDF_QUERY_INTERFACE_CONFIG Config;
    UCXHUB_PARENT_INTERFACE_ORIGINAL ParentTemplate;
    UCXHUB_STACK_INTERFACE StackTemplate;
    USBD_CLIENT_INTERFACE ClientTemplate;
    PNP_LOCATION_INTERFACE Location;
    NTSTATUS Status;
 
    /* Templates use the smallest accepted size; KMDF rejects anything below it */
    RtlZeroMemory(&ParentTemplate, sizeof(ParentTemplate));
    ParentTemplate.Header.Size = sizeof(ParentTemplate);
    ParentTemplate.Header.Version = UCXHUB_PARENT_INTERFACE_VERSION;
    WDF_QUERY_INTERFACE_CONFIG_INIT(&Config,
                                    (PINTERFACE)&ParentTemplate,
                                    &GUID_UCXHUB_PARENT_INTERFACE,
                                    UcxEvtQueryParentInterface);
    Config.ImportInterface = TRUE;
    Status = WdfDeviceAddQueryInterface(m_Pdo, &Config);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Root hub PDO %p parent interface add failed 0x%lx\n", m_Pdo, Status);
        return Status;
    }
 
    RtlZeroMemory(&StackTemplate, sizeof(StackTemplate));
    StackTemplate.Header.Size = UCXHUB_STACK_INTERFACE_SIZE_ORIGINAL;
    StackTemplate.Header.Version = UCXHUB_STACK_INTERFACE_VERSION_1;
    WDF_QUERY_INTERFACE_CONFIG_INIT(&Config,
                                    (PINTERFACE)&StackTemplate,
                                    &GUID_UCXHUB_STACK_INTERFACE,
                                    UcxEvtQueryStackInterface);
    Config.ImportInterface = TRUE;
    Status = WdfDeviceAddQueryInterface(m_Pdo, &Config);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Root hub PDO %p stack interface add failed 0x%lx\n", m_Pdo, Status);
        return Status;
    }
 
    WDF_QUERY_INTERFACE_CONFIG_INIT(&Config, NULL, &USB_BUS_INTERFACE_USBDI_GUID, UcxEvtQueryUsbdiInterface);
    Config.ImportInterface = TRUE;
    Status = WdfDeviceAddQueryInterface(m_Pdo, &Config);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Root hub PDO %p USBDI interface add failed 0x%lx\n", m_Pdo, Status);
        return Status;
    }
 
    RtlZeroMemory(&ClientTemplate, sizeof(ClientTemplate));
    ClientTemplate.Header.Size = sizeof(ClientTemplate);
    ClientTemplate.Header.Version = USBD_CLIENT_INTERFACE_VERSION;
    WDF_QUERY_INTERFACE_CONFIG_INIT(&Config,
                                    (PINTERFACE)&ClientTemplate,
                                    &GUID_USBD_CLIENT_INTERFACE,
                                    UcxEvtQueryUsbdClientInterface);
    Config.ImportInterface = TRUE;
    Status = WdfDeviceAddQueryInterface(m_Pdo, &Config);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Root hub PDO %p USBD client interface add failed 0x%lx\n", m_Pdo, Status);
        return Status;
    }
 
    RtlZeroMemory(&Location, sizeof(Location));
    Location.Size = sizeof(Location);
    Location.Version = PNP_LOCATION_INTERFACE_VERSION;
    Location.InterfaceReference = UcxInterfaceNoOp;
    Location.InterfaceDereference = UcxInterfaceNoOp;
    Location.GetLocationString = UcxGetLocationString;
    WDF_QUERY_INTERFACE_CONFIG_INIT(&Config, (PINTERFACE)&Location, &GUID_PNP_LOCATION_INTERFACE, NULL);
    Config.ImportInterface = FALSE;
 
    Status = WdfDeviceAddQueryInterface(m_Pdo, &Config);
    if (!NT_SUCCESS(Status))
        DPRINT1("Root hub PDO %p location interface add failed 0x%lx\n", m_Pdo, Status);
 
    return Status;
}

Referenced by AddQueryInterfaces(), and CreatePdo().

BuildPowerCapabilities()

VOID UcxRootHub::BuildPowerCapabilities ( )

private

D2 is the wake state for every S state the controller can wake from.

Definition at line 87 of file rhubpdo.cpp.

{
    const DEVICE_CAPABILITIES* Hc = &m_Controller->m_HcCaps;
    SYSTEM_POWER_STATE FirstWake;
    ULONG State;
 
    WDF_DEVICE_POWER_CAPABILITIES_INIT(&m_PowerCaps);
    m_PowerCaps.DeviceD1 = WdfFalse;
    m_PowerCaps.DeviceD2 = WdfTrue;
    m_PowerCaps.WakeFromD0 = WdfTrue;
    m_PowerCaps.WakeFromD1 = WdfFalse;
    m_PowerCaps.WakeFromD2 = WdfTrue;
    m_PowerCaps.WakeFromD3 = WdfFalse;
    m_PowerCaps.DeviceWake = PowerDeviceD2;
 
    FirstWake = (Hc->SystemWake == PowerSystemUnspecified) ? PowerSystemWorking : Hc->SystemWake;
    m_PowerCaps.SystemWake = FirstWake;
 
    for (State = PowerSystemSleeping1; State <= PowerSystemHibernate; State++)
    {
        if (State <= (ULONG)Hc->SystemWake && Hc->DeviceState[State] != PowerDeviceUnspecified)
        {
            m_PowerCaps.DeviceState[State] = PowerDeviceD2;
            if (FirstWake == PowerSystemShutdown)
                m_PowerCaps.SystemWake = (SYSTEM_POWER_STATE)State;
        }
        else
        {
            m_PowerCaps.DeviceState[State] = PowerDeviceD3;
        }
    }
 
    /* Hybrid sleep: waking from S3 means waking from S4 too */
    if (m_PowerCaps.DeviceState[PowerSystemSleeping3] == PowerDeviceD2 &&
        m_PowerCaps.DeviceState[PowerSystemHibernate] != PowerDeviceD2)
    {
        m_PowerCaps.DeviceState[PowerSystemHibernate] = PowerDeviceD2;
        m_PowerCaps.SystemWake = PowerSystemHibernate;
    }
}

Referenced by BuildPowerCapabilities(), and CreatePdo().

Create()

_Must_inspect_result_ NTSTATUS UcxRootHub::Create ( _In_ UCXCONTROLLER  Controller, _In_ PUCX_ROOTHUB_CONFIG  Config, _In_opt_ PWDF_OBJECT_ATTRIBUTES  Attributes, _Out_ UCXROOTHUB *  RootHub  )

static

Definition at line 22 of file rhub.cpp.

{
    WDF_OBJECT_ATTRIBUTES UcxAttributes;
    WDF_OBJECT_ATTRIBUTES DeviceAttributes;
    UcxController* ControllerContext = UcxController::FromHandle(Controller);
    UcxRootHub* Context;
    PVOID DeviceContext;
    WDFOBJECT Object;
    NTSTATUS Status;
 
    PAGED_CODE();
 
    *RootHub = NULL;
 
    WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&UcxAttributes, UcxRootHub);
    UcxAttributes.EvtCleanupCallback = UcxRootHub::EvtCleanup;
 
    if (Attributes != NULL)
        Attributes->ParentObject = Controller;
    else
        UcxAttributes.ParentObject = Controller;
 
    Status = UcxCreateObjectWithTwoContexts(Attributes != NULL ? Attributes : &UcxAttributes,
                                            Attributes != NULL ? &UcxAttributes : NULL,
                                            &Object);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Root hub object create failed 0x%lx\n", Status);
        return Status;
    }
 
    Context = new (UcxGetRootHubContext(Object)) UcxRootHub();
    Context->m_Handle = (UCXROOTHUB)Object;
 
    /* The same handle doubles as the root hub's UCXUSBDEVICE */
    WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&DeviceAttributes, UcxUsbDevice);
    Status = WdfObjectAllocateContext(Object, &DeviceAttributes, &DeviceContext);
    if (NT_SUCCESS(Status))
    {
        Context->m_Device = new (DeviceContext) UcxUsbDevice();
        Status = Context->Initialize(ControllerContext, Config);
    }
    else
    {
        DPRINT1("Root hub device context allocation failed 0x%lx\n", Status);
    }
 
    if (!NT_SUCCESS(Status))
    {
        WdfObjectDelete(Object);
        return Status;
    }
 
    {
        SpinLockGuard Guard(&ControllerContext->m_TopologyLock);
 
        ControllerContext->m_RootHub = Context;
        ControllerContext->m_ChildDeviceCount = 1;
    }
 
    *RootHub = Context->m_Handle;
    DPRINT("Root hub %p created for controller %p\n", Context, ControllerContext);
    return STATUS_SUCCESS;
}

Referenced by Create().

CreateEndpoint()

NTSTATUS UcxRootHub::CreateEndpoint ( _In_ BOOLEAN  Interrupt )

private

One of the two endpoints the hub talks to; their queues live on the controller FDO.

Definition at line 121 of file rhub.cpp.

{
    WDF_IO_QUEUE_FORWARD_PROGRESS_POLICY Policy;
    WDF_OBJECT_ATTRIBUTES QueueAttributes;
    WDF_IO_QUEUE_CONFIG QueueConfig;
    UcxEndpointInit Init;
    PUCXENDPOINT_INIT InitPointer = &Init;
    UCXENDPOINT EndpointHandle;
    WDFQUEUE Queue;
    NTSTATUS Status;
 
    if (Interrupt)
    {
        WDF_IO_QUEUE_CONFIG_INIT(&QueueConfig, WdfIoQueueDispatchSequential);
        QueueConfig.EvtIoInternalDeviceControl = UcxEvtRootHubInterruptTransfer;
        WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&QueueAttributes, UcxInterruptQueueState);
    }
    else
    {
        WDF_IO_QUEUE_CONFIG_INIT(&QueueConfig, WdfIoQueueDispatchParallel);
        QueueConfig.Settings.Parallel.NumberOfPresentedRequests =
            m_Config.NumberOfPresentedControlUrbCallbacks;
        QueueConfig.EvtIoInternalDeviceControl = UcxEvtRootHubControlTransfer;
        WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&QueueAttributes, UcxControlQueueContext);
    }
    QueueAttributes.ParentObject = m_Handle;
 
    Status = WdfIoQueueCreate(m_Controller->m_Fdo, &QueueConfig, &QueueAttributes, &Queue);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Root hub %s queue create failed 0x%lx\n", Interrupt ? "interrupt" : "control", Status);
        return Status;
    }
 
    WDF_IO_QUEUE_FORWARD_PROGRESS_POLICY_DEFAULT_INIT(&Policy, 1);
    Status = WdfIoQueueAssignForwardProgressPolicy(Queue, &Policy);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Root hub %s queue forward progress setup failed 0x%lx\n", Interrupt ? "interrupt" : "control", Status);
        return Status;
    }
 
    RtlZeroMemory(&Init, sizeof(Init));
    Init.Kind = Interrupt ? UcxEndpointKind::Generic : UcxEndpointKind::Default;
    Init.TransferType = Interrupt ? UcxTransferType::Interrupt : UcxTransferType::Control;
    Init.Device = (UCXUSBDEVICE)m_Handle;
    Init.CreateMachine = FALSE;
 
    Status = UcxEndpoint::Create((UCXUSBDEVICE)m_Handle, &InitPointer, NULL, &EndpointHandle);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Root hub %s endpoint create failed 0x%lx\n", Interrupt ? "interrupt" : "control", Status);
        return Status;
    }
 
    UcxEndpoint::FromHandle(EndpointHandle)->SetWdfIoQueue(Queue);
 
    if (Interrupt)
    {
        UcxInterruptQueueState* State = UcxGetInterruptQueueState(Queue);
 
        KeInitializeSpinLock(&State->PortChangeLock);
 
        /* Different start values, so the very first transfer always reaches the HCD */
        State->PortChangeGeneration = 1;
        State->PortChangeGenerationProcessed = 0;
        KeInitializeEvent(&State->NoIndicateWakeInProgress, NotificationEvent, TRUE);
        State->RootHub = this;
 
        m_InterruptQueue = Queue;
        m_InterruptState = State;
        m_InterruptEndpoint = UcxEndpoint::FromHandle(EndpointHandle);
        DPRINT("Root hub %p interrupt endpoint %p\n", this, m_InterruptEndpoint);
    }
    else
    {
        UcxGetControlQueueContext(Queue)->RootHub = this;
 
        m_ControlQueue = Queue;
        m_ControlEndpoint = UcxEndpoint::FromHandle(EndpointHandle);
        DPRINT("Root hub %p control endpoint %p\n", this, m_ControlEndpoint);
    }
 
    return STATUS_SUCCESS;
}

Referenced by CreateEndpoint(), and Initialize().

CreatePdo()

NTSTATUS UcxRootHub::CreatePdo ( )

private

Definition at line 129 of file rhubpdo.cpp.

{
    static const UNICODE_STRING InstanceId = RTL_CONSTANT_STRING(L"0\0");
    static const UNICODE_STRING DeviceId = RTL_CONSTANT_STRING(UCX_ROOT_HUB_ID L"\0");
    static UCHAR PnpMinor = IRP_MN_QUERY_INTERFACE;
    static UCHAR PowerMinor = IRP_MN_SET_POWER;
    WDF_PNPPOWER_EVENT_CALLBACKS PnpPower;
    WDF_PDO_EVENT_CALLBACKS PdoCallbacks;
    WDF_OBJECT_ATTRIBUTES Attributes;
    WDF_IO_QUEUE_CONFIG QueueConfig;
    PNP_BUS_INFORMATION BusInfo;
    WCHAR IdBuffer[UCX_HWID_BUFFER_CHARS];
    WCHAR NameBuffer[64];
    UNICODE_STRING HardwareIds;
    UNICODE_STRING Name;
    PWDFDEVICE_INIT Init;
    UcxRootHubPdoContext* PdoContext;
    WDFDEVICE Pdo = NULL;
    WDFDEVICE Fdo = m_Controller->m_Fdo;
    ULONG Index;
    NTSTATUS Status;
 
    BusInfo.BusTypeGuid = GUID_BUS_TYPE_USB;
    BusInfo.LegacyBusType = PNPBus;
    BusInfo.BusNumber = 0;
    WdfDeviceSetBusInformationForChildren(Fdo, &BusInfo);
 
    Init = WdfPdoInitAllocate(Fdo);
    if (Init == NULL)
    {
        DPRINT1("Root hub PDO init allocation failed\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    Status = WdfPdoInitAssignInstanceID(Init, &InstanceId);
    if (NT_SUCCESS(Status))
        Status = WdfPdoInitAssignDeviceID(Init, &DeviceId);
    if (NT_SUCCESS(Status))
    {
        UcxBuildRootHubHardwareIds(&m_Controller->m_Config, IdBuffer, ARRAYSIZE(IdBuffer), &HardwareIds);
        Status = WdfPdoInitAddHardwareID(Init, &HardwareIds);
    }
 
    if (NT_SUCCESS(Status))
    {
        /* The root hub's queues live on the controller FDO */
        WdfPdoInitAllowForwardingRequestToParent(Init);
 
        Status = WdfDeviceInitAssignWdmIrpPreprocessCallback(Init,
                                                             UcxEvtRootHubPreprocessInternalIoctl,
                                                             IRP_MJ_INTERNAL_DEVICE_CONTROL,
                                                             NULL,
                                                             0);
    }
    if (NT_SUCCESS(Status))
    {
        Status = WdfDeviceInitAssignWdmIrpPreprocessCallback(Init,
                                                             UcxEvtRootHubPreprocessQueryInterface,
                                                             IRP_MJ_PNP,
                                                             &PnpMinor,
                                                             1);
    }
    if (NT_SUCCESS(Status))
    {
        Status = WdfDeviceInitAssignWdmIrpPreprocessCallback(Init,
                                                             UcxEvtRootHubPreprocessSetPower,
                                                             IRP_MJ_POWER,
                                                             &PowerMinor,
                                                             1);
    }
 
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Root hub PDO ID or preprocess setup failed 0x%lx\n", Status);
        WdfDeviceInitFree(Init);
        return Status;
    }
 
    /* Every request reaching the HCD then carries the HCD's request context */
    WdfDeviceInitSetRequestAttributes(Init, &m_Config.WdfRequestAttributes);
 
    WDF_PNPPOWER_EVENT_CALLBACKS_INIT(&PnpPower);
    PnpPower.EvtDevicePrepareHardware = UcxEvtRootHubPrepareHardware;
    PnpPower.EvtDeviceReleaseHardware = UcxEvtRootHubReleaseHardware;
    PnpPower.EvtDeviceD0Entry = UcxEvtRootHubD0Entry;
    PnpPower.EvtDeviceD0Exit = UcxEvtRootHubD0Exit;
    WdfDeviceInitSetPnpPowerEventCallbacks(Init, &PnpPower);
 
    WDF_PDO_EVENT_CALLBACKS_INIT(&PdoCallbacks);
    PdoCallbacks.EvtDeviceEnableWakeAtBus = UcxEvtRootHubEnableWakeAtBus;
    PdoCallbacks.EvtDeviceDisableWakeAtBus = UcxEvtRootHubDisableWakeAtBus;
    WdfPdoInitSetEventCallbacks(Init, &PdoCallbacks);
 
    WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&Attributes, UcxRootHubPdoContext);
 
    /* USBPDO-n is shared with the PDOs the hub creates; take the first free one */
    for (Index = 0;; Index++)
    {
        Status = RtlStringCchPrintfW(NameBuffer, ARRAYSIZE(NameBuffer), L"\\Device\\USBPDO-%d", Index);
        if (!NT_SUCCESS(Status))
            break;
 
        RtlInitUnicodeString(&Name, NameBuffer);
        Status = WdfDeviceInitAssignName(Init, &Name);
        if (!NT_SUCCESS(Status))
            break;
 
        Status = WdfDeviceInitAssignSDDLString(Init, &UcxRootHubPdoSddl);
        if (!NT_SUCCESS(Status))
            break;
 
        Status = WdfDeviceCreate(&Init, &Attributes, &Pdo);
        if (Status != STATUS_OBJECT_NAME_COLLISION)
            break;
    }
 
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Root hub PDO create failed at USBPDO-%lu 0x%lx\n", Index, Status);
        if (Init != NULL)
            WdfDeviceInitFree(Init);
        return Status;
    }
 
    DPRINT("Root hub PDO %p is %wZ\n", Pdo, &Name);
 
    /* User mode IOCTLs on the root hub PDO are not served */
    WDF_IO_QUEUE_CONFIG_INIT_DEFAULT_QUEUE(&QueueConfig, WdfIoQueueDispatchParallel);
    QueueConfig.EvtIoDeviceControl = UcxEvtRootHubPdoIoDeviceControl;
    Status = WdfIoQueueCreate(Pdo, &QueueConfig, WDF_NO_OBJECT_ATTRIBUTES, WDF_NO_HANDLE);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Root hub PDO %p queue create failed 0x%lx\n", Pdo, Status);
        WdfObjectDelete(Pdo);
        return Status;
    }
 
    WdfDeviceSetSpecialFileSupport(Pdo, WdfSpecialFilePaging, TRUE);
    WdfDeviceSetSpecialFileSupport(Pdo, WdfSpecialFileHibernation, TRUE);
    WdfDeviceSetSpecialFileSupport(Pdo, WdfSpecialFileDump, TRUE);
    WdfDeviceSetSpecialFileSupport(Pdo, WdfSpecialFileBoot, TRUE);
 
    WDF_DEVICE_PNP_CAPABILITIES_INIT(&m_PnpCaps);
    m_PnpCaps.Removable = WdfFalse;
    m_PnpCaps.Address = 0;
    m_PnpCaps.UniqueID = WdfFalse;
    WdfDeviceSetPnpCapabilities(Pdo, &m_PnpCaps);
 
    BuildPowerCapabilities();
    WdfDeviceSetPowerCapabilities(Pdo, &m_PowerCaps);
 
    PdoContext = UcxGetRootHubPdoContext(Pdo);
    PdoContext->RootHub = this;
    PdoContext->Controller = m_Controller;
    m_SystemPowerAction = PowerActionNone;
 
    Status = WdfDeviceCreateDeviceInterface(Pdo, &GUID_DEVINTERFACE_USB_HUB, NULL);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Root hub PDO %p hub interface create failed 0x%lx\n", Pdo, Status);
        WdfObjectDelete(Pdo);
        return Status;
    }
 
    {
        SpinLockGuard Guard(&m_PdoInfoLock);
 
        m_Pdo = Pdo;
    }
 
    Status = WdfFdoAddStaticChild(Fdo, Pdo);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Root hub PDO %p static child add failed 0x%lx\n", Pdo, Status);
        m_Pdo = NULL;
        WdfObjectDelete(Pdo);
        return Status;
    }
 
    /* From here the PDO belongs to the FDO and is not deleted on failure */
    return AddQueryInterfaces();
}

Referenced by CreatePdo(), and Initialize().

Device()

UcxUsbDevice * UcxRootHub::Device ( ) const

inline

Definition at line 71 of file rhub.h.

    {
        return m_Device;
    }

Referenced by UcxController::SetFailed(), and UcxController::WalkDevices().

DispatchGetInfo()

VOID UcxRootHub::DispatchGetInfo	(	_In_ WDFREQUEST	Request,
		_Inout_ PUCXHUB_ROOTHUB_INFO	Info
	)

Definition at line 526 of file rhub.cpp.

{
    /* The HCD only knows ROOTHUB_INFO; the completion routine restores the size */
    Info->Info.Size = sizeof(Info->Info);
    Info->InterruptPipe = m_InterruptEndpoint->m_Pipe.Handle();
 
    DPRINT("Root hub %p GetInfo request %p to HCD\n", this, Request);
    m_Config.EvtRootHubGetInfo(m_Handle, Request);
}

Referenced by DispatchGetInfo().

EnableForwardProgress()

NTSTATUS UcxRootHub::EnableForwardProgress ( )

inline

Definition at line 90 of file rhub.h.

    {
        return STATUS_SUCCESS;
    }

Referenced by _IRQL_requires_().

FailIo()

VOID UcxRootHub::FailIo

(

)

Definition at line 477 of file rhub.cpp.

{
    DPRINT("Root hub %p failing I/O for controller reset\n", this);
    WdfIoQueuePurge(m_InterruptQueue, NULL, NULL);
    WdfIoQueuePurge(m_ControlQueue, NULL, NULL);
}

Referenced by FailIo(), and ControllerResetMachine::FailRootHubIo().

FinishPortResetRequest()

VOID UcxRootHub::FinishPortResetRequest

(

_In_ BOOLEAN

Succeeded

)

Definition at line 500 of file rhub.cpp.

{
    PIRP Irp = m_PendingAsyncReset;
    PUCXHUB_RESET_FLAGS Flags;
 
    m_PendingAsyncReset = NULL;
 
    Flags = (PUCXHUB_RESET_FLAGS)IoGetCurrentIrpStackLocation(Irp)->Parameters.Others.Argument1;
    Flags->AsUlong = 0;
 
    if (InterlockedExchange(&m_Controller->m_DeviceContextsLost, 0) != 0)
        Flags->HostContextLost = 1;
 
    m_Controller->m_RootHubResetSeen = 0;
 
    if (!Succeeded)
        DPRINT1("Root hub %p async reset IRP %p failed\n", this, Irp);
 
    Irp->IoStatus.Status = Succeeded ? STATUS_SUCCESS : STATUS_NO_SUCH_DEVICE;
    Irp->IoStatus.Information = 0;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
}

Referenced by ControllerResetMachine::CompleteHubReset(), and FinishPortResetRequest().

FromHandle()

UcxRootHub * UcxRootHub::FromHandle ( _In_ UCXROOTHUB  Handle )

static

Definition at line 14 of file rhub.cpp.

{
    return UcxGetRootHubContext(Handle);
}

Referenced by FromHandle().

Initialize()

NTSTATUS UcxRootHub::Initialize ( _In_ UcxController *  Controller, _In_ PUCX_ROOTHUB_CONFIG  Config  )

private

Definition at line 92 of file rhub.cpp.

{
    NTSTATUS Status;
 
    m_Controller = Controller;
    KeInitializeSpinLock(&m_PdoInfoLock);
 
    /* The HCD's size is trusted only as far as the structure we know */
    RtlZeroMemory(&m_Config, sizeof(m_Config));
    RtlCopyMemory(&m_Config, Config, min(Config->Size, (ULONG)sizeof(m_Config)));
 
    /* Speed is set first so the endpoints get the SuperSpeed transfer limits */
    m_Device->InitializeAsRootHub(m_Handle, Controller);
 
    Status = CreateEndpoint(FALSE);
    if (!NT_SUCCESS(Status))
        return Status;
 
    Status = CreateEndpoint(TRUE);
    if (!NT_SUCCESS(Status))
        return Status;
 
    return CreatePdo();
}

Referenced by Initialize().

Pdo()

WDFDEVICE UcxRootHub::Pdo ( ) const

inline

Definition at line 108 of file rhub.h.

    {
        return m_Pdo;
    }

Referenced by UcxEndpoint::CloseStaticStreams(), CreatePdo(), and UcxEndpoint::OpenStaticStreams().

PortChanged()

VOID UcxRootHub::PortChanged

(

)

Port change from the HCD, or one the reset machine simulates.

Definition at line 227 of file rhub.cpp.

{
    UcxInterruptQueueState* State = m_InterruptState;
    WDFREQUEST Release = NULL;
    BOOLEAN IndicateWake;
 
    DPRINT("Root hub %p port change\n", this);
 
    {
        SpinLockGuard Guard(&State->PortChangeLock);
 
        State->PortChangeGeneration++;
 
        /* If the cancel routine already owns the held transfer, it completes it */
        if (State->HeldTransfer != NULL &&
            NT_SUCCESS(WdfRequestUnmarkCancelable(State->HeldTransfer)))
        {
            Release = State->HeldTransfer;
            State->HeldTransfer = NULL;
            State->PortChangeGenerationProcessed = State->PortChangeGeneration;
        }
 
        IndicateWake = State->IndicateWakeEnabled;
        if (IndicateWake)
            KeClearEvent(&State->NoIndicateWakeInProgress);
    }
 
    if (IndicateWake)
    {
        /* Raised so a D0 IRP the wake triggers never runs inline on this thread */
        {
            DispatchLevelGuard Raise;
 
            WdfDeviceIndicateWakeStatus(m_Pdo, STATUS_SUCCESS);
        }
        KeSetEvent(&State->NoIndicateWakeInProgress, IO_NO_INCREMENT, FALSE);
    }
 
    if (Release == NULL)
        return;
 
    if (!m_Controller->BlockReset())
    {
        DPRINT1("Root hub %p failing held status change transfer %p, controller resetting\n", this, Release);
        WdfRequestComplete(Release, STATUS_NO_SUCH_DEVICE);
        return;
    }
 
    m_Config.EvtRootHubInterruptTx(m_Handle, Release);
    m_Controller->UnblockReset();
}

Referenced by PortChanged(), ControllerResetMachine::SignalPortChange(), and UcxApiRootHubPortChanged().

ReferenceSymbolicName()

NTSTATUS UcxRootHub::ReferenceSymbolicName

(

_Out_ WDFSTRING *

Name

)

Hands out the root hub's interface name with a reference the caller drops.

Definition at line 540 of file rhub.cpp.

{
    SpinLockGuard Guard(&m_PdoInfoLock);
 
    if (!m_PdoStarted || m_SymbolicName == NULL)
    {
        *Name = NULL;
        return STATUS_UNSUCCESSFUL;
    }
 
    WdfObjectReferenceWithTag(m_SymbolicName, (PVOID)UCX_POOL_TAG);
    *Name = m_SymbolicName;
    return STATUS_SUCCESS;
}

Referenced by ReferenceSymbolicName().

ResumeIo()

VOID UcxRootHub::ResumeIo

(

)

Definition at line 485 of file rhub.cpp.

{
    {
        SpinLockGuard Guard(&m_InterruptState->PortChangeLock);
 
        /* The next status change transfer goes to the HCD even if flagged */
        m_InterruptState->PortChangeGeneration++;
    }
 
    DPRINT("Root hub %p resuming I/O\n", this);
    WdfIoQueueStart(m_InterruptQueue);
    WdfIoQueueStart(m_ControlQueue);
}

Referenced by ResumeIo(), and ControllerResetMachine::UnblockRootHubTraffic().

Friends And Related Function Documentation

UcxRootHubPdo

friend class UcxRootHubPdo

friend

Definition at line 167 of file rhub.h.

Member Data Documentation

EvtCleanup

VOID UcxRootHub::EvtCleanup

staticprivate

Definition at line 165 of file rhub.h.

Referenced by Create().

m_Config

UCX_ROOTHUB_CONFIG UcxRootHub::m_Config

Definition at line 116 of file rhub.h.

Referenced by CreateEndpoint(), CreatePdo(), DispatchGetInfo(), Initialize(), and PortChanged().

m_ControlEndpoint

UcxEndpoint* UcxRootHub::m_ControlEndpoint

Definition at line 121 of file rhub.h.

Referenced by CreateEndpoint().

m_Controller

UcxController* UcxRootHub::m_Controller

Definition at line 115 of file rhub.h.

Referenced by BuildPowerCapabilities(), CreateEndpoint(), CreatePdo(), FinishPortResetRequest(), Initialize(), PortChanged(), UcxParentResetDuringResume(), and UcxParentWasProgrammingLost().

m_ControlQueue

WDFQUEUE UcxRootHub::m_ControlQueue

Definition at line 123 of file rhub.h.

Referenced by CreateEndpoint(), FailIo(), and ResumeIo().

m_Device

UcxUsbDevice* UcxRootHub::m_Device

Definition at line 119 of file rhub.h.

Referenced by Device(), and Initialize().

m_Handle

UCXROOTHUB UcxRootHub::m_Handle

Definition at line 114 of file rhub.h.

Referenced by Create(), CreateEndpoint(), DispatchGetInfo(), Initialize(), and PortChanged().

m_InterruptEndpoint

UcxEndpoint* UcxRootHub::m_InterruptEndpoint

Definition at line 122 of file rhub.h.

Referenced by CreateEndpoint(), and DispatchGetInfo().

m_InterruptQueue

WDFQUEUE UcxRootHub::m_InterruptQueue

Definition at line 124 of file rhub.h.

Referenced by CreateEndpoint(), FailIo(), and ResumeIo().

m_InterruptState

UcxInterruptQueueState* UcxRootHub::m_InterruptState

Definition at line 125 of file rhub.h.

Referenced by CreateEndpoint(), PortChanged(), and ResumeIo().

m_LastSystemSleepState

SYSTEM_POWER_STATE UcxRootHub::m_LastSystemSleepState

Definition at line 142 of file rhub.h.

m_NumberOf20Ports

USHORT UcxRootHub::m_NumberOf20Ports

Definition at line 127 of file rhub.h.

m_NumberOf30Ports

USHORT UcxRootHub::m_NumberOf30Ports

Definition at line 128 of file rhub.h.

m_Pdo

WDFDEVICE UcxRootHub::m_Pdo

Definition at line 135 of file rhub.h.

Referenced by AddQueryInterfaces(), CreatePdo(), Pdo(), and PortChanged().

m_PdoInfoLock

KSPIN_LOCK UcxRootHub::m_PdoInfoLock

Definition at line 134 of file rhub.h.

Referenced by CreatePdo(), Initialize(), and ReferenceSymbolicName().

m_PdoStarted

BOOLEAN UcxRootHub::m_PdoStarted

Definition at line 136 of file rhub.h.

Referenced by ReferenceSymbolicName().

m_PendingAsyncReset

PIRP UcxRootHub::m_PendingAsyncReset

Definition at line 140 of file rhub.h.

Referenced by FinishPortResetRequest().

m_PnpCaps

WDF_DEVICE_PNP_CAPABILITIES UcxRootHub::m_PnpCaps

Definition at line 130 of file rhub.h.

Referenced by CreatePdo().

m_PowerCaps

WDF_DEVICE_POWER_CAPABILITIES UcxRootHub::m_PowerCaps

Definition at line 131 of file rhub.h.

Referenced by BuildPowerCapabilities(), and CreatePdo().

m_SymbolicName

WDFSTRING UcxRootHub::m_SymbolicName

Definition at line 137 of file rhub.h.

Referenced by ReferenceSymbolicName().

m_SystemPowerAction

POWER_ACTION UcxRootHub::m_SystemPowerAction

Definition at line 143 of file rhub.h.

Referenced by CreatePdo().

---

The documentation for this class was generated from the following files:

• drivers/usb/ucx01000/rhub.h
• drivers/usb/ucx01000/hubinterface.cpp
• drivers/usb/ucx01000/rhub.cpp
• drivers/usb/ucx01000/rhubpdo.cpp