[mirror_edk2.git] / MdeModulePkg / Application / CapsuleApp / CapsuleApp.c

/** @file\r
  A shell application that triggers capsule update process.\r
\r
  Copyright (c) 2016 - 2018, 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 <Uefi.h>\r
#include <Library/BaseLib.h>\r
#include <Library/DebugLib.h>\r
#include <Library/BaseMemoryLib.h>\r
#include <Library/MemoryAllocationLib.h>\r
#include <Library/UefiBootServicesTableLib.h>\r
#include <Library/UefiRuntimeServicesTableLib.h>\r
#include <Library/UefiLib.h>\r
#include <Library/PrintLib.h>\r
#include <Library/BmpSupportLib.h>\r
#include <Protocol/GraphicsOutput.h>\r
#include <Guid/GlobalVariable.h>\r
#include <Guid/CapsuleReport.h>\r
#include <Guid/SystemResourceTable.h>\r
#include <Guid/FmpCapsule.h>\r
#include <IndustryStandard/WindowsUxCapsule.h>\r
\r
#define CAPSULE_HEADER_SIZE  0x20\r
\r
#define NESTED_CAPSULE_HEADER_SIZE  SIZE_4KB\r
#define SYSTEM_FIRMWARE_FLAG 0x50000\r
#define DEVICE_FIRMWARE_FLAG 0x78010\r
\r
#define MAJOR_VERSION   1\r
#define MINOR_VERSION   0\r
\r
#define MAX_CAPSULE_NUM 10\r
\r
extern UINTN  Argc;\r
extern CHAR16 **Argv;\r
\r
//\r
// Define how many block descriptors we want to test with.\r
//\r
UINTN  NumberOfDescriptors = 1;\r
UINTN  CapsuleFirstIndex;\r
UINTN  CapsuleLastIndex;\r
\r
/**\r
  Dump capsule information\r
\r
  @param[in] CapsuleName  The name of the capsule image.\r
\r
  @retval EFI_SUCCESS            The capsule information is dumped.\r
  @retval EFI_UNSUPPORTED        Input parameter is not valid.\r
**/\r
EFI_STATUS\r
DumpCapsule (\r
  IN CHAR16                                        *CapsuleName\r
  );\r
\r
/**\r
  Dump capsule status variable.\r
\r
  @retval EFI_SUCCESS            The capsule status variable is dumped.\r
  @retval EFI_UNSUPPORTED        Input parameter is not valid.\r
**/\r
EFI_STATUS\r
DumpCapsuleStatusVariable (\r
  VOID\r
  );\r
\r
/**\r
  Dump FMP protocol info.\r
**/\r
VOID\r
DumpFmpData (\r
  VOID\r
  );\r
\r
/**\r
  Dump FMP image data.\r
\r
  @param[in]  ImageTypeId   The ImageTypeId of the FMP image.\r
                            It is used to identify the FMP protocol.\r
  @param[in]  ImageIndex    The ImageIndex of the FMP image.\r
                            It is the input parameter for FMP->GetImage().\r
  @param[in]  ImageName     The file name to hold the output FMP image.\r
**/\r
VOID\r
DumpFmpImage (\r
  IN EFI_GUID  *ImageTypeId,\r
  IN UINTN     ImageIndex,\r
  IN CHAR16    *ImageName\r
  );\r
\r
/**\r
  Dump ESRT info.\r
**/\r
VOID\r
DumpEsrtData (\r
  VOID\r
  );\r
\r
/**\r
  Read a file.\r
\r
  @param[in]  FileName        The file to be read.\r
  @param[out] BufferSize      The file buffer size\r
  @param[out] Buffer          The file buffer\r
\r
  @retval EFI_SUCCESS    Read file successfully\r
  @retval EFI_NOT_FOUND  Shell protocol or file not found\r
  @retval others         Read file failed\r
**/\r
EFI_STATUS\r
ReadFileToBuffer (\r
  IN  CHAR16                               *FileName,\r
  OUT UINTN                                *BufferSize,\r
  OUT VOID                                 **Buffer\r
  );\r
\r
/**\r
  Write a file.\r
\r
  @param[in] FileName        The file to be written.\r
  @param[in] BufferSize      The file buffer size\r
  @param[in] Buffer          The file buffer\r
\r
  @retval EFI_SUCCESS    Write file successfully\r
  @retval EFI_NOT_FOUND  Shell protocol not found\r
  @retval others         Write file failed\r
**/\r
EFI_STATUS\r
WriteFileFromBuffer (\r
  IN  CHAR16                               *FileName,\r
  IN  UINTN                                BufferSize,\r
  IN  VOID                                 *Buffer\r
  );\r
\r
/**\r
\r
  This function parse application ARG.\r
\r
  @return Status\r
**/\r
EFI_STATUS\r
GetArg (\r
  VOID\r
  );\r
