[mirror_edk2.git] / MdeModulePkg / Library / DxeCapsuleLibFmp / DxeCapsuleLib.c

/** @file\r
  DXE capsule library.\r
\r
  Caution: This module requires additional review when modified.\r
  This module will have external input - capsule image.\r
  This external input must be validated carefully to avoid security issue like\r
  buffer overflow, integer overflow.\r
\r
  SupportCapsuleImage(), ProcessCapsuleImage(), IsValidCapsuleHeader(),\r
  ValidateFmpCapsule(), DisplayCapsuleImage(), ConvertBmpToGopBlt() will\r
  receive untrusted input and do basic validation.\r
\r
  Copyright (c) 2016 - 2017, Intel Corporation. All rights reserved.<BR>\r
  This program and the accompanying materials\r
  are licensed and made available under the terms and conditions of the BSD License\r
  which accompanies this distribution.  The full text of the license may be found at\r
  http://opensource.org/licenses/bsd-license.php\r
\r
  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
\r
**/\r
\r
#include <PiDxe.h>\r
\r
#include <IndustryStandard/Bmp.h>\r
#include <IndustryStandard/WindowsUxCapsule.h>\r
\r
#include <Guid/FmpCapsule.h>\r
#include <Guid/SystemResourceTable.h>\r
#include <Guid/EventGroup.h>\r
\r
#include <Library/BaseLib.h>\r
#include <Library/DebugLib.h>\r
#include <Library/BaseMemoryLib.h>\r
#include <Library/DxeServicesTableLib.h>\r
#include <Library/UefiBootServicesTableLib.h>\r
#include <Library/UefiRuntimeServicesTableLib.h>\r
#include <Library/MemoryAllocationLib.h>\r
#include <Library/CapsuleLib.h>\r
#include <Library/DevicePathLib.h>\r
#include <Library/UefiLib.h>\r
#include <Library/PcdLib.h>\r
\r
#include <Protocol/GraphicsOutput.h>\r
#include <Protocol/EsrtManagement.h>\r
#include <Protocol/FirmwareManagement.h>\r
#include <Protocol/DevicePath.h>\r
\r
EFI_SYSTEM_RESOURCE_TABLE *mEsrtTable              = NULL;\r
BOOLEAN                   mIsVirtualAddrConverted  = FALSE;\r
BOOLEAN                   mDxeCapsuleLibEndOfDxe   = FALSE;\r
\r
/**\r
  Initialize capsule related variables.\r
**/\r
VOID\r
InitCapsuleVariable (\r
  VOID\r
  );\r
\r
/**\r
  Record capsule status variable.\r
\r
  @param[in] CapsuleHeader  The capsule image header\r
  @param[in] CapsuleStatus  The capsule process stauts\r
\r
  @retval EFI_SUCCESS          The capsule status variable is recorded.\r
  @retval EFI_OUT_OF_RESOURCES No resource to record the capsule status variable.\r
**/\r
EFI_STATUS\r
RecordCapsuleStatusVariable (\r
  IN EFI_CAPSULE_HEADER                           *CapsuleHeader,\r
  IN EFI_STATUS                                   CapsuleStatus\r
  );\r
\r
/**\r
  Record FMP capsule status variable.\r
\r
  @param[in] CapsuleHeader  The capsule image header\r
  @param[in] CapsuleStatus  The capsule process stauts\r
  @param[in] PayloadIndex   FMP payload index\r
  @param[in] ImageHeader    FMP image header\r
  @param[in] FmpDevicePath  DevicePath associated with the FMP producer\r
\r
  @retval EFI_SUCCESS          The capsule status variable is recorded.\r
  @retval EFI_OUT_OF_RESOURCES No resource to record the capsule status variable.\r
**/\r
EFI_STATUS\r
RecordFmpCapsuleStatusVariable (\r
  IN EFI_CAPSULE_HEADER                            *CapsuleHeader,\r
  IN EFI_STATUS                                    CapsuleStatus,\r
  IN UINTN                                         PayloadIndex,\r
  IN EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER  *ImageHeader,\r
  IN EFI_DEVICE_PATH_PROTOCOL                      *FmpDevicePath OPTIONAL\r
  );\r
