XhciInterrupters Class Reference

#include <intr.h>

Collaboration diagram for XhciInterrupters:

Classes
struct	Interrupter

Public Member Functions
NTSTATUS	Create (_In_ XhciController *Controller)
NTSTATUS	FilterResourceRequirements (_In_ WDFIORESREQLIST Requirements)
NTSTATUS	Prepare (_In_ WDFCMRESLIST Raw, _In_ WDFCMRESLIST Translated)
VOID	Release ()
NTSTATUS	D0Entry (_In_ BOOLEAN StatePreserved)
VOID	D0ExitPreInterruptsDisabled ()
VOID	D0Exit ()
VOID	PostReset ()
ULONG	Count () const
ULONG	TargetForCurrentProcessor () const
ULONG	TargetForProcessor (_In_ ULONG ProcessorIndex) const
NTSTATUS	AffinitizeResourceRequirements (_In_ WDFIORESREQLIST Requirements)

Private Types
enum class	Mechanism : ULONG { Line , Msi , MsiX }

Private Member Functions
NTSTATUS	PrepareOne (_Inout_ Interrupter *Entry, _In_ WDFINTERRUPT Interrupt, _In_ ULONG Index, _In_ BOOLEAN MessageSignaled)
VOID	ReleaseOne (_Inout_ Interrupter *Entry)
NTSTATUS	CreateInterrupt (_In_opt_ PCM_PARTIAL_RESOURCE_DESCRIPTOR Raw, _In_opt_ PCM_PARTIAL_RESOURCE_DESCRIPTOR Translated, _Out_ WDFINTERRUPT *Interrupt)
ULONG	SecondaryCountFor (_In_ ULONG Messages) const
NTSTATUS	BuildLookup ()

Private Attributes
XhciController *	m_Controller
WDFINTERRUPT	m_PrimaryInterrupt
Mechanism	m_Mechanism
ULONG	m_SecondaryCount
ULONG	m_Count
ULONG	m_Capacity
Interrupter *	m_Table
PUSHORT	m_Lookup
ULONG	m_LookupSize

Detailed Description

All interrupters of a controller.

Definition at line 13 of file intr.h.

Member Enumeration Documentation

Mechanism

enum class XhciInterrupters::Mechanism : ULONG

strongprivate

Enumerator
Line
Msi
MsiX

Definition at line 88 of file intr.h.

    {
        Line,
        Msi,
        MsiX
    };

Member Function Documentation

AffinitizeResourceRequirements()

NTSTATUS XhciInterrupters::AffinitizeResourceRequirements

(

_In_ WDFIORESREQLIST

Requirements

)

Called from EvtDeviceFilterAddResourceRequirements.

Definition at line 952 of file intr.cpp.

{
    WDFIORESLIST List;
    PIO_RESOURCE_DESCRIPTOR Descriptor;
    IO_RESOURCE_DESCRIPTOR Pinned;
    ULONG ListIndex;
    ULONG Messages;
    ULONG PerInterrupter;
    ULONG NextProcessor = 0;
    ULONG Index;
    ULONG Step;
    BOOLEAN Primary = TRUE;
 
    PAGED_CODE();
 
    if (m_SecondaryCount == 0)
        return STATUS_SUCCESS;
 
    if (!XhciFindMessageList(Requirements, &ListIndex, &Messages))
    {
        DPRINT1("Secondary interrupters planned but no MSI-X list found\n");
        return STATUS_SUCCESS;
    }
 
    PerInterrupter = XhciActiveProcessors(0) / m_SecondaryCount;
    List = WdfIoResourceRequirementsListGetIoResList(Requirements, ListIndex);
 
    for (Index = 0; Index < WdfIoResourceListGetCount(List); Index++)
    {
        Descriptor = WdfIoResourceListGetDescriptor(List, Index);
        if (!XhciIsMessageRequirement(Descriptor))
            continue;
 
        Pinned = *Descriptor;
        Pinned.Flags |= CM_RESOURCE_INTERRUPT_POLICY_INCLUDED;
        Pinned.u.Interrupt.AffinityPolicy = IrqPolicySpecifiedProcessors;
        Pinned.u.Interrupt.TargetedProcessors = 0;
 
        /* The primary gets an empty processor set */
        if (!Primary)
        {
            for (Step = 0; Step < PerInterrupter && NextProcessor < RTL_BITS_OF(KAFFINITY); Step++)
            {
                Pinned.u.Interrupt.TargetedProcessors |= (KAFFINITY)1 << NextProcessor;
                NextProcessor++;
            }
        }
 
        Primary = FALSE;
        WdfIoResourceListUpdateDescriptor(List, &Pinned, Index);
    }
 
    return STATUS_SUCCESS;
}

