[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
  UINT8                               CapsuleResultVariable[sizeof(EFI_CAPSULE_RESULT_VARIABLE_HEADER) + sizeof(EFI_CAPSULE_RESULT_VARIABLE_FMP)];\r
  EFI_CAPSULE_RESULT_VARIABLE_HEADER  *CapsuleResultVariableHeader;\r
  EFI_CAPSULE_RESULT_VARIABLE_FMP     *CapsuleResultVariableFmp;\r
  EFI_STATUS                          Status;\r
\r
  CapsuleResultVariableHeader = (VOID *)&CapsuleResultVariable[0];\r
  CapsuleResultVariableHeader->VariableTotalSize = sizeof(CapsuleResultVariable);\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, 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
  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
294	UINT8 CapsuleResultVariable[sizeof(EFI_CAPSULE_RESULT_VARIABLE_HEADER) + sizeof(EFI_CAPSULE_RESULT_VARIABLE_FMP)];\r
295	EFI_CAPSULE_RESULT_VARIABLE_HEADER *CapsuleResultVariableHeader;\r
296	EFI_CAPSULE_RESULT_VARIABLE_FMP *CapsuleResultVariableFmp;\r
297	EFI_STATUS Status;\r
298	\r
299	CapsuleResultVariableHeader = (VOID *)&CapsuleResultVariable[0];\r
300	CapsuleResultVariableHeader->VariableTotalSize = sizeof(CapsuleResultVariable);\r
301	CopyGuid(&CapsuleResultVariableHeader->CapsuleGuid, &CapsuleHeader->CapsuleGuid);\r
302	ZeroMem(&CapsuleResultVariableHeader->CapsuleProcessed, sizeof(CapsuleResultVariableHeader->CapsuleProcessed));\r
303	gRT->GetTime(&CapsuleResultVariableHeader->CapsuleProcessed, NULL);\r
304	CapsuleResultVariableHeader->CapsuleStatus = CapsuleStatus;\r
305	\r
306	CapsuleResultVariableFmp = (VOID *)&CapsuleResultVariable[sizeof(EFI_CAPSULE_RESULT_VARIABLE_HEADER)];\r
307	CapsuleResultVariableFmp->Version = 0x1;\r
308	CapsuleResultVariableFmp->PayloadIndex = (UINT8)PayloadIndex;\r
309	CapsuleResultVariableFmp->UpdateImageIndex = ImageHeader->UpdateImageIndex;\r
310	CopyGuid (&CapsuleResultVariableFmp->UpdateImageTypeId, &ImageHeader->UpdateImageTypeId);\r
311	\r
312	//\r
313	// Save Local Cache\r
314	//\r
315	Status = WriteNewCapsuleResultVariableCache(&CapsuleResultVariable, sizeof(CapsuleResultVariable));\r
316	\r
317	if ((CapsuleHeader->Flags & CAPSULE_FLAGS_PERSIST_ACROSS_RESET) != 0) {\r
318	Status = WriteNewCapsuleResultVariable(&CapsuleResultVariable, sizeof(CapsuleResultVariable));\r
319	}\r
320	return Status;\r
321	}\r
322	\r
323	/**\r
324	Initialize CapsuleMax variables.\r
325	**/\r
326	VOID\r
327	InitCapsuleMaxVariable (\r
328	VOID\r
329	)\r
330	{\r
331	EFI_STATUS Status;\r
332	UINTN Size;\r
333	CHAR16 CapsuleMaxStr[sizeof("Capsule####")];\r
334	EDKII_VARIABLE_LOCK_PROTOCOL *VariableLock;\r
335	\r
336	UnicodeSPrint(\r
337	CapsuleMaxStr,\r
338	sizeof(CapsuleMaxStr),\r
339	L"Capsule%04x",\r
340	PcdGet16(PcdCapsuleMax)\r
341	);\r
342	\r
343	Size = sizeof(L"Capsule####") - sizeof(CHAR16); // no zero terminator\r
344	Status = gRT->SetVariable(\r
345	L"CapsuleMax",\r
346	&gEfiCapsuleReportGuid,\r
347	EFI_VARIABLE_BOOTSERVICE_ACCESS \| EFI_VARIABLE_RUNTIME_ACCESS,\r
348	Size,\r
349	CapsuleMaxStr\r
350	);\r
351	if (!EFI_ERROR(Status)) {\r
352	// Lock it per UEFI spec.\r
353	Status = gBS->LocateProtocol(&gEdkiiVariableLockProtocolGuid, NULL, (VOID **)&VariableLock);\r
354	if (!EFI_ERROR(Status)) {\r
355	Status = VariableLock->RequestToLock(VariableLock, L"CapsuleMax", &gEfiCapsuleReportGuid);\r
356	ASSERT_EFI_ERROR(Status);\r
357	}\r
358	}\r
359	}\r
360	\r
361	/**\r
362	Initialize CapsuleLast variables.\r
363	**/\r
364	VOID\r
365	InitCapsuleLastVariable (\r
366	VOID\r
367	)\r
368	{\r
369	EFI_STATUS Status;\r
370	EFI_BOOT_MODE BootMode;\r
371	EDKII_VARIABLE_LOCK_PROTOCOL *VariableLock;\r
372	VOID *CapsuleResult;\r
373	UINTN Size;\r
374	CHAR16 CapsuleLastStr[sizeof("Capsule####")];\r
375	\r
376	BootMode = GetBootModeHob();\r
377	if (BootMode == BOOT_ON_FLASH_UPDATE) {\r
378	Status = gRT->SetVariable(\r
379	L"CapsuleLast",\r
380	&gEfiCapsuleReportGuid,\r
381	EFI_VARIABLE_NON_VOLATILE \| EFI_VARIABLE_BOOTSERVICE_ACCESS \| EFI_VARIABLE_RUNTIME_ACCESS,\r
382	0,\r
383	NULL\r
384	);\r
385	// Do not lock it because it will be updated later.\r
386	} else {\r
387	//\r
388	// Check if OS/APP cleared L"Capsule####"\r
389	//\r
390	ZeroMem(CapsuleLastStr, sizeof(CapsuleLastStr));\r
391	Size = sizeof(L"Capsule####") - sizeof(CHAR16); // no zero terminator\r
392	Status = gRT->GetVariable(\r
393	L"CapsuleLast",\r
394	&gEfiCapsuleReportGuid,\r
395	NULL,\r
396	&Size,\r
397	CapsuleLastStr\r
398	);\r
399	if (!EFI_ERROR(Status)) {\r
400	//\r
401	// L"CapsuleLast" is got, check if data is there.\r
402	//\r
403	Status = GetVariable2 (\r
404	CapsuleLastStr,\r
405	&gEfiCapsuleReportGuid,\r
406	(VOID **) &CapsuleResult,\r
407	NULL\r
408	);\r
409	if (EFI_ERROR(Status)) {\r
410	//\r
411	// If no data, delete L"CapsuleLast"\r
412	//\r
413	Status = gRT->SetVariable(\r
414	L"CapsuleLast",\r
415	&gEfiCapsuleReportGuid,\r
416	EFI_VARIABLE_NON_VOLATILE \| EFI_VARIABLE_BOOTSERVICE_ACCESS \| EFI_VARIABLE_RUNTIME_ACCESS,\r
417	0,\r
418	NULL\r
419	);\r
420	}\r
421	}\r
422	\r
423	// Lock it in normal boot path per UEFI spec.\r
424	Status = gBS->LocateProtocol(&gEdkiiVariableLockProtocolGuid, NULL, (VOID **)&VariableLock);\r
425	if (!EFI_ERROR(Status)) {\r
426	Status = VariableLock->RequestToLock(VariableLock, L"CapsuleLast", &gEfiCapsuleReportGuid);\r
427	ASSERT_EFI_ERROR(Status);\r
428	}\r
429	}\r
430	}\r
431	\r
432	/**\r
433	Initialize capsule update variables.\r
434	**/\r
435	VOID\r
436	InitCapsuleUpdateVariable (\r
437	VOID\r
438	)\r
439	{\r
440	EFI_STATUS Status;\r
441	UINTN Index;\r
442	CHAR16 CapsuleVarName[30];\r
443	CHAR16 *TempVarName;\r
444	\r
445	//\r
446	// Clear all the capsule variables CapsuleUpdateData, CapsuleUpdateData1, CapsuleUpdateData2...\r
447	// as early as possible which will avoid the next time boot after the capsule update\r
448	// will still into the capsule loop\r
449	//\r
450	StrCpyS (CapsuleVarName, sizeof(CapsuleVarName)/sizeof(CapsuleVarName[0]), EFI_CAPSULE_VARIABLE_NAME);\r
451	TempVarName = CapsuleVarName + StrLen (CapsuleVarName);\r
452	Index = 0;\r
453	while (TRUE) {\r
454	if (Index > 0) {\r
455	UnicodeValueToString (TempVarName, 0, Index, 0);\r
456	}\r
457	Status = gRT->SetVariable (\r
458	CapsuleVarName,\r
459	&gEfiCapsuleVendorGuid,\r
460	EFI_VARIABLE_NON_VOLATILE \| EFI_VARIABLE_RUNTIME_ACCESS \| EFI_VARIABLE_BOOTSERVICE_ACCESS,\r
461	0,\r
462	(VOID *)NULL\r
463	);\r
464	if (EFI_ERROR (Status)) {\r
465	//\r
466	// There is no capsule variables, quit\r
467	//\r
468	break;\r
469	}\r
470	Index++;\r
471	}\r
472	}\r
473	\r
474	/**\r
475	Initialize capsule related variables.\r
476	**/\r
477	VOID\r
478	InitCapsuleVariable (\r
479	VOID\r
480	)\r
481	{\r
482	InitCapsuleUpdateVariable();\r
483	InitCapsuleMaxVariable();\r
484	InitCapsuleLastVariable();\r
485	//\r
486	// No need to clear L"Capsule####", because OS/APP should refer L"CapsuleLast"\r
487	// to check status and delete them.\r
488	//\r
489	}\r