#include <mmio.h>

Collaboration diagram for XhciRegisters:

[legend]

Public Member Functions
NTSTATUS	Prepare (_In_ XhciController *Controller, _In_ WDFCMRESLIST Translated)

VOID	Release ()

NTSTATUS	BiosHandoff ()

NTSTATUS	WaitForReady ()

NTSTATUS	Stop ()

NTSTATUS	Reset ()

NTSTATUS	Run ()

NTSTATUS	SaveState ()

NTSTATUS	RestoreState ()

ULONG	ReadCapability32 (_In_ ULONG Offset) const

ULONG	ReadOperational32 (_In_ ULONG Offset) const

VOID	WriteOperational32 (_In_ ULONG Offset, _In_ ULONG Value)

ULONG64	ReadOperational64 (_In_ ULONG Offset) const

VOID	WriteOperational64 (_In_ ULONG Offset, _In_ ULONG64 Value)

ULONG	ReadRuntime32 (_In_ ULONG Offset) const

VOID	WriteRuntime32 (_In_ ULONG Offset, _In_ ULONG Value)

ULONG64	ReadRuntime64 (_In_ ULONG Offset) const

VOID	WriteRuntime64 (_In_ ULONG Offset, _In_ ULONG64 Value)

VOID	RingDoorbell (_In_ ULONG Index, _In_ ULONG Value)

ULONG	ReadPort32 (_In_ ULONG Port, _In_ ULONG Offset) const

VOID	WritePort32 (_In_ ULONG Port, _In_ ULONG Offset, _In_ ULONG Value)

ULONG	FindExtendedCapability (_In_ ULONG Id, _In_ ULONG Start) const

ULONG	ReadExtended32 (_In_ ULONG Offset) const

VOID	WriteExtended32 (_In_ ULONG Offset, _In_ ULONG Value)

ULONG	MaxSlots () const

ULONG	MaxInterrupters () const

ULONG	MaxPorts () const

ULONG	EventRingSegmentTableMax () const

ULONG	ScratchpadCount () const

ULONG	ContextSize () const

ULONG	PageSize () const

USHORT	InterfaceVersion () const

BOOLEAN	Addressing64 () const

BOOLEAN	ContiguousFrameId () const

ULONG	SupportedStreams () const

ULONG	Hcsparams3 () const

NTSTATUS	ResetController (_In_ BOOLEAN AllowRunning)

BOOLEAN	IsMapped () const

ULONG	CapLength () const

ULONG	Hccparams1 () const

ULONG	Hccparams2 () const

UCHAR	VersionMajor () const

UCHAR	VersionMinor () const

BOOLEAN	MseLengthUsable () const

ULONG	MaxEventRingSegments () const

ULONG	LegacySupportOffset () const

ULONG	DebugCapabilityOffset () const

ULONG	CurrentFrame (_In_ ULONG Increment) const

VOID	ProgramSsicPortUnused (_In_ BOOLEAN PowerDown)

VOID	SaveVendorBits ()

VOID	RestoreVendorBits ()

VOID	ApplyD0Workarounds ()

Private Member Functions
NTSTATUS	MapRegisters (_In_ WDFCMRESLIST Translated)

NTSTATUS	ParseCapabilities ()

VOID	ReadFirmwareVersion ()

BOOLEAN	InRange (_In_ ULONG Offset, _In_ ULONG Size) const

UCHAR	ReadByte (_In_ ULONG Offset) const

VOID	WriteByte (_In_ ULONG Offset, _In_ UCHAR Value)

VOID	ModifyCapability32 (_In_ ULONG Offset, _In_ ULONG Clear, _In_ ULONG Set)

ULONG64	Read64 (_In_ PUCHAR Address) const

VOID	Write64 (_In_ PUCHAR Address, _In_ ULONG64 Value)

NTSTATUS	WaitForStateOperation (_In_ ULONG BusyBit)

NTSTATUS	CheckStateOperationAllowed () const

Detailed Description

Owns the MMIO mapping and every raw register access.

Definition at line 13 of file mmio.h.

Member Function Documentation

◆ Addressing64()

BOOLEAN XhciRegisters::Addressing64 ( ) const

Definition at line 663 of file mmio.cpp.

{
    /* Read live, as the reference does */
    return (ReadCapability32(XHCI_CAP_HCCPARAMS1) & XHCI_HCC1_AC64) != 0;
}

◆ ApplyD0Workarounds()

VOID XhciRegisters::ApplyD0Workarounds ( )

Definition at line 1052 of file mmio.cpp.

{
    ULONG64 Fixes = m_Controller->m_InternalFlags;
 
    if (Fixes & XhciController::FixFrescoControl)
        ModifyCapability32(XHCI_VENDOR_FRESCO_CONTROL, 1UL << 12, 0);
    if (Fixes & XhciController::FixFrescoShadow)
        ModifyCapability32(XHCI_VENDOR_FRESCO_SHADOW, (1UL << 1) | (1UL << 7), 0);
    if (m_Controller->HasErrata(XhciErrata::IntelPchAsyncOrderingFix))
        ModifyCapability32(XHCI_VENDOR_PPT_BULK, 0, 1UL << 21);
    if (Fixes & XhciController::FixEtronSet)
        ModifyCapability32(XHCI_VENDOR_ETRON_CONTROL, 0, 1UL << 15);
    if (Fixes & XhciController::FixEtronClear)
        ModifyCapability32(XHCI_VENDOR_ETRON_CONTROL, 1UL << 23, 0);
 
    if (m_Controller->HasErrata(XhciErrata::PwrTogglePmeEnable))
    {
        ModifyCapability32(XHCI_VENDOR_PME, 0, 1UL << 28);
        KeStallExecutionProcessor(50);
        ModifyCapability32(XHCI_VENDOR_PME, 1UL << 28, 0);
    }
}

Referenced by XhciController::D0Entry().

◆ BiosHandoff()

NTSTATUS XhciRegisters::BiosHandoff ( )

Definition at line 712 of file mmio.cpp.

{
    ULONG Waits;
    NTSTATUS Status;
 
    if (!m_Controller->IsAccessible())
        return STATUS_SUCCESS;
 
    if (m_LegacySupport != 0)
    {
        WriteByte(m_LegacySupport + XHCI_LEGSUP_OS_OWNED_BYTE,
                  ReadByte(m_LegacySupport + XHCI_LEGSUP_OS_OWNED_BYTE) | XHCI_LEGSUP_OWNED);
 
        for (Waits = 0; ReadByte(m_LegacySupport + XHCI_LEGSUP_BIOS_OWNED_BYTE) & XHCI_LEGSUP_OWNED; Waits++)
        {
            if (Waits == XHCI_HANDOFF_WAITS)
            {
                if (!m_Controller->HasErrata(XhciErrata::BootTolerateBiosHold))
                {
                    DPRINT1("BIOS kept ownership of the controller\n");
                    return STATUS_UNSUCCESSFUL;
                }
 
                DPRINT1("BIOS kept ownership of the controller, continuing\n");
                break;
            }
 
            XhciSleepMs(XHCI_HANDOFF_WAIT_MS);
        }
    }
    else
    {
        DPRINT1("No USB legacy support capability, skipping the BIOS handoff\n");
    }
 
    if (!(ReadOperational32(XHCI_OP_USBSTS) & XHCI_USBSTS_HCH))
    {
        if (m_Controller->HasErrata(XhciErrata::BootStrictBiosRelease))
        {
            DPRINT1("Controller still running after the BIOS handoff\n");
            return STATUS_UNSUCCESSFUL;
        }
 
        Status = Stop();
        if (!NT_SUCCESS(Status))
        {
            DPRINT1("Stopping the controller after the BIOS handoff failed 0x%lx\n", Status);
            return Status;
        }
    }
 
    /* Keeps the BIOS SMI handler quiet, notably on S3 resume */
    if (m_LegacySupport != 0)
    {
        ULONG Offset = m_LegacySupport + XHCI_LEGSUP_CTLSTS;
 
        WriteExtended32(Offset, ReadExtended32(Offset) & XHCI_LEGCTLSTS_KEEP_MASK);
    }
 
    return STATUS_SUCCESS;
}

