FxPkgPdo Class Reference

#include <fxpkgpdo.hpp>

Inheritance diagram for FxPkgPdo:

Collaboration diagram for FxPkgPdo:

Public Member Functions
	FxPkgPdo (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in CfxDevice *Device)
	~FxPkgPdo ()
virtual _Must_inspect_result_ NTSTATUS	Initialize (__in PWDFDEVICE_INIT DeviceInit)
virtual VOID	FinishInitialize (__in PWDFDEVICE_INIT DeviceInit)
VOID	RegisterCallbacks (__in PWDF_PDO_EVENT_CALLBACKS DispatchTable)
_Must_inspect_result_ NTSTATUS	AddEjectionDevice (__in MdDeviceObject DependentDevice)
VOID	RemoveEjectionDevice (__in MdDeviceObject DependentDevice)
VOID	ClearEjectionDevicesList (VOID)
_Must_inspect_result_ NTSTATUS	HandleQueryInterfaceForReenumerate (__in FxIrp *Irp, __out PBOOLEAN CompleteRequest)
__inline BOOLEAN	IsForwardRequestToParentEnabled (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)

Public Attributes
SINGLE_LIST_ENTRY	m_DeviceTextHead
LCID	m_DefaultLocale
FxDeviceDescriptionEntry *	m_Description
FxChildList *	m_OwningChildList
FxPnpDeviceResourcesQuery	m_DeviceResourcesQuery
FxPnpDeviceResourceRequirementsQuery	m_DeviceResourceRequirementsQuery
FxPnpDeviceEject	m_DeviceEject
FxPnpDeviceSetLock	m_DeviceSetLock
FxPowerDeviceEnableWakeAtBus	m_DeviceEnableWakeAtBus
FxPowerDeviceDisableWakeAtBus	m_DeviceDisableWakeAtBus
FxPnpDeviceReportedMissing	m_DeviceReportedMissing
BOOLEAN	m_RawOK
BOOLEAN	m_Static
BOOLEAN	m_AddedToStaticList
BOOLEAN	m_AllowForwardRequestToParent
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

Protected Attributes
PWSTR	m_DeviceID
PWSTR	m_InstanceID
PWSTR	m_HardwareIDs
PWSTR	m_CompatibleIDs
PWSTR	m_ContainerID
PWSTR	m_IDsAllocation
FxRelatedDeviceList *	m_EjectionDeviceList
MxEvent *	m_DeviceEjectProcessed
BOOLEAN	m_CanBeDeleted
BOOLEAN	m_EnableWakeAtBusInvoked
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
};

Private Member Functions
virtual _Must_inspect_result_ NTSTATUS	SendIrpSynchronously (__in 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 PDEVICE_CAPABILITIES ReportedCaps, __in PDEVICE_CAPABILITIES ParentCaps)
_Must_inspect_result_ NTSTATUS	PnpQueryResources (__inout FxIrp *Irp)
_Must_inspect_result_ NTSTATUS	PnpQueryResourceRequirements (__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	PnpEventFdoRemovedOverload (VOID)
virtual VOID	PnpEventSurpriseRemovePendingOverload (VOID)
virtual WDF_DEVICE_PNP_STATE	PnpGetPostRemoveState (VOID)
_Must_inspect_result_ NTSTATUS	DispatchSystemSetPower (__in FxIrp *Irp)
_Must_inspect_result_ NTSTATUS	DispatchDeviceSetPower (__in FxIrp *Irp)
virtual _Must_inspect_result_ NTSTATUS	PowerCheckParentOverload (__in BOOLEAN *ParentOn)
virtual WDF_DEVICE_POWER_STATE	PowerCheckDeviceTypeOverload (VOID)
virtual WDF_DEVICE_POWER_STATE	PowerCheckDeviceTypeNPOverload (VOID)
virtual _Must_inspect_result_ NTSTATUS	PowerEnableWakeAtBusOverload (VOID)
virtual VOID	PowerDisableWakeAtBusOverload (VOID)
virtual VOID	PowerParentPowerDereference (VOID)
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)
VOID	PowerNotifyParentChildWakeArmed (VOID)
VOID	PowerNotifyParentChildWakeDisarmed (VOID)

Static Private Member Functions
static _Must_inspect_result_ NTSTATUS	_PnpCompleteIrp (__in FxPkgPnp *This, __inout FxIrp *Irp)
static _Must_inspect_result_ NTSTATUS	_PnpQueryDeviceRelations (__in FxPkgPnp *This, __inout FxIrp *Irp)
static _Must_inspect_result_ NTSTATUS	_PnpQueryInterface (IN FxPkgPnp *This, IN FxIrp *Irp)
static _Must_inspect_result_ NTSTATUS	_PnpQueryCapabilities (__inout FxPkgPnp *This, __inout FxIrp *Irp)
static VOID NTAPI	_QueryCapsWorkItem (__in MdDeviceObject DeviceObject, __in PVOID Context)
static _Must_inspect_result_ NTSTATUS	_PnpQueryResources (__inout FxPkgPnp *This, __inout FxIrp *Irp)
static _Must_inspect_result_ NTSTATUS	_PnpQueryResourceRequirements (__inout FxPkgPnp *This, __inout FxIrp *Irp)
static _Must_inspect_result_ NTSTATUS	_PnpQueryDeviceText (__inout FxPkgPnp *This, __inout FxIrp *Irp)
static _Must_inspect_result_ NTSTATUS	_PnpFilterResourceRequirements (__inout FxPkgPnp *This, __inout FxIrp *Irp)
static _Must_inspect_result_ NTSTATUS	_PnpEject (__inout FxPkgPnp *This, __inout FxIrp *Irp)
static _Must_inspect_result_ NTSTATUS	_PnpSetLock (__inout FxPkgPnp *This, __inout FxIrp *Irp)
static _Must_inspect_result_ NTSTATUS	_PnpQueryId (__inout FxPkgPnp *This, __inout FxIrp *Irp)
static _Must_inspect_result_ NTSTATUS	_PnpQueryPnpDeviceState (__inout FxPkgPnp *This, __inout FxIrp *Irp)
static _Must_inspect_result_ NTSTATUS	_PnpQueryBusInformation (__inout FxPkgPnp *This, __inout FxIrp *Irp)
static _Must_inspect_result_ NTSTATUS	_PnpSurpriseRemoval (__inout FxPkgPnp *This, __inout FxIrp *Irp)
static _Must_inspect_result_ NTSTATUS	_DispatchPowerSequence (__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)
static VOID NTAPI	_RemoveAndReenumerateSelf (__in PVOID Context)

Static Private Attributes
static const PFN_PNP_POWER_CALLBACK	m_PdoPnpFunctionTable [IRP_MN_SURPRISE_REMOVAL+1]
static const PFN_PNP_POWER_CALLBACK	m_PdoPowerFunctionTable [IRP_MN_QUERY_POWER+1]

Additional Inherited Members
Static Public Member Functions inherited from FxObject
static FxObject *	_FromDisposeEntry (__in PSINGLE_LIST_ENTRY Entry)
static FxObject *	_GetObjectFromHandle (__in WDFOBJECT Handle, __inout PWDFOBJECT_OFFSET ObjectOffset)
static PVOID __inline	_ToHandle (__in FxObject *Object)
static VOID __inline	_ReferenceActual (__in WDFOBJECT Object, __in_opt PVOID Tag, __in LONG Line, __in PSTR File)
static VOID __inline	_DereferenceActual (__in WDFOBJECT Object, __in_opt PVOID Tag, __in LONG Line, __in PSTR File)
static PVOID	_GetDebugBase (__in FxObject *Object)
static PFX_POOL_HEADER	_CleanupPointer (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObject *Object)
static _Must_inspect_result_ NTSTATUS	_GetEffectiveLock (__in FxObject *Object, __in_opt IFxHasCallbacks *Callbacks, __in BOOLEAN AutomaticLocking, __in BOOLEAN PassiveCallbacks, __out FxCallbackLock **CallbackLock, __out_opt FxObject **CallbackLockObject)
static _Must_inspect_result_ NTSTATUS	_ObjectQuery (_In_ FxObject *Object, _In_ CONST GUID *Guid, _In_ ULONG QueryBufferLength, _Out_writes_bytes_(QueryBufferLength) PVOID QueryBuffer)
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 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 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

Detailed Description

Definition at line 31 of file fxpkgpdo.hpp.

Constructor & Destructor Documentation

FxPkgPdo()

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

Definition at line 81 of file fxpkgpdo.cpp.

      :
    FxPkgPnp(FxDriverGlobals, Device, FX_TYPE_PACKAGE_PDO)
/*++
 
Routine Description:
 
    This is the constructor for the FxPkgPdo.  Don't do any initialization
    that might fail here.
 
Arguments:
 
    none
 
Returns:
 
    none
 
--*/
 
{
    m_DeviceTextHead.Next = NULL;
 
    m_DeviceID   = NULL;
    m_InstanceID = NULL;
    m_HardwareIDs = NULL;
    m_CompatibleIDs = NULL;
    m_ContainerID = NULL;
    m_IDsAllocation = NULL;
 
    m_RawOK = FALSE;
    m_Static = FALSE;
    m_AddedToStaticList = FALSE;
 
    //
    // By default the PDO is the owner of wait wake irps (only case where this
    // wouldn't be the case is for a bus filter to be sitting above us).
    //
    m_SharedPower.m_WaitWakeOwner = TRUE;
 
    m_Description = NULL;
    m_OwningChildList = NULL;
 
    m_EjectionDeviceList = NULL;
    m_DeviceEjectProcessed = NULL;
 
    m_CanBeDeleted = FALSE;
    m_EnableWakeAtBusInvoked = FALSE;
}

~FxPkgPdo()

FxPkgPdo::~FxPkgPdo

(

)

Definition at line 133 of file fxpkgpdo.cpp.

