irq.c File Reference

#include <ntoskrnl.h>
#include <debug.h>

Include dependency graph for irq.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
NTSTATUS NTAPI	IoConnectInterrupt (OUT PKINTERRUPT *InterruptObject, IN PKSERVICE_ROUTINE ServiceRoutine, IN PVOID ServiceContext, IN PKSPIN_LOCK SpinLock, IN ULONG Vector, IN KIRQL Irql, IN KIRQL SynchronizeIrql, IN KINTERRUPT_MODE InterruptMode, IN BOOLEAN ShareVector, IN KAFFINITY ProcessorEnableMask, IN BOOLEAN FloatingSave)
VOID NTAPI	IoDisconnectInterrupt (PKINTERRUPT InterruptObject)

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 12 of file irq.c.

Function Documentation

IoConnectInterrupt()

NTSTATUS NTAPI IoConnectInterrupt	(	OUT PKINTERRUPT *	InterruptObject,
		IN PKSERVICE_ROUTINE	ServiceRoutine,
		IN PVOID	ServiceContext,
		IN PKSPIN_LOCK	SpinLock,
		IN ULONG	Vector,
		IN KIRQL	Irql,
		IN KIRQL	SynchronizeIrql,
		IN KINTERRUPT_MODE	InterruptMode,
		IN BOOLEAN	ShareVector,
		IN KAFFINITY	ProcessorEnableMask,
		IN BOOLEAN	FloatingSave
	)

Definition at line 22 of file irq.c.

{
    PKINTERRUPT Interrupt;
    PKINTERRUPT InterruptUsed;
    PIO_INTERRUPT IoInterrupt;
    PKSPIN_LOCK SpinLockUsed;
    BOOLEAN FirstRun;
    CCHAR Count = 0;
    KAFFINITY Affinity;
    PAGED_CODE();
 
    /* Assume failure */
    *InterruptObject = NULL;
 
    /* Get the affinity */
    Affinity = ProcessorEnableMask & KeActiveProcessors;
    while (Affinity)
    {
        /* Increase count */
        if (Affinity & 1) Count++;
        Affinity >>= 1;
    }
 
    /* Make sure we have a valid CPU count */
    if (!Count) return STATUS_INVALID_PARAMETER;
 
    /* Allocate the array of I/O Interrupts */
    IoInterrupt = ExAllocatePoolWithTag(NonPagedPool,
                                        (Count - 1) * sizeof(KINTERRUPT) +
                                        sizeof(IO_INTERRUPT),
                                        TAG_KINTERRUPT);
    if (!IoInterrupt) return STATUS_INSUFFICIENT_RESOURCES;
 
    /* Select which Spinlock to use */
    SpinLockUsed = SpinLock ? SpinLock : &IoInterrupt->SpinLock;
 
    /* We first start with a built-in Interrupt inside the I/O Structure */
    *InterruptObject = &IoInterrupt->FirstInterrupt;
    Interrupt = (PKINTERRUPT)(IoInterrupt + 1);
    FirstRun = TRUE;
 
    /* Start with a fresh structure */
    RtlZeroMemory(IoInterrupt, sizeof(IO_INTERRUPT));
 
    /* Now create all the interrupts */
    Affinity = ProcessorEnableMask & KeActiveProcessors;
    for (Count = 0; Affinity; Count++, Affinity >>= 1)
    {
        /* Check if it's enabled for this CPU */
        if (Affinity & 1)
        {
            /* Check which one we will use */
            InterruptUsed = FirstRun ? &IoInterrupt->FirstInterrupt : Interrupt;
 
            /* Initialize it */
            KeInitializeInterrupt(InterruptUsed,
                                  ServiceRoutine,
                                  ServiceContext,
                                  SpinLockUsed,
                                  Vector,
                                  Irql,
                                  SynchronizeIrql,
                                  InterruptMode,
                                  ShareVector,
                                  Count,
                                  FloatingSave);
 
            /* Connect it */
            if (!KeConnectInterrupt(InterruptUsed))
            {
                /* Check how far we got */
                if (FirstRun)
                {
                    /* We failed early so just free this */
                    ExFreePoolWithTag(IoInterrupt, TAG_KINTERRUPT);
                }
                else
                {
                    /* Far enough, so disconnect everything */
                    IoDisconnectInterrupt(&IoInterrupt->FirstInterrupt);
                }
 
                /* And fail */
                return STATUS_INVALID_PARAMETER;
            }
 
            /* Now we've used up our First Run */
            if (FirstRun)
            {
                FirstRun = FALSE;
            }
            else
            {
                /* Move on to the next one */
                IoInterrupt->Interrupt[(UCHAR)Count] = Interrupt++;
            }
        }
    }
 
    /* Return Success */
    return STATUS_SUCCESS;
}

Referenced by AcpiOsInstallInterruptHandler(), AddControllers(), EnableIrq(), FdoCallHWInitialize(), HDA_FDOStartDevice(), i8042ConnectKeyboardInterrupt(), i8042ConnectMouseInterrupt(), InPortStartDevice(), IntVideoPortSetupInterrupt(), LegacyAttachInterrupt(), NdisMRegisterInterrupt(), PortFdoConnectInterrupt(), sb16_play(), SerialPnpStartDevice(), StreamClassStartDevice(), UniataConnectIntr2(), and USBPORT_StartDevice().

IoDisconnectInterrupt()

VOID NTAPI IoDisconnectInterrupt

(

PKINTERRUPT

InterruptObject

)

Definition at line 140 of file irq.c.

{
    LONG i;
    PIO_INTERRUPT IoInterrupt;
    PAGED_CODE();
 
    /* Get the I/O Interrupt */
    IoInterrupt = CONTAINING_RECORD(InterruptObject,
                                    IO_INTERRUPT,
                                    FirstInterrupt);
 
    /* Disconnect the first one */
    KeDisconnectInterrupt(&IoInterrupt->FirstInterrupt);
 
    /* Now disconnect the others */
    for (i = 0; i < KeNumberProcessors; i++)
    {
        /* Make sure one was registered */
        if (IoInterrupt->Interrupt[i])
        {
            /* Disconnect it */
            KeDisconnectInterrupt(&InterruptObject[i]);
        }
    }
 
    /* Free the I/O Interrupt */
    ExFreePool(IoInterrupt); // ExFreePoolWithTag(IoInterrupt, TAG_KINTERRUPT);
}

Referenced by AcpiOsRemoveInterruptHandler(), AddControllers(), FdoRemoveAdapter(), HDA_FDORemoveDevice(), i8042ConnectMouseInterrupt(), InPortRemoveDevice(), IntVideoPortFindAdapter(), IoConnectInterrupt(), NdisMDeregisterInterrupt(), StreamClassReleaseResources(), UniataDisconnectIntr2(), Unload(), and USBPORT_StartDevice().