FxPoxInterface Class Reference

#include <fxpoxinterface.hpp>

Collaboration diagram for FxPoxInterface:

Public Member Functions
	FxPoxInterface (__in FxPkgPnp *PkgPnp)
	~FxPoxInterface (VOID)
NTSTATUS	CreateDevicePowerRequirementMachine (VOID)
NTSTATUS	NotifyDevicePowerDown (VOID)
VOID	DeviceIsPoweredOn (VOID)
FxPkgPnp *	PkgPnp (VOID)
POHANDLE	GetPoHandle (VOID)
NTSTATUS	InitializeComponents (VOID)
VOID	UninitializeComponents (VOID)
VOID	RequestComponentActive (VOID)
BOOLEAN	DeclareComponentIdle (VOID)
VOID	UpdateIdleTimeoutHint (VOID)
VOID	SimulateDevicePowerRequired (VOID)
VOID	SimulateDevicePowerNotRequired (VOID)
VOID	PoxReportDevicePoweredOn (VOID)
VOID	PowerRequiredCallbackInvoked (VOID)
VOID	PowerNotRequiredCallbackInvoked (VOID)

Public Attributes
FxDevicePwrRequirementMachine *	m_DevicePowerRequirementMachine
ULONG	m_NextIdleTimeoutHint

Private Member Functions
NTSTATUS	PoxRegisterDevice (VOID)
VOID	DprProcessEventFromPoxCallback (__in FxDevicePwrRequirementEvents Event)
struct _POX_SETTINGS *	GetPowerFrameworkSettings (VOID)
VOID	PowerRequiredCallbackWorker (__in BOOLEAN InvokedFromPoxCallback)
VOID	PowerNotRequiredCallbackWorker (__in BOOLEAN InvokedFromPoxCallback)
VOID	PoxStartDevicePowerManagement (VOID)
VOID	PoxUnregisterDevice (VOID)
VOID	PoxActivateComponent (VOID)
VOID	PoxIdleComponent (VOID)
VOID	PoxSetDeviceIdleTimeout (__in ULONGLONG IdleTimeout)

Private Attributes
FxPkgPnp *	m_PkgPnp
POHANDLE	m_PoHandle
BOOLEAN	m_DevicePowerRequired
MxLock	m_DevicePowerRequiredLock
ULONG	m_CurrentIdleTimeoutHint

Static Private Attributes
static PO_FX_COMPONENT_IDLE_STATE_CALLBACK	StateCallback
static PO_FX_COMPONENT_ACTIVE_CONDITION_CALLBACK	ComponentActiveCallback
static PO_FX_COMPONENT_IDLE_CONDITION_CALLBACK	ComponentIdleCallback
static PO_FX_DEVICE_POWER_REQUIRED_CALLBACK	PowerRequiredCallback
static PO_FX_DEVICE_POWER_NOT_REQUIRED_CALLBACK	PowerNotRequiredCallback
static PO_FX_POWER_CONTROL_CALLBACK	PowerControlCallback

Friends
class	FxDevicePwrRequirementMachine

Detailed Description

Definition at line 9 of file fxpoxinterface.hpp.

Constructor & Destructor Documentation

FxPoxInterface()

FxPoxInterface::FxPoxInterface

(

__in FxPkgPnp *

PkgPnp

)

Definition at line 22 of file poxinterface.cpp.

{
    m_PkgPnp = PkgPnp;
    m_PoHandle = NULL;
    m_DevicePowerRequired = TRUE;
    m_DevicePowerRequirementMachine = NULL;
    m_CurrentIdleTimeoutHint = 0;
    m_NextIdleTimeoutHint = 0;
}

~FxPoxInterface()

FxPoxInterface::~FxPoxInterface

(

VOID

)

Definition at line 34 of file poxinterface.cpp.

{
    if (NULL != m_DevicePowerRequirementMachine) {
        delete m_DevicePowerRequirementMachine;
    }
}

Member Function Documentation

CreateDevicePowerRequirementMachine()

NTSTATUS FxPoxInterface::CreateDevicePowerRequirementMachine

(

VOID

)

Definition at line 44 of file poxinterface.cpp.