{
    //
    // If IoCreateDevice fails on a dynamically created PDO, m_Description will
    // be != NULL b/c we will not go through the pnp state machine in its entirety
    // for cleanup.  FxChildList will need a valid m_Description to cleanup upon
    // failure from EvtChildListDeviceCrate, so we just leave m_Description alone
    // here if != NULL.
    //
    // ASSERT(m_Description == NULL);
 
    FxDeviceText::_CleanupList(&m_DeviceTextHead);
 
    //
    // This will free the underlying memory for m_DeviceID, m_InstanceID,
    // m_HardwareIDs, m_CompatibleIDs and m_ContainerID
    //
    if (m_IDsAllocation != NULL) {
        FxPoolFree(m_IDsAllocation);
        m_IDsAllocation = NULL;
    }
 
    if (m_OwningChildList != NULL) {
        m_OwningChildList->RELEASE(this);
    }
 
    if (m_EjectionDeviceList != NULL) {
        delete m_EjectionDeviceList;
        m_EjectionDeviceList = NULL;
    }
}

Member Function Documentation

_DispatchPowerSequence()

_Must_inspect_result_ NTSTATUS FxPkgPdo::_DispatchPowerSequence ( __inout FxPkgPnp *  This, __in FxIrp *  Irp  )

staticprivate

Definition at line 39 of file pdopower.cpp.

{
    return ((FxPkgPdo*) This)->CompletePowerRequest(Irp, STATUS_NOT_SUPPORTED);
}

_DispatchQueryPower()

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

staticprivate

Definition at line 201 of file pdopower.cpp.

{
    FxPkgPdo* pThis;
    NTSTATUS status;
 
    pThis = ((FxPkgPdo*) This);
 
    if (Irp->GetParameterPowerType() == SystemPowerState
        &&
        This->PowerPolicyIsWakeEnabled()) {
 
        status = pThis->PowerPolicyHandleSystemQueryPower(
            Irp->GetParameterPowerStateSystemState()
            );
    }
    else {
        status = STATUS_SUCCESS;
    }
 
    return pThis->CompletePowerRequest(Irp, status);
}

_DispatchSetPower()

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

staticprivate

Definition at line 63 of file pdopower.cpp.

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

_PnpCompleteIrp()

_Must_inspect_result_ NTSTATUS FxPkgPdo::_PnpCompleteIrp ( __in FxPkgPnp *  This, __inout FxIrp *  Irp  )

staticprivate

Definition at line 414 of file fxpkgpdo.cpp.

{
    return ((FxPkgPdo*) This)->CompletePnpRequest(Irp, Irp->GetStatus());
}

_PnpEject()

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

staticprivate

Definition at line 968 of file fxpkgpdo.cpp.

{
    MxEvent event;
    FxPkgPdo* pdoPkg;
    NTSTATUS status;
 
    pdoPkg = (FxPkgPdo*)This;
 
    //
    // This will make sure no new state changing pnp irps arrive while
    // we are still processing this one. Also, note that irp is not being
    // marked pending.
    //
    pdoPkg->SetPendingPnpIrp(Irp, FALSE);
 
    status = event.Initialize(SynchronizationEvent, FALSE);
    if (!NT_SUCCESS(status)) {
 
        DoTraceLevelMessage(
            pdoPkg->GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
            "Event allocation failed while processing eject for WDFDEVICE %p,"
            " %!STATUS!",
            pdoPkg->m_Device->GetHandle(), status);
    }
    else {
        ASSERT(pdoPkg->m_DeviceEjectProcessed == NULL);
        pdoPkg->m_DeviceEjectProcessed = event.GetSelfPointer();
 
        //
        // let state machine process eject
        //
        pdoPkg->PnpProcessEvent(PnpEventEject);
 
        //
        // No need to wait in a critical region because we are in the context of a
        // pnp request which is in the system context.
        //
        event.WaitFor(Executive, KernelMode, FALSE, NULL);
 
        pdoPkg->m_DeviceEjectProcessed = NULL;
 
        status = Irp->GetStatus();
    }
 
    //
    // complete request
    //
 
    pdoPkg->ClearPendingPnpIrp();
    pdoPkg->CompletePnpRequest(Irp, status);
 
    return status;
}

_PnpFilterResourceRequirements()

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

staticprivate

Definition at line 343 of file fxpkgpdokm.cpp.

{
    NTSTATUS status;
 
    //
    // Give the Framework objects a pass at the list.
    //
    status = ((FxPkgPdo*) This)->FilterResourceRequirements(
        (PIO_RESOURCE_REQUIREMENTS_LIST*)(&Irp->GetIrp()->IoStatus.Information)
        );
 
    if (NT_SUCCESS(status)) {
        //
        // Upon successful internal filtering, return the embedded status.
        //
        status = Irp->GetStatus();
    }
    else {
        //
        // Only on failure do we change the status of the irp
        //
        Irp->SetStatus(status);
    }
 
    return ((FxPkgPdo*) This)->CompletePnpRequest(Irp, status);
}

_PnpQueryBusInformation()

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

staticprivate

Definition at line 1529 of file fxpkgpdo.cpp.

{
    FxPkgPdo* pThis;
    NTSTATUS status;
 
    pThis = (FxPkgPdo*) This;
 
    status = pThis->m_Device->m_ParentDevice->m_PkgPnp->
        HandleQueryBusInformation(Irp);
 
    return pThis->CompletePnpRequest(Irp, status);
}

_PnpQueryCapabilities()

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

staticprivate

Definition at line 551 of file fxpkgpdo.cpp.

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

_PnpQueryDeviceRelations()

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

staticprivate

Definition at line 424 of file fxpkgpdo.cpp.

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

_PnpQueryDeviceText()

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

staticprivate

Definition at line 858 of file fxpkgpdo.cpp.

{
    FxPkgPdo* pThis;
    LCID localeId;
    FxDeviceText *pDeviceTextObject;
    NTSTATUS status;
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
 
    pThis = (FxPkgPdo*) This;
    pFxDriverGlobals = pThis->GetDriverGlobals();
 
    localeId = Irp->GetParameterQueryDeviceTextLocaleId();
    status = Irp->GetStatus();
 
    //
    // The PDO package maintains a collection of "DeviceText" objects.  We
    // will look up the item in the collection with the "appropriate" locale.
    //
    // If no entries are found in the collection for the given locale, then
    // we will use the "default locale" property of the PDO and use the
    // entry for the "default locale".
    //
 
    //
    // Try to find the FxDeviceText object for the given locale.
    //
    pDeviceTextObject = FindObjectForGivenLocale(
        &pThis->m_DeviceTextHead, localeId);
 
    if (pDeviceTextObject == NULL) {
        pDeviceTextObject = FindObjectForGivenLocale(
            &pThis->m_DeviceTextHead, pThis->m_DefaultLocale);
    }
 
    if (pDeviceTextObject != NULL) {
        PWCHAR pInformation;
 
        pInformation = NULL;
 
        switch (Irp->GetParameterQueryDeviceTextType()) {
        case DeviceTextDescription:
            pInformation = pDeviceTextObject->m_Description;
            break;
 
        case DeviceTextLocationInformation:
            pInformation = pDeviceTextObject->m_LocationInformation;
            break;
        }
 
        //
        // Information should now point to a valid unicode string.
        //
        if (pInformation != NULL) {
            PWCHAR pBuffer;
            size_t length;
 
            length = (wcslen(pInformation) + 1) * sizeof(WCHAR);
 
            //
            // Make sure the information field of the IRP isn't already set.
            //
            ASSERT(Irp->GetInformation() == NULL);
 
            pBuffer = (PWCHAR) MxMemory::MxAllocatePoolWithTag(
                PagedPool, length, pFxDriverGlobals->Tag);
 
            if (pBuffer != NULL) {
                RtlCopyMemory(pBuffer, pInformation, length);
                Irp->SetInformation((ULONG_PTR) pBuffer);
 
                status = STATUS_SUCCESS;
            }
            else {
                status = STATUS_INSUFFICIENT_RESOURCES;
 
                DoTraceLevelMessage(
                    pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
                    "WDFDEVICE %p failing Query Device Text, type %d, %!STATUS!",
                    pThis->m_Device->GetHandle(),
                    Irp->GetParameterQueryDeviceTextType(), status);
            }
        }
    }
 
    return pThis->CompletePnpRequest(Irp, status);
}

_PnpQueryId()

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

staticprivate

Definition at line 1359 of file fxpkgpdo.cpp.

