notpowerpolicyownerstatemachine.cpp

Go to the documentation of this file.

/*++
 
Copyright (c) Microsoft. All rights reserved.
 
Module Name:
 
    NotPowerPolicyOwnerStateMachine.cpp
 
Abstract:
 
    This module implements the Not Power Policy Owner state machine for the driver
    framework.  This code was split out from PowerPolicyStateMachine.cpp
 
Author:
 
 
 
 
Environment:
 
    Both kernel and user mode
 
Revision History:
 
 
 
--*/
 
#include "pnppriv.hpp"
 
extern "C" {
#if defined(EVENT_TRACING)
#include "NotPowerPolicyOwnerStateMachine.tmh"
#endif
}
 
const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_NotPowerPolOwnerObjectCreatedStates[] =
{
    { PwrPolStart, WdfDevStatePwrPolStarting DEBUGGED_EVENT },
    { PwrPolRemove, WdfDevStatePwrPolRemoved DEBUGGED_EVENT },
};
 
const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_NotPowerPolOwnerStartingStates[] =
{
    { PwrPolPowerUp, WdfDevStatePwrPolStarted DEBUGGED_EVENT },
    { PwrPolPowerUpFailed, WdfDevStatePwrPolStartingFailed DEBUGGED_EVENT },
};
 
const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_NotPowerPolOwnerStartingSucceededStates[] =
{
    { PwrPolPowerDownIoStopped, WdfDevStatePwrPolGotoDx DEBUGGED_EVENT },
    { PwrPolStop, WdfDevStatePwrPolStopping DEBUGGED_EVENT },
    { PwrPolSurpriseRemove, WdfDevStatePwrPolStopping DEBUGGED_EVENT },
    { PwrPolPowerUpHwStarted, WdfDevStatePwrPolGotoD0InD0 TRAP_ON_EVENT },
};
 
const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_NotPowerPolOwnerStartingFailedStates[] =
{
    { PwrPolRemove, WdfDevStatePwrPolRemoved DEBUGGED_EVENT },
};
 
const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_NotPowerPolOwnerGotoDxStates[] =
{
    { PwrPolPowerDown, WdfDevStatePwrPolDx DEBUGGED_EVENT },
    { PwrPolPowerDownFailed, WdfDevStatePwrPolStartingSucceeded DEBUGGED_EVENT },
};
 
const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_NotPowerPolOwnerGotoDxInDxStates[] =
{
    { PwrPolPowerDown, WdfDevStatePwrPolDx TRAP_ON_EVENT },
    { PwrPolPowerDownFailed, WdfDevStatePwrPolDx TRAP_ON_EVENT },
};
 
const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_NotPowerPolOwnerDxStates[] =
{
    { PwrPolPowerUpHwStarted, WdfDevStatePwrPolGotoD0 DEBUGGED_EVENT },
    { PwrPolStop, WdfDevStatePwrPolStopping DEBUGGED_EVENT },
    { PwrPolSurpriseRemove, WdfDevStatePwrPolStopping DEBUGGED_EVENT },
    { PwrPolPowerDownIoStopped, WdfDevStatePwrPolGotoDxInDx TRAP_ON_EVENT },
};
 
const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_NotPowerPolOwnerGotoD0States[] =
{
    { PwrPolPowerUp, WdfDevStatePwrPolStartingSucceeded DEBUGGED_EVENT },
    { PwrPolPowerUpFailed, WdfDevStatePwrPolStartingSucceeded TRAP_ON_EVENT },
};
 
const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_NotPowerPolOwnerGotoD0InD0States[] =
{
    { PwrPolPowerUp, WdfDevStatePwrPolStartingSucceeded TRAP_ON_EVENT },
    { PwrPolPowerUpFailed, WdfDevStatePwrPolStartingSucceeded TRAP_ON_EVENT },
};
 
const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_NotPowerPolOwnerStoppedStates[] =
{
    { PwrPolStart, WdfDevStatePwrPolStarting DEBUGGED_EVENT },
    { PwrPolRemove, WdfDevStatePwrPolRemoved DEBUGGED_EVENT },
};
 
