FvbService.c

Go to the documentation of this file.

 
#include "FvbService.h"
 
//
// Global variable for this FVB driver  which contains
// the private data of all firmware volume block instances
//
FWB_GLOBAL  mFvbModuleGlobal;
 
FV_MEMMAP_DEVICE_PATH  mFvMemmapDevicePathTemplate = {
  {
    {
      HARDWARE_DEVICE_PATH,
      HW_MEMMAP_DP,
      {
        (UINT8)(sizeof (MEMMAP_DEVICE_PATH)),
        (UINT8)(sizeof (MEMMAP_DEVICE_PATH) >> 8)
      }
    },
    EfiMemoryMappedIO,
    (EFI_PHYSICAL_ADDRESS)0,
    (EFI_PHYSICAL_ADDRESS)0,
  },
  {
    END_DEVICE_PATH_TYPE,
    END_ENTIRE_DEVICE_PATH_SUBTYPE,
    {
      END_DEVICE_PATH_LENGTH,
      0
    }
  }
};
 
FV_PIWG_DEVICE_PATH  mFvPIWGDevicePathTemplate = {
  {
    {
      MEDIA_DEVICE_PATH,
      MEDIA_PIWG_FW_VOL_DP,
      {
        (UINT8)(sizeof (MEDIA_FW_VOL_DEVICE_PATH)),
        (UINT8)(sizeof (MEDIA_FW_VOL_DEVICE_PATH) >> 8)
      }
    },
    { 0 }
  },
  {
    END_DEVICE_PATH_TYPE,
    END_ENTIRE_DEVICE_PATH_SUBTYPE,
    {
      END_DEVICE_PATH_LENGTH,
      0
    }
  }
};
 
EFI_FW_VOL_BLOCK_DEVICE  mFvbDeviceTemplate = {
  FVB_DEVICE_SIGNATURE,
  NULL,
  0, // Instance
  {
    FvbProtocolGetAttributes,
    FvbProtocolSetAttributes,
    FvbProtocolGetPhysicalAddress,
    FvbProtocolGetBlockSize,
    FvbProtocolRead,
    FvbProtocolWrite,
    FvbProtocolEraseBlocks,
    NULL
  } // FwVolBlockInstance
};
 
EFI_FW_VOL_INSTANCE *
GetFvbInstance (
  IN  UINTN  Instance
  )
{
  EFI_FW_VOL_INSTANCE  *FwhRecord;
 
  if ( Instance >= mFvbModuleGlobal.NumFv ) {
    ASSERT_EFI_ERROR (EFI_INVALID_PARAMETER);
    return NULL;
  }
 
  //
  // Find the right instance of the FVB private data
  //
  FwhRecord = mFvbModuleGlobal.FvInstance;
  while ( Instance > 0 ) {
    FwhRecord = (EFI_FW_VOL_INSTANCE *)((UINTN)((UINT8 *)FwhRecord) +
                                        FwhRecord->VolumeHeader.HeaderLength +
                                        (sizeof (EFI_FW_VOL_INSTANCE) - sizeof (EFI_FIRMWARE_VOLUME_HEADER)));
    Instance--;
  }
 
  return FwhRecord;
}
 
STATIC
EFI_FVB_ATTRIBUTES_2
FvbGetVolumeAttributes (
  IN UINTN  Instance
  )
{
  EFI_FW_VOL_INSTANCE  *FwInstance;
 
  FwInstance = GetFvbInstance (Instance);
  ASSERT (FwInstance != NULL);
 
  if (FwInstance == NULL) {
    return 0;
  }
 
  return FwInstance->VolumeHeader.Attributes;
}
 
