/*++

Copyright (c) 1990  Microsoft Corporation

Module Name:

    state.c

Abstract:

    Maintains state changes for power management power states
    for device objects

Author:

    Ken Reneris (kenr) 19-July-1994

Revision History:

--*/


#include "pop.h"

#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, PopStateChangeWorker)
#endif


NTSTATUS
PoRequestPowerChange (
    IN PDEVICE_OBJECT   DeviceObject,
    IN POWER_STATE      SystemPowerState,
    IN ULONG            DevicePowerState
    )
/*++

Routine Description:

    Request to put the supplied device object into the supplied power
    state.   If need be the device will be sent a SetPower irp to
    allow it to change into the specific power state.

Arguments:

    DeviceObject - Device Object to change power state
    SystsemPowerState - Desired system specified power state
    DevicePowerState - Desired device specific power state

Return Value:

    Success if state change is pending; otherwise error

--*/
{
    KIRQL   OldIrql;

#ifndef _PNP_POWER_

    return STATUS_NOT_IMPLEMENTED;

#else

    PopLockStateDatabase (&OldIrql);

    PopRequestPowerChange (
       DeviceObject->DeviceObjectExtension,
       SystemPowerState,
       DevicePowerState
       );

    PopUnlockStateDatabase (OldIrql);

    return STATUS_SUCCESS;

#endif
}

#ifdef _PNP_POWER_

VOID
PopRequestPowerChange (
    IN PDEVOBJ_EXTENSION DeviceObjectExt,
    IN POWER_STATE      SystemPowerState,
    IN ULONG            DevicePowerState
    )