BuildLookup()

NTSTATUS XhciInterrupters::BuildLookup ( )

private

Definition at line 1228 of file intr.cpp.

{
    Interrupter* Entry;
    ULONG Size;
    ULONG Number;
    ULONG Target;
    ULONG Index;
 
    Size = XhciActiveProcessors(ALL_PROCESSOR_GROUPS);
    m_Lookup = (PUSHORT)ExAllocatePoolZero(NonPagedPool,
                                           max(Size, 1UL) * sizeof(*m_Lookup),
                                           XHCI_TAG_INTERRUPTER);
    if (m_Lookup == NULL)
    {
        DPRINT1("Processor lookup table allocation for %lu processors failed\n", Size);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    m_LookupSize = Size;
 
    /* Zero entries mean the primary; group 0 masks only */
    for (Target = 1; Target < m_Count; Target++)
    {
        Entry = &m_Table[Target];
        for (Number = 0; Number < RTL_BITS_OF(KAFFINITY); Number++)
        {
            if ((Entry->Affinity & ((KAFFINITY)1 << Number)) == 0)
                continue;
 
            Index = XhciProcessorIndex(Entry->Group, Number);
            if (Index < m_LookupSize)
                m_Lookup[Index] = (USHORT)Target;
        }
    }
 
    return STATUS_SUCCESS;
}

Referenced by Prepare().

Count()

ULONG XhciInterrupters::Count

(

)

const

Definition at line 1407 of file intr.cpp.

{
    return m_Count;
}

Referenced by SecondaryCountFor().

Create()

NTSTATUS XhciInterrupters::Create

(

_In_ XhciController *

Controller

)

Definition at line 831 of file intr.cpp.

{
    NTSTATUS Status;
 
    PAGED_CODE();
 
    m_Controller = Controller;
    m_PrimaryInterrupt = NULL;
    m_Mechanism = Mechanism::Line;
    m_SecondaryCount = 0;
    m_Count = 0;
    m_Capacity = 0;
    m_Table = NULL;
    m_Lookup = NULL;
    m_LookupSize = 0;
 
    XhciActiveCountRoutine =
        (PFN_XHCI_ACTIVE_COUNT)XhciFindKernelRoutine(L"KeQueryActiveProcessorCountEx");
    XhciIndexFromNumberRoutine =
        (PFN_XHCI_INDEX_FROM_NUMBER)XhciFindKernelRoutine(L"KeGetProcessorIndexFromNumber");
    XhciCurrentNumberRoutine =
        (PFN_XHCI_CURRENT_NUMBER)XhciFindKernelRoutine(L"KeGetCurrentProcessorNumberEx");
    XhciDpcWatchdogRoutine =
        (PFN_XHCI_DPC_WATCHDOG)XhciFindKernelRoutine(L"KeQueryDpcWatchdogInformation");
 
    /* The primary takes the first interrupt resource KMDF finds at start */
    Status = CreateInterrupt(NULL, NULL, &m_PrimaryInterrupt);
    if (!NT_SUCCESS(Status))
        DPRINT1("Primary interrupt creation failed 0x%lx\n", Status);
 
    return Status;
}

Referenced by XhciController::Initialize().

CreateInterrupt()

NTSTATUS XhciInterrupters::CreateInterrupt ( _In_opt_ PCM_PARTIAL_RESOURCE_DESCRIPTOR  Raw, _In_opt_ PCM_PARTIAL_RESOURCE_DESCRIPTOR  Translated, _Out_ WDFINTERRUPT *  Interrupt  )

private

Definition at line 866 of file intr.cpp.

{
    WDF_INTERRUPT_CONFIG Config;
    WDF_OBJECT_ATTRIBUTES Attributes;
    NTSTATUS Status;
 
    WDF_INTERRUPT_CONFIG_INIT(&Config, XhciEvtInterruptIsr, XhciEvtInterruptDpc);
    Config.EvtInterruptEnable = XhciEvtInterruptEnable;
    Config.EvtInterruptDisable = XhciEvtInterruptDisable;
    Config.InterruptRaw = Raw;
    Config.InterruptTranslated = Translated;
 
    WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&Attributes, XHCI_INTERRUPT_CONTEXT);
 
    Status = WdfInterruptCreate(m_Controller->m_Device, &Config, &Attributes, Interrupt);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("WdfInterruptCreate failed 0x%lx\n", Status);
        *Interrupt = NULL;
    }
 
    return Status;
}

