apic.c File Reference

#include <hal.h>
#include <debug.h>
#include "apic.h"

Include dependency graph for apic.c:

Go to the source code of this file.

Macros
#define	NDEBUG
#define	APIC_LAZY_IRQL
#define	ApicRaiseIrql   ApicSetIrql

Functions
void __cdecl	HackEoi (void)
FORCEINLINE ULONG	IOApicRead (UCHAR Register)
FORCEINLINE VOID	IOApicWrite (UCHAR Register, ULONG Value)
FORCEINLINE VOID	ApicWriteIORedirectionEntry (UCHAR Index, IOAPIC_REDIRECTION_REGISTER ReDirReg)
FORCEINLINE IOAPIC_REDIRECTION_REGISTER	ApicReadIORedirectionEntry (UCHAR Index)
FORCEINLINE VOID	ApicRequestInterrupt (IN UCHAR Vector, UCHAR TriggerMode)
FORCEINLINE VOID	ApicSendEOI (void)
FORCEINLINE KIRQL	ApicGetProcessorIrql (VOID)
FORCEINLINE KIRQL	ApicGetCurrentIrql (VOID)
FORCEINLINE VOID	ApicSetIrql (KIRQL Irql)
FORCEINLINE VOID	ApicLowerIrql (KIRQL Irql)
UCHAR FASTCALL	HalpIrqToVector (UCHAR Irq)
KIRQL FASTCALL	HalpVectorToIrql (UCHAR Vector)
UCHAR FASTCALL	HalpVectorToIrq (UCHAR Vector)
VOID NTAPI	HalpSendEOI (VOID)
VOID NTAPI	ApicInitializeLocalApic (ULONG Cpu)
UCHAR NTAPI	HalpAllocateSystemInterrupt (IN UCHAR Irq, IN KIRQL Irql)
VOID NTAPI	ApicInitializeIOApic (VOID)
VOID NTAPI	HalpInitializePICs (IN BOOLEAN EnableInterrupts)
VOID DECLSPEC_NORETURN FASTCALL	HalpApcInterruptHandler (IN PKTRAP_FRAME TrapFrame)
VOID DECLSPEC_NORETURN FASTCALL	HalpDispatchInterruptHandler (IN PKTRAP_FRAME TrapFrame)
VOID FASTCALL	HalRequestSoftwareInterrupt (IN KIRQL Irql)
VOID FASTCALL	HalClearSoftwareInterrupt (IN KIRQL Irql)
BOOLEAN NTAPI	HalEnableSystemInterrupt (IN ULONG Vector, IN KIRQL Irql, IN KINTERRUPT_MODE InterruptMode)
VOID NTAPI	HalDisableSystemInterrupt (IN ULONG Vector, IN KIRQL Irql)
BOOLEAN NTAPI	HalBeginSystemInterrupt (IN KIRQL Irql, IN ULONG Vector, OUT PKIRQL OldIrql)
VOID NTAPI	HalEndSystemInterrupt (IN KIRQL OldIrql, IN PKTRAP_FRAME TrapFrame)
KIRQL NTAPI	KeGetCurrentIrql (VOID)
VOID FASTCALL	KfLowerIrql (IN KIRQL OldIrql)
KIRQL FASTCALL	KfRaiseIrql (IN KIRQL NewIrql)
KIRQL NTAPI	KeRaiseIrqlToDpcLevel (VOID)
KIRQL NTAPI	KeRaiseIrqlToSynchLevel (VOID)

Variables
ULONG	ApicVersion
UCHAR	HalpVectorToIndex [256]
const UCHAR	HalpIRQLtoTPR [32]
const KIRQL	HalVectorToIRQL [16]

Macro Definition Documentation

APIC_LAZY_IRQL

#define APIC_LAZY_IRQL

Definition at line 22 of file apic.c.

ApicRaiseIrql

#define ApicRaiseIrql   ApicSetIrql

Definition at line 200 of file apic.c.

NDEBUG

#define NDEBUG

Definition at line 15 of file apic.c.

Function Documentation

ApicGetCurrentIrql()

FORCEINLINE KIRQL ApicGetCurrentIrql

