windows-xp/Source/XPSP1/NT/drivers/storage/scsiport/power.c

/*++

Copyright (C) Microsoft Corporation, 1996 - 1999

Module Name:

    power.c

Abstract:

    This module contains the routines for port driver power support

Authors:

    Peter Wieland

Environment:

    Kernel mode only

Notes:

Revision History:

--*/

#include "port.h"

PUCHAR PowerMinorStrings[] = {
    "IRP_MN_WAIT_WAKE",
    "IRP_MN_POWER_SEQUENCE",
    "IRP_MN_SET_POWER",
    "IRP_MN_QUERY_POWER"
};

VOID
SpProcessAdapterSystemState(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
    );

VOID
SpProcessAdapterDeviceState(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
    );

NTSTATUS
SpQueryTargetPower(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp,
    IN POWER_STATE_TYPE Type,
    IN POWER_STATE State
    );

NTSTATUS
SpQueryAdapterPower(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp,
    IN POWER_STATE_TYPE Type,
    IN POWER_STATE State
    );

NTSTATUS
SpSetTargetDeviceState(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp,
    IN DEVICE_POWER_STATE DeviceState
    );

VOID
SpSetTargetDeviceStateLockedCompletion(
    IN PDEVICE_OBJECT DeviceObject,
    IN NTSTATUS Status,
    IN PIRP OriginalIrp
    );

VOID
SpSetTargetDeviceStateUnlockedCompletion(
    IN PDEVICE_OBJECT DeviceObject,
    IN NTSTATUS Status,
    IN PIRP OriginalIrp
    );

NTSTATUS
SpSetTargetSystemState(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp,
    IN SYSTEM_POWER_STATE SystemState
    );

VOID
SpSetTargetSystemStateLockedCompletion(
    IN PDEVICE_OBJECT DeviceObject,
    IN NTSTATUS Status,
    IN PIRP OriginalIrp
    );

VOID
SpSetTargetSystemStateUnlockedCompletion(
    IN PDEVICE_OBJECT DeviceObject,
    IN NTSTATUS Status,
    IN PIRP OriginalIrp
    );

VOID
SpSetTargetDeviceStateForSystemStateCompletion(
    IN PDEVICE_OBJECT DeviceObject,
    IN UCHAR MinorFunction,
    IN POWER_STATE PowerState,
    IN PIRP OriginalIrp,
    IN PIO_STATUS_BLOCK IoStatus
    );

NTSTATUS
SpSetAdapterPower(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp,
    IN POWER_STATE_TYPE Type,
    IN POWER_STATE State
    );

VOID
SpRequestAdapterPowerCompletion(
    IN PDEVICE_OBJECT DeviceObject,
    IN UCHAR MinorFunction,
    IN POWER_STATE PowerState,
    IN PIRP OriginalIrp,
    IN PIO_STATUS_BLOCK IoStatus
    );

VOID
SpPowerAdapterForTargetCompletion(
    IN PDEVICE_OBJECT DeviceObject,
    IN UCHAR MinorFunction,
    IN POWER_STATE PowerState,
    IN PIRP OriginalIrp,
    IN PIO_STATUS_BLOCK IoStatus
    );

NTSTATUS
SpSetLowerPowerCompletion(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp,
    IN PVOID Context
    );

VOID
SpSetTargetDesiredPowerCompletion(
    IN PDEVICE_OBJECT DeviceObject,
    IN UCHAR MinorFunction,
    IN POWER_STATE PowerState,
    IN PIRP OriginalIrp,
    IN PIO_STATUS_BLOCK IoStatus
    );

VOID
SpRequestValidPowerStateCompletion (
    IN PDEVICE_OBJECT DeviceObject,
    IN UCHAR MinorFunction,
    IN POWER_STATE PowerState,
    IN PLOGICAL_UNIT_EXTENSION LogicalUnit,
    IN PIO_STATUS_BLOCK IoStatus
    );

typedef struct {
    NTSTATUS Status;
    KEVENT Event;
} SP_SIGNAL_POWER_COMPLETION_CONTEXT, *PSP_SIGNAL_POWER_COMPLETION_CONTEXT;

VOID
SpSignalPowerCompletion(
    IN PDEVICE_OBJECT DeviceObject,
    IN UCHAR MinorFunction,
    IN POWER_STATE PowerState,
    IN PSP_SIGNAL_POWER_COMPLETION_CONTEXT Context,
    IN PIO_STATUS_BLOCK IoStatus
    );

#pragma alloc_text(PAGE, SpRequestValidAdapterPowerStateSynchronous)


NTSTATUS
ScsiPortDispatchPower(
    IN PDEVICE_OBJECT DeviceObject,
    IN OUT PIRP Irp
    )
/*++

Routine Description:

    This routine handles all IRP_MJ_POWER IRPs for the target device objects.

    N.B. This routine is NOT pageable as it may be called at dispatch level.

Arguments:

    DeviceObject - Pointer to the device object for which this IRP applies.

    Irp - Pointer to the IRP_MJ_PNP IRP to dispatch.

Return Value:

    NT status.

--*/

