path: root/Silicon/Intel/IntelSiliconPkg/Feature/Flash/SpiFvbService/SpiFvbServiceCommon.c

/** @file
  Common driver source for several Serial Flash devices
  which are compliant with the Intel(R) Serial Flash Interface Compatibility Specification.

  Copyright (c) 2017, Intel Corporation. All rights reserved.<BR>
  Copyright (c) Microsoft Corporation.<BR>
  SPDX-License-Identifier: BSD-2-Clause-Patent

**/

#include "SpiFvbServiceCommon.h"

//
// Global variable for this FVB driver  which contains
// the private data of all firmware volume block instances
//
FVB_GLOBAL   mFvbModuleGlobal;

//
// This platform driver knows there are multiple FVs on FD.
// Now we only provide FVs on Variable region and MicorCode region for performance issue.
//
FV_INFO mPlatformFvBaseAddress[] = {
  {0, 0}, // {FixedPcdGet32(PcdFlashNvStorageVariableBase), FixedPcdGet32(PcdFlashNvStorageVariableSize)},
  {0, 0}, // {FixedPcdGet32(PcdFlashMicrocodeFvBase), FixedPcdGet32(PcdFlashMicrocodeFvSize)},
  {0, 0}
};

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
    }
  }
};

//
// Template structure used when installing FVB protocol
//
EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL mFvbProtocolTemplate = {
  FvbProtocolGetAttributes,
  FvbProtocolSetAttributes,
  FvbProtocolGetPhysicalAddress,
  FvbProtocolGetBlockSize,
  FvbProtocolRead,
  FvbProtocolWrite,
  FvbProtocolEraseBlocks,
  NULL
};

/**
  Get the EFI_FVB_ATTRIBUTES_2 of a FV.

  @param[in]  FvbInstance The pointer to the EFI_FVB_INSTANCE.

  @return     Attributes of the FV identified by FvbInstance.
              Zero is returned if the FvbInstance pointer is NULL.

**/
EFI_FVB_ATTRIBUTES_2
FvbGetVolumeAttributes (
  IN CONST  EFI_FVB_INSTANCE    *FvbInstance
  )
{
  if (FvbInstance == NULL) {
    ASSERT (FvbInstance != NULL);
    return 0;
  }

  return FvbInstance->FvHeader.Attributes;
}

/**
  Retrieves the starting address of an LBA in an FV. It also
  return a few other attribut of the FV.

  @param[in]  FvbInstance     The pointer to the EFI_FVB_INSTANCE.
  @param[in]  Lba             The logical block address
  @param[out] LbaAddress      On output, contains the physical starting address
                              of the Lba. This pointer is optional and may be NULL.
  @param[out] LbaLength       On output, contains the length of the block.
                              This pointer is optional and may be NULL.
  @param[out] NumOfBlocks     A pointer to a caller allocated UINTN in which the
                              number of consecutive blocks starting with Lba is
                              returned. All blocks in this range have a size of
                              BlockSize. This pointer is optional and may be NULL.

  @retval   EFI_SUCCESS           Successfully returns
  @retval   EFI_INVALID_PARAMETER FvbInstance is NULL.

**/
EFI_STATUS
FvbGetLbaAddress (
  IN  CONST EFI_FVB_INSTANCE              *FvbInstance,
  IN  EFI_LBA                             Lba,
  OUT UINTN                               *LbaAddress OPTIONAL,
  OUT UINTN                               *LbaLength OPTIONAL,
  OUT UINTN                               *NumOfBlocks OPTIONAL
  )
{
  UINT32                                  NumBlocks;
  UINT32                                  BlockLength;
  UINTN                                   Offset;
  EFI_LBA                                 StartLba;
  EFI_LBA                                 NextLba;
  CONST EFI_FV_BLOCK_MAP_ENTRY            *BlockMap;

  StartLba  = 0;
  Offset    = 0;

  if (FvbInstance == NULL) {
    return EFI_INVALID_PARAMETER;
  }

  BlockMap  = &(FvbInstance->FvHeader.BlockMap[0]);

  //
  // Parse the blockmap of the FV to find which map entry the Lba belongs to
  //
  while (TRUE) {
    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 = FvbInstance->FvBase + Offset;
      }

      if (LbaLength != NULL) {
        *LbaLength = BlockLength;
      }

      if (NumOfBlocks != NULL) {
        *NumOfBlocks = (UINTN)(NextLba - Lba);
      }
      return EFI_SUCCESS;
    }

    StartLba  = NextLba;
    Offset    = Offset + NumBlocks * BlockLength;
    BlockMap++;
  }
}