{
    FxPkgPdo* pThis;
    NTSTATUS status;
    PWCHAR pBuffer;
    PCWSTR pSrc;
    size_t cbLength;
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
    BUS_QUERY_ID_TYPE queryIdType;
 
    pThis = (FxPkgPdo*) This;
    pFxDriverGlobals  = pThis->GetDriverGlobals();
    status = Irp->GetStatus();
    cbLength = 0;
 
    queryIdType = Irp->GetParameterQueryIdType();
 
    switch (queryIdType) {
    case BusQueryDeviceID:
    case BusQueryInstanceID:
    case BusQueryContainerID:
        if (queryIdType == BusQueryDeviceID) {
            pSrc = pThis->m_DeviceID;
        }
        else if (queryIdType == BusQueryInstanceID) {
            pSrc = pThis->m_InstanceID;
        }
        else {
            pSrc = pThis->m_ContainerID;
        }
 
        if (pSrc != NULL) {
            cbLength = (wcslen(pSrc) + 1) * sizeof(WCHAR);
 
            pBuffer = (PWCHAR) MxMemory::MxAllocatePoolWithTag(
                PagedPool, cbLength, pFxDriverGlobals->Tag);
        }
        else {
            status = Irp->GetStatus();
            break;
        }
 
        if (pBuffer != NULL) {
 
            //
            // This will copy the NULL terminator too
            //
            RtlCopyMemory(pBuffer, pSrc, cbLength);
            Irp->SetInformation((ULONG_PTR) pBuffer);
            status = STATUS_SUCCESS;
        }
        else {
            status = STATUS_INSUFFICIENT_RESOURCES;
        }
        break;
 
    case BusQueryHardwareIDs:
    case BusQueryCompatibleIDs:
        if (queryIdType == BusQueryHardwareIDs) {
            pSrc = pThis->m_HardwareIDs;
        }
        else {
            pSrc = pThis->m_CompatibleIDs;
        }
 
        if (pSrc != NULL) {
            cbLength = FxCalculateTotalMultiSzStringSize(pSrc);
        }
        else {
            //
            // Must return an empty list
            //
            cbLength = 2 * sizeof(UNICODE_NULL);
        }
 
        pBuffer = (PWCHAR) MxMemory::MxAllocatePoolWithTag(
            PagedPool, cbLength, pFxDriverGlobals->Tag);
 
        if (pBuffer != NULL) {
            if (pSrc != NULL) {
                RtlCopyMemory(pBuffer, pSrc, cbLength);
            }
            else {
                RtlZeroMemory(pBuffer, cbLength);
            }
 
            Irp->SetInformation((ULONG_PTR) pBuffer);
            status = STATUS_SUCCESS;
        }
        else {
            status = STATUS_INSUFFICIENT_RESOURCES;
        }
        break;
    }
 
    if (!NT_SUCCESS(status)) {
        Irp->SetInformation(NULL);
 
        if (status == STATUS_NOT_SUPPORTED) {
            DoTraceLevelMessage(
                pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
                "WDFDEVICE %p does not have a string for PnP query IdType "
                "%!BUS_QUERY_ID_TYPE!, %!STATUS!",
                pThis->m_Device->GetHandle(),
                queryIdType, status);
        }
        else {
            DoTraceLevelMessage(
                pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
                "WDFDEVICE %p could not alloc string for PnP query IdType "
                "%!BUS_QUERY_ID_TYPE!, %!STATUS!",
                pThis->m_Device->GetHandle(),
                queryIdType, status);
        }
    }
 
    return ((FxPkgPdo*) pThis)->CompletePnpRequest(Irp, status);
}

_PnpQueryInterface()

_Must_inspect_result_ NTSTATUS FxPkgPdo::_PnpQueryInterface ( IN FxPkgPnp *  This, IN FxIrp *  Irp  )

staticprivate

Definition at line 522 of file fxpkgpdo.cpp.

{
    NTSTATUS status;
    BOOLEAN completeIrp;
 
    status = ((FxPkgPdo*) This)->HandleQueryInterface(Irp, &completeIrp);
 
    return ((FxPkgPdo*) This)->CompletePnpRequest(Irp, status);
}

_PnpQueryPnpDeviceState()

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

staticprivate

Definition at line 1483 of file fxpkgpdo.cpp.

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

_PnpQueryResourceRequirements()

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

staticprivate

Definition at line 131 of file fxpkgpdokm.cpp.

{
    return ((FxPkgPdo*) This)->PnpQueryResourceRequirements(Irp);
}

_PnpQueryResources()

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

staticprivate

Definition at line 39 of file fxpkgpdokm.cpp.

{
    return ((FxPkgPdo*) This)->PnpQueryResources(Irp);
}

_PnpSetLock()

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

staticprivate

Definition at line 1323 of file fxpkgpdo.cpp.

{
    NTSTATUS status;
    BOOLEAN lock;
 
    lock = Irp->GetParameterSetLockLock();
 
    status = ((FxPkgPdo*) This)->m_DeviceSetLock.Invoke(
        ((FxPkgPdo*) This)->m_Device->GetHandle(), lock);
 
    if (NT_SUCCESS(status)) {
        Irp->SetInformation(NULL);
    }
 
    return ((FxPkgPdo*) This)->CompletePnpRequest(Irp, status);
}

_PnpSurpriseRemoval()

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

staticprivate

Definition at line 1561 of file fxpkgpdo.cpp.

{
    FxPkgPdo* pThis;
 
    pThis = (FxPkgPdo*) This;
 
    pThis->m_Description->DeviceSurpriseRemoved();
 
    return pThis->PnpSurpriseRemoval(Irp);
}

_QueryCapsWorkItem()

VOID FxPkgPdo::_QueryCapsWorkItem ( __in MdDeviceObject  DeviceObject, __in PVOID  Context  )

staticprivate

Definition at line 779 of file fxpkgpdo.cpp.

{
    STACK_DEVICE_CAPABILITIES parentCapabilities;
    MdWorkItem pItem;
    FxPkgPdo* pPkgPdo;
    FxIrp irp;
    NTSTATUS status;
    MxDeviceObject parentDeviceObject;
 
    irp.SetIrp((MdIrp)Context);
    pItem = (MdWorkItem) irp.GetContext(0);
 
    pPkgPdo = FxDevice::GetFxDevice(DeviceObject)->GetPdoPkg();
 
    parentDeviceObject.SetObject(
        pPkgPdo->m_Device->m_ParentDevice->GetDeviceObject());
 
    status = GetStackCapabilities(
        pPkgPdo->m_Device->GetDriverGlobals(),
        &parentDeviceObject,
        NULL, // D3ColdInterface
        &parentCapabilities);
 
    if (NT_SUCCESS(status)) {
#pragma prefast(suppress:__WARNING_POTENTIAL_BUFFER_OVERFLOW_HIGH_PRIORITY, "prefast is confused")
        pPkgPdo->HandleQueryCapabilities(
            irp.GetParameterDeviceCapabilities(),
            &parentCapabilities.DeviceCaps
            );
        status = STATUS_SUCCESS;
    }
 
    pPkgPdo->CompletePnpRequest(&irp, status);
 
    MxWorkItem::_Free(pItem);
}

Referenced by PnpQueryCapabilities().

_RemoveAndReenumerateSelf()

VOID FxPkgPdo::_RemoveAndReenumerateSelf ( __in PVOID  Context )

staticprivate

Definition at line 1665 of file fxpkgpdo.cpp.

{
    ((FxPkgPdo*) Context)->AskParentToRemoveAndReenumerate();
}

Referenced by HandleQueryInterfaceForReenumerate().

AddEjectionDevice()

_Must_inspect_result_ NTSTATUS FxPkgPdo::AddEjectionDevice

(

__in MdDeviceObject

DependentDevice

)

Definition at line 1826 of file fxpkgpdo.cpp.

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

AskParentToRemoveAndReenumerate()

_Must_inspect_result_ NTSTATUS FxPkgPdo::AskParentToRemoveAndReenumerate ( VOID  )

privatevirtual

Implements FxPkgPnp.

Definition at line 1598 of file fxpkgpdo.cpp.

{
    //
    // Static children do not support reenumeration.
    //
    if (m_Description != NULL && m_Static == FALSE) {
        m_Description->GetParentList()->ReenumerateEntry(m_Description);
        return STATUS_SUCCESS;
    }
 
    return STATUS_NOT_FOUND;
}

ClearEjectionDevicesList()

VOID FxPkgPdo::ClearEjectionDevicesList

(

VOID

)

Definition at line 1906 of file fxpkgpdo.cpp.

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

DeleteSymbolicLinkOverload()

VOID FxPkgPdo::DeleteSymbolicLinkOverload ( __in BOOLEAN  GracefulRemove )

privatevirtual

Definition at line 1630 of file fxpkgpdo.cpp.

{
    if (GracefulRemove) {
        //
        // We will remove the symbolic link when we determine if the PDO was
        // reported missing or not.
        //
        return;
    }
    else if (m_Description->IsDeviceReportedMissing()) {
        //
        // Surprise removed and we have reported the PDO as missing
        //
 
        m_Device->DeleteSymbolicLink();
    }
}

DispatchDeviceSetPower()

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

private

Definition at line 151 of file pdopower.cpp.

{
    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.  ASSERT and log
            // an error.
            //
            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());
 
            ASSERTMSG("Received set device power irp but the irp was not "
                "requested by the device (the power policy owner)\n",
                FALSE);
        }
 
        //
        // 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;
        }
    }
 
    SetPendingDevicePowerIrp(Irp);
 
    if (Irp->GetParameterPowerStateDeviceState() == PowerDeviceD0) {
        PowerProcessEvent(PowerD0);
    }
    else {
        PowerProcessEvent(PowerDx);
    }
 
    return STATUS_PENDING;
}

DispatchSystemSetPower()

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

private

Definition at line 95 of file pdopower.cpp.

{
    KIRQL irql;
    MxDeviceObject deviceObject(m_Device->GetDeviceObject());
 
    m_SystemPowerState = (BYTE) Irp->GetParameterPowerStateSystemState();
    deviceObject.SetPowerState(SystemPowerState,
                               Irp->GetParameterPowerState());
 
    if (IsPowerPolicyOwner()) {
        if (m_SystemPowerState == PowerSystemWorking) {
            //
            // Ideally we would like to complete the S0 irp before we start
            // processing the event in the state machine so that the D0 irp
            // comes after the S0 is moving up the stack...
            //
            // ... BUT ...
            //
            // ... by allowing the S0 irp to go up the stack first, we must then
            // handle pnp requests from the current power policy state (because
            // the S0 irp could be the last S irp in the system and when completed,
            // the pnp lock is released).  So, we process the event first so
            // that we can move into a state where we can handle pnp events in
            // the power policy state machine.
            //
            // We mitigate the situation a little bit by forcing the processing of the
            // event to occur on the power policy thread rather then in the current
            // context.
            //
            Mx::MxRaiseIrql(DISPATCH_LEVEL, &irql);
            PowerPolicyProcessEvent(PwrPolS0);
            Mx::MxLowerIrql(irql);
 
            return CompletePowerRequest(Irp, STATUS_SUCCESS);
        }
        else {
            //
            // Power policy state machine will complete the request later
            //
            SetPendingSystemPowerIrp(Irp);
            PowerPolicyProcessEvent(PwrPolSx);
            return STATUS_PENDING;
        }
    }
    else {
        //
        // Since we are not the power policy owner, we just complete all S irps
        //
        return CompletePowerRequest(Irp, STATUS_SUCCESS);
    }
}