(

VOID

)

Definition at line 168 of file apic.c.

{
#ifdef _M_AMD64
    return (KIRQL)__readcr8();
#elif defined(APIC_LAZY_IRQL)
    // HACK: some magic to Sync VBox's APIC registers
    ApicRead(APIC_VER);

    /* Return the field in the PCR */
    return (KIRQL)__readfsbyte(FIELD_OFFSET(KPCR, Irql));
#else
    // HACK: some magic to Sync VBox's APIC registers
    ApicRead(APIC_VER);

    /* Read the TPR and convert it to an IRQL */
    return TprToIrql(ApicRead(APIC_TPR));
#endif
}

Referenced by HalBeginSystemInterrupt(), HalpApcInterruptHandler(), HalpDispatchInterruptHandler(), KeGetCurrentIrql(), KfLowerIrql(), and KfRaiseIrql().

ApicGetProcessorIrql()

FORCEINLINE KIRQL ApicGetProcessorIrql

(

VOID

)

Definition at line 160 of file apic.c.

{
    /* Read the TPR and convert it to an IRQL */
    return TprToIrql(ApicRead(APIC_PPR));
}

Referenced by HalpApcInterruptHandler(), and HalpDispatchInterruptHandler().

ApicInitializeIOApic()

VOID NTAPI ApicInitializeIOApic

(

VOID

)

Definition at line 383 of file apic.c.

{
    PHARDWARE_PTE Pte;
    IOAPIC_REDIRECTION_REGISTER ReDirReg;
    UCHAR Index;
    ULONG Vector;

    /* Map the I/O Apic page */
    Pte = HalAddressToPte(IOAPIC_BASE);
    Pte->PageFrameNumber = IOAPIC_PHYS_BASE / PAGE_SIZE;
    Pte->Valid = 1;
    Pte->Write = 1;
    Pte->Owner = 1;
    Pte->CacheDisable = 1;
    Pte->Global = 1;
    _ReadWriteBarrier();

    /* Setup a redirection entry */
    ReDirReg.Vector = 0xFF;
    ReDirReg.DeliveryMode = APIC_MT_Fixed;
    ReDirReg.DestinationMode = APIC_DM_Physical;
    ReDirReg.DeliveryStatus = 0;
    ReDirReg.Polarity = 0;
    ReDirReg.RemoteIRR = 0;
    ReDirReg.TriggerMode = APIC_TGM_Edge;
    ReDirReg.Mask = 1;
    ReDirReg.Reserved = 0;
    ReDirReg.Destination = 0;

    /* Loop all table entries */
    for (Index = 0; Index < 24; Index++)
    {
        /* Initialize entry */
        IOApicWrite(IOAPIC_REDTBL + 2 * Index, ReDirReg.Long0);
        IOApicWrite(IOAPIC_REDTBL + 2 * Index + 1, ReDirReg.Long1);
    }

    /* Init the vactor to index table */
    for (Vector = 0; Vector <= 255; Vector++)
    {
        HalpVectorToIndex[Vector] = 0xFF;
    }

    // HACK: Allocate all IRQs, should rather do that on demand
    for (Index = 0; Index <= 15; Index++)
    {
        /* Map the IRQs to IRQLs like with the PIC */
        HalpAllocateSystemInterrupt(Index, 27 - Index);
    }

    /* Enable the timer interrupt */
    ReDirReg.Vector = APIC_CLOCK_VECTOR;
    ReDirReg.DeliveryMode = APIC_MT_Fixed;
    ReDirReg.DestinationMode = APIC_DM_Physical;
    ReDirReg.TriggerMode = APIC_TGM_Edge;
    ReDirReg.Mask = 0;
    ReDirReg.Destination = ApicRead(APIC_ID);
    IOApicWrite(IOAPIC_REDTBL + 2 * APIC_CLOCK_INDEX, ReDirReg.Long0);
}

Referenced by HalpInitializePICs().

ApicInitializeLocalApic()

VOID NTAPI ApicInitializeLocalApic

(

ULONG

Cpu

)

Definition at line 259 of file apic.c.

