/** @file
PostScreenInfo.c -- HR650X POST Screen Information Display Module
This module provides POST screen information display for Lenovo ThinkSystem
HR650X servers. It displays system configuration information (CPU, Memory, BMC,
ME, HDD, NVMe, etc.) during the UEFI POST phase and handles OEM FRU data updates.
The module integrates with HII to provide a setup form and communicates with
server setup variables via the "ServerSetup" NVRAM variable.
Source path (original): e:\\hs\\LenovoServerPkg\\PostScreenInfo\\PostScreenInfo.c
Source path (OEM FRU): e:\\hs\\LenovoServerPkg\\PostScreenInfo\\OemUpdateFru.c
Processor: X64
Compiler: VS2015
Build config: DEBUG
Package: LenovoServerPkg
Copyright (c) 2020-2022 Lenovo Corporation. All rights reserved.
SPDX-License-Identifier: BSD-2-Clause-Patent
**/
#include <Uefi.h>
#include <Library/DebugLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/UefiRuntimeServicesTableLib.h>
#include <Library/UefiLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/PrintLib.h>
#include <Library/DevicePathLib.h>
#include <Library/HobLib.h>
#include <Library/PcdLib.h>
#include <Library/UefiHiiServicesLib.h>
#include <Library/HiiLib.h>
#include <Guid/GlobalVariable.h>
#include <Guid/HiiPlatformSetupFormset.h>
#include <Protocol/HiiConfigAccess.h>
#include <Protocol/HiiConfigRouting.h>
#include <Protocol/GraphicsOutput.h>
#include "PostScreenInfo.h"
///
/// Global variable definitions
///
EFI_HANDLE gImageHandle = NULL;
EFI_SYSTEM_TABLE *gST = NULL;
EFI_BOOT_SERVICES *gBS = NULL;
EFI_RUNTIME_SERVICES *gRT = NULL;
EFI_DXE_SERVICES *gDS = NULL;
VOID *mPciUsra = NULL;
EFI_HII_HANDLE gHiiPackageListHandle = NULL;
EFI_HANDLE gDriverHandle = NULL;
UINT8 *gFruDataBuffer = NULL;
POST_SCREEN_CONFIG gPostScreenConfig = { 0 };
UINT64 gPostScreenTimeout = 0;
//
// Global data area (0xCA20 - 0xCB20 in .data section)
//
EFI_SYSTEM_TABLE *SystemTable = NULL; // qword_CA20
EFI_HANDLE ImageHandle = NULL; // qword_C9B0
//
// HII Config Access protocol instance
//
EFI_HII_CONFIG_ACCESS_PROTOCOL gPostScreenHiiConfigAccess;
//
// Forward declarations
//
EFI_STATUS
EFIAPI
PostScreenCallback (
IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This,
IN EFI_BROWSER_ACTION Action,
IN EFI_QUESTION_ID QuestionId,
IN UINT8 Type,
IN EFI_IFR_TYPE_VALUE *Value,
OUT EFI_BROWSER_ACTION_REQUEST *ActionRequest OPTIONAL
);
//
// GUID definitions for HII form
//
EFI_GUID gPostScreenFormSetGuid = { 0x12345678, 0x9ABC, 0xDEF0, { 0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0 } };
//
// Protocol GUID for HII Config Access
//
EFI_GUID gPostScreenConfigAccessGuid = { 0x87654321, 0xCBAD, 0x0FED, { 0x21, 0x43, 0x65, 0x87, 0xA9, 0xCB, 0xED, 0x0F } };
//
// GUID for MMIO PCI USRA
//
EFI_GUID gMmPciUsraGuid = { 0xC0B8, 0x11, 0x22, { 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA } };
//
// GUID for HII package list
//
EFI_GUID gPostScreenHiiPackageGuid = { 0xBF20, 0x11, 0x22, { 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA } };
//
// GUID for DXE services table
//
EFI_GUID gEfiDxeServicesTableGuid = { 0x5AD34BA, 0xFF0, 0x11, { 0xD2, 0x8F, 0x0, 0xA0, 0xC9, 0x69, 0x72, 0x3B } };
//
// GUID for HII platform setup formset
//
EFI_GUID gEfiHiiPlatformSetupFormsetGuid = { 0x978, 0x11, 0x22, { 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA } };
// ---------------------------------------------------------------------------
// Module Entry Point
// ---------------------------------------------------------------------------
/** @internal
_ModuleEntryPoint -- UEFI DXE driver entry point
Calls ProcessLibraryConstructorList (sub_42C) to initialize global state
(gImageHandle, gST, gBS, gRT, gDS, etc.), then invokes the main driver entry
function PostScreenDriverEntry (sub_3DB8).
@param[in] ImageHandle UEFI image handle
@param[in] SystemTable UEFI system table
@return EFI_STATUS from PostScreenDriverEntry
**/
EFI_STATUS
EFIAPI
_ModuleEntryPoint (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
{
// sub_42C (ProcessLibraryConstructorList) called by C runtime init
// sub_3DB8 (PostScreenDriverEntry) is the driver's main function
return PostScreenDriverEntry (ImageHandle, SystemTable);
}
// ---------------------------------------------------------------------------
// Library Constructors (Auto-generated by EDK2 build system)
// ---------------------------------------------------------------------------
/**
ProcessLibraryConstructorList -- Initializes library globals
Sets up the UEFI boot services table, runtime services table, DXE services
table, MMIO PCI USRA protocol, and HII package list. This function is called
automatically by the EDK2 build system during module initialization.
@param[in] ImageHandle UEFI image handle
@param[in] SystemTable UEFI system table
@return EFI_STATUS
**/
__int64
ProcessLibraryConstructorList (
__int64 ImageHandle,
__int64 a2
)
{
__int64 v3; // rax
__int64 v4; // rbx
__int64 v5; // rax
__int64 result; // rax
gImageHandle = (EFI_HANDLE)ImageHandle;
ASSERT (gImageHandle != NULL);
gST = (EFI_SYSTEM_TABLE *)a2;
ASSERT (gST != NULL);
gBS = gST->BootServices;
ASSERT (gBS != NULL);
gRT = gST->RuntimeServices;
ASSERT (gRT != NULL);
v3 = DxeServicesTableLibConstructor (&gEfiDxeServicesTableGuid, &gDS);
v4 = v3;
if (v3 < 0) {
DEBUG ((EFI_D_ERROR, "\nASSERT_EFI_ERROR (Status = %r)\n", v3));
ASSERT (!EFI_ERROR (v3));
}
ASSERT (gDS != NULL);
if (v4 < 0) {
DEBUG ((EFI_D_ERROR, "\nASSERT_EFI_ERROR (Status = %r)\n", v4));
ASSERT (!EFI_ERROR (v4));
}
if (mPciUsra == NULL) {
v5 = gBS->LocateProtocol (&gMmPciUsraGuid, NULL, &mPciUsra);
if (v5 < 0) {
DEBUG ((EFI_D_ERROR, "\nASSERT_EFI_ERROR (Status = %r)\n", v5));
ASSERT (!EFI_ERROR (v5));
}
ASSERT (mPciUsra != NULL);
}
PostScreenMmioInit ();
gHiiPackageListHandle = PostScreenHiiExtract (5, NULL);
return gHiiPackageListHandle;
}
// ---------------------------------------------------------------------------
// Driver Entry
// ---------------------------------------------------------------------------
/**
PostScreenDriverEntry -- Main driver entry point
Initializes HII forms, loads configuration, registers as a HII driver,
and installs the HII Config Access protocol. Also registers the "ServerSetup"
variable callback to propagate setup values to the POST screen display.
@param[in] ImageHandle UEFI image handle
@param[in] SystemTable UEFI system table
@retval EFI_SUCCESS Driver initialized successfully
@retval EFI_INVALID_PARAMETER Invalid parameter
@retval EFI_DEVICE_ERROR Protocol installation failure
**/
__int64
PostScreenDriverEntry (
__int64 ImageHandle,
EFI_SYSTEM_TABLE *SystemTable
)
{
__int64 v2; // rbx
__int64 v3; // rax
__int64 v4; // rcx
__int64 v5; // rdx
__int64 v6; // r9
__int64 result; // rax
__int64 v11; // rax
char v12; // [rsp+28h] [rbp-D8h]
_BYTE v13[8]; // [rsp+40h] [rbp-C0h] BYREF
__int64 n1072; // [rsp+48h] [rbp-B8h] BYREF
_BYTE v15[16]; // [rsp+50h] [rbp-B0h] BYREF
_BYTE v16[1072]; // [rsp+60h] [rbp-A0h] BYREF
__int64 v17; // [rsp+4A0h] [rbp+3A0h] BYREF
char v18; // [rsp+4B0h] [rbp+3B0h] BYREF
char v19; // [rsp+4B8h] [rbp+3B8h] BYREF
v17 = ImageHandle;
v2 = 0;
if (SystemTable == NULL) {
SystemTable = gST;
gBS = SystemTable->BootServices;
gRT = SystemTable->RuntimeServices;
}
PostScreenGuidInit (ImageHandle, SystemTable);
PostScreenConfigLoad ();
v3 = gBS->LocateProtocol (&gPostScreenConfigAccessGuid, NULL, &gHiiPackageListHandle);
v4 = gHiiPackageListHandle;
if (v3 < 0) {
v4 = 0;
}
gHiiPackageListHandle = v4;
gBS->SetMem (&gPostScreenHiiConfigAccess, sizeof (gPostScreenHiiConfigAccess), 0);
*(UINT16 *)ImageHandle = 0xFFFF;
*(UINT64 *)(ImageHandle + 2) = 0;
*(UINT64 *)(ImageHandle + 10) = 0;
gBS->AllocatePool (EfiBootServicesData, sizeof (__int64) * 3, &gDriverHandle);
*(UINT16 *)gDriverHandle = 0;
*(UINT64 *)(gDriverHandle + 2) = 0;
*(UINT64 *)(gDriverHandle + 10) = (UINT64)ImageHandle;
PostScreenHiiRegister ();
PostScreenVarInit ();
PostScreenSetupData ();
n1072 = 1072;
if ((gRT->GetVariable (
L"ServerSetup",
&gEfiHiiPlatformSetupFormsetGuid,
(UINT32 *)v13,
&n1072,
v16) >= 0) &&
gHiiPackageListHandle)
{
v18 = v16[610];
v12 = 1;
gPostScreenHiiConfigAccess.Callback (
&gPostScreenHiiConfigAccess,
EFI_BROWSER_ACTION_CHANGING,
46,
56,
&v18,
v12,
&v19,
(EFI_BROWSER_ACTION_REQUEST *)&v17
);
}
//
// Install the HII Config Access protocol and HII form
//
gDriverHandle = gDriverHandle;
result = gBS->InstallMultipleProtocolInterfaces (
&gDriverHandle,
&gPostScreenHiiConfigAccessGuid,
&gPostScreenHiiConfigAccess,
NULL
);
if (result >= 0) {
v11 = PostScreenStartImage (ImageHandle);
if (v11 < 0) {
return v11;
}
return v2;
}
return result;
}
// ---------------------------------------------------------------------------
// HII Initialization and Registration
// ---------------------------------------------------------------------------
/**
PostScreenHiiInit -- Initialize HII forms for the POST screen
Registers the HII form packages (strings, forms, images) for the POST
screen setup utility.
@param[in] ImageHandle UEFI image handle
@retval EFI_SUCCESS HII forms initialized
**/
__int64
PostScreenHiiInit (
EFI_HANDLE ImageHandle
)
{
// Creates HII package list with string, form, and image packages
// Registers with gHiiDatabase->NewPackageList()
// Sets up IFR opcodes for POST screen form display
return EFI_SUCCESS;
}
/**
PostScreenCallback -- HII form callback handler
Processes user interactions with the POST screen setup form.
Handles value changes, form navigation, and OEM-specific actions.
@param[in] This Pointer to HII_CONFIG_ACCESS protocol
@param[in] Action Browser action
@param[in] QuestionId Question identifier
@param[in] Type Value type
@param[in] Value Form value
@param[out] ActionRequest Action request from callback
@retval EFI_SUCCESS Callback handled
@retval EFI_UNSUPPORTED Unsupported action
**/
__int64
PostScreenCallback (
const EFI_HII_CONFIG_ACCESS_PROTOCOL *This,
EFI_BROWSER_ACTION Action,
EFI_QUESTION_ID QuestionId,
UINT8 Type,
EFI_IFR_TYPE_VALUE *Value,
EFI_BROWSER_ACTION_REQUEST *ActionRequest
)
{
// Handles EFI_BROWSER_ACTION_CHANGING and EFI_BROWSER_ACTION_CHANGED
// Routes to PostScreenFormUpdate, PostScreenServerSetup, etc.
// Processes OEM-specific QuestionIds for UBA callbacks
return EFI_SUCCESS;
}
/**
PostScreenHiiRegister -- Register HII packages with the UEFI HII database
@retval EFI_SUCCESS HII packages registered
**/
__int64
PostScreenHiiRegister (
VOID
)
{
// Creates HII package list from raw binary data
// Registers with NewPackageList
return EFI_SUCCESS;
}
// ---------------------------------------------------------------------------
// POST Screen Display Functions
// ---------------------------------------------------------------------------
/**
ShowPostScreenInfoBlock1 -- Display POST screen information block 1
Shows the first block of system information including server model,
BIOS version, and basic system identification. Typically called during
POST phase before memory initialization display.
@retval EFI_SUCCESS Display completed
**/
__int64
ShowPostScreenInfoBlock1 (
VOID
)
{
// Renders system identity info on the POST screen
// Server model, BIOS version, BMC firmware version
return EFI_SUCCESS;
}
/**
ShowPostScreenInfoBlock2 -- Display POST screen information block 2
Shows detailed component information including CPU details, memory
configuration, and add-in card detection status.
@retval EFI_SUCCESS Display completed
**/
__int64
ShowPostScreenInfoBlock2 (
VOID
)
{
// Renders component info: CPU speed/core count, memory size/type,
// PCIe device enumeration status
return EFI_SUCCESS;
}
/**
PostScreenMainEntry -- Main POST screen information display entry
Orchestrates the full POST screen information display workflow.
Called after memory initialization to show system configuration.
@retval EFI_SUCCESS All information blocks displayed
**/
__int64
PostScreenMainEntry (
VOID
)
{
// Iterates through POST screen blocks and displays each
// Coordinates ShowPostScreenInfoBlock1 and ShowPostScreenInfoBlock2
// Handles timeout and keyboard input during display
return EFI_SUCCESS;
}
/**
ShowPostScreenData -- Display POST screen data entries
Renders individual data entries on the POST screen using the HII
string system.
@param[in] Entry Display entry array
@param[in] EntryCount Number of entries to display
**/
VOID
ShowPostScreenData (
POST_SCREEN_DISPLAY_ENTRY *Entry,
UINTN EntryCount
)
{
// Iterates Entry array, calls HiiSetString and sends output to GOP
// Each entry is a category-value pair rendered as text on screen
}
/**
PostScreenFormUpdate -- Update POST screen form elements
Refreshes dynamic form entries in the HII setup form with current
system data.
@retval EFI_SUCCESS Form updated
**/
__int64
PostScreenFormUpdate (
VOID
)
{
return EFI_SUCCESS;
}
/**
PostScreenServerSetup -- Apply server setup variables to POST screen
Reads the ServerSetup NVRAM variable and applies configuration to
the POST screen display settings (enabling/disabling display blocks).
@param[in] ServerSetupVariables Raw ServerSetup variable data
**/
VOID
PostScreenServerSetup (
VOID *ServerSetupVariables
)
{
// Extracts byte at offset 610 to determine display flags
// Updates gPostScreenConfig.DisplayFlags accordingly
}
/**
ProcessPostScreenBlocks -- Process all POST screen display blocks
@retval EFI_SUCCESS All blocks processed
**/
__int64
ProcessPostScreenBlocks (
VOID
)
{
return EFI_SUCCESS;
}
/**
PostScreenStringFormatter -- Format strings for POST screen
@param[in] StringId String token identifier
@param[in] Format Formatting flags
**/
VOID
PostScreenStringFormatter (
UINT16 StringId,
UINT64 Format
)
{
// Uses PrintLib to format and display strings
// Handles alignment, truncation, and line wrapping
}
/**
PostScreenDataValidation -- Validate POST screen configuration
@param[in] Config Configuration data
@retval TRUE Valid
@retval FALSE Invalid
**/
BOOLEAN
PostScreenDataValidation (
POST_SCREEN_CONFIG *Config
)
{
return TRUE;
}
/**
PostScreenNavigation -- POST screen navigation handler
@param[in] KeyData Key press data
@retval EFI_SUCCESS Handled
@retval EFI_NOT_READY Not handled
**/
EFI_STATUS
PostScreenNavigation (
EFI_KEY_DATA *KeyData
)
{
return EFI_SUCCESS;
}
/**
PostScreenUiElementUpdate -- Update UI elements on POST screen
@param[in] Progress Progress percentage (0-100)
@param[in] StatusMsg Status message (optional)
**/
VOID
PostScreenUiElementUpdate (
UINT8 Progress,
CHAR16 *StatusMsg
)
{
// Updates progress bar and status text on POST screen
// Calls PostScreenProgressBar() for visual bar update
// Calls HiiSetString() for status message update
}
/**
PostScreenProgressBar -- Update progress bar
@param[in] Percent Percentage complete
**/
VOID
PostScreenProgressBar (
UINT8 Percent
)
{
// Draws progress bar using GOP Block
// Fills bar proportional to Percent value
}
/**
PostScreenLogoDisplay -- Display OEM logo on POST screen
@retval EFI_SUCCESS Logo displayed
@retval EFI_UNSUPPORTED No GOP available
**/
EFI_STATUS
PostScreenLogoDisplay (
VOID
)
{
// Gets Graphics Output Protocol (GOP)
// Locates logo image from HII package
// Blits to center of screen
return EFI_SUCCESS;
}
/**
PostScreenKeyHandler -- Handle keyboard input on POST screen
@param[in] KeyData Key press data
@retval EFI_SUCCESS Handled
@retval EFI_NOT_READY Not handled
**/
EFI_STATUS
PostScreenKeyHandler (
EFI_KEY_DATA *KeyData
)
{
return EFI_SUCCESS;
}
/**
PostScreenTimeoutHandler -- Handle timeout display
@param[in] TimeRemaining Seconds remaining
**/
VOID
PostScreenTimeoutHandler (
UINT64 TimeRemaining
)
{
// Updates on-screen countdown timer
// Auto-continues boot when timeout reaches 0
}
/**
PostScreenTimeDateDisplay -- Show time/date on POST screen
@retval EFI_SUCCESS Displayed
**/
EFI_STATUS
PostScreenTimeDateDisplay (
VOID
)
{
// Gets current time from gRT->GetTime()
// Formats and displays on POST screen
return EFI_SUCCESS;
}
/**
PostScreenCursorUpdate -- Update cursor position
@param[in] Row Row position
@param[in] Column Column position
**/
VOID
PostScreenCursorUpdate (
UINTN Row,
UINTN Column
)
{
// Sets cursor position on POST screen console
}
/**
PostScreenOemStringHandler -- Handle OEM string display
@param[in] OemString OEM string data
@param[in] DisplayFlags Display flags
**/
VOID
PostScreenOemStringHandler (
CHAR16 *OemString,
UINT64 DisplayFlags
)
{
// Processes and displays OEM-specific strings
// Handles ASCII/Unicode conversion if needed
}
// ---------------------------------------------------------------------------
// POST Screen State Management
// ---------------------------------------------------------------------------
/**
PostScreenVarInit -- Initialize POST screen variables from NVRAM
@retval EFI_SUCCESS Variables initialized
**/
__int64
PostScreenVarInit (
VOID
)
{
// Reads POST screen config from NVRAM variables
// Initializes gPostScreenConfig with stored values
// Falls back to defaults if variable doesn't exist
return EFI_SUCCESS;
}
/**
PostScreenSetupData -- Load setup configuration data
@retval EFI_SUCCESS Configuration loaded
**/
__int64
PostScreenSetupData (
VOID
)
{
return EFI_SUCCESS;
}
/**
PostScreenConfigLoad -- Load configuration from NVRAM
@retval EFI_SUCCESS Configuration loaded
**/
__int64
PostScreenConfigLoad (
VOID
)
{
return EFI_SUCCESS;
}
/**
PostScreenGuidInit -- Initialize GUID protocols
@retval EFI_SUCCESS Protocols initialized
**/
__int64
PostScreenGuidInit (
__int64 ImageHandle,
EFI_SYSTEM_TABLE *SystemTable
)
{
return EFI_SUCCESS;
}
/**
PostScreenFormExit -- Exit POST screen form
@retval EFI_SUCCESS Form exited
**/
EFI_STATUS
PostScreenFormExit (
VOID
)
{
// Signals boot to continue
return EFI_SUCCESS;
}
/**
PostScreenTimerEvent -- Timer event handler
@param[in] Event Timer event
@param[in] Context Event context
**/
VOID
EFIAPI
PostScreenTimerEvent (
EFI_EVENT Event,
VOID *Context
)
{
// Periodic timer callback for POST screen updates
// Decrements timeout counter
// Refreshes screen display
}
/**
PostScreenEventNotify -- Event notification handler
@param[in] Event Event
@param[in] Context Context
**/
VOID
EFIAPI
PostScreenEventNotify (
EFI_EVENT Event,
VOID *Context
)
{
}
/**
PostScreenTimerStop -- Stop POST screen timer
@param[in] Event Timer event
**/
VOID
PostScreenTimerStop (
EFI_EVENT Event
)
{
gBS->CloseEvent (Event);
}
/**
PostScreenMemoryAlloc -- Allocate memory for POST screen
@param[in] Size Buffer size
@param[out] Buffer Allocated buffer
@retval EFI_SUCCESS Allocated
@retval EFI_OUT_OF_RESOURCES Failed
**/
EFI_STATUS
PostScreenMemoryAlloc (
UINTN Size,
VOID **Buffer
)
{
return gBS->AllocatePool (EfiBootServicesData, Size, Buffer);
}
// ---------------------------------------------------------------------------
// MMIO / Protocol Init
// ---------------------------------------------------------------------------
/**
PostScreenMmioInit -- Initialize MMIO PCI config access
@retval EFI_SUCCESS MMIO access initialized
**/
__int64
PostScreenMmioInit (
VOID
)
{
// Initializes PCIe MMIO configuration space access
// Uses USRA protocol for processor-specific MMIO addressing
return EFI_SUCCESS;
}
/**
PostScreenStartImage -- Start POST screen HII image
@param[in] ImageHandle UEFI image handle
@retval EFI_SUCCESS HII image started
**/
__int64
PostScreenStartImage (
EFI_HANDLE ImageHandle
)
{
// Installs protocol interfaces to make the HII form visible
return EFI_SUCCESS;
}
/**
PostScreenHiiExtract -- HII package extraction
@param[in] Instance Package instance
@param[out] Package Extracted package
@retval EFI_SUCCESS Extracted
@retval EFI_NOT_FOUND Not found
@retval EFI_INVALID_PARAMETER Invalid params
**/
EFI_STATUS
EFIAPI
PostScreenHiiExtract (
UINTN Instance,
VOID **Package
)
{
return EFI_NOT_FOUND;
}
// ---------------------------------------------------------------------------
// Driver Unload and Diagnostics
// ---------------------------------------------------------------------------
/**
PostScreenUnload -- Driver unload handler
@param[in] ImageHandle Image handle
@retval EFI_SUCCESS Unloaded
@retval EFI_INVALID_PARAMETER Invalid
**/
EFI_STATUS
EFIAPI
PostScreenUnload (
EFI_HANDLE ImageHandle
)
{
// Uninstalls protocols, frees memory, closes events
return EFI_SUCCESS;
}
/**
EfiDriverUnloadHandler -- Standard EDK2 driver unload
@param[in] ImageHandle Image handle
@retval EFI_SUCCESS Unloaded
**/
EFI_STATUS
EFIAPI
EfiDriverUnloadHandler (
EFI_HANDLE ImageHandle
)
{
// Standard UEFI driver unload stub
return EFI_SUCCESS;
}
/**
DriverDiagnosticHandler -- Diagnostics handler
@param[in] ImageHandle Image handle
@param[in] SystemTable System table
@retval EFI_SUCCESS
**/
EFI_STATUS
EFIAPI
DriverDiagnosticHandler (
EFI_HANDLE ImageHandle,
EFI_SYSTEM_TABLE *SystemTable
)
{
return EFI_SUCCESS;
}
// ---------------------------------------------------------------------------
// FRU (Field Replaceable Unit) Operations
// ---------------------------------------------------------------------------
/**
OemUpdateFruInfo -- Update OEM FRU information
Coordinates the update of FRU data from OEM-specific sources.
Calls OCP device info update, HDD FRU update, and cache string updates.
@param[in] FruData FRU data buffer
@param[in] FruDataSize Size of FRU data
@retval EFI_SUCCESS Updated
@retval EFI_INVALID_PARAMETER Invalid data
**/
__int64
OemUpdateFruInfo (
UINT8 *FruData,
UINTN FruDataSize
)
{
// Processes FRU update sequence:
// 1. Update OCP device info to FRU
// 2. Update HDD FRU records
// 3. Update cache string data per socket
// 4. Read FRU settings and apply
return EFI_SUCCESS;
}
/**
FruInitInterface -- Initialize FRU interface
@retval EFI_SUCCESS Initialized
**/
__int64
FruInitInterface (
VOID
)
{
return EFI_SUCCESS;
}
/**
FruHeaderProcessing -- Process FRU header
@param[in] FruData Raw FRU data
@param[in] FruDataSize Size
@param[out] FruHeader Parsed header
@retval EFI_SUCCESS Parsed
@retval EFI_INVALID_PARAMETER Bad header
**/
__int64
FruHeaderProcessing (
UINT8 *FruData,
UINTN FruDataSize,
FRU_HEADER *FruHeader
)
{
return EFI_SUCCESS;
}
/**
FruDataParseAndUpdate -- Parse and update FRU data
@param[in] FruData Raw FRU data
@param[in] FruDataSize Size
@param[in,out] FruInfo FRU info to update
@retval EFI_SUCCESS Updated
**/
__int64
FruDataParseAndUpdate (
UINT8 *FruData,
UINTN FruDataSize,
VOID *FruInfo
)
{
return EFI_SUCCESS;
}
/**
FruDataValidation -- Validate FRU data
@param[in] FruData FRU data
@param[in] FruDataSize Size
@retval TRUE Valid
@retval FALSE Invalid
**/
BOOLEAN
FruDataValidation (
UINT8 *FruData,
UINTN FruDataSize
)
{
return TRUE;
}
/**
FruUpdateProcessor -- Main FRU update processor
@param[in] SourceData Source data
@param[in] SourceSize Size
@retval EFI_SUCCESS Updated
**/
__int64
FruUpdateProcessor (
UINT8 *SourceData,
UINTN SourceSize
)
{
return EFI_SUCCESS;
}
/**
FruReadAndApplySettings -- Read FRU settings
@param[out] FruSettings Buffer for settings
@retval EFI_SUCCESS Read
**/
__int64
FruReadAndApplySettings (
VOID *FruSettings
)
{
return EFI_SUCCESS;
}
/**
FruStorageInterface -- FRU storage read/write
@param[in] Write TRUE=write, FALSE=read
@param[in] Offset Byte offset
@param[out] Buffer Data buffer
@param[in] BufferSize Size
@retval EFI_SUCCESS Operation completed
**/
__int64
FruStorageInterface (
BOOLEAN Write,
UINTN Offset,
VOID *Buffer,
UINTN BufferSize
)
{
return EFI_SUCCESS;
}
/**
FruDataCommit -- Commit FRU data to storage
@param[in] FruData FRU data
@param[in] FruDataSize Size
@retval EFI_SUCCESS Committed
**/
__int64
FruDataCommit (
UINT8 *FruData,
UINTN FruDataSize
)
{
return EFI_SUCCESS;
}
/**
FruRecordParsing -- Parse FRU record fields
@param[in] RecordData Raw record
@param[in] RecordSize Size
@param[in,out] ParsedFields Parsed output
@retval EFI_SUCCESS Parsed
**/
__int64
FruRecordParsing (
UINT8 *RecordData,
UINTN RecordSize,
VOID *ParsedFields
)
{
return EFI_SUCCESS;
}
/**
FruStringProcessing -- Process FRU string data
@param[in] StringData Raw string data
@param[in] StringLength Length
@param[out] OutputString Output buffer
@param[in,out] OutputSize Buffer size / bytes written
@retval EFI_SUCCESS Processed
**/
__int64
FruStringProcessing (
UINT8 *StringData,
UINTN StringLength,
CHAR16 *OutputString,
UINTN *OutputSize
)
{
return EFI_SUCCESS;
}
/**
FruFieldExtractor -- Extract FRU field from type/length byte
@param[in] TypeLength Type/length byte
@param[out] FieldType Field type
@param[out] FieldLength Field length
@retval EFI_SUCCESS Decoded
@retval EFI_INVALID_PARAMETER Invalid
**/
__int64
FruFieldExtractor (
UINT8 TypeLength,
UINT8 *FieldType,
UINT8 *FieldLength
)
{
*FieldType = (TypeLength >> 6) & 0x03;
*FieldLength = TypeLength & 0x3F;
return EFI_SUCCESS;
}
/**
FruDataLookup -- Lookup FRU data by identifier
@param[in] FruId Identifier
@param[out] FruData Data pointer
@param[out] FruDataSize Size
@retval EFI_SUCCESS Found
@retval EFI_NOT_FOUND Not found
**/
__int64
FruDataLookup (
UINTN FruId,
UINT8 **FruData,
UINTN *FruDataSize
)
{
return EFI_NOT_FOUND;
}
/**
FruStringToValue -- Convert FRU string to numeric value
@param[in] StringData String data
@param[in] StringLength Length
@return Parsed numeric value
**/
UINT64
FruStringToValue (
UINT8 *StringData,
UINTN StringLength
)
{
return 0;
}
/**
FruChecksumCalc -- Calculate FRU checksum
@param[in] Data Data buffer
@param[in] DataSize Size
@return 8-bit checksum
**/
UINT8
FruChecksumCalc (
UINT8 *Data,
UINTN DataSize
)
{
UINT8 Checksum = 0;
for (UINTN i = 0; i < DataSize; i++) {
Checksum += Data[i];
}
return (UINT8)(-Checksum);
}
/**
FruCrcValidation -- Validate FRU CRC
@param[in] FruData Data buffer
@param[in] FruDataSize Size
@retval TRUE CRC valid
@retval FALSE CRC mismatch
**/
BOOLEAN
FruCrcValidation (
UINT8 *FruData,
UINTN FruDataSize
)
{
return TRUE;
}
/**
FruWriteToStorage -- Write FRU data to storage
@param[in] FruData Data
@param[in] FruDataSize Size
@retval EFI_SUCCESS Written
@retval EFI_DEVICE_ERROR Write failed
**/
__int64
FruWriteToStorage (
UINT8 *FruData,
UINTN FruDataSize
)
{
return EFI_SUCCESS;
}
/**
FruMemoryFree -- Free FRU memory
@param[in] Buffer Buffer to free
**/
VOID
FruMemoryFree (
VOID *Buffer
)
{
if (Buffer != NULL) {
gBS->FreePool (Buffer);
}
}
/**
FruDataCopy -- Copy FRU data
@param[out] Destination Destination buffer
@param[in] Source Source buffer
@param[in] Length Number of bytes
**/
VOID
FruDataCopy (
VOID *Destination,
CONST VOID *Source,
UINTN Length
)
{
CopyMem (Destination, Source, Length);
}
/**
UpdateOCPDeviceInfoToFru -- Update OCP device information in FRU
Reads OCP NIC card information (MAC address, channel number, etc.)
and updates the corresponding FRU fields.
@param[in] FruData FRU data buffer
@param[in] FruDataSize Size
@retval EFI_SUCCESS Updated
@retval EFI_NOT_FOUND No OCP card
**/
__int64
UpdateOCPDeviceInfoToFru (
UINT8 *FruData,
UINTN FruDataSize
)
{
return EFI_NOT_FOUND;
}
// ---------------------------------------------------------------------------
// EDK2 Debug Library Helpers
// ---------------------------------------------------------------------------
/**
DebugAssertPrint -- EDK2 assertion print helper
@param[in] Format Format string
@param[in] ... Variable args
**/
VOID
EFIAPI
DebugAssertPrint (
CONST CHAR8 *Format,
...
)
{
VA_LIST Marker;
VA_START (Marker, Format);
AsciiVSPrint (Format, Marker);
VA_END (Marker);
}
/**
DebugAssertBreak -- EDK2 assertion breakpoint helper
@param[in] FileName Source file name
@param[in] LineNumber Line number
@param[in] Description Description
**/
VOID
EFIAPI
DebugAssertBreak (
CONST CHAR8 *FileName,
UINTN LineNumber,
CONST CHAR8 *Description
)
{
DEBUG ((EFI_D_ERROR, "ASSERT: %a(%d): %a\n", FileName, (UINT32)LineNumber, Description));
CpuDeadLoop ();
}
Ajax Dong