Referenced by XhciController::D0Entry(), and Prepare().

◆ CapLength()

ULONG XhciRegisters::CapLength ( ) const

Definition at line 609 of file mmio.cpp.

{
    return m_CapLength;
}

◆ CheckStateOperationAllowed()

NTSTATUS XhciRegisters::CheckStateOperationAllowed ( ) const

private

Definition at line 914 of file mmio.cpp.

{
    ULONG Usbsts = ReadOperational32(XHCI_OP_USBSTS);
 
    if (!(Usbsts & XHCI_USBSTS_HCH))
    {
        DPRINT1("State save or restore refused, controller running\n");
        return STATUS_ADAPTER_HARDWARE_ERROR;
    }
 
    if (Usbsts & (XHCI_USBSTS_SSS | XHCI_USBSTS_RSS))
    {
        DPRINT1("State save or restore already in progress, USBSTS 0x%08lx\n", Usbsts);
        return STATUS_ADAPTER_HARDWARE_ERROR;
    }
 
    return STATUS_SUCCESS;
}

Referenced by RestoreState(), and SaveState().

◆ ContextSize()

ULONG XhciRegisters::ContextSize ( ) const

Definition at line 651 of file mmio.cpp.

{
    return (m_Hccparams1 & XHCI_HCC1_CSZ) ? 64 : 32;
}

Referenced by XhciEndpoint::BuildEndpointConfigure(), XhciEndpoint::InputEndpointContext(), XhciEndpointMachine::ReconfigureAfterStop(), and XhciEndpointMachine::ReconfigureForReset().

◆ ContiguousFrameId()

BOOLEAN XhciRegisters::ContiguousFrameId ( ) const

Definition at line 670 of file mmio.cpp.

{
    if (m_Controller->HasErrata(XhciErrata::IsochNoFrameIdContinuity))
        return FALSE;
 
    return (m_Hccparams1 & XHCI_HCC1_CFC) != 0;
}

◆ CurrentFrame()

ULONG XhciRegisters::CurrentFrame ( _In_ ULONG Increment ) const

Current 11 bit frame, Increment microframes ahead.

Definition at line 679 of file mmio.cpp.

{
    ULONG Index = ReadRuntime32(XHCI_RT_MFINDEX) & XHCI_MFINDEX_MASK;
 
    return ((Index + Increment) >> 3) & 0x7FF;
}

Referenced by XhciController::InitFrameSnapshot().

◆ DebugCapabilityOffset()

ULONG XhciRegisters::DebugCapabilityOffset ( ) const

Definition at line 645 of file mmio.cpp.

{
    return m_DebugCapability;
}

◆ EventRingSegmentTableMax()

ULONG XhciRegisters::EventRingSegmentTableMax ( ) const

Definition at line 561 of file mmio.cpp.

{
    return m_MaxEventRingSegments;
}

◆ FindExtendedCapability()

ULONG XhciRegisters::FindExtendedCapability	(	_In_ ULONG	Id,
		_In_ ULONG	Start
	)		const

Next extended capability with Id after Start (0 starts at the first); 0 when none.

Definition at line 284 of file mmio.cpp.

{
    ULONG Offset;
    ULONG Header;
    ULONG Next;
 
    if (!m_Mapped || m_ExtendedList == 0)
        return 0;
 
    Offset = (Start == 0) ? m_ExtendedList : Start;
    Header = ReadCapability32(Offset);
 
    /* A given start is skipped; only entries after it are candidates */
    if (Start == 0 && (Header & XHCI_EXTCAP_ID_MASK) == Id)
        return Offset;
 
    for (;;)
    {
        Next = ((Header & XHCI_EXTCAP_NEXT_MASK) >> XHCI_EXTCAP_NEXT_SHIFT) * 4;
        if (Next == 0)
            return 0;
 
        Offset += Next;
        if (Offset >= m_Length)
            return 0;
 
        Header = ReadCapability32(Offset);
        if ((Header & XHCI_EXTCAP_ID_MASK) == Id)
            return Offset;
    }
}

Referenced by ParseCapabilities(), and XhciRootHub::Prepare().

◆ Hccparams1()

ULONG XhciRegisters::Hccparams1 ( ) const

Definition at line 597 of file mmio.cpp.

{
    return m_Hccparams1;
}

◆ Hccparams2()

ULONG XhciRegisters::Hccparams2 ( ) const

Definition at line 603 of file mmio.cpp.

{
    return m_Hccparams2;
}

Referenced by XhciController::QueryUsbCapability().

◆ Hcsparams3()

ULONG XhciRegisters::Hcsparams3 ( ) const

Definition at line 591 of file mmio.cpp.

{
    return m_Hcsparams3;
}

Referenced by XhciRootHub::Prepare().

◆ InRange()

BOOLEAN XhciRegisters::InRange	(	_In_ ULONG	Offset,
		_In_ ULONG	Size
	)		const

private

Definition at line 348 of file mmio.cpp.

{
    return m_Mapped && Offset < m_Length && Size <= m_Length - Offset;
}

Referenced by ModifyCapability32(), ParseCapabilities(), ReadExtended32(), ReadFirmwareVersion(), and WriteExtended32().

◆ InterfaceVersion()

USHORT XhciRegisters::InterfaceVersion ( ) const

Definition at line 657 of file mmio.cpp.

{
    return (USHORT)((m_VersionMajor << 8) | m_VersionMinor);
}

◆ IsMapped()

BOOLEAN XhciRegisters::IsMapped ( ) const

Definition at line 633 of file mmio.cpp.

{
    return m_Mapped;
}

Referenced by XhciController::IsAccessible().

◆ LegacySupportOffset()

ULONG XhciRegisters::LegacySupportOffset ( ) const

Definition at line 639 of file mmio.cpp.

{
    return m_LegacySupport;
}

◆ MapRegisters()

NTSTATUS XhciRegisters::MapRegisters ( _In_ WDFCMRESLIST Translated )

private

Definition at line 57 of file mmio.cpp.