const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_NotPowerPolOwnerStoppingWaitForImplicitPowerDownStates[] =
{
    { PwrPolImplicitPowerDown, WdfDevStatePwrPolStoppingSendStatus DEBUGGED_EVENT },
    { PwrPolImplicitPowerDownFailed, WdfDevStatePwrPolStoppingFailed DEBUGGED_EVENT },
    { PwrPolPowerDownIoStopped, WdfDevStatePwrPolStoppingPoweringDown DEBUGGED_EVENT },
    { PwrPolPowerUpHwStarted, WdfDevStatePwrPolStoppingPoweringUp DEBUGGED_EVENT },
};
 
const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_NotPowerPolOwnerStoppingPoweringUpStates[] =
{
    { PwrPolPowerUp, WdfDevStatePwrPolStoppingWaitingForImplicitPowerDown DEBUGGED_EVENT },
    { PwrPolPowerUpFailed, WdfDevStatePwrPolStoppingWaitingForImplicitPowerDown TRAP_ON_EVENT },
};
 
const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_NotPowerPolOwnerStoppingPoweringDownStates[] =
{
    { PwrPolPowerDown, WdfDevStatePwrPolStoppingWaitingForImplicitPowerDown DEBUGGED_EVENT },
    { PwrPolPowerDownFailed, WdfDevStatePwrPolStoppingWaitingForImplicitPowerDown DEBUGGED_EVENT },
};
 
const POWER_POLICY_EVENT_TARGET_STATE FxPkgPnp::m_NotPowerPolOwnerRemovedStates[] =
{
    { PwrPolStart, WdfDevStatePwrPolStarting DEBUGGED_EVENT },
    { PwrPolRemove, WdfDevStatePwrPolRemoved DEBUGGED_EVENT },
};
 
