ReactOS  0.4.15-dev-3217-gc6d1646
FxWakeInterruptMachine Class Reference

#include <fxwakeinterruptstatemachine.hpp>

Inheritance diagram for FxWakeInterruptMachine:
Collaboration diagram for FxWakeInterruptMachine:

Public Member Functions

 FxWakeInterruptMachine (__in FxInterrupt *Interrupt)
 
VOID ProcessEvent (__in FxWakeInterruptEvents Event)
 
- Public Member Functions inherited from FxThreadedEventQueue
 FxThreadedEventQueue (__in UCHAR QueueDepth)
 
 ~FxThreadedEventQueue (VOID)
 
_Must_inspect_result_ NTSTATUS Init (__inout FxPkgPnp *Pnp, __in PFN_PNP_EVENT_WORKER WorkerRoutine, __in PVOID WorkerContext=NULL)
 
VOID QueueToThread (VOID)
 
- Public Member Functions inherited from FxEventQueue
 FxEventQueue (__in UCHAR QueueDepth)
 
_Must_inspect_result_ NTSTATUS Initialize (__in PFX_DRIVER_GLOBALS DriverGlobals)
 
 _Acquires_lock_ (this->m_QueueLock) __drv_maxIRQL(DISPATCH_LEVEL) __drv_setsIRQL(DISPATCH_LEVEL) VOID Lock(__out __drv_deref(__drv_savesIRQL) PKIRQL Irql)
 
 _Releases_lock_ (this->m_QueueLock) __drv_requiresIRQL(DISPATCH_LEVEL) VOID Unlock(__in __drv_restoresIRQL KIRQL Irql)
 
BOOLEAN IsFull (VOID)
 
BOOLEAN IsEmpty (VOID)
 
VOID IncrementHead (VOID)
 
UCHAR GetHead (VOID)
 
UCHAR InsertAtHead (VOID)
 
UCHAR InsertAtTail (VOID)
 
UCHAR IncrementHistoryIndex (VOID)
 
BOOLEAN IsClosedLocked (VOID)
 
VOID GetFinishedState (__inout FxPostProcessInfo *Info)
 
BOOLEAN SetFinished (__in FxCREvent *Event)
 
VOID SetDelayedDeletion (VOID)
 
- Public Member Functions inherited from FxStump
PVOID operator new (__in size_t Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals)
 
PVOID operator new (__in size_t Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in POOL_TYPE PoolType)
 
VOID operator delete (__in PVOID pointer)
 
PVOID operator new[] (__in size_t Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals)
 
VOID operator delete[] (__in PVOID pointer)
 

Static Public Member Functions

static VOID _ProcessEventInner (__inout FxPkgPnp *PkgPnp, __inout FxPostProcessInfo *Info, __in PVOID WorkerContext)
 

Protected Attributes

FxInterruptm_Interrupt
 
BOOLEAN m_ActiveForWake
 
BOOLEAN m_Claimed
 
MxEvent m_IsrEvent
 
BYTE m_CurrentState
 
FxWakeInterruptEvents m_Queue [FxWakeInterruptEventQueueDepth]
 
FxWakeInterruptMachineStateHistory m_States
 
- Protected Attributes inherited from FxThreadedEventQueue
MxWorkItem m_WorkItem
 
WORK_QUEUE_ITEM m_EventWorkQueueItem
 
- Protected Attributes inherited from FxEventQueue
UCHAR m_QueueHead
 
UCHAR m_QueueTail
 
UCHAR m_QueueDepth
 
UCHAR m_HistoryIndex
 
FxPkgPnpm_PkgPnp
 
PVOID m_EventWorkerContext
 
MxLock m_QueueLock
 
PFN_PNP_EVENT_WORKER m_EventWorker
 
FxCREventm_WorkItemFinished
 
union {
   UCHAR   m_QueueFlags
 
   struct {
      UCHAR   WorkItemQueued: 1
 
