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;
}