FxInterrupt Class Reference

#include <fxinterrupt.hpp>

Inheritance diagram for FxInterrupt:

Collaboration diagram for FxInterrupt:

Public Member Functions
	FxInterrupt (__in PFX_DRIVER_GLOBALS FxDriverGlobals)
virtual	~FxInterrupt (VOID)
_Must_inspect_result_ NTSTATUS	CreateWakeInterruptMachine (VOID)
_Must_inspect_result_ NTSTATUS	Initialize (__in CfxDevice *Device, __in FxObject *Parent, __in PWDF_INTERRUPT_CONFIG Configuration)
_Must_inspect_result_ NTSTATUS	InitializeWorker (__in FxObject *Parent, __in PWDF_INTERRUPT_CONFIG Configuration)
_Must_inspect_result_ NTSTATUS	InitializeInternal (__in FxObject *Parent, __in PWDF_INTERRUPT_CONFIG Configuration)
virtual BOOLEAN	Dispose (VOID)
virtual VOID	DeleteObject (VOID)
VOID	OnPostReleaseHardware (VOID)
VOID	DpcHandler (__in_opt PVOID SystemArgument1, __in_opt PVOID SystemArgument2)
BOOLEAN	QueueDpcForIsr (VOID)
BOOLEAN	Synchronize (__in PFN_WDF_INTERRUPT_SYNCHRONIZE Callback, __in WDFCONTEXT Context)
struct _KINTERRUPT *	GetInterruptPtr (VOID)
__inline BOOLEAN	IsWakeCapable (VOID)
VOID	SetActiveForWake (__in BOOLEAN ActiveForWake)
BOOLEAN	IsActiveForWake (VOID)
VOID	ProcessWakeInterruptEvent (__in FxWakeInterruptEvents Event)
VOID	ReportActive (_In_ BOOLEAN Internal=FALSE)
VOID	ReportInactive (_In_ BOOLEAN Internal=FALSE)
BOOLEAN	IsSoftDisconnectCapable (VOID)
VOID	WorkItemHandler (VOID)
BOOLEAN	QueueWorkItemForIsr (VOID)
__inline BOOLEAN	IsPassiveHandling (VOID)
__inline BOOLEAN	IsPassiveConnect (VOID)
__inline BOOLEAN	IsAutomaticSerialization (VOID)
VOID	AcquireLock (VOID)
BOOLEAN	TryToAcquireLock (VOID)
VOID	ReleaseLock (VOID)
CfxDevice *	GetDevice (VOID)
PWDF_INTERRUPT_INFO	GetInfo (VOID)
WDFINTERRUPT	GetHandle (VOID)
BOOLEAN	IsSharedSpinLock (VOID)
BOOLEAN	IsSyncIrqlSet (VOID)
KIRQL	GetSyncIrql (VOID)
KIRQL	GetResourceIrql (VOID)
BOOLEAN	SharesLock (FxInterrupt *Interrupt)
_Must_inspect_result_ NTSTATUS	Connect (__in ULONG NotifyFlags)
_Must_inspect_result_ NTSTATUS	ConnectInternal (VOID)
_Must_inspect_result_ NTSTATUS	Disconnect (__in ULONG NotifyFlags)
VOID	DisconnectInternal (VOID)
_Must_inspect_result_ NTSTATUS	ForceDisconnect (VOID)
_Must_inspect_result_ NTSTATUS	ForceReconnect (VOID)
VOID	FilterResourceRequirements (__inout PIO_RESOURCE_DESCRIPTOR IoResourceDescriptor)
VOID	AssignResources (__in PCM_PARTIAL_RESOURCE_DESCRIPTOR CmDescRaw, __in PCM_PARTIAL_RESOURCE_DESCRIPTOR CmDescTrans)
PCM_PARTIAL_RESOURCE_DESCRIPTOR	GetResources (VOID)
VOID	AssignResourcesInternal (__in PCM_PARTIAL_RESOURCE_DESCRIPTOR CmDescRaw, __in PCM_PARTIAL_RESOURCE_DESCRIPTOR CmDescTrans, __in PWDF_INTERRUPT_INFO InterruptConfig)
VOID	RevokeResources (VOID)
VOID	RevokeResourcesInternal (VOID)
VOID	SetPolicy (__in WDF_INTERRUPT_POLICY Policy, __in WDF_INTERRUPT_PRIORITY Priority, __in PGROUP_AFFINITY TargetProcessorSet)
VOID	SetPolicyInternal (__in WDF_INTERRUPT_POLICY Policy, __in WDF_INTERRUPT_PRIORITY Priority, __in PGROUP_AFFINITY TargetProcessorSet)
VOID	FlushQueuedDpcs (VOID)
VOID	FlushQueuedWorkitem (VOID)
VOID	InvokeWakeInterruptEvtIsr (VOID)
BOOLEAN	WakeInterruptIsr (VOID)
BOOLEAN	IsLevelTriggered (__in ULONG Flags)
__inline BOOLEAN	QueueDeferredRoutineForIsr (VOID)
Public Member Functions inherited from FxNonPagedObject
	FxNonPagedObject (__in WDFTYPE Type, __in USHORT Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals)
	FxNonPagedObject (__in WDFTYPE Type, __in USHORT Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObjectType ObjectType)
virtual	~FxNonPagedObject (VOID)
	_Acquires_lock_ (this->m_NPLock.m_Lock) __drv_maxIRQL(DISPATCH_LEVEL) __drv_setsIRQL(DISPATCH_LEVEL) VOID Lock(__out __drv_deref(__drv_savesIRQL) PKIRQL PreviousIrql)
	_Releases_lock_ (this->m_NPLock.m_Lock) __drv_requiresIRQL(DISPATCH_LEVEL) __inline VOID Unlock(__in __drv_restoresIRQL KIRQL PreviousIrql)
	_Acquires_lock_ (this->m_NPLock.m_Lock) __drv_requiresIRQL(DISPATCH_LEVEL) VOID LockAtDispatch(VOID)
	_Requires_lock_held_ (this->m_NPLock.m_Lock) _Releases_lock_(this -> m_NPLock.m_Lock) __drv_requiresIRQL(DISPATCH_LEVEL) __inline VOID UnlockFromDispatch(VOID)
Public Member Functions inherited from FxObject
PVOID	GetCOMWrapper ()
void	SetCOMWrapper (__drv_aliasesMem PVOID Wrapper)
	FxObject (__in WDFTYPE Type, __in USHORT Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals)
virtual	~FxObject (VOID)
PVOID __inline	operator new (__in size_t Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObjectType Type)
PVOID __inline	operator new (__in size_t Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in_opt PWDF_OBJECT_ATTRIBUTES Attributes, __in USHORT ExtraSize=0)
VOID	operator delete (__in PVOID Memory)
VOID	SetNoContextHeader (VOID)
PVOID __inline	GetObjectHandle (VOID)
__inline FxContextHeader *	GetContextHeader (VOID)
__inline PFX_DRIVER_GLOBALS	GetDriverGlobals (VOID)
WDFTYPE	GetType (VOID)
USHORT	GetObjectSize (VOID)
LONG	GetRefCnt (VOID)
FxTagTracker *	GetTagTracker (VOID)
CfxDevice *	GetDevice (VOID)
CfxDeviceBase *	GetDeviceBase (VOID)
VOID	SetDeviceBase (__in CfxDeviceBase *DeviceBase)
__inline VOID	CallCleanup (VOID)
ULONG __inline	AddRef (__in_opt PVOID Tag=NULL, __in LONG Line=0, __in_opt PSTR File=NULL)
virtual ULONG	Release (__in_opt PVOID Tag=NULL, __in LONG Line=0, __in_opt PSTR File=NULL)
virtual ULONG	AddRefOverride (__in WDFOBJECT_OFFSET Offset, __in_opt PVOID Tag=NULL, __in LONG Line=0, __in_opt PSTR File=NULL)
virtual ULONG	ReleaseOverride (__in WDFOBJECT_OFFSET Offset, __in_opt PVOID Tag=NULL, __in LONG Line=0, __in_opt PSTR File=NULL)
virtual _Must_inspect_result_ NTSTATUS	QueryInterface (__in FxQueryInterfaceParams *Params)
VOID	MarkTraceState (VOID)
BOOLEAN __inline	IsTraceState (VOID)
VOID __inline	TraceDroppedEvent (__in FxObjectDroppedEvent Event)
VOID	MarkPassiveDispose (__in FxObjectLockState State=ObjectLock)
VOID	MarkPassiveCallbacks (__in FxObjectLockState State=ObjectLock)
VOID	MarkForceDisposeThread (__in FxObjectLockState State=ObjectLock)
BOOLEAN	IsPassiveCallbacks (__in BOOLEAN AcquireLock=TRUE)
BOOLEAN	IsPassiveDispose (__in BOOLEAN AcquireLock=TRUE)
BOOLEAN	IsForceDisposeThread (__in BOOLEAN AcquireLock=TRUE)
VOID	MarkCommitted (VOID)
BOOLEAN	IsCommitted (VOID)
VOID	MarkDisposeOverride (__in FxObjectLockState State=ObjectLock)
VOID	MarkNoDeleteDDI (__in FxObjectLockState State=ObjectLock)
BOOLEAN	IsNoDeleteDDI (VOID)
_Must_inspect_result_ NTSTATUS	Commit (__in_opt PWDF_OBJECT_ATTRIBUTES Attributes, __out_opt WDFOBJECT *ObjectHandle, __in_opt FxObject *Parent=NULL, __in BOOLEAN AssignDriverAsDefaultParent=TRUE)
VOID	DeleteFromFailedCreate (VOID)
VOID	ClearEvtCallbacks (VOID)
BOOLEAN	EarlyDispose (VOID)
virtual VOID	DeleteObject (VOID)
virtual BOOLEAN	Dispose (VOID)
_Must_inspect_result_ NTSTATUS	AssignParentObject (__in FxObject *ParentObject)
_Must_inspect_result_ NTSTATUS	AddContext (__in FxContextHeader *Header, __in PVOID *Context, __in PWDF_OBJECT_ATTRIBUTES Attributes)
_Must_inspect_result_ NTSTATUS	RemoveParentAssignment (VOID)
_Must_inspect_result_ FxObject *	GetParentObjectReferenced (__in PVOID Tag)
BOOLEAN	IsDisposed (VOID)

Static Public Member Functions
static _Must_inspect_result_ NTSTATUS	_CreateAndInit (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in CfxDevice *Device, __in_opt FxObject *Parent, __in PWDF_OBJECT_ATTRIBUTES Attributes, __in PWDF_INTERRUPT_CONFIG Configuration, __out FxInterrupt **Interrupt)
static BOOLEAN	_IsMessageInterrupt (__in USHORT ResourceFlags)
static BOOLEAN	_IsWakeHintedInterrupt (__in USHORT ResourceFlags)
Static Public Member Functions inherited from FxObject
static FxObject *	_FromDisposeEntry (__in PSINGLE_LIST_ENTRY Entry)
static FxObject *	_GetObjectFromHandle (__in WDFOBJECT Handle, __inout PWDFOBJECT_OFFSET ObjectOffset)
static PVOID __inline	_ToHandle (__in FxObject *Object)
static VOID __inline	_ReferenceActual (__in WDFOBJECT Object, __in_opt PVOID Tag, __in LONG Line, __in PSTR File)
static VOID __inline	_DereferenceActual (__in WDFOBJECT Object, __in_opt PVOID Tag, __in LONG Line, __in PSTR File)
static PVOID	_GetDebugBase (__in FxObject *Object)
static PFX_POOL_HEADER	_CleanupPointer (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObject *Object)
static _Must_inspect_result_ NTSTATUS	_GetEffectiveLock (__in FxObject *Object, __in_opt IFxHasCallbacks *Callbacks, __in BOOLEAN AutomaticLocking, __in BOOLEAN PassiveCallbacks, __out FxCallbackLock **CallbackLock, __out_opt FxObject **CallbackLockObject)
static _Must_inspect_result_ NTSTATUS	_ObjectQuery (_In_ FxObject *Object, _In_ CONST GUID *Guid, _In_ ULONG QueryBufferLength, _Out_writes_bytes_(QueryBufferLength) PVOID QueryBuffer)

Protected Attributes
LIST_ENTRY	m_PnpList
Protected Attributes inherited from FxObject
union {
CfxDeviceBase *   m_DeviceBase
CfxDevice *   m_Device
};

Private Member Functions
VOID	Reset (VOID)
VOID	ResetInternal (VOID)
VOID	SetSyncIrql (KIRQL SyncIrql)
VOID	FlushAndRundown (VOID)
VOID	FlushAndRundownInternal (VOID)
NTSTATUS	InterruptEnable (VOID)
NTSTATUS	InterruptEnableInvokeCallback (VOID)
NTSTATUS	InterruptDisable (VOID)
NTSTATUS	InterruptDisableInvokeCallback (VOID)