\r
/**\r
  Function indicate the current completion progress of the firmware\r
  update. Platform may override with own specific progress function.\r
\r
  @param[in]  Completion    A value between 1 and 100 indicating the current completion progress of the firmware update\r
\r
  @retval EFI_SUCESS    Input capsule is a correct FMP capsule.\r
**/\r
EFI_STATUS\r
EFIAPI\r
Update_Image_Progress (\r
  IN UINTN  Completion\r
  )\r
{\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Return if this CapsuleGuid is a FMP capsule GUID or not.\r
\r
  @param[in] CapsuleGuid A pointer to EFI_GUID\r
\r
  @retval TRUE  It is a FMP capsule GUID.\r
  @retval FALSE It is not a FMP capsule GUID.\r
**/\r
BOOLEAN\r
IsFmpCapsuleGuid (\r
  IN EFI_GUID  *CapsuleGuid\r
  )\r
{\r
  if (CompareGuid(&gEfiFmpCapsuleGuid, CapsuleGuid)) {\r
    return TRUE;\r
  }\r
\r
  return FALSE;\r
}\r
\r
/**\r
  Validate if it is valid capsule header\r
\r
  Caution: This function may receive untrusted input.\r
\r
  This function assumes the caller provided correct CapsuleHeader pointer\r
  and CapsuleSize.\r
\r
  This function validates the fields in EFI_CAPSULE_HEADER.\r
\r
  @param[in]  CapsuleHeader    Points to a capsule header.\r
  @param[in]  CapsuleSize      Size of the whole capsule image.\r
\r
**/\r
BOOLEAN\r
IsValidCapsuleHeader (\r
  IN EFI_CAPSULE_HEADER  *CapsuleHeader,\r
  IN UINT64              CapsuleSize\r
  )\r
{\r
  if (CapsuleHeader->CapsuleImageSize != CapsuleSize) {\r
    return FALSE;\r
  }\r
  if (CapsuleHeader->HeaderSize >= CapsuleHeader->CapsuleImageSize) {\r
    return FALSE;\r
  }\r
  return TRUE;\r
}\r
\r
/**\r
  Validate Fmp capsules layout.\r
\r
  Caution: This function may receive untrusted input.\r
\r
  This function assumes the caller validated the capsule by using\r
  IsValidCapsuleHeader(), so that all fields in EFI_CAPSULE_HEADER are correct.\r
  The capsule buffer size is CapsuleHeader->CapsuleImageSize.\r
\r
  This function validates the fields in EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER\r
  and EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER.\r
\r
  This function need support nested FMP capsule.\r
\r
  @param[in]   CapsuleHeader        Points to a capsule header.\r
  @param[out]  EmbeddedDriverCount  The EmbeddedDriverCount in the FMP capsule.\r
\r
  @retval EFI_SUCESS             Input capsule is a correct FMP capsule.\r
  @retval EFI_INVALID_PARAMETER  Input capsule is not a correct FMP capsule.\r
**/\r
EFI_STATUS\r
ValidateFmpCapsule (\r
  IN EFI_CAPSULE_HEADER  *CapsuleHeader,\r
  OUT UINT16             *EmbeddedDriverCount OPTIONAL\r
  )\r
{\r
  EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER       *FmpCapsuleHeader;\r
  UINT8                                        *EndOfCapsule;\r
  EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER *ImageHeader;\r
  UINT8                                        *EndOfPayload;\r
  UINT64                                       *ItemOffsetList;\r
  UINT32                                       ItemNum;\r
  UINTN                                        Index;\r
  UINTN                                        FmpCapsuleSize;\r
  UINTN                                        FmpCapsuleHeaderSize;\r
  UINT64                                       FmpImageSize;\r
  UINTN                                        FmpImageHeaderSize;\r
\r
  if (!IsFmpCapsuleGuid(&CapsuleHeader->CapsuleGuid)) {\r
    return ValidateFmpCapsule ((EFI_CAPSULE_HEADER *)((UINTN)CapsuleHeader + CapsuleHeader->HeaderSize), EmbeddedDriverCount);\r
  }\r
\r
  if (CapsuleHeader->HeaderSize >= CapsuleHeader->CapsuleImageSize) {\r
    DEBUG((DEBUG_ERROR, "HeaderSize(0x%x) >= CapsuleImageSize(0x%x)\n", CapsuleHeader->HeaderSize, CapsuleHeader->CapsuleImageSize));\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  FmpCapsuleHeader = (EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER *) ((UINT8 *) CapsuleHeader + CapsuleHeader->HeaderSize);\r
  EndOfCapsule     = (UINT8 *) CapsuleHeader + CapsuleHeader->CapsuleImageSize;\r
  FmpCapsuleSize   = (UINTN)EndOfCapsule - (UINTN)FmpCapsuleHeader;\r
\r
  if (FmpCapsuleSize < sizeof(EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER)) {\r
    DEBUG((DEBUG_ERROR, "FmpCapsuleSize(0x%x) < EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER\n", FmpCapsuleSize));\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  // Check EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER\r
  if (FmpCapsuleHeader->Version != EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER_INIT_VERSION) {\r
    DEBUG((DEBUG_ERROR, "FmpCapsuleHeader->Version(0x%x) != EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER_INIT_VERSION\n", FmpCapsuleHeader->Version));\r
    return EFI_INVALID_PARAMETER;\r
  }\r
  ItemOffsetList = (UINT64 *)(FmpCapsuleHeader + 1);\r
\r
  // No overflow\r
  ItemNum = FmpCapsuleHeader->EmbeddedDriverCount + FmpCapsuleHeader->PayloadItemCount;\r
\r
  if ((FmpCapsuleSize - sizeof(EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER))/sizeof(UINT64) < ItemNum) {\r
    DEBUG((DEBUG_ERROR, "ItemNum(0x%x) too big\n", ItemNum));\r
    return EFI_INVALID_PARAMETER;\r
  }\r
  FmpCapsuleHeaderSize = sizeof(EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER) + sizeof(UINT64)*ItemNum;\r
\r
  // Check ItemOffsetList\r
  for (Index = 0; Index < ItemNum; Index++) {\r
    if (ItemOffsetList[Index] >= FmpCapsuleSize) {\r
      DEBUG((DEBUG_ERROR, "ItemOffsetList[%d](0x%lx) >= FmpCapsuleSize(0x%x)\n", Index, ItemOffsetList[Index], FmpCapsuleSize));\r
      return EFI_INVALID_PARAMETER;\r
    }\r
    if (ItemOffsetList[Index] < FmpCapsuleHeaderSize) {\r
      DEBUG((DEBUG_ERROR, "ItemOffsetList[%d](0x%lx) < FmpCapsuleHeaderSize(0x%x)\n", Index, ItemOffsetList[Index], FmpCapsuleHeaderSize));\r
      return EFI_INVALID_PARAMETER;\r
    }\r
    //\r
    // All the address in ItemOffsetList must be stored in ascending order\r
    //\r
    if (Index > 0) {\r
      if (ItemOffsetList[Index] <= ItemOffsetList[Index - 1]) {\r
        DEBUG((DEBUG_ERROR, "ItemOffsetList[%d](0x%lx) < ItemOffsetList[%d](0x%x)\n", Index, ItemOffsetList[Index], Index, ItemOffsetList[Index - 1]));\r
        return EFI_INVALID_PARAMETER;\r
      }\r
    }\r
  }\r
\r
  // Check EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER\r
  for (Index = FmpCapsuleHeader->EmbeddedDriverCount; Index < ItemNum; Index++) {\r
    ImageHeader  = (EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER *)((UINT8 *)FmpCapsuleHeader + ItemOffsetList[Index]);\r
    if (Index == ItemNum - 1) {\r
      EndOfPayload = (UINT8 *)((UINTN)EndOfCapsule - (UINTN)FmpCapsuleHeader);\r
    } else {\r
      EndOfPayload = (UINT8 *)(UINTN)ItemOffsetList[Index+1];\r
    }\r
    FmpImageSize = (UINTN)EndOfPayload - ItemOffsetList[Index];\r
\r
    if (FmpImageSize < OFFSET_OF(EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER, UpdateHardwareInstance)) {\r
      DEBUG((DEBUG_ERROR, "FmpImageSize(0x%lx) < EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER\n", FmpImageSize));\r
      return EFI_INVALID_PARAMETER;\r
    }\r
    FmpImageHeaderSize = sizeof(EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER);\r
    if ((ImageHeader->Version > EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER_INIT_VERSION) ||\r
        (ImageHeader->Version < 1)) {\r
      DEBUG((DEBUG_ERROR, "ImageHeader->Version(0x%x) Unknown\n", ImageHeader->Version));\r
      return EFI_INVALID_PARAMETER;\r
    }\r
    if (ImageHeader->Version < EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER_INIT_VERSION) {\r
      FmpImageHeaderSize = OFFSET_OF(EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER, UpdateHardwareInstance);\r
    }\r
\r
    // No overflow\r
    if (FmpImageSize != (UINT64)FmpImageHeaderSize + (UINT64)ImageHeader->UpdateImageSize + (UINT64)ImageHeader->UpdateVendorCodeSize) {\r
      DEBUG((DEBUG_ERROR, "FmpImageSize(0x%lx) mismatch, UpdateImageSize(0x%x) UpdateVendorCodeSize(0x%x)\n", FmpImageSize, ImageHeader->UpdateImageSize, ImageHeader->UpdateVendorCodeSize));\r
      return EFI_INVALID_PARAMETER;\r
    }\r
  }\r
\r
  if (ItemNum == 0) {\r
    //\r
    // No driver & payload element in FMP\r
    //\r
    EndOfPayload = (UINT8 *)(FmpCapsuleHeader + 1);\r
    if (EndOfPayload != EndOfCapsule) {\r
      DEBUG((DEBUG_ERROR, "EndOfPayload(0x%x) mismatch, EndOfCapsule(0x%x)\n", EndOfPayload, EndOfCapsule));\r
      return EFI_INVALID_PARAMETER;\r
    }\r
    return EFI_UNSUPPORTED;\r
  }\r
\r
  if (EmbeddedDriverCount != NULL) {\r
    *EmbeddedDriverCount = FmpCapsuleHeader->EmbeddedDriverCount;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Convert a *.BMP graphics image to a GOP blt buffer. If a NULL Blt buffer\r
  is passed in a GopBlt buffer will be allocated by this routine. If a GopBlt\r
  buffer is passed in it will be used if it is big enough.\r
\r
  Caution: This function may receive untrusted input.\r
\r
  @param[in]       BmpImage      Pointer to BMP file\r
  @param[in]       BmpImageSize  Number of bytes in BmpImage\r
  @param[in, out]  GopBlt        Buffer containing GOP version of BmpImage.\r
  @param[in, out]  GopBltSize    Size of GopBlt in bytes.\r
  @param[out]      PixelHeight   Height of GopBlt/BmpImage in pixels\r
  @param[out]      PixelWidth    Width of GopBlt/BmpImage in pixels\r
\r
  @retval EFI_SUCCESS           GopBlt and GopBltSize are returned.\r
  @retval EFI_UNSUPPORTED       BmpImage is not a valid *.BMP image\r
  @retval EFI_BUFFER_TOO_SMALL  The passed in GopBlt buffer is not big enough.\r
                                GopBltSize will contain the required size.\r
  @retval EFI_OUT_OF_RESOURCES  No enough buffer to allocate.\r
\r
**/\r
STATIC\r
EFI_STATUS\r
ConvertBmpToGopBlt (\r
  IN     VOID      *BmpImage,\r
  IN     UINTN     BmpImageSize,\r
  IN OUT VOID      **GopBlt,\r
  IN OUT UINTN     *GopBltSize,\r
     OUT UINTN     *PixelHeight,\r
     OUT UINTN     *PixelWidth\r
  )\r
{\r
  UINT8                         *Image;\r
  UINT8                         *ImageHeader;\r
  BMP_IMAGE_HEADER              *BmpHeader;\r
  BMP_COLOR_MAP                 *BmpColorMap;\r
  EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BltBuffer;\r
  EFI_GRAPHICS_OUTPUT_BLT_PIXEL *Blt;\r
  UINT64                        BltBufferSize;\r
  UINTN                         Index;\r
  UINTN                         Height;\r
  UINTN                         Width;\r
  UINTN                         ImageIndex;\r
  UINT32                        DataSizePerLine;\r
  BOOLEAN                       IsAllocated;\r
  UINT32                        ColorMapNum;\r
\r
  if (sizeof (BMP_IMAGE_HEADER) > BmpImageSize) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  BmpHeader = (BMP_IMAGE_HEADER *) BmpImage;\r
\r
  if (BmpHeader->CharB != 'B' || BmpHeader->CharM != 'M') {\r
    return EFI_UNSUPPORTED;\r
  }\r
\r
  //\r
  // Doesn't support compress.\r
  //\r
  if (BmpHeader->CompressionType != 0) {\r
    return EFI_UNSUPPORTED;\r
  }\r
\r
  //\r
  // Only support BITMAPINFOHEADER format.\r
  // BITMAPFILEHEADER + BITMAPINFOHEADER = BMP_IMAGE_HEADER\r
  //\r
  if (BmpHeader->HeaderSize != sizeof (BMP_IMAGE_HEADER) - OFFSET_OF(BMP_IMAGE_HEADER, HeaderSize)) {\r
    return EFI_UNSUPPORTED;\r
  }\r
\r
  //\r
  // The data size in each line must be 4 byte alignment.\r
  //\r
  DataSizePerLine = ((BmpHeader->PixelWidth * BmpHeader->BitPerPixel + 31) >> 3) & (~0x3);\r
  BltBufferSize = MultU64x32 (DataSizePerLine, BmpHeader->PixelHeight);\r
  if (BltBufferSize > (UINT32) ~0) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if ((BmpHeader->Size != BmpImageSize) ||\r
      (BmpHeader->Size < BmpHeader->ImageOffset) ||\r
      (BmpHeader->Size - BmpHeader->ImageOffset !=  BmpHeader->PixelHeight * DataSizePerLine)) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  //\r
  // Calculate Color Map offset in the image.\r
  //\r
  Image       = BmpImage;\r
  BmpColorMap = (BMP_COLOR_MAP *) (Image + sizeof (BMP_IMAGE_HEADER));\r
  if (BmpHeader->ImageOffset < sizeof (BMP_IMAGE_HEADER)) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if (BmpHeader->ImageOffset > sizeof (BMP_IMAGE_HEADER)) {\r
    switch (BmpHeader->BitPerPixel) {\r
      case 1:\r
        ColorMapNum = 2;\r
        break;\r
      case 4:\r
        ColorMapNum = 16;\r
        break;\r
      case 8:\r
        ColorMapNum = 256;\r
        break;\r
      default:\r
        ColorMapNum = 0;\r
        break;\r
      }\r
    //\r
    // BMP file may has padding data between the bmp header section and the bmp data section.\r
    //\r
    if (BmpHeader->ImageOffset - sizeof (BMP_IMAGE_HEADER) < sizeof (BMP_COLOR_MAP) * ColorMapNum) {\r
      return EFI_INVALID_PARAMETER;\r
    }\r
  }\r
\r
  //\r
  // Calculate graphics image data address in the image\r
  //\r
  Image         = ((UINT8 *) BmpImage) + BmpHeader->ImageOffset;\r
  ImageHeader   = Image;\r
\r
  //\r
  // Calculate the BltBuffer needed size.\r
  //\r
  BltBufferSize = MultU64x32 ((UINT64) BmpHeader->PixelWidth, BmpHeader->PixelHeight);\r
  //\r
  // Ensure the BltBufferSize * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL) doesn't overflow\r
  //\r
  if (BltBufferSize > DivU64x32 ((UINTN) ~0, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL))) {\r
    return EFI_UNSUPPORTED;\r
  }\r
  BltBufferSize = MultU64x32 (BltBufferSize, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL));\r
\r
  IsAllocated   = FALSE;\r
  if (*GopBlt == NULL) {\r
    //\r
    // GopBlt is not allocated by caller.\r
    //\r
    *GopBltSize = (UINTN) BltBufferSize;\r
    *GopBlt     = AllocatePool (*GopBltSize);\r
    IsAllocated = TRUE;\r
    if (*GopBlt == NULL) {\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
  } else {\r
    //\r
    // GopBlt has been allocated by caller.\r
    //\r
    if (*GopBltSize < (UINTN) BltBufferSize) {\r
      *GopBltSize = (UINTN) BltBufferSize;\r
      return EFI_BUFFER_TOO_SMALL;\r
    }\r
  }\r
\r
  *PixelWidth   = BmpHeader->PixelWidth;\r
  *PixelHeight  = BmpHeader->PixelHeight;\r
\r
  //\r
  // Convert image from BMP to Blt buffer format\r
  //\r
  BltBuffer = *GopBlt;\r
  for (Height = 0; Height < BmpHeader->PixelHeight; Height++) {\r
    Blt = &BltBuffer[(BmpHeader->PixelHeight - Height - 1) * BmpHeader->PixelWidth];\r
    for (Width = 0; Width < BmpHeader->PixelWidth; Width++, Image++, Blt++) {\r
      switch (BmpHeader->BitPerPixel) {\r
      case 1:\r
        //\r
        // Convert 1-bit (2 colors) BMP to 24-bit color\r
        //\r
        for (Index = 0; Index < 8 && Width < BmpHeader->PixelWidth; Index++) {\r
          Blt->Red    = BmpColorMap[((*Image) >> (7 - Index)) & 0x1].Red;\r
          Blt->Green  = BmpColorMap[((*Image) >> (7 - Index)) & 0x1].Green;\r
          Blt->Blue   = BmpColorMap[((*Image) >> (7 - Index)) & 0x1].Blue;\r
          Blt++;\r
          Width++;\r
        }\r
\r
        Blt--;\r
        Width--;\r
        break;\r
\r
      case 4:\r
        //\r
        // Convert 4-bit (16 colors) BMP Palette to 24-bit color\r
        //\r
        Index       = (*Image) >> 4;\r
        Blt->Red    = BmpColorMap[Index].Red;\r
        Blt->Green  = BmpColorMap[Index].Green;\r
        Blt->Blue   = BmpColorMap[Index].Blue;\r
        if (Width < (BmpHeader->PixelWidth - 1)) {\r
          Blt++;\r
          Width++;\r
          Index       = (*Image) & 0x0f;\r
          Blt->Red    = BmpColorMap[Index].Red;\r
          Blt->Green  = BmpColorMap[Index].Green;\r
          Blt->Blue   = BmpColorMap[Index].Blue;\r
        }\r
        break;\r
\r
      case 8:\r
        //\r
        // Convert 8-bit (256 colors) BMP Palette to 24-bit color\r
        //\r
        Blt->Red    = BmpColorMap[*Image].Red;\r
        Blt->Green  = BmpColorMap[*Image].Green;\r
        Blt->Blue   = BmpColorMap[*Image].Blue;\r
        break;\r
\r
      case 24:\r
        //\r
        // It is 24-bit BMP.\r
        //\r
        Blt->Blue   = *Image++;\r
        Blt->Green  = *Image++;\r
        Blt->Red    = *Image;\r
        break;\r
\r
      case 32:\r
        //\r
        // it is 32-bit BMP. Skip pixel's highest byte\r
        //\r
        Blt->Blue  = *Image++;\r
        Blt->Green = *Image++;\r
        Blt->Red   = *Image++;\r
        break;\r
\r
      default:\r
        //\r
        // Other bit format BMP is not supported.\r
        //\r
        if (IsAllocated) {\r
          FreePool (*GopBlt);\r
          *GopBlt = NULL;\r
        }\r
        return EFI_UNSUPPORTED;\r
      };\r
\r
    }\r
\r
    ImageIndex = (UINTN) Image - (UINTN) ImageHeader;\r
    if ((ImageIndex % 4) != 0) {\r
      //\r
      // Bmp Image starts each row on a 32-bit boundary!\r
      //\r
      Image = Image + (4 - (ImageIndex % 4));\r
    }\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
\r
/**\r
  Those capsules supported by the firmwares.\r
\r
  Caution: This function may receive untrusted input.\r
\r
  @param[in]  CapsuleHeader    Points to a capsule header.\r
\r
  @retval EFI_SUCESS       Input capsule is supported by firmware.\r
  @retval EFI_UNSUPPORTED  Input capsule is not supported by the firmware.\r
**/\r
EFI_STATUS\r
DisplayCapsuleImage (\r
  IN EFI_CAPSULE_HEADER  *CapsuleHeader\r
  )\r
{\r
  DISPLAY_DISPLAY_PAYLOAD       *ImagePayload;\r
  UINTN                         PayloadSize;\r
  EFI_STATUS                    Status;\r
  EFI_GRAPHICS_OUTPUT_BLT_PIXEL *Blt;\r
  UINTN                         BltSize;\r
  UINTN                         Height;\r
  UINTN                         Width;\r
  EFI_GRAPHICS_OUTPUT_PROTOCOL  *GraphicsOutput;\r
\r
  ImagePayload = (DISPLAY_DISPLAY_PAYLOAD *)(CapsuleHeader + 1);\r
  PayloadSize = CapsuleHeader->CapsuleImageSize - sizeof(EFI_CAPSULE_HEADER);\r
\r
  if (ImagePayload->Version != 1) {\r
    return EFI_UNSUPPORTED;\r
  }\r
  if (CalculateCheckSum8((UINT8 *)CapsuleHeader, CapsuleHeader->CapsuleImageSize) != 0) {\r
    return EFI_UNSUPPORTED;\r
  }\r
  //\r
  // Only Support Bitmap by now\r
  //\r
  if (ImagePayload->ImageType != 0) {\r
    return EFI_UNSUPPORTED;\r
  }\r
\r
  //\r
  // Try to open GOP\r
  //\r
  Status = gBS->HandleProtocol (gST->ConsoleOutHandle, &gEfiGraphicsOutputProtocolGuid, (VOID **)&GraphicsOutput);\r
  if (EFI_ERROR (Status)) {\r
    Status = gBS->LocateProtocol(&gEfiGraphicsOutputProtocolGuid, NULL, (VOID **)&GraphicsOutput);\r
    if (EFI_ERROR(Status)) {\r
      return EFI_UNSUPPORTED;\r
    }\r
  }\r
\r
  if (GraphicsOutput->Mode->Mode != ImagePayload->Mode) {\r
    return EFI_UNSUPPORTED;\r
  }\r
\r
  Blt = NULL;\r
  Width = 0;\r
  Height = 0;\r
  Status = ConvertBmpToGopBlt (\r
             ImagePayload + 1,\r
             PayloadSize - sizeof(DISPLAY_DISPLAY_PAYLOAD),\r
             (VOID **)&Blt,\r
             &BltSize,\r
             &Height,\r
             &Width\r
             );\r
\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  Status = GraphicsOutput->Blt (\r
                             GraphicsOutput,\r
                             Blt,\r
                             EfiBltBufferToVideo,\r
                             0,\r
                             0,\r
                             (UINTN) ImagePayload->OffsetX,\r
                             (UINTN) ImagePayload->OffsetY,\r
                             Width,\r
                             Height,\r
                             Width * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL)\r
                             );\r
\r
  FreePool(Blt);\r
\r
  return Status;\r
}\r
\r
/**\r
  Dump FMP information.\r
\r
  @param[in] ImageInfoSize       The size of ImageInfo, in bytes.\r
  @param[in] ImageInfo           A pointer to EFI_FIRMWARE_IMAGE_DESCRIPTOR.\r
  @param[in] DescriptorVersion   The version of EFI_FIRMWARE_IMAGE_DESCRIPTOR.\r
  @param[in] DescriptorCount     The count of EFI_FIRMWARE_IMAGE_DESCRIPTOR.\r
  @param[in] DescriptorSize      The size of an individual EFI_FIRMWARE_IMAGE_DESCRIPTOR, in bytes.\r
  @param[in] PackageVersion      The version of package.\r
  @param[in] PackageVersionName  The version name of package.\r
**/\r
VOID\r
DumpFmpImageInfo (\r
  IN UINTN                           ImageInfoSize,\r
  IN EFI_FIRMWARE_IMAGE_DESCRIPTOR   *ImageInfo,\r
  IN UINT32                          DescriptorVersion,\r
  IN UINT8                           DescriptorCount,\r
  IN UINTN                           DescriptorSize,\r
  IN UINT32                          PackageVersion,\r
  IN CHAR16                          *PackageVersionName\r
  )\r
{\r
  EFI_FIRMWARE_IMAGE_DESCRIPTOR                 *CurrentImageInfo;\r
  UINTN                                         Index;\r
\r
  DEBUG((DEBUG_VERBOSE, "  DescriptorVersion  - 0x%x\n", DescriptorVersion));\r
  DEBUG((DEBUG_VERBOSE, "  DescriptorCount    - 0x%x\n", DescriptorCount));\r
  DEBUG((DEBUG_VERBOSE, "  DescriptorSize     - 0x%x\n", DescriptorSize));\r
  DEBUG((DEBUG_VERBOSE, "  PackageVersion     - 0x%x\n", PackageVersion));\r
  DEBUG((DEBUG_VERBOSE, "  PackageVersionName - %s\n\n", PackageVersionName));\r
  CurrentImageInfo = ImageInfo;\r
  for (Index = 0; Index < DescriptorCount; Index++) {\r
    DEBUG((DEBUG_VERBOSE, "  ImageDescriptor (%d)\n", Index));\r
    DEBUG((DEBUG_VERBOSE, "    ImageIndex                  - 0x%x\n", CurrentImageInfo->ImageIndex));\r
    DEBUG((DEBUG_VERBOSE, "    ImageTypeId                 - %g\n", &CurrentImageInfo->ImageTypeId));\r
    DEBUG((DEBUG_VERBOSE, "    ImageId                     - 0x%lx\n", CurrentImageInfo->ImageId));\r
    DEBUG((DEBUG_VERBOSE, "    ImageIdName                 - %s\n", CurrentImageInfo->ImageIdName));\r
    DEBUG((DEBUG_VERBOSE, "    Version                     - 0x%x\n", CurrentImageInfo->Version));\r
    DEBUG((DEBUG_VERBOSE, "    VersionName                 - %s\n", CurrentImageInfo->VersionName));\r
    DEBUG((DEBUG_VERBOSE, "    Size                        - 0x%x\n", CurrentImageInfo->Size));\r
    DEBUG((DEBUG_VERBOSE, "    AttributesSupported         - 0x%lx\n", CurrentImageInfo->AttributesSupported));\r
    DEBUG((DEBUG_VERBOSE, "    AttributesSetting           - 0x%lx\n", CurrentImageInfo->AttributesSetting));\r
    DEBUG((DEBUG_VERBOSE, "    Compatibilities             - 0x%lx\n", CurrentImageInfo->Compatibilities));\r
    if (DescriptorVersion > 1) {\r
      DEBUG((DEBUG_VERBOSE, "    LowestSupportedImageVersion - 0x%x\n", CurrentImageInfo->LowestSupportedImageVersion));\r
      if (DescriptorVersion > 2) {\r
        DEBUG((DEBUG_VERBOSE, "    LastAttemptVersion          - 0x%x\n", CurrentImageInfo->LastAttemptVersion));\r
        DEBUG((DEBUG_VERBOSE, "    LastAttemptStatus           - 0x%x\n", CurrentImageInfo->LastAttemptStatus));\r
        DEBUG((DEBUG_VERBOSE, "    HardwareInstance            - 0x%lx\n", CurrentImageInfo->HardwareInstance));\r
      }\r
    }\r
    //\r
    // Use DescriptorSize to move ImageInfo Pointer to stay compatible with different ImageInfo version\r
    //\r
    CurrentImageInfo = (EFI_FIRMWARE_IMAGE_DESCRIPTOR *)((UINT8 *)CurrentImageInfo + DescriptorSize);\r
  }\r
}\r
\r
/**\r
  Dump a non-nested FMP capsule.\r
\r
  @param[in]  CapsuleHeader  A pointer to CapsuleHeader\r
**/\r
VOID\r
DumpFmpCapsule (\r
  IN EFI_CAPSULE_HEADER                *CapsuleHeader\r
  )\r
{\r
  EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER        *FmpCapsuleHeader;\r
  EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER  *ImageHeader;\r
  UINTN                                         Index;\r
  UINT64                                        *ItemOffsetList;\r
\r
  FmpCapsuleHeader = (EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER *)((UINT8 *)CapsuleHeader + CapsuleHeader->HeaderSize);\r
\r
  DEBUG((DEBUG_VERBOSE, "FmpCapsule:\n"));\r
  DEBUG((DEBUG_VERBOSE, "  Version                - 0x%x\n", FmpCapsuleHeader->Version));\r
  DEBUG((DEBUG_VERBOSE, "  EmbeddedDriverCount    - 0x%x\n", FmpCapsuleHeader->EmbeddedDriverCount));\r
  DEBUG((DEBUG_VERBOSE, "  PayloadItemCount       - 0x%x\n", FmpCapsuleHeader->PayloadItemCount));\r
\r
  ItemOffsetList = (UINT64 *)(FmpCapsuleHeader + 1);\r
  for (Index = 0; Index < FmpCapsuleHeader->EmbeddedDriverCount; Index++) {\r
    DEBUG((DEBUG_VERBOSE, "  ItemOffsetList[%d]      - 0x%lx\n", Index, ItemOffsetList[Index]));\r
  }\r
  for (; Index < (UINT32)FmpCapsuleHeader->EmbeddedDriverCount + FmpCapsuleHeader->PayloadItemCount; Index++) {\r
    DEBUG((DEBUG_VERBOSE, "  ItemOffsetList[%d]      - 0x%lx\n", Index, ItemOffsetList[Index]));\r
    ImageHeader = (EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER *)((UINT8 *)FmpCapsuleHeader + ItemOffsetList[Index]);\r
\r
    DEBUG((DEBUG_VERBOSE, "  ImageHeader:\n"));\r
    DEBUG((DEBUG_VERBOSE, "    Version                - 0x%x\n", ImageHeader->Version));\r
    DEBUG((DEBUG_VERBOSE, "    UpdateImageTypeId      - %g\n", &ImageHeader->UpdateImageTypeId));\r
    DEBUG((DEBUG_VERBOSE, "    UpdateImageIndex       - 0x%x\n", ImageHeader->UpdateImageIndex));\r
    DEBUG((DEBUG_VERBOSE, "    UpdateImageSize        - 0x%x\n", ImageHeader->UpdateImageSize));\r
    DEBUG((DEBUG_VERBOSE, "    UpdateVendorCodeSize   - 0x%x\n", ImageHeader->UpdateVendorCodeSize));\r
    if (ImageHeader->Version >= EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER_INIT_VERSION) {\r
      DEBUG((DEBUG_VERBOSE, "    UpdateHardwareInstance - 0x%lx\n", ImageHeader->UpdateHardwareInstance));\r
    }\r
  }\r
}\r
\r
/**\r
  Dump all FMP information.\r
**/\r
VOID\r
DumpAllFmpInfo (\r
  VOID\r
  )\r
{\r
  EFI_STATUS                                    Status;\r
  EFI_HANDLE                                    *HandleBuffer;\r
  UINTN                                         NumberOfHandles;\r
  EFI_FIRMWARE_MANAGEMENT_PROTOCOL              *Fmp;\r
  UINTN                                         Index;\r
  UINTN                                         ImageInfoSize;\r
  EFI_FIRMWARE_IMAGE_DESCRIPTOR                 *FmpImageInfoBuf;\r
  UINT32                                        FmpImageInfoDescriptorVer;\r
  UINT8                                         FmpImageInfoCount;\r
  UINTN                                         DescriptorSize;\r
  UINT32                                        PackageVersion;\r
  CHAR16                                        *PackageVersionName;\r
\r
  Status = gBS->LocateHandleBuffer (\r
                  ByProtocol,\r
                  &gEfiFirmwareManagementProtocolGuid,\r
                  NULL,\r
                  &NumberOfHandles,\r
                  &HandleBuffer\r
                  );\r
  if (EFI_ERROR(Status)) {\r
    return ;\r
  }\r
\r
  for (Index = 0; Index < NumberOfHandles; Index++) {\r
    Status = gBS->HandleProtocol(\r
                    HandleBuffer[Index],\r
                    &gEfiFirmwareManagementProtocolGuid,\r
                    (VOID **)&Fmp\r
                    );\r
    if (EFI_ERROR(Status)) {\r
      continue;\r
    }\r
\r
    ImageInfoSize = 0;\r
    Status = Fmp->GetImageInfo (\r
                    Fmp,\r
                    &ImageInfoSize,\r
                    NULL,\r
                    NULL,\r
                    NULL,\r
                    NULL,\r
                    NULL,\r
                    NULL\r
                    );\r
    if (Status != EFI_BUFFER_TOO_SMALL) {\r
      continue;\r
    }\r
\r
    FmpImageInfoBuf = AllocateZeroPool (ImageInfoSize);\r
    if (FmpImageInfoBuf == NULL) {\r
      continue;\r
    }\r
\r
    PackageVersionName = NULL;\r
    Status = Fmp->GetImageInfo (\r
                    Fmp,\r
                    &ImageInfoSize,               // ImageInfoSize\r
                    FmpImageInfoBuf,              // ImageInfo\r
                    &FmpImageInfoDescriptorVer,   // DescriptorVersion\r
                    &FmpImageInfoCount,           // DescriptorCount\r
                    &DescriptorSize,              // DescriptorSize\r
                    &PackageVersion,              // PackageVersion\r
                    &PackageVersionName           // PackageVersionName\r
                    );\r
    if (EFI_ERROR(Status)) {\r
      FreePool(FmpImageInfoBuf);\r
      continue;\r
    }\r
\r
    DEBUG((DEBUG_INFO, "FMP (%d) ImageInfo:\n", Index));\r
    DumpFmpImageInfo(\r
      ImageInfoSize,               // ImageInfoSize\r
      FmpImageInfoBuf,             // ImageInfo\r
      FmpImageInfoDescriptorVer,   // DescriptorVersion\r
      FmpImageInfoCount,           // DescriptorCount\r
      DescriptorSize,              // DescriptorSize\r
      PackageVersion,              // PackageVersion\r
      PackageVersionName           // PackageVersionName\r
      );\r
\r
    if (PackageVersionName != NULL) {\r
      FreePool(PackageVersionName);\r
    }\r
\r
    FreePool(FmpImageInfoBuf);\r
  }\r
\r
  return ;\r
}\r
\r
/**\r
  Get FMP handle by ImageTypeId and HardwareInstance.\r
\r
  @param[in]     UpdateImageTypeId       Used to identify device firmware targeted by this update.\r
  @param[in]     UpdateHardwareInstance  The HardwareInstance to target with this update.\r
  @param[in,out] NoHandles               The number of handles returned in Buffer.\r
  @param[out]    Buffer[out]             A pointer to the buffer to return the requested array of handles.\r
\r
  @retval EFI_SUCCESS            The array of handles was returned in Buffer, and the number of\r
                                 handles in Buffer was returned in NoHandles.\r
  @retval EFI_NOT_FOUND          No handles match the search.\r
  @retval EFI_OUT_OF_RESOURCES   There is not enough pool memory to store the matching results.\r
**/\r
EFI_STATUS\r
GetFmpHandleBufferByType (\r
  IN     EFI_GUID                     *UpdateImageTypeId,\r
  IN     UINT64                       UpdateHardwareInstance,\r
  IN OUT UINTN                        *NoHandles,\r
  OUT    EFI_HANDLE                   **Buffer\r
  )\r
{\r
  EFI_STATUS                                    Status;\r
  EFI_HANDLE                                    *HandleBuffer;\r
  UINTN                                         NumberOfHandles;\r
  EFI_HANDLE                                    *MatchedHandleBuffer;\r
  UINTN                                         MatchedNumberOfHandles;\r
  EFI_FIRMWARE_MANAGEMENT_PROTOCOL              *Fmp;\r
  UINTN                                         Index;\r
  UINTN                                         ImageInfoSize;\r
  EFI_FIRMWARE_IMAGE_DESCRIPTOR                 *FmpImageInfoBuf;\r
  UINT32                                        FmpImageInfoDescriptorVer;\r
  UINT8                                         FmpImageInfoCount;\r
  UINTN                                         DescriptorSize;\r
  UINT32                                        PackageVersion;\r
  CHAR16                                        *PackageVersionName;\r
  UINTN                                         Index2;\r
  EFI_FIRMWARE_IMAGE_DESCRIPTOR                 *TempFmpImageInfo;\r
\r
  *NoHandles = 0;\r
  *Buffer = NULL;\r
\r
  Status = gBS->LocateHandleBuffer (\r
                  ByProtocol,\r
                  &gEfiFirmwareManagementProtocolGuid,\r
                  NULL,\r
                  &NumberOfHandles,\r
                  &HandleBuffer\r
                  );\r
  if (EFI_ERROR(Status)) {\r
    return Status;\r
  }\r
\r
  MatchedNumberOfHandles = 0;\r
  MatchedHandleBuffer = AllocateZeroPool (sizeof(EFI_HANDLE) * NumberOfHandles);\r
  if (MatchedHandleBuffer == NULL) {\r
    FreePool (HandleBuffer);\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  for (Index = 0; Index < NumberOfHandles; Index++) {\r
    Status = gBS->HandleProtocol(\r
                    HandleBuffer[Index],\r
                    &gEfiFirmwareManagementProtocolGuid,\r
                    (VOID **)&Fmp\r
                    );\r
    if (EFI_ERROR(Status)) {\r
      continue;\r
    }\r
\r
    ImageInfoSize = 0;\r
    Status = Fmp->GetImageInfo (\r
                    Fmp,\r
                    &ImageInfoSize,\r
                    NULL,\r
                    NULL,\r
                    NULL,\r
                    NULL,\r
                    NULL,\r
                    NULL\r
                    );\r
    if (Status != EFI_BUFFER_TOO_SMALL) {\r
      continue;\r
    }\r
\r
    FmpImageInfoBuf = AllocateZeroPool (ImageInfoSize);\r
    if (FmpImageInfoBuf == NULL) {\r
      continue;\r
    }\r
\r
    PackageVersionName = NULL;\r
    Status = Fmp->GetImageInfo (\r
                    Fmp,\r
                    &ImageInfoSize,               // ImageInfoSize\r
                    FmpImageInfoBuf,              // ImageInfo\r
                    &FmpImageInfoDescriptorVer,   // DescriptorVersion\r
                    &FmpImageInfoCount,           // DescriptorCount\r
                    &DescriptorSize,              // DescriptorSize\r
                    &PackageVersion,              // PackageVersion\r
                    &PackageVersionName           // PackageVersionName\r
                    );\r
    if (EFI_ERROR(Status)) {\r
      FreePool(FmpImageInfoBuf);\r
      continue;\r
    }\r
\r
    if (PackageVersionName != NULL) {\r
      FreePool(PackageVersionName);\r
    }\r
\r
    TempFmpImageInfo = FmpImageInfoBuf;\r
    for (Index2 = 0; Index2 < FmpImageInfoCount; Index2++) {\r
      //\r
      // Check if this FMP instance matches\r
      //\r
      if (CompareGuid(UpdateImageTypeId, &TempFmpImageInfo->ImageTypeId)) {\r
        if ((UpdateHardwareInstance == 0) ||\r
            ((FmpImageInfoDescriptorVer >= EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION) &&\r
             (UpdateHardwareInstance == TempFmpImageInfo->HardwareInstance))) {\r
          MatchedHandleBuffer[MatchedNumberOfHandles] = HandleBuffer[Index];\r
          MatchedNumberOfHandles++;\r
          break;\r
        }\r
      }\r
      TempFmpImageInfo = (EFI_FIRMWARE_IMAGE_DESCRIPTOR *)((UINT8 *)TempFmpImageInfo + DescriptorSize);\r
    }\r
    FreePool(FmpImageInfoBuf);\r
  }\r
\r
  if (MatchedNumberOfHandles == 0) {\r
    return EFI_NOT_FOUND;\r
  }\r
\r
  *NoHandles = MatchedNumberOfHandles;\r
  *Buffer = MatchedHandleBuffer;\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Return FmpImageInfoDescriptorVer by an FMP handle.\r
\r
  @param[in]  Handle   A FMP handle.\r
\r
  @return FmpImageInfoDescriptorVer associated with the FMP.\r
**/\r
UINT32\r
GetFmpImageInfoDescriptorVer (\r
  IN EFI_HANDLE                                   Handle\r
  )\r
{\r
  EFI_STATUS                                    Status;\r
  EFI_FIRMWARE_MANAGEMENT_PROTOCOL              *Fmp;\r
  UINTN                                         ImageInfoSize;\r
  EFI_FIRMWARE_IMAGE_DESCRIPTOR                 *FmpImageInfoBuf;\r
  UINT32                                        FmpImageInfoDescriptorVer;\r
  UINT8                                         FmpImageInfoCount;\r
  UINTN                                         DescriptorSize;\r
  UINT32                                        PackageVersion;\r
  CHAR16                                        *PackageVersionName;\r
\r
  Status = gBS->HandleProtocol(\r
                  Handle,\r
                  &gEfiFirmwareManagementProtocolGuid,\r
                  (VOID **)&Fmp\r
                  );\r
  if (EFI_ERROR(Status)) {\r
    return 0;\r
  }\r
\r
  ImageInfoSize = 0;\r
  Status = Fmp->GetImageInfo (\r
                  Fmp,\r
                  &ImageInfoSize,\r
                  NULL,\r
                  NULL,\r
                  NULL,\r
                  NULL,\r
                  NULL,\r
                  NULL\r
                  );\r
  if (Status != EFI_BUFFER_TOO_SMALL) {\r
    return 0;\r
  }\r
\r
  FmpImageInfoBuf = AllocateZeroPool (ImageInfoSize);\r
  if (FmpImageInfoBuf == NULL) {\r
    return 0;\r
  }\r
\r
  PackageVersionName = NULL;\r
  Status = Fmp->GetImageInfo (\r
                  Fmp,\r
                  &ImageInfoSize,               // ImageInfoSize\r
                  FmpImageInfoBuf,              // ImageInfo\r
                  &FmpImageInfoDescriptorVer,   // DescriptorVersion\r
                  &FmpImageInfoCount,           // DescriptorCount\r
                  &DescriptorSize,              // DescriptorSize\r
                  &PackageVersion,              // PackageVersion\r
                  &PackageVersionName           // PackageVersionName\r
                  );\r
  if (EFI_ERROR(Status)) {\r
    FreePool(FmpImageInfoBuf);\r
    return 0;\r
  }\r
  return FmpImageInfoDescriptorVer;\r
}\r
\r
/**\r
  Set FMP image data.\r
\r
  @param[in]  Handle        A FMP handle.\r
  @param[in]  ImageHeader   The payload image header.\r
  @param[in]  PayloadIndex  The index of the payload.\r
\r
  @return The status of FMP->SetImage.\r
**/\r
EFI_STATUS\r
SetFmpImageData (\r
  IN EFI_HANDLE                                   Handle,\r
  IN EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER *ImageHeader,\r
  IN UINTN                                        PayloadIndex\r
  )\r
{\r
  EFI_STATUS                                    Status;\r
  EFI_FIRMWARE_MANAGEMENT_PROTOCOL              *Fmp;\r
  UINT8                                         *Image;\r
  VOID                                          *VendorCode;\r
  CHAR16                                        *AbortReason;\r
\r
  Status = gBS->HandleProtocol(\r
                  Handle,\r
                  &gEfiFirmwareManagementProtocolGuid,\r
                  (VOID **)&Fmp\r
                  );\r
  if (EFI_ERROR(Status)) {\r
    return Status;\r
  }\r
\r
  if (ImageHeader->Version >= EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER_INIT_VERSION) {\r
    Image = (UINT8 *)(ImageHeader + 1);\r
  } else {\r
    //\r
    // If the EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER is version 1,\r
    // Header should exclude UpdateHardwareInstance field\r
    //\r
    Image = (UINT8 *)ImageHeader + OFFSET_OF(EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER, UpdateHardwareInstance);\r
  }\r
\r
  if (ImageHeader->UpdateVendorCodeSize == 0) {\r
    VendorCode = NULL;\r
  } else {\r
    VendorCode = Image + ImageHeader->UpdateImageSize;\r
  }\r
  AbortReason = NULL;\r
  DEBUG((DEBUG_INFO, "Fmp->SetImage ...\n"));\r
  DEBUG((DEBUG_INFO, "ImageTypeId - %g, ", &ImageHeader->UpdateImageTypeId));\r
  DEBUG((DEBUG_INFO, "PayloadIndex - 0x%x, ", PayloadIndex));\r
  DEBUG((DEBUG_INFO, "ImageIndex - 0x%x ", ImageHeader->UpdateImageIndex));\r
  if (ImageHeader->Version >= EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER_INIT_VERSION) {\r
    DEBUG((DEBUG_INFO, "(UpdateHardwareInstance - 0x%x)", ImageHeader->UpdateHardwareInstance));\r
  }\r
  DEBUG((DEBUG_INFO, "\n"));\r
  Status = Fmp->SetImage(\r
                  Fmp,\r
                  ImageHeader->UpdateImageIndex,          // ImageIndex\r
                  Image,                                  // Image\r
                  ImageHeader->UpdateImageSize,           // ImageSize\r
                  VendorCode,                             // VendorCode\r
                  Update_Image_Progress,                  // Progress\r
                  &AbortReason                            // AbortReason\r
                  );\r
  DEBUG((DEBUG_INFO, "Fmp->SetImage - %r\n", Status));\r
  if (AbortReason != NULL) {\r
    DEBUG ((DEBUG_ERROR, "%s\n", AbortReason));\r
    FreePool(AbortReason);\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
  Start a UEFI image in the FMP payload.\r
\r
  @param[in]  ImageBuffer   A pointer to the memory location containing a copy of the image to be loaded..\r
  @param[in]  ImageSize     The size in bytes of ImageBuffer.\r
\r
  @return The status of gBS->LoadImage and gBS->StartImage.\r
**/\r
EFI_STATUS\r
StartFmpImage (\r
  IN VOID   *ImageBuffer,\r
  IN UINTN  ImageSize\r
  )\r
{\r
  MEMMAP_DEVICE_PATH                            MemMapNode;\r
  EFI_STATUS                                    Status;\r
  EFI_HANDLE                                    ImageHandle;\r
  EFI_DEVICE_PATH_PROTOCOL                      *DriverDevicePath;\r
  UINTN                                         ExitDataSize;\r
\r
  SetDevicePathNodeLength (&MemMapNode.Header, sizeof (MemMapNode));\r
  MemMapNode.Header.Type     = HARDWARE_DEVICE_PATH;\r
  MemMapNode.Header.SubType  = HW_MEMMAP_DP;\r
  MemMapNode.MemoryType      = EfiBootServicesCode;\r
  MemMapNode.StartingAddress = (EFI_PHYSICAL_ADDRESS)(UINTN)ImageBuffer;\r
  MemMapNode.EndingAddress   = (EFI_PHYSICAL_ADDRESS)(UINTN)((UINT8 *)ImageBuffer + ImageSize - 1);\r
\r
  DriverDevicePath = AppendDevicePathNode (NULL, &MemMapNode.Header);\r
  if (DriverDevicePath == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  DEBUG((DEBUG_INFO, "FmpCapsule: LoadImage ...\n"));\r
  Status = gBS->LoadImage(\r
                  FALSE,\r
                  gImageHandle,\r
                  DriverDevicePath,\r
                  ImageBuffer,\r
                  ImageSize,\r
                  &ImageHandle\r
                  );\r
  DEBUG((DEBUG_INFO, "FmpCapsule: LoadImage - %r\n", Status));\r
  if (EFI_ERROR(Status)) {\r
    FreePool(DriverDevicePath);\r
    return Status;\r
  }\r
\r
  DEBUG((DEBUG_INFO, "FmpCapsule: StartImage ...\n"));\r
  Status = gBS->StartImage(\r
                  ImageHandle,\r
                  &ExitDataSize,\r
                  NULL\r
                  );\r
  DEBUG((DEBUG_INFO, "FmpCapsule: StartImage - %r\n", Status));\r
  if (EFI_ERROR(Status)) {\r
    DEBUG ((DEBUG_ERROR, "Driver Return Status = %r\n", Status));\r
  }\r
\r
  FreePool(DriverDevicePath);\r
  return Status;\r
}\r
\r
/**\r
  Record FMP capsule status.\r
\r
  @param[in]  Handle        A FMP handle.\r
  @param[in] CapsuleHeader  The capsule image header\r
  @param[in] CapsuleStatus  The capsule process stauts\r
  @param[in] PayloadIndex   FMP payload index\r
  @param[in] ImageHeader    FMP image header\r
**/\r
VOID\r
RecordFmpCapsuleStatus (\r
  IN EFI_HANDLE                                    Handle,  OPTIONAL\r
  IN EFI_CAPSULE_HEADER                            *CapsuleHeader,\r
  IN EFI_STATUS                                    CapsuleStatus,\r
  IN UINTN                                         PayloadIndex,\r
  IN EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER  *ImageHeader\r
  )\r
{\r
  EFI_STATUS                                    Status;\r
  EFI_DEVICE_PATH_PROTOCOL                      *FmpDevicePath;\r
  UINT32                                        FmpImageInfoDescriptorVer;\r
  EFI_STATUS                                    StatusEsrt;\r
  ESRT_MANAGEMENT_PROTOCOL                      *EsrtProtocol;\r
  EFI_SYSTEM_RESOURCE_ENTRY                     EsrtEntry;\r
\r
  FmpDevicePath = NULL;\r
  if (Handle != NULL) {\r
    gBS->HandleProtocol(\r
           Handle,\r
           &gEfiDevicePathProtocolGuid,\r
           (VOID **)&FmpDevicePath\r
           );\r
  }\r
\r
  RecordFmpCapsuleStatusVariable (\r
    CapsuleHeader,\r
    CapsuleStatus,\r
    PayloadIndex,\r
    ImageHeader,\r
    FmpDevicePath\r
    );\r
\r
  //\r
  // Update corresponding ESRT entry LastAttemp Status\r
  //\r
  Status = gBS->LocateProtocol(&gEsrtManagementProtocolGuid, NULL, (VOID **)&EsrtProtocol);\r
  if (EFI_ERROR (Status)) {\r
    return ;\r
  }\r
\r
  if (Handle == NULL) {\r
    return ;\r
  }\r
\r
  //\r
  // Update EsrtEntry For V1, V2 FMP instance.\r
  // V3 FMP ESRT cache will be synced up through EsrtSyncFmp interface\r
  //\r
  FmpImageInfoDescriptorVer = GetFmpImageInfoDescriptorVer (Handle);\r
  if (FmpImageInfoDescriptorVer < EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION) {\r
    StatusEsrt = EsrtProtocol->GetEsrtEntry(&ImageHeader->UpdateImageTypeId, &EsrtEntry);\r
    if (!EFI_ERROR(StatusEsrt)){\r
      if (!EFI_ERROR(CapsuleStatus)) {\r
        EsrtEntry.LastAttemptStatus = LAST_ATTEMPT_STATUS_SUCCESS;\r
      } else {\r
        EsrtEntry.LastAttemptStatus = LAST_ATTEMPT_STATUS_ERROR_UNSUCCESSFUL;\r
      }\r
      EsrtEntry.LastAttemptVersion = 0;\r
      EsrtProtocol->UpdateEsrtEntry(&EsrtEntry);\r
    }\r
  }\r
}\r
\r
/**\r
  Process Firmware management protocol data capsule.\r
\r
  This function assumes the caller validated the capsule by using\r
  ValidateFmpCapsule(), so that all fields in EFI_CAPSULE_HEADER,\r
  EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER and\r
  EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER are correct.\r
\r
  This function need support nested FMP capsule.\r
\r
  @param[in]   CapsuleHeader         Points to a capsule header.\r
\r
  @retval EFI_SUCESS            Process Capsule Image successfully.\r
  @retval EFI_UNSUPPORTED       Capsule image is not supported by the firmware.\r
  @retval EFI_VOLUME_CORRUPTED  FV volume in the capsule is corrupted.\r
  @retval EFI_OUT_OF_RESOURCES  Not enough memory.\r
  @retval EFI_NOT_READY         No FMP protocol to handle this FMP capsule.\r
**/\r
EFI_STATUS\r
ProcessFmpCapsuleImage (\r
  IN EFI_CAPSULE_HEADER  *CapsuleHeader\r
  )\r
{\r
  EFI_STATUS                                    Status;\r
  EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER        *FmpCapsuleHeader;\r
  EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER  *ImageHeader;\r
  UINT64                                        *ItemOffsetList;\r
  UINT32                                        ItemNum;\r
  UINTN                                         Index;\r
  EFI_HANDLE                                    *HandleBuffer;\r
  UINTN                                         NumberOfHandles;\r
  UINTN                                         DriverLen;\r
  UINT64                                        UpdateHardwareInstance;\r
  UINTN                                         Index2;\r
  BOOLEAN                                       NotReady;\r
  BOOLEAN                                       Abort;\r
\r
  if (!IsFmpCapsuleGuid(&CapsuleHeader->CapsuleGuid)) {\r
    return ProcessFmpCapsuleImage ((EFI_CAPSULE_HEADER *)((UINTN)CapsuleHeader + CapsuleHeader->HeaderSize));\r
  }\r
\r
  NotReady = FALSE;\r
  Abort = FALSE;\r
\r
  DumpFmpCapsule(CapsuleHeader);\r
\r
  FmpCapsuleHeader = (EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER *) ((UINT8 *) CapsuleHeader + CapsuleHeader->HeaderSize);\r
\r
  if (FmpCapsuleHeader->Version > EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER_INIT_VERSION) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
  ItemOffsetList = (UINT64 *)(FmpCapsuleHeader + 1);\r
\r
  ItemNum = FmpCapsuleHeader->EmbeddedDriverCount + FmpCapsuleHeader->PayloadItemCount;\r
\r
  //\r
  // capsule in which driver count and payload count are both zero is not processed.\r
  //\r
  if (ItemNum == 0) {\r
    return EFI_SUCCESS;\r
  }\r
\r
  //\r
  // 1. Try to load & start all the drivers within capsule\r
  //\r
  for (Index = 0; Index < FmpCapsuleHeader->EmbeddedDriverCount; Index++) {\r
    if ((FmpCapsuleHeader->PayloadItemCount == 0) &&\r
        (Index == (UINTN)FmpCapsuleHeader->EmbeddedDriverCount - 1)) {\r
      //\r
      // When driver is last element in the ItemOffsetList array, the driver size is calculated by reference CapsuleImageSize in EFI_CAPSULE_HEADER\r
      //\r
      DriverLen = CapsuleHeader->CapsuleImageSize - CapsuleHeader->HeaderSize - (UINTN)ItemOffsetList[Index];\r
    } else {\r
      DriverLen = (UINTN)ItemOffsetList[Index + 1] - (UINTN)ItemOffsetList[Index];\r
    }\r
\r
    Status = StartFmpImage (\r
               (UINT8 *)FmpCapsuleHeader + ItemOffsetList[Index],\r
               DriverLen\r
               );\r
    if (EFI_ERROR(Status)) {\r
      DEBUG ((DEBUG_ERROR, "Driver Return Status = %r\n", Status));\r
      return Status;\r
    }\r
  }\r
\r
  //\r
  // 2. Route payload to right FMP instance\r
  //\r
  DEBUG((DEBUG_INFO, "FmpCapsule: route payload to right FMP instance ...\n"));\r
\r
  DumpAllFmpInfo ();\r
\r
  //\r
  // Check all the payload entry in capsule payload list\r
  //\r
  for (Index = FmpCapsuleHeader->EmbeddedDriverCount; Index < ItemNum; Index++) {\r
    ImageHeader  = (EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER *)((UINT8 *)FmpCapsuleHeader + ItemOffsetList[Index]);\r
\r
    UpdateHardwareInstance = 0;\r
    if (ImageHeader->Version >= EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER_INIT_VERSION) {\r
      UpdateHardwareInstance = ImageHeader->UpdateHardwareInstance;\r
    }\r
\r
    Status = GetFmpHandleBufferByType (\r
               &ImageHeader->UpdateImageTypeId,\r
               UpdateHardwareInstance,\r
               &NumberOfHandles,\r
               &HandleBuffer\r
               );\r
    if (EFI_ERROR(Status)) {\r
      NotReady = TRUE;\r
      RecordFmpCapsuleStatus (\r
        NULL,\r
        CapsuleHeader,\r
        EFI_NOT_READY,\r
        Index - FmpCapsuleHeader->EmbeddedDriverCount,\r
        ImageHeader\r
        );\r
      continue;\r
    }\r
\r
    for (Index2 = 0; Index2 < NumberOfHandles; Index2++) {\r
      if (Abort) {\r
        RecordFmpCapsuleStatus (\r
          HandleBuffer[Index2],\r
          CapsuleHeader,\r
          EFI_ABORTED,\r
          Index - FmpCapsuleHeader->EmbeddedDriverCount,\r
          ImageHeader\r
          );\r
        continue;\r
      }\r
\r
      Status = SetFmpImageData (\r
                 HandleBuffer[Index2],\r
                 ImageHeader,\r
                 Index - FmpCapsuleHeader->EmbeddedDriverCount\r
                 );\r
      if (Status != EFI_SUCCESS) {\r
        Abort = TRUE;\r
      }\r
\r
      RecordFmpCapsuleStatus (\r
        HandleBuffer[Index2],\r
        CapsuleHeader,\r
        Status,\r
        Index - FmpCapsuleHeader->EmbeddedDriverCount,\r
        ImageHeader\r
        );\r
    }\r
    if (HandleBuffer != NULL) {\r
      FreePool(HandleBuffer);\r
    }\r
  }\r
\r
  if (NotReady) {\r
    return EFI_NOT_READY;\r
  }\r
\r
  //\r
  // always return SUCCESS to indicate this capsule is processed.\r
  // The status of SetImage is recorded in capsule result variable.\r
  //\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Return if there is a FMP header below capsule header.\r
\r
  @param[in] CapsuleHeader A pointer to EFI_CAPSULE_HEADER\r
\r
  @retval TRUE  There is a FMP header below capsule header.\r
  @retval FALSE There is not a FMP header below capsule header\r
**/\r
BOOLEAN\r
IsNestedFmpCapsule (\r
  IN EFI_CAPSULE_HEADER         *CapsuleHeader\r
  )\r
{\r
  EFI_STATUS                 Status;\r
  EFI_SYSTEM_RESOURCE_TABLE  *Esrt;\r
  EFI_SYSTEM_RESOURCE_ENTRY  *EsrtEntry;\r
  UINTN                      Index;\r
  BOOLEAN                    EsrtGuidFound;\r
  EFI_CAPSULE_HEADER         *NestedCapsuleHeader;\r
  UINTN                      NestedCapsuleSize;\r
  ESRT_MANAGEMENT_PROTOCOL   *EsrtProtocol;\r
  EFI_SYSTEM_RESOURCE_ENTRY  Entry;\r
\r
  EsrtGuidFound = FALSE;\r
\r
  //\r
  // Check ESRT protocol\r
  //\r
  Status = gBS->LocateProtocol(&gEsrtManagementProtocolGuid, NULL, (VOID **)&EsrtProtocol);\r
  if (!EFI_ERROR(Status)) {\r
    Status = EsrtProtocol->GetEsrtEntry(&CapsuleHeader->CapsuleGuid, &Entry);\r
    if (!EFI_ERROR(Status)) {\r
      EsrtGuidFound = TRUE;\r
    }\r
  }\r
\r
  //\r
  // Check ESRT configuration table\r
  //\r
  if (!EsrtGuidFound) {\r
    Status = EfiGetSystemConfigurationTable(&gEfiSystemResourceTableGuid, (VOID **)&Esrt);\r
    if (!EFI_ERROR(Status)) {\r
      ASSERT (Esrt != NULL);\r
      EsrtEntry = (VOID *)(Esrt + 1);\r
      for (Index = 0; Index < Esrt->FwResourceCount; Index++, EsrtEntry++) {\r
        if (CompareGuid(&EsrtEntry->FwClass, &CapsuleHeader->CapsuleGuid)) {\r
          EsrtGuidFound = TRUE;\r
          break;\r
        }\r
      }\r
    }\r
  }\r
  if (!EsrtGuidFound) {\r
    return FALSE;\r
  }\r
\r
  //\r
  // Check nested capsule header\r
  // FMP GUID after ESRT one\r
  //\r
  NestedCapsuleHeader = (EFI_CAPSULE_HEADER *)((UINT8 *)CapsuleHeader + CapsuleHeader->HeaderSize);\r
  NestedCapsuleSize = (UINTN)CapsuleHeader + CapsuleHeader->CapsuleImageSize - (UINTN)NestedCapsuleHeader;\r
  if (NestedCapsuleSize < sizeof(EFI_CAPSULE_HEADER)) {\r
    return FALSE;\r
  }\r
  if (!IsValidCapsuleHeader(NestedCapsuleHeader, NestedCapsuleSize)) {\r
    return FALSE;\r
  }\r
  if (!IsFmpCapsuleGuid(&NestedCapsuleHeader->CapsuleGuid)) {\r
    return FALSE;\r
  }\r
  DEBUG ((DEBUG_INFO, "IsNestedFmpCapsule\n"));\r
  return TRUE;\r
}\r
\r
/**\r
  Return if this FMP is a system FMP or a device FMP, based upon CapsuleHeader.\r
\r
  @param[in] CapsuleHeader A pointer to EFI_CAPSULE_HEADER\r
\r
  @retval TRUE  It is a system FMP.\r
  @retval FALSE It is a device FMP.\r
**/\r
BOOLEAN\r
IsFmpCapsule (\r
  IN EFI_CAPSULE_HEADER         *CapsuleHeader\r
  )\r
{\r
  if (IsFmpCapsuleGuid(&CapsuleHeader->CapsuleGuid)) {\r
    return TRUE;\r
  }\r
  if (IsNestedFmpCapsule(CapsuleHeader)) {\r
    return TRUE;\r
  }\r
  return FALSE;\r
}\r
\r
/**\r
  Those capsules supported by the firmwares.\r
\r
  Caution: This function may receive untrusted input.\r
\r
  @param[in]  CapsuleHeader    Points to a capsule header.\r
\r
  @retval EFI_SUCESS       Input capsule is supported by firmware.\r
  @retval EFI_UNSUPPORTED  Input capsule is not supported by the firmware.\r
  @retval EFI_INVALID_PARAMETER Input capsule layout is not correct\r
**/\r
EFI_STATUS\r
EFIAPI\r
SupportCapsuleImage (\r
  IN EFI_CAPSULE_HEADER  *CapsuleHeader\r
  )\r
{\r
  //\r
  // check Display Capsule Guid\r
  //\r
  if (CompareGuid (&gWindowsUxCapsuleGuid, &CapsuleHeader->CapsuleGuid)) {\r
    return EFI_SUCCESS;\r
  }\r
\r
  if (IsFmpCapsule(CapsuleHeader)) {\r
    //\r
    // Check layout of FMP capsule\r
    //\r
    return ValidateFmpCapsule(CapsuleHeader, NULL);\r
  }\r
  DEBUG((DEBUG_ERROR, "Unknown Capsule Guid - %g\n", &CapsuleHeader->CapsuleGuid));\r
  return EFI_UNSUPPORTED;\r
}\r
\r
/**\r
  The firmware implements to process the capsule image.\r
\r
  Caution: This function may receive untrusted input.\r
\r
  @param[in]  CapsuleHeader         Points to a capsule header.\r
\r
  @retval EFI_SUCESS            Process Capsule Image successfully.\r
  @retval EFI_UNSUPPORTED       Capsule image is not supported by the firmware.\r
  @retval EFI_VOLUME_CORRUPTED  FV volume in the capsule is corrupted.\r
  @retval EFI_OUT_OF_RESOURCES  Not enough memory.\r
**/\r
EFI_STATUS\r
EFIAPI\r
ProcessCapsuleImage (\r
  IN EFI_CAPSULE_HEADER  *CapsuleHeader\r
  )\r
{\r
  EFI_STATUS                   Status;\r
\r
  if (SupportCapsuleImage (CapsuleHeader) != EFI_SUCCESS) {\r
    RecordCapsuleStatusVariable(CapsuleHeader, EFI_UNSUPPORTED);\r
    return EFI_UNSUPPORTED;\r
  }\r
\r
  //\r
  // Display image in firmware update display capsule\r
  //\r
  if (CompareGuid (&gWindowsUxCapsuleGuid, &CapsuleHeader->CapsuleGuid)) {\r
    DEBUG((DEBUG_INFO, "ProcessCapsuleImage for WindowsUxCapsule ...\n"));\r
    Status = DisplayCapsuleImage(CapsuleHeader);\r
    RecordCapsuleStatusVariable(CapsuleHeader, Status);\r
    return Status;\r
  }\r
\r
  //\r
  // Check FMP capsule layout\r
  //\r
  if (IsFmpCapsule (CapsuleHeader)) {\r
    DEBUG((DEBUG_INFO, "ProcessCapsuleImage for FmpCapsule ...\n"));\r
    DEBUG((DEBUG_INFO, "ValidateFmpCapsule ...\n"));\r
    Status = ValidateFmpCapsule(CapsuleHeader, NULL);\r
    DEBUG((DEBUG_INFO, "ValidateFmpCapsule - %r\n", Status));\r
    if (EFI_ERROR(Status)) {\r
      RecordCapsuleStatusVariable(CapsuleHeader, Status);\r
      return Status;\r
    }\r
\r
    //\r
    // Press EFI FMP Capsule\r
    //\r
    DEBUG((DEBUG_INFO, "ProcessFmpCapsuleImage ...\n"));\r
    Status = ProcessFmpCapsuleImage(CapsuleHeader);\r
    DEBUG((DEBUG_INFO, "ProcessFmpCapsuleImage - %r\n", Status));\r
\r
    return Status;\r
  }\r
\r
  return EFI_UNSUPPORTED;\r
}\r
\r
/**\r
  Callback function executed when the EndOfDxe event group is signaled.\r
\r
  @param[in] Event      Event whose notification function is being invoked.\r
  @param[in] Context    The pointer to the notification function's context, which\r
                        is implementation-dependent.\r
**/\r
VOID\r
EFIAPI\r
DxeCapsuleLibEndOfDxe (\r
  IN EFI_EVENT  Event,\r
  IN VOID       *Context\r
  )\r
{\r
  mDxeCapsuleLibEndOfDxe = TRUE;\r
}\r
\r
/**\r
  The constructor function.\r
\r
  @param[in]  ImageHandle   The firmware allocated handle for the EFI image.\r
  @param[in]  SystemTable   A pointer to the EFI System Table.\r
\r
  @retval EFI_SUCCESS   The constructor successfully .\r
**/\r
EFI_STATUS\r
EFIAPI\r
DxeCapsuleLibConstructor (\r
  IN EFI_HANDLE         ImageHandle,\r
  IN EFI_SYSTEM_TABLE   *SystemTable\r
  )\r
{\r
  EFI_EVENT     EndOfDxeEvent;\r
  EFI_STATUS    Status;\r
\r
  Status = gBS->CreateEventEx (\r
                  EVT_NOTIFY_SIGNAL,\r
                  TPL_CALLBACK,\r
                  DxeCapsuleLibEndOfDxe,\r
                  NULL,\r
                  &gEfiEndOfDxeEventGroupGuid,\r
                  &EndOfDxeEvent\r
                  );\r
  ASSERT_EFI_ERROR (Status);\r
\r
  InitCapsuleVariable();\r
\r
  return EFI_SUCCESS;\r
}\r