AMI-Aptio-BIOS-Reversed/PcRtcSmm/PcRtcSmm.h at a42bdf720a4c28ee31ce9d1de96442d89ac8055c

Fork: 0
ajax / AMI-Aptio-BIOS-Reversed
Find file
Newer
Older
AMI-Aptio-BIOS-Reversed / PcRtcSmm / PcRtcSmm.h
Ajax Dong 2 days ago 24 KB Init
Raw Blame History
/** @file
  PcRtcSmm.h -- Header for PcRtcSmm

Copyright (c) HR650X BIOS Decompilation Project
**/

#ifndef __PCRTCSMM_H__
#define __PCRTCSMM_H__

#include "../uefi_headers/Uefi.h"

//
// Function Prototypes
//

EFI_STATUS
EFIAPI
PcRtcGetCentury(
  VOID
);

EFI_STATUS
EFIAPI
CpuPause(
  VOID
);

EFI_STATUS
EFIAPI
ReadTsc(
  VOID
);

EFI_STATUS
EFIAPI
EnableInterrupts(
  VOID
);

EFI_STATUS
EFIAPI
DisableInterrupts(
  VOID
);

EFI_STATUS
EFIAPI
GetCallerEflags(
  VOID
);

EFI_STATUS
EFIAPI
SetJump(
  VOID
);

EFI_STATUS
EFIAPI
LongJump(
  VOID
);

EFI_STATUS
EFIAPI
PcRtcValidateJumpBuffer(
  VOID
);

EFI_STATUS
EFIAPI
DebugPrint(
  VOID
);

EFI_STATUS
EFIAPI
DebugAssert(
  VOID
);

EFI_STATUS
EFIAPI
CompareGuidPair(
  VOID
);

EFI_STATUS
EFIAPI
ReadUnaligned64(
  VOID
);

EFI_STATUS
EFIAPI
PcRtcSmmCpuWrite(
  VOID
);

EFI_STATUS
EFIAPI
PcdGet32(
  VOID
);

EFI_STATUS
EFIAPI
PciExpressWrite500(
  VOID
);

EFI_STATUS
EFIAPI
ReadMmio32(
  VOID
);

EFI_STATUS
EFIAPI
MicroSecondDelay(
  VOID
);

EFI_STATUS
EFIAPI
SmmCpuReadSaveState(
  VOID
);

EFI_STATUS
EFIAPI
IsAddressInSmram(
  VOID
);

EFI_STATUS
EFIAPI
FreePoolMmramAware(
  VOID
);

EFI_STATUS
EFIAPI
PcRtcReadReg(
  VOID
);

EFI_STATUS
EFIAPI
PcRtcWriteReg(
  VOID
);

EFI_STATUS
EFIAPI
DecimalToBcd(
  VOID
);

EFI_STATUS
EFIAPI
BcdToDecimal(
  VOID
);

EFI_STATUS
EFIAPI
PcRtcWaitForUpdateComplete(
  VOID
);

EFI_STATUS
EFIAPI
PcRtcIsLeapYear(
  VOID
);

EFI_STATUS
EFIAPI
PcRtcIsDayValid(
  VOID
);

EFI_STATUS
EFIAPI
PcRtcValidateTime(
  VOID
);

EFI_STATUS
EFIAPI
PcRtcConvertFromRegisterFormat(
  VOID
);

EFI_STATUS
EFIAPI
PcRtcConvertToRegisterFormat(
  VOID
);

EFI_STATUS
EFIAPI
PcRtcIsTimeNearby(
  VOID
);

EFI_STATUS
EFIAPI
PcRtcGetTime(
  VOID
);

EFI_STATUS
EFIAPI
PcRtcSmmGetTimeHandler(
  VOID
);

EFI_STATUS
EFIAPI
PcRtcSetTime(
  VOID
);

EFI_STATUS
EFIAPI
PcRtcSmmSetTimeHandler(
  VOID
);

EFI_STATUS
EFIAPI
PcRtcGetWakeupTime(
  VOID
);

EFI_STATUS
EFIAPI
PcRtcSmmGetAlarmHandler(
  VOID
);

EFI_STATUS
EFIAPI
PcRtcSetWakeupTime(
  VOID
);

EFI_STATUS
EFIAPI
PcRtcSmmSetAlarmHandler(
  VOID
);

EFI_STATUS
EFIAPI
PcRtcInitRtcHardware(
  VOID
);

EFI_STATUS
EFIAPI
PcRtcInitialize(
  VOID
);

EFI_STATUS
EFIAPI
PcRtcSmmDriverInit(
  VOID
);

EFI_STATUS
EFIAPI
SmmCoreEntry(
  VOID
);

EFI_STATUS
EFIAPI
_ModuleEntryPoint(
  VOID
);

EFI_STATUS
EFIAPI
SmmMain(
  VOID
);

EFI_STATUS
EFIAPI
SmmInstallConfigurationTable(
  VOID
);

EFI_STATUS
EFIAPI
Register Ports (SMM alias)(
  VOID
);

EFI_STATUS
EFIAPI
Register Indices(
  VOID
);

EFI_STATUS
EFIAPI
A bits(
  VOID
);

