#include "usbhub3.h"
#include "devhcd.h"
#include <debug.h>

Include dependency graph for devhcd.cpp:

Classes
struct	HubUsb20Lpm

Macros
#define	NDEBUG

#define	UCX_SIZE_ADDRESS0 sizeof(ADDRESS0_OWNERSHIP_ACQUIRE)

#define	UCX_SIZE_ENABLE sizeof(USBDEVICE_ENABLE)

#define	UCX_SIZE_RESET sizeof(USBDEVICE_RESET)

#define	UCX_SIZE_ADDRESS sizeof(USBDEVICE_ADDRESS)

#define	UCX_SIZE_UPDATE sizeof(USBDEVICE_UPDATE)

#define	UCX_SIZE_DISABLE sizeof(USBDEVICE_DISABLE)

#define	UCX_SIZE_PURGE sizeof(USBDEVICE_PURGEIO)

#define	UCX_SIZE_START sizeof(USBDEVICE_STARTIO)

#define	UCX_SIZE_ABORT sizeof(USBDEVICE_ABORTIO)

#define	UCX_SIZE_CONFIGURE sizeof(ENDPOINTS_CONFIGURE)

#define	UCX_SIZE_EP0_UPDATE sizeof(DEFAULT_ENDPOINT_UPDATE)

#define	UCX_SIZE_EP_RESET sizeof(ENDPOINT_RESET)

#define	EP0_PACKET_SUPER 512

#define	EP0_PACKET_HIGH_FULL 64

#define	EP0_PACKET_LOW 8

#define	BANDWIDTH_RETRY_DELAY_MS 1000

#define	HUB_MSG_SET_ADDRESS_FAILED 0x40010001

#define	HUB_ROOT_RESUME_SIGNAL_MS 20

#define	LPM20_DEFAULT_BESL 4

Functions
	C_ASSERT (UCX_SIZE_UPDATE==0x30)

	C_ASSERT (UCX_SIZE_RESET==0x18)

static VOID NTAPI	HubChildSetPayloadHeader (_In_ HubChild *Child, _In_ ULONG Size)

static HubUcxPayload *NTAPI	HubChildNewPayload (_In_ HubChild *Child, _In_ ULONG Size)

static VOID NTAPI	HubChildStartBandwidthTimer (_In_ HubChild *Child)

static VOID NTAPI	HubChildStopBandwidthTimer (_In_ HubChild *Child)

static VOID NTAPI	HubChildFailStatus (_In_ HubChild *Child, _In_ NTSTATUS NtStatus, _In_ USBD_STATUS UsbdStatus)

static VOID NTAPI	HubChildKeepUnchanged (_In_ HubChild Child, _In_reads_(Count) UCXENDPOINT Endpoints, _In_ ULONG Count)

VOID NTAPI	HubConfigMovePipes (_In_opt_ HubConfiguration *Config, _In_ PipeState From, _In_ PipeState To)

static VOID NTAPI	HubInterfaceSetPipes (_In_ HubInterface *Interface, _In_ PipeState To)

NTSTATUS NTAPI	HubChildSubmitUcxIoctl (_In_ HubChild *Child, _In_ ULONG IoControlCode)

static NTSTATUS NTAPI	HubChildEnableDone (_In_ HubChild *Child, _In_ NTSTATUS Status)

static BOOLEAN NTAPI	HubChildConfigureDone (_In_ HubChild Child, _Inout_ NTSTATUS Status)

static VOID NTAPI	HubChildAddressDone (_In_ HubChild *Child, _In_ NTSTATUS Status)

static VOID NTAPI	HubChildTakeTunnelState (_In_ HubChild *Child)

static VOID NTAPI	HubChildUcxIoctlComplete (_In_ WDFREQUEST Request, _In_ WDFIOTARGET Target, _In_ PWDF_REQUEST_COMPLETION_PARAMS Params, _In_ WDFCONTEXT Context)

static VOID NTAPI	HubChildReadUsb20Lpm (_In_ HubChild Child, _Out_ HubUsb20Lpm Lpm)

static BOOLEAN NTAPI	HubChildComputeLpm20 (_In_ HubChild *Child, _Inout_ PUSBDEVICE_UPDATE Update)