      UCHAR   Closed: 1
 
      UCHAR   DelayDeletion: 1
 
   }   m_QueueFlagsByName
 
}; 
 
UCHAR m_WorkItemRunningCount
 

Static Protected Attributes

static const FxWakeInterruptStateTable m_StateTable []
 
static const FxWakeInterruptTargetState m_FailedStates []
 
static const FxWakeInterruptTargetState m_D0States []
 
static const FxWakeInterruptTargetState m_DxStates []
 
static const FxWakeInterruptTargetState m_DxNotArmedForWakeStates []
 
static const FxWakeInterruptTargetState m_WakingStates []
 
static const FxWakeInterruptTargetState m_InvokingEvtIsrPostWakeStates []
 
static const FxWakeInterruptTargetState m_CompletingD0States []
 
static const FxWakeInterruptTargetState m_InvokingIsrInD0 []
 
- Static Protected Attributes inherited from FxThreadedEventQueue
static WORKER_THREAD_ROUTINE _WorkerThreadRoutine
 
static MX_WORKITEM_ROUTINE _WorkItemCallback
 

Private Member Functions

VOID ProcessEventInner (__inout FxPostProcessInfo *Info)
 

Static Private Member Functions

static FxWakeInterruptStates Waking (__in FxWakeInterruptMachine *This)
 
static FxWakeInterruptStates Dx (__in FxWakeInterruptMachine *This)
 
static FxWakeInterruptStates DxNotArmedForWake (__in FxWakeInterruptMachine *This)
 
static FxWakeInterruptStates Failed (__in FxWakeInterruptMachine *This)
 
static FxWakeInterruptStates InvokingEvtIsrPostWake (__in FxWakeInterruptMachine *This)
 
static FxWakeInterruptStates InvokingEvtIsrInDxNotArmedForWake (__in FxWakeInterruptMachine *This)
 
static FxWakeInterruptStates InvokingEvtIsrInD0 (__in FxWakeInterruptMachine *This)
 
static FxWakeInterruptStates CompletingD0 (__in FxWakeInterruptMachine *This)
 

Private Attributes

friend FxInterrupt
 

Additional Inherited Members

- Public Attributes inherited from FxEventQueue
FxWaitLockInternal m_StateMachineLock
 
- Protected Member Functions inherited from FxThreadedEventQueue
VOID QueueWorkItem (VOID)
 
- Protected Member Functions inherited from FxEventQueue
VOID Configure (__in FxPkgPnp *Pnp, __in PFN_PNP_EVENT_WORKER WorkerRoutine, __in PVOID Context)
 
BOOLEAN QueueToThreadWorker (VOID)
 
VOID EventQueueWorker (VOID)
 
BOOLEAN IsIdleLocked (VOID)
 
- Protected Member Functions inherited from FxStump
 FxStump (VOID)
 

Detailed Description

Definition at line 89 of file fxwakeinterruptstatemachine.hpp.

Constructor & Destructor Documentation

◆ FxWakeInterruptMachine()

FxWakeInterruptMachine::FxWakeInterruptMachine ( __in FxInterrupt Interrupt)

Definition at line 118 of file wakeinterruptstatemachine.cpp.

121 {
122  //
123  // Make sure we can fit the state into a byte
124  //
125  C_ASSERT(WakeInterruptMax <= 0xFF);
126 
128 
129  RtlZeroMemory(&m_Queue, sizeof(m_Queue));
130  RtlZeroMemory(&m_States, sizeof(m_States));
131 
132  //
133  // Store the initial state in the state history array
134  //
137 }
const UCHAR FxWakeInterruptEventQueueDepth
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_INTERRUPT_CONFIG _In_opt_ PWDF_OBJECT_ATTRIBUTES _Out_ WDFINTERRUPT * Interrupt
Definition: wdfinterrupt.h:372
FxWakeInterruptEvents m_Queue[FxWakeInterruptEventQueueDepth]
UCHAR IncrementHistoryIndex(VOID)
FxThreadedEventQueue(__in UCHAR QueueDepth)
Definition: eventqueue.cpp:352
#define C_ASSERT(e)
Definition: intsafe.h:73
UCHAR History[FxWakeInterruptEventQueueDepth]
FxWakeInterruptMachineStateHistory m_States
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262