{
//     NTSTATUS status;
//     FxDevicePwrRequirementMachine * fxDprMachine = NULL;
 
//     ASSERT(NULL == m_DevicePowerRequirementMachine);
 
//     fxDprMachine = new (m_PkgPnp->GetDriverGlobals())
//                             FxDevicePwrRequirementMachine(this);
//     if (NULL == fxDprMachine) {
//         status = STATUS_INSUFFICIENT_RESOURCES;
//         DoTraceLevelMessage(
//             m_PkgPnp->GetDriverGlobals(),
//             TRACE_LEVEL_ERROR, TRACINGPNP,
//             "WDFDEVICE 0x%p !devobj 0x%p failed to allocate "
//             "FxDevicePwrRequirementMachine. %!STATUS!.",
//             m_PkgPnp->GetDevice()->GetHandle(),
//             m_PkgPnp->GetDevice()->GetDeviceObject(),
//             status);
//         goto exit;
//     }
 
//     status = fxDprMachine->Initialize(m_PkgPnp->GetDriverGlobals());
//     if (FALSE == NT_SUCCESS(status)) {
//         DoTraceLevelMessage(
//             m_PkgPnp->GetDriverGlobals(),
//             TRACE_LEVEL_ERROR, TRACINGPNP,
//             "WDFDEVICE 0x%p !devobj 0x%p Device Power Requirement State Machine"
//             " Initialize() failed, %!STATUS!",
//             m_PkgPnp->GetDevice()->GetHandle(),
//             m_PkgPnp->GetDevice()->GetDeviceObject(),
//             status);
//         goto exit;
//     }
 
//     status = fxDprMachine->Init(
//                             m_PkgPnp,
//                             FxDevicePwrRequirementMachine::_ProcessEventInner
//                             );
//     if (!NT_SUCCESS(status)) {
//         DoTraceLevelMessage(
//             m_PkgPnp->GetDriverGlobals(),
//             TRACE_LEVEL_ERROR, TRACINGPNP,
//             "WDFDEVICE 0x%p !devobj 0x%p Device Power Requirement State Machine"
//             " Init() failed, %!STATUS!",
//             m_PkgPnp->GetDevice()->GetHandle(),
//             m_PkgPnp->GetDevice()->GetDeviceObject(),
//             status);
//         goto exit;
//     }
 
//     m_DevicePowerRequirementMachine = fxDprMachine;
 
//     status = STATUS_SUCCESS;
 
// exit:
//     if (FALSE == NT_SUCCESS(status)) {
//         if (NULL != fxDprMachine) {
//             delete fxDprMachine;
//         }
//     }
//     return status;
    ROSWDFNOTIMPLEMENTED;
    return STATUS_SUCCESS;
}

DeclareComponentIdle()

BOOLEAN FxPoxInterface::DeclareComponentIdle

(

VOID

)

Definition at line 306 of file poxinterface.cpp.

{
    // BOOLEAN canPowerDown;
 
    // if (FALSE == m_PkgPnp->m_PowerPolicyMachine.m_Owner->m_IdleSettings.
    //                             m_TimeoutMgmt.UsingSystemManagedIdleTimeout()) {
    //     //
    //     // Driver-managed idle timeout. We can power down immediately, without
    //     // waiting for device-power-not-required notification.
    //     //
    //     canPowerDown = TRUE;
    // } else {
    //     //
    //     // System-managed idle timeout
    //     //
    //     PoxIdleComponent();
 
    //     //
    //     // We must wait for device-power-not-required notification before
    //     // powering down.
    //     //
    //     canPowerDown = FALSE;
    // }
 
    // return canPowerDown;
    ROSWDFNOTIMPLEMENTED;
    return TRUE;
}

DeviceIsPoweredOn()

VOID FxPoxInterface::DeviceIsPoweredOn

(

VOID

)

Definition at line 423 of file poxinterface.cpp.

{
    ROSWDFNOTIMPLEMENTED;
    // if (FALSE == m_PkgPnp->m_PowerPolicyMachine.m_Owner->m_IdleSettings.
    //                             m_TimeoutMgmt.UsingSystemManagedIdleTimeout()) {
    //     //
    //     // Driver-managed idle timeout. Nothing to do.
    //     //
    //     return;
    // }
 
    // //
    // // System-managed idle timeout. Notify the device power requirement state
    // // machine that we are back in D0.
    // //
    // m_DevicePowerRequirementMachine->ProcessEvent(
    //                                     DprEventDeviceReturnedToD0
    //                                     );
    // return;
}

DprProcessEventFromPoxCallback()

VOID FxPoxInterface::DprProcessEventFromPoxCallback ( __in FxDevicePwrRequirementEvents  Event )

private

