VirtNorFlashFvb.c

/*++ @file  NorFlashFvbDxe.c
 
 Copyright (c) 2011 - 2021, Arm Limited. All rights reserved.<BR>
 
 SPDX-License-Identifier: BSD-2-Clause-Patent
 
 --*/
 
#include <PiDxe.h>
 
#include <Library/BaseLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/PcdLib.h>
#include <Library/SafeIntLib.h>
#include <Library/UefiLib.h>
 
#include <Guid/NvVarStoreFormatted.h>
#include <Guid/SystemNvDataGuid.h>
#include <Guid/VariableFormat.h>
 
#include "VirtNorFlash.h"
 
extern UINTN  mFlashNvStorageVariableBase;
 
EFI_STATUS
InitializeFvAndVariableStoreHeaders (
  IN NOR_FLASH_INSTANCE  *Instance
  )
{
  EFI_STATUS                  Status;
  VOID                        *Headers;
  UINTN                       HeadersLength;
  EFI_FIRMWARE_VOLUME_HEADER  *FirmwareVolumeHeader;
  VARIABLE_STORE_HEADER       *VariableStoreHeader;
  UINT32                      NvStorageFtwSpareSize;
  UINT32                      NvStorageFtwWorkingSize;
  UINT32                      NvStorageVariableSize;
  UINT64                      NvStorageFtwSpareBase;
  UINT64                      NvStorageFtwWorkingBase;
  UINT64                      NvStorageVariableBase;
 
  HeadersLength = sizeof (EFI_FIRMWARE_VOLUME_HEADER) + sizeof (EFI_FV_BLOCK_MAP_ENTRY) + sizeof (VARIABLE_STORE_HEADER);
  Headers       = AllocateZeroPool (HeadersLength);
 
  NvStorageFtwWorkingSize = PcdGet32 (PcdFlashNvStorageFtwWorkingSize);
  NvStorageFtwSpareSize   = PcdGet32 (PcdFlashNvStorageFtwSpareSize);
  NvStorageVariableSize   = PcdGet32 (PcdFlashNvStorageVariableSize);
 
  NvStorageFtwSpareBase = (PcdGet64 (PcdFlashNvStorageFtwSpareBase64) != 0) ?
                          PcdGet64 (PcdFlashNvStorageFtwSpareBase64) : PcdGet32 (PcdFlashNvStorageFtwSpareBase);
  NvStorageFtwWorkingBase = (PcdGet64 (PcdFlashNvStorageFtwWorkingBase64) != 0) ?
                            PcdGet64 (PcdFlashNvStorageFtwWorkingBase64) : PcdGet32 (PcdFlashNvStorageFtwWorkingBase);
  NvStorageVariableBase = (PcdGet64 (PcdFlashNvStorageVariableBase64) != 0) ?
                          PcdGet64 (PcdFlashNvStorageVariableBase64) : PcdGet32 (PcdFlashNvStorageVariableBase);
 
  // FirmwareVolumeHeader->FvLength is declared to have the Variable area AND the FTW working area AND the FTW Spare contiguous.
  if ((NvStorageVariableBase + NvStorageVariableSize) != NvStorageFtwWorkingBase) {
    DEBUG ((
      DEBUG_ERROR,
      "%a: NvStorageFtwWorkingBase is not contiguous with NvStorageVariableBase region\n",
      __func__
      ));
    return EFI_INVALID_PARAMETER;
  }
 
  if ((NvStorageFtwWorkingBase + NvStorageFtwWorkingSize) != NvStorageFtwSpareBase) {
    DEBUG ((
      DEBUG_ERROR,
      "%a: NvStorageFtwSpareBase is not contiguous with NvStorageFtwWorkingBase region\n",
      __func__
      ));
    return EFI_INVALID_PARAMETER;
  }
 
  // Check if the size of the area is at least one block size
  if ((NvStorageVariableSize <= 0) || (NvStorageVariableSize / Instance->BlockSize <= 0)) {
    DEBUG ((
      DEBUG_ERROR,
      "%a: NvStorageVariableSize is 0x%x, should be atleast one block size\n",
      __func__,
      NvStorageVariableSize
      ));
    return EFI_INVALID_PARAMETER;
  }
 
  if ((NvStorageFtwWorkingSize <= 0) || (NvStorageFtwWorkingSize / Instance->BlockSize <= 0)) {
    DEBUG ((
      DEBUG_ERROR,
      "%a: NvStorageFtwWorkingSize is 0x%x, should be atleast one block size\n",
      __func__,
      NvStorageFtwWorkingSize
      ));
    return EFI_INVALID_PARAMETER;
  }
 
  if ((NvStorageFtwSpareSize <= 0) || (NvStorageFtwSpareSize / Instance->BlockSize <= 0)) {
    DEBUG ((
      DEBUG_ERROR,
      "%a: NvStorageFtwSpareSize is 0x%x, should be atleast one block size\n",
      __func__,
      NvStorageFtwSpareSize
      ));
    return EFI_INVALID_PARAMETER;
  }
 
  // Ensure the Variable area Base Addresses are aligned on a block size boundaries
  if ((NvStorageVariableBase % Instance->BlockSize != 0) ||
      (NvStorageFtwWorkingBase % Instance->BlockSize != 0) ||
      (NvStorageFtwSpareBase % Instance->BlockSize != 0))
  {
    DEBUG ((DEBUG_ERROR, "%a: NvStorage Base addresses must be aligned to block size boundaries", __func__));
    return EFI_INVALID_PARAMETER;
  }
 
  //
  // EFI_FIRMWARE_VOLUME_HEADER
  //
  FirmwareVolumeHeader = (EFI_FIRMWARE_VOLUME_HEADER *)Headers;
  CopyGuid (&FirmwareVolumeHeader->FileSystemGuid, &gEfiSystemNvDataFvGuid);
  FirmwareVolumeHeader->FvLength =
    PcdGet32 (PcdFlashNvStorageVariableSize) +
    PcdGet32 (PcdFlashNvStorageFtwWorkingSize) +
    PcdGet32 (PcdFlashNvStorageFtwSpareSize);
  FirmwareVolumeHeader->Signature  = EFI_FVH_SIGNATURE;
  FirmwareVolumeHeader->Attributes = (EFI_FVB_ATTRIBUTES_2)(
                                                            EFI_FVB2_READ_ENABLED_CAP   | // Reads may be enabled
                                                            EFI_FVB2_READ_STATUS        | // Reads are currently enabled
                                                            EFI_FVB2_STICKY_WRITE       | // A block erase is required to flip bits into EFI_FVB2_ERASE_POLARITY
                                                            EFI_FVB2_MEMORY_MAPPED      | // It is memory mapped
                                                            EFI_FVB2_ERASE_POLARITY     | // After erasure all bits take this value (i.e. '1')
                                                            EFI_FVB2_WRITE_STATUS       | // Writes are currently enabled
                                                            EFI_FVB2_WRITE_ENABLED_CAP    // Writes may be enabled
                                                            );
  FirmwareVolumeHeader->HeaderLength          = sizeof (EFI_FIRMWARE_VOLUME_HEADER) + sizeof (EFI_FV_BLOCK_MAP_ENTRY);
  FirmwareVolumeHeader->Revision              = EFI_FVH_REVISION;
  FirmwareVolumeHeader->BlockMap[0].NumBlocks = Instance->LastBlock + 1;
  FirmwareVolumeHeader->BlockMap[0].Length    = Instance->BlockSize;
  FirmwareVolumeHeader->BlockMap[1].NumBlocks = 0;
  FirmwareVolumeHeader->BlockMap[1].Length    = 0;
  FirmwareVolumeHeader->Checksum              = CalculateCheckSum16 ((UINT16 *)FirmwareVolumeHeader, FirmwareVolumeHeader->HeaderLength);
 
  //
  // VARIABLE_STORE_HEADER
  //
  VariableStoreHeader = (VARIABLE_STORE_HEADER *)((UINTN)Headers + FirmwareVolumeHeader->HeaderLength);
  CopyGuid (&VariableStoreHeader->Signature, &gEfiAuthenticatedVariableGuid);
  VariableStoreHeader->Size   = PcdGet32 (PcdFlashNvStorageVariableSize) - FirmwareVolumeHeader->HeaderLength;
  VariableStoreHeader->Format = VARIABLE_STORE_FORMATTED;
  VariableStoreHeader->State  = VARIABLE_STORE_HEALTHY;
 
  // Install the combined super-header in the NorFlash
  Status = FvbWrite (&Instance->FvbProtocol, 0, 0, &HeadersLength, Headers);
 
  FreePool (Headers);
  return Status;
}
 
