FxPkgFdo Class Reference

#include <fxpkgfdo.hpp>

Inheritance diagram for FxPkgFdo:

Collaboration diagram for FxPkgFdo:

Public Member Functions
_Must_inspect_result_ NTSTATUS	RegisterCallbacks (__in PWDF_FDO_EVENT_CALLBACKS DispatchTable)
_Must_inspect_result_ NTSTATUS	CreateDefaultDeviceList (__in PWDF_CHILD_LIST_CONFIG ListConfig, __in PWDF_OBJECT_ATTRIBUTES ListAttributes)
virtual _Must_inspect_result_ NTSTATUS	Initialize (__in PWDFDEVICE_INIT DeviceInit)
_Must_inspect_result_ NTSTATUS	PostCreateDeviceInitialize (VOID)
_Must_inspect_result_ NTSTATUS	SetFilter (__in BOOLEAN Value)
BOOLEAN	IsFilter (VOID)
Public Member Functions inherited from FxPkgPnp
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)

Static Public Member Functions
static _Must_inspect_result_ NTSTATUS	_Create (__in PFX_DRIVER_GLOBALS pGlobals, __in CfxDevice *Device, __deref_out FxPkgFdo **PkgFdo)
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)

Public Attributes
FxChildList *	m_DefaultDeviceList
FxChildList *	m_StaticDeviceList
FxIoTarget *	m_DefaultTarget
FxIoTargetSelf *	m_SelfTarget
Public Attributes inherited from FxPkgPnp
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

Static Public Attributes
static MdCompletionRoutineType	RaiseDevicePowerCompletion

Protected Member Functions
	~FxPkgFdo ()
Protected Member Functions inherited from FxPkgPnp
	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 STDCALL	_PnpFilteredStartDeviceCompletionRoutine (__in MdDeviceObject DeviceObject, __inout MdIrp Irp, __inout PVOID Context)
static _Must_inspect_result_ NTSTATUS STDCALL	_PnpStartDeviceCompletionRoutine (__in MdDeviceObject DeviceObject, __inout MdIrp Irp, __inout PVOID Context)
Static Protected Member Functions inherited from FxPkgPnp
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)

Static Protected Attributes
static MdCompletionRoutineType	_SystemPowerS0Completion
static MdCompletionRoutineType	_SystemPowerSxCompletion
Static Protected Attributes inherited from FxPkgPnp
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
	FxPkgFdo (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in CfxDevice *Device)
virtual _Must_inspect_result_ NTSTATUS	SendIrpSynchronously (__inout FxIrp *Irp)
virtual _Must_inspect_result_ NTSTATUS	FireAndForgetIrp (__inout FxIrp *Irp)
_Must_inspect_result_ NTSTATUS	PnpQueryDeviceRelations (__inout FxIrp *Irp)
_Must_inspect_result_ NTSTATUS	PnpQueryCapabilities (__inout FxIrp *Irp)
VOID	HandleQueryCapabilities (__inout FxIrp *Irp)
VOID	HandleQueryCapabilitiesCompletion (__inout FxIrp *Irp)
_Must_inspect_result_ NTSTATUS	PnpFilterResourceRequirements (__inout FxIrp *Irp)
VOID	HandleQueryPnpDeviceStateCompletion (__inout FxIrp *Irp)
virtual BOOLEAN	PnpSendStartDeviceDownTheStackOverload (VOID)
virtual WDF_DEVICE_PNP_STATE	PnpEventEjectHardwareOverload (VOID)
virtual WDF_DEVICE_PNP_STATE	PnpEventCheckForDevicePresenceOverload (VOID)
virtual WDF_DEVICE_PNP_STATE	PnpEventPdoRemovedOverload (VOID)
virtual WDF_DEVICE_PNP_STATE	PnpGetPostRemoveState (VOID)
virtual WDF_DEVICE_PNP_STATE	PnpEventFdoRemovedOverload (VOID)
virtual _Must_inspect_result_ NTSTATUS	PowerCheckParentOverload (__out BOOLEAN *ParentOn)
virtual WDF_DEVICE_POWER_STATE	PowerCheckDeviceTypeOverload (VOID)
virtual WDF_DEVICE_POWER_STATE	PowerCheckDeviceTypeNPOverload (VOID)
virtual VOID	PowerParentPowerDereference (VOID)
_Must_inspect_result_ NTSTATUS	DispatchSystemSetPower (__in FxIrp *Irp)
_Must_inspect_result_ NTSTATUS	DispatchDeviceSetPower (__in FxIrp *Irp)
_Must_inspect_result_ NTSTATUS	DispatchSystemQueryPower (__in FxIrp *Irp)
_Must_inspect_result_ NTSTATUS	DispatchDeviceQueryPower (__in FxIrp *Irp)
_Must_inspect_result_ NTSTATUS	RaiseDevicePower (__in FxIrp *Irp)
_Must_inspect_result_ NTSTATUS	LowerDevicePower (__in FxIrp *Irp)
virtual VOID	PowerReleasePendingDeviceIrp (__in BOOLEAN IrpMustBePresent=TRUE)
virtual _Must_inspect_result_ NTSTATUS	ProcessRemoveDeviceOverload (__inout FxIrp *Irp)
virtual VOID	DeleteSymbolicLinkOverload (__in BOOLEAN GracefulRemove)
virtual VOID	QueryForReenumerationInterface (VOID)
virtual VOID	ReleaseReenumerationInterface (VOID)
virtual _Must_inspect_result_ NTSTATUS	AskParentToRemoveAndReenumerate (VOID)
virtual _Must_inspect_result_ NTSTATUS	QueryForPowerThread (VOID)
virtual const PFN_PNP_POWER_CALLBACK *	GetDispatchPnp (VOID)
virtual const PFN_PNP_POWER_CALLBACK *	GetDispatchPower (VOID)
_Must_inspect_result_ NTSTATUS	QueryForDsfInterface (VOID)

Static Private Member Functions
static _Must_inspect_result_ NTSTATUS	_PnpPassDown (__in FxPkgPnp *This, __inout FxIrp *Irp)
static _Must_inspect_result_ NTSTATUS	_PnpSurpriseRemoval (__inout FxPkgPnp *This, __inout FxIrp *Irp)
static _Must_inspect_result_ NTSTATUS	_PnpQueryDeviceRelations (__inout FxPkgPnp *This, __inout FxIrp *Irp)
static _Must_inspect_result_ NTSTATUS	_PnpQueryInterface (__inout FxPkgPnp *This, __inout FxIrp *Irp)
static _Must_inspect_result_ NTSTATUS	_PnpQueryCapabilities (__inout FxPkgPnp *This, __inout FxIrp *Irp)
static _Must_inspect_result_ NTSTATUS	_PnpQueryCapabilitiesCompletionRoutine (__in MdDeviceObject DeviceObject, __inout MdIrp Irp, __inout PVOID Context)
static _Must_inspect_result_ NTSTATUS	_PnpFilterResourceRequirements (__inout FxPkgPnp *This, __inout FxIrp *Irp)
static _Must_inspect_result_ NTSTATUS	_PnpQueryPnpDeviceState (__inout FxPkgPnp *This, __inout FxIrp *Irp)
static _Must_inspect_result_ NTSTATUS	_PnpQueryPnpDeviceStateCompletionRoutine (__in MdDeviceObject DeviceObject, __inout MdIrp Irp, __inout PVOID Context)
static _Must_inspect_result_ NTSTATUS	_PowerPassDown (__inout FxPkgPnp *This, __in FxIrp *Irp)
static _Must_inspect_result_ NTSTATUS	_DispatchSetPower (__inout FxPkgPnp *This, __in FxIrp *Irp)
static _Must_inspect_result_ NTSTATUS	_DispatchQueryPower (__inout FxPkgPnp *This, __in FxIrp *Irp)

Private Attributes
REENUMERATE_SELF_INTERFACE_STANDARD	m_SurpriseRemoveAndReenumerateSelfInterface
FxPnpDeviceFilterResourceRequirements	m_DeviceFilterAddResourceRequirements
FxPnpDeviceFilterResourceRequirements	m_DeviceFilterRemoveResourceRequirements
FxPnpDeviceRemoveAddedResources	m_DeviceRemoveAddedResources
BOOLEAN	m_Filter

Static Private Attributes
static const PFN_PNP_POWER_CALLBACK	m_FdoPnpFunctionTable [IRP_MN_SURPRISE_REMOVAL+1]
static const PFN_PNP_POWER_CALLBACK	m_FdoPowerFunctionTable [IRP_MN_QUERY_POWER+1]

Additional Inherited Members
Protected Attributes inherited from FxPkgPnp
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
};

Detailed Description

Definition at line 34 of file fxpkgfdo.hpp.

Constructor & Destructor Documentation

FxPkgFdo()

FxPkgFdo::FxPkgFdo ( __in PFX_DRIVER_GLOBALS  FxDriverGlobals, __in CfxDevice *  Device  )

private

Definition at line 114 of file fxpkgfdo.cpp.

      :
    FxPkgPnp(FxDriverGlobals, Device, FX_TYPE_PACKAGE_FDO)
/*++
 
Routine Description:
 
    This is the constructor for the FxPkgFdo.  Don't do any initialization
    that might fail here.
 
Arguments:
 
    none
 
Returns:
 
    none
 
--*/
 
