| /** @file | |
| Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR> | |
| This program and the accompanying materials | |
| are licensed and made available under the terms and conditions of the BSD License | |
| which accompanies this distribution. The full text of the license may be found at | |
| http://opensource.org/licenses/bsd-license.php | |
| THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, | |
| WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. | |
| Module Name: | |
| HobGeneration.c | |
| Abstract: | |
| Revision History: | |
| **/ | |
| #include "DxeIpl.h" | |
| #include "HobGeneration.h" | |
| #include "PpisNeededByDxeCore.h" | |
| #include "FlashLayout.h" | |
| #include "Debug.h" | |
| #define EFI_CPUID_EXTENDED_FUNCTION 0x80000000 | |
| #define CPUID_EXTENDED_ADD_SIZE 0x80000008 | |
| #define EBDA_VALUE_ADDRESS 0x40E | |
| HOB_TEMPLATE gHobTemplate = { | |
| { // Phit | |
| { // Header | |
| EFI_HOB_TYPE_HANDOFF, // HobType | |
| sizeof (EFI_HOB_HANDOFF_INFO_TABLE), // HobLength | |
| 0 // Reserved | |
| }, | |
| EFI_HOB_HANDOFF_TABLE_VERSION, // Version | |
| BOOT_WITH_FULL_CONFIGURATION, // BootMode | |
| 0, // EfiMemoryTop | |
| 0, // EfiMemoryBottom | |
| 0, // EfiFreeMemoryTop | |
| 0, // EfiFreeMemoryBottom | |
| 0 // EfiEndOfHobList | |
| }, | |
| { // Bfv | |
| { | |
| EFI_HOB_TYPE_FV, // HobType | |
| sizeof (EFI_HOB_FIRMWARE_VOLUME), // HobLength | |
| 0 // Reserved | |
| }, | |
| 0, // BaseAddress | |
| 0 // Length | |
| }, | |
| { // BfvResource | |
| { | |
| EFI_HOB_TYPE_RESOURCE_DESCRIPTOR, // HobType | |
| sizeof (EFI_HOB_RESOURCE_DESCRIPTOR), // HobLength | |
| 0 // Reserved | |
| }, | |
| { | |
| 0 // Owner Guid | |
| }, | |
| EFI_RESOURCE_FIRMWARE_DEVICE, // ResourceType | |
| (EFI_RESOURCE_ATTRIBUTE_PRESENT | | |
| EFI_RESOURCE_ATTRIBUTE_INITIALIZED | | |
| EFI_RESOURCE_ATTRIBUTE_TESTED | | |
| EFI_RESOURCE_ATTRIBUTE_WRITE_BACK_CACHEABLE), // ResourceAttribute | |
| 0, // PhysicalStart | |
| 0 // ResourceLength | |
| }, | |
| { // Cpu | |
| { // Header | |
| EFI_HOB_TYPE_CPU, // HobType | |
| sizeof (EFI_HOB_CPU), // HobLength | |
| 0 // Reserved | |
| }, | |
| 52, // SizeOfMemorySpace - Architecture Max | |
| 16, // SizeOfIoSpace, | |
| { | |
| 0, 0, 0, 0, 0, 0 // Reserved[6] | |
| } | |
| }, | |
| { // Stack HOB | |
| { // header | |
| EFI_HOB_TYPE_MEMORY_ALLOCATION, // Hob type | |
| sizeof (EFI_HOB_MEMORY_ALLOCATION_STACK), // Hob size | |
| 0 // reserved | |
| }, | |
| { | |
| EFI_HOB_MEMORY_ALLOC_STACK_GUID, | |
| 0x0, // EFI_PHYSICAL_ADDRESS MemoryBaseAddress; | |
| 0x0, // UINT64 MemoryLength; | |
| EfiBootServicesData, // EFI_MEMORY_TYPE MemoryType; | |
| {0, 0, 0, 0} // Reserved Reserved[4]; | |
| } | |
| }, | |
| { // MemoryAllocation for HOB's & Images | |
| { | |
| EFI_HOB_TYPE_MEMORY_ALLOCATION, // HobType | |
| sizeof (EFI_HOB_MEMORY_ALLOCATION), // HobLength | |
| 0 // Reserved | |
| }, | |
| { | |
| { | |
| 0, //EFI_HOB_MEMORY_ALLOC_MODULE_GUID // Name | |
| }, | |
| 0x0, // EFI_PHYSICAL_ADDRESS MemoryBaseAddress; | |
| 0x0, // UINT64 MemoryLength; | |
| EfiBootServicesData, // EFI_MEMORY_TYPE MemoryType; | |
| { | |
| 0, 0, 0, 0 // Reserved Reserved[4]; | |
| } | |
| } | |
| }, | |
| { // MemoryFreeUnder1MB for unused memory that DXE core will claim | |
| { | |
| EFI_HOB_TYPE_RESOURCE_DESCRIPTOR, // HobType | |
| sizeof (EFI_HOB_RESOURCE_DESCRIPTOR), // HobLength | |
| 0 // Reserved | |
| }, | |
| { | |
| 0 // Owner Guid | |
| }, | |
| EFI_RESOURCE_SYSTEM_MEMORY, // ResourceType | |
| (EFI_RESOURCE_ATTRIBUTE_PRESENT | | |
| EFI_RESOURCE_ATTRIBUTE_TESTED | | |
| EFI_RESOURCE_ATTRIBUTE_INITIALIZED | | |
| EFI_RESOURCE_ATTRIBUTE_UNCACHEABLE | | |
| EFI_RESOURCE_ATTRIBUTE_WRITE_COMBINEABLE | | |
| EFI_RESOURCE_ATTRIBUTE_WRITE_THROUGH_CACHEABLE | | |
| EFI_RESOURCE_ATTRIBUTE_WRITE_BACK_CACHEABLE), | |
| 0x0, // PhysicalStart | |
| 0 // ResourceLength | |
| }, | |
| { // MemoryFreeAbove1MB for unused memory that DXE core will claim | |
| { | |
| EFI_HOB_TYPE_RESOURCE_DESCRIPTOR, // HobType | |
| sizeof (EFI_HOB_RESOURCE_DESCRIPTOR), // HobLength | |
| 0 // Reserved | |
| }, | |
| { | |
| 0 // Owner Guid | |
| }, | |
| EFI_RESOURCE_SYSTEM_MEMORY, // ResourceType | |
| (EFI_RESOURCE_ATTRIBUTE_PRESENT | | |
| EFI_RESOURCE_ATTRIBUTE_TESTED | | |
| EFI_RESOURCE_ATTRIBUTE_INITIALIZED | | |
| EFI_RESOURCE_ATTRIBUTE_UNCACHEABLE | | |
| EFI_RESOURCE_ATTRIBUTE_WRITE_COMBINEABLE | | |
| EFI_RESOURCE_ATTRIBUTE_WRITE_THROUGH_CACHEABLE | | |
| EFI_RESOURCE_ATTRIBUTE_WRITE_BACK_CACHEABLE), | |
| 0x0, // PhysicalStart | |
| 0 // ResourceLength | |
| }, | |
| { // MemoryFreeAbove4GB for unused memory that DXE core will claim | |
| { | |
| EFI_HOB_TYPE_RESOURCE_DESCRIPTOR, // HobType | |
| sizeof (EFI_HOB_RESOURCE_DESCRIPTOR), // HobLength | |
| 0 // Reserved | |
| }, | |
| { | |
| 0 // Owner Guid | |
| }, | |
| EFI_RESOURCE_SYSTEM_MEMORY, // ResourceType | |
| (EFI_RESOURCE_ATTRIBUTE_PRESENT | | |
| EFI_RESOURCE_ATTRIBUTE_INITIALIZED | | |
| EFI_RESOURCE_ATTRIBUTE_UNCACHEABLE | | |
| EFI_RESOURCE_ATTRIBUTE_WRITE_COMBINEABLE | | |
| EFI_RESOURCE_ATTRIBUTE_WRITE_THROUGH_CACHEABLE | | |
| EFI_RESOURCE_ATTRIBUTE_WRITE_BACK_CACHEABLE), | |
| 0x0, // PhysicalStart | |
| 0 // ResourceLength | |
| }, | |
| { // Memory Allocation Module for DxeCore | |
| { // header | |
| EFI_HOB_TYPE_MEMORY_ALLOCATION, // Hob type | |
| sizeof (EFI_HOB_MEMORY_ALLOCATION_MODULE), // Hob size | |
| 0 // reserved | |
| }, | |
| { | |
| EFI_HOB_MEMORY_ALLOC_MODULE_GUID, | |
| 0x0, // EFI_PHYSICAL_ADDRESS MemoryBaseAddress; | |
| 0x0, // UINT64 MemoryLength; | |
| EfiBootServicesCode, // EFI_MEMORY_TYPE MemoryType; | |
| { | |
| 0, 0, 0, 0 // UINT8 Reserved[4]; | |
| }, | |
| }, | |
| DXE_CORE_FILE_NAME_GUID, | |
| 0x0 // EFI_PHYSICAL_ADDRESS of EntryPoint; | |
| }, | |
| { // MemoryDxeCore | |
| { | |
| EFI_HOB_TYPE_RESOURCE_DESCRIPTOR, // HobType | |
| sizeof (EFI_HOB_RESOURCE_DESCRIPTOR), // HobLength | |
| 0 // Reserved | |
| }, | |
| { | |
| 0 // Owner Guid | |
| }, | |
| EFI_RESOURCE_SYSTEM_MEMORY, // ResourceType | |
| (EFI_RESOURCE_ATTRIBUTE_PRESENT | | |
| // EFI_RESOURCE_ATTRIBUTE_TESTED | // Do not mark as TESTED, or DxeCore will find it and use it before check Allocation | |
| EFI_RESOURCE_ATTRIBUTE_INITIALIZED | | |
| EFI_RESOURCE_ATTRIBUTE_UNCACHEABLE | | |
| EFI_RESOURCE_ATTRIBUTE_WRITE_COMBINEABLE | | |
| EFI_RESOURCE_ATTRIBUTE_WRITE_THROUGH_CACHEABLE | | |
| EFI_RESOURCE_ATTRIBUTE_WRITE_BACK_CACHEABLE), | |
| 0x0, // PhysicalStart | |
| 0 // ResourceLength | |
| }, | |
| { // Memory Map Hints to reduce fragmentation in the memory map | |
| { | |
| { | |
| EFI_HOB_TYPE_GUID_EXTENSION, // Hob type | |
| sizeof (MEMORY_TYPE_INFORMATION_HOB), // Hob size | |
| 0, // reserved | |
| }, | |
| EFI_MEMORY_TYPE_INFORMATION_GUID | |
| }, | |
| { | |
| { | |
| EfiACPIReclaimMemory, | |
| 0x80 | |
| }, // 0x80 pages = 512k for ASL | |
| { | |
| EfiACPIMemoryNVS, | |
| 0x100 | |
| }, // 0x100 pages = 1024k for S3, SMM, etc | |
| { | |
| EfiReservedMemoryType, | |
| 0x04 | |
| }, // 16k for BIOS Reserved | |
| { | |
| EfiRuntimeServicesData, | |
| 0x100 | |
| }, | |
| { | |
| EfiRuntimeServicesCode, | |
| 0x100 | |
| }, | |
| { | |
| EfiBootServicesCode, | |
| 0x200 | |
| }, | |
| { | |
| EfiBootServicesData, | |
| 0x200 | |
| }, | |
| { | |
| EfiLoaderCode, | |
| 0x100 | |
| }, | |
| { | |
| EfiLoaderData, | |
| 0x100 | |
| }, | |
| { | |
| EfiMaxMemoryType, | |
| 0 | |
| } | |
| } | |
| }, | |
| { // Pointer to ACPI Table | |
| { | |
| { | |
| EFI_HOB_TYPE_GUID_EXTENSION, // Hob type | |
| sizeof (TABLE_HOB), // Hob size | |
| 0 // reserved | |
| }, | |
| EFI_ACPI_TABLE_GUID | |
| }, | |
| 0 | |
| }, | |
| { // Pointer to ACPI20 Table | |
| { | |
| { | |
| EFI_HOB_TYPE_GUID_EXTENSION, // Hob type | |
| sizeof (TABLE_HOB), // Hob size | |
| 0 // reserved | |
| }, | |
| EFI_ACPI_20_TABLE_GUID | |
| }, | |
| 0 | |
| }, | |
| { // Pointer to SMBIOS Table | |
| { | |
| { | |
| EFI_HOB_TYPE_GUID_EXTENSION, // Hob type | |
| sizeof (TABLE_HOB), // Hob size | |
| 0 // reserved | |
| }, | |
| SMBIOS_TABLE_GUID | |
| }, | |
| 0 | |
| }, | |
| { // Pointer to MPS Table | |
| { | |
| { | |
| EFI_HOB_TYPE_GUID_EXTENSION, // Hob type | |
| sizeof (TABLE_HOB), // Hob size | |
| 0, // reserved | |
| }, | |
| EFI_MPS_TABLE_GUID | |
| }, | |
| 0 | |
| }, | |
| /** | |
| { // Pointer to FlushInstructionCache | |
| EFI_HOB_TYPE_GUID_EXTENSION, // Hob type | |
| sizeof (PROTOCOL_HOB), // Hob size | |
| 0, // reserved | |
| EFI_PEI_FLUSH_INSTRUCTION_CACHE_GUID, | |
| NULL | |
| }, | |
| { // Pointer to TransferControl | |
| EFI_HOB_TYPE_GUID_EXTENSION, // Hob type | |
| sizeof (PROTOCOL_HOB), // Hob size | |
| 0, // reserved | |
| EFI_PEI_TRANSFER_CONTROL_GUID, | |
| NULL | |
| }, | |
| { // Pointer to PeCoffLoader | |
| EFI_HOB_TYPE_GUID_EXTENSION, // Hob type | |
| sizeof (PROTOCOL_HOB), // Hob size | |
| 0, // reserved | |
| EFI_PEI_PE_COFF_LOADER_GUID, | |
| NULL | |
| }, | |
| { // Pointer to EfiDecompress | |
| EFI_HOB_TYPE_GUID_EXTENSION, // Hob type | |
| sizeof (PROTOCOL_HOB), // Hob size | |
| 0, // reserved | |
| EFI_DECOMPRESS_PROTOCOL_GUID, | |
| NULL | |
| }, | |
| { // Pointer to TianoDecompress | |
| EFI_HOB_TYPE_GUID_EXTENSION, // Hob type | |
| sizeof (PROTOCOL_HOB), // Hob size | |
| 0, // reserved | |
| EFI_TIANO_DECOMPRESS_PROTOCOL_GUID, | |
| NULL | |
| }, | |
| **/ | |
| { // Pointer to ReportStatusCode | |
| { | |
| { | |
| EFI_HOB_TYPE_GUID_EXTENSION, // Hob type | |
| sizeof (PROTOCOL_HOB), // Hob size | |
| 0 // reserved | |
| }, | |
| EFI_STATUS_CODE_RUNTIME_PROTOCOL_GUID | |
| }, | |
| 0 | |
| }, | |
| { // EFILDR Memory Descriptor | |
| { | |
| { | |
| EFI_HOB_TYPE_GUID_EXTENSION, // Hob type | |
| sizeof (MEMORY_DESC_HOB), // Hob size | |
| 0 // reserved | |
| }, | |
| LDR_MEMORY_DESCRIPTOR_GUID | |
| }, | |
| 0, | |
| NULL | |
| }, | |
| { // Pci Express Base Address Hob | |
| { | |
| { | |
| EFI_HOB_TYPE_GUID_EXTENSION, // Hob type | |
| sizeof (PCI_EXPRESS_BASE_HOB), // Hob size | |
| 0 // reserved | |
| }, | |
| EFI_PCI_EXPRESS_BASE_ADDRESS_GUID | |
| }, | |
| { | |
| 0, | |
| 0, | |
| 0, | |
| } | |
| }, | |
| { // Acpi Description Hob | |
| { | |
| { | |
| EFI_HOB_TYPE_GUID_EXTENSION, // Hob type | |
| sizeof (ACPI_DESCRIPTION_HOB), // Hob size | |
| 0 // reserved | |
| }, | |
| EFI_ACPI_DESCRIPTION_GUID | |
| }, | |
| { | |
| { | |
| 0, | |
| }, | |
| } | |
| }, | |
| { // NV Storage FV Resource | |
| { | |
| EFI_HOB_TYPE_RESOURCE_DESCRIPTOR, // HobType | |
| sizeof (EFI_HOB_RESOURCE_DESCRIPTOR), // HobLength | |
| 0 // Reserved | |
| }, | |
| { | |
| 0 // Owner Guid | |
| }, | |
| EFI_RESOURCE_FIRMWARE_DEVICE, // ResourceType | |
| (EFI_RESOURCE_ATTRIBUTE_PRESENT | | |
| EFI_RESOURCE_ATTRIBUTE_INITIALIZED | | |
| EFI_RESOURCE_ATTRIBUTE_TESTED | | |
| EFI_RESOURCE_ATTRIBUTE_WRITE_BACK_CACHEABLE), // ResourceAttribute | |
| 0, // PhysicalStart (Fixed later) | |
| NV_STORAGE_FVB_SIZE // ResourceLength | |
| }, | |
| { // FVB holding NV Storage | |
| { | |
| { | |
| EFI_HOB_TYPE_GUID_EXTENSION, // Hob type | |
| sizeof (FVB_HOB), | |
| 0 | |
| }, | |
| EFI_FLASH_MAP_HOB_GUID | |
| }, | |
| { | |
| {0, 0, 0}, // Reserved[3] | |
| EFI_FLASH_AREA_GUID_DEFINED, // AreaType | |
| EFI_SYSTEM_NV_DATA_FV_GUID , // AreaTypeGuid | |
| 1, | |
| { | |
| { | |
| EFI_FLASH_AREA_FV | EFI_FLASH_AREA_MEMMAPPED_FV, // SubAreaData.Attributes | |
| 0, // SubAreaData.Reserved | |
| 0, // SubAreaData.Base (Fixed later) | |
| NV_STORAGE_FVB_SIZE, // SubAreaData.Length | |
| EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL_GUID // SubAreaData.FileSystem | |
| } | |
| }, | |
| 0, // VolumeSignature (Fixed later) | |
| NV_STORAGE_FILE_PATH, // Mapped file without padding | |
| // TotalFVBSize = FileSize + PaddingSize = multiple of BLOCK_SIZE | |
| NV_STORAGE_SIZE + EFI_RUNTIME_UPDATABLE_FV_HEADER_LENGTH, | |
| // ActuralSize | |
| EFI_RUNTIME_UPDATABLE_FV_HEADER_LENGTH | |
| } | |
| }, | |
| { // NV Storage Hob | |
| { | |
| { | |
| EFI_HOB_TYPE_GUID_EXTENSION, // Hob type | |
| sizeof (FVB_HOB), // Hob size | |
| 0 // reserved | |
| }, | |
| EFI_FLASH_MAP_HOB_GUID | |
| }, | |
| { | |
| {0, 0, 0}, // Reserved[3] | |
| EFI_FLASH_AREA_EFI_VARIABLES, // AreaType | |
| { 0 }, // AreaTypeGuid | |
| 1, | |
| { | |
| { | |
| EFI_FLASH_AREA_SUBFV | EFI_FLASH_AREA_MEMMAPPED_FV, // SubAreaData.Attributes | |
| 0, // SubAreaData.Reserved | |
| 0, // SubAreaData.Base (Fixed later) | |
| NV_STORAGE_SIZE, // SubAreaData.Length | |
| EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL_GUID // SubAreaData.FileSystem | |
| } | |
| }, | |
| 0, | |
| NV_STORAGE_FILE_PATH, | |
| NV_STORAGE_SIZE, | |
| 0 | |
| } | |
| }, | |
| { // NV Ftw FV Resource | |
| { | |
| EFI_HOB_TYPE_RESOURCE_DESCRIPTOR, // HobType | |
| sizeof (EFI_HOB_RESOURCE_DESCRIPTOR), // HobLength | |
| 0 // Reserved | |
| }, | |
| { | |
| 0 // Owner Guid | |
| }, | |
| EFI_RESOURCE_FIRMWARE_DEVICE, // ResourceType | |
| (EFI_RESOURCE_ATTRIBUTE_PRESENT | | |
| EFI_RESOURCE_ATTRIBUTE_INITIALIZED | | |
| EFI_RESOURCE_ATTRIBUTE_TESTED | | |
| EFI_RESOURCE_ATTRIBUTE_WRITE_BACK_CACHEABLE), // ResourceAttribute | |
| 0, // PhysicalStart (Fixed later) | |
| NV_FTW_FVB_SIZE // ResourceLength | |
| }, | |
| { // FVB holding FTW spaces including Working & Spare space | |
| { | |
| { | |
| EFI_HOB_TYPE_GUID_EXTENSION, // Hob type | |
| sizeof (FVB_HOB), | |
| 0 | |
| }, | |
| EFI_FLASH_MAP_HOB_GUID | |
| }, | |
| { | |
| {0, 0, 0}, // Reserved[3] | |
| EFI_FLASH_AREA_GUID_DEFINED, // AreaType | |
| EFI_SYSTEM_NV_DATA_FV_GUID, // AreaTypeGuid | |
| 1, | |
| { | |
| { | |
| EFI_FLASH_AREA_FV | EFI_FLASH_AREA_MEMMAPPED_FV, // SubAreaData.Attributes | |
| 0, // SubAreaData.Reserved | |
| 0, // SubAreaData.Base (Fixed later) | |
| NV_FTW_FVB_SIZE, // SubAreaData.Length | |
| EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL_GUID // SubAreaData.FileSystem | |
| } | |
| }, | |
| 0, | |
| L"", // Empty String indicates using memory | |
| 0, | |
| 0 | |
| } | |
| }, | |
| { // NV Ftw working Hob | |
| { | |
| { | |
| EFI_HOB_TYPE_GUID_EXTENSION, // Hob type | |
| sizeof (FVB_HOB), // Hob size | |
| 0 // reserved | |
| }, | |
| EFI_FLASH_MAP_HOB_GUID | |
| }, | |
| { | |
| {0, 0, 0}, // Reserved[3] | |
| EFI_FLASH_AREA_FTW_STATE, // AreaType | |
| { 0 }, // AreaTypeGuid | |
| 1, | |
| { | |
| { | |
| EFI_FLASH_AREA_SUBFV | EFI_FLASH_AREA_MEMMAPPED_FV, // SubAreaData.Attributes | |
| 0, // SubAreaData.Reserved | |
| 0, // SubAreaData.Base (Fixed later) | |
| NV_FTW_WORKING_SIZE, // SubAreaData.Length | |
| EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL_GUID // SubAreaData.FileSystem | |
| } | |
| }, | |
| 0, // VolumeSignature | |
| L"", | |
| 0, | |
| 0 | |
| } | |
| }, | |
| { // NV Ftw spare Hob | |
| { | |
| { | |
| EFI_HOB_TYPE_GUID_EXTENSION, // Hob type | |
| sizeof (FVB_HOB), // Hob size | |
| 0 // reserved | |
| }, | |
| EFI_FLASH_MAP_HOB_GUID | |
| }, | |
| { | |
| {0, 0, 0}, // Reserved[3] | |
| EFI_FLASH_AREA_FTW_BACKUP, // AreaType | |
| { 0 }, // AreaTypeGuid | |
| 1, | |
| { | |
| { | |
| EFI_FLASH_AREA_SUBFV | EFI_FLASH_AREA_MEMMAPPED_FV, // SubAreaData.Attributes | |
| 0, // SubAreaData.Reserved | |
| 0, // SubAreaData.Base (Fixed later) | |
| NV_FTW_SPARE_SIZE, // SubAreaData.Length | |
| EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL_GUID // SubAreaData.FileSystem | |
| } | |
| }, | |
| 0, | |
| L"", | |
| 0, | |
| 0 | |
| } | |
| }, | |
| { // EndOfHobList | |
| EFI_HOB_TYPE_END_OF_HOB_LIST, // HobType | |
| sizeof (EFI_HOB_GENERIC_HEADER), // HobLength | |
| 0 // Reserved | |
| } | |
| }; | |
| HOB_TEMPLATE *gHob = &gHobTemplate; | |
| VOID * | |
| PrepareHobMemory ( | |
| IN UINTN NumberOfMemoryMapEntries, | |
| IN EFI_MEMORY_DESCRIPTOR *EfiMemoryDescriptor | |
| ) | |
| /*++ | |
| Description: | |
| Update the Hob filling MemoryFreeUnder1MB, MemoryAbove1MB, MemoryAbove4GB | |
| Arguments: | |
| NumberOfMemoryMapEntries - Count of Memory Descriptors | |
| EfiMemoryDescriptor - Point to the buffer containing NumberOfMemoryMapEntries Memory Descriptors | |
| Return: | |
| VOID * : The end address of MemoryAbove1MB (or the top free memory under 4GB) | |
| --*/ | |
| { | |
| UINTN Index; | |
| UINT64 EbdaAddress; | |
| // | |
| // Prepare Low Memory | |
| // 0x18 pages is 72 KB. | |
| // | |
| EbdaAddress = ((UINT64)(*(UINT16 *)(UINTN)(EBDA_VALUE_ADDRESS))) << 4; | |
| if (EbdaAddress < 0x9A000 || EbdaAddress > EFI_MEMORY_BELOW_1MB_END) { | |
| // | |
| // EBDA should not go below 0x9A000 in any implementation, | |
| // so add check here to make sure EBDA_VALUE_ADDRESS has a valid value. | |
| // | |
| EbdaAddress = EFI_MEMORY_BELOW_1MB_END; | |
| } | |
| gHob->MemoryFreeUnder1MB.ResourceLength = EbdaAddress - EFI_MEMORY_BELOW_1MB_START; | |
| gHob->MemoryFreeUnder1MB.PhysicalStart = EFI_MEMORY_BELOW_1MB_START; | |
| // | |
| // Prepare High Memory | |
| // Assume Memory Map is ordered from low to high | |
| // | |
| gHob->MemoryAbove1MB.PhysicalStart = 0; | |
| gHob->MemoryAbove1MB.ResourceLength = 0; | |
| gHob->MemoryAbove4GB.PhysicalStart = 0; | |
| gHob->MemoryAbove4GB.ResourceLength = 0; | |
| for (Index = 0; Index < NumberOfMemoryMapEntries; Index++) { | |
| // | |
| // Skip regions below 1MB | |
| // | |
| if (EfiMemoryDescriptor[Index].PhysicalStart < 0x100000) { | |
| continue; | |
| } | |
| // | |
| // Process regions above 1MB | |
| // | |
| if (EfiMemoryDescriptor[Index].PhysicalStart >= 0x100000) { | |
| if (EfiMemoryDescriptor[Index].Type == EfiConventionalMemory) { | |
| if (gHob->MemoryAbove1MB.PhysicalStart == 0) { | |
| gHob->MemoryAbove1MB.PhysicalStart = EfiMemoryDescriptor[Index].PhysicalStart; | |
| gHob->MemoryAbove1MB.ResourceLength = LShiftU64 (EfiMemoryDescriptor[Index].NumberOfPages, EFI_PAGE_SHIFT); | |
| } else if (gHob->MemoryAbove1MB.PhysicalStart + gHob->MemoryAbove1MB.ResourceLength == EfiMemoryDescriptor[Index].PhysicalStart) { | |
| gHob->MemoryAbove1MB.ResourceLength += LShiftU64 (EfiMemoryDescriptor[Index].NumberOfPages, EFI_PAGE_SHIFT); | |
| } | |
| } | |
| if ((EfiMemoryDescriptor[Index].Type == EfiReservedMemoryType) || | |
| (EfiMemoryDescriptor[Index].Type >= EfiACPIReclaimMemory) ) { | |
| continue; | |
| } | |
| if ((EfiMemoryDescriptor[Index].Type == EfiRuntimeServicesCode) || | |
| (EfiMemoryDescriptor[Index].Type == EfiRuntimeServicesData)) { | |
| break; | |
| } | |
| } | |
| // | |
| // Process region above 4GB | |
| // | |
| if (EfiMemoryDescriptor[Index].PhysicalStart >= 0x100000000LL) { | |
| if (EfiMemoryDescriptor[Index].Type == EfiConventionalMemory) { | |
| if (gHob->MemoryAbove4GB.PhysicalStart == 0) { | |
| gHob->MemoryAbove4GB.PhysicalStart = EfiMemoryDescriptor[Index].PhysicalStart; | |
| gHob->MemoryAbove4GB.ResourceLength = LShiftU64 (EfiMemoryDescriptor[Index].NumberOfPages, EFI_PAGE_SHIFT); | |
| } | |
| if (gHob->MemoryAbove4GB.PhysicalStart + gHob->MemoryAbove4GB.ResourceLength == | |
| EfiMemoryDescriptor[Index].PhysicalStart) { | |
| gHob->MemoryAbove4GB.ResourceLength += LShiftU64 (EfiMemoryDescriptor[Index].NumberOfPages, EFI_PAGE_SHIFT); | |
| } | |
| } | |
| } | |
| } | |
| if (gHob->MemoryAbove4GB.ResourceLength == 0) { | |
| // | |
| // If there is no memory above 4GB then change the resource descriptor HOB | |
| // into another type. I'm doing this as it's unclear if a resource | |
| // descriptor HOB of length zero is valid. Spec does not say it's illegal, | |
| // but code in EDK does not seem to handle this case. | |
| // | |
| gHob->MemoryAbove4GB.Header.HobType = EFI_HOB_TYPE_UNUSED; | |
| } | |
| return (VOID *)(UINTN)(gHob->MemoryAbove1MB.PhysicalStart + gHob->MemoryAbove1MB.ResourceLength); | |
| } | |
| VOID * | |
| PrepareHobStack ( | |
| IN VOID *StackTop | |
| ) | |
| { | |
| gHob->Stack.AllocDescriptor.MemoryLength = EFI_MEMORY_STACK_PAGE_NUM * EFI_PAGE_SIZE; | |
| gHob->Stack.AllocDescriptor.MemoryBaseAddress = (EFI_PHYSICAL_ADDRESS)(UINTN)StackTop - gHob->Stack.AllocDescriptor.MemoryLength; | |
| return (VOID *)(UINTN)gHob->Stack.AllocDescriptor.MemoryBaseAddress; | |
| } | |
| VOID * | |
| PrepareHobMemoryDescriptor ( | |
| VOID *MemoryDescriptorTop, | |
| UINTN MemDescCount, | |
| EFI_MEMORY_DESCRIPTOR *MemDesc | |
| ) | |
| { | |
| gHob->MemoryDescriptor.MemDescCount = MemDescCount; | |
| gHob->MemoryDescriptor.MemDesc = (EFI_MEMORY_DESCRIPTOR *)((UINTN)MemoryDescriptorTop - MemDescCount * sizeof(EFI_MEMORY_DESCRIPTOR)); | |
| // | |
| // Make MemoryDescriptor.MemDesc page aligned | |
| // | |
| gHob->MemoryDescriptor.MemDesc = (EFI_MEMORY_DESCRIPTOR *)((UINTN) gHob->MemoryDescriptor.MemDesc & ~EFI_PAGE_MASK); | |
| CopyMem (gHob->MemoryDescriptor.MemDesc, MemDesc, MemDescCount * sizeof(EFI_MEMORY_DESCRIPTOR)); | |
| return gHob->MemoryDescriptor.MemDesc; | |
| } | |
| VOID | |
| PrepareHobBfv ( | |
| VOID *Bfv, | |
| UINTN BfvLength | |
| ) | |
| { | |
| //UINTN BfvLengthPageSize; | |
| // | |
| // Calculate BFV location at top of the memory region. | |
| // This is like a RAM Disk. Align to page boundry. | |
| // | |
| //BfvLengthPageSize = EFI_PAGES_TO_SIZE (EFI_SIZE_TO_PAGES (BfvLength)); | |
| gHob->Bfv.BaseAddress = (EFI_PHYSICAL_ADDRESS)(UINTN)Bfv; | |
| gHob->Bfv.Length = BfvLength; | |
| // | |
| // Resource descriptor for the FV | |
| // | |
| gHob->BfvResource.PhysicalStart = gHob->Bfv.BaseAddress; | |
| gHob->BfvResource.ResourceLength = gHob->Bfv.Length; | |
| } | |
| VOID | |
| PrepareHobDxeCore ( | |
| VOID *DxeCoreEntryPoint, | |
| EFI_PHYSICAL_ADDRESS DxeCoreImageBase, | |
| UINT64 DxeCoreLength | |
| ) | |
| { | |
| gHob->DxeCore.MemoryAllocationHeader.MemoryBaseAddress = DxeCoreImageBase; | |
| gHob->DxeCore.MemoryAllocationHeader.MemoryLength = DxeCoreLength; | |
| gHob->DxeCore.EntryPoint = (EFI_PHYSICAL_ADDRESS)(UINTN)DxeCoreEntryPoint; | |
| gHob->MemoryDxeCore.PhysicalStart = DxeCoreImageBase; | |
| gHob->MemoryDxeCore.ResourceLength = DxeCoreLength; | |
| } | |
| VOID * | |
| PrepareHobNvStorage ( | |
| VOID *NvStorageTop | |
| ) | |
| /* | |
| Initialize Block-Aligned Firmware Block. | |
| Variable: | |
| +-------------------+ | |
| | FV_Header | | |
| +-------------------+ | |
| | | | |
| |VAR_STORAGE(0x4000)| | |
| | | | |
| +-------------------+ | |
| FTW: | |
| +-------------------+ | |
| | FV_Header | | |
| +-------------------+ | |
| | | | |
| | Working(0x2000) | | |
| | | | |
| +-------------------+ | |
| | | | |
| | Spare(0x10000) | | |
| | | | |
| +-------------------+ | |
| */ | |
| { | |
| STATIC VARIABLE_STORE_HEADER VarStoreHeader = { | |
| VARIABLE_STORE_SIGNATURE, | |
| 0xffffffff, // will be fixed in Variable driver | |
| VARIABLE_STORE_FORMATTED, | |
| VARIABLE_STORE_HEALTHY, | |
| 0, | |
| 0 | |
| }; | |
| STATIC EFI_FIRMWARE_VOLUME_HEADER NvStorageFvbHeader = { | |
| { | |
| 0, | |
| }, // ZeroVector[16] | |
| EFI_SYSTEM_NV_DATA_FV_GUID, | |
| NV_STORAGE_FVB_SIZE, | |
| EFI_FVH_SIGNATURE, | |
| EFI_FVB_READ_ENABLED_CAP | | |
| EFI_FVB_READ_STATUS | | |
| EFI_FVB_WRITE_ENABLED_CAP | | |
| EFI_FVB_WRITE_STATUS | | |
| EFI_FVB_ERASE_POLARITY, | |
| EFI_RUNTIME_UPDATABLE_FV_HEADER_LENGTH, | |
| 0, // CheckSum | |
| 0, // ExtHeaderOffset | |
| { | |
| 0, | |
| }, // Reserved[1] | |
| 1, // Revision | |
| { | |
| { | |
| NV_STORAGE_FVB_BLOCK_NUM, | |
| FV_BLOCK_SIZE, | |
| } | |
| } | |
| }; | |
| STATIC EFI_FV_BLOCK_MAP_ENTRY BlockMapEntryEnd = {0, 0}; | |
| EFI_PHYSICAL_ADDRESS StorageFvbBase; | |
| EFI_PHYSICAL_ADDRESS FtwFvbBase; | |
| UINT16 *Ptr; | |
| UINT16 Checksum; | |
| // | |
| // Use first 16-byte Reset Vector of FVB to store extra information | |
| // UINT32 Offset 0 stores the volume signature | |
| // UINT8 Offset 4 : should init the Variable Store Header if non-zero | |
| // | |
| gHob->NvStorageFvb.FvbInfo.VolumeId = *(UINT32 *) (UINTN) (NV_STORAGE_STATE); | |
| gHob->NvStorage. FvbInfo.VolumeId = *(UINT32 *) (UINTN) (NV_STORAGE_STATE); | |
| // | |
| // *(NV_STORAGE_STATE + 4): | |
| // 2 - Size error | |
| // 1 - File not exist | |
| // 0 - File exist with correct size | |
| // | |
| if (*(UINT8 *) (UINTN) (NV_STORAGE_STATE + 4) == 2) { | |
| ClearScreen (); | |
| PrintString ("Error: Size of Efivar.bin should be 16k!\n"); | |
| CpuDeadLoop(); | |
| } | |
| if (*(UINT8 *) (UINTN) (NV_STORAGE_STATE + 4) != 0) { | |
| // | |
| // Efivar.bin doesn't exist | |
| // 1. Init variable storage header to valid header | |
| // | |
| CopyMem ( | |
| (VOID *) (UINTN) NV_STORAGE_START, | |
| &VarStoreHeader, | |
| sizeof (VARIABLE_STORE_HEADER) | |
| ); | |
| // | |
| // 2. set all bits in variable storage body to 1 | |
| // | |
| SetMem ( | |
| (VOID *) (UINTN) (NV_STORAGE_START + sizeof (VARIABLE_STORE_HEADER)), | |
| NV_STORAGE_SIZE - sizeof (VARIABLE_STORE_HEADER), | |
| 0xff | |
| ); | |
| } | |
| // | |
| // Relocate variable storage | |
| // | |
| // 1. Init FVB Header to valid header: First 0x48 bytes | |
| // In real platform, these fields are fixed by tools | |
| // | |
| // | |
| Checksum = 0; | |
| for ( | |
| Ptr = (UINT16 *) &NvStorageFvbHeader; | |
| Ptr < (UINT16 *) ((UINTN) (UINT8 *) &NvStorageFvbHeader + sizeof (EFI_FIRMWARE_VOLUME_HEADER)); | |
| ++Ptr | |
| ) { | |
| Checksum = (UINT16) (Checksum + (*Ptr)); | |
| } | |
| NvStorageFvbHeader.Checksum = (UINT16) (0x10000 - Checksum); | |
| StorageFvbBase = (EFI_PHYSICAL_ADDRESS)(((UINTN)NvStorageTop - NV_STORAGE_FVB_SIZE - NV_FTW_FVB_SIZE) & ~EFI_PAGE_MASK); | |
| CopyMem ((VOID *) (UINTN) StorageFvbBase, &NvStorageFvbHeader, sizeof (EFI_FIRMWARE_VOLUME_HEADER)); | |
| CopyMem ( | |
| (VOID *) (UINTN) (StorageFvbBase + sizeof (EFI_FIRMWARE_VOLUME_HEADER)), | |
| &BlockMapEntryEnd, | |
| sizeof (EFI_FV_BLOCK_MAP_ENTRY) | |
| ); | |
| // | |
| // 2. Relocate variable data | |
| // | |
| CopyMem ( | |
| (VOID *) (UINTN) (StorageFvbBase + EFI_RUNTIME_UPDATABLE_FV_HEADER_LENGTH), | |
| (VOID *) (UINTN) NV_STORAGE_START, | |
| NV_STORAGE_SIZE | |
| ); | |
| // | |
| // 3. Set the remaining memory to 0xff | |
| // | |
| SetMem ( | |
| (VOID *) (UINTN) (StorageFvbBase + EFI_RUNTIME_UPDATABLE_FV_HEADER_LENGTH + NV_STORAGE_SIZE), | |
| NV_STORAGE_FVB_SIZE - NV_STORAGE_SIZE - EFI_RUNTIME_UPDATABLE_FV_HEADER_LENGTH, | |
| 0xff | |
| ); | |
| // | |
| // Create the FVB holding NV Storage in memory | |
| // | |
| gHob->NvStorageFvResource.PhysicalStart = | |
| gHob->NvStorageFvb.FvbInfo.Entries[0].Base = StorageFvbBase; | |
| // | |
| // Create the NV Storage Hob | |
| // | |
| gHob->NvStorage.FvbInfo.Entries[0].Base = StorageFvbBase + EFI_RUNTIME_UPDATABLE_FV_HEADER_LENGTH; | |
| // | |
| // Create the FVB holding FTW spaces | |
| // | |
| FtwFvbBase = (EFI_PHYSICAL_ADDRESS)((UINTN) StorageFvbBase + NV_STORAGE_FVB_SIZE); | |
| gHob->NvFtwFvResource.PhysicalStart = | |
| gHob->NvFtwFvb.FvbInfo.Entries[0].Base = FtwFvbBase; | |
| // | |
| // Put FTW Working in front | |
| // | |
| gHob->NvFtwWorking.FvbInfo.Entries[0].Base = FtwFvbBase + EFI_RUNTIME_UPDATABLE_FV_HEADER_LENGTH; | |
| // | |
| // Put FTW Spare area after FTW Working area | |
| // | |
| gHob->NvFtwSpare.FvbInfo.Entries[0].Base = | |
| (EFI_PHYSICAL_ADDRESS)((UINTN) FtwFvbBase + EFI_RUNTIME_UPDATABLE_FV_HEADER_LENGTH + NV_FTW_WORKING_SIZE); | |
| return (VOID *)(UINTN)StorageFvbBase; | |
| } | |
| VOID | |
| PrepareHobPhit ( | |
| VOID *MemoryTop, | |
| VOID *FreeMemoryTop | |
| ) | |
| { | |
| gHob->Phit.EfiMemoryTop = (EFI_PHYSICAL_ADDRESS)(UINTN)MemoryTop; | |
| gHob->Phit.EfiMemoryBottom = gHob->Phit.EfiMemoryTop - CONSUMED_MEMORY; | |
| gHob->Phit.EfiFreeMemoryTop = (EFI_PHYSICAL_ADDRESS)(UINTN)FreeMemoryTop; | |
| gHob->Phit.EfiFreeMemoryBottom = gHob->Phit.EfiMemoryBottom + sizeof(HOB_TEMPLATE); | |
| CopyMem ((VOID *)(UINTN)gHob->Phit.EfiMemoryBottom, gHob, sizeof(HOB_TEMPLATE)); | |
| gHob = (HOB_TEMPLATE *)(UINTN)gHob->Phit.EfiMemoryBottom; | |
| gHob->Phit.EfiEndOfHobList = (EFI_PHYSICAL_ADDRESS)(UINTN)&gHob->EndOfHobList; | |
| } | |
| VOID | |
| PrepareHobCpu ( | |
| VOID | |
| ) | |
| { | |
| UINT32 CpuidEax; | |
| // | |
| // Create a CPU hand-off information | |
| // | |
| gHob->Cpu.SizeOfMemorySpace = 36; | |
| AsmCpuid (EFI_CPUID_EXTENDED_FUNCTION, &CpuidEax, NULL, NULL, NULL); | |
| if (CpuidEax >= CPUID_EXTENDED_ADD_SIZE) { | |
| AsmCpuid (CPUID_EXTENDED_ADD_SIZE, &CpuidEax, NULL, NULL, NULL); | |
| gHob->Cpu.SizeOfMemorySpace = (UINT8)(CpuidEax & 0xFF); | |
| } | |
| } | |
| VOID | |
| CompleteHobGeneration ( | |
| VOID | |
| ) | |
| { | |
| gHob->MemoryAllocation.AllocDescriptor.MemoryBaseAddress = gHob->Phit.EfiFreeMemoryTop; | |
| // | |
| // Reserve all the memory under Stack above FreeMemoryTop as allocated | |
| // | |
| gHob->MemoryAllocation.AllocDescriptor.MemoryLength = gHob->Stack.AllocDescriptor.MemoryBaseAddress - gHob->Phit.EfiFreeMemoryTop; | |
| // | |
| // adjust Above1MB ResourceLength | |
| // | |
| if (gHob->MemoryAbove1MB.PhysicalStart + gHob->MemoryAbove1MB.ResourceLength > gHob->Phit.EfiMemoryTop) { | |
| gHob->MemoryAbove1MB.ResourceLength = gHob->Phit.EfiMemoryTop - gHob->MemoryAbove1MB.PhysicalStart; | |
| } | |
| } | |