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.
719 lines
15 KiB
719 lines
15 KiB
/*++
|
|
|
|
Copyright (c) 1997 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
pmsleep.c
|
|
|
|
Abstract:
|
|
|
|
This file provides the code that changes the system from
|
|
the ACPI S0 (running) state to any one of the sleep states.
|
|
|
|
Author:
|
|
|
|
Jake Oshins (jakeo) Feb. 11, 1997
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
#include "halp.h"
|
|
#include "acpitabl.h"
|
|
#include "xxacpi.h"
|
|
#include "kddll.h"
|
|
#include "ixsleep.h"
|
|
|
|
//
|
|
// Internal functions
|
|
//
|
|
|
|
NTSTATUS
|
|
HalpAcpiSleep(
|
|
IN PVOID Context,
|
|
IN LONG NumberProcessors,
|
|
IN volatile PLONG Number
|
|
);
|
|
|
|
VOID
|
|
HalpSetClockBeforeSleep(
|
|
VOID
|
|
);
|
|
|
|
VOID
|
|
HalpSetClockAfterSleep(
|
|
VOID
|
|
);
|
|
|
|
BOOLEAN
|
|
HalpWakeupTimeElapsed(
|
|
VOID
|
|
);
|
|
|
|
VOID
|
|
HalpFreeTiledCR3 (
|
|
VOID
|
|
);
|
|
|
|
VOID
|
|
HalpReenableAcpi(
|
|
VOID
|
|
);
|
|
|
|
VOID
|
|
HalpPiix4Detect(
|
|
BOOLEAN DuringBoot
|
|
);
|
|
|
|
typedef struct _ERESOURCE {
|
|
LIST_ENTRY SystemResourcesList;
|
|
PVOID OwnerTable;
|
|
SHORT ActiveCount;
|
|
USHORT Flag;
|
|
PKSEMAPHORE SharedWaiters;
|
|
PKEVENT ExclusiveWaiters;
|
|
LIST_ENTRY OwnerThreads[2];
|
|
ULONG ContentionCount;
|
|
USHORT NumberOfSharedWaiters;
|
|
USHORT NumberOfExclusiveWaiters;
|
|
union {
|
|
PVOID Address;
|
|
ULONG CreatorBackTraceIndex;
|
|
};
|
|
|
|
KSPIN_LOCK SpinLock;
|
|
} ERESOURCE, *PERESOURCE;
|
|
|
|
#ifdef ALLOC_PRAGMA
|
|
#pragma alloc_text(PAGELK, HalpAcpiPreSleep)
|
|
#pragma alloc_text(PAGELK, HalpAcpiPostSleep)
|
|
#pragma alloc_text(PAGELK, HalpWakeupTimeElapsed)
|
|
#pragma alloc_text(PAGELK, HalpReenableAcpi)
|
|
#pragma alloc_text(PAGELK, HaliSetWakeEnable)
|
|
#pragma alloc_text(PAGELK, HaliSetWakeAlarm)
|
|
#pragma alloc_text(PAGELK, HalpMapNvsArea)
|
|
#pragma alloc_text(PAGELK, HalpFreeNvsBuffers)
|
|
#endif
|
|
|
|
HAL_WAKEUP_STATE HalpWakeupState;
|
|
|
|
#if DBG
|
|
BOOLEAN HalpFailSleep = FALSE;
|
|
#endif
|
|
|
|
#define PM1_TMR_EN 0x0001
|
|
#define PM1_RTC_EN 0x0400
|
|
|
|
//
|
|
// For re-enabling the debugger's com port.
|
|
//
|
|
extern PUCHAR KdComPortInUse;
|
|
|
|
extern PACPI_BIOS_MULTI_NODE HalpAcpiMultiNode;
|
|
extern PUCHAR HalpAcpiNvsData;
|
|
extern PVOID *HalpNvsVirtualAddress;
|
|
|
|
|
|
BOOLEAN
|
|
HalpAcpiPreSleep(
|
|
SLEEP_STATE_CONTEXT Context
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Arguments:
|
|
|
|
none
|
|
|
|
Return Value:
|
|
|
|
status
|
|
|
|
--*/
|
|
{
|
|
USHORT pmTimer;
|
|
PUSHORT pm1a;
|
|
PUSHORT pm1b;
|
|
PUSHORT pm1astatus;
|
|
PUSHORT pm1bstatus;
|
|
|
|
pm1astatus = (PUSHORT)(ULONG_PTR) HalpFixedAcpiDescTable.pm1a_evt_blk_io_port;
|
|
pm1bstatus = (PUSHORT)(ULONG_PTR) HalpFixedAcpiDescTable.pm1b_evt_blk_io_port;
|
|
pm1a = (PUSHORT)(ULONG_PTR) (HalpFixedAcpiDescTable.pm1a_evt_blk_io_port +
|
|
(HalpFixedAcpiDescTable.pm1_evt_len / 2));
|
|
|
|
pm1b = (PUSHORT)(ULONG_PTR) (HalpFixedAcpiDescTable.pm1b_evt_blk_io_port +
|
|
(HalpFixedAcpiDescTable.pm1_evt_len / 2));
|
|
|
|
HalpSleepContext.AsULONG = Context.AsULONG;
|
|
|
|
#if DBG
|
|
if (HalpFailSleep) {
|
|
return FALSE;
|
|
}
|
|
#endif
|
|
|
|
HalpSetClockBeforeSleep();
|
|
|
|
//
|
|
// Save the (A)PIC for any sleep state, as we need to play
|
|
// with it on the way back up again.
|
|
//
|
|
HalpSaveInterruptControllerState();
|
|
if (Context.bits.Flags & SLEEP_STATE_SAVE_MOTHERBOARD) {
|
|
|
|
HalpSaveDmaControllerState();
|
|
HalpSaveTimerState();
|
|
|
|
}
|
|
|
|
//
|
|
// We need to make sure that the PM Timer is disabled from this
|
|
// point onward. We also need to make that the RTC Enable is only
|
|
// enabled if the RTC should wake up the computer
|
|
//
|
|
pmTimer = READ_PORT_USHORT(pm1a);
|
|
if (HalpFixedAcpiDescTable.pm1b_evt_blk_io_port) {
|
|
|
|
pmTimer |= READ_PORT_USHORT(pm1b);
|
|
|
|
}
|
|
|
|
//
|
|
// Clear the timer enable bit.
|
|
//
|
|
pmTimer &= ~PM1_TMR_EN;
|
|
|
|
//
|
|
// Check to see if we the machine supports RTC Wake in Fixed Feature
|
|
// space. Some machines implement RTC support via control methods
|
|
//
|
|
if ( !(HalpFixedAcpiDescTable.flags & RTC_WAKE_GENERIC) ) {
|
|
|
|
//
|
|
// Check to see if we need to disable/enable the RTC alarm
|
|
//
|
|
if (!HalpWakeupState.RtcWakeupEnable) {
|
|
|
|
pmTimer &= ~PM1_RTC_EN;
|
|
|
|
} else {
|
|
|
|
pmTimer |= PM1_RTC_EN;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Write it back into the hardware.
|
|
//
|
|
WRITE_PORT_USHORT(pm1a, pmTimer);
|
|
if (HalpFixedAcpiDescTable.pm1b_evt_blk_io_port) {
|
|
|
|
WRITE_PORT_USHORT(pm1b, pmTimer);
|
|
}
|
|
|
|
//
|
|
// At this point, we should be running with interrupts disabled and
|
|
// the TMR_EN bit cleared. This is a good place to clear the PM1 Status
|
|
// Register
|
|
//
|
|
pmTimer = READ_PORT_USHORT( pm1astatus );
|
|
if (HalpFixedAcpiDescTable.pm1b_evt_blk_io_port) {
|
|
|
|
pmTimer |= READ_PORT_USHORT( pm1bstatus );
|
|
}
|
|
|
|
WRITE_PORT_USHORT( pm1astatus, pmTimer );
|
|
if (HalpFixedAcpiDescTable.pm1b_evt_blk_io_port) {
|
|
|
|
WRITE_PORT_USHORT( pm1bstatus, pmTimer );
|
|
}
|
|
|
|
//
|
|
// Check to see if we need to disable all wakeup events.
|
|
//
|
|
|
|
if (!HalpWakeupState.GeneralWakeupEnable) {
|
|
|
|
AcpiEnableDisableGPEvents(FALSE);
|
|
|
|
} else {
|
|
|
|
//
|
|
// Only call this before going to sleep --- waking up should
|
|
// reset the GPEs to the 'proper' value
|
|
//
|
|
AcpiGpeEnableWakeEvents();
|
|
}
|
|
|
|
HalpPreserveNvsArea();
|
|
|
|
//
|
|
// If we should have woken up already, don't sleep.
|
|
//
|
|
return !HalpWakeupTimeElapsed();
|
|
}
|
|
|
|
BOOLEAN
|
|
HalpAcpiPostSleep(
|
|
ULONG Context
|
|
)
|
|
{
|
|
USHORT pmTimer;
|
|
PUSHORT pm1a;
|
|
PUSHORT pm1b;
|
|
BOOLEAN ProfileInterruptEnabled;
|
|
|
|
#ifdef PICACPI
|
|
extern ULONG HalpProfilingStopped;
|
|
|
|
ProfileInterruptEnabled = (HalpProfilingStopped == 0);
|
|
#else
|
|
extern ULONG HalpProfileRunning;
|
|
|
|
ProfileInterruptEnabled = (HalpProfileRunning == 1);
|
|
#endif
|
|
|
|
pm1a = (PUSHORT)(ULONG_PTR)(HalpFixedAcpiDescTable.pm1a_evt_blk_io_port +
|
|
(HalpFixedAcpiDescTable.pm1_evt_len / 2));
|
|
|
|
pm1b = (PUSHORT)(ULONG_PTR)(HalpFixedAcpiDescTable.pm1b_evt_blk_io_port +
|
|
(HalpFixedAcpiDescTable.pm1_evt_len / 2));
|
|
|
|
|
|
//
|
|
// Read the currently set PM1 Enable bits
|
|
//
|
|
pmTimer = READ_PORT_USHORT(pm1a);
|
|
if (HalpFixedAcpiDescTable.pm1b_evt_blk_io_port) {
|
|
|
|
pmTimer |= READ_PORT_USHORT(pm1b);
|
|
|
|
}
|
|
|
|
//
|
|
// Set the timer enable bit. Clear the RTC enable bit
|
|
//
|
|
pmTimer |= PM1_TMR_EN;
|
|
pmTimer &= ~PM1_RTC_EN;
|
|
|
|
//
|
|
// Write back the new PM1 Enable bits
|
|
//
|
|
WRITE_PORT_USHORT(pm1a, pmTimer);
|
|
if (HalpFixedAcpiDescTable.pm1b_evt_blk_io_port) {
|
|
|
|
WRITE_PORT_USHORT(pm1b, pmTimer);
|
|
|
|
}
|
|
|
|
//
|
|
// Unset the RTC alarm and re-enable periodic interrupts.
|
|
//
|
|
HalpSetClockAfterSleep();
|
|
|
|
HalpWakeupState.RtcWakeupEnable = FALSE;
|
|
|
|
*((PULONG)HalpWakeVector) = 0;
|
|
|
|
HalpSetInterruptControllerWakeupState(Context);
|
|
|
|
if (HalpSleepContext.bits.Flags & SLEEP_STATE_SAVE_MOTHERBOARD) {
|
|
|
|
//
|
|
// If Kd was in use, then invalidate it. It will re-sync itself.
|
|
//
|
|
if (KdComPortInUse) {
|
|
KdRestore(TRUE);
|
|
}
|
|
|
|
HalpRestoreDmaControllerState();
|
|
|
|
HalpRestoreTimerState();
|
|
|
|
}
|
|
|
|
HalpPiix4Detect(FALSE);
|
|
|
|
//
|
|
// Enable all GPEs, not just the wake ones
|
|
//
|
|
|
|
AcpiEnableDisableGPEvents(TRUE);
|
|
|
|
HalpRestoreNvsArea();
|
|
|
|
HalpResetSBF();
|
|
|
|
//
|
|
// If we were profiling before, fire up the profile interrupt
|
|
//
|
|
if (ProfileInterruptEnabled) {
|
|
HalStartProfileInterrupt(0);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOLEAN
|
|
HalpWakeupTimeElapsed(
|
|
VOID
|
|
)
|
|
{
|
|
LARGE_INTEGER wakeupTime, currentTime;
|
|
TIME_FIELDS currentTimeFields;
|
|
|
|
//
|
|
// Check to see if a wakeup timer has already expired.
|
|
//
|
|
if (HalpWakeupState.RtcWakeupEnable) {
|
|
|
|
HalQueryRealTimeClock(¤tTimeFields);
|
|
|
|
RtlTimeFieldsToTime(¤tTimeFields, ¤tTime);
|
|
|
|
RtlTimeFieldsToTime(&HalpWakeupState.RtcWakeupTime, &wakeupTime);
|
|
|
|
//
|
|
// We advance currentTime by 1 second to make sure the timer doesn't
|
|
// expire before we go to sleep.
|
|
//
|
|
currentTime.QuadPart += 10000000; // Add 1 second
|
|
|
|
return ((ULONGLONG)wakeupTime.QuadPart <= (ULONGLONG)currentTime.QuadPart);
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
NTSTATUS
|
|
HaliSetWakeAlarm (
|
|
IN ULONGLONG WakeSystemTime,
|
|
IN PTIME_FIELDS WakeTimeFields OPTIONAL
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine sets the real-time clock's alarm to go
|
|
off at a specified time in the future and programs
|
|
the ACPI chipset so that this wakes the computer.
|
|
|
|
Arguments:
|
|
|
|
WakeSystemTime - amount of time that passes before we wake
|
|
WakeTimeFields - time to wake broken down into TIME_FIELDS
|
|
|
|
Return Value:
|
|
|
|
status
|
|
|
|
--*/
|
|
{
|
|
if (WakeSystemTime == 0) {
|
|
|
|
HalpWakeupState.RtcWakeupEnable = FALSE;
|
|
return STATUS_SUCCESS;
|
|
|
|
}
|
|
|
|
ASSERT( WakeTimeFields );
|
|
HalpWakeupState.RtcWakeupEnable = TRUE;
|
|
HalpWakeupState.RtcWakeupTime = *WakeTimeFields;
|
|
return HalpSetWakeAlarm(WakeSystemTime, WakeTimeFields);
|
|
}
|
|
|
|
VOID
|
|
HaliSetWakeEnable(
|
|
IN BOOLEAN Enable
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is called to set the policy for waking up.
|
|
As we go to sleep, the global HalpWakeupState will be
|
|
read and the hardware set accordingly.
|
|
|
|
Arguments:
|
|
|
|
Enable - true or false
|
|
|
|
Return Value:
|
|
|
|
--*/
|
|
{
|
|
//
|
|
// Always clear the RTC wake --- we expect that someone will
|
|
// set the alarm after they call this function
|
|
//
|
|
HalpWakeupState.RtcWakeupEnable = FALSE;
|
|
|
|
//
|
|
// Toggle the generate wake up bit
|
|
//
|
|
HalpWakeupState.GeneralWakeupEnable = Enable;
|
|
}
|
|
|
|
VOID
|
|
HalpReenableAcpi(
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This calls into the ACPI driver to switch back into ACPI mode,
|
|
presumably after S4 and sets the ACPI registers that the HAL
|
|
controls.
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
--*/
|
|
{
|
|
// TEMPTEMP?
|
|
HalpInitializeClock();
|
|
|
|
AcpiInitEnableAcpi(TRUE);
|
|
AcpiEnableDisableGPEvents(TRUE);
|
|
}
|
|
|
|
VOID
|
|
HalpMapNvsArea(
|
|
VOID
|
|
)
|
|
{
|
|
NTSTATUS status;
|
|
ULONG i, bufferSize, bufferOffset, nodeCount;
|
|
|
|
PAGED_CODE();
|
|
|
|
status = HalpAcpiFindRsdt(&HalpAcpiMultiNode);
|
|
|
|
if (!NT_SUCCESS(status)) {
|
|
return;
|
|
}
|
|
|
|
if (HalpAcpiMultiNode->Count == 0) {
|
|
|
|
//
|
|
// There's no work to do here.
|
|
//
|
|
|
|
goto HalpMapNvsError;
|
|
}
|
|
|
|
//
|
|
// Find total size of the buffer we need.
|
|
//
|
|
|
|
bufferSize = 0;
|
|
nodeCount = 0;
|
|
|
|
for (i = 0; i < HalpAcpiMultiNode->Count; i++) {
|
|
|
|
if (HalpAcpiMultiNode->E820Entry[i].Type == AcpiAddressRangeNVS) {
|
|
|
|
ASSERT(HalpAcpiMultiNode->E820Entry[i].Length.HighPart == 0);
|
|
|
|
bufferSize += HalpAcpiMultiNode->E820Entry[i].Length.LowPart;
|
|
nodeCount++;
|
|
}
|
|
}
|
|
|
|
if (bufferSize == 0) {
|
|
|
|
//
|
|
// There's no work to do here.
|
|
//
|
|
|
|
goto HalpMapNvsError;
|
|
}
|
|
|
|
#if DBG
|
|
if (bufferSize > (20 * PAGE_SIZE)) {
|
|
DbgPrint("HALACPI: The BIOS wants the OS to preserve %x bytes\n", bufferSize);
|
|
}
|
|
#endif
|
|
|
|
HalpAcpiNvsData = ExAllocatePoolWithTag(NonPagedPool,
|
|
bufferSize,
|
|
'AlaH');
|
|
|
|
if (!HalpAcpiNvsData) {
|
|
|
|
DbgPrint("HALACPI: The BIOS's non-volatile data will not be preserved\n");
|
|
goto HalpMapNvsError;
|
|
}
|
|
|
|
HalpNvsVirtualAddress = ExAllocatePoolWithTag(NonPagedPool,
|
|
(nodeCount + 1) * sizeof(PVOID),
|
|
'AlaH');
|
|
|
|
if (!HalpNvsVirtualAddress) {
|
|
goto HalpMapNvsError;
|
|
}
|
|
|
|
|
|
//
|
|
// Make a mapping for each run.
|
|
//
|
|
|
|
bufferOffset = 0;
|
|
nodeCount = 0;
|
|
|
|
for (i = 0; i < HalpAcpiMultiNode->Count; i++) {
|
|
|
|
if (HalpAcpiMultiNode->E820Entry[i].Type == AcpiAddressRangeNVS) {
|
|
|
|
HalpNvsVirtualAddress[nodeCount] =
|
|
MmMapIoSpace(HalpAcpiMultiNode->E820Entry[i].Base,
|
|
HalpAcpiMultiNode->E820Entry[i].Length.LowPart,
|
|
MmNonCached);
|
|
|
|
ASSERT(HalpNvsVirtualAddress[nodeCount]);
|
|
|
|
nodeCount++;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Mark the end.
|
|
//
|
|
|
|
HalpNvsVirtualAddress[nodeCount] = NULL;
|
|
|
|
return;
|
|
|
|
HalpMapNvsError:
|
|
|
|
if (HalpAcpiMultiNode) ExFreePool(HalpAcpiMultiNode);
|
|
if (HalpNvsVirtualAddress) ExFreePool(HalpNvsVirtualAddress);
|
|
if (HalpAcpiNvsData) ExFreePool(HalpAcpiNvsData);
|
|
|
|
HalpAcpiMultiNode = NULL;
|
|
|
|
return;
|
|
}
|
|
|
|
VOID
|
|
HalpPreserveNvsArea(
|
|
VOID
|
|
)
|
|
{
|
|
ULONG i, dataOffset = 0, nodeCount = 0;
|
|
|
|
if (!HalpAcpiMultiNode) {
|
|
|
|
//
|
|
// Either there was nothing to save or there
|
|
// was a fatal error.
|
|
//
|
|
|
|
return;
|
|
}
|
|
|
|
for (i = 0; i < HalpAcpiMultiNode->Count; i++) {
|
|
|
|
if (HalpAcpiMultiNode->E820Entry[i].Type == AcpiAddressRangeNVS) {
|
|
|
|
//
|
|
// Copy from BIOS memory to temporary buffer.
|
|
//
|
|
|
|
RtlCopyMemory(HalpAcpiNvsData + dataOffset,
|
|
HalpNvsVirtualAddress[nodeCount],
|
|
HalpAcpiMultiNode->E820Entry[i].Length.LowPart);
|
|
|
|
nodeCount++;
|
|
dataOffset += HalpAcpiMultiNode->E820Entry[i].Length.LowPart;
|
|
}
|
|
}
|
|
}
|
|
|
|
VOID
|
|
HalpRestoreNvsArea(
|
|
VOID
|
|
)
|
|
{
|
|
ULONG i, dataOffset = 0, nodeCount = 0;
|
|
|
|
if (!HalpAcpiMultiNode) {
|
|
|
|
//
|
|
// Either there was nothing to save or there
|
|
// was a fatal error.
|
|
//
|
|
|
|
return;
|
|
}
|
|
|
|
for (i = 0; i < HalpAcpiMultiNode->Count; i++) {
|
|
|
|
if (HalpAcpiMultiNode->E820Entry[i].Type == AcpiAddressRangeNVS) {
|
|
|
|
//
|
|
// Copy from temporary buffer to BIOS area.
|
|
//
|
|
|
|
RtlCopyMemory(HalpNvsVirtualAddress[nodeCount],
|
|
HalpAcpiNvsData + dataOffset,
|
|
HalpAcpiMultiNode->E820Entry[i].Length.LowPart);
|
|
|
|
nodeCount++;
|
|
dataOffset += HalpAcpiMultiNode->E820Entry[i].Length.LowPart;
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
VOID
|
|
HalpFreeNvsBuffers(
|
|
VOID
|
|
)
|
|
{
|
|
ULONG i, nodeCount = 0;
|
|
|
|
PAGED_CODE();
|
|
|
|
if (!HalpAcpiMultiNode) {
|
|
|
|
//
|
|
// Either there was nothing to save or there
|
|
// was a fatal error.
|
|
//
|
|
|
|
return;
|
|
}
|
|
|
|
for (i = 0; i < HalpAcpiMultiNode->Count; i++) {
|
|
|
|
if (HalpAcpiMultiNode->E820Entry[i].Type == AcpiAddressRangeNVS) {
|
|
|
|
//
|
|
// Give back all the PTEs that we took earlier
|
|
//
|
|
|
|
MmUnmapIoSpace(HalpNvsVirtualAddress[nodeCount],
|
|
HalpAcpiMultiNode->E820Entry[i].Length.LowPart);
|
|
|
|
nodeCount++;
|
|
}
|
|
}
|
|
|
|
ASSERT(HalpAcpiMultiNode);
|
|
ASSERT(HalpNvsVirtualAddress);
|
|
ASSERT(HalpAcpiNvsData);
|
|
|
|
ExFreePool(HalpAcpiMultiNode);
|
|
ExFreePool(HalpNvsVirtualAddress);
|
|
ExFreePool(HalpAcpiNvsData);
|
|
|
|
HalpAcpiMultiNode = NULL;
|
|
HalpNvsVirtualAddress = NULL;
|
|
HalpAcpiNvsData = NULL;
|
|
}
|