const NOT_POWER_POLICY_OWNER_STATE_TABLE FxPkgPnp::m_WdfNotPowerPolicyOwnerStates[] =
{
    // current state
    // transition function,
    // target states
    // count of target states
    // Queue state
    //
    { WdfDevStatePwrPolObjectCreated,
      NULL,
      FxPkgPnp::m_NotPowerPolOwnerObjectCreatedStates,
      ARRAY_SIZE(FxPkgPnp::m_NotPowerPolOwnerObjectCreatedStates),
      TRUE,
    },
 
    { WdfDevStatePwrPolStarting,
      FxPkgPnp::NotPowerPolOwnerStarting,
      FxPkgPnp::m_NotPowerPolOwnerStartingStates,
      ARRAY_SIZE(FxPkgPnp::m_NotPowerPolOwnerStartingStates),
      FALSE,
    },
 
    { WdfDevStatePwrPolStarted,
      FxPkgPnp::NotPowerPolOwnerStarted,
      NULL,
      0,
      FALSE,
    },
 
    { WdfDevStatePwrPolStartingSucceeded,
      NULL,
      FxPkgPnp::m_NotPowerPolOwnerStartingSucceededStates,
      ARRAY_SIZE(FxPkgPnp::m_NotPowerPolOwnerStartingSucceededStates),
      TRUE,
    },
 
    { WdfDevStatePwrPolGotoDx,
      FxPkgPnp::NotPowerPolOwnerGotoDx,
      FxPkgPnp::m_NotPowerPolOwnerGotoDxStates,
      ARRAY_SIZE(FxPkgPnp::m_NotPowerPolOwnerGotoDxStates),
      FALSE,
    },
 
    { WdfDevStatePwrPolGotoDxInDx,
      FxPkgPnp::NotPowerPolOwnerGotoDxInDx,
      FxPkgPnp::m_NotPowerPolOwnerGotoDxInDxStates,
      ARRAY_SIZE(FxPkgPnp::m_NotPowerPolOwnerGotoDxInDxStates),
      FALSE,
    },
 
    { WdfDevStatePwrPolDx,
      NULL,
      FxPkgPnp::m_NotPowerPolOwnerDxStates,
      ARRAY_SIZE(FxPkgPnp::m_NotPowerPolOwnerDxStates),
      TRUE,
    },
 
    { WdfDevStatePwrPolGotoD0,
      FxPkgPnp::NotPowerPolOwnerGotoD0,
      FxPkgPnp::m_NotPowerPolOwnerGotoD0States,
      ARRAY_SIZE(FxPkgPnp::m_NotPowerPolOwnerGotoD0States),
      FALSE,
    },
 
    { WdfDevStatePwrPolGotoD0InD0,
      FxPkgPnp::NotPowerPolOwnerGotoD0InD0,
      FxPkgPnp::m_NotPowerPolOwnerGotoD0InD0States,
      ARRAY_SIZE(FxPkgPnp::m_NotPowerPolOwnerGotoD0InD0States),
      FALSE,
    },
 
    { WdfDevStatePwrPolStopping,
      FxPkgPnp::NotPowerPolOwnerStopping,
      NULL,
      0,
      FALSE,
    },
 
    { WdfDevStatePwrPolStoppingSendStatus,
      FxPkgPnp::NotPowerPolOwnerStoppingSendStatus,
      NULL,
      0,
      FALSE,
    },
 
    { WdfDevStatePwrPolStartingFailed,
      FxPkgPnp::NotPowerPolOwnerStartingFailed,
      FxPkgPnp::m_NotPowerPolOwnerStartingFailedStates,
      ARRAY_SIZE(FxPkgPnp::m_NotPowerPolOwnerStartingFailedStates),
      TRUE,
    },
 
    { WdfDevStatePwrPolStoppingFailed,
      FxPkgPnp::NotPowerPolOwnerStoppingFailed,
      NULL,
      0,
      FALSE,
    },
 
    { WdfDevStatePwrPolStopped,
      NULL,
      FxPkgPnp::m_NotPowerPolOwnerStoppedStates,
      ARRAY_SIZE(FxPkgPnp::m_NotPowerPolOwnerStoppedStates),
      TRUE,
    },
 
    { WdfDevStatePwrPolStoppingWaitingForImplicitPowerDown,
      NULL,
      FxPkgPnp::m_NotPowerPolOwnerStoppingWaitForImplicitPowerDownStates,
      ARRAY_SIZE(FxPkgPnp::m_NotPowerPolOwnerStoppingWaitForImplicitPowerDownStates),
      TRUE,
    },
 
    { WdfDevStatePwrPolStoppingPoweringUp,
      FxPkgPnp::NotPowerPolOwnerStoppingPoweringUp,
      FxPkgPnp::m_NotPowerPolOwnerStoppingPoweringUpStates,
      ARRAY_SIZE(FxPkgPnp::m_NotPowerPolOwnerStoppingPoweringUpStates),
      FALSE,
    },
 
    { WdfDevStatePwrPolStoppingPoweringDown,
      FxPkgPnp::NotPowerPolOwnerStoppingPoweringDown,
      FxPkgPnp::m_NotPowerPolOwnerStoppingPoweringDownStates,
      ARRAY_SIZE(FxPkgPnp::m_NotPowerPolOwnerStoppingPoweringDownStates),
      FALSE,
    },
 
    { WdfDevStatePwrPolRemoved,
      FxPkgPnp::NotPowerPolOwnerRemoved,
      FxPkgPnp::m_NotPowerPolOwnerRemovedStates,
      ARRAY_SIZE(FxPkgPnp::m_NotPowerPolOwnerRemovedStates),
      TRUE,
    },
 
    // the last entry must have WdfDevStatePwrPolNull as the current state
    { WdfDevStatePwrPolNull,
      NULL,
      NULL,
      0,
      FALSE,
    },
};
 