{
    APIC_BASE_ADRESS_REGISTER BaseRegister;
    APIC_SPURIOUS_INERRUPT_REGISTER SpIntRegister;
    LVT_REGISTER LvtEntry;

    /* Enable the APIC if it wasn't yet */
    BaseRegister.Long = __readmsr(MSR_APIC_BASE);
    BaseRegister.Enable = 1;
    BaseRegister.BootStrapCPUCore = (Cpu == 0);
    __writemsr(MSR_APIC_BASE, BaseRegister.Long);

    /* Set spurious vector and SoftwareEnable to 1 */
    SpIntRegister.Long = ApicRead(APIC_SIVR);
    SpIntRegister.Vector = APIC_SPURIOUS_VECTOR;
    SpIntRegister.SoftwareEnable = 1;
    SpIntRegister.FocusCPUCoreChecking = 0;
    ApicWrite(APIC_SIVR, SpIntRegister.Long);

    /* Read the version and save it globally */
    if (Cpu == 0) ApicVersion = ApicRead(APIC_VER);

    /* Set the mode to flat (max 8 CPUs supported!) */
    ApicWrite(APIC_DFR, APIC_DF_Flat);

    /* Set logical apic ID */
    ApicWrite(APIC_LDR, ApicLogicalId(Cpu) << 24);

    /* Set the spurious ISR */
    KeRegisterInterruptHandler(APIC_SPURIOUS_VECTOR, ApicSpuriousService);

    /* Create a template LVT */
    LvtEntry.Long = 0;
    LvtEntry.Vector = 0xFF;
    LvtEntry.MessageType = APIC_MT_Fixed;
    LvtEntry.DeliveryStatus = 0;
    LvtEntry.RemoteIRR = 0;
    LvtEntry.TriggerMode = APIC_TGM_Edge;
    LvtEntry.Mask = 1;
    LvtEntry.TimerMode = 0;

    /* Initialize and mask LVTs */
    ApicWrite(APIC_TMRLVTR, LvtEntry.Long);
    ApicWrite(APIC_THRMLVTR, LvtEntry.Long);
    ApicWrite(APIC_PCLVTR, LvtEntry.Long);
    ApicWrite(APIC_EXT0LVTR, LvtEntry.Long);
    ApicWrite(APIC_EXT1LVTR, LvtEntry.Long);
    ApicWrite(APIC_EXT2LVTR, LvtEntry.Long);
    ApicWrite(APIC_EXT3LVTR, LvtEntry.Long);

    /* LINT0 */
    LvtEntry.Vector = APIC_SPURIOUS_VECTOR;
    LvtEntry.MessageType = APIC_MT_ExtInt;
    ApicWrite(APIC_LINT0, LvtEntry.Long);

    /* Enable LINT1 (NMI) */
    LvtEntry.Mask = 0;
    LvtEntry.Vector = APIC_NMI_VECTOR;
    LvtEntry.MessageType = APIC_MT_NMI;
    LvtEntry.TriggerMode = APIC_TGM_Level;
    ApicWrite(APIC_LINT1, LvtEntry.Long);

    /* Enable error LVTR */
    LvtEntry.Vector = APIC_ERROR_VECTOR;
    LvtEntry.MessageType = APIC_MT_Fixed;
    ApicWrite(APIC_ERRLVTR, LvtEntry.Long);

    /* Set the IRQL from the PCR */
    ApicSetIrql(KeGetPcr()->Irql);
#ifdef APIC_LAZY_IRQL
    /* Save the new hard IRQL in the IRR field */
    KeGetPcr()->IRR = KeGetPcr()->Irql;
#endif
}

Referenced by HalpInitProcessor().

ApicLowerIrql()

FORCEINLINE VOID ApicLowerIrql

(

KIRQL

Irql

)

Definition at line 205 of file apic.c.

{
    __writefsbyte(FIELD_OFFSET(KPCR, Irql), Irql);

    /* Is the new Irql lower than set in the TPR? */
    if (Irql < KeGetPcr()->IRR)
    {
        /* Save the new hard IRQL in the IRR field */
        KeGetPcr()->IRR = Irql;

        /* Need to lower it back */
        ApicWrite(APIC_TPR, IrqlToTpr(Irql));
    }
}

