ReactOS 0.4.16-dev-1946-g52006dd
Classes | Typedefs | Functions | Variables
fxinterruptapi.cpp File Reference
#include "pnppriv.hpp"
Include dependency graph for fxinterruptapi.cpp:

Go to the source code of this file.

Classes

struct  _WDF_INTERRUPT_CONFIG_V1_9
 
struct  _WDF_INTERRUPT_CONFIG_V1_11_BETA
 
struct  _WDF_INTERRUPT_CONFIG_V1_11
 

Typedefs

typedef struct _WDF_INTERRUPT_CONFIG_V1_9 WDF_INTERRUPT_CONFIG_V1_9
 
typedef struct _WDF_INTERRUPT_CONFIG_V1_9 * PWDF_INTERRUPT_CONFIG_V1_9
 
typedef struct _WDF_INTERRUPT_CONFIG_V1_11_BETA WDF_INTERRUPT_CONFIG_V1_11_BETA
 
typedef struct _WDF_INTERRUPT_CONFIG_V1_11_BETA * PWDF_INTERRUPT_CONFIG_V1_11_BETA
 
typedef struct _WDF_INTERRUPT_CONFIG_V1_11 WDF_INTERRUPT_CONFIG_V1_11
 
typedef struct _WDF_INTERRUPT_CONFIG_V1_11 * PWDF_INTERRUPT_CONFIG_V1_11
 

Functions