Definition at line 467 of file poxinterface.cpp.

{
    ROSWDFNOTIMPLEMENTED;
    // KIRQL irql;
 
    // //
    // // We should not run the state machine from within a power framework
    // // callback because we might end up reaching a state where we unregister
    // // with the power framework. Unregistering from a callback leads to a
    // // deadlock. Therefore, we raise IRQL before queueing an event to the state
    // // machine. Raising IRQL causes the event processing to be deferred to a
    // // worker thread.
    // //
 
    // //
    // // This path should only be invoked for kernel mode. For user mode, this
    // // condition is avoided by reflector guranteeing that it queues a worker
    // // item to send a Pofx event corresponding to any PoFx callback
    // //
    // ASSERT(FX_IS_KERNEL_MODE);
 
    // Mx::MxRaiseIrql(DISPATCH_LEVEL, &irql);
    // m_DevicePowerRequirementMachine->ProcessEvent(Event);
    // Mx::MxLowerIrql(irql);
}

GetPoHandle()

POHANDLE FxPoxInterface::GetPoHandle ( VOID  )

inline

Definition at line 47 of file fxpoxinterface.hpp.

    {
        return m_PoHandle;
    }

GetPowerFrameworkSettings()

PPOX_SETTINGS FxPoxInterface::GetPowerFrameworkSettings ( VOID  )

private

Definition at line 447 of file poxinterface.cpp.

{
    PPOX_SETTINGS poxSettings = NULL;
 
    ROSWDFNOTIMPLEMENTED;
    // if (m_PkgPnp->m_PowerPolicyMachine.m_Owner->
    //      m_IdleSettings.m_TimeoutMgmt.DriverSpecifiedPowerFrameworkSettings()) {
 
    //     poxSettings = m_PkgPnp->m_PowerPolicyMachine.m_Owner->
    //                    m_IdleSettings.m_TimeoutMgmt.GetPowerFrameworkSettings();
 
    //     ASSERT(NULL != poxSettings);
    // }
 
    return poxSettings;
}

Referenced by _Function_class_(), and PoxRegisterDevice().

InitializeComponents()

NTSTATUS FxPoxInterface::InitializeComponents

(

VOID

)

Definition at line 113 of file poxinterface.cpp.

{
//     NTSTATUS status;
//     PPOX_SETTINGS poxSettings = NULL;
//     WDFDEVICE fxDevice = NULL;
 
 
//     if (FALSE == m_PkgPnp->m_PowerPolicyMachine.m_Owner->m_IdleSettings.
//                                 m_TimeoutMgmt.UsingSystemManagedIdleTimeout()) {
//         //
//         // Driver-managed idle timeout. Nothing to do.
//         //
//         return STATUS_SUCCESS;
//     }
 
//     //
//     // We create the device power requirement state machine only if system-
//     // managed idle timeout is being used.
//     //
//     if (NULL == m_DevicePowerRequirementMachine) {
//         status = CreateDevicePowerRequirementMachine();
//         if (FALSE == NT_SUCCESS(status)) {
//             goto exit;
//         }
//     }
 
//     ASSERT(NULL != m_DevicePowerRequirementMachine);
 
//     //
//     // Register with the power framework
//     //
//     status = PoxRegisterDevice();
 
//     if (FALSE == NT_SUCCESS(status)) {
//         DoTraceLevelMessage(
//             m_PkgPnp->GetDriverGlobals(),
//             TRACE_LEVEL_ERROR, TRACINGPNP,
//             "WDFDEVICE 0x%p !devobj 0x%p FxPox::PoxRegisterDevice failed. "
//             "%!STATUS!.",
//             m_PkgPnp->GetDevice()->GetHandle(),
//             m_PkgPnp->GetDevice()->GetDeviceObject(),
//             status);
//         goto exit;
//     }
 
//     //
//     // At the time of registration, all components are active. When we start the
//     // power framework's device power management (see below), all components are
//     // moved to the idle state by default. Take an extra reference on the
//     // component to prevent this from happening. The power policy state machine
//     // will evaluate the S0-idle policy later and ask us to drop this reference
//     // if the policy requires it.
//     //
//     PoxActivateComponent();
 
//     //
//     // Tell the power framework to start its device power management. This will
//     // drop a reference on the component, but the component will still remain
//     // active because of the extra reference we took above.
//     //
//     PoxStartDevicePowerManagement();
 
//     //
//     // If the client driver has specified power framework settings, retrieve
//     // them.
//     //
//     poxSettings = GetPowerFrameworkSettings();
 
//     //
//     // If the driver wanted to receive the POHANDLE, invoke their callback now
//     //
//     if ((NULL != poxSettings) &&
//         (NULL != poxSettings->EvtDeviceWdmPostPoFxRegisterDevice)) {
 
//         fxDevice = m_PkgPnp->GetDevice()->GetHandle();
 
//         status = poxSettings->EvtDeviceWdmPostPoFxRegisterDevice(
//                                   fxDevice,
//                                   m_PoHandle
//                                   );
//         if (FALSE == NT_SUCCESS(status)) {
 
//             DoTraceLevelMessage(
//                 m_PkgPnp->GetDriverGlobals(),
//                 TRACE_LEVEL_ERROR, TRACINGPNP,
//                 "WDFDEVICE 0x%p !devobj 0x%p. The client driver has failed the "
//                 "EvtDeviceWdmPostPoFxRegisterDevice callback with %!STATUS!.",
//                 m_PkgPnp->GetDevice()->GetHandle(),
//                 m_PkgPnp->GetDevice()->GetDeviceObject(),
//                 status);
 
//             //
//             // Notify the driver that the POHANDLE is about to become invalid
//             //
//             if (NULL != poxSettings->EvtDeviceWdmPrePoFxUnregisterDevice) {
//                 poxSettings->EvtDeviceWdmPrePoFxUnregisterDevice(
//                                 fxDevice,
//                                 m_PoHandle
//                                 );
//             }
 
//             //
//             // Unregister with the power framework
//             //
//             PoxUnregisterDevice();
//             goto exit;
//         }
//     }
 
//     //
//     // Tell the device power requirement state machine that we have registered
//     // with the power framework
//     //
//     m_DevicePowerRequirementMachine->ProcessEvent(DprEventRegisteredWithPox);
 
// exit:
//     return status;
    ROSWDFNOTIMPLEMENTED;
    return STATUS_SUCCESS;
}