Referenced by HalEndSystemInterrupt(), HalpApcInterruptHandler(), HalpDispatchInterruptHandler(), and KfLowerIrql().

ApicReadIORedirectionEntry()

FORCEINLINE IOAPIC_REDIRECTION_REGISTER ApicReadIORedirectionEntry

(

UCHAR

Index

)

Definition at line 122 of file apic.c.

{
    IOAPIC_REDIRECTION_REGISTER ReDirReg;

    ReDirReg.Long0 = IOApicRead(IOAPIC_REDTBL + 2 * Index);
    ReDirReg.Long1 = IOApicRead(IOAPIC_REDTBL + 2 * Index + 1);

    return ReDirReg;
}

Referenced by HalBeginSystemInterrupt(), and HalEnableSystemInterrupt().

ApicRequestInterrupt()

FORCEINLINE VOID ApicRequestInterrupt	(	IN UCHAR	Vector,
		UCHAR	TriggerMode
	)

Definition at line 135 of file apic.c.

{
    APIC_COMMAND_REGISTER CommandRegister;

    /* Setup the command register */
    CommandRegister.Long0 = 0;
    CommandRegister.Vector = Vector;
    CommandRegister.MessageType = APIC_MT_Fixed;
    CommandRegister.TriggerMode = TriggerMode;
    CommandRegister.DestinationShortHand = APIC_DSH_Self;

    /* Write the low dword to send the interrupt */
    ApicWrite(APIC_ICR0, CommandRegister.Long0);
}

Referenced by HalBeginSystemInterrupt(), and HalRequestSoftwareInterrupt().

ApicSendEOI()

FORCEINLINE VOID ApicSendEOI

(

void

)

Definition at line 152 of file apic.c.

{
    //ApicWrite(APIC_EOI, 0);
    HackEoi();
}

Referenced by HalBeginSystemInterrupt(), HalEndSystemInterrupt(), HalpApcInterruptHandler(), HalpDispatchInterruptHandler(), and HalpSendEOI().

ApicSetIrql()

FORCEINLINE VOID ApicSetIrql

(

KIRQL

Irql

)

Definition at line 189 of file apic.c.

{
#ifdef _M_AMD64
    __writecr8(Irql);
#elif defined(APIC_LAZY_IRQL)
    __writefsbyte(FIELD_OFFSET(KPCR, Irql), Irql);
#else
    /* Convert IRQL and write the TPR */
    ApicWrite(APIC_TPR, IrqlToTpr(Irql));
#endif
}

Referenced by ApicInitializeLocalApic().

ApicWriteIORedirectionEntry()

FORCEINLINE VOID ApicWriteIORedirectionEntry	(	UCHAR	Index,
		IOAPIC_REDIRECTION_REGISTER	ReDirReg
	)

Definition at line 112 of file apic.c.

{
    IOApicWrite(IOAPIC_REDTBL + 2 * Index, ReDirReg.Long0);
    IOApicWrite(IOAPIC_REDTBL + 2 * Index + 1, ReDirReg.Long1);
}

Referenced by HalEnableSystemInterrupt().

HackEoi()

void __cdecl HackEoi

(

void

)

Referenced by ApicSendEOI().

HalBeginSystemInterrupt()

BOOLEAN NTAPI HalBeginSystemInterrupt	(	IN KIRQL	Irql,
		IN ULONG	Vector,
		OUT PKIRQL	OldIrql
	)

Definition at line 678 of file apic.c.