_Must_inspect_result_ __drv_maxIRQL (DISPATCH_LEVEL) NTSTATUS NTAPI WDFEXPORT(WdfInterruptCreate)(__in PWDF_DRIVER_GLOBALS DriverGlobals
 
 FxObjectHandleGetPtrAndGlobals (GetFxDriverGlobals(DriverGlobals), Device, FX_TYPE_DEVICE,(PVOID *)&pDevice, &pFxDriverGlobals)
 
 FxPointerNotNull (pFxDriverGlobals, Configuration)
 
 FxPointerNotNull (pFxDriverGlobals, Interrupt)
 
 if (pFxDriverGlobals->IsVersionGreaterThanOrEqualTo(1, 13))
 
else if (pFxDriverGlobals->IsVersionGreaterThanOrEqualTo(1, 11))
 
 if (Configuration->Size !=sizeof(WDF_INTERRUPT_CONFIG) &&Configuration->Size !=sizeof(WDF_INTERRUPT_CONFIG_V1_11) &&Configuration->Size !=sizeof(WDF_INTERRUPT_CONFIG_V1_11_BETA) &&Configuration->Size !=sizeof(WDF_INTERRUPT_CONFIG_V1_9))
 
 if (Configuration->Size< sizeof(WDF_INTERRUPT_CONFIG))
 
 FX_VERIFY_WITH_NAME (DRIVER(BadArgument, TODO), CHECK(ERROR_STRING_HW_ACCESS_NOT_ALLOWED,(pDevice->IsInterruptAccessAllowed()==TRUE)), DriverGlobals->DriverName)
 
 FX_VERIFY_WITH_NAME (DRIVER(BadArgument, TODO), CHECK("PassiveHandling not set to TRUE in WDF_INTERRUPT_CONFIG structure",(Configuration->PassiveHandling==TRUE)), DriverGlobals->DriverName)
 
 if (Configuration->EvtInterruptIsr==NULL)
 
 if (!NT_SUCCESS(status))
 
 if (Attributes !=NULL &&Attributes->ParentObject !=NULL)
 
 if (devicePnpState !=WdfDevStatePnpInit &&0x0==(pDevice->GetCallbackFlags() &FXDEVICE_CALLBACK_IN_PREPARE_HARDWARE))
 
 if (devicePnpState==WdfDevStatePnpInit)
 
 if (Configuration->EvtInterruptDpc !=NULL &&Configuration->EvtInterruptWorkItem !=NULL)
 
 if (NT_SUCCESS(status))
 
BOOLEAN NTAPI WDFEXPORT() WdfInterruptQueueDpcForIsr (__in PWDF_DRIVER_GLOBALS DriverGlobals, __in WDFINTERRUPT Interrupt)
 
BOOLEAN NTAPI WDFEXPORT() WdfInterruptQueueWorkItemForIsr (__in PWDF_DRIVER_GLOBALS DriverGlobals, __in WDFINTERRUPT Interrupt)
 
 FxObjectHandleGetPtr (GetFxDriverGlobals(DriverGlobals), Interrupt, FX_TYPE_INTERRUPT,(PVOID *)&pFxInterrupt)
 
 if (pFxInterrupt->IsPassiveHandling())
 
 FxPointerNotNull (pFxInterrupt->GetDriverGlobals(), Callback)
 
return pFxInterrupt Synchronize (Callback, Context)
 
__in _Requires_lock_not_held_ (_Curr_) _Acquires_lock_(_Curr_) WDFINTERRUPT Interrupt)
 
 __drv_maxIRQL (DISPATCH_LEVEL+1) VOID NTAPI WDFEXPORT(WdfInterruptReleaseLock)(__in PWDF_DRIVER_GLOBALS DriverGlobals
 
__in _Requires_lock_held_ (_Curr_) _Releases_lock_(_Curr_) WDFINTERRUPT Interrupt)
 
 __drv_maxIRQL (PASSIVE_LEVEL) VOID NTAPI WDFEXPORT(WdfInterruptEnable)(__in PWDF_DRIVER_GLOBALS DriverGlobals
 
VOID pFxInterrupt ForceReconnect ()
 
VOID pFxInterrupt ForceDisconnect ()
 
_Must_inspect_result_ struct _KINTERRUPT *NTAPI WDFEXPORT() WdfInterruptWdmGetInterrupt (__in PWDF_DRIVER_GLOBALS DriverGlobals, __in WDFINTERRUPT Interrupt)
 
 FxObjectHandleGetPtrAndGlobals (GetFxDriverGlobals(DriverGlobals), Interrupt, FX_TYPE_INTERRUPT,(PVOID *)&pFxInterrupt, &pFxDriverGlobals)
 
 FxPointerNotNull (pFxDriverGlobals, Info)
 
 if (sizeof(WDF_INTERRUPT_INFO_V1_7)==Info->Size)
 
else if (sizeof(WDF_INTERRUPT_INFO)==Info->Size)
 
 FxVerifierDbgBreakPoint (pFxDriverGlobals)
 
 RtlCopyMemory (Info, pFxInterrupt->GetInfo(), size)
 
WDFDEVICE NTAPI WDFEXPORT() WdfInterruptGetDevice (__in PWDF_DRIVER_GLOBALS DriverGlobals, __in WDFINTERRUPT Interrupt)
 
 if (Policy< WdfIrqPolicyMachineDefault||Policy > WdfIrqPolicySpreadMessagesAcrossAllProcessors)
 
 if (Priority< WdfIrqPriorityLow||Priority > WdfIrqPriorityHigh)
 
RtlZeroMemory & processorSet (processorSet)
 
pFxInterrupt SetPolicy (Policy, Priority, &processorSet)
 
 if (PolicyAndGroup->Size !=sizeof(WDF_INTERRUPT_EXTENDED_POLICY))
 
 if (policy< WdfIrqPolicyMachineDefault||policy > WdfIrqPolicySpreadMessagesAcrossAllProcessors)
 
 if (priority< WdfIrqPriorityLow||priority > WdfIrqPriorityHigh)
 
 if (processorSet->Reserved[0] !=0||processorSet->Reserved[1] !=0||processorSet->Reserved[2] !=0)
 
pFxInterrupt SetPolicy (policy, priority, processorSet)
 

Variables

_Must_inspect_result_ __in WDFDEVICE Device
 
_Must_inspect_result_ __in WDFDEVICE __in PWDF_INTERRUPT_CONFIG Configuration
 
_Must_inspect_result_ __in WDFDEVICE __in PWDF_INTERRUPT_CONFIG __in_opt PWDF_OBJECT_ATTRIBUTES Attributes
 
_Must_inspect_result_ __in WDFDEVICE __in PWDF_INTERRUPT_CONFIG __in_opt PWDF_OBJECT_ATTRIBUTES __out WDFINTERRUPT * Interrupt
 
PFX_DRIVER_GLOBALS pFxDriverGlobals = NULL
 
FxInterrupt * pFxInterrupt = NULL
 
FxDevice * pDevice
 
FxObject * pParent
 
NTSTATUS status
 
WDF_DEVICE_PNP_STATE devicePnpState = pDevice->GetDevicePnpState()
 
ULONG expectedConfigSize
 
WDF_INTERRUPT_CONFIG intConfig
 
 else
 
__in WDFINTERRUPT __in PFN_WDF_INTERRUPT_SYNCHRONIZE Callback
 
__in WDFINTERRUPT __in PFN_WDF_INTERRUPT_SYNCHRONIZE __in WDFCONTEXT Context
 
__in WDFINTERRUPT __out PWDF_INTERRUPT_INFO Info
 
ULONG size = 0
 
 return
 
Info Size = size
 
__in WDFINTERRUPT __in WDF_INTERRUPT_POLICY Policy
 
__in WDFINTERRUPT __in WDF_INTERRUPT_POLICY __in WDF_INTERRUPT_PRIORITY Priority
 
__in WDFINTERRUPT __in WDF_INTERRUPT_POLICY __in WDF_INTERRUPT_PRIORITY __in KAFFINITY TargetProcessorSet
 
GROUP_AFFINITY processorSet = NULL
 
processorSet Mask = TargetProcessorSet
 
__in WDFINTERRUPT __in PWDF_INTERRUPT_EXTENDED_POLICY PolicyAndGroup
 
WDF_INTERRUPT_POLICY policy = PolicyAndGroup->Policy
 
WDF_INTERRUPT_PRIORITY priority = PolicyAndGroup->Priority
 

Typedef Documentation

◆ PWDF_INTERRUPT_CONFIG_V1_11

typedef struct _WDF_INTERRUPT_CONFIG_V1_11 * PWDF_INTERRUPT_CONFIG_V1_11

◆ PWDF_INTERRUPT_CONFIG_V1_11_BETA

typedef struct _WDF_INTERRUPT_CONFIG_V1_11_BETA * PWDF_INTERRUPT_CONFIG_V1_11_BETA

◆ PWDF_INTERRUPT_CONFIG_V1_9

typedef struct _WDF_INTERRUPT_CONFIG_V1_9 * PWDF_INTERRUPT_CONFIG_V1_9

◆ WDF_INTERRUPT_CONFIG_V1_11

typedef struct _WDF_INTERRUPT_CONFIG_V1_11 WDF_INTERRUPT_CONFIG_V1_11

◆ WDF_INTERRUPT_CONFIG_V1_11_BETA

typedef struct _WDF_INTERRUPT_CONFIG_V1_11_BETA WDF_INTERRUPT_CONFIG_V1_11_BETA

◆ WDF_INTERRUPT_CONFIG_V1_9

typedef struct _WDF_INTERRUPT_CONFIG_V1_9 WDF_INTERRUPT_CONFIG_V1_9

Function Documentation

◆ __drv_maxIRQL() [1/3]

_Must_inspect_result_ __drv_maxIRQL ( DISPATCH_LEVEL  )

◆ __drv_maxIRQL() [2/3]

__drv_maxIRQL ( DISPATCH_LEVEL+  1)

◆ __drv_maxIRQL() [3/3]

__drv_maxIRQL ( PASSIVE_LEVEL  )

◆ _Requires_lock_held_()

__in _Requires_lock_held_ ( _Curr_  )

Definition at line 815 of file fxinterruptapi.cpp.

834{
835 DDI_ENTRY();
836
837 FxInterrupt* pFxInterrupt;
838 NTSTATUS status;
839
840 FxObjectHandleGetPtr(GetFxDriverGlobals(DriverGlobals),
841 Interrupt,
842 FX_TYPE_INTERRUPT,
843 (PVOID*)&pFxInterrupt);
844
845 if (pFxInterrupt->IsPassiveHandling()) {
846 status = FxVerifierCheckIrqlLevel(pFxInterrupt->GetDriverGlobals(),
847 PASSIVE_LEVEL);
848 if (!NT_SUCCESS(status)) {
849 return;
850 }
851 }
852
853 pFxInterrupt->ReleaseLock();
854}
NTSTATUS
LONG NTSTATUS
Definition: precomp.h:26
FxInterrupt::IsPassiveHandling
__inline BOOLEAN IsPassiveHandling(VOID)
Definition: fxinterrupt.hpp:455
FxInterrupt::ReleaseLock
VOID ReleaseLock(VOID)
Definition: interruptobject.cpp:1943
FxObject::GetDriverGlobals
__inline PFX_DRIVER_GLOBALS GetDriverGlobals(VOID)
Definition: fxobject.hpp:734
NT_SUCCESS
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:33
PASSIVE_LEVEL
#define PASSIVE_LEVEL
Definition: env_spec_w32.h:693
GetFxDriverGlobals
__inline PFX_DRIVER_GLOBALS GetFxDriverGlobals(__in PWDF_DRIVER_GLOBALS DriverGlobals)
Definition: fxglobals.h:597
DDI_ENTRY
#define DDI_ENTRY()
Definition: fxglobalskm.h:56
status
NTSTATUS status
Definition: fxinterruptapi.cpp:237
pFxInterrupt
FxInterrupt * pFxInterrupt
Definition: fxinterruptapi.cpp:234
FxObjectHandleGetPtr
FxObjectHandleGetPtr(GetFxDriverGlobals(DriverGlobals), Interrupt, FX_TYPE_INTERRUPT,(PVOID *)&pFxInterrupt)
FX_TYPE_INTERRUPT
@ FX_TYPE_INTERRUPT
Definition: fxtypes.h:80
FxVerifierCheckIrqlLevel
__inline NTSTATUS FxVerifierCheckIrqlLevel(__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in KIRQL Irql)
Definition: fxverifier.h:158
status
Definition: ps.c:97
Interrupt
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_INTERRUPT_CONFIG _In_opt_ PWDF_OBJECT_ATTRIBUTES _Out_ WDFINTERRUPT * Interrupt
Definition: wdfinterrupt.h:379

◆ _Requires_lock_not_held_()

__in _Requires_lock_not_held_ ( _Curr_  )

Definition at line 767 of file fxinterruptapi.cpp.

786{
787 DDI_ENTRY();
788
789 FxInterrupt* pFxInterrupt;
790 NTSTATUS status;
791
792 FxObjectHandleGetPtr(GetFxDriverGlobals(DriverGlobals),
793 Interrupt,
794 FX_TYPE_INTERRUPT,
795 (PVOID*)&pFxInterrupt);
796
797 if (pFxInterrupt->IsPassiveHandling()) {
798 status = FxVerifierCheckIrqlLevel(pFxInterrupt->GetDriverGlobals(),
799 PASSIVE_LEVEL);
800 if (!NT_SUCCESS(status)) {
801 return;
802 }
803 }
804
805 pFxInterrupt->AcquireLock();
806}
FxInterrupt::AcquireLock
VOID AcquireLock(VOID)
Definition: interruptobject.cpp:1888

◆ ForceDisconnect()

VOID pFxInterrupt ForceDisconnect ( )

◆ ForceReconnect()

VOID pFxInterrupt ForceReconnect ( )

◆ FX_VERIFY_WITH_NAME() [1/2]

FX_VERIFY_WITH_NAME ( DRIVER(BadArgument, TODO)  ,
CHECK("PassiveHandling not set to TRUE in WDF_INTERRUPT_CONFIG structure",(Configuration->PassiveHandling==TRUE))  ,
DriverGlobals->  DriverName 
)

◆ FX_VERIFY_WITH_NAME() [2/2]

FX_VERIFY_WITH_NAME ( DRIVER(BadArgument, TODO)  ,
CHECK(ERROR_STRING_HW_ACCESS_NOT_ALLOWED,(pDevice->IsInterruptAccessAllowed()==TRUE))  ,
DriverGlobals->  DriverName 
)

◆ FxObjectHandleGetPtr()

FxObjectHandleGetPtr ( GetFxDriverGlobals(DriverGlobals)  ,
Interrupt  ,
FX_TYPE_INTERRUPT  ,
(PVOID *)&  pFxInterrupt 
)

Referenced by __drv_maxIRQL(), _Requires_lock_held_(), _Requires_lock_not_held_(), if(), WdfInterruptGetDevice(), WdfInterruptQueueDpcForIsr(), WdfInterruptQueueWorkItemForIsr(), and WdfInterruptWdmGetInterrupt().

◆ FxObjectHandleGetPtrAndGlobals() [1/2]

FxObjectHandleGetPtrAndGlobals ( GetFxDriverGlobals(DriverGlobals)  ,
Device  ,
FX_TYPE_DEVICE  ,
(PVOID *)&  pDevice,
&  pFxDriverGlobals 
)

◆ FxObjectHandleGetPtrAndGlobals() [2/2]

FxObjectHandleGetPtrAndGlobals ( GetFxDriverGlobals(DriverGlobals)  ,
Interrupt  ,
FX_TYPE_INTERRUPT  ,
(PVOID *)&  pFxInterrupt,
&  pFxDriverGlobals 
)

◆ FxPointerNotNull() [1/4]

FxPointerNotNull ( pFxDriverGlobals  ,
Configuration   
)

◆ FxPointerNotNull() [2/4]

FxPointerNotNull ( pFxDriverGlobals  ,
Info   
)

◆ FxPointerNotNull() [3/4]

FxPointerNotNull ( pFxDriverGlobals  ,
Interrupt   
)

◆ FxPointerNotNull() [4/4]

FxPointerNotNull ( pFxInterrupt->  GetDriverGlobals(),
Callback   
)

◆ FxVerifierDbgBreakPoint()

FxVerifierDbgBreakPoint ( pFxDriverGlobals  )

Referenced by if().

◆ if() [1/20]

if ( !  NT_SUCCESSstatus)

Definition at line 339 of file fxinterruptapi.cpp.

339 {
340 return status;
341 }

◆ if() [2/20]

if ( Attributes !  = NULL && Attributes->ParentObject != NULL)

Definition at line 343 of file fxinterruptapi.cpp.

343 {
344 FxObjectHandleGetPtr(pFxDriverGlobals,
345 Attributes->ParentObject,
346 FX_TYPE_OBJECT,
347 (PVOID*)&pParent);
348 }
pParent
FxObject * pParent
Definition: fxinterruptapi.cpp:236
pFxDriverGlobals
PFX_DRIVER_GLOBALS pFxDriverGlobals
Definition: fxinterruptapi.cpp:233
FX_TYPE_OBJECT
@ FX_TYPE_OBJECT
Definition: fxtypes.h:45
Attributes
_Must_inspect_result_ _In_ WDFDMAENABLER _In_ _In_opt_ PWDF_OBJECT_ATTRIBUTES Attributes
Definition: wdfcommonbuffer.h:97

◆ if() [3/20]

if ( Configuration->EvtInterruptDpc !  = NULL && Configuration->EvtInterruptWorkItem != NULL)

Definition at line 495 of file fxinterruptapi.cpp.

496 {
497 status = STATUS_INVALID_PARAMETER;
498 DoTraceLevelMessage(
499 pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
500 "Driver can provide either EvtInterruptDpc or "
501 "EvtInterruptWorkItem callback but not both. "
502 "WDF_INTERRUPT_CONFIG structure 0x%p passed, %!STATUS!",
503 Configuration, status);
504
505 return status;
506 }
TRACINGPNP
#define TRACINGPNP
Definition: dbgtrace.h:67
DoTraceLevelMessage
DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGPNP, "Enter, WDFDEVICE %p", Device)
TRACE_LEVEL_ERROR
#define TRACE_LEVEL_ERROR
Definition: storswtr.h:27
STATUS_INVALID_PARAMETER
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
Configuration
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_INTERRUPT_CONFIG Configuration
Definition: wdfinterrupt.h:374

