xinb
/
alder_lake_bios
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
alder_lake_bios/Insyde/InsydeModulePkg/Universal/Dash/DashDxe/Pldm.c

777 lines
23 KiB
C
Raw Permalink Blame History

/** @file
Platform Level Data Model implementation
;******************************************************************************
;* Copyright (c) 2012 - 2020, Insyde Software Corp. All Rights Reserved.
;*
;* You may not reproduce, distribute, publish, display, perform, modify, adapt,
;* transmit, broadcast, present, recite, release, license or otherwise exploit
;* any part of this publication in any form, by any means, without the prior
;* written permission of Insyde Software Corporation.
;*
;******************************************************************************
*/
#include "Pldm.h"
#include <Library/BdsCpLib.h>
#include <Guid/H2OBdsCheckPoint.h>
PLDM_CONTEXT mPldmContext;
VOID
EFIAPI
PushManagementDataToMC(
IN EFI_EVENT Event,
IN VOID *Context
);
VOID
EFIAPI
SyncBootOrderDataWhenBootOrderHookEnable (
IN EFI_EVENT Event,
IN VOID *Context
);
VOID
EFIAPI
SetPldmResponseMode(
EFI_PLDM_PROTOCOL *This
)
{
PLDM_CONTEXT *Context;
Context = PLDM_CONTEXT_FROM_THIS(This);
Context->Mctp->SetResponseMode(Context->Mctp);
Context->ResponseMode = TRUE;
}
VOID
EFIAPI
SetPldmRequestMode(
EFI_PLDM_PROTOCOL *This
)
{
PLDM_CONTEXT *Context;
Context = PLDM_CONTEXT_FROM_THIS(This);
Context->Mctp->SetRequestMode(Context->Mctp);
Context->ResponseMode = FALSE;
}
/**
Set binding MCTP protcol
@param [in] This Point to EFI_PLDM_PROTOCOL
@param [in] Mctp Binding MCTP protocol
@retval EFI_SUCCESS Successful
@retval EFI_INVALID_PARAMETER Invalid parameter error
**/
EFI_STATUS
EFIAPI
PldmSetMctpBinding (
IN EFI_PLDM_PROTOCOL *This,
IN EFI_MCTP_PROTOCOL *Mctp
)
{
PLDM_CONTEXT *PldmContext;
if (Mctp == NULL) {
return EFI_INVALID_PARAMETER;
}
PldmContext = PLDM_CONTEXT_FROM_THIS (This);
PldmContext->Mctp = Mctp;
return EFI_SUCCESS;
/**
Set Data Transfer Handle and Data Transfer Flag for the transfer header of a PLDM request message
@param [out] RequestMessage The PLDM request message
@param [in] TransferHandle The Transfer Handle
@param [in] Flag The Transfer Flag
@retval none
**/
}
VOID
EFIAPI
PldmSetDataTransferHandle (
OUT VOID *RequestMessage,
IN UINT32 TransferHandle,
IN UINT8 Flag
)
{
((UINT32 *)RequestMessage)[0] = TransferHandle;
((UINT8 *)RequestMessage)[4] = Flag;
}
/**
Retrieve Data Transfer Handle and Data Transfer Flag from PLDM response data
@param [in] ResponseMessage The PLDM response message
@param [out] TransferHandle The Transfer Handle
@param [out] Flag The Transfer Flag
@retval none
**/
VOID
EFIAPI
PldmGetNextDataTransferHandle (
IN VOID *ResponseMessage,
OUT UINT32 *TransferHandle,
OUT UINT8 *Flag
)
{
*TransferHandle = ((UINT32 *)(UINT8 *)ResponseMessage)[0];
if (Flag != NULL) {
*Flag = ((UINT8 *)ResponseMessage)[4];
}
}
/**
Process a complete PLDM request and response transaction with single request and single response
@param [in] This
@param [in] PldmType 00: PLDM Base, 01: SMBIOS, 02: Monitoring & Control, 03: BIOS Control & Configuration
@param [in] Command The PLDM command according to the PLDM Type
@param [in] RequestMessage PLDM Request Message with PLDM header excluded
@param [in] RequestMessageSize Number of bytes for RequestMessage
@param [in] ResponseMessage PLDM Response Message with PLDM header excluded
@param [in, out] ResponseMessageSize Number of bytes for ResponseMessage
@retval EFI_SUCCESS Successful
@return Other values Unsuccessful
**/
EFI_STATUS
EFIAPI
ProcessSimplePldmMessage (
IN EFI_PLDM_PROTOCOL *This,
IN UINT8 PldmType,
IN UINT8 Command,
IN VOID *RequestMessage,
IN UINTN RequestMessageSize,
IN VOID *ResponseMessage,
IN OUT UINTN *ResponseMessageSize
)
{
EFI_STATUS Status;
PLDM_HEADER Header = PLDM_HEADER_COMMON;
PLDM_CONTEXT *PldmContext;
PldmContext = PLDM_CONTEXT_FROM_THIS (This);
This->SetRequestMode(This);
PldmContext->TransactionInProgress = TRUE;
Header.PldmType = PldmType;
Header.PldmCmdCode = Command;
PldmContext->InstanceId = (PldmContext->InstanceId + 1) % 32;
Header.InstanceId = PldmContext->InstanceId;
Status = This->SendMessage(This, Header, RequestMessage,RequestMessageSize);
if (Status == EFI_SUCCESS) {
Status = This->ReceiveMessage (This, &Header, ResponseMessage, ResponseMessageSize);
}
PldmContext->TransactionInProgress = FALSE;;
return Status;
}
/**
Process a complete PLDM request and response transaction with multiple requests for large request data transfer
@param [in] This
@param [in] PldmType 00: PLDM Base, 01: SMBIOS, 02: Monitoring & Control, 03: BIOS Control & Configuration
@param [in] Command The PLDM command according to the PLDM Type
@param [in] TransferHeader The Request Transfer Header according to the PLDM command
@param [in] TransferHeaderSize Number of bytes for TransferHeader
@param [in] RequestMessage PLDM Request Message with PLDM header and Transfer Header excluded
@param [in] RequestMessageSize Number of bytes for RequestMessage
@retval EFI_SUCCESS Successful
@return Other values Unsuccessful
**/
EFI_STATUS
EFIAPI
ProcessPldmMessageWithSplitRequests (
IN EFI_PLDM_PROTOCOL *This,
IN UINT8 PldmType,
IN UINT8 Command,
IN VOID *TransferHeader,
IN UINTN TransferHeaderSize,
IN VOID *RequestMessage,
IN UINTN RequestMessageSize
)
{
UINT8 Payload[MAX_PLDM_PAYLOAD_SIZE];
UINT8 TransferFlag;
UINT32 TransferHandle;
UINTN TransferIndex;
UINTN PayloadSize;
UINTN MsgSize;
UINTN RemainingBytes;
PLDM_HEADER RequestHeader = PLDM_HEADER_COMMON;
PLDM_HEADER ResponseHeader;
PLDM_CONTEXT *PldmContext;
EFI_STATUS Status;
UINT32 Crc32;
PldmContext = PLDM_CONTEXT_FROM_THIS(This);
This->SetRequestMode(This);
PldmContext->TransactionInProgress = TRUE;
RequestHeader.PldmType = PldmType;
RequestHeader.PldmCmdCode = Command;
Status = EFI_SUCCESS;
TransferHandle = 0x10;
TransferIndex = 0;
Crc32 = 0;
gBS->CalculateCrc32(RequestMessage, RequestMessageSize, &Crc32);
do {
PldmContext->InstanceId = (PldmContext->InstanceId + 1) % 32;
RequestHeader.InstanceId = PldmContext->InstanceId;
//
// Add additinal 4 CRC32 bytes
//
RemainingBytes = RequestMessageSize - TransferIndex + 4;
if (RemainingBytes + TransferHeaderSize > PldmContext->MaxPayloadSize) {
if (RemainingBytes + TransferHeaderSize - 4 >= PldmContext->MaxPayloadSize) {
PayloadSize = PldmContext->MaxPayloadSize;
} else {
//
// CRC bytes will be sent in the next transfer loop
//
PayloadSize = RemainingBytes + TransferHeaderSize - 4;
}
MsgSize = PayloadSize - TransferHeaderSize;
if (TransferIndex == 0) {
TransferFlag = PldmTransferStart;
} else {
TransferFlag = PldmTransferMiddle;
}
} else {
PayloadSize = RemainingBytes + TransferHeaderSize;
MsgSize = RemainingBytes - 4;
if (TransferIndex == 0) {
TransferFlag = PldmTransferStartAndEnd;
} else {
TransferFlag = PldmTransferEnd;
}
}
PldmSetDataTransferHandle (TransferHeader, TransferHandle, TransferFlag);
gBS->CopyMem (Payload, TransferHeader, TransferHeaderSize);
gBS->CopyMem (Payload + TransferHeaderSize, (UINT8 *)RequestMessage + TransferIndex, MsgSize);
if ((TransferFlag & PldmTransferEnd) == PldmTransferEnd) {
gBS->CopyMem (Payload + PayloadSize - 4, &Crc32, 4);
}
Status = This->SendMessage (This, RequestHeader, Payload, PayloadSize );
if (EFI_ERROR (Status)) {
break;
}
TransferIndex += PayloadSize - TransferHeaderSize;
PayloadSize = PldmContext->MaxPayloadSize;
Status = This->ReceiveMessage (This, &ResponseHeader, Payload, &PayloadSize);
if (EFI_ERROR (Status)) {
break;
}
PldmGetNextDataTransferHandle(Payload, &TransferHandle, NULL);
}while ((TransferFlag & PldmTransferEnd)!= PldmTransferEnd);
PldmContext->TransactionInProgress = FALSE;;
return Status;
}
/**
Process a complete PLDM request and response transaction with multiple responses for large response data transfer
@param [in] This
@param [in] PldmType 00: PLDM Base, 01: SMBIOS, 02: Monitoring & Control, 03: BIOS Control & Configuration
@param [in] Command The PLDM command according to the PLDM Type
@param [in] TransferHeader The Request Transfer Header according to the PLDM command
@param [in] TransferHeaderSize Number of bytes for TransferHeader
@param [out] ResponseMessage PLDM Response Message with PLDM header and Transfer Header excluded
@param [in, out] ResponseMessageSize Number of bytes for ResponseMessage
@retval EFI_SUCCESS Successful
@return Other values Unsuccessful
**/
EFI_STATUS
EFIAPI
ProcessPldmMessageWithSplitResponses (
IN EFI_PLDM_PROTOCOL *This,
IN UINT8 PldmType,
IN UINT8 Command,
IN VOID *TransferHeader,
IN UINTN TransferHeaderSize,
OUT VOID *ResponseMessage,
IN OUT UINTN *ResponseMessageSize
)
{
UINT8 Payload[MAX_PLDM_PAYLOAD_SIZE];
UINT8 TransferOperationFlag;
UINT8 TransferFlag;
UINT32 TransferHandle;
UINTN TransferIndex;
UINTN PayloadSize;
UINTN MsgSize;
PLDM_HEADER RequestHeader = PLDM_HEADER_COMMON;
PLDM_HEADER ResponseHeader;
PLDM_CONTEXT *PldmContext;
EFI_STATUS Status;
UINT32 Crc32;
PldmContext = PLDM_CONTEXT_FROM_THIS(This);
This->SetRequestMode(This);
PldmContext->TransactionInProgress = TRUE;
RequestHeader.PldmType = PldmType;
RequestHeader.PldmCmdCode = Command;
TransferHandle = 0x10;
TransferOperationFlag = PldmGetFirstPart;
TransferIndex = 0;
Status = EFI_SUCCESS;
do {
PldmContext->InstanceId = (PldmContext->InstanceId + 1) % 32;
RequestHeader.InstanceId = PldmContext->InstanceId;
PldmSetDataTransferHandle (TransferHeader, TransferHandle, TransferOperationFlag);
gBS->CopyMem (Payload , TransferHeader, TransferHeaderSize);
PayloadSize = TransferHeaderSize;
Status = This->SendMessage (This, RequestHeader, Payload, PayloadSize);
if (EFI_ERROR(Status)) {
break;
}
PayloadSize = PldmContext->MaxPayloadSize;
Status = This->ReceiveMessage (This, &ResponseHeader, Payload, &PayloadSize);
if (EFI_ERROR(Status)) {
break;
}
PldmGetNextDataTransferHandle(Payload, &TransferHandle, &TransferFlag);
if ((TransferFlag & 0xF8) !=0x00) {
Status = EFI_PROTOCOL_ERROR;
break;
}
if ((TransferFlag & PldmTransferEnd) == PldmTransferEnd) {
MsgSize = PayloadSize - (RESPONSE_TRANSFER_HEADER_SIZE + 4);
} else {
MsgSize = PayloadSize - RESPONSE_TRANSFER_HEADER_SIZE;
}
gBS->CopyMem ((UINT8 *)ResponseMessage + TransferIndex, Payload + RESPONSE_TRANSFER_HEADER_SIZE, MsgSize);
TransferIndex += MsgSize;
TransferOperationFlag = PldmGetNextPart;
}while ((TransferFlag & PldmTransferEnd) != PldmTransferEnd);
if (Status == EFI_SUCCESS) {
*ResponseMessageSize = TransferIndex;
Crc32 = 0;
gBS->CalculateCrc32 (ResponseMessage, *ResponseMessageSize, &Crc32);
if ( *(UINT32 *)(Payload + PayloadSize - 4) != Crc32) {
Status = EFI_CRC_ERROR;
}
}
PldmContext->TransactionInProgress = FALSE;
return Status;
}
/**
Send a single request message to the management controller
@param [in] This Pointer to EFI_PLDM_PROTOCOL
@param [in] Header The PLDM header
@param [in] Message The Request Message without PLDM header
@param [in] MessageSize
@retval EFI_SUCCESS Successful
@return Other values Unsuccessful
**/
EFI_STATUS
EFIAPI
PldmSendMessage (
IN EFI_PLDM_PROTOCOL *This,
IN PLDM_HEADER Header,
IN VOID *Message,
IN UINTN MessageSize
)
{
PLDM_CONTEXT *PldmContext;
EFI_STATUS Status;
UINT8 *MctpMsg;
PldmContext = PLDM_CONTEXT_FROM_THIS (This);
MctpMsg = PldmContext->Buffer;
if (PldmContext->ResponseMode) {
Header.RequestBit = 0;
}
gBS->CopyMem (MctpMsg, &Header, sizeof (PLDM_HEADER));
if ((MessageSize != 0) && (Message != NULL)) {
gBS->CopyMem (MctpMsg + sizeof (PLDM_HEADER), Message, MessageSize);
}
Status = PldmContext->Mctp->SendMessage (PldmContext->Mctp,
MctpMsg,
MessageSize + sizeof (PLDM_HEADER)
);
return Status;
}
/**
Receive a single response message from the management controller
@param [in] This Pointer to EFI_PLDM_PROTOCOL
@param [out] Header The PLDM header
@param [out] Message The Response Message without PLDM header
@param [in, out] MessageSize
@retval EFI_SUCCESS Successful
@return Other values Unsuccessful
**/
EFI_STATUS
EFIAPI
PldmReceiveMessage (
IN EFI_PLDM_PROTOCOL *This,
OUT PLDM_HEADER *Header,
OUT VOID *Message,
IN OUT UINTN *MessageSize
)
{
PLDM_CONTEXT *PldmContext;
EFI_STATUS Status;
UINT8 *MctpMsg;
UINTN MctpMsgSize;
UINTN MsgOffset;
PldmContext = PLDM_CONTEXT_FROM_THIS (This);
MctpMsg = PldmContext->Buffer;
MctpMsgSize = *MessageSize + sizeof (PLDM_HEADER) + 1;
Status = PldmContext->Mctp->ReceiveMessage (PldmContext->Mctp,
MctpMsg,
&MctpMsgSize
);
if (Status == EFI_SUCCESS) {
if ((!PldmContext->ResponseMode) && (MctpMsg[sizeof(PLDM_HEADER)] != PLDM_SUCCESS)) {
return EFI_PLDM_COMPLETION_ERROR;
}
if (PldmContext->ResponseMode) {
MsgOffset = sizeof (PLDM_HEADER);
} else {
MsgOffset = sizeof (PLDM_HEADER) + 1;
}
gBS->CopyMem (Header, MctpMsg, sizeof (PLDM_HEADER));
*MessageSize = MctpMsgSize - MsgOffset;
gBS->CopyMem (Message, MctpMsg + MsgOffset, *MessageSize);
}
return Status;
}
/**
Get PLDM Target ID
@param [in] This Pointer to EFI_PLDM_PROTOCOL
@param [out] Tid The Target ID
@retval EFI_SUCCESS Command completed successfully
@return Other value Unknown error
**/
EFI_STATUS
EFIAPI
PldmGetTid (
IN EFI_PLDM_PROTOCOL *This,
OUT UINT8 *Tid
)
{
EFI_STATUS Status;
UINTN Size;
Size = 1;
Status = ProcessSimplePldmMessage(This,
PLDM_TYPE_MESSAGE_CONTROL_AND_DISCOVERY,
PLDM_BASE_GET_TID,
NULL,
0,
Tid,
&Size
);
return Status;
}
/**
Get PLDM supported versions
@param [in] This Pointer to EFI_PLDM_PROTOCOL
@param [in] PldmType
@param [out] VersionInfo The supported version information
@param [out] VersionInfoSize Number of bytes for VersionInfo
@retval EFI_SUCCESS Command completed successfully
@return Other value Unknown error
**/
EFI_STATUS
EFIAPI
GetPldmVersion (
IN EFI_PLDM_PROTOCOL *This,
IN UINT8 PldmType,
OUT UINT32 *VersionInfo,
OUT UINTN *VersionInfoSize
)
{
EFI_STATUS Status;
PLDM_GET_VERSION_REQUEST_DATA PldmRequest;
PldmRequest.DataTransferHandle = 0;
PldmRequest.TransferOperationFlag = PldmGetFirstPart;
PldmRequest.PldmType = PldmType;
Status = ProcessPldmMessageWithSplitResponses(This,
PLDM_TYPE_MESSAGE_CONTROL_AND_DISCOVERY,
PLDM_BASE_GET_PLDM_VERSION,
&PldmRequest,
sizeof (PldmRequest),
VersionInfo,
VersionInfoSize
);
return Status;
}
/**
Get supported PLDM Types
@param This Pointer to EFI_PLDM_PROTOCOL
@param SupportedTypes Bit mask for the supported types,
if Bit No. N of the Mth Byte is set, then command M*8+N is supported
@retval EFI_SUCCESS Command completed successfully
@return Other value Unknown error
**/
EFI_STATUS
EFIAPI
GetPldmSupportedTypes (
EFI_PLDM_PROTOCOL *This,
UINT8 *SupportedTypes
)
{
EFI_STATUS Status;
UINTN ResponseSize;
ResponseSize = 8; //sizeof (PLDM_SUPPORTED_TYPES);
Status = ProcessSimplePldmMessage(This,
PLDM_TYPE_MESSAGE_CONTROL_AND_DISCOVERY,
PLDM_BASE_GET_PLDM_TYPES,
NULL,
0,
SupportedTypes,
&ResponseSize
);
return Status;
}
/**
Get supported PLDM commands for a specified PLDM type
@param This Pointer to EFI_PLDM_PROTOCOL
@param PldmType 00: PLDM Base, 01: SMBIOS, 02: Monitoring & Control, 03: BIOS Control & Configuration
@param PldmTypeVersion Version for the PLDM type, it should be 0xF1F0F000
@param SupportedCommands
@retval EFI_SUCCESS Command completed successfully
@return Other value Unknown error
**/
EFI_STATUS
EFIAPI
GetPldmSupportedCommands (
EFI_PLDM_PROTOCOL *This,
UINT8 PldmType,
UINT32 PldmTypeVersion,
UINT8 *SupportedCommands
)
{
EFI_STATUS Status;
UINTN ResponseSize;
PLDM_GET_COMMANDS_REQUEST_DATA PldmRequest;
PldmRequest.PldmType = PldmType;
PldmRequest.Version = PldmTypeVersion;
ResponseSize = 32; //sizeof (PLDM_SUPPORTED_COMMANDS);
Status = ProcessSimplePldmMessage(This,
PLDM_TYPE_MESSAGE_CONTROL_AND_DISCOVERY,
PLDM_BASE_GET_PLDM_COMMANDS,
&PldmRequest,
sizeof (PLDM_GET_COMMANDS_REQUEST_DATA),
SupportedCommands,
&ResponseSize
);
return Status;
}
/**
EFI_PLDM_PROTOCOL initialization
@param PldmContext pointer to PLDM_CONTEXT structure
@param Mctp pointer to EFI_MCTP_PROTOCOL structure
@retval SUCCESS command complete successfully
@return other values command failed
**/
EFI_STATUS
EFIAPI
EFIAPI
SetupPldmProtocol (
PLDM_CONTEXT *PldmContext,
EFI_MCTP_PROTOCOL *Mctp
)
{
EFI_STATUS Status;
H2O_CP_HANDLE CpHandle;
PldmContext->Signature = PLDM_SIGNATURE;
PldmContext->Mctp = Mctp;
PldmContext->InstanceId = 0;
PldmContext->MaxPayloadSize = MAX_PLDM_PAYLOAD_SIZE;
PldmContext->Pldm.SetRequestMode = SetPldmRequestMode;
PldmContext->Pldm.SetResponseMode = SetPldmResponseMode;
PldmContext->Pldm.SendMessage = PldmSendMessage;
PldmContext->Pldm.ReceiveMessage = PldmReceiveMessage;
PldmContext->Pldm.GetTid = PldmGetTid;
PldmContext->Pldm.GetVersion = GetPldmVersion;
PldmContext->Pldm.GetSupportedTypes = GetPldmSupportedTypes;
PldmContext->Pldm.GetSupportedCommands = GetPldmSupportedCommands;
PldmContext->Pldm.GetSmbiosStructureTableMetaData = PldmGetSmbiosStructureTableMetaData;
PldmContext->Pldm.SetSmbiosStructureTableMetaData = PldmSetSmbiosStructureTableMetaData;
PldmContext->Pldm.GetSmbiosStructureTable = PldmGetSmbiosStructureTable;
PldmContext->Pldm.SetSmbiosStructureTable = PldmSetSmbiosStructureTable;
PldmContext->Pldm.SetDateTime = PldmBiosSetDateTime;
PldmContext->Pldm.GetBiosTable = PldmGetBiosTable;
PldmContext->Pldm.SetBiosTable = PldmSetBiosTable;
PldmContext->Pldm.GetBiosTableTags = PldmGetBiosTableTags;
PldmContext->Pldm.SetBiosTableTags = PldmSetBiosTableTags;
PldmContext->Pldm.GetBiosAttrCurrentValueByHandle = PldmGetBiosAttrCurrentValueByHandle;
PldmContext->Pldm.GetBiosAttrCurrentValueByType = PldmGetBiosAttrCurrentValueByType;
PldmContext->Pldm.SetBiosAttrCurrentValue = PldmSetBiosAttrCurrentValue;
PldmContext->Pldm.GetBiosAttrPendingValueByHandle = PldmGetBiosAttrPendingValueByHandle;
PldmContext->Pldm.GetBiosAttrPendingValueByType = PldmGetBiosAttrPendingValueByType;
PldmContext->Pldm.AcceptBiosAttrPendingValues = PldmAcceptBiosAttrPendingValues;
PldmContext->Pldm.PlatformEventMessage = PldmPlatformEventMessage;
PldmContext->Pldm.AppendBiosString = AppendBiosString;
PldmContext->Pldm.AppendBiosAttr = AppendBiosAttr;
PldmContext->Pldm.AppendBiosAttrValue = AppendBiosAttrValue;
PldmContext->Pldm.ResetBiosTables = ResetBiosTables;
PldmContext->Pldm.PushBiosTables = PushBiosTables;
PldmContext->Pldm.RegisterSensorReadingFunction = RegisterSensorReadingFunction;
PldmContext->SensorReadingEvent = NULL;
PldmContext->SensorReadingCheckEvent = NULL;
PldmContext->Pldm.SetRequestMode(&PldmContext->Pldm);
PldmContext->Buffer = AllocatePool (PLDM_BUFFER_SIZE);
if (PldmContext->Buffer == NULL) {
return EFI_OUT_OF_RESOURCES;
}
Status = InitBiosTables (PldmContext);
if (EFI_ERROR (Status)) {
FreePool (PldmContext->Buffer);
return Status;
}
if (FeaturePcdGet (PcdH2OBdsCpBootDeviceEnumAfterSupported)) {
Status = H2OCpRegisterHandler (
&gH2OBdsCpBootDeviceEnumAfterGuid,
SyncBootOrderDataFromMC,
H2O_CP_MEDIUM,
&CpHandle
);
if (EFI_ERROR (Status)) {
DEBUG_CP ((DEBUG_ERROR, "Checkpoint Register Fail: %g (%r)\n", &gH2OBdsCpBootDeviceEnumAfterGuid, Status));
return Status;
}
DEBUG_CP ((DEBUG_INFO, "Checkpoint Registered: %g (%r)\n", &gH2OBdsCpBootDeviceEnumAfterGuid, Status));
} else {
DEBUG ((DEBUG_ERROR, "PcdH2OBdsCpBootDeviceEnumAfterSupported is not set to true for boot order sync with MC!\n"));
ASSERT (FALSE);
}
if (FeaturePcdGet (PcdH2OBdsCpReadyToBootAfterSupported)) {
Status = H2OCpRegisterHandler (
&gH2OBdsCpReadyToBootAfterGuid,
PushManagementDataToMC,
H2O_CP_MEDIUM,
&CpHandle
);
if (EFI_ERROR (Status)) {
DEBUG_CP ((DEBUG_ERROR, "Checkpoint Register Fail: %g (%r)\n", &gH2OBdsCpReadyToBootAfterGuid, Status));
return Status;
}
DEBUG_CP ((DEBUG_INFO, "Checkpoint Registered: %g (%r)\n", &gH2OBdsCpReadyToBootAfterGuid, Status));
}
return Status;
}
Reference in New Issue View Git Blame Copy Permalink