NotifyDevicePowerDown()

NTSTATUS FxPoxInterface::NotifyDevicePowerDown

(

VOID

)

Definition at line 368 of file poxinterface.cpp.

{
    // KIRQL irql;
    // BOOLEAN canPowerOff;
 
    // if (FALSE == m_PkgPnp->m_PowerPolicyMachine.m_Owner->m_IdleSettings.
    //                             m_TimeoutMgmt.UsingSystemManagedIdleTimeout()) {
    //     //
    //     // Driver-managed idle timeout. We don't have to take power framework's
    //     // device power requirement into consideration. Just return success.
    //     //
    //     return STATUS_SUCCESS;
    // }
 
    // //
    // // Acquire the lock to ensure that device power requirement doesn't change.
    // //
    // m_DevicePowerRequiredLock.Acquire(&irql);
    // if (FALSE == m_DevicePowerRequired) {
    //     //
    //     // Send an event to the device power requirement state machine to tell
    //     // it that we are about to go to Dx.
    //     //
    //     // We send the event inside a lock in order to handle the race condition
    //     // when the power framework notifies us that device power is required at
    //     // the same time that we are about to go to Dx. By sending the event
    //     // inside the lock, we ensure that the DprEventDeviceGoingToDx event is
    //     // always queued to device power requirement state machine before the
    //     // DprEventPoxRequiresPower.
    //     //
    //     // This allows for a clean design in the device power requirement state
    //     // machine by ensuring that it does not have to handle a non-intuitive
    //     // sequence, i.e. DprEventPoxRequiresPower followed by
    //     // DprEventDeviceGoingToDx. This sequence is non-intuitive because it
    //     // doesn't make sense for a device to go to Dx after it has been
    //     // informed that device power is required. Avoiding this non-intuitive
    //     // sequence via locking enables a clean design for the device power
    //     // requirement state machine.
    //     //
    //     m_DevicePowerRequirementMachine->ProcessEvent(DprEventDeviceGoingToDx);
    //     canPowerOff = TRUE;
 
    // } else {
    //     canPowerOff = FALSE;
    // }
    // m_DevicePowerRequiredLock.Release(irql);
 
    // return canPowerOff ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL;
    ROSWDFNOTIMPLEMENTED;
    return STATUS_SUCCESS;
}

PkgPnp()

FxPkgPnp * FxPoxInterface::PkgPnp ( VOID  )

inline