{
    KIRQL CurrentIrql;

    /* Get the current IRQL */
    CurrentIrql = ApicGetCurrentIrql();

#ifdef APIC_LAZY_IRQL
    /* Check if this interrupt is allowed */
    if (CurrentIrql >= Irql)
    {
        IOAPIC_REDIRECTION_REGISTER RedirReg;
        UCHAR Index;

        /* It is not, set the real Irql in the TPR! */
        ApicWrite(APIC_TPR, IrqlToTpr(CurrentIrql));

        /* Save the new hard IRQL in the IRR field */
        KeGetPcr()->IRR = CurrentIrql;

        /* End this interrupt */
        ApicSendEOI();

        /* Get the irq for this vector */
        Index = HalpVectorToIndex[Vector];

        /* Check if its valid */
        if (Index != 0xff)
        {
            /* Read the I/O redirection entry */
            RedirReg = ApicReadIORedirectionEntry(Index);

            /* Re-request the interrupt to be handled later */
            ApicRequestInterrupt(Vector, (UCHAR)RedirReg.TriggerMode);
       }
       else
       {
            /* Re-request the interrupt to be handled later */
            ApicRequestInterrupt(Vector, APIC_TGM_Edge);
       }

        /* Pretend it was a spurious interrupt */
        return FALSE;
    }
#endif
    /* Save the current IRQL */
    *OldIrql = CurrentIrql;

    /* Set the new IRQL */
    ApicRaiseIrql(Irql);

    /* Turn on interrupts */
    _enable();

    /* Success */
    return TRUE;
}

Referenced by HalpApcInterruptHandler(), HalpDispatchInterruptHandler(), and MpsTimerHandler().

HalClearSoftwareInterrupt()

VOID FASTCALL HalClearSoftwareInterrupt

(

IN KIRQL

Irql

)

Definition at line 589 of file apic.c.

{
    /* Nothing to do */
}

HalDisableSystemInterrupt()

VOID NTAPI HalDisableSystemInterrupt	(	IN ULONG	Vector,
		IN KIRQL	Irql
	)

Definition at line 654 of file apic.c.

{
    IOAPIC_REDIRECTION_REGISTER ReDirReg;
    UCHAR Index;
    ASSERT(Irql <= HIGH_LEVEL);
    ASSERT(Vector < RTL_NUMBER_OF(HalpVectorToIndex));

    Index = HalpVectorToIndex[Vector];

    /* Read lower dword of redirection entry */
    ReDirReg.Long0 = IOApicRead(IOAPIC_REDTBL + 2 * Index);

    /* Mask it */
    ReDirReg.Mask = 1;

    /* Write back lower dword */
    IOApicWrite(IOAPIC_REDTBL + 2 * Irql, ReDirReg.Long0);
}

HalEnableSystemInterrupt()

BOOLEAN NTAPI HalEnableSystemInterrupt	(	IN ULONG	Vector,
		IN KIRQL	Irql,
		IN KINTERRUPT_MODE	InterruptMode
	)

Definition at line 600 of file apic.c.

{
    IOAPIC_REDIRECTION_REGISTER ReDirReg;
    PKPRCB Prcb = KeGetCurrentPrcb();
    UCHAR Index;
    ASSERT(Irql <= HIGH_LEVEL);
    ASSERT((IrqlToTpr(Irql) & 0xF0) == (Vector & 0xF0));

    /* Get the irq for this vector */
    Index = HalpVectorToIndex[Vector];

    /* Check if its valid */
    if (Index == 0xff)
    {
        /* Interrupt is not in use */
        return FALSE;
    }

    /* Read the redirection entry */
    ReDirReg = ApicReadIORedirectionEntry(Index);

    /* Check if the interrupt was unused */
    if (ReDirReg.Vector != Vector)
    {
        ReDirReg.Vector = Vector;
        ReDirReg.DeliveryMode = APIC_MT_LowestPriority;
        ReDirReg.DestinationMode = APIC_DM_Logical;
        ReDirReg.Destination = 0;
    }

    /* Check if the destination is logical */
    if (ReDirReg.DestinationMode == APIC_DM_Logical)
    {
        /* Set the bit for this cpu */
        ReDirReg.Destination |= ApicLogicalId(Prcb->Number);
    }

    /* Set the trigger mode */
    ReDirReg.TriggerMode = 1 - InterruptMode;

    /* Now unmask it */
    ReDirReg.Mask = FALSE;

    /* Write back the entry */
    ApicWriteIORedirectionEntry(Index, ReDirReg);

    return TRUE;
}

HalEndSystemInterrupt()

VOID NTAPI HalEndSystemInterrupt	(	IN KIRQL	OldIrql,
		IN PKTRAP_FRAME	TrapFrame
	)

