You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
734 lines
20 KiB
734 lines
20 KiB
/*++
|
|
|
|
Copyright (c) 1990-2000 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
power.c
|
|
|
|
Abstract:
|
|
|
|
This file contains the support for power management
|
|
|
|
Environment:
|
|
|
|
Kernel Mode Driver.
|
|
|
|
Notes:
|
|
|
|
Nothing in here or in routines referenced from here should be pageable.
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "busp.h"
|
|
#include "pnpisa.h"
|
|
#include <initguid.h>
|
|
#include <wdmguid.h>
|
|
#include "halpnpp.h"
|
|
|
|
NTSTATUS
|
|
PiDispatchPower(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN OUT PIRP Irp
|
|
);
|
|
|
|
NTSTATUS
|
|
PiDispatchPowerFdo(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN OUT PIRP Irp
|
|
);
|
|
|
|
NTSTATUS
|
|
PiDispatchPowerPdo(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN OUT PIRP Irp
|
|
);
|
|
|
|
NTSTATUS
|
|
PipPassPowerIrpFdo(
|
|
PDEVICE_OBJECT DeviceObject,
|
|
PIRP Irp
|
|
);
|
|
|
|
NTSTATUS
|
|
PipPowerIrpNotSupportedPdo(
|
|
PDEVICE_OBJECT DeviceObject,
|
|
PIRP Irp
|
|
);
|
|
|
|
NTSTATUS
|
|
PipQueryPowerStatePdo (
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN OUT PIRP Irp
|
|
);
|
|
|
|
NTSTATUS
|
|
PipSetPowerStatePdo (
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN OUT PIRP Irp
|
|
);
|
|
|
|
NTSTATUS
|
|
PipSetQueryPowerStateFdo (
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN OUT PIRP Irp
|
|
);
|
|
|
|
NTSTATUS
|
|
PipRequestPowerUpCompletionRoutinePdo (
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN UCHAR MinorFunction,
|
|
IN POWER_STATE PowerState,
|
|
IN PVOID Context,
|
|
IN PIO_STATUS_BLOCK IoStatus
|
|
);
|
|
|
|
NTSTATUS
|
|
FdoContingentPowerCompletionRoutine (
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN UCHAR MinorFunction,
|
|
IN POWER_STATE PowerState,
|
|
IN PVOID Context,
|
|
IN PIO_STATUS_BLOCK IoStatus
|
|
);
|
|
|
|
const PUCHAR SystemPowerStateStrings[] = {
|
|
"Unspecified",
|
|
"Working",
|
|
"Sleeping1",
|
|
"Sleeping2",
|
|
"Sleeping3",
|
|
"Hibernate",
|
|
"Shutdown"
|
|
};
|
|
|
|
const PUCHAR DevicePowerStateStrings[] = {
|
|
"Unspecified",
|
|
"D0",
|
|
"D1",
|
|
"D2",
|
|
"D3"
|
|
};
|
|
|
|
const PPI_DISPATCH PiPowerDispatchTableFdo[] =
|
|
{
|
|
PipPassPowerIrpFdo,
|
|
PipPassPowerIrpFdo,
|
|
PipSetQueryPowerStateFdo,
|
|
PipSetQueryPowerStateFdo,
|
|
};
|
|
|
|
#if ISOLATE_CARDS
|
|
const PPI_DISPATCH PiPowerDispatchTablePdo[] =
|
|
{
|
|
PipPowerIrpNotSupportedPdo,
|
|
PipPowerIrpNotSupportedPdo,
|
|
PipSetPowerStatePdo,
|
|
PipQueryPowerStatePdo,
|
|
};
|
|
#endif
|
|
|
|
|
|
VOID
|
|
PipDumpPowerIrpLocation(
|
|
PIO_STACK_LOCATION IrpSp
|
|
)
|
|
{
|
|
DebugPrintContinue((
|
|
DEBUG_POWER,
|
|
"%s %d\n",
|
|
(IrpSp->Parameters.Power.Type == DevicePowerState) ?
|
|
DevicePowerStateStrings[IrpSp->Parameters.Power.State.DeviceState] : SystemPowerStateStrings[IrpSp->Parameters.Power.State.SystemState],
|
|
IrpSp->Parameters.Power.ShutdownType));
|
|
}
|
|
|
|
NTSTATUS
|
|
PiDispatchPower(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN OUT PIRP Irp
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine handles all the IRP_MJ_POWER IRPs.
|
|
|
|
Arguments:
|
|
|
|
DeviceObject - Pointer to the device object for which this IRP applies.
|
|
|
|
Irp - Pointer to the IRP_MJ_PNP_POWER IRP to dispatch.
|
|
|
|
Return Value:
|
|
|
|
NT status.
|
|
|
|
--*/
|
|
{
|
|
PIO_STACK_LOCATION irpSp;
|
|
NTSTATUS status = STATUS_SUCCESS;
|
|
PPI_BUS_EXTENSION busExtension;
|
|
|
|
//
|
|
// Make sure this is a valid device object.
|
|
//
|
|
|
|
busExtension = DeviceObject->DeviceExtension;
|
|
|
|
#if !ISOLATE_CARDS
|
|
return PiDispatchPowerFdo(DeviceObject, Irp);
|
|
#else
|
|
if (busExtension->Flags & DF_BUS) {
|
|
return PiDispatchPowerFdo(DeviceObject, Irp);
|
|
} else {
|
|
return PiDispatchPowerPdo(DeviceObject, Irp);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
#if ISOLATE_CARDS
|
|
|
|
NTSTATUS
|
|
PipPowerIrpNotSupportedPdo(
|
|
PDEVICE_OBJECT DeviceObject,
|
|
PIRP Irp
|
|
)
|
|
{
|
|
PIO_STACK_LOCATION irpSp;
|
|
|
|
irpSp = IoGetCurrentIrpStackLocation(Irp);
|
|
PoStartNextPowerIrp(Irp);
|
|
|
|
DebugPrint((DEBUG_POWER,
|
|
"Completing unsupported power irp %x for PDO %x\n",
|
|
irpSp->MinorFunction,
|
|
DeviceObject
|
|
));
|
|
|
|
PipCompleteRequest(Irp, STATUS_NOT_SUPPORTED, NULL);
|
|
return STATUS_NOT_SUPPORTED;
|
|
}
|
|
|
|
NTSTATUS
|
|
PiDispatchPowerPdo(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN OUT PIRP Irp
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine handles all the IRP_MJ_POWER IRPs.
|
|
|
|
Arguments:
|
|
|
|
DeviceObject - Pointer to the device object for which this IRP applies.
|
|
|
|
Irp - Pointer to the IRP_MJ_PNP_POWER IRP to dispatch.
|
|
|
|
Return Value:
|
|
|
|
NT status.
|
|
|
|
--*/
|
|
{
|
|
PIO_STACK_LOCATION irpSp;
|
|
NTSTATUS status = STATUS_SUCCESS;
|
|
PDEVICE_INFORMATION deviceExtension;
|
|
|
|
//
|
|
// Make sure this is a valid device object.
|
|
//
|
|
|
|
deviceExtension = DeviceObject->DeviceExtension;
|
|
if (deviceExtension->Flags & DF_DELETED) {
|
|
status = STATUS_NO_SUCH_DEVICE;
|
|
PoStartNextPowerIrp(Irp);
|
|
PipCompleteRequest(Irp, status, NULL);
|
|
return status;
|
|
}
|
|
|
|
//
|
|
// Get a pointer to our stack location and take appropriate action based
|
|
// on the minor function.
|
|
//
|
|
|
|
irpSp = IoGetCurrentIrpStackLocation(Irp);
|
|
if (irpSp->MinorFunction > IRP_MN_PO_MAXIMUM_FUNCTION) {
|
|
status = PipPowerIrpNotSupportedPdo(DeviceObject, Irp);
|
|
} else {
|
|
status = PiPowerDispatchTablePdo[irpSp->MinorFunction](DeviceObject, Irp);
|
|
}
|
|
return status;
|
|
}
|
|
|
|
NTSTATUS
|
|
PipQueryPowerStatePdo (
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN OUT PIRP Irp
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine handles the Query_Power irp for the PDO .
|
|
|
|
Arguments:
|
|
|
|
DeviceObject - Pointer to the device object for which this IRP applies.
|
|
|
|
Irp - Pointer to the IRP_MJ_PNP_POWER IRP to dispatch.
|
|
|
|
Return Value:
|
|
|
|
NT status.
|
|
|
|
--*/
|
|
{
|
|
|
|
DEVICE_POWER_STATE targetState;
|
|
NTSTATUS status;
|
|
PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation (Irp);
|
|
|
|
DebugPrint((DEBUG_POWER, "QueryPower on PDO %x: ", DeviceObject));
|
|
PipDumpPowerIrpLocation(irpSp);
|
|
|
|
if (irpSp->Parameters.Power.Type == DevicePowerState) {
|
|
targetState=irpSp->Parameters.Power.State.DeviceState;
|
|
ASSERT ((targetState == PowerDeviceD0) ||
|
|
(targetState == PowerDeviceD3));
|
|
|
|
if ((targetState == PowerDeviceD0) ||
|
|
(targetState == PowerDeviceD3) ) {
|
|
|
|
status=Irp->IoStatus.Status = STATUS_SUCCESS;
|
|
} else {
|
|
status=Irp->IoStatus.Status = STATUS_INVALID_DEVICE_REQUEST;
|
|
}
|
|
} else {
|
|
//
|
|
// Just succeed S irps
|
|
//
|
|
status=Irp->IoStatus.Status = STATUS_SUCCESS;
|
|
}
|
|
|
|
PoStartNextPowerIrp (Irp);
|
|
IoCompleteRequest(Irp, IO_NO_INCREMENT);
|
|
|
|
DebugPrint((DEBUG_POWER, "QueryPower on PDO %x: returned %x\n", DeviceObject, status));
|
|
return status;
|
|
|
|
}
|
|
|
|
NTSTATUS
|
|
PipSetPowerStatePdo (
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN OUT PIRP Irp
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine handles SET_POWER_IRP for the IsaPnp device (i.e. PDO)
|
|
It sets the devices power state to the power state type as indicated. In
|
|
the case of a device state change which is transitioning a device out of
|
|
the PowerDevice0 state, we need call PoSetPowerState prior to leaving the
|
|
PowerDeviceD0. In the case if a device state change which is transitioning
|
|
a device into the PowerDeviceD0 state, we call PoSetPowerState after the
|
|
device is successfully put into the PowerDeviceD0 state.
|
|
|
|
Arguments:
|
|
|
|
DeviceObject - Pointer to the device object for which this IRP applies.
|
|
|
|
Irp - Pointer to the IRP_MJ_PNP_POWER IRP to dispatch.
|
|
|
|
Return Value:
|
|
|
|
NT status.
|
|
|
|
--*/
|
|
{
|
|
PDEVICE_INFORMATION pdoExtension;
|
|
NTSTATUS status;
|
|
PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation (Irp);
|
|
DEVICE_POWER_STATE targetState=irpSp->Parameters.Power.State.DeviceState;
|
|
POWER_STATE newState;
|
|
|
|
DebugPrint((DEBUG_POWER, "SetPower on PDO %x: ", DeviceObject));
|
|
PipDumpPowerIrpLocation(irpSp);
|
|
|
|
pdoExtension = PipReferenceDeviceInformation(DeviceObject, FALSE);
|
|
if (pdoExtension == NULL) {
|
|
status = STATUS_NO_SUCH_DEVICE;
|
|
} else if (pdoExtension->Flags & DF_NOT_FUNCTIONING) {
|
|
status = STATUS_NO_SUCH_DEVICE;
|
|
PipDereferenceDeviceInformation(pdoExtension, FALSE);
|
|
} else {
|
|
if (irpSp->Parameters.Power.Type == DevicePowerState) {
|
|
|
|
// * On transition from D0 to D0, we do nothing.
|
|
//
|
|
// * On transition to D3, we'll deactivate the card.
|
|
//
|
|
// * On transition from D3->D0 we'll refresh the resources
|
|
// and activate the card.
|
|
//
|
|
if ((targetState == PowerDeviceD0) &&
|
|
(pdoExtension->DevicePowerState == PowerDeviceD0)) {
|
|
// Do not try to power device back up if this is a D0->D0
|
|
// transition. The device is already powered.
|
|
DebugPrint((DEBUG_POWER,
|
|
"PDO %x D0 -> D0 Transition ignored\n", DeviceObject));
|
|
} else if ((pdoExtension->DevicePowerState == PowerDeviceD0) &&
|
|
pdoExtension->CrashDump) {
|
|
DebugPrint((DEBUG_POWER,
|
|
"PDO %x D0 -> ?? Transition ignored, crash file\n",
|
|
DeviceObject));
|
|
} else if (targetState > PowerDeviceD0) {
|
|
targetState = PowerDeviceD3;
|
|
DebugPrint((DEBUG_POWER,
|
|
"Powering down PDO %x CSN %d/LDN %d\n",
|
|
DeviceObject,
|
|
pdoExtension->CardInformation->CardSelectNumber,
|
|
pdoExtension->LogicalDeviceNumber
|
|
));
|
|
if ((pdoExtension->Flags & (DF_ACTIVATED | DF_READ_DATA_PORT)) == DF_ACTIVATED) {
|
|
if (!(PipRDPNode->Flags & (DF_STOPPED|DF_REMOVED|DF_SURPRISE_REMOVED))) {
|
|
PipWakeAndSelectDevice(
|
|
pdoExtension->CardInformation->CardSelectNumber,
|
|
pdoExtension->LogicalDeviceNumber);
|
|
PipDeactivateDevice();
|
|
PipWaitForKey();
|
|
} else {
|
|
targetState = PowerDeviceD0;
|
|
}
|
|
}
|
|
} else {
|
|
if ((pdoExtension->Flags & (DF_ACTIVATED | DF_READ_DATA_PORT)) == DF_ACTIVATED) {
|
|
DebugPrint((DEBUG_POWER,
|
|
"Powering up PDO %x CSN %d/LDN %d\n",
|
|
DeviceObject,
|
|
pdoExtension->CardInformation->CardSelectNumber,
|
|
pdoExtension->LogicalDeviceNumber
|
|
));
|
|
if (!(PipRDPNode->Flags & (DF_STOPPED|DF_REMOVED|DF_SURPRISE_REMOVED))) {
|
|
PipWakeAndSelectDevice(
|
|
pdoExtension->CardInformation->CardSelectNumber,
|
|
pdoExtension->LogicalDeviceNumber);
|
|
status = PipSetDeviceResources(
|
|
pdoExtension,
|
|
pdoExtension->AllocatedResources);
|
|
if (NT_SUCCESS(status)) {
|
|
PipActivateDevice();
|
|
}
|
|
PipWaitForKey();
|
|
} else {
|
|
targetState = PowerDeviceD3;
|
|
}
|
|
|
|
}
|
|
}
|
|
newState.DeviceState = targetState;
|
|
PoSetPowerState(DeviceObject, DevicePowerState, newState);
|
|
pdoExtension->DevicePowerState = targetState;
|
|
}
|
|
status = STATUS_SUCCESS;
|
|
PipDereferenceDeviceInformation(pdoExtension, FALSE);
|
|
}
|
|
|
|
Irp->IoStatus.Status = status;
|
|
|
|
PoStartNextPowerIrp (Irp);
|
|
IoCompleteRequest(Irp, IO_NO_INCREMENT);
|
|
|
|
DebugPrint((DEBUG_POWER, "SetPower on PDO %x: returned %x\n", DeviceObject, status));
|
|
return status;
|
|
}
|
|
#endif
|
|
|
|
NTSTATUS
|
|
PipPassPowerIrpFdo(
|
|
PDEVICE_OBJECT DeviceObject,
|
|
PIRP Irp
|
|
)
|
|
|
|
/*++
|
|
|
|
Description:
|
|
|
|
This function pass the power Irp to lower level driver.
|
|
|
|
Arguments:
|
|
|
|
DeviceObject - the Fdo
|
|
Irp - the request
|
|
|
|
Return:
|
|
|
|
STATUS_PENDING
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS status;
|
|
PPI_BUS_EXTENSION busExtension;
|
|
PIO_STACK_LOCATION irpSp;
|
|
|
|
PoStartNextPowerIrp(Irp);
|
|
|
|
irpSp = IoGetCurrentIrpStackLocation(Irp);
|
|
busExtension = (PPI_BUS_EXTENSION) DeviceObject->DeviceExtension;
|
|
|
|
DebugPrint((DEBUG_POWER,
|
|
"Passing down power irp %x for FDO %x to %x\n",
|
|
irpSp->MinorFunction,
|
|
DeviceObject,
|
|
busExtension->AttachedDevice
|
|
));
|
|
|
|
IoSkipCurrentIrpStackLocation(Irp);
|
|
status = PoCallDriver(busExtension->AttachedDevice, Irp);
|
|
DebugPrint((DEBUG_POWER,
|
|
"Passed down power irp for FDO: returned %x\n",
|
|
status));
|
|
return status;
|
|
}
|
|
|
|
NTSTATUS
|
|
PiDispatchPowerFdo(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN OUT PIRP Irp
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine handles all the IRP_MJ_POWER IRPs.
|
|
|
|
Arguments:
|
|
|
|
DeviceObject - Pointer to the device object for which this IRP applies.
|
|
|
|
Irp - Pointer to the IRP_MJ_PNP_POWER IRP to dispatch.
|
|
|
|
Return Value:
|
|
|
|
NT status.
|
|
|
|
--*/
|
|
{
|
|
PIO_STACK_LOCATION irpSp;
|
|
NTSTATUS status = STATUS_SUCCESS;
|
|
PPI_BUS_EXTENSION busExtension;
|
|
|
|
//
|
|
// Make sure this is a valid device object.
|
|
//
|
|
|
|
busExtension = DeviceObject->DeviceExtension;
|
|
if (busExtension->AttachedDevice == NULL) {
|
|
status = STATUS_NO_SUCH_DEVICE;
|
|
PoStartNextPowerIrp(Irp);
|
|
PipCompleteRequest(Irp, status, NULL);
|
|
return status;
|
|
}
|
|
|
|
//
|
|
// Get a pointer to our stack location and take appropriate action based
|
|
// on the minor function.
|
|
//
|
|
|
|
irpSp = IoGetCurrentIrpStackLocation(Irp);
|
|
if (irpSp->MinorFunction > IRP_MN_PO_MAXIMUM_FUNCTION) {
|
|
return PipPassPowerIrpFdo(DeviceObject, Irp);
|
|
} else {
|
|
status = PiPowerDispatchTableFdo[irpSp->MinorFunction](DeviceObject, Irp);
|
|
}
|
|
return status;
|
|
}
|
|
|
|
NTSTATUS
|
|
PipSetQueryPowerStateFdo (
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN OUT PIRP Irp
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine handles QUERY_POWER or SET_POWER IRPs for the IsaPnp bus device
|
|
(i.e. FDO). It sets the devices power state for the power state type as indicated.
|
|
In the case of a device state change which is transitioning a device out of
|
|
the PowerDevice0 state, we need call PoSetPowerState prior to leaving the
|
|
PowerDeviceD0. In the case if a device state change which is transitioning
|
|
a device into the PowerDeviceD0 state, we call PoSetPowerState after the
|
|
device is successfully put into the PowerDeviceD0 state.
|
|
|
|
Arguments:
|
|
|
|
DeviceObject - Pointer to the device object for which this IRP applies.
|
|
|
|
Irp - Pointer to the IRP_MJ_PNP_POWER IRP to dispatch.
|
|
|
|
Return Value:
|
|
|
|
NT status.
|
|
|
|
--*/
|
|
{
|
|
PPI_BUS_EXTENSION fdoExtension;
|
|
PIO_STACK_LOCATION irpSp;
|
|
NTSTATUS status;
|
|
|
|
fdoExtension = DeviceObject->DeviceExtension;
|
|
|
|
irpSp = IoGetCurrentIrpStackLocation (Irp);
|
|
|
|
DebugPrint((DEBUG_POWER, "%s on FDO %x: ",
|
|
(irpSp->MinorFunction == IRP_MN_SET_POWER) ? "SetPower" :
|
|
"QueryPower", DeviceObject));
|
|
PipDumpPowerIrpLocation(irpSp);
|
|
|
|
if (irpSp->Parameters.Power.Type == SystemPowerState) {
|
|
POWER_STATE powerState;
|
|
|
|
switch (irpSp->Parameters.Power.State.SystemState) {
|
|
case PowerSystemWorking:
|
|
|
|
//
|
|
// Make sure the bus is on for these system states
|
|
//
|
|
|
|
powerState.DeviceState = PowerDeviceD0;
|
|
break;
|
|
|
|
case PowerSystemSleeping1:
|
|
case PowerSystemHibernate:
|
|
case PowerSystemShutdown:
|
|
case PowerSystemSleeping2:
|
|
case PowerSystemSleeping3:
|
|
|
|
//
|
|
// Going to sleep ... Power down
|
|
//
|
|
|
|
powerState.DeviceState = PowerDeviceD3;
|
|
break;
|
|
|
|
default:
|
|
|
|
//
|
|
// Unknown request - be safe power up
|
|
//
|
|
|
|
ASSERT (TRUE == FALSE);
|
|
powerState.DeviceState = PowerDeviceD0;
|
|
break;
|
|
}
|
|
|
|
DebugPrint((DEBUG_POWER, "request power irp to busdev %x, pending\n",
|
|
fdoExtension->FunctionalBusDevice));
|
|
IoMarkIrpPending(Irp);
|
|
PoRequestPowerIrp (
|
|
fdoExtension->FunctionalBusDevice,
|
|
irpSp->MinorFunction,
|
|
powerState,
|
|
FdoContingentPowerCompletionRoutine,
|
|
Irp,
|
|
NULL
|
|
);
|
|
|
|
return STATUS_PENDING;
|
|
|
|
}
|
|
|
|
status = PipPassPowerIrpFdo(DeviceObject, Irp);
|
|
DebugPrint((DEBUG_POWER, "SetPower(device) on FDO %x: returned %x\n", DeviceObject, status));
|
|
return status;
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
FdoContingentPowerCompletionRoutine (
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN UCHAR MinorFunction,
|
|
IN POWER_STATE PowerState,
|
|
IN PVOID Context,
|
|
IN PIO_STATUS_BLOCK IoStatus
|
|
)
|
|
{
|
|
PIRP irp = Context;
|
|
PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation (irp);
|
|
|
|
DebugPrint((DEBUG_POWER, "requested power irp completed to %x\n", DeviceObject));
|
|
|
|
//
|
|
// Propagate the status of the transient power IRP
|
|
//
|
|
irp->IoStatus.Status = IoStatus->Status;
|
|
|
|
if (NT_SUCCESS(IoStatus->Status)) {
|
|
|
|
PPI_BUS_EXTENSION fdoExtension;
|
|
|
|
fdoExtension = DeviceObject->DeviceExtension;
|
|
|
|
PoStartNextPowerIrp (irp);
|
|
//
|
|
// changing device power state call PoSetPowerState now.
|
|
//
|
|
|
|
if (MinorFunction == IRP_MN_SET_POWER) {
|
|
SYSTEM_POWER_STATE OldSystemPowerState = fdoExtension->SystemPowerState;
|
|
|
|
fdoExtension->SystemPowerState = irpSp->Parameters.Power.State.SystemState;
|
|
fdoExtension->DevicePowerState = PowerState.DeviceState;
|
|
PoSetPowerState (
|
|
DeviceObject,
|
|
DevicePowerState,
|
|
PowerState
|
|
);
|
|
DebugPrint((DEBUG_POWER, "New FDO %x powerstate system %s/%s\n",
|
|
DeviceObject,
|
|
SystemPowerStateStrings[fdoExtension->SystemPowerState],
|
|
DevicePowerStateStrings[fdoExtension->DevicePowerState]));
|
|
#if ISOLATE_CARDS
|
|
|
|
if ((OldSystemPowerState == PowerSystemHibernate) ||
|
|
(OldSystemPowerState == PowerSystemSleeping3) ) {
|
|
BOOLEAN needsRescan;
|
|
|
|
PipReportStateChange(PiSWaitForKey);
|
|
if ((fdoExtension->BusNumber == 0) && PipRDPNode &&
|
|
(PipRDPNode->Flags & (DF_ACTIVATED|DF_PROCESSING_RDP|DF_QUERY_STOPPED)) == DF_ACTIVATED) {
|
|
needsRescan = PipMinimalCheckBus(fdoExtension);
|
|
if (needsRescan) {
|
|
PipRDPNode->Flags |= DF_NEEDS_RESCAN;
|
|
IoInvalidateDeviceRelations(
|
|
fdoExtension->PhysicalBusDevice,
|
|
BusRelations);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
IoSkipCurrentIrpStackLocation (irp);
|
|
PoCallDriver (fdoExtension->AttachedDevice, irp);
|
|
|
|
} else {
|
|
|
|
PoStartNextPowerIrp (irp);
|
|
IoCompleteRequest(irp, IO_NO_INCREMENT);
|
|
}
|
|
|
|
return STATUS_SUCCESS;
|
|
} // FdoContingentPowerCompletionRoutine
|
|
|