Definition at line 39 of file fxpoxinterface.hpp.

    {
        return m_PkgPnp;
    }

Referenced by FxPoxInterface(), and FxDevicePwrRequirementMachine::ProcessEventInner().

PowerNotRequiredCallbackInvoked()

VOID FxPoxInterface::PowerNotRequiredCallbackInvoked

(

VOID

)

Definition at line 106 of file poxinterfaceum.cpp.

{
    //
    // Notice that it is important that we first acknowledge the callback
    // because once we queue an event in the state machine, the state machine
    // could end up calling PoFxUnregister from the same thread
    //
    m_PkgPnp->GetDevice()->GetDeviceStack2()->PoFxCompleteDevicePowerNotRequired();
 
    //
    // The contract with the reflector is that the reflector guarantees to
    // not send this event from the PoFx callback
    //
    PowerNotRequiredCallbackWorker(FALSE /* InvokedFromPoxCallback */);
 
    return;
}

PowerNotRequiredCallbackWorker()

VOID FxPoxInterface::PowerNotRequiredCallbackWorker ( __in BOOLEAN  InvokedFromPoxCallback )

private

Definition at line 567 of file poxinterface.cpp.

{
    ROSWDFNOTIMPLEMENTED;
    // KIRQL irql;
 
    // //
    // // Make a note of the fact that device power is not required
    // //
    // m_DevicePowerRequiredLock.Acquire(&irql);
    // m_DevicePowerRequired = FALSE;
    // m_DevicePowerRequiredLock.Release(irql);
 
    // //
    // // Send the device-power-not-required event to the device power
    // // requirement state machine.
    // //
    // if (InvokedFromPoxCallback) {
    //     DprProcessEventFromPoxCallback(DprEventPoxDoesNotRequirePower);
    // } else {
    //     m_DevicePowerRequirementMachine->ProcessEvent(
    //                                         DprEventPoxDoesNotRequirePower
    //                                         );
    // }
    // return;
}

Referenced by PowerNotRequiredCallbackInvoked().

PowerRequiredCallbackInvoked()

VOID FxPoxInterface::PowerRequiredCallbackInvoked

(

VOID

)

Definition at line 97 of file poxinterfaceum.cpp.

{
    PowerRequiredCallbackWorker(FALSE /* InvokedFromPoxCallback */);
    return;
}

PowerRequiredCallbackWorker()

VOID FxPoxInterface::PowerRequiredCallbackWorker ( __in BOOLEAN  InvokedFromPoxCallback )

private

Definition at line 540 of file poxinterface.cpp.

{
    ROSWDFNOTIMPLEMENTED;
    // KIRQL irql;
 
    // //
    // // Make a note of the fact that device power is required
    // //
    // m_DevicePowerRequiredLock.Acquire(&irql);
    // m_DevicePowerRequired = TRUE;
    // m_DevicePowerRequiredLock.Release(irql);
 
    // //
    // // Send the device-power-required event to the device power requirement
    // // state machine.
    // //
    // if (InvokedFromPoxCallback) {
    //     DprProcessEventFromPoxCallback(DprEventPoxRequiresPower);
    // } else {
    //     m_DevicePowerRequirementMachine->ProcessEvent(DprEventPoxRequiresPower);
    // }
    // return;
}

Referenced by PowerRequiredCallbackInvoked().

PoxActivateComponent()

VOID FxPoxInterface::PoxActivateComponent ( VOID  )

private

Definition at line 413 of file poxinterfacekm.cpp.

{
    //
    // We only support single component and don't
    // need to set any flags
    //
    PoFxActivateComponent(m_PoHandle,
                          0, //component
                          0  //flags
                          );
}

PoxIdleComponent()

VOID FxPoxInterface::PoxIdleComponent ( VOID  )

private

Definition at line 429 of file poxinterfacekm.cpp.

{
    //
    // We only support single component and don't
    // need to set any flags
    //
    PoFxIdleComponent(m_PoHandle,
                      0, //component
                      0  //flags
                      );
}

PoxRegisterDevice()

NTSTATUS FxPoxInterface::PoxRegisterDevice ( VOID  )

private

Definition at line 274 of file poxinterfacekm.cpp.

