#include <fxpowerpolicystatemachine.hpp>

Inheritance diagram for FxPowerPolicyOwnerSettings:

Collaboration diagram for FxPowerPolicyOwnerSettings:

[legend]

Public Member Functions
	FxPowerPolicyOwnerSettings (__in FxPkgPnp *PkgPnp)

	~FxPowerPolicyOwnerSettings (VOID)

_Must_inspect_result_ NTSTATUS	Init (VOID)

VOID	CleanupPowerCallback (VOID)

VOID	IncrementChildrenArmedForWakeCount (VOID)

VOID	DecrementChildrenArmedForWakeCount (VOID)

Public Member Functions inherited from FxStump
PVOID	operator new (__in size_t Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals)

PVOID	operator new (__in size_t Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in POOL_TYPE PoolType)

VOID	operator delete (__in PVOID pointer)

PVOID	operator new[] (__in size_t Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals)

VOID	operator delete[] (__in PVOID pointer)

Public Attributes
friend	FxPowerPolicyMachine

FxPowerIdleMachine	m_PowerIdleMachine

FxPoxInterface	m_PoxInterface

FxPowerDeviceArmWakeFromS0	m_DeviceArmWakeFromS0

FxPowerDeviceArmWakeFromSx	m_DeviceArmWakeFromSx

FxPowerDeviceDisarmWakeFromS0	m_DeviceDisarmWakeFromS0

FxPowerDeviceDisarmWakeFromSx	m_DeviceDisarmWakeFromSx

FxPowerDeviceWakeFromS0Triggered	m_DeviceWakeFromS0Triggered

FxPowerDeviceWakeFromSxTriggered	m_DeviceWakeFromSxTriggered

FxUsbIdleInfo *	m_UsbIdle

FxPkgPnp *	m_PkgPnp

WakePolicySettings	m_WakeSettings

IdlePolicySettings	m_IdleSettings

ULONG	m_SystemToDeviceStateMap

ULONG	m_ChildrenPoweredOnCount

LONG	m_ChildrenArmedCount

NTSTATUS	m_WaitWakeStatus

BYTE	m_IdealDxStateForSx

BOOLEAN	m_RequestedPowerUpIrp

BOOLEAN	m_RequestedPowerDownIrp

BOOLEAN	m_RequestedWaitWakeIrp

BOOLEAN	m_WakeCompletionEventDropped

BOOLEAN	m_PowerFailed

BOOLEAN	m_CanSaveState

BOOLEAN	m_ChildrenCanPowerUp

BOOLEAN	m_SystemWakeSource

Protected Attributes
PCALLBACK_OBJECT	m_PowerCallbackObject

PVOID	m_PowerCallbackRegistration

LONG	m_WaitWakeCancelCompletionOwnership

Static Protected Attributes
static MdCallbackFunctionType	_PowerStateCallback

Additional Inherited Members
Protected Member Functions inherited from FxStump
	FxStump (VOID)

Detailed Description

Definition at line 550 of file fxpowerpolicystatemachine.hpp.

Constructor & Destructor Documentation

◆ FxPowerPolicyOwnerSettings()

FxPowerPolicyOwnerSettings::FxPowerPolicyOwnerSettings ( __in FxPkgPnp * PkgPnp )

Definition at line 2607 of file powerpolicystatemachine.cpp.

      : m_PoxInterface(PkgPnp)
{
    ULONG i;
 
    m_UsbIdle = NULL;
 
    m_PkgPnp = PkgPnp;
 
    //
    // Default every state to D3 except for system working which is D0 by
    // default.
    //
    m_SystemToDeviceStateMap = 0x0;
 
    for (i = 0; i < PowerSystemMaximum; i++) {
        FxPkgPnp::_SetPowerCapState(i,
                                    i == PowerSystemWorking ? PowerDeviceD0
                                                            : PowerDeviceD3,
                                    &m_SystemToDeviceStateMap);
    }
 
    m_IdealDxStateForSx = PowerDeviceD3;
 
    m_RequestedPowerUpIrp = FALSE;
    m_RequestedPowerDownIrp = FALSE;
    m_RequestedWaitWakeIrp = FALSE;
    m_WakeCompletionEventDropped = FALSE;
    m_PowerFailed = FALSE;
    m_CanSaveState = TRUE;
 
    m_ChildrenCanPowerUp = FALSE;
    m_ChildrenPoweredOnCount = 0;
    m_ChildrenArmedCount = 0;
 
    m_WaitWakeStatus = STATUS_NOT_SUPPORTED;
    m_SystemWakeSource = FALSE;
    m_WaitWakeCancelCompletionOwnership = CancelOwnershipUnclaimed;
 
    m_PowerCallbackObject = NULL;
    m_PowerCallbackRegistration = NULL;
}