FinishInitialize()

VOID FxPkgPdo::FinishInitialize ( __in PWDFDEVICE_INIT  DeviceInit )

virtual

Definition at line 340 of file fxpkgpdo.cpp.

{
    PdoInit* pdoInit;
 
    pdoInit = &DeviceInit->Pdo;
 
    m_DefaultLocale = pdoInit->DefaultLocale;
    m_DeviceTextHead.Next = pdoInit->DeviceText.Next;
    pdoInit->DeviceText.Next = NULL;
 
    //
    // Important to do this last since this will cause a pnp state machine
    // transition
    //
    FxPkgPnp::FinishInitialize(DeviceInit); // __super call
}

FireAndForgetIrp()

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

privatevirtual

Definition at line 384 of file fxpkgpdo.cpp.

{
    NTSTATUS status;
 
    status = Irp->GetStatus();
 
    if (Irp->GetMajorFunction() == IRP_MJ_POWER) {
        return CompletePowerRequest(Irp, status);
    }
    else {
        return CompletePnpRequest(Irp, status);
    }
}

GetDispatchPnp()

virtual const PFN_PNP_POWER_CALLBACK * FxPkgPdo::GetDispatchPnp ( VOID  )

inlineprivatevirtual

Implements FxPkgPnp.

Definition at line 560 of file fxpkgpdo.hpp.

    {
        return m_PdoPnpFunctionTable;
    }

GetDispatchPower()

virtual const PFN_PNP_POWER_CALLBACK * FxPkgPdo::GetDispatchPower ( VOID  )

inlineprivatevirtual

Implements FxPkgPnp.

Definition at line 569 of file fxpkgpdo.hpp.

    {
        return m_PdoPowerFunctionTable;
    }

HandleQueryCapabilities()

VOID FxPkgPdo::HandleQueryCapabilities ( __inout PDEVICE_CAPABILITIES  ReportedCaps, __in PDEVICE_CAPABILITIES  ParentCaps  )

private

Definition at line 666 of file fxpkgpdo.cpp.

{
    LONG pnpCaps;
    ULONG i;
 
    //
    // PowerSystemUnspecified is reserved for system use as per the DDK
    //
    for (i = PowerSystemWorking; i < PowerSystemMaximum; i++) {
        DEVICE_POWER_STATE state;
 
        state = _GetPowerCapState(i, m_PowerCaps.States);
 
        if (state == PowerDeviceMaximum) {
            //
            // PDO did not specify any value, use parent's cap
            //
#pragma prefast(suppress:__WARNING_POTENTIAL_BUFFER_OVERFLOW_HIGH_PRIORITY, "Esp:675")
            ReportedCaps->DeviceState[i] = ParentCaps->DeviceState[i];
        }
        else {
            //
            // Use PDO's reported value
            //
            ReportedCaps->DeviceState[i] = state;
        }
    }
 
    pnpCaps = GetPnpCapsInternal();
 
    //
    // Appropriately fill the DeviceCapabilities structure.
    //
    SET_PNP_CAP(pnpCaps, ReportedCaps, LockSupported);
    SET_PNP_CAP(pnpCaps, ReportedCaps, EjectSupported);
    SET_PNP_CAP(pnpCaps, ReportedCaps, Removable);
    SET_PNP_CAP(pnpCaps, ReportedCaps, DockDevice);
    SET_PNP_CAP(pnpCaps, ReportedCaps, UniqueID);
 
    if ((pnpCaps & FxPnpCapSilentInstallMask) != FxPnpCapSilentInstallUseDefault) {
        SET_PNP_CAP(pnpCaps, ReportedCaps, SilentInstall);
    }
    else if (m_RawOK) {
        //
        // By default, we report raw devices as silent install devices
        // because if they are raw, they don't need any further
        // installation.
        //
        ReportedCaps->SilentInstall = TRUE;
    }
 
    SET_PNP_CAP(pnpCaps, ReportedCaps, SurpriseRemovalOK);
    SET_PNP_CAP(pnpCaps, ReportedCaps, HardwareDisabled);
    SET_PNP_CAP(pnpCaps, ReportedCaps, NoDisplayInUI);
 
    SET_POWER_CAP(m_PowerCaps.Caps , ReportedCaps, WakeFromD0);
    SET_POWER_CAP(m_PowerCaps.Caps , ReportedCaps, WakeFromD1);
    SET_POWER_CAP(m_PowerCaps.Caps , ReportedCaps, WakeFromD2);
    SET_POWER_CAP(m_PowerCaps.Caps , ReportedCaps, WakeFromD3);
    SET_POWER_CAP(m_PowerCaps.Caps , ReportedCaps, DeviceD1);
    SET_POWER_CAP(m_PowerCaps.Caps , ReportedCaps, DeviceD2);
 
    if (m_RawOK) {
        ReportedCaps->RawDeviceOK = TRUE;
    }
 
    ReportedCaps->UINumber = m_PnpCapsUINumber;
    ReportedCaps->Address  = m_PnpCapsAddress;
 
    if (m_PowerCaps.SystemWake != PowerSystemMaximum) {
        ReportedCaps->SystemWake = (SYSTEM_POWER_STATE) m_PowerCaps.SystemWake;
    }
    else {
        ReportedCaps->SystemWake = ParentCaps->SystemWake;
    }
 
    //
    // Set the least-powered device state from which the device can
    // wake the system.
    //
    if (m_PowerCaps.DeviceWake != PowerDeviceMaximum) {
        ReportedCaps->DeviceWake = (DEVICE_POWER_STATE) m_PowerCaps.DeviceWake;
    }
    else {
        ReportedCaps->DeviceWake = ParentCaps->DeviceWake;
    }
 
    //
    // Set the Device wake up latencies.
    //
    if (m_PowerCaps.D1Latency != (ULONG) -1) {
        ReportedCaps->D1Latency = m_PowerCaps.D1Latency;
    }
    else {
        ReportedCaps->D1Latency = 0;
    }
 
    if (m_PowerCaps.D2Latency != (ULONG) -1) {
        ReportedCaps->D2Latency = m_PowerCaps.D2Latency;
    }
    else {
        ReportedCaps->D2Latency = 0;
    }
 
    if (m_PowerCaps.D3Latency != (ULONG) -1) {
        ReportedCaps->D3Latency = m_PowerCaps.D3Latency;
    }
}

Referenced by _QueryCapsWorkItem(), and PnpQueryCapabilities().

HandleQueryInterfaceForReenumerate()

_Must_inspect_result_ NTSTATUS FxPkgPdo::HandleQueryInterfaceForReenumerate	(	__in FxIrp *	Irp,
		__out PBOOLEAN	CompleteRequest
	)

Definition at line 1687 of file fxpkgpdo.cpp.

{
    PREENUMERATE_SELF_INTERFACE_STANDARD pInterface;
    NTSTATUS status;
 
    *CompleteRequest = TRUE;
 
    if (m_Static) {
        //
        // Return the embedded status in the irp since this is a statically
        // enumerated child.  Only dynamically enuemrated child support self
        // reenumeration.
        //
        return Irp->GetStatus();
    }
 
    if (Irp->GetParameterQueryInterfaceVersion() == 1 &&
        Irp->GetParameterQueryInterfaceSize() >= sizeof(*pInterface)) {
 
        pInterface = (PREENUMERATE_SELF_INTERFACE_STANDARD)
            Irp->GetParameterQueryInterfaceInterface();
 
        //
        // Expose the interface to the requesting driver.
        //
        pInterface->Version = 1;
        pInterface->Size = sizeof(*pInterface);
        pInterface->Context = this;
        pInterface->InterfaceReference = FxDevice::_InterfaceReferenceNoOp;
        pInterface->InterfaceDereference = FxDevice::_InterfaceDereferenceNoOp;
        pInterface->SurpriseRemoveAndReenumerateSelf = &FxPkgPdo::_RemoveAndReenumerateSelf;
 
        status = STATUS_SUCCESS;
 
        //
        // Caller assumes a reference has been taken.
        //
        pInterface->InterfaceReference(pInterface->Context);
    }
    else {
        status = STATUS_INVALID_BUFFER_SIZE;
    }
 
    return status;
}

Initialize()

_Must_inspect_result_ NTSTATUS FxPkgPdo::Initialize ( __in PWDFDEVICE_INIT  DeviceInit )

virtual

Reimplemented from FxPkgPnp.

Definition at line 184 of file fxpkgpdo.cpp.

