XhciController Class Reference

#include <hc.h>

Collaboration diagram for XhciController:

Public Types
enum	: ULONG64 {   FixFrescoShadow = 0x01 , FixFrescoControl = 0x02 , FixEtronSet = 0x04 , FixEtronClear = 0x08 ,   FixAsmediaResetDelay = 0x10 }
enum class	SystemAction : ULONG {   Boot = 0 , ResumeFromSleep = 1 , ResumeFromHibernate = 2 , Sleep = 3 ,   HybridSleep = 4 , Hibernate = 5 , Shutdown = 6 , None = 7 }

Public Member Functions
BOOLEAN	HasErrata (_In_ XhciErrata Bit) const
VOID	SetErrata (_In_ XhciErrata Bit)
BOOLEAN	IsAccessible () const
VOID	MarkGone ()
	_IRQL_requires_max_ (DISPATCH_LEVEL) VOID RaiseControllerFault(_In_ XhciRecovery Action
	_IRQL_requires_max_ (DISPATCH_LEVEL) ULONG GetFrameNumber(_In_ ULONG Increment)
	_IRQL_requires_max_ (DISPATCH_LEVEL) VOID VerifierCheck(_In_ ULONG Flag)
	_IRQL_requires_max_ (DISPATCH_LEVEL) VOID OnRootHubD0Entry()
	_IRQL_requires_max_ (DISPATCH_LEVEL) VOID NotifyPortConnectState(_In_ BOOLEAN AnyConnected)
NTSTATUS	Initialize (_In_ WDFDEVICE Device, _In_ UCXCONTROLLER Ucx, _In_ const XhciIdentity *Identity)
NTSTATUS	PrepareHardware (_In_ WDFCMRESLIST Raw, _In_ WDFCMRESLIST Translated)
VOID	ReleaseHardware ()
NTSTATUS	D0Entry (_In_ WDF_POWER_DEVICE_STATE PreviousState)
NTSTATUS	D0EntryPostInterruptsEnabled (_In_ WDF_POWER_DEVICE_STATE PreviousState)
VOID	D0ExitPreInterruptsDisabled ()
VOID	D0Exit (_In_ WDF_POWER_DEVICE_STATE TargetState)
VOID	SelfManagedIoInit ()
VOID	SelfManagedIoCleanup ()
VOID	UsageNotification (_In_ WDF_SPECIAL_FILE_TYPE Type, _In_ BOOLEAN InPath)
VOID	SetPortWake (_In_ BOOLEAN Arm)
VOID	TrackSystemPowerIrp (_In_ PIO_STACK_LOCATION Stack)
VOID	WatchdogTick ()
VOID	RecoveryWorker ()
VOID	IdleTimeoutWorker ()
VOID	UcxReset ()
NTSTATUS	QueryUsbCapability (_In_ const GUID *Capability, _In_ ULONG OutputBufferLength, _Out_writes_bytes_opt_(OutputBufferLength) PVOID OutputBuffer, _Out_ PULONG ResultLength)
VOID	FdoCleanup ()

Static Public Member Functions
static XhciController *	FromDevice (_In_ WDFDEVICE Device)
static XhciController *	FromUcx (_In_ UCXCONTROLLER UcxController)

Public Attributes
_In_ ULONG	Reason
WDFDEVICE	m_Device
PDEVICE_OBJECT	m_WdmDevice
UCXCONTROLLER	m_Ucx
ULONG64	m_Errata
ULONG64	m_ErrataWord2
XhciRegisters	m_Registers
XhciCommonBuffer	m_Buffers
XhciSlotTable	m_Slots
XhciInterrupters	m_Interrupters
XhciCommandRing	m_Commands
XhciRootHub	m_RootHub
XhciIdentity	m_Identity
ULONG64	m_InternalFlags
BOOLEAN	m_ReservedIoArmed
WDF_POWER_DEVICE_STATE	m_PowerState
SystemAction	m_SystemAction
XhciDmaBuffer *	m_SplitPadBuffer
BOOLEAN	m_WaitWakeQueued
BOOLEAN	m_TestMode

Private Types
enum class	IdleStatus : ULONG { NotConfigured , NoS0Wake , Configured }

Private Member Functions
NTSTATUS	CreateWdfObjects ()
VOID	PopulateErrata ()
VOID	QueryErrataDatabase (_In_ BOOLEAN AtAddDevice)
VOID	ReadRegistryErrata ()
VOID	SetInternalFlags ()
VOID	ReadVerifierFlags ()
VOID	ConfigureS0Idle ()
VOID	SetIdleTimeout (_In_ ULONG Milliseconds)
VOID	EvaluateDsm (_In_ ULONG Function)
VOID	EvaluatePrmi ()
VOID	UpdateRegistryCounters ()
VOID	RunFirmwareCommands ()
NTSTATUS	StartController ()
NTSTATUS	RunD0Pass (_In_ BOOLEAN Restore)
VOID	InitFrameSnapshot ()
	_IRQL_requires_max_ (DISPATCH_LEVEL) VOID QueueRecovery(_In_ ULONG Actions
VOID	BootRecovery (_In_ ULONG Actions)
VOID	RunRecovery (_In_ ULONG Actions)
	_IRQL_requires_max_ (DISPATCH_LEVEL) VOID SetGone(_In_ BOOLEAN ReportToPnp)
	_IRQL_requires_max_ (DISPATCH_LEVEL) VOID DisableController()
VOID	InternalReset ()
ULONG64	NowMs () const

Private Attributes
ULONG	m_VerifierFlags
BOOLEAN	m_Gone
BOOLEAN	m_SaveFailed
BOOLEAN	m_FrameSnapshotReady
LONG64	m_FrameSnapshot
ULONG	m_TimeIncrement
ULONG	m_SpecialFiles
ULONG	m_RestoreFailures
ULONG	m_RecoveryCount
LONG	m_ResetCount
LONG	m_ResetInterval
LONG	m_ResetLock
IdleStatus	m_IdleStatus
ULONG	m_LastIdleTimeout
WDFTIMER	m_Watchdog
WDFWORKITEM	m_RecoveryItem
WDFWORKITEM	m_IdleItem
KSPIN_LOCK	m_RecoveryLock
ULONG	m_RecoveryActions
KMUTEX	m_RecoveryMutex
BOOLEAN	m_GoneHandled
BOOLEAN	m_PnpToldRemoved

Detailed Description

Lives in the UCXCONTROLLER context and embeds every module object.

Definition at line 47 of file hc.h.

Member Enumeration Documentation

anonymous enum

anonymous enum : ULONG64

Internal fixes keyed by PCI id, bits of m_InternalFlags.

Enumerator
FixFrescoShadow
FixFrescoControl
FixEtronSet
FixEtronClear
FixAsmediaResetDelay

Definition at line 103 of file hc.h.

    {
        FixFrescoShadow = 0x01,
        FixFrescoControl = 0x02,
        FixEtronSet = 0x04,
        FixEtronClear = 0x08,
        FixAsmediaResetDelay = 0x10
    };

IdleStatus

enum class XhciController::IdleStatus : ULONG

strongprivate

Enumerator
NotConfigured
NoS0Wake
Configured

Definition at line 207 of file hc.h.

    {
        NotConfigured,
        NoS0Wake,
        Configured
    };

SystemAction

enum class XhciController::SystemAction : ULONG

strong

Tracked system power action.

Enumerator
Boot
ResumeFromSleep
ResumeFromHibernate
Sleep
HybridSleep
Hibernate
Shutdown
None

Definition at line 120 of file hc.h.

    {
        Boot = 0,
        ResumeFromSleep = 1,
        ResumeFromHibernate = 2,
        Sleep = 3,
        HybridSleep = 4,
        Hibernate = 5,
        Shutdown = 6,
        None = 7
    };

Member Function Documentation

_IRQL_requires_max_() [1/8]

XhciController::_IRQL_requires_max_

(

DISPATCH_LEVEL

)

32 bit frame number, Increment microframes ahead.

_IRQL_requires_max_() [2/8]

XhciController::_IRQL_requires_max_ ( DISPATCH_LEVEL  )

private

_IRQL_requires_max_() [3/8]

XhciController::_IRQL_requires_max_

(

DISPATCH_LEVEL

)

Port connect state for the power engine.

_IRQL_requires_max_() [4/8]

XhciController::_IRQL_requires_max_

(

DISPATCH_LEVEL

)

Root hub PDO reached D0: switch to the short idle timeout.

_IRQL_requires_max_() [5/8]

XhciController::_IRQL_requires_max_ ( DISPATCH_LEVEL  )

private

_IRQL_requires_max_() [6/8]

XhciController::_IRQL_requires_max_

(

DISPATCH_LEVEL

)

Any IRQL up to DISPATCH_LEVEL; the work runs on the recovery work item.

_IRQL_requires_max_() [7/8]

XhciController::_IRQL_requires_max_ ( DISPATCH_LEVEL  )

private

_IRQL_requires_max_() [8/8]

XhciController::_IRQL_requires_max_

(

DISPATCH_LEVEL

)

DPRINT1 a hardware verifier condition; breaks in when that flag is enabled.

BootRecovery()

VOID XhciController::BootRecovery ( _In_ ULONG  Actions )

private

Definition at line 1971 of file hc.cpp.

{
    static LONG InlineResets;
 
    /* The branches are exclusive even when several bits are set */
    if (Actions & (XHCI_RECOVER_GONE | XHCI_RECOVER_GONE_PNP | XHCI_RECOVER_NO_RESTART))
    {
        KeBugCheckEx(XHCI_BUGCHECK_USB3_DRIVER, 2, (ULONG_PTR)WdfDeviceWdmGetPhysicalDevice(m_Device), 3, 0);
    }
    else if (Actions & XHCI_RECOVER_INTERNAL_RESET)
    {
        if (KeGetCurrentIrql() != PASSIVE_LEVEL)
        {
            UcxControllerNeedsReset(m_Ucx);
            return;
        }
 
        /* QUIRK: one counter shared by every controller */
        if (InterlockedIncrement(&InlineResets) != 1)
            DPRINT1("Boot path internal resets overlap\n");
        InternalReset();
        InterlockedDecrement(&InlineResets);
    }
    else if (Actions & XHCI_RECOVER_RESET)
    {
        UcxControllerNeedsReset(m_Ucx);
    }
    else
    {
        DPRINT1("Boot path recovery 0x%lx has no handler\n", Actions);
    }
}

ConfigureS0Idle()

VOID XhciController::ConfigureS0Idle ( )

private

Definition at line 761 of file hc.cpp.

{
    D3COLD_SUPPORT_INTERFACE D3Cold;
    DEVICE_WAKE_DEPTH Depth = DeviceWakeDepthNotWakeable;
    NTSTATUS Status;
 
    if (HasErrata(XhciErrata::PwrStayInD0))
    {
        DPRINT1("S0 idle disabled by errata\n");
        m_IdleStatus = IdleStatus::NotConfigured;
        return;
    }
 
    if (HasErrata(XhciErrata::AcpiDsmAllowD3Cold))
        EvaluateDsm(3);
 
    RtlZeroMemory(&D3Cold, sizeof(D3Cold));
    Status = WdfFdoQueryForInterface(m_Device, &XhciGuidD3ColdSupport, (PINTERFACE)&D3Cold,
                                     sizeof(D3Cold), D3COLD_SUPPORT_INTERFACE_VERSION, NULL);
    if (!NT_SUCCESS(Status))
    {
        DPRINT("No D3cold interface 0x%lx, S0 idle off\n", Status);
        m_IdleStatus = IdleStatus::NoS0Wake;
        return;
    }
 
    if (D3Cold.GetIdleWakeInfo != NULL)
    {
        Status = D3Cold.GetIdleWakeInfo(D3Cold.Context, PowerSystemWorking, &Depth);
        if (!NT_SUCCESS(Status))
        {
            DPRINT1("Idle wake information query failed 0x%lx\n", Status);
            Depth = DeviceWakeDepthNotWakeable;
        }
    }
 
    if (D3Cold.InterfaceDereference != NULL)
        D3Cold.InterfaceDereference(D3Cold.Context);
 
    if (Depth <= DeviceWakeDepthD0)
    {
        DPRINT("Controller cannot wake from a Dx state in S0, S0 idle off\n");
        m_IdleStatus = IdleStatus::NoS0Wake;
        return;
    }
 
    m_IdleStatus = IdleStatus::Configured;
    SetIdleTimeout(XHCI_IDLE_TIMEOUT_LONG_MS);
 
    /* ReactOS has no runtime power framework */
    DPRINT("Power framework registration skipped\n");
}

Referenced by Initialize().

CreateWdfObjects()

NTSTATUS XhciController::CreateWdfObjects ( )

private

Definition at line 850 of file hc.cpp.

{
    WDF_TIMER_CONFIG TimerConfig;
    WDF_WORKITEM_CONFIG WorkConfig;
    WDF_OBJECT_ATTRIBUTES Attributes;
    NTSTATUS Status;
 
    WDF_TIMER_CONFIG_INIT_PERIODIC(&TimerConfig, XhciEvtWatchdog, XHCI_WATCHDOG_PERIOD_MS);
    TimerConfig.TolerableDelay = XHCI_WATCHDOG_TOLERANCE_MS;
    TimerConfig.AutomaticSerialization = FALSE;
 
    /* The UCXCONTROLLER is passive; every watchdog step is fine at DISPATCH */
    WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&Attributes, XHCI_OBJECT_CONTEXT);
    Attributes.ParentObject = m_Ucx;
    Attributes.ExecutionLevel = WdfExecutionLevelDispatch;
 
    Status = WdfTimerCreate(&TimerConfig, &Attributes, &m_Watchdog);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Watchdog timer creation failed 0x%lx\n", Status);
        return Status;
    }
    XhciGetObjectContext(m_Watchdog)->Controller = this;
 
    WDF_WORKITEM_CONFIG_INIT(&WorkConfig, XhciEvtIdleTimeoutWork);
    WorkConfig.AutomaticSerialization = FALSE;
    WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&Attributes, XHCI_OBJECT_CONTEXT);
    Attributes.ParentObject = m_Ucx;
 
    Status = WdfWorkItemCreate(&WorkConfig, &Attributes, &m_IdleItem);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Idle timeout work item creation failed 0x%lx\n", Status);
        return Status;
    }
    XhciGetObjectContext(m_IdleItem)->Controller = this;
 
    WDF_WORKITEM_CONFIG_INIT(&WorkConfig, XhciEvtRecoveryWork);
    WorkConfig.AutomaticSerialization = FALSE;
 
    Status = WdfWorkItemCreate(&WorkConfig, &Attributes, &m_RecoveryItem);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Recovery work item creation failed 0x%lx\n", Status);
        return Status;
    }
    XhciGetObjectContext(m_RecoveryItem)->Controller = this;
 
    KeInitializeMutex(&m_RecoveryMutex, 0);
    KeInitializeSpinLock(&m_RecoveryLock);
    m_RecoveryActions = 0;
    return STATUS_SUCCESS;
}

