/** @file
  PcdDxe.h -- Header for PcdDxe

Copyright (c) HR650X BIOS Decompilation Project
**/

#ifndef __PCDDXE_H__
#define __PCDDXE_H__

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

//
// Function Prototypes
//

EFI_STATUS
EFIAPI
DebugPrint(
  VOID
);

EFI_STATUS
EFIAPI
DebugAssert(
  VOID
);

EFI_STATUS
EFIAPI
ModuleEntryPoint(
  VOID
);

EFI_STATUS
EFIAPI
PcdDxeDriverEntry(
  VOID
);

EFI_STATUS
EFIAPI
PcdDxeInitDatabase(
  VOID
);

EFI_STATUS
EFIAPI
DxePcdGetSize(
  VOID
);

EFI_STATUS
EFIAPI
GetLocalTokenNumber(
  VOID
);

EFI_STATUS
EFIAPI
GetSkuIdAdjustedTokenNumber(
  VOID
);

EFI_STATUS
EFIAPI
GetPcdInfoSize(
  VOID
);

EFI_STATUS
EFIAPI
GetTokenIndex(
  VOID
);

EFI_STATUS
EFIAPI
GetTokenNumberFromGuid(
  VOID
);

EFI_STATUS
EFIAPI
NotifyPcdCallbacks(
  VOID
);

EFI_STATUS
EFIAPI
UpdatePcdSizeInfo(
  VOID
);

EFI_STATUS
EFIAPI
DxePcdSetPtr(
  VOID
);

EFI_STATUS
EFIAPI
DxePcdSetByGuid(
  VOID
);

EFI_STATUS
EFIAPI
DxePcdSetValue16(
  VOID
);

EFI_STATUS
EFIAPI
SetNvStorePcdValue(
  VOID
);

EFI_STATUS
EFIAPI
GetVariableForPcd(
  VOID
);

EFI_STATUS
EFIAPI
GetPcdNvStoreData(
  VOID
);

EFI_STATUS
EFIAPI
DxePcdCallbackNotifyAll(
  VOID
);

EFI_STATUS
EFIAPI
DxePcdOnSetVariableEvent(
  VOID
);

EFI_STATUS
EFIAPI
GetSectionFromFfs(
  VOID
);

EFI_STATUS
EFIAPI
FreePool(
  VOID
);

EFI_STATUS
EFIAPI
AcquireLock(
  VOID
);

EFI_STATUS
EFIAPI
ReleaseLock(
  VOID
);

EFI_STATUS
EFIAPI
CompareGuid(
  VOID
);

EFI_STATUS
EFIAPI
IsListValid(
  VOID
);

EFI_STATUS
EFIAPI
StrLen(
  VOID
);

EFI_STATUS
EFIAPI
AsciiStrLen(
  VOID
);

EFI_STATUS
EFIAPI
AsciiStrCpyS(
  VOID
);

EFI_STATUS
EFIAPI
ReadUnaligned64(
  VOID
);

EFI_STATUS
EFIAPI
UEFI handles from ModuleEntryPoint(
  VOID
);

EFI_STATUS
EFIAPI
gImageHandle    = NULL;(
  VOID
);

EFI_STATUS
EFIAPI
console protocol handle, lazily initialized by GetDebugConOut()(
  VOID
);

EFI_STATUS
EFIAPI
*gDebugConProtocol = NULL;(
  VOID
);

EFI_STATUS
EFIAPI
list pointer, retrieved from SystemTable configuration table(
  VOID
);

EFI_STATUS
EFIAPI
GetHobListInternal()(
  VOID
);

EFI_STATUS
EFIAPI
*mHobList       = NULL;(
  VOID
);

EFI_STATUS
EFIAPI
function table.  Array of LIST_ENTRY (16 bytes each)(
  VOID
);

EFI_STATUS
EFIAPI
entry per PCD token.  Initialized during PcdDxeInitDatabase().(
  VOID
);

EFI_STATUS
EFIAPI
*mCallbackFnTable = NULL;(
  VOID
);

EFI_STATUS
EFIAPI
*mPcdDatabasePeiDb = NULL;(
  VOID
);

EFI_STATUS
EFIAPI
*mPcdDatabaseDxeDb = NULL;(
  VOID
);

EFI_STATUS
EFIAPI
to pre-computed size info table for GetPcdInfo protocol(
  VOID
);

EFI_STATUS
EFIAPI
*mPcdInfoSizeTable = NULL;(
  VOID
);