Referenced by Create(), and Prepare().

D0Entry()

NTSTATUS XhciInterrupters::D0Entry

(

_In_ BOOLEAN

StatePreserved

)

Programs ERST, ERDP and IMAN for every interrupter before Run.

Definition at line 1326 of file intr.cpp.

{
    ULONG Index;
 
    if (!m_Controller->IsAccessible())
        return STATUS_SUCCESS;
 
    /* On a restore the ring contents and positions from before D0 exit stay valid */
    for (Index = 0; Index < m_Count; Index++)
    {
        if (!StatePreserved)
            XhciResetEventRing(&m_Table[Index]);
 
        XhciProgramEventRing(&m_Table[Index]);
    }
 
    return STATUS_SUCCESS;
}

Referenced by XhciController::RunD0Pass().

D0Exit()

VOID XhciInterrupters::D0Exit

(

)

Definition at line 1380 of file intr.cpp.

{
    DPRINT("Interrupters stopped, %lu in use\n", m_Count);
}

Referenced by XhciController::D0Exit().

D0ExitPreInterruptsDisabled()

VOID XhciInterrupters::D0ExitPreInterruptsDisabled

(

)

Definition at line 1347 of file intr.cpp.

{
    Interrupter* Entry;
    LARGE_INTEGER Timeout;
    KIRQL OldIrql;
    ULONG Index;
 
    PAGED_CODE();
 
    for (Index = 0; Index < m_Count; Index++)
    {
        Entry = &m_Table[Index];
        if (Entry->Requeue == NULL)
            continue;
 
        KeAcquireSpinLock(&Entry->Lock, &OldIrql);
        Entry->PendingDisable = TRUE;
        KeReleaseSpinLock(&Entry->Lock, OldIrql);
 
        /* Freeing state under a running work item is worse than waiting */
        Timeout = XhciRelativeMs(XHCI_DRAIN_WAIT_MS);
        while (KeWaitForSingleObject(&Entry->RequeueIdle,
                                     Executive,
                                     KernelMode,
                                     FALSE,
                                     &Timeout) == STATUS_TIMEOUT)
        {
            DPRINT1("Interrupter %lu requeue work item still running after 60 s\n", Index);
        }
    }
}

Referenced by XhciController::D0ExitPreInterruptsDisabled().

FilterResourceRequirements()

NTSTATUS XhciInterrupters::FilterResourceRequirements

(

_In_ WDFIORESREQLIST

Requirements

)

Called from EvtDeviceFilterRemoveResourceRequirements.

Definition at line 921 of file intr.cpp.

