[mirror_edk2.git] / MdeModulePkg / Core / Dxe / FwVolBlock / FwVolBlock.c

/** @file\r
  Implementations for Firmware Volume Block protocol.\r
\r
  It consumes FV HOBs and creates read-only Firmare Volume Block protocol\r
  instances for each of them.\r
\r
Copyright (c) 2006 - 2018, Intel Corporation. All rights reserved.<BR>\r
SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#include "DxeMain.h"\r
#include "FwVolBlock.h"\r
\r
FV_MEMMAP_DEVICE_PATH  mFvMemmapDevicePathTemplate = {\r
  {\r
    {\r
      HARDWARE_DEVICE_PATH,\r
      HW_MEMMAP_DP,\r
      {\r
        (UINT8)(sizeof (MEMMAP_DEVICE_PATH)),\r
        (UINT8)(sizeof (MEMMAP_DEVICE_PATH) >> 8)\r
      }\r
    },\r
    EfiMemoryMappedIO,\r
    (EFI_PHYSICAL_ADDRESS)0,\r
    (EFI_PHYSICAL_ADDRESS)0,\r
  },\r
  {\r
    END_DEVICE_PATH_TYPE,\r
    END_ENTIRE_DEVICE_PATH_SUBTYPE,\r
    {\r
      END_DEVICE_PATH_LENGTH,\r
      0\r
    }\r
  }\r
};\r
\r
FV_PIWG_DEVICE_PATH  mFvPIWGDevicePathTemplate = {\r
  {\r
    {\r
      MEDIA_DEVICE_PATH,\r
      MEDIA_PIWG_FW_VOL_DP,\r
      {\r
        (UINT8)(sizeof (MEDIA_FW_VOL_DEVICE_PATH)),\r
        (UINT8)(sizeof (MEDIA_FW_VOL_DEVICE_PATH) >> 8)\r
      }\r
    },\r
    { 0 }\r
  },\r
  {\r
    END_DEVICE_PATH_TYPE,\r
    END_ENTIRE_DEVICE_PATH_SUBTYPE,\r
    {\r
      END_DEVICE_PATH_LENGTH,\r
      0\r
    }\r
  }\r
};\r
\r
EFI_FW_VOL_BLOCK_DEVICE  mFwVolBlock = {\r
  FVB_DEVICE_SIGNATURE,\r
  NULL,\r
  NULL,\r
  {\r
    FwVolBlockGetAttributes,\r
    (EFI_FVB_SET_ATTRIBUTES)FwVolBlockSetAttributes,\r
    FwVolBlockGetPhysicalAddress,\r
    FwVolBlockGetBlockSize,\r
    FwVolBlockReadBlock,\r
    (EFI_FVB_WRITE)FwVolBlockWriteBlock,\r
    (EFI_FVB_ERASE_BLOCKS)FwVolBlockEraseBlock,\r
    NULL\r
  },\r
  0,\r
  NULL,\r
  0,\r
  0,\r
  0\r
};\r
\r
/**\r
  Retrieves Volume attributes.  No polarity translations are done.\r
\r
  @param  This                   Calling context\r
  @param  Attributes             output buffer which contains attributes\r
\r
  @retval EFI_SUCCESS            The firmware volume attributes were returned.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
FwVolBlockGetAttributes (\r
  IN CONST  EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL  *This,\r
  OUT       EFI_FVB_ATTRIBUTES_2                *Attributes\r
  )\r
{\r
  EFI_FW_VOL_BLOCK_DEVICE  *FvbDevice;\r
\r
  FvbDevice = FVB_DEVICE_FROM_THIS (This);\r
\r
  //\r
  // Since we are read only, it's safe to get attributes data from our in-memory copy.\r
  //\r
  *Attributes = FvbDevice->FvbAttributes & ~EFI_FVB2_WRITE_STATUS;\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Modifies the current settings of the firmware volume according to the input parameter.\r
\r
  @param  This                   Calling context\r
  @param  Attributes             input buffer which contains attributes\r
\r
  @retval EFI_SUCCESS            The firmware volume attributes were returned.\r
  @retval EFI_INVALID_PARAMETER  The attributes requested are in conflict with\r
                                 the capabilities as declared in the firmware\r
                                 volume header.\r
  @retval EFI_UNSUPPORTED        Not supported.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
FwVolBlockSetAttributes (\r
  IN CONST  EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL  *This,\r
  IN CONST  EFI_FVB_ATTRIBUTES_2                *Attributes\r
  )\r
{\r
  return EFI_UNSUPPORTED;\r
}\r
\r
/**\r
  The EraseBlock() function erases one or more blocks as denoted by the\r
  variable argument list. The entire parameter list of blocks must be verified\r
  prior to erasing any blocks.  If a block is requested that does not exist\r
  within the associated firmware volume (it has a larger index than the last\r
  block of the firmware volume), the EraseBlock() function must return\r
  EFI_INVALID_PARAMETER without modifying the contents of the firmware volume.\r
\r
  @param  This                   Calling context\r
  @param  ...                    Starting LBA followed by Number of Lba to erase.\r
                                 a -1 to terminate the list.\r
\r
  @retval EFI_SUCCESS            The erase request was successfully completed.\r
  @retval EFI_ACCESS_DENIED      The firmware volume is in the WriteDisabled\r
                                 state.\r
  @retval EFI_DEVICE_ERROR       The block device is not functioning correctly\r
                                 and could not be written. The firmware device\r
                                 may have been partially erased.\r
  @retval EFI_INVALID_PARAMETER  One or more of the LBAs listed in the variable\r
                                 argument list do\r
  @retval EFI_UNSUPPORTED        Not supported.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
FwVolBlockEraseBlock (\r
  IN EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL  *This,\r
  ...\r
  )\r
{\r
  return EFI_UNSUPPORTED;\r
}\r
\r
/**\r
  Read the specified number of bytes from the block to the input buffer.\r
\r
  @param  This                   Indicates the calling context.\r
  @param  Lba                    The starting logical block index to read.\r
  @param  Offset                 Offset into the block at which to begin reading.\r
  @param  NumBytes               Pointer to a UINT32. At entry, *NumBytes\r
                                 contains the total size of the buffer. At exit,\r
                                 *NumBytes contains the total number of bytes\r
                                 actually read.\r
  @param  Buffer                 Pinter to a caller-allocated buffer that\r
                                 contains the destine for the read.\r
\r
  @retval EFI_SUCCESS            The firmware volume was read successfully.\r
  @retval EFI_BAD_BUFFER_SIZE    The read was attempted across an LBA boundary.\r
  @retval EFI_ACCESS_DENIED      Access denied.\r
  @retval EFI_DEVICE_ERROR       The block device is malfunctioning and could not\r
                                 be read.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
FwVolBlockReadBlock (\r
  IN CONST  EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL  *This,\r
  IN CONST  EFI_LBA                             Lba,\r
  IN CONST  UINTN                               Offset,\r
  IN OUT    UINTN                               *NumBytes,\r
  IN OUT    UINT8                               *Buffer\r
  )\r
{\r
  EFI_FW_VOL_BLOCK_DEVICE     *FvbDevice;\r
  EFI_FIRMWARE_VOLUME_HEADER  *FwVolHeader;\r
  UINT8                       *LbaOffset;\r
  UINTN                       LbaStart;\r
  UINTN                       NumOfBytesRead;\r
  UINTN                       LbaIndex;\r
\r
  FvbDevice = FVB_DEVICE_FROM_THIS (This);\r
\r
  //\r
  // Check if This FW can be read\r
  //\r
  if ((FvbDevice->FvbAttributes & EFI_FVB2_READ_STATUS) == 0) {\r
    return EFI_ACCESS_DENIED;\r
  }\r
\r
  LbaIndex = (UINTN)Lba;\r
  if (LbaIndex >= FvbDevice->NumBlocks) {\r
    //\r
    // Invalid Lba, read nothing.\r
    //\r
    *NumBytes = 0;\r
    return EFI_BAD_BUFFER_SIZE;\r
  }\r
\r
  if (Offset > FvbDevice->LbaCache[LbaIndex].Length) {\r
    //\r
    // all exceed boundary, read nothing.\r
    //\r
    *NumBytes = 0;\r
    return EFI_BAD_BUFFER_SIZE;\r
  }\r
\r
  NumOfBytesRead = *NumBytes;\r
  if (Offset + NumOfBytesRead > FvbDevice->LbaCache[LbaIndex].Length) {\r
    //\r
    // partial exceed boundary, read data from current postion to end.\r
    //\r
    NumOfBytesRead = FvbDevice->LbaCache[LbaIndex].Length - Offset;\r
  }\r
\r
  LbaStart    = FvbDevice->LbaCache[LbaIndex].Base;\r
  FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *)((UINTN)FvbDevice->BaseAddress);\r
  LbaOffset   = (UINT8 *)FwVolHeader + LbaStart + Offset;\r
\r
  //\r
  // Perform read operation\r
  //\r
  CopyMem (Buffer, LbaOffset, NumOfBytesRead);\r
\r
  if (NumOfBytesRead == *NumBytes) {\r
    return EFI_SUCCESS;\r
  }\r
\r
  *NumBytes = NumOfBytesRead;\r
  return EFI_BAD_BUFFER_SIZE;\r
}\r
\r
/**\r
  Writes the specified number of bytes from the input buffer to the block.\r
\r
  @param  This                   Indicates the calling context.\r
  @param  Lba                    The starting logical block index to write to.\r
  @param  Offset                 Offset into the block at which to begin writing.\r
  @param  NumBytes               Pointer to a UINT32. At entry, *NumBytes\r
                                 contains the total size of the buffer. At exit,\r
                                 *NumBytes contains the total number of bytes\r
                                 actually written.\r
  @param  Buffer                 Pinter to a caller-allocated buffer that\r
                                 contains the source for the write.\r
\r
  @retval EFI_SUCCESS            The firmware volume was written successfully.\r
  @retval EFI_BAD_BUFFER_SIZE    The write was attempted across an LBA boundary.\r
                                 On output, NumBytes contains the total number of\r
                                 bytes actually written.\r
  @retval EFI_ACCESS_DENIED      The firmware volume is in the WriteDisabled\r
                                 state.\r
  @retval EFI_DEVICE_ERROR       The block device is malfunctioning and could not\r
                                 be written.\r
  @retval EFI_UNSUPPORTED        Not supported.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
FwVolBlockWriteBlock (\r
  IN     EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL  *This,\r
  IN     EFI_LBA                             Lba,\r
  IN     UINTN                               Offset,\r
  IN OUT UINTN                               *NumBytes,\r
  IN     UINT8                               *Buffer\r
  )\r
{\r
  return EFI_UNSUPPORTED;\r
}\r
\r
/**\r
  Get Fvb's base address.\r
\r
  @param  This                   Indicates the calling context.\r
  @param  Address                Fvb device base address.\r
\r
  @retval EFI_SUCCESS            Successfully got Fvb's base address.\r
  @retval EFI_UNSUPPORTED        Not supported.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
FwVolBlockGetPhysicalAddress (\r
  IN CONST  EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL  *This,\r
  OUT       EFI_PHYSICAL_ADDRESS                *Address\r
  )\r
{\r
  EFI_FW_VOL_BLOCK_DEVICE  *FvbDevice;\r
\r
  FvbDevice = FVB_DEVICE_FROM_THIS (This);\r
\r
  if ((FvbDevice->FvbAttributes & EFI_FVB2_MEMORY_MAPPED) != 0) {\r
    *Address = FvbDevice->BaseAddress;\r
    return EFI_SUCCESS;\r
  }\r
\r
  return EFI_UNSUPPORTED;\r
}\r
\r
/**\r
  Retrieves the size in bytes of a specific block within a firmware volume.\r
\r
  @param  This                   Indicates the calling context.\r
  @param  Lba                    Indicates the block for which to return the\r
                                 size.\r
  @param  BlockSize              Pointer to a caller-allocated UINTN in which the\r
                                 size of the block is returned.\r
  @param  NumberOfBlocks         Pointer to a caller-allocated UINTN in which the\r
                                 number of consecutive blocks starting with Lba\r
                                 is returned. All blocks in this range have a\r
                                 size of BlockSize.\r
\r
  @retval EFI_SUCCESS            The firmware volume base address is returned.\r
  @retval EFI_INVALID_PARAMETER  The requested LBA is out of range.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
FwVolBlockGetBlockSize (\r
  IN CONST  EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL  *This,\r
  IN CONST  EFI_LBA                             Lba,\r
  IN OUT    UINTN                               *BlockSize,\r
  IN OUT    UINTN                               *NumberOfBlocks\r
  )\r
{\r
  UINTN                       TotalBlocks;\r
  EFI_FW_VOL_BLOCK_DEVICE     *FvbDevice;\r
  EFI_FV_BLOCK_MAP_ENTRY      *PtrBlockMapEntry;\r
  EFI_FIRMWARE_VOLUME_HEADER  *FwVolHeader;\r
\r
  FvbDevice = FVB_DEVICE_FROM_THIS (This);\r
\r
  //\r
  // Do parameter checking\r
  //\r
  if (Lba >= FvbDevice->NumBlocks) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *)((UINTN)FvbDevice->BaseAddress);\r
\r
  PtrBlockMapEntry = FwVolHeader->BlockMap;\r
\r
  //\r
  // Search the block map for the given block\r
  //\r
  TotalBlocks = 0;\r
  while ((PtrBlockMapEntry->NumBlocks != 0) || (PtrBlockMapEntry->Length != 0)) {\r
    TotalBlocks += PtrBlockMapEntry->NumBlocks;\r
    if (Lba < TotalBlocks) {\r
      //\r
      // We find the range\r
      //\r
      break;\r
    }\r
\r
    PtrBlockMapEntry++;\r
  }\r
\r
  *BlockSize      = PtrBlockMapEntry->Length;\r
  *NumberOfBlocks = TotalBlocks - (UINTN)Lba;\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
\r
  Get FVB authentication status\r
\r
  @param FvbProtocol    FVB protocol.\r
\r
  @return Authentication status.\r
\r
**/\r
UINT32\r
GetFvbAuthenticationStatus (\r
  IN EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL  *FvbProtocol\r
  )\r
{\r
  EFI_FW_VOL_BLOCK_DEVICE  *FvbDevice;\r
  UINT32                   AuthenticationStatus;\r
\r
  AuthenticationStatus = 0;\r
  FvbDevice            = BASE_CR (FvbProtocol, EFI_FW_VOL_BLOCK_DEVICE, FwVolBlockInstance);\r
  if (FvbDevice->Signature == FVB_DEVICE_SIGNATURE) {\r
    AuthenticationStatus = FvbDevice->AuthenticationStatus;\r
  }\r
\r
  return AuthenticationStatus;\r
}\r
\r
/**\r
  This routine produces a firmware volume block protocol on a given\r
  buffer.\r
\r
  @param  BaseAddress            base address of the firmware volume image\r
  @param  Length                 length of the firmware volume image\r
  @param  ParentHandle           handle of parent firmware volume, if this image\r
                                 came from an FV image file and section in another firmware\r
                                 volume (ala capsules)\r
  @param  AuthenticationStatus   Authentication status inherited, if this image\r
                                 came from an FV image file and section in another firmware volume.\r
  @param  FvProtocol             Firmware volume block protocol produced.\r
\r
  @retval EFI_VOLUME_CORRUPTED   Volume corrupted.\r
  @retval EFI_OUT_OF_RESOURCES   No enough buffer to be allocated.\r
  @retval EFI_SUCCESS            Successfully produced a FVB protocol on given\r
                                 buffer.\r
\r
**/\r
EFI_STATUS\r
ProduceFVBProtocolOnBuffer (\r
  IN EFI_PHYSICAL_ADDRESS  BaseAddress,\r
  IN UINT64                Length,\r
  IN EFI_HANDLE            ParentHandle,\r
  IN UINT32                AuthenticationStatus,\r
  OUT EFI_HANDLE           *FvProtocol  OPTIONAL\r
  )\r
{\r
  EFI_STATUS                  Status;\r
  EFI_FW_VOL_BLOCK_DEVICE     *FvbDev;\r
  EFI_FIRMWARE_VOLUME_HEADER  *FwVolHeader;\r
  UINTN                       BlockIndex;\r
  UINTN                       BlockIndex2;\r
  UINTN                       LinearOffset;\r
  UINT32                      FvAlignment;\r
  EFI_FV_BLOCK_MAP_ENTRY      *PtrBlockMapEntry;\r
\r
  FvAlignment = 0;\r
  FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *)(UINTN)BaseAddress;\r
  //\r
  // Validate FV Header, if not as expected, return\r
  //\r
  if (FwVolHeader->Signature != EFI_FVH_SIGNATURE) {\r
    return EFI_VOLUME_CORRUPTED;\r
  }\r