◆ if() [4/20]

if ( Configuration->  EvtInterruptIsr = = NULL)

Definition at line 322 of file fxinterruptapi.cpp.

322 {
323 DoTraceLevelMessage(
324 pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
325 "NULL EvtInterruptIsr in WDF_INTERRUPT_CONFIG structure 0x%p"
326 " passed", Configuration);
327 return STATUS_INVALID_PARAMETER;
328 }

◆ if() [5/20]

if ( Configuration->Size !  = sizeof(WDF_INTERRUPT_CONFIG) && Configuration->Size != sizeof(WDF_INTERRUPT_CONFIG_V1_11) && Configuration->Size != sizeof(WDF_INTERRUPT_CONFIG_V1_11_BETA) && Configuration->Size != sizeof(WDF_INTERRUPT_CONFIG_V1_9))

Definition at line 264 of file fxinterruptapi.cpp.

267 {
268
269 DoTraceLevelMessage(
270 pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
271 "WDF_INTERRUPT_CONFIG size 0x%x incorrect, expected 0x%x",
272 Configuration->Size, expectedConfigSize);
273
274 return STATUS_INFO_LENGTH_MISMATCH;
275 }
expectedConfigSize
ULONG expectedConfigSize
Definition: fxinterruptapi.cpp:239
STATUS_INFO_LENGTH_MISMATCH
#define STATUS_INFO_LENGTH_MISMATCH
Definition: udferr_usr.h:133