{
    ULONG ListIndex;
    ULONG Messages;
    BOOLEAN MsiX;
 
    PAGED_CODE();
 
    if (m_Controller->HasErrata(XhciErrata::IntLegacyLineOnly))
    {
        m_SecondaryCount = 0;
        return XhciStripMessageRequirements(Requirements);
    }
 
    MsiX = XhciFindMessageList(Requirements, &ListIndex, &Messages);
    m_SecondaryCount = MsiX ? SecondaryCountFor(Messages) : 0;
 
    DPRINT("Requirements list %lu offers %lu messages (MSI-X %u), %lu secondary interrupters\n",
           ListIndex, Messages, MsiX, m_SecondaryCount);
 
    if (WdfIoResourceRequirementsListGetCount(Requirements) != 0)
    {
        XhciTrimMessageRequirements(WdfIoResourceRequirementsListGetIoResList(Requirements, ListIndex),
                                    1 + m_SecondaryCount);
    }
 
    return STATUS_SUCCESS;
}

PostReset()

VOID XhciInterrupters::PostReset

(

)

Definition at line 1386 of file intr.cpp.

{
    ULONG Index;
 
    if (!m_Controller->IsAccessible())
        return;
 
    for (Index = 0; Index < m_Count; Index++)
    {
        XhciResetEventRing(&m_Table[Index]);
        XhciProgramEventRing(&m_Table[Index]);
    }
 
    for (Index = 0; Index < m_Count; Index++)
    {
        if (m_Table[Index].Enabled)
            XhciUnmaskInterrupter(&m_Table[Index]);
    }
}

Referenced by XhciController::InternalReset().

Prepare()

NTSTATUS XhciInterrupters::Prepare	(	_In_ WDFCMRESLIST	Raw,
		_In_ WDFCMRESLIST	Translated
	)

Definition at line 1104 of file intr.cpp.