{
    NTSTATUS status;
    size_t cbLength, cbStrLength;
    PWSTR pCur;
    PdoInit* pPdo;
 
    status = FxPkgPnp::Initialize(DeviceInit);
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    cbLength = 0;
 
    //
    // Compute the total number of bytes required for all strings and then
    // make one allocation and remember pointers w/in the string so we can
    // retrieve them individually later.
    //
    pPdo = &DeviceInit->Pdo;
    cbLength += FxCalculateTotalStringSize(&pPdo->HardwareIDs);
    cbLength += FxCalculateTotalStringSize(&pPdo->CompatibleIDs);
 
    if (pPdo->DeviceID != NULL) {
        cbLength += pPdo->DeviceID->ByteLength(TRUE);
    }
    if (pPdo->InstanceID != NULL) {
        cbLength += pPdo->InstanceID->ByteLength(TRUE);
    }
    if (pPdo->ContainerID != NULL) {
        cbLength += pPdo->ContainerID->ByteLength(TRUE);
    }
 
    m_IDsAllocation = (PWSTR) FxPoolAllocate(GetDriverGlobals(),
                                             PagedPool,
                                             cbLength);
 
    if (m_IDsAllocation == NULL) {
        status = STATUS_INSUFFICIENT_RESOURCES;
 
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
            "DeviceInit %p could not allocate string for device IDs "
            "(length %I64d), %!STATUS!", DeviceInit, cbLength, status);
 
        return status;
    }
 
    pCur = m_IDsAllocation;
 
    m_HardwareIDs = pCur;
    pCur = FxCopyMultiSz(m_HardwareIDs, &pPdo->HardwareIDs);
 
    m_CompatibleIDs = pCur;
    pCur = FxCopyMultiSz(m_CompatibleIDs, &pPdo->CompatibleIDs);
 
    if (pPdo->DeviceID != NULL) {
        m_DeviceID = pCur;
 
        //
        // Copy the bytes and then null terminate the buffer
        //
        cbStrLength = pPdo->DeviceID->ByteLength(FALSE);
 
        RtlCopyMemory(m_DeviceID,
                      pPdo->DeviceID->Buffer(),
                      cbStrLength);
 
        m_DeviceID[cbStrLength / sizeof(WCHAR)] = UNICODE_NULL;
 
        pCur = (PWSTR) WDF_PTR_ADD_OFFSET(m_DeviceID,
                                          cbStrLength + sizeof(UNICODE_NULL));
    }
 
    if (pPdo->InstanceID != NULL) {
        m_InstanceID = pCur;
 
        //
        // Copy the bytes and then null terminate the buffer
        //
        cbStrLength = pPdo->InstanceID->ByteLength(FALSE);
 
        RtlCopyMemory(m_InstanceID,
                      pPdo->InstanceID->Buffer(),
                      cbStrLength);
 
        m_InstanceID[cbStrLength / sizeof(WCHAR)] = UNICODE_NULL;
 
        pCur = (PWSTR) WDF_PTR_ADD_OFFSET(m_InstanceID,
                                          cbStrLength + sizeof(UNICODE_NULL));
    }
 
    if (pPdo->ContainerID != NULL) {
        m_ContainerID = pCur;
 
        //
        // Copy the bytes and then null terminate the buffer
        //
        cbStrLength = pPdo->ContainerID->ByteLength(FALSE);
 
        RtlCopyMemory(m_ContainerID,
                      pPdo->ContainerID->Buffer(),
                      cbStrLength);
 
        m_ContainerID[cbStrLength / sizeof(WCHAR)] = UNICODE_NULL;
    }
 
    m_Static = pPdo->Static;
 
    if (m_Static) {
        //
        // Statically enumerated children do not support reenumeration requests
        // from the stack on top of them.
        //
 
        //
        // The only way we can have static children is if an FDO enumerates them.
        //
 
 
 
 
 
        Mx::MxAssert(m_Device->m_ParentDevice->IsFdo());
        m_OwningChildList = m_Device->m_ParentDevice->GetFdoPkg()->m_StaticDeviceList;
 
        m_OwningChildList->ADDREF(this);
    }
    else {
        m_Description = pPdo->DescriptionEntry;
 
        m_OwningChildList = m_Description->GetParentList();
        m_OwningChildList->ADDREF(this);
    }
 
    return STATUS_SUCCESS;
}

IsForwardRequestToParentEnabled()

__inline BOOLEAN FxPkgPdo::IsForwardRequestToParentEnabled ( VOID  )

inline

Definition at line 206 of file fxpkgpdo.hpp.

    {
        return m_AllowForwardRequestToParent;
    }

PnpEventCheckForDevicePresenceOverload()

WDF_DEVICE_PNP_STATE FxPkgPdo::PnpEventCheckForDevicePresenceOverload ( VOID  )

privatevirtual

Implements FxPkgPnp.

Definition at line 1155 of file fxpkgpdo.cpp.

{
    if (m_Description != NULL) {
        if (m_Description->IsDeviceRemoved()) {
            //
            // The description freed itself now that the device has been reported
            // missing.
            //
            return WdfDevStatePnpPdoRemoved;
        }
        else {
            //
            // Device was not reported as missing, keep it alive
            //
            return WdfDevStatePnpRemovedPdoWait;
        }
    }
    else {
        //
        // Only static children can get this far without having an m_Description
        //
        ASSERT(m_Static);
 
        //
        // The description freed itself now that the device has been reported
        // missing.
        //
        return WdfDevStatePnpPdoRemoved;
    }
}

PnpEventEjectHardwareOverload()

WDF_DEVICE_PNP_STATE FxPkgPdo::PnpEventEjectHardwareOverload ( VOID  )

privatevirtual

Implements FxPkgPnp.

Definition at line 1045 of file fxpkgpdo.cpp.

{
    NTSTATUS status;
    WDF_DEVICE_PNP_STATE state;
 
    status = m_DeviceEject.Invoke(m_Device->GetHandle());
 
    if (NT_SUCCESS(status)) {
 
        //
        // Upon a successful eject, mark the child as missing so that when we
        // get another QDR, it is not re-reported.
        //
        FxChildList* pList;
        MxEvent* event;
 
        pList = m_Description->GetParentList();
 
        status = pList->UpdateAsMissing(m_Description->GetId());
        if (NT_SUCCESS(status)) {
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGPNP,
                "PDO WDFDEVICE %p !devobj %p marked missing as a result of eject",
                m_Device->GetHandle(), m_Device->GetDeviceObject());
        }
        else {
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                "Failed to mark PDO WDFDEVICE %p !devobj %p missing after eject %!STATUS!",
                m_Device->GetHandle(), m_Device->GetDeviceObject(),
                status);
        }
 
        //
        // We must wait for any pending scans to finish so that the previous
        // update as missing is enacted into the list and reported to the
        // OS.  Otherwise, if we don't wait we could be in the middle of a
        // scan, complete the eject, report the child again and it will be
        // reenumerated.
        //
        event = pList->GetScanEvent();
 
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
                            "waiting on event %p for device to finish scanning",
                            &event);
 
        //
        // No need to wait in a crtical region because we are in the context of a
        // pnp request which is in the system context.
        //
        event->WaitFor(Executive, KernelMode, FALSE, NULL);
 
        //
        // Change the state.
        //
        state = WdfDevStatePnpEjectedWaitingForRemove;
    }
    else {
        state = WdfDevStatePnpEjectFailed;
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
            "Eject failed since driver's EvtDeviceEject returned %!STATUS!", status);
 
        if (status == STATUS_NOT_SUPPORTED) {
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGDEVICE,
                "EvtDeviceEject returned an invalid status STATUS_NOT_SUPPORTED");
 
            if (GetDriverGlobals()->IsVerificationEnabled(1, 11, OkForDownLevel)) {
                FxVerifierDbgBreakPoint(GetDriverGlobals());
            }
        }
    }
 
    //
    // set irp status
    //
    SetPendingPnpIrpStatus(status);
 
    //
    // Pnp dispatch routine is waiting on this event, and it will complete
    // the Eject irp
    //
    m_DeviceEjectProcessed->Set();
 
    return state;
}

PnpEventFdoRemovedOverload()

WDF_DEVICE_PNP_STATE FxPkgPdo::PnpEventFdoRemovedOverload ( VOID  )

privatevirtual

Implements FxPkgPnp.

Definition at line 1269 of file fxpkgpdo.cpp.

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

PnpEventPdoRemovedOverload()

WDF_DEVICE_PNP_STATE FxPkgPdo::PnpEventPdoRemovedOverload ( VOID  )

privatevirtual

Implements FxPkgPnp.

Definition at line 1208 of file fxpkgpdo.cpp.

{
    m_CanBeDeleted = TRUE;
 
    //
    // Unconditionally delete the symbolic link now (vs calling
    // DeleteSymbolicLinkOverload()) because we know that the device has been
    // reported as missing.
    //
    m_Device->DeleteSymbolicLink();
 
    //
    // Do that which all device stacks need to do upon removal.
    //
    PnpEventRemovedCommonCode();
 
    //
    // m_Device is Release()'ed in FxPkgPnp::PnpEventFinal
    //
    if (m_Description != NULL) {
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
                            "Removing entry reference %p on FxPkgPnp %p",
                            m_Description, this);
 
        m_Description->ProcessDeviceRemoved();
        m_Description = NULL;
    }
 
    return WdfDevStatePnpFinal;
}

PnpEventSurpriseRemovePendingOverload()

VOID FxPkgPdo::PnpEventSurpriseRemovePendingOverload ( VOID  )

privatevirtual

Reimplemented from FxPkgPnp.

Definition at line 1282 of file fxpkgpdo.cpp.

{
    if (m_Description != NULL) {
        m_Description->DeviceSurpriseRemoved();
    }
 
    FxPkgPnp::PnpEventSurpriseRemovePendingOverload();
}

PnpGetPostRemoveState()

WDF_DEVICE_PNP_STATE FxPkgPdo::PnpGetPostRemoveState ( VOID  )

privatevirtual

Implements FxPkgPnp.

Definition at line 1258 of file fxpkgpdo.cpp.

{
    //
    // Transition to the check for device presence state.
    //
    return WdfDevStatePnpCheckForDevicePresence;
}

PnpQueryCapabilities()

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

private

Definition at line 561 of file fxpkgpdo.cpp.