EFI_STATUS
EFIAPI
of entries in mPcdInfoSizeTable(
  VOID
);

EFI_STATUS
EFIAPI
mPcdInfoCount = 0;(
  VOID
);

EFI_STATUS
EFIAPI
number of PCD tokens (PEI + DXE combined)(
  VOID
);

EFI_STATUS
EFIAPI
mPcdTotalTokenCount = 0;(
  VOID
);

EFI_STATUS
EFIAPI
of PCD tokens from the PEI phase(
  VOID
);

EFI_STATUS
EFIAPI
mPeiTokenCount = 0;(
  VOID
);

EFI_STATUS
EFIAPI
of DXE EX (extra / extension) tokens(
  VOID
);

EFI_STATUS
EFIAPI
mDxeExTokenCount = 0;(
  VOID
);

EFI_STATUS
EFIAPI
counts for token size fields (for bit-field extraction)(
  VOID
);

EFI_STATUS
EFIAPI
mPeiTokenSizeBitCount = 0;(
  VOID
);

EFI_STATUS
EFIAPI
of the GUID tables in bytes (16 bytes per entry)(
  VOID
);

EFI_STATUS
EFIAPI
mPeiGuidTableSize = 0;(
  VOID
);

EFI_STATUS
EFIAPI
from end of PEI DB to start of DXE token range(
  VOID
);

EFI_STATUS
EFIAPI
mDxeTokenOffset = 0;(
  VOID
);

EFI_STATUS
EFIAPI
flags indicating empty databases / tables(
  VOID
);

EFI_STATUS
EFIAPI
mIsPeiDbEmpty        = FALSE;(
  VOID
);

EFI_STATUS
EFIAPI
state variable (1 = released, 2 = acquired)(
  VOID
);

EFI_STATUS
EFIAPI
gLockState = EFI_LOCK_RELEASED;(
  VOID
);

EFI_STATUS
EFIAPI
CMOS diagnostic status (register 0x4B)(
  VOID
);

EFI_STATUS
EFIAPI
(0x70, (__inbyte (0x70) & 0x80) | 0x4B);(
  VOID
);

EFI_STATUS
EFIAPI
NVRAM boot flag from memory-mapped IO at 0xFDAF0490(
  VOID
);