static VOID NTAPI	HubChildResetTargetEndpoint (_In_ HubChild *Child, _In_ ULONG Flags)

	_IRQL_requires_ (PASSIVE_LEVEL) VOID NTAPI HubChildDeleteInterface(_In_ HubChild *Child
	Sends a synchronous IOCTL to the specified device object.

	for (Index=0;Index< Interface->PipeCount;Index++)

	WdfObjectDelete (Interface->Memory)

	if (Config==NULL) return

	while (!IsListEmpty(&Config->Interfaces))

	WdfObjectDelete (Config->Memory)

static VOID NTAPI	HubChildClientRequestComplete (_In_ WDFREQUEST Request, _In_ WDFIOTARGET Target, _In_ PWDF_REQUEST_COMPLETION_PARAMS Params, _In_ WDFCONTEXT Context)

VOID NTAPI	HubChildForwardToController (_In_ HubChild *Child)

Hub m_Stack	DeviceSetPdo (Hub->UsbDevice(), Child->m_UsbDevice, Pdo)

	if (Buffer==NULL)

	if (Status==STATUS_BUFFER_TOO_SMALL)

	if (!NT_SUCCESS(Status))

	_Out_writes_bytes_ (Length) PUSB_HUB_NAME Name

	if (Length< FIELD_OFFSET(USB_HUB_NAME, HubName))

	RtlCopyMemory (Name->HubName, Info->ControllerNameUnicodeString, Copy)

	ExFreePoolWithTag (Info, HUB_TAG_HUB)

Variables
static EVT_WDF_REQUEST_COMPLETION_ROUTINE	HubChildUcxIoctlComplete

static EVT_WDF_REQUEST_COMPLETION_ROUTINE	HubChildClientRequestComplete

_In_ HubInterface *	Interface

HubPipe *	Pipe

ULONG	Index

_Inout_ HubConfiguration **	Slot

PLIST_ENTRY	Entry

KIRQL	Irql

KeAcquireSpinLock &	Child

	Config = *Slot

_In_ PDEVICE_OBJECT	Pdo

_In_ PVOID	BusContext

_In_ PVOID _Outptr_result_maybenull_ PUSB_BUS_INFORMATION_LEVEL_1 *	Result

ULONG	Length = sizeof(*Buffer)

ULONG	Actual = 0

NTSTATUS	Status = Hub->m_Usbdi.QueryBusInformation(BusContext, 1, Buffer, &Length, &Actual)

	Buffer = (PUSB_BUS_INFORMATION_LEVEL_1)ExAllocatePoolWithTag(PagedPool, Length, HUB_TAG_HUB)

ULONG	Copy = min(Info->ControllerNameLength, Length - FIELD_OFFSET(USB_HUB_NAME, HubName))

	else

_Out_ PUSB_BUS_NOTIFICATION	Notification

Notification	TotalBandwidth = Info->TotalBandwidth

Notification	ConsumedBandwidth = Info->ConsumedBandwidth

Notification	ControllerNameLength = Info->ControllerNameLength

Macro Definition Documentation

◆ BANDWIDTH_RETRY_DELAY_MS

#define BANDWIDTH_RETRY_DELAY_MS 1000

Definition at line 39 of file devhcd.cpp.

◆ EP0_PACKET_HIGH_FULL

#define EP0_PACKET_HIGH_FULL 64

Definition at line 35 of file devhcd.cpp.

◆ EP0_PACKET_LOW

#define EP0_PACKET_LOW 8

Definition at line 36 of file devhcd.cpp.

◆ EP0_PACKET_SUPER

#define EP0_PACKET_SUPER 512

Definition at line 34 of file devhcd.cpp.

◆ HUB_MSG_SET_ADDRESS_FAILED

#define HUB_MSG_SET_ADDRESS_FAILED 0x40010001

Definition at line 42 of file devhcd.cpp.

◆ HUB_ROOT_RESUME_SIGNAL_MS

#define HUB_ROOT_RESUME_SIGNAL_MS 20

Definition at line 45 of file devhcd.cpp.

◆ LPM20_DEFAULT_BESL

#define LPM20_DEFAULT_BESL 4

Definition at line 48 of file devhcd.cpp.

◆ NDEBUG

#define NDEBUG

Definition at line 11 of file devhcd.cpp.

◆ UCX_SIZE_ABORT

#define UCX_SIZE_ABORT sizeof(USBDEVICE_ABORTIO)

Definition at line 23 of file devhcd.cpp.

◆ UCX_SIZE_ADDRESS

#define UCX_SIZE_ADDRESS sizeof(USBDEVICE_ADDRESS)

Definition at line 18 of file devhcd.cpp.

◆ UCX_SIZE_ADDRESS0

#define UCX_SIZE_ADDRESS0 sizeof(ADDRESS0_OWNERSHIP_ACQUIRE)

Definition at line 15 of file devhcd.cpp.

◆ UCX_SIZE_CONFIGURE

#define UCX_SIZE_CONFIGURE sizeof(ENDPOINTS_CONFIGURE)

Definition at line 24 of file devhcd.cpp.

◆ UCX_SIZE_DISABLE

#define UCX_SIZE_DISABLE sizeof(USBDEVICE_DISABLE)

Definition at line 20 of file devhcd.cpp.

◆ UCX_SIZE_ENABLE

#define UCX_SIZE_ENABLE sizeof(USBDEVICE_ENABLE)

Definition at line 16 of file devhcd.cpp.

◆ UCX_SIZE_EP0_UPDATE

#define UCX_SIZE_EP0_UPDATE sizeof(DEFAULT_ENDPOINT_UPDATE)

Definition at line 25 of file devhcd.cpp.

◆ UCX_SIZE_EP_RESET

#define UCX_SIZE_EP_RESET sizeof(ENDPOINT_RESET)

Definition at line 26 of file devhcd.cpp.

◆ UCX_SIZE_PURGE

#define UCX_SIZE_PURGE sizeof(USBDEVICE_PURGEIO)

Definition at line 21 of file devhcd.cpp.

◆ UCX_SIZE_RESET

#define UCX_SIZE_RESET sizeof(USBDEVICE_RESET)

Definition at line 17 of file devhcd.cpp.

◆ UCX_SIZE_START

#define UCX_SIZE_START sizeof(USBDEVICE_STARTIO)

Definition at line 22 of file devhcd.cpp.

◆ UCX_SIZE_UPDATE

#define UCX_SIZE_UPDATE sizeof(USBDEVICE_UPDATE)

Definition at line 19 of file devhcd.cpp.

Function Documentation

◆ _IRQL_requires_()

_IRQL_requires_ ( PASSIVE_LEVEL )

Sends a synchronous IOCTL to the specified device object.

Parameters

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

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

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

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

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

Grows a private buffer to what the helper asks for.

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

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

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

◆ _Out_writes_bytes_()

_Out_writes_bytes_ ( Length )

◆ C_ASSERT() [1/2]

C_ASSERT ( UCX_SIZE_RESET = =0x18 )

◆ C_ASSERT() [2/2]

C_ASSERT ( UCX_SIZE_UPDATE = =0x30 )

◆ DeviceSetPdo()

Hub m_Stack DeviceSetPdo	(	Hub->	UsbDevice(),
		Child->	m_UsbDevice,
		Pdo
	)

Referenced by UcxEvtQueryStackInterface().

◆ ExFreePoolWithTag()

ExFreePoolWithTag	(	Info	,
		HUB_TAG_HUB
	)

◆ for()

for ( Index = 0; Index < Interface->PipeCount; Index++ )

Definition at line 1239 of file devhcd.cpp.

    {
        Pipe = &Interface->Pipes[Index];
        if (Pipe->State != PipeState::Disabled)
            continue;
 
        Hub->m_Stack.EndpointDelete(Hub->UsbDevice(), Child->m_UsbDevice, Pipe->Endpoint);
        Pipe->State = PipeState::Deleted;
    }

◆ HubChildAddressDone()

static VOID NTAPI HubChildAddressDone	(	_In_ HubChild *	Child,
		_In_ NTSTATUS	Status
	)

static

Definition at line 341 of file devhcd.cpp.

{
    const LONG Flag = (LONG)ChildState::LastSetAddressFailed;
 
    if (NT_SUCCESS(Status))
    {
        Child->m_Address = (UCHAR)Child->m_UcxPayload->Address.Address;
 
        if (InterlockedAnd(&Child->m_StateFlags, ~Flag) & Flag)
        {
            DPRINT1("Device %p SET_ADDRESS works again after an earlier failure\n", Child);
            InterlockedDecrement(&HubDriver.SuperSpeedDebounceVotes);
        }
 
        return;
    }
 
    Child->m_EnumMessageId = HUB_MSG_SET_ADDRESS_FAILED;
 
    if ((Child->m_Kind & DSM_KIND_PORT30) &&
        !(InterlockedOr(&Child->m_StateFlags, Flag) & Flag))
    {
        DPRINT1("Device %p SET_ADDRESS failed, SuperSpeed connects now get extra debounce time\n", Child);
        InterlockedIncrement(&HubDriver.SuperSpeedDebounceVotes);
    }
}

Referenced by HubChildUcxIoctlComplete().

◆ HubChildClientRequestComplete()

static VOID NTAPI HubChildClientRequestComplete	(	_In_ WDFREQUEST	Request,
		_In_ WDFIOTARGET	Target,
		_In_ PWDF_REQUEST_COMPLETION_PARAMS	Params,
		_In_ WDFCONTEXT	Context
	)

static

Definition at line 1335 of file devhcd.cpp.

{
    HubChild* Child = (HubChild*)Context;
 
    UNREFERENCED_PARAMETER(Target);
 
    WdfRequestCompleteWithInformation(Request, Params->IoStatus.Status, Params->IoStatus.Information);
    Child->Post(DsmEvent::ControllerRequestDone);
}

◆ HubChildComputeLpm20()

static BOOLEAN NTAPI HubChildComputeLpm20	(	_In_ HubChild *	Child,
		_Inout_ PUSBDEVICE_UPDATE	Update
	)

static

Definition at line 694 of file devhcd.cpp.

{
    HubLpm20Status Result;
    HubUsb20Lpm Lpm;
 
    HubChildReadUsb20Lpm(Child, &Lpm);
 
    if (Child->HasProperty(ChildProperty::IsHub))
        Result = HubLpm20Status::DeviceIsHub;
    else if (Child->HasHack(ChildHack::DisableUsb20Lpm))
        Result = HubLpm20Status::DeviceHack;
    else if (Child->m_Hub->HasFlag(HubFlag::DisableUsb20Lpm))
        Result = HubLpm20Status::HubHack;
    else if (!HubDriver.HasFlag(HubGlobal::EnableUsb20HardwareLpm))
        Result = HubLpm20Status::GloballyDisabled;
    else if (!Lpm.Capable)
        Result = HubLpm20Status::DeviceNotCapable;
    else if (!Lpm.Besl)
        Result = HubLpm20Status::FirstGenerationDevice;
    else if (!Child->m_Port->HasProperty(PortProperty::Usb20LpmCapable))
        Result = HubLpm20Status::PortNotCapable;
    else
        Result = HubLpm20Status::Enabled;
 
    if (Result == HubLpm20Status::Enabled)
    {
        Update->Flags.Update20HardwareLpmParameters = 1;
        Update->Usb20HardwareLpmParameters.HardwareLpmEnable = 1;
        Update->Usb20HardwareLpmParameters.L1Timeout = HubDriver.Usb20LpmTimeout;
        Update->Usb20HardwareLpmParameters.RemoteWakeEnable =
            Child->HasHack(ChildHack::DisableRemoteWakeForUsb20Lpm) ? 0 : 1;
        Update->Usb20HardwareLpmParameters.BestEffortServiceLatency = LPM20_DEFAULT_BESL;
        Update->Usb20HardwareLpmParameters.BestEffortServiceLatencyDeep = 0;
        Update->Usb20HardwareLpmParameters.HostInitiatedResumeDurationMode = 0;
 
        if (Child->m_Port->HasProperty(PortProperty::BeslCapable))
        {
            if (Lpm.BaselineValid)
                Update->Usb20HardwareLpmParameters.BestEffortServiceLatency = Lpm.Baseline;
 
            if (Lpm.DeepValid)
            {
                Update->Usb20HardwareLpmParameters.BestEffortServiceLatencyDeep = Lpm.Deep;
                Update->Usb20HardwareLpmParameters.HostInitiatedResumeDurationMode = 1;
            }
        }
    }
 
    /* Diagnostic only; the parameters still go out and UCX ignores them */
    Child->m_Lpm20Status = (Child->m_Kind & DSM_KIND_SUPER_SPEED) ? (ULONG)HubLpm20Status::RunningAtSuperSpeed
                                                                  : (ULONG)Result;
    DPRINT("Device %p USB 2.0 LPM status %lu\n", Child, Child->m_Lpm20Status);
 
    return Result == HubLpm20Status::Enabled;
}

Referenced by DeviceMachine::UpdateDeviceInController(), and DeviceMachine::UpdateLpm20().

◆ HubChildConfigureDone()

static BOOLEAN NTAPI HubChildConfigureDone	(	_In_ HubChild *	Child,
		_Inout_ NTSTATUS *	Status
	)

static

FALSE when the completion already posted its own event.

Definition at line 251 of file devhcd.cpp.

{
    PENDPOINTS_CONFIGURE Configure = &Child->m_UcxPayload->Configure;
    BOOLEAN Failed;
 
    HubConfigMovePipes(Child->m_CurrentConfig, PipeState::PendingDisable, PipeState::Disabled);
    HubConfigMovePipes(Child->m_OldConfig, PipeState::PendingDisable, PipeState::Disabled);
    if (Child->m_OldInterface != NULL)
        HubInterfaceSetPipes(Child->m_OldInterface, PipeState::Disabled);
 
    if (Configure->ExitLatencyDelta != 0)
    {
        /* The ELD exit latency is cleared either way */
        if (Configure->FailureFlags.MaxExitLatencyTooLarge)
        {
            DPRINT1("Device %p exit latency delta %lu rejected, effective latency %u\n",
                    Child, Configure->ExitLatencyDelta, Child->m_EffectiveExitLatency);
            Child->m_MaxExitLatencyFromEld = 0;
        }
        else if (NT_SUCCESS(*Status))
        {
            Child->m_MaxExitLatencyFromEld = Child->m_EffectiveExitLatency + Configure->ExitLatencyDelta;
            DPRINT("Device %p max exit latency from delta is %lu\n", Child, Child->m_MaxExitLatencyFromEld);
        }
        else
        {
            Child->m_MaxExitLatencyFromEld = 0;
        }
    }
 
    Failed = Configure->FailureFlags.InsufficientBandwidth ||
             Configure->FailureFlags.InsufficientHardwareResourcesForEndpoints ||
             Configure->FailureFlags.MaxExitLatencyTooLarge;
 
    if (Failed)
    {
        DPRINT("Device %p endpoint configure ran out of bandwidth or resources\n", Child);
        Child->m_LastUsbdStatus = USBD_STATUS_NO_BANDWIDTH;
        *Status = STATUS_UNSUCCESSFUL;
 
        /* Older controllers report a latency problem as a resource problem; retry without U1 and U2 */
        if (Child->m_EffectiveExitLatency != 0)
        {
            DPRINT1("Device %p endpoint configure failed at exit latency %u, retrying without U1 and U2\n",
                    Child, Child->m_EffectiveExitLatency);
            HubChildKeepUnchanged(Child, Child->m_EndpointsToDisable, Child->m_DisableCount);
            Child->m_DisableCount = 0;
 
            /* The USBD code goes into the NT status here */
            Child->m_LastNtStatus = (NTSTATUS)HubNtStatusToUsbd(STATUS_UNSUCCESSFUL);
            Child->Post(DsmEvent::ControllerExitLatencyTooLarge);
            return FALSE;
        }
 
        HubChildStartBandwidthTimer(Child);
    }
 
    if (InterlockedAnd(&Child->m_StateFlags, ~(LONG)ChildState::AltSettingFiltered) &
        (LONG)ChildState::AltSettingFiltered)
    {
        DPRINT1("Device %p select failed by the alternate setting filter\n", Child);
        Child->m_LastUsbdStatus = USBD_STATUS_NO_BANDWIDTH;
        *Status = STATUS_UNSUCCESSFUL;
        HubChildStartBandwidthTimer(Child);
    }
    else if (Child->m_EnableCount != 0 && NT_SUCCESS(*Status))
    {
        HubChildStopBandwidthTimer(Child);
    }
    else if (*Status == STATUS_UNSUCCESSFUL)
    {
        *Status = STATUS_INSUFFICIENT_RESOURCES;
    }
 
    HubConfigMovePipes(Child->m_CurrentConfig,
                       PipeState::PendingEnable,
                       NT_SUCCESS(*Status) ? PipeState::Enabled : PipeState::Disabled);
 
    Child->m_DisableCount = 0;
    Child->m_EnableCount = 0;
    Child->m_UnchangedCount = 0;
    return TRUE;
}

Referenced by HubChildUcxIoctlComplete().

◆ HubChildEnableDone()

static NTSTATUS NTAPI HubChildEnableDone	(	_In_ HubChild *	Child,
		_In_ NTSTATUS	Status
	)

static

Definition at line 219 of file devhcd.cpp.

{
    PUSBDEVICE_ENABLE Enable = &Child->m_UcxPayload->Enable;
 
    if (Enable->FailureFlags.InsufficientHardwareResourcesForDefaultEndpoint ||
        Enable->FailureFlags.InsufficientHardwareResourcesForDevice)
    {
        DPRINT("Device %p enable ran out of controller resources\n", Child);
        Child->m_LastUsbdStatus = USBD_STATUS_NO_BANDWIDTH;
        HubChildStartBandwidthTimer(Child);
        return STATUS_UNSUCCESSFUL;
    }
 
    if (NT_SUCCESS(Status))
    {
        HubChildStopBandwidthTimer(Child);
        return Status;
    }
 
    /* A generic failure is reported as out of resources */
    if (Status == STATUS_UNSUCCESSFUL)
        return STATUS_INSUFFICIENT_RESOURCES;
 
    return Status;
}

Referenced by HubChildUcxIoctlComplete().

◆ HubChildFailStatus()

static VOID NTAPI HubChildFailStatus	(	_In_ HubChild *	Child,
		_In_ NTSTATUS	NtStatus,
		_In_ USBD_STATUS	UsbdStatus
	)

static

Definition at line 102 of file devhcd.cpp.

{
    Child->m_LastNtStatus = NtStatus;
    Child->m_LastUsbdStatus = UsbdStatus;
}

Referenced by DeviceMachine::CreateDefaultEndpoint(), DeviceMachine::CreateDeviceInController(), DeviceMachine::CreateEndpoints(), HubChildResetTargetEndpoint(), HubChildSubmitUcxIoctl(), DeviceMachine::NotifyDeviceReset(), and DeviceMachine::ProgramEndpoints().

◆ 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().

◆ HubChildKeepUnchanged()

static VOID NTAPI HubChildKeepUnchanged	(	_In_ HubChild *	Child,
		_In_reads_(Count) UCXENDPOINT *	Endpoints,
		_In_ ULONG	Count
	)

static

Definition at line 115 of file devhcd.cpp.

{
    ULONG Index;
 
    for (Index = 0; Index < Count; Index++)
    {
        if (Child->m_UnchangedCount >= Child->m_EndpointArrayCapacity)
            break;
 
        Child->m_EndpointsUnchanged[Child->m_UnchangedCount++] = Endpoints[Index];
    }
}

Referenced by DeviceMachine::EndpointsNeedDisableOnFailure(), and HubChildConfigureDone().

◆ HubChildNewPayload()

static HubUcxPayload *NTAPI HubChildNewPayload	(	_In_ HubChild *	Child,
		_In_ ULONG	Size
	)

static

Definition at line 72 of file devhcd.cpp.

{
    RtlZeroMemory(Child->m_UcxPayload, sizeof(*Child->m_UcxPayload));
    HubChildSetPayloadHeader(Child, Size);
    return Child->m_UcxPayload;
}

Referenced by DeviceMachine::AbortDeviceIo(), DeviceMachine::ClaimAddressZero(), DeviceMachine::DisableDeviceInController(), DeviceMachine::EnableDeviceInController(), HubChildResetTargetEndpoint(), DeviceMachine::NotifyDeviceReset(), DeviceMachine::ProgramEndpoints(), DeviceMachine::PurgeDeviceIo(), DeviceMachine::PurgeDeviceTreeIo(), DeviceMachine::PurgeIoForSuspend(), DeviceMachine::SetDeviceAddress(), DeviceMachine::StartDeviceIo(), DeviceMachine::UpdateDefaultEndpoint(), DeviceMachine::UpdateDeviceInController(), and DeviceMachine::UpdateExitLatency().

◆ HubChildReadUsb20Lpm()

static VOID NTAPI HubChildReadUsb20Lpm	(	_In_ HubChild *	Child,
		_Out_ HubUsb20Lpm *	Lpm
	)

static

Definition at line 630 of file devhcd.cpp.

{
    PUSB_BOS_DESCRIPTOR Bos = Child->m_Bos;
    PUSB_DEVICE_CAPABILITY_USB20_EXTENSION_DESCRIPTOR Extension;
    PUSB_COMMON_DESCRIPTOR Common;
    PUCHAR Current;
    PUCHAR End;
    UCHAR Baseline;
    UCHAR Deep;
 
    RtlZeroMemory(Lpm, sizeof(*Lpm));
 
    if (Bos == NULL)
        return;
 
    Current = (PUCHAR)Bos + Bos->bLength;
    End = (PUCHAR)Bos + Bos->wTotalLength;
 
    for (; Current + sizeof(*Common) <= End; Current += Common->bLength)
    {
        Common = (PUSB_COMMON_DESCRIPTOR)Current;
        if (Common->bLength == 0)
            break;
 
        Extension = (PUSB_DEVICE_CAPABILITY_USB20_EXTENSION_DESCRIPTOR)Current;
 
        if (Common->bDescriptorType != USB_DEVICE_CAPABILITY_DESCRIPTOR_TYPE ||
            Common->bLength < sizeof(*Extension) ||
            Current + sizeof(*Extension) > End ||
            Extension->bDevCapabilityType != USB_DEVICE_CAPABILITY_USB20_EXTENSION ||
            !Extension->bmAttributes.LPMCapable)
        {
            continue;
        }
 
        Baseline = (UCHAR)Extension->bmAttributes.BaselineBESL;
        Deep = (UCHAR)Extension->bmAttributes.DeepBESL;
 
        Lpm->Capable = TRUE;
        if (Extension->bmAttributes.BESLAndAlternateHIRDSupported)
            Lpm->Besl = TRUE;
 
        if (Extension->bmAttributes.BaselineBESLValid && Baseline != 0)
        {
            Lpm->BaselineValid = TRUE;
            Lpm->Baseline = Baseline;
        }
 
        /* A deep value not above a valid baseline is ignored */
        if (Extension->bmAttributes.DeepBESLValid && Deep != 0 &&
            !(Extension->bmAttributes.BaselineBESLValid && Deep <= Baseline))
        {
            Lpm->DeepValid = TRUE;
            Lpm->Deep = Deep;
        }
    }
}

Referenced by HubChildComputeLpm20().

◆ HubChildResetTargetEndpoint()

static VOID NTAPI HubChildResetTargetEndpoint	(	_In_ HubChild *	Child,
		_In_ ULONG	Flags
	)

static

Definition at line 945 of file devhcd.cpp.

{
    HubUcxPayload* Payload = HubChildNewPayload(Child, UCX_SIZE_EP_RESET);
 
    if (Child->m_TargetPipe == NULL)
    {
        DPRINT1("Device %p endpoint reset without a target pipe\n", Child);
        HubChildFailStatus(Child, STATUS_INVALID_PARAMETER, USBD_STATUS_INVALID_PIPE_HANDLE);
        Child->Post(DsmEvent::ControllerIoctlFailed);
        return;
    }
 
    Payload->EndpointReset.Endpoint = Child->m_TargetPipe->Endpoint;
    Payload->EndpointReset.Flags = (ENDPOINT_RESET_FLAGS)Flags;
    HubChildSubmitUcxIoctl(Child, IOCTL_UCXHUB_ENDPOINT_RESET);
}

Referenced by DeviceMachine::ResetEndpoint(), and DeviceMachine::ResetEndpointAndTransfers().

◆ HubChildSetPayloadHeader()

static VOID NTAPI HubChildSetPayloadHeader	(	_In_ HubChild *	Child,
		_In_ ULONG	Size
	)

static

Definition at line 58 of file devhcd.cpp.

{
    PUSBDEVICE_MGMT_HEADER Header = &Child->m_UcxPayload->Header;
 
    Header->Size = Size;
    Header->Hub = Child->m_Hub->UsbDevice();
    Header->UsbDevice = Child->m_UsbDevice;
}

Referenced by HubChildNewPayload(), and DeviceMachine::UpdateLpm20().

◆ HubChildStartBandwidthTimer()

static VOID NTAPI HubChildStartBandwidthTimer ( _In_ HubChild * Child )

static

Definition at line 84 of file devhcd.cpp.

{
    WdfTimerStart(Child->m_BandwidthRetryTimer, WDF_REL_TIMEOUT_IN_MS(BANDWIDTH_RETRY_DELAY_MS));
}

Referenced by HubChildConfigureDone(), and HubChildEnableDone().

◆ HubChildStopBandwidthTimer()

static VOID NTAPI HubChildStopBandwidthTimer ( _In_ HubChild * Child )

static

Definition at line 93 of file devhcd.cpp.

{
    WdfTimerStop(Child->m_BandwidthRetryTimer, FALSE);
}

Referenced by HubChildConfigureDone(), HubChildEnableDone(), and DeviceMachine::ProgramEndpoints().

◆ HubChildSubmitUcxIoctl()

NTSTATUS NTAPI HubChildSubmitUcxIoctl	(	_In_ HubChild *	Child,
		_In_ ULONG	IoControlCode
	)

Sends the payload already in the device's UCX buffer. On a send failure the failure event is posted here and the completion never runs.

Definition at line 174 of file devhcd.cpp.

{
    WDFIOTARGET Target = Child->m_Hub->m_RootHubTarget;
    WDFREQUEST Request = Child->m_UcxRequest;
    WDF_REQUEST_REUSE_PARAMS Reuse;
    NTSTATUS Status;
 
    WDF_REQUEST_REUSE_PARAMS_INIT(&Reuse, WDF_REQUEST_REUSE_NO_FLAGS, STATUS_SUCCESS);
    Status = WdfRequestReuse(Request, &Reuse);
    if (!NT_SUCCESS(Status))
        DPRINT1("Device %p UCX request reuse failed 0x%lx\n", Child, Status);
 
    Child->m_UcxIoctl = IoControlCode;
 
    /* The request was made on the local target; that stack is at least as deep */
    Status = WdfIoTargetFormatRequestForInternalIoctlOthers(Target,
                                                            Request,
                                                            IoControlCode,
                                                            Child->m_UcxPayloadMemory,
                                                            NULL,
                                                            NULL,
                                                            NULL,
                                                            NULL,
                                                            NULL);
    if (NT_SUCCESS(Status))
    {
        WdfRequestSetCompletionRoutine(Request, HubChildUcxIoctlComplete, Child);
 
        if (WdfRequestSend(Request, Target, WDF_NO_SEND_OPTIONS))
            return STATUS_SUCCESS;
 
        Status = WdfRequestGetStatus(Request);
    }
 
    DPRINT1("Device %p UCX request 0x%lx not sent 0x%lx\n", Child, IoControlCode, Status);
    HubChildFailStatus(Child, Status, HubNtStatusToUsbd(Status));
    Child->Post(DsmEvent::ControllerIoctlFailed);
    return Status;
}

Referenced by DeviceMachine::AbortDeviceIo(), DeviceMachine::ClaimAddressZero(), DeviceMachine::DisableDeviceInController(), DeviceMachine::EnableDeviceInController(), HubChildResetTargetEndpoint(), DeviceMachine::NotifyDeviceReset(), DeviceMachine::ProgramEndpoints(), DeviceMachine::PurgeDeviceIo(), DeviceMachine::PurgeDeviceTreeIo(), DeviceMachine::PurgeIoForSuspend(), DeviceMachine::SetDeviceAddress(), DeviceMachine::StartDeviceIo(), DeviceMachine::UpdateDefaultEndpoint(), DeviceMachine::UpdateDeviceInController(), DeviceMachine::UpdateExitLatency(), and DeviceMachine::UpdateLpm20().

◆ HubChildTakeTunnelState()

static VOID NTAPI HubChildTakeTunnelState ( _In_ HubChild * Child )

static

Definition at line 374 of file devhcd.cpp.

{
    PUSBDEVICE_UPDATE Update = &Child->m_UcxPayload->Update;
    UCHAR State;
 
    if (!Update->Flags.UpdateTunnelState)
        return;
 
    State = UcxHubUpdateTunnelAnswer(Update)->TunnelState;
    if (State == HUB_TUNNEL_STATE_NONE)
    {
        DPRINT1("Device %p controller gave no USB4 tunnel state\n", Child);
        return;
    }
 
    DPRINT("Device %p USB4 tunnel state %u\n", Child, State);
    Child->m_TunnelState = State;
}

Referenced by HubChildUcxIoctlComplete().

◆ HubChildUcxIoctlComplete()

static VOID NTAPI HubChildUcxIoctlComplete	(	_In_ WDFREQUEST	Request,
		_In_ WDFIOTARGET	Target,
		_In_ PWDF_REQUEST_COMPLETION_PARAMS	Params,
		_In_ WDFCONTEXT	Context
	)

static

Definition at line 397 of file devhcd.cpp.

{
    HubChild* Child = (HubChild*)Context;
    NTSTATUS Status = Params->IoStatus.Status;
 
    UNREFERENCED_PARAMETER(Request);
    UNREFERENCED_PARAMETER(Target);
 
    switch (Child->m_UcxIoctl)
    {
        case IOCTL_UCXHUB_DEVICE_ENABLE:
            Status = HubChildEnableDone(Child, Status);
            break;
 
        case IOCTL_UCXHUB_ENDPOINTS_CONFIGURE:
            if (!HubChildConfigureDone(Child, &Status))
                return;
            break;
 
        case IOCTL_UCXHUB_DEVICE_ADDRESS:
            HubChildAddressDone(Child, Status);
            break;
 
        case IOCTL_UCXHUB_DEVICE_RESET:
            HubConfigMovePipes(Child->m_CurrentConfig, PipeState::PendingDisable, PipeState::Disabled);
            break;
 
        case IOCTL_UCXHUB_DEVICE_UPDATE:
            /* Every successful update counts as taking the target latency, even ones without it */
            if (NT_SUCCESS(Status))
            {
                Child->m_EffectiveExitLatency = Child->m_TargetExitLatency;
                HubChildTakeTunnelState(Child);
            }
            else if (Child->m_UcxPayload->Update.FailureFlags.MaxExitLatencyTooLarge)
            {
                DPRINT1("Device %p exit latency %u too large for the controller 0x%lx\n",
                        Child, Child->m_TargetExitLatency, Status);
                Child->Post(DsmEvent::ControllerExitLatencyTooLarge);
                return;
            }
            break;
 
        default:
            break;
    }
 
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Device %p UCX request 0x%lx failed 0x%lx\n", Child, Child->m_UcxIoctl, Status);
 
        /* A USBD status left over from an earlier failure wins */
        Child->m_LastNtStatus = Status;
        if (Child->m_LastUsbdStatus == 0)
            Child->m_LastUsbdStatus = HubNtStatusToUsbd(Status);
    }
 
    Child->Post(NT_SUCCESS(Status) ? DsmEvent::ControllerIoctlDone : DsmEvent::ControllerIoctlFailed);
}

