hubsvc.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Enumerations
enum class	HubUxdEvent : ULONG { Disable = 1 , Disconnect = 2 }

Functions
	_IRQL_requires_ (PASSIVE_LEVEL) NTSTATUS NTAPI HubAllocateHubNumber(_Out_ PULONG HubNumber)
	Sends a synchronous IOCTL to the specified device object.
BOOLEAN NTAPI	HubUsb4NeedsHostPower (_In_ HubChild *Child)
VOID NTAPI	HubClearTtBuffer (_In_ UCXHUB_HUB_CONTEXT HubContext, _In_ UCXHUB_DEVICE_CONTEXT DeviceContext, _In_ UCXENDPOINT Endpoint, _In_ ULONG EndpointNumber, _In_ ULONG TtPortNumber)
VOID NTAPI	HubNoPingResponse (_In_ UCXHUB_HUB_CONTEXT HubContext, _In_ UCXHUB_DEVICE_CONTEXT DeviceContext)
BOOLEAN NTAPI	HubValidateHubConfiguration (_In_ HubFdo *Hub, _In_reads_bytes_(Length) PUSB_CONFIGURATION_DESCRIPTOR Descriptor, _In_ ULONG Length)
BOOLEAN NTAPI	HubCheckUsb2HubDescriptor (_In_ HubFdo *Hub, _In_reads_bytes_(Length) PUSB_HUB_DESCRIPTOR Descriptor, _In_ ULONG Length)
BOOLEAN NTAPI	HubCheckUsb3HubDescriptor (_In_ HubFdo *Hub, _In_reads_bytes_(Length) PUSB_30_HUB_DESCRIPTOR Descriptor, _In_ ULONG Length)
VOID NTAPI	HubLogConfigTotalLengthMismatch (_In_ HubFdo *Hub)
VOID NTAPI	HubWmiNotifyOverCurrent (_In_ HubFdo *Hub, _In_ ULONG PortNumber)
PVOID NTAPI	HubConnectorNodeForPort (_In_ HubPort *Port)
VOID NTAPI	HubLogDeviceValidationError (_In_ HubChild *Child, _In_ ULONG Code)
BOOLEAN NTAPI	HubIdLanguageSupported (_In_ HubChild *Child, _In_ USHORT Language)
NTSTATUS NTAPI	HubIdBuildHardwareIds (_In_ HubChild *Child, _In_opt_ PWDFDEVICE_INIT DeviceInit, _Out_opt_ PUSB_ID_STRING Ids)
NTSTATUS NTAPI	HubIdBuildCompatibleIds (_In_ HubChild *Child, _In_opt_ PWDFDEVICE_INIT DeviceInit, _Out_opt_ PUSB_ID_STRING Ids)
NTSTATUS NTAPI	HubIdListCopy (_Out_ PUSB_ID_STRING Destination, _In_ const USB_ID_STRING *Source)
VOID NTAPI	HubIdListFree (_Inout_ PUSB_ID_STRING Ids)
BOOLEAN NTAPI	HubIdGetContainerId (_In_ HubChild *Child, _Out_ GUID *ContainerId)
BOOLEAN NTAPI	HubIdGetSerialNumberText (_In_ HubChild *Child, _Outptr_result_bytebuffer_(*Length) PCWSTR *Text, _Out_ PULONG Length)
VOID NTAPI	HubIdFreeDeviceIds (_In_ HubChild *Child)
HubPort *NTAPI	HubConnectorFindCompanion (_In_ HubPort *Port, _In_ ULONG Index)
	_IRQL_requires_max_ (DISPATCH_LEVEL) VOID NTAPI HubNoteHubOverCurrent(_In_ HubFdo *Hub)
_In_ PCUNICODE_STRING _In_ ULONG _In_ ULONG	_In_reads_bytes_ (Length) PVOID Data)
VOID NTAPI	HubReleaseRegistryState (_In_ HubChild *Child)
VOID NTAPI	HubChildForwardToController (_In_ HubChild *Child)
	_Out_writes_bytes_ (Length) PUSB_HUB_NAME Name
VOID NTAPI	HubFreeBillboardInfo (_In_ HubChild *Child)
VOID NTAPI	HubReleaseTransferState (_In_ HubChild *Child)
HubPipe *NTAPI	HubFindPipeByHandle (_In_opt_ HubConfiguration *Config, _In_ USBD_PIPE_HANDLE Handle)
VOID NTAPI	HubMakeUsb2StyleDescriptor (_In_ HubFdo *Hub, _Out_ PUSB_HUB_DESCRIPTOR Descriptor)