/**
  Reads specified number of bytes into a buffer from the specified block.

  @param[in]      FvbInstance           The pointer to the EFI_FVB_INSTANCE
  @param[in]      Lba                   The logical block address to be read from
  @param[in]      BlockOffset           Offset into the block at which to begin reading
  @param[in]      NumBytes              Pointer that on input contains the total size of
                                        the buffer. On output, it contains the total number
                                        of bytes read
  @param[in]      Buffer                Pointer to a caller allocated buffer that will be
                                        used to hold the data read

  @retval         EFI_SUCCESS           The firmware volume was read successfully and
                                        contents are in Buffer
  @retval         EFI_BAD_BUFFER_SIZE   Read attempted across a LBA boundary. On output,
                                        NumBytes contains the total number of bytes returned
                                        in Buffer
  @retval         EFI_ACCESS_DENIED     The firmware volume is in the ReadDisabled state
  @retval         EFI_DEVICE_ERROR      The block device is not functioning correctly and
                                        could not be read
  @retval         EFI_INVALID_PARAMETER FvbInstance, NumBytes, and/or Buffer are NULL

**/
EFI_STATUS
FvbReadBlock (
  IN CONST  EFI_FVB_INSTANCE              *FvbInstance,
  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;
  BOOLEAN                                 BadBufferSize = FALSE;

  if ((FvbInstance == NULL) || (NumBytes == NULL) || (Buffer == NULL)) {
    return EFI_INVALID_PARAMETER;
  }

  if (*NumBytes == 0) {
    return EFI_INVALID_PARAMETER;
  }

  Status = FvbGetLbaAddress (FvbInstance, Lba, &LbaAddress, &LbaLength, NULL);
  if (EFI_ERROR(Status)) {
    return Status;
  }

  Attributes = FvbGetVolumeAttributes (FvbInstance);

  if ((Attributes & EFI_FVB2_READ_STATUS) == 0) {
    return EFI_ACCESS_DENIED;
  }

  if (BlockOffset > LbaLength) {
   return EFI_INVALID_PARAMETER;
  }

  if (LbaLength < (*NumBytes + BlockOffset)) {
    DEBUG ((DEBUG_INFO,
      "FvReadBlock: Reducing Numbytes from 0x%x to 0x%x\n",
      *NumBytes,
      (UINT32)(LbaLength - BlockOffset))
      );
    *NumBytes     = (UINT32) (LbaLength - BlockOffset);
    BadBufferSize = TRUE;
  }

  Status = SpiFlashRead (LbaAddress + BlockOffset, (UINT32 *)NumBytes, Buffer);

  if (!EFI_ERROR (Status) && BadBufferSize) {
    return EFI_BAD_BUFFER_SIZE;
  } else {
    return Status;
  }
}