Member Function Documentation

◆ _ProcessEventInner()

VOID FxWakeInterruptMachine::_ProcessEventInner ( __inout FxPkgPnp PkgPnp,
__inout FxPostProcessInfo Info,
__in PVOID  WorkerContext 
)
static

Definition at line 245 of file wakeinterruptstatemachine.cpp.

250 {
251 
252  UNREFERENCED_PARAMETER(PkgPnp);
253 
254  FxWakeInterruptMachine * pThis = (FxWakeInterruptMachine *) WorkerContext;
255 
256  //
257  // Take the state machine lock.
258  //
259  pThis->m_StateMachineLock.AcquireLock(
260  pThis->m_PkgPnp->GetDriverGlobals()
261  );
262 
263  //
264  // Call the function that will actually run the state machine.
265  //
266  pThis->ProcessEventInner(Info);
267 
268  //
269  // We are being called from the work item and m_WorkItemRunning is > 0, so
270  // we cannot be deleted yet.
271  //
272  ASSERT(Info->SomethingToDo() == FALSE);
273 
274  //
275  // Now release the state machine lock
276  //
277  pThis->m_StateMachineLock.ReleaseLock(
278  pThis->m_PkgPnp->GetDriverGlobals()
279  );
280 
281  return;
282 }
#define UNREFERENCED_PARAMETER(P)
Definition: ntbasedef.h:317
_Must_inspect_result_ _In_ WDFCHILDLIST _In_ PWDF_CHILD_LIST_ITERATOR _Out_ WDFDEVICE _Inout_opt_ PWDF_CHILD_RETRIEVE_INFO Info
Definition: wdfchildlist.h:683
#define FALSE
Definition: types.h:117
FxPkgPnp * m_PkgPnp
#define ASSERT(a)
Definition: mode.c:44
__inline PFX_DRIVER_GLOBALS GetDriverGlobals(VOID)
Definition: fxobject.hpp:734
VOID ProcessEventInner(__inout FxPostProcessInfo *Info)
FxWaitLockInternal m_StateMachineLock

Referenced by FxInterrupt::CreateWakeInterruptMachine().

◆ CompletingD0()

FxWakeInterruptStates FxWakeInterruptMachine::CompletingD0 ( __in FxWakeInterruptMachine This)
staticprivate

Definition at line 486 of file wakeinterruptstatemachine.cpp.

489 {
490  This->m_PkgPnp->AckPendingWakeInterruptOperation(FALSE);
491 
492  return WakeInterruptD0;
493 }
#define FALSE
Definition: types.h:117

◆ Dx()

FxWakeInterruptStates FxWakeInterruptMachine::Dx ( __in FxWakeInterruptMachine This)
staticprivate

Definition at line 418 of file wakeinterruptstatemachine.cpp.

421 {
422  //
423  // Flush queued callbacks so that we know that nobody is still trying to
424  // synchronize against this interrupt. For KMDF this will flush DPCs and
425  // for UMDF this will send a message to reflector to flush queued DPCs.
426  //
427  This->m_Interrupt->FlushQueuedDpcs();
428 
429 #if FX_IS_KERNEL_MODE
430  //
431  // Rundown the workitem if present (passive-level interrupt support or KMDF).
432  // Not needed for UMDF since reflector doesn't use workitem for isr.
433  //
434  This->m_Interrupt->FlushQueuedWorkitem();
435 
436 #endif
437 
438  This->m_PkgPnp->AckPendingWakeInterruptOperation(FALSE);
439 
440  return WakeInterruptMax;
441 }
#define FALSE
Definition: types.h:117