Private Attributes
friend	FxPkgPnp
WDF_TRI_STATE	m_ShareVector
struct _KINTERRUPT *	m_Interrupt
MdLock *	m_SpinLock
KIRQL	m_OldIrql
volatile KIRQL	m_SynchronizeIrql
MxLock	m_BuiltInSpinLock
FxWaitLock *	m_WaitLock
KDPC	m_Dpc
FxSystemWorkItem *	m_SystemWorkItem
FxCallbackLock *	m_CallbackLock
BOOLEAN	m_DisposeWaitLock
BOOLEAN	m_UseSoftDisconnect
BOOLEAN	m_PassiveHandling
BOOLEAN	m_AddedToList
BOOLEAN	m_Connected
BOOLEAN	m_ForceDisconnected
BOOLEAN	m_Enabled
BOOLEAN	m_FloatingSave
BOOLEAN	m_CreatedInPrepareHardware
FxWakeInterruptMachine *	m_WakeInterruptMachine
BOOLEAN	m_Active
BOOLEAN	m_SetPolicy
WDF_INTERRUPT_POLICY	m_Policy
WDF_INTERRUPT_PRIORITY	m_Priority
GROUP_AFFINITY	m_Processors
PFN_WDF_INTERRUPT_ENABLE	m_EvtInterruptEnable
PFN_WDF_INTERRUPT_DISABLE	m_EvtInterruptDisable
PFN_WDF_INTERRUPT_ISR	m_EvtInterruptIsr
PFN_WDF_INTERRUPT_DPC	m_EvtInterruptDpc
PFN_WDF_INTERRUPT_WORKITEM	m_EvtInterruptWorkItem
RD_INTERRUPT_CONTEXT	m_RdInterruptContext
FxInterruptWaitblock *	m_InterruptWaitblock
BOOLEAN	m_CanQueue
BOOLEAN	m_PassiveHandlingByRedirector
WDF_INTERRUPT_INFO	m_InterruptInfo
PCM_PARTIAL_RESOURCE_DESCRIPTOR	m_CmTranslatedResource
struct _KINTERRUPT *	m_InterruptCaptured
BOOLEAN	m_Disconnecting
BOOLEAN	m_IsEdgeTriggeredNonMsiInterrupt

Static Private Attributes
static MdInterruptSynchronizeRoutineType	_InterruptMarkDisconnecting
static MdInterruptServiceRoutineType	_InterruptThunk
static EVT_SYSTEMWORKITEM	_InterruptWorkItemCallback
static MdInterruptSynchronizeRoutineType	_InterruptSynchronizeThunk
static MdDeferredRoutineType	_InterruptDpcThunk
static MdInterruptSynchronizeRoutineType	_InterruptEnableThunk
static MdInterruptSynchronizeRoutineType	_InterruptDisableThunk

Additional Inherited Members
Protected Member Functions inherited from FxObject
	FxObject (__in WDFTYPE Type, __in USHORT Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObjectType ObjectType)
FxObjectDebugExtension *	GetDebugExtension (VOID)
BOOLEAN	IsDebug (VOID)
VOID	AllocateTagTracker (__in WDFTYPE Type)
virtual VOID	SelfDestruct (VOID)
PVOID __inline	GetObjectHandleUnchecked (VOID)
VOID __inline	DestroyChildren (VOID)
VOID	DeleteEarlyDisposedObject (VOID)
Static Protected Member Functions inherited from FxObject
static PVOID	_GetBase (__in FxObject *Object)

Detailed Description

Definition at line 45 of file fxinterrupt.hpp.

Constructor & Destructor Documentation

FxInterrupt()

FxInterrupt::FxInterrupt

(

__in PFX_DRIVER_GLOBALS

FxDriverGlobals

)

Definition at line 143 of file interruptobject.cpp.

      :
    FxNonPagedObject(FX_TYPE_INTERRUPT, sizeof(FxInterrupt), Globals)
{
 
    m_Interrupt = NULL;
 
    m_OldIrql   = PASSIVE_LEVEL;
 
    m_EvtInterruptEnable = NULL;
    m_EvtInterruptDisable = NULL;
 
    m_PassiveHandling = FALSE;
 
    m_EvtInterruptIsr = NULL;
    m_EvtInterruptDpc = NULL;
    m_EvtInterruptWorkItem = NULL;
 
    m_CallbackLock = NULL;
    m_WaitLock = NULL;
    m_SystemWorkItem = NULL;
 
    m_DisposeWaitLock = FALSE;
 
    //
    // We want platform specific behavior for soft disconnect to avoid any
    // compat issues on existing platforms. In later versions (after 1.11) the
    // platform differenciation could be removed.
    //
#if defined(_ARM_)
    m_UseSoftDisconnect = TRUE;
#else
    m_UseSoftDisconnect = FALSE;
#endif
 
#if FX_IS_KERNEL_MODE
    KeInitializeDpc(&m_Dpc, _InterruptDpcThunk, this);
 
    m_Active = FALSE;
    m_InterruptCaptured = NULL;
 
#elif FX_IS_USER_MODE
 
    m_RdInterruptContext = NULL;
    m_InterruptWaitblock = NULL;
    m_CanQueue = FALSE;
    m_PassiveHandlingByRedirector = FALSE;
#endif
 
    m_Disconnecting = FALSE;
    m_IsEdgeTriggeredNonMsiInterrupt = FALSE;
 
    m_ShareVector = WdfUseDefault;
 
    m_AddedToList = FALSE;
    m_Connected = FALSE;
    m_ForceDisconnected = FALSE;
    m_Enabled = FALSE;
    m_FloatingSave = FALSE;
 
    m_WakeInterruptMachine = NULL;
 
    // This field is init later on.
    m_CreatedInPrepareHardware = FALSE;
 
    WDF_INTERRUPT_INFO_INIT(&m_InterruptInfo);
    m_CmTranslatedResource = NULL;
 
    Reset();
 
    // This is set up by Initialize
    m_SpinLock  = NULL;
 
    //
    // MSI Support
    //
    m_InterruptInfo.MessageNumber = 0;
 
    //
    // WdfIrqPolicyOneCloseProcessor is a safe policy to use. It ensures that
    // old devices continue to work without any change in their functionality.
    //
    m_Policy    = WdfIrqPolicyOneCloseProcessor;
    m_Priority  = WdfIrqPriorityUndefined;
    RtlZeroMemory(&m_Processors, sizeof(m_Processors));
    m_SetPolicy = FALSE;
 
    InitializeListHead(&m_PnpList);
 
    //
    // Driver writer can only create WDFINTERRUPTs, not delete them
    //
    MarkNoDeleteDDI(ObjectDoNotLock);
    MarkPassiveDispose(ObjectDoNotLock);
    MarkDisposeOverride(ObjectDoNotLock);
}

~FxInterrupt()

FxInterrupt::~FxInterrupt ( VOID  )

virtual

Definition at line 241 of file interruptobject.cpp.

{
 
    //
    // If this hits, its because someone destroyed the INTERRUPT by
    // removing too many references by mistake without calling WdfObjectDelete
    //
    if( m_Interrupt != NULL ) {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
            "Destroy Interrupt destroyed without calling WdfObjectDelete, or "
            "by Framework processing DeviceRemove. Possible reference count problem?");
        FxVerifierDbgBreakPoint(GetDriverGlobals());
    }
 
    if (m_Device != NULL) {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
            "Destroy Interrupt destroyed without calling WdfObjectDelete, or "
            "by Framework processing DeviceRemove. Possible reference count problem?");
        FxVerifierDbgBreakPoint(GetDriverGlobals());
    }
}

Member Function Documentation

_CreateAndInit()

_Must_inspect_result_ NTSTATUS FxInterrupt::_CreateAndInit ( __in PFX_DRIVER_GLOBALS  FxDriverGlobals, __in CfxDevice *  Device, __in_opt FxObject *  Parent, __in PWDF_OBJECT_ATTRIBUTES  Attributes, __in PWDF_INTERRUPT_CONFIG  Configuration, __out FxInterrupt **  Interrupt  )

static

Definition at line 421 of file interruptobject.cpp.

{
    FxInterrupt * pFxInterrupt;
    NTSTATUS status;
 
    pFxInterrupt = new (FxDriverGlobals, Attributes)
        FxInterrupt(FxDriverGlobals);
 
    if (pFxInterrupt == NULL) {
        status = STATUS_INSUFFICIENT_RESOURCES;
 
        DoTraceLevelMessage(
            FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
            "not enough memory to allocate WDFINTERRUPT for WDFDEVICE %p, "
            "%!STATUS!", Device, status);
 
        return status;
    }
 
    if (NULL == Parent) {
        Parent = Device;
    }
 
    status = pFxInterrupt->Initialize(Device, Parent, Configuration);
 
    if (NT_SUCCESS(status)) {
        status = pFxInterrupt->Commit(Attributes, NULL, Parent);
        if (!NT_SUCCESS(status)) {
            DoTraceLevelMessage(
                FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
                "FxInterrupt Commit failed %!STATUS!", status);
        }
    }
 
    if (NT_SUCCESS(status)) {
        *Interrupt = pFxInterrupt;
    }
    else {
        pFxInterrupt->DeleteFromFailedCreate();
        return status;
    }
 
    if (Configuration->CanWakeDevice) {
        status = pFxInterrupt->CreateWakeInterruptMachine();
    }
 
    if (!NT_SUCCESS(status)) {
        pFxInterrupt->DeleteFromFailedCreate();
    }
 
    return status;
}

_IsMessageInterrupt()

static BOOLEAN FxInterrupt::_IsMessageInterrupt ( __in USHORT  ResourceFlags )

inlinestatic

Definition at line 695 of file fxinterrupt.hpp.

    {
        if (ResourceFlags & CM_RESOURCE_INTERRUPT_MESSAGE) {
            return TRUE;
        }
        else {
            return FALSE;
        }
    }

Referenced by AssignResources(), FxPkgPnp::FilterResourceRequirements(), FxPkgPnp::PnpMatchResources(), and FxPkgPnp::ValidateInterruptResourceCm().

_IsWakeHintedInterrupt()

static BOOLEAN FxInterrupt::_IsWakeHintedInterrupt ( __in USHORT  ResourceFlags )

inlinestatic

Definition at line 709 of file fxinterrupt.hpp.

    {
        if (ResourceFlags & CM_RESOURCE_INTERRUPT_WAKE_HINT) {
            return TRUE;
        }
        else {
            return FALSE;
        }
    }

AcquireLock()

VOID FxInterrupt::AcquireLock

(

VOID

)

Definition at line 1877 of file interruptobject.cpp.

{
    if (FALSE == m_PassiveHandling) {
        struct _KINTERRUPT* kinterrupt = GetInterruptPtr();
 
        //
        // DIRQL interrupt handling.
        //
        ASSERTMSG("Can't synchronize when the interrupt isn't connected: ",
                  kinterrupt != NULL);
 
        if (NULL != kinterrupt) {
            m_OldIrql = Mx::MxAcquireInterruptSpinLock(kinterrupt);
        }
    }
    else {
        //
        // Passive-level interrupt handling when automatic serialization is off.
        //
        ASSERT(Mx::MxGetCurrentIrql() == PASSIVE_LEVEL);
        ASSERT(m_WaitLock != NULL);
        m_WaitLock->AcquireLock(GetDriverGlobals(), NULL);
    }
}

Referenced by _Requires_lock_not_held_(), InterruptDisableInvokeCallback(), InterruptEnableInvokeCallback(), and InvokeWakeInterruptEvtIsr().

AssignResources()

VOID FxInterrupt::AssignResources	(	__in PCM_PARTIAL_RESOURCE_DESCRIPTOR	CmDescRaw,
		__in PCM_PARTIAL_RESOURCE_DESCRIPTOR	CmDescTrans
	)

Definition at line 928 of file interruptobject.cpp.