/**
  Writes specified number of bytes from the input buffer to the block.

  @param[in]  FvbInstance           The pointer to the EFI_FVB_INSTANCE
  @param[in]  Lba                   The starting logical block index to write to
  @param[in]  BlockOffset           Offset into the block at which to begin writing
  @param[in]  NumBytes              Pointer that on input contains the total size of
                                    the buffer. On output, it contains the total number
                                    of bytes actually written
  @param[in]  Buffer                Pointer to a caller allocated buffer that contains
                                    the source for the write

  @retval     EFI_SUCCESS           The firmware volume was written successfully
  @retval     EFI_BAD_BUFFER_SIZE   Write attempted across a LBA boundary. On output,
                                    NumBytes contains the total number of bytes
                                    actually written
  @retval     EFI_ACCESS_DENIED     The firmware volume is in the WriteDisabled state
  @retval     EFI_DEVICE_ERROR      The block device is not functioning correctly and
                                    could not be written
  @retval     EFI_INVALID_PARAMETER FvbInstance, NumBytes, and/or Buffer are NULL

**/
EFI_STATUS
FvbWriteBlock (
  IN CONST  EFI_FVB_INSTANCE              *FvbInstance,
  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;
  BOOLEAN                                 BadBufferSize = FALSE;

  if ((FvbInstance == NULL) || (NumBytes == NULL) || (Buffer == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
  if (*NumBytes == 0) {
    return EFI_INVALID_PARAMETER;
  }

  Status = FvbGetLbaAddress (FvbInstance, Lba, &LbaAddress, &LbaLength, NULL);
  if (EFI_ERROR(Status)) {
    return Status;
  }

  //
  // Check if the FV is write enabled
  //
  Attributes = FvbGetVolumeAttributes (FvbInstance);
  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_INFO,
      "FvWriteBlock: Reducing Numbytes from 0x%x to 0x%x\n",
      *NumBytes,
      (UINT32)(LbaLength - BlockOffset))
      );
    *NumBytes     = (UINT32) (LbaLength - BlockOffset);
    BadBufferSize = TRUE;
  }

  Status = SpiFlashWrite (LbaAddress + BlockOffset, (UINT32 *)NumBytes, Buffer);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  Status = SpiFlashLock ();
  if (EFI_ERROR (Status)) {
    return Status;
  }

  WriteBackInvalidateDataCacheRange ((VOID *) (LbaAddress + BlockOffset), *NumBytes);

  if (!EFI_ERROR (Status) && BadBufferSize) {
    return EFI_BAD_BUFFER_SIZE;
  } else {
    return Status;
  }
}

/**
  Erases and initializes a firmware volume block.

  @param[in]    FvbInstance       The pointer to the EFI_FVB_INSTANCE
  @param[in]    Lba               The logical block index to be erased

  @retval   EFI_SUCCESS           The erase request was successfully completed
  @retval   EFI_ACCESS_DENIED     The firmware volume is in the WriteDisabled state
  @retval   EFI_DEVICE_ERROR      The block device is not functioning correctly and
                                  could not be written. Firmware device may have been
                                  partially erased
  @retval   EFI_INVALID_PARAMETER FvbInstance is NULL

**/
EFI_STATUS
FvbEraseBlock (
  IN CONST  EFI_FVB_INSTANCE    *FvbInstance,
  IN        EFI_LBA             Lba
  )
{

  EFI_FVB_ATTRIBUTES_2                    Attributes;
  UINTN                                   LbaAddress;
  UINTN                                   LbaLength;
  EFI_STATUS                              Status;

  if (FvbInstance == NULL) {
    return EFI_INVALID_PARAMETER;
  }

  //
  // Check if the FV is write enabled
  //
  Attributes = FvbGetVolumeAttributes (FvbInstance);

  if( (Attributes & EFI_FVB2_WRITE_STATUS) == 0)  {
    return EFI_ACCESS_DENIED;
  }

  //
  // Get the starting address of the block for erase.
  //
  Status = FvbGetLbaAddress (FvbInstance, Lba, &LbaAddress, &LbaLength, NULL);
  if (EFI_ERROR(Status)) {
    return Status;
  }

  Status = SpiFlashBlockErase (LbaAddress, &LbaLength);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  Status = SpiFlashLock ();
  if (EFI_ERROR (Status)) {
    return Status;
  }

  WriteBackInvalidateDataCacheRange ((VOID *) LbaAddress, LbaLength);

  return Status;
}