Variables
_In_ HubPort *	Port
_In_ HubPort _In_ WDFSTRING	Name
_In_ ULONG	MessageId
EVT_WDF_TIMER	HubEvtBandwidthRetryTimer
_In_ PWDFDEVICE_INIT	DeviceInit
_Inout_ PIRP	Irp
_In_ PCUNICODE_STRING _In_ ULONG	Type
_In_ PCUNICODE_STRING _In_ ULONG _In_ ULONG	Length
_In_ PCUNICODE_STRING _In_ WDFSTRING	Value
_In_ HubChild *	Child
_In_ HubChild _Out_opt_ PBOOLEAN	UpdateRequired
_In_ HubUxdEvent	Event
_In_ WDFSTRING	String
_In_ PDEVICE_OBJECT	Pdo
_Out_ PUSB_BUS_NOTIFICATION	Notification
_In_ ULONG	PortNumber

Enumeration Type Documentation

HubUxdEvent

enum class HubUxdEvent : ULONG

strong

Enumerator
Disable
Disconnect

Definition at line 327 of file hubsvc.h.

{
    Disable = 1,
    Disconnect = 2
};

Function Documentation

_In_reads_bytes_()

_In_ PCUNICODE_STRING _In_ ULONG _In_ ULONG _In_reads_bytes_

(

Length

)

Definition at line 1072 of file hubregistry.cpp.

{
    WDFKEY Key;
    NTSTATUS Status;
 
    Status = HubOpenDeviceKey(Child, KEY_WRITE, &Key);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Device %p value %wZ: hardware key not opened 0x%lx\n", Child, Name, Status);
        return Status;
    }
 
    Status = WdfRegistryAssignValue(Key, Name, Type, Length, Data);
    if (!NT_SUCCESS(Status))
        DPRINT1("Device %p value %wZ not written 0x%lx\n", Child, Name, Status);
 
    WdfRegistryClose(Key);
    return Status;
}

_IRQL_requires_()

_IRQL_requires_

(

PASSIVE_LEVEL

)

Sends a synchronous IOCTL to the specified device object.

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.

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;
}

_IRQL_requires_max_()

_IRQL_requires_max_

(

DISPATCH_LEVEL

)

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.

Definition at line 77 of file common.c.