Referenced by Initialize().

D0Entry()

NTSTATUS XhciController::D0Entry

(

_In_ WDF_POWER_DEVICE_STATE

PreviousState

)

Definition at line 1357 of file hc.cpp.

{
    UCX_CONTROLLER_RESET_COMPLETE_INFO ResetInfo;
    BOOLEAN FromHibernate = (m_SystemAction == SystemAction::ResumeFromHibernate);
    BOOLEAN WasReset = FALSE;
    BOOLEAN AllOnes = FALSE;
    BOOLEAN Restore;
    NTSTATUS Status;
 
    if (m_Registers.ReadCapability32(XHCI_CAP_LENGTH_VERSION) == MAXULONG)
    {
        DPRINT1("Controller registers read all ones at D0 entry\n");
        AllOnes = TRUE;
        Status = STATUS_UNSUCCESSFUL;
        goto Exit;
    }
 
    if (FromHibernate)
    {
        /* Without a crash dump stack the firmware owned the controller during resume */
        Status = m_Registers.BiosHandoff();
        if (!NT_SUCCESS(Status))
        {
            DPRINT1("BIOS handoff on hibernate resume failed 0x%lx\n", Status);
            goto Exit;
        }
 
        m_Slots.DiscardState();
 
        Status = m_Registers.Reset();
        if (!NT_SUCCESS(Status))
        {
            DPRINT1("Reset on hibernate resume failed 0x%lx\n", Status);
            goto Exit;
        }
        WasReset = TRUE;
    }
 
    if (!m_FrameSnapshotReady)
        InitFrameSnapshot();
 
    if (HasErrata(XhciErrata::AcpiDsmHsicSuspendDetach))
        EvaluateDsm(5);
 
    Restore = !HasErrata(XhciErrata::PwrSkipSaveRestore) &&
              !m_SaveFailed &&
              PreviousState != WdfPowerDeviceD3Final &&
              !FromHibernate;
 
    Status = RunD0Pass(Restore);
    if (!NT_SUCCESS(Status))
        goto Exit;
 
    if (PreviousState != WdfPowerDeviceD3Final && !FromHibernate)
    {
        if (Restore)
        {
            Status = m_Registers.RestoreState();
            if (!NT_SUCCESS(Status))
            {
                DPRINT1("Controller state restore failed 0x%lx\n", Status);
                m_RestoreFailures++;
                VerifierCheck(XHCI_VERIFY_SAVE_RESTORE);
            }
        }
 
        if (!Restore || !NT_SUCCESS(Status))
        {
            m_Slots.DiscardState();
 
            Status = m_Registers.Reset();
            if (!NT_SUCCESS(Status))
            {
                DPRINT1("Controller reset at D0 entry failed 0x%lx\n", Status);
                goto Exit;
            }
            WasReset = TRUE;
 
            Status = RunD0Pass(FALSE);
            if (!NT_SUCCESS(Status))
                goto Exit;
        }
    }
 
    m_Registers.ApplyD0Workarounds();
    m_RootHub.D0Entry();
    m_PowerState = WdfPowerDeviceD0;
 
    if (WasReset)
    {
        UCX_CONTROLLER_RESET_COMPLETE_INFO_INIT(&ResetInfo, UcxControllerStateLost, FALSE);
        UcxControllerResetComplete(m_Ucx, &ResetInfo);
    }
 
    Status = STATUS_SUCCESS;
 
Exit:
    if (NT_SUCCESS(Status))
    {
        if (m_SystemAction <= SystemAction::ResumeFromHibernate)
        {
            m_SystemAction = SystemAction::None;
 
            if (m_IdleStatus == IdleStatus::Configured && m_LastIdleTimeout != XHCI_IDLE_TIMEOUT_LONG_MS)
                SetIdleTimeout(XHCI_IDLE_TIMEOUT_LONG_MS);
        }
 
        return STATUS_SUCCESS;
    }
 
    m_Slots.DisableAll();
    if (AllOnes)
    {
        SetGone(TRUE);
    }
    else
    {
        QueueRecovery(XHCI_RECOVER_NONE, XHCI_REASON_START_FAILED);
        SetGone(FALSE);
    }
 
    return Status;
}

Referenced by XhciEvtDeviceD0Entry().

D0EntryPostInterruptsEnabled()

NTSTATUS XhciController::D0EntryPostInterruptsEnabled

(

_In_ WDF_POWER_DEVICE_STATE

PreviousState

)

Definition at line 1574 of file hc.cpp.

{
    NTSTATUS Status;
 
    Status = StartController();
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Controller start failed 0x%lx\n", Status);
        return Status;
    }
 
    m_RootHub.PostInterruptsEntry();
    m_Commands.PostInterruptsEntry();
 
    if (PreviousState == WdfPowerDeviceD3Final)
        RunFirmwareCommands();
 
    if (HasErrata(XhciErrata::HostRefuseToStart))
    {
        DPRINT1("Controller is marked as not supported\n");
        return STATUS_NOT_SUPPORTED;
    }
 
    return STATUS_SUCCESS;
}

Referenced by XhciEvtDeviceD0EntryPostInterruptsEnabled().

D0Exit()

VOID XhciController::D0Exit

(

_In_ WDF_POWER_DEVICE_STATE

TargetState

)

Definition at line 1613 of file hc.cpp.