{
    PCM_PARTIAL_RESOURCE_DESCRIPTOR Descriptor;
    ULONG Count = WdfCmResourceListGetCount(Translated);
    ULONG Index;
 
    for (Index = 0; Index < Count; Index++)
    {
        Descriptor = WdfCmResourceListGetDescriptor(Translated, Index);
        if (Descriptor == NULL || Descriptor->Type != CmResourceTypeMemory)
            continue;
 
        /* Only the first memory range is the register BAR */
        m_Base = (PUCHAR)MmMapIoSpace(Descriptor->u.Memory.Start,
                                      Descriptor->u.Memory.Length,
                                      MmNonCached);
        if (m_Base == NULL)
        {
            DPRINT1("Mapping %lu register bytes at 0x%I64x failed\n",
                    Descriptor->u.Memory.Length, Descriptor->u.Memory.Start.QuadPart);
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        m_Length = Descriptor->u.Memory.Length;
        m_Mapped = TRUE;
        return STATUS_SUCCESS;
    }
 
    /* QUIRK: a missing memory resource reports STATUS_UNSUCCESSFUL */
    DPRINT1("No memory resource for the register BAR\n");
    return STATUS_UNSUCCESSFUL;
}

Referenced by Prepare().

◆ MaxEventRingSegments()

ULONG XhciRegisters::MaxEventRingSegments ( ) const

Definition at line 567 of file mmio.cpp.

{
    return m_MaxEventRingSegments;
}

◆ MaxInterrupters()

ULONG XhciRegisters::MaxInterrupters ( ) const

Definition at line 549 of file mmio.cpp.

{
    return m_MaxInterrupters;
}

Referenced by XhciInterrupters::Prepare().

◆ MaxPorts()

ULONG XhciRegisters::MaxPorts ( ) const

Definition at line 555 of file mmio.cpp.

{
    return m_MaxPorts;
}

Referenced by XhciRootHub::Prepare().

◆ MaxSlots()

ULONG XhciRegisters::MaxSlots ( ) const

Definition at line 543 of file mmio.cpp.

{
    return m_MaxSlots;
}

Referenced by _IRQL_requires_().

◆ ModifyCapability32()

VOID XhciRegisters::ModifyCapability32	(	_In_ ULONG	Offset,
		_In_ ULONG	Clear,
		_In_ ULONG	Set
	)

private

Definition at line 371 of file mmio.cpp.

{
    PULONG Register;
 
    if (!InRange(Offset, sizeof(ULONG)))
        return;
 
    Register = (PULONG)(m_Base + Offset);
    WRITE_REGISTER_ULONG(Register, (READ_REGISTER_ULONG(Register) & ~Clear) | Set);
}

Referenced by ApplyD0Workarounds(), ProgramSsicPortUnused(), and RestoreVendorBits().

◆ MseLengthUsable()

BOOLEAN XhciRegisters::MseLengthUsable ( ) const

Definition at line 627 of file mmio.cpp.

{
    return m_MseLengthUsable;
}

◆ PageSize()

ULONG XhciRegisters::PageSize ( ) const

Definition at line 579 of file mmio.cpp.

{
    return PAGE_SIZE;
}

◆ ParseCapabilities()

NTSTATUS XhciRegisters::ParseCapabilities ( )

private

Definition at line 171 of file mmio.cpp.

{
    ULONG Value;
    ULONG Psa;
    ULONG Offset;
 
    ReadFirmwareVersion();
 
    Value = ReadCapability32(XHCI_CAP_LENGTH_VERSION);
    m_CapLength = Value & XHCI_CAPLENGTH_MASK;
    m_VersionMajor = (UCHAR)(Value >> XHCI_HCIVERSION_MAJOR_SHIFT);
    m_VersionMinor = (UCHAR)(Value >> XHCI_HCIVERSION_MINOR_SHIFT);
 
    if (m_VersionMajor == 0)
        m_Controller->SetErrata(XhciErrata::IntPrimaryOnly);
    else if (m_VersionMinor >= 0x10 || m_VersionMajor > 1)
        m_MseLengthUsable = TRUE;
 
    m_Operational = m_Base + m_CapLength;
 
    Value = ReadCapability32(XHCI_CAP_HCSPARAMS1);
    m_MaxSlots = Value & XHCI_HCS1_MAX_SLOTS_MASK;
    m_MaxInterrupters = (Value & XHCI_HCS1_MAX_INTRS_MASK) >> XHCI_HCS1_MAX_INTRS_SHIFT;
    m_MaxPorts = Value >> XHCI_HCS1_MAX_PORTS_SHIFT;
    if (m_MaxSlots == 0)
    {
        DPRINT1("HCSPARAMS1 0x%08lx reports no device slots\n", Value);
        return STATUS_INVALID_PARAMETER;
    }
    if (m_MaxInterrupters == 0 || m_MaxInterrupters > 0x400)
    {
        DPRINT1("HCSPARAMS1 0x%08lx reports %lu interrupters\n", Value, m_MaxInterrupters);
        return STATUS_INVALID_PARAMETER;
    }
    if (m_MaxPorts == 0)
    {
        DPRINT1("HCSPARAMS1 0x%08lx reports no ports\n", Value);
        return STATUS_INVALID_PARAMETER;
    }
 
    Value = ReadCapability32(XHCI_CAP_HCSPARAMS2);
    m_MaxEventRingSegments = 1UL << ((Value & XHCI_HCS2_ERST_MAX_MASK) >> XHCI_HCS2_ERST_MAX_SHIFT);
    m_Scratchpads = (((Value & XHCI_HCS2_SCRATCH_HI_MASK) >> XHCI_HCS2_SCRATCH_HI_SHIFT) << 5) |
                    (Value >> XHCI_HCS2_SCRATCH_LO_SHIFT);
 
    m_Hcsparams3 = ReadCapability32(XHCI_CAP_HCSPARAMS3);
    if ((m_Hcsparams3 & XHCI_HCS3_U1_LATENCY_MASK) > 0x0A)
    {
        DPRINT1("HCSPARAMS3 0x%08lx U1 exit latency out of range\n", m_Hcsparams3);
        return STATUS_INVALID_PARAMETER;
    }
    if ((m_Hcsparams3 >> XHCI_HCS3_U2_LATENCY_SHIFT) > 0x7FF)
    {
        DPRINT1("HCSPARAMS3 0x%08lx U2 exit latency out of range\n", m_Hcsparams3);
        return STATUS_INVALID_PARAMETER;
    }
 
    m_Hccparams1 = ReadCapability32(XHCI_CAP_HCCPARAMS1);
    m_Hccparams2 = (m_CapLength >= 0x20) ? ReadCapability32(XHCI_CAP_HCCPARAMS2) : 0;
 
    /* A 4 KB stream context array holds at most 256 entries */
    Psa = (m_Hccparams1 & XHCI_HCC1_MAX_PSA_MASK) >> XHCI_HCC1_MAX_PSA_SHIFT;
    if (Psa > 7)
        Psa = 7;
    if (Psa == 0 || m_Controller->HasErrata(XhciErrata::StrmUnsupported))
        m_Streams = 0;
    else
        m_Streams = (2UL << Psa) - 1;
 
    Offset = (m_Hccparams1 >> XHCI_HCC1_XECP_SHIFT) * 4;
    if (Offset == 0 || Offset >= m_Length)
    {
        DPRINT1("Extended capability pointer 0x%lx outside the %lu byte BAR\n", Offset, m_Length);
        return STATUS_INVALID_PARAMETER;
    }
    m_ExtendedList = Offset;
    m_LegacySupport = FindExtendedCapability(XHCI_EXTCAP_LEGACY, 0);
    m_DebugCapability = FindExtendedCapability(XHCI_EXTCAP_DEBUG, 0);
 
    /* DBOFF and RTSOFF must fall inside the mapping */
    Offset = ReadCapability32(XHCI_CAP_DBOFF);
    if (Offset == 0 || !InRange(Offset, XHCI_DOORBELL_STRIDE * (m_MaxSlots + 1)))
    {
        DPRINT1("Doorbell offset 0x%lx invalid for a %lu byte BAR\n", Offset, m_Length);
        return STATUS_INVALID_PARAMETER;
    }
    m_Doorbells = m_Base + Offset;
 
    Offset = ReadCapability32(XHCI_CAP_RTSOFF);
    if (Offset == 0 ||
        !InRange(Offset, XHCI_RUNTIME_INTERRUPTER_BASE + XHCI_INTERRUPTER_STRIDE * m_MaxInterrupters))
    {
        DPRINT1("Runtime offset 0x%lx invalid for a %lu byte BAR\n", Offset, m_Length);
        return STATUS_INVALID_PARAMETER;
    }
    m_Runtime = m_Base + Offset;
 
    Value = ReadOperational32(XHCI_OP_PAGESIZE);
    if (Value != XHCI_PAGESIZE_4K)
    {
        DPRINT1("PAGESIZE 0x%lx is not 4 KB only\n", Value);
        return STATUS_INVALID_PARAMETER;
    }
 
    DPRINT("xHCI %x.%02x: %lu slots, %lu interrupters, %lu ports, %lu scratchpads, HCC 0x%08lx/0x%08lx\n",
           m_VersionMajor, m_VersionMinor, m_MaxSlots, m_MaxInterrupters, m_MaxPorts,
           m_Scratchpads, m_Hccparams1, m_Hccparams2);
    return STATUS_SUCCESS;
}

Referenced by Prepare().

◆ Prepare()

NTSTATUS XhciRegisters::Prepare	(	_In_ XhciController *	Controller,
		_In_ WDFCMRESLIST	Translated
	)

Definition at line 92 of file mmio.cpp.

{
    NTSTATUS Status;
 
    m_Controller = Controller;
 
    Status = MapRegisters(Translated);
    if (!NT_SUCCESS(Status))
        return Status;
 
    Status = ParseCapabilities();
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Capability registers rejected 0x%lx\n", Status);
        return Status;
    }
 
    Status = BiosHandoff();
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("BIOS handoff failed 0x%lx\n", Status);
        return Status;
    }
 
    Status = ResetController(FALSE);
    if (!NT_SUCCESS(Status))
        DPRINT1("Initial controller reset failed 0x%lx\n", Status);
 
    return Status;
}

