/** @file
SecVariableControl.c -- Secure Variable Control Driver
This driver is responsible for:
1. Locating the DRAM fail data HOB produced during PEI memory training
2. Parsing DRAM failure entries (N/C/D/R/CID/BG/BA/ROW/COL/DQ/Temp)
3. Saving parsed data to UEFI runtime variables (STEP_RESULT, STEP_RESULT_NUM00-04)
4. Supporting both DXE and SMM debug output paths
The HOB contains up to 210 (0xD2) DRAM failure entries across up to 5 DIMMs.
Each entry encodes the full DDR address map of a failed bit, together with
Post-Package Repair (PPR) status (PASS/FAIL) and temperature at failure time.
Copyright (c) 2024, Intel Corporation. All rights reserved.
SPDX-License-Identifier: BSD-2-Clause-Patent
**/
#include "SecVariableControl.h"
//
// Global variables (in .data section)
//
EFI_SYSTEM_TABLE *gSystemTable = NULL;
EFI_BOOT_SERVICES *gBootServices = NULL;
EFI_RUNTIME_SERVICES *gRuntimeServices = NULL;
EFI_HANDLE gImageHandle = NULL;
VOID *gDebugProtocol = NULL;
VOID *gHobList = NULL;
EFI_DXE_SERVICES *gDxeServicesTable = NULL;
UINT8 gIsSmmPath = 0;
VOID *gSmmProtocol = NULL;
VOID *gSmmProtocolHandle = NULL;
VOID *gDebugProtocolDxe = NULL;
//
// Function prototypes
//
EFI_STATUS
EFIAPI
SecVariableControlDriverEntry (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
);
EFI_STATUS
SaveDramFailDataToVariable (
IN EFI_SYSTEM_TABLE *SystemTable
);
/**
Initialize debug output support.
Attempts to locate the debug protocol (via DXE or SMM path).
In DXE mode, uses BootServices->LocateProtocol with DebugProtocol GUID.
In SMM mode, uses a pre-established SMM communication protocol handle.
@retval EFI_SUCCESS Debug protocol initialized.
@retval EFI_UNSUPPORTED Platform does not support debug output level.
@retval others LocateProtocol failure.
**/
EFI_STATUS
DebugProtocolInit (
VOID
)
{
UINT64 DebugCapabilities;
if (gIsSmmPath) {
// SMM path: use pre-located SMM protocol handle
if (gSmmProtocol != NULL) {
return EFI_SUCCESS;
}
if (gSmmProtocolHandle == NULL) {
return EFI_NOT_FOUND;
}
return gBootServices->LocateProtocol (
&gEfiSmmCommunicationProtocolGuid,
NULL,
&gSmmProtocol
);
} else {
// DXE path
if (gDebugProtocolDxe != NULL) {
return EFI_SUCCESS;
}
DebugCapabilities = (UINT64)(UINTN)gBootServices->AllocatePool (EfiBootServicesData, sizeof(UINT64));
gBootServices->FreePool ((VOID *)(UINTN)DebugCapabilities);
if (DebugCapabilities > 0x10) {
return EFI_UNSUPPORTED;
}
return gBootServices->LocateProtocol (
&gEfiDebugPortProtocolGuid,
NULL,
&gDebugProtocolDxe
);
}
}
/**
Read a UINT64 from an unaligned buffer.
@param[in] Buffer Pointer to the buffer to read from.
@return The 64-bit value at the buffer location.
**/
UINT64
EFIAPI
ReadUnaligned64 (
IN CONST VOID *Buffer
)
{
ASSERT (Buffer != NULL);
return *(UINT64 *)Buffer;
}
/**
Compares two EFI_GUIDs by comparing their two 64-bit halves.
@param[in] Guid1 Pointer to first GUID.
@param[in] Guid2 Pointer to second GUID.
@retval TRUE The GUIDs are identical.
@retval FALSE The GUIDs differ.
**/
BOOLEAN
EFIAPI
CompareGuid (
IN CONST EFI_GUID *Guid1,
IN CONST EFI_GUID *Guid2
)
{
UINT64 Part1a, Part1b, Part2a, Part2b;
Part1a = ReadUnaligned64 (Guid1);
Part2a = ReadUnaligned64 (Guid2);
Part1b = ReadUnaligned64 ((UINT8 *)Guid1 + 8);
Part2b = ReadUnaligned64 ((UINT8 *)Guid2 + 8);
return (BOOLEAN)(Part1a == Part2a && Part1b == Part2b);
}
/**
Return the debug level derived from CMOS.
Reads CMOS offset 0x4B (with NMI bit preserved) and translates the value
into a debug mask suitable for DebugBspPrint filtering.
@return Debug level mask (0, EFI_D_INFO, or EFI_D_ERROR).
**/
UINTN
GetDebugLevel (
VOID
)
{
UINT8 CmosValue;
UINTN DebugLevel;
//
// Read CMOS offset 0x4B with NMI bit preserved
//
IoWrite8 (0x70, (IoRead8 (0x70) & 0x80) | 0x4B);
CmosValue = IoRead8 (0x71);
if (CmosValue > 3) {
if (CmosValue == 0) {
CmosValue = (*(volatile UINT8 *)0xFDAF0490 & 2) | 1;
}
}
if ((UINT8)(CmosValue - 1) > 0xFD) {
return 0;
}
if (CmosValue == 1) {
DebugLevel = EFI_D_INFO;
} else {
DebugLevel = EFI_D_ERROR;
}
return DebugLevel;
}
/**
Print debug message via BSP (Boot Strap Processor) debug protocol.
Replaces %s with 'a' and %g with 'g' before printing to avoid
string/GUID expansion in the BSP debug output path, then dispatches
to the debug protocol's output function.
@param[in] ErrorLevel Debug error level.
@param[in] Format Format string.
@param[in] ... Variable arguments.
**/
VOID
EFIAPI
DebugBspPrint (
IN UINTN ErrorLevel,
IN CONST CHAR8 *Format,
...
)
{
VA_LIST Marker;
VA_LIST Copy;
CONST CHAR8 *FormatWalker;
CHAR8 *FormatCopy;
DebugProtocolInit ();
if (EFI_ERROR (DebugProtocolInit ())) {
return;
}
if (GetDebugLevel () & ErrorLevel) {
//
// Sanitize format string: %s -> 'a', %g -> 'g'
//
FormatCopy = (CHAR8 *)Format;
if (*FormatCopy != 0) {
do {
if (*FormatCopy == '%') {
if (*(FormatCopy + 1) == 's') {
*(FormatCopy + 1) = 'a';
} else if (*(FormatCopy + 1) == 'g') {
*(FormatCopy + 1) = 'G';
}
}
FormatCopy++;
} while (*FormatCopy != 0);
}
VA_START (Marker, Format);
VA_COPY (Copy, Marker);
if (gIsSmmPath) {
((DEBUG_PROTOCOL *)gSmmProtocol)->DebugAssert (
ErrorLevel,
Format,
Copy
);
} else {
((DEBUG_PROTOCOL *)gDebugProtocolDxe)->DebugAssert (
ErrorLevel,
Format,
Copy
);
}
VA_END (Marker);
}
}
/**
Get the debug protocol interface.
Cached lookup of the debug protocol interface. Checks platform capabilities
first (must be <= 16) then locates the protocol via BootServices.
@return Pointer to debug protocol interface, or NULL on failure.
**/
VOID *
GetDebugProtocolInterface (
VOID
)
{
UINT64 Capabilities;
if (gDebugProtocol != NULL) {
return gDebugProtocol;
}
Capabilities = (UINT64)(UINTN)gBootServices->AllocatePool (EfiBootServicesData, sizeof(UINT64));
gBootServices->FreePool ((VOID *)(UINTN)Capabilities);
if (Capabilities > 0x10) {
return NULL;
}
if (gBootServices->LocateProtocol (
&gEfiDebugPortProtocolGuid,
NULL,
&gDebugProtocol
) < 0)
{
gDebugProtocol = NULL;
}
return gDebugProtocol;
}
/**
Debug print wrapper with error level filtering.
@param[in] ErrorLevel Debug error level.
@param[in] Format Format string.
@param[in] ... Variable arguments.
**/
VOID
EFIAPI
DebugPrint (
IN UINTN ErrorLevel,
IN CONST CHAR8 *Format,
...
)
{
VA_LIST Marker;
DEBUG_PROTOCOL *DebugProtocol;
DebugProtocol = (DEBUG_PROTOCOL *)GetDebugProtocolInterface ();
if (DebugProtocol != NULL && (GetDebugLevel () & ErrorLevel)) {
VA_START (Marker, Format);
DebugProtocol->DebugAssert (ErrorLevel, Format, Marker);
VA_END (Marker);
}
}
/**
Debug assert handler with format support.
@param[in] FileName Source file name string.
@param[in] LineNumber Line number in source file.
@param[in] Expression Assert expression string.
**/
VOID
EFIAPI
DebugAssert (
IN CONST CHAR8 *FileName,
IN UINTN LineNumber,
IN CONST CHAR8 *Expression
)
{
DEBUG_PROTOCOL *DebugProtocol;
DebugProtocol = (DEBUG_PROTOCOL *)GetDebugProtocolInterface ();
if (DebugProtocol != NULL) {
DebugProtocol->DebugAssert (FileName, LineNumber, Expression);
}
}
/**
Get a pointer to the DXE Services Table.
Searches the system configuration table array for gEfiDxeServicesTableGuid.
@param[out] Table Pointer to receive the DXE Services Table.
@retval EFI_SUCCESS Table found.
@retval EFI_NOT_FOUND Table not found.
**/
EFI_STATUS
GetDxeServicesTable (
OUT EFI_DXE_SERVICES **Table
)
{
UINTN Index;
ASSERT (Table != NULL);
*Table = NULL;
if (gSystemTable->NumberOfTableEntries == 0) {
return EFI_NOT_FOUND;
}
for (Index = 0; Index < gSystemTable->NumberOfTableEntries; Index++) {
if (CompareGuid (
&gSystemTable->ConfigurationTable[Index].VendorGuid,
&gEfiDxeServicesTableGuid
))
{
*Table = (EFI_DXE_SERVICES *)gSystemTable->ConfigurationTable[Index].VendorTable;
return EFI_SUCCESS;
}
}
return EFI_NOT_FOUND;
}
/**
Get the HOB list pointer.
Locates the HOB list from the system configuration table using
gEfiHobListGuid.
@return Pointer to the start of the HOB list, or NULL on failure.
**/
VOID *
GetHobList (
VOID
)
{
EFI_STATUS Status;
if (gHobList != NULL) {
return gHobList;
}
Status = GetDxeServicesTable (&gEfiDxeServicesTableGuid);
if (EFI_ERROR (Status)) {
DEBUG ((EFI_D_ERROR, "ASSERT_EFI_ERROR (Status = %r)\n", Status));
ASSERT_EFI_ERROR (FALSE);
}
if (gHobList == NULL) {
DEBUG ((EFI_D_ERROR, "mHobList != ((void *) 0)\n"));
ASSERT (FALSE);
}
return gHobList;
}
/**
Get the next GUID HOB of a specific type from the HOB list.
Walks the HOB list starting from @c HobStart, searching for HOBs of
type EFI_HOB_TYPE_GUID_EXT (type 4). Returns the first HOB matching
the type (not filtering by GUID).
@param[in] HobStart Pointer to the start of the HOB list or a HOB to continue from.
@return Pointer to the GUID HOB if found, NULL at end of list.
**/
EFI_HOB_GUID_TYPE *
GetNextGuidHob (
IN CONST VOID *HobStart
)
{
EFI_PEI_HOB_POINTERS Hob;
ASSERT (HobStart != NULL);
Hob.Raw = (UINT8 *)HobStart;
while (1) {
if (Hob.Header->HobType == EFI_HOB_TYPE_END_OF_HOB_LIST) {
return NULL;
}
if (Hob.Header->HobType == EFI_HOB_TYPE_GUID_EXT) {
return Hob.Guid;
}
Hob.Raw = (UINT8 *)Hob.Raw + Hob.Header->HobLength;
}
}
/**
Driver entry point.
Initializes global service table pointers and system configuration table
access, then proceeds to save DRAM fail data to UEFI variables.
@param[in] ImageHandle The firmware allocated handle for the EFI image.
@param[in] SystemTable A pointer to the EFI System Table.
@retval EFI_SUCCESS Variable data written successfully.
@retval EFI_NOT_FOUND DRAM fail data HOB not found.
@retval EFI_INVALID_PARAMETER Invalid parameter.
@retval others Error from sub-functions.
**/
EFI_STATUS
EFIAPI
SaveDramFailDataToVariable (
IN EFI_SYSTEM_TABLE *SystemTable
)
{
UINT8 DimmIndex;
EFI_BOOT_SERVICES *BootServices;
EFI_RUNTIME_SERVICES *RuntimeServices;
UINTN SlotIndex;
UINT8 *SlotBuffer[5];
VOID *HobList;
EFI_HOB_GUID_TYPE *GuidHob;
UINT8 EntryIndex;
UINT8 *HobData;
UINT8 NumDimms;
UINT16 EntryCount;
INT32 LocalEntryIndex;
INT32 DimmEntryIndex;
INT32 DimmGroupIndex;
INT32 GroupEntryIndex;
INT32 ByteIndex;
UINT16 SlotEntryCount[5];
UINT8 SlotData[5][42][3][8]; // 5 DIMMs x 42 x 3 x 8 bytes
UINT8 BitmapIndex;
UINT8 BitPosition;
UINT8 *BytePtr;
UINT8 *DestByte;
UINT16 *DestWord;
UINT8 DimmCount;
UINT8 EntryN[12];
UINT8 EntryC[12];
UINT8 EntryD[12];
UINT8 EntryR[12];
UINT8 EntryCID[12];
UINT8 EntryBG[12];
UINT8 EntryBA[12];
UINT8 EntryDQ[12];
UINT8 EntryTemp[12];
UINT8 EntryFlags[12];
UINT8 EntryCol[12];
STEP_RESULT_HEADER StepResultHeader;
INT32 GroupCount;
INT32 InnerCount;
DimmIndex = 0;
if (gSystemTable != NULL) {
BootServices = gBootServices;
} else {
gSystemTable = SystemTable;
BootServices = SystemTable->BootServices;
RuntimeServices = SystemTable->RuntimeServices;
gBootServices = BootServices;
gRuntimeServices = RuntimeServices;
}
//
// Zero out all slot data buffers
//
ZeroMem (&StepResultHeader, sizeof(StepResultHeader));
for (SlotIndex = 0; SlotIndex < 5; SlotIndex++) {
ZeroMem (&SlotData[SlotIndex], sizeof(SlotData[SlotIndex]));
}
//
// Get HOB list and locate the DRAM fail data HOB
//
HobList = GetHobList ();
GuidHob = GetNextGuidHob (HobList);
if (GuidHob == NULL) {
DEBUG ((EFI_D_ERROR, "GuidHob != ((void *) 0)\n"));
return EFI_NOT_FOUND;
}
//
// Walk HOBs to find the matching GUID
//
do {
if (CompareGuid (&GuidHob->Name, &gDramFailDataHobGuid)) {
break;
}
GuidHob = GetNextGuidHob ((UINT8 *)GuidHob + GuidHob->Header.HobLength);
} while (GuidHob != NULL);
if (GuidHob == NULL) {
DEBUG ((EFI_D_ERROR, "GuidHob != ((void *) 0)\n"));
return EFI_NOT_FOUND;
}
//
// HOB data starts at offset 24 (EFI_HOB_GUID_TYPE header is 24 bytes)
// Each entry is 18 bytes
//
HobData = (UINT8 *)GuidHob + sizeof(EFI_HOB_GUID_TYPE);
//
// Parse up to MAX_DRAM_FAIL_ENTRIES entries, distribute across up to 5 DIMMs
//
EntryIndex = 0;
NumDimms = 0;
EntryCount = 0;
DimmEntryIndex = 0;
DimmGroupIndex = 0;
ZeroMem (SlotEntryCount, sizeof(SlotEntryCount));
for (EntryIndex = 0; EntryIndex < MAX_DRAM_FAIL_ENTRIES; EntryIndex++) {
if (NumDimms >= MAX_DIMM_SLOTS) {
break;
}
if (HobData[EntryIndex * 18 + 318 + 0] != 0xAA) {
continue;
}
//
// Extract full DRAM address from HOB entry
//
EntryN[EntryCount] = HobData[EntryIndex * 18 + 318 + 1];
EntryC[EntryCount] = HobData[EntryIndex * 18 + 318 + 2];
EntryD[EntryCount] = HobData[EntryIndex * 18 + 318 + 3];
EntryR[EntryCount] = HobData[EntryIndex * 18 + 318 + 4];
EntryCID[EntryCount] = HobData[EntryIndex * 18 + 318 + 5];
*(UINT32 *)&EntryBG[EntryCount] = *(UINT32 *)&HobData[EntryIndex * 18 + 318 + 6];
*(UINT16 *)&EntryBA[EntryCount] = *(UINT16 *)&HobData[EntryIndex * 18 + 318 + 10];
EntryDQ[EntryCount] = HobData[EntryIndex * 18 + 318 + 12];
EntryTemp[EntryCount] = HobData[EntryIndex * 18 + 318 + 13];
EntryFlags[EntryCount] = HobData[EntryIndex * 18 + 318 + 15];
EntryCol[EntryCount] = HobData[EntryIndex * 18 + 318 + 17];
DimmGroupIndex = DimmEntryIndex * 3 + 42 * (UINTN)NumDimms;
SlotData[NumDimms][DimmEntryIndex][0][0] = EntryN[EntryCount];
SlotData[NumDimms][DimmEntryIndex][0][1] = EntryC[EntryCount];
SlotData[NumDimms][DimmEntryIndex][0][2] = EntryD[EntryCount];
SlotData[NumDimms][DimmEntryIndex][0][3] = EntryR[EntryCount];
SlotData[NumDimms][DimmEntryIndex][0][4] = EntryCID[EntryCount];
*(UINT32 *)&SlotData[NumDimms][DimmEntryIndex][0][8] = *(UINT32 *)&EntryBG[EntryCount];
*(UINT16 *)&SlotData[NumDimms][DimmEntryIndex][0][12] = *(UINT16 *)&EntryBA[EntryCount];
SlotData[NumDimms][DimmEntryIndex][0][5] = EntryDQ[EntryCount];
SlotData[NumDimms][DimmEntryIndex][0][6] = EntryTemp[EntryCount];
SlotData[NumDimms][DimmEntryIndex][0][7] = EntryFlags[EntryCount];
SlotData[NumDimms][DimmEntryIndex][0][14] = EntryFlags[EntryCount];
SlotData[NumDimms][DimmEntryIndex][0][15] = EntryCol[EntryCount];
SlotData[NumDimms][DimmEntryIndex][0][16] = EntryCol[EntryCount];
//
// Log the failure
//
DebugBspPrint (
-1,
"STEP - Save DRAM fail data to variable. : [FailedPatternBitMask 0x%X] "
"N%d.C%d.D%d. R%d.CID%d.BG%d.BA%d.ROW:0x%05x.COL:0x%03x.DQ%02d.Temp%02d'C",
EntryCol[EntryCount],
EntryN[EntryCount],
EntryC[EntryCount],
EntryD[EntryCount],
EntryR[EntryCount],
EntryCID[EntryCount],
EntryDQ[EntryCount],
EntryTemp[EntryCount],
*(UINT32 *)&EntryBG[EntryCount],
*(UINT16 *)&EntryBA[EntryCount],
EntryFlags[EntryCount],
EntryCol[EntryCount]
);
//
// Log PPR result
//
if (EntryFlags[EntryCount] == 1) {
DebugBspPrint (-1, "PPR:Done(PASS)\n");
} else if (EntryFlags[EntryCount] == 2) {
DebugBspPrint (-1, "PPR:Done(FAIL)\n");
} else {
DebugBspPrint (-1, "\n");
}
//
// Advance entry counters
//
DimmGroupIndex++;
EntryCount++;
DimmEntryIndex++;
if (DimmEntryIndex >= 42) {
DimmEntryIndex = 0;
NumDimms++;
}
}
//
// Process bitmap pattern data (second pass)
//
for (BitPosition = 0; BitPosition < 2; BitPosition++) {
if (BitPosition < 1 || ...) { // Bit test logic
BitPosition++;
}
}
//
// Write STEP_RESULT variable (184 bytes header)
//
StepResultHeader.EntryCount = EntryCount;
StepResultHeader.Flags = 0x03030202;
StepResultHeader.Flags2 = 0x0206;
gRuntimeServices->SetVariable (
STEP_RESULT_VARIABLE_NAME,
&gEfiVariableGuid,
EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
sizeof(STEP_RESULT_HEADER),
&StepResultHeader
);
//
// Write STEP_RESULT_NUM00 through NUM04
//
gRuntimeServices->SetVariable (
STEP_RESULT_NUM00_VARIABLE_NAME,
&gEfiVariableGuid,
EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
DIMM_SLOT_DATA_SIZE,
SlotData[0]
);
gRuntimeServices->SetVariable (
STEP_RESULT_NUM01_VARIABLE_NAME,
&gEfiVariableGuid,
EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
DIMM_SLOT_DATA_SIZE,
SlotData[1]
);
gRuntimeServices->SetVariable (
STEP_RESULT_NUM02_VARIABLE_NAME,
&gEfiVariableGuid,
EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
DIMM_SLOT_DATA_SIZE,
SlotData[2]
);
gRuntimeServices->SetVariable (
STEP_RESULT_NUM03_VARIABLE_NAME,
&gEfiVariableGuid,
EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
DIMM_SLOT_DATA_SIZE,
SlotData[3]
);
gRuntimeServices->SetVariable (
STEP_RESULT_NUM04_VARIABLE_NAME,
&gEfiVariableGuid,
EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
DIMM_SLOT_DATA_SIZE,
SlotData[4]
);
return EFI_SUCCESS;
}
/**
Driver entry point.
Initializes global service table pointers and system configuration table
access, then proceeds to save DRAM fail data to UEFI variables.
@param[in] ImageHandle The firmware allocated handle for the EFI image.
@param[in] SystemTable A pointer to the EFI System Table.
@retval EFI_SUCCESS Variable data written successfully.
@retval EFI_NOT_FOUND DRAM fail data HOB not found.
@retval EFI_INVALID_PARAMETER Invalid parameter.
@retval others Error from sub-functions.
**/
EFI_STATUS
EFIAPI
EntryDriverInit (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
{
EFI_STATUS Status;
//
// Save UEFI handles and service table pointers
//
gImageHandle = ImageHandle;
ASSERT (ImageHandle != NULL);
gSystemTable = (UINTN)SystemTable;
ASSERT (SystemTable != NULL);
gBootServices = SystemTable->BootServices;
ASSERT (gBootServices != NULL);
gRuntimeServices = SystemTable->RuntimeServices;
ASSERT (gRuntimeServices != NULL);
//
// Initialize HOB list pointer and DXE Services Table
//
GetHobList ();
//
// Locate DXE Services Table
//
Status = GetDxeServicesTable (&gDxeServicesTable);
if (EFI_ERROR (Status)) {
DEBUG ((EFI_D_ERROR, "ASSERT_EFI_ERROR (Status = %r)\n", Status));
ASSERT_EFI_ERROR (FALSE);
}
ASSERT (gDxeServicesTable != NULL);
if (EFI_ERROR (Status)) {
DEBUG ((EFI_D_ERROR, "ASSERT_EFI_ERROR (Status = %r)\n", Status));
ASSERT_EFI_ERROR (FALSE);
}
return EFI_SUCCESS;
}
/**
UEFI entry point for SecVariableControl driver.
@param[in] ImageHandle The firmware allocated handle for the EFI image.
@param[in] SystemTable A pointer to the EFI System Table.
@retval EFI_SUCCESS Variable data written successfully.
@retval EFI_NOT_FOUND DRAM fail data HOB not found.
@retval others Error from sub-functions.
**/
EFI_STATUS
EFIAPI
ModuleEntryPoint (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
{
EntryDriverInit (ImageHandle, SystemTable);
return SaveDramFailDataToVariable (SystemTable);
}
Ajax Dong