{
    POWER_ACTION Action = WdfDeviceGetSystemPowerAction(m_Device);
    BOOLEAN Save;
    NTSTATUS Status;
 
    m_PowerState = TargetState;
 
    m_Buffers.D0Exit();
    m_RootHub.D0Exit();
 
    WdfTimerStop(m_Watchdog, TRUE);
    Status = m_Registers.Stop();
    if (!NT_SUCCESS(Status))
        DPRINT1("Controller stop at D0 exit failed 0x%lx\n", Status);
 
    m_Interrupters.D0Exit();
 
    Save = !HasErrata(XhciErrata::PwrSkipSaveRestore) &&
           !m_SaveFailed &&
           TargetState != WdfPowerDeviceD3Final &&
           m_SystemAction != SystemAction::Hibernate;
    if (Save)
    {
        Status = m_Registers.SaveState();
        if (!NT_SUCCESS(Status))
        {
            /* QUIRK: one failure turns save and restore off for good */
            DPRINT("Controller state save failed 0x%lx\n", Status);
            m_SaveFailed = TRUE;
            VerifierCheck(XHCI_VERIFY_SAVE_RESTORE);
        }
 
        m_Registers.ProgramSsicPortUnused(TRUE);
        m_Registers.SaveVendorBits();
 
        if (HasErrata(XhciErrata::AcpiDsmHsicSuspendDetach))
            EvaluateDsm(6);
    }
 
    if (HasErrata(XhciErrata::PwrResetBeforeShutdown) && Action == PowerActionShutdownReset)
    {
        Status = m_Registers.ResetController(TRUE);
        if (!NT_SUCCESS(Status))
            DPRINT("Reset before restart failed 0x%lx\n", Status);
    }
 
    WdfWorkItemFlush(m_RecoveryItem);
    WdfWorkItemFlush(m_IdleItem);
}

Referenced by XhciEvtDeviceD0Exit().

D0ExitPreInterruptsDisabled()

VOID XhciController::D0ExitPreInterruptsDisabled

(

)

Definition at line 1604 of file hc.cpp.

{
    if (HasErrata(XhciErrata::AcpiNotifyBeforeIntOff))
        EvaluatePrmi();
 
    m_Interrupters.D0ExitPreInterruptsDisabled();
}

Referenced by XhciEvtDeviceD0ExitPreInterruptsDisabled().

EvaluateDsm()

VOID XhciController::EvaluateDsm ( _In_ ULONG  Function )

private

Definition at line 686 of file hc.cpp.

{
    PACPI_EVAL_INPUT_BUFFER_COMPLEX Input;
    PACPI_METHOD_ARGUMENT Argument;
    ULONG Size;
    ULONG Index;
 
    Size = sizeof(ACPI_EVAL_INPUT_BUFFER_COMPLEX) + sizeof(GUID) - sizeof(ULONG) +
           3 * sizeof(ACPI_METHOD_ARGUMENT);
 
    Input = (PACPI_EVAL_INPUT_BUFFER_COMPLEX)ExAllocatePoolZero(NonPagedPool, Size, XHCI_TAG_CONTROLLER);
    if (Input == NULL)
    {
        DPRINT1("No memory for the _DSM(%lu) call\n", Function);
        return;
    }
 
    Input->Signature = ACPI_EVAL_INPUT_BUFFER_COMPLEX_SIGNATURE;
    Input->MethodNameAsUlong = 'MSD_';
    Input->Size = Size;
    Input->ArgumentCount = 4;
 
    /* UUID, then the function value, then two reserved zeros */
    Argument = &Input->Argument[0];
    ACPI_METHOD_SET_ARGUMENT_BUFFER(Argument, &XhciGuidDsm, sizeof(GUID));
    for (Index = 0; Index < 3; Index++)
    {
        Argument = ACPI_METHOD_NEXT_ARGUMENT(Argument);
        ACPI_METHOD_SET_ARGUMENT_INTEGER(Argument, (Index == 0) ? Function : 0);
    }
 
    XhciEvaluateAcpiMethod(m_Device, Input, Size);
    ExFreePoolWithTag(Input, XHCI_TAG_CONTROLLER);
}

Referenced by ConfigureS0Idle(), D0Entry(), and D0Exit().

EvaluatePrmi()

VOID XhciController::EvaluatePrmi ( )

private

Definition at line 723 of file hc.cpp.

{
    ACPI_EVAL_INPUT_BUFFER Input;
 
    RtlZeroMemory(&Input, sizeof(Input));
    Input.Signature = ACPI_EVAL_INPUT_BUFFER_SIGNATURE;
    Input.MethodNameAsUlong = 'IMRP';
 
    XhciEvaluateAcpiMethod(m_Device, &Input, sizeof(Input));
}

Referenced by D0ExitPreInterruptsDisabled().

FdoCleanup()

VOID XhciController::FdoCleanup

(

)

Definition at line 1229 of file hc.cpp.

{
    PBUS_INTERFACE_STANDARD Bus = &m_Identity.PciInterface;
 
    if (Bus->InterfaceDereference != NULL)
        Bus->InterfaceDereference(Bus->Context);
 
    RtlZeroMemory(Bus, sizeof(*Bus));
}

Referenced by XhciEvtFdoCleanup().

FromDevice()

XhciController * XhciController::FromDevice ( _In_ WDFDEVICE  Device )

static

Definition at line 169 of file hc.cpp.

{
    return XhciGetFdoContext(Device)->Controller;
}

Referenced by XhciEvtDeviceArmWakeFromS0(), XhciEvtDeviceArmWakeFromSx(), XhciEvtDeviceD0Entry(), XhciEvtDeviceD0EntryPostInterruptsEnabled(), XhciEvtDeviceD0Exit(), XhciEvtDeviceD0ExitPreInterruptsDisabled(), XhciEvtDeviceDisarmWakeFromS0(), XhciEvtDeviceDisarmWakeFromSx(), XhciEvtDeviceFilterAddResourceRequirements(), XhciEvtDeviceFilterRemoveResourceRequirements(), XhciEvtDevicePrepareHardware(), XhciEvtDeviceReleaseHardware(), XhciEvtDeviceSelfManagedIoCleanup(), XhciEvtDeviceSelfManagedIoInit(), XhciEvtDeviceUsageNotification(), XhciEvtDeviceWakeFromS0Triggered(), XhciEvtPreprocessInternalIoctl(), and XhciEvtPreprocessSetPower().

FromUcx()

XhciController * XhciController::FromUcx ( _In_ UCXCONTROLLER  UcxController )

static

Definition at line 176 of file hc.cpp.

{
    return XhciGetControllerContext(UcxController);
}

Referenced by XhciEndpoint::Create(), XhciEvtControllerEnableForwardProgress(), XhciEvtControllerGetCurrentFrameNumber(), XhciEvtControllerQueryUsbCapability(), XhciEvtControllerReset(), and XhciEvtControllerUsbDeviceAdd().

HasErrata()

BOOLEAN XhciController::HasErrata ( _In_ XhciErrata  Bit ) const

inline

Definition at line 58 of file hc.h.

    {
        ULONG Position = static_cast<ULONG>(Bit);
 
        if (Position >= 64)
            return (m_ErrataWord2 & (1ULL << (Position - 64))) != 0;
 
        return (m_Errata & XhciErrataBit(Bit)) != 0;
    }

Referenced by XhciRootHub::AcknowledgeResume(), XhciRegisters::ApplyD0Workarounds(), XhciUsbDevice::ApplyUpdate(), XhciRegisters::BiosHandoff(), XhciEndpoint::BuildContext(), XhciTransferRing::BuildLinkTrb(), XhciUsbDevice::BuildSlotContext(), XhciRootHub::ClearUsb20PortFeature(), ConfigureS0Idle(), XhciRegisters::ContiguousFrameId(), XhciRootHub::D0Entry(), D0Entry(), D0EntryPostInterruptsEnabled(), XhciRootHub::D0Exit(), D0Exit(), D0ExitPreInterruptsDisabled(), XhciEndpointMachine::DelaysFirstStop(), XhciEndpoint::DequeueAfterStop(), XhciInterrupters::FilterResourceRequirements(), Initialize(), XhciEndpoint::Initialize(), XhciRootHub::IsHiddenDebugPort(), XhciEndpointMachine::NeedsContextRebuildAfterStop(), XhciEndpointMachine::OnPrimaryInterrupterOnly(), XhciEndpoint::OnTransferEvent(), XhciRegisters::ParseCapabilities(), XhciCommandRing::PlaceLocked(), XhciInterrupters::Prepare(), XhciRegisters::ProgramSsicPortUnused(), XhciRootHub::QueryTunnelState(), QueryUsbCapability(), XhciRegisters::Read64(), XhciUsbDevice::Reset(), XhciEndpoint::ResetStreamTransferLength(), XhciRegisters::RestoreVendorBits(), XhciRootHub::ResuspendResumedPorts(), XhciTransferRing::ReturnSegments(), XhciRegisters::SaveVendorBits(), XhciInterrupters::SecondaryCountFor(), SelfManagedIoInit(), SetPortWake(), XhciRootHub::SetUsb20PortFeature(), XhciRootHub::SetUsb30LinkState(), XhciRootHub::SetWakeEnables(), XhciEndpoint::StreamTransferLength(), XhciUsbDevice::WantsTunnelStateDsm(), and XhciRegisters::Write64().

IdleTimeoutWorker()

VOID XhciController::IdleTimeoutWorker

(

)

Definition at line 822 of file hc.cpp.

{
    SetIdleTimeout(XHCI_IDLE_TIMEOUT_SHORT_MS);
}

InitFrameSnapshot()

VOID XhciController::InitFrameSnapshot ( )

private

Definition at line 1805 of file hc.cpp.

{
    InterlockedExchange64(&m_FrameSnapshot, XhciPackFrameSnapshot(m_Registers.CurrentFrame(1), NowMs()));
    m_FrameSnapshotReady = TRUE;
}

Referenced by D0Entry().

Initialize()

NTSTATUS XhciController::Initialize	(	_In_ WDFDEVICE	Device,
		_In_ UCXCONTROLLER	Ucx,
		_In_ const XhciIdentity *	Identity
	)

Definition at line 905 of file hc.cpp.