Referenced by XhciController::PrepareHardware().

◆ ProgramSsicPortUnused()

VOID XhciRegisters::ProgramSsicPortUnused ( _In_ BOOLEAN PowerDown )

Definition at line 1004 of file mmio.cpp.

{
    if (!m_Controller->HasErrata(XhciErrata::PortParkIdleSsic))
        return;
 
    ModifyCapability32(XHCI_VENDOR_SSIC_PORT, XHCI_SSIC_PROG_DONE, 0);
    if (PowerDown)
        ModifyCapability32(XHCI_VENDOR_SSIC_PORT, 0, XHCI_SSIC_PROG_UNUSED);
    else
        ModifyCapability32(XHCI_VENDOR_SSIC_PORT, XHCI_SSIC_PROG_UNUSED, 0);
    ModifyCapability32(XHCI_VENDOR_SSIC_PORT, 0, XHCI_SSIC_PROG_DONE);
}

Referenced by XhciController::D0Exit(), ResetController(), and XhciController::RunD0Pass().

◆ Read64()

ULONG64 XhciRegisters::Read64 ( _In_ PUCHAR Address ) const

private

Definition at line 386 of file mmio.cpp.

{
    ULONG Low;
    ULONG High;
 
#ifdef _WIN64
    if (!m_Controller->HasErrata(XhciErrata::RegSplit64BitAccess))
        return READ_REGISTER_ULONG64((PULONG64)Address);
#endif
 
    Low = READ_REGISTER_ULONG((PULONG)Address);
    High = READ_REGISTER_ULONG((PULONG)(Address + sizeof(ULONG)));
    return ((ULONG64)High << 32) | Low;
}

Referenced by ReadOperational64(), and ReadRuntime64().

◆ ReadByte()

UCHAR XhciRegisters::ReadByte ( _In_ ULONG Offset ) const

private

Definition at line 356 of file mmio.cpp.

{
    return READ_REGISTER_UCHAR(m_Base + Offset);
}

Referenced by BiosHandoff().

◆ ReadCapability32()

ULONG XhciRegisters::ReadCapability32 ( _In_ ULONG Offset ) const

Definition at line 421 of file mmio.cpp.

{
    if (!m_Mapped)
        return MAXULONG;
 
    return READ_REGISTER_ULONG((PULONG)(m_Base + Offset));
}

Referenced by Addressing64(), XhciController::D0Entry(), FindExtendedCapability(), ParseCapabilities(), and ReadFirmwareVersion().

◆ ReadExtended32()

ULONG XhciRegisters::ReadExtended32 ( _In_ ULONG Offset ) const

Definition at line 319 of file mmio.cpp.

{
    if (!InRange(Offset, sizeof(ULONG)))
    {
        DPRINT1("Extended capability read at 0x%lx outside the BAR\n", Offset);
        return MAXULONG;
    }
 
    return READ_REGISTER_ULONG((PULONG)(m_Base + Offset));
}

Referenced by BiosHandoff(), XhciRootHub::FillSpeeds(), XhciRootHub::IsHiddenDebugPort(), XhciRootHub::ParseProtocol(), XhciRootHub::Prepare(), XhciRootHub::QueryTunnelState(), and SaveVendorBits().

◆ ReadFirmwareVersion()

VOID XhciRegisters::ReadFirmwareVersion ( )

private

Definition at line 147 of file mmio.cpp.

{
    XhciIdentity* Id = &m_Controller->m_Identity;
    BOOLEAN Qualcomm;
 
    if (Id->FirmwareVersion != XHCI_FIRMWARE_UNKNOWN)
        return;
 
    Qualcomm = (Id->ParentBus == UcxControllerParentBusTypeAcpi &&
                _strnicmp(Id->AcpiVendorId, "QCOM", 4) == 0);
 
    if (Id->PciVendorId == 0x1B6F)
    {
        if (InRange(XHCI_VENDOR_ETRON_FIRMWARE, sizeof(ULONG)))
            Id->FirmwareVersion = ReadCapability32(XHCI_VENDOR_ETRON_FIRMWARE);
    }
    else if (Id->PciVendorId == 0x104C || Qualcomm)
    {
        if (InRange(XHCI_VENDOR_TI_FIRMWARE, sizeof(ULONG)))
            Id->FirmwareVersion = ReadCapability32(XHCI_VENDOR_TI_FIRMWARE) & 0xFFFF;
    }
}

