This patch introduces a variant of the ArmVirtualizationPkg PlatformLib instance that can be combined with the relocatable PrePi to produce a build that is able to fully configure itself based on the memory layout described in a flattened device tree (FDT) image).
Contributed-under: TianoCore Contribution Agreement 1.0 Signed-off-by: Ard Biesheuvel ard.biesheuvel@linaro.org --- .../AARCH64/MemnodeParser.S | 224 +++++++++++++++++++++ .../AARCH64/RelocatableVirtHelper.S | 177 ++++++++++++++++ .../ArmVirtRelocatablePlatformLib.inf | 66 ++++++ .../ArmVirtualizationPlatformLib/RelocatableVirt.c | 78 +++++++ 4 files changed, 545 insertions(+) create mode 100644 ArmPlatformPkg/ArmVirtualizationPkg/Library/ArmVirtualizationPlatformLib/AARCH64/MemnodeParser.S create mode 100644 ArmPlatformPkg/ArmVirtualizationPkg/Library/ArmVirtualizationPlatformLib/AARCH64/RelocatableVirtHelper.S create mode 100644 ArmPlatformPkg/ArmVirtualizationPkg/Library/ArmVirtualizationPlatformLib/ArmVirtRelocatablePlatformLib.inf create mode 100644 ArmPlatformPkg/ArmVirtualizationPkg/Library/ArmVirtualizationPlatformLib/RelocatableVirt.c
diff --git a/ArmPlatformPkg/ArmVirtualizationPkg/Library/ArmVirtualizationPlatformLib/AARCH64/MemnodeParser.S b/ArmPlatformPkg/ArmVirtualizationPkg/Library/ArmVirtualizationPlatformLib/AARCH64/MemnodeParser.S new file mode 100644 index 000000000000..cbd40c611543 --- /dev/null +++ b/ArmPlatformPkg/ArmVirtualizationPkg/Library/ArmVirtualizationPlatformLib/AARCH64/MemnodeParser.S @@ -0,0 +1,224 @@ +// +// Copyright (c) 2014, Linaro Ltd. All rights reserved. +// +// 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. +// + +// +// Theory of operation +// ------------------- +// +// This code parses a Flattened Device Tree binary (DTB) to find the base of +// system RAM. It is written in assembly so that it can be executed before a +// stack has been set up. +// +// To find the base of system RAM, we have to traverse the FDT to find a memory +// node. The first node that has a device_type property with the value 'memory' +// and a 'reg' property is selected, and the name of the node (memory[@xxx]) is +// ignored, as are any other nodes that match the above constraints. +// +// In pseudo code, this implementation does the following: +// +// for each node { +// have_device_type = false +// have_reg = false +// +// for each property { +// if property value == 'memory' { +// if property name == 'device_type' { +// have_device_type = true +// } +// } else { +// if property name == 'reg' { +// have_reg = true +// membase = property value[0] +// memsize = property value[1] +// } +// } +// } +// if have_device_type and have_reg { +// return membase and memsize +// } +// } +// return NOT_FOUND +// + +#define FDT_BEGIN_NODE 0x1 +#define FDT_END_NODE 0x2 +#define FDT_PROP 0x3 +#define FDT_END 0x9 + + xMEMSIZE .req x0 + xMEMBASE .req x1 + wFDTSIZE .req w2 + + xLR .req x8 + xDTP .req x9 + xSTRTAB .req x10 + xMEMNODE .req x11 + + .text + .align 3 +_fdtmagic: + .byte 0xd0, 0x0d, 0xfe, 0xed +_memory: + .asciz "memory" +_reg: + .asciz "reg" +_device_type: + .asciz "device_type" + + // + // Compare strings in x4 and x5, return in w3 + // + .align 3 +strcmp: + ldrb w6, [x4], #1 + ldrb w7, [x5], #1 + subs w3, w6, w7 + cbz w6, 0f + cbz w7, 0f + beq strcmp +0: ret + + .globl find_memnode +find_memnode: + // + // Preserve link register + // + mov xLR, x30 + mov xDTP, x0 + mov xMEMNODE, #0 + + // + // Check the DTB magic at offset 0 + // + ldr w4, _fdtmagic + ldp w5, wFDTSIZE, [xDTP] + cmp w4, w5 + bne err_invalid_magic + rev wFDTSIZE, wFDTSIZE + + // + // Read the string offset and store it for later use + // Read the struct offset and add it to the DT pointer + // + ldp w4, w5, [xDTP, #8] + rev w4, w4 + rev w5, w5 + add xSTRTAB, xDTP, x5 + add xDTP, xDTP, x4 + + // + // Check current tag for FDT_BEGIN_NODE + // + ldr w5, [xDTP] + rev w5, w5 + cmp w5, #FDT_BEGIN_NODE + bne err_unexpected_begin_tag + +begin_node: + mov xMEMNODE, #0 + add xDTP, xDTP, #4 + + // + // Advance xDTP past NULL terminated string + // +0: ldrb w4, [xDTP], #1 + cbnz w4, 0b + +next_tag: + add xDTP, xDTP, #3 + and xDTP, xDTP, #~3 + + // + // Read the next tag, could be BEGIN_NODE, END_NODE, PROP, END + // + ldr w5, [xDTP] + rev w5, w5 + cmp w5, #FDT_BEGIN_NODE + beq begin_node + cmp w5, #FDT_END_NODE + beq end_node + cmp w5, #FDT_PROP + beq prop_node + cmp w5, #FDT_END + beq err_end_of_fdt + b err_unexpected_tag + +prop_node: + // + // If propname == 'reg', record as membase and memsize + // If propname == 'device_type' and value == 'memory', + // set the 'is_memnode' flag for this node + // + ldr w12, [xDTP, #4] + add xDTP, xDTP, #12 + rev w12, w12 + mov x5, xDTP + adr x4, _memory + bl strcmp + + // + // Get handle to property name + // + ldr w5, [xDTP, #-4] + rev w5, w5 + add x5, xSTRTAB, x5 + + cbz w3, check_device_type + + // + // Check for 'reg' property + // + adr x4, _reg + bl strcmp + cbnz w3, inc_and_next_tag + + // + // Extract two 64-bit quantities from the 'reg' property. These values + // will only be used if the node also turns out to have a device_type + // property with a value of 'memory'. + // + ldp xMEMBASE, xMEMSIZE, [xDTP] + rev xMEMBASE, xMEMBASE + rev xMEMSIZE, xMEMSIZE + orr xMEMNODE, xMEMNODE, #2 + b inc_and_next_tag + +check_device_type: + // + // Check whether the current property's name is 'device_type' + // + adr x4, _device_type + bl strcmp + cbnz w3, inc_and_next_tag + orr xMEMNODE, xMEMNODE, #1 + +inc_and_next_tag: + add xDTP, xDTP, x12 + b next_tag + +end_node: + // + // Check for device_type = memory and reg = xxxx + // If we have both, we are done + // + add xDTP, xDTP, #4 + cmp xMEMNODE, #3 + bne next_tag + + ret xLR + +err_invalid_magic: +err_unexpected_begin_tag: +err_unexpected_tag: +err_end_of_fdt: + mov xMEMSIZE, #0 + ret xLR diff --git a/ArmPlatformPkg/ArmVirtualizationPkg/Library/ArmVirtualizationPlatformLib/AARCH64/RelocatableVirtHelper.S b/ArmPlatformPkg/ArmVirtualizationPkg/Library/ArmVirtualizationPlatformLib/AARCH64/RelocatableVirtHelper.S new file mode 100644 index 000000000000..a9b808f7494d --- /dev/null +++ b/ArmPlatformPkg/ArmVirtualizationPkg/Library/ArmVirtualizationPlatformLib/AARCH64/RelocatableVirtHelper.S @@ -0,0 +1,177 @@ +# +# Copyright (c) 2011-2013, ARM Limited. All rights reserved. +# +# 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. +# +# + +#include <AsmMacroIoLibV8.h> +#include <Base.h> +#include <Library/ArmLib.h> +#include <Library/PcdLib.h> +#include <AutoGen.h> + +.text +.align 2 + +GCC_ASM_EXPORT(ArmPlatformPeiBootAction) +GCC_ASM_EXPORT(ArmPlatformIsPrimaryCore) +GCC_ASM_EXPORT(ArmPlatformGetPrimaryCoreMpId) +GCC_ASM_EXPORT(ArmPlatformGetCorePosition) +GCC_ASM_EXPORT(ArmGetPhysAddrTop) + +GCC_ASM_IMPORT(_gPcd_FixedAtBuild_PcdArmPrimaryCore) +GCC_ASM_IMPORT(_gPcd_FixedAtBuild_PcdArmPrimaryCoreMask) +GCC_ASM_IMPORT(_gPcd_FixedAtBuild_PcdCoreCount) + +.LFdtMagic: + .byte 0xd0, 0x0d, 0xfe, 0xed + +.LArm64LinuxMagic: + .byte 0x41, 0x52, 0x4d, 0x64 + +ASM_PFX(ArmPlatformPeiBootAction): + // preserve LR + mov x29, x30 + + // + // If we are booting from RAM using the Linux kernel boot protocol, x0 will + // point to the DTB image in memory. Otherwise, we are just coming out of + // reset, and x0 will be 0. Check also the FDT magic. + // + cbz x0, .Lout + ldr w8, .LFdtMagic + ldr w9, [x0] + cmp w8, w9 + bne .Lout + + // + // The base of the runtime image has been preserved in x1. Check whether + // the expected magic number can be found in the header. + // + ldr w8, .LArm64LinuxMagic + ldr w9, [x1, #0x38] + cmp w8, w9 + bne .Lout + + // + // OK, so far so good. We have confirmed that we likely have a DTB and are + // booting via the arm64 Linux boot protocol. Record the base of the image as + // PcdFdbaseAddress + // + adr x8, PcdGet64 (PcdFdBaseAddress) + ldr x2, [x8] + str x1, [x8] + + // + // Add the shift of PcdFdBaseAddress to PcdFvBaseAddress as well + // + adr x8, PcdGet64 (PcdFvBaseAddress) + ldr x3, [x8] + sub x3, x3, x2 + add x3, x3, x1 + str x3, [x8] + + // + // Parse the memory info from the DTB. + // + mov x27, x0 + mov x28, x1 + bl find_memnode // returns (memsize,membase,fdtsize) size in (x0,x1,x2) + cbz x0, .Lout + + // + // Store the system base and size + // + adr x8, PcdGet64 (PcdSystemMemorySize) + str x0, [x8] + + adr x8, PcdGet64 (PcdSystemMemoryBase) + str x1, [x8] + + // + // To prevent the FDT from being clobbered before we have a chance of + // preserving it, copy it right above the FD image and add its size to + // the FD size so the core code will treat it as part of the flash image. + // + adr x8, PcdGet32 (PcdFdSize) + ldr w9, [x8] + add x0, x28, x9 + add w9, w9, w2 + str w9, [x8] + + // + // Store the new FDT pointer + // + adr x8, PcdGet64 (PcdDeviceTreeInitialBaseAddress) + str x0, [x8] + + // + // Now copy the dtb: + // source: x27 + // dest: x0 + // length: w2 + // + mov x1, x27 + bl memcpy + +.Lout: + ret x29 + +//UINTN +//ArmPlatformGetPrimaryCoreMpId ( +// VOID +// ); +ASM_PFX(ArmPlatformGetPrimaryCoreMpId): + LoadConstantToReg (_gPcd_FixedAtBuild_PcdArmPrimaryCore, x0) + ldrh w0, [x0] + ret + +//UINTN +//ArmPlatformIsPrimaryCore ( +// IN UINTN MpId +// ); +ASM_PFX(ArmPlatformIsPrimaryCore): + mov x0, #1 + ret + +//UINTN +//ArmPlatformGetCorePosition ( +// IN UINTN MpId +// ); +// With this function: CorePos = (ClusterId * 4) + CoreId +ASM_PFX(ArmPlatformGetCorePosition): + and x1, x0, #ARM_CORE_MASK + and x0, x0, #ARM_CLUSTER_MASK + add x0, x1, x0, LSR #6 + ret + +//EFI_PHYSICAL_ADDRESS +//GetPhysAddrTop ( +// VOID +// ); +ASM_PFX(ArmGetPhysAddrTop): + mrs x0, id_aa64mmfr0_el1 + adr x1, .LPARanges + and x0, x0, #7 + ldrb w1, [x1, x0] + mov x0, #1 + lsl x0, x0, x1 + ret + +// +// Bits 0..2 of the AA64MFR0_EL1 system register encode the size of the +// physical address space support on this CPU: +// 0 == 32 bits, 1 == 36 bits, etc etc +// 6 and 7 are reserved +// +.LPARanges: + .byte 32, 36, 40, 42, 44, 48, -1, -1 + +ASM_FUNCTION_REMOVE_IF_UNREFERENCED diff --git a/ArmPlatformPkg/ArmVirtualizationPkg/Library/ArmVirtualizationPlatformLib/ArmVirtRelocatablePlatformLib.inf b/ArmPlatformPkg/ArmVirtualizationPkg/Library/ArmVirtualizationPlatformLib/ArmVirtRelocatablePlatformLib.inf new file mode 100644 index 000000000000..a18975038003 --- /dev/null +++ b/ArmPlatformPkg/ArmVirtualizationPkg/Library/ArmVirtualizationPlatformLib/ArmVirtRelocatablePlatformLib.inf @@ -0,0 +1,66 @@ +#/* @file +# Copyright (c) 2011-2014, ARM Limited. All rights reserved. +# Copyright (c) 2014, Linaro Limited. All rights reserved. +# +# 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. +# +#*/ + +[Defines] + INF_VERSION = 0x00010005 + BASE_NAME = ArmVirtRelocatablePlatformLib + FILE_GUID = c8602718-4faa-4119-90ca-cae72509ac4c + MODULE_TYPE = BASE + VERSION_STRING = 1.0 + LIBRARY_CLASS = ArmPlatformLib|SEC PEIM + +[Packages] + MdePkg/MdePkg.dec + MdeModulePkg/MdeModulePkg.dec + EmbeddedPkg/EmbeddedPkg.dec + ArmPkg/ArmPkg.dec + ArmPlatformPkg/ArmPlatformPkg.dec + ArmPlatformPkg/ArmVirtualizationPkg/ArmVirtualizationPkg.dec + +[LibraryClasses] + IoLib + ArmLib + PrintLib + FdtLib + SerialPortLib + HobLib + +[Sources.common] + RelocatableVirt.c + VirtMem.c + +[Sources.AARCH64] + AARCH64/RelocatableVirtHelper.S | GCC + AARCH64/MemnodeParser.S | GCC + +[FeaturePcd] + gEmbeddedTokenSpaceGuid.PcdCacheEnable + gArmPlatformTokenSpaceGuid.PcdSystemMemoryInitializeInSec + +[Pcd] + gArmTokenSpaceGuid.PcdSystemMemorySize + +[FixedPcd] + gArmVirtualizationTokenSpaceGuid.PcdDeviceTreeInitialBaseAddress + gArmPlatformTokenSpaceGuid.PcdCoreCount + gArmTokenSpaceGuid.PcdSystemMemoryBase + gArmTokenSpaceGuid.PcdArmPrimaryCoreMask + gArmTokenSpaceGuid.PcdArmPrimaryCore + gArmTokenSpaceGuid.PcdFdBaseAddress + gArmTokenSpaceGuid.PcdFdSize + gArmTokenSpaceGuid.PcdFvBaseAddress + +[Guids] + gEarlyPL011BaseAddressGuid + gFdtHobGuid diff --git a/ArmPlatformPkg/ArmVirtualizationPkg/Library/ArmVirtualizationPlatformLib/RelocatableVirt.c b/ArmPlatformPkg/ArmVirtualizationPkg/Library/ArmVirtualizationPlatformLib/RelocatableVirt.c new file mode 100644 index 000000000000..e9fe114383a5 --- /dev/null +++ b/ArmPlatformPkg/ArmVirtualizationPkg/Library/ArmVirtualizationPlatformLib/RelocatableVirt.c @@ -0,0 +1,78 @@ +/** @file +* +* Copyright (c) 2011-2013, ARM Limited. All rights reserved. +* Copyright (c) 2014, Linaro Limited. All rights reserved. +* Copyright (c) 2014, Red Hat, Inc. +* +* +* 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. +* +**/ + +#include <Library/IoLib.h> +#include <Library/ArmPlatformLib.h> +#include <Library/DebugLib.h> +#include <Library/PcdLib.h> +#include <ArmPlatform.h> +#include <libfdt.h> +#include <Pi/PiBootMode.h> +#include <Uefi/UefiBaseType.h> +#include <Uefi/UefiMultiPhase.h> +#include <Pi/PiHob.h> +#include <Library/HobLib.h> +#include <Guid/EarlyPL011BaseAddress.h> + +/** + Return the current Boot Mode + + This function returns the boot reason on the platform + + @return Return the current Boot Mode of the platform + +**/ +EFI_BOOT_MODE +ArmPlatformGetBootMode ( + VOID + ) +{ + return BOOT_WITH_FULL_CONFIGURATION; +} + +/** + This function is called by PrePeiCore, in the SEC phase. +**/ +RETURN_STATUS +ArmPlatformInitialize ( + IN UINTN MpId + ) +{ + // + // We are relying on ArmPlatformInitializeSystemMemory () being called from + // InitializeMemory (), which only occurs if the following feature is disabled + // + ASSERT (!FeaturePcdGet (PcdSystemMemoryInitializeInSec)); + return RETURN_SUCCESS; +} + +VOID +ArmPlatformInitializeSystemMemory ( + VOID + ) +{ +} + +VOID +ArmPlatformGetPlatformPpiList ( + OUT UINTN *PpiListSize, + OUT EFI_PEI_PPI_DESCRIPTOR **PpiList + ) +{ + *PpiListSize = 0; + *PpiList = NULL; +}