{
    WDF_IO_QUEUE_CONFIG QueueConfig;
    WDF_DEVICE_POWER_POLICY_WAKE_SETTINGS WakeSettings;
    NTSTATUS Status;
 
    m_Device = Device;
    m_WdmDevice = WdfDeviceWdmGetDeviceObject(Device);
    m_Ucx = Ucx;
    m_Identity = *Identity;
    m_PowerState = WdfPowerDeviceD3Final;
    m_SystemAction = SystemAction::Boot;
    m_TimeIncrement = KeQueryTimeIncrement();
    m_TestMode = XhciDriver.TestMode;
    m_IdleStatus = IdleStatus::NotConfigured;
 
    if (m_Identity.ParentBus == UcxControllerParentBusTypeAcpi)
    {
        m_Identity.PciVendorId = XHCI_ACPI_PARENT_ID;
        m_Identity.PciDeviceId = XHCI_ACPI_PARENT_ID;
        m_Identity.PciRevisionId = 0;
        m_Identity.PciBus = 0;
        m_Identity.PciDevice = 0;
        m_Identity.PciFunction = 0;
    }
    else
    {
        RtlZeroMemory(m_Identity.AcpiVendorId, sizeof(m_Identity.AcpiVendorId));
        RtlZeroMemory(m_Identity.AcpiDeviceId, sizeof(m_Identity.AcpiDeviceId));
        RtlZeroMemory(m_Identity.AcpiRevisionId, sizeof(m_Identity.AcpiRevisionId));
    }
 
    Status = CreateWdfObjects();
    if (!NT_SUCCESS(Status))
        return Status;
 
    PopulateErrata();
    if (HasErrata(XhciErrata::HostRefuseToStart))
    {
        DPRINT1("Controller is marked as not supported\n");
        return STATUS_NOT_SUPPORTED;
    }
 
    WDF_IO_QUEUE_CONFIG_INIT_DEFAULT_QUEUE(&QueueConfig, WdfIoQueueDispatchSequential);
    QueueConfig.EvtIoDeviceControl = XhciEvtIoDeviceControl;
    Status = WdfIoQueueCreate(m_Device, &QueueConfig, WDF_NO_OBJECT_ATTRIBUTES, WDF_NO_HANDLE);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Default queue creation failed 0x%lx\n", Status);
        return Status;
    }
 
    Status = m_Buffers.Create(this);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Common buffer creation failed 0x%lx\n", Status);
        return Status;
    }
 
    Status = m_Interrupters.Create(this);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Interrupter creation failed 0x%lx\n", Status);
        return Status;
    }
 
    Status = m_Slots.Create(this);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Device slot table creation failed 0x%lx\n", Status);
        return Status;
    }
 
    Status = m_Commands.Create(this);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Command ring creation failed 0x%lx\n", Status);
        return Status;
    }
 
    if (HasErrata(XhciErrata::IntelPchBandwidthCap))
        DPRINT1("Panther Point command filter not implemented, endpoint limit not enforced\n");
 
    Status = m_RootHub.Create(this);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Root hub creation failed 0x%lx\n", Status);
        return Status;
    }
 
    DPRINT("Controller capability WMI block not provided\n");
 
    ConfigureS0Idle();
 
    WDF_DEVICE_POWER_POLICY_WAKE_SETTINGS_INIT(&WakeSettings);
    WakeSettings.Enabled = WdfFalse;
    WakeSettings.ArmForWakeIfChildrenAreArmedForWake = TRUE;
    WakeSettings.IndicateChildWakeOnParentWake = TRUE;
    WakeSettings.UserControlOfWakeSettings = WakeDoNotAllowUserControl;
    Status = WdfDeviceAssignSxWakeSettings(m_Device, &WakeSettings);
    if (!NT_SUCCESS(Status))
        DPRINT1("Sx wake settings refused 0x%lx\n", Status);
 
    return STATUS_SUCCESS;
}

InternalReset()

VOID XhciController::InternalReset ( )

private

Definition at line 2113 of file hc.cpp.

{
    NTSTATUS StopStatus;
    NTSTATUS ResetStatus = STATUS_SUCCESS;
    NTSTATUS Status;
 
    /* QUIRK: overlap is only reported */
    if (InterlockedIncrement(&m_ResetLock) != 1)
        DPRINT1("Controller %p internal reset entered twice\n", this);
 
    InterlockedIncrement(&m_ResetCount);
    m_RecoveryCount++;
 
    WdfTimerStop(m_Watchdog, TRUE);
    m_Commands.PreReset();
    m_Slots.PreReset();
 
    KeFlushQueuedDpcs();
    StopStatus = m_Registers.Stop();
    KeFlushQueuedDpcs();
 
    if (!NT_SUCCESS(StopStatus))
    {
        DPRINT1("Stop before internal reset failed 0x%lx\n", StopStatus);
        DisableController();
    }
    else
    {
        ResetStatus = m_Registers.ResetController(TRUE);
    }
 
    m_Commands.PostReset();
    m_Buffers.PostResetFlush();
    m_Slots.PostReset();
    m_RootHub.PostReset();
 
    if (!NT_SUCCESS(StopStatus))
    {
        VerifierCheck(XHCI_VERIFY_STOP_TIMEOUT);
        QueueRecovery(XHCI_RECOVER_NO_RESTART, XHCI_REASON_STOP_FAILED);
        Status = StopStatus;
    }
    else
    {
        m_Interrupters.PostReset();
 
        if (!NT_SUCCESS(ResetStatus))
        {
            DPRINT1("Internal reset failed 0x%lx\n", ResetStatus);
            VerifierCheck(XHCI_VERIFY_RESET_TIMEOUT);
            QueueRecovery(XHCI_RECOVER_NO_RESTART, XHCI_REASON_RESET_FAILED);
            Status = ResetStatus;
        }
        else
        {
            Status = StartController();
            if (!NT_SUCCESS(Status))
            {
                DPRINT1("Start after internal reset failed 0x%lx\n", Status);
                VerifierCheck(XHCI_VERIFY_START_TIMEOUT);
                QueueRecovery(XHCI_RECOVER_NO_RESTART, XHCI_REASON_RESTART_FAILED);
            }
        }
    }
 
    if (NT_SUCCESS(Status))
    {
        m_Commands.PostResetSuccess();
    }
    else
    {
        DPRINT1("Controller %p internal reset ended with 0x%lx\n", this, Status);
        m_Commands.FailAll();
        UcxControllerSetFailed(m_Ucx);
    }
 
    InterlockedDecrement(&m_ResetLock);
}

Referenced by BootRecovery(), RunRecovery(), and UcxReset().

IsAccessible()

BOOLEAN XhciController::IsAccessible

(

)

const

Registers mapped and the controller not marked gone.

Definition at line 193 of file hc.cpp.

{
    if (!m_Registers.IsMapped() || m_Gone)
    {
        DPRINT("Controller %p not accessible\n", this);
        return FALSE;
    }
 
    return TRUE;
}

Referenced by _IRQL_requires_max_(), XhciUsbDevice::Address(), XhciRegisters::BiosHandoff(), XhciRootHub::ClearPortFeature(), XhciInterrupters::D0Entry(), XhciUsbDevice::Disable(), XhciUsbDevice::Enable(), XhciUsbDevice::EndpointsConfigure(), XhciRootHub::GetPortErrorCount(), XhciRootHub::GetPortStatus(), XhciCommandRing::InitializeRing(), XhciRootHub::InterruptTransfer(), XhciCommandRing::OnTimer(), XhciInterrupters::PostReset(), XhciSlotTable::Program(), XhciCommandRing::Release(), XhciUsbDevice::Reset(), XhciRegisters::ResetController(), XhciRegisters::RestoreState(), XhciRegisters::Run(), XhciRegisters::SaveState(), XhciRootHub::SetPortFeature(), XhciRegisters::Stop(), UcxReset(), XhciUsbDevice::Update(), XhciRegisters::WaitForReady(), and WatchdogTick().

MarkGone()

VOID XhciController::MarkGone

(

)

Definition at line 1924 of file hc.cpp.

{
    SetGone(TRUE);
}

Referenced by XhciRootHub::CheckRunning(), XhciRootHub::GetPortStatus(), XhciRootHub::InterruptTransfer(), and XhciCommandRing::OnTimer().

NowMs()

ULONG64 XhciController::NowMs ( ) const

private

Definition at line 1783 of file hc.cpp.

{
    LARGE_INTEGER Ticks;
 
    KeQueryTickCount(&Ticks);
    return (ULONG64)Ticks.QuadPart * m_TimeIncrement / 10000;
}

Referenced by InitFrameSnapshot().

PopulateErrata()

VOID XhciController::PopulateErrata ( )

private

Definition at line 580 of file hc.cpp.

{
    m_Errata = XhciErrataBit(XhciErrata::BootTolerateBiosHold);
    m_ErrataWord2 = 0;
    QueryErrataDatabase(TRUE);
    ReadRegistryErrata();
    SetInternalFlags();
 
    DPRINT1("Controller %04lx:%04lx rev %02x errata 0x%I64x 0x%I64x internal 0x%I64x\n",
            m_Identity.PciVendorId, m_Identity.PciDeviceId, m_Identity.PciRevisionId,
            m_Errata, m_ErrataWord2, m_InternalFlags);
}

Referenced by Initialize().

PrepareHardware()

NTSTATUS XhciController::PrepareHardware	(	_In_ WDFCMRESLIST	Raw,
		_In_ WDFCMRESLIST	Translated
	)

Definition at line 1254 of file hc.cpp.

{
    NTSTATUS Status;
 
    Status = m_Registers.Prepare(this, Translated);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Register prepare failed 0x%lx\n", Status);
        goto Fail;
    }
 
    Status = m_Buffers.Prepare();
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Common buffer prepare failed 0x%lx\n", Status);
        goto Fail;
    }
 
    Status = m_Interrupters.Prepare(Raw, Translated);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Interrupter prepare failed 0x%lx\n", Status);
        goto Fail;
    }
 
    Status = m_Slots.Prepare();
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Device slot prepare failed 0x%lx\n", Status);
        goto Fail;
    }
 
    Status = m_Commands.Prepare();
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Command ring prepare failed 0x%lx\n", Status);
        goto Fail;
    }
 
    Status = m_RootHub.Prepare();
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Root hub prepare failed 0x%lx\n", Status);
        goto Fail;
    }
 
    return STATUS_SUCCESS;
 
Fail:
    /* Keeps PnP from restarting a controller that cannot start */
    DPRINT1("Controller %p failed to prepare hardware 0x%lx\n", this, Status);
    QueueRecovery(XHCI_RECOVER_REPORT_FAILED, XHCI_REASON_START_FAILED);
    return Status;
}

Referenced by XhciEvtDevicePrepareHardware().

QueryErrataDatabase()

VOID XhciController::QueryErrataDatabase ( _In_ BOOLEAN  AtAddDevice )

private

Definition at line 432 of file hc.cpp.