{
    NTSTATUS                    status;
    BOOLEAN                     requestSent = FALSE;
 
    BOOLEAN                     shouldRetry = TRUE;
    PCDB                        cdb = (PCDB)DeviceExtension->PowerContext.Srb.Cdb;
    ULONG                       timeoutValue = DeviceExtension->TimeOutValue;
    ULONG                       retryCount = 1;
 
    // reset some fields.
    DeviceExtension->PowerContext.RetryIntervalIn100ns = 0;
    status = PowerContextReuseRequest(DeviceExtension);
    RequestClearSendTime(DeviceExtension->PowerContext.PowerRequest);
 
    if (!NT_SUCCESS(status))
    {
        return status;
    }
 
    // set proper timeout value and max retry count.
    switch(DeviceExtension->PowerContext.PowerChangeState.PowerDown)
    {
    case PowerDownDeviceInitial:
    case PowerDownDeviceQuiesced:
    case PowerDownDeviceStopped:
        break;
 
    case PowerDownDeviceLocked:
        // Case of issuing SYNC CACHE command. Do not use power irp timeout remaining time in this case
        // as we want to give best try on SYNC CACHE command.
        retryCount = MAXIMUM_RETRIES;
        timeoutValue = DeviceExtension->TimeOutValue;
        break;
 
    case PowerDownDeviceFlushed:
    {
        // Case of issuing STOP UNIT command
        // As "Imme" bit is set to '1', this command should be completed in short time.
        // This command is at low importance, failure of this command has very small impact.
        ULONG secondsRemaining = 0;
 
#if (WINVER >= 0x0601)
        // this API is introduced in Windows7
        PoQueryWatchdogTime(DeviceExtension->LowerPdo, &secondsRemaining);
#endif
 
        if (secondsRemaining == 0)
        {
            // not able to retrieve remaining time from PoQueryWatchdogTime API, use default values.
            retryCount = MAXIMUM_RETRIES;
            timeoutValue = SCSI_CDROM_TIMEOUT;
        }
        else
        {
            // plan to leave about 30 seconds to lower level drivers if possible.
            if (secondsRemaining >= 32)
            {
                retryCount = (secondsRemaining - 30)/SCSI_CDROM_TIMEOUT + 1;
                timeoutValue = SCSI_CDROM_TIMEOUT;
 
                if (retryCount > MAXIMUM_RETRIES)
                {
                    retryCount = MAXIMUM_RETRIES;
                }
 
                if (retryCount == 1)
                {
                    timeoutValue = secondsRemaining - 30;
                }
            }
            else
            {
                // issue the command with minimal timeout value and do not retry on it.
                retryCount = 1;
                timeoutValue = 2;
            }
        }
    }
        break;
    default:
        NT_ASSERT( FALSE );
        status = STATUS_NOT_IMPLEMENTED;
        return status;
    }
 
    DeviceExtension->PowerContext.RetryCount = retryCount;
 
    // issue command.
    while (shouldRetry)
    {
 
        // set SRB fields.
        DeviceExtension->PowerContext.Srb.SrbFlags = SRB_FLAGS_NO_DATA_TRANSFER |
                                                     SRB_FLAGS_DISABLE_SYNCH_TRANSFER |
                                                     SRB_FLAGS_NO_QUEUE_FREEZE |
                                                     SRB_FLAGS_BYPASS_LOCKED_QUEUE |
                                                     SRB_FLAGS_D3_PROCESSING;
 
        DeviceExtension->PowerContext.Srb.Function = SRB_FUNCTION_EXECUTE_SCSI;
        DeviceExtension->PowerContext.Srb.TimeOutValue = timeoutValue;
 
        if (DeviceExtension->PowerContext.PowerChangeState.PowerDown == PowerDownDeviceInitial)
        {
            DeviceExtension->PowerContext.Srb.Function = SRB_FUNCTION_LOCK_QUEUE;
        }
        else if (DeviceExtension->PowerContext.PowerChangeState.PowerDown == PowerDownDeviceLocked)
        {
            DeviceExtension->PowerContext.Srb.Function = SRB_FUNCTION_QUIESCE_DEVICE;
        }
        else if (DeviceExtension->PowerContext.PowerChangeState.PowerDown == PowerDownDeviceQuiesced)
        {
            // Case of issuing SYNC CACHE command.
            DeviceExtension->PowerContext.Srb.CdbLength = 10;
            cdb->SYNCHRONIZE_CACHE10.OperationCode = SCSIOP_SYNCHRONIZE_CACHE;
        }
        else if (DeviceExtension->PowerContext.PowerChangeState.PowerDown == PowerDownDeviceFlushed)
        {
            // Case of issuing STOP UNIT command.
            DeviceExtension->PowerContext.Srb.CdbLength = 6;
            cdb->START_STOP.OperationCode = SCSIOP_START_STOP_UNIT;
            cdb->START_STOP.Start = 0;
            cdb->START_STOP.Immediate = 1;
        }
        else if (DeviceExtension->PowerContext.PowerChangeState.PowerDown == PowerDownDeviceStopped)
        {
            DeviceExtension->PowerContext.Srb.Function = SRB_FUNCTION_UNLOCK_QUEUE;
        }
 
        // Set up completion routine and context if requested
        if (CompletionRoutine)
        {
            WdfRequestSetCompletionRoutine(DeviceExtension->PowerContext.PowerRequest,
                                           CompletionRoutine,
                                           Context);
        }
 
        status = RequestSend(DeviceExtension,
                             DeviceExtension->PowerContext.PowerRequest,
                             DeviceExtension->IoTarget,
                             CompletionRoutine ? 0 : WDF_REQUEST_SEND_OPTION_SYNCHRONOUS,
                             &requestSent);
 
        if (requestSent)
        {
            if ((CompletionRoutine == NULL) &&
                (SRB_STATUS(DeviceExtension->PowerContext.Srb.SrbStatus) != SRB_STATUS_SUCCESS))
            {
                TracePrint((TRACE_LEVEL_ERROR,
                            TRACE_FLAG_POWER,
                            "%p\tError occured when issuing %s command to device. Srb %p, Status %x\n",
                            DeviceExtension->PowerContext.PowerRequest,
                            (DeviceExtension->PowerContext.PowerChangeState.PowerDown == PowerDownDeviceQuiesced) ? "SYNC CACHE" : "STOP UNIT",
                            &DeviceExtension->PowerContext.Srb,
                            DeviceExtension->PowerContext.Srb.SrbStatus));
 
                NT_ASSERT(!(TEST_FLAG(DeviceExtension->PowerContext.Srb.SrbStatus, SRB_STATUS_QUEUE_FROZEN)));
 
                shouldRetry = RequestSenseInfoInterpret(DeviceExtension,
                                                        DeviceExtension->PowerContext.PowerRequest,
                                                        &(DeviceExtension->PowerContext.Srb),
                                                        retryCount - DeviceExtension->PowerContext.RetryCount,
                                                        &status,
                                                        &(DeviceExtension->PowerContext.RetryIntervalIn100ns));
 
                if (shouldRetry && (DeviceExtension->PowerContext.RetryCount-- == 0))
                {
                    shouldRetry = FALSE;
                }
            }
            else
            {
                // succeeded, do not need to retry.
                shouldRetry = FALSE;
            }
 
        }
        else
        {
            // request failed to be sent
            shouldRetry = FALSE;
        }
 
        if (shouldRetry)
        {
            LARGE_INTEGER t;
            t.QuadPart = -DeviceExtension->PowerContext.RetryIntervalIn100ns;
            KeDelayExecutionThread(KernelMode, FALSE, &t);
 
            status = PowerContextReuseRequest(DeviceExtension);
            if (!NT_SUCCESS(status))
            {
                shouldRetry = FALSE;
            }
        }
    }
 
    if (DeviceExtension->PowerContext.PowerChangeState.PowerDown == PowerDownDeviceQuiesced)
    {
        // record SYNC CACHE command completion time stamp.
        KeQueryTickCount(&DeviceExtension->PowerContext.Step1CompleteTime);
    }
 
    return status;
}

_Out_writes_bytes_()

_Out_writes_bytes_