/**
  Modifies the current settings of the firmware volume according to the
  input parameter, and returns the new setting of the volume

  @param[in]  FvbInstance           The pointer to the EFI_FVB_INSTANCE.
  @param[in]  Attributes            On input, it is a pointer to EFI_FVB_ATTRIBUTES_2
                                    containing the desired firmware volume settings.
                                    On successful return, it contains the new settings
                                    of the firmware volume

  @retval     EFI_SUCCESS           Successfully returns
  @retval     EFI_ACCESS_DENIED     The volume setting is locked and cannot be modified
  @retval     EFI_INVALID_PARAMETER FvbInstance or Attributes is NULL.
                                    Or the attributes requested are in conflict with the
                                    capabilities as declared in the firmware volume header.

**/
EFI_STATUS
FvbSetVolumeAttributes (
  IN EFI_FVB_INSTANCE                     *FvbInstance,
  IN OUT EFI_FVB_ATTRIBUTES_2             *Attributes
  )
{
  EFI_FVB_ATTRIBUTES_2                      OldAttributes;
  EFI_FVB_ATTRIBUTES_2                      *AttribPtr;
  EFI_FVB_ATTRIBUTES_2                      UnchangedAttributes;
  UINT32                                    Capabilities;
  UINT32                                    OldStatus, NewStatus;

  if ((FvbInstance == NULL) || (Attributes == NULL)) {
    return EFI_INVALID_PARAMETER;
  }

  AttribPtr     = (EFI_FVB_ATTRIBUTES_2 *) &(FvbInstance->FvHeader.Attributes);
  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 ) {
    if ( OldStatus ^ NewStatus ) {
      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) {
      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) {
      return EFI_INVALID_PARAMETER;
    }
  }

  //
  // Test lock
  //
  if ((Capabilities & EFI_FVB2_LOCK_CAP) == 0) {
    if (NewStatus & EFI_FVB2_LOCK_STATUS) {
      return EFI_INVALID_PARAMETER;
    }
  }

  *AttribPtr  = (*AttribPtr) & (0xFFFFFFFF & (~EFI_FVB2_STATUS));
  *AttribPtr  = (*AttribPtr) | NewStatus;
  *Attributes = *AttribPtr;

  return EFI_SUCCESS;
}

/**
  Get the total size of the firmware volume on flash used for variable store operations.

  @param[out] BaseAddress         Base address of the variable store firmware volume.
  @param[out] Length              Length in bytes of the firmware volume used for variable store operations.

**/
VOID
GetVariableFvInfo (
  OUT EFI_PHYSICAL_ADDRESS      *BaseAddress,
  OUT UINT32                    *Length
  )
{
  EFI_STATUS                    Status;
  EFI_PHYSICAL_ADDRESS          NvBaseAddress;
  EFI_PHYSICAL_ADDRESS          NvVariableBaseAddress;
  UINT64                        Length64;
  UINT32                        NvStoreLength;
  UINT32                        FtwSpareLength;
  UINT32                        FtwWorkingLength;
  UINT32                        TotalLength;

  TotalLength = 0;
  Status = EFI_SUCCESS;

  if ((BaseAddress == NULL) || (Length == NULL)) {
    ASSERT ((BaseAddress != NULL) && (Length != NULL));
    return;
  }

  *BaseAddress = 0;
  *Length = 0;

  Status = GetVariableFlashNvStorageInfo (&NvBaseAddress, &Length64);
  if (!EFI_ERROR (Status)) {
    NvVariableBaseAddress = NvBaseAddress;
    // Stay within the current UINT32 size assumptions in the variable stack.
    Status = SafeUint64ToUint32 (Length64, &NvStoreLength);
  }
  if (EFI_ERROR (Status)) {
    ASSERT_EFI_ERROR (Status);
    return;
  }

  //
  // GetVariableFlashNvStorageInfo () only reports regular variable region information,
  // if platform implemented an additional NVS region following the regular variable region,
  // then both region size should be included as overall NVS region size.
  //
  // The below PcdFlashNvStorageAdditionalSize is for compatible with legacy usages that should be deprecated.
  // The new usage model should define separate regions without implicit connections to UEFI Variable or FTW regions.
  //
  // Example NVS flash map for such legacy usage:
  // Note: PcdFlashNvStorageAdditionalSize is equal to platform PcdFlashFvNvStorageEventLogSize.
  //  ---------------
  //  |UEFI Variable|
  //  ---------------
  //  |EventLog     | <= this is Additional NVS region
  //  ---------------
  //  |FTW Working  |
  //  ---------------
  //  |FTW Spare    |
  //  ---------------
  //
  NvStoreLength += PcdGet32 (PcdFlashNvStorageAdditionalSize);

  Status = GetVariableFlashFtwSpareInfo (&NvBaseAddress, &Length64);
  if (!EFI_ERROR (Status)) {
    // Stay within the current UINT32 size assumptions in the variable stack.
    Status = SafeUint64ToUint32 (Length64, &FtwSpareLength);
  }
  if (EFI_ERROR (Status)) {
    ASSERT_EFI_ERROR (Status);
    return;
  }

  Status = GetVariableFlashFtwWorkingInfo (&NvBaseAddress, &Length64);
  if (!EFI_ERROR (Status)) {
    // Stay within the current UINT32 size assumptions in the variable stack.
    Status = SafeUint64ToUint32 (Length64, &FtwWorkingLength);
  }
  if (EFI_ERROR (Status)) {
    ASSERT_EFI_ERROR (Status);
    return;
  }

  Status = SafeUint32Add (NvStoreLength, FtwSpareLength, &TotalLength);
  if (EFI_ERROR (Status)) {
    ASSERT_EFI_ERROR (Status);
    return;
  }

  Status = SafeUint32Add (TotalLength, FtwWorkingLength, &TotalLength);
  if (EFI_ERROR (Status)) {
    ASSERT_EFI_ERROR (Status);
    return;
  }

  *BaseAddress = NvVariableBaseAddress;
  *Length = TotalLength;
}