{
    static const PCWSTR Providers[] = { L"USBXHCI", L"USBXHCI2" };
    PFN_XHCI_QUERY_DEVICE_FLAGS Query = (PFN_XHCI_QUERY_DEVICE_FLAGS)XhciDriver.QueryDeviceFlags;
    PULONG64 Words[] = { &m_Errata, &m_ErrataWord2 };
    WCHAR Keys[7][96];
    ULONG KeyCount;
    ULONG64 Flags;
    BOOLEAN Any = FALSE;
    BOOLEAN Pci = (m_Identity.ParentBus != UcxControllerParentBusTypeAcpi);
    ULONG Provider;
    ULONG Index;
 
    if (Query == NULL)
        return;
 
    /* Keys go from the broadest match to the most specific one */
    RtlStringCchCopyW(Keys[0], RTL_NUMBER_OF(Keys[0]), L"USBXHCI:ALL");
    if (Pci)
    {
        RtlStringCchPrintfW(Keys[1], RTL_NUMBER_OF(Keys[1]), L"USBXHCI:PCI\\VEN_%04X",
                            m_Identity.PciVendorId);
        RtlStringCchPrintfW(Keys[2], RTL_NUMBER_OF(Keys[2]), L"%s&DEV_%04X",
                            Keys[1], m_Identity.PciDeviceId);
        RtlStringCchPrintfW(Keys[3], RTL_NUMBER_OF(Keys[3]), L"%s&REV_%02X",
                            Keys[2], m_Identity.PciRevisionId);
    }
    else
    {
        RtlStringCchPrintfW(Keys[1], RTL_NUMBER_OF(Keys[1]), L"USBXHCI:ACPI\\VEN_%S",
                            m_Identity.AcpiVendorId);
        RtlStringCchPrintfW(Keys[2], RTL_NUMBER_OF(Keys[2]), L"%s&DEV_%S",
                            Keys[1], m_Identity.AcpiDeviceId);
        RtlStringCchPrintfW(Keys[3], RTL_NUMBER_OF(Keys[3]), L"%s&REV_%S",
                            Keys[2], m_Identity.AcpiRevisionId);
    }
    KeyCount = 4;
 
    if (m_Identity.FirmwareVersion != XHCI_FIRMWARE_UNKNOWN)
    {
        RtlStringCchPrintfW(Keys[KeyCount], RTL_NUMBER_OF(Keys[KeyCount]), L"%s&%I64X",
                            Keys[3], m_Identity.FirmwareVersion);
        KeyCount++;
    }
 
    if (Pci)
    {
        RtlStringCchPrintfW(Keys[KeyCount], RTL_NUMBER_OF(Keys[KeyCount]), L"%s&SUBSYS_%04X%04X",
                            Keys[2], m_Identity.PciSubsystemId, m_Identity.PciSubsystemVendorId);
        RtlStringCchPrintfW(Keys[KeyCount + 1], RTL_NUMBER_OF(Keys[KeyCount + 1]), L"%s&REV_%02X",
                            Keys[KeyCount], m_Identity.PciRevisionId);
        KeyCount += 2;
    }
 
    for (Provider = 0; Provider < RTL_NUMBER_OF(Providers); Provider++)
    {
        for (Index = 0; Index < KeyCount; Index++)
        {
            Flags = 0;
            if (!NT_SUCCESS(Query(Keys[Index], Providers[Provider], &Flags)))
                continue;
 
            DPRINT("Errata word %lu 0x%I64x from %S\n", Provider + 1, Flags, Keys[Index]);
            *Words[Provider] |= Flags;
 
            /* The catch all key does not identify this controller */
            if (Index != 0)
                Any = TRUE;
        }
    }
 
    if (!Any)
        DPRINT("No errata database entry for this controller\n");
 
    if (HasErrata(XhciErrata::HostRefuseToStart))
    {
        /* Skip recovery at AddDevice; that device is about to be deleted */
        if (!AtAddDevice)
            QueueRecovery(XHCI_RECOVER_NO_RESTART, XHCI_REASON_NOT_SUPPORTED);
    }
    else if (HasErrata(XhciErrata::HostStaleFirmware))
    {
        DPRINT1("Controller firmware 0x%I64x is outdated\n", m_Identity.FirmwareVersion);
        VerifierCheck(XHCI_VERIFY_FIRMWARE_OUTDATED);
        QueueRecovery(XHCI_RECOVER_NONE, XHCI_REASON_OLD_FIRMWARE);
    }
}

Referenced by PopulateErrata(), and SelfManagedIoInit().

QueryUsbCapability()

NTSTATUS XhciController::QueryUsbCapability	(	_In_ const GUID *	Capability,
		_In_ ULONG	OutputBufferLength,
		_Out_writes_bytes_opt_(OutputBufferLength) PVOID	OutputBuffer,
		_Out_ PULONG	ResultLength
	)

Definition at line 2210 of file hc.cpp.

{
    ULONG Hcc2;
 
    *ResultLength = 0;
 
    if (IsEqualGUID(*Capability, XhciGuidChainedMdls))
        return HasErrata(XhciErrata::XferFlattenMdlChain) ? STATUS_NOT_SUPPORTED : STATUS_SUCCESS;
 
    if (IsEqualGUID(*Capability, XhciGuidStaticStreams))
    {
        *ResultLength = sizeof(USHORT);
        if (OutputBufferLength < sizeof(USHORT))
        {
            DPRINT1("Stream capability buffer of %lu bytes too small\n", OutputBufferLength);
            return STATUS_BUFFER_TOO_SMALL;
        }
        if (OutputBuffer == NULL)
        {
            DPRINT1("Stream capability buffer missing\n");
            return STATUS_INVALID_PARAMETER;
        }
 
        *(PUSHORT)OutputBuffer = (USHORT)m_Registers.SupportedStreams();
        return STATUS_SUCCESS;
    }
 
    if (IsEqualGUID(*Capability, XhciGuidFunctionSuspend) ||
        IsEqualGUID(*Capability, XhciGuidSelectiveSuspend))
    {
        return STATUS_SUCCESS;
    }
 
    if (IsEqualGUID(*Capability, XhciGuidClearTtBufferOnCancel))
        return HasErrata(XhciErrata::XferFlushTtOnAbort) ? STATUS_SUCCESS : STATUS_NOT_SUPPORTED;
 
    if (IsEqualGUID(*Capability, XhciGuidHighBandwidthIsoch))
    {
        *ResultLength = sizeof(ULONG);
        if (OutputBufferLength < sizeof(ULONG))
        {
            DPRINT1("Isoch capability buffer of %lu bytes too small\n", OutputBufferLength);
            return STATUS_BUFFER_TOO_SMALL;
        }
        if (OutputBuffer == NULL)
        {
            DPRINT1("Isoch capability buffer missing\n");
            return STATUS_INVALID_PARAMETER;
        }
 
        Hcc2 = m_Registers.Hccparams2();
        if (!(Hcc2 & XHCI_HCC2_LEC))
            return STATUS_NOT_SUPPORTED;
 
        *(PULONG)OutputBuffer = (Hcc2 & XHCI_HCC2_ETC) ? 32 : 4;
        return STATUS_SUCCESS;
    }
 
    return STATUS_NOT_IMPLEMENTED;
}

Referenced by XhciEvtControllerQueryUsbCapability().

ReadRegistryErrata()

VOID XhciController::ReadRegistryErrata ( )

private

Definition at line 522 of file hc.cpp.

{
    DECLARE_CONST_UNICODE_STRING(ValueName, L"UseStrictBiosHandoff");
    WDFKEY Keys[2] = { NULL, NULL };
    ULONG Value;
    ULONG Index;
    NTSTATUS Status;
 
    Status = WdfDriverOpenParametersRegistryKey(WdfGetDriver(), KEY_READ, WDF_NO_OBJECT_ATTRIBUTES, &Keys[0]);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Driver parameters key open failed 0x%lx\n", Status);
        Keys[0] = NULL;
    }
 
    Status = WdfDeviceOpenRegistryKey(m_Device, PLUGPLAY_REGKEY_DEVICE, KEY_READ, WDF_NO_OBJECT_ATTRIBUTES, &Keys[1]);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Device hardware key open failed 0x%lx\n", Status);
        Keys[1] = NULL;
    }
 
    for (Index = 0; Index < RTL_NUMBER_OF(Keys); Index++)
    {
        if (Keys[Index] == NULL)
            continue;
 
        if (NT_SUCCESS(WdfRegistryQueryULong(Keys[Index], &ValueName, &Value)))
        {
            if (Value == 0)
                m_Errata &= ~XhciErrataBit(XhciErrata::BootStrictBiosRelease);
            else if (Value == 1)
                m_Errata |= XhciErrataBit(XhciErrata::BootStrictBiosRelease);
        }
 
        WdfRegistryClose(Keys[Index]);
    }
}

Referenced by PopulateErrata().

ReadVerifierFlags()

VOID XhciController::ReadVerifierFlags ( )

private

Definition at line 596 of file hc.cpp.

{
    WCHAR Ids[3][24];
    WCHAR Path[160];
    UNICODE_STRING PathString;
    DECLARE_CONST_UNICODE_STRING(ValueName, L"controller");
    PCWSTR Version = (m_Registers.VersionMajor() == 0) ? L"xHCI96" : L"xHCI10";
    ULONG64 Flags = 0;
    ULONG Length;
    ULONG Type;
    WDFKEY Key;
    ULONG Index;
    NTSTATUS Status = STATUS_OBJECT_NAME_NOT_FOUND;
 
    if (m_Identity.ParentBus == UcxControllerParentBusTypeAcpi)
    {
        RtlStringCchPrintfW(Ids[0], RTL_NUMBER_OF(Ids[0]), L"%S%S%S", m_Identity.AcpiVendorId,
                            m_Identity.AcpiDeviceId, m_Identity.AcpiRevisionId);
        RtlStringCchPrintfW(Ids[1], RTL_NUMBER_OF(Ids[1]), L"%S%S", m_Identity.AcpiVendorId,
                            m_Identity.AcpiDeviceId);
    }
    else
    {
        RtlStringCchPrintfW(Ids[0], RTL_NUMBER_OF(Ids[0]), L"%04X%04X%02X", m_Identity.PciVendorId,
                            m_Identity.PciDeviceId, m_Identity.PciRevisionId);
        RtlStringCchPrintfW(Ids[1], RTL_NUMBER_OF(Ids[1]), L"%04X%04X", m_Identity.PciVendorId,
                            m_Identity.PciDeviceId);
    }
    RtlStringCchCopyW(Ids[2], RTL_NUMBER_OF(Ids[2]), L"global");
 
    for (Index = 0; Index < RTL_NUMBER_OF(Ids) && Status == STATUS_OBJECT_NAME_NOT_FOUND; Index++)
    {
        RtlStringCchPrintfW(Path, RTL_NUMBER_OF(Path),
                            L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\usb\\HardwareVerifier\\%s\\%s",
                            Ids[Index], Version);
        RtlInitUnicodeString(&PathString, Path);
 
        Status = WdfRegistryOpenKey(NULL, &PathString, KEY_READ, WDF_NO_OBJECT_ATTRIBUTES, &Key);
        if (!NT_SUCCESS(Status))
            continue;
 
        Status = WdfRegistryQueryValue(Key, &ValueName, sizeof(Flags), &Flags, &Length, &Type);
        WdfRegistryClose(Key);
    }
 
    if (!NT_SUCCESS(Status))
    {
        if (Status != STATUS_OBJECT_NAME_NOT_FOUND)
            DPRINT1("Hardware verifier settings read failed 0x%lx\n", Status);
        Flags = 0;
    }
 
    m_VerifierFlags = (ULONG)Flags;
}