{
    PCOMMON_EXTENSION commonExtension = DeviceObject->DeviceExtension;
    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
    BOOLEAN isPdo = commonExtension->IsPdo;
    NTSTATUS status;

    //
    // Get the current status of the request.
    //

    status = Irp->IoStatus.Status;

    DebugPrint((4, "ScsiPortDispatchPower: irp %p is %s for %s %p\n",
                Irp,
                PowerMinorStrings[irpStack->MinorFunction],
                isPdo ? "pdo" : "fdo",
                DeviceObject));

    switch (irpStack->MinorFunction) {

       case IRP_MN_SET_POWER: {

           POWER_STATE_TYPE type = irpStack->Parameters.Power.Type;
           POWER_STATE state = irpStack->Parameters.Power.State;

           DebugPrint((4, "ScsiPortDispatchPower: SET_POWER type %d state %d\n",
                       type, state));

#if DBG
           if (type == SystemPowerState) {
               ASSERT(state.SystemState >= PowerSystemUnspecified);
               ASSERT(state.SystemState < PowerSystemMaximum);
           } else {                
               ASSERT(state.DeviceState >= PowerDeviceUnspecified);
               ASSERT(state.DeviceState < PowerDeviceMaximum);
           }
#endif

           //
           // If this is a power-down request then call PoSetPowerState now
           // while we're not actually holding any resources or locks.
           //

           if ((state.SystemState != PowerSystemWorking) ||
               (state.DeviceState != PowerDeviceD0)) {

               PoSetPowerState(DeviceObject, type, state);

            }

           //
           // Special case system shutdown request.
           //

           if ((type == SystemPowerState) &&
               (state.SystemState > PowerSystemHibernate)) { 

               if (isPdo) {

                   //
                   // Do not pwer-downdown PDOs on shutdown.  There is no 
                   // reliable way to ensure that disks will spin up on restart.
                   //

                   status = STATUS_SUCCESS;
                   break;

               } else {

                   PADAPTER_EXTENSION adapter;

                   //
                   // If the adapter is not configured to receive power-down
                   // requests at shutdown, just pass the request down.
                   // 
                   
                   adapter = (PADAPTER_EXTENSION)commonExtension;
                   if (adapter->NeedsShutdown == FALSE) {

                       PoStartNextPowerIrp(Irp);
                       IoCopyCurrentIrpStackLocationToNext(Irp);
                       return PoCallDriver(commonExtension->LowerDeviceObject, Irp);
                   }
               }
           }

           if (isPdo) {

               if (type == DevicePowerState) {
                   status = SpSetTargetDeviceState(DeviceObject,
                                                   Irp,
                                                   state.DeviceState);
               } else {
                   status = SpSetTargetSystemState(DeviceObject,
                                                   Irp,
                                                   state.SystemState);
               }
           } else {
               
               PADAPTER_EXTENSION adapter = DeviceObject->DeviceExtension;
               
               //
               // If we have disabled power then ignore any non-working power irps.
               //
               
               if ((adapter->DisablePower) &&
                   ((state.DeviceState != PowerDeviceD0) ||
                    (state.SystemState != PowerSystemWorking))) {

                   status = STATUS_SUCCESS;
                   break;
               } else {
                   status = SpSetAdapterPower(DeviceObject, Irp, type, state);
               }
            }

            if(status == STATUS_PENDING) {
                return status;
            }

            break;
       }

       case IRP_MN_QUERY_POWER: {
           POWER_STATE_TYPE type = irpStack->Parameters.Power.Type;
           POWER_STATE state = irpStack->Parameters.Power.State;

           DebugPrint((4, "ScsiPortDispatchPower: QUERY_POWER type %d "
                       "state %d\n",
                       type, state));

           if ((type == SystemPowerState) &&
               (state.SystemState > PowerSystemHibernate)) {

               //
               // Ignore shutdown irps.
               //
               
               DebugPrint((4, "ScsiPortDispatch power - ignoring shutdown "
                           "query irp for level %d\n",
                           state.SystemState));
               status = STATUS_SUCCESS;
               break;
           }

           if (isPdo) {
               if ((type == SystemPowerState) &&
                   (state.SystemState > PowerSystemHibernate)) {

                   //
                   // Ignore shutdown irps.
                   //
                   
                   DebugPrint((4, "ScsiPortDispatch power - ignoring shutdown "
                               "query irp for level %d\n",
                               state.SystemState));
                   status = STATUS_SUCCESS;
               } else {
                   status = SpQueryTargetPower(DeviceObject,
                                               Irp,
                                               type,
                                               state);
               }
           } else {

               PADAPTER_EXTENSION adapter = (PADAPTER_EXTENSION)commonExtension;

               //
               // If we don't support power for this adapter then fail all
               // queries.
               //

               if (adapter->DisablePower) {
                   status = STATUS_NOT_SUPPORTED;
                   break;
               }

               status = SpQueryAdapterPower(DeviceObject, Irp, type, state);

               if (NT_SUCCESS(status)) {
                   
                   //
                   // See what the lower driver wants to do.
                   //
                   
                   PoStartNextPowerIrp(Irp);
                   IoCopyCurrentIrpStackLocationToNext(Irp);
                   return PoCallDriver(commonExtension->LowerDeviceObject, Irp);
               }
           }

           break;
       }

       case IRP_MN_WAIT_WAKE: {

           if (isPdo) {

               //
               // We don't support WAIT WAKE, so just fail the request.
               //

               status = STATUS_INVALID_DEVICE_REQUEST;
               PoStartNextPowerIrp(Irp);
               Irp->IoStatus.Status = status;
               IoCompleteRequest(Irp, IO_NO_INCREMENT);

           } else {

               //
               // Pass the request down.
               //

               PoStartNextPowerIrp(Irp);
               IoSkipCurrentIrpStackLocation(Irp);
               status = PoCallDriver(commonExtension->LowerDeviceObject, Irp);

           }

           return status;
       }

       default: {
           //
           // We pass down FDO requests we don't handle.
           //
           
           if (!isPdo) {
               PoStartNextPowerIrp(Irp);
               IoSkipCurrentIrpStackLocation(Irp);
               return PoCallDriver(commonExtension->LowerDeviceObject, Irp);
           }

           break;
        }
    }

    //
    // Complete the request.
    //

    PoStartNextPowerIrp(Irp);
    Irp->IoStatus.Status = status;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);

    return status;
}


NTSTATUS
SpSetAdapterPower(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp,
    IN POWER_STATE_TYPE Type,
    IN POWER_STATE State
    )
/*++

Routine Description:

    Wrapper routine to dump adapter power requests into the device i/o queue.
    Power requests are processed by the StartIo routine which calls
    SpProcessAdapterPower to do the actual work.

Arguments:

    DeviceObject - the device object being power managed.

    Irp - the power management irp.

    Type - the type of set_power irp (device or system)

    State - the state the adapter is being put into.

Return Value:

    STATUS_PENDING

--*/

{
    PCOMMON_EXTENSION commonExtension = DeviceObject->DeviceExtension;
    PADAPTER_EXTENSION adapter = DeviceObject->DeviceExtension;

    NTSTATUS status;

    ASSERT_FDO(DeviceObject);

    DebugPrint((2, "SpSetAdapterPower - starting packet\n"));

    if(SpIsAdapterControlTypeSupported(adapter, ScsiStopAdapter)) {

        IoMarkIrpPending(Irp);
        IoStartPacket(DeviceObject, Irp, 0L, FALSE);
        return STATUS_PENDING;

    } else if((commonExtension->CurrentPnpState != IRP_MN_START_DEVICE) &&
              (commonExtension->PreviousPnpState != IRP_MN_START_DEVICE)) {

        //
        // Fine, we're in a low power state.  If we get a start or a remove
        // then there's an implicit power transition there so we don't really
        // need to set our current power state.
        //

        IoMarkIrpPending(Irp);
        IoCopyCurrentIrpStackLocationToNext(Irp);
        PoStartNextPowerIrp(Irp);
        PoCallDriver(commonExtension->LowerDeviceObject, Irp);
        return STATUS_PENDING;

    } else {

        Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
        return Irp->IoStatus.Status;
    }
}


VOID
SpPowerAdapterForTargetCompletion(
    IN PDEVICE_OBJECT DeviceObject,
    IN UCHAR MinorFunction,
    IN POWER_STATE PowerState,
    IN PIRP OriginalIrp,
    IN PIO_STATUS_BLOCK IoStatus
    )