\r
/**\r
  Create UX capsule.\r
\r
  @retval EFI_SUCCESS            The capsule header is appended.\r
  @retval EFI_UNSUPPORTED        Input parameter is not valid.\r
  @retval EFI_OUT_OF_RESOURCES   No enough resource to create UX capsule.\r
**/\r
EFI_STATUS\r
CreateBmpFmp (\r
  VOID\r
  )\r
{\r
  CHAR16                                        *OutputCapsuleName;\r
  VOID                                          *BmpBuffer;\r
  UINTN                                         FileSize;\r
  CHAR16                                        *BmpName;\r
  UINT8                                         *FullCapsuleBuffer;\r
  UINTN                                         FullCapsuleBufferSize;\r
  EFI_DISPLAY_CAPSULE                           *DisplayCapsule;\r
  EFI_STATUS                                    Status;\r
  EFI_GRAPHICS_OUTPUT_PROTOCOL                  *Gop;\r
  EFI_GRAPHICS_OUTPUT_MODE_INFORMATION          *Info;\r
  EFI_GRAPHICS_OUTPUT_BLT_PIXEL                 *GopBlt;\r
  UINTN                                         GopBltSize;\r
  UINTN                                         Height;\r
  UINTN                                         Width;\r
\r
  Status = gBS->LocateProtocol(&gEfiGraphicsOutputProtocolGuid, NULL, (VOID **)&Gop);\r
  if (EFI_ERROR(Status)) {\r
    Print(L"CapsuleApp: NO GOP is found.\n");\r
    return EFI_UNSUPPORTED;\r
  }\r
  Info = Gop->Mode->Info;\r
  Print(L"Current GOP: Mode - %d, ", Gop->Mode->Mode);\r
  Print(L"HorizontalResolution - %d, ", Info->HorizontalResolution);\r
  Print(L"VerticalResolution - %d\n", Info->VerticalResolution);\r
  // HorizontalResolution >= BMP_IMAGE_HEADER.PixelWidth\r
  // VerticalResolution   >= BMP_IMAGE_HEADER.PixelHeight\r
\r
  if (Argc != 5) {\r
    Print(L"CapsuleApp: Incorrect parameter count.\n");\r
    return EFI_UNSUPPORTED;\r
  }\r
\r
  if (StrCmp(Argv[3], L"-O") != 0) {\r
    Print(L"CapsuleApp: NO output capsule name.\n");\r
    return EFI_UNSUPPORTED;\r
  }\r
  OutputCapsuleName = Argv[4];\r
\r
  BmpBuffer = NULL;\r
  FileSize = 0;\r
  FullCapsuleBuffer = NULL;\r
\r
  BmpName = Argv[2];\r
  Status = ReadFileToBuffer(BmpName, &FileSize, &BmpBuffer);\r
  if (EFI_ERROR(Status)) {\r
    Print(L"CapsuleApp: BMP image (%s) is not found.\n", BmpName);\r
    goto Done;\r
  }\r
\r
  GopBlt = NULL;\r
  Status = TranslateBmpToGopBlt (\r
             BmpBuffer,\r
             FileSize,\r
             &GopBlt,\r
             &GopBltSize,\r
             &Height,\r
             &Width\r
             );\r
  if (EFI_ERROR(Status)) {\r
    Print(L"CapsuleApp: BMP image (%s) is not valid.\n", BmpName);\r
    goto Done;\r
  }\r
  if (GopBlt != NULL) {\r
    FreePool (GopBlt);\r
  }\r
  Print(L"BMP image (%s), Width - %d, Height - %d\n", BmpName, Width, Height);\r
\r
  if (Height > Info->VerticalResolution) {\r
    Status = EFI_INVALID_PARAMETER;\r
    Print(L"CapsuleApp: BMP image (%s) height is larger than current resolution.\n", BmpName);\r
    goto Done;\r
  }\r
  if (Width > Info->HorizontalResolution) {\r
    Status = EFI_INVALID_PARAMETER;\r
    Print(L"CapsuleApp: BMP image (%s) width is larger than current resolution.\n", BmpName);\r
    goto Done;\r
  }\r
\r
  FullCapsuleBufferSize = sizeof(EFI_DISPLAY_CAPSULE) + FileSize;\r
  FullCapsuleBuffer = AllocatePool(FullCapsuleBufferSize);\r
  if (FullCapsuleBuffer == NULL) {\r
    Print(L"CapsuleApp: Capsule Buffer size (0x%x) too big.\n", FullCapsuleBufferSize);\r
    Status = EFI_OUT_OF_RESOURCES;\r
    goto Done;\r
  }\r
\r
  DisplayCapsule = (EFI_DISPLAY_CAPSULE *)FullCapsuleBuffer;\r
  CopyGuid(&DisplayCapsule->CapsuleHeader.CapsuleGuid, &gWindowsUxCapsuleGuid);\r
  DisplayCapsule->CapsuleHeader.HeaderSize = sizeof(DisplayCapsule->CapsuleHeader);\r
  DisplayCapsule->CapsuleHeader.Flags = CAPSULE_FLAGS_PERSIST_ACROSS_RESET;\r
  DisplayCapsule->CapsuleHeader.CapsuleImageSize = (UINT32)FullCapsuleBufferSize;\r
\r
  DisplayCapsule->ImagePayload.Version = 1;\r
  DisplayCapsule->ImagePayload.Checksum = 0;\r
  DisplayCapsule->ImagePayload.ImageType = 0; // BMP\r
  DisplayCapsule->ImagePayload.Reserved = 0;\r
  DisplayCapsule->ImagePayload.Mode = Gop->Mode->Mode;\r
\r
  //\r
  // Center the bitmap horizontally\r
  //\r
  DisplayCapsule->ImagePayload.OffsetX = (UINT32)((Info->HorizontalResolution - Width) / 2);\r
\r
  //\r
  // Put bitmap 3/4 down the display.  If bitmap is too tall, then align bottom\r
  // of bitmap at bottom of display.\r
  //\r
  DisplayCapsule->ImagePayload.OffsetY =\r
    MIN (\r
      (UINT32)(Info->VerticalResolution - Height),\r
      (UINT32)(((3 * Info->VerticalResolution) - (2 * Height)) / 4)\r
      );\r
\r
  Print(L"BMP image (%s), OffsetX - %d, OffsetY - %d\n",\r
    BmpName,\r
    DisplayCapsule->ImagePayload.OffsetX,\r
    DisplayCapsule->ImagePayload.OffsetY\r
    );\r
\r
  CopyMem((DisplayCapsule + 1), BmpBuffer, FileSize);\r
\r
  DisplayCapsule->ImagePayload.Checksum = CalculateCheckSum8(FullCapsuleBuffer, FullCapsuleBufferSize);\r
\r
  Status = WriteFileFromBuffer(OutputCapsuleName, FullCapsuleBufferSize, FullCapsuleBuffer);\r
  Print(L"CapsuleApp: Write %s %r\n", OutputCapsuleName, Status);\r
\r
Done:\r
  if (BmpBuffer != NULL) {\r
    FreePool(BmpBuffer);\r
  }\r
\r
  if (FullCapsuleBuffer != NULL) {\r
    FreePool(FullCapsuleBuffer);\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
  Get ImageTypeId in the FMP capsule header.\r
\r
  @param[in] CapsuleHeader  The FMP capsule image header.\r
\r
  @return ImageTypeId\r
**/\r
EFI_GUID *\r
GetCapsuleImageTypeId (\r
  IN EFI_CAPSULE_HEADER                            *CapsuleHeader\r
  )\r
{\r
  EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER       *FmpCapsuleHeader;\r
  UINT64                                       *ItemOffsetList;\r
  EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER *ImageHeader;\r
\r
  FmpCapsuleHeader = (EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER *)((UINT8 *)CapsuleHeader + CapsuleHeader->HeaderSize);\r
  ItemOffsetList = (UINT64 *)(FmpCapsuleHeader + 1);\r
  if (FmpCapsuleHeader->PayloadItemCount == 0) {\r
    return NULL;\r
  }\r
  ImageHeader = (EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER *)((UINT8 *)FmpCapsuleHeader + ItemOffsetList[FmpCapsuleHeader->EmbeddedDriverCount]);\r
  return &ImageHeader->UpdateImageTypeId;\r
}\r
\r
/**\r
  Get ESRT FwType according to ImageTypeId\r
\r
  @param[in]  ImageTypeId   ImageTypeId of an FMP capsule.\r
\r
  @return ESRT FwType\r
**/\r
UINT32\r
GetEsrtFwType (\r
  IN  EFI_GUID                                      *ImageTypeId\r
  )\r
{\r
  EFI_STATUS                 Status;\r
  EFI_SYSTEM_RESOURCE_TABLE  *Esrt;\r
  EFI_SYSTEM_RESOURCE_ENTRY  *EsrtEntry;\r
  UINTN                      Index;\r
\r
  //\r
  // Check ESRT\r
  //\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, ImageTypeId)) {\r
        return EsrtEntry->FwType;\r
      }\r
    }\r
  }\r