{
    m_DefaultDeviceList = NULL;
    m_StaticDeviceList = NULL;
 
    m_DefaultTarget = NULL;
    m_SelfTarget = NULL;
 
    m_BusEnumRetries = 0;
 
    //
    // Since we will always have a valid PDO when we are the FDO, we can do
    // any device interface related activity at any time
    //
    m_DeviceInterfacesCanBeEnabled = TRUE;
 
    m_Filter = FALSE;
 
    RtlZeroMemory(&m_BusInformation, sizeof(m_BusInformation));
 
    RtlZeroMemory(&m_SurpriseRemoveAndReenumerateSelfInterface,
        sizeof(m_SurpriseRemoveAndReenumerateSelfInterface));
}

~FxPkgFdo()

FxPkgFdo::~FxPkgFdo ( )

protected

Definition at line 159 of file fxpkgfdo.cpp.

{
    if (m_DefaultDeviceList != NULL) {
        m_DefaultDeviceList->RELEASE(this);
    }
    if (m_StaticDeviceList != NULL) {
        m_StaticDeviceList->RELEASE(this);
    }
    if (m_SelfTarget != NULL) {
        m_SelfTarget->RELEASE(this);
    }
    if (m_DefaultTarget != NULL) {
        m_DefaultTarget->RELEASE(this);
    }
}

Member Function Documentation

_Create()

_Must_inspect_result_ NTSTATUS FxPkgFdo::_Create ( __in PFX_DRIVER_GLOBALS  pGlobals, __in CfxDevice *  Device, __deref_out FxPkgFdo **  PkgFdo  )

static

Definition at line 195 of file fxpkgfdo.cpp.

{
    NTSTATUS status;
    FxPkgFdo * fxPkgFdo;
    FxEventQueue *eventQueue;
 
    fxPkgFdo = new(DriverGlobals) FxPkgFdo(DriverGlobals, Device);
 
    if (NULL == fxPkgFdo) {
        status = STATUS_INSUFFICIENT_RESOURCES;
        DoTraceLevelMessage(DriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
                            "Memory allocation failed: %!STATUS!", status);
        return status;
    }
 
    //
    // Initialize the event queues in the PnP, power and power policy state
    // machines
    //
    eventQueue = static_cast<FxEventQueue*> (&(fxPkgFdo->m_PnpMachine));
    status = eventQueue->Initialize(DriverGlobals);
    if (!NT_SUCCESS(status)) {
        goto exit;
    }
 
    eventQueue = static_cast<FxEventQueue*> (&(fxPkgFdo->m_PowerMachine));
    status = eventQueue->Initialize(DriverGlobals);
    if (!NT_SUCCESS(status)) {
        goto exit;
    }
 
    eventQueue = static_cast<FxEventQueue*> (&(fxPkgFdo->m_PowerPolicyMachine));
    status = eventQueue->Initialize(DriverGlobals);
    if (!NT_SUCCESS(status)) {
        goto exit;
    }
 
    *PkgFdo = fxPkgFdo;
 
exit:
    if (!NT_SUCCESS(status)) {
        fxPkgFdo->DeleteFromFailedCreate();
    }
 
    return status;
}

Referenced by FxDevice::FdoInitialize().

_DispatchQueryPower()

_Must_inspect_result_ NTSTATUS FxPkgFdo::_DispatchQueryPower ( __inout FxPkgPnp *  This, __in FxIrp *  Irp  )

staticprivate

Definition at line 123 of file fdopower.cpp.

{
    if (Irp->GetParameterPowerType() == SystemPowerState) {
        return ((FxPkgFdo*) This)->DispatchSystemQueryPower(Irp);
    }
    else {
        return ((FxPkgFdo*) This)->DispatchDeviceQueryPower(Irp);
    }
}

_DispatchSetPower()

_Must_inspect_result_ NTSTATUS FxPkgFdo::_DispatchSetPower ( __inout FxPkgPnp *  This, __in FxIrp *  Irp  )

staticprivate

Definition at line 90 of file fdopower.cpp.

{
    if (Irp->GetParameterPowerType() == SystemPowerState) {
        return ((FxPkgFdo*) This)->DispatchSystemSetPower(Irp);
    }
    else {
        return ((FxPkgFdo*) This)->DispatchDeviceSetPower(Irp);
    }
}

_PnpFilteredStartDeviceCompletionRoutine()

_Must_inspect_result_ NTSTATUS STDCALL FxPkgFdo::_PnpFilteredStartDeviceCompletionRoutine ( __in MdDeviceObject  DeviceObject, __inout MdIrp  Irp, __inout PVOID  Context  )

staticprotected

Definition at line 1438 of file fxpkgfdo.cpp.

{
    FxFilteredStartContext *pContext;
    FxPkgFdo* pPkgFdo;
 
    pContext = (FxFilteredStartContext*) Context;
 
    //
    // Save off the package so we can use it after we free the context
    //
    pPkgFdo = pContext->PkgFdo;
 
    delete pContext;
 
    return _PnpStartDeviceCompletionRoutine(DeviceObject, Irp, pPkgFdo);
}

Referenced by PnpSendStartDeviceDownTheStackOverload().

_PnpFilterResourceRequirements()

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

staticprivate

Definition at line 748 of file fxpkgfdo.cpp.

{
    return ((FxPkgFdo*) This)->PnpFilterResourceRequirements(Irp);
}

_PnpPassDown()

_Must_inspect_result_ NTSTATUS FxPkgFdo::_PnpPassDown ( __in FxPkgPnp *  This, __inout FxIrp *  Irp  )

staticprivate

Definition at line 307 of file fxpkgfdo.cpp.

{
    NTSTATUS status;
    FxDevice* device;
    MdIrp pIrp;
 
    device = ((FxPkgFdo*)This)->m_Device;
    pIrp = Irp->GetIrp();
 
    Irp->CopyCurrentIrpStackLocationToNext();
    status = Irp->CallDriver(
        ((FxPkgFdo*)This)->m_Device->GetAttachedDevice());
 
    Mx::MxReleaseRemoveLock(device->GetRemoveLock(),
                            pIrp
                            );
 
    return status;
}

Referenced by _PnpQueryInterface(), FireAndForgetIrp(), and PnpQueryDeviceRelations().

_PnpQueryCapabilities()

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

staticprivate

Definition at line 551 of file fxpkgfdo.cpp.

{
 
 
 
 
 
 
 
 
 
 
 
 
    return ((FxPkgFdo*) This)->PnpQueryCapabilities(Irp);
}

_PnpQueryCapabilitiesCompletionRoutine()

_Must_inspect_result_ NTSTATUS FxPkgFdo::_PnpQueryCapabilitiesCompletionRoutine ( __in MdDeviceObject  DeviceObject, __inout MdIrp  Irp, __inout PVOID  Context  )

staticprivate

Definition at line 227 of file fxpkgfdokm.cpp.

{
    UNREFERENCED_PARAMETER(DeviceObject);
    UNREFERENCED_PARAMETER(Irp);
    UNREFERENCED_PARAMETER(Context);
 
    ASSERTMSG("Not implemented for KMDF\n", FALSE);
 
    return STATUS_NOT_IMPLEMENTED;
}

_PnpQueryDeviceRelations()

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

staticprivate

Definition at line 372 of file fxpkgfdo.cpp.

{
    return ((FxPkgFdo*) This)->PnpQueryDeviceRelations(Irp);
}

_PnpQueryInterface()

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

staticprivate

Definition at line 490 of file fxpkgfdo.cpp.

{
    FxPkgFdo* pThis;
    NTSTATUS status;
    BOOLEAN completeIrp;
 
    pThis = (FxPkgFdo*) This;
 
    DoTraceLevelMessage(pThis->GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
                        "Entering QueryInterface handler");
 
    status = pThis->HandleQueryInterface(Irp, &completeIrp);
 
    DoTraceLevelMessage(pThis->GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
                        "Exiting QueryInterface handler, %!STATUS!",
                        status);
    //
    // If we understand the irp, we'll complete it.  Otherwise we
    // pass it down.
    //
    if (completeIrp == FALSE) {
        status = _PnpPassDown(pThis, Irp);
    }
    else {
        Irp->SetInformation(NULL);
        pThis->CompletePnpRequest(Irp, status);
    }
 
    //
    // Remlock is released in _PnpPassDown and  CompletePnpRequest. If this
    // irp is racing with remove on another thread, it's possible for the device
    // to get deleted right after the lock is released and before anything
    // after this point is executed. So make sure to not touch any memory in
    // the return path.
    //
 
    return status;
}

_PnpQueryPnpDeviceState()

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

staticprivate

Definition at line 305 of file fxpkgfdokm.cpp.

{
    FxPkgFdo* pThis;
    NTSTATUS status;
 
    pThis = (FxPkgFdo*) This;
 
    status = pThis->SendIrpSynchronously(Irp);
 
    if (status == STATUS_NOT_SUPPORTED) {
        //
        // Morph into a successful code so that we process the request
        //
        status = STATUS_SUCCESS;
        Irp->SetStatus(status);
    }
 
    if (NT_SUCCESS(status)) {
        pThis->HandleQueryPnpDeviceStateCompletion(Irp);
    }
    else {
        DoTraceLevelMessage(
            This->GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
            "Lower stack returned error for query pnp device state, %!STATUS!",
            status);
    }
 
    //
    // Since we already sent the request down the stack, we must complete it
    // now.
    //
    return pThis->CompletePnpRequest(Irp, status);
}

_PnpQueryPnpDeviceStateCompletionRoutine()

_Must_inspect_result_ NTSTATUS FxPkgFdo::_PnpQueryPnpDeviceStateCompletionRoutine ( __in MdDeviceObject  DeviceObject, __inout MdIrp  Irp, __inout PVOID  Context  )

staticprivate

Definition at line 288 of file fxpkgfdokm.cpp.