/*++

Routine Description:

    This routine is called for a D0 request to a target device after it's
    adapter has been powered back on.  The routine will call back into
    SpSetTargetDeviceState to restart the power request or complete the
    target D request if the adapter power up was not successful.

Arguments:

    DeviceObject - the adapter which was powered up.

    MinorFunction - IRP_MN_SET_POWER

    PowerState - PowerDeviceD0

    OriginalIrp - The original target D0 irp.  This is the irp which will
                  be reprocessed.

    IoStatus - the status of the adapter power up request.

Return Value:

    none.

--*/

{
    PADAPTER_EXTENSION adapter = DeviceObject->DeviceExtension;

    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(OriginalIrp);
    POWER_STATE_TYPE type = irpStack->Parameters.Power.Type;
    POWER_STATE state = irpStack->Parameters.Power.State;

    NTSTATUS status = IoStatus->Status;

    DebugPrint((1, "SpPowerAdapterForTargetCompletion: DevObj %#p, Irp "
                   "%#p, Status %#08lx\n",
                DeviceObject, OriginalIrp, IoStatus));

    ASSERT_FDO(DeviceObject);
    ASSERT_PDO(irpStack->DeviceObject);

    ASSERT(type == DevicePowerState);
    ASSERT(state.DeviceState == PowerDeviceD0);

    ASSERT(NT_SUCCESS(status));

    if(NT_SUCCESS(status)) {

        ASSERT(adapter->CommonExtension.CurrentDeviceState == PowerDeviceD0);

        status = SpSetTargetDeviceState(irpStack->DeviceObject,
                                        OriginalIrp,
                                        PowerDeviceD0);
    }

    if(status != STATUS_PENDING) {
        PoStartNextPowerIrp(OriginalIrp);
        OriginalIrp->IoStatus.Status = status;
        IoCompleteRequest(OriginalIrp, IO_NO_INCREMENT);
    }
    return;
}


NTSTATUS
SpQueryAdapterPower(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp,
    IN POWER_STATE_TYPE Type,
    IN POWER_STATE State
    )
{
    PADAPTER_EXTENSION adapter = DeviceObject->DeviceExtension;
    PCOMMON_EXTENSION commonExtension = DeviceObject->DeviceExtension;
    NTSTATUS status;

    if((adapter->HwAdapterControl != NULL) && (adapter->IsPnp))  {

        status = STATUS_SUCCESS;

    } else if((commonExtension->CurrentPnpState != IRP_MN_START_DEVICE) &&
              (commonExtension->PreviousPnpState != IRP_MN_START_DEVICE)) {

        //
        // If the adapter's not been started yet then we can blindly go to
        // a lower power state - START irps imply a transition into the D0 state
        //

        status = STATUS_SUCCESS;

    } else {

        status = STATUS_NOT_SUPPORTED;
    }

    return status;
}


NTSTATUS
SpQueryTargetPower(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp,
    IN POWER_STATE_TYPE Type,
    IN POWER_STATE State
    )
{
    return STATUS_SUCCESS;
}


NTSTATUS
SpRequestValidPowerState(
    IN PADAPTER_EXTENSION Adapter,
    IN PLOGICAL_UNIT_EXTENSION LogicalUnit,
    IN PSCSI_REQUEST_BLOCK Srb
    )
{
    PCOMMON_EXTENSION commonExtension = &(LogicalUnit->CommonExtension);
    PSRB_DATA srbData = Srb->OriginalRequest;

    BOOLEAN needsPower = SpSrbRequiresPower(Srb);

    NTSTATUS status = STATUS_SUCCESS;

    //
    // Make sure we're at a power level which can process this request.  If
    // we aren't then make this a pending request, lock the queues and
    // ask the power system to bring us up to a more energetic level.
    //

    if((Srb->Function == SRB_FUNCTION_UNLOCK_QUEUE) ||
       (Srb->Function == SRB_FUNCTION_LOCK_QUEUE)) {

        //
        // Lock and unlock commands don't require power and will work
        // regardless of the current power state.
        //

        return status;
    }

    //
    // Even if this is a bypass request, the class driver may not request
    // actual miniport operations on the unpowered side of a power sequence.
    // This means that this is either:
    //      * a request to an idle device - powering up the device will power
    //        up the adapter if necessary.
    //      * a request to power down a device - adapter cannot have powered
    //        off until this is done.
    //      * a part of a power up sequence - the only real SCSI commands come
    //        after the power up irp has been processed and that irp will
    //        already have turned the adapter on.
    // This boils down to - we don't need to do anything special here to
    // power up the adapter.  The device power sequences will take care of
    // it automatically.
    //

    //
    // If the device or system isn't working AND this is not a request to
    // unlock the queue then let it go through.  The class driver is going
    // to unlock the queue after sending us a power request so we need to
    // be able to handle one.
    //

    if((commonExtension->CurrentDeviceState != PowerDeviceD0) ||
       ((commonExtension->CurrentSystemState != PowerSystemWorking) &&
        (!TEST_FLAG(Srb->SrbFlags, SRB_FLAGS_BYPASS_LOCKED_QUEUE)))) {

        //
        // This request cannot be executed now.  Mark it as pending
        // in the logical unit structure and return.
        // GetNextLogicalUnit will restart the commnad after all of the
        // active commands have completed.
        //

        ASSERT(!TEST_FLAG(Srb->SrbFlags, SRB_FLAGS_BYPASS_LOCKED_QUEUE));

        ASSERT(!(LogicalUnit->LuFlags & LU_PENDING_LU_REQUEST));

        DebugPrint((4, "ScsiPortStartIo: logical unit (%d,%d,%d) [%#p] is "
                       "in power state (%d,%d) - must power up for irp "
                       "%#p\n",
                    Srb->PathId,
                    Srb->TargetId,
                    Srb->Lun,
                    commonExtension->DeviceObject,
                    commonExtension->CurrentDeviceState,
                    commonExtension->CurrentSystemState,
                    srbData->CurrentIrp));

        ASSERT(LogicalUnit->PendingRequest == NULL);
        LogicalUnit->PendingRequest = Srb->OriginalRequest;

        //
        // Indicate that the logical unit is still active so that the
        // request will get processed when the request list is empty.
        //

        SET_FLAG(LogicalUnit->LuFlags, LU_PENDING_LU_REQUEST |
                                       LU_LOGICAL_UNIT_IS_ACTIVE);

        if(commonExtension->CurrentSystemState != PowerSystemWorking) {

            DebugPrint((1, "SpRequestValidPowerState: can't power up target "
                           "since it's in system state %d\n",
                        commonExtension->CurrentSystemState));

            //
            // Set the desired D state in the device extension.  This is
            // necessary when we're in a low system state as well as useful for
            // debugging when we're in low D states.
            //

            commonExtension->DesiredDeviceState = PowerDeviceD0;

            //
            // If we aren't in a valid system state then just release the
            // spinlock and return.  The next time we receive a system
            // state irp we'll issue the appropriate D state irp as well.
            //

            return STATUS_PENDING;

        } else if(commonExtension->DesiredDeviceState == PowerDeviceD0) {

            //
            // Scsiport is already asking to power up this lun.  Once that's
            // happened this request will be restarted.  For now just leave
            // it as the pending request.
            //

            return STATUS_PENDING;
        }

        //
        // Tell Po that we're not idle in case this was stuck in the queue
        // for some reason.
        //

        if(commonExtension->IdleTimer != NULL) {
            PoSetDeviceBusy(commonExtension->IdleTimer);
        }

        //
        // Get PO to send a power request to this device stack to put it
        // back into the D0 state.
        //

        {
            POWER_STATE powerState;

            powerState.DeviceState = PowerDeviceD0;

            status = PoRequestPowerIrp(
                        commonExtension->DeviceObject,
                        IRP_MN_SET_POWER,
                        powerState,
                        NULL,
                        NULL,
                        NULL);
        }

        //
        // CODEWORK - if we can't power up the device here we'll need to
        // hang around in the tick handler for a while and try to do
        // it from there.
        //

        ASSERT(NT_SUCCESS(status));

        return STATUS_PENDING;
    }

    ASSERT(Adapter->CommonExtension.CurrentDeviceState == PowerDeviceD0);
    ASSERT(Adapter->CommonExtension.CurrentSystemState == PowerSystemWorking);

    return status;
}