Referenced by SelfManagedIoInit().

RecoveryWorker()

VOID XhciController::RecoveryWorker

(

)

Definition at line 2095 of file hc.cpp.

{
    ULONG Actions;
    KIRQL Irql;
 
    KeWaitForSingleObject(&m_RecoveryMutex, Executive, KernelMode, FALSE, NULL);
 
    KeAcquireSpinLock(&m_RecoveryLock, &Irql);
    Actions = m_RecoveryActions;
    m_RecoveryActions = 0;
    KeReleaseSpinLock(&m_RecoveryLock, Irql);
 
    RunRecovery(Actions);
 
    KeReleaseMutex(&m_RecoveryMutex, FALSE);
}

ReleaseHardware()

VOID XhciController::ReleaseHardware

(

)

Definition at line 1312 of file hc.cpp.

{
    /* D0 exit did not run when D0 entry failed */
    WdfWorkItemFlush(m_RecoveryItem);
    WdfWorkItemFlush(m_IdleItem);
 
    m_RootHub.Release();
    m_Commands.Release();
    m_Slots.Release();
    m_Interrupters.Release();
    m_Buffers.Release();
    m_Registers.Release();
}

Referenced by XhciEvtDeviceReleaseHardware().

RunD0Pass()

NTSTATUS XhciController::RunD0Pass ( _In_ BOOLEAN  Restore )

private

Definition at line 1329 of file hc.cpp.

{
    NTSTATUS Status;
 
    if (Restore)
    {
        m_Registers.ProgramSsicPortUnused(FALSE);
        m_Registers.RestoreVendorBits();
    }
 
    Status = m_Interrupters.D0Entry(Restore);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Interrupter D0 entry failed 0x%lx\n", Status);
        return Status;
    }
 
    m_Slots.D0Entry();
 
    Status = m_Commands.D0Entry();
    if (!NT_SUCCESS(Status))
        DPRINT1("Command ring D0 entry failed 0x%lx\n", Status);
 
    return Status;
}

Referenced by D0Entry().

RunFirmwareCommands()

VOID XhciController::RunFirmwareCommands ( )

private

Definition at line 1536 of file hc.cpp.

{
    BOOLEAN Pci = (m_Identity.ParentBus != UcxControllerParentBusTypeAcpi);
    BOOLEAN Renesas = Pci && (m_Identity.PciVendorId == 0x1033 || m_Identity.PciVendorId == 0x1912);
    BOOLEAN Asmedia = Pci && m_Identity.PciVendorId == 0x1B21;
    BOOLEAN Nvidia;
    ULONG Parameter;
    ULONG64 Version;
 
    Nvidia = !Pci && _strnicmp(m_Identity.AcpiVendorId, "NVDA", 4) == 0;
    if (!Renesas && !Asmedia && !Nvidia)
        return;
 
    m_Identity.FirmwareVersion = XHCI_FIRMWARE_UNKNOWN;
 
    if (Asmedia)
    {
        if (!XhciSendFirmwareCommand(this, static_cast<ULONG>(XhciTrbType::VendorFirmwareVersionAltSetup), &Parameter))
            return;
 
        Version = Parameter;
        if (!XhciSendFirmwareCommand(this, static_cast<ULONG>(XhciTrbType::VendorFirmwareVersionAlt), &Parameter))
            return;
 
        m_Identity.FirmwareVersion = Version | ((ULONG64)Parameter << 24);
    }
    else
    {
        if (!XhciSendFirmwareCommand(this, static_cast<ULONG>(XhciTrbType::VendorFirmwareVersion), &Parameter))
            return;
 
        m_Identity.FirmwareVersion = Parameter & 0xFFFF;
    }
 
    DPRINT1("Controller firmware version 0x%I64x\n", m_Identity.FirmwareVersion);
}

Referenced by D0EntryPostInterruptsEnabled().

RunRecovery()

VOID XhciController::RunRecovery ( _In_ ULONG  Actions )

private

Definition at line 2024 of file hc.cpp.

{
    WDF_DEVICE_STATE State;
 
    if ((Actions & XHCI_RECOVER_RESET) && m_ResetCount > XHCI_RESET_LIMIT)
    {
        DPRINT1("Controller reset %ld times in 5 minutes, giving up\n", m_ResetCount);
        Actions |= XHCI_RECOVER_NO_RESTART;
    }
 
    while (Actions != 0)
    {
        if (Actions & (XHCI_RECOVER_GONE | XHCI_RECOVER_GONE_PNP))
        {
            if (!m_GoneHandled)
            {
                m_GoneHandled = TRUE;
                m_Commands.OnHostLost();
                KeFlushQueuedDpcs();
                m_Buffers.OnHostLost();
                m_Slots.OnHostLost();
                m_RootHub.OnHostLost();
                KeFlushQueuedDpcs();
                UcxControllerSetFailed(m_Ucx);
 
                if (Actions & XHCI_RECOVER_GONE)
                    WdfDeviceSetFailed(m_Device, WdfDeviceFailedNoRestart);
            }
 
            if ((Actions & XHCI_RECOVER_GONE_PNP) && !m_PnpToldRemoved)
            {
                WDF_DEVICE_STATE_INIT(&State);
                State.Removed = WdfTrue;
                WdfDeviceSetDeviceState(m_Device, &State);
                m_PnpToldRemoved = TRUE;
            }
 
            Actions &= ~(XHCI_RECOVER_GONE | XHCI_RECOVER_GONE_PNP | XHCI_RECOVER_INTERNAL_RESET |
                         XHCI_RECOVER_RESET | XHCI_RECOVER_NO_RESTART);
        }
        else if (Actions & XHCI_RECOVER_NO_RESTART)
        {
            DisableController();
            WdfDeviceSetFailed(m_Device, WdfDeviceFailedNoRestart);
            Actions &= ~(XHCI_RECOVER_INTERNAL_RESET | XHCI_RECOVER_RESET | XHCI_RECOVER_NO_RESTART);
        }
        else if (Actions & XHCI_RECOVER_INTERNAL_RESET)
        {
            InternalReset();
            Actions &= ~XHCI_RECOVER_INTERNAL_RESET;
        }
        else if (Actions & XHCI_RECOVER_RESET)
        {
            UcxControllerNeedsReset(m_Ucx);
            Actions &= ~XHCI_RECOVER_RESET;
        }
        else if (Actions & XHCI_RECOVER_REPORT_FAILED)
        {
            WdfDeviceSetFailed(m_Device, WdfDeviceFailedNoRestart);
            Actions &= ~XHCI_RECOVER_REPORT_FAILED;
        }
        else
        {
            DPRINT1("Recovery actions 0x%lx not understood\n", Actions);
            break;
        }
    }
}

Referenced by RecoveryWorker().

SelfManagedIoCleanup()

VOID XhciController::SelfManagedIoCleanup

(

)

Definition at line 1722 of file hc.cpp.

{
    if (m_SplitPadBuffer != NULL)
    {
        m_Buffers.Free(m_SplitPadBuffer);
        m_SplitPadBuffer = NULL;
    }
 
    UpdateRegistryCounters();
}

Referenced by XhciEvtDeviceSelfManagedIoCleanup().

SelfManagedIoInit()

VOID XhciController::SelfManagedIoInit

(

)

Definition at line 1668 of file hc.cpp.

{
    PDEVICE_OBJECT Pdo = WdfDeviceWdmGetPhysicalDevice(m_Device);
 
    if (Pdo->Flags & XHCI_DEVICE_USED_BY_DEBUGGER)
        DPRINT1("Controller shared with the kernel debugger; low power epoch tracking unavailable\n");
 
    DPRINT("Friendly name not set\n");
 
    ReadVerifierFlags();
    QueryErrataDatabase(FALSE);
 
    if (HasErrata(XhciErrata::XferPacketAlignChunks) && m_SplitPadBuffer == NULL)
    {
        m_SplitPadBuffer = m_Buffers.Acquire(XHCI_PAD_BUFFER_SIZE);
        if (m_SplitPadBuffer == NULL)
            DPRINT1("No split transfer pad buffer, transfers run without it\n");
    }
}

Referenced by XhciEvtDeviceSelfManagedIoInit().

SetErrata()

VOID XhciController::SetErrata

(

_In_ XhciErrata

Bit

)

Only bits 0 and 12 may be set after population.

Definition at line 183 of file hc.cpp.

{
    if (Bit != XhciErrata::RegSplit64BitAccess && Bit != XhciErrata::IntPrimaryOnly)
        DPRINT1("Errata bit %lu set after population\n", static_cast<ULONG>(Bit));
 
    m_Errata |= XhciErrataBit(Bit);
}

Referenced by XhciRegisters::ParseCapabilities().

SetIdleTimeout()

VOID XhciController::SetIdleTimeout ( _In_ ULONG  Milliseconds )

private

Definition at line 737 of file hc.cpp.

{
    WDF_DEVICE_POWER_POLICY_IDLE_SETTINGS Settings;
    NTSTATUS Status;
 
    WDF_DEVICE_POWER_POLICY_IDLE_SETTINGS_INIT(&Settings, IdleCanWakeFromS0);
    Settings.UserControlOfIdleSettings = IdleAllowUserControl;
    Settings.IdleTimeout = Milliseconds;
    Settings.IdleTimeoutType = SystemManagedIdleTimeoutWithHint;
 
    Status = WdfDeviceAssignS0IdleSettings(m_Device, &Settings);
    if (!NT_SUCCESS(Status))
    {
        /* QUIRK: a failure downgrades the idle status after the fact */
        DPRINT("Idle timeout %lu ms refused 0x%lx\n", Milliseconds, Status);
        m_IdleStatus = IdleStatus::NoS0Wake;
        return;
    }
 
    m_LastIdleTimeout = Milliseconds;
}

