xinb
/
alder_lake_bios
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
alder_lake_bios/Intel/AlderLake/AlderLakePlatSamplePkg/Telemetry/MrcHealthDxe/MrcHealthDataInit.c

385 lines
16 KiB
C
Raw Permalink Blame History

/** @file
This code install AIP protocol to report MRC health data to expose through ACPI PHAT for Telemetry.
@copyright
INTEL CONFIDENTIAL
Copyright 2019 - 2020 Intel Corporation.
The source code contained or described herein and all documents related to the
source code ("Material") are owned by Intel Corporation or its suppliers or
licensors. Title to the Material remains with Intel Corporation or its suppliers
and licensors. The Material may contain trade secrets and proprietary and
confidential information of Intel Corporation and its suppliers and licensors,
and is protected by worldwide copyright and trade secret laws and treaty
provisions. No part of the Material may be used, copied, reproduced, modified,
published, uploaded, posted, transmitted, distributed, or disclosed in any way
without Intel's prior express written permission.
No license under any patent, copyright, trade secret or other intellectual
property right is granted to or conferred upon you by disclosure or delivery
of the Materials, either expressly, by implication, inducement, estoppel or
otherwise. Any license under such intellectual property rights must be
express and approved by Intel in writing.
Unless otherwise agreed by Intel in writing, you may not remove or alter
this notice or any other notice embedded in Materials by Intel or
Intel's suppliers or licensors in any way.
This file contains an 'Intel Peripheral Driver' and is uniquely identified as
"Intel Reference Module" and is licensed for Intel CPUs and chipsets under
the terms of your license agreement with Intel or your vendor. This file may
be modified by the user, subject to additional terms of the license agreement.
@par Specification Reference:
**/
#include <Bdat4.h>
#include <Base.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/DebugLib.h>
#include <Library/UefiLib.h>
#include <Library/IoLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/MemoryAllocationLib.h>
#include <IndustryStandard/Acpi30.h>
#include <Protocol/AcpiTable.h>
#include <PiDxe.h>
#include <IndustryStandard/Pci22.h>
#include <Protocol/AdapterInformation.h>
#include <Telemetry/Include/Protocol/TelemetryAdapterInformation.h>
#include <Protocol/DevicePath.h>
#include <Library/AslUpdateLib.h>
#include <Library/DevicePathLib.h>
#include <Telemetry/Include/TelemetryCommon.h>
#include <MemInfoHob.h>
#include <Library/HobLib.h>
///
/// Ensure proper structure formats
///
#pragma pack(push, 1)
///
/// BIOS Data ACPI structure
///
typedef struct {
EFI_ACPI_DESCRIPTION_HEADER Header;
EFI_ACPI_3_0_GENERIC_ADDRESS_STRUCTURE BdatGas;
} EFI_BDAT_ACPI_DESCRIPTION_TABLE;
#pragma pack(pop)
typedef struct {
EFI_HANDLE Handle;
EFI_ADAPTER_INFORMATION_PROTOCOL AdapterInfo;
EFI_DEVICE_PATH_PROTOCOL *MrcDevicePath;
} MRC_HEALTH_DEV;
typedef struct {
EFI_AIP_HEALTH_HEADER Header;
UINT8 Revision;
BDAT_STRUCTURE BDAT;
} EFI_ADAPTER_INFO_MRC_HEALTH_STATE;
#define EFI_BDAT_TABLE_SIGNATURE SIGNATURE_32 ('B', 'D', 'A', 'T')
///
/// structure Revision (as defined in Telemetry Gen 2.0 spec.)
///
#define MRC_AIP_HEADER_REVISION 0x01
#define MRC_AIP_DATA_REVISION 0x01
/**
This function gets the MRC health data.
@param[in] This A pointer to the EFI_ADAPTER_INFORMATION_PROTOCOL instance.
@param[in] InformationType A pointer to gAdapterInfoMrcGuid that defines the contents of InformationBlock.
The caller must use the InformationType to specify the infromation it needs to retrieve
from this service and to determine how to parse the InformationBlock.
The driver should not attempt to free InformationType.
@param[out] InformationBlock A pointer to the number of GUIDs present in InfoTypesBuffer.
@param[out] InformationBlockSize The driver return the size of the InformationBlock.
@retval EFI_INVALID_PARAMETER
@retval EFI_OUT_OF_RESOURCES
@retval EFI_UNSUPPORTED
@retval EFI_SUCCESS
**/
EFI_STATUS
EFIAPI
MrcHealthDataAipGetInfo (
IN EFI_ADAPTER_INFORMATION_PROTOCOL *This,
IN EFI_GUID *InformationType,
OUT VOID **InformationBlock,
OUT UINTN *InformationBlockSize
)
{
EFI_STATUS Status;
EFI_ACPI_TABLE_PROTOCOL *AcpiTable;
UINTN Handle;
UINTN BlockSize;
EFI_ADAPTER_INFO_MRC_HEALTH_STATE *HealthDataBlockPtr;
EFI_ACPI_DESCRIPTION_HEADER *Table;
VOID *BdatBuffer;
EFI_BDAT_ACPI_DESCRIPTION_TABLE *BdatAcpiTable;
UINTN Index;
UINT8 IsHealthy;
MEMORY_PLATFORM_DATA_HOB *MemPlatformDataHob;
BOOLEAN IsBdatFound;
if ((This == NULL) || (InformationBlock == NULL) || (InformationBlockSize == NULL)) {
return EFI_INVALID_PARAMETER;
}
if (!CompareGuid (InformationType, &gAdapterInfoMrcGuid)) {
return EFI_UNSUPPORTED;
}
*InformationBlockSize = 0;
*InformationBlock = NULL;
IsHealthy = TelemetryUnknown;
IsBdatFound = FALSE;
BlockSize = sizeof (EFI_ADAPTER_INFO_MRC_HEALTH_STATE);
HealthDataBlockPtr = (EFI_ADAPTER_INFO_MRC_HEALTH_STATE *) AllocateZeroPool (BlockSize);
if (HealthDataBlockPtr == NULL) {
DEBUG ((DEBUG_ERROR, "MrcHealthDataAipGetInfo : Out of resource to allocate for EFI_ADAPTER_INFO_MRC_HEALTH_STATE.\n"));
return EFI_OUT_OF_RESOURCES;
}
//
// Getting health Information ...
//
//
// #1. Try to locate ACPI BDAT which is supposed to be installed after MRC.
// If BDAT is found, report it.
AcpiTable = NULL;
Status = gBS->LocateProtocol (&gEfiAcpiTableProtocolGuid, NULL, (VOID **) &AcpiTable);
if (EFI_ERROR (Status) || (AcpiTable == NULL)) {
DEBUG ((DEBUG_ERROR, "MrcHealthDataAipGetInfo : locate gEfiAcpiTableProtocolGuid failure \n"));
}
Table = NULL;
Handle = 0;
Status = LocateAcpiTableBySignature (
EFI_BDAT_TABLE_SIGNATURE,
&Table,
&Handle
);
if (EFI_ERROR (Status) || (Table == NULL)) {
DEBUG ((DEBUG_ERROR, "MrcHealthDataAipGetInfo : BDAT is not found \n"));
} else {
IsBdatFound = TRUE;
BdatAcpiTable = (EFI_BDAT_ACPI_DESCRIPTION_TABLE *) Table;
BdatBuffer = (VOID *) BdatAcpiTable->BdatGas.Address;
DEBUG ((DEBUG_INFO, "MrcHealthDataAipGetInfo : BDAT found @ Address %x \n", BdatBuffer));
CopyMem (&(HealthDataBlockPtr->BDAT), BdatBuffer, sizeof (BDAT_STRUCTURE));
}
//
// Storing MRC Health Data ...
//
HealthDataBlockPtr->Revision = MRC_AIP_DATA_REVISION;
MemPlatformDataHob = GetFirstGuidHob (&gSiMemoryPlatformDataGuid);
ASSERT (MemPlatformDataHob != NULL);
if (MemPlatformDataHob != NULL) {
if (MemPlatformDataHob->Data.MrcBasicMemoryTestPass == FALSE) {
IsHealthy = TelemetryAdvisory;
} else {
IsHealthy = TelemetryHealthy;
}
}
//
// Create the data header
//
HealthDataBlockPtr->Header.Length = sizeof (EFI_ADAPTER_INFO_MRC_HEALTH_STATE);
HealthDataBlockPtr->Header.Revision = MRC_AIP_HEADER_REVISION;
HealthDataBlockPtr->Header.Healthy = IsHealthy;
CopyGuid (&HealthDataBlockPtr->Header.Signature, &gAdapterInfoMrcGuid);
//
// Print MRC health data block
//
DEBUG ((DEBUG_INFO, "=== EFI_ADAPTER_INFO_MRC_HEALTH_STATE ==\n"));
DEBUG ((DEBUG_INFO, " EFI_AIP_HEALTH_HEADER \n"));
DEBUG ((DEBUG_INFO, " Length = 0x%04x \n", HealthDataBlockPtr->Header.Length));
DEBUG ((DEBUG_INFO, " Revision = 0x%02x \n", HealthDataBlockPtr->Header.Revision));
DEBUG ((DEBUG_INFO, " Healthy = 0x%02x \n", HealthDataBlockPtr->Header.Healthy));
DEBUG ((DEBUG_INFO, " Signature = %g \n", HealthDataBlockPtr->Header.Signature));
DEBUG ((DEBUG_INFO, " Revision = 0x%02x \n", HealthDataBlockPtr->Revision));
if (IsBdatFound) {
DEBUG ((DEBUG_INFO, " BDAT = 0x%lx \n", HealthDataBlockPtr->BDAT));
DEBUG ((DEBUG_INFO, "==================================\n"));
DEBUG ((DEBUG_INFO, " BDAT_STRUCTURE data\n"));
DEBUG ((DEBUG_INFO, " BDAT_HEADER_STRUCTURE \n"));
DEBUG ((DEBUG_INFO, " BiosDataSignature = "));
for (Index = 0; Index < sizeof (HealthDataBlockPtr->BDAT.Header.BiosDataSignature); Index++) {
DEBUG ((DEBUG_INFO, " 0x%02x", HealthDataBlockPtr->BDAT.Header.BiosDataSignature[Index]));
}
DEBUG ((DEBUG_INFO, "\n"));
DEBUG ((DEBUG_INFO, " BiosDataStructureSize = 0x%08x\n", HealthDataBlockPtr->BDAT.Header.BiosDataStructSize));
DEBUG ((DEBUG_INFO, " Crc16 = 0x%04x\n", HealthDataBlockPtr->BDAT.Header.Crc16));
DEBUG ((DEBUG_INFO, " Reserved = 0x%04x\n", HealthDataBlockPtr->BDAT.Header.Reserved));
DEBUG ((DEBUG_INFO, " Version.Rev.Primary = 0x%04x\n", HealthDataBlockPtr->BDAT.Header.Version.Rev.Primary));
DEBUG ((DEBUG_INFO, " Version.Rev.Secondary = 0x%04x\n", HealthDataBlockPtr->BDAT.Header.Version.Rev.Secondary));
DEBUG ((DEBUG_INFO, " Version.Data32 = 0x%08x\n", HealthDataBlockPtr->BDAT.Header.Version.Data32));
DEBUG ((DEBUG_INFO, " OemOffset = 0x%08x\n", HealthDataBlockPtr->BDAT.Header.OemOffset));
DEBUG ((DEBUG_INFO, " Reserved1 = 0x%08x\n", HealthDataBlockPtr->BDAT.Header.Reserved1));
DEBUG ((DEBUG_INFO, " Reserved2 = 0x%08x\n", HealthDataBlockPtr->BDAT.Header.Reserved2));
DEBUG ((DEBUG_INFO, " BDAT_SCHEMA_LIST_STRUCTURE \n"));
DEBUG ((DEBUG_INFO, " SchemaListLength = 0x%04x\n", HealthDataBlockPtr->BDAT.Schemas.SchemaListLength));
DEBUG ((DEBUG_INFO, " Reserved1 = 0x%04x\n", HealthDataBlockPtr->BDAT.Schemas.Reserved1));
DEBUG ((DEBUG_INFO, " Time.Year = 0x%04x\n", HealthDataBlockPtr->BDAT.Schemas.Time.Year));
DEBUG ((DEBUG_INFO, " Time.Month = 0x%02x\n", HealthDataBlockPtr->BDAT.Schemas.Time.Month));
DEBUG ((DEBUG_INFO, " Time.Day = 0x%02x\n", HealthDataBlockPtr->BDAT.Schemas.Time.Day));
DEBUG ((DEBUG_INFO, " Time.Hour = 0x%02x\n", HealthDataBlockPtr->BDAT.Schemas.Time.Hour));
DEBUG ((DEBUG_INFO, " Time.Minute = 0x%02x\n", HealthDataBlockPtr->BDAT.Schemas.Time.Minute));
DEBUG ((DEBUG_INFO, " Time.Second = 0x%02x\n", HealthDataBlockPtr->BDAT.Schemas.Time.Second));
DEBUG ((DEBUG_INFO, " Time.Reserved2 = 0x%02x\n", HealthDataBlockPtr->BDAT.Schemas.Time.Reserved2));
}
*InformationBlock = HealthDataBlockPtr;
*InformationBlockSize = sizeof (EFI_ADAPTER_INFO_MRC_HEALTH_STATE);
return EFI_SUCCESS;
}
/**
This function gets a list of Information types for this instance of the protocol.
@param[in] *This A pointer to the EFI_ADAPTER_INFORMATION_PROTOCOL instance.
@param[out] **InfoTypesBuffer A pointer to the array of InformationType GUID is supported by This.
This buffer is allocated by this service, and it is the responsibility
of the caller to free it after using it.
@param[out] *InfoTypesBufferCount A pointer to the number of GUIDs present in InfoTypesBuffer.
@retval EFI_INVALID_PARAMETER
@retval EFI_OUT_OF_RESOURCES
@retval EFI_SUCCESS
**/
EFI_STATUS
EFIAPI
MrcHealthDataGetSupportedTypes (
IN EFI_ADAPTER_INFORMATION_PROTOCOL *This,
OUT EFI_GUID **InfoTypesBuffer,
OUT UINTN *InfoTypesBufferCount
)
{
if ((This == NULL) || (InfoTypesBuffer == NULL) || (InfoTypesBufferCount == NULL)) {
return EFI_INVALID_PARAMETER;
}
*InfoTypesBuffer = AllocateCopyPool (sizeof (gAdapterInfoMrcGuid), &gAdapterInfoMrcGuid);
if (*InfoTypesBuffer == NULL) {
return EFI_OUT_OF_RESOURCES;
}
*InfoTypesBufferCount = 1;
return EFI_SUCCESS;
}
/**
This function sets the MRC health data.
@param[in] *This A pointer to the EFI_ADAPTER_INFORMATION_PROTOCOL instance.
@param[in] EFI_GUID *InformationType A pointer to gAdapterInfoMrcGuid that defines the contents of InformationBlock.
The caller must use the InformationType to specify the infromation it needs to retrieve
from this service and to determine how to parse the InformationBlock.
The driver should not attempt to free InformationType.
@param[in] VOID **InformationBlock A poointer to the number of GUIDs present in InfoTypesBuffer.
@retval EFI_WRITE_PROTECTED
**/
EFI_STATUS
EFIAPI
MrcHealthDataAipSetInfo (
IN EFI_ADAPTER_INFORMATION_PROTOCOL *This,
IN EFI_GUID *InformationType,
IN VOID *InformationBlock,
IN UINTN InformationBlockSize
)
{
if ((This == NULL) || (InformationBlock == NULL)) {
return EFI_INVALID_PARAMETER;
}
if (!CompareGuid (InformationType, &gAdapterInfoMrcGuid)) {
return EFI_UNSUPPORTED;
}
return EFI_WRITE_PROTECTED;;
}
/**
This function installs EFI_ADAPTER_INFORMATION_PROTOCOL for MRC Health Data.
The data is consumed by Telemetry data collector.
@retval EFI_SUCCESS The MRC Health data is successfully published in AIP protocol.
@retval EFI_OUT_OF_RESOURCES Out of resources to allocate EFI_ADAPTER_INFORMATION_PROTOCOL.
**/
EFI_STATUS
EFIAPI
InitializeMrcHealthData (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
{
EFI_STATUS Status;
MRC_HEALTH_DEV *MrcHealthPrivate;
VENDOR_DEVICE_PATH VendorDeviceNode;
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
Status = EFI_SUCCESS;
DevicePath = NULL;
DEBUG ((DEBUG_INFO, "InitializeMrcHealthData Begins\n"));
MrcHealthPrivate = (MRC_HEALTH_DEV *) AllocateZeroPool (sizeof (MRC_HEALTH_DEV));
if (MrcHealthPrivate == NULL) {
DEBUG ((EFI_D_ERROR, "EFI_OUT_OF_RESOURCES to Allocate MRC_HEALTH_DEV.\n"));
return EFI_OUT_OF_RESOURCES;
}
MrcHealthPrivate->Handle = NULL;
MrcHealthPrivate->AdapterInfo.GetInformation = MrcHealthDataAipGetInfo;
MrcHealthPrivate->AdapterInfo.SetInformation = MrcHealthDataAipSetInfo;
MrcHealthPrivate->AdapterInfo.GetSupportedTypes = MrcHealthDataGetSupportedTypes;
ZeroMem (&VendorDeviceNode, sizeof (VENDOR_DEVICE_PATH));
VendorDeviceNode.Header.Type = HARDWARE_DEVICE_PATH;
VendorDeviceNode.Header.SubType = HW_VENDOR_DP;
CopyGuid (&VendorDeviceNode.Guid, &gAdapterInfoMrcGuid);
SetDevicePathNodeLength (&VendorDeviceNode.Header, sizeof (VENDOR_DEVICE_PATH));
DevicePath = AppendDevicePathNode (NULL, (EFI_DEVICE_PATH_PROTOCOL*)&VendorDeviceNode);
if (DevicePath == NULL) {
Status = EFI_OUT_OF_RESOURCES;
goto ERROR;
}
MrcHealthPrivate->MrcDevicePath = DevicePath;
Status = gBS->InstallMultipleProtocolInterfaces (
&MrcHealthPrivate->Handle,
&gEfiAdapterInformationProtocolGuid,
&MrcHealthPrivate->AdapterInfo,
&gEfiDevicePathProtocolGuid,
MrcHealthPrivate->MrcDevicePath,
NULL
);
if (EFI_ERROR (Status)) {
DEBUG ((EFI_D_ERROR, "InitializeMrcHealthData: faild to install AIP protocol, %r.\n", Status));
goto ERROR;
}
DEBUG ((DEBUG_ERROR, "InitializeMrcHealthData Ends\n"));
return Status;
ERROR:
//
// On error, clean the Aip service context data, and free the memory allocated.
//
FreePool (MrcHealthPrivate);
if (DevicePath != NULL) {
FreePool (DevicePath);
}
return Status;
}
Reference in New Issue View Git Blame Copy Permalink