EFI_STATUS
EFIAPI
In Progress(
  VOID
);

EFI_STATUS
EFIAPI
B bits(
  VOID
);

EFI_STATUS
EFIAPI
Savings Enable(
  VOID
);

EFI_STATUS
EFIAPI
Wave Enable(
  VOID
);

EFI_STATUS
EFIAPI
Ended Interrupt Enable(
  VOID
);

EFI_STATUS
EFIAPI
Interrupt Enable(
  VOID
);

EFI_STATUS
EFIAPI
D bits(
  VOID
);

EFI_STATUS
EFIAPI
RAM and Time(
  VOID
);

EFI_STATUS
EFIAPI
macros for RTC register access via SMM I/O ports(
  VOID
);

EFI_STATUS
EFIAPI
Global Variables (mapped from .data section at 0x2A20-0x2C40)(
  VOID
);

EFI_STATUS
EFIAPI
EFI globals (set by UefiBootServicesTableLib / UefiRuntimeServicesTableLib)(
  VOID
);

EFI_STATUS
EFIAPI
gImageHandle      = NULL;     // 0x2AB8(
  VOID
);

EFI_STATUS
EFIAPI
EFI_BOOT_SERVICES       *gBS              = NULL;     // 0x2AB0(
  VOID
);

EFI_STATUS
EFIAPI
//(
  VOID
);

EFI_STATUS
EFIAPI
globals (resolved via SmmServicesTableLib)(
  VOID
);

EFI_STATUS
EFIAPI
*gSmst            = NULL;     // 0x2AC8(
  VOID
);

EFI_STATUS
EFIAPI
from GUID at 0x2A60(
  VOID
);

EFI_STATUS
EFIAPI
Runtime RSC Handler Protocol(
  VOID
);

EFI_STATUS
EFIAPI
SmmEndOfDxe  +104 SmmAllocatePages  +112 SmmFreePages +120 SmmAllocatePool(
  VOID
);

EFI_STATUS
EFIAPI
*gSmmRuntimeRsc   = NULL;     // 0x2AA0 (qword_2AA0)(
  VOID
);

EFI_STATUS
EFIAPI
(qword_2AE8, lazy-init from GUID 0x2A20)(
  VOID
);

EFI_STATUS
EFIAPI
(qword_2AF0, SMM CPU I/O2 interface)(
  VOID
);

EFI_STATUS
EFIAPI
Variable Protocol (lazy-init)(
  VOID
);

EFI_STATUS
EFIAPI
*gSmmVariable     = NULL;     // 0x2AD0 (qword_2AD0)(
  VOID
);

EFI_STATUS
EFIAPI
type from PCD protocol(
  VOID
);

EFI_STATUS
EFIAPI
gPcdDbValue       = 0;        // 0x2AD8: PcdGet32(PcdPlatformType) result(
  VOID
);

EFI_STATUS
EFIAPI
(PCD protocol pointer)(
  VOID
);

EFI_STATUS
EFIAPI
list (lazy-init via gEfiHobListGuid)(
  VOID
);

EFI_STATUS
EFIAPI
*gHobList         = NULL;     // 0x2AE0 (qword_2AE0)(
  VOID
);

EFI_STATUS
EFIAPI
range tracking(
  VOID
);

EFI_STATUS
EFIAPI
*gSmramRanges     = NULL;     // 0x2C18(
  VOID
);

EFI_STATUS
EFIAPI
state globals(
  VOID
);

EFI_STATUS
EFIAPI
gRtcTimeZone      = 2047;     // 0x2C38: EFI_UNSPECIFIED_TIMEZONE(
  VOID
);

EFI_STATUS
EFIAPI
UINT8                   gRtcCenturyOffset = 0x32;     // 0x2C3B (n50): CMOS offset for century byte(
  VOID
);

EFI_STATUS
EFIAPI
Config Structure (28 bytes at 0x2C20: unk_2C20)(
  VOID
);

EFI_STATUS
EFIAPI
by sub_D20 (SetTime) and sub_EC8 (GetWakeupTime) to save/restore(
  VOID
);

EFI_STATUS
EFIAPI
across operations.(
  VOID
);

EFI_STATUS
EFIAPI
gRtcConfig;                   // 0x2C20(
  VOID
);

EFI_STATUS
EFIAPI
System Return Status for module entry(
  VOID
);

EFI_STATUS
EFIAPI
gModuleEntryStatus = 0x8000000000000001ULL; // 0x2C08(
  VOID
);

EFI_STATUS
EFIAPI
gJumpBuffer[320];             // 0x2B10 (unk_2B10)(
  VOID
);

EFI_STATUS
EFIAPI
port scratch (byte at 0x2B00)(
  VOID
);

EFI_STATUS
EFIAPI
gDebugPortScratch;            // 0x2B00(
  VOID
);

EFI_STATUS
EFIAPI
declarations for internal functions(
  VOID
);

EFI_STATUS
EFIAPI
EFI_STATUS(
  VOID
);

EFI_STATUS
EFIAPI
intrinsic wrappers (sub_470, sub_480, sub_490, sub_4A0, sub_4B0)(
  VOID
);