Definition at line 741 of file apic.c.

{
    /* Send an EOI */
    ApicSendEOI();

    /* Restore the old IRQL */
    ApicLowerIrql(OldIrql);
}

Referenced by MpsTimerHandler().

HalpAllocateSystemInterrupt()

UCHAR NTAPI HalpAllocateSystemInterrupt	(	IN UCHAR	Irq,
		IN KIRQL	Irql
	)

Definition at line 336 of file apic.c.

{
    IOAPIC_REDIRECTION_REGISTER ReDirReg;
    IN UCHAR Vector;

    /* Start with lowest vector */
    Vector = IrqlToTpr(Irql) & 0xF0;

    /* Find an empty vector */
    while (HalpVectorToIndex[Vector] != 0xFF)
    {
        Vector++;

        /* Check if we went over the edge */
        if (TprToIrql(Vector) > Irql)
        {
            /* Nothing free, return failure */
            return 0;
        }
    }

    /* Save irq in the table */
    HalpVectorToIndex[Vector] = Irq;

    /* Setup a redirection entry */
    ReDirReg.Vector = Vector;
    ReDirReg.DeliveryMode = APIC_MT_LowestPriority;
    ReDirReg.DestinationMode = APIC_DM_Logical;
    ReDirReg.DeliveryStatus = 0;
    ReDirReg.Polarity = 0;
    ReDirReg.RemoteIRR = 0;
    ReDirReg.TriggerMode = APIC_TGM_Edge;
    ReDirReg.Mask = 1;
    ReDirReg.Reserved = 0;
    ReDirReg.Destination = 0;

    /* Initialize entry */
    IOApicWrite(IOAPIC_REDTBL + 2 * Irq, ReDirReg.Long0);
    IOApicWrite(IOAPIC_REDTBL + 2 * Irq + 1, ReDirReg.Long1);

    return Vector;
}

Referenced by ApicInitializeIOApic().

HalpApcInterruptHandler()

VOID DECLSPEC_NORETURN FASTCALL HalpApcInterruptHandler

(

IN PKTRAP_FRAME

TrapFrame

)

Definition at line 487 of file apic.c.

{
    KPROCESSOR_MODE ProcessorMode;
    KIRQL OldIrql;
    ASSERT(ApicGetProcessorIrql() == APC_LEVEL);

   /* Enter trap */
    KiEnterInterruptTrap(TrapFrame);

#ifdef APIC_LAZY_IRQL
    if (!HalBeginSystemInterrupt(APC_LEVEL, APC_VECTOR, &OldIrql))
    {
        /* "Spurious" interrupt, exit the interrupt */
        KiEoiHelper(TrapFrame);
    }
#else
    /* Save the old IRQL */
    OldIrql = ApicGetCurrentIrql();
    ASSERT(OldIrql < APC_LEVEL);
#endif

    /* Raise to APC_LEVEL */
    ApicRaiseIrql(APC_LEVEL);

    /* End the interrupt */
    ApicSendEOI();

    /* Kernel or user APC? */
    if (KiUserTrap(TrapFrame)) ProcessorMode = UserMode;
    else if (TrapFrame->EFlags & EFLAGS_V86_MASK) ProcessorMode = UserMode;
    else ProcessorMode = KernelMode;

    /* Enable interrupts and call the kernel's APC interrupt handler */
    _enable();
    KiDeliverApc(ProcessorMode, NULL, TrapFrame);

    /* Disable interrupts */
    _disable();

    /* Restore the old IRQL */
    ApicLowerIrql(OldIrql);

    /* Exit the interrupt */
    KiEoiHelper(TrapFrame);
}

HalpDispatchInterruptHandler()

VOID DECLSPEC_NORETURN FASTCALL HalpDispatchInterruptHandler

(

IN PKTRAP_FRAME

TrapFrame

)

Definition at line 536 of file apic.c.

