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

/** @file\r
  A shell application that triggers capsule update process.\r
\r
  Copyright (c) 2016 - 2019, Intel Corporation. All rights reserved.<BR>\r
  SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#include "CapsuleApp.h"\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
  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
  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
  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
  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
  if (!IsValidCapsuleHeader (CapsuleBuffer, FileSize)) {\r
    Print(L"CapsuleApp: Capsule image (%s) is not a valid capsule.\n", CapsuleName);\r
    Status = EFI_INVALID_PARAMETER;\r
    goto Done;\r
  }\r
\r
  if (!IsFmpCapsuleGuid (&((EFI_CAPSULE_HEADER *) CapsuleBuffer)->CapsuleGuid)) {\r
    Print(L"CapsuleApp: Capsule image (%s) is not a FMP capsule.\n", CapsuleName);\r
    Status = EFI_INVALID_PARAMETER;\r
    goto Done;\r
  }\r
\r
  ImageTypeId = GetCapsuleImageTypeId(CapsuleBuffer);\r
  if (ImageTypeId == NULL) {\r
    Print(L"CapsuleApp: Capsule ImageTypeId is not found.\n");\r
    Status = EFI_INVALID_PARAMETER;\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
    Status = EFI_INVALID_PARAMETER;\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
  Print APP usage.\r
**/\r
VOID\r
PrintUsage (\r
  VOID\r
  )\r
{\r
  Print(L"CapsuleApp:  usage\n");\r
  Print(L"  CapsuleApp <Capsule...> [-NR] [-OD [FSx]]\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 -L\n");\r
  Print(L"  CapsuleApp -L INFO\n");\r
  Print(L"  CapsuleApp -F\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\n");\r
  Print(L"       with CAPSULE_FLAGS_PERSIST_ACROSS_RESET and without CAPSULE_FLAGS_INITIATE_RESET.\n");\r
  Print(L"  -OD: Delivery of Capsules via file on Mass Storage device.\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"  -L:  Dump provisioned capsule image information.\n");\r
  Print(L"  -F:  Dump all EFI System Partition.\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                         CapsuleBufferSize[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
  BOOLEAN                       CapsuleOnDisk;\r
  CHAR16                        *CapsuleName;\r
  CHAR16                        *CapsuleNames[MAX_CAPSULE_NUM];\r
  CHAR16                        *MapFsStr;\r
  UINTN                         CapsuleNum;\r
  UINTN                         Index;\r
  UINTN                         ParaOdIndex;\r
  UINTN                         ParaNrIndex;\r
  EFI_GUID                      ImageTypeId;\r
  UINTN                         ImageIndex;\r
\r
  BlockDescriptors  = NULL;\r
  MapFsStr          = NULL;\r
  CapsuleNum        = 0;\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 (StrCmp(Argv[1], L"-L") == 0) {\r
    if (Argc >= 3 && StrCmp(Argv[2], L"INFO") == 0) {\r
      DumpProvisionedCapsule(TRUE);\r
    } else {\r
      DumpProvisionedCapsule(FALSE);\r
    }\r
    return EFI_SUCCESS;\r
  }\r
\r
  if (StrCmp(Argv[1], L"-F") == 0) {\r
    DumpAllEfiSysPartition();\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
  CapsuleOnDisk = FALSE;\r
  ParaOdIndex = 0;\r
  ParaNrIndex = 0;\r
\r
  for (Index = 1; Index < Argc; Index++) {\r
    if (StrCmp(Argv[Index], L"-OD") == 0) {\r
      ParaOdIndex = Index;\r
      CapsuleOnDisk = TRUE;\r
    } else if (StrCmp(Argv[Index], L"-NR") == 0) {\r
      ParaNrIndex = Index;\r
      NoReset = TRUE;\r
    }\r
  }\r
\r
  if (ParaOdIndex > ParaNrIndex) {\r
    if (ParaNrIndex != 0) {\r
      CapsuleLastIndex = ParaNrIndex - 1;\r
    } else {\r
      CapsuleLastIndex = ParaOdIndex - 1;\r
    }\r
\r
    if (ParaOdIndex == Argc -1) {\r
      MapFsStr = NULL;\r
    } else if (ParaOdIndex == Argc - 2) {\r
      MapFsStr = Argv[Argc-1];\r
    } else {\r
      Print (L"CapsuleApp: Cannot specify more than one FS mapping!\n");\r
      Status = EFI_INVALID_PARAMETER;\r
      goto Done;\r
    }\r
  } else if (ParaOdIndex < ParaNrIndex) {\r
    if (ParaOdIndex != 0) {\r
      CapsuleLastIndex = ParaOdIndex - 1;\r
      if (ParaOdIndex == ParaNrIndex - 1) {\r
        MapFsStr = NULL;\r
      } else if (ParaOdIndex == ParaNrIndex - 2) {\r
        MapFsStr = Argv[ParaOdIndex + 1];\r
      } else {\r
        Print (L"CapsuleApp: Cannot specify more than one FS mapping!\n");\r
        Status = EFI_INVALID_PARAMETER;\r
        goto Done;\r
      }\r
    } else {\r
      CapsuleLastIndex = ParaNrIndex - 1;\r
    }\r
  } else {\r
    CapsuleLastIndex = Argc - 1;\r
  }\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(&CapsuleBufferSize, sizeof(CapsuleBufferSize));\r
  BlockDescriptors = NULL;\r
\r
  for (Index = 0; Index < CapsuleNum; Index++) {\r
    CapsuleName = Argv[CapsuleFirstIndex + Index];\r
    Status = ReadFileToBuffer(CapsuleName, &CapsuleBufferSize[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], CapsuleBufferSize[Index])) {\r
      Print(L"CapsuleApp: Capsule image (%s) is not a valid capsule.\n", CapsuleName);\r
      return EFI_INVALID_PARAMETER;\r
    }\r
    CapsuleNames[Index] = CapsuleName;\r
  }\r
\r
  //\r
  // Every capsule use 2 descriptor 1 for data 1 for end\r
  //\r
  Status = BuildGatherList(CapsuleBuffer, CapsuleBufferSize, 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 (CapsuleBufferSize[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 is capsule on disk.\r
  //\r
  if (CapsuleOnDisk) {\r
    Status = ProcessCapsuleOnDisk (CapsuleBuffer, CapsuleBufferSize, CapsuleNames, MapFsStr, CapsuleNum);\r
    if (Status != EFI_SUCCESS) {\r
      Print (L"CapsuleApp: failed to update capsule - %r\n", Status);\r
      goto Done;\r
    } else {\r
      if (!NoReset) {\r
        gRT->ResetSystem (ResetType, EFI_SUCCESS, 0, NULL);\r
      } else {\r
        goto Done;\r
      }\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