◆ if() [6/20]

if ( )

Definition at line 280 of file fxinterruptapi.cpp.

280 {
281 //
282 // Init new fields to default values.
283 //
284 WDF_INTERRUPT_CONFIG_INIT(&intConfig,
285 Configuration->EvtInterruptIsr,
286 Configuration->EvtInterruptDpc);
287 //
288 // Copy over existing fields and readjust the struct size.
289 //
290 RtlCopyMemory(&intConfig, Configuration, Configuration->Size);
291 intConfig.Size = sizeof(intConfig);
292
293 //
294 // Use new config structure from now on.
295 //
296 Configuration = &intConfig;
297 }
intConfig
WDF_INTERRUPT_CONFIG intConfig
Definition: fxinterruptapi.cpp:240
_WDF_INTERRUPT_CONFIG::EvtInterruptIsr
PFN_WDF_INTERRUPT_ISR EvtInterruptIsr
Definition: wdfinterrupt.h:225
_WDF_INTERRUPT_CONFIG::Size
ULONG Size
Definition: wdfinterrupt.h:203
RtlCopyMemory
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
WDF_INTERRUPT_CONFIG_INIT
FORCEINLINE VOID WDF_INTERRUPT_CONFIG_INIT(_Out_ PWDF_INTERRUPT_CONFIG Configuration, _In_ PFN_WDF_INTERRUPT_ISR EvtInterruptIsr, _In_opt_ PFN_WDF_INTERRUPT_DPC EvtInterruptDpc)
Definition: wdfinterrupt.h:271