{
    PCM_PARTIAL_RESOURCE_DESCRIPTOR Descriptor;
    WDFINTERRUPT Interrupt;
    ULONG Assigned = 0;
    ULONG Index;
    ULONG Message;
    ULONG Limit;
    BOOLEAN FirstSkipped;
    NTSTATUS Status;
 
    PAGED_CODE();
 
    m_Mechanism = Mechanism::Line;
    for (Index = 0; Index < WdfCmResourceListGetCount(Raw); Index++)
    {
        Descriptor = WdfCmResourceListGetDescriptor(Raw, Index);
        if (Descriptor->Type != CmResourceTypeInterrupt)
            continue;
 
        if (XhciIsMessageResource(Descriptor))
        {
            m_Mechanism = (Assigned != 0) ? Mechanism::MsiX : Mechanism::Msi;
            Assigned += Descriptor->u.MessageInterrupt.Raw.MessageCount;
        }
        else
        {
            Assigned++;
        }
    }
 
    if (Assigned == 0)
    {
        DPRINT1("No interrupt resources were assigned\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    m_Table = (Interrupter*)ExAllocatePoolZero(NonPagedPool,
                                               Assigned * sizeof(*m_Table),
                                               XHCI_TAG_INTERRUPTER);
    if (m_Table == NULL)
    {
        DPRINT1("Interrupter table allocation for %lu entries failed\n", Assigned);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    m_Capacity = Assigned;
 
    Status = PrepareOne(&m_Table[0], m_PrimaryInterrupt, 0, m_Mechanism != Mechanism::Line);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Primary interrupter prepare failed 0x%lx\n", Status);
        return Status;
    }
 
    m_Count = 1;
 
    /* Register parsing may have asked for a single interrupter after filtering */
    if (m_Controller->HasErrata(XhciErrata::IntPrimaryOnly))
        m_SecondaryCount = 0;
 
    /* The MSI-X table alone may allow more than MaxIntrs */
    Limit = m_Controller->m_Registers.MaxInterrupters();
    if (Limit != 0 && m_SecondaryCount > Limit - 1)
        m_SecondaryCount = Limit - 1;
 
    if (m_SecondaryCount != 0 && Assigned > 1 && m_Mechanism == Mechanism::MsiX)
    {
        FirstSkipped = FALSE;
        Message = 0;
 
        for (Index = 0; Index < WdfCmResourceListGetCount(Translated); Index++)
        {
            Descriptor = WdfCmResourceListGetDescriptor(Translated, Index);
            if (Descriptor->Type != CmResourceTypeInterrupt ||
                (Descriptor->Flags & CM_RESOURCE_INTERRUPT_MESSAGE) == 0)
            {
                continue;
            }
 
            /* The first message belongs to the primary */
            if (!FirstSkipped)
            {
                FirstSkipped = TRUE;
                continue;
            }
 
            Message++;
            if (Message > m_SecondaryCount || Message >= m_Capacity)
                break;
 
            Status = CreateInterrupt(WdfCmResourceListGetDescriptor(Raw, Index), Descriptor, &Interrupt);
            if (!NT_SUCCESS(Status))
            {
                DPRINT1("Secondary interrupter %lu creation failed 0x%lx\n", Message, Status);
                return Status;
            }
 
            Status = PrepareOne(&m_Table[Message], Interrupt, Message, TRUE);
            if (!NT_SUCCESS(Status))
            {
                DPRINT1("Secondary interrupter %lu prepare failed 0x%lx\n", Message, Status);
                return Status;
            }
 
#if defined(NT_PROCESSOR_GROUPS)
            m_Table[Message].Group = Descriptor->u.MessageInterrupt.Translated.Group;
#endif
            m_Table[Message].Affinity = Descriptor->u.MessageInterrupt.Translated.Affinity;
 
            /* Count only the interrupters actually set up */
            m_Count = Message + 1;
        }
    }
 
    DPRINT("%lu interrupt messages assigned, mechanism %lu, %lu interrupters in use\n",
           Assigned, static_cast<ULONG>(m_Mechanism), m_Count);
 
    return BuildLookup();
}

Referenced by XhciController::PrepareHardware().

PrepareOne()

NTSTATUS XhciInterrupters::PrepareOne ( _Inout_ Interrupter *  Entry, _In_ WDFINTERRUPT  Interrupt, _In_ ULONG  Index, _In_ BOOLEAN  MessageSignaled  )

private

Definition at line 1009 of file intr.cpp.

{
    XhciController* Controller = m_Controller;
    WDF_WORKITEM_CONFIG WorkConfig;
    WDF_OBJECT_ATTRIBUTES Attributes;
    PXHCI_ERST_ENTRY Table;
    PLIST_ENTRY Link;
    XhciDmaBuffer* Buffer;
    ULONG Segments;
    ULONG Hardware;
    ULONG Slot;
    NTSTATUS Status;
 
    Entry->Controller = Controller;
    Entry->Interrupt = Interrupt;
    Entry->Index = Index;
    Entry->RegisterOffset = XHCI_RUNTIME_INTERRUPTER_BASE + Index * XHCI_INTERRUPTER_STRIDE;
    Entry->MessageSignaled = MessageSignaled;
    InitializeListHead(&Entry->SegmentList);
    KeInitializeSpinLock(&Entry->Lock);
    KeInitializeEvent(&Entry->RequeueIdle, NotificationEvent, TRUE);
 
    /* Segment count: software default capped by ERST Max, then by the errata */
    Segments = Controller->HasErrata(XhciErrata::EvtResetOnRingOverflow) ?
               XHCI_SEGMENTS_RING_FULL : XHCI_SEGMENTS_DEFAULT;
    Hardware = max(Controller->m_Registers.EventRingSegmentTableMax(), 1UL);
    Segments = min(Segments, Hardware);
    if (Segments > XHCI_SEGMENTS_LIMITED && Controller->HasErrata(XhciErrata::EvtTwoSegmentRingCap))
        Segments = XHCI_SEGMENTS_LIMITED;
 
    Entry->SegmentCount = Segments;
    Entry->SegmentSize = PAGE_SIZE;
    Entry->TrbsPerSegment = PAGE_SIZE / sizeof(XHCI_TRB);
 
    Entry->Erst = Controller->m_Buffers.Acquire(Segments * sizeof(XHCI_ERST_ENTRY));
    if (Entry->Erst == NULL)
    {
        DPRINT1("Interrupter %lu: no buffer for the segment table\n", Index);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    Status = Controller->m_Buffers.AcquireList(Entry->SegmentSize, Segments, &Entry->SegmentList);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Interrupter %lu: no buffers for %lu event ring segments 0x%lx\n",
                Index, Segments, Status);
        goto Fail;
    }
 
    XhciWriteInterrupter(Entry, XHCI_ERSTSZ, 0);
 
    /* The table is written once here and survives power transitions */
    Table = (PXHCI_ERST_ENTRY)Entry->Erst->VirtualAddress;
    Slot = 0;
    for (Link = Entry->SegmentList.Flink; Link != &Entry->SegmentList; Link = Link->Flink)
    {
        Buffer = CONTAINING_RECORD(Link, XhciDmaBuffer, Link);
        Table[Slot].SegmentAddress = (ULONG64)Buffer->LogicalAddress.QuadPart;
        Table[Slot].SegmentSize = Entry->TrbsPerSegment;
        Table[Slot].Reserved = 0;
        Slot++;
    }
 
    WDF_WORKITEM_CONFIG_INIT(&WorkConfig, XhciEvtRequeueWorkItem);
    WorkConfig.AutomaticSerialization = FALSE;
    WDF_OBJECT_ATTRIBUTES_INIT(&Attributes);
    Attributes.ParentObject = Interrupt;
 
    Status = WdfWorkItemCreate(&WorkConfig, &Attributes, &Entry->Requeue);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Interrupter %lu: requeue work item creation failed 0x%lx\n", Index, Status);
        Entry->Requeue = NULL;
        goto Fail;
    }
 
    Entry->Segment = CONTAINING_RECORD(Entry->SegmentList.Flink, XhciDmaBuffer, Link);
    Entry->CycleState = XHCI_TRB_CYCLE;
    Entry->Prepared = TRUE;
    XhciInterruptContext(Interrupt)->Entry = Entry;
    return STATUS_SUCCESS;
 
