mirror of https://github.com/acidanthera/audk.git
316 lines
11 KiB
C
316 lines
11 KiB
C
/** @file
|
|
*
|
|
* Copyright (c) 2011-2014, 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 "BdsInternal.h"
|
|
#include "BdsLinuxLoader.h"
|
|
|
|
#define ALIGN32_BELOW(addr) ALIGN_POINTER(addr - 32,32)
|
|
|
|
#define IS_ADDRESS_IN_REGION(RegionStart, RegionSize, Address) \
|
|
(((UINTN)(RegionStart) <= (UINTN)(Address)) && ((UINTN)(Address) <= ((UINTN)(RegionStart) + (UINTN)(RegionSize))))
|
|
|
|
STATIC
|
|
EFI_STATUS
|
|
PreparePlatformHardware (
|
|
VOID
|
|
)
|
|
{
|
|
//Note: Interrupts will be disabled by the GIC driver when ExitBootServices() will be called.
|
|
|
|
// Clean before Disable else the Stack gets corrupted with old data.
|
|
ArmCleanDataCache ();
|
|
ArmDisableDataCache ();
|
|
// Invalidate all the entries that might have snuck in.
|
|
ArmInvalidateDataCache ();
|
|
|
|
// Invalidate and disable the Instruction cache
|
|
ArmDisableInstructionCache ();
|
|
ArmInvalidateInstructionCache ();
|
|
|
|
// Turn off MMU
|
|
ArmDisableMmu();
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
STATIC
|
|
EFI_STATUS
|
|
StartLinux (
|
|
IN EFI_PHYSICAL_ADDRESS LinuxImage,
|
|
IN UINTN LinuxImageSize,
|
|
IN EFI_PHYSICAL_ADDRESS KernelParamsAddress,
|
|
IN UINTN KernelParamsSize,
|
|
IN UINT32 MachineType
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
LINUX_KERNEL LinuxKernel;
|
|
|
|
// Shut down UEFI boot services. ExitBootServices() will notify every driver that created an event on
|
|
// ExitBootServices event. Example the Interrupt DXE driver will disable the interrupts on this event.
|
|
Status = ShutdownUefiBootServices ();
|
|
if(EFI_ERROR(Status)) {
|
|
DEBUG((EFI_D_ERROR,"ERROR: Can not shutdown UEFI boot services. Status=0x%X\n", Status));
|
|
goto Exit;
|
|
}
|
|
|
|
// Move the kernel parameters to any address inside the first 1MB.
|
|
// This is necessary because the ARM Linux kernel requires
|
|
// the FTD / ATAG List to reside entirely inside the first 1MB of
|
|
// physical memory.
|
|
//Note: There is no requirement on the alignment
|
|
if (MachineType != ARM_FDT_MACHINE_TYPE) {
|
|
if (((UINTN)KernelParamsAddress > LINUX_ATAG_MAX_OFFSET) && (KernelParamsSize < PcdGet32(PcdArmLinuxAtagMaxOffset))) {
|
|
KernelParamsAddress = (EFI_PHYSICAL_ADDRESS)(UINTN)CopyMem (ALIGN32_BELOW(LINUX_ATAG_MAX_OFFSET - KernelParamsSize), (VOID*)(UINTN)KernelParamsAddress, KernelParamsSize);
|
|
}
|
|
} else {
|
|
if (((UINTN)KernelParamsAddress > LINUX_FDT_MAX_OFFSET) && (KernelParamsSize < PcdGet32(PcdArmLinuxFdtMaxOffset))) {
|
|
KernelParamsAddress = (EFI_PHYSICAL_ADDRESS)(UINTN)CopyMem (ALIGN32_BELOW(LINUX_FDT_MAX_OFFSET - KernelParamsSize), (VOID*)(UINTN)KernelParamsAddress, KernelParamsSize);
|
|
}
|
|
}
|
|
|
|
if ((UINTN)LinuxImage > LINUX_KERNEL_MAX_OFFSET) {
|
|
//Note: There is no requirement on the alignment
|
|
LinuxKernel = (LINUX_KERNEL)CopyMem (ALIGN32_BELOW(LINUX_KERNEL_MAX_OFFSET - LinuxImageSize), (VOID*)(UINTN)LinuxImage, LinuxImageSize);
|
|
} else {
|
|
LinuxKernel = (LINUX_KERNEL)(UINTN)LinuxImage;
|
|
}
|
|
|
|
// Check if the Linux Image is a uImage
|
|
if (*(UINT32*)LinuxKernel == LINUX_UIMAGE_SIGNATURE) {
|
|
// Assume the Image Entry Point is just after the uImage header (64-byte size)
|
|
LinuxKernel = (LINUX_KERNEL)((UINTN)LinuxKernel + 64);
|
|
LinuxImageSize -= 64;
|
|
}
|
|
|
|
// Check there is no overlapping between kernel and its parameters
|
|
// We can only assert because it is too late to fallback to UEFI (ExitBootServices has been called).
|
|
ASSERT (!IS_ADDRESS_IN_REGION(LinuxKernel, LinuxImageSize, KernelParamsAddress) &&
|
|
!IS_ADDRESS_IN_REGION(LinuxKernel, LinuxImageSize, KernelParamsAddress + KernelParamsSize));
|
|
|
|
//
|
|
// Switch off interrupts, caches, mmu, etc
|
|
//
|
|
Status = PreparePlatformHardware ();
|
|
ASSERT_EFI_ERROR(Status);
|
|
|
|
// Register and print out performance information
|
|
PERF_END (NULL, "BDS", NULL, 0);
|
|
if (PerformanceMeasurementEnabled ()) {
|
|
PrintPerformance ();
|
|
}
|
|
|
|
//
|
|
// Start the Linux Kernel
|
|
//
|
|
|
|
// Outside BootServices, so can't use Print();
|
|
DEBUG((EFI_D_ERROR, "\nStarting the kernel:\n\n"));
|
|
|
|
// Jump to kernel with register set
|
|
LinuxKernel ((UINTN)0, MachineType, (UINTN)KernelParamsAddress);
|
|
|
|
// Kernel should never exit
|
|
// After Life services are not provided
|
|
ASSERT(FALSE);
|
|
|
|
Exit:
|
|
// Only be here if we fail to start Linux
|
|
Print (L"ERROR : Can not start the kernel. Status=0x%X\n", Status);
|
|
|
|
// Free Runtimee Memory (kernel and FDT)
|
|
return Status;
|
|
}
|
|
|
|
/**
|
|
Start a Linux kernel from a Device Path
|
|
|
|
@param LinuxKernel Device Path to the Linux Kernel
|
|
@param Parameters Linux kernel arguments
|
|
@param Fdt Device Path to the Flat Device Tree
|
|
|
|
@retval EFI_SUCCESS All drivers have been connected
|
|
@retval EFI_NOT_FOUND The Linux kernel Device Path has not been found
|
|
@retval EFI_OUT_OF_RESOURCES There is not enough resource memory to store the matching results.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
BdsBootLinuxAtag (
|
|
IN EFI_DEVICE_PATH_PROTOCOL* LinuxKernelDevicePath,
|
|
IN EFI_DEVICE_PATH_PROTOCOL* InitrdDevicePath,
|
|
IN CONST CHAR8* CommandLineArguments
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
UINT32 LinuxImageSize;
|
|
UINT32 InitrdImageBaseSize = 0;
|
|
UINT32 InitrdImageSize = 0;
|
|
UINT32 AtagSize;
|
|
EFI_PHYSICAL_ADDRESS AtagBase;
|
|
EFI_PHYSICAL_ADDRESS LinuxImage;
|
|
EFI_PHYSICAL_ADDRESS InitrdImageBase = 0;
|
|
EFI_PHYSICAL_ADDRESS InitrdImage = 0;
|
|
|
|
PERF_START (NULL, "BDS", NULL, 0);
|
|
|
|
// Load the Linux kernel from a device path
|
|
LinuxImage = LINUX_KERNEL_MAX_OFFSET;
|
|
Status = BdsLoadImage (LinuxKernelDevicePath, AllocateMaxAddress, &LinuxImage, &LinuxImageSize);
|
|
if (EFI_ERROR(Status)) {
|
|
Print (L"ERROR: Did not find Linux kernel.\n");
|
|
return Status;
|
|
}
|
|
|
|
if (InitrdDevicePath) {
|
|
// Load the initrd near to the Linux kernel
|
|
InitrdImageBase = LINUX_KERNEL_MAX_OFFSET;
|
|
Status = BdsLoadImage (InitrdDevicePath, AllocateMaxAddress, &InitrdImageBase, &InitrdImageBaseSize);
|
|
if (Status == EFI_OUT_OF_RESOURCES) {
|
|
Status = BdsLoadImage (InitrdDevicePath, AllocateAnyPages, &InitrdImageBase, &InitrdImageBaseSize);
|
|
}
|
|
if (EFI_ERROR(Status)) {
|
|
Print (L"ERROR: Did not find initrd image.\n");
|
|
goto EXIT_FREE_LINUX;
|
|
}
|
|
|
|
// Check if the initrd is a uInitrd
|
|
if (*(UINT32*)((UINTN)InitrdImageBase) == LINUX_UIMAGE_SIGNATURE) {
|
|
// Skip the 64-byte image header
|
|
InitrdImage = (EFI_PHYSICAL_ADDRESS)((UINTN)InitrdImageBase + 64);
|
|
InitrdImageSize = InitrdImageBaseSize - 64;
|
|
} else {
|
|
InitrdImage = InitrdImageBase;
|
|
InitrdImageSize = InitrdImageBaseSize;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Setup the Linux Kernel Parameters
|
|
//
|
|
|
|
// By setting address=0 we leave the memory allocation to the function
|
|
Status = PrepareAtagList (CommandLineArguments, InitrdImage, InitrdImageSize, &AtagBase, &AtagSize);
|
|
if (EFI_ERROR(Status)) {
|
|
Print(L"ERROR: Can not prepare ATAG list. Status=0x%X\n", Status);
|
|
goto EXIT_FREE_INITRD;
|
|
}
|
|
|
|
return StartLinux (LinuxImage, LinuxImageSize, AtagBase, AtagSize, PcdGet32(PcdArmMachineType));
|
|
|
|
EXIT_FREE_INITRD:
|
|
if (InitrdDevicePath) {
|
|
gBS->FreePages (InitrdImageBase, EFI_SIZE_TO_PAGES (InitrdImageBaseSize));
|
|
}
|
|
|
|
EXIT_FREE_LINUX:
|
|
gBS->FreePages (LinuxImage, EFI_SIZE_TO_PAGES (LinuxImageSize));
|
|
|
|
return Status;
|
|
}
|
|
|
|
/**
|
|
Start a Linux kernel from a Device Path
|
|
|
|
@param LinuxKernel Device Path to the Linux Kernel
|
|
@param Parameters Linux kernel arguments
|
|
@param Fdt Device Path to the Flat Device Tree
|
|
|
|
@retval EFI_SUCCESS All drivers have been connected
|
|
@retval EFI_NOT_FOUND The Linux kernel Device Path has not been found
|
|
@retval EFI_OUT_OF_RESOURCES There is not enough resource memory to store the matching results.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
BdsBootLinuxFdt (
|
|
IN EFI_DEVICE_PATH_PROTOCOL* LinuxKernelDevicePath,
|
|
IN EFI_DEVICE_PATH_PROTOCOL* InitrdDevicePath,
|
|
IN CONST CHAR8* CommandLineArguments,
|
|
IN EFI_DEVICE_PATH_PROTOCOL* FdtDevicePath
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
UINT32 LinuxImageSize;
|
|
UINT32 InitrdImageBaseSize = 0;
|
|
UINT32 InitrdImageSize = 0;
|
|
UINT32 FdtBlobSize;
|
|
EFI_PHYSICAL_ADDRESS FdtBlobBase;
|
|
EFI_PHYSICAL_ADDRESS LinuxImage;
|
|
EFI_PHYSICAL_ADDRESS InitrdImageBase = 0;
|
|
EFI_PHYSICAL_ADDRESS InitrdImage = 0;
|
|
|
|
PERF_START (NULL, "BDS", NULL, 0);
|
|
|
|
// Load the Linux kernel from a device path
|
|
LinuxImage = LINUX_KERNEL_MAX_OFFSET;
|
|
Status = BdsLoadImage (LinuxKernelDevicePath, AllocateMaxAddress, &LinuxImage, &LinuxImageSize);
|
|
if (EFI_ERROR(Status)) {
|
|
Print (L"ERROR: Did not find Linux kernel.\n");
|
|
return Status;
|
|
}
|
|
|
|
if (InitrdDevicePath) {
|
|
InitrdImageBase = LINUX_KERNEL_MAX_OFFSET;
|
|
Status = BdsLoadImage (InitrdDevicePath, AllocateMaxAddress, &InitrdImageBase, &InitrdImageBaseSize);
|
|
if (Status == EFI_OUT_OF_RESOURCES) {
|
|
Status = BdsLoadImage (InitrdDevicePath, AllocateAnyPages, &InitrdImageBase, &InitrdImageBaseSize);
|
|
}
|
|
if (EFI_ERROR(Status)) {
|
|
Print (L"ERROR: Did not find initrd image.\n");
|
|
goto EXIT_FREE_LINUX;
|
|
}
|
|
|
|
// Check if the initrd is a uInitrd
|
|
if (*(UINT32*)((UINTN)InitrdImageBase) == LINUX_UIMAGE_SIGNATURE) {
|
|
// Skip the 64-byte image header
|
|
InitrdImage = (EFI_PHYSICAL_ADDRESS)((UINTN)InitrdImageBase + 64);
|
|
InitrdImageSize = InitrdImageBaseSize - 64;
|
|
} else {
|
|
InitrdImage = InitrdImageBase;
|
|
InitrdImageSize = InitrdImageBaseSize;
|
|
}
|
|
}
|
|
|
|
// Load the FDT binary from a device path. The FDT will be reloaded later to a more appropriate location for the Linux kernel.
|
|
FdtBlobBase = 0;
|
|
Status = BdsLoadImage (FdtDevicePath, AllocateAnyPages, &FdtBlobBase, &FdtBlobSize);
|
|
if (EFI_ERROR(Status)) {
|
|
Print (L"ERROR: Did not find Device Tree blob.\n");
|
|
goto EXIT_FREE_INITRD;
|
|
}
|
|
|
|
// Update the Fdt with the Initrd information. The FDT will increase in size.
|
|
// By setting address=0 we leave the memory allocation to the function
|
|
Status = PrepareFdt (CommandLineArguments, InitrdImage, InitrdImageSize, &FdtBlobBase, &FdtBlobSize);
|
|
if (EFI_ERROR(Status)) {
|
|
Print(L"ERROR: Can not load kernel with FDT. Status=%r\n", Status);
|
|
goto EXIT_FREE_FDT;
|
|
}
|
|
|
|
return StartLinux (LinuxImage, LinuxImageSize, FdtBlobBase, FdtBlobSize, ARM_FDT_MACHINE_TYPE);
|
|
|
|
EXIT_FREE_FDT:
|
|
gBS->FreePages (FdtBlobBase, EFI_SIZE_TO_PAGES (FdtBlobSize));
|
|
|
|
EXIT_FREE_INITRD:
|
|
if (InitrdDevicePath) {
|
|
gBS->FreePages (InitrdImageBase, EFI_SIZE_TO_PAGES (InitrdImageBaseSize));
|
|
}
|
|
|
|
EXIT_FREE_LINUX:
|
|
gBS->FreePages (LinuxImage, EFI_SIZE_TO_PAGES (LinuxImageSize));
|
|
|
|
return Status;
|
|
}
|
|
|