diff options
Diffstat (limited to 'Core/EM/NVRAM/NVRAMDXE.c')
| -rw-r--r-- | Core/EM/NVRAM/NVRAMDXE.c | 5719 |
1 files changed, 5719 insertions, 0 deletions
diff --git a/Core/EM/NVRAM/NVRAMDXE.c b/Core/EM/NVRAM/NVRAMDXE.c new file mode 100644 index 0000000..ef43629 --- /dev/null +++ b/Core/EM/NVRAM/NVRAMDXE.c @@ -0,0 +1,5719 @@ +//********************************************************************** +//********************************************************************** +//** ** +//** (C)Copyright 1985-2014, American Megatrends, Inc. ** +//** ** +//** All Rights Reserved. ** +//** ** +//** 5555 Oakbrook Parkway, Suite 200, Norcross, GA 30093 ** +//** ** +//** Phone: (770)-246-8600 ** +//** ** +//********************************************************************** +//********************************************************************** + +//********************************************************************** +// $Header: /Alaska/SOURCE/Core/Modules/NVRAM/NVRAMDXE.c 117 6/11/14 3:12p Oleksiyy $ +// +// $Revision: 117 $ +// +// $Date: 6/11/14 3:12p $ +//********************************************************************** +// Revision History +// ---------------- +// $Log: /Alaska/SOURCE/Core/Modules/NVRAM/NVRAMDXE.c $ +// +// 117 6/11/14 3:12p Oleksiyy +// [TAG] EIP173026 +// [Category] Bug Fix +// [Severity] Important +// [Symptom] With AMITSE 2.17.1245 windows 8.1 (UEFI) does not install +// [RootCause] GetNextVariableName was in certain cases returning name +// and GUID of a boot time variable +// [Solution] Variable name and GUID of a boot time variable X were +// returned at runtime under the following conditions: +// - The variable X was present in the default var.store and not +// present in the main var.store +// - The variable immediately before variable X in the default +// var.store was present in the main var.store +// The default var.store is a var.store generated at build time that +// contains default values for all setup variables +// (variables associated with setup controls). +// The main var.store is the main NVRAM area. Variable is added into a +// main var.store when somebody +// calls SetVariable. +// [Files] NVRAMRead.c +// NVRAMDXE.c +// NVRAM.cif +// +// 116 3/28/14 5:25p Oleksiyy +// [TAG] EIP159166 +// [Category] Improvement +// [Description] Set Auth Variable behaivour when AuthVariable_SUPPORT +// is not present in project made up to speck. +// [Files] NVRAMDXE.c +// +// 115 3/28/14 3:01p Oleksiyy +// [TAG] EIP159166 +// [Category] Improvement +// [Description] When SetVariable is called with gEfiGlobalVariableGuid +// and Variable Name, which is not in the list of Efi Global Variables, +// EFI_INVALID_PARAMETER must be returned according to recent changes to +// UEFI spec. +// [Files] NVRAMDXE.c +// +// 114 3/10/14 4:46p Oleksiyy +// [TAG] EIP156697 +// [Category] Improvement +// [Description] Multiple copies of the same variable through +// GetNextVariableName resolved for Default and Manufactoring modes. +// [Files] NVRAMDXE.c +// +// 113 3/05/14 4:41p Oleksiyy +// [TAG] EIP154299 +// [Category] Improvement +// [Description] Integer + heap potential overflow in SetVariable +// patched. +// [Files] NVRAMDXE.c +// +// 112 1/30/14 10:57a Oleksiyy +// [TAG] EIP148909 +// [Category] Improvement +// [Description] Variable creation on Default Configuration fixed. +// [Files] NVRAMDXE.c +// +// 111 1/14/14 5:45p Oleksiyy +// [TAG] EIP121524 +// [Category] New Feature +// [Description] Extended Aptio functionality for clearing or restoring +// NVRAM to factory default state (preserving only selected Vars). +// [Files] NVRAM.sdl +// NVRAM.mak +// NVRAMDXE.c +// NVRAM.cif +// +// 110 9/24/13 4:42p Oleksiyy +// [TAG] EIP132754 +// [Category] Improvement +// [Description] Removing #ifdef statement as unnecessary. +// [Files] NVRAMDXE.c +// +// 109 8/28/13 6:46p Oleksiyy +// [TAG] EIP132754 +// [Category] Improvement +// [Description] NVRAM modifications for Legacy2Efi module. Sequrity +// update. +// [Files] NVRAMDXE.c +// +// 108 8/27/13 7:45p Oleksiyy +// [TAG] EIP129423 +// [Category] Improvement +// [Description] Setup items behaviour on first and second boot unified. +// [Files] NVRAMDXE.c +// +// 107 8/15/13 12:38p Oleksiyy +// [TAG] EIP132754 +// [Category] New Feature +// [Description] NVRAM modifications for Legacy2Efi module +// [Files] NVRAMDXE.c +// +// 106 2/22/13 4:42p Oleksiyy +// [TAG] EIP115154 +// [Category] Improvement +// [Description] System hangs or resets when all SetVariable calls +// fails. +// Do not return EFI_OUT_OF_RESOURCES if Mailbox failed to save. +// +// [Files] NVRAMDXE.c +// +// 105 1/04/13 5:40p Felixp +// Code clean up: redundant if statements are consolidated. +// +// 104 1/04/13 10:40a Felixp +// [TAG] EIP109422 +// [Category] Improvement +// [Description] Issues found by CppCheck in NVRAM Module part +// InstallNvramControlSmmProtocol call that has been accidently +// deleted by previous check in is restored. +// +// 103 12/13/12 6:16p Oleksiyy +// [TAG] EIP109422 +// [Category] Improvement +// [Description] Issues found by CppCheck in NVRAM Module part +// [Files] NVRAMDXE.c and NVRAMPEI.c +// +// 102 12/13/12 6:12p Felixp +// [TAG] EIP103562 +// [Category] New Feature +// [Description] A mechanism to preserve non-runtime (NV+BS) variables +// across firmware update. +// This feature is required to support +// item 29 of the System.Fundamentals.Firmware.UEFISecureBoot WIN8 Logo +// requirement. +// [Files] NvramDxe.c, SMIFlashLinks.c +// +// 101 11/29/12 5:10p Felixp +// Minor improvement: Since UEFI Specification versions prior to 2.1 +// (0x2000A) are no longer supported, +// all the "#if EFI_SPECIFICATION_VERSION >= 0x2000A" conditional +// compilation statements are removed. +// Files modified: NVRAM.h, NVRAMRead.c, NVRAMDXE.c +// +// 100 11/29/12 4:20p Felixp +// [TAG] EIP106617 +// [Category] Bug Fix +// [Symptom] BeginCriticalSection/EndCriticalSection primitives are not +// really thread safe +// [RootCause] The main problem with the previous implementation was +// that the Critical Section object ("cs") itself was not +// also protected by the critical section, meaning that code must not +// write to this object when interrupts are +// enabled. +// If BeginCriticalSection() is interrupted before the "Busy" flag is set, +// and the interrupt handler attempts to +// re-enter the critical section, interrupt masks and SMI enable state +// will become permanently corrupted. +// Likewise, if EndCriticalSection is interrupted at the wrong time, the +// saved interrupt masks and SMI enable +// state will be overwritten by the interrupt handler re- entering the +// critical section. +// [Solution] By introducing a local temp context, the problem is +// completely solved. +// [Files] NvramDxe.c +// +// 99 11/29/12 3:41p Felixp +// IsStoreOk bug fix (introduced by previous check in) +// +// 98 11/29/12 3:27p Felixp +// Nvram.h, NvramDxe.c: +// 1. Bug Fix (EIP106441): The Authenticated Variable SCT test was +// failing due to a +// bug in UpdateVariable function. The function was skipping the +// update if new variable data +// is equal to the old variable data. The update should not be skipped +// in case of the append operation +// (when EFI_VARIABLE_APPEND_WRITE attribute is set). +// The function is updated accordingly. +// 2. Bug fix: External declaration for the FlashEmpty variable declared +// variable type as UINT32, +// even though the variable is defined in Tokenc.c as UINTN. +// +// 97 11/07/12 4:15p Oleksiyy +// [TAG] EIP99114 +// [Category] New Feature +// [Description] Please make state of "Runtime" variable used in +// NvramDxe.c globally available +// [Files] 99114 +// +// 96 9/18/12 10:57a Felixp +// [TAG] EIP91311 +// [Category] Bug Fix +// [Symptom] The variable defaults are missing at runtime when NvramSmi +// module is used. +// [RootCause] The defaults variable store data structure where not +// updated with the new buffer address. +// It was still pointing to the old address. +// [Solution] ReallocateHybridVarstoreToSmm function is updated to fix +// the main NVRAM store and all the nested variable stores. +// [Files] NvramDxe.c +// +// 95 6/06/12 3:46p Oleksiyy +// [TAG] EIP88436 +// [Category] Improvement +// [Description] Windows 8 feature test UEFI PXE Boot - System hangs. +// [Files] NVRAMDXE.c +// +// 94 5/25/12 4:33p Felixp +// [TAG] EIP88550 +// [Category] Bug Fix +// [Symptom] On Rose City label 17, sometimes setup entry is very slow +// [RootCause] The system occasionally became very slow during start up +// of the setup client. +// The problem was caused missynchronization of the global data used by +// NVRAM DXE and NVRAM SMM drivers. +// +// [Solution] The code is updated to make sure NvramMailBox data is up +// to date at the time of NVRAM SMM driver initialization. +// [Files] NvramDxe.c +// +// 93 5/22/12 6:00p Oleksiyy +// [TAG] EIP90318 +// [Category] Bug Fix +// [Severity] Normal +// [Symptom] ChiefRiver SCT Fail, improper variable MonotonicCounter in +// NVRAM module +// [RootCause] EFI_GLOBAL_VARIABLE guid is used in non EFI defined +// variable. +// [Solution] New guig AMI_GLOBAL_VARIABLE_GUID is created and used. +// [Files] AmiLib.h, Misc.c and NVRAMDXE.c +// +// 92 3/22/12 5:31p Oleksiyy +// [TAG] EIP85222 +// [Category] Improvement +// [Description] NVRAM hooks needs virtualization +// [Files] NVRAMDXE.c +// +// 91 3/20/12 10:43a Felixp +// [TAG] EIP85396 +// [Category] Bug Fix +// [Symptom] Loading SETUP defaults using IsResetConfigMode() +// [RootCause] The NVRAM reset happens very early in the NVRAM driver +// initialization process. +// The hybrid interface functions, used during NVRAM reset, +// were accessing global data that has not yet been initialized. +// [Solution] The NVRAM reset is now performed using direct flash access +// (without hybrid interface). +// The hybrid interface is initialized after the NVRAM reset. +// +// 90 3/13/12 10:29a Felixp +// Bug fix in HybridGetAddressDelta: +// Symptoms: The system was hanging during initialization of the NVRAM DXE +// driver +// when NVRAM FV header was corrupted. +// Details: NvramInitialize detects FV header corruption and calls +// NvResetConfiguration to fix it. +// NvResetConfiguration call other functions and control eventually goes +// to HybridGetAddressDelta, +// which didn't work properly since it used VarStoreInfo global data +// structure that had not been initialized yet. +// HybridGetAddressDelta is updated to work properly before VarStoreInfo +// has been initialized. +// +// 89 3/03/12 2:48p Felixp +// Bug fixes in DxeSetVariable: +// Return EFI_INVALID parameter when: +// - Illegal attribute bits are set +// - Boot time variable is being set at runtime +// +// 88 2/22/12 4:07p Oleksiyy +// [TAG] EIP83723 +// [Category] Improvement +// [Description] Review commnts from EIP 82122 applied. +// [Files] NVRAMDXE.c +// +// 87 2/17/12 6:27p Oleksiyy +// [TAG] EIP82122 +// [Category] Bug Fix +// [Severity] Normal +// [Symptom] "Secure Boot Manual Logo Test" fails +// [RootCause] If Garbage Collection happens during append operation - +// after garbage collection previous data will be lost after GC. +// [Solution] Append after Garbage collection treated in special way. +// [Files] NVRAMDXE.c +// +// 86 1/30/12 2:17p Felixp +// [TAG] EIP81531 +// [Category] Bug Fix +// [Symptom] ASSERT in debug mode during boot with default configuration +// [RootCause] HybridGetAddressDelta() checks bounds against the wrong +// NVRAM region +// [Solution] HybridGetAddressDelta() is updated to use NvInfo pointer +// instead of NvramInfo +// +// 85 11/11/11 3:19p Felixp +// 1.Performance of the NVRAM driver has been improved by creation of the +// in-memory cache of the +// NVRAM data (older code accessed ROM directly). The feature can be +// disabled by commenting out +// definition of the HYBRID_NV_INTERFACE macro in NvramDxe.c +// 2. Support for isolation of the SMM NVRAM services at runtime (no data +// access outside of SMM). +// The isolation of the SMM NVRAM driver implies migration of the NVRAM +// API into SMM. The DXE +// portion of the NVRAM driver is getting shut down. It is replaced by +// the NvramSmi driver (external +// eModule; not part of the Core) that redirects NVRAM calls into SMM. +// The feature should be used +// when flash part is locked at runtime. The support is automatically +// enabled when NvramSmi module +// is in the project (by defining +// DO_NOT_ACCESS_DATA_OUTSIDE_OF_SMM_AT_RUNTIME macro). +// +// 84 7/13/11 9:24a Justinj +// [TAG] EIP62762 +// [Category] Improvement +// [Description] Optimize NVRAM cache index so that the entire linked +// list is not walked every time a variable is set or retrieved. +// [Files] NVRAM.h +// NVRAMRead.c +// NVRAMDXE.c +// +// 83 7/08/11 3:31p Oleksiyy +// [TAG] EIP64390 +// [Category] Bug Fix +// [Severity] Normal +// [Symptom] Repetitive SetVariables calls cause UEFI OS crash +// [RootCause] When NVRAM_RT_GARBAGE_COLLECTION_SUPPORT is off, +// CopyVarStoreToMemStore does not do anything (immediately returns error) +// but SelectiveFree was still trying to free memory at uninitialized +// address (NewInfo.NvramAddress is not initialized). +// +// [Solution] Added check for Rintime before going to BS. +// [Files] NVRAMDXE.c +// +// 82 6/16/11 10:23a Artems +// Bugfix in authenticated variable support +// +// 81 6/16/11 8:58a Felixp +// Bug fix in the IndexInit function: VarIndexPtr->BufferSize was not +// initialized. +// +// 80 6/13/11 6:42p Artems +// Added changes to support Authenticated Variable +// +// 79 5/11/11 6:33p Oleksiyy +// [TAG] EIP60206 +// [Category] Improvement +// [Description] Authenticated Variables improvement. +// NV_CACHE_SUPPORT == O support added. +// [Files] NVRAMDXE.c and NVRAM.h +// +// 78 5/06/11 6:15p Oleksiyy +// [TAG] EIP53253 +// [Category] Improvement +// [Description] To comply with UEFI 2.3.1 +// EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS and +// EFI_VARIABLE_APPEND_WRITE attributes handling added. +// [Files] NVRAM.h, NVRAMRead.c and NVRAMDXE.c +// +// 77 3/09/11 6:18p Artems +// Undo previous changes, as they are unnecessary since SCT fixed bug on +// their side +// +// 76 2/25/11 3:01p Artems +// EIP 53749: SCT variable test fails. Here included partial fix. SCT uses +// wrong guid +// in its test - this part not included in generic source and available as +// patch for sole purpose +// of passing SCT test +// +// 75 2/11/11 11:08a Artems +// +// 74 2/02/11 3:09p Oleksiyy +// [TAG] EIP42253 +// [Category] Improvement +// [Description] Convert Flash Pointer added. +// [Files] NVRAMDXE.c +// +// 73 1/25/11 12:46p Oleksiyy +// [TAG] EIP42253 +// [Category] New Feature +// [Description] Added support for platforms, where flash part is not +// memory mapped while write enabled, controlled by +// NO_MMIO_FLASH_ACCESS_DURING_UPDATE sdl token. Flash protocol used to +// access flash in that case. +// [Files] NVRAMDXE.c, Flash.c, Tokens.c and Runtime.sdl +// +// 72 1/19/11 6:04p Oleksiyy +// [TAG] EIP52517 +// [Category] Bug Fix +// [Severity] Normal +// [Symptom] NVRAM inconsistency when updating Setup first time in 32 +// bit mode +// [RootCause] DxeSetVariable function in NVRAMDXE.c passes wrong +// Interface to UpdateVariable. +// [Solution] DxeSetVariable function in NVRAMDXE.c modified. +// [Files] NVRAMDXE.c +// +// 71 11/17/10 12:04p Oleksiyy +// [TAG] EIP39460 +// [Category] New Feature +// [Description] Runtime Garbage Collection potential bug fix. +// Initialization of Mailbox updated. +// [Files] NVRAMDXE.c +// +// 70 11/11/10 7:40a Felixp +// Bug fix: updated to compile in UEFI 2.0 mode. +// +// 69 11/08/10 5:58p Felixp +// Bug fixes in the RT Garbage Collection Support implementation +// (EIP39460). +// +// 68 11/08/10 5:29p Felixp +// Depdency from SecureMod_SUPPORT SDL token is removed +// +// 67 11/08/10 5:23p Felixp +// Bug fixes in the Runtime Garbage Collection Support implementation (EIP +// 39460). +// +// 66 11/05/10 2:14p Felixp +// Bug Fix in QueryVariableInfo. +// QueryVariableInfo was always reporting MaximumVariableSize of 8 bytes. +// +// 65 9/30/10 4:53p Oleksiyy +// Issue Number: 45053 +// +// Category: Improvement +// +// Description: If update on Next field in NVAR failed, the NVRAM +// recovery was not triggered. Problem fix now. +// +// Files: NVRAMDXE.c +// +// 64 9/30/10 4:38p Oleksiyy +// Issue Number: 40356 and 39462 +// +// Category: New Feature +// +// Description: Support for EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS +// Small fix of previously checked in code. +// +// Files: NVRAM. h, NVRAMRead.c, NVRAMDXE.c +// +// 63 9/24/10 8:00a Felixp +// Minor bug fix in initialization of NvramCs variable +// +// 62 9/24/10 7:57a Felixp +// Improvement( EIP 40257): +// BeginCriticalSection/EndCriticalSection are updated to enable/disable +// interrupts using +// PIC interrupt mask registers (ports 0x21 and oxa1) instead of just +// setting the CPU interrupt flag (CLI/STI). +// +// 61 9/22/10 6:39p Felixp +// Enhancement(EIP 39462 and EIP 40356): +// Support of the authenticated update of the NVRAM variables +// as described in UEFI specification version 2.1 and above. +// NOTE: The actual authentication is performed by the external SecureMod +// eModule, +// which must be in the proejct to use this feature. +// +// 60 9/22/10 5:47p Felixp +// Enhancement(EIP 39460): Runtime Garbage Collection Support. +// (controlled by the NVRAM_RT_GARBAGE_COLLECTION_SUPPORT SDL token ). +// +// 59 6/30/10 4:32p Felixp +// +// 58 6/30/10 2:19p Felixp +// Switching to simulation in recovery modue is disabled. +// +// 57 4/26/10 2:56p Felixp +// +// 56 4/26/10 11:57a Felixp +// Clean up of the trace messages. +// +// 55 4/23/10 5:32p Felixp +// 1. NVRAM Reset Policy is updated. +// Don't reset configuration if defaults are not available. +// Restore defaults is they disappeared from the NVRAM. +// 2. Turn on NVRAM simulation in Recovery mode (to protect main FV before +// main BIOS is updated) +// +// 54 4/22/10 11:50p Felixp +// Bug fix in the NvramInitialize. NvResetConfiguration after the +// DxeIsNvramCompatible was called with the wrong argument. +// This caused problems when fault tolerant NVRAM update was enabled. +// +// 53 4/22/10 11:47p Felixp +// EnumerateStore function is updated to skip incomplete +// NVAR record (if any) at the end of the NVRAM data area. +// +// 52 3/05/10 11:52a Felixp +// Bug fix: +// Symptoms: When FAULT_TOLERANT_NVRAM_UPDATE is enabled, +// UEFI Windows crashes with blue screen 1E during start up. +// Details: The VarStoreInfo.BackupAddress was not virtualized during +// virtual mode transition. +// +// 51 2/02/10 5:16p Oleksiyy +// EIP 33263 : Hooks for SetVariable, GetVariable and GetNextVarName +// added +// +// 50 12/04/09 12:29p Felixp +// NvarEqNvar moved to NvramRead.c +// +// 49 11/24/09 4:40p Felixp +// Minor bug fixes +// +// 48 11/23/09 11:00p Felixp +// +// 47 11/23/09 4:44p Felixp +// Code to validate NVRAM header fields used by the NVRAM driver is added. +// If problem is found, the header fields are updated with the correct +// values. +// +// 46 11/20/09 4:06p Felixp +// NVRAM driver is updated to support UEFI2.1 +// EFI_VARIABLE_HARDWARE_ERROR_RECORD attribue. +// +// 45 11/20/09 9:27a Felixp +// NVRAM record corruption check is added to IndexFindVariable and +// IndexUpdateVariable functions. +// +// 44 8/25/09 4:11p Felixp +// NVRAM Record Checksum Support(EIP 23825) is added. +// Disabled by default. Enable using NVRAM_RECORD_CHECKSUM_SUPPORT SDL +// token. +// +// 43 7/30/09 3:38p Felixp +// Bug fix: +// Symptoms: systems were occasionally hanging during first boot after +// flashing, +// when SetVariable call from SMM was followed by the GetVariable call +// from outside of SMM. +// Details: VarIndex data structure updated to save varstore indexes +// within VarStoreInfo.NvramInfo +// instead of pointers to varstore information (pointers cannot be used +// because VarIndex information is used by both SMM and non-SMM NVRAM +// services, +// which have independent copies of VarStoreInfo global variable). +// +// 42 7/10/09 8:53a Felixp +// +// 41 7/10/09 8:51a Felixp +// New NVRAM_MONOTONIC_COUNTER_SUPPORT SDL token is created. The token can +// be used +// to disable Core NVRAM-based implementation of the monotonic counter +// architectural protocol and +// to use stand alone monotonic counter driver instead. +// Code clean up; comments and function header added. +// +// 40 6/26/09 3:33p Felixp +// Bug fix (EIP 23329): +// 1. CheckStore function: Auto detect active NVRAM area (main or backup) +// before NVRAM access. +// 2. DxeSetVariable: Bug fix in parameter validation +// 3. Additional debug messages added +// +// 39 5/21/09 5:38p Felixp +// 1. Reset NVRAM content to defaults (loaded from FFS file in FV_MAIN or +// other FV) +// if it has been corrupted during failed BIOS update. +// 2. Validate compatibility of the NVRAM content using external hook +// (DxeIsNvramDataCompatible). +// It NVRAM content is incompatible, reset it to defaults +// (loaded from FFS file in FV_MAIN or other FV). +// +// 38 5/14/09 9:36a Felixp +// New feature: SMM version of Runtime Services +// NVRAM driver is updated to populate SMM runtime table +// with the pointers to SMM version of variable services. +// +// 37 5/04/09 2:26p Felixp +// +// 36 5/04/09 11:24a Felixp +// Make sure code compiles with NV_CACHE_SUPPORT set to zero +// +// 35 5/04/09 11:07a Felixp +// Bug fix. NVRAM DXE will crash if defaults are reset on first boot(EIP +// 20149). +// Symptoms: If TRUE is returned by IsResetConfig() on the first boot +// after a fresh flash, system hangs in the NVRAM DXE driver. +// Function updated: IndexReset +// +// 34 3/23/09 2:20p Felixp +// Bug fix: EIP 20442. +// Symptoms: USB mass storage device is sometimes missing from the BBS +// popup menu +// when F12 is pressed continuously on USB keyboard. +// Details: the problem was caused by the fact that timer interrupt +// handler was running with SMI disabled. +// BeginCriticalSection/EndCriticalSection updated to enable SMI's +// before interrupts. +// The change provides support for interrupt handlers depending upon +// processing performed by the SMI handler +// +// 33 1/02/09 2:19p Felixp +// Improved handling of the variables with default values. +// When variable is deleted, return EFI_WRITE_PROTECTED instead of +// EFI_NOT_FOUND +// if only default value (which can not be deleted) exists. +// When volatile variable is created, return EFI_INVALID_PARAMETER if +// default value exists +// (If default value exists, the variable is non volatile. Attributes +// for existing variable can not be changed). +// +// 32 11/21/08 2:13p Felixp +// Bug fix in IsClean routine. +// +// 31 11/20/08 6:17p Felixp +// Bug fin in CreateVariable (proper handling of the GUID index overflow). +// +// 30 11/20/08 2:23p Felixp +// Bug fix in the NextGuid detection logic within EnumerateStore routine. +// +// 29 10/17/08 9:40a Felixp +// Bug fix in IndexUpdateVariable (caused blue screen during UEFI Vista +// installation). +// +// 28 10/09/08 11:47a Felixp +// 1. Fault tolerant NVRAM garbage collection support is added. +// Use FAULT_TOLERANT_NVRAM_UPDATE SDL token to enable/disable (disabled +// by default). +// NOTE: This feature requires upgrade of the Board module. +// NOTE: This feature requires porting: +// Fault tolerant update requires reserved flash area of size NVRAM_SIZE +// used for back up during NVRAM garbage collection. +// The address of the area is defined by NVRAM_BACKUP_ADDRESS SDL token +// defined in Board.sdl. +// Size and Base addresses of other firmware volumes may need to be +// adjusted to free up space for the NVRAM back up area. +// Default ROM layout expects NVRAM back up area immediately below the +// main NVRAM area. +// For projects with the customized ROM layout Core.mak has to be updated. +// 2. Top level NVRAM function updated to be reentrance-safe. +// NOTE: This feature requires upgrade of the SB module. +// 3. Improved recovery from the flash programming failures and +// corruptions within NVRAM area. +// 4. More reliable non-fault tolerant garbage collection. +// +// 27 8/01/08 3:23p Felixp +// Bug fix in UpdateVariable routine (Index was not properly updated if +// NvCompact happened in the UpdateVariable) +// +// 26 7/14/08 3:16p Felixp +// +// 25 7/08/08 5:31p Felixp +// Don't do NvCompact at runtime +// +// 24 4/21/08 11:32p Felixp +// Bug fix in the NVRAM corruption recovery logic +// +// 23 3/12/08 2:52p Felixp +// Error code reporting when flash update failed added +// +// 22 2/19/08 11:11p Felixp +// 1. NvProgram updated: code added to verify if data have been programmed +// correctly +// 2. Minor bug fix in NvCompact +// 3. CreateVariable/UpdateVariable updated with the code that handles +// failed flash write operations +// 4. Bug fix in DxeSetVariable: during boot with default configuration, +// current value was not properly updated +// 5. Update in init routine VarStoreDiscovery: during boot with default +// configuration, main NVRAM store is also exposed. This is needed to +// provide current value for variables without defaults. +// +// 21 11/07/07 3:09p Felixp +// Bug fixes: +// 1. GetVariable/SetVariable crashed or returned EFI_NOT_FOUND after +// ExitBootServices and before SetVartualAddressMap +// 2. During first boot or boot with default values updated value of the +// variable did not show up until system reset (GetVariable was returning +// old value) +// +// 20 10/15/07 3:00p Felixp +// Bug fix in NvramInitialize: defaults were ignored in simulation mode. +// +// 19 10/12/07 3:06p Felixp +// Bug fix(EIP issue 10480): NVRAM initialization routine is updated to +// properly handle NV simulation. +// +// 18 9/13/07 10:18a Felixp +// Bug fix in DxeNvramInit routine. +// NVRAM area descriptor was not properly reinitialized +// during calls to DxeNvramInit with ResetVolatileStore set FALSE +// +// 17 9/06/07 12:14a Felixp +// +// 16 8/31/07 3:44p Felixp +// NVRAM code has been significantly changed to introduce the following +// improvements: +// 1. The code is chaned to always use the same amount of memory. +// Previous implementation allocated memory as needed, which caused +// occasional S4 problems. +// Plus S4 resume never worked during the very first boot after the +// firmware update. +// 2. Support for NVRAM defaults added. +// NVRAM image with the default values for the Setup variables is now +// generated by the build process. +// The image is generated by the HpkTool (included into AMITSE module +// part). +// In addition to standard Setup defaults it is also possible +// to generate manufactoring defaults. Support for the manufactoring +// defaults +// is disabled by default and can be enabled using +// MANUFACTURING_MODE_SUPPORT SDL token. +// 3. Support for boot with alternative configurations is added. +// Decision to switch to the alternative configuration +// (alternative set of values for NVRAM variables) +// is based on values returned by the porintg routine in OemPort.c. +// During boot with alternative configurations GetVariable service +// returns alternative values for the setup-related variables. +// If variable does not have an alternative value, current value is +// returned. +// Two alternative configurations are supported: +// Boot with manufactoring settings(activated when IsMfgMode routine in +// OemPort.c returns TRUE). +// Boot with default settings(activated when IsDefaultConfigMode routine +// in OemPort.c returns TRUE). +// NOTE: This feature requires of the Board module +// 4.NVRAM reset option is added. +// If porting routine IsResetConfigMode in OemPort.c returns TRUE in PEI +// phase, +// NVRAM content will be reset during initialization of the DXE NVRAM +// driver. +// During reset operation all setup-related variables are reset to their +// default values. +// All other variables are deleted. +// NOTE: This feature requires upgrade of the Board module +// 5.Detection of NVRAM update added. +// NVRAM implementation detects if NVRAM has been updated since the last +// NVRAM call. +// This provides ability to use variables services before and after +// firmware update. +// 6.Overall code clean up and simplification. +// 7.Core Sources are no longer required in order to use NV_SIMULATION +// option. +// 8.PI 1.0 support. +// Support for a PI 1.0 complient variable PPI is added. Old PPI is still +// preserved in this label for backward compatibility. +// New library routines PeiGetVariable and PeiGetNextVariableName are +// created in order to hide the differences between two PPIs. +// It is recommended to update existing code to use new library routines. +// Support of the old PPI may be dropped in the future versions of Core. +// 9. NVRAM is now packaged as a raw FFS file embedded into the standard +// FV (used to be non-standard FV with raw NVRAM image). +// Validation: New NVRAM code has been validated using SCT and EFI version +// of Windows Server 2008 +// Files modified: Core.sdl, Core.mak, AmiPeiLib.h, PeiLib.c, +// ReadOnlyVariable.h, , Token.c, HpkTool.exe, AMITSE.mak, Setup.ini, +// NVRAM.sdl, NVRAM.mak, NVRAM.h, NVRAMRead.c, NVRAMPEI.c, +// NVRAMDXE.c +// +// 15 8/07/07 2:42p Felixp +// Additional Status Codes added +// +// 14 4/25/07 6:02p Felixp +// MemSetVariable improvements: don't do memory deallocation/allocation +// when variable is updated with the data of the same size. +// +// 13 3/29/07 1:06p Felixp +// SCT workarounds removed (the issues have been fixed in the new version +// of SCT). +// +// 12 12/29/06 3:02p Felixp +// Update to use new flash interface +// +// 11 12/19/06 12:39p Felixp +// Bug fixes in Variable Services +// +// 10 12/18/06 3:00p Robert +// Updated for change in IsProgramCompleted parameters +// +// 9 11/01/06 4:40p Robert +// Added changes that are updates for the source to work with the new +// Flash module +// +// 8 10/27/06 10:42a Felixp +// Bug fixes for correct work in Virtual Address Space. +// +// 7 10/23/06 7:03p Felixp +// 1. Virtual address space fixup of the global variables added +// 2. NVRAM simulation support +// +// 6 10/12/06 9:07p Felixp +// +// 5 10/12/06 9:44a Felixp +// UEFI2.0 compliance: use CreateLegacyBootEvent instead of CreateEvent +// +// 3 10/09/06 10:08a Felixp +// UEFI2.0 support (QueryVariableInfo funciton added) +// +// 2 9/20/06 10:38a Felixp +// 1. Bug fix in MemSetVariable: cached variable data was not updated +// during variable update in Runtime +// 2. Legacy boot event handler added to switch to runtime mode in case of +// legacy boot +// +// 10 7/17/06 7:50p Felixp +// changes so that module can be compiled in NV_SIMULATION mode without +// Flash.lib +// +// 9 12/06/05 2:36p Felixp +// bug fixes in NVCompact and NVSetVariable +// +// 8 9/23/05 5:44p Felixp +// bug fix in NVSetVariable (when update of the variable causes NVCompact, +// NameSize is uninitialized) +// +// 5 7/22/05 2:19a Felixp +// 1. NVRAM enclosed into Firmware volume. +// 2. bug fixes (mostly in NVCompact) +// +// 4 4/07/05 12:09p Felixp +// bug fixing +// +// 3 1/20/05 11:37a Felixp +// Component restructurized to support release in binary format +// +// 2 1/18/05 3:22p Felixp +// PrintDebugMessage renamed to Trace +// +// 21 11/18/04 6:08p Felixp +// checkpoint(0x99) removed +// +// 19 8/28/04 1:49a Felixp +// NVRAM Routines fixes +// +// 15 7/16/04 1:00p Markw +// Check max tpl. +// +// 1 3/29/04 2:32a Felixp +// +//********************************************************************** +//<AMI_FHDR_START> +// +// Name: NVRAMDXE.h +// +// Description: +// +//<AMI_FHDR_END> +//********************************************************************** +#include "NVRAM.h" +#include <AmiDxeLib.h> +#include "token.h" + +#include <Protocol/Variable.h> +#include <Protocol/MonotonicCounter.h> +#include <Protocol/FlashProtocol.h> +#include <AmiCspLib.h> +#include "NvramPreserveList.h" + +#define HYBRID_NV_INTERFACE + +#define HASH_SHA256_LEN 32 + +#define UEFI21_SPECIFIC_VARIABLE_ATTRIBUTES (EFI_VARIABLE_HARDWARE_ERROR_RECORD |\ + EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS) + +#define UEFI23_1_SPECIFIC_VARIABLE_ATTRIBUTES (EFI_VARIABLE_HARDWARE_ERROR_RECORD |\ + EFI_VARIABLE_APPEND_WRITE |\ + UEFI23_1_AUTHENTICATED_VARIABLE_ATTRIBUTES) + +//##### Security ###### +#if AuthVariable_SUPPORT +VOID AuthVariableServiceInit (VOID); +VOID AuthVariableServiceInitSMM (VOID); +VOID AuthServiceVirtualFixup(VOID); +EFI_STATUS VerifyVariable ( + IN CHAR16 *VariableName, + IN EFI_GUID *VendorGuid, + IN UINT32 *Attributes, + IN VOID **Data, + IN UINTN *DataSize, + IN VOID *OldData, + IN UINTN OldDataSize, + IN OUT EXT_SEC_FLAGS *ExtFlags +); +#else +VOID AuthVariableServiceInit (VOID) {}; +VOID AuthVariableServiceInitSMM (VOID) {}; +VOID AuthServiceVirtualFixup(VOID) {}; +EFI_STATUS VerifyVariable ( + IN CHAR16 *VariableName, + IN EFI_GUID *VendorGuid, + IN UINT32 *Attributes, + IN VOID **Data, + IN UINTN *DataSize, + IN VOID *OldData, + IN UINTN OldDataSize, + IN OUT EXT_SEC_FLAGS *ExtFlags +){ +//UEFI 2.3.1 requres to return SECURITY_VIOLATION error if no Auth Var support present + if (*Attributes & UEFI23_1_AUTHENTICATED_VARIABLE_ATTRIBUTES) + return EFI_SECURITY_VIOLATION; + else + return EFI_SUCCESS; +} +#endif //#if AuthVariable_SUPPORT + +#define ALL_VARIABLE_ATTRIBUTES ( EFI_VARIABLE_NON_VOLATILE |\ + EFI_VARIABLE_BOOTSERVICE_ACCESS |\ + EFI_VARIABLE_RUNTIME_ACCESS|\ + UEFI23_1_SPECIFIC_VARIABLE_ATTRIBUTES) + +#define VALATILE_VARIABLE_STORE_SIZE 0x10000 + +#define BEGIN_CRITICAL_SECTION(Cs) \ + { if ((Cs)->Busy) return EFI_ACCESS_DENIED;\ + BeginCriticalSection(Cs);\ + } +#define END_CRITICAL_SECTION(Cs) EndCriticalSection(Cs) +#ifdef EFI_DEBUG + +#define NVRAM_TRACE(Arguments) { if (!Runtime) TRACE(Arguments); } +#else +#define NVRAM_TRACE(Arguments) +#endif + +//============================================================================ +// Type definitions +typedef BOOLEAN (*NVRAM_UPDATE_ROUTINE)(IN VOID *Address, UINTN Size); +typedef BOOLEAN (*NVRAM_PROGRAM_ROUTINE)(IN VOID *Address, UINTN Size, VOID *Data); +typedef BOOLEAN (*COPY_VAR_STORE_FILTER)( + IN VOID *Context, CHAR16* VarName, EFI_GUID* VarGuid, + NVRAM_STORE_INFO *Info +); + +typedef struct +{ + NVRAM_UPDATE_ROUTINE EnableUpdate; + NVRAM_UPDATE_ROUTINE DisableUpdate; + NVRAM_UPDATE_ROUTINE EraseBytes; + NVRAM_PROGRAM_ROUTINE WriteBytes; +} VARIABLE_INTERFACE; + +typedef struct +{ + UINT32 Mode; + UINT32 HeaderLength; + UINT32 NvramMode; + UINT32 InfoCount, LastInfoIndex; + NVRAM_STORE_INFO NvramInfo[10]; + NVRAM_STORE_INFO *NvInfo, *MemInfo; + VARIABLE_INTERFACE *NvInterface, *MemInterface; + UINT8 *BackupAddress; +#ifdef HYBRID_NV_INTERFACE + UINTN AddressDelta; + UINT8* NvramFlashAddress; +#endif +} VARSTORE_INFO; + +typedef struct +{ + BOOLEAN Busy; + BOOLEAN SmiState; + UINT8 IntState[2]; +} CRITICAL_SECTION; + +typedef EFI_STATUS (HOOK_GET_VARIABLE)( + IN CHAR16 *VariableName, IN EFI_GUID *VendorGuid, + OUT UINT32 *Attributes OPTIONAL, + IN OUT UINTN *DataSize, OUT VOID *Data +); +typedef EFI_STATUS (HOOK_SET_VARIABLE)( + IN CHAR16 *VariableName, IN EFI_GUID *VendorGuid, + IN UINT32 Attributes, IN UINTN DataSize, IN VOID *Data +); + +typedef EFI_STATUS (HOOK_GET_NEXT_VARIABLE_NAME)( + IN OUT UINTN *VariableNameSize, + IN OUT CHAR16 *VariableName, IN OUT EFI_GUID *VendorGuid +); + +typedef EFI_STATUS (*SHOW_BOOT_TIME_VARIABLES)(BOOLEAN Show); + +typedef struct{ + SHOW_BOOT_TIME_VARIABLES ShowBootTimeVariables; +} AMI_NVRAM_CONTROL_PROTOCOL; + +#define LTEB_GUID \ + {0xC8BCA618, 0xBFC6, 0x46B7, 0x8D, 0x19, 0x83, 0x14, 0xE2, 0xE5, 0x6E, 0xC1} + +typedef struct { + CHAR16 *Name; + EFI_GUID Guid; +} SDL_VAR_ENTRY; + +typedef struct { + CHAR16 *Name; + UINT32 Attributes; +} STD_EFI_VAR_ENTRY; + +//====================================================================== +//Function Prototypes +EFI_STATUS NvramReinitialize(); +EFI_STATUS InitVolatileStore( + NVRAM_STORE_INFO *Info, UINTN Size, + UINTN HeaderLength, UINT8 Flags, + BOOLEAN Runtime +); +BOOLEAN CheckTheHeader(NVRAM_STORE_INFO *Info, UINT32 HeaderLength, BOOLEAN Update); + +//====================================================================== +// Global and extern variables +extern const BOOLEAN NvramMonotonicCounterSupport; +extern BOOLEAN NvramChecksumSupport; +extern const BOOLEAN FlashNotMemoryMapped; +static BOOLEAN Runtime = FALSE; +static BOOLEAN HideBtVariables = TRUE; +static EFI_GUID gAmiNvramControlProtocolGuid = { 0xf7ca7568, 0x5a09, 0x4d2c, { 0x8a, 0x9b, 0x75, 0x84, 0x68, 0x59, 0x2a, 0xe2 } }; +static BOOLEAN SaveOnlyPreservedVars = FALSE; +#ifdef DO_NOT_ACCESS_DATA_OUTSIDE_OF_SMM_AT_RUNTIME +BOOLEAN NoAccessOutsideofSmm = FALSE; +#endif + +VARSTORE_INFO VarStoreInfo; +CRITICAL_SECTION NvramCs = {FALSE, FALSE, {0,0} }; +CRITICAL_SECTION *NvramCsPtr = &NvramCs; + +const static UINT32 NvramSignature = NVAR_SIGNATURE; +extern const BOOLEAN NvramRtGarbageCollectionSupport; +EFI_PHYSICAL_ADDRESS NvramDriverBuffer = 0; // Runtime buffer for use in Runtime with the size of 3 times NVRAM_SIZE +// First part (2 times NVRAM_SIZE) usialy used for TmpBuffer, while last part for VolatileStore. +UINT32 NvramDriverBufferSize = 0; +BOOLEAN FirstPartAlloc = FALSE; +BOOLEAN SecondPartAlloc = FALSE; + +static FLASH_PROTOCOL *Flash = NULL; +extern HOOK_GET_VARIABLE GET_VAR_LIST EndOfGetVariableHook; +extern HOOK_SET_VARIABLE SET_VAR_LIST EndOfSetVariableHook; +extern HOOK_GET_NEXT_VARIABLE_NAME GET_NEXT_VAR_NAME_LIST EndOfGetNextVarNameHook; + +HOOK_GET_VARIABLE* GetVariableHookList[]= + {GET_VAR_LIST NULL}; +HOOK_SET_VARIABLE* SetVariableHookList[]= + {SET_VAR_LIST NULL}; +HOOK_GET_NEXT_VARIABLE_NAME* GetNextVarNameHookList[]= + {GET_NEXT_VAR_NAME_LIST NULL}; +// Build time array of variables to be preserved. +SDL_VAR_ENTRY gSdlVarLst[] = { + NVRAM_PRESERVE_VARIABLES_LIST {NULL, {0,0,0,0,0,0,0,0,0,0,0}} +}; + +STD_EFI_VAR_ENTRY gStdEfiVarList[] = { + {L"LangCodes", EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS}, + {L"Lang", EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_NON_VOLATILE}, + {L"Timeout", EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_NON_VOLATILE}, + {L"PlatformLangCodes", EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS}, + {L"PlatformLang", EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_NON_VOLATILE}, + {L"ConIn", EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_NON_VOLATILE}, + {L"ConOut", EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_NON_VOLATILE}, + {L"ErrOut", EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_NON_VOLATILE}, + {L"ConInDev", EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS}, + {L"ConOutDev", EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS}, + {L"ErrOutDev", EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS}, + {L"BootOrder", EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_NON_VOLATILE}, + {L"BootNext", EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_NON_VOLATILE}, + {L"BootCurrent", EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS}, + {L"BootOptionSupport", EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS}, + {L"DriverOrder", EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_NON_VOLATILE}, + {L"HwErrRecSupport", EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_NON_VOLATILE}, + {L"SetupMode", EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS}, + {L"KEK", EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS}, + {L"PK", EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS}, + {L"SignatureSupport", EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS}, + {L"SecureBoot", EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS}, + {L"KEKDefault", EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS}, + {L"PKDefault", EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS}, + {L"dbDefault", EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS}, + {L"dbxDefault", EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS}, + {L"dbtDefault", EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS}, + {L"OsIndicationsSupported", EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS}, + {L"OsIndications", EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_NON_VOLATILE}, + {L"VendorKeys", EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS}, + {NULL, 0} +}; + +STD_EFI_VAR_ENTRY gStdEfiVarListWildCard[] = { + {L"Boot****", EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_NON_VOLATILE}, + {L"Driver****", EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_NON_VOLATILE}, + {L"Key****", EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_NON_VOLATILE}, + {NULL, 0} +}; + +EFI_STATUS ShowBootTimeVariables (BOOLEAN Show); +AMI_NVRAM_CONTROL_PROTOCOL NvramControl = {ShowBootTimeVariables }; + +EFI_STATUS GetVariableHook( + IN CHAR16 *VariableName, IN EFI_GUID *VendorGuid, + OUT UINT32 *Attributes OPTIONAL, + IN OUT UINTN *DataSize, OUT VOID *Data +){ + UINTN i; + EFI_STATUS Result = EFI_UNSUPPORTED; + for(i=0; GetVariableHookList[i] && (Result == EFI_UNSUPPORTED); i++) + Result = GetVariableHookList[i](VariableName, VendorGuid, Attributes, DataSize, Data); + return Result; +} + +EFI_STATUS SetVariableHook( + IN CHAR16 *VariableName, IN EFI_GUID *VendorGuid, + IN UINT32 Attributes, IN UINTN DataSize, IN VOID *Data +){ + UINTN i; + EFI_STATUS Result = EFI_UNSUPPORTED; + for(i=0; SetVariableHookList[i] && (Result == EFI_UNSUPPORTED); i++) + Result = SetVariableHookList [i](VariableName, VendorGuid, Attributes, DataSize, Data); + return Result; +} + +EFI_STATUS GetNextVarNameHook( + IN OUT UINTN *VariableNameSize, + IN OUT CHAR16 *VariableName, IN OUT EFI_GUID *VendorGuid +){ + UINTN i; + EFI_STATUS Result = EFI_UNSUPPORTED; + for(i=0; GetNextVarNameHookList[i] && (Result == EFI_UNSUPPORTED); i++) + Result = GetNextVarNameHookList [i](VariableNameSize, VariableName, VendorGuid); + return Result; +} +//--- GetVariable, SetVariable and GetNextVarName Hooks END ------ + +//Update Interfaces: +//Memory-based +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: DummyUpdateRoutine +// +// Description: This function is dummy function doing nothing and always returning TRUE +// +// Input: IN VOID *Address - Memory address +// UINTN Size - Size +// +// Output: TRUE always +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +BOOLEAN DummyUpdateRoutine(IN VOID *Address, UINTN Size) {return TRUE;} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: MemErase +// +// Description: This function sets Size amount memory starting from Address to FLASH_EMPTY_BYTE +// +// Input: IN VOID *Address - Memory address +// UINTN Size - Size +// +// Output: TRUE always +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +BOOLEAN MemErase(IN VOID *Address, UINTN Size) +{ + MemSet(Address,Size,FLASH_EMPTY_BYTE); + return TRUE; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: MemProgram +// +// Description: This function writs Data to memory starting from Address +// +// Input: IN VOID *Address - Memory address +// UINTN Size - Size of data to write +// VOID *Data - pointer to data to write +// +// Output: TRUE always +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +BOOLEAN MemProgram(IN VOID *Address, UINTN Size, VOID *Data) +{ + MemCpy(Address,Data,Size); + return TRUE; +} + +//Flash-based +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: NvEnableWrites +// +// Description: This function enables writes to flash starting from Address +// +// Input: IN VOID *Address - Start address +// UINTN Size - Size of flash to be write enabled +// +// Output: TRUE always +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +BOOLEAN NvEnableWrites(IN VOID *Address, UINTN Size) +{ + UINT8* Start = (UINT8*)Address; + UINT8* p; + Flash->DeviceWriteEnable(); + + for (p=(UINT8*)BLOCK(Start); p<Start+Size; p+=FlashBlockSize) FlashBlockWriteEnable(p); + + return TRUE; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: NvDisableWrites +// +// Description: This function disables writes to flash starting from Address +// +// Input: IN VOID *Address - Start address +// UINTN Size - Size of flash to be write disable +// +// Output: TRUE always +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +BOOLEAN NvDisableWrites(IN VOID *Address, UINTN Size) +{ + UINT8* Start = (UINT8*)Address; + UINT8* p; + + for (p=(UINT8*)BLOCK(Start); p<Start+Size; p+=FlashBlockSize) FlashBlockWriteDisable(p); + + Flash->DeviceWriteDisable(); + return TRUE; +} + +#define INT_SIZE sizeof(INTN) + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: IsProgrammableOrEqual +// +// Description: This function checks if defined memory chunks are the same and if destenation is programmable +// +// Input: IN UINT8 *pDest - pointer to memory to check +// IN UINT8 *pSource - pointer to the source to compare with +// IN UINTN Size - size of the chunk +// OUT BOOLEAN *pIsProgrammable - Will be set to TRUE if pDest is programable +// OUT BOOLEAN *pIsEqual - Will be set to TRUE if pDest and pSource has the same content +// +// Output: VOID +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +VOID IsProgrammableOrEqual( + IN UINT8 *pDest, + IN UINT8 *pSource, + IN UINTN Size, + OUT BOOLEAN *pIsProgrammable, + OUT BOOLEAN *pIsEqual +) +{ + *pIsEqual = TRUE; + *pIsProgrammable = TRUE; + + // loops through the destination looking to see if the data is the same + // as the source, or if the Destination has already bee erased + if (!( (UINTN)pDest & (INT_SIZE-1) || (UINTN)pSource & (INT_SIZE-1) )) + { + UINTN *Dest = (UINTN*)pDest, *Source = (UINTN*)pSource; + + for ( ; Size >= INT_SIZE; Size -= INT_SIZE) + { + UINTN s,d; + + if (FLASH_EMPTY_BYTE==0) + { + s=~*Source; + if (FlashNotMemoryMapped) + Flash->Read((UINT8 *)Dest, INT_SIZE, &(UINT8)d); + else + d=*Dest; + } + + else + { + s=*Source; + if (FlashNotMemoryMapped) + { + Flash->Read((UINT8 *)Dest, INT_SIZE, &(UINT8)d); + d=~d; + } + else + d=~*Dest; + } + + if ((d&s)!=0) + { + *pIsProgrammable = FALSE; + *pIsEqual = FALSE; + return; + } + if (FlashNotMemoryMapped) + { + Flash->Read((UINT8 *)Dest, INT_SIZE, &(UINT8)d); + if (d != *Source++) *pIsEqual = FALSE; + Dest++; + } + else + if (*Dest++ != *Source++) *pIsEqual = FALSE; + + } + } + + // since the address may not be INT_SIZE aligned, this checks + // the rest of the data + for ( ; Size > 0; Size--) + { + UINT8 s,d; + + if (FLASH_EMPTY_BYTE==0) + { + s=~*pSource; + if (FlashNotMemoryMapped) + Flash->Read(pDest, 1, &d); + else + d=*pDest; + + } + else + { + s=*pSource; + if (FlashNotMemoryMapped) + { + Flash->Read(pDest, 1, &d); + d=~d; + } + else + d=~*pDest; + + } + + if ((d&s)!=0) + { + *pIsProgrammable = FALSE; + *pIsEqual = FALSE; + return; + } + if (FlashNotMemoryMapped) + { + Flash->Read(pDest, 1, &d); + if ( d != *pSource++) *pIsEqual = FALSE; + pDest++; + } + else + if (*pDest++ != *pSource++) + *pIsEqual = FALSE; + + } +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: IsClean +// +// Description: This function checks if defined memory chunk is clean +// +// Input: IN UINT8 *pDest - pointer to memory to check +// IN UINTN Size - size of the chunk +// +// Output: BOOLEAN - TRUE if pDest is clean, otherwice FALSE +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +static BOOLEAN IsClean( + IN UINT8 *pDest, + IN UINTN Size +) +{ + // loops through the destination looking to see if the buffer is empty + if (!( (UINTN)pDest & (INT_SIZE-1) )) + { + for ( ; Size >= INT_SIZE; Size -= INT_SIZE, pDest += INT_SIZE) + { + if (FlashNotMemoryMapped) + { + UINTN nData=0; + Flash->Read(pDest, INT_SIZE, &(UINT8)nData); + if (nData != FlashEmpty) return FALSE; + } + else + if (*(UINTN*)pDest != FlashEmpty) return FALSE; + } + } + + // since the address may not be INT_SIZE aligned, this checks + // the rest of the data + for ( ; Size > 0; Size--, pDest++) + { + if (FlashNotMemoryMapped) + { + UINT8 nData=0; + Flash->Read(pDest, 1, &(UINT8)nData); + if (nData != FLASH_EMPTY_BYTE) return FALSE; + } + else + if (*pDest != FLASH_EMPTY_BYTE) return FALSE; + } + + return TRUE; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: NvProgram +// +// Description: This function programms Size amount of flash starting with Address +// +// Input: IN VOID *Address - pointer to flash to programm +// IN UINTN Size - size of the data to programm +// VOID *Data - pointer to the data to be programed +// +// Output: BOOLEAN - TRUE if pDest is clean, otherwice FALSE +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +BOOLEAN NvProgram(IN VOID *Address, UINTN Size, VOID *Data) +{ + BOOLEAN Status; + BOOLEAN Programmable,Equal; + + if (Size==0) return TRUE; + + IsProgrammableOrEqual(Address,Data,Size,&Programmable,&Equal); + + if (Equal) return TRUE; + + if (!Programmable) return FALSE; + + Status = FlashProgram(Address,Data,(UINT32)Size); + + if (Status) + { + if (FlashNotMemoryMapped) + { + UINT8 nData=0; + UINTN Count=0; + for ( Count=0; Count<Size; Count++) + { + Flash->Read((UINT8 *)Address+Count, 1, &nData ); + Status = ( nData == *((UINT8 *)Data+Count) ); + if (!Status) break; + } + } + else + Status = ( MemCmp(Address,Data,Size) == 0 ); + + } + + if (!Runtime && !Status) ERROR_CODE(DXE_FLASH_UPDATE_FAILED,EFI_ERROR_MAJOR); + + return Status; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: SelectiveAllocate +// +// Description: This function returns pointer to allocated memory to use as +// temp buffer for any occasions. If NvramDriverBuffer is not 0 - +// memory allocated previously will be used. If not - function will +// allocate memory with the Size - and return pointer to it. +// +// Input: IN BOOLEAN FirstPart - if TRUE - first part of NvramDriverBuffer +// will be used. +// IN UINTN Size - size of memory to allocate. +// +// Output: UINT8* - pointer to allocated memory. +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +UINT8* SelectiveAllocate (BOOLEAN FirstPart, UINTN Size) +{ + if (NvramDriverBuffer){ + if (FirstPart){ + if (!FirstPartAlloc){ + FirstPartAlloc = TRUE; + return (UINT8*)NvramDriverBuffer; + }else return NULL; + }else{ + if (!SecondPartAlloc){ + SecondPartAlloc = TRUE; + return (UINT8*)(NvramDriverBuffer + NvramDriverBufferSize / 3 * 2); + }else return NULL; + } + }else{ + if (!Runtime){ +#ifdef DO_NOT_ACCESS_DATA_OUTSIDE_OF_SMM_AT_RUNTIME + if (NoAccessOutsideofSmm){ + UINT8 *Buffer; + EFI_STATUS Status = pSmst->SmmAllocatePool ( + EfiRuntimeServicesData,Size, &Buffer + ); + if (EFI_ERROR(Status)) return NULL; + return Buffer; + } + else +#endif + return (UINT8*)Malloc(Size); + } + } + return NULL; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: SelectiveFree +// +// Description: This function free memory allocated for temp buffer +// for any occasions. If address passed to this function fits +// (NvramDriverBuffer + it's size) range memory allocated in +// NvramDriverBuffer will be released. If not - function will +// call FreePool routine. +// +// Input: UINT8* Target - pointer to the begining of memory to free +// +// Output: VOID +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID SelectiveFree (UINT8* Target) +{ + if (NvramDriverBuffer){ + if (Target == (UINT8*) NvramDriverBuffer){ + FirstPartAlloc = FALSE; + return; + } + if (Target == (UINT8*) (NvramDriverBuffer + NvramDriverBufferSize / 3 * 2)){ + SecondPartAlloc = FALSE; + return; + } + } + if (!Runtime){ +#ifdef DO_NOT_ACCESS_DATA_OUTSIDE_OF_SMM_AT_RUNTIME + if (NoAccessOutsideofSmm) pSmst->SmmFreePool (Target); + else +#endif + pBS->FreePool(Target); + } + return; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: NvErase +// +// Description: This function erases Size amount of flash starting with Address +// +// Input: IN VOID *Address - pointer to flash to erase +// IN UINTN Size - size of the flash to erase +// +// Output: BOOLEAN - TRUE or FALSE based on result +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +BOOLEAN NvErase(IN VOID *Address, UINTN Size) +{ + UINT8* pStart = (UINT8*)Address; + UINT8* pEnd = pStart+Size; + UINT8* pStartBlock = (UINT8*)BLOCK(pStart); + UINT8* pEndBlock = (UINT8*)BLOCK(pEnd-1)+FlashBlockSize; + UINTN PrologSize = pStart - pStartBlock; + UINTN EpilogSize = pEndBlock-pEnd; + UINT8* pBuffer=NULL; + UINT8* p; + BOOLEAN ok; + + if ( Size==0 || IsClean(Address,Size) ) return TRUE; + + if (PrologSize+EpilogSize) + { + pBuffer = SelectiveAllocate (TRUE, (PrologSize + EpilogSize)); + if (pBuffer == NULL) return FALSE; + MemCpy(pBuffer,pStartBlock,PrologSize); + MemCpy(pBuffer+PrologSize,pEnd,EpilogSize); + } + + //erase first block + if (ok=FlashEraseBlock(pStartBlock)) + { + if (PrologSize) ok=NvProgram(pStartBlock,PrologSize,pBuffer); + + if (ok) + { + //erase other blocks + for (p=pStartBlock+=FlashBlockSize; p!=pEndBlock; p+=FlashBlockSize) + { + if (!(ok=FlashEraseBlock(p))) break; + } + + if (ok && EpilogSize) ok=NvProgram(pEnd,EpilogSize,pBuffer+PrologSize); + } + } + + if (pBuffer) SelectiveFree (pBuffer); + + if (!ok) ERROR_CODE(DXE_FLASH_UPDATE_FAILED,EFI_ERROR_MAJOR); + + return ok; +} + +VARIABLE_INTERFACE MemInterface = {DummyUpdateRoutine, DummyUpdateRoutine, MemErase, MemProgram}; +VARIABLE_INTERFACE NvInterface = {NvEnableWrites, NvDisableWrites, NvErase, NvProgram}; + +#ifdef HYBRID_NV_INTERFACE + +UINTN HybridGetAddressDelta(UINT8 *Address, UINTN Size){ + if (VarStoreInfo.NvInfo == 0) return VarStoreInfo.AddressDelta; +//Sometimes VarStoreInfo.NvInterface is used to update +//store other than VarStoreInfo.NvramInfo. +//For example during UpdateFtVarstore it is used to update backup store. +//This function is used to fall-back to non-hybrid interface if varstore other than +//VarStoreInfo.NvramInfo is being updated. + return + ( Address >= VarStoreInfo.NvInfo->NvramAddress + && Address+Size + <= VarStoreInfo.NvInfo->NvramAddress + + VarStoreInfo.NvInfo->NvramSize + ) ? VarStoreInfo.AddressDelta : 0; +} + +BOOLEAN HybridEnableWrites(IN VOID *Address, UINTN Size){ + UINTN Delta = HybridGetAddressDelta(Address,Size); + return NvEnableWrites(Delta+(UINT8*)Address, Size); +} + +BOOLEAN HybridDisableWrites(IN VOID *Address, UINTN Size){ + UINTN Delta = HybridGetAddressDelta(Address,Size); + return NvDisableWrites(Delta+(UINT8*)Address, Size); +} + +BOOLEAN HybridErase(IN VOID *Address, UINTN Size){ + BOOLEAN ok; + UINTN Delta = HybridGetAddressDelta(Address,Size); + ok = NvErase(Delta+(UINT8*)Address, Size); + // Zero Delta implies that there is no memory buffer + if (Delta==0) return ok; + if (ok) return MemErase(Address, Size); + // Flash update operation has failed. + // The memory buffer is out of synch with the flash device. + // Re-synchronize the mememory buffer by reading flash device. + if (FlashNotMemoryMapped) + Flash->Read(Delta+(UINT8*)Address, Size, Address); + else + MemCpy(Address, Delta+(UINT8*)Address, Size); + return FALSE; +} + +BOOLEAN HybridProgram(IN VOID *Address, UINTN Size, VOID *Data){ + BOOLEAN ok; + UINTN Delta = HybridGetAddressDelta(Address,Size); + ok = NvProgram(Delta+(UINT8*)Address, Size, Data); + // Zero Delta implies that there is no memory buffer + if (Delta==0) return ok; + if (ok) return MemProgram(Address, Size, Data); + // Flash update operation has failed. + // The memory buffer is out of synch with the flash device. + // Re-synchronize the mememory buffer by reading flash device. + if (FlashNotMemoryMapped) + Flash->Read(Delta+(UINT8*)Address, Size, Address); + else + MemCpy(Address, Delta+(UINT8*)Address, Size); + return FALSE; +} + +VARIABLE_INTERFACE HybridInterface = {HybridEnableWrites, HybridDisableWrites, HybridErase, HybridProgram}; + +VOID InitHybridInterface(NVRAM_STORE_INFO *NvStore){ + EFI_STATUS Status; + //We can't use InitVolatileStore here because it will screw up SelectiveAllocate/SelectiveFree logic. + + //TODO: When DO_NOT_ACCESS_DATA_OUTSIDE_OF_SMM_AT_RUNTIME is defined, we assume that + //DXE Variable services will be replaced prior to transitioning to runtime. + //If this will not happen, the NVRAM driver may not work properly. + //It may either crash (or crash the Windows), or generate false garbage collections. + //To support fall back scenario the memory allocation below and registration of the virtual address change event must be changed + VarStoreInfo.NvramFlashAddress = NvStore->NvramAddress; + Status = pBS->AllocatePool ( +#ifdef DO_NOT_ACCESS_DATA_OUTSIDE_OF_SMM_AT_RUNTIME + EfiBootServicesData, +#else + EfiRuntimeServicesData, +#endif + NvStore->NvramSize, &NvStore->NvramAddress + ); + if (!EFI_ERROR(Status)){ + VarStoreInfo.NvInterface=&HybridInterface; + MemCpy(NvStore->NvramAddress,VarStoreInfo.NvramFlashAddress,NvStore->NvramSize); + NVRAM_TRACE((TRACE_DXE_CORE,"NVRAM: working in hybrid mode\n")); + }else{ + VarStoreInfo.NvInterface=&NvInterface; + NvStore->NvramAddress = VarStoreInfo.NvramFlashAddress; + } + //We altered content of the varstore. Let's reinitialize it. + NvInitInfoBuffer( + NvStore, VarStoreInfo.HeaderLength, + NVRAM_STORE_FLAG_NON_VALATILE + ); + VarStoreInfo.AddressDelta=VarStoreInfo.NvramFlashAddress-NvStore->NvramAddress; +} + +BOOLEAN SwapVarstoresInHybridMode(NVRAM_STORE_INFO *BackupInfo){ + UINT8* OriginalNvramFlashAddress; + if ( VarStoreInfo.NvramFlashAddress == 0 ) return FALSE; + OriginalNvramFlashAddress=VarStoreInfo.NvramFlashAddress; + + VarStoreInfo.NvramFlashAddress = VarStoreInfo.BackupAddress; + // Zero AddressDelta implies that the memory buffer is no longer used. + if (VarStoreInfo.AddressDelta!=0){ + VarStoreInfo.AddressDelta=VarStoreInfo.NvramFlashAddress-VarStoreInfo.NvInfo->NvramAddress; + + MemCpy( + VarStoreInfo.NvInfo->NvramAddress,VarStoreInfo.BackupAddress, + VarStoreInfo.NvInfo->NvramSize + ); + } + BackupInfo->NvramAddress = VarStoreInfo.NvInfo->NvramAddress; + BackupInfo->NvramSize = VarStoreInfo.NvInfo->NvramSize; + NvInitInfoBuffer( + BackupInfo, VarStoreInfo.HeaderLength, VarStoreInfo.NvInfo->Flags + ); + VarStoreInfo.BackupAddress = OriginalNvramFlashAddress; + return TRUE; +} + +VOID HybridStoreToRealStore(NVRAM_STORE_INFO *InInfo, NVRAM_STORE_INFO *OutInfo){ + *OutInfo = *InInfo; + OutInfo->NvramAddress = VarStoreInfo.NvramFlashAddress; + OutInfo->NvramGuidsAddress = (EFI_GUID*)((UINT8*)OutInfo->NvramGuidsAddress + VarStoreInfo.AddressDelta); + OutInfo->pEndOfVars += VarStoreInfo.AddressDelta; + OutInfo->pFirstVar += VarStoreInfo.AddressDelta; + OutInfo->pLastReturned=0; +} + +#ifdef DO_NOT_ACCESS_DATA_OUTSIDE_OF_SMM_AT_RUNTIME +VOID ReallocateHybridVarstoreToSmm(){ + NVRAM_STORE_INFO *Info = VarStoreInfo.NvInfo; + UINT8* SmmBuffer; + UINT32 i; + UINT8* NvramAddress; + UINT8* EndOfVars; + + EFI_STATUS Status = pSmst->SmmAllocatePool ( + EfiRuntimeServicesData, + Info->NvramSize, &SmmBuffer + ); + if (EFI_ERROR(Status)){ + // Zero AddressDelta implies that the memory buffer is no longer used. + VarStoreInfo.AddressDelta=0; + return; + } + MemCpy( + SmmBuffer,Info->NvramAddress,Info->NvramSize + ); + VarStoreInfo.AddressDelta=SmmBuffer-Info->NvramAddress; + NvramAddress = Info->NvramAddress; + EndOfVars= Info->pEndOfVars; + // Fix up the main NVRAM store and nested variable stores. + // An example of a nested store is the defaults store. + for (i=0; i<VarStoreInfo.InfoCount; i++){ + // If a store is embedded into the main NVRAM store, + // fix it up with the SMM buffer address + if ( VarStoreInfo.NvramInfo[i].NvramAddress >= NvramAddress + && VarStoreInfo.NvramInfo[i].pEndOfVars <= EndOfVars + ){ + VarStoreInfo.NvramInfo[i].NvramAddress += VarStoreInfo.AddressDelta; + VarStoreInfo.NvramInfo[i].NvramGuidsAddress = (EFI_GUID*)((UINT8*)VarStoreInfo.NvramInfo[i].NvramGuidsAddress + VarStoreInfo.AddressDelta); + VarStoreInfo.NvramInfo[i].pEndOfVars += VarStoreInfo.AddressDelta; + VarStoreInfo.NvramInfo[i].pFirstVar += VarStoreInfo.AddressDelta; + VarStoreInfo.NvramInfo[i].pLastReturned=0; + } + } + VarStoreInfo.AddressDelta=VarStoreInfo.NvramFlashAddress-SmmBuffer; +} +#endif // DO_NOT_ACCESS_DATA_OUTSIDE_OF_SMM_AT_RUNTIME +#endif + +#ifdef DO_NOT_ACCESS_DATA_OUTSIDE_OF_SMM_AT_RUNTIME +VOID ReallocateVolatileVarstoreToSmm(){ + NVRAM_STORE_INFO *Info = VarStoreInfo.MemInfo; + UINT8* SmmBuffer; + UINTN Delta; + + EFI_STATUS Status = pSmst->SmmAllocatePool ( + EfiRuntimeServicesData, + Info->NvramSize, &SmmBuffer + ); + if (EFI_ERROR(Status)){ + //TODO: Shutdown non-valatile services; + ASSERT(FALSE); + return; + } + MemCpy( + SmmBuffer,Info->NvramAddress,Info->NvramSize + ); + Delta=SmmBuffer-Info->NvramAddress; + Info->NvramAddress = SmmBuffer; + Info->NvramGuidsAddress = (EFI_GUID*)((UINT8*)Info->NvramGuidsAddress + Delta); + Info->pEndOfVars += Delta; + Info->pFirstVar += Delta; + Info->pLastReturned=0; +} +#endif + +/////////////////////////////////////////////////////////////////////////// +//Cache operations +#define NV_CACHE_SUPPORT 1 + +typedef struct +{ + DLINK Link; + NVAR *Nvar; + NVAR *FinalDataNvar; + UINT32 InfoIndex; + CHAR16 Name[8]; +} VAR_INDEX_ENTRY; + +typedef struct +{ + DLIST LetterIndex['z'-'a'+1]; + DLIST OtherIndex; + DLIST Blanks; + UINT8 *Buffer; + UINTN UsedSize; + UINTN BufferSize; +} VAR_INDEX; + +#if !NV_CACHE_SUPPORT +VAR_INDEX *VarIndexPtr=NULL; +#else +#define VARIABLE_INDEX_SIZE 0x10000 + +VAR_INDEX VarIndex; +VAR_INDEX *VarIndexPtr=&VarIndex; + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: IsNvramRuntime +// +// Description: This function returns the value of Runtime local variable +// +// Input: None +// +// Output: BOOLEAN - current value of Runtime local variable +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +BOOLEAN IsNvramRuntime() +{ + return Runtime; +} + +BOOLEAN AreBtVariablesHidden() +{ + return HideBtVariables && Runtime; +} +EFI_STATUS ShowBootTimeVariables (BOOLEAN Show){ + HideBtVariables = !Show; + TRACE((-1,"Setting HideBtVariables to %d\n",HideBtVariables)); + return EFI_SUCCESS; +} + +EFI_STATUS InstallNvramControlSmmProtocol(){ + return pSmst->SmmInstallConfigurationTable( + pSmst, &gAmiNvramControlProtocolGuid, &NvramControl, sizeof(NvramControl) + ); +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: IndexGetList +// +// Description: This function gets list of variables starting with FirstLetter +// +// Input: CHAR16 FirstLetter - letter to search +// +// Output: DLIST* - pointer to list of Var starting with FirstLetter +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +DLIST* IndexGetList(CHAR16 FirstLetter) +{ + //convert to lower case + if (FirstLetter>='A'&&FirstLetter<='Z') FirstLetter -= 'A'; + else if (FirstLetter>='a'&&FirstLetter<='z') FirstLetter -= 'a'; + else return &VarIndexPtr->OtherIndex; + + return &VarIndexPtr->LetterIndex[FirstLetter]; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: IndexGetListNvar +// +// Description: This function gets list of variables starting with First Letter of Nvar +// +// Input: NVAR *Nvar - pointer to Var +// +// Output: DLIST* - pointer to list of Var +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +DLIST* IndexGetListNvar(NVAR *Nvar) +{ + VOID *NamePtr; + CHAR16 FirstLetter; + + NamePtr = NvGetName(Nvar); + FirstLetter = (Nvar->flags&NVRAM_FLAG_ASCII_NAME) ? *(CHAR8*)NamePtr : *(CHAR16*)NamePtr; + return IndexGetList(FirstLetter); +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: IndexFindVariableEntry +// +// Description: This function searches for Var with specific GUID +// +// Input: IN CHAR16 *VariableName - pointer to Var Name in Unicode +// IN EFI_GUID *VendorGuid - pointer to Var GUID +// OUT UINTN *VariableNameSize - size of Var name +// OUT NVRAM_STORE_INFO **Info - double pointer to NVRAM_STORE_INFO structure +// OUT BOOLEAN *UnindexedExists - indicator, that there is unindexed variables +// +// Output: VAR_INDEX_ENTRY* - pointer to Var's Index entry found; NULL if not found +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +VAR_INDEX_ENTRY* IndexFindVariableEntry( + IN CHAR16 *VariableName, IN EFI_GUID *VendorGuid, + OUT UINTN *VariableNameSize, + OUT NVRAM_STORE_INFO **Info, OUT BOOLEAN *UnindexedExists +) +{ + DLINK *Link; + VAR_INDEX_ENTRY* Entry; + UINTN Count; + DLIST *List; + BOOLEAN CorruptedEntryFound; + + if (VarIndexPtr==NULL) + { + *UnindexedExists=TRUE; + return NULL; + } + + List = IndexGetList(VariableName[0]); + CorruptedEntryFound = FALSE; + + for (Link=List->pHead, Count=0; Link!=NULL; Link=Link->pNext, Count++) + { + UINTN i; + Entry = OUTTER(Link,Link, VAR_INDEX_ENTRY); + + for (i=0; i<sizeof(Entry->Name)/sizeof(CHAR16)&&Entry->Name[i]; i++) + if (Entry->Name[i]!=VariableName[i+1]) break; + + if (Entry->Name[i]&&Entry->Name[i]!=VariableName[i+1]) continue; + + if(!NvIsVariable( Entry->Nvar, + &VarStoreInfo.NvramInfo[Entry->InfoIndex] + ) + ){ + CorruptedEntryFound = TRUE; + continue; + } + + if (NvVarEq( + Entry->Nvar,VariableName,VendorGuid, + VariableNameSize,&VarStoreInfo.NvramInfo[Entry->InfoIndex] + ) + ) break; + } + + //entry found + if (Link!=NULL) + { + *Info=&VarStoreInfo.NvramInfo[Entry->InfoIndex]; + //VariableNameSize has already been initialized by the NvVarEq call + //Make sure the cached final data Nvar is valid + if (Entry->FinalDataNvar==NULL) + Entry->FinalDataNvar=NvGetDataNvar(Entry->Nvar, *Info); + + return Entry; + } + + *UnindexedExists=CorruptedEntryFound || Count<List->Size; + return NULL; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: IndexFindVariable +// +// Description: This function searches for Var with specific GUID +// +// Input: IN CHAR16 *VariableName - pointer to Var Name in Unicode +// IN EFI_GUID *VendorGuid - pointer to Var GUID +// OUT UINTN *VariableNameSize - size of Var name +// OUT NVRAM_STORE_INFO **Info - double pointer to NVRAM_STORE_INFO structure +// OUT BOOLEAN *UnindexedExists - indicator, that there is unindexed variables +// +// Output: NVAR* - pointer to Var found; NULL if not found +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +NVAR* IndexFindVariable( + IN CHAR16 *VariableName, IN EFI_GUID *VendorGuid, + OUT UINTN *VariableNameSize, + OUT NVRAM_STORE_INFO **Info, OUT BOOLEAN *UnindexedExists +) +{ + VAR_INDEX_ENTRY* Entry = IndexFindVariableEntry( + VariableName, VendorGuid, + VariableNameSize, + Info, UnindexedExists + ); + if (Entry != NULL) return Entry->Nvar; + + return NULL; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: IndexGetBlankEntry +// +// Description: This function searches for the blank entry in VarIndexPtr structure +// +// Input: NONE +// +// Output: VAR_INDEX_ENTRY* - pointer to the blank entry, NUUL if no space +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +VAR_INDEX_ENTRY* IndexGetBlankEntry() +{ + VAR_INDEX_ENTRY* Entry; + //---Check if there is space in buffer----- + if (VarIndexPtr->UsedSize<=VarIndexPtr->BufferSize-sizeof(VAR_INDEX_ENTRY)) + { + Entry = (VAR_INDEX_ENTRY*)(VarIndexPtr->Buffer+VarIndexPtr->UsedSize); + VarIndexPtr->UsedSize+=sizeof(VAR_INDEX_ENTRY); + } + //---If not - check in blanks-------- + else if (!DListEmpty(&VarIndexPtr->Blanks)) + { + Entry = OUTTER( + VarIndexPtr->Blanks.pTail, + Link, VAR_INDEX_ENTRY + ); + DListDelete(&VarIndexPtr->Blanks,&Entry->Link); + } + + else + { + Entry = NULL; + } + + return Entry; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: IndexAddVariable +// +// Description: This function adds new Var +// +// Input: NVAR *Nvar - pointer to Var +// IN NVRAM_STORE_INFO *Info - pointer to NVRAM_STORE_INFO structure +// +// Output: VOID +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +VOID IndexAddVariable( + IN NVAR *Nvar, IN NVRAM_STORE_INFO *Info +) +{ + DLIST *List; + VAR_INDEX_ENTRY *Entry; + UINTN i; + VOID *NamePtr; + + if (VarIndexPtr==NULL) return ; + + List = IndexGetListNvar(Nvar); + Entry = IndexGetBlankEntry(); + + if (Entry==NULL) + { + List->Size++; + return; + } + + Entry->Nvar=Nvar; + Entry->FinalDataNvar=NULL; + Entry->InfoIndex= (UINT32)(Info-&VarStoreInfo.NvramInfo[0]); + ASSERT(Entry->InfoIndex<VarStoreInfo.InfoCount) + NamePtr=NvGetName(Nvar); + + if (Nvar->flags&NVRAM_FLAG_ASCII_NAME) + { + CHAR8 *N = (CHAR8*)NamePtr+1; + + for (i=0; i<sizeof(Entry->Name)/sizeof(CHAR16)-1&&N[i]!=0; i++) + Entry->Name[i]=N[i]; + } + + else + { + CHAR16 *N = (CHAR16*)NamePtr+1; + + for (i=0; i<sizeof(Entry->Name)/sizeof(CHAR16)-1&&N[i]!=0; i++) + Entry->Name[i]=N[i]; + } + + Entry->Name[i]=0; + DListAdd(List,&Entry->Link); +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: IndexUpdateVariable +// +// Description: This function searces for Var and if it is found updates it, or add new var otherwise +// +// Input: NVAR *Nvar - pointer to Var +// IN NVRAM_STORE_INFO *Info - pointer to NVRAM_STORE_INFO structure +// +// Output: VOID +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +VOID IndexUpdateVariable( + IN NVAR *Nvar, IN NVRAM_STORE_INFO *Info +) +{ + VAR_INDEX_ENTRY *Entry=NULL; + DLIST *List = IndexGetListNvar(Nvar); + DLINK *Link; + + if (VarIndexPtr==NULL) return ; + + for (Link=List->pHead; Link!=NULL; Link=Link->pNext) + { + VAR_INDEX_ENTRY *TmpEntry = OUTTER(Link,Link, VAR_INDEX_ENTRY); + + if(!NvIsVariable(TmpEntry->Nvar, + &VarStoreInfo.NvramInfo[TmpEntry->InfoIndex] + ) + ) continue; + + if (NvarEqNvar(TmpEntry->Nvar,&VarStoreInfo.NvramInfo[TmpEntry->InfoIndex],Nvar,Info)) + { + Entry=TmpEntry; + break; + } + } + + if (Entry==NULL) + { + IndexAddVariable(Nvar,Info); + } + else + { + Entry->Nvar=Nvar; + Entry->FinalDataNvar=NULL; + Entry->InfoIndex= (UINT32)(Info-&VarStoreInfo.NvramInfo[0]); + ASSERT(Entry->InfoIndex<VarStoreInfo.InfoCount) + } +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: IndexDeleteVariable +// +// Description: This function deletes Var and adds it's entry in VarIndexPtr to blanks +// +// Input: NVAR *Nvar - pointer to Var to delete +// +// Output: VOID +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +VOID IndexDeleteVariable(NVAR *Nvar) +{ + VAR_INDEX_ENTRY *Entry=NULL; + DLIST *List = IndexGetListNvar(Nvar); + DLINK *Link; + + if (VarIndexPtr==NULL) return ; + + for (Link=List->pHead; Link!=NULL; Link=Link->pNext) + { + Entry = OUTTER(Link,Link, VAR_INDEX_ENTRY); + + if (Entry->Nvar==Nvar) + { + DListDelete(List,&Entry->Link); + DListAdd(&VarIndexPtr->Blanks,&Entry->Link); + return; + } + } +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: IndexDeleteVariableEntry +// +// Description: This function deletes Var and adds it's entry in VarIndexPtr to blanks +// +// Input: VAR_INDEX_ENTRY *Entry - pointer to Entry to delete +// +// Output: VOID +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +VOID IndexDeleteVariableEntry(VAR_INDEX_ENTRY *Entry) +{ + DLIST *List; + if (Entry == NULL) return; + + List = IndexGetListNvar(Entry->Nvar); + + if (VarIndexPtr==NULL) return ; + + DListDelete(List,&Entry->Link); + DListAdd(&VarIndexPtr->Blanks,&Entry->Link); +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: IndexReset +// +// Description: This function resets the VarIndexPtr and updates VarStoreInfo structures +// +// Input: NONE +// +// Output: VOID +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +VOID IndexReset() +{ + INTN i; + + if (VarIndexPtr==NULL) return ; + + VarIndexPtr->UsedSize=0; + + for (i=0; i<='z'-'a'; i++) DListInit(&VarIndexPtr->LetterIndex[i]); + //---Reset fields in VarIndexPtr--------------- + DListInit(&VarIndexPtr->OtherIndex); + DListInit(&VarIndexPtr->Blanks); + + for (i=(INTN)VarStoreInfo.InfoCount-1; i>=0; i--) + { + NVRAM_STORE_INFO *Info = &VarStoreInfo.NvramInfo[i]; + NVAR *Nvar=(NVAR*)Info->pFirstVar; + + if (!NvIsVariable(Nvar,Info)) continue; + + for (; Nvar!=NULL; Nvar=NvGetNextValid(Nvar,Info)) + IndexUpdateVariable(Nvar,Info); + } +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: IndexInit +// +// Description: This function allocates memory for Var Index Buffer and fils pointer to it in +// VarIndexPtr stucture +// +// Input: NONE +// +// Output: VOID +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +VOID IndexInit() +{ + EFI_STATUS Status = pBS->AllocatePool( + EfiBootServicesData, + VARIABLE_INDEX_SIZE, + &VarIndexPtr->Buffer + ); + + if (EFI_ERROR(Status)) + { + VarIndexPtr=NULL; + return; + } + VarIndexPtr->BufferSize = VARIABLE_INDEX_SIZE; + IndexReset(); +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: IndexExitBs +// +// Description: This function resets VarIndexPtr to NULL on Exit BS +// +// Input: NONE +// +// Output: VOID +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +VOID IndexExitBs() +{ + VarIndexPtr = NULL; +} + +VOID IndexVirtualFixup() +{ + +} +#endif +/////////////////////////////////////////////////////////////////////////// +//Basic operations +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: IsEnoughSpace +// +// Description: This function checks is there is Size space avaiable in NVRAM_STORE_INFO +// +// Input: NVRAM_STORE_INFO* Info - pointer to NVRAM_STORE_INFO stucture +// UINTN Size - Size to check for +// +// Output: BOOLEAN - TRUE if space avaiable, FALSE otherwise +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +BOOLEAN IsEnoughSpace(NVRAM_STORE_INFO* Info, UINTN Size) +{ + return ( Info->pEndOfVars + Size + <= Info->NvramAddress+Info->NvramSize - sizeof(EFI_GUID)*(Info->NextGuid+1) - sizeof(NVAR) + ); +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: RecoverFromFlashUpdateFailure +// +// Description: This function checks is there was a flash update failure and signal about it +// to CheckStore +// +// Input: NVRAM_STORE_INFO* Info - pointer to NVRAM_STORE_INFO stucture +// VOID *EndOfVars - End of Vars pointer +// UINTN DataSize - Size of data, that was programed +// NVAR *PrevVar - pointer to previous instance of Var +// +// Output: VOID +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +VOID RecoverFromFlashUpdateFailure( + NVRAM_STORE_INFO *Info, VOID *EndOfVars, UINTN DataSize, NVAR *PrevVar +) +{ + UINT8 *p; + NVAR *NewVar; + + //Nothing has been programmed. Just return + if (EndOfVars==Info->pEndOfVars) return; + + NewVar = (NVAR*)Info->pEndOfVars; + //Check if variable size has been programmed correctly + if (NewVar->size==DataSize) + { + // Let's see if the signature is correct. + // If the signature is correct, let's see if + // the 'next' field has been properly updated. + if ( NewVar->signature==NvramSignature + && NvGetDataNvar(PrevVar, Info) != NewVar + ){ + // if we are here, the next field has not been properly udpated + // leave pInfo->pEndOfVars at the address of the last record. + Info->LastVarSize=(VAR_SIZE_TYPE)DataSize; + return; + } + //Yes, the size has been programmed correctly. + //NvGetNextNvar routine is smart enough to skip + //invalid records with valid size. + Info->pEndOfVars+=DataSize;//Update Info->pEndOfVars + Info->LastVarSize=0;//Opearaion failed, set Info->LastVarSize to zero + return; + } + + //check if something has actually been programmed + for (p=Info->pEndOfVars; p<(UINT8*)EndOfVars && *p==FLASH_EMPTY_BYTE; p++) ; + + //if nothing has been programmed, just return + if (p==EndOfVars) return; + + //if we reached this point, NVRAM store is corruped + //Set pInfo->pEndOfVars at the address of corruption. + //This will trigger recovery operation + //(See 'Error Recovery' section at the end of the DxeSetVariable routine). + Info->pEndOfVars = p; + Info->LastVarSize=(VAR_SIZE_TYPE)DataSize; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: GetVarAuthExtFlags +// +// Description: This function returns Security fields Mc and KeyHash form existing +// Var in Var store +// It is called called every time variable with one of +// UEFI23_1_AUTHENTICATED_VARIABLE_ATTRIBUTES is being verified. +// +// Input: NVAR *Var pointer to the 1st instance of Var +// NVRAM_STORE_INFO *pInfo - pointer to NVRAM store structure +// OUT EXT_SEC_FLAGS->MonotonicCount - value of MC or TIME stamp +// OUT EXT_SEC_FLAGS->KeyHash - pointer to memory, allocated by caller, +// where Hash of PublicKeyDigest will be returned. +// +// Output: *EXT_SEC_FLAGS +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +VOID +GetVarAuthExtFlags( + IN NVAR *Var, + IN NVRAM_STORE_INFO *pInfo, + OUT EXT_SEC_FLAGS *ExtFlags +) +{ + if(Var==NULL || pInfo==NULL || ExtFlags==NULL) + return; +// Return Authenticate attributes along with NonVolitile attrib + if ( pInfo->Flags & NVRAM_STORE_FLAG_NON_VALATILE ) + ExtFlags->AuthFlags |=EFI_VARIABLE_NON_VOLATILE; + + if(Var->flags & (NVRAM_FLAG_AUTH_WRITE | NVRAM_FLAG_EXT_HEDER)) { + ExtFlags->AuthFlags |= (UINT8)(*NvGetExtFlags (Var) & UEFI23_1_AUTHENTICATED_VARIABLE_ATTRIBUTES) ;//(NVRAM_eFLAG_TIME_BASED_AUTH_WRITE | NVRAM_eFLAG_AUTH_WRITE)); + ExtFlags->Mc = (*(UINT64*)(NvGetExtFlags (NvGetDataNvar(Var, pInfo)) + 1)); + MemCpy(&ExtFlags->KeyHash[0], (VOID*)(NvGetExtFlags (Var) + 1 + 8), HASH_SHA256_LEN); + } +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: FlashMemFlashWrite +// +// Description: This function used to copy some information from one part of +// flash to another, when flash is not memory mapped. It uses temporary +// buffer one or more times. +// +// Input: IN VARIABLE_INTERFACE *Interface - pointer to Variable interface +// IN OUT UINT8 **PointerTo - Destination +// IN VOID *From - Source +// IN UINTN SizeToWrite - in bytes. +// IN NVRAM_STORE_INFO *Info - pointer to NVRAM_STORE_INFO stucture +// +// Output: *EXT_SEC_FLAGS +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +BOOLEAN +FlashMemFlashWrite( + IN VARIABLE_INTERFACE *Interface, + IN OUT UINT8 **PointerTo, + IN VOID *From, + IN UINTN SizeToWrite, + IN NVRAM_STORE_INFO *Info +) +{ + UINT8 TempMemory [256]; + UINT8 *TempFrom = (UINT8*)From; + UINT16 TempSize; + BOOLEAN Result; + + do + { + Interface->DisableUpdate(Info->NvramAddress,Info->NvramSize); + if (SizeToWrite <= 256) + TempSize = (UINT16) SizeToWrite; + else + { + TempSize = 256; + SizeToWrite -= 256; + } + MemCpy(TempMemory, TempFrom, TempSize); + Interface->EnableUpdate(Info->NvramAddress,Info->NvramSize); + Result = Interface->WriteBytes(*PointerTo, TempSize, TempMemory); + *PointerTo += TempSize; + if ((TempSize < 256) || (SizeToWrite == 0) || !Result) break; + TempFrom += TempSize; + } + while (TRUE); + return Result; +} +#if AuthVariable_SUPPORT +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: FindVariable +// +// Description: This function searches for Var with specific GUID and Name +// +// Input: IN CHAR16 *VariableName - pointer to Var Name in Unicode +// IN EFI_GUID *VendorGuid - pointer to Var GUID +// OUT UINT32* Attributes - Pointer to memory where Attributes will be returned +// IN OUT UINTN *DataSize - size of Var - if smaller than actual EFI_BUFFER_TOO_SMALL +// will be returned and DataSize will be set to actual size needed +// OUT VOID *Data - Pointer to memory where Var is loacted +// +// Output: EFI_STATUS - based on result +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS FindVariable( + IN CHAR16 *VariableName, IN EFI_GUID *VendorGuid, + OUT UINT32 *Attributes , + IN OUT UINTN *DataSize, OUT VOID **Data +) +{ + UINTN VariableNameSize; + NVRAM_STORE_INFO *Info; + NVAR *Nvar; + + Info = VarStoreInfo.NvInfo; + Nvar = (NVAR*)NvFindVariable(VariableName,VendorGuid,&VariableNameSize,Info); + + if ((Nvar != NULL) && (Data != NULL)) + { +// if (Runtime && !(Nvar->flags & NVRAM_FLAG_RUNTIME)) return EFI_NOT_FOUND; + if (Attributes) + if (EFI_ERROR(NvGetAttributesFromNvar(Nvar, Info, Attributes))) + return EFI_NOT_FOUND; + + *Data = (UINT8*)NvGetData(Nvar, VariableNameSize, DataSize, Info); + + return EFI_SUCCESS; + } + + return EFI_NOT_FOUND; +} +#endif + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: CreateVariableEx +// +// Description: This function adds new variable to Varstore +// +// Input: IN CHAR16 *VariableName - pointer to Var Name in Unicode +// IN EFI_GUID *VendorGuid - pointer to Var GUID +// IN UINT32 Attributes - attributes of Variable +// IN UINTN DataSize - size of Var data +// IN VOID *Data - pointer to the Var data +// OUT NVRAM_STORE_INFO *Info - pointer to NVRAM_STORE_INFO structure +// VARIABLE_INTERFACE *Interface - pointer to the interface with the Variable routins +// (OPTIONAL) NVAR* OldVar - in case of garbage collection pointer to the first i +// nstance of variable to get Monotonic Counter and Flags from +// (OPTIONAL) NVRAM_STORE_INFO *FromInfo - in case of garbage collection pointer to the +// store info strucrure - to get Public Key from +// +// Output: EFI_STATUS +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS CreateVariableEx( + IN CHAR16 *VariableName, IN EFI_GUID *VendorGuid, + IN UINT32 Attributes, IN UINTN DataSize, IN VOID *Data, + NVRAM_STORE_INFO *Info, VARIABLE_INTERFACE *Interface, OPTIONAL NVAR* OldVar, EXT_SEC_FLAGS *ExtSecFlags, + OPTIONAL VOID *AppendData, OPTIONAL UINTN AppendDataSize +) +{ + UINTN Size=sizeof(NVAR) + AppendDataSize, ExtSize = 0; + NVAR Var = {FLASH_EMPTY_SIGNATURE,0,FLASH_EMPTY_NEXT,NVRAM_FLAG_VALID}; + CHAR16* s; + EFI_GUID* Guid; + INT16 guid=0; + BOOLEAN ok; + UINT8 *p, *p1, Dummy, ExtFlags = 0; + + if (Attributes & EFI_VARIABLE_RUNTIME_ACCESS) + Var.flags |= NVRAM_FLAG_RUNTIME; +#if AuthVariable_SUPPORT + if ( Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD ) + Var.flags |= NVRAM_FLAG_HARDWARE_ERROR_RECORD; + if (Attributes & UEFI23_1_AUTHENTICATED_VARIABLE_ATTRIBUTES/*EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS*/) + { + Var.flags |= NVRAM_FLAG_EXT_HEDER | NVRAM_FLAG_AUTH_WRITE; + ExtSize = 1 + 8 + HASH_SHA256_LEN + 2; //ExtFlags + Monotonic Counter + PublicKeyDigest Hash + ExtSize + ExtFlags |= Attributes & UEFI23_1_AUTHENTICATED_VARIABLE_ATTRIBUTES; + // We store PublicKeyDigest Hash only in the first instance of Var in store to save space + } +#endif + if (NvramChecksumSupport) + { + Var.flags |= NVRAM_FLAG_EXT_HEDER; + if (ExtSize == 0) ExtSize += 4; // ExtSize - Ext Flag, Checksumm and Size + else ExtSize += 1; // Add Checksumm Feild + ExtFlags |= NVRAM_EXT_FLAG_CHECKSUM; + } + + //find GUID in the GUID area + for ( Guid=Info->NvramGuidsAddress + ; Guid>Info->NvramGuidsAddress-Info->NextGuid + && guidcmp(Guid,VendorGuid) + ; Guid-- + ) guid++; + + if (((OldVar != NULL) && (OldVar->flags & NVRAM_FLAG_GUID)) || (Info->NextGuid>255 && guid>=Info->NextGuid)) + { + Var.flags |= NVRAM_FLAG_GUID; + Size+=sizeof(EFI_GUID); + } + + else + { + Size+=1; + } + + //Alalize the name. Check if it has non basic Latin characters + for (s=VariableName; *s&&!*((CHAR8*)s+1); s++) ; + + if (!*s) + { + Var.flags |= NVRAM_FLAG_ASCII_NAME; + Size+=s-VariableName+1; + } + + else + { + while (*s++); + + Size+=(UINT8*)s-(UINT8*)VariableName; + } + if ((UINTN)(~0) - Size < DataSize + ExtSize) + return EFI_OUT_OF_RESOURCES; + + Size += DataSize + ExtSize; + + if (!IsEnoughSpace(Info,Size)) return EFI_OUT_OF_RESOURCES; + + Var.size=(VAR_SIZE_TYPE)Size; + Interface->EnableUpdate(Info->NvramAddress,Info->NvramSize); + p = Info->pEndOfVars; + + do + { + //Program Var at pEndOfVars + ok=Interface->WriteBytes(p,sizeof(NVAR),&Var); + p += sizeof(NVAR); + + if (!ok) break; + + //Program Guid + if (Var.flags&NVRAM_FLAG_GUID) + { + //program the whole guid + ok=Interface->WriteBytes(p,sizeof(EFI_GUID),VendorGuid); + p+=sizeof(EFI_GUID); + } + + else + { + //program the whole guid at NVRAM_GUIDS_ADDRESS - NextGuid + if (guid==Info->NextGuid) + { + ok=Interface->WriteBytes( + (UINT8*)(Info->NvramGuidsAddress-Info->NextGuid), + sizeof(EFI_GUID),VendorGuid + ); + Info->NextGuid++; + + if (!ok) break; + } + + //program guid(1 byte) at pEndOfVars+sizeof(NVAR); + ok=Interface->WriteBytes(p++,1,&guid); + } + + if (!ok) break; + + //Program name and data + if (Var.flags&NVRAM_FLAG_ASCII_NAME) + { + UINT8* q; + + for (q=(UINT8*)VariableName; *(CHAR16*)q && ok ; q+=2,p++) + ok = Interface->WriteBytes(p,1,q); + + if (ok) ok = Interface->WriteBytes(p++,1,q); //zero at end + } + + else + { + UINT16* q; + + for (q=VariableName; *q && ok ; q++,p+=2) + ok = Interface->WriteBytes(p,2,q); + + if (ok) + { + ok = Interface->WriteBytes(p,2,q); //zero at end + p+=2; + } + } + + if (!ok) break; + + //AppendWrite after Garbage collection + if (Attributes & EFI_VARIABLE_APPEND_WRITE) { + if (FlashNotMemoryMapped){ + ok=FlashMemFlashWrite(Interface, &p, AppendData, AppendDataSize, Info); + } + else + { + ok=Interface->WriteBytes(p,AppendDataSize,AppendData); + p+=AppendDataSize; + } + if (!ok) break; + } + + //Program data + ok=Interface->WriteBytes(p,DataSize,Data); + p+=DataSize; + p1=p; + + if (!ok) break; + + //---Fill Ext area--- + if (Attributes & UEFI23_1_AUTHENTICATED_VARIABLE_ATTRIBUTES/*EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS*/) + { + ok=Interface->WriteBytes(p, 1, &ExtFlags);//--Ext Flag + if (!ok) break; + p += 1; + ok=Interface->WriteBytes(p, 8, &ExtSecFlags->Mc);//--Monotonic counter + if (!ok) break; + p += 8; + ok=Interface->WriteBytes(p, HASH_SHA256_LEN, &ExtSecFlags->KeyHash[0]);//--Public Key Hash + if (!ok) break; + p = Info->pEndOfVars + Size - 2; + ok=Interface->WriteBytes(p, 2,&ExtSize);//--Ext Size + if (!ok) break; + } + if (NvramChecksumSupport) + { + if (!(Var.flags & NVRAM_FLAG_AUTH_WRITE)) // ???NVRAM_FLAG_EXT_HEDER + { + p = p1 + ExtSize; + //write ExtSize + ok=Interface->WriteBytes(p-sizeof(VAR_SIZE_TYPE),sizeof(VAR_SIZE_TYPE),&ExtSize); + if (!ok) break; + //write ExtFlags + ok=Interface->WriteBytes(p1, 1, &ExtFlags); + if (!ok) break; + //write checksum + if (FlashNotMemoryMapped) + Interface->DisableUpdate(Info->NvramAddress,Info->NvramSize); + + Dummy = NvCalculateNvarChecksum((NVAR*)Info->pEndOfVars); + + if (FlashNotMemoryMapped) + Interface->EnableUpdate(Info->NvramAddress,Info->NvramSize); + + //adjust to exclude empty checksum field + Dummy += FLASH_EMPTY_BYTE; + ok=Interface->WriteBytes(p-3, 1, &Dummy); + if (!ok) break; + } + else + { + p = p1 + ExtSize; + if (FlashNotMemoryMapped) + Interface->DisableUpdate(Info->NvramAddress,Info->NvramSize); + + Dummy = NvCalculateNvarChecksum((NVAR*)Info->pEndOfVars); + + if (FlashNotMemoryMapped) + Interface->EnableUpdate(Info->NvramAddress,Info->NvramSize); + //adjust to exclude empty checksum field + Dummy += FLASH_EMPTY_BYTE; + ok=Interface->WriteBytes(p-3, 1, &Dummy); + if (!ok) break; + } + } + //write a signature + ok=Interface->WriteBytes( + Info->pEndOfVars,sizeof(NvramSignature),(VOID*)&NvramSignature + ); + + } + while (FALSE); + + Interface->DisableUpdate(Info->NvramAddress,Info->NvramSize); + + if (ok) + { + Info->pEndOfVars += Size; + Info->LastVarSize=(VAR_SIZE_TYPE)Size; + } + + else + { + RecoverFromFlashUpdateFailure(Info,p,Size,(NVAR*)Info->pEndOfVars); + } + + return (ok) ? EFI_SUCCESS : EFI_DEVICE_ERROR; +} + +EFI_STATUS CreateVariable( + IN CHAR16 *VariableName, IN EFI_GUID *VendorGuid, + IN UINT32 Attributes, IN UINTN DataSize, IN VOID *Data, + NVRAM_STORE_INFO *Info, VARIABLE_INTERFACE *Interface, OPTIONAL NVAR* OldVar, EXT_SEC_FLAGS *ExtSecFlags +) +{ + return CreateVariableEx(VariableName, VendorGuid, Attributes, DataSize, + Data, Info, Interface, OldVar, ExtSecFlags, NULL, 0); +} +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: UpdateVariable +// +// Description: This function updates variable +// +// Input: IN NVAR *OldVar - pointer to the old Var +// IN CHAR16 *VariableName - pointer to Var Name in Unicode +// IN UINTN NameSize - size of the Var mane +// IN EFI_GUID *VendorGuid - pointer to Var GUID +// IN UINT32 Attributes - attributes of Variable +// IN UINTN DataSize - size of Var data +// IN VOID *Data - pointer to the Var data +// OUT NVRAM_STORE_INFO *Info - pointer to NVRAM_STORE_INFO structure +// VARIABLE_INTERFACE *Interface - pointer to the interface with the Variable routins +// +// Output: EFI_STATUS +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS UpdateVariable( + IN NVAR *OldVar, IN CHAR16 *VariableName, IN UINTN NameSize, + IN EFI_GUID *VendorGuid, IN UINT32 Attributes, + IN UINTN DataSize, IN VOID *Data, + IN OUT VAR_INDEX_ENTRY *OldVarEntry OPTIONAL, + IN EXT_SEC_FLAGS *ExtSecFlags, + NVRAM_STORE_INFO *Info, VARIABLE_INTERFACE *Interface +) +{ + UINTN OldDataSize; + VOID *OldData; + BOOLEAN ok; + UINTN Size, ExtSize = 0; + NVAR Var = {FLASH_EMPTY_SIGNATURE,0,FLASH_EMPTY_NEXT,NVRAM_FLAG_VALID|NVRAM_FLAG_DATA_ONLY}; + UINT8 *p, *p1, Dummy, ExtFlags = 0; + + if (!NvAttribEq(OldVar,Attributes,Info)) return EFI_INVALID_PARAMETER; + + if (OldVarEntry != NULL && OldVarEntry->FinalDataNvar != NULL) + OldData = NvGetData( OldVarEntry->FinalDataNvar, NameSize, &OldDataSize, Info ); + else + OldData = NvGetData( OldVar, NameSize, &OldDataSize, Info ); + + if (Attributes & UEFI23_1_AUTHENTICATED_VARIABLE_ATTRIBUTES/*EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS*/) + { + Var.flags |= NVRAM_FLAG_EXT_HEDER | NVRAM_FLAG_AUTH_WRITE; + ExtSize = 1 + 8 + 2; //ExtFlags + Monotonic Counter + ExtSize + // AuthFlags only set in 1st instance + // ExtFlags |= Attributes & UEFI23_1_AUTHENTICATED_VARIABLE_ATTRIBUTES; + } + //if new data equal to the old data don't do anything + if (NvramChecksumSupport) + { ExtFlags |= NVRAM_EXT_FLAG_CHECKSUM; + if (ExtSize == 0) ExtSize += 4; // ExtSize - Ext Flag, Checksumm and Size + else ExtSize += 1; // Add Checksumm Feild + if ( (Attributes & EFI_VARIABLE_APPEND_WRITE) == 0 + && OldDataSize == DataSize && !MemCmp(OldData, Data, DataSize) + && (OldVar->flags & NVRAM_FLAG_EXT_HEDER)) + return EFI_SUCCESS; + else Var.flags |= NVRAM_FLAG_EXT_HEDER; + } + else + if ( (Attributes & EFI_VARIABLE_APPEND_WRITE) == 0 + && OldDataSize == DataSize && !MemCmp(OldData, Data, DataSize)) + return EFI_SUCCESS; + + // Append write implementation + if (Attributes & EFI_VARIABLE_APPEND_WRITE) + Size=sizeof(NVAR)+ OldDataSize + DataSize + ExtSize; + else + Size=sizeof(NVAR)+ DataSize + ExtSize; + + if (!IsEnoughSpace(Info,Size)) return EFI_OUT_OF_RESOURCES; + + Var.size=(VAR_SIZE_TYPE)Size; + Interface->EnableUpdate(Info->NvramAddress,Info->NvramSize); + p = Info->pEndOfVars; + + //Program Var at pEndOfVars + do + { + ok=Interface->WriteBytes(p,sizeof(NVAR),&Var); + p += sizeof(NVAR); + + if (!ok) break; + + //Program data + //AppendWrite + if (Attributes & EFI_VARIABLE_APPEND_WRITE) { + if (FlashNotMemoryMapped){ + ok=FlashMemFlashWrite(Interface, &p, OldData, OldDataSize, Info); + } + else + { + ok=Interface->WriteBytes(p,OldDataSize,OldData); + p+=OldDataSize; + } + if (!ok) break; + } + // end Append write + ok=Interface->WriteBytes(p,DataSize,Data); + p+=DataSize; + p1 = p; + if (!ok) break; + + //---Fill Ext area--- + if (Attributes & UEFI23_1_AUTHENTICATED_VARIABLE_ATTRIBUTES/*EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS*/) + { + ok=Interface->WriteBytes(p, 1, &ExtFlags);//--Ext Flag + if (!ok) break; + p += 1; + ok=Interface->WriteBytes(p, 8, &ExtSecFlags->Mc);//--Monotonic counter + if (!ok) break; + p = Info->pEndOfVars + Size - 2; + ok=Interface->WriteBytes(p, 2,&ExtSize);//--Ext Size + if (!ok) break; + } + if (NvramChecksumSupport) + { + if (!(Var.flags & NVRAM_FLAG_AUTH_WRITE)) // ??? should be ExtFlags? + { + p = p1 + ExtSize; + //write ExtSize + ok=Interface->WriteBytes(p-sizeof(VAR_SIZE_TYPE),sizeof(VAR_SIZE_TYPE),&ExtSize); + if (!ok) break; + //write ExtFlags + ok=Interface->WriteBytes(p-ExtSize, 1, &ExtFlags); + if (!ok) break; + //write checksum + if (FlashNotMemoryMapped) + Interface->DisableUpdate(Info->NvramAddress,Info->NvramSize); + + Dummy = NvCalculateNvarChecksum((NVAR*)Info->pEndOfVars); + + if (FlashNotMemoryMapped) + Interface->EnableUpdate(Info->NvramAddress,Info->NvramSize); + + //adjust to exclude empty checksum field + Dummy += FLASH_EMPTY_BYTE; + ok=Interface->WriteBytes(p-3, 1, &Dummy); + if (!ok) break; + } + else + { + p = p1 + ExtSize; + if (FlashNotMemoryMapped) + Interface->DisableUpdate(Info->NvramAddress,Info->NvramSize); + + Dummy = NvCalculateNvarChecksum((NVAR*)Info->pEndOfVars); + + if (FlashNotMemoryMapped) + Interface->EnableUpdate(Info->NvramAddress,Info->NvramSize); + + //adjust to exclude empty checksum field + Dummy += FLASH_EMPTY_BYTE; + ok=Interface->WriteBytes(p-3, 1, &Dummy); + if (!ok) break; + } + } + //write a signature + ok=Interface->WriteBytes(Info->pEndOfVars,sizeof(NvramSignature),(VOID*)&NvramSignature); + + if (!ok) break; + //set Var.next; + + if (FlashNotMemoryMapped) + Interface->DisableUpdate(Info->NvramAddress,Info->NvramSize); + + if (OldVarEntry != NULL && OldVarEntry->FinalDataNvar != NULL) + OldVar=OldVarEntry->FinalDataNvar; + else + OldVar=NvGetDataNvar(OldVar,Info); + + if (FlashNotMemoryMapped) + Interface->EnableUpdate(Info->NvramAddress,Info->NvramSize); + + Var.next=(UINT32)(Info->pEndOfVars-(UINT8*)OldVar); + ok=Interface->WriteBytes((UINT8*)OldVar+NEXT_OFFSET,NEXT_SIZE,(UINT8*)&Var+NEXT_OFFSET); + } + while (FALSE); + + Interface->DisableUpdate(Info->NvramAddress,Info->NvramSize); + + if (ok) + { + if (OldVarEntry != NULL) + OldVarEntry->FinalDataNvar = (NVAR*)Info->pEndOfVars; + Info->pEndOfVars += Size; + Info->LastVarSize=(VAR_SIZE_TYPE)Size; + } + + else + { + RecoverFromFlashUpdateFailure(Info,p,Size,OldVar); + } + + return (ok) ? EFI_SUCCESS : EFI_DEVICE_ERROR; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: DeleteVariable +// +// Description: This function delets variable +// +// Input: IN NVAR *Var - pointer to the Var to be deleted +// OUT NVRAM_STORE_INFO *Info - pointer to NVRAM_STORE_INFO structure +// VARIABLE_INTERFACE *Interface - pointer to the interface with the Variable routins +// +// Output: EFI_STATUS +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS DeleteVariable(IN NVAR *Var, NVRAM_STORE_INFO *Info, VARIABLE_INTERFACE *Interface) +{ + UINT8 flag = Var->flags^NVRAM_FLAG_VALID;//invert validity bit + BOOLEAN ok; + CHAR8 *WriteAddress = (UINT8*)Var+FLAG_OFFSET; + UINTN WriteSize = FLAG_SIZE; + Interface->EnableUpdate(WriteAddress,WriteSize); + ok=Interface->WriteBytes(WriteAddress,WriteSize,&flag); + Interface->DisableUpdate(WriteAddress,WriteSize); + return (ok) ? EFI_SUCCESS : EFI_DEVICE_ERROR; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: CopyVariable +// +// Description: This function copyes variable from one Nvram store to another +// +// Input: IN CHAR16 *VariableName - pointer to Var Name in Unicode +// IN EFI_GUID *VendorGuid - pointer to Var GUID +// IN UINTN DataSize - size of Var data +// IN VOID *Data - pointer to the Var data temprary storadge +// OUT NVRAM_STORE_INFO *FromInfo - pointer to NVRAM_STORE_INFO structure to copy from +// OUT NVRAM_STORE_INFO *ToInfo - pointer to NVRAM_STORE_INFO structure to copy to +// VARIABLE_INTERFACE *ToInterface - pointer to the interface with the Variable routins +// +// Output: EFI_STATUS +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS CopyVariable( + IN CHAR16 *VariableName, IN EFI_GUID *VendorGuid, +//Buffer used for temporary variable data storage + IN UINTN DataSize, IN VOID *Data, + NVRAM_STORE_INFO *FromInfo, NVRAM_STORE_INFO *ToInfo, + VARIABLE_INTERFACE *ToInterface +) +{ + EFI_STATUS Status; + UINT32 Attributes; + NVAR *nVar; + EXT_SEC_FLAGS ExtSecFlags = {0,0,{0}}; + + Status = NvGetVariable( + VariableName, VendorGuid, &Attributes, &DataSize, Data, + FromInfo, &nVar + ); + + if (EFI_ERROR(Status)) return Status; + + GetVarAuthExtFlags(nVar, FromInfo, &ExtSecFlags); + + if (nVar->flags & NVRAM_FLAG_AUTH_WRITE) + return CreateVariable( + VariableName, VendorGuid, Attributes, DataSize, Data, + ToInfo, ToInterface, nVar, &ExtSecFlags); + else + return CreateVariable( + VariableName, VendorGuid, Attributes, DataSize, Data, + ToInfo, ToInterface, nVar, NULL); +} + +//Varstore maintenance +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: VarNotInPreserveList +// +// Description: Looks for the provided variable in the preserved list. +// +// Input: IN CHAR16 *VarName - Variable name to be found. +// IN EFI_GUID *Guid - Variable GUID to be found. +// +// Output: BOOLEAN - Depending on result. +// TRUE - if not in list, FALSE - if in list. +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +BOOLEAN VarNotInPreserveList( + IN CHAR16 *VarName, + IN EFI_GUID *Guid +) +{ + SDL_VAR_ENTRY *Entry; + UINTN Index; + if (VarName == NULL || Guid == NULL) + return TRUE; // If it has no name or GUID - it is not in the list + // Determine the size in bytes of the variable name string. + + + // Scan list + for (Index = 0, Entry = gSdlVarLst; + Entry->Name != NULL; + Entry = &gSdlVarLst[++Index] ) + { + // Check the GUID's for a match. + if (!guidcmp(&Entry->Guid, Guid)) { + //NVRAM_TRACE((TRACE_DXE_CORE,"VarNotInPreserveList: GUID Match found.\n")); + // Compare variable name strings. + if (Wcscmp(Entry->Name, VarName) == 0){ + //NVRAM_TRACE((TRACE_DXE_CORE,"VarNotInPreserveList: Compleat Match found!!!.\n")); + // Match found! + return FALSE; + } + } + } + + return TRUE; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: VarNotInEfiGlobalVarList +// +// Description: Searches for the passed variable in the EFI Global Var lists and +// if found, makes sure, that it has the same attributes. +// +// Input: IN CHAR16 *VarName - Variable name to be found. +// IN UINT32 Attributes - Variable attributes. +// +// Output: BOOLEAN - Depending on result. +// TRUE - if not in list, FALSE - if in list. +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +BOOLEAN VarNotInEfiGlobalVarList ( + IN CHAR16 *VariNameToTest, + IN UINT32 Attributes + ) +{ + UINT32 i, j; + UINTN CommonLength; + + + // Search through list where names are strictly predefined + for (i = 0; gStdEfiVarList[i].Name != NULL; i ++) + { + if ((Wcscmp(gStdEfiVarList[i].Name, VariNameToTest) == 0) && + (gStdEfiVarList[i].Attributes == Attributes || Attributes == 0)) + return FALSE; + } + + // Look in the list where names could have 4 different hexadecimal numbers at the end + CommonLength = Wcslen(VariNameToTest) - 4; // Subtract 4 last characters, that can be different from those, that are in list + for (i = 0; gStdEfiVarListWildCard[i].Name != NULL; i ++) + { + if ((CommonLength + 4 == Wcslen(gStdEfiVarListWildCard[i].Name)) && + (MemCmp(gStdEfiVarListWildCard[i].Name, VariNameToTest, CommonLength * sizeof(CHAR16)) == 0) && + (gStdEfiVarListWildCard[i].Attributes == Attributes || Attributes == 0)) + { + + for (j = 0; j < 4;) + { + // if 4 lasrt characters are not hexadecimal numbers - this is not a legal Efi Global Variable + if ((VariNameToTest[CommonLength + j] >= L'0' && VariNameToTest[CommonLength + j] <= L'9') || + (VariNameToTest[CommonLength + j] >= L'a' && VariNameToTest[CommonLength + j] <= L'f') || + (VariNameToTest[CommonLength + j] >= L'A' && VariNameToTest[CommonLength + j] <= L'F')) + j ++; + else + return TRUE; + + } + return FALSE; + } + } + + return TRUE; + +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: SkipSpecificNvar +// +// Description: Helper varstore filtering function. +// Skips the variable that corresponds to the passed in NVAR. +// +// Output: BOOLEAN +// TRUE - skip the variable +// FALSE - do not skip the variable +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +BOOLEAN SkipSpecificNvar( + NVAR *SkipVar, CHAR16* VarName, EFI_GUID* VarGuid, + NVRAM_STORE_INFO *Info +){ + return SkipVar!=NULL && NvVarEq(SkipVar, VarName, VarGuid, NULL, Info); +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: SkipVarsWithDefaults +// +// Description: Helper varstore filtering function. +// Skips the variables that have defaults. +// +// Output: BOOLEAN +// TRUE - skip the variable +// FALSE - do not skip the variable +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +BOOLEAN SkipVarsWithDefaults( + NVRAM_STORE_INFO *DefInfo, CHAR16* VarName, EFI_GUID* VarGuid, + NVRAM_STORE_INFO *Info +){ + return DefInfo!=NULL + && ( Wcscmp(VarName, (CHAR16*)StdDefaults)==0 + || Wcscmp(VarName, (CHAR16*)MfgDefaults)==0 + || NvFindVariable(VarName, VarGuid, NULL, DefInfo) != NULL + ); +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: CopyVariables +// +// Description: This function copies variables from one varstore to another +// +// Input: OUT NVRAM_STORE_INFO *Info - pointer to NVRAM_STORE_INFO structure to copy from +// OUT NVRAM_STORE_INFO *NewInfo - pointer to NVRAM_STORE_INFO structure to copy to +// VARIABLE_INTERFACE *NewInterface - pointer to the interface with the update routins +// COPY_VAR_STORE_FILTER FilterFunction - filtering function +// VOID *FilterContext - filtering function context +// +// Output: EFI_STATUS +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS CopyVariables( + IN NVRAM_STORE_INFO* Info, + OUT NVRAM_STORE_INFO *NewInfo, + VARIABLE_INTERFACE *NewInterface, + COPY_VAR_STORE_FILTER FilterFunction, + VOID *FilterContext +) +{ + EFI_STATUS Status; + VOID *TmpBuffer, *TmpData; + CHAR16 *TmpName; + UINTN NvramSize = Info->NvramSize; + EFI_GUID Guid; + + TmpBuffer = SelectiveAllocate (TRUE, NvramSize*2); + + if (TmpBuffer==NULL) return EFI_OUT_OF_RESOURCES; + + TmpName = TmpBuffer; TmpData = (UINT8*)TmpBuffer+NvramSize; + TmpName[0]=0; + + //Copy variables + do + { + UINTN Size = NvramSize; + Status = NvGetNextVariableName( + &Size, TmpName, &Guid, Info, FALSE + ); + + if (EFI_ERROR(Status)) break; + + //check if the variable needs to be skipped + if ( FilterFunction!=NULL + && FilterFunction(FilterContext, TmpName, &Guid, Info) + ) continue; + if (SaveOnlyPreservedVars && VarNotInPreserveList(TmpName, &Guid)) + continue; + Status=CopyVariable( + TmpName, &Guid, NvramSize, TmpData, Info, NewInfo, NewInterface + ); + + if (EFI_ERROR(Status)) + { + if (Status==EFI_NOT_FOUND) continue; + SelectiveFree (TmpBuffer); + SaveOnlyPreservedVars = FALSE; + return Status; + } + } + while (TRUE); + + SelectiveFree (TmpBuffer); + + if (Status==EFI_NOT_FOUND) Status=EFI_SUCCESS; + SaveOnlyPreservedVars = FALSE; + return Status; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: CopyVarStore +// +// Description: This function copyes varstore to a new location +// +// Input: OUT NVRAM_STORE_INFO *Info - pointer to NVRAM_STORE_INFO structure to copy from +// OUT NVRAM_STORE_INFO *NewInfo - pointer to NVRAM_STORE_INFO structure to copy to +// VARIABLE_INTERFACE *NewInterface - pointer to the interface with the update routins +// COPY_VAR_STORE_FILTER FilterFunction - filtering function +// VOID *FilterContext - filtering function context +// +// Output: EFI_STATUS +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS CopyVarStore( + IN NVRAM_STORE_INFO* Info, + OUT NVRAM_STORE_INFO *NewInfo, + VARIABLE_INTERFACE *NewInterface, + COPY_VAR_STORE_FILTER FilterFunction, + VOID *FilterContext +) +{ + BOOLEAN ok; + + //This function assumes that the following + //fields of NewInfo have been initialized: + // NvramAddress, NvramSize, NvramGuidsAddress, Flags + if ((Runtime) && (!NvramDriverBuffer)) return EFI_OUT_OF_RESOURCES; + + NewInterface->EnableUpdate(NewInfo->NvramAddress,NewInfo->NvramSize); + ok=NewInterface->EraseBytes(NewInfo->NvramAddress,NewInfo->NvramSize); + NewInterface->DisableUpdate(NewInfo->NvramAddress,NewInfo->NvramSize); + NewInfo->pFirstVar = NewInfo->NvramAddress + VarStoreInfo.HeaderLength; + NewInfo->pEndOfVars = NewInfo->pFirstVar; + NewInfo->LastVarSize = 0; + NewInfo->pLastReturned = NULL; + NewInfo->NextGuid = 0; + + if (!ok) return EFI_DEVICE_ERROR; + + //Copy the header + NewInterface->EnableUpdate(NewInfo->NvramAddress,NewInfo->NvramSize); + ok=NewInterface->WriteBytes( + NewInfo->NvramAddress, + VarStoreInfo.HeaderLength, + Info->NvramAddress + ); + NewInterface->DisableUpdate(NewInfo->NvramAddress,NewInfo->NvramSize); + + if (!ok) return EFI_DEVICE_ERROR; + + + return CopyVariables(Info,NewInfo,NewInterface,FilterFunction,FilterContext); +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: CopyVarStoreToMemStore +// +// Description: This function allocates memory copyes varstore to a new location +// +// Input: OUT NVRAM_STORE_INFO *Info - pointer to NVRAM_STORE_INFO structure to copy from +// IN NVAR* SkipVar - pointer to var to be skiped +// OUT NVRAM_STORE_INFO *NewInfo - pointer to NVRAM_STORE_INFO structure which was created +// +// Output: EFI_STATUS +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS CopyVarStoreToMemStore( + IN NVRAM_STORE_INFO* Info, + IN NVAR* SkipVar, OUT NVRAM_STORE_INFO *NewInfo +) +{ + EFI_STATUS Status; + + if ((Runtime) && (!NvramDriverBuffer)) return EFI_OUT_OF_RESOURCES; + if (!Runtime) PROGRESS_CODE(DXE_NVRAM_CLEANUP); + NVRAM_TRACE((TRACE_DXE_CORE,"NVRAM Garbage Collection\n")); + + Status = InitVolatileStore( + NewInfo, Info->NvramSize, VarStoreInfo.HeaderLength, Info->Flags, FALSE + ); + + if (EFI_ERROR(Status)) return Status; + + Status = CopyVarStore( + Info,NewInfo,&MemInterface,SkipSpecificNvar,SkipVar + ); + + if (EFI_ERROR(Status)) SelectiveFree (NewInfo->NvramAddress); + else CheckTheHeader(NewInfo, VarStoreInfo.HeaderLength, TRUE); + return Status; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: SetNvramFfsFileState +// +// Description: This function updates State of Ffs file with new bits described by NewState +// +// Input: OUT NVRAM_STORE_INFO *Info - pointer to NVRAM_STORE_INFO structure +// VARIABLE_INTERFACE *Interface - pointer to the interface with the Variable routins +// EFI_FFS_FILE_STATE NewState - New state to update to +// +// Output: EFI_STATUS +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS SetNvramFfsFileState( + NVRAM_STORE_INFO *Info, VARIABLE_INTERFACE *Interface, + EFI_FFS_FILE_STATE NewState +) +{ + BOOLEAN ok; + EFI_FFS_FILE_STATE *StatePtr = GetNvramFfsFileStatePtr(Info); + + if (StatePtr==NULL) return EFI_DEVICE_ERROR; + + if (FlashEmpty!=0) NewState = ~NewState & *StatePtr; + else NewState |= *StatePtr; + + Interface->EnableUpdate(StatePtr,sizeof(NewState)); + ok = Interface->WriteBytes(StatePtr,sizeof(NewState),&NewState); + Interface->DisableUpdate(StatePtr,sizeof(NewState)); + return (ok) ? EFI_SUCCESS : EFI_DEVICE_ERROR; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: ResetFfsFileStateInMemory +// +// Description: This function sets State of Ffs file to new value described by NewState +// +// Input: OUT NVRAM_STORE_INFO *Info - pointer to NVRAM_STORE_INFO structure +// EFI_FFS_FILE_STATE NewState - New state to set +// +// Output: EFI_STATUS +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS ResetFfsFileStateInMemory( + NVRAM_STORE_INFO *Info, EFI_FFS_FILE_STATE NewState +) +{ + EFI_FFS_FILE_STATE *StatePtr = GetNvramFfsFileStatePtr(Info); + + if (StatePtr==NULL) return EFI_DEVICE_ERROR; + + if (FlashEmpty!=0) NewState = ~NewState; + + *StatePtr = NewState; + return (*StatePtr == NewState) ? EFI_SUCCESS : EFI_DEVICE_ERROR; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: CheckTheHeader +// +// Description: This function validates correctness of the header fields used by the driver +// and fixes them if Update parameter is TRUE +// +// Input: IN NVRAM_STORE_INFO *Info - pointer to NVRAM_STORE_INFO structure to check +// IN UINT32 HeaderLength - length of the NVRAM header +// IN BOOLEAN Update - If TRUE, invalid header will be updated to fix the problem +// +// Output: BOOLEAN +// TRUE - No problems detected +// FALSE - Problem(s) detected +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +BOOLEAN CheckTheHeader(NVRAM_STORE_INFO *Info, UINT32 HeaderLength, BOOLEAN Update){ + BOOLEAN HeaderValid = TRUE; + EFI_FIRMWARE_VOLUME_HEADER *Fv = (EFI_FIRMWARE_VOLUME_HEADER*)Info->NvramAddress; + + //check the signature + if ( Fv->Signature!=FV_SIGNATURE + || Fv->FvLength!=Info->NvramSize + || Fv->HeaderLength!=HeaderLength-sizeof(EFI_FFS_FILE_HEADER) + ){ + if (Update){ + Fv->Signature=FV_SIGNATURE; + Fv->FvLength=Info->NvramSize; + Fv->HeaderLength=(UINT16)(HeaderLength-sizeof(EFI_FFS_FILE_HEADER)); + } + HeaderValid = FALSE; + } + if (!IsMainNvramStoreValid(Info, VarStoreInfo.BackupAddress, NULL)){ + if (Update){ + ResetFfsFileStateInMemory( + Info, + EFI_FILE_HEADER_CONSTRUCTION + | EFI_FILE_HEADER_VALID + | EFI_FILE_DATA_VALID + ); + } + HeaderValid = FALSE; + } + return HeaderValid; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: UpdateFtVarstore +// +// Description: This function copyes Varstore to a new location and makes this copy main Varstore +// +// Input: OUT NVRAM_STORE_INFO *Info - pointer to NVRAM_STORE_INFO structure +// VARIABLE_INTERFACE *Interface - pointer to the interface with the Variable routins +// NVRAM_STORE_INFO* NewInfo - pointer to the new NVRAM_STORE_INFO Varstore +// +// Output: EFI_STATUS +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS UpdateFtVarstore( + NVRAM_STORE_INFO* Info, VARIABLE_INTERFACE *Interface, NVRAM_STORE_INFO* NewInfo +) +{ + NVRAM_STORE_INFO BackupInfo; + EFI_STATUS Status; + + BackupInfo.NvramAddress = VarStoreInfo.BackupAddress; + BackupInfo.NvramSize = Info->NvramSize; + NvInitInfoBuffer( + &BackupInfo, VarStoreInfo.HeaderLength, Info->Flags + ); +// State Transitions: +// Main Backup Valid Store +// = Initial State After Firmware Flashing +// 1. DATA_VALID HEADER_INVALID Main +// = Update Cycle 1 +// 2. DATA_VALID HEADER_VALID Main +// 3. MARKED_FOR_UPDATE HEADER_VALID Main +// 4. MARKED_FOR_UPDATE DATA_VALID Backup +// = Update Cycle 1 is Over +// = Update Cycle 2 +// 5. HEADER_VALID DATA_VALID Backup +// 6. HEADER_VALID MARKED_FOR_UPDATE Backup +// 7. DATA_VALID MARKED_FOR_UPDATE Main +// = Update Cycle 2 is Over +// = Update Cycle 3 +// 8. DATA_VALID HEADER_VALID Main +// Stae 8 == State 2 + Status=ResetFfsFileStateInMemory( + NewInfo, EFI_FILE_HEADER_CONSTRUCTION|EFI_FILE_HEADER_VALID + ); + + if (EFI_ERROR(Status)) return Status; + + Status = CopyVarStore(NewInfo,&BackupInfo,Interface,NULL,NULL); + + if (EFI_ERROR(Status)) return Status; + + Status=SetNvramFfsFileState(Info, Interface, EFI_FILE_MARKED_FOR_UPDATE); + + if (EFI_ERROR(Status)) return Status; + + Status=SetNvramFfsFileState(&BackupInfo, Interface, EFI_FILE_DATA_VALID); + + if (EFI_ERROR(Status)) return Status; +#ifdef HYBRID_NV_INTERFACE + if (!SwapVarstoresInHybridMode(&BackupInfo)){ +#endif + VarStoreInfo.BackupAddress = Info->NvramAddress; +#ifdef HYBRID_NV_INTERFACE + } +#endif + *Info = BackupInfo; + NVRAM_TRACE((TRACE_DXE_CORE,"NVRAM areas swapped(NVRAM address: %X; Backup address: %X).\n", Info->NvramAddress, VarStoreInfo.BackupAddress)); + return EFI_SUCCESS; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: UpdateVarstore +// +// Description: This function copyes Varstore to a new location and makes this copy main Varstore +// if old varstore flag has NVRAM_STORE_FLAG_NON_VALATILE and Backupadress is valid, else it +// just copy Varstor to new location +// +// Input: OUT NVRAM_STORE_INFO *Info - pointer to NVRAM_STORE_INFO structure +// VARIABLE_INTERFACE *Interface - pointer to the interface with the Variable routins +// NVRAM_STORE_INFO* NewInfo - pointer to the new NVRAM_STORE_INFO Varstore +// +// Output: EFI_STATUS +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS UpdateVarstore( + NVRAM_STORE_INFO* Info, VARIABLE_INTERFACE *Interface, NVRAM_STORE_INFO* NewInfo +) +{ + EFI_STATUS Status; + + if ( (Info->Flags & NVRAM_STORE_FLAG_NON_VALATILE) + && VarStoreInfo.BackupAddress!=0 + && CheckTheHeader(Info, VarStoreInfo.HeaderLength, FALSE) + ) + { + Status = UpdateFtVarstore(Info,Interface,NewInfo); + } + + else + { + Status = CopyVarStore(NewInfo,Info,Interface,NULL,NULL); + } + + if (!EFI_ERROR(Status)) + { + if (Info==VarStoreInfo.NvInfo) NvramReinitialize(); + +#if NV_CACHE_SUPPORT + else IndexReset(); + +#endif + } + + return Status; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: NvResetConfiguration +// +// Description: This function resets NvRam configuration +// +// Input: OUT NVRAM_STORE_INFO *Info - pointer to NVRAM_STORE_INFO structure +// VARIABLE_INTERFACE *Interface - pointer to the interface with the Variable routins +// BOOLEAN ExternalDefaults - if TRUE - use external defaults +// +// Output: EFI_STATUS +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS NvResetConfiguration( + NVRAM_STORE_INFO* Info, VARIABLE_INTERFACE *Interface, + BOOLEAN ExternalDefaults, BOOLEAN PreserveVariablesWithNoDefaults +) +{ + UINT16 HeaderLength = VarStoreInfo.HeaderLength; + NVRAM_STORE_INFO NewInfo; + NVRAM_STORE_INFO DefaultsInfo; + NVRAM_STORE_INFO *DefInfo = NULL; + EFI_STATUS Status; + VOID *TmpBuffer; + UINTN NvramSize = Info->NvramSize; + BOOLEAN HeaderIsValid; + + PROGRESS_CODE(DXE_CONFIGURATION_RESET); + NVRAM_TRACE((TRACE_DXE_CORE, + "NVRAM Reset: ExternalDefaults=%d; PreserveVariablesWithNoDefaults=%d\n", + ExternalDefaults,PreserveVariablesWithNoDefaults + )); + + Status = InitVolatileStore( + &NewInfo, Info->NvramSize, VarStoreInfo.HeaderLength, Info->Flags, FALSE + ); + + if (EFI_ERROR(Status)) return Status; + + MemCpy(NewInfo.NvramAddress, Info->NvramAddress, HeaderLength); + HeaderIsValid = CheckTheHeader(&NewInfo, HeaderLength, TRUE); + if (!HeaderIsValid){ + PreserveVariablesWithNoDefaults=FALSE; + NVRAM_TRACE((TRACE_DXE_CORE, "NVRAM Reset: NVRAM FV header is corrupted\n")); + } + if (ExternalDefaults) + { + // {9221315B-30BB-46b5-813E-1B1BF4712BD3} +#define SETUP_DEFAULTS_FFS_GUID { 0x9221315b, 0x30bb, 0x46b5, { 0x81, 0x3e, 0x1b, 0x1b, 0xf4, 0x71, 0x2b, 0xd3 } } + static EFI_GUID SetupDefaultsFfsGuid = SETUP_DEFAULTS_FFS_GUID; + EFI_FIRMWARE_VOLUME_PROTOCOL *Fv; + EFI_HANDLE *FvHandle; + UINTN Number,i; + UINT32 Authentication; + + Status = pBS->LocateHandleBuffer( + ByProtocol,&gEfiFirmwareVolumeProtocolGuid, NULL, &Number, &FvHandle + ); + + for (i=0; i<Number; i++) + { + Status=pBS->HandleProtocol(FvHandle[i], &gEfiFirmwareVolumeProtocolGuid, &Fv); + + if (EFI_ERROR(Status)) continue; + + DefaultsInfo.NvramAddress=NULL; + DefaultsInfo.NvramSize=0; + Status=Fv->ReadSection ( + Fv,&SetupDefaultsFfsGuid, + EFI_SECTION_RAW, 0, + &DefaultsInfo.NvramAddress, &DefaultsInfo.NvramSize, + &Authentication + ); + + if (!EFI_ERROR(Status)) + { + NVRAM_TRACE((TRACE_DXE_CORE, "NVRAM: External Defaults Found: Size=%X\n",DefaultsInfo.NvramSize)); + NvInitInfoBuffer( + &DefaultsInfo, 0, + NVRAM_STORE_FLAG_NON_VALATILE + | NVRAM_STORE_FLAG_READ_ONLY + | NVRAM_STORE_FLAG_DO_NOT_ENUMERATE + ); + DefInfo = &DefaultsInfo; + break; + } + } + } + + else + { + DefaultsInfo.NvramAddress = NULL; + DefInfo = Info; + } + + if (DefInfo!=NULL) + { + TmpBuffer = SelectiveAllocate (TRUE, NvramSize); + + if (TmpBuffer==NULL) + { + SelectiveFree (NewInfo.NvramAddress); + return EFI_OUT_OF_RESOURCES; + } + Status=CopyVariable( + (CHAR16*)StdDefaults, (EFI_GUID*)&AmiDefaultsVariableGuid, + NvramSize,TmpBuffer,DefInfo,&NewInfo,&MemInterface + ); + + if (Status!=EFI_OUT_OF_RESOURCES) + { + Status=CopyVariable( + (CHAR16*)MfgDefaults, (EFI_GUID*)&AmiDefaultsVariableGuid, + NvramSize,TmpBuffer,DefInfo,&NewInfo,&MemInterface + ); + } + + SelectiveFree (TmpBuffer); + + if (PreserveVariablesWithNoDefaults){ + NVRAM_STORE_INFO DefVarInfo; + if (NvGetDefaultsInfo(StdDefaults,DefInfo,&DefVarInfo) != NULL) + Status=CopyVariables( + Info, &NewInfo, &MemInterface, SkipVarsWithDefaults ,&DefVarInfo + ); + } + if (DefaultsInfo.NvramAddress!=NULL ) + { + pBS->FreePool(DefaultsInfo.NvramAddress); + } + // don't reset NVRAM if no defaults found + if (NewInfo.pEndOfVars == NewInfo.pFirstVar) DefInfo=NULL; + } + + if ( Status!=EFI_OUT_OF_RESOURCES + && ( DefInfo!=NULL || !HeaderIsValid ) + && ( Info->pEndOfVars - Info->NvramAddress!= NewInfo.pEndOfVars - NewInfo.NvramAddress + || DefInfo!=Info + ) + ) Status=UpdateVarstore(Info,Interface,&NewInfo); + + SelectiveFree (NewInfo.NvramAddress); + return Status; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: IsStoreOk +// +// Description: This function checks is Varstore is correct +// +// Input: OUT NVRAM_STORE_INFO *Info - pointer to NVRAM_STORE_INFO structure +// +// Output: BOOLEAN - based on result +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +BOOLEAN IsStoreOk(NVRAM_STORE_INFO *Info) +{ + return + ( Info->LastVarSize==0 + || NvIsVariable((NVAR*)(Info->pEndOfVars-Info->LastVarSize),Info) + ) + && *(UINT32*)Info->pEndOfVars==(UINT32)FlashEmpty + && ((NVAR*)Info->pEndOfVars)->size==FLASH_EMPTY_SIZE + && *(UINT32*)(Info->NvramGuidsAddress-Info->NextGuid)==(UINT32)FlashEmpty; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: CheckStore +// +// Description: This function checks if Varstore is correct and otherwise tries to +// Reinitialize NvRam, copy Varstore to memory and prints messages +// based on situation. +// +// Input: OUT NVRAM_STORE_INFO *Info - pointer to NVRAM_STORE_INFO structure +// +// Output: BOOLEAN - based on result +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +VOID CheckStore(BOOLEAN Recover) +{ + NVRAM_STORE_INFO *Info = VarStoreInfo.NvInfo; + NVRAM_STORE_INFO NewInfo; + EFI_STATUS Status; + BOOLEAN MainStoreValid; + BOOLEAN BackupStoreValid; +#ifdef HYBRID_NV_INTERFACE + NVRAM_STORE_INFO FlashInfo; + HybridStoreToRealStore(Info,&FlashInfo); +#endif + MainStoreValid = IsMainNvramStoreValid( +#ifdef HYBRID_NV_INTERFACE + &FlashInfo, +#else + VarStoreInfo.NvInfo, +#endif + VarStoreInfo.BackupAddress, &BackupStoreValid + ); + if (!MainStoreValid){ + if (BackupStoreValid){ + NVRAM_STORE_INFO BackupInfo; + NVRAM_TRACE((TRACE_DXE_CORE,"NVRAM Store is not valid. Switching to Backup Store.\n")); +#ifdef HYBRID_NV_INTERFACE + if (!SwapVarstoresInHybridMode(&BackupInfo)){ +#endif + BackupInfo.NvramAddress = VarStoreInfo.BackupAddress; + BackupInfo.NvramSize = VarStoreInfo.NvInfo->NvramSize; + NvInitInfoBuffer( + &BackupInfo, VarStoreInfo.HeaderLength, VarStoreInfo.NvInfo->Flags + ); + VarStoreInfo.BackupAddress = VarStoreInfo.NvInfo->NvramAddress; +#ifdef HYBRID_NV_INTERFACE + } +#endif + *VarStoreInfo.NvInfo = BackupInfo; + NvramReinitialize(); + MainStoreValid = TRUE; +#ifdef HYBRID_NV_INTERFACE + HybridStoreToRealStore(Info,&FlashInfo); +#endif + }else{//both main and backup stores are invliad; force the recovery. + Recover = TRUE; + } + } +#ifdef HYBRID_NV_INTERFACE + if (MainStoreValid && IsStoreOk(&FlashInfo)) return; +#else + if (MainStoreValid && IsStoreOk(Info)) return; +#endif + + if (!Recover) + { + NVRAM_TRACE((TRACE_DXE_CORE,"NVRAM inconsistency detected. Reinitializing.\n")); +#ifdef HYBRID_NV_INTERFACE + //When inconsystency is detected, re-read the flash content into the memory buffer + //(they may be out of synchronization) + MemCpy( + VarStoreInfo.NvInfo->NvramAddress, + VarStoreInfo.NvramFlashAddress, + VarStoreInfo.NvInfo->NvramSize + ); +#endif + NvramReinitialize(); + + if (IsStoreOk(Info)) return; + } + NVRAM_TRACE((TRACE_DXE_CORE,"NVRAM corruption detected.\n")); + + Status = CopyVarStoreToMemStore(Info,NULL,&NewInfo); + + if (EFI_ERROR(Status)){ + SelectiveFree (NewInfo.NvramAddress); + return ; + } + + UpdateVarstore(Info,VarStoreInfo.NvInterface,&NewInfo); + SelectiveFree (NewInfo.NvramAddress); +} + +//High level routines +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: DxeGetVariable +// +// Description: This function searches for Var with specific GUID and Name +// +// Input: IN CHAR16 *VariableName - pointer to Var Name in Unicode +// IN EFI_GUID *VendorGuid - pointer to Var GUID +// OPTIONAL OUT UINT32* Attributes - Pointer to memory where Attributes will be returned +// IN OUT UINTN *DataSize - size of Var - if smaller than actual EFI_BUFFER_TOO_SMALL +// will be returned and DataSize will be set to actual size needed +// OUT VOID *Data - Pointer to memory where Var will be returned +// +// Output: EFI_STATUS - based on result +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS DxeGetVariable( + IN CHAR16 *VariableName, IN EFI_GUID *VendorGuid, + OUT UINT32 *Attributes OPTIONAL, + IN OUT UINTN *DataSize, OUT VOID *Data +) +{ + EFI_STATUS Status; + UINT32 Attrib; + + if (!VariableName || !VendorGuid || !DataSize || !Data && *DataSize) + return EFI_INVALID_PARAMETER; + Status = GetVariableHook ( + VariableName,VendorGuid,Attributes,DataSize,Data + ); + if (Status != EFI_UNSUPPORTED) return Status; + CheckStore(FALSE); +#if NV_CACHE_SUPPORT + { + UINTN VariableNameSize; + NVRAM_STORE_INFO *Info; + BOOLEAN UnindexedExists; + NVAR *Nvar = NULL; + VAR_INDEX_ENTRY *NvarEntry = IndexFindVariableEntry( + VariableName,VendorGuid,&VariableNameSize, + &Info, &UnindexedExists + ); + + if (NvarEntry!=NULL) + { + Nvar = NvarEntry->Nvar; + if (AreBtVariablesHidden() && !(Nvar->flags & NVRAM_FLAG_RUNTIME)) return EFI_NOT_FOUND; + + // Get the attributes from the first entry, data-only entries do not store attribs + if (Attributes) + if (EFI_ERROR(NvGetAttributesFromNvar(Nvar, Info, Attributes))) + return EFI_NOT_FOUND; + + // Get the data using the cached data-only entry, if possible + return NvGetVariableFromNvar( + NvarEntry->FinalDataNvar,VariableNameSize,NULL,DataSize,Data,Info, NULL + ); + } + + if (!UnindexedExists) return EFI_NOT_FOUND; + } +#endif + Status = NvGetVariable2( + VariableName, VendorGuid, &Attrib, + DataSize, Data, + VarStoreInfo.InfoCount, VarStoreInfo.NvramInfo + ); + + if (!EFI_ERROR(Status) || Status == EFI_BUFFER_TOO_SMALL) + { + if (AreBtVariablesHidden() && !(Attrib & EFI_VARIABLE_RUNTIME_ACCESS)) return EFI_NOT_FOUND; + + if (Status != EFI_BUFFER_TOO_SMALL && Attributes) *Attributes=Attrib; + } + + return Status; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: DxeGetNextVariableName +// +// Description: This function searches for next Var after Var with specific name and GUID and returns it's Name. +// +// Input: IN OUT UINTN *VariableNameSize - size of Varname - if smaller than actual EFI_BUFFER_TOO_SMALL +// will be returned and DataSize will be set to actual size needed +// IN OUT CHAR16 *VariableName - pointer where Var Name in Unicode will be stored +// IN OUT EFI_GUID *VendorGuid - pointer to menory where Var GUID is stored +// +// Output: EFI_STATUS - based on result +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS DxeGetNextVariableName( + IN OUT UINTN *VariableNameSize, + IN OUT CHAR16 *VariableName, IN OUT EFI_GUID *VendorGuid +) +{ + EFI_STATUS Status; + + if ( !VariableNameSize || !VariableName || !VendorGuid) + return EFI_INVALID_PARAMETER; + Status = GetNextVarNameHook ( + VariableNameSize, VariableName, VendorGuid + ); + if (Status != EFI_UNSUPPORTED) return Status; + CheckStore(FALSE); + Status = NvGetNextVariableName2( + VariableNameSize, VariableName, VendorGuid, + VarStoreInfo.InfoCount, VarStoreInfo.NvramInfo, + &VarStoreInfo.LastInfoIndex,AreBtVariablesHidden() + ); + return Status; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: DxeSetVariable +// +// Description: This function sets Var with specific GUID, Name and attributes +// +// Input: IN CHAR16 *VariableName - pointer to Var Name in Unicode +// IN EFI_GUID *VendorGuid - pointer to Var GUID +// IN UINT32 Attributes - Attributes of the Var +// IN UINTN DataSize - size of Var +// IN VOID *Data - Pointer to memory where Var data is stored +// +// Output: EFI_STATUS - based on result +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS DxeSetVariable( + IN CHAR16 *VariableName, IN EFI_GUID *VendorGuid, + IN UINT32 Attributes, IN UINTN DataSize, IN VOID *Data +) +{ + NVAR *Var = NULL; + UINTN NameSize; + BOOLEAN NvVariableFound; + NVRAM_STORE_INFO *Info=NULL; + VARIABLE_INTERFACE *Interface; + EFI_STATUS Status; + NVRAM_STORE_INFO NewInfo; +#if NV_CACHE_SUPPORT + BOOLEAN UnindexedExists; + BOOLEAN UpdateIndex; + VAR_INDEX_ENTRY *VarEntry; +#endif + UINTN OldDataSize=0; + VOID *OldData=NULL; + EXT_SEC_FLAGS ExtSecFlags = {0, 0,{0}}; + EFI_GUID EfiGlobalVariableGuid = EFI_GLOBAL_VARIABLE; + + if ( + !VariableName || VariableName[0]==0 || !VendorGuid + || ( Attributes & ~ALL_VARIABLE_ATTRIBUTES) + || (Attributes & EFI_VARIABLE_RUNTIME_ACCESS) && !(Attributes & EFI_VARIABLE_BOOTSERVICE_ACCESS ) + || DataSize && !Data + || Runtime && Attributes && ( + !(Attributes & EFI_VARIABLE_NON_VOLATILE) + || !(Attributes & EFI_VARIABLE_RUNTIME_ACCESS) && AreBtVariablesHidden() + ) + ) return EFI_INVALID_PARAMETER; + if (guidcmp(VendorGuid, & EfiGlobalVariableGuid) == 0) + { + if (VarNotInEfiGlobalVarList (VariableName, Attributes)) + { + NVRAM_TRACE((TRACE_DXE_CORE, "Variable with EfiGlobalVariableGuid has illegal name: %S or attributes: %x ! Please use different GUID. \n", VariableName, Attributes)); + ASSERT(FALSE); + return EFI_INVALID_PARAMETER; + } + } + Status = SetVariableHook ( + VariableName,VendorGuid,Attributes,DataSize,Data + ); + if (Status != EFI_UNSUPPORTED) return Status; + if (DataSize>MAX_NVRAM_VARIABLE_SIZE) return EFI_OUT_OF_RESOURCES; + + CheckStore(FALSE); +#if NV_CACHE_SUPPORT + //UpdateIndex defines if indexed address has to be updated. + //Typically we don't have to update index because + //index contains address of the first NVAR for a particular variable, + //which does not change when we update variable data. + //However, there is one exception from the rule. + //We need to update the index, when indexed address points to the default value of the variable. + //In this case UpdateIndex will be set to TRUE + UpdateIndex = FALSE; + VarEntry = IndexFindVariableEntry( + VariableName,VendorGuid,&NameSize, + &Info, &UnindexedExists + ); + + if (VarEntry!=NULL) + { + Var = VarEntry->Nvar; + if (Info==VarStoreInfo.NvInfo) NvVariableFound=TRUE; + else if (Info==VarStoreInfo.MemInfo) NvVariableFound=FALSE; + else + { + //We are setting UnindexedExists to TRUE because + //there may be other variable instances in varstores with lower priority + Var=NULL; VarEntry=NULL; UpdateIndex=TRUE; UnindexedExists=TRUE; + } + } + + if (Var==NULL && UnindexedExists) + { + NvVariableFound=TRUE; + Var = NvFindVariable(VariableName,VendorGuid, &NameSize, VarStoreInfo.NvInfo); + + if (Var==NULL) + { + NvVariableFound=FALSE; + Var = NvFindVariable(VariableName,VendorGuid, &NameSize, VarStoreInfo.MemInfo); + } + } + +#else + NvVariableFound=TRUE; + Var = NvFindVariable(VariableName,VendorGuid, &NameSize, VarStoreInfo.NvInfo); + + if (Var==NULL) + { + NvVariableFound=FALSE; + Var = NvFindVariable(VariableName,VendorGuid, &NameSize, VarStoreInfo.MemInfo); + } + +#endif + if( Var!=NULL ) + { + // It's illegal to set boot time variable at run time. + if (AreBtVariablesHidden() && !(Var->flags & NVRAM_FLAG_RUNTIME)) return EFI_INVALID_PARAMETER; + if (NvVariableFound) + { + Info = VarStoreInfo.NvInfo; + Interface = VarStoreInfo.NvInterface; + } + else + { + Info = VarStoreInfo.MemInfo; + Interface = VarStoreInfo.MemInterface; + } + GetVarAuthExtFlags(Var, Info, &ExtSecFlags); +#if NV_CACHE_SUPPORT + if (VarEntry != NULL && VarEntry->FinalDataNvar != NULL) + OldData = NvGetData( VarEntry->FinalDataNvar, NameSize, &OldDataSize, Info); + else +#endif + OldData = NvGetData( Var, NameSize, &OldDataSize, Info); + } else { + if (Attributes & EFI_VARIABLE_NON_VOLATILE) + { + Info = VarStoreInfo.NvInfo; + Interface = VarStoreInfo.NvInterface; + } + else + { +#if NV_CACHE_SUPPORT + //if UpdateIndex is TRUE, default value exists + //If default value exists, the variable is non valatile + //Attributes for existing variable can not be changed + if (UpdateIndex) return EFI_INVALID_PARAMETER; +#endif + Info = VarStoreInfo.MemInfo; + Interface = VarStoreInfo.MemInterface; + } + OldDataSize = 0; + OldData = NULL; + } + + Status = VerifyVariable(VariableName, VendorGuid, &Attributes, &Data, &DataSize, OldData, OldDataSize, &ExtSecFlags); + if (EFI_ERROR(Status)) { + // case for SigDb Append mode. EFI_ALREADY_STARTED treat as Ok to exit SetVar + if(Status == EFI_ALREADY_STARTED) + Status = EFI_SUCCESS; + return Status; + } + +// Function called with empty access attributes - the variable shall be erased. + if(!Attributes) + DataSize = 0; + // + // Verification passed. + // + if ((!(Attributes & EFI_VARIABLE_APPEND_WRITE) && !DataSize) || + !(Attributes & EFI_VARIABLE_BOOTSERVICE_ACCESS) ) + { + //delete + if (Var==NULL) return +#if NV_CACHE_SUPPORT + //if UpdateIndex is TRUE, default value (which can not be deleted ) exists + (UpdateIndex) ? EFI_WRITE_PROTECTED : +#endif + EFI_NOT_FOUND; + + if (Runtime && !NvVariableFound) return EFI_INVALID_PARAMETER; + + Status = DeleteVariable(Var,Info,Interface); +#if NV_CACHE_SUPPORT + + if (!EFI_ERROR(Status)) + { + //The variable has just been deleted from the primary varstore. + //However, we may still have variable instance in other stores. + INT32 i; + NVAR *v; + + if (NvVariableFound) + { + for (i=VarStoreInfo.InfoCount-1; i>=0; i--) + { + if ( Info == &VarStoreInfo.NvramInfo[i] + || (Info->Flags & NVRAM_STORE_FLAG_NON_VALATILE)==0 + ) continue; + + v = NvFindVariable( + VariableName,VendorGuid, &NameSize, + &VarStoreInfo.NvramInfo[i] + ); + + if (v!=NULL) + { + IndexUpdateVariable(v,&VarStoreInfo.NvramInfo[i]); + return Status; + } + } + } + + //If other instances are not found, delete the index entry + IndexDeleteVariableEntry(VarEntry); + } + +#endif + return Status; + } + + if (Var==NULL) + { + //create new + Status = CreateVariable( + VariableName,VendorGuid,Attributes, + DataSize, Data, Info,Interface, NULL, &ExtSecFlags// NULL + ); +#if NV_CACHE_SUPPORT + if (!EFI_ERROR(Status)) + { + if (UpdateIndex) + { + if ( ( !( VarStoreInfo.NvramMode & (NVRAM_MODE_DEFAULT_CONFIGURATION|NVRAM_MODE_MANUFACTORING) ) ) + || Info!=VarStoreInfo.NvInfo ) + { + IndexUpdateVariable( + (NVAR*)(Info->pEndOfVars-Info->LastVarSize),Info + ); + + } + } + else + IndexAddVariable( + (NVAR*)(Info->pEndOfVars-Info->LastVarSize),Info + ); + } + +#endif + } + + else + { + //update existing + Status = UpdateVariable( + Var,VariableName,NameSize,VendorGuid,Attributes, + DataSize, Data, +#if NV_CACHE_SUPPORT + VarEntry, +#else + NULL, +#endif + + &ExtSecFlags, + Info, Interface + ); + } + + //Error Recovery + if ( Status==EFI_OUT_OF_RESOURCES + || Status==EFI_DEVICE_ERROR && !IsStoreOk(Info) + ) + { + BOOLEAN FirstPass=TRUE; + do{ + if (!SaveOnlyPreservedVars) + { + NVRAM_TRACE((TRACE_DXE_CORE,"NVRAM: SetVariable failed. Status=%r. Starting Recovery...\n",Status)); + } + else + { + NVRAM_TRACE((TRACE_DXE_CORE,"NVRAM: SetVariable failed After Recovery. Clearing NVRAM...\n")); + } + NewInfo.NvramAddress = NULL; + if (EFI_ERROR(CopyVarStoreToMemStore(Info,Var,&NewInfo))){ + if (NewInfo.NvramAddress!=NULL) SelectiveFree (NewInfo.NvramAddress); + return Status; + } + if (Attributes & EFI_VARIABLE_APPEND_WRITE) + Status = CreateVariableEx( + VariableName,VendorGuid,Attributes, + DataSize, Data, &NewInfo, &MemInterface, NULL, &ExtSecFlags, + OldData, OldDataSize + ); + else + Status = CreateVariable( + VariableName,VendorGuid,Attributes, + DataSize, Data, &NewInfo, &MemInterface, NULL, &ExtSecFlags + ); + + if (!EFI_ERROR(Status)) + { + Status = UpdateVarstore(Info,Interface,&NewInfo); + } + + else + { + if ((Status==EFI_OUT_OF_RESOURCES) && (FirstPass)) SaveOnlyPreservedVars = TRUE; + + CheckStore(TRUE); + } + + SelectiveFree (NewInfo.NvramAddress); + + NVRAM_TRACE((TRACE_DXE_CORE,"NVRAM: SetVariable Status after recovery=%r.\n",Status)); + FirstPass = FALSE; + } + while (SaveOnlyPreservedVars); + } + return Status; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: BeginCriticalSection +// +// Description: This function calls when critical section begins. It disables interupts, +// and Smi and fills CRITICAL_SECTION structure fields +// +// Input: CRITICAL_SECTION *Cs - pointer to CRITICAL_SECTION structure +// +// Output: VOID +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +VOID BeginCriticalSection(CRITICAL_SECTION *Cs) +{ + CRITICAL_SECTION TempCs; + + TempCs.IntState[0] = IoRead8(0x21); + TempCs.IntState[1] = IoRead8(0xa1); + TempCs.SmiState = SbLib_GetSmiState(); + + IoWrite8(0x21, 0xff); + IoWrite8(0xa1, 0xff); + SbLib_SmiDisable(); + + Cs->Busy = TRUE; + + Cs->IntState[0] = TempCs.IntState[0]; + Cs->IntState[1] = TempCs.IntState[1]; + Cs->SmiState = TempCs.SmiState; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: EndCriticalSection +// +// Description: This function calls when critical section ends. It enable interupts, +// and Smi and fills CRITICAL_SECTION structure fields +// +// Input: CRITICAL_SECTION *Cs - pointer to CRITICAL_SECTION structure +// +// Output: VOID +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +VOID EndCriticalSection(CRITICAL_SECTION *Cs) +{ + CRITICAL_SECTION TempCs; + + TempCs.IntState[0] = Cs->IntState[0]; + TempCs.IntState[1] = Cs->IntState[1]; + TempCs.SmiState = Cs->SmiState; + + Cs->Busy = FALSE; + + if (TempCs.SmiState) SbLib_SmiEnable(); + IoWrite8(0x21, TempCs.IntState[0]); + IoWrite8(0xa1, TempCs.IntState[1]); +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: DxeGetVariableSafe +// +// Description: This function searches for Var with specific GUID and Name +// beginning and ending critical section +// +// Input: IN CHAR16 *VariableName - pointer to Var Name in Unicode +// IN EFI_GUID *VendorGuid - pointer to Var GUID +// OPTIONAL OUT UINT32* Attributes - Pointer to memory where Attributes will be returned +// IN OUT UINTN *DataSize - size of Var - if smaller than actual EFI_BUFFER_TOO_SMALL +// will be returned and DataSize will be set to actual size needed +// OUT VOID *Data - Pointer to memory where Var will be returned +// +// Output: EFI_STATUS - based on result +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS DxeGetVariableSafe( + IN CHAR16 *VariableName, IN EFI_GUID *VendorGuid, + OUT UINT32 *Attributes OPTIONAL, + IN OUT UINTN *DataSize, OUT VOID *Data +) +{ + EFI_STATUS Status; + BEGIN_CRITICAL_SECTION(NvramCsPtr); + Status = DxeGetVariable( + VariableName,VendorGuid,Attributes,DataSize,Data + ); + END_CRITICAL_SECTION(NvramCsPtr); + return Status; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: DxeGetNextVariableNameSafe +// +// Description: This function searches for Var folowing after Var with specific name and GUID +// and returns it's Name, beginning and ending critical section . +// +// Input: IN OUT UINTN *VariableNameSize - size of Varname - if smaller than actual EFI_BUFFER_TOO_SMALL +// will be returned and DataSize will be set to actual size needed +// IN OUT CHAR16 *VariableName - pointer where Var Name in Unicode will be stored +// IN OUT EFI_GUID *VendorGuid - pointer to menory where Var GUID is stored +// +// Output: EFI_STATUS - based on result +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS DxeGetNextVariableNameSafe( + IN OUT UINTN *VariableNameSize, + IN OUT CHAR16 *VariableName, IN OUT EFI_GUID *VendorGuid +) +{ + EFI_STATUS Status; + BEGIN_CRITICAL_SECTION(NvramCsPtr); + Status = DxeGetNextVariableName( + VariableNameSize,VariableName,VendorGuid + ); + END_CRITICAL_SECTION(NvramCsPtr); + return Status; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: DxeSetVariableSafe +// +// Description: This function sets Var with specific GUID, Name and attributes +// beginning and ending critical section. +// +// Input: IN CHAR16 *VariableName - pointer to Var Name in Unicode +// IN EFI_GUID *VendorGuid - pointer to Var GUID +// IN UINT32 Attributes - Attributes of the Var +// IN UINTN DataSize - size of Var +// IN VOID *Data - Pointer to memory where Var data is stored +// +// Output: EFI_STATUS - based on result +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS DxeSetVariableSafe( + IN CHAR16 *VariableName, IN EFI_GUID *VendorGuid, + IN UINT32 Attributes, IN UINTN DataSize, IN VOID *Data +) +{ + EFI_STATUS Status; + BEGIN_CRITICAL_SECTION(NvramCsPtr); + Status = DxeSetVariable( + VariableName,VendorGuid,Attributes,DataSize,Data + ); + END_CRITICAL_SECTION(NvramCsPtr); + return Status; +} + +//Initialization +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: InitVolatileStore +// +// Description: This function allocates memory and inits NVRAM_STORE_INFO structure. +// +// Input: NVRAM_STORE_INFO *pInfo - pointer to NVRAM store structure +// UINTN HeaderSize - Size of the header +// UINT8 Flags - default Flags +// +// Output: EFI_STATUS +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS InitVolatileStore( + NVRAM_STORE_INFO *Info, UINTN Size, + UINTN HeaderLength, UINT8 Flags, + BOOLEAN Runtime +) +{ + EFI_STATUS Status = EFI_SUCCESS; + + if ((NvramDriverBuffer) && (Flags & NVRAM_STORE_FLAG_NON_VALATILE)) { + Info->NvramAddress = SelectiveAllocate (FALSE, Size); + if (Info->NvramAddress == NULL) return EFI_OUT_OF_RESOURCES; + }else{ +#ifdef DO_NOT_ACCESS_DATA_OUTSIDE_OF_SMM_AT_RUNTIME + if (NoAccessOutsideofSmm){ + Status = pSmst->SmmAllocatePool ( + EfiRuntimeServicesData,Size, &Info->NvramAddress + ); + if (EFI_ERROR(Status)) return Status; + } + else +#endif + { + Status = pBS->AllocatePool ( + (Runtime) ? EfiRuntimeServicesData : EfiBootServicesData, + Size, &Info->NvramAddress + ); + if (EFI_ERROR(Status)) return Status; + } + } + + Info->NvramSize = Size; + MemSet(Info->NvramAddress,Info->NvramSize,FLASH_EMPTY_BYTE); + NvInitInfoBuffer( + Info,HeaderLength,Flags + ); + return EFI_SUCCESS; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: EnumerateStore +// +// Description: This function searches for last Ver and fills the NVRAM_STORE_INFO structure. +// +// Input: NVRAM_STORE_INFO *pInfo - pointer to NVRAM store structure +// +// Output: VOID +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +VOID EnumerateStore(NVRAM_STORE_INFO *Info) +{ + NVAR *Var, *LastVar; + INT16 NextGuid; + //Init NextGuid and pEndOfVars + Var = (NVAR*)Info->pFirstVar; + LastVar = Var; + NextGuid=0; + + if (NvIsVariable(Var,Info)) + { + //We assume that the first variable pInfo->pFirstVar is always valid + //It's OK since we checked for pInfo->pFirstVar validity + //during during NVRAM_STORE_INFO initialization in NvInitInfoBuffer routine + for (; Var; Var=NvGetNextNvar(Var,Info)) + { + if ( ( Var->flags&(NVRAM_FLAG_DATA_ONLY|NVRAM_FLAG_GUID) ) == 0 ) + { + INT16 guid = *(UINT8*)(Var+1); + + if (guid>NextGuid) NextGuid=guid; + } + + LastVar = Var; + } + + NextGuid++; + Info->LastVarSize = LastVar->size; + Info->pEndOfVars = (UINT8*)LastVar+LastVar->size; + Info->NextGuid = NextGuid; + + // Skip incomplete NVAR record at the end of the NVRAM area (if any) + LastVar = (NVAR*)Info->pEndOfVars; + if ( LastVar->size != FLASH_EMPTY_SIZE + && LastVar->size + <= (UINT8*)(Info->NvramGuidsAddress-NextGuid) - Info->pEndOfVars + ){ + Info->LastVarSize += LastVar->size; + Info->pEndOfVars += LastVar->size; + } + } +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: VarStoreDiscovery +// +// Description: This function searches for nested Verstores and adds them to the NVRAM_STORE_INFO structure. +// +// Input: NVRAM_STORE_INFO *pInfo - pointer to NVRAM store structure +// NVRAM_STORE_INFO *MemInfo - pointer to NVRAM store structure in memory +// +// Output: VOID +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +VOID VarStoreDiscovery(NVRAM_STORE_INFO *NvInfo, NVRAM_STORE_INFO *MemInfo) +{ + VarStoreInfo.InfoCount = 0; + VarStoreInfo.LastInfoIndex = 0; + + //Handle Manufacturing mode + if ( VarStoreInfo.NvramMode & NVRAM_MODE_MANUFACTORING + && NvGetDefaultsInfo( + MfgDefaults,NvInfo,&VarStoreInfo.NvramInfo[VarStoreInfo.InfoCount] + ) != NULL + ) + { + VarStoreInfo.InfoCount++; + } + + //Handle Default config mode + if (!(VarStoreInfo.NvramMode & NVRAM_MODE_DEFAULT_CONFIGURATION)) + { + //add regular NVRAM + VarStoreInfo.NvramInfo[VarStoreInfo.InfoCount]=*NvInfo; + VarStoreInfo.NvInfo = &VarStoreInfo.NvramInfo[VarStoreInfo.InfoCount]; + if (VarStoreInfo.NvramMode & NVRAM_MODE_MANUFACTORING) + VarStoreInfo.NvramInfo[VarStoreInfo.InfoCount].Flags |= NVRAM_STORE_FLAG_DO_NOT_ENUMERATE; + VarStoreInfo.InfoCount++; + + //add defaults + if (NvGetDefaultsInfo( + StdDefaults,NvInfo,&VarStoreInfo.NvramInfo[VarStoreInfo.InfoCount] + ) != NULL + ) + { + VarStoreInfo.InfoCount++; + } + } + + else + { + //add defaults + if (NvGetDefaultsInfo( + StdDefaults,NvInfo,&VarStoreInfo.NvramInfo[VarStoreInfo.InfoCount] + ) != NULL + ) + { + VarStoreInfo.InfoCount++; + } + + //add regular NVRAM + VarStoreInfo.NvramInfo[VarStoreInfo.InfoCount]=*NvInfo; + VarStoreInfo.NvInfo = &VarStoreInfo.NvramInfo[VarStoreInfo.InfoCount]; + VarStoreInfo.NvramInfo[VarStoreInfo.InfoCount].Flags |= NVRAM_STORE_FLAG_DO_NOT_ENUMERATE; + VarStoreInfo.InfoCount++; + } + + VarStoreInfo.NvramInfo[VarStoreInfo.InfoCount] = *MemInfo; + VarStoreInfo.MemInfo=&VarStoreInfo.NvramInfo[VarStoreInfo.InfoCount]; + VarStoreInfo.InfoCount++; + //Init NextGuid and pEndOfVars + EnumerateStore(VarStoreInfo.NvInfo); +} + +//--- Hook to chek NvRam data +BOOLEAN DxeIsNvramDataCompatible(IN EFI_GET_VARIABLE GetVariable); + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: NvramInitialize +// +// Description: This function initializes Varstore +// +// Input: NONE +// +// Output: EFI_STATUS based on result +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS NvramInitialize() +{ + static EFI_GUID guidHobList = HOB_LIST_GUID; + NVRAM_STORE_INFO NvStore, MemStore; + NVRAM_HOB *NvramHob = (NVRAM_HOB*)GetEfiConfigurationTable(pST,&guidHobList); + NVRAM_STORE_INFO DefaultsInfo; + BOOLEAN UseExternalDefaults=FALSE; + BOOLEAN PreserveVariablesWithNoDefaults=FALSE; + + if (!NvramHob) return EFI_NOT_FOUND; + + if (EFI_ERROR(FindNextHobByGuid((EFI_GUID*)&AmiNvramHobGuid, &NvramHob))) + return EFI_NOT_FOUND; + + if (NvramRtGarbageCollectionSupport) { + NvramDriverBufferSize = NvramHob->NvramSize * 3; + if( EFI_ERROR( pBS->AllocatePages( + AllocateAnyPages, EfiRuntimeServicesData, + EFI_SIZE_TO_PAGES(NvramDriverBufferSize), + &NvramDriverBuffer ) + )) NvramDriverBuffer = 0; + } + + MemSet(&VarStoreInfo,sizeof(VarStoreInfo),0); + VarStoreInfo.HeaderLength = NvramHob->HeaderLength; + VarStoreInfo.NvramMode = NvramHob->NvramMode; + VarStoreInfo.BackupAddress = (UINT8*)NvramHob->BackupAddress; +#ifdef EFI_DEBUG + if (VarStoreInfo.BackupAddress) + NVRAM_TRACE((TRACE_DXE_CORE,"NVRAM back up address: %X\n", VarStoreInfo.BackupAddress)); +#endif + VarStoreInfo.MemInterface=&MemInterface; + InitVolatileStore( + &MemStore, + VALATILE_VARIABLE_STORE_SIZE, + VarStoreInfo.HeaderLength,0,TRUE + ); + //TODO: comment out the code below for now. + // Switching to simulation during recovery is not necessarily a good idea. + // For example, it can cause endless reboot if recovery is enabled during the + // very first boot after BIOS flashing. Ideally we should switch to simulation + // only when NVRAM is incompatible with the FV_MAIN drivers + // (which is checked later in this function). While enabling the simulation + // we should also "notify" (notification mechanism TBD) the reflash module + // that if FV_MAIN is updated, NVRAM must also be updated. +/* + BootMode = GetBootMode(); + if (BootMode==BOOT_IN_RECOVERY_MODE) + VarStoreInfo.NvramMode |= NVRAM_MODE_SIMULATION; +*/ + //If we are in the simulation mode let's create new + //memory based variable store and initialze it with + //content of the NVRAM flash area. + if (VarStoreInfo.NvramMode & NVRAM_MODE_SIMULATION) + { + VarStoreInfo.NvInterface=&MemInterface; + InitVolatileStore( + &NvStore, NvramHob->NvramSize, + VarStoreInfo.HeaderLength, + NVRAM_STORE_FLAG_NON_VALATILE,TRUE + ); + MemCpy(NvStore.NvramAddress,(UINT8*)NvramHob->NvramAddress,NvStore.NvramSize); + //We altered content of the varstore. Let's reinitialize it. + NvInitInfoBuffer( + &NvStore, VarStoreInfo.HeaderLength, + NVRAM_STORE_FLAG_NON_VALATILE + ); + //no backup in the simulation mode + VarStoreInfo.BackupAddress=0; + NVRAM_TRACE((TRACE_DXE_CORE,"NVRAM: working in simulation mode\n")); + } + + else + { + VarStoreInfo.NvInterface=&NvInterface; + NvStore.NvramAddress = (UINT8*)NvramHob->NvramAddress; + NvStore.NvramSize = NvramHob->NvramSize; + NvInitInfoBuffer( + &NvStore, + VarStoreInfo.HeaderLength, + NVRAM_STORE_FLAG_NON_VALATILE + ); + } + + //If FV header is corrupted or built-in defaults are not found, + //reset NVRAM data; use external defaults. + if ( ((EFI_FIRMWARE_VOLUME_HEADER*)NvStore.NvramAddress)->Signature!=FV_SIGNATURE + || NvGetDefaultsInfo(StdDefaults, &NvStore, &DefaultsInfo) == NULL + ){ + UseExternalDefaults = TRUE; + PreserveVariablesWithNoDefaults = TRUE; + VarStoreInfo.NvramMode |= NVRAM_MODE_RESET_CONFIGURATION; + } + //Handle NVRAM reset + if (VarStoreInfo.NvramMode & NVRAM_MODE_RESET_CONFIGURATION) + { + NvResetConfiguration( + &NvStore,VarStoreInfo.NvInterface, + UseExternalDefaults, PreserveVariablesWithNoDefaults + ); + VarStoreInfo.NvramMode&=~NVRAM_MODE_RESET_CONFIGURATION; + } +#ifdef HYBRID_NV_INTERFACE + if (!(VarStoreInfo.NvramMode & NVRAM_MODE_SIMULATION)) + InitHybridInterface(&NvStore); +#endif + VarStoreDiscovery(&NvStore,&MemStore); +#if NV_CACHE_SUPPORT + IndexInit(); +#endif + + if (!DxeIsNvramDataCompatible(DxeGetVariableSafe)) + { + NVRAM_TRACE((TRACE_DXE_CORE, "NVRAM DXE: Incompactible NVRAM detected\n")); + NvResetConfiguration( + VarStoreInfo.NvInfo, VarStoreInfo.NvInterface, + TRUE, TRUE + ); + } + + return EFI_SUCCESS; +} + +EFI_STATUS NvramReinitialize() +{ + NVRAM_STORE_INFO NvStore, MemStore; + + NvStore.NvramAddress = VarStoreInfo.NvInfo->NvramAddress; + NvStore.NvramSize = VarStoreInfo.NvInfo->NvramSize; + MemStore = *VarStoreInfo.MemInfo; + NvInitInfoBuffer( + &NvStore, + VarStoreInfo.HeaderLength, + NVRAM_STORE_FLAG_NON_VALATILE + ); + VarStoreDiscovery(&NvStore,&MemStore); +#if NV_CACHE_SUPPORT + IndexReset(); +#endif + return EFI_SUCCESS; +} +//////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////// +static EFI_GUID guidVariable = EFI_VARIABLE_ARCH_PROTOCOL_GUID; +static EFI_GUID guidVariableWrite = EFI_VARIABLE_WRITE_ARCH_PROTOCOL_GUID; +static EFI_GUID guidMonotonicCounter = EFI_MONOTONIC_COUNTER_ARCH_PROTOCOL_GUID; +extern EFI_GUID gAmiGlobalVariableGuid; +UINT32 CounterLo=0, CounterHi=0; + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: GetNextHighMonotonicCount +// +// Description: This function gets Next High Monotonic Count +// +// Input: OUT UINT32 *HighCount - pointer to where result will be stored +// +// Output: EFI_STATUS based on result +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS GetNextHighMonotonicCount(OUT UINT32 *HighCount) +{ + EFI_STATUS Status; + UINTN Size = sizeof(UINT32); + + if (!HighCount) return EFI_INVALID_PARAMETER; + + if (!CounterHi) + { + Status = pRS->GetVariable(L"MonotonicCounter", &gAmiGlobalVariableGuid, + NULL, &Size, &CounterHi + ); + + if (EFI_ERROR(Status) && Status != EFI_NOT_FOUND) + return Status; + } + + ++CounterHi; + Status = pRS->SetVariable( + L"MonotonicCounter", &gAmiGlobalVariableGuid, + EFI_VARIABLE_NON_VOLATILE|EFI_VARIABLE_BOOTSERVICE_ACCESS|EFI_VARIABLE_RUNTIME_ACCESS, + Size, &CounterHi + ); + + if (EFI_ERROR(Status)) return Status; + + *HighCount = CounterHi; + return EFI_SUCCESS; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: GetNextMonotonicCount +// +// Description: This function gets Next low and high Monotonic Count +// +// Input: OUT UINT64 *Count - pointer to where result will be stored +// +// Output: EFI_STATUS based on result +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS GetNextMonotonicCount(OUT UINT64 *Count) +{ + if (!Count) return EFI_INVALID_PARAMETER; + + ((UINT32*)Count)[0] = CounterLo++; + //--- If low counter overflovs - GetNextHighMonotonicCount + if (!CounterLo) return GetNextHighMonotonicCount(&((UINT32*)Count)[1]); + //--- If not - get current HighMonotonicCount + else ((UINT32*)Count)[1] = CounterHi; + + return EFI_SUCCESS; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: QueryVariableInfo +// +// Description: This function returns parameters of VarStore with passed attributes +// +// Input: IN UINT32 Attributes - Atributes to search for +// OUT UINT64 *MaximumVariableStorageSize - Maximum Variable Storage Size +// OUT UINT64 *RemainingVariableStorageSize - Remaining Variable Storage Size +// OUT UINT64 *MaximumVariableSize - Maximum Variable Size +// +// Output: EFI_STATUS based on result +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS QueryVariableInfo ( + IN UINT32 Attributes, + OUT UINT64 *MaximumVariableStorageSize, + OUT UINT64 *RemainingVariableStorageSize, + OUT UINT64 *MaximumVariableSize +) +{ + UINT64 StorageSize,RemainingStorage,MaxVarSize; + NVRAM_STORE_INFO *Info; + UINTN SizeOfVarSizeType = MAX_NVRAM_VARIABLE_SIZE; + + if ( !Attributes || (Attributes & ~ALL_VARIABLE_ATTRIBUTES) + ||(Attributes & EFI_VARIABLE_RUNTIME_ACCESS) && !(Attributes & EFI_VARIABLE_BOOTSERVICE_ACCESS ) + || !MaximumVariableStorageSize || !RemainingVariableStorageSize || !MaximumVariableSize + ) + return EFI_INVALID_PARAMETER; + + Info = (Attributes & EFI_VARIABLE_NON_VOLATILE) + ? VarStoreInfo.NvInfo : VarStoreInfo.MemInfo; + StorageSize=Info->NvramSize; + RemainingStorage=(UINT8*)( + (EFI_GUID*)(Info->NvramAddress+Info->NvramSize) + - Info->NextGuid-1 + )-Info->pEndOfVars; + MaxVarSize= (SizeOfVarSizeType>RemainingStorage) + ? RemainingStorage : SizeOfVarSizeType; + MaxVarSize -= sizeof(NVAR) + sizeof(EFI_GUID); + + if ((INTN)MaxVarSize<0) MaxVarSize=0; + + *MaximumVariableStorageSize = StorageSize; + *RemainingVariableStorageSize = RemainingStorage; + *MaximumVariableSize = MaxVarSize; + return EFI_SUCCESS; +} + +VOID NvramNotInSmmExitBs(); +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: VarExitBS +// +// Description: This function will be called when Exit BS will signaled +// will update data to work in RunTime. +// +// Input: IN EFI_EVENT Event - signalled event +// IN VOID *Context - calling context +// +// Output: VOID +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +VOID VarExitBS (IN EFI_EVENT Event, IN VOID *Context) +{ + Runtime = TRUE; +#if NV_CACHE_SUPPORT + IndexExitBs(); +#endif + //When we call this function from SMM, Event is NULL + if (Event!=NULL) NvramNotInSmmExitBs(); +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: VarStoreVirtualFixup +// +// Description: This function will be invoked to convert +// runtime pointers to virtual address +// +// Input: NVRAM_STORE_INFO *Info - pointer to NVRAM_STORE_INFO structure to fixup +// +// Output: VOID +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +VOID VarStoreVirtualFixup(NVRAM_STORE_INFO *Info) +{ + pRS->ConvertPointer(0,&Info->pFirstVar); + pRS->ConvertPointer(0,&Info->pEndOfVars); + pRS->ConvertPointer(0,&Info->NvramGuidsAddress); + pRS->ConvertPointer(0,&Info->NvramAddress); + Info->pLastReturned=NULL; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: VarInterfaceVirtualFixup +// +// Description: This function will be invoked to convert +// runtime pointers to virtual address +// +// Input: VARIABLE_INTERFACE *Interface - pointer to VARIABLE_INTERFACE structure to fixup +// +// Output: VOID +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +VOID VarInterfaceVirtualFixup(VARIABLE_INTERFACE *Interface) +{ + pRS->ConvertPointer(0,(VOID**)&Interface->EnableUpdate); + pRS->ConvertPointer(0,(VOID**)&Interface->DisableUpdate); + pRS->ConvertPointer(0,(VOID**)&Interface->EraseBytes); + pRS->ConvertPointer(0,(VOID**)&Interface->WriteBytes); +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: VarVirtAddressChange +// +// Description: This function will be invoked to convert whole Var infrustructure +// and pRS runtime pointers to virtual address +// +// Input: IN EFI_EVENT Event - signalled event +// IN VOID *Context - calling context +// +// Output: VOID +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +VOID VarVirtAddressChange (IN EFI_EVENT Event, IN VOID *Context) +{ + UINTN i; + VarStoreVirtualFixup(VarStoreInfo.NvInfo); +#ifdef HYBRID_NV_INTERFACE + pRS->ConvertPointer(0,&VarStoreInfo.NvramFlashAddress); + VarStoreInfo.AddressDelta=VarStoreInfo.NvramFlashAddress-VarStoreInfo.NvInfo->NvramAddress; +#endif + for (i=0; i< VarStoreInfo.InfoCount; i++) + if (VarStoreInfo.NvInfo!=&VarStoreInfo.NvramInfo[i]) + VarStoreVirtualFixup(&VarStoreInfo.NvramInfo[i]); + + for (i=0; GetVariableHookList[i]; i++){ + pRS->ConvertPointer(0,(VOID**)&(GetVariableHookList[i])); + } + + for (i=0; SetVariableHookList[i]; i++){ + pRS->ConvertPointer(0,(VOID**)&(SetVariableHookList[i])); + } + + for (i=0; GetNextVarNameHookList[i]; i++){ + pRS->ConvertPointer(0,(VOID**)&(GetNextVarNameHookList[i])); + } + + pRS->ConvertPointer(0,&VarStoreInfo.NvInfo); + pRS->ConvertPointer(0,&VarStoreInfo.MemInfo); + VarInterfaceVirtualFixup(VarStoreInfo.NvInterface); + VarInterfaceVirtualFixup(VarStoreInfo.MemInterface); + pRS->ConvertPointer(0,&VarStoreInfo.NvInterface); + pRS->ConvertPointer(0,&VarStoreInfo.MemInterface); + if (VarStoreInfo.BackupAddress!=NULL) + pRS->ConvertPointer(0,&VarStoreInfo.BackupAddress); + if (NvramDriverBuffer) + pRS->ConvertPointer(0,(VOID**)&NvramDriverBuffer); + VarStoreInfo.LastInfoIndex = 0; + pRS->ConvertPointer(0, &Flash); +#if NV_CACHE_SUPPORT + IndexVirtualFixup(); +#endif + //Fixup global data for for a virtual address space. + FlashVirtualFixup(pRS); + //pRS is converted by the library + //(call to InitAmiRuntimeLib initiates the processes) + AuthServiceVirtualFixup(); +} + +/////////////////////////////////////////////////////////////////// + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: MonotonicCounterInit +// +// Description: This function initialize pBS MonotonicCount servicies and installs +// corresponding protocols +// +// Input: IN EFI_HANDLE ImageHandle - Image handle +// IN EFI_SYSTEM_TABLE *SystemTable - pointer to System Table +// +// Output: VOID +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +VOID MonotonicCounterInit( + IN EFI_HANDLE ImageHandle, IN EFI_SYSTEM_TABLE *SystemTable +) +{ + EFI_HANDLE Handle = NULL; + UINT32 HighCount; + InitAmiLib(ImageHandle,SystemTable); + pRS->GetNextHighMonotonicCount = GetNextHighMonotonicCount; + pBS->GetNextMonotonicCount = GetNextMonotonicCount; + //Init Hi part of the monotonic counter + GetNextHighMonotonicCount(&HighCount); + pBS->InstallMultipleProtocolInterfaces( + &Handle, + &guidMonotonicCounter, NULL, + NULL + ); +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: NvRamInit +// +// Description: This function initialize pRS Var servicies and MonotonicCount servicies +// (if MONOTONIC_COUNT_IN_NVRAM token is set) installs +// corresponding protocols +// +// Input: IN EFI_HANDLE ImageHandle - Image handle +// IN EFI_SYSTEM_TABLE *SystemTable - pointer to System Table +// +// Output: VOID +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +VOID NvRamInit( + IN EFI_HANDLE ImageHandle, IN EFI_SYSTEM_TABLE *SystemTable +) +{ + EFI_HANDLE Handle = NULL; + EFI_EVENT Event; + EFI_STATUS Status; + + //TODO: When DO_NOT_ACCESS_DATA_OUTSIDE_OF_SMM_AT_RUNTIME is defined, we assume that + //DXE Variable services will be replaced prior to transitioning to runtime. + //If this will not happen, the NVRAM driver may not work properly. + //It may either crash (or crash the Windows), or generate false garbage collections. + //If support fall back scenario the memory registration of the virtual address change event + //and cdoe that allocates hybrid mode buffer must be changed + //TODO: When DO_NOT_ACCESS_DATA_OUTSIDE_OF_SMM_AT_RUNTIME is defined, we can allocate MemStore buffer in boot time memory. + InitAmiRuntimeLib( + ImageHandle, SystemTable, VarExitBS, +#ifdef DO_NOT_ACCESS_DATA_OUTSIDE_OF_SMM_AT_RUNTIME + NULL +#else + VarVirtAddressChange +#endif + ); + PROGRESS_CODE(DXE_NVRAM_INIT); + + Status = pBS->LocateProtocol(&gFlashProtocolGuid, NULL, &Flash); + ASSERT_EFI_ERROR(Status); + + NvramInitialize(); +// We need to know when to switch to the Runtime mode. +// Switch to runtime happens on exit boot services or legacy boot event. +// exit boot services callabck is installed by the InitAmiRuntimeLib function. +// Let's install legacy boot callbakc here. + CreateLegacyBootEvent(TPL_CALLBACK, &VarExitBS, NULL, &Event); + pRS->GetNextVariableName = DxeGetNextVariableNameSafe; + pRS->GetVariable = DxeGetVariableSafe; + pRS->SetVariable = DxeSetVariableSafe; + pRS->QueryVariableInfo = QueryVariableInfo; + + pBS->InstallMultipleProtocolInterfaces( + &Handle, + &guidVariable, NULL, + &guidVariableWrite, NULL, + NULL + ); + //--- Install MonotonicCount servicies (if NVRAM_MONOTONIC_COUNTER_SUPPORT token is set) + if (NvramMonotonicCounterSupport) MonotonicCounterInit(ImageHandle, SystemTable); +} + + +//********************************************************************** +// NVRAM SMM BEGIN +//********************************************************************** +//when this type is changed, initialization of the NvRamMailboxBuffer variable must also be changed. +typedef struct +{ +//TODO: StopRtDataAccess - must be the first field; NvramSmi driver is using it + BOOLEAN StopRtDataAccess; + VARSTORE_INFO *VarStoreInfoPtr; + VAR_INDEX *VarIndexPtr; + BOOLEAN SwitchToRuntime; + CRITICAL_SECTION *NvramCsPtr; + EFI_PHYSICAL_ADDRESS NvramDriverBuffer; + UINT32 NvramBuffSize; +} NVRAM_MAILBOX; + +#define NVRAM_MAILBOX_ADDRESS_VARIABLE_GUID \ + {0x54913a6d, 0xf4ee, 0x4cdb, 0x84, 0x75, 0x74, 0x6, 0x2b, 0xfc, 0xec, 0xf5} + +EFI_GUID NvRamMailboxVariableGuid = NVRAM_MAILBOX_ADDRESS_VARIABLE_GUID; +NVRAM_MAILBOX *NvRamMailbox; + +/*************** OUTSIDE SMM **********************************/ + +NVRAM_MAILBOX NvRamMailboxBuffer = {FALSE, &VarStoreInfo, NULL, FALSE, NULL, 0, 0}; + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: LegacyToEfiFn +// +// Description: +// +// Input: +// +// Output: +// +// Notes: +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS +LegacyToEfiFn ( + IN EFI_EVENT Event, + IN VOID *Context +) +{ + // NvramCsPtr = &NvramCs; + Runtime = FALSE; + NvRamMailbox->SwitchToRuntime = FALSE; + + + + return EFI_SUCCESS; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: NvramNotInSmmInit +// +// Description: This function initialize pRS Var, MonotonicCount servicies +// (if MONOTONIC_COUNT_IN_NVRAM token is set) and installs +// corresponding protocols and sets NvRamMailbox Var not in SMM +// +// Input: IN EFI_HANDLE ImageHandle - Image handle +// IN EFI_SYSTEM_TABLE *SystemTable - pointer to System Table +// +// Output: EFI_STATUS +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS NvramNotInSmmInit( + IN EFI_HANDLE ImageHandle, IN EFI_SYSTEM_TABLE *SystemTable +) +{ + + EFI_GUID pLTEBGuid = LTEB_GUID; + EFI_EVENT Event; + + EFI_STATUS Status; + + NvRamInit(ImageHandle, SystemTable); + NvRamMailboxBuffer.VarIndexPtr = VarIndexPtr; + NvRamMailboxBuffer.NvramCsPtr = NvramCsPtr; + if (NvramRtGarbageCollectionSupport) { + NvRamMailboxBuffer.NvramDriverBuffer = NvramDriverBuffer; + NvRamMailboxBuffer.NvramBuffSize = NvramDriverBufferSize; + } + NvRamMailbox = &NvRamMailboxBuffer; + + AuthVariableServiceInit (); + + Status = pBS->CreateEventEx( EVT_NOTIFY_SIGNAL, + TPL_CALLBACK, + LegacyToEfiFn, + NULL, + &pLTEBGuid, + &Event); + + Status = pRS->SetVariable( + L"NvRamMailbox",&NvRamMailboxVariableGuid, + EFI_VARIABLE_BOOTSERVICE_ACCESS, sizeof(NvRamMailbox), &NvRamMailbox + ); + ASSERT_EFI_ERROR(Status); + + return EFI_SUCCESS; +} +/*************** INSIDE SMM **********************************/ +VARSTORE_INFO *RtVarStoreInfoPtr; + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: SynchronizeVarStore +// +// Description: This function synchronizes NVRAM_STORE_INFO structure after enterin SMM +// +// Input: NVRAM_STORE_INFO *Source - source NVRAM_STORE_INFO structure +// NVRAM_STORE_INFO *Target - synchronized NVRAM_STORE_INFO structure +// +// Output: VOID +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +VOID SynchronizeVarStore(NVRAM_STORE_INFO *Source, NVRAM_STORE_INFO *Target) +{ + UINTN Delta = Target->NvramAddress - Source->NvramAddress; + Target->pFirstVar = Source->pFirstVar + Delta; + Target->pEndOfVars = Source->pEndOfVars + Delta; + Target->NextGuid = Source->NextGuid; + Target->LastVarSize = Source->LastVarSize; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: SynchronizeVarStoreInfo +// +// Description: This function synchronizes all NVRAM_STORE_INFO structures in VARSTORE_INFO after enterin SMM +// +// Input: VARSTORE_INFO *From - source VARSTORE_INFO structure +// VARSTORE_INFO *To - synchronized VARSTORE_INFO structure +// +// Output: VOID +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +VOID SynchronizeVarStoreInfo(VARSTORE_INFO *From, VARSTORE_INFO *To) +{ + UINT32 i; + To->InfoCount = From->InfoCount; + + for (i=0; i<From->InfoCount; i++) + { + SynchronizeVarStore(&From->NvramInfo[i], &To->NvramInfo[i]); + } +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: SynchronizeBeforeOperation +// +// Description: This function synchronizes Runtime and non Runtime Var Structures after enterin SMM +// before each operation with Variables +// +// Input: NONE +// +// Output: VOID +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +VOID SynchronizeBeforeOperation() +{ +#ifdef DO_NOT_ACCESS_DATA_OUTSIDE_OF_SMM_AT_RUNTIME +if (!NoAccessOutsideofSmm) +#endif +{ + SynchronizeVarStoreInfo( + RtVarStoreInfoPtr,&VarStoreInfo + ); + VarStoreInfo.NvInfo = (NVRAM_STORE_INFO*)( + (UINT8*)RtVarStoreInfoPtr->NvInfo - (UINT8*)NvRamMailbox->VarStoreInfoPtr + + (UINT8*)&VarStoreInfo + ); + VarStoreInfo.MemInfo = (NVRAM_STORE_INFO*)( + (UINT8*)RtVarStoreInfoPtr->MemInfo - (UINT8*)NvRamMailbox->VarStoreInfoPtr + + (UINT8*)&VarStoreInfo + ); +#ifdef DO_NOT_ACCESS_DATA_OUTSIDE_OF_SMM_AT_RUNTIME + if (NvRamMailbox->StopRtDataAccess){ + NoAccessOutsideofSmm=TRUE; +#if NV_CACHE_SUPPORT +//TODO: This has to be reviewed if RT Index support is added + //Shutdown the index + IndexExitBs(); +#endif + ReallocateVolatileVarstoreToSmm(); +#ifdef HYBRID_NV_INTERFACE + ReallocateHybridVarstoreToSmm(); +#endif + NvramCs = *NvramCsPtr; + NvramCsPtr->Busy = FALSE; + NvramCsPtr = &NvramCs; // switch to local CS + } +#endif +} + if (!Runtime && NvRamMailbox->SwitchToRuntime){ + VarExitBS(NULL,NULL); + } +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: SynchronizeAfterOperation +// +// Description: This function synchronizes Runtime and non Runtime Var Structures after enterin SMM +// after each operation with Variables +// +// Input: NONE +// +// Output: VOID +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +VOID SynchronizeAfterOperation() +{ +#ifdef DO_NOT_ACCESS_DATA_OUTSIDE_OF_SMM_AT_RUNTIME +if (!NoAccessOutsideofSmm) +#endif +{ + SynchronizeVarStoreInfo( + &VarStoreInfo, RtVarStoreInfoPtr + ); + RtVarStoreInfoPtr->NvInfo = (NVRAM_STORE_INFO*)( + (UINT8*)VarStoreInfo.NvInfo - (UINT8*)&VarStoreInfo + + (UINT8*)NvRamMailbox->VarStoreInfoPtr + ); + RtVarStoreInfoPtr->MemInfo = (NVRAM_STORE_INFO*)( + (UINT8*)VarStoreInfo.MemInfo - (UINT8*)&VarStoreInfo + + (UINT8*)NvRamMailbox->VarStoreInfoPtr + ); +} +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: SmmGetVariable +// +// Description: This function searches for Var with specific GUID and Name in SMM +// synchronizing Varstors before and after operation +// +// Input: IN CHAR16 *VariableName - pointer to Var Name in Unicode +// IN EFI_GUID *VendorGuid - pointer to Var GUID +// OPTIONAL OUT UINT32* Attributes - Pointer to memory where Attributes will be returned +// IN OUT UINTN *DataSize - size of Var - if smaller than actual EFI_BUFFER_TOO_SMALL +// will be returned and DataSize will be set to actual size needed +// OUT VOID *Data - Pointer to memory where Var will be returned +// +// Output: EFI_STATUS - based on result +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS SmmGetVariable( + IN CHAR16 *VariableName, IN EFI_GUID *VendorGuid, + OUT UINT32 *Attributes OPTIONAL, + IN OUT UINTN *DataSize, OUT VOID *Data +) +{ + EFI_STATUS Status; + BEGIN_CRITICAL_SECTION(NvramCsPtr); + SynchronizeBeforeOperation(); + Status = DxeGetVariable( + VariableName, VendorGuid, Attributes, DataSize, Data + ); + SynchronizeAfterOperation(); + END_CRITICAL_SECTION(NvramCsPtr); + return Status; +} +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: SmmSetVariable +// +// Description: This function sets Var with specific GUID, Name and attributes in SMM +// synchronizing Varstors before and after operation +// +// Input: IN CHAR16 *VariableName - pointer to Var Name in Unicode +// IN EFI_GUID *VendorGuid - pointer to Var GUID +// IN UINT32 Attributes - Attributes of the Var +// IN UINTN DataSize - size of Var +// IN VOID *Data - Pointer to memory where Var data is stored +// +// Output: EFI_STATUS - based on result +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS SmmSetVariable( + IN CHAR16 *VariableName, IN EFI_GUID *VendorGuid, + IN UINT32 Attributes, IN UINTN DataSize, IN VOID *Data +) +{ + EFI_STATUS Status; + + BEGIN_CRITICAL_SECTION(NvramCsPtr); + SynchronizeBeforeOperation(); + Status = DxeSetVariable( + VariableName, VendorGuid, Attributes, DataSize, Data + ); + SynchronizeAfterOperation(); + END_CRITICAL_SECTION(NvramCsPtr); + return Status; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: SmmGetNextVariableName +// +// Description: This function searches for next Var after Var with specific name and GUID and returns it's Name +// in SMM synchronizing Varstors before and after operation. +// +// Input: IN OUT UINTN *VariableNameSize - size of Varname - if smaller than actual EFI_BUFFER_TOO_SMALL +// will be returned and DataSize will be set to actual size needed +// IN OUT CHAR16 *VariableName - pointer where Var Name in Unicode will be stored +// IN OUT EFI_GUID *VendorGuid - pointer to menory where Var GUID is stored +// +// Output: EFI_STATUS - based on result +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS SmmGetNextVariableName ( + IN OUT UINTN *VariableNameSize, + IN OUT CHAR16 *VariableName, IN OUT EFI_GUID *VendorGuid +) +{ + EFI_STATUS Status; + + BEGIN_CRITICAL_SECTION(NvramCsPtr); + SynchronizeBeforeOperation(); + Status = DxeGetNextVariableName( + VariableNameSize, VariableName, VendorGuid + ); + SynchronizeAfterOperation(); + END_CRITICAL_SECTION(NvramCsPtr); + return Status; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: SmmQueryVariableInfo +// +// Description: This function returns parameters of VarStore with passed attributes in SMM +// synchronizing Varstors before operation. +// +// Input: IN UINT32 Attributes - Atributes to search for +// OUT UINT64 *MaximumVariableStorageSize - Maximum Variable Storage Size +// OUT UINT64 *RemainingVariableStorageSize - Remaining Variable Storage Size +// OUT UINT64 *MaximumVariableSize - Maximum Variable Size +// +// Output: EFI_STATUS based on result +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS SmmQueryVariableInfo ( + IN UINT32 Attributes, + OUT UINT64 *MaximumVariableStorageSize, + OUT UINT64 *RemainingVariableStorageSize, + OUT UINT64 *MaximumVariableSize +) +{ + EFI_STATUS Status; + + SynchronizeBeforeOperation(); + Status = QueryVariableInfo( + Attributes, MaximumVariableStorageSize, + RemainingVariableStorageSize, MaximumVariableSize + ); + return Status; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: NvramSmmInit +// +// Description: This function gets NvRamMailbox and initialize pRS Var servicies and +// corresponding structures +// +// Input: IN EFI_HANDLE ImageHandle - Image handle +// IN EFI_SYSTEM_TABLE *SystemTable - pointer to System Table +// +// Output: EFI_STATUS based on result +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS NvramSmmInit( + IN EFI_HANDLE ImageHandle, IN EFI_SYSTEM_TABLE *SystemTable +) +{ + EFI_STATUS Status; + UINTN Size=sizeof(NvRamMailbox); + + Status = pST->RuntimeServices->GetVariable( + L"NvRamMailbox",&NvRamMailboxVariableGuid, + NULL, &Size, &NvRamMailbox + ); + + if (EFI_ERROR(Status)) return Status; + + RtVarStoreInfoPtr = NvRamMailbox->VarStoreInfoPtr; + VarStoreInfo=*RtVarStoreInfoPtr; + VarIndexPtr=NvRamMailbox->VarIndexPtr; + NvramCsPtr=NvRamMailbox->NvramCsPtr; + + if (NvramRtGarbageCollectionSupport){ + NvramDriverBuffer = NvRamMailbox->NvramDriverBuffer; + NvramDriverBufferSize = NvRamMailbox->NvramBuffSize; + } + + VarStoreInfo.MemInterface=&MemInterface; + VarStoreInfo.NvInfo = + &VarStoreInfo.NvramInfo[ + RtVarStoreInfoPtr->NvInfo - RtVarStoreInfoPtr->NvramInfo + ]; + VarStoreInfo.MemInfo = + &VarStoreInfo.NvramInfo[ + RtVarStoreInfoPtr->MemInfo - RtVarStoreInfoPtr->NvramInfo + ]; +#ifdef HYBRID_NV_INTERFACE + VarStoreInfo.NvInterface=&HybridInterface; +#else + VarStoreInfo.NvInterface=&NvInterface; +#endif + + pRS->GetNextVariableName = SmmGetNextVariableName; + pRS->GetVariable = SmmGetVariable; + pRS->SetVariable = SmmSetVariable; + pRS->QueryVariableInfo = SmmQueryVariableInfo; + Status = pBS->LocateProtocol(&gFlashSmmProtocolGuid, NULL, &Flash); + ASSERT_EFI_ERROR (Status); + AuthVariableServiceInitSMM(); + InstallNvramControlSmmProtocol(); + return EFI_SUCCESS; +} + +/*************** INSIDE and OUSIDE SMM ************************/ +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: NvramNotInSmmExitBs +// +// Description: This function signals that exit BS event was taken place and switches +// SwitchToRuntime field in NvRamMailbox +// +// Input: NONE +// +// Output: VOID +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +VOID NvramNotInSmmExitBs() +{ + NvRamMailbox->SwitchToRuntime = !NvRamMailbox->SwitchToRuntime; +#ifdef DO_NOT_ACCESS_DATA_OUTSIDE_OF_SMM_AT_RUNTIME + //Make a dummy SMM GetVariable call to process SwitchToRuntime + //make sure GetVariable is substituted + if (pRS->GetVariable!=DxeGetVariableSafe){ + static EFI_GUID DummyGuid={0}; + UINTN Size = 0; + UINTN Dummy; + pRS->GetVariable(L"Dummy", &DummyGuid,NULL, &Size, &Dummy); + } +#endif +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: NvRamSmmEntry +// +// Description: This function is the entry point for this DXE. This function +// installs NvRam services in and outside SMM. +// +// Input: IN EFI_HANDLE ImageHandle - Image handle +// IN EFI_SYSTEM_TABLE *SystemTable - Pointer to the system table +// +// Output: EFI_STATUS - Status based on errors that occurred while waiting for +// time to expire. +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS NvRamSmmEntry( + IN EFI_HANDLE ImageHandle, IN EFI_SYSTEM_TABLE *SystemTable +) +{ + InitAmiLib(ImageHandle,SystemTable); + return InitSmmHandlerEx( + ImageHandle, SystemTable, NvramSmmInit, NvramNotInSmmInit + ); +} +//********************************************************************** +// NVRAM SMM END +//********************************************************************** +//********************************************************************** +//********************************************************************** +//** ** +//** (C)Copyright 1985-2014, American Megatrends, Inc. ** +//** ** +//** All Rights Reserved. ** +//** ** +//** 5555 Oakbrook Parkway, Suite 200, Norcross, GA 30093 ** +//** ** +//** Phone: (770)-246-8600 ** +//** ** +//********************************************************************** +//********************************************************************** |