EFI_STATUS
EFIAPI
support functions(
  VOID
);

EFI_STATUS
EFIAPI
JUMP_BUFFER * (at least 320 bytes)(
  VOID
);

EFI_STATUS
EFIAPI
the jump buffer pointer and alignment(
  VOID
);

EFI_STATUS
EFIAPI
(JumpBuffer);(
  VOID
);

EFI_STATUS
EFIAPI
registers: rbx, rbp, rdi, rsi, r12, r13, r14, r15(
  VOID
);

EFI_STATUS
EFIAPI
by return address and MXCSR(
  VOID
);

EFI_STATUS
EFIAPI
pointer proxy(
  VOID
);

EFI_STATUS
EFIAPI
XMM6-XMM15 (128-bit each)(
  VOID
);

EFI_STATUS
EFIAPI
through the saved return address (offset 72 in jump buffer)(
  VOID
);

EFI_STATUS
EFIAPI
overlap: if Source < Destination and Source + Length >= Destination(
  VOID
);

EFI_STATUS
EFIAPI
backwards from end.(
  VOID
);

EFI_STATUS
EFIAPI
(Source < Destination &&(
  VOID
);

EFI_STATUS
EFIAPI
in reverse 8-byte chunks(
  VOID
);

EFI_STATUS
EFIAPI
(; Length >= 8; Length -= 8)(
  VOID
);

EFI_STATUS
EFIAPI
remaining bytes in reverse(
  VOID
);

EFI_STATUS
EFIAPI
(; Length > 0; Length--)(
  VOID
);

EFI_STATUS
EFIAPI
forward 8-byte chunks via qmemcpy(
  VOID
);

EFI_STATUS
EFIAPI
Remaining = Length;(
  VOID
);

EFI_STATUS
EFIAPI
remaining 1-7 bytes(
  VOID
);

EFI_STATUS
EFIAPI
8-byte aligned chunks(
  VOID
);

EFI_STATUS
EFIAPI
Chunks = Length >> 3;(
  VOID
);

EFI_STATUS
EFIAPI
remaining bytes(
  VOID
);

EFI_STATUS
EFIAPI
Remaining = Length & 7;(
  VOID
);

EFI_STATUS
EFIAPI
helpers (sub_199C at 0x199C and sub_1ABC at 0x1ABC / sub_1A34 at 0x1A34)(
  VOID
);

EFI_STATUS
EFIAPI
the SMM variable protocol if needed (lazy init)(
  VOID
);

EFI_STATUS
EFIAPI
(gSmmVariable == NULL)(
  VOID
);

EFI_STATUS
EFIAPI
debug level from CMOS (port 0x70 index 0x4C, preserving NMI bit)(
  VOID
);

EFI_STATUS
EFIAPI
(0x70, (IoRead8 (0x70) & 0x80) | 0x4C);(
  VOID
);

EFI_STATUS
EFIAPI
the filter level from CMOS(
  VOID
);

EFI_STATUS
EFIAPI
(CmosDebugLevel > 3)(
  VOID
);

EFI_STATUS
EFIAPI
if (CmosDebugLevel == 1)(
  VOID
);

EFI_STATUS
EFIAPI
}(
  VOID
);

EFI_STATUS
EFIAPI
infinite loop (no return)(
  VOID
);

EFI_STATUS
EFIAPI
(TRUE);(
  VOID
);

EFI_STATUS
EFIAPI
register via SMM CPU protocol(
  VOID
);

EFI_STATUS
EFIAPI
= 0x40000002 (some CPU register write)(
  VOID
);

EFI_STATUS
EFIAPI
= 0x0306000A(
  VOID
);