◆ DxNotArmedForWake()

FxWakeInterruptStates FxWakeInterruptMachine::DxNotArmedForWake ( __in FxWakeInterruptMachine This)
staticprivate

Definition at line 444 of file wakeinterruptstatemachine.cpp.

447 {
448  //
449  // Ask power state machine to process the acknowledgement event
450  // on a different thread as we could be running the state machine's
451  // engine in the context of a wake ISR, and the power
452  // state machine will attempt to disconnect this interrupt when
453  // it processes the acknowledgement event.
454  //
455  This->m_PkgPnp->AckPendingWakeInterruptOperation(TRUE);
456 
457  return WakeInterruptMax;
458 }
#define TRUE
Definition: types.h:120

◆ Failed()

FxWakeInterruptStates FxWakeInterruptMachine::Failed ( __in FxWakeInterruptMachine This)
staticprivate

Definition at line 508 of file wakeinterruptstatemachine.cpp.

511 {
512  //
513  // Device failed to power up and we are not invoking the
514  // client driver's callback. So we cannot claim the
515  // interrupt
516  //
517  This->m_Claimed = FALSE;
518 
519  This->m_IsrEvent.Set();
520 
521  return WakeInterruptMax;
522 }
#define FALSE
Definition: types.h:117

◆ InvokingEvtIsrInD0()

FxWakeInterruptStates FxWakeInterruptMachine::InvokingEvtIsrInD0 ( __in FxWakeInterruptMachine This)
staticprivate

Definition at line 496 of file wakeinterruptstatemachine.cpp.

499 {
500  This->m_Interrupt->InvokeWakeInterruptEvtIsr();
501 
502  This->m_IsrEvent.Set();
503 
504  return WakeInterruptD0;
505 }

◆ InvokingEvtIsrInDxNotArmedForWake()

FxWakeInterruptStates FxWakeInterruptMachine::InvokingEvtIsrInDxNotArmedForWake ( __in FxWakeInterruptMachine This)
staticprivate

Definition at line 462 of file wakeinterruptstatemachine.cpp.

465 {
466  This->m_Interrupt->InvokeWakeInterruptEvtIsr();
467 
468  This->m_IsrEvent.Set();
469 
471 }

◆ InvokingEvtIsrPostWake()

FxWakeInterruptStates FxWakeInterruptMachine::InvokingEvtIsrPostWake ( __in FxWakeInterruptMachine This)
staticprivate

Definition at line 474 of file wakeinterruptstatemachine.cpp.

477 {
478  This->m_Interrupt->InvokeWakeInterruptEvtIsr();
479 
480  This->m_IsrEvent.Set();
481 
483 }

◆ ProcessEvent()

VOID FxWakeInterruptMachine::ProcessEvent ( __in FxWakeInterruptEvents  Event)

Definition at line 140 of file wakeinterruptstatemachine.cpp.