{
    UNREFERENCED_PARAMETER(DeviceObject);
    UNREFERENCED_PARAMETER(Irp);
    UNREFERENCED_PARAMETER(Context);
 
    ASSERTMSG("Not implemented for KMDF\n", FALSE);
 
    return STATUS_NOT_IMPLEMENTED;
}

_PnpStartDeviceCompletionRoutine()

_Must_inspect_result_ NTSTATUS STDCALL FxPkgFdo::_PnpStartDeviceCompletionRoutine ( __in MdDeviceObject  DeviceObject, __inout MdIrp  Irp, __inout PVOID  Context  )

staticprotected

Definition at line 1462 of file fxpkgfdo.cpp.

{
    FxPkgFdo* pThis;
    FxIrp irp(Irp);
 
    UNREFERENCED_PARAMETER(DeviceObject);
 
    pThis = (FxPkgFdo*) Context;
 
    if (NT_SUCCESS(irp.GetStatus())) {
        pThis->SetPendingPnpIrp(&irp);
 
        //
        // Only raise irql if we are the power policy owner.  Only the p.p.o.
        // does this so that we only have one driver in the device stack moving
        // to another thread.
        //
        if (pThis->IsPowerPolicyOwner()) {
            KIRQL irql;
 
            //
            // By raising to dispatch level we are forcing the pnp state machine
            // to move to another thread.  On NT 6.0 PnP supports asynchronous
            // starts, so this will other starts to proceed while WDF processes
            // this device starting.
            //
            Mx::MxRaiseIrql(DISPATCH_LEVEL, &irql);
            pThis->PnpProcessEvent(PnpEventStartDeviceComplete);
            Mx::MxLowerIrql(irql);
        }
        else {
            pThis->PnpProcessEvent(PnpEventStartDeviceComplete);
        }
    }
    else {
        //
        // Just complete the request, the current pnp state can handle the remove
        // which will be sent b/c of the failed start.
        //
        DoTraceLevelMessage(
            pThis->GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
            "PNP start failed with %!STATUS!", irp.GetStatus());
 
        //
        // Process the event *before* completing the irp so that this even is in
        // the queue before the device remove event which will be be processed
        // right after the start irp has been completed.
        //
        pThis->PnpProcessEvent(PnpEventStartDeviceFailed);
 
        pThis->CompletePnpRequest(&irp, irp.GetStatus());
    }
 
    return STATUS_MORE_PROCESSING_REQUIRED;
}

Referenced by _PnpFilteredStartDeviceCompletionRoutine(), and PnpSendStartDeviceDownTheStackOverload().

_PnpSurpriseRemoval()

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

staticprivate

Definition at line 345 of file fxpkgfdo.cpp.

{
    return ((FxPkgFdo*) This)->PnpSurpriseRemoval(Irp);
}

_PowerPassDown()

_Must_inspect_result_ NTSTATUS FxPkgFdo::_PowerPassDown ( __inout FxPkgPnp *  This, __in FxIrp *  Irp  )

staticprivate

Definition at line 43 of file fdopower.cpp.

{
    FxPkgFdo* pThis;
    NTSTATUS status;
    MdIrp pIrp;
 
    pIrp = Irp->GetIrp();
    pThis = (FxPkgFdo*) This;
 
    //
    // FDOs don't handle this IRP, so simply pass it down.
    //
    Irp->StartNextPowerIrp();
    Irp->CopyCurrentIrpStackLocationToNext();
 
    status = Irp->PoCallDriver(pThis->m_Device->GetAttachedDevice());
 
    Mx::MxReleaseRemoveLock(pThis->m_Device->GetRemoveLock(),
                            pIrp);
 
    return status;
}

Referenced by DispatchDeviceQueryPower(), DispatchSystemQueryPower(), DispatchSystemSetPower(), FireAndForgetIrp(), and PowerReleasePendingDeviceIrp().

AskParentToRemoveAndReenumerate()

_Must_inspect_result_ NTSTATUS FxPkgFdo::AskParentToRemoveAndReenumerate ( VOID  )

privatevirtual

Implements FxPkgPnp.

Definition at line 567 of file fxpkgfdokm.cpp.

{
    PREENUMERATE_SELF_INTERFACE_STANDARD pInterface;
 
    pInterface = &m_SurpriseRemoveAndReenumerateSelfInterface;
 
    if (pInterface->SurpriseRemoveAndReenumerateSelf != NULL) {
        pInterface->SurpriseRemoveAndReenumerateSelf(pInterface->Context);
 
        return STATUS_SUCCESS;
    }
 
    return STATUS_NOT_SUPPORTED;
}

CreateDefaultDeviceList()

_Must_inspect_result_ NTSTATUS FxPkgFdo::CreateDefaultDeviceList	(	__in PWDF_CHILD_LIST_CONFIG	ListConfig,
		__in PWDF_OBJECT_ATTRIBUTES	ListAttributes
	)

Definition at line 816 of file fxpkgfdo.cpp.

{
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
    WDFCHILDLIST hList;
    size_t totalDescriptionSize = 0;
    NTSTATUS status;
 
    pFxDriverGlobals = GetDriverGlobals();
 
    ASSERT(m_EnumInfo != NULL);
 
    //
    // This should not fail, we already validated the total size when we
    // validated the config (we just had no place to store the total size, so
    // we recompute it again).
    //
    status = FxChildList::_ComputeTotalDescriptionSize(
        pFxDriverGlobals,
        ListConfig,
        &totalDescriptionSize
        );
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    status = FxChildList::_CreateAndInit(&m_DefaultDeviceList,
                                         pFxDriverGlobals,
                                         ListAttributes,
                                         totalDescriptionSize,
                                         m_Device,
                                         ListConfig);
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    status = m_DefaultDeviceList->Commit(ListAttributes,
                                         (WDFOBJECT*)&hList,
                                         m_Device);
 
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
                            "Could not convert object to handle");
        m_DefaultDeviceList->DeleteFromFailedCreate();
        m_DefaultDeviceList = NULL;
        return status;
    }
 
    //
    // This will be released in the destructor
    //
    m_DefaultDeviceList->ADDREF(this);
 
    return status;
}

Referenced by FxDevice::FdoInitialize().

DeleteSymbolicLinkOverload()

VOID FxPkgFdo::DeleteSymbolicLinkOverload ( __in BOOLEAN  GracefulRemove )

privatevirtual

Definition at line 1280 of file fxpkgfdo.cpp.

{
    UNREFERENCED_PARAMETER(GracefulRemove);
 
    //
    // We always remove the symbolic link for an FDO since there is no presence
    // state to check.
    //
    m_Device->DeleteSymbolicLink();
}

DispatchDeviceQueryPower()

_Must_inspect_result_ NTSTATUS FxPkgFdo::DispatchDeviceQueryPower ( __in FxIrp *  Irp )

private

Definition at line 446 of file fdopower.cpp.

{
    //
    // Either the framework is the power policy owner and we wouldn't be sending
    // a device query power or we are a subordinate will do what the power
    // policy owner wants 100% of the time.
    //
    Irp->SetStatus(STATUS_SUCCESS);
 
    //
    // This will release the remove lock
    //
    return _PowerPassDown(this, Irp);
}

DispatchDeviceSetPower()

_Must_inspect_result_ NTSTATUS FxPkgFdo::DispatchDeviceSetPower ( __in FxIrp *  Irp )

private

Definition at line 299 of file fdopower.cpp.

{
    NTSTATUS status;
 
    if (IsPowerPolicyOwner()) {
        if (m_PowerPolicyMachine.m_Owner->m_RequestedPowerUpIrp == FALSE &&
            m_PowerPolicyMachine.m_Owner->m_RequestedPowerDownIrp == FALSE) {
            //
            // A power irp arrived, but we did not request it.  log and bugcheck
            //
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                "Received set device power irp 0x%p on WDFDEVICE 0x%p !devobj 0x%p, "
                "but the irp was not requested by the device (the power policy owner)",
                Irp->GetIrp(), m_Device->GetHandle(),
                m_Device->GetDeviceObject());
 
            FxVerifierBugCheck(GetDriverGlobals(),  // globals
                   WDF_POWER_MULTIPLE_PPO, // specific type
                   (ULONG_PTR)m_Device->GetDeviceObject(), //parm 2
                   (ULONG_PTR)Irp->GetIrp());  // parm 3
 
            /* NOTREACHED */
        }
 
        //
        // We are no longer requesting a power irp because we received the one
        // we requested.
        //
        if (m_PowerPolicyMachine.m_Owner->m_RequestedPowerUpIrp) {
            m_PowerPolicyMachine.m_Owner->m_RequestedPowerUpIrp = FALSE;
        } else {
            m_PowerPolicyMachine.m_Owner->m_RequestedPowerDownIrp = FALSE;
        }
    }
 
    //
    // Determine if we are raising or lowering the device power state.
    //
    if (Irp->GetParameterPowerStateDeviceState() == PowerDeviceD0) {
        status = RaiseDevicePower(Irp);
    }
    else {
        status = LowerDevicePower(Irp);
    }
 
    return status;
}

DispatchSystemQueryPower()

_Must_inspect_result_ NTSTATUS FxPkgFdo::DispatchSystemQueryPower ( __in FxIrp *  Irp )

private

Definition at line 417 of file fdopower.cpp.

{
    if (PowerPolicyIsWakeEnabled()) {
        NTSTATUS status;
 
        status = PowerPolicyHandleSystemQueryPower(
            Irp->GetParameterPowerStateSystemState()
            );
 
        Irp->SetStatus(status);
 
        if (!NT_SUCCESS(status)) {
            return CompletePowerRequest(Irp, status);
        }
    }
 
    //
    // Passing down the irp because one of the following
    // a) We don't care b/c we don't control the power policy
    // b) we are not enabled for arming for wake from Sx
    // c) we can wake from the queried S state
    //
    return _PowerPassDown(this, Irp);
}