Fail:
    if (!IsListEmpty(&Entry->SegmentList))
        Controller->m_Buffers.FreeList(&Entry->SegmentList);
    Controller->m_Buffers.Free(Entry->Erst);
    Entry->Erst = NULL;
    return Status;
}

Referenced by Prepare().

Release()

VOID XhciInterrupters::Release

(

)

Definition at line 1296 of file intr.cpp.

{
    ULONG Index;
 
    PAGED_CODE();
 
    if (m_Table != NULL)
    {
        for (Index = 0; Index < m_Capacity; Index++)
        {
            if (m_Table[Index].Prepared)
                ReleaseOne(&m_Table[Index]);
        }
 
        ExFreePoolWithTag(m_Table, XHCI_TAG_INTERRUPTER);
        m_Table = NULL;
    }
 
    if (m_Lookup != NULL)
    {
        ExFreePoolWithTag(m_Lookup, XHCI_TAG_INTERRUPTER);
        m_Lookup = NULL;
    }
 
    m_Count = 0;
    m_Capacity = 0;
    m_LookupSize = 0;
}

Referenced by XhciController::ReleaseHardware().

ReleaseOne()

VOID XhciInterrupters::ReleaseOne ( _Inout_ Interrupter *  Entry )

private

Definition at line 1267 of file intr.cpp.

{
    XhciController* Controller = m_Controller;
 
    if (Controller->IsAccessible())
    {
        XhciWriteInterrupter(Entry, XHCI_ERSTSZ, 0);
        XhciWriteInterrupter64(Entry, XHCI_ERSTBA, 0);
        XhciWriteInterrupter64(Entry, XHCI_ERDP, 0);
    }
 
    Controller->m_Buffers.FreeList(&Entry->SegmentList);
    Controller->m_Buffers.Free(Entry->Erst);
    Entry->Erst = NULL;
    Entry->Segment = NULL;
 
    if (Entry->Requeue != NULL)
    {
        WdfWorkItemFlush(Entry->Requeue);
        WdfObjectDelete(Entry->Requeue);
        Entry->Requeue = NULL;
    }
 
    XhciInterruptContext(Entry->Interrupt)->Entry = NULL;
    Entry->Prepared = FALSE;
}