SetInternalFlags()

VOID XhciController::SetInternalFlags ( )

private

Definition at line 562 of file hc.cpp.

{
    ULONG Vendor = m_Identity.PciVendorId;
    ULONG Device = m_Identity.PciDeviceId;
 
    m_InternalFlags = 0;
 
    if (Vendor == 0x1B73 && Device == 0x1100 && m_Identity.PciRevisionId == 0x10)
        m_InternalFlags = FixFrescoShadow;
    else if (Vendor == 0x1B73 && Device == 0x1009)
        m_InternalFlags = FixFrescoControl;
    else if (Vendor == 0x1B6F && Device == 0x7023)
        m_InternalFlags |= FixEtronSet | FixEtronClear;
    else if (Vendor == 0x1B21 && Device >= 0x1040 && Device <= 0x1042)
        m_InternalFlags |= FixAsmediaResetDelay;
}

Referenced by PopulateErrata().

SetPortWake()

VOID XhciController::SetPortWake

(

_In_ BOOLEAN

Arm

)

Definition at line 836 of file hc.cpp.

{
    m_WaitWakeQueued = Arm;
 
    if (!Arm && HasErrata(XhciErrata::PortHoldWakeMaskAwake))
        return;
 
    m_RootHub.SetWakeEnables(Arm);
}

Referenced by XhciEvtDeviceArmWakeFromS0(), and XhciEvtDeviceDisarmWakeFromS0().

StartController()

NTSTATUS XhciController::StartController ( )

private

Definition at line 1483 of file hc.cpp.

{
    NTSTATUS Status;
 
    Status = m_Registers.Run();
    if (!NT_SUCCESS(Status))
        return Status;
 
    WdfTimerStart(m_Watchdog, WDF_REL_TIMEOUT_IN_MS(XHCI_WATCHDOG_PERIOD_MS));
    return STATUS_SUCCESS;
}

Referenced by D0EntryPostInterruptsEnabled(), and InternalReset().

TrackSystemPowerIrp()

VOID XhciController::TrackSystemPowerIrp

(

_In_ PIO_STACK_LOCATION

Stack

)

Definition at line 1746 of file hc.cpp.

{
    SYSTEM_POWER_STATE_CONTEXT Context = Stack->Parameters.Power.SystemPowerStateContext;
 
    switch (Stack->Parameters.Power.State.SystemState)
    {
        case PowerSystemWorking:
            m_SystemAction = (Context.CurrentSystemState == PowerSystemHibernate) ?
                             SystemAction::ResumeFromHibernate : SystemAction::ResumeFromSleep;
            break;
 
        case PowerSystemSleeping1:
        case PowerSystemSleeping2:
        case PowerSystemSleeping3:
            m_SystemAction = (Context.EffectiveSystemState == PowerSystemHibernate) ?
                             SystemAction::HybridSleep : SystemAction::Sleep;
            break;
 
        case PowerSystemHibernate:
            m_SystemAction = SystemAction::Hibernate;
            break;
 
        case PowerSystemShutdown:
            m_SystemAction = (Context.EffectiveSystemState == PowerSystemHibernate) ?
                             SystemAction::Hibernate : SystemAction::Shutdown;
            break;
 
        default:
            DPRINT1("Unexpected system power state %d\n", Stack->Parameters.Power.State.SystemState);
            break;
    }
}

UcxReset()

VOID XhciController::UcxReset

(

)

Definition at line 2193 of file hc.cpp.

{
    UCX_CONTROLLER_RESET_COMPLETE_INFO Info;
 
    if (IsAccessible())
        InternalReset();
    else
        DPRINT1("UCX reset of an inaccessible controller skipped\n");
 
    /* QUIRK: reported even after a failed reset; SetFailed already told UCX */
    UCX_CONTROLLER_RESET_COMPLETE_INFO_INIT(&Info, UcxControllerStateLost, TRUE);
    UcxControllerResetComplete(m_Ucx, &Info);
}

Referenced by XhciEvtControllerReset().

UpdateRegistryCounters()

VOID XhciController::UpdateRegistryCounters ( )

private

Definition at line 1689 of file hc.cpp.

{
    DECLARE_CONST_UNICODE_STRING(RestoreName, L"HCRestoreStateFailureCount");
    DECLARE_CONST_UNICODE_STRING(RecoveryName, L"HCRecoveryCount");
    PCUNICODE_STRING Names[2] = { &RestoreName, &RecoveryName };
    ULONG Counts[2] = { m_RestoreFailures, m_RecoveryCount };
    WDFKEY Key;
    ULONG Value;
    ULONG Index;
    NTSTATUS Status;
 
    Status = WdfDeviceOpenRegistryKey(m_Device, PLUGPLAY_REGKEY_DEVICE, KEY_READ | KEY_WRITE,
                                      WDF_NO_OBJECT_ATTRIBUTES, &Key);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Device key open for the recovery counters failed 0x%lx\n", Status);
        return;
    }
 
    for (Index = 0; Index < RTL_NUMBER_OF(Names); Index++)
    {
        if (!NT_SUCCESS(WdfRegistryQueryULong(Key, Names[Index], &Value)))
            Value = 0;
 
        Status = WdfRegistryAssignULong(Key, Names[Index], Value + Counts[Index]);
        if (!NT_SUCCESS(Status))
            DPRINT1("Writing %wZ failed 0x%lx\n", Names[Index], Status);
    }
 
    WdfRegistryClose(Key);
}

Referenced by SelfManagedIoCleanup().

UsageNotification()

VOID XhciController::UsageNotification	(	_In_ WDF_SPECIAL_FILE_TYPE	Type,
		_In_ BOOLEAN	InPath
	)

Definition at line 1734 of file hc.cpp.

{
    /* No pageable code in this driver, so there is nothing to lock down */
    if (InPath)
        m_SpecialFiles |= 1UL << Type;
    else
        m_SpecialFiles &= ~(1UL << Type);
}

Referenced by XhciEvtDeviceUsageNotification().

WatchdogTick()

VOID XhciController::WatchdogTick

(

)

Definition at line 1848 of file hc.cpp.

{
    ULONG Usbsts;
 
    if (!IsAccessible())
        return;
 
    Usbsts = m_Registers.ReadOperational32(XHCI_OP_USBSTS);
    if (Usbsts == MAXULONG)
    {
        DPRINT1("Watchdog read all ones, controller gone\n");
        SetGone(TRUE);
        return;
    }
 
    /* QUIRK: neither error is cleared here, so each tick reports it again */
    if (Usbsts & XHCI_USBSTS_HSE)
    {
        DPRINT1("Host System Error, USBSTS 0x%08lx\n", Usbsts);
        VerifierCheck(XHCI_VERIFY_HSE);
        QueueRecovery(XHCI_RECOVER_RESET, XHCI_REASON_HOST_SYSTEM_ERROR);
        return;
    }
 
    if (Usbsts & XHCI_USBSTS_HCE)
    {
        DPRINT1("Host Controller Error, USBSTS 0x%08lx\n", Usbsts);
        VerifierCheck(XHCI_VERIFY_HCE);
        QueueRecovery(XHCI_RECOVER_RESET, XHCI_REASON_HOST_CONTROLLER_ERROR);
        return;
    }
 
    if (InterlockedIncrement(&m_ResetInterval) >= XHCI_RESET_WINDOW_TICKS)
    {
        InterlockedExchange(&m_ResetInterval, 0);
        InterlockedExchange(&m_ResetCount, 0);
    }
 
    m_Buffers.Rebalance();
}

Member Data Documentation

m_Buffers

XhciCommonBuffer XhciController::m_Buffers

Definition at line 92 of file hc.h.

Referenced by _IRQL_requires_(), XhciTransferRing::BorrowBounceBuffer(), XhciControlRing::BuildControlTd(), XhciEndpoint::Cleanup(), XhciTransferRing::Cleanup(), XhciUsbDevice::Cleanup(), D0Exit(), XhciEndpoint::DefaultUpdateDone(), XhciEndpoint::DisableRings(), XhciTransferRing::EnsureFreeSegments(), XhciEndpoint::FreeDefaultStreams(), XhciSlotTable::FreeTables(), Initialize(), InternalReset(), XhciEndpoint::OpenStreams(), XhciCommandRing::Prepare(), PrepareHardware(), XhciEndpointMachine::ReconfigureAfterStop(), XhciEndpointMachine::ReconfigureForReset(), XhciCommandRing::Release(), ReleaseHardware(), XhciControlRing::ReleaseResources(), XhciEndpoint::ResetConfigureDone(), XhciEndpoint::ResetDropDone(), RunRecovery(), SelfManagedIoCleanup(), SelfManagedIoInit(), XhciUsbDevice::StartReconfigure(), XhciEndpoint::StopAddDone(), XhciEndpoint::StopDropDone(), XhciEndpoint::StreamsDisableDone(), XhciEndpoint::StreamsEnableDone(), and WatchdogTick().

m_Commands

XhciCommandRing XhciController::m_Commands

Definition at line 95 of file hc.h.

Referenced by XhciEndpoint::ControlResetDone(), D0EntryPostInterruptsEnabled(), XhciEndpoint::DequeueAfterReset(), XhciEndpoint::DequeueAfterStop(), XhciUsbDevice::EndpointsConfigure(), Initialize(), InternalReset(), PrepareHardware(), XhciEndpointMachine::ReconfigureAfterStop(), XhciEndpointMachine::ReconfigureForReset(), ReleaseHardware(), XhciUsbDevice::Reset(), XhciEndpointMachine::ResetDefaultPipe(), XhciEndpoint::ResetDropDone(), XhciEndpointMachine::ResetEndpoint(), RunD0Pass(), RunRecovery(), XhciEndpointMachine::SendStopCommand(), XhciUsbDevice::StartReconfigure(), XhciEndpoint::StopDropDone(), XhciUsbDevice::SubmitAddressDevice(), XhciUsbDevice::SubmitDisableSlot(), XhciUsbDevice::SubmitEnableSlot(), XhciUsbDevice::SubmitSecondConfigure(), and XhciUsbDevice::Update().