{
    if (CmDescTrans->u.Interrupt.Group > 0 &&
        FxIsProcessorGroupSupported() == FALSE) {
        //
        // This should never happen.
        //
        FxVerifierDbgBreakPoint(GetDriverGlobals());
    }
 
#if FX_IS_USER_MODE
    //
    // For UMDF, see if this is level-triggered interrupt in which case we need
    // reflector to handle it at passive level. Also, level-triggered
    // support is present only on Win8 and newer. Note that, for KMDF, driver
    // would have provided the choice of handling at passive level so we know
    // that early on for KMDF, however for UMDF, driver can't specify the choice
    // and UMDF figures out whether to handle at passive or not by looking at
    // the interrupt type in resources.
    //
    if (IsLevelTriggered(CmDescTrans->Flags) &&
        FxIsPassiveLevelInterruptSupported()) {
        m_PassiveHandlingByRedirector = TRUE;
    }
#endif
 
    if (IsPassiveConnect() && _IsMessageInterrupt(CmDescTrans->Flags)) {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
            "Driver cannot specify PassiveHandling for MSI interrupts.");
        FxVerifierDbgBreakPoint(GetDriverGlobals());
        // IoConnectInterruptEx will fail later on.
    }
 
    m_InterruptInfo.Group                   = CmDescTrans->u.Interrupt.Group;
    m_InterruptInfo.TargetProcessorSet      = CmDescTrans->u.Interrupt.Affinity;
    m_InterruptInfo.ShareDisposition        = CmDescTrans->ShareDisposition;
    m_InterruptInfo.Mode                    =
        CmDescTrans->Flags & CM_RESOURCE_INTERRUPT_LATCHED ? Latched : LevelSensitive;
 
    //
    // Interrupt's IRQL.
    //
    m_InterruptInfo.Irql = (KIRQL)CmDescTrans->u.Interrupt.Level;
 
    if (IsPassiveConnect()) {
        m_InterruptInfo.Irql = PASSIVE_LEVEL;
    }
 
    //
    //  Note if this is an MSI interrupt
    //
    m_InterruptInfo.MessageSignaled = _IsMessageInterrupt(CmDescTrans->Flags);
 
    //
    // Edge-triggered interrupts that are ActiveBoth are made stateful by the OS
    // (GPIO buttons driver) to track buttons' press/release state. This is because
    // the driver may not have the ability to read the state directly from the hardware.
    //
    // There is no way to identify ActiveBoth interrupts since KINTERRUPT_POLARITY is
    // not exposed to client drivers, so we decided to apply this logic to all
    // edge-triggered non-MSI interrupts.
    //
    m_IsEdgeTriggeredNonMsiInterrupt = (m_InterruptInfo.Mode == Latched &&
        m_InterruptInfo.MessageSignaled == FALSE);
 
    if (m_InterruptInfo.MessageSignaled &&
        CmDescRaw->u.MessageInterrupt.Raw.MessageCount > 1) {
        //
        // This is an assignment for a multi-message PCI 2.2-style resource.
        // Thus the vector and message data have to be deduced.
        //
        m_InterruptInfo.Vector = CmDescTrans->u.Interrupt.Vector + m_InterruptInfo.MessageNumber;
 
        m_Device->SetDeviceTelemetryInfoFlags(DeviceInfoMsi22MultiMessageInterrupt);
    }
    else {
        //
        // This is an assignment for a single interrupt, either line-based or
        // PCI 2.2 single-message MSI, or PCI 3.0 MSI-X-style resource.
        //
        m_InterruptInfo.Vector = CmDescTrans->u.Interrupt.Vector;
 
        if (m_InterruptInfo.MessageSignaled) {
            m_Device->SetDeviceTelemetryInfoFlags(DeviceInfoMsiXOrSingleMsi22Interrupt);
        }
        else {
            if (IsLevelTriggered(CmDescTrans->Flags)) {
                m_Device->SetDeviceTelemetryInfoFlags(DeviceInfoLineBasedLevelTriggeredInterrupt);
            }
            else {
                m_Device->SetDeviceTelemetryInfoFlags(DeviceInfoLineBasedEdgeTriggeredInterrupt);
            }
        }
    }
 
    if (IsPassiveConnect()) {
        m_Device->SetDeviceTelemetryInfoFlags(DeviceInfoPassiveLevelInterrupt);
    }
 
    //
    // Do mode-specific work. For KMDF, it's a no-op.
    // For UMDF, send a sync message to Reflector to assign resources.
    //
    AssignResourcesInternal(CmDescRaw, CmDescTrans, &m_InterruptInfo);
 
    //
    // Weak ref to the translated resource interrupt descriptor.
    // It is valid from prepare hardware callback to release hardware callback.
    //
    m_CmTranslatedResource = CmDescTrans;
 
    DoTraceLevelMessage(
        GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGPNP,
        "Is MSI? %d, MSI-ID %d, AffinityPolicy %!WDF_INTERRUPT_POLICY!, "
        "Priority %!WDF_INTERRUPT_PRIORITY!, Group %d, Affinity 0x%I64x, "
        "Irql 0x%x, Vector 0x%x\n",
        m_InterruptInfo.MessageSignaled,
        m_InterruptInfo.MessageNumber,
        m_Policy,
        m_Priority,
        m_InterruptInfo.Group,
        (ULONGLONG)m_InterruptInfo.TargetProcessorSet,
        m_InterruptInfo.Irql,
        m_InterruptInfo.Vector);
 
}

Referenced by Initialize(), and FxPkgPnp::PnpMatchResources().

AssignResourcesInternal()

VOID FxInterrupt::AssignResourcesInternal	(	__in PCM_PARTIAL_RESOURCE_DESCRIPTOR	CmDescRaw,
		__in PCM_PARTIAL_RESOURCE_DESCRIPTOR	CmDescTrans,
		__in PWDF_INTERRUPT_INFO	InterruptConfig
	)

Definition at line 71 of file fxinterruptkm.hpp.

{
    UNREFERENCED_PARAMETER(CmDescRaw);
    UNREFERENCED_PARAMETER(CmDescTrans);
    UNREFERENCED_PARAMETER(InterruptInfo);
 
    //
    // Does nothing for KMDF
    //
}

Referenced by AssignResources().

Connect()

_Must_inspect_result_ NTSTATUS FxInterrupt::Connect

(

__in ULONG

NotifyFlags

)

Definition at line 1189 of file interruptobject.cpp.

{
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
    NTSTATUS status;
 
    pFxDriverGlobals = GetDriverGlobals();
 
    if ((NotifyFlags & NotifyResourcesExplicitPowerup) &&
        IsActiveForWake()) {
        //
        // If an interrupt is marked as wakeable and the device has been set to
        // wake via a driver-owned ISR, leave the interrupt connected.
        //
        SetActiveForWake(FALSE);
 
        return STATUS_SUCCESS;
    }
 
    //
    // See if we need to just do soft connect. We do soft connect on explicit
    // power up if driver opted-in for that.
    //
    if (IsSoftDisconnectCapable() &&
        (NotifyFlags & NotifyResourcesExplicitPowerup)){
 
        ReportActive(TRUE);
 
        status = STATUS_SUCCESS;
        goto Enable;
    }
 
    //
    // We should either be disconnected or being asked to connect in the NP path
    //
    ASSERT(m_Connected == FALSE || (NotifyFlags & NotifyResourcesNP));
 
    if (m_ForceDisconnected) {
        return STATUS_SUCCESS;
    }
 
    //
    // Check to see if this interrupt object was actually assigned any
    // resources.  If it wasn't, then don't attempt to connect.  A WDFINTERRUPT
    // object won't be assigned any resources if the underlying device wasn't
    // granted any by the PnP manager.
    //
    if (m_InterruptInfo.Vector == 0) {
        return STATUS_SUCCESS;
    }
 
    //
    // If we are in an NP path, the interrupt remained connected while the device
    // went into Dx so there is no need to reconnect it.
    //
    if ((NotifyFlags & NotifyResourcesNP) == 0) {
 
        ASSERT(m_Interrupt == NULL);
        ASSERT(m_SynchronizeIrql != PASSIVE_LEVEL || m_PassiveHandling);
 
        //
        // Call pnp manager to connect the interrupt. For KMDF, we call
        // kernel DDI, whereas for UMDF, we send a sync message to redirector.
        //
        status = ConnectInternal();
 
        if (!NT_SUCCESS(status)) {
            m_Interrupt = NULL;
 
            DoTraceLevelMessage(
                pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
                "IoConnectInterrupt(Ex) Failed,"
                " SpinLock 0x%p,"
                " Vector 0x%x,"
                " IRQL 0x%x,"
                " Synchronize IRQL 0x%x,"
                " Mode 0x%x,"
                " ShareVector %s,"
                " ProcessorGroup %d,"
                " ProcessorEnableMask 0x%I64x,"
                " FloatingSave %s,"
                " %!STATUS!",
                m_SpinLock,
                m_InterruptInfo.Vector,
                m_InterruptInfo.Irql,
                m_SynchronizeIrql,
                m_InterruptInfo.Mode,
                m_InterruptInfo.ShareDisposition ==
                    CmResourceShareShared ? "True" : "False",
                m_InterruptInfo.Group,
                (ULONGLONG)m_InterruptInfo.TargetProcessorSet,
                m_FloatingSave ? "True" : "False",
                status
                );
 
            return status;
        }
 
        m_Connected = TRUE;
 
#if FX_IS_KERNEL_MODE
        m_Active = TRUE;
#endif
 
    }
    else {
        ASSERT(m_Connected);
        ASSERT(m_Interrupt != NULL);
    }
 
Enable:
 
    //
    // Enable the interrupt at the hardware.
    //
    status = InterruptEnable();
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(
            pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
            "EvtInterruptEnable WDFDEVICE %p, WDFINTERRUPT %p, PKINTERRUPT %p "
            "returned %!STATUS!", m_Device->GetHandle(), GetHandle(),
            m_Interrupt, status);
 
        return status;
    }
 
    m_Enabled = TRUE;
 
    return status;
}

Referenced by FxPkgPnp::NotifyResourceObjectsD0().

ConnectInternal()

NTSTATUS FxInterrupt::ConnectInternal

(

VOID

)

Definition at line 130 of file interruptobjectkm.cpp.

{
    IO_CONNECT_INTERRUPT_PARAMETERS connectParams;
    FxPkgPnp* fxPkgPnp;
 
    fxPkgPnp = m_Device->m_PkgPnp;
 
    //
    // Tell the PnP Manager to connect the interrupt.
    //
    ASSERT(fxPkgPnp->m_IoConnectInterruptEx != NULL);
 
    //
    // We're running on Longhorn or later (or somebody backported the new
    // interrupt code,) so tell the PnP manager everything we can about this
    // device.
    //
    RtlZeroMemory(&connectParams, sizeof(connectParams));
 
    if (FxIsProcessorGroupSupported()) {
        connectParams.Version = CONNECT_FULLY_SPECIFIED_GROUP;
    }
    else {
        connectParams.Version = CONNECT_FULLY_SPECIFIED;
    }
 
    connectParams.FullySpecified.PhysicalDeviceObject = m_Device->GetPhysicalDevice();
    connectParams.FullySpecified.InterruptObject      = &m_Interrupt;
    connectParams.FullySpecified.ServiceRoutine       = _InterruptThunk;
    connectParams.FullySpecified.ServiceContext       = this;
    connectParams.FullySpecified.SpinLock             = m_SpinLock;
    connectParams.FullySpecified.FloatingSave         = m_FloatingSave;
    connectParams.FullySpecified.Vector               = m_InterruptInfo.Vector;
    connectParams.FullySpecified.Irql                 = m_InterruptInfo.Irql;
    connectParams.FullySpecified.ProcessorEnableMask  = m_InterruptInfo.TargetProcessorSet;
    connectParams.FullySpecified.Group                = m_InterruptInfo.Group;
    connectParams.FullySpecified.InterruptMode        = m_InterruptInfo.Mode;
    connectParams.FullySpecified.ShareVector          =
        m_InterruptInfo.ShareDisposition == CmResourceShareShared ? TRUE : FALSE;
    connectParams.FullySpecified.SynchronizeIrql      = m_SynchronizeIrql;
 
    return fxPkgPnp->m_IoConnectInterruptEx(&connectParams);
}

Referenced by Connect().

CreateWakeInterruptMachine()

_Must_inspect_result_ NTSTATUS FxInterrupt::CreateWakeInterruptMachine

(

VOID

)

Definition at line 267 of file interruptobject.cpp.

{
    NTSTATUS status;
    FxWakeInterruptMachine * fxWakeInterruptMachine = NULL;
 
    ASSERT(NULL == m_WakeInterruptMachine);
 
    fxWakeInterruptMachine = new (m_Device->m_PkgPnp->GetDriverGlobals())
                            FxWakeInterruptMachine(this);
 
    if (NULL == fxWakeInterruptMachine) {
        status = STATUS_INSUFFICIENT_RESOURCES;
        DoTraceLevelMessage(
            GetDriverGlobals(),
            TRACE_LEVEL_ERROR, TRACINGPNP,
            "WDFDEVICE 0x%p failed to allocate FxWakeInterruptMachine. %!STATUS!.",
            m_Device, status);
        goto exit;
    }
 
    status = fxWakeInterruptMachine->Initialize(m_Device->m_PkgPnp->GetDriverGlobals());
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(
            GetDriverGlobals(),
            TRACE_LEVEL_ERROR, TRACINGPNP,
            "WDFDEVICE 0x%p failed to initialize FxWakeInterruptMachine. %!STATUS!.",
            m_Device, status);
        goto exit;
    }
 
    status = fxWakeInterruptMachine->Init(
                            m_Device->m_PkgPnp,
                            FxWakeInterruptMachine::_ProcessEventInner,
                            fxWakeInterruptMachine
                            );
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(
            GetDriverGlobals(),
            TRACE_LEVEL_ERROR, TRACINGPNP,
            "WDFDEVICE 0x%p failed to init FxWakeInterruptMachine. %!STATUS!.",
            m_Device, status);
        goto exit;
    }
 
    m_WakeInterruptMachine = fxWakeInterruptMachine;
 
    fxWakeInterruptMachine->m_IsrEvent.Initialize(SynchronizationEvent,FALSE);
 
    m_Device->m_PkgPnp->WakeInterruptCreated();
 
    DoTraceLevelMessage(
        GetDriverGlobals(),
        TRACE_LEVEL_VERBOSE, TRACINGPNP,
        "WDFDEVICE 0x%p created wake interrupt",
        m_Device);
 
exit:
    if (!NT_SUCCESS(status)) {
        if (NULL != fxWakeInterruptMachine) {
            delete fxWakeInterruptMachine;
        }
    }
    return status;
}

Referenced by _CreateAndInit().

DeleteObject()

VOID FxInterrupt::DeleteObject ( VOID  )

virtual

Reimplemented from FxObject.

Definition at line 857 of file interruptobject.cpp.

{
    if (m_AddedToList) {
        //
        // Pop this off of PnP's list of interrupts.
        //
        m_Device->m_PkgPnp->RemoveInterruptObject(this);
    }
 
    if (m_CmTranslatedResource != NULL) {
        //
        // This can happen if driver explicitly deletes the interrupt in its
        // release hardware callback.
        //
        RevokeResources();
    }
 
    if (m_WakeInterruptMachine) {
        delete m_WakeInterruptMachine;
        m_WakeInterruptMachine = NULL;
    }
 
    //
    // Use the base FxObject's DeleteObject implementation which will Dispose us
    //
    FxNonPagedObject::DeleteObject(); // __super call
}

Disconnect()