{
 
    NTSTATUS status;
    PO_FX_DEVICE poxDevice;
    PO_FX_COMPONENT_IDLE_STATE idleState;
    PPOX_SETTINGS poxSettings = NULL;
 
    RtlZeroMemory(&poxDevice, sizeof(poxDevice));
    RtlZeroMemory(&idleState, sizeof(idleState));
 
    poxDevice.Version = PO_FX_VERSION_V1;
 
    //
    // Specify callbacks and context
    //
    poxDevice.ComponentIdleStateCallback =
                    FxPoxInterface::StateCallback;
    poxDevice.ComponentActiveConditionCallback =
                    FxPoxInterface::ComponentActiveCallback;
    poxDevice.ComponentIdleConditionCallback =
                    FxPoxInterface::ComponentIdleCallback;
    poxDevice.DevicePowerRequiredCallback =
                    FxPoxInterface::PowerRequiredCallback;
    poxDevice.DevicePowerNotRequiredCallback =
                    FxPoxInterface::PowerNotRequiredCallback;
    poxDevice.DeviceContext = this;
 
    //
    // We register as a single component device
    //
    poxDevice.ComponentCount = 1;
 
    //
    // If the client driver has specified power framework settings, retrieve
    // them.
    //
    poxSettings = GetPowerFrameworkSettings();
 
    //
    // We specify a power control callback only if the client driver supplies us
    // a power control callback
    //
    poxDevice.PowerControlCallback =
        ((NULL == poxSettings) || (NULL == poxSettings->PowerControlCallback)) ?
            NULL :
            FxPoxInterface::PowerControlCallback;
 
    //
    // If the client driver has specified any settings for component 0, use
    // them. Otherwise use the default settings.
    //
    if ((NULL == poxSettings) || (NULL == poxSettings->Component)) {
        //
        // Default settings
        //
 
        //
        // We only support F0
        //
        poxDevice.Components[0].IdleStateCount = 1;
 
        //
        // Transition latency should be 0 for F0
        //
        idleState.TransitionLatency = 0;
 
        //
        // Residency requirement should be 0 for F0
        //
        idleState.ResidencyRequirement = 0;
 
        //
        // The value doesn't matter because we do not support multiple F-states.
        //
        idleState.NominalPower = PO_FX_UNKNOWN_POWER;
 
        //
        // Specify the state information for F0
        //
        poxDevice.Components[0].IdleStates = &idleState;
    }
    else {
        //
        // Client driver's settings
        //
        RtlCopyMemory(&(poxDevice.Components[0]),
                      poxSettings->Component,
                      sizeof(poxDevice.Components[0]));
    }
 
    //
    // Register with the power framework
    //
    status = PoFxRegisterDevice(
                m_PkgPnp->GetDevice()->GetPhysicalDevice(),
                &poxDevice,
                &(m_PoHandle)
                );
    if (FALSE == NT_SUCCESS(status)) {
        DoTraceLevelMessage(
            m_PkgPnp->GetDriverGlobals(),
            TRACE_LEVEL_ERROR, TRACINGPNP,
            "WDFDEVICE 0x%p !devobj 0x%p FxPox::PoxRegisterDevice failed. "
            "%!STATUS!.",
            m_PkgPnp->GetDevice()->GetHandle(),
            m_PkgPnp->GetDevice()->GetDeviceObject(),
            status);
        goto exit;
    }
 
    status = STATUS_SUCCESS;
 
exit:
    return status;
 
}

PoxReportDevicePoweredOn()

VOID FxPoxInterface::PoxReportDevicePoweredOn

(

VOID

)

Definition at line 445 of file poxinterfacekm.cpp.

{
    PoFxReportDevicePoweredOn(m_PoHandle);
}

PoxSetDeviceIdleTimeout()

VOID FxPoxInterface::PoxSetDeviceIdleTimeout ( __in ULONGLONG  IdleTimeout )

private

Definition at line 454 of file poxinterfacekm.cpp.

{
    PoFxSetDeviceIdleTimeout(m_PoHandle, IdleTimeout);
}

PoxStartDevicePowerManagement()

VOID FxPoxInterface::PoxStartDevicePowerManagement ( VOID  )

private

Definition at line 395 of file poxinterfacekm.cpp.

{
    PoFxStartDevicePowerManagement(m_PoHandle);
}

PoxUnregisterDevice()

VOID FxPoxInterface::PoxUnregisterDevice ( VOID  )

private

Definition at line 404 of file poxinterfacekm.cpp.

{
    PoFxUnregisterDevice(m_PoHandle);
}

RequestComponentActive()

VOID FxPoxInterface::RequestComponentActive

(

VOID

)