\r
  return ESRT_FW_TYPE_UNKNOWN;\r
}\r
\r
/**\r
  Append a capsule header on top of current image.\r
  This function follows Windows UEFI Firmware Update Platform document.\r
\r
  @retval EFI_SUCCESS            The capsule header is appended.\r
  @retval EFI_UNSUPPORTED        Input parameter is not valid.\r
  @retval EFI_OUT_OF_RESOURCES   No enough resource to append capsule header.\r
**/\r
EFI_STATUS\r
CreateNestedFmp (\r
  VOID\r
  )\r
{\r
  CHAR16                                        *OutputCapsuleName;\r
  VOID                                          *CapsuleBuffer;\r
  UINTN                                         FileSize;\r
  CHAR16                                        *CapsuleName;\r
  UINT8                                         *FullCapsuleBuffer;\r
  UINTN                                         FullCapsuleBufferSize;\r
  EFI_CAPSULE_HEADER                            *NestedCapsuleHeader;\r
  EFI_GUID                                      *ImageTypeId;\r
  UINT32                                        FwType;\r
  EFI_STATUS                                    Status;\r
\r
  if (Argc != 5) {\r
    Print(L"CapsuleApp: Incorrect parameter count.\n");\r
    return EFI_UNSUPPORTED;\r
  }\r
\r
  if (StrCmp(Argv[3], L"-O") != 0) {\r
    Print(L"CapsuleApp: NO output capsule name.\n");\r
    return EFI_UNSUPPORTED;\r
  }\r
  OutputCapsuleName = Argv[4];\r
\r
  CapsuleBuffer = NULL;\r
  FileSize = 0;\r
  FullCapsuleBuffer = NULL;\r
\r
  CapsuleName = Argv[2];\r
  Status = ReadFileToBuffer(CapsuleName, &FileSize, &CapsuleBuffer);\r
  if (EFI_ERROR(Status)) {\r
    Print(L"CapsuleApp: Capsule image (%s) is not found.\n", CapsuleName);\r
    goto Done;\r
  }\r
\r
  ImageTypeId = GetCapsuleImageTypeId(CapsuleBuffer);\r
  if (ImageTypeId == NULL) {\r
    Print(L"CapsuleApp: Capsule ImageTypeId is not found.\n");\r
    goto Done;\r
  }\r
  FwType = GetEsrtFwType(ImageTypeId);\r
  if ((FwType != ESRT_FW_TYPE_SYSTEMFIRMWARE) && (FwType != ESRT_FW_TYPE_DEVICEFIRMWARE)) {\r
    Print(L"CapsuleApp: Capsule FwType is invalid.\n");\r
    goto Done;\r
  }\r
\r
  FullCapsuleBufferSize = NESTED_CAPSULE_HEADER_SIZE + FileSize;\r
  FullCapsuleBuffer = AllocatePool(FullCapsuleBufferSize);\r
  if (FullCapsuleBuffer == NULL) {\r
    Print(L"CapsuleApp: Capsule Buffer size (0x%x) too big.\n", FullCapsuleBufferSize);\r
    Status = EFI_OUT_OF_RESOURCES;\r
    goto Done;\r
  }\r
\r
  NestedCapsuleHeader = (EFI_CAPSULE_HEADER *)FullCapsuleBuffer;\r
  ZeroMem(NestedCapsuleHeader, NESTED_CAPSULE_HEADER_SIZE);\r
  CopyGuid(&NestedCapsuleHeader->CapsuleGuid, ImageTypeId);\r
  NestedCapsuleHeader->HeaderSize = NESTED_CAPSULE_HEADER_SIZE;\r
  NestedCapsuleHeader->Flags = (FwType == ESRT_FW_TYPE_SYSTEMFIRMWARE) ? SYSTEM_FIRMWARE_FLAG : DEVICE_FIRMWARE_FLAG;\r
  NestedCapsuleHeader->CapsuleImageSize = (UINT32)FullCapsuleBufferSize;\r
\r
  CopyMem((UINT8 *)NestedCapsuleHeader + NestedCapsuleHeader->HeaderSize, CapsuleBuffer, FileSize);\r
\r
  Status = WriteFileFromBuffer(OutputCapsuleName, FullCapsuleBufferSize, FullCapsuleBuffer);\r
  Print(L"CapsuleApp: Write %s %r\n", OutputCapsuleName, Status);\r
\r
Done:\r
  if (CapsuleBuffer != NULL) {\r
    FreePool(CapsuleBuffer);\r
  }\r
\r
  if (FullCapsuleBuffer != NULL) {\r
    FreePool(FullCapsuleBuffer);\r
  }\r
\r
  return Status;\r
}\r
\r
\r
/**\r
  Clear capsule status variable.\r
\r
  @retval EFI_SUCCESS            The capsule status variable is cleared.\r
**/\r
EFI_STATUS\r
ClearCapsuleStatusVariable (\r
  VOID\r
  )\r
{\r
  EFI_STATUS                          Status;\r
  UINT32                              Index;\r
  CHAR16                              CapsuleVarName[20];\r
  CHAR16                              *TempVarName;\r
  BOOLEAN                             Found;\r
\r
  StrCpyS (CapsuleVarName, sizeof(CapsuleVarName)/sizeof(CapsuleVarName[0]), L"Capsule");\r
  TempVarName = CapsuleVarName + StrLen (CapsuleVarName);\r
  Index = 0;\r
\r
  Found = FALSE;\r
  while (TRUE) {\r
    UnicodeSPrint (TempVarName, 5 * sizeof(CHAR16), L"%04x", Index);\r
\r
    Status = gRT->SetVariable (\r
                    CapsuleVarName,\r
                    &gEfiCapsuleReportGuid,\r
                    EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS,\r
                    0,\r
                    (VOID *)NULL\r
                    );\r
    if (Status == EFI_NOT_FOUND) {\r
      //\r
      // There is no more capsule variables, quit\r
      //\r
      break;\r
    }\r
    Found = TRUE;\r
\r
    Print (L"Clear %s %r\n", CapsuleVarName, Status);\r
\r
    Index++;\r
    if (Index > 0xFFFF) {\r
      break;\r
    }\r
  }\r
\r
  if (!Found) {\r
    Print (L"No any Capsule#### variable found\n");\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Build Gather list for a list of capsule images.\r
\r
  @param[in]  CapsuleBuffer    An array of pointer to capsule images\r
  @param[in]  FileSize         An array of UINTN to capsule images size\r
  @param[in]  CapsuleNum       The count of capsule images\r
  @param[out] BlockDescriptors The block descriptors for the capsule images\r
\r
  @retval EFI_SUCCESS The block descriptors for the capsule images are constructed.\r
**/\r
EFI_STATUS\r
BuildGatherList (\r
  IN VOID                          **CapsuleBuffer,\r
  IN UINTN                         *FileSize,\r
  IN UINTN                         CapsuleNum,\r
  OUT EFI_CAPSULE_BLOCK_DESCRIPTOR **BlockDescriptors\r
  )\r
{\r
  EFI_STATUS                    Status;\r
  EFI_CAPSULE_BLOCK_DESCRIPTOR  *BlockDescriptors1;\r
  EFI_CAPSULE_BLOCK_DESCRIPTOR  *BlockDescriptors2;\r
  EFI_CAPSULE_BLOCK_DESCRIPTOR  *BlockDescriptorPre;\r
  EFI_CAPSULE_BLOCK_DESCRIPTOR  *BlockDescriptorsHeader;\r
  EFI_CAPSULE_BLOCK_DESCRIPTOR  *TempBlockPtr;\r
  UINT8                         *TempDataPtr;\r
  UINTN                         SizeLeft;\r
  UINTN                         Size;\r
  INT32                         Count;\r
  INT32                         Number;\r
  UINTN                         Index;\r
\r
  TempBlockPtr           = NULL;\r
  BlockDescriptors1      = NULL;\r
  BlockDescriptors2      = NULL;\r
  BlockDescriptorPre     = NULL;\r
  BlockDescriptorsHeader = NULL;\r
\r
  for (Index = 0; Index < CapsuleNum; Index++) {\r
    //\r
    // Allocate memory for the descriptors.\r
    //\r
    if (NumberOfDescriptors == 1) {\r
      Count = 2;\r
    } else {\r
      Count = (INT32)(NumberOfDescriptors + 2) / 2;\r
    }\r
\r
    Size               = Count * sizeof (EFI_CAPSULE_BLOCK_DESCRIPTOR);\r
    BlockDescriptors1  = AllocateRuntimeZeroPool (Size);\r
    if (BlockDescriptors1 == NULL) {\r
      Print (L"CapsuleApp: failed to allocate memory for descriptors\n");\r
      Status = EFI_OUT_OF_RESOURCES;\r
      goto ERREXIT;\r
    } else {\r
      Print (L"CapsuleApp: creating capsule descriptors at 0x%X\n", (UINTN) BlockDescriptors1);\r
      Print (L"CapsuleApp: capsule data starts          at 0x%X with size 0x%X\n", (UINTN) CapsuleBuffer[Index], FileSize[Index]);\r
    }\r
\r
    //\r
    // Record descirptor header\r
    //\r
    if (Index == 0) {\r
      BlockDescriptorsHeader = BlockDescriptors1;\r
    }\r
\r
    if (BlockDescriptorPre != NULL) {\r
      BlockDescriptorPre->Union.ContinuationPointer = (UINTN) BlockDescriptors1;\r
      BlockDescriptorPre->Length = 0;\r
    }\r
\r
    //\r
    // Fill them in\r
    //\r
    TempBlockPtr  = BlockDescriptors1;\r
    TempDataPtr   = CapsuleBuffer[Index];\r
    SizeLeft      = FileSize[Index];\r
    for (Number = 0; (Number < Count - 1) && (SizeLeft != 0); Number++) {\r
      //\r
      // Divide remaining data in half\r
      //\r
      if (NumberOfDescriptors != 1) {\r
        if (SizeLeft == 1) {\r
          Size = 1;\r
        } else {\r
          Size = SizeLeft / 2;\r
        }\r
      } else {\r
        Size = SizeLeft;\r
      }\r
      TempBlockPtr->Union.DataBlock    = (UINTN)TempDataPtr;\r
      TempBlockPtr->Length  = Size;\r
      Print (L"CapsuleApp: capsule block/size              0x%X/0x%X\n", (UINTN) TempDataPtr, Size);\r
      SizeLeft -= Size;\r
      TempDataPtr += Size;\r
      TempBlockPtr++;\r
    }\r
\r
    //\r
    // Allocate the second list, point the first block's last entry to point\r
    // to this one, and fill this one in. Worst case is that the previous\r
    // list only had one element that pointed here, so we need at least two\r
    // elements -- one to point to all the data, another to terminate the list.\r
    //\r
    if ((NumberOfDescriptors != 1) && (SizeLeft != 0)) {\r
      Count = (INT32)(NumberOfDescriptors + 2) - Count;\r
      if (Count == 1) {\r
        Count++;\r
      }\r
\r
      Size              = Count * sizeof (EFI_CAPSULE_BLOCK_DESCRIPTOR);\r
      BlockDescriptors2 = AllocateRuntimeZeroPool (Size);\r
      if (BlockDescriptors2 == NULL) {\r
        Print (L"CapsuleApp: failed to allocate memory for descriptors\n");\r
        Status = EFI_OUT_OF_RESOURCES;\r
        goto ERREXIT;\r
      }\r
\r
      //\r
      // Point the first list's last element to point to this second list.\r
      //\r
      TempBlockPtr->Union.ContinuationPointer   = (UINTN) BlockDescriptors2;\r
\r
      TempBlockPtr->Length  = 0;\r
      TempBlockPtr = BlockDescriptors2;\r
      for (Number = 0; Number < Count - 1; Number++) {\r
        //\r
        // If second-to-last one, then dump rest to this element\r
        //\r
        if (Number == (Count - 2)) {\r
          Size = SizeLeft;\r
        } else {\r
          //\r
          // Divide remaining data in half\r
          //\r
          if (SizeLeft == 1) {\r
            Size = 1;\r
          } else {\r
            Size = SizeLeft / 2;\r
          }\r
        }\r
\r
        TempBlockPtr->Union.DataBlock    = (UINTN)TempDataPtr;\r
        TempBlockPtr->Length  = Size;\r
        Print (L"CapsuleApp: capsule block/size              0x%X/0x%X\n", (UINTN) TempDataPtr, Size);\r
        SizeLeft -= Size;\r
        TempDataPtr += Size;\r
        TempBlockPtr++;\r
        if (SizeLeft == 0) {\r
          break;\r
        }\r
      }\r
    }\r
\r
    BlockDescriptorPre = TempBlockPtr;\r
    BlockDescriptors1  = NULL;\r
  }\r
\r
  //\r
  // Null-terminate.\r
  //\r
  if (TempBlockPtr != NULL) {\r
    TempBlockPtr->Union.ContinuationPointer    = (UINTN)NULL;\r
    TempBlockPtr->Length  = 0;\r
    *BlockDescriptors = BlockDescriptorsHeader;\r
  }\r
\r
  return EFI_SUCCESS;\r
\r
ERREXIT:\r
  if (BlockDescriptors1 != NULL) {\r
    FreePool(BlockDescriptors1);\r
  }\r
\r
  if (BlockDescriptors2 != NULL) {\r
    FreePool(BlockDescriptors2);\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
  Clear the Gather list for a list of capsule images.\r
\r
  @param[in]  BlockDescriptors The block descriptors for the capsule images\r
  @param[in]  CapsuleNum       The count of capsule images\r
**/\r
VOID\r
CleanGatherList (\r
  IN EFI_CAPSULE_BLOCK_DESCRIPTOR   *BlockDescriptors,\r
  IN UINTN                          CapsuleNum\r
  )\r
{\r
  EFI_CAPSULE_BLOCK_DESCRIPTOR   *TempBlockPtr;\r
  EFI_CAPSULE_BLOCK_DESCRIPTOR   *TempBlockPtr1;\r
  EFI_CAPSULE_BLOCK_DESCRIPTOR   *TempBlockPtr2;\r
  UINTN                          Index;\r
\r
  if (BlockDescriptors != NULL) {\r
    TempBlockPtr1 = BlockDescriptors;\r
    while (1){\r
      TempBlockPtr = TempBlockPtr1;\r
      for (Index = 0; Index < CapsuleNum; Index++) {\r
        if (TempBlockPtr[Index].Length == 0) {\r
          break;\r
        }\r
      }\r
\r
      if (TempBlockPtr[Index].Union.ContinuationPointer == (UINTN)NULL) {\r
        break;\r
      }\r
\r
      TempBlockPtr2 = (VOID *) ((UINTN) TempBlockPtr[Index].Union.ContinuationPointer);\r
      FreePool(TempBlockPtr1);\r
      TempBlockPtr1 = TempBlockPtr2;\r
    }\r
  }\r
}\r
\r
/**\r
  Validate if it is valid capsule header\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 (CapsuleSize < sizeof (EFI_CAPSULE_HEADER)) {\r
    return FALSE;\r
  }\r
  if (CapsuleHeader->CapsuleImageSize != CapsuleSize) {\r
    return FALSE;\r
  }\r
  if (CapsuleHeader->HeaderSize > CapsuleHeader->CapsuleImageSize) {\r
    return FALSE;\r
  }\r
  if (CapsuleHeader->HeaderSize < sizeof (EFI_CAPSULE_HEADER)) {\r
    return FALSE;\r
  }\r
\r
  return TRUE;\r
}\r
\r
/**\r
  Print APP usage.\r
**/\r
VOID\r
PrintUsage (\r
  VOID\r
  )\r
{\r
  Print(L"CapsuleApp:  usage\n");\r
  Print(L"  CapsuleApp <Capsule...> [-NR]\n");\r
  Print(L"  CapsuleApp -S\n");\r
  Print(L"  CapsuleApp -C\n");\r
  Print(L"  CapsuleApp -P\n");\r
  Print(L"  CapsuleApp -E\n");\r
  Print(L"  CapsuleApp -G <BMP> -O <Capsule>\n");\r
  Print(L"  CapsuleApp -N <Capsule> -O <NestedCapsule>\n");\r
  Print(L"  CapsuleApp -D <Capsule>\n");\r
  Print(L"  CapsuleApp -P GET <ImageTypeId> <Index> -O <FileName>\n");\r
  Print(L"Parameter:\n");\r
  Print(L"  -NR: No reset will be triggered for the capsule with\n");\r
  Print(L"       CAPSULE_FLAGS_PERSIST_ACROSS_RESET and without\n");\r
  Print(L"       CAPSULE_FLAGS_INITIATE_RESET.\n");\r
  Print(L"  -S:  Dump capsule report variable (EFI_CAPSULE_REPORT_GUID),\n");\r
  Print(L"       which is defined in UEFI specification.\n");\r
  Print(L"  -C:  Clear capsule report variable (EFI_CAPSULE_REPORT_GUID),\n");\r
  Print(L"       which is defined in UEFI specification.\n");\r
  Print(L"  -P:  Dump UEFI FMP protocol info, or get image with specified\n");\r
  Print(L"       ImageTypeId and Index (decimal format) to a file if 'GET'\n");\r
  Print(L"       option is used.\n");\r
  Print(L"  -E:  Dump UEFI ESRT table info.\n");\r
  Print(L"  -G:  Convert a BMP file to be an UX capsule,\n");\r
  Print(L"       according to Windows Firmware Update document\n");\r
  Print(L"  -N:  Append a Capsule Header to an existing FMP capsule image\n");\r
  Print(L"       with its ImageTypeId supported by the system,\n");\r
  Print(L"       according to Windows Firmware Update document\n");\r
  Print(L"  -O:  Output new Capsule file name\n");\r
  Print(L"  -D:  Dump Capsule image header information, image payload\n");\r
  Print(L"       information if it is an UX capsule and FMP header\n");\r
  Print(L"       information if it is a FMP capsule.\n");\r
}\r
\r
/**\r
  Update Capsule image.\r
\r
  @param[in]  ImageHandle     The image handle.\r
  @param[in]  SystemTable     The system table.\r
\r
  @retval EFI_SUCCESS            Command completed successfully.\r
  @retval EFI_UNSUPPORTED        Command usage unsupported.\r
  @retval EFI_INVALID_PARAMETER  Command usage invalid.\r
  @retval EFI_NOT_FOUND          The input file can't be found.\r
**/\r
EFI_STATUS\r
EFIAPI\r
UefiMain (\r
  IN EFI_HANDLE        ImageHandle,\r
  IN EFI_SYSTEM_TABLE  *SystemTable\r
  )\r
{\r
  EFI_STATUS                    Status;\r
  RETURN_STATUS                 RStatus;\r
  UINTN                         FileSize[MAX_CAPSULE_NUM];\r
  VOID                          *CapsuleBuffer[MAX_CAPSULE_NUM];\r
  EFI_CAPSULE_BLOCK_DESCRIPTOR  *BlockDescriptors;\r
  EFI_CAPSULE_HEADER            *CapsuleHeaderArray[MAX_CAPSULE_NUM + 1];\r
  UINT64                        MaxCapsuleSize;\r
  EFI_RESET_TYPE                ResetType;\r
  BOOLEAN                       NeedReset;\r
  BOOLEAN                       NoReset;\r
  CHAR16                        *CapsuleName;\r
  UINTN                         CapsuleNum;\r
  UINTN                         Index;\r
  EFI_GUID                      ImageTypeId;\r
  UINTN                         ImageIndex;\r
\r
  Status = GetArg();\r
  if (EFI_ERROR(Status)) {\r
    Print(L"Please use UEFI SHELL to run this application!\n", Status);\r
    return Status;\r
  }\r
  if (Argc < 2) {\r
    PrintUsage();\r
    return EFI_UNSUPPORTED;\r
  }\r
  if (StrCmp(Argv[1], L"-D") == 0) {\r
    if (Argc != 3) {\r
      Print(L"CapsuleApp: Incorrect parameter count.\n");\r
      return EFI_UNSUPPORTED;\r
    }\r
    Status = DumpCapsule(Argv[2]);\r
    return Status;\r
  }\r
  if (StrCmp(Argv[1], L"-G") == 0) {\r
    Status = CreateBmpFmp();\r
    return Status;\r
  }\r
  if (StrCmp(Argv[1], L"-N") == 0) {\r
    Status = CreateNestedFmp();\r
    return Status;\r
  }\r
  if (StrCmp(Argv[1], L"-S") == 0) {\r
    Status = DumpCapsuleStatusVariable();\r
    return EFI_SUCCESS;\r
  }\r
  if (StrCmp(Argv[1], L"-C") == 0) {\r
    Status = ClearCapsuleStatusVariable();\r
    return Status;\r
  }\r
  if (StrCmp(Argv[1], L"-P") == 0) {\r
    if (Argc == 2) {\r
      DumpFmpData();\r
    }\r
    if (Argc >= 3) {\r
      if (StrCmp(Argv[2], L"GET") != 0) {\r
        Print(L"CapsuleApp: Unrecognized option(%s).\n", Argv[2]);\r
        return EFI_UNSUPPORTED;\r
      } else {\r
        if (Argc != 7) {\r
          Print(L"CapsuleApp: Incorrect parameter count.\n");\r
          return EFI_UNSUPPORTED;\r
        }\r
\r
        //\r
        // FMP->GetImage()\r
        //\r
        RStatus = StrToGuid (Argv[3], &ImageTypeId);\r
        if (RETURN_ERROR (RStatus) || (Argv[3][GUID_STRING_LENGTH] != L'\0')) {\r
          Print (L"Invalid ImageTypeId - %s\n", Argv[3]);\r
          return EFI_INVALID_PARAMETER;\r
        }\r
        ImageIndex = StrDecimalToUintn(Argv[4]);\r
        if (StrCmp(Argv[5], L"-O") != 0) {\r
          Print(L"CapsuleApp: NO output file name.\n");\r
          return EFI_UNSUPPORTED;\r
        }\r
        DumpFmpImage(&ImageTypeId, ImageIndex, Argv[6]);\r
      }\r
    }\r
    return EFI_SUCCESS;\r
  }\r
\r
  if (StrCmp(Argv[1], L"-E") == 0) {\r
    DumpEsrtData();\r
    return EFI_SUCCESS;\r
  }\r
\r
  if (Argv[1][0] == L'-') {\r
    Print(L"CapsuleApp: Unrecognized option(%s).\n", Argv[1]);\r
    return EFI_UNSUPPORTED;\r
  }\r
\r
  CapsuleFirstIndex = 1;\r
  NoReset = FALSE;\r
  if ((Argc > 1) && (StrCmp(Argv[Argc - 1], L"-NR") == 0)) {\r
    NoReset = TRUE;\r
    CapsuleLastIndex = Argc - 2;\r
  } else {\r
    CapsuleLastIndex = Argc - 1;\r
  }\r
  CapsuleNum = CapsuleLastIndex - CapsuleFirstIndex + 1;\r
\r
  if (CapsuleFirstIndex > CapsuleLastIndex) {\r
    Print(L"CapsuleApp: NO capsule image.\n");\r
    return EFI_UNSUPPORTED;\r
  }\r
  if (CapsuleNum > MAX_CAPSULE_NUM) {\r
    Print(L"CapsuleApp: Too many capsule images.\n");\r
    return EFI_UNSUPPORTED;\r
  }\r
\r
  ZeroMem(&CapsuleBuffer, sizeof(CapsuleBuffer));\r
  ZeroMem(&FileSize, sizeof(FileSize));\r
  BlockDescriptors = NULL;\r
\r
  for (Index = 0; Index < CapsuleNum; Index++) {\r
    CapsuleName = Argv[CapsuleFirstIndex + Index];\r
    Status = ReadFileToBuffer(CapsuleName, &FileSize[Index], &CapsuleBuffer[Index]);\r
    if (EFI_ERROR(Status)) {\r
      Print(L"CapsuleApp: capsule image (%s) is not found.\n", CapsuleName);\r
      goto Done;\r
    }\r
    if (!IsValidCapsuleHeader (CapsuleBuffer[Index], FileSize[Index])) {\r
      Print(L"CapsuleApp: Capsule image (%s) is not a valid capsule.\n", CapsuleName);\r
      return EFI_INVALID_PARAMETER;\r
    }\r
  }\r
\r
  //\r
  // Every capsule use 2 descriptor 1 for data 1 for end\r
  //\r
  Status = BuildGatherList(CapsuleBuffer, FileSize, CapsuleNum, &BlockDescriptors);\r
  if (EFI_ERROR(Status)) {\r
    goto Done;\r
  }\r
\r
  //\r
  // Call the runtime service capsule.\r
  //\r
  NeedReset = FALSE;\r
  for (Index = 0; Index < CapsuleNum; Index++) {\r
    CapsuleHeaderArray[Index] = (EFI_CAPSULE_HEADER *) CapsuleBuffer[Index];\r
    if ((CapsuleHeaderArray[Index]->Flags & CAPSULE_FLAGS_PERSIST_ACROSS_RESET) != 0) {\r
      NeedReset = TRUE;\r
    }\r
  }\r
  CapsuleHeaderArray[CapsuleNum] = NULL;\r
\r
  //\r
  // Inquire platform capability of UpdateCapsule.\r
  //\r
  Status = gRT->QueryCapsuleCapabilities (CapsuleHeaderArray, CapsuleNum, &MaxCapsuleSize, &ResetType);\r
  if (EFI_ERROR(Status)) {\r
    Print (L"CapsuleApp: failed to query capsule capability - %r\n", Status);\r
    goto Done;\r
  }\r
\r
  for (Index = 0; Index < CapsuleNum; Index++) {\r
    if (FileSize[Index] > MaxCapsuleSize) {\r
      Print (L"CapsuleApp: capsule is too large to update, %ld is allowed\n", MaxCapsuleSize);\r
      Status = EFI_UNSUPPORTED;\r
      goto Done;\r
    }\r
  }\r
\r
  //\r
  // Check whether the input capsule image has the flag of persist across system reset.\r
  //\r
  if (NeedReset) {\r
    Status = gRT->UpdateCapsule(CapsuleHeaderArray,CapsuleNum,(UINTN) BlockDescriptors);\r
    if (Status != EFI_SUCCESS) {\r
      Print (L"CapsuleApp: failed to update capsule - %r\n", Status);\r
      goto Done;\r
    }\r
    //\r
    // For capsule with CAPSULE_FLAGS_PERSIST_ACROSS_RESET + CAPSULE_FLAGS_INITIATE_RESET,\r
    // a system reset should have been triggered by gRT->UpdateCapsule() calling above.\r
    //\r
    // For capsule with CAPSULE_FLAGS_PERSIST_ACROSS_RESET and without CAPSULE_FLAGS_INITIATE_RESET,\r
    // check if -NR (no-reset) has been specified or not.\r
    //\r
    if (!NoReset) {\r
      //\r
      // For capsule who has reset flag and no -NR (no-reset) has been specified, after calling UpdateCapsule service,\r
      // trigger a system reset to process capsule persist across a system reset.\r
      //\r
      gRT->ResetSystem (ResetType, EFI_SUCCESS, 0, NULL);\r
    }\r
  } else {\r
    //\r
    // For capsule who has no reset flag, only call UpdateCapsule Service without a\r
    // system reset. The service will process the capsule immediately.\r
    //\r
    Status = gRT->UpdateCapsule (CapsuleHeaderArray,CapsuleNum,(UINTN) BlockDescriptors);\r
    if (Status != EFI_SUCCESS) {\r
      Print (L"CapsuleApp: failed to update capsule - %r\n", Status);\r
    }\r
  }\r
\r
  Status = EFI_SUCCESS;\r
\r
Done:\r
  for (Index = 0; Index < CapsuleNum; Index++) {\r
    if (CapsuleBuffer[Index] != NULL) {\r
      FreePool (CapsuleBuffer[Index]);\r
    }\r
  }\r
\r
  CleanGatherList(BlockDescriptors, CapsuleNum);\r
\r
  return Status;\r
}\r