143 {
145  KIRQL irql;
146  LONGLONG timeout = 0;
147 
148  //
149  // Acquire state machine *queue* lock, raising to DISPATCH_LEVEL
150  //
151  Lock(&irql);
152 
153  if (IsFull()) {
154  //
155  // The queue is full. This should never happen.
156  //
157  Unlock(irql);
158 
159  ASSERTMSG("The wake interrupt state machine queue is full\n",
160  FALSE);
161  return;
162  }
163 
164  if (IsClosedLocked()) {
165  //
166  // The queue is closed. This should never happen.
167  //
170  "WDFDEVICE 0x%p !devobj 0x%p current wake interrupt state"
171  " %!FxWakeInterruptStates! dropping event "
172  "%!FxWakeInterruptEvents! because of a closed queue",
176  Event);
177 
178  Unlock(irql);
179 
180  ASSERTMSG(
181  "The wake interrupt state machine queue is closed\n",
182  FALSE
183  );
184  return;
185  }
186 
187  //
188  // Enqueue the event
189  //
191 
192  //
193  // Drop the state machine *queue* lock
194  //
195  Unlock(irql);
196 
197  //
198  // Now, if we are running at PASSIVE_LEVEL, attempt to run the state machine
199  // on this thread. If we can't do that, then queue a work item.
200  //
201  if (irql == PASSIVE_LEVEL) {
202  //
203  // Try to acquire the state machine lock
204  //
205  status = m_StateMachineLock.AcquireLock(
207  &timeout
208  );
209  if (FxWaitLockInternal::IsLockAcquired(status)) {
211 
212  //
213  // We now hold the state machine lock. So call the function that
214  // dispatches the next state.
215  //
217 
218  //
219  // The pnp state machine should be the only one deleting the object
220  //
221  ASSERT(info.m_DeleteObject == FALSE);
222 
223  //
224  // Release the state machine lock
225  //
226  m_StateMachineLock.ReleaseLock(
228  );
229 
230  info.Evaluate(m_PkgPnp);
231 
232  return;
233  }
234  }
235 
236  //
237  // For one reason or another, we couldn't run the state machine on this
238  // thread. So queue a work item to do it.
239  //
240  QueueToThread();
241  return;
242 }
__inline CfxDevice * GetDevice(VOID)
Definition: fxpackage.hpp:46
MdDeviceObject __inline GetDeviceObject(VOID)
Definition: fxdevice.hpp:174
WDFDEVICE __inline GetHandle(VOID)
Definition: fxdevice.hpp:237
LONG NTSTATUS
Definition: precomp.h:26
FxWakeInterruptEvents m_Queue[FxWakeInterruptEventQueueDepth]
KIRQL irql
Definition: wave.h:1
Definition: dhcpd.h:245
#define TRACE_LEVEL_INFORMATION
Definition: storswtr.h:29
GLbitfield GLuint64 timeout
Definition: glext.h:7164
UCHAR KIRQL
Definition: env_spec_w32.h:591
BOOLEAN IsFull(VOID)
#define FALSE
Definition: types.h:117
#define ASSERTMSG(msg, exp)
Definition: nt_native.h:431
_In_ PVOID _In_ ULONG Event
Definition: iotypes.h:467
FxPkgPnp * m_PkgPnp
int64_t LONGLONG
Definition: typedefs.h:68
UCHAR InsertAtTail(VOID)
#define ASSERT(a)
Definition: mode.c:44
struct _test_info info[]
Definition: SetCursorPos.c:19
#define PASSIVE_LEVEL
Definition: env_spec_w32.h:693
BOOLEAN IsClosedLocked(VOID)
#define TRACINGPNP
Definition: dbgtrace.h:67
__inline PFX_DRIVER_GLOBALS GetDriverGlobals(VOID)
Definition: fxobject.hpp:734
DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGPNP, "Enter, WDFDEVICE %p", Device)
_Must_inspect_result_ _In_opt_ PWDF_OBJECT_ATTRIBUTES _Out_ WDFWAITLOCK * Lock
Definition: wdfsync.h:124
VOID ProcessEventInner(__inout FxPostProcessInfo *Info)
static SERVICE_STATUS status
Definition: service.c:31
FxWaitLockInternal m_StateMachineLock
Definition: ps.c:97

Referenced by FxInterrupt::ProcessWakeInterruptEvent(), and FxInterrupt::WakeInterruptIsr().

◆ ProcessEventInner()

VOID FxWakeInterruptMachine::ProcessEventInner ( __inout FxPostProcessInfo Info)
private

Definition at line 285 of file wakeinterruptstatemachine.cpp.