EFI_STATUS
EFIAPI
(CmosData == 0) {(
  VOID
);

EFI_STATUS
EFIAPI
the assertion message if the mask allows(
  VOID
);

EFI_STATUS
EFIAPI
((AssertMask & Status) != 0) {(
  VOID
);

EFI_STATUS
EFIAPI
the HOB list (needed for PCD database init)(
  VOID
);

EFI_STATUS
EFIAPI
();(
  VOID
);

EFI_STATUS
EFIAPI
the module-specific driver initialization(
  VOID
);

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

EFI_STATUS
EFIAPI
1: verify gPcdProtocolGuid is NOT already installed(
  VOID
);

EFI_STATUS
EFIAPI
= NULL;(
  VOID
);

EFI_STATUS
EFIAPI
2: initialize the PCD database(
  VOID
);

EFI_STATUS
EFIAPI
3: install PCD protocols(
  VOID
);

EFI_STATUS
EFIAPI
4: install the PCD protocol on the handle(
  VOID
);

EFI_STATUS
EFIAPI
= gBS->InstallProtocolInterface ((
  VOID
);

EFI_STATUS
EFIAPI
1: retrieve the DXE PCD DB from the firmware volume(
  VOID
);

EFI_STATUS
EFIAPI
= GetSectionFromFv (&gPcdDatabaseGuid);(
  VOID
);

EFI_STATUS
EFIAPI
2: make an owned copy of the DXE PCD DB(
  VOID
);

EFI_STATUS
EFIAPI
= AllocateZeroPool ((
  VOID
);

EFI_STATUS
EFIAPI
3: locate the PEI PCD DB from the HOB list(
  VOID
);

EFI_STATUS
EFIAPI
4: set up the PEI database pointer(
  VOID
);

EFI_STATUS
EFIAPI
(PeiDbAddr != NULL) {(
  VOID
);

EFI_STATUS
EFIAPI
the PEI DB into the DXE DB (patch the self-marker)(
  VOID
);

/// allocate an empty stub
EFI_STATUS
EFIAPI
PEI DB found(
  VOID
);

EFI_STATUS
EFIAPI
= AllocateZeroPool (72);(
  VOID
);

EFI_STATUS
EFIAPI
5: compute token counts and table sizes(
  VOID
);

EFI_STATUS
EFIAPI
PCD database headers encode counts as UINT16 at known offsets:(
  VOID
);

EFI_STATUS
EFIAPI
= *(UINT16 *)(mPcdDatabaseDxeDb + 64);(
  VOID
);

EFI_STATUS
EFIAPI
bit counts = 8 * (UINT16 at +0x42)(
  VOID
);

EFI_STATUS
EFIAPI
= 8 * *(UINT16 *)(mPcdDatabasePeiDb + 66);(
  VOID
);

EFI_STATUS
EFIAPI
table sizes = 16 * (UINT16 at +0x44)(
  VOID
);

EFI_STATUS
EFIAPI
= 16 * *(UINT16 *)(mPcdDatabasePeiDb + 68);(
  VOID
);

EFI_STATUS
EFIAPI
EX token count(
  VOID
);

EFI_STATUS
EFIAPI
= PeiDbTokenCount - *(UINT16 *)(mPcdDatabasePeiDb + 66);(
  VOID
);

EFI_STATUS
EFIAPI
flags(
  VOID
);

EFI_STATUS
EFIAPI
= (PeiDbTokenCount == 0);(
  VOID
);

EFI_STATUS
EFIAPI
info table: one entry per "size table slot" across both phases(
  VOID
);

EFI_STATUS
EFIAPI
=   (UINTN)*(UINT16 *)(mPcdDatabasePeiDb + 66)(
  VOID
);

EFI_STATUS
EFIAPI
6: allocate and initialize the callback function table(
  VOID
);

EFI_STATUS
EFIAPI
= (UINTN)(mPcdTotalTokenCount) + 1;(
  VOID
);

EFI_STATUS
EFIAPI
as a self-linked circular list head(
  VOID
);

EFI_STATUS
EFIAPI
the correct database (PEI vs DXE)(
  VOID
);

EFI_STATUS
EFIAPI
(TokenNumber >= mPeiTokenCount + 1) {(
  VOID
);

EFI_STATUS
EFIAPI
the 4-bit size field from the upper nibble of HIBYTE(
  VOID
);

EFI_STATUS
EFIAPI
= (LocalTokenNumber >> 28) & 0xF;(
  VOID
);

/// query dynamically
EFI_STATUS
EFIAPI
pre-computed size(
  VOID
);

EFI_STATUS
EFIAPI
(TokenNumber - 1, &Size);(
  VOID
);

/// determine the actual size
EFI_STATUS
EFIAPI
has SkuId variants(
  VOID
);

EFI_STATUS
EFIAPI
((LocalTokenNumber & PCD_TYPE_MASK) == 0) {(
  VOID
);

EFI_STATUS
EFIAPI
pointer into the database(
  VOID
);

EFI_STATUS
EFIAPI
= PcdDb + (LocalTokenNumber & PCD_TOKEN_INDEX_MASK);(
  VOID
);

EFI_STATUS
EFIAPI
token: the value lives in the VPD table section(
  VOID
);

EFI_STATUS
EFIAPI
= DbValuePtr + *(UINT32 *)((LocalTokenNumber & PCD_TOKEN_INDEX_MASK) + PcdDb);(
  VOID
);

EFI_STATUS
EFIAPI
NV / HII / String tokens, return the value pointer(
  VOID
);

EFI_STATUS
EFIAPI
the database (the actual NV or HII access path is(
  VOID
);

EFI_STATUS
EFIAPI
by the SetPtr / SetNvStorePcdValue functions).(
  VOID
);

EFI_STATUS
EFIAPI
function should only be called for tokens WITHOUT(
  VOID
);

EFI_STATUS
EFIAPI
variants at this level.(
  VOID
);

EFI_STATUS
EFIAPI
((LocalTokenNumber & PCD_ATTRIBUTE_SKUID_ENABLED) == 0);(
  VOID
);

EFI_STATUS
EFIAPI
the SkuId table pointer (offset at +4 from the token slot)(
  VOID
);

EFI_STATUS
EFIAPI
= (UINTN *)(PcdDb + *(UINT32 *)((LocalTokenNumber & PCD_TOKEN_INDEX_MASK) + PcdDb + 4));(
  VOID
);

EFI_STATUS
EFIAPI
the SkuId table looking for our SkuId matches the self-marker(
  VOID
);

EFI_STATUS
EFIAPI
(TableCount != 0) {(
  VOID
);

EFI_STATUS
EFIAPI
our SkuId entry at 'Index'(
  VOID
);

EFI_STATUS
EFIAPI
ADJUST;(
  VOID
);

EFI_STATUS
EFIAPI
found: use slot 0(
  VOID
);

EFI_STATUS
EFIAPI
= 0;(
  VOID
);

EFI_STATUS
EFIAPI
to find an empty slot(
  VOID
);

EFI_STATUS
EFIAPI
= SkuIdTable + 1;(
  VOID
);

EFI_STATUS
EFIAPI
the base table address and adjust offsets(
  VOID
);

EFI_STATUS
EFIAPI
= (UINTN)PcdDb + (LocalTokenNumber & PCD_TOKEN_INDEX_MASK);(
  VOID
);

EFI_STATUS
EFIAPI
data: each SkuId occupies 'SkuIdValue' bytes(
  VOID
);

EFI_STATUS
EFIAPI
(UINT32)(TypeBits | ((TableBase + SkuIdValue * Index - (UINTN)PcdDb) & PCD_TOKEN_INDEX_MASK));(
  VOID
);

EFI_STATUS
EFIAPI
/ NV: each SkuId entry is 4 bytes (UINT32 offset)(
  VOID
);

EFI_STATUS
EFIAPI
TypeBits | ((UINT32)((UINTN)PcdDb + *(UINT32 *)(TableBase + 4) + 4 * Index - (UINTN)PcdDb) & PCD_TOKEN_INDEX_MASK);(
  VOID
);

EFI_STATUS
EFIAPI
types: 5 entries per SkuId (20 bytes each)(
  VOID
);

EFI_STATUS
EFIAPI
TypeBits | ((UINT32)((UINTN)PcdDb + *(UINT32 *)(TableBase + 4) + 20 * Index - (UINTN)PcdDb) & PCD_TOKEN_INDEX_MASK);(
  VOID
);

EFI_STATUS
EFIAPI
be a fixed-size token (bits 24-27 clear)(
  VOID
);

EFI_STATUS
EFIAPI
((LocalTokenNumber & PCD_TYPE_MASK) == 0);(
  VOID
);

EFI_STATUS
EFIAPI
NV-stored: check for dynamic SkuId entries(
  VOID
);

EFI_STATUS
EFIAPI
((LocalTokenNumber & PCD_ATTRIBUTE_SKUID_ENABLED) != 0) {(
  VOID
);

EFI_STATUS
EFIAPI
found: return base size(
  VOID
);

EFI_STATUS
EFIAPI
the SkuId-specific size(
  VOID
);

EFI_STATUS
EFIAPI
fixed-size tokens contribute to the size table index(
  VOID
);

EFI_STATUS
EFIAPI
((TokenSpace[Token] & PCD_TYPE_MASK) == 0) {(
  VOID
);

EFI_STATUS
EFIAPI
has SkuId variants: count = 1 + SkuId table entries(
  VOID
);

EFI_STATUS
EFIAPI
+= *GetSkuIdTableForToken (Token, IsPeiPhase) + 1;(
  VOID
);

EFI_STATUS
EFIAPI
token: always 2 slots (base + 1)(
  VOID
);

EFI_STATUS
EFIAPI
+= 2;(
  VOID
);

EFI_STATUS
EFIAPI
have the SkuId-enabled bit set(
  VOID
);

EFI_STATUS
EFIAPI
((LocalTokenNumber & PCD_ATTRIBUTE_SKUID_ENABLED) != 0);(
  VOID
);

EFI_STATUS
EFIAPI
the PEI database first(
  VOID
);

EFI_STATUS
EFIAPI
(!mIsPeiDbEmpty) {(
  VOID
);

EFI_STATUS
EFIAPI
through to the DXE database(
  VOID
);

EFI_STATUS
EFIAPI
= mPcdDatabaseDxeDb;(
  VOID
);

EFI_STATUS
EFIAPI
function pointer is stored at Node + 16(
  VOID
);

EFI_STATUS
EFIAPI
be a fixed-size-type token(
  VOID
);

EFI_STATUS
EFIAPI
the token is NV-stored, the size field is the NV variable size(
  VOID
);

EFI_STATUS
EFIAPI
((LocalTokenNumber & PCD_ATTRIBUTE_NV) == 0) {(
  VOID
);

EFI_STATUS
EFIAPI
for SkuId variant size update(
  VOID
);

EFI_STATUS
EFIAPI
the size to the maximum allowed(
  VOID
);

EFI_STATUS
EFIAPI
(TokenNumber - 1, Size);(
  VOID
);

EFI_STATUS
EFIAPI
match the exact token size(
  VOID
);

EFI_STATUS
EFIAPI
(*Size != DxePcdGetSize (TokenNumber)) {(
  VOID
);

EFI_STATUS
EFIAPI
callbacks before modifying the value(
  VOID
);

EFI_STATUS
EFIAPI
(TokenNumber < mDxeExTokenCount + 1 ||(
  VOID
);

EFI_STATUS
EFIAPI
direct write (1/2/4/8 bytes)(
  VOID
);

EFI_STATUS
EFIAPI
(*Size) {(
  VOID
);

EFI_STATUS
EFIAPI
(UpdatePcdSizeInfo (TokenNumber - 1, Size)) {(
  VOID
);

EFI_STATUS
EFIAPI
through to NV variable path(
  VOID
);

EFI_STATUS
EFIAPI
= SetNvStorePcdValue ((
  VOID
);

EFI_STATUS
EFIAPI
through the NV variable store path(
  VOID
);

/// direct write (should not normally happen)
EFI_STATUS
EFIAPI
only(
  VOID
);

EFI_STATUS
EFIAPI
(TargetPtr, Buffer, *Size);(
  VOID
);

EFI_STATUS
EFIAPI
1: query the size of the existing NV variable(
  VOID
);

EFI_STATUS
EFIAPI
2: allocate + read the variable(
  VOID
);

EFI_STATUS
EFIAPI
3: overwrite the value at the correct offset(
  VOID
);

EFI_STATUS
EFIAPI
((UINT8 *)Buffer + StringTableSize, ValueBuffer, ValueSize);(
  VOID
);

EFI_STATUS
EFIAPI
4: write the variable back(
  VOID
);

EFI_STATUS
EFIAPI
= gRT->SetVariable ((
  VOID
);

/// create it
EFI_STATUS
EFIAPI
does not exist(
  VOID
);

EFI_STATUS
EFIAPI
path: allocate, read, modify, write back(
  VOID
);

EFI_STATUS
EFIAPI
= AllocatePool (BufferSize);(
  VOID
);

/// check if its GUID matches
EFI_STATUS
EFIAPI
token has valid data(
  VOID
);

EFI_STATUS
EFIAPI
(CompareGuid ((
  VOID
);

EFI_STATUS
EFIAPI
the size first(
  VOID
);

EFI_STATUS
EFIAPI
= gRT->GetVariable ((
  VOID
);

/// must be EFI_NOT_FOUND
EFI_STATUS
EFIAPI
status(
  VOID
);

EFI_STATUS
EFIAPI
(Status == EFI_NOT_FOUND);(
  VOID
);

/// check the "notify on set" flag
EFI_STATUS
EFIAPI
token with data(
  VOID
);

EFI_STATUS
EFIAPI
has the notify flag set(
  VOID
);

EFI_STATUS
EFIAPI
Callback;(
  VOID
);

/// this is an ASSERT condition
EFI_STATUS
EFIAPI
list not found(
  VOID
);

EFI_STATUS
EFIAPI
(EFI_NOT_FOUND);(
  VOID
);

EFI_STATUS
EFIAPI
to open FirmwareVolume2 protocol first(
  VOID
);

EFI_STATUS
EFIAPI
= gBS->OpenProtocol ((
  VOID
);

EFI_STATUS
EFIAPI
back to FirmwareVolumeBlock2 protocol(
  VOID
);

EFI_STATUS
EFIAPI
the internal REP MOVSB-based implementation(
  VOID
);

EFI_STATUS
EFIAPI
(DestinationBuffer, SourceBuffer, Length);(
  VOID
);

EFI_STATUS
EFIAPI
the internal REP STOSB-based implementation(
  VOID
);

EFI_STATUS
EFIAPI
(Buffer, Length);(
  VOID
);

EFI_STATUS
EFIAPI
for buffer overlap(
  VOID
);

EFI_STATUS
EFIAPI
(((UINTN)Source > (UINTN)Destination &&(
  VOID
);

EFI_STATUS
EFIAPI
detected(
  VOID
);

EFI_STATUS
EFIAPI
(FALSE);(
  VOID
);

/// no overlap
EFI_STATUS
EFIAPI
to copy(
  VOID
);

EFI_STATUS
EFIAPI
(*Source != '\0') {(
  VOID
);

#endif /* __PCDDXE_H__ */