EFI_STATUS
EFIAPI
((EFI_SMM_CPU_PROTOCOL *)gSmmCpuProtocol)->WriteRegister ((
  VOID
);

EFI_STATUS
EFIAPI
alignment(
  VOID
);

EFI_STATUS
EFIAPI
(((UINTN)Address & 1) != 0)(
  VOID
);

EFI_STATUS
EFIAPI
microseconds into:(
  VOID
);

EFI_STATUS
EFIAPI
= MicroSeconds >> 22;(
  VOID
);

EFI_STATUS
EFIAPI
for the initial TSC + per-iteration ticks to pass(
  VOID
);

EFI_STATUS
EFIAPI
{(
  VOID
);

EFI_STATUS
EFIAPI
until TSC >= TargetTsc(
  VOID
);

EFI_STATUS
EFIAPI
(((TargetTsc - (UINT32)__indword (1288)) & 0x800000) == 0)(
  VOID
);

EFI_STATUS
EFIAPI
iteration uses full tick range(
  VOID
);

EFI_STATUS
EFIAPI
(35);(
  VOID
);

EFI_STATUS
EFIAPI
helper functions(
  VOID
);

/// use Smst to free inside SMRAM,
EFI_STATUS
EFIAPI
if the address is within SMRAM(
  VOID
);

EFI_STATUS
EFIAPI
BootServices to free outside.(
  VOID
);

EFI_STATUS
EFIAPI
(IsAddressInSmram ((UINT64)Buffer))(
  VOID
);

EFI_STATUS
EFIAPI
wrapper (sub_1B64 at 0x1B64)(
  VOID
);

EFI_STATUS
EFIAPI
Register Access(
  VOID
);

EFI_STATUS
EFIAPI
conversion (DecimalToBcd = sub_18F4 at 0x18F4(
  VOID
);

EFI_STATUS
EFIAPI
= sub_1940 at 0x1940)(
  VOID
);

EFI_STATUS
EFIAPI
(sub_1400 at 0x1400)(
  VOID
);

EFI_STATUS
EFIAPI
Register D VRT bit(
  VOID
);

EFI_STATUS
EFIAPI
= PcRtcReadReg (RTC_REGISTER_D);(
  VOID
);

EFI_STATUS
EFIAPI
Register A UIP with timeout(
  VOID
);

EFI_STATUS
EFIAPI
= 10001;(
  VOID
);

EFI_STATUS
EFIAPI
Register A and check UIP(
  VOID
);

EFI_STATUS
EFIAPI
= PcRtcReadReg (RTC_REGISTER_A);(
  VOID
);

EFI_STATUS
EFIAPI
VRT again after the update completes(
  VOID
);

EFI_STATUS
EFIAPI
table (used by IsDayValid at sub_1500)(
  VOID
);

EFI_STATUS
EFIAPI
in each month (non-leap year February = 28, leap February = 29)(
  VOID
);

EFI_STATUS
EFIAPI
as an array of 12 UINTN values for SIMD loading in sub_1500.(
  VOID
);

EFI_STATUS
EFIAPI
= days for months 1-2(
  VOID
);

EFI_STATUS
EFIAPI
= days for months 3-12 starting at 30(
  VOID
);

EFI_STATUS
EFIAPI
CONST UINT8 mDaysInMonth[12] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };(
  VOID
);

EFI_STATUS
EFIAPI
// ============================================================================(
  VOID
);

EFI_STATUS
EFIAPI
year: divisible by 4, and not (divisible by 100 unless divisible by 400)(
  VOID
);

EFI_STATUS
EFIAPI
((Year & 3) != 0)(
  VOID
);

EFI_STATUS
EFIAPI
(sub_1500 at 0x1500)(
  VOID
);

EFI_STATUS
EFIAPI
up days in this month(
  VOID
);

EFI_STATUS
EFIAPI
= mDaysInMonth[Time->Month - 1];(
  VOID
);

EFI_STATUS
EFIAPI
special: check for leap year(
  VOID
);

EFI_STATUS
EFIAPI
(Time->Month == 2)(
  VOID
);

EFI_STATUS
EFIAPI
(sub_1478 at 0x1478)(
  VOID
);

EFI_STATUS
EFIAPI
(sub_1260 at 0x1260)(
  VOID
);

EFI_STATUS
EFIAPI
PM flag from Hour bit 7 and clear it(
  VOID
);

EFI_STATUS
EFIAPI
= Time->Hour;(
  VOID
);

EFI_STATUS
EFIAPI
BCD to decimal for all time fields(
  VOID
);

EFI_STATUS
EFIAPI
for invalid BCD conversion (0xFF indicates failure)(
  VOID
);

EFI_STATUS
EFIAPI
(Time->Year == 0xFF ||(
  VOID
);

EFI_STATUS
EFIAPI
century byte from RTC CMOS(
  VOID
);

EFI_STATUS
EFIAPI
(gRtcCenturyOffset != 0)(
  VOID
);

EFI_STATUS
EFIAPI
from 12-hour to 24-hour format(
  VOID
);

EFI_STATUS
EFIAPI
(!Is24Hour)(
  VOID
);

EFI_STATUS
EFIAPI
(Time->Hour < 12)(
  VOID
);

EFI_STATUS
EFIAPI
(Time->Hour == 12)(
  VOID
);

EFI_STATUS
EFIAPI
nanosecond (time register reads don't provide nanoseconds)(
  VOID
);

EFI_STATUS
EFIAPI
(sub_1640 at 0x1640)(
  VOID
);

EFI_STATUS
EFIAPI
Hour from 24-hour to 12-hour(
  VOID
);

EFI_STATUS
EFIAPI
(Time->Hour > 12)(
  VOID
);

EFI_STATUS
EFIAPI
century: Year / 100(
  VOID
);

EFI_STATUS
EFIAPI
= Time->Year;(
  VOID
);

EFI_STATUS
EFIAPI
to BCD(
  VOID
);

EFI_STATUS
EFIAPI
century byte to CMOS(
  VOID
);

EFI_STATUS
EFIAPI
Second to BCD (return value)(
  VOID
);

EFI_STATUS
EFIAPI
(!IsBinary)(
  VOID
);

EFI_STATUS
EFIAPI
PM flag in Hour if in 12-hour mode and PM(
  VOID
);

EFI_STATUS
EFIAPI
(!Is24Hour && RegisterB == 0)(
  VOID
);

EFI_STATUS
EFIAPI
check if we need PM bit: the 12-hour conversion already set it.(
  VOID
);

EFI_STATUS
EFIAPI
make sure it's persistent.(
  VOID
);