STATIC
EFI_STATUS
FvbGetLbaAddress (
  IN  UINTN    Instance,
  IN  EFI_LBA  Lba,
  OUT UINTN    *LbaAddress,
  OUT UINTN    *LbaLength,
  OUT UINTN    *NumOfBlocks
  )
{
  UINT32                  NumBlocks;
  UINT32                  BlockLength;
  UINTN                   Offset;
  EFI_LBA                 StartLba;
  EFI_LBA                 NextLba;
  EFI_FW_VOL_INSTANCE     *FwhInstance;
  EFI_FV_BLOCK_MAP_ENTRY  *BlockMap;
 
  //
  // Find the right instance of the FVB private data
  //
  FwhInstance = GetFvbInstance (Instance);
  if (FwhInstance == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  StartLba = 0;
  Offset   = 0;
  BlockMap = &FwhInstance->VolumeHeader.BlockMap[0];
  ASSERT (BlockMap != NULL);
 
  //
  // Parse the blockmap of the FV to find which map entry the Lba belongs to
  //
  while (TRUE) {
    if ( BlockMap != NULL) {
      NumBlocks   = BlockMap->NumBlocks;
      BlockLength = BlockMap->Length;
    }
 
    if ((NumBlocks == 0) || (BlockLength == 0)) {
      return EFI_INVALID_PARAMETER;
    }
 
    NextLba = StartLba + NumBlocks;
 
    //
    // The map entry found
    //
    if ((Lba >= StartLba) && (Lba < NextLba)) {
      Offset = Offset + (UINTN)MultU64x32 ((Lba - StartLba), BlockLength);
      if (LbaAddress != NULL) {
        *LbaAddress = FwhInstance->FvBase + Offset;
      }
 
      if (LbaLength != NULL) {
        *LbaLength = BlockLength;
      }
 
      if (NumOfBlocks != NULL) {
        *NumOfBlocks = (UINTN)(NextLba - Lba);
      }
 
      return EFI_SUCCESS;
    }
 
    StartLba = NextLba;
    Offset   = Offset + NumBlocks * BlockLength;
    BlockMap++;
  }
}
 
STATIC
EFI_STATUS
FvbReadBlock (
  IN UINTN      Instance,
  IN EFI_LBA    Lba,
  IN UINTN      BlockOffset,
  IN OUT UINTN  *NumBytes,
  IN UINT8      *Buffer
  )
{
  EFI_FVB_ATTRIBUTES_2  Attributes;
  UINTN                 LbaAddress;
  UINTN                 LbaLength;
  EFI_STATUS            Status;
  EFI_STATUS            ReadStatus;
 
  if ((NumBytes == NULL) || (Buffer == NULL)) {
    return (EFI_INVALID_PARAMETER);
  }
 
  if (*NumBytes == 0) {
    return (EFI_INVALID_PARAMETER);
  }
 
  Status = FvbGetLbaAddress (Instance, Lba, &LbaAddress, &LbaLength, NULL);
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  Attributes = FvbGetVolumeAttributes (Instance);
 
  if ((Attributes & EFI_FVB2_READ_STATUS) == 0) {
    return (EFI_ACCESS_DENIED);
  }
 
  if (BlockOffset > LbaLength) {
    return (EFI_INVALID_PARAMETER);
  }
 
  if (LbaLength < (*NumBytes + BlockOffset)) {
    *NumBytes = (UINT32)(LbaLength - BlockOffset);
    Status    = EFI_BAD_BUFFER_SIZE;
  }
 
  ReadStatus = LibFvbFlashDeviceRead (LbaAddress + BlockOffset, NumBytes, Buffer);
  if (EFI_ERROR (ReadStatus)) {
    return ReadStatus;
  }
 
  return Status;
}
 
EFI_STATUS
FvbWriteBlock (
  IN UINTN      Instance,
  IN EFI_LBA    Lba,
  IN UINTN      BlockOffset,
  IN OUT UINTN  *NumBytes,
  IN UINT8      *Buffer
  )
{
  EFI_FVB_ATTRIBUTES_2  Attributes;
  UINTN                 LbaAddress;
  UINTN                 LbaLength;
  EFI_STATUS            Status;
 
  if ((NumBytes == NULL) || (Buffer == NULL)) {
    return (EFI_INVALID_PARAMETER);
  }
 
  if (*NumBytes == 0) {
    return (EFI_INVALID_PARAMETER);
  }
 
  Status = FvbGetLbaAddress (Instance, Lba, &LbaAddress, &LbaLength, NULL);
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  //
  // Check if the FV is write enabled
  //
  Attributes = FvbGetVolumeAttributes (Instance);
  if ((Attributes & EFI_FVB2_WRITE_STATUS) == 0) {
    return EFI_ACCESS_DENIED;
  }
 
  //
  // Perform boundary checks and adjust NumBytes
  //
  if (BlockOffset > LbaLength) {
    return EFI_INVALID_PARAMETER;
  }
 
  if ( LbaLength < (*NumBytes + BlockOffset)) {
    DEBUG ((
      DEBUG_ERROR,
      "FvWriteBlock: Reducing Numbytes from 0x%x to 0x%x\n",
      *NumBytes,
      (UINT32)(LbaLength - BlockOffset)
      ));
    *NumBytes = (UINT32)(LbaLength - BlockOffset);
    return EFI_BAD_BUFFER_SIZE;
  }
 
  LibFvbFlashDeviceBlockLock (LbaAddress, LbaLength, FALSE);
  Status = LibFvbFlashDeviceWrite (LbaAddress + BlockOffset, NumBytes, Buffer);
 
  LibFvbFlashDeviceBlockLock (LbaAddress, LbaLength, TRUE);
  WriteBackInvalidateDataCacheRange ((VOID *)(LbaAddress + BlockOffset), *NumBytes);
  return Status;
}
 
EFI_STATUS
FvbEraseBlock (
  IN UINTN    Instance,
  IN EFI_LBA  Lba
  )
{
  EFI_FVB_ATTRIBUTES_2  Attributes;
  UINTN                 LbaAddress;
  UINTN                 LbaLength;
  EFI_STATUS            Status;
 
  //
  // Check if the FV is write enabled
  //
  Attributes = FvbGetVolumeAttributes (Instance);
 
  if ((Attributes & EFI_FVB2_WRITE_STATUS) == 0) {
    return (EFI_ACCESS_DENIED);
  }
 
  //
  // Get the starting address of the block for erase.
  //
  Status = FvbGetLbaAddress (Instance, Lba, &LbaAddress, &LbaLength, NULL);
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  LibFvbFlashDeviceBlockLock (LbaAddress, LbaLength, FALSE);
 
  Status = LibFvbFlashDeviceBlockErase (LbaAddress, LbaLength);
 
  LibFvbFlashDeviceBlockLock (LbaAddress, LbaLength, TRUE);
 
  WriteBackInvalidateDataCacheRange ((VOID *)LbaAddress, LbaLength);
 
  return Status;
}
 
STATIC
EFI_STATUS
FvbSetVolumeAttributes (
  IN UINTN                     Instance,
  IN OUT EFI_FVB_ATTRIBUTES_2  *Attributes
  )
{
  EFI_FW_VOL_INSTANCE   *FwhInstance;
  EFI_FVB_ATTRIBUTES_2  OldAttributes;
  EFI_FVB_ATTRIBUTES_2  *AttribPtr;
  EFI_FVB_ATTRIBUTES_2  UnchangedAttributes;
  UINT32                Capabilities;
  UINT32                OldStatus;
  UINT32                NewStatus;
 
  //
  // Find the right instance of the FVB private data
  //
  FwhInstance = GetFvbInstance (Instance);
  if (FwhInstance == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  AttribPtr = (EFI_FVB_ATTRIBUTES_2 *)&(FwhInstance->VolumeHeader.Attributes);
  ASSERT (AttribPtr != NULL);
  if ( AttribPtr == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  OldAttributes = *AttribPtr;
  Capabilities  = OldAttributes & EFI_FVB2_CAPABILITIES;
  OldStatus     = OldAttributes & EFI_FVB2_STATUS;
  NewStatus     = *Attributes   & EFI_FVB2_STATUS;
 
  UnchangedAttributes = EFI_FVB2_READ_DISABLED_CAP  | \
                        EFI_FVB2_READ_ENABLED_CAP   | \
                        EFI_FVB2_WRITE_DISABLED_CAP | \
                        EFI_FVB2_WRITE_ENABLED_CAP  | \
                        EFI_FVB2_LOCK_CAP           | \
                        EFI_FVB2_STICKY_WRITE       | \
                        EFI_FVB2_MEMORY_MAPPED      | \
                        EFI_FVB2_ERASE_POLARITY     | \
                        EFI_FVB2_READ_LOCK_CAP      | \
                        EFI_FVB2_WRITE_LOCK_CAP     | \
                        EFI_FVB2_ALIGNMENT;
 
  //
  // Some attributes of FV is read only can *not* be set
  //
  if ((OldAttributes & UnchangedAttributes) ^ (*Attributes & UnchangedAttributes)) {
    return EFI_INVALID_PARAMETER;
  }
 
  //
  // If firmware volume is locked, no status bit can be updated
  //
  if ((OldAttributes & EFI_FVB2_LOCK_STATUS) != 0) {
    if ((OldStatus ^ NewStatus) != 0) {
      return EFI_ACCESS_DENIED;
    }
  }
 
  //
  // Test read disable
  //
  if ((Capabilities & EFI_FVB2_READ_DISABLED_CAP) == 0) {
    if ((NewStatus & EFI_FVB2_READ_STATUS) == 0) {
      return EFI_INVALID_PARAMETER;
    }
  }
 
  //
  // Test read enable
  //
  if ((Capabilities & EFI_FVB2_READ_ENABLED_CAP) == 0) {
    if ((NewStatus & EFI_FVB2_READ_STATUS) != 0) {
      return EFI_INVALID_PARAMETER;
    }
  }
 
  //
  // Test write disable
  //
  if ((Capabilities & EFI_FVB2_WRITE_DISABLED_CAP) == 0) {
    if ((NewStatus & EFI_FVB2_WRITE_STATUS) == 0) {
      return EFI_INVALID_PARAMETER;
    }
  }
 
  //
  // Test write enable
  //
  if ((Capabilities & EFI_FVB2_WRITE_ENABLED_CAP) == 0) {
    if ((NewStatus & EFI_FVB2_WRITE_STATUS) != 0) {
      return EFI_INVALID_PARAMETER;
    }
  }
 
  //
  // Test lock
  //
  if ((Capabilities & EFI_FVB2_LOCK_CAP) == 0) {
    if ((NewStatus & EFI_FVB2_LOCK_STATUS) != 0) {
      return EFI_INVALID_PARAMETER;
    }
  }
 
  *AttribPtr  = (*AttribPtr) & (0xFFFFFFFF & (~EFI_FVB2_STATUS));
  *AttribPtr  = (*AttribPtr) | NewStatus;
  *Attributes = *AttribPtr;
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
FvbProtocolGetPhysicalAddress (
  IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL  *This,
  OUT EFI_PHYSICAL_ADDRESS                     *Address
  )
{
  EFI_FW_VOL_BLOCK_DEVICE  *FvbDevice;
  EFI_FW_VOL_INSTANCE      *FwhInstance;
 
  FvbDevice   = FVB_DEVICE_FROM_THIS (This);
  FwhInstance = GetFvbInstance (FvbDevice->Instance);
  if (FwhInstance == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  *Address = FwhInstance->FvBase;
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
FvbProtocolGetBlockSize (
  IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL  *This,
  IN  EFI_LBA                                  Lba,
  OUT UINTN                                    *BlockSize,
  OUT UINTN                                    *NumOfBlocks
  )
{
  EFI_FW_VOL_BLOCK_DEVICE  *FvbDevice;
 
  FvbDevice = FVB_DEVICE_FROM_THIS (This);
  return FvbGetLbaAddress (FvbDevice->Instance, Lba, NULL, BlockSize, NumOfBlocks);
}
 
EFI_STATUS
EFIAPI
FvbProtocolGetAttributes (
  IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL  *This,
  OUT EFI_FVB_ATTRIBUTES_2                     *Attributes
  )
{
  EFI_FW_VOL_BLOCK_DEVICE  *FvbDevice;
 
  FvbDevice   = FVB_DEVICE_FROM_THIS (This);
  *Attributes = FvbGetVolumeAttributes (FvbDevice->Instance);
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
FvbProtocolSetAttributes (
  IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL  *This,
  IN OUT EFI_FVB_ATTRIBUTES_2                  *Attributes
  )
{
  EFI_STATUS               Status;
  EFI_FW_VOL_BLOCK_DEVICE  *FvbDevice;
 
  FvbDevice = FVB_DEVICE_FROM_THIS (This);
  Status    = FvbSetVolumeAttributes (FvbDevice->Instance, Attributes);
  return Status;
}
 
EFI_STATUS
EFIAPI
FvbProtocolEraseBlocks (
  IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL  *This,
  ...
  )
{
  EFI_FW_VOL_BLOCK_DEVICE  *FvbDevice;
  EFI_FW_VOL_INSTANCE      *FwhInstance;
  UINTN                    NumOfBlocks;
  VA_LIST                  args;
  EFI_LBA                  StartingLba;
  UINTN                    NumOfLba;
  EFI_STATUS               Status;
 
  FvbDevice   = FVB_DEVICE_FROM_THIS (This);
  FwhInstance = GetFvbInstance (FvbDevice->Instance);
  if (FwhInstance == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  NumOfBlocks = FwhInstance->NumOfBlocks;
  VA_START (args, This);
 
  do {
    StartingLba = VA_ARG (args, EFI_LBA);
    if ( StartingLba == EFI_LBA_LIST_TERMINATOR ) {
      break;
    }
 
    NumOfLba = VA_ARG (args, UINT32);
 
    //
    // Check input parameters
    //
    if (NumOfLba == 0) {
      VA_END (args);
      return EFI_INVALID_PARAMETER;
    }
 
    if ((StartingLba + NumOfLba) > NumOfBlocks ) {
      return EFI_INVALID_PARAMETER;
    }
  } while (1);
 
  VA_END (args);
 
  VA_START (args, This);
  do {
    StartingLba = VA_ARG (args, EFI_LBA);
    if (StartingLba == EFI_LBA_LIST_TERMINATOR) {
      break;
    }
 
    NumOfLba = VA_ARG (args, UINT32);
 
    while ( NumOfLba > 0 ) {
      Status = FvbEraseBlock (FvbDevice->Instance, StartingLba);
      if ( EFI_ERROR (Status)) {
        VA_END (args);
        return Status;
      }
 
      StartingLba++;
      NumOfLba--;
    }
  } while (1);
 
  VA_END (args);
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
FvbProtocolWrite (
  IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL  *This,
  IN EFI_LBA                                   Lba,
  IN UINTN                                     Offset,
  IN OUT UINTN                                 *NumBytes,
  IN UINT8                                     *Buffer
  )
{
  EFI_FW_VOL_BLOCK_DEVICE  *FvbDevice;
  EFI_STATUS               Status;
 
  FvbDevice = FVB_DEVICE_FROM_THIS (This);
  Status    = FvbWriteBlock (FvbDevice->Instance, Lba, Offset, NumBytes, Buffer);
  DEBUG ((
    DEBUG_VERBOSE,
    "FvbWrite: Lba: 0x%lx Offset: 0x%x NumBytes: 0x%x, Buffer: 0x%x Status:%r\n",
    Lba,
    Offset,
    *NumBytes,
    Buffer,
    Status
    ));
 
  return Status;
}
 
EFI_STATUS
EFIAPI
FvbProtocolRead (
  IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL  *This,
  IN EFI_LBA                                   Lba,
  IN UINTN                                     Offset,
  IN OUT UINTN                                 *NumBytes,
  OUT UINT8                                    *Buffer
  )
{
  EFI_FW_VOL_BLOCK_DEVICE  *FvbDevice;
  EFI_STATUS               Status;
 
  FvbDevice = FVB_DEVICE_FROM_THIS (This);
  Status    = FvbReadBlock (FvbDevice->Instance, Lba, Offset, NumBytes, Buffer);
  DEBUG ((
    DEBUG_VERBOSE,
    "FvbRead: Lba: 0x%lx Offset: 0x%x NumBytes: 0x%x, Buffer: 0x%x, Status:%r\n",
    Lba,
    Offset,
    *NumBytes,
    Buffer,
    Status
    ));
 
  return Status;
}
 
BOOLEAN
IsFvHeaderValid (
  IN       EFI_PHYSICAL_ADDRESS  FvBase
  )
{
  UINT16                      Sum;
  EFI_FIRMWARE_VOLUME_HEADER  *FwVolHeader;
 
  FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *)(UINTN)FvBase;
  if (FvBase == PcdGet32 (PcdFlashNvStorageVariableBase)) {
    if (CompareMem (&FwVolHeader->FileSystemGuid, &gEfiSystemNvDataFvGuid, sizeof (EFI_GUID)) != 0 ) {
      DEBUG ((DEBUG_INFO, "  --FileSystemGuid not match: %g\n", &FwVolHeader->FileSystemGuid));
      return FALSE;
    }
  } else {
    if (CompareMem (&FwVolHeader->FileSystemGuid, &gEfiFirmwareFileSystem2Guid, sizeof (EFI_GUID)) != 0 ) {
      DEBUG ((DEBUG_INFO, "  --not expected guid.\n"));
      return FALSE;
    }
  }
 
  if ((FwVolHeader->Revision != EFI_FVH_REVISION)   ||
      (FwVolHeader->Signature != EFI_FVH_SIGNATURE) ||
      (FwVolHeader->FvLength == ((UINTN)-1))       ||
      ((FwVolHeader->HeaderLength & 0x01) != 0))
  {
    DEBUG ((DEBUG_INFO, "  -- >Revision = 0x%x, Signature = 0x%x\n", FwVolHeader->Revision, FwVolHeader->Signature));
    DEBUG ((DEBUG_INFO, "  -- >FvLength = 0x%lx, HeaderLength = 0x%x\n", FwVolHeader->FvLength, FwVolHeader->HeaderLength));
    return FALSE;
  }
 
  Sum = CalculateSum16 ((UINT16 *)FwVolHeader, FwVolHeader->HeaderLength);
  if (Sum != 0) {
    DEBUG ((DEBUG_INFO, "error: checksum: 0x%04X (expect 0x0)\n", Sum));
    return FALSE;
  }
 
  return TRUE;
}
 
EFI_STATUS
GetInitialVariableData (
  OUT VOID   **VarData,
  OUT UINTN  *VarSize
  )
{
  EFI_STATUS                     Status;
  VOID                           *ImageData;
  UINTN                          ImageSize;
  EFI_FIRMWARE_VOLUME_HEADER     *FvHeader;
  VARIABLE_STORE_HEADER          *VariableStore;
  AUTHENTICATED_VARIABLE_HEADER  *Variable;
  UINTN                          VariableSize;
  UINTN                          VarEndAddr;
 
  if ((VarData == NULL) || (VarSize == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  Status = GetSectionFromAnyFv (PcdGetPtr (PcdNvsDataFile), EFI_SECTION_RAW, 0, &ImageData, &ImageSize);
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  FvHeader      = (EFI_FIRMWARE_VOLUME_HEADER *)ImageData;
  VariableStore = (VARIABLE_STORE_HEADER *)((UINT8 *)ImageData + FvHeader->HeaderLength);
  VarEndAddr    = (UINTN)VariableStore + VariableStore->Size;
  Variable      = (AUTHENTICATED_VARIABLE_HEADER *)HEADER_ALIGN (VariableStore + 1);
  *VarData      = (VOID *)Variable;
  while (((UINTN)Variable < VarEndAddr)) {
    if (Variable->StartId != VARIABLE_DATA) {
      break;
    }
 
    VariableSize = sizeof (AUTHENTICATED_VARIABLE_HEADER) + Variable->DataSize + Variable->NameSize;
    Variable     = (AUTHENTICATED_VARIABLE_HEADER *)HEADER_ALIGN ((UINTN)Variable + VariableSize);
  }
 
  *VarSize = (UINTN)Variable - HEADER_ALIGN (VariableStore + 1);
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
FvbInitialize (
  VOID
  )
{
  EFI_FW_VOL_INSTANCE         *FwVolInstance;
  EFI_FIRMWARE_VOLUME_HEADER  *FvHeader;
  EFI_FV_BLOCK_MAP_ENTRY      *BlockMap;
  EFI_PHYSICAL_ADDRESS        BaseAddress;
  UINTN                       WriteAddr;
  EFI_STATUS                  Status;
  UINTN                       BufferSize;
  UINTN                       Length;
  VARIABLE_STORE_HEADER       VariableStore;
  VOID                        *VarData;
 
  InitVariableStore ();
  BaseAddress = PcdGet32 (PcdFlashNvStorageVariableBase);
  FvHeader    = (EFI_FIRMWARE_VOLUME_HEADER *)(UINTN)BaseAddress;
 
  //
  // Check FV header and variable store header
  //
  if (!IsFvHeaderValid (BaseAddress)) {
    //
    //  Write back a healthy FV header
    //
    DEBUG ((DEBUG_ERROR, "Fvb: Writing back a healthy FV header: 0x%lx\n", BaseAddress));
    FvHeader = GetFvHeaderTemplate ();
    LibFvbFlashDeviceBlockLock ((UINTN)BaseAddress, FvHeader->BlockMap->Length, FALSE);
 
    Status = LibFvbFlashDeviceBlockErase ((UINTN)BaseAddress, FvHeader->BlockMap->Length);
    ASSERT_EFI_ERROR (Status);
 
    Length     = FvHeader->HeaderLength;
    WriteAddr  = (UINTN)BaseAddress;
    Status     = LibFvbFlashDeviceWrite (WriteAddr, &Length, (UINT8 *)FvHeader);
    WriteAddr += Length;
    ASSERT_EFI_ERROR (Status);
 
    //
    // Write back variable store header
    //
    VariableStore.Size   = PcdGet32 (PcdFlashNvStorageVariableSize) - FvHeader->HeaderLength;
    VariableStore.Format = VARIABLE_STORE_FORMATTED;
    VariableStore.State  = VARIABLE_STORE_HEALTHY;
    CopyGuid (&VariableStore.Signature, &gEfiAuthenticatedVariableGuid);
    BufferSize = sizeof (VARIABLE_STORE_HEADER);
    Status     = LibFvbFlashDeviceWrite (WriteAddr, &BufferSize, (UINT8 *)&VariableStore);
    WriteAddr += BufferSize;
    ASSERT_EFI_ERROR (Status);
 
    //
    // Write initial variable data if found
    //
    Status = GetInitialVariableData (&VarData, &Length);
    if (!EFI_ERROR (Status)) {
      Status = LibFvbFlashDeviceWrite (WriteAddr, &Length, (UINT8 *)VarData);
      ASSERT_EFI_ERROR (Status);
    }
 
    LibFvbFlashDeviceBlockLock ((UINTN)BaseAddress, FvHeader->BlockMap->Length, TRUE);
    WriteBackInvalidateDataCacheRange ((VOID *)(UINTN)BaseAddress, FvHeader->BlockMap->Length);
  }
 
  //
  // Create a new FW volume instance for NVS variable
  //
  BufferSize    = FvHeader->HeaderLength + sizeof (EFI_FW_VOL_INSTANCE) - sizeof (EFI_FIRMWARE_VOLUME_HEADER);
  FwVolInstance = (EFI_FW_VOL_INSTANCE *)AllocateRuntimeZeroPool (BufferSize);
  if (FwVolInstance == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  FwVolInstance->FvBase = (UINTN)BaseAddress;
  CopyMem (&FwVolInstance->VolumeHeader, FvHeader, FvHeader->HeaderLength);
 
  //
  // Process the block map for each FV. Assume it has same block size.
  //
  FwVolInstance->NumOfBlocks = 0;
  FvHeader                   = &FwVolInstance->VolumeHeader;
  for (BlockMap = FvHeader->BlockMap; BlockMap->NumBlocks != 0; BlockMap++) {
    FwVolInstance->NumOfBlocks += BlockMap->NumBlocks;
  }
 
  //
  // Add a FVB Protocol Instance
  //
  Status = InstallFvbProtocol (FwVolInstance, mFvbModuleGlobal.NumFv);
  mFvbModuleGlobal.NumFv++;
  mFvbModuleGlobal.FvInstance = FwVolInstance;
 
  return Status;
}