{
    KIRQL OldIrql;
    ASSERT(ApicGetProcessorIrql() == DISPATCH_LEVEL);

   /* Enter trap */
    KiEnterInterruptTrap(TrapFrame);

#ifdef APIC_LAZY_IRQL
    if (!HalBeginSystemInterrupt(DISPATCH_LEVEL, DISPATCH_VECTOR, &OldIrql))
    {
        /* "Spurious" interrupt, exit the interrupt */
        KiEoiHelper(TrapFrame);
    }
#else
    /* Get the current IRQL */
    OldIrql = ApicGetCurrentIrql();
    ASSERT(OldIrql < DISPATCH_LEVEL);
#endif

    /* Raise to DISPATCH_LEVEL */
    ApicRaiseIrql(DISPATCH_LEVEL);

    /* End the interrupt */
    ApicSendEOI();

    /* Enable interrupts and call the kernel's DPC interrupt handler */
    _enable();
    KiDispatchInterrupt();
    _disable();

    /* Restore the old IRQL */
    ApicLowerIrql(OldIrql);

    /* Exit the interrupt */
    KiEoiHelper(TrapFrame);
}

HalpInitializePICs()

VOID NTAPI HalpInitializePICs

(

IN BOOLEAN

EnableInterrupts

)

Definition at line 445 of file apic.c.

{
    ULONG_PTR EFlags;

    /* Save EFlags and disable interrupts */
    EFlags = __readeflags();
    _disable();

    /* Initialize and mask the PIC */
    HalpInitializeLegacyPICs();

    /* Initialize the I/O APIC */
    ApicInitializeIOApic();

    /* Manually reserve some vectors */
    HalpVectorToIndex[APIC_CLOCK_VECTOR] = 8;
    HalpVectorToIndex[APC_VECTOR] = 99;
    HalpVectorToIndex[DISPATCH_VECTOR] = 99;

    /* Set interrupt handlers in the IDT */
    KeRegisterInterruptHandler(APIC_CLOCK_VECTOR, HalpClockInterrupt);
#ifndef _M_AMD64
    KeRegisterInterruptHandler(APC_VECTOR, HalpApcInterrupt);
    KeRegisterInterruptHandler(DISPATCH_VECTOR, HalpDispatchInterrupt);
#endif

    /* Register the vectors for APC and dispatch interrupts */
    HalpRegisterVector(IDT_INTERNAL, 0, APC_VECTOR, APC_LEVEL);
    HalpRegisterVector(IDT_INTERNAL, 0, DISPATCH_VECTOR, DISPATCH_LEVEL);

    /* Restore interrupt state */
    if (EnableInterrupts) EFlags |= EFLAGS_INTERRUPT_MASK;
    __writeeflags(EFlags);
}

Referenced by HalInitSystem().

HalpIrqToVector()

UCHAR FASTCALL HalpIrqToVector

(

UCHAR

Irq

)

Definition at line 225 of file apic.c.

{
    IOAPIC_REDIRECTION_REGISTER ReDirReg;

    /* Read low dword of the redirection entry */
    ReDirReg.Long0 = IOApicRead(IOAPIC_REDTBL + 2 * Irq);

    /* Return the vector */
    return (UCHAR)ReDirReg.Vector;
}

Referenced by HalpGetRootInterruptVector().

HalpSendEOI()

VOID NTAPI HalpSendEOI

(

VOID

)

Definition at line 252 of file apic.c.

{
    ApicSendEOI();
}

HalpVectorToIrq()

UCHAR FASTCALL HalpVectorToIrq

(

UCHAR

Vector

)

Definition at line 245 of file apic.c.

{
    return HalpVectorToIndex[Vector];
}

HalpVectorToIrql()

KIRQL FASTCALL HalpVectorToIrql

(

UCHAR

Vector

)

Definition at line 238 of file apic.c.

{
    return TprToIrql(Vector);
}

Referenced by HalpGetRootInterruptVector().

HalRequestSoftwareInterrupt()

VOID FASTCALL HalRequestSoftwareInterrupt

(

IN KIRQL

Irql

)

Definition at line 581 of file apic.c.

{
    /* Convert irql to vector and request an interrupt */
    ApicRequestInterrupt(IrqlToSoftVector(Irql), APIC_TGM_Edge);
}

IOApicRead()

FORCEINLINE ULONG IOApicRead