EFI_STATUS
EFIAPI
(sub_16F8 at 0x16F8)(
  VOID
);

EFI_STATUS
EFIAPI
equal, check minutes(
  VOID
);

EFI_STATUS
EFIAPI
(Time1->Minute > Time2->Minute)(
  VOID
);

EFI_STATUS
EFIAPI
equal, check seconds(
  VOID
);

EFI_STATUS
EFIAPI
(Time1->Second > Time2->Second)(
  VOID
);

EFI_STATUS
EFIAPI
(sub_1744 at 0x1744)(
  VOID
);

EFI_STATUS
EFIAPI
Dec 31 -> Jan 1 cross-year(
  VOID
);

EFI_STATUS
EFIAPI
((UINT16)From->Year + 1 != (UINT16)Target->Year ||(
  VOID
);

EFI_STATUS
EFIAPI
month rollover: From->Month + 1 == Target->Month and Target->Day == 1(
  VOID
);

EFI_STATUS
EFIAPI
(FromMonth + 1 == (UINTN)Target->Month && Target->Day == 1)(
  VOID
);

EFI_STATUS
EFIAPI
(PcRtcIsLeapYear (From->Year))(
  VOID
);

EFI_STATUS
EFIAPI
other months, check days-in-month(
  VOID
);

EFI_STATUS
EFIAPI
= (From->Day == mDaysInMonth[FromMonth - 1]);(
  VOID
);

/// check day rollover
EFI_STATUS
EFIAPI
year, same month(
  VOID
);

EFI_STATUS
EFIAPI
(From->Day + 1 == Target->Day)(
  VOID
);

/// alarm must be >= current time
EFI_STATUS
EFIAPI
day(
  VOID
);

EFI_STATUS
EFIAPI
(From->Day == Target->Day && PcRtcTimeCompare (From, Target) <= 0)(
  VOID
);

EFI_STATUS
EFIAPI
- SMM GetTime handler (sub_84C -> sub_C28 at 0xC28)(
  VOID
);

EFI_STATUS
EFIAPI
Register B to determine format(
  VOID
);

EFI_STATUS
EFIAPI
= PcRtcReadReg (RTC_REGISTER_B);(
  VOID
);

EFI_STATUS
EFIAPI
all time registers(
  VOID
);

EFI_STATUS
EFIAPI
TimeZone and Daylight from globals(
  VOID
);

EFI_STATUS
EFIAPI
from register format (BCD->decimal, 12hr->24hr, add century)(
  VOID
);

EFI_STATUS
EFIAPI
= PcRtcConvertFromRegisterFormat (Time, RegisterB);(
  VOID
);

EFI_STATUS
EFIAPI
the converted time(
  VOID
);

EFI_STATUS
EFIAPI
= PcRtcValidateTime (Time);(
  VOID
);

EFI_STATUS
EFIAPI
capabilities(
  VOID
);

EFI_STATUS
EFIAPI
(Capabilities != NULL)(
  VOID
);

EFI_STATUS
EFIAPI
Hz(
  VOID
);

EFI_STATUS
EFIAPI
thunk (sub_84C at 0x84C)(
  VOID
);

EFI_STATUS
EFIAPI
- SMM SetTime handler (sub_854 -> sub_D20 at 0xD20)(
  VOID
);

EFI_STATUS
EFIAPI
the time(
  VOID
);

EFI_STATUS
EFIAPI
time for internal manipulation(
  VOID
);

EFI_STATUS
EFIAPI
(&LocalTime, Time, sizeof (EFI_TIME));(
  VOID
);

EFI_STATUS
EFIAPI
for update complete before writing(
  VOID
);

EFI_STATUS
EFIAPI
= PcRtcWaitForUpdateComplete ();(
  VOID
);

EFI_STATUS
EFIAPI
the "RTC" SMM variable to invalidate DXE-side cache(
  VOID
);

EFI_STATUS
EFIAPI
(gSmmRuntimeRsc != NULL)(
  VOID
);

EFI_STATUS
EFIAPI
RSC protocol has the SmmDeleteVariable at offset 88(
  VOID
);

EFI_STATUS
EFIAPI
SET bit in Register B to freeze RTC updates(
  VOID
);

EFI_STATUS
EFIAPI
century byte to CMOS (offset from Config or default 0x32)(
  VOID
);

EFI_STATUS
EFIAPI
(Config != NULL && Config->CenturyRegister != 0)(
  VOID
);

EFI_STATUS
EFIAPI
time to register format(
  VOID
);

EFI_STATUS
EFIAPI
(&LocalTime, RegisterB);(
  VOID
);

EFI_STATUS
EFIAPI
(RTC_SECONDS,     LocalTime.Second);(
  VOID
);

EFI_STATUS
EFIAPI
SET bit to resume RTC updates(
  VOID
);

EFI_STATUS
EFIAPI
(RTC_REGISTER_B, RegisterB & ~RTC_B_SET);(
  VOID
);

EFI_STATUS
EFIAPI
TimeZone and Daylight to config structure(
  VOID
);

EFI_STATUS
EFIAPI
(Config != NULL)(
  VOID
);

EFI_STATUS
EFIAPI
thunk (sub_854 at 0x854)(
  VOID
);

EFI_STATUS
EFIAPI
- SMM GetWakeupTime handler (sub_870 -> sub_EC8 at 0xEC8)(
  VOID
);

EFI_STATUS
EFIAPI
Register B and C for alarm status(
  VOID
);

EFI_STATUS
EFIAPI
alarm registers (seconds, minutes, hours)(
  VOID
);

EFI_STATUS
EFIAPI
date registers (day, month, year)(
  VOID
);

EFI_STATUS
EFIAPI
Register D for century storage(
  VOID
);

EFI_STATUS
EFIAPI
RegisterD;(
  VOID
);

EFI_STATUS
EFIAPI
TimeZone/Daylight from config structure(
  VOID
);

EFI_STATUS
EFIAPI
to read the "RTCALARM" SMM variable to get Year/Month(
  VOID
);

EFI_STATUS
EFIAPI
= sizeof (EFI_TIME);(
  VOID
);

EFI_STATUS
EFIAPI
Year/Month/Day from the stored alarm variable(
  VOID
);

EFI_STATUS
EFIAPI
from register format(
  VOID
);

EFI_STATUS
EFIAPI
thunk (sub_870 at 0x870)(
  VOID
);

EFI_STATUS
EFIAPI
- SMM SetWakeupTime handler (sub_87C -> sub_1074 at 0x1074)(
  VOID
);

EFI_STATUS
EFIAPI
current RTC time to validate proximity (alarm must be within 24 hours)(
  VOID
);

EFI_STATUS
EFIAPI
= PcRtcGetTime (&CurrentTime, NULL);(
  VOID
);

EFI_STATUS
EFIAPI
if alarm time is nearby (within 1 day)(
  VOID
);

EFI_STATUS
EFIAPI
(!PcRtcIsTimeNearby (&CurrentTime, Time))(
  VOID
);

EFI_STATUS
EFIAPI
alarm time(
  VOID
);

EFI_STATUS
EFIAPI
(&AlarmTime, Time, sizeof (EFI_TIME));(
  VOID
);

EFI_STATUS
EFIAPI
alarm to register format(
  VOID
);

EFI_STATUS
EFIAPI
(&AlarmTime, RegisterB);(
  VOID
);

EFI_STATUS
EFIAPI
current alarm register values (for restoring previous alarm)(
  VOID
);

EFI_STATUS
EFIAPI
Register D century(
  VOID
);

EFI_STATUS
EFIAPI
= PcRtcReadReg (RTC_REGISTER_D) & 0x3F;(
  VOID
);

EFI_STATUS
EFIAPI
TimeZone/Daylight from globals(
  VOID
);

EFI_STATUS
EFIAPI
"RTCALARM" SMM variable(
  VOID
);

EFI_STATUS
EFIAPI
= ((SMM_RSC_HANDLER_PROTOCOL *)gSmmRuntimeRsc)->SmmSetVariable ((
  VOID
);

EFI_STATUS
EFIAPI
Register B SET bit to freeze updates(
  VOID
);

EFI_STATUS
EFIAPI
= RegisterB | RTC_B_SET;(
  VOID
);

EFI_STATUS
EFIAPI
alarm registers(
  VOID
);

EFI_STATUS
EFIAPI
(RTC_SECONDS_ALARM, AlarmTime.Second);(
  VOID
);

EFI_STATUS
EFIAPI
and update Register D with the alarm day/century(
  VOID
);

EFI_STATUS
EFIAPI
(RTC_REGISTER_C);        // Clear pending AF(
  VOID
);

EFI_STATUS
EFIAPI
(RTC_REGISTER_D, AlarmTime.Day & 0x3F);(
  VOID
);

EFI_STATUS
EFIAPI
pending interrupt by reading Register C(
  VOID
);

EFI_STATUS
EFIAPI
(RTC_REGISTER_C);(
  VOID
);

EFI_STATUS
EFIAPI
existing alarm values and keep them (only clear AIE)(
  VOID
);

EFI_STATUS
EFIAPI
date(
  VOID
);

EFI_STATUS
EFIAPI
alarm registers (redundant for Enabled, restores current for not)(
  VOID
);

EFI_STATUS
EFIAPI
(!Enabled)(
  VOID
);

EFI_STATUS
EFIAPI
read(
  VOID
);

EFI_STATUS
EFIAPI
Month/Year(
  VOID
);

EFI_STATUS
EFIAPI
(RTC_MONTH, AlarmTime.Month);(
  VOID
);

EFI_STATUS
EFIAPI
AIE bit: set if enabled, clear if not(
  VOID
);

EFI_STATUS
EFIAPI
(Enabled)(
  VOID
);

EFI_STATUS
EFIAPI
final Register B value (clear SET, optionally set AIE)(
  VOID
);

EFI_STATUS
EFIAPI
(RTC_REGISTER_B, RegisterBNew & 0x7F);(
  VOID
);

EFI_STATUS
EFIAPI
thunk (sub_87C at 0x87C)(
  VOID
);

EFI_STATUS
EFIAPI
- RTC chip initialization (sub_984 at 0x984)(
  VOID
);

EFI_STATUS
EFIAPI
1: Initialize RTC hardware registers(
  VOID
);

EFI_STATUS
EFIAPI
(RTC_REGISTER_A, 0x26);           // 32768 Hz, divider reset(
  VOID
);