DispatchSystemSetPower()

_Must_inspect_result_ NTSTATUS FxPkgFdo::DispatchSystemSetPower ( __in FxIrp *  Irp )

private

Definition at line 236 of file fdopower.cpp.

{
    NTSTATUS status;
    MxDeviceObject deviceObject(m_Device->GetDeviceObject());
 
    m_SystemPowerState = (BYTE) Irp->GetParameterPowerStateSystemState();
    deviceObject.SetPowerState(SystemPowerState,
                               Irp->GetParameterPowerState());
 
    if (IsPowerPolicyOwner()) {
        //
        // If we are going to S0, we just notify the power policy state machine
        // and then let the request go (per the fast resume spec).  Otherwise,
        // send the request down and on the way up, send the Dx request.
        //
        if (m_SystemPowerState == PowerSystemWorking) {
            //
            // Post the event into the state machine when the irp is going up
            // the stack.  See the comment in _SystemPowerS0Completion for more
            // detail as to why.
            //
            Irp->CopyCurrentIrpStackLocationToNext();
            Irp->SetCompletionRoutineEx(deviceObject.GetObject(),
                                        _SystemPowerS0Completion,
                                        this);
 
            return Irp->PoCallDriver(m_Device->GetAttachedDevice());
        }
        else {
            //
            // Stash away the irp for the power policy state machine.  We will
            // post the event to the power policy state machine when the S irp
            // completes back to this driver.
            //
            SetPendingSystemPowerIrp(Irp);
 
            Irp->CopyCurrentIrpStackLocationToNext();
            Irp->SetCompletionRoutineEx(deviceObject.GetObject(),
                                        _SystemPowerSxCompletion,
                                        this);
 
            Irp->PoCallDriver(m_Device->GetAttachedDevice());
 
            status = STATUS_PENDING;
        }
    }
    else {
        //
        // We don't do anything with S irps if we are not the power policy
        // owner.
        //
        // This will release the remove lock as well.
        //
        status = _PowerPassDown(this, Irp);
    }
 
    return status;
}

FireAndForgetIrp()

_Must_inspect_result_ NTSTATUS FxPkgFdo::FireAndForgetIrp ( __inout FxIrp *  Irp )

privatevirtual

Definition at line 276 of file fxpkgfdo.cpp.

{
    if (Irp->GetMajorFunction() == IRP_MJ_POWER) {
        return _PowerPassDown(this, Irp);
    }
    else {
        return _PnpPassDown(this, Irp);
    }
}

GetDispatchPnp()

virtual const PFN_PNP_POWER_CALLBACK * FxPkgFdo::GetDispatchPnp ( VOID  )

inlineprivatevirtual

Implements FxPkgPnp.

Definition at line 428 of file fxpkgfdo.hpp.

    {
        return m_FdoPnpFunctionTable;
    }

GetDispatchPower()

virtual const PFN_PNP_POWER_CALLBACK * FxPkgFdo::GetDispatchPower ( VOID  )

inlineprivatevirtual

Implements FxPkgPnp.

Definition at line 437 of file fxpkgfdo.hpp.

    {
        return m_FdoPowerFunctionTable;
    }

HandleQueryCapabilities()

VOID FxPkgFdo::HandleQueryCapabilities ( __inout FxIrp *  Irp )

private

Definition at line 572 of file fxpkgfdo.cpp.

{
    PDEVICE_CAPABILITIES pCaps;
    LONG pnpCaps;
 
    DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
                        "Entering QueryCapabilities handler");
 
    pCaps = Irp->GetParameterDeviceCapabilities();
 
    pnpCaps = GetPnpCapsInternal();
 
    //
    // Add Capabilities.  These need to be done as the IRP goes down, since
    // lower drivers need to see them.
    //
    if ((pCaps->Size >= sizeof(DEVICE_CAPABILITIES)) && (pCaps->Version == 1)) {
        SET_PNP_CAP_IF_TRUE(pnpCaps, pCaps, LockSupported);
        SET_PNP_CAP_IF_TRUE(pnpCaps, pCaps, EjectSupported);
        SET_PNP_CAP_IF_TRUE(pnpCaps, pCaps, Removable);
        SET_PNP_CAP_IF_TRUE(pnpCaps, pCaps, DockDevice);
        SET_PNP_CAP_IF_TRUE(pnpCaps, pCaps, SurpriseRemovalOK);
        SET_PNP_CAP_IF_TRUE(pnpCaps, pCaps, NoDisplayInUI);
        //
        // If the driver has declared a wake capable interrupt,
        // we need to set this bit in the capabilities so that
        // ACPI will relinquish control of wake responsiblity
        //
        if (SupportsWakeInterrupt()) {
            pCaps->WakeFromInterrupt = TRUE;
        }
    }
 
    DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
                        "Exiting QueryCapabilities handler");
    return;
}

Referenced by PnpQueryCapabilities().

HandleQueryCapabilitiesCompletion()

VOID FxPkgFdo::HandleQueryCapabilitiesCompletion ( __inout FxIrp *  Irp )

private

Definition at line 613 of file fxpkgfdo.cpp.

{
    PDEVICE_CAPABILITIES pCaps;
    LONG pnpCaps;
    ULONG i;
 
    DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
                        "Entering QueryCapabilities completion handler");
 
    pCaps = Irp->GetParameterDeviceCapabilities();
 
    pnpCaps = GetPnpCapsInternal();
 
    //
    // Confirm this is a valid DeviceCapabilities structure.
    //
    ASSERT(pCaps->Size >= sizeof(DEVICE_CAPABILITIES));
    ASSERT(pCaps->Version >= 1);
 
    if ((pCaps->Size >= sizeof(DEVICE_CAPABILITIES)) &&
        (pCaps->Version == 1)) {
        ULONG states;
 
        //
        // Remove Capabilities
        //
 
        //
        // Re-add SOME capibilties that the bus driver may have accidentally
        // stomped.
 
 
 
 
 
        SET_PNP_CAP_IF_FALSE(pnpCaps, pCaps, LockSupported);
        SET_PNP_CAP_IF_FALSE(pnpCaps, pCaps, EjectSupported);
        SET_PNP_CAP_IF_FALSE(pnpCaps, pCaps, DockDevice);
 
        SET_PNP_CAP(pnpCaps, pCaps, Removable);
        SET_PNP_CAP(pnpCaps, pCaps, SurpriseRemovalOK);
 
        //
        // The DeviceState array contains a table of D states that correspond
        // to a given S state.  If the driver writer initialized entries of the
        // array, and if the new value is a deeper sleep state than the
        // original, we will use the new driver supplied value.
        //
        states = m_PowerCaps.States;
 
        for (i = PowerSystemWorking; i < PowerSystemMaximum; i++) {
            DEVICE_POWER_STATE state;
 
            //
            // PowerDeviceMaximum indicates to use the default value
            //
            // We are only allowed to deepen the D states, not lighten them,
            // hence the > compare.
            //
            state = _GetPowerCapState(i, states);
 
            if (state != PowerDeviceMaximum && state > pCaps->DeviceState[i]) {
                pCaps->DeviceState[i] = state;
            }
        }
 
        //
        // If the driver supplied SystemWake value is lighter than the current
        // value, then use the driver supplied value.
        //
        // PowerSystemMaximum indicates to use the default value
        //
        // We are only allowed to lighten the S state, not deepen it, hence
        // the < compare.
        //
        if (m_PowerCaps.SystemWake != PowerSystemMaximum &&
            m_PowerCaps.SystemWake < pCaps->SystemWake) {
            pCaps->SystemWake = (SYSTEM_POWER_STATE) m_PowerCaps.SystemWake;
        }
 
        //
        // Same for DeviceWake
        //
        if (m_PowerCaps.DeviceWake != PowerDeviceMaximum &&
            m_PowerCaps.DeviceWake < pCaps->DeviceWake) {
            pCaps->DeviceWake = (DEVICE_POWER_STATE) m_PowerCaps.DeviceWake;
        }
 
        //
        // Set the Device wake up latencies.  A value of -1 indicates to
        // use the default values provided by the lower stack.
        //
        if (m_PowerCaps.D1Latency != (ULONG) -1 &&
            m_PowerCaps.D1Latency > pCaps->D1Latency) {
            pCaps->D1Latency = m_PowerCaps.D1Latency;
        }
 
        if (m_PowerCaps.D2Latency != (ULONG) -1 &&
            m_PowerCaps.D2Latency > pCaps->D2Latency) {
            pCaps->D2Latency = m_PowerCaps.D2Latency;
        }
 
        if (m_PowerCaps.D3Latency != (ULONG) -1 &&
            m_PowerCaps.D3Latency > pCaps->D3Latency) {
            pCaps->D3Latency = m_PowerCaps.D3Latency;
        }
 
        //
        // Set the Address and the UI number values.  A value of -1 indicates
        // to use the default values provided by the lower stack.
        //
        if (m_PnpCapsAddress != (ULONG) -1) {
            pCaps->Address = m_PnpCapsAddress;
        }
 
        if (m_PnpCapsUINumber != (ULONG) -1) {
            pCaps->UINumber= m_PnpCapsUINumber;
        }
    }
 
    //
    // CompletePnpRequest is called after return from this function
    // so it is safe to log here
    //
 
    DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
                        "Exiting QueryCapabilities completion handler");
 
    return;
}