/**
  Check the integrity of firmware volume header

  @param[in]  FvHeader   A pointer to a firmware volume header

  @retval     TRUE          The firmware volume is consistent.
  @retval     FALSE         The firmware volume has corrupted or an invalid firmware
                            volume was provided.

**/
BOOLEAN
IsFvHeaderValid (
  IN       EFI_PHYSICAL_ADDRESS          FvBase,
  IN CONST EFI_FIRMWARE_VOLUME_HEADER    *FvHeader
  )
{
  EFI_PHYSICAL_ADDRESS    NvStorageFvBaseAddress;
  UINT32                  NvStorageSize;

  if (FvHeader == NULL) {
    ASSERT (FvHeader != NULL);
    return FALSE;
  }

  GetVariableFvInfo (&NvStorageFvBaseAddress, &NvStorageSize);

  if (FvBase == NvStorageFvBaseAddress) {
    if (CompareMem (&FvHeader->FileSystemGuid, &gEfiSystemNvDataFvGuid, sizeof(EFI_GUID)) != 0 ) {
      return FALSE;
    }
  } else {
    if (CompareMem (&FvHeader->FileSystemGuid, &gEfiFirmwareFileSystem2Guid, sizeof(EFI_GUID)) != 0 ) {
      return FALSE;
    }
  }
  if ( (FvHeader->Revision != EFI_FVH_REVISION)   ||
       (FvHeader->Signature != EFI_FVH_SIGNATURE) ||
       (FvHeader->FvLength == ((UINTN) -1))       ||
       ((FvHeader->HeaderLength & 0x01 ) !=0) )  {
    return FALSE;
  }

  if (CalculateCheckSum16 ((UINT16 *) FvHeader, FvHeader->HeaderLength) != 0) {
    return FALSE;
  }

  return TRUE;
}

//
// FVB protocol APIs
//

/**
  Retrieves the physical address of the device.

  @param[in]  This    A pointer to EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL.
  @param[out] Address Output buffer containing the address.

  @retval   EFI_SUCCESS             The function always return successfully.
  @retval   EFI_INVALID_PARAMETER   A pointer argument provided is NULL.

**/
EFI_STATUS
EFIAPI
FvbProtocolGetPhysicalAddress (
  IN CONST  EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL    *This,
  OUT       EFI_PHYSICAL_ADDRESS                  *Address
  )
{
  EFI_FVB_INSTANCE      *FvbInstance;

  if ((This == NULL) || (Address == NULL)) {
    return EFI_INVALID_PARAMETER;
  }

  FvbInstance = FVB_INSTANCE_FROM_THIS (This);

  *Address = FvbInstance->FvBase;

  return EFI_SUCCESS;
}

/**
  Retrieve the size of a logical block

  @param[in]  This        Calling context
  @param[in]  Lba         Indicates which block to return the size for.
  @param[out] BlockSize   A pointer to a caller allocated UINTN in which
                          the size of the block is returned
  @param[out] NumOfBlocks A pointer to a caller allocated UINTN in which the
                          number of consecutive blocks starting with Lba is
                          returned. All blocks in this range have a size of
                          BlockSize

  @retval     EFI_SUCCESS             The function always return successfully.
  @retval     EFI_INVALID_PARAMETER   A pointer argument provided is NULL.

**/
EFI_STATUS
EFIAPI
FvbProtocolGetBlockSize (
  IN CONST  EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL    *This,
  IN        EFI_LBA                               Lba,
  OUT       UINTN                                 *BlockSize,
  OUT       UINTN                                 *NumOfBlocks
  )
{
  EFI_FVB_INSTANCE                 *FvbInstance;

  if ((This == NULL) || (BlockSize == NULL) || (NumOfBlocks == NULL)) {
    return EFI_INVALID_PARAMETER;
  }

  FvbInstance = FVB_INSTANCE_FROM_THIS (This);

  DEBUG ((
    DEBUG_INFO,
    "FvbProtocolGetBlockSize: Lba: 0x%lx BlockSize: 0x%x NumOfBlocks: 0x%x\n",
    Lba,
    *BlockSize,
    *NumOfBlocks
    ));

  return FvbGetLbaAddress (
           FvbInstance,
           Lba,
           NULL,
           BlockSize,
           NumOfBlocks
           );
}

