Source code of Windows XP (NT5)
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.
 
 
 
 
 
 

897 lines
21 KiB

/*++
Copyright (c) 1997 Microsoft Corporation
Module Name:
power.c
Abstract:
This module contains the code that handles the power IRPs for the serial
driver.
Environment:
Kernel mode
Revision History :
--*/
#include "precomp.h"
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGESRP0, SerialGotoPowerState)
#pragma alloc_text(PAGESRP0, SerialPowerDispatch)
#pragma alloc_text(PAGESRP0, SerialSetPowerD0)
#pragma alloc_text(PAGESRP0, SerialSetPowerD3)
#pragma alloc_text(PAGESRP0, SerialSaveDeviceState)
#pragma alloc_text(PAGESRP0, SerialRestoreDeviceState)
#pragma alloc_text(PAGESRP0, SerialSendWaitWake)
#endif // ALLOC_PRAGMA
NTSTATUS
SerialSystemPowerCompletion(IN PDEVICE_OBJECT PDevObj, UCHAR MinorFunction,
IN POWER_STATE PowerState, IN PVOID Context,
PIO_STATUS_BLOCK IoStatus)
/*++
Routine Description:
This routine is the completion routine for PoRequestPowerIrp calls
in this module.
Arguments:
PDevObj - Pointer to the device object the irp is completing for
MinorFunction - IRP_MN_XXXX value requested
PowerState - Power state request was made of
Context - Event to set or NULL if no setting required
IoStatus - Status block from request
Return Value:
VOID
--*/
{
if (Context != NULL) {
KeSetEvent((PKEVENT)Context, IO_NO_INCREMENT, 0);
}
return STATUS_SUCCESS;
}
VOID
SerialSaveDeviceState(IN PSERIAL_DEVICE_EXTENSION PDevExt)
/*++
Routine Description:
This routine saves the device state of the UART
Arguments:
PDevExt - Pointer to the device extension for the devobj to save the state
for.
Return Value:
VOID
--*/
{
PSERIAL_DEVICE_STATE pDevState = &PDevExt->DeviceState;
#if defined(NEC_98)
//
// This argument use at MACRO only.
//
PSERIAL_DEVICE_EXTENSION Extension = PDevExt;
#else
#endif //defined(NEC_98)
PAGED_CODE();
SerialDump(SERTRACECALLS, ("SERIAL: Entering SerialSaveDeviceState\n"));
//
// Read necessary registers direct
//
pDevState->IER = READ_INTERRUPT_ENABLE(PDevExt->Controller);
pDevState->MCR = READ_MODEM_CONTROL(PDevExt->Controller);
pDevState->LCR = READ_LINE_CONTROL(PDevExt->Controller);
SerialDump(SERTRACECALLS, ("SERIAL: Leaving SerialSaveDeviceState\n"));
}
VOID
SerialRestoreDeviceState(IN PSERIAL_DEVICE_EXTENSION PDevExt)
/*++
Routine Description:
This routine restores the device state of the UART
Arguments:
PDevExt - Pointer to the device extension for the devobj to restore the
state for.
Return Value:
VOID
--*/
{
PSERIAL_DEVICE_STATE pDevState = &PDevExt->DeviceState;
SHORT divisor;
SERIAL_IOCTL_SYNC S;
#if defined(NEC_98)
//
// This argument use at MACRO only.
//
PSERIAL_DEVICE_EXTENSION Extension = PDevExt;
#else
#endif //defined(NEC_98)
PAGED_CODE();
SerialDump(SERTRACECALLS, ("SERIAL: Enter SerialRestoreDeviceState\n"));
SerialDump(SERTRACECALLS, ("------ PDevExt: %x\n", PDevExt));
//
// Disable interrupts both via OUT2 and IER
//
WRITE_MODEM_CONTROL(PDevExt->Controller, 0);
DISABLE_ALL_INTERRUPTS(PDevExt->Controller);
//
// Set the baud rate
//
SerialGetDivisorFromBaud(PDevExt->ClockRate, PDevExt->CurrentBaud, &divisor);
S.Extension = PDevExt;
S.Data = (PVOID)divisor;
SerialSetBaud(&S);
//
// Reset / Re-enable the FIFO's
//
if (PDevExt->FifoPresent) {
WRITE_FIFO_CONTROL(PDevExt->Controller, (UCHAR)0);
READ_RECEIVE_BUFFER(PDevExt->Controller);
WRITE_FIFO_CONTROL(PDevExt->Controller,
(UCHAR)(SERIAL_FCR_ENABLE | PDevExt->RxFifoTrigger
| SERIAL_FCR_RCVR_RESET
| SERIAL_FCR_TXMT_RESET));
} else {
WRITE_FIFO_CONTROL(PDevExt->Controller, (UCHAR)0);
}
//
// In case we are dealing with a bitmasked multiportcard,
// that has the mask register enabled, enable the
// interrupts.
//
if (PDevExt->InterruptStatus) {
if (PDevExt->Indexed) {
WRITE_PORT_UCHAR(PDevExt->InterruptStatus, (UCHAR)0xFF);
} else {
//
// Either we are standalone or already mapped
//
if (PDevExt->OurIsrContext == PDevExt) {
//
// This is a standalone
//
WRITE_PORT_UCHAR(PDevExt->InterruptStatus,
(UCHAR)(1 << (PDevExt->PortIndex - 1)));
} else {
//
// One of many
//
WRITE_PORT_UCHAR(PDevExt->InterruptStatus,
(UCHAR)((PSERIAL_MULTIPORT_DISPATCH)PDevExt->
OurIsrContext)->UsablePortMask);
}
}
}
//
// Restore a couple more registers
//
WRITE_INTERRUPT_ENABLE(PDevExt->Controller, pDevState->IER);
WRITE_LINE_CONTROL(PDevExt->Controller, pDevState->LCR);
//
// Clear out any stale interrupts
//
READ_INTERRUPT_ID_REG(PDevExt->Controller);
READ_LINE_STATUS(PDevExt->Controller);
READ_MODEM_STATUS(PDevExt->Controller);
if (PDevExt->DeviceState.Reopen == TRUE) {
SerialDump(SERPNPPOWER, ("SERIAL: Reopening device\n"));
PDevExt->DeviceIsOpened = TRUE;
PDevExt->DeviceState.Reopen = FALSE;
//
// This enables interrupts on the device!
//
WRITE_MODEM_CONTROL(PDevExt->Controller,
(UCHAR)(pDevState->MCR | SERIAL_MCR_OUT2));
//
// Refire the state machine
//
DISABLE_ALL_INTERRUPTS(PDevExt->Controller);
ENABLE_ALL_INTERRUPTS(PDevExt->Controller);
}
}
NTSTATUS
SerialPowerDispatch(IN PDEVICE_OBJECT PDevObj, IN PIRP PIrp)
/*++
Routine Description:
This is a dispatch routine for the IRPs that come to the driver with the
IRP_MJ_POWER major code (power IRPs).
Arguments:
PDevObj - Pointer to the device object for this device
PIrp - Pointer to the IRP for the current request
Return Value:
The function value is the final status of the call
--*/
{
PSERIAL_DEVICE_EXTENSION pDevExt = PDevObj->DeviceExtension;
PIO_STACK_LOCATION pIrpStack = IoGetCurrentIrpStackLocation(PIrp);
NTSTATUS status;
PDEVICE_OBJECT pLowerDevObj = pDevExt->LowerDeviceObject;
PDEVICE_OBJECT pPdo = pDevExt->Pdo;
BOOLEAN acceptingIRPs;
PAGED_CODE();
if ((status = SerialIRPPrologue(PIrp, pDevExt)) != STATUS_SUCCESS) {
PoStartNextPowerIrp(PIrp);
SerialCompleteRequest(pDevExt, PIrp, IO_NO_INCREMENT);
return status;
}
status = STATUS_SUCCESS;
switch (pIrpStack->MinorFunction) {
case IRP_MN_WAIT_WAKE:
SerialDump(SERPNPPOWER, ("SERIAL: Got IRP_MN_WAIT_WAKE Irp\n"));
break;
case IRP_MN_POWER_SEQUENCE:
SerialDump(SERPNPPOWER, ("SERIAL: Got IRP_MN_POWER_SEQUENCE Irp\n"));
break;
case IRP_MN_SET_POWER:
SerialDump(SERPNPPOWER, ("SERIAL: Got IRP_MN_SET_POWER Irp\n"));
//
// Perform different ops if it was system or device
//
switch (pIrpStack->Parameters.Power.Type) {
case SystemPowerState: {
POWER_STATE powerState;
//
// They asked for a system power state change
//
SerialDump(SERPNPPOWER, ("------: SystemPowerState\n"));
//
// We will only service this if we are policy owner -- we
// don't need to lock on this value since we only service
// one power request at a time.
//
if (pDevExt->OwnsPowerPolicy != TRUE) {
status = STATUS_SUCCESS;
goto PowerExit;
}
switch (pIrpStack->Parameters.Power.State.SystemState) {
case PowerSystemUnspecified:
powerState.DeviceState = PowerDeviceUnspecified;
break;
case PowerSystemWorking:
powerState.DeviceState = PowerDeviceD0;
break;
case PowerSystemSleeping1:
case PowerSystemSleeping2:
case PowerSystemSleeping3:
case PowerSystemHibernate:
case PowerSystemShutdown:
case PowerSystemMaximum:
powerState.DeviceState = PowerDeviceD3;
break;
default:
status = STATUS_SUCCESS;
goto PowerExit;
break;
}
PoSetPowerState(PDevObj, pIrpStack->Parameters.Power.Type,
pIrpStack->Parameters.Power.State);
//
// Send IRP to change device state if we should change
//
//
// We only power up the stack if the device is open. This is based
// on our policy of keeping the device powered down unless it is
// open.
//
if (((powerState.DeviceState < pDevExt->PowerState)
&& pDevExt->OpenCount)) {
PoRequestPowerIrp(pPdo, IRP_MN_SET_POWER, powerState, NULL, NULL,
NULL);
}else {
//
// If powering down, we can't go past wake state
// if wait-wake pending
//
if (powerState.DeviceState >= pDevExt->PowerState) {
//
// Power down -- ensure there is no wake-wait pending OR
// we can do down to that level and still wake the machine
//
if ((pDevExt->PendingWakeIrp == NULL && !pDevExt->SendWaitWake)
|| powerState.DeviceState <= pDevExt->DeviceWake) {
PoRequestPowerIrp(pPdo, IRP_MN_SET_POWER, powerState, NULL,
NULL, NULL);
}
}
}
status = STATUS_SUCCESS;
goto PowerExit;
}
case DevicePowerState:
SerialDump(SERPNPPOWER, ("------: DevicePowerState\n"));
break;
default:
SerialDump(SERPNPPOWER, ("------: UNKNOWN PowerState\n"));
status = STATUS_SUCCESS;
goto PowerExit;
}
//
// If we are already in the requested state, just pass the IRP down
//
if (pDevExt->PowerState
== pIrpStack->Parameters.Power.State.DeviceState) {
SerialDump(SERPNPPOWER, ("SERIAL: Already in requested power state\n")
);
status = STATUS_SUCCESS;
break;
}
switch (pIrpStack->Parameters.Power.State.DeviceState) {
case PowerDeviceD0:
SerialDump(SERPNPPOWER, ("SERIAL: Going to power state D0\n"));
return SerialSetPowerD0(PDevObj, PIrp);
case PowerDeviceD1:
case PowerDeviceD2:
case PowerDeviceD3:
SerialDump(SERPNPPOWER, ("SERIAL: Going to power state D3\n"));
return SerialSetPowerD3(PDevObj, PIrp);
default:
break;
}
break;
case IRP_MN_QUERY_POWER:
SerialDump (SERPNPPOWER, ("SERIAL: Got IRP_MN_QUERY_POWER Irp\n"));
//
// Check if we have a wait-wake pending and if so,
// ensure we don't power down too far.
//
if (pDevExt->PendingWakeIrp != NULL || pDevExt->SendWaitWake) {
if (pIrpStack->Parameters.Power.Type == DevicePowerState
&& pIrpStack->Parameters.Power.State.DeviceState
> pDevExt->DeviceWake) {
status = PIrp->IoStatus.Status = STATUS_INVALID_DEVICE_STATE;
PoStartNextPowerIrp(PIrp);
SerialCompleteRequest(pDevExt, PIrp, IO_NO_INCREMENT);
return status;
}
}
//
// If no wait-wake, always successful
//
PIrp->IoStatus.Status = STATUS_SUCCESS;
status = STATUS_SUCCESS;
PoStartNextPowerIrp(PIrp);
IoSkipCurrentIrpStackLocation(PIrp);
return SerialPoCallDriver(pDevExt, pLowerDevObj, PIrp);
} // switch (pIrpStack->MinorFunction)
PowerExit:;
PoStartNextPowerIrp(PIrp);
//
// Pass to the lower driver
//
IoSkipCurrentIrpStackLocation(PIrp);
status = SerialPoCallDriver(pDevExt, pLowerDevObj, PIrp);
return status;
}
NTSTATUS
SerialSetPowerD0(IN PDEVICE_OBJECT PDevObj, IN PIRP PIrp)
/*++
Routine Description:
This routine Decides if we need to pass the power Irp down the stack
or not. It then either sets up a completion handler to finish the
initialization or calls the completion handler directly.
Arguments:
PDevObj - Pointer to the devobj we are changing power state on
PIrp - Pointer to the IRP for the current request
Return Value:
Return status of either PoCallDriver of the call to the initialization
routine.
--*/
{
PSERIAL_DEVICE_EXTENSION pDevExt = PDevObj->DeviceExtension;
PIO_STACK_LOCATION pIrpStack = IoGetCurrentIrpStackLocation(PIrp);
NTSTATUS status;
PAGED_CODE();
SerialDump(SERTRACECALLS, ("SERIAL: In SerialSetPowerD0\n"));
SerialDump(SERPNPPOWER, ("SERIAL: SetPowerD0 has IRP %x\n", PIrp));
ASSERT(pDevExt->LowerDeviceObject);
//
// Set up completion to init device when it is on
//
KeClearEvent(&pDevExt->PowerD0Event);
IoCopyCurrentIrpStackLocationToNext(PIrp);
IoSetCompletionRoutine(PIrp, SerialSyncCompletion, &pDevExt->PowerD0Event,
TRUE, TRUE, TRUE);
SerialDump(SERPNPPOWER, ("SERIAL: Calling next driver\n"));
status = PoCallDriver(pDevExt->LowerDeviceObject, PIrp);
if (status == STATUS_PENDING) {
SerialDump(SERPNPPOWER, ("SERIAL: Waiting for next driver\n"));
KeWaitForSingleObject (&pDevExt->PowerD0Event, Executive, KernelMode,
FALSE, NULL);
} else {
if (!NT_SUCCESS(status)) {
PIrp->IoStatus.Status = status;
PoStartNextPowerIrp(PIrp);
SerialCompleteRequest(pDevExt, PIrp, IO_NO_INCREMENT);
return status;
}
}
if (!NT_SUCCESS(PIrp->IoStatus.Status)) {
status = PIrp->IoStatus.Status;
PoStartNextPowerIrp(PIrp);
SerialCompleteRequest(pDevExt, PIrp, IO_NO_INCREMENT);
return status;
}
//
// Restore the device
//
pDevExt->PowerState = PowerDeviceD0;
//
// Theoretically we could change states in the middle of processing
// the restore which would result in a bad PKINTERRUPT being used
// in SerialRestoreDeviceState().
//
if (pDevExt->PNPState == SERIAL_PNP_STARTED) {
SerialRestoreDeviceState(pDevExt);
}
//
// Now that we are powered up, call PoSetPowerState
//
PoSetPowerState(PDevObj, pIrpStack->Parameters.Power.Type,
pIrpStack->Parameters.Power.State);
PoStartNextPowerIrp(PIrp);
SerialCompleteRequest(pDevExt, PIrp, IO_NO_INCREMENT);
SerialDump(SERTRACECALLS, ("SERIAL: Leaving SerialSetPowerD0\n"));
return status;
}
NTSTATUS
SerialGotoPowerState(IN PDEVICE_OBJECT PDevObj,
IN PSERIAL_DEVICE_EXTENSION PDevExt,
IN DEVICE_POWER_STATE DevPowerState)
/*++
Routine Description:
This routine causes the driver to request the stack go to a particular
power state.
Arguments:
PDevObj - Pointer to the device object for this device
PDevExt - Pointer to the device extension we are working from
DevPowerState - the power state we wish to go to
Return Value:
The function value is the final status of the call
--*/
{
KEVENT gotoPowEvent;
NTSTATUS status;
POWER_STATE powerState;
PAGED_CODE();
SerialDump(SERTRACECALLS, ("SERIAL: In SerialGotoPowerState\n"));
powerState.DeviceState = DevPowerState;
KeInitializeEvent(&gotoPowEvent, SynchronizationEvent, FALSE);
status = PoRequestPowerIrp(PDevObj, IRP_MN_SET_POWER, powerState,
SerialSystemPowerCompletion, &gotoPowEvent,
NULL);
if (status == STATUS_PENDING) {
KeWaitForSingleObject(&gotoPowEvent, Executive, KernelMode, FALSE, NULL);
status = STATUS_SUCCESS;
}
#if DBG
if (!NT_SUCCESS(status)) {
SerialDump(SERPNPPOWER, ("SERIAL: SerialGotoPowerState FAILED\n"));
}
#endif
SerialDump(SERTRACECALLS, ("SERIAL: Leaving SerialGotoPowerState\n"));
return status;
}
NTSTATUS
SerialSetPowerD3(IN PDEVICE_OBJECT PDevObj, IN PIRP PIrp)
/*++
Routine Description:
This routine handles the SET_POWER minor function.
Arguments:
PDevObj - Pointer to the device object for this device
PIrp - Pointer to the IRP for the current request
Return Value:
The function value is the final status of the call
--*/
{
NTSTATUS status = STATUS_SUCCESS;
PSERIAL_DEVICE_EXTENSION pDevExt = PDevObj->DeviceExtension;
PIO_STACK_LOCATION pIrpStack = IoGetCurrentIrpStackLocation(PIrp);
PAGED_CODE();
SerialDump(SERDIAG3, ("SERIAL: In SerialSetPowerD3\n"));
//
// Send the wait wake now, just in time
//
if (pDevExt->SendWaitWake) {
SerialSendWaitWake(pDevExt);
}
//
// Before we power down, call PoSetPowerState
//
PoSetPowerState(PDevObj, pIrpStack->Parameters.Power.Type,
pIrpStack->Parameters.Power.State);
//
// If the device is not closed, disable interrupts and allow the fifo's
// to flush.
//
if (pDevExt->DeviceIsOpened == TRUE) {
LARGE_INTEGER charTime;
pDevExt->DeviceIsOpened = FALSE;
pDevExt->DeviceState.Reopen = TRUE;
charTime.QuadPart = -SerialGetCharTime(pDevExt).QuadPart;
//
// Shut down the chip
//
SerialDisableUART(pDevExt);
#if defined(NEC_98)
#else
//
// Drain the device
//
SerialDrainUART(pDevExt, &charTime);
#endif //defined(NEC_98)
//
// Save the device state
//
SerialSaveDeviceState(pDevExt);
}
//
// If the device is not open, we don't need to save the state;
// we can just reset the device on power-up
//
PIrp->IoStatus.Status = STATUS_SUCCESS;
pDevExt->PowerState = PowerDeviceD3;
//
// For what we are doing, we don't need a completion routine
// since we don't race on the power requests.
//
PIrp->IoStatus.Status = STATUS_SUCCESS;
PoStartNextPowerIrp(PIrp);
IoSkipCurrentIrpStackLocation(PIrp);
return SerialPoCallDriver(pDevExt, pDevExt->LowerDeviceObject, PIrp);
}
NTSTATUS
SerialSendWaitWake(PSERIAL_DEVICE_EXTENSION PDevExt)
/*++
Routine Description:
This routine causes a waitwake IRP to be sent
Arguments:
PDevExt - Pointer to the device extension for this device
Return Value:
STATUS_INVALID_DEVICE_STATE if one is already pending, else result
of call to PoRequestPowerIrp.
--*/
{
NTSTATUS status;
PIRP pIrp;
POWER_STATE powerState;
PAGED_CODE();
//
// Make sure one isn't pending already -- serial will only handle one at
// a time.
//
if (PDevExt->PendingWakeIrp != NULL) {
return STATUS_INVALID_DEVICE_STATE;
}
//
// Make sure we are capable of waking the machine
//
if (PDevExt->SystemWake <= PowerSystemWorking) {
return STATUS_INVALID_DEVICE_STATE;
}
if (PDevExt->DeviceWake == PowerDeviceUnspecified) {
return STATUS_INVALID_DEVICE_STATE;
}
//
// Send IRP to request wait wake and add a pending irp flag
//
//
InterlockedIncrement(&PDevExt->PendingIRPCnt);
powerState.SystemState = PDevExt->SystemWake;
status = PoRequestPowerIrp(PDevExt->Pdo, IRP_MN_WAIT_WAKE,
powerState, SerialWakeCompletion, PDevExt, &pIrp);
if (status == STATUS_PENDING) {
status = STATUS_SUCCESS;
PDevExt->PendingWakeIrp = pIrp;
} else if (!NT_SUCCESS(status)) {
SerialIRPEpilogue(PDevExt);
}
return status;
}
NTSTATUS
SerialWakeCompletion(IN PDEVICE_OBJECT PDevObj, IN UCHAR MinorFunction,
IN POWER_STATE PowerState, IN PVOID Context,
IN PIO_STATUS_BLOCK IoStatus)
/*++
Routine Description:
This routine handles completion of the waitwake IRP.
Arguments:
PDevObj - Pointer to the device object for this device
MinorFunction - Minor function previously supplied to PoRequestPowerIrp
PowerState - PowerState previously supplied to PoRequestPowerIrp
Context - a pointer to the device extension
IoStatus - current/final status of the waitwake IRP
Return Value:
The function value is the final status of attempting to process the
waitwake.
--*/
{
NTSTATUS status;
PSERIAL_DEVICE_EXTENSION pDevExt = (PSERIAL_DEVICE_EXTENSION)Context;
POWER_STATE powerState;
status = IoStatus->Status;
if (NT_SUCCESS(status)) {
//
// A wakeup has occurred -- powerup our stack
//
powerState.DeviceState = PowerDeviceD0;
PoRequestPowerIrp(pDevExt->Pdo, IRP_MN_SET_POWER, powerState, NULL,
NULL, NULL);
}
pDevExt->PendingWakeIrp = NULL;
SerialIRPEpilogue(pDevExt);
return status;
}