Referenced by PnpQueryCapabilities().

HandleQueryPnpDeviceStateCompletion()

VOID FxPkgFdo::HandleQueryPnpDeviceStateCompletion ( __inout FxIrp *  Irp )

private

Definition at line 763 of file fxpkgfdo.cpp.

{
    PNP_DEVICE_STATE pnpDeviceState;
 
    DoTraceLevelMessage(
        GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
        "Entering QueryPnpDeviceState completion handler");
 
    pnpDeviceState = HandleQueryPnpDeviceState(
        (PNP_DEVICE_STATE) Irp->GetInformation()
        );
 
    Irp->SetInformation((ULONG_PTR) pnpDeviceState);
 
    DoTraceLevelMessage(
        GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGPNP,
        "WDFDEVICE 0x%p !devobj 0x%p returning PNP_DEVICE_STATE 0x%d IRP 0x%p",
        m_Device->GetHandle(),
        m_Device->GetDeviceObject(),
        pnpDeviceState,
        Irp->GetIrp());
 
    DoTraceLevelMessage(
        GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
        "Exiting QueryPnpDeviceState completion handler");
 
    return;
}

Referenced by _PnpQueryPnpDeviceState().

Initialize()

_Must_inspect_result_ NTSTATUS FxPkgFdo::Initialize ( __in PWDFDEVICE_INIT  DeviceInit )

virtual

Reimplemented from FxPkgPnp.

Definition at line 361 of file fxpkgfdokm.cpp.

{
    PFX_DRIVER_GLOBALS pGlobals;
    WDF_CHILD_LIST_CONFIG config;
    size_t totalDescriptionSize = 0;
    WDFCHILDLIST hList;
    NTSTATUS status;
 
    pGlobals = GetDriverGlobals();
 
    status = FxPkgPnp::Initialize(DeviceInit);
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    status = AllocateEnumInfo();
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    #pragma prefast(suppress: __WARNING_PASSING_FUNCTION_UNEXPECTED_NULL, "Static child lists do not use the EvtChildListCreateDevice callback")
    WDF_CHILD_LIST_CONFIG_INIT(&config,
                               sizeof(FxStaticChildDescription),
                               NULL);
 
    status = FxChildList::_ComputeTotalDescriptionSize(pGlobals,
                                                       &config,
                                                       &totalDescriptionSize);
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    status = FxChildList::_CreateAndInit(&m_StaticDeviceList,
                                         pGlobals,
                                         WDF_NO_OBJECT_ATTRIBUTES,
                                         totalDescriptionSize,
                                         m_Device,
                                         &config,
                                         TRUE);
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    status = m_StaticDeviceList->Commit(WDF_NO_OBJECT_ATTRIBUTES,
                                        (WDFOBJECT*) &hList,
                                        m_Device);
 
    if (!NT_SUCCESS(status)) {
        m_StaticDeviceList->DeleteFromFailedCreate();
        m_StaticDeviceList = NULL;
 
        return status;
    }
 
    //
    // This will be released in the destructor
    //
    m_StaticDeviceList->ADDREF(this);
 
    return status;
}

Referenced by FxDevice::FdoInitialize().

IsFilter()

BOOLEAN FxPkgFdo::IsFilter ( VOID  )

inline

Definition at line 130 of file fxpkgfdo.hpp.

    {
        return m_Filter;
    }

LowerDevicePower()

_Must_inspect_result_ NTSTATUS FxPkgFdo::LowerDevicePower ( __in FxIrp *  Irp )

private

Definition at line 401 of file fdopower.cpp.

{
    SetPendingDevicePowerIrp(Irp);
 
    //
    // Kick off the power state machine.
    //
    PowerProcessEvent(PowerDx);
 
    return STATUS_PENDING;
}

Referenced by DispatchDeviceSetPower().

PnpEventCheckForDevicePresenceOverload()

WDF_DEVICE_PNP_STATE FxPkgFdo::PnpEventCheckForDevicePresenceOverload ( VOID  )

privatevirtual

Implements FxPkgPnp.

Definition at line 1133 of file fxpkgfdo.cpp.

{
    ASSERT(!"This should only be implemented for PDOs.");
 
    //
    // Do something safe.  Act like the device is not
    // present.
    //
    return WdfDevStatePnpFinal;
}

PnpEventEjectHardwareOverload()

WDF_DEVICE_PNP_STATE FxPkgFdo::PnpEventEjectHardwareOverload ( VOID  )

privatevirtual

Implements FxPkgPnp.

Definition at line 1099 of file fxpkgfdo.cpp.

{
    ASSERT(!"This should only be reachable for PDOs.");
 
    //
    // Do something safe.  Act like the device got
    // ejected.
    //
    return WdfDevStatePnpEjectedWaitingForRemove;
}

PnpEventFdoRemovedOverload()

WDF_DEVICE_PNP_STATE FxPkgFdo::PnpEventFdoRemovedOverload ( VOID  )

privatevirtual

Implements FxPkgPnp.

Definition at line 1224 of file fxpkgfdo.cpp.

{
    //
    // Do that which all device stacks need to do upon removal.
    //
    PnpEventRemovedCommonCode();
 
    return WdfDevStatePnpFinal;
}

PnpEventPdoRemovedOverload()

WDF_DEVICE_PNP_STATE FxPkgFdo::PnpEventPdoRemovedOverload ( VOID  )

privatevirtual

Implements FxPkgPnp.

Definition at line 1167 of file fxpkgfdo.cpp.

{
    ASSERT(!"This should only be implemented for PDOs.");
 
    return WdfDevStatePnpFinal;
}

PnpFilterResourceRequirements()

_Must_inspect_result_ NTSTATUS FxPkgFdo::PnpFilterResourceRequirements ( __inout FxIrp *  Irp )

private

Definition at line 43 of file fxpkgfdokm.cpp.

{
    PIO_RESOURCE_REQUIREMENTS_LIST pWdmRequirementsList;
    PIO_RESOURCE_REQUIREMENTS_LIST pNewWdmList;
    NTSTATUS status;
    FxIoResReqList *pIoResReqList;
    WDFIORESREQLIST reqlist;
 
    DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
                        "Entering FilterResourceRequirements handler");
 
    if (m_DeviceFilterRemoveResourceRequirements.m_Method != NULL) {
 
        pWdmRequirementsList = (PIO_RESOURCE_REQUIREMENTS_LIST) Irp->GetInformation();
 
        status = STATUS_INSUFFICIENT_RESOURCES;
 
        pIoResReqList = FxIoResReqList::_CreateFromWdmList(GetDriverGlobals(),
                                                           pWdmRequirementsList,
                                                           FxResourceAllAccessAllowed);
 
        if (pIoResReqList != NULL) {
            status = pIoResReqList->Commit(NULL, (PWDFOBJECT) &reqlist);
 
            // Commit should never fail because we own all object state
            ASSERT(NT_SUCCESS(status));
            UNREFERENCED_PARAMETER(status);
 
            status = m_DeviceFilterRemoveResourceRequirements.Invoke(
                m_Device->GetHandle(), pIoResReqList->GetHandle());
 
            if (NT_SUCCESS(status) && pIoResReqList->IsChanged()) {
                pNewWdmList = pIoResReqList->CreateWdmList();
 
                if (pNewWdmList != NULL) {
                    //
                    // List could be missing previously
                    //
                    if (pWdmRequirementsList != NULL) {
                        //
                        // Propagate BusNumber to our new list.
                        //
                        pNewWdmList->BusNumber = pWdmRequirementsList->BusNumber;
 
                        MxMemory::MxFreePool(pWdmRequirementsList);
                    }
 
                    Irp->SetInformation((ULONG_PTR) pNewWdmList);
                }
                else {
                    status = STATUS_INSUFFICIENT_RESOURCES;
                }
            }
 
            //
            // No matter what, free the resource requirements list object.  If
            // we need another one when adding resources, another one will be
            // allocated.
            //
            pIoResReqList->DeleteObject();
            pIoResReqList = NULL;
        }
    }
    else {
        //
        // No filtering on the way down, set status to STATUS_SUCCESS so we
        // send the irp down the stack.
        //
        status = STATUS_SUCCESS;
    }
 
    if (NT_SUCCESS(status)) {
        status = SendIrpSynchronously(Irp);
    }
 
    //
    // If we do not handle the IRP on the way down and the PDO does not handle
    // the IRP, we can have a status of STATUS_NOT_SUPPORTED.  We still want to
    // process the irp in this state.
    //
    if (NT_SUCCESS(status) || status == STATUS_NOT_SUPPORTED) {
        NTSTATUS filterStatus;
 
        //
        // Give the Framework objects a pass at the list.
        //
        filterStatus = FxPkgPnp::FilterResourceRequirements(
            (PIO_RESOURCE_REQUIREMENTS_LIST*)(&Irp->GetIrp()->IoStatus.Information)
            );
 
        if (!NT_SUCCESS(filterStatus)) {
            status = filterStatus;
        }
        else if (m_DeviceFilterAddResourceRequirements.m_Method != NULL) {
            //
            // Now give the driver a shot at it.
            //
            pWdmRequirementsList = (PIO_RESOURCE_REQUIREMENTS_LIST)
                Irp->GetInformation();
 
            pIoResReqList = FxIoResReqList::_CreateFromWdmList(
                GetDriverGlobals(), pWdmRequirementsList, FxResourceAllAccessAllowed);
 
            if (pIoResReqList != NULL) {
                status = pIoResReqList->Commit(NULL, (PWDFOBJECT) &reqlist);
                UNREFERENCED_PARAMETER(status);
 
                //
                // Since we absolutely control the lifetime of pIoResReqList, this
                // should never fail
                //
                ASSERT(NT_SUCCESS(status));
 
                status = m_DeviceFilterAddResourceRequirements.Invoke(
                    m_Device->GetHandle(), reqlist);
 
                //
                // It is possible the child driver modified the resource list,
                // and if so we need to update the requirements list.
                //
                if (NT_SUCCESS(status) && pIoResReqList->IsChanged()) {
                    pNewWdmList = pIoResReqList->CreateWdmList();
 
                    if (pNewWdmList != NULL) {
                        //
                        // List could be missing previously
                        //
                        if (pWdmRequirementsList != NULL) {
                            //
                            // Propagate BusNumber to our new list.
                            //
                            pNewWdmList->BusNumber = pWdmRequirementsList->BusNumber;
 
                            ExFreePool(pWdmRequirementsList);
                        }
 
                        Irp->SetInformation((ULONG_PTR) pNewWdmList);
                    }
                    else {
                        status = STATUS_INSUFFICIENT_RESOURCES;
                    }
                }
 
                pIoResReqList->DeleteObject();
                pIoResReqList = NULL;
            }
            else {
                status = STATUS_INSUFFICIENT_RESOURCES;
            }
        }
    }
 
    CompletePnpRequest(Irp, status);
 
    DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
                        "Exiting FilterResourceRequirements handler, %!STATUS!",
                        status);
 
    return status;
}