(

Length

)

HubCheckUsb2HubDescriptor()

BOOLEAN NTAPI HubCheckUsb2HubDescriptor	(	_In_ HubFdo *	Hub,
		_In_reads_bytes_(Length) PUSB_HUB_DESCRIPTOR	Descriptor,
		_In_ ULONG	Length
	)

Definition at line 59 of file hubdescval.cpp.

{
    HubDescContext Context;
 
    HubBuildDescContext(Hub, &Context);
    return HubDescCheck20Hub(&Context, Descriptor, Length);
}

Referenced by HubMachine::ParseHubDescriptor().

HubCheckUsb3HubDescriptor()

BOOLEAN NTAPI HubCheckUsb3HubDescriptor	(	_In_ HubFdo *	Hub,
		_In_reads_bytes_(Length) PUSB_30_HUB_DESCRIPTOR	Descriptor,
		_In_ ULONG	Length
	)

Definition at line 72 of file hubdescval.cpp.

{
    HubDescContext Context;
 
    HubBuildDescContext(Hub, &Context);
    return HubDescCheck30Hub(&Context, Descriptor, Length);
}

Referenced by HubMachine::ParseHubDescriptor().

HubChildForwardToController()

VOID NTAPI HubChildForwardToController

(

_In_ HubChild *

Child

)

Sends the device's current client request to UCX as is; completes it, then posts ControllerRequestDone.

Definition at line 1352 of file devhcd.cpp.

{
    WDFREQUEST Request = Child->m_ClientRequest;
 
    WdfRequestFormatRequestUsingCurrentType(Request);
    WdfRequestSetCompletionRoutine(Request, HubChildClientRequestComplete, Child);
 
    if (!WdfRequestSend(Request, Child->m_Hub->m_RootHubTarget, WDF_NO_SEND_OPTIONS))
    {
        DPRINT1("Device %p client request not sent 0x%lx\n", Child, WdfRequestGetStatus(Request));
        WdfRequestComplete(Request, WdfRequestGetStatus(Request));
        Child->Post(DsmEvent::ControllerRequestDone);
    }
}

Referenced by DeviceMachine::ForwardToController().

HubClearTtBuffer()

VOID NTAPI HubClearTtBuffer	(	_In_ UCXHUB_HUB_CONTEXT	HubContext,
		_In_ UCXHUB_DEVICE_CONTEXT	DeviceContext,
		_In_ UCXENDPOINT	Endpoint,
		_In_ ULONG	EndpointNumber,
		_In_ ULONG	TtPortNumber
	)

Definition at line 220 of file hubreq.cpp.

{
    HubFdo* Hub = HubFdo::FromContext(HubContext);
    HubChild* Child = (HubChild*)DeviceContext;
    HubTtClear* Clear = NULL;
    WDFREQUEST Request = NULL;
    BOOLEAN ResetTt = Hub->HasFlag(HubFlag::ResetTtOnCancel);
    USHORT Value;
    NTSTATUS Status;
 
    if (!Hub->HasFlag(HubFlag::TtHub) || Child == NULL || Hub->HasFlag(HubFlag::NoClearTtOnCancel))
        goto Done;
 
    /* Computed even for RESET_TT, which does not use it */
    WdfObjectReferenceWithTag(Child->m_Object, (PVOID)HubTagClearTt);
    Status = HubTtClearValue(Child, Endpoint, EndpointNumber, &Value);
    WdfObjectDereferenceWithTag(Child->m_Object, (PVOID)HubTagClearTt);
    if (!NT_SUCCESS(Status))
        goto Done;
 
    Clear = (HubTtClear*)ExAllocatePoolZero(NonPagedPool, sizeof(*Clear), HUB_TAG_HUB);
    if (Clear == NULL)
    {
        DPRINT1("Hub %p no memory for a TT clear\n", Hub);
        goto Done;
    }
 
    Clear->Hub = Hub;
    Clear->Endpoint = Endpoint;
 
    if (!NT_SUCCESS(Clear->Control.Create(Hub->m_Device, WdfDeviceGetIoTarget(Hub->m_Device))))
        goto Done;
    Request = Clear->Control.Request;
 
    Clear->Control.SetSetup(0x23,
                            ResetTt ? HUB_REQUEST_RESET_TT : HUB_REQUEST_CLEAR_TT_BUFFER,
                            ResetTt ? 0 : Value,
                            Hub->HasFlag(HubFlag::MultiTtHub) ? (USHORT)TtPortNumber : 1,
                            0);
 
    Status = Clear->Control.Send(Hub->m_RootHubTarget,
                                 Hub->UsbDevice(),
                                 HubTtClearComplete,
                                 Clear,
                                 NULL,
                                 0,
                                 FALSE,
                                 Hub->NeedsForwardProgress());
    if (NT_SUCCESS(Status))
        return;
 
Done:
    if (Request != NULL)
        WdfObjectDelete(Request);
    if (Clear != NULL)
        ExFreePoolWithTag(Clear, HUB_TAG_HUB);
 
    Hub->m_Stack.ClearTtBufferComplete(Hub->m_Stack.Hub, Endpoint);
}