EFI_STATUS
EFIAPI
pending interrupt(
  VOID
);

EFI_STATUS
EFIAPI
VRT (will be set by hardware)(
  VOID
);

EFI_STATUS
EFIAPI
for UIP to clear(
  VOID
);

EFI_STATUS
EFIAPI
2: Read the current RTC time from hardware(
  VOID
);

EFI_STATUS
EFIAPI
3: Configure Register B(
  VOID
);

EFI_STATUS
EFIAPI
bits: AIE (5), DM (2) = 0x24(
  VOID
);

EFI_STATUS
EFIAPI
= (RegisterB & 0x24) | 0x02;(
  VOID
);

EFI_STATUS
EFIAPI
4: Try to read the "RTC" SMM variable for TimeZone(
  VOID
);

EFI_STATUS
EFIAPI
= sizeof (UINT64);(
  VOID
);

EFI_STATUS
EFIAPI
5: Try to convert and validate the current time(
  VOID
);

EFI_STATUS
EFIAPI
= PcRtcConvertFromRegisterFormat (&CurrentTime, RegisterBNew);(
  VOID
);

/// reset to factory defaults
EFI_STATUS
EFIAPI
invalid(
  VOID
);

EFI_STATUS
EFIAPI
reset via SMM CPU protocol write(
  VOID
);