288 {
289  KIRQL irql;
292  FxWakeInterruptStates newState;
293 
294  //
295  // Process as many events as we can
296  //
297  for ( ; ; ) {
298  //
299  // Acquire state machine *queue* lock
300  //
301  Lock(&irql);
302 
303  if (IsEmpty()) {
304  //
305  // The queue is empty.
306  //
308  Unlock(irql);
309  return;
310  }
311 
312  //
313  // Get the event from the queue
314  //
315  event = m_Queue[GetHead()];
316  IncrementHead();
317 
318  //
319  // Drop the state machine *queue* lock
320  //
321  Unlock(irql);
322 
323  //
324  // Get the state table entry for the current state
325  //
326  // NOTE: Prefast complains about buffer overflow if (m_CurrentState ==
327  // WakeInterruptMax), but that should never happen because WakeInterruptMax is not a real
328  // state. We just use it to represent the maximum value in the enum that
329  // defines the states.
330  //
333 
334  //
335  // Based on the event received, figure out the next state
336  //
337  newState = WakeInterruptMax;
338  for (ULONG i = 0; i < entry->TargetStatesCount; i++) {
339  if (entry->TargetStates[i].WakeInterruptEvent == event) {
340  DO_EVENT_TRAP(&entry->TargetStates[i]);
341  newState = entry->TargetStates[i].WakeInterruptState;
342  break;
343  }
344  }
345 
346  if (newState == WakeInterruptMax) {
347  //
348  // Unexpected event for this state
349  //
353  TRACINGPNP,
354  "WDFDEVICE 0x%p !devobj 0x%p wake interrupt state "
355  "%!FxWakeInterruptStates! dropping event "
356  "%!FxWakeInterruptEvents!",
360  event
361  );
362 
363  COVERAGE_TRAP();
364  }
365 
366  while (newState != WakeInterruptMax) {
371  "WDFDEVICE 0x%p !devobj 0x%p entering wake interrupt "
372  "state %!FxWakeInterruptStates! from "
373  "%!FxWakeInterruptStates!",
376  newState,
378  );
379 
380  //
381  // Update the state history array
382  //
384 
385  //
386  // Move to the new state
387  //
388  m_CurrentState = (BYTE) newState;
390 
391  //
392  // Invoke the state entry function (if present) for the new state
393  //
394  if (entry->StateFunc != NULL) {
395  newState = entry->StateFunc(this);
396  }
397  else {
398  newState = WakeInterruptMax;
399  }
400  }
401  }
402 
403  return;
404 }
UCHAR GetHead(VOID)
__inline CfxDevice * GetDevice(VOID)
Definition: fxpackage.hpp:46
MdDeviceObject __inline GetDeviceObject(VOID)
Definition: fxdevice.hpp:174
WDFDEVICE __inline GetHandle(VOID)
Definition: fxdevice.hpp:237
#define __analysis_assume(expr)
Definition: ms_sal.h:2893
FxWakeInterruptEvents m_Queue[FxWakeInterruptEventQueueDepth]
KIRQL irql
Definition: wave.h:1
UCHAR IncrementHistoryIndex(VOID)
#define TRACE_LEVEL_INFORMATION
Definition: storswtr.h:29
#define TRACINGPNPPOWERSTATES
Definition: dbgtrace.h:69
_Must_inspect_result_ _In_ WDFCHILDLIST _In_ PWDF_CHILD_LIST_ITERATOR _Out_ WDFDEVICE _Inout_opt_ PWDF_CHILD_RETRIEVE_INFO Info
Definition: wdfchildlist.h:683
UCHAR KIRQL
Definition: env_spec_w32.h:591
VOID IncrementHead(VOID)
#define DO_EVENT_TRAP(x)
Definition: fxpkgpnp.hpp:61
#define COVERAGE_TRAP()
Definition: fxmacros.hpp:246
FxPkgPnp * m_PkgPnp
UCHAR History[FxWakeInterruptEventQueueDepth]
unsigned char UCHAR
Definition: xmlstorage.h:181
uint32_t entry
Definition: isohybrid.c:63
struct _cl_event * event
Definition: glext.h:7739
unsigned char BYTE
Definition: xxhash.c:193
VOID GetFinishedState(__inout FxPostProcessInfo *Info)
#define TRACINGPNP
Definition: dbgtrace.h:67
__inline PFX_DRIVER_GLOBALS GetDriverGlobals(VOID)
Definition: fxobject.hpp:734
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
BOOLEAN IsEmpty(VOID)
DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGPNP, "Enter, WDFDEVICE %p", Device)
#define NULL
Definition: types.h:112
static const FxWakeInterruptStateTable m_StateTable[]
FxWakeInterruptMachineStateHistory m_States
_Must_inspect_result_ _In_opt_ PWDF_OBJECT_ATTRIBUTES _Out_ WDFWAITLOCK * Lock
Definition: wdfsync.h:124
unsigned int ULONG
Definition: retypes.h:1

