//\r
// Go ahead to scan this Fv, and cache FileHandles within it.\r
//\r
- for (PeimCount = 0; PeimCount < PcdGet32 (PcdPeiCoreMaxPeimPerFv); PeimCount++) {\r
+ for (PeimCount = 0; PeimCount < FixedPcdGet32 (PcdPeiCoreMaxPeimPerFv); PeimCount++) {\r
Status = FvPpi->FindFileByType (FvPpi, PEI_CORE_INTERNAL_FFS_FILE_DISPATCH_TYPE, CoreFileHandle->FvHandle, &FileHandle);\r
if (Status != EFI_SUCCESS) {\r
break;\r
// Check whether the count of Peims exceeds the max support PEIMs in a FV image\r
// If more Peims are required in a FV image, PcdPeiCoreMaxPeimPerFv can be set to a larger value in DSC file.\r
//\r
- ASSERT (PeimCount < PcdGet32 (PcdPeiCoreMaxPeimPerFv));\r
+ ASSERT (PeimCount < FixedPcdGet32 (PcdPeiCoreMaxPeimPerFv));\r
\r
//\r
// Get Apriori File handle\r
// defined in DXE Core.\r
//\r
#define MINIMUM_INITIAL_MEMORY_SIZE 0x10000\r
+/**\r
+ This function is to test if the memory range described in resource HOB is available or not. \r
+ \r
+ This function should only be invoked when Loading Module at Fixed Address(LMFA) feature is enabled. Some platform may allocate the \r
+ memory before PeiLoadFixAddressHook in invoked. so this function is to test if the memory range described by the input resource HOB is\r
+ available or not.\r
+\r
+ @param PrivateData Pointer to the private data passed in from caller\r
+ @param ResourceHob Pointer to a resource HOB which described the memory range described by the input resource HOB\r
+**/\r
+BOOLEAN\r
+PeiLoadFixAddressIsMemoryRangeAvailable (\r
+ IN PEI_CORE_INSTANCE *PrivateData,\r
+ IN EFI_HOB_RESOURCE_DESCRIPTOR *ResourceHob\r
+ )\r
+{\r
+ EFI_HOB_MEMORY_ALLOCATION *MemoryHob;\r
+ BOOLEAN IsAvailable;\r
+ EFI_PEI_HOB_POINTERS Hob;\r
+ \r
+ IsAvailable = TRUE;\r
+ if (PrivateData == NULL || ResourceHob == NULL) {\r
+ return FALSE;\r
+ }\r
+ //\r
+ // test if the memory range describe in the HOB is already allocated.\r
+ //\r
+ for (Hob.Raw = PrivateData->HobList.Raw; !END_OF_HOB_LIST(Hob); Hob.Raw = GET_NEXT_HOB(Hob)) {\r
+ // \r
+ // See if this is a memory allocation HOB \r
+ //\r
+ if (GET_HOB_TYPE (Hob) == EFI_HOB_TYPE_MEMORY_ALLOCATION) { \r
+ MemoryHob = Hob.MemoryAllocation;\r
+ if(MemoryHob->AllocDescriptor.MemoryBaseAddress == ResourceHob->PhysicalStart && \r
+ MemoryHob->AllocDescriptor.MemoryBaseAddress + MemoryHob->AllocDescriptor.MemoryLength == ResourceHob->PhysicalStart + ResourceHob->ResourceLength) {\r
+ IsAvailable = FALSE;\r
+ break; \r
+ }\r
+ }\r
+ }\r
+ \r
+ return IsAvailable;\r
+ \r
+}\r
/**\r
Hook function for Loading Module at Fixed Address feature\r
\r
EFI_PEI_HOB_POINTERS NextHob;\r
EFI_PHYSICAL_ADDRESS MaxMemoryBaseAddress;\r
UINT64 MaxMemoryLength;\r
+ EFI_HOB_MEMORY_ALLOCATION *MemoryHob;\r
//\r
// Initialize Local Variables\r
//\r
// \r
TotalReservedMemorySize += PeiMemorySize;\r
\r
- DEBUG ((EFI_D_INFO, "LOADING MODULE FIXED INFO: PcdLoadFixAddressRuntimeCodePageNumber= %x.\n", PcdGet32(PcdLoadFixAddressRuntimeCodePageNumber)));\r
- DEBUG ((EFI_D_INFO, "LOADING MODULE FIXED INFO: PcdLoadFixAddressBootTimeCodePageNumber= %x.\n", PcdGet32(PcdLoadFixAddressBootTimeCodePageNumber)));\r
- DEBUG ((EFI_D_INFO, "LOADING MODULE FIXED INFO: PcdLoadFixAddressPeiCodePageNumber= %x.\n", PcdGet32(PcdLoadFixAddressPeiCodePageNumber))); \r
- DEBUG ((EFI_D_INFO, "LOADING MODULE FIXED INFO: Total Reserved Memory Size = %lx.\n", TotalReservedMemorySize));\r
+ DEBUG ((EFI_D_INFO, "LOADING MODULE FIXED INFO: PcdLoadFixAddressRuntimeCodePageNumber= 0x%x.\n", PcdGet32(PcdLoadFixAddressRuntimeCodePageNumber)));\r
+ DEBUG ((EFI_D_INFO, "LOADING MODULE FIXED INFO: PcdLoadFixAddressBootTimeCodePageNumber= 0x%x.\n", PcdGet32(PcdLoadFixAddressBootTimeCodePageNumber)));\r
+ DEBUG ((EFI_D_INFO, "LOADING MODULE FIXED INFO: PcdLoadFixAddressPeiCodePageNumber= 0x%x.\n", PcdGet32(PcdLoadFixAddressPeiCodePageNumber))); \r
+ DEBUG ((EFI_D_INFO, "LOADING MODULE FIXED INFO: Total Reserved Memory Size = 0x%lx.\n", TotalReservedMemorySize));\r
//\r
// Loop through the system memory typed hob to merge the adjacent memory range \r
//\r
}\r
} \r
}\r
+ //\r
+ // Some platform is already allocated pages before the HOB re-org. Here to build dedicated resource HOB to describe\r
+ // the allocated memory range\r
+ //\r
+ for (Hob.Raw = PrivateData->HobList.Raw; !END_OF_HOB_LIST(Hob); Hob.Raw = GET_NEXT_HOB(Hob)) {\r
+ // \r
+ // See if this is a memory allocation HOB \r
+ //\r
+ if (GET_HOB_TYPE (Hob) == EFI_HOB_TYPE_MEMORY_ALLOCATION) {\r
+ MemoryHob = Hob.MemoryAllocation;\r
+ for (NextHob.Raw = PrivateData->HobList.Raw; !END_OF_HOB_LIST(NextHob); NextHob.Raw = GET_NEXT_HOB(NextHob)) {\r
+ //\r
+ // See if this is a resource descriptor HOB\r
+ //\r
+ if (GET_HOB_TYPE (NextHob) == EFI_HOB_TYPE_RESOURCE_DESCRIPTOR) {\r
+ NextResourceHob = NextHob.ResourceDescriptor;\r
+ //\r
+ // If range described in this hob is not system memory or heigher than MAX_ADDRESS, ignored.\r
+ //\r
+ if (NextResourceHob->ResourceType == EFI_RESOURCE_SYSTEM_MEMORY && NextResourceHob->PhysicalStart + NextResourceHob->ResourceLength > MAX_ADDRESS) {\r
+ continue;\r
+ }\r
+ //\r
+ // If the range describe in memory allocation HOB belongs to the memroy range described by the resource hob\r
+ // \r
+ if (MemoryHob->AllocDescriptor.MemoryBaseAddress >= NextResourceHob->PhysicalStart && \r
+ MemoryHob->AllocDescriptor.MemoryBaseAddress + MemoryHob->AllocDescriptor.MemoryLength <= NextResourceHob->PhysicalStart + NextResourceHob->ResourceLength) {\r
+ //\r
+ // Build seperate resource hob for this allocated range\r
+ // \r
+ if (MemoryHob->AllocDescriptor.MemoryBaseAddress > NextResourceHob->PhysicalStart) {\r
+ BuildResourceDescriptorHob (\r
+ EFI_RESOURCE_SYSTEM_MEMORY, \r
+ NextResourceHob->ResourceAttribute,\r
+ NextResourceHob->PhysicalStart, \r
+ (MemoryHob->AllocDescriptor.MemoryBaseAddress - NextResourceHob->PhysicalStart) \r
+ );\r
+ }\r
+ if (MemoryHob->AllocDescriptor.MemoryBaseAddress + MemoryHob->AllocDescriptor.MemoryLength < NextResourceHob->PhysicalStart + NextResourceHob->ResourceLength) {\r
+ BuildResourceDescriptorHob (\r
+ EFI_RESOURCE_SYSTEM_MEMORY, \r
+ NextResourceHob->ResourceAttribute,\r
+ MemoryHob->AllocDescriptor.MemoryBaseAddress + MemoryHob->AllocDescriptor.MemoryLength, \r
+ (NextResourceHob->PhysicalStart + NextResourceHob->ResourceLength -(MemoryHob->AllocDescriptor.MemoryBaseAddress + MemoryHob->AllocDescriptor.MemoryLength)) \r
+ );\r
+ }\r
+ NextResourceHob->PhysicalStart = MemoryHob->AllocDescriptor.MemoryBaseAddress;\r
+ NextResourceHob->ResourceLength = MemoryHob->AllocDescriptor.MemoryLength;\r
+ break;\r
+ }\r
+ }\r
+ }\r
+ }\r
+ }\r
+\r
//\r
// Try to find and validate the TOP address.\r
// \r
- if ((INT64)FixedPcdGet64(PcdLoadModuleAtFixAddressEnable) > 0 ) {\r
+ if ((INT64)PcdGet64(PcdLoadModuleAtFixAddressEnable) > 0 ) {\r
//\r
// The LMFA feature is enabled as load module at fixed absolute address.\r
//\r
- TopLoadingAddress = (EFI_PHYSICAL_ADDRESS)FixedPcdGet64(PcdLoadModuleAtFixAddressEnable);\r
+ TopLoadingAddress = (EFI_PHYSICAL_ADDRESS)PcdGet64(PcdLoadModuleAtFixAddressEnable);\r
DEBUG ((EFI_D_INFO, "LOADING MODULE FIXED INFO: Loading module at fixed absolute address.\n"));\r
//\r
// validate the Address. Loop the resource descriptor HOB to make sure the address is in valid memory range\r
//\r
if ((TopLoadingAddress & EFI_PAGE_MASK) != 0) {\r
- DEBUG ((EFI_D_INFO, "LOADING MODULE FIXED ERROR:Top Address %lx is invalid since top address should be page align. \n", TopLoadingAddress)); \r
+ DEBUG ((EFI_D_INFO, "LOADING MODULE FIXED ERROR:Top Address 0x%lx is invalid since top address should be page align. \n", TopLoadingAddress)); \r
ASSERT (FALSE); \r
}\r
//\r
// See if Top address specified by user is valid.\r
//\r
if (ResourceHob->PhysicalStart + TotalReservedMemorySize < TopLoadingAddress && \r
- (ResourceHob->PhysicalStart + ResourceHob->ResourceLength - MINIMUM_INITIAL_MEMORY_SIZE) >= TopLoadingAddress) {\r
+ (ResourceHob->PhysicalStart + ResourceHob->ResourceLength - MINIMUM_INITIAL_MEMORY_SIZE) >= TopLoadingAddress && \r
+ PeiLoadFixAddressIsMemoryRangeAvailable(PrivateData, ResourceHob)) {\r
CurrentResourceHob = ResourceHob; \r
CurrentHob = Hob;\r
break;\r
- }\r
+ }\r
}\r
} \r
} \r
if (CurrentResourceHob != NULL) {\r
- DEBUG ((EFI_D_INFO, "LOADING MODULE FIXED INFO:Top Address %lx is valid \n", TopLoadingAddress));\r
+ DEBUG ((EFI_D_INFO, "LOADING MODULE FIXED INFO:Top Address 0x%lx is valid \n", TopLoadingAddress));\r
TopLoadingAddress += MINIMUM_INITIAL_MEMORY_SIZE; \r
} else {\r
- DEBUG ((EFI_D_INFO, "LOADING MODULE FIXED ERROR:Top Address %lx is invalid \n", TopLoadingAddress)); \r
+ DEBUG ((EFI_D_INFO, "LOADING MODULE FIXED ERROR:Top Address 0x%lx is invalid \n", TopLoadingAddress)); \r
DEBUG ((EFI_D_INFO, "LOADING MODULE FIXED ERROR:The recommended Top Address for the platform is: \n")); \r
//\r
// Print the recomended Top address range.\r
//\r
// See if Top address specified by user is valid.\r
//\r
- if (ResourceHob->ResourceLength > TotalReservedMemorySize) {\r
- DEBUG ((EFI_D_INFO, "(%lx, %lx)\n", \r
+ if (ResourceHob->ResourceLength > TotalReservedMemorySize && PeiLoadFixAddressIsMemoryRangeAvailable(PrivateData, ResourceHob)) {\r
+ DEBUG ((EFI_D_INFO, "(0x%lx, 0x%lx)\n", \r
(ResourceHob->PhysicalStart + TotalReservedMemorySize -MINIMUM_INITIAL_MEMORY_SIZE), \r
(ResourceHob->PhysicalStart + ResourceHob->ResourceLength -MINIMUM_INITIAL_MEMORY_SIZE) \r
)); \r
//\r
// Assert here \r
//\r
- ASSERT (FALSE); \r
+ ASSERT (FALSE); \r
+ return; \r
} \r
} else {\r
//\r
//\r
if (ResourceHob->ResourceType == EFI_RESOURCE_SYSTEM_MEMORY && \r
ResourceHob->PhysicalStart + ResourceHob->ResourceLength <= MAX_ADDRESS &&\r
- ResourceHob->ResourceLength > TotalReservedMemorySize) {\r
+ ResourceHob->ResourceLength > TotalReservedMemorySize && PeiLoadFixAddressIsMemoryRangeAvailable(PrivateData, ResourceHob)) {\r
//\r
// See if this is the highest largest system memory region below MaxAddress\r
//\r
//\r
// Assert here \r
//\r
- ASSERT (FALSE); \r
+ ASSERT (FALSE);\r
+ return; \r
} else {\r
TopLoadingAddress = CurrentResourceHob->PhysicalStart + CurrentResourceHob->ResourceLength ; \r
} \r
\r
if (CurrentResourceHob != NULL) {\r
//\r
- // rebuild hob for PEI memmory and reserved memory\r
+ // rebuild resource HOB for PEI memmory and reserved memory\r
//\r
BuildResourceDescriptorHob (\r
- EFI_RESOURCE_SYSTEM_MEMORY, // MemoryType,\r
+ EFI_RESOURCE_SYSTEM_MEMORY, \r
(\r
EFI_RESOURCE_ATTRIBUTE_PRESENT |\r
EFI_RESOURCE_ATTRIBUTE_INITIALIZED |\r
EFI_RESOURCE_ATTRIBUTE_WRITE_THROUGH_CACHEABLE |\r
EFI_RESOURCE_ATTRIBUTE_WRITE_BACK_CACHEABLE\r
),\r
- (TopLoadingAddress - TotalReservedMemorySize), // MemoryBegin\r
- TotalReservedMemorySize // MemoryLength\r
+ (TopLoadingAddress - TotalReservedMemorySize), \r
+ TotalReservedMemorySize \r
);\r
//\r
- // rebuild hob for the remain memory if necessary\r
+ // rebuild resource for the remain memory if necessary\r
//\r
if (CurrentResourceHob->PhysicalStart < TopLoadingAddress - TotalReservedMemorySize) {\r
BuildResourceDescriptorHob (\r
- EFI_RESOURCE_SYSTEM_MEMORY, // MemoryType,\r
+ EFI_RESOURCE_SYSTEM_MEMORY, \r
(\r
EFI_RESOURCE_ATTRIBUTE_PRESENT |\r
EFI_RESOURCE_ATTRIBUTE_INITIALIZED |\r
EFI_RESOURCE_ATTRIBUTE_WRITE_THROUGH_CACHEABLE |\r
EFI_RESOURCE_ATTRIBUTE_WRITE_BACK_CACHEABLE\r
),\r
- CurrentResourceHob->PhysicalStart, // MemoryBegin\r
- (TopLoadingAddress - TotalReservedMemorySize - CurrentResourceHob->PhysicalStart) // MemoryLength\r
+ CurrentResourceHob->PhysicalStart, \r
+ (TopLoadingAddress - TotalReservedMemorySize - CurrentResourceHob->PhysicalStart) \r
);\r
}\r
if (CurrentResourceHob->PhysicalStart + CurrentResourceHob->ResourceLength > TopLoadingAddress ) {\r
// Cache the top address for Loading Module at Fixed Address feature\r
//\r
PrivateData->LoadModuleAtFixAddressTopAddress = TopLoadingAddress - MINIMUM_INITIAL_MEMORY_SIZE;\r
- DEBUG ((EFI_D_INFO, "LOADING MODULE FIXED INFO: Top address = %lx\n", PrivateData->LoadModuleAtFixAddressTopAddress)); \r
+ DEBUG ((EFI_D_INFO, "LOADING MODULE FIXED INFO: Top address = 0x%lx\n", PrivateData->LoadModuleAtFixAddressTopAddress)); \r
//\r
// reinstall the PEI memory relative to TopLoadingAddress\r
//\r
PEI_CORE_FV_HANDLE *CoreFvHandle;\r
VOID *LoadFixPeiCodeBegin;\r
\r
- PeiServices = (CONST EFI_PEI_SERVICES **) &Private->PS;\r
+ PeiServices = (CONST EFI_PEI_SERVICES **) &Private->Ps;\r
PeimEntryPoint = NULL;\r
PeimFileHandle = NULL;\r
EntryPoint = 0;\r
SaveCurrentFileHandle = Private->CurrentFileHandle;\r
\r
for (Index1 = 0; Index1 <= SaveCurrentFvCount; Index1++) {\r
- for (Index2 = 0; (Index2 < PcdGet32 (PcdPeiCoreMaxPeimPerFv)) && (Private->Fv[Index1].FvFileHandles[Index2] != NULL); Index2++) {\r
+ for (Index2 = 0; (Index2 < FixedPcdGet32 (PcdPeiCoreMaxPeimPerFv)) && (Private->Fv[Index1].FvFileHandles[Index2] != NULL); Index2++) {\r
if (Private->Fv[Index1].PeimState[Index2] == PEIM_STATE_REGISITER_FOR_SHADOW) {\r
PeimFileHandle = Private->Fv[Index1].FvFileHandles[Index2];\r
Status = PeiLoadImage (\r
- (CONST EFI_PEI_SERVICES **) &Private->PS,\r
+ (CONST EFI_PEI_SERVICES **) &Private->Ps,\r
PeimFileHandle,\r
PEIM_STATE_REGISITER_FOR_SHADOW,\r
&EntryPoint,\r
PeimEntryPoint = (EFI_PEIM_ENTRY_POINT2)(UINTN)EntryPoint;\r
\r
PERF_START (PeimFileHandle, "PEIM", NULL, 0);\r
- PeimEntryPoint(PeimFileHandle, (const EFI_PEI_SERVICES **) &Private->PS);\r
+ PeimEntryPoint(PeimFileHandle, (const EFI_PEI_SERVICES **) &Private->Ps);\r
PERF_END (PeimFileHandle, "PEIM", NULL, 0);\r
}\r
\r
// Start to dispatch all modules within the current Fv.\r
//\r
for (PeimCount = Private->CurrentPeimCount;\r
- (PeimCount < PcdGet32 (PcdPeiCoreMaxPeimPerFv)) && (Private->CurrentFvFileHandles[PeimCount] != NULL);\r
+ (PeimCount < FixedPcdGet32 (PcdPeiCoreMaxPeimPerFv)) && (Private->CurrentFvFileHandles[PeimCount] != NULL);\r
PeimCount++) {\r
Private->CurrentPeimCount = PeimCount;\r
PeimFileHandle = Private->CurrentFileHandle = Private->CurrentFvFileHandles[PeimCount];\r
));\r
DEBUG_CODE_END ();\r
\r
- if (FixedPcdGet64(PcdLoadModuleAtFixAddressEnable) != 0) {\r
+ if (PcdGet64(PcdLoadModuleAtFixAddressEnable) != 0 && (Private->HobList.HandoffInformationTable->BootMode != BOOT_ON_S3_RESUME)) {\r
//\r
// Loading Module at Fixed Address is enabled\r
//\r
PeiLoadFixAddressHook(Private);\r
+ //\r
+ // if Loading Module at Fixed Address is enabled, Allocating memory range for Pei code range.\r
+ //\r
+ LoadFixPeiCodeBegin = AllocatePages((UINTN)PcdGet32(PcdLoadFixAddressPeiCodePageNumber));\r
+ DEBUG ((EFI_D_INFO, "LOADING MODULE FIXED INFO: PeiCodeBegin = 0x%lX, PeiCodeTop= 0x%lX\n", (UINT64)(UINTN)LoadFixPeiCodeBegin, (UINT64)((UINTN)LoadFixPeiCodeBegin + PcdGet32(PcdLoadFixAddressPeiCodePageNumber) * EFI_PAGE_SIZE)));\r
}\r
\r
//\r
//\r
// Fixup the PeiCore's private data\r
//\r
- PrivateInMem->PS = &PrivateInMem->ServiceTableShadow;\r
+ PrivateInMem->Ps = &PrivateInMem->ServiceTableShadow;\r
PrivateInMem->CpuIo = &PrivateInMem->ServiceTableShadow.CpuIo;\r
PrivateInMem->HobList.Raw = (VOID*) ((UINTN) PrivateInMem->HobList.Raw + HeapOffset);\r
PrivateInMem->StackBase = (EFI_PHYSICAL_ADDRESS)(((UINTN)PrivateInMem->PhysicalMemoryBegin + EFI_PAGE_MASK) & ~EFI_PAGE_MASK);\r
\r
- PeiServices = (CONST EFI_PEI_SERVICES **) &PrivateInMem->PS;\r
+ PeiServices = (CONST EFI_PEI_SERVICES **) &PrivateInMem->Ps;\r
\r
//\r
// Fixup for PeiService's address\r
//\r
PrivateInMem->PeimDispatcherReenter = TRUE;\r
\r
- if (FixedPcdGet64(PcdLoadModuleAtFixAddressEnable) != 0) {\r
- //\r
- // if Loading Module at Fixed Address is enabled, This is the first invoke to page \r
- // allocation for Pei Core segment. This memory segment should be reserved for loading PEIM\r
- //\r
- LoadFixPeiCodeBegin = AllocatePages((UINTN)PcdGet32(PcdLoadFixAddressPeiCodePageNumber));\r
- DEBUG ((EFI_D_INFO, "LOADING MODULE FIXED INFO: PeiCodeBegin = %x, PeiCodeTop= %x\n", (UINTN)LoadFixPeiCodeBegin, ((UINTN)LoadFixPeiCodeBegin) + PcdGet32(PcdLoadFixAddressPeiCodePageNumber) * EFI_PAGE_SIZE)); \r
+ if (PcdGet64(PcdLoadModuleAtFixAddressEnable) != 0 && (PrivateInMem->HobList.HandoffInformationTable->BootMode != BOOT_ON_S3_RESUME)) {\r
//\r
// if Loading Module at Fixed Address is enabled, allocate the PEI code memory range usage bit map array.\r
- // Every bit in the array indicate the status of the corresponding memory page, available or not\r
+ // Every bit in the array indicate the status of the corresponding memory page available or not\r
//\r
PrivateInMem->PeiCodeMemoryRangeUsageBitMap = AllocateZeroPool (((PcdGet32(PcdLoadFixAddressPeiCodePageNumber)>>6) + 1)*sizeof(UINT64));\r
}\r
//\r
// Evaluate a given DEPEX\r
//\r
- return PeimDispatchReadiness (&Private->PS, DepexData);\r
+ return PeimDispatchReadiness (&Private->Ps, DepexData);\r
}\r
\r
/**\r