/** @file\r
\r
- Implement the Fault Tolerant Write (FTW) protocol based on SMM FTW \r
+ Implement the Fault Tolerant Write (FTW) protocol based on SMM FTW\r
module.\r
\r
-Copyright (c) 2011 - 2013, 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
+Copyright (c) 2011 - 2018, Intel Corporation. All rights reserved. <BR>\r
+SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#include "FaultTolerantWriteSmmDxe.h"\r
\r
-EFI_HANDLE mHandle = NULL;\r
-EFI_SMM_COMMUNICATION_PROTOCOL *mSmmCommunication = NULL;\r
-UINTN mPrivateDataSize = 0;\r
+EFI_HANDLE mHandle = NULL;\r
+EFI_MM_COMMUNICATION2_PROTOCOL *mMmCommunication2 = NULL;\r
+UINTN mPrivateDataSize = 0;\r
\r
EFI_FAULT_TOLERANT_WRITE_PROTOCOL mFaultTolerantWriteDriver = {\r
FtwGetMaxBlockSize,\r
**/\r
VOID\r
InitCommunicateBuffer (\r
- OUT VOID **CommunicateBuffer,\r
- OUT VOID **DataPtr,\r
- IN UINTN DataSize,\r
- IN UINTN Function\r
+ OUT VOID **CommunicateBuffer,\r
+ OUT VOID **DataPtr,\r
+ IN UINTN DataSize,\r
+ IN UINTN Function\r
)\r
{\r
- EFI_SMM_COMMUNICATE_HEADER *SmmCommunicateHeader; \r
- SMM_FTW_COMMUNICATE_FUNCTION_HEADER *SmmFtwFunctionHeader; \r
+ EFI_MM_COMMUNICATE_HEADER *SmmCommunicateHeader;\r
+ SMM_FTW_COMMUNICATE_FUNCTION_HEADER *SmmFtwFunctionHeader;\r
\r
//\r
// The whole buffer size: SMM_COMMUNICATE_HEADER_SIZE + SMM_FTW_COMMUNICATE_HEADER_SIZE + DataSize.\r
//\r
SmmCommunicateHeader = AllocateZeroPool (DataSize + SMM_COMMUNICATE_HEADER_SIZE + SMM_FTW_COMMUNICATE_HEADER_SIZE);\r
ASSERT (SmmCommunicateHeader != NULL);\r
- \r
+\r
//\r
// Prepare data buffer.\r
//\r
CopyGuid (&SmmCommunicateHeader->HeaderGuid, &gEfiSmmFaultTolerantWriteProtocolGuid);\r
SmmCommunicateHeader->MessageLength = DataSize + SMM_FTW_COMMUNICATE_HEADER_SIZE;\r
- \r
- SmmFtwFunctionHeader = (SMM_FTW_COMMUNICATE_FUNCTION_HEADER *) SmmCommunicateHeader->Data;\r
+\r
+ SmmFtwFunctionHeader = (SMM_FTW_COMMUNICATE_FUNCTION_HEADER *)SmmCommunicateHeader->Data;\r
SmmFtwFunctionHeader->Function = Function;\r
\r
*CommunicateBuffer = SmmCommunicateHeader;\r
if (DataPtr != NULL) {\r
*DataPtr = SmmFtwFunctionHeader->Data;\r
- } \r
+ }\r
}\r
\r
-\r
/**\r
Send the data in communicate buffer to SMI handler and get response.\r
\r
@param[in, out] SmmCommunicateHeader The communicate buffer.\r
@param[in] DataSize The payload size.\r
- \r
+\r
**/\r
EFI_STATUS\r
SendCommunicateBuffer (\r
- IN OUT EFI_SMM_COMMUNICATE_HEADER *SmmCommunicateHeader,\r
- IN UINTN DataSize\r
+ IN OUT EFI_MM_COMMUNICATE_HEADER *SmmCommunicateHeader,\r
+ IN UINTN DataSize\r
)\r
{\r
- EFI_STATUS Status;\r
- UINTN CommSize;\r
- SMM_FTW_COMMUNICATE_FUNCTION_HEADER *SmmFtwFunctionHeader; \r
- \r
+ EFI_STATUS Status;\r
+ UINTN CommSize;\r
+ SMM_FTW_COMMUNICATE_FUNCTION_HEADER *SmmFtwFunctionHeader;\r
+\r
CommSize = DataSize + SMM_COMMUNICATE_HEADER_SIZE + SMM_FTW_COMMUNICATE_HEADER_SIZE;\r
- Status = mSmmCommunication->Communicate (mSmmCommunication, SmmCommunicateHeader, &CommSize);\r
+ Status = mMmCommunication2->Communicate (\r
+ mMmCommunication2,\r
+ SmmCommunicateHeader,\r
+ SmmCommunicateHeader,\r
+ &CommSize\r
+ );\r
ASSERT_EFI_ERROR (Status);\r
\r
- SmmFtwFunctionHeader = (SMM_FTW_COMMUNICATE_FUNCTION_HEADER *) SmmCommunicateHeader->Data;\r
- return SmmFtwFunctionHeader->ReturnStatus;\r
+ SmmFtwFunctionHeader = (SMM_FTW_COMMUNICATE_FUNCTION_HEADER *)SmmCommunicateHeader->Data;\r
+ return SmmFtwFunctionHeader->ReturnStatus;\r
}\r
\r
-\r
/**\r
Get the FvbBaseAddress and FvbAttributes from the FVB handle FvbHandle.\r
\r
@param[in] FvbHandle The handle of FVB protocol that provides services.\r
@param[out] FvbBaseAddress The base address of the FVB attached with FvbHandle.\r
@param[out] FvbAttributes The attributes of the FVB attached with FvbHandle.\r
- \r
+\r
@retval EFI_SUCCESS The function completed successfully.\r
@retval Others The function could not complete successfully.\r
\r
**/\r
EFI_STATUS\r
ConvertFvbHandle (\r
- IN EFI_HANDLE FvbHandle,\r
- OUT EFI_PHYSICAL_ADDRESS *FvbBaseAddress,\r
- OUT EFI_FVB_ATTRIBUTES_2 *FvbAttributes\r
+ IN EFI_HANDLE FvbHandle,\r
+ OUT EFI_PHYSICAL_ADDRESS *FvbBaseAddress,\r
+ OUT EFI_FVB_ATTRIBUTES_2 *FvbAttributes\r
)\r
{\r
- EFI_STATUS Status;\r
- EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *Fvb;\r
+ EFI_STATUS Status;\r
+ EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *Fvb;\r
\r
- Status = gBS->HandleProtocol (FvbHandle, &gEfiFirmwareVolumeBlockProtocolGuid, (VOID **) &Fvb);\r
+ Status = gBS->HandleProtocol (FvbHandle, &gEfiFirmwareVolumeBlockProtocolGuid, (VOID **)&Fvb);\r
if (EFI_ERROR (Status)) {\r
return Status;\r
}\r
- \r
+\r
Status = Fvb->GetPhysicalAddress (Fvb, FvbBaseAddress);\r
if (EFI_ERROR (Status)) {\r
return Status;\r
}\r
\r
Status = Fvb->GetAttributes (Fvb, FvbAttributes);\r
- return Status; \r
+ return Status;\r
}\r
\r
-\r
/**\r
Get the size of the largest block that can be updated in a fault-tolerant manner.\r
\r
EFI_STATUS\r
EFIAPI\r
FtwGetMaxBlockSize (\r
- IN EFI_FAULT_TOLERANT_WRITE_PROTOCOL *This,\r
- OUT UINTN *BlockSize\r
+ IN EFI_FAULT_TOLERANT_WRITE_PROTOCOL *This,\r
+ OUT UINTN *BlockSize\r
)\r
{\r
- EFI_STATUS Status;\r
- UINTN PayloadSize;\r
- EFI_SMM_COMMUNICATE_HEADER *SmmCommunicateHeader; \r
- SMM_FTW_GET_MAX_BLOCK_SIZE_HEADER *SmmFtwBlockSizeHeader;\r
+ EFI_STATUS Status;\r
+ UINTN PayloadSize;\r
+ EFI_MM_COMMUNICATE_HEADER *SmmCommunicateHeader;\r
+ SMM_FTW_GET_MAX_BLOCK_SIZE_HEADER *SmmFtwBlockSizeHeader;\r
\r
//\r
// Initialize the communicate buffer.\r
//\r
- PayloadSize = sizeof (SMM_FTW_GET_MAX_BLOCK_SIZE_HEADER);\r
+ PayloadSize = sizeof (SMM_FTW_GET_MAX_BLOCK_SIZE_HEADER);\r
InitCommunicateBuffer ((VOID **)&SmmCommunicateHeader, (VOID **)&SmmFtwBlockSizeHeader, PayloadSize, FTW_FUNCTION_GET_MAX_BLOCK_SIZE);\r
- \r
+\r
//\r
// Send data to SMM.\r
//\r
//\r
// Get data from SMM\r
//\r
- *BlockSize = SmmFtwBlockSizeHeader->BlockSize; \r
+ *BlockSize = SmmFtwBlockSizeHeader->BlockSize;\r
FreePool (SmmCommunicateHeader);\r
- \r
+\r
return Status;\r
}\r
\r
-\r
/**\r
Allocates space for the protocol to maintain information about writes.\r
Since writes must be completed in a fault-tolerant manner and multiple\r
EFI_STATUS\r
EFIAPI\r
FtwAllocate (\r
- IN EFI_FAULT_TOLERANT_WRITE_PROTOCOL *This,\r
- IN EFI_GUID *CallerId,\r
- IN UINTN PrivateDataSize,\r
- IN UINTN NumberOfWrites\r
+ IN EFI_FAULT_TOLERANT_WRITE_PROTOCOL *This,\r
+ IN EFI_GUID *CallerId,\r
+ IN UINTN PrivateDataSize,\r
+ IN UINTN NumberOfWrites\r
)\r
{\r
- EFI_STATUS Status;\r
- UINTN PayloadSize;\r
- EFI_SMM_COMMUNICATE_HEADER *SmmCommunicateHeader; \r
- SMM_FTW_ALLOCATE_HEADER *SmmFtwAllocateHeader;\r
+ EFI_STATUS Status;\r
+ UINTN PayloadSize;\r
+ EFI_MM_COMMUNICATE_HEADER *SmmCommunicateHeader;\r
+ SMM_FTW_ALLOCATE_HEADER *SmmFtwAllocateHeader;\r
\r
//\r
// Initialize the communicate buffer.\r
//\r
- PayloadSize = sizeof (SMM_FTW_ALLOCATE_HEADER);\r
+ PayloadSize = sizeof (SMM_FTW_ALLOCATE_HEADER);\r
InitCommunicateBuffer ((VOID **)&SmmCommunicateHeader, (VOID **)&SmmFtwAllocateHeader, PayloadSize, FTW_FUNCTION_ALLOCATE);\r
CopyGuid (&SmmFtwAllocateHeader->CallerId, CallerId);\r
SmmFtwAllocateHeader->PrivateDataSize = PrivateDataSize;\r
- SmmFtwAllocateHeader->NumberOfWrites = NumberOfWrites; \r
- \r
+ SmmFtwAllocateHeader->NumberOfWrites = NumberOfWrites;\r
+\r
//\r
// Send data to SMM.\r
//\r
Status = SendCommunicateBuffer (SmmCommunicateHeader, PayloadSize);\r
- if (!EFI_ERROR( Status)) {\r
+ if (!EFI_ERROR (Status)) {\r
mPrivateDataSize = PrivateDataSize;\r
}\r
\r
return Status;\r
}\r
\r
-\r
/**\r
Starts a target block update. This records information about the write\r
in fault tolerant storage, and will complete the write in a recoverable\r
EFI_STATUS\r
EFIAPI\r
FtwWrite (\r
- IN EFI_FAULT_TOLERANT_WRITE_PROTOCOL *This,\r
- IN EFI_LBA Lba,\r
- IN UINTN Offset,\r
- IN UINTN Length,\r
- IN VOID *PrivateData,\r
- IN EFI_HANDLE FvBlockHandle,\r
- IN VOID *Buffer\r
+ IN EFI_FAULT_TOLERANT_WRITE_PROTOCOL *This,\r
+ IN EFI_LBA Lba,\r
+ IN UINTN Offset,\r
+ IN UINTN Length,\r
+ IN VOID *PrivateData,\r
+ IN EFI_HANDLE FvBlockHandle,\r
+ IN VOID *Buffer\r
)\r
{\r
- EFI_STATUS Status;\r
- UINTN PayloadSize;\r
- EFI_SMM_COMMUNICATE_HEADER *SmmCommunicateHeader; \r
- SMM_FTW_WRITE_HEADER *SmmFtwWriteHeader;\r
+ EFI_STATUS Status;\r
+ UINTN PayloadSize;\r
+ EFI_MM_COMMUNICATE_HEADER *SmmCommunicateHeader;\r
+ SMM_FTW_WRITE_HEADER *SmmFtwWriteHeader;\r
\r
//\r
// Initialize the communicate buffer.\r
//\r
- PayloadSize = OFFSET_OF (SMM_FTW_WRITE_HEADER, Data) + Length;\r
+ PayloadSize = OFFSET_OF (SMM_FTW_WRITE_HEADER, Data) + Length;\r
if (PrivateData != NULL) {\r
//\r
// The private data buffer size should be the same one in FtwAllocate API.\r
//\r
PayloadSize += mPrivateDataSize;\r
}\r
+\r
InitCommunicateBuffer ((VOID **)&SmmCommunicateHeader, (VOID **)&SmmFtwWriteHeader, PayloadSize, FTW_FUNCTION_WRITE);\r
\r
//\r
- // FvBlockHandle can not be used in SMM environment. Here we get the FVB protocol first, then get FVB base address \r
+ // FvBlockHandle can not be used in SMM environment. Here we get the FVB protocol first, then get FVB base address\r
// and its attribute. Send these information to SMM handler, the SMM handler will find the proper FVB to write data.\r
//\r
Status = ConvertFvbHandle (FvBlockHandle, &SmmFtwWriteHeader->FvbBaseAddress, &SmmFtwWriteHeader->FvbAttributes);\r
FreePool (SmmCommunicateHeader);\r
return EFI_ABORTED;\r
}\r
- \r
+\r
SmmFtwWriteHeader->Lba = Lba;\r
- SmmFtwWriteHeader->Offset = Offset; \r
+ SmmFtwWriteHeader->Offset = Offset;\r
SmmFtwWriteHeader->Length = Length;\r
CopyMem (SmmFtwWriteHeader->Data, Buffer, Length);\r
if (PrivateData == NULL) {\r
// Send data to SMM.\r
//\r
Status = SendCommunicateBuffer (SmmCommunicateHeader, PayloadSize);\r
- FreePool (SmmCommunicateHeader); \r
+ FreePool (SmmCommunicateHeader);\r
return Status;\r
}\r
\r
-\r
/**\r
Restarts a previously interrupted write. The caller must provide the\r
block protocol needed to complete the interrupted write.\r
EFI_STATUS\r
EFIAPI\r
FtwRestart (\r
- IN EFI_FAULT_TOLERANT_WRITE_PROTOCOL *This,\r
- IN EFI_HANDLE FvBlockHandle\r
+ IN EFI_FAULT_TOLERANT_WRITE_PROTOCOL *This,\r
+ IN EFI_HANDLE FvBlockHandle\r
)\r
{\r
- EFI_STATUS Status;\r
- UINTN PayloadSize;\r
- EFI_SMM_COMMUNICATE_HEADER *SmmCommunicateHeader; \r
- SMM_FTW_RESTART_HEADER *SmmFtwRestartHeader;\r
- \r
+ EFI_STATUS Status;\r
+ UINTN PayloadSize;\r
+ EFI_MM_COMMUNICATE_HEADER *SmmCommunicateHeader;\r
+ SMM_FTW_RESTART_HEADER *SmmFtwRestartHeader;\r
+\r
//\r
// Initialize the communicate buffer.\r
//\r
- PayloadSize = sizeof (SMM_FTW_RESTART_HEADER);\r
- InitCommunicateBuffer ((VOID **)&SmmCommunicateHeader, (VOID **)&SmmFtwRestartHeader, PayloadSize, FTW_FUNCTION_RESTART); \r
+ PayloadSize = sizeof (SMM_FTW_RESTART_HEADER);\r
+ InitCommunicateBuffer ((VOID **)&SmmCommunicateHeader, (VOID **)&SmmFtwRestartHeader, PayloadSize, FTW_FUNCTION_RESTART);\r
\r
//\r
- // FvBlockHandle can not be used in SMM environment. Here we get the FVB protocol first, then get FVB base address \r
+ // FvBlockHandle can not be used in SMM environment. Here we get the FVB protocol first, then get FVB base address\r
// and its attribute. Send these information to SMM handler, the SMM handler will find the proper FVB to write data.\r
//\r
Status = ConvertFvbHandle (FvBlockHandle, &SmmFtwRestartHeader->FvbBaseAddress, &SmmFtwRestartHeader->FvbAttributes);\r
if (EFI_ERROR (Status)) {\r
- FreePool (SmmCommunicateHeader); \r
+ FreePool (SmmCommunicateHeader);\r
return EFI_ABORTED;\r
}\r
\r
// Send data to SMM.\r
//\r
Status = SendCommunicateBuffer (SmmCommunicateHeader, PayloadSize);\r
- FreePool (SmmCommunicateHeader); \r
+ FreePool (SmmCommunicateHeader);\r
return Status;\r
}\r
\r
-\r
/**\r
Aborts all previously allocated writes.\r
\r
EFI_STATUS\r
EFIAPI\r
FtwAbort (\r
- IN EFI_FAULT_TOLERANT_WRITE_PROTOCOL *This\r
+ IN EFI_FAULT_TOLERANT_WRITE_PROTOCOL *This\r
)\r
{\r
- EFI_STATUS Status;\r
- EFI_SMM_COMMUNICATE_HEADER *SmmCommunicateHeader; \r
- \r
+ EFI_STATUS Status;\r
+ EFI_MM_COMMUNICATE_HEADER *SmmCommunicateHeader;\r
+\r
//\r
// Initialize the communicate buffer.\r
//\r
InitCommunicateBuffer ((VOID **)&SmmCommunicateHeader, NULL, 0, FTW_FUNCTION_ABORT);\r
- \r
+\r
//\r
// Send data to SMM.\r
//\r
Status = SendCommunicateBuffer (SmmCommunicateHeader, 0);\r
\r
- FreePool (SmmCommunicateHeader); \r
+ FreePool (SmmCommunicateHeader);\r
return Status;\r
}\r
\r
-\r
/**\r
Starts a target block update. This function records information about the write\r
in fault-tolerant storage and completes the write in a recoverable\r
EFI_STATUS\r
EFIAPI\r
FtwGetLastWrite (\r
- IN EFI_FAULT_TOLERANT_WRITE_PROTOCOL *This,\r
- OUT EFI_GUID *CallerId,\r
- OUT EFI_LBA *Lba,\r
- OUT UINTN *Offset,\r
- OUT UINTN *Length,\r
- IN OUT UINTN *PrivateDataSize,\r
- OUT VOID *PrivateData,\r
- OUT BOOLEAN *Complete\r
+ IN EFI_FAULT_TOLERANT_WRITE_PROTOCOL *This,\r
+ OUT EFI_GUID *CallerId,\r
+ OUT EFI_LBA *Lba,\r
+ OUT UINTN *Offset,\r
+ OUT UINTN *Length,\r
+ IN OUT UINTN *PrivateDataSize,\r
+ OUT VOID *PrivateData,\r
+ OUT BOOLEAN *Complete\r
)\r
{\r
- EFI_STATUS Status;\r
- UINTN PayloadSize;\r
- EFI_SMM_COMMUNICATE_HEADER *SmmCommunicateHeader; \r
- SMM_FTW_GET_LAST_WRITE_HEADER *SmmFtwGetLastWriteHeader;\r
+ EFI_STATUS Status;\r
+ UINTN PayloadSize;\r
+ EFI_MM_COMMUNICATE_HEADER *SmmCommunicateHeader;\r
+ SMM_FTW_GET_LAST_WRITE_HEADER *SmmFtwGetLastWriteHeader;\r
\r
//\r
// Initialize the communicate buffer.\r
//\r
- PayloadSize = OFFSET_OF (SMM_FTW_GET_LAST_WRITE_HEADER, Data) + *PrivateDataSize;\r
+ PayloadSize = OFFSET_OF (SMM_FTW_GET_LAST_WRITE_HEADER, Data) + *PrivateDataSize;\r
InitCommunicateBuffer ((VOID **)&SmmCommunicateHeader, (VOID **)&SmmFtwGetLastWriteHeader, PayloadSize, FTW_FUNCTION_GET_LAST_WRITE);\r
SmmFtwGetLastWriteHeader->PrivateDataSize = *PrivateDataSize;\r
\r
// Get data from SMM\r
//\r
*PrivateDataSize = SmmFtwGetLastWriteHeader->PrivateDataSize;\r
- if (Status == EFI_SUCCESS || Status == EFI_BUFFER_TOO_SMALL) {\r
+ if ((Status == EFI_SUCCESS) || (Status == EFI_BUFFER_TOO_SMALL)) {\r
*Lba = SmmFtwGetLastWriteHeader->Lba;\r
- *Offset = SmmFtwGetLastWriteHeader->Offset; \r
+ *Offset = SmmFtwGetLastWriteHeader->Offset;\r
*Length = SmmFtwGetLastWriteHeader->Length;\r
*Complete = SmmFtwGetLastWriteHeader->Complete;\r
CopyGuid (CallerId, &SmmFtwGetLastWriteHeader->CallerId);\r
*Complete = SmmFtwGetLastWriteHeader->Complete;\r
}\r
\r
- FreePool (SmmCommunicateHeader); \r
+ FreePool (SmmCommunicateHeader);\r
return Status;\r
}\r
\r
VOID\r
EFIAPI\r
SmmFtwReady (\r
- IN EFI_EVENT Event,\r
- IN VOID *Context\r
+ IN EFI_EVENT Event,\r
+ IN VOID *Context\r
)\r
{\r
- EFI_STATUS Status;\r
- EFI_FAULT_TOLERANT_WRITE_PROTOCOL *FtwProtocol;\r
+ EFI_STATUS Status;\r
+ EFI_FAULT_TOLERANT_WRITE_PROTOCOL *FtwProtocol;\r
\r
//\r
// Just return to avoid install SMM FaultTolerantWriteProtocol again\r
// if Fault Tolerant Write protocol had been installed.\r
- // \r
+ //\r
Status = gBS->LocateProtocol (&gEfiFaultTolerantWriteProtocolGuid, NULL, (VOID **)&FtwProtocol);\r
if (!EFI_ERROR (Status)) {\r
return;\r
}\r
- \r
- Status = gBS->LocateProtocol (&gEfiSmmCommunicationProtocolGuid, NULL, (VOID **) &mSmmCommunication);\r
+\r
+ Status = gBS->LocateProtocol (&gEfiMmCommunication2ProtocolGuid, NULL, (VOID **)&mMmCommunication2);\r
ASSERT_EFI_ERROR (Status);\r
\r
//\r
&mFaultTolerantWriteDriver\r
);\r
ASSERT_EFI_ERROR (Status);\r
- \r
+\r
Status = gBS->CloseEvent (Event);\r
- ASSERT_EFI_ERROR (Status); \r
+ ASSERT_EFI_ERROR (Status);\r
}\r
\r
-\r
/**\r
The driver entry point for Fault Tolerant Write driver.\r
\r
EFI_STATUS\r
EFIAPI\r
FaultTolerantWriteSmmInitialize (\r
- IN EFI_HANDLE ImageHandle,\r
- IN EFI_SYSTEM_TABLE *SystemTable\r
+ IN EFI_HANDLE ImageHandle,\r
+ IN EFI_SYSTEM_TABLE *SystemTable\r
)\r
{\r
- VOID *SmmFtwRegistration;\r
+ VOID *SmmFtwRegistration;\r
\r
//\r
// Smm FTW driver is ready\r
//\r
EfiCreateProtocolNotifyEvent (\r
&gEfiSmmFaultTolerantWriteProtocolGuid,\r
- TPL_CALLBACK, \r
- SmmFtwReady, \r
- NULL, \r
+ TPL_CALLBACK,\r
+ SmmFtwReady,\r
+ NULL,\r
&SmmFtwRegistration\r
);\r
- \r
+\r
return EFI_SUCCESS;\r
}\r
-\r
projects / mirror_edk2.git / blobdiff