{
    PDEVICE_CAPABILITIES pDeviceCapabilities;
    STACK_DEVICE_CAPABILITIES parentStackCapabilities = {0};
    NTSTATUS status;
 
    status = STATUS_UNSUCCESSFUL;
 
    pDeviceCapabilities = Irp->GetParameterDeviceCapabilities();
 
    //
    // Confirm this is a valid DeviceCapabilities structure.
    //
    ASSERT(pDeviceCapabilities->Size >= sizeof(DEVICE_CAPABILITIES));
    ASSERT(pDeviceCapabilities->Version == 1);
 
    if ((pDeviceCapabilities->Version == 1) &&
        (pDeviceCapabilities->Size >= sizeof(DEVICE_CAPABILITIES))) {
 
        //
        // Since query caps must be sent to the parent stack until it reaches
        // the root, we can quickly run out of stack space.  If that happens,
        // then move to a work item to get a fresh stack with plenty of stack
        // space.
        //
        if (Mx::MxHasEnoughRemainingThreadStack() == FALSE) {
            MxWorkItem workItem;
 
            status = workItem.Allocate(m_Device->GetDeviceObject());
 
            if (NT_SUCCESS(status)) {
                //
                // Store off the work item so we can free it in the worker routine
                //
                Irp->SetContext(0, (PVOID)workItem.GetWorkItem());
 
                //
                // Mark the irp as pending because it will be completed in
                // another thread
                //
                Irp->MarkIrpPending();
 
                //
                // Kick off to another thread
                //
                workItem.Enqueue(_QueryCapsWorkItem, Irp->GetIrp());
 
                return STATUS_PENDING;
            }
            else {
                //
                // Not enough for a work item, return error
                //
                status = STATUS_INSUFFICIENT_RESOURCES;
            }
        }
        else {
            MxDeviceObject parentDeviceObject;
 
            parentDeviceObject.SetObject(
                m_Device->m_ParentDevice->GetDeviceObject());
            status = GetStackCapabilities(
                GetDriverGlobals(),
                &parentDeviceObject,
                NULL,   // D3ColdInterface
                &parentStackCapabilities);
 
            if (NT_SUCCESS(status)) {
#pragma prefast(suppress:__WARNING_POTENTIAL_BUFFER_OVERFLOW_HIGH_PRIORITY, "prefast is confused")
                HandleQueryCapabilities(pDeviceCapabilities,
                                        &parentStackCapabilities.DeviceCaps);
 
                //
                // The check above does not guarantee STATUS_SUCCESS explicitly
                // (ie the verifier can change the value to something other then
                // STATUS_SUCCESS) so set it here
                //
                status = STATUS_SUCCESS;
            }
        }
    }
 
    return CompletePnpRequest(Irp, status);
}

PnpQueryDeviceRelations()

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

private

Definition at line 434 of file fxpkgpdo.cpp.

{
    PDEVICE_RELATIONS pDeviceRelations;
    NTSTATUS status;
    DEVICE_RELATION_TYPE type;
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
 
    status = Irp->GetStatus();
    pFxDriverGlobals = GetDriverGlobals();
 
    type = Irp->GetParameterQDRType();
    switch (type) {
    case BusRelations:
        status = HandleQueryBusRelations(Irp);
        break;
 
    case EjectionRelations:
    case RemovalRelations:
        status = HandleQueryDeviceRelations(
            Irp,
            (type == RemovalRelations) ? m_RemovalDeviceList
                                       : m_EjectionDeviceList);
 
        //
        // 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) {
            //
            // Complete the request with the status it was received with
            //
            status = Irp->GetStatus();
        }
        break;
 
    case TargetDeviceRelation:
        pDeviceRelations = (PDEVICE_RELATIONS) MxMemory::MxAllocatePoolWithTag(
                PagedPool, sizeof(DEVICE_RELATIONS), pFxDriverGlobals->Tag);
 
        if (pDeviceRelations != NULL) {
            PDEVICE_OBJECT pDeviceObject;
 
            pDeviceObject = reinterpret_cast<PDEVICE_OBJECT> (m_Device->GetDeviceObject());
 
            Mx::MxReferenceObject(pDeviceObject);
 
            pDeviceRelations->Count = 1;
            pDeviceRelations->Objects[0] = pDeviceObject;
 
            Irp->SetInformation((ULONG_PTR) pDeviceRelations);
            status = STATUS_SUCCESS;
        }
        else {
            Irp->SetInformation(NULL);
            status = STATUS_INSUFFICIENT_RESOURCES;
 
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                "WDFDEVICE %p failing TargetDeviceRelations, %!STATUS!",
                m_Device->GetHandle(), status);
        }
        break;
    }
 
    return CompletePnpRequest(Irp, status);
}

PnpQueryResourceRequirements()

_Must_inspect_result_ NTSTATUS FxPkgPdo::PnpQueryResourceRequirements ( __inout FxIrp *  Irp )

private

Definition at line 141 of file fxpkgpdokm.cpp.

{
    PIO_RESOURCE_REQUIREMENTS_LIST pWdmRequirementsList;
    FxIoResReqList *pIoResReqList = NULL;
    PSINGLE_LIST_ENTRY ple;
    NTSTATUS status;
 
    status = STATUS_SUCCESS;
 
    m_DeviceInterfaceLock.AcquireLock(GetDriverGlobals());
 
 
 
 
    // We know for sure that the PDO is known to pnp now because it has received
    // this query resource requirements request.
    m_Device->m_PdoKnown = TRUE;
 
    //
    // Now that it is a known PDO, we can register interfaces on it whose
    // registration was delayed because the PDO was unknown at the time of the
    // call to WdfDeviceCreateDeviceInterface. If it is not the first time
    // then we re-register (see comments below for reason).
    //
    for (ple = m_DeviceInterfaceHead.Next; ple != NULL; ple = ple->Next) {
        FxDeviceInterface *pDeviceInterface;
 
        pDeviceInterface = FxDeviceInterface::_FromEntry(ple);
 
        //
        // At this time the interface may be in registered or unregistered state.
        // The reason being that pnp may unregister the interface from underneath
        // during the life of PDO (note that drivers never unregister explicitly
        // as there is no unregistration API, and the scenarios in which it can
        // happen are given below). Therefore WDF needs to re-register the interface,
        // otherwise driver may end up with an unregistered interface and fail to
        // enable interface.
        //
        // Pnp can unregister the interface in following cases:
        // 1. The driver is uninstalled, and re-installed
        //    In this case, the stack is torn down but the PDO is not
        //    deleted. Pnp deletes the interface registration, however WDF
        //    doesn't delete the interface structure because it is deleted as
        //    part of PDO deletion in destructor. When the driver is re-installed
        //    Pnp sends another query resource requirements irp and WDF needs to
        //    re-register at this time.
        //
        // 2. Pnp couldn't find a driver and loaded a NULL driver while
        //    waiting for reinstall to happen from WU. This is similar to case above
        //    except that the pnp activities are transparent to user.
        //    In this case, PDO was never started. However it did get
        //    the query resource requirements irp and therefore its interface
        //    was registered by WDF. Pnp deleted the interface registration
        //    when installing NULL driver. When pnp finally finds a driver from
        //    WU, it sends another query resource requirement irp. At this time,
        //    WDF needs to re-register.
        //
        // In both the above cases, WDF has to re-register (and free previous
        // sym link) when query resource requirements irp arrives again. Note
        // that Pnp doesn't delete the interface registration during disable,
        // s/w surprise-removal, or resource rebalance. In case of resource
        // rebalance, query resource requirement irp is sent after stop, and
        // WDF will end up registering again even though pnp did not unregister
        // the interface. This is fine because kernel API for registration
        // allows multiple calls to register, and in case registration already
        // exists it returns informational status (not error status)
        // STATUS_OBJECT_NAME_EXISTS and also returns the same symbolic link.
        //
        //
        // Free the symbolic link if already present
        //
        if (pDeviceInterface->m_SymbolicLinkName.Buffer != NULL) {
            RtlFreeUnicodeString(&pDeviceInterface->m_SymbolicLinkName);
            RtlZeroMemory(&pDeviceInterface->m_SymbolicLinkName,
                          sizeof(pDeviceInterface->m_SymbolicLinkName));
        }
 
        //
        // Register. Note that if the interface was already registered, the
        // call to IoRegisterDeviceInterface will return informational status
        // (not error status) STATUS_OBJECT_NAME_EXISTS and also return the
        // symbolic link.
        //
        status = pDeviceInterface->Register(
            m_Device->GetPhysicalDevice()
            );
 
        if (!NT_SUCCESS(status)) {
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                "could not register device interface on PDO WDFDEVICE %p, "
                "!devobj %p, failing IRP_MN_QUERY_RESOURCE_REQUIREMENTS %!STATUS!",
                m_Device->GetHandle(),
                m_Device->GetDeviceObject(), status);
            break;
        }
    }
 
    m_DeviceInterfaceLock.ReleaseLock(GetDriverGlobals());
 
    if (!NT_SUCCESS(status)) {
        return CompletePnpRequest(Irp, status);
    }
 
    //
    // Driver writer is not interested in this callback, forgoe the allocation
    // of the FxCollection and complete the request here.
    //
    if (m_DeviceResourceRequirementsQuery.m_Method == NULL) {
        return CompletePnpRequest(Irp, status);
    }
 
    pWdmRequirementsList = NULL;
 
    //
    // Create a collection which will be populated by the
    // bus driver.
    //
    status = FxIoResReqList::_CreateAndInit(&pIoResReqList,
                                            GetDriverGlobals(),
                                            WDF_NO_OBJECT_ATTRIBUTES,
                                            FxResourceAllAccessAllowed);
    if (!NT_SUCCESS(status)) {
        goto exit;
    }
 
    WDFIORESREQLIST reqlist;
 
    //
    // Get a handle to the collection that can be passed to the driver.
    //
    status = pIoResReqList->Commit(NULL, (PWDFOBJECT) &reqlist);
 
    //
    // We control the object's state, this should never fail
    //
    ASSERT(NT_SUCCESS(status));
    UNREFERENCED_PARAMETER(status);
 
    //
    // Call the driver.  The driver will populate the resource collection
    // with a set of child collections which will contain each of the
    // possible resource assignments.
    //
    status = m_DeviceResourceRequirementsQuery.Invoke(
        m_Device->GetHandle(), reqlist);
 
    if (NT_SUCCESS(status)) {
        if (pIoResReqList->Count()) {
            //
            // Create a IO_RESOURCE_REQUIREMENTS_LIST based on the
            // contents of our collection.
            //
            pWdmRequirementsList = pIoResReqList->CreateWdmList();
 
            if (pWdmRequirementsList != NULL) {
                Irp->SetInformation((ULONG_PTR) pWdmRequirementsList);
            }
            else {
                status = STATUS_INSUFFICIENT_RESOURCES;
            }
        }
        else {
            //
            // The driver didn't add any resources, so we'll just
            // ignore this request.
            //
            // Return the status that was passed in.
            //
            status = Irp->GetStatus();
        }
    }
 
    pIoResReqList->DeleteObject();
 
    exit:
        return CompletePnpRequest(Irp, status);
}