m_Device

WDFDEVICE XhciController::m_Device

Definition at line 85 of file hc.h.

Referenced by BootRecovery(), ConfigureS0Idle(), XhciInterrupters::CreateInterrupt(), D0Exit(), EvaluateDsm(), EvaluatePrmi(), Initialize(), XhciUsbDevice::QueueTunnelStateDsm(), ReadRegistryErrata(), RunRecovery(), SelfManagedIoInit(), SetIdleTimeout(), and UpdateRegistryCounters().

m_Errata

ULONG64 XhciController::m_Errata

Definition at line 88 of file hc.h.

Referenced by HasErrata(), PopulateErrata(), QueryErrataDatabase(), ReadRegistryErrata(), and SetErrata().

m_ErrataWord2

ULONG64 XhciController::m_ErrataWord2

Definition at line 89 of file hc.h.

Referenced by HasErrata(), PopulateErrata(), and QueryErrataDatabase().

m_FrameSnapshot

LONG64 XhciController::m_FrameSnapshot

private

Definition at line 265 of file hc.h.

Referenced by InitFrameSnapshot().

m_FrameSnapshotReady

BOOLEAN XhciController::m_FrameSnapshotReady

private

Definition at line 264 of file hc.h.

Referenced by D0Entry(), and InitFrameSnapshot().

m_Gone

BOOLEAN XhciController::m_Gone

private

Definition at line 262 of file hc.h.

Referenced by IsAccessible().

m_GoneHandled

BOOLEAN XhciController::m_GoneHandled

private

Definition at line 284 of file hc.h.

Referenced by RunRecovery().

m_Identity

XhciIdentity XhciController::m_Identity

Who the controller is.

Definition at line 100 of file hc.h.

Referenced by FdoCleanup(), Initialize(), PopulateErrata(), XhciRegisters::ReadFirmwareVersion(), ReadVerifierFlags(), RunFirmwareCommands(), and SetInternalFlags().

m_IdleItem

WDFWORKITEM XhciController::m_IdleItem

private

Definition at line 278 of file hc.h.

Referenced by CreateWdfObjects(), D0Exit(), and ReleaseHardware().

m_IdleStatus

IdleStatus XhciController::m_IdleStatus

private

Definition at line 273 of file hc.h.

Referenced by ConfigureS0Idle(), D0Entry(), Initialize(), and SetIdleTimeout().

m_InternalFlags

ULONG64 XhciController::m_InternalFlags

Definition at line 111 of file hc.h.

Referenced by XhciRegisters::ApplyD0Workarounds(), PopulateErrata(), XhciRegisters::ResetController(), and SetInternalFlags().

m_Interrupters

XhciInterrupters XhciController::m_Interrupters

Definition at line 94 of file hc.h.

Referenced by D0Exit(), D0ExitPreInterruptsDisabled(), Initialize(), InternalReset(), PrepareHardware(), ReleaseHardware(), RunD0Pass(), and XhciTransferRing::UpdateInterrupterTarget().

m_LastIdleTimeout

ULONG XhciController::m_LastIdleTimeout

private

Definition at line 274 of file hc.h.

Referenced by D0Entry(), and SetIdleTimeout().

m_PnpToldRemoved

BOOLEAN XhciController::m_PnpToldRemoved

private

Definition at line 285 of file hc.h.

Referenced by RunRecovery().

m_PowerState

WDF_POWER_DEVICE_STATE XhciController::m_PowerState

D0 only after a successful D0 entry; the target state from D0 exit start.

Definition at line 117 of file hc.h.

Referenced by D0Entry(), XhciRootHub::D0Exit(), D0Exit(), and Initialize().

m_RecoveryActions

ULONG XhciController::m_RecoveryActions

private

Definition at line 282 of file hc.h.

Referenced by CreateWdfObjects(), and RecoveryWorker().

m_RecoveryCount

ULONG XhciController::m_RecoveryCount

private

Definition at line 269 of file hc.h.

Referenced by InternalReset(), and UpdateRegistryCounters().

m_RecoveryItem

WDFWORKITEM XhciController::m_RecoveryItem

private

Definition at line 277 of file hc.h.

Referenced by CreateWdfObjects(), D0Exit(), and ReleaseHardware().

m_RecoveryLock

KSPIN_LOCK XhciController::m_RecoveryLock

private

Definition at line 281 of file hc.h.

Referenced by CreateWdfObjects(), and RecoveryWorker().

m_RecoveryMutex

KMUTEX XhciController::m_RecoveryMutex

private

Definition at line 283 of file hc.h.

Referenced by CreateWdfObjects(), and RecoveryWorker().

m_Registers

XhciRegisters XhciController::m_Registers

Definition at line 91 of file hc.h.

Referenced by _IRQL_requires_(), _IRQL_requires_max_(), XhciEndpoint::BuildEndpointConfigure(), XhciRootHub::CheckRunning(), D0Entry(), D0Exit(), XhciRootHub::DisableLpmForSlot(), XhciRootHub::FillSpeeds(), XhciRootHub::GetPortErrorCount(), XhciRootHub::GetPortStatus(), InitFrameSnapshot(), XhciEndpoint::Initialize(), XhciCommandRing::InitializeRing(), XhciEndpoint::InputEndpointContext(), InternalReset(), IsAccessible(), XhciRootHub::IsHiddenDebugPort(), XhciCommandRing::OnTimer(), XhciEndpoint::OpenStreams(), XhciTransferRing::PacketCount(), XhciRootHub::ParseProtocol(), XhciRootHub::Prepare(), XhciInterrupters::Prepare(), PrepareHardware(), XhciSlotTable::Program(), XhciCommandRing::PutOnRingLocked(), XhciRootHub::QueryTunnelState(), QueryUsbCapability(), XhciRootHub::ReadPortSc(), ReadVerifierFlags(), XhciEndpointMachine::ReconfigureAfterStop(), XhciEndpointMachine::ReconfigureForReset(), XhciCommandRing::Release(), ReleaseHardware(), XhciCommandRing::RestartStoppedRingLocked(), RunD0Pass(), StartController(), XhciTransferRing::TdSize(), XhciRootHub::UpdatePortReg(), XhciRootHub::UpdatePortScLocked(), and WatchdogTick().

m_ReservedIoArmed

BOOLEAN XhciController::m_ReservedIoArmed

Set by UCX through EvtControllerEnableForwardProgress; read by transfer code.

Definition at line 114 of file hc.h.

Referenced by XhciEvtControllerEnableForwardProgress().

m_ResetCount

LONG XhciController::m_ResetCount

private

Definition at line 270 of file hc.h.

Referenced by InternalReset(), RunRecovery(), and WatchdogTick().

m_ResetInterval

LONG XhciController::m_ResetInterval

private

Definition at line 271 of file hc.h.

Referenced by WatchdogTick().

m_ResetLock

LONG XhciController::m_ResetLock

private

Definition at line 272 of file hc.h.

Referenced by InternalReset().

m_RestoreFailures

ULONG XhciController::m_RestoreFailures

private

Definition at line 268 of file hc.h.

Referenced by D0Entry(), and UpdateRegistryCounters().

m_RootHub

XhciRootHub XhciController::m_RootHub

Definition at line 96 of file hc.h.

Referenced by XhciUsbDevice::ApplyUpdate(), D0Entry(), D0EntryPostInterruptsEnabled(), D0Exit(), XhciUsbDevice::Disable(), Initialize(), InternalReset(), PrepareHardware(), ReleaseHardware(), RunRecovery(), SetPortWake(), and XhciEvtDeviceWakeFromS0Triggered().

m_SaveFailed

BOOLEAN XhciController::m_SaveFailed

private

Definition at line 263 of file hc.h.

Referenced by D0Entry(), and D0Exit().

m_Slots

XhciSlotTable XhciController::m_Slots

Definition at line 93 of file hc.h.

Referenced by D0Entry(), XhciUsbDevice::ForgetSlot(), Initialize(), InternalReset(), XhciUsbDevice::OnEnableSlotDone(), PrepareHardware(), ReleaseHardware(), RunD0Pass(), and RunRecovery().

m_SpecialFiles

ULONG XhciController::m_SpecialFiles

private

Definition at line 267 of file hc.h.

Referenced by UsageNotification().

m_SplitPadBuffer

XhciDmaBuffer* XhciController::m_SplitPadBuffer

Errata bit 34 pad buffer, NULL when absent.

Definition at line 134 of file hc.h.

Referenced by SelfManagedIoCleanup(), and SelfManagedIoInit().

m_SystemAction

SystemAction XhciController::m_SystemAction

Definition at line 131 of file hc.h.

Referenced by D0Entry(), XhciRootHub::D0Exit(), D0Exit(), Initialize(), and TrackSystemPowerIrp().

m_TestMode

BOOLEAN XhciController::m_TestMode

Definition at line 204 of file hc.h.

Referenced by Initialize().

m_TimeIncrement

ULONG XhciController::m_TimeIncrement

private

Definition at line 266 of file hc.h.

Referenced by Initialize(), and NowMs().

m_Ucx

UCXCONTROLLER XhciController::m_Ucx

Definition at line 87 of file hc.h.

Referenced by BootRecovery(), CreateWdfObjects(), D0Entry(), XhciCommonBuffer::EnablerCleanup(), Initialize(), InternalReset(), RunRecovery(), and UcxReset().

m_VerifierFlags

ULONG XhciController::m_VerifierFlags

private

Definition at line 261 of file hc.h.

Referenced by ReadVerifierFlags().

m_WaitWakeQueued

BOOLEAN XhciController::m_WaitWakeQueued

Definition at line 203 of file hc.h.

Referenced by SetPortWake(), XhciEvtDeviceArmWakeFromSx(), and XhciEvtDeviceDisarmWakeFromSx().

m_Watchdog

WDFTIMER XhciController::m_Watchdog

private

Definition at line 276 of file hc.h.

Referenced by CreateWdfObjects(), D0Exit(), InternalReset(), and StartController().

m_WdmDevice

PDEVICE_OBJECT XhciController::m_WdmDevice

Definition at line 86 of file hc.h.

Referenced by XhciControlRing::BuildControlTd(), Initialize(), and XhciEndpoint::SendClearStall().

Reason

_In_ ULONG XhciController::Reason

Definition at line 83 of file hc.h.

---

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

• drivers/usb/usbxhci/hc.h
• drivers/usb/usbxhci/hc.cpp