EFI_STATUS
EFIAPI
();(
  VOID
);

EFI_STATUS
EFIAPI
SET (bit 7) is clear, AIE (bit 5) is set, 24HR (bit 1) is set(
  VOID
);

EFI_STATUS
EFIAPI
(RTC_REGISTER_B, RegisterBNew & 0xDF | 0x02);(
  VOID
);

EFI_STATUS
EFIAPI
6: Write back the SMM variable with the current time + config(
  VOID
);

EFI_STATUS
EFIAPI
= PcRtcSetTime (&CurrentTime, &gRtcConfig);(
  VOID
);

EFI_STATUS
EFIAPI
7: Get wakeup alarm time(
  VOID
);

EFI_STATUS
EFIAPI
= PcRtcGetWakeupTime (&AlarmEnabled, &AlarmPending, &AlarmTime, &gRtcConfig);(
  VOID
);

EFI_STATUS
EFIAPI
8: If no alarm pending, set default alarm (2000-01-01, clear AIE)(
  VOID
);

EFI_STATUS
EFIAPI
(!AlarmEnabled && EFI_ERROR (Status))(
  VOID
);

EFI_STATUS
EFIAPI
the current config timezone/daylight(
  VOID
);

EFI_STATUS
EFIAPI
= gRtcConfig.TimeZone;(
  VOID
);

EFI_STATUS
EFIAPI
default alarm time: 2000-01-01 00:00:00(
  VOID
);

EFI_STATUS
EFIAPI
to register format(
  VOID
);

EFI_STATUS
EFIAPI
(&CurrentTime, RegisterB);(
  VOID
);

EFI_STATUS
EFIAPI
the "RTCALARM" variable(
  VOID
);

EFI_STATUS
EFIAPI
Register B SET bit, write alarm registers, clear SET bit(
  VOID
);

EFI_STATUS
EFIAPI
(RTC_REGISTER_B, RegisterB | RTC_B_SET);(
  VOID
);

EFI_STATUS
EFIAPI
- Protocol registration (sub_884 at 0x884)(
  VOID
);

EFI_STATUS
EFIAPI
the protocol database for gEfiSmmRscHandlerGuid(
  VOID
);

EFI_STATUS
EFIAPI
= Smst->NumberOfProtocols;(
  VOID
);

EFI_STATUS
EFIAPI
protocol entry from Smst->ProtocolRegistry(
  VOID
);

EFI_STATUS
EFIAPI
entry is 24 bytes:(
  VOID
);

EFI_STATUS
EFIAPI
*EntryGuid = (EFI_GUID *)(*(UINT64 *)(Smst + 160) + (Index * 24));(
  VOID
);

EFI_STATUS
EFIAPI
not find SMM Runtime Services Protocol(
  VOID
);

EFI_STATUS
EFIAPI
(4, "Couldn't find SMM Runtime Services\n");(
  VOID
);

EFI_STATUS
EFIAPI
RTC hardware(
  VOID
);

EFI_STATUS
EFIAPI
= PcRtcInitRtcHardware (gSmmRuntimeRsc);(
  VOID
);

EFI_STATUS
EFIAPI
the four RTC handlers in the RSC protocol(
  VOID
);

EFI_STATUS
EFIAPI
- Full driver entry (sub_560 at 0x560)(
  VOID
);

EFI_STATUS
EFIAPI
1: Save EFI table pointers to globals(
  VOID
);

EFI_STATUS
EFIAPI
= ImageHandle;(
  VOID
);

EFI_STATUS
EFIAPI
2: Locate SMM Base2 protocol(
  VOID
);