PnpQueryResources()

_Must_inspect_result_ NTSTATUS FxPkgPdo::PnpQueryResources ( __inout FxIrp *  Irp )

private

Definition at line 49 of file fxpkgpdokm.cpp.

{
    FxCmResList *pResList = NULL;
    PCM_RESOURCE_LIST pWdmResourceList;
    WDFCMRESLIST list;
    NTSTATUS status;
 
    //
    // It is only necessary to create a collection if the caller is interested
    // in this callback.
    //
    if (m_DeviceResourcesQuery.m_Method == NULL) {
        return CompletePnpRequest(Irp, Irp->GetStatus());
    }
 
    pWdmResourceList = NULL;
 
    status = FxCmResList::_CreateAndInit(&pResList,
                                         GetDriverGlobals(),
                                         m_Device,
                                         WDF_NO_OBJECT_ATTRIBUTES,
                                         FxResourceAllAccessAllowed);
    if (!NT_SUCCESS(status)) {
        goto exit;
    }
 
    status = pResList->Commit(NULL, (PWDFOBJECT) &list);
 
    if (NT_SUCCESS(status)) {
        status = m_DeviceResourcesQuery.Invoke(
            m_Device->GetHandle(), list);
 
        if (NT_SUCCESS(status)) {
            //
            // Walk the resource collection and create the appropriate
            // CM_RESOURCE_LIST.
            //
            if (pResList->Count()) {
                pWdmResourceList = pResList->CreateWdmList();
            }
            else {
                //
                // The driver didn't add any resources, so we'll just
                // ignore this Irp.
                //
                // Return that status that was passed in.
                //
                status = Irp->GetStatus();
                pWdmResourceList = (PCM_RESOURCE_LIST) Irp->GetInformation();
            }
        }
    }
 
    pResList->DeleteObject();
 
    exit:
        Irp->SetInformation((ULONG_PTR) pWdmResourceList);
        return CompletePnpRequest(Irp, status);
}

PnpSendStartDeviceDownTheStackOverload()

BOOLEAN FxPkgPdo::PnpSendStartDeviceDownTheStackOverload ( VOID  )

privatevirtual

Implements FxPkgPnp.

Definition at line 1294 of file fxpkgpdo.cpp.

{
    //
    // We are successful so far, indicate this in the irp.
    //
    SetPendingPnpIrpStatus(STATUS_SUCCESS);
 
    return TRUE;
}

PowerCheckDeviceTypeNPOverload()

WDF_DEVICE_POWER_STATE FxPkgPdo::PowerCheckDeviceTypeNPOverload ( VOID  )

privatevirtual

Implements FxPkgPnp.

Definition at line 310 of file pdopower.cpp.

{
    return WdfDevStatePowerCheckParentStateNP;
}

PowerCheckDeviceTypeOverload()

WDF_DEVICE_POWER_STATE FxPkgPdo::PowerCheckDeviceTypeOverload ( VOID  )

privatevirtual

Implements FxPkgPnp.

Definition at line 289 of file pdopower.cpp.

{
    return WdfDevStatePowerCheckParentState;
}

PowerCheckParentOverload()

_Must_inspect_result_ NTSTATUS FxPkgPdo::PowerCheckParentOverload ( __in BOOLEAN *  ParentOn )

privatevirtual

Definition at line 261 of file pdopower.cpp.

{
 
 
 
 
    return (m_Device->m_ParentDevice->m_PkgPnp)->
        PowerPolicyCanChildPowerUp(ParentOn);
}

PowerDisableWakeAtBusOverload()

VOID FxPkgPdo::PowerDisableWakeAtBusOverload ( VOID  )

privatevirtual

Reimplemented from FxPkgPnp.

Definition at line 374 of file pdopower.cpp.

{
    if (m_EnableWakeAtBusInvoked) {
        m_EnableWakeAtBusInvoked = FALSE;
        PowerNotifyParentChildWakeDisarmed();
 
        m_DeviceDisableWakeAtBus.Invoke(m_Device->GetHandle());
    }
}

PowerEnableWakeAtBusOverload()

_Must_inspect_result_ NTSTATUS FxPkgPdo::PowerEnableWakeAtBusOverload ( VOID  )

privatevirtual

Reimplemented from FxPkgPnp.

Definition at line 332 of file pdopower.cpp.

{
    NTSTATUS status;
 
    //
    // The EnableWakeAtBus callback should not be called twice in a row without
    // an intermediate call to the DisableWakeAtBus callback.
    //
    ASSERT(m_EnableWakeAtBusInvoked == FALSE);
 
    status = m_DeviceEnableWakeAtBus.Invoke(
        m_Device->GetHandle(),
        (SYSTEM_POWER_STATE) m_SystemPowerState
        );
 
    if (NT_SUCCESS(status)) {
        m_EnableWakeAtBusInvoked = TRUE;
        PowerNotifyParentChildWakeArmed();
    }
 
    return status;
}

PowerNotifyParentChildWakeArmed()

VOID FxPkgPdo::PowerNotifyParentChildWakeArmed ( VOID  )

private

Definition at line 426 of file pdopower.cpp.

{
    FxPowerPolicyOwnerSettings* settings;
 
    ASSERT(m_Device->m_ParentDevice != NULL);
 
 
 
 
 
    settings = m_Device->m_ParentDevice->m_PkgPnp->
        m_PowerPolicyMachine.m_Owner;
    if (settings != NULL) {
        settings->IncrementChildrenArmedForWakeCount();
    }
}

Referenced by PowerEnableWakeAtBusOverload().

PowerNotifyParentChildWakeDisarmed()

VOID FxPkgPdo::PowerNotifyParentChildWakeDisarmed ( VOID  )

private

Definition at line 459 of file pdopower.cpp.

{
    FxPowerPolicyOwnerSettings* settings;
 
    ASSERT(m_Device->m_ParentDevice != NULL);
 
 
 
 
 
    settings = m_Device->m_ParentDevice->m_PkgPnp->
        m_PowerPolicyMachine.m_Owner;
    if (settings != NULL) {
        settings->DecrementChildrenArmedForWakeCount();
    }
}

Referenced by PowerDisableWakeAtBusOverload().

PowerParentPowerDereference()

VOID FxPkgPdo::PowerParentPowerDereference ( VOID  )

privatevirtual

Implements FxPkgPnp.

Definition at line 403 of file pdopower.cpp.

{
 
    m_Device->m_ParentDevice->m_PkgPnp->PowerPolicyChildPoweredDown();
}

PowerReleasePendingDeviceIrp()

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

privatevirtual

Definition at line 241 of file pdopower.cpp.

{
    MdIrp pIrp;
 
    pIrp = ClearPendingDevicePowerIrp();
 
    UNREFERENCED_PARAMETER(IrpMustBePresent);
    ASSERT(IrpMustBePresent == FALSE || pIrp != NULL);
 
    if (pIrp != NULL) {
        FxIrp irp(pIrp);
 
        CompletePowerRequest(&irp, STATUS_SUCCESS);
    }
}

ProcessRemoveDeviceOverload()

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

privatevirtual

Definition at line 1753 of file fxpkgpdo.cpp.

{
    if (m_CanBeDeleted) {
        //
        // 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);
 
        //
        // Detach and delete the device object.
        //
        DeleteDevice();
 
        //
        // Can't call CompletePnpRequest because we just released the tag in
        // IoReleaseRemoveLockAndWait above.
        //
        Irp->CompleteRequest(IO_NO_INCREMENT);
 
        return STATUS_SUCCESS;
    }
    else {
        //
        // This was a PDO which was not reported missing, so do not free the
        // memory and clear out our stack local address.
        //
        m_DeviceRemoveProcessed = NULL;
        return CompletePnpRequest(Irp, Irp->GetStatus());
    }
}

QueryForPowerThread()

_Must_inspect_result_ NTSTATUS FxPkgPdo::QueryForPowerThread ( VOID  )

privatevirtual

Implements FxPkgPnp.

Definition at line 1804 of file fxpkgpdo.cpp.

{
    return CreatePowerThread();
}

QueryForReenumerationInterface()

virtual VOID FxPkgPdo::QueryForReenumerationInterface ( VOID  )

inlineprivatevirtual

Implements FxPkgPnp.

Definition at line 522 of file fxpkgpdo.hpp.

    {
        //
        // As the PDO, we already have the interface built in
        //
        DO_NOTHING();
    }

RegisterCallbacks()

VOID FxPkgPdo::RegisterCallbacks

(

__in PWDF_PDO_EVENT_CALLBACKS

DispatchTable

)

Definition at line 1576 of file fxpkgpdo.cpp.

{
    m_DeviceResourcesQuery.m_Method            = DispatchTable->EvtDeviceResourcesQuery;
    m_DeviceResourceRequirementsQuery.m_Method = DispatchTable->EvtDeviceResourceRequirementsQuery;
    m_DeviceEject.m_Method                     = DispatchTable->EvtDeviceEject;
    m_DeviceSetLock.m_Method                   = DispatchTable->EvtDeviceSetLock;
 
    m_DeviceEnableWakeAtBus.m_Method           = DispatchTable->EvtDeviceEnableWakeAtBus;
    m_DeviceDisableWakeAtBus.m_Method          = DispatchTable->EvtDeviceDisableWakeAtBus;
 
    //
    // this callback was added in V1.11
    //
    if (DispatchTable->Size > sizeof(WDF_PDO_EVENT_CALLBACKS_V1_9)) {
        m_DeviceReportedMissing.m_Method       = DispatchTable->EvtDeviceReportedMissing;
    }
}

Referenced by FxDevice::PdoInitialize().