Definition at line 288 of file poxinterface.cpp.

{
    // if (FALSE == m_PkgPnp->m_PowerPolicyMachine.m_Owner->m_IdleSettings.
    //                             m_TimeoutMgmt.UsingSystemManagedIdleTimeout()) {
    //     //
    //     // Driver-managed idle timeout. Nothing to do.
    //     //
    //     return;
    // }
 
    // PoxActivateComponent();
    // return;
    ROSWDFNOTIMPLEMENTED;
}

SimulateDevicePowerNotRequired()

VOID FxPoxInterface::SimulateDevicePowerNotRequired

(

VOID

)

Definition at line 518 of file poxinterface.cpp.

{
    ROSWDFNOTIMPLEMENTED;
    // if (FALSE == m_PkgPnp->m_PowerPolicyMachine.m_Owner->m_IdleSettings.
    //                             m_TimeoutMgmt.UsingSystemManagedIdleTimeout()) {
    //     //
    //     // Driver-managed idle timeout. Nothing to do.
    //     //
    //     return;
    // }
 
    // //
    // // System-managed idle timeout. Notify the device power requirement state
    // // machine that device power is not required.
    // //
    // PowerNotRequiredCallbackWorker(FALSE /* InvokedFromPoxCallback */);
    // return;
}

SimulateDevicePowerRequired()

VOID FxPoxInterface::SimulateDevicePowerRequired

(

VOID

)

Definition at line 496 of file poxinterface.cpp.

{
    ROSWDFNOTIMPLEMENTED;
    // if (FALSE == m_PkgPnp->m_PowerPolicyMachine.m_Owner->m_IdleSettings.
    //                             m_TimeoutMgmt.UsingSystemManagedIdleTimeout()) {
    //     //
    //     // Driver-managed idle timeout. Nothing to do.
    //     //
    //     return;
    // }
 
    // //
    // // System-managed idle timeout. Notify the device power requirement state
    // // machine that device power is required.
    // //
    // PowerRequiredCallbackWorker(FALSE /* InvokedFromPoxCallback */);
    // return;
}

UninitializeComponents()

VOID FxPoxInterface::UninitializeComponents

(

VOID

)

Definition at line 237 of file poxinterface.cpp.

{
    // PPOX_SETTINGS poxSettings = NULL;
 
    // if (FALSE == m_PkgPnp->m_PowerPolicyMachine.m_Owner->m_IdleSettings.
    //                             m_TimeoutMgmt.UsingSystemManagedIdleTimeout()) {
    //     //
    //     // Driver-managed idle timeout. Nothing to do.
    //     //
    //     return;
    // }
 
    // ASSERT(NULL != m_DevicePowerRequirementMachine);
 
    // //
    // // If the client driver has specified power framework settings, retrieve
    // // them.
    // //
    // poxSettings = GetPowerFrameworkSettings();
 
    // //
    // // Notify the client driver that the POHANDLE is about to become invalid
    // //
    // if ((NULL != poxSettings) &&
    //     (NULL != poxSettings->EvtDeviceWdmPrePoFxUnregisterDevice)) {
 
    //     poxSettings->EvtDeviceWdmPrePoFxUnregisterDevice(
    //                    m_PkgPnp->GetDevice()->GetHandle(),
    //                    m_PoHandle
    //                    );
    // }
 
    // //
    // // Unregister with the power framework
    // //
    // PoxUnregisterDevice();
 
    // //
    // // Tell the device power requirement state machine that we have unregistered
    // // with the power framework
    // //
    // m_DevicePowerRequirementMachine->ProcessEvent(
    //                                     DprEventUnregisteredWithPox
    //                                     );
    // return;
    ROSWDFNOTIMPLEMENTED;
}

UpdateIdleTimeoutHint()

VOID FxPoxInterface::UpdateIdleTimeoutHint

(

VOID

)

Definition at line 338 of file poxinterface.cpp.

{
    // ULONGLONG idleTimeoutHint;
 
    // if (FALSE == m_PkgPnp->m_PowerPolicyMachine.m_Owner->m_IdleSettings.
    //                             m_TimeoutMgmt.UsingSystemManagedIdleTimeout()) {
    //     //
    //     // Driver-managed idle timeout. Nothing to do.
    //     //
    //     return;
    // }
 
    // if (m_NextIdleTimeoutHint != m_CurrentIdleTimeoutHint) {
    //     m_CurrentIdleTimeoutHint = m_NextIdleTimeoutHint;
 
    //     //
    //     // Convert the idle timeout from milliseconds to 100-nanosecond units
    //     //
    //     idleTimeoutHint = ((ULONGLONG) m_CurrentIdleTimeoutHint) * 10 * 1000;
    //     PoxSetDeviceIdleTimeout(idleTimeoutHint);
    // }
 
    // return;
    ROSWDFNOTIMPLEMENTED;
}