/*++

Routine Description:

    Request to set the devices PendingPowerState and PendingDevicePowerState
    to the passed parameters.  This function will merge multiple power
    state requests and queue the device object for later processing if
    needed.

    Assumes the caller has the power state database lock

Arguments:

    DeviceObject - Device Object to change power state
    SystsemPowerState - Desired system specified power state
    DevicePowerState - Desired device specific power state

Return Value:

    none.

--*/
{
    PLIST_ENTRY     WhichQueue;


    ASSERT (SystemPowerState <= PowerDown);

    //
    // If device is already queued onto a power state change queue, remove it
    //

    if (DeviceObjectExt->PowerStateChange.Flink) {
        RemoveEntryList (&DeviceObjectExt->PowerStateChange);
        DeviceObjectExt->PowerStateChange.Flink = NULL;
    }

    //
    // If this device isn't concerned with power management, then set it
    // to whatever state we're in
    //

    if (!DeviceObjectExt->PowerControlNeeded) {
        DeviceObjectExt->CurrentPowerState = SystemPowerState;
        DeviceObjectExt->PendingPowerState = SystemPowerState;
        return ;
    }

    //
    // If device specific state specified, set it as pending
    //

    if (DevicePowerState != 0) {
        DeviceObjectExt->PendingDevicePowerState = DevicePowerState;
    }

    //
    // If power management has been disabled, then devices should always
    // be in the PowerUp state.
    //

    if (!PoEnabled) {
        // hardcoded to PowerUp state when not enabled
        SystemPowerState = PowerUp;
    }

    //
    // Merge the pending state with the current pending state.
    //

    SystemPowerState = PopNewPendingState[DeviceObjectExt->PendingPowerState]
                                         [SystemPowerState];
    ASSERT (SystemPowerState != PowerUnspecified);

    //
    // If the new state is PowerUp but the pending state is either suspend
    // or hibernate, delay the powerup until the SuspendInProgress
    // flag is clear
    //

    if (SystemPowerState == VerifyUp) {
        DeviceObjectExt->SetPowerUpPending = TRUE;

        //
        // Change requesting state to the pending state
        //

        SystemPowerState = DeviceObjectExt->PendingPowerState;
    }

    //
    // If delayed powerup is needed and the current state matches the
    // new state, and a suspend is no longer in progress then
    // change requesting state to be a PowerUp
    //

    if (DeviceObjectExt->SetPowerUpPending &&
        DeviceObjectExt->CurrentPowerState == SystemPowerState &&
        !DeviceObjectExt->Suspending) {

        DeviceObjectExt->SetPowerUpPending = FALSE;
        SystemPowerState = PowerUp;
    }

    //
    // Set new pending state
    //

    DeviceObjectExt->PendingPowerState = SystemPowerState;

    //
    // Determine which PowerChange queue to enqueue devices request
    //

    if (DeviceObjectExt->CurrentSetPowerIrp) {

        //
        // Power state change in progress for this device, put
        // device back on InProgress queue
        //

        WhichQueue = &PopStateChangeInProgress;

    } else if (DeviceObjectExt->CurrentPowerState == DeviceObjectExt->PendingPowerState  &&
               DeviceObjectExt->CurrentDevicePowerState == DeviceObjectExt->PendingDevicePowerState) {

        //
        // Pending power states match current states, no need to queue
        //

        WhichQueue = NULL;

    } else if (DeviceObjectExt->PendingPowerState == PowerUp  &&
               !DeviceObjectExt->UseAsyncPowerUp) {

        //
        // PowerUp and the device does not support AsyncPowerUp, so it's a
        // system synchronous power state change
        //

        WhichQueue = &PopSyncStateChangeQueue;

    } else {

        //
        // Asynchronous state change
        //

        WhichQueue = &PopAsyncStateChangeQueue;
    }

    if (WhichQueue) {

        //
        // Enqueue device onto it's queue & kick off a DPC to handle it
        //

        InsertTailList (WhichQueue, &DeviceObjectExt->PowerStateChange);
        if (!PopStateChangeDpcActive) {
            PopStateChangeDpcActive = TRUE;
            KeInsertQueueDpc (&PopStateChangeDpc, NULL, NULL);
        }

#if 0
        //
        // Stop IoStartPacket from sending any new non-power irps
        // to the device driver.  Once the device reaches an
        // steady-state of PowerUp the queue will be released
        //

        DeviceObjectExt->StartIoQueueHolding = TRUE;
#endif

    } else {

        //
        // Device was not added to any work queue, if all state change
        // queues are empty notify Suspend/Hibernate code
        //

        if (PopIsStateDatabaseIdle()) {
            if (!KeReadStateEvent (&PopStateDatabaseIdle)) {
                KeSetEvent (&PopStateDatabaseIdle, 0, FALSE);
            }
        }
    }
}



VOID
PopStateChange (
    IN PKDPC    Dpc,
    IN PVOID    DeferredContext,
    IN PVOID    SystemArgument1,
    IN PVOID    SystemArgument2
    )
