FxPkgPnp Class Reference

#include <fxpkgpnp.hpp>

Inheritance diagram for FxPkgPnp:

Collaboration diagram for FxPkgPnp:

Public Member Functions
VOID	PnpProcessEvent (__in FxPnpEvent Event, __in BOOLEAN ProcessEventOnDifferentThread=FALSE)
VOID	PowerProcessEvent (__in FxPowerEvent Event, __in BOOLEAN ProcessEventOnDifferentThread=FALSE)
VOID	PowerPolicyProcessEvent (__in FxPowerPolicyEvent Event, __in BOOLEAN ProcessEventOnDifferentThread=FALSE)
BOOLEAN	ShouldProcessPnpEventOnDifferentThread (__in KIRQL CurrentIrql, __in BOOLEAN CallerSpecifiedProcessingOnDifferentThread)
BOOLEAN	ShouldProcessPowerPolicyEventOnDifferentThread (__in KIRQL CurrentIrql, __in BOOLEAN CallerSpecifiedProcessingOnDifferentThread)
VOID	CleanupStateMachines (__in BOOLEAN ClenaupPnp)
VOID	CleanupDeviceFromFailedCreate (__in MxEvent *WaitEvent)
virtual _Must_inspect_result_ NTSTATUS	Initialize (__in PWDFDEVICE_INIT DeviceInit)
_Must_inspect_result_ NTSTATUS	PostCreateDeviceInitialize (VOID)
virtual VOID	FinishInitialize (__inout PWDFDEVICE_INIT DeviceInit)
VOID	SetSpecialFileSupport (__in WDF_SPECIAL_FILE_TYPE FileType, __in BOOLEAN Supported)
_Must_inspect_result_ NTSTATUS	RegisterCallbacks (__in PWDF_PNPPOWER_EVENT_CALLBACKS DispatchTable)
VOID	RegisterPowerPolicyCallbacks (__in PWDF_POWER_POLICY_EVENT_CALLBACKS Callbacks)
NTSTATUS	RegisterPowerPolicyWmiInstance (__in const GUID *Guid, __in FxWmiInstanceInternalCallbacks *Callbacks, __out FxWmiInstanceInternal **Instance)
NTSTATUS	PowerPolicySetS0IdleSettings (__in PWDF_DEVICE_POWER_POLICY_IDLE_SETTINGS Settings)
NTSTATUS	AssignPowerFrameworkSettings (__in PWDF_POWER_FRAMEWORK_SETTINGS PowerFrameworkSettings)
NTSTATUS	PowerPolicySetSxWakeSettings (__in PWDF_DEVICE_POWER_POLICY_WAKE_SETTINGS Settings, __in BOOLEAN ArmForWakeIfChildrenAreArmedForWake, __in BOOLEAN IndicateChildWakeOnParentWake)
BOOLEAN	PowerIndicateWaitWakeStatus (__in NTSTATUS WaitWakeStatus)
BOOLEAN	PowerPolicyIsWakeEnabled (VOID)
ULONG	PowerPolicyGetCurrentWakeReason (VOID)
BOOLEAN __inline	PowerPolicyShouldPropagateWakeStatusToChildren (VOID)
VOID	ChildRemoved (VOID)
VOID	PowerPolicySetS0IdleState (__in BOOLEAN State)
VOID	PowerPolicySetSxWakeState (__in BOOLEAN State)
VOID	SetPowerCaps (__in PWDF_DEVICE_POWER_CAPABILITIES PowerCapabilities)
VOID	SetPnpCaps (__in PWDF_DEVICE_PNP_CAPABILITIES PnpCapabilities)
VOID	GetPnpState (__out PWDF_DEVICE_STATE State)
VOID	SetPnpState (__in PWDF_DEVICE_STATE State)
VOID	SetDeviceFailed (__in WDF_DEVICE_FAILED_ACTION FailedAction)
VOID	SetChildBusInformation (__in PPNP_BUS_INFORMATION BusInformation)
_Must_inspect_result_ NTSTATUS	HandleQueryBusInformation (__inout FxIrp *Irp)
_Must_inspect_result_ NTSTATUS __inline	PowerReference (__in BOOLEAN WaitForD0, __in_opt PVOID Tag=NULL, __in_opt LONG Line=0, __in_opt PSTR File=NULL)
VOID __inline	PowerDereference (__in_opt PVOID Tag=NULL, __in_opt LONG Line=0, __in_opt PSTR File=NULL)
BOOLEAN	HasPowerThread (VOID)
VOID	QueueToPowerThread (__in PWORK_QUEUE_ITEM WorkItem)
_Must_inspect_result_ NTSTATUS	AddUsageDevice (__in MdDeviceObject DependentDevice)
VOID	RemoveUsageDevice (__in MdDeviceObject DependentDevice)
_Must_inspect_result_ NTSTATUS	AddRemovalDevice (__in MdDeviceObject DependentDevice)
VOID	RemoveRemovalDevice (__in MdDeviceObject DependentDevice)
VOID	ClearRemovalDevicesList (VOID)
_Must_inspect_result_ NTSTATUS	AllocateEnumInfo (VOID)
VOID	AddChildList (__in FxChildList *List)
VOID	RemoveChildList (__in FxChildList *List)
VOID	ChildListNotifyRemove (__inout PLONG PendingCount)
_Must_inspect_result_ NTSTATUS	AllocateDmaEnablerList (VOID)
VOID	AddDmaEnabler (__in FxDmaEnabler *Enabler)
VOID	RemoveDmaEnabler (__in FxDmaEnabler *Enabler)
VOID	RevokeDmaEnablerResources (__in FxDmaEnabler *Enabler)
VOID	AddQueryInterface (__in FxQueryInterface *QI, __in BOOLEAN Lock)
VOID	QueryForD3ColdInterface (VOID)
VOID	DropD3ColdInterface (VOID)
BOOLEAN	IsPowerPolicyOwner (VOID)
BOOLEAN	SupportsWakeInterrupt (VOID)
BOOLEAN	IsS0IdleWakeFromS0Enabled (VOID)
BOOLEAN	IsS0IdleSystemManaged (VOID)
BOOLEAN	IsS0IdleUsbSSEnabled (VOID)
BOOLEAN	IsSxWakeEnabled (VOID)
_Must_inspect_result_ NTSTATUS	PowerPolicyCanChildPowerUp (__out PBOOLEAN PowerUp)
VOID	PowerPolicyChildPoweredDown (VOID)
POWER_ACTION	GetSystemPowerAction (VOID)
VOID	ProcessDelayedDeletion (VOID)
VOID	SignalDeviceRemovedEvent (VOID)
virtual NTSTATUS	FireAndForgetIrp (FxIrp *Irp)=0
FxCmResList *	GetTranslatedResourceList (VOID)
FxCmResList *	GetRawResourceList (VOID)
ULONG	GetInterruptObjectCount (VOID)
VOID	AckPendingWakeInterruptOperation (__in BOOLEAN ProcessPowerEventOnDifferentThread)
VOID	SendEventToAllWakeInterrupts (__in enum FxWakeInterruptEvents WakeInterruptEvent)
_Must_inspect_result_ NTSTATUS	ValidateCmResource (__inout PCM_PARTIAL_RESOURCE_DESCRIPTOR *CmResourceRaw, __inout PCM_PARTIAL_RESOURCE_DESCRIPTOR *CmResource)
_Must_inspect_result_ NTSTATUS	ValidateInterruptResourceCm (__in PCM_PARTIAL_RESOURCE_DESCRIPTOR CmIntResourceRaw, __in PCM_PARTIAL_RESOURCE_DESCRIPTOR CmIntResource, __in PWDF_INTERRUPT_CONFIG Configuration)
BOOLEAN	IsDefaultReleaseHardwareOrder (VOID)
BOOLEAN	HasMultipleInterrupts (VOID)
VOID	WakeInterruptCreated (VOID)
Public Member Functions inherited from FxPackage
	FxPackage (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in CfxDevice *Device, __in WDFTYPE Type)
virtual NTSTATUS	Dispatch (__in MdIrp Irp)=0
__inline CfxDevice *	GetDevice (VOID)
	DECLARE_INTERNAL_NEW_OPERATOR ()
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)

Public Attributes
FxPnpStateAndCaps	m_PnpStateAndCaps
ULONG	m_PnpCapsAddress
ULONG	m_PnpCapsUINumber
FxPowerCaps	m_PowerCaps
BOOLEAN	m_Failed
BYTE	m_SystemPowerState
BYTE	m_DevicePowerState
BYTE	m_DevicePowerStateOld
FxRelatedDeviceList *	m_UsageDependentDeviceList
FxRelatedDeviceList *	m_RemovalDeviceList
FxWaitLockInternal	m_QueryInterfaceLock
SINGLE_LIST_ENTRY	m_QueryInterfaceHead
FxWaitLockInternal	m_DeviceInterfaceLock
SINGLE_LIST_ENTRY	m_DeviceInterfaceHead
BOOLEAN	m_DeviceInterfacesCanBeEnabled
BOOLEAN	m_SpecialSupport [WdfSpecialFileMax-1]
LONG	m_SpecialFileCount [WdfSpecialFileMax-1]
ULONG	m_DeviceStopCount
FxPnpMachine	m_PnpMachine
FxPowerMachine	m_PowerMachine
FxPowerPolicyMachine	m_PowerPolicyMachine
FxSelfManagedIoMachine *	m_SelfManagedIoMachine
SharedPowerData	m_SharedPower
D3COLD_SUPPORT_INTERFACE	m_D3ColdInterface
FxPnpDeviceUsageNotification	m_DeviceUsageNotification
FxPnpDeviceUsageNotificationEx	m_DeviceUsageNotificationEx
FxPnpDeviceRelationsQuery	m_DeviceRelationsQuery
FxPnpDeviceD0Entry	m_DeviceD0Entry
FxPnpDeviceD0EntryPostInterruptsEnabled	m_DeviceD0EntryPostInterruptsEnabled
FxPnpDeviceD0ExitPreInterruptsDisabled	m_DeviceD0ExitPreInterruptsDisabled
FxPnpDeviceD0Exit	m_DeviceD0Exit
FxPnpDevicePrepareHardware	m_DevicePrepareHardware
FxPnpDeviceReleaseHardware	m_DeviceReleaseHardware
FxPnpDeviceQueryStop	m_DeviceQueryStop
FxPnpDeviceQueryRemove	m_DeviceQueryRemove
FxPnpDeviceSurpriseRemoval	m_DeviceSurpriseRemoval

Protected Member Functions
	FxPkgPnp (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in CfxDevice *Device, __in WDFTYPE Type)
	~FxPkgPnp ()
virtual BOOLEAN	Dispose (VOID)
virtual _Must_inspect_result_ NTSTATUS	Dispatch (__in MdIrp Irp)
virtual const PFN_PNP_POWER_CALLBACK *	GetDispatchPnp (VOID)=0
virtual const PFN_PNP_POWER_CALLBACK *	GetDispatchPower (VOID)=0
VOID	DeleteDevice (VOID)
VOID	SetInternalFailure (VOID)
NTSTATUS	CompletePowerRequest (__inout FxIrp *Irp, __in NTSTATUS Status)
NTSTATUS	CompletePnpRequest (__inout FxIrp *Irp, __in NTSTATUS Status)
PNP_DEVICE_STATE	HandleQueryPnpDeviceState (__in PNP_DEVICE_STATE PnpDeviceState)
_Must_inspect_result_ NTSTATUS	HandleQueryBusRelations (__inout FxIrp *Irp)
_Must_inspect_result_ NTSTATUS	HandleQueryDeviceRelations (__inout FxIrp *Irp, __inout FxRelatedDeviceList *List)
_Must_inspect_result_ NTSTATUS	HandleQueryInterface (__inout FxIrp *Irp, __out PBOOLEAN CompleteRequest)
_Must_inspect_result_ NTSTATUS	QueryForCapabilities (VOID)
VOID	PnpAssignInterruptsSyncIrql (VOID)
_Must_inspect_result_ NTSTATUS	PnpMatchResources (VOID)
	__drv_when (!NT_SUCCESS(return), __drv_arg(ResourcesMatched, _Must_inspect_result_)) NTSTATUS PnpPrepareHardware(__out PBOOLEAN ResourcesMatched)
_Must_inspect_result_ NTSTATUS	PnpPrepareHardwareInternal (VOID)
_Must_inspect_result_ NTSTATUS	PnpReleaseHardware (VOID)
_Must_inspect_result_ NTSTATUS	PnpEnableInterfacesAndRegisterWmi (VOID)
_Must_inspect_result_ NTSTATUS	PnpSurpriseRemoval (__inout FxIrp *Irp)
NTSTATUS	FilterResourceRequirements (__in IO_RESOURCE_REQUIREMENTS_LIST **IoList)
virtual VOID	PowerReleasePendingDeviceIrp (BOOLEAN IrpMustBePresent=TRUE)=0
VOID	AddInterruptObject (__in FxInterrupt *Interrupt)
VOID	RemoveInterruptObject (__in FxInterrupt *Interrupt)
VOID	PnpProcessEventInner (__inout FxPostProcessInfo *Info)
VOID	PowerProcessEventInner (__inout FxPostProcessInfo *Info)
VOID	PowerPolicyProcessEventInner (__inout FxPostProcessInfo *Info)
VOID	PnpEnterNewState (__in WDF_DEVICE_PNP_STATE State)
VOID	PowerEnterNewState (__in WDF_DEVICE_POWER_STATE State)
VOID	PowerPolicyEnterNewState (__in WDF_DEVICE_POWER_POLICY_STATE State)
VOID	NotPowerPolicyOwnerEnterNewState (__in WDF_DEVICE_POWER_POLICY_STATE NewState)
_Must_inspect_result_ NTSTATUS	DispatchWaitWake (__inout FxIrp *Irp)
VOID	SaveState (__in BOOLEAN UseCanSaveState)
_Must_inspect_result_ NTSTATUS	PnpDeviceUsageNotification (__inout FxIrp *Irp)
LONG	GetPnpStateInternal (VOID)
LONG	GetPnpCapsInternal (VOID)
virtual BOOLEAN	PnpSendStartDeviceDownTheStackOverload (VOID)=0
virtual WDF_DEVICE_PNP_STATE	PnpEventCheckForDevicePresenceOverload (VOID)=0
virtual WDF_DEVICE_PNP_STATE	PnpEventEjectHardwareOverload (VOID)=0
virtual WDF_DEVICE_PNP_STATE	PnpGetPostRemoveState (VOID)=0
virtual WDF_DEVICE_PNP_STATE	PnpEventPdoRemovedOverload (VOID)=0
virtual WDF_DEVICE_PNP_STATE	PnpEventFdoRemovedOverload (VOID)=0
virtual VOID	PnpEventSurpriseRemovePendingOverload (VOID)
VOID	PnpEventRemovedCommonCode (VOID)
VOID	PnpPowerPolicyStart (VOID)
VOID	PnpPowerPolicyStop (VOID)
VOID	PnpPowerPolicySurpriseRemove (VOID)
VOID	PnpPowerPolicyRemove (VOID)
VOID	PnpFinishProcessingIrp (__in BOOLEAN IrpMustBePresent=TRUE)
VOID	PnpDisableInterfaces (VOID)
virtual NTSTATUS	SendIrpSynchronously (FxIrp *Irp)=0
virtual WDF_DEVICE_POWER_STATE	PowerCheckDeviceTypeOverload (VOID)=0
virtual WDF_DEVICE_POWER_STATE	PowerCheckDeviceTypeNPOverload (VOID)=0
virtual NTSTATUS	PowerCheckParentOverload (BOOLEAN *ParentOn)=0
virtual NTSTATUS	PowerEnableWakeAtBusOverload (VOID)
virtual VOID	PowerDisableWakeAtBusOverload (VOID)
virtual VOID	PowerParentPowerDereference (VOID)=0
VOID	PowerGotoDx (VOID)
BOOLEAN	PowerGotoDxIoStopped (VOID)
BOOLEAN	PowerGotoDxIoStoppedNP (VOID)
BOOLEAN	PowerDmaEnableAndScan (__in BOOLEAN ImplicitPowerUp)
VOID	PowerCompletePendedWakeIrp (VOID)
VOID	PowerCompleteWakeRequestFromWithinMachine (__in NTSTATUS Status)
BOOLEAN	PowerMakeWakeRequestNonCancelable (__in NTSTATUS Status)
BOOLEAN	PowerIsWakeRequestPresent (VOID)
VOID	PowerSendIdlePowerEvent (__in FxPowerIdleEvents Event)
VOID	PowerSendPowerDownEvents (__in FxPowerDownType Type)
VOID	PowerSendPowerUpEvents (VOID)
VOID	PowerSendPowerDownFailureEvent (__in FxPowerDownType Type)
VOID	PowerSendPowerUpFailureEvent (VOID)
VOID	PowerSetDevicePowerState (__in WDF_POWER_DEVICE_STATE State)
_Must_inspect_result_ BOOLEAN	PowerDmaPowerUp (VOID)
BOOLEAN	PowerDmaPowerDown (VOID)
VOID	PowerConnectInterruptFailed (VOID)
VOID	PowerPolicyUpdateSystemWakeSource (__in FxIrp *Irp)
_Must_inspect_result_ NTSTATUS	PowerPolicySendDevicePowerRequest (__in DEVICE_POWER_STATE DeviceState, __in SendDeviceRequestAction Action)
_Must_inspect_result_ NTSTATUS	PowerPolicySendWaitWakeRequest (__in SYSTEM_POWER_STATE SystemState)
VOID	PowerPolicyCompleteSystemPowerIrp (VOID)
BOOLEAN	PowerPolicyCancelWaitWake (VOID)
VOID	PowerPolicySubmitUsbIdleNotification (VOID)
BOOLEAN	PowerPolicyCancelUsbSSIfCapable (VOID)
VOID	PowerPolicyCancelUsbSS (VOID)
SYSTEM_POWER_STATE	PowerPolicyGetPendingSystemState (VOID)
_Must_inspect_result_ NTSTATUS	PowerPolicyHandleSystemQueryPower (__in SYSTEM_POWER_STATE QueryState)
BOOLEAN	PowerPolicyCanWakeFromSystemState (__in SYSTEM_POWER_STATE SystemState)
SYSTEM_POWER_STATE	PowerPolicyGetDeviceDeepestSystemWakeState (VOID)
DEVICE_POWER_STATE	PowerPolicyGetDeviceDeepestDeviceWakeState (__in SYSTEM_POWER_STATE SystemState)
BOOLEAN	IsPresentPendingPnpIrp (VOID)
VOID	SetPendingPnpIrp (__inout FxIrp *Irp, __in BOOLEAN MarkIrpPending=TRUE)
VOID	SetPendingPnpIrpStatus (__in NTSTATUS Status)
MdIrp	ClearPendingPnpIrp (VOID)
MdIrp	GetPendingPnpIrp (VOID)
VOID	SetPendingDevicePowerIrp (__inout FxIrp *Irp)
MdIrp	ClearPendingDevicePowerIrp (VOID)
VOID	SetPendingSystemPowerIrp (__inout FxIrp *Irp)
MdIrp	ClearPendingSystemPowerIrp (VOID)
MdIrp	GetPendingSystemPowerIrp (VOID)
BOOLEAN	IsDevicePowerUpIrpPending (VOID)
BOOLEAN	IsUsageSupported (__in DEVICE_USAGE_NOTIFICATION_TYPE Usage)
VOID	SetUsageSupport (__in DEVICE_USAGE_NOTIFICATION_TYPE Usage, __in BOOLEAN Supported)
LONG	AdjustUsageCount (__in DEVICE_USAGE_NOTIFICATION_TYPE Usage, __in BOOLEAN Add)
LONG	GetUsageCount (__in __range(1, 4) ULONG Usage)
BOOLEAN	IsInSpecialUse (VOID)
ULONG	SetUsageNotificationFlags (__in DEVICE_USAGE_NOTIFICATION_TYPE Type, __in BOOLEAN InPath)
VOID	RevertUsageNotificationFlags (__in DEVICE_USAGE_NOTIFICATION_TYPE Type, __in BOOLEAN InPath, __in ULONG OldFlags)
VOID	CommitUsageNotification (__in DEVICE_USAGE_NOTIFICATION_TYPE Type, __in ULONG OldFlags)
_Must_inspect_result_ NTSTATUS	CreatePowerThread (VOID)
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
static _Must_inspect_result_ NTSTATUS	_PnpStartDevice (__inout FxPkgPnp *This, __inout FxIrp *Irp)
static _Must_inspect_result_ NTSTATUS	_PnpQueryStopDevice (__inout FxPkgPnp *This, __inout FxIrp *Irp)
static _Must_inspect_result_ NTSTATUS	_PnpCancelStopDevice (__inout FxPkgPnp *This, __inout FxIrp *Irp)
static _Must_inspect_result_ NTSTATUS	_PnpStopDevice (__inout FxPkgPnp *This, __inout FxIrp *Irp)
static _Must_inspect_result_ NTSTATUS	_PnpQueryRemoveDevice (__inout FxPkgPnp *This, __inout FxIrp *Irp)
static _Must_inspect_result_ NTSTATUS	_PnpCancelRemoveDevice (__inout FxPkgPnp *This, __inout FxIrp *Irp)
static _Must_inspect_result_ NTSTATUS	_PnpRemoveDevice (__inout FxPkgPnp *This, __inout FxIrp *Irp)
static VOID	_PnpProcessEventInner (__inout FxPkgPnp *This, __inout FxPostProcessInfo *Info, __in PVOID WorkerContext)
static VOID	_PowerProcessEventInner (__in FxPkgPnp *This, __in FxPostProcessInfo *Info, __in PVOID WorkerContext)
static VOID	_PowerPolicyProcessEventInner (__inout FxPkgPnp *This, __inout FxPostProcessInfo *Info, __in PVOID WorkerContext)
static _Must_inspect_result_ NTSTATUS	_DispatchWaitWake (__inout FxPkgPnp *This, __inout FxIrp *Irp)
static _Must_inspect_result_ NTSTATUS	_PnpDeviceUsageNotification (__inout FxPkgPnp *This, __inout FxIrp *Irp)
static VOID	_SetPowerCapState (__in ULONG Index, __in DEVICE_POWER_STATE State, __out PULONG Result)
static DEVICE_POWER_STATE	_GetPowerCapState (__in ULONG Index, __in ULONG State)
static WDF_DEVICE_PNP_STATE	PnpEventCheckForDevicePresence (__inout FxPkgPnp *This)
static WDF_DEVICE_PNP_STATE	PnpEventEjectHardware (__inout FxPkgPnp *This)
static WDF_DEVICE_PNP_STATE	PnpEventInitStarting (__inout FxPkgPnp *This)
static WDF_DEVICE_PNP_STATE	PnpEventInitSurpriseRemoved (__inout FxPkgPnp *This)
static WDF_DEVICE_PNP_STATE	PnpEventHardwareAvailable (__inout FxPkgPnp *This)
static WDF_DEVICE_PNP_STATE	PnpEventEnableInterfaces (__inout FxPkgPnp *This)
static WDF_DEVICE_PNP_STATE	PnpEventHardwareAvailablePowerPolicyFailed (__inout FxPkgPnp *This)
static WDF_DEVICE_PNP_STATE	PnpEventQueryRemoveAskDriver (__inout FxPkgPnp *This)
static WDF_DEVICE_PNP_STATE	PnpEventQueryRemoveEnsureDeviceAwake (__inout FxPkgPnp *This)
static WDF_DEVICE_PNP_STATE	PnpEventQueryRemovePending (__inout FxPkgPnp *This)
static WDF_DEVICE_PNP_STATE	PnpEventQueryRemoveStaticCheck (__inout FxPkgPnp *This)
static WDF_DEVICE_PNP_STATE	PnpEventQueriedRemoving (__inout FxPkgPnp *This)
static WDF_DEVICE_PNP_STATE	PnpEventQueryStopAskDriver (__inout FxPkgPnp *This)
static WDF_DEVICE_PNP_STATE	PnpEventQueryStopEnsureDeviceAwake (__inout FxPkgPnp *This)
static WDF_DEVICE_PNP_STATE	PnpEventQueryStopPending (__inout FxPkgPnp *This)
static WDF_DEVICE_PNP_STATE	PnpEventQueryStopStaticCheck (__inout FxPkgPnp *This)
static WDF_DEVICE_PNP_STATE	PnpEventQueryCanceled (__inout FxPkgPnp *This)
static WDF_DEVICE_PNP_STATE	PnpEventRemoved (__inout FxPkgPnp *This)
static WDF_DEVICE_PNP_STATE	PnpEventPdoRemoved (__inout FxPkgPnp *This)
static WDF_DEVICE_PNP_STATE	PnpEventRemovedPdoWait (__inout FxPkgPnp *This)
static WDF_DEVICE_PNP_STATE	PnpEventRemovedPdoSurpriseRemoved (__inout FxPkgPnp *This)
static WDF_DEVICE_PNP_STATE	PnpEventRemovingDisableInterfaces (__inout FxPkgPnp *This)
static WDF_DEVICE_PNP_STATE	PnpEventRestarting (__inout FxPkgPnp *This)
static WDF_DEVICE_PNP_STATE	PnpEventStarted (__inout FxPkgPnp *This)
static WDF_DEVICE_PNP_STATE	PnpEventStartedCancelStop (__inout FxPkgPnp *This)
static WDF_DEVICE_PNP_STATE	PnpEventStartedCancelRemove (__inout FxPkgPnp *This)
static WDF_DEVICE_PNP_STATE	PnpEventStartedRemoving (__inout FxPkgPnp *This)
static WDF_DEVICE_PNP_STATE	PnpEventStartingFromStopped (__inout FxPkgPnp *This)
static WDF_DEVICE_PNP_STATE	PnpEventStopped (__inout FxPkgPnp *This)
static WDF_DEVICE_PNP_STATE	PnpEventStoppedWaitForStartCompletion (__inout FxPkgPnp *This)
static WDF_DEVICE_PNP_STATE	PnpEventStartedStopping (__inout FxPkgPnp *This)
static WDF_DEVICE_PNP_STATE	PnpEventSurpriseRemoved (__inout FxPkgPnp *This)
static WDF_DEVICE_PNP_STATE	PnpEventInitQueryRemove (__inout FxPkgPnp *This)
static WDF_DEVICE_PNP_STATE	PnpEventInitQueryRemoveCanceled (__inout FxPkgPnp *This)
static WDF_DEVICE_PNP_STATE	PnpEventFdoRemoved (__inout FxPkgPnp *This)
static WDF_DEVICE_PNP_STATE	PnpEventQueriedSurpriseRemove (__inout FxPkgPnp *This)
static WDF_DEVICE_PNP_STATE	PnpEventSurpriseRemoveIoStarted (__inout FxPkgPnp *This)
static WDF_DEVICE_PNP_STATE	PnpEventFailedPowerDown (__inout FxPkgPnp *This)
static WDF_DEVICE_PNP_STATE	PnpEventFailedIoStarting (__inout FxPkgPnp *This)
static WDF_DEVICE_PNP_STATE	PnpEventFailedOwnHardware (__inout FxPkgPnp *This)
static WDF_DEVICE_PNP_STATE	PnpEventFailed (__inout FxPkgPnp *This)
static WDF_DEVICE_PNP_STATE	PnpEventFailedPowerPolicyRemoved (__inout FxPkgPnp *This)
static WDF_DEVICE_PNP_STATE	PnpEventFailedSurpriseRemoved (__inout FxPkgPnp *This)
static WDF_DEVICE_PNP_STATE	PnpEventFailedStarted (__inout FxPkgPnp *This)
static WDF_DEVICE_PNP_STATE	PnpEventFailedInit (__inout FxPkgPnp *This)
static WDF_DEVICE_PNP_STATE	PnpEventPdoInitFailed (__inout FxPkgPnp *This)
static WDF_DEVICE_PNP_STATE	PnpEventRestart (__inout FxPkgPnp *This)
static WDF_DEVICE_PNP_STATE	PnpEventRestartReleaseHardware (__inout FxPkgPnp *This)
static WDF_DEVICE_PNP_STATE	PnpEventRestartHardwareAvailable (__inout FxPkgPnp *This)
static WDF_DEVICE_PNP_STATE	PnpEventPdoRestart (__inout FxPkgPnp *This)
static WDF_DEVICE_PNP_STATE	PnpEventRemovedChildrenRemoved (__inout FxPkgPnp *This)
static WDF_DEVICE_PNP_STATE	PnpEventFinal (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerCheckDeviceType (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerCheckDeviceTypeNP (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerEnablingWakeAtBus (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerEnablingWakeAtBusNP (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerCheckParentState (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerCheckParentStateNP (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerDZero (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerD0NP (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerD0BusWakeOwner (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerD0BusWakeOwnerNP (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerD0ArmedForWake (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerD0ArmedForWakeNP (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerGotoImplicitD3DisarmWakeAtBus (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerD0DisarmingWakeAtBus (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerD0DisarmingWakeAtBusNP (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerD0Starting (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerD0StartingConnectInterrupt (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerD0StartingDmaEnable (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerD0StartingStartSelfManagedIo (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerDecideD0State (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerGotoD3Stopped (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerStartingCheckDeviceType (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerStartingChild (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerDxDisablingWakeAtBus (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerDxDisablingWakeAtBusNP (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerGotoDNotZero (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerGotoDNotZeroNP (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerGotoDNotZeroIoStopped (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerGotoDNotZeroIoStoppedNP (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerGotoDxNPFailed (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerGotoDxArmedForWake (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerGotoDxArmedForWakeNP (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerDNotZeroNP (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerGotoDxIoStoppedArmedForWake (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerGotoDxIoStoppedArmedForWakeNP (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerCheckParentStateArmedForWake (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerCheckParentStateArmedForWakeNP (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerStartSelfManagedIo (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerStartSelfManagedIoNP (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerStartSelfManagedIoFailed (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerStartSelfManagedIoFailedNP (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerWakePending (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerWakePendingNP (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerWaking (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerWakingNP (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerWakingConnectInterrupt (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerWakingConnectInterruptNP (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerWakingConnectInterruptFailed (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerWakingConnectInterruptFailedNP (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerWakingDmaEnable (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerWakingDmaEnableNP (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerWakingDmaEnableFailed (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerWakingDmaEnableFailedNP (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerReportPowerUpFailedDerefParent (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerReportPowerUpFailed (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerPowerFailedPowerDown (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerReportPowerDownFailed (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerInitialConnectInterruptFailed (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerInitialDmaEnableFailed (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerInitialSelfManagedIoFailed (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerInitialPowerUpFailedDerefParent (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerInitialPowerUpFailed (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerDxSurpriseRemovedPowerDown (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerDxSurpriseRemovedPowerUp (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerDxStoppedDisarmWake (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerDxStoppedDisarmWakeNP (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerGotoDxStoppedDisableInterruptNP (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerGotoDxStopped (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerGotoStopped (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerStoppedCompleteDx (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerDxStoppedDecideDxState (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerDxStoppedArmForWake (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerDxStoppedArmForWakeNP (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerFinalPowerDownFailed (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerD0SurpriseRemoved (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerSurpriseRemoved (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerUpFailedDerefParent (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerUpFailed (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerGotoDxFailed (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerGotoDxStoppedDisableInterrupt (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerUpFailedDerefParentNP (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerUpFailedNP (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerNotifyingD0ExitToWakeInterrupts (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerNotifyingD0EntryToWakeInterrupts (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerNotifyingD0ExitToWakeInterruptsNP (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_STATE	PowerNotifyingD0EntryToWakeInterruptsNP (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolStarting (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolStartingPoweredUp (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolStartingPoweredUpFailed (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolStartingSucceeded (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolStartingFailed (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolStartingDecideS0Wake (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolStartedIdleCapable (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolIdleCapableDeviceIdle (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolDeviceIdleReturnToActive (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolDeviceIdleSleeping (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolDeviceIdleStopping (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolTimerExpiredNoWake (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolTimerExpiredNoWakeCompletePowerDown (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolWaitingUnarmedQueryIdle (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolS0NoWakePowerUp (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolS0NoWakeCompletePowerUp (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolSystemSleepFromDeviceWaitingUnarmed (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolSystemSleepNeedWake (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolSystemSleepNeedWakeCompletePowerUp (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolSystemSleepPowerRequestFailed (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolCheckPowerPageable (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolSleepingWakeWakeArrived (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolSleepingWakeRevertArmWake (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolSystemAsleepWakeArmed (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolSystemWakeDeviceWakeEnabled (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolSystemWakeDeviceWakeEnabledWakeCanceled (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolSystemWakeDeviceWakeDisarm (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolSystemWakeDeviceWakeTriggeredS0 (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolSystemWakeDeviceWokeDisarm (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolSleepingWakeWakeArrivedNP (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolSleepingWakeRevertArmWakeNP (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolSleepingWakePowerDownFailed (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolSleepingWakePowerDownFailedWakeCanceled (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolSystemAsleepWakeArmedNP (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolSystemWakeDeviceWakeEnabledNP (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolSystemWakeDeviceWakeEnabledWakeCanceledNP (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolSystemWakeDeviceWakeDisarmNP (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolSystemWakeDeviceWakeTriggeredS0NP (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolSystemWakeDeviceWokeDisarmNP (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolSystemWakeDeviceWakeCompletePowerUp (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolSleeping (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolSleepingNoWakePowerDown (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolSleepingNoWakeCompletePowerDown (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolSleepingNoWakeDxRequestFailed (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolSleepingWakePowerDown (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolSleepingSendWake (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolSystemAsleepNoWake (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolSystemWakeDeviceWakeDisabled (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolSystemWakeDeviceToD0 (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolSystemWakeDeviceToD0CompletePowerUp (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolSystemWakeQueryIdle (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolStartedWakeCapable (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolWakeCapableDeviceIdle (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolWakeCapableUsbSSCompleted (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolTimerExpiredDecideUsbSS (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolTimerExpiredWakeCapablePowerDown (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolTimerExpiredWakeCapableSendWake (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolTimerExpiredWakeCapableUsbSS (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolTimerExpiredWakeCapableWakeArrived (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolTimerExpiredWakeCapableCancelWake (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolTimerExpiredWakeCapableWakeCanceled (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolTimerExpiredWakeCapableCleanup (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolTimerExpiredWakeCapableDxAllocFailed (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolTimerExpiredWakeCapableUndoPowerDown (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolTimerExpiredWakeCompletedPowerDown (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolTimerExpiredWakeCompletedPowerUp (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolTimerExpiredWakeCompletedHardwareStarted (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolWaitingArmedUsbSS (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolWaitingArmedQueryIdle (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolIoPresentArmed (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolIoPresentArmedWakeCanceled (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolS0WakeDisarm (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolS0WakeCompletePowerUp (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolTimerExpiredWakeSucceeded (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolTimerExpiredWakeCompletedDisarm (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolWakeFailedUsbSS (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolTimerExpiredWakeCapablePowerDownFailedCancelWake (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolTimerExpiredWakeCapablePowerDownFailedWakeCanceled (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolTimerExpiredWakeCapablePowerDownFailedUsbSS (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolCancelingWakeForSystemSleep (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolCancelingWakeForSystemSleepWakeCanceled (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolDisarmingWakeForSystemSleepCompletePowerUp (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolPowerUpForSystemSleepFailed (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolWokeFromS0UsbSS (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolWokeFromS0 (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolWokeFromS0NotifyDriver (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolStoppingResetDevice (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolStoppingResetDeviceCompletePowerUp (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolStoppingResetDeviceFailed (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolStoppingD0 (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolStoppingD0Failed (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolStoppingDisarmWake (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolStoppingDisarmWakeCancelWake (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolStoppingDisarmWakeWakeCanceled (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolStopping (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolStoppingSucceeded (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolStoppingFailed (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolStoppingSendStatus (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolStoppedRemoving (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolRemoved (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolRestarting (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolRestartingFailed (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolStoppingCancelTimer (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolStoppingCancelUsbSS (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolStoppingCancelWake (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolCancelUsbSS (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolStarted (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolStartedCancelTimer (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolStartedWakeCapableCancelTimerForSleep (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolStartedWakeCapableSleepingUsbSS (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolStartedIdleCapableCancelTimerForSleep (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolDeviceD0PowerRequestFailed (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolDevicePowerRequestFailed (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolSleepingPowerDownNotProcessed (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolTimerExpiredWakeCapablePowerDownNotProcessed (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolTimerExpiredNoWakePowerDownNotProcessed (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolTimerExpiredNoWakeUndoPowerDown (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolTimerExpiredNoWakeReturnToActive (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolTimerExpiredNoWakePoweredDownDisableIdleTimer (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolPowerUpForSystemSleepNotSeen (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolWaitingArmedStoppingCancelUsbSS (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolWaitingArmedWakeFailedCancelUsbSS (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolWaitingArmedIoPresentCancelUsbSS (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolWaitingArmedWakeSucceededCancelUsbSS (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolCancelingUsbSSForSystemSleep (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolStoppingD0CancelUsbSS (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolWaitingArmedWakeInterruptFired (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolSystemWakeDeviceWakeInterruptFired (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolSystemWakeDeviceWakeInterruptFiredNP (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	PowerPolTimerExpiredWakeCapableWakeInterruptArrived (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	NotPowerPolOwnerStarting (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	NotPowerPolOwnerStarted (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	NotPowerPolOwnerGotoDx (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	NotPowerPolOwnerGotoDxInDx (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	NotPowerPolOwnerGotoD0 (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	NotPowerPolOwnerGotoD0InD0 (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	NotPowerPolOwnerStopping (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	NotPowerPolOwnerStoppingSendStatus (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	NotPowerPolOwnerStartingFailed (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	NotPowerPolOwnerStoppingFailed (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	NotPowerPolOwnerStoppingPoweringUp (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	NotPowerPolOwnerStoppingPoweringDown (__inout FxPkgPnp *This)
static WDF_DEVICE_POWER_POLICY_STATE	NotPowerPolOwnerRemoved (__inout FxPkgPnp *This)
static VOID	_PowerSetSystemWakeSource (__in FxIrp *Irp)
static CPPNP_STATE_TABLE	GetPnpTableEntry (__in WDF_DEVICE_PNP_STATE State)
static CPPOWER_STATE_TABLE	GetPowerTableEntry (__in WDF_DEVICE_POWER_STATE State)
static CPPOWER_POLICY_STATE_TABLE	GetPowerPolicyTableEntry (__in WDF_DEVICE_POWER_POLICY_STATE State)
static _Must_inspect_result_ CPNOT_POWER_POLICY_OWNER_STATE_TABLE	GetNotPowerPolicyOwnerTableEntry (__in WDF_DEVICE_POWER_POLICY_STATE State)
static NTSTATUS	_S0IdleQueryInstance (__in CfxDevice *Device, __in FxWmiInstanceInternal *Instance, __in ULONG OutBufferSize, __out PVOID OutBuffer, __out PULONG BufferUsed)
static NTSTATUS	_S0IdleSetInstance (__in CfxDevice *Device, __in FxWmiInstanceInternal *Instance, __in ULONG InBufferSize, __in PVOID InBuffer)
static NTSTATUS	_S0IdleSetItem (__in CfxDevice *Device, __in FxWmiInstanceInternal *Instance, __in ULONG DataItemId, __in ULONG InBufferSize, __in PVOID InBuffer)
static NTSTATUS	_SxWakeQueryInstance (__in CfxDevice *Device, __in FxWmiInstanceInternal *Instaace, __in ULONG OutBufferSize, __out PVOID OutBuffer, __out PULONG BufferUsed)
static NTSTATUS	_SxWakeSetInstance (__in CfxDevice *Device, __in FxWmiInstanceInternal *Instance, __in ULONG InBufferSize, __in PVOID InBuffer)
static NTSTATUS	_SxWakeSetItem (__in CfxDevice *Device, __in FxWmiInstanceInternal *Instance, __in ULONG DataItemId, __in ULONG InBufferSize, __in PVOID InBuffer)
static DEVICE_USAGE_NOTIFICATION_TYPE	_SpecialTypeToUsage (__in WDF_SPECIAL_FILE_TYPE Type)
static WDF_SPECIAL_FILE_TYPE	_UsageToSpecialType (__in DEVICE_USAGE_NOTIFICATION_TYPE Type)
Static Protected Member Functions inherited from FxObject
static PVOID	_GetBase (__in FxObject *Object)

Protected Attributes
MxEvent *	m_DeviceRemoveProcessed
LONG	m_PendingChildCount
BYTE	m_DeviceWake [DeviceWakeStates]
BYTE	m_SystemWake
BYTE	m_FailedAction
BYTE	m_SetDeviceRemoveProcessed
POWER_THREAD_INTERFACE	m_PowerThreadInterface
FxEnumerationInfo *	m_EnumInfo
FxCmResList *	m_Resources
FxCmResList *	m_ResourcesRaw
FxSpinLockTransactionedList *	m_DmaEnablerList
PNP_BUS_INFORMATION	m_BusInformation
UCHAR	m_BusEnumRetries
UCHAR	m_SystemPowerAction
BOOLEAN	m_CapsQueried
BOOLEAN	m_InternalFailure
BOOLEAN	m_HasPowerThread
BOOLEAN	m_ReleaseHardwareAfterDescendantsOnFailure
PFN_IO_CONNECT_INTERRUPT_EX	m_IoConnectInterruptEx
PFN_IO_DISCONNECT_INTERRUPT_EX	m_IoDisconnectInterruptEx
PFN_IO_REPORT_INTERRUPT_ACTIVE	m_IoReportInterruptActive
PFN_IO_REPORT_INTERRUPT_INACTIVE	m_IoReportInterruptInactive
Protected Attributes inherited from FxObject
union {
CfxDeviceBase *   m_DeviceBase
CfxDevice *   m_Device
};

Static Protected Attributes
static MdCancelRoutineType	_PowerWaitWakeCancelRoutine
static MdRequestPowerCompleteType	_PowerPolDeviceWaitWakeComplete
static MdRequestPowerCompleteType	_PowerPolDevicePowerDownComplete
static MdRequestPowerCompleteType	_PowerPolDevicePowerUpComplete
static MdCompletionRoutineType	_PowerPolicyWaitWakeCompletionRoutine
static MdCompletionRoutineType	_PowerPolicyUsbSelectiveSuspendCompletionRoutine
static const GUID	GUID_POWER_THREAD_INTERFACE

Private Member Functions
VOID	DisconnectInterruptNP (VOID)
NTSTATUS	UpdateWmiInstanceForS0Idle (__in FxWmiInstanceAction Action)
VOID	ReadRegistryS0Idle (__in PCUNICODE_STRING ValueName, __out BOOLEAN *Enabled)
NTSTATUS	UpdateWmiInstanceForSxWake (__in FxWmiInstanceAction Action)
VOID	ReadRegistrySxWake (__in PCUNICODE_STRING ValueName, __out BOOLEAN *Enabled)
VOID	WriteStateToRegistry (__in HANDLE RegKey, __in PUNICODE_STRING ValueName, __in ULONG Value)
NTSTATUS	ReadStateFromRegistry (_In_ PCUNICODE_STRING ValueName, _Out_ PULONG Value)
NTSTATUS	UpdateWmiInstance (_In_ FxWmiInstanceAction Action, _In_ BOOLEAN ForS0Idle)
VOID	PowerPolicyCheckAssumptions (VOID)
VOID	PowerCheckAssumptions (VOID)
VOID	PnpCheckAssumptions (VOID)
VOID	NotifyResourceobjectsToReleaseResources (VOID)
_Must_inspect_result_ NTSTATUS	NotifyResourceObjectsD0 (__in ULONG NotifyFlags)
NTSTATUS	NotifyResourceObjectsDx (__in ULONG NotifyFlags)
BOOLEAN	PnpCheckAndIncrementRestartCount (VOID)
BOOLEAN	PnpIncrementRestartCountLogic (_In_ HANDLE RestartKey, _In_ BOOLEAN CreatedNewKey)
VOID	PnpCleanupForRemove (__in BOOLEAN GracefulRemove)
virtual NTSTATUS	ProcessRemoveDeviceOverload (FxIrp *Irp)=0
virtual VOID	DeleteSymbolicLinkOverload (BOOLEAN GracefulRemove)=0
virtual VOID	QueryForReenumerationInterface (VOID)=0
virtual VOID	ReleaseReenumerationInterface (VOID)=0
virtual NTSTATUS	AskParentToRemoveAndReenumerate (VOID)=0
_Must_inspect_result_ NTSTATUS	CreatePowerThreadIfNeeded (VOID)
virtual NTSTATUS	QueryForPowerThread (VOID)=0
VOID	ReleasePowerThread (VOID)
_Must_inspect_result_ NTSTATUS	HandleQueryInterfaceForPowerThread (__inout FxIrp *Irp, __out PBOOLEAN CompleteRequest)
_Must_inspect_result_ NTSTATUS	PnpPowerReferenceSelf (VOID)
VOID	PnpPowerDereferenceSelf (VOID)
BOOLEAN	PowerPolicyCanIdlePowerDown (__in DEVICE_POWER_STATE DxState)
VOID	PowerPolicyPostParentToD0ToChildren (VOID)
VOID	PowerPolicyChildrenCanPowerUp (VOID)
VOID __inline	PowerPolicyDisarmWakeFromSx (VOID)
_Must_inspect_result_ NTSTATUS	PowerPolicyPowerDownForSx (__in DEVICE_POWER_STATE DxState, __in SendDeviceRequestAction Action)
VOID	PowerPolicyBlockChildrenPowerUp (VOID)
_Must_inspect_result_ NTSTATUS	PnpPowerReferenceDuringQueryPnp (VOID)

Static Private Member Functions
static VOID	_PowerThreadEnqueue (__in PVOID Context, __in PWORK_QUEUE_ITEM WorkItem)
static VOID STDCALL	_PowerThreadInterfaceReference (__inout PVOID Context)
static VOID STDCALL	_PowerThreadInterfaceDereference (__inout PVOID Context)

Private Attributes
friend	FxPnpMachine
friend	FxPowerMachine
friend	FxPowerPolicyMachine
friend	FxPowerPolicyOwnerSettings
friend	FxInterrupt
FxCREvent	m_CleanupEventUm
MxEvent	m_RemoveEventUm
ULONG	m_InterruptObjectCount
LIST_ENTRY	m_InterruptListHead
ULONG	m_WakeInterruptCount
ULONG	m_WakeInterruptPendingAckCount
BOOLEAN	m_SystemWokenByWakeInterrupt
BOOLEAN	m_WakeInterruptsKeepConnected
BOOLEAN	m_AchievedStart
FxSystemThread *	m_PowerThread
LONG	m_PowerThreadInterfaceReferenceCount
FxCREvent *	m_PowerThreadEvent
MdIrp	m_PendingPnPIrp
MdIrp	m_PendingSystemPowerIrp
MdIrp	m_PendingDevicePowerIrp
FxPnpStateCallback *	m_PnpStateCallbacks
FxPowerStateCallback *	m_PowerStateCallbacks
FxPowerPolicyStateCallback *	m_PowerPolicyStateCallbacks

Static Private Attributes
static const PNP_STATE_TABLE	m_WdfPnpStates []
static const POWER_STATE_TABLE	m_WdfPowerStates []
static const POWER_POLICY_STATE_TABLE	m_WdfPowerPolicyStates []
static const NOT_POWER_POLICY_OWNER_STATE_TABLE	m_WdfNotPowerPolicyOwnerStates []
static const PNP_EVENT_TARGET_STATE	m_PnpInitOtherStates []
static const PNP_EVENT_TARGET_STATE	m_PnpInitStartingOtherStates []
static const PNP_EVENT_TARGET_STATE	m_PnpHardwareAvailableOtherStates []
static const PNP_EVENT_TARGET_STATE	m_PnpQueryStopPendingOtherStates []
static const PNP_EVENT_TARGET_STATE	m_PnpRemovedPdoWaitOtherStates []
static const PNP_EVENT_TARGET_STATE	m_PnpRestartingOtherStates []
static const PNP_EVENT_TARGET_STATE	m_PnpStartedOtherStates []
static const PNP_EVENT_TARGET_STATE	m_PnpQueryRemovePendingOtherStates []
static const PNP_EVENT_TARGET_STATE	m_PnpQueriedRemovingOtherStates []
static const PNP_EVENT_TARGET_STATE	m_PnpInitQueryRemoveOtherStates []
static const PNP_EVENT_TARGET_STATE	m_PnpStoppedOtherStates []
static const PNP_EVENT_TARGET_STATE	m_PnpStoppedWaitForStartCompletionOtherStates []
static const PNP_EVENT_TARGET_STATE	m_PnpStartedStoppingOtherStates []
static const PNP_EVENT_TARGET_STATE	m_PnpStartedStoppingFailedOtherStates []
static const PNP_EVENT_TARGET_STATE	m_PnpEjectFailedOtherStates []
static const PNP_EVENT_TARGET_STATE	m_PnpStartedRemovingOtherStates []
static const PNP_EVENT_TARGET_STATE	m_PnpFailedPowerDownOtherStates []
static const PNP_EVENT_TARGET_STATE	m_PnpFailedIoStartingOtherStates []
static const PNP_EVENT_TARGET_STATE	m_PnpFailedWaitForRemoveOtherStates []
static const PNP_EVENT_TARGET_STATE	m_PnpRestartOtherStates []
static const PNP_EVENT_TARGET_STATE	m_PnpRestartReleaseHardware []
static const PNP_EVENT_TARGET_STATE	m_PnpRestartHardwareAvailableOtherStates []
static const POWER_EVENT_TARGET_STATE	m_PowerD0OtherStates []
static const POWER_EVENT_TARGET_STATE	m_PowerD0NPOtherStates []
static const POWER_EVENT_TARGET_STATE	m_PowerD0BusWakeOwnerOtherStates []
static const POWER_EVENT_TARGET_STATE	m_PowerD0BusWakeOwnerNPOtherStates []
static const POWER_EVENT_TARGET_STATE	m_PowerD0ArmedForWakeOtherStates []
static const POWER_EVENT_TARGET_STATE	m_PowerD0ArmedForWakeNPOtherStates []
static const POWER_EVENT_TARGET_STATE	m_PowerDNotZeroOtherStates []
static const POWER_EVENT_TARGET_STATE	m_PowerDNotZeroNPOtherStates []
static const POWER_EVENT_TARGET_STATE	m_DxArmedForWakeOtherStates []
static const POWER_EVENT_TARGET_STATE	m_DxArmedForWakeNPOtherStates []
static const POWER_EVENT_TARGET_STATE	m_WakePendingOtherStates []
static const POWER_EVENT_TARGET_STATE	m_WakePendingNPOtherStates []
static const POWER_EVENT_TARGET_STATE	m_DxSurpriseRemovedOtherStates []
static const POWER_EVENT_TARGET_STATE	m_PowerStoppedOtherStates []
static const POWER_EVENT_TARGET_STATE	m_PowerDxStoppedOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolObjectCreatedOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolStartingOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolStartedIdleCapableOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolIdleCapableDeviceIdleOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolTimerExpiredNoWakeOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolTimerExpiredNoWakeCompletePowerDownOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolWaitingUnarmedOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolS0NoWakePowerUpOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolS0NoWakeCompletePowerUpOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolSystemSleepNeedWakeOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolSystemSleepNeedWakeCompletePowerUpOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolSystemAsleepWakeArmedOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolSystemAsleepWakeArmedNPOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolSystemWakeDeviceToD0OtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolSystemWakeDeviceToD0CompletePowerUpOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolStartedWakeCapableOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolWakeCapableDeviceIdleOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolTimerExpiredWakeCapablePowerDownOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolTimerExpiredWakeCapableSendWakeOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolTimerExpiredWakeCapableUsbSSOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolWaitingArmedOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolDisarmingWakeForSystemSleepCompletePowerUpOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolCancelingWakeForSystemSleepWakeCanceledOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolWokeFromS0OtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolStoppingResetDeviceOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolStoppingResetDeviceCompletePowerUpOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolStoppingD0OtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolStoppingDisarmWakeOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolStoppingDisarmWakeCancelWakeOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolIoPresentArmedOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolIoPresentArmedWakeCanceledOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolS0WakeCompletePowerUpOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolTimerExpiredWakeCapableWakeSucceededOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolTimerExpiredWakeCapableWakeFailedOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolTimerExpiredWakeCapablePowerDownFailedCancelWakeOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolCancelingWakeForSystemSleepOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolTimerExpiredWakeCapableWakeArrivedOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolTimerExpiredWakeCapableCancelWakeOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolTimerExpiredWakeCompletedPowerDownOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolTimerExpiredWakeCompletedPowerUpOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolSystemWakeDeviceWakeEnabledOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolSystemWakeDeviceWakeEnabledNPOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolSystemWakeDeviceWakeEnabledWakeCanceledOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolSystemWakeDeviceWakeEnabledWakeCanceledNPOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolSleepingWakeWakeArrivedOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolSystemWakeDeviceWakeTriggeredS0OtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolSystemWakeDeviceWakeTriggeredS0NPOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolSystemWakeDeviceWakeCompletePowerUpOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolSleepingNoWakePowerDownOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolSleepingNoWakeCompletePowerDownOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolSleepingWakePowerDownOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolSleepingSendWakeOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolSleepingWakeWakeArrivedNPOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolSleepingWakePowerDownFailedOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolStartedOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolStartedWaitForIdleTimeoutOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolDevicePowerRequestFailedOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolStoppingOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolStoppedOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolRestartingOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolStoppingCancelWakeOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolCancelUsbSSOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolSleepingWakeRevertArmWakeOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolSleepingWakeRevertArmWakeNPOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolRemovedOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolTimerExpiredWakeCapableWakeInterruptArrivedOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolTimerExpiredWakeCapablePowerDownFailedWakeInterruptArrivedOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolWaitingArmedWakeInterruptFiredDuringPowerDownOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_NotPowerPolOwnerObjectCreatedStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_NotPowerPolOwnerStartingStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_NotPowerPolOwnerStartingSucceededStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_NotPowerPolOwnerStartingFailedStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_NotPowerPolOwnerGotoDxStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_NotPowerPolOwnerGotoDxInDxStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_NotPowerPolOwnerDxStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_NotPowerPolOwnerGotoD0States []
static const POWER_POLICY_EVENT_TARGET_STATE	m_NotPowerPolOwnerGotoD0InD0States []
static const POWER_POLICY_EVENT_TARGET_STATE	m_NotPowerPolOwnerStoppedStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_NotPowerPolOwnerStoppingWaitForImplicitPowerDownStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_NotPowerPolOwnerStoppingPoweringUpStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_NotPowerPolOwnerStoppingPoweringDownStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_NotPowerPolOwnerRemovedStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolWaitingArmedWakeInterruptFiredOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolSystemWakeDeviceWakeInterruptFiredOtherStates []
static const POWER_POLICY_EVENT_TARGET_STATE	m_PowerPolSystemWakeDeviceWakeInterruptFiredNPOtherStates []
static const PWCHAR	m_RestartStartAchievedName = RESTART_START_ACHIEVED_NAME
static const PWCHAR	m_RestartStartTimeName = RESTART_START_TIME_NAME
static const PWCHAR	m_RestartCountName = RESTART_COUNT_NAME
static const ULONG	m_RestartTimePeriodMaximum = 60
static const ULONG	m_RestartCountMaximum = 5

Additional Inherited Members
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)

Detailed Description

Definition at line 488 of file fxpkgpnp.hpp.

Constructor & Destructor Documentation

FxPkgPnp()

FxPkgPnp::FxPkgPnp ( __in PFX_DRIVER_GLOBALS  FxDriverGlobals, __in CfxDevice *  Device, __in WDFTYPE  Type  )

protected

Definition at line 48 of file fxpkgpnp.cpp.

      :
    FxPackage(FxDriverGlobals, Device, Type)
{
    ULONG i;
 
    m_DmaEnablerList = NULL;
    m_RemovalDeviceList = NULL;
    m_UsageDependentDeviceList = NULL;
 
    //
    // Initialize the structures to the default state and then override the
    // non WDF std default values to the unsupported / off values.
    //
    m_PnpStateAndCaps.Value =
        FxPnpStateDisabledUseDefault         |
        FxPnpStateDontDisplayInUIUseDefault  |
        FxPnpStateFailedUseDefault           |
        FxPnpStateNotDisableableUseDefault   |
        FxPnpStateRemovedUseDefault          |
        FxPnpStateResourcesChangedUseDefault |
 
        FxPnpCapLockSupportedUseDefault      |
        FxPnpCapEjectSupportedUseDefault     |
        FxPnpCapRemovableUseDefault          |
        FxPnpCapDockDeviceUseDefault         |
        FxPnpCapUniqueIDUseDefault           |
        FxPnpCapSilentInstallUseDefault      |
        FxPnpCapSurpriseRemovalOKUseDefault  |
        FxPnpCapHardwareDisabledUseDefault   |
        FxPnpCapNoDisplayInUIUseDefault
        ;
 
    m_PnpCapsAddress = (ULONG) -1;
    m_PnpCapsUINumber = (ULONG) -1;
 
    RtlZeroMemory(&m_PowerCaps, sizeof(m_PowerCaps));
    m_PowerCaps.Caps =
        FxPowerCapDeviceD1UseDefault   |
        FxPowerCapDeviceD2UseDefault   |
        FxPowerCapWakeFromD0UseDefault |
        FxPowerCapWakeFromD1UseDefault |
        FxPowerCapWakeFromD2UseDefault |
        FxPowerCapWakeFromD3UseDefault
        ;
 
    m_PowerCaps.DeviceWake = PowerDeviceMaximum;
    m_PowerCaps.SystemWake = PowerSystemMaximum;
 
    m_PowerCaps.D1Latency = (ULONG) -1;
    m_PowerCaps.D2Latency = (ULONG) -1;
    m_PowerCaps.D3Latency = (ULONG) -1;
 
    m_PowerCaps.States = 0;
    for (i = 0; i < PowerSystemMaximum; i++) {
        _SetPowerCapState(i, PowerDeviceMaximum, &m_PowerCaps.States);
    }
 
    RtlZeroMemory(&m_D3ColdInterface, sizeof(m_D3ColdInterface));
    RtlZeroMemory(&m_SpecialSupport[0], sizeof(m_SpecialSupport));
    RtlZeroMemory(&m_SpecialFileCount[0], sizeof(m_SpecialFileCount));
 
    m_PowerThreadInterface.Interface.Size = sizeof(m_PowerThreadInterface);
    m_PowerThreadInterface.Interface.Version = 1;
    m_PowerThreadInterface.Interface.Context = this;
    m_PowerThreadInterface.Interface.InterfaceReference = &FxPkgPnp::_PowerThreadInterfaceReference;
    m_PowerThreadInterface.Interface.InterfaceDereference = &FxPkgPnp::_PowerThreadInterfaceDereference;
    m_PowerThreadInterface.PowerThreadEnqueue = &FxPkgPnp::_PowerThreadEnqueue;
    m_PowerThread = NULL;
    m_HasPowerThread = FALSE;
    m_PowerThreadInterfaceReferenceCount = 1;
    m_PowerThreadEvent = NULL;
 
    m_DeviceStopCount = 0;
    m_CapsQueried = FALSE;
    m_InternalFailure = FALSE;
    m_FailedAction = WdfDeviceFailedUndefined;
 
    //
    // We only set the pending child count to 1 once we know we have successfully
    // created an FxDevice and initialized it fully.  If we delete an FxDevice
    // which is half baked, it cannot have any FxChildLists which have any
    // pending children on them.
    //
    m_PendingChildCount = 0;
 
    m_QueryInterfaceHead.Next = NULL;
 
    m_DeviceInterfaceHead.Next = NULL;
    m_DeviceInterfacesCanBeEnabled = FALSE;
 
    m_Failed = FALSE;
    m_SetDeviceRemoveProcessed = FALSE;
 
    m_SystemPowerState    = PowerSystemWorking;
    m_DevicePowerState    = WdfPowerDeviceD3Final;
    m_DevicePowerStateOld = WdfPowerDeviceD3Final;
 
    m_PendingPnPIrp = NULL;
    m_PendingSystemPowerIrp = NULL;
    m_PendingDevicePowerIrp = NULL;
    m_SystemPowerAction = (UCHAR) PowerActionNone;
 
    m_PnpStateCallbacks = NULL;
    m_PowerStateCallbacks = NULL;
    m_PowerPolicyStateCallbacks = NULL;
 
    m_SelfManagedIoMachine = NULL;
 
    m_EnumInfo = NULL;
 
    m_Resources = NULL;
    m_ResourcesRaw = NULL;
 
    InitializeListHead(&m_InterruptListHead);
    m_InterruptObjectCount = 0;
    m_WakeInterruptCount = 0;
    m_WakeInterruptPendingAckCount = 0;
    m_SystemWokenByWakeInterrupt = FALSE;
    m_WakeInterruptsKeepConnected = FALSE;
    m_AchievedStart = FALSE;
 
    m_SharedPower.m_WaitWakeIrp = NULL;
    m_SharedPower.m_WaitWakeOwner = FALSE;
    m_SharedPower.m_ExtendWatchDogTimer = FALSE;
 
    m_DeviceRemoveProcessed = NULL;
 
#if (FX_CORE_MODE==FX_CORE_KERNEL_MODE)
    //
    // Interrupt APIs for Vista and forward
    //
    m_IoConnectInterruptEx      = FxLibraryGlobals.IoConnectInterruptEx;
    m_IoDisconnectInterruptEx   = FxLibraryGlobals.IoDisconnectInterruptEx;
 
    //
    // Interrupt APIs for Windows 8 and forward
    //
    m_IoReportInterruptActive   = FxLibraryGlobals.IoReportInterruptActive;
    m_IoReportInterruptInactive = FxLibraryGlobals.IoReportInterruptInactive;
 
#endif
 
    m_ReleaseHardwareAfterDescendantsOnFailure = FALSE;
 
    MarkDisposeOverride(ObjectDoNotLock);
}

~FxPkgPnp()

FxPkgPnp::~FxPkgPnp ( )

protected

Definition at line 199 of file fxpkgpnp.cpp.

{
    PSINGLE_LIST_ENTRY ple;
 
    Mx::MxAssert(Mx::MxGetCurrentIrql() == PASSIVE_LEVEL);
 
    //
    // We should either have zero pending children or we never made it out of
    // the init state during a failed WDFDEVICE create or failed EvtDriverDeviceAdd
    //
    Mx::MxAssert(m_PendingChildCount == 0 ||
           m_Device->GetDevicePnpState() == WdfDevStatePnpInit);
 
 
    ple = m_DeviceInterfaceHead.Next;
    while (ple != NULL) {
        FxDeviceInterface* pDI;
 
        pDI = FxDeviceInterface::_FromEntry(ple);
 
        //
        // Advance to the next before deleting the current
        //
        ple = ple->Next;
 
        //
        // No longer in the list
        //
        pDI->m_Entry.Next = NULL;
 
        delete pDI;
    }
    m_DeviceInterfaceHead.Next = NULL;
 
    if (m_DmaEnablerList != NULL) {
        delete m_DmaEnablerList;
        m_DmaEnablerList = NULL;
    }
 
    if (m_RemovalDeviceList != NULL) {
        delete m_RemovalDeviceList;
        m_RemovalDeviceList = NULL;
    }
 
    if (m_UsageDependentDeviceList != NULL) {
        delete m_UsageDependentDeviceList;
        m_UsageDependentDeviceList = NULL;
    }
 
    if (m_PnpStateCallbacks != NULL) {
        delete m_PnpStateCallbacks;
    }
 
    if (m_PowerStateCallbacks != NULL) {
        delete m_PowerStateCallbacks;
    }
 
    if (m_PowerPolicyStateCallbacks != NULL) {
        delete m_PowerPolicyStateCallbacks;
    }
 
    if (m_SelfManagedIoMachine != NULL) {
        delete m_SelfManagedIoMachine;
        m_SelfManagedIoMachine = NULL;
    }
 
    if (m_EnumInfo != NULL) {
        delete m_EnumInfo;
        m_EnumInfo = NULL;
    }
 
    if (m_Resources != NULL) {
        m_Resources->RELEASE(this);
        m_Resources = NULL;
    }
 
    if (m_ResourcesRaw != NULL) {
        m_ResourcesRaw->RELEASE(this);
        m_ResourcesRaw = NULL;
    }
 
    ASSERT(IsListEmpty(&m_InterruptListHead));
}

Member Function Documentation

__drv_when()

FxPkgPnp::__drv_when ( !  NT_SUCCESSreturn, __drv_arg(ResourcesMatched, _Must_inspect_result_)    )

protected

_DispatchWaitWake()

_Must_inspect_result_ NTSTATUS FxPkgPnp::_DispatchWaitWake ( __inout FxPkgPnp *  This, __inout FxIrp *  Irp  )

staticprotected

Definition at line 2400 of file fxpkgpnp.cpp.

{
    return This->DispatchWaitWake(Irp);
}

_GetPowerCapState()

DEVICE_POWER_STATE FxPkgPnp::_GetPowerCapState ( __in ULONG  Index, __in ULONG  State  )

staticprotected

Definition at line 5657 of file fxpkgpnp.cpp.

{
    ASSERT(Index < 8);
                                // isolate the value            and normalize it
    return (DEVICE_POWER_STATE) ((State & (0xF << (Index * 4))) >> (Index * 4));
}

Referenced by FxPkgPdo::HandleQueryCapabilities(), FxPkgFdo::HandleQueryCapabilitiesCompletion(), and PowerPolSleepingNoWakePowerDown().

_PnpCancelRemoveDevice()

_Must_inspect_result_ NTSTATUS FxPkgPnp::_PnpCancelRemoveDevice ( __inout FxPkgPnp *  This, __inout FxIrp *  Irp  )

staticprotected

Definition at line 2026 of file fxpkgpnp.cpp.

{
    //
    // Seed the irp with success
    //
    Irp->SetStatus(STATUS_SUCCESS);
 
    //
    // Pend it and transition the state machine
    //
 
    This->SetPendingPnpIrp(Irp);
    This->PnpProcessEvent(PnpEventCancelRemove);
 
    return STATUS_PENDING;
}

_PnpCancelStopDevice()

_Must_inspect_result_ NTSTATUS FxPkgPnp::_PnpCancelStopDevice ( __inout FxPkgPnp *  This, __inout FxIrp *  Irp  )

staticprotected

Definition at line 1901 of file fxpkgpnp.cpp.

{
    //
    // Seed the irp with success
    //
    Irp->SetStatus(STATUS_SUCCESS);
 
    //
    // Pend it and transition the state machine
    //
    This->SetPendingPnpIrp(Irp);
    This->PnpProcessEvent(PnpEventCancelStop);
 
    return STATUS_PENDING;
}

_PnpDeviceUsageNotification()

_Must_inspect_result_ NTSTATUS FxPkgPnp::_PnpDeviceUsageNotification ( __inout FxPkgPnp *  This, __inout FxIrp *  Irp  )

staticprotected

Definition at line 3857 of file fxpkgpnp.cpp.

{
    return This->PnpDeviceUsageNotification(Irp);
}

_PnpProcessEventInner()

VOID FxPkgPnp::_PnpProcessEventInner ( __inout FxPkgPnp *  This, __inout FxPostProcessInfo *  Info, __in PVOID  WorkerContext  )

staticprotected

Definition at line 952 of file pnpstatemachine.cpp.

{
    UNREFERENCED_PARAMETER(WorkerContext);
 
    //
    // Take the state machine lock.
    //
    This->m_PnpMachine.m_StateMachineLock.AcquireLock(
        This->GetDriverGlobals()
        );
 
    //
    // Call the function that will actually run the state machine.
    //
    This->PnpProcessEventInner(Info);
 
    //
    // We are being called from the work item and m_WorkItemRunning is > 0, so
    // we cannot be deleted yet.
    //
    ASSERT(Info->SomethingToDo() == FALSE);
 
    //
    // Now release the lock
    //
    This->m_PnpMachine.m_StateMachineLock.ReleaseLock(
        This->GetDriverGlobals()
        );
}

Referenced by PostCreateDeviceInitialize().

_PnpQueryRemoveDevice()

_Must_inspect_result_ NTSTATUS FxPkgPnp::_PnpQueryRemoveDevice ( __inout FxPkgPnp *  This, __inout FxIrp *  Irp  )

staticprotected

Definition at line 1981 of file fxpkgpnp.cpp.

{
    //
    // By default we handle this state.
    //
    Irp->SetStatus(STATUS_SUCCESS);
 
    //
    // Keep this IRP around, since we're going to deal with it later.
    //
    This->SetPendingPnpIrp(Irp);
 
    //
    // Now run the state machine on this thread.
    //
    This->PnpProcessEvent(PnpEventQueryRemove);
 
    return STATUS_PENDING;
}

_PnpQueryStopDevice()

_Must_inspect_result_ NTSTATUS FxPkgPnp::_PnpQueryStopDevice ( __inout FxPkgPnp *  This, __inout FxIrp *  Irp  )

staticprotected

Definition at line 1850 of file fxpkgpnp.cpp.

{
    //
    // Keep this IRP around, since we're going to deal with it later.
    //
    This->SetPendingPnpIrp(Irp);
 
    //
    // Now run the state machine on this thread.
    //
    This->PnpProcessEvent(PnpEventQueryStop);
 
    return STATUS_PENDING;
}

_PnpRemoveDevice()

_Must_inspect_result_ NTSTATUS FxPkgPnp::_PnpRemoveDevice ( __inout FxPkgPnp *  This, __inout FxIrp *  Irp  )

staticprotected

Definition at line 2275 of file fxpkgpnp.cpp.

{
#if (FX_CORE_MODE==FX_CORE_USER_MODE)
    MxEvent * event = This->m_RemoveEventUm.GetSelfPointer();
#else
    MxEvent eventOnStack;
    eventOnStack.Initialize(SynchronizationEvent, FALSE);
    MxEvent * event = eventOnStack.GetSelfPointer();
#endif
 
    NTSTATUS status;
 
    status = Mx::MxAcquireRemoveLock(
        This->m_Device->GetRemoveLock(),
        Irp->GetIrp());
 
#if DBG
    ASSERT(NT_SUCCESS(status));
#else
    UNREFERENCED_PARAMETER(status);
#endif
 
    //
    // Keep this object around after m_Device has RELEASE'ed its reference to
    // this package.
    //
    This->ADDREF(Irp);
 
    //
    // Removes are always success
    //
    Irp->SetStatus(STATUS_SUCCESS);
 
    ASSERT(This->m_DeviceRemoveProcessed == NULL);
    This->m_DeviceRemoveProcessed = event;
 
    //
    // Post the event and wait for the FxDevice to destroy itself or determine
    // it has not been reported missing yet (for PDOs and bus filters).
    //
    This->PnpProcessEvent(PnpEventRemove);
 
    DoTraceLevelMessage(
        This->GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGPNP,
        "WDFDEVICE %p, !devobj %p waiting for remove event to finish processing",
        This->m_Device->GetHandle(), This->m_Device->GetDeviceObject());
 
    //
    // No need to wait in a critical region because we are in the context of a
    // pnp request which is in the system context.
    //
    event->WaitFor(Executive, KernelMode, FALSE, NULL);
 
    This->m_DeviceRemoveProcessed = NULL;
 
    status = This->ProcessRemoveDeviceOverload(Irp);
 
    //
    // Release the reference added at the top.  This is most likely going to be
    // the last reference on the package for KMDF. For UMDF, host manages the
    // lifetime of FxDevice so this may not be the last release for UMDF.
    //
    This->RELEASE(Irp);
 
    return status;
}

_PnpStartDevice()

_Must_inspect_result_ NTSTATUS FxPkgPnp::_PnpStartDevice ( __inout FxPkgPnp *  This, __inout FxIrp *  Irp  )

staticprotected

Definition at line 1823 of file fxpkgpnp.cpp.

{
    This->SetPendingPnpIrp(Irp);
    This->PnpProcessEvent(PnpEventStartDevice);
 
    return STATUS_PENDING;
}

_PnpStopDevice()

_Must_inspect_result_ NTSTATUS FxPkgPnp::_PnpStopDevice ( __inout FxPkgPnp *  This, __inout FxIrp *  Irp  )

staticprotected

Definition at line 1945 of file fxpkgpnp.cpp.

{
    //
    // Seed the irp with success
    //
    Irp->SetStatus(STATUS_SUCCESS);
 
    //
    // Pend and transition the state machine
    //
    This->SetPendingPnpIrp(Irp);
    This->PnpProcessEvent(PnpEventStop);
 
    return STATUS_PENDING;
}

_PowerPolicyProcessEventInner()

VOID FxPkgPnp::_PowerPolicyProcessEventInner ( __inout FxPkgPnp *  This, __inout FxPostProcessInfo *  Info, __in PVOID  WorkerContext  )

staticprotected

Definition at line 3048 of file powerpolicystatemachine.cpp.

{
 
    UNREFERENCED_PARAMETER(Context);
 
    //
    // Take the state machine lock.
    //
    This->m_PowerPolicyMachine.m_StateMachineLock.AcquireLock(
        This->GetDriverGlobals()
        );
 
    //
    // Call the function that will actually run the state machine.
    //
    This->PowerPolicyProcessEventInner(Info);
 
    //
    // We are being called from the work item and m_WorkItemRunning is > 0, so
    // we cannot be deleted yet.
    //
    ASSERT(Info->SomethingToDo() == FALSE);
 
    //
    // Now release the lock
    //
    This->m_PowerPolicyMachine.m_StateMachineLock.ReleaseLock(
        This->GetDriverGlobals()
        );
}

Referenced by PostCreateDeviceInitialize().

_PowerProcessEventInner()

VOID FxPkgPnp::_PowerProcessEventInner ( __in FxPkgPnp *  This, __in FxPostProcessInfo *  Info, __in PVOID  WorkerContext  )

staticprotected

Definition at line 1309 of file powerstatemachine.cpp.

{
 
    UNREFERENCED_PARAMETER(WorkerContext);
 
    //
    // Take the state machine lock.
    //
    This->m_PowerMachine.m_StateMachineLock.AcquireLock(
        This->GetDriverGlobals()
        );
 
    //
    // Call the function that will actually run the state machine.
    //
    This->PowerProcessEventInner(Info);
 
    //
    // We are being called from the work item and m_WorkItemRunning is > 0, so
    // we cannot be deleted yet.
    //
    ASSERT(Info->SomethingToDo() == FALSE);
 
    //
    // Now release the lock
    //
    This->m_PowerMachine.m_StateMachineLock.ReleaseLock(
        This->GetDriverGlobals()
        );
}

Referenced by PostCreateDeviceInitialize().

_PowerSetSystemWakeSource()

VOID FxPkgPnp::_PowerSetSystemWakeSource ( __in FxIrp *  Irp )

staticprotected

Definition at line 133 of file powerstatemachinekm.cpp.

{
    PoSetSystemWake(Irp->GetIrp());
}

Referenced by PowerMakeWakeRequestNonCancelable().

_PowerThreadEnqueue()

static VOID FxPkgPnp::_PowerThreadEnqueue ( __in PVOID  Context, __in PWORK_QUEUE_ITEM  WorkItem  )

inlinestaticprivate

Definition at line 3944 of file fxpkgpnp.hpp.

    {
        BOOLEAN result;
 
        result = ((FxPkgPnp*) Context)->m_PowerThread->QueueWorkItem(WorkItem);
#if DBG
        ASSERT(result);
#else
        UNREFERENCED_PARAMETER(result);
#endif
    }

Referenced by FxPkgPnp().

_PowerThreadInterfaceDereference()

VOID FxPkgPnp::_PowerThreadInterfaceDereference ( __inout PVOID  Context )

staticprivate

Definition at line 5292 of file fxpkgpnp.cpp.

{
    FxPkgPnp* pThis;
 
    pThis = (FxPkgPnp*) Context;
 
    if (InterlockedDecrement(&pThis->m_PowerThreadInterfaceReferenceCount) == 0) {
        pThis->m_PowerThreadEvent->Set();
    }
}

Referenced by FxPkgPnp().

_PowerThreadInterfaceReference()

VOID FxPkgPnp::_PowerThreadInterfaceReference ( __inout PVOID  Context )

staticprivate

Definition at line 5262 of file fxpkgpnp.cpp.

{
    LONG count;
 
    count = InterlockedIncrement(
        &((FxPkgPnp*) Context)->m_PowerThreadInterfaceReferenceCount
        );
 
#if DBG
    ASSERT(count >= 2);
#else
    UNREFERENCED_PARAMETER(count);
#endif
}

Referenced by FxPkgPnp().

_S0IdleQueryInstance()

NTSTATUS FxPkgPnp::_S0IdleQueryInstance ( __in CfxDevice *  Device, __in FxWmiInstanceInternal *  Instance, __in ULONG  OutBufferSize, __out PVOID  OutBuffer, __out PULONG  BufferUsed  )

staticprotected

Definition at line 3455 of file fxpkgpnp.cpp.

{
    *((BOOLEAN*) OutBuffer) =
        (Device->m_PkgPnp)->m_PowerPolicyMachine.m_Owner->m_IdleSettings.Enabled;
    *BufferUsed = sizeof(BOOLEAN);
 
    return STATUS_SUCCESS;
}

_S0IdleSetInstance()

NTSTATUS FxPkgPnp::_S0IdleSetInstance ( __in CfxDevice *  Device, __in FxWmiInstanceInternal *  Instance, __in ULONG  InBufferSize, __in PVOID  InBuffer  )

staticprotected

Definition at line 3471 of file fxpkgpnp.cpp.

{
    BOOLEAN value;
 
 
    //
    // FxWmiIrpHandler makes sure the buffer is at least one byte big, so we
    // don't check the buffer size.
    //
 
    value = *(PBOOLEAN) InBuffer;
 
    (Device->m_PkgPnp)->PowerPolicySetS0IdleState(value);
 
    return STATUS_SUCCESS;
}

_S0IdleSetItem()

NTSTATUS FxPkgPnp::_S0IdleSetItem ( __in CfxDevice *  Device, __in FxWmiInstanceInternal *  Instance, __in ULONG  DataItemId, __in ULONG  InBufferSize, __in PVOID  InBuffer  )

staticprotected

Definition at line 3494 of file fxpkgpnp.cpp.

{
    BOOLEAN value;
 
    if (DataItemId != 0) {
        return STATUS_INVALID_DEVICE_REQUEST;
    }
 
    if (InBufferSize < sizeof(BOOLEAN)) {
        return STATUS_BUFFER_TOO_SMALL;
    }
 
    value = *(BOOLEAN*) InBuffer;
    (Device->m_PkgPnp)->PowerPolicySetS0IdleState(value);
 
    return STATUS_SUCCESS;
}

_SetPowerCapState()

VOID FxPkgPnp::_SetPowerCapState ( __in ULONG  Index, __in DEVICE_POWER_STATE  State, __out PULONG  Result  )

staticprotected

Definition at line 5616 of file fxpkgpnp.cpp.

{
    //
    // We store off state in 4 bits, starting at the lowest byte
    //
    ASSERT(Index < 8);
 
    //
    // Erase the old value
    //
    *Result &= ~(0xF << (Index * 4));
 
    //
    // Write in the new one
    //
    *Result |= (0xF & State) << (Index * 4);
}

Referenced by FxPkgPnp(), FxPowerPolicyOwnerSettings::FxPowerPolicyOwnerSettings(), QueryForCapabilities(), and SetPowerCaps().

_SpecialTypeToUsage()

static DEVICE_USAGE_NOTIFICATION_TYPE FxPkgPnp::_SpecialTypeToUsage ( __in WDF_SPECIAL_FILE_TYPE  Type )

inlinestaticprotected

Definition at line 3187 of file fxpkgpnp.hpp.

    {
        switch (Type) {
        case WdfSpecialFilePaging:       return DeviceUsageTypePaging;
        case WdfSpecialFileHibernation:  return DeviceUsageTypeHibernation;
        case WdfSpecialFileDump:         return DeviceUsageTypeDumpFile;
        case WdfSpecialFileBoot:         return DeviceUsageTypeBoot;
        default:           ASSERT(FALSE);return DeviceUsageTypePaging;
        }
    }

Referenced by PnpDeviceUsageNotification(), and SetSpecialFileSupport().

_SxWakeQueryInstance()

NTSTATUS FxPkgPnp::_SxWakeQueryInstance ( __in CfxDevice *  Device, __in FxWmiInstanceInternal *  Instaace, __in ULONG  OutBufferSize, __out PVOID  OutBuffer, __out PULONG  BufferUsed  )

staticprotected

Definition at line 3519 of file fxpkgpnp.cpp.

{
    *((BOOLEAN*) OutBuffer) =
        (Device->m_PkgPnp)->m_PowerPolicyMachine.m_Owner->m_WakeSettings.Enabled;
    *BufferUsed = sizeof(BOOLEAN);
 
    return STATUS_SUCCESS;
}

_SxWakeSetInstance()

NTSTATUS FxPkgPnp::_SxWakeSetInstance ( __in CfxDevice *  Device, __in FxWmiInstanceInternal *  Instance, __in ULONG  InBufferSize, __in PVOID  InBuffer  )

staticprotected

Definition at line 3535 of file fxpkgpnp.cpp.

{
    BOOLEAN value;
 
    //
    // FxWmiIrpHandler makes sure that the buffer is at least one byte big, so
    // we don't check the buffer size
    //
    value = *(PBOOLEAN) InBuffer;
 
    (Device->m_PkgPnp)->PowerPolicySetSxWakeState(value);
 
    return STATUS_SUCCESS;
}

_SxWakeSetItem()

NTSTATUS FxPkgPnp::_SxWakeSetItem ( __in CfxDevice *  Device, __in FxWmiInstanceInternal *  Instance, __in ULONG  DataItemId, __in ULONG  InBufferSize, __in PVOID  InBuffer  )

staticprotected

Definition at line 3556 of file fxpkgpnp.cpp.

{
    BOOLEAN value;
 
    if (DataItemId != 0) {
        return STATUS_INVALID_DEVICE_REQUEST;
    }
 
    if (InBufferSize < sizeof(BOOLEAN)) {
        return STATUS_BUFFER_TOO_SMALL;
    }
 
    value = *(BOOLEAN*) InBuffer;
    (Device->m_PkgPnp)->PowerPolicySetSxWakeState(value);
 
    return STATUS_SUCCESS;
}

_UsageToSpecialType()

static WDF_SPECIAL_FILE_TYPE FxPkgPnp::_UsageToSpecialType ( __in DEVICE_USAGE_NOTIFICATION_TYPE  Type )

inlinestaticprotected

Definition at line 3202 of file fxpkgpnp.hpp.

    {
        switch (Type) {
        case DeviceUsageTypePaging:         return WdfSpecialFilePaging;
        case DeviceUsageTypeHibernation:    return WdfSpecialFileHibernation;
        case DeviceUsageTypeDumpFile:       return WdfSpecialFileDump;
        case DeviceUsageTypeBoot:           return WdfSpecialFileBoot;
        default:            ASSERT(FALSE);  return WdfSpecialFilePaging;
        }
    }

Referenced by PnpDeviceUsageNotification().

AckPendingWakeInterruptOperation()

VOID FxPkgPnp::AckPendingWakeInterruptOperation

(

__in BOOLEAN

ProcessPowerEventOnDifferentThread

)

Definition at line 6211 of file fxpkgpnp.cpp.

{
    if (InterlockedDecrement((LONG *)&m_WakeInterruptPendingAckCount) == 0) {
        PowerProcessEvent(
            PowerWakeInterruptCompleteTransition,
            ProcessPowerEventOnDifferentThread
            );
    }
}

AddChildList()

VOID FxPkgPnp::AddChildList

(

__in FxChildList *

List

)

Definition at line 4970 of file fxpkgpnp.cpp.

{
    DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
                        "Adding FxChildList %p, WDFCHILDLIST %p", List,
                        List->GetHandle());
 
    m_EnumInfo->m_ChildListList.Add(GetDriverGlobals(),
                                    &List->m_TransactionLink);
}

Referenced by FxDevice::AddChildList().

AddDmaEnabler()

VOID FxPkgPnp::AddDmaEnabler

(

__in FxDmaEnabler *

Enabler

)

Definition at line 277 of file fxpkgpnpkm.cpp.

{
    DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
                        "Adding DmaEnabler %p, WDFDMAENABLER %p",
                        Enabler, Enabler->GetObjectHandle());
 
    m_DmaEnablerList->Add(GetDriverGlobals(), &Enabler->m_TransactionLink);
}

Referenced by FxDevice::AddDmaEnabler().

AddInterruptObject()

VOID FxPkgPnp::AddInterruptObject ( __in FxInterrupt *  Interrupt )

protected

Definition at line 5928 of file fxpkgpnp.cpp.

{
    m_InterruptObjectCount++;
    InsertTailList(&m_InterruptListHead, &Interrupt->m_PnpList);
}

Referenced by FxInterrupt::Initialize().

AddQueryInterface()

VOID FxPkgPnp::AddQueryInterface	(	__in FxQueryInterface *	QI,
		__in BOOLEAN	Lock
	)

Definition at line 5017 of file fxpkgpnp.cpp.

{
    SINGLE_LIST_ENTRY **ppPrev, *pCur;
 
    if (Lock) {
        m_QueryInterfaceLock.AcquireLock(GetDriverGlobals());
    }
 
    ASSERT(QI->m_Entry.Next == NULL);
 
    //
    // Iterate until we find the end of the list and then append the new
    // structure.  ppPrev is the pointer to the Next pointer value.  When we
    // get to the end, ppPrev will be equal to the Next field which points to NULL.
    //
    ppPrev = &m_QueryInterfaceHead.Next;
    pCur = m_QueryInterfaceHead.Next;
 
    while (pCur != NULL) {
        ppPrev = &pCur->Next;
        pCur = pCur->Next;
    }
 
    *ppPrev = &QI->m_Entry;
 
    if (Lock) {
        m_QueryInterfaceLock.ReleaseLock(GetDriverGlobals());
    }
}

AddRemovalDevice()

_Must_inspect_result_ NTSTATUS FxPkgPnp::AddRemovalDevice

(

__in MdDeviceObject

DependentDevice

)

Definition at line 4753 of file fxpkgpnp.cpp.

{
    FxRelatedDevice* pRelated;
    NTSTATUS status;
 
    if (m_RemovalDeviceList == NULL) {
        KIRQL irql;
 
        Lock(&irql);
        if (m_RemovalDeviceList == NULL) {
            m_RemovalDeviceList = new (GetDriverGlobals()) FxRelatedDeviceList();
 
            if (m_RemovalDeviceList != NULL) {
                status = STATUS_SUCCESS;
            }
            else {
                status = STATUS_INSUFFICIENT_RESOURCES;
 
                DoTraceLevelMessage(
                    GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                    "Could not allocate removal device list for WDFDEVICE %p, "
                    "%!STATUS!", m_Device->GetHandle(), status);
            }
        }
        else {
            //
            // another thread allocated the list already
            //
            status = STATUS_SUCCESS;
        }
        Unlock(irql);
 
        if (!NT_SUCCESS(status)) {
            return status;
        }
    }
 
    pRelated = new(GetDriverGlobals())
        FxRelatedDevice(DependentDevice, GetDriverGlobals());
    if (pRelated == NULL) {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    status = m_RemovalDeviceList->Add(GetDriverGlobals(), pRelated);
 
    if (NT_SUCCESS(status)) {
        //
        // RemovalRelations are queried automatically by PnP when the device is
        // going to be query removed.  No need to tell pnp that the list changed
        // until it needs to query for it.
        //
        DO_NOTHING();
    }
    else {
        pRelated->DeleteFromFailedCreate();
    }
 
    return status;
}

AddUsageDevice()

_Must_inspect_result_ NTSTATUS FxPkgPnp::AddUsageDevice

(

__in MdDeviceObject

DependentDevice

)

Definition at line 4685 of file fxpkgpnp.cpp.

{
    FxRelatedDevice* pRelated;
    NTSTATUS status;
 
    if (m_UsageDependentDeviceList == NULL) {
        KIRQL irql;
 
        Lock(&irql);
        if (m_UsageDependentDeviceList == NULL) {
            m_UsageDependentDeviceList = new (GetDriverGlobals()) FxRelatedDeviceList();
 
            if (m_UsageDependentDeviceList != NULL) {
                status = STATUS_SUCCESS;
            }
            else {
                status = STATUS_INSUFFICIENT_RESOURCES;
 
                DoTraceLevelMessage(
                    GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                    "Could not allocate usage device list for WDFDEVICE %p, "
                    "%!STATUS!", m_Device->GetHandle(), status);
            }
 
        }
        else {
            //
            // another thread allocated the list already
            //
            status = STATUS_SUCCESS;
        }
        Unlock(irql);
 
        if (!NT_SUCCESS(status)) {
            return status;
        }
    }
 
    pRelated = new(GetDriverGlobals())
        FxRelatedDevice(DependentDevice, GetDriverGlobals());
 
    if (pRelated == NULL) {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    status = m_UsageDependentDeviceList->Add(GetDriverGlobals(), pRelated);
 
    if (!NT_SUCCESS(status)) {
        pRelated->DeleteFromFailedCreate();
    }
 
    return status;
}

AdjustUsageCount()

LONG FxPkgPnp::AdjustUsageCount ( __in DEVICE_USAGE_NOTIFICATION_TYPE  Usage, __in BOOLEAN  Add  )

inlineprotected

Definition at line 3147 of file fxpkgpnp.hpp.

    {
        if (Add) {
            return InterlockedIncrement(&m_SpecialFileCount[((ULONG)Usage)-1]);
        }
        else {
            return InterlockedDecrement(&m_SpecialFileCount[((ULONG)Usage)-1]);
        }
    }

Referenced by RevertUsageNotificationFlags(), and SetUsageNotificationFlags().

AllocateDmaEnablerList()

_Must_inspect_result_ NTSTATUS FxPkgPnp::AllocateDmaEnablerList

(

VOID

)

Definition at line 241 of file fxpkgpnpkm.cpp.

{
    FxSpinLockTransactionedList* pList;
    NTSTATUS status;
    KIRQL irql;
 
    if (m_DmaEnablerList != NULL) {
        return STATUS_SUCCESS;
    }
 
    Lock(&irql);
    if (m_DmaEnablerList == NULL) {
        pList = new (GetDriverGlobals()) FxSpinLockTransactionedList();
 
        if (pList != NULL) {
            m_DmaEnablerList = pList;
            status = STATUS_SUCCESS;
        }
        else {
            status = STATUS_INSUFFICIENT_RESOURCES;
        }
    }
    else {
        //
        // Already have a DMA list
        //
        status = STATUS_SUCCESS;
    }
    Unlock(irql);
 
    return status;
}

Referenced by FxDevice::AllocateDmaEnablerList().

AllocateEnumInfo()

_Must_inspect_result_ NTSTATUS FxPkgPnp::AllocateEnumInfo

(

VOID

)

Definition at line 4920 of file fxpkgpnp.cpp.

{
    KIRQL irql;
    NTSTATUS status;
 
    if (m_EnumInfo != NULL) {
        return STATUS_SUCCESS;
    }
 
    Lock(&irql);
    if (m_EnumInfo == NULL) {
        m_EnumInfo = new (GetDriverGlobals()) FxEnumerationInfo(GetDriverGlobals());
 
        if (m_EnumInfo != NULL) {
            status = m_EnumInfo->Initialize();
 
            if (!NT_SUCCESS(status)) {
                delete m_EnumInfo;
                m_EnumInfo = NULL;
 
                DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR,
                                    TRACINGPNP,
                                    "Could not initialize enum info for "
                                    "WDFDEVICE %p, %!STATUS!",
                                    m_Device->GetHandle(), status);
            }
 
        }
        else {
            status = STATUS_INSUFFICIENT_RESOURCES;
 
            DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                                "Could not allocate enum info for WDFDEVICE %p, "
                                "%!STATUS!", m_Device->GetHandle(), status);
        }
    }
    else {
        //
        // another thread allocated the list already
        //
        status = STATUS_SUCCESS;
    }
    Unlock(irql);
 
    return status;
}

Referenced by FxDevice::AllocateEnumInfo(), and FxPkgFdo::Initialize().

AskParentToRemoveAndReenumerate()

virtual NTSTATUS FxPkgPnp::AskParentToRemoveAndReenumerate ( VOID  )

privatepure virtual

Implemented in FxPkgFdo, and FxPkgPdo.

Referenced by SetDeviceFailed().

AssignPowerFrameworkSettings()

NTSTATUS FxPkgPnp::AssignPowerFrameworkSettings

(

__in PWDF_POWER_FRAMEWORK_SETTINGS

PowerFrameworkSettings

)

Definition at line 6243 of file fxpkgpnp.cpp.

{
//     NTSTATUS status;
//     PPO_FX_COMPONENT_IDLE_STATE idleStates = NULL;
//     ULONG idleStatesSize = 0;
//     PPO_FX_COMPONENT component = NULL;
//     ULONG componentSize = 0;
//     PPOX_SETTINGS poxSettings = NULL;
//     ULONG poxSettingsSize = 0;
//     BYTE * buffer = NULL;
 
//     if (FALSE==(IdleTimeoutManagement::_SystemManagedIdleTimeoutAvailable())) {
//         //
//         // If system-managed idle timeout is not available on this OS, then
//         // there is nothing to do.
//         //
//         DoTraceLevelMessage(
//             GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGPNP,
//             "WDFDEVICE %p !devobj %p Power framework is not supported on the "
//             "current OS. Therefore, the power framework settings will not take "
//             "effect.",
//             m_Device->GetHandle(),
//             m_Device->GetDeviceObject()
//             );
//         return STATUS_SUCCESS;
//     }
 
//     if (NULL != PowerFrameworkSettings->Component) {
//         //
//         // Caller should ensure that IdleStateCount is not zero
//         //
//         ASSERT(0 != PowerFrameworkSettings->Component->IdleStateCount);
 
//         //
//         // Compute buffer size needed for storing F-states
//         //
//         status = RtlULongMult(
//                     PowerFrameworkSettings->Component->IdleStateCount,
//                     sizeof(*(PowerFrameworkSettings->Component->IdleStates)),
//                     &idleStatesSize
//                     );
//         if (FALSE == NT_SUCCESS(status)) {
//             DoTraceLevelMessage(
//                 GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
//                 "WDFDEVICE %p !devobj %p Unable to compute length of buffer "
//                 "required to store F-states. RtlULongMult failed with "
//                 "%!STATUS!",
//                 m_Device->GetHandle(),
//                 m_Device->GetDeviceObject(),
//                 status
//                 );
//             goto exit;
//         }
 
//         //
//         // Compute buffer size needed for storing component information
//         // (including F-states)
//         //
//         status = RtlULongAdd(idleStatesSize,
//                              sizeof(*component),
//                              &componentSize);
//         if (FALSE == NT_SUCCESS(status)) {
//             DoTraceLevelMessage(
//                 GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
//                 "WDFDEVICE %p !devobj %p Unable to compute length of buffer "
//                 "required to store driver's component information. RtlULongAdd "
//                 "failed with %!STATUS!",
//                 m_Device->GetHandle(),
//                 m_Device->GetDeviceObject(),
//                 status
//                 );
//             goto exit;
//         }
//     }
 
//     //
//     // Compute total buffer size needed for power framework settings
//     //
//     status = RtlULongAdd(componentSize,
//                          sizeof(*poxSettings),
//                          &poxSettingsSize);
//     if (FALSE == NT_SUCCESS(status)) {
//         DoTraceLevelMessage(
//             GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
//             "WDFDEVICE %p !devobj %p Unable to compute length of buffer "
//             "required to store driver's power framework settings. RtlULongAdd "
//             "failed with %!STATUS!",
//             m_Device->GetHandle(),
//             m_Device->GetDeviceObject(),
//             status
//             );
//         goto exit;
//     }
 
//     //
//     // Allocate memory to copy the settings
//     //
//     buffer = (BYTE *) MxMemory::MxAllocatePoolWithTag(NonPagedPool,
//                                                       poxSettingsSize,
//                                                       GetDriverGlobals()->Tag);
//     if (NULL == buffer) {
//         status = STATUS_INSUFFICIENT_RESOURCES;
//         DoTraceLevelMessage(
//             GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
//             "WDFDEVICE %p !devobj %p Unable to allocate buffer required to "
//             "store F-states. %!STATUS!",
//             m_Device->GetHandle(),
//             m_Device->GetDeviceObject(),
//             status
//             );
//         goto exit;
//     }
 
//     //
//     // Set our pointers to point to appropriate locations in the buffer.
//     //
//     // NOTES:
//     //   - The array of F-states comes first because it has ULONGLONG members
//     //     because of which it has the biggest alignment requirement.
//     //   - The logic below works even if the client driver did not specify any
//     //     component information. In that case idleStatesSize and componentSize
//     //     are both 0 and 'poxSettings' points to the beginning of the allocated
//     //     buffer
//     //
//     idleStates = (PPO_FX_COMPONENT_IDLE_STATE) buffer;
//     component = (PPO_FX_COMPONENT) (buffer + idleStatesSize);
//     poxSettings = (PPOX_SETTINGS) (buffer + componentSize);
 
//     //
//     // Copy the relevant parts of the settings buffer
//     //
//     poxSettings->EvtDeviceWdmPostPoFxRegisterDevice =
//         PowerFrameworkSettings->EvtDeviceWdmPostPoFxRegisterDevice;
//     poxSettings->EvtDeviceWdmPrePoFxUnregisterDevice =
//         PowerFrameworkSettings->EvtDeviceWdmPrePoFxUnregisterDevice;
//     poxSettings->Component = PowerFrameworkSettings->Component;
//     poxSettings->ComponentActiveConditionCallback =
//         PowerFrameworkSettings->ComponentActiveConditionCallback;
//     poxSettings->ComponentIdleConditionCallback =
//         PowerFrameworkSettings->ComponentIdleConditionCallback;
//     poxSettings->ComponentIdleStateCallback =
//         PowerFrameworkSettings->ComponentIdleStateCallback;
//     poxSettings->PowerControlCallback =
//         PowerFrameworkSettings->PowerControlCallback;
//     poxSettings->PoFxDeviceContext = PowerFrameworkSettings->PoFxDeviceContext;
 
//     if (NULL != PowerFrameworkSettings->Component) {
//         //
//         // Copy the component information
//         //
//         poxSettings->Component = component;
//         RtlCopyMemory(poxSettings->Component,
//                       PowerFrameworkSettings->Component,
//                       sizeof(*component));
 
//         //
//         // Caller should ensure that IdleStates is not NULL
//         //
//         ASSERT(NULL != PowerFrameworkSettings->Component->IdleStates);
 
//         //
//         // Copy the F-states
//         //
//         poxSettings->Component->IdleStates = idleStates;
//         RtlCopyMemory(poxSettings->Component->IdleStates,
//                       PowerFrameworkSettings->Component->IdleStates,
//                       idleStatesSize);
//     }
 
//     //
//     // Commit these settings
//     //
//     status = m_PowerPolicyMachine.m_Owner->
//                 m_IdleSettings.m_TimeoutMgmt.CommitPowerFrameworkSettings(
//                                                             GetDriverGlobals(),
//                                                             poxSettings
//                                                             );
//     if (FALSE == NT_SUCCESS(status)) {
//         goto exit;
//     }
 
//     status = STATUS_SUCCESS;
 
// exit:
//     if (FALSE == NT_SUCCESS(status)) {
//         if (NULL != buffer) {
//             MxMemory::MxFreePool(buffer);
//         }
//     }
//     return status;
    ROSWDFNOTIMPLEMENTED;
    return STATUS_SUCCESS;
}

ChildListNotifyRemove()

VOID FxPkgPnp::ChildListNotifyRemove

(

__inout PLONG

PendingCount

)

Definition at line 4999 of file fxpkgpnp.cpp.

{
    FxTransactionedEntry* ple;
 
    ple = NULL;
 
    if (m_EnumInfo != NULL) {
        m_EnumInfo->m_ChildListList.LockForEnum(GetDriverGlobals());
        while ((ple = m_EnumInfo->m_ChildListList.GetNextEntry(ple)) != NULL) {
            FxChildList::_FromEntry(ple)->NotifyDeviceRemove(PendingCount);
        }
        m_EnumInfo->m_ChildListList.UnlockFromEnum(GetDriverGlobals());
    }
}

ChildRemoved()

VOID FxPkgPnp::ChildRemoved ( VOID  )

inline

Definition at line 3415 of file fxpkgpnp.hpp.

    {
        LONG c;
 
        //
        // Called by a child that we are waiting on its removal
        //
        c = InterlockedDecrement(&m_PendingChildCount);
        ASSERT(c >= 0);
 
        if (c == 0) {
            PnpProcessEvent(PnpEventChildrenRemovalComplete);
        }
    }

Referenced by PnpEventFinal().

CleanupDeviceFromFailedCreate()

VOID FxPkgPnp::CleanupDeviceFromFailedCreate

(

__in MxEvent *

WaitEvent

)

Definition at line 2190 of file fxpkgpnp.cpp.

{
    Mx::MxAssert(Mx::MxGetCurrentIrql() == PASSIVE_LEVEL);
 
    //
    // Caller must initialize the event as Synchronization event and it should
    // be passed as non-signalled. But we Clear it just to be sure.
    //
    WaitEvent->Clear();
 
    ADDREF(WaitEvent);
 
    ASSERT(m_DeviceRemoveProcessed == NULL);
    m_DeviceRemoveProcessed = WaitEvent;
 
    //
    // Simulate a remove event coming to the device.  After this call returns
    // m_Device is still valid and must be deleted.
    //
    PnpProcessEvent(PnpEventRemove);
 
    //
    // No need to wait in a critical region because we are in the context of a
    // pnp request which is in the system context.
    //
    WaitEvent->WaitFor(Executive, KernelMode, FALSE, NULL);
    m_DeviceRemoveProcessed = NULL;
 
    RELEASE(WaitEvent);
}

Referenced by FxDevice::DeleteDeviceFromFailedCreateNoDelete().

CleanupStateMachines()

VOID FxPkgPnp::CleanupStateMachines

(

__in BOOLEAN

ClenaupPnp

)

Definition at line 2066 of file fxpkgpnp.cpp.

{
#if (FX_CORE_MODE==FX_CORE_USER_MODE)
    FxCREvent * event = m_CleanupEventUm.GetSelfPointer();
#else
    FxCREvent eventOnStack;
    eventOnStack.Initialize();
    FxCREvent * event = eventOnStack.GetSelfPointer();
#endif
 
    //
    // Order of shutdown is important here.
    // o Pnp initiates events to power policy.
    // o Power policy initiates events to power and device-power-requirement
    // o Power does not initiate any events
    // o Device-power-requirement does not initiate any events
    //
    // By shutting them down in the order in which they send events, we can
    // guarantee that no new events will be posted into the subsidiary state
    // machines.
    //
 
    //
    // This will shut off the pnp state machine and synchronize any outstanding
    // threads of execution.
    //
    if (CleanupPnp && m_PnpMachine.SetFinished(
            event
            ) == FALSE) {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGPNP,
            "WDFDEVICE %p, !devobj %p waiting for pnp state machine to finish",
            m_Device->GetHandle(), m_Device->GetDeviceObject());
 
        //
        // Process the event *before* completing the irp so that this event is in
        // the queue before the device remove event which will be processed
        // right after the start irp has been completed.
        //
        event->EnterCRAndWaitAndLeave();
    }
 
    //
    // Even though event is a SynchronizationEvent, so we need to reset it for
    // the next wait because SetFinished will set it if even if the transition
    // to the finished state is immediate
    //
    event->Clear();
 
    if (m_PowerPolicyMachine.SetFinished(event) == FALSE) {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGPNP,
            "WDFDEVICE %p, !devobj %p waiting for pwr pol state machine to finish",
            m_Device->GetHandle(), m_Device->GetDeviceObject());
 
        event->EnterCRAndWaitAndLeave();
    }
 
    //
    // See previous comment about why we Clear()
    //
    event->Clear();
 
    if (m_PowerMachine.SetFinished(event) == FALSE) {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGPNP,
            "WDFDEVICE %p, !devobj %p waiting for pwr state machine to finish",
            m_Device->GetHandle(), m_Device->GetDeviceObject());
 
        event->EnterCRAndWaitAndLeave();
    }
 
    if (IsPowerPolicyOwner()) {
        //
        // See previous comment about why we Clear()
        //
        event->Clear();
 
        if (NULL != m_PowerPolicyMachine.m_Owner->m_PoxInterface.
                                        m_DevicePowerRequirementMachine) {
 
            if (FALSE == m_PowerPolicyMachine.m_Owner->m_PoxInterface.
                          m_DevicePowerRequirementMachine->SetFinished(event)) {
 
                DoTraceLevelMessage(
                    GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGPNP,
                    "WDFDEVICE %p, !devobj %p waiting for device power "
                    "requirement state machine to finish",
                    m_Device->GetHandle(),
                    m_Device->GetDeviceObject());
 
                event->EnterCRAndWaitAndLeave();
            }
        }
 
        m_PowerPolicyMachine.m_Owner->CleanupPowerCallback();
    }
 
    //
    // Release the power thread if we have one either through creation or query.
    // Since the power policy state machine is off, we should no longer need
    // a dedicated thread.
    //
    // *** NOTE ***
    // The power thread must be released *BEFORE* sending the irp down the stack
    // because this can happen
    // 1)  this driver is not the power thread owner, but the last client
    // 2)  we send the pnp irp first
    // 3)  the power thread owner waits on this thread for all the clients to go
    //     away, but this device still has a reference on it
    // 4)  this device will not release the reference b/c the owner is waiting
    //     in the same thread.
    //
    ReleasePowerThread();
 
    //
    // Deref the reenumeration interface
    //
    ReleaseReenumerationInterface();
}

Referenced by FxDevice::DeleteDeviceFromFailedCreateNoDelete(), ProcessDelayedDeletion(), FxPkgFdo::ProcessRemoveDeviceOverload(), and FxPkgPdo::ProcessRemoveDeviceOverload().

ClearPendingDevicePowerIrp()

MdIrp FxPkgPnp::ClearPendingDevicePowerIrp ( VOID  )

inlineprotected

Definition at line 3069 of file fxpkgpnp.hpp.

    {
        MdIrp irp;
 
        irp = m_PendingDevicePowerIrp;
        m_PendingDevicePowerIrp = NULL;
 
        return irp;
    }

Referenced by FxPkgFdo::PowerReleasePendingDeviceIrp(), and FxPkgPdo::PowerReleasePendingDeviceIrp().

ClearPendingPnpIrp()

MdIrp FxPkgPnp::ClearPendingPnpIrp ( VOID  )

inlineprotected

Definition at line 3029 of file fxpkgpnp.hpp.

    {
        MdIrp irp;
 
        irp = m_PendingPnPIrp;
        m_PendingPnPIrp = NULL;
 
        return irp;
    }

Referenced by FxPkgPdo::_PnpEject(), PnpFinishProcessingIrp(), PnpProcessEventInner(), and FxPkgFdo::PnpSendStartDeviceDownTheStackOverload().

ClearPendingSystemPowerIrp()

MdIrp FxPkgPnp::ClearPendingSystemPowerIrp ( VOID  )

inlineprotected

Definition at line 3092 of file fxpkgpnp.hpp.

    {
        MdIrp irp;
 
        irp = m_PendingSystemPowerIrp;
        m_PendingSystemPowerIrp = NULL;
 
        return irp;
    }

ClearRemovalDevicesList()

VOID FxPkgPnp::ClearRemovalDevicesList

(

VOID

)

Definition at line 4832 of file fxpkgpnp.cpp.

{
    FxRelatedDevice* pEntry;
 
    if (m_RemovalDeviceList == NULL) {
        return;
    }
 
    m_RemovalDeviceList->LockForEnum(GetDriverGlobals());
    while ((pEntry = m_RemovalDeviceList->GetNextEntry(NULL)) != NULL) {
        m_RemovalDeviceList->Remove(GetDriverGlobals(), pEntry->GetDevice());
    }
    m_RemovalDeviceList->UnlockFromEnum(GetDriverGlobals());
 
    //
    // RemovalRelations are queried automatically by PnP when the device is
    // going to be query removed.  No need to tell pnp that the list changed
    // until it needs to query for it.
    //
}

CommitUsageNotification()

VOID FxPkgPnp::CommitUsageNotification ( __in DEVICE_USAGE_NOTIFICATION_TYPE  Type, __in ULONG  OldFlags  )

protected

Definition at line 4614 of file fxpkgpnp.cpp.

{
    PFX_DRIVER_GLOBALS FxDriverGlobals = GetDriverGlobals();
    ULONG newFlags;
 
    newFlags = m_Device->GetDeviceObjectFlags();
 
    if ((OldFlags & DO_POWER_PAGABLE) == DO_POWER_PAGABLE &&
        (newFlags & DO_POWER_PAGABLE) == 0) {
        //
        // We transitioned from a power pageable to a non power pageable
        // device.  Move the power state machine to the appropriate
        // state.
        //
        PowerProcessEvent(PowerMarkNonpageable);
    }
 
    if ((OldFlags & DO_POWER_PAGABLE) == 0 &&
        (newFlags & DO_POWER_PAGABLE) == DO_POWER_PAGABLE) {
        //
        // We transitioned from a non power pageable to a power pageable
        // device.  Move the power state machine to the appropriate
        // state.
        //
        PowerProcessEvent(PowerMarkPageable);
    }
 
    //
    // Notify PNP that it should no longer be able
    // to disable this device.
    //
    MxDeviceObject physicalDeviceObject(
                                m_Device->GetPhysicalDevice()
                                );
    physicalDeviceObject.InvalidateDeviceState(
        m_Device->GetDeviceObject()
        );
 
    DoTraceLevelMessage(
        FxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGPNP,
        "After:  special count %d, flags 0x%x, device %p (WDFDEVICE %p)",
        GetUsageCount(Type), newFlags,
        m_Device->GetDeviceObject(), m_Device->GetHandle());
}

Referenced by PnpDeviceUsageNotification().

CompletePnpRequest()

NTSTATUS FxPkgPnp::CompletePnpRequest ( __inout FxIrp *  Irp, __in NTSTATUS  Status  )

protected

Definition at line 5752 of file fxpkgpnp.cpp.

{
    MdIrp pIrp = Irp->GetIrp();
 
    Irp->SetStatus(Status);
    Irp->CompleteRequest(IO_NO_INCREMENT);
 
    Mx::MxReleaseRemoveLock(m_Device->GetRemoveLock(),
                            pIrp);
 
    return Status;
}

Referenced by FxPkgPdo::_PnpEject(), FxPkgPdo::_PnpFilterResourceRequirements(), FxPkgPdo::_PnpQueryBusInformation(), FxPkgPdo::_PnpQueryDeviceText(), FxPkgFdo::_PnpQueryInterface(), FxPkgPdo::_PnpQueryInterface(), FxPkgFdo::_PnpQueryPnpDeviceState(), FxPkgPdo::_PnpSetLock(), FxPkgFdo::_PnpStartDeviceCompletionRoutine(), FxPkgPdo::_QueryCapsWorkItem(), FxPkgPdo::FireAndForgetIrp(), PnpDeviceUsageNotification(), FxPkgFdo::PnpFilterResourceRequirements(), PnpFinishProcessingIrp(), FxPkgFdo::PnpQueryCapabilities(), FxPkgPdo::PnpQueryCapabilities(), FxPkgFdo::PnpQueryDeviceRelations(), FxPkgPdo::PnpQueryDeviceRelations(), FxPkgPdo::PnpQueryResourceRequirements(), FxPkgPdo::PnpQueryResources(), FxPkgFdo::PnpSendStartDeviceDownTheStackOverload(), and FxPkgPdo::ProcessRemoveDeviceOverload().

CompletePowerRequest()

NTSTATUS FxPkgPnp::CompletePowerRequest ( __inout FxIrp *  Irp, __in NTSTATUS  Status  )

protected

Definition at line 5404 of file fxpkgpnp.cpp.

{
    MdIrp irp;
 
    //
    // Once we call CompleteRequest, 2 things happen
    // 1) this object may go away
    // 2) Irp->m_Irp will be cleared
    //
    // As such, we capture the underlying WDM objects so that we can use them
    // to release the remove lock and use the PIRP *value* as a tag to release
    // the remlock.
    //
    irp = Irp->GetIrp();
 
    Irp->SetStatus(Status);
    Irp->StartNextPowerIrp();
    Irp->CompleteRequest(IO_NO_INCREMENT);
 
    Mx::MxReleaseRemoveLock(m_Device->GetRemoveLock(),
                            irp);
 
    return Status;
}

Referenced by FxPkgPdo::_DispatchQueryPower(), FxPkgFdo::DispatchSystemQueryPower(), FxPkgPdo::DispatchSystemSetPower(), DispatchWaitWake(), FxPkgPdo::FireAndForgetIrp(), PowerCompletePendedWakeIrp(), PowerPolicyCancelWaitWake(), PowerPolicyCompleteSystemPowerIrp(), FxPkgFdo::PowerReleasePendingDeviceIrp(), and FxPkgPdo::PowerReleasePendingDeviceIrp().

CreatePowerThread()

_Must_inspect_result_ NTSTATUS FxPkgPnp::CreatePowerThread ( VOID  )

protected

Definition at line 5125 of file fxpkgpnp.cpp.

{
    FxSystemThread *pThread, *pOld;
    NTSTATUS status;
 
    status = FxSystemThread::_CreateAndInit(
                &pThread,
                GetDriverGlobals(),
                m_Device->GetHandle(),
                m_Device->GetDeviceObject());
 
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    //
    // Simple locking logic in case N requests are conncurrent.  (The requests
    // never should be concurrent, but in the case that there are 2 usage
    // notifications coming in from two different sources, it could
    // theoritically happen.)
    //
    pOld = (FxSystemThread*) InterlockedCompareExchangePointer(
        (PVOID*) &m_PowerThread, pThread, NULL);
 
    if (pOld != NULL) {
        //
        // Someone also set the thread pointer value at the same time, free
        // our new one here.
        //
        pThread->ExitThread();
        pThread->DeleteObject();
    }
 
    m_HasPowerThread = TRUE;
 
    return STATUS_SUCCESS;
}

Referenced by FxPkgFdo::QueryForPowerThread(), and FxPkgPdo::QueryForPowerThread().

CreatePowerThreadIfNeeded()

_Must_inspect_result_ NTSTATUS FxPkgPnp::CreatePowerThreadIfNeeded ( VOID  )

private

Definition at line 158 of file pnpstatemachinekm.cpp.

{
    NTSTATUS status = STATUS_SUCCESS;
    MxDeviceObject pTopOfStack;
 
 
 
 
 
 
 
 
 
 
 
 
    pTopOfStack.SetObject(
        m_Device->GetAttachedDeviceReference());
 
    ASSERT(pTopOfStack.GetObject() != NULL);
 
    if (pTopOfStack.GetObject() != NULL) {
        //
        // If the top of the stack is not power pageable, the stack needs a power
        // thread.  Query for it if we are not a PDO (and create it if the lower
        // stack does not support it), and create it if we are a PDO.
        //
        // Some stacks send a usage notification when processing a start device, so
        // a notification could have already traveled through the stack by the time
        // the start irp has completed back up to this device.
        //
        if ((pTopOfStack.GetFlags() & DO_POWER_PAGABLE) == 0 &&
            HasPowerThread() == FALSE) {
            status = QueryForPowerThread();
 
            if (!NT_SUCCESS(status)) {
                SetInternalFailure();
                SetPendingPnpIrpStatus(status);
            }
        }
 
        pTopOfStack.DereferenceObject();
        pTopOfStack.SetObject(NULL);
    }
 
    return status;
}

DeleteDevice()

VOID FxPkgPnp::DeleteDevice ( VOID  )

protected

Definition at line 2249 of file fxpkgpnp.cpp.

{
    //
    // This will detach and delete the device object
    //
    m_Device->Destroy();
 
    //
    // If this is the last reference, this will free the memory for the device
    //
    m_Device->DeleteObject();
}

Referenced by ProcessDelayedDeletion(), FxPkgFdo::ProcessRemoveDeviceOverload(), and FxPkgPdo::ProcessRemoveDeviceOverload().

DeleteSymbolicLinkOverload()

virtual VOID FxPkgPnp::DeleteSymbolicLinkOverload ( BOOLEAN  GracefulRemove )

privatepure virtual

Referenced by PnpCleanupForRemove().

DisconnectInterruptNP()

VOID FxPkgPnp::DisconnectInterruptNP ( VOID  )

private

Definition at line 4758 of file powerstatemachine.cpp.

{
    //
    // NotifyResourceObjectsDx will call IoDisconnectInterrupt.  Since we
    // are in the NP path, this may cause a deadlock between this thread and
    // paging I/O.  Log something to the IFR so that if the watchdog timer kicks
    // in, at least we have context as to why we died.
    //
    DoTraceLevelMessage(
        GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
        "Force disconnecting interrupts on !devobj 0x%p, WDFDEVICE %p",
        m_Device->GetDeviceObject(),
        m_Device->GetHandle());
 
    //
    // NotifyResourceObjectsDx will log any errors
    //
    (void) NotifyResourceObjectsDx(NotifyResourcesForceDisconnect);
}

Dispatch()

_Must_inspect_result_ NTSTATUS FxPkgPnp::Dispatch ( __in MdIrp  Irp )

protectedvirtual

Implements FxPackage.

Definition at line 520 of file fxpkgpnp.cpp.

{
    NTSTATUS status;
    FxIrp irp(Irp);
 
#if (FX_CORE_MODE==FX_CORE_KERNEL_MODE)
    FX_TRACK_DRIVER(GetDriverGlobals());
#endif
 
    if (irp.GetMajorFunction() == IRP_MJ_PNP) {
 
        switch (irp.GetMinorFunction()) {
        case IRP_MN_START_DEVICE:
        case IRP_MN_QUERY_REMOVE_DEVICE:
        case IRP_MN_REMOVE_DEVICE:
        case IRP_MN_CANCEL_REMOVE_DEVICE:
        case IRP_MN_STOP_DEVICE:
        case IRP_MN_QUERY_STOP_DEVICE:
        case IRP_MN_CANCEL_STOP_DEVICE:
        case IRP_MN_SURPRISE_REMOVAL:
        case IRP_MN_EJECT:
        case IRP_MN_QUERY_PNP_DEVICE_STATE:
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGPNP,
                "WDFDEVICE 0x%p !devobj 0x%p, IRP_MJ_PNP, %!pnpmn! IRP 0x%p",
                m_Device->GetHandle(),
                m_Device->GetDeviceObject(),
                irp.GetMinorFunction(), irp.GetIrp());
            break;
 
        case IRP_MN_QUERY_DEVICE_RELATIONS:
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGPNP,
                "WDFDEVICE 0x%p !devobj 0x%p, IRP_MJ_PNP, %!pnpmn! "
                "type %!DEVICE_RELATION_TYPE! IRP 0x%p",
                m_Device->GetHandle(),
                m_Device->GetDeviceObject(),
                irp.GetMinorFunction(),
                irp.GetParameterQDRType(), irp.GetIrp());
            break;
 
        default:
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
                "WDFDEVICE 0x%p !devobj 0x%p, IRP_MJ_PNP, %!pnpmn! IRP 0x%p",
                m_Device->GetHandle(),
                m_Device->GetDeviceObject(),
                irp.GetMinorFunction(), irp.GetIrp());
            break;
        }
 
        if (irp.GetMinorFunction() <= IRP_MN_SURPRISE_REMOVAL) {
            status = (*GetDispatchPnp()[irp.GetMinorFunction()])(this, &irp);
        }
        else {
            //
            // For Pnp IRPs we don't understand, just forget about them
            //
            status = FireAndForgetIrp(&irp);
        }
    }
    else {
        //
        // If this isn't a PnP Irp, it must be a power irp.
        //
        switch (irp.GetMinorFunction()) {
        case IRP_MN_WAIT_WAKE:
        case IRP_MN_SET_POWER:
            if (irp.GetParameterPowerType() == SystemPowerState) {
                DoTraceLevelMessage(
                    GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGPNP,
                    "WDFDEVICE 0x%p !devobj 0x%p IRP_MJ_POWER, %!pwrmn! "
                    "IRP 0x%p for %!SYSTEM_POWER_STATE! (S%d)",
                    m_Device->GetHandle(),
                    m_Device->GetDeviceObject(),
                    irp.GetMinorFunction(), irp.GetIrp(),
                    irp.GetParameterPowerStateSystemState(),
                    irp.GetParameterPowerStateSystemState() - 1);
            }
            else {
                DoTraceLevelMessage(
                    GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGPNP,
                    "WDFDEVICE 0x%p !devobj 0x%p IRP_MJ_POWER, %!pwrmn! "
                    "IRP 0x%p for %!DEVICE_POWER_STATE!",
                    m_Device->GetHandle(),
                    m_Device->GetDeviceObject(),
                    irp.GetMinorFunction(), irp.GetIrp(),
                    irp.GetParameterPowerStateDeviceState());
            }
            break;
 
        default:
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
                "WDFDEVICE 0x%p !devobj 0x%p IRP_MJ_POWER, %!pwrmn! IRP 0x%p",
                m_Device->GetHandle(),
                m_Device->GetDeviceObject(),
                irp.GetMinorFunction(), irp.GetIrp());
            break;
        }
 
        Mx::MxAssert(irp.GetMajorFunction() == IRP_MJ_POWER);
 
        if (irp.GetMinorFunction() <= IRP_MN_QUERY_POWER) {
            status = (*GetDispatchPower()[irp.GetMinorFunction()])(this, &irp);
        }
        else {
            //
            // For Power IRPs we don't understand, just forget about them
            //
            status = FireAndForgetIrp(&irp);
        }
    }
 
    return status;
}

DispatchWaitWake()

_Must_inspect_result_ NTSTATUS FxPkgPnp::DispatchWaitWake ( __inout FxIrp *  Irp )

protected

Definition at line 2431 of file fxpkgpnp.cpp.

{
    PFX_DRIVER_GLOBALS FxDriverGlobals = GetDriverGlobals();
    NTSTATUS status;
    PIRP oldIrp;
    KIRQL irql;
 
    if (IsPowerPolicyOwner()) {
        if (m_PowerPolicyMachine.m_Owner->m_RequestedWaitWakeIrp == FALSE) {
            //
            // A power irp arrived, but we did not request it.  log and bugcheck
            //
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                "Received wait wake power irp %p on device %p, but the irp was "
                "not requested by the device (the power policy owner)",
                Irp->GetIrp(), m_Device->GetDeviceObject());
 
            FxVerifierBugCheck(GetDriverGlobals(),  // globals
                   WDF_POWER_MULTIPLE_PPO, // specific type
                   (ULONG_PTR)m_Device->GetDeviceObject(), //parm 2
                   (ULONG_PTR)Irp->GetIrp());  // parm 3
 
            /* NOTREACHED */
        }
 
        //
        // We are no longer requesting a power irp because we received the one
        // we requested.
        //
        m_PowerPolicyMachine.m_Owner->m_RequestedWaitWakeIrp = FALSE;
    }
 
    //
    // The Framework has the concept of a "Wait/Wake Owner."  This is the layer
    // in the stack that is enabling and disabling wake at the bus level.  This
    // is probably the PDO or a bus filter like ACPI.sys.  This is distinct
    // from being the "Power Policy Owner," which would mean that this driver
    // is deciding what D-state is appropriate for the device, and also
    // sending Wait/Wake IRPs.
    //
 
    if (m_SharedPower.m_WaitWakeOwner) {
        m_PowerMachine.m_WaitWakeLock.Acquire(&irql);
 
        if (m_SharedPower.m_WaitWakeIrp != NULL) {
            //
            // We only allow one pended wait wake irp in the stack at a time.
            // Fail this secondary wait wake request.
            //
            status = STATUS_INVALID_DEVICE_STATE;
 
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                "Failing wait wake irp %p with %!STATUS! because wait wake irp "
                "%p already pended",
                Irp->GetIrp(), status, m_SharedPower.m_WaitWakeIrp);
        }
        else {
            MdCancelRoutine pRoutine;
 
            //
            // No wait wake irp is currently in the stack, so attempt to set
            // a cancel routine and transition the power state machine into a
            // a state where it can arm the device at the bus level for this
            // child.
            //
            // The power state machine expects the wait wake irp to have a cancel
            // routine set in all states.  For those states which require a
            // non cancelable irp, those states clear the cancel routine as
            // appropriate.
            //
            pRoutine = Irp->SetCancelRoutine(_PowerWaitWakeCancelRoutine);
#if DBG
            ASSERT(pRoutine == NULL);
#else
            UNREFERENCED_PARAMETER(pRoutine);
#endif
            status = STATUS_PENDING;
 
            if (Irp->IsCanceled()) {
                DoTraceLevelMessage(GetDriverGlobals(),
                                    TRACE_LEVEL_ERROR, TRACINGPNP,
                                    "wait wake irp %p already canceled", Irp->GetIrp());
 
                //
                // This IRP has already been cancelled, we must clear the cancel
                // routine before completing the IRP.
                //
                pRoutine = Irp->SetCancelRoutine(NULL);
 
                if (pRoutine != NULL) {
                    //
                    // Our cancel routine will not be called
                    //
#if DBG
                    ASSERT(pRoutine == _PowerWaitWakeCancelRoutine);
#else
                    UNREFERENCED_PARAMETER(pRoutine);
#endif
                    Irp->SetStatus(STATUS_CANCELLED);
                    status = STATUS_CANCELLED;
                }
            }
 
            if (status == STATUS_PENDING) {
                //
                // Either we successfully set the cancel routine or the irp
                // was canceled and the cancel routine is about to run when
                // we drop the lock.  If the routine is about to run, we still
                // need to setup m_SharedPower to values that it expects.
                //
                Irp->MarkIrpPending();
                m_SharedPower.m_WaitWakeIrp = Irp->GetIrp();
            }
        }
        m_PowerMachine.m_WaitWakeLock.Release(irql);
 
        if (NT_SUCCESS(status)) {
            //
            // Post to the appropriate matchines
            //
            PowerProcessEvent(PowerWakeArrival);
 
            if (IsPowerPolicyOwner()) {
                PowerPolicyProcessEvent(PwrPolWakeArrived);
            }
        }
        else {
            CompletePowerRequest(Irp, status);
        }
 
        return status;
    }
    else if (IsPowerPolicyOwner()) {
        //
        // Try to set m_WaitWakeIrp to the new IRP value only if the current
        // value of m_WaitWakeIrp is NULL because there can only be one
        // active wait wake irp in the stack at a time.  Since the power policy
        // state machine never sends more then one, this is really a guard
        // against some other device in the stack sending a wait wake irp to
        // this device in the wrong state.
        //
        oldIrp = (PIRP) InterlockedCompareExchangePointer(
            (PVOID*) &m_SharedPower.m_WaitWakeIrp,
            Irp->GetIrp(),
            NULL
            );
 
        //
        // If oldIrp is NULL then there was no previous irp and we successfully
        // exchanged the new PIRP value into m_WaitWakeIrp
        //
        if (oldIrp == NULL) {
            m_PowerPolicyMachine.SetWaitWakeUnclaimed();
 
            //
            // NOTE:  There is a built in race condition here that WDF cannot
            //        solve with the given WDM primitives.  After arming the
            //        device for wake, there is a window where the wait wake irp
            //        has not yet been processed by the wait wake owner.  Until
            //        the wake request is processed, wake events could be generated
            //        and lost.  There is nothing we can do about this until we
            //        have synchronous "goto Dx and arm" command available.
            //
            Irp->CopyCurrentIrpStackLocationToNext();
            Irp->SetCompletionRoutineEx(m_Device->GetDeviceObject(),
                                        _PowerPolicyWaitWakeCompletionRoutine,
                                        this);
 
            //
            // Technically, there should be a PDO vs FDO overload here which
            // does the right thing w/regard to this request and if it is at the
            // bottom of the stack or not.  But, by design, we check for
            // m_WaitWakeOwner first which has the direct side affect of making
            // it impossible for a PDO to get to this point.
            //
            ASSERT(m_Device->IsFdo());
 
            status = Irp->PoCallDriver(m_Device->GetAttachedDevice());
 
            //
            // Send the wake arrived after sending the request as commented above.
            // This window between sending the request and sending the event to
            // the state machine allows the wait owner to complete the request
            // immediately.   When completed synchronously, it has an effect on
            //  both wake scenarios:
            //
            // 1) wake from S0:  the device never transitions to Dx and the idle
            //                   timer is resumed if no i/o is present
            //
            // 2) wake from sx:  the device is disarmed for wake from Sx and
            //                   put into Dx with being armed for wake.
            //
            PowerPolicyProcessEvent(PwrPolWakeArrived);
        }
        else {
            status = STATUS_POWER_STATE_INVALID;
 
            DoTraceLevelMessage(
                FxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGPNP,
                "already have a ww irp %p, failing new ww irp %p with %!STATUS!",
                oldIrp, Irp->GetIrp(), status);
 
            CompletePowerRequest(Irp, status);
        }
    }
    else {
        //
        // Not the power policy owner, not the wait wake irp owner, ignore the
        // irp
        //
        // This will release the remove lock.
        //
        status = FireAndForgetIrp(Irp);
    }
 
    return status;
}

Dispose()

BOOLEAN FxPkgPnp::Dispose ( VOID  )

protectedvirtual

Reimplemented from FxObject.

Definition at line 284 of file fxpkgpnp.cpp.

{
    PSINGLE_LIST_ENTRY ple;
 
    //
    // All of the interrupts were freed during this object's dispose path.  This
    // is because all of the interrupts were attached as children to this object.
    //
    // It is safe to just reinitialize the list head.
    //
    InitializeListHead(&m_InterruptListHead);
 
    m_QueryInterfaceLock.AcquireLock(GetDriverGlobals());
 
    //
    // A derived class can insert an embedded FxQueryInterface into the QI list,
    // so clear out the list before the destructor chain runs.  (The derived
    // class will be destructed first, as such, the embedded FxQueryInterface
    // will also destruct first and complain it is still in a list.
    //
    ple = m_QueryInterfaceHead.Next;
 
    //
    // Clear out the head while holding the lock so that we synchronize against
    // processing a QI while deleting the list.
    //
    m_QueryInterfaceHead.Next = NULL;
 
    m_QueryInterfaceLock.ReleaseLock(GetDriverGlobals());
 
    while (ple != NULL) {
        FxQueryInterface* pQI;
 
        pQI = FxQueryInterface::_FromEntry(ple);
 
        //
        // Advance before we potentiall free the structure
        //
        ple = ple->Next;
 
        //
        // FxQueryInterface's destructor requires Next be NULL
        //
        pQI->m_Entry.Next = NULL;
 
        if (pQI->m_EmbeddedInterface == FALSE) {
            delete pQI;
        }
    }
 
#if (FX_CORE_MODE==FX_CORE_KERNEL_MODE)
    DropD3ColdInterface();
#endif
 
    //
    // Call up the hierarchy
    //
    return FxPackage::Dispose(); // __super call
}

DropD3ColdInterface()

VOID FxPkgPnp::DropD3ColdInterface

(

VOID

)

Definition at line 615 of file fxpkgpnpkm.cpp.

{
    if (m_D3ColdInterface.InterfaceDereference != NULL) {
        m_D3ColdInterface.InterfaceDereference(m_D3ColdInterface.Context);
    }
 
    RtlZeroMemory(&m_D3ColdInterface, sizeof(m_D3ColdInterface));
}

Referenced by Dispose().

FilterResourceRequirements()

NTSTATUS FxPkgPnp::FilterResourceRequirements ( __in IO_RESOURCE_REQUIREMENTS_LIST **  IoList )

protected

Definition at line 16 of file fxpkgpnpkm.cpp.

{
    ULONG altResListIndex;
    PIO_RESOURCE_REQUIREMENTS_LIST pIoRequirementList;
    PIO_RESOURCE_LIST pIoResList;
 
    pIoRequirementList = *IoList;
 
    if (pIoRequirementList == NULL) {
        return STATUS_SUCCESS;
    }
 
    if (IsListEmpty(&m_InterruptListHead)) {
        //
        // No interrupt objects created to filter resource requirements.
        //
        return STATUS_SUCCESS;
    }
 
    pIoResList = pIoRequirementList->List;
 
    //
    // Parse one or more alternative resource lists.
    //
    for (altResListIndex = 0;
         altResListIndex < pIoRequirementList->AlternativeLists;
         altResListIndex++) {
        PLIST_ENTRY pIntListEntryForMSI;
        PLIST_ENTRY pIntListEntryForLBI;
        BOOLEAN multiMessageMSI22Found;
        BOOLEAN previousDescMSI;
        ULONG descIndex;
 
        multiMessageMSI22Found = FALSE;
        previousDescMSI = FALSE;
 
        pIntListEntryForMSI = &m_InterruptListHead;
        pIntListEntryForLBI = &m_InterruptListHead;
 
        //
        // Traverse each _IO_RESOURCE_LISTs looking for interrupt descriptors
        // and call FilterResourceRequirements method so that it can apply
        // policy set on the interrupt object into the resource-descriptor.
        //
 
        for (descIndex = 0; descIndex < pIoResList->Count; descIndex++) {
            ULONG messageCount;
            PIO_RESOURCE_DESCRIPTOR pIoDesc;
            FxInterrupt* pInterruptInstance;
 
            pIoDesc = &pIoResList->Descriptors[descIndex];
 
            switch (pIoDesc->Type) {
            case CmResourceTypeInterrupt:
 
                if (FxInterrupt::_IsMessageInterrupt(pIoDesc->Flags)) {
 
                    previousDescMSI = TRUE;
 
                    //
                    // We will advance to the next interrupt object if the resource
                    // is not an alternate resource descriptor. A resource list can
                    // have a preferred and zero or more alternate resource descriptors
                    // for the same resource. We need to apply the same policy on the
                    // alternate desc that we applied on the preferred one in case one
                    // of the alernate desc is selected for this device. An alternate
                    // resource descriptor can't be the first descriptor in a list.
                    //
                    if ((pIoDesc->Option & IO_RESOURCE_ALTERNATIVE) == 0) {
                        pIntListEntryForMSI = pIntListEntryForMSI->Flink;
                    }
 
                    if (pIntListEntryForMSI == &m_InterruptListHead) {
                        DoTraceLevelMessage(
                            GetDriverGlobals(), TRACE_LEVEL_WARNING, TRACINGPNP,
                            "Not enough interrupt objects created for MSI by WDFDEVICE 0x%p ",
                            m_Device->GetHandle());
                        break;
                    }
 
                    pInterruptInstance = CONTAINING_RECORD(pIntListEntryForMSI, FxInterrupt, m_PnpList);
                    messageCount = pIoDesc->u.Interrupt.MaximumVector - pIoDesc->u.Interrupt.MinimumVector + 1;
 
                    if (messageCount > 1) {
                        //
                        //  PCI spec guarantees that there can be only one preferred/default
                        //  MSI 2.2 descriptor in a single list.
                        //
                        if ((pIoDesc->Option & IO_RESOURCE_ALTERNATIVE) == 0) {
#if DBG
                            ASSERT(multiMessageMSI22Found == FALSE);
#else
                            UNREFERENCED_PARAMETER(multiMessageMSI22Found);
#endif
                            multiMessageMSI22Found = TRUE;
 
                        }
                    }
                    else {
                        //
                        //  This is either single message MSI 2.2 or MSI-X interrupts
                        //
                        DO_NOTHING();
                    }
 
                    pInterruptInstance->FilterResourceRequirements(pIoDesc);
                }
                else {
 
                    //
                    // We will advance to next interrupt object if the desc is not an alternate
                    // descriptor. For non PCI devices, the first LBI interrupt desc can't be an
                    // alternate descriptor.
                    //
                    if ((pIoDesc->Option & IO_RESOURCE_ALTERNATIVE) == 0) {
                        pIntListEntryForLBI = pIntListEntryForLBI->Flink;
                    }
 
                    //
                    // An LBI can be first alternate resource if there are preceding MSI(X) descriptors
                    // listed in the list. In that case, this descriptor is the alternate interrupt resource
                    // for all of the MSI messages. As a result, we will use the first interrupt object from
                    // the list if this ends up being assigned by the system instead of MSI.
                    //
                    if (previousDescMSI) {
                        ASSERT(pIoDesc->Option & IO_RESOURCE_ALTERNATIVE);
                        pIntListEntryForLBI = m_InterruptListHead.Flink;
                        previousDescMSI = FALSE;
                    }
 
                    //
                    // There can be one or more LBI interrupts and each LBI interrupt
                    // could have zero or more alternate descriptors.
                    //
                    if (pIntListEntryForLBI == &m_InterruptListHead) {
                        DoTraceLevelMessage(
                            GetDriverGlobals(), TRACE_LEVEL_WARNING, TRACINGPNP,
                            "Not enough interrupt objects created for LBI by WDFDEVICE 0x%p ",
                            m_Device->GetHandle());
                        break;
                    }
 
                    pInterruptInstance = CONTAINING_RECORD(pIntListEntryForLBI, FxInterrupt, m_PnpList);
 
                    pInterruptInstance->FilterResourceRequirements(pIoDesc);
                }
 
                break;
 
            default:
                break;
            }
        }
 
        //
        // Since the Descriptors is a variable length list, you cannot get to the next
        // alternate list by doing pIoRequirementList->List[altResListIndex].
        // Descriptors[descIndex] will now point to the end of the descriptor list.
        // If there is another alternate list, it would be begin there.
        //
        pIoResList = (PIO_RESOURCE_LIST) &pIoResList->Descriptors[descIndex];
    }
 
    return STATUS_SUCCESS;
}

Referenced by FxPkgFdo::PnpFilterResourceRequirements().

FinishInitialize()

VOID FxPkgPnp::FinishInitialize ( __inout PWDFDEVICE_INIT  DeviceInit )

virtual

Definition at line 1240 of file fxpkgpnp.cpp.

{
    //
    // Reassign the state callback arrays away from the init struct.
    // Set the init field to NULL so that it does not attempt to free the array
    // when it is destroyed.
    //
    m_PnpStateCallbacks = DeviceInit->PnpPower.PnpStateCallbacks;
    DeviceInit->PnpPower.PnpStateCallbacks = NULL;
 
    m_PowerStateCallbacks = DeviceInit->PnpPower.PowerStateCallbacks;
    DeviceInit->PnpPower.PowerStateCallbacks = NULL;
 
    m_PowerPolicyStateCallbacks = DeviceInit->PnpPower.PowerPolicyStateCallbacks;
    DeviceInit->PnpPower.PowerPolicyStateCallbacks = NULL;
 
    //
    // Bias the count towards one so that we can optimize the synchronous
    // cleanup case when the device is being destroyed.
    //
    m_PendingChildCount = 1;
 
    //
    // Now "Add" this device in the terms that the PnP state machine uses.  This
    // will be in the context of an actual AddDevice function for FDOs, and
    // something very much like it for PDOs.
    //
    // Important that the posting of the event is after setting of the state
    // callback arrays so that we can guarantee that any state transition
    // callback will be made.
    //
    PnpProcessEvent(PnpEventAddDevice);
}

Referenced by FxDevice::_Create(), and FxPkgPdo::FinishInitialize().

FireAndForgetIrp()

virtual NTSTATUS FxPkgPnp::FireAndForgetIrp ( FxIrp *  Irp )

pure virtual

Referenced by Dispatch(), and DispatchWaitWake().

GetDispatchPnp()

virtual const PFN_PNP_POWER_CALLBACK * FxPkgPnp::GetDispatchPnp ( VOID  )

protectedpure virtual

Implemented in FxPkgFdo, and FxPkgPdo.

Referenced by Dispatch().

GetDispatchPower()

virtual const PFN_PNP_POWER_CALLBACK * FxPkgPnp::GetDispatchPower ( VOID  )

protectedpure virtual

Implemented in FxPkgFdo, and FxPkgPdo.

Referenced by Dispatch().

GetInterruptObjectCount()

ULONG FxPkgPnp::GetInterruptObjectCount ( VOID  )

inline

Definition at line 3812 of file fxpkgpnp.hpp.

    {
        return m_InterruptObjectCount;
    }

GetNotPowerPolicyOwnerTableEntry()

static _Must_inspect_result_ CPNOT_POWER_POLICY_OWNER_STATE_TABLE FxPkgPnp::GetNotPowerPolicyOwnerTableEntry ( __in WDF_DEVICE_POWER_POLICY_STATE  State )

inlinestaticprotected

Definition at line 2928 of file fxpkgpnp.hpp.

    {
        ULONG i;
 
        for (i = 0;
             m_WdfNotPowerPolicyOwnerStates[i].CurrentTargetState != WdfDevStatePwrPolNull;
             i++) {
            if (m_WdfNotPowerPolicyOwnerStates[i].CurrentTargetState == State) {
                return &m_WdfNotPowerPolicyOwnerStates[i];
            }
        }
 
        return NULL;
    }

Referenced by NotPowerPolicyOwnerEnterNewState(), and PowerPolicyProcessEventInner().

GetPendingPnpIrp()

MdIrp FxPkgPnp::GetPendingPnpIrp ( VOID  )

inlineprotected

Definition at line 3042 of file fxpkgpnp.hpp.

    {
        return m_PendingPnPIrp;
    }

Referenced by PnpFinishProcessingIrp().

GetPendingSystemPowerIrp()

MdIrp FxPkgPnp::GetPendingSystemPowerIrp ( VOID  )

inlineprotected

Definition at line 3105 of file fxpkgpnp.hpp.

    {
        return m_PendingSystemPowerIrp;
    }

GetPnpCapsInternal()

LONG FxPkgPnp::GetPnpCapsInternal ( VOID  )

protected

Definition at line 5466 of file fxpkgpnp.cpp.

{
    LONG caps;
    KIRQL irql;
 
    Lock(&irql);
    caps = m_PnpStateAndCaps.Value & FxPnpCapMask;
    Unlock(irql);
 
    return caps;
}

Referenced by FxPkgFdo::HandleQueryCapabilities(), FxPkgPdo::HandleQueryCapabilities(), FxPkgFdo::HandleQueryCapabilitiesCompletion(), and HandleQueryPnpDeviceState().

GetPnpState()

VOID FxPkgPnp::GetPnpState

(

__out PWDF_DEVICE_STATE

State

)

Definition at line 5549 of file fxpkgpnp.cpp.

{
    LONG state;
 
    state = GetPnpStateInternal();
 
    SET_TRI_STATE_FROM_STATE_BITS(state, State, Disabled);
    SET_TRI_STATE_FROM_STATE_BITS(state, State, DontDisplayInUI);
    SET_TRI_STATE_FROM_STATE_BITS(state, State, Failed);
    SET_TRI_STATE_FROM_STATE_BITS(state, State, NotDisableable);
    SET_TRI_STATE_FROM_STATE_BITS(state, State, Removed);
    SET_TRI_STATE_FROM_STATE_BITS(state, State, ResourcesChanged);
}

GetPnpStateInternal()

LONG FxPkgPnp::GetPnpStateInternal ( VOID  )

protected

Definition at line 5433 of file fxpkgpnp.cpp.

{
    LONG state;
    KIRQL irql;
 
    //
    // State is shared with the caps bits.  Use a lock to guard against
    // corruption of the value between these 2 values
    //
    Lock(&irql);
    state = m_PnpStateAndCaps.Value & FxPnpStateMask;
    Unlock(irql);
 
    return state;
}

Referenced by GetPnpState(), and HandleQueryPnpDeviceState().

GetPnpTableEntry()

static CPPNP_STATE_TABLE FxPkgPnp::GetPnpTableEntry ( __in WDF_DEVICE_PNP_STATE  State )

inlinestaticprotected

Definition at line 2853 of file fxpkgpnp.hpp.

    {
        return &m_WdfPnpStates[WdfDevStateNormalize(State) - WdfDevStatePnpObjectCreated];
    }

Referenced by PnpEnterNewState(), and PnpProcessEventInner().

GetPowerPolicyTableEntry()

static CPPOWER_POLICY_STATE_TABLE FxPkgPnp::GetPowerPolicyTableEntry ( __in WDF_DEVICE_POWER_POLICY_STATE  State )

inlinestaticprotected

Definition at line 2871 of file fxpkgpnp.hpp.

    {
        return &m_WdfPowerPolicyStates[WdfDevStateNormalize(State) - WdfDevStatePwrPolObjectCreated];
    }

Referenced by PowerPolicyEnterNewState(), and PowerPolicyProcessEventInner().

GetPowerTableEntry()

static CPPOWER_STATE_TABLE FxPkgPnp::GetPowerTableEntry ( __in WDF_DEVICE_POWER_STATE  State )

inlinestaticprotected

Definition at line 2862 of file fxpkgpnp.hpp.

    {
        return &m_WdfPowerStates[WdfDevStateNormalize(State) - WdfDevStatePowerObjectCreated];
    }

Referenced by PowerEnterNewState(), and PowerProcessEventInner().

GetRawResourceList()

FxCmResList * FxPkgPnp::GetRawResourceList ( VOID  )

inline

Definition at line 3804 of file fxpkgpnp.hpp.

    {
        return m_ResourcesRaw;
    }

GetSystemPowerAction()

POWER_ACTION FxPkgPnp::GetSystemPowerAction ( VOID  )

inline

Definition at line 3768 of file fxpkgpnp.hpp.

    {
        return (POWER_ACTION) m_SystemPowerAction;
    }

GetTranslatedResourceList()

FxCmResList * FxPkgPnp::GetTranslatedResourceList ( VOID  )

inline

Definition at line 3796 of file fxpkgpnp.hpp.

    {
        return m_Resources;
    }

Referenced by FxDevice::GetTranslatedResources().

GetUsageCount()

LONG FxPkgPnp::GetUsageCount ( __in __range(1, 4) ULONG  Usage )

inlineprotected

Definition at line 3161 of file fxpkgpnp.hpp.

    {
        return m_SpecialFileCount[Usage-1];
    }

Referenced by CommitUsageNotification(), IsInSpecialUse(), PnpDeviceUsageNotification(), PowerGotoDxIoStopped(), PowerGotoDxIoStoppedNP(), and SetUsageNotificationFlags().

HandleQueryBusInformation()

_Must_inspect_result_ NTSTATUS FxPkgPnp::HandleQueryBusInformation

(

__inout FxIrp *

Irp

)

Definition at line 947 of file fxpkgpnp.cpp.

{
    NTSTATUS status;
 
    //
    // Probably is a better check then this to see if the driver set the bus
    // information
    //
    if (m_BusInformation.BusTypeGuid.Data1 != 0x0) {
        PPNP_BUS_INFORMATION pBusInformation;
        PFX_DRIVER_GLOBALS pFxDriverGlobals;
 
        pFxDriverGlobals = GetDriverGlobals();
        pBusInformation = (PPNP_BUS_INFORMATION) MxMemory::MxAllocatePoolWithTag(
                PagedPool, sizeof(PNP_BUS_INFORMATION), pFxDriverGlobals->Tag);
 
        if (pBusInformation != NULL) {
            //
            // Initialize the PNP_BUS_INFORMATION structure with the data
            // from PDO properties.
            //
            RtlCopyMemory(pBusInformation,
                          &m_BusInformation,
                          sizeof(PNP_BUS_INFORMATION));
 
            Irp->SetInformation((ULONG_PTR) pBusInformation);
            status = STATUS_SUCCESS;
        }
        else {
            Irp->SetInformation(NULL);
            status = STATUS_INSUFFICIENT_RESOURCES;
 
            DoTraceLevelMessage(
                pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
                "WDFDEVICE %p could not allocate PNP_BUS_INFORMATION string, "
                " %!STATUS!", m_Device->GetHandle(), status);
        }
    }
    else {
        status = Irp->GetStatus();
    }
 
    return status;
}

Referenced by FxPkgPdo::_PnpQueryBusInformation().

HandleQueryBusRelations()

_Must_inspect_result_ NTSTATUS FxPkgPnp::HandleQueryBusRelations ( __inout FxIrp *  Irp )

protected

Definition at line 758 of file fxpkgpnp.cpp.

{
    FxWaitLockTransactionedList* pList;
    PDEVICE_RELATIONS pRelations;
    FxTransactionedEntry* ple;
    NTSTATUS status, listStatus;
    BOOLEAN changed;
 
    //
    // Before we do anything, callback into the driver
    //
    m_DeviceRelationsQuery.Invoke(m_Device->GetHandle(), BusRelations);
 
    //
    // Default to success unless list processing fails
    //
    status = STATUS_SUCCESS;
 
    //
    // Keep track of changes made by any list object.  If anything changes,
    // remember it for post-processing.
    //
    changed = FALSE;
 
    pRelations = (PDEVICE_RELATIONS) Irp->GetInformation();
 
    if (m_EnumInfo != NULL) {
        pList = &m_EnumInfo->m_ChildListList;
 
        pList->LockForEnum(GetDriverGlobals());
    }
    else {
        pList = NULL;
    }
 
    ple = NULL;
    while (pList != NULL && (ple = pList->GetNextEntry(ple)) != NULL) {
        FxChildList* pChildList;
 
        pChildList = FxChildList::_FromEntry(ple);
 
        //
        // ProcessBusRelations will free and reallocate pRelations if necessary
        //
        listStatus = pChildList->ProcessBusRelations(&pRelations);
 
        //
        // STATUS_NOT_SUPPORTED is a special value.  It indicates that the call
        // to ProcessBusRelations did not modify pRelations in any way.
        //
        if (listStatus == STATUS_NOT_SUPPORTED) {
            continue;
        }
 
 
        if (!NT_SUCCESS(listStatus)) {
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                "WDFDEVICE %p, WDFCHILDLIST %p returned %!STATUS! from "
                "processing bus relations",
                m_Device->GetHandle(), pChildList->GetHandle(), listStatus);
            status = listStatus;
            break;
        }
 
        //
        // We updated pRelations, change the status later
        //
        changed = TRUE;
    }
 
    //
    // By checking for NT_SUCCESS(status) below we account for
    // both the cases - list changed, as well as list unchanged but possibly
    // children being reported missing (that doesn't involve list change).
    //
    if (NT_SUCCESS(status)) {
 
        ple = NULL;
        while (pList != NULL && (ple = pList->GetNextEntry(ple)) != NULL) {
            FxChildList* pChildList;
 
            pChildList = FxChildList::_FromEntry(ple);
 
            //
            // invoke the ReportedMissing callback for for children that are
            // being reporte missing
            //
            pChildList->InvokeReportedMissingCallback();
        }
    }
 
    if (pList != NULL) {
        pList->UnlockFromEnum(GetDriverGlobals());
    }
 
    if (NT_SUCCESS(status) && changed == FALSE) {
        //
        // Went through the entire list of FxChildList objects, but no object
        // modified the pRelations, so restore the caller's NTSTATUS.
        //
        status = Irp->GetStatus();
    }
 
    //
    // Re-set the relations into the structure so that any changes that any call
    // to FxChildList::ProcessBusRelations takes effect and is reported.
    //
    Irp->SetInformation((ULONG_PTR) pRelations);
    Irp->SetStatus(status);
 
    DoTraceLevelMessage(
        GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
        "WDFDEVICE %p, returning %!STATUS! from processing bus relations",
        m_Device->GetHandle(), status
        );
 
    if (NT_SUCCESS(status) && pRelations != NULL) {
        ULONG i;
 
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGPNP,
            "WDFDEVICE %p returning %d devices in relations %p",
            m_Device->GetHandle(), pRelations->Count, pRelations
            );
 
        //
        // Try to not consume an IFR entry per DO reported.  Instead, report up
        // to 4 at a time.
        //
        for (i = 0; i < pRelations->Count && GetDriverGlobals()->FxVerboseOn; i += 4) {
            if (i + 3 < pRelations->Count) {
                DoTraceLevelMessage(
                    GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
                    "PDO %p PDO %p PDO %p PDO %p",
                    pRelations->Objects[i],
                    pRelations->Objects[i+1],
                    pRelations->Objects[i+2],
                    pRelations->Objects[i+3]
                    );
            }
            else if (i + 2 < pRelations->Count) {
                DoTraceLevelMessage(
                    GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
                    "PDO %p PDO %p PDO %p",
                    pRelations->Objects[i],
                    pRelations->Objects[i+1],
                    pRelations->Objects[i+2]
                    );
            }
            else if (i + 1 < pRelations->Count) {
                DoTraceLevelMessage(
                    GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
                    "PDO %p PDO %p",
                    pRelations->Objects[i],
                    pRelations->Objects[i+1]
                    );
            }
            else {
                DoTraceLevelMessage(
                    GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
                    "PDO %p",
                    pRelations->Objects[i]
                    );
            }
        }
    }
 
    return status;
}

Referenced by FxPkgFdo::PnpQueryDeviceRelations(), and FxPkgPdo::PnpQueryDeviceRelations().

HandleQueryDeviceRelations()

_Must_inspect_result_ NTSTATUS FxPkgPnp::HandleQueryDeviceRelations ( __inout FxIrp *  Irp, __inout FxRelatedDeviceList *  List  )

protected

Definition at line 996 of file fxpkgpnp.cpp.

{
    PDEVICE_RELATIONS pPriorRelations, pNewRelations;
    FxRelatedDevice* entry;
    DEVICE_RELATION_TYPE type;
    ULONG count;
    size_t size;
    NTSTATUS status;
    BOOLEAN retry;
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
 
    if (List == NULL) {
        //
        // Indicate that we didn't modify the irp at all since we have no list
        //
        return STATUS_NOT_SUPPORTED;
    }
 
    pFxDriverGlobals = GetDriverGlobals();
    type = Irp->GetParameterQDRType();
    status = STATUS_SUCCESS;
 
    //
    // Notify driver that he should re-scan for device relations.
    //
    m_DeviceRelationsQuery.Invoke(m_Device->GetHandle(), type);
 
    pPriorRelations = (PDEVICE_RELATIONS) Irp->GetInformation();
    retry = FALSE;
 
    count = 0;
 
    List->LockForEnum(pFxDriverGlobals);
 
    //
    // Count how many entries there are in the list
    //
    for (entry = NULL; (entry = List->GetNextEntry(entry)) != NULL; count++) {
        DO_NOTHING();
    }
 
    //
    // If we have
    // 1)  no devices in the list AND
    //   a) we have nothing to report OR
    //   b) we have something to report and there are previous relations (which
    //      if left unchanged will be used to report our missing devices)
    //
    // THEN we have nothing else to do, just return
    //
    if (count == 0 &&
        (List->m_NeedReportMissing == 0 || pPriorRelations != NULL)) {
        List->UnlockFromEnum(pFxDriverGlobals);
        return STATUS_NOT_SUPPORTED;
    }
 
    if (pPriorRelations != NULL) {
        //
        // Looks like another driver in the stack has already added some
        // entries.  Make sure we allocate space for these additional entries.
        //
        count += pPriorRelations->Count;
    }
 
    //
    // Allocate space for the device relations structure (which includes
    // space for one PDEVICE_OBJECT, and then allocate enough additional
    // space for the extra PDEVICE_OBJECTS we need.
    //
    // (While no FxChildList objects are used in this function, this static
    // function from the class computes what we need.)
    //
    size = FxChildList::_ComputeRelationsSize(count);
 
    pNewRelations = (PDEVICE_RELATIONS) MxMemory::MxAllocatePoolWithTag(
        PagedPool, size, pFxDriverGlobals->Tag);
 
    if (pNewRelations == NULL) {
        //
        // Dereference any previously reported relations before exiting.  They
        // are dereferenced here because the PNP manager will see error and not
        // do anything while the driver which added these objects expects the
        // pnp manager to do the dereference.  Since this device is changing the
        // status, it must act like the pnp manager.
        //
        if (pPriorRelations != NULL) {
            ULONG i;
 
            for (i = 0; i < pPriorRelations->Count; i++) {
                Mx::MxDereferenceObject(pPriorRelations->Objects[i]);
            }
        }
 
        if (List->IncrementRetries() < 3) {
            retry = TRUE;
        }
 
        status = STATUS_INSUFFICIENT_RESOURCES;
 
        DoTraceLevelMessage(
            pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
            "WDFDEVICE %p could not allocate device relations for type %d string, "
            " %!STATUS!", m_Device->GetHandle(), type, status);
 
        goto Done;
    }
 
    RtlZeroMemory(pNewRelations, size);
 
    //
    // If there was an existing device relations structure, copy
    // the entries to the new structure.
    //
    if (pPriorRelations != NULL && pPriorRelations->Count > 0) {
        RtlCopyMemory(
            pNewRelations,
            pPriorRelations,
            FxChildList::_ComputeRelationsSize(pPriorRelations->Count)
            );
    }
 
    //
    // Walk the list and return the relations here
    //
    for (entry = NULL;
         (entry = List->GetNextEntry(entry)) != NULL;
         pNewRelations->Count++) {
        MdDeviceObject pdo;
 
        pdo = entry->GetDevice();
 
        if (entry->m_State == RelatedDeviceStateNeedsReportPresent) {
            entry->m_State = RelatedDeviceStateReportedPresent;
        }
 
        //
        // Add it to the DEVICE_RELATIONS structure.  Pnp dictates that each
        // PDO in the list be referenced.
        //
        pNewRelations->Objects[pNewRelations->Count] = reinterpret_cast<PDEVICE_OBJECT>(pdo);
        Mx::MxReferenceObject(pdo);
    }
 
Done:
    if (NT_SUCCESS(status)) {
        List->ZeroRetries();
    }
 
    List->UnlockFromEnum(GetDriverGlobals());
 
    if (pPriorRelations != NULL) {
        MxMemory::MxFreePool(pPriorRelations);
    }
 
    if (retry) {
        MxDeviceObject physicalDeviceObject(
                                    m_Device->GetPhysicalDevice()
                                    );
 
        physicalDeviceObject.InvalidateDeviceRelations(type);
    }
 
    Irp->SetStatus(status);
    Irp->SetInformation((ULONG_PTR) pNewRelations);
 
    return status;
}

Referenced by FxPkgFdo::PnpQueryDeviceRelations(), and FxPkgPdo::PnpQueryDeviceRelations().

HandleQueryInterface()

_Must_inspect_result_ NTSTATUS FxPkgPnp::HandleQueryInterface ( __inout FxIrp *  Irp, __out PBOOLEAN  CompleteRequest  )

protected

Definition at line 1493 of file fxpkgpnp.cpp.

{
    FxDeviceProcessQueryInterfaceRequest callback;
    const GUID* pInterfaceType;
    PSINGLE_LIST_ENTRY ple;
    FxQueryInterface *pQI;
    PVOID pFound;
    PINTERFACE pExposedInterface;
    PVOID pExposedInterfaceSpecificData;
    BOOLEAN sendToParent;
 
    NTSTATUS status;
 
    *CompleteRequest = FALSE;
 
    pFound = NULL;
    pQI = NULL;
    pExposedInterface = NULL;
    pExposedInterfaceSpecificData = NULL;
    sendToParent = FALSE;
 
    pInterfaceType = Irp->GetParameterQueryInterfaceType();
    //
    // The power thread is special cased because it has a different semantic
    // then the usual QI irp that we expose to the driver writer.  In this case,
    // we want to fill in the interface if the lower stack does not support it.
    //
    if (FxIsEqualGuid(pInterfaceType, &GUID_POWER_THREAD_INTERFACE)) {
        return HandleQueryInterfaceForPowerThread(Irp, CompleteRequest);
    }
    else if (FxIsEqualGuid(pInterfaceType, &GUID_REENUMERATE_SELF_INTERFACE_STANDARD)) {
        if (m_Device->IsPdo()) {
            return ((FxPkgPdo*) this)->HandleQueryInterfaceForReenumerate(
                Irp, CompleteRequest);
        }
    }
 
    status = Irp->GetStatus();
 
    //
    // Walk the interface collection and return the appropriate interface.
    //
    m_QueryInterfaceLock.AcquireLock(GetDriverGlobals());
 
    for (ple = m_QueryInterfaceHead.Next; ple != NULL; ple = ple->Next) {
        pQI = FxQueryInterface::_FromEntry(ple);
 
        if (FxIsEqualGuid(Irp->GetParameterQueryInterfaceType(),
                          &pQI->m_InterfaceType)) {
 
            pExposedInterface = Irp->GetParameterQueryInterfaceInterface();
            pExposedInterfaceSpecificData =
                Irp->GetParameterQueryInterfaceInterfaceSpecificData();
 
            if (pQI->m_Interface != NULL) {
                //
                // NOTE:  If a driver has exposed the same interface GUID with
                //        different sizes as a ways of versioning, then the driver
                //        writer can specify the minimum size and version number
                //        and then fill in the remaining fields in the callback
                //        below.
                //
                if (pQI->m_Interface->Size <= Irp->GetParameterQueryInterfaceSize() &&
                    pQI->m_Interface->Version <= Irp->GetParameterQueryInterfaceVersion()) {
 
                    if (pQI->m_ImportInterface == FALSE) {
                        //
                        // Expose the interface to the requesting driver.
                        //
                        RtlCopyMemory(pExposedInterface,
                                      pQI->m_Interface,
                                      pQI->m_Interface->Size);
                    }
                    else {
                        //
                        // The interface contains data which the driver wants
                        // before copying over its information, so don't do a
                        // copy and let the event callback do the copy
                        //
                        DO_NOTHING();
                    }
                }
                else {
                    status = STATUS_INVALID_BUFFER_SIZE;
                    break;
                }
            }
 
            callback.m_Method = pQI->m_ProcessRequest.m_Method;
            sendToParent = pQI->m_SendQueryToParentStack;
            pFound = pQI;
 
            status = STATUS_SUCCESS;
            break;
        }
    }
 
    m_QueryInterfaceLock.ReleaseLock(GetDriverGlobals());
 
    if (!NT_SUCCESS(status) || pFound == NULL) {
        goto Done;
    }
 
    //
    // Let the driver see the interface before it is handed out.
    //
    status = callback.Invoke(m_Device->GetHandle(),
                             (LPGUID) Irp->GetParameterQueryInterfaceType(),
                             pExposedInterface,
                             pExposedInterfaceSpecificData);
 
    //
    // STATUS_NOT_SUPPORTED is a special cased error code which indicates that
    // the QI should travel down the rest of the stack.
    //
    if (!NT_SUCCESS(status) && status != STATUS_NOT_SUPPORTED) {
        goto Done;
    }
 
    //
    // If it is meant for the parent, send it down the parent stack
    //
    if (sendToParent) {
        status = PnpPassThroughQI(m_Device, Irp);
        goto Done;
    }
 
    //
    // Reference the interface before returning it to the requesting driver.
    // If this is an import interface, the event callback is free to not fill
    // in the InterfaceReference function pointer.
    //
    if (pExposedInterface->InterfaceReference != NULL) {
        pExposedInterface->InterfaceReference(pExposedInterface->Context);
    }
 
    //
    // If we are not a PDO in the stack, then send the fully formatted QI request
    // down the stack to allow others to filter the interface.
    //
    if (m_Device->IsPdo() == FALSE) {
        ASSERT(NT_SUCCESS(status) || status == STATUS_NOT_SUPPORTED);
 
        Irp->SetStatus(status);
        Irp->CopyCurrentIrpStackLocationToNext();
        status = Irp->SendIrpSynchronously(m_Device->GetAttachedDevice());
    }
 
Done:
    if (pFound != NULL) {
        *CompleteRequest = TRUE;
    }
 
    return status;
}

Referenced by FxPkgFdo::_PnpQueryInterface().

HandleQueryInterfaceForPowerThread()

_Must_inspect_result_ NTSTATUS FxPkgPnp::HandleQueryInterfaceForPowerThread ( __inout FxIrp *  Irp, __out PBOOLEAN  CompleteRequest  )

private

Definition at line 1437 of file fxpkgpnp.cpp.

{
    NTSTATUS status;
 
    *CompleteRequest = TRUE;
 
    //
    // Send the request down the stack first.  If someone lower handles it
    // or failed trying to, just return their status
    //
    status = SendIrpSynchronously(Irp);
 
    if (NT_SUCCESS(status) || status != STATUS_NOT_SUPPORTED) {
        //
        // Success or failure trying to handle it
        //
        return status;
    }
 
    //
    // The semantic of this QI is that it sent down while processing start or
    // a device usage notification on the way *up* the stack.  That means that
    // by the time the QI gets to the lower part of the stack, the power thread
    // will have already been allocated and exported.
    //
    ASSERT(HasPowerThread());
 
    if (Irp->GetParameterQueryInterfaceVersion() == 1 &&
        Irp->GetParameterQueryInterfaceSize() >=
                                        m_PowerThreadInterface.Interface.Size) {
        //
        // Expose the interface to the requesting driver.
        //
        CopyQueryInterfaceToIrpStack(&m_PowerThreadInterface, Irp);
 
        status = STATUS_SUCCESS;
 
        //
        // Caller assumes a reference has been taken.
        //
        m_PowerThreadInterface.Interface.InterfaceReference(
            m_PowerThreadInterface.Interface.Context
            );
    }
    else {
        status = STATUS_INVALID_BUFFER_SIZE;
    }
 
    return status;
}

Referenced by HandleQueryInterface().

HandleQueryPnpDeviceState()

PNP_DEVICE_STATE FxPkgPnp::HandleQueryPnpDeviceState ( __in PNP_DEVICE_STATE  PnpDeviceState )

protected

Definition at line 662 of file fxpkgpnp.cpp.

{
    LONG state;
 
    state = GetPnpStateInternal();
 
    //
    // Return device state set by driver.
    //
    SET_PNP_DEVICE_STATE_BIT(&PnpDeviceState,
                             PNP_DEVICE_DISABLED,
                             state,
                             Disabled);
    SET_PNP_DEVICE_STATE_BIT(&PnpDeviceState,
                             PNP_DEVICE_DONT_DISPLAY_IN_UI,
                             state,
                             DontDisplayInUI);
    SET_PNP_DEVICE_STATE_BIT(&PnpDeviceState,
                             PNP_DEVICE_FAILED,
                             state,
                             Failed);
    SET_PNP_DEVICE_STATE_BIT(&PnpDeviceState,
                             PNP_DEVICE_NOT_DISABLEABLE,
                             state,
                             NotDisableable);
    SET_PNP_DEVICE_STATE_BIT(&PnpDeviceState,
                             PNP_DEVICE_REMOVED,
                             state,
                             Removed);
    SET_PNP_DEVICE_STATE_BIT(&PnpDeviceState,
                             PNP_DEVICE_RESOURCE_REQUIREMENTS_CHANGED,
                             state,
                             ResourcesChanged);
 
    if ((state & FxPnpStateDontDisplayInUIMask) == FxPnpStateDontDisplayInUIUseDefault) {
        LONG caps;
 
        //
        // Mask off all caps except for NoDispalyInUI
        //
        caps = GetPnpCapsInternal() & FxPnpCapNoDisplayInUIMask;
 
        //
        // If the driver didn't specify pnp state, see if they specified no
        // display as a capability.  For raw PDOs and just usability, it is not
        // always clear to the driver writer that they must set both the pnp cap
        // and the pnp state for the no display in UI property to stick after
        // the device has been started.
        //
        if (caps == FxPnpCapNoDisplayInUITrue) {
            PnpDeviceState |= PNP_DEVICE_DONT_DISPLAY_IN_UI;
        }
        else if (caps == FxPnpCapNoDisplayInUIFalse) {
            PnpDeviceState &= ~PNP_DEVICE_DONT_DISPLAY_IN_UI;
        }
    }
 
    //
    // Return device state maintained by frameworks.
    //
    if (IsInSpecialUse()) {
        PnpDeviceState |= PNP_DEVICE_NOT_DISABLEABLE;
    }
 
    //
    // If there is an internal failure, then indicate that up to pnp.
    //
    if (m_InternalFailure || m_Failed) {
        PnpDeviceState |= PNP_DEVICE_FAILED;
    }
 
    return PnpDeviceState;
}

Referenced by FxPkgFdo::HandleQueryPnpDeviceStateCompletion().

HasMultipleInterrupts()

BOOLEAN FxPkgPnp::HasMultipleInterrupts ( VOID  )

inline

Definition at line 4066 of file fxpkgpnp.hpp.

    {
        return (m_InterruptObjectCount > 1 ? TRUE : FALSE);
    }

Referenced by GetDriverInfo().

HasPowerThread()

BOOLEAN FxPkgPnp::HasPowerThread ( VOID  )

inline

Definition at line 3508 of file fxpkgpnp.hpp.

    {
        return m_HasPowerThread;
    }

Referenced by CreatePowerThreadIfNeeded(), HandleQueryInterfaceForPowerThread(), PnpDeviceUsageNotification(), and FxThreadedEventQueue::QueueWorkItem().

Initialize()

_Must_inspect_result_ NTSTATUS FxPkgPnp::Initialize ( __in PWDFDEVICE_INIT  DeviceInit )

virtual

Reimplemented in FxPkgFdo, and FxPkgPdo.

Definition at line 349 of file fxpkgpnp.cpp.

{
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
    NTSTATUS status;
 
    pFxDriverGlobals = GetDriverGlobals();
 
    m_ReleaseHardwareAfterDescendantsOnFailure = (DeviceInit->ReleaseHardwareOrderOnFailure ==
                WdfReleaseHardwareOrderOnFailureAfterDescendants);
 
    status = m_QueryInterfaceLock.Initialize();
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR,
                            TRACINGPNP,
                            "Could not initialize QueryInterfaceLock for "
                            "WDFDEVICE %p, %!STATUS!",
                            m_Device->GetHandle(), status);
        return status;
    }
 
    status = m_DeviceInterfaceLock.Initialize();
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR,
                            TRACINGPNP,
                            "Could not initialize DeviceInterfaceLock for "
                            "WDFDEVICE %p, %!STATUS!",
                            m_Device->GetHandle(), status);
        return status;
    }
 
    //
    // Initialize preallocated events for UM
    // (For KM, events allocated on stack are used since event initialization
    // doesn't fail in KM)
    //
#if (FX_CORE_MODE==FX_CORE_USER_MODE)
 
    status = m_CleanupEventUm.Initialize();
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR,
                            TRACINGPNP,
                            "Could not initialize cleanup event for "
                            "WDFDEVICE %p, %!STATUS!",
                            m_Device->GetHandle(), status);
        return status;
    }
 
    status = m_RemoveEventUm.Initialize(SynchronizationEvent, FALSE);
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR,
                            TRACINGPNP,
                            "Could not initialize remove event for "
                            "WDFDEVICE %p, %!STATUS!",
                            m_Device->GetHandle(), status);
        return status;
    }
#endif
 
    if (DeviceInit->IsPwrPolOwner()) {
        m_PowerPolicyMachine.m_Owner = new (pFxDriverGlobals)
            FxPowerPolicyOwnerSettings(this);
 
        if (m_PowerPolicyMachine.m_Owner == NULL) {
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        status = m_PowerPolicyMachine.m_Owner->Init();
        if (!NT_SUCCESS(status)) {
            return status;
        }
 
#if (FX_CORE_MODE==FX_CORE_KERNEL_MODE)
        QueryForD3ColdInterface();
#endif
    }
 
    //
    // we will change the access flags on the object later on when we build up
    // the list from the wdm resources
    //
    status = FxCmResList::_CreateAndInit(&m_Resources,
                                         pFxDriverGlobals,
                                         m_Device,
                                         WDF_NO_OBJECT_ATTRIBUTES,
                                         FxResourceNoAccess);
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    status = m_Resources->Commit(WDF_NO_OBJECT_ATTRIBUTES,
                                 WDF_NO_HANDLE,
                                 m_Device);
 
    //
    // This should never fail
    //
    ASSERT(NT_SUCCESS(status));
    if (!NT_SUCCESS(status)) {
        m_Resources->DeleteFromFailedCreate();
        m_Resources = NULL;
        return status;
    }
 
    m_Resources->ADDREF(this);
 
    //
    // we will change the access flags on the object later on when we build up
    // the list from the wdm resources
    //
    status = FxCmResList::_CreateAndInit(&m_ResourcesRaw,
                                         pFxDriverGlobals,
                                         m_Device,
                                         WDF_NO_OBJECT_ATTRIBUTES,
                                         FxResourceNoAccess);
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    status = m_ResourcesRaw->Commit(WDF_NO_OBJECT_ATTRIBUTES,
                                    WDF_NO_HANDLE,
                                    m_Device);
 
    //
    // This should never fail
    //
    ASSERT(NT_SUCCESS(status));
    if (!NT_SUCCESS(status)) {
        m_ResourcesRaw->DeleteFromFailedCreate();
        m_ResourcesRaw = NULL;
        return status;
    }
 
    m_ResourcesRaw->ADDREF(this);
 
    status = RegisterCallbacks(&DeviceInit->PnpPower.PnpPowerEventCallbacks);
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    if (IsPowerPolicyOwner()) {
        RegisterPowerPolicyCallbacks(&DeviceInit->PnpPower.PolicyEventCallbacks);
    }
 
    return status;
}

Referenced by FxPkgFdo::Initialize(), FxPkgPdo::Initialize(), and FxDevice::PdoInitialize().

IsDefaultReleaseHardwareOrder()

BOOLEAN FxPkgPnp::IsDefaultReleaseHardwareOrder ( VOID  )

inline

Definition at line 4054 of file fxpkgpnp.hpp.

    {
#if FX_IS_KERNEL_MODE
        return (m_ReleaseHardwareAfterDescendantsOnFailure == WdfReleaseHardwareOrderOnFailureEarly ? TRUE : FALSE);
#else
        return FALSE;
#endif
    }

Referenced by GetDriverInfo().

IsDevicePowerUpIrpPending()

BOOLEAN FxPkgPnp::IsDevicePowerUpIrpPending ( VOID  )

inlineprotected

Definition at line 3113 of file fxpkgpnp.hpp.

    {
        DEVICE_POWER_STATE state;
        FxIrp irp(m_PendingDevicePowerIrp);
 
        if (irp.GetIrp() == NULL) {
            return FALSE;
        }
 
        state = irp.GetParameterPowerStateDeviceState();
 
        return (state == PowerDeviceD0 ? TRUE : FALSE);
    }

Referenced by SaveState().

IsInSpecialUse()

BOOLEAN FxPkgPnp::IsInSpecialUse ( VOID  )

inlineprotected

Definition at line 3170 of file fxpkgpnp.hpp.

    {
        if (GetUsageCount(WdfSpecialFilePaging) == 0 &&
            GetUsageCount(WdfSpecialFileHibernation) == 0 &&
            GetUsageCount(WdfSpecialFileDump) == 0 &&
            GetUsageCount(WdfSpecialFileBoot) == 0) {
            return FALSE;
        }
        else {
            return TRUE;
        }
    }

Referenced by HandleQueryPnpDeviceState(), and SetUsageNotificationFlags().

IsPowerPolicyOwner()

BOOLEAN FxPkgPnp::IsPowerPolicyOwner ( VOID  )

inline

Definition at line 3612 of file fxpkgpnp.hpp.

    {
        return m_PowerPolicyMachine.m_Owner != NULL ? TRUE : FALSE;
    }

Referenced by FxPkgFdo::_PnpStartDeviceCompletionRoutine(), FxIoQueue::FxIoQueue(), GetDriverInfo(), PowerMakeWakeRequestNonCancelable(), ResumeIdleWorker(), and StopIdleWorker().

IsPresentPendingPnpIrp()

BOOLEAN FxPkgPnp::IsPresentPendingPnpIrp ( VOID  )

inlineprotected

Definition at line 3004 of file fxpkgpnp.hpp.

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

Referenced by PnpFinishProcessingIrp().

IsS0IdleSystemManaged()

BOOLEAN FxPkgPnp::IsS0IdleSystemManaged ( VOID  )

inline

Definition at line 3645 of file fxpkgpnp.hpp.

    {
        if (IsPowerPolicyOwner()) {
            return m_PowerPolicyMachine.m_Owner->m_IdleSettings.m_TimeoutMgmt.UsingSystemManagedIdleTimeout();
        }
        else {
            return FALSE;
        }
    }

Referenced by GetDriverInfo().

IsS0IdleUsbSSEnabled()

BOOLEAN FxPkgPnp::IsS0IdleUsbSSEnabled ( VOID  )

inline

Definition at line 3658 of file fxpkgpnp.hpp.

    {
        if (IsPowerPolicyOwner()) {
            return (m_PowerPolicyMachine.m_Owner->m_IdleSettings.WakeFromS0Capable &&
                    m_PowerPolicyMachine.m_Owner->m_IdleSettings.UsbSSCapable);
        }
        else {
            return FALSE;
        }
    }

Referenced by GetDriverInfo().

IsS0IdleWakeFromS0Enabled()

BOOLEAN FxPkgPnp::IsS0IdleWakeFromS0Enabled ( VOID  )

inline

Definition at line 3632 of file fxpkgpnp.hpp.

    {
        if (IsPowerPolicyOwner()) {
            return m_PowerPolicyMachine.m_Owner->m_IdleSettings.WakeFromS0Capable;
        }
        else {
            return FALSE;
        }
    }

Referenced by GetDriverInfo().

IsSxWakeEnabled()

BOOLEAN FxPkgPnp::IsSxWakeEnabled ( VOID  )

inline

Definition at line 3672 of file fxpkgpnp.hpp.

    {
        if (IsPowerPolicyOwner()) {
            return m_PowerPolicyMachine.m_Owner->m_WakeSettings.Enabled;
        }
        else {
            return FALSE;
        }
    }

Referenced by GetDriverInfo().

IsUsageSupported()

BOOLEAN FxPkgPnp::IsUsageSupported ( __in DEVICE_USAGE_NOTIFICATION_TYPE  Usage )

inlineprotected

Definition at line 3130 of file fxpkgpnp.hpp.

    {
        return m_SpecialSupport[((ULONG)Usage)-1];
    }

Referenced by PnpDeviceUsageNotification(), and SaveState().

NotifyResourceObjectsD0()

_Must_inspect_result_ NTSTATUS FxPkgPnp::NotifyResourceObjectsD0 ( __in ULONG  NotifyFlags )

private

Definition at line 6055 of file fxpkgpnp.cpp.

{
    FxInterrupt* pInterrupt;
    PLIST_ENTRY ple;
    NTSTATUS status;
 
    for (ple = m_InterruptListHead.Flink;
         ple != &m_InterruptListHead;
         ple = ple->Flink) {
 
        //
        // Connect the interrupts
        //
        pInterrupt = CONTAINING_RECORD(ple, FxInterrupt, m_PnpList);
 
        status = pInterrupt->Connect(NotifyFlags);
 
        if (!NT_SUCCESS(status)) {
            DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                                "WDFINTERRUPT %p failed to connect, %!STATUS!",
                                pInterrupt->GetHandle(), status);
 
            return status;
        }
    }
 
    return STATUS_SUCCESS;
}

NotifyResourceObjectsDx()

NTSTATUS FxPkgPnp::NotifyResourceObjectsDx ( __in ULONG  NotifyFlags )

private

Definition at line 6104 of file fxpkgpnp.cpp.

{
    FxInterrupt* pInterrupt;
    PLIST_ENTRY ple;
    NTSTATUS status, finalStatus;
 
    finalStatus = STATUS_SUCCESS;
 
    //
    // Disconect in the reverse order in which we connected the interrupts
    //
    for (ple = m_InterruptListHead.Blink;
         ple != &m_InterruptListHead;
         ple = ple->Blink) {
 
        //
        // Disconnect interrupts and then tell them that they no longer
        // own their resources.
        //
        pInterrupt = CONTAINING_RECORD(ple, FxInterrupt, m_PnpList);
 
        status = pInterrupt->Disconnect(NotifyFlags);
 
        if (!NT_SUCCESS(status)) {
            //
            // When we encounter an error we still disconnect the remaining
            // interrupts b/c we would just do it later during device tear down
            // (might as well do it now).
            //
            DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                                "WDFINTERRUPT %p failed to disconnect, %!STATUS!",
                                pInterrupt->GetHandle(), status);
            //
            // Overwriting a previous finalStatus is OK, we'll just report the
            // last one
            //
            finalStatus = status;
        }
    }
 
    return finalStatus;
}

Referenced by DisconnectInterruptNP(), PowerConnectInterruptFailed(), PowerGotoDxIoStopped(), and PowerGotoDxIoStoppedNP().

NotifyResourceobjectsToReleaseResources()

VOID FxPkgPnp::NotifyResourceobjectsToReleaseResources ( VOID  )

private

Definition at line 5990 of file fxpkgpnp.cpp.

{
    FxInterrupt* interruptInstance;
    PLIST_ENTRY intListEntry;
 
    //
    // Revoke each of the interrupts.
    //
 
    intListEntry = m_InterruptListHead.Flink;
 
    while (intListEntry != &m_InterruptListHead) {
 
        //
        // Disconnect interrupts and then tell them that they no longer
        // own their resources.
        //
 
        interruptInstance = CONTAINING_RECORD(intListEntry, FxInterrupt, m_PnpList);
        interruptInstance->RevokeResources();
        intListEntry = intListEntry->Flink;
    }
 
    //
    // Now revoke each of the DMA enablers (only system-mode enablers
    // will be affected by this)
    //
 
    if (m_DmaEnablerList != NULL) {
        FxTransactionedEntry* listEntry;
 
        m_DmaEnablerList->LockForEnum(GetDriverGlobals());
 
        for (listEntry = m_DmaEnablerList->GetNextEntry(NULL);
             listEntry != NULL;
             listEntry = m_DmaEnablerList->GetNextEntry(listEntry)) {
            RevokeDmaEnablerResources(
                (FxDmaEnabler *) listEntry->GetTransactionedObject()
                );
        }
 
        m_DmaEnablerList->UnlockFromEnum(GetDriverGlobals());
    }
}

Referenced by PnpCleanupForRemove().

NotPowerPolicyOwnerEnterNewState()

VOID FxPkgPnp::NotPowerPolicyOwnerEnterNewState ( __in WDF_DEVICE_POWER_POLICY_STATE  NewState )

protected

Definition at line 270 of file notpowerpolicyownerstatemachine.cpp.

{
    CPNOT_POWER_POLICY_OWNER_STATE_TABLE entry;
    WDF_DEVICE_POWER_POLICY_STATE currentState, newState;
    WDF_DEVICE_POWER_POLICY_NOTIFICATION_DATA data;
 
    currentState = m_Device->GetDevicePowerPolicyState();
    newState = NewState;
 
    while (newState != WdfDevStatePwrPolNull) {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGPNPPOWERSTATES,
            "WDFDEVICE 0x%p !devobj 0x%p entering not power policy owner state "
            "%!WDF_DEVICE_POWER_POLICY_STATE! from "
            "%!WDF_DEVICE_POWER_POLICY_STATE!", m_Device->GetHandle(),
            m_Device->GetDeviceObject(), newState, currentState);
 
        if (m_PowerPolicyStateCallbacks != NULL) {
            //
            // Callback for leaving the old state
            //
            RtlZeroMemory(&data, sizeof(data));
 
            data.Type = StateNotificationLeaveState;
            data.Data.LeaveState.CurrentState = currentState;
            data.Data.LeaveState.NewState = newState;
 
            m_PowerPolicyStateCallbacks->Invoke(currentState,
                                                StateNotificationLeaveState,
                                                m_Device->GetHandle(),
                                                &data);
        }
 
        m_PowerPolicyMachine.m_States.History[
            m_PowerPolicyMachine.IncrementHistoryIndex()] = (USHORT) newState;
 
        if (m_PowerPolicyStateCallbacks != NULL) {
            //
            // Callback for entering the new state
            //
            RtlZeroMemory(&data, sizeof(data));
 
            data.Type = StateNotificationEnterState;
            data.Data.EnterState.CurrentState = currentState;
            data.Data.EnterState.NewState = newState;
 
            m_PowerPolicyStateCallbacks->Invoke(newState,
                                                StateNotificationEnterState,
                                                m_Device->GetHandle(),
                                                &data);
        }
 
        m_Device->SetDevicePowerPolicyState(newState);
        currentState = newState;
 
        entry = GetNotPowerPolicyOwnerTableEntry(currentState);
 
        //
        // Call the state handler, if there is one.
        //
        if (entry->StateFunc != NULL) {
            newState = entry->StateFunc(this);
        }
        else {
            newState = WdfDevStatePwrPolNull;
        }
 
        if (m_PowerPolicyStateCallbacks != NULL) {
            //
            // Callback for post processing the new state
            //
            RtlZeroMemory(&data, sizeof(data));
 
            data.Type = StateNotificationPostProcessState;
            data.Data.PostProcessState.CurrentState = currentState;
 
            m_PowerPolicyStateCallbacks->Invoke(currentState,
                                                StateNotificationPostProcessState,
                                                m_Device->GetHandle(),
                                                &data);
        }
    }
}

Referenced by PowerPolicyProcessEventInner().

NotPowerPolOwnerGotoD0()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::NotPowerPolOwnerGotoD0 ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 419 of file notpowerpolicyownerstatemachine.cpp.

{
    This->PowerProcessEvent(PowerCompleteD0);
    return WdfDevStatePwrPolNull;
}

NotPowerPolOwnerGotoD0InD0()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::NotPowerPolOwnerGotoD0InD0 ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 428 of file notpowerpolicyownerstatemachine.cpp.

{
    This->PowerProcessEvent(PowerCompleteD0);
    return WdfDevStatePwrPolNull;
}

NotPowerPolOwnerGotoDx()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::NotPowerPolOwnerGotoDx ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 401 of file notpowerpolicyownerstatemachine.cpp.

{
    This->PowerProcessEvent(PowerCompleteDx);
    return WdfDevStatePwrPolNull;
}

NotPowerPolOwnerGotoDxInDx()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::NotPowerPolOwnerGotoDxInDx ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 410 of file notpowerpolicyownerstatemachine.cpp.

{
    This->PowerProcessEvent(PowerCompleteDx);
    return WdfDevStatePwrPolNull;
}

NotPowerPolOwnerRemoved()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::NotPowerPolOwnerRemoved ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 571 of file notpowerpolicyownerstatemachine.cpp.

{
    //
    // Since we are not the power policy owner, there is nothing to be done.
    // Indicate to the PNP state machine that we are ready for removal.
    //
    This->PnpProcessEvent(PnpEventPwrPolRemoved);
    return WdfDevStatePwrPolNull;
}

NotPowerPolOwnerStarted()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::NotPowerPolOwnerStarted ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 379 of file notpowerpolicyownerstatemachine.cpp.

{
    This->PnpProcessEvent(PnpEventPwrPolStarted);
    return WdfDevStatePwrPolStartingSucceeded;
}

NotPowerPolOwnerStarting()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::NotPowerPolOwnerStarting ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 357 of file notpowerpolicyownerstatemachine.cpp.

{
    This->PowerProcessEvent(PowerImplicitD0);
    return WdfDevStatePwrPolNull;
}

NotPowerPolOwnerStartingFailed()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::NotPowerPolOwnerStartingFailed ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 481 of file notpowerpolicyownerstatemachine.cpp.

{
    This->PnpProcessEvent(PnpEventPwrPolStartFailed);
    return WdfDevStatePwrPolNull;
}

NotPowerPolOwnerStopping()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::NotPowerPolOwnerStopping ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 437 of file notpowerpolicyownerstatemachine.cpp.

{
    This->PowerProcessEvent(PowerImplicitD3);
    return WdfDevStatePwrPolStoppingWaitingForImplicitPowerDown;
}

NotPowerPolOwnerStoppingFailed()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::NotPowerPolOwnerStoppingFailed ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 503 of file notpowerpolicyownerstatemachine.cpp.

{
    This->PnpProcessEvent(PnpEventPwrPolStopFailed);
    return WdfDevStatePwrPolStopped;
}

NotPowerPolOwnerStoppingPoweringDown()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::NotPowerPolOwnerStoppingPoweringDown ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 548 of file notpowerpolicyownerstatemachine.cpp.

{
    This->PowerProcessEvent(PowerCompleteDx);
    return WdfDevStatePwrPolNull;
}

NotPowerPolOwnerStoppingPoweringUp()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::NotPowerPolOwnerStoppingPoweringUp ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 525 of file notpowerpolicyownerstatemachine.cpp.

{
    This->PowerProcessEvent(PowerCompleteD0);
    return WdfDevStatePwrPolNull;
}

NotPowerPolOwnerStoppingSendStatus()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::NotPowerPolOwnerStoppingSendStatus ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 459 of file notpowerpolicyownerstatemachine.cpp.

{
    This->PnpProcessEvent(PnpEventPwrPolStopped);
    return WdfDevStatePwrPolStopped;
}

PnpAssignInterruptsSyncIrql()

VOID FxPkgPnp::PnpAssignInterruptsSyncIrql ( VOID  )

protected

Definition at line 4097 of file pnpstatemachine.cpp.

{
    PLIST_ENTRY ple;
    FxInterrupt* pInterrupt;
 
    for (ple = m_InterruptListHead.Flink;
         ple != &m_InterruptListHead;
         ple = ple->Flink) {
 
        KIRQL syncIrql;
 
        pInterrupt = CONTAINING_RECORD(ple, FxInterrupt, m_PnpList);
 
        syncIrql = pInterrupt->GetResourceIrql();
 
        if (syncIrql == PASSIVE_LEVEL) {
            //
            // The irql associated with the resources assigned is passive,
            // this can happen in the following scenarios:
            //
            // (1)  no resources were assigned.  Skip this interrupt b/c it has
            //      no associated resources. Note: setting the SynchronizeIrql
            //      to PASSIVE_LEVEL is a no-op.
            //
            // (2) this interrupt is handled at passive-level.
            //      Set SynchronizeIrql to passive-level and continue.
            //
            pInterrupt->SetSyncIrql(PASSIVE_LEVEL);
            continue;
        }
 
        if (pInterrupt->IsSharedSpinLock() == FALSE) {
            //
            // If the interrupt spinlock is not shared, it's sync irql is the
            // irql assigned to it in the resources.
            //
            pInterrupt->SetSyncIrql(syncIrql);
        }
        else if (pInterrupt->IsSyncIrqlSet() == FALSE) {
            FxInterrupt* pFwdInterrupt;
            PLIST_ENTRY pleFwd;
 
            //
            // Find all of the other interrupts which share the lock and compute
            // the max sync irql.
            //
            for (pleFwd = ple->Flink;
                 pleFwd != &m_InterruptListHead;
                 pleFwd = pleFwd->Flink) {
 
                pFwdInterrupt = CONTAINING_RECORD(pleFwd, FxInterrupt, m_PnpList);
 
                //
                // If the 2 do not share the same lock, they are not in the same
                // set.
                //
                if (pFwdInterrupt->SharesLock(pInterrupt) == FALSE) {
                    continue;
                }
 
                if (pFwdInterrupt->GetResourceIrql() > syncIrql) {
                    syncIrql = pFwdInterrupt->GetResourceIrql();
                }
            }
 
            //
            // Now that we found the max sync irql, set it for all interrupts in
            // the set which share the lock
            //
            for (pleFwd = ple->Flink;
                 pleFwd != &m_InterruptListHead;
                 pleFwd = pleFwd->Flink) {
 
                pFwdInterrupt = CONTAINING_RECORD(pleFwd, FxInterrupt, m_PnpList);
 
                //
                // If the 2 do not share the same lock, they are not in the same
                // set.
                //
                if (pFwdInterrupt->SharesLock(pInterrupt) == FALSE) {
                    continue;
                }
 
                pFwdInterrupt->SetSyncIrql(syncIrql);
            }
 
            //
            // Set the sync irql for the first interrupt in the set.  We have set
            // the sync irql for all other interrupts in the set.
            //
            pInterrupt->SetSyncIrql(syncIrql);
        }
        else {
            //
            // If IsSyncIrqlSet is TRUE, we already covered this interrupt in a
            // previous pass of this loop when we computed the max sync irql for
            // an interrupt set.
            //
            ASSERT(pInterrupt->GetSyncIrql() > PASSIVE_LEVEL);
            DO_NOTHING();
        }
    }
}

Referenced by __drv_when().

PnpCheckAndIncrementRestartCount()

BOOLEAN FxPkgPnp::PnpCheckAndIncrementRestartCount ( VOID  )

private

Definition at line 39 of file pnpstatemachinekm.cpp.

{
    NTSTATUS status;
    FxAutoRegKey settings, restart;
    ULONG disposition = 0;
 
    DECLARE_CONST_UNICODE_STRING(keyNameRestart, L"Restart");
 
    status = m_Device->OpenSettingsKey(&settings.m_Key);
    if (!NT_SUCCESS(status)) {
        return FALSE;
    }
 
    //
    // We ask for a volatile key so that upon reboot, the count is purged and we
    // start a new fresh restart count.
    //
    status = FxRegKey::_Create(settings.m_Key,
                               &keyNameRestart,
                               &restart.m_Key,
                               KEY_ALL_ACCESS,
                               REG_OPTION_VOLATILE,
                               &disposition);
    if (!NT_SUCCESS(status)) {
        return FALSE;
    }
 
    return PnpIncrementRestartCountLogic(restart.m_Key,
                                         disposition == REG_CREATED_NEW_KEY);
}

PnpCheckAssumptions()

VOID FxPkgPnp::PnpCheckAssumptions ( VOID  )

private

Definition at line 752 of file pnpstatemachine.cpp.

{
    WDFCASSERT(sizeof(FxPnpStateInfo) == sizeof(ULONG));
 
    WDFCASSERT((sizeof(m_WdfPnpStates)/sizeof(m_WdfPnpStates[0]))
               ==
               (WdfDevStatePnpNull - WdfDevStatePnpObjectCreated));
 
    // we assume these are the same length when we update the history index
    WDFCASSERT((sizeof(m_PnpMachine.m_Queue)/sizeof(m_PnpMachine.m_Queue[0]))
               ==
               (sizeof(m_PnpMachine.m_States.History)/
                sizeof(m_PnpMachine.m_States.History[0])));
}

PnpCleanupForRemove()

VOID FxPkgPnp::PnpCleanupForRemove ( __in BOOLEAN  GracefulRemove )

private

Definition at line 2210 of file pnpstatemachine.cpp.

{
    //
    // Disable WMI.
    //
    m_Device->WmiPkgDeregister();
 
    //
    // Disable any device interfaces.
    //
    PnpDisableInterfaces();
 
    DeleteSymbolicLinkOverload(GracefulRemove);
 
 
 
 
 
 
 
 
    // Flush/purge top-edge queues
    m_Device->m_PkgIo->StopProcessingForPower(
        FxIoStopProcessingForPowerPurgeManaged
        );
 
    //
    // Invoke EvtDeviceSelfManagedIoFlush
    //
    if (m_SelfManagedIoMachine != NULL) {
        m_SelfManagedIoMachine->Flush();
    }
 
    //
    // Tell all the resource objects that they no longer own anything.
    //
    NotifyResourceobjectsToReleaseResources();
 
    //
    // Flush persistent state to permanent storage.  We do this in the failed
    // state for the surprise removed case.  By storing the state when we are
    // surprise removed, if the stack is reenumerated, it will pick up the saved
    // state that was just committed.  If the state was saved during remove
    // device it can be too late because the new instance of the same device
    // could already be up and running and not pick up the saved state.
    //
    // It is important to save the state before completing the (potentially)
    // pended pnp irp.  Completing the pnp irp will allow a new instance of the
    // device to be enumerated and we want to save state before that happens.
    //
    SaveState(FALSE);
 
    if (m_SharedPower.m_WaitWakeOwner) {
        //
        // Don't care about the return code, just blindly try to complete the
        // wake request.  The function can handle the case where there is no
        // irp to complete.
        //
        (void) PowerIndicateWaitWakeStatus(STATUS_NO_SUCH_DEVICE);
    }
}

PnpDeviceUsageNotification()

_Must_inspect_result_ NTSTATUS FxPkgPnp::PnpDeviceUsageNotification ( __inout FxIrp *  Irp )

protected

Definition at line 3867 of file fxpkgpnp.cpp.

{
    FxRelatedDeviceList* pList;
    FxRelatedDevice *pDependent;
    FxAutoIrp relatedIrp(NULL), parentIrp(NULL);
    MxDeviceObject topOfParentStack;
    DEVICE_USAGE_NOTIFICATION_TYPE type;
    NTSTATUS status;
    MxDeviceObject pAttached;
    MdIrp pNewIrp;
    CCHAR maxStack;
    BOOLEAN inPath, supported;
    ULONG oldFlags;
    MxAutoWorkItem workItem;
 
    DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
                        "Entering DeviceUsageNotification handler");
 
    status = STATUS_SUCCESS;
 
    type = Irp->GetParameterUsageNotificationType();
    inPath = Irp->GetParameterUsageNotificationInPath();
    supported = FALSE;
 
    DoTraceLevelMessage(
        GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
        "type %x, in path %x, can support paging %x, dump file %x, "
        "hiber file %x, boot file %x",
        type, inPath,
        IsUsageSupported(_SpecialTypeToUsage(WdfSpecialFilePaging)),
        IsUsageSupported(_SpecialTypeToUsage(WdfSpecialFileDump)),
        IsUsageSupported(_SpecialTypeToUsage(WdfSpecialFileHibernation)),
        IsUsageSupported(_SpecialTypeToUsage(WdfSpecialFileBoot)));
 
 
    if (type >= static_cast<DEVICE_USAGE_NOTIFICATION_TYPE>(WdfSpecialFilePaging)
        && type < static_cast<DEVICE_USAGE_NOTIFICATION_TYPE>(WdfSpecialFileMax)) {
        if (inPath) {
            if (m_Device->IsFilter()) {
                //
                // Filters always support usage notifications
                //
                supported = TRUE;
            }
            else {
                supported = IsUsageSupported(type);
            }
        }
        else {
            //
            // We always handle notifications where we are out of the path
            //
            supported = TRUE;
        }
    }
 
    if (supported == FALSE) {
        status = STATUS_NOT_IMPLEMENTED;
 
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
            "Usage type %x not supported, %!STATUS!", type, status);
 
        return CompletePnpRequest(Irp, status);
    }
 
    //
    // Usage notification IRP gets forwarded to parent stack or to
    // dependent stack. Since in such cases (with deep device tree) the stack
    // may run out quickly, ensure there is enough stack, otherwise use a
    // workitem.
    //
    if (Mx::MxHasEnoughRemainingThreadStack() == FALSE &&
        (m_Device->IsPdo() ||
        m_UsageDependentDeviceList != NULL)) {
 
        status = workItem.Allocate(m_Device->GetDeviceObject());
        if (!NT_SUCCESS(status)) {
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                "WDFDEVICE %p !devobj %p could not allocate workitem "
                "to send usage notification type %d, inpath %d, %!STATUS!",
                m_Device->GetHandle(),
                m_Device->GetDeviceObject(),
                type, inPath, status);
 
            return CompletePnpRequest(Irp, status);
        }
    }
 
    //
    // Usage notification is supported.  Set the flags on the device object
    // before processing this any further and save the current flags on the
    // device object.
    //
    oldFlags = SetUsageNotificationFlags(type, inPath);
 
    if (m_Device->IsPdo()) {
 
 
 
 
 
 
 
 
 
 
 
 
        topOfParentStack.SetObject(
            m_Device->m_ParentDevice->GetAttachedDeviceReference());
 
        pNewIrp = FxIrp::AllocateIrp(topOfParentStack.GetStackSize());
        if (pNewIrp != NULL) {
            parentIrp.SetIrp(pNewIrp);
 
            //
            // parentIrp now owns the irp
            //
            pNewIrp = NULL;
 
            status = SendDeviceUsageNotification(&topOfParentStack,
                                                 &parentIrp,
                                                 &workItem,
                                                 Irp,
                                                 FALSE);
        }
        else {
            status = STATUS_INSUFFICIENT_RESOURCES;
 
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                "WDFDEVICE %p could not allocate PIRP for parent !devobj %p to "
                "send usage notification type %d, inpath %d, %!STATUS!",
                m_Device->GetHandle(), topOfParentStack.GetObject(),
                type, inPath, status);
        }
        topOfParentStack.DereferenceObject();
        topOfParentStack.SetObject(NULL);
 
        if (!NT_SUCCESS(status)) {
            DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
                                "Exit %!STATUS!", status);
 
            RevertUsageNotificationFlags(type, inPath, oldFlags);
            return CompletePnpRequest(Irp, status);
        }
    }
 
    maxStack = 0;
    pDependent = NULL;
 
    //
    // If the driver supports the given special file, lets notify dependent
    // stacks.
    //
 
    //
    // LockForEnum will lock out new changes to the list until we unlock the list.
    // We remain at passive level once we are locked.
    //
    if (m_UsageDependentDeviceList != NULL) {
        //
        // We capture the m_UsageDependentDeviceList pointer value so that we
        // always use the same pointer value and that we have matched actions
        // (lock for enum / unlock from enum).  What we are trying to avoid is
        // this:
        // 1) we do not lock for enum because m_UsageDependentDeviceList == NULL
        // 2) in the middle of this function, m_UsageDependentDeviceList is
        //    assigned a pointer value
        // 3) we try to unlock from enum later (or iterate, thinking the enum
        //    lock is held) by checking m_UsageDependentDeviceList for NULL, and
        //    now that is != NULL, use it.
        //
        // By capturing the pointer now, we either have a list or not and we don't
        // hit situations 2 or 3.  So, the rule is every subseqeunt time we need
        // to check if there is valid m_UsageDependentDeviceList pointer, we
        // use pList, but when we use the list, we can use m_UsageDependentDeviceList
        // directly.
        //
        pList = m_UsageDependentDeviceList;
 
        m_UsageDependentDeviceList->LockForEnum(GetDriverGlobals());
 
        while ((pDependent = m_UsageDependentDeviceList->GetNextEntry(pDependent)) != NULL) {
 
            MxDeviceObject deviceObject(pDependent->GetDevice());
 
 
 
 
 
 
 
 
 
 
 
 
 
            pAttached.SetObject(deviceObject.GetAttachedDeviceReference());
 
            if (pAttached.GetStackSize() > maxStack) {
                maxStack = pAttached.GetStackSize();
            }
 
            pAttached.DereferenceObject();
        }
    }
    else {
        pList = NULL;
    }
 
    if (maxStack > 0) {
        //
        // If we have a maxStack size, we have a list as well
        //
        ASSERT(m_UsageDependentDeviceList != NULL);
 
        //
        // Allocate one irp for all the stacks so that we don't have an
        // allocation later.  This way, once we have the irp, we can send the
        // usage notification to all stacks reliably, as well as the reverting
        // of the notification if we encounter failure.
        //
        pNewIrp = FxIrp::AllocateIrp(maxStack);
        if (pNewIrp == NULL) {
            status = STATUS_INSUFFICIENT_RESOURCES;
 
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                "WDFDEVICE %p could not allocate IRP to send usage notifications"
                " to related stacks, type %d, inpath %d, status %!STATUS!",
                m_Device->GetHandle(), type, inPath, status);
        }
        else {
            MxDeviceObject dependentDevice;
 
            //
            // relatedIrp will free the irp when it goes out of scope
            //
            relatedIrp.SetIrp(pNewIrp);
 
            //
            // Walk our collection of dependent device stacks, and notify
            // each stack of the device notification.  If any fail, notify
            // the stacks who already were told of the reverted behavior.
            //
            pDependent = NULL;
            while ((pDependent = m_UsageDependentDeviceList->GetNextEntry(pDependent)) != NULL) {
                dependentDevice.SetObject(pDependent->GetDevice());
                status = SendDeviceUsageNotification(&dependentDevice,
                                                     &relatedIrp,
                                                     &workItem,
                                                     Irp,
                                                     FALSE);
 
                if (!NT_SUCCESS(status)) {
                    FxRelatedDevice* pDependent2;
 
                    pDependent2 = NULL;
 
                    //
                    // A device failed the device usage notification request.
                    // Notify the stacks that didn't fail, so they can unwind
                    // the operation.
                    //
                    while ((pDependent2 = m_UsageDependentDeviceList->GetNextEntry(pDependent2)) != NULL &&
                           pDependent2 != pDependent) {
                        dependentDevice.SetObject(pDependent2->GetDevice());
 
                        //
                        // We're already in a failure path. We can't do anything
                        // about yet another failure. So we ignore the return
                        // value.
                        //
                        (void) SendDeviceUsageNotification(&dependentDevice,
                                                           &relatedIrp,
                                                           &workItem,
                                                           Irp,
                                                           TRUE);
                    }
 
                    //
                    // Now break out of our outter loop.
                    //
                    break;
                }
            }
        }
    }
 
    //
    // If we are successful to this point, then send the IRP down the
    // stack.
    //
    if (NT_SUCCESS(status)) {
        BOOLEAN referenceSucceeded, sendDown;
 
        referenceSucceeded = FALSE;
        sendDown = TRUE;
 
        //
        // Make sure the stack is in D0 before sending down the request.  This
        // will at least guarantee that all devices below this one are in D0
        // when the make the transition from power pageable to non or vice versa.
        //
        if (IsPowerPolicyOwner()) {
            status = PowerReference(TRUE);
 
            if (NT_SUCCESS(status)) {
                referenceSucceeded = TRUE;
            }
            else {
                Irp->SetStatus(status);
                sendDown = FALSE;
            }
        }
 
        if (sendDown) {
            //
            // If we supported the usage, set the status to success, otherwise we
            // keep the status in the irp as it arrived to this device
            //
            if (supported) {
                Irp->SetStatus(status);
            }
            status = SendIrpSynchronously(Irp);
        }
 
        //
        // Transitioning from a thread which was power pagable to non power
        // pagable.  We now need a power thread for the stack, ask for it.
        // Note that there is no need for power thread in case of "boot"
        // notification since boot notification doesn't require clearing device's
        // DO_POWER_PAGABLE flag (power thread is required when handling power
        // irp at dispatch level which can happen if the DO_POWER_PAGABLE flag
        // is cleared).
        //
        // NOTE:  Once we have a power thread, we never go back to using work
        //        items even though the stack may revert to power pagable.
        //        This is an acceptable tradeoff between resource usage and
        //        WDF complexity.
        //
        //
        if (NT_SUCCESS(status) &&
            inPath &&
            (HasPowerThread() == FALSE) &&
            type != static_cast<DEVICE_USAGE_NOTIFICATION_TYPE>(WdfSpecialFileBoot)
            ) {
            status = QueryForPowerThread();
 
            if (!NT_SUCCESS(status)) {
                //
                // Keep status the same through out so we can set it back in
                // the irp when we are done.
                //
                if (m_Device->IsPdo()) {
                    //
                    // need to revert our parent's stack
                    //
 
 
 
 
 
 
 
 
 
 
 
 
                    topOfParentStack.SetObject(
                        m_Device->m_ParentDevice->GetAttachedDeviceReference());
 
                    //
                    // Ignore the status because we can't do anything on failure
                    //
                    (void) SendDeviceUsageNotification(&topOfParentStack,
                                                       &parentIrp,
                                                       &workItem,
                                                       Irp,
                                                       TRUE);
 
                    topOfParentStack.DereferenceObject();
                }
                else {
                    //
                    // Notify the stack below us
                    //
                    Irp->CopyCurrentIrpStackLocationToNext();
                    Irp->SetParameterUsageNotificationInPath(FALSE);
 
                    //
                    // Required for pnp irps
                    //
                    Irp->SetStatus(STATUS_NOT_SUPPORTED);
 
                    //
                    // Ignore the status because we can't do anything on failure
                    //
                    (void) Irp->SendIrpSynchronously(m_Device->GetAttachedDevice());
                }
 
                Irp->SetStatus(status);
            }
        }
 
        //
        // Now check whether the lower devices succeeded or failed.  If they
        // failed, back out our changes and propogate the failure.
        //
        if (!NT_SUCCESS(status)) {
            //
            // Revert the flags set on the device object.
            //
            RevertUsageNotificationFlags(type, inPath, oldFlags);
 
            //
            // Notify dependent stacks of the failure.
            //
            pDependent = NULL;
 
            //
            // See pList initiatilazation as to why we compare pList for != NULL
            // and not m_UsageDependentDeviceList.
            //
            if (pList != NULL) {
                MxDeviceObject dependentDevice;
 
                while ((pDependent = m_UsageDependentDeviceList->GetNextEntry(pDependent)) != NULL) {
                    dependentDevice.SetObject(pDependent->GetDevice());
 
                    //
                    // We're already in a failure path. We can't do anything
                    // about yet another failure. So we ignore the return value.
                    //
                    (void) SendDeviceUsageNotification(&dependentDevice,
                                                       &relatedIrp,
                                                       &workItem,
                                                       Irp,
                                                       TRUE);
                }
            }
        }
 
        //
        // By this point, we have propagated the notification to dependent devices
        // and lower stack, and if anyone failed during that time, we also
        // propagated failure to dependent stacks and lower stack.
        // If status is success at this point, invoke the driver's callback.
        //
        if (NT_SUCCESS(status)) {
            //
            // Invoke callback. Note that only one of the callbacks
            // DeviceUsageNotification or DeviceUsgeNotificationEx will get
            // invoked since only one of the callbacks at a time is supported.
            // We ensured that during registration of the callback.
            // Note that Ex callback will return success if driver did not
            // supply any callback.
            //
            m_DeviceUsageNotification.Invoke(m_Device->GetHandle(),
                                             _UsageToSpecialType(type),
                                             inPath);
 
            status = m_DeviceUsageNotificationEx.Invoke(
                                        m_Device->GetHandle(),
                                        _UsageToSpecialType(type),
                                        inPath
                                        );
 
            if (!NT_SUCCESS(status)) {
                //
                // Driver's callback returned failure. We need to propagate
                // failure to lower stack and dependent stacks.
                //
                //
                // Keep status the same through out so we can set it back in
                // the irp when we are done.
                //
                if (m_Device->IsPdo()) {
                    //
                    // need to revert our parent's stack
                    //
 
 
 
 
 
 
 
 
 
 
 
 
                    topOfParentStack.SetObject(
                        m_Device->m_ParentDevice->GetAttachedDeviceReference());
 
                    //
                    // Ignore the status because we can't do anything on failure
                    //
                    (void) SendDeviceUsageNotification(&topOfParentStack,
                                                       &parentIrp,
                                                       &workItem,
                                                       Irp,
                                                       TRUE);
 
                    topOfParentStack.DereferenceObject();
                }
                else {
                    //
                    // Notify the stack below us
                    //
                    Irp->CopyCurrentIrpStackLocationToNext();
                    Irp->SetParameterUsageNotificationInPath(FALSE);
 
                    //
                    // Required for pnp irps
                    //
                    Irp->SetStatus(STATUS_NOT_SUPPORTED);
 
                    //
                    // Ignore the status because we can't do anything on failure
                    //
                    (void) Irp->SendIrpSynchronously(m_Device->GetAttachedDevice());
                }
 
                Irp->SetStatus(status);
 
                //
                // Revert the flags set on the device object.
                //
                RevertUsageNotificationFlags(type, inPath, oldFlags);
 
                //
                // Notify dependent stacks of the failure.
                //
                pDependent = NULL;
 
                //
                // See pList initiatilazation as to why we compare pList for != NULL
                // and not m_UsageDependentDeviceList.
                //
                if (pList != NULL) {
                    MxDeviceObject dependentDevice;
 
                    while ((pDependent = m_UsageDependentDeviceList->GetNextEntry(pDependent)) != NULL) {
                        dependentDevice.SetObject(pDependent->GetDevice());
 
                        //
                        // We're already in a failure path. We can't do anything
                        // about yet another failure. So we ignore the return value.
                        //
                        (void) SendDeviceUsageNotification(&dependentDevice,
                                                           &relatedIrp,
                                                           &workItem,
                                                           Irp,
                                                           TRUE);
                    }
                }
            }
 
            if (NT_SUCCESS(status)) {
 
                CommitUsageNotification(type, oldFlags);
 
                //
                // If we are in the dump file path, we cannot idle out because we
                // can experience a crash dump at any time.
                //
                if (IsPowerPolicyOwner() && type == DeviceUsageTypeDumpFile) {
                    //
                    // Add a reference everytime we are notified of being in the
                    // path, no need to match the first inPath notification and the
                    // last !inPath notification.
                    //
                    if (inPath) {
                        NTSTATUS refStatus;
 
                        ASSERT(GetUsageCount(type) > 0);
 
                        //
                        // Since our previous synchronous power reference succeeded,
                        // an addtional reference while we are powered up should
                        // never fail.
                        //
                        refStatus = PowerReference(FALSE);
#if DBG
                        ASSERT(NT_SUCCESS(refStatus));
#else
                        UNREFERENCED_PARAMETER(refStatus);
#endif
                    }
                    else {
                        ASSERT(GetUsageCount(type) >= 0);
                        PowerDereference();
                    }
                }
            }
        }
 
        //
        // We no longer need to be in D0 if we don't have to be.
        //
        if (referenceSucceeded) {
            ASSERT(IsPowerPolicyOwner());
            PowerDereference();
        }
    }
 
    //
    // See pList initiatilazation as to why we compare pList for != NULL
    // and not m_UsageDependentDeviceList.
    //
    if (pList != NULL) {
        m_UsageDependentDeviceList->UnlockFromEnum(GetDriverGlobals());
    }
 
    DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
                        "Exit %!STATUS!", status);
 
    return CompletePnpRequest(Irp, status);
}

PnpDisableInterfaces()

VOID FxPkgPnp::PnpDisableInterfaces ( VOID  )

protected

Definition at line 3822 of file pnpstatemachine.cpp.

{
    PSINGLE_LIST_ENTRY ple;
 
    m_DeviceInterfaceLock.AcquireLock(GetDriverGlobals());
 
    m_DeviceInterfacesCanBeEnabled = FALSE;
 
    for (ple = m_DeviceInterfaceHead.Next; ple != NULL; ple = ple->Next) {
 
        FxDeviceInterface *pDeviceInterface;
        pDeviceInterface = FxDeviceInterface::_FromEntry(ple);
        pDeviceInterface->SetState(FALSE);
    }
 
    m_DeviceInterfaceLock.ReleaseLock(GetDriverGlobals());
}

Referenced by PnpCleanupForRemove().

PnpEnableInterfacesAndRegisterWmi()

_Must_inspect_result_ NTSTATUS FxPkgPnp::PnpEnableInterfacesAndRegisterWmi ( VOID  )

protected

Definition at line 3412 of file pnpstatemachine.cpp.

{
    PSINGLE_LIST_ENTRY ple;
    NTSTATUS status;
 
    status = STATUS_SUCCESS;
 
    //
    // Enable any device interfaces.
    //
    m_DeviceInterfaceLock.AcquireLock(GetDriverGlobals());
 
    m_DeviceInterfacesCanBeEnabled = TRUE;
 
    for (ple = m_DeviceInterfaceHead.Next; ple != NULL; ple = ple->Next) {
        FxDeviceInterface *pDeviceInterface;
 
        pDeviceInterface = FxDeviceInterface::_FromEntry(ple);
 
 
 
 
 
 
#if (FX_CORE_MODE == FX_CORE_KERNEL_MODE)
        //
        // By this time, the device interface, no matter what the WDFDEVICE role
        // will have been registered.
        //
        ASSERT(pDeviceInterface->m_SymbolicLinkName.Buffer != NULL);
#endif
        pDeviceInterface->SetState(TRUE);
 
        status = STATUS_SUCCESS;
    }
 
    m_DeviceInterfaceLock.ReleaseLock(GetDriverGlobals());
 
    if (NT_SUCCESS(status)) {
        status = m_Device->WmiPkgRegister();
    }
 
    if (!NT_SUCCESS(status)) {
        SetInternalFailure();
        SetPendingPnpIrpStatus(status);
    }
 
    return status;
}

PnpEnterNewState()

VOID FxPkgPnp::PnpEnterNewState ( __in WDF_DEVICE_PNP_STATE  State )

protected

Definition at line 1156 of file pnpstatemachine.cpp.

{
    CPPNP_STATE_TABLE    entry;
    WDF_DEVICE_PNP_STATE currentState, newState;
    WDF_DEVICE_PNP_NOTIFICATION_DATA data;
 
    currentState = m_Device->GetDevicePnpState();
    newState = State;
 
    while (newState != WdfDevStatePnpNull) {
        DoTraceLevelMessage(
             GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGPNPPOWERSTATES,
             "WDFDEVICE 0x%p !devobj 0x%p entering PnP State "
             "%!WDF_DEVICE_PNP_STATE! from %!WDF_DEVICE_PNP_STATE!",
             m_Device->GetHandle(),
             m_Device->GetDeviceObject(),
             newState,
             currentState);
 
        if (m_PnpStateCallbacks != NULL) {
            //
            // Callback for leaving the old state
            //
            RtlZeroMemory(&data, sizeof(data));
 
            data.Type = StateNotificationLeaveState;
            data.Data.LeaveState.CurrentState = currentState;
            data.Data.LeaveState.NewState = newState;
 
            m_PnpStateCallbacks->Invoke(currentState,
                                        StateNotificationLeaveState,
                                        m_Device->GetHandle(),
                                        &data);
        }
 
        m_PnpMachine.m_States.History[m_PnpMachine.IncrementHistoryIndex()] =
            (USHORT) newState;
 
        if (m_PnpStateCallbacks != NULL) {
            //
            // Callback for entering the new state
            //
            RtlZeroMemory(&data, sizeof(data));
 
            data.Type = StateNotificationEnterState;
            data.Data.EnterState.CurrentState = currentState;
            data.Data.EnterState.NewState = newState;
 
            m_PnpStateCallbacks->Invoke(newState,
                                        StateNotificationEnterState,
                                        m_Device->GetHandle(),
                                        &data);
        }
 
        m_Device->SetDevicePnpState(newState);
        currentState = newState;
 
        entry = GetPnpTableEntry(currentState);
 
        //
        // Call the state handler if one is present and record our new state
        //
        if (entry->StateFunc != NULL) {
            newState = entry->StateFunc(this);
 
            //
            // Validate the return value if FX_STATE_MACHINE_VERIFY is enabled
            //
            VALIDATE_PNP_STATE(currentState, newState);
        }
        else {
            newState = WdfDevStatePnpNull;
        }
 
        if (m_PnpStateCallbacks != NULL) {
            //
            // Callback for post processing the new state
            //
            RtlZeroMemory(&data, sizeof(data));
 
            data.Type = StateNotificationPostProcessState;
            data.Data.PostProcessState.CurrentState = currentState;
 
            m_PnpStateCallbacks->Invoke(currentState,
                                        StateNotificationPostProcessState,
                                        m_Device->GetHandle(),
                                        &data);
        }
    }
}

Referenced by PnpProcessEventInner().

PnpEventCheckForDevicePresence()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventCheckForDevicePresence ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 1263 of file pnpstatemachine.cpp.

{
    return This->PnpEventCheckForDevicePresenceOverload();
}

PnpEventCheckForDevicePresenceOverload()

virtual WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventCheckForDevicePresenceOverload ( VOID  )

protectedpure virtual

Implemented in FxPkgFdo, and FxPkgPdo.

PnpEventEjectHardware()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventEjectHardware ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 1287 of file pnpstatemachine.cpp.

{
    return This->PnpEventEjectHardwareOverload();
}

PnpEventEjectHardwareOverload()

virtual WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventEjectHardwareOverload ( VOID  )

protectedpure virtual

Implemented in FxPkgFdo, and FxPkgPdo.

PnpEventEnableInterfaces()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventEnableInterfaces ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 1458 of file pnpstatemachine.cpp.

{
    NTSTATUS status;
 
    status = This->PnpEnableInterfacesAndRegisterWmi();
 
    if (!NT_SUCCESS(status)) {
        //
        // Upon failure, PnpEnableInterfacesAndRegisterWmi already marked the
        // irp as failed and recorded an internal error.
        //
        // FailedPowerDown will gracefully tear down the stack and bring it out
        // of D0.
        //
        return WdfDevStatePnpFailedPowerDown;
    }
 
    return WdfDevStatePnpStarted;
}

PnpEventFailed()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventFailed ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 2875 of file pnpstatemachine.cpp.

{
    This->PnpCleanupForRemove(FALSE);
 
    //
    // Tell the power policy state machine to prepare for device removal
    //
    This->PnpPowerPolicyRemove();
 
    return WdfDevStatePnpNull;
}

PnpEventFailedInit()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventFailedInit ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3042 of file pnpstatemachine.cpp.

{
    //
    // Release the power thread that we may have previously acquired in
    // HardwareAvailable.
    //
    This->ReleasePowerThread();
 
    //
    // Deref the reenumeration interface
    //
    This->ReleaseReenumerationInterface();
 
    This->PnpFinishProcessingIrp();
 
    return WdfDevStatePnpInit;
}

PnpEventFailedIoStarting()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventFailedIoStarting ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 2824 of file pnpstatemachine.cpp.

{
    This->PnpPowerPolicySurpriseRemove();
 
    return WdfDevStatePnpNull;
}

PnpEventFailedOwnHardware()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventFailedOwnHardware ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 2848 of file pnpstatemachine.cpp.

{
    //
    // Invoke EvtDeviceReleaseHardware
    //
    (void) This->PnpReleaseHardware();
 
    return WdfDevStatePnpFailed;
}

PnpEventFailedPowerDown()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventFailedPowerDown ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 2788 of file pnpstatemachine.cpp.

{
    //
    // Normal stop so that the power state machine will go through the power off
    // path and not skip directly to off like it would if we sent it a surprise
    // remove notification.
    //
    This->PnpPowerPolicyStop();
 
    return WdfDevStatePnpNull;
}

PnpEventFailedPowerPolicyRemoved()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventFailedPowerPolicyRemoved ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 2904 of file pnpstatemachine.cpp.

{
    //
    // Finish processing any pended PnP IRP.  Since we can reach this state from
    // states where a pnp irp was *not* pended, we do not require a pnp irp to
    // have been pended when trying to complete it.
    //
    This->PnpFinishProcessingIrp(FALSE);
 
    //
    // Request reenumeration if the client driver asked for it or if there was
    // an internal failure *and* if the client driver didn't specify failure...
    // AND if we have not yet exceeded our restart count within a period of time.
    //
    if ((This->m_FailedAction == WdfDeviceFailedAttemptRestart ||
         (This->m_FailedAction == WdfDeviceFailedUndefined && This->m_InternalFailure))
        &&
        This->PnpCheckAndIncrementRestartCount()) {
        //
        // No need to invalidate state because we are in a state waiting for
        // a remove device anyways so failure is imminent.
        //
        This->AskParentToRemoveAndReenumerate();
    }
 
    if (This->m_FailedAction != WdfDeviceFailedUndefined || This->m_InternalFailure) {
        //
        // If the failure occurred in this device, then tear down the stack if
        // we are in a state in which pnp thinks we are started.  If we are
        // already in a stopped state, this invalidation will do no harm.
        //
        MxDeviceObject physicalDeviceObject(
                                This->m_Device->GetPhysicalDevice()
                                );
 
        //
        // We need to pass FDO as a parameter as UMDF currently doesn't have
        // PDOs and instead needs FDO to invalidate device state.
        //
        physicalDeviceObject.InvalidateDeviceState(
            This->m_Device->GetDeviceObject() //FDO
            );
    }
 
    return WdfDevStatePnpFailedWaitForRemove;
}

PnpEventFailedStarted()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventFailedStarted ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3014 of file pnpstatemachine.cpp.

{
    //
    // Complete the pended start irp with error
    //
    This->SetPendingPnpIrpStatus(STATUS_INVALID_DEVICE_STATE);
    This->PnpFinishProcessingIrp();
 
    return WdfDevStatePnpFailedWaitForRemove;
}

PnpEventFailedSurpriseRemoved()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventFailedSurpriseRemoved ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 2967 of file pnpstatemachine.cpp.

{
    //
    // Invoke EvtDeviceSurpriseRemove
    //
    This->m_DeviceSurpriseRemoval.Invoke(This->m_Device->GetHandle());
 
    //
    // Call the overloaded surprise remove handler
    //
    This->PnpEventSurpriseRemovePendingOverload();
 
    //
    // The surprise remove irp was pended, complete it now.  The irp need not
    // be present.  If we failed before the surprise irp was sent and the irp
    // arrived in the middle of processing the failure, we could have completed
    // the s.r. irp in FailedWaitForRemove, which is OK.
    //
    This->PnpFinishProcessingIrp(FALSE);
 
    //
    // Return back to the failed state where will wait for remove
    //
    return WdfDevStatePnpFailedWaitForRemove;
}

PnpEventFdoRemoved()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventFdoRemoved ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 2709 of file pnpstatemachine.cpp.

{
    return This->PnpEventFdoRemovedOverload();
}

PnpEventFdoRemovedOverload()

virtual WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventFdoRemovedOverload ( VOID  )

protectedpure virtual

Implemented in FxPkgFdo, and FxPkgPdo.

PnpEventFinal()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventFinal ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3325 of file pnpstatemachine.cpp.

{
    NTSTATUS status;
 
    //
    // We may not have a pnp irp at this stage (esp for PDO which are in the
    // removed state and whose parent is being removed) so we use the function
    // pointer as the unique tag.
    //
    // IoReleaseRemoveLockAndWait requires an outstanding reference to release,
    // so acquire it before calling it if we are in the case where the PDO is
    // being removed with no outstanding PNP remove irp b/c the parent is being
    // removed.
    //
    if (This->m_DeviceRemoveProcessed == NULL) {
        status = Mx::MxAcquireRemoveLock(
            This->m_Device->GetRemoveLock(),
            (PVOID)&FxPkgPnp::PnpEventFinal);
 
        ASSERT(NT_SUCCESS(status));
        UNREFERENCED_PARAMETER(status);
    }
 
    //
    // Indicate to the parent device that we are removed now (vs the destructor
    // of the object where we would never reach because in the case of the PDO
    // being removed b/c the parent is going away, the parent has a reference
    // on the PDO).
 
 
 
 
 
 
 
    if (This->m_Device->m_ParentWaitingOnChild) {
        (This->m_Device->m_ParentDevice->m_PkgPnp)->ChildRemoved();
    }
 
 
    if (This->m_DeviceRemoveProcessed == NULL) {
        //
        // We can get into this state w/out an event to set when a PDO (this
        // device) is in the removed state and then the parent is removed.
        //
 
        //
        // After this is called, any irp dispatched to FxDevice::DispatchWithLock
        // will fail with STATUS_INVALID_DEVICE_REQUEST.
        //
        Mx::MxReleaseRemoveLockAndWait(
            This->m_Device->GetRemoveLock(),
            (PVOID)&FxPkgPnp::PnpEventFinal);
 
        //
        // Delete the object when we exit the state machine.  Dispose was run
        // early in a previous state.
        //
        This->m_PnpMachine.SetDelayedDeletion();
    }
    else {
        //
        // The thread which received the pnp remove irp will delete the device
        //
        This->m_SetDeviceRemoveProcessed = TRUE;
    }
 
    return WdfDevStatePnpNull;
}

Referenced by PnpEventFinal().

PnpEventHardwareAvailable()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventHardwareAvailable ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 1365 of file pnpstatemachine.cpp.

{
    NTSTATUS status;
    BOOLEAN matched;
 
    status = STATUS_SUCCESS;
    matched = FALSE;
 
    This->QueryForReenumerationInterface();
 
    status = This->CreatePowerThreadIfNeeded();
 
    if (NT_SUCCESS(status)) {
        status = This->PnpPrepareHardware(&matched);
    }
 
    if (!NT_SUCCESS(status)) {
        if (matched == FALSE) {
            //
            // NOTE:  consider going to WdfDevStatePnpFailed instead of yet
            //        another failed state out of start device handling.
            //
 
            //
            // We can handle remove out of the init state, revert back to that
            // state.
            //
            return WdfDevStatePnpFailedInit;
        }
        else {
            //
            // EvtDevicePrepareHardware is what failed, goto a state where we
            // undo that call.
            //
            return WdfDevStatePnpFailedOwnHardware;
        }
    }
 
    //
    // We only query for the capabilities for the power policy owner because
    // we use the capabilities to determine the right Dx state when we want to
    // wake from S0 or Sx.  Since only the power policy owner can enable wake
    // behavior, only the owner needs to query for the information.
    //
    // ALSO, if we are a filter, there are issues in stacks wrt pnp reentrancy.
 
 
 
 
 
 
 
    //
    if (This->IsPowerPolicyOwner()) {
        //
        // Query the stack for capabilities before telling the stack hw is
        // available
        //
        status = This->QueryForCapabilities();
 
        if (!NT_SUCCESS(status)) {
            DoTraceLevelMessage(
                This->GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                "could not query caps for stack, %!STATUS!", status);
 
            This->SetPendingPnpIrpStatus(status);
            return WdfDevStatePnpFailedOwnHardware;
        }
 
        This->m_CapsQueried = TRUE;
    }
 
    This->PnpPowerPolicyStart();
 
    return WdfDevStatePnpNull;
}

PnpEventHardwareAvailablePowerPolicyFailed()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventHardwareAvailablePowerPolicyFailed ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 1498 of file pnpstatemachine.cpp.

{
    This->SetPendingPnpIrpStatus(STATUS_DEVICE_POWER_FAILURE);
 
    return WdfDevStatePnpFailedOwnHardware;
}

PnpEventInitQueryRemove()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventInitQueryRemove ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 2659 of file pnpstatemachine.cpp.

{
    FxIrp irp(This->ClearPendingPnpIrp());
 
    irp.SetStatus(STATUS_SUCCESS);
    This->FireAndForgetIrp(&irp);
 
    return WdfDevStatePnpNull;
}

PnpEventInitQueryRemoveCanceled()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventInitQueryRemoveCanceled ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 2684 of file pnpstatemachine.cpp.

{
    FxIrp irp(This->ClearPendingPnpIrp());
 
    This->FireAndForgetIrp(&irp);
 
    return WdfDevStatePnpInit;
}

PnpEventInitStarting()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventInitStarting ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 1311 of file pnpstatemachine.cpp.

{
    if (This->PnpSendStartDeviceDownTheStackOverload() == FALSE) {
        //
        // Start was sent asynchronously down the stack, the irp's completion
        // routine will move the state machine to the new state.
        //
        return WdfDevStatePnpNull;
    }
 
    return WdfDevStatePnpHardwareAvailable;
}

PnpEventInitSurpriseRemoved()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventInitSurpriseRemoved ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 1340 of file pnpstatemachine.cpp.

{
    This->PnpFinishProcessingIrp(TRUE);
 
    return WdfDevStatePnpInit;
}

PnpEventPdoInitFailed()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventPdoInitFailed ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3075 of file pnpstatemachine.cpp.

{
    COVERAGE_TRAP();
 
 
    This->m_Device->EarlyDispose();
 
    //
    // All the children are in the disposed state, destroy them all.  m_Device
    // is not destroyed in this call.
    //
 
    This->m_Device->DestroyChildren();
 
    return WdfDevStatePnpFinal;
}

PnpEventPdoRemoved()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventPdoRemoved ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 2127 of file pnpstatemachine.cpp.

{
    return This->PnpEventPdoRemovedOverload();
}

PnpEventPdoRemovedOverload()

virtual WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventPdoRemovedOverload ( VOID  )

protectedpure virtual

Implemented in FxPkgFdo, and FxPkgPdo.

PnpEventPdoRestart()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventPdoRestart ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3227 of file pnpstatemachine.cpp.

{
    //
    // Since this is a PDO and it is being restarted, it could have had an internal
    // failure during its previous start.  Since we use m_InternalFailure to set
    // PNP_DEVICE_FAILED when handling IRP_MN_QUERY_PNP_DEVICE_STATE, it should
    // be set to FALSE so we don't immediately fail the device after the start
    // has been succeeded.
    //
    This->m_InternalFailure = FALSE;
    This->m_Failed = FALSE;
 
    //
    // The PDO is being restarted and could have previous had a power thread
    // running.  If so, the reference count goes to zero when removed from a
    // started state.  Reset back to 1.
    //
    This->m_PowerThreadInterfaceReferenceCount = 1;
 
    //
    // The count is decremented on the initial started->removed transition (and
    // not subsequent removed -> removed transitiosn).  On removed -> restarted,
    // we need to set the count back to a bias of 1 so when we process the remove
    // again we can know if there are any pending child (of this PDO) removals
    // that we must wait for.
    //
    This->m_PendingChildCount = 1;
 
    //
    // Reset WMI state
    //
    // This->m_Device->m_PkgWmi->ResetStateForPdoRestart(); __REACTOS__
 
 
    This->m_Device->m_PkgIo->ResetStateForRestart();
 
    if (This->IsPowerPolicyOwner()) {
        This->m_PowerPolicyMachine.m_Owner->m_PowerIdleMachine.Reset();
    }
 
    //
    // Set STATUS_SUCCESS in the irp so that the stack will start smoothly after
    // we have powered up.
    //
    This->SetPendingPnpIrpStatus(STATUS_SUCCESS);
 
    //
    // This flag is set on the wake-enabled device powering down path,
    // but if the device power down failed it may not have been cleared.
    //
    This->m_WakeInterruptsKeepConnected = FALSE;
 
 
    //
    // This flag is cleared so we can reacquire the start time and state
    //
    This->m_AchievedStart = FALSE;
 
    return WdfDevStatePnpHardwareAvailable;
}

PnpEventQueriedRemoving()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventQueriedRemoving ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 1743 of file pnpstatemachine.cpp.

{
    //
    // It is important to stop power policy before releasing the reference.
    // If the reference was released first, we could get into a situation where
    // we immediately go idle and then we must send a D0 irp when in the remove.
    // If there are devices on top of this device and we send a D0 irp during
    // remove processing, the upper devices will be sent an irp after getting a
    // pnp remove (and either crash or fail the power irp upon receiving it).
    //
    This->PnpPowerPolicyStop();
    This->PnpPowerDereferenceSelf();
 
    return WdfDevStatePnpNull;
}

PnpEventQueriedSurpriseRemove()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventQueriedSurpriseRemove ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 2729 of file pnpstatemachine.cpp.

{
    COVERAGE_TRAP();
 
    This->PnpPowerDereferenceSelf();
 
    return WdfDevStatePnpSurpriseRemoveIoStarted;
}

PnpEventQueryCanceled()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventQueryCanceled ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 2060 of file pnpstatemachine.cpp.

{
    This->PnpPowerDereferenceSelf();
 
    return WdfDevStatePnpStarted;
}

PnpEventQueryRemoveAskDriver()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventQueryRemoveAskDriver ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 1523 of file pnpstatemachine.cpp.

{
    WDF_DEVICE_PNP_STATE state;
    NTSTATUS    status;
 
    //
    // First, call the driver.  If it succeeds, look at whether
    // it managed to stop its stuff.
    //
    status = This->m_DeviceQueryRemove.Invoke(This->m_Device->GetHandle());
 
    if (NT_SUCCESS(status)) {
        //
        // The driver has stopped all of its self managed io.  Proceed to
        // stop everything before passing the request down the stack.
        //
        state = WdfDevStatePnpQueryRemoveEnsureDeviceAwake;
    }
    else {
        //
        // The callback didn't manage to stop.  Go back to the Started state
        // where we will complete the pended pnp irp
        //
        DoTraceLevelMessage(
            This->GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
            "EvtDeviceQueryRemove failed, %!STATUS!", status);
 
        if (status == STATUS_NOT_SUPPORTED) {
            DoTraceLevelMessage(
                This->GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                "EvtDeviceQueryRemove returned an invalid status "
                "STATUS_NOT_SUPPORTED");
 
            if (This->GetDriverGlobals()->IsVerificationEnabled(1, 11, OkForDownLevel)) {
                FxVerifierDbgBreakPoint(This->GetDriverGlobals());
            }
        }
 
        state = WdfDevStatePnpStarted;
    }
 
    This->SetPendingPnpIrpStatus(status);
 
    return state;
}

PnpEventQueryRemoveEnsureDeviceAwake()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventQueryRemoveEnsureDeviceAwake ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 1586 of file pnpstatemachine.cpp.

{
    NTSTATUS status;
    WDF_DEVICE_PNP_STATE state;
 
    //
    // Make sure that the device is powered on before we send the query remove
    // on its way.  If we do this after we send the query remove, we could race
    // with the remove which removes the reference and we want the device
    // powered on when processing remove.
    //
    status = This->PnpPowerReferenceDuringQueryPnp();
    if (STATUS_PENDING == status) {
        //
        // Device is transitioning to D0. The Pnp state machine will wait in
        // the current state until the transition is complete
        //
        state = WdfDevStatePnpNull;
    }
    else if (NT_SUCCESS(status)) {
        //
        // Already in D0
        //
        state = WdfDevStatePnpQueryRemovePending;
    }
    else {
        DoTraceLevelMessage(
            This->GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
            "StopIdle on WDFDEVICE %p failed, %!STATUS!, failing query remove",
            This->m_Device->GetHandle(), status);
 
        This->SetPendingPnpIrpStatus(status);
 
        //
        // The Started state will complete the irp when it sees the failure
        // status set on the irp.
        //
        state = WdfDevStatePnpStarted;
    }
 
    return state;
}

PnpEventQueryRemovePending()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventQueryRemovePending ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 1643 of file pnpstatemachine.cpp.

{
    FxIrp irp;
 
    irp.SetIrp(This->ClearPendingPnpIrp());
    (void) This->FireAndForgetIrp(&irp);
    return WdfDevStatePnpNull;
}

PnpEventQueryRemoveStaticCheck()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventQueryRemoveStaticCheck ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 1668 of file pnpstatemachine.cpp.

{
    NTSTATUS status;
    BOOLEAN completeQuery;
 
    completeQuery = TRUE;
 
    if (This->m_DeviceStopCount != 0) {
        DoTraceLevelMessage(
            This->GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGPNP,
            "Failing QueryRemoveDevice because the driver "
            "has indicated that it cannot be stopped, count %d",
            This->m_DeviceStopCount);
 
        status = STATUS_INVALID_DEVICE_STATE;
    }
    else if (This->IsInSpecialUse()) {
        DoTraceLevelMessage(
            This->GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGPNP,
            "Failing QueryRemoveDevice due to open special file counts "
            "(paging %d, hiber %d, dump %d, boot %d)",
            This->GetUsageCount(WdfSpecialFilePaging),
            This->GetUsageCount(WdfSpecialFileHibernation),
            This->GetUsageCount(WdfSpecialFileDump),
            This->GetUsageCount(WdfSpecialFileBoot));
 
        status = STATUS_DEVICE_NOT_READY;
    }
    else {
        //
        // Go on to next state in the "remove" progression.
        //
        completeQuery = FALSE;
        status = STATUS_SUCCESS;
    }
 
    if (completeQuery) {
        //
        // Store the status which Started will complete
        //
        This->SetPendingPnpIrpStatus(status);
 
        //
        // Revert to started
        //
        return WdfDevStatePnpStarted;
    }
    else {
        //
        // Wait for the other state machines to stop
        //
        return WdfDevStatePnpQueryRemoveAskDriver;
    }
}

PnpEventQueryStopAskDriver()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventQueryStopAskDriver ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 1774 of file pnpstatemachine.cpp.

{
    WDF_DEVICE_PNP_STATE state;
    NTSTATUS    status;
 
    //
    // First, call the driver.  If it succeeds, look at whether
    // it managed to stop its stuff.
    //
    status = This->m_DeviceQueryStop.Invoke(This->m_Device->GetHandle());
 
    if (NT_SUCCESS(status)) {
        //
        // Tell the other state machines to stop
        //
        state = WdfDevStatePnpQueryStopEnsureDeviceAwake;
    }
    else {
        DoTraceLevelMessage(
            This->GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
            "EvtDeviceQueryStop failed, %!STATUS!", status);
 
        if (status == STATUS_NOT_SUPPORTED) {
            DoTraceLevelMessage(
                This->GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                "EvtDeviceQueryStop returned an invalid status "
                "STATUS_NOT_SUPPORTED");
 
            if (This->GetDriverGlobals()->IsVerificationEnabled(1, 11, OkForDownLevel)) {
                FxVerifierDbgBreakPoint(This->GetDriverGlobals());
            }
        }
 
        //
        // The callback didn't manage to stop.  Go back to the Started state.
        //
        state = WdfDevStatePnpStarted;
    }
 
    This->SetPendingPnpIrpStatus(status);
 
    return state;
}

PnpEventQueryStopEnsureDeviceAwake()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventQueryStopEnsureDeviceAwake ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 1835 of file pnpstatemachine.cpp.

{
    NTSTATUS status;
    WDF_DEVICE_PNP_STATE state;
 
    //
    // Make sure that the device is powered on before we send the query stop
    // on its way.  If we do this after we send the query stop, we could race
    // with the stop and we want the device powered on when processing stop.
    //
    status = This->PnpPowerReferenceDuringQueryPnp();
    if (STATUS_PENDING == status) {
        //
        // Device is transitioning to D0. The Pnp state machine will wait in
        // the current state until the transition is complete
        //
        state = WdfDevStatePnpNull;
    }
    else if (NT_SUCCESS(status)) {
        //
        // Already in D0
        //
        state = WdfDevStatePnpQueryStopPending;
    }
    else {
        DoTraceLevelMessage(
            This->GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
            "StopIdle on WDFDEVICE %p failed, %!STATUS!, failing query stop",
            This->m_Device->GetHandle(), status);
 
        This->SetPendingPnpIrpStatus(status);
 
        //
        // The Started state will complete the irp when it sees the failure
        // status set on the irp.
        //
        state = WdfDevStatePnpStarted;
    }
 
    return state;
}

PnpEventQueryStopPending()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventQueryStopPending ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 1891 of file pnpstatemachine.cpp.

{
    FxIrp irp;
 
    irp.SetIrp(This->ClearPendingPnpIrp());
    (void) This->FireAndForgetIrp(&irp);
    return WdfDevStatePnpNull;
}

PnpEventQueryStopStaticCheck()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventQueryStopStaticCheck ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 1917 of file pnpstatemachine.cpp.

{
    NTSTATUS status;
    BOOLEAN completeQuery = TRUE;
 
    if (This->m_DeviceStopCount != 0) {
        DoTraceLevelMessage(
            This->GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGPNP,
            "Failing QueryStopDevice because the driver "
            "has indicated that it cannot be stopped, count %d",
            This->m_DeviceStopCount);
 
        status = STATUS_INVALID_DEVICE_STATE;
    }
    else if (This->IsInSpecialUse()) {
        DoTraceLevelMessage(
            This->GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGPNP,
            "Failing QueryStopDevice due to open special file counts (paging %d,"
            " hiber %d, dump %d, boot %d)",
            This->GetUsageCount(WdfSpecialFilePaging),
            This->GetUsageCount(WdfSpecialFileHibernation),
            This->GetUsageCount(WdfSpecialFileDump),
            This->GetUsageCount(WdfSpecialFileBoot));
 
        status = STATUS_DEVICE_NOT_READY;
    }
    else {
        //
        // Go on to next state in the "stop" progression.
        //
        status = STATUS_SUCCESS;
        completeQuery = FALSE;
    }
 
    if (completeQuery) {
        //
        // Set the state which started will complete the request with
        //
        This->SetPendingPnpIrpStatus(status);
 
        //
        // Revert to started
        //
        return WdfDevStatePnpStarted;
    }
    else {
        //
        // Go ask power what the self managed io state is
        //
        return WdfDevStatePnpQueryStopAskDriver;
    }
}

PnpEventRemoved()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventRemoved ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 2083 of file pnpstatemachine.cpp.

{
    //
    // Remove any child PDOs which may still be lingering around.  We do
    // the cleanup here so that we do it only once for the PDO which is being
    // removed (but may stick around) b/c it was not reported as missing.
    //
    //
    // Iterate over all of the reported children
    //
    This->ChildListNotifyRemove(&This->m_PendingChildCount);
 
    //
    // Decrement our bias from when the device was (re)started.  If all of the
    // children removed themselves synchronously, we just move to the cleanup
    // state, otherwise wait for all the children to fully process the remove
    // before remove the parent so that ordering of removal between parent and
    // child is guaranteed (where the order is that all children are cleaned
    // up before the parent is cleaned up).
    //
    if (InterlockedDecrement(&This->m_PendingChildCount) > 0) {
        return WdfDevStatePnpRemovedWaitForChildren;
    }
    else {
        return WdfDevStatePnpRemovedChildrenRemoved;
    }
}

PnpEventRemovedChildrenRemoved()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventRemovedChildrenRemoved ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3304 of file pnpstatemachine.cpp.

{
    return This->PnpGetPostRemoveState();
}

PnpEventRemovedCommonCode()

VOID FxPkgPnp::PnpEventRemovedCommonCode ( VOID  )

protected

Definition at line 1989 of file pnpstatemachine.cpp.

{
    //
    // Purge non power managed queues now
    //
    m_Device->m_PkgIo->StopProcessingForPower(
        FxIoStopProcessingForPowerPurgeNonManaged
        );
 
    if (m_SelfManagedIoMachine != NULL) {
        m_SelfManagedIoMachine->Cleanup();
    }
 
    //
    // Cleanup WMI *after* EvtDeviceSelfManagedIoCleanup b/c we want to cleanup
    // after a well known and documented time.  The WMI docs state that you can
    // register providers and instances all the way through
    // EvtDeviceSelfManagedIoCleanup, so we mark WMI as cleaned up after that
    // call.
    //
    m_Device->WmiPkgCleanup();
 
    //
    // Mark the device as removed.
    //
    m_PnpStateAndCaps.Value &= ~FxPnpStateRemovedMask;
    m_PnpStateAndCaps.Value |= FxPnpStateRemovedTrue;
 
    //
    // Now call the driver and tell it to cleanup all its software state.
    //
    // We do the dispose early here before deleting the object
    // since the PNP remove event is the main trigger for
    // the Dispose chain in the framework.
    //
    // (Almost everything in the driver is rooted on the device object)
    //
 
    m_Device->EarlyDispose();
 
    //
    // All the children are in the disposed state, destroy them all.  m_Device
    // is not destroyed in this call.
    //
 
    m_Device->DestroyChildren();
 
    //
    // Wait for all children to drain out and cleanup.
    //
 
    m_Device->m_DisposeList->WaitForEmpty();
 
}

Referenced by FxPkgFdo::PnpEventFdoRemovedOverload(), and FxPkgPdo::PnpEventPdoRemovedOverload().

PnpEventRemovedPdoSurpriseRemoved()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventRemovedPdoSurpriseRemoved ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 2173 of file pnpstatemachine.cpp.

{
    //
    // Invoke EvtDeviceSurpriseRemove
    //
    This->m_DeviceSurpriseRemoval.Invoke(This->m_Device->GetHandle());
 
    //
    // Call the overloaded surprise remove handler since
    // PnpEventSurpriseRemovePendingOverload will not get called
    //
    This->PnpEventSurpriseRemovePendingOverload();
 
    //
    // The surprise remove irp was pended, complete it now
    //
    This->PnpFinishProcessingIrp();
 
    return WdfDevStatePnpRemovedPdoWait;
}

PnpEventRemovedPdoWait()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventRemovedPdoWait ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 2148 of file pnpstatemachine.cpp.

{
    if (This->m_DeviceRemoveProcessed != NULL) {
        This->m_SetDeviceRemoveProcessed = TRUE;
    }
 
    return WdfDevStatePnpNull;
}

PnpEventRemovingDisableInterfaces()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventRemovingDisableInterfaces ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 2290 of file pnpstatemachine.cpp.

{
    NTSTATUS status;
 
    //
    // Surprise remove path releases hardware first then disables the interfaces,
    // so do the same in the graceful remove path.
    //
 
    //
    // Call the driver and tell it to unmap resources.
    //
    status = This->PnpReleaseHardware();
    if (!NT_SUCCESS(status)) {
        //
        // The driver failed to unmap resources.  Presumably this means that
        // there are now some leaked PTEs.  Just log the failure.
        //
        DoTraceLevelMessage(
            This->GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
            "EvtDeviceReleaseHardware %p failed, %!STATUS!",
            This->m_Device->GetHandle(), status);
    }
 
    This->PnpCleanupForRemove(TRUE);
 
    //
    // Tell the power policy state machine to prepare for device removal
    //
    This->PnpPowerPolicyRemove();
 
    return WdfDevStatePnpNull;
}

PnpEventRestart()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventRestart ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3107 of file pnpstatemachine.cpp.

{
    //
    // Stop the power policy machine so that we simulate stopping first
    //
    This->PnpPowerPolicyStop();
 
    return WdfDevStatePnpNull;
}

PnpEventRestartHardwareAvailable()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventRestartHardwareAvailable ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3180 of file pnpstatemachine.cpp.

{
    NTSTATUS status;
    BOOLEAN matched;
 
    status = This->PnpPrepareHardware(&matched);
 
    if (!NT_SUCCESS(status)) {
        if (matched == FALSE) {
            //
            // Wait for the remove irp to come in
            //
            COVERAGE_TRAP();
            return WdfDevStatePnpFailed;
        }
        else {
            //
            // EvtDevicePrepareHardware is what failed, goto a state where we
            // undo that call.
            //
            COVERAGE_TRAP();
            return WdfDevStatePnpFailedOwnHardware;
        }
    }
 
    This->PnpPowerPolicyStart();
 
    return WdfDevStatePnpNull;
}

PnpEventRestarting()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventRestarting ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 2441 of file pnpstatemachine.cpp.

{
    //
    // Send an event to the Power Policy State Machine
    // telling it to "Start."
    //
    This->PnpPowerPolicyStart();
 
    return WdfDevStatePnpNull;
}

PnpEventRestartReleaseHardware()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventRestartReleaseHardware ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3133 of file pnpstatemachine.cpp.

{
    NTSTATUS status;
 
    status = This->PnpReleaseHardware();
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(
            This->GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
            "EvtDeviceReleaseHardware failed with %!STATUS!", status);
 
        COVERAGE_TRAP();
 
        This->SetInternalFailure();
        This->SetPendingPnpIrpStatus(status);
 
        return WdfDevStatePnpFailed;
    }
 
    if (This->PnpSendStartDeviceDownTheStackOverload() == FALSE) {
        //
        // The start irp's completion routine will move the state machine into
        // the new state.
        //
        return WdfDevStatePnpNull;
    }
 
    //
    // Start happened synchronously.  Transition to the new state now.
    //
    return WdfDevStatePnpRestartHardwareAvailable;
}

PnpEventStarted()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventStarted ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 2342 of file pnpstatemachine.cpp.

{
 
    This->m_AchievedStart = TRUE;
 
    //
    // Log Telemetry event for the FDO
    //
    if (This->m_Device->IsPdo() == FALSE) {
        This->m_Device->FxLogDeviceStartTelemetryEvent();
    }
 
    This->PnpFinishProcessingIrp();
 
    return WdfDevStatePnpNull;
}

PnpEventStartedCancelRemove()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventStartedCancelRemove ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 2396 of file pnpstatemachine.cpp.

{
    UNREFERENCED_PARAMETER(This);
 
    return WdfDevStatePnpStarted;
}

PnpEventStartedCancelStop()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventStartedCancelStop ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 2374 of file pnpstatemachine.cpp.

{
    UNREFERENCED_PARAMETER(This);
    return WdfDevStatePnpStarted;
}

PnpEventStartedRemoving()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventStartedRemoving ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 2419 of file pnpstatemachine.cpp.

{
    This->PnpPowerPolicyStop();
 
    return WdfDevStatePnpNull;
}

PnpEventStartedStopping()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventStartedStopping ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 2595 of file pnpstatemachine.cpp.

{
    //
    // It is important to stop power policy before releasing the reference.
    // If the reference was released first, we could get into a situation where
    // we immediately go idle and then we must send a D0 irp when in the remove.
    // If there are devices on top of this device and we send a D0 irp during
    // remove processing, the upper devices will be sent an irp after getting a
    // pnp remove (and either crash or fail the power irp upon receiving it).
    //
    This->PnpPowerPolicyStop();
    This->PnpPowerDereferenceSelf();
 
    return WdfDevStatePnpNull;
}

PnpEventStartingFromStopped()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventStartingFromStopped ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 2468 of file pnpstatemachine.cpp.

{
    NTSTATUS status;
    BOOLEAN matched;
 
    status = This->PnpPrepareHardware(&matched);
 
    if (!NT_SUCCESS(status)) {
        //
        // We can handle remove out of the init state, revert back to that state
        //
        if (matched == FALSE) {
            //
            // Wait for the remove irp to come in
            //
            COVERAGE_TRAP();
            return WdfDevStatePnpFailed;
        }
        else {
            //
            // EvtDevicePrepareHardware is what failed, goto a state where we
            // undo that call.
            //
            COVERAGE_TRAP();
            return WdfDevStatePnpFailedOwnHardware;
        }
    }
 
    return WdfDevStatePnpRestarting;
}

PnpEventStopped()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventStopped ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 2516 of file pnpstatemachine.cpp.

{
    WDF_DEVICE_PNP_STATE state;
    NTSTATUS status;
 
    status = This->PnpReleaseHardware();
    if (NT_SUCCESS(status)) {
        //
        // Tell all the resource objects that they no longer own anything.
        //
        This->NotifyResourceobjectsToReleaseResources();
 
        state = WdfDevStatePnpNull;
    }
    else {
        DoTraceLevelMessage(This->GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                            "EvtDeviceReleaseHardware failed - %!STATUS!",
                            status);
        COVERAGE_TRAP();
 
        This->SetInternalFailure();
        state = WdfDevStatePnpFailed;
    }
 
    //
    // Send the irp on its merry way.  This irp (stop device) cannot be failed
    // and must always be sent down the stack.
    //
    This->PnpFinishProcessingIrp();
 
    return state;
}

PnpEventStoppedWaitForStartCompletion()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventStoppedWaitForStartCompletion ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 2566 of file pnpstatemachine.cpp.

{
    if (This->PnpSendStartDeviceDownTheStackOverload() == FALSE) {
        //
        // The start irp's completion routine will move the state machine into
        // the new state.
        //
        return WdfDevStatePnpNull;
    }
 
    return WdfDevStatePnpStartingFromStopped;
}

PnpEventSurpriseRemoved()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventSurpriseRemoved ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 2627 of file pnpstatemachine.cpp.

{
    //
    // Invoke EvtDeviceSurpriseRemove
    //
    This->m_DeviceSurpriseRemoval.Invoke(This->m_Device->GetHandle());
 
    //
    // Notify the virtual override of the surprise remove.
    //
    This->PnpEventSurpriseRemovePendingOverload();
 
    return WdfDevStatePnpFailed;
}

PnpEventSurpriseRemoveIoStarted()

WDF_DEVICE_PNP_STATE FxPkgPnp::PnpEventSurpriseRemoveIoStarted ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 2754 of file pnpstatemachine.cpp.

{
    //
    // Invoke EvtDeviceSurpriseRemove
    //
 
    This->m_DeviceSurpriseRemoval.Invoke(This->m_Device->GetHandle());
 
    //
    // Notify the virtual override of the surprise remove.
    //
    This->PnpEventSurpriseRemovePendingOverload();
 
    return WdfDevStatePnpFailedIoStarting;
}

PnpEventSurpriseRemovePendingOverload()

VOID FxPkgPnp::PnpEventSurpriseRemovePendingOverload ( VOID  )

protectedvirtual

Reimplemented in FxPkgPdo.

Definition at line 3855 of file pnpstatemachine.cpp.

{
 
    //
    // Mark all of the children as missing because the parent has just been
    // removed.   Note that this will happen after all of the children have
    // already received the surprise remove event.  This is OK because the
    // reported status is inspected during the remove device event which will
    // happen after the parent finishes processing the surprise event.
    //
    if (m_EnumInfo != NULL) {
        m_EnumInfo->m_ChildListList.LockForEnum(GetDriverGlobals());
        FxTransactionedEntry* ple;
 
        ple = NULL;
        while ((ple = m_EnumInfo->m_ChildListList.GetNextEntry(ple)) != NULL) {
            FxChildList::_FromEntry(ple)->NotifyDeviceSurpriseRemove();
        }
 
        m_EnumInfo->m_ChildListList.UnlockFromEnum(GetDriverGlobals());
    }
}

Referenced by FxPkgPdo::PnpEventSurpriseRemovePendingOverload().

PnpFinishProcessingIrp()

VOID FxPkgPnp::PnpFinishProcessingIrp ( __in BOOLEAN  IrpMustBePresent = TRUE )

protected

Definition at line 3779 of file pnpstatemachine.cpp.

{
    FxIrp irp;
 
    UNREFERENCED_PARAMETER(IrpMustBePresent);
    ASSERT(IrpMustBePresent == FALSE || IsPresentPendingPnpIrp());
 
    //
    // Start device is the only request we handle on the way back up the stack.
    // Also, if we fail any pnp irps that we are allowed to fail, we just
    // complete them.
    //
    if (IsPresentPendingPnpIrp()) {
 
        irp.SetIrp(GetPendingPnpIrp());
        if (irp.GetMinorFunction() == IRP_MN_START_DEVICE
            ||
            !NT_SUCCESS(irp.GetStatus())) {
 
            irp.SetIrp(ClearPendingPnpIrp());
            CompletePnpRequest(&irp, irp.GetStatus());
        }
        else {
            m_PnpMachine.m_FireAndForget = TRUE;
        }
    }
}

Referenced by PnpProcessEventInner().

PnpGetPostRemoveState()

virtual WDF_DEVICE_PNP_STATE FxPkgPnp::PnpGetPostRemoveState ( VOID  )

protectedpure virtual

Implemented in FxPkgFdo, and FxPkgPdo.

PnpIncrementRestartCountLogic()

BOOLEAN FxPkgPnp::PnpIncrementRestartCountLogic ( _In_ HANDLE  RestartKey, _In_ BOOLEAN  CreatedNewKey  )

private

Definition at line 4527 of file pnpstatemachine.cpp.

{
    NTSTATUS status = STATUS_SUCCESS;
    ULONG count;
    LARGE_INTEGER currentTickCount, startTickCount;
    BOOLEAN started, writeTick, writeCount, writeStarted;
 
    DECLARE_CONST_UNICODE_STRING(valueNameStartTime, RESTART_START_TIME_NAME);
    DECLARE_CONST_UNICODE_STRING(valueNameCount, RESTART_COUNT_NAME);
    DECLARE_CONST_UNICODE_STRING(valueNameStartAchieved, RESTART_START_ACHIEVED_NAME);
 
    count = 0;
    started = FALSE;
    writeTick = FALSE;
    writeCount = FALSE;
    writeStarted = FALSE;
 
    Mx::MxQueryTickCount(&currentTickCount);
 
    started = m_AchievedStart;
    if (started) {
        //
        // Save the fact the driver started without failing
        //
        writeStarted = TRUE;
    }
 
 
    //
    // If the key was created right now, there is nothing to check, just write out
    // the data.
    //
    if (CreatedNewKey) {
        writeTick = TRUE;
        writeCount = TRUE;
 
        //
        // First restart
        //
        count = 1;
    }
    else {
        ULONG length, type;
 
        //
        // First try to get the start time of when we first attempted a restart
        //
        status = FxRegKey::_QueryValue(GetDriverGlobals(),
                                       RestartKey,
                                       &valueNameStartTime,
                                       sizeof(startTickCount.QuadPart),
                                       &startTickCount.QuadPart,
                                       &length,
                                       &type);
 
        if (NT_SUCCESS(status) &&
            length == sizeof(startTickCount.QuadPart) && type == REG_BINARY) {
 
            //
            // Now try to get the last restart count
            //
            status = FxRegKey::_QueryULong(RestartKey,
                                           &valueNameCount,
                                           &count);
 
            if (status == STATUS_OBJECT_NAME_NOT_FOUND) {
                //
                // We read the start time, but not the count.  Assume there was
                // at least one previous restart.
                //
                count = 1;
                status = STATUS_SUCCESS;
            }
        }
 
        if (NT_SUCCESS(status)) {
            if (currentTickCount.QuadPart < startTickCount.QuadPart) {
                //
                // Somehow the key survived a reboot or the clock overflowed
                // and the current time is less then the last time we started
                // timing restarts.  Either way, just treat this as the first
                // time we are restarting.
                //
                writeTick = TRUE;
                writeCount = TRUE;
                count = 1;
            }
            else {
                LONGLONG delta;
 
                //
                // Compute the difference in time in 100 ns units
                //
                delta = (currentTickCount.QuadPart - startTickCount.QuadPart) *
                         Mx::MxQueryTimeIncrement();
 
                if (delta <= WDF_ABS_TIMEOUT_IN_SEC(m_RestartTimePeriodMaximum)) {
                    //
                    // We are within the time limit, see if we are within the
                    // count limit
                    count++;
 
                    //
                    // The count starts at one, so include the maximum in the
                    // compare.
                    //
                    if (count <= m_RestartCountMaximum) {
                        writeCount = TRUE;
                    }
                    else {
                        //
                        // Exceeded the restart count, do not attempt to restart
                        // the device.
                        //
                        status = STATUS_UNSUCCESSFUL;
                    }
                }
                else {
                    if (started == FALSE) {
                        ULONG length, type, value;
                        status = FxRegKey::_QueryValue(GetDriverGlobals(),
                                                       RestartKey,
                                                       &valueNameStartAchieved,
                                                       sizeof(value),
                                                       &value,
                                                       &length,
                                                       &type);
                        if (!NT_SUCCESS(status) || length != sizeof(value) ||
                            type != REG_DWORD) {
                            value = 0;
                        }
                        started = value != 0;
                        status = STATUS_SUCCESS;
                    }
 
                    if (started) {
                        //
                        // Exceeded the time limit.  This is treated as a reset of
                        // the time limit, so we will try to restart and reset the
                        // start time and restart count.
                        //
                        writeTick = TRUE;
                        writeCount = TRUE;
                        count = 1;
 
                        //
                        // Erase the fact the driver once started and
                        // make it do it again to get another 5 attempts to
                        // restart.
                        //
                        writeStarted = TRUE;
                        started = FALSE;
                    }
                    else {
                        //
                        // Device never started
                        //
                        status = STATUS_UNSUCCESSFUL;
                    }
                }
            }
        }
    }
 
    if (writeTick) {
        //
        // Write out the time and the count
        //
        NTSTATUS status2;
        status2 = FxRegKey::_SetValue(RestartKey,
                                     (PUNICODE_STRING)&valueNameStartTime,
                                     REG_BINARY,
                                     &currentTickCount.QuadPart,
                                     sizeof(currentTickCount.QuadPart));
        //
        // Don't let status report success if it was an error prior to _SetValue
        //
        if(NT_SUCCESS(status)) {
            status = status2;
        }
    }
 
    if (NT_SUCCESS(status) && writeCount) {
        status = FxRegKey::_SetValue(RestartKey,
                                     (PUNICODE_STRING)&valueNameCount,
                                     REG_DWORD,
                                     &count,
                                     sizeof(count));
    }
 
    if (writeStarted) {
        NTSTATUS status2;
        DWORD value = started;
        status2 = FxRegKey::_SetValue(RestartKey,
                                     (PUNICODE_STRING)&valueNameStartAchieved,
                                     REG_DWORD,
                                     &value,
                                     sizeof(value));
        //
        // Don't let status report success if it was an error prior to _SetValue
        //
        if(NT_SUCCESS(status)) {
            status = status2;
        }
    }
 
    return NT_SUCCESS(status) ? TRUE : FALSE;
}

Referenced by PnpCheckAndIncrementRestartCount().

PnpMatchResources()

_Must_inspect_result_ NTSTATUS FxPkgPnp::PnpMatchResources ( VOID  )

protected

Definition at line 3882 of file pnpstatemachine.cpp.

{
    PCM_RESOURCE_LIST pResourcesRaw;
    PCM_RESOURCE_LIST pResourcesTranslated;
    FxResourceCm* resCmRaw;
    FxResourceCm* resCmTrans;
    FxInterrupt*  interrupt;
    PLIST_ENTRY ple;
    NTSTATUS status;
    FxCollectionEntry *curRaw, *curTrans, *endTrans;
    ULONG messageCount;
    FxIrp irp;
 
    DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
                        "Entering PnpMatchResources");
 
    //
    // We must clear these flags before calling into the event handler because
    // it might set these states back (which is OK).  If we don't clear these
    // states and the start succeeds, we would endlessly report that our
    // resources have changed and be restarted over and over.
    //
    m_PnpStateAndCaps.Value &= ~(FxPnpStateFailedMask |
                                 FxPnpStateResourcesChangedMask);
    m_PnpStateAndCaps.Value |= (FxPnpStateFailedUseDefault |
                                FxPnpStateResourcesChangedUseDefault);
 
    irp.SetIrp(m_PendingPnPIrp);
    pResourcesRaw = irp.GetParameterAllocatedResources();
    pResourcesTranslated = irp.GetParameterAllocatedResourcesTranslated();
 
    status = m_ResourcesRaw->BuildFromWdmList(pResourcesRaw, FxResourceNoAccess);
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
            "Could not allocate raw resource list for WDFDEVICE 0x%p, %!STATUS!",
            m_Device->GetHandle(), status);
        goto Done;
    }
 
    status = m_Resources->BuildFromWdmList(pResourcesTranslated, FxResourceNoAccess);
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
            "Could not allocate translated resource list for WDFDEVICE 0x%p, %!STATUS!",
            m_Device->GetHandle(), status);
        goto Done;
    }
 
    //
    // reset the stored information in all interrupts in the rebalance case
    //
    for (ple = m_InterruptListHead.Flink;
         ple != &m_InterruptListHead;
         ple = ple->Flink) {
        interrupt = CONTAINING_RECORD(ple, FxInterrupt, m_PnpList);
        interrupt->Reset();
    }
 
    //
    // Now iterate across the resources, looking for ones that correspond
    // to objects that we are managing.  Tell those objects about the resources
    // that were assigned.
    //
    ple = &m_InterruptListHead;
 
    endTrans = m_Resources->End();
 
    for (curTrans = m_Resources->Start(), curRaw = m_ResourcesRaw->Start();
         curTrans != endTrans;
         curTrans = curTrans->Next(), curRaw = curRaw->Next()) {
 
        ASSERT(curTrans->m_Object->GetType() == FX_TYPE_RESOURCE_CM);
        ASSERT(curRaw->m_Object->GetType() == FX_TYPE_RESOURCE_CM);
 
        resCmRaw = (FxResourceCm*) curRaw->m_Object;
 
        if (resCmRaw->m_Descriptor.Type == CmResourceTypeInterrupt) {
            //
            // We're looking at an interrupt resource.
            //
            if (ple->Flink == &m_InterruptListHead) {
                //
                // Oops, there are no more interrupt objects.
                //
                DoTraceLevelMessage(
                    GetDriverGlobals(), TRACE_LEVEL_WARNING, TRACINGPNP,
                    "Not enough interrupt objects created by WDFDEVICE 0x%p",
                    m_Device->GetHandle());
                break;
            }
 
            resCmTrans = (FxResourceCm*) curTrans->m_Object;
            ASSERT(resCmTrans->m_Descriptor.Type == CmResourceTypeInterrupt);
 
            messageCount = resCmRaw->m_Descriptor.u.MessageInterrupt.Raw.MessageCount;
 
            if (FxInterrupt::_IsMessageInterrupt(resCmTrans->m_Descriptor.Flags)
                &&
                (messageCount > 1)) {
                ULONG i;
                //
                // Multi-message MSI 2.2 needs to be handled differently
                //
                for (i = 0, ple = ple->Flink;
                     i < messageCount && ple != &m_InterruptListHead;
                     i++, ple = ple->Flink) {
 
                    //
                    // Get the next interrupt object.
                    //
                    interrupt = CONTAINING_RECORD(ple, FxInterrupt, m_PnpList);
 
                    //
                    // Tell the interrupt object what its resources are.
                    //
                    interrupt->AssignResources(&resCmRaw->m_Descriptor,
                                               &resCmTrans->m_Descriptor);
                }
            }
            else {
                //
                // This is either MSI2.2 with 1 message, MSI-X or Line based.
                //
                ple = ple->Flink;
                interrupt = CONTAINING_RECORD(ple, FxInterrupt, m_PnpList);
 
                //
                // Tell the interrupt object what its resources are.
                //
                interrupt->AssignResources(&resCmRaw->m_Descriptor,
                                           &resCmTrans->m_Descriptor);
            }
        }
    }
 
#if FX_IS_KERNEL_MODE
 
 
 
 
 
 
 
 
 
    //
    // If there are any pended I/Os that were sent to the target
    // that were pended in the transition to stop, then this will
    // resend them.
    //
    // ISSUE:  This has the potential of I/O completing
    // before the driver's start callback has been called...but,
    // this is the same as the PDO pending a sent irp and completing
    // it when the PDO is restarted before the FDO has a change to
    // process the start irp which was still pended below.
    //
    if (m_Device->IsFilter()) {
        //
        // If this is a filter device, then copy the FILE_REMOVABLE_MEDIA
        // characteristic from the lower device.
        //
        if (m_Device->GetAttachedDevice()->Characteristics & FILE_REMOVABLE_MEDIA) {
            ULONG characteristics;
 
            characteristics =
                m_Device->GetDeviceObject()->Characteristics | FILE_REMOVABLE_MEDIA;
 
            m_Device->GetDeviceObject()->Characteristics = characteristics;
        }
 
 
 
 
 
 
 
 
 
 
        m_Device->SetFilterIoType();
    }
 
#endif // FX_IS_KERNEL_MODE
 
Done:
    DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
                        "Exiting PnpMatchResources %!STATUS!", status);
 
    return status;
}

Referenced by __drv_when().

PnpPowerDereferenceSelf()

VOID FxPkgPnp::PnpPowerDereferenceSelf ( VOID  )

private

Definition at line 5382 of file fxpkgpnp.cpp.

{
    if (IsPowerPolicyOwner()) {
        PowerDereference();
    }
}

PnpPowerPolicyRemove()

VOID FxPkgPnp::PnpPowerPolicyRemove ( VOID  )

protected

Definition at line 3759 of file pnpstatemachine.cpp.

{
    PowerPolicyProcessEvent(PwrPolRemove);
}

PnpPowerPolicyStart()

VOID FxPkgPnp::PnpPowerPolicyStart ( VOID  )

protected

Definition at line 3698 of file pnpstatemachine.cpp.

{
    PowerPolicyProcessEvent(PwrPolStart);
}

PnpPowerPolicyStop()

VOID FxPkgPnp::PnpPowerPolicyStop ( VOID  )

protected

Definition at line 3718 of file pnpstatemachine.cpp.

{
    PowerPolicyProcessEvent(PwrPolStop);
}

PnpPowerPolicySurpriseRemove()

VOID FxPkgPnp::PnpPowerPolicySurpriseRemove ( VOID  )

protected

Definition at line 3738 of file pnpstatemachine.cpp.

{
    PowerPolicyProcessEvent(PwrPolSurpriseRemove);
}

PnpPowerReferenceDuringQueryPnp()

_Must_inspect_result_ NTSTATUS FxPkgPnp::PnpPowerReferenceDuringQueryPnp ( VOID  )

private

Definition at line 5351 of file fxpkgpnp.cpp.

{
    if (IsPowerPolicyOwner()) {
        //
        // We want to synchronously wait to move into D0
        //
        return m_PowerPolicyMachine.m_Owner->
            m_PowerIdleMachine.PowerReferenceWithFlags(
                FxPowerReferenceSendPnpPowerUpEvent
                );
    }
    else {
        return STATUS_SUCCESS;
    }
}

PnpPowerReferenceSelf()

_Must_inspect_result_ NTSTATUS FxPkgPnp::PnpPowerReferenceSelf ( VOID  )

private

Definition at line 5322 of file fxpkgpnp.cpp.

{
    if (IsPowerPolicyOwner()) {
        //
        // We want to synchronously wait to move into D0
        //
        return PowerReference(TRUE);
    }
    else {
        return STATUS_SUCCESS;
    }
}

PnpPrepareHardwareInternal()

NTSTATUS FxPkgPnp::PnpPrepareHardwareInternal ( VOID  )

protected

Definition at line 219 of file pnpstatemachinekm.cpp.

{
    //
    // nothing to do for KMDF.
    //
    return STATUS_SUCCESS;
}

Referenced by __drv_when().

PnpProcessEvent()

VOID FxPkgPnp::PnpProcessEvent	(	__in FxPnpEvent	Event,
		__in BOOLEAN	ProcessEventOnDifferentThread = FALSE
	)

Definition at line 823 of file pnpstatemachine.cpp.

{
    NTSTATUS status;
    KIRQL oldIrql;
 
    //
    // Take the lock, raising to DISPATCH_LEVEL.
    //
    m_PnpMachine.Lock(&oldIrql);
 
    if (m_PnpMachine.IsFull()) {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGPNP,
            "WDFDEVICE 0x%p !devobj 0x%p current pnp state %!WDF_DEVICE_PNP_STATE! "
            "dropping event %!FxPnpEvent! because of a full queue",
            m_Device->GetHandle(),
            m_Device->GetDeviceObject(),
            m_Device->GetDevicePnpState(),
            Event);
 
        //
        // The queue is full.  Bail.
        //
        m_PnpMachine.Unlock(oldIrql);
 
        ASSERT(!"The PnP queue is full.  This shouldn't be able to happen.");
        return;
    }
 
    if (m_PnpMachine.IsClosedLocked()) {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGPNP,
            "WDFDEVICE 0x%p !devobj 0x%p current pnp state %!WDF_DEVICE_PNP_STATE! "
            "dropping event %!FxPnpEvent! because of a closed queue",
            m_Device->GetHandle(),
            m_Device->GetDeviceObject(),
            m_Device->GetDevicePnpState(),
            Event);
 
        //
        // The queue is closed.  Bail
        //
        m_PnpMachine.Unlock(oldIrql);
 
        return;
    }
 
    //
    // Enqueue the event.  Whether the event goes on the front
    // or the end of the queue depends on which event it is.
    //
    if (Event & PnpPriorityEventsMask) {
        //
        // Stick it on the front of the queue, making it the next
        // event that will be processed.
        //
        m_PnpMachine.m_Queue[m_PnpMachine.InsertAtHead()] = Event;
    }
    else {
        //
        // Stick it on the end of the queue.
        //
        m_PnpMachine.m_Queue[m_PnpMachine.InsertAtTail()] = Event;
    }
 
    //
    // Drop the lock.
    //
    m_PnpMachine.Unlock(oldIrql);
 
    //
    // Now, if we are running at PASSIVE_LEVEL, attempt to run the state
    // machine on this thread.  If we can't do that, then queue a work item.
    //
 
    if (FALSE == ShouldProcessPnpEventOnDifferentThread(
                    oldIrql,
                    ProcessOnDifferentThread
                    )) {
 
        LONGLONG timeout = 0;
 
        status = m_PnpMachine.m_StateMachineLock.AcquireLock(GetDriverGlobals(),
                                                             &timeout);
 
        if (FxWaitLockInternal::IsLockAcquired(status)) {
            FxPostProcessInfo info;
 
            //
            // We now hold the state machine lock.  So call the function that
            // dispatches the next state.
            //
            PnpProcessEventInner(&info);
 
            m_PnpMachine.m_StateMachineLock.ReleaseLock(GetDriverGlobals());
 
            info.Evaluate(this);
            return;
        }
    }
 
    //
    // For one reason or another, we couldn't run the state machine on this
    // thread.  So queue a work item to do it.  If m_PnPWorkItemEnqueuing
    // is non-zero, that means that the work item is already being enqueued
    // on another thread.  This is significant, since it means that we can't do
    // anything with the work item on this thread, but it's okay, since the
    // work item will pick up our work and do it.
    //
    m_PnpMachine.QueueToThread();
}

Referenced by FxPkgPdo::_PnpEject(), FxPkgFdo::_PnpStartDeviceCompletionRoutine(), ChildRemoved(), CleanupDeviceFromFailedCreate(), FxChildList::DrainFreeListHead(), FinishInitialize(), FxPkgFdo::PnpSendStartDeviceDownTheStackOverload(), PnpSurpriseRemoval(), PowerSendPowerDownFailureEvent(), PowerSendPowerUpFailureEvent(), and FxPowerIdleMachine::SendD0Notification().

PnpProcessEventInner()

VOID FxPkgPnp::PnpProcessEventInner ( __inout FxPostProcessInfo *  Info )

protected

Definition at line 987 of file pnpstatemachine.cpp.

{
    WDF_DEVICE_PNP_STATE newState;
    CPPNP_STATE_TABLE    entry;
    FxPnpEvent           event;
    KIRQL                oldIrql;
 
    //
    // Process as many events as we can.
    //
    for ( ; ; ) {
        entry = GetPnpTableEntry(m_Device->GetDevicePnpState());
 
        //
        // Get an event from the queue.
        //
        m_PnpMachine.Lock(&oldIrql);
 
        if (m_PnpMachine.IsEmpty()) {
            m_PnpMachine.GetFinishedState(Info);
 
            if (m_PnpMachine.m_FireAndForget) {
                m_PnpMachine.m_FireAndForget = FALSE;
                Info->m_FireAndForgetIrp = ClearPendingPnpIrp();
 
                ASSERT(Info->m_FireAndForgetIrp != NULL);
            }
 
            Info->m_SetRemovedEvent = m_SetDeviceRemoveProcessed;
            m_SetDeviceRemoveProcessed = FALSE;
 
            //
            // The queue is empty.
            //
            m_PnpMachine.Unlock(oldIrql);
 
            return;
        }
 
        event = m_PnpMachine.m_Queue[m_PnpMachine.GetHead()];
 
        //
        // At this point, we need to determine whether we can process this
        // event.
        //
        if (event & PnpPriorityEventsMask) {
            //
            // These are always possible to handle.
            //
            DO_NOTHING();
        }
        else {
            //
            // Check to see if this state can handle new events.
            //
            if (entry->StateInfo.Bits.QueueOpen == FALSE) {
                //
                // This state can't handle new events.
                //
                m_PnpMachine.Unlock(oldIrql);
                return;
            }
        }
 
        m_PnpMachine.IncrementHead();
        m_PnpMachine.Unlock(oldIrql);
 
        //
        // Find the entry in the PnP state table that corresponds
        // to this event.
        //
        newState = WdfDevStatePnpNull;
 
        if (entry->FirstTargetState.PnpEvent == event) {
            newState = entry->FirstTargetState.TargetState;
 
            DO_EVENT_TRAP(&entry->FirstTargetState);
        }
        else if (entry->OtherTargetStates != NULL) {
            ULONG i = 0;
 
            for (i = 0;
                 entry->OtherTargetStates[i].PnpEvent != PnpEventNull;
                 i++) {
                if (entry->OtherTargetStates[i].PnpEvent == event) {
                    newState = entry->OtherTargetStates[i].TargetState;
                    DO_EVENT_TRAP(&entry->OtherTargetStates[i]);
                    break;
                }
            }
        }
 
        if (newState == WdfDevStatePnpNull) {
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
                "WDFDEVICE 0x%p !devobj 0x%p current pnp state "
                "%!WDF_DEVICE_PNP_STATE! dropping event %!FxPnpEvent!",
                m_Device->GetHandle(),
                m_Device->GetDeviceObject(),
                m_Device->GetDevicePnpState(),
                event);
 
            if ((entry->StateInfo.Bits.KnownDroppedEvents & event) == 0) {
                COVERAGE_TRAP();
 
                DoTraceLevelMessage(
                    GetDriverGlobals(), TRACE_LEVEL_WARNING, TRACINGPNP,
                    "WDFDEVICE 0x%p !devobj %p current state "
                    "%!WDF_DEVICE_PNP_STATE!, policy event %!FxPnpEvent! is not"
                    " a known dropped event, known dropped events are "
                    "%!FxPnpEvent!",
                    m_Device->GetHandle(),
                    m_Device->GetDeviceObject(),
                    m_Device->GetDevicePnpState(),
                    event,
                    entry->StateInfo.Bits.KnownDroppedEvents);
 
                // DIAG:  add diag code here
            }
 
            //
            // This state doesn't respond to the Event.  Make sure we do not
            // drop an event which pends a pnp irp on the floor though.
            //
            if (event & PnpEventPending) {
                //
                // In the case of a previous power up/down failure, the following
                // can happen
                // 1  invalidate device relations
                // 2  failure event is posted to pnp state machine
                // 3  process power failure event first, but while processing,
                //    query device state is completed, and failed /removed is reported
                // 4  surprise remove comes, the irp is queued, the event is queued
                // 5  processing of power failure event continues, gets to
                //    Failed and completes the s.r irp
                // 6  the surprise remove event is processed (the current value
                //    of the local var event), but since we are already in the
                //    Failed state, we ignore this event and end up
                //    here.
                //
                // This means that if we are processing surprise remove, we cannot
                // 100% expect that an irp has been pended.
                //
                PnpFinishProcessingIrp(
                    (event == PnpEventSurpriseRemove) ? FALSE : TRUE);
            }
            else {
                DO_NOTHING();
            }
        }
        else {
            //
            // Now enter the new state.
            //
            PnpEnterNewState(newState);
        }
    }
}

Referenced by PnpProcessEvent().

PnpReleaseHardware()

_Must_inspect_result_ NTSTATUS FxPkgPnp::PnpReleaseHardware ( VOID  )

protected

Definition at line 3621 of file pnpstatemachine.cpp.

{
    NTSTATUS        status;
    FxInterrupt*    interrupt;
    PLIST_ENTRY     le;
 
    //
    // Invoke the device's release hardware callback.
    //
    status = m_DeviceReleaseHardware.Invoke(
                        m_Device->GetHandle(),
                        m_Resources->GetHandle());
 
    if (status == STATUS_NOT_SUPPORTED) {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
            "EvtDeviceReleaseHardware returned an invalid status "
            "STATUS_NOT_SUPPORTED");
 
        if (GetDriverGlobals()->IsVerificationEnabled(1, 11, OkForDownLevel)) {
            FxVerifierDbgBreakPoint(GetDriverGlobals());
        }
    }
 
#if (FX_CORE_MODE == FX_CORE_USER_MODE)
    if (NT_SUCCESS(status)) {
        //
        // make sure driver has unmapped its resources
        //
        m_Resources->ValidateResourceUnmap();
    }
 
    //
    // delete the register and port resource tables
    //
    m_Resources->DeleteRegisterResourceTable();
    m_Resources->DeletePortResourceTable();
#endif
 
    //
    // Delete all interrupt objects that were created in the prepare hardware
    // callback that the driver did not explicitly delete (in reverse order).
    //
    le = m_InterruptListHead.Blink;
 
    while(le != &m_InterruptListHead) {
 
        // Find the interrupt object pointer.
        interrupt = CONTAINING_RECORD(le, FxInterrupt, m_PnpList);
 
        // Advance the entry before it becomes invalid.
        le = le->Blink;
 
        // Let the interrupt know that 'release hardware' was called.
        interrupt->OnPostReleaseHardware();
    }
 
    return status;
}

PnpSendStartDeviceDownTheStackOverload()

virtual BOOLEAN FxPkgPnp::PnpSendStartDeviceDownTheStackOverload ( VOID  )

protectedpure virtual

Implemented in FxPkgFdo, and FxPkgPdo.

PnpSurpriseRemoval()

_Must_inspect_result_ NTSTATUS FxPkgPnp::PnpSurpriseRemoval ( __inout FxIrp *  Irp )

protected

Definition at line 2366 of file fxpkgpnp.cpp.

{
    //
    // Package specific handling
    //
    Irp->SetStatus(STATUS_SUCCESS);
    SetPendingPnpIrp(Irp);
    PnpProcessEvent(PnpEventSurpriseRemove);
 
    return STATUS_PENDING;
}

Referenced by FxPkgPdo::_PnpSurpriseRemoval().

PostCreateDeviceInitialize()

_Must_inspect_result_ NTSTATUS FxPkgPnp::PostCreateDeviceInitialize

(

VOID

)

Definition at line 1187 of file fxpkgpnp.cpp.

{
    NTSTATUS status;
 
    status = m_PnpMachine.Init(this, &FxPkgPnp::_PnpProcessEventInner);
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                            "PnP State Machine init failed, %!STATUS!",
                            status);
        return status;
    }
 
    status = m_PowerMachine.Init(this, &FxPkgPnp::_PowerProcessEventInner);
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                            "Power State Machine init failed, %!STATUS!",
                            status);
        return status;
    }
 
    status = m_PowerPolicyMachine.Init(this, &FxPkgPnp::_PowerPolicyProcessEventInner);
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                            "Power Policy State Machine init failed, %!STATUS!",
                            status);
        return status;
    }
 
    return status;
}

Referenced by FxDevice::PdoInitialize(), and FxPkgFdo::PostCreateDeviceInitialize().

PowerCheckAssumptions()

VOID FxPkgPnp::PowerCheckAssumptions ( VOID  )

private

Definition at line 1070 of file powerstatemachine.cpp.

{
    WDFCASSERT(sizeof(FxPowerStateInfo) == sizeof(ULONG));
 
    WDFCASSERT((sizeof(m_WdfPowerStates)/sizeof(m_WdfPowerStates[0]))
               ==
               (WdfDevStatePowerNull - WdfDevStatePowerObjectCreated));
 
    // we assume these are the same length when we update the history index
    WDFCASSERT((sizeof(m_PowerMachine.m_Queue.Events)/
                sizeof(m_PowerMachine.m_Queue.Events[0]))
               ==
               (sizeof(m_PowerMachine.m_States.History)/
                sizeof(m_PowerMachine.m_States.History[0])));
}

PowerCheckDeviceType()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerCheckDeviceType ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 1692 of file powerstatemachine.cpp.

{
    return This->PowerCheckDeviceTypeOverload();
}

PowerCheckDeviceTypeNP()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerCheckDeviceTypeNP ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 1714 of file powerstatemachine.cpp.

{
    return This->PowerCheckDeviceTypeNPOverload();
}

PowerCheckDeviceTypeNPOverload()

virtual WDF_DEVICE_POWER_STATE FxPkgPnp::PowerCheckDeviceTypeNPOverload ( VOID  )

protectedpure virtual

Implemented in FxPkgFdo, and FxPkgPdo.

PowerCheckDeviceTypeOverload()

virtual WDF_DEVICE_POWER_STATE FxPkgPnp::PowerCheckDeviceTypeOverload ( VOID  )

protectedpure virtual

Implemented in FxPkgFdo, and FxPkgPdo.

PowerCheckParentOverload()

virtual NTSTATUS FxPkgPnp::PowerCheckParentOverload ( BOOLEAN *  ParentOn )

protectedpure virtual

PowerCheckParentState()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerCheckParentState ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 1622 of file powerstatemachine.cpp.

{
    NTSTATUS status;
    BOOLEAN parentOn;
 
    status = This->PowerCheckParentOverload(&parentOn);
 
    if (!NT_SUCCESS(status)) {
        return WdfDevStatePowerUpFailed;
    }
    else if (parentOn) {
        return WdfDevStatePowerWaking;
    }
    else {
        return WdfDevStatePowerWaitForParent;
    }
}

PowerCheckParentStateArmedForWake()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerCheckParentStateArmedForWake ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3129 of file powerstatemachine.cpp.

{
    NTSTATUS status;
    BOOLEAN parentOn;
 
    status = This->PowerCheckParentOverload(&parentOn);
 
    if (!NT_SUCCESS(status)) {
        return WdfDevStatePowerUpFailed;
    }
    else if (parentOn) {
        return WdfDevStatePowerDxDisablingWakeAtBus;
    }
    else {
        return WdfDevStatePowerWaitForParentArmedForWake;
    }
}

PowerCheckParentStateArmedForWakeNP()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerCheckParentStateArmedForWakeNP ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3166 of file powerstatemachine.cpp.

{
    NTSTATUS status;
    BOOLEAN parentOn;
 
    status = This->PowerCheckParentOverload(&parentOn);
 
    if (!NT_SUCCESS(status)) {
        return WdfDevStatePowerUpFailedNP;
    }
    else if (parentOn) {
        return WdfDevStatePowerDxDisablingWakeAtBusNP;
    }
    else {
        return WdfDevStatePowerWaitForParentArmedForWakeNP;
    }
}

PowerCheckParentStateNP()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerCheckParentStateNP ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 1657 of file powerstatemachine.cpp.

{
    NTSTATUS status;
    BOOLEAN parentOn;
 
    status = This->PowerCheckParentOverload(&parentOn);
 
    if (!NT_SUCCESS(status)) {
        return WdfDevStatePowerUpFailedNP;
    }
    else if (parentOn) {
        return WdfDevStatePowerWakingNP;
    }
    else {
        return WdfDevStatePowerWaitForParentNP;
    }
}

PowerCompletePendedWakeIrp()

VOID FxPkgPnp::PowerCompletePendedWakeIrp ( VOID  )

protected

Definition at line 4832 of file powerstatemachine.cpp.

{
    PLIST_ENTRY ple;
    KIRQL irql;
 
    if (m_SharedPower.m_WaitWakeOwner == FALSE) {
        COVERAGE_TRAP();
        return;
    }
 
    //
    // Pop an irp off of the list
    //
    m_PowerMachine.m_WaitWakeLock.Acquire(&irql);
    ASSERT(IsListEmpty(&m_PowerMachine.m_WaitWakeIrpToBeProcessedList) == FALSE);
    ple = RemoveHeadList(&m_PowerMachine.m_WaitWakeIrpToBeProcessedList);
    m_PowerMachine.m_WaitWakeLock.Release(irql);
 
    InitializeListHead(ple);
 
    FxIrp irp(FxIrp::GetIrpFromListEntry(ple));
 
    CompletePowerRequest(&irp, irp.GetStatus());
}

Referenced by PowerCompleteWakeRequestFromWithinMachine(), and PowerProcessEventInner().

PowerCompleteWakeRequestFromWithinMachine()

VOID FxPkgPnp::PowerCompleteWakeRequestFromWithinMachine ( __in NTSTATUS  Status )

protected

Definition at line 4874 of file powerstatemachine.cpp.

{
    if (PowerMakeWakeRequestNonCancelable(WaitWakeStatus)) {
        PowerCompletePendedWakeIrp();
    }
}

PowerConnectInterruptFailed()

VOID FxPkgPnp::PowerConnectInterruptFailed ( VOID  )

protected

Definition at line 5283 of file powerstatemachine.cpp.

{
    NTSTATUS status;
 
    status = NotifyResourceObjectsDx(NotifyResourcesForceDisconnect);
 
    if (!NT_SUCCESS(status)) {
        //
        // Report the error, but continue forward
        //
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
            "Interrupt(s) disconnect on WDFDEVICE %p failed, %!STATUS!",
            m_Device->GetHandle(), status);
    }
 
    status = m_DeviceD0Exit.Invoke(m_Device->GetHandle(),
        WdfPowerDeviceD3Final);
 
    if (!NT_SUCCESS(status)) {
        //
        // Report the error, but continue forward
        //
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
            "EvtDeviceD0Exit WDFDEVICE 0x%p !devobj 0x%p failed, %!STATUS!",
            m_Device->GetHandle(),
            m_Device->GetDeviceObject(), status);
    }
 
    PowerSetDevicePowerState(WdfPowerDeviceD3Final);
}

PowerD0ArmedForWake()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerD0ArmedForWake ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 1960 of file powerstatemachine.cpp.

{
    if ((This->m_Device->GetDeviceObjectFlags() & DO_POWER_PAGABLE) == 0) {
        //
        // We are non pageable, go to that state now
        //
        COVERAGE_TRAP();
 
        return WdfDevStatePowerDecideD0State;
    }
 
    return WdfDevStatePowerNull;
}

PowerD0ArmedForWakeNP()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerD0ArmedForWakeNP ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 1991 of file powerstatemachine.cpp.

{
    if (This->m_Device->GetDeviceObjectFlags() & DO_POWER_PAGABLE) {
        //
        // We are pageable, go to that state now
        //
        COVERAGE_TRAP();
 
        return WdfDevStatePowerDecideD0State;
    }
 
    return WdfDevStatePowerNull;
}

PowerD0BusWakeOwner()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerD0BusWakeOwner ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 1888 of file powerstatemachine.cpp.

{
    if ((This->m_Device->GetDeviceObjectFlags() & DO_POWER_PAGABLE) == 0) {
        //
        // We are non pageable, go to that state now
        //
        COVERAGE_TRAP();
 
        return WdfDevStatePowerDecideD0State;
    }
    else if (This->PowerIsWakeRequestPresent()) {
        return WdfDevStatePowerEnablingWakeAtBus;
    }
    else {
        return WdfDevStatePowerNull;
    }
}

PowerD0BusWakeOwnerNP()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerD0BusWakeOwnerNP ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 1924 of file powerstatemachine.cpp.

{
    if (This->m_Device->GetDeviceObjectFlags() & DO_POWER_PAGABLE) {
        //
        // Pageable.
        //
        COVERAGE_TRAP();
 
        return WdfDevStatePowerDecideD0State;
    }
    else if (This->PowerIsWakeRequestPresent()) {
        return WdfDevStatePowerEnablingWakeAtBusNP;
    }
    else {
        return WdfDevStatePowerNull;
    }
}

PowerD0DisarmingWakeAtBus()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerD0DisarmingWakeAtBus ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 2057 of file powerstatemachine.cpp.

{
    //
    // We should only get into this state when this devobj is not a PDO and a
    // power policy owner.
    //
    ASSERT((This->m_Device->IsPdo() &&
        This->IsPowerPolicyOwner()) == FALSE);
 
    //
    // Disarm
    //
    This->PowerDisableWakeAtBusOverload();
    This->PowerCompletePendedWakeIrp();
 
    //
    // Go back to normal unarmed D0 with bus wake ownership
    //
    return WdfDevStatePowerD0BusWakeOwner;
}

PowerD0DisarmingWakeAtBusNP()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerD0DisarmingWakeAtBusNP ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 2094 of file powerstatemachine.cpp.

{
    //
    // We should only get into this state when this devobj is not a PDO and a
    // power policy owner.
    //
    ASSERT((This->m_Device->IsPdo() && This->IsPowerPolicyOwner()) == FALSE);
 
    //
    // Disarm
    //
    This->PowerDisableWakeAtBusOverload();
    This->PowerCompletePendedWakeIrp();
 
    //
    // Go back to normal unarmed D0 with bus wake ownership
    //
    return WdfDevStatePowerD0BusWakeOwnerNP;
}

PowerD0NP()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerD0NP ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 1859 of file powerstatemachine.cpp.

{
    if (This->m_Device->GetDeviceObjectFlags() & DO_POWER_PAGABLE) {
        //
        // We are pageable, go to that state now
        //
        COVERAGE_TRAP();
        return WdfDevStatePowerDecideD0State;
    }
 
    return WdfDevStatePowerNull;
}

PowerD0Starting()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerD0Starting ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 2130 of file powerstatemachine.cpp.

{
    NTSTATUS    status;
 
    //
    // Call the driver to tell it to put the hardware into the working
    // state.
    //
    // m_DevicePowerState is the "old" state because we update it after the
    // D0Entry callback.
    //
    status = This->m_DeviceD0Entry.Invoke(
        This->m_Device->GetHandle(),
        (WDF_POWER_DEVICE_STATE) This->m_DevicePowerState);
 
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(
            This->GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
            "EvtDeviceD0Entry WDFDEVICE 0x%p !devobj 0x%p,  old state "
            "%!WDF_POWER_DEVICE_STATE! failed, %!STATUS!",
            This->m_Device->GetHandle(),
            This->m_Device->GetDeviceObject(),
            This->m_DevicePowerState, status);
 
        return WdfDevStatePowerInitialPowerUpFailedDerefParent;
    }
 
    return WdfDevStatePowerD0StartingConnectInterrupt;
}

PowerD0StartingConnectInterrupt()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerD0StartingConnectInterrupt ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 2176 of file powerstatemachine.cpp.

{
    NTSTATUS status;
 
    //
    // Connect the interrupt and enable it
    //
    status = This->NotifyResourceObjectsD0(NotifyResourcesNoFlags);
    if (!NT_SUCCESS(status)) {
        //
        // NotifyResourceObjectsD0 has already logged the error, no need to
        // repeat any error messsages here
        //
        return WdfDevStatePowerInitialConnectInterruptFailed;
    }
 
    status = This->m_DeviceD0EntryPostInterruptsEnabled.Invoke(
        This->m_Device->GetHandle(),
        (WDF_POWER_DEVICE_STATE) This->m_DevicePowerState);
 
    if (!NT_SUCCESS(status)) {
 
        DoTraceLevelMessage(
            This->GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
            "EvtDeviceD0EntryPostInterruptsEnabed WDFDEVICE 0x%p !devobj 0x%p, "
            "old state %!WDF_POWER_DEVICE_STATE! failed, %!STATUS!",
            This->m_Device->GetHandle(),
            This->m_Device->GetDeviceObject(),
            This->m_DevicePowerState, status);
        return WdfDevStatePowerInitialConnectInterruptFailed;
    }
 
    //
    // Last, figure out which state to drop into.  This is the juncture
    // where we figure out if we're doing power in a pageable fashion.
    //
    return WdfDevStatePowerD0StartingDmaEnable;
}

PowerD0StartingDmaEnable()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerD0StartingDmaEnable ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 2232 of file powerstatemachine.cpp.

{
    if (This->PowerDmaEnableAndScan(TRUE) == FALSE) {
        return WdfDevStatePowerInitialDmaEnableFailed;
    }
 
    return WdfDevStatePowerD0StartingStartSelfManagedIo;
}

PowerD0StartingStartSelfManagedIo()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerD0StartingStartSelfManagedIo ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 2257 of file powerstatemachine.cpp.

{
 
 
 
 
    This->m_Device->m_PkgIo->ResumeProcessingForPower();
 
    if (This->m_SelfManagedIoMachine != NULL) {
        NTSTATUS status;
 
        status = This->m_SelfManagedIoMachine->Start();
 
        if (!NT_SUCCESS(status)) {
            // return WdfDevStatePowerInitialSelfManagedIoFailed; __REACTOS__ : allow to fail
        }
    }
 
    This->PowerSetDevicePowerState(WdfPowerDeviceD0);
 
    //
    // Send the PowerUp event to both the PnP and the Power Policy state machines.
    //
    This->PowerSendPowerUpEvents();
 
    return WdfDevStatePowerDecideD0State;
}

PowerD0SurpriseRemoved()

static WDF_DEVICE_POWER_STATE FxPkgPnp::PowerD0SurpriseRemoved ( __inout FxPkgPnp *  This )

staticprotected

PowerDecideD0State()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerDecideD0State ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 2301 of file powerstatemachine.cpp.

{
    if (This->m_Device->GetDeviceObjectFlags() & DO_POWER_PAGABLE) {
        //
        // Pageable.
        //
        if (This->m_SharedPower.m_WaitWakeOwner) {
            return WdfDevStatePowerD0BusWakeOwner;
        }
        else {
            return WdfDevStatePowerD0;
        }
    }
    else {
        //
        // Non-pageable.
        //
        if (This->m_SharedPower.m_WaitWakeOwner) {
            return WdfDevStatePowerD0BusWakeOwnerNP;
        }
        else {
            return WdfDevStatePowerD0NP;
        }
    }
}

PowerDereference()

VOID __inline FxPkgPnp::PowerDereference ( __in_opt PVOID  Tag = NULL, __in_opt LONG  Line = 0, __in_opt PSTR  File = NULL  )

inline

Definition at line 3498 of file fxpkgpnp.hpp.

    {
        m_PowerPolicyMachine.m_Owner->m_PowerIdleMachine.IoDecrement(Tag, Line, File);
    }

Referenced by PnpDeviceUsageNotification(), PnpPowerDereferenceSelf(), PowerPolicyChildPoweredDown(), and ResumeIdleWorker().

PowerDisableWakeAtBusOverload()

virtual VOID FxPkgPnp::PowerDisableWakeAtBusOverload ( VOID  )

inlineprotectedvirtual

Reimplemented in FxPkgPdo.

Definition at line 1396 of file fxpkgpnp.hpp.

    {
    }

PowerDmaEnableAndScan()

BOOLEAN FxPkgPnp::PowerDmaEnableAndScan ( __in BOOLEAN  ImplicitPowerUp )

protected

Definition at line 3666 of file powerstatemachine.cpp.

{
    FxTransactionedEntry* ple;
 
    if (PowerDmaPowerUp() == FALSE) {
        return FALSE;
    }
 
    if (m_EnumInfo != NULL) {
        //
        // Scan for children
        //
        m_EnumInfo->m_ChildListList.LockForEnum(GetDriverGlobals());
 
        ple = NULL;
        while ((ple = m_EnumInfo->m_ChildListList.GetNextEntry(ple)) != NULL) {
            ((FxChildList*) ple->GetTransactionedObject())->ScanForChildren();
        }
 
        m_EnumInfo->m_ChildListList.UnlockFromEnum(GetDriverGlobals());
    }
 
    if (ImplicitPowerUp == FALSE) {
        PowerPolicyProcessEvent(PwrPolPowerUpHwStarted);
    }
 
    return TRUE;
}

PowerDmaPowerDown()

BOOLEAN FxPkgPnp::PowerDmaPowerDown ( VOID  )

protected

Definition at line 83 of file powerstatemachinekm.cpp.

{
    // FxTransactionedEntry* ple;
    // NTSTATUS status;
    BOOLEAN result;
 
    result = TRUE;
 
    //
    // Power up each dma enabler
    //
    // if (m_DmaEnablerList != NULL) {
    //     m_DmaEnablerList->LockForEnum(GetDriverGlobals());
 
    //     ple = NULL;
    //     while ((ple = m_DmaEnablerList->GetNextEntry(ple)) != NULL) {
    //         status = ((FxDmaEnabler*) ple->GetTransactionedObject())->PowerDown();
 
    //         if (!NT_SUCCESS(status)) {
    //             //
    //             // We do not break out of the loop on power down failure.  We will
    //             // continue to power down each channel regardless of the previous
    //             // channel's power down status.
    //             //
    //             result = FALSE;
    //         }
    //     }
 
    //     m_DmaEnablerList->UnlockFromEnum(GetDriverGlobals());
    // }
 
    return result;
}

Referenced by PowerGotoDxIoStopped(), and PowerGotoDxIoStoppedNP().

PowerDmaPowerUp()

_Must_inspect_result_ BOOLEAN FxPkgPnp::PowerDmaPowerUp ( VOID  )

protected

Definition at line 36 of file powerstatemachinekm.cpp.

{
    // FxTransactionedEntry* ple;
    // NTSTATUS status;
    BOOLEAN result;
 
    result = TRUE;
 
    //
    // Power up each dma enabler
    //
    // if (m_DmaEnablerList != NULL) {
    //     m_DmaEnablerList->LockForEnum(GetDriverGlobals());
 
    //     ple = NULL;
    //     while ((ple = m_DmaEnablerList->GetNextEntry(ple)) != NULL) {
    //         status = ((FxDmaEnabler*) ple->GetTransactionedObject())->PowerUp();
 
    //         if (!NT_SUCCESS(status)) {
    //             result = FALSE;
    //             break;
    //         }
    //     }
 
    //     m_DmaEnablerList->UnlockFromEnum(GetDriverGlobals());
    // }
 
    return result;
}

Referenced by PowerDmaEnableAndScan().

PowerDNotZeroNP()

static WDF_DEVICE_POWER_STATE FxPkgPnp::PowerDNotZeroNP ( __inout FxPkgPnp *  This )

staticprotected

PowerDxDisablingWakeAtBus()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerDxDisablingWakeAtBus ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 2552 of file powerstatemachine.cpp.

{
    //
    // We should only get into this state when this devobj is not a PDO and a
    // power policy owner.
    //
    ASSERT((This->m_Device->IsPdo() && This->IsPowerPolicyOwner()) == FALSE);
 
    This->PowerDisableWakeAtBusOverload();
 
    return WdfDevStatePowerWaking;
}

PowerDxDisablingWakeAtBusNP()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerDxDisablingWakeAtBusNP ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 2580 of file powerstatemachine.cpp.

{
    //
    // We should only get into this state when this devobj is not a PDO and a
    // power policy owner.
    //
    ASSERT((This->m_Device->IsPdo() && This->IsPowerPolicyOwner()) == FALSE);
 
    This->PowerDisableWakeAtBusOverload();
 
    return WdfDevStatePowerWakingNP;
}

PowerDxStoppedArmForWake()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerDxStoppedArmForWake ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4314 of file powerstatemachine.cpp.

{
    NTSTATUS status;
 
    COVERAGE_TRAP();
 
    //
    // We should only get into this state when this devobj is not a PDO and a
    // power policy owner.
    //
    ASSERT((This->m_Device->IsPdo() && This->IsPowerPolicyOwner()) == FALSE);
 
    status = This->PowerEnableWakeAtBusOverload();
 
    if (NT_SUCCESS(status)) {
        //
        // No matter of the irp status (canceled, pending, completed), we always
        // transition to the D0ArmedForWake state because that is where we
        // we handle the change in the irp's status.
        //
        COVERAGE_TRAP();
        return WdfDevStatePowerDxArmedForWake;
    }
    else {
        COVERAGE_TRAP();
        This->PowerCompleteWakeRequestFromWithinMachine(status);
        return WdfDevStatePowerDx;
    }
}

PowerDxStoppedArmForWakeNP()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerDxStoppedArmForWakeNP ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4362 of file powerstatemachine.cpp.

{
    NTSTATUS status;
 
    COVERAGE_TRAP();
 
    //
    // We should only get into this state when this devobj is not a PDO and a
    // power policy owner.
    //
    ASSERT((This->m_Device->IsPdo() && This->IsPowerPolicyOwner()) == FALSE);
 
    status = This->PowerEnableWakeAtBusOverload();
 
    if (NT_SUCCESS(status)) {
        //
        // No matter of the irp status (canceled, pending, completed), we always
        // transition to the D0ArmedForWake state because that is where we
        // we handle the change in the irp's status.
        //
        COVERAGE_TRAP();
        return WdfDevStatePowerDxArmedForWakeNP;
    }
    else {
        COVERAGE_TRAP();
        This->PowerCompleteWakeRequestFromWithinMachine(status);
        return WdfDevStatePowerDxNP;
    }
}

PowerDxStoppedDecideDxState()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerDxStoppedDecideDxState ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4259 of file powerstatemachine.cpp.

{
    //
    // We should only get into this state when this devobj is not the power
    // policy owner.
    //
    ASSERT(This->IsPowerPolicyOwner() == FALSE);
 
    //
    // Move power policy back into a working state
    //
    // While it seems odd to send a power up in a Dx state, the power up is
    // really an indication to the power policy state machine that the implicit
    // D0 has been successfully processed, basically, it is a status event more
    // then an indication of true power state.
    //
    This->PowerSendPowerUpEvents();
 
    if (This->m_Device->GetDeviceObjectFlags() & DO_POWER_PAGABLE) {
        if (This->PowerIsWakeRequestPresent()) {
            COVERAGE_TRAP();
            return WdfDevStatePowerDxStoppedArmForWake;
        }
        else {
            return WdfDevStatePowerDx;
        }
    }
    else {
        if (This->PowerIsWakeRequestPresent()) {
            COVERAGE_TRAP();
            return WdfDevStatePowerDxStoppedArmForWakeNP;
        }
        else {
            COVERAGE_TRAP();
            return WdfDevStatePowerDxNP;
        }
    }
}

PowerDxStoppedDisarmWake()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerDxStoppedDisarmWake ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4097 of file powerstatemachine.cpp.

{
    //
    // We should only get into this state when this devobj is not a PDO and a
    // power policy owner.
    //
    ASSERT((This->m_Device->IsPdo() && This->IsPowerPolicyOwner()) == FALSE);
 
    This->PowerDisableWakeAtBusOverload();
 
    return WdfDevStatePowerGotoDxStoppedDisableInterrupt;
}

PowerDxStoppedDisarmWakeNP()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerDxStoppedDisarmWakeNP ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4126 of file powerstatemachine.cpp.

{
    //
    // We should only get into this state when this devobj is not a PDO and a
    // power policy owner.
    //
    ASSERT((This->m_Device->IsPdo() && This->IsPowerPolicyOwner()) == FALSE);
 
    This->PowerDisableWakeAtBusOverload();
 
    return WdfDevStatePowerGotoDxStoppedDisableInterruptNP;
}

PowerDxSurpriseRemovedPowerDown()

static WDF_DEVICE_POWER_STATE FxPkgPnp::PowerDxSurpriseRemovedPowerDown ( __inout FxPkgPnp *  This )

staticprotected

PowerDxSurpriseRemovedPowerUp()

static WDF_DEVICE_POWER_STATE FxPkgPnp::PowerDxSurpriseRemovedPowerUp ( __inout FxPkgPnp *  This )

staticprotected

PowerDZero()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerDZero ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 1830 of file powerstatemachine.cpp.

{
    if ((This->m_Device->GetDeviceObjectFlags() & DO_POWER_PAGABLE) == 0) {
        //
        // We are non pageable, go to that state now
        //
        COVERAGE_TRAP();
 
        return WdfDevStatePowerDecideD0State;
    }
 
    return WdfDevStatePowerNull;
}

PowerEnableWakeAtBusOverload()

virtual NTSTATUS FxPkgPnp::PowerEnableWakeAtBusOverload ( VOID  )

inlineprotectedvirtual

Reimplemented in FxPkgPdo.

Definition at line 1387 of file fxpkgpnp.hpp.

    {
        return STATUS_SUCCESS;
    }

PowerEnablingWakeAtBus()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerEnablingWakeAtBus ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 1736 of file powerstatemachine.cpp.

{
    NTSTATUS status;
 
    //
    // We should only get into this state when this devobj is not a PDO and a
    // power policy owner.
    //
    ASSERT((This->m_Device->IsPdo() && This->IsPowerPolicyOwner()) == FALSE);
 
    status = This->PowerEnableWakeAtBusOverload();
 
    ASSERT(status != STATUS_CANCELLED);
 
    if (NT_SUCCESS(status)) {
        //
        // No matter of the irp status (canceled, pending, completed), we always
        // transition to the D0ArmedForWake state because that is where we
        // we handle the change in the irp's status.
        //
        return WdfDevStatePowerD0ArmedForWake;
    }
    else {
        This->PowerCompleteWakeRequestFromWithinMachine(status);
 
        return WdfDevStatePowerD0BusWakeOwner;
    }
}

PowerEnablingWakeAtBusNP()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerEnablingWakeAtBusNP ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 1780 of file powerstatemachine.cpp.

{
    NTSTATUS status;
 
    //
    // We should only get into this state when this devobj is not a PDO and a
    // power policy owner.
    //
    ASSERT((This->m_Device->IsPdo() &&
        This->IsPowerPolicyOwner()) == FALSE);
 
    status = This->PowerEnableWakeAtBusOverload();
 
    ASSERT(status != STATUS_CANCELLED);
 
    if (NT_SUCCESS(status)) {
        //
        // No matter of the irp status (canceled, pending, completed), we always
        // transition to the D0ArmedForWake state because that is where we
        // we handle the change in the irp's status.
        //
        return WdfDevStatePowerD0ArmedForWakeNP;
    }
    else {
        //
        // Complete the irp with the error that callback indicated
        //
        COVERAGE_TRAP();
 
        This->PowerCompleteWakeRequestFromWithinMachine(status);
 
        return WdfDevStatePowerD0BusWakeOwnerNP;
    }
}

PowerEnterNewState()

VOID FxPkgPnp::PowerEnterNewState ( __in WDF_DEVICE_POWER_STATE  State )

protected

Definition at line 1511 of file powerstatemachine.cpp.

{
    CPPOWER_STATE_TABLE    entry;
    WDF_DEVICE_POWER_STATE currentState, newState;
    WDF_DEVICE_POWER_NOTIFICATION_DATA data;
    FxWatchdog watchdog(this);
 
    currentState = m_Device->GetDevicePowerState();
    newState = State;
 
    while (newState != WdfDevStatePowerNull) {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGPNPPOWERSTATES,
            "WDFDEVICE 0x%p !devobj 0x%p entering Power State "
            "%!WDF_DEVICE_POWER_STATE! from %!WDF_DEVICE_POWER_STATE!",
            m_Device->GetHandle(),
            m_Device->GetDeviceObject(),
            newState, currentState);
 
        if (m_PowerStateCallbacks != NULL) {
            //
            // Callback for leaving the old state
            //
            RtlZeroMemory(&data, sizeof(data));
 
            data.Type = StateNotificationLeaveState;
            data.Data.LeaveState.CurrentState = currentState;
            data.Data.LeaveState.NewState = newState;
 
            m_PowerStateCallbacks->Invoke(currentState,
                                          StateNotificationLeaveState,
                                          m_Device->GetHandle(),
                                          &data);
        }
 
        m_PowerMachine.m_States.History[m_PowerMachine.IncrementHistoryIndex()] =
            (USHORT) newState;
 
        if (m_PowerStateCallbacks != NULL) {
            //
            // Callback for entering the new state
            //
            RtlZeroMemory(&data, sizeof(data));
 
            data.Type = StateNotificationEnterState;
            data.Data.EnterState.CurrentState = currentState;
            data.Data.EnterState.NewState = newState;
 
            m_PowerStateCallbacks->Invoke(newState,
                                          StateNotificationEnterState,
                                          m_Device->GetHandle(),
                                          &data);
        }
 
        m_Device->SetDevicePowerState(newState);
        currentState = newState;
 
        entry = GetPowerTableEntry(currentState);
 
        //
        // And call the state handler, if there is one.
        //
        if (entry->StateFunc != NULL) {
            watchdog.StartTimer(currentState);
            newState = entry->StateFunc(this);
            watchdog.CancelTimer(currentState);
 
            //
            // Validate the return value if FX_STATE_MACHINE_VERIFY is enabled
            //
            VALIDATE_POWER_STATE(currentState, newState);
 
        }
        else {
            newState = WdfDevStatePowerNull;
        }
 
        if (m_PowerStateCallbacks != NULL) {
            //
            // Callback for post processing the new state
            //
            RtlZeroMemory(&data, sizeof(data));
 
            data.Type = StateNotificationPostProcessState;
            data.Data.PostProcessState.CurrentState = currentState;
 
            m_PowerStateCallbacks->Invoke(currentState,
                                          StateNotificationPostProcessState,
                                          m_Device->GetHandle(),
                                          &data);
        }
    }
}

Referenced by PowerProcessEventInner().

PowerFinalPowerDownFailed()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerFinalPowerDownFailed ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4410 of file powerstatemachine.cpp.

{
    This->PowerSendPowerDownFailureEvent(FxPowerDownTypeImplicit);
 
    //
    // If we are not the PPO for the stack we could receive a power irp
    // during the middle of an implicit power down so we cannot assume
    // that there will be no pended power irp during an implicit power down.
    //
    ASSERT(This->IsPowerPolicyOwner() ? This->m_PendingDevicePowerIrp == NULL  : TRUE);
 
    return WdfDevStatePowerStopped;
}

PowerGotoD3Stopped()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerGotoD3Stopped ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 2343 of file powerstatemachine.cpp.

{
    NTSTATUS status;
    BOOLEAN failed;
 
    failed = FALSE;
 
    //
    // We *must* call suspend here even though the pnp state machine called self
    // managed io stop.  Consider the following:
    // 1 this device is a filter
    // 2 the power policy owner has idle enabled and the device stack is
    //   currently idled out (in Dx)
    // 3 the query remove comes, this driver processes it and succeeds
    //   self managed io stop
    // 4 before the PwrPolStop event is processed in this driver, the pwr policy
    //   owner moves the stack into D0.
    // 5 now this driver processed the PwrPolStop and moves into this state.  We
    //   now need to make sure self managed i/o is in the stopped state before
    //   doing anything else.
    //
 
    //
    // The self managed io state machine can handle a suspend event when it is
    // already in the stopped state.
    //
    // Tell the driver to stop its self-managed I/O.
    //
    if (This->m_SelfManagedIoMachine != NULL) {
        status = This->m_SelfManagedIoMachine->Suspend();
 
        if (!NT_SUCCESS(status)) {
            DoTraceLevelMessage(
                This->GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                "EvtDeviceSelfManagedIoStop failed %!STATUS!", status);
            failed = TRUE;
        }
    }
 
 
 
 
 
    // Top-edge queue hold.
    This->m_Device->m_PkgIo->StopProcessingForPower(FxIoStopProcessingForPowerHold);
 
    if (This->PowerDmaPowerDown() == FALSE) {
        failed = TRUE;
    }
 
    status = This->m_DeviceD0ExitPreInterruptsDisabled.Invoke(
        This->m_Device->GetHandle(),
        WdfPowerDeviceD3Final
        );
 
    if (!NT_SUCCESS(status)) {
        failed = TRUE;
 
        DoTraceLevelMessage(
            This->GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
            "EvtDeviceD0ExitPreInterruptsDisabled WDFDEVICE 0x%p !devobj 0x%p, "
            "new state %!WDF_POWER_DEVICE_STATE! failed, %!STATUS!",
            This->m_Device->GetHandle(),
            This->m_Device->GetDeviceObject(),
            WdfPowerDeviceD3Final, status);
    }
 
    //
    // Disconnect the interrupt.
    //
    status = This->NotifyResourceObjectsDx(NotifyResourcesForceDisconnect);
    if (!NT_SUCCESS(status)) {
        //
        // NotifyResourceObjectsDx already traced the error
        //
        failed = TRUE;
    }
 
    //
    // Call the driver to tell it to put the hardware into a sleeping
    // state.
    //
    status = This->m_DeviceD0Exit.Invoke(This->m_Device->GetHandle(),
                                         WdfPowerDeviceD3Final);
    if (!NT_SUCCESS(status)) {
        failed = TRUE;
 
        DoTraceLevelMessage(
            This->GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
            "EvtDeviceD0Exit WDFDEVICE 0x%p !devobj 0x%p, new state "
            "%!WDF_POWER_DEVICE_STATE! failed, %!STATUS!",
            This->m_Device->GetHandle(),
            This->m_Device->GetDeviceObject(),
            WdfPowerDeviceD3Final, status);
    }
 
    This->PowerSetDevicePowerState(WdfPowerDeviceD3Final);
 
    //
    // If this is a child, release the power reference on the parent
    //
    This->PowerParentPowerDereference();
 
    if (failed) {
        return WdfDevStatePowerFinalPowerDownFailed;
    }
 
    This->PowerSendPowerDownEvents(FxPowerDownTypeImplicit);
 
    //
    // If we are not the PPO for the stack we could receive a power irp
    // during the middle of an implicit power down so we cannot assume
    // that there will be no pended power irp during an implicit power down.
    //
    ASSERT(This->IsPowerPolicyOwner() ? This->m_PendingDevicePowerIrp == NULL  : TRUE);
 
    return WdfDevStatePowerStopped;
}

PowerGotoDNotZero()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerGotoDNotZero ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 2608 of file powerstatemachine.cpp.

{
    This->PowerGotoDx();
 
    return WdfDevStatePowerNull;
}

PowerGotoDNotZeroIoStopped()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerGotoDNotZeroIoStopped ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 2652 of file powerstatemachine.cpp.

{
    if (This->PowerGotoDxIoStopped() == FALSE) {
        return WdfDevStatePowerGotoDxFailed;
    }
 
    return WdfDevStatePowerDx;
}

PowerGotoDNotZeroIoStoppedNP()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerGotoDNotZeroIoStoppedNP ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 2664 of file powerstatemachine.cpp.

{
    if (This->PowerGotoDxIoStoppedNP() == FALSE) {
        return WdfDevStatePowerGotoDxNPFailed;
    }
 
    return WdfDevStatePowerDxNP;
}

PowerGotoDNotZeroNP()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerGotoDNotZeroNP ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 2630 of file powerstatemachine.cpp.

{
    This->PowerGotoDx();
 
    return WdfDevStatePowerNull;
}

PowerGotoDx()

VOID FxPkgPnp::PowerGotoDx ( VOID  )

protected

Definition at line 2698 of file powerstatemachine.cpp.

{
    if (m_SelfManagedIoMachine != NULL) {
        NTSTATUS    status;
 
        //
        // Tell the driver to stop its self-managed I/O
        //
        status = m_SelfManagedIoMachine->Suspend();
 
        if (!NT_SUCCESS(status)) {
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                "EvtDeviceSelfManagedIoStop failed %!STATUS!", status);
 
            m_PowerMachine.m_IoCallbackFailure = TRUE;
        }
    }
 
 
 
 
 
    // Top-edge queue hold
    m_Device->m_PkgIo->StopProcessingForPower(FxIoStopProcessingForPowerHold);
 
    PowerPolicyProcessEvent(PwrPolPowerDownIoStopped);
}

PowerGotoDxArmedForWake()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerGotoDxArmedForWake ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3058 of file powerstatemachine.cpp.

{
    This->PowerGotoDx();
 
    return WdfDevStatePowerNull;
}

PowerGotoDxArmedForWakeNP()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerGotoDxArmedForWakeNP ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3081 of file powerstatemachine.cpp.

{
    This->PowerGotoDx();
 
    return WdfDevStatePowerNull;
}

PowerGotoDxFailed()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerGotoDxFailed ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4500 of file powerstatemachine.cpp.

{
    //
    // NotifyResourceObjectsDx will log any errors
    //
    (void) This->NotifyResourceObjectsDx(NotifyResourcesForceDisconnect |
                                     NotifyResourcesDisconnectInactive);
 
    return WdfDevStatePowerReportPowerDownFailed;
}

PowerGotoDxIoStopped()

BOOLEAN FxPkgPnp::PowerGotoDxIoStopped ( VOID  )

protected

Definition at line 2742 of file powerstatemachine.cpp.

{
    WDF_POWER_DEVICE_STATE state;
    NTSTATUS    status;
    BOOLEAN     failed;
    FxIrp   irp;
    ULONG   notifyFlags;
 
    failed = FALSE;
 
    //
    // First determine the state that will be indicated to the driver
    //
    irp.SetIrp(m_PendingDevicePowerIrp);
 
    switch (irp.GetParameterPowerShutdownType()) {
    case PowerActionShutdown:
    case PowerActionShutdownReset:
    case PowerActionShutdownOff:
        state = WdfPowerDeviceD3Final;
        break;
 
    default:
        state = (WDF_POWER_DEVICE_STATE) irp.GetParameterPowerStateDeviceState();
        break;
    }
 
    //
    // Can we even be a power pageable device and be in hibernation path?
    //
    if (m_SystemPowerState == PowerSystemHibernate &&
        GetUsageCount(WdfSpecialFileHibernation) != 0) {
        COVERAGE_TRAP();
 
        //
        // This device is in the hibernation path and the target system state is
        // S4.  Tell the driver that it should do special handling.
        //
        state = WdfPowerDevicePrepareForHibernation;
    }
 
    if (PowerDmaPowerDown() == FALSE) {
        failed = TRUE;
    }
 
    status = m_DeviceD0ExitPreInterruptsDisabled.Invoke(
        m_Device->GetHandle(),
        state
        );
 
    if (!NT_SUCCESS(status)) {
        failed = TRUE;
 
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
            "EvtDeviceD0ExitPreInterruptsDisabled WDFDEVICE 0x%p !devobj 0x%p, "
            "new state %!WDF_POWER_DEVICE_STATE! failed, %!STATUS!",
            m_Device->GetHandle(),
            m_Device->GetDeviceObject(), state, status);
    }
 
    //
    // interrupt disable & disconnect
    //
 
    notifyFlags = NotifyResourcesExplicitPowerDown;
 
    //
    // In general, m_WaitWakeIrp is accessed through guarded InterlockedExchange
    // operations. However, following is a special case where we just want to know
    // the current value. It is possible that the value of m_WaitWakeIrp can
    // change right after we query it. Users of NotifyResourcesArmedForWake will
    // need to be aware of this fact.
    //
    // Note that relying on m_WaitWakeIrp to decide whether to disconnect the wake
    // interrupts or not is unreliable and may result in a race condition between
    // the device powering down and a wake interrupt firing:
    //
    // Thread A: Device is powering down and is going to disconnect wake interrupts
    //           unless m_WaitWakeIrp is not NULL.
    // Thread B: Wake interrupt fires (holding the OS interrupt lock) which results
    //           in completing the IRP_MN_WAIT_WAKE and setting m_WaitWakeIrp to NULL.
    //           Thread then blocks waiting for the device to power up.
    // Thread A: m_WaitWakeIrp is NULL so we disconnect the wake interrupt, but are
    //           blocked waiting to acquire the lock held by the ISR. The deadlock
    //           results in bugcheck 0x9F since the Dx IRP is being blocked.
    //
    // The m_WakeInterruptsKeepConnected flag is set when we request a IRP_MN_WAIT_WAKE
    // in the device powering down path, and is cleared below once it is used.
    //
    if (m_SharedPower.m_WaitWakeIrp != NULL || m_WakeInterruptsKeepConnected == TRUE) {
        notifyFlags |= NotifyResourcesArmedForWake;
        m_WakeInterruptsKeepConnected = FALSE;
    }
 
    status = NotifyResourceObjectsDx(notifyFlags);
    if (!NT_SUCCESS(status)) {
        //
        // NotifyResourceObjectsDx already traced the error
        //
        failed = TRUE;
    }
 
    //
    // Call the driver to tell it to put the hardware into a sleeping
    // state.
    //
 
    status = m_DeviceD0Exit.Invoke(m_Device->GetHandle(), state);
 
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
            "EvtDeviceD0Exit WDFEVICE 0x%p !devobj 0x%p, new state "
            "%!WDF_POWER_DEVICE_STATE! failed, %!STATUS!",
            m_Device->GetHandle(),
            m_Device->GetDeviceObject(), state, status);
 
        failed = TRUE;
    }
 
    //
    // If this is a child, release the power reference on the parent
    //
    PowerParentPowerDereference();
 
    //
    // Set our state no matter if power down failed or not
    //
    PowerSetDevicePowerState(state);
 
    //
    // Stopping self managed io previously failed, convert that failure into
    // a local failure here.
    //
    if (m_PowerMachine.m_IoCallbackFailure) {
        m_PowerMachine.m_IoCallbackFailure = FALSE;
        failed = TRUE;
    }
 
    if (failed) {
        //
        // Power policy will use this property when it is processing the
        // completion of the Dx irp.
        //
        m_PowerMachine.m_PowerDownFailure = TRUE;
 
        //
        // This state will record that we encountered an internal error.
        //
        return FALSE;
    }
 
    PowerSendPowerDownEvents(FxPowerDownTypeExplicit);
 
    PowerReleasePendingDeviceIrp();
 
    return TRUE;
}

PowerGotoDxIoStoppedArmedForWake()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerGotoDxIoStoppedArmedForWake ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3105 of file powerstatemachine.cpp.

{
    if (This->PowerGotoDxIoStopped() == FALSE) {
        return WdfDevStatePowerGotoDxFailed;
    }
 
    return WdfDevStatePowerDxArmedForWake;
}

PowerGotoDxIoStoppedArmedForWakeNP()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerGotoDxIoStoppedArmedForWakeNP ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3117 of file powerstatemachine.cpp.

{
    if (This->PowerGotoDxIoStoppedNP() == FALSE) {
        return WdfDevStatePowerGotoDxNPFailed;
    }
 
    return WdfDevStatePowerDxArmedForWakeNP;
}

PowerGotoDxIoStoppedNP()

BOOLEAN FxPkgPnp::PowerGotoDxIoStoppedNP ( VOID  )

protected

Definition at line 2919 of file powerstatemachine.cpp.

{
    WDF_POWER_DEVICE_STATE state;
    NTSTATUS    status;
    BOOLEAN     failed;
    FxIrp   irp;
 
    failed = FALSE;
 
    //
    // First determine the state that will be indicated to the driver
    //
    irp.SetIrp(m_PendingDevicePowerIrp);
 
    switch (irp.GetParameterPowerShutdownType()) {
    case PowerActionShutdown:
    case PowerActionShutdownReset:
    case PowerActionShutdownOff:
        state = WdfPowerDeviceD3Final;
        break;
 
    default:
        state = (WDF_POWER_DEVICE_STATE) irp.GetParameterPowerStateDeviceState();
        break;
    }
 
    if (m_SystemPowerState == PowerSystemHibernate &&
        GetUsageCount(WdfSpecialFileHibernation) != 0) {
        //
        // This device is in the hibernation path and the target system state is
        // S4.  Tell the driver that it should do special handling.
        //
        state = WdfPowerDevicePrepareForHibernation;
    }
 
    if (PowerDmaPowerDown()  == FALSE) {
        failed = TRUE;
    }
 
    status = m_DeviceD0ExitPreInterruptsDisabled.Invoke(
        m_Device->GetHandle(),
        state
        );
 
    if (!NT_SUCCESS(status)) {
        failed = TRUE;
 
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
            "EvtDeviceD0ExitPreInterruptsDisabled WDFDEVICE 0x%p !devobj 0x%p, "
            "new state %!WDF_POWER_DEVICE_STATE! failed, %!STATUS!",
            m_Device->GetHandle(),
            m_Device->GetDeviceObject(), state, status);
    }
 
    //
    // Interrupt disable (and NO disconnect)
    //
    status = NotifyResourceObjectsDx(NotifyResourcesNP);
 
    if (!NT_SUCCESS(status)) {
        //
        // NotifyResourceObjectsDx already traced the error
        //
        failed = TRUE;
    }
 
    //
    // Call the driver to tell it to put the hardware into a sleeping
    // state.
    //
 
    status = m_DeviceD0Exit.Invoke(m_Device->GetHandle(), state);
 
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
            "EvtDeviceD0Exit WDFDEVICE 0x%p !devobj 0x%p, new state "
            "%!WDF_POWER_DEVICE_STATE! failed, %!STATUS!",
            m_Device->GetHandle(),
            m_Device->GetDeviceObject(), state, status);
 
        failed = TRUE;
    }
 
    //
    // If this is a child, release the power reference on the parent
    //
    PowerParentPowerDereference();
 
    //
    // Set our state no matter if power down failed or not
    //
    PowerSetDevicePowerState(state);
 
    //
    // Stopping self managed io previously failed, convert that failure into
    // a local failure here.
    //
    if (m_PowerMachine.m_IoCallbackFailure) {
        m_PowerMachine.m_IoCallbackFailure = FALSE;
        failed = TRUE;
    }
 
    if (failed) {
        //
        // Power policy will use this property when it is processing the
        // completion of the Dx irp.
        //
        m_PowerMachine.m_PowerDownFailure = TRUE;
 
        //
        // This state will record that we encountered an internal error.
        //
        return FALSE;
    }
 
    PowerSendPowerDownEvents(FxPowerDownTypeExplicit);
 
    PowerReleasePendingDeviceIrp();
 
    return TRUE;
}

PowerGotoDxNPFailed()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerGotoDxNPFailed ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 2676 of file powerstatemachine.cpp.

{
    This->DisconnectInterruptNP();
 
    return WdfDevStatePowerReportPowerDownFailed;
}

PowerGotoDxStopped()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerGotoDxStopped ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4178 of file powerstatemachine.cpp.

{
    This->PowerSendPowerDownEvents(FxPowerDownTypeImplicit);
 
    return WdfDevStatePowerStopped;
}

PowerGotoDxStoppedDisableInterrupt()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerGotoDxStoppedDisableInterrupt ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4526 of file powerstatemachine.cpp.

{
    //
    // NotifyResourceObjectsDx will log any errors
    //
    (void) This->NotifyResourceObjectsDx(NotifyResourcesForceDisconnect |
                                     NotifyResourcesDisconnectInactive);
 
    return WdfDevStatePowerGotoDxStopped;
}

PowerGotoDxStoppedDisableInterruptNP()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerGotoDxStoppedDisableInterruptNP ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4155 of file powerstatemachine.cpp.

{
    This->NotifyResourceObjectsDx(NotifyResourcesSurpriseRemoved);
 
    return WdfDevStatePowerGotoDxStopped;
}

PowerGotoImplicitD3DisarmWakeAtBus()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerGotoImplicitD3DisarmWakeAtBus ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 2022 of file powerstatemachine.cpp.

{
    //
    // We should only get into this state when this devobj is a PDO and not a
    // power policy owner.
    //
    ASSERT((This->m_Device->IsPdo() &&
        This->IsPowerPolicyOwner()) == FALSE);
 
    //
    // Disarm
    // No need to complete the pended ww irp. State machine will complete it
    // in PnpFailed handler, or upper driver will cancel it.
    //
    This->PowerDisableWakeAtBusOverload();
 
    return WdfDevStatePowerGotoD3Stopped;
}

PowerGotoStopped()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerGotoStopped ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4201 of file powerstatemachine.cpp.

{
    //
    // We should only get into this state when this devobj is not the power
    // policy owner.
    //
    ASSERT(This->IsPowerPolicyOwner() == FALSE);
 
    This->PowerReleasePendingDeviceIrp();
    return WdfDevStatePowerStopped;
}

PowerIndicateWaitWakeStatus()

BOOLEAN FxPkgPnp::PowerIndicateWaitWakeStatus

(

__in NTSTATUS

WaitWakeStatus

)

Definition at line 4781 of file powerstatemachine.cpp.

{
    if (PowerMakeWakeRequestNonCancelable(WaitWakeStatus)) {
        //
        // The power machine will eventually call PowerCompletePendedWakeIrp
        // to complete the request.
        //
        if (WaitWakeStatus == STATUS_CANCELLED) {
            PowerProcessEvent(PowerWakeCanceled);
        }
        else if (NT_SUCCESS(WaitWakeStatus)) {
            PowerProcessEvent(PowerWakeSucceeded);
        }
        else {
            PowerProcessEvent(PowerWakeFailed);
        }
 
        return TRUE;
    }
    else {
        return FALSE;
    }
}

Referenced by if(), PnpCleanupForRemove(), and PowerPolicyCancelWaitWake().

PowerInitialConnectInterruptFailed()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerInitialConnectInterruptFailed ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3953 of file powerstatemachine.cpp.

{
    This->PowerConnectInterruptFailed();
 
    return WdfDevStatePowerInitialPowerUpFailedDerefParent;
}

PowerInitialDmaEnableFailed()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerInitialDmaEnableFailed ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3978 of file powerstatemachine.cpp.

{
    NTSTATUS status;
 
    (void) This->PowerDmaPowerDown();
 
    status = This->m_DeviceD0ExitPreInterruptsDisabled.Invoke(
        This->m_Device->GetHandle(),
        WdfPowerDeviceD3Final
        );
 
    if (!NT_SUCCESS(status)) {
        //
        // Report the error, but continue forward
        //
        DoTraceLevelMessage(
            This->GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
            "EvtDeviceD0ExitPreInterruptsDisabled WDFDEVICE 0x%p !devobj 0x%p "
            "new state %!WDF_POWER_DEVICE_STATE! failed, %!STATUS!",
            This->m_Device->GetHandle(),
            This->m_Device->GetDeviceObject(),
            WdfPowerDeviceD3Final, status);
    }
 
    return WdfDevStatePowerInitialConnectInterruptFailed;
}

PowerInitialPowerUpFailed()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerInitialPowerUpFailed ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4075 of file powerstatemachine.cpp.

{
    This->PowerSendPowerUpFailureEvent();
 
    return WdfDevStatePowerStopped;
}

PowerInitialPowerUpFailedDerefParent()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerInitialPowerUpFailedDerefParent ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4049 of file powerstatemachine.cpp.

{
 
    //
    // If this is a child, release the power reference on the parent
    //
    This->PowerParentPowerDereference();
 
    return WdfDevStatePowerInitialPowerUpFailed;
}

PowerInitialSelfManagedIoFailed()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerInitialSelfManagedIoFailed ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4021 of file powerstatemachine.cpp.

{
 
 
 
 
    This->m_Device->m_PkgIo->StopProcessingForPower(FxIoStopProcessingForPowerHold);
 
    return WdfDevStatePowerInitialDmaEnableFailed;
}

PowerIsWakeRequestPresent()

BOOLEAN FxPkgPnp::PowerIsWakeRequestPresent ( VOID  )

inlineprotected

Definition at line 2672 of file fxpkgpnp.hpp.

    {
        //
        // We don't acquire the spinlock because when we transition to the state
        // which will attempt the arming of the device (at bus level), we will
        // gracefully handle the absence of the irp.
        //
        // On the other side if there is no irp and it is set immediately after
        // our check, the event posted by the irp's arrival will transition us
        // to the state which will attempt the arming.
        //
        return m_SharedPower.m_WaitWakeIrp != NULL ? TRUE : FALSE;
    }

PowerMakeWakeRequestNonCancelable()

BOOLEAN FxPkgPnp::PowerMakeWakeRequestNonCancelable ( __in NTSTATUS  Status )

protected

Definition at line 4899 of file powerstatemachine.cpp.

{
    KIRQL irql;
    BOOLEAN result;
 
    //
    // Currently we assume that if we are the bus wait wake owner and that only
    // PDOs can be bus wake owners, so we must have a parent device.
    //
    ASSERT(m_SharedPower.m_WaitWakeOwner &&
        (m_Device->m_ParentDevice != NULL));
 
    result = FALSE;
 
    //
    // Attempt to retrieve the wait wake irp.  We can safely dereference the
    // PIRP in while holding the lock as long as it is not NULL.
    //
    m_PowerMachine.m_WaitWakeLock.Acquire(&irql);
 
    if (m_SharedPower.m_WaitWakeIrp != NULL) {
        MdCancelRoutine pOldCancelRoutine;
        FxIrp wwIrp;
 
        wwIrp.SetIrp(m_SharedPower.m_WaitWakeIrp);
 
        pOldCancelRoutine = wwIrp.SetCancelRoutine(NULL);
 
        if (pOldCancelRoutine != NULL) {
            FxPkgPnp* pParentPkg;
 
            pParentPkg = m_Device->m_ParentDevice->m_PkgPnp;
 
            //
            // Propagate the successful wake status from the parent to this
            // child's WW IRP if the parent is the PPO for its stack.
            //
            if (NT_SUCCESS(WaitWakeStatus) &&
                pParentPkg->IsPowerPolicyOwner() &&
                pParentPkg->m_PowerPolicyMachine.m_Owner->m_SystemWakeSource) {
                //
                // The only way that m_SystemWakeSource can be TRUE is if
                // FxLibraryGlobals.PoGetSystemWake != NULL and if it is not
                // NULL, then FxLibraryGlobals.PoSetSystemWake cannot be NULL
                // either.
 
 
 
 
 
                FxPkgPnp::_PowerSetSystemWakeSource(&wwIrp);
 
                //
                // If this PDO is the PPO for its stack, then we must mark this
                // device as the system wake source if we have any
                // enumerated PDOs off of this PDO so that we can propagate the
                // system wake source attribute to our children stacks.
                // (For a FDO which is the PPO, we do this in the WW completion
                // routine.)
                //
                if (IsPowerPolicyOwner()) {
                    DoTraceLevelMessage(
                        GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGPNP,
                        "WDFDEVICE 0x%p !devobj 0x%p WW !irp 0x%p is a source "
                        "of wake", m_Device->GetHandle(),
                        m_Device->GetDeviceObject(),
                        m_SharedPower.m_WaitWakeIrp);
 
                    m_PowerPolicyMachine.m_Owner->m_SystemWakeSource = TRUE;
                }
            }
 
            //
            // Set the status for the irp when it is completed later
            //
            wwIrp.SetStatus(WaitWakeStatus);
 
            //
            // Queue the irp for completion later
            //
            InsertTailList(&m_PowerMachine.m_WaitWakeIrpToBeProcessedList,
                           wwIrp.ListEntry());
 
            wwIrp.SetIrp(NULL);
            m_SharedPower.m_WaitWakeIrp = NULL;
            result = TRUE;
        }
        else {
            //
            // The irp is being canceled as we run here.  As soon as the spin
            // lock is dropped, the cancel routine will run (or continue if it
            // is blocked on this lock).  Do nothing here and let the cancel
            // routine run its course.
            //
            ASSERT(wwIrp.IsCanceled());
            DO_NOTHING();
        }
    }
    m_PowerMachine.m_WaitWakeLock.Release(irql);
 
    return result;
}

Referenced by PowerCompleteWakeRequestFromWithinMachine(), and PowerIndicateWaitWakeStatus().

PowerNotifyingD0EntryToWakeInterrupts()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerNotifyingD0EntryToWakeInterrupts ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4604 of file powerstatemachine.cpp.

{
    if (This->m_WakeInterruptCount == 0) {
        return WdfDevStatePowerWakingConnectInterrupt;
    }
 
    This->SendEventToAllWakeInterrupts(WakeInterruptEventEnteringD0);
 
    return WdfDevStatePowerNull;;
}

PowerNotifyingD0EntryToWakeInterruptsNP()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerNotifyingD0EntryToWakeInterruptsNP ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4681 of file powerstatemachine.cpp.

{
    if (This->m_WakeInterruptCount == 0) {
        return WdfDevStatePowerWakingConnectInterruptNP;
    }
 
    This->SendEventToAllWakeInterrupts(WakeInterruptEventEnteringD0);
 
    return WdfDevStatePowerNull;;
}

PowerNotifyingD0ExitToWakeInterrupts()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerNotifyingD0ExitToWakeInterrupts ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4632 of file powerstatemachine.cpp.

{
    if (This->m_WakeInterruptCount == 0) {
        return WdfDevStatePowerGotoDxIoStopped;
    }
 
    //
    // Indiciate to the wake interrupt state machine that the device is
    // leaving D0 and also whether the device is armed for wake. The wake
    // interrupt machine treats these differently as described below.
    //
    if (This->m_WakeInterruptsKeepConnected == TRUE ||
        This->m_SharedPower.m_WaitWakeIrp != NULL) {
        This->SendEventToAllWakeInterrupts(WakeInterruptEventLeavingD0);
    }
    else {
        //
        // When a wake interrupt is not armed for wake it will be disconnected
        // by the power state machine once the wake interrupt state machine
        // acknowledges the transition. If the interrupt fires between
        // the time this event is posted and it is disconnected, it needs to be
        // delivered to the driver or a deadlock could occur between PO state machine
        // trying to disconnect the interrupt and the wake interrupt machine
        // holding on to the ISR waiting for the device to return to D0 before
        // delivering the interrupt.
        //
        This->SendEventToAllWakeInterrupts(WakeInterruptEventLeavingD0NotArmedForWake);
    }
 
    return WdfDevStatePowerNull;;
}

PowerNotifyingD0ExitToWakeInterruptsNP()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerNotifyingD0ExitToWakeInterruptsNP ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4709 of file powerstatemachine.cpp.

{
    if (This->m_WakeInterruptCount == 0) {
        return WdfDevStatePowerGotoDxIoStoppedNP;
    }
 
    //
    // Indiciate to the wake interrupt state machine that the device is
    // leaving D0 and also whether the device is armed for wake. The wake
    // interrupt machine treats these differently as described below
    //
    if (This->m_WakeInterruptsKeepConnected == TRUE ||
        This->m_SharedPower.m_WaitWakeIrp != NULL) {
        This->SendEventToAllWakeInterrupts(WakeInterruptEventLeavingD0);
    }
    else {
        //
        // When a wake interrupt is not armed for wake it will be disconnected by
        // the power state machine once the wake interrupt state machine
        // acknowledges the transition. If the interrupt fires between
        // the time this event is posted and it is disconnected, it needs to be
        // delivered to the driver or a deadlock could occur between PO state machine
        // trying to disconnect the interrupt and the wake interrupt machine holding on
        // to the ISR waiting for the device to return to D0 before delivering the
        // interrupt.
        //
        This->SendEventToAllWakeInterrupts(WakeInterruptEventLeavingD0NotArmedForWake);
    }
 
    return WdfDevStatePowerNull;;
}

PowerParentPowerDereference()

virtual VOID FxPkgPnp::PowerParentPowerDereference ( VOID  )

protectedpure virtual

Implemented in FxPkgFdo, and FxPkgPdo.

Referenced by PowerGotoDxIoStopped(), and PowerGotoDxIoStoppedNP().

PowerPolCancelingUsbSSForSystemSleep()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolCancelingUsbSSForSystemSleep ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 8296 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolCancelingUsbSSForSystemSleep);
 
    if (This->PowerPolicyCancelUsbSSIfCapable()) {
        //
        // Usbss completion event will move us from this state.
        //
        return WdfDevStatePwrPolNull;
    }
 
    //
    // If usbss irp was there it has already been canceled, so march on.
    //
    return WdfDevStatePwrPolCancelingWakeForSystemSleep;
}

PowerPolCancelingWakeForSystemSleep()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolCancelingWakeForSystemSleep ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 6103 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolCancelingWakeForSystemSleep);
 
    if (This->PowerPolicyCancelWaitWake() == FALSE &&
        This->m_PowerPolicyMachine.m_Owner->m_WakeCompletionEventDropped) {
        return WdfDevStatePwrPolCancelingWakeForSystemSleepWakeCanceled;
    }
 
    return WdfDevStatePwrPolNull;
}

PowerPolCancelingWakeForSystemSleepWakeCanceled()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolCancelingWakeForSystemSleepWakeCanceled ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 6118 of file powerpolicystatemachine.cpp.

{
    NTSTATUS status;
 
    ASSERT_PWR_POL_STATE(
        This, WdfDevStatePwrPolCancelingWakeForSystemSleepWakeCanceled);
 
    status = This->PowerPolicySendDevicePowerRequest(PowerDeviceD0, NoRetry);
 
    if (!NT_SUCCESS(status)) {
        COVERAGE_TRAP();
        return WdfDevStatePwrPolPowerUpForSystemSleepNotSeen;
    }
 
    return WdfDevStatePwrPolNull;
}

PowerPolCancelUsbSS()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolCancelUsbSS ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 6845 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolCancelUsbSS);
 
    //
    // We notified the device power requirement state machine that we are about
    // to power down, but eventually we didn't power down. So notify the device
    // power requirement state machine that the device should be considered
    // powered on.
    //
    This->m_PowerPolicyMachine.m_Owner->
                m_PoxInterface.DeviceIsPoweredOn();
 
    This->m_PowerPolicyMachine.m_Owner->
            m_PoxInterface.RequestComponentActive();
 
    if (This->PowerPolicyCancelUsbSSIfCapable() == FALSE) {
        //
        // UsbSS has already been canceled/completed
        //
        return WdfDevStatePwrPolStartedCancelTimer;
    }
 
    return WdfDevStatePwrPolNull;
}

PowerPolCheckPowerPageable()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolCheckPowerPageable ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4146 of file powerpolicystatemachine.cpp.

{
    ULONG flags;
    MxDeviceObject deviceObject;
 
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolCheckPowerPageable);
 
    deviceObject.SetObject(This->m_Device->GetDeviceObject());
    flags = deviceObject.GetFlags();
 
    if (flags & DO_POWER_PAGABLE) {
        ASSERT((flags & DO_POWER_INRUSH) == 0);
 
        return WdfDevStatePwrPolSleepingWakeWakeArrived;
    }
    else {
        //
        // DO_POWER_INRUSH also gets us to this state, but since it is mutually
        // exclusive with DO_POWER_PAGABLE, we don't need to check for it
        //
        return WdfDevStatePwrPolSleepingWakeWakeArrivedNP;
    }
}

PowerPolDeviceD0PowerRequestFailed()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolDeviceD0PowerRequestFailed ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 7049 of file powerpolicystatemachine.cpp.

{
    COVERAGE_TRAP();
 
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolDeviceD0PowerRequestFailed);
 
    This->SetInternalFailure();
 
    if (FALSE == This->m_ReleaseHardwareAfterDescendantsOnFailure) {
        This->PnpProcessEvent(PnpEventPowerUpFailed);
    }
 
    return WdfDevStatePwrPolDevicePowerRequestFailed;
}

PowerPolDeviceIdleReturnToActive()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolDeviceIdleReturnToActive ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3787 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolDeviceIdleReturnToActive);
 
    This->m_PowerPolicyMachine.m_Owner->
            m_PoxInterface.RequestComponentActive();
 
    return WdfDevStatePwrPolStartedCancelTimer;
}

PowerPolDeviceIdleSleeping()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolDeviceIdleSleeping ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3812 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolDeviceIdleSleeping);
 
    //
    // Normally we'd make the component active when we get the device-power-
    // required notification. But we've not yet processed the device-power-not-
    // required notification, so we will not be processing the device-power-
    // required notification either. So let's activate the component before we
    // process the Sx IRP.
    //
    This->m_PowerPolicyMachine.m_Owner->
            m_PoxInterface.RequestComponentActive();
 
    return WdfDevStatePwrPolStartedIdleCapableCancelTimerForSleep;
}

PowerPolDeviceIdleStopping()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolDeviceIdleStopping ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3844 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolDeviceIdleStopping);
 
    //
    // Normally we'd make the component active when we get the device-power-
    // required notification. But we've not yet processed the device-power-not-
    // required notification, so we will not be processing the device-power-
    // required notification either. So let's activate the component before we
    // process the stop/remove request.
    //
    This->m_PowerPolicyMachine.m_Owner->
            m_PoxInterface.RequestComponentActive();
 
    return WdfDevStatePwrPolStoppingCancelTimer;
}

PowerPolDevicePowerRequestFailed()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolDevicePowerRequestFailed ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 7079 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolDevicePowerRequestFailed);
 
    //
    // In the failure path we still need to notify the children that they can
    // power up so that they will unblock.
    //
    This->PowerPolicyChildrenCanPowerUp();
 
    This->m_PowerPolicyMachine.m_Owner->m_PowerFailed = TRUE;
 
    //
    // Notify the device power requirement state machine that the device should
    // be considered powered on, although it may not be in reality. Doing this
    // will ensure that component activation before device removal will succeed.
    //
    This->m_PowerPolicyMachine.m_Owner->
                m_PoxInterface.DeviceIsPoweredOn();
 
    return WdfDevStatePwrPolNull;
}

PowerPolDisarmingWakeForSystemSleepCompletePowerUp()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolDisarmingWakeForSystemSleepCompletePowerUp ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 6138 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(
        This, WdfDevStatePwrPolDisarmingWakeForSystemSleepCompletePowerUp);
 
    //
    // If the PDO is the Power Policy owner, then disable wake at bus, otherwise
    // the power state machine will disable wake at bus.
    //
    if (This->m_Device->IsPdo()) {
        This->PowerDisableWakeAtBusOverload();
    }
 
    This->m_PowerPolicyMachine.m_Owner->m_DeviceDisarmWakeFromS0.Invoke(
        This->m_Device->GetHandle()
        );
 
    This->PowerProcessEvent(PowerCompleteD0);
 
    return WdfDevStatePwrPolNull;
}

PowerPolicyBlockChildrenPowerUp()

VOID FxPkgPnp::PowerPolicyBlockChildrenPowerUp ( VOID  )

inlineprivate

Definition at line 4017 of file fxpkgpnp.hpp.

    {
        if (m_EnumInfo != NULL) {
            m_EnumInfo->AcquireParentPowerStateLock(GetDriverGlobals());
            //
            // Setup a guard so that no children power up until we return to S0.
            //
            m_PowerPolicyMachine.m_Owner->m_ChildrenCanPowerUp = FALSE;
            m_EnumInfo->ReleaseParentPowerStateLock(GetDriverGlobals());
        }
    }

Referenced by PowerPolicyPowerDownForSx().

PowerPolicyCancelUsbSS()

VOID FxPkgPnp::PowerPolicyCancelUsbSS ( VOID  )

protected

Definition at line 197 of file powerpolicystatemachinekm.cpp.

{
    m_PowerPolicyMachine.m_Owner->m_UsbIdle->m_IdleIrp.Cancel();
}

Referenced by PowerPolicyCancelUsbSSIfCapable().

PowerPolicyCancelUsbSSIfCapable()

BOOLEAN FxPkgPnp::PowerPolicyCancelUsbSSIfCapable ( VOID  )

protected

Definition at line 8361 of file powerpolicystatemachine.cpp.

{
    if (m_PowerPolicyMachine.m_Owner->m_UsbIdle == NULL ||
        m_PowerPolicyMachine.m_Owner->m_UsbIdle->m_EventDropped) {
        return FALSE;
    }
    else {
        PowerPolicyCancelUsbSS();
        return TRUE;
    }
}

PowerPolicyCancelWaitWake()

BOOLEAN FxPkgPnp::PowerPolicyCancelWaitWake ( VOID  )

protected

Definition at line 7724 of file powerpolicystatemachine.cpp.

{
    MdIrp wwIrp;
    BOOLEAN cancelled, result;
 
    if (m_SharedPower.m_WaitWakeOwner) {
        //
        // This will complete the irp and then post the appropriate events to
        // both the power and power policy state machines.
        //
        cancelled = PowerIndicateWaitWakeStatus(STATUS_CANCELLED);
    }
    else {
        wwIrp = (MdIrp) InterlockedExchangePointer(
            (PVOID*) &m_SharedPower.m_WaitWakeIrp, NULL);
 
        if (wwIrp != NULL) {
            FxIrp irp(wwIrp);
 
            DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
                                "Successfully got WaitWake irp %p for cancelling", wwIrp);
 
            result = irp.Cancel();
 
            DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
                                "Cancel of irp %p returned %d", wwIrp, result);
 
 
            if (m_PowerPolicyMachine.CanCompleteWaitWakeIrp()) {
                CompletePowerRequest(&irp, irp.GetStatus());
            }
            else {
                //
                // Irp has been completed by the lower bus driver, that's OK
                // because the completion of the request will trigger the
                // same transition
                //
                DO_NOTHING();
            }
 
            cancelled = TRUE;
        }
        else {
            DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
                                "No WaitWake irp to cancel");
 
            cancelled = FALSE;
        }
    }
 
    return cancelled;
}

PowerPolicyCanChildPowerUp()

_Must_inspect_result_ NTSTATUS FxPkgPnp::PowerPolicyCanChildPowerUp ( __out PBOOLEAN  PowerUp )

inline

Definition at line 3686 of file fxpkgpnp.hpp.

    {
        *PowerUp = FALSE;
 
        if (IsPowerPolicyOwner()) {
            NTSTATUS status;
 
            //
            // By referencing the parent (this device) we make sure that if the
            // parent is in Dx, we force it back into D0 so that this child can
            // be in D0.
            //
            status = PowerReference(FALSE);
 
            if (!NT_SUCCESS(status)) {
                return status;
            }
 
            //
            // m_EnumInfo is valid because the child device is calling into the
            // parent device and if there is a child, there is a m_EnumInfo.
            //
            m_EnumInfo->AcquireParentPowerStateLock(GetDriverGlobals());
 
            //
            // The caller has added a power reference to this device, so this device
            // will remain in D0 until that power reference has been removed.  This
            // count is separate from the power ref count b/c the power ref count
            // only controls when the idle timer will fire.  This count handles the
            // race that can occur after we decide that the parent is idle and act
            // on it and the child powers up before this parent actually powers
            // down.
            //
            m_PowerPolicyMachine.m_Owner->m_ChildrenPoweredOnCount++;
            *PowerUp = m_PowerPolicyMachine.m_Owner->m_ChildrenCanPowerUp;
 
            m_EnumInfo->ReleaseParentPowerStateLock(GetDriverGlobals());
        }
        else {
            //
            // The parent (this device) is not the power policy owner.  That
            // means we cannot poke the parent to come back to D0 and rely on
            // the parent being in D0.  Our only recourse is to move into D0 and
            // ignore the parent's device power state.
            //
            // We will only get into this situation if the parent is not the
            // power policy owner of the stack.  This usually means the parent
            // is a filter driver in the parent stack and is creating a virtual
            // child.  Since the child is assumed virtual, it's D state is not
            // tied to real hardware and doesn't really matter.
            //
            *PowerUp = TRUE;
        }
 
        return STATUS_SUCCESS;
    }

Referenced by FxPkgPdo::PowerCheckParentOverload().

PowerPolicyCanIdlePowerDown()

BOOLEAN FxPkgPnp::PowerPolicyCanIdlePowerDown ( __in DEVICE_POWER_STATE  DxState )

private

Definition at line 7933 of file powerpolicystatemachine.cpp.

{
    BOOLEAN powerDown;
 
    //
    // If we potentially have children, make sure that they are all in Dx before
    // the parent powers down.
    //
    if (m_EnumInfo != NULL) {
        m_EnumInfo->AcquireParentPowerStateLock(GetDriverGlobals());
        if (m_PowerPolicyMachine.m_Owner->m_ChildrenPoweredOnCount == 0) {
            //
            // Setup a guard so that no children power up until we either fail
            // this power down or power all the way down and back up.
            //
            m_PowerPolicyMachine.m_Owner->m_ChildrenCanPowerUp = FALSE;
            powerDown = TRUE;
        }
        else {
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGPNP,
                "WDFDEVICE %p !devobj 0x%p not idling out because there are %d "
                "children who are powered up", m_Device->GetHandle(),
                m_Device->GetDeviceObject(),
                m_PowerPolicyMachine.m_Owner->m_ChildrenPoweredOnCount);
            powerDown = FALSE;
        }
        m_EnumInfo->ReleaseParentPowerStateLock(GetDriverGlobals());
    }
    else {
        powerDown = TRUE;
    }
 
    if (powerDown) {
        NTSTATUS status;
 
        status = PowerPolicySendDevicePowerRequest(DxState, NoRetry);
 
        if (!NT_SUCCESS(status)) {
            //
            // This will set m_ChildrenCanPowerUp to TRUE and send a
            // ParentMovesToD0 in case any children powered down in between
            // determining if the parent can go idle and failing to do so.
            //
            PowerPolicyChildrenCanPowerUp();
 
            powerDown = FALSE;
        }
    }
 
    return powerDown;
}

PowerPolicyCanWakeFromSystemState()

BOOLEAN FxPkgPnp::PowerPolicyCanWakeFromSystemState ( __in SYSTEM_POWER_STATE  SystemState )

inlineprotected

Definition at line 2831 of file fxpkgpnp.hpp.

    {
        return SystemState <= PowerPolicyGetDeviceDeepestSystemWakeState();
    }

Referenced by PowerPolicyHandleSystemQueryPower().

PowerPolicyCheckAssumptions()

VOID FxPkgPnp::PowerPolicyCheckAssumptions ( VOID  )

private

Definition at line 2052 of file powerpolicystatemachine.cpp.

{
    WDFCASSERT(sizeof(FxPwrPolStateInfo) == sizeof(ULONG));
 
    WDFCASSERT((sizeof(m_WdfPowerPolicyStates)/sizeof(m_WdfPowerPolicyStates[0]))
                 ==
               (WdfDevStatePwrPolNull - WdfDevStatePwrPolObjectCreated));
 
    // we assume these are the same length when we update the history index
    WDFCASSERT((sizeof(m_PowerPolicyMachine.m_Queue)/
                sizeof(m_PowerPolicyMachine.m_Queue[0]))
               ==
               (sizeof(m_PowerPolicyMachine.m_States.History)/
                sizeof(m_PowerPolicyMachine.m_States.History[0])));
}

PowerPolicyChildPoweredDown()

VOID FxPkgPnp::PowerPolicyChildPoweredDown ( VOID  )

inline

Definition at line 3746 of file fxpkgpnp.hpp.

    {
        //
        // If this parent is the power policy owner of the child's stack, release
        // the requirement this device to be in D0 while the child is in D0.
        //
        if (IsPowerPolicyOwner()) {
            //
            // Decrement the number of children who are powered on
            //
            m_EnumInfo->AcquireParentPowerStateLock(GetDriverGlobals());
            ASSERT(m_PowerPolicyMachine.m_Owner->m_ChildrenPoweredOnCount > 0);
            m_PowerPolicyMachine.m_Owner->m_ChildrenPoweredOnCount--;
            m_EnumInfo->ReleaseParentPowerStateLock(GetDriverGlobals());
 
            PowerDereference();
        }
    }

Referenced by FxPkgPdo::PowerParentPowerDereference().

PowerPolicyChildrenCanPowerUp()

VOID FxPkgPnp::PowerPolicyChildrenCanPowerUp ( VOID  )

private

Definition at line 8040 of file powerpolicystatemachine.cpp.

{
    //
    // This can be called for any PPO so we must check first if we have any
    // possibility of children.
    //
    if (m_EnumInfo == NULL) {
        return;
    }
 
    if (IsPowerPolicyOwner()) {
        m_EnumInfo->AcquireParentPowerStateLock(GetDriverGlobals());
 
        //
        // When the child attempts to power up, m_ChildrenPoweredOnCount can
        // be incremented while the parent is in Dx. The important value
        // here is the guard value, m_ChildrenCanPowerUp which must be
        // FALSE.
        //
        // ASSERT (m_PowerPolicyMachine.m_Owner->m_ChildrenPoweredOnCount == 0);
 
        //
        // In the USB SS case, we can return to StartingDecideS0Wake without
        // ever attempting to go into a Dx state state, so m_ChildrenCanPowerUp
        // can be TRUE.
        //
        // ASSERT(m_PowerPolicyMachine.m_Owner->m_ChildrenCanPowerUp == FALSE);
 
        m_PowerPolicyMachine.m_Owner->m_ChildrenCanPowerUp = TRUE;
        m_EnumInfo->ReleaseParentPowerStateLock(GetDriverGlobals());
 
        //
        // Now that we have set the state of the parent, any child which checks
        // the power state after we have released the lock will be able to
        // power up immediately.  We now need to unblock all children which
        // checked the parent state before this function was called by posting
        // a PowerParentToD0 event to each child (regardless of the PDO device
        // power state).
        //
        PowerPolicyPostParentToD0ToChildren();
    }
    else {
        //
        // Since we are not the power policy owner for the parent device,
        // we cannot make any guarantees about the child being in D0 while
        // the parent is in D0 so we do not call PowerPostParentToD0ToChildren().
        // Additionally in PowerPolicyCanChildPowerUp(), if the parent (this)
        // device is not the PPO, we don't even check the parent D state before
        // powering up the child.
        //
        DO_NOTHING();
    }
}

Referenced by PowerPolicyCanIdlePowerDown().

PowerPolicyCompleteSystemPowerIrp()

VOID FxPkgPnp::PowerPolicyCompleteSystemPowerIrp ( VOID  )

protected

Definition at line 7700 of file powerpolicystatemachine.cpp.

{
    FxIrp irp(m_PendingSystemPowerIrp);
    NTSTATUS status;
 
    ASSERT(m_PendingSystemPowerIrp != NULL);
 
    status = STATUS_SUCCESS;
 
    DoTraceLevelMessage(
        GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
        "Completing system power irp %p (S%d), %!STATUS!",
        m_PendingSystemPowerIrp,
        irp.GetParameterPowerStateSystemState()-1,
        status);
 
    m_PendingSystemPowerIrp = NULL;
 
    CompletePowerRequest(&irp, STATUS_SUCCESS);
}

Referenced by PowerPolicyProcessEventInner().

PowerPolicyDisarmWakeFromSx()

VOID __inline FxPkgPnp::PowerPolicyDisarmWakeFromSx ( VOID  )

private

Definition at line 8111 of file powerpolicystatemachine.cpp.

{
    NTSTATUS wwStatus;
    FxTransactionedEntry* ple;
 
    m_PowerPolicyMachine.m_Owner->m_DeviceDisarmWakeFromSx.Invoke(
        m_Device->GetHandle()
        );
 
    wwStatus = m_PowerPolicyMachine.m_Owner->m_WaitWakeStatus;
 
    if (wwStatus != STATUS_CANCELLED &&
        m_EnumInfo != NULL &&
        PowerPolicyShouldPropagateWakeStatusToChildren()) {
        m_EnumInfo->m_ChildListList.LockForEnum(GetDriverGlobals());
 
        ple = NULL;
        while ((ple = m_EnumInfo->m_ChildListList.GetNextEntry(ple)) != NULL) {
            ((FxChildList*) ple->GetTransactionedObject())->
                IndicateWakeStatus(wwStatus);
        }
 
        m_EnumInfo->m_ChildListList.UnlockFromEnum(GetDriverGlobals());
    }
 
    m_PowerPolicyMachine.m_Owner->m_WaitWakeStatus = STATUS_NOT_SUPPORTED;
 
    //
    // Always set the wake source back to FALSE regardless of it previous value.
    //
    m_PowerPolicyMachine.m_Owner->m_SystemWakeSource = FALSE;
}

PowerPolicyEnterNewState()

VOID FxPkgPnp::PowerPolicyEnterNewState ( __in WDF_DEVICE_POWER_POLICY_STATE  State )

protected

Definition at line 3349 of file powerpolicystatemachine.cpp.

{
    CPPOWER_POLICY_STATE_TABLE entry;
    WDF_DEVICE_POWER_POLICY_STATE currentState, newState;
    WDF_DEVICE_POWER_POLICY_NOTIFICATION_DATA data;
    FxWatchdog watchdog(this);
 
    currentState = m_Device->GetDevicePowerPolicyState();
    newState = NewState;
 
    while (newState != WdfDevStatePwrPolNull) {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGPNPPOWERSTATES,
            "WDFDEVICE 0x%p !devobj 0x%p entering power policy state "
            "%!WDF_DEVICE_POWER_POLICY_STATE! from "
            "%!WDF_DEVICE_POWER_POLICY_STATE!", m_Device->GetHandle(),
            m_Device->GetDeviceObject(), newState, currentState);
 
        if (m_PowerPolicyStateCallbacks != NULL) {
            //
            // Callback for leaving the old state
            //
            RtlZeroMemory(&data, sizeof(data));
 
            data.Type = StateNotificationLeaveState;
            data.Data.LeaveState.CurrentState = currentState;
            data.Data.LeaveState.NewState = newState;
 
            m_PowerPolicyStateCallbacks->Invoke(currentState,
                                                StateNotificationLeaveState,
                                                m_Device->GetHandle(),
                                                &data);
        }
 
        m_PowerPolicyMachine.m_States.History[
            m_PowerPolicyMachine.IncrementHistoryIndex()] = (USHORT) newState;
 
        if (m_PowerPolicyStateCallbacks != NULL) {
            //
            // Callback for entering the new state
            //
            RtlZeroMemory(&data, sizeof(data));
 
            data.Type = StateNotificationEnterState;
            data.Data.EnterState.CurrentState = currentState;
            data.Data.EnterState.NewState = newState;
 
            m_PowerPolicyStateCallbacks->Invoke(newState,
                                                StateNotificationEnterState,
                                                m_Device->GetHandle(),
                                                &data);
        }
 
        m_Device->SetDevicePowerPolicyState(newState);
        currentState = newState;
 
        entry = GetPowerPolicyTableEntry(currentState);
 
        //
        // And call the state handler, if there is one.
        //
        if (entry->StateFunc != NULL) {
            watchdog.StartTimer(currentState);
            newState = entry->StateFunc(this);
            watchdog.CancelTimer(currentState);
 
            //
            // Validate the return value if FX_STATE_MACHINE_VERIFY is enabled
            //
            VALIDATE_PWR_POL_STATE(currentState, newState);
 
        }
        else {
            newState = WdfDevStatePwrPolNull;
        }
 
        if (m_PowerPolicyStateCallbacks != NULL) {
            //
            // Callback for post processing the new state
            //
            RtlZeroMemory(&data, sizeof(data));
 
            data.Type = StateNotificationPostProcessState;
            data.Data.PostProcessState.CurrentState = currentState;
 
            m_PowerPolicyStateCallbacks->Invoke(currentState,
                                                StateNotificationPostProcessState,
                                                m_Device->GetHandle(),
                                                &data);
        }
    }
}

Referenced by PowerPolicyProcessEventInner().

PowerPolicyGetCurrentWakeReason()

ULONG FxPkgPnp::PowerPolicyGetCurrentWakeReason

(

VOID

)

Definition at line 5782 of file fxpkgpnp.cpp.

{
    ULONG wakeReason;
 
    wakeReason = 0x0;
 
    if (m_PowerPolicyMachine.m_Owner->m_WakeSettings.ArmForWakeIfChildrenAreArmedForWake &&
        m_PowerPolicyMachine.m_Owner->m_ChildrenArmedCount > 0) {
        //
        // Wake settings depends on children and one or more children are
        // armed for wake.
        //
        wakeReason |= FxPowerPolicySxWakeChildrenArmedFlag;
    }
 
    if (m_PowerPolicyMachine.m_Owner->m_WakeSettings.Enabled) {
        //
        // Wake settings is explicitly enabled.
        //
        wakeReason |= FxPowerPolicySxWakeDeviceEnabledFlag;
    }
 
    return wakeReason;
}

Referenced by PowerPolicyIsWakeEnabled().

PowerPolicyGetDeviceDeepestDeviceWakeState()

DEVICE_POWER_STATE FxPkgPnp::PowerPolicyGetDeviceDeepestDeviceWakeState ( __in SYSTEM_POWER_STATE  SystemState )

protected

Definition at line 6440 of file fxpkgpnp.cpp.

{
    DEVICE_POWER_STATE dxState;
 
    //
    // Earlier versions of WDF (pre-1.11) did not take into account SystemState
    // in figuring out the deepest wake state. So for compatibility we restrict
    // this to drivers compiled for 1.11 or newer. See comments in the
    // FxPkgPnp::QueryForCapabilities function for more information on
    // compatibility risk.
    //
    if (GetDriverGlobals()->IsVersionGreaterThanOrEqualTo(1,11)) {
        if ((SystemState < PowerSystemWorking) ||
            (SystemState > PowerSystemHibernate)) {
            dxState = PowerDeviceD0;
        } else {
            dxState = MapWakeDepthToDstate(
                (DEVICE_WAKE_DEPTH)m_DeviceWake[SystemState - PowerSystemWorking]
                );
        }
    }
    else {
        //
        // For pre-1.11 drivers, all of m_DeviceWake array is populated with
        // the same DeviceWake value obtained from device capabilities so we
        // just use the first one (index 0).
        //
        dxState = MapWakeDepthToDstate((DEVICE_WAKE_DEPTH)m_DeviceWake[0]);
    }
 
    //
    // Per WDM docs DeviceWake and SystemWake must be non-zero to support
    // wake. We warn about the violation. Ideally, a verifier check would have
    // been better but we want to avoid that because some drivers may
    // intentionally call this DDI and do not treat the DDI failure as fatal (
    // because they are aware that DDI may succeed in some cases), and a verifier
    // breakpoint would force them to avoid the verifier failure by not enabling
    // verifier.
    //
    if (dxState == PowerDeviceUnspecified ||
        m_SystemWake == PowerSystemUnspecified) {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_WARNING, TRACINGPNP,
            "SystemWake %!SYSTEM_POWER_STATE! and DeviceWake "
            "%!DEVICE_POWER_STATE! power state reported in device "
            "capabilities do not support wake. Both the SystemWake and "
            "DeviceWake members should be nonzero to support wake-up on "
            "this system.", m_SystemWake, dxState);
    }
 
    return dxState;
}

Referenced by PowerPolicySetS0IdleSettings(), and PowerPolicySetSxWakeSettings().

PowerPolicyGetDeviceDeepestSystemWakeState()

SYSTEM_POWER_STATE FxPkgPnp::PowerPolicyGetDeviceDeepestSystemWakeState ( VOID  )

inlineprotected

Definition at line 2839 of file fxpkgpnp.hpp.

    {
        return (SYSTEM_POWER_STATE) m_SystemWake;
    }

Referenced by PowerPolicyCanWakeFromSystemState().

PowerPolicyGetPendingSystemState()

SYSTEM_POWER_STATE FxPkgPnp::PowerPolicyGetPendingSystemState ( VOID  )

inlineprotected

Definition at line 2808 of file fxpkgpnp.hpp.

    {
        FxIrp irp(m_PendingSystemPowerIrp);
 
        //
        // In a FastS4 situation, Parameters.Power.State.SystemState will be
        // PowerSystemHibernate, while TargetSystemState will indicate the
        // true Sx state the machine is moving into.
        //
        return (SYSTEM_POWER_STATE)
            (irp.GetParameterPowerSystemPowerStateContext()).
                TargetSystemState;
    }

PowerPolicyHandleSystemQueryPower()

_Must_inspect_result_ NTSTATUS FxPkgPnp::PowerPolicyHandleSystemQueryPower ( __in SYSTEM_POWER_STATE  QueryState )

protected

Definition at line 3582 of file fxpkgpnp.cpp.

{
    PFX_DRIVER_GLOBALS FxDriverGlobals = GetDriverGlobals();
    NTSTATUS status;
 
    if (QueryState >= PowerSystemHibernate ||
        PowerPolicyCanWakeFromSystemState(QueryState)) {
        //
        // If the query is for the machine's minimum S state or we going into
        // hibernate or off, always succeed it.
        //
        status = STATUS_SUCCESS;
    }
    else {
 
        //
        // On Windows Vista and above, its OK to return a failure status code
        // if the system is going into an S state at which the device cannot
        // wake the system.
        //
        ASSERT(FxLibraryGlobals.OsVersionInfo.dwMajorVersion >= 6);
 
        //
        // The S state the machine is going into is one where we can't
        // wake it up because our D state is too low for this S state.
        // Since this isn't the minimum S state the machine is capable
        // of, reject the current query.
        //
        DoTraceLevelMessage(
            FxDriverGlobals, TRACE_LEVEL_WARNING, TRACINGPNP,
            "failing system query power because the device cannot wake the "
            "machine from S%d",
            QueryState - 1);
 
        status = STATUS_POWER_STATE_INVALID;
    }
 
    return status;
}

Referenced by FxPkgPdo::_DispatchQueryPower(), and FxPkgFdo::DispatchSystemQueryPower().

PowerPolicyIsWakeEnabled()

BOOLEAN FxPkgPnp::PowerPolicyIsWakeEnabled

(

VOID

)

Definition at line 5769 of file fxpkgpnp.cpp.

{
    if (IsPowerPolicyOwner() && PowerPolicyGetCurrentWakeReason() != 0x0) {
        return TRUE;
    }
    else {
        return FALSE;
    }
}

Referenced by FxPkgFdo::DispatchSystemQueryPower().

PowerPolicyPostParentToD0ToChildren()

VOID FxPkgPnp::PowerPolicyPostParentToD0ToChildren ( VOID  )

private

Definition at line 8007 of file powerpolicystatemachine.cpp.

{
    FxTransactionedEntry* ple;
 
    ASSERT(IsPowerPolicyOwner());
 
    if (m_EnumInfo != NULL) {
        m_EnumInfo->m_ChildListList.LockForEnum(GetDriverGlobals());
 
        ple = NULL;
        while ((ple = m_EnumInfo->m_ChildListList.GetNextEntry(ple)) != NULL) {
            ((FxChildList*) ple->GetTransactionedObject())->PostParentToD0();
        }
 
        m_EnumInfo->m_ChildListList.UnlockFromEnum(GetDriverGlobals());
    }
}

Referenced by PowerPolicyChildrenCanPowerUp().

PowerPolicyPowerDownForSx()

_Must_inspect_result_ NTSTATUS FxPkgPnp::PowerPolicyPowerDownForSx ( __in DEVICE_POWER_STATE  DxState, __in SendDeviceRequestAction  Action  )

inlineprivate

Definition at line 3996 of file fxpkgpnp.hpp.

    {
        //
        // The device is powering down because the system is moving into a lower
        // power state.
        //
        // If we have child devices, setup the guard so that they do not power
        // up while the parent is in low power.  Note that in this case (an Sx
        // transition) we do not look at the count of powered up children
        // because the power policy owner for the child's stack should not be
        // powering up the device once it has processed the Sx irp for its stack.
        //
        PowerPolicyBlockChildrenPowerUp();
 
        return PowerPolicySendDevicePowerRequest(DxState, Action);
    }

PowerPolicyProcessEvent()

VOID FxPkgPnp::PowerPolicyProcessEvent	(	__in FxPowerPolicyEvent	Event,
		__in BOOLEAN	ProcessEventOnDifferentThread = FALSE
	)

Definition at line 2886 of file powerpolicystatemachine.cpp.

{
    NTSTATUS status;
    ULONG mask;
    KIRQL irql;
 
    //
    // Take the lock, raising to DISPATCH_LEVEL.
    //
    m_PowerPolicyMachine.Lock(&irql);
 
    //
    // If the input Event is any of the events described by PowerSingularEventMask,
    // then check whether it is already queued up. If so, then dont enqueue this
    // Event.
    //
    if (Event & PowerPolSingularEventMask) {
        if ((m_PowerPolicyMachine.m_SingularEventsPresent & Event) == 0x00) {
            m_PowerPolicyMachine.m_SingularEventsPresent |= Event;
        }
        else {
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGPNP,
                "WDFDEVICE 0x%p !devobj 0x%p current pwr pol state "
                "%!WDF_DEVICE_POWER_POLICY_STATE! dropping event "
                "%!FxPowerPolicyEvent! because the Event is already enqueued.",
                m_Device->GetHandle(),
                m_Device->GetDeviceObject(),
                m_Device->GetDevicePowerPolicyState(), Event);
 
            m_PowerPolicyMachine.Unlock(irql);
            return;
        }
    }
 
    if (m_PowerPolicyMachine.IsFull()) {
        //
        // The queue is full.  Bail.
        //
        m_PowerPolicyMachine.Unlock(irql);
 
        ASSERT(!"The Power queue is full.  This shouldn't be able to happen.");
        return;
    }
 
    if (m_PowerPolicyMachine.IsClosedLocked()) {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGPNP,
            "WDFDEVICE 0x%p !devobj 0x%p current pwr pol state "
            "%!WDF_DEVICE_POWER_POLICY_STATE! dropping event "
            "%!FxPowerPolicyEvent! because of a closed queue",
            m_Device->GetHandle(),
            m_Device->GetDeviceObject(),
            m_Device->GetDevicePowerPolicyState(), Event);
 
        //
        // The queue is closed.  Bail
        //
        m_PowerPolicyMachine.Unlock(irql);
 
        return;
    }
 
    //
    // Enqueue the event.  Whether the event goes on the front
    // or the end of the queue depends on which event it is and if we are the
    // PPO or not.
    //
    // Yes, mask could be a member variable of m_PowerPolicyMachine, but why
    // waste 4 bytes when it is very easy to figure out?
    //
    mask = IsPowerPolicyOwner() ? PwrPolPriorityEventsMask
                                : PwrPolNotOwnerPriorityEventsMask;
 
    if (Event & mask) {
        //
        // Stick it on the front of the queue, making it the next event that
        // will be processed if, otherwise let these events go by.
        //
        m_PowerPolicyMachine.m_Queue[m_PowerPolicyMachine.InsertAtHead()] = Event;
    }
    else {
        //
        // Stick it on the end of the queue.
        //
        m_PowerPolicyMachine.m_Queue[m_PowerPolicyMachine.InsertAtTail()] = Event;
    }
 
    //
    // Drop the lock.
    //
    m_PowerPolicyMachine.Unlock(irql);
 
    //
    // Now, if we are running at PASSIVE_LEVEL, attempt to run the state
    // machine on this thread.  If we can't do that, then queue a work item.
    //
    if (FALSE == ShouldProcessPowerPolicyEventOnDifferentThread(
                    irql,
                    ProcessOnDifferentThread
                    )) {
 
        LONGLONG timeout = 0;
 
        status = m_PowerPolicyMachine.m_StateMachineLock.AcquireLock(
            GetDriverGlobals(), &timeout);
 
        if (FxWaitLockInternal::IsLockAcquired(status)) {
            FxPostProcessInfo info;
 
            //
            // We now hold the state machine lock.  So call the function that
            // dispatches the next state.
            //
            PowerPolicyProcessEventInner(&info);
 
            //
            // The pnp state machine should be the only one deleting the object
            //
            ASSERT(info.m_DeleteObject == FALSE);
 
            m_PowerPolicyMachine.m_StateMachineLock.ReleaseLock(
                GetDriverGlobals());
 
            info.Evaluate(this);
 
            return;
        }
    }
 
    //
    // The tag added above will be released when the work item runs
    //
 
    //
    // For one reason or another, we couldn't run the state machine on this
    // thread.  So queue a work item to do it.  If m_PnPWorkItemEnqueuing
    // is non-zero, that means that the work item is already being enqueued
    // on another thread.  This is significant, since it means that we can't do
    // anything with the work item on this thread, but it's okay, since the
    // work item will pick up our work and do it.
    //
    m_PowerPolicyMachine.QueueToThread();
}

Referenced by __drv_maxIRQL(), FxPowerIdleMachine::DisablingTimerExpired(), FxPkgPdo::DispatchSystemSetPower(), DispatchWaitWake(), FxPowerIdleMachine::InDxIoIncrement(), PnpPowerPolicyRemove(), PnpPowerPolicyStart(), PnpPowerPolicyStop(), PnpPowerPolicySurpriseRemove(), PowerDmaEnableAndScan(), PowerGotoDx(), PowerPolicySetS0IdleState(), PowerSendPowerDownEvents(), PowerSendPowerDownFailureEvent(), PowerSendPowerUpEvents(), PowerSendPowerUpFailureEvent(), FxPowerIdleMachine::TimedOutIoIncrement(), and FxPowerIdleMachine::TimingOut().

PowerPolicyProcessEventInner()

VOID FxPkgPnp::PowerPolicyProcessEventInner ( __inout FxPostProcessInfo *  Info )

protected

Definition at line 3084 of file powerpolicystatemachine.cpp.

{
    WDF_DEVICE_POWER_POLICY_STATE newState;
    FxPowerPolicyEvent event;
    ULONG i;
    KIRQL irql;
 
    if (IsPowerPolicyOwner()) {
        CPPOWER_POLICY_STATE_TABLE entry;
 
        //
        // Process as many events as we can.
        //
        for ( ; ; ) {
            entry = GetPowerPolicyTableEntry(m_Device->GetDevicePowerPolicyState());
 
            //
            // Get an event from the queue.
            //
            m_PowerPolicyMachine.Lock(&irql);
 
            if (m_PowerPolicyMachine.IsEmpty()) {
                m_PowerPolicyMachine.GetFinishedState(Info);
 
                //
                // The queue is empty.
                //
                m_PowerPolicyMachine.Unlock(irql);
                return;
            }
 
            event = m_PowerPolicyMachine.m_Queue[m_PowerPolicyMachine.GetHead()];
 
            //
            // At this point, we need to determine whether we can process this
            // event.
            //
            if (event & PwrPolPriorityEventsMask) {
                //
                // These are always possible to handle.
                //
                DO_NOTHING();
            }
            else {
                //
                // Check to see if this state can handle new events, ie if this
                // is a green dot (queue open) or red dot (queue *not* open) state.
                //
                if (entry->StateInfo.Bits.QueueOpen == FALSE) {
                    //
                    // This state can't handle new events.
                    //
                    m_PowerPolicyMachine.Unlock(irql);
                    return;
                }
            }
 
            //
            // If the event obtained from the queue was a singular event, then
            // clear the flag to allow other similar events to be put into this
            // queue for processing.
            //
            if (m_PowerPolicyMachine.m_SingularEventsPresent & event) {
               m_PowerPolicyMachine.m_SingularEventsPresent &= ~event;
            }
 
            m_PowerPolicyMachine.IncrementHead();
            m_PowerPolicyMachine.Unlock(irql);
 
            //
            // Find the entry in the power policy state table that corresponds
            // to this event.
            //
            newState = WdfDevStatePwrPolNull;
 
            if (entry->FirstTargetState.PowerPolicyEvent == event) {
                newState = entry->FirstTargetState.TargetState;
 
                DO_EVENT_TRAP(&entry->FirstTargetState);
            }
            else if (entry->OtherTargetStates != NULL) {
                for (i = 0;
                     entry->OtherTargetStates[i].PowerPolicyEvent != PwrPolNull;
                     i++) {
                    if (entry->OtherTargetStates[i].PowerPolicyEvent == event) {
                        newState = entry->OtherTargetStates[i].TargetState;
                        DO_EVENT_TRAP(&entry->OtherTargetStates[i]);
                        break;
                    }
                }
            }
 
            if (newState == WdfDevStatePwrPolNull) {
                //
                // This state doesn't respond to the event.  Just throw the event
                // away.
                //
                DoTraceLevelMessage(
                    GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
                    "WDFDEVICE 0x%p !devobj 0x%p current pwr pol state "
                    "%!WDF_DEVICE_POWER_POLICY_STATE! dropping event "
                    "%!FxPowerPolicyEvent!", m_Device->GetHandle(),
                    m_Device->GetDeviceObject(),
                    m_Device->GetDevicePowerPolicyState(), event);
 
                if ((entry->StateInfo.Bits.KnownDroppedEvents & event) == 0) {
                    COVERAGE_TRAP();
 
                    DoTraceLevelMessage(
                        GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                        "WDFDEVICE 0x%p !devobj 0x%p current state "
                        "%!WDF_DEVICE_POWER_POLICY_STATE!, policy event "
                        "%!FxPowerPolicyEvent! is not a known dropped "
                        "event, known dropped events are %!FxPowerPolicyEvent!",
                        m_Device->GetHandle(), m_Device->GetDeviceObject(),
                        m_Device->GetDevicePowerPolicyState(),
                        event, entry->StateInfo.Bits.KnownDroppedEvents);
 
 
                }
 
                //
                // Failsafes for events which have required processing in them.
                //
                switch (event) {
                case PwrPolSx:
                    //
                    // The Sx handling code expects that the state machine
                    // complete the Sx irp.  (S0 irps are never pended).  Since
                    // we don't have a state to transition to that will complete
                    // the request, do so now.
                    //
                    // (This can legitimately happen if a PDO is disabled and
                    //  the machines moves into an Sx state.)
                    //
                    PowerPolicyCompleteSystemPowerIrp();
                    break;
 
                case PwrPolUsbSelectiveSuspendCompleted:
                    //
                    // This state did not handle the event and event got
                    // dropped. However some state is definitely going to wait
                    // for this event. That's why we need m_EventDropped flag.
                    // If we didn't have this flag there will be no way to know
                    // if the event got dropped and some state will end up
                    // waiting for it indefinitely.
                    //
                    m_PowerPolicyMachine.m_Owner->m_UsbIdle->m_EventDropped = TRUE;
                    break;
 
                case PwrPolUsbSelectiveSuspendCallback:
                    m_PowerPolicyMachine.UsbSSCallbackProcessingComplete();
                    break;
 
                case PwrPolWakeSuccess:
                case PwrPolWakeFailed:
                    //
                    // This state did not handle the event and event got
                    // dropped. However some state is definitely going to wait
                    // for this event. That's why we need
                    // m_WakeCompletionEventDropped flag. If we didn't have this
                    // flag there will be no way to know if the event got
                    // dropped and some state will end up waiting for it
                    // indefinitely.
                    //
                    m_PowerPolicyMachine.m_Owner->m_WakeCompletionEventDropped = TRUE;
                    break;
 
                default:
                    DO_NOTHING();
                    break;
                }
            }
            else {
                //
                // Now enter the new state.
                //
                PowerPolicyEnterNewState(newState);
            }
        }
    }
    else {
        //
        // Process as many events as we can.
        //
        for ( ; ; ) {
            CPNOT_POWER_POLICY_OWNER_STATE_TABLE entry;
 
#pragma prefast(suppress:__WARNING_DEREF_NULL_PTR, "The current power policy state will always be in the table so entry will never be NULL")
            entry = GetNotPowerPolicyOwnerTableEntry(
                m_Device->GetDevicePowerPolicyState()
                );
 
            //
            // Get an event from the queue.
            //
            m_PowerPolicyMachine.Lock(&irql);
 
            if (m_PowerPolicyMachine.IsEmpty()) {
                //
                // The queue is empty.
                //
                m_PowerPolicyMachine.Unlock(irql);
                return;
            }
 
            event = m_PowerPolicyMachine.m_Queue[m_PowerPolicyMachine.GetHead()];
 
            //
            // At this point, we need to determine whether we can process this
            // event.
            //
            if (event & PwrPolNotOwnerPriorityEventsMask) {
                //
                // These are always possible to handle.
                //
                DO_NOTHING();
            }
            else {
                //
                // Check to see if this state can handle new events, ie if this
                // is a green dot (queue open) or red dot (queue *not* open) state.
                //
                if (entry->QueueOpen == FALSE) {
                    //
                    // This state can't handle new events.
                    //
                    m_PowerPolicyMachine.Unlock(irql);
                    return;
                }
            }
 
            //
            // If the event obtained from the queue was a singular event, then
            // clear the flag to allow other similar events to be put into this
            // queue for processing.
            //
            if (m_PowerPolicyMachine.m_SingularEventsPresent & event) {
               m_PowerPolicyMachine.m_SingularEventsPresent &= ~event;
            }
 
            m_PowerPolicyMachine.IncrementHead();
            m_PowerPolicyMachine.Unlock(irql);
 
            if (entry != NULL && entry->TargetStatesCount > 0) {
                for (i = 0; i < entry->TargetStatesCount; i++) {
                    if (event == entry->TargetStates[i].PowerPolicyEvent) {
                        DO_EVENT_TRAP(&entry->TargetStates[i]);
 
                        //
                        // Now enter the new state.
                        //
                        NotPowerPolicyOwnerEnterNewState(
                            entry->TargetStates[i].TargetState);
                        break;
                    }
                }
            }
        }
    }
}

Referenced by PowerPolicyProcessEvent().

PowerPolicySendDevicePowerRequest()

_Must_inspect_result_ NTSTATUS FxPkgPnp::PowerPolicySendDevicePowerRequest ( __in DEVICE_POWER_STATE  DeviceState, __in SendDeviceRequestAction  Action  )

protected

Definition at line 7524 of file powerpolicystatemachine.cpp.

{
    MdRequestPowerComplete pCompletionRoutine;
    LARGE_INTEGER interval;
    NTSTATUS status;
    POWER_STATE state;
    ULONG i;
 
    status = STATUS_UNSUCCESSFUL;
    interval.QuadPart = WDF_REL_TIMEOUT_IN_MS(500);
    state.DeviceState = DeviceState;
 
    if (DeviceState == PowerDeviceD0) {
        //
        // We are powering up, we do not synchronize the completion of the D0 irp
        // with a potential S0 irp. However we need to ensure that if an upper filter
        // driver fails the power irp, we handle it gracefully rather than keep waiting
        // for the power irp to arrive.
        //
        pCompletionRoutine = _PowerPolDevicePowerUpComplete;
    }
    else {
        //
        // We are powering down, we synchronize the completion of the Dx irp
        // with a potential Sx irp.  If there is no pending Sx irp, the state
        // machine takes care of it.
        //
        pCompletionRoutine = _PowerPolDevicePowerDownComplete;
    }
 
    //
    // We track when we request power irps to catch someone other then ourselves
    // sending power irps to our own stack.
    //
    if (DeviceState == PowerDeviceD0) {
        m_PowerPolicyMachine.m_Owner->m_RequestedPowerUpIrp = TRUE;
    }
    else {
        m_PowerPolicyMachine.m_Owner->m_RequestedPowerDownIrp = TRUE;
    }
 
    for (i = 0; i < 100; i++) {
        status = FxIrp::RequestPowerIrp(m_Device->GetDeviceObject(),
                                   IRP_MN_SET_POWER,
                                   state,
                                   pCompletionRoutine,
                                   this);
 
        //
        // If we are not retrying, we always break out
        //
        if (NT_SUCCESS(status) || Action == NoRetry) {
            break;
        }
 
        Mx::MxDelayExecutionThread(KernelMode, FALSE, &interval);
    }
 
    if (!NT_SUCCESS(status)) {
        //
        // We are no longer requesting a power irp
        //
        if (DeviceState == PowerDeviceD0) {
            m_PowerPolicyMachine.m_Owner->m_RequestedPowerUpIrp = FALSE;
        }
        else {
            m_PowerPolicyMachine.m_Owner->m_RequestedPowerDownIrp = FALSE;
        }
 
        if (Action == Retry) {
            COVERAGE_TRAP();
 
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                "Could not request D%d irp for device %p (WDFDEVICE %p), "
                "%!STATUS!", DeviceState-1,
                m_Device->GetDeviceObject(),
                m_Device->GetHandle(), status);
        }
    }
 
    DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
                        "Requesting D%d irp, %!STATUS!",
                        DeviceState-1, status);
 
    return status;
}

Referenced by PowerPolicyCanIdlePowerDown(), and PowerPolicyPowerDownForSx().

PowerPolicySendWaitWakeRequest()

_Must_inspect_result_ NTSTATUS FxPkgPnp::PowerPolicySendWaitWakeRequest ( __in SYSTEM_POWER_STATE  SystemState )

protected

Definition at line 7650 of file powerpolicystatemachine.cpp.

{
    NTSTATUS status;
    POWER_STATE state;
 
    state.SystemState = SystemState;
 
    //
    // We track when we request power irps to catch someone other then ourselves
    // sending power irps to our own stack.
    //
    m_PowerPolicyMachine.m_Owner->m_RequestedWaitWakeIrp = TRUE;
 
    //
    // Since we are sending a fresh wake, clear any state that was meant
    // for the last wake IRP
    //
    m_SystemWokenByWakeInterrupt = FALSE;
 
    //
    // we are requesting new ww irp so re-initialize dropped event tracker.
    //
    m_PowerPolicyMachine.m_Owner->m_WakeCompletionEventDropped = FALSE;
 
    DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
                        "Requesting wait wake irp for S%d", SystemState-1);
 
    status = FxIrp::RequestPowerIrp(m_Device->GetDeviceObject(),
                               IRP_MN_WAIT_WAKE,
                               state,
                               _PowerPolDeviceWaitWakeComplete,
                               this);
 
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                            "Requesting wait wake irp for S%d failed, %!STATUS!",
                            SystemState-1, status);
 
        //
        // We are no longer requesting a power irp
        //
        m_PowerPolicyMachine.m_Owner->m_RequestedWaitWakeIrp = FALSE;
    }
 
    return status;
}

PowerPolicySetS0IdleSettings()

NTSTATUS FxPkgPnp::PowerPolicySetS0IdleSettings

(

__in PWDF_DEVICE_POWER_POLICY_IDLE_SETTINGS

Settings

)

Definition at line 2778 of file fxpkgpnp.cpp.

{
    DEVICE_POWER_STATE dxState;
    ULONG idleTimeout;
    NTSTATUS status;
    BOOLEAN enabled, s0Capable, overridable, firstTime;
    WDF_TRI_STATE powerUpOnSystemWake;
    const LONGLONG negliblySmallIdleTimeout = -1; // 100 nanoseconds
 
    s0Capable = FALSE;
    dxState = PowerDeviceD3;
    overridable = FALSE;
    firstTime = TRUE;
 
    if (Settings->Enabled == WdfTrue) {
        enabled = TRUE;
 
    } else if (Settings->Enabled == WdfUseDefault) {
        enabled = TRUE;
 
        if (Mx::MxGetCurrentIrql() == PASSIVE_LEVEL) {
            DECLARE_CONST_UNICODE_STRING(valueName, WDF_S0_IDLE_DEFAULT_VALUE_NAME);
 
            //
            // Read registry. If registry value is not found, the value of "enabled"
            // remains unchanged
            //
            ReadRegistryS0Idle(&valueName, &enabled);
        }
        else {
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_WARNING, TRACINGPNP,
                "If registry value WdfDefaultIdleInWorkingState was present, "
                "it was not read because DDI WdfDeviceAssignS0IdleSettings "
                "was not called at PASSIVE_LEVEL");
        }
    }
    else {
        enabled = FALSE;
    }
 
    if (m_PowerPolicyMachine.m_Owner->m_IdleSettings.Set) {
        firstTime = FALSE;
    }
 
    if (m_CapsQueried == FALSE && Mx::MxGetCurrentIrql() == PASSIVE_LEVEL) {
        status = QueryForCapabilities();
        if (!NT_SUCCESS(status)) {
            return status;
        }
 
        //
        // Do not set m_CapsQueried to TRUE yet because we will do that once we
        // know the entire stack has been built we will do the query again.
        //
    }
 
    switch (Settings->IdleCaps) {
    case IdleUsbSelectiveSuspend:
    case IdleCanWakeFromS0:
        s0Capable = TRUE;
 
        if (Settings->DxState == PowerDeviceMaximum) {
            dxState = PowerPolicyGetDeviceDeepestDeviceWakeState(PowerSystemWorking);
 
            //
            // Some bus drivers
 
            // incorrectly report DeviceWake=D0 to
            // indicate that it does not support wake instead of specifying
            // PowerDeviceUnspecified and KMDF ends up requesting
            // a D0 irp when going to Dx. The check prevents this bug.
            //
            if (dxState < PowerDeviceD1 ||
                dxState > PowerDeviceD3 ||
                (dxState > PowerDeviceD2 && Settings->IdleCaps == IdleUsbSelectiveSuspend)
                ) {
                status = STATUS_POWER_STATE_INVALID;
 
                DoTraceLevelMessage(
                    GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                    "DeviceWake power state reported in device capabilities "
                    "%!DEVICE_POWER_STATE! indicates that device can not signal"
                    " a wake event, %!STATUS!",
                    dxState, status);
                return status;
            }
        }
        else {
            DEVICE_POWER_STATE dxDeepest;
 
            dxState = Settings->DxState;
            dxDeepest = PowerPolicyGetDeviceDeepestDeviceWakeState(PowerSystemWorking);
 
            if (dxState > dxDeepest) {
                status = STATUS_POWER_STATE_INVALID;
 
                DoTraceLevelMessage(
                    GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                    "DxState specified by driver %!DEVICE_POWER_STATE! cannot "
                    "be lighter than lightest available device wake state"
                    " %!DEVICE_POWER_STATE!, %!STATUS!", dxState,
                    dxDeepest, status);
                return status;
            }
 
            //
            // Can only perform wait wake from D2 on a USB device
            //
            if (dxState > PowerDeviceD2 &&
                Settings->IdleCaps == IdleUsbSelectiveSuspend) {
                status = STATUS_POWER_STATE_INVALID;
 
                DoTraceLevelMessage(
                    GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                    "DxState specified by driver %!DEVICE_POWER_STATE! cannot "
                    "be lighter than PowerDeviceD2 for USB selective suspend "
                    "%!STATUS!",
                    dxState, status);
                return status;
            }
        }
 
        if (Settings->IdleCaps == IdleUsbSelectiveSuspend) {
            status = m_PowerPolicyMachine.InitUsbSS();
 
            if (!NT_SUCCESS(status)) {
                DoTraceLevelMessage(
                    GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                    "Failed to initialize USB selective suspend %!STATUS!",
                    status);
                return status;
            }
        }
 
        break;
 
    case IdleCannotWakeFromS0:
        s0Capable = FALSE;
 
        if (Settings->DxState == PowerDeviceMaximum) {
            dxState = PowerDeviceD3;
        }
        else {
            dxState = Settings->DxState;
        }
 
        break;
 
    default:
        ASSERT(FALSE);
        break;
    }
 
    if (Settings->IdleTimeout == IdleTimeoutDefaultValue) {
        idleTimeout = FxPowerPolicyDefaultTimeout;
    }
    else {
        idleTimeout = Settings->IdleTimeout;
    }
 
    if (Settings->UserControlOfIdleSettings == IdleAllowUserControl) {
 
        // status = UpdateWmiInstanceForS0Idle(AddInstance);
        // if (!NT_SUCCESS(status)) {
        //     return status;
        // } __REACTOS__
 
        if (Settings->Enabled == WdfUseDefault) {
            //
            // Read the registry entry for idle enabled if it's the first time.
            //
            if (firstTime && Mx::MxGetCurrentIrql() == PASSIVE_LEVEL) {
                DECLARE_CONST_UNICODE_STRING(valueName, WDF_S0_IDLE_ENABLED_VALUE_NAME);
 
                //
                // Read registry. If registry value is not found, the value of
                // "enabled" remains unchanged
                //
                ReadRegistryS0Idle(&valueName, &enabled);
            }
            else {
                //
                // Use the saved value for idle enabled.
                //
                enabled = m_PowerPolicyMachine.m_Owner->m_IdleSettings.Enabled;
            }
        }
 
        overridable = TRUE;
    }
    else if (Settings->UserControlOfIdleSettings == IdleDoNotAllowUserControl) {
        //
        // No user control
        //
        overridable = FALSE;
 
        // (void) UpdateWmiInstanceForS0Idle(RemoveInstance); __REACTOS__
    }
 
    //
    // !!!! DO NOT INTRODUCE FAILURES BEYOND THIS POINT !!!!
    //
    // We should not introduce any failures that are not due to driver errors
    // beyond this point. This is because we are going to commit the driver's
    // S0-idle settings now and any failure in the midst of that could leave us
    // in a bad state. Therefore, all failable code where the failure is beyond
    // the driver's control should be placed above this point.
    //
    // For example, a driver may want wake-from-S0 support, but the device may
    // not support it. We already checked for that failure above, before we
    // started committing any of the driver's S0-idle settings.
    //
    // Any failures below this point should only be due to driver errors, i.e.
    // the driver incorrectly calling the AssignS0IdleSettings DDI.
    //
 
    if (firstTime) {
        m_PowerPolicyMachine.m_Owner->m_IdleSettings.Set = TRUE;
        m_PowerPolicyMachine.m_Owner->m_IdleSettings.Overridable = overridable;
    }
 
    //
    // IdleTimeoutType is available only on > 1.9
    //
#ifndef __REACTOS__
    if (Settings->Size > sizeof(WDF_DEVICE_POWER_POLICY_IDLE_SETTINGS_V1_9)) {
        if (firstTime) {
             if ((SystemManagedIdleTimeout == Settings->IdleTimeoutType) ||
                 (SystemManagedIdleTimeoutWithHint ==
                                        Settings->IdleTimeoutType)) {
                //
                // This is the first time S0-idle policy is being specified and
                // the caller has asked for the idle timeout to be determined
                // by the power manager.
                //
                status = m_PowerPolicyMachine.m_Owner->m_IdleSettings.
                            m_TimeoutMgmt.UseSystemManagedIdleTimeout(
                                                            GetDriverGlobals()
                                                            );
                if (!NT_SUCCESS(status)) {
                    return status;
                }
            }
        } else {
            //
            // This is not the first time S0-idle policy is being specified.
            // Verify that the caller is not trying to change their mind about
            // whether the idle timeout is determined by the power manager.
            //
            BOOLEAN currentlyUsingSystemManagedIdleTimeout;
            BOOLEAN callerWantsSystemManagedIdleTimeout;
 
            currentlyUsingSystemManagedIdleTimeout =
                m_PowerPolicyMachine.m_Owner->m_IdleSettings.m_TimeoutMgmt.
                                                UsingSystemManagedIdleTimeout();
            callerWantsSystemManagedIdleTimeout =
              ((SystemManagedIdleTimeout == Settings->IdleTimeoutType) ||
               (SystemManagedIdleTimeoutWithHint == Settings->IdleTimeoutType));
 
            //
            // UMDF currently does not implement
            // IdleTimeoutManagement::_SystemManagedIdleTimeoutAvailable. So
            // that method must be called only as part of the second check in
            // the "if" statement below. Since UMDF currently does not support
            // system managed idle timeout, the first check will always evaluate
            // to 'FALSE', so the second check never gets executed for UMDF.
            //
            if ((callerWantsSystemManagedIdleTimeout !=
                            currentlyUsingSystemManagedIdleTimeout)
                 &&
                (IdleTimeoutManagement::_SystemManagedIdleTimeoutAvailable())
                ) {
 
                status = STATUS_INVALID_DEVICE_REQUEST;
                DoTraceLevelMessage(
                    GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                    "A previous call to assign S0-idle policy specified that "
                    "the idle timeout %s be determined by the power manager. "
                    "This decision cannot be changed. %!STATUS!",
                    currentlyUsingSystemManagedIdleTimeout ?
                      "should" :
                      "should not",
                    status);
                FxVerifierDbgBreakPoint(GetDriverGlobals());
                return status;
            }
        }
    }
#endif
 
    if (Settings->IdleCaps == IdleCannotWakeFromS0) {
        //
        // PowerUpIdleDeviceOnSystemWake field added after v1.7.
        // By default KMDF uses an optimization where the device is not powered
        // up when resuming from Sx if it is idle. The field
        // PowerUpIdleDeviceOnSystemWake is used to turn off this optimization and allow
        // device to power up when resuming from Sx. Note that this optimization
        // is applicable only for IdleCannotWakeFromS0. In other cases the
        // device is always powered up in order to arm for wake.
        //
        powerUpOnSystemWake =
            (Settings->Size > sizeof(WDF_DEVICE_POWER_POLICY_IDLE_SETTINGS_V1_7)) ?
            Settings->PowerUpIdleDeviceOnSystemWake :
            WdfUseDefault;
 
        switch(powerUpOnSystemWake) {
        case WdfTrue:
            m_PowerPolicyMachine.m_Owner->m_IdleSettings.PowerUpIdleDeviceOnSystemWake = TRUE;
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
                "Driver turned off S0Idle optimization. Device will be "
                "powered up on resume from Sx even when it is idle");
            break;
        case WdfFalse:
            m_PowerPolicyMachine.m_Owner->m_IdleSettings.PowerUpIdleDeviceOnSystemWake = FALSE;
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
                "Driver turned on S0Idle optimization. Device will remain "
                "powered off if idle when resuming from Sx");
            break;
        case WdfUseDefault:
            DO_NOTHING();
            break;
        default:
            break;
        }
    }
 
    if (FALSE ==
            m_PowerPolicyMachine.m_Owner->m_IdleSettings.UsbSSCapabilityKnown)
    {
        if (Settings->IdleCaps == IdleUsbSelectiveSuspend) {
            m_PowerPolicyMachine.m_Owner->m_IdleSettings.UsbSSCapable = TRUE;
            m_PowerPolicyMachine.m_Owner->
                m_IdleSettings.UsbSSCapabilityKnown = TRUE;
 
        } else if (Settings->IdleCaps == IdleCanWakeFromS0) {
 
            m_PowerPolicyMachine.m_Owner->
                m_IdleSettings.UsbSSCapabilityKnown = TRUE;
        }
    }
 
    //
    // Wake FromS0Capable is set every time because we want to allow the driver
    // to swap between idle wake capable and idle not wake capable.  This should
    // be allowed so that a scenario similar to the following can be implemented:
    //
    // a) when the device has an outstanding open, the device should arm itself
    //    for wake when idle
    //
    // b)  when the device does not have an outstanding open, the device should
    //     be off and not armed.
    //
    // The only way to be off is to assign S0 wake settings, so the
    // WakeFromS0Capable field must change on each DDI call.  This is not a
    // problem for the power policy state machine because it evaluates
    // WakeFromS0Capable state before enabling of idle.  If we are not
    // WakeFromS0Capable and USB SS capable (ie a have a torn/unsynchronized
    // state) in m_IdleSettings, we will recover from it when processing
    // PwrPolS0IdlePolicyChanged in the state machine (b/c this event causes
    // both fields to be reevaluated).
    //
    m_PowerPolicyMachine.m_Owner->m_IdleSettings.WakeFromS0Capable = s0Capable;
 
    m_PowerPolicyMachine.m_Owner->m_IdleSettings.DxState = dxState;
 
    if (m_PowerPolicyMachine.m_Owner->
            m_IdleSettings.m_TimeoutMgmt.UsingSystemManagedIdleTimeout()) {
        //
        // With system managed idle timeout, we don't want to apply an idle
        // timeout of our own on top of that. Effectively, our idle timeout is
        // 0.
        // But we apply a negligibly small timeout value as this allows us to
        // keep the same logic in the idle state machine, regardless of whether
        // we're using system-managed idle timeout or driver-managed idle
        // timeout.
        //
        if (firstTime) {
            m_PowerPolicyMachine.m_Owner->
                m_PowerIdleMachine.m_PowerTimeout.QuadPart =
                                            negliblySmallIdleTimeout;
        }
 
        if (SystemManagedIdleTimeoutWithHint == Settings->IdleTimeoutType) {
            //
            // We save the idle timeout hint, but we don't provide the hint to
            // the power framework immediately. This is because currently we may
            // or may not be registered with the power framework. Note that
            // WdfDeviceAssignS0IdleSettings might get called even when we are
            // not registered with the power framework.
            //
            // Therefore, we provide the hint to the power framework only when
            // we get to the WdfDevStatePwrPolStartingDecideS0Wake state. This
            // state is a good choice for providing the hint because:
            //   1. We know we would be registered with the power framework when
            //      we are in this state.
            //   2. Any change in S0-idle settings causes us to go through this
            //      state.
            //
            m_PowerPolicyMachine.m_Owner->m_PoxInterface.m_NextIdleTimeoutHint =
                                                                    idleTimeout;
        }
 
    } else {
        m_PowerPolicyMachine.m_Owner->m_PowerIdleMachine.m_PowerTimeout.QuadPart
            = WDF_REL_TIMEOUT_IN_MS(idleTimeout);
    }
 
    //
    // If the driver is 1.11 or later, update the bus drivers with the client's
    // choice on the topic of D3hot or D3cold.
    //
    if ((Settings->Size > sizeof(WDF_DEVICE_POWER_POLICY_IDLE_SETTINGS_V1_9)) &&
        (Settings->ExcludeD3Cold != WdfUseDefault)) {
        MxDeviceObject deviceObject;
        BOOLEAN enableD3Cold;
 
        deviceObject.SetObject(m_Device->GetDeviceObject());
 
        switch (Settings->ExcludeD3Cold) {
        case WdfFalse:
            enableD3Cold = TRUE;
            break;
        default:
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                "Invalid tri-state value for ExcludeD3Cold %d",
                Settings->ExcludeD3Cold);
            __fallthrough;
        case WdfTrue:
            enableD3Cold = FALSE;
            break;
        }
 
        SetD3ColdSupport(GetDriverGlobals(),
                         &deviceObject,
                         &m_D3ColdInterface,
                         enableD3Cold);
    }
 
    PowerPolicySetS0IdleState(enabled);
 
    return STATUS_SUCCESS;
}

PowerPolicySetS0IdleState()

VOID FxPkgPnp::PowerPolicySetS0IdleState

(

__in BOOLEAN

State

)

Definition at line 3710 of file fxpkgpnp.cpp.

{
    m_PowerPolicyMachine.m_Owner->m_IdleSettings.Enabled = State ? TRUE : FALSE;
    m_PowerPolicyMachine.m_Owner->m_IdleSettings.Dirty = TRUE;
    PowerPolicyProcessEvent(PwrPolS0IdlePolicyChanged);
}

Referenced by _S0IdleSetInstance(), _S0IdleSetItem(), PowerPolicySetS0IdleSettings(), and FxDevice::ProcessWmiPowerQueryOrSetData().

PowerPolicySetSxWakeSettings()

NTSTATUS FxPkgPnp::PowerPolicySetSxWakeSettings	(	__in PWDF_DEVICE_POWER_POLICY_WAKE_SETTINGS	Settings,
		__in BOOLEAN	ArmForWakeIfChildrenAreArmedForWake,
		__in BOOLEAN	IndicateChildWakeOnParentWake
	)

Definition at line 3245 of file fxpkgpnp.cpp.

{
    DEVICE_POWER_STATE dxState;
    NTSTATUS status;
    BOOLEAN overridable, firstTime, enabled;
 
    dxState = PowerDeviceD3;
    overridable = FALSE;
    firstTime = TRUE;
 
    if (Settings->Enabled == WdfTrue) {
        enabled = TRUE;
 
    }
    else if (Settings->Enabled == WdfUseDefault) {
        enabled = TRUE;
 
        if (Mx::MxGetCurrentIrql() == PASSIVE_LEVEL) {
            DECLARE_CONST_UNICODE_STRING(valueName, WDF_SX_WAKE_DEFAULT_VALUE_NAME);
 
            //
            // Read registry. If registry value is not found, the value of "enabled"
            // remains unchanged
            //
            ReadRegistrySxWake(&valueName, &enabled);
        }
        else {
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_WARNING, TRACINGPNP,
                "If registry value WdfDefaultWakeFromSleepState was present, "
                "it was not read because DDI WdfDeviceAssignSxWakeSettings "
                "was not called at PASSIVE_LEVEL");
        }
    }
    else {
        enabled = FALSE;
    }
 
    if (m_PowerPolicyMachine.m_Owner->m_WakeSettings.Set) {
        firstTime = FALSE;
    }
 
    if (m_CapsQueried == FALSE && Mx::MxGetCurrentIrql() == PASSIVE_LEVEL) {
        status = QueryForCapabilities();
        if (!NT_SUCCESS(status)) {
            return status;
        }
 
        //
        // Do not set m_CapsQueried to TRUE yet because we will do that once we
        // know the entire stack has been built we will do the query again.
        //
    }
 
    if (Settings->DxState == PowerDeviceMaximum) {
        dxState = PowerPolicyGetDeviceDeepestDeviceWakeState((SYSTEM_POWER_STATE)m_SystemWake);
 
        //
        // Some bus drivers
 
        // incorrectly report DeviceWake=D0 to
        // indicate that it does not support wake instead of specifying
        // PowerDeviceUnspecified and KMDF ends up requesting
        // a D0 irp when going to Dx. The check prevents this bug.
        //
        if (dxState < PowerDeviceD1 || dxState > PowerDeviceD3) {
            status = STATUS_POWER_STATE_INVALID;
 
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                "DeviceWake power state reported in device capabilities "
                "%!DEVICE_POWER_STATE! indicates that device can not signal a "
                "wake event, %!STATUS!",
                dxState, status);
            return status;
        }
    }
    else {
        DEVICE_POWER_STATE dxDeepest;
 
        dxState = Settings->DxState;
        dxDeepest = PowerPolicyGetDeviceDeepestDeviceWakeState((SYSTEM_POWER_STATE)m_SystemWake);
 
        if (dxState > dxDeepest) {
            status = STATUS_POWER_STATE_INVALID;
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                "DxState specified by driver %!DEVICE_POWER_STATE! cannot be"
                " lighter than lightest available device wake state "
                "%!DEVICE_POWER_STATE!, %!STATUS!", dxState,
                dxDeepest, status);
            return status;
        }
    }
 
    if (Settings->UserControlOfWakeSettings == WakeAllowUserControl) {
 
        // status = UpdateWmiInstanceForSxWake(AddInstance); __REACTOS__
 
        // if (!NT_SUCCESS(status)) {
        //     return status;
        // }
 
        if (Settings->Enabled == WdfUseDefault) {
            //
            // Read the registry entry for wake enabled if it's the first time.
            //
            if (firstTime && Mx::MxGetCurrentIrql() == PASSIVE_LEVEL) {
                DECLARE_CONST_UNICODE_STRING(valueName, WDF_SX_WAKE_ENABLED_VALUE_NAME);
 
                //
                // Read registry. If registry value is not found, the value of
                // "enabled" remains unchanged
                //
                ReadRegistrySxWake(&valueName, &enabled);
            }
            else {
                //
                // Use the saved value for wake enabled.
                //
                enabled = m_PowerPolicyMachine.m_Owner->m_WakeSettings.Enabled;
            }
        }
 
        overridable = TRUE;
    }
    else if (Settings->UserControlOfWakeSettings == WakeDoNotAllowUserControl) {
        //
        // No user control, just set to enabled
        //
        overridable = FALSE;
 
        // (void) UpdateWmiInstanceForSxWake(RemoveInstance); __REACTOS__
    }
 
    if (firstTime) {
        m_PowerPolicyMachine.m_Owner->m_WakeSettings.Set = TRUE;
        m_PowerPolicyMachine.m_Owner->m_WakeSettings.Overridable = overridable;
 
        //
        // If ArmForWakeIfChildrenAreArmedForWake setting is set to FALSE,
        // then we use the legacy framework behavior which did not depend
        // on the child device being capable of arming for wake or not.
        //
        m_PowerPolicyMachine.m_Owner->m_WakeSettings.ArmForWakeIfChildrenAreArmedForWake =
            ArmForWakeIfChildrenAreArmedForWake;
 
        //
        // If IndicateChildWakeOnParentWake setting is set to FALSE, then
        // we use the legacy framework behavior wherein the wake status
        // is not propagated from the parent device to the child device.
        //
        m_PowerPolicyMachine.m_Owner->m_WakeSettings.IndicateChildWakeOnParentWake =
            IndicateChildWakeOnParentWake;
    }
 
    m_PowerPolicyMachine.m_Owner->m_WakeSettings.DxState = dxState;
 
    PowerPolicySetSxWakeState(enabled);
 
    return STATUS_SUCCESS;
}

PowerPolicySetSxWakeState()

VOID FxPkgPnp::PowerPolicySetSxWakeState

(

__in BOOLEAN

State

)

Definition at line 3720 of file fxpkgpnp.cpp.

{
    m_PowerPolicyMachine.m_Owner->m_WakeSettings.Enabled = State ? TRUE : FALSE;
    m_PowerPolicyMachine.m_Owner->m_WakeSettings.Dirty = TRUE;
 
    //
    // Since we are not posting an event to the power policy state machine, try
    // to write out the value now, otherwise it will be written when we
    // transition
    //
    if (Mx::MxGetCurrentIrql() == PASSIVE_LEVEL) {
        NTSTATUS status;
        LONGLONG timeout;
 
        timeout = 0;
 
        //
        // If the lock is already acquired on this thread, this will fail, which
        // is OK.
        //
        status = m_PowerPolicyMachine.m_StateMachineLock.AcquireLock(
            GetDriverGlobals(),
            &timeout
            );
 
        if (FxWaitLockInternal::IsLockAcquired(status)) {
            SaveState(TRUE);
 
            m_PowerPolicyMachine.m_StateMachineLock.ReleaseLock(
                GetDriverGlobals()
                );
        }
    }
}

Referenced by _SxWakeSetInstance(), _SxWakeSetItem(), PowerPolicySetSxWakeSettings(), and FxDevice::ProcessWmiPowerQueryOrSetData().

PowerPolicyShouldPropagateWakeStatusToChildren()

BOOLEAN __inline FxPkgPnp::PowerPolicyShouldPropagateWakeStatusToChildren ( VOID  )

inline

Definition at line 3407 of file fxpkgpnp.hpp.

    {
        return m_PowerPolicyMachine.m_Owner->m_WakeSettings.IndicateChildWakeOnParentWake;
    }

Referenced by PowerPolicyDisarmWakeFromSx().

PowerPolicySubmitUsbIdleNotification()

VOID FxPkgPnp::PowerPolicySubmitUsbIdleNotification ( VOID  )

protected

Definition at line 162 of file powerpolicystatemachinekm.cpp.

{
    // FxIrp* usbIdleIrp;
 
    // //
    // // This will be set to TRUE if USBSS completion event gets dropped.
    // //
    // m_PowerPolicyMachine.m_Owner->m_UsbIdle->m_EventDropped = FALSE;
 
    // usbIdleIrp = &m_PowerPolicyMachine.m_Owner->m_UsbIdle->m_IdleIrp;
 
    // usbIdleIrp->Reuse();
 
    // usbIdleIrp->SetCompletionRoutineEx(
    //     m_Device->GetDeviceObject(),
    //     _PowerPolicyUsbSelectiveSuspendCompletionRoutine,
    //     this);
 
    // usbIdleIrp->SetMajorFunction(IRP_MJ_INTERNAL_DEVICE_CONTROL);
    // usbIdleIrp->SetParameterIoctlCode(
    //     IOCTL_INTERNAL_USB_SUBMIT_IDLE_NOTIFICATION);
    // usbIdleIrp->SetParameterIoctlInputBufferLength(
    //     sizeof(m_PowerPolicyMachine.m_Owner->m_UsbIdle->m_CallbackInfo));
    // usbIdleIrp->SetParameterIoctlType3InputBuffer(
    //     (PVOID) &m_PowerPolicyMachine.m_Owner->m_UsbIdle->m_CallbackInfo);
 
    // m_PowerPolicyMachine.m_Owner->m_UsbIdle->m_IdleIrp.CallDriver(
    //     m_Device->GetAttachedDevice()
    //     );
    ROSWDFNOTIMPLEMENTED;
}

PowerPolicyUpdateSystemWakeSource()

VOID FxPkgPnp::PowerPolicyUpdateSystemWakeSource ( __in FxIrp *  Irp )

protected

Definition at line 35 of file powerpolicystatemachinekm.cpp.

{
    //
    // Check to see if this device caused the machine to wake up
    //
    m_PowerPolicyMachine.m_Owner->m_SystemWakeSource =
        PoGetSystemWake(Irp->GetIrp());
 
    if (m_PowerPolicyMachine.m_Owner->m_SystemWakeSource) {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGPNP,
            "WDFDEVICE 0x%p !devobj 0x%p WW !irp 0x%p is a source of "
            "wake",
            m_Device->GetHandle(),
            m_Device->GetDeviceObject(),
            Irp->GetIrp());
    }
}

PowerPolIdleCapableDeviceIdle()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolIdleCapableDeviceIdle ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3752 of file powerpolicystatemachine.cpp.

{
    BOOLEAN canPowerDown;
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolIdleCapableDeviceIdle);
 
    canPowerDown = This->m_PowerPolicyMachine.m_Owner->
                        m_PoxInterface.DeclareComponentIdle();
 
    //
    // If we are using driver-managed idle timeout we can power down immediately
    // and so we jump to the next state (that initiates power down) immediately.
    // If we are using system-managed idle timeout, we wait in the current state
    // for device-power-not-required notification.
    //
    return (canPowerDown ?
                WdfDevStatePwrPolTimerExpiredNoWake :
                WdfDevStatePwrPolNull);
}

PowerPolIoPresentArmed()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolIoPresentArmed ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 5794 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolIoPresentArmed);
 
    if (This->PowerPolicyCancelWaitWake() == FALSE &&
        This->m_PowerPolicyMachine.m_Owner->m_WakeCompletionEventDropped) {
        COVERAGE_TRAP();
        return WdfDevStatePwrPolIoPresentArmedWakeCanceled;
    }
 
    return WdfDevStatePwrPolNull;
}

PowerPolIoPresentArmedWakeCanceled()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolIoPresentArmedWakeCanceled ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 5825 of file powerpolicystatemachine.cpp.

{
    NTSTATUS status;
 
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolIoPresentArmedWakeCanceled);
 
    This->m_PowerPolicyMachine.m_Owner->
            m_PoxInterface.RequestComponentActive();
 
    status = This->PowerPolicySendDevicePowerRequest(PowerDeviceD0, Retry);
 
    if (!NT_SUCCESS(status)) {
        COVERAGE_TRAP();
        return WdfDevStatePwrPolDeviceD0PowerRequestFailed;
    }
 
    return WdfDevStatePwrPolNull;
}

PowerPolPowerUpForSystemSleepFailed()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolPowerUpForSystemSleepFailed ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 6177 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolPowerUpForSystemSleepFailed);
 
    This->PowerPolicyCompleteSystemPowerIrp();
 
    return WdfDevStatePwrPolDevicePowerRequestFailed;
}

PowerPolPowerUpForSystemSleepNotSeen()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolPowerUpForSystemSleepNotSeen ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 7301 of file powerpolicystatemachine.cpp.

{
    if (This->m_PendingSystemPowerIrp != NULL) {
        This->PowerPolicyCompleteSystemPowerIrp();
    }
 
    return WdfDevStatePwrPolDeviceD0PowerRequestFailed;
}

PowerPolRemoved()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolRemoved ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 6640 of file powerpolicystatemachine.cpp.

{
    KIRQL irql;
 
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolRemoved);
 
    //
    // We raise IRQL to dispatch level so that pnp is forced onto its own thread
    // to process the PwrPolRemoved event.  If pnp is on the power thread when
    // it processes the event and it tries to delete the dedicated thread, it
    // will deadlock waiting for the thread it is on to exit.
    //
    Mx::MxRaiseIrql(DISPATCH_LEVEL, &irql);
    This->PnpProcessEvent(PnpEventPwrPolRemoved);
    Mx::MxLowerIrql(irql);
 
    return WdfDevStatePwrPolNull;
}

PowerPolRestarting()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolRestarting ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 6675 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolRestarting);
 
    This->m_PowerPolicyMachine.m_Owner->m_PowerIdleMachine.Start();
 
    This->PowerProcessEvent(PowerImplicitD0);
 
    //
    // Wait for the successful power up before starting any idle timers.  If
    // the power up fails, we will not send a power policy stop from the pnp
    // engine.
    //
    return WdfDevStatePwrPolNull;
}

PowerPolRestartingFailed()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolRestartingFailed ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 6706 of file powerpolicystatemachine.cpp.

{
    KIRQL irql;
 
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolRestartingFailed);
 
    This->m_PowerPolicyMachine.m_Owner->m_PowerIdleMachine.Stop();
 
    //
    // We raise IRQL to dispatch level so that pnp is forced onto its own thread
    // to process the PwrPolStartFailed event.  If pnp is on the power thread
    // when it processes the event and it tries to delete the dedicated thread,
    // it will deadlock waiting for the thread it is on to exit.
    //
    Mx::MxRaiseIrql(DISPATCH_LEVEL, &irql);
    This->PnpProcessEvent(PnpEventPwrPolStartFailed);
    Mx::MxLowerIrql(irql);
 
    return WdfDevStatePwrPolStopped;
}

PowerPolS0NoWakeCompletePowerUp()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolS0NoWakeCompletePowerUp ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4001 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolS0NoWakeCompletePowerUp);
 
    This->m_PowerPolicyMachine.m_Owner->
                m_PoxInterface.DeviceIsPoweredOn();
 
    This->PowerProcessEvent(PowerCompleteD0);
 
    return WdfDevStatePwrPolNull;
}

PowerPolS0NoWakePowerUp()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolS0NoWakePowerUp ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3977 of file powerpolicystatemachine.cpp.

{
    NTSTATUS status;
 
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolS0NoWakePowerUp);
 
    //
    // Attempt to get back to the D0 state
    //
    This->m_PowerPolicyMachine.m_Owner->
            m_PoxInterface.RequestComponentActive();
    status = This->PowerPolicySendDevicePowerRequest(PowerDeviceD0, Retry);
 
    if (!NT_SUCCESS(status)) {
        COVERAGE_TRAP();
        return WdfDevStatePwrPolDeviceD0PowerRequestFailed;
    }
 
    return WdfDevStatePwrPolNull;
}

PowerPolS0WakeCompletePowerUp()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolS0WakeCompletePowerUp ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 5872 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolS0WakeCompletePowerUp);
 
    This->PowerProcessEvent(PowerCompleteD0);
 
    return WdfDevStatePwrPolNull;
}

PowerPolS0WakeDisarm()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolS0WakeDisarm ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 5847 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolS0WakeDisarm);
 
    This->m_PowerPolicyMachine.m_Owner->
                m_PoxInterface.DeviceIsPoweredOn();
 
    //
    // If the PDO is the Power Policy owner, then disable wake at bus, otherwise
    // the power state machine will disable wake at bus.
    //
    if (This->m_Device->IsPdo()) {
        This->PowerDisableWakeAtBusOverload();
    }
 
    This->m_PowerPolicyMachine.m_Owner->m_DeviceDisarmWakeFromS0.Invoke(
        This->m_Device->GetHandle()
        );
 
    return WdfDevStatePwrPolS0WakeCompletePowerUp;
}

PowerPolSleeping()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolSleeping ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4751 of file powerpolicystatemachine.cpp.

{
    NTSTATUS notifyPowerDownStatus;
    SYSTEM_POWER_STATE systemState;
 
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolSleeping);
 
    //
    // If the bus/PDO is not in the hibernate path, then verify that all the
    // children have powered down by now.
    //
    if (This->GetUsageCount(WdfSpecialFileHibernation) == 0 &&
        This->m_PowerPolicyMachine.m_Owner->m_ChildrenPoweredOnCount > 0) {
        DoTraceLevelMessage(
            This->GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
            "WDFDEVICE %p powering down before child devices have powered down. "
            "This usually indicates a faulty child device that completed the Sx "
            "irp before sending the Dx irp",
            This->m_Device->GetHandle());
 
        FxVerifierBreakOnDeviceStateError(
            This->m_Device->GetDriverGlobals());
    }
 
    //
    // Simulate a device-power-not-required notification from the power
    // framework. An Sx-IRP is essentially equivalent to a device-power-not-
    // required notification.
    //
    This->m_PowerPolicyMachine.m_Owner->
        m_PoxInterface.SimulateDevicePowerNotRequired();
 
    //
    // Notify the device-power-requirement state machine that we are about to
    // power down
    //
    notifyPowerDownStatus = This->m_PowerPolicyMachine.m_Owner->
                              m_PoxInterface.NotifyDevicePowerDown();
 
    //
    // We simulated a device-power-not-required notification before we notified
    // the device-power-requirement state machine that we are powering down.
    // Therefore, our notification should have succeeded.
    //
    ASSERT(NT_SUCCESS(notifyPowerDownStatus));
    UNREFERENCED_PARAMETER(notifyPowerDownStatus);
 
    systemState = This->PowerPolicyGetPendingSystemState();
 
    if (This->PowerPolicyIsWakeEnabled() &&
        This->PowerPolicyCanWakeFromSystemState(systemState)) {
        return WdfDevStatePwrPolSleepingWakePowerDown;
    }
    else {
        return WdfDevStatePwrPolSleepingNoWakePowerDown;
    }
}

PowerPolSleepingNoWakeCompletePowerDown()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolSleepingNoWakeCompletePowerDown ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4885 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This,
                         WdfDevStatePwrPolSleepingNoWakeCompletePowerDown);
 
    This->PowerProcessEvent(PowerCompleteDx);
 
    return WdfDevStatePwrPolNull;
}

PowerPolSleepingNoWakeDxRequestFailed()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolSleepingNoWakeDxRequestFailed ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4912 of file powerpolicystatemachine.cpp.

{
    COVERAGE_TRAP();
 
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolSleepingNoWakeDxRequestFailed);
 
    This->SetInternalFailure();
    This->PowerPolicyCompleteSystemPowerIrp();
 
    if (FALSE == This->m_ReleaseHardwareAfterDescendantsOnFailure) {
        This->PnpProcessEvent(PnpEventPowerDownFailed);
    }
 
    return WdfDevStatePwrPolDevicePowerRequestFailed;
}

PowerPolSleepingNoWakePowerDown()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolSleepingNoWakePowerDown ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4826 of file powerpolicystatemachine.cpp.

{
    NTSTATUS status;
    DEVICE_POWER_STATE dxState;
 
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolSleepingNoWakePowerDown);
 
    dxState = (DEVICE_POWER_STATE)
        This->m_PowerPolicyMachine.m_Owner->m_IdealDxStateForSx;
 
    if (dxState != PowerDeviceD3) {
        DEVICE_POWER_STATE dxMappedState;
 
        //
        // Get the lightest Dx state for this Sx state as reported by the
        // device capabilities of the stack.
        //
        dxMappedState = _GetPowerCapState(
            This->PowerPolicyGetPendingSystemState(),
            This->m_PowerPolicyMachine.m_Owner->m_SystemToDeviceStateMap
            );
 
        //
        // If the ideal desired state is lighter than what the S->D mapping says
        // is the lightest supported D state, use the mapping value instead.
        //
        if (dxState < dxMappedState) {
            dxState = dxMappedState;
        }
    }
 
    ASSERT(dxState >= PowerDeviceD1 && dxState <= PowerDeviceD3);
 
    status = This->PowerPolicyPowerDownForSx(dxState, Retry);
 
    if (!NT_SUCCESS(status)) {
        COVERAGE_TRAP();
        return WdfDevStatePwrPolSleepingNoWakeDxRequestFailed;
    }
 
    return WdfDevStatePwrPolNull;
}

PowerPolSleepingPowerDownNotProcessed()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolSleepingPowerDownNotProcessed ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 7119 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolSleepingPowerDownNotProcessed);
 
    This->SetInternalFailure();
 
    return WdfDevStatePwrPolSystemSleepPowerRequestFailed;
}

PowerPolSleepingSendWake()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolSleepingSendWake ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4966 of file powerpolicystatemachine.cpp.

{
    SYSTEM_POWER_STATE systemState;
    NTSTATUS status;
 
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolSleepingSendWake);
 
    //
    // We are in a wake-enabled path, keep wake interrupts connected.
    //
    This->m_WakeInterruptsKeepConnected = TRUE;
 
    //
    // We use the deepest possible Sx state instead of the current Sx state so
    // that we can handle the FastS4 case where PowerPolicyGetPendingSystemState
    // would return, but we could possible goto S4.  By using the deepest
    // possible state, we can arm for any possible Sx state that we are capable
    // of waking from.
    //
    systemState = This->PowerPolicyGetDeviceDeepestSystemWakeState();
 
    status = This->PowerPolicySendWaitWakeRequest(systemState);
 
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(
            This->GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
            "Attempting to send wait wake request for EvtDeviceArmWakeFromSx() "
            "failed, %!STATUS!", status);
 
        COVERAGE_TRAP();
 
        return WdfDevStatePwrPolSleepingNoWakeCompletePowerDown;
    }
 
    return WdfDevStatePwrPolNull;
}

PowerPolSleepingWakePowerDown()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolSleepingWakePowerDown ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4931 of file powerpolicystatemachine.cpp.

{
    NTSTATUS status;
 
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolSleepingWakePowerDown);
 
    status = This->PowerPolicyPowerDownForSx(
        This->m_PowerPolicyMachine.m_Owner->m_WakeSettings.DxState, NoRetry
        );
 
    if (!NT_SUCCESS(status)) {
        COVERAGE_TRAP();
        return WdfDevStatePwrPolSleepingNoWakePowerDown;
    }
 
    return WdfDevStatePwrPolNull;
}

PowerPolSleepingWakePowerDownFailed()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolSleepingWakePowerDownFailed ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4521 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(
        This, WdfDevStatePwrPolSleepingWakePowerDownFailed);
 
    if (This->PowerPolicyCancelWaitWake() == FALSE &&
        This->m_PowerPolicyMachine.m_Owner->m_WakeCompletionEventDropped) {
        return WdfDevStatePwrPolSleepingWakePowerDownFailedWakeCanceled;
    }
 
    return WdfDevStatePwrPolNull;
}

PowerPolSleepingWakePowerDownFailedWakeCanceled()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolSleepingWakePowerDownFailedWakeCanceled ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4551 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(
        This, WdfDevStatePwrPolSleepingWakePowerDownFailedWakeCanceled);
 
    This->PowerPolicyCompleteSystemPowerIrp();
 
    return WdfDevStatePwrPolDevicePowerRequestFailed;
}

PowerPolSleepingWakeRevertArmWake()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolSleepingWakeRevertArmWake ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4251 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(
        This, WdfDevStatePwrPolSleepingWakeRevertArmWake);
 
    DoTraceLevelMessage(
        This->GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
        "reverting arm for wake from Sx due to failure to allocate wait wake "
        "request or wait wake request completed immeidately.  Device will *NOT* "
        "be armed for wake from Sx");
 
    //
    // Enable calls should be matched with Disable calls even in the failure
    // cases. However, for the Enable wake at bus failure, we do not call the
    // disable wake at bus method as we try to keep the failure behavior
    // consistent with the Power State machine. Only the Device Disarm wake
    // callback will be invoked here.
    //
    This->PowerPolicyDisarmWakeFromSx();
 
    //
    // attempt to cancel ww
    //
    if (This->PowerPolicyCancelWaitWake() == FALSE &&
        This->m_PowerPolicyMachine.m_Owner->m_WakeCompletionEventDropped) {
        return WdfDevStatePwrPolSleepingNoWakeCompletePowerDown;
    }
 
    return WdfDevStatePwrPolNull;
}

PowerPolSleepingWakeRevertArmWakeNP()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolSleepingWakeRevertArmWakeNP ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4487 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(
        This, WdfDevStatePwrPolSleepingWakeRevertArmWakeNP);
 
    DoTraceLevelMessage(
        This->GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
        "reverting arm for wake from Sx due to failure to allocate wait wake "
        "request or wait wake request completed immeidately.  Device will *NOT* "
        "be armed for wake from Sx");
 
    //
    // Enable calls should be matched with Disable calls even in the failure
    // cases. However, for the Enable wake at bus failure, we do not call the
    // disable wake at bus method as we try to keep the failure behavior
    // consistent with the Power State machine. Only the Device Disarm wake
    // callback will be invoked here.
    //
    This->PowerPolicyDisarmWakeFromSx();
 
    //
    // attempt to cancel ww
    //
    if (This->PowerPolicyCancelWaitWake() == FALSE &&
        This->m_PowerPolicyMachine.m_Owner->m_WakeCompletionEventDropped) {
        return WdfDevStatePwrPolSleepingNoWakeCompletePowerDown;
    }
 
    return WdfDevStatePwrPolNull;
}

PowerPolSleepingWakeWakeArrived()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolSleepingWakeWakeArrived ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4186 of file powerpolicystatemachine.cpp.

{
    NTSTATUS status;
    ULONG wakeReason;
 
    ASSERT_PWR_POL_STATE(
        This, WdfDevStatePwrPolSleepingWakeWakeArrived);
 
    ASSERT(This->PowerPolicyCanWakeFromSystemState(
                This->PowerPolicyGetPendingSystemState()
                ));
 
    wakeReason = This->PowerPolicyGetCurrentWakeReason();
 
    status = This->m_PowerPolicyMachine.m_Owner->m_DeviceArmWakeFromSx.Invoke(
        This->m_Device->GetHandle(),
        FLAG_TO_BOOL(wakeReason, FxPowerPolicySxWakeDeviceEnabledFlag),
        FLAG_TO_BOOL(wakeReason, FxPowerPolicySxWakeChildrenArmedFlag)
        );
 
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(
            This->GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
            "WDFDEVICE %p Failed to arm for wake from Sx, %!STATUS!",
            This->m_Device->GetHandle(), status);
 
        return WdfDevStatePwrPolSleepingWakeRevertArmWake;
    }
 
    //
    // If the PDO is the Power Policy owner, then enable wake at bus, otherwise
    // the power state machine will enable wake at bus.
    //
    if (This->m_Device->IsPdo()) {
        status = This->PowerEnableWakeAtBusOverload();
        if (!NT_SUCCESS(status)) {
            DoTraceLevelMessage(
                This->GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                "WDFDEVICE %p Failed to Enable Wake at Bus, %!STATUS!",
                This->m_Device->GetHandle(), status);
            return WdfDevStatePwrPolSleepingWakeRevertArmWake;
        }
    }
 
    This->PowerProcessEvent(PowerCompleteDx);
 
    return WdfDevStatePwrPolNull;
}

PowerPolSleepingWakeWakeArrivedNP()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolSleepingWakeWakeArrivedNP ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4421 of file powerpolicystatemachine.cpp.

{
    NTSTATUS status;
    ULONG wakeReason;
 
    ASSERT_PWR_POL_STATE(
        This, WdfDevStatePwrPolSleepingWakeWakeArrivedNP);
 
    ASSERT(This->PowerPolicyCanWakeFromSystemState(
                This->PowerPolicyGetPendingSystemState()
                ));
 
    wakeReason = This->PowerPolicyGetCurrentWakeReason();
 
    status = This->m_PowerPolicyMachine.m_Owner->m_DeviceArmWakeFromSx.Invoke(
        This->m_Device->GetHandle(),
        FLAG_TO_BOOL(wakeReason, FxPowerPolicySxWakeDeviceEnabledFlag),
        FLAG_TO_BOOL(wakeReason, FxPowerPolicySxWakeChildrenArmedFlag)
        );
 
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(
            This->GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
            "WDFDEVICE %p Failed to arm for wake from Sx, %!STATUS!",
            This->m_Device->GetHandle(), status);
 
        return WdfDevStatePwrPolSleepingWakeRevertArmWakeNP;
    }
 
    //
    // If the PDO is the Power Policy owner, then enable wake at bus, otherwise
    // the power state machine will enable wake at bus.
    //
    if (This->m_Device->IsPdo()) {
        status = This->PowerEnableWakeAtBusOverload();
        if (!NT_SUCCESS(status)) {
            DoTraceLevelMessage(
                This->GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                "WDFDEVICE %p Failed to Enable Wake at Bus, %!STATUS!",
                This->m_Device->GetHandle(), status);
            return WdfDevStatePwrPolSleepingWakeRevertArmWakeNP;
        }
    }
 
    This->PowerProcessEvent(PowerCompleteDx);
 
    return WdfDevStatePwrPolNull;
}

PowerPolStarted()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolStarted ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 6887 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolStarted);
 
    //
    // We signal we are in D0 even though there is idling out in this state
    // because we could have just come from a state which *was* idled out.
    // For instance
    // 1) We are in WaitingArmed and an io present event moved us out of this state
    // 2) Immediately afterward, the s0 idle policy was changed
    // 3) When we enter StartingDecideS0Wake, we will move into this state without
    //    first entering StartedWakeCapable.
    // 4) The source of the io present event, if waiting synchronously needs to
    //    be unblocked.
    //
    This->m_PowerPolicyMachine.m_Owner->m_PowerIdleMachine.DisableTimer();
 
    return WdfDevStatePwrPolNull;
}

PowerPolStartedCancelTimer()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolStartedCancelTimer ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 6922 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolStartedCancelTimer);
 
    if (This->m_PowerPolicyMachine.m_Owner->m_PowerIdleMachine.DisableTimer()) {
        return WdfDevStatePwrPolStartingDecideS0Wake;
    }
    else {
        COVERAGE_TRAP();
        return WdfDevStatePwrPolStartedWaitForIdleTimeout;
    }
}

PowerPolStartedIdleCapable()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolStartedIdleCapable ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3736 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolStartedIdleCapable);
 
    //
    // Enable the idle state machine.  This will release any threads who are
    // waiting for the device to return to D0.
    //
    This->m_PowerPolicyMachine.m_Owner->m_PowerIdleMachine.EnableTimer();
 
    return WdfDevStatePwrPolNull;
}

PowerPolStartedIdleCapableCancelTimerForSleep()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolStartedIdleCapableCancelTimerForSleep ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 7019 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(
        This, WdfDevStatePwrPolStartedIdleCapableCancelTimerForSleep);
 
    if (This->m_PowerPolicyMachine.m_Owner->m_PowerIdleMachine.DisableTimer()) {
        return WdfDevStatePwrPolSleeping;
    }
    else {
        COVERAGE_TRAP();
        return WdfDevStatePwrPolStartedIdleCapableWaitForIdleTimeout;
    }
}

PowerPolStartedWakeCapable()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolStartedWakeCapable ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 5163 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolStartedWakeCapable);
 
    //
    // Enable the idle state machine.  This will release any threads who are
    // waiting for the device to return to D0.
    //
    This->m_PowerPolicyMachine.m_Owner->m_PowerIdleMachine.EnableTimer();
 
    return WdfDevStatePwrPolNull;
}

PowerPolStartedWakeCapableCancelTimerForSleep()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolStartedWakeCapableCancelTimerForSleep ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 6950 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(
        This, WdfDevStatePwrPolStartedWakeCapableCancelTimerForSleep);
 
    if (This->m_PowerPolicyMachine.m_Owner->m_PowerIdleMachine.DisableTimer()) {
        return WdfDevStatePwrPolSleeping;
    }
    else {
        COVERAGE_TRAP();
        return WdfDevStatePwrPolStartedWakeCapableWaitForIdleTimeout;
    }
}

PowerPolStartedWakeCapableSleepingUsbSS()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolStartedWakeCapableSleepingUsbSS ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 6980 of file powerpolicystatemachine.cpp.

{
    BOOLEAN result;
 
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolStartedWakeCapableSleepingUsbSS);
 
    result = This->m_PowerPolicyMachine.m_Owner->m_PowerIdleMachine.DisableTimer();
 
    //
    // Since the power timeout expired, the disable should not return FALSE
    //
    ASSERT(result);
    UNREFERENCED_PARAMETER(result);
 
    //
    // Cancel USBSS irp
    //
    This->PowerPolicyCancelUsbSS();
 
    return WdfDevStatePwrPolNull;
}

PowerPolStarting()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolStarting ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3543 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolStarting);
 
    This->m_PowerPolicyMachine.m_Owner->m_PowerIdleMachine.Start();
 
    This->PowerProcessEvent(PowerImplicitD0);
 
    //
    // Wait for the successful power up before starting any idle timers.  If
    // the power up fails, we will not send a power policy stop from the pnp
    // engine.
    //
    return WdfDevStatePwrPolNull;
}

PowerPolStartingDecideS0Wake()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolStartingDecideS0Wake ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3698 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolStartingDecideS0Wake);
 
    This->PowerPolicyChildrenCanPowerUp();
 
    //
    // Save idle state if it is dirty.  We check when deciding the S0 state
    // because any change in the S0 idle settings will go through this state.
    //
    This->SaveState(TRUE);
 
    //
    // If necessary update the idle timeout hint to the power framework
    //
    This->m_PowerPolicyMachine.m_Owner->m_PoxInterface.UpdateIdleTimeoutHint();
 
    if (This->m_PowerPolicyMachine.m_Owner->m_IdleSettings.Enabled) {
        if (This->m_PowerPolicyMachine.m_Owner->m_IdleSettings.WakeFromS0Capable) {
            //
            // We can idle out and wake from S0
            //
            return WdfDevStatePwrPolStartedWakeCapable;
        }
        else {
            //
            // We can idle out, but not wake from the idle state
            //
            return WdfDevStatePwrPolStartedIdleCapable;
        }
    }
 
    return WdfDevStatePwrPolStarted;
}

PowerPolStartingFailed()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolStartingFailed ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3661 of file powerpolicystatemachine.cpp.

{
    KIRQL irql;
 
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolStartingFailed);
 
    This->m_PowerPolicyMachine.m_Owner->m_PowerIdleMachine.Stop();
 
    //
    // We raise IRQL to dispatch level so that pnp is forced onto its own thread
    // to process the PwrPolStartFailed event.  If pnp is on the power thread when
    // it processes the event and it tries to delete the dedicated thread, it
    // will deadlock waiting for the thread its on to exit.
    //
    Mx::MxRaiseIrql(DISPATCH_LEVEL, &irql);
    This->PnpProcessEvent(PnpEventPwrPolStartFailed);
    Mx::MxLowerIrql(irql);
 
    return WdfDevStatePwrPolNull;
}

PowerPolStartingPoweredUp()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolStartingPoweredUp ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3562 of file powerpolicystatemachine.cpp.

{
    NTSTATUS status;
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolStartingPoweredUp);
 
    //
    // The decision regarding whether or not the power framework determines the
    // idle timeout is now "frozen" and cannot be changed unless the device is
    // stopped and restarted.
    //
    This->m_PowerPolicyMachine.m_Owner->
            m_IdleSettings.m_TimeoutMgmt.FreezeIdleTimeoutManagementStatus(
                                                This->GetDriverGlobals()
                                                );
 
    status = This->m_PowerPolicyMachine.m_Owner->
                        m_PoxInterface.InitializeComponents();
    if (FALSE == NT_SUCCESS(status)) {
        return WdfDevStatePwrPolStartingPoweredUpFailed;
    }
 
    return WdfDevStatePwrPolStartingSucceeded;
}

PowerPolStartingPoweredUpFailed()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolStartingPoweredUpFailed ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3609 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolStartingPoweredUpFailed);
 
    This->PowerProcessEvent(PowerImplicitD3);
 
    return WdfDevStatePwrPolNull;
}

PowerPolStartingSucceeded()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolStartingSucceeded ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3635 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolStartingSucceeded);
 
    This->PnpProcessEvent(PnpEventPwrPolStarted);
 
    return WdfDevStatePwrPolStartingDecideS0Wake;
}

PowerPolStoppedRemoving()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolStoppedRemoving ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 6614 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolStoppedRemoving);
 
    This->m_PowerPolicyMachine.m_Owner->
            m_PoxInterface.UninitializeComponents();
 
    return WdfDevStatePwrPolRemoved;
}

PowerPolStopping()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolStopping ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 6519 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolStopping);
 
    //
    // Prevent any children from powering up.  Technically this is not necessary
    // because if we are getting to this point, all of our children have already
    // been implicitly stopped as well, but this keeps the child power up state
    // consistent with the power policy state.
    //
    This->PowerPolicyBlockChildrenPowerUp();
 
    //
    // This power change event does not need to be synchronous
    //
    This->PowerProcessEvent(PowerImplicitD3);
 
    return WdfDevStatePwrPolNull;
}

PowerPolStoppingCancelTimer()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolStoppingCancelTimer ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 6742 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolStoppingCancelTimer);
 
    if (This->m_PowerPolicyMachine.m_Owner->m_PowerIdleMachine.DisableTimer()) {
        return WdfDevStatePwrPolStopping;
    }
    else {
        //
        // Timer was not canceled, move to the state where we wait for the
        // timeout event to be posted.
        //
        return WdfDevStatePwrPolStoppingWaitForIdleTimeout;
    }
}

PowerPolStoppingCancelUsbSS()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolStoppingCancelUsbSS ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 6773 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolStoppingCancelUsbSS);
 
    //
    // We notified the device power requirement state machine that we are about
    // to power down, but eventually we didn't power down. So notify the device
    // power requirement state machine that the device should be considered
    // powered on.
    //
    This->m_PowerPolicyMachine.m_Owner->
                m_PoxInterface.DeviceIsPoweredOn();
 
    This->m_PowerPolicyMachine.m_Owner->
            m_PoxInterface.RequestComponentActive();
 
    if (This->PowerPolicyCancelUsbSSIfCapable() == FALSE) {
        //
        // UsbSS already canceled/completed
        //
        return WdfDevStatePwrPolStoppingCancelTimer;
    }
 
    return WdfDevStatePwrPolStoppingWaitForUsbSSCompletion;
}

PowerPolStoppingCancelWake()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolStoppingCancelWake ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 6814 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolStoppingCancelWake);
 
    if (This->PowerPolicyCancelWaitWake() == FALSE &&
        This->m_PowerPolicyMachine.m_Owner->m_WakeCompletionEventDropped) {
        COVERAGE_TRAP();
        return WdfDevStatePwrPolStopping;
    }
    else {
        return WdfDevStatePwrPolNull;
    }
}

PowerPolStoppingD0()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolStoppingD0 ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 6407 of file powerpolicystatemachine.cpp.

{
    NTSTATUS status;
 
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolStoppingD0);
 
    This->m_PowerPolicyMachine.m_Owner->
            m_PoxInterface.RequestComponentActive();
 
    This->m_PowerPolicyMachine.m_Owner->m_PowerIdleMachine.DisableTimer();
 
    status = This->PowerPolicySendDevicePowerRequest(PowerDeviceD0, Retry);
    if (!NT_SUCCESS(status)) {
        COVERAGE_TRAP();
        return WdfDevStatePwrPolDeviceD0PowerRequestFailed;
    }
 
    return WdfDevStatePwrPolNull;
}

PowerPolStoppingD0CancelUsbSS()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolStoppingD0CancelUsbSS ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 8329 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolStoppingD0CancelUsbSS);
 
    if (This->PowerPolicyCancelUsbSSIfCapable()) {
        //
        // Usbss completion event will move us from this state.
        //
        return WdfDevStatePwrPolNull;
    }
 
    //
    // If usbss irp was there it has already been canceled, so march on.
    //
    return WdfDevStatePwrPolStoppingD0;
}

PowerPolStoppingD0Failed()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolStoppingD0Failed ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 6430 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolStoppingD0Failed);
 
    This->m_PowerPolicyMachine.m_Owner->m_PowerFailed = TRUE;
 
    //
    // Notify the device power requirement state machine that the device should
    // be considered powered on, although it is not. Doing this will ensure that
    // component activation before device removal will succeed.
    //
    This->m_PowerPolicyMachine.m_Owner->
                m_PoxInterface.DeviceIsPoweredOn();
 
    return WdfDevStatePwrPolStoppingDisarmWakeCancelWake;
}

PowerPolStoppingDisarmWake()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolStoppingDisarmWake ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 6464 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolStoppingDisarmWake);
 
    This->m_PowerPolicyMachine.m_Owner->
                m_PoxInterface.DeviceIsPoweredOn();
 
    //
    // If the PDO is the Power Policy owner, then disable wake at bus, otherwise
    // the power state machine will disable wake at bus.
    //
    if (This->m_Device->IsPdo()) {
        This->PowerDisableWakeAtBusOverload();
    }
 
    This->m_PowerPolicyMachine.m_Owner->m_DeviceDisarmWakeFromS0.Invoke(
        This->m_Device->GetHandle()
        );
 
    This->PowerProcessEvent(PowerCompleteD0);
 
    return WdfDevStatePwrPolNull;
 
}

PowerPolStoppingDisarmWakeCancelWake()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolStoppingDisarmWakeCancelWake ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 6492 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolStoppingDisarmWakeCancelWake);
 
    if (This->PowerPolicyCancelWaitWake() == FALSE &&
        This->m_PowerPolicyMachine.m_Owner->m_WakeCompletionEventDropped) {
        return WdfDevStatePwrPolStoppingDisarmWakeWakeCanceled;
    }
 
    return WdfDevStatePwrPolNull;
}

PowerPolStoppingDisarmWakeWakeCanceled()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolStoppingDisarmWakeWakeCanceled ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 6507 of file powerpolicystatemachine.cpp.

{
    UNREFERENCED_PARAMETER(This);
 
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolStoppingDisarmWakeWakeCanceled);
 
    return WdfDevStatePwrPolStopping;
}

PowerPolStoppingFailed()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolStoppingFailed ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 6542 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolStoppingFailed);
 
    This->m_PowerPolicyMachine.m_Owner->m_PowerFailed = TRUE;
 
    return WdfDevStatePwrPolStoppingSendStatus;
}

PowerPolStoppingResetDevice()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolStoppingResetDevice ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 6300 of file powerpolicystatemachine.cpp.

{
    NTSTATUS status;
    BOOLEAN result;
 
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolStoppingResetDevice);
 
    This->m_PowerPolicyMachine.m_Owner->
            m_PoxInterface.RequestComponentActive();
 
    result = This->m_PowerPolicyMachine.m_Owner->m_PowerIdleMachine.DisableTimer();
    ASSERT(result);
    UNREFERENCED_PARAMETER(result);
 
    status = This->PowerPolicySendDevicePowerRequest(PowerDeviceD0, Retry);
 
    if (!NT_SUCCESS(status)) {
        COVERAGE_TRAP();
        return WdfDevStatePwrPolDeviceD0PowerRequestFailed;
    }
 
    return WdfDevStatePwrPolNull;
}

PowerPolStoppingResetDeviceCompletePowerUp()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolStoppingResetDeviceCompletePowerUp ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 6341 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(
        This, WdfDevStatePwrPolStoppingResetDeviceCompletePowerUp);
 
    This->m_PowerPolicyMachine.m_Owner->
                m_PoxInterface.DeviceIsPoweredOn();
 
    This->PowerProcessEvent(PowerCompleteD0);
 
    return WdfDevStatePwrPolNull;
}

PowerPolStoppingResetDeviceFailed()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolStoppingResetDeviceFailed ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 6372 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolStoppingResetDeviceFailed);
 
    This->m_PowerPolicyMachine.m_Owner->m_PowerFailed = TRUE;
 
    //
    // Notify the device power requirement state machine that the device should
    // be considered powered on, although it is not. Doing this will ensure that
    // component activation before device removal will succeed.
    //
    This->m_PowerPolicyMachine.m_Owner->
                m_PoxInterface.DeviceIsPoweredOn();
 
    return WdfDevStatePwrPolStopping;
}

PowerPolStoppingSendStatus()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolStoppingSendStatus ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 6567 of file powerpolicystatemachine.cpp.

{
    KIRQL irql;
 
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolStoppingSendStatus);
 
    This->m_PowerPolicyMachine.m_Owner->m_PowerIdleMachine.Stop();
 
    //
    // We raise IRQL to dispatch level so that pnp is forced onto its own thread
    // to process the PwrPolStopped event.  If pnp is on the power thread when
    // it processes the event and it tries to delete the dedicated thread, it
    // will deadlock waiting for the thread its on to exit.
    //
    Mx::MxRaiseIrql(DISPATCH_LEVEL, &irql);
    This->PnpProcessEvent(
        This->m_PowerPolicyMachine.m_Owner->m_PowerFailed
                          ? PnpEventPwrPolStopFailed
                          : PnpEventPwrPolStopped
        );
    Mx::MxLowerIrql(irql);
 
    //
    // Reset back to a non failed state
    //
    This->m_PowerPolicyMachine.m_Owner->m_PowerFailed = FALSE;
 
    return WdfDevStatePwrPolStopped;
}

PowerPolStoppingSucceeded()

static WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolStoppingSucceeded ( __inout FxPkgPnp *  This )

staticprotected

PowerPolSystemAsleepNoWake()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolSystemAsleepNoWake ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 5020 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolSystemAsleepNoWake);
 
    This->PowerPolicyCompleteSystemPowerIrp();
 
    return WdfDevStatePwrPolNull;
}

PowerPolSystemAsleepWakeArmed()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolSystemAsleepWakeArmed ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4285 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolSystemAsleepWakeArmed);
    This->PowerPolicyCompleteSystemPowerIrp();
 
    return WdfDevStatePwrPolNull;
}

PowerPolSystemAsleepWakeArmedNP()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolSystemAsleepWakeArmedNP ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4577 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolSystemAsleepWakeArmedNP);
 
    This->PowerPolicyCompleteSystemPowerIrp();
 
    return WdfDevStatePwrPolNull;
}

PowerPolSystemSleepFromDeviceWaitingUnarmed()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolSystemSleepFromDeviceWaitingUnarmed ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4031 of file powerpolicystatemachine.cpp.

{
    SYSTEM_POWER_STATE systemState;
 
    ASSERT_PWR_POL_STATE(
        This, WdfDevStatePwrPolSystemSleepFromDeviceWaitingUnarmed);
 
    systemState = This->PowerPolicyGetPendingSystemState();
 
    if (This->PowerPolicyIsWakeEnabled() &&
        This->PowerPolicyCanWakeFromSystemState(systemState)) {
        return WdfDevStatePwrPolSystemSleepNeedWake;
    }
    else {
        return WdfDevStatePwrPolSystemAsleepNoWake;
    }
}

PowerPolSystemSleepNeedWake()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolSystemSleepNeedWake ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4052 of file powerpolicystatemachine.cpp.

{
    NTSTATUS status;
    BOOLEAN result;
 
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolSystemSleepNeedWake);
 
    result = This->m_PowerPolicyMachine.m_Owner->m_PowerIdleMachine.DisableTimer();
    ASSERT(result);
    UNREFERENCED_PARAMETER(result);
 
    status = This->PowerPolicySendDevicePowerRequest(PowerDeviceD0, Retry);
 
    //
    // We are currently in Dx and not armed for wake.  While the current Dx
    // state may not be the same Dx state we would be for Sx, we can't get to
    // D0 to arm ourselves for Sx wake so just leave ourselves as is.
    //
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(
            This->GetDriverGlobals(), TRACE_LEVEL_WARNING, TRACINGPNP,
            "Failed to allocate D0 request to disarm from wake from S0 to allow "
            "arm for wake from Sx, %!STATUS!", status);
 
        COVERAGE_TRAP();
 
        //
        // If D0 IRP allocation fails, we don't treat that as an error. Instead,
        // we just let the device remain in Dx without arming it for
        // wake-from-Sx, even though the driver had enabled wake-from-Sx.
        //
        return WdfDevStatePwrPolSystemAsleepNoWake;
    }
 
    return WdfDevStatePwrPolNull;
}

PowerPolSystemSleepNeedWakeCompletePowerUp()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolSystemSleepNeedWakeCompletePowerUp ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4092 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This,
                         WdfDevStatePwrPolSystemSleepNeedWakeCompletePowerUp);
 
    This->PowerProcessEvent(PowerCompleteD0);
 
    return WdfDevStatePwrPolNull;
}

PowerPolSystemSleepPowerRequestFailed()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolSystemSleepPowerRequestFailed ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4120 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolSystemSleepPowerRequestFailed);
 
    This->PowerPolicyCompleteSystemPowerIrp();
 
    return WdfDevStatePwrPolDevicePowerRequestFailed;
}

PowerPolSystemWakeDeviceToD0()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolSystemWakeDeviceToD0 ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 5078 of file powerpolicystatemachine.cpp.

{
    NTSTATUS status;
 
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolSystemWakeDeviceToD0);
 
    status = This->PowerPolicySendDevicePowerRequest(PowerDeviceD0, Retry);
    if (!NT_SUCCESS(status)) {
        COVERAGE_TRAP();
        return WdfDevStatePwrPolDeviceD0PowerRequestFailed;
    }
 
    return WdfDevStatePwrPolNull;
}

PowerPolSystemWakeDeviceToD0CompletePowerUp()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolSystemWakeDeviceToD0CompletePowerUp ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 5096 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(
        This, WdfDevStatePwrPolSystemWakeDeviceToD0CompletePowerUp);
 
    //
    // Simulate a device-power-not-required notification from the power
    // framework. An S0-IRP is essentially equivalent to a device-power-required
    // notification.
    //
    This->m_PowerPolicyMachine.m_Owner->
        m_PoxInterface.SimulateDevicePowerRequired();
 
    //
    // Notify the device-power-requirement state machine that we are powered on
    //
    This->m_PowerPolicyMachine.m_Owner->
                m_PoxInterface.DeviceIsPoweredOn();
 
    This->PowerProcessEvent(PowerCompleteD0);
 
    return WdfDevStatePwrPolNull;
}

PowerPolSystemWakeDeviceWakeCompletePowerUp()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolSystemWakeDeviceWakeCompletePowerUp ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4709 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This,
                         WdfDevStatePwrPolSystemWakeDeviceWakeCompletePowerUp);
 
    //
    // Simulate a device-power-required notification from the power framework.
    // An S0-IRP is essentially equivalent to a device-power-required
    // notification.
    //
    This->m_PowerPolicyMachine.m_Owner->
        m_PoxInterface.SimulateDevicePowerRequired();
 
    //
    // Notify the device-power-requirement state machine that we are powered on
    //
    This->m_PowerPolicyMachine.m_Owner->
                m_PoxInterface.DeviceIsPoweredOn();
 
    This->PowerProcessEvent(PowerCompleteD0);
 
    return WdfDevStatePwrPolNull;
}

PowerPolSystemWakeDeviceWakeDisabled()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolSystemWakeDeviceWakeDisabled ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 5032 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolSystemWakeDeviceWakeDisabled);
 
    //
    // We do not attempt to let the device remain in Dx if we are using system-
    // managed idle timeout. This is because an S0 IRP is equivalent to a
    // device-power-required notification from the power framework. In response
    // to it, we need to power up the device and notify the power framework that
    // the device is powered on.
    //
    if ((This->m_PowerPolicyMachine.m_Owner->
          m_IdleSettings.m_TimeoutMgmt.UsingSystemManagedIdleTimeout() == FALSE)
            &&
        (This->m_PowerPolicyMachine.m_Owner->m_IdleSettings.Enabled)
            &&
        (This->m_PowerPolicyMachine.m_Owner->
          m_IdleSettings.WakeFromS0Capable == FALSE)
            &&
        (This->m_PowerPolicyMachine.m_Owner->
          m_IdleSettings.PowerUpIdleDeviceOnSystemWake == FALSE)) {
 
        return WdfDevStatePwrPolSystemWakeQueryIdle;
    }
    else {
        return WdfDevStatePwrPolSystemWakeDeviceToD0;
    }
}

PowerPolSystemWakeDeviceWakeDisarm()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolSystemWakeDeviceWakeDisarm ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4355 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(
        This, WdfDevStatePwrPolSystemWakeDeviceWakeDisarm);
 
    //
    // If the PDO is the Power Policy owner, then disable wake at bus, otherwise
    // the power state machine will disable wake at bus.
    //
    if (This->m_Device->IsPdo()) {
        This->PowerDisableWakeAtBusOverload();
    }
 
    This->PowerPolicyDisarmWakeFromSx();
 
    return WdfDevStatePwrPolSystemWakeDeviceWakeCompletePowerUp;
}

PowerPolSystemWakeDeviceWakeDisarmNP()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolSystemWakeDeviceWakeDisarmNP ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4646 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolSystemWakeDeviceWakeDisarmNP);
 
    //
    // If the PDO is the Power Policy owner, then disable wake at bus, otherwise
    // the power state machine will disable wake at bus.
    //
    if (This->m_Device->IsPdo()) {
        This->PowerDisableWakeAtBusOverload();
    }
 
    This->PowerPolicyDisarmWakeFromSx();
 
    return WdfDevStatePwrPolSystemWakeDeviceWakeCompletePowerUp;
}

PowerPolSystemWakeDeviceWakeEnabled()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolSystemWakeDeviceWakeEnabled ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4296 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(
        This, WdfDevStatePwrPolSystemWakeDeviceWakeEnabled);
 
    if (This->PowerPolicyCancelWaitWake() == FALSE &&
        This->m_PowerPolicyMachine.m_Owner->m_WakeCompletionEventDropped) {
        return WdfDevStatePwrPolSystemWakeDeviceWakeEnabledWakeCanceled;
    }
 
    return WdfDevStatePwrPolNull;
}

PowerPolSystemWakeDeviceWakeEnabledNP()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolSystemWakeDeviceWakeEnabledNP ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4589 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolSystemWakeDeviceWakeEnabledNP);
 
    if (This->PowerPolicyCancelWaitWake() == FALSE &&
        This->m_PowerPolicyMachine.m_Owner->m_WakeCompletionEventDropped) {
        return WdfDevStatePwrPolSystemWakeDeviceWakeEnabledWakeCanceledNP;
    }
 
    return WdfDevStatePwrPolNull;
}

PowerPolSystemWakeDeviceWakeEnabledWakeCanceled()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolSystemWakeDeviceWakeEnabledWakeCanceled ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4335 of file powerpolicystatemachine.cpp.

{
    NTSTATUS status;
 
    ASSERT_PWR_POL_STATE(
        This, WdfDevStatePwrPolSystemWakeDeviceWakeEnabledWakeCanceled);
 
    status = This->PowerPolicySendDevicePowerRequest(PowerDeviceD0, Retry);
 
    if (!NT_SUCCESS(status)) {
        COVERAGE_TRAP();
        return WdfDevStatePwrPolDeviceD0PowerRequestFailed;
    }
 
    return WdfDevStatePwrPolNull;
}

PowerPolSystemWakeDeviceWakeEnabledWakeCanceledNP()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolSystemWakeDeviceWakeEnabledWakeCanceledNP ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4626 of file powerpolicystatemachine.cpp.

{
    NTSTATUS status;
 
    ASSERT_PWR_POL_STATE(
        This, WdfDevStatePwrPolSystemWakeDeviceWakeEnabledWakeCanceledNP);
 
    status = This->PowerPolicySendDevicePowerRequest(PowerDeviceD0, Retry);
 
    if (!NT_SUCCESS(status)) {
        COVERAGE_TRAP();
        return WdfDevStatePwrPolDeviceD0PowerRequestFailed;
    }
 
    return WdfDevStatePwrPolNull;
}

PowerPolSystemWakeDeviceWakeInterruptFired()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolSystemWakeDeviceWakeInterruptFired ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4312 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(
        This, WdfDevStatePwrPolSystemWakeDeviceWakeInterruptFired);
 
    //
    // Make a note of the fact that system was woken by
    // a wake interrupt of this device
    //
    This->m_SystemWokenByWakeInterrupt = TRUE;
 
    if (This->PowerPolicyCancelWaitWake() == FALSE &&
        This->m_PowerPolicyMachine.m_Owner->m_WakeCompletionEventDropped) {
 
        return WdfDevStatePwrPolSystemWakeDeviceWakeTriggered;
    }
 
    return WdfDevStatePwrPolNull;
}

PowerPolSystemWakeDeviceWakeInterruptFiredNP()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolSystemWakeDeviceWakeInterruptFiredNP ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4604 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(
        This, WdfDevStatePwrPolSystemWakeDeviceWakeInterruptFiredNP);
 
    //
    // Make a notee of the fact that system was woken by
    // a wake interrupt of this device
    //
    This->m_SystemWokenByWakeInterrupt = TRUE;
 
    if (This->PowerPolicyCancelWaitWake() == FALSE &&
        This->m_PowerPolicyMachine.m_Owner->m_WakeCompletionEventDropped) {
        return WdfDevStatePwrPolSystemWakeDeviceWakeTriggeredNP;
    }
 
    return WdfDevStatePwrPolNull;
}

PowerPolSystemWakeDeviceWakeTriggeredS0()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolSystemWakeDeviceWakeTriggeredS0 ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4376 of file powerpolicystatemachine.cpp.

{
    NTSTATUS status;
 
    ASSERT_PWR_POL_STATE(
        This, WdfDevStatePwrPolSystemWakeDeviceWakeTriggeredS0);
 
    status = This->PowerPolicySendDevicePowerRequest(PowerDeviceD0, Retry);
 
    if (!NT_SUCCESS(status)) {
        COVERAGE_TRAP();
        return WdfDevStatePwrPolDeviceD0PowerRequestFailed;
    }
 
    return WdfDevStatePwrPolNull;
}

PowerPolSystemWakeDeviceWakeTriggeredS0NP()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolSystemWakeDeviceWakeTriggeredS0NP ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4666 of file powerpolicystatemachine.cpp.

{
    NTSTATUS status;
 
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolSystemWakeDeviceWakeTriggeredS0NP);
 
    status = This->PowerPolicySendDevicePowerRequest(PowerDeviceD0, Retry);
 
    if (!NT_SUCCESS(status)) {
        COVERAGE_TRAP();
        return WdfDevStatePwrPolDeviceD0PowerRequestFailed;
    }
 
    return WdfDevStatePwrPolNull;
}

PowerPolSystemWakeDeviceWokeDisarm()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolSystemWakeDeviceWokeDisarm ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4396 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(
        This, WdfDevStatePwrPolSystemWakeDeviceWokeDisarm);
 
    //
    // If the PDO is the Power Policy owner, then disable wake at bus, otherwise
    // the power state machine will enable wake at bus.
    //
    if (This->m_Device->IsPdo()) {
        This->PowerDisableWakeAtBusOverload();
    }
 
    This->m_PowerPolicyMachine.m_Owner->m_DeviceWakeFromSxTriggered.Invoke(
        This->m_Device->GetHandle()
        );
 
    This->PowerPolicyDisarmWakeFromSx();
 
    return WdfDevStatePwrPolSystemWakeDeviceWakeCompletePowerUp;
}

PowerPolSystemWakeDeviceWokeDisarmNP()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolSystemWakeDeviceWokeDisarmNP ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4685 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolSystemWakeDeviceWokeDisarmNP);
 
    //
    // If the PDO is the Power Policy owner, then disable wake at bus, otherwise
    // the power state machine will disable wake at bus.
    //
    if (This->m_Device->IsPdo()) {
        This->PowerDisableWakeAtBusOverload();
    }
 
    This->m_PowerPolicyMachine.m_Owner->m_DeviceWakeFromSxTriggered.Invoke(
        This->m_Device->GetHandle()
        );
 
    This->PowerPolicyDisarmWakeFromSx();
 
    return WdfDevStatePwrPolSystemWakeDeviceWakeCompletePowerUp;
}

PowerPolSystemWakeQueryIdle()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolSystemWakeQueryIdle ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 5138 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolSystemWakeQueryIdle);
 
    //
    // This state can be reached only if we are using driver-managed idle
    // timeout.
    //
    ASSERT(
      This->m_PowerPolicyMachine.m_Owner->
          m_IdleSettings.m_TimeoutMgmt.UsingSystemManagedIdleTimeout() == FALSE
      );
 
    if (This->m_PowerPolicyMachine.m_Owner->m_PowerIdleMachine.QueryReturnToIdle()) {
        return WdfDevStatePwrPolWaitingUnarmed;
    }
    else {
        return WdfDevStatePwrPolSystemWakeDeviceToD0;
    }
}

PowerPolTimerExpiredDecideUsbSS()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolTimerExpiredDecideUsbSS ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 5215 of file powerpolicystatemachine.cpp.

{
    NTSTATUS notifyPowerDownStatus;
 
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolTimerExpiredDecideUsbSS);
 
    //
    // Notify the device power requirement state machine that we are about to
    // power down.
    //
    notifyPowerDownStatus = This->m_PowerPolicyMachine.m_Owner->
                              m_PoxInterface.NotifyDevicePowerDown();
    if (FALSE == NT_SUCCESS(notifyPowerDownStatus)) {
        //
        // We couldn't notify the device power requirement state machine that
        // we are about to power down, because the "device-power-required"
        // notification has already arrived. So we should not power down at this
        // time. Revert back to the started state.
        //
        return WdfDevStatePwrPolDeviceIdleReturnToActive;
    }
 
    if (This->m_PowerPolicyMachine.m_Owner->m_IdleSettings.UsbSSCapable) {
        return WdfDevStatePwrPolTimerExpiredWakeCapableUsbSS;
    }
    else {
        return WdfDevStatePwrPolTimerExpiredWakeCapablePowerDown;
    }
}

PowerPolTimerExpiredNoWake()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolTimerExpiredNoWake ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3876 of file powerpolicystatemachine.cpp.

{
    BOOLEAN poweredDown;
    NTSTATUS notifyPowerDownStatus;
 
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolTimerExpiredNoWake);
 
    //
    // Notify the device power requirement state machine that we are about to
    // power down.
    //
    notifyPowerDownStatus = This->m_PowerPolicyMachine.m_Owner->
                              m_PoxInterface.NotifyDevicePowerDown();
    if (FALSE == NT_SUCCESS(notifyPowerDownStatus)) {
        //
        // We couldn't notify the device power requirement state machine that
        // we are about to power down, because the "device-power-required"
        // notification has already arrived. So we should not power down at this
        // time. Revert back to the started state.
        //
        return WdfDevStatePwrPolTimerExpiredNoWakeReturnToActive;
    }
 
    poweredDown = This->PowerPolicyCanIdlePowerDown(
        This->m_PowerPolicyMachine.m_Owner->m_IdleSettings.DxState
        );
 
    if (poweredDown == FALSE) {
        //
        // Upon failure, revert back to the started state.
        //
        return WdfDevStatePwrPolTimerExpiredNoWakeUndoPowerDown;
    }
 
    return WdfDevStatePwrPolNull;
}

PowerPolTimerExpiredNoWakeCompletePowerDown()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolTimerExpiredNoWakeCompletePowerDown ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3916 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This,
                         WdfDevStatePwrPolTimerExpiredNoWakeCompletePowerDown);
 
    This->PowerProcessEvent(PowerCompleteDx);
 
    return WdfDevStatePwrPolNull;
}

PowerPolTimerExpiredNoWakePowerDownNotProcessed()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolTimerExpiredNoWakePowerDownNotProcessed ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 7172 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(
        This, WdfDevStatePwrPolTimerExpiredNoWakePowerDownNotProcessed);
 
    This->SetInternalFailure();
 
    return WdfDevStatePwrPolTimerExpiredNoWakeUndoPowerDown;
}

PowerPolTimerExpiredNoWakePoweredDownDisableIdleTimer()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolTimerExpiredNoWakePoweredDownDisableIdleTimer ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 7261 of file powerpolicystatemachine.cpp.

{
    BOOLEAN result;
 
    ASSERT_PWR_POL_STATE(
        This, WdfDevStatePwrPolTimerExpiredNoWakePoweredDownDisableIdleTimer);
 
    //
    // Disable the timer so that when we move back into D0, the timer is not
    // automatically started.  Since the timer has already fired, we should never
    // get FALSE back (which indicates we should wait for the timer to fire).
    //
    result = This->m_PowerPolicyMachine.m_Owner->m_PowerIdleMachine.DisableTimer();
    ASSERT(result);
    UNREFERENCED_PARAMETER(result);
 
    //
    // Check to see if we should immediately power up
    //
    return WdfDevStatePwrPolWaitingUnarmedQueryIdle;
}

PowerPolTimerExpiredNoWakeReturnToActive()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolTimerExpiredNoWakeReturnToActive ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 7232 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(
        This, WdfDevStatePwrPolTimerExpiredNoWakeReturnToActive);
 
    This->m_PowerPolicyMachine.m_Owner->
            m_PoxInterface.RequestComponentActive();
 
    return WdfDevStatePwrPolStartedIdleCapable;
}

PowerPolTimerExpiredNoWakeUndoPowerDown()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolTimerExpiredNoWakeUndoPowerDown ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 7199 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(
        This, WdfDevStatePwrPolTimerExpiredNoWakeUndoPowerDown);
 
    //
    // We notified the device power requirement state machine that we are about
    // to power down, but eventually we didn't power down. So notify the device
    // power requirement state machine that the device should be considered
    // powered on.
    //
    This->m_PowerPolicyMachine.m_Owner->
                m_PoxInterface.DeviceIsPoweredOn();
 
    return WdfDevStatePwrPolTimerExpiredNoWakeReturnToActive;
}

PowerPolTimerExpiredWakeCapableCancelWake()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolTimerExpiredWakeCapableCancelWake ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 5447 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolTimerExpiredWakeCapableCancelWake);
 
    if (This->PowerPolicyCancelWaitWake() == FALSE) {
        return WdfDevStatePwrPolTimerExpiredWakeCapableWakeCanceled;
    }
 
    return WdfDevStatePwrPolNull;
}

PowerPolTimerExpiredWakeCapableCleanup()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolTimerExpiredWakeCapableCleanup ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 5500 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolTimerExpiredWakeCapableCleanup);
 
    if (This->m_PowerPolicyMachine.m_Owner->m_IdleSettings.UsbSSCapable) {
        COVERAGE_TRAP();
        This->m_PowerPolicyMachine.UsbSSCallbackProcessingComplete();
    }
 
    //
    // Cancel UsbSS if present
    //
    if (This->PowerPolicyCancelUsbSSIfCapable()) {
        //
        // wait for Usbss completion event to move us from this state.
        //
        return WdfDevStatePwrPolNull;
    }
 
    return WdfDevStatePwrPolTimerExpiredWakeCompletedPowerDown;
}

PowerPolTimerExpiredWakeCapableDxAllocFailed()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolTimerExpiredWakeCapableDxAllocFailed ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 5539 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(
        This, WdfDevStatePwrPolTimerExpiredWakeCapableDxAllocFailed);
 
    if (This->m_PowerPolicyMachine.m_Owner->m_IdleSettings.UsbSSCapable) {
        COVERAGE_TRAP();
        This->m_PowerPolicyMachine.UsbSSCallbackProcessingComplete();
    }
 
    //
    // cancel USB SS irp if capable
    //
    if (This->PowerPolicyCancelUsbSSIfCapable()) {
        //
        // wait for Usbss completion event to move us from this state.
        //
        return WdfDevStatePwrPolNull;
    }
 
    return WdfDevStatePwrPolTimerExpiredWakeCapableUndoPowerDown;
}

PowerPolTimerExpiredWakeCapablePowerDown()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolTimerExpiredWakeCapablePowerDown ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 5264 of file powerpolicystatemachine.cpp.

{
    BOOLEAN poweredDown;
 
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolTimerExpiredWakeCapablePowerDown);
 
    poweredDown = This->PowerPolicyCanIdlePowerDown(
        This->m_PowerPolicyMachine.m_Owner->m_IdleSettings.DxState
        );
 
    if (poweredDown == FALSE) {
        //
        // Upon failure, revert back to the started state.
        //
        return WdfDevStatePwrPolTimerExpiredWakeCapableDxAllocFailed;
    }
 
    return WdfDevStatePwrPolNull;
}

PowerPolTimerExpiredWakeCapablePowerDownFailedCancelWake()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolTimerExpiredWakeCapablePowerDownFailedCancelWake ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 6010 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(
        This,
        WdfDevStatePwrPolTimerExpiredWakeCapablePowerDownFailedCancelWake);
 
    if (This->PowerPolicyCancelWaitWake() == FALSE) {
        return WdfDevStatePwrPolTimerExpiredWakeCapablePowerDownFailedWakeCanceled;
    }
 
    return WdfDevStatePwrPolNull;
}

PowerPolTimerExpiredWakeCapablePowerDownFailedUsbSS()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolTimerExpiredWakeCapablePowerDownFailedUsbSS ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 6070 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolTimerExpiredWakeCapablePowerDownFailedUsbSS);
 
    if (This->m_PowerPolicyMachine.m_Owner->m_IdleSettings.UsbSSCapable) {
        This->m_PowerPolicyMachine.UsbSSCallbackProcessingComplete();
    }
 
    if (This->PowerPolicyCancelUsbSSIfCapable()) {
        //
        // wait for Usbss completion event to move us from this state.
        //
        return WdfDevStatePwrPolNull;
    }
 
    return WdfDevStatePwrPolDevicePowerRequestFailed;
}

PowerPolTimerExpiredWakeCapablePowerDownFailedWakeCanceled()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolTimerExpiredWakeCapablePowerDownFailedWakeCanceled ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 6039 of file powerpolicystatemachine.cpp.

{
    UNREFERENCED_PARAMETER(This);
 
    ASSERT_PWR_POL_STATE(
        This,
        WdfDevStatePwrPolTimerExpiredWakeCapablePowerDownFailedWakeCanceled);
 
    return WdfDevStatePwrPolTimerExpiredWakeCapablePowerDownFailedUsbSS;
}

PowerPolTimerExpiredWakeCapablePowerDownNotProcessed()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolTimerExpiredWakeCapablePowerDownNotProcessed ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 7145 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(
        This, WdfDevStatePwrPolTimerExpiredWakeCapablePowerDownNotProcessed);
 
    This->SetInternalFailure();
 
    return WdfDevStatePwrPolTimerExpiredWakeCapableDxAllocFailed;
}

PowerPolTimerExpiredWakeCapableSendWake()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolTimerExpiredWakeCapableSendWake ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 5304 of file powerpolicystatemachine.cpp.

{
    NTSTATUS status;
 
    ASSERT_PWR_POL_STATE(
        This, WdfDevStatePwrPolTimerExpiredWakeCapableSendWake);
 
    //
    // We are in a wake-enabled path, keep wake interrupts connected.
    //
    This->m_WakeInterruptsKeepConnected = TRUE;
 
    status = This->PowerPolicySendWaitWakeRequest(PowerSystemWorking);
 
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(
            This->GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
            "Could not allocate wake request for wake from S0, revert arming,"
            " %!STATUS!", status);
 
        COVERAGE_TRAP();
 
        return WdfDevStatePwrPolTimerExpiredWakeCapableCleanup;
    }
 
    return WdfDevStatePwrPolNull;
}

PowerPolTimerExpiredWakeCapableUndoPowerDown()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolTimerExpiredWakeCapableUndoPowerDown ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 5579 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(
        This, WdfDevStatePwrPolTimerExpiredWakeCapableUndoPowerDown);
 
    //
    // We notified the device power requirement state machine that we are about
    // to power down, but eventually we didn't power down. So notify the device
    // power requirement state machine that the device should be considered
    // powered on.
    //
    This->m_PowerPolicyMachine.m_Owner->
                m_PoxInterface.DeviceIsPoweredOn();
    return WdfDevStatePwrPolDeviceIdleReturnToActive;
}

PowerPolTimerExpiredWakeCapableUsbSS()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolTimerExpiredWakeCapableUsbSS ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 5335 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolTimerExpiredWakeCapableUsbSS);
 
    This->PowerPolicySubmitUsbIdleNotification();
 
    return WdfDevStatePwrPolNull;
}

PowerPolTimerExpiredWakeCapableWakeArrived()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolTimerExpiredWakeCapableWakeArrived ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 5394 of file powerpolicystatemachine.cpp.

{
    NTSTATUS status;
 
    ASSERT_PWR_POL_STATE(
        This, WdfDevStatePwrPolTimerExpiredWakeCapableWakeArrived);
 
    status = This->m_PowerPolicyMachine.m_Owner->m_DeviceArmWakeFromS0.Invoke(
        This->m_Device->GetHandle()
        );
 
    if (!NT_SUCCESS(status)) {
        return WdfDevStatePwrPolTimerExpiredWakeCapableCancelWake;
    }
 
    //
    // If the PDO is the Power Policy owner, then enable wake at bus, otherwise
    // the power state machine will enable wake at bus.
    //
    if (This->m_Device->IsPdo()) {
        status = This->PowerEnableWakeAtBusOverload();
        if (!NT_SUCCESS(status)) {
            DoTraceLevelMessage(
                This->GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                "WDFDEVICE %p Failed to Enable Wake at Bus, %!STATUS!",
                This->m_Device->GetHandle(), status);
 
            return WdfDevStatePwrPolTimerExpiredWakeCapableCancelWake;
        }
    }
 
    This->PowerProcessEvent(PowerCompleteDx);
 
    return WdfDevStatePwrPolNull;
}

PowerPolTimerExpiredWakeCapableWakeCanceled()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolTimerExpiredWakeCapableWakeCanceled ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 5475 of file powerpolicystatemachine.cpp.

{
    UNREFERENCED_PARAMETER(This);
 
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolTimerExpiredWakeCapableWakeCanceled);
 
    return WdfDevStatePwrPolTimerExpiredWakeCapableCleanup;
}

PowerPolTimerExpiredWakeCapableWakeInterruptArrived()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolTimerExpiredWakeCapableWakeInterruptArrived ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 8389 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolTimerExpiredWakeCapableWakeInterruptArrived);
 
    if (This->PowerPolicyCancelWaitWake() == FALSE &&
        This->m_PowerPolicyMachine.m_Owner->m_WakeCompletionEventDropped) {
        return WdfDevStatePwrPolTimerExpiredWakeCapableWakeSucceeded;
    }
 
    return WdfDevStatePwrPolNull;
}

PowerPolTimerExpiredWakeCompletedDisarm()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolTimerExpiredWakeCompletedDisarm ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 5925 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolTimerExpiredWakeCompletedDisarm);
 
    //
    // If the PDO is the Power Policy owner, then disable wake at bus, otherwise
    // the power state machine will disable wake at bus.
    //
    if (This->m_Device->IsPdo()) {
        This->PowerDisableWakeAtBusOverload();
    }
 
    This->m_PowerPolicyMachine.m_Owner->m_DeviceDisarmWakeFromS0.Invoke(
        This->m_Device->GetHandle()
        );
 
    return WdfDevStatePwrPolTimerExpiredWakeCapableCleanup;
 
}

PowerPolTimerExpiredWakeCompletedHardwareStarted()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolTimerExpiredWakeCompletedHardwareStarted ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 5688 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This,
        WdfDevStatePwrPolTimerExpiredWakeCompletedHardwareStarted);
 
    This->m_PowerPolicyMachine.m_Owner->
                m_PoxInterface.DeviceIsPoweredOn();
 
    return WdfDevStatePwrPolS0WakeCompletePowerUp;
}

PowerPolTimerExpiredWakeCompletedPowerDown()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolTimerExpiredWakeCompletedPowerDown ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 5611 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(
        This, WdfDevStatePwrPolTimerExpiredWakeCompletedPowerDown);
 
    This->PowerProcessEvent(PowerCompleteDx);
 
    return WdfDevStatePwrPolNull;
}

PowerPolTimerExpiredWakeCompletedPowerUp()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolTimerExpiredWakeCompletedPowerUp ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 5638 of file powerpolicystatemachine.cpp.

{
    NTSTATUS status;
    BOOLEAN result;
 
    ASSERT_PWR_POL_STATE(
        This, WdfDevStatePwrPolTimerExpiredWakeCompletedPowerUp);
 
    This->m_PowerPolicyMachine.m_Owner->
            m_PoxInterface.RequestComponentActive();
 
    //
    // Disable the timer so that when we move back into D0, the timer is not
    // automatically started.  Since the timer has already fired, we should never
    // get FALSE back (which indicates we should wait for the timer to fire).
    //
    result = This->m_PowerPolicyMachine.m_Owner->m_PowerIdleMachine.DisableTimer();
    ASSERT(result);
    UNREFERENCED_PARAMETER(result);
 
    status = This->PowerPolicySendDevicePowerRequest(PowerDeviceD0, Retry);
 
    if (!NT_SUCCESS(status)) {
        //
        // Couldn't allocate power irp, goto the failed state
        //
        COVERAGE_TRAP();
        return WdfDevStatePwrPolDeviceD0PowerRequestFailed;
    }
 
    return WdfDevStatePwrPolNull;
}

PowerPolTimerExpiredWakeSucceeded()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolTimerExpiredWakeSucceeded ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 5898 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolTimerExpiredWakeSucceeded);
 
    This->m_PowerPolicyMachine.m_Owner->m_DeviceWakeFromS0Triggered.Invoke(
        This->m_Device->GetHandle()
        );
 
    return WdfDevStatePwrPolTimerExpiredWakeCompletedDisarm;
}

PowerPolWaitingArmedIoPresentCancelUsbSS()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolWaitingArmedIoPresentCancelUsbSS ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 8230 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolWaitingArmedIoPresentCancelUsbSS);
 
    if (This->PowerPolicyCancelUsbSSIfCapable()) {
        //
        // Usbss completion event will move us from this state.
        //
        return WdfDevStatePwrPolNull;
    }
 
    //
    // If usbss irp was there it has already been canceled, so march on.
    //
    return WdfDevStatePwrPolIoPresentArmed;
}

PowerPolWaitingArmedQueryIdle()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolWaitingArmedQueryIdle ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 5761 of file powerpolicystatemachine.cpp.

{
    //
    // If QueryReturnToIdle returns TRUE, return to the waiting state
    //
    if (This->m_PowerPolicyMachine.m_Owner->m_PowerIdleMachine.QueryReturnToIdle()) {
        return WdfDevStatePwrPolWaitingArmed;
    }
    else {
        return WdfDevStatePwrPolWaitingArmedIoPresentCancelUsbSS;
    }
}

PowerPolWaitingArmedStoppingCancelUsbSS()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolWaitingArmedStoppingCancelUsbSS ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 8157 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolWaitingArmedStoppingCancelUsbSS);
 
    This->m_PowerPolicyMachine.m_Owner->m_PowerIdleMachine.DisableTimer();
 
    //
    // Since we are in Dx and surprise removed, cancel the usb SS irp if it is
    // there.  Otherwise, the USB PDO will call us back after we have processed
    // remove.
    //
    if (This->PowerPolicyCancelUsbSSIfCapable()) {
        //
        // Usbss completion event will move us from this state.
        //
        return WdfDevStatePwrPolNull;
    }
 
    //
    // If usbss irp was there it has already been canceled, so march on.
    //
    return WdfDevStatePwrPolStoppingCancelWake;
}

PowerPolWaitingArmedUsbSS()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolWaitingArmedUsbSS ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 5717 of file powerpolicystatemachine.cpp.

{
    BOOLEAN result;
 
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolWaitingArmedUsbSS);
 
    if (This->m_PowerPolicyMachine.m_Owner->m_IdleSettings.UsbSSCapable) {
        This->m_PowerPolicyMachine.UsbSSCallbackProcessingComplete();
    }
 
    //
    // Disable the timer so that when we move back into D0, the timer is not
    // automatically started.  Since the timer has already fired, we should never
    // get FALSE back (which indicates we should wait for the timer to fire).
    //
    result = This->m_PowerPolicyMachine.m_Owner->m_PowerIdleMachine.DisableTimer();
    ASSERT(result);
    UNREFERENCED_PARAMETER(result);
 
    //
    // PwrPolIoPresent can be sent before PwrPolPowerTimeoutExpired in the idle
    // state machine if the idle s.m. attempts to cancel the timer after it has
    // started running.  That means the PwrPolIoPresent meant to wake up the
    // device and resume from idle is lost.  By first querying the idle s.m.
    // after moving into Dx we can recover from the lost event.
    //
    return WdfDevStatePwrPolWaitingArmedQueryIdle;
}

PowerPolWaitingArmedWakeFailedCancelUsbSS()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolWaitingArmedWakeFailedCancelUsbSS ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 8197 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolWaitingArmedWakeFailedCancelUsbSS);
 
    if (This->PowerPolicyCancelUsbSSIfCapable()) {
        //
        // Usbss completion event will move us from this state.
        //
        return WdfDevStatePwrPolNull;
    }
 
    //
    // If usbss irp was there it has already been canceled, so march on.
    //
    return WdfDevStatePwrPolIoPresentArmedWakeCanceled;
}

PowerPolWaitingArmedWakeInterruptFired()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolWaitingArmedWakeInterruptFired ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 5810 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolWaitingArmedWakeInterruptFired);
 
    if (This->PowerPolicyCancelWaitWake() == FALSE &&
        This->m_PowerPolicyMachine.m_Owner->m_WakeCompletionEventDropped) {
        return WdfDevStatePwrPolWaitingArmedWakeSucceededCancelUsbSS;
    }
 
    return WdfDevStatePwrPolNull;
}

PowerPolWaitingArmedWakeSucceededCancelUsbSS()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolWaitingArmedWakeSucceededCancelUsbSS ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 8263 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolWaitingArmedWakeSucceededCancelUsbSS);
 
    if (This->PowerPolicyCancelUsbSSIfCapable()) {
        //
        // Usbss completion event will move us from this state.
        //
        return WdfDevStatePwrPolNull;
    }
 
    //
    // If usbss irp was there it has already been canceled, so march on.
    //
    return WdfDevStatePwrPolWokeFromS0;
}

PowerPolWaitingUnarmedQueryIdle()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolWaitingUnarmedQueryIdle ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3943 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolWaitingUnarmedQueryIdle);
 
    //
    // If QueryReturnToIdle returns TRUE, return to the waiting state
    //
    if (This->m_PowerPolicyMachine.m_Owner->m_PowerIdleMachine.QueryReturnToIdle()) {
        return WdfDevStatePwrPolWaitingUnarmed;
    }
    else {
        return WdfDevStatePwrPolS0NoWakePowerUp;
    }
}

PowerPolWakeCapableDeviceIdle()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolWakeCapableDeviceIdle ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 5179 of file powerpolicystatemachine.cpp.

{
    BOOLEAN canPowerDown;
 
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolWakeCapableDeviceIdle);
 
    canPowerDown = This->m_PowerPolicyMachine.m_Owner->
                            m_PoxInterface.DeclareComponentIdle();
 
    //
    // If we are using driver-managed idle timeout we can power down immediately
    // and so we jump to the next state (that initiates power down) immediately.
    // If we are using system-managed idle timeout, we wait in the current state
    // for device-power-not-required notification.
    //
    return (canPowerDown ?
                WdfDevStatePwrPolTimerExpiredDecideUsbSS :
                WdfDevStatePwrPolNull);
}

PowerPolWakeCapableUsbSSCompleted()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolWakeCapableUsbSSCompleted ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 5359 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolWakeCapableUsbSSCompleted);
 
    //
    // We notified the device power requirement state machine that we are about
    // to power down, but eventually we didn't power down. So notify the device
    // power requirement state machine that the device should be considered
    // powered on.
    //
    This->m_PowerPolicyMachine.m_Owner->
                m_PoxInterface.DeviceIsPoweredOn();
 
    This->m_PowerPolicyMachine.m_Owner->
            m_PoxInterface.RequestComponentActive();
 
    return WdfDevStatePwrPolStartedWakeCapable;
}

PowerPolWakeFailedUsbSS()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolWakeFailedUsbSS ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 5962 of file powerpolicystatemachine.cpp.

{
    BOOLEAN result;
 
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolWakeFailedUsbSS);
 
    if (This->m_PowerPolicyMachine.m_Owner->m_IdleSettings.UsbSSCapable) {
        This->m_PowerPolicyMachine.UsbSSCallbackProcessingComplete();
    }
 
    //
    // Disable the timer so that when we move back into D0, the timer is not
    // automatically started.  Since the timer has already fired, we should never
    // get FALSE back (which indicates we should wait for the timer to fire).
    //
    result = This->m_PowerPolicyMachine.m_Owner->m_PowerIdleMachine.DisableTimer();
    ASSERT(result);
    UNREFERENCED_PARAMETER(result);
 
    //
    // cancel USB SS irp if capable
    //
    if (This->PowerPolicyCancelUsbSSIfCapable()) {
        //
        // wait for Usbss completion event to move us from this state.
        //
        return WdfDevStatePwrPolNull;
    }
 
    return WdfDevStatePwrPolIoPresentArmedWakeCanceled;
}

PowerPolWokeFromS0()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolWokeFromS0 ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 6252 of file powerpolicystatemachine.cpp.

{
    NTSTATUS status;
 
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolWokeFromS0);
 
    This->m_PowerPolicyMachine.m_Owner->
            m_PoxInterface.RequestComponentActive();
 
    status = This->PowerPolicySendDevicePowerRequest(PowerDeviceD0, Retry);
    if (!NT_SUCCESS(status)) {
        COVERAGE_TRAP();
        return WdfDevStatePwrPolDeviceD0PowerRequestFailed;
    }
 
    return WdfDevStatePwrPolNull;
}

PowerPolWokeFromS0NotifyDriver()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolWokeFromS0NotifyDriver ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 6273 of file powerpolicystatemachine.cpp.

{
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolWokeFromS0NotifyDriver);
 
    This->m_PowerPolicyMachine.m_Owner->m_DeviceWakeFromS0Triggered.Invoke(
        This->m_Device->GetHandle()
        );
 
    return WdfDevStatePwrPolS0WakeDisarm;
}

PowerPolWokeFromS0UsbSS()

WDF_DEVICE_POWER_POLICY_STATE FxPkgPnp::PowerPolWokeFromS0UsbSS ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 6204 of file powerpolicystatemachine.cpp.

{
    BOOLEAN result;
 
    ASSERT_PWR_POL_STATE(This, WdfDevStatePwrPolWokeFromS0UsbSS);
 
    if (This->m_PowerPolicyMachine.m_Owner->m_IdleSettings.UsbSSCapable) {
        This->m_PowerPolicyMachine.UsbSSCallbackProcessingComplete();
    }
 
    //
    // Disable the timer so that when we move back into D0, the timer is not
    // automatically started.  Since the timer has already fired, we should never
    // get FALSE back (which indicates we should wait for the timer to fire).
    //
    result = This->m_PowerPolicyMachine.m_Owner->m_PowerIdleMachine.DisableTimer();
    ASSERT(result);
    UNREFERENCED_PARAMETER(result);
 
    //
    // Cancel USBSS irp if capable
    //
    if (This->PowerPolicyCancelUsbSSIfCapable()) {
        //
        // Usbss completion event will move us from this state.
        //
        return WdfDevStatePwrPolNull;
    }
 
    return WdfDevStatePwrPolWokeFromS0;
}

PowerPowerFailedPowerDown()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerPowerFailedPowerDown ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3894 of file powerstatemachine.cpp.

{
    //
    // Even though we failed power up and never really powered down, record our
    // state as powered down, so that if we are restarted (can easily happen for
    // a PDO), we have the correct previous state.
    //
    This->PowerSetDevicePowerState(WdfPowerDeviceD3Final);
 
    This->PowerSendPowerDownEvents(FxPowerDownTypeImplicit);
 
    return WdfDevStatePowerStopped;
}

PowerProcessEvent()

VOID FxPkgPnp::PowerProcessEvent	(	__in FxPowerEvent	Event,
		__in BOOLEAN	ProcessEventOnDifferentThread = FALSE
	)

Definition at line 1156 of file powerstatemachine.cpp.

{
    NTSTATUS status;
    KIRQL irql;
 
    //
    // Take the lock, raising to DISPATCH_LEVEL.
    //
    m_PowerMachine.Lock(&irql);
 
    //
    // If the input Event is any of the events described by PowerSingularEventMask,
    // then check whether it is already queued up. If so, then dont enqueue this
    // Event.
    //
    if (Event & PowerSingularEventMask) {
        if ((m_PowerMachine.m_SingularEventsPresent & Event) == 0x00) {
            m_PowerMachine.m_SingularEventsPresent |= Event;
        }
        else {
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGPNP,
                "WDFDEVICE 0x%p !devobj 0x%p current pwr pol state "
                "%!WDF_DEVICE_POWER_STATE! dropping event %!FxPowerEvent! because "
                "the Event is already enqueued.", m_Device->GetHandle(),
                m_Device->GetDeviceObject(),
                m_Device->GetDevicePowerState(),
                Event);
 
            m_PowerMachine.Unlock(irql);
            return;
        }
    }
 
    if (m_PowerMachine.IsFull()) {
        //
        // The queue is full.  Bail.
        //
        m_PowerMachine.Unlock(irql);
 
        ASSERT(!"The Power queue is full.  This shouldn't be able to happen.");
        return;
    }
 
    if (m_PowerMachine.IsClosedLocked()) {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGPNP,
            "WDFDEVICE 0x%p !devobj 0x%p current pwr pol state "
            "%!WDF_DEVICE_POWER_STATE! dropping event %!FxPowerEvent! because "
            "of a closed queue", m_Device->GetHandle(),
            m_Device->GetDeviceObject(),
            m_Device->GetDevicePowerState(),
            Event);
 
        //
        // The queue is closed.  Bail
        //
        m_PowerMachine.Unlock(irql);
 
        return;
    }
 
    //
    // Enqueue the event.  Whether the event goes on the front
    // or the end of the queue depends on which event it is.
    //
    if (Event & PowerPriorityEventsMask) {
        //
        // Stick it on the front of the queue, making it the next
        // event that will be processed.
        //
        m_PowerMachine.m_Queue.Events[m_PowerMachine.InsertAtHead()] = (USHORT) Event;
    }
    else {
        //
        // Stick it on the end of the queue.
        //
        m_PowerMachine.m_Queue.Events[m_PowerMachine.InsertAtTail()] = (USHORT) Event;
    }
 
    //
    // Drop the lock.
    //
    m_PowerMachine.Unlock(irql);
 
    //
    // Now, if we are running at PASSIVE_LEVEL, attempt to run the state
    // machine on this thread.  If we can't do that, then queue a work item.
    //
 
    if (irql == PASSIVE_LEVEL &&
        FALSE == ProcessOnDifferentThread) {
        LONGLONG timeout = 0;
 
        status = m_PowerMachine.m_StateMachineLock.AcquireLock(
            GetDriverGlobals(), &timeout);
 
        if (FxWaitLockInternal::IsLockAcquired(status)) {
            FxPostProcessInfo info;
 
            //
            // We now hold the state machine lock.  So call the function that
            // dispatches the next state.
            //
            PowerProcessEventInner(&info);
 
            //
            // The pnp state machine should be the only one deleting the object
            //
            ASSERT(info.m_DeleteObject == FALSE);
 
            m_PowerMachine.m_StateMachineLock.ReleaseLock(GetDriverGlobals());
 
            info.Evaluate(this);
 
            return;
        }
    }
 
    //
    // The tag added above will be released when the work item runs
    //
 
    // For one reason or another, we couldn't run the state machine on this
    // thread.  So queue a work item to do it.  If m_PnPWorkItemEnqueuing
    // is non-zero, that means that the work item is already being enqueued
    // on another thread.  This is significant, since it means that we can't do
    // anything with the work item on this thread, but it's okay, since the
    // work item will pick up our work and do it.
    //
    m_PowerMachine.QueueToThread();
}

Referenced by AckPendingWakeInterruptOperation(), CommitUsageNotification(), FxPkgPdo::DispatchDeviceSetPower(), DispatchWaitWake(), FxPkgFdo::LowerDevicePower(), and PowerIndicateWaitWakeStatus().

PowerProcessEventInner()

VOID FxPkgPnp::PowerProcessEventInner ( __inout FxPostProcessInfo *  Info )

protected

Definition at line 1345 of file powerstatemachine.cpp.

{
    WDF_DEVICE_POWER_STATE currentPowerState, newState;
    CPPOWER_STATE_TABLE entry;
    FxPowerEvent event;
    KIRQL       oldIrql;
 
    //
    // Process as many events as we can.
    //
    for (;;) {
 
        newState = WdfDevStatePowerNull;
        currentPowerState = m_Device->GetDevicePowerState();
        entry = GetPowerTableEntry(currentPowerState);
 
        //
        // Get an event from the queue.
        //
        m_PowerMachine.Lock(&oldIrql);
 
        if (m_PowerMachine.IsEmpty()) {
            m_PowerMachine.GetFinishedState(Info);
 
            //
            // The queue is empty.
            //
            m_PowerMachine.Unlock(oldIrql);
            return;
        }
 
        event = (FxPowerEvent) m_PowerMachine.m_Queue.Events[m_PowerMachine.GetHead()];
 
        //
        // At this point, we need to determine whether we can process this
        // event.
        //
        if (event & PowerPriorityEventsMask) {
            //
            // These are always possible to handle.
            //
            DO_NOTHING();
        }
        else {
            //
            // Check to see if this state can handle new events.
            //
            if (entry->StateInfo.Bits.QueueOpen == FALSE) {
                //
                // This state can't handle new events.
                //
                m_PowerMachine.Unlock(oldIrql);
                return;
            }
        }
 
        //
        // If the event obtained from the queue was a singular event, then
        // clear the flag to allow other similar events to be put into this
        // queue for processing.
        //
        if (m_PowerMachine.m_SingularEventsPresent & event) {
           m_PowerMachine.m_SingularEventsPresent &= ~event;
        }
 
        m_PowerMachine.IncrementHead();
        m_PowerMachine.Unlock(oldIrql);
 
        //
        // Find the entry in the power state table that corresponds to this event
        //
        if (entry->FirstTargetState.PowerEvent == event) {
            newState = entry->FirstTargetState.TargetState;
 
            DO_EVENT_TRAP(&entry->FirstTargetState);
        }
        else if (entry->OtherTargetStates != NULL) {
            ULONG i = 0;
 
            for (i = 0;
                 entry->OtherTargetStates[i].PowerEvent != PowerEventMaximum;
                 i++) {
                if (entry->OtherTargetStates[i].PowerEvent == event) {
                    newState = entry->OtherTargetStates[i].TargetState;
                    DO_EVENT_TRAP(&entry->OtherTargetStates[i]);
                    break;
                }
            }
        }
 
        if (newState == WdfDevStatePowerNull) {
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
                "WDFDEVICE 0x%p !devobj 0x%p current power state "
                "%!WDF_DEVICE_POWER_STATE! dropping event %!FxPowerEvent!",
                m_Device->GetHandle(),
                m_Device->GetDeviceObject(),
                m_Device->GetDevicePowerState(), event);
 
            //
            // This state doesn't respond to the Event.  Potentially throw
            // the event away.
            //
            if ((entry->StateInfo.Bits.KnownDroppedEvents & event) == 0) {
                COVERAGE_TRAP();
 
                DoTraceLevelMessage(
                    GetDriverGlobals(), TRACE_LEVEL_WARNING, TRACINGPNP,
                    "WDFDEVICE %p !devobj 0x%p current state "
                    "%!WDF_DEVICE_POWER_STATE! event %!FxPowerEvent! is not a "
                    "known dropped event, known dropped events are "
                    "%!FxPowerEvent!", m_Device->GetHandle(),
                    m_Device->GetDeviceObject(),
                    m_Device->GetDevicePowerState(),
                    event, entry->StateInfo.Bits.KnownDroppedEvents);
 
 
            }
 
            switch (event) {
            case PowerWakeSucceeded:
            case PowerWakeFailed:
            case PowerWakeCanceled:
                //
                // There are states where we don't care if the wake completed.
                // Since the completion/cancellation of the wake request posts
                // an event which it assumes will complete the request, we must
                // catch these events here and complete the request.
                //
                PowerCompletePendedWakeIrp();
                break;
 
            case PowerD0:
            case PowerDx:
                //
                // There are some (non WDF) power policy owner implementations
                // which send Dx to Dx or D0 to D0 transitions to the stack.
                //
                // We don't explicitly handle them in the state machine.
                //
                // Instead, we complete the pended irp if are about to drop it
                // on the floor.
                //
                PowerReleasePendingDeviceIrp();
                break;
            }
        }
        else {
            //
            // Now enter the new state.
            //
            PowerEnterNewState(newState);
        }
    }
}

Referenced by PowerProcessEvent().

PowerReference()

_Must_inspect_result_ NTSTATUS __inline FxPkgPnp::PowerReference ( __in BOOLEAN  WaitForD0, __in_opt PVOID  Tag = NULL, __in_opt LONG  Line = 0, __in_opt PSTR  File = NULL  )

inline

Definition at line 3486 of file fxpkgpnp.hpp.

    {
        return m_PowerPolicyMachine.m_Owner->m_PowerIdleMachine.PowerReference(WaitForD0, Tag, Line, File);
    }

Referenced by PnpDeviceUsageNotification(), PnpPowerReferenceSelf(), PowerPolicyCanChildPowerUp(), FxIoQueue::SetTransitionFromEmpty(), and StopIdleWorker().

PowerReleasePendingDeviceIrp()

virtual VOID FxPkgPnp::PowerReleasePendingDeviceIrp ( BOOLEAN  IrpMustBePresent = TRUE )

protectedpure virtual

Referenced by PowerGotoDxIoStopped(), PowerGotoDxIoStoppedNP(), and PowerProcessEventInner().

PowerReportPowerDownFailed()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerReportPowerDownFailed ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3925 of file powerstatemachine.cpp.

{
 
 
 
 
    This->PowerReleasePendingDeviceIrp();
    This->PowerSendPowerDownFailureEvent(FxPowerDownTypeExplicit);
 
    return WdfDevStatePowerNull;
}

PowerReportPowerUpFailed()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerReportPowerUpFailed ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3868 of file powerstatemachine.cpp.

{
    This->m_SystemPowerAction = PowerActionNone;
 
    This->PowerReleasePendingDeviceIrp();
    This->PowerSendPowerUpFailureEvent();
 
    return WdfDevStatePowerNull;
}

PowerReportPowerUpFailedDerefParent()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerReportPowerUpFailedDerefParent ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3842 of file powerstatemachine.cpp.

{
    //
    // If this is a child, release the power reference on the parent
    //
    This->PowerParentPowerDereference();
 
    return WdfDevStatePowerReportPowerUpFailed;
}

PowerSendIdlePowerEvent()

VOID FxPkgPnp::PowerSendIdlePowerEvent ( __in FxPowerIdleEvents  Event )

protected

Definition at line 5020 of file powerstatemachine.cpp.

{
    if (IsPowerPolicyOwner()) {
        m_PowerPolicyMachine.m_Owner->m_PowerIdleMachine.ProcessPowerEvent(Event);
    }
}

Referenced by PowerSendPowerDownEvents(), PowerSendPowerUpEvents(), and PowerSendPowerUpFailureEvent().

PowerSendPowerDownEvents()

VOID FxPkgPnp::PowerSendPowerDownEvents ( __in FxPowerDownType  Type )

protected

Definition at line 5030 of file powerstatemachine.cpp.

{
    //
    // If this is an implicit power type, there is completion routine on the
    // power irp and we must send these events in the power state machine
    // regardless if we are the PPO or not.
    //
    if (Type == FxPowerDownTypeImplicit) {
        PowerSendIdlePowerEvent(PowerIdleEventPowerDown);
 
        //
        // If we are the power policy owner, there is no need to distinguish
        // between an implicit power down or an explicit power down since the
        // PPO controls all power irps in the stack and a power policy stop
        // (e.g. an implicit power down) will not be racing with a real power
        // irp.
        //
        // The non PPO state machine needs to distinguish between the 2 types
        // of power downs because both of them may occur simultaneously and we
        // don't want to interpret the power down event for the real Dx irp with
        // the power down event for the (final) implicit power down.
        //
        PowerPolicyProcessEvent(IsPowerPolicyOwner() ? PwrPolPowerDown
                                                     : PwrPolImplicitPowerDown);
        return;
    }
 
    ASSERT(Type == FxPowerDownTypeExplicit);
 
    //
    // If we are the PPO, then we will send PwrPolPowerDown in the completion
    // routine passed to PoRequestPowerIrp.  If we are not the PPO, we must send
    // the event now because we have no such completion routine.
    //
    if (IsPowerPolicyOwner()) {
        //
        // Transition the idle state machine to off immediately.
        //
        m_PowerPolicyMachine.m_Owner->m_PowerIdleMachine.ProcessPowerEvent(
            PowerIdleEventPowerDown
            );
    }
    else {
        //
        // If we are not the PPO, there is no idle state machine to send an
        // event to and there is no Po request completion routine to send this
        // event, so we send it now.
        //
        PowerPolicyProcessEvent(PwrPolPowerDown);
    }
}

Referenced by PowerGotoDxIoStopped(), and PowerGotoDxIoStoppedNP().

PowerSendPowerDownFailureEvent()

VOID FxPkgPnp::PowerSendPowerDownFailureEvent ( __in FxPowerDownType  Type )

protected

Definition at line 5124 of file powerstatemachine.cpp.

{
    SetInternalFailure();
 
    if (IsPowerPolicyOwner()) {
        //
        // If we are the PPO and this is an explicit power operation, then we
        // will send PwrPolPowerDownFailed in the completion routine passed to
        // PoRequestPowerIrp.   Otherwise, if this is an implicit power operation
        // that failed, we need to send the event now because there is no
        // Po completion routine to send the event later.
        //
        if (Type == FxPowerDownTypeImplicit) {
            //
            // Since there is no power irp to complete, we must send the event
            // now.
            //
            // We only send PwrPolImplicitPowerDownFailed if we are not the
            // PPO, so we can't share code with the !PPO path.
            //
            PowerPolicyProcessEvent(PwrPolPowerDownFailed);
        }
        else {
            ASSERT(Type == FxPowerDownTypeExplicit);
 
            //
            // Process the state change immediately in the idle state machine.
            // We should do this only on an explicit power down since the PPO
            // will have disabled the idle state machine before attempting an
            // implicit power down.
            //
            m_PowerPolicyMachine.m_Owner->m_PowerIdleMachine.ProcessPowerEvent(
                PowerIdleEventPowerDownFailed
                );
        }
    }
    else {
        //
        // We are not the PPO, so we must send the event now because we have no
        // such completion routine.  Decide which event to send to the
        // !PPO state machine.
        //
        PowerPolicyProcessEvent(
            Type == FxPowerDownTypeImplicit ? PwrPolImplicitPowerDownFailed
                                            : PwrPolPowerDownFailed
            );
 
        //
        // Send the pnp event last becuase if we are in the middle of a Dx
        // transition during S0, there is no S irp to guard a pnp state change
        // from occurring immediately after sending this event.  If we sent it
        // before sending the power policy message, power policy might not
        // transition to the failed state by the time pnp does creating a
        // mismatch.
        //
        if (FALSE == m_ReleaseHardwareAfterDescendantsOnFailure) {
            PnpProcessEvent(PnpEventPowerDownFailed);
        }
    }
}

PowerSendPowerUpEvents()

VOID FxPkgPnp::PowerSendPowerUpEvents ( VOID  )

protected

Definition at line 5097 of file powerstatemachine.cpp.

{
    PowerSendIdlePowerEvent(PowerIdleEventPowerUpComplete);
 
    //
    // This must be called *before* PowerPostParentToD0ToChildren so that we
    // clear the child power up guard variable in the power policy state machine
    // and then post an event which will unblock the child.
    //
    PowerPolicyProcessEvent(PwrPolPowerUp);
}

PowerSendPowerUpFailureEvent()

VOID FxPkgPnp::PowerSendPowerUpFailureEvent ( VOID  )

protected

Definition at line 5201 of file powerstatemachine.cpp.

{
    SetInternalFailure();
    PowerSendIdlePowerEvent(PowerIdleEventPowerUpFailed);
 
    PowerPolicyProcessEvent(PwrPolPowerUpFailed);
 
    if (FALSE == m_ReleaseHardwareAfterDescendantsOnFailure) {
        PnpProcessEvent(PnpEventPowerUpFailed);
    }
}

PowerSetDevicePowerState()

VOID FxPkgPnp::PowerSetDevicePowerState ( __in WDF_POWER_DEVICE_STATE  State )

protected

Definition at line 5229 of file powerstatemachine.cpp.

{
    POWER_STATE powerState;
 
    //
    // Remember our previous state
    //
    m_DevicePowerStateOld = m_DevicePowerState;
 
    //
    // Set our new state
    //
    ASSERT(State <= 0xFF);
    m_DevicePowerState = (BYTE) State;
 
    //
    // Notify the system of the new power state.
    //
    switch (State) {
    case WdfPowerDeviceD3Final:
    case WdfPowerDevicePrepareForHibernation:
        powerState.DeviceState = PowerDeviceD3;
        break;
 
    case WdfPowerDeviceD0:
         m_SystemPowerAction = PowerActionNone;
         __fallthrough;
 
    default:
        powerState.DeviceState = (DEVICE_POWER_STATE) State;
        break;
    }
 
    MxDeviceObject deviceObject(m_Device->GetDeviceObject());
    deviceObject.SetPowerState(
                    DevicePowerState,
                    powerState);
}

Referenced by PowerConnectInterruptFailed(), PowerGotoDxIoStopped(), and PowerGotoDxIoStoppedNP().

PowerStartingCheckDeviceType()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerStartingCheckDeviceType ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 2478 of file powerstatemachine.cpp.

{
    if (This->m_Device->IsPdo()) {
        return WdfDevStatePowerStartingChild;
    }
    else {
        return WdfDevStatePowerD0Starting;
    }
}

PowerStartingChild()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerStartingChild ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 2505 of file powerstatemachine.cpp.

{
    NTSTATUS status;
    BOOLEAN parentOn;
 
    status = This->PowerCheckParentOverload(&parentOn);
 
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(
            This->GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
            "PowerReference on parent WDFDEVICE %p for child WDFDEVICE %p "
            "failed, %!STATUS!", This->m_Device->m_ParentDevice->m_Device->GetHandle(),
                This->m_Device->GetHandle(),
            status);
 
        return WdfDevStatePowerInitialPowerUpFailed;
    }
    else if (parentOn) {
        //
        // Parent is powered on, start the power up sequence
        //
        return WdfDevStatePowerD0Starting;
    }
    else {
        //
        // The call to PowerReference will bring the parent into D0 and
        // move us out of this state after we return.
        //
        return WdfDevStatePowerNull;
    }
}

PowerStartSelfManagedIo()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerStartSelfManagedIo ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3199 of file powerstatemachine.cpp.

{
 
 
 
 
 
    // Top-edge queue release
    This->m_Device->m_PkgIo->ResumeProcessingForPower();
 
    if (This->m_SelfManagedIoMachine != NULL) {
        NTSTATUS    status;
 
        status = This->m_SelfManagedIoMachine->Start();
 
        if (!NT_SUCCESS(status)) {
            DoTraceLevelMessage(
                This->GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                "EvtDeviceSelfManagedIoRestart failed - %!STATUS!", status);
 
            return WdfDevStatePowerStartSelfManagedIoFailed;
        }
    }
 
    This->PowerSetDevicePowerState(WdfPowerDeviceD0);
 
    //
    // Send the PowerUp event to both the PnP and the Power Policy state
    // machines.
    //
    This->PowerSendPowerUpEvents();
 
    This->PowerReleasePendingDeviceIrp();
 
    if (This->m_SharedPower.m_WaitWakeOwner) {
        return WdfDevStatePowerD0BusWakeOwner;
    }
    else {
        return WdfDevStatePowerD0;
    }
}

PowerStartSelfManagedIoFailed()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerStartSelfManagedIoFailed ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3318 of file powerstatemachine.cpp.

{
 
 
 
 
    This->m_Device->m_PkgIo->StopProcessingForPower(FxIoStopProcessingForPowerHold);
 
    return WdfDevStatePowerWakingDmaEnableFailed;
}

PowerStartSelfManagedIoFailedNP()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerStartSelfManagedIoFailedNP ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3345 of file powerstatemachine.cpp.

{
 
 
 
 
    This->m_Device->m_PkgIo->StopProcessingForPower(FxIoStopProcessingForPowerHold);
 
    return WdfDevStatePowerWakingDmaEnableFailedNP;
}

PowerStartSelfManagedIoNP()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerStartSelfManagedIoNP ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3259 of file powerstatemachine.cpp.

{
 
 
 
 
 
    // Top-edge queue release
    This->m_Device->m_PkgIo->ResumeProcessingForPower();
 
    if (This->m_SelfManagedIoMachine != NULL) {
        NTSTATUS    status;
 
        status = This->m_SelfManagedIoMachine->Start();
 
        if (!NT_SUCCESS(status)) {
            DoTraceLevelMessage(
                This->GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                "EvtDeviceSelfManagedIoRestart failed - %!STATUS!", status);
 
            return WdfDevStatePowerStartSelfManagedIoFailedNP;
        }
    }
 
    This->PowerSetDevicePowerState(WdfPowerDeviceD0);
 
    //
    // Send the PowerUp event to both the PnP and the Power Policy state machines.
    //
    This->PowerSendPowerUpEvents();
 
    This->PowerReleasePendingDeviceIrp();
 
    if (This->m_SharedPower.m_WaitWakeOwner) {
        return WdfDevStatePowerD0BusWakeOwnerNP;
    }
    else {
        return WdfDevStatePowerD0NP;
    }
}

PowerStoppedCompleteDx()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerStoppedCompleteDx ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4230 of file powerstatemachine.cpp.

{
    //
    // We should only get into this state when this devobj is not the power
    // policy owner.
    //
    ASSERT(This->IsPowerPolicyOwner() == FALSE);
 
    This->PowerReleasePendingDeviceIrp();
    return WdfDevStatePowerDxStopped;
}

PowerSurpriseRemoved()

static WDF_DEVICE_POWER_STATE FxPkgPnp::PowerSurpriseRemoved ( __inout FxPkgPnp *  This )

staticprotected

PowerUpFailed()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerUpFailed ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4469 of file powerstatemachine.cpp.

{
    COVERAGE_TRAP();
    //
    // Notify the interrupt state machines that the power up failed
    //
    This->SendEventToAllWakeInterrupts(WakeInterruptEventD0EntryFailed);
    //
    // NotifyResourceObjectsDx will log any errors
    //
    (void) This->NotifyResourceObjectsDx(NotifyResourcesForceDisconnect |
                                     NotifyResourcesDisconnectInactive);
 
    return WdfDevStatePowerReportPowerUpFailed;
}

PowerUpFailedDerefParent()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerUpFailedDerefParent ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4439 of file powerstatemachine.cpp.

{
    //
    // Notify the interrupt state machines that the power up failed
    //
    This->SendEventToAllWakeInterrupts(WakeInterruptEventD0EntryFailed);
    //
    // NotifyResourceObjectsDx will log any errors
    //
    (void) This->NotifyResourceObjectsDx(NotifyResourcesForceDisconnect |
                                     NotifyResourcesDisconnectInactive);
 
    return WdfDevStatePowerReportPowerUpFailedDerefParent;
}

PowerUpFailedDerefParentNP()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerUpFailedDerefParentNP ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4552 of file powerstatemachine.cpp.

{
    //
    // Notify the interrupt state machines that the power up failed
    //
    This->SendEventToAllWakeInterrupts(WakeInterruptEventD0EntryFailed);
    This->DisconnectInterruptNP();
 
    return WdfDevStatePowerReportPowerUpFailedDerefParent;
}

PowerUpFailedNP()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerUpFailedNP ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 4578 of file powerstatemachine.cpp.

{
    //
    // Notify the interrupt state machines that the power up failed
    //
    This->SendEventToAllWakeInterrupts(WakeInterruptEventD0EntryFailed);
    This->DisconnectInterruptNP();
 
    return WdfDevStatePowerReportPowerUpFailed;
}

PowerWakePending()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerWakePending ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3373 of file powerstatemachine.cpp.

{
    This->PowerCompletePendedWakeIrp();
    return WdfDevStatePowerNull;
}

PowerWakePendingNP()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerWakePendingNP ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3397 of file powerstatemachine.cpp.

{
    This->PowerCompletePendedWakeIrp();
    return WdfDevStatePowerNull;
}

PowerWaking()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerWaking ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3421 of file powerstatemachine.cpp.

{
    NTSTATUS status;
 
    //
    // m_DevicePowerState is the "old" state because we update it after the
    // D0Entry callback in SelfManagedIo or PowerPolicyStopped
    //
    status = This->m_DeviceD0Entry.Invoke(
        This->m_Device->GetHandle(),
        (WDF_POWER_DEVICE_STATE) This->m_DevicePowerState);
 
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(
            This->GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
            "EvtDeviceD0Entry WDFDEVICE 0x%p !devobj 0x%p, old state "
            "%!WDF_POWER_DEVICE_STATE! failed, %!STATUS!",
            This->m_Device->GetHandle(),
            This->m_Device->GetDeviceObject(),
            This->m_DevicePowerState, status);
 
        return WdfDevStatePowerUpFailedDerefParent;
    }
 
    return WdfDevStatePowerNotifyingD0EntryToWakeInterrupts;
}

PowerWakingConnectInterrupt()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerWakingConnectInterrupt ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3511 of file powerstatemachine.cpp.

{
    NTSTATUS status;
 
    //
    // interrupt connect and enable
    //
    status = This->NotifyResourceObjectsD0(NotifyResourcesExplicitPowerup);
 
    if (!NT_SUCCESS(status)) {
        return WdfDevStatePowerWakingConnectInterruptFailed;
    }
 
    status = This->m_DeviceD0EntryPostInterruptsEnabled.Invoke(
        This->m_Device->GetHandle(),
        (WDF_POWER_DEVICE_STATE) This->m_DevicePowerState);
 
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(
            This->GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
            "EvtDeviceD0EntryPostInterruptsEnabed WDFDEVICE 0x%p !devobj 0x%p, "
            "old state %!WDF_POWER_DEVICE_STATE! failed, %!STATUS!",
            This->m_Device->GetHandle(),
            This->m_Device->GetDeviceObject(),
            This->m_DevicePowerState, status);
        return WdfDevStatePowerWakingConnectInterruptFailed;
    }
 
    return WdfDevStatePowerWakingDmaEnable;
}

PowerWakingConnectInterruptFailed()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerWakingConnectInterruptFailed ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3608 of file powerstatemachine.cpp.

{
    This->PowerConnectInterruptFailed();
 
    return WdfDevStatePowerReportPowerUpFailedDerefParent;
}

PowerWakingConnectInterruptFailedNP()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerWakingConnectInterruptFailedNP ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3631 of file powerstatemachine.cpp.

{
    //
    // PowerConnectInterruptFailed will call IoDisconnectInterrupt.  Since we
    // are in the NP path, this may cause a deadlock between this thread and
    // paging I/O.  Log something to the IFR so that if the watchdog timer kicks
    // in, at least we have context as to why we died.
    //
    DoTraceLevelMessage(
        This->GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
        "Force disconnecting interupts on !devobj %p, WDFDEVICE %p",
        This->m_Device->GetDeviceObject(),
        This->m_Device->GetHandle());
 
    This->PowerConnectInterruptFailed();
 
    return WdfDevStatePowerReportPowerUpFailedDerefParent;
}

PowerWakingConnectInterruptNP()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerWakingConnectInterruptNP ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3559 of file powerstatemachine.cpp.

{
    NTSTATUS status;
 
    //
    // interrupt enable (already connected b/c they were never disconnected
    // during the Dx transition).
    //
    status = This->NotifyResourceObjectsD0(NotifyResourcesNP);
 
    if (!NT_SUCCESS(status)) {
        return WdfDevStatePowerWakingConnectInterruptFailedNP;
    }
 
    status = This->m_DeviceD0EntryPostInterruptsEnabled.Invoke(
        This->m_Device->GetHandle(),
        (WDF_POWER_DEVICE_STATE) This->m_DevicePowerState);
 
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(
            This->GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
            "EvtDeviceD0EntryPostInterruptsEnabed WDFDEVICE 0x%p !devobj 0x%p, "
            "old state %!WDF_POWER_DEVICE_STATE! failed, %!STATUS!",
            This->m_Device->GetHandle(),
            This->m_Device->GetDeviceObject(),
            This->m_DevicePowerState, status);
        return WdfDevStatePowerWakingConnectInterruptFailedNP;
    }
 
    return WdfDevStatePowerWakingDmaEnableNP;
}

PowerWakingDmaEnable()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerWakingDmaEnable ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3698 of file powerstatemachine.cpp.

{
    if (This->PowerDmaEnableAndScan(FALSE) == FALSE) {
        return WdfDevStatePowerWakingDmaEnableFailed;
    }
 
    //
    // Return the state that we should drop into next.
    //
    return WdfDevStatePowerNull;
}

PowerWakingDmaEnableFailed()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerWakingDmaEnableFailed ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3754 of file powerstatemachine.cpp.

{
    NTSTATUS status;
 
    (void) This->PowerDmaPowerDown();
 
    status = This->m_DeviceD0ExitPreInterruptsDisabled.Invoke(
        This->m_Device->GetHandle(),
        WdfPowerDeviceD3Final
        );
 
    if (!NT_SUCCESS(status)) {
        //
        // Report the error, but continue forward
        //
        DoTraceLevelMessage(
            This->GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
            "EvtDeviceD0ExitPreInterruptsDisabled WDFDEVICE 0x%p !devobj 0x%p "
            "new state %!WDF_POWER_DEVICE_STATE! failed, %!STATUS!",
            This->m_Device->GetHandle(),
            This->m_Device->GetDeviceObject(),
            WdfPowerDeviceD3Final, status);
    }
 
    return WdfDevStatePowerWakingConnectInterruptFailed;
}

PowerWakingDmaEnableFailedNP()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerWakingDmaEnableFailedNP ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3797 of file powerstatemachine.cpp.

{
    NTSTATUS status;
 
    COVERAGE_TRAP();
 
    (void) This->PowerDmaPowerDown();
 
    status = This->m_DeviceD0ExitPreInterruptsDisabled.Invoke(
        This->m_Device->GetHandle(),
        WdfPowerDeviceD3Final
        );
 
    if (!NT_SUCCESS(status)) {
        //
        // Report the error, but continue forward
        //
        DoTraceLevelMessage(
            This->GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
            "EvtDeviceD0ExitPreInterruptsDisabled WDFDEVICE 0x%p !devobj 0x%p "
            "new state %!WDF_POWER_DEVICE_STATE! failed, %!STATUS!",
            This->m_Device->GetHandle(),
            This->m_Device->GetDeviceObject(),
            WdfPowerDeviceD3Final, status);
    }
 
    return WdfDevStatePowerWakingConnectInterruptFailedNP;
}

PowerWakingDmaEnableNP()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerWakingDmaEnableNP ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3726 of file powerstatemachine.cpp.

{
    if (This->PowerDmaEnableAndScan(FALSE) == FALSE) {
        return WdfDevStatePowerWakingDmaEnableFailedNP;
    }
 
    //
    // Return the state that we should drop into next.
    //
    return WdfDevStatePowerNull;
}

PowerWakingNP()

WDF_DEVICE_POWER_STATE FxPkgPnp::PowerWakingNP ( __inout FxPkgPnp *  This )

staticprotected

Definition at line 3467 of file powerstatemachine.cpp.

{
    NTSTATUS status;
 
    //
    // m_DevicePowerState is the "old" state because we update it after the
    // D0Entry callback in SelfManagedIoNP or PowerPolicyStopped
    //
    status = This->m_DeviceD0Entry.Invoke(
        This->m_Device->GetHandle(),
        (WDF_POWER_DEVICE_STATE) This->m_DevicePowerState);
 
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(
            This->GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
            "EvtDeviceD0Entry WDFDEVICE 0x%p !devobj 0x%p, old state "
            "%!WDF_POWER_DEVICE_STATE! failed, %!STATUS!",
            This->m_Device->GetHandle(),
            This->m_Device->GetDeviceObject(),
            This->m_DevicePowerState, status);
 
        return WdfDevStatePowerUpFailedDerefParentNP;
    }
 
    return WdfDevStatePowerNotifyingD0EntryToWakeInterruptsNP;
}

ProcessDelayedDeletion()

VOID FxPkgPnp::ProcessDelayedDeletion

(

VOID

)

Definition at line 1293 of file fxpkgpnp.cpp.

{
    DoTraceLevelMessage(
        GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGPNP,
        "WDFDEVICE %p, !devobj %p processing delayed deletion from pnp state "
        "machine", m_Device->GetHandle(), m_Device->GetDeviceObject());
 
    CleanupStateMachines(FALSE);
    DeleteDevice();
}

ProcessRemoveDeviceOverload()

virtual NTSTATUS FxPkgPnp::ProcessRemoveDeviceOverload ( FxIrp *  Irp )

privatepure virtual

QueryForCapabilities()

_Must_inspect_result_ NTSTATUS FxPkgPnp::QueryForCapabilities ( VOID  )

protected

Definition at line 1675 of file fxpkgpnp.cpp.

{
    STACK_DEVICE_CAPABILITIES caps;
    NTSTATUS status;
 
    MxDeviceObject deviceObject;
 
    deviceObject.SetObject(m_Device->GetDeviceObject());
 
    status = GetStackCapabilities(GetDriverGlobals(),
                                  &deviceObject,
                                  &m_D3ColdInterface,
                                  &caps);
 
    if (NT_SUCCESS(status)) {
        ULONG states, i;
 
        ASSERT(caps.DeviceCaps.DeviceWake <= 0xFF && caps.DeviceCaps.SystemWake <= 0xFF);
 
        m_SystemWake = (BYTE) caps.DeviceCaps.SystemWake;
 
        //
        // Initialize the array of wakeable D-states to say that all system
        // states down to the one identified in the caps can generate wake.
        // This will be overridden below if the BIOS supplied more information.
        //
        // Compatibility Note: Non-ACPI bus drivers (root-enumerated drivers)
        // or other bus drivers that haven't set the power settings correctly
        // for their PDO may end up with a valid value for DeviceWake in the
        // device capabilities but a value of PowerSystemUnspecified for
        // SystemWake, in which case a call to WdfDeviceAssignS0IdleSettings or
        // WdfDeviceAssignSxWakeSettings DDIs will fail on 1.11+ resulting in
        // device compat issues. The failure is expected and right thing to do
        // but has compatibility implications - drivers that worked earlier now
        // fail on 1.11. Note that earlier versions of WDF did not have
        // m_DeviceWake as an array and stored just the capabilities->DeviceWake
        // value without regard to the SystemWake but the current implementation
        // introduces dependency on systemWake value). So for compat reasons,
        // for pre-1.11 compiled drivers we initilaize the array with DeviceWake
        // value ignoring SystemWake, removing any dependency of DeviceWake
        // on SystemWake value and thus preserving previous behavior for
        // pre-1.11 compiled drivers.
        //
        if (GetDriverGlobals()->IsVersionGreaterThanOrEqualTo(1,11)) {
 
            RtlFillMemory(m_DeviceWake, DeviceWakeStates, DeviceWakeDepthNotWakeable);
 
            for (i = PowerSystemWorking; i <= m_SystemWake; i++) {
 
                //
                // Note that this cast is hiding a conversion between two slightly
                // incompatible types.  DeviceWake is in terms of DEVICE_POWER_STATE
                // which is defined this way:
                //
                //  typedef enum _DEVICE_POWER_STATE {
                //      PowerDeviceUnspecified = 0,
                //      PowerDeviceD0,
                //      PowerDeviceD1,
                //      PowerDeviceD2,
                //      PowerDeviceD3,
                //      PowerDeviceMaximum
                //  } DEVICE_POWER_STATE, *PDEVICE_POWER_STATE;
                //
                // m_DeviceWake is defined in terms of DEVICE_WAKE_DEPTH which is
                // defined this way:
                //
                //  typedef enum _DEVICE_WAKE_DEPTH {
                //      DeviceWakeDepthNotWakeable    = 0,
                //      DeviceWakeDepthD0,
                //      DeviceWakeDepthD1,
                //      DeviceWakeDepthD2,
                //      DeviceWakeDepthD3hot,
                //      DeviceWakeDepthD3cold,
                //      DeviceWakeDepthMaximum
                //  } DEVICE_WAKE_DEPTH, *PDEVICE_WAKE_DEPTH;
                //
                // The result is that the conversion below will map D3 onto D3hot,
                // which is a safe assumption to start with, one which may be
                // overridden later.
                //
                C_ASSERT(PowerDeviceD0 == static_cast<DEVICE_POWER_STATE>(DeviceWakeDepthD0));
                m_DeviceWake[i - PowerSystemWorking] = (BYTE) caps.DeviceCaps.DeviceWake;
            }
        }
        else {
            //
            // See comments above for information on mapping of device power
            // state to device wake depth.
            //
            RtlFillMemory(m_DeviceWake,
                          DeviceWakeStates,
                          (BYTE) caps.DeviceCaps.DeviceWake);
        }
 
        //
        // Capture the S -> D state mapping table as a ULONG for use in the
        // power policy owner state machine when the machine moves into Sx and
        // the device is not armed for wake and has set an IdealDxStateForSx
        // value
        //
        states = 0x0;
 
        for (i = 0; i < ARRAY_SIZE(caps.DeviceCaps.DeviceState); i++) {
            _SetPowerCapState(i,  caps.DeviceCaps.DeviceState[i], &states);
        }
 
        m_PowerPolicyMachine.m_Owner->m_SystemToDeviceStateMap = states;
 
        //
        // Query for the D3cold support interface.  If present, it will tell
        // us specifically which D-states will work for generating wake signals
        // from specific S-states.
        //
        // Earlier versions of WDF didn't make this query, so for compatibility,
        // we only make it now if the driver was built against WDF 1.11 or
        // later.  In truth, this just shifts the failure from initialization
        // time to run time, because the information that we're presumably
        // getting from the BIOS with this interrogation is saying that the
        // code in earlier verisions of WDF would have blindly enabled a device
        // for wake which simply wasn't capable of generating its wake signal
        // from the chosen D-state.  Thus the device would have been put into
        // a low power state and then failed to resume in response to its wake
        // signal.
        //
 
        if (GetDriverGlobals()->IsVersionGreaterThanOrEqualTo(1,11)) {
 
            //
            // Cycle through all the system states that this device can wake
            // from.  There's no need to look at deeper sleep states than
            // m_SystemWake because the driver will not arm for wake in
            // those states.
            //
            for (i = PowerSystemWorking; i <= m_SystemWake; i++) {
                if (caps.DeepestWakeableDstate[i] != DeviceWakeDepthMaximum) {
                    m_DeviceWake[i - PowerSystemWorking] = (BYTE)caps.DeepestWakeableDstate[i];
                }
            }
        }
    }
 
    return status;
}

Referenced by PowerPolicySetS0IdleSettings(), and PowerPolicySetSxWakeSettings().

QueryForD3ColdInterface()

VOID FxPkgPnp::QueryForD3ColdInterface

(

VOID

)

Definition at line 538 of file fxpkgpnpkm.cpp.

{
    MxDeviceObject deviceObject;
    PDEVICE_OBJECT topOfStack;
    PDEVICE_OBJECT pdo;
    FxAutoIrp irp;
    NTSTATUS status;
 
    //
    // This function can be invoked multiple times, particularly if filters
    // send IRP_MN_QUERY_CAPABILITIES.  So bail out if the interface has already
    // been acquired.
    //
 
    if ((m_D3ColdInterface.InterfaceDereference != NULL) ||
        (m_D3ColdInterface.GetIdleWakeInfo != NULL) ||
        (m_D3ColdInterface.SetD3ColdSupport != NULL)) {
        return;
    }
 
    pdo = m_Device->GetPhysicalDevice();
 
    if (pdo == NULL) {
        return;
    }
 
    //
    // Get the top of stack device object, even though normal filters and the
    // FDO may not have been added to the stack yet to ensure that this
    // query-interface is seen by bus filters.  Specifically, in a PCI device
    // which is soldered to the motherboard, ACPI will be on the stack and it
    // needs to see this IRP.
    //
    topOfStack = IoGetAttachedDeviceReference(pdo);
    deviceObject.SetObject(topOfStack);
    if (deviceObject.GetObject() != NULL) {
        irp.SetIrp(FxIrp::AllocateIrp(deviceObject.GetStackSize()));
        if (irp.GetIrp() == NULL) {
 
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                "Failed to allocate IRP to get D3COLD_SUPPORT_INTERFACE from !devobj %p",
                pdo);
        } else {
 
            //
            // Initialize the Irp
            //
            irp.SetStatus(STATUS_NOT_SUPPORTED);
 
            irp.ClearNextStack();
            irp.SetMajorFunction(IRP_MJ_PNP);
            irp.SetMinorFunction(IRP_MN_QUERY_INTERFACE);
            irp.SetParameterQueryInterfaceType(&GUID_D3COLD_SUPPORT_INTERFACE);
            irp.SetParameterQueryInterfaceVersion(D3COLD_SUPPORT_INTERFACE_VERSION);
            irp.SetParameterQueryInterfaceSize(sizeof(m_D3ColdInterface));
            irp.SetParameterQueryInterfaceInterfaceSpecificData(NULL);
            irp.SetParameterQueryInterfaceInterface((PINTERFACE)&m_D3ColdInterface);
 
            status = irp.SendIrpSynchronously(deviceObject.GetObject());
 
            if (!NT_SUCCESS(status)) {
                DoTraceLevelMessage(
                    GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
                    "!devobj %p declined to supply D3COLD_SUPPORT_INTERFACE",
                    pdo);
 
                RtlZeroMemory(&m_D3ColdInterface, sizeof(m_D3ColdInterface));
            }
        }
    }
    ObDereferenceObject(topOfStack);
}

Referenced by Initialize().

QueryForPowerThread()

virtual NTSTATUS FxPkgPnp::QueryForPowerThread ( VOID  )

privatepure virtual

Implemented in FxPkgFdo, and FxPkgPdo.

Referenced by CreatePowerThreadIfNeeded(), and PnpDeviceUsageNotification().

QueryForReenumerationInterface()

virtual VOID FxPkgPnp::QueryForReenumerationInterface ( VOID  )

privatepure virtual

Implemented in FxPkgFdo, and FxPkgPdo.

QueueToPowerThread()

VOID FxPkgPnp::QueueToPowerThread ( __in PWORK_QUEUE_ITEM  WorkItem )

inline

Definition at line 3516 of file fxpkgpnp.hpp.

    {
        m_PowerThreadInterface.PowerThreadEnqueue(
            m_PowerThreadInterface.Interface.Context,
            WorkItem
            );
    }

Referenced by FxThreadedEventQueue::QueueWorkItem().

ReadRegistryS0Idle()

VOID FxPkgPnp::ReadRegistryS0Idle ( __in PCUNICODE_STRING  ValueName, __out BOOLEAN *  Enabled  )

private

Definition at line 376 of file fxpkgpnpkm.cpp.

{
    NTSTATUS status;
    FxAutoRegKey hKey;
 
    status = m_Device->OpenSettingsKey(&hKey.m_Key, STANDARD_RIGHTS_READ);
 
    //
    // Modify the value of Enabled only if success
    //
    if (NT_SUCCESS(status)) {
        ULONG value;
 
        status = FxRegKey::_QueryULong(
            hKey.m_Key, ValueName, &value);
 
        if (NT_SUCCESS(status)) {
            //
            // Normalize the ULONG value into a BOOLEAN
            //
            *Enabled = (value == FALSE) ? FALSE : TRUE;
        }
    }
}

Referenced by PowerPolicySetS0IdleSettings().

ReadRegistrySxWake()

VOID FxPkgPnp::ReadRegistrySxWake ( __in PCUNICODE_STRING  ValueName, __out BOOLEAN *  Enabled  )

private

Definition at line 469 of file fxpkgpnpkm.cpp.

{
    FxAutoRegKey hKey;
    NTSTATUS status;
 
    status = m_Device->OpenSettingsKey(&hKey.m_Key, STANDARD_RIGHTS_READ);
 
    //
    // Modify the value of Enabled only if success
    //
    if (NT_SUCCESS(status)) {
        ULONG value;
 
        status = FxRegKey::_QueryULong(
            hKey.m_Key, ValueName, &value);
 
        if (NT_SUCCESS(status)) {
            //
            // Normalize the ULONG value into a BOOLEAN
            //
            *Enabled = (value == FALSE) ? FALSE : TRUE;
        }
    }
}

Referenced by PowerPolicySetSxWakeSettings().

ReadStateFromRegistry()

NTSTATUS FxPkgPnp::ReadStateFromRegistry ( _In_ PCUNICODE_STRING  ValueName, _Out_ PULONG  Value  )

private

Definition at line 105 of file fxpkgpnpum.cpp.

{
    DWORD err;
    NTSTATUS status;
    DWORD data;
    DWORD dataSize;
    HKEY pwrPolKey = NULL;
    IWudfDeviceStack* devStack;
 
    ASSERT(NULL != Value);
    ASSERT(ValueName != NULL &&
           ValueName->Length != 0 &&
           ValueName->Buffer != NULL);
 
    *Value = 0;
    devStack = m_Device->GetDeviceStack();
 
    err = RegOpenKeyEx(devStack->GetDeviceRegistryKey(),
                       WUDF_POWER_POLICY_SETTINGS,
                       0,
                       KEY_READ,
                       &pwrPolKey);
    if (ERROR_SUCCESS != err) {
        DoTraceLevelMessage(GetDriverGlobals(),
                            TRACE_LEVEL_ERROR,
                            TRACINGPNP,
                            "RegOpenKeyEx returned error %d",
                            err);
        goto Clean;
    }
 
    dataSize = sizeof(data);
    err = RegQueryValueEx(pwrPolKey,
                          ValueName->Buffer,
                          NULL,
                          NULL,
                          (BYTE*) &data,
                          &dataSize);
    if (ERROR_SUCCESS != err) {
        DoTraceLevelMessage(GetDriverGlobals(),
                            TRACE_LEVEL_ERROR,
                            TRACINGPNP,
                            "failed to read registry, "
                            "RegQueryValueEx returned error %d",
                            err);
        goto Clean;
    }
 
    *Value = data;
    err = ERROR_SUCCESS;
 
Clean:
    if (NULL != pwrPolKey) {
        RegCloseKey(pwrPolKey);
    }
 
    if (ERROR_SUCCESS == err) {
        status = STATUS_SUCCESS;
    }
    else {
        PUMDF_VERSION_DATA driverVersion = devStack->GetMinDriverVersion();
        BOOL preserveCompat =
             devStack->ShouldPreserveIrpCompletionStatusCompatibility();
 
        status = CHostFxUtil::NtStatusFromHr(HRESULT_FROM_WIN32(err),
                                             driverVersion->MajorNumber,
                                             driverVersion->MinorNumber,
                                             preserveCompat);
    }
 
    return status;
}

RegisterCallbacks()

_Must_inspect_result_ NTSTATUS FxPkgPnp::RegisterCallbacks

(

__in PWDF_PNPPOWER_EVENT_CALLBACKS

DispatchTable

)

Definition at line 2667 of file fxpkgpnp.cpp.

{
    NTSTATUS status;
 
    //
    // Update the callback table.
    //
    m_DeviceD0Entry.m_Method           = DispatchTable->EvtDeviceD0Entry;
    m_DeviceD0EntryPostInterruptsEnabled.m_Method =
                                         DispatchTable->EvtDeviceD0EntryPostInterruptsEnabled;
    m_DeviceD0ExitPreInterruptsDisabled.m_Method =
                                         DispatchTable->EvtDeviceD0ExitPreInterruptsDisabled;
    m_DeviceD0Exit.m_Method            = DispatchTable->EvtDeviceD0Exit;
 
    m_DevicePrepareHardware.m_Method   = DispatchTable->EvtDevicePrepareHardware;
    m_DeviceReleaseHardware.m_Method   = DispatchTable->EvtDeviceReleaseHardware;
 
    m_DeviceQueryStop.m_Method         = DispatchTable->EvtDeviceQueryStop;
    m_DeviceQueryRemove.m_Method       = DispatchTable->EvtDeviceQueryRemove;
 
    m_DeviceSurpriseRemoval.m_Method   = DispatchTable->EvtDeviceSurpriseRemoval;
 
    m_DeviceUsageNotification.m_Method = DispatchTable->EvtDeviceUsageNotification;
    m_DeviceUsageNotificationEx.m_Method = DispatchTable->EvtDeviceUsageNotificationEx;
    m_DeviceRelationsQuery.m_Method    = DispatchTable->EvtDeviceRelationsQuery;
 
    if (DispatchTable->EvtDeviceSelfManagedIoCleanup != NULL ||
        DispatchTable->EvtDeviceSelfManagedIoFlush != NULL ||
        DispatchTable->EvtDeviceSelfManagedIoInit != NULL ||
        DispatchTable->EvtDeviceSelfManagedIoSuspend != NULL ||
        DispatchTable->EvtDeviceSelfManagedIoRestart != NULL) {
 
        status = FxSelfManagedIoMachine::_CreateAndInit(&m_SelfManagedIoMachine,
                                                        this);
 
        if (!NT_SUCCESS(status)) {
            return status;
        }
 
        m_SelfManagedIoMachine->InitializeMachine(DispatchTable);
    }
 
    return STATUS_SUCCESS;
}

Referenced by Initialize().

RegisterPowerPolicyCallbacks()

VOID FxPkgPnp::RegisterPowerPolicyCallbacks

(

__in PWDF_POWER_POLICY_EVENT_CALLBACKS

Callbacks

)

Definition at line 2715 of file fxpkgpnp.cpp.

{
    m_PowerPolicyMachine.m_Owner->m_DeviceArmWakeFromS0.m_Method =
        Callbacks->EvtDeviceArmWakeFromS0;
    m_PowerPolicyMachine.m_Owner->m_DeviceArmWakeFromSx.m_Method =
        Callbacks->EvtDeviceArmWakeFromSx;
    m_PowerPolicyMachine.m_Owner->m_DeviceArmWakeFromSx.m_MethodWithReason =
        Callbacks->EvtDeviceArmWakeFromSxWithReason;
 
    m_PowerPolicyMachine.m_Owner->m_DeviceDisarmWakeFromS0.m_Method =
        Callbacks->EvtDeviceDisarmWakeFromS0;
    m_PowerPolicyMachine.m_Owner->m_DeviceDisarmWakeFromSx.m_Method =
        Callbacks->EvtDeviceDisarmWakeFromSx;
 
    m_PowerPolicyMachine.m_Owner->m_DeviceWakeFromS0Triggered.m_Method =
        Callbacks->EvtDeviceWakeFromS0Triggered;
    m_PowerPolicyMachine.m_Owner->m_DeviceWakeFromSxTriggered.m_Method =
        Callbacks->EvtDeviceWakeFromSxTriggered;
}

Referenced by Initialize().

RegisterPowerPolicyWmiInstance()

NTSTATUS FxPkgPnp::RegisterPowerPolicyWmiInstance	(	__in const GUID *	Guid,
		__in FxWmiInstanceInternalCallbacks *	Callbacks,
		__out FxWmiInstanceInternal **	Instance
	)

Definition at line 2738 of file fxpkgpnp.cpp.

{
    // WDF_WMI_PROVIDER_CONFIG config;
    // NTSTATUS status;
 
    // WDF_WMI_PROVIDER_CONFIG_INIT(&config, Guid);
 
    // //
    // // We are assuming we are registering either for the wait wake or device
    // // timeout GUIDs which both operate on BOOLEANs.  If we expand this API in
    // // the future, have the caller pass in a config structure for the provider
    // // GUID.
    // //
    // config.MinInstanceBufferSize = sizeof(BOOLEAN);
 
    // status = m_Device->m_PkgWmi->AddPowerPolicyProviderAndInstance(
    //     &config,
    //     Callbacks,
    //     Instance);
 
    // if (status == STATUS_OBJECT_NAME_COLLISION) {
    //     status = STATUS_SUCCESS;
    // }
 
    // if (!NT_SUCCESS(status)) {
    //     DoTraceLevelMessage(
    //         GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
    //         "Failed to register WMI power GUID %!STATUS!", status);
    // }
    //
    // return status;
    ROSWDFNOTIMPLEMENTED;
    return STATUS_SUCCESS;
}

ReleasePowerThread()

VOID FxPkgPnp::ReleasePowerThread ( VOID  )

private

Definition at line 5180 of file fxpkgpnp.cpp.

{
    BOOLEAN hadThread;
 
    hadThread = m_HasPowerThread;
 
    //
    // Set to FALSE before cleaning up the reference or thread itself in case
    // there is some other context trying to enqueue.  The only way that could
    // be happening is if the power policy owner is not WDF and sends power irps
    // after query remove or surprise remove.
    //
    m_HasPowerThread = FALSE;
 
    //
    // Check for ownership
    //
    if (m_PowerThread != NULL) {
 
        FxCREvent event;
 
        //
        // Event on stack is used, which is fine since this code is invoked
        // only in KM. Verify this assumption.
        //
        // If this code is ever needed for UM, m_PowerThreadEvent should be
        // pre-initialized (simlar to the way m_RemoveEventUm is used)
        //
        WDF_VERIFY_KM_ONLY_CODE();
 
        ASSERT(m_PowerThreadEvent == NULL);
        m_PowerThreadEvent = event.GetSelfPointer();
 
        if (InterlockedDecrement(&m_PowerThreadInterfaceReferenceCount) > 0) {
            //
            // Wait for all references to go away before exitting the thread.
            // A reference will be taken for every device in the stack above this
            // one which queried for the interface.
            //
            event.EnterCRAndWaitAndLeave();
        }
 
        m_PowerThreadEvent = NULL;
 
        //
        // Wait for the thread to exit and then delete it.  Since we have
        // turned off the power policy state machine, we can safely do this here.
        // Any upper level clients will have also turned off their power policy
        // state machines.
        //
        m_PowerThread->ExitThread();
        m_PowerThread->DeleteObject();
 
        m_PowerThread = NULL;
    }
    else if (hadThread) {
        //
        // Release our reference
        //
        m_PowerThreadInterface.Interface.InterfaceDereference(
            m_PowerThreadInterface.Interface.Context
            );
    }
}

Referenced by CleanupStateMachines().

ReleaseReenumerationInterface()

virtual VOID FxPkgPnp::ReleaseReenumerationInterface ( VOID  )

privatepure virtual

Implemented in FxPkgFdo, and FxPkgPdo.

Referenced by CleanupStateMachines().

RemoveChildList()

VOID FxPkgPnp::RemoveChildList

(

__in FxChildList *

List

)

Definition at line 4983 of file fxpkgpnp.cpp.

{
    DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
                        "Removing FxChildList %p, WDFCHILDLIST %p", List,
                        List->GetHandle());
 
    m_EnumInfo->m_ChildListList.Remove(GetDriverGlobals(), &List->m_TransactionLink);
 
    //
 
    //
}

Referenced by FxDevice::RemoveChildList().

RemoveDmaEnabler()

VOID FxPkgPnp::RemoveDmaEnabler

(

__in FxDmaEnabler *

Enabler

)

Definition at line 289 of file fxpkgpnpkm.cpp.

{
    DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
                        "Removing DmaEnabler %p, WDFDMAENABLER %p",
                        Enabler, Enabler->GetObjectHandle());
 
    m_DmaEnablerList->Remove(GetDriverGlobals(), &Enabler->m_TransactionLink);
}

Referenced by FxDevice::RemoveDmaEnabler().

RemoveInterruptObject()

VOID FxPkgPnp::RemoveInterruptObject ( __in FxInterrupt *  Interrupt )

protected

Definition at line 5965 of file fxpkgpnp.cpp.

{
    m_InterruptObjectCount--;
    RemoveEntryList(&Interrupt->m_PnpList);
}

Referenced by FxInterrupt::DeleteObject().

RemoveRemovalDevice()

VOID FxPkgPnp::RemoveRemovalDevice

(

__in MdDeviceObject

DependentDevice

)

Definition at line 4816 of file fxpkgpnp.cpp.

{
    if (m_RemovalDeviceList != NULL) {
        m_RemovalDeviceList->Remove(GetDriverGlobals(), DependentDevice);
    }
 
    //
    // RemovalRelations are queried automatically by PnP when the device is
    // going to be query removed.  No need to tell pnp that the list changed
    // until it needs to query for it.
    //
}

RemoveUsageDevice()

VOID FxPkgPnp::RemoveUsageDevice

(

__in MdDeviceObject

DependentDevice

)

Definition at line 4742 of file fxpkgpnp.cpp.

{
    if (m_UsageDependentDeviceList != NULL) {
        m_UsageDependentDeviceList->Remove(GetDriverGlobals(), DependentDevice);
    }
}

RevertUsageNotificationFlags()

VOID FxPkgPnp::RevertUsageNotificationFlags ( __in DEVICE_USAGE_NOTIFICATION_TYPE  Type, __in BOOLEAN  InPath, __in ULONG  OldFlags  )

protected

Definition at line 4578 of file fxpkgpnp.cpp.

{
    //
    // Re-adjust our "special file count".
    //
    InPath = !InPath;
    AdjustUsageCount(Type, InPath);
 
    //
    // Restore the flags on the device object.
    //
    m_Device->SetDeviceObjectFlags(OldFlags);
}

Referenced by PnpDeviceUsageNotification().

RevokeDmaEnablerResources()

VOID FxPkgPnp::RevokeDmaEnablerResources

(

__in FxDmaEnabler *

Enabler

)

Definition at line 529 of file fxpkgpnpkm.cpp.

{
    // DmaEnabler->RevokeResources();
    ROSWDFNOTIMPLEMENTED;
}

Referenced by NotifyResourceobjectsToReleaseResources().

SaveState()

VOID FxPkgPnp::SaveState ( __in BOOLEAN  UseCanSaveState )

protected

Definition at line 5831 of file fxpkgpnp.cpp.

{
    UNICODE_STRING name;
    FxAutoRegKey hKey;
    NTSTATUS status;
    ULONG value;
 
    //
    // We only have settings to save if we are the power policy owner
    //
    if (IsPowerPolicyOwner() == FALSE) {
        return;
    }
 
    if (UseCanSaveState &&
        m_PowerPolicyMachine.m_Owner->m_CanSaveState == FALSE) {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
            "Not saving wake settings for WDFDEVICE %p due to system power "
            "transition", m_Device->GetHandle());
        return;
    }
 
    //
    // Check to see if there is anything to write out
    //
    if (m_PowerPolicyMachine.m_Owner->m_IdleSettings.Dirty == FALSE &&
        m_PowerPolicyMachine.m_Owner->m_WakeSettings.Dirty == FALSE) {
        return;
    }
 
    //
    // No need to write out if user control is not enabled
    //
    if (m_PowerPolicyMachine.m_Owner->m_IdleSettings.Overridable == FALSE &&
        m_PowerPolicyMachine.m_Owner->m_WakeSettings.Overridable == FALSE) {
        return;
    }
 
    //
    // If the device is in paging path we should not be touching registry during
    // power up because it may incur page fault which won't be satisfied if the
    // device is still not powered up, blocking power Irp. User control state
    // change will not get written if any at this time but will be flushed out
    // to registry during device disable/remove in the remove path.
    //
    if (IsUsageSupported(DeviceUsageTypePaging) && IsDevicePowerUpIrpPending()) {
        return;
    }
 
#if ((FX_CORE_MODE)==(FX_CORE_KERNEL_MODE))
 
    status = m_Device->OpenSettingsKey(&hKey.m_Key, STANDARD_RIGHTS_WRITE);
    if (!NT_SUCCESS(status)) {
        return;
    }
#else
    status = STATUS_SUCCESS;
#endif
 
    if (m_PowerPolicyMachine.m_Owner->m_IdleSettings.Overridable &&
        m_PowerPolicyMachine.m_Owner->m_IdleSettings.Dirty) {
        RtlInitUnicodeString(&name, WDF_S0_IDLE_ENABLED_VALUE_NAME);
        value = m_PowerPolicyMachine.m_Owner->m_IdleSettings.Enabled;
 
        WriteStateToRegistry(hKey.m_Key, &name, value);
 
        m_PowerPolicyMachine.m_Owner->m_IdleSettings.Dirty = FALSE;
    }
 
    if (m_PowerPolicyMachine.m_Owner->m_WakeSettings.Overridable &&
        m_PowerPolicyMachine.m_Owner->m_WakeSettings.Dirty)  {
        RtlInitUnicodeString(&name, WDF_SX_WAKE_ENABLED_VALUE_NAME);
        value = m_PowerPolicyMachine.m_Owner->m_WakeSettings.Enabled;
 
        WriteStateToRegistry(hKey.m_Key, &name, value);
 
        m_PowerPolicyMachine.m_Owner->m_WakeSettings.Dirty = FALSE;
    }
}

SendEventToAllWakeInterrupts()

VOID FxPkgPnp::SendEventToAllWakeInterrupts

(

__in enum FxWakeInterruptEvents

WakeInterruptEvent

)

Definition at line 6164 of file fxpkgpnp.cpp.

{
    FxInterrupt* pInterrupt;
    PLIST_ENTRY ple;
 
    if (m_WakeInterruptCount == 0) {
        return;
    }
 
    //
    // Initialize the pending count to the wake interrupt count
    // If the event needs an acknowledgement, this variable will
    // be decremented as the interrupt machines ack.
    //
    m_WakeInterruptPendingAckCount = m_WakeInterruptCount;
 
    for (ple = m_InterruptListHead.Flink;
         ple != &m_InterruptListHead;
         ple = ple->Flink) {
 
        pInterrupt = CONTAINING_RECORD(ple, FxInterrupt, m_PnpList);
 
        if (pInterrupt->IsWakeCapable()) {
            pInterrupt->ProcessWakeInterruptEvent(WakeInterruptEvent);
        }
 
    }
}

SendIrpSynchronously()

virtual NTSTATUS FxPkgPnp::SendIrpSynchronously ( FxIrp *  Irp )

protectedpure virtual

Referenced by HandleQueryInterfaceForPowerThread(), and PnpDeviceUsageNotification().

SetChildBusInformation()

VOID FxPkgPnp::SetChildBusInformation ( __in PPNP_BUS_INFORMATION  BusInformation )

inline

Definition at line 3468 of file fxpkgpnp.hpp.

    {
        RtlCopyMemory(&m_BusInformation,
                      BusInformation,
                      sizeof(PNP_BUS_INFORMATION));
    }

SetDeviceFailed()

VOID FxPkgPnp::SetDeviceFailed

(

__in WDF_DEVICE_FAILED_ACTION

FailedAction

)

Definition at line 3775 of file fxpkgpnp.cpp.

{
    NTSTATUS    status;
    MdDeviceObject pdo;
 
#if (FX_CORE_MODE == FX_CORE_USER_MODE)
    if (GetDriverGlobals()->IsVersionGreaterThanOrEqualTo(2, 15) == FALSE &&
        FailedAction == WdfDeviceFailedAttemptRestart) {
 
        FailedAction = WdfDeviceFailedNoRestart;
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_WARNING, TRACINGDEVICE,
            "WdfDeviceFailedAttemptRestart is only available for UMDF 2.15 "
            "and later drivers. Reverting to WdfDeviceFailedNoRestart.");
    }
#endif
 
    m_FailedAction = (BYTE) FailedAction;
 
    //
    // This will cause the PnP manager to tear down this stack, even if
    // the PDO can't be surprise-removed.
    //
    m_Failed = TRUE;
 
    if (FailedAction == WdfDeviceFailedAttemptRestart) {
        //
        // Attempt to get the PDO surprise-removed.
        //
        status = AskParentToRemoveAndReenumerate();
 
        if (NT_SUCCESS(status)) {
            return;
        }
    }
 
#if (FX_CORE_MODE == FX_CORE_KERNEL_MODE)
    //
    // In between creating a PDO WDFDEVICE and it starting, if this DDI is called,
    // we will not have a valid PDO.  Make sure it is valid before we proceed.
    //
    pdo = m_Device->GetSafePhysicalDevice();
 
    if (pdo != NULL) {
        //
        // Now tell the PnP manager to re-query us for our state.
        //
        MxDeviceObject physicalDeviceObject(pdo);
 
        physicalDeviceObject.InvalidateDeviceState(
            m_Device->GetDeviceObject()
            );
    }
#else // USER_MODE
    m_Device->GetMxDeviceObject()->InvalidateDeviceState(
        m_Device->GetDeviceObject());
    UNREFERENCED_PARAMETER(pdo);
#endif
}

SetInternalFailure()

VOID FxPkgPnp::SetInternalFailure ( VOID  )

protected

Definition at line 4856 of file fxpkgpnp.cpp.

{
    m_InternalFailure = TRUE;
 
    MxDeviceObject physicalDeviceObject(
                                m_Device->GetPhysicalDevice()
                                );
    physicalDeviceObject.InvalidateDeviceState(
        m_Device->GetDeviceObject()
        );
}

Referenced by __drv_when(), CreatePowerThreadIfNeeded(), PnpEnableInterfacesAndRegisterWmi(), PowerSendPowerDownFailureEvent(), and PowerSendPowerUpFailureEvent().

SetPendingDevicePowerIrp()

VOID FxPkgPnp::SetPendingDevicePowerIrp ( __inout FxIrp *  Irp )

inlineprotected

Definition at line 3050 of file fxpkgpnp.hpp.

    {
        ASSERT(m_PendingDevicePowerIrp == NULL);
 
        Irp->MarkIrpPending();
        m_PendingDevicePowerIrp = Irp->GetIrp();
 
        if (Irp->GetParameterPowerStateDeviceState() > PowerDeviceD0) {
            //
            // We are powering down, capture the current power action.  We will
            // reset it to PowerActionNone once we have powered up.
            //
            m_SystemPowerAction = (UCHAR) Irp->GetParameterPowerShutdownType();
        }
    }

Referenced by FxPkgPdo::DispatchDeviceSetPower(), and FxPkgFdo::LowerDevicePower().

SetPendingPnpIrp()

VOID FxPkgPnp::SetPendingPnpIrp ( __inout FxIrp *  Irp, __in BOOLEAN  MarkIrpPending = TRUE  )

protected

Definition at line 4883 of file fxpkgpnp.cpp.

{
    if (m_PendingPnPIrp != NULL ) {
        FxIrp pendingIrp(m_PendingPnPIrp);
 
        //
        // A state changing pnp irp is already pended. If we don't bugcheck
        // the pended pnp irp will be overwritten with new pnp irp and the old
        // one may never get completed, which may have drastic implications (
        // unresponsive system, power manager not sending Sx Irp etc.)
        //
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
            "A new state changing pnp irp %!pnpmn! IRP %p arrived while another "
            "pnp irp %!pnpmn! IRP %p is still pending WDFDEVICE %p\n",
            Irp->GetMinorFunction(), Irp->GetIrp(),
            pendingIrp.GetMinorFunction(),pendingIrp.GetIrp(),
            m_Device->GetHandle());
 
        FxVerifierBugCheck(GetDriverGlobals(),  // globals
                           WDF_PNP_FATAL_ERROR, // specific type
                           (ULONG_PTR)m_Device->GetHandle(), //parm 2
                           (ULONG_PTR)Irp->GetIrp());  // parm 3
 
        /* NOTREACHED */
        return;
    }
    if (MarkIrpPending) {
        Irp->MarkIrpPending();
    }
    m_PendingPnPIrp = Irp->GetIrp();
}

Referenced by FxPkgPdo::_PnpEject(), FxPkgFdo::_PnpStartDeviceCompletionRoutine(), and PnpSurpriseRemoval().

SetPendingPnpIrpStatus()

VOID FxPkgPnp::SetPendingPnpIrpStatus ( __in NTSTATUS  Status )

inlineprotected

Definition at line 3018 of file fxpkgpnp.hpp.

    {
        FxIrp irp(m_PendingPnPIrp);
 
        ASSERT(m_PendingPnPIrp != NULL);
        irp.SetStatus(Status);
    }

Referenced by __drv_when(), CreatePowerThreadIfNeeded(), PnpEnableInterfacesAndRegisterWmi(), FxPkgPdo::PnpEventEjectHardwareOverload(), and FxPkgPdo::PnpSendStartDeviceDownTheStackOverload().

SetPendingSystemPowerIrp()

VOID FxPkgPnp::SetPendingSystemPowerIrp ( __inout FxIrp *  Irp )

inlineprotected

Definition at line 3082 of file fxpkgpnp.hpp.

    {
        ASSERT(m_PendingSystemPowerIrp == NULL);
        Irp->MarkIrpPending();
        m_PendingSystemPowerIrp = Irp->GetIrp();
    }

Referenced by FxPkgFdo::DispatchSystemSetPower(), and FxPkgPdo::DispatchSystemSetPower().

SetPnpCaps()

VOID FxPkgPnp::SetPnpCaps

(

__in PWDF_DEVICE_PNP_CAPABILITIES

PnpCapabilities

)

Definition at line 5496 of file fxpkgpnp.cpp.

{
    LONG pnpCaps;
    KIRQL irql;
 
    pnpCaps = 0;
    pnpCaps |= GET_PNP_CAP_BITS_FROM_STRUCT(PnpCapabilities, LockSupported);
    pnpCaps |= GET_PNP_CAP_BITS_FROM_STRUCT(PnpCapabilities, EjectSupported);
    pnpCaps |= GET_PNP_CAP_BITS_FROM_STRUCT(PnpCapabilities, Removable);
    pnpCaps |= GET_PNP_CAP_BITS_FROM_STRUCT(PnpCapabilities, DockDevice);
    pnpCaps |= GET_PNP_CAP_BITS_FROM_STRUCT(PnpCapabilities, UniqueID);
    pnpCaps |= GET_PNP_CAP_BITS_FROM_STRUCT(PnpCapabilities, SilentInstall);
    pnpCaps |= GET_PNP_CAP_BITS_FROM_STRUCT(PnpCapabilities, SurpriseRemovalOK);
    pnpCaps |= GET_PNP_CAP_BITS_FROM_STRUCT(PnpCapabilities, HardwareDisabled);
    pnpCaps |= GET_PNP_CAP_BITS_FROM_STRUCT(PnpCapabilities, NoDisplayInUI);
 
    //
    // Since the caller of IRP_MN_QUERY_CAPABILITIES sets these 2 values to -1,
    // we can reuse the -1 as the default/no override value since the associated
    // PDEVICE_CAPAPBILITIES structure will have been predisposed to these values
    //
    if (PnpCapabilities->Address != (ULONG) -1) {
        m_PnpCapsAddress = PnpCapabilities->Address;
    }
    if (PnpCapabilities->UINumber != (ULONG) -1) {
        m_PnpCapsUINumber = PnpCapabilities->UINumber;
    }
 
    //
    // Use the FxPnpStateMask to keep the state mask while applying the new
    // pnp capabilities.
    //
    Lock(&irql);
    m_PnpStateAndCaps.Value = (m_PnpStateAndCaps.Value & FxPnpStateMask) | pnpCaps;
    Unlock(irql);
}

SetPnpState()

VOID FxPkgPnp::SetPnpState

(

__in PWDF_DEVICE_STATE

State

)

Definition at line 5579 of file fxpkgpnp.cpp.

{
    LONG pnpState;
    KIRQL irql;
 
    pnpState = 0x0;
    pnpState |= GET_PNP_STATE_BITS_FROM_STRUCT(State, Disabled);
    pnpState |= GET_PNP_STATE_BITS_FROM_STRUCT(State, DontDisplayInUI);
    pnpState |= GET_PNP_STATE_BITS_FROM_STRUCT(State, Failed);
    pnpState |= GET_PNP_STATE_BITS_FROM_STRUCT(State, NotDisableable);
    pnpState |= GET_PNP_STATE_BITS_FROM_STRUCT(State, Removed);
    pnpState |= GET_PNP_STATE_BITS_FROM_STRUCT(State, ResourcesChanged);
 
    //
    // Mask off FxPnpCapMask to keep the capabilities part of the bitfield
    // the same while change the pnp state.
    //
    Lock(&irql);
    m_PnpStateAndCaps.Value = (m_PnpStateAndCaps.Value & FxPnpCapMask) | pnpState;
    Unlock(irql);
}

SetPowerCaps()

VOID FxPkgPnp::SetPowerCaps

(

__in PWDF_DEVICE_POWER_CAPABILITIES

PowerCapabilities

)

Definition at line 5683 of file fxpkgpnp.cpp.

{
    ULONG states, i;
    USHORT powerCaps;
 
    states = 0x0;
 
    //
    // Build up the device power state encoding into a temp var so that if we are
    // retrieving the encoding in another thread, we don't get a partial view
    //
    for (i = 0; i < ARRAY_SIZE(PowerCapabilities->DeviceState); i++) {
        _SetPowerCapState(i,  PowerCapabilities->DeviceState[i], &states);
    }
 
    m_PowerCaps.States = states;
 
    //
    // Same idea.  Build up the caps locally first so that when we assign them
    // into the object, it is assigned as a whole.
    //
    powerCaps = 0x0;
    powerCaps |= GET_POWER_CAP_BITS_FROM_STRUCT(PowerCapabilities, DeviceD1);
    powerCaps |= GET_POWER_CAP_BITS_FROM_STRUCT(PowerCapabilities, DeviceD2);
    powerCaps |= GET_POWER_CAP_BITS_FROM_STRUCT(PowerCapabilities, WakeFromD0);
    powerCaps |= GET_POWER_CAP_BITS_FROM_STRUCT(PowerCapabilities, WakeFromD1);
    powerCaps |= GET_POWER_CAP_BITS_FROM_STRUCT(PowerCapabilities, WakeFromD2);
    powerCaps |= GET_POWER_CAP_BITS_FROM_STRUCT(PowerCapabilities, WakeFromD3);
 
    m_PowerCaps.Caps = powerCaps;
 
    if (PowerCapabilities->DeviceWake != PowerDeviceMaximum) {
        m_PowerCaps.DeviceWake = (BYTE) PowerCapabilities->DeviceWake;
    }
    if (PowerCapabilities->SystemWake != PowerSystemMaximum) {
        m_PowerCaps.SystemWake = (BYTE) PowerCapabilities->SystemWake;
    }
 
    m_PowerCaps.D1Latency = PowerCapabilities->D1Latency;
    m_PowerCaps.D2Latency = PowerCapabilities->D2Latency;
    m_PowerCaps.D3Latency = PowerCapabilities->D3Latency;
 
    if (PowerCapabilities->IdealDxStateForSx != PowerDeviceMaximum) {
        //
        // Caller has already validated that IdealDxStateForSx is only set if
        // they device is the power policy owner.
        //
        m_PowerPolicyMachine.m_Owner->m_IdealDxStateForSx = (BYTE)
            PowerCapabilities->IdealDxStateForSx;
    }
}

SetSpecialFileSupport()

VOID FxPkgPnp::SetSpecialFileSupport	(	__in WDF_SPECIAL_FILE_TYPE	FileType,
		__in BOOLEAN	Supported
	)

Definition at line 1307 of file fxpkgpnp.cpp.

{
    switch (FileType) {
    case WdfSpecialFilePaging:
    case WdfSpecialFileHibernation:
    case WdfSpecialFileDump:
    case WdfSpecialFileBoot:
        SetUsageSupport(_SpecialTypeToUsage(FileType), Supported);
        break;
 
    default:
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                            "Invalid special file type %x", FileType);
    }
}

SetUsageNotificationFlags()

ULONG FxPkgPnp::SetUsageNotificationFlags ( __in DEVICE_USAGE_NOTIFICATION_TYPE  Type, __in BOOLEAN  InPath  )

protected

Definition at line 4497 of file fxpkgpnp.cpp.

{
    PFX_DRIVER_GLOBALS FxDriverGlobals = GetDriverGlobals();
    ULONG oldFlags, newFlags;
 
    oldFlags = m_Device->GetDeviceObjectFlags();
 
    //
 
    //
    DoTraceLevelMessage(
        FxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGPNP,
        "Before:  type %d, in path %d, special count %d, flags 0x%x, "
        "device %p (WDFDEVICE %p), is pageable capable %d",
        Type, InPath, GetUsageCount(Type), oldFlags,
        m_Device->GetDeviceObject(), m_Device->GetHandle(),
        m_Device->IsPowerPageableCapable());
 
    //
    // Adjust our "special file count".
    //
    AdjustUsageCount(Type, InPath);
 
    //
    // Boot notification doesn't require updating device flags.
    //
    if (Type == static_cast<DEVICE_USAGE_NOTIFICATION_TYPE>(WdfSpecialFileBoot)) {
        return oldFlags;
    }
 
    if (m_Device->IsFilter()) {
        //
        // Clear the previous flags and reset them to the attached
        // device's flags
        //
        newFlags = oldFlags & ~(DO_POWER_PAGABLE | DO_POWER_INRUSH);
        newFlags |= m_Device->GetAttachedDeviceObjectFlags() &
                (DO_POWER_PAGABLE | DO_POWER_INRUSH);
        m_Device->SetDeviceObjectFlags(newFlags);
    }
    else {
        if (InPath) {
            m_Device->SetDeviceObjectFlags(
                m_Device->GetDeviceObjectFlags() & ~DO_POWER_PAGABLE
                );
        }
        else {
            if (m_Device->IsPowerPageableCapable() && IsInSpecialUse() == FALSE) {
                m_Device->SetDeviceObjectFlags(
                    m_Device->GetDeviceObjectFlags() | DO_POWER_PAGABLE
                    );
            }
        }
    }
 
    return oldFlags;
}

Referenced by PnpDeviceUsageNotification().

SetUsageSupport()

VOID FxPkgPnp::SetUsageSupport ( __in DEVICE_USAGE_NOTIFICATION_TYPE  Usage, __in BOOLEAN  Supported  )

inlineprotected

Definition at line 3138 of file fxpkgpnp.hpp.

    {
        m_SpecialSupport[((ULONG) Usage)-1] = Supported;
    }

Referenced by SetSpecialFileSupport().

ShouldProcessPnpEventOnDifferentThread()

BOOLEAN FxPkgPnp::ShouldProcessPnpEventOnDifferentThread	(	__in KIRQL	CurrentIrql,
		__in BOOLEAN	CallerSpecifiedProcessingOnDifferentThread
	)

Definition at line 88 of file pnpstatemachinekm.cpp.

{
    //
    // For KMDF, we ignore what the caller of PnpProcessEvent specified (which
    // should always be FALSE, BTW) and base our decision on the current IRQL.
    // If we are running at PASSIVE_LEVEL, we process on the same thread else
    // we queue a work item.
    //
    UNREFERENCED_PARAMETER(CallerSpecifiedProcessingOnDifferentThread);
 
    ASSERT(FALSE == CallerSpecifiedProcessingOnDifferentThread);
 
    return (CurrentIrql == PASSIVE_LEVEL) ? FALSE : TRUE;
}

Referenced by PnpProcessEvent().

ShouldProcessPowerPolicyEventOnDifferentThread()

BOOLEAN FxPkgPnp::ShouldProcessPowerPolicyEventOnDifferentThread	(	__in KIRQL	CurrentIrql,
		__in BOOLEAN	CallerSpecifiedProcessingOnDifferentThread
	)

Definition at line 69 of file powerpolicystatemachinekm.cpp.

{
    //
    // For KMDF, we ignore what the caller of PowerPolicyProcessEvent specified
    // (which should always be FALSE, BTW) and base our decision on the current
    // IRQL. If we are running at PASSIVE_LEVEL, we process on the same thread
    // else we queue a work item.
    //
    UNREFERENCED_PARAMETER(CallerSpecifiedProcessingOnDifferentThread);
 
    ASSERT(FALSE == CallerSpecifiedProcessingOnDifferentThread);
 
    return (CurrentIrql == PASSIVE_LEVEL) ? FALSE : TRUE;
}

Referenced by PowerPolicyProcessEvent().

SignalDeviceRemovedEvent()

VOID FxPkgPnp::SignalDeviceRemovedEvent ( VOID  )

inline

Definition at line 3782 of file fxpkgpnp.hpp.

    {
        m_DeviceRemoveProcessed->Set();
    }

SupportsWakeInterrupt()

BOOLEAN FxPkgPnp::SupportsWakeInterrupt ( VOID  )

inline

Definition at line 3620 of file fxpkgpnp.hpp.

    {
        if (m_WakeInterruptCount > 0) {
            return TRUE;
        } else {
            return FALSE;
        }
    }

Referenced by FxPkgFdo::HandleQueryCapabilities().

UpdateWmiInstance()

NTSTATUS FxPkgPnp::UpdateWmiInstance ( _In_ FxWmiInstanceAction  Action, _In_ BOOLEAN  ForS0Idle  )

private

Definition at line 56 of file fxpkgpnpum.cpp.

{
    HRESULT hr;
    NTSTATUS status;
    IWudfDeviceStack* devStack;
    WmiIdleWakeInstanceUpdate updateType;
 
    devStack = m_Device->GetDeviceStack();
 
    ASSERT(Action != InstanceActionInvalid);
 
    if (Action == AddInstance) {
        updateType = ForS0Idle ? AddS0IdleInstance : AddSxWakeInstance;
    } else {
        updateType = ForS0Idle ? RemoveS0IdleInstance : RemoveSxWakeInstance;
    }
 
    hr = devStack->UpdateIdleWakeWmiInstance(updateType);
    if (S_OK == hr) {
        status = STATUS_SUCCESS;
    }
    else {
        PUMDF_VERSION_DATA driverVersion = devStack->GetMinDriverVersion();
        BOOL preserveCompat =
             devStack->ShouldPreserveIrpCompletionStatusCompatibility();
 
        status = CHostFxUtil::NtStatusFromHr(hr,
                                             driverVersion->MajorNumber,
                                             driverVersion->MinorNumber,
                                             preserveCompat);
    }
 
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(GetDriverGlobals(),
                            TRACE_LEVEL_ERROR,
                            TRACINGPNP,
                            "failed to send ioctl to update %s WMI instance "
                            "%!STATUS!",
                            ForS0Idle ? "S0Idle" : "SxWake",
                            status);
    }
 
    return status;
}

Referenced by UpdateWmiInstanceForS0Idle(), and UpdateWmiInstanceForSxWake().

UpdateWmiInstanceForS0Idle()

NTSTATUS FxPkgPnp::UpdateWmiInstanceForS0Idle ( __in FxWmiInstanceAction  Action )

private

Definition at line 243 of file fxpkgpnpum.cpp.

{
    NTSTATUS status;
 
    //
    // Send an IOCTL to redirector
    // to add/remove S0Idle WMI instance.
    //
    status = UpdateWmiInstance(Action, TRUE);
 
    return status;
}

UpdateWmiInstanceForSxWake()

NTSTATUS FxPkgPnp::UpdateWmiInstanceForSxWake ( __in FxWmiInstanceAction  Action )

private

Definition at line 281 of file fxpkgpnpum.cpp.

{
    NTSTATUS status;
 
    //
    // Send an IOCTL to redirector
    // to add/remove SxWake WMI instance.
    //
    status = UpdateWmiInstance(Action, FALSE);
 
    return status;
}

ValidateCmResource()

_Must_inspect_result_ NTSTATUS FxPkgPnp::ValidateCmResource	(	__inout PCM_PARTIAL_RESOURCE_DESCRIPTOR *	CmResourceRaw,
		__inout PCM_PARTIAL_RESOURCE_DESCRIPTOR *	CmResource
	)

Definition at line 4223 of file pnpstatemachine.cpp.

{
    NTSTATUS            status;
    FxCollectionEntry*  cur;
    FxCollectionEntry*  curRaw;
    FxResourceCm*       res;
    FxResourceCm*       resRaw;
    PFX_DRIVER_GLOBALS  fxDriverGlobals;
 
    ASSERT(m_ResourcesRaw != NULL);
    ASSERT(m_Resources != NULL);
 
    res = NULL;
    resRaw = NULL;
 
    fxDriverGlobals = GetDriverGlobals();
 
    //
    // Find the resource in our list.
    //
    for (cur = m_Resources->Start(), curRaw = m_ResourcesRaw->Start();
         cur != m_Resources->End();
         cur = cur->Next(), curRaw = curRaw->Next()) {
 
        res = (FxResourceCm*) cur->m_Object;
        resRaw = (FxResourceCm*) curRaw->m_Object;
 
        if (&res->m_DescriptorClone == *CmResource) {
            break;
        }
    }
 
    //
    // Error out if not found.
    //
    if (cur == m_Resources->End()) {
        status = STATUS_INVALID_PARAMETER;
        DoTraceLevelMessage(
            fxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
            "The translated PCM_PARTIAL_RESOURCE_DESCRIPTOR 0x%p is not valid, "
            "WDFDEVICE 0x%p, %!STATUS!",
            *CmResource, m_Device->GetHandle(), status);
        FxVerifierDbgBreakPoint(fxDriverGlobals);
        goto Done;
    }
 
    //
    // Error out if the associated raw resource is not the same.
    //
    if (&resRaw->m_DescriptorClone != *CmResourceRaw) {
        status = STATUS_INVALID_PARAMETER;
        DoTraceLevelMessage(
            fxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
            "The raw PCM_PARTIAL_RESOURCE_DESCRIPTOR 0x%p is not valid, "
            "WDFDEVICE 0x%p, %!STATUS!",
            *CmResourceRaw, m_Device->GetHandle(), status);
        FxVerifierDbgBreakPoint(fxDriverGlobals);
        goto Done;
    }
 
    //
    // Make sure driver didn't change any of the PnP settings.
    //
    if (sizeof(res->m_Descriptor) !=
            RtlCompareMemory(&res->m_DescriptorClone,
                             &res->m_Descriptor,
                             sizeof(res->m_Descriptor))) {
        status = STATUS_INVALID_PARAMETER;
        DoTraceLevelMessage(
            fxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
            "The translated PCM_PARTIAL_RESOURCE_DESCRIPTOR 0x%p is not valid, "
            "driver cannot change the assigned PnP resources, WDFDEVICE 0x%p, "
            "%!STATUS!",
            *CmResource, m_Device->GetHandle(), status);
        FxVerifierDbgBreakPoint(fxDriverGlobals);
        goto Done;
    }
 
    if (sizeof(resRaw->m_Descriptor) !=
            RtlCompareMemory(&resRaw->m_DescriptorClone,
                             &resRaw->m_Descriptor,
                             sizeof(resRaw->m_Descriptor))) {
        status = STATUS_INVALID_PARAMETER;
        DoTraceLevelMessage(
            fxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
            "The raw PCM_PARTIAL_RESOURCE_DESCRIPTOR 0x%p is not valid, "
            "driver cannot change the assigned PnP resources, WDFDEVICE 0x%p, "
            "%!STATUS!",
            *CmResourceRaw, m_Device->GetHandle(), status);
        FxVerifierDbgBreakPoint(fxDriverGlobals);
        goto Done;
    }
 
    //
    // Return the real descriptor.
    //
    ASSERT(res != NULL && resRaw != NULL);
    *CmResource = &res->m_Descriptor;
    *CmResourceRaw = &resRaw->m_Descriptor;
 
    status = STATUS_SUCCESS;
 
Done:
    return status;
}

Referenced by ValidateInterruptResourceCm().

ValidateInterruptResourceCm()

_Must_inspect_result_ NTSTATUS FxPkgPnp::ValidateInterruptResourceCm	(	__in PCM_PARTIAL_RESOURCE_DESCRIPTOR	CmIntResourceRaw,
		__in PCM_PARTIAL_RESOURCE_DESCRIPTOR	CmIntResource,
		__in PWDF_INTERRUPT_CONFIG	Configuration
	)

Definition at line 4348 of file pnpstatemachine.cpp.

{
    NTSTATUS            status;
    PLIST_ENTRY         le;
    FxInterrupt*        interrupt;
    ULONG               messageCount;
    PFX_DRIVER_GLOBALS  fxDriverGlobals;
    PCM_PARTIAL_RESOURCE_DESCRIPTOR cmIntResourceRaw;
    PCM_PARTIAL_RESOURCE_DESCRIPTOR cmIntResource;
 
    cmIntResourceRaw = CmIntResourceRaw;
    cmIntResource = CmIntResource;
    fxDriverGlobals = GetDriverGlobals();
 
    //
    // Get the real descriptor not the copy.
    //
    status = ValidateCmResource(&cmIntResourceRaw, &cmIntResource);
    if (!NT_SUCCESS(status)) {
        goto Done;
    }
 
    //
    // Make sure this is an interrupt resource.
    //
    if (cmIntResourceRaw->Type != CmResourceTypeInterrupt) {
        status = STATUS_INVALID_PARAMETER;
        DoTraceLevelMessage(
            fxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
            "The raw PCM_PARTIAL_RESOURCE_DESCRIPTOR 0x%p is not an "
            "interrupt resource, WDFDEVICE 0x%p, %!STATUS!",
            CmIntResourceRaw, m_Device->GetHandle(), status);
        FxVerifierDbgBreakPoint(fxDriverGlobals);
        goto Done;
    }
 
    if (cmIntResource->Type != CmResourceTypeInterrupt) {
        status = STATUS_INVALID_PARAMETER;
        DoTraceLevelMessage(
            fxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
            "The translated PCM_PARTIAL_RESOURCE_DESCRIPTOR 0x%p is not an "
            "interrupt resource, WDFDEVICE 0x%p, %!STATUS!",
            CmIntResource, m_Device->GetHandle(), status);
        FxVerifierDbgBreakPoint(fxDriverGlobals);
        goto Done;
    }
 
    //
    // Make sure resource was not claimed by another interrupt.
    // Multi-message MSI 2.2 interrupts: allowed to reuse claimed resources.
    //     Driver must create them sequentially.
    // Line-based interrupts: allowed to reuse claimed resources.
    //     Driver can create them out-of-order.
    // Other MSI: not allowed to reuse claimed resources.
    //
    messageCount = 0;
 
    for (le = m_InterruptListHead.Flink;
         le != &m_InterruptListHead;
         le = le->Flink) {
 
        interrupt = CONTAINING_RECORD(le, FxInterrupt, m_PnpList);
 
        if (cmIntResource != interrupt->GetResources()) {
            //
            // Multi-message MSI 2.2 interrupts must be sequential.
            //
            if (messageCount != 0) {
                status = STATUS_INVALID_PARAMETER;
                DoTraceLevelMessage(
                    fxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
                    "Multi-message MSI 2.2 interrupts must be created "
                    "sequentially, WDFDEVICE 0x%p, %!STATUS!",
                    m_Device->GetHandle(), status);
                FxVerifierDbgBreakPoint(fxDriverGlobals);
                goto Done;
            }
 
            continue;
        }
 
        if (interrupt->IsWakeCapable() &&
            Configuration->PassiveHandling) {
            DoTraceLevelMessage(
                fxDriverGlobals, TRACE_LEVEL_INFORMATION, TRACINGPNP,
                "The PCM_PARTIAL_RESOURCE_DESCRIPTOR 0x%p was already used "
                "to create a wakable interrupt 0x%p, WDFDEVICE 0x%p and "
                "any functional interrupt being shared with wakable interrupt "
                "can not use passive level handling",
                CmIntResource, interrupt->GetHandle(),
                m_Device->GetHandle());
            status = STATUS_INVALID_PARAMETER;
            goto Done;
        }
 
        if (interrupt->IsPassiveHandling() &&
            Configuration->CanWakeDevice) {
            DoTraceLevelMessage(
                fxDriverGlobals, TRACE_LEVEL_INFORMATION, TRACINGPNP,
                "The PCM_PARTIAL_RESOURCE_DESCRIPTOR 0x%p was already used "
                "to create a passive level interrupt 0x%p, WDFDEVICE 0x%p and "
                "is now being used to create a wakable interrupt. A functional "
                "passive level interrupt can not be shared with wakable interrupt",
                CmIntResource, interrupt->GetHandle(),
                m_Device->GetHandle());
            status = STATUS_INVALID_PARAMETER;
            goto Done;
        }
 
        //
        // Check for multi-message MSI 2.2 interrupts. These are allowed
        // to use the same resource.
        // We allow line based interrupts to reuse claimed resources.
        //
        if (FxInterrupt::_IsMessageInterrupt(cmIntResource->Flags) == FALSE) {
            DoTraceLevelMessage(
                fxDriverGlobals, TRACE_LEVEL_INFORMATION, TRACINGPNP,
                "The PCM_PARTIAL_RESOURCE_DESCRIPTOR 0x%p was already used "
                "to create interrupt 0x%p, WDFDEVICE 0x%p",
                CmIntResource, interrupt->GetHandle(),
                m_Device->GetHandle());
            continue;
        }
 
        //
        // Only allow the correct # of messages.
        //
        messageCount++;
        if (messageCount >
            cmIntResourceRaw->u.MessageInterrupt.Raw.MessageCount) {
 
            status = STATUS_INVALID_PARAMETER;
            DoTraceLevelMessage(
                fxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
                "All the MSI 2.2 interrupts for "
                "PCM_PARTIAL_RESOURCE_DESCRIPTOR 0x%p are already created, "
                "WDFDEVICE 0x%p, %!STATUS!",
                CmIntResource, m_Device->GetHandle(), status);
            FxVerifierDbgBreakPoint(fxDriverGlobals);
            goto Done;
        }
    }
 
    status = STATUS_SUCCESS;
 
Done:
    return status;
}

WakeInterruptCreated()

VOID FxPkgPnp::WakeInterruptCreated ( VOID  )

inline

Definition at line 4074 of file fxpkgpnp.hpp.

    {
        ASSERT(IsPowerPolicyOwner() != FALSE);
 
        ++m_WakeInterruptCount;
    }

Referenced by FxInterrupt::CreateWakeInterruptMachine().

WriteStateToRegistry()

VOID FxPkgPnp::WriteStateToRegistry ( __in HANDLE  RegKey, __in PUNICODE_STRING  ValueName, __in ULONG  Value  )

private

Definition at line 301 of file fxpkgpnpkm.cpp.

{
    ZwSetValueKey(RegKey, ValueName, 0, REG_DWORD, &Value, sizeof(Value));
}

Referenced by SaveState().

Member Data Documentation

_PowerPolDevicePowerDownComplete

__drv_sameIRQL VOID FxPkgPnp::_PowerPolDevicePowerDownComplete

staticprotected

Definition at line 2755 of file fxpkgpnp.hpp.

Referenced by PowerPolicySendDevicePowerRequest().

_PowerPolDevicePowerUpComplete

__drv_sameIRQL VOID FxPkgPnp::_PowerPolDevicePowerUpComplete

staticprotected

Definition at line 2759 of file fxpkgpnp.hpp.

Referenced by PowerPolicySendDevicePowerRequest().

_PowerPolDeviceWaitWakeComplete

__drv_sameIRQL VOID FxPkgPnp::_PowerPolDeviceWaitWakeComplete

staticprotected

Definition at line 2751 of file fxpkgpnp.hpp.

Referenced by PowerPolicySendWaitWakeRequest().

_PowerPolicyUsbSelectiveSuspendCompletionRoutine

__drv_sameIRQL NTSTATUS FxPkgPnp::_PowerPolicyUsbSelectiveSuspendCompletionRoutine

staticprotected

Definition at line 2805 of file fxpkgpnp.hpp.

_PowerPolicyWaitWakeCompletionRoutine

__drv_sameIRQL NTSTATUS FxPkgPnp::_PowerPolicyWaitWakeCompletionRoutine

staticprotected

Definition at line 2801 of file fxpkgpnp.hpp.

Referenced by DispatchWaitWake().

_PowerWaitWakeCancelRoutine

VOID FxPkgPnp::_PowerWaitWakeCancelRoutine

staticprotected

Definition at line 2736 of file fxpkgpnp.hpp.

Referenced by DispatchWaitWake().

FxInterrupt

friend FxPkgPnp::FxInterrupt

private

Definition at line 494 of file fxpkgpnp.hpp.

FxPnpMachine

friend FxPkgPnp::FxPnpMachine

private

Definition at line 490 of file fxpkgpnp.hpp.

FxPowerMachine

friend FxPkgPnp::FxPowerMachine

private

Definition at line 491 of file fxpkgpnp.hpp.

FxPowerPolicyMachine

friend FxPkgPnp::FxPowerPolicyMachine

private

Definition at line 492 of file fxpkgpnp.hpp.

FxPowerPolicyOwnerSettings

friend FxPkgPnp::FxPowerPolicyOwnerSettings

private

Definition at line 493 of file fxpkgpnp.hpp.

Referenced by Initialize().

GUID_POWER_THREAD_INTERFACE

const GUID FxPkgPnp::GUID_POWER_THREAD_INTERFACE

staticprotected

Initial value:

= {
    0xdc7a8e51, 0x49b3, 0x4a3a, { 0x9e, 0x81, 0x62, 0x52, 0x05, 0xe7, 0xd7, 0x29 }
}

Definition at line 4282 of file fxpkgpnp.hpp.

Referenced by HandleQueryInterface(), and FxPkgFdo::QueryForPowerThread().

m_AchievedStart

BOOLEAN FxPkgPnp::m_AchievedStart

private

Definition at line 4344 of file fxpkgpnp.hpp.

Referenced by FxPkgPnp(), and PnpIncrementRestartCountLogic().

m_BusEnumRetries

UCHAR FxPkgPnp::m_BusEnumRetries

protected

Definition at line 4237 of file fxpkgpnp.hpp.

Referenced by FxPkgFdo::FxPkgFdo().

m_BusInformation

PNP_BUS_INFORMATION FxPkgPnp::m_BusInformation

protected

Definition at line 4232 of file fxpkgpnp.hpp.

Referenced by FxPkgFdo::FxPkgFdo(), HandleQueryBusInformation(), and SetChildBusInformation().

m_CapsQueried

BOOLEAN FxPkgPnp::m_CapsQueried

protected

Definition at line 4247 of file fxpkgpnp.hpp.

Referenced by FxPkgPnp(), PowerPolicySetS0IdleSettings(), and PowerPolicySetSxWakeSettings().

m_CleanupEventUm

FxCREvent FxPkgPnp::m_CleanupEventUm

private

Definition at line 4304 of file fxpkgpnp.hpp.

Referenced by CleanupStateMachines(), and Initialize().

m_D3ColdInterface

D3COLD_SUPPORT_INTERFACE FxPkgPnp::m_D3ColdInterface

Definition at line 4166 of file fxpkgpnp.hpp.

Referenced by DropD3ColdInterface(), FxPkgPnp(), PowerPolicySetS0IdleSettings(), QueryForCapabilities(), and QueryForD3ColdInterface().

m_DeviceD0Entry

FxPnpDeviceD0Entry FxPkgPnp::m_DeviceD0Entry

Definition at line 4551 of file fxpkgpnp.hpp.

Referenced by RegisterCallbacks().

m_DeviceD0EntryPostInterruptsEnabled

FxPnpDeviceD0EntryPostInterruptsEnabled FxPkgPnp::m_DeviceD0EntryPostInterruptsEnabled

Definition at line 4552 of file fxpkgpnp.hpp.

Referenced by RegisterCallbacks().

m_DeviceD0Exit

FxPnpDeviceD0Exit FxPkgPnp::m_DeviceD0Exit

Definition at line 4554 of file fxpkgpnp.hpp.

Referenced by PowerConnectInterruptFailed(), PowerGotoDxIoStopped(), PowerGotoDxIoStoppedNP(), and RegisterCallbacks().

m_DeviceD0ExitPreInterruptsDisabled

FxPnpDeviceD0ExitPreInterruptsDisabled FxPkgPnp::m_DeviceD0ExitPreInterruptsDisabled

Definition at line 4553 of file fxpkgpnp.hpp.

Referenced by PowerGotoDxIoStopped(), PowerGotoDxIoStoppedNP(), and RegisterCallbacks().

m_DeviceInterfaceHead

SINGLE_LIST_ENTRY FxPkgPnp::m_DeviceInterfaceHead

Definition at line 4126 of file fxpkgpnp.hpp.

Referenced by FxPkgPnp(), if(), FxDevice::IsInterfaceRegistered(), PnpDisableInterfaces(), PnpEnableInterfacesAndRegisterWmi(), FxPkgPdo::PnpQueryResourceRequirements(), and ~FxPkgPnp().

m_DeviceInterfaceLock

FxWaitLockInternal FxPkgPnp::m_DeviceInterfaceLock

Definition at line 4124 of file fxpkgpnp.hpp.

Referenced by Initialize(), FxDevice::IsInterfaceRegistered(), PnpDisableInterfaces(), PnpEnableInterfacesAndRegisterWmi(), and FxPkgPdo::PnpQueryResourceRequirements().

m_DeviceInterfacesCanBeEnabled

BOOLEAN FxPkgPnp::m_DeviceInterfacesCanBeEnabled

Definition at line 4128 of file fxpkgpnp.hpp.

Referenced by FxPkgFdo::FxPkgFdo(), FxPkgPnp(), PnpDisableInterfaces(), and PnpEnableInterfacesAndRegisterWmi().

m_DevicePowerState

BYTE FxPkgPnp::m_DevicePowerState

Definition at line 4105 of file fxpkgpnp.hpp.

Referenced by FxPkgPnp(), and PowerSetDevicePowerState().

m_DevicePowerStateOld

BYTE FxPkgPnp::m_DevicePowerStateOld

Definition at line 4108 of file fxpkgpnp.hpp.

Referenced by FxPkgPnp(), and PowerSetDevicePowerState().

m_DevicePrepareHardware

FxPnpDevicePrepareHardware FxPkgPnp::m_DevicePrepareHardware

Definition at line 4556 of file fxpkgpnp.hpp.

Referenced by __drv_when(), and RegisterCallbacks().

m_DeviceQueryRemove

FxPnpDeviceQueryRemove FxPkgPnp::m_DeviceQueryRemove

Definition at line 4560 of file fxpkgpnp.hpp.

Referenced by RegisterCallbacks().

m_DeviceQueryStop

FxPnpDeviceQueryStop FxPkgPnp::m_DeviceQueryStop

Definition at line 4559 of file fxpkgpnp.hpp.

Referenced by RegisterCallbacks().

m_DeviceRelationsQuery

FxPnpDeviceRelationsQuery FxPkgPnp::m_DeviceRelationsQuery

Definition at line 4549 of file fxpkgpnp.hpp.

Referenced by HandleQueryBusRelations(), HandleQueryDeviceRelations(), and RegisterCallbacks().

m_DeviceReleaseHardware

FxPnpDeviceReleaseHardware FxPkgPnp::m_DeviceReleaseHardware

Definition at line 4557 of file fxpkgpnp.hpp.

Referenced by PnpReleaseHardware(), and RegisterCallbacks().

m_DeviceRemoveProcessed

MxEvent* FxPkgPnp::m_DeviceRemoveProcessed

protected

Definition at line 4172 of file fxpkgpnp.hpp.

Referenced by CleanupDeviceFromFailedCreate(), FxPkgPnp(), FxPkgPdo::ProcessRemoveDeviceOverload(), and SignalDeviceRemovedEvent().

m_DeviceStopCount

ULONG FxPkgPnp::m_DeviceStopCount

Definition at line 4146 of file fxpkgpnp.hpp.

Referenced by FxPkgPnp(), and if().

m_DeviceSurpriseRemoval

FxPnpDeviceSurpriseRemoval FxPkgPnp::m_DeviceSurpriseRemoval

Definition at line 4561 of file fxpkgpnp.hpp.

Referenced by RegisterCallbacks().

m_DeviceUsageNotification

FxPnpDeviceUsageNotification FxPkgPnp::m_DeviceUsageNotification

Definition at line 4547 of file fxpkgpnp.hpp.

Referenced by PnpDeviceUsageNotification(), and RegisterCallbacks().

m_DeviceUsageNotificationEx

FxPnpDeviceUsageNotificationEx FxPkgPnp::m_DeviceUsageNotificationEx

Definition at line 4548 of file fxpkgpnp.hpp.

Referenced by PnpDeviceUsageNotification(), and RegisterCallbacks().

m_DeviceWake

BYTE FxPkgPnp::m_DeviceWake[DeviceWakeStates]

protected

Definition at line 4185 of file fxpkgpnp.hpp.

Referenced by PowerPolicyGetDeviceDeepestDeviceWakeState(), and QueryForCapabilities().

m_DmaEnablerList

FxSpinLockTransactionedList* FxPkgPnp::m_DmaEnablerList

protected

Definition at line 4227 of file fxpkgpnp.hpp.

Referenced by AddDmaEnabler(), AllocateDmaEnablerList(), FxPkgPnp(), NotifyResourceobjectsToReleaseResources(), RemoveDmaEnabler(), and ~FxPkgPnp().

m_DxArmedForWakeNPOtherStates

const POWER_EVENT_TARGET_STATE FxPkgPnp::m_DxArmedForWakeNPOtherStates

staticprivate

Initial value:

=
{
    { PowerWakeSucceeded,           WdfDevStatePowerWakePendingNP DEBUGGED_EVENT },
    { PowerWakeFailed,              WdfDevStatePowerWakePendingNP DEBUGGED_EVENT },
    { PowerWakeCanceled,            WdfDevStatePowerWakePendingNP DEBUGGED_EVENT },
    { PowerImplicitD3,              WdfDevStatePowerDxStoppedDisarmWakeNP TRAP_ON_EVENT },
    { PowerEventMaximum,            WdfDevStatePowerNull },
}

Definition at line 4417 of file fxpkgpnp.hpp.

m_DxArmedForWakeOtherStates

const POWER_EVENT_TARGET_STATE FxPkgPnp::m_DxArmedForWakeOtherStates

staticprivate

Initial value:

=
{
    { PowerWakeSucceeded,           WdfDevStatePowerWakePending DEBUGGED_EVENT },
    { PowerWakeCanceled,            WdfDevStatePowerWakePending DEBUGGED_EVENT },
    { PowerWakeFailed,              WdfDevStatePowerWakePending DEBUGGED_EVENT },
    { PowerImplicitD3,              WdfDevStatePowerDxStoppedDisarmWake TRAP_ON_EVENT },
    { PowerEventMaximum,            WdfDevStatePowerNull },
}

Definition at line 4416 of file fxpkgpnp.hpp.

m_DxSurpriseRemovedOtherStates

const POWER_EVENT_TARGET_STATE FxPkgPnp::m_DxSurpriseRemovedOtherStates[]

staticprivate

Definition at line 4420 of file fxpkgpnp.hpp.

m_EnumInfo

FxEnumerationInfo* FxPkgPnp::m_EnumInfo

protected

Definition at line 4215 of file fxpkgpnp.hpp.

Referenced by AddChildList(), AllocateEnumInfo(), ChildListNotifyRemove(), FxPkgFdo::CreateDefaultDeviceList(), FxPkgPnp(), HandleQueryBusRelations(), PnpEventSurpriseRemovePendingOverload(), PowerDmaEnableAndScan(), PowerPolicyBlockChildrenPowerUp(), PowerPolicyCanChildPowerUp(), PowerPolicyCanIdlePowerDown(), PowerPolicyChildPoweredDown(), PowerPolicyChildrenCanPowerUp(), PowerPolicyDisarmWakeFromSx(), PowerPolicyPostParentToD0ToChildren(), RemoveChildList(), and ~FxPkgPnp().

m_Failed

BOOLEAN FxPkgPnp::m_Failed

Definition at line 4095 of file fxpkgpnp.hpp.

Referenced by FxPkgPnp(), HandleQueryPnpDeviceState(), and SetDeviceFailed().

m_FailedAction

BYTE FxPkgPnp::m_FailedAction

protected

Definition at line 4191 of file fxpkgpnp.hpp.

Referenced by FxPkgPnp(), and SetDeviceFailed().

m_HasPowerThread

BOOLEAN FxPkgPnp::m_HasPowerThread

protected

Definition at line 4256 of file fxpkgpnp.hpp.

Referenced by CreatePowerThread(), FxPkgPnp(), HasPowerThread(), FxPkgFdo::QueryForPowerThread(), and ReleasePowerThread().

m_InternalFailure

BOOLEAN FxPkgPnp::m_InternalFailure

protected

Definition at line 4249 of file fxpkgpnp.hpp.

Referenced by FxPkgPnp(), HandleQueryPnpDeviceState(), and SetInternalFailure().

m_InterruptListHead

LIST_ENTRY FxPkgPnp::m_InterruptListHead

private

Definition at line 4310 of file fxpkgpnp.hpp.

Referenced by AddInterruptObject(), Dispose(), FilterResourceRequirements(), FxPkgPnp(), NotifyResourceObjectsD0(), NotifyResourceObjectsDx(), NotifyResourceobjectsToReleaseResources(), PnpAssignInterruptsSyncIrql(), PnpMatchResources(), PnpReleaseHardware(), SendEventToAllWakeInterrupts(), ValidateInterruptResourceCm(), and ~FxPkgPnp().

m_InterruptObjectCount

ULONG FxPkgPnp::m_InterruptObjectCount

private

Definition at line 4308 of file fxpkgpnp.hpp.

Referenced by AddInterruptObject(), FxPkgPnp(), GetInterruptObjectCount(), HasMultipleInterrupts(), FxInterrupt::Initialize(), and RemoveInterruptObject().

m_IoConnectInterruptEx

PFN_IO_CONNECT_INTERRUPT_EX FxPkgPnp::m_IoConnectInterruptEx

protected

Definition at line 4288 of file fxpkgpnp.hpp.

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

m_IoDisconnectInterruptEx

PFN_IO_DISCONNECT_INTERRUPT_EX FxPkgPnp::m_IoDisconnectInterruptEx

protected

Definition at line 4289 of file fxpkgpnp.hpp.

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

m_IoReportInterruptActive

PFN_IO_REPORT_INTERRUPT_ACTIVE FxPkgPnp::m_IoReportInterruptActive

protected

Definition at line 4293 of file fxpkgpnp.hpp.

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

m_IoReportInterruptInactive

PFN_IO_REPORT_INTERRUPT_INACTIVE FxPkgPnp::m_IoReportInterruptInactive

protected

Definition at line 4294 of file fxpkgpnp.hpp.

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

m_NotPowerPolOwnerDxStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_NotPowerPolOwnerDxStates

staticprivate

Initial value:

=
{
    { PwrPolPowerUpHwStarted, WdfDevStatePwrPolGotoD0 DEBUGGED_EVENT },
    { PwrPolStop, WdfDevStatePwrPolStopping DEBUGGED_EVENT },
    { PwrPolSurpriseRemove, WdfDevStatePwrPolStopping DEBUGGED_EVENT },
    { PwrPolPowerDownIoStopped, WdfDevStatePwrPolGotoDxInDx TRAP_ON_EVENT },
}

Definition at line 4499 of file fxpkgpnp.hpp.

m_NotPowerPolOwnerGotoD0InD0States

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_NotPowerPolOwnerGotoD0InD0States

staticprivate

Initial value:

=
{
    { PwrPolPowerUp, WdfDevStatePwrPolStartingSucceeded TRAP_ON_EVENT },
    { PwrPolPowerUpFailed, WdfDevStatePwrPolStartingSucceeded TRAP_ON_EVENT },
}

Definition at line 4501 of file fxpkgpnp.hpp.

m_NotPowerPolOwnerGotoD0States

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_NotPowerPolOwnerGotoD0States

staticprivate

Initial value:

=
{
    { PwrPolPowerUp, WdfDevStatePwrPolStartingSucceeded DEBUGGED_EVENT },
    { PwrPolPowerUpFailed, WdfDevStatePwrPolStartingSucceeded TRAP_ON_EVENT },
}

Definition at line 4500 of file fxpkgpnp.hpp.

m_NotPowerPolOwnerGotoDxInDxStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_NotPowerPolOwnerGotoDxInDxStates

staticprivate

Initial value:

=
{
    { PwrPolPowerDown, WdfDevStatePwrPolDx TRAP_ON_EVENT },
    { PwrPolPowerDownFailed, WdfDevStatePwrPolDx TRAP_ON_EVENT },
}

Definition at line 4498 of file fxpkgpnp.hpp.

m_NotPowerPolOwnerGotoDxStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_NotPowerPolOwnerGotoDxStates

staticprivate

Initial value:

=
{
    { PwrPolPowerDown, WdfDevStatePwrPolDx DEBUGGED_EVENT },
    { PwrPolPowerDownFailed, WdfDevStatePwrPolStartingSucceeded DEBUGGED_EVENT },
}

Definition at line 4497 of file fxpkgpnp.hpp.

m_NotPowerPolOwnerObjectCreatedStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_NotPowerPolOwnerObjectCreatedStates

staticprivate

Initial value:

=
{
    { PwrPolStart, WdfDevStatePwrPolStarting DEBUGGED_EVENT },
    { PwrPolRemove, WdfDevStatePwrPolRemoved DEBUGGED_EVENT },
}

Definition at line 4493 of file fxpkgpnp.hpp.

m_NotPowerPolOwnerRemovedStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_NotPowerPolOwnerRemovedStates

staticprivate

Initial value:

=
{
    { PwrPolStart, WdfDevStatePwrPolStarting DEBUGGED_EVENT },
    { PwrPolRemove, WdfDevStatePwrPolRemoved DEBUGGED_EVENT },
}

Definition at line 4506 of file fxpkgpnp.hpp.

m_NotPowerPolOwnerStartingFailedStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_NotPowerPolOwnerStartingFailedStates

staticprivate

Initial value:

=
{
    { PwrPolRemove, WdfDevStatePwrPolRemoved DEBUGGED_EVENT },
}

Definition at line 4496 of file fxpkgpnp.hpp.

m_NotPowerPolOwnerStartingStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_NotPowerPolOwnerStartingStates

staticprivate

Initial value:

=
{
    { PwrPolPowerUp, WdfDevStatePwrPolStarted DEBUGGED_EVENT },
    { PwrPolPowerUpFailed, WdfDevStatePwrPolStartingFailed DEBUGGED_EVENT },
}

Definition at line 4494 of file fxpkgpnp.hpp.

m_NotPowerPolOwnerStartingSucceededStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_NotPowerPolOwnerStartingSucceededStates

staticprivate

Initial value:

=
{
    { PwrPolPowerDownIoStopped, WdfDevStatePwrPolGotoDx DEBUGGED_EVENT },
    { PwrPolStop, WdfDevStatePwrPolStopping DEBUGGED_EVENT },
    { PwrPolSurpriseRemove, WdfDevStatePwrPolStopping DEBUGGED_EVENT },
    { PwrPolPowerUpHwStarted, WdfDevStatePwrPolGotoD0InD0 TRAP_ON_EVENT },
}

Definition at line 4495 of file fxpkgpnp.hpp.

m_NotPowerPolOwnerStoppedStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_NotPowerPolOwnerStoppedStates

staticprivate

Initial value:

=
{
    { PwrPolStart, WdfDevStatePwrPolStarting DEBUGGED_EVENT },
    { PwrPolRemove, WdfDevStatePwrPolRemoved DEBUGGED_EVENT },
}

Definition at line 4502 of file fxpkgpnp.hpp.

m_NotPowerPolOwnerStoppingPoweringDownStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_NotPowerPolOwnerStoppingPoweringDownStates

staticprivate

Initial value:

=
{
    { PwrPolPowerDown, WdfDevStatePwrPolStoppingWaitingForImplicitPowerDown DEBUGGED_EVENT },
    { PwrPolPowerDownFailed, WdfDevStatePwrPolStoppingWaitingForImplicitPowerDown DEBUGGED_EVENT },
}

Definition at line 4505 of file fxpkgpnp.hpp.

m_NotPowerPolOwnerStoppingPoweringUpStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_NotPowerPolOwnerStoppingPoweringUpStates

staticprivate

Initial value:

=
{
    { PwrPolPowerUp, WdfDevStatePwrPolStoppingWaitingForImplicitPowerDown DEBUGGED_EVENT },
    { PwrPolPowerUpFailed, WdfDevStatePwrPolStoppingWaitingForImplicitPowerDown TRAP_ON_EVENT },
}

Definition at line 4504 of file fxpkgpnp.hpp.

m_NotPowerPolOwnerStoppingWaitForImplicitPowerDownStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_NotPowerPolOwnerStoppingWaitForImplicitPowerDownStates

staticprivate

Initial value:

=
{
    { PwrPolImplicitPowerDown, WdfDevStatePwrPolStoppingSendStatus DEBUGGED_EVENT },
    { PwrPolImplicitPowerDownFailed, WdfDevStatePwrPolStoppingFailed DEBUGGED_EVENT },
    { PwrPolPowerDownIoStopped, WdfDevStatePwrPolStoppingPoweringDown DEBUGGED_EVENT },
    { PwrPolPowerUpHwStarted, WdfDevStatePwrPolStoppingPoweringUp DEBUGGED_EVENT },
}

Definition at line 4503 of file fxpkgpnp.hpp.

m_PendingChildCount

LONG FxPkgPnp::m_PendingChildCount

protected

Definition at line 4178 of file fxpkgpnp.hpp.

Referenced by ChildRemoved(), FinishInitialize(), FxPkgPnp(), and ~FxPkgPnp().

m_PendingDevicePowerIrp

MdIrp FxPkgPnp::m_PendingDevicePowerIrp

private

Definition at line 4372 of file fxpkgpnp.hpp.

Referenced by ClearPendingDevicePowerIrp(), FxPkgPnp(), IsDevicePowerUpIrpPending(), PowerGotoDxIoStopped(), PowerGotoDxIoStoppedNP(), and SetPendingDevicePowerIrp().

m_PendingPnPIrp

MdIrp FxPkgPnp::m_PendingPnPIrp

private

Definition at line 4360 of file fxpkgpnp.hpp.

Referenced by ClearPendingPnpIrp(), FxPkgPnp(), GetPendingPnpIrp(), IsPresentPendingPnpIrp(), PnpMatchResources(), SetPendingPnpIrp(), and SetPendingPnpIrpStatus().

m_PendingSystemPowerIrp

MdIrp FxPkgPnp::m_PendingSystemPowerIrp

private

Definition at line 4366 of file fxpkgpnp.hpp.

Referenced by ClearPendingSystemPowerIrp(), FxPkgPnp(), GetPendingSystemPowerIrp(), PowerPolicyCompleteSystemPowerIrp(), PowerPolicyGetPendingSystemState(), and SetPendingSystemPowerIrp().

m_PnpCapsAddress

ULONG FxPkgPnp::m_PnpCapsAddress

Definition at line 4090 of file fxpkgpnp.hpp.

Referenced by FxPkgPnp(), FxPkgPdo::HandleQueryCapabilities(), FxPkgFdo::HandleQueryCapabilitiesCompletion(), and SetPnpCaps().

m_PnpCapsUINumber

ULONG FxPkgPnp::m_PnpCapsUINumber

Definition at line 4091 of file fxpkgpnp.hpp.

Referenced by FxPkgPnp(), FxPkgPdo::HandleQueryCapabilities(), FxPkgFdo::HandleQueryCapabilitiesCompletion(), and SetPnpCaps().

m_PnpEjectFailedOtherStates

const PNP_EVENT_TARGET_STATE FxPkgPnp::m_PnpEjectFailedOtherStates

staticprivate

Initial value:

=
{
    { PnpEventSurpriseRemove, WdfDevStatePnpSurpriseRemove TRAP_ON_EVENT },
    { PnpEventNull, WdfDevStatePnpNull },
}

Definition at line 4399 of file fxpkgpnp.hpp.

m_PnpFailedIoStartingOtherStates

const PNP_EVENT_TARGET_STATE FxPkgPnp::m_PnpFailedIoStartingOtherStates

staticprivate

Initial value:

=
{
    { PnpEventPwrPolStopFailed, WdfDevStatePnpFailedOwnHardware DEBUGGED_EVENT },
    { PnpEventNull, WdfDevStatePnpNull },
}

Definition at line 4402 of file fxpkgpnp.hpp.

m_PnpFailedPowerDownOtherStates

const PNP_EVENT_TARGET_STATE FxPkgPnp::m_PnpFailedPowerDownOtherStates

staticprivate

Initial value:

=
{
    { PnpEventPwrPolStopFailed, WdfDevStatePnpFailedOwnHardware DEBUGGED_EVENT },
    { PnpEventNull, WdfDevStatePnpNull },
}

Definition at line 4401 of file fxpkgpnp.hpp.

m_PnpFailedWaitForRemoveOtherStates

const PNP_EVENT_TARGET_STATE FxPkgPnp::m_PnpFailedWaitForRemoveOtherStates

staticprivate

Initial value:

=
{
    { PnpEventSurpriseRemove, WdfDevStatePnpFailedSurpriseRemoved DEBUGGED_EVENT },
    { PnpEventStartDevice, WdfDevStatePnpFailedStarted TRAP_ON_EVENT },
    { PnpEventNull, WdfDevStatePnpNull },
}

Definition at line 4403 of file fxpkgpnp.hpp.

m_PnpHardwareAvailableOtherStates

const PNP_EVENT_TARGET_STATE FxPkgPnp::m_PnpHardwareAvailableOtherStates

staticprivate

Initial value:

=
{
    { PnpEventPwrPolStartFailed, WdfDevStatePnpHardwareAvailablePowerPolicyFailed DEBUGGED_EVENT },
    { PnpEventNull, WdfDevStatePnpNull },
}

Definition at line 4387 of file fxpkgpnp.hpp.

m_PnpInitOtherStates

const PNP_EVENT_TARGET_STATE FxPkgPnp::m_PnpInitOtherStates

staticprivate

Initial value:

=
{
    { PnpEventQueryRemove, WdfDevStatePnpInitQueryRemove DEBUGGED_EVENT },
    { PnpEventRemove, WdfDevStatePnpRemoved DEBUGGED_EVENT },
    { PnpEventParentRemoved, WdfDevStatePnpRemoved DEBUGGED_EVENT },
    { PnpEventSurpriseRemove, WdfDevStatePnpInitSurpriseRemoved DEBUGGED_EVENT },
    { PnpEventEject, WdfDevStatePnpEjectHardware DEBUGGED_EVENT },
    { PnpEventNull, WdfDevStatePnpNull },
}

Definition at line 4385 of file fxpkgpnp.hpp.

m_PnpInitQueryRemoveOtherStates

const PNP_EVENT_TARGET_STATE FxPkgPnp::m_PnpInitQueryRemoveOtherStates

staticprivate

Initial value:

=
{
    { PnpEventCancelRemove, WdfDevStatePnpInitQueryRemoveCanceled DEBUGGED_EVENT },
    { PnpEventNull, WdfDevStatePnpNull },
}

Definition at line 4394 of file fxpkgpnp.hpp.

m_PnpInitStartingOtherStates

const PNP_EVENT_TARGET_STATE FxPkgPnp::m_PnpInitStartingOtherStates

staticprivate

Initial value:

=
{
    { PnpEventStartDeviceFailed, WdfDevStatePnpInit DEBUGGED_EVENT },
    { PnpEventNull, WdfDevStatePnpNull },
}

Definition at line 4386 of file fxpkgpnp.hpp.

m_PnpMachine

FxPnpMachine FxPkgPnp::m_PnpMachine

Definition at line 4151 of file fxpkgpnp.hpp.

Referenced by FxPkgFdo::_Create(), CleanupStateMachines(), PnpCheckAssumptions(), PnpEnterNewState(), PnpFinishProcessingIrp(), PnpProcessEvent(), PnpProcessEventInner(), and PostCreateDeviceInitialize().

m_PnpQueriedRemovingOtherStates

const PNP_EVENT_TARGET_STATE FxPkgPnp::m_PnpQueriedRemovingOtherStates

staticprivate

Initial value:

=
{
    { PnpEventPwrPolStopFailed, WdfDevStatePnpRemovingDisableInterfaces DEBUGGED_EVENT },
    { PnpEventNull, WdfDevStatePnpNull },
}

Definition at line 4393 of file fxpkgpnp.hpp.

m_PnpQueryRemovePendingOtherStates

const PNP_EVENT_TARGET_STATE FxPkgPnp::m_PnpQueryRemovePendingOtherStates

staticprivate

Initial value:

=
{
    { PnpEventCancelRemove, WdfDevStatePnpQueryCanceled DEBUGGED_EVENT },
    { PnpEventSurpriseRemove, WdfDevStatePnpQueriedSurpriseRemove TRAP_ON_EVENT },
    { PnpEventNull, WdfDevStatePnpNull },
}

Definition at line 4392 of file fxpkgpnp.hpp.

m_PnpQueryStopPendingOtherStates

const PNP_EVENT_TARGET_STATE FxPkgPnp::m_PnpQueryStopPendingOtherStates

staticprivate

Initial value:

=
{
    { PnpEventCancelStop, WdfDevStatePnpQueryCanceled DEBUGGED_EVENT },
    { PnpEventSurpriseRemove, WdfDevStatePnpQueriedSurpriseRemove TRAP_ON_EVENT },
    { PnpEventNull, WdfDevStatePnpNull },
}

Definition at line 4388 of file fxpkgpnp.hpp.

m_PnpRemovedPdoWaitOtherStates

const PNP_EVENT_TARGET_STATE FxPkgPnp::m_PnpRemovedPdoWaitOtherStates

staticprivate

Initial value:

=
{
    { PnpEventStartDevice, WdfDevStatePnpPdoRestart DEBUGGED_EVENT },
    { PnpEventRemove, WdfDevStatePnpCheckForDevicePresence DEBUGGED_EVENT },
    { PnpEventParentRemoved, WdfDevStatePnpPdoRemoved DEBUGGED_EVENT },
    { PnpEventSurpriseRemove, WdfDevStatePnpRemovedPdoSurpriseRemoved DEBUGGED_EVENT },
    { PnpEventNull, WdfDevStatePnpNull },
}

Definition at line 4389 of file fxpkgpnp.hpp.

m_PnpRestartHardwareAvailableOtherStates

const PNP_EVENT_TARGET_STATE FxPkgPnp::m_PnpRestartHardwareAvailableOtherStates

staticprivate

Initial value:

=
{
    { PnpEventPwrPolStartFailed, WdfDevStatePnpHardwareAvailablePowerPolicyFailed DEBUGGED_EVENT },
    { PnpEventNull, WdfDevStatePnpNull },
}

Definition at line 4406 of file fxpkgpnp.hpp.

m_PnpRestartingOtherStates

const PNP_EVENT_TARGET_STATE FxPkgPnp::m_PnpRestartingOtherStates

staticprivate

Initial value:

=
{
    { PnpEventPwrPolStartFailed, WdfDevStatePnpFailedOwnHardware DEBUGGED_EVENT },
    { PnpEventNull, WdfDevStatePnpNull },
}

Definition at line 4390 of file fxpkgpnp.hpp.

m_PnpRestartOtherStates

const PNP_EVENT_TARGET_STATE FxPkgPnp::m_PnpRestartOtherStates

staticprivate

Initial value:

=
{
    { PnpEventPwrPolStopFailed, WdfDevStatePnpHardwareAvailablePowerPolicyFailed DEBUGGED_EVENT },
    { PnpEventNull, WdfDevStatePnpNull },
}

Definition at line 4404 of file fxpkgpnp.hpp.

m_PnpRestartReleaseHardware

const PNP_EVENT_TARGET_STATE FxPkgPnp::m_PnpRestartReleaseHardware

staticprivate

Initial value:

=
{
    { PnpEventStartDeviceFailed, WdfDevStatePnpFailed TRAP_ON_EVENT },
    { PnpEventNull, WdfDevStatePnpNull },
}

Definition at line 4405 of file fxpkgpnp.hpp.

m_PnpStartedOtherStates

const PNP_EVENT_TARGET_STATE FxPkgPnp::m_PnpStartedOtherStates

staticprivate

Initial value:

=
{
    { PnpEventQueryStop, WdfDevStatePnpQueryStopStaticCheck DEBUGGED_EVENT },
    { PnpEventCancelStop, WdfDevStatePnpStartedCancelStop DEBUGGED_EVENT },
    { PnpEventCancelRemove, WdfDevStatePnpStartedCancelRemove DEBUGGED_EVENT },
    { PnpEventRemove, WdfDevStatePnpStartedRemoving DEBUGGED_EVENT },
    { PnpEventSurpriseRemove, WdfDevStatePnpSurpriseRemoveIoStarted DEBUGGED_EVENT },
    { PnpEventPowerUpFailed,   WdfDevStatePnpFailedIoStarting DEBUGGED_EVENT },
    { PnpEventPowerDownFailed, WdfDevStatePnpFailedPowerDown DEBUGGED_EVENT },
    { PnpEventStartDevice, WdfDevStatePnpRestart DEBUGGED_EVENT },
    { PnpEventNull, WdfDevStatePnpNull },
}

Definition at line 4391 of file fxpkgpnp.hpp.

m_PnpStartedRemovingOtherStates

const PNP_EVENT_TARGET_STATE FxPkgPnp::m_PnpStartedRemovingOtherStates

staticprivate

Initial value:

=
{
    { PnpEventPwrPolStopFailed, WdfDevStatePnpRemovingDisableInterfaces DEBUGGED_EVENT },
    { PnpEventNull, WdfDevStatePnpNull },
}

Definition at line 4400 of file fxpkgpnp.hpp.

m_PnpStartedStoppingFailedOtherStates

const PNP_EVENT_TARGET_STATE FxPkgPnp::m_PnpStartedStoppingFailedOtherStates

staticprivate

Initial value:

=
{
    { PnpEventPwrPolStopFailed, WdfDevStatePnpFailedOwnHardware TRAP_ON_EVENT },
    { PnpEventNull, WdfDevStatePnpNull },
}

Definition at line 4398 of file fxpkgpnp.hpp.

m_PnpStartedStoppingOtherStates

const PNP_EVENT_TARGET_STATE FxPkgPnp::m_PnpStartedStoppingOtherStates

staticprivate

Initial value:

=
{
    { PnpEventPwrPolStopFailed, WdfDevStatePnpFailedOwnHardware DEBUGGED_EVENT },
    { PnpEventNull, WdfDevStatePnpNull },
}

Definition at line 4397 of file fxpkgpnp.hpp.

m_PnpStateAndCaps

FxPnpStateAndCaps FxPkgPnp::m_PnpStateAndCaps

Definition at line 4088 of file fxpkgpnp.hpp.

Referenced by __drv_when(), FxPkgPnp(), GetPnpCapsInternal(), GetPnpStateInternal(), PnpEventRemovedCommonCode(), PnpMatchResources(), SetPnpCaps(), and SetPnpState().

m_PnpStateCallbacks

FxPnpStateCallback* FxPkgPnp::m_PnpStateCallbacks

private

Definition at line 4374 of file fxpkgpnp.hpp.

Referenced by FinishInitialize(), FxPkgPnp(), PnpEnterNewState(), and ~FxPkgPnp().

m_PnpStoppedOtherStates

const PNP_EVENT_TARGET_STATE FxPkgPnp::m_PnpStoppedOtherStates

staticprivate

Initial value:

=
{
    { PnpEventSurpriseRemove, WdfDevStatePnpSurpriseRemove DEBUGGED_EVENT },
    { PnpEventNull, WdfDevStatePnpNull },
}

Definition at line 4395 of file fxpkgpnp.hpp.

m_PnpStoppedWaitForStartCompletionOtherStates

const PNP_EVENT_TARGET_STATE FxPkgPnp::m_PnpStoppedWaitForStartCompletionOtherStates

staticprivate

Initial value:

=
{
    { PnpEventStartDeviceFailed, WdfDevStatePnpFailed TRAP_ON_EVENT },
    { PnpEventNull, WdfDevStatePnpNull },
}

Definition at line 4396 of file fxpkgpnp.hpp.

m_PowerCaps

FxPowerCaps FxPkgPnp::m_PowerCaps

Definition at line 4093 of file fxpkgpnp.hpp.

Referenced by FxPkgPnp(), FxPkgPdo::HandleQueryCapabilities(), FxPkgFdo::HandleQueryCapabilitiesCompletion(), and SetPowerCaps().

m_PowerD0ArmedForWakeNPOtherStates

const POWER_EVENT_TARGET_STATE FxPkgPnp::m_PowerD0ArmedForWakeNPOtherStates

staticprivate

Initial value:

=
{
    { PowerWakeSucceeded,           WdfDevStatePowerD0DisarmingWakeAtBusNP DEBUGGED_EVENT },
    { PowerWakeFailed,              WdfDevStatePowerD0DisarmingWakeAtBusNP TRAP_ON_EVENT },
    { PowerWakeCanceled,            WdfDevStatePowerD0DisarmingWakeAtBusNP DEBUGGED_EVENT },
    { PowerMarkPageable,            WdfDevStatePowerD0ArmedForWake TRAP_ON_EVENT },
    { PowerImplicitD3,              WdfDevStatePowerGotoImplicitD3DisarmWakeAtBus TRAP_ON_EVENT },
    { PowerEventMaximum,            WdfDevStatePowerNull },
}

Definition at line 4413 of file fxpkgpnp.hpp.

m_PowerD0ArmedForWakeOtherStates

const POWER_EVENT_TARGET_STATE FxPkgPnp::m_PowerD0ArmedForWakeOtherStates

staticprivate

Initial value:

=
{
    { PowerWakeSucceeded,           WdfDevStatePowerD0DisarmingWakeAtBus DEBUGGED_EVENT },
    { PowerWakeFailed,              WdfDevStatePowerD0DisarmingWakeAtBus DEBUGGED_EVENT },
    { PowerWakeCanceled,            WdfDevStatePowerD0DisarmingWakeAtBus DEBUGGED_EVENT },
    { PowerMarkNonpageable,         WdfDevStatePowerD0ArmedForWakeNP TRAP_ON_EVENT },
    { PowerImplicitD3,              WdfDevStatePowerGotoImplicitD3DisarmWakeAtBus DEBUGGED_EVENT },
    { PowerEventMaximum,            WdfDevStatePowerNull },
}

Definition at line 4412 of file fxpkgpnp.hpp.

m_PowerD0BusWakeOwnerNPOtherStates

const POWER_EVENT_TARGET_STATE FxPkgPnp::m_PowerD0BusWakeOwnerNPOtherStates

staticprivate

Initial value:

=
{
    { PowerWakeArrival,             WdfDevStatePowerEnablingWakeAtBusNP DEBUGGED_EVENT },
    { PowerImplicitD3,              WdfDevStatePowerGotoD3Stopped DEBUGGED_EVENT },
    { PowerMarkPageable,            WdfDevStatePowerD0BusWakeOwner DEBUGGED_EVENT },
    { PowerEventMaximum,            WdfDevStatePowerNull },
}

Definition at line 4411 of file fxpkgpnp.hpp.

m_PowerD0BusWakeOwnerOtherStates

const POWER_EVENT_TARGET_STATE FxPkgPnp::m_PowerD0BusWakeOwnerOtherStates

staticprivate

Initial value:

=
{
    { PowerWakeArrival,             WdfDevStatePowerEnablingWakeAtBus DEBUGGED_EVENT },
    { PowerImplicitD3,              WdfDevStatePowerGotoD3Stopped DEBUGGED_EVENT },
    { PowerMarkNonpageable,         WdfDevStatePowerDecideD0State DEBUGGED_EVENT },
    { PowerEventMaximum,            WdfDevStatePowerNull },
}

Definition at line 4410 of file fxpkgpnp.hpp.

m_PowerD0NPOtherStates

const POWER_EVENT_TARGET_STATE FxPkgPnp::m_PowerD0NPOtherStates

staticprivate

Initial value:

=
{
    { PowerImplicitD3,              WdfDevStatePowerGotoD3Stopped DEBUGGED_EVENT },
    { PowerMarkPageable,            WdfDevStatePowerDecideD0State DEBUGGED_EVENT },
    { PowerEventMaximum,            WdfDevStatePowerNull },
}

Definition at line 4409 of file fxpkgpnp.hpp.

m_PowerD0OtherStates

const POWER_EVENT_TARGET_STATE FxPkgPnp::m_PowerD0OtherStates

staticprivate

Initial value:

=
{
    { PowerImplicitD3,              WdfDevStatePowerGotoD3Stopped DEBUGGED_EVENT },
    { PowerMarkNonpageable,         WdfDevStatePowerDecideD0State DEBUGGED_EVENT },
    { PowerEventMaximum,            WdfDevStatePowerNull },
}

Definition at line 4408 of file fxpkgpnp.hpp.

m_PowerDNotZeroNPOtherStates

const POWER_EVENT_TARGET_STATE FxPkgPnp::m_PowerDNotZeroNPOtherStates

staticprivate

Initial value:

=
{
    { PowerImplicitD3, WdfDevStatePowerGotoDxStoppedDisableInterruptNP DEBUGGED_EVENT },
    { PowerEventMaximum, WdfDevStatePowerNull },
}

Definition at line 4415 of file fxpkgpnp.hpp.

m_PowerDNotZeroOtherStates

const POWER_EVENT_TARGET_STATE FxPkgPnp::m_PowerDNotZeroOtherStates

staticprivate

Initial value:

=
{
    { PowerImplicitD3,              WdfDevStatePowerGotoDxStoppedDisableInterrupt DEBUGGED_EVENT },
    { PowerEventMaximum,            WdfDevStatePowerNull },
}

Definition at line 4414 of file fxpkgpnp.hpp.

m_PowerDxStoppedOtherStates

const POWER_EVENT_TARGET_STATE FxPkgPnp::m_PowerDxStoppedOtherStates

staticprivate

Initial value:

=
{
    { PowerD0,                      WdfDevStatePowerGotoStopped DEBUGGED_EVENT },
    { PowerEventMaximum,            WdfDevStatePowerNull },
}

Definition at line 4422 of file fxpkgpnp.hpp.

m_PowerMachine

FxPowerMachine FxPkgPnp::m_PowerMachine

Definition at line 4152 of file fxpkgpnp.hpp.

Referenced by FxPkgFdo::_Create(), CleanupStateMachines(), DispatchWaitWake(), PostCreateDeviceInitialize(), PowerCheckAssumptions(), PowerCompletePendedWakeIrp(), PowerEnterNewState(), PowerGotoDx(), PowerGotoDxIoStopped(), PowerGotoDxIoStoppedNP(), PowerMakeWakeRequestNonCancelable(), PowerProcessEvent(), and PowerProcessEventInner().

m_PowerPolCancelingWakeForSystemSleepOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolCancelingWakeForSystemSleepOtherStates

staticprivate

Initial value:

=
{
    { PwrPolWakeSuccess,     WdfDevStatePwrPolCancelingWakeForSystemSleepWakeCanceled DEBUGGED_EVENT },
    { PwrPolNull,            WdfDevStatePwrPolNull },
}

Definition at line 4459 of file fxpkgpnp.hpp.

m_PowerPolCancelingWakeForSystemSleepWakeCanceledOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolCancelingWakeForSystemSleepWakeCanceledOtherStates

staticprivate

Initial value:

=
{
    { PwrPolPowerUpFailed, WdfDevStatePwrPolPowerUpForSystemSleepFailed DEBUGGED_EVENT },
    { PwrPolPowerUpNotSeen, WdfDevStatePwrPolPowerUpForSystemSleepNotSeen TRAP_ON_EVENT },
    { PwrPolNull, WdfDevStatePwrPolNull },
}

Definition at line 4446 of file fxpkgpnp.hpp.

m_PowerPolCancelUsbSSOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolCancelUsbSSOtherStates

staticprivate

Initial value:

=
{
    { PwrPolStop, WdfDevStatePwrPolStoppingWaitForUsbSSCompletion TRAP_ON_EVENT },
    { PwrPolSurpriseRemove, WdfDevStatePwrPolStoppingWaitForUsbSSCompletion TRAP_ON_EVENT },
    { PwrPolNull,        WdfDevStatePwrPolNull },
}

Definition at line 4485 of file fxpkgpnp.hpp.

m_PowerPolDevicePowerRequestFailedOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolDevicePowerRequestFailedOtherStates

staticprivate

Initial value:

=
{
    { PwrPolSurpriseRemove, WdfDevStatePwrPolStopping DEBUGGED_EVENT },
    { PwrPolNull,           WdfDevStatePwrPolNull },
}

Definition at line 4480 of file fxpkgpnp.hpp.

m_PowerPolDisarmingWakeForSystemSleepCompletePowerUpOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolDisarmingWakeForSystemSleepCompletePowerUpOtherStates

staticprivate

Initial value:

=
{
    { PwrPolPowerUpFailed, WdfDevStatePwrPolPowerUpForSystemSleepFailed DEBUGGED_EVENT },
    { PwrPolNull, WdfDevStatePwrPolNull },
}

Definition at line 4445 of file fxpkgpnp.hpp.

m_PowerPolicyMachine

FxPowerPolicyMachine FxPkgPnp::m_PowerPolicyMachine

Definition at line 4153 of file fxpkgpnp.hpp.

Referenced by __drv_maxIRQL(), FxPkgFdo::_Create(), _S0IdleQueryInstance(), _SxWakeQueryInstance(), CleanupStateMachines(), FxPkgFdo::DispatchDeviceSetPower(), FxPkgPdo::DispatchDeviceSetPower(), DispatchWaitWake(), if(), Initialize(), IsPowerPolicyOwner(), IsS0IdleSystemManaged(), IsS0IdleUsbSSEnabled(), IsS0IdleWakeFromS0Enabled(), IsSxWakeEnabled(), NotPowerPolicyOwnerEnterNewState(), PnpPowerReferenceDuringQueryPnp(), FxDevice::PoFxDevicePowerNotRequired(), FxDevice::PoFxDevicePowerRequired(), PostCreateDeviceInitialize(), PowerDereference(), PowerMakeWakeRequestNonCancelable(), FxPkgPdo::PowerNotifyParentChildWakeArmed(), FxPkgPdo::PowerNotifyParentChildWakeDisarmed(), PowerPolicyBlockChildrenPowerUp(), PowerPolicyCancelUsbSS(), PowerPolicyCancelUsbSSIfCapable(), PowerPolicyCancelWaitWake(), PowerPolicyCanChildPowerUp(), PowerPolicyCanIdlePowerDown(), PowerPolicyCheckAssumptions(), PowerPolicyChildPoweredDown(), PowerPolicyChildrenCanPowerUp(), PowerPolicyDisarmWakeFromSx(), PowerPolicyEnterNewState(), PowerPolicyGetCurrentWakeReason(), PowerPolicyProcessEvent(), PowerPolicyProcessEventInner(), PowerPolicySendDevicePowerRequest(), PowerPolicySendWaitWakeRequest(), PowerPolicySetS0IdleSettings(), PowerPolicySetS0IdleState(), PowerPolicySetSxWakeSettings(), PowerPolicySetSxWakeState(), PowerPolicyShouldPropagateWakeStatusToChildren(), PowerPolicyUpdateSystemWakeSource(), PowerReference(), PowerSendIdlePowerEvent(), PowerSendPowerDownEvents(), PowerSendPowerDownFailureEvent(), FxDevice::ProcessWmiPowerQueryOrSetData(), QueryForCapabilities(), RegisterPowerPolicyCallbacks(), SaveState(), and SetPowerCaps().

m_PowerPolicyStateCallbacks

FxPowerPolicyStateCallback* FxPkgPnp::m_PowerPolicyStateCallbacks

private

Definition at line 4378 of file fxpkgpnp.hpp.

Referenced by FinishInitialize(), FxPkgPnp(), NotPowerPolicyOwnerEnterNewState(), PowerPolicyEnterNewState(), and ~FxPkgPnp().

m_PowerPolIdleCapableDeviceIdleOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolIdleCapableDeviceIdleOtherStates

staticprivate

Initial value:

=
{
    { PwrPolSx, WdfDevStatePwrPolDeviceIdleSleeping DEBUGGED_EVENT },
    { PwrPolStop, WdfDevStatePwrPolDeviceIdleStopping DEBUGGED_EVENT },
    { PwrPolSurpriseRemove,WdfDevStatePwrPolDeviceIdleStopping DEBUGGED_EVENT },
    { PwrPolS0IdlePolicyChanged, WdfDevStatePwrPolDeviceIdleReturnToActive TRAP_ON_EVENT },
    { PwrPolIoPresent, WdfDevStatePwrPolDeviceIdleReturnToActive DEBUGGED_EVENT },
    { PwrPolNull, WdfDevStatePwrPolNull },
}

Definition at line 4427 of file fxpkgpnp.hpp.

m_PowerPolIoPresentArmedOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolIoPresentArmedOtherStates

staticprivate

Initial value:

=
{
    { PwrPolWakeSuccess, WdfDevStatePwrPolIoPresentArmedWakeCanceled DEBUGGED_EVENT },
    { PwrPolNull, WdfDevStatePwrPolNull },
}

Definition at line 4453 of file fxpkgpnp.hpp.

m_PowerPolIoPresentArmedWakeCanceledOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolIoPresentArmedWakeCanceledOtherStates

staticprivate

Initial value:

=
{
    { PwrPolPowerUpFailed, WdfDevStatePwrPolDevicePowerRequestFailed DEBUGGED_EVENT },
    { PwrPolPowerUpNotSeen, WdfDevStatePwrPolDeviceD0PowerRequestFailed TRAP_ON_EVENT },
    { PwrPolNull, WdfDevStatePwrPolNull },
}

Definition at line 4454 of file fxpkgpnp.hpp.

m_PowerPolObjectCreatedOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolObjectCreatedOtherStates

staticprivate

Initial value:

=
{
    { PwrPolRemove, WdfDevStatePwrPolRemoved DEBUGGED_EVENT },
    { PwrPolNull, WdfDevStatePwrPolNull },
}

Definition at line 4424 of file fxpkgpnp.hpp.

m_PowerPolRemovedOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolRemovedOtherStates

staticprivate

Initial value:

=
{
    { PwrPolRemove, WdfDevStatePwrPolRemoved DEBUGGED_EVENT },
    { PwrPolNull, WdfDevStatePwrPolNull },
}

Definition at line 4488 of file fxpkgpnp.hpp.

m_PowerPolRestartingOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolRestartingOtherStates

staticprivate

Initial value:

=
{
    { PwrPolPowerUpFailed,  WdfDevStatePwrPolRestartingFailed DEBUGGED_EVENT },
    { PwrPolNull,           WdfDevStatePwrPolNull },
}

Definition at line 4483 of file fxpkgpnp.hpp.

m_PowerPolS0NoWakeCompletePowerUpOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolS0NoWakeCompletePowerUpOtherStates

staticprivate

Initial value:

=
{
    { PwrPolPowerUpFailed, WdfDevStatePwrPolDevicePowerRequestFailed DEBUGGED_EVENT },
    { PwrPolNull, WdfDevStatePwrPolNull },
}

Definition at line 4432 of file fxpkgpnp.hpp.

m_PowerPolS0NoWakePowerUpOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolS0NoWakePowerUpOtherStates

staticprivate

Initial value:

=
{
    { PwrPolPowerUpFailed, WdfDevStatePwrPolDevicePowerRequestFailed DEBUGGED_EVENT },
    { PwrPolPowerUpNotSeen, WdfDevStatePwrPolDeviceD0PowerRequestFailed TRAP_ON_EVENT },
    { PwrPolNull, WdfDevStatePwrPolNull },
}

Definition at line 4431 of file fxpkgpnp.hpp.

m_PowerPolS0WakeCompletePowerUpOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolS0WakeCompletePowerUpOtherStates

staticprivate

Initial value:

=
{
    { PwrPolPowerUpFailed, WdfDevStatePwrPolDevicePowerRequestFailed DEBUGGED_EVENT },
    { PwrPolNull, WdfDevStatePwrPolNull },
}

Definition at line 4455 of file fxpkgpnp.hpp.

m_PowerPolSleepingNoWakeCompletePowerDownOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolSleepingNoWakeCompletePowerDownOtherStates

staticprivate

Initial value:

=
{
    { PwrPolPowerDownFailed, WdfDevStatePwrPolSystemSleepPowerRequestFailed DEBUGGED_EVENT },
    { PwrPolNull, WdfDevStatePwrPolNull },
}

Definition at line 4473 of file fxpkgpnp.hpp.

m_PowerPolSleepingNoWakePowerDownOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolSleepingNoWakePowerDownOtherStates

staticprivate

Initial value:

=
{
    { PwrPolPowerDown, WdfDevStatePwrPolSleepingPowerDownNotProcessed TRAP_ON_EVENT },
    { PwrPolNull, WdfDevStatePwrPolNull },
}

Definition at line 4472 of file fxpkgpnp.hpp.

m_PowerPolSleepingSendWakeOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolSleepingSendWakeOtherStates

staticprivate

Initial value:

=
{
    { PwrPolWakeSuccess, WdfDevStatePwrPolSleepingNoWakeCompletePowerDown DEBUGGED_EVENT },
    { PwrPolWakeFailed, WdfDevStatePwrPolSleepingNoWakeCompletePowerDown DEBUGGED_EVENT },
    { PwrPolNull, WdfDevStatePwrPolNull },
}

Definition at line 4475 of file fxpkgpnp.hpp.

m_PowerPolSleepingWakePowerDownFailedOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolSleepingWakePowerDownFailedOtherStates

staticprivate

Initial value:

=
{
    { PwrPolWakeFailed, WdfDevStatePwrPolSleepingWakePowerDownFailedWakeCanceled DEBUGGED_EVENT },
    { PwrPolNull, WdfDevStatePwrPolNull },
}

Definition at line 4477 of file fxpkgpnp.hpp.

m_PowerPolSleepingWakePowerDownOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolSleepingWakePowerDownOtherStates

staticprivate

Initial value:

=
{
    { PwrPolPowerDown, WdfDevStatePwrPolSleepingPowerDownNotProcessed TRAP_ON_EVENT },
    { PwrPolNull, WdfDevStatePwrPolNull },
}

Definition at line 4474 of file fxpkgpnp.hpp.

m_PowerPolSleepingWakeRevertArmWakeNPOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolSleepingWakeRevertArmWakeNPOtherStates

staticprivate

Initial value:

=
{
    { PwrPolWakeSuccess,    WdfDevStatePwrPolSleepingNoWakeCompletePowerDown DEBUGGED_EVENT },
    { PwrPolNull,           WdfDevStatePwrPolNull },
}

Definition at line 4487 of file fxpkgpnp.hpp.

m_PowerPolSleepingWakeRevertArmWakeOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolSleepingWakeRevertArmWakeOtherStates

staticprivate

Initial value:

=
{
    { PwrPolWakeSuccess,    WdfDevStatePwrPolSleepingNoWakeCompletePowerDown DEBUGGED_EVENT },
    { PwrPolNull,           WdfDevStatePwrPolNull },
}

Definition at line 4486 of file fxpkgpnp.hpp.

m_PowerPolSleepingWakeWakeArrivedNPOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolSleepingWakeWakeArrivedNPOtherStates

staticprivate

Initial value:

=
{
    { PwrPolPowerDownFailed, WdfDevStatePwrPolSleepingWakePowerDownFailed DEBUGGED_EVENT },
    { PwrPolNull, WdfDevStatePwrPolNull },
}

Definition at line 4476 of file fxpkgpnp.hpp.

m_PowerPolSleepingWakeWakeArrivedOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolSleepingWakeWakeArrivedOtherStates

staticprivate

Initial value:

=
{
    { PwrPolPowerDownFailed, WdfDevStatePwrPolSleepingWakePowerDownFailed DEBUGGED_EVENT },
    { PwrPolNull, WdfDevStatePwrPolNull },
}

Definition at line 4468 of file fxpkgpnp.hpp.

m_PowerPolStartedIdleCapableOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolStartedIdleCapableOtherStates

staticprivate

Initial value:

=
{
    { PwrPolSx, WdfDevStatePwrPolStartedIdleCapableCancelTimerForSleep DEBUGGED_EVENT },
    { PwrPolStop, WdfDevStatePwrPolStoppingCancelTimer DEBUGGED_EVENT },
    { PwrPolSurpriseRemove,WdfDevStatePwrPolStoppingCancelTimer DEBUGGED_EVENT },
    { PwrPolS0IdlePolicyChanged, WdfDevStatePwrPolStartedCancelTimer DEBUGGED_EVENT },
    { PwrPolNull, WdfDevStatePwrPolNull },
}

Definition at line 4426 of file fxpkgpnp.hpp.

m_PowerPolStartedOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolStartedOtherStates

staticprivate

Initial value:

=
{
    { PwrPolStop, WdfDevStatePwrPolStopping DEBUGGED_EVENT },
    { PwrPolSurpriseRemove, WdfDevStatePwrPolStopping DEBUGGED_EVENT },
    { PwrPolS0IdlePolicyChanged, WdfDevStatePwrPolStartingDecideS0Wake DEBUGGED_EVENT },
    { PwrPolNull, WdfDevStatePwrPolNull },
}

Definition at line 4478 of file fxpkgpnp.hpp.

m_PowerPolStartedWaitForIdleTimeoutOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolStartedWaitForIdleTimeoutOtherStates

staticprivate

Initial value:

=
{
    { PwrPolStop, WdfDevStatePwrPolStoppingWaitForIdleTimeout TRAP_ON_EVENT },
    { PwrPolSurpriseRemove, WdfDevStatePwrPolStoppingWaitForIdleTimeout TRAP_ON_EVENT },
    { PwrPolNull, WdfDevStatePwrPolNull },
}

Definition at line 4479 of file fxpkgpnp.hpp.

m_PowerPolStartedWakeCapableOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolStartedWakeCapableOtherStates

staticprivate

Initial value:

=
{
    { PwrPolSx, WdfDevStatePwrPolStartedWakeCapableCancelTimerForSleep DEBUGGED_EVENT },
    { PwrPolStop, WdfDevStatePwrPolStoppingCancelTimer DEBUGGED_EVENT },
    { PwrPolSurpriseRemove, WdfDevStatePwrPolStoppingCancelTimer DEBUGGED_EVENT },
    { PwrPolS0IdlePolicyChanged, WdfDevStatePwrPolStartedCancelTimer DEBUGGED_EVENT },
    { PwrPolNull, WdfDevStatePwrPolNull },
}

Definition at line 4439 of file fxpkgpnp.hpp.

m_PowerPolStartingOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolStartingOtherStates

staticprivate

Initial value:

=
{
    { PwrPolPowerUpFailed, WdfDevStatePwrPolStartingFailed DEBUGGED_EVENT },
    { PwrPolNull, WdfDevStatePwrPolNull },
}

Definition at line 4425 of file fxpkgpnp.hpp.

m_PowerPolStoppedOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolStoppedOtherStates

staticprivate

Initial value:

=
{
    { PwrPolRemove,         WdfDevStatePwrPolStoppedRemoving DEBUGGED_EVENT },
    { PwrPolNull,           WdfDevStatePwrPolNull },
}

Definition at line 4482 of file fxpkgpnp.hpp.

m_PowerPolStoppingCancelWakeOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolStoppingCancelWakeOtherStates

staticprivate

Initial value:

=
{
    { PwrPolWakeSuccess, WdfDevStatePwrPolStopping DEBUGGED_EVENT },
    { PwrPolNull,        WdfDevStatePwrPolNull },
}

Definition at line 4484 of file fxpkgpnp.hpp.

m_PowerPolStoppingD0OtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolStoppingD0OtherStates

staticprivate

Initial value:

=
{
    { PwrPolPowerUpFailed, WdfDevStatePwrPolStoppingD0Failed DEBUGGED_EVENT },
    { PwrPolPowerUpNotSeen, WdfDevStatePwrPolDeviceD0PowerRequestFailed TRAP_ON_EVENT },
    { PwrPolNull, WdfDevStatePwrPolNull },
}

Definition at line 4450 of file fxpkgpnp.hpp.

m_PowerPolStoppingDisarmWakeCancelWakeOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolStoppingDisarmWakeCancelWakeOtherStates

staticprivate

Initial value:

=
{
    { PwrPolWakeSuccess,     WdfDevStatePwrPolStoppingDisarmWakeWakeCanceled DEBUGGED_EVENT },
    { PwrPolNull,            WdfDevStatePwrPolNull },
}

Definition at line 4452 of file fxpkgpnp.hpp.

m_PowerPolStoppingDisarmWakeOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolStoppingDisarmWakeOtherStates

staticprivate

Initial value:

=
{
    { PwrPolPowerUpFailed, WdfDevStatePwrPolStoppingD0Failed DEBUGGED_EVENT },
    { PwrPolNull, WdfDevStatePwrPolNull },
}

Definition at line 4451 of file fxpkgpnp.hpp.

m_PowerPolStoppingOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolStoppingOtherStates

staticprivate

Initial value:

=
{
    { PwrPolPowerDownFailed, WdfDevStatePwrPolStoppingFailed DEBUGGED_EVENT },
    { PwrPolNull,WdfDevStatePwrPolNull },
}

Definition at line 4481 of file fxpkgpnp.hpp.

m_PowerPolStoppingResetDeviceCompletePowerUpOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolStoppingResetDeviceCompletePowerUpOtherStates

staticprivate

Initial value:

=
{
    { PwrPolPowerUpFailed, WdfDevStatePwrPolStoppingResetDeviceFailed DEBUGGED_EVENT },
    { PwrPolNull, WdfDevStatePwrPolNull },
}

Definition at line 4449 of file fxpkgpnp.hpp.

m_PowerPolStoppingResetDeviceOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolStoppingResetDeviceOtherStates

staticprivate

Initial value:

=
{
    { PwrPolPowerUpFailed, WdfDevStatePwrPolStoppingResetDeviceFailed DEBUGGED_EVENT },
    { PwrPolPowerUpNotSeen, WdfDevStatePwrPolDeviceD0PowerRequestFailed TRAP_ON_EVENT },
    { PwrPolNull, WdfDevStatePwrPolNull },
}

Definition at line 4448 of file fxpkgpnp.hpp.

m_PowerPolSystemAsleepWakeArmedNPOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolSystemAsleepWakeArmedNPOtherStates

staticprivate

Initial value:

=
{
    { PwrPolWakeSuccess, WdfDevStatePwrPolSystemWakeDeviceWakeTriggeredNP DEBUGGED_EVENT },
    { PwrPolWakeInterruptFired, WdfDevStatePwrPolSystemWakeDeviceWakeInterruptFiredNP TRAP_ON_EVENT },
    { PwrPolNull,        WdfDevStatePwrPolNull },
}

Definition at line 4436 of file fxpkgpnp.hpp.

m_PowerPolSystemAsleepWakeArmedOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolSystemAsleepWakeArmedOtherStates

staticprivate

Initial value:

=
{
    { PwrPolWakeSuccess, WdfDevStatePwrPolSystemWakeDeviceWakeTriggered DEBUGGED_EVENT },
    { PwrPolWakeInterruptFired, WdfDevStatePwrPolSystemWakeDeviceWakeInterruptFired DEBUGGED_EVENT },
    { PwrPolNull,        WdfDevStatePwrPolNull },
}

Definition at line 4435 of file fxpkgpnp.hpp.

m_PowerPolSystemSleepNeedWakeCompletePowerUpOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolSystemSleepNeedWakeCompletePowerUpOtherStates

staticprivate

Initial value:

=
{
    { PwrPolPowerUpFailed, WdfDevStatePwrPolSystemSleepPowerRequestFailed DEBUGGED_EVENT },
    { PwrPolNull, WdfDevStatePwrPolNull },
}

Definition at line 4434 of file fxpkgpnp.hpp.

m_PowerPolSystemSleepNeedWakeOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolSystemSleepNeedWakeOtherStates

staticprivate

Initial value:

=
{
    { PwrPolPowerUpFailed, WdfDevStatePwrPolSystemSleepPowerRequestFailed DEBUGGED_EVENT },
    { PwrPolPowerUpNotSeen, WdfDevStatePwrPolPowerUpForSystemSleepNotSeen TRAP_ON_EVENT },
    { PwrPolNull, WdfDevStatePwrPolNull },
}

Definition at line 4433 of file fxpkgpnp.hpp.

m_PowerPolSystemWakeDeviceToD0CompletePowerUpOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolSystemWakeDeviceToD0CompletePowerUpOtherStates

staticprivate

Initial value:

=
{
    { PwrPolPowerUpFailed, WdfDevStatePwrPolDevicePowerRequestFailed DEBUGGED_EVENT },
    { PwrPolNull, WdfDevStatePwrPolNull },
}

Definition at line 4438 of file fxpkgpnp.hpp.

m_PowerPolSystemWakeDeviceToD0OtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolSystemWakeDeviceToD0OtherStates

staticprivate

Initial value:

=
{
    { PwrPolPowerUpFailed, WdfDevStatePwrPolDevicePowerRequestFailed DEBUGGED_EVENT },
    { PwrPolPowerUpNotSeen, WdfDevStatePwrPolDeviceD0PowerRequestFailed TRAP_ON_EVENT },
    { PwrPolNull,        WdfDevStatePwrPolNull },
}

Definition at line 4437 of file fxpkgpnp.hpp.

m_PowerPolSystemWakeDeviceWakeCompletePowerUpOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolSystemWakeDeviceWakeCompletePowerUpOtherStates

staticprivate

Initial value:

=
{
    { PwrPolPowerUpFailed, WdfDevStatePwrPolDevicePowerRequestFailed DEBUGGED_EVENT },
    { PwrPolNull, WdfDevStatePwrPolNull },
}

Definition at line 4471 of file fxpkgpnp.hpp.

m_PowerPolSystemWakeDeviceWakeEnabledNPOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolSystemWakeDeviceWakeEnabledNPOtherStates

staticprivate

Initial value:

=
{
    { PwrPolWakeSuccess,    WdfDevStatePwrPolSystemWakeDeviceWakeEnabledWakeCanceledNP DEBUGGED_EVENT },
    { PwrPolNull,           WdfDevStatePwrPolNull },
}

Definition at line 4465 of file fxpkgpnp.hpp.

m_PowerPolSystemWakeDeviceWakeEnabledOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolSystemWakeDeviceWakeEnabledOtherStates

staticprivate

Initial value:

=
{
    { PwrPolWakeSuccess,    WdfDevStatePwrPolSystemWakeDeviceWakeEnabledWakeCanceled DEBUGGED_EVENT },
    { PwrPolNull,           WdfDevStatePwrPolNull },
}

Definition at line 4464 of file fxpkgpnp.hpp.

m_PowerPolSystemWakeDeviceWakeEnabledWakeCanceledNPOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolSystemWakeDeviceWakeEnabledWakeCanceledNPOtherStates

staticprivate

Initial value:

=
{
    { PwrPolPowerUpFailed, WdfDevStatePwrPolDevicePowerRequestFailed DEBUGGED_EVENT },
    { PwrPolPowerUpNotSeen, WdfDevStatePwrPolDeviceD0PowerRequestFailed TRAP_ON_EVENT },
    { PwrPolNull,          WdfDevStatePwrPolNull },
}

Definition at line 4467 of file fxpkgpnp.hpp.

m_PowerPolSystemWakeDeviceWakeEnabledWakeCanceledOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolSystemWakeDeviceWakeEnabledWakeCanceledOtherStates

staticprivate

Initial value:

=
{
    { PwrPolPowerUpFailed, WdfDevStatePwrPolDevicePowerRequestFailed DEBUGGED_EVENT },
    { PwrPolPowerUpNotSeen, WdfDevStatePwrPolDeviceD0PowerRequestFailed TRAP_ON_EVENT },
    { PwrPolNull,           WdfDevStatePwrPolNull },
}

Definition at line 4466 of file fxpkgpnp.hpp.

m_PowerPolSystemWakeDeviceWakeInterruptFiredNPOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolSystemWakeDeviceWakeInterruptFiredNPOtherStates

staticprivate

Initial value:

=
{
    { PwrPolWakeSuccess, WdfDevStatePwrPolSystemWakeDeviceWakeTriggeredNP TRAP_ON_EVENT },
    { PwrPolNull, WdfDevStatePwrPolNull },
}

Definition at line 4509 of file fxpkgpnp.hpp.

m_PowerPolSystemWakeDeviceWakeInterruptFiredOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolSystemWakeDeviceWakeInterruptFiredOtherStates

staticprivate

Initial value:

=
{
    { PwrPolWakeSuccess, WdfDevStatePwrPolSystemWakeDeviceWakeTriggered TRAP_ON_EVENT },
    { PwrPolNull, WdfDevStatePwrPolNull },
}

Definition at line 4508 of file fxpkgpnp.hpp.

m_PowerPolSystemWakeDeviceWakeTriggeredS0NPOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolSystemWakeDeviceWakeTriggeredS0NPOtherStates

staticprivate

Initial value:

=
{
    { PwrPolPowerUpFailed, WdfDevStatePwrPolDevicePowerRequestFailed DEBUGGED_EVENT },
    { PwrPolPowerUpNotSeen, WdfDevStatePwrPolDeviceD0PowerRequestFailed TRAP_ON_EVENT },
    { PwrPolNull, WdfDevStatePwrPolNull },
}

Definition at line 4470 of file fxpkgpnp.hpp.

m_PowerPolSystemWakeDeviceWakeTriggeredS0OtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolSystemWakeDeviceWakeTriggeredS0OtherStates

staticprivate

Initial value:

=
{
    { PwrPolPowerUpFailed, WdfDevStatePwrPolDevicePowerRequestFailed DEBUGGED_EVENT },
    { PwrPolPowerUpNotSeen, WdfDevStatePwrPolDeviceD0PowerRequestFailed TRAP_ON_EVENT },
    { PwrPolNull,           WdfDevStatePwrPolNull },
}

Definition at line 4469 of file fxpkgpnp.hpp.

m_PowerPolTimerExpiredNoWakeCompletePowerDownOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolTimerExpiredNoWakeCompletePowerDownOtherStates

staticprivate

Initial value:

=
{
    { PwrPolPowerDownFailed, WdfDevStatePwrPolDevicePowerRequestFailed DEBUGGED_EVENT },
    { PwrPolNull, WdfDevStatePwrPolNull },
}

Definition at line 4429 of file fxpkgpnp.hpp.

m_PowerPolTimerExpiredNoWakeOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolTimerExpiredNoWakeOtherStates

staticprivate

Initial value:

=
{
    { PwrPolPowerDown, WdfDevStatePwrPolTimerExpiredNoWakePowerDownNotProcessed TRAP_ON_EVENT },
    { PwrPolNull, WdfDevStatePwrPolNull },
}

Definition at line 4428 of file fxpkgpnp.hpp.

m_PowerPolTimerExpiredWakeCapableCancelWakeOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolTimerExpiredWakeCapableCancelWakeOtherStates

staticprivate

Initial value:

=
{
    { PwrPolWakeFailed, WdfDevStatePwrPolTimerExpiredWakeCapableWakeCanceled DEBUGGED_EVENT },
    { PwrPolNull, WdfDevStatePwrPolNull },
}

Definition at line 4461 of file fxpkgpnp.hpp.

m_PowerPolTimerExpiredWakeCapablePowerDownFailedCancelWakeOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolTimerExpiredWakeCapablePowerDownFailedCancelWakeOtherStates

staticprivate

Initial value:

=
{
    { PwrPolWakeFailed, WdfDevStatePwrPolTimerExpiredWakeCapablePowerDownFailedWakeCanceled DEBUGGED_EVENT },
    { PwrPolNull, WdfDevStatePwrPolNull },
}

Definition at line 4458 of file fxpkgpnp.hpp.

m_PowerPolTimerExpiredWakeCapablePowerDownFailedWakeInterruptArrivedOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolTimerExpiredWakeCapablePowerDownFailedWakeInterruptArrivedOtherStates

staticprivate

Initial value:

=
{
    { PwrPolWakeSuccess, WdfDevStatePwrPolTimerExpiredWakeCapablePowerDownFailedWakeCanceled TRAP_ON_EVENT },
    { PwrPolNull, WdfDevStatePwrPolNull },
}

Definition at line 4490 of file fxpkgpnp.hpp.

m_PowerPolTimerExpiredWakeCapablePowerDownOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolTimerExpiredWakeCapablePowerDownOtherStates

staticprivate

Initial value:

=
{
    { PwrPolPowerDown, WdfDevStatePwrPolTimerExpiredWakeCapablePowerDownNotProcessed TRAP_ON_EVENT },
    { PwrPolNull, WdfDevStatePwrPolNull },
}

Definition at line 4441 of file fxpkgpnp.hpp.

m_PowerPolTimerExpiredWakeCapableSendWakeOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolTimerExpiredWakeCapableSendWakeOtherStates

staticprivate

Initial value:

=
{
    { PwrPolWakeFailed, WdfDevStatePwrPolTimerExpiredWakeCompletedDisarm DEBUGGED_EVENT },
    { PwrPolWakeSuccess, WdfDevStatePwrPolTimerExpiredWakeSucceeded DEBUGGED_EVENT },
    { PwrPolNull, WdfDevStatePwrPolNull },
}

Definition at line 4442 of file fxpkgpnp.hpp.

m_PowerPolTimerExpiredWakeCapableUsbSSOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolTimerExpiredWakeCapableUsbSSOtherStates

staticprivate

Initial value:

=
{
    { PwrPolSx, WdfDevStatePwrPolStartedWakeCapableSleepingUsbSS DEBUGGED_EVENT },
    { PwrPolStop, WdfDevStatePwrPolStoppingCancelUsbSS TRAP_ON_EVENT },
    { PwrPolSurpriseRemove, WdfDevStatePwrPolStoppingCancelUsbSS DEBUGGED_EVENT },
    { PwrPolUsbSelectiveSuspendCompleted, WdfDevStatePwrPolWakeCapableUsbSSCompleted DEBUGGED_EVENT },
    { PwrPolS0IdlePolicyChanged, WdfDevStatePwrPolCancelUsbSS DEBUGGED_EVENT },
    { PwrPolIoPresent, WdfDevStatePwrPolCancelUsbSS DEBUGGED_EVENT },
    { PwrPolDevicePowerRequired, WdfDevStatePwrPolCancelUsbSS DEBUGGED_EVENT },
    { PwrPolNull, WdfDevStatePwrPolNull },
}

Definition at line 4443 of file fxpkgpnp.hpp.

m_PowerPolTimerExpiredWakeCapableWakeArrivedOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolTimerExpiredWakeCapableWakeArrivedOtherStates

staticprivate

Initial value:

=
{
    { PwrPolWakeSuccess,    WdfDevStatePwrPolTimerExpiredWakeCapableWakeSucceeded DEBUGGED_EVENT },
    { PwrPolWakeFailed,     WdfDevStatePwrPolTimerExpiredWakeCapableWakeFailed DEBUGGED_EVENT },
    { PwrPolPowerDownFailed, WdfDevStatePwrPolTimerExpiredWakeCapablePowerDownFailedCancelWake DEBUGGED_EVENT },
    { PwrPolWakeInterruptFired, WdfDevStatePwrPolTimerExpiredWakeCapableWakeInterruptArrived },
    { PwrPolNull,           WdfDevStatePwrPolNull },
}

Definition at line 4460 of file fxpkgpnp.hpp.

m_PowerPolTimerExpiredWakeCapableWakeFailedOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolTimerExpiredWakeCapableWakeFailedOtherStates

staticprivate

Initial value:

=
{
    { PwrPolPowerDownFailed, WdfDevStatePwrPolTimerExpiredWakeCapablePowerDownFailedUsbSS DEBUGGED_EVENT },
    { PwrPolNull, WdfDevStatePwrPolNull },
}

Definition at line 4457 of file fxpkgpnp.hpp.

m_PowerPolTimerExpiredWakeCapableWakeInterruptArrivedOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolTimerExpiredWakeCapableWakeInterruptArrivedOtherStates

staticprivate

Initial value:

=
{
    { PwrPolWakeSuccess, WdfDevStatePwrPolTimerExpiredWakeCapableWakeSucceeded TRAP_ON_EVENT },
    { PwrPolPowerDownFailed, WdfDevStatePwrPolTimerExpiredWakeCapablePowerDownFailedWakeInterruptArrived TRAP_ON_EVENT },
    { PwrPolPowerDown, WdfDevStatePwrPolWaitingArmedWakeInterruptFiredDuringPowerDown },
    { PwrPolNull, WdfDevStatePwrPolNull },
}

Definition at line 4489 of file fxpkgpnp.hpp.

m_PowerPolTimerExpiredWakeCapableWakeSucceededOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolTimerExpiredWakeCapableWakeSucceededOtherStates

staticprivate

Initial value:

=
{
    { PwrPolPowerDownFailed, WdfDevStatePwrPolTimerExpiredWakeCapablePowerDownFailedUsbSS DEBUGGED_EVENT },
    { PwrPolNull, WdfDevStatePwrPolNull },
}

Definition at line 4456 of file fxpkgpnp.hpp.

m_PowerPolTimerExpiredWakeCompletedPowerDownOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolTimerExpiredWakeCompletedPowerDownOtherStates

staticprivate

Initial value:

=
{
    { PwrPolPowerDownFailed, WdfDevStatePwrPolDevicePowerRequestFailed DEBUGGED_EVENT },
    { PwrPolNull,           WdfDevStatePwrPolNull },
}

Definition at line 4462 of file fxpkgpnp.hpp.

m_PowerPolTimerExpiredWakeCompletedPowerUpOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolTimerExpiredWakeCompletedPowerUpOtherStates

staticprivate

Initial value:

=
{
    { PwrPolPowerUpFailed, WdfDevStatePwrPolDevicePowerRequestFailed DEBUGGED_EVENT },
    { PwrPolPowerUpNotSeen, WdfDevStatePwrPolDeviceD0PowerRequestFailed TRAP_ON_EVENT },
    { PwrPolNull, WdfDevStatePwrPolNull },
}

Definition at line 4463 of file fxpkgpnp.hpp.

m_PowerPolWaitingArmedOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolWaitingArmedOtherStates

staticprivate

Initial value:

=
{
    { PwrPolSx, WdfDevStatePwrPolCancelingUsbSSForSystemSleep DEBUGGED_EVENT },
    { PwrPolWakeSuccess, WdfDevStatePwrPolWaitingArmedWakeSucceededCancelUsbSS DEBUGGED_EVENT },
    { PwrPolWakeFailed, WdfDevStatePwrPolWaitingArmedWakeFailedCancelUsbSS DEBUGGED_EVENT },
    { PwrPolStop, WdfDevStatePwrPolStoppingD0CancelUsbSS DEBUGGED_EVENT },
    { PwrPolSurpriseRemove, WdfDevStatePwrPolWaitingArmedStoppingCancelUsbSS DEBUGGED_EVENT },
    { PwrPolS0IdlePolicyChanged, WdfDevStatePwrPolWaitingArmedIoPresentCancelUsbSS  DEBUGGED_EVENT },
    { PwrPolUsbSelectiveSuspendCompleted, WdfDevStatePwrPolIoPresentArmed TRAP_ON_EVENT },
    { PwrPolDevicePowerRequired, WdfDevStatePwrPolWaitingArmedIoPresentCancelUsbSS DEBUGGED_EVENT },
    { PwrPolWakeInterruptFired, WdfDevStatePwrPolWaitingArmedWakeInterruptFired DEBUGGED_EVENT },
    { PwrPolNull, WdfDevStatePwrPolNull },
}

Definition at line 4444 of file fxpkgpnp.hpp.

m_PowerPolWaitingArmedWakeInterruptFiredDuringPowerDownOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolWaitingArmedWakeInterruptFiredDuringPowerDownOtherStates

staticprivate

Initial value:

=
{
    { PwrPolWakeSuccess, WdfDevStatePwrPolWaitingArmedWakeSucceededCancelUsbSS TRAP_ON_EVENT },
    { PwrPolNull, WdfDevStatePwrPolNull },
}

Definition at line 4491 of file fxpkgpnp.hpp.

m_PowerPolWaitingArmedWakeInterruptFiredOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolWaitingArmedWakeInterruptFiredOtherStates

staticprivate

Initial value:

=
{
    { PwrPolWakeSuccess, WdfDevStatePwrPolWaitingArmedWakeSucceededCancelUsbSS TRAP_ON_EVENT },
    { PwrPolNull, WdfDevStatePwrPolNull },
}

Definition at line 4507 of file fxpkgpnp.hpp.

m_PowerPolWaitingUnarmedOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolWaitingUnarmedOtherStates

staticprivate

Initial value:

=
{
    { PwrPolSx, WdfDevStatePwrPolSystemSleepFromDeviceWaitingUnarmed DEBUGGED_EVENT },
    { PwrPolStop, WdfDevStatePwrPolStoppingResetDevice DEBUGGED_EVENT },
    { PwrPolSurpriseRemove, WdfDevStatePwrPolStoppingCancelTimer DEBUGGED_EVENT },
    { PwrPolS0IdlePolicyChanged, WdfDevStatePwrPolS0NoWakePowerUp DEBUGGED_EVENT },
    { PwrPolDevicePowerRequired, WdfDevStatePwrPolS0NoWakePowerUp DEBUGGED_EVENT },
    { PwrPolNull, WdfDevStatePwrPolNull },
}

Definition at line 4430 of file fxpkgpnp.hpp.

m_PowerPolWakeCapableDeviceIdleOtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolWakeCapableDeviceIdleOtherStates

staticprivate

Initial value:

=
{
    { PwrPolSx, WdfDevStatePwrPolDeviceIdleSleeping DEBUGGED_EVENT },
    { PwrPolStop, WdfDevStatePwrPolDeviceIdleStopping TRAP_ON_EVENT },
    { PwrPolSurpriseRemove,WdfDevStatePwrPolDeviceIdleStopping DEBUGGED_EVENT },
    { PwrPolS0IdlePolicyChanged, WdfDevStatePwrPolDeviceIdleReturnToActive TRAP_ON_EVENT },
    { PwrPolIoPresent, WdfDevStatePwrPolDeviceIdleReturnToActive DEBUGGED_EVENT },
    { PwrPolNull, WdfDevStatePwrPolNull },
}

Definition at line 4440 of file fxpkgpnp.hpp.

m_PowerPolWokeFromS0OtherStates

const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_PowerPolWokeFromS0OtherStates

staticprivate

Initial value:

=
{
    { PwrPolPowerUpFailed, WdfDevStatePwrPolDevicePowerRequestFailed DEBUGGED_EVENT },
    { PwrPolPowerUpNotSeen, WdfDevStatePwrPolDeviceD0PowerRequestFailed TRAP_ON_EVENT },
    { PwrPolNull, WdfDevStatePwrPolNull },
}

Definition at line 4447 of file fxpkgpnp.hpp.

m_PowerStateCallbacks

FxPowerStateCallback* FxPkgPnp::m_PowerStateCallbacks

private

Definition at line 4376 of file fxpkgpnp.hpp.

Referenced by FinishInitialize(), FxPkgPnp(), PowerEnterNewState(), and ~FxPkgPnp().

m_PowerStoppedOtherStates

const POWER_EVENT_TARGET_STATE FxPkgPnp::m_PowerStoppedOtherStates

staticprivate

Initial value:

=
{
    { PowerDx,                      WdfDevStatePowerStoppedCompleteDx DEBUGGED_EVENT },
    { PowerEventMaximum,            WdfDevStatePowerNull },
}

Definition at line 4421 of file fxpkgpnp.hpp.

m_PowerThread

FxSystemThread* FxPkgPnp::m_PowerThread

private

Definition at line 4350 of file fxpkgpnp.hpp.

Referenced by CreatePowerThread(), FxPkgPnp(), and ReleasePowerThread().

m_PowerThreadEvent

FxCREvent* FxPkgPnp::m_PowerThreadEvent

private

Definition at line 4354 of file fxpkgpnp.hpp.

Referenced by _PowerThreadInterfaceDereference(), FxPkgPnp(), and ReleasePowerThread().

m_PowerThreadInterface

POWER_THREAD_INTERFACE FxPkgPnp::m_PowerThreadInterface

protected

Definition at line 4213 of file fxpkgpnp.hpp.

Referenced by FxPkgPnp(), HandleQueryInterfaceForPowerThread(), FxPkgFdo::QueryForPowerThread(), QueueToPowerThread(), and ReleasePowerThread().

m_PowerThreadInterfaceReferenceCount

LONG FxPkgPnp::m_PowerThreadInterfaceReferenceCount

private

Definition at line 4352 of file fxpkgpnp.hpp.

Referenced by _PowerThreadInterfaceDereference(), _PowerThreadInterfaceReference(), FxPkgPnp(), and ReleasePowerThread().

m_QueryInterfaceHead

SINGLE_LIST_ENTRY FxPkgPnp::m_QueryInterfaceHead

Definition at line 4122 of file fxpkgpnp.hpp.

Referenced by AddQueryInterface(), Dispose(), FxPkgPnp(), and HandleQueryInterface().

m_QueryInterfaceLock

FxWaitLockInternal FxPkgPnp::m_QueryInterfaceLock

Definition at line 4120 of file fxpkgpnp.hpp.

Referenced by AddQueryInterface(), Dispose(), HandleQueryInterface(), and Initialize().

m_ReleaseHardwareAfterDescendantsOnFailure

BOOLEAN FxPkgPnp::m_ReleaseHardwareAfterDescendantsOnFailure

protected

Definition at line 4277 of file fxpkgpnp.hpp.

Referenced by FxPkgPnp(), Initialize(), IsDefaultReleaseHardwareOrder(), PowerSendPowerDownFailureEvent(), and PowerSendPowerUpFailureEvent().

m_RemovalDeviceList

FxRelatedDeviceList* FxPkgPnp::m_RemovalDeviceList

Definition at line 4115 of file fxpkgpnp.hpp.

Referenced by AddRemovalDevice(), ClearRemovalDevicesList(), FxPkgPnp(), FxPkgFdo::PnpQueryDeviceRelations(), FxPkgPdo::PnpQueryDeviceRelations(), RemoveRemovalDevice(), and ~FxPkgPnp().

m_RemoveEventUm

MxEvent FxPkgPnp::m_RemoveEventUm

private

Definition at line 4305 of file fxpkgpnp.hpp.

Referenced by Initialize().

m_Resources

FxCmResList* FxPkgPnp::m_Resources

protected

Definition at line 4220 of file fxpkgpnp.hpp.

Referenced by __drv_when(), FxPkgPnp(), GetTranslatedResourceList(), Initialize(), PnpMatchResources(), PnpReleaseHardware(), FxPkgFdo::PnpSendStartDeviceDownTheStackOverload(), ValidateCmResource(), and ~FxPkgPnp().

m_ResourcesRaw

FxCmResList* FxPkgPnp::m_ResourcesRaw

protected

Definition at line 4225 of file fxpkgpnp.hpp.

Referenced by __drv_when(), FxPkgPnp(), GetRawResourceList(), Initialize(), PnpMatchResources(), FxPkgFdo::PnpSendStartDeviceDownTheStackOverload(), ValidateCmResource(), and ~FxPkgPnp().

m_RestartCountMaximum

const ULONG FxPkgPnp::m_RestartCountMaximum = 5

staticprivate

Definition at line 4539 of file fxpkgpnp.hpp.

Referenced by PnpIncrementRestartCountLogic().

m_RestartCountName

const PWCHAR FxPkgPnp::m_RestartCountName = RESTART_COUNT_NAME

staticprivate

Definition at line 4527 of file fxpkgpnp.hpp.

m_RestartStartAchievedName

const PWCHAR FxPkgPnp::m_RestartStartAchievedName = RESTART_START_ACHIEVED_NAME

staticprivate

Definition at line 4525 of file fxpkgpnp.hpp.

m_RestartStartTimeName

const PWCHAR FxPkgPnp::m_RestartStartTimeName = RESTART_START_TIME_NAME

staticprivate

Definition at line 4526 of file fxpkgpnp.hpp.

m_RestartTimePeriodMaximum

const ULONG FxPkgPnp::m_RestartTimePeriodMaximum = 60

staticprivate

Definition at line 4533 of file fxpkgpnp.hpp.

Referenced by PnpIncrementRestartCountLogic().

m_SelfManagedIoMachine

FxSelfManagedIoMachine* FxPkgPnp::m_SelfManagedIoMachine

Definition at line 4155 of file fxpkgpnp.hpp.

Referenced by FxPkgPnp(), PnpCleanupForRemove(), PnpEventRemovedCommonCode(), PowerGotoDx(), RegisterCallbacks(), and ~FxPkgPnp().

m_SetDeviceRemoveProcessed

BYTE FxPkgPnp::m_SetDeviceRemoveProcessed

protected

Definition at line 4198 of file fxpkgpnp.hpp.

Referenced by FxPkgPnp(), and PnpProcessEventInner().

m_SharedPower

SharedPowerData FxPkgPnp::m_SharedPower

Definition at line 4161 of file fxpkgpnp.hpp.

Referenced by DispatchWaitWake(), FxPkgPdo::FxPkgPdo(), FxPkgPnp(), PnpCleanupForRemove(), PowerCompletePendedWakeIrp(), PowerGotoDxIoStopped(), PowerIsWakeRequestPresent(), PowerMakeWakeRequestNonCancelable(), PowerPolicyCancelWaitWake(), and FxWatchdog::StartTimer().

m_SpecialFileCount

LONG FxPkgPnp::m_SpecialFileCount[WdfSpecialFileMax-1]

Definition at line 4139 of file fxpkgpnp.hpp.

Referenced by AdjustUsageCount(), FxPkgPnp(), and GetUsageCount().

m_SpecialSupport

BOOLEAN FxPkgPnp::m_SpecialSupport[WdfSpecialFileMax-1]

Definition at line 4133 of file fxpkgpnp.hpp.

Referenced by FxPkgPnp(), IsUsageSupported(), and SetUsageSupport().

m_SystemPowerAction

UCHAR FxPkgPnp::m_SystemPowerAction

protected

Definition at line 4242 of file fxpkgpnp.hpp.

Referenced by FxPkgPnp(), GetSystemPowerAction(), PowerSetDevicePowerState(), and SetPendingDevicePowerIrp().

m_SystemPowerState

BYTE FxPkgPnp::m_SystemPowerState

Definition at line 4102 of file fxpkgpnp.hpp.

Referenced by FxPkgFdo::DispatchSystemSetPower(), FxPkgPdo::DispatchSystemSetPower(), FxPkgPnp(), FxPkgPdo::PowerEnableWakeAtBusOverload(), PowerGotoDxIoStopped(), and PowerGotoDxIoStoppedNP().

m_SystemWake

BYTE FxPkgPnp::m_SystemWake

protected

Definition at line 4188 of file fxpkgpnp.hpp.

Referenced by PowerPolicyGetDeviceDeepestDeviceWakeState(), PowerPolicyGetDeviceDeepestSystemWakeState(), PowerPolicySetSxWakeSettings(), and QueryForCapabilities().

m_SystemWokenByWakeInterrupt

BOOLEAN FxPkgPnp::m_SystemWokenByWakeInterrupt

private

Definition at line 4330 of file fxpkgpnp.hpp.

Referenced by FxPkgPnp(), and PowerPolicySendWaitWakeRequest().

m_UsageDependentDeviceList

FxRelatedDeviceList* FxPkgPnp::m_UsageDependentDeviceList

Definition at line 4113 of file fxpkgpnp.hpp.

Referenced by AddUsageDevice(), FxPkgPnp(), PnpDeviceUsageNotification(), RemoveUsageDevice(), and ~FxPkgPnp().

m_WakeInterruptCount

ULONG FxPkgPnp::m_WakeInterruptCount

private

Definition at line 4316 of file fxpkgpnp.hpp.

Referenced by FxPkgPnp(), SendEventToAllWakeInterrupts(), SupportsWakeInterrupt(), and WakeInterruptCreated().

m_WakeInterruptPendingAckCount

ULONG FxPkgPnp::m_WakeInterruptPendingAckCount

private

Definition at line 4323 of file fxpkgpnp.hpp.

Referenced by AckPendingWakeInterruptOperation(), FxPkgPnp(), and SendEventToAllWakeInterrupts().

m_WakeInterruptsKeepConnected

BOOLEAN FxPkgPnp::m_WakeInterruptsKeepConnected

private

Definition at line 4339 of file fxpkgpnp.hpp.

Referenced by FxPkgPnp(), and PowerGotoDxIoStopped().

m_WakePendingNPOtherStates

const POWER_EVENT_TARGET_STATE FxPkgPnp::m_WakePendingNPOtherStates

staticprivate

Initial value:

=
{
    { PowerImplicitD0,              WdfDevStatePowerCheckParentStateArmedForWakeNP TRAP_ON_EVENT },
    { PowerImplicitD3,              WdfDevStatePowerDxStoppedDisarmWakeNP DEBUGGED_EVENT },
    { PowerEventMaximum,            WdfDevStatePowerNull },
}

Definition at line 4419 of file fxpkgpnp.hpp.

m_WakePendingOtherStates

const POWER_EVENT_TARGET_STATE FxPkgPnp::m_WakePendingOtherStates

staticprivate

Initial value:

=
{
    { PowerImplicitD0,              WdfDevStatePowerCheckParentStateArmedForWake TRAP_ON_EVENT },
    { PowerImplicitD3,              WdfDevStatePowerDxStoppedDisarmWake DEBUGGED_EVENT },
    { PowerEventMaximum,            WdfDevStatePowerNull },
}

Definition at line 4418 of file fxpkgpnp.hpp.

m_WdfNotPowerPolicyOwnerStates

const NOT_POWER_POLICY_OWNER_STATE_TABLE FxPkgPnp::m_WdfNotPowerPolicyOwnerStates

staticprivate

Definition at line 4383 of file fxpkgpnp.hpp.

Referenced by GetNotPowerPolicyOwnerTableEntry().

m_WdfPnpStates

const PNP_STATE_TABLE FxPkgPnp::m_WdfPnpStates

staticprivate

Definition at line 4380 of file fxpkgpnp.hpp.

Referenced by GetPnpTableEntry(), and PnpCheckAssumptions().

m_WdfPowerPolicyStates

const POWER_POLICY_STATE_TABLE FxPkgPnp::m_WdfPowerPolicyStates

staticprivate

Definition at line 4382 of file fxpkgpnp.hpp.

Referenced by GetPowerPolicyTableEntry(), and PowerPolicyCheckAssumptions().

m_WdfPowerStates

const POWER_STATE_TABLE FxPkgPnp::m_WdfPowerStates

staticprivate

Definition at line 4381 of file fxpkgpnp.hpp.

Referenced by GetPowerTableEntry(), and PowerCheckAssumptions().

---

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

• sdk/lib/drivers/wdf/shared/inc/private/common/fxpkgpnp.hpp
• sdk/lib/drivers/wdf/shared/irphandlers/pnp/fxpkgpnp.cpp
• sdk/lib/drivers/wdf/shared/irphandlers/pnp/km/fxpkgpnpkm.cpp
• sdk/lib/drivers/wdf/shared/irphandlers/pnp/km/pnpstatemachinekm.cpp
• sdk/lib/drivers/wdf/shared/irphandlers/pnp/km/powerpolicystatemachinekm.cpp
• sdk/lib/drivers/wdf/shared/irphandlers/pnp/km/powerstatemachinekm.cpp
• sdk/lib/drivers/wdf/shared/irphandlers/pnp/notpowerpolicyownerstatemachine.cpp
• sdk/lib/drivers/wdf/shared/irphandlers/pnp/pnpstatemachine.cpp
• sdk/lib/drivers/wdf/shared/irphandlers/pnp/powerpolicystatemachine.cpp
• sdk/lib/drivers/wdf/shared/irphandlers/pnp/powerstatemachine.cpp
• sdk/lib/drivers/wdf/shared/irphandlers/pnp/um/fxpkgpnpum.cpp
• sdk/lib/drivers/wdf/shared/irphandlers/pnp/um/pnpstatemachineum.cpp
• sdk/lib/drivers/wdf/shared/irphandlers/pnp/um/powerpolicystatemachineum.cpp
• sdk/lib/drivers/wdf/shared/irphandlers/pnp/um/powerstatemachineum.cpp