devhcd.h File Reference

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

Go to the source code of this file.

Macros
#define	HUB_LPM_POLICY_U1_ENABLED   0x00000001
#define	HUB_LPM_POLICY_U2_ENABLED   0x00000002
#define	HUB_LPM_POLICY_U1_ACCEPT   0x00000004
#define	HUB_LPM_POLICY_U2_ACCEPT   0x00000008
#define	HUB_LPM_POLICY_U1_INITIATE   0x00000010
#define	HUB_LPM_POLICY_U2_INITIATE   0x00000020
#define	HUB_LPM_POLICY_CONSERVATIVE   0x00000040
#define	HUB_LPM_POLICY_AGGRESSIVE   0x00000080
#define	HUB_LINK_TARGET_U1   0x00000001
#define	HUB_LINK_TARGET_U2   0x00000002
#define	HUB_LINK_U1_OFF_FOR_LATENCY   0x00000004
#define	HUB_LINK_U2_OFF_FOR_LATENCY   0x00000008
#define	HUB_LINK_OFF_FOR_NO_PING   0x00000010

Enumerations
enum class	HubLpm20Status : ULONG {   Unknown , Enabled , DeviceIsHub , DeviceHack ,   HubHack , GloballyDisabled , DeviceNotCapable , FirstGenerationDevice ,   PortNotCapable , RunningAtSuperSpeed }

