mirror of https://github.com/acidanthera/audk.git
701 lines
28 KiB
C
701 lines
28 KiB
C
/** @file
|
|
Copyright (c) 2021, Intel Corporation. All rights reserved.<BR>
|
|
SPDX-License-Identifier: BSD-2-Clause-Patent
|
|
**/
|
|
|
|
#include "UefiPayloadEntry.h"
|
|
#include <UniversalPayload/AcpiTable.h>
|
|
#include <UniversalPayload/SerialPortInfo.h>
|
|
#include <UniversalPayload/PciRootBridges.h>
|
|
#include <UniversalPayload/ExtraData.h>
|
|
#include <Guid/MemoryTypeInformation.h>
|
|
#include <Guid/AcpiBoardInfoGuid.h>
|
|
#include <Guid/BootManagerMenu.h>
|
|
|
|
#define ROW_LIMITER 16
|
|
|
|
typedef
|
|
EFI_STATUS
|
|
(*HOB_PRINT_HANDLER) (
|
|
IN VOID *Hob,
|
|
IN UINT16 HobLength
|
|
);
|
|
|
|
typedef struct {
|
|
UINT16 Type;
|
|
CHAR8 *Name;
|
|
HOB_PRINT_HANDLER PrintHandler;
|
|
} HOB_PRINT_HANDLER_TABLE;
|
|
|
|
CHAR8 *mMemoryTypeStr[] = {
|
|
"EfiReservedMemoryType",
|
|
"EfiLoaderCode",
|
|
"EfiLoaderData",
|
|
"EfiBootServicesCode",
|
|
"EfiBootServicesData",
|
|
"EfiRuntimeServicesCode",
|
|
"EfiRuntimeServicesData",
|
|
"EfiConventionalMemory",
|
|
"EfiUnusableMemory",
|
|
"EfiACPIReclaimMemory",
|
|
"EfiACPIMemoryNVS",
|
|
"EfiMemoryMappedIO",
|
|
"EfiMemoryMappedIOPortSpace",
|
|
"EfiPalCode",
|
|
"EfiPersistentMemory",
|
|
"EfiMaxMemoryType"
|
|
};
|
|
|
|
CHAR8 *mResource_Type_List[] = {
|
|
"EFI_RESOURCE_SYSTEM_MEMORY ", // 0x00000000
|
|
"EFI_RESOURCE_MEMORY_MAPPED_IO ", // 0x00000001
|
|
"EFI_RESOURCE_IO ", // 0x00000002
|
|
"EFI_RESOURCE_FIRMWARE_DEVICE ", // 0x00000003
|
|
"EFI_RESOURCE_MEMORY_MAPPED_IO_PORT ", // 0x00000004
|
|
"EFI_RESOURCE_MEMORY_RESERVED ", // 0x00000005
|
|
"EFI_RESOURCE_IO_RESERVED ", // 0x00000006
|
|
"EFI_RESOURCE_MAX_MEMORY_TYPE " // 0x00000007
|
|
};
|
|
|
|
typedef
|
|
EFI_STATUS
|
|
(*GUID_HOB_PRINT) (
|
|
IN UINT8 *HobRaw,
|
|
IN UINT16 HobLength
|
|
);
|
|
|
|
typedef struct {
|
|
EFI_GUID *Guid;
|
|
GUID_HOB_PRINT PrintHandler;
|
|
CHAR8 *GuidName;
|
|
} GUID_HOB_PRINT_HANDLE;
|
|
|
|
typedef struct {
|
|
EFI_GUID *Guid;
|
|
CHAR8 *Type;
|
|
} PRINT_MEMORY_ALLOCCATION_HOB;
|
|
|
|
/**
|
|
Print the Hex value of a given range.
|
|
@param[in] DataStart A pointer to the start of data to be printed.
|
|
@param[in] DataSize The length of the data to be printed.
|
|
@retval EFI_SUCCESS If it completed successfully.
|
|
**/
|
|
EFI_STATUS
|
|
PrintHex (
|
|
IN UINT8 *DataStart,
|
|
IN UINT16 DataSize
|
|
)
|
|
{
|
|
UINTN Index1;
|
|
UINTN Index2;
|
|
UINT8 *StartAddr;
|
|
|
|
StartAddr = DataStart;
|
|
for (Index1 = 0; Index1 * ROW_LIMITER < DataSize; Index1++) {
|
|
DEBUG ((DEBUG_VERBOSE, " 0x%04p:", (DataStart - StartAddr)));
|
|
for (Index2 = 0; (Index2 < ROW_LIMITER) && (Index1 * ROW_LIMITER + Index2 < DataSize); Index2++) {
|
|
DEBUG ((DEBUG_VERBOSE, " %02x", *DataStart));
|
|
DataStart++;
|
|
}
|
|
|
|
DEBUG ((DEBUG_VERBOSE, "\n"));
|
|
}
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
Print the information in HandOffHob.
|
|
|
|
@param[in] HobStart A pointer to the HOB of type EFI_HOB_TYPE_HANDOFF.
|
|
@param[in] HobLength The length in bytes of HOB of type EFI_HOB_TYPE_HANDOFF.
|
|
@retval EFI_SUCCESS If it completed successfully.
|
|
**/
|
|
EFI_STATUS
|
|
PrintHandOffHob (
|
|
IN VOID *HobStart,
|
|
IN UINT16 HobLength
|
|
)
|
|
{
|
|
EFI_PEI_HOB_POINTERS Hob;
|
|
|
|
Hob.Raw = (UINT8 *)HobStart;
|
|
ASSERT (HobLength >= sizeof (*Hob.HandoffInformationTable));
|
|
DEBUG ((DEBUG_INFO, " BootMode = 0x%x\n", Hob.HandoffInformationTable->BootMode));
|
|
DEBUG ((DEBUG_INFO, " EfiMemoryTop = 0x%lx\n", Hob.HandoffInformationTable->EfiMemoryTop));
|
|
DEBUG ((DEBUG_INFO, " EfiMemoryBottom = 0x%lx\n", Hob.HandoffInformationTable->EfiMemoryBottom));
|
|
DEBUG ((DEBUG_INFO, " EfiFreeMemoryTop = 0x%lx\n", Hob.HandoffInformationTable->EfiFreeMemoryTop));
|
|
DEBUG ((DEBUG_INFO, " EfiFreeMemoryBottom = 0x%lx\n", Hob.HandoffInformationTable->EfiFreeMemoryBottom));
|
|
DEBUG ((DEBUG_INFO, " EfiEndOfHobList = 0x%lx\n", Hob.HandoffInformationTable->EfiEndOfHobList));
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
Print the information in Memory Allocation Hob.
|
|
@param[in] HobStart A pointer to the HOB of type EFI_HOB_TYPE_MEMORY_ALLOCATION.
|
|
@param[in] HobLength The length in bytes of HOB of type EFI_HOB_TYPE_MEMORY_ALLOCATION.
|
|
@retval EFI_SUCCESS If it completed successfully.
|
|
**/
|
|
EFI_STATUS
|
|
PrintMemoryAllocationHob (
|
|
IN VOID *HobStart,
|
|
IN UINT16 HobLength
|
|
)
|
|
{
|
|
EFI_PEI_HOB_POINTERS Hob;
|
|
|
|
Hob.Raw = (UINT8 *)HobStart;
|
|
|
|
if (CompareGuid (&Hob.MemoryAllocation->AllocDescriptor.Name, &gEfiHobMemoryAllocStackGuid)) {
|
|
ASSERT (HobLength >= sizeof (*Hob.MemoryAllocationStack));
|
|
DEBUG ((DEBUG_INFO, " Type = EFI_HOB_MEMORY_ALLOCATION_STACK\n"));
|
|
} else if (CompareGuid (&Hob.MemoryAllocation->AllocDescriptor.Name, &gEfiHobMemoryAllocBspStoreGuid)) {
|
|
ASSERT (HobLength >= sizeof (*Hob.MemoryAllocationBspStore));
|
|
DEBUG ((DEBUG_INFO, " Type = EFI_HOB_MEMORY_ALLOCATION_BSP_STORE\n"));
|
|
} else if (CompareGuid (&Hob.MemoryAllocation->AllocDescriptor.Name, &gEfiHobMemoryAllocModuleGuid)) {
|
|
ASSERT (HobLength >= sizeof (*Hob.MemoryAllocationModule));
|
|
DEBUG ((DEBUG_INFO, " Type = EFI_HOB_MEMORY_ALLOCATION_MODULE\n"));
|
|
DEBUG ((DEBUG_INFO, " Module Name = %g\n", Hob.MemoryAllocationModule->ModuleName));
|
|
DEBUG ((DEBUG_INFO, " Physical Address = 0x%lx\n", Hob.MemoryAllocationModule->EntryPoint));
|
|
} else {
|
|
ASSERT (HobLength >= sizeof (*Hob.MemoryAllocation));
|
|
DEBUG ((DEBUG_INFO, " Type = EFI_HOB_TYPE_MEMORY_ALLOCATION\n"));
|
|
}
|
|
|
|
DEBUG ((DEBUG_INFO, " MemoryBaseAddress = 0x%lx\n", Hob.MemoryAllocationStack->AllocDescriptor.MemoryBaseAddress));
|
|
DEBUG ((DEBUG_INFO, " MemoryLength = 0x%lx\n", Hob.MemoryAllocationStack->AllocDescriptor.MemoryLength));
|
|
DEBUG ((DEBUG_INFO, " MemoryType = %a \n", mMemoryTypeStr[Hob.MemoryAllocationStack->AllocDescriptor.MemoryType]));
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
Print the information in Resource Discriptor Hob.
|
|
@param[in] HobStart A pointer to HOB of type EFI_HOB_TYPE_RESOURCE_DESCRIPTOR.
|
|
@param[in] HobLength The Length in bytes of HOB of type EFI_HOB_TYPE_RESOURCE_DESCRIPTOR.
|
|
@retval EFI_SUCCESS If it completed successfully.
|
|
**/
|
|
EFI_STATUS
|
|
PrintResourceDiscriptorHob (
|
|
IN VOID *HobStart,
|
|
IN UINT16 HobLength
|
|
)
|
|
{
|
|
EFI_PEI_HOB_POINTERS Hob;
|
|
|
|
Hob.Raw = (UINT8 *)HobStart;
|
|
ASSERT (HobLength >= sizeof (*Hob.ResourceDescriptor));
|
|
|
|
DEBUG ((DEBUG_INFO, " ResourceType = %a\n", mResource_Type_List[Hob.ResourceDescriptor->ResourceType]));
|
|
if (!IsZeroGuid (&Hob.ResourceDescriptor->Owner)) {
|
|
DEBUG ((DEBUG_INFO, " Owner = %g\n", Hob.ResourceDescriptor->Owner));
|
|
}
|
|
|
|
DEBUG ((DEBUG_INFO, " ResourceAttribute = 0x%x\n", Hob.ResourceDescriptor->ResourceAttribute));
|
|
DEBUG ((DEBUG_INFO, " PhysicalStart = 0x%lx\n", Hob.ResourceDescriptor->PhysicalStart));
|
|
DEBUG ((DEBUG_INFO, " ResourceLength = 0x%lx\n", Hob.ResourceDescriptor->ResourceLength));
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
Print the information in Acpi Guid Hob.
|
|
|
|
@param[in] HobRaw A pointer to the start of gUniversalPayloadAcpiTableGuid HOB.
|
|
@param[in] HobLength The size of the HOB data buffer.
|
|
|
|
@retval EFI_SUCCESS If it completed successfully.
|
|
**/
|
|
EFI_STATUS
|
|
PrintAcpiGuidHob (
|
|
IN UINT8 *HobRaw,
|
|
IN UINT16 HobLength
|
|
)
|
|
{
|
|
UNIVERSAL_PAYLOAD_ACPI_TABLE *AcpiTableHob;
|
|
|
|
AcpiTableHob = (UNIVERSAL_PAYLOAD_ACPI_TABLE *)GET_GUID_HOB_DATA (HobRaw);
|
|
ASSERT (HobLength >= AcpiTableHob->Header.Length);
|
|
DEBUG ((DEBUG_INFO, " Revision = 0x%x\n", AcpiTableHob->Header.Revision));
|
|
DEBUG ((DEBUG_INFO, " Length = 0x%x\n", AcpiTableHob->Header.Length));
|
|
DEBUG ((DEBUG_INFO, " Rsdp = 0x%p\n", (UINT64)AcpiTableHob->Rsdp));
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
Print the information in Serial Guid Hob.
|
|
@param[in] HobRaw A pointer to the start of gUniversalPayloadSerialPortInfoGuid HOB.
|
|
@param[in] HobLength The size of the HOB data buffer.
|
|
|
|
@retval EFI_SUCCESS If it completed successfully.
|
|
**/
|
|
EFI_STATUS
|
|
PrintSerialGuidHob (
|
|
IN UINT8 *HobRaw,
|
|
IN UINT16 HobLength
|
|
)
|
|
{
|
|
UNIVERSAL_PAYLOAD_SERIAL_PORT_INFO *SerialPortInfo;
|
|
|
|
SerialPortInfo = (UNIVERSAL_PAYLOAD_SERIAL_PORT_INFO *)GET_GUID_HOB_DATA (HobRaw);
|
|
ASSERT (HobLength >= SerialPortInfo->Header.Length);
|
|
DEBUG ((DEBUG_INFO, " Revision = 0x%x\n", SerialPortInfo->Header.Revision));
|
|
DEBUG ((DEBUG_INFO, " Length = 0x%x\n", SerialPortInfo->Header.Length));
|
|
DEBUG ((DEBUG_INFO, " UseMmio = 0x%x\n", SerialPortInfo->UseMmio));
|
|
DEBUG ((DEBUG_INFO, " RegisterStride = 0x%x\n", SerialPortInfo->RegisterStride));
|
|
DEBUG ((DEBUG_INFO, " BaudRate = %d\n", SerialPortInfo->BaudRate));
|
|
DEBUG ((DEBUG_INFO, " RegisterBase = 0x%lx\n", SerialPortInfo->RegisterBase));
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
Print the information in Smbios Guid Hob.
|
|
@param[in] HobRaw A pointer to the start of gUniversalPayloadSmbios3TableGuid HOB.
|
|
@param[in] HobLength The size of the HOB data buffer.
|
|
@retval EFI_SUCCESS If it completed successfully.
|
|
**/
|
|
EFI_STATUS
|
|
PrintSmbios3GuidHob (
|
|
IN UINT8 *HobRaw,
|
|
IN UINT16 HobLength
|
|
)
|
|
{
|
|
UNIVERSAL_PAYLOAD_SMBIOS_TABLE *SmBiosTable;
|
|
|
|
SmBiosTable = (UNIVERSAL_PAYLOAD_SMBIOS_TABLE *)GET_GUID_HOB_DATA (HobRaw);
|
|
ASSERT (HobLength >= SmBiosTable->Header.Length);
|
|
DEBUG ((DEBUG_INFO, " Revision = 0x%x\n", SmBiosTable->Header.Revision));
|
|
DEBUG ((DEBUG_INFO, " Length = 0x%x\n", SmBiosTable->Header.Length));
|
|
DEBUG ((DEBUG_INFO, " SmBiosEntryPoint = 0x%lx\n", (UINT64)SmBiosTable->SmBiosEntryPoint));
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
Print the information in Smbios Guid Hob.
|
|
@param[in] HobRaw A pointer to the start of gUniversalPayloadSmbiosTableGuid HOB.
|
|
@param[in] HobLength The size of the HOB data buffer.
|
|
|
|
@retval EFI_SUCCESS If it completed successfully.
|
|
**/
|
|
EFI_STATUS
|
|
PrintSmbiosTablGuidHob (
|
|
IN UINT8 *HobRaw,
|
|
IN UINT16 HobLength
|
|
)
|
|
{
|
|
UNIVERSAL_PAYLOAD_SMBIOS_TABLE *SmBiosTable;
|
|
|
|
SmBiosTable = (UNIVERSAL_PAYLOAD_SMBIOS_TABLE *)GET_GUID_HOB_DATA (HobRaw);
|
|
ASSERT (HobLength >= SmBiosTable->Header.Length);
|
|
DEBUG ((DEBUG_INFO, " Revision = 0x%x\n", SmBiosTable->Header.Revision));
|
|
DEBUG ((DEBUG_INFO, " Length = 0x%x\n", SmBiosTable->Header.Length));
|
|
DEBUG ((DEBUG_INFO, " SmBiosEntryPoint = 0x%lx\n", (UINT64)SmBiosTable->SmBiosEntryPoint));
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
Print the information in Acpi BoardInfo Guid Hob.
|
|
@param[in] HobRaw A pointer to the start of gUefiAcpiBoardInfoGuid HOB.
|
|
@param[in] HobLength The size of the HOB data buffer.
|
|
|
|
@retval EFI_SUCCESS If it completed successfully.
|
|
**/
|
|
EFI_STATUS
|
|
PrintAcpiBoardInfoGuidHob (
|
|
IN UINT8 *HobRaw,
|
|
IN UINT16 HobLength
|
|
)
|
|
{
|
|
ACPI_BOARD_INFO *AcpBoardInfo;
|
|
|
|
AcpBoardInfo = (ACPI_BOARD_INFO *)GET_GUID_HOB_DATA (HobRaw);
|
|
ASSERT (HobLength >= sizeof (*AcpBoardInfo));
|
|
DEBUG ((DEBUG_INFO, " Revision = 0x%x\n", AcpBoardInfo->Revision));
|
|
DEBUG ((DEBUG_INFO, " Reserved0 = 0x%x\n", AcpBoardInfo->Reserved0));
|
|
DEBUG ((DEBUG_INFO, " ResetValue = 0x%x\n", AcpBoardInfo->ResetValue));
|
|
DEBUG ((DEBUG_INFO, " PmEvtBase = 0x%lx\n", AcpBoardInfo->PmEvtBase));
|
|
DEBUG ((DEBUG_INFO, " PmGpeEnBase = 0x%lx\n", AcpBoardInfo->PmGpeEnBase));
|
|
DEBUG ((DEBUG_INFO, " PmCtrlRegBase = 0x%lx\n", AcpBoardInfo->PmCtrlRegBase));
|
|
DEBUG ((DEBUG_INFO, " PmTimerRegBase = 0x%lx\n", AcpBoardInfo->PmTimerRegBase));
|
|
DEBUG ((DEBUG_INFO, " ResetRegAddress = 0x%lx\n", AcpBoardInfo->ResetRegAddress));
|
|
DEBUG ((DEBUG_INFO, " PcieBaseAddress = 0x%lx\n", AcpBoardInfo->PcieBaseAddress));
|
|
DEBUG ((DEBUG_INFO, " PcieBaseSize = 0x%lx\n", AcpBoardInfo->PcieBaseSize));
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
Print the information in Pci RootBridge Info Guid Hob.
|
|
@param[in] HobRaw A pointer to the start of gUniversalPayloadPciRootBridgeInfoGuid HOB.
|
|
@param[in] HobLength The size of the HOB data buffer.
|
|
|
|
@retval EFI_SUCCESS If it completed successfully.
|
|
**/
|
|
EFI_STATUS
|
|
PrintPciRootBridgeInfoGuidHob (
|
|
IN UINT8 *HobRaw,
|
|
IN UINT16 HobLength
|
|
)
|
|
{
|
|
UNIVERSAL_PAYLOAD_PCI_ROOT_BRIDGES *PciRootBridges;
|
|
UINTN Index;
|
|
UINTN Length;
|
|
|
|
Index = 0;
|
|
PciRootBridges = (UNIVERSAL_PAYLOAD_PCI_ROOT_BRIDGES *)GET_GUID_HOB_DATA (HobRaw);
|
|
Length = sizeof (UNIVERSAL_PAYLOAD_PCI_ROOT_BRIDGES) + PciRootBridges->Count * sizeof (UNIVERSAL_PAYLOAD_PCI_ROOT_BRIDGE);
|
|
ASSERT (HobLength >= Length);
|
|
DEBUG ((DEBUG_INFO, " Revision = 0x%x\n", PciRootBridges->Header.Revision));
|
|
DEBUG ((DEBUG_INFO, " Length = 0x%x\n", PciRootBridges->Header.Length));
|
|
DEBUG ((DEBUG_INFO, " Count = 0x%x\n", PciRootBridges->Count));
|
|
DEBUG ((DEBUG_INFO, " ResourceAssigned = %a\n", (PciRootBridges->ResourceAssigned ? "True" : "False")));
|
|
|
|
while (Index < PciRootBridges->Count) {
|
|
DEBUG ((DEBUG_INFO, " Root Bridge Index[%d]:\n", Index));
|
|
DEBUG ((DEBUG_INFO, " Segment = 0x%x\n", PciRootBridges->RootBridge[Index].Segment));
|
|
DEBUG ((DEBUG_INFO, " Supports = 0x%lx\n", PciRootBridges->RootBridge[Index].Supports));
|
|
DEBUG ((DEBUG_INFO, " Attributes = 0x%lx\n", PciRootBridges->RootBridge[Index].Attributes));
|
|
DEBUG ((DEBUG_INFO, " DmaAbove4G = 0x%x\n", PciRootBridges->RootBridge[Index].DmaAbove4G));
|
|
DEBUG ((DEBUG_INFO, " NoExtendedConfigSpace = 0x%x\n", PciRootBridges->RootBridge[Index].NoExtendedConfigSpace));
|
|
DEBUG ((DEBUG_INFO, " AllocationAttributes = 0x%lx\n", PciRootBridges->RootBridge[Index].AllocationAttributes));
|
|
DEBUG ((DEBUG_INFO, " Bus.Base = 0x%lx\n", PciRootBridges->RootBridge[Index].Bus.Base));
|
|
DEBUG ((DEBUG_INFO, " Bus.Limit = 0x%lx\n", PciRootBridges->RootBridge[Index].Bus.Limit));
|
|
DEBUG ((DEBUG_INFO, " Bus.Translation = 0x%lx\n", PciRootBridges->RootBridge[Index].Bus.Translation));
|
|
DEBUG ((DEBUG_INFO, " Io.Base = 0x%lx\n", PciRootBridges->RootBridge[Index].Io.Base));
|
|
DEBUG ((DEBUG_INFO, " Io.Limit = 0x%lx\n", PciRootBridges->RootBridge[Index].Io.Limit));
|
|
DEBUG ((DEBUG_INFO, " Io.Translation = 0x%lx\n", PciRootBridges->RootBridge[Index].Io.Translation));
|
|
DEBUG ((DEBUG_INFO, " Mem.Base = 0x%lx\n", PciRootBridges->RootBridge[Index].Mem.Base));
|
|
DEBUG ((DEBUG_INFO, " Mem.Limit = 0x%lx\n", PciRootBridges->RootBridge[Index].Mem.Limit));
|
|
DEBUG ((DEBUG_INFO, " Mem.Translation = 0x%lx\n", PciRootBridges->RootBridge[Index].Mem.Translation));
|
|
DEBUG ((DEBUG_INFO, " MemAbove4G.Base = 0x%lx\n", PciRootBridges->RootBridge[Index].MemAbove4G.Base));
|
|
DEBUG ((DEBUG_INFO, " MemAbove4G.Limit = 0x%lx\n", PciRootBridges->RootBridge[Index].MemAbove4G.Limit));
|
|
DEBUG ((DEBUG_INFO, " MemAbove4G.Translation = 0x%lx\n", PciRootBridges->RootBridge[Index].MemAbove4G.Translation));
|
|
DEBUG ((DEBUG_INFO, " PMem.Base = 0x%lx\n", PciRootBridges->RootBridge[Index].PMem.Base));
|
|
DEBUG ((DEBUG_INFO, " PMem.Limit = 0x%lx\n", PciRootBridges->RootBridge[Index].PMem.Limit));
|
|
DEBUG ((DEBUG_INFO, " PMem.Translation = 0x%lx\n", PciRootBridges->RootBridge[Index].PMem.Translation));
|
|
DEBUG ((DEBUG_INFO, " PMemAbove4G.Base = 0x%lx\n", PciRootBridges->RootBridge[Index].PMemAbove4G.Base));
|
|
DEBUG ((DEBUG_INFO, " PMemAbove4G.Limit = 0x%lx\n", PciRootBridges->RootBridge[Index].PMemAbove4G.Limit));
|
|
DEBUG ((DEBUG_INFO, " PMemAbove4G.Translation = 0x%lx\n", PciRootBridges->RootBridge[Index].PMemAbove4G.Translation));
|
|
Index += 1;
|
|
}
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
Print the information in Extra Data Guid Hob.
|
|
@param[in] HobRaw A pointer to the start of gUniversalPayloadExtraDataGuid HOB.
|
|
@param[in] HobLength The size of the HOB data buffer.
|
|
|
|
@retval EFI_SUCCESS If it completed successfully.
|
|
**/
|
|
EFI_STATUS
|
|
PrintExtraDataGuidHob (
|
|
IN UINT8 *HobRaw,
|
|
IN UINT16 HobLength
|
|
)
|
|
{
|
|
UNIVERSAL_PAYLOAD_EXTRA_DATA *ExtraData;
|
|
UINTN Index;
|
|
UINTN Length;
|
|
|
|
Index = 0;
|
|
ExtraData = (UNIVERSAL_PAYLOAD_EXTRA_DATA *)GET_GUID_HOB_DATA (HobRaw);
|
|
Length = sizeof (UNIVERSAL_PAYLOAD_EXTRA_DATA) + ExtraData->Count * sizeof (UNIVERSAL_PAYLOAD_EXTRA_DATA_ENTRY);
|
|
ASSERT (HobLength >= Length);
|
|
DEBUG ((DEBUG_INFO, " Revision = 0x%x\n", ExtraData->Header.Revision));
|
|
DEBUG ((DEBUG_INFO, " Length = 0x%x\n", ExtraData->Header.Length));
|
|
DEBUG ((DEBUG_INFO, " Count = 0x%x\n", ExtraData->Count));
|
|
|
|
while (Index < ExtraData->Count) {
|
|
DEBUG ((DEBUG_INFO, " Id[%d] = %a\n", Index, ExtraData->Entry[Index].Identifier));
|
|
DEBUG ((DEBUG_INFO, " Base[%d] = 0x%lx\n", Index, ExtraData->Entry[Index].Base));
|
|
DEBUG ((DEBUG_INFO, " Size[%d] = 0x%lx\n", Index, ExtraData->Entry[Index].Size));
|
|
Index += 1;
|
|
}
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
Print the information in MemoryTypeInfoGuidHob.
|
|
@param[in] HobRaw A pointer to the start of gEfiMemoryTypeInformationGuid HOB.
|
|
@param[in] HobLength The size of the HOB data buffer.
|
|
|
|
@retval EFI_SUCCESS If it completed successfully.
|
|
**/
|
|
EFI_STATUS
|
|
PrintMemoryTypeInfoGuidHob (
|
|
IN UINT8 *HobRaw,
|
|
IN UINT16 HobLength
|
|
)
|
|
{
|
|
EFI_MEMORY_TYPE_INFORMATION *MemoryTypeInfo;
|
|
|
|
MemoryTypeInfo = (EFI_MEMORY_TYPE_INFORMATION *)GET_GUID_HOB_DATA (HobRaw);
|
|
ASSERT (HobLength >= sizeof (*MemoryTypeInfo));
|
|
DEBUG ((DEBUG_INFO, " Type = 0x%x\n", MemoryTypeInfo->Type));
|
|
DEBUG ((DEBUG_INFO, " NumberOfPages = 0x%x\n", MemoryTypeInfo->NumberOfPages));
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
Print the information in EdkiiBootManagerMenuFileGuid.
|
|
@param[in] HobRaw A pointer to the start of gEdkiiBootManagerMenuFileGuid HOB.
|
|
@param[in] HobLength The size of the HOB data buffer.
|
|
@retval EFI_SUCCESS If it completed successfully.
|
|
**/
|
|
EFI_STATUS
|
|
PrintBootManagerMenuGuidHob (
|
|
IN UINT8 *HobRaw,
|
|
IN UINT16 HobLength
|
|
)
|
|
{
|
|
UNIVERSAL_PAYLOAD_BOOT_MANAGER_MENU *BootManagerMenuFile;
|
|
|
|
BootManagerMenuFile = (UNIVERSAL_PAYLOAD_BOOT_MANAGER_MENU *)GET_GUID_HOB_DATA (HobRaw);
|
|
ASSERT (HobLength >= sizeof (*BootManagerMenuFile));
|
|
DEBUG ((DEBUG_INFO, " Revision = 0x%x\n", BootManagerMenuFile->Header.Revision));
|
|
DEBUG ((DEBUG_INFO, " Length = 0x%x\n", BootManagerMenuFile->Header.Length));
|
|
DEBUG ((DEBUG_INFO, " FileName = %g\n", &BootManagerMenuFile->FileName));
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
//
|
|
// Mappint table for dump Guid Hob information.
|
|
// This table can be easily extented.
|
|
//
|
|
GUID_HOB_PRINT_HANDLE GuidHobPrintHandleTable[] = {
|
|
{ &gUniversalPayloadAcpiTableGuid, PrintAcpiGuidHob, "gUniversalPayloadAcpiTableGuid(ACPI table Guid)" },
|
|
{ &gUniversalPayloadSerialPortInfoGuid, PrintSerialGuidHob, "gUniversalPayloadSerialPortInfoGuid(Serial Port Info)" },
|
|
{ &gUniversalPayloadSmbios3TableGuid, PrintSmbios3GuidHob, "gUniversalPayloadSmbios3TableGuid(SmBios Guid)" },
|
|
{ &gUniversalPayloadSmbiosTableGuid, PrintSmbiosTablGuidHob, "gUniversalPayloadSmbiosTableGuid(SmBios Guid)" },
|
|
{ &gUefiAcpiBoardInfoGuid, PrintAcpiBoardInfoGuidHob, "gUefiAcpiBoardInfoGuid(Acpi Guid)" },
|
|
{ &gUniversalPayloadPciRootBridgeInfoGuid, PrintPciRootBridgeInfoGuidHob, "gUniversalPayloadPciRootBridgeInfoGuid(Pci Guid)" },
|
|
{ &gEfiMemoryTypeInformationGuid, PrintMemoryTypeInfoGuidHob, "gEfiMemoryTypeInformationGuid(Memory Type Information Guid)" },
|
|
{ &gUniversalPayloadExtraDataGuid, PrintExtraDataGuidHob, "gUniversalPayloadExtraDataGuid(PayLoad Extra Data Guid)" },
|
|
{ &gEdkiiBootManagerMenuFileGuid, PrintBootManagerMenuGuidHob, "gEdkiiBootManagerMenuFileGuid(Boot Manager Menu File Guid)" }
|
|
};
|
|
|
|
/**
|
|
Print the Guid Hob using related print handle function.
|
|
@param[in] HobStart A pointer to the HOB of type EFI_HOB_TYPE_GUID_EXTENSION.
|
|
@param[in] HobLength The length in bytes of the HOB of type EFI_HOB_TYPE_GUID_EXTENSION.
|
|
@retval EFI_SUCCESS If it completed successfully.
|
|
**/
|
|
EFI_STATUS
|
|
PrintGuidHob (
|
|
IN VOID *HobStart,
|
|
IN UINT16 HobLength
|
|
)
|
|
{
|
|
EFI_PEI_HOB_POINTERS Hob;
|
|
UINTN Index;
|
|
EFI_STATUS Status;
|
|
|
|
Hob.Raw = (UINT8 *)HobStart;
|
|
ASSERT (HobLength >= sizeof (Hob.Guid));
|
|
|
|
for (Index = 0; Index < ARRAY_SIZE (GuidHobPrintHandleTable); Index++) {
|
|
if (CompareGuid (&Hob.Guid->Name, GuidHobPrintHandleTable[Index].Guid)) {
|
|
DEBUG ((DEBUG_INFO, " Guid = %a\n", GuidHobPrintHandleTable[Index].GuidName));
|
|
Status = GuidHobPrintHandleTable[Index].PrintHandler (Hob.Raw, GET_GUID_HOB_DATA_SIZE (Hob.Raw));
|
|
return Status;
|
|
}
|
|
}
|
|
|
|
DEBUG ((DEBUG_INFO, " Name = %g\n", &Hob.Guid->Name));
|
|
PrintHex (GET_GUID_HOB_DATA (Hob.Raw), GET_GUID_HOB_DATA_SIZE (Hob.Raw));
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
Print the information in FV Hob.
|
|
@param[in] HobStart A pointer to the HOB of type EFI_HOB_TYPE_FV.
|
|
@param[in] HobLength The length in bytes of the HOB of type EFI_HOB_TYPE_FV.
|
|
@retval EFI_SUCCESS If it completed successfully.
|
|
**/
|
|
EFI_STATUS
|
|
PrintFvHob (
|
|
IN VOID *HobStart,
|
|
IN UINT16 HobLength
|
|
)
|
|
{
|
|
EFI_PEI_HOB_POINTERS Hob;
|
|
|
|
Hob.Raw = (UINT8 *)HobStart;
|
|
ASSERT (HobLength >= sizeof (*Hob.FirmwareVolume));
|
|
|
|
DEBUG ((DEBUG_INFO, " BaseAddress = 0x%lx\n", Hob.FirmwareVolume->BaseAddress));
|
|
DEBUG ((DEBUG_INFO, " Length = 0x%lx\n", Hob.FirmwareVolume->Length));
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
Print the information in Cpu Hob.
|
|
@param[in] HobStart A pointer to the HOB of type EFI_HOB_TYPE_CPU.
|
|
@param[in] HobLength The length in bytes of the HOB of type EFI_HOB_TYPE_CPU.
|
|
@retval EFI_SUCCESS If it completed successfully.
|
|
**/
|
|
EFI_STATUS
|
|
PrintCpuHob (
|
|
IN VOID *HobStart,
|
|
IN UINT16 HobLength
|
|
)
|
|
{
|
|
EFI_PEI_HOB_POINTERS Hob;
|
|
|
|
Hob.Raw = (UINT8 *)HobStart;
|
|
ASSERT (HobLength >= sizeof (*Hob.Cpu));
|
|
|
|
DEBUG ((DEBUG_INFO, " SizeOfMemorySpace = 0x%lx\n", Hob.Cpu->SizeOfMemorySpace));
|
|
DEBUG ((DEBUG_INFO, " SizeOfIoSpace = 0x%lx\n", Hob.Cpu->SizeOfIoSpace));
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
Print the information in MemoryPoolHob.
|
|
@param[in] HobStart A pointer to the HOB of type EFI_HOB_TYPE_MEMORY_POOL.
|
|
@param[in] HobLength The length in bytes of the HOB of type EFI_HOB_TYPE_MEMORY_POOL.
|
|
@retval EFI_SUCCESS If it completed successfully.
|
|
**/
|
|
EFI_STATUS
|
|
PrintMemoryPoolHob (
|
|
IN VOID *HobStart,
|
|
IN UINT16 HobLength
|
|
)
|
|
{
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
Print the information in Fv2Hob.
|
|
@param[in] HobStart A pointer to the HOB of type EFI_HOB_TYPE_FV2.
|
|
@param[in] HobLength The length in bytes of the HOB of type EFI_HOB_TYPE_FV2.
|
|
@retval EFI_SUCCESS If it completed successfully.
|
|
**/
|
|
EFI_STATUS
|
|
PrintFv2Hob (
|
|
IN VOID *HobStart,
|
|
IN UINT16 HobLength
|
|
)
|
|
{
|
|
EFI_PEI_HOB_POINTERS Hob;
|
|
|
|
Hob.Raw = (UINT8 *)HobStart;
|
|
ASSERT (HobLength >= sizeof (*Hob.FirmwareVolume2));
|
|
|
|
DEBUG ((DEBUG_INFO, " BaseAddress = 0x%lx\n", Hob.FirmwareVolume2->BaseAddress));
|
|
DEBUG ((DEBUG_INFO, " Length = 0x%lx\n", Hob.FirmwareVolume2->Length));
|
|
DEBUG ((DEBUG_INFO, " FvName = %g\n", &Hob.FirmwareVolume2->FvName));
|
|
DEBUG ((DEBUG_INFO, " FileName = %g\n", &Hob.FirmwareVolume2->FileName));
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
Print the information in Capsule Hob.
|
|
@param[in] HobStart A pointer to the HOB of type EFI_HOB_TYPE_UEFI_CAPSULE.
|
|
@param[in] HobLength The length in bytes of the HOB of type EFI_HOB_TYPE_UEFI_CAPSULE.
|
|
@retval EFI_SUCCESS If it completed successfully.
|
|
**/
|
|
EFI_STATUS
|
|
PrintCapsuleHob (
|
|
IN VOID *HobStart,
|
|
IN UINT16 HobLength
|
|
)
|
|
{
|
|
EFI_PEI_HOB_POINTERS Hob;
|
|
|
|
Hob.Raw = (UINT8 *)HobStart;
|
|
ASSERT (HobLength >= sizeof (*Hob.Capsule));
|
|
|
|
DEBUG ((DEBUG_INFO, " BaseAddress = 0x%lx\n", Hob.Capsule->BaseAddress));
|
|
DEBUG ((DEBUG_INFO, " Length = 0x%lx\n", Hob.Capsule->Length));
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
Print the information in Fv3 Hob.
|
|
@param[in] HobStart A pointer to the HOB of type EFI_HOB_TYPE_FV3.
|
|
@param[in] HobLength The length in bytes of the HOB of type EFI_HOB_TYPE_FV3.
|
|
@retval EFI_SUCCESS If it completed successfully.
|
|
**/
|
|
EFI_STATUS
|
|
PrintFv3Hob (
|
|
IN VOID *HobStart,
|
|
IN UINT16 HobLength
|
|
)
|
|
{
|
|
EFI_PEI_HOB_POINTERS Hob;
|
|
|
|
Hob.Raw = (UINT8 *)HobStart;
|
|
ASSERT (HobLength >= sizeof (*Hob.FirmwareVolume3));
|
|
|
|
DEBUG ((DEBUG_INFO, " BaseAddress = 0x%lx\n", Hob.FirmwareVolume3->BaseAddress));
|
|
DEBUG ((DEBUG_INFO, " Length = 0x%lx\n", Hob.FirmwareVolume3->Length));
|
|
DEBUG ((DEBUG_INFO, " AuthenticationStatus = 0x%x\n", Hob.FirmwareVolume3->AuthenticationStatus));
|
|
DEBUG ((DEBUG_INFO, " ExtractedFv = %a\n", (Hob.FirmwareVolume3->ExtractedFv ? "True" : "False")));
|
|
DEBUG ((DEBUG_INFO, " FVName = %g\n", &Hob.FirmwareVolume3->FvName));
|
|
DEBUG ((DEBUG_INFO, " FileName = %g\n", &Hob.FirmwareVolume3->FileName));
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
//
|
|
// Mappint table from Hob type to Hob print function.
|
|
//
|
|
HOB_PRINT_HANDLER_TABLE mHobHandles[] = {
|
|
{ EFI_HOB_TYPE_HANDOFF, "EFI_HOB_TYPE_HANDOFF", PrintHandOffHob },
|
|
{ EFI_HOB_TYPE_MEMORY_ALLOCATION, "EFI_HOB_TYPE_MEMORY_ALLOCATION", PrintMemoryAllocationHob },
|
|
{ EFI_HOB_TYPE_RESOURCE_DESCRIPTOR, "EFI_HOB_TYPE_RESOURCE_DESCRIPTOR", PrintResourceDiscriptorHob },
|
|
{ EFI_HOB_TYPE_GUID_EXTENSION, "EFI_HOB_TYPE_GUID_EXTENSION", PrintGuidHob },
|
|
{ EFI_HOB_TYPE_FV, "EFI_HOB_TYPE_FV", PrintFvHob },
|
|
{ EFI_HOB_TYPE_CPU, "EFI_HOB_TYPE_CPU", PrintCpuHob },
|
|
{ EFI_HOB_TYPE_MEMORY_POOL, "EFI_HOB_TYPE_MEMORY_POOL", PrintMemoryPoolHob },
|
|
{ EFI_HOB_TYPE_FV2, "EFI_HOB_TYPE_FV2", PrintFv2Hob },
|
|
{ EFI_HOB_TYPE_UEFI_CAPSULE, "EFI_HOB_TYPE_UEFI_CAPSULE", PrintCapsuleHob },
|
|
{ EFI_HOB_TYPE_FV3, "EFI_HOB_TYPE_FV3", PrintFv3Hob }
|
|
};
|
|
|
|
/**
|
|
Print all HOBs info from the HOB list.
|
|
@param[in] HobStart A pointer to the HOB list
|
|
@return The pointer to the HOB list.
|
|
**/
|
|
VOID
|
|
PrintHob (
|
|
IN CONST VOID *HobStart
|
|
)
|
|
{
|
|
EFI_PEI_HOB_POINTERS Hob;
|
|
UINTN Count;
|
|
UINTN Index;
|
|
|
|
ASSERT (HobStart != NULL);
|
|
|
|
Hob.Raw = (UINT8 *)HobStart;
|
|
DEBUG ((DEBUG_INFO, "Print all Hob information from Hob 0x%p\n", Hob.Raw));
|
|
|
|
Count = 0;
|
|
//
|
|
// Parse the HOB list to see which type it is, and print the information.
|
|
//
|
|
while (!END_OF_HOB_LIST (Hob)) {
|
|
for (Index = 0; Index < ARRAY_SIZE (mHobHandles); Index++) {
|
|
if (Hob.Header->HobType == mHobHandles[Index].Type) {
|
|
DEBUG ((DEBUG_INFO, "HOB[%d]: Type = %a, Offset = 0x%p, Length = 0x%x\n", Count, mHobHandles[Index].Name, (Hob.Raw - (UINT8 *)HobStart), Hob.Header->HobLength));
|
|
mHobHandles[Index].PrintHandler (Hob.Raw, Hob.Header->HobLength);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (Index == ARRAY_SIZE (mHobHandles)) {
|
|
DEBUG ((DEBUG_INFO, "HOB[%d]: Type = %d, Offset = 0x%p, Length = 0x%x\n", Count, Hob.Header->HobType, (Hob.Raw - (UINT8 *)HobStart), Hob.Header->HobLength));
|
|
DEBUG ((DEBUG_INFO, " Unkown Hob type\n"));
|
|
PrintHex (Hob.Raw, Hob.Header->HobLength);
|
|
}
|
|
|
|
Count++;
|
|
Hob.Raw = GET_NEXT_HOB (Hob);
|
|
}
|
|
|
|
DEBUG ((DEBUG_INFO, "There are totally %d Hobs, the End Hob address is %p\n", Count, Hob.Raw));
|
|
}
|