xinb
/
alder_lake_bios
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
alder_lake_bios/Intel/AlderLake/AlderLakePlatSamplePkg/Features/Smbios/SmbiosMiscDxe/SmbiosMiscEntryPoint.c

938 lines
33 KiB
C
Raw Permalink Blame History

/** @file
This driver parses the mDefaultSmbiosPlatformInfo structure and reports
any generated data using SMBIOS protocol.
@par Revision Reference:
SMBIOS Specification from DMTF: http://www.dmtf.org/standards/smbios
Intel Framework Specifications, all available at: http://www.intel.com/technology/framework/spec.htm
Unified Extensible Firmware Interface (UEFI) Specifications: http://www.uefi.org/specs/
@copyright
INTEL CONFIDENTIAL
Copyright 2017 - 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 a 'Sample Driver' and is licensed as such under the terms
of your license agreement with Intel or your vendor. This file may be modified
by the user, subject to the additional terms of the license agreement.
@par Specification Reference:
**/
#include "CommonHeader.h"
#include "SmbiosMisc.h"
#include <SmbiosPlatformInfoDefault.h>
#include <Guid/SmBios.h>
#include <Library/PssLib.h>
#include <Library/CpuPlatformLib.h>
#include <Library/PchInfoLib.h>
#include <CpuRegs.h>
#include <MeBiosPayloadHob.h>
#include <Library/HobLib.h>
GLOBAL_REMOVE_IF_UNREFERENCED EFI_HANDLE mImageHandle;
//
// Number of SmBios Platform Info Table entries.
//
GLOBAL_REMOVE_IF_UNREFERENCED UINTN mSmbiosPlatformInfoTableEntries =(sizeof (mDefaultSmbiosPlatformInfo) / sizeof (SMBIOS_PLATFORM_INFO));
/**
Publish the Reference code version info as per Firmware Version Info (FVI) Interface Spec v0.8
using smbios type 14, group association.
@param[in] Event - Event whose notification function is being invoked (Ready To Boot).
@param[in] Context - Pointer to the notification functions context, which is implementation dependent.
**/
VOID
EFIAPI
AddSmbiosT14Callback (
IN EFI_EVENT Event,
IN VOID *Context
)
{
EFI_SMBIOS_PROTOCOL *SmbiosProtocol;
EFI_STATUS Status;
EFI_SMBIOS_HANDLE SmbiosHandle;
EFI_SMBIOS_TABLE_HEADER *Record;
UINT32 FviTypeCount; // number of Fvi records locates.
UINT32 FviTypeCountOld;
UINT32 FviT14Size; // Size of the SMBIOS record to be installed.
GROUP_STRUCT *FviTableOld; // Pointers to discovered Fvi entries.
GROUP_STRUCT *FviTableNew;
SMBIOS_TABLE_TYPE14 *SmbiosTableType14;
UINT8 *GroupName;
UINT8 *EndPtr;
static UINT8 T14FviString[sizeof (T14_FVI_STRING)] = T14_FVI_STRING;
UINT8 FviSmbiosType;
SmbiosProtocol = NULL;
FviTableNew = NULL;
SmbiosTableType14 = NULL;
DEBUG ((DEBUG_INFO, "AddSmbiosT14Callback(): Executing SMBIOS T14 callback.\n"));
//
// Parse the SMBIOS records for
//
Status = gBS->LocateProtocol (
&gEfiSmbiosProtocolGuid,
NULL,
(VOID *) &SmbiosProtocol
);
if (EFI_ERROR(Status)) {
DEBUG ((DEBUG_ERROR, "AddSmbiosT14Callback(): Locate SMBIOS protocol failure!!\n"));
return;
}
FviTypeCount = 0;
SmbiosHandle = SMBIOS_HANDLE_PI_RESERVED;
//
// Get FVI SMBIOS Type
//
FviSmbiosType = PcdGet8(PcdFviSmbiosType);
do {
Status = SmbiosProtocol->GetNext (
SmbiosProtocol,
&SmbiosHandle,
NULL,
&Record,
NULL
);
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_INFO, "AddSmbiosT14Callback(): The SMBIOS record is the last available record.\n"));
break;
}
//
// Only One EFI_SMBIOS_TYPE_GROUP_ASSOCIATIONS with the label T14FviString.
// is allowed in the system.
//
if (Record->Type == EFI_SMBIOS_TYPE_GROUP_ASSOCIATIONS) {
GroupName = ((UINT8 *)Record) + Record->Length;
if(AsciiStrCmp ((CHAR8 *) GroupName, (CHAR8 *) T14FviString) == 0) {
DEBUG ((DEBUG_INFO, "AddSmbiosT14Callback(): The T14 table is already in SMBIOS records.\n"));
FviTypeCount = 0; // mark the set as empty
break;
}
}
//
// Locate the FviSmbiosType records.
//
if (Record->Type == FviSmbiosType) {
FviTypeCountOld = FviTypeCount;
FviTypeCount++;
FviTableOld = FviTableNew;
FviTableNew = AllocateZeroPool (sizeof(GROUP_STRUCT)*FviTypeCount);
if (FviTableNew == NULL) {
DEBUG ((DEBUG_ERROR, "AddSmbiosT14Callback(): Allocate memory for FviTable failed!!\n"));
goto AddSmbiosT14CallbackExit;
}
if (FviTypeCountOld > 0) {
CopyMem (FviTableNew, FviTableOld, (sizeof (GROUP_STRUCT) * FviTypeCountOld));
}
if (FviTableOld != NULL) {
FreePool (FviTableOld);
}
FviTableNew[FviTypeCount - 1].ItemType = Record->Type;
FviTableNew[FviTypeCount - 1].ItemHandle = Record->Handle;
}
} while (Status == EFI_SUCCESS); // End of retrieving Smbios FviSmbiosType records.
DEBUG ((DEBUG_INFO, "AddSmbiosT14Callback(): Located %d FviSmbiosType (%d) records\n", FviTypeCount, FviSmbiosType));
if (FviTypeCount != 0) {
//
// Add the Record to the SMBIOS table.
//
FviT14Size = sizeof (SMBIOS_TABLE_TYPE14) + (UINT32) sizeof (T14_FVI_STRING) + (sizeof (GROUP_STRUCT) * (FviTypeCount - 1)) + 1;
SmbiosTableType14 = AllocateZeroPool (FviT14Size);
if (SmbiosTableType14 == NULL) {
DEBUG ((DEBUG_ERROR, "AddSmbiosT14Callback(): Allocate memory for FviTable failed!!\n"));
goto AddSmbiosT14CallbackExit;
}
SmbiosTableType14->Hdr.Type = EFI_SMBIOS_TYPE_GROUP_ASSOCIATIONS;
SmbiosTableType14->Hdr.Length = (UINT8) (sizeof (SMBIOS_TABLE_TYPE14) + (sizeof (GROUP_STRUCT) * (FviTypeCount - 1)));
SmbiosTableType14->Hdr.Handle = SMBIOS_HANDLE_PI_RESERVED; // Assign an unused handle.
SmbiosTableType14->GroupName = 1;
CopyMem (SmbiosTableType14->Group, FviTableNew, sizeof (GROUP_STRUCT) * FviTypeCount);
CopyMem ((&SmbiosTableType14->Group[FviTypeCount].ItemType), T14FviString, sizeof (T14FviString));
EndPtr = (UINT8 *) (SmbiosTableType14); // Extra zero marks the end of the record.
EndPtr[FviT14Size - 1] = 0;
Status = SmbiosProtocol->Add (
SmbiosProtocol,
NULL,
&SmbiosTableType14->Hdr.Handle,
(EFI_SMBIOS_TABLE_HEADER *) SmbiosTableType14
);
if (!EFI_ERROR(Status)) {
DEBUG ((DEBUG_INFO, "AddSmbiosT14Callback(): The T14 table is installed into SMBIOS records, unload this event.\n"));
gBS->CloseEvent (Event);
}
}
AddSmbiosT14CallbackExit:
if (SmbiosTableType14 != NULL) {
FreePool (SmbiosTableType14);
}
if (FviTableNew != NULL) {
FreePool (FviTableNew);
}
}
/*++
Install a SMBIOS type 24 record - Hardware Security.
The SMBIOS record is constructed with the 'Power-on Password Status value' and 'Front Panel Reset
value' set to 'Not Implemented. The status of the 'Keyboard Password Status value' and 'Administrator
Password Status value' set according to their variable settings.
@param[in] Event - Event whose notification function is being invoked (Ready To Boot).
@param[in] Context - Pointer to the notification functions context, which is implementation dependent.
--*/
VOID
EFIAPI
AddSmbiosT24Callback (
IN EFI_EVENT Event,
IN VOID *Context
)
{
EFI_SMBIOS_PROTOCOL *SmbiosProtocol;
EFI_STATUS Status;
UINT32 T24Size; // Size of the SMBIOS record to be installed.
SMBIOS_TABLE_TYPE24 *SmbiosTableType24;
UINT8 *EndPtr;
EFI_PASSWORD_STATUS PwdData;
UINTN VarSize;
DEBUG ((DEBUG_INFO, "AddSmbiosT24Callback(): Callback to Create Smbios T24 entry.\n"));
Status = gBS->LocateProtocol (
&gEfiSmbiosProtocolGuid,
NULL,
(VOID *) &SmbiosProtocol
);
if (EFI_ERROR(Status)) {
DEBUG ((DEBUG_ERROR, "AddSmbiosT24Callback(): Locate SMBIOS protocol failure!!\n"));
return;
}
T24Size = sizeof (SMBIOS_TABLE_TYPE24) + 2;
SmbiosTableType24 = AllocateZeroPool (T24Size);
if (SmbiosTableType24 == NULL) {
DEBUG ((DEBUG_ERROR, "AddSmbiosT24Callback(): Allocate memory for T24 table failed!!\n"));
return;
}
SmbiosTableType24->Hdr.Type = EFI_SMBIOS_TYPE_HARDWARE_SECURITY;
SmbiosTableType24->Hdr.Length = (UINT8) (sizeof (SMBIOS_TABLE_TYPE24));
SmbiosTableType24->Hdr.Handle = SMBIOS_HANDLE_PI_RESERVED; // Assign an unused handle.
VarSize = sizeof (PwdData);
Status = gRT->GetVariable (
L"PasswordStatus",
&gSystemAccessGuid,
NULL,
&VarSize,
&PwdData
);
if(EFI_ERROR(Status)) {
//
// If no Password Status variable exists, Set feature to not implemented.
//
SmbiosTableType24->HardwareSecuritySettings = (UINT8) ((EfiHardwareSecurityStatusNotImplemented << 6) |
(EfiHardwareSecurityStatusNotImplemented << 4) |
(EfiHardwareSecurityStatusNotImplemented << 2) |
(EfiHardwareSecurityStatusNotImplemented)
);
} else {
SmbiosTableType24->HardwareSecuritySettings = (UINT8) ((EfiHardwareSecurityStatusNotImplemented << 6) |
((PwdData.UserName & 0x3) << 4) |
((PwdData.AdminName & 0x3) << 2) |
EfiHardwareSecurityStatusNotImplemented
);
}
EndPtr = (UINT8 *) (SmbiosTableType24); // Extra zero marks the end of the record.
EndPtr[T24Size - 2] = 0;
EndPtr[T24Size - 1] = 0;
Status = SmbiosProtocol->Add (
SmbiosProtocol,
NULL,
&SmbiosTableType24->Hdr.Handle,
(EFI_SMBIOS_TABLE_HEADER *) SmbiosTableType24
);
if (!EFI_ERROR(Status)) {
DEBUG ((DEBUG_INFO, "AddSmbiosT24Callback(): The T24 table is installed into SMBIOS records, unload this event.\n"));
gBS->CloseEvent (Event);
}
FreePool(SmbiosTableType24);
}
/*++
Update SKU Number field in SMBIOS type 1 (System Information) with Board ID and BOM ID
@param[in] Smbios - Pointer to SMBIOS Protocol instance.
--*/
EFI_STATUS
EFIAPI
UpdateSmbiosT01 (
IN EFI_SMBIOS_PROTOCOL *Smbios
)
{
EFI_STATUS Status = EFI_SUCCESS;
CHAR8 SkuNumberString [SMBIOS_STRING_MAX_LENGTH];
INT64 SkuNumber;
EFI_SMBIOS_HANDLE SmbiosHandle;
EFI_SMBIOS_TABLE_HEADER *Record;
SMBIOS_TABLE_TYPE1 *Type1Record;
UINTN StringNumber;
ME_BIOS_PAYLOAD_HOB *MbpHob;
if (Smbios == NULL) {
return EFI_INVALID_PARAMETER;
}
SkuNumber = 0;
SkuNumber |= 0x00000000000000FF & ((INT64) PcdGet16 (PcdBoardBomId)); // Byte 0: BOM ID
SkuNumber |= 0x000000000000FF00 & ((INT64) PcdGet16 (PcdBoardRev) << 8); // Byte 1: Fab ID
SkuNumber |= 0x00000000FFFF0000 & ((INT64) PcdGet16 (PcdBoardId) << 16); // Byte 2~3: Board ID
SkuNumber |= 0x000000FF00000000 & ((INT64) GetCpuStepping() << 32); // Byte 4: CPU Stepping
SkuNumber |= 0x0000FF0000000000 & ((INT64) PchStepping() << 40) ; // Byte 5: PCH Stepping
if (MmioRead32(TXT_PUBLIC_BASE + 0x200) & BIT31) {
SkuNumber |= 0x0001000000000000; // Byte 6: Production silicon (bit 0 = 1), PreProduction silicon (bit = 0)
}
MbpHob = NULL;
MbpHob = GetFirstGuidHob (&gMeBiosPayloadHobGuid);
if (MbpHob != NULL) {
if (MbpHob->MeBiosPayload.FwPlatType.RuleData.Fields.IntelMeFwImageType == IntelMeCorporateFw) {
SkuNumber |= 0x0100000000000000; // Byte 7: Corporate FW (bit 0 = 1), Consumer FW (Bit 0 = 0)
}
}
AsciiValueToStringS (SkuNumberString,
SMBIOS_STRING_MAX_LENGTH,
PREFIX_ZERO | RADIX_HEX,
(INT64) SkuNumber,
16); // 16 characters for 8 bytes data
SmbiosHandle = SMBIOS_HANDLE_PI_RESERVED;
do {
Status = Smbios->GetNext (Smbios, &SmbiosHandle, NULL, &Record, NULL);
} while ((Status == EFI_SUCCESS) && (Record->Type != EFI_SMBIOS_TYPE_SYSTEM_INFORMATION));
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_ERROR, "UpdateSmbiosT01 (): SMBIOS TYPE 1 record is not found\n"));
} else {
Type1Record = (SMBIOS_TABLE_TYPE1 *) Record;
StringNumber = Type1Record->SKUNumber;
Status = Smbios->UpdateString (Smbios, &SmbiosHandle, &StringNumber, SkuNumberString);
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_ERROR, "UpdateSmbiosT01(): Update SMBIOS TYPE 1 SKU Number String Failed : %r\n", Status));
}
}
return Status;
}
/*++
Updae a SMBIOS type 1 & type 2 record - System Information & Board Information.
The SMBIOS type 1 & 2 serial number fields are updated with PSS serial number.
@param[in] Smbios - Pointer to SMBIOS Protocol instance.
--*/
EFI_STATUS
EFIAPI
UpdateSmbiosT01T02 (
IN EFI_SMBIOS_PROTOCOL *Smbios
)
{
EFI_STATUS Status;
CHAR8 PssSerialNum [SMBIOS_STRING_MAX_LENGTH];
UINT32 PssSerialSize;
EFI_SMBIOS_HANDLE SmbiosHandle;
EFI_SMBIOS_TABLE_HEADER *Record;
SMBIOS_TABLE_TYPE1 *Type1Record;
SMBIOS_TABLE_TYPE2 *Type2Record;
UINTN StringNumber;
BOOLEAN T01Update;
BOOLEAN T02Update;
DEBUG ((DEBUG_INFO, "UpdateSmbiosT01T02(): Callback to Update Smbios T01 T02 entry.\n"));
if (Smbios == NULL) {
return EFI_INVALID_PARAMETER;
}
PssSerialSize = SMBIOS_STRING_MAX_LENGTH > 16 ? 16 : SMBIOS_STRING_MAX_LENGTH; //Board serial number region should be 16 bytes
//
// Read PSS serial number.
//
Status = PssGetSerialNumber ((UINT8 *)PssSerialNum, PssSerialSize);
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_ERROR, "Serial Number Read from PSS Failed : %r\n", Status));
return Status;
}
//
// Find SMBIOS Type 01 & 02 record then update serial number field string.
//
T01Update = FALSE;
T02Update = FALSE;
SmbiosHandle = SMBIOS_HANDLE_PI_RESERVED;
while (!(T01Update && T02Update)) {
Status = Smbios->GetNext (Smbios, &SmbiosHandle, NULL, &Record, NULL);
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_ERROR, "UpdateSmbiosT01T02 (): SMBIOS TYPE 1 or 2 record is not found\n"));
break;
}
if (Record->Type == EFI_SMBIOS_TYPE_SYSTEM_INFORMATION) {
Type1Record = (SMBIOS_TABLE_TYPE1 *) Record;
StringNumber = Type1Record->SerialNumber;
Status = Smbios->UpdateString (Smbios, &SmbiosHandle, &StringNumber, PssSerialNum);
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_ERROR, "UpdateSmbiosT01T02(): Update SMBIOS TYPE 1 Serial Number String Failed : %r\n", Status));
} else {
T01Update = TRUE;
}
} else if (Record->Type == EFI_SMBIOS_TYPE_BASEBOARD_INFORMATION) {
Type2Record = (SMBIOS_TABLE_TYPE2 *) Record;
StringNumber = Type2Record->SerialNumber;
Status = Smbios->UpdateString (Smbios, &SmbiosHandle, &StringNumber, PssSerialNum);
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_ERROR, "UpdateSmbiosT01T02(): Update SMBIOS TYPE 2 Serial Number String Failed : %r\n", Status));
}else {
T02Update = TRUE;
}
}
}
return Status;
}
/**
Standard EFI driver point. This driver parses the mSmbiosMiscDataTable
structure and reports any generated data using SMBIOS protocol.
@param[in] ImageHandle Handle for the image of this driver
@param[in] SystemTable Pointer to the EFI System Table
@retval EFI_SUCCESS The data was successfully stored.
**/
EFI_STATUS
EFIAPI
SmbiosMiscEntryPoint(
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
{
UINTN Index;
EFI_STATUS EfiStatus;
EFI_SMBIOS_PROTOCOL *Smbios;
EFI_EVENT Event;
EFI_EVENT ReadyToBootEvent;
EFI_STATUS Status;
SMBIOS_PLATFORM_INFO *SmbiosPlatformInfo;
VOID *RecordData;
VOID *RecordStrings;
UINTN StringCount;
BOOLEAN NeedToFreePoolMem;
UINTN MaxInstances;
DEBUG((DEBUG_INFO, "SmbiosMiscEntryPoint(): Entry~!\n"));
mImageHandle = ImageHandle;
EfiStatus = gBS->LocateProtocol(&gEfiSmbiosProtocolGuid, NULL, (VOID**)&Smbios);
if (EFI_ERROR(EfiStatus)) {
DEBUG((DEBUG_ERROR, "Could not locate SMBIOS protocol. %r\n", EfiStatus));
return EfiStatus;
}
//
// Get Smbios Platform Information table
//
SmbiosPlatformInfo = (SMBIOS_PLATFORM_INFO*)(UINTN)PcdGet64(PcdSmbiosPlatformInfo);
for (Index = 0; Index < mSmbiosPlatformInfoTableEntries; ++Index) {
if (SmbiosPlatformInfo){
//
// Update function parameters with Updated Platform Info
//
RecordData = (VOID*)((SMBIOS_PLATFORM_INFO*)(SmbiosPlatformInfo + Index)->Info);
RecordStrings = (VOID*)((SMBIOS_PLATFORM_INFO*)(SmbiosPlatformInfo + Index)->Strings);
StringCount = (SmbiosPlatformInfo + Index)->StringCount;
NeedToFreePoolMem = (SmbiosPlatformInfo + Index)->IsPoolAllocated;
MaxInstances = (SmbiosPlatformInfo + Index)->NoOfInstances;
if (RecordData == NULL){
//
// Update function parameters with Default Platform Info
//
RecordData = mDefaultSmbiosPlatformInfo[Index].Info;
RecordStrings = mDefaultSmbiosPlatformInfo[Index].Strings;
StringCount = mDefaultSmbiosPlatformInfo[Index].StringCount;
NeedToFreePoolMem = mDefaultSmbiosPlatformInfo[Index].IsPoolAllocated;
MaxInstances = mDefaultSmbiosPlatformInfo[Index].NoOfInstances;
}
} else {
//
// Update function parameters with Default Platform Info
//
RecordData = mDefaultSmbiosPlatformInfo[Index].Info;
RecordStrings = mDefaultSmbiosPlatformInfo[Index].Strings;
StringCount = mDefaultSmbiosPlatformInfo[Index].StringCount;
NeedToFreePoolMem = mDefaultSmbiosPlatformInfo[Index].IsPoolAllocated;
MaxInstances = mDefaultSmbiosPlatformInfo[Index].NoOfInstances;
}
//
// Invoke the generic function publish the smbios tables using Platform info
//
EfiStatus = MiscCommonSmbiosFunction(
RecordData,
RecordStrings,
StringCount,
NeedToFreePoolMem,
MaxInstances,
Smbios
);
if (EFI_ERROR(EfiStatus)) {
DEBUG((DEBUG_ERROR, "Misc smbios store error. Index=%d, ReturnStatus=%r\n", Index, EfiStatus));
continue; // Workaround to continue instead of return error status because of returning will skip other smbios function
}
}
//
// Parse the SMBIOS table to update Type 01, Type 02 record.
//
EfiStatus = UpdateSmbiosT01 (Smbios); // SKU Number (Board ID + BOM ID) in Type 01
if (EFI_ERROR (EfiStatus)) {
DEBUG((DEBUG_ERROR, "Update SMBIOS Type 1 SKU Number failed : %r\n", EfiStatus));
}
if (PcdGetBool (PcdPssReadSN)) {
EfiStatus = UpdateSmbiosT01T02 (Smbios); // Serial Number (from PSS) in Type 01 & 02
if (EFI_ERROR (EfiStatus)) {
DEBUG((DEBUG_ERROR, "Update SMBIOS Type 1 & Type 2 serial number from PSS failed : %r\n", EfiStatus));
}
}
//
// This callback will parse the SMBIOS table for FVI and create a Type 14 record.
//
DEBUG ((DEBUG_INFO, "SmbiosMiscEntryPoint(): Create Smbios T14 callback.\n"));
EfiStatus = EfiCreateEventReadyToBootEx (
TPL_CALLBACK,
AddSmbiosT14Callback,
NULL,
&Event
);
ASSERT_EFI_ERROR (EfiStatus);
//
// This callback will install a Type 24 record - Hardware Security.
//
DEBUG ((DEBUG_INFO, "SmbiosMiscEntryPoint(): Create Smbios T24 callback.\n"));
EfiStatus = EfiCreateEventReadyToBootEx (
TPL_CALLBACK,
AddSmbiosT24Callback,
NULL,
&Event
);
ASSERT_EFI_ERROR (EfiStatus);
//
// Register, ReadyToBoot callback event, to create SMBIOS Dynamic Table.
//
Status = EfiCreateEventReadyToBootEx(
TPL_NOTIFY,
DynamicTable,
NULL,
&ReadyToBootEvent
);
ASSERT_EFI_ERROR (Status);
return EfiStatus;
}
/**
Create Dynamic SMBIOS Table and store data.
@retval EFI_SUCCESS Structure created sucessfully.
@retval EFI_NOT_READY Some of The SMBIOS records was not available yet.
@retval EFI_OUT_OF_RESOURCES No enough memory.
**/
EFI_STATUS
EFIAPI
CreateDynamicSmbiosTable (
VOID
)
{
UINT8 AddrPointer;
EFI_STATUS Status = EFI_SUCCESS;
EFI_PHYSICAL_ADDRESS PhysicalAddress;
SMBIOS_TABLE_ENTRY_POINT *EntryPointStructure;
DEBUG ((DEBUG_INFO, "CreateDynamicSmbiosTable(): Entry!\n"));
//
// Get SMBIOS table pointers
//
EntryPointStructure = NULL;
Status = EfiGetSystemConfigurationTable (&gEfiSmbiosTableGuid, (VOID **) &EntryPointStructure);
if (EFI_ERROR (Status) || EntryPointStructure == NULL) {
DEBUG ((DEBUG_ERROR, "SMBIOS Entry Point strucuture not found \n"));
return EFI_NOT_FOUND;
}
//
// To allocate 32-bit physical starting address of Dynamic Table. This field is static and BIOS cannot update
// the Dynamic Strucuture Table Address after OS hand-off.
//
PhysicalAddress = 0xffffffff;
Status = gBS->AllocatePages (
AllocateMaxAddress,
EfiReservedMemoryType,
EFI_SIZE_TO_PAGES (EntryPointStructure->TableLength),
&PhysicalAddress
);
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_ERROR, "CreateDynamicSmbiosTable() could not allocate SMBIOS table < 4GB\n"));
return EFI_OUT_OF_RESOURCES;
} else {
//
// During boot time, both Static and Dynamic tables will have the same data. Copy entire SMBIOS Static table data into Dynamic Table address location.
//
CopyMem ((VOID *) (UINTN)PhysicalAddress,(VOID *) (UINTN)EntryPointStructure->TableAddress, sizeof (EntryPointStructure->TableLength));
//
// SMBIOS Entry Point structure, Formatted Area, with offset 0C-0F, would store the 32-bit physical address of the Dynamic Table.
// Copy Dynamic table physical address into Entry Point structure.
//
DEBUG ((DEBUG_INFO, "CreateDynamicSmbiosTable() EntryPointRevision is [%d]\n", EntryPointStructure->EntryPointRevision));
if (EntryPointStructure->EntryPointRevision == 0x00) {
for (AddrPointer = 0; AddrPointer < 5; AddrPointer++) {
EntryPointStructure->FormattedArea[AddrPointer] = 0x00;
}
} else {
//
// In the SMBIOS Spec, the range from 01h to FFh is reserved. The process shouldn't run here.
//
DEBUG ((DEBUG_ERROR, "CreateDynamicSmbiosTable(): EntryPointRevision is 0x%x, only 0x00 is valid.\n", EntryPointStructure->EntryPointRevision));
ASSERT (TRUE);
}
}
return EFI_SUCCESS;
}
/**
Add SMBIOS Table at Dynamically.
@param[in] Event - Event whose notification function is being invoked (Ready To Boot).
@param[in] Context - Pointer to the notification functions context, which is implementation dependent.
**/
VOID
EFIAPI
DynamicTable(
IN EFI_EVENT Event,
IN VOID *Context
)
{
CreateDynamicSmbiosTable();
}
/**
Add an SMBIOS record.
@param[in] Smbios The EFI_SMBIOS_PROTOCOL instance.
@param[out] SmbiosHandle A unique handle will be assigned to the SMBIOS record.
@param[in] Record The data for the fixed portion of the SMBIOS record. The format of the record is
determined by EFI_SMBIOS_TABLE_HEADER.Type. The size of the formatted area is defined
by EFI_SMBIOS_TABLE_HEADER.Length and either followed by a double-null (0x0000) or
a set of null terminated strings and a null.
@retval EFI_SUCCESS Record was added.
@retval EFI_OUT_OF_RESOURCES Record was not added due to lack of system resources.
**/
EFI_STATUS
AddSmbiosRecord (
IN EFI_SMBIOS_PROTOCOL *Smbios,
OUT EFI_SMBIOS_HANDLE *SmbiosHandle,
IN EFI_SMBIOS_TABLE_HEADER *Record
)
{
*SmbiosHandle = SMBIOS_HANDLE_PI_RESERVED;
return Smbios->Add (
Smbios,
NULL,
SmbiosHandle,
Record
);
}
/**
Initialize SMBIOS table strings.
@param[out] **Destination The pointer for the destination.
@param[in] *Source The pointer for the source date.
@param[out] **StrBuffer The pointer for string buffer.
@param[out] *Count The accumulated number of strings.
@param[out] *SizeOfStrings The accumulated number of strings length.
@param[in, out] *StrBuffSize Size of StrBuffer.
@retval EFI_SUCCESS Successful.
@retval EFI_INVALID_PARAMETER Distination pointer is not NULL.
@retval EFI_BUFFER_TOO_SMALL StrBuffSize is zero.
**/
EFI_STATUS
SmbiosStrInit (
OUT CHAR16 **Destination,
IN CHAR16 CONST *Source,
OUT CHAR16 **StrBuffer,
OUT UINTN *Count,
OUT UINTN *SizeOfStrings,
IN OUT UINTN *StrBuffSize
)
{
UINTN StrSize;
if ((*Destination != NULL) || (*StrBuffer == NULL)) {
return EFI_INVALID_PARAMETER;
}
if (StrBuffSize == 0) {
return EFI_BUFFER_TOO_SMALL;
}
DEBUG ((DEBUG_INFO, "(SmbiosStrInit) Entry.\n"));
if (StrLen(Source) > SMBIOS_STRING_MAX_LENGTH) {
StrSize = SMBIOS_STRING_MAX_LENGTH;
} else {
StrSize = StrLen(Source);
}
DEBUG ((DEBUG_INFO, "(SmbiosStrInit) Source string: %S\n", Source));
StrCpyS (*StrBuffer, *StrBuffSize, Source);
*Destination = *StrBuffer;
*StrBuffer += (StrSize + 1);
*StrBuffSize -= (StrSize + 1);
*SizeOfStrings += StrSize;
*Count += 1;
return EFI_SUCCESS;
}
/**
Update SMBIOS strings.
@param[in] **StringArray The strings to be updated.
@param[in] *StarAddr The pointer of start location.
@param[in] NumOfStrings The number of strings.
@param[in] BufferSize The usage size from start location, *StarAddr.
**/
VOID
SmbiosStringsUpdate (
CHAR16 **StringArray,
UINT8 *StartAddr,
UINTN NumOfStrings,
UINTN BufferSize
)
{
UINTN LenStr;
UINTN IdxStr;
LenStr = 0;
IdxStr = 0;
for (IdxStr = 0; IdxStr < NumOfStrings; IdxStr++) {
if (StringArray[IdxStr] == NULL) {
continue;
}
UnicodeStrToAsciiStrS (StringArray[IdxStr], (CHAR8*) (StartAddr + LenStr + IdxStr), BufferSize);
LenStr += StrLen(StringArray[IdxStr]);
BufferSize -= StrLen(StringArray[IdxStr]);
}
}
/**
The Generic Smbios Function to handle all SMBIOS records.
@param RecordData Pointer to copy of RecordData from the Data Table.
@retval EFI_SUCCESS All parameters were valid.
@retval EFI_UNSUPPORTED Unexpected RecordType value.
@retval EFI_INVALID_PARAMETER Invalid parameter was found.
**/
EFI_STATUS EFIAPI MiscCommonSmbiosFunction(
IN VOID *RecordData,
IN VOID *RecordStrings,
IN UINTN StringCount,
IN BOOLEAN NeedToFreePoolMem,
IN UINTN MaxInstances,
IN EFI_SMBIOS_PROTOCOL *Smbios
)
{
EFI_STATUS Status;
EFI_SMBIOS_HANDLE SmbiosHandle;
UINT8 *SmbiosRecord;
UINT8 *RecordInfo;
CHAR16 *StringsData;
UINT8 Instance;
CHAR8 *OptionalStrStart;
CHAR16 *StrBufferStart;
CHAR16 *StrBufferPtr;
UINTN StrBuffSize;
UINTN OptionalStrBufferSize;
UINTN StringNumber;
UINTN StringLength;
UINTN StringIndex;
CHAR16 **StrPtr;
CHAR16 *SmbiosTableStrings[MISC_MAX_SMBIOS_TABLE_STRINGS];
SMBIOS_STRUCTURE *SmbiosHeader;
Status = EFI_UNSUPPORTED;
StringNumber = 0;
StringLength = 0;
StrBufferStart = NULL;
//
// Get Smbios Platform Information table
//
RecordInfo = RecordData;
StringsData = RecordStrings;
//
// First check for invalid parameters.
//
if (RecordInfo == NULL) {
return EFI_INVALID_PARAMETER;
}
if (StringCount > MISC_MAX_SMBIOS_TABLE_STRINGS) {
return EFI_INVALID_PARAMETER;
}
if(StringCount){
StrBufferStart = AllocateZeroPool (StringCount * SMBIOS_STRING_MAX_LENGTH * sizeof(CHAR16));
}
SmbiosHeader = (SMBIOS_STRUCTURE*)RecordInfo;
StrPtr = (CHAR16**)(StringsData);
DEBUG ((DEBUG_INFO, "(MiscCommonSmbiosFunction) Record Type : %d\n",SmbiosHeader->Type));
for (Instance = 0; Instance < MaxInstances; Instance++){
if(RecordInfo == NULL)
continue;
if (RecordStrings != NULL) {
if(StringsData == NULL)
continue;
//
// Initialize SMBIOS Tables strings
//
if(StringCount){
ZeroMem (SmbiosTableStrings, StringCount * sizeof(CHAR16*));
StringNumber = 0;
StringLength = 0;
StrBufferPtr = StrBufferStart;
StrBuffSize = (StringCount * SMBIOS_STRING_MAX_LENGTH * sizeof(CHAR16)) / sizeof (CHAR16);
}
for (StringIndex = 0; StringIndex < StringCount; StringIndex++){
if (*StrPtr) {
SmbiosStrInit (&SmbiosTableStrings[StringIndex], *StrPtr, &StrBufferPtr, &StringNumber, &StringLength, &StrBuffSize);
}
StrPtr = StrPtr + 1;
}
}
//
// Two zeros following the last string.
//
if((StringsData != NULL) && StringCount){
OptionalStrBufferSize = StringLength + StringNumber + 1;
} else {
OptionalStrBufferSize = 1 + 1;
}
//
// Allocate memory size for SMBIOS record
//
SmbiosRecord = AllocatePool(SmbiosHeader->Length + OptionalStrBufferSize);
if (SmbiosRecord == NULL) {
Status = EFI_OUT_OF_RESOURCES;
goto Exit;
}
//
// Initialize SMBIOS Record Instance from Updated Policy Data
//
ZeroMem(SmbiosRecord, SmbiosHeader->Length + OptionalStrBufferSize);
CopyMem(SmbiosRecord, RecordInfo, SmbiosHeader->Length);
//
// Update SMBIOS Tables strings
//
if((StringsData != NULL) && StringCount){
OptionalStrStart = (CHAR8 *)(SmbiosRecord + SmbiosHeader->Length);
SmbiosStringsUpdate ((CHAR16 **) SmbiosTableStrings, (UINT8*) OptionalStrStart, StringNumber, OptionalStrBufferSize);
}
//
// Now we have got the full smbios record, call smbios protocol to add this record.
//
Status = AddSmbiosRecord (Smbios, &SmbiosHandle, (EFI_SMBIOS_TABLE_HEADER *) SmbiosRecord);
FreePool(SmbiosRecord);
//
// Increment the pointers to next Instance
//
RecordInfo = RecordInfo + SmbiosHeader->Length;
StringsData = StringsData + StringCount;
}
Exit:
if(NeedToFreePoolMem){
FreePool(RecordData);
if(StringCount){
FreePool(RecordStrings);
}
}
return Status;
}
Reference in New Issue View Git Blame Copy Permalink