Friends And Related Function Documentation

FxDevicePwrRequirementMachine

friend class FxDevicePwrRequirementMachine

friend

Definition at line 11 of file fxpoxinterface.hpp.

Member Data Documentation

ComponentActiveCallback

VOID FxPoxInterface::ComponentActiveCallback

staticprivate

Definition at line 158 of file fxpoxinterface.hpp.

Referenced by PoxRegisterDevice().

ComponentIdleCallback

VOID FxPoxInterface::ComponentIdleCallback

staticprivate

Definition at line 159 of file fxpoxinterface.hpp.

Referenced by PoxRegisterDevice().

m_CurrentIdleTimeoutHint

ULONG FxPoxInterface::m_CurrentIdleTimeoutHint

private

Definition at line 194 of file fxpoxinterface.hpp.

Referenced by FxPoxInterface().

m_DevicePowerRequired

BOOLEAN FxPoxInterface::m_DevicePowerRequired

private

Definition at line 188 of file fxpoxinterface.hpp.

Referenced by FxPoxInterface().

m_DevicePowerRequiredLock

MxLock FxPoxInterface::m_DevicePowerRequiredLock

private

Definition at line 189 of file fxpoxinterface.hpp.

m_DevicePowerRequirementMachine

FxDevicePwrRequirementMachine* FxPoxInterface::m_DevicePowerRequirementMachine

Definition at line 168 of file fxpoxinterface.hpp.

Referenced by FxDevicePwrRequirementMachine::_ProcessEventInner(), FxPoxInterface(), and ~FxPoxInterface().

m_NextIdleTimeoutHint

ULONG FxPoxInterface::m_NextIdleTimeoutHint

Definition at line 174 of file fxpoxinterface.hpp.

Referenced by FxPoxInterface(), and FxPkgPnp::PowerPolicySetS0IdleSettings().

m_PkgPnp

FxPkgPnp* FxPoxInterface::m_PkgPnp

private

Definition at line 177 of file fxpoxinterface.hpp.

Referenced by _Function_class_(), FxDevicePwrRequirementMachine::_ProcessEventInner(), FxPoxInterface(), PkgPnp(), PowerNotRequiredCallbackInvoked(), PoxRegisterDevice(), and FxDevicePwrRequirementMachine::ProcessEvent().

m_PoHandle

POHANDLE FxPoxInterface::m_PoHandle

private

Definition at line 182 of file fxpoxinterface.hpp.

Referenced by FxPoxInterface(), GetPoHandle(), PoxActivateComponent(), PoxIdleComponent(), PoxRegisterDevice(), PoxReportDevicePoweredOn(), PoxSetDeviceIdleTimeout(), PoxStartDevicePowerManagement(), and PoxUnregisterDevice().

PowerControlCallback

PO_FX_POWER_CONTROL_CALLBACK FxPoxInterface::PowerControlCallback

staticprivate

Definition at line 162 of file fxpoxinterface.hpp.

Referenced by PoxRegisterDevice().

PowerNotRequiredCallback

VOID FxPoxInterface::PowerNotRequiredCallback

staticprivate

Definition at line 161 of file fxpoxinterface.hpp.

Referenced by PoxRegisterDevice().

PowerRequiredCallback

VOID FxPoxInterface::PowerRequiredCallback

staticprivate

Definition at line 160 of file fxpoxinterface.hpp.

Referenced by PoxRegisterDevice().

StateCallback

VOID FxPoxInterface::StateCallback

staticprivate

Definition at line 157 of file fxpoxinterface.hpp.

Referenced by PoxRegisterDevice().

---

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

• sdk/lib/drivers/wdf/shared/inc/private/common/fxpoxinterface.hpp
• sdk/lib/drivers/wdf/shared/irphandlers/pnp/km/poxinterfacekm.cpp
• sdk/lib/drivers/wdf/shared/irphandlers/pnp/poxinterface.cpp
• sdk/lib/drivers/wdf/shared/irphandlers/pnp/um/poxinterfaceum.cpp