_Must_inspect_result_ NTSTATUS FxInterrupt::Disconnect

(

__in ULONG

NotifyFlags

)

Definition at line 1340 of file interruptobject.cpp.

{
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
    NTSTATUS status, finalStatus;
 
    finalStatus = STATUS_SUCCESS;
    pFxDriverGlobals = GetDriverGlobals();
 
    //
    // Check to see if this interrupt object was actually assigned any
    // resources.  If it wasn't, then don't attempt to disconnect.  A
    // WDFINTERRUPT object won't be assigned any resources if the underlying
    // device wasn't granted any by the PnP manager.
    //
 
    if (m_InterruptInfo.Vector == 0) {
        return STATUS_SUCCESS;
    }
 
    if (IsWakeCapable() &&
        (NotifyFlags & NotifyResourcesArmedForWake)) {
        //
        // If an interrupt is marked as wakeable and the device has been set to
        // wake via a driver-owned ISR, leave the interrupt connected.
        //
        ASSERT(NotifyFlags & NotifyResourcesExplicitPowerDown);
 
        SetActiveForWake(TRUE);
 
        return STATUS_SUCCESS;
    }
 
    //
    // This takes care of the power-up failure path for interrupt that doesnt
    // support soft disconnect. The interrupt has already been hard
    // disconnected in power-up failure path.
    //
    if ((NotifyFlags & NotifyResourcesDisconnectInactive) &&
        (IsSoftDisconnectCapable() == FALSE) &&
        (IsActiveForWake() == FALSE)) {
        //
        // We got here to disconnect an inactive interrupt. But if
        // this interrupt is not Soft Disconnect capable then it was
        // never made inactive in the first place so nothing to do here.
        // It should already be hard disconnected by now.
        //
        ASSERT(NotifyFlags & NotifyResourcesForceDisconnect);
 
        return STATUS_SUCCESS;
    }
 
 
    if (m_Connected == FALSE) {
        //
        // No way we can be not connect and enabled
        //
        ASSERT(m_Enabled == FALSE);
 
        //
        // if m_Connected is FALSE because the driver forcefully disconnected
        // the interrupt we still want to disconnect the actual interrupt object
        // if the caller wants to force disconnect (e.g., the device is being
        // removed)
        //
        if (m_Interrupt != NULL &&
            (NotifyFlags & NotifyResourcesForceDisconnect)) {
            //
            // If the driver lets the state machine handle the interrupt state
            // we should never get here so make sure the driver forced the issue.
            //
            ASSERT(m_ForceDisconnected);
 
            goto Disconnect;
        }
 
        return STATUS_SUCCESS;
    }
 
    if (m_Enabled && ((NotifyFlags & NotifyResourcesSurpriseRemoved) == 0)) {
 
        //
        //
        // For wake capable interrupts it is possible to enter this path
        // with NotifyResourcesDisconnectInactive flag if the device fails
        // to power up after the interrupt was left connected during Dx
        //
        if (IsWakeCapable() == FALSE) {
            ASSERT((NotifyFlags & NotifyResourcesDisconnectInactive) == 0);
        }
 
        //
        // Disable the interrupt at the hardware.
        //
        status = InterruptDisable();
 
        m_Enabled = FALSE;
 
        if (!NT_SUCCESS(status)) {
            //
            // Even upon failure we continue because we don't want to leave
            // the interrupt connected when we tear down the stack.
            //
            DoTraceLevelMessage(
                pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
                "EvtInterruptDisable WDFDEVICE %p, WDFINTERRUPT %p, "
                "PKINTERRUPT %p returned %!STATUS!",
                m_Device->GetHandle(),
                GetHandle(), m_Interrupt, status);
 
            //
            // Overwrite the previous value.  Not a big deal since both are
            // errors.
            //
            finalStatus = status;
        }
    }
 
#if FX_IS_KERNEL_MODE
    //
    // Some edge-triggered interrupts may fire before the connection process is
    // finished and m_Interrupt is set. To accomodate them, we save the KINTERRUPT
    // in _InterruptThunk to m_InterruptCaptured which serves as a backup for
    // m_Interrupt. Now we need to NULL m_InterruptCaptured and ensure that
    // _InterruptThunk will not re-capture it.
    //
    if (m_IsEdgeTriggeredNonMsiInterrupt == TRUE) {
        //
        // Synchronize the setting of m_Disconnecting with any running ISRs.
        // No new ISR callbacks will run after _SynchronizeExecution returns,
        // until m_Disconnecting is set to FALSE again.
        //
        if (m_Interrupt != NULL) {
            _SynchronizeExecution(m_Interrupt, _InterruptMarkDisconnecting, this);
        }
 
        //
        // Because m_Disconnecting was set, we know the ISR
        // will not re-capture the KINTERRUPT again.
        //
        m_InterruptCaptured = NULL;
    }
#endif
 
    //
    // Now flush queued callbacks so that we know that nobody is still trying to
    // synchronize against this interrupt. For KMDF this will flush DPCs and
    // for UMDF this will send a message to reflector to flush queued DPCs.
    //
    FlushQueuedDpcs();
 
#if FX_IS_KERNEL_MODE
    //
    // Rundown the workitem if present (passive-level interrupt support or KMDF).
    // Not needed for UMDF since reflector doesn't use workitem for isr.
    //
    FlushQueuedWorkitem();
 
#endif
 
    //
    // See if we need to just do soft disconnect. Soft disconnect is done only
    // during explicit power down.
    //
    if (IsSoftDisconnectCapable() &&
        (NotifyFlags & NotifyResourcesExplicitPowerDown)) {
        ReportInactive(TRUE);
 
        goto Exit;
    }
 
    //
    // In the NP path we disable the interrupt but do not disconnect the
    // interrupt.  (That is b/c IoDisconnectInterrupt is a pagable function and
    // calling it could cause paging I/O on this device which will be unserviceable
    // because it is in Dx.
    //
    if (NotifyFlags & NotifyResourcesNP) {
        //
        // If we are in the NP path, force disconnect should not be set.  Force
        // disconnect is setup during a query remove/stop power down.
        //
        ASSERT((NotifyFlags & NotifyResourcesForceDisconnect) == 0);
 
        goto Exit;
    }
 
Disconnect:
    //
    // Disconnect the interrupt. For KMDF, this calls the kernel DDI, and for
    // UMDF, sends a sync message to reflector.
    //
    DisconnectInternal();
 
    if (IsActiveForWake()) {
        //
        // Since the interrupt has been disconnected, it not longer active
        // for wake
        //
        SetActiveForWake(FALSE);
    }
 
    m_Connected = FALSE;
 
#if FX_IS_KERNEL_MODE
    m_Active = FALSE;
#endif
 
Exit:
    m_Disconnecting = FALSE;
 
    return finalStatus;
}

Referenced by Disconnect(), ForceDisconnect(), and FxPkgPnp::NotifyResourceObjectsDx().

DisconnectInternal()

VOID FxInterrupt::DisconnectInternal

(

VOID

)

Definition at line 177 of file interruptobjectkm.cpp.

{
    IO_DISCONNECT_INTERRUPT_PARAMETERS params;
    PKINTERRUPT interruptObject;
    FxPkgPnp* fxPkgPnp;
 
    fxPkgPnp = m_Device->m_PkgPnp;
 
    //
    // Now null these pointers so that we can catch anyone trying to use them
    // erroneously.
    //
    interruptObject = m_Interrupt;
    m_Interrupt = NULL;
 
    //
    // Disconnect the interrupt.
    //
    ASSERT(fxPkgPnp->m_IoDisconnectInterruptEx != NULL);
 
    RtlZeroMemory(&params, sizeof(params));
 
    if (FxIsProcessorGroupSupported()) {
        params.Version = CONNECT_FULLY_SPECIFIED_GROUP;
    }
    else {
        params.Version = CONNECT_FULLY_SPECIFIED;
    }
 
    params.ConnectionContext.InterruptObject = interruptObject;
 
    fxPkgPnp->m_IoDisconnectInterruptEx(&params);
 
    return;
}

Referenced by Disconnect().

Dispose()

BOOLEAN FxInterrupt::Dispose ( VOID  )

virtual

Reimplemented from FxObject.

Definition at line 915 of file interruptobject.cpp.

{
    // MarkPassiveDispose() in Initialize ensures this
    ASSERT(Mx::MxGetCurrentIrql() == PASSIVE_LEVEL);
 
    FlushAndRundown();
 
    return TRUE;
}

DpcHandler()

VOID FxInterrupt::DpcHandler	(	__in_opt PVOID	SystemArgument1,
		__in_opt PVOID	SystemArgument2
	)

Definition at line 52 of file interruptobjectkm.cpp.

{
    UNREFERENCED_PARAMETER(SystemArgument1);
    UNREFERENCED_PARAMETER(SystemArgument2);
 
    ASSERT(m_EvtInterruptDpc != NULL);
 
    FX_TRACK_DRIVER(GetDriverGlobals());
 
    //
    // Call the drivers registered DpcForIsr event callback
    //
    if (m_CallbackLock != NULL) {
        KIRQL irql = 0;
 
        m_CallbackLock->Lock(&irql);
        m_EvtInterruptDpc(GetHandle(), m_Device->GetHandle());
        m_CallbackLock->Unlock(irql);
    }
    else {
        m_EvtInterruptDpc(GetHandle(), m_Device->GetHandle());
    }
 
    return;
}

FilterResourceRequirements()

VOID FxInterrupt::FilterResourceRequirements

(

__inout PIO_RESOURCE_DESCRIPTOR

IoResourceDescriptor

)

Definition at line 216 of file interruptobjectkm.cpp.

{
    //
    // Set sharing policy.
    //
    switch (m_ShareVector) {
    case WdfTrue:
        //
        // Override the bus driver's value, explicitly sharing this interrupt.
        //
        IoResourceDescriptor->ShareDisposition = CmResourceShareShared;
        break;
 
    case WdfFalse:
        //
        // Override the bus driver's value, explicitly claiming this interrupt
        // as non-shared.
        //
        IoResourceDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
        break;
 
    case WdfUseDefault:
    default:
        //
        // Leave the bus driver's value alone.
        //
        break;
    }
 
    //
    // Apply policy.  Only do this if we are running on an OS which supports
    // the notion of Interrupt Policy and if the policy is not already included
    // by the bus driver based on registry settings.
    //
    if (FxLibraryGlobals.IoConnectInterruptEx != NULL &&
        m_SetPolicy &&
        (IoResourceDescriptor->Flags & CM_RESOURCE_INTERRUPT_POLICY_INCLUDED) == 0x0) {
 
        IoResourceDescriptor->Flags |= CM_RESOURCE_INTERRUPT_POLICY_INCLUDED;
        IoResourceDescriptor->u.Interrupt.AffinityPolicy      = (IRQ_DEVICE_POLICY)m_Policy;
        IoResourceDescriptor->u.Interrupt.PriorityPolicy      = (IRQ_PRIORITY)m_Priority;
        IoResourceDescriptor->u.Interrupt.TargetedProcessors  = m_Processors.Mask;
        IoResourceDescriptor->u.Interrupt.Group               = m_Processors.Group;
    }
}

Referenced by FxPkgPnp::FilterResourceRequirements().

FlushAndRundown()

VOID FxInterrupt::FlushAndRundown ( VOID  )

private

Definition at line 1646 of file interruptobject.cpp.

{
    FxObject* pObject;
 
    //
    // This called at PASSIVE_LEVEL which is required for
    // IoDisconnectInterrupt and KeFlushQueuedDpcs
    //
    ASSERT(Mx::MxGetCurrentIrql() == PASSIVE_LEVEL);
 
    //
    // If we have the KeFlushQueuedDpcs function call it
    // to ensure the DPC routine is no longer running before
    // we release the final reference to memory and the framework objects
    //
    FlushQueuedDpcs();
 
    //
    // Do mode-specific work.
    //
    FlushAndRundownInternal();
 
    //
    // Release the reference taken in FxInterrupt::Initialize
    //
    if (m_Device != NULL) {
        pObject = m_Device;
        m_Device = NULL;
 
        pObject->RELEASE(this);
    }
 
    //
    // Release the reference taken in FxInterrupt::Initialize
    //
    RELEASE((PVOID)_InterruptThunk);
}

Referenced by Dispose().

FlushAndRundownInternal()

VOID FxInterrupt::FlushAndRundownInternal ( VOID  )

private

Definition at line 413 of file interruptobjectkm.cpp.

{
    //
    // Rundown the workitem.
    //
    if (m_SystemWorkItem != NULL) {
        m_SystemWorkItem->DeleteObject();
        m_SystemWorkItem = NULL;
    }
 
    //
    // If present, delete the default passive-lock.
    //
    if (m_DisposeWaitLock) {
        ASSERT(m_WaitLock != NULL);
        m_WaitLock->DeleteObject();
        m_WaitLock = NULL;
        m_DisposeWaitLock = FALSE;
    }
}

Referenced by FlushAndRundown().

FlushQueuedDpcs()

VOID FxInterrupt::FlushQueuedDpcs

(

VOID

)

Definition at line 283 of file interruptobjectkm.cpp.

{
    KeFlushQueuedDpcs();
}

Referenced by Disconnect(), and FlushAndRundown().

FlushQueuedWorkitem()

VOID FxInterrupt::FlushQueuedWorkitem

(

VOID

)

Definition at line 1864 of file interruptobject.cpp.

{
    if (m_SystemWorkItem != NULL) {
        m_SystemWorkItem->WaitForExit();
    }
}