NTSTATUS
SpSetLowerPowerCompletion(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp,
    IN PVOID Context
    )
{
    PADAPTER_EXTENSION adapter = DeviceObject->DeviceExtension;
    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
    POWER_STATE_TYPE type = irpStack->Parameters.Power.Type;
    POWER_STATE state = irpStack->Parameters.Power.State;

    DebugPrint((2, "SpSetLowerPowerCompletion: DevObj %#p Irp %#p "
                   "%sState %d\n",
                DeviceObject, Irp,
                ((type == SystemPowerState) ? "System" : "Device"),
                state.DeviceState - 1));

    if(NT_SUCCESS(Irp->IoStatus.Status)) {

        if(type == SystemPowerState) {

            DebugPrint((2, "SpSetLowerPowerCompletion: Lower device succeeded "
                           "the system state transition.  Reprocessing power "
                           "irp\n"));
            SpProcessAdapterSystemState(DeviceObject, Irp);
        } else {
            DebugPrint((2, "SpSetLowerPowerCompletion: Lower device power up "
                           "was successful.  Reprocessing power irp\n"));

            SpProcessAdapterDeviceState(DeviceObject, Irp);
        }
        return STATUS_MORE_PROCESSING_REQUIRED;
    } else {
        DebugPrint((1, "SpSetLowerPowerCompletion: Lower device power operation"
                       "failed - completing power irp with status %#08lx\n",
                    Irp->IoStatus.Status));
        PoStartNextPowerIrp(Irp);
        SpStartNextPacket(DeviceObject, FALSE);
        return STATUS_SUCCESS;
    }
}


VOID
SpProcessAdapterSystemState(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
    )
/*++

Routine Description:

    This routine handles a system power IRP for the adapter.

Arguments:

    DeviceObject - the device object for the adapter.

    Irp - the power irp.

Return Value:

    none

--*/
{
    PADAPTER_EXTENSION adapterExtension = DeviceObject->DeviceExtension;
    PCOMMON_EXTENSION commonExtension = DeviceObject->DeviceExtension;

    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
    SYSTEM_POWER_STATE state = irpStack->Parameters.Power.State.SystemState;

    SYSTEM_POWER_STATE originalSystemState;

    NTSTATUS status = STATUS_SUCCESS;

    ASSERT_FDO(DeviceObject);
    ASSERT(irpStack->Parameters.Power.Type == SystemPowerState);

    DebugPrint((2, "SpProcessAdapterSystemState: DevObj %#p Irp %#p "
                   "SystemState %d\n",
                   DeviceObject, Irp, state));

    originalSystemState = commonExtension->CurrentSystemState;

    try {

        POWER_STATE newDeviceState;

        if(((commonExtension->CurrentSystemState != PowerSystemWorking) &&
            (state != PowerSystemWorking)) ||
           (commonExtension->CurrentSystemState == state)) {

            DebugPrint((2, "SpProcessAdapterSystemState: no work required for "
                           "transition from system state %d to %d\n",
                        commonExtension->CurrentSystemState,
                        state));
            commonExtension->CurrentSystemState = state;
            leave;
        }

        //
        // Set the new system state.  We'll back it out if any errors occur.
        //

        commonExtension->CurrentSystemState = state;

        if(state != PowerSystemWorking) {

            //
            // Going into a non-working state - power down the device.
            //

            DebugPrint((1, "SpProcessAdapterSystemState: need to power "
                           "down adapter for non-working system state "
                           "%d\n", state));

            newDeviceState.DeviceState = PowerDeviceD3;

            //
            // This system irp cannot be completed until we've successfully
            // powered the adapter off (or on).
            //

            status = PoRequestPowerIrp(DeviceObject,
                                       IRP_MN_SET_POWER,
                                       newDeviceState,
                                       SpRequestAdapterPowerCompletion,
                                       Irp,
                                       NULL);

            DebugPrint((2, "SpProcessAdapterSystemState: PoRequestPowerIrp "
                           "returned %#08lx\n", status));

        } else {

            //
            // Transitioning the device into a system working state.  Just
            // do the enable.  When a child device is put into S0 and has
            // work to process it will request a D0 of the child which will
            // in turn request a D0 of the parent (ie. the adapter).  We can
            // defer adapter power on until that occurs.
            //

            // Going into a working device state.  When the targets are
            // powered on and we have work to do they will request an
            // adapter power up for us.
            //

            DebugPrint((1, "SpProcessAdapterSystemState: going to working "
                           "state - no need to take adapter out of power "
                           "state %d\n",
                        commonExtension->CurrentDeviceState));

            ASSERT(state == PowerSystemWorking);

            status = SpEnableDisableAdapter(adapterExtension, TRUE);

            ASSERT(status != STATUS_PENDING);

            DebugPrint((1, "SpProcessAdapterSystemState: SpEnableDisableAd. "
                           "returned %#08lx\n", status));

        }

    } finally {

        SpStartNextPacket(DeviceObject, FALSE);

        if(status != STATUS_PENDING) {

            if(!NT_SUCCESS(status)) {

                //
                // Something went wrong above.  Restore the original system
                // state.
                //

                commonExtension->CurrentSystemState = originalSystemState;
            }

            Irp->IoStatus.Status = status;
            PoStartNextPowerIrp(Irp);
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
        }

    }
    return;
}