/*++

Routine Description:

    DPC to process devices which have pending power state changes.

Arguments:

Return Value:

    none.

--*/
{
    PLIST_ENTRY         Entry;
    KIRQL               OldIrql;
    BOOLEAN             SyncRequest, CleanUpError;
    PDEVOBJ_EXTENSION   DeviceObjectExt;
    PIRP                irp;
    PIO_STACK_LOCATION  irpSp;
    POWER_STATE         NewPowerState;
    ULONG               NewDevicePowerState;
    PLIST_ENTRY         Link;


    CleanUpError = FALSE;

    for (; ;) {
        PopLockStateDatabase (&OldIrql);

        //
        // If there's a synchronous state change waiting, and no other
        // synchronous state change start one.
        //

        if (!IsListEmpty(&PopSyncStateChangeQueue)  &&  !PopSyncChangeInProgress) {

            //
            // Process entry in synchronous queue
            //

            PopSyncChangeInProgress = TRUE;
            SyncRequest = TRUE;
            Entry = RemoveHeadList (&PopSyncStateChangeQueue);

        } else if (!IsListEmpty(&PopAsyncStateChangeQueue)) {

            //
            // Process entry in asynchronous queue
            //

            SyncRequest = FALSE;
            Entry = RemoveHeadList (&PopAsyncStateChangeQueue);

        } else {

            //
            // No entries found to work on, done
            //

            break;
        }

        //
        // Put device in the state change in progress queue
        //

        InsertTailList (&PopStateChangeInProgress, Entry);
        DeviceObjectExt = CONTAINING_RECORD(Entry, DEVOBJ_EXTENSION, PowerStateChange);

        //
        // SetPower is in progress, put non-zero value in CurrentSetPowerIrp
        // and collect the new pending state information
        //

        DeviceObjectExt->CurrentSetPowerIrp = (PIRP) -1;
        NewPowerState = DeviceObjectExt->PendingPowerState;
        NewDevicePowerState = DeviceObjectExt->PendingDevicePowerState;

        //
        // Unlock power database
        //

        PopUnlockStateDatabase (OldIrql);

        //
        // Allocate and send the device a SetPower irp for it's new power
        // state
        //

        irp = IoAllocateIrp ( (CCHAR) 2, FALSE );

        if (!irp) {
            CleanUpError = TRUE;
            break;
        }

        //
        // Retain the current irp performing the SetPower for this device
        //

        DeviceObjectExt->CurrentSetPowerIrp = irp;

        //
        // Copy some state into the first stack location
        //

        irpSp = IoGetNextIrpStackLocation (irp);
        irpSp->Parameters.Others.Argument1 = (PVOID) NewPowerState;
        irpSp->Parameters.Others.Argument2 = (PVOID) NewDevicePowerState;
        irpSp->Parameters.Others.Argument3 = (PVOID) SyncRequest;
        irpSp->DeviceObject = DeviceObjectExt->DeviceObject;

        //
        // Fill in params for SetPower irp
        //

        IoSetNextIrpStackLocation (irp);
        irpSp = IoGetNextIrpStackLocation (irp);
        irpSp->MajorFunction = IRP_MJ_SET_POWER;
        irpSp->Parameters.SetPower.PowerState = NewPowerState;
        irpSp->Parameters.SetPower.DevicePowerState = NewDevicePowerState;
        irpSp->DeviceObject = DeviceObjectExt->DeviceObject;
        irp->UserIosb  = NULL;
        irp->UserEvent = NULL;

        IoHoldDeviceQueue (DeviceObjectExt->DeviceObject, irp);

        IoSetCompletionRoutine(
                irp,
                PopSetPowerComplete,
                NULL,  /* Context */
                TRUE,
                TRUE,
                TRUE
            );

        //
        // If the device is in the powered up state, then we will
        // send this initial !PowerUp request to the device via
        // a worker thread.  This allows the device driver to have
        // pagable code for it's SetPower handling as the first
        // request it will get to leave the PowerUp state will always
        // occur at IRQL < DISPATCH_LEVEL.
        //

        if (DeviceObjectExt->CurrentPowerState == PowerUp ||
            DeviceObjectExt->PowerControlPagable == TRUE) {

#if DBG
            //
            // If device has PowerControlPaged, it must also have
            // AsyncPowerUp
            //

            if (DeviceObjectExt->PowerControlPagable) {
                ASSERT (DeviceObjectExt->UseAsyncPowerUp);
            }
#endif

            //
            // Queue the IRP for the worker thread
            //

            Link = ExInterlockedInsertTailList (
                        &PopStateChangeWorkerList,
                        (PLIST_ENTRY) &irp->Tail.Overlay.ListEntry,
                        &PopStateLock
                        );

            if (Link == NULL) {
                ExQueueWorkItem (&PopStateChangeWorkItem, CriticalWorkQueue);
            }

        } else {

            //
            // send the IRP
            //

            irp->Tail.Overlay.Thread = PsGetCurrentThread();
            IoCallDriver( DeviceObjectExt->DeviceObject, irp );
        }

        //
        // loop, go look for more work
        //
    }

    if (CleanUpError) {

        //
        // Something happened and the power state change requested
        // on the DeviceObjectExt.  Undo the work, and
        // set a timer to try again later.
        //

        PopLockStateDatabase (&OldIrql);

        DeviceObjectExt->CurrentSetPowerIrp = NULL;
        if (SyncRequest) {
            PopSyncChangeInProgress = FALSE;
        }

        //
        // Request device's current state
        //

        PopRequestPowerChange (DeviceObjectExt, 0, 0);

        //
        // Try again later
        //

        KeSetTimer (
            &PopStateChangeTimer,
            PopIdleScanTime,
            &PopStateChangeDpc
            );

    } else {

        //
        // All pending work submitted, wait for more
        //

        PopStateChangeDpcActive = FALSE;
    }

    //
    // Unlock Power Manager Database
    //

    PopUnlockStateDatabase (OldIrql);
}