Referenced by Disconnect().

ForceDisconnect()

_Must_inspect_result_ NTSTATUS FxInterrupt::ForceDisconnect

(

VOID

)

Definition at line 1576 of file interruptobject.cpp.

{
    ULONG flags;
 
    //
    // Since we have no context or coordination of power state when these calls
    // are made, our only recourse is to see if the device is power pagable or
    // not and use that as the basis for our flags.
    //
    if (m_Device->GetDeviceObjectFlags() & DO_POWER_PAGABLE) {
        flags = NotifyResourcesNoFlags;
    }
    else {
        flags = NotifyResourcesNP;
    }
 
    //
    // Log the event because the driver is not allow the state machine to handle
    // the interrupt's state.
    //
    DoTraceLevelMessage(
         GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGPNP,
         "Force disconnect called on WDFDEVICE %p, WDFINTERRUPT %p, PKINTERRUPT %p",
         m_Device->GetHandle(), GetHandle(), m_Interrupt);
 
    m_ForceDisconnected = TRUE;
 
    return Disconnect(flags);
}

ForceReconnect()

_Must_inspect_result_ NTSTATUS FxInterrupt::ForceReconnect

(

VOID

)

Definition at line 1610 of file interruptobject.cpp.

{
    ULONG flags;
 
    //
    // Since we have no context or coordination of power state when these calls
    // are made, our only recourse is to see if the device is power pagable or
    // not and use that as the basis for our flags.
    //
    if (m_Device->GetDeviceObjectFlags() & DO_POWER_PAGABLE) {
        flags = NotifyResourcesNoFlags;
    }
    else {
        flags = NotifyResourcesNP;
    }
 
    //
    // Log the event because the driver is not allow the state machine to handle
    // the interrupt's state.
    //
    DoTraceLevelMessage(
         GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGPNP,
         "Force connect called on WDFDEVICE %p, WDFINTERRUPT %p, PKINTERRUPT %p",
         m_Device->GetHandle(), GetHandle(), m_Interrupt);
 
    m_ForceDisconnected = FALSE;
 
    return Connect(flags);
}

GetDevice()

CfxDevice * FxInterrupt::GetDevice ( VOID  )

inline

Definition at line 517 of file fxinterrupt.hpp.

    {
        return m_Device;
    }

Referenced by WdfInterruptGetDevice().

GetHandle()

WDFINTERRUPT FxInterrupt::GetHandle ( VOID  )

inline

Definition at line 530 of file fxinterrupt.hpp.

    {
        return (WDFINTERRUPT) GetObjectHandle();
    }

Referenced by FxPkgPnp::NotifyResourceObjectsD0(), FxPkgPnp::NotifyResourceObjectsDx(), and FxPkgPnp::ValidateInterruptResourceCm().

GetInfo()

PWDF_INTERRUPT_INFO FxInterrupt::GetInfo

(

VOID

)

Definition at line 902 of file interruptobject.cpp.

{
    return &m_InterruptInfo;
}

GetInterruptPtr()

__inline struct _KINTERRUPT * FxInterrupt::GetInterruptPtr

(

VOID

)

Definition at line 34 of file fxinterruptkm.hpp.

{
    struct _KINTERRUPT* interrupt = m_Interrupt;
 
    if (interrupt == NULL) {
        interrupt = m_InterruptCaptured;
    }
 
    return interrupt;
}

Referenced by AcquireLock(), ReleaseLock(), Synchronize(), and WdfInterruptWdmGetInterrupt().

GetResourceIrql()

KIRQL FxInterrupt::GetResourceIrql ( VOID  )

inline

Definition at line 562 of file fxinterrupt.hpp.

    {
        return m_InterruptInfo.Irql;
    }

Referenced by FxPkgPnp::PnpAssignInterruptsSyncIrql().

GetResources()

PCM_PARTIAL_RESOURCE_DESCRIPTOR FxInterrupt::GetResources ( VOID  )

inline

Definition at line 768 of file fxinterrupt.hpp.

    {
        // Weak ref to the translated resource interrupt descriptor.
        // It is valid from prepare hardware callback to release hardware callback.
        return m_CmTranslatedResource;
    }

Referenced by FxPkgPnp::ValidateInterruptResourceCm().

GetSyncIrql()

KIRQL FxInterrupt::GetSyncIrql ( VOID  )

inline

Definition at line 554 of file fxinterrupt.hpp.

    {
        return m_SynchronizeIrql;
    }

Referenced by FxPkgPnp::PnpAssignInterruptsSyncIrql().

Initialize()

_Must_inspect_result_ NTSTATUS FxInterrupt::Initialize	(	__in CfxDevice *	Device,
		__in FxObject *	Parent,
		__in PWDF_INTERRUPT_CONFIG	Configuration
	)

Definition at line 483 of file interruptobject.cpp.

{
    NTSTATUS    status;
    FxPkgPnp*   pkgPnp;
 
    PCM_PARTIAL_RESOURCE_DESCRIPTOR cmDescRaw;
    PCM_PARTIAL_RESOURCE_DESCRIPTOR cmDescTrans;
 
    //
    // DIRQL handling: FxInterrupt can be parented by, and optionally
    //     serialize its DpcForIsr or WorItemForIsr with an FxDevice or
    //     FxIoQueue.
    //
    // Passive handling: FxInterrupt can be parented by, and optionally
    //     serialize its WorItemForIsr with an FxDevice or FxIoQueue.
 
    //
    // Add a reference to the device object we are associated with.  We will be
    // notified in Dispose to release this reference.
    //
    Device->ADDREF(this);
 
    //
    // It is important to store the Device only after taking the reference
    // because Dispose checks for m_Device != NULL to release the reference.  If
    // assign it here and then take the reference later, we can return failure
    // in between the assignment and reference and then release a reference that
    // was not taken in Dispose.
    //
    m_Device = Device;
    pkgPnp = m_Device->m_PkgPnp;
 
    //
    // NOTE:  Since Dispose always releases this reference, we *must* take this
    //        reference, so that even if we return error, the reference is
    //        still there to be removed on cleanup.
    //
    ADDREF((PVOID)_InterruptThunk);
 
    //
    // Values always supplied by the caller
    //
    m_ShareVector           = Configuration->ShareVector;
    m_FloatingSave          = Configuration->FloatingSave;
 
    m_EvtInterruptEnable    = Configuration->EvtInterruptEnable;
    m_EvtInterruptDisable   = Configuration->EvtInterruptDisable;
 
    //
    // Do further initialization
    //
    status = InitializeWorker(Parent, Configuration);
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    //
    // Update the message number used for MSI support
    //
    m_InterruptInfo.MessageNumber = pkgPnp->m_InterruptObjectCount;
 
    //
    // This logic is executed when the driver creates interrupts in its
    // EvtDevicePrepareHardware callback.
    //
    if (Configuration->InterruptRaw != NULL) {
 
        ASSERT(Configuration->InterruptTranslated != NULL);
        ASSERT(m_Device->GetDevicePnpState() != WdfDevStatePnpInit);
 
        m_CreatedInPrepareHardware = TRUE;
 
        //
        // Get the real resource descriptors not the copies.
        //
        cmDescRaw = &(CONTAINING_RECORD(Configuration->InterruptRaw,
                                        FxResourceCm,
                                        m_DescriptorClone))->m_Descriptor;
 
        cmDescTrans = &(CONTAINING_RECORD(Configuration->InterruptTranslated,
                                          FxResourceCm,
                                          m_DescriptorClone))->m_Descriptor;
        //
        // Assign resources to this interrupt.
        //
        FxInterrupt::AssignResources(cmDescRaw, cmDescTrans);
    }
 
    // Add this interrupt to the list of them being kept in the PnP package.
    pkgPnp->AddInterruptObject(this);
 
    m_AddedToList = TRUE;
 
    return STATUS_SUCCESS;
}

Referenced by _CreateAndInit().

InitializeInternal()

_Must_inspect_result_ NTSTATUS FxInterrupt::InitializeInternal	(	__in FxObject *	Parent,
		__in PWDF_INTERRUPT_CONFIG	Configuration
	)

Definition at line 38 of file interruptobjectkm.cpp.

{
    UNREFERENCED_PARAMETER(Parent);
    UNREFERENCED_PARAMETER(Configuration);
 
    DO_NOTHING();
 
    return STATUS_SUCCESS;
}

Referenced by InitializeWorker().

InitializeWorker()

_Must_inspect_result_ NTSTATUS FxInterrupt::InitializeWorker	(	__in FxObject *	Parent,
		__in PWDF_INTERRUPT_CONFIG	Configuration
	)

Definition at line 585 of file interruptobject.cpp.

{
    FxObject*           tmpObject;
    IFxHasCallbacks*    callbacks;
    NTSTATUS            status;
    CfxDeviceBase*      deviceBase;
    BOOLEAN             passiveCallbacks;
 
    const PFX_DRIVER_GLOBALS fxDriverGlobals = GetDriverGlobals();
    const WDFTYPE parentType = Parent->GetType();
 
    //
    // Init interrupt's callbacks.
    //
    m_EvtInterruptIsr       = Configuration->EvtInterruptIsr;
    m_EvtInterruptDpc       = Configuration->EvtInterruptDpc;
    m_EvtInterruptWorkItem  = Configuration->EvtInterruptWorkItem;
 
    //
    // Init soft disconnect configuration
    //
    switch (Configuration->ReportInactiveOnPowerDown) {
    case WdfTrue:
        m_UseSoftDisconnect = TRUE;
        break;
 
    case WdfFalse:
        m_UseSoftDisconnect = FALSE;
        break;
 
    case WdfUseDefault:
    default:
        //
        // Leave the driver's value alone.
        //
        break;
    }
 
    //
    // TRUE if passive-level interrupt handling is enabled for this interrupt.
    //
    m_PassiveHandling = Configuration->PassiveHandling;
 
    //
    // If the caller specified a spinlock we use it.
    //
    if (Configuration->SpinLock != NULL) {
        FxSpinLock* pFxSpinLock;
 
        FxObjectHandleGetPtr(GetDriverGlobals(),
                             Configuration->SpinLock,
                             FX_TYPE_SPIN_LOCK,
                             (PVOID*)&pFxSpinLock);
 
        pFxSpinLock->SetInterruptSpinLock();
 
        m_SpinLock = pFxSpinLock->GetLock();
    }
    else if (m_PassiveHandling == FALSE) {
        //
        // If the caller does not specify a spinlock, and this is
        // a DIRQL interrupt we use a built in one.
        // Originally this logic was added to allow Acquire/Release Lock
        // to work on W2K platforms that does not support
        // KeAcquireInterruptSpinLock.
        //
        m_SpinLock = &m_BuiltInSpinLock.Get();
    }
 
    //
    // Automatic serialization: the DPC or work-item is synchronized with
    // the parent's callback lock.
    //
 
    //
    // Get the first ancestor that implements callbacks.
    //
    deviceBase = FxDeviceBase::_SearchForDevice(Parent, &callbacks);
 
    //
    // Validate parent:
    // - the specified device (from API) must be one of the ancestors.
    // - the parent can only be a queue or a device.
    //
    if (m_DeviceBase == NULL || deviceBase != m_DeviceBase ||
        (parentType != FX_TYPE_QUEUE && parentType != FX_TYPE_DEVICE)) {
        status = STATUS_INVALID_PARAMETER;
        DoTraceLevelMessage(
            fxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
            "The specified object 0x%p is not a valid parent for a "
            "WDFINTERRUPT, WDF_INTERRUPT_CONFIG structure 0x%p passed, "
            "%!STATUS!", Parent->GetObjectHandle(), Configuration, status);
 
        return status;
    }
 
    //
    // If automatic-serialization is off, m_CallbackLock is NULL.
    // else if parent doesn't use locking, m_CallbackLock is NULL.
    // else if work-item ISR callback set, m_CallbackLock is a passive lock.
    // else m_CallbackLock is a spin-lock.
    //
    // Note: logic retrieves the parent's callback lock when automatic
    // serialization is on even if work-item or DPC callbacks are not set,
    // this is not to break the existing behavior/validation.
    //
    if (Configuration->EvtInterruptWorkItem != NULL) {
        passiveCallbacks = TRUE;
    }
    else if (Configuration->EvtInterruptDpc != NULL) {
        passiveCallbacks = FALSE;
    }
    else if (m_PassiveHandling) {
        passiveCallbacks = TRUE;
    }
    else {
        passiveCallbacks = FALSE;
    }
 
    status = _GetEffectiveLock( Parent,
                                callbacks,      // IFxHasCallbacks*
                                Configuration->AutomaticSerialization,
                                passiveCallbacks,
                                &m_CallbackLock,
                                &tmpObject      // No reference count is taken.
                                );
    if (!NT_SUCCESS(status)) {
        //
        // We should never incur this error.
        //
        ASSERT(status != STATUS_WDF_INCOMPATIBLE_EXECUTION_LEVEL);
        return status;
    }
 
    //
    // If the parent is a queue, the queue inherits the deletion constraints of the
    // interrupt object, i.e., driver cannot manually delete the queue.
    //
    if (FX_TYPE_QUEUE == parentType) {
        ((FxIoQueue*)Parent)->SetInterruptQueue();
    }
 
    //
    // Passive-level handling: init wait-lock.
    //
    if (m_PassiveHandling) {
        ASSERT(NULL == m_SpinLock);
 
        //
        //If the caller specified a waitlock, we use it.
        //
        if (Configuration->WaitLock != NULL) {
            ASSERT(m_PassiveHandling);
            FxObjectHandleGetPtr(GetDriverGlobals(),
                                 Configuration->WaitLock,
                                 FX_TYPE_WAIT_LOCK,
                                 (PVOID*)&m_WaitLock);
        }
 
        //
        // Use a default lock if none was specified.
        //
        if (NULL == m_WaitLock) {
            WDFWAITLOCK waitLock = NULL;
            WDF_OBJECT_ATTRIBUTES attributes;
 
            WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
 
            status = FxWaitLock::_Create(
                            fxDriverGlobals,
                            &attributes,
                            NULL,
                            FALSE,
                            &waitLock);
 
            if (!NT_SUCCESS(status)) {
                DoTraceLevelMessage(fxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
                                    "Could not allocate waitlock, %!STATUS!",
                                    status);
                return status;
            }
 
            FxObjectHandleGetPtr(fxDriverGlobals,
                                 waitLock,
                                 FX_TYPE_WAIT_LOCK,
                                 (PVOID*)&m_WaitLock);
            //
            // Explicitly dispose this wait-lock object.
            //
            m_DisposeWaitLock = TRUE;
        }
    }
 
    //
    // If needed, initialize the interrupt's workitem.
    // Alloacte workitem if driver specified EvtInterruptWorkitem.
    // In addition, for Umdf, allocate workitem if driver alternatively
    // specified EvtInterruptDpc. Note that driver is not allwed to specify both.
    //
    if (m_EvtInterruptWorkItem != NULL ||
        (FxLibraryGlobals.IsUserModeFramework && m_EvtInterruptDpc != NULL)) {
        status = FxSystemWorkItem::_Create(
                        fxDriverGlobals,
                        m_Device->GetDeviceObject(),
                        &m_SystemWorkItem);
 
        if (!NT_SUCCESS(status)) {
            DoTraceLevelMessage(fxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
                                "Could not allocate workitem, %!STATUS!",
                                status);
            return status;
        }
    }
 
    //
    // Do mode-apecific initialization
    //
    status = InitializeInternal(Parent, Configuration);
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    return STATUS_SUCCESS;
}