VOID
SpProcessAdapterDeviceState(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
    )
/*++

Routine Description:

    This routine handles a device power IRP for the adapter.

Arguments:

    DeviceObject - the device object for the adapter.

    Irp - the power irp.

Return Value:

    none

--*/
{
    PADAPTER_EXTENSION adapterExtension = DeviceObject->DeviceExtension;
    PCOMMON_EXTENSION commonExtension = DeviceObject->DeviceExtension;

    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);

    DEVICE_POWER_STATE state = irpStack->Parameters.Power.State.DeviceState;

    NTSTATUS status = STATUS_SUCCESS;

    ASSERT_FDO(DeviceObject);
    ASSERT(irpStack->Parameters.Power.Type == DevicePowerState);

    DebugPrint((1, "SpProcessAdapterDevicePower: DevObj %#p Irp %#p "
                   "State %d\n",
                   DeviceObject, Irp, state));

    //
    // First check to see if we actually need to touch the queue.
    // If both the current and new state are working or non-working then
    // we don't have a thing to do.
    //

    if(((commonExtension->CurrentDeviceState != PowerDeviceD0) &&
        (state != PowerDeviceD0)) ||
       (commonExtension->CurrentDeviceState == state)) {

        DebugPrint((2, "SpProcessAdapterDeviceState: no work required "
                       "for transition from device state %d to %d\n",
                    commonExtension->CurrentDeviceState,
                    state));

    } else {

        BOOLEAN enable = (state == PowerDeviceD0);

        status = SpEnableDisableAdapter(adapterExtension, enable);

        ASSERT(status != STATUS_PENDING);

        DebugPrint((2, "SpProcessAdapterDeviceState: SpEnableDisableAd. "
                       "returned %#08lx\n", status));

    }

    ASSERT(status != STATUS_PENDING);

    if(NT_SUCCESS(status)) {
        commonExtension->CurrentDeviceState = state;
    }

    //
    // If this is not a D0 irp then throw it down to the lower driver,
    // otherwise complete it.
    //

    SpStartNextPacket(DeviceObject, FALSE);
    Irp->IoStatus.Status = status;
    PoStartNextPowerIrp(Irp);

    if(irpStack->Parameters.Power.State.DeviceState != PowerDeviceD0) {
        IoCopyCurrentIrpStackLocationToNext(Irp);
        PoCallDriver(commonExtension->LowerDeviceObject, Irp);
    } else {
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
    }

    //
    // If we successfully powered up the adapter, initiate a rescan so our child
    // device state is accurate.
    // 

    if (NT_SUCCESS(status) && (state == PowerDeviceD0)) {

        DebugPrint((1, "SpProcessAdapterDeviceState: powered up.. rescan %p\n",
                       adapterExtension->LowerPdo));

        IoInvalidateDeviceRelations(
            adapterExtension->LowerPdo,
            BusRelations);
    }

    return;
}


VOID
ScsiPortProcessAdapterPower(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
    )
{
    PADAPTER_EXTENSION adapter = DeviceObject->DeviceExtension;
    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);

    ASSERT(irpStack->MajorFunction == IRP_MJ_POWER);
    ASSERT(irpStack->MinorFunction == IRP_MN_SET_POWER);
    ASSERT_FDO(DeviceObject);

    //
    // Determine if the irp should be sent to the lower driver first.
    // If so send it down without calling SpStartNextPacket so we'll
    // still have synchronization in the completion routine.
    //
    // The completion routine calls ScsiPortProcessAdapterPower for this
    // irp.
    //

    if(irpStack->Parameters.Power.Type == SystemPowerState) {

        //
        // Process system state irps before we send them down.
        //

        SpProcessAdapterSystemState(DeviceObject, Irp);

    } else if(irpStack->Parameters.Power.State.DeviceState == PowerDeviceD0) {

        NTSTATUS status;

        //
        // System power IRP or a power-up request.  These should be
        // processed by the lower driver before being processed by
        // scsiport.
        //

        IoCopyCurrentIrpStackLocationToNext(Irp);

        IoSetCompletionRoutine(Irp,
                               SpSetLowerPowerCompletion,
                               NULL,
                               TRUE,
                               TRUE,
                               TRUE);

        status = PoCallDriver(
                     adapter->CommonExtension.LowerDeviceObject,
                     Irp);
    } else {
        SpProcessAdapterDeviceState(DeviceObject, Irp);
    }

    return;
}


VOID
SpRequestAdapterPowerCompletion(
    IN PDEVICE_OBJECT DeviceObject,
    IN UCHAR MinorFunction,
    IN POWER_STATE PowerState,
    IN PIRP SystemIrp,
    IN PIO_STATUS_BLOCK IoStatus
    )
{
    PADAPTER_EXTENSION adapter = DeviceObject->DeviceExtension;

    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(SystemIrp);
    SYSTEM_POWER_STATE state = irpStack->Parameters.Power.State.SystemState;

    BOOLEAN enable = FALSE;

    NTSTATUS status = IoStatus->Status;

    ASSERT_FDO(DeviceObject);
    ASSERT(IoGetCurrentIrpStackLocation(SystemIrp)->Parameters.Power.Type ==
           SystemPowerState);

    DebugPrint((2, "SpRequestAdapterPowerCompletion: Adapter %#p, "
                   "Irp %#p, State %d, Status %#08lx\n",
                adapter,
                SystemIrp,
                PowerState.DeviceState,
                IoStatus->Status));

    SystemIrp->IoStatus.Status = IoStatus->Status;

    if(NT_SUCCESS(status)) {

        enable = (state == PowerSystemWorking);

        status = SpEnableDisableAdapter(adapter, enable);

        DebugPrint((1, "SpRequestAdapterPowerCompletion: %s adapter call "
                       "returned %#08lx\n",
                    enable ? "Enable" : "Disable",
                    status));

        ASSERT(status != STATUS_PENDING);

        if((NT_SUCCESS(status)) && enable) {

            POWER_STATE setState;

            setState.SystemState = PowerSystemWorking;

            PoSetPowerState(DeviceObject,
                            SystemPowerState,
                            setState);

        }
    }

    IoCopyCurrentIrpStackLocationToNext(SystemIrp);

    PoStartNextPowerIrp(SystemIrp);
    PoCallDriver(adapter->CommonExtension.LowerDeviceObject, SystemIrp);

    return;
}