VOID
PopStateChangeWorker (
    IN PVOID    WorkerContext
    )
/*++

Routine Description:

    Dispatches enqueued SetPower IRPs from PASSIVE_LEVEL.

Arguments:

Return Value:

--*/
{
    PLIST_ENTRY         Entry;
    PIRP                irp;
    PIO_STACK_LOCATION  irpSp;

    PAGED_CODE();

    //
    // Reset work queue item for next time
    //

    ExInitializeWorkItem (&PopStateChangeWorkItem, PopStateChangeWorker, NULL);

    //
    // Dispatch any pending state change irps
    //

    while (Entry = ExInterlockedRemoveHeadList (&PopStateChangeWorkerList, &PopStateLock)) {

        //
        // Send this state change IRP
        //

        irp = CONTAINING_RECORD(Entry, IRP, Tail.Overlay.ListEntry);
        irpSp = IoGetCurrentIrpStackLocation (irp);
        irp->Tail.Overlay.Thread = PsGetCurrentThread();
        IoCallDriver( irpSp->DeviceObject, irp );
    }
}


NTSTATUS
PopSetPowerComplete (
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp,
    IN PVOID Context
/*++

Routine Description:

    Completion function for a SetPower IRP.  If the device completed
    the SetPower request sucessfully, then the drivers current power
    state is updated; otherwise, the devices current power state is
    not changed.

Arguments:

    DeviceObject - NULL.
    Irp          - SetPower irp which has completed
    Context      - NULL.

Return Value:

    STATUS_MORE_PROCESSING_REQUIRED is returned to IoCompleteRequest
    to signify that IoCompleteRequest should not continue processing
    the IRP.

--*/
    )
{
    KIRQL               OldIrql;
    BOOLEAN             SetIdleTimer;
    BOOLEAN             SyncRequest;
    BOOLEAN             Failed;
    UCHAR               PowerState, DevicePowerState;
    PIO_STACK_LOCATION  irpSp;
    PDEVOBJ_EXTENSION   DeviceObjectExt;
#if DBG
    POWER_STATE                 FailedCurrentPowerState;
    POWER_STATE                 FailedPendingPowerState;
    POBJECT_NAME_INFORMATION    FailedObjectName;
#endif

    SetIdleTimer = FALSE;
    Failed = FALSE;

    //
    // Read state from Irp.
    //

    irpSp = IoGetCurrentIrpStackLocation (Irp);
    PowerState       = (UCHAR)   irpSp->Parameters.Others.Argument1;
    DevicePowerState = (UCHAR)   irpSp->Parameters.Others.Argument2;
    SyncRequest      = (BOOLEAN) irpSp->Parameters.Others.Argument3;
    DeviceObject     = irpSp->DeviceObject;
    DeviceObjectExt  = DeviceObject->DeviceObjectExtension;

    PopLockStateDatabase (&OldIrql);

    //
    // Set device's new power state to match those
    // of the requested state
    //

    if (NT_SUCCESS (Irp->IoStatus.Status)) {
        DeviceObjectExt->CurrentPowerState = PowerState;
        DeviceObjectExt->CurrentDevicePowerState = DevicePowerState;

    } else {

        //
        // Device failed to enter the requested power state.
        //

#if DBG
        if (DeviceObjectExt->PendingPowerState == PowerState &&
            DeviceObjectExt->CurrentPowerState != DeviceObjectExt->PendingPowerState) {

            Failed = TRUE;
            FailedCurrentPowerState = DeviceObjectExt->CurrentPowerState;
            FailedPendingPowerState = DeviceObjectExt->PendingPowerState;
        }
#endif
        //
        // If failed to set the pending power state, then abort the pending
        // power state back to the current state.
        //

        if (DeviceObjectExt->PendingPowerState == PowerState) {
            DeviceObjectExt->PendingPowerState = DeviceObjectExt->CurrentPowerState;
        }

        if (DeviceObjectExt->PendingDevicePowerState == DevicePowerState) {
            DeviceObjectExt->PendingDevicePowerState = DeviceObjectExt->CurrentDevicePowerState;
        }
    }

    //
    // Check to see if this was a synchronous state change which just completed,
    // if so allow the new synchronous state change.
    //

    if (SyncRequest) {
        ASSERT (PopSyncChangeInProgress == TRUE);
        PopSyncChangeInProgress = FALSE;
    }

    //
    // SetPower no longer in progress, clear the CurrentIrpSetPower pointer
    //

    DeviceObjectExt->CurrentSetPowerIrp = NULL;

    //
    // Request power state to match current pending state
    //

    PopRequestPowerChange (DeviceObjectExt, 0, 0);

    //
    // If the CurrentPowerState and the PendingPowerState are both
    // PowerUp, then the device is PoweredOn and a change is not pending
    //

    if (DeviceObjectExt->CurrentPowerState == PowerUp  &&
        DeviceObjectExt->PendingPowerState == PowerUp) {

        //
        // If the Device get Idle detection make sure it's in the
        // ActiveIdleScanQueue
        //

        if (DeviceObjectExt->MaxIdleCount != 0 &&
            DeviceObjectExt->IdleList.Flink == NULL) {

            SetIdleTimer = IsListEmpty(&PopActiveIdleScanQueue);
            InsertTailList (&PopActiveIdleScanQueue, &DeviceObjectExt->IdleList);
            PoSetDeviceBusy (DeviceObject);
        }

        //
        // Release any irps which were postponded from IoStartPacket
        //

        IoReleaseStartIoHoldingQueue (DeviceObject);
    }

    PopUnlockStateDatabase (OldIrql);

#if DBG
    if (Failed) {

        FailedObjectName = PopGetDeviceName (DeviceObject);
        if (FailedObjectName) {
            DbgPrint ("PO: Device %lx failed %s->%s  '%Z'\n",
                DeviceObject,
                PopPowerState (FailedCurrentPowerState),
                PopPowerState (FailedPendingPowerState),
                &FailedObjectName->Name
                );

            ExFreePool (FailedObjectName);
        } else {
            DbgPrint ("PO: Device %lx failed %s->%s\n",
                DeviceObject,
                PopPowerState (FailedCurrentPowerState),
                PopPowerState (FailedPendingPowerState)
                );
        }
    }
#endif

    //
    // If IdleScan list went from being empty to having something in it,
    // set the idle the timer
    //

    if (SetIdleTimer) {
        KeSetTimer (&PopIdleScanTimer, PopIdleScanTime, &PopIdleScanDpc);
    }

    //
    // Irp processing is complete, free the irp and then return
    // more_processing_requered which causes IoCompleteRequest to
    // stop "completing" this irp any future.
    //

    IoFreeIrp (Irp);
    return STATUS_MORE_PROCESSING_REQUIRED;
}

#endif // _PNP_POWER_