EFI_STATUS
EFIAPI
= NULL;(
  VOID
);

EFI_STATUS
EFIAPI
3: Get Smst location(
  VOID
);

EFI_STATUS
EFIAPI
4: Locate SMM Access2 protocol(
  VOID
);

EFI_STATUS
EFIAPI
= 0;(
  VOID
);

EFI_STATUS
EFIAPI
5: Get SMRAM capabilities (query size first)(
  VOID
);

EFI_STATUS
EFIAPI
6: Allocate buffer for SMRAM ranges(
  VOID
);

EFI_STATUS
EFIAPI
= AllocateSmramPool (EfiRuntimeServicesData, SmramRangeBufferSize);(
  VOID
);

EFI_STATUS
EFIAPI
7: Re-read SMRAM ranges into the allocated buffer(
  VOID
);

EFI_STATUS
EFIAPI
= ((EFI_SMM_ACCESS2_PROTOCOL *)(UINTN)CpuIo2Handle)->GetCapabilities ((
  VOID
);

EFI_STATUS
EFIAPI
8: Calculate SMRAM range count (each range is 32 bytes = 5 qwords >> 5)(
  VOID
);

EFI_STATUS
EFIAPI
= SmramRangeBufferSize >> 5;(
  VOID
);

EFI_STATUS
EFIAPI
9: Get PCD protocol and read platform type(
  VOID
);

EFI_STATUS
EFIAPI
= ((PCD_PROTOCOL *)GetPcdProtocol ())->Get32 (5);(
  VOID
);

EFI_STATUS
EFIAPI
10: Initialize HOB list(
  VOID
);

EFI_STATUS
EFIAPI
11: Check PCIe config address for Express presence(
  VOID
);

EFI_STATUS
EFIAPI
((INT8)(*(UINT8 *)PciExpressReadAddress (1024068)) >= 0)(
  VOID
);

EFI_STATUS
EFIAPI
0x500 to the word at PCIe config address 0x100100 (1024064)(
  VOID
);

EFI_STATUS
EFIAPI
((UINT16 *)PciExpressReadAddress (1024064));(
  VOID
);

/// enable memory space
EFI_STATUS
EFIAPI
bit 7 on the byte at 0x100104 (1024068)(
  VOID
);

EFI_STATUS
EFIAPI
12: TSC-based short delay (approx 357 TSC cycles)(
  VOID
);

EFI_STATUS
EFIAPI
= GetCallerEflags ();(
  VOID
);

EFI_STATUS
EFIAPI
initial TSC(
  VOID
);

EFI_STATUS
EFIAPI
= ReadMmio32 (1288) & 0xFFFFFF;(
  VOID
);

EFI_STATUS
EFIAPI
target TSC: initial + 357 cycles(
  VOID
);

EFI_STATUS
EFIAPI
= ReadTsc ();(
  VOID
);

EFI_STATUS
EFIAPI
previous interrupt state(
  VOID
);

EFI_STATUS
EFIAPI
(InterruptsEnabled)(
  VOID
);

EFI_STATUS
EFIAPI
(sub_480 at 0x480 -> sub_560 at 0x560)(
  VOID
);

EFI_STATUS
EFIAPI
(0x4B4)(
  VOID
);

EFI_STATUS
EFIAPI
the driver(
  VOID
);

EFI_STATUS
EFIAPI
(ImageHandle, SystemTable);(
  VOID
);

EFI_STATUS
EFIAPI
for error recovery(
  VOID
);

EFI_STATUS
EFIAPI
(SetJump (&gJumpBuffer) == 0)(
  VOID
);

EFI_STATUS
EFIAPI
execution: initialize RTC and register handlers(
  VOID
);

EFI_STATUS
EFIAPI
= PcRtcInitialize (gSmst);(
  VOID
);

EFI_STATUS
EFIAPI
the jump buffer and prepare for re-initialization(
  VOID
);

EFI_STATUS
EFIAPI
(&gJumpBuffer);(
  VOID
);

EFI_STATUS
EFIAPI
ASSERTs are reached only via AutoGen.c recovery:(
  VOID
);

EFI_STATUS
EFIAPI
((
  VOID
);

EFI_STATUS
EFIAPI
path: free SMRAM pool(
  VOID
);

EFI_STATUS
EFIAPI
(gSmramRanges);(
  VOID
);

EFI_STATUS
EFIAPI
- backward compatibility entry (forwarded from entry point)(
  VOID
);

EFI_STATUS
EFIAPI
the SMM system table(
  VOID
);

EFI_STATUS
EFIAPI
= Smst;(
  VOID
);

EFI_STATUS
EFIAPI
remaining init happens in _ModuleEntryPoint via PcRtcSmmDriverInit(
  VOID
);

EFI_STATUS
EFIAPI
PcRtcInitialize.(
  VOID
);

EFI_STATUS
EFIAPI
EFI_SUCCESS;(
  VOID
);

EFI_STATUS
EFIAPI
function is a no-op in the reconstructed driver; the original(
  VOID
);

EFI_STATUS
EFIAPI
allocated and populated the configuration table via(
  VOID
);

#endif /* __PCRTCSMM_H__ */