interrupt.cpp File Reference

#include "private.hpp"
#include <debug.h>

Include dependency graph for interrupt.cpp:

Go to the source code of this file.

Classes
struct	SYNC_ENTRY
class	CInterruptSync

Macros
#define	NDEBUG

Typedefs
typedef struct SYNC_ENTRY *	PSYNC_ENTRY

Functions
BOOLEAN NTAPI	CInterruptSynchronizedRoutine (IN PVOID ServiceContext)
BOOLEAN NTAPI	IInterruptServiceRoutine (IN PKINTERRUPT Interrupt, IN PVOID ServiceContext)
NTSTATUS NTAPI	PcNewInterruptSync (OUT PINTERRUPTSYNC *OutInterruptSync, IN PUNKNOWN OuterUnknown OPTIONAL, IN PRESOURCELIST ResourceList, IN ULONG ResourceIndex, IN INTERRUPTSYNCMODE Mode)

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 11 of file interrupt.cpp.

Typedef Documentation

PSYNC_ENTRY

typedef struct SYNC_ENTRY * PSYNC_ENTRY

Function Documentation

CInterruptSynchronizedRoutine()

BOOLEAN NTAPI CInterruptSynchronizedRoutine

(

IN PVOID

ServiceContext

)

Definition at line 84 of file interrupt.cpp.

{
    CInterruptSync * This = (CInterruptSync*)ServiceContext;
    This->m_Status = This->m_SyncRoutine(This, This->m_DynamicContext);
 
    DPRINT("CInterruptSynchronizedRoutine this %p SyncRoutine %p Context %p Status %x\n", This, This->m_SyncRoutine, This->m_DynamicContext, This->m_Status);
    return TRUE;
}

IInterruptServiceRoutine()

BOOLEAN NTAPI IInterruptServiceRoutine	(	IN PKINTERRUPT	Interrupt,
		IN PVOID	ServiceContext
	)

Definition at line 139 of file interrupt.cpp.

{
    PLIST_ENTRY CurEntry;
    PSYNC_ENTRY Entry;
    NTSTATUS Status;
    BOOL Success, Ret;
 
    CInterruptSync * This = (CInterruptSync*)ServiceContext;
 
    DPRINT("IInterruptServiceRoutine Mode %u\n", This->m_Mode);
 
    Ret = FALSE;
    if (This->m_Mode == InterruptSyncModeNormal)
    {
        CurEntry = This->m_ServiceRoutines.Flink;
        while (CurEntry != &This->m_ServiceRoutines)
        {
            Entry = CONTAINING_RECORD(CurEntry, SYNC_ENTRY, ListEntry);
            Status = Entry->SyncRoutine((CInterruptSync*)This, Entry->DynamicContext);
            if (Status == STATUS_SUCCESS)
            {
                /* Mark as handled and break on the first success */
                Ret = TRUE;
                break;
            }
            CurEntry = CurEntry->Flink;
        }
        return Ret;
    }
    else if (This->m_Mode == InterruptSyncModeAll)
    {
        CurEntry = This->m_ServiceRoutines.Flink;
        while (CurEntry != &This->m_ServiceRoutines)
        {
            Entry = CONTAINING_RECORD(CurEntry, SYNC_ENTRY, ListEntry);
            Status = Entry->SyncRoutine((CInterruptSync*)This, Entry->DynamicContext);
            if (Status == STATUS_SUCCESS)
            {
                /* Mark as handled but don't break */
                Ret = TRUE;
            }
            CurEntry = CurEntry->Flink;
        }
        return Ret;
    }
    else if (This->m_Mode == InterruptSyncModeRepeat)
    {
        do
        {
            Success = FALSE;
            CurEntry = This->m_ServiceRoutines.Flink;
            while (CurEntry != &This->m_ServiceRoutines)
            {
                Entry = CONTAINING_RECORD(CurEntry, SYNC_ENTRY, ListEntry);
                Status = Entry->SyncRoutine((CInterruptSync*)This, Entry->DynamicContext);
                if (Status == STATUS_SUCCESS)
                {
                    /* Mark as handled if it works at least once */
                    Success = TRUE;
                    Ret = TRUE;
                }
                CurEntry = CurEntry->Flink;
            }
        } while(Success);
        return Ret;
    }
    else
    {
        DPRINT("Unknown mode %u\n", This->m_Mode);
        return Ret;
    }
}

PcNewInterruptSync()

NTSTATUS NTAPI PcNewInterruptSync	(	OUT PINTERRUPTSYNC *	OutInterruptSync,
		IN PUNKNOWN OuterUnknown	OPTIONAL,
		IN PRESOURCELIST	ResourceList,
		IN ULONG	ResourceIndex,
		IN INTERRUPTSYNCMODE	Mode
	)

Definition at line 295 of file interrupt.cpp.

{
    CInterruptSync * This;
    NTSTATUS Status;
 
    DPRINT("PcNewInterruptSync entered OutInterruptSync %p OuterUnknown %p ResourceList %p ResourceIndex %u Mode %d\n",
            OutInterruptSync, OuterUnknown, ResourceList, ResourceIndex, Mode);
 
    if (!OutInterruptSync || !ResourceList || Mode < InterruptSyncModeNormal || Mode > InterruptSyncModeRepeat)
        return STATUS_INVALID_PARAMETER;
 
    if (ResourceIndex > ResourceList->NumberOfEntriesOfType(CmResourceTypeInterrupt))
        return STATUS_INVALID_PARAMETER;
 
    This = new(NonPagedPool, TAG_PORTCLASS)CInterruptSync(OuterUnknown);
    if (!This)
        return STATUS_INSUFFICIENT_RESOURCES;
 
    Status = This->QueryInterface(IID_IInterruptSync, (PVOID*)OutInterruptSync);
 
    if (!NT_SUCCESS(Status))
    {
        delete This;
        return Status;
    }
 
    ResourceList->AddRef();
 
    //
    // initialize object
    //
    This->m_Mode = Mode;
    This->m_ResourceIndex = ResourceIndex;
    This->m_ResourceList = ResourceList;
    InitializeListHead(&This->m_ServiceRoutines);
    KeInitializeSpinLock(&This->m_Lock);
 
    return Status;
}

Referenced by CMiniport::ProcessResources(), CAC97MiniportWaveRT::ProcessResources(), and STDMETHODIMP_().