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

/** @file\r
  DXE capsule report related function.\r
\r
  Copyright (c) 2016, 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
#include <Protocol/FirmwareManagement.h>\r
#include <Protocol/VariableLock.h>\r
#include <Guid/CapsuleReport.h>\r
#include <Guid/FmpCapsule.h>\r
#include <Guid/CapsuleVendor.h>\r
\r
#include <Library/BaseLib.h>\r
#include <Library/DebugLib.h>\r
#include <Library/BaseMemoryLib.h>\r
#include <Library/UefiBootServicesTableLib.h>\r
#include <Library/UefiRuntimeServicesTableLib.h>\r
#include <Library/MemoryAllocationLib.h>\r
#include <Library/UefiLib.h>\r
#include <Library/PcdLib.h>\r
#include <Library/HobLib.h>\r
#include <Library/PrintLib.h>\r
#include <Library/ReportStatusCodeLib.h>\r
#include <Library/CapsuleLib.h>\r
\r
#include <IndustryStandard/WindowsUxCapsule.h>\r
\r
typedef struct {\r
  EFI_CAPSULE_RESULT_VARIABLE_HEADER  CapsuleResultHeader;\r
  EFI_CAPSULE_RESULT_VARIABLE_FMP     CapsuleResultFmp;\r
} CAPSULE_RESULT_VARIABLE_CACHE;\r
\r
#define CAPSULE_RESULT_VARIABLE_CACHE_COUNT   0x10\r
\r
CAPSULE_RESULT_VARIABLE_CACHE *mCapsuleResultVariableCache;\r
UINTN                         mCapsuleResultVariableCacheMaxCount;\r
UINTN                         mCapsuleResultVariableCacheCount;\r
\r
/**\r
  Get current capsule last variable index.\r
\r
  @return Current capsule last variable index.\r
  @retval -1  No current capsule last variable.\r
**/\r
INTN\r
GetCurrentCapsuleLastIndex (\r
  VOID\r
  )\r
{\r
  UINTN                            Size;\r
  CHAR16                           CapsuleLastStr[sizeof("Capsule####")];\r
  EFI_STATUS                       Status;\r
  UINT16                           CurrentIndex;\r
\r
  Size = sizeof(L"Capsule####") - sizeof(CHAR16); // no zero terminator\r
  Status = gRT->GetVariable(\r
                  L"CapsuleLast",\r
                  &gEfiCapsuleReportGuid,\r
                  NULL,\r
                  &Size,\r
                  CapsuleLastStr\r
                  );\r
  if (EFI_ERROR(Status)) {\r
    return -1;\r
  }\r
  CurrentIndex = (UINT16)StrHexToUintn(&CapsuleLastStr[sizeof("Capsule") - 1]);\r
  return CurrentIndex;\r
}\r
\r
/**\r
  Check if this FMP capsule is processed.\r
\r
  @param[in] CapsuleHeader  The capsule image header\r
  @param[in] PayloadIndex   FMP payload index\r
  @param[in] ImageHeader    FMP image header\r
\r
  @retval TRUE  This FMP capsule is processed.\r
  @retval FALSE This FMP capsule is not processed.\r
**/\r
BOOLEAN\r
IsFmpCapsuleProcessed (\r
  IN EFI_CAPSULE_HEADER                            *CapsuleHeader,\r
  IN UINTN                                         PayloadIndex,\r
  IN EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER  *ImageHeader\r
  )\r
{\r
  UINTN                               Index;\r
  EFI_CAPSULE_RESULT_VARIABLE_HEADER  *CapsuleResult;\r
  EFI_CAPSULE_RESULT_VARIABLE_FMP     *CapsuleResultFmp;\r
\r
  for (Index = 0; Index < mCapsuleResultVariableCacheCount; Index++) {\r
    //\r
    // Check\r
    //\r
    CapsuleResult = &mCapsuleResultVariableCache[Index].CapsuleResultHeader;\r
    if (CapsuleResult->VariableTotalSize >= sizeof(EFI_CAPSULE_RESULT_VARIABLE_HEADER)) {\r
      if (CompareGuid(&CapsuleResult->CapsuleGuid, &gEfiFmpCapsuleGuid)) {\r
        if (CapsuleResult->VariableTotalSize >= sizeof(EFI_CAPSULE_RESULT_VARIABLE_HEADER) + sizeof(EFI_CAPSULE_RESULT_VARIABLE_FMP)) {\r
          CapsuleResultFmp = (EFI_CAPSULE_RESULT_VARIABLE_FMP *)(CapsuleResult + 1);\r
          if (CompareGuid(&CapsuleResultFmp->UpdateImageTypeId, &ImageHeader->UpdateImageTypeId) &&\r
              (CapsuleResultFmp->UpdateImageIndex == ImageHeader->UpdateImageIndex) &&\r
              (CapsuleResultFmp->PayloadIndex == PayloadIndex) ) {\r
            return TRUE;\r
          }\r
        }\r
      }\r
    }\r
  }\r
\r
  return FALSE;\r
}\r
\r
/**\r
  Write a new capsule status variable cache.\r
\r
  @param[in] CapsuleResult      The capsule status variable\r
  @param[in] CapsuleResultSize  The size of the capsule stauts variable in bytes\r
\r
  @retval EFI_SUCCESS          The capsule status variable is cached.\r
  @retval EFI_OUT_OF_RESOURCES No resource to cache the capsule status variable.\r
**/\r
EFI_STATUS\r
WriteNewCapsuleResultVariableCache (\r
  IN VOID    *CapsuleResult,\r
  IN UINTN   CapsuleResultSize\r
  )\r
{\r
  if (CapsuleResultSize > sizeof(CAPSULE_RESULT_VARIABLE_CACHE)) {\r
    CapsuleResultSize = sizeof(CAPSULE_RESULT_VARIABLE_CACHE);\r
  }\r
\r
  if (mCapsuleResultVariableCacheCount == mCapsuleResultVariableCacheMaxCount) {\r
    mCapsuleResultVariableCache = ReallocatePool(\r
                                    mCapsuleResultVariableCacheMaxCount * sizeof(CAPSULE_RESULT_VARIABLE_CACHE),\r
                                    (mCapsuleResultVariableCacheMaxCount + CAPSULE_RESULT_VARIABLE_CACHE_COUNT) * sizeof(CAPSULE_RESULT_VARIABLE_CACHE),\r
                                    mCapsuleResultVariableCache\r
                                    );\r
    if (mCapsuleResultVariableCache == NULL) {\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
    mCapsuleResultVariableCacheMaxCount += CAPSULE_RESULT_VARIABLE_CACHE_COUNT;\r
  }\r
\r
  ASSERT(mCapsuleResultVariableCacheCount < mCapsuleResultVariableCacheMaxCount);\r
  ASSERT(mCapsuleResultVariableCache != NULL);\r
  CopyMem(\r
    &mCapsuleResultVariableCache[mCapsuleResultVariableCacheCount],\r
    CapsuleResult,\r
    CapsuleResultSize\r
    );\r
  mCapsuleResultVariableCacheCount++;\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Get a new capsule status variable index.\r
\r
  @return A new capsule status variable index.\r
  @retval -1  No new capsule status variable index.\r
**/\r
INTN\r
GetNewCapsuleResultIndex (\r
  VOID\r
  )\r
{\r
  INTN                             CurrentIndex;\r
\r
  CurrentIndex = GetCurrentCapsuleLastIndex();\r
  if (CurrentIndex >= PcdGet16(PcdCapsuleMax)) {\r
    return -1;\r
  }\r
\r
  return CurrentIndex + 1;\r
}\r
\r
/**\r
  Write a new capsule status variable.\r
\r
  @param[in] CapsuleResult      The capsule status variable\r
  @param[in] CapsuleResultSize  The size of the capsule stauts variable in bytes\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
WriteNewCapsuleResultVariable (\r
  IN VOID    *CapsuleResult,\r
  IN UINTN   CapsuleResultSize\r
  )\r
{\r
  INTN                                CapsuleResultIndex;\r
  CHAR16                              CapsuleResultStr[sizeof("Capsule####")];\r
  UINTN                               Size;\r
  EFI_STATUS                          Status;\r
\r
  CapsuleResultIndex = GetNewCapsuleResultIndex();\r
  DEBUG((DEBUG_INFO, "New CapsuleResultIndex - 0x%x\n", CapsuleResultIndex));\r
  if (CapsuleResultIndex == -1) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
  UnicodeSPrint(\r
    CapsuleResultStr,\r
    sizeof(CapsuleResultStr),\r
    L"Capsule%04x",\r
    CapsuleResultIndex\r
    );\r
\r
  Status = gRT->SetVariable(\r
                  CapsuleResultStr,\r
                  &gEfiCapsuleReportGuid,\r
                  EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,\r
                  CapsuleResultSize,\r
                  CapsuleResult\r
                  );\r
  if (!EFI_ERROR(Status)) {\r
    Size = sizeof(L"Capsule####") - sizeof(CHAR16); // no zero terminator\r
    DEBUG((DEBUG_INFO, "Set CapsuleLast - %s\n", CapsuleResultStr));\r
    Status = gRT->SetVariable(\r
                    L"CapsuleLast",\r
                    &gEfiCapsuleReportGuid,\r
                    EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,\r
                    Size,\r
                    CapsuleResultStr\r
                    );\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
  Record capsule status variable and to local cache.\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
  EFI_CAPSULE_RESULT_VARIABLE_HEADER  CapsuleResultVariable;\r
  EFI_STATUS                          Status;\r
\r
  CapsuleResultVariable.VariableTotalSize = sizeof(CapsuleResultVariable);\r
  CopyGuid (&CapsuleResultVariable.CapsuleGuid, &CapsuleHeader->CapsuleGuid);\r
  ZeroMem(&CapsuleResultVariable.CapsuleProcessed, sizeof(CapsuleResultVariable.CapsuleProcessed));\r
  gRT->GetTime(&CapsuleResultVariable.CapsuleProcessed, NULL);\r
  CapsuleResultVariable.CapsuleStatus = CapsuleStatus;\r
\r
  //\r
  // Save Local Cache\r
  //\r
  Status = WriteNewCapsuleResultVariableCache(&CapsuleResultVariable, sizeof(CapsuleResultVariable));\r
\r
  if ((CapsuleHeader->Flags & CAPSULE_FLAGS_PERSIST_ACROSS_RESET) != 0) {\r
    Status = WriteNewCapsuleResultVariable(&CapsuleResultVariable, sizeof(CapsuleResultVariable));\r
  }\r
  return Status;\r
}\r
\r
/**\r
  Record FMP capsule status variable and to local cache.\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
\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
  )\r
{\r
  EFI_CAPSULE_RESULT_VARIABLE_HEADER  *CapsuleResultVariableHeader;\r
  EFI_CAPSULE_RESULT_VARIABLE_FMP     *CapsuleResultVariableFmp;\r
  EFI_STATUS                          Status;\r
  UINT8                               *CapsuleResultVariable;\r
  UINT32                              CapsuleResultVariableSize;\r
\r
  CapsuleResultVariable     = NULL;\r
  CapsuleResultVariableSize = sizeof(EFI_CAPSULE_RESULT_VARIABLE_HEADER) + sizeof(EFI_CAPSULE_RESULT_VARIABLE_FMP);\r
  CapsuleResultVariable     = AllocatePool (CapsuleResultVariableSize);\r
  if (CapsuleResultVariable == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
  CapsuleResultVariableHeader = (VOID *)CapsuleResultVariable;\r
  CapsuleResultVariableHeader->VariableTotalSize = CapsuleResultVariableSize;\r
  CopyGuid(&CapsuleResultVariableHeader->CapsuleGuid, &CapsuleHeader->CapsuleGuid);\r
  ZeroMem(&CapsuleResultVariableHeader->CapsuleProcessed, sizeof(CapsuleResultVariableHeader->CapsuleProcessed));\r
  gRT->GetTime(&CapsuleResultVariableHeader->CapsuleProcessed, NULL);\r
  CapsuleResultVariableHeader->CapsuleStatus = CapsuleStatus;\r
\r
  CapsuleResultVariableFmp = (VOID *)(CapsuleResultVariable + sizeof(EFI_CAPSULE_RESULT_VARIABLE_HEADER));\r
  CapsuleResultVariableFmp->Version = 0x1;\r
  CapsuleResultVariableFmp->PayloadIndex = (UINT8)PayloadIndex;\r
  CapsuleResultVariableFmp->UpdateImageIndex = ImageHeader->UpdateImageIndex;\r
  CopyGuid (&CapsuleResultVariableFmp->UpdateImageTypeId, &ImageHeader->UpdateImageTypeId);\r
\r
  //\r
  // Save Local Cache\r
  //\r
  Status = WriteNewCapsuleResultVariableCache(CapsuleResultVariable, CapsuleResultVariableSize);\r
\r
  if ((CapsuleHeader->Flags & CAPSULE_FLAGS_PERSIST_ACROSS_RESET) != 0) {\r
    Status = WriteNewCapsuleResultVariable(CapsuleResultVariable, CapsuleResultVariableSize);\r
  }\r
  FreePool (CapsuleResultVariable);\r
  return Status;\r
}\r
\r
/**\r
  Initialize CapsuleMax variables.\r
**/\r
VOID\r
InitCapsuleMaxVariable (\r
  VOID\r
  )\r
{\r
  EFI_STATUS                       Status;\r
  UINTN                            Size;\r
  CHAR16                           CapsuleMaxStr[sizeof("Capsule####")];\r
  EDKII_VARIABLE_LOCK_PROTOCOL     *VariableLock;\r
\r
  UnicodeSPrint(\r
    CapsuleMaxStr,\r
    sizeof(CapsuleMaxStr),\r
    L"Capsule%04x",\r
    PcdGet16(PcdCapsuleMax)\r
    );\r
\r
  Size = sizeof(L"Capsule####") - sizeof(CHAR16); // no zero terminator\r
  Status = gRT->SetVariable(\r
                  L"CapsuleMax",\r
                  &gEfiCapsuleReportGuid,\r
                  EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,\r
                  Size,\r
                  CapsuleMaxStr\r
                  );\r
  if (!EFI_ERROR(Status)) {\r
    // Lock it per UEFI spec.\r
    Status = gBS->LocateProtocol(&gEdkiiVariableLockProtocolGuid, NULL, (VOID **)&VariableLock);\r
    if (!EFI_ERROR(Status)) {\r
      Status = VariableLock->RequestToLock(VariableLock, L"CapsuleMax", &gEfiCapsuleReportGuid);\r
      ASSERT_EFI_ERROR(Status);\r
    }\r
  }\r
}\r
\r
/**\r
  Initialize CapsuleLast variables.\r
**/\r
VOID\r
InitCapsuleLastVariable (\r
  VOID\r
  )\r
{\r
  EFI_STATUS                       Status;\r
  EFI_BOOT_MODE                    BootMode;\r
  EDKII_VARIABLE_LOCK_PROTOCOL     *VariableLock;\r
  VOID                             *CapsuleResult;\r
  UINTN                            Size;\r
  CHAR16                           CapsuleLastStr[sizeof("Capsule####")];\r
\r
  BootMode = GetBootModeHob();\r
  if (BootMode == BOOT_ON_FLASH_UPDATE) {\r
    Status = gRT->SetVariable(\r
                    L"CapsuleLast",\r
                    &gEfiCapsuleReportGuid,\r
                    EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,\r
                    0,\r
                    NULL\r
                    );\r
    // Do not lock it because it will be updated later.\r
  } else {\r
    //\r
    // Check if OS/APP cleared L"Capsule####"\r
    //\r
    ZeroMem(CapsuleLastStr, sizeof(CapsuleLastStr));\r
    Size = sizeof(L"Capsule####") - sizeof(CHAR16); // no zero terminator\r
    Status = gRT->GetVariable(\r
                    L"CapsuleLast",\r
                    &gEfiCapsuleReportGuid,\r
                    NULL,\r
                    &Size,\r
                    CapsuleLastStr\r
                    );\r
    if (!EFI_ERROR(Status)) {\r
      //\r
      // L"CapsuleLast" is got, check if data is there.\r
      //\r
      Status = GetVariable2 (\r
                 CapsuleLastStr,\r
                 &gEfiCapsuleReportGuid,\r
                 (VOID **) &CapsuleResult,\r
                 NULL\r
                 );\r
      if (EFI_ERROR(Status)) {\r
        //\r
        // If no data, delete L"CapsuleLast"\r
        //\r
        Status = gRT->SetVariable(\r
                        L"CapsuleLast",\r
                        &gEfiCapsuleReportGuid,\r
                        EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,\r
                        0,\r
                        NULL\r
                        );\r
      }\r
    }\r
\r
    // Lock it in normal boot path per UEFI spec.\r
    Status = gBS->LocateProtocol(&gEdkiiVariableLockProtocolGuid, NULL, (VOID **)&VariableLock);\r
    if (!EFI_ERROR(Status)) {\r
      Status = VariableLock->RequestToLock(VariableLock, L"CapsuleLast", &gEfiCapsuleReportGuid);\r
      ASSERT_EFI_ERROR(Status);\r
    }\r
  }\r
}\r
\r
/**\r
  Initialize capsule update variables.\r
**/\r
VOID\r
InitCapsuleUpdateVariable (\r
  VOID\r
  )\r
{\r
  EFI_STATUS                     Status;\r
  UINTN                          Index;\r
  CHAR16                         CapsuleVarName[30];\r
  CHAR16                         *TempVarName;\r
\r
  //\r
  // Clear all the capsule variables CapsuleUpdateData, CapsuleUpdateData1, CapsuleUpdateData2...\r
  // as early as possible which will avoid the next time boot after the capsule update\r
  // will still into the capsule loop\r
  //\r
  StrCpyS (CapsuleVarName, sizeof(CapsuleVarName)/sizeof(CapsuleVarName[0]), EFI_CAPSULE_VARIABLE_NAME);\r
  TempVarName = CapsuleVarName + StrLen (CapsuleVarName);\r
  Index = 0;\r
  while (TRUE) {\r
    if (Index > 0) {\r
      UnicodeValueToString (TempVarName, 0, Index, 0);\r
    }\r
    Status = gRT->SetVariable (\r
                    CapsuleVarName,\r
                    &gEfiCapsuleVendorGuid,\r
                    EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS,\r
                    0,\r
                    (VOID *)NULL\r
                    );\r
    if (EFI_ERROR (Status)) {\r
      //\r
      // There is no capsule variables, quit\r
      //\r
      break;\r
    }\r
    Index++;\r
  }\r
}\r
\r
/**\r
  Initialize capsule related variables.\r
**/\r
VOID\r
InitCapsuleVariable (\r
  VOID\r
  )\r
{\r
  InitCapsuleUpdateVariable();\r
  InitCapsuleMaxVariable();\r
  InitCapsuleLastVariable();\r
  //\r
  // No need to clear L"Capsule####", because OS/APP should refer L"CapsuleLast"\r
  // to check status and delete them.\r
  //\r
}\r
Commit	Line	Data
d2a16030 JY	1	/** @file\r
	2	DXE capsule report related function.\r
	3	\r
	4	Copyright (c) 2016, Intel Corporation. All rights reserved.<BR>\r
	5	This program and the accompanying materials\r
	6	are licensed and made available under the terms and conditions of the BSD License\r
	7	which accompanies this distribution. The full text of the license may be found at\r
	8	http://opensource.org/licenses/bsd-license.php\r
	9	\r
	10	THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
	11	WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
	12	\r
	13	**/\r
	14	\r
	15	#include <PiDxe.h>\r
	16	#include <Protocol/FirmwareManagement.h>\r
	17	#include <Protocol/VariableLock.h>\r
	18	#include <Guid/CapsuleReport.h>\r
	19	#include <Guid/FmpCapsule.h>\r
	20	#include <Guid/CapsuleVendor.h>\r
	21	\r
	22	#include <Library/BaseLib.h>\r
	23	#include <Library/DebugLib.h>\r
	24	#include <Library/BaseMemoryLib.h>\r
	25	#include <Library/UefiBootServicesTableLib.h>\r
	26	#include <Library/UefiRuntimeServicesTableLib.h>\r
	27	#include <Library/MemoryAllocationLib.h>\r
	28	#include <Library/UefiLib.h>\r
	29	#include <Library/PcdLib.h>\r
	30	#include <Library/HobLib.h>\r
	31	#include <Library/PrintLib.h>\r
	32	#include <Library/ReportStatusCodeLib.h>\r
	33	#include <Library/CapsuleLib.h>\r
	34	\r
	35	#include <IndustryStandard/WindowsUxCapsule.h>\r
	36	\r
	37	typedef struct {\r
	38	EFI_CAPSULE_RESULT_VARIABLE_HEADER CapsuleResultHeader;\r
	39	EFI_CAPSULE_RESULT_VARIABLE_FMP CapsuleResultFmp;\r
	40	} CAPSULE_RESULT_VARIABLE_CACHE;\r
	41	\r
	42	#define CAPSULE_RESULT_VARIABLE_CACHE_COUNT 0x10\r
	43	\r
	44	CAPSULE_RESULT_VARIABLE_CACHE *mCapsuleResultVariableCache;\r
	45	UINTN mCapsuleResultVariableCacheMaxCount;\r
	46	UINTN mCapsuleResultVariableCacheCount;\r
	47	\r
	48	/**\r
	49	Get current capsule last variable index.\r
	50	\r
	51	@return Current capsule last variable index.\r
	52	@retval -1 No current capsule last variable.\r
	53	**/\r
	54	INTN\r
	55	GetCurrentCapsuleLastIndex (\r
	56	VOID\r
	57	)\r
	58	{\r
	59	UINTN Size;\r
	60	CHAR16 CapsuleLastStr[sizeof("Capsule####")];\r
	61	EFI_STATUS Status;\r
	62	UINT16 CurrentIndex;\r
	63	\r
	64	Size = sizeof(L"Capsule####") - sizeof(CHAR16); // no zero terminator\r
65	Status = gRT->GetVariable(\r
66	L"CapsuleLast",\r
67	&gEfiCapsuleReportGuid,\r
68	NULL,\r
69	&Size,\r
70	CapsuleLastStr\r
71	);\r
72	if (EFI_ERROR(Status)) {\r
73	return -1;\r
74	}\r
75	CurrentIndex = (UINT16)StrHexToUintn(&CapsuleLastStr[sizeof("Capsule") - 1]);\r
76	return CurrentIndex;\r
77	}\r
78	\r
79	/**\r
80	Check if this FMP capsule is processed.\r
81	\r
82	@param[in] CapsuleHeader The capsule image header\r
83	@param[in] PayloadIndex FMP payload index\r
84	@param[in] ImageHeader FMP image header\r
85	\r
86	@retval TRUE This FMP capsule is processed.\r
87	@retval FALSE This FMP capsule is not processed.\r
88	**/\r
89	BOOLEAN\r
90	IsFmpCapsuleProcessed (\r
91	IN EFI_CAPSULE_HEADER *CapsuleHeader,\r
92	IN UINTN PayloadIndex,\r
93	IN EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER *ImageHeader\r
94	)\r
95	{\r
96	UINTN Index;\r
97	EFI_CAPSULE_RESULT_VARIABLE_HEADER *CapsuleResult;\r
98	EFI_CAPSULE_RESULT_VARIABLE_FMP *CapsuleResultFmp;\r
99	\r
100	for (Index = 0; Index < mCapsuleResultVariableCacheCount; Index++) {\r
101	//\r
102	// Check\r
103	//\r
104	CapsuleResult = &mCapsuleResultVariableCache[Index].CapsuleResultHeader;\r
105	if (CapsuleResult->VariableTotalSize >= sizeof(EFI_CAPSULE_RESULT_VARIABLE_HEADER)) {\r
106	if (CompareGuid(&CapsuleResult->CapsuleGuid, &gEfiFmpCapsuleGuid)) {\r
107	if (CapsuleResult->VariableTotalSize >= sizeof(EFI_CAPSULE_RESULT_VARIABLE_HEADER) + sizeof(EFI_CAPSULE_RESULT_VARIABLE_FMP)) {\r
108	CapsuleResultFmp = (EFI_CAPSULE_RESULT_VARIABLE_FMP *)(CapsuleResult + 1);\r
109	if (CompareGuid(&CapsuleResultFmp->UpdateImageTypeId, &ImageHeader->UpdateImageTypeId) &&\r
110	(CapsuleResultFmp->UpdateImageIndex == ImageHeader->UpdateImageIndex) &&\r
111	(CapsuleResultFmp->PayloadIndex == PayloadIndex) ) {\r
112	return TRUE;\r
113	}\r
114	}\r
115	}\r
116	}\r
117	}\r
118	\r
119	return FALSE;\r
120	}\r
121	\r
122	/**\r
123	Write a new capsule status variable cache.\r
124	\r
125	@param[in] CapsuleResult The capsule status variable\r
126	@param[in] CapsuleResultSize The size of the capsule stauts variable in bytes\r
127	\r
128	@retval EFI_SUCCESS The capsule status variable is cached.\r
129	@retval EFI_OUT_OF_RESOURCES No resource to cache the capsule status variable.\r
130	**/\r
131	EFI_STATUS\r
132	WriteNewCapsuleResultVariableCache (\r
133	IN VOID *CapsuleResult,\r
134	IN UINTN CapsuleResultSize\r
135	)\r
136	{\r
137	if (CapsuleResultSize > sizeof(CAPSULE_RESULT_VARIABLE_CACHE)) {\r
138	CapsuleResultSize = sizeof(CAPSULE_RESULT_VARIABLE_CACHE);\r
139	}\r
140	\r
141	if (mCapsuleResultVariableCacheCount == mCapsuleResultVariableCacheMaxCount) {\r
142	mCapsuleResultVariableCache = ReallocatePool(\r
143	mCapsuleResultVariableCacheMaxCount * sizeof(CAPSULE_RESULT_VARIABLE_CACHE),\r
144	(mCapsuleResultVariableCacheMaxCount + CAPSULE_RESULT_VARIABLE_CACHE_COUNT) * sizeof(CAPSULE_RESULT_VARIABLE_CACHE),\r
145	mCapsuleResultVariableCache\r
146	);\r
147	if (mCapsuleResultVariableCache == NULL) {\r
148	return EFI_OUT_OF_RESOURCES;\r
149	}\r
150	mCapsuleResultVariableCacheMaxCount += CAPSULE_RESULT_VARIABLE_CACHE_COUNT;\r
151	}\r
152	\r
153	ASSERT(mCapsuleResultVariableCacheCount < mCapsuleResultVariableCacheMaxCount);\r
154	ASSERT(mCapsuleResultVariableCache != NULL);\r
155	CopyMem(\r
156	&mCapsuleResultVariableCache[mCapsuleResultVariableCacheCount],\r
157	CapsuleResult,\r
158	CapsuleResultSize\r
159	);\r
160	mCapsuleResultVariableCacheCount++;\r
161	\r
162	return EFI_SUCCESS;\r
163	}\r
164	\r
165	/**\r
166	Get a new capsule status variable index.\r
167	\r
168	@return A new capsule status variable index.\r
169	@retval -1 No new capsule status variable index.\r
170	**/\r
171	INTN\r
172	GetNewCapsuleResultIndex (\r
173	VOID\r
174	)\r
175	{\r
176	INTN CurrentIndex;\r
177	\r
178	CurrentIndex = GetCurrentCapsuleLastIndex();\r
179	if (CurrentIndex >= PcdGet16(PcdCapsuleMax)) {\r
180	return -1;\r
181	}\r
182	\r
183	return CurrentIndex + 1;\r
184	}\r
185	\r
186	/**\r
187	Write a new capsule status variable.\r
188	\r
189	@param[in] CapsuleResult The capsule status variable\r
190	@param[in] CapsuleResultSize The size of the capsule stauts variable in bytes\r
191	\r
192	@retval EFI_SUCCESS The capsule status variable is recorded.\r
193	@retval EFI_OUT_OF_RESOURCES No resource to record the capsule status variable.\r
194	**/\r
195	EFI_STATUS\r
196	WriteNewCapsuleResultVariable (\r
197	IN VOID *CapsuleResult,\r
198	IN UINTN CapsuleResultSize\r
199	)\r
200	{\r
201	INTN CapsuleResultIndex;\r
202	CHAR16 CapsuleResultStr[sizeof("Capsule####")];\r
203	UINTN Size;\r
204	EFI_STATUS Status;\r
205	\r
206	CapsuleResultIndex = GetNewCapsuleResultIndex();\r
207	DEBUG((DEBUG_INFO, "New CapsuleResultIndex - 0x%x\n", CapsuleResultIndex));\r
208	if (CapsuleResultIndex == -1) {\r
209	return EFI_OUT_OF_RESOURCES;\r
210	}\r
211	UnicodeSPrint(\r
212	CapsuleResultStr,\r
213	sizeof(CapsuleResultStr),\r
214	L"Capsule%04x",\r
215	CapsuleResultIndex\r
216	);\r
217	\r
218	Status = gRT->SetVariable(\r
219	CapsuleResultStr,\r
220	&gEfiCapsuleReportGuid,\r
221	EFI_VARIABLE_NON_VOLATILE \| EFI_VARIABLE_BOOTSERVICE_ACCESS \| EFI_VARIABLE_RUNTIME_ACCESS,\r
222	CapsuleResultSize,\r
223	CapsuleResult\r
224	);\r
225	if (!EFI_ERROR(Status)) {\r
226	Size = sizeof(L"Capsule####") - sizeof(CHAR16); // no zero terminator\r
227	DEBUG((DEBUG_INFO, "Set CapsuleLast - %s\n", CapsuleResultStr));\r
228	Status = gRT->SetVariable(\r
229	L"CapsuleLast",\r
230	&gEfiCapsuleReportGuid,\r
231	EFI_VARIABLE_NON_VOLATILE \| EFI_VARIABLE_BOOTSERVICE_ACCESS \| EFI_VARIABLE_RUNTIME_ACCESS,\r
232	Size,\r
233	CapsuleResultStr\r
234	);\r
235	}\r
236	\r
237	return Status;\r
238	}\r
239	\r
240	/**\r
241	Record capsule status variable and to local cache.\r
242	\r
243	@param[in] CapsuleHeader The capsule image header\r
244	@param[in] CapsuleStatus The capsule process stauts\r
245	\r
246	@retval EFI_SUCCESS The capsule status variable is recorded.\r
247	@retval EFI_OUT_OF_RESOURCES No resource to record the capsule status variable.\r
248	**/\r
249	EFI_STATUS\r
250	RecordCapsuleStatusVariable (\r
251	IN EFI_CAPSULE_HEADER *CapsuleHeader,\r
252	IN EFI_STATUS CapsuleStatus\r
253	)\r
254	{\r
255	EFI_CAPSULE_RESULT_VARIABLE_HEADER CapsuleResultVariable;\r
256	EFI_STATUS Status;\r
257	\r
258	CapsuleResultVariable.VariableTotalSize = sizeof(CapsuleResultVariable);\r
259	CopyGuid (&CapsuleResultVariable.CapsuleGuid, &CapsuleHeader->CapsuleGuid);\r
260	ZeroMem(&CapsuleResultVariable.CapsuleProcessed, sizeof(CapsuleResultVariable.CapsuleProcessed));\r
261	gRT->GetTime(&CapsuleResultVariable.CapsuleProcessed, NULL);\r
262	CapsuleResultVariable.CapsuleStatus = CapsuleStatus;\r
263	\r
264	//\r
265	// Save Local Cache\r
266	//\r
267	Status = WriteNewCapsuleResultVariableCache(&CapsuleResultVariable, sizeof(CapsuleResultVariable));\r
268	\r
269	if ((CapsuleHeader->Flags & CAPSULE_FLAGS_PERSIST_ACROSS_RESET) != 0) {\r
270	Status = WriteNewCapsuleResultVariable(&CapsuleResultVariable, sizeof(CapsuleResultVariable));\r
271	}\r
272	return Status;\r
273	}\r
274	\r
275	/**\r
276	Record FMP capsule status variable and to local cache.\r
277	\r
278	@param[in] CapsuleHeader The capsule image header\r
279	@param[in] CapsuleStatus The capsule process stauts\r
280	@param[in] PayloadIndex FMP payload index\r
281	@param[in] ImageHeader FMP image header\r
282	\r
283	@retval EFI_SUCCESS The capsule status variable is recorded.\r
284	@retval EFI_OUT_OF_RESOURCES No resource to record the capsule status variable.\r
285	**/\r
286	EFI_STATUS\r
287	RecordFmpCapsuleStatusVariable (\r
288	IN EFI_CAPSULE_HEADER *CapsuleHeader,\r
289	IN EFI_STATUS CapsuleStatus,\r
290	IN UINTN PayloadIndex,\r
291	IN EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER *ImageHeader\r
292	)\r
293	{\r
d2a16030 JY	294	EFI_CAPSULE_RESULT_VARIABLE_HEADER *CapsuleResultVariableHeader;\r
	295	EFI_CAPSULE_RESULT_VARIABLE_FMP *CapsuleResultVariableFmp;\r
	296	EFI_STATUS Status;\r
b857bf48 DB	297	UINT8 *CapsuleResultVariable;\r
b857bf48 DB	298	UINT32 CapsuleResultVariableSize;\r
d2a16030	299	\r
b857bf48 DB	300	CapsuleResultVariable = NULL;\r
	301	CapsuleResultVariableSize = sizeof(EFI_CAPSULE_RESULT_VARIABLE_HEADER) + sizeof(EFI_CAPSULE_RESULT_VARIABLE_FMP);\r
	302	CapsuleResultVariable = AllocatePool (CapsuleResultVariableSize);\r
	303	if (CapsuleResultVariable == NULL) {\r
	304	return EFI_OUT_OF_RESOURCES;\r
	305	}\r
	306	CapsuleResultVariableHeader = (VOID *)CapsuleResultVariable;\r
	307	CapsuleResultVariableHeader->VariableTotalSize = CapsuleResultVariableSize;\r
d2a16030 JY	308	CopyGuid(&CapsuleResultVariableHeader->CapsuleGuid, &CapsuleHeader->CapsuleGuid);\r
	309	ZeroMem(&CapsuleResultVariableHeader->CapsuleProcessed, sizeof(CapsuleResultVariableHeader->CapsuleProcessed));\r
	310	gRT->GetTime(&CapsuleResultVariableHeader->CapsuleProcessed, NULL);\r
	311	CapsuleResultVariableHeader->CapsuleStatus = CapsuleStatus;\r
	312	\r
b857bf48	313	CapsuleResultVariableFmp = (VOID *)(CapsuleResultVariable + sizeof(EFI_CAPSULE_RESULT_VARIABLE_HEADER));\r
d2a16030 JY	314	CapsuleResultVariableFmp->Version = 0x1;\r
	315	CapsuleResultVariableFmp->PayloadIndex = (UINT8)PayloadIndex;\r
	316	CapsuleResultVariableFmp->UpdateImageIndex = ImageHeader->UpdateImageIndex;\r
	317	CopyGuid (&CapsuleResultVariableFmp->UpdateImageTypeId, &ImageHeader->UpdateImageTypeId);\r
	318	\r
	319	//\r
	320	// Save Local Cache\r
	321	//\r
b857bf48	322	Status = WriteNewCapsuleResultVariableCache(CapsuleResultVariable, CapsuleResultVariableSize);\r
d2a16030 JY	323	\r
d2a16030 JY	324	if ((CapsuleHeader->Flags & CAPSULE_FLAGS_PERSIST_ACROSS_RESET) != 0) {\r
b857bf48	325	Status = WriteNewCapsuleResultVariable(CapsuleResultVariable, CapsuleResultVariableSize);\r
d2a16030	326	}\r
b857bf48	327	FreePool (CapsuleResultVariable);\r
d2a16030 JY	328	return Status;\r
	329	}\r
	330	\r
	331	/**\r
	332	Initialize CapsuleMax variables.\r
	333	**/\r
	334	VOID\r
	335	InitCapsuleMaxVariable (\r
	336	VOID\r
	337	)\r
	338	{\r
	339	EFI_STATUS Status;\r
	340	UINTN Size;\r
	341	CHAR16 CapsuleMaxStr[sizeof("Capsule####")];\r
	342	EDKII_VARIABLE_LOCK_PROTOCOL *VariableLock;\r
	343	\r
	344	UnicodeSPrint(\r
	345	CapsuleMaxStr,\r
	346	sizeof(CapsuleMaxStr),\r
	347	L"Capsule%04x",\r
	348	PcdGet16(PcdCapsuleMax)\r
	349	);\r
	350	\r
	351	Size = sizeof(L"Capsule####") - sizeof(CHAR16); // no zero terminator\r
	352	Status = gRT->SetVariable(\r
	353	L"CapsuleMax",\r
	354	&gEfiCapsuleReportGuid,\r
	355	EFI_VARIABLE_BOOTSERVICE_ACCESS \| EFI_VARIABLE_RUNTIME_ACCESS,\r
	356	Size,\r
	357	CapsuleMaxStr\r
	358	);\r
	359	if (!EFI_ERROR(Status)) {\r
	360	// Lock it per UEFI spec.\r
	361	Status = gBS->LocateProtocol(&gEdkiiVariableLockProtocolGuid, NULL, (VOID **)&VariableLock);\r
	362	if (!EFI_ERROR(Status)) {\r
	363	Status = VariableLock->RequestToLock(VariableLock, L"CapsuleMax", &gEfiCapsuleReportGuid);\r
	364	ASSERT_EFI_ERROR(Status);\r
	365	}\r
	366	}\r
	367	}\r
	368	\r
	369	/**\r
	370	Initialize CapsuleLast variables.\r
	371	**/\r
	372	VOID\r
	373	InitCapsuleLastVariable (\r
	374	VOID\r
	375	)\r
	376	{\r
	377	EFI_STATUS Status;\r
	378	EFI_BOOT_MODE BootMode;\r
	379	EDKII_VARIABLE_LOCK_PROTOCOL *VariableLock;\r
	380	VOID *CapsuleResult;\r
	381	UINTN Size;\r
	382	CHAR16 CapsuleLastStr[sizeof("Capsule####")];\r
	383	\r
	384	BootMode = GetBootModeHob();\r
	385	if (BootMode == BOOT_ON_FLASH_UPDATE) {\r
	386	Status = gRT->SetVariable(\r
	387	L"CapsuleLast",\r
	388	&gEfiCapsuleReportGuid,\r
	389	EFI_VARIABLE_NON_VOLATILE \| EFI_VARIABLE_BOOTSERVICE_ACCESS \| EFI_VARIABLE_RUNTIME_ACCESS,\r
	390	0,\r
	391	NULL\r
392	);\r
393	// Do not lock it because it will be updated later.\r
394	} else {\r
395	//\r
396	// Check if OS/APP cleared L"Capsule####"\r
397	//\r
398	ZeroMem(CapsuleLastStr, sizeof(CapsuleLastStr));\r
399	Size = sizeof(L"Capsule####") - sizeof(CHAR16); // no zero terminator\r
400	Status = gRT->GetVariable(\r
401	L"CapsuleLast",\r
402	&gEfiCapsuleReportGuid,\r
403	NULL,\r
404	&Size,\r
405	CapsuleLastStr\r
406	);\r
407	if (!EFI_ERROR(Status)) {\r
408	//\r
409	// L"CapsuleLast" is got, check if data is there.\r
410	//\r
411	Status = GetVariable2 (\r
412	CapsuleLastStr,\r
413	&gEfiCapsuleReportGuid,\r
414	(VOID **) &CapsuleResult,\r
415	NULL\r
416	);\r
417	if (EFI_ERROR(Status)) {\r
418	//\r
419	// If no data, delete L"CapsuleLast"\r
420	//\r
421	Status = gRT->SetVariable(\r
422	L"CapsuleLast",\r
423	&gEfiCapsuleReportGuid,\r
424	EFI_VARIABLE_NON_VOLATILE \| EFI_VARIABLE_BOOTSERVICE_ACCESS \| EFI_VARIABLE_RUNTIME_ACCESS,\r
425	0,\r
426	NULL\r
427	);\r
428	}\r
429	}\r
430	\r
431	// Lock it in normal boot path per UEFI spec.\r
432	Status = gBS->LocateProtocol(&gEdkiiVariableLockProtocolGuid, NULL, (VOID **)&VariableLock);\r
433	if (!EFI_ERROR(Status)) {\r
434	Status = VariableLock->RequestToLock(VariableLock, L"CapsuleLast", &gEfiCapsuleReportGuid);\r
435	ASSERT_EFI_ERROR(Status);\r
436	}\r
437	}\r
438	}\r
439	\r
440	/**\r
441	Initialize capsule update variables.\r
442	**/\r
443	VOID\r
444	InitCapsuleUpdateVariable (\r
445	VOID\r
446	)\r
447	{\r
448	EFI_STATUS Status;\r
449	UINTN Index;\r
450	CHAR16 CapsuleVarName[30];\r
451	CHAR16 *TempVarName;\r
452	\r
453	//\r
454	// Clear all the capsule variables CapsuleUpdateData, CapsuleUpdateData1, CapsuleUpdateData2...\r
455	// as early as possible which will avoid the next time boot after the capsule update\r
456	// will still into the capsule loop\r
457	//\r
458	StrCpyS (CapsuleVarName, sizeof(CapsuleVarName)/sizeof(CapsuleVarName[0]), EFI_CAPSULE_VARIABLE_NAME);\r
459	TempVarName = CapsuleVarName + StrLen (CapsuleVarName);\r
460	Index = 0;\r
461	while (TRUE) {\r
462	if (Index > 0) {\r
463	UnicodeValueToString (TempVarName, 0, Index, 0);\r
464	}\r
465	Status = gRT->SetVariable (\r
466	CapsuleVarName,\r
467	&gEfiCapsuleVendorGuid,\r
468	EFI_VARIABLE_NON_VOLATILE \| EFI_VARIABLE_RUNTIME_ACCESS \| EFI_VARIABLE_BOOTSERVICE_ACCESS,\r
469	0,\r
470	(VOID *)NULL\r
471	);\r
472	if (EFI_ERROR (Status)) {\r
473	//\r
474	// There is no capsule variables, quit\r
475	//\r
476	break;\r
477	}\r
478	Index++;\r
479	}\r
480	}\r
481	\r
482	/**\r
483	Initialize capsule related variables.\r
484	**/\r
485	VOID\r
486	InitCapsuleVariable (\r
487	VOID\r
488	)\r
489	{\r
490	InitCapsuleUpdateVariable();\r
491	InitCapsuleMaxVariable();\r
492	InitCapsuleLastVariable();\r
493	//\r
494	// No need to clear L"Capsule####", because OS/APP should refer L"CapsuleLast"\r
495	// to check status and delete them.\r
496	//\r
497	}\r