\r
  //\r
  // If EFI_FVB2_WEAK_ALIGNMENT is set in the volume header then the first byte of the volume\r
  // can be aligned on any power-of-two boundary. A weakly aligned volume can not be moved from\r
  // its initial linked location and maintain its alignment.\r
  //\r
  if ((FwVolHeader->Attributes & EFI_FVB2_WEAK_ALIGNMENT) != EFI_FVB2_WEAK_ALIGNMENT) {\r
    //\r
    // Get FvHeader alignment\r
    //\r
    FvAlignment = 1 << ((FwVolHeader->Attributes & EFI_FVB2_ALIGNMENT) >> 16);\r
    //\r
    // FvAlignment must be greater than or equal to 8 bytes of the minimum FFS alignment value.\r
    //\r
    if (FvAlignment < 8) {\r
      FvAlignment = 8;\r
    }\r
\r
    if ((UINTN)BaseAddress % FvAlignment != 0) {\r
      //\r
      // FvImage buffer is not at its required alignment.\r
      //\r
      DEBUG ((\r
        DEBUG_ERROR,\r
        "Unaligned FvImage found at 0x%lx:0x%lx, the required alignment is 0x%x\n",\r
        BaseAddress,\r
        Length,\r
        FvAlignment\r
        ));\r
      return EFI_VOLUME_CORRUPTED;\r
    }\r
  }\r
