The GCD services are used to manage the memory and I/O regions that\r
are accessible to the CPU that is executing the DXE core.\r
\r
-Copyright (c) 2006 - 2008, Intel Corporation. <BR>\r
-All rights reserved. This program and the accompanying materials\r
+Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>\r
+This program and the accompanying materials\r
are licensed and made available under the terms and conditions of the BSD License\r
which accompanies this distribution. The full text of the license may be found at\r
http://opensource.org/licenses/bsd-license.php\r
{ EFI_RESOURCE_ATTRIBUTE_WRITE_COMBINEABLE, EFI_MEMORY_WC, TRUE },\r
{ EFI_RESOURCE_ATTRIBUTE_WRITE_THROUGH_CACHEABLE, EFI_MEMORY_WT, TRUE },\r
{ EFI_RESOURCE_ATTRIBUTE_WRITE_BACK_CACHEABLE, EFI_MEMORY_WB, TRUE },\r
- { EFI_RESOURCE_ATTRIBUTE_READ_PROTECTED, EFI_MEMORY_RP, TRUE },\r
- { EFI_RESOURCE_ATTRIBUTE_WRITE_PROTECTED, EFI_MEMORY_WP, TRUE },\r
- { EFI_RESOURCE_ATTRIBUTE_EXECUTION_PROTECTED, EFI_MEMORY_XP, TRUE },\r
+ { EFI_RESOURCE_ATTRIBUTE_READ_PROTECTABLE, EFI_MEMORY_RP, TRUE },\r
+ { EFI_RESOURCE_ATTRIBUTE_WRITE_PROTECTABLE, EFI_MEMORY_WP, TRUE },\r
+ { EFI_RESOURCE_ATTRIBUTE_EXECUTION_PROTECTABLE, EFI_MEMORY_XP, TRUE },\r
{ EFI_RESOURCE_ATTRIBUTE_PRESENT, EFI_MEMORY_PRESENT, FALSE },\r
{ EFI_RESOURCE_ATTRIBUTE_INITIALIZED, EFI_MEMORY_INITIALIZED, FALSE },\r
{ EFI_RESOURCE_ATTRIBUTE_TESTED, EFI_MEMORY_TESTED, FALSE },\r
{ 0, 0, FALSE }\r
};\r
\r
+///\r
+/// Lookup table used to print GCD Memory Space Map\r
+///\r
+GLOBAL_REMOVE_IF_UNREFERENCED CONST CHAR8 *mGcdMemoryTypeNames[] = {\r
+ "NonExist ", // EfiGcdMemoryTypeNonExistent\r
+ "Reserved ", // EfiGcdMemoryTypeReserved\r
+ "SystemMem", // EfiGcdMemoryTypeSystemMemory\r
+ "MMIO ", // EfiGcdMemoryTypeMemoryMappedIo\r
+ "Unknown " // EfiGcdMemoryTypeMaximum\r
+};\r
+\r
+///\r
+/// Lookup table used to print GCD I/O Space Map\r
+///\r
+GLOBAL_REMOVE_IF_UNREFERENCED CONST CHAR8 *mGcdIoTypeNames[] = {\r
+ "NonExist", // EfiGcdIoTypeNonExistent\r
+ "Reserved", // EfiGcdIoTypeReserved\r
+ "I/O ", // EfiGcdIoTypeIo\r
+ "Unknown " // EfiGcdIoTypeMaximum \r
+};\r
+\r
+///\r
+/// Lookup table used to print GCD Allocation Types\r
+///\r
+GLOBAL_REMOVE_IF_UNREFERENCED CONST CHAR8 *mGcdAllocationTypeNames[] = {\r
+ "AnySearchBottomUp ", // EfiGcdAllocateAnySearchBottomUp\r
+ "MaxAddressSearchBottomUp ", // EfiGcdAllocateMaxAddressSearchBottomUp\r
+ "AtAddress ", // EfiGcdAllocateAddress\r
+ "AnySearchTopDown ", // EfiGcdAllocateAnySearchTopDown\r
+ "MaxAddressSearchTopDown ", // EfiGcdAllocateMaxAddressSearchTopDown\r
+ "Unknown " // EfiGcdMaxAllocateType\r
+};\r
+\r
+/**\r
+ Dump the entire contents if the GCD Memory Space Map using DEBUG() macros when\r
+ PcdDebugPrintErrorLevel has the DEBUG_GCD bit set.\r
+\r
+ @param InitialMap TRUE if the initial GCD Memory Map is being dumped. Otherwise, FALSE.\r
+ \r
+**/\r
+VOID\r
+EFIAPI\r
+CoreDumpGcdMemorySpaceMap (\r
+ BOOLEAN InitialMap\r
+ )\r
+{\r
+ DEBUG_CODE (\r
+ EFI_STATUS Status;\r
+ UINTN NumberOfDescriptors;\r
+ EFI_GCD_MEMORY_SPACE_DESCRIPTOR *MemorySpaceMap;\r
+ UINTN Index;\r
+ \r
+ Status = CoreGetMemorySpaceMap (&NumberOfDescriptors, &MemorySpaceMap);\r
+ ASSERT_EFI_ERROR (Status);\r
+\r
+ if (InitialMap) {\r
+ DEBUG ((DEBUG_GCD, "GCD:Initial GCD Memory Space Map\n"));\r
+ }\r
+ DEBUG ((DEBUG_GCD, "GCDMemType Range Capabilities Attributes \n"));\r
+ DEBUG ((DEBUG_GCD, "========== ================================= ================ ================\n"));\r
+ for (Index = 0; Index < NumberOfDescriptors; Index++) {\r
+ DEBUG ((DEBUG_GCD, "%a %016lx-%016lx %016lx %016lx%c\n", \r
+ mGcdMemoryTypeNames[MIN (MemorySpaceMap[Index].GcdMemoryType, EfiGcdMemoryTypeMaximum)],\r
+ MemorySpaceMap[Index].BaseAddress, \r
+ MemorySpaceMap[Index].BaseAddress + MemorySpaceMap[Index].Length - 1,\r
+ MemorySpaceMap[Index].Capabilities, \r
+ MemorySpaceMap[Index].Attributes,\r
+ MemorySpaceMap[Index].ImageHandle == NULL ? ' ' : '*'\r
+ ));\r
+ }\r
+ DEBUG ((DEBUG_GCD, "\n"));\r
+ FreePool (MemorySpaceMap);\r
+ );\r
+}\r
+\r
+/**\r
+ Dump the entire contents if the GCD I/O Space Map using DEBUG() macros when \r
+ PcdDebugPrintErrorLevel has the DEBUG_GCD bit set.\r
+\r
+ @param InitialMap TRUE if the initial GCD I/O Map is being dumped. Otherwise, FALSE.\r
+ \r
+**/\r
+VOID\r
+EFIAPI\r
+CoreDumpGcdIoSpaceMap (\r
+ BOOLEAN InitialMap\r
+ )\r
+{\r
+ DEBUG_CODE (\r
+ EFI_STATUS Status;\r
+ UINTN NumberOfDescriptors;\r
+ EFI_GCD_IO_SPACE_DESCRIPTOR *IoSpaceMap;\r
+ UINTN Index;\r
+ \r
+ Status = CoreGetIoSpaceMap (&NumberOfDescriptors, &IoSpaceMap);\r
+ ASSERT_EFI_ERROR (Status);\r
+ \r
+ if (InitialMap) {\r
+ DEBUG ((DEBUG_GCD, "GCD:Initial GCD I/O Space Map\n"));\r
+ } \r
+ \r
+ DEBUG ((DEBUG_GCD, "GCDIoType Range \n"));\r
+ DEBUG ((DEBUG_GCD, "========== =================================\n"));\r
+ for (Index = 0; Index < NumberOfDescriptors; Index++) {\r
+ DEBUG ((DEBUG_GCD, "%a %016lx-%016lx%c\n", \r
+ mGcdIoTypeNames[MIN (IoSpaceMap[Index].GcdIoType, EfiGcdIoTypeMaximum)],\r
+ IoSpaceMap[Index].BaseAddress, \r
+ IoSpaceMap[Index].BaseAddress + IoSpaceMap[Index].Length - 1,\r
+ IoSpaceMap[Index].ImageHandle == NULL ? ' ' : '*'\r
+ ));\r
+ }\r
+ DEBUG ((DEBUG_GCD, "\n"));\r
+ FreePool (IoSpaceMap);\r
+ );\r
+}\r
+ \r
+/**\r
+ Validate resource descriptor HOB's attributes.\r
+\r
+ If Attributes includes some memory resource's settings, it should include \r
+ the corresponding capabilites also.\r
+\r
+ @param Attributes Resource descriptor HOB attributes.\r
+\r
+**/\r
+VOID\r
+CoreValidateResourceDescriptorHobAttributes (\r
+ IN UINT64 Attributes\r
+ )\r
+{\r
+ ASSERT (((Attributes & EFI_RESOURCE_ATTRIBUTE_READ_PROTECTED) == 0) ||\r
+ ((Attributes & EFI_RESOURCE_ATTRIBUTE_READ_PROTECTABLE) != 0));\r
+ ASSERT (((Attributes & EFI_RESOURCE_ATTRIBUTE_WRITE_PROTECTED) == 0) ||\r
+ ((Attributes & EFI_RESOURCE_ATTRIBUTE_WRITE_PROTECTABLE) != 0));\r
+ ASSERT (((Attributes & EFI_RESOURCE_ATTRIBUTE_EXECUTION_PROTECTED) == 0) ||\r
+ ((Attributes & EFI_RESOURCE_ATTRIBUTE_EXECUTION_PROTECTABLE) != 0));\r
+}\r
\r
/**\r
Acquire memory lock on mGcdMemorySpaceLock.\r
)\r
{\r
ASSERT (Length != 0);\r
- ASSERT (TopEntry->Signature == 0);\r
- ASSERT (BottomEntry->Signature == 0);\r
\r
if (BaseAddress > Entry->BaseAddress) {\r
+ ASSERT (BottomEntry->Signature == 0);\r
+\r
CopyMem (BottomEntry, Entry, sizeof (EFI_GCD_MAP_ENTRY));\r
Entry->BaseAddress = BaseAddress;\r
BottomEntry->EndAddress = BaseAddress - 1;\r
}\r
\r
if ((BaseAddress + Length - 1) < Entry->EndAddress) {\r
+ ASSERT (TopEntry->Signature == 0);\r
+\r
CopyMem (TopEntry, Entry, sizeof (EFI_GCD_MAP_ENTRY));\r
TopEntry->BaseAddress = BaseAddress + Length;\r
Entry->EndAddress = BaseAddress + Length - 1;\r
EFI_GCD_MAP_ENTRY *BottomEntry;\r
LIST_ENTRY *StartLink;\r
LIST_ENTRY *EndLink;\r
-\r
- EFI_CPU_ARCH_PROTOCOL *CpuArch;\r
- UINT64 CpuArchAttributes;\r
+ UINT64 CpuArchAttributes;\r
\r
if (Length == 0) {\r
+ DEBUG ((DEBUG_GCD, " Status = %r\n", EFI_INVALID_PARAMETER));\r
return EFI_INVALID_PARAMETER;\r
}\r
\r
\r
goto Done;\r
}\r
+ ASSERT (StartLink != NULL && EndLink != NULL);\r
\r
//\r
// Verify that the list of descriptors are unallocated non-existent memory.\r
Status = EFI_OUT_OF_RESOURCES;\r
goto Done;\r
}\r
+ ASSERT (TopEntry != NULL && BottomEntry != NULL);\r
\r
if (Operation == GCD_SET_ATTRIBUTES_MEMORY_OPERATION) {\r
//\r
// Call CPU Arch Protocol to attempt to set attributes on the range\r
//\r
CpuArchAttributes = ConverToCpuArchAttributes (Attributes);\r
- if ( CpuArchAttributes != INVALID_CPU_ARCH_ATTRIBUTES ) {\r
- Status = CoreLocateProtocol (&gEfiCpuArchProtocolGuid, NULL, (VOID **)&CpuArch);\r
- if (EFI_ERROR (Status)) {\r
- Status = EFI_ACCESS_DENIED;\r
- goto Done;\r
- }\r
-\r
- Status = CpuArch->SetMemoryAttributes (\r
- CpuArch,\r
- BaseAddress,\r
- Length,\r
- CpuArchAttributes\r
- );\r
- if (EFI_ERROR (Status)) {\r
- goto Done;\r
+ if (CpuArchAttributes != INVALID_CPU_ARCH_ATTRIBUTES) {\r
+ if (gCpu != NULL) {\r
+ Status = gCpu->SetMemoryAttributes (\r
+ gCpu,\r
+ BaseAddress,\r
+ Length,\r
+ CpuArchAttributes\r
+ );\r
+ if (EFI_ERROR (Status)) {\r
+ goto Done;\r
+ }\r
}\r
}\r
-\r
}\r
\r
//\r
Status = CoreCleanupGcdMapEntry (TopEntry, BottomEntry, StartLink, EndLink, Map);\r
\r
Done:\r
+ DEBUG ((DEBUG_GCD, " Status = %r\n", Status));\r
+\r
if ((Operation & GCD_MEMORY_SPACE_OPERATION) != 0) {\r
CoreReleaseGcdMemoryLock ();\r
+ CoreDumpGcdMemorySpaceMap (FALSE);\r
}\r
if ((Operation & GCD_IO_SPACE_OPERATION) != 0) {\r
CoreReleaseGcdIoLock ();\r
+ CoreDumpGcdIoSpaceMap (FALSE);\r
}\r
\r
return Status;\r
// Make sure parameters are valid\r
//\r
if (GcdAllocateType < 0 || GcdAllocateType >= EfiGcdMaxAllocateType) {\r
+ DEBUG ((DEBUG_GCD, " Status = %r\n", EFI_INVALID_PARAMETER));\r
return EFI_INVALID_PARAMETER;\r
}\r
if (GcdMemoryType < 0 || GcdMemoryType >= EfiGcdMemoryTypeMaximum) {\r
+ DEBUG ((DEBUG_GCD, " Status = %r\n", EFI_INVALID_PARAMETER));\r
return EFI_INVALID_PARAMETER;\r
}\r
if (GcdIoType < 0 || GcdIoType >= EfiGcdIoTypeMaximum) {\r
+ DEBUG ((DEBUG_GCD, " Status = %r\n", EFI_INVALID_PARAMETER));\r
return EFI_INVALID_PARAMETER;\r
}\r
if (BaseAddress == NULL) {\r
+ DEBUG ((DEBUG_GCD, " Status = %r\n", EFI_INVALID_PARAMETER));\r
return EFI_INVALID_PARAMETER;\r
}\r
if (ImageHandle == NULL) {\r
+ DEBUG ((DEBUG_GCD, " Status = %r\n", EFI_INVALID_PARAMETER));\r
return EFI_INVALID_PARAMETER;\r
}\r
if (Alignment >= 64) {\r
+ DEBUG ((DEBUG_GCD, " Status = %r\n", EFI_NOT_FOUND));\r
return EFI_NOT_FOUND;\r
}\r
if (Length == 0) {\r
+ DEBUG ((DEBUG_GCD, " Status = %r\n", EFI_INVALID_PARAMETER));\r
return EFI_INVALID_PARAMETER;\r
}\r
\r
Status = EFI_NOT_FOUND;\r
goto Done;\r
}\r
+ ASSERT (StartLink != NULL && EndLink != NULL);\r
\r
//\r
// Verify that the list of descriptors are unallocated memory matching GcdMemoryType.\r
Status = EFI_NOT_FOUND;\r
goto Done;\r
}\r
+ ASSERT (StartLink != NULL && EndLink != NULL);\r
\r
Link = StartLink;\r
//\r
Status = EFI_OUT_OF_RESOURCES;\r
goto Done;\r
}\r
+ ASSERT (TopEntry != NULL && BottomEntry != NULL);\r
\r
//\r
// Convert/Insert the list of descriptors from StartLink to EndLink\r
Status = CoreCleanupGcdMapEntry (TopEntry, BottomEntry, StartLink, EndLink, Map);\r
\r
Done:\r
+ DEBUG ((DEBUG_GCD, " Status = %r", Status));\r
+ if (!EFI_ERROR (Status)) {\r
+ DEBUG ((DEBUG_GCD, " (BaseAddress = %016lx)", *BaseAddress));\r
+ }\r
+ DEBUG ((DEBUG_GCD, "\n"));\r
+ \r
if ((Operation & GCD_MEMORY_SPACE_OPERATION) != 0) {\r
CoreReleaseGcdMemoryLock ();\r
+ CoreDumpGcdMemorySpaceMap (FALSE);\r
}\r
if ((Operation & GCD_IO_SPACE_OPERATION) !=0) {\r
CoreReleaseGcdIoLock ();\r
+ CoreDumpGcdIoSpaceMap (FALSE);\r
}\r
\r
return Status;\r
IN UINT64 Capabilities\r
)\r
{\r
+ DEBUG ((DEBUG_GCD, "GCD:AddMemorySpace(Base=%016lx,Length=%016lx)\n", BaseAddress, Length));\r
+ DEBUG ((DEBUG_GCD, " GcdMemoryType = %a\n", mGcdMemoryTypeNames[MIN (GcdMemoryType, EfiGcdMemoryTypeMaximum)]));\r
+ DEBUG ((DEBUG_GCD, " Capabilities = %016lx\n", Capabilities));\r
+\r
//\r
// Make sure parameters are valid\r
//\r
IN EFI_HANDLE DeviceHandle OPTIONAL\r
)\r
{\r
+ DEBUG ((DEBUG_GCD, "GCD:AllocateMemorySpace(Base=%016lx,Length=%016lx)\n", *BaseAddress, Length));\r
+ DEBUG ((DEBUG_GCD, " GcdAllocateType = %a\n", mGcdAllocationTypeNames[MIN (GcdAllocateType, EfiGcdMaxAllocateType)]));\r
+ DEBUG ((DEBUG_GCD, " GcdMemoryType = %a\n", mGcdMemoryTypeNames[MIN (GcdMemoryType, EfiGcdMemoryTypeMaximum)]));\r
+ DEBUG ((DEBUG_GCD, " Alignment = %016lx\n", LShiftU64 (1, Alignment)));\r
+ DEBUG ((DEBUG_GCD, " ImageHandle = %p\n", ImageHandle));\r
+ DEBUG ((DEBUG_GCD, " DeviceHandle = %p\n", DeviceHandle));\r
+ \r
return CoreAllocateSpace (\r
GCD_ALLOCATE_MEMORY_OPERATION,\r
GcdAllocateType,\r
IN UINT64 Length\r
)\r
{\r
+ DEBUG ((DEBUG_GCD, "GCD:FreeMemorySpace(Base=%016lx,Length=%016lx)\n", BaseAddress, Length));\r
+\r
return CoreConvertSpace (GCD_FREE_MEMORY_OPERATION, (EFI_GCD_MEMORY_TYPE) 0, (EFI_GCD_IO_TYPE) 0, BaseAddress, Length, 0, 0);\r
}\r
\r
IN UINT64 Length\r
)\r
{\r
+ DEBUG ((DEBUG_GCD, "GCD:RemoveMemorySpace(Base=%016lx,Length=%016lx)\n", BaseAddress, Length));\r
+ \r
return CoreConvertSpace (GCD_REMOVE_MEMORY_OPERATION, (EFI_GCD_MEMORY_TYPE) 0, (EFI_GCD_IO_TYPE) 0, BaseAddress, Length, 0, 0);\r
}\r
\r
if (EFI_ERROR (Status)) {\r
Status = EFI_NOT_FOUND;\r
} else {\r
+ ASSERT (StartLink != NULL && EndLink != NULL);\r
//\r
// Copy the contents of the found descriptor into Descriptor\r
//\r
IN UINT64 Attributes\r
)\r
{\r
+ DEBUG ((DEBUG_GCD, "GCD:SetMemorySpaceAttributes(Base=%016lx,Length=%016lx)\n", BaseAddress, Length));\r
+ DEBUG ((DEBUG_GCD, " Attributes = %016lx\n", Attributes));\r
+\r
return CoreConvertSpace (GCD_SET_ATTRIBUTES_MEMORY_OPERATION, (EFI_GCD_MEMORY_TYPE) 0, (EFI_GCD_IO_TYPE) 0, BaseAddress, Length, 0, Attributes);\r
}\r
\r
IN UINT64 Length\r
)\r
{\r
+ DEBUG ((DEBUG_GCD, "GCD:AddIoSpace(Base=%016lx,Length=%016lx)\n", BaseAddress, Length));\r
+ DEBUG ((DEBUG_GCD, " GcdIoType = %a\n", mGcdIoTypeNames[MIN (GcdIoType, EfiGcdIoTypeMaximum)]));\r
+ \r
//\r
// Make sure parameters are valid\r
//\r
IN EFI_HANDLE DeviceHandle OPTIONAL\r
)\r
{\r
+ DEBUG ((DEBUG_GCD, "GCD:AllocateIoSpace(Base=%016lx,Length=%016lx)\n", *BaseAddress, Length));\r
+ DEBUG ((DEBUG_GCD, " GcdAllocateType = %a\n", mGcdAllocationTypeNames[MIN (GcdAllocateType, EfiGcdMaxAllocateType)]));\r
+ DEBUG ((DEBUG_GCD, " GcdIoType = %a\n", mGcdIoTypeNames[MIN (GcdIoType, EfiGcdIoTypeMaximum)]));\r
+ DEBUG ((DEBUG_GCD, " Alignment = %016lx\n", LShiftU64 (1, Alignment)));\r
+ DEBUG ((DEBUG_GCD, " ImageHandle = %p\n", ImageHandle));\r
+ DEBUG ((DEBUG_GCD, " DeviceHandle = %p\n", DeviceHandle));\r
+ \r
return CoreAllocateSpace (\r
GCD_ALLOCATE_IO_OPERATION,\r
GcdAllocateType,\r
IN UINT64 Length\r
)\r
{\r
+ DEBUG ((DEBUG_GCD, "GCD:FreeIoSpace(Base=%016lx,Length=%016lx)\n", BaseAddress, Length));\r
+\r
return CoreConvertSpace (GCD_FREE_IO_OPERATION, (EFI_GCD_MEMORY_TYPE) 0, (EFI_GCD_IO_TYPE) 0, BaseAddress, Length, 0, 0);\r
}\r
\r
IN UINT64 Length\r
)\r
{\r
+ DEBUG ((DEBUG_GCD, "GCD:RemoveIoSpace(Base=%016lx,Length=%016lx)\n", BaseAddress, Length));\r
+ \r
return CoreConvertSpace (GCD_REMOVE_IO_OPERATION, (EFI_GCD_MEMORY_TYPE) 0, (EFI_GCD_IO_TYPE) 0, BaseAddress, Length, 0, 0);\r
}\r
\r
if (EFI_ERROR (Status)) {\r
Status = EFI_NOT_FOUND;\r
} else {\r
+ ASSERT (StartLink != NULL && EndLink != NULL);\r
//\r
// Copy the contents of the found descriptor into Descriptor\r
//\r
EFI_PHYSICAL_ADDRESS MaxMemoryBaseAddress;\r
UINT64 MaxMemoryLength;\r
UINT64 MaxMemoryAttributes;\r
- EFI_PHYSICAL_ADDRESS MaxAddress;\r
+ EFI_PHYSICAL_ADDRESS TestedMemoryBaseAddress;\r
+ UINT64 TestedMemoryLength;\r
EFI_PHYSICAL_ADDRESS HighAddress;\r
- EFI_HOB_RESOURCE_DESCRIPTOR *MaxResourceHob;\r
EFI_HOB_GUID_TYPE *GuidHob;\r
UINT32 ReservedCodePageNumber;\r
\r
// Initialize Local Variables\r
//\r
PhitResourceHob = NULL;\r
- MaxResourceHob = NULL;\r
ResourceHob = NULL;\r
BaseAddress = 0;\r
Length = 0;\r
}\r
\r
//\r
- // Find the Resource Descriptor HOB that contains range FreeMemoryBaseAddress..FreeMemoryLength\r
+ // Find the Resource Descriptor HOB that contains PHIT range EfiFreeMemoryBottom..EfiFreeMemoryTop\r
//\r
Length = 0;\r
Found = FALSE;\r
for (Hob.Raw = *HobStart; !END_OF_HOB_LIST(Hob); Hob.Raw = GET_NEXT_HOB(Hob)) {\r
+ //\r
+ // Skip all HOBs except Resource Descriptor HOBs\r
+ //\r
+ if (GET_HOB_TYPE (Hob) != EFI_HOB_TYPE_RESOURCE_DESCRIPTOR) {\r
+ continue;\r
+ }\r
\r
- if (GET_HOB_TYPE (Hob) == EFI_HOB_TYPE_RESOURCE_DESCRIPTOR) {\r
+ //\r
+ // Skip Resource Descriptor HOBs that do not describe tested system memory\r
+ //\r
+ ResourceHob = Hob.ResourceDescriptor;\r
+ if (ResourceHob->ResourceType != EFI_RESOURCE_SYSTEM_MEMORY) {\r
+ continue;\r
+ }\r
+ if ((ResourceHob->ResourceAttribute & MEMORY_ATTRIBUTE_MASK) != TESTED_MEMORY_ATTRIBUTES) {\r
+ continue;\r
+ }\r
\r
- ResourceHob = Hob.ResourceDescriptor;\r
+ //\r
+ // Skip Resource Descriptor HOBs that do not contain the PHIT range EfiFreeMemoryBottom..EfiFreeMemoryTop\r
+ //\r
+ if (PhitHob->EfiFreeMemoryBottom < ResourceHob->PhysicalStart) {\r
+ continue;\r
+ }\r
+ if (PhitHob->EfiFreeMemoryTop > (ResourceHob->PhysicalStart + ResourceHob->ResourceLength)) {\r
+ continue;\r
+ }\r
\r
- if (ResourceHob->ResourceType == EFI_RESOURCE_SYSTEM_MEMORY &&\r
- (ResourceHob->ResourceAttribute & MEMORY_ATTRIBUTE_MASK) == TESTED_MEMORY_ATTRIBUTES ) {\r
-\r
- if (PhitHob->EfiFreeMemoryBottom >= ResourceHob->PhysicalStart &&\r
- PhitHob->EfiFreeMemoryTop <= (ResourceHob->PhysicalStart + ResourceHob->ResourceLength) ) {\r
-\r
- //\r
- // Cache the resource descriptor HOB for the memory region described by the PHIT HOB\r
- //\r
- PhitResourceHob = ResourceHob;\r
- Found = TRUE;\r
-\r
- Attributes = PhitResourceHob->ResourceAttribute;\r
- BaseAddress = PageAlignAddress (PhitHob->EfiMemoryTop);\r
- Length = PageAlignLength (ResourceHob->PhysicalStart + ResourceHob->ResourceLength - BaseAddress);\r
- if (Length < MINIMUM_INITIAL_MEMORY_SIZE) {\r
- BaseAddress = PageAlignAddress (PhitHob->EfiFreeMemoryBottom);\r
- Length = PageAlignLength (PhitHob->EfiFreeMemoryTop - BaseAddress);\r
- if (Length < MINIMUM_INITIAL_MEMORY_SIZE) {\r
- BaseAddress = PageAlignAddress (ResourceHob->PhysicalStart);\r
- Length = PageAlignLength ((UINT64)((UINTN)*HobStart - BaseAddress));\r
- }\r
- }\r
- break;\r
- }\r
+ //\r
+ // Cache the resource descriptor HOB for the memory region described by the PHIT HOB\r
+ //\r
+ PhitResourceHob = ResourceHob;\r
+ Found = TRUE;\r
+\r
+ //\r
+ // Compute range between PHIT EfiFreeMemoryTop and the end of the Resource Descriptor HOB\r
+ //\r
+ Attributes = PhitResourceHob->ResourceAttribute;\r
+ BaseAddress = PageAlignAddress (PhitHob->EfiMemoryTop);\r
+ Length = PageAlignLength (ResourceHob->PhysicalStart + ResourceHob->ResourceLength - BaseAddress);\r
+ if (Length < MINIMUM_INITIAL_MEMORY_SIZE) {\r
+ //\r
+ // If that range is not large enough to intialize the DXE Core, then \r
+ // Compute range between PHIT EfiFreeMemoryBottom and PHIT EfiFreeMemoryTop\r
+ //\r
+ BaseAddress = PageAlignAddress (PhitHob->EfiFreeMemoryBottom);\r
+ Length = PageAlignLength (PhitHob->EfiFreeMemoryTop - BaseAddress);\r
+ if (Length < MINIMUM_INITIAL_MEMORY_SIZE) {\r
+ //\r
+ // If that range is not large enough to intialize the DXE Core, then \r
+ // Compute range between the start of the Resource Descriptor HOB and the start of the HOB List\r
+ //\r
+ BaseAddress = PageAlignAddress (ResourceHob->PhysicalStart);\r
+ Length = PageAlignLength ((UINT64)((UINTN)*HobStart - BaseAddress));\r
}\r
}\r
+ break;\r
}\r
\r
//\r
// region that is big enough to initialize the DXE core. Always skip the PHIT Resource HOB.\r
// The max address must be within the physically addressible range for the processor.\r
//\r
- MaxMemoryLength = 0;\r
- MaxAddress = MAX_ADDRESS;\r
- do {\r
- HighAddress = 0;\r
- Found = FALSE;\r
+ HighAddress = MAX_ADDRESS;\r
+ for (Hob.Raw = *HobStart; !END_OF_HOB_LIST(Hob); Hob.Raw = GET_NEXT_HOB(Hob)) {\r
//\r
- // Search for a tested memory region that is below MaxAddress\r
+ // Skip the Resource Descriptor HOB that contains the PHIT\r
//\r
- for (Hob.Raw = *HobStart; !END_OF_HOB_LIST(Hob); Hob.Raw = GET_NEXT_HOB(Hob)) {\r
-\r
- //\r
- // See if this is a resource descriptor HOB that does not contain the PHIT.\r
- //\r
- if (Hob.ResourceDescriptor != PhitResourceHob && GET_HOB_TYPE (Hob) == EFI_HOB_TYPE_RESOURCE_DESCRIPTOR) {\r
+ if (Hob.ResourceDescriptor == PhitResourceHob) {\r
+ continue;\r
+ }\r
+ //\r
+ // Skip all HOBs except Resource Descriptor HOBs\r
+ //\r
+ if (GET_HOB_TYPE (Hob) != EFI_HOB_TYPE_RESOURCE_DESCRIPTOR) {\r
+ continue;\r
+ }\r
\r
- ResourceHob = Hob.ResourceDescriptor;\r
- //\r
- // See if this resource descrior HOB describes tested system memory below MaxAddress\r
- //\r
- if (ResourceHob->ResourceType == EFI_RESOURCE_SYSTEM_MEMORY &&\r
- (ResourceHob->ResourceAttribute & MEMORY_ATTRIBUTE_MASK) == TESTED_MEMORY_ATTRIBUTES &&\r
- ResourceHob->PhysicalStart + ResourceHob->ResourceLength <= MaxAddress) {\r
- //\r
- // See if this is the highest tested system memory region below MaxAddress\r
- //\r
- if (ResourceHob->PhysicalStart > HighAddress) {\r
-\r
- MaxResourceHob = ResourceHob;\r
- HighAddress = MaxResourceHob->PhysicalStart;\r
- Found = TRUE;\r
- }\r
- }\r
- }\r
+ //\r
+ // Skip Resource Descriptor HOBs that do not describe tested system memory below MAX_ADDRESS\r
+ //\r
+ ResourceHob = Hob.ResourceDescriptor;\r
+ if (ResourceHob->ResourceType != EFI_RESOURCE_SYSTEM_MEMORY) {\r
+ continue;\r
}\r
- if (Found) {\r
- //\r
- // Compute the size of the tested memory region below MaxAddrees\r
- //\r
- MaxMemoryBaseAddress = PageAlignAddress (MaxResourceHob->PhysicalStart);\r
- MaxMemoryLength = PageAlignLength (MaxResourceHob->PhysicalStart + MaxResourceHob->ResourceLength - MaxMemoryBaseAddress);\r
- MaxMemoryAttributes = MaxResourceHob->ResourceAttribute;\r
+ if ((ResourceHob->ResourceAttribute & MEMORY_ATTRIBUTE_MASK) != TESTED_MEMORY_ATTRIBUTES) {\r
+ continue;\r
+ }\r
+ if ((ResourceHob->PhysicalStart + ResourceHob->ResourceLength) > (EFI_PHYSICAL_ADDRESS)MAX_ADDRESS) {\r
+ continue;\r
}\r
- MaxAddress = ResourceHob->PhysicalStart;\r
- } while (Found && MaxMemoryLength < MINIMUM_INITIAL_MEMORY_SIZE);\r
+ \r
+ //\r
+ // Skip Resource Descriptor HOBs that are below a previously found Resource Descriptor HOB\r
+ //\r
+ if (HighAddress != (EFI_PHYSICAL_ADDRESS)MAX_ADDRESS && ResourceHob->PhysicalStart <= HighAddress) {\r
+ continue;\r
+ }\r
+\r
+ //\r
+ // Skip Resource Descriptor HOBs that are not large enough to initilize the DXE Core\r
+ //\r
+ TestedMemoryBaseAddress = PageAlignAddress (ResourceHob->PhysicalStart);\r
+ TestedMemoryLength = PageAlignLength (ResourceHob->PhysicalStart + ResourceHob->ResourceLength - TestedMemoryBaseAddress);\r
+ if (TestedMemoryLength < MINIMUM_INITIAL_MEMORY_SIZE) {\r
+ continue;\r
+ }\r
+ \r
+ //\r
+ // Save the Resource Descriptor HOB context that is large enough to initilize the DXE Core\r
+ //\r
+ MaxMemoryBaseAddress = TestedMemoryBaseAddress;\r
+ MaxMemoryLength = TestedMemoryLength;\r
+ MaxMemoryAttributes = ResourceHob->ResourceAttribute; \r
+ HighAddress = ResourceHob->PhysicalStart;\r
+ }\r
\r
+ //\r
+ // If Length is not large enough to initialize the DXE Core or a Resource \r
+ // Descriptor HOB was found above the PHIT HOB that is large enough to initialize \r
+ // the DXE Core, then use the range described by the Resource Descriptor \r
+ // HOB that was found above the PHIT HOB.\r
+ //\r
if ((Length < MINIMUM_INITIAL_MEMORY_SIZE) ||\r
(MaxMemoryBaseAddress > BaseAddress && MaxMemoryLength >= MINIMUM_INITIAL_MEMORY_SIZE)) {\r
BaseAddress = MaxMemoryBaseAddress;\r
\r
InsertHeadList (&mGcdMemorySpaceMap, &Entry->Link);\r
\r
+ CoreDumpGcdMemorySpaceMap (TRUE);\r
+ \r
//\r
// Initialize the GCD I/O Space Map\r
//\r
\r
InsertHeadList (&mGcdIoSpaceMap, &Entry->Link);\r
\r
+ CoreDumpGcdIoSpaceMap (TRUE);\r
+ \r
//\r
// Walk the HOB list and add all resource descriptors to the GCD\r
//\r
}\r
\r
if (GcdMemoryType != EfiGcdMemoryTypeNonExistent) {\r
+ //\r
+ // Validate the Resource HOB Attributes\r
+ //\r
+ CoreValidateResourceDescriptorHobAttributes (ResourceHob->ResourceAttribute);\r
+\r
//\r
// Convert the Resource HOB Attributes to an EFI Memory Capabilities mask\r
//\r
projects / mirror_edk2.git / blobdiff