PnpGetPostRemoveState()

WDF_DEVICE_PNP_STATE FxPkgFdo::PnpGetPostRemoveState ( VOID  )

privatevirtual

Implements FxPkgPnp.

Definition at line 1197 of file fxpkgfdo.cpp.

{
    return WdfDevStatePnpFdoRemoved;
}

PnpQueryCapabilities()

_Must_inspect_result_ NTSTATUS FxPkgFdo::PnpQueryCapabilities ( __inout FxIrp *  Irp )

private

Definition at line 244 of file fxpkgfdokm.cpp.

{
    NTSTATUS status;
 
    HandleQueryCapabilities(Irp);
 
    status = SendIrpSynchronously(Irp);
 
    //
    // Now that the IRP has returned to us,  we modify what the bus driver
    // set up.
    //
    if (NT_SUCCESS(status)) {
        HandleQueryCapabilitiesCompletion(Irp);
    }
 
    CompletePnpRequest(Irp, status);
 
    return status;
}

PnpQueryDeviceRelations()

_Must_inspect_result_ NTSTATUS FxPkgFdo::PnpQueryDeviceRelations ( __inout FxIrp *  Irp )

private

Definition at line 399 of file fxpkgfdo.cpp.

{
    NTSTATUS status;
    DEVICE_RELATION_TYPE type;
 
    type = Irp->GetParameterQDRType();
 
    DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
                        "Entering QueryDeviceRelations handler, "
                        "type %!DEVICE_RELATION_TYPE!",
                        type);
 
    status = STATUS_SUCCESS;
 
 
    //
    // Set up the type of relations.
    //
    switch (type) {
    case BusRelations:
        status = HandleQueryBusRelations(Irp);
 
        //
        // STATUS_NOT_SUPPORTED is a special value. It means that
        // HandleQueryBusRelations did not modify the irp at all and it should
        // be sent off as is.
        //
        if (status == STATUS_NOT_SUPPORTED) {
            //
            // We set status to STATUS_SUCCESS so that we send the requqest down
            // the stack in the comparison below.
            //
            status = STATUS_SUCCESS;
        }
        break;
 
    case RemovalRelations:
        status = HandleQueryDeviceRelations(Irp, m_RemovalDeviceList);
 
        //
        // STATUS_NOT_SUPPORTED is a special value. It means that
        // HandleQueryDeviceRelations did not modify the irp at all and it should
        // be sent off as is.
        //
        if (status == STATUS_NOT_SUPPORTED) {
            //
            // We set status to STATUS_SUCCESS so that we send the requqest down
            // the stack in the comparison below.
            //
            status = STATUS_SUCCESS;
        }
        break;
    }
 
    if (NT_SUCCESS(status)) {
        status = _PnpPassDown(this, Irp);
    }
    else {
        CompletePnpRequest(Irp, status);
    }
 
    DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
                        "Exiting QueryDeviceRelations handler, status %!STATUS!",
                        status);
 
    return status;
}

PnpSendStartDeviceDownTheStackOverload()

BOOLEAN FxPkgFdo::PnpSendStartDeviceDownTheStackOverload ( VOID  )

privatevirtual

Implements FxPkgPnp.

Definition at line 919 of file fxpkgfdo.cpp.

{
    //
    // We will re-set the pending pnp irp when the start irp returns
    //
    FxIrp irp(ClearPendingPnpIrp());
    PCM_RESOURCE_LIST pWdmRaw, pWdmTranslated;
    NTSTATUS status;
    BOOLEAN setFilteredCompletion = FALSE;
    FxFilteredStartContext* pContext = NULL;
 
    pWdmRaw = irp.GetParameterAllocatedResources();
    pWdmTranslated = irp.GetParameterAllocatedResourcesTranslated();
 
    //
    // Always setup the irp to be sent down the stack.  In case of an error,
    // this does no harm and it keeps everything simple.
    //
    irp.CopyCurrentIrpStackLocationToNext();
 
    //
    // If the driver registered for a callback to remove its added resources
    // and there are resources to remove, call the driver and set the next
    // stack location to the filtered resources lists
    //
    if (m_DeviceRemoveAddedResources.m_Method != NULL &&
        pWdmRaw != NULL && pWdmTranslated != NULL) {
 
        //
        // Since we reuse these 2 fields for both the removal and the normal
        // reporting (and can then be subsequently reused on a restart), we
        // set the changed status back to FALSE.
        //
        m_ResourcesRaw->m_Changed = FALSE;
        m_Resources->m_Changed = FALSE;
 
        status = m_ResourcesRaw->BuildFromWdmList(pWdmRaw,
                                                  FxResourceAllAccessAllowed);
 
        if (NT_SUCCESS(status)) {
            status = m_Resources->BuildFromWdmList(pWdmTranslated,
                                                   FxResourceAllAccessAllowed);
        }
 
        if (NT_SUCCESS(status)) {
            status = m_DeviceRemoveAddedResources.Invoke(
                m_Device->GetHandle(),
                m_ResourcesRaw->GetHandle(),
                m_Resources->GetHandle()
                );
        }
 
        if (NT_SUCCESS(status) &&
            (m_ResourcesRaw->IsChanged() || m_Resources->IsChanged())) {
 
            pContext = new(GetDriverGlobals()) FxFilteredStartContext();
 
            if (pContext != NULL) {
                pContext->PkgFdo = this;
 
                //
                // Allocate the raw and translated resources.  Upon failure for
                // either, fail the start irp.  We allocate from NonPagedPool
                // because we are going to free the list in a completion routine
                // which maybe running at an IRQL > PASSIVE_LEVEL.
                //
                if (m_ResourcesRaw->Count() > 0) {
                    pContext->ResourcesRaw =
                        m_ResourcesRaw->CreateWdmList(NonPagedPool);
 
                    if (pContext->ResourcesRaw == NULL) {
                        status = STATUS_INSUFFICIENT_RESOURCES;
                    }
                }
 
                if (NT_SUCCESS(status) && m_Resources->Count() > 0) {
                    pContext->ResourcesTranslated =
                        m_Resources->CreateWdmList(NonPagedPool);
 
                    if (pContext->ResourcesTranslated == NULL) {
                        status = STATUS_INSUFFICIENT_RESOURCES;
                    }
                }
 
                if (NT_SUCCESS(status)) {
                    //
                    // We copied to the next stack location at the start
                    //
                    irp.SetParameterAllocatedResources(
                        pContext->ResourcesRaw);
                    irp.SetParameterAllocatedResourcesTranslated(
                        pContext->ResourcesTranslated);
 
                    //
                    // Completion routine will free the resource list
                    // allocations.
                    //
                    setFilteredCompletion = TRUE;
                }
                else {
                    //
                    // Allocation failure.  The destructor will free any
                    // outstanding allocations.
                    //
                    delete pContext;
                }
            }
        }
    }
    else {
        status = STATUS_SUCCESS;
    }
 
    if (NT_SUCCESS(status)) {
        //
        // The completion of the start irp will move the state machine into a new
        // state.
        //
        // After calling IoSetCompletionRoutineEx the driver must call
        // IoCallDriver, otherwise a memory leak would occur. So call this API
        // as close to IoCallDriver as possible to avoid failure paths.
        //
        if (setFilteredCompletion) {
            ASSERT(pContext != NULL);
            irp.SetCompletionRoutineEx(
                m_Device->GetDeviceObject(),
                _PnpFilteredStartDeviceCompletionRoutine,
                pContext);
        }
        else {
            irp.SetCompletionRoutineEx(
                m_Device->GetDeviceObject(),
                _PnpStartDeviceCompletionRoutine,
                this);
        }
 
        irp.CallDriver(m_Device->GetAttachedDevice());
    }
    else {
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                            "PNP start preprocessing failed with %!STATUS!",
                            status);
 
        //
        // Move the state machine to the failed state.
        //
        // Process the event *before* completing the irp so that this even is in
        // the queue before the device remove event which will be be processed
        // right after the start irp has been completed.
        //
        PnpProcessEvent(PnpEventStartDeviceFailed);
 
        //
        // All states which handle the PnpEventStartDeviceFailed event
        // transition do not expect a pended start irp.
        //
        CompletePnpRequest(&irp, status);
    }
 
    //
    // Indicate to the caller that the transition is asynchronous.
    //
    return FALSE;
}