VOID
FxPkgPnp::NotPowerPolicyOwnerEnterNewState(
    __in WDF_DEVICE_POWER_POLICY_STATE NewState
    )
{
    CPNOT_POWER_POLICY_OWNER_STATE_TABLE entry;
    WDF_DEVICE_POWER_POLICY_STATE currentState, newState;
    WDF_DEVICE_POWER_POLICY_NOTIFICATION_DATA data;
 
    currentState = m_Device->GetDevicePowerPolicyState();
    newState = NewState;
 
    while (newState != WdfDevStatePwrPolNull) {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGPNPPOWERSTATES,
            "WDFDEVICE 0x%p !devobj 0x%p entering not power policy owner state "
            "%!WDF_DEVICE_POWER_POLICY_STATE! from "
            "%!WDF_DEVICE_POWER_POLICY_STATE!", m_Device->GetHandle(),
            m_Device->GetDeviceObject(), newState, currentState);
 
        if (m_PowerPolicyStateCallbacks != NULL) {
            //
            // Callback for leaving the old state
            //
            RtlZeroMemory(&data, sizeof(data));
 
            data.Type = StateNotificationLeaveState;
            data.Data.LeaveState.CurrentState = currentState;
            data.Data.LeaveState.NewState = newState;
 
            m_PowerPolicyStateCallbacks->Invoke(currentState,
                                                StateNotificationLeaveState,
                                                m_Device->GetHandle(),
                                                &data);
        }
 
        m_PowerPolicyMachine.m_States.History[
            m_PowerPolicyMachine.IncrementHistoryIndex()] = (USHORT) newState;
 
        if (m_PowerPolicyStateCallbacks != NULL) {
            //
            // Callback for entering the new state
            //
            RtlZeroMemory(&data, sizeof(data));
 
            data.Type = StateNotificationEnterState;
            data.Data.EnterState.CurrentState = currentState;
            data.Data.EnterState.NewState = newState;
 
            m_PowerPolicyStateCallbacks->Invoke(newState,
                                                StateNotificationEnterState,
                                                m_Device->GetHandle(),
                                                &data);
        }
 
        m_Device->SetDevicePowerPolicyState(newState);
        currentState = newState;
 
        entry = GetNotPowerPolicyOwnerTableEntry(currentState);
 
        //
        // Call the state handler, if there is one.
        //
        if (entry->StateFunc != NULL) {
            newState = entry->StateFunc(this);
        }
        else {
            newState = WdfDevStatePwrPolNull;
        }
 
        if (m_PowerPolicyStateCallbacks != NULL) {
            //
            // Callback for post processing the new state
            //
            RtlZeroMemory(&data, sizeof(data));
 
            data.Type = StateNotificationPostProcessState;
            data.Data.PostProcessState.CurrentState = currentState;
 
            m_PowerPolicyStateCallbacks->Invoke(currentState,
                                                StateNotificationPostProcessState,
                                                m_Device->GetHandle(),
                                                &data);
        }
    }
}
 
WDF_DEVICE_POWER_POLICY_STATE
FxPkgPnp::NotPowerPolOwnerStarting(
    __inout FxPkgPnp* This
    )
/*++
 
Routine Description:
    Starting the power policy state machine for a device which is not the power
    policy owner.  Tell the power state machine to start up.
 
Arguments:
    This - instance of the state machine
 
Return Value:
    WdfDevStatePwrPolNull
 
  --*/
{
    This->PowerProcessEvent(PowerImplicitD0);
    return WdfDevStatePwrPolNull;
}
 
WDF_DEVICE_POWER_POLICY_STATE
FxPkgPnp::NotPowerPolOwnerStarted(
    __inout FxPkgPnp* This
    )
/*++
 
Routine Description:
    Starting the power policy state machine for a device which is not the power
    policy owner has succeeded.  Indicate status to the pnp state machine.
 
Arguments:
    This - instance of the state machine
 
Return Value:
    WdfDevStatePwrPolNull
 
  --*/
{
    This->PnpProcessEvent(PnpEventPwrPolStarted);
    return WdfDevStatePwrPolStartingSucceeded;
}
 
WDF_DEVICE_POWER_POLICY_STATE
FxPkgPnp::NotPowerPolOwnerGotoDx(
    __inout FxPkgPnp* This
    )
{
    This->PowerProcessEvent(PowerCompleteDx);
    return WdfDevStatePwrPolNull;
}
 
WDF_DEVICE_POWER_POLICY_STATE
FxPkgPnp::NotPowerPolOwnerGotoDxInDx(
    __inout FxPkgPnp* This
    )
{
    This->PowerProcessEvent(PowerCompleteDx);
    return WdfDevStatePwrPolNull;
}
 
WDF_DEVICE_POWER_POLICY_STATE
FxPkgPnp::NotPowerPolOwnerGotoD0(
    __inout FxPkgPnp* This
    )
{
    This->PowerProcessEvent(PowerCompleteD0);
    return WdfDevStatePwrPolNull;
}
 
WDF_DEVICE_POWER_POLICY_STATE
FxPkgPnp::NotPowerPolOwnerGotoD0InD0(
    __inout FxPkgPnp* This
    )
{
    This->PowerProcessEvent(PowerCompleteD0);
    return WdfDevStatePwrPolNull;
}
 