/**
  Retrieves Volume attributes.  No polarity translations are done.

  @param[in]    This        Calling context
  @param[out]   Attributes  Output buffer which contains attributes

  @retval       EFI_SUCCESS             The function always return successfully.
  @retval       EFI_INVALID_PARAMETER   A pointer argument provided is NULL.

**/
EFI_STATUS
EFIAPI
FvbProtocolGetAttributes (
  IN CONST  EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL   *This,
  OUT       EFI_FVB_ATTRIBUTES_2                 *Attributes
  )
{
  EFI_FVB_INSTANCE                 *FvbInstance;

  if ((This == NULL) || (Attributes == NULL)) {
    return EFI_INVALID_PARAMETER;
  }

  FvbInstance = FVB_INSTANCE_FROM_THIS (This);

  *Attributes = FvbGetVolumeAttributes (FvbInstance);

  DEBUG ((
    DEBUG_INFO,
    "FvbProtocolGetAttributes: This: 0x%x Attributes: 0x%x\n",
    This,
    *Attributes
    ));

  return EFI_SUCCESS;
}

/**
  Sets Volume attributes. No polarity translations are done.

  @param[in]  This        Calling context
  @param[out] Attributes  Output buffer which contains attributes

  @retval     EFI_SUCCESS The function always return successfully.

**/
EFI_STATUS
EFIAPI
FvbProtocolSetAttributes (
  IN CONST  EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL   *This,
  IN OUT    EFI_FVB_ATTRIBUTES_2                 *Attributes
  )
{
  EFI_STATUS                       Status;
  EFI_FVB_INSTANCE                 *FvbInstance;

  if ((This == NULL) || (Attributes == NULL)) {
    return EFI_INVALID_PARAMETER;
  }

  DEBUG ((
    DEBUG_INFO,
    "FvbProtocolSetAttributes: Before SET -  This: 0x%x Attributes: 0x%x\n",
    This,
    *Attributes
    ));

  FvbInstance  = FVB_INSTANCE_FROM_THIS (This);

  Status = FvbSetVolumeAttributes (FvbInstance, Attributes);

  DEBUG ((
    DEBUG_INFO,
    "FvbProtocolSetAttributes: After SET -  This: 0x%x Attributes: 0x%x\n",
    This,
    *Attributes
    ));

  return Status;
}

/**
  The EraseBlock() function erases one or more blocks as denoted by the
  variable argument list. The entire parameter list of blocks must be verified
  prior to erasing any blocks.  If a block is requested that does not exist
  within the associated firmware volume (it has a larger index than the last
  block of the firmware volume), the EraseBlock() function must return
  EFI_INVALID_PARAMETER without modifying the contents of the firmware volume.

  @param[in] This         Calling context
  @param[in] ...          Starting LBA followed by Number of Lba to erase.
                          a -1 to terminate the list.

  @retval EFI_SUCCESS             The erase request was successfully completed
  @retval EFI_INVALID_PARAMETER   A pointer argument provided is NULL.
  @retval EFI_ACCESS_DENIED       The firmware volume is in the WriteDisabled state
  @retval EFI_DEVICE_ERROR        The block device is not functioning correctly and
                                  could not be written. Firmware device may have been
                                  partially erased

**/
EFI_STATUS
EFIAPI
FvbProtocolEraseBlocks (
  IN CONST  EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL    *This,
  ...
  )
{
  EFI_FVB_INSTANCE                      *FvbInstance;
  UINTN                                 NumOfBlocks;
  VA_LIST                               Args;
  EFI_LBA                               StartingLba;
  UINTN                                 NumOfLba;
  EFI_STATUS                            Status;

  DEBUG((DEBUG_INFO, "FvbProtocolEraseBlocks: \n"));

  if (This == NULL) {
    return EFI_INVALID_PARAMETER;
  }

  FvbInstance  = FVB_INSTANCE_FROM_THIS (This);

  NumOfBlocks = FvbInstance->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 (FvbInstance, StartingLba);
      if ( EFI_ERROR(Status)) {
        VA_END (Args);
        return Status;
      }
      StartingLba ++;
      NumOfLba --;
    }

  } while ( 1 );

  VA_END (Args);

  return EFI_SUCCESS;
}