Referenced by Initialize().

InterruptDisable()

NTSTATUS FxInterrupt::InterruptDisable ( VOID  )

private

Definition at line 1795 of file interruptobject.cpp.

{
    FxInterruptDisableParameters params;
 
    params.Interrupt = this;
    params.ReturnVal = STATUS_SUCCESS;
 
    if (m_EvtInterruptDisable != NULL) {
        _SynchronizeExecution(m_Interrupt, _InterruptDisableThunk, &params);
    }
 
    return params.ReturnVal;
}

Referenced by Disconnect().

InterruptDisableInvokeCallback()

NTSTATUS FxInterrupt::InterruptDisableInvokeCallback ( VOID  )

private

Definition at line 1751 of file interruptobject.cpp.

{
    NTSTATUS status;
 
    if (m_PassiveHandling) {
        //
        // Passive-level interrupt handling: acquire our internal passive-lock
        // after the kernel acquired its own passive-lock and before invoking
        // the callback.
        //
        AcquireLock();
        status = m_EvtInterruptDisable(GetHandle(),
                                       m_Device->GetHandle());
        ReleaseLock();
    }
    else {
        //
        // DIRQL interrupt handling: invoke the callback.
        //
        status = m_EvtInterruptDisable(GetHandle(),
                                       m_Device->GetHandle());
    }
 
    return status;
}

InterruptEnable()

NTSTATUS FxInterrupt::InterruptEnable ( VOID  )

private

Definition at line 1731 of file interruptobject.cpp.

{
    FxInterruptEnableParameters params;
 
    params.Interrupt = this;
    params.ReturnVal = STATUS_SUCCESS;
 
    if (m_EvtInterruptEnable) {
        _SynchronizeExecution(m_Interrupt, _InterruptEnableThunk, &params);
    }
 
    return params.ReturnVal;
}

Referenced by Connect().

InterruptEnableInvokeCallback()

NTSTATUS FxInterrupt::InterruptEnableInvokeCallback ( VOID  )

private

Definition at line 1688 of file interruptobject.cpp.

{
    NTSTATUS status;
 
    if (m_PassiveHandling) {
        //
        // Passive-level interrupt handling: acquire our internal passive-lock
        // after the kernel acquired its own passive-lock and before invoking
        // the callback.
        //
        AcquireLock();
        status = m_EvtInterruptEnable(GetHandle(),
                                      m_Device->GetHandle());
        ReleaseLock();
    }
    else {
        //
        // DIRQL interrupt handling: invoke the callback.
        //
        status = m_EvtInterruptEnable(GetHandle(),
                                      m_Device->GetHandle());
    }
 
    return status;
}

InvokeWakeInterruptEvtIsr()

VOID FxInterrupt::InvokeWakeInterruptEvtIsr

(

VOID

)

Definition at line 347 of file interruptobject.cpp.

{
    ASSERT(m_PassiveHandling);
    ASSERT(m_WakeInterruptMachine != NULL);
 
    //
    // Acquire our internal passive-lock after the kernel acquired its own
    // passive-lock and before invoking the callback.
    //
    AcquireLock();
 
    m_WakeInterruptMachine->m_Claimed = m_EvtInterruptIsr(
                                            GetHandle(),
                                            m_InterruptInfo.MessageNumber);
    ReleaseLock();
}

IsActiveForWake()

BOOLEAN FxInterrupt::IsActiveForWake ( VOID  )

inline

Definition at line 357 of file fxinterrupt.hpp.

    {
        if ((m_WakeInterruptMachine != NULL) &&
            (m_WakeInterruptMachine->m_ActiveForWake)) {
            return TRUE;
        } else {
            return FALSE;
        }
    }

Referenced by Connect(), and Disconnect().

IsAutomaticSerialization()

__inline BOOLEAN FxInterrupt::IsAutomaticSerialization ( VOID  )

inline

Definition at line 494 of file fxinterrupt.hpp.

    {
        return m_CallbackLock != NULL ? TRUE : FALSE;
    }

IsLevelTriggered()

BOOLEAN FxInterrupt::IsLevelTriggered ( __in ULONG  Flags )

inline

Definition at line 829 of file fxinterrupt.hpp.

    {
        return ((Flags & CM_RESOURCE_INTERRUPT_LEVEL_LATCHED_BITS)
            == CM_RESOURCE_INTERRUPT_LEVEL_SENSITIVE);
    }

Referenced by AssignResources().

IsPassiveConnect()

__inline BOOLEAN FxInterrupt::IsPassiveConnect ( VOID  )

inline

Definition at line 464 of file fxinterrupt.hpp.

    {
        //
        // UMDF's handling of interrupt is split in two parts:
        // 1. framework code that runs at passive always in host process and
        //    therefore uses mode-agnostic code meant for passive-level handling,
        //    tracked through m_PassiveHandling member.
        //    field of interrupt object.
        // 2. redirector code that does passive handling of all of level-triggered
        //    interrupt and DIRQL handing of all others (edge and msi). Driver
        //    doesn't have any choice in that. The m_PassiveHandling field in the
        //    interrupt config is always set for passive for UMDF (through UMDF's
        //    init function). m_PasiveHandlingByRedirector member is present to
        //    this part of code.
        // In summary, m_PassiveHandling and m_PasiveHandlingByRedirector
        // effectively maintain how the interrupt is connected (passive or DIRQL),
        // for KMDF and UMDF respectively. This routine tells how the
        // interrupt is connnected by looking at these members.
        //
#if (FX_CORE_MODE == FX_CORE_KERNEL_MODE)
        return IsPassiveHandling();
#else
        return m_PassiveHandlingByRedirector;
#endif
    }

Referenced by AssignResources().

IsPassiveHandling()

__inline BOOLEAN FxInterrupt::IsPassiveHandling ( VOID  )

inline

Definition at line 455 of file fxinterrupt.hpp.

    {
        return m_PassiveHandling;
    }

Referenced by _Requires_lock_held_(), _Requires_lock_not_held_(), _SynchronizeExecution(), IsPassiveConnect(), and FxPkgPnp::ValidateInterruptResourceCm().

IsSharedSpinLock()

BOOLEAN FxInterrupt::IsSharedSpinLock ( VOID  )

inline

Definition at line 538 of file fxinterrupt.hpp.

    {
        return m_SpinLock != &m_BuiltInSpinLock.Get() ? TRUE : FALSE;
    }

Referenced by FxPkgPnp::PnpAssignInterruptsSyncIrql().

IsSoftDisconnectCapable()

BOOLEAN FxInterrupt::IsSoftDisconnectCapable ( VOID  )

inline

Definition at line 391 of file fxinterrupt.hpp.

    {
        if (m_UseSoftDisconnect &&
            FxLibraryGlobals.IoReportInterruptInactive != NULL &&
            m_Interrupt != NULL &&
            m_Connected) {
            return TRUE;
        }
        else {
            return FALSE;
        }
    }

Referenced by Connect(), and Disconnect().

IsSyncIrqlSet()

BOOLEAN FxInterrupt::IsSyncIrqlSet ( VOID  )

inline

Definition at line 546 of file fxinterrupt.hpp.

    {
        return m_SynchronizeIrql != PASSIVE_LEVEL ? TRUE : FALSE;
    }

Referenced by FxPkgPnp::PnpAssignInterruptsSyncIrql().

IsWakeCapable()

__inline BOOLEAN FxInterrupt::IsWakeCapable ( VOID  )

inline

Definition at line 341 of file fxinterrupt.hpp.

    {
        return ((m_WakeInterruptMachine != NULL) ? TRUE:FALSE);
    }

Referenced by Disconnect(), FxPkgPnp::SendEventToAllWakeInterrupts(), and FxPkgPnp::ValidateInterruptResourceCm().

OnPostReleaseHardware()

VOID FxInterrupt::OnPostReleaseHardware

(

VOID

)

Definition at line 891 of file interruptobject.cpp.

{
    if (m_CreatedInPrepareHardware) {
        // Delete this interrupt.
        DeleteObject();
    }
}

Referenced by FxPkgPnp::PnpReleaseHardware().

ProcessWakeInterruptEvent()

VOID FxInterrupt::ProcessWakeInterruptEvent ( __in FxWakeInterruptEvents  Event )

inline

Definition at line 370 of file fxinterrupt.hpp.

    {
        m_WakeInterruptMachine->ProcessEvent(Event);
    }

Referenced by FxPkgPnp::SendEventToAllWakeInterrupts().

QueueDeferredRoutineForIsr()

__inline BOOLEAN FxInterrupt::QueueDeferredRoutineForIsr ( VOID  )

inline

Definition at line 839 of file fxinterrupt.hpp.

    {
    //
    // Queue DPC for KMDF and workitem for UMDF. Note that driver can either
    // specify EvtInterruptDpc or EvtInterruptWorkItem, and therefore it can
    // either call WdfInterruptQueueDpcForisr or WdfInterruptQueueWorkitemForIsr.
    //
 
 
 
 
    //
#if (FX_CORE_MODE == FX_CORE_KERNEL_MODE)
        return QueueDpcForIsr();
#else
        return QueueWorkItemForIsr();
#endif
     }

Referenced by WdfInterruptQueueDpcForIsr().

QueueDpcForIsr()

BOOLEAN FxInterrupt::QueueDpcForIsr

(

VOID

)

Definition at line 82 of file interruptobjectkm.cpp.

{
    BOOLEAN queued;
 
    //
    // Using this function is optional,
    // but the caller better have registered a handler
    //
    ASSERT(m_EvtInterruptDpc != NULL);
 
    queued = KeInsertQueueDpc(&m_Dpc, this, NULL);
 
    return queued;
}

Referenced by QueueDeferredRoutineForIsr().

QueueWorkItemForIsr()

BOOLEAN FxInterrupt::QueueWorkItemForIsr

(

VOID

)

Definition at line 1812 of file interruptobject.cpp.

{
    BOOLEAN queued;
 
    //
    // Using this function is optional,
    // but the caller better have registered a handler
    //
#if ((FX_CORE_MODE)==(FX_CORE_KERNEL_MODE))
    ASSERT(m_EvtInterruptWorkItem != NULL);
#else
    ASSERT(m_EvtInterruptWorkItem != NULL || m_EvtInterruptDpc != NULL);
#endif
 
    if (Mx::MxGetCurrentIrql() > DISPATCH_LEVEL) {
        //
        // Note: if the caller runs at DIRQL, the function returns the result
        // of KeInsertQueueDpc() and not that of WorkItem.TryToQueue().
        // The latter result is lost. Docs should clarify this behavior.
        //
#if ((FX_CORE_MODE)==(FX_CORE_KERNEL_MODE))
        queued = Mx::MxInsertQueueDpc(&m_Dpc, this, NULL);
#else
        queued = FALSE;
        FX_VERIFY(INTERNAL, TRAPMSG("Not expected"));
#endif
    }
    else {
        queued = m_SystemWorkItem->TryToEnqueue(_InterruptWorkItemCallback, this);
    }
 
    return queued;
}

Referenced by QueueDeferredRoutineForIsr(), and WdfInterruptQueueWorkItemForIsr().

ReleaseLock()

VOID FxInterrupt::ReleaseLock

(

VOID

)

Definition at line 1932 of file interruptobject.cpp.