◆ if() [7/20]

if ( devicePnpState !  = WdfDevStatePnpInit && 0x0 == (pDevice->GetCallbackFlags() &                    FXDEVICE_CALLBACK_IN_PREPARE_HARDWARE))

Definition at line 355 of file fxinterruptapi.cpp.

357 {
358
359 status = STATUS_INVALID_DEVICE_STATE;
360
361 DoTraceLevelMessage(
362 pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
363 "WDFINTERRUPTs can only be created during: "
364 "(1) EvtDriverDeviceAdd when the WDFDEVICE %p is initially created, or "
365 "(2) EvtDevicePrepareHardware, %!STATUS!", Device, status);
366
367 return status;
368 }
STATUS_INVALID_DEVICE_STATE
#define STATUS_INVALID_DEVICE_STATE
Definition: udferr_usr.h:178
Device
_Must_inspect_result_ _In_ WDFDEVICE Device
Definition: wdfchildlist.h:474

◆ if() [8/20]

if ( devicePnpState  = = WdfDevStatePnpInit)

Definition at line 374 of file fxinterruptapi.cpp.

374 {
375
376 if (Configuration->InterruptRaw != NULL ||
377 Configuration->InterruptTranslated != NULL) {
378
379 status = STATUS_INVALID_PARAMETER;
380
381 DoTraceLevelMessage(
382 pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
383 "Not NULL InterruptRaw or InterruptTranslated in "
384 "WDF_INTERRUPT_CONFIG structure 0x%p passed, %!STATUS!",
385 Configuration, status);
386
387 return status;
388 }
389
390 //
391 // Wake Interrupts can not be created in AddDevice as it is
392 // not known if they are actually marked as wake capable
393 //
394 if (Configuration->CanWakeDevice) {
395 status = STATUS_INVALID_PARAMETER;
396
397 DoTraceLevelMessage(
398 pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
399 "CanWakeDevice set in WDF_INTERRUPT_CONFIG structure 0x%p"
400 "during EvtDriverDeviceAdd, %!STATUS!",
401 Configuration, status);
402
403 return status;
404 }
405 }
NULL
#define NULL
Definition: types.h:112

◆ if() [9/20]

if ( NT_SUCCESS(status)  )

Definition at line 614 of file fxinterruptapi.cpp.

614 {
615 *Interrupt = (WDFINTERRUPT) pFxInterrupt->GetObjectHandle();
616 }
FxObject::GetObjectHandle
PVOID __inline GetObjectHandle(VOID)
Definition: fxobject.hpp:603

◆ if() [10/20]

else if ( pFxDriverGlobals->  IsVersionGreaterThanOrEqualTo1, 11)

Definition at line 253 of file fxinterruptapi.cpp.