EFI_STATUS
ValidateFvHeader (
  IN  NOR_FLASH_INSTANCE  *Instance
  )
{
  UINT16                            Checksum;
  CONST EFI_FIRMWARE_VOLUME_HEADER  *FwVolHeader;
  CONST VARIABLE_STORE_HEADER       *VariableStoreHeader;
  UINTN                             VarOffset;
  UINTN                             VariableStoreLength;
  UINTN                             FvLength;
 
  FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *)Instance->RegionBaseAddress;
 
  FvLength = PcdGet32 (PcdFlashNvStorageVariableSize) + PcdGet32 (PcdFlashNvStorageFtwWorkingSize) +
             PcdGet32 (PcdFlashNvStorageFtwSpareSize);
 
  //
  // Verify the header revision, header signature, length
  // Length of FvBlock cannot be 2**64-1
  // HeaderLength cannot be an odd number
  //
  if (  (FwVolHeader->Revision  != EFI_FVH_REVISION)
     || (FwVolHeader->Signature != EFI_FVH_SIGNATURE)
     || (FwVolHeader->FvLength  != FvLength)
        )
  {
    DEBUG ((
      DEBUG_INFO,
      "%a: No Firmware Volume header present\n",
      __func__
      ));
    return EFI_NOT_FOUND;
  }
 
  // Check the Firmware Volume Guid
  if ( CompareGuid (&FwVolHeader->FileSystemGuid, &gEfiSystemNvDataFvGuid) == FALSE ) {
    DEBUG ((
      DEBUG_INFO,
      "%a: Firmware Volume Guid non-compatible\n",
      __func__
      ));
    return EFI_NOT_FOUND;
  }
 
  // Verify the header checksum
  Checksum = CalculateSum16 ((UINT16 *)FwVolHeader, FwVolHeader->HeaderLength);
  if (Checksum != 0) {
    DEBUG ((
      DEBUG_INFO,
      "%a: FV checksum is invalid (Checksum:0x%X)\n",
      __func__,
      Checksum
      ));
    return EFI_NOT_FOUND;
  }
 
  VariableStoreHeader = (VARIABLE_STORE_HEADER *)((UINTN)FwVolHeader + FwVolHeader->HeaderLength);
 
  // Check the Variable Store Guid
  if (!CompareGuid (&VariableStoreHeader->Signature, &gEfiAuthenticatedVariableGuid)) {
    DEBUG ((
      DEBUG_INFO,
      "%a: Variable Store Guid non-compatible\n",
      __func__
      ));
    return EFI_NOT_FOUND;
  }
 
  VariableStoreLength = PcdGet32 (PcdFlashNvStorageVariableSize) - FwVolHeader->HeaderLength;
  if (VariableStoreHeader->Size != VariableStoreLength) {
    DEBUG ((
      DEBUG_INFO,
      "%a: Variable Store Length does not match\n",
      __func__
      ));
    return EFI_NOT_FOUND;
  }
 
  //
  // check variables
  //
  DEBUG ((DEBUG_INFO, "%a: checking variables\n", __func__));
  VarOffset = sizeof (*VariableStoreHeader);
  for ( ; ;) {
    UINTN                                VarHeaderEnd;
    UINTN                                VarNameEnd;
    UINTN                                VarEnd;
    UINTN                                VarPadding;
    CONST AUTHENTICATED_VARIABLE_HEADER  *VarHeader;
    CONST CHAR16                         *VarName;
    CONST CHAR8                          *VarState;
    RETURN_STATUS                        Status;
 
    Status = SafeUintnAdd (VarOffset, sizeof (*VarHeader), &VarHeaderEnd);
    if (RETURN_ERROR (Status)) {
      DEBUG ((DEBUG_ERROR, "%a: integer overflow\n", __func__));
      return EFI_NOT_FOUND;
    }
 
    if (VarHeaderEnd >= VariableStoreHeader->Size) {
      if (VarOffset <= VariableStoreHeader->Size - sizeof (UINT16)) {
        CONST UINT16  *StartId;
 
        StartId = (VOID *)((UINTN)VariableStoreHeader + VarOffset);
        if (*StartId == 0x55aa) {
          DEBUG ((DEBUG_ERROR, "%a: startid at invalid location\n", __func__));
          return EFI_NOT_FOUND;
        }
      }
 
      DEBUG ((DEBUG_INFO, "%a: end of var list (no space left)\n", __func__));
      break;
    }
 
    VarHeader = (VOID *)((UINTN)VariableStoreHeader + VarOffset);
    if (VarHeader->StartId != 0x55aa) {
      DEBUG ((DEBUG_INFO, "%a: end of var list (no startid)\n", __func__));
      break;
    }
 
    if (VarHeader->State == 0xff) {
      DEBUG ((DEBUG_INFO, "%a: end of var list (unwritten state)\n", __func__));
      break;
    }
 
    VarName = NULL;
    switch (VarHeader->State) {
      // usage: State = VAR_HEADER_VALID_ONLY
      case VAR_HEADER_VALID_ONLY:
        VarState = "header-ok";
        VarName  = L"<unknown>";
        break;
 
      // usage: State = VAR_ADDED
      case VAR_ADDED:
        VarState = "ok";
        break;
 
      // usage: State &= VAR_IN_DELETED_TRANSITION
      case VAR_ADDED &VAR_IN_DELETED_TRANSITION:
        VarState = "del-in-transition";
        break;
 
      // usage: State &= VAR_DELETED
      case VAR_ADDED &VAR_DELETED:
      case VAR_ADDED &VAR_DELETED &VAR_IN_DELETED_TRANSITION:
        VarState = "deleted";
        break;
 
      default:
        DEBUG ((
          DEBUG_ERROR,
          "%a: invalid variable state: 0x%x\n",
          __func__,
          VarHeader->State
          ));
        return EFI_NOT_FOUND;
    }
 
    Status = SafeUintnAdd (VarHeaderEnd, VarHeader->NameSize, &VarNameEnd);
    if (RETURN_ERROR (Status)) {
      DEBUG ((DEBUG_ERROR, "%a: integer overflow\n", __func__));
      return EFI_NOT_FOUND;
    }
 
    Status = SafeUintnAdd (VarNameEnd, VarHeader->DataSize, &VarEnd);
    if (RETURN_ERROR (Status)) {
      DEBUG ((DEBUG_ERROR, "%a: integer overflow\n", __func__));
      return EFI_NOT_FOUND;
    }
 
    if (VarEnd > VariableStoreHeader->Size) {
      DEBUG ((
        DEBUG_ERROR,
        "%a: invalid variable size: 0x%Lx + 0x%Lx + 0x%x + 0x%x > 0x%x\n",
        __func__,
        (UINT64)VarOffset,
        (UINT64)(sizeof (*VarHeader)),
        VarHeader->NameSize,
        VarHeader->DataSize,
        VariableStoreHeader->Size
        ));
      return EFI_NOT_FOUND;
    }
 
    if (((VarHeader->NameSize & 1) != 0) ||
        (VarHeader->NameSize < 4))
    {
      DEBUG ((DEBUG_ERROR, "%a: invalid name size\n", __func__));
      return EFI_NOT_FOUND;
    }
 
    if (VarName == NULL) {
      VarName = (VOID *)((UINTN)VariableStoreHeader + VarHeaderEnd);
      if (VarName[VarHeader->NameSize / 2 - 1] != L'\0') {
        DEBUG ((DEBUG_ERROR, "%a: name is not null terminated\n", __func__));
        return EFI_NOT_FOUND;
      }
    }
 
    DEBUG ((
      DEBUG_VERBOSE,
      "%a: +0x%04Lx: name=0x%x data=0x%x guid=%g '%s' (%a)\n",
      __func__,
      (UINT64)VarOffset,
      VarHeader->NameSize,
      VarHeader->DataSize,
      &VarHeader->VendorGuid,
      VarName,
      VarState
      ));
 
    VarPadding = (4 - (VarEnd & 3)) & 3;
    Status     = SafeUintnAdd (VarEnd, VarPadding, &VarOffset);
    if (RETURN_ERROR (Status)) {
      DEBUG ((DEBUG_ERROR, "%a: integer overflow\n", __func__));
      return EFI_NOT_FOUND;
    }
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
FvbGetAttributes (
  IN CONST  EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL  *This,
  OUT       EFI_FVB_ATTRIBUTES_2                 *Attributes
  )
{
  EFI_FVB_ATTRIBUTES_2  FlashFvbAttributes;
 
  FlashFvbAttributes = (EFI_FVB_ATTRIBUTES_2)(
 
                                              EFI_FVB2_READ_ENABLED_CAP | // Reads may be enabled
                                              EFI_FVB2_READ_STATUS      | // Reads are currently enabled
                                              EFI_FVB2_STICKY_WRITE     | // A block erase is required to flip bits into EFI_FVB2_ERASE_POLARITY
                                              EFI_FVB2_MEMORY_MAPPED    | // It is memory mapped
                                              EFI_FVB2_ERASE_POLARITY   | // After erasure all bits take this value (i.e. '1')
                                              EFI_FVB2_WRITE_STATUS     | // Writes are currently enabled
                                              EFI_FVB2_WRITE_ENABLED_CAP  // Writes may be enabled
 
                                              );
 
  *Attributes = FlashFvbAttributes;
 
  DEBUG ((DEBUG_BLKIO, "FvbGetAttributes(0x%X)\n", *Attributes));
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
FvbSetAttributes (
  IN CONST  EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL  *This,
  IN OUT    EFI_FVB_ATTRIBUTES_2                 *Attributes
  )
{
  DEBUG ((DEBUG_BLKIO, "FvbSetAttributes(0x%X) is not supported\n", *Attributes));
  return EFI_UNSUPPORTED;
}
 
EFI_STATUS
EFIAPI
FvbGetPhysicalAddress (
  IN CONST  EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL  *This,
  OUT       EFI_PHYSICAL_ADDRESS                 *Address
  )
{
  NOR_FLASH_INSTANCE  *Instance;
 
  Instance = INSTANCE_FROM_FVB_THIS (This);
 
  DEBUG ((DEBUG_BLKIO, "FvbGetPhysicalAddress(BaseAddress=0x%08x)\n", Instance->RegionBaseAddress));
 
  ASSERT (Address != NULL);
 
  *Address = mFlashNvStorageVariableBase;
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
FvbGetBlockSize (
  IN CONST  EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL  *This,
  IN        EFI_LBA                              Lba,
  OUT       UINTN                                *BlockSize,
  OUT       UINTN                                *NumberOfBlocks
  )
{
  EFI_STATUS          Status;
  NOR_FLASH_INSTANCE  *Instance;
 
  Instance = INSTANCE_FROM_FVB_THIS (This);
 
  DEBUG ((DEBUG_BLKIO, "FvbGetBlockSize(Lba=%ld, BlockSize=0x%x, LastBlock=%ld)\n", Lba, Instance->BlockSize, Instance->LastBlock));
 
  if (Lba > Instance->LastBlock) {
    DEBUG ((DEBUG_ERROR, "FvbGetBlockSize: ERROR - Parameter LBA %ld is beyond the last Lba (%ld).\n", Lba, Instance->LastBlock));
    Status = EFI_INVALID_PARAMETER;
  } else {
    // This is easy because in this platform each NorFlash device has equal sized blocks.
    *BlockSize      = (UINTN)Instance->BlockSize;
    *NumberOfBlocks = (UINTN)(Instance->LastBlock - Lba + 1);
 
    DEBUG ((DEBUG_BLKIO, "FvbGetBlockSize: *BlockSize=0x%x, *NumberOfBlocks=0x%x.\n", *BlockSize, *NumberOfBlocks));
 
    Status = EFI_SUCCESS;
  }
 
  return Status;
}
 
EFI_STATUS
EFIAPI
FvbRead (
  IN CONST  EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL  *This,
  IN        EFI_LBA                              Lba,
  IN        UINTN                                Offset,
  IN OUT    UINTN                                *NumBytes,
  IN OUT    UINT8                                *Buffer
  )
{
  EFI_STATUS          TempStatus;
  UINTN               BlockSize;
  NOR_FLASH_INSTANCE  *Instance;
 
  Instance = INSTANCE_FROM_FVB_THIS (This);
 
  DEBUG ((DEBUG_BLKIO, "FvbRead(Parameters: Lba=%ld, Offset=0x%x, *NumBytes=0x%x, Buffer @ 0x%08x)\n", Instance->StartLba + Lba, Offset, *NumBytes, Buffer));
 
  TempStatus = EFI_SUCCESS;
 
  // Cache the block size to avoid de-referencing pointers all the time
  BlockSize = Instance->BlockSize;
 
  DEBUG ((DEBUG_BLKIO, "FvbRead: Check if (Offset=0x%x + NumBytes=0x%x) <= BlockSize=0x%x\n", Offset, *NumBytes, BlockSize));
 
  // The read must not span block boundaries.
  // We need to check each variable individually because adding two large values together overflows.
  if ((Offset               >= BlockSize) ||
      (*NumBytes            >  BlockSize) ||
      ((Offset + *NumBytes) >  BlockSize))
  {
    DEBUG ((DEBUG_ERROR, "FvbRead: ERROR - EFI_BAD_BUFFER_SIZE: (Offset=0x%x + NumBytes=0x%x) > BlockSize=0x%x\n", Offset, *NumBytes, BlockSize));
    return EFI_BAD_BUFFER_SIZE;
  }
 
  // We must have some bytes to read
  if (*NumBytes == 0) {
    return EFI_BAD_BUFFER_SIZE;
  }
 
  // Decide if we are doing full block reads or not.
  if (*NumBytes % BlockSize != 0) {
    TempStatus = NorFlashRead (Instance, Instance->StartLba + Lba, Offset, *NumBytes, Buffer);
    if (EFI_ERROR (TempStatus)) {
      return EFI_DEVICE_ERROR;
    }
  } else {
    // Read NOR Flash data into shadow buffer
    TempStatus = NorFlashReadBlocks (Instance, Instance->StartLba + Lba, BlockSize, Buffer);
    if (EFI_ERROR (TempStatus)) {
      // Return one of the pre-approved error statuses
      return EFI_DEVICE_ERROR;
    }
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
FvbWrite (
  IN CONST  EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL  *This,
  IN        EFI_LBA                              Lba,
  IN        UINTN                                Offset,
  IN OUT    UINTN                                *NumBytes,
  IN        UINT8                                *Buffer
  )
{
  NOR_FLASH_INSTANCE  *Instance;
 
  Instance = INSTANCE_FROM_FVB_THIS (This);
 
  return NorFlashWriteSingleBlock (Instance, Instance->StartLba + Lba, Offset, NumBytes, Buffer);
}
 
EFI_STATUS
EFIAPI
FvbEraseBlocks (
  IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL  *This,
  ...
  )
{
  EFI_STATUS          Status;
  VA_LIST             Args;
  UINTN               BlockAddress; // Physical address of Lba to erase
  EFI_LBA             StartingLba;  // Lba from which we start erasing
  UINTN               NumOfLba;     // Number of Lba blocks to erase
  NOR_FLASH_INSTANCE  *Instance;
 
  Instance = INSTANCE_FROM_FVB_THIS (This);
 
  DEBUG ((DEBUG_BLKIO, "FvbEraseBlocks()\n"));
 
  Status = EFI_SUCCESS;
 
  // Before erasing, check the entire list of parameters to ensure all specified blocks are valid
 
  VA_START (Args, This);
  do {
    // Get the Lba from which we start erasing
    StartingLba = VA_ARG (Args, EFI_LBA);
 
    // Have we reached the end of the list?
    if (StartingLba == EFI_LBA_LIST_TERMINATOR) {
      // Exit the while loop
      break;
    }
 
    // How many Lba blocks are we requested to erase?
    NumOfLba = VA_ARG (Args, UINTN);
 
    // All blocks must be within range
    DEBUG ((
      DEBUG_BLKIO,
      "FvbEraseBlocks: Check if: ( StartingLba=%ld + NumOfLba=%Lu - 1 ) > LastBlock=%ld.\n",
      Instance->StartLba + StartingLba,
      (UINT64)NumOfLba,
      Instance->LastBlock
      ));
    if ((NumOfLba == 0) || ((Instance->StartLba + StartingLba + NumOfLba - 1) > Instance->LastBlock)) {
      VA_END (Args);
      DEBUG ((DEBUG_ERROR, "FvbEraseBlocks: ERROR - Lba range goes past the last Lba.\n"));
      Status = EFI_INVALID_PARAMETER;
      goto EXIT;
    }
  } while (TRUE);
 
  VA_END (Args);
 
  //
  // To get here, all must be ok, so start erasing
  //
  VA_START (Args, This);
  do {
    // Get the Lba from which we start erasing
    StartingLba = VA_ARG (Args, EFI_LBA);
 
    // Have we reached the end of the list?
    if (StartingLba == EFI_LBA_LIST_TERMINATOR) {
      // Exit the while loop
      break;
    }
 
    // How many Lba blocks are we requested to erase?
    NumOfLba = VA_ARG (Args, UINTN);
 
    // Go through each one and erase it
    while (NumOfLba > 0) {
      // Get the physical address of Lba to erase
      BlockAddress = GET_NOR_BLOCK_ADDRESS (
                       Instance->RegionBaseAddress,
                       Instance->StartLba + StartingLba,
                       Instance->BlockSize
                       );
 
      // Erase it
      DEBUG ((DEBUG_BLKIO, "FvbEraseBlocks: Erasing Lba=%ld @ 0x%08x.\n", Instance->StartLba + StartingLba, BlockAddress));
      Status = NorFlashUnlockAndEraseSingleBlock (Instance, BlockAddress);
      if (EFI_ERROR (Status)) {
        VA_END (Args);
        Status = EFI_DEVICE_ERROR;
        goto EXIT;
      }
 
      // Move to the next Lba
      StartingLba++;
      NumOfLba--;
    }
  } while (TRUE);
 
  VA_END (Args);
 
EXIT:
  return Status;
}
 
VOID
EFIAPI
FvbVirtualNotifyEvent (
  IN EFI_EVENT  Event,
  IN VOID       *Context
  )
{
  EfiConvertPointer (0x0, (VOID **)&mFlashNvStorageVariableBase);
  return;
}