/**
  Writes data beginning at Lba:Offset from FV. The write terminates either
  when *NumBytes of data have been written, or when a block boundary is
  reached.  *NumBytes is updated to reflect the actual number of bytes
  written. The write opertion does not include erase. This routine will
  attempt to write only the specified bytes. If the writes do not stick,
  it will return an error.

  @param[in]      This      Calling context
  @param[in]      Lba       Block in which to begin write
  @param[in]      Offset    Offset in the block at which to begin write
  @param[in,out]  NumBytes  On input, indicates the requested write size. On
                            output, indicates the actual number of bytes written
  @param[in]      Buffer    Buffer containing source data for the write.

  @retval EFI_SUCCESS           The firmware volume was written successfully
  @retval EFI_BAD_BUFFER_SIZE   Write attempted across a LBA boundary. On output,
                                NumBytes contains the total number of bytes
                                actually written
  @retval EFI_ACCESS_DENIED     The firmware volume is in the WriteDisabled state
  @retval EFI_DEVICE_ERROR      The block device is not functioning correctly and
                                could not be written
  @retval EFI_INVALID_PARAMETER A pointer argument provided is NULL.

**/
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_FVB_INSTANCE        *FvbInstance;

  if ((This == NULL) || (NumBytes == NULL) || (Buffer == NULL)) {
    return EFI_INVALID_PARAMETER;
  }

  FvbInstance = FVB_INSTANCE_FROM_THIS (This);

  DEBUG ((
    DEBUG_INFO,
    "FvbProtocolWrite: Lba: 0x%lx Offset: 0x%x NumBytes: 0x%x, Buffer: 0x%x\n",
    Lba,
    Offset,
    *NumBytes,
    Buffer
    ));

  return FvbWriteBlock (FvbInstance, Lba, Offset, NumBytes, Buffer);
}

/**
  Reads data beginning at Lba:Offset from FV. The Read terminates either
  when *NumBytes of data have been read, or when a block boundary is
  reached.  *NumBytes is updated to reflect the actual number of bytes
  written. The write opertion does not include erase. This routine will
  attempt to write only the specified bytes. If the writes do not stick,
  it will return an error.

  @param[in]      This      Calling context
  @param[in]      Lba       Block in which to begin write
  @param[in]      Offset    Offset in the block at which to begin write
  @param[in,out]  NumBytes  On input, indicates the requested write size. On
                            output, indicates the actual number of bytes written
  @param[in]      Buffer    Buffer containing source data for the write.

  @retval EFI_SUCCESS           The firmware volume was read successfully and
                                contents are in Buffer
  @retval EFI_BAD_BUFFER_SIZE   Read attempted across a LBA boundary. On output,
                                NumBytes contains the total number of bytes returned
                                in Buffer
  @retval EFI_ACCESS_DENIED     The firmware volume is in the ReadDisabled state
  @retval EFI_DEVICE_ERROR      The block device is not functioning correctly and
                                could not be read
  @retval EFI_INVALID_PARAMETER A pointer argument provided is NULL.

**/
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_FVB_INSTANCE     *FvbInstance;
  EFI_STATUS           Status;

  if ((This == NULL) || (NumBytes == NULL) || (Buffer == NULL)) {
    return EFI_INVALID_PARAMETER;
  }

  FvbInstance = FVB_INSTANCE_FROM_THIS (This);
  Status = FvbReadBlock (FvbInstance, Lba, Offset, NumBytes, Buffer);
  DEBUG ((
    DEBUG_INFO,
    "FvbProtocolRead: Lba: 0x%lx Offset: 0x%x NumBytes: 0x%x, Buffer: 0x%x\n",
    Lba,
    Offset,
    *NumBytes,
    Buffer
    ));

  return Status;
}