253 {
254 expectedConfigSize = sizeof(WDF_INTERRUPT_CONFIG_V1_11);
255 } else {
WDF_INTERRUPT_CONFIG_V1_11
struct _WDF_INTERRUPT_CONFIG_V1_11 WDF_INTERRUPT_CONFIG_V1_11

◆ if() [11/20]

if ( pFxDriverGlobals->  IsVersionGreaterThanOrEqualTo1, 13)

Definition at line 251 of file fxinterruptapi.cpp.

251 {
252 expectedConfigSize = sizeof(WDF_INTERRUPT_CONFIG);
253 } else if (pFxDriverGlobals->IsVersionGreaterThanOrEqualTo(1,11)) {
_FX_DRIVER_GLOBALS::IsVersionGreaterThanOrEqualTo
_Must_inspect_result_ BOOLEAN IsVersionGreaterThanOrEqualTo(__in ULONG Major, __in ULONG Minor)
Definition: globalskm.cpp:92
WDF_INTERRUPT_CONFIG
struct _WDF_INTERRUPT_CONFIG WDF_INTERRUPT_CONFIG

◆ if() [12/20]

if ( pFxInterrupt->  IsPassiveHandling())

Definition at line 747 of file fxinterruptapi.cpp.

747 {
748 status = FxVerifierCheckIrqlLevel(pFxInterrupt->GetDriverGlobals(),
749 PASSIVE_LEVEL);
750 if (!NT_SUCCESS(status)) {
751 return FALSE;
752 }
753 }
FALSE
#define FALSE
Definition: types.h:117

◆ if() [13/20]

if ( Policy< WdfIrqPolicyMachineDefault||Policy >  WdfIrqPolicySpreadMessagesAcrossAllProcessors)

Definition at line 1134 of file fxinterruptapi.cpp.

1135 {
1136 DoTraceLevelMessage(
1137 pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
1138 "Policy %d is out of range", Policy);
1139 FxVerifierDbgBreakPoint(pFxDriverGlobals);
1140 return;
1141 }
FxVerifierDbgBreakPoint
FxVerifierDbgBreakPoint(pFxDriverGlobals)
Policy
_In_ WDFINTERRUPT _In_ WDF_INTERRUPT_POLICY Policy
Definition: wdfinterrupt.h:653

◆ if() [14/20]

if ( policy< WdfIrqPolicyMachineDefault||policy >  WdfIrqPolicySpreadMessagesAcrossAllProcessors)

Definition at line 1219 of file fxinterruptapi.cpp.

1220 {
1221 DoTraceLevelMessage(
1222 pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
1223 "Policy %d is out of range", policy);
1224 FxVerifierDbgBreakPoint(pFxDriverGlobals);
1225 return;
1226 }
policy
WDF_INTERRUPT_POLICY policy
Definition: fxinterruptapi.cpp:1195

◆ if() [15/20]

if ( PolicyAndGroup->Size !  = sizeof(WDF_INTERRUPT_EXTENDED_POLICY))

Definition at line 1204 of file fxinterruptapi.cpp.

1204 {
1205 DoTraceLevelMessage(
1206 pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
1207 "WDF_INTERRUPT_EXTENDED_POLICY %p Size %d invalid, expected %d",
1208 PolicyAndGroup,
1209 PolicyAndGroup->Size,
1210 sizeof(WDF_INTERRUPT_EXTENDED_POLICY));
1211 FxVerifierDbgBreakPoint(pFxDriverGlobals);
1212 return;
1213 }
_WDF_INTERRUPT_EXTENDED_POLICY
Definition: wdfinterrupt.h:336
PolicyAndGroup
_In_ WDFINTERRUPT _In_ PWDF_INTERRUPT_EXTENDED_POLICY PolicyAndGroup
Definition: wdfinterrupt.h:691

◆ if() [16/20]

if ( Priority< WdfIrqPriorityLow||Priority >  WdfIrqPriorityHigh)

Definition at line 1143 of file fxinterruptapi.cpp.

1143 {
1144 DoTraceLevelMessage(
1145 pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
1146 "Priority %d is out of range", Priority);
1147 FxVerifierDbgBreakPoint(pFxDriverGlobals);
1148 return;
1149 }
Priority
_In_ WDFINTERRUPT _In_ WDF_INTERRUPT_POLICY _In_ WDF_INTERRUPT_PRIORITY Priority
Definition: wdfinterrupt.h:655

◆ if() [17/20]

if ( priority< WdfIrqPriorityLow||priority >  WdfIrqPriorityHigh)

Definition at line 1228 of file fxinterruptapi.cpp.

1228 {
1229 DoTraceLevelMessage(
1230 pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
1231 "Priority %d is out of range", priority);
1232 FxVerifierDbgBreakPoint(pFxDriverGlobals);
1233 return;
1234 }
priority
WDF_INTERRUPT_PRIORITY priority
Definition: fxinterruptapi.cpp:1196

◆ if() [18/20]

if ( processorSet->Reserved !  [0] = 0 || processorSet->Reserved[1] != 0 || processorSet->Reserved[2] != 0)

Definition at line 1236 of file fxinterruptapi.cpp.

1237 {
1238 DoTraceLevelMessage(
1239 pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
1240 "TargetProcessorSet's reserved fields are not zero");
1241 FxVerifierDbgBreakPoint(pFxDriverGlobals);
1242 return;
1243 }

◆ if() [19/20]

else if ( sizeof(WDF_INTERRUPT_INFO)  = = Info->Size)

Definition at line 1032 of file fxinterruptapi.cpp.

1032 {
1033 size = sizeof(WDF_INTERRUPT_INFO);
1034 }
size
GLsizeiptr size
Definition: glext.h:5919
WDF_INTERRUPT_INFO
struct _WDF_INTERRUPT_INFO WDF_INTERRUPT_INFO

◆ if() [20/20]

if ( sizeof(WDF_INTERRUPT_INFO_V1_7)  = = Info->Size)

Definition at line 1029 of file fxinterruptapi.cpp.

1029 {
1030 size = sizeof(WDF_INTERRUPT_INFO_V1_7);
1031 }
WDF_INTERRUPT_INFO_V1_7
struct _WDF_INTERRUPT_INFO_V1_7 WDF_INTERRUPT_INFO_V1_7

◆ processorSet()

RtlZeroMemory & processorSet ( processorSet  )

◆ RtlCopyMemory()

RtlCopyMemory ( Info  ,
pFxInterrupt->  GetInfo(),
size   
)

◆ SetPolicy() [1/2]

pFxInterrupt SetPolicy ( Policy  ,
Priority  ,
&  processorSet 
)

◆ SetPolicy() [2/2]

pFxInterrupt SetPolicy ( policy  ,
priority  ,
processorSet   
)

◆ Synchronize()

return pFxInterrupt Synchronize ( Callback  ,
Context   
)

◆ WdfInterruptGetDevice()

WDFDEVICE NTAPI WDFEXPORT() WdfInterruptGetDevice ( __in PWDF_DRIVER_GLOBALS  DriverGlobals,
__in WDFINTERRUPT  Interrupt 
)

Definition at line 1051 of file fxinterruptapi.cpp.

1074{
1075 DDI_ENTRY();
1076
1077 FxInterrupt* pFxInterrupt;
1078
1079 FxObjectHandleGetPtr(GetFxDriverGlobals(DriverGlobals),
1080 Interrupt,
1081 FX_TYPE_INTERRUPT,
1082 (PVOID*)&pFxInterrupt);
1083
1084 return pFxInterrupt->GetDevice()->GetHandle();
1085}
FxDeviceBase::GetHandle
WDFDEVICE __inline GetHandle(VOID)
Definition: fxdevice.hpp:237
FxInterrupt::GetDevice
CfxDevice * GetDevice(VOID)
Definition: fxinterrupt.hpp:517

◆ WdfInterruptQueueDpcForIsr()

BOOLEAN NTAPI WDFEXPORT() WdfInterruptQueueDpcForIsr ( __in PWDF_DRIVER_GLOBALS  DriverGlobals,
__in WDFINTERRUPT  Interrupt 
)

Definition at line 623 of file fxinterruptapi.cpp.

648{
649 DDI_ENTRY();
650
651 FxInterrupt* pFxInterrupt;
652
653 FxObjectHandleGetPtr(GetFxDriverGlobals(DriverGlobals),
654 Interrupt,
655 FX_TYPE_INTERRUPT,
656 (PVOID*)&pFxInterrupt);
657
658 return pFxInterrupt->QueueDeferredRoutineForIsr();
659}
FxInterrupt::QueueDeferredRoutineForIsr
__inline BOOLEAN QueueDeferredRoutineForIsr(VOID)
Definition: fxinterrupt.hpp:839

◆ WdfInterruptQueueWorkItemForIsr()

BOOLEAN NTAPI WDFEXPORT() WdfInterruptQueueWorkItemForIsr ( __in PWDF_DRIVER_GLOBALS  DriverGlobals,
__in WDFINTERRUPT  Interrupt 
)

Definition at line 663 of file fxinterruptapi.cpp.

689{
690 DDI_ENTRY();
691
692 FxInterrupt* pFxInterrupt;
693
694 FxObjectHandleGetPtr(GetFxDriverGlobals(DriverGlobals),
695 Interrupt,
696 FX_TYPE_INTERRUPT,
697 (PVOID*)&pFxInterrupt);
698
699 return pFxInterrupt->QueueWorkItemForIsr();
700}
FxInterrupt::QueueWorkItemForIsr
BOOLEAN QueueWorkItemForIsr(VOID)
Definition: interruptobject.cpp:1823

◆ WdfInterruptWdmGetInterrupt()

_Must_inspect_result_ struct _KINTERRUPT *NTAPI WDFEXPORT() WdfInterruptWdmGetInterrupt ( __in PWDF_DRIVER_GLOBALS  DriverGlobals,
__in WDFINTERRUPT  Interrupt 
)

Definition at line 953 of file fxinterruptapi.cpp.

974{
975 DDI_ENTRY();
976
977 FxInterrupt* pFxInterrupt;
978
979 FxObjectHandleGetPtr(GetFxDriverGlobals(DriverGlobals),
980 Interrupt,
981 FX_TYPE_INTERRUPT,
982 (PVOID*)&pFxInterrupt);
983
984 return pFxInterrupt->GetInterruptPtr();
985}
FxInterrupt::GetInterruptPtr
struct _KINTERRUPT * GetInterruptPtr(VOID)
Definition: fxinterruptkm.hpp:34

Variable Documentation

◆ Attributes

_Must_inspect_result_ __in WDFDEVICE __in PWDF_INTERRUPT_CONFIG __in_opt PWDF_OBJECT_ATTRIBUTES Attributes

Definition at line 202 of file fxinterruptapi.cpp.

◆ Callback

__in WDFINTERRUPT __in PFN_WDF_INTERRUPT_SYNCHRONIZE Callback

Definition at line 711 of file fxinterruptapi.cpp.

◆ Configuration

_Must_inspect_result_ __in WDFDEVICE __in PWDF_INTERRUPT_CONFIG Configuration

Definition at line 200 of file fxinterruptapi.cpp.

◆ Context

__in WDFINTERRUPT __in PFN_WDF_INTERRUPT_SYNCHRONIZE __in WDFCONTEXT Context
Initial value:
{
DDI_ENTRY()

Definition at line 713 of file fxinterruptapi.cpp.

◆ Device

_Must_inspect_result_ __in WDFDEVICE Device

Definition at line 198 of file fxinterruptapi.cpp.

◆ devicePnpState

devicePnpState = pDevice->GetDevicePnpState()

Definition at line 238 of file fxinterruptapi.cpp.

◆ else

else
Initial value:
{
expectedConfigSize = sizeof(WDF_INTERRUPT_CONFIG_V1_9)
WDF_INTERRUPT_CONFIG_V1_9
struct _WDF_INTERRUPT_CONFIG_V1_9 WDF_INTERRUPT_CONFIG_V1_9

Definition at line 255 of file fxinterruptapi.cpp.

◆ expectedConfigSize

ULONG expectedConfigSize

Definition at line 239 of file fxinterruptapi.cpp.

Referenced by if().

◆ Info

__in WDFINTERRUPT __out PWDF_INTERRUPT_INFO Info
Initial value:
{
DDI_ENTRY()

Definition at line 996 of file fxinterruptapi.cpp.

◆ intConfig

WDF_INTERRUPT_CONFIG intConfig

Definition at line 240 of file fxinterruptapi.cpp.

Referenced by if().

◆ Interrupt

__in WDFINTERRUPT Interrupt
Initial value:
{
DDI_ENTRY()

Definition at line 204 of file fxinterruptapi.cpp.

◆ Mask

processorSet Mask = TargetProcessorSet

Definition at line 1152 of file fxinterruptapi.cpp.

◆ pDevice

FxDevice* pDevice

Definition at line 235 of file fxinterruptapi.cpp.

◆ pFxDriverGlobals

PFX_DRIVER_GLOBALS pFxDriverGlobals = NULL

Definition at line 233 of file fxinterruptapi.cpp.

Referenced by if().

◆ pFxInterrupt

FxInterrupt * pFxInterrupt = NULL

Definition at line 234 of file fxinterruptapi.cpp.

Referenced by __drv_maxIRQL(), FxInterrupt::_CreateAndInit(), _Requires_lock_held_(), _Requires_lock_not_held_(), if(), WdfInterruptGetDevice(), WdfInterruptQueueDpcForIsr(), WdfInterruptQueueWorkItemForIsr(), and WdfInterruptWdmGetInterrupt().

◆ Policy

__in WDFINTERRUPT __in WDF_INTERRUPT_POLICY Policy

Definition at line 1096 of file fxinterruptapi.cpp.

◆ policy

policy = PolicyAndGroup->Policy

Definition at line 1195 of file fxinterruptapi.cpp.

Referenced by if().

◆ PolicyAndGroup

__in WDFINTERRUPT __in PWDF_INTERRUPT_EXTENDED_POLICY PolicyAndGroup
Initial value:
{
DDI_ENTRY()

Definition at line 1166 of file fxinterruptapi.cpp.

◆ pParent

FxObject* pParent

Definition at line 236 of file fxinterruptapi.cpp.

Referenced by if().

◆ Priority

__in WDFINTERRUPT __in WDF_INTERRUPT_POLICY __in WDF_INTERRUPT_PRIORITY Priority

Definition at line 1098 of file fxinterruptapi.cpp.

◆ priority

priority = PolicyAndGroup->Priority

Definition at line 1196 of file fxinterruptapi.cpp.

Referenced by if().

◆ processorSet

PGROUP_AFFINITY processorSet = NULL

Definition at line 1126 of file fxinterruptapi.cpp.

◆ return

return

Definition at line 1041 of file fxinterruptapi.cpp.

◆ size

ULONG size = 0

Definition at line 1019 of file fxinterruptapi.cpp.

◆ Size

Info Size = size

Definition at line 1046 of file fxinterruptapi.cpp.

◆ status

status
Initial value:
= FxValidateObjectAttributes(
pFxDriverGlobals,
Attributes,
Configuration->AutomaticSerialization ?
FX_VALIDATE_OPTION_NONE_SPECIFIED :
FX_VALIDATE_OPTION_PARENT_NOT_ALLOWED)
FX_VALIDATE_OPTION_NONE_SPECIFIED
@ FX_VALIDATE_OPTION_NONE_SPECIFIED
Definition: fxvalidatefunctions.hpp:45
FX_VALIDATE_OPTION_PARENT_NOT_ALLOWED
@ FX_VALIDATE_OPTION_PARENT_NOT_ALLOWED
Definition: fxvalidatefunctions.hpp:46
FxValidateObjectAttributes
_Must_inspect_result_ NTSTATUS FxValidateObjectAttributes(__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in PWDF_OBJECT_ATTRIBUTES Attributes, __in ULONG Flags=FX_VALIDATE_OPTION_NONE_SPECIFIED)
Definition: fxvalidatefunctions.cpp:45

Definition at line 237 of file fxinterruptapi.cpp.

Referenced by __drv_maxIRQL(), _Requires_lock_held_(), _Requires_lock_not_held_(), and if().

◆ TargetProcessorSet

__in WDFINTERRUPT __in WDF_INTERRUPT_POLICY __in WDF_INTERRUPT_PRIORITY __in KAFFINITY TargetProcessorSet
Initial value:
{
DDI_ENTRY()

Definition at line 1100 of file fxinterruptapi.cpp.