{
    if (FALSE == m_PassiveHandling) {
        struct _KINTERRUPT* kinterrupt = GetInterruptPtr();
 
        //
        // DIRQL interrupt handling.
        //
        ASSERTMSG("Can't synchronize when the interrupt isn't connected: ",
                  kinterrupt != NULL);
 
        if (NULL != kinterrupt) {
#pragma prefast(suppress:__WARNING_CALLER_FAILING_TO_HOLD, "Unable to annotate ReleaseLock for this case.");
            Mx::MxReleaseInterruptSpinLock(kinterrupt, m_OldIrql);
        }
    }
    else {
        //
        // Passive-level interrupt handling when automatic serialization is off.
        //
        ASSERT(Mx::MxGetCurrentIrql() == PASSIVE_LEVEL);
        ASSERT(m_WaitLock != NULL);
#pragma prefast(suppress:__WARNING_CALLER_FAILING_TO_HOLD, "Unable to annotate ReleaseLock for this case.");
        m_WaitLock->ReleaseLock(GetDriverGlobals());
    }
}

Referenced by _Requires_lock_held_(), InterruptDisableInvokeCallback(), InterruptEnableInvokeCallback(), and InvokeWakeInterruptEvtIsr().

ReportActive()

VOID FxInterrupt::ReportActive

(

_In_ BOOLEAN

Internal = FALSE

)

Definition at line 457 of file interruptobjectkm.cpp.

{
    IO_REPORT_INTERRUPT_ACTIVE_STATE_PARAMETERS parameters;
    FxPkgPnp* fxPkgPnp;
 
    fxPkgPnp = m_Device->m_PkgPnp;
 
    if (Internal == FALSE) {
        //
        // if the interrupt is not connected, you can't report active or inactive
        //
        if(m_Connected == FALSE || m_Interrupt == NULL) {
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_WARNING, TRACINGPNP,
                "Driver is reporting WDFINTERRUPT %p as being active even though"
                " it is not connected.",  GetHandle());
            FxVerifierDbgBreakPoint(GetDriverGlobals());
            return;
        }
 
        if (fxPkgPnp->m_IoReportInterruptActive == NULL) {
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_WARNING, TRACINGPNP,
                "Driver is calling DDI WdfInterruptReportActive() on an OS that "
                "doesn't support the DDI.");
            FxVerifierDbgBreakPoint(GetDriverGlobals());
            return;
        }
    }
 
    //
    // No need to report active if interrupt is already active
    //
    if (m_Active) {
        return;
    }
 
    RtlZeroMemory(&parameters, sizeof(parameters));
 
    if (FxIsProcessorGroupSupported()) {
        parameters.Version = CONNECT_FULLY_SPECIFIED_GROUP;
    }
    else {
        parameters.Version = CONNECT_FULLY_SPECIFIED;
    }
 
    parameters.ConnectionContext.InterruptObject = m_Interrupt;
 
    fxPkgPnp->m_IoReportInterruptActive(&parameters);
    m_Active = TRUE;
 
    return;
}

Referenced by Connect().

ReportInactive()

VOID FxInterrupt::ReportInactive

(

_In_ BOOLEAN

Internal = FALSE

)

Definition at line 514 of file interruptobjectkm.cpp.

{
    IO_REPORT_INTERRUPT_ACTIVE_STATE_PARAMETERS parameters;
    FxPkgPnp* fxPkgPnp;
 
    fxPkgPnp = m_Device->m_PkgPnp;
 
    if (Internal == FALSE) {
        //
        // if the interrupt is not connected, you can't report active or inactive
        //
        if(m_Connected == FALSE || m_Interrupt == NULL) {
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_WARNING, TRACINGPNP,
                "Driver is reporting WDFINTERRUPT %p as being inactive even though"
                " it is not connected.",  GetHandle());
            FxVerifierDbgBreakPoint(GetDriverGlobals());
            return;
        }
 
        if (fxPkgPnp->m_IoReportInterruptInactive == NULL) {
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_WARNING, TRACINGPNP,
                "Driver is calling DDI WdfInterruptReportInactive() on an OS that "
                "doesn't support the DDI.");
            FxVerifierDbgBreakPoint(GetDriverGlobals());
            return;
        }
    }
 
    //
    // No need to report Inactive if interrupt is already Inactive
    //
    if (m_Active == FALSE) {
        return;
    }
 
    RtlZeroMemory(&parameters, sizeof(parameters));
 
    if (FxIsProcessorGroupSupported()) {
        parameters.Version = CONNECT_FULLY_SPECIFIED_GROUP;
    }
    else {
        parameters.Version = CONNECT_FULLY_SPECIFIED;
    }
 
    parameters.ConnectionContext.InterruptObject = m_Interrupt;
 
    fxPkgPnp->m_IoReportInterruptInactive(&parameters);
    m_Active = FALSE;
 
    return;
}

Referenced by Disconnect().

Reset()

VOID FxInterrupt::Reset ( VOID  )

private

Definition at line 814 of file interruptobject.cpp.

{
    //
    // Other values in m_InterruptInfo survive a reset, so RtlZeroMemory is not
    // an option.  Manually set the fields that need resetting.
    //
    m_InterruptInfo.TargetProcessorSet      = 0;
    m_InterruptInfo.Group                   = 0;
    m_InterruptInfo.Irql                    = PASSIVE_LEVEL;
    m_InterruptInfo.ShareDisposition        = 0;
    m_InterruptInfo.Mode                    = LevelSensitive;
    m_InterruptInfo.Vector                  = 0;
 
    m_SynchronizeIrql = PASSIVE_LEVEL;
 
    //
    // Do mode-specific reset.
    // For KMDF, it's a no-op.
    // For UMDF, a message is sent to reflector to reset the interrupt info.
    //
    ResetInternal();
}

Referenced by FxInterrupt(), and FxPkgPnp::PnpMatchResources().

ResetInternal()

VOID FxInterrupt::ResetInternal ( VOID  )

private

Definition at line 49 of file fxinterruptkm.hpp.

{
    //
    // Does nothing for KMDF
    //
}

Referenced by Reset().

RevokeResources()

VOID FxInterrupt::RevokeResources

(

VOID

)

Definition at line 1079 of file interruptobject.cpp.

{
    ULONG messageNumber;
 
    //
    // The message # doesn't change, so we must preserve it.
    //
    messageNumber = m_InterruptInfo.MessageNumber;
 
    //
    // This will zero out all the fields and init the size (as the structure
    // can be resued again say after a rebalance).
    //
    WDF_INTERRUPT_INFO_INIT(&m_InterruptInfo);
 
    m_InterruptInfo.MessageNumber = messageNumber;
 
    //
    // Used by interrupts created during 'EvtDevicePrepareHardware' callback.
    //
    m_CmTranslatedResource = NULL;
 
    //
    // Do mode-specific work. For KMDF, it's a no-op.
    // For UMDF, send a sync message to Reflector.
    //
    RevokeResourcesInternal();
}

Referenced by DeleteObject(), and FxPkgPnp::NotifyResourceobjectsToReleaseResources().

RevokeResourcesInternal()

VOID FxInterrupt::RevokeResourcesInternal

(

VOID

)

Definition at line 60 of file fxinterruptkm.hpp.

{
    //
    // Does nothing for KMDF
    //
}

Referenced by RevokeResources().

SetActiveForWake()

VOID FxInterrupt::SetActiveForWake ( __in BOOLEAN  ActiveForWake )

inline

Definition at line 349 of file fxinterrupt.hpp.

    {
        m_WakeInterruptMachine->m_ActiveForWake = ActiveForWake;
    }

Referenced by Connect(), and Disconnect().

SetPolicy()

VOID FxInterrupt::SetPolicy	(	__in WDF_INTERRUPT_POLICY	Policy,
		__in WDF_INTERRUPT_PRIORITY	Priority,
		__in PGROUP_AFFINITY	TargetProcessorSet
	)

Definition at line 1126 of file interruptobject.cpp.

{
    //
    // We cannot apply policy for interrupts created during prepare hardware.
    //
    if (m_CreatedInPrepareHardware) {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
            "You cannot apply policy at this stage for WDFINTERRUPT 0x%p "
            "For interrupts created in EvtDevicePrepareHardware you must use "
            "EvtDeviceFilter APIs or use a pre-process routine to handle the "
            "IRP_MN_FILTER_RESOURCE_REQUIREMENT, %!STATUS!",
            GetHandle(), STATUS_INVALID_DEVICE_REQUEST);
        FxVerifierDbgBreakPoint(GetDriverGlobals());
    }
 
    m_Policy            = Policy;
    m_Priority          = Priority;
    m_Processors        = *TargetProcessorSet;
 
    //
    // Make sure OS supports processor groups, default to group 0 otherwise.
    //
    if (FxIsProcessorGroupSupported() == FALSE) {
       m_Processors.Group  = 0;
    }
 
    m_SetPolicy = TRUE;
 
    //
    // Do mode-specific work. This function does nothing for KMDF.
    // It sends a message to reflector for UMDF.
    //
    SetPolicyInternal(Policy, Priority, TargetProcessorSet);
}

SetPolicyInternal()

VOID FxInterrupt::SetPolicyInternal	(	__in WDF_INTERRUPT_POLICY	Policy,
		__in WDF_INTERRUPT_PRIORITY	Priority,
		__in PGROUP_AFFINITY	TargetProcessorSet
	)

Definition at line 88 of file fxinterruptkm.hpp.

{
    UNREFERENCED_PARAMETER(Policy);
    UNREFERENCED_PARAMETER(Priority);
    UNREFERENCED_PARAMETER(TargetProcessorSet);
 
    //
    // Does nothing for KMDF
    //
}

Referenced by SetPolicy().

SetSyncIrql()

VOID FxInterrupt::SetSyncIrql ( KIRQL  SyncIrql )

inlineprivate

Definition at line 589 of file fxinterrupt.hpp.

    {
        m_SynchronizeIrql = SyncIrql;
    }

Referenced by FxPkgPnp::PnpAssignInterruptsSyncIrql().

SharesLock()

BOOLEAN FxInterrupt::SharesLock ( FxInterrupt *  Interrupt )

inline

Definition at line 570 of file fxinterrupt.hpp.

    {
        return m_SpinLock == Interrupt->m_SpinLock ? TRUE : FALSE;
    }

Referenced by FxPkgPnp::PnpAssignInterruptsSyncIrql().

Synchronize()

BOOLEAN FxInterrupt::Synchronize	(	__in PFN_WDF_INTERRUPT_SYNCHRONIZE	Callback,
		__in WDFCONTEXT	Context
	)

Definition at line 1990 of file interruptobject.cpp.

{
    struct _KINTERRUPT* kinterrupt;
    FxInterruptSyncParameters params;
 
    params.Interrupt = this;
    params.Callback  = Callback;
    params.Context   = Context;
 
    kinterrupt = GetInterruptPtr();
 
#if (FX_CORE_MODE == FX_CORE_KERNEL_MODE)
    ASSERTMSG("Can't synchronize when the interrupt isn't connected: ",
              kinterrupt != NULL);
#endif
 
    return _SynchronizeExecution(kinterrupt,
                                 _InterruptSynchronizeThunk,
                                 &params);
}

TryToAcquireLock()

BOOLEAN FxInterrupt::TryToAcquireLock

(

VOID

)

Definition at line 1905 of file interruptobject.cpp.

{
    LONGLONG    timeout = 0;
 
    ASSERTMSG("TryToAcquireLock is only available for passive-level "
              "interrupt handling: ", m_PassiveHandling);
 
    if (FALSE == m_PassiveHandling) {
        return FALSE;
    }
 
    ASSERT(m_WaitLock != NULL);
    ASSERT(Mx::MxGetCurrentIrql() == PASSIVE_LEVEL);
 
    //
    // Passive-level interrupt handling. Automatic serialization is off.
    //
    return FxWaitLockInternal::IsLockAcquired(
                m_WaitLock->AcquireLock(GetDriverGlobals(), &timeout)
                );
}

WakeInterruptIsr()

BOOLEAN FxInterrupt::WakeInterruptIsr

(

VOID

)

Definition at line 379 of file interruptobject.cpp.

{
    ASSERT(m_WakeInterruptMachine != NULL);
 
    //
    // Queue an event in the state machine
    //
    m_WakeInterruptMachine->ProcessEvent(WakeInterruptEventIsr);
 
    GetDriverGlobals()->WaitForSignal(m_WakeInterruptMachine->m_IsrEvent.GetSelfPointer(),
                                      "Wake Interrupt ISR is stuck waiting for the device"
                                      "to power back up and driver calllback to be processed",
                                      GetHandle(),
                                      GetDriverGlobals()->DbgWaitForWakeInterruptIsrTimeoutInSec,
                                      WaitSignalBreakUnderVerifier|WaitSignalBreakUnderDebugger);
 
    //
    // State machine stores the return value of the callback in the
    // m_Claimed member variable
    //
    return m_WakeInterruptMachine->m_Claimed;
}

WorkItemHandler()

VOID FxInterrupt::WorkItemHandler

(

VOID

)

Definition at line 100 of file interruptobjectkm.cpp.

{
    ASSERT(m_EvtInterruptWorkItem != NULL );
 
    FX_TRACK_DRIVER(GetDriverGlobals());
 
    //
    // Call the drivers registered WorkItemForIsr event callback
    //
    if (m_CallbackLock != NULL) {
        KIRQL irql = 0;
 
        m_CallbackLock->Lock(&irql);
 
        FxPerfTraceWorkItem(&m_EvtInterruptWorkItem);
        m_EvtInterruptWorkItem(GetHandle(), m_Device->GetHandle());
        m_CallbackLock->Unlock(irql);
    }
    else {
        FxPerfTraceWorkItem(&m_EvtInterruptWorkItem);
        m_EvtInterruptWorkItem(GetHandle(), m_Device->GetHandle());
    }
 
    return;
}