Referenced by _ProcessEventInner(), and ProcessEvent().

◆ Waking()

FxWakeInterruptStates FxWakeInterruptMachine::Waking ( __in FxWakeInterruptMachine This)
staticprivate

Definition at line 408 of file wakeinterruptstatemachine.cpp.

411 {
412  This->m_PkgPnp->PowerPolicyProcessEvent(PwrPolWakeInterruptFired);
413 
414  return WakeInterruptMax;
415 }

Member Data Documentation

◆ FxInterrupt

friend FxWakeInterruptMachine::FxInterrupt
private

Definition at line 91 of file fxwakeinterruptstatemachine.hpp.

◆ m_ActiveForWake

BOOLEAN FxWakeInterruptMachine::m_ActiveForWake
protected

◆ m_Claimed

BOOLEAN FxWakeInterruptMachine::m_Claimed
protected

◆ m_CompletingD0States

const FxWakeInterruptTargetState FxWakeInterruptMachine::m_CompletingD0States[]
staticprotected

Definition at line 192 of file fxwakeinterruptstatemachine.hpp.

◆ m_CurrentState

BYTE FxWakeInterruptMachine::m_CurrentState
protected

◆ m_D0States

◆ m_DxNotArmedForWakeStates

◆ m_DxStates

◆ m_FailedStates

const FxWakeInterruptTargetState FxWakeInterruptMachine::m_FailedStates
staticprotected

◆ m_Interrupt

FxInterrupt* FxWakeInterruptMachine::m_Interrupt
protected

Definition at line 167 of file fxwakeinterruptstatemachine.hpp.

Referenced by FxWakeInterruptMachine().

◆ m_InvokingEvtIsrPostWakeStates

const FxWakeInterruptTargetState FxWakeInterruptMachine::m_InvokingEvtIsrPostWakeStates[]
staticprotected

Definition at line 191 of file fxwakeinterruptstatemachine.hpp.

◆ m_InvokingIsrInD0

const FxWakeInterruptTargetState FxWakeInterruptMachine::m_InvokingIsrInD0[]
staticprotected

Definition at line 193 of file fxwakeinterruptstatemachine.hpp.

◆ m_IsrEvent

MxEvent FxWakeInterruptMachine::m_IsrEvent
protected

◆ m_Queue

FxWakeInterruptEvents FxWakeInterruptMachine::m_Queue[FxWakeInterruptEventQueueDepth]
protected

◆ m_States

FxWakeInterruptMachineStateHistory FxWakeInterruptMachine::m_States
protected

Definition at line 182 of file fxwakeinterruptstatemachine.hpp.

Referenced by FxWakeInterruptMachine(), and ProcessEventInner().

◆ m_StateTable

const FxWakeInterruptStateTable FxWakeInterruptMachine::m_StateTable
staticprotected

Definition at line 184 of file fxwakeinterruptstatemachine.hpp.

Referenced by ProcessEventInner().

◆ m_WakingStates


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