init. 1AQQW051HEADmaster

1 files changed, 2252 insertions, 0 deletions

diff --git a/Core/EM/CmosManager/CmosAccess.c b/Core/EM/CmosManager/CmosAccess.c
new file mode 100644
index 0000000..d3dea31
--- /dev/null
+++ b/Core/EM/CmosManager/CmosAccess.c
@@ -0,0 +1,2252 @@
+//*************************************************************************
+//*************************************************************************
+//**                                                                     **
+//**        (C)Copyright 1985-2009, American Megatrends, Inc.            **
+//**                                                                     **
+//**                       All Rights Reserved.                          **
+//**                                                                     **
+//**      5555 Oakbrook Parkway, Suite 200, Norcross, GA 30093           **
+//**                                                                     **
+//**                       Phone: (770)-246-8600                         **
+//**                                                                     **
+//*************************************************************************
+//*************************************************************************
+
+//**********************************************************************
+// $Header: /Alaska/SOURCE/Modules/CMOS Manager/CMOS Core/CMOS Source/CmosAccess.c 25    6/15/10 2:24p Michaela $
+// 
+// $Revision: 25 $
+//
+// $Date: 6/15/10 2:24p $
+//**********************************************************************
+// Revision History
+// ----------------
+// $Log: /Alaska/SOURCE/Modules/CMOS Manager/CMOS Core/CMOS Source/CmosAccess.c $
+// 
+// 25    6/15/10 2:24p Michaela
+// 
+// 24    3/10/10 4:39p Michaela
+// 
+// 23    3/08/10 5:39p Michaela
+// 
+// 22    3/08/10 1:31p Michaela
+// 
+// 21    3/08/10 1:09p Michaela
+// 
+// 20    3/05/10 4:55p Michaela
+// 
+// 19    12/04/09 7:32p Michaela
+// 
+// 18    12/03/09 6:42p Michaela
+// 1. Updated CmosReadWrite() to use physical access to 
+//    non-checksummed locations within the Managed Region
+//    only if CMOS_RECOVER_ONLY_CHECKSUMMED is TRUE.
+//    (controlled via CMOS_MGR_RECOVER_ONLY_CHECKUMMED
+//    SDL token)
+//    
+// 2. Added CanClearLegacyStatusBits() to determine
+//    whether or not the legacy status bits can be
+//    clear to a non-failure status.
+//    
+// 3. SynchronizeLegacyStatusRegisters() is updated to
+//    only clear the bad checksum failure status in
+//    the legacy status registers in the DXE phase
+//    or on the first boot after flashing the firmware.
+// 
+// 17    11/10/09 9:14p Michaela
+// 
+// 16    7/29/09 9:59a Michaela
+// updates Aptio Enhancement EIP 22205
+// (no code changes)
+// 
+// 15    7/23/09 1:30p Michaela
+// Rename ReadRtcIndex and WriteRtcIndex
+// 
+// 14    6/15/09 5:11p Michaela
+// 
+// 13    6/02/09 3:27p Michaela
+// For label: 4.6.3_CMOSMGR_11
+// 
+// 12    2/23/09 6:03p Michaela
+// --code clean-up in CmosBankReadWrite()
+// --added test code to support test module it it is present
+// 
+// 11    11/25/08 3:20p Michaela
+// Updates for Label 4.6.3_CMOSMGR_08
+// - Assembly macro fixes
+// - Added assembly macros
+// - Moved loading defaults into DXE phase
+// - Updated help file example
+// 
+// 10    11/17/08 4:40p Michaela
+// --Removed Token Name strings in debug development code
+// 
+// 9     11/17/08 3:39p Michaela
+// --Removed debug development code
+// --CMOS Buffer feature is depreciated
+// --ReadCmosStatusBytes and UpdateBatteryStatus now directly 
+//   calls CmosPhysicalReadWrite to avoid error when the 
+//   Optimal Defaults table is being used for reads & writes
+// 
+// 8     11/14/08 9:12a Michaela
+// **CMOS register variables changed from UINT8 to UINT16
+// **added global CMOS_PORT_MAP array (gCmosBank) for
+//   supporting board-specific access functions.  The array is defined
+//   using the CMOS_PORT_MAPPING Elink.  The array starts at
+//   index 1.
+// **Added CmosBankReadWrite() for calling the board-specific
+//   access functions.
+// **Modified CmosPhysicalReadWrite() to call CmosBankReadWrite()
+//   for physical CMOS access
+// 
+// 7     11/07/08 5:13p Michaela
+// Updated to make CMOS manager available in all phases 
+// of the boot process:
+// 
+// A CMOS API Pointer is maintained in CMOS and accessible
+// via provided macros in C and assembly source.
+// 
+// 6     3/25/08 3:04p Michaela
+// --deleted UpdateLegacyChecksumStatus
+// --Modified SynchronizeLegacyStatusRegisters to 
+//   update both battery and checksum status bits
+// 
+// 5     3/07/08 4:07p Michaela
+// Label 4.6.3_CMOSMGR_05 fixes:
+// -- write errors to Optimal Defaults buffer before memory detection
+// -- CMOS Token table corruption when name strings are disabled
+// 
+// 4     2/29/08 9:35p Michaela
+// - Added recovery path policy
+// - fixed other minor bugs
+// 
+// 3     2/26/08 12:49p Michaela
+// Added/modified Helpbuilder headers
+// 
+// 2     2/22/08 3:20p Olegi
+// Renamed some of the equates to avoid the naming collisions.
+// 
+// 1     2/22/08 2:29p Michaela
+// 
+// 1     2/04/08 6:00p MichaelA
+// Created
+// 
+//**********************************************************************
+
+//<AMI_FHDR_START>
+//---------------------------------------------------------------------------
+//
+// Name:    CmosAccess.c
+//
+// Description: Contains the routines that constitute the CMOS access
+//              implementation.  This file contains source code that is used
+//              for both PEI and DXE phases.
+//
+//---------------------------------------------------------------------------
+//<AMI_FHDR_END>
+
+#include <Efi.h>
+#ifdef PEI_COMPILE
+    #include <Pei.h>
+    #include <AmiPeiLib.h>
+#else
+    #include <AmiDxeLib.h>
+#endif
+#include <CmosAccess.h>
+#include <SspTokens.h>
+#include "CmosManager.h"
+#include "CmosManagerHob.h"
+#include "CmosBoard.h"
+
+//---------------------------------------------------------------------------
+// CmosBank is initialized using the CMOS_PORT_MAPPING SDL Elink.
+// This array is used to determine which index/data port pair to use or
+// which board-specific access function to call for a specific CMOS register 
+// address. The first element is not used and contains all zeros.
+//---------------------------------------------------------------------------
+
+CMOS_PORT_MAP gCmosBank[] = { {0,0,0,0,0}, CMOS_PORT_MAPPING  };
+UINT16 gCmosBankCount = \
+    sizeof(gCmosBank) / sizeof(CMOS_PORT_MAP);
+
+EFI_CMOS_BATTERY_TEST gCmosBatteryIsGood = CMOS_BATTERY_TEST_MAPPING;
+
+//---------------------------------------------------------------------------
+// Function(s) originally defined in CmosManager.c
+//---------------------------------------------------------------------------
+extern EFI_CMOS_MANAGER_INTERFACE *GetCmosMangerInterface(
+    IN EFI_CMOS_ACCESS_INTERFACE   *Cmos );
+
+
+//---------------------------------------------------------------------------
+// Function(s) originally defined in CmosBuffer.c or CmosPhysical.c
+// depending on the sdl token BUFFERED_CMOS_SUPPORT
+//---------------------------------------------------------------------------
+    
+
+//---------------------------------------------------------------------------
+// Function declarations for this file
+//---------------------------------------------------------------------------
+EFI_STATUS CalculateUpdatedCheckSum(
+    IN  EFI_CMOS_MANAGER_INTERFACE  *Manager,
+    IN  UINT16                      CmosAddress,
+    IN  UINT8                       OldCmosValue,
+    IN  UINT8                       NewCmosValue,
+    OUT UINT16                      *NewChecksum );
+
+EFI_STATUS CalculateChecksum(
+    IN  EFI_CMOS_MANAGER_INTERFACE  *Manager,
+    OUT UINT16                      *ChecksumValue );
+
+EFI_STATUS WriteChecksum(
+    IN  EFI_CMOS_MANAGER_INTERFACE  *Manager,
+    OUT UINT16                      ChecksumValue );
+
+
+//<AMI_PHDR_START>
+//---------------------------------------------------------------------------
+//
+// Procedure: EncodeParameter 
+//
+// Description:
+//      Value is shifted left by the bit field size specified in Token.
+//
+// Input:
+//      OUT UINT8 *Value
+//                  -- Address of value to be encoded 
+//      IN CMOS_TOKEN *Token
+//                  -- Token describing the bit field size
+//
+// Notes:
+//      None
+//
+//---------------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+VOID EncodeParameter(
+    OUT UINT8       *Value,
+    IN  CMOS_TOKEN  *Token )
+{
+    *Value <<= Token->Value.Field.BitOffset;
+    
+}
+
+//<AMI_PHDR_START>
+//---------------------------------------------------------------------------
+//
+// Procedure: DecodeParameter
+//
+// Description:
+//      Value is shifted right and masked by the bit field's size and offset
+//      as specified in Token.
+//
+// Input:
+//      OUT UINT8 *Value
+//                  -- Address of value to be decoded
+//      IN CMOS_TOKEN *Token
+//                  -- Token describing the bit field's size and offset
+//
+// Notes:
+//      None
+//
+//---------------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+VOID DecodeParameter(
+    OUT UINT8        *Value,
+    IN CMOS_TOKEN   *Token )
+{
+    *Value >>= Token->Value.Field.BitOffset;
+    *Value &=  (0xff >> (8 - Token->Value.Field.Size));
+    
+}
+
+
+//<AMI_PHDR_START>
+//---------------------------------------------------------------------------
+//
+// Procedure: BitFieldOverflow
+//
+// Description:
+//      For testing whether or not a Value overflows the field size
+//      as specified in Token. 
+//
+// Input:
+//      IN UINT8 *Value
+//                  -- Value to be tested 
+//      IN CMOS_TOKEN *Token
+//                  -- Token describing the bit field's size
+//
+// Notes:
+//      None
+//
+//---------------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+BOOLEAN BitFieldOverflow(
+    IN UINT8        *Value, 
+    IN CMOS_TOKEN   *Token )
+{
+    if ( *Value & ~(0xff >> (8 - Token->Value.Field.Size)) )
+        return TRUE;
+    else
+        return FALSE;
+}
+
+//<AMI_PHDR_START>
+//---------------------------------------------------------------------------
+//
+// Procedure: SetClobberBits
+//
+// Description:
+//      Creates a mask with bits set corresponding to the size and offset
+//      of the bit field as specified by Token.
+//
+// Input:
+//      OUT UINT8 *Mask
+//                  -- Mask to be created
+//      IN CMOS_TOKEN *Token
+//                  -- Token describing the bit field's size and offset
+//
+// Notes:
+//      None
+//
+//---------------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+VOID SetClobberBits(
+    OUT UINT8        *Mask, 
+    IN CMOS_TOKEN   *Token )
+{
+    *Mask = 0xff >> (8 - Token->Value.Field.Size);
+    *Mask <<= Token->Value.Field.BitOffset;
+}
+
+
+
+//<AMI_PHDR_START>
+//---------------------------------------------------------------------------
+//
+// Procedure: CmosFindToken
+//
+// Description:
+//      Returns index of CMOS token in token table or 0 if not found.
+//
+// Input:
+//      IN  EFI_CMOS_MANAGER_INTERFACE *Manager
+//                  -- This is the CMOS Manager interface pointer.
+//      IN  UINT16 CmosToken 
+//                  -- Encoded CMOS token for which to locate an index into
+//                     the CMOS token table
+//
+// Output:
+//      UINT16 (Return Value)
+//                  = Index of the CmosToken in the token table, or
+//                  = 0, if the CmosToken was not found
+//
+// Notes:
+//      None
+//
+//---------------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+UINT16 CmosFindToken(
+    IN  EFI_CMOS_MANAGER_INTERFACE  *Manager,
+    IN  UINT16                      CmosToken )
+{
+    UINT16   i = 0;   // First valid token table index is 1
+    
+    while (++i < Manager->TokenCount) {
+        if (Manager->TokenTable[i].Value.AllBits == CmosToken) {
+            break;
+        }
+    }
+    
+    if (i < Manager->TokenCount)
+        return i;
+
+    return 0;
+}
+
+
+//<AMI_PHDR_START>
+//---------------------------------------------------------------------------
+//
+// Procedure: CmosGetTokenFromRegister
+//
+// Description:
+//      Returns encoded token for the specified register.
+//
+// Input:
+//      IN  EFI_CMOS_MANAGER_INTERFACE *Manager
+//                  -- This is the CMOS Manager interface pointer.
+//      IN  UINT8 CmosRegister 
+//                  -- CMOS register to for which to search
+//
+// Output:
+//      UINT16 (Return Value)
+//                  = Token found in the token table, or
+//                  = 0, if the Register was not found
+//
+// Notes:
+//
+//      Caller must ensure the register has been reserved properly
+//      in SSP.
+//
+//      This should be considered a risky function call and extra care
+//      should be taken to ensure the proper CmosRegister is specified.
+//
+//      This function has the potential for problems, as it is possible that 
+//      a specified CmosRegister has not been defined in SSP and/or may
+//      be used by another CmosToken.
+//
+//      All verification of parameters must be done by the caller.
+//
+//---------------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+UINT16 CmosGetTokenFromRegister(
+    IN  EFI_CMOS_ACCESS_INTERFACE   *Cmos,
+    IN  UINT16                      CmosRegister )
+{
+    UINT16                      i = 0;
+    EFI_CMOS_MANAGER_INTERFACE  *Manager = GetCmosMangerInterface(Cmos);
+    
+    // Manager->TokenCount is the total number of entries in 
+    // Manager->TokenTable where the first entry is zero.
+    
+    while (++i < Manager->TokenCount) {
+        if (Manager->TokenTable[i].Value.Field.CmosAddress == CmosRegister){
+            break;
+        }
+    }
+    
+    // Minimal error checking is to ensure it is an 8-bit CMOS Token
+    if (i < Manager->TokenCount ){
+        if (Manager->TokenTable[i].Value.Field.Size == 8)
+            return Manager->TokenTable[i].Value.AllBits;
+    }
+
+    // a valid token is greater than 0x1000
+    return 0;  
+}
+
+
+//<AMI_PHDR_START>
+//---------------------------------------------------------------------------
+//
+// Procedure: CmosBankReadWrite
+//
+// Description:
+//      This function determines which structure in the global CMOS_PORT_MAP
+//      array corresponds to the provided CmosAddress and either calls the
+//      associated function or uses the associated IO ports to read/write the 
+//      CMOS register value to/from the CmosParameterValue.
+//      
+// Input:
+//      IN      EFI_CMOS_MANAGER_INTERFACE *Manager
+//                  --  Pointer to the CMOS Manager internal interface
+//      IN      CMOS_ACCESS_TYPE AccessType
+//                  --  WriteType or ReadType
+//      IN      UINT16 CmosAddress
+//                  --  CMOS register to for which the access is to be made
+//      IN/OUT  UINT8 *CmosParameterValue
+//                  --  This is the value to write for write access or the 
+//                      value that was read for read access.
+//              
+//
+// Output:
+//      EFI_STATUS (Return Value)
+//                  EFI_SUCCESS or valid EFI error code
+//
+// Notes:
+//      N/A
+//
+//---------------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+EFI_STATUS CmosBankReadWrite(
+    IN  EFI_CMOS_MANAGER_INTERFACE  *Manager,
+    IN  CMOS_ACCESS_TYPE            AccessType,
+    IN  UINT16                      CmosAddress,
+    IN OUT UINT8                    *CmosParameterValue )
+{
+    UINT8       i = 1;
+    EFI_STATUS  Status = EFI_NOT_FOUND;
+    DEFINE_PEI_SERVICES(Manager->Access.PeiServices); // defines NULL if DXE
+
+    // scan the CMOS_PORT_MAP array to determine how to access this address
+    for (; i < gCmosBankCount; i++)
+    {
+      if (     (CmosAddress >= gCmosBank[i].Low) 
+            && (CmosAddress <= gCmosBank[i].High) )
+      {
+      
+        // First, attempt to call the board-specific function if available
+        if (gCmosBank[i].BoardReadWrite != NULL){
+            Status = gCmosBank[i].BoardReadWrite( PeiServices,
+                                              AccessType,
+                                              CmosAddress,
+                                              CmosParameterValue );
+            break;
+        }
+        
+        // Otherwise, attempt to use the provided index/data ports 
+        // if available (assuming 8 bit port access)
+        else if ( (gCmosBank[i].Index > 0) && (gCmosBank[i].Data > 0) ){
+            IoWrite8( gCmosBank[i].Index, (UINT8)CmosAddress );
+            if (AccessType == ReadType){
+                *CmosParameterValue = IoRead8( gCmosBank[i].Data );
+            }
+            else {
+                IoWrite8( gCmosBank[i].Data, *CmosParameterValue );
+            }
+            Status = EFI_SUCCESS;
+            break;
+        }
+        
+      }
+    }
+    return Status;
+}
+
+
+//<AMI_PHDR_START>
+//---------------------------------------------------------------------------
+//
+// Procedure: CmosPhysicalReadWrite
+//
+// Description:
+//      This function provides support for performing the actual
+//      read or write from/to a physical CMOS location.
+//
+// Input:
+//      IN EFI_CMOS_MANAGER_INTERFACE *Manager
+//                  -- Manager interface pointer
+//      IN CMOS_ACCESS_TYPE AccessType
+//                  -- Specifies whether to perform a read or a write
+//      IN UINT8 CmosAddress
+//                  -- Actual CMOS address/offset
+//      IN UINT8 BitsToWrite
+//                  -- Mask specifying the bits to be written (these
+//                      bits will be cleared first)
+//      IN OUT  UINT8 *CmosParameterValue
+//                  -- CMOS value to be written or, on successful exit, will
+//                      contain the value that was read
+//
+// Output:
+//      EFI_STATUS (Return Value)
+//                  = EFI_SUCCESS if successful
+//                  = or other valid EFI error code
+//
+// Notes:
+//      None
+//
+//---------------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+EFI_STATUS CmosPhysicalReadWrite(
+    IN      EFI_CMOS_MANAGER_INTERFACE  *Manager,
+    IN      CMOS_ACCESS_TYPE            AccessType,
+    IN      UINT16                      CmosAddress,
+    IN      UINT8                       BitsToWrite,  
+    IN OUT  UINT8                       *CmosParameterValue )
+{
+    UINT8       CmosRegisterValue;
+    UINT8       NewValue;
+    UINT16      NewChecksum = 0;
+    EFI_STATUS  Status = EFI_SUCCESS;
+    DEFINE_PEI_SERVICES(Manager->Access.PeiServices);
+
+    // Always read the value
+    CmosBankReadWrite( Manager,
+                       ReadType,
+                       CmosAddress,
+                       &CmosRegisterValue );
+    
+    // If read access, simply return the unmodified data
+    if ( AccessType == ReadType ) {
+        CMOS_TRACE_FULL(( CMOS_TRACE_ALWAYS, 
+            "    Physical Read: Register 0x%02X = 0x%02X\n",
+            CmosAddress, CmosRegisterValue));
+        *CmosParameterValue = CmosRegisterValue;
+    }
+    
+    // If writing, then don't clobber unused bits
+    else {
+        NewValue = (CmosRegisterValue & ~BitsToWrite) | *CmosParameterValue;
+
+        // get the new checksum before writing
+        if (!Manager->CheckStatus(Manager, CMOS_FORCE_NO_CHECKSUM))
+            Status = CalculateUpdatedCheckSum( Manager, CmosAddress,
+                CmosRegisterValue, NewValue, &NewChecksum);
+
+        // write the value
+        CMOS_TRACE_FULL(( CMOS_TRACE_ALWAYS, 
+            "    Physical Write: Register 0x%02X = 0x%02X\n",
+            CmosAddress, NewValue));
+        CmosBankReadWrite( Manager,
+                           WriteType,
+                           CmosAddress,
+                           &NewValue );
+        
+        // write the checksum, if necessary 
+        // (this write will cause an infinite loop without a flag)
+        if (!Manager->CheckStatus(Manager, CMOS_FORCE_NO_CHECKSUM)){
+            if (Manager->CheckStatus(Manager, CMOS_ADDRESS_IS_CHECKSUMMED)){
+                Manager->SetStatus(Manager, CMOS_FORCE_NO_CHECKSUM);
+                WriteChecksum( Manager, NewChecksum );
+                Manager->ClearStatus(Manager, CMOS_FORCE_NO_CHECKSUM);
+            }
+        }
+    }
+
+    return EFI_SUCCESS;
+}
+
+//<AMI_PHDR_START>
+//---------------------------------------------------------------------------
+//
+// Procedure: NotChecksummed
+//
+// Description:
+//      This function returns TRUE if the CmosAddress is NOT included in the
+//      checksum and returns FALSE otherwise.
+//
+// Input:
+//      IN EFI_CMOS_MANAGER_INTERFACE  *Manager
+//                  -- Manager interface pointer
+//      IN UINT8 CmosAddress
+//                  -- Actual CMOS address/offset
+//
+// Output:
+//      BOOLEAN (Return Value)
+//                  = TRUE if CmosAddress is NOT included in the checksum
+//                  = FALSE if CmosAddress IS included in the checksum
+//
+//---------------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+BOOLEAN NotChecksummed(
+    IN      EFI_CMOS_MANAGER_INTERFACE  *Mgr,
+    IN      UINT16                      CmosAddress )
+{
+    UINT16  NoChecksumIndex = 1;    // NoChecksumTable starts at 1
+
+    while ( (NoChecksumIndex < Mgr->NoChecksumCount)
+         && (CmosAddress > Mgr->NoChecksumTable[NoChecksumIndex].Index) )
+    {
+        ++NoChecksumIndex;
+    }
+
+    if ( CmosAddress == Mgr->NoChecksumTable[NoChecksumIndex].Index )
+        return TRUE;
+    else
+        return FALSE;
+}
+
+//<AMI_PHDR_START>
+//---------------------------------------------------------------------------
+//
+// Procedure: CmosBufferReadWrite
+//
+// Description:
+//      This function provides support for performing the actual
+//      read or write from/to a CMOS buffer location (using the 
+//      Optimal Defaults Table Buffer).
+//
+// Input:
+//      IN EFI_CMOS_MANAGER_INTERFACE  *Manager
+//                  -- Manager interface pointer
+//      IN CMOS_ACCESS_TYPE AccessType
+//                  -- Specifies whether to perform a read or a write
+//      IN UINT8 CmosAddress
+//                  -- Actual CMOS address/offset
+//      IN UINT8 BitsToWrite
+//                  -- Mask specifying the bits to be written (these
+//                     bits will be cleared first)
+//      IN OUT UINT8 *CmosParameterValue
+//                  -- CMOS value to be written or, on successful exit, will
+//                     contain the value that was read
+//
+// Output:
+//      EFI_STATUS (Return Value)
+//                  = EFI_SUCCESS if successful
+//                  = or other valid EFI error code
+//
+// Notes:
+//
+//      Control comes here because of one of two reasons:
+//
+//      1) The checksum is bad
+//
+//                  All writes/read are to/from the 
+//                  Manager->OptimalDefaultTable only for locations not found 
+//                  in the Manager->NoChecksumTable until DXE phase.
+//
+//      2) The battery is bad
+//
+//                  All writes/read are to/from the 
+//                  Manager->OptimalDefaultTable for all locations.
+//
+//---------------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+EFI_STATUS CmosBufferReadWrite(
+    IN      EFI_CMOS_MANAGER_INTERFACE  *Manager,
+    IN      CMOS_ACCESS_TYPE            AccessType,
+    IN      UINT16                      CmosAddress,
+    IN      UINT8                       BitsToWrite,  
+    IN OUT  UINT8                       *CmosParameterValue )
+{
+    EFI_STATUS  Status = EFI_SUCCESS;
+    UINT8       NewValue;
+    UINT16      NewChecksum = 0;
+    UINT8       CmosRegisterValue;
+    // First CMOS register @ buffer index 1
+    UINT16      BufferIndex = CmosAddress - FIRST_CMOS_REGISTER + 1; 
+    DEFINE_PEI_SERVICES(Manager->Access.PeiServices);
+
+    if (CmosAddress < FIRST_CMOS_REGISTER || CmosAddress > LAST_CMOS_REGISTER){
+        CMOS_TRACE((CMOS_TRACE_ALWAYS, 
+            "    CmosBufferReadWrite: Invalid CmosAddress (0x%X)\n", 
+            CmosAddress ));
+        return EFI_INVALID_PARAMETER;
+    }
+
+    // get the default value from the table
+    CmosRegisterValue = Manager->OptimalDefaultTable[BufferIndex].Value;
+                            
+    // If read access, simply return the unmodified data
+    if ( AccessType == ReadType ) {
+        *CmosParameterValue = CmosRegisterValue;
+        CMOS_TRACE_FULL((CMOS_TRACE_ALWAYS, 
+            "    Buffer Read: 0x%X = OptimalDefaultTable[%d].Value \n",
+            CmosRegisterValue, BufferIndex  ));
+    }
+    
+    // If writing, mark the location as dirty and don't clobber unused bits 
+    else {
+        NewValue = (CmosRegisterValue & ~BitsToWrite) | *CmosParameterValue;
+
+        // get the new checksum before writing (this sets or clears
+        // the CMOS_ADDRESS_IS_CHECKSUMMED Manager->ManagerStatus flag)
+        if (!Manager->CheckStatus(Manager, CMOS_FORCE_NO_CHECKSUM)) {
+            Status = CalculateUpdatedCheckSum( Manager, CmosAddress,
+                CmosRegisterValue, NewValue, &NewChecksum);
+        }
+
+        // Optimal default table writes take precedence
+        Manager->OptimalDefaultTable[BufferIndex].Value = NewValue;
+        CMOS_TRACE_FULL((CMOS_TRACE_ALWAYS, 
+            "    Buffer Write: OptimalDefaultTable[%d].Value = 0x%X\n",
+            BufferIndex, NewValue ));
+
+        // write the checksum, if necessary
+        // (this write will cause an infinite loop without a flag)
+        if (!Manager->CheckStatus(Manager, CMOS_FORCE_NO_CHECKSUM)){
+            if (Manager->CheckStatus(Manager, CMOS_ADDRESS_IS_CHECKSUMMED)){
+                Manager->SetStatus(Manager, CMOS_FORCE_NO_CHECKSUM);
+                WriteChecksum( Manager, NewChecksum );
+                Manager->ClearStatus(Manager, CMOS_FORCE_NO_CHECKSUM);
+                CMOS_TRACE_FULL((CMOS_TRACE_ALWAYS, 
+                    "    NewChecksum = 0x%X\n",
+                    NewChecksum ));
+            }
+        }
+    }
+
+    return EFI_SUCCESS;
+}
+
+
+//<AMI_PHDR_START>
+//---------------------------------------------------------------------------
+//
+// Procedure: CmosReadWrite
+//
+// Description:
+//      Decides which version of xxxReadWrite to call based upon the
+//      current Access Routing Logic.
+//
+// Input:
+//      IN EFI_CMOS_MANAGER_INTERFACE *Manager
+//                  -- Manager interface pointer
+//      IN CMOS_ACCESS_TYPE AccessType
+//                  -- Specifies whether to perform a read or a write
+//      IN UINT8 CmosAddress
+//                  -- Actual CMOS address/offset
+//      IN UINT8 BitsToWrite
+//                  -- Mask specifying the bits to be written (these
+//                      bits will be cleared first)
+//      IN OUT  UINT8 *CmosParameter
+//                  -- CMOS value to be written or, on successful exit, will
+//                      contain the value that was read
+//
+// Output:
+//      EFI_STATUS (Return Value)
+//                  = EFI_SUCCESS or valid EFI error code
+//
+// Notes:
+//      None
+//
+//---------------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+EFI_STATUS CmosReadWrite(
+    IN      EFI_CMOS_MANAGER_INTERFACE  *Mgr,
+    IN      CMOS_ACCESS_TYPE            AccessType,
+    IN      UINT16                      CmosAddress,
+    IN      UINT8                       BitsToWrite,  
+    IN OUT  UINT8                       *CmosParameter )
+{
+    BOOLEAN UseBufferAccess = FALSE;
+    
+    // If the checksum is bad or the battery is bad, accesses will be
+    // routed to the optimal default table by default.
+
+    if ( Mgr->CheckStatus( Mgr, CMOS_OPTIMAL_DEFAULTS_ENABLED )){
+        UseBufferAccess = TRUE;
+        
+        // Force physical access if these conditions are applicable:
+        //
+        //      1. the CMOS is usable,
+        //      2. recovery is limited to only checksummed locations
+        //      3. the current location is not checksummed
+
+        if (    Mgr->CheckStatus( Mgr, CMOS_IS_USABLE ) 
+            &&  Mgr->CheckStatus( Mgr, CMOS_RECOVER_ONLY_CHECKSUMMED )
+            &&  NotChecksummed( Mgr, CmosAddress ) )
+        {
+           UseBufferAccess = FALSE;
+        }
+    }
+
+    if (UseBufferAccess)        
+        return CmosBufferReadWrite( Mgr,
+                                    AccessType, 
+                                    CmosAddress,  
+                                    BitsToWrite,
+                                    CmosParameter);
+    else
+        return CmosPhysicalReadWrite(   Mgr,
+                                        AccessType, 
+                                        CmosAddress,  
+                                        BitsToWrite,
+                                        CmosParameter);
+}
+
+//<AMI_PHDR_START>
+//---------------------------------------------------------------------------
+//
+// Procedure: CmosReadWriteEncodedToken
+//
+// Description:
+//      This is the main worker function which verifies and either  
+//      reads/writes a value from/to the CMOS location as specified by the  
+//      encoded token.
+//
+// Input:
+//      IN      EFI_CMOS_MANAGER_INTERFACE *Manager
+//                  -- This is the CMOS Manager interface pointer.
+//      IN      CMOS_ACCESS_TYPE AccessType
+//                  -- Specifies whether to perform a read or a write
+//      IN      UINT16 TokenTableIndex
+//                  -- Index into the token table
+//      IN OUT  UINT8 *CmosParameter
+//                  -- CMOS value to be written or, on successful exit, will
+//                      contain the value that was read
+//
+// Output:
+//      EFI_STATUS (Return Value)
+//                  = EFI_SUCCESS if successful
+//                  = EFI_INVALID_PARAMETER, if the CmosParameter does
+//                      not comply with the expected size
+//                  = or other valid EFI error code
+//
+// Notes:
+//                  1) Gets the CMOS token from the global table
+//                  2) If writing, the value is error-checked for size and 
+//                      up-shifted to the correct bit position. Also, the
+//                      BitsToWrite mask is used to specify
+//                      which bits to clear in the destination before
+//                      writing.
+//                  3) This token is decoded to get the CMOS index, 
+//                  4) The read/write is performed
+//                  5) If reading, the value is down-shifted and masked to 
+//                      return the expected value.
+//
+//---------------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+EFI_STATUS CmosReadWriteEncodedToken(
+    IN      EFI_CMOS_MANAGER_INTERFACE  *Manager,
+    IN      CMOS_ACCESS_TYPE            AccessType,
+    IN      UINT16                      TokenTableIndex,
+    IN OUT  UINT8                       *CmosParameter )
+{
+    CMOS_TOKEN  *CmosToken = &Manager->TokenTable[TokenTableIndex];
+    UINT8       BitsToWrite = 0;
+    DEFINE_PEI_SERVICES(Manager->Access.PeiServices);
+    
+    // If writing, encode the CmosParameter
+
+    if (AccessType == WriteType) {
+    
+        // Check to make sure the data is the correct size for the bit field
+
+        if ( BitFieldOverflow(CmosParameter, CmosToken) ){
+            return EFI_INVALID_PARAMETER;
+        }
+
+        // Shift up to the correct offset within the byte
+
+        EncodeParameter(CmosParameter, CmosToken);
+        
+        // Set the bits in BitsToWrite mask that are 
+        // consumed by this token
+
+        SetClobberBits(&BitsToWrite, CmosToken);
+    }
+    
+    // Read (or write) the CmosParameter to actual (or CMOS buffer) location
+
+    CmosReadWrite(Manager,
+                AccessType, 
+                (UINT16)CmosToken->Value.Field.CmosAddress,  // byte address
+                BitsToWrite,
+                CmosParameter);
+    
+    // If reading, shift down to bit-position zero and mask off upper bits
+
+    if (AccessType == ReadType) 
+        DecodeParameter(CmosParameter, CmosToken);
+    
+    return EFI_SUCCESS;
+}
+
+
+//<AMI_PHDR_START>
+//---------------------------------------------------------------------------
+//
+// Procedure: CmosRead
+//
+// Description:
+//      Reads to CmosValue from the CMOS location specified by CmosToken.
+//
+// Input:
+//      IN  EFI_CMOS_ACCESS_INTERFACE *Cmos
+//                  -- This is the access interface pointer.
+//      IN  UINT16 CmosToken 
+//                  -- This is the encoded CMOS location.
+//      OUT UINT8 *CmosValue
+//                  -- On success, this will contain the value at
+//                      the specified CMOS location.
+//
+// Output:
+//      EFI_STATUS (Return Value)
+//                  = EFI_SUCCESS if successful
+//                  = EFI_NOT_FOUND, if the token is not in the token table
+//                  = or other valid EFI error code
+//
+// Notes:
+//      None
+//
+//---------------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+EFI_STATUS CmosRead(
+    IN  EFI_CMOS_ACCESS_INTERFACE   *Cmos,
+    IN  UINT16                      CmosToken,
+    OUT UINT8                       *CmosValue )
+{
+    EFI_STATUS                      Status = EFI_NOT_FOUND;
+    UINT16                          TokenTableIndex = 0;
+    EFI_CMOS_MANAGER_INTERFACE      *Mgr = GetCmosMangerInterface(Cmos);
+    DEFINE_PEI_SERVICES(Cmos->PeiServices);
+
+    // if CmosToken <= 0xe, then always read the register.  These registers
+    // will be readable regardless of the state of the battery.
+
+    if (CmosToken <= 0xe){
+        Status = CmosBankReadWrite( Mgr, ReadType, CmosToken, CmosValue );
+    }
+
+    // Otherwise, if CmosToken < MIN_TOKEN_VALUE and the battery is good, 
+    // then directly  read the register. (For a bad battery, return 
+    // EFI_DEVICE_ERROR.)
+
+    else if (CmosToken < MIN_TOKEN_VALUE) {
+        if ( !Mgr->CheckStatus( Mgr, CMOS_IS_USABLE ) ) {
+            Status = EFI_DEVICE_ERROR;
+        }
+        else {
+            Status = CmosBankReadWrite( Mgr, ReadType, CmosToken, CmosValue );
+        }
+    }
+
+    // Otherwise, after validating the CmosToken, decode it to read the  
+    // associated register bit(s).
+
+    else {
+        TokenTableIndex = CmosFindToken(Mgr, CmosToken);
+        if (TokenTableIndex > 0) {
+            Status = CmosReadWriteEncodedToken( Mgr, ReadType, 
+                                                TokenTableIndex, CmosValue);
+        }
+        else
+            Status = EFI_INVALID_PARAMETER;
+    }
+    
+    return Status;
+}
+
+
+//<AMI_PHDR_START>
+//---------------------------------------------------------------------------
+//
+// Procedure: ReadCmosBytes
+//
+// Description:
+//      Reads Bytes from the specified CMOS register(s).
+//
+// Input:
+//      IN  EFI_CMOS_MANAGER_INTERFACE *Manager
+//                  -- Manger interface pointer.
+//      IN UINT8 Count
+//                  -- Count of CMOS_BYTEs to read
+//      OUT CMOS_BYTE *Bytes
+//                  -- An array of CMOS_BYTE structures
+//
+// Output:
+//      EFI_STATUS (Return Value)
+//                  = EFI_SUCCESS or valid EFI error code
+//
+// Notes:
+//      None
+//
+//---------------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+EFI_STATUS ReadCmosBytes(
+    IN  EFI_CMOS_MANAGER_INTERFACE  *Manager,
+    IN  UINT16                      Count,
+    OUT CMOS_BYTE                   *CmosBytes )
+{
+    EFI_STATUS                      Status = EFI_SUCCESS;
+    UINT16                          i = 0;
+    DEFINE_PEI_SERVICES(Manager->Access.PeiServices);
+
+
+    for (; i < Count; i++){
+        Status = CmosReadWrite(Manager, ReadType, CmosBytes[i].Register, 0, 
+                                         &CmosBytes[i].Value);
+    }
+
+    return EFI_SUCCESS;
+}
+
+//<AMI_PHDR_START>
+//---------------------------------------------------------------------------
+//
+// Procedure: ReadCmosStatusBytes
+//
+// Description:
+//      Initializes a CMOS_STATUS_BYTES structure and reads the associated
+//      CMOS registers.
+//
+// Input:
+//      IN  EFI_CMOS_ACCESS_INTERFACE *Cmos
+//                  --  Manger interface pointer.
+//      OUT CMOS_STATUS_BYTES *StatusBytes
+//                  --  Address of a valid, uninitialized, CMOS_STATUS_BYTES 
+//                      structure.
+//
+// Output:
+//      EFI_STATUS (Return Value)
+//                  = EFI_SUCCESS or valid EFI error code
+//
+// Notes:
+//
+//---------------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+EFI_STATUS ReadCmosStatusBytes(
+    IN  EFI_CMOS_ACCESS_INTERFACE   *Cmos,
+    OUT CMOS_STATUS_BYTES           *StatusBytes )
+{
+    EFI_STATUS                  Status = EFI_SUCCESS;
+    EFI_CMOS_MANAGER_INTERFACE  *Mgr = GetCmosMangerInterface(Cmos);
+    UINT8                       CmosValue;
+    DEFINE_PEI_SERVICES(Mgr->Access.PeiServices);
+
+    if (StatusBytes == NULL)
+        return Status = EFI_INVALID_PARAMETER;
+    
+    StatusBytes->DiagnosticStatusRegister = CMOS_DIAGNOSTIC_STATUS_REGISTER;
+    StatusBytes->BatteryStatusRegister = CMOS_RTC_STATUS_REGISTER;
+    
+    CmosPhysicalReadWrite(  Mgr, 
+                            ReadType, 
+                            StatusBytes->BatteryStatusRegister,
+                            0, 
+                            &StatusBytes->Battery.AllBits );
+                                    
+    CmosPhysicalReadWrite(  Mgr, 
+                            ReadType, 
+                            StatusBytes->DiagnosticStatusRegister,
+                            0, 
+                            &StatusBytes->Diagnostic.AllBits );
+                            
+    if ( Mgr->CheckStatus(Mgr, CMOS_OPTIMAL_DEFAULTS_ENABLED) )
+        StatusBytes->ConfigurationStatus.IsVirtualized = TRUE;
+    else
+        StatusBytes->ConfigurationStatus.IsVirtualized = FALSE;
+
+    // If the CMOS hardware is usable, update from cmos-based
+    // status bits, which are more reliable.  Otherwise, use the 
+    // the memory-based status.
+    //
+    // Note, some information could be lost on reset in DXE 
+    // when using the memory-based status.
+    //
+    // Also, register 0xe is cleared in DXE, if the CMOS
+    // is usable and the checksum has been recalculated.
+
+    StatusBytes->ConfigurationStatus.BadBattery = FALSE;
+    StatusBytes->ConfigurationStatus.DefaultsLoaded = FALSE;
+    StatusBytes->ConfigurationStatus.IsFirstBoot = FALSE;
+    StatusBytes->ConfigurationStatus.BadChecksum = FALSE;
+
+    if ( Mgr->CheckStatus(Mgr, CMOS_IS_USABLE) ) {
+        StatusBytes->ConfigurationStatus.NotUsable = FALSE;
+
+        Cmos->Read( Cmos, CMOS_MGR_BATTERY_BAD, &CmosValue ); 
+        StatusBytes->ConfigurationStatus.BadBattery |= CmosValue;
+
+        Cmos->Read( Cmos, CMOS_MGR_DEFAULTS_LOADED, &CmosValue ); 
+        StatusBytes->ConfigurationStatus.DefaultsLoaded |= CmosValue;
+
+        Cmos->Read( Cmos, CMOS_MGR_FIRST_BOOT_DETECTED, &CmosValue ); 
+        StatusBytes->ConfigurationStatus.IsFirstBoot |= CmosValue;
+
+        Cmos->Read( Cmos, CMOS_MGR_CHECKSUM_BAD,&CmosValue ); 
+        StatusBytes->ConfigurationStatus.BadChecksum |= CmosValue;
+    }
+    else {
+        StatusBytes->ConfigurationStatus.NotUsable = TRUE;
+        if ( Mgr->CheckStatus(Mgr, CMOS_BAD_BATTERY) )
+            StatusBytes->ConfigurationStatus.BadBattery = TRUE;
+        if ( Mgr->CheckStatus(Mgr, CMOS_DEFAULTS_LOADED) )
+            StatusBytes->ConfigurationStatus.DefaultsLoaded = TRUE;
+        if ( Mgr->CheckStatus(Mgr, CMOS_FIRST_BOOT_DETECTED) )
+            StatusBytes->ConfigurationStatus.IsFirstBoot = TRUE;
+        if ( Mgr->CheckStatus(Mgr, CMOS_BAD_CHECKSUM) )
+            StatusBytes->ConfigurationStatus.BadChecksum = TRUE;
+    }
+
+
+    return Status;
+}
+
+
+//<AMI_PHDR_START>
+//---------------------------------------------------------------------------
+//
+// Procedure: ReadChecksum
+//
+// Description:
+//      Reads the checksum from the CMOS register(s).
+//
+// Input:
+//      IN  EFI_CMOS_MANAGER_INTERFACE *Manager
+//                  -- Manger interface pointer.
+//      OUT UINT16 *ChecksumValue
+//                  -- The returned checksum value
+//
+// Output:
+//      EFI_STATUS (Return Value)
+//                  = EFI_SUCCESS or valid EFI error code
+//
+// Notes:
+//      None
+//
+//---------------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+EFI_STATUS ReadChecksum(
+    IN  EFI_CMOS_MANAGER_INTERFACE  *Manager,
+    OUT UINT16                      *ChecksumValue )
+{
+    DEFINE_PEI_SERVICES(Manager->Access.PeiServices);
+
+    Manager->Access.Read( &Manager->Access, CMOS_CHECKSUM_HIGH, 
+        (UINT8*)ChecksumValue );
+    *ChecksumValue <<= 8;
+    Manager->Access.Read( &Manager->Access, CMOS_CHECKSUM_LOW, 
+        (UINT8*)ChecksumValue );
+
+    return EFI_SUCCESS;
+}
+
+//<AMI_PHDR_START>
+//---------------------------------------------------------------------------
+//
+// Procedure: WriteChecksum
+//
+// Description:
+//      Write the checksum to the CMOS register(s).
+//
+// Input:
+//      IN EFI_CMOS_MANAGER_INTERFACE *Manager
+//                  -- Manger interface pointer.
+//      IN UINT16 ChecksumValue
+//                  -- Value to write to the checksum location.
+//
+// Output:
+//      EFI_STATUS (Return Value)
+//                  = EFI_SUCCESS or valid EFI error code
+//
+// Notes:
+//      None
+//
+//---------------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+EFI_STATUS WriteChecksum(
+    IN  EFI_CMOS_MANAGER_INTERFACE  *Manager,
+    IN  UINT16                      ChecksumValue )
+{
+    DEFINE_PEI_SERVICES(Manager->Access.PeiServices);
+
+    // update the HOB if available
+
+    if (Manager->ManagerHob != NULL)
+        Manager->ManagerHob->Checksum = ChecksumValue;
+
+        
+    CMOS_TRACE_FULL((CMOS_TRACE_ALWAYS, "WriteChecksum: Value = 0x%X\n",
+        ChecksumValue ));
+
+    // update the CMOS checksum
+
+    Manager->SetStatus(Manager, CMOS_FORCE_NO_CHECKSUM);
+    Manager->Access.Write( &Manager->Access, CMOS_CHECKSUM_LOW, 
+        (UINT8)ChecksumValue );
+    ChecksumValue >>= 8;
+    Manager->Access.Write( &Manager->Access, CMOS_CHECKSUM_HIGH, 
+        (UINT8)ChecksumValue );
+    Manager->ClearStatus(Manager, CMOS_FORCE_NO_CHECKSUM);
+
+    
+    return EFI_SUCCESS;
+}
+
+
+//<AMI_PHDR_START>
+//---------------------------------------------------------------------------
+//
+// Procedure: UpdateBatteryStatus
+//
+// Description:
+//      This function is used to update the CMOS battery status.  It is up
+//      to the user of the Manager interface to determine whether or ot
+//      the platform supports this feature.  (If the platform does not 
+//      support this feature, the battery status is indeterminate.)
+//
+// Input:
+//      IN EFI_CMOS_MANAGER_INTERFACE *Manager
+//                  -- Pointer to the Manager's interface
+//
+// Output:
+//      EFI_STATUS (Return value)
+//                  = EFI_SUCCESS or valid EFI error code
+//
+// Notes:
+//
+//---------------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+
+EFI_STATUS UpdateBatteryStatus (
+    IN EFI_CMOS_MANAGER_INTERFACE   *Mgr )
+{
+    EFI_STATUS          Status = EFI_SUCCESS;
+    BOOLEAN             IsGood;
+    DEFINE_PEI_SERVICES(Mgr->Access.PeiServices);
+
+    CMOS_TRACE_FULL(( CMOS_TRACE_ALWAYS, "\n\nUpdateBatteryStatus Entry\n"));
+    
+    // Update the battery status bit in the Manager's CMOS_MANAGER_STATUS
+    // field and update the legacy CMOS status register if legacy register
+    // updates are enabled.
+
+#ifdef PEI_COMPILE
+    IsGood = gCmosBatteryIsGood( PeiServices );
+#else
+    IsGood = gCmosBatteryIsGood( NULL );
+#endif
+
+    if ( IsGood ) {
+        Mgr->ClearStatus(Mgr, CMOS_BAD_BATTERY); 
+        CMOS_TRACE_FULL(( CMOS_TRACE_ALWAYS, "    ...Battery is good.\n" ));
+    }
+    else {
+        Mgr->SetStatus(Mgr, CMOS_BAD_BATTERY); 
+        CMOS_TRACE_FULL(( CMOS_TRACE_ALWAYS, "    ...Battery is BAD!!\n" ));
+    }
+
+    return Status;
+}
+
+
+//<AMI_PHDR_START>
+//---------------------------------------------------------------------------
+//
+// Procedure: CanClearLegacyStatusBits
+//
+// Description:
+//      Determines whether or not the legacy status bits in 
+//      CMOS_DIAGNOSTIC_STATUS_REGISTER can be cleared to a non-failure
+//      status.
+//
+// Input:
+//      IN EFI_CMOS_MANAGER_INTERFACE *Mgr
+//                  -- Manger interface pointer
+//
+// Output:
+//      BOOLEAN (Return Value)
+//                  = TRUE - bits can be cleared
+//                  = FALSE - bits can be cleared
+//
+// Notes:
+//
+//  EFI_CMOS_ACCESS_INTERFACE.PeiServices == NULL in DXE phase.
+//
+//---------------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+BOOLEAN CanClearLegacyStatusBits (
+    IN      EFI_CMOS_MANAGER_INTERFACE  *Mgr )
+{
+    BOOLEAN  IsDxePhase = (Mgr->Access.PeiServices == NULL) ? TRUE : FALSE;
+    BOOLEAN  IsFirstBoot = Mgr->CheckStatus(Mgr, CMOS_FIRST_BOOT_DETECTED);
+
+    if ( IsDxePhase  ){
+        return TRUE;
+    } 
+    else {
+        return FALSE;
+    }
+}
+
+
+//<AMI_PHDR_START>
+//---------------------------------------------------------------------------
+//
+// Procedure: SynchronizeLegacyStatusRegisters
+//
+// Description:
+//      Synchronizes legacy CMOS status registers with status changes.
+//
+// Input:
+//      IN EFI_CMOS_MANAGER_INTERFACE *Manager
+//                  -- Manger interface pointer
+//      IN CMOS_MANAGER_STATUS BitMap
+//                  -- The status bits to be modified
+//      IN CMOS_BIT_ACCESS_TYPE AccessType
+//                  -- Specifies whether to set or clear the bits
+//
+// Output:
+//      EFI_STATUS (Return Value)
+//                  = EFI_SUCCESS or valid EFI error code
+//
+// Notes:
+//      The BitMap contains all the bits to be modified in the legacy
+//      status registers.
+//
+//      If CMOS_LEGACY_STATUS_ENABLED is off, or is being turned off, this 
+//      function will not modify CMOS registers.
+//
+//      Failure status bits in CMOS_DIAGNOSTIC_STATUS_REGISTER can only be 
+//      cleared if this is the first boot or if executing in the DXE phase.
+//
+//---------------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+EFI_STATUS SynchronizeLegacyStatusRegisters(
+    IN  EFI_CMOS_MANAGER_INTERFACE  *Mgr,
+    IN CMOS_MANAGER_STATUS          BitMap,
+    IN CMOS_BIT_ACCESS_TYPE         AccessType )
+{
+    DIAGNOSTIC_STATUS_BYTE  StatusByte;
+    DEFINE_PEI_SERVICES(Mgr->Access.PeiServices);
+
+    CMOS_TRACE_FULL((CMOS_TRACE_ALWAYS, 
+        "\n\nSynchronizeLegacyStatusRegisters: Entry\n" ));
+
+    // If the checksum status is being modified, 
+    // then update the ChecksumIsBad bit
+    
+    if ( (BitMap & CMOS_BAD_CHECKSUM) != 0 )
+    {
+        // Read the legacy diagnostic status register
+
+        CmosBankReadWrite(  Mgr, ReadType, CMOS_DIAGNOSTIC_STATUS_REGISTER, 
+                            &StatusByte.AllBits );
+
+        if (AccessType == SetType){
+            CMOS_TRACE_FULL((CMOS_TRACE_ALWAYS, 
+                "  StatusByte.Field.ChecksumIsBad = 1\n" ));
+            StatusByte.Field.ChecksumIsBad = 1;
+        } 
+        else if ( CanClearLegacyStatusBits(Mgr) ) {
+            CMOS_TRACE_FULL((CMOS_TRACE_ALWAYS, 
+                "  StatusByte.Field.ChecksumIsBad = 0\n" ));
+            StatusByte.Field.ChecksumIsBad = 0;
+        }
+        else {
+            CMOS_TRACE_FULL((CMOS_TRACE_ALWAYS, 
+                "  StatusByte.Field.ChecksumIsBad = No Change\n" ));
+        }
+
+        // write back the changes
+
+        CmosBankReadWrite(  Mgr, WriteType, CMOS_DIAGNOSTIC_STATUS_REGISTER, 
+                            &StatusByte.AllBits );
+    }   
+    else {
+        CMOS_TRACE_FULL((CMOS_TRACE_ALWAYS, 
+            "  StatusByte.Field.ChecksumIsBad = No Change\n" ));
+    }         
+    
+    
+
+    // If the battery status is being modified, 
+    // then update the RtcPowerIsBad bit
+    
+    if (  (BitMap & CMOS_BAD_BATTERY) != 0 )
+    {
+        // Read the legacy diagnostic status register
+
+        CmosBankReadWrite(  Mgr, ReadType, CMOS_DIAGNOSTIC_STATUS_REGISTER, 
+                            &StatusByte.AllBits );
+
+        if (AccessType == SetType){
+            CMOS_TRACE_FULL((CMOS_TRACE_ALWAYS, 
+                "  StatusByte.Field.RtcPowerIsBad = 1\n" ));
+            StatusByte.Field.RtcPowerIsBad = 1;
+        } 
+        else if ( CanClearLegacyStatusBits(Mgr) ) {
+            StatusByte.Field.RtcPowerIsBad = 0;
+            CMOS_TRACE_FULL((CMOS_TRACE_ALWAYS, 
+                "  StatusByte.Field.RtcPowerIsBad = 0\n" ));
+        }
+
+        // Write the legacy diagnostic status register
+
+        CmosBankReadWrite(  Mgr, WriteType, CMOS_DIAGNOSTIC_STATUS_REGISTER, 
+                            &StatusByte.AllBits );
+    }
+    else {
+        CMOS_TRACE_FULL((CMOS_TRACE_ALWAYS, 
+            "  StatusByte.Field.RtcPowerIsBad = No Change\n" ));
+    }
+
+    CMOS_TRACE_FULL((CMOS_TRACE_ALWAYS, 
+        "SynchronizeLegacyStatusRegisters: Exit\n\n" ));
+                  
+    return EFI_SUCCESS;
+                  
+}
+
+
+//<AMI_PHDR_START>
+//---------------------------------------------------------------------------
+//
+// Procedure: CalculateUpdatedCheckSum
+//
+// Description:
+//      Computes a new "updated" CMOS checksum based on the change of value
+//      at a single address.
+//
+// Input:
+//      IN EFI_CMOS_MANAGER_INTERFACE  *Manager
+//                  -- The Manger interface pointer.
+//      IN UINT16 CmosAddress
+//                  -- CMOS location to be changed
+//      IN UINT8 OldCmosValue
+//                  -- Current value at the CMOS location
+//      IN UINT8 NewCmosValue
+//                  -- New value to be written to the CMOS location
+//      OUT UINT16 *NewChecksum 
+//                  -- Updated checksum
+//
+// Output:
+//      EFI_STATUS (Return Value)
+//                  = EFI_SUCCESS or a valid EFI error code
+//
+// Notes:
+//      After this call, Manager->CheckStatus(Manager, 
+//      CMOS_ADDRESS_IS_CHECKSUMMED) returns TRUE if the address "is" 
+//      included in the checksum.
+//
+//---------------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+EFI_STATUS CalculateUpdatedCheckSum(
+    IN  EFI_CMOS_MANAGER_INTERFACE  *Mgr,
+    IN  UINT16                      CmosAddress,
+    IN  UINT8                       OldCmosValue,
+    IN  UINT8                       NewCmosValue,
+    OUT UINT16                      *NewChecksum )
+{
+    UINT16  UnmanagedIndex = 1;  // UnmanagedTable starts at 1
+    UINT16  NoChecksumIndex = 1; // NoChecksumTable starts at 1
+    DEFINE_PEI_SERVICES(Mgr->Access.PeiServices);
+
+    // Check if the address is included in the NoChecksumTable 
+    // or the UnmanagedTable
+
+    while ( NoChecksumIndex < Mgr->NoChecksumCount )
+    {
+        if ( CmosAddress <= Mgr->NoChecksumTable[NoChecksumIndex].Index )
+            break;
+        ++NoChecksumIndex;
+    }
+
+    while ( UnmanagedIndex < Mgr->UnmanagedTableCount )
+    {
+        if ( CmosAddress <= Mgr->UnmanagedTable[UnmanagedIndex].Index )
+            break;
+        ++UnmanagedIndex;
+    }
+
+    
+    // Set ManagerStatus and compute NewChecksum if necessary 
+
+    if (    CmosAddress == Mgr->NoChecksumTable[NoChecksumIndex].Index 
+         || CmosAddress == Mgr->UnmanagedTable[UnmanagedIndex].Index     )
+    {
+#if (FULL_CMOS_MANAGER_DEBUG)
+        if ( CmosAddress == Mgr->NoChecksumTable[NoChecksumIndex].Index ) {
+            CMOS_TRACE((CMOS_TRACE_ALWAYS, "    ->Not Checksummed (0x%X)\n", CmosAddress ));
+        }
+        else {
+            CMOS_TRACE((CMOS_TRACE_ALWAYS, "    ->Not Managed (0x%X)\n", CmosAddress ));
+        }
+#endif
+        Mgr->ClearStatus(Mgr, CMOS_ADDRESS_IS_CHECKSUMMED);
+    }
+    else {
+        ReadChecksum( Mgr, NewChecksum );
+        *NewChecksum = *NewChecksum - OldCmosValue + NewCmosValue;
+        Mgr->SetStatus(Mgr, CMOS_ADDRESS_IS_CHECKSUMMED);
+    }
+    
+    return EFI_SUCCESS;
+}
+
+
+
+//<AMI_PHDR_START>
+//---------------------------------------------------------------------------
+//
+// Procedure: CalculateChecksum
+//
+// Description:
+//      Calculate the checksum over the entire range of managed CMOS
+//      (standard and/or extended CMOS).
+//
+// Input:
+//      IN EFI_CMOS_MANAGER_INTERFACE *Manager
+//                  -- The Manger interface pointer.
+//      OUT UINT16 *ChecksumValue 
+//                  -- The calculated checksum.
+//
+// Output:
+//      EFI_STATUS (Return Value)
+//                  = EFI_SUCCESS or valid EFI error code
+//
+// Modified:
+//      Manager->ManagerStatus
+//                  CMOS_BAD_CHECKSUM - set/clear after comparing with
+//                                      the current checksum in CMOS.
+//
+//---------------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+EFI_STATUS CalculateChecksum(
+    IN  EFI_CMOS_MANAGER_INTERFACE  *Mgr,
+    OUT UINT16                      *ChecksumValue )
+{
+    //-----------------------------------------------------------------------
+    // Algorithm Notes:
+    //
+    //  The NoChecksumTable is in numeric order and contains all CMOS
+    //  registers starting at FIRST_CMOS_REGISTER and ending with
+    //  LAST_CMOS_REGISTER unless the register has been explicitly specified
+    //  with Checksum = YES in the NvramField declaration.
+    //
+    //  ...the NoChecksumTable need traversed only once.
+    //-----------------------------------------------------------------------
+
+    UINT16  CurRegister;
+    UINT8   CurValue;
+    UINT16  UnmanagedIndex = 1;  // UnmanagedTable starts at 1
+    UINT16  NoChecksumIndex = 1; // NoChecksumTable starts at 1
+    UINT16  CurrentChecksum;
+    DEFINE_PEI_SERVICES(Mgr->Access.PeiServices);
+
+    *ChecksumValue = 0; // ...just in case
+    CMOS_TRACE_FULL((CMOS_TRACE_ALWAYS, "\n\nCalculateChecksum: Entry\n" ));
+    
+    // Calculate it
+    for ( CurRegister = Mgr->FirstManagedRegister; 
+          CurRegister <= Mgr->LastManagedRegister;   // inclusive
+          ++CurRegister ) 
+    {
+        //---------------------------------------------
+        // Skip the location if the location is not managed
+        //
+        // Note: the UnmanagedTable is in numeric order, 
+        //       so it only needs traversed one time.
+        //---------------------------------------------
+        
+        while ( (UnmanagedIndex < Mgr->UnmanagedTableCount)
+                && (CurRegister 
+                    > Mgr->UnmanagedTable[UnmanagedIndex].Index) )
+        {
+            ++UnmanagedIndex;
+        }
+        if ( CurRegister == Mgr->UnmanagedTable[UnmanagedIndex].Index ){
+            CMOS_TRACE_FULL((CMOS_TRACE_ALWAYS, 
+                "    -->0x%X (un-managed)\n", CurRegister));
+            continue;
+        }
+
+
+        while ( (NoChecksumIndex < Mgr->NoChecksumCount)
+                && (CurRegister 
+                        > Mgr->NoChecksumTable[NoChecksumIndex].Index) )
+        {
+            ++NoChecksumIndex;
+        }
+            
+
+        if ( (CurRegister != 
+                Mgr->NoChecksumTable[NoChecksumIndex].Index ) )
+        {
+            CmosReadWrite(Mgr, ReadType, CurRegister, 0, 
+                &CurValue);
+            *ChecksumValue += CurValue; // update the output parameter
+        }
+    }
+    CMOS_TRACE_FULL((CMOS_TRACE_ALWAYS, 
+        "\n         --------------------------------\n"));
+    CMOS_TRACE_FULL((CMOS_TRACE_ALWAYS,   
+        "         Computed *ChecksumValue = 0x%04X\n\n",
+        *ChecksumValue ));
+    
+    // Compare with physical CMOS checksum value and set/clear status bit 
+
+    ReadChecksum( Mgr, &CurrentChecksum);
+
+    CMOS_TRACE_FULL((CMOS_TRACE_ALWAYS, 
+        "\n         -----------------------\n"));
+    CMOS_TRACE_FULL((CMOS_TRACE_ALWAYS,   
+        "         Saved Checksum = 0x%04X\n\n",
+        CurrentChecksum ));
+        
+    if (*ChecksumValue != CurrentChecksum) {
+        Mgr->SetStatus(Mgr, CMOS_BAD_CHECKSUM);
+        CMOS_TRACE((CMOS_TRACE_ALWAYS, "    ...CMOS_BAD_CHECKSUM\n"));
+    }
+    else {
+        Mgr->ClearStatus(Mgr, CMOS_BAD_CHECKSUM);
+        CMOS_TRACE_FULL((CMOS_TRACE_ALWAYS, "    ...Checksum is OK\n" ));
+    }
+
+    CMOS_TRACE_FULL((CMOS_TRACE_ALWAYS, "CalculateChecksum: Done\n" ));
+    
+    return EFI_SUCCESS;
+}
+
+
+//<AMI_PHDR_START>
+//---------------------------------------------------------------------------
+//
+// Procedure: CmosWrite
+//
+// Description: 
+//      Writes from CmosValue to CMOS location encoded into CmosToken.
+//
+// Input:
+//      IN  EFI_CMOS_ACCESS_INTERFACE *Cmos
+//                  -- This is the access interface pointer.
+//      IN  UINT16 CmosToken 
+//                  -- This is the encoded CMOS location.
+//      IN  UINT8 CmosValue
+//                  -- On success, this value will be written to
+//                      the specified CMOS location.
+//
+// Output:
+//      EFI_STATUS (Return Value)
+//                  = EFI_SUCCESS if successful
+//                  = EFI_NOT_FOUND, if the token is not in the token table
+//                  = or other valid EFI error code
+//
+// Notes:
+//      None
+//
+//---------------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+EFI_STATUS CmosWrite(
+    IN  EFI_CMOS_ACCESS_INTERFACE   *Cmos,
+    IN  UINT16                      CmosToken,
+    IN  UINT8                       CmosValue )
+{
+    EFI_STATUS                      Status = EFI_SUCCESS;
+    UINT16                          TokenTableIndex = 0;
+    EFI_CMOS_MANAGER_INTERFACE      *Mgr = GetCmosMangerInterface(Cmos);
+    DEFINE_PEI_SERVICES(Cmos->PeiServices);
+
+
+    // if CmosToken <= 0xe, then always write the register.  These registers
+    // will be writable regardless of the state of the battery.
+
+    if (CmosToken <= 0xe){
+        Status = CmosBankReadWrite( Mgr, WriteType, CmosToken, &CmosValue );
+    }
+
+    // Otherwise, if CmosToken is less than MIN_TOKEN_VALUE and the battery 
+    // is good, then an additional test is made to disallow writing of actual 
+    // registers if they are within the managed region.  Otherwise, the 
+    // actual physical register is written. (For a bad battery, return 
+    // EFI_DEVICE_ERROR when trying to write the physical register.)
+    
+    else if ( CmosToken < MIN_TOKEN_VALUE ){
+        if ( !Mgr->CheckStatus( Mgr, CMOS_IS_USABLE ) ) {
+            Status = EFI_DEVICE_ERROR;
+        }
+        else if ( (CmosToken >= FIRST_MANAGED_CMOS_ADDRESS)
+             && (CmosToken < MAX_MANAGED_CMOS_ADDRESS) )
+            Status = EFI_INVALID_PARAMETER;
+        else
+            Status = CmosBankReadWrite( Mgr, WriteType,
+                                        CmosToken, &CmosValue );
+    }
+
+    // Otherwise, after validating the CmosToken, decode it to write the  
+    // associated register bit(s).
+
+    else if ((TokenTableIndex = CmosFindToken( Mgr, CmosToken )) > 0) {
+        Status = CmosReadWriteEncodedToken( Mgr, WriteType, TokenTableIndex,
+                                            &CmosValue );
+    }
+    else
+        Status = EFI_INVALID_PARAMETER;
+
+    return Status;
+}
+
+
+//<AMI_PHDR_START>
+//---------------------------------------------------------------------------
+//
+// Procedure: LoadOptimalDefaults
+//
+// Description:
+//      Initialize all physical CMOS registers with the default values 
+//      specified in NvramField's Default value.
+//
+// Input:
+//      IN  EFI_CMOS_MANAGER_INTERFACE *Manager
+//                  -- The Manger interface pointer.
+//
+// Output:
+//      EFI_STATUS (Return Value)
+//                  = EFI_SUCCESS or valid EFI error code
+//
+// Modified:
+//      Manager->ManagerStatus bits:
+//                         CMOS_BAD_CHECKSUM - cleared on success
+//               CMOS_ERROR_LOADING_DEFAULTS - set on error
+//
+// Notes:
+//      LoadOptimalDefaults will be called for one of two reasons:
+//
+//      1) On the first boot after flashing the ROM, the default
+//         values will be written to all CMOS registers, regardless
+//         of whether or not they are listed in the NoChecksumTable.
+//
+//      2) If a bad checksum is reported in PEI, the 
+//         OptimalDefaultTable will be used as a read/write buffer
+//         until DXE, where (by default) the CMOS_BAD_CHECKSUM status bit will
+//         signal to write the buffer to physical CMOS.
+//
+//      * The optimal defaults buffer may be modified from the original
+//        version if CMOS_OPTIMAL_DEFAULTS_ENABLED status bit is set. 
+//
+//      * If the CMOS_BAD_CHECKSUM status is set, then only those values
+//        included in the checksum are written to physical CMOS.
+//
+//---------------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+EFI_STATUS LoadOptimalDefaults(
+    IN  EFI_CMOS_MANAGER_INTERFACE  *Mgr )
+{
+    EFI_STATUS  Status = EFI_SUCCESS;
+    UINT16      CurRegister;
+    UINT8       CurValue;
+    UINT16      NewChecksum = 0;
+    UINT16      UnmanagedIndex = 1;     // UnmanagedTable starts at 1
+    UINT16      DefaultIndex = 1;       // OptimalDefaultTable starts at 1
+    UINT16      NoChecksumIndex = 1;    // NoChecksumTable starts at 1
+    CMOS_MANAGER_STATUS  SavedStatus = Mgr->ManagerStatus & 
+                                    (CMOS_OPTIMAL_DEFAULTS_ENABLED );
+    EFI_CMOS_ACCESS_INTERFACE   *Cmos = Mgr->GetAccessInterface(Mgr);
+    DEFINE_PEI_SERVICES(Mgr->Access.PeiServices);
+
+    CMOS_TRACE_FULL((CMOS_TRACE_ALWAYS, "LoadOptimalDefaults Entry\n"));
+
+    // Calculate it
+    //-----------------------------------------------------------------------
+    // Configure to ensure reads/writes are to physical registers.
+    //-----------------------------------------------------------------------
+
+    Mgr->ClearStatus(Mgr, CMOS_OPTIMAL_DEFAULTS_ENABLED );
+        
+    // temporarily disallow checksum updating
+
+    Mgr->SetStatus(Mgr, CMOS_FORCE_NO_CHECKSUM);
+
+
+    //---------------------------------------------
+    // For the first boot, ignore the bad checksum
+    // so that defaults are loaded for all 
+    // registers.
+    //---------------------------------------------
+
+    if ( Mgr->CheckStatus( Mgr, CMOS_FIRST_BOOT_DETECTED ) ){
+        Mgr->ClearStatus(Mgr, CMOS_BAD_CHECKSUM);
+    }
+
+    //-----------------------------------------------------------------------
+    // Write the physical registers:
+    //
+    // There "should" be exactly one default entry for each register in the  
+    // managed region. (This is not assumed to be true.)
+    //-----------------------------------------------------------------------
+
+    for ( CurRegister = Mgr->FirstManagedRegister; 
+          CurRegister <= Mgr->LastManagedRegister;   // inclusive
+          ++CurRegister, ++DefaultIndex ) 
+    {
+        if ( DefaultIndex >= Mgr->OptimalDefaultCount){ // bad news!
+            Mgr->SetStatus(Mgr, CMOS_ERROR_LOADING_DEFAULTS);
+            break;  
+        }
+
+        //---------------------------------------------
+        // Skip the location if the location is not managed
+        //
+        // Note: the UnmanagedTable is in numeric order, 
+        //       so it only needs traversed one time.
+        //---------------------------------------------
+        
+        while ( (UnmanagedIndex < Mgr->UnmanagedTableCount)
+                && (CurRegister 
+                    > Mgr->UnmanagedTable[UnmanagedIndex].Index) )
+        {
+            ++UnmanagedIndex;
+        }
+        if ( CurRegister == Mgr->UnmanagedTable[UnmanagedIndex].Index ){
+
+            // Ensure DefaultIndex is not incremented at the top of the 
+            // loop, as un-managed locations do not have a default value.
+
+            CMOS_TRACE_FULL((CMOS_TRACE_ALWAYS, 
+                "    -->Skip 0x%X (un-managed)\n", 
+                CurRegister));
+            --DefaultIndex;
+            continue;
+        }
+
+
+        //---------------------------------------------
+        // Skip location if:
+        //
+        //    1. there is a bad checksum,
+        //    2. recovery is enabled only for checksummed locations
+        //
+        // (Note, the NoChecksumTable is in numeric order)
+        //---------------------------------------------
+        
+        if ( Mgr->CheckStatus( Mgr, 
+                CMOS_BAD_CHECKSUM + CMOS_RECOVER_ONLY_CHECKSUMMED ) )
+        {
+            while ( (NoChecksumIndex < Mgr->NoChecksumCount)
+                && (CurRegister 
+                    > Mgr->NoChecksumTable[NoChecksumIndex].Index) )
+            {
+                ++NoChecksumIndex;
+            } 
+            if ( (CurRegister 
+                    == Mgr->NoChecksumTable[NoChecksumIndex].Index ) ){
+                CMOS_TRACE_FULL((CMOS_TRACE_ALWAYS, 
+                    "    -->Skip 0x%X (not checksummed)\n",
+                    CurRegister));
+                continue;
+            }
+        }
+        
+        // Update the physical register
+
+        CurValue = Mgr->OptimalDefaultTable[DefaultIndex].Value;
+        Status = CmosReadWrite(Mgr, WriteType, CurRegister, ALL_BITS, 
+                                &CurValue);
+
+        if (EFI_ERROR(Status)){
+            CMOS_TRACE((CMOS_TRACE_ALWAYS, 
+                "    Unable to load default for register: 0x%X\n",
+                CurRegister ));
+             break;
+        } 
+      
+
+    }
+
+    // if no error, calculate checksum and reset the 
+    // CMOS_BAD_CHECKSUM status bit.
+
+    if (   EFI_ERROR(Status) 
+        || Mgr->CheckStatus(Mgr, CMOS_ERROR_LOADING_DEFAULTS))
+    {
+        CMOS_TRACE((CMOS_TRACE_ALWAYS, 
+            "    Error: Could not load Optimal Defaults\n"));
+        Status = EFI_UNSUPPORTED;
+    }
+    else
+    {
+        CalculateChecksum(Mgr, &NewChecksum);
+        WriteChecksum(Mgr, NewChecksum); 
+        Mgr->ClearStatus(Mgr, CMOS_BAD_CHECKSUM);
+    }
+
+    //-----------------------------------------------------------------------
+    // Restore previous access routing settings. 
+    //-----------------------------------------------------------------------
+
+    Mgr->ManagerStatus = Mgr->ManagerStatus | SavedStatus;
+    
+    // Allow checksums to be computed now
+
+    Mgr->ClearStatus(Mgr, CMOS_FORCE_NO_CHECKSUM);
+    
+    // Set status bit to indicate that defaults have been loaded
+
+    Mgr->SetStatus(Mgr, CMOS_DEFAULTS_LOADED);
+
+    CMOS_TRACE_FULL((CMOS_TRACE_ALWAYS, "LoadOptimalDefaults Exit\n"));
+
+    return Status;
+}
+
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------------
+// Procedure:   StopTime
+//
+// Description: Stops the time on RTC clock.
+//
+// Input:       
+//      IN EFI_CMOS_MANAGER_INTERFACE *Mgr
+//                  -- The Manger interface pointer.
+//
+// Output:      None
+//
+// Notes:       Here is the control flow of this function:
+//              1. Stop the time by setting bit 7 on RTC register 0xb.
+//
+//----------------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+VOID StopTime(
+    IN EFI_CMOS_MANAGER_INTERFACE  *Mgr ) 
+{
+    UINT8  Value;
+
+    CmosBankReadWrite( Mgr, ReadType, 0xb, &Value );
+    Value |= 0x80;
+    CmosBankReadWrite( Mgr, WriteType, 0xb, &Value );
+}
+
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------------
+// Procedure:   StartTime
+//
+// Description: Start the time on RTC clock. This is used when changing the
+//              Date and Time
+//
+// Input:       
+//      IN EFI_CMOS_MANAGER_INTERFACE *Mgr
+//                  -- The Manger interface pointer.
+//
+// Output:      None
+//
+// Notes:       Here is the control flow of this function:
+//              1. Start the time by clearing bit 7 on RTC register 0xb.
+//
+//----------------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+VOID StartTime(
+    IN EFI_CMOS_MANAGER_INTERFACE  *Mgr ) 
+{
+    UINT8  Value;
+
+    CmosBankReadWrite( Mgr, ReadType, 0xb, &Value );
+    Value &= 0x7f;
+    CmosBankReadWrite( Mgr, WriteType, 0xb, &Value );
+}
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------------
+// Procedure:   BCDToDec
+//
+// Description: Converts a Decimal value to a BCD value.
+//
+// Input:       
+//      IN UINT8 Dec - Decimal value
+//
+// Output:      
+//      UINT8 (return value) - BCD value
+//
+// Notes:       
+//      Only for 2 digit decimal.
+//
+//----------------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+UINT8 DecToBCD(IN UINT8 Dec)
+{
+    UINT8 FirstDigit = Dec % 10;
+    UINT8 SecondDigit = Dec / 10;
+
+    return (SecondDigit << 4) + FirstDigit;
+}
+
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------------
+// Procedure:   BCDToDec
+//
+// Description: Converts a BCD value to a Decimal value.
+//
+// Input:       
+//      IN UINT8 BCD -- BCD value
+//
+// Output:      
+//      UINT8 - decimal value
+//
+// Notes:       
+//      Only for 2 digit BCD.
+//
+//----------------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+UINT8 BCDToDec(IN UINT8 BCD)
+{
+    UINT8 FirstDigit = BCD & 0xf;
+    UINT8 SecondDigit = BCD >> 4;;
+
+    return SecondDigit * 10  + FirstDigit;
+}
+
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------------
+// Procedure:   CmosMgrReadRtcIndex
+//
+// Description: Read the RTC value at the given Index.
+//
+// Input:       
+//      IN EFI_CMOS_MANAGER_INTERFACE *Mgr
+//                  -- The Manger interface pointer.
+//      IN UINT8 Index
+//
+// Output:      
+//      UINT8 (return value) --
+//                  = RTC Value read from the provided Index
+//
+// Notes:       
+//      Here is the control flow of this function:
+//               1. Read port 0x70 (RTC Index Register) to get bit 7.
+//                  Bit 7 is the NMI bit-it should not be changed.
+//               2. Output 0x70 with the Index and NMI bit setting.
+//               3. Read 0x71 for Data. Getting Dec when appropriate.
+//               4. Return the Data.
+//----------------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+static UINT8 CmosMgrReadRtcIndex(
+    IN EFI_CMOS_MANAGER_INTERFACE   *Mgr,
+    IN UINT8                        Index )
+{
+    UINT8   Value;
+
+    CmosBankReadWrite( Mgr, ReadType, Index, &Value );
+    Value = BCDToDec(Value);
+    
+    return Value;
+}
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------------
+// Procedure:   CmosMgrWriteRtcIndex
+//
+// Description: Write the RTC value at the given Index.
+//
+// Input:       
+//      IN EFI_CMOS_MANAGER_INTERFACE *Mgr
+//                  -- The Manger interface pointer.
+//      IN UINT8 Index
+//                  -- Index to write
+//      IN UINT8 Value
+//                  -- Value to write
+//
+// Output:      None
+//
+// Notes:       Here is the control flow of this function:
+//              1. Read port 0x70 (RTC Index Register) to get bit 7.
+//                 Bit 7 is the NMI bit-it should not be changed.
+//              2. Output 0x70 with the Index. Switch to BCD when needed.
+//              3. Write the data to 0x71.
+//----------------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+static void CmosMgrWriteRtcIndex(
+    IN EFI_CMOS_MANAGER_INTERFACE   *Mgr,
+    IN UINT8                        Index, 
+    IN UINT8                        Value )
+{
+    Value = DecToBCD(Value);
+    CmosBankReadWrite( Mgr, WriteType, Index, &Value );
+}
+
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------------
+// Procedure:   CmosSetDateTime
+//
+// Description: 
+//      This routine simply writes the CMOS RTC registers from information
+//      provided by the EFI_TIME structure, assuming the information is 
+//      correct.
+//
+// Input:
+//      IN EFI_CMOS_MANAGER_INTERFACE *Manager
+//                  -- The Manger interface pointer.
+//      IN EFI_TIME *Time
+//                  -- EFI Time structure
+//
+// Output:
+//      EFI_STATUS (Return Value)
+//                  = EFI_SUCCESS or valid EFI error code
+//
+// Modified:
+//      N/A
+//
+// Notes:       
+//      Data is assumed to be valid.  Only a simple check for NULL pointer
+//      is done.
+//
+//----------------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+EFI_STATUS CmosSetDateTime (
+    IN  EFI_CMOS_ACCESS_INTERFACE   *Cmos,
+    IN  EFI_TIME                    *Time )
+{
+    EFI_CMOS_MANAGER_INTERFACE      *Mgr = GetCmosMangerInterface(Cmos);
+    DEFINE_PEI_SERVICES(Cmos->PeiServices);
+
+    if (Time == NULL || Mgr == NULL) 
+        return EFI_INVALID_PARAMETER;
+
+    StopTime(Mgr);
+    
+    CmosMgrWriteRtcIndex( Mgr, ACPI_CENTURY_CMOS, Time->Year / 100 );
+    CmosMgrWriteRtcIndex( Mgr, 9, Time->Year % 100 );
+    CmosMgrWriteRtcIndex( Mgr, 8, Time->Month );
+    CmosMgrWriteRtcIndex( Mgr, 7, Time->Day );
+    CmosMgrWriteRtcIndex( Mgr, 4, Time->Hour );
+    CmosMgrWriteRtcIndex( Mgr, 2, Time->Minute );
+    CmosMgrWriteRtcIndex( Mgr, 0, Time->Second );
+    
+    StartTime(Mgr);
+
+    return  EFI_SUCCESS;
+}
+
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------------
+// Procedure:   CmosGetDateTime
+//
+// Description: Return the current date and time
+//
+// Input:       
+//      IN EFI_CMOS_MANAGER_INTERFACE *Manager
+//                  -- The Manger interface pointer.
+//      OUT EFI_TIME *Time
+//                  -- EFI Time structure
+//
+// Output: 
+//      EFI_STATUS (Return Value)
+//                  = EFI_SUCCESS or valid EFI error code
+//
+//
+//----------------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+EFI_STATUS CmosGetDateTime (
+    IN  EFI_CMOS_ACCESS_INTERFACE   *Cmos,
+    OUT EFI_TIME                    *Time )
+{
+    EFI_CMOS_MANAGER_INTERFACE      *Mgr = GetCmosMangerInterface(Cmos);
+    DEFINE_PEI_SERVICES(Cmos->PeiServices);
+
+    if (Time == NULL || Cmos == NULL) 
+        return EFI_INVALID_PARAMETER;
+
+    //If RTC Year only 1 digit, EFI spec says years range is 1998 - 2097
+    Time->Year      = CmosMgrReadRtcIndex(Mgr, ACPI_CENTURY_CMOS) * 100 
+                        + CmosMgrReadRtcIndex(Mgr, 9);
+    Time->Month     = CmosMgrReadRtcIndex(Mgr, 8);
+    Time->Day       = CmosMgrReadRtcIndex(Mgr, 7);
+    Time->Hour      = CmosMgrReadRtcIndex(Mgr, 4);
+    Time->Minute    = CmosMgrReadRtcIndex(Mgr, 2);
+    Time->Second    = CmosMgrReadRtcIndex(Mgr, 0);
+    Time->Nanosecond= 0;
+
+    return  EFI_SUCCESS;
+}
+
+//*************************************************************************
+//*************************************************************************
+//**                                                                     **
+//**        (C)Copyright 1985-2009, American Megatrends, Inc.            **
+//**                                                                     **
+//**                       All Rights Reserved.                          **
+//**                                                                     **
+//**      5555 Oakbrook Parkway, Suite 200, Norcross, GA 30093           **
+//**                                                                     **
+//**                       Phone: (770)-246-8600                         **
+//**                                                                     **
+//*************************************************************************
+//*************************************************************************