VOID
SpSetTargetDesiredPowerCompletion(
    IN PDEVICE_OBJECT DeviceObject,
    IN UCHAR MinorFunction,
    IN POWER_STATE PowerState,
    IN PIRP OriginalIrp,
    IN PIO_STATUS_BLOCK IoStatus
    )
{
    PCOMMON_EXTENSION commonExtension = DeviceObject->DeviceExtension;

    ASSERT_PDO(DeviceObject);
    ASSERT(MinorFunction == IRP_MN_SET_POWER);
    ASSERT(NT_SUCCESS(IoStatus->Status));
    ASSERT(PowerState.DeviceState == PowerDeviceD0);
    ASSERT(commonExtension->CurrentDeviceState == PowerDeviceD0);
    ASSERT(commonExtension->DesiredDeviceState == PowerState.DeviceState);
    ASSERT(OriginalIrp == NULL);

    DebugPrint((4, "SpSetTargetDesiredPowerCompletion: power irp completed "
                   "with status %#08lx\n", IoStatus->Status));

    commonExtension->DesiredDeviceState = PowerDeviceUnspecified;

    return;
}


VOID
SpSetTargetDeviceStateLockedCompletion(
    IN PDEVICE_OBJECT DeviceObject,
    IN NTSTATUS Status,
    IN PIRP OriginalIrp
    )
/*++

Routine Description:

    This routine is called after locking the queue for handling of a device
    state.  The proper device state is set and an unlock request is sent
    to the queue.  The OriginalIrp (whatever it may have been) will be
    completed after the unlock has been completed.

Arguments:

    DeviceObject - the device object

    Status - the status of the enable/disable operation

    OriginalIrp - the original power irp.

Return Value:

    none

--*/

{
    PLOGICAL_UNIT_EXTENSION logicalUnit = DeviceObject->DeviceExtension;
    PCOMMON_EXTENSION commonExtension = DeviceObject->DeviceExtension;

    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(OriginalIrp);

    ASSERT(irpStack->Parameters.Power.Type == DevicePowerState);

    DebugPrint((4, "SpSetTargetDeviceStateLockedCompletion: DO %#p Irp %#p "
                   "Status %#08lx\n",
                DeviceObject, OriginalIrp, Status));

    if(NT_SUCCESS(Status)) {

        DEVICE_POWER_STATE newState =
            irpStack->Parameters.Power.State.DeviceState;

        DebugPrint((4, "SpSetTargetDeviceStateLockedCompletion: old device state "
                       "was %d - new device state is %d\n",
                    commonExtension->CurrentDeviceState,
                    irpStack->Parameters.Power.State.DeviceState));

        SpAdjustDisabledBit(logicalUnit,
                            (BOOLEAN) ((newState == PowerDeviceD0) ? TRUE :
                                                                     FALSE));
        commonExtension->CurrentDeviceState = newState;

        SpEnableDisableLogicalUnit(
            logicalUnit,
            TRUE,
            SpSetTargetDeviceStateUnlockedCompletion,
            OriginalIrp);

        return;
    }

    OriginalIrp->IoStatus.Status = Status;
    PoStartNextPowerIrp(OriginalIrp);
    IoCompleteRequest(OriginalIrp, IO_NO_INCREMENT);
    return;
}


VOID
SpSetTargetDeviceStateUnlockedCompletion(
    IN PDEVICE_OBJECT DeviceObject,
    IN NTSTATUS Status,
    IN PIRP OriginalIrp
    )
/*++

Routine Description:

    This routine is called after unlocking the queue following the setting
    of the new device state.  It simply completes the original power request.

Arguments:

    DeviceObject - the device object

    Status - the status of the enable/disable operation

    OriginalIrp - the original power irp.

Return Value:

    none

--*/

{
    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(OriginalIrp);

    ASSERT(irpStack->Parameters.Power.Type == DevicePowerState);

    DebugPrint((4, "SpSetTargetDeviceStateUnlockedCompletion: DO %#p Irp %#p "
                   "Status %#08lx\n",
                DeviceObject, OriginalIrp, Status));

    if(NT_SUCCESS(Status) &&
       (irpStack->Parameters.Power.State.DeviceState == PowerDeviceD0)) {

        //
        // Power up completed - fire notifications.
        //

        PoSetPowerState(DeviceObject,
                        DevicePowerState,
                        irpStack->Parameters.Power.State);
    }

    OriginalIrp->IoStatus.Status = Status;
    PoStartNextPowerIrp(OriginalIrp);
    IoCompleteRequest(OriginalIrp, IO_NO_INCREMENT);
    return;
}


NTSTATUS
SpSetTargetDeviceState(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp,
    IN DEVICE_POWER_STATE DeviceState
    )
/*++

Routine Description:

Arguments:

Return Value:

--*/

{
    PLOGICAL_UNIT_EXTENSION logicalUnit = DeviceObject->DeviceExtension;
    PCOMMON_EXTENSION commonExtension = DeviceObject->DeviceExtension;
    PADAPTER_EXTENSION adapter = logicalUnit->AdapterExtension;

    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);

    BOOLEAN isHibernation;

    NTSTATUS status = STATUS_SUCCESS;

    ASSERT_PDO(DeviceObject);
    ASSERT(irpStack->Parameters.Power.Type == DevicePowerState);

    DebugPrint((4, "SpSetTargetDeviceState: device %#p irp %#p\n",
                DeviceObject, Irp));

    //
    // First check to see if we actually need to touch the queue.
    // If both the current and new state are working or non-working then
    // we don't have a thing to do.
    //

    if(((commonExtension->CurrentDeviceState != PowerDeviceD0) &&
        (DeviceState != PowerDeviceD0)) ||
       (commonExtension->CurrentDeviceState == DeviceState)) {

        DebugPrint((4, "SpSetTargetDeviceState: Transition from D%d to D%d "
                       "requires no extra work\n",
                    commonExtension->CurrentDeviceState,
                    DeviceState));

        commonExtension->CurrentDeviceState = DeviceState;

        return STATUS_SUCCESS;
    }

    //
    // We can't power up the target device if the adapter isn't already
    // powered up.
    //

    if((DeviceState == PowerDeviceD0) &&
       (adapter->CommonExtension.CurrentDeviceState != PowerDeviceD0)) {

        POWER_STATE newAdapterState;

        DebugPrint((1, "SpSetTargetPower: Unable to power up target "
                       "before adapter - requesting adapter %#p "
                       "powerup\n",
                    adapter));

        irpStack->DeviceObject = DeviceObject;

        newAdapterState.DeviceState = PowerDeviceD0;

        return PoRequestPowerIrp(adapter->DeviceObject,
                                 IRP_MN_SET_POWER,
                                 newAdapterState,
                                 SpPowerAdapterForTargetCompletion,
                                 Irp,
                                 NULL);
    }

    //
    // Device power operations use queue locks to ensure
    // synchronization with i/o requests.  However they never leave
    // the logical unit queue permenantly locked - otherwise we'd be
    // unable to power-up the device when i/o came in.  Lock the queue
    // so we can set the power state.
    //

    IoMarkIrpPending(Irp);

    SpEnableDisableLogicalUnit(
        logicalUnit,
        FALSE,
        SpSetTargetDeviceStateLockedCompletion,
        Irp);

    return STATUS_PENDING;
}