ReleaseReenumerationInterface()

virtual VOID FxPkgPdo::ReleaseReenumerationInterface ( VOID  )

inlineprivatevirtual

Implements FxPkgPnp.

Definition at line 534 of file fxpkgpdo.hpp.

    {
        //
        // As the PDO, we already have the interface built in
        //
        DO_NOTHING();
    }

RemoveEjectionDevice()

VOID FxPkgPdo::RemoveEjectionDevice

(

__in MdDeviceObject

DependentDevice

)

Definition at line 1890 of file fxpkgpdo.cpp.

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

SendIrpSynchronously()

_Must_inspect_result_ NTSTATUS FxPkgPdo::SendIrpSynchronously ( __in FxIrp *  Irp )

privatevirtual

Definition at line 361 of file fxpkgpdo.cpp.

{
    return Irp->GetStatus();
}

Member Data Documentation

m_AddedToStaticList

BOOLEAN FxPkgPdo::m_AddedToStaticList

Definition at line 63 of file fxpkgpdo.hpp.

Referenced by FxChildList::Add(), FxDevice::DeleteObject(), and FxPkgPdo().

m_AllowForwardRequestToParent

BOOLEAN FxPkgPdo::m_AllowForwardRequestToParent

Definition at line 69 of file fxpkgpdo.hpp.

Referenced by IsForwardRequestToParentEnabled(), and FxDevice::PdoInitialize().

m_CanBeDeleted

BOOLEAN FxPkgPdo::m_CanBeDeleted

protected

Definition at line 123 of file fxpkgpdo.hpp.

Referenced by FxPkgPdo(), PnpEventPdoRemovedOverload(), and ProcessRemoveDeviceOverload().

m_CompatibleIDs

PWSTR FxPkgPdo::m_CompatibleIDs

protected

Definition at line 98 of file fxpkgpdo.hpp.

Referenced by _PnpQueryId(), FxPkgPdo(), and Initialize().

m_ContainerID

PWSTR FxPkgPdo::m_ContainerID

protected

Definition at line 105 of file fxpkgpdo.hpp.

Referenced by _PnpQueryId(), FxPkgPdo(), and Initialize().

m_DefaultLocale

LCID FxPkgPdo::m_DefaultLocale

Definition at line 38 of file fxpkgpdo.hpp.

Referenced by _PnpQueryDeviceText(), and FinishInitialize().

m_Description

FxDeviceDescriptionEntry* FxPkgPdo::m_Description

Definition at line 40 of file fxpkgpdo.hpp.

Referenced by _PnpSurpriseRemoval(), FxChildList::Add(), AskParentToRemoveAndReenumerate(), DeleteSymbolicLinkOverload(), FxChildList::DrainFreeListHead(), FxPkgPdo(), Initialize(), FxDeviceDescriptionEntry::IsDeviceRemoved(), PnpEventCheckForDevicePresenceOverload(), PnpEventEjectHardwareOverload(), PnpEventPdoRemovedOverload(), and PnpEventSurpriseRemovePendingOverload().

m_DeviceDisableWakeAtBus

FxPowerDeviceDisableWakeAtBus FxPkgPdo::m_DeviceDisableWakeAtBus

Definition at line 54 of file fxpkgpdo.hpp.

Referenced by PowerDisableWakeAtBusOverload(), and RegisterCallbacks().

m_DeviceEject

FxPnpDeviceEject FxPkgPdo::m_DeviceEject

Definition at line 50 of file fxpkgpdo.hpp.

Referenced by PnpEventEjectHardwareOverload(), and RegisterCallbacks().

m_DeviceEjectProcessed

MxEvent* FxPkgPdo::m_DeviceEjectProcessed

protected

Definition at line 121 of file fxpkgpdo.hpp.

Referenced by _PnpEject(), FxPkgPdo(), and PnpEventEjectHardwareOverload().

m_DeviceEnableWakeAtBus

FxPowerDeviceEnableWakeAtBus FxPkgPdo::m_DeviceEnableWakeAtBus

Definition at line 53 of file fxpkgpdo.hpp.

Referenced by PowerEnableWakeAtBusOverload(), and RegisterCallbacks().

m_DeviceID

PWSTR FxPkgPdo::m_DeviceID

protected

Definition at line 77 of file fxpkgpdo.hpp.

Referenced by _PnpQueryId(), FxPkgPdo(), and Initialize().

m_DeviceReportedMissing

FxPnpDeviceReportedMissing FxPkgPdo::m_DeviceReportedMissing

Definition at line 57 of file fxpkgpdo.hpp.

Referenced by RegisterCallbacks().

m_DeviceResourceRequirementsQuery

FxPnpDeviceResourceRequirementsQuery FxPkgPdo::m_DeviceResourceRequirementsQuery

Definition at line 49 of file fxpkgpdo.hpp.

Referenced by PnpQueryResourceRequirements(), and RegisterCallbacks().

m_DeviceResourcesQuery

FxPnpDeviceResourcesQuery FxPkgPdo::m_DeviceResourcesQuery

Definition at line 48 of file fxpkgpdo.hpp.

Referenced by PnpQueryResources(), and RegisterCallbacks().

m_DeviceSetLock

FxPnpDeviceSetLock FxPkgPdo::m_DeviceSetLock

Definition at line 51 of file fxpkgpdo.hpp.

Referenced by RegisterCallbacks().

m_DeviceTextHead

SINGLE_LIST_ENTRY FxPkgPdo::m_DeviceTextHead

Definition at line 37 of file fxpkgpdo.hpp.

Referenced by _PnpQueryDeviceText(), FinishInitialize(), FxPkgPdo(), and ~FxPkgPdo().

m_EjectionDeviceList

FxRelatedDeviceList* FxPkgPdo::m_EjectionDeviceList

protected

Definition at line 113 of file fxpkgpdo.hpp.

Referenced by AddEjectionDevice(), ClearEjectionDevicesList(), FxPkgPdo(), PnpQueryDeviceRelations(), RemoveEjectionDevice(), and ~FxPkgPdo().

m_EnableWakeAtBusInvoked

BOOLEAN FxPkgPdo::m_EnableWakeAtBusInvoked

protected

Definition at line 141 of file fxpkgpdo.hpp.

Referenced by FxPkgPdo(), PowerDisableWakeAtBusOverload(), and PowerEnableWakeAtBusOverload().

m_HardwareIDs

PWSTR FxPkgPdo::m_HardwareIDs

protected

Definition at line 91 of file fxpkgpdo.hpp.

Referenced by _PnpQueryId(), FxPkgPdo(), and Initialize().

m_IDsAllocation

PWSTR FxPkgPdo::m_IDsAllocation

protected

Definition at line 111 of file fxpkgpdo.hpp.

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

m_InstanceID

PWSTR FxPkgPdo::m_InstanceID

protected

Definition at line 84 of file fxpkgpdo.hpp.

Referenced by _PnpQueryId(), FxPkgPdo(), and Initialize().

m_OwningChildList

FxChildList* FxPkgPdo::m_OwningChildList

Definition at line 42 of file fxpkgpdo.hpp.

Referenced by FxPkgPdo(), if(), Initialize(), and ~FxPkgPdo().

m_PdoPnpFunctionTable

const PFN_PNP_POWER_CALLBACK FxPkgPdo::m_PdoPnpFunctionTable

staticprivate

Initial value:

=
{
    _PnpStartDevice,                
    _PnpQueryRemoveDevice,          
    _PnpRemoveDevice,               
    _PnpCancelRemoveDevice,         
    _PnpStopDevice,                 
    _PnpQueryStopDevice,            
    _PnpCancelStopDevice,           
 
    _PnpQueryDeviceRelations,       
    _PnpQueryInterface,             
    _PnpQueryCapabilities,          
    _PnpQueryResources,             
    _PnpQueryResourceRequirements,  
    _PnpQueryDeviceText,            
    _PnpFilterResourceRequirements, 
 
    _PnpCompleteIrp,                
 
    _PnpCompleteIrp,                
    _PnpCompleteIrp,                
    _PnpEject,                      
    _PnpSetLock,                    
    _PnpQueryId,                    
    _PnpQueryPnpDeviceState,        
    _PnpQueryBusInformation,        
    _PnpDeviceUsageNotification,    
    _PnpSurpriseRemoval,            
}

Definition at line 147 of file fxpkgpdo.hpp.

Referenced by GetDispatchPnp().

m_PdoPowerFunctionTable

const PFN_PNP_POWER_CALLBACK FxPkgPdo::m_PdoPowerFunctionTable

staticprivate

Initial value:

=
{
    _DispatchWaitWake,      
    _DispatchPowerSequence, 
    _DispatchSetPower,      
    _DispatchQueryPower,    
}

Definition at line 152 of file fxpkgpdo.hpp.

Referenced by GetDispatchPower().

m_RawOK

BOOLEAN FxPkgPdo::m_RawOK

Definition at line 59 of file fxpkgpdo.hpp.

Referenced by FxPkgPdo(), HandleQueryCapabilities(), and FxDevice::PdoInitialize().

m_Static

BOOLEAN FxPkgPdo::m_Static

Definition at line 61 of file fxpkgpdo.hpp.

Referenced by AskParentToRemoveAndReenumerate(), FxDevice::DeleteObject(), FxPkgPdo(), HandleQueryInterfaceForReenumerate(), Initialize(), and PnpEventCheckForDevicePresenceOverload().

---

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

• sdk/lib/drivers/wdf/shared/inc/private/common/fxpkgpdo.hpp
• sdk/lib/drivers/wdf/shared/irphandlers/pnp/fxpkgpdo.cpp
• sdk/lib/drivers/wdf/shared/irphandlers/pnp/km/fxpkgpdokm.cpp
• sdk/lib/drivers/wdf/shared/irphandlers/pnp/pdopower.cpp
• sdk/lib/drivers/wdf/shared/irphandlers/pnp/um/fxpkgpdoum.cpp