◆ ~FxPowerPolicyOwnerSettings()

FxPowerPolicyOwnerSettings::~FxPowerPolicyOwnerSettings ( VOID )

Definition at line 2651 of file powerpolicystatemachine.cpp.

{
    //
    // There are paths which cleanup this object which  do not go through the
    // pnp state machine, so make sure the power object callback fields are
    // freed.  In these paths, we are guaranteed PASSIVE_LEVEL b/c there will
    // be no dangling references which can cause deletion at a greater IRQL.
    //
    CleanupPowerCallback();
 
    if (m_UsbIdle != NULL) {
        delete m_UsbIdle;
        m_UsbIdle = NULL;
    }
}

Member Function Documentation

◆ CleanupPowerCallback()

VOID FxPowerPolicyOwnerSettings::CleanupPowerCallback ( VOID )

Definition at line 2670 of file powerpolicystatemachine.cpp.

{
    if (m_PowerCallbackRegistration != NULL) {
        Mx::UnregisterCallback(m_PowerCallbackRegistration);
        m_PowerCallbackRegistration = NULL;
 
    }
 
    if (m_PowerCallbackObject != NULL) {
        Mx::MxDereferenceObject(m_PowerCallbackObject);
        m_PowerCallbackObject = NULL;
    }
}

Referenced by FxPkgPnp::CleanupStateMachines(), and ~FxPowerPolicyOwnerSettings().

◆ DecrementChildrenArmedForWakeCount()

VOID FxPowerPolicyOwnerSettings::DecrementChildrenArmedForWakeCount ( VOID )

inline

Definition at line 583 of file fxpowerpolicystatemachine.hpp.

    {
        InterlockedDecrement(&m_ChildrenArmedCount);
    }

◆ IncrementChildrenArmedForWakeCount()

VOID FxPowerPolicyOwnerSettings::IncrementChildrenArmedForWakeCount ( VOID )

inline

Definition at line 575 of file fxpowerpolicystatemachine.hpp.

    {
        InterlockedIncrement(&m_ChildrenArmedCount);
    }

◆ Init()

_Must_inspect_result_ NTSTATUS FxPowerPolicyOwnerSettings::Init ( VOID )

Definition at line 2700 of file powerpolicystatemachine.cpp.

{
    OBJECT_ATTRIBUTES oa;
    UNICODE_STRING string;
    NTSTATUS status;
 
    RtlInitUnicodeString(&string, L"\\Callback\\PowerState");
    InitializeObjectAttributes(
        &oa,
        &string,
        OBJ_CASE_INSENSITIVE,
        NULL,
        NULL
        );
 
    //
    // Create a callback object, but we do not want to be the first ones
    // to create it (it should be created way before we load in NTOS
    // anyways)
    //
    status = Mx::CreateCallback(&m_PowerCallbackObject, &oa, FALSE, TRUE);
 
    if (NT_SUCCESS(status)) {
        m_PowerCallbackRegistration = Mx::RegisterCallback(
            m_PowerCallbackObject,
            _PowerStateCallback,
            this
            );
 
        if (m_PowerCallbackRegistration == NULL) {
            //
            // Non-critical failure, so we'll free the callback object and keep
            // going
            //
            Mx::MxDereferenceObject(m_PowerCallbackObject);
            m_PowerCallbackObject = NULL;
        }
    }
 
    //
    // Initialize FxPowerIdleMachine
    //
    status = m_PowerIdleMachine.Init();
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    return status;
}