NTSTATUS
SpSetTargetSystemState(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp,
    IN SYSTEM_POWER_STATE SystemState
    )
/*++

Routine Description:

Arguments:

Return Value:

--*/

{
    PLOGICAL_UNIT_EXTENSION logicalUnit = DeviceObject->DeviceExtension;
    PCOMMON_EXTENSION commonExtension = DeviceObject->DeviceExtension;

    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);

    POWER_STATE newDeviceState;

    NTSTATUS status = STATUS_SUCCESS;

    ASSERT_PDO(DeviceObject);
    ASSERT(irpStack->Parameters.Power.Type == SystemPowerState);

    DebugPrint((2, "SpSetTargetSystemState: device %#p irp %#p\n",
                DeviceObject, Irp));

    //
    // First check to see if we actually need to touch the queue.
    // If both the current and new state are working or non-working then
    // we don't have a thing to do.
    //

    if(((commonExtension->CurrentSystemState != PowerSystemWorking) &&
        (SystemState != PowerSystemWorking)) ||
       (commonExtension->CurrentSystemState == SystemState)) {

        DebugPrint((2, "SpSetTargetPower: Transition from S%d to S%d "
                       "requires no extra work\n",
                    commonExtension->CurrentSystemState,
                    SystemState));

        commonExtension->CurrentSystemState = SystemState;

        return STATUS_SUCCESS;
    }

    //
    // Disable the logical unit so we can set it's power state safely.
    //

    IoMarkIrpPending(Irp);

    SpEnableDisableLogicalUnit(
        logicalUnit,
        FALSE,
        SpSetTargetSystemStateLockedCompletion,
        Irp);

    return STATUS_PENDING;
}


VOID
SpSetTargetSystemStateLockedCompletion(
    IN PDEVICE_OBJECT DeviceObject,
    IN NTSTATUS Status,
    IN PIRP PowerIrp
    )
/*++

Routine Description:

    This routine is called after the logical unit has been locked and is
    responsible for setting the new system state of the logical unit.  If
    the logical unit currently has a desired power state (other than
    unspecified) this routine will request that the device be put into that
    power state after the logical unit is re-enabled.

    Once the work is done this routine will request that the logical unit
    be re-enabled.  After that the power irp will be completed.

Arguments:

    DeviceObject - the device object which has been disabled

    Status       - the status of the disable request

    PowerIrp     - the power irp we are processing

Return Value:

    none

--*/

{
    PLOGICAL_UNIT_EXTENSION logicalUnit = DeviceObject->DeviceExtension;
    PCOMMON_EXTENSION commonExtension = DeviceObject->DeviceExtension;

    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(PowerIrp);

    POWER_STATE_TYPE type = irpStack->Parameters.Power.Type;
    SYSTEM_POWER_STATE state = irpStack->Parameters.Power.State.SystemState;

    POWER_STATE powerState;

    ASSERT_PDO(DeviceObject);
    ASSERT(type == SystemPowerState);
    ASSERT(PowerIrp != NULL);

    DebugPrint((2, "SpSetTargetSystemStateLockedCompletion: DevObj %#p, "
                   "Status %#08lx PowerIrp %#p\n",
                DeviceObject, Status, PowerIrp));

    //
    // If the enable/disable failed then the power operation is obviously
    // unsuccessful.  Fail the power irp.
    //

    if(!NT_SUCCESS(Status)) {

        ASSERT(FALSE);

        PowerIrp->IoStatus.Status = Status;
        PoStartNextPowerIrp(PowerIrp);
        IoCompleteRequest(PowerIrp, IO_NO_INCREMENT);
        return;
    }

    SpAdjustDisabledBit(
        logicalUnit,
        (BOOLEAN) ((state == PowerSystemWorking) ? TRUE : FALSE));

    commonExtension->CurrentSystemState = state;

    DebugPrint((2, "SpSetTargetSystemStateLockedCompletion: new system state %d "
                   "set - desired device state is %d\n",
                state,
                commonExtension->DesiredDeviceState));

    //
    // Re-enable the logical unit.  We'll put it into the correct D state
    // after it's been turned back on.
    //

    SpEnableDisableLogicalUnit(logicalUnit,
                               TRUE,
                               SpSetTargetSystemStateUnlockedCompletion,
                               PowerIrp);

    return;
}


VOID
SpSetTargetSystemStateUnlockedCompletion(
    IN PDEVICE_OBJECT DeviceObject,
    IN NTSTATUS Status,
    IN PIRP PowerIrp
    )