Member Data Documentation

_InterruptDisableThunk

BOOLEAN FxInterrupt::_InterruptDisableThunk

staticprivate

Definition at line 685 of file fxinterrupt.hpp.

Referenced by InterruptDisable().

_InterruptDpcThunk

VOID FxInterrupt::_InterruptDpcThunk

staticprivate

Definition at line 622 of file fxinterrupt.hpp.

Referenced by FxInterrupt().

_InterruptEnableThunk

BOOLEAN FxInterrupt::_InterruptEnableThunk

staticprivate

Definition at line 664 of file fxinterrupt.hpp.

Referenced by InterruptEnable().

_InterruptMarkDisconnecting

BOOLEAN FxInterrupt::_InterruptMarkDisconnecting

staticprivate

Definition at line 224 of file fxinterrupt.hpp.

Referenced by Disconnect().

_InterruptSynchronizeThunk

BOOLEAN FxInterrupt::_InterruptSynchronizeThunk

staticprivate

Definition at line 617 of file fxinterrupt.hpp.

Referenced by Synchronize().

_InterruptThunk

VOID CALLBACK FxInterrupt::_InterruptThunk

staticprivate

Definition at line 611 of file fxinterrupt.hpp.

Referenced by ConnectInternal(), FlushAndRundown(), and Initialize().

_InterruptWorkItemCallback

VOID FxInterrupt::_InterruptWorkItemCallback

staticprivate

Definition at line 614 of file fxinterrupt.hpp.

Referenced by QueueWorkItemForIsr().

FxPkgPnp

friend FxInterrupt::FxPkgPnp

private

Definition at line 47 of file fxinterrupt.hpp.

m_Active

BOOLEAN FxInterrupt::m_Active

private

Definition at line 148 of file fxinterrupt.hpp.

Referenced by Connect(), Disconnect(), FxInterrupt(), ReportActive(), and ReportInactive().

m_AddedToList

BOOLEAN FxInterrupt::m_AddedToList

private

Definition at line 113 of file fxinterrupt.hpp.

Referenced by DeleteObject(), FxInterrupt(), and Initialize().

m_BuiltInSpinLock

MxLock FxInterrupt::m_BuiltInSpinLock

private

Definition at line 72 of file fxinterrupt.hpp.

Referenced by InitializeWorker(), and IsSharedSpinLock().

m_CallbackLock

FxCallbackLock* FxInterrupt::m_CallbackLock

private

Definition at line 93 of file fxinterrupt.hpp.

Referenced by DpcHandler(), FxInterrupt(), InitializeWorker(), IsAutomaticSerialization(), and WorkItemHandler().

m_CanQueue

BOOLEAN FxInterrupt::m_CanQueue

private

Definition at line 188 of file fxinterrupt.hpp.

Referenced by FxInterrupt().

m_CmTranslatedResource

PCM_PARTIAL_RESOURCE_DESCRIPTOR FxInterrupt::m_CmTranslatedResource

private

Definition at line 216 of file fxinterrupt.hpp.

Referenced by AssignResources(), DeleteObject(), FxInterrupt(), GetResources(), and RevokeResources().

m_Connected

BOOLEAN FxInterrupt::m_Connected

private

Definition at line 119 of file fxinterrupt.hpp.

Referenced by Connect(), Disconnect(), FxInterrupt(), IsSoftDisconnectCapable(), ReportActive(), and ReportInactive().

m_CreatedInPrepareHardware

BOOLEAN FxInterrupt::m_CreatedInPrepareHardware

private

Definition at line 135 of file fxinterrupt.hpp.

Referenced by FxInterrupt(), Initialize(), OnPostReleaseHardware(), and SetPolicy().

m_Disconnecting

BOOLEAN FxInterrupt::m_Disconnecting

private

Definition at line 238 of file fxinterrupt.hpp.

Referenced by Disconnect(), and FxInterrupt().

m_DisposeWaitLock

BOOLEAN FxInterrupt::m_DisposeWaitLock

private

Definition at line 98 of file fxinterrupt.hpp.

Referenced by FlushAndRundownInternal(), FxInterrupt(), and InitializeWorker().

m_Dpc

KDPC FxInterrupt::m_Dpc

private

Definition at line 85 of file fxinterrupt.hpp.

Referenced by FxInterrupt(), QueueDpcForIsr(), and QueueWorkItemForIsr().

m_Enabled

BOOLEAN FxInterrupt::m_Enabled

private

Definition at line 125 of file fxinterrupt.hpp.

Referenced by Connect(), Disconnect(), and FxInterrupt().

m_EvtInterruptDisable

PFN_WDF_INTERRUPT_DISABLE FxInterrupt::m_EvtInterruptDisable

private

Definition at line 163 of file fxinterrupt.hpp.

Referenced by FxInterrupt(), Initialize(), InterruptDisable(), and InterruptDisableInvokeCallback().

m_EvtInterruptDpc

PFN_WDF_INTERRUPT_DPC FxInterrupt::m_EvtInterruptDpc

private

Definition at line 166 of file fxinterrupt.hpp.

Referenced by DpcHandler(), FxInterrupt(), InitializeWorker(), QueueDpcForIsr(), and QueueWorkItemForIsr().

m_EvtInterruptEnable

PFN_WDF_INTERRUPT_ENABLE FxInterrupt::m_EvtInterruptEnable

private

Definition at line 162 of file fxinterrupt.hpp.

Referenced by FxInterrupt(), Initialize(), InterruptEnable(), and InterruptEnableInvokeCallback().

m_EvtInterruptIsr

PFN_WDF_INTERRUPT_ISR FxInterrupt::m_EvtInterruptIsr

private

Definition at line 165 of file fxinterrupt.hpp.

Referenced by FxInterrupt(), InitializeWorker(), and InvokeWakeInterruptEvtIsr().

m_EvtInterruptWorkItem

PFN_WDF_INTERRUPT_WORKITEM FxInterrupt::m_EvtInterruptWorkItem

private

Definition at line 167 of file fxinterrupt.hpp.

Referenced by FxInterrupt(), InitializeWorker(), QueueWorkItemForIsr(), and WorkItemHandler().

m_FloatingSave

BOOLEAN FxInterrupt::m_FloatingSave

private

Definition at line 130 of file fxinterrupt.hpp.

Referenced by Connect(), ConnectInternal(), FxInterrupt(), and Initialize().

m_ForceDisconnected

BOOLEAN FxInterrupt::m_ForceDisconnected

private

Definition at line 120 of file fxinterrupt.hpp.

Referenced by Connect(), Disconnect(), ForceDisconnect(), ForceReconnect(), and FxInterrupt().

m_Interrupt

struct _KINTERRUPT* FxInterrupt::m_Interrupt

private

Definition at line 59 of file fxinterrupt.hpp.

Referenced by Connect(), ConnectInternal(), Disconnect(), DisconnectInternal(), ForceDisconnect(), ForceReconnect(), FxInterrupt(), GetInterruptPtr(), InterruptDisable(), InterruptEnable(), IsSoftDisconnectCapable(), ReportActive(), ReportInactive(), and ~FxInterrupt().

m_InterruptCaptured

struct _KINTERRUPT* FxInterrupt::m_InterruptCaptured

private

Definition at line 231 of file fxinterrupt.hpp.

Referenced by Disconnect(), FxInterrupt(), and GetInterruptPtr().

m_InterruptInfo

WDF_INTERRUPT_INFO FxInterrupt::m_InterruptInfo

private

Definition at line 210 of file fxinterrupt.hpp.

Referenced by AssignResources(), Connect(), ConnectInternal(), Disconnect(), FxInterrupt(), GetInfo(), GetResourceIrql(), Initialize(), InvokeWakeInterruptEvtIsr(), Reset(), and RevokeResources().

m_InterruptWaitblock

FxInterruptWaitblock* FxInterrupt::m_InterruptWaitblock

private

Definition at line 181 of file fxinterrupt.hpp.

Referenced by FxInterrupt().

m_IsEdgeTriggeredNonMsiInterrupt

BOOLEAN FxInterrupt::m_IsEdgeTriggeredNonMsiInterrupt

private

Definition at line 244 of file fxinterrupt.hpp.

Referenced by AssignResources(), Disconnect(), and FxInterrupt().

m_OldIrql

KIRQL FxInterrupt::m_OldIrql

private

Definition at line 66 of file fxinterrupt.hpp.

Referenced by AcquireLock(), FxInterrupt(), and ReleaseLock().

m_PassiveHandling

BOOLEAN FxInterrupt::m_PassiveHandling

private

Definition at line 109 of file fxinterrupt.hpp.

Referenced by AcquireLock(), Connect(), FxInterrupt(), InitializeWorker(), InterruptDisableInvokeCallback(), InterruptEnableInvokeCallback(), InvokeWakeInterruptEvtIsr(), IsPassiveHandling(), ReleaseLock(), and TryToAcquireLock().

m_PassiveHandlingByRedirector

BOOLEAN FxInterrupt::m_PassiveHandlingByRedirector

private

Definition at line 204 of file fxinterrupt.hpp.

Referenced by AssignResources(), FxInterrupt(), and IsPassiveConnect().

m_PnpList

LIST_ENTRY FxInterrupt::m_PnpList

protected

Definition at line 248 of file fxinterrupt.hpp.

Referenced by FxInterrupt().

m_Policy

WDF_INTERRUPT_POLICY FxInterrupt::m_Policy

private

Definition at line 155 of file fxinterrupt.hpp.

Referenced by AssignResources(), FilterResourceRequirements(), FxInterrupt(), and SetPolicy().

m_Priority

WDF_INTERRUPT_PRIORITY FxInterrupt::m_Priority

private

Definition at line 156 of file fxinterrupt.hpp.

Referenced by AssignResources(), FilterResourceRequirements(), FxInterrupt(), and SetPolicy().

m_Processors

GROUP_AFFINITY FxInterrupt::m_Processors

private

Definition at line 157 of file fxinterrupt.hpp.

Referenced by FilterResourceRequirements(), FxInterrupt(), and SetPolicy().

m_RdInterruptContext

RD_INTERRUPT_CONTEXT FxInterrupt::m_RdInterruptContext

private

Definition at line 173 of file fxinterrupt.hpp.

Referenced by FxInterrupt().

m_SetPolicy

BOOLEAN FxInterrupt::m_SetPolicy

private

Definition at line 154 of file fxinterrupt.hpp.

Referenced by FilterResourceRequirements(), FxInterrupt(), and SetPolicy().

m_ShareVector

WDF_TRI_STATE FxInterrupt::m_ShareVector

private

Definition at line 54 of file fxinterrupt.hpp.

Referenced by FilterResourceRequirements(), FxInterrupt(), and Initialize().

m_SpinLock

MdLock* FxInterrupt::m_SpinLock

private

Definition at line 64 of file fxinterrupt.hpp.

Referenced by Connect(), ConnectInternal(), FxInterrupt(), InitializeWorker(), IsSharedSpinLock(), and SharesLock().

m_SynchronizeIrql

volatile KIRQL FxInterrupt::m_SynchronizeIrql

private

Definition at line 67 of file fxinterrupt.hpp.

Referenced by Connect(), ConnectInternal(), GetSyncIrql(), IsSyncIrqlSet(), Reset(), and SetSyncIrql().

m_SystemWorkItem

FxSystemWorkItem* FxInterrupt::m_SystemWorkItem

private

Definition at line 87 of file fxinterrupt.hpp.

Referenced by FlushAndRundownInternal(), FlushQueuedWorkitem(), FxInterrupt(), InitializeWorker(), and QueueWorkItemForIsr().

m_UseSoftDisconnect

BOOLEAN FxInterrupt::m_UseSoftDisconnect

private

Definition at line 104 of file fxinterrupt.hpp.

Referenced by FxInterrupt(), InitializeWorker(), and IsSoftDisconnectCapable().

m_WaitLock

FxWaitLock* FxInterrupt::m_WaitLock

private

Definition at line 77 of file fxinterrupt.hpp.

Referenced by AcquireLock(), FlushAndRundownInternal(), FxInterrupt(), InitializeWorker(), ReleaseLock(), and TryToAcquireLock().

m_WakeInterruptMachine

FxWakeInterruptMachine* FxInterrupt::m_WakeInterruptMachine

private

Definition at line 140 of file fxinterrupt.hpp.

Referenced by CreateWakeInterruptMachine(), DeleteObject(), FxInterrupt(), InvokeWakeInterruptEvtIsr(), IsActiveForWake(), IsWakeCapable(), ProcessWakeInterruptEvent(), SetActiveForWake(), and WakeInterruptIsr().

---

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

• sdk/lib/drivers/wdf/shared/inc/private/common/fxinterrupt.hpp
• sdk/lib/drivers/wdf/shared/inc/private/km/fxinterruptkm.hpp
• sdk/lib/drivers/wdf/shared/inc/private/um/fxinterruptum.hpp
• sdk/lib/drivers/wdf/shared/irphandlers/pnp/interruptobject.cpp
• sdk/lib/drivers/wdf/shared/irphandlers/pnp/km/interruptobjectkm.cpp
• sdk/lib/drivers/wdf/shared/irphandlers/pnp/um/interruptobjectum.cpp