\r
  //\r
  // Allocate EFI_FW_VOL_BLOCK_DEVICE\r
  //\r
  FvbDev = AllocateCopyPool (sizeof (EFI_FW_VOL_BLOCK_DEVICE), &mFwVolBlock);\r
  if (FvbDev == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  FvbDev->BaseAddress                     = BaseAddress;\r
  FvbDev->FvbAttributes                   = FwVolHeader->Attributes;\r
  FvbDev->FwVolBlockInstance.ParentHandle = ParentHandle;\r
  FvbDev->AuthenticationStatus            = AuthenticationStatus;\r
\r
  //\r
  // Init the block caching fields of the device\r
  // First, count the number of blocks\r
  //\r
  FvbDev->NumBlocks = 0;\r
  for (PtrBlockMapEntry = FwVolHeader->BlockMap;\r
       PtrBlockMapEntry->NumBlocks != 0;\r
       PtrBlockMapEntry++)\r
  {\r
    FvbDev->NumBlocks += PtrBlockMapEntry->NumBlocks;\r
  }\r
\r
  //\r
  // Second, allocate the cache\r
  //\r
  if (FvbDev->NumBlocks >= (MAX_ADDRESS / sizeof (LBA_CACHE))) {\r
    CoreFreePool (FvbDev);\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  FvbDev->LbaCache = AllocatePool (FvbDev->NumBlocks * sizeof (LBA_CACHE));\r
  if (FvbDev->LbaCache == NULL) {\r
    CoreFreePool (FvbDev);\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  //\r
  // Last, fill in the cache with the linear address of the blocks\r
  //\r
  BlockIndex   = 0;\r
  LinearOffset = 0;\r
  for (PtrBlockMapEntry = FwVolHeader->BlockMap;\r
       PtrBlockMapEntry->NumBlocks != 0; PtrBlockMapEntry++)\r
  {\r
    for (BlockIndex2 = 0; BlockIndex2 < PtrBlockMapEntry->NumBlocks; BlockIndex2++) {\r
      FvbDev->LbaCache[BlockIndex].Base   = LinearOffset;\r
      FvbDev->LbaCache[BlockIndex].Length = PtrBlockMapEntry->Length;\r
      LinearOffset                       += PtrBlockMapEntry->Length;\r
      BlockIndex++;\r
    }\r
  }\r
\r
  //\r
  // Judget whether FV name guid is produced in Fv extension header\r
  //\r
  if (FwVolHeader->ExtHeaderOffset == 0) {\r
    //\r
    // FV does not contains extension header, then produce MEMMAP_DEVICE_PATH\r
    //\r
    FvbDev->DevicePath = (EFI_DEVICE_PATH_PROTOCOL *)AllocateCopyPool (sizeof (FV_MEMMAP_DEVICE_PATH), &mFvMemmapDevicePathTemplate);\r
    if (FvbDev->DevicePath == NULL) {\r
      FreePool (FvbDev);\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
\r
    ((FV_MEMMAP_DEVICE_PATH *)FvbDev->DevicePath)->MemMapDevPath.StartingAddress = BaseAddress;\r
    ((FV_MEMMAP_DEVICE_PATH *)FvbDev->DevicePath)->MemMapDevPath.EndingAddress   = BaseAddress + FwVolHeader->FvLength - 1;\r
  } else {\r
    //\r
    // FV contains extension header, then produce MEDIA_FW_VOL_DEVICE_PATH\r
    //\r
    FvbDev->DevicePath = (EFI_DEVICE_PATH_PROTOCOL *)AllocateCopyPool (sizeof (FV_PIWG_DEVICE_PATH), &mFvPIWGDevicePathTemplate);\r
    if (FvbDev->DevicePath == NULL) {\r
      FreePool (FvbDev);\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
\r
    CopyGuid (\r
      &((FV_PIWG_DEVICE_PATH *)FvbDev->DevicePath)->FvDevPath.FvName,\r
      (GUID *)(UINTN)(BaseAddress + FwVolHeader->ExtHeaderOffset)\r
      );\r
  }\r
\r
  //\r
  //\r
  // Attach FvVolBlock Protocol to new handle\r
  //\r
  Status = CoreInstallMultipleProtocolInterfaces (\r
             &FvbDev->Handle,\r
             &gEfiFirmwareVolumeBlockProtocolGuid,\r
             &FvbDev->FwVolBlockInstance,\r
             &gEfiDevicePathProtocolGuid,\r
             FvbDev->DevicePath,\r
             NULL\r
             );\r
\r
  //\r
  // If they want the handle back, set it.\r
  //\r
  if (FvProtocol != NULL) {\r
    *FvProtocol = FvbDev->Handle;\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
  This routine consumes FV hobs and produces instances of FW_VOL_BLOCK_PROTOCOL as appropriate.\r
\r
  @param  ImageHandle            The image handle.\r
  @param  SystemTable            The system table.\r
\r
  @retval EFI_SUCCESS            Successfully initialized firmware volume block\r
                                 driver.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
FwVolBlockDriverInit (\r
  IN EFI_HANDLE        ImageHandle,\r
  IN EFI_SYSTEM_TABLE  *SystemTable\r
  )\r
{\r
  EFI_PEI_HOB_POINTERS  FvHob;\r
  EFI_PEI_HOB_POINTERS  Fv3Hob;\r
  UINT32                AuthenticationStatus;\r
\r
  //\r
  // Core Needs Firmware Volumes to function\r
  //\r
  FvHob.Raw = GetHobList ();\r
  while ((FvHob.Raw = GetNextHob (EFI_HOB_TYPE_FV, FvHob.Raw)) != NULL) {\r
    AuthenticationStatus = 0;\r
    //\r
    // Get the authentication status propagated from PEI-phase to DXE.\r
    //\r
    Fv3Hob.Raw = GetHobList ();\r
    while ((Fv3Hob.Raw = GetNextHob (EFI_HOB_TYPE_FV3, Fv3Hob.Raw)) != NULL) {\r
      if ((Fv3Hob.FirmwareVolume3->BaseAddress == FvHob.FirmwareVolume->BaseAddress) &&\r
          (Fv3Hob.FirmwareVolume3->Length == FvHob.FirmwareVolume->Length))\r
      {\r
        AuthenticationStatus = Fv3Hob.FirmwareVolume3->AuthenticationStatus;\r
        break;\r
      }\r
\r
      Fv3Hob.Raw = GET_NEXT_HOB (Fv3Hob);\r
    }\r
\r
    //\r
    // Produce an FVB protocol for it\r
    //\r
    ProduceFVBProtocolOnBuffer (FvHob.FirmwareVolume->BaseAddress, FvHob.FirmwareVolume->Length, NULL, AuthenticationStatus, NULL);\r
    FvHob.Raw = GET_NEXT_HOB (FvHob);\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  This DXE service routine is used to process a firmware volume. In\r
  particular, it can be called by BDS to process a single firmware\r
  volume found in a capsule.\r
\r
  Caution: The caller need validate the input firmware volume to follow\r
  PI specification.\r
  DxeCore will trust the input data and process firmware volume directly.\r
\r
  @param  FvHeader               pointer to a firmware volume header\r
  @param  Size                   the size of the buffer pointed to by FvHeader\r
  @param  FVProtocolHandle       the handle on which a firmware volume protocol\r
                                 was produced for the firmware volume passed in.\r
\r
  @retval EFI_OUT_OF_RESOURCES   if an FVB could not be produced due to lack of\r
                                 system resources\r
  @retval EFI_VOLUME_CORRUPTED   if the volume was corrupted\r
  @retval EFI_SUCCESS            a firmware volume protocol was produced for the\r
                                 firmware volume\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
CoreProcessFirmwareVolume (\r
  IN VOID         *FvHeader,\r
  IN UINTN        Size,\r
  OUT EFI_HANDLE  *FVProtocolHandle\r
  )\r
{\r
  VOID        *Ptr;\r
  EFI_STATUS  Status;\r
\r
  *FVProtocolHandle = NULL;\r
  Status            = ProduceFVBProtocolOnBuffer (\r
                        (EFI_PHYSICAL_ADDRESS)(UINTN)FvHeader,\r
                        (UINT64)Size,\r
                        NULL,\r
                        0,\r
                        FVProtocolHandle\r
                        );\r
  //\r
  // Since in our implementation we use register-protocol-notify to put a\r
  // FV protocol on the FVB protocol handle, we can't directly verify that\r
  // the FV protocol was produced. Therefore here we will check the handle\r
  // and make sure an FV protocol is on it. This indicates that all went\r
  // well. Otherwise we have to assume that the volume was corrupted\r
  // somehow.\r
  //\r
  if (!EFI_ERROR (Status)) {\r
    ASSERT (*FVProtocolHandle != NULL);\r
    Ptr    = NULL;\r
    Status = CoreHandleProtocol (*FVProtocolHandle, &gEfiFirmwareVolume2ProtocolGuid, (VOID **)&Ptr);\r
    if (EFI_ERROR (Status) || (Ptr == NULL)) {\r
      return EFI_VOLUME_CORRUPTED;\r
    }\r
\r
    return EFI_SUCCESS;\r
  }\r
\r
  return Status;\r
}\r