/*++

Routine Description:

    This routine is called after the system state of the logical unit has been
    set and it has been re-enabled.  If the device has a desired power state
    or if it needs to be turned off (or on) for hibernation the power irp
    will be sent from here.

Arguments:

    DeviceObject - the logical unit which has been unlocked

    Status - the status of the unlock request

    PowerIrp - the original power irp.

Return Value:

    none

--*/
{
    PLOGICAL_UNIT_EXTENSION logicalUnit = DeviceObject->DeviceExtension;
    PCOMMON_EXTENSION commonExtension = DeviceObject->DeviceExtension;

    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(PowerIrp);

    POWER_STATE_TYPE type = irpStack->Parameters.Power.Type;
    SYSTEM_POWER_STATE state = irpStack->Parameters.Power.State.SystemState;

    POWER_STATE powerState;

    ASSERT_PDO(DeviceObject);
    ASSERT(type == SystemPowerState);
    ASSERT(PowerIrp != NULL);

    DebugPrint((2, "SpSetTargetSystemStateUnlockedCompletion: DevObj %#p, "
                   "Status %#08lx PowerIrp %#p\n",
                DeviceObject, Status, PowerIrp));

    if(!NT_SUCCESS(Status)) {

        //
        // Oh dear - this device couldn't be re-enabled.  The logical unit is
        // useless until this can be done.
        //

        //
        // CODEWORK - figure out a way to deal with this case.
        //

        ASSERT(FALSE);
        PowerIrp->IoStatus.Status = Status;
        PoStartNextPowerIrp(PowerIrp);
        IoCompleteRequest(PowerIrp, IO_NO_INCREMENT);
        return;
    }

    if(state == PowerSystemWorking) {

        //
        // We're waking up the system.  Check to see if the device needs
        // to be powered immediately as well.
        //

        //
        // Power up - fire notifications.
        //

        powerState.SystemState = state;
        PoSetPowerState(DeviceObject,
                        SystemPowerState,
                        powerState);

        if(commonExtension->DesiredDeviceState != PowerDeviceUnspecified) {

            //
            // Request a power up of the target device now.  We'll complete
            // the system irp immediately without waiting for the device irp
            // to finish.
            //

            powerState.DeviceState = commonExtension->DesiredDeviceState;

            DebugPrint((1, "SpSetTargetSystemStateUnlockedCompletion: Target has "
                           "desired device state of %d - issuing irp to "
                           "request transition\n",
                        powerState.DeviceState));

            Status = PoRequestPowerIrp(DeviceObject,
                                       IRP_MN_SET_POWER,
                                       powerState,
                                       SpSetTargetDesiredPowerCompletion,
                                       NULL,
                                       NULL);

            ASSERT(Status == STATUS_PENDING);

        }

        if(Status != STATUS_PENDING) {
            PowerIrp->IoStatus.Status = Status;
        } else {
            PowerIrp->IoStatus.Status = STATUS_SUCCESS;
        }

        PoStartNextPowerIrp(PowerIrp);
        IoCompleteRequest(PowerIrp, IO_NO_INCREMENT);

    } else {

        //
        // We're going to put the device into a D state based on the current
        // S state.
        //

        DebugPrint((2, "SpSetTargetSystemStateUnlockedCompletion: power down "
                       "target for non-working system state "
                       "transition\n"));

        powerState.DeviceState = PowerDeviceD3;

        //
        // Request the appropriate D irp.  We'll block the S irp until the
        // D transition has been completed.
        //

        Status = PoRequestPowerIrp(
                    DeviceObject,
                    IRP_MN_SET_POWER,
                    powerState,
                    SpSetTargetDeviceStateForSystemStateCompletion,
                    PowerIrp,
                    NULL);

        if(!NT_SUCCESS(Status)) {

            //
            // STATUS_PENDING is still successful.
            //

            PowerIrp->IoStatus.Status = Status;
            PoStartNextPowerIrp(PowerIrp);
            IoCompleteRequest(PowerIrp, IO_NO_INCREMENT);
        }
    }
    return;
}


VOID
SpSetTargetDeviceStateForSystemStateCompletion(
    IN PDEVICE_OBJECT DeviceObject,
    IN UCHAR MinorFunction,
    IN POWER_STATE PowerState,
    IN PIRP OriginalIrp,
    IN PIO_STATUS_BLOCK IoStatus
    )
{
    PIO_STACK_LOCATION irpStack;

    irpStack = IoGetCurrentIrpStackLocation(OriginalIrp);

    ASSERT_PDO(DeviceObject);

    ASSERT(irpStack->Parameters.Power.Type == SystemPowerState);
    ASSERT(irpStack->Parameters.Power.State.SystemState != PowerSystemWorking);

    DebugPrint((2, "SpSetTargetDeviceStateForSystemCompletion: DevObj %#p, "
                   "Irp %#p, Status %#08lx\n",
                DeviceObject, OriginalIrp, IoStatus));

    OriginalIrp->IoStatus.Status = IoStatus->Status;
    PoStartNextPowerIrp(OriginalIrp);
    IoCompleteRequest(OriginalIrp, IO_NO_INCREMENT);

    return;
}


VOID
SpRequestValidPowerStateCompletion (
    IN PDEVICE_OBJECT DeviceObject,
    IN UCHAR MinorFunction,
    IN POWER_STATE PowerState,
    IN PLOGICAL_UNIT_EXTENSION LogicalUnit,
    IN PIO_STATUS_BLOCK IoStatus
    )
{

    //
    // re-enable the logical unit.  Don't bother with a completion routine
    // because there's nothing to do.
    //

    ASSERT(NT_SUCCESS(IoStatus->Status));
    SpEnableDisableLogicalUnit(LogicalUnit, TRUE, NULL, NULL);
    return;
}


NTSTATUS
SpRequestValidAdapterPowerStateSynchronous(
    IN PADAPTER_EXTENSION Adapter
    )
{
    PCOMMON_EXTENSION commonExtension = &(Adapter->CommonExtension);
    NTSTATUS status = STATUS_SUCCESS;

    //
    // Interlock with other calls to this routine - there's no reason to have
    // several D0 irps in flight at any given time.
    //

    ExAcquireFastMutex(&(Adapter->PowerMutex));

    try {
        //
        // Check to see if we're already in a working state.  If so we can just
        // continue.
        //

        if((commonExtension->CurrentSystemState == PowerSystemWorking) &&
           (commonExtension->CurrentDeviceState == PowerDeviceD0)) {
            leave;
        }

        //
        // First check the system state.  If the device is in a non-working system
        // state then we'll need to block waiting for the system to wake up.
        //

        if(commonExtension->CurrentSystemState != PowerSystemWorking) {

            //
            // If we're not in a system working state then fail the attempt 
            // to set a new device state.  The caller should retry when the 
            // system is powered on.  Ideally we won't be getting requests 
            // which cause us to try and power up while the system is 
            // suspended.
            //

            status = STATUS_UNSUCCESSFUL;
            leave;
        }

        //
        // Request a power change request.
        //

        {
            POWER_STATE newAdapterState;
            SP_SIGNAL_POWER_COMPLETION_CONTEXT context;

            DebugPrint((1, "SpRequestValidAdapterPowerState: Requesting D0 power "
                           "irp for adapter %p\n", Adapter));

            newAdapterState.DeviceState = PowerDeviceD0;

            KeInitializeEvent(&(context.Event), SynchronizationEvent, FALSE);

            status = PoRequestPowerIrp(Adapter->DeviceObject,
                                       IRP_MN_SET_POWER,
                                       newAdapterState,
                                       SpSignalPowerCompletion,
                                       &context,
                                       NULL);

            if(status == STATUS_PENDING) {
                KeWaitForSingleObject(&(context.Event),
                                      KernelMode,
                                      Executive,
                                      FALSE,
                                      NULL);
            }

            status = context.Status;
            leave;
        }
    } finally {
        ExReleaseFastMutex(&(Adapter->PowerMutex));
    }

    return status;
}


VOID
SpSignalPowerCompletion(
    IN PDEVICE_OBJECT DeviceObject,
    IN UCHAR MinorFunction,
    IN POWER_STATE PowerState,
    IN PSP_SIGNAL_POWER_COMPLETION_CONTEXT Context,
    IN PIO_STATUS_BLOCK IoStatus
    )
{
    Context->Status = IoStatus->Status;
    KeSetEvent(&(Context->Event), IO_NO_INCREMENT, FALSE);
    return;
}