Referenced by ParseCapabilities().

◆ ReadOperational32()

ULONG XhciRegisters::ReadOperational32 ( _In_ ULONG Offset ) const

Definition at line 431 of file mmio.cpp.

{
    if (!m_Mapped)
        return MAXULONG;
 
    return READ_REGISTER_ULONG((PULONG)(m_Operational + Offset));
}

Referenced by BiosHandoff(), XhciRootHub::CheckRunning(), CheckStateOperationAllowed(), ParseCapabilities(), ResetController(), RestoreState(), Run(), SaveState(), Stop(), WaitForReady(), WaitForStateOperation(), and XhciController::WatchdogTick().

◆ ReadOperational64()

ULONG64 XhciRegisters::ReadOperational64 ( _In_ ULONG Offset ) const

Definition at line 450 of file mmio.cpp.

{
    if (!m_Mapped)
        return ~0ULL;
 
    return Read64(m_Operational + Offset);
}

Referenced by XhciCommandRing::OnTimer().

◆ ReadPort32()

ULONG XhciRegisters::ReadPort32	(	_In_ ULONG	Port,
		_In_ ULONG	Offset
	)		const

PORTSC and the three registers after it for a 1 based port number.

Definition at line 516 of file mmio.cpp.

{
    if (!m_Mapped || Port == 0 || Port > m_MaxPorts)
        return MAXULONG;
 
    return READ_REGISTER_ULONG((PULONG)(m_Operational + XHCI_OP_PORT_BASE +
                                        XHCI_OP_PORT_STRIDE * (Port - 1) + Offset));
}

Referenced by XhciRootHub::DisableLpmForSlot(), XhciRootHub::GetPortErrorCount(), XhciRootHub::GetPortStatus(), XhciRootHub::ParseProtocol(), XhciRootHub::ReadPortSc(), and XhciRootHub::UpdatePortReg().

◆ ReadRuntime32()

ULONG XhciRegisters::ReadRuntime32 ( _In_ ULONG Offset ) const

Definition at line 469 of file mmio.cpp.

{
    if (!m_Mapped)
        return MAXULONG;
 
    return READ_REGISTER_ULONG((PULONG)(m_Runtime + Offset));
}

Referenced by CurrentFrame().

◆ ReadRuntime64()

ULONG64 XhciRegisters::ReadRuntime64 ( _In_ ULONG Offset ) const

Definition at line 488 of file mmio.cpp.

{
    if (!m_Mapped)
        return ~0ULL;
 
    return Read64(m_Runtime + Offset);
}

◆ Release()

VOID XhciRegisters::Release ( )

Definition at line 126 of file mmio.cpp.

{
    if (m_Mapped)
    {
        MmUnmapIoSpace(m_Base, m_Length);
        m_Mapped = FALSE;
    }
 
    m_Base = NULL;
    m_Length = 0;
    m_Operational = NULL;
    m_Runtime = NULL;
    m_Doorbells = NULL;
    m_ExtendedList = 0;
    m_LegacySupport = 0;
    m_DebugCapability = 0;
}

Referenced by XhciController::ReleaseHardware().

◆ Reset()

NTSTATUS XhciRegisters::Reset ( )

Definition at line 800 of file mmio.cpp.

{
    return ResetController(FALSE);
}

Referenced by XhciController::D0Entry().

◆ ResetController()

NTSTATUS XhciRegisters::ResetController ( _In_ BOOLEAN AllowRunning )

HCRST sequence. Reset() is this with AllowRunning FALSE.

Definition at line 806 of file mmio.cpp.

{
    ULONG Waits;
    ULONG Step = 1;
    ULONG Elapsed = 0;
    NTSTATUS Status;
 
    if (!m_Controller->IsAccessible())
        return STATUS_SUCCESS;
 
    Status = WaitForReady();
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Controller not ready before reset\n");
        return Status;
    }
 
    if (!AllowRunning && !(ReadOperational32(XHCI_OP_USBSTS) & XHCI_USBSTS_HCH))
    {
        DPRINT1("Reset refused, controller not halted\n");
        return STATUS_UNSUCCESSFUL;
    }
 
    ProgramSsicPortUnused(FALSE);
 
    WriteOperational32(XHCI_OP_USBCMD, XHCI_USBCMD_HCRST);
 
    /* QUIRK: Intel controllers can hang the system if a register is read within 1 ms of HCRST */
    KeStallExecutionProcessor(1000);
 
    for (Waits = 0; ReadOperational32(XHCI_OP_USBCMD) & XHCI_USBCMD_HCRST; Waits++)
    {
        if (Waits == XHCI_RESET_WAITS)
        {
            DPRINT1("Host controller reset did not finish in %lu ms\n", Elapsed);
            return STATUS_UNSUCCESSFUL;
        }
 
        XhciSleepMs(Step);
        Elapsed += Step;
        if (Step < XHCI_RESET_MAX_STEP_MS)
            Step *= 2;
    }
 
    if (Elapsed > XHCI_RESET_SLOW_MS)
        DPRINT1("Host controller reset took %lu ms, over the %u ms limit\n", Elapsed, XHCI_RESET_SLOW_MS);
 
    Status = WaitForReady();
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Controller not ready after reset\n");
        return Status;
    }
 
    if (m_Controller->m_InternalFlags & XhciController::FixAsmediaResetDelay)
        XhciSleepMs(100);
 
    return STATUS_SUCCESS;
}

Referenced by XhciController::D0Exit(), XhciController::InternalReset(), Prepare(), and Reset().

◆ RestoreState()

NTSTATUS XhciRegisters::RestoreState ( )

Definition at line 984 of file mmio.cpp.

{
    NTSTATUS Status;
 
    if (!m_Controller->IsAccessible())
        return STATUS_SUCCESS;
 
    Status = CheckStateOperationAllowed();
    if (!NT_SUCCESS(Status))
        return Status;
 
    /* DNCTRL is not part of the saved state and must be back before CRS */
    WriteOperational32(XHCI_OP_DNCTRL, XHCI_DNCTRL_FUNCTION_WAKE);
    WriteOperational32(XHCI_OP_USBCMD, ReadOperational32(XHCI_OP_USBCMD) | XHCI_USBCMD_CRS);
    return WaitForStateOperation(XHCI_USBSTS_RSS);
}

Referenced by XhciController::D0Entry().

◆ RestoreVendorBits()

VOID XhciRegisters::RestoreVendorBits ( )

Definition at line 1035 of file mmio.cpp.

{
    ULONG Index;
 
    if (!m_Controller->HasErrata(XhciErrata::PwrPreserveVendorRegs))
        return;
 
    for (Index = 0; Index < RTL_NUMBER_OF(XhciVendorBitRegisters); Index++)
    {
        if (m_VendorBits & (1UL << Index))
            ModifyCapability32(XhciVendorBitRegisters[Index], 0, XHCI_VENDOR_SAVED_BIT);
        else
            ModifyCapability32(XhciVendorBitRegisters[Index], XHCI_VENDOR_SAVED_BIT, 0);
    }
}