Functions
NTSTATUS NTAPI	HubChildSubmitUcxIoctl (_In_ HubChild *Child, _In_ ULONG IoControlCode)
VOID NTAPI	HubConfigMovePipes (_In_opt_ HubConfiguration *Config, _In_ PipeState From, _In_ PipeState To)
	_IRQL_requires_ (PASSIVE_LEVEL) VOID NTAPI HubChildDeleteInterface(_In_ HubChild *Child
	Sends a synchronous IOCTL to the specified device object.
VOID NTAPI	HubChildCollectForDisable (_In_ HubChild *Child, _In_ HubInterface *Interface)
BOOLEAN NTAPI	HubChildU2ForEnumerated (_In_ HubChild *Child)
USBD_STATUS NTAPI	HubNtStatusToUsbd (_In_ NTSTATUS Status)

Variables
_In_ HubInterface *	Interface

Macro Definition Documentation

HUB_LINK_OFF_FOR_NO_PING

#define HUB_LINK_OFF_FOR_NO_PING   0x00000010

Definition at line 25 of file devhcd.h.

HUB_LINK_TARGET_U1

#define HUB_LINK_TARGET_U1   0x00000001

Definition at line 21 of file devhcd.h.

HUB_LINK_TARGET_U2

#define HUB_LINK_TARGET_U2   0x00000002

Definition at line 22 of file devhcd.h.

HUB_LINK_U1_OFF_FOR_LATENCY

#define HUB_LINK_U1_OFF_FOR_LATENCY   0x00000004

Definition at line 23 of file devhcd.h.

HUB_LINK_U2_OFF_FOR_LATENCY

#define HUB_LINK_U2_OFF_FOR_LATENCY   0x00000008

Definition at line 24 of file devhcd.h.

HUB_LPM_POLICY_AGGRESSIVE

#define HUB_LPM_POLICY_AGGRESSIVE   0x00000080

Definition at line 18 of file devhcd.h.

HUB_LPM_POLICY_CONSERVATIVE

#define HUB_LPM_POLICY_CONSERVATIVE   0x00000040

Definition at line 17 of file devhcd.h.

HUB_LPM_POLICY_U1_ACCEPT

#define HUB_LPM_POLICY_U1_ACCEPT   0x00000004

Definition at line 13 of file devhcd.h.

HUB_LPM_POLICY_U1_ENABLED

#define HUB_LPM_POLICY_U1_ENABLED   0x00000001

Definition at line 11 of file devhcd.h.

HUB_LPM_POLICY_U1_INITIATE

#define HUB_LPM_POLICY_U1_INITIATE   0x00000010

Definition at line 15 of file devhcd.h.

HUB_LPM_POLICY_U2_ACCEPT

#define HUB_LPM_POLICY_U2_ACCEPT   0x00000008

Definition at line 14 of file devhcd.h.

HUB_LPM_POLICY_U2_ENABLED

#define HUB_LPM_POLICY_U2_ENABLED   0x00000002

Definition at line 12 of file devhcd.h.

HUB_LPM_POLICY_U2_INITIATE

#define HUB_LPM_POLICY_U2_INITIATE   0x00000020

Definition at line 16 of file devhcd.h.

Enumeration Type Documentation

HubLpm20Status

enum class HubLpm20Status : ULONG

strong

Enumerator
Unknown
Enabled
DeviceIsHub
DeviceHack
HubHack
GloballyDisabled
DeviceNotCapable
FirstGenerationDevice
PortNotCapable
RunningAtSuperSpeed

Definition at line 28 of file devhcd.h.

{
    Unknown,
    Enabled,
    DeviceIsHub,
    DeviceHack,
    HubHack,
    GloballyDisabled,
    DeviceNotCapable,
    FirstGenerationDevice,
    PortNotCapable,
    RunningAtSuperSpeed
};

Function Documentation

_IRQL_requires_()

_IRQL_requires_

(

PASSIVE_LEVEL

)

Sends a synchronous IOCTL to the specified device object.

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

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

HubChildCollectForDisable()

VOID NTAPI HubChildCollectForDisable	(	_In_ HubChild *	Child,
		_In_ HubInterface *	Interface
	)

Enabled pipes go to the disable list as PendingDisable, disabled ones stay unchanged.

Definition at line 132 of file devconfig.cpp.

{
    HubPipe* Pipe;
    ULONG Index;
 
    for (Index = 0; Index < Interface->PipeCount; Index++)
    {
        Pipe = &Interface->Pipes[Index];
 
        switch (Pipe->State)
        {
            case PipeState::Enabled:
                Pipe->State = PipeState::PendingDisable;
                Child->m_EndpointsToDisable[Child->m_DisableCount++] = Pipe->Endpoint;
                break;
 
            case PipeState::Disabled:
                Child->m_EndpointsUnchanged[Child->m_UnchangedCount++] = Pipe->Endpoint;
                break;
 
            case PipeState::NotCreated:
                break;
 
            default:
                DPRINT1("Device %p pipe %lu in unexpected state %u\n", Child, Index, (UCHAR)Pipe->State);
                ASSERT(FALSE);
                break;
        }
    }
}

Referenced by DeviceMachine::DisableAllEndpoints(), DeviceMachine::DisableNewInterfaceEndpoints(), DeviceMachine::PrepareConfigLists(), and DeviceMachine::PrepareInterfaceLists().

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

HubChildU2ForEnumerated()

BOOLEAN NTAPI HubChildU2ForEnumerated

(

_In_ HubChild *

Child

)

TRUE when an enumerated, unconfigured device gets a U2 timeout; sets that timeout.

Definition at line 135 of file devlpm.cpp.

{
    if (!HubChildHasPolicy(Child, HUB_LPM_POLICY_U2_ACCEPT) ||
        HubChildLpmBlocked(Child) ||
        HubChildPortKeepsU2Off(Child))
    {
        return FALSE;
    }
 
    Child->m_U2Timeout = HubChildHasPolicy(Child, HUB_LPM_POLICY_U2_INITIATE) ? U2_TIMEOUT_LONGEST
                                                                              : TIMEOUT_ACCEPT_ONLY;
    return TRUE;
}

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

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

HubNtStatusToUsbd()

USBD_STATUS NTAPI HubNtStatusToUsbd

(

_In_ NTSTATUS

Status

)

NT to USBD status mapping shared by the hub and the child PDO.

Definition at line 190 of file childpdo.cpp.

{
    switch (Status)
    {
        case STATUS_SUCCESS:
            return USBD_STATUS_SUCCESS;
 
        /* The first one is the hub's own addition to the shared table */
        case STATUS_DEVICE_NOT_CONNECTED:
        case STATUS_NO_SUCH_DEVICE:
            return USBD_STATUS_DEVICE_GONE;
 
        case STATUS_INSUFFICIENT_RESOURCES:
            return USBD_STATUS_INSUFFICIENT_RESOURCES;
 
        case STATUS_NOT_SUPPORTED:
            return USBD_STATUS_NOT_SUPPORTED;
 
        case STATUS_CANCELLED:
            return USBD_STATUS_CANCELED;
 
        default:
            return USBD_STATUS_INVALID_PARAMETER;
    }
}

Referenced by DeviceMachine::CompleteClientRequestFailed(), HubChildConfigureDone(), HubChildRecordFailure(), HubChildSubmitUcxIoctl(), HubChildUcxIoctlComplete(), HubPdoSyncComplete(), and DeviceMachine::NotifyDeviceReset().

Variable Documentation

Interface

_In_ HubInterface* Interface

Definition at line 68 of file devhcd.h.