PostCreateDeviceInitialize()

_Must_inspect_result_ NTSTATUS FxPkgFdo::PostCreateDeviceInitialize

(

VOID

)

Definition at line 1524 of file fxpkgfdo.cpp.

{
    NTSTATUS status;
 
    status = FxPkgPnp::PostCreateDeviceInitialize(); // __super call
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
#if (FX_CORE_MODE == FX_CORE_KERNEL_MODE)
    //
    // Allow device simulation framework to hook interrupt routines.
    //
    if (GetDriverGlobals()->FxDsfOn) {
        status = QueryForDsfInterface();
        if (!NT_SUCCESS(status)) {
            return status;
        }
    }
 
#endif
 
    status = m_Device->AllocateTarget(&m_DefaultTarget,
                                      FALSE /*SelfTarget=FALSE*/);
    if (NT_SUCCESS(status)) {
        //
        // This will be released in the destructor
        //
        m_DefaultTarget->ADDREF(this);
    }
 
    if (m_Device->m_SelfIoTargetNeeded) {
        status = m_Device->AllocateTarget((FxIoTarget**)&m_SelfTarget,
                                          TRUE /*SelfTarget*/);
        if (NT_SUCCESS(status)) {
            //
            // This will be released in the destructor
            //
            m_SelfTarget->ADDREF(this);
        }
    }
 
 
    return status;
}

Referenced by FxDevice::FdoInitialize().

PowerCheckDeviceTypeNPOverload()

WDF_DEVICE_POWER_STATE FxPkgFdo::PowerCheckDeviceTypeNPOverload ( VOID  )

privatevirtual

Implements FxPkgPnp.

Definition at line 520 of file fdopower.cpp.

{
    return WdfDevStatePowerWakingNP;
}

PowerCheckDeviceTypeOverload()

WDF_DEVICE_POWER_STATE FxPkgFdo::PowerCheckDeviceTypeOverload ( VOID  )

privatevirtual

Implements FxPkgPnp.

Definition at line 498 of file fdopower.cpp.

{
    return WdfDevStatePowerWaking;
}

PowerCheckParentOverload()

_Must_inspect_result_ NTSTATUS FxPkgFdo::PowerCheckParentOverload ( __out BOOLEAN *  ParentOn )

privatevirtual

Definition at line 543 of file fdopower.cpp.

{
    ASSERT(!"This state shouldn't be reachable for an FDO.");
    *ParentOn = TRUE;
    return STATUS_SUCCESS;
}

PowerParentPowerDereference()

VOID FxPkgFdo::PowerParentPowerDereference ( VOID  )

privatevirtual

Implements FxPkgPnp.

Definition at line 569 of file fdopower.cpp.

{
    DO_NOTHING();
}

PowerReleasePendingDeviceIrp()

VOID FxPkgFdo::PowerReleasePendingDeviceIrp ( __in BOOLEAN  IrpMustBePresent = TRUE )

privatevirtual

Definition at line 464 of file fdopower.cpp.

{
    MdIrp pIrp;
 
    pIrp = ClearPendingDevicePowerIrp();
 
    UNREFERENCED_PARAMETER(IrpMustBePresent);
    ASSERT(IrpMustBePresent == FALSE || pIrp != NULL);
 
    if (pIrp != NULL) {
        FxIrp irp(pIrp);
 
        if (irp.GetParameterPowerStateDeviceState() == PowerDeviceD0) {
            //
            // We catch D0 irps on the way up, so complete it
            //
            CompletePowerRequest(&irp, STATUS_SUCCESS);
        }
        else {
            irp.SetStatus(STATUS_SUCCESS);
 
            //
            // We catch Dx irps on the way down, so send it on its way
            //
            // This will also release the remove lock
            //
            (void) _PowerPassDown(this, &irp);
        }
    }
}

ProcessRemoveDeviceOverload()

_Must_inspect_result_ NTSTATUS FxPkgFdo::ProcessRemoveDeviceOverload ( __inout FxIrp *  Irp )

privatevirtual

Definition at line 1250 of file fxpkgfdo.cpp.

{
    NTSTATUS status;
 
    //
    // After this is called, any irp dispatched to FxDevice::DispatchWithLock
    // will fail with STATUS_INVALID_DEVICE_REQUEST.
    //
    Mx::MxReleaseRemoveLockAndWait(m_Device->GetRemoveLock(),
                                   Irp->GetIrp());
 
    //
    // Cleanup the state machines and release the power thread.
    //
    CleanupStateMachines(TRUE);
 
    Irp->CopyCurrentIrpStackLocationToNext();
    status = Irp->CallDriver(m_Device->GetAttachedDevice());
 
    //
    // Detach and delete the device object.
    //
    DeleteDevice();
 
    return status;
}

QueryForDsfInterface()

_Must_inspect_result_ NTSTATUS FxPkgFdo::QueryForDsfInterface ( VOID  )

private

Definition at line 455 of file fxpkgfdokm.cpp.

{
// __REACTOS__ : not supported
//     WDF_DSF_INTERFACE dsfInterface;
//     NTSTATUS status;
//     BOOLEAN derefQI = FALSE;
 
//     RtlZeroMemory(&dsfInterface, sizeof(dsfInterface));
 
//     //
//     // Since there are some stacks that are not PnP re-entrant (like USBHUB,
//     // xpsp2), we specify that the QI goes only to our attached device and
//     // not to the top of the stack as a normal QI irp would.
//     //
//     // We also do this a preventative measure for other stacks we don't know
//     // about internally and do not have access to when testing.
//     //
//     status = m_Device->QueryForInterface(&GUID_WDF_DSF_INTERFACE,
//         (PINTERFACE) &dsfInterface,
//         sizeof(dsfInterface),
//         WDM_DSF_INTERFACE_V1_0,
//         NULL,
//         m_Device->GetAttachedDevice()
//         );
 
//     if (status == STATUS_NOT_SUPPORTED) {
//         DoTraceLevelMessage(
//             GetDriverGlobals(), TRACE_LEVEL_WARNING, TRACINGPNP,
//             "Lower stack does not have a DSF interface");
//         status = STATUS_SUCCESS;
//         goto Done;
//     }
 
//     if (!NT_SUCCESS(status)) {
//         DoTraceLevelMessage(
//             GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
//             "Lower stack returned an error for query DSF interface, %!STATUS!",
//             status);
//         goto Done;
//     }
 
//     derefQI = TRUE;
 
//     //
//     // Basic run time checks.
//     //
//     if (dsfInterface.Interface.Version != WDM_DSF_INTERFACE_V1_0) {
//         status = STATUS_REVISION_MISMATCH;
//         DoTraceLevelMessage(
//             GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
//             "Lower DSF stack supports v(%x), requested v(%x), %!STATUS!",
//             dsfInterface.Interface.Version,
//             WDM_DSF_INTERFACE_V1_0,
//             status);
//         goto Done;
//     }
 
//     //
//     // Ex functions should be both set or cleared.
//     // Active/Inactive functions should be both set or cleared.
//     // Ex function must be present.
//     // Note: !!(ptr) expression below converts ptr value to true/false value.
//     //       I.e., ptr==NULL to false and ptr!=NULL to true.
//     //
//     if (!((!!(dsfInterface.IoConnectInterruptEx) ==
//               !!(dsfInterface.IoDisconnectInterruptEx)) &&
//           (!!(dsfInterface.IoReportInterruptActive) ==
//               !!(dsfInterface.IoReportInterruptInactive)) &&
//           (dsfInterface.IoConnectInterruptEx != NULL)
//               )) {
//         status = STATUS_DATA_ERROR;
//         DoTraceLevelMessage(
//             GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
//             "Function mismatch detected in DSF interface, %!STATUS!",
//             status);
//         goto Done;
//     }
 
//     //
//     // Info is correct.
//     //
//     m_IoConnectInterruptEx      = dsfInterface.IoConnectInterruptEx;
//     m_IoDisconnectInterruptEx   = dsfInterface.IoDisconnectInterruptEx;
 
//     //
//     // If DSF interface provides active/inactive functions then use them
//     //
//     if (dsfInterface.IoReportInterruptActive != NULL)
//     {
//         m_IoReportInterruptActive   = dsfInterface.IoReportInterruptActive;
//         m_IoReportInterruptInactive = dsfInterface.IoReportInterruptInactive;
//     }
 
// Done:
 
//     //
//     // The contract with the DSF layer is to release the interface right away;
//     // the embedded interrupt function ptrs will be valid until this driver is
//     // unloaded.
//     //
//     if (derefQI) {
//         dsfInterface.Interface.InterfaceDereference(dsfInterface.Interface.Context);
//     }
 
//     return status;
    return STATUS_NOT_IMPLEMENTED;
}

Referenced by PostCreateDeviceInitialize().

QueryForPowerThread()

_Must_inspect_result_ NTSTATUS FxPkgFdo::QueryForPowerThread ( VOID  )

privatevirtual

Implements FxPkgPnp.

Definition at line 1387 of file fxpkgfdo.cpp.

{
    NTSTATUS status;
 
    //
    // Query down the stack to see if a lower device already created a thread.
    // Do NOT send this to the top of the stack, it is sent to the attached
    // device b/c we need the thread from a device below us b/c its lifetime
    // will outlast this device's.
    //
    status = m_Device->QueryForInterface(&GUID_POWER_THREAD_INTERFACE,
        &m_PowerThreadInterface.Interface,
        sizeof(m_PowerThreadInterface),
        1,
        NULL,
        m_Device->GetAttachedDevice());
 
    if (NT_SUCCESS(status)) {
        //
        // A lower thread exists, use it
        //
        m_HasPowerThread = TRUE;
    }
    else {
        //
        // No thread exists yet, attempt to create our own
        //
        status = CreatePowerThread();
    }
 
    return status;
}