Referenced by XhciController::RunD0Pass().

◆ RingDoorbell()

VOID XhciRegisters::RingDoorbell	(	_In_ ULONG	Index,
		_In_ ULONG	Value
	)

Definition at line 507 of file mmio.cpp.

{
    if (m_Mapped && Index <= m_MaxSlots)
        WRITE_REGISTER_ULONG((PULONG)(m_Doorbells + Index * XHCI_DOORBELL_STRIDE), Value);
}

Referenced by _IRQL_requires_max_(), XhciCommandRing::PutOnRingLocked(), and XhciCommandRing::RestartStoppedRingLocked().

◆ Run()

NTSTATUS XhciRegisters::Run ( )

Definition at line 868 of file mmio.cpp.

{
    ULONG Command;
    ULONG Index;
 
    if (!m_Controller->IsAccessible())
        return STATUS_SUCCESS;
 
    if (!(ReadOperational32(XHCI_OP_USBSTS) & XHCI_USBSTS_HCH))
    {
        DPRINT1("Start refused, controller not halted\n");
        return STATUS_ADAPTER_HARDWARE_ERROR;
    }
 
    WriteOperational32(XHCI_OP_DNCTRL, XHCI_DNCTRL_FUNCTION_WAKE);
 
    /* QUIRK: HSEE is left as it reads */
    Command = ReadOperational32(XHCI_OP_USBCMD) | XHCI_USBCMD_RS | XHCI_USBCMD_INTE;
    Command &= ~(XHCI_USBCMD_CME | XHCI_USBCMD_ETE);
    if (m_Hccparams2 & XHCI_HCC2_CMC)
        Command |= XHCI_USBCMD_CME;
    if ((m_Hccparams2 & XHCI_HCC2_LEC) && (m_Hccparams2 & XHCI_HCC2_ETC))
        Command |= XHCI_USBCMD_ETE;
    WriteOperational32(XHCI_OP_USBCMD, Command);
 
    for (Index = 0; Index < XHCI_RUN_STALLS; Index++)
    {
        KeStallExecutionProcessor(XHCI_RUN_STALL_US);
        if (!(ReadOperational32(XHCI_OP_USBSTS) & XHCI_USBSTS_HCH))
            return STATUS_SUCCESS;
    }
 
    /* Then poll with 5 ms sleeps */
    for (Index = 0; Index < XHCI_RUN_WAITS; Index++)
    {
        XhciSleepMs(XHCI_RUN_WAIT_MS);
        if (!(ReadOperational32(XHCI_OP_USBSTS) & XHCI_USBSTS_HCH))
            return STATUS_SUCCESS;
    }
 
    /* QUIRK: still halted is only reported */
    DPRINT1("Controller still halted after start, USBSTS 0x%08lx\n", ReadOperational32(XHCI_OP_USBSTS));
    return STATUS_SUCCESS;
}

Referenced by XhciController::StartController().

◆ SaveState()

NTSTATUS XhciRegisters::SaveState ( )

Definition at line 968 of file mmio.cpp.

{
    NTSTATUS Status;
 
    if (!m_Controller->IsAccessible())
        return STATUS_SUCCESS;
 
    Status = CheckStateOperationAllowed();
    if (!NT_SUCCESS(Status))
        return Status;
 
    WriteOperational32(XHCI_OP_USBCMD, ReadOperational32(XHCI_OP_USBCMD) | XHCI_USBCMD_CSS);
    return WaitForStateOperation(XHCI_USBSTS_SSS);
}

Referenced by XhciController::D0Exit().

◆ SaveVendorBits()

VOID XhciRegisters::SaveVendorBits ( )

Definition at line 1019 of file mmio.cpp.

{
    ULONG Index;
 
    if (!m_Controller->HasErrata(XhciErrata::PwrPreserveVendorRegs))
        return;
 
    m_VendorBits = 0;
    for (Index = 0; Index < RTL_NUMBER_OF(XhciVendorBitRegisters); Index++)
    {
        if (ReadExtended32(XhciVendorBitRegisters[Index]) & XHCI_VENDOR_SAVED_BIT)
            m_VendorBits |= 1UL << Index;
    }
}

Referenced by XhciController::D0Exit().

◆ ScratchpadCount()

ULONG XhciRegisters::ScratchpadCount ( ) const

Definition at line 573 of file mmio.cpp.

{
    return m_Scratchpads;
}

Referenced by _IRQL_requires_().

◆ Stop()

NTSTATUS XhciRegisters::Stop ( )

Definition at line 775 of file mmio.cpp.

{
    ULONG Waits;
 
    if (!m_Controller->IsAccessible())
        return STATUS_SUCCESS;
 
    WriteOperational32(XHCI_OP_USBCMD, ReadOperational32(XHCI_OP_USBCMD) & ~XHCI_USBCMD_RS);
 
    /* QUIRK: each 1 ms wait lasts a full timer tick */
    for (Waits = 0; !(ReadOperational32(XHCI_OP_USBSTS) & XHCI_USBSTS_HCH); Waits++)
    {
        if (Waits == XHCI_HALT_WAITS)
        {
            DPRINT1("Controller did not halt, USBSTS 0x%08lx\n", ReadOperational32(XHCI_OP_USBSTS));
            return STATUS_UNSUCCESSFUL;
        }
 
        XhciSleepMs(1);
    }
 
    return STATUS_SUCCESS;
}

Referenced by BiosHandoff(), XhciController::D0Exit(), and XhciController::InternalReset().

◆ SupportedStreams()

ULONG XhciRegisters::SupportedStreams ( ) const

Definition at line 585 of file mmio.cpp.

{
    return m_Streams;
}

Referenced by XhciEndpoint::Initialize(), XhciEndpoint::OpenStreams(), and XhciController::QueryUsbCapability().

◆ VersionMajor()

UCHAR XhciRegisters::VersionMajor ( ) const

Definition at line 615 of file mmio.cpp.

{
    return m_VersionMajor;
}

Referenced by XhciTransferRing::PacketCount(), XhciController::ReadVerifierFlags(), and XhciTransferRing::TdSize().

◆ VersionMinor()

UCHAR XhciRegisters::VersionMinor ( ) const

Definition at line 621 of file mmio.cpp.

{
    return m_VersionMinor;
}

◆ WaitForReady()

NTSTATUS XhciRegisters::WaitForReady ( )

Definition at line 690 of file mmio.cpp.

{
    ULONG Waits;
 
    if (!m_Controller->IsAccessible())
        return STATUS_SUCCESS;
 
    for (Waits = 0; ReadOperational32(XHCI_OP_USBSTS) & XHCI_USBSTS_CNR; Waits++)
    {
        if (Waits == XHCI_CNR_WAITS)
        {
            DPRINT1("Controller Not Ready still set after %lu ms\n", XHCI_CNR_WAITS * XHCI_CNR_WAIT_MS);
            return STATUS_UNSUCCESSFUL;
        }
 
        XhciSleepMs(XHCI_CNR_WAIT_MS);
    }
 
    return STATUS_SUCCESS;
}

Referenced by ResetController().