WDF_DEVICE_POWER_POLICY_STATE
FxPkgPnp::NotPowerPolOwnerStopping(
    __inout FxPkgPnp* This
    )
/*++
 
Routine Description:
    Stopping the power policy state machine for a device which is not the power
    policy owner.  Tell the power state machine to power down.
 
Arguments:
    This - instance of the state machine
 
Return Value:
    WdfDevStatePwrPolStoppingWaitingForImplicitPowerDown
 
  --*/
{
    This->PowerProcessEvent(PowerImplicitD3);
    return WdfDevStatePwrPolStoppingWaitingForImplicitPowerDown;
}
 
WDF_DEVICE_POWER_POLICY_STATE
FxPkgPnp::NotPowerPolOwnerStoppingSendStatus(
    __inout FxPkgPnp* This
    )
/*++
 
Routine Description:
    Stopping the power policy state machine for a device which is not the power
    policy owner has succeeded.  Inidcate status to the pnp state machine.
 
Arguments:
    This - instance of the state machine
 
Return Value:
    WdfDevStatePwrPolStopped
 
  --*/
{
    This->PnpProcessEvent(PnpEventPwrPolStopped);
    return WdfDevStatePwrPolStopped;
}
 
WDF_DEVICE_POWER_POLICY_STATE
FxPkgPnp::NotPowerPolOwnerStartingFailed(
    __inout FxPkgPnp* This
    )
/*++
 
Routine Description:
    Starting the power policy state machine for a device which is not the power
    policy owner has failed.  Inidcate status to the pnp state machine.
 
Arguments:
    This - instance of the state machine
 
Return Value:
    WdfDevStatePwrPolNull
 
  --*/
{
    This->PnpProcessEvent(PnpEventPwrPolStartFailed);
    return WdfDevStatePwrPolNull;
}
 
WDF_DEVICE_POWER_POLICY_STATE
FxPkgPnp::NotPowerPolOwnerStoppingFailed(
    __inout FxPkgPnp* This
    )
/*++
 
Routine Description:
    Stopping the power policy state machine for a device which is not the power
    policy owner has failed.  Inidcate status to the pnp state machine.
 
Arguments:
    This - instance of the state machine
 
Return Value:
    WdfDevStatePwrPolStopped
 
  --*/
{
    This->PnpProcessEvent(PnpEventPwrPolStopFailed);
    return WdfDevStatePwrPolStopped;
}
 
WDF_DEVICE_POWER_POLICY_STATE
FxPkgPnp::NotPowerPolOwnerStoppingPoweringUp(
    __inout FxPkgPnp* This
    )
/*++
 
Routine Description:
    Right as  we attempted to implicitly power down, a real D0 irp came into the
    stack.  Complete the D0 irp in the power state machine so that the power
    state machine can process the implicit power irp
 
Arguments:
    This - instance of the state machine
 
Return Value:
    WdfDevStatePwrPolNull
 
  --*/
{
    This->PowerProcessEvent(PowerCompleteD0);
    return WdfDevStatePwrPolNull;
}
 
WDF_DEVICE_POWER_POLICY_STATE
FxPkgPnp::NotPowerPolOwnerStoppingPoweringDown(
    __inout FxPkgPnp* This
    )
/*++
 
Routine Description:
    Right as  we attempted to implicitly power down, a real Dx irp came into the
    stack.  Complete the Dx irp in the power state machine so that the power
    state machine can process the implicit power irp
 
Arguments:
    This - instance of the state machine
 
Return Value:
    WdfDevStatePwrPolNull
 
  --*/
{
    This->PowerProcessEvent(PowerCompleteDx);
    return WdfDevStatePwrPolNull;
}
 
WDF_DEVICE_POWER_POLICY_STATE
FxPkgPnp::NotPowerPolOwnerRemoved(
    __inout FxPkgPnp* This
    )
/*++
 
Routine Description:
    The device is being removed, so prepare for removal.
 
Arguments:
    This - instance of the state machine
 
Return Value:
    WdfDevStatePwrPolNull
 
  --*/
{
    //
    // Since we are not the power policy owner, there is nothing to be done.
    // Indicate to the PNP state machine that we are ready for removal.
    //
    This->PnpProcessEvent(PnpEventPwrPolRemoved);
    return WdfDevStatePwrPolNull;
}