QueryForReenumerationInterface()

VOID FxPkgFdo::QueryForReenumerationInterface ( VOID  )

privatevirtual

Implements FxPkgPnp.

Definition at line 1307 of file fxpkgfdo.cpp.

{
    PREENUMERATE_SELF_INTERFACE_STANDARD pInterface;
    NTSTATUS status;
 
    pInterface = &m_SurpriseRemoveAndReenumerateSelfInterface;
 
    if (pInterface->SurpriseRemoveAndReenumerateSelf != NULL) {
        //
        // Already got it, just return.  This function can be called again during
        // stop -> start, so we must check.
        //
        return;
    }
 
    RtlZeroMemory(pInterface, sizeof(*pInterface));
    pInterface->Size =  sizeof(*pInterface);
    pInterface->Version = 1;
 
    //
    // Since there are some stacks that are not PnP re-entrant
 
    // we specify that the QI goes only to our attached device and
    // not to the top of the stack as a normal QI irp would.  For the
    // reenumerate self interface, having someone on top of us filter the
    // IRP makes no sense anyways.
    //
    // We also do this as a preventative measure for other stacks we don't know
    // about internally and do not have access to when testing.
    //
    status = m_Device->QueryForInterface(&GUID_REENUMERATE_SELF_INTERFACE_STANDARD,
        (PINTERFACE) pInterface,
        sizeof(*pInterface),
        1,
        NULL,
        m_Device->GetAttachedDevice()
        );
 
    //
    // Failure to get this interface is not fatal.
    // Note that an implicit reference has been taken on the interface. We
    // must release the reference when we are done with the interface.
    //
    UNREFERENCED_PARAMETER(status); // for analyis tools.
}

RaiseDevicePower()

_Must_inspect_result_ NTSTATUS FxPkgFdo::RaiseDevicePower ( __in FxIrp *  Irp )

private

Definition at line 353 of file fdopower.cpp.

{
    Irp->MarkIrpPending();
    Irp->CopyCurrentIrpStackLocationToNext();
    Irp->SetCompletionRoutineEx(m_Device->GetDeviceObject(),
                                RaiseDevicePowerCompletion,
                                this);
 
    Irp->PoCallDriver(m_Device->GetAttachedDevice());
 
    return STATUS_PENDING;
}

Referenced by DispatchDeviceSetPower().

RegisterCallbacks()

_Must_inspect_result_ NTSTATUS FxPkgFdo::RegisterCallbacks

(

__in PWDF_FDO_EVENT_CALLBACKS

DispatchTable

)

Definition at line 796 of file fxpkgfdo.cpp.

{
    //
    // Walk the table, and only update the pkg table *if* the dispatch
    // table has a non-null entry.
    //
    m_DeviceFilterAddResourceRequirements.m_Method =
        DispatchTable->EvtDeviceFilterAddResourceRequirements;
    m_DeviceFilterRemoveResourceRequirements.m_Method =
        DispatchTable->EvtDeviceFilterRemoveResourceRequirements;
    m_DeviceRemoveAddedResources.m_Method =
        DispatchTable->EvtDeviceRemoveAddedResources;
 
    return STATUS_SUCCESS;
}

Referenced by FxDevice::FdoInitialize().

ReleaseReenumerationInterface()

VOID FxPkgFdo::ReleaseReenumerationInterface ( VOID  )

privatevirtual

Implements FxPkgPnp.

Definition at line 1356 of file fxpkgfdo.cpp.

{
    PREENUMERATE_SELF_INTERFACE_STANDARD pInterface;
 
    pInterface = &m_SurpriseRemoveAndReenumerateSelfInterface;
 
    pInterface->SurpriseRemoveAndReenumerateSelf = NULL;
 
    if (pInterface->InterfaceDereference != NULL) {
        pInterface->InterfaceDereference(pInterface->Context);
    }
}

SendIrpSynchronously()

_Must_inspect_result_ NTSTATUS FxPkgFdo::SendIrpSynchronously ( __inout FxIrp *  Irp )

privatevirtual

Definition at line 248 of file fxpkgfdo.cpp.

{
    Irp->CopyCurrentIrpStackLocationToNext();
    return Irp->SendIrpSynchronously(m_Device->GetAttachedDevice());
}

Referenced by _PnpQueryPnpDeviceState(), PnpFilterResourceRequirements(), and PnpQueryCapabilities().

SetFilter()

_Must_inspect_result_ NTSTATUS FxPkgFdo::SetFilter

(

__in BOOLEAN

Value

)

Definition at line 892 of file fxpkgfdo.cpp.

{
    m_Filter = Value;
    return STATUS_SUCCESS;
}

Referenced by FxDevice::SetFilter().

Member Data Documentation

_SystemPowerS0Completion

_Must_inspect_result_ NTSTATUS STDCALL FxPkgFdo::_SystemPowerS0Completion

staticprotected

Definition at line 461 of file fxpkgfdo.hpp.

Referenced by DispatchSystemSetPower().

_SystemPowerSxCompletion

_Must_inspect_result_ NTSTATUS STDCALL FxPkgFdo::_SystemPowerSxCompletion

staticprotected

Definition at line 465 of file fxpkgfdo.hpp.

Referenced by DispatchSystemSetPower().

m_DefaultDeviceList

FxChildList* FxPkgFdo::m_DefaultDeviceList

Definition at line 40 of file fxpkgfdo.hpp.

Referenced by CreateDefaultDeviceList(), FxPkgFdo(), if(), and ~FxPkgFdo().

m_DefaultTarget

FxIoTarget* FxPkgFdo::m_DefaultTarget

Definition at line 47 of file fxpkgfdo.hpp.

Referenced by FxPkgFdo(), FxDevice::GetDefaultIoTarget(), PostCreateDeviceInitialize(), and ~FxPkgFdo().

m_DeviceFilterAddResourceRequirements

FxPnpDeviceFilterResourceRequirements FxPkgFdo::m_DeviceFilterAddResourceRequirements

private

Definition at line 63 of file fxpkgfdo.hpp.

Referenced by PnpFilterResourceRequirements(), and RegisterCallbacks().

m_DeviceFilterRemoveResourceRequirements

FxPnpDeviceFilterResourceRequirements FxPkgFdo::m_DeviceFilterRemoveResourceRequirements

private

Definition at line 65 of file fxpkgfdo.hpp.

Referenced by PnpFilterResourceRequirements(), and RegisterCallbacks().

m_DeviceRemoveAddedResources

FxPnpDeviceRemoveAddedResources FxPkgFdo::m_DeviceRemoveAddedResources

private

Definition at line 67 of file fxpkgfdo.hpp.

Referenced by PnpSendStartDeviceDownTheStackOverload(), and RegisterCallbacks().

m_FdoPnpFunctionTable

const PFN_PNP_POWER_CALLBACK FxPkgFdo::m_FdoPnpFunctionTable

staticprivate

Definition at line 74 of file fxpkgfdo.hpp.

Referenced by GetDispatchPnp().

m_FdoPowerFunctionTable

const PFN_PNP_POWER_CALLBACK FxPkgFdo::m_FdoPowerFunctionTable

staticprivate

Initial value:

=
{
    _DispatchWaitWake,      
    _PowerPassDown,         
    _DispatchSetPower,      
    _DispatchQueryPower,    
}

Definition at line 79 of file fxpkgfdo.hpp.

Referenced by GetDispatchPower().

m_Filter

BOOLEAN FxPkgFdo::m_Filter

private

Definition at line 69 of file fxpkgfdo.hpp.

Referenced by FxPkgFdo(), IsFilter(), and SetFilter().

m_SelfTarget

FxIoTargetSelf* FxPkgFdo::m_SelfTarget

Definition at line 53 of file fxpkgfdo.hpp.

Referenced by FxPkgFdo(), FxDevice::GetSelfIoTarget(), PostCreateDeviceInitialize(), and ~FxPkgFdo().

m_StaticDeviceList

FxChildList* FxPkgFdo::m_StaticDeviceList

Definition at line 42 of file fxpkgfdo.hpp.

Referenced by FxPkgFdo(), Initialize(), FxPkgPdo::Initialize(), and ~FxPkgFdo().

m_SurpriseRemoveAndReenumerateSelfInterface

REENUMERATE_SELF_INTERFACE_STANDARD FxPkgFdo::m_SurpriseRemoveAndReenumerateSelfInterface

private

Definition at line 57 of file fxpkgfdo.hpp.

Referenced by AskParentToRemoveAndReenumerate(), FxPkgFdo(), QueryForReenumerationInterface(), and ReleaseReenumerationInterface().

RaiseDevicePowerCompletion

_Must_inspect_result_ NTSTATUS STDCALL FxPkgFdo::RaiseDevicePowerCompletion

static

Definition at line 454 of file fxpkgfdo.hpp.

Referenced by RaiseDevicePower().

---

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

• sdk/lib/drivers/wdf/shared/inc/private/common/fxpkgfdo.hpp
• sdk/lib/drivers/wdf/shared/irphandlers/pnp/fdopower.cpp
• sdk/lib/drivers/wdf/shared/irphandlers/pnp/fxpkgfdo.cpp
• sdk/lib/drivers/wdf/shared/irphandlers/pnp/km/fxpkgfdokm.cpp
• sdk/lib/drivers/wdf/shared/irphandlers/pnp/um/fxpkgfdoum.cpp