◆ WaitForStateOperation()

NTSTATUS XhciRegisters::WaitForStateOperation ( _In_ ULONG BusyBit )

private

Polls USBSTS for a save or restore to finish.

Definition at line 934 of file mmio.cpp.

{
    LARGE_INTEGER Interval;
    ULONG Usbsts;
    ULONG Waits = 0;
 
    Interval.QuadPart = -2000;
 
    for (;;)
    {
        Usbsts = ReadOperational32(XHCI_OP_USBSTS);
        if (Usbsts & XHCI_USBSTS_SRE)
        {
            DPRINT1("Save/Restore Error reported, USBSTS 0x%08lx\n", Usbsts);
            WriteOperational32(XHCI_OP_USBSTS, XHCI_USBSTS_SRE);
            return STATUS_ADAPTER_HARDWARE_ERROR;
        }
 
        if (!(Usbsts & BusyBit))
            return STATUS_SUCCESS;
 
        if (Waits == XHCI_STATE_WAITS)
        {
            DPRINT1("State save or restore timed out, USBSTS 0x%08lx\n", Usbsts);
            return STATUS_ADAPTER_HARDWARE_ERROR;
        }
 
        Waits++;
        KeDelayExecutionThread(KernelMode, FALSE, &Interval);
    }
}

Referenced by RestoreState(), and SaveState().

◆ Write64()

VOID XhciRegisters::Write64	(	_In_ PUCHAR	Address,
		_In_ ULONG64	Value
	)

private

Definition at line 403 of file mmio.cpp.

{
#ifdef _WIN64
    if (!m_Controller->HasErrata(XhciErrata::RegSplit64BitAccess))
    {
        WRITE_REGISTER_ULONG64((PULONG64)Address, Value);
        return;
    }
#endif
 
    /* Low dword first; CRCR, ERSTBA and ERDP latch on the high dword write */
    WRITE_REGISTER_ULONG((PULONG)Address, (ULONG)Value);
    WRITE_REGISTER_ULONG((PULONG)(Address + sizeof(ULONG)), (ULONG)(Value >> 32));
}

Referenced by WriteOperational64(), and WriteRuntime64().

◆ WriteByte()

VOID XhciRegisters::WriteByte	(	_In_ ULONG	Offset,
		_In_ UCHAR	Value
	)

private

Definition at line 363 of file mmio.cpp.

{
    WRITE_REGISTER_UCHAR(m_Base + Offset, Value);
}

Referenced by BiosHandoff().

◆ WriteExtended32()

VOID XhciRegisters::WriteExtended32	(	_In_ ULONG	Offset,
		_In_ ULONG	Value
	)

Definition at line 332 of file mmio.cpp.

{
    if (!InRange(Offset, sizeof(ULONG)))
    {
        DPRINT1("Extended capability write at 0x%lx outside the BAR\n", Offset);
        return;
    }
 
    WRITE_REGISTER_ULONG((PULONG)(m_Base + Offset), Value);
}

Referenced by BiosHandoff().

◆ WriteOperational32()

VOID XhciRegisters::WriteOperational32	(	_In_ ULONG	Offset,
		_In_ ULONG	Value
	)

Definition at line 441 of file mmio.cpp.

{
    if (m_Mapped)
        WRITE_REGISTER_ULONG((PULONG)(m_Operational + Offset), Value);
}

Referenced by XhciSlotTable::Program(), ResetController(), RestoreState(), Run(), SaveState(), Stop(), and WaitForStateOperation().

◆ WriteOperational64()

VOID XhciRegisters::WriteOperational64	(	_In_ ULONG	Offset,
		_In_ ULONG64	Value
	)

Definition at line 460 of file mmio.cpp.

{
    if (m_Mapped)
        Write64(m_Operational + Offset, Value);
}

Referenced by XhciCommandRing::InitializeRing(), XhciCommandRing::OnTimer(), XhciSlotTable::Program(), XhciCommandRing::Release(), and XhciCommandRing::RestartStoppedRingLocked().

◆ WritePort32()

VOID XhciRegisters::WritePort32	(	_In_ ULONG	Port,
		_In_ ULONG	Offset,
		_In_ ULONG	Value
	)

Definition at line 528 of file mmio.cpp.

{
    if (!m_Mapped || Port == 0 || Port > m_MaxPorts)
        return;
 
    WRITE_REGISTER_ULONG((PULONG)(m_Operational + XHCI_OP_PORT_BASE +
                                  XHCI_OP_PORT_STRIDE * (Port - 1) + Offset), Value);
}

Referenced by XhciRootHub::UpdatePortReg(), and XhciRootHub::UpdatePortScLocked().

◆ WriteRuntime32()

VOID XhciRegisters::WriteRuntime32	(	_In_ ULONG	Offset,
		_In_ ULONG	Value
	)

Definition at line 479 of file mmio.cpp.

{
    if (m_Mapped)
        WRITE_REGISTER_ULONG((PULONG)(m_Runtime + Offset), Value);
}

◆ WriteRuntime64()

VOID XhciRegisters::WriteRuntime64	(	_In_ ULONG	Offset,
		_In_ ULONG64	Value
	)

Definition at line 498 of file mmio.cpp.

{
    if (m_Mapped)
        Write64(m_Runtime + Offset, Value);
}

Member Data Documentation

◆ m_Base

PUCHAR XhciRegisters::m_Base

private

Definition at line 183 of file mmio.h.

Referenced by MapRegisters(), ModifyCapability32(), ParseCapabilities(), ReadByte(), ReadCapability32(), ReadExtended32(), Release(), WriteByte(), and WriteExtended32().

◆ m_CapLength

ULONG XhciRegisters::m_CapLength

private

Definition at line 194 of file mmio.h.

Referenced by CapLength(), and ParseCapabilities().

◆ m_Controller

XhciController* XhciRegisters::m_Controller

private

Definition at line 182 of file mmio.h.

Referenced by ApplyD0Workarounds(), BiosHandoff(), ContiguousFrameId(), ParseCapabilities(), Prepare(), ProgramSsicPortUnused(), Read64(), ReadFirmwareVersion(), ResetController(), RestoreState(), RestoreVendorBits(), Run(), SaveState(), SaveVendorBits(), Stop(), WaitForReady(), and Write64().

◆ m_DebugCapability

ULONG XhciRegisters::m_DebugCapability

private

Definition at line 192 of file mmio.h.

Referenced by DebugCapabilityOffset(), ParseCapabilities(), and Release().

◆ m_Doorbells

PUCHAR XhciRegisters::m_Doorbells

private

Definition at line 188 of file mmio.h.

Referenced by ParseCapabilities(), Release(), and RingDoorbell().

◆ m_ExtendedList

ULONG XhciRegisters::m_ExtendedList

private

Definition at line 190 of file mmio.h.

Referenced by FindExtendedCapability(), ParseCapabilities(), and Release().

◆ m_Hccparams1

ULONG XhciRegisters::m_Hccparams1

private

Definition at line 204 of file mmio.h.

Referenced by ContextSize(), ContiguousFrameId(), Hccparams1(), and ParseCapabilities().

◆ m_Hccparams2

ULONG XhciRegisters::m_Hccparams2