◆ HubConfigMovePipes()

VOID NTAPI HubConfigMovePipes	(	_In_opt_ HubConfiguration *	Config,
		_In_ PipeState	From,
		_In_ PipeState	To
	)

Moves every pipe of a configuration in state From to state To.

Definition at line 133 of file devhcd.cpp.

{
    PLIST_ENTRY Entry;
    HubInterface* Interface;
    ULONG Index;
 
    if (Config == NULL)
        return;
 
    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].State == From)
                Interface->Pipes[Index].State = To;
        }
    }
}

Referenced by DeviceMachine::EndpointsNeedDisableOnFailure(), HubChildConfigureDone(), HubChildUcxIoctlComplete(), DeviceMachine::MarkPendingEndpointsDisabled(), DeviceMachine::NotifyDeviceReset(), and DeviceMachine::ProgramEndpoints().

◆ HubInterfaceSetPipes()

static VOID NTAPI HubInterfaceSetPipes	(	_In_ HubInterface *	Interface,
		_In_ PipeState	To
	)

static

Definition at line 160 of file devhcd.cpp.

{
    ULONG Index;
 
    for (Index = 0; Index < Interface->PipeCount; Index++)
        Interface->Pipes[Index].State = To;
}

Referenced by HubChildConfigureDone().

◆ if() [1/5]