(

UCHAR

Register

)

Definition at line 94 of file apic.c.

{
    /* Select the register, then do the read */
    *(volatile UCHAR *)(IOAPIC_BASE + IOAPIC_IOREGSEL) = Register;
    return *(volatile ULONG *)(IOAPIC_BASE + IOAPIC_IOWIN);
}

Referenced by ApicReadIORedirectionEntry(), HalDisableSystemInterrupt(), and HalpIrqToVector().

IOApicWrite()

FORCEINLINE VOID IOApicWrite	(	UCHAR	Register,
		ULONG	Value
	)

Definition at line 103 of file apic.c.

{
    /* Select the register, then do the write */
    *(volatile UCHAR *)(IOAPIC_BASE + IOAPIC_IOREGSEL) = Register;
    *(volatile ULONG *)(IOAPIC_BASE + IOAPIC_IOWIN) = Value;
}

Referenced by ApicInitializeIOApic(), ApicWriteIORedirectionEntry(), HalDisableSystemInterrupt(), and HalpAllocateSystemInterrupt().

KeGetCurrentIrql()

KIRQL NTAPI KeGetCurrentIrql

(

VOID

)

Definition at line 757 of file apic.c.

{
    /* Read the current TPR and convert it to an IRQL */
    return ApicGetCurrentIrql();
}

KeRaiseIrqlToDpcLevel()

KIRQL NTAPI KeRaiseIrqlToDpcLevel

(

VOID

)

Definition at line 806 of file apic.c.

{
    return KfRaiseIrql(DISPATCH_LEVEL);
}

KeRaiseIrqlToSynchLevel()

KIRQL NTAPI KeRaiseIrqlToSynchLevel

(

VOID

)

Definition at line 813 of file apic.c.

{
    return KfRaiseIrql(SYNCH_LEVEL);
}

KfLowerIrql()

VOID FASTCALL KfLowerIrql

(

IN KIRQL

OldIrql

)

Definition at line 765 of file apic.c.

{
#if DBG
    /* Validate correct lower */
    if (OldIrql > ApicGetCurrentIrql())
    {
        /* Crash system */
        KeBugCheck(IRQL_NOT_LESS_OR_EQUAL);
    }
#endif
    /* Set the new IRQL */
    ApicLowerIrql(OldIrql);
}

KfRaiseIrql()

KIRQL FASTCALL KfRaiseIrql

(

IN KIRQL

NewIrql

)

Definition at line 782 of file apic.c.

{
    KIRQL OldIrql;

    /* Read the current IRQL */
    OldIrql = ApicGetCurrentIrql();
#if DBG
    /* Validate correct raise */
    if (OldIrql > NewIrql)
    {
        /* Crash system */
        KeBugCheck(IRQL_NOT_GREATER_OR_EQUAL);
    }
#endif
    /* Convert the new IRQL to a TPR value and write the register */
    ApicRaiseIrql(NewIrql);

    /* Return old IRQL */
    return OldIrql;
}

Referenced by KeRaiseIrqlToDpcLevel(), and KeRaiseIrqlToSynchLevel().

Variable Documentation

ApicVersion

ULONG ApicVersion

Definition at line 27 of file apic.c.

Referenced by ApicInitializeLocalApic().

HalpIRQLtoTPR

const UCHAR HalpIRQLtoTPR[32]

Definition at line 32 of file apic.c.

HalpVectorToIndex

UCHAR HalpVectorToIndex[256]

Definition at line 28 of file apic.c.

Referenced by ApicInitializeIOApic(), HalBeginSystemInterrupt(), HalDisableSystemInterrupt(), HalEnableSystemInterrupt(), HalpAllocateSystemInterrupt(), HalpInitializePICs(), and HalpVectorToIrq().

HalVectorToIRQL

const KIRQL HalVectorToIRQL[16]

Initial value:

=
{
       0, 
    0xff, 
    0xff, 
       1, 
       2, 
       4, 
       5, 
       6, 
       7, 
       8, 
       9, 
      10, 
      27, 
      28, 
      29, 
      31, 
}

Definition at line 69 of file apic.c.