Referenced by Release().

SecondaryCountFor()

ULONG XhciInterrupters::SecondaryCountFor ( _In_ ULONG  Messages ) const

private

Definition at line 894 of file intr.cpp.

{
    ULONG Limit;
    ULONG Processors;
    ULONG Count;
 
    if (m_Controller->HasErrata(XhciErrata::IntPrimaryOnly) || Messages <= 1)
        return 0;
 
    /* One message always goes to the primary */
    Limit = min(Messages - 1, (ULONG)XHCI_SECONDARY_MAX);
 
    /* A single processor still gets its own secondary */
    Processors = XhciActiveProcessors(0);
    if (Processors <= Limit)
        return Processors;
 
    /* Halve until the processors split evenly over what is available */
    Count = Processors / 2;
    while (Count > Limit)
        Count /= 2;
 
    return Count;
}

Referenced by FilterResourceRequirements().

TargetForCurrentProcessor()

ULONG XhciInterrupters::TargetForCurrentProcessor

(

)

const

Interrupter target for work issued on the current processor.

Definition at line 1413 of file intr.cpp.

{
    return TargetForProcessor(XhciCurrentProcessorIndex());
}

Referenced by XhciTransferRing::UpdateInterrupterTarget().

TargetForProcessor()

ULONG XhciInterrupters::TargetForProcessor

(

_In_ ULONG

ProcessorIndex

)

const

Interrupter target for work issued on the processor with this system wide index.

Definition at line 1419 of file intr.cpp.

{
    /* Processors added after start are not in the table and use the primary */
    if (m_Lookup == NULL || ProcessorIndex >= m_LookupSize)
        return 0;
 
    return m_Lookup[ProcessorIndex];
}

Referenced by TargetForCurrentProcessor(), and XhciTransferRing::UpdateInterrupterTarget().

Member Data Documentation

m_Capacity

ULONG XhciInterrupters::m_Capacity

private

Definition at line 123 of file intr.h.

Referenced by Create(), Prepare(), and Release().

m_Controller

XhciController* XhciInterrupters::m_Controller

private

Definition at line 118 of file intr.h.

Referenced by Create(), CreateInterrupt(), D0Entry(), FilterResourceRequirements(), PostReset(), Prepare(), PrepareOne(), ReleaseOne(), and SecondaryCountFor().

m_Count

ULONG XhciInterrupters::m_Count

private

Interrupters actually prepared

Definition at line 122 of file intr.h.

Referenced by BuildLookup(), Count(), Create(), D0Entry(), D0Exit(), D0ExitPreInterruptsDisabled(), PostReset(), Prepare(), and Release().

m_Lookup

PUSHORT XhciInterrupters::m_Lookup

private

Definition at line 125 of file intr.h.

Referenced by BuildLookup(), Create(), Release(), and TargetForProcessor().

m_LookupSize

ULONG XhciInterrupters::m_LookupSize

private

Definition at line 126 of file intr.h.

Referenced by BuildLookup(), Create(), Release(), and TargetForProcessor().

m_Mechanism

Mechanism XhciInterrupters::m_Mechanism

private

Definition at line 120 of file intr.h.

Referenced by Create(), and Prepare().

m_PrimaryInterrupt

WDFINTERRUPT XhciInterrupters::m_PrimaryInterrupt

private

Definition at line 119 of file intr.h.

Referenced by Create(), and Prepare().

m_SecondaryCount

ULONG XhciInterrupters::m_SecondaryCount

private

Definition at line 121 of file intr.h.

Referenced by AffinitizeResourceRequirements(), Create(), FilterResourceRequirements(), and Prepare().

m_Table

Interrupter* XhciInterrupters::m_Table

private

Definition at line 124 of file intr.h.

Referenced by BuildLookup(), Create(), D0Entry(), D0ExitPreInterruptsDisabled(), PostReset(), Prepare(), and Release().

---

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

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