HubConnectorFindCompanion()

HubPort *NTAPI HubConnectorFindCompanion	(	_In_ HubPort *	Port,
		_In_ ULONG	Index
	)

Companion port 0 or 1 sharing Port's connector, or NULL. Only valid under the map lock.

Definition at line 287 of file portconn.cpp.

{
    HubConnectorNode* Node;
 
    if (Index > 1)
    {
        DPRINT1("Companion index %lu out of range\n", Index);
        return NULL;
    }
 
    Node = HubConnectorFindByPort(Port);
    if (Node == NULL)
    {
        if (Port->HasProperty(PortProperty::InConnectorMap))
            DPRINT1("Port %u: registered port has no connector\n", Port->Number());
 
        return NULL;
    }
 
    if (!Port->IsUsb30())
        return (Index == 0) ? Node->Usb30 : Node->Usb30Second;
 
    if (Index == 0)
        return Node->Usb20;
 
    return (Node->Usb30 == Port) ? Node->Usb30Second : Node->Usb30;
}

Referenced by HubIoGetConnectorProperties().

HubConnectorNodeForPort()

PVOID NTAPI HubConnectorNodeForPort

(

_In_ HubPort *

Port

)

Connector map node of a port, or NULL when the port is not mapped.

Definition at line 320 of file portconn.cpp.

{
    HubConnectorNode* Node;
 
    if (!Port->HasProperty(PortProperty::InConnectorMap))
        return NULL;
 
    HubConnectorLock();
    Node = HubConnectorFindByPort(Port);
    HubConnectorUnlock();
 
    return Node;
}

Referenced by DeviceMachine::AddChildToHub().

HubFindPipeByHandle()

HubPipe *NTAPI HubFindPipeByHandle	(	_In_opt_ HubConfiguration *	Config,
		_In_ USBD_PIPE_HANDLE	Handle
	)

Pipe of Config whose USBD pipe handle is Handle, or NULL. The caller protects Config.

Definition at line 858 of file devreq.cpp.

{
    HubInterface* Interface;
    PLIST_ENTRY Entry;
    ULONG Index;
 
    if (Config == NULL)
        return NULL;
 
    for (Entry = Config->Interfaces.Flink; Entry != &Config->Interfaces; Entry = Entry->Flink)
    {
        Interface = CONTAINING_RECORD(Entry, HubInterface, Link);
 
        for (Index = 0; Index < Interface->PipeCount; Index++)
        {
            if (Interface->Pipes[Index].PipeHandle == Handle)
                return &Interface->Pipes[Index];
        }
    }
 
    return NULL;
}

Referenced by DeviceMachine::FindClientPipe().

HubFreeBillboardInfo()

VOID NTAPI HubFreeBillboardInfo

(

_In_ HubChild *

Child

)

Frees the billboard record and its descriptor copy, if any.

Definition at line 348 of file devdesc.cpp.

{
    HubBillboardInfo* Billboard = Child->m_Billboard;
 
    if (Billboard == NULL)
        return;
 
    if (Billboard->Descriptor != NULL)
        ExFreePoolWithTag(Billboard->Descriptor, HUB_TAG_HUB);
 
    ExFreePoolWithTag(Billboard, HUB_TAG_HUB);
    Child->m_Billboard = NULL;
}

Referenced by HubKeepBillboardData(), HubReleaseTransferState(), and DeviceMachine::ReadBosHeader().

HubIdBuildCompatibleIds()

NTSTATUS NTAPI HubIdBuildCompatibleIds	(	_In_ HubChild *	Child,
		_In_opt_ PWDFDEVICE_INIT	DeviceInit,
		_Out_opt_ PUSB_ID_STRING	Ids
	)

Compatible ids into a PDO init and/or a multi-sz list, which is zeroed first.

Definition at line 597 of file hubid.cpp.

{
    HubIdSink Sink = { HubIdKind::Compatible, DeviceInit, Ids };
    HubIdText Text;
 
    if (Ids != NULL)
        RtlZeroMemory(Ids, sizeof(*Ids));
 
    if (HubIdUsesFailureId(Child))
    {
        const HubFailureId* Failure = HubFailureIdFor(Child);
        return HubIdEmitCounted(&Sink, Failure->Id, Failure->IdBytes);
    }
 
    if (Child->HasProperty(ChildProperty::IsComposite))
        return HubIdBuildCompositeIds(Child, &Sink);
 
    if (Child->HasProperty(ChildProperty::IsHub))
    {
        switch (Child->Speed())
        {
            case UsbHighSpeed:
            case UsbFullSpeed:
                Text.Set(L"USB\\USB20_HUB");
                return HubIdEmitText(&Sink, &Text);
 
            case UsbSuperSpeed:
                Text.Set(L"USB\\USB30_HUB");
                return HubIdEmitText(&Sink, &Text);
 
            default:
                return STATUS_SUCCESS;
        }
    }
 
    if (Child->HasProperty(ChildProperty::HasBillboard))
        return HubIdEmitCounted(&Sink, HubBillboardId, sizeof(HubBillboardId));
 
    return HubIdBuildClassIds(Child, &Sink);
}

HubIdBuildHardwareIds()

NTSTATUS NTAPI HubIdBuildHardwareIds	(	_In_ HubChild *	Child,
		_In_opt_ PWDFDEVICE_INIT	DeviceInit,
		_Out_opt_ PUSB_ID_STRING	Ids
	)

Hardware ids into a PDO init and/or a multi-sz list, which is zeroed first.

Definition at line 381 of file hubid.cpp.

{
    HubIdSink Sink = { HubIdKind::Hardware, DeviceInit, Ids };
    const USB_DEVICE_DESCRIPTOR* Descriptor = &Child->m_DeviceDescriptor;
    HubIdText Text;
    WCHAR Revision[5];
    NTSTATUS Status;
 
    if (Ids != NULL)
        RtlZeroMemory(Ids, sizeof(*Ids));
 
    if (HubIdUsesFailureId(Child))
    {
        const HubFailureId* Failure = HubFailureIdFor(Child);
        return HubIdEmitCounted(&Sink, Failure->Id, Failure->IdBytes);
    }
 
    if (DeviceInit != NULL && HubIdIsVmReserved(Child))
        return HubIdEmit(&Sink, &Child->m_VmReservedId);
 
    HubIdRevisionText(Descriptor->bcdUSB, Descriptor->bcdDevice, Revision);
 
    Text.Format(L"USB\\VID_%04X&PID_%04X&REV_", Descriptor->idVendor, Descriptor->idProduct);
    Text.Append(Revision);
    Status = HubIdEmitText(&Sink, &Text);
    if (!NT_SUCCESS(Status))
        return Status;
 
    Text.Format(L"USB\\VID_%04X&PID_%04X", Descriptor->idVendor, Descriptor->idProduct);
    return HubIdEmitText(&Sink, &Text);
}

HubIdFreeDeviceIds()

VOID NTAPI HubIdFreeDeviceIds

(

_In_ HubChild *

Child

)

Frees the identity buffers of a device; called when the device object is destroyed.

Definition at line 813 of file hubid.cpp.

{
    if (Child->m_VmReservedId.Buffer != NULL)
        ExFreePoolWithTag(Child->m_VmReservedId.Buffer, HUB_TAG_DEVICE);
 
    RtlZeroMemory(&Child->m_VmReservedId, sizeof(Child->m_VmReservedId));
}

HubIdGetContainerId()

BOOLEAN NTAPI HubIdGetContainerId	(	_In_ HubChild *	Child,
		_Out_ GUID *	ContainerId
	)

Container id the PDO got; FALSE when it got none.

Definition at line 749 of file hubid.cpp.

{
    RtlZeroMemory(ContainerId, sizeof(*ContainerId));
 
    if (Child->HasProperty(ChildProperty::NotRemovable) || !HubIdHasContainerId(Child))
        return FALSE;
 
    *ContainerId = Child->m_ContainerId;
    return TRUE;
}

HubIdGetSerialNumberText()

BOOLEAN NTAPI HubIdGetSerialNumberText	(	_In_ HubChild *	Child,
		_Outptr_result_bytebuffer_ *Length PCWSTR *	Text,
		_Out_ PULONG	Length
	)

Cached serial number text without its decoration, for the serial string IOCTL.

Definition at line 1111 of file hubid.cpp.

{
    *Text = NULL;
    *Length = 0;
 
    if (Child->m_SerialNumber == NULL ||
        Child->m_SerialNumberLength < Child->m_SerialPrefixLength + sizeof(WCHAR))
    {
        return FALSE;
    }
 
    *Text = Child->m_SerialNumber + Child->m_SerialPrefixLength / sizeof(WCHAR);
    *Length = Child->m_SerialNumberLength - Child->m_SerialPrefixLength - sizeof(WCHAR);
    return TRUE;
}

Referenced by HubIoGetDescriptor(), and DeviceMachine::SameSerialNumber().

HubIdLanguageSupported()

BOOLEAN NTAPI HubIdLanguageSupported	(	_In_ HubChild *	Child,
		_In_ USHORT	Language
	)

TRUE when the device lists Language among its string languages.

Definition at line 911 of file hubid.cpp.

{
    const USB_STRING_DESCRIPTOR* List = Child->m_LanguageIds;
    ULONG Count;
    ULONG Index;
 
    if (List == NULL || List->bLength <= 2)
        return FALSE;
 
    Count = (List->bLength - 2) / sizeof(WCHAR);
    for (Index = 0; Index < Count && List->bString[Index] != 0; Index++)
    {
        if (List->bString[Index] == Language)
            return TRUE;
    }
 
    return FALSE;
}

Referenced by DeviceMachine::ProductNameWanted().

HubIdListCopy()

NTSTATUS NTAPI HubIdListCopy	(	_Out_ PUSB_ID_STRING	Destination,
		_In_ const USB_ID_STRING *	Source
	)