private

Definition at line 205 of file mmio.h.

Referenced by Hccparams2(), ParseCapabilities(), and Run().

◆ m_Hcsparams3

ULONG XhciRegisters::m_Hcsparams3

private

Definition at line 203 of file mmio.h.

Referenced by Hcsparams3(), and ParseCapabilities().

◆ m_LegacySupport

ULONG XhciRegisters::m_LegacySupport

private

Definition at line 191 of file mmio.h.

Referenced by BiosHandoff(), LegacySupportOffset(), ParseCapabilities(), and Release().

◆ m_Length

ULONG XhciRegisters::m_Length

private

Definition at line 184 of file mmio.h.

Referenced by FindExtendedCapability(), InRange(), MapRegisters(), ParseCapabilities(), and Release().

◆ m_Mapped

BOOLEAN XhciRegisters::m_Mapped

private

Definition at line 185 of file mmio.h.

Referenced by FindExtendedCapability(), InRange(), IsMapped(), MapRegisters(), ReadCapability32(), ReadOperational32(), ReadOperational64(), ReadPort32(), ReadRuntime32(), ReadRuntime64(), Release(), RingDoorbell(), WriteOperational32(), WriteOperational64(), WritePort32(), WriteRuntime32(), and WriteRuntime64().

◆ m_MaxEventRingSegments

ULONG XhciRegisters::m_MaxEventRingSegments

private

Definition at line 201 of file mmio.h.

Referenced by EventRingSegmentTableMax(), MaxEventRingSegments(), and ParseCapabilities().

◆ m_MaxInterrupters

ULONG XhciRegisters::m_MaxInterrupters

private

Definition at line 199 of file mmio.h.

Referenced by MaxInterrupters(), and ParseCapabilities().

◆ m_MaxPorts

ULONG XhciRegisters::m_MaxPorts

private

Definition at line 200 of file mmio.h.

Referenced by MaxPorts(), ParseCapabilities(), ReadPort32(), and WritePort32().

◆ m_MaxSlots

ULONG XhciRegisters::m_MaxSlots

private

Definition at line 198 of file mmio.h.

Referenced by MaxSlots(), ParseCapabilities(), and RingDoorbell().

◆ m_MseLengthUsable

BOOLEAN XhciRegisters::m_MseLengthUsable

private

Definition at line 197 of file mmio.h.

Referenced by MseLengthUsable(), and ParseCapabilities().

◆ m_Operational

PUCHAR XhciRegisters::m_Operational

private

Definition at line 186 of file mmio.h.

Referenced by ParseCapabilities(), ReadOperational32(), ReadOperational64(), ReadPort32(), Release(), WriteOperational32(), WriteOperational64(), and WritePort32().

◆ m_Runtime

PUCHAR XhciRegisters::m_Runtime

private

Definition at line 187 of file mmio.h.

Referenced by ParseCapabilities(), ReadRuntime32(), ReadRuntime64(), Release(), WriteRuntime32(), and WriteRuntime64().

◆ m_Scratchpads

ULONG XhciRegisters::m_Scratchpads

private

Definition at line 202 of file mmio.h.

Referenced by ParseCapabilities(), and ScratchpadCount().

◆ m_Streams

ULONG XhciRegisters::m_Streams

private

Definition at line 206 of file mmio.h.

Referenced by ParseCapabilities(), and SupportedStreams().

◆ m_VendorBits

ULONG XhciRegisters::m_VendorBits

private

Bit 25 of the three errata 55 registers, one bit each.

Definition at line 209 of file mmio.h.

Referenced by RestoreVendorBits(), and SaveVendorBits().

◆ m_VersionMajor

UCHAR XhciRegisters::m_VersionMajor

private

Definition at line 195 of file mmio.h.

Referenced by InterfaceVersion(), ParseCapabilities(), and VersionMajor().

◆ m_VersionMinor

UCHAR XhciRegisters::m_VersionMinor

private

Definition at line 196 of file mmio.h.

Referenced by InterfaceVersion(), ParseCapabilities(), and VersionMinor().

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

drivers/usb/usbxhci/mmio.h
drivers/usb/usbxhci/mmio.cpp

Private Attributes
XhciController *	m_Controller

PUCHAR	m_Base

ULONG	m_Length

BOOLEAN	m_Mapped

PUCHAR	m_Operational

PUCHAR	m_Runtime

PUCHAR	m_Doorbells

ULONG	m_ExtendedList

ULONG	m_LegacySupport

ULONG	m_DebugCapability

ULONG	m_CapLength

UCHAR	m_VersionMajor

UCHAR	m_VersionMinor

BOOLEAN	m_MseLengthUsable

ULONG	m_MaxSlots

ULONG	m_MaxInterrupters

ULONG	m_MaxPorts

ULONG	m_MaxEventRingSegments

ULONG	m_Scratchpads

ULONG	m_Hcsparams3

ULONG	m_Hccparams1

ULONG	m_Hccparams2

ULONG	m_Streams

ULONG	m_VendorBits

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Function Documentation

◆ Addressing64()

◆ ApplyD0Workarounds()

◆ BiosHandoff()

◆ CapLength()

◆ CheckStateOperationAllowed()

◆ ContextSize()

◆ ContiguousFrameId()

◆ CurrentFrame()

◆ DebugCapabilityOffset()

◆ EventRingSegmentTableMax()

◆ FindExtendedCapability()

◆ Hccparams1()

◆ Hccparams2()

◆ Hcsparams3()

◆ InRange()

◆ InterfaceVersion()

◆ IsMapped()

◆ LegacySupportOffset()

◆ MapRegisters()

◆ MaxEventRingSegments()

◆ MaxInterrupters()

◆ MaxPorts()

◆ MaxSlots()

◆ ModifyCapability32()

◆ MseLengthUsable()

◆ PageSize()

◆ ParseCapabilities()

◆ Prepare()

◆ ProgramSsicPortUnused()

◆ Read64()

◆ ReadByte()

◆ ReadCapability32()

◆ ReadExtended32()

◆ ReadFirmwareVersion()

◆ ReadOperational32()

◆ ReadOperational64()

◆ ReadPort32()

◆ ReadRuntime32()

◆ ReadRuntime64()

◆ Release()

◆ Reset()

◆ ResetController()

◆ RestoreState()

◆ RestoreVendorBits()

◆ RingDoorbell()

◆ Run()

◆ SaveState()

◆ SaveVendorBits()

◆ ScratchpadCount()

◆ Stop()

◆ SupportedStreams()

◆ VersionMajor()

◆ VersionMinor()

◆ WaitForReady()

◆ WaitForStateOperation()

◆ Write64()

◆ WriteByte()

◆ WriteExtended32()

◆ WriteOperational32()

◆ WriteOperational64()

◆ WritePort32()

◆ WriteRuntime32()

◆ WriteRuntime64()

Member Data Documentation

◆ m_Base

◆ m_CapLength

◆ m_Controller

◆ m_DebugCapability

◆ m_Doorbells

◆ m_ExtendedList

◆ m_Hccparams1

◆ m_Hccparams2

◆ m_Hcsparams3

◆ m_LegacySupport

◆ m_Length