if ( ! NT_SUCCESSStatus )

Definition at line 1428 of file devhcd.cpp.

    {
        DPRINT1("Hub %p bus information query failed 0x%lx\n", Hub, Status);
        ExFreePoolWithTag(Buffer, HUB_TAG_HUB);
        return Status;
    }

◆ if() [2/5]

if ( Buffer = = NULL )

Definition at line 1406 of file devhcd.cpp.

    {
        DPRINT1("Hub %p no memory for bus information\n", Hub);
        return STATUS_INSUFFICIENT_RESOURCES;
    }

◆ if() [3/5]

if ( Config = =NULL )

◆ if() [4/5]

if ( )

Definition at line 1456 of file devhcd.cpp.

    {
        DPRINT1("Hub %p controller name buffer of %lu bytes is too small\n", Hub, Length);
        Status = STATUS_BUFFER_TOO_SMALL;
    }

Referenced by HubChildAddressDone().

◆ if() [5/5]

if ( Status = = STATUS_BUFFER_TOO_SMALL )

Definition at line 1413 of file devhcd.cpp.

    {
        ExFreePoolWithTag(Buffer, HUB_TAG_HUB);
 
        Length = Actual;
        Buffer = (PUSB_BUS_INFORMATION_LEVEL_1)ExAllocatePoolWithTag(PagedPool, Length, HUB_TAG_HUB);
        if (Buffer == NULL)
        {
            DPRINT1("Hub %p no memory for %lu bytes of bus information\n", Hub, Length);
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        Status = Hub->m_Usbdi.QueryBusInformation(BusContext, 1, Buffer, &Length, &Actual);
    }

◆ RtlCopyMemory()

RtlCopyMemory	(	Name->	HubName,
		Info->	ControllerNameUnicodeString,
		Copy
	)

◆ WdfObjectDelete() [1/2]

WdfObjectDelete ( Config-> Memory )

◆ WdfObjectDelete() [2/2]

WdfObjectDelete ( Interface-> Memory )

◆ while()

while ( !IsListEmpty &-> Interfaces )

Definition at line 1273 of file devhcd.cpp.

    {
        Entry = RemoveHeadList(&Config->Interfaces);
        HubChildDeleteInterface(Child, CONTAINING_RECORD(Entry, HubInterface, Link));
    }