Duplicates a multi-sz id list into nonpaged pool.

Definition at line 173 of file hubid.cpp.

{
    RtlZeroMemory(Destination, sizeof(*Destination));
 
    if (Source->Buffer == NULL || Source->LengthInBytes == 0)
        return STATUS_SUCCESS;
 
    *Destination = *Source;
    Destination->Buffer = (PWCHAR)ExAllocatePoolWithTag(NonPagedPool, Source->LengthInBytes, HUB_TAG_DEVICE);
    if (Destination->Buffer == NULL)
    {
        DPRINT1("Id list copy of %lu bytes could not be allocated\n", Source->LengthInBytes);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    RtlCopyMemory(Destination->Buffer, Source->Buffer, Source->LengthInBytes);
    return STATUS_SUCCESS;
}

Referenced by if().

HubIdListFree()

VOID NTAPI HubIdListFree

(

_Inout_ PUSB_ID_STRING

Ids

)

Frees a multi-sz id list; an empty list is fine.

Definition at line 159 of file hubid.cpp.

{
    if (Ids->Buffer == NULL)
        return;
 
    ExFreePoolWithTag(Ids->Buffer, HUB_TAG_DEVICE);
    Ids->Buffer = NULL;
    Ids->LengthInBytes = 0;
}

HubLogConfigTotalLengthMismatch()

VOID NTAPI HubLogConfigTotalLengthMismatch

(

_In_ HubFdo *

Hub

)

Definition at line 85 of file hubdescval.cpp.

{
    HubDescContext Context;
 
    HubBuildDescContext(Hub, &Context);
    HubDescLog(&Context, HubDescCode::ConfigTotalLengthTooLarge, FALSE);
}

Referenced by HubMachine::CacheConfigDescriptor().

HubLogDeviceValidationError()

VOID NTAPI HubLogDeviceValidationError	(	_In_ HubChild *	Child,
		_In_ ULONG	Code
	)

Records a descriptor validation code against the device.

Definition at line 483 of file devmisc.cpp.

{
    RtlSetBit(&Child->m_ValidationBitmap, Code);
}

Referenced by DeviceMachine::AddChildToHub().

HubMakeUsb2StyleDescriptor()

VOID NTAPI HubMakeUsb2StyleDescriptor	(	_In_ HubFdo *	Hub,
		_Out_ PUSB_HUB_DESCRIPTOR	Descriptor
	)

The 71 byte USB 2.0 style hub descriptor legacy tools expect, for any hub speed.

Definition at line 135 of file hubwmi.cpp.

{
    ULONG MaskBytes;
 
    RtlZeroMemory(Descriptor, sizeof(*Descriptor));
 
    if (Hub->IsRootHub())
    {
        Descriptor->bPowerOnToPowerGood = 2;
    }
    else if (Hub->m_Parent.HubSpeed == UsbHighSpeed || Hub->m_Parent.HubSpeed == UsbFullSpeed)
    {
        RtlCopyMemory(Descriptor, &Hub->m_HubDescriptor.Usb20, sizeof(*Descriptor));
        return;
    }
    else if (Hub->m_Parent.HubSpeed == UsbSuperSpeed)
    {
        Descriptor->wHubCharacteristics = Hub->m_HubDescriptor.Usb30.wHubCharacteristics & 0x1F;
        Descriptor->bPowerOnToPowerGood = Hub->m_HubDescriptor.Usb30.bPowerOnToPowerGood;
        Descriptor->bHubControlCurrent = Hub->m_HubDescriptor.Usb30.bHubControlCurrent;
    }
    else
    {
        /* A low speed hub cannot exist */
        return;
    }
 
    /* Always 9, even when more than 7 ports need a longer mask */
    Descriptor->bDescriptorLength = 9;
    Descriptor->bDescriptorType = USB_20_HUB_DESCRIPTOR_TYPE;
    Descriptor->bNumberOfPorts = (UCHAR)Hub->m_PortCount;
 
    /* All ports removable, followed by an all ones power control mask */
    MaskBytes = Descriptor->bNumberOfPorts / 8 + 1;
    RtlFillMemory(&Descriptor->bRemoveAndPowerMask[MaskBytes], MaskBytes, 0xFF);
}

Referenced by HubWmiQueryHubNode().

HubNoPingResponse()

VOID NTAPI HubNoPingResponse	(	_In_ UCXHUB_HUB_CONTEXT	HubContext,
		_In_ UCXHUB_DEVICE_CONTEXT	DeviceContext
	)

Definition at line 2955 of file childpdo.cpp.

{
    UNREFERENCED_PARAMETER(HubContext);
 
    DPRINT1("Device %p did not answer a ping\n", DeviceContext);
    ((HubChild*)DeviceContext)->Post(DsmEvent::NoPingResponse);
}

HubReleaseRegistryState()

VOID NTAPI HubReleaseRegistryState

(

_In_ HubChild *

Child

)

Frees the buffers the registry and MS OS code keep in the device. Call at destroy.

Definition at line 2115 of file hubregistry.cpp.

{
    if (Child->m_FriendlyName != NULL)
    {
        ExFreePoolWithTag(Child->m_FriendlyName, HUB_TAG_DEVICE);
        Child->m_FriendlyName = NULL;
        Child->m_FriendlyNameLength = 0;
    }
 
    if (Child->m_MsOs20Set != NULL)
    {
        ExFreePoolWithTag(Child->m_MsOs20Set, HUB_TAG_DEVICE);
        Child->m_MsOs20Set = NULL;
    }
 
    if (Child->m_ExtProperties != NULL)
    {
        ExFreePoolWithTag(Child->m_ExtProperties, HUB_TAG_DEVICE);
        Child->m_ExtProperties = NULL;
    }
}

HubReleaseTransferState()

VOID NTAPI HubReleaseTransferState

(

_In_ HubChild *

Child

)

Frees the buffers only the transfer module owns. Call when the device object is destroyed.

Definition at line 973 of file devdesc.cpp.

{
    HubFreeBillboardInfo(Child);
 
    if (Child->m_SublinkSpeedAttr != NULL)
    {
        ExFreePoolWithTag(Child->m_SublinkSpeedAttr, HUB_TAG_DEVICE);
        Child->m_SublinkSpeedAttr = NULL;
        Child->m_SublinkSpeedAttrCount = 0;
    }
 
    if (Child->m_MsOsExtConfig != NULL)
    {
        ExFreePoolWithTag(Child->m_MsOsExtConfig, HUB_TAG_DEVICE);
        Child->m_MsOsExtConfig = NULL;
    }
}

HubUsb4NeedsHostPower()

BOOLEAN NTAPI HubUsb4NeedsHostPower

(

_In_ HubChild *

Child

)

A device behind a USB4 port holds its host router powered while tunneled or not known yet.

Definition at line 587 of file hubtunnel.cpp.

{
    return Child->m_Port->HasFlag(PortFlag::Usb4Host) &&
           (Child->m_TunnelState == HUB_TUNNEL_STATE_TUNNELED ||
            Child->m_TunnelState == HUB_TUNNEL_STATE_UNKNOWN);
}

HubValidateHubConfiguration()

BOOLEAN NTAPI HubValidateHubConfiguration	(	_In_ HubFdo *	Hub,
		_In_reads_bytes_(Length) PUSB_CONFIGURATION_DESCRIPTOR	Descriptor,
		_In_ ULONG	Length
	)

Definition at line 46 of file hubdescval.cpp.

{
    HubDescContext Context;
 
    HubBuildDescContext(Hub, &Context);
    return HubDescCheckConfiguration(&Context, Descriptor, Length, NULL);
}

Referenced by HubMachine::CacheConfigDescriptor().

HubWmiNotifyOverCurrent()

VOID NTAPI HubWmiNotifyOverCurrent	(	_In_ HubFdo *	Hub,
		_In_ ULONG	PortNumber
	)

Definition at line 750 of file hubwmi.cpp.

{
    HubWmiFirePortEvent(Hub, PortNumber, OverCurrent);
}

Referenced by PortMachine::NotifyUserOfOverCurrent().

Variable Documentation

Child

_In_ HubChild* Child

Definition at line 385 of file hubsvc.h.

DeviceInit

_In_ PWDFDEVICE_INIT DeviceInit

Definition at line 246 of file hubsvc.h.

Event

_In_ HubUxdEvent Event

Definition at line 393 of file hubsvc.h.

HubEvtBandwidthRetryTimer

EVT_WDF_TIMER HubEvtBandwidthRetryTimer

Definition at line 214 of file hubsvc.h.

Referenced by HubChild::Create().

Irp

_Inout_ PIRP Irp

Definition at line 283 of file hubsvc.h.

Length

_In_ ULONG Length

Definition at line 354 of file hubsvc.h.

MessageId

_In_ ULONG MessageId

Definition at line 157 of file hubsvc.h.

Name

_In_ PCUNICODE_STRING Name

Definition at line 93 of file hubsvc.h.

Notification

_Out_ PUSB_BUS_NOTIFICATION Notification

Definition at line 473 of file hubsvc.h.

Pdo

_In_ PDEVICE_OBJECT Pdo

Definition at line 450 of file hubsvc.h.

Port

_In_ HubPort* Port

Definition at line 92 of file hubsvc.h.

PortNumber

_In_ ULONG PortNumber

Definition at line 524 of file hubsvc.h.

String

_In_ WDFSTRING String

Definition at line 401 of file hubsvc.h.

Type

_In_ PCUNICODE_STRING _In_ ULONG Type

Definition at line 353 of file hubsvc.h.

UpdateRequired

_In_ HubChild _Out_opt_ PBOOLEAN UpdateRequired

Definition at line 386 of file hubsvc.h.

Value

_In_ PCUNICODE_STRING _In_ WDFSTRING Value

Definition at line 363 of file hubsvc.h.