tyler.durden
/
audk
mirror of https://github.com/acidanthera/audk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

ArmPkg/Application: Add new EFI application to boot Linux 

This new application support ATAG and FDT Linux kernel.
It uses the Device Tree from the EFI Configuration Table
to boot FDT aware Linux kernel.

Contributed-under: TianoCore Contribution Agreement 1.0
Signed-off-by: Ronald Cron <Ronald.Cron@arm.com>
Reviewed-by: Olivier Martin <Olivier.Martin@arm.com>



git-svn-id: https://svn.code.sf.net/p/edk2/code/trunk/edk2@17828 6f19259b-4bc3-4df7-8a09-765794883524
This commit is contained in:
Ronald Cron 2015-07-06 16:49:40 +00:00 committed by oliviermartin
parent e6c51eaf02
commit 23b01c83b2
20 changed files with 2787 additions and 691 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

370
ArmPkg/Application/LinuxLoader/AArch64/LinuxStarter.c Normal file
View File

@ -0,0 +1,370 @@
/** @file
*
* Copyright (c) 2011-2015, 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 <Library/ArmLib.h>
#include <Library/ArmGicLib.h>
#include <Library/IoLib.h>
#include <Library/PcdLib.h>
#include <Ppi/ArmMpCoreInfo.h>
#include <Guid/Fdt.h>
#include "LinuxLoader.h"
/*
Linux kernel booting: Look at the doc in the Kernel source :
Documentation/arm64/booting.txt
The kernel image must be placed at the start of the memory to be used by the
kernel (2MB aligned) + 0x80000.
The Device tree blob is expected to be under 2MB and be within the first 512MB
of kernel memory and be 2MB aligned.
A Flattened Device Tree (FDT) used to boot linux needs to be updated before
the kernel is started. It needs to indicate how secondary cores are brought up
and where they are waiting before loading Linux. The FDT also needs to hold
the correct kernel command line and filesystem RAM-disk information.
At the moment we do not fully support generating this FDT information at
runtime. A prepared FDT should be provided at boot. FDT is the only supported
method for booting the AArch64 Linux kernel.
Linux does not use any runtime services at this time, so we can let it
overwrite UEFI.
*/
#define LINUX_ALIGN_VAL (0x080000) // 2MB + 0x80000 mask
#define LINUX_ALIGN_MASK (0x1FFFFF) // Bottom 21bits
#define ALIGN_2MB(addr) ALIGN_POINTER(addr , (2*1024*1024))
/* ARM32 and AArch64 kernel handover differ.
* x0 is set to FDT base.
* x1-x3 are reserved for future use and should be set to zero.
*/
typedef VOID (*LINUX_KERNEL64)(UINTN ParametersBase, UINTN Reserved0,
UINTN Reserved1, UINTN Reserved2);
/* These externs are used to relocate some ASM code into Linux memory. */
extern VOID *SecondariesPenStart;
extern VOID *SecondariesPenEnd;
extern UINTN *AsmMailboxbase;
STATIC
VOID
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 ();
// Disable and invalidate the instruction cache
ArmDisableInstructionCache ();
ArmInvalidateInstructionCache ();
// Turn off MMU
ArmDisableMmu ();
}
STATIC
EFI_STATUS
StartLinux (
IN EFI_PHYSICAL_ADDRESS LinuxImage,
IN UINTN LinuxImageSize,
IN EFI_PHYSICAL_ADDRESS FdtBlobBase,
IN UINTN FdtBlobSize
)
{
EFI_STATUS Status;
LINUX_KERNEL64 LinuxKernel = (LINUX_KERNEL64)LinuxImage;
// Send msg to secondary cores to go to the kernel pen.
ArmGicSendSgiTo (PcdGet32 (PcdGicDistributorBase), ARM_GIC_ICDSGIR_FILTER_EVERYONEELSE, 0x0E, PcdGet32 (PcdGicSgiIntId));
// 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));
return Status;
}
// Check if the Linux Image is a uImage
if (*(UINTN*)LinuxKernel == LINUX_UIMAGE_SIGNATURE) {
// Assume the Image Entry Point is just after the uImage header (64-byte size)
LinuxKernel = (LINUX_KERNEL64)((UINTN)LinuxKernel + 64);
LinuxImageSize -= 64;
}
//
// Switch off interrupts, caches, mmu, etc
//
PreparePlatformHardware ();
// Register and print out performance information
PERF_END (NULL, "BDS", NULL, 0);
if (PerformanceMeasurementEnabled ()) {
PrintPerformance ();
}
//
// Start the Linux Kernel
//
// x1-x3 are reserved (set to zero) for future use.
LinuxKernel ((UINTN)FdtBlobBase, 0, 0, 0);
// Kernel should never exit
// After Life services are not provided
ASSERT (FALSE);
// We cannot recover the execution at this stage
while (1);
}
/**
Start a Linux kernel from a Device Path
@param SystemMemoryBase Base of the system memory
@param LinuxKernel Device Path to the Linux Kernel
@param Parameters Linux kernel arguments
@param Fdt Device Path to the Flat Device Tree
@param MachineType ARM machine type value
@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.
@retval RETURN_UNSUPPORTED ATAG is not support by this architecture
**/
EFI_STATUS
BootLinuxAtag (
IN EFI_PHYSICAL_ADDRESS SystemMemoryBase,
IN EFI_DEVICE_PATH_PROTOCOL* LinuxKernelDevicePath,
IN EFI_DEVICE_PATH_PROTOCOL* InitrdDevicePath,
IN CONST CHAR8* CommandLineArguments,
IN UINTN MachineType
)
{
// NOTE : AArch64 Linux kernel does not support ATAG, FDT only.
ASSERT (0);
return EFI_UNSUPPORTED;
}
/**
Start a Linux kernel from a Device Path
@param[in] LinuxKernelDevicePath Device Path to the Linux Kernel
@param[in] InitrdDevicePath Device Path to the Initrd
@param[in] Arguments Linux kernel arguments
@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
BootLinuxFdt (
IN EFI_PHYSICAL_ADDRESS SystemMemoryBase,
IN EFI_DEVICE_PATH_PROTOCOL* LinuxKernelDevicePath,
IN EFI_DEVICE_PATH_PROTOCOL* InitrdDevicePath,
IN EFI_DEVICE_PATH_PROTOCOL* FdtDevicePath,
IN CONST CHAR8* Arguments
)
{
EFI_STATUS Status;
EFI_STATUS PenBaseStatus;
UINTN LinuxImageSize;
UINTN InitrdImageSize;
UINTN InitrdImageBaseSize;
VOID *InstalledFdtBase;
UINTN FdtBlobSize;
EFI_PHYSICAL_ADDRESS FdtBlobBase;
EFI_PHYSICAL_ADDRESS LinuxImage;
EFI_PHYSICAL_ADDRESS InitrdImage;
EFI_PHYSICAL_ADDRESS InitrdImageBase;
ARM_PROCESSOR_TABLE *ArmProcessorTable;
ARM_CORE_INFO *ArmCoreInfoTable;
UINTN Index;
EFI_PHYSICAL_ADDRESS PenBase;
UINTN PenSize;
UINTN MailBoxBase;
PenBaseStatus = EFI_UNSUPPORTED;
PenSize = 0;
InitrdImage = 0;
InitrdImageSize = 0;
InitrdImageBase = 0;
InitrdImageBaseSize = 0;
PERF_START (NULL, "BDS", NULL, 0);
//
// Load the Linux kernel from a device path
//
// Try to put the kernel at the start of RAM so as to give it access to all memory.
// If that fails fall back to try loading it within LINUX_KERNEL_MAX_OFFSET of memory start.
LinuxImage = SystemMemoryBase + 0x80000;
Status = BdsLoadImage (LinuxKernelDevicePath, AllocateAddress, &LinuxImage, &LinuxImageSize);
if (EFI_ERROR (Status)) {
// Try again but give the loader more freedom of where to put the image.
LinuxImage = LINUX_KERNEL_MAX_OFFSET;
Status = BdsLoadImage (LinuxKernelDevicePath, AllocateMaxAddress, &LinuxImage, &LinuxImageSize);
if (EFI_ERROR (Status)) {
Print (L"ERROR: Did not find Linux kernel (%r).\n", Status);
return Status;
}
}
// Adjust the kernel location slightly if required. The kernel needs to be placed at start
// of memory (2MB aligned) + 0x80000.
if ((LinuxImage & LINUX_ALIGN_MASK) != LINUX_ALIGN_VAL) {
LinuxImage = (EFI_PHYSICAL_ADDRESS)CopyMem (ALIGN_2MB (LinuxImage) + 0x80000, (VOID*)(UINTN)LinuxImage, LinuxImageSize);
}
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 (%r).\n", Status);
goto EXIT_FREE_LINUX;
}
// Check if the initrd is a uInitrd
if (*(UINTN*)((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;
}
}
if (FdtDevicePath == NULL) {
//
// Get the FDT from the Configuration Table.
// The FDT will be reloaded in PrepareFdt() to a more appropriate
// location for the Linux Kernel.
//
Status = EfiGetSystemConfigurationTable (&gFdtTableGuid, &InstalledFdtBase);
if (EFI_ERROR (Status)) {
Print (L"ERROR: Did not get the Device Tree blob (%r).\n", Status);
goto EXIT_FREE_INITRD;
}
FdtBlobBase = (EFI_PHYSICAL_ADDRESS)InstalledFdtBase;
FdtBlobSize = fdt_totalsize (InstalledFdtBase);
} else {
//
// FDT device path explicitly defined. The FDT is relocated later to a
// more appropriate location for the Linux kernel.
//
FdtBlobBase = LINUX_KERNEL_MAX_OFFSET;
Status = BdsLoadImage (FdtDevicePath, AllocateMaxAddress, &FdtBlobBase, &FdtBlobSize);
if (EFI_ERROR (Status)) {
Print (L"ERROR: Did not find Device Tree blob (%r).\n", Status);
goto EXIT_FREE_INITRD;
}
}
//
// Install secondary core pens if the Power State Coordination Interface is not supported
//
if (FeaturePcdGet (PcdArmLinuxSpinTable)) {
// Place Pen at the start of Linux memory. We can then tell Linux to not use this bit of memory
PenBase = LinuxImage - 0x80000;
PenSize = (UINTN)&SecondariesPenEnd - (UINTN)&SecondariesPenStart;
// Reserve the memory as RuntimeServices
PenBaseStatus = gBS->AllocatePages (AllocateAddress, EfiRuntimeServicesCode, EFI_SIZE_TO_PAGES (PenSize), &PenBase);
if (EFI_ERROR (PenBaseStatus)) {
Print (L"Warning: Failed to reserve the memory required for the secondary cores at 0x%lX, Status = %r\n", PenBase, PenBaseStatus);
// Even if there is a risk of memory corruption we carry on
}
// Put mailboxes below the pen code so we know where they are relative to code.
MailBoxBase = (UINTN)PenBase + ((UINTN)&SecondariesPenEnd - (UINTN)&SecondariesPenStart);
// Make sure this is 8 byte aligned.
if (MailBoxBase % sizeof (MailBoxBase) != 0) {
MailBoxBase += sizeof (MailBoxBase) - MailBoxBase % sizeof (MailBoxBase);
}
CopyMem ( (VOID*)(PenBase), (VOID*)&SecondariesPenStart, PenSize);
// Update the MailboxBase variable used in the pen code
*(UINTN*)(PenBase + ((UINTN)&AsmMailboxbase - (UINTN)&SecondariesPenStart)) = MailBoxBase;
for (Index = 0; Index < gST->NumberOfTableEntries; Index++) {
// Check for correct GUID type
if (CompareGuid (&gArmMpCoreInfoGuid, &(gST->ConfigurationTable[Index].VendorGuid))) {
UINTN i;
// Get them under our control. Move from depending on 32bit reg(sys_flags) and SWI
// to 64 bit addr and WFE
ArmProcessorTable = (ARM_PROCESSOR_TABLE *)gST->ConfigurationTable[Index].VendorTable;
ArmCoreInfoTable = ArmProcessorTable->ArmCpus;
for (i = 0; i < ArmProcessorTable->NumberOfEntries; i++ ) {
// This goes into the SYSFLAGS register for the VE platform. We only have one 32bit reg to use
MmioWrite32 (ArmCoreInfoTable[i].MailboxSetAddress, (UINTN)PenBase);
// So FDT can set the mailboxes correctly with the parser. These are 64bit Memory locations.
ArmCoreInfoTable[i].MailboxSetAddress = (UINTN)MailBoxBase + i*sizeof (MailBoxBase);
// Clear the mailboxes for the respective cores
*((UINTN*)(ArmCoreInfoTable[i].MailboxSetAddress)) = 0x0;
}
}
}
// Flush caches to make sure our pen gets to mem before we free the cores.
ArmCleanDataCache ();
}
// By setting address=0 we leave the memory allocation to the function
Status = PrepareFdt (SystemMemoryBase, Arguments, InitrdImage, InitrdImageSize, &FdtBlobBase, &FdtBlobSize);
if (EFI_ERROR (Status)) {
Print (L"ERROR: Can not load Linux kernel with Device Tree. Status=0x%X\n", Status);
goto EXIT_FREE_FDT;
}
return StartLinux (LinuxImage, LinuxImageSize, FdtBlobBase, FdtBlobSize);
EXIT_FREE_FDT:
if (!EFI_ERROR (PenBaseStatus)) {
gBS->FreePages (PenBase, EFI_SIZE_TO_PAGES (PenSize));
}
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;
}

58
ArmPkg/Application/LinuxLoader/AArch64/LinuxStarterHelper.S Normal file
View File

@ -0,0 +1,58 @@
//
// 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.
//
//
/* Secondary core pens for AArch64 Linux booting.
This code it placed in Linux kernel memory and marked reserved. UEFI ensures
that the secondary cores get to this pen and the kernel can then start the
cores from here.
NOTE: This code must be self-contained.
*/
#include <Library/ArmLib.h>
.text
.align 3
GCC_ASM_EXPORT(SecondariesPenStart)
ASM_GLOBAL SecondariesPenEnd
ASM_PFX(SecondariesPenStart):
// Registers x0-x3 are reserved for future use and should be set to zero.
mov x0, xzr
mov x1, xzr
mov x2, xzr
mov x3, xzr
// Get core position. Taken from ArmPlatformGetCorePosition().
// Assumes max 4 cores per cluster.
mrs x4, mpidr_el1 // Get MPCore register.
and x5, x4, #ARM_CORE_MASK // Get core number.
and x4, x4, #ARM_CLUSTER_MASK // Get cluster number.
add x4, x5, x4, LSR #6 // Add scaled cluster number to core number.
lsl x4, x4, 3 // Get mailbox offset for this core.
ldr x5, AsmMailboxbase // Get mailbox addr relative to pc (36 bytes ahead).
add x4, x4, x5 // Add core mailbox offset to base of mailbox.
1: ldr x5, [x4] // Load value from mailbox.
cmp xzr, x5 // Has the mailbox been set?
b.ne 2f // If so break out of loop.
wfe // If not, wait a bit.
b 1b // Wait over, check if mailbox set again.
2: br x5 // Jump to mailbox value.
.align 3 // Make sure the variable below is 8 byte aligned.
.global AsmMailboxbase
AsmMailboxbase: .xword 0xdeaddeadbeefbeef
SecondariesPenEnd:

177
ArmPkg/Application/LinuxLoader/Arm/LinuxAtag.c Normal file
View File

@ -0,0 +1,177 @@
/** @file
*
* Copyright (c) 2011-2015, 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 "LinuxAtag.h"
#include "LinuxLoader.h"
// Point to the current ATAG
STATIC LINUX_ATAG *mLinuxKernelCurrentAtag;
STATIC
VOID
SetupCoreTag (
IN UINT32 PageSize
)
{
mLinuxKernelCurrentAtag->header.size = tag_size (LINUX_ATAG_CORE);
mLinuxKernelCurrentAtag->header.type = ATAG_CORE;
mLinuxKernelCurrentAtag->body.core_tag.flags = 1; /* ensure read-only */
mLinuxKernelCurrentAtag->body.core_tag.pagesize = PageSize; /* systems PageSize (4k) */
mLinuxKernelCurrentAtag->body.core_tag.rootdev = 0; /* zero root device (typically overridden from kernel command line )*/
// move pointer to next tag
mLinuxKernelCurrentAtag = next_tag_address (mLinuxKernelCurrentAtag);
}
STATIC
VOID
SetupMemTag (
IN UINTN StartAddress,
IN UINT32 Size
)
{
mLinuxKernelCurrentAtag->header.size = tag_size (LINUX_ATAG_MEM);
mLinuxKernelCurrentAtag->header.type = ATAG_MEM;
mLinuxKernelCurrentAtag->body.mem_tag.start = StartAddress; /* Start of memory chunk for AtagMem */
mLinuxKernelCurrentAtag->body.mem_tag.size = Size; /* Size of memory chunk for AtagMem */
// move pointer to next tag
mLinuxKernelCurrentAtag = next_tag_address (mLinuxKernelCurrentAtag);
}
STATIC
VOID
SetupCmdlineTag (
IN CONST CHAR8 *CmdLine
)
{
UINT32 LineLength;
// Increment the line length by 1 to account for the null string terminator character
LineLength = AsciiStrLen (CmdLine) + 1;
/* Check for NULL strings.
* Do not insert a tag for an empty CommandLine, don't even modify the tag address pointer.
* Remember, you have at least one null string terminator character.
*/
if (LineLength > 1) {
mLinuxKernelCurrentAtag->header.size = ((UINT32)sizeof (LINUX_ATAG_HEADER) + LineLength + (UINT32)3) >> 2;
mLinuxKernelCurrentAtag->header.type = ATAG_CMDLINE;
/* place CommandLine into tag */
AsciiStrCpy (mLinuxKernelCurrentAtag->body.cmdline_tag.cmdline, CmdLine);
// move pointer to next tag
mLinuxKernelCurrentAtag = next_tag_address (mLinuxKernelCurrentAtag);
}
}
STATIC
VOID
SetupInitrdTag (
IN UINT32 InitrdImage,
IN UINT32 InitrdImageSize
)
{
mLinuxKernelCurrentAtag->header.size = tag_size (LINUX_ATAG_INITRD2);
mLinuxKernelCurrentAtag->header.type = ATAG_INITRD2;
mLinuxKernelCurrentAtag->body.initrd2_tag.start = InitrdImage;
mLinuxKernelCurrentAtag->body.initrd2_tag.size = InitrdImageSize;
// Move pointer to next tag
mLinuxKernelCurrentAtag = next_tag_address (mLinuxKernelCurrentAtag);
}
STATIC
VOID
SetupEndTag (
VOID
)
{
// Empty tag ends list; this has zero length and no body
mLinuxKernelCurrentAtag->header.type = ATAG_NONE;
mLinuxKernelCurrentAtag->header.size = 0;
/* We can not calculate the next address by using the standard macro:
* Params = next_tag_address (Params);
* because it relies on the header.size, which here it is 0 (zero).
* The easiest way is to add the sizeof (mLinuxKernelCurrentAtag->header).
*/
mLinuxKernelCurrentAtag = (LINUX_ATAG*)((UINT32)mLinuxKernelCurrentAtag + sizeof (mLinuxKernelCurrentAtag->header));
}
EFI_STATUS
PrepareAtagList (
IN EFI_PHYSICAL_ADDRESS SystemMemoryBase,
IN CONST CHAR8* CommandLineString,
IN EFI_PHYSICAL_ADDRESS InitrdImage,
IN UINTN InitrdImageSize,
OUT EFI_PHYSICAL_ADDRESS *AtagBase,
OUT UINT32 *AtagSize
)
{
EFI_STATUS Status;
LIST_ENTRY *ResourceLink;
LIST_ENTRY ResourceList;
EFI_PHYSICAL_ADDRESS AtagStartAddress;
SYSTEM_MEMORY_RESOURCE *Resource;
AtagStartAddress = LINUX_ATAG_MAX_OFFSET;
Status = gBS->AllocatePages (AllocateMaxAddress, EfiBootServicesData, EFI_SIZE_TO_PAGES (ATAG_MAX_SIZE), &AtagStartAddress);
if (EFI_ERROR (Status)) {
DEBUG ((EFI_D_WARN, "Warning: Failed to allocate Atag at 0x%lX (%r). The Atag will be allocated somewhere else in System Memory.\n", AtagStartAddress, Status));
Status = gBS->AllocatePages (AllocateAnyPages, EfiBootServicesData, EFI_SIZE_TO_PAGES (ATAG_MAX_SIZE), &AtagStartAddress);
if (EFI_ERROR (Status)) {
return Status;
}
}
// Ready to setup the atag list
mLinuxKernelCurrentAtag = (LINUX_ATAG*)(UINTN)AtagStartAddress;
// Standard core tag 4k PageSize
SetupCoreTag ( (UINT32)SIZE_4KB );
// Physical memory setup
GetSystemMemoryResources (&ResourceList);
ResourceLink = ResourceList.ForwardLink;
while (ResourceLink != NULL && ResourceLink != &ResourceList) {
Resource = (SYSTEM_MEMORY_RESOURCE*)ResourceLink;
DEBUG ((EFI_D_INFO, "- [0x%08X,0x%08X]\n",
(UINT32)Resource->PhysicalStart,
(UINT32)Resource->PhysicalStart + (UINT32)Resource->ResourceLength));
SetupMemTag ((UINT32)Resource->PhysicalStart, (UINT32)Resource->ResourceLength );
ResourceLink = ResourceLink->ForwardLink;
}
// CommandLine setting root device
if (CommandLineString) {
SetupCmdlineTag (CommandLineString);
}
if (InitrdImageSize > 0 && InitrdImage != 0) {
SetupInitrdTag ((UINT32)InitrdImage, (UINT32)InitrdImageSize);
}
// End of tags
SetupEndTag ();
// Calculate atag list size
*AtagBase = AtagStartAddress;
*AtagSize = (UINT32)mLinuxKernelCurrentAtag - (UINT32)AtagStartAddress + 1;
return EFI_SUCCESS;
}

124
ArmPkg/Application/LinuxLoader/Arm/LinuxAtag.h Normal file
View File

@ -0,0 +1,124 @@
/** @file
*
* Copyright (c) 2011-2015, 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.
*
**/
#ifndef __LINUX_ATAG_H__
#define __LINUX_ATAG_H__
//
// ATAG Definitions
//
#define ATAG_MAX_SIZE 0x3000
/* ATAG : list of possible tags */
#define ATAG_NONE 0x00000000
#define ATAG_CORE 0x54410001
#define ATAG_MEM 0x54410002
#define ATAG_VIDEOTEXT 0x54410003
#define ATAG_RAMDISK 0x54410004
#define ATAG_INITRD2 0x54420005
#define ATAG_SERIAL 0x54410006
#define ATAG_REVISION 0x54410007
#define ATAG_VIDEOLFB 0x54410008
#define ATAG_CMDLINE 0x54410009
#define ATAG_ARM_MP_CORE 0x5441000A
#define next_tag_address(t) ((LINUX_ATAG*)((UINT32)(t) + (((t)->header.size) << 2) ))
#define tag_size(type) ((UINT32)((sizeof(LINUX_ATAG_HEADER) + sizeof(type)) >> 2))
typedef struct {
UINT32 size; /* length of tag in words including this header */
UINT32 type; /* tag type */
} LINUX_ATAG_HEADER;
typedef struct {
UINT32 flags;
UINT32 pagesize;
UINT32 rootdev;
} LINUX_ATAG_CORE;
typedef struct {
UINT32 size;
UINTN start;
} LINUX_ATAG_MEM;
typedef struct {
UINT8 x;
UINT8 y;
UINT16 video_page;
UINT8 video_mode;
UINT8 video_cols;
UINT16 video_ega_bx;
UINT8 video_lines;
UINT8 video_isvga;
UINT16 video_points;
} LINUX_ATAG_VIDEOTEXT;
typedef struct {
UINT32 flags;
UINT32 size;
UINTN start;
} LINUX_ATAG_RAMDISK;
typedef struct {
UINT32 start;
UINT32 size;
} LINUX_ATAG_INITRD2;
typedef struct {
UINT32 low;
UINT32 high;
} LINUX_ATAG_SERIALNR;
typedef struct {
UINT32 rev;
} LINUX_ATAG_REVISION;
typedef struct {
UINT16 lfb_width;
UINT16 lfb_height;
UINT16 lfb_depth;
UINT16 lfb_linelength;
UINT32 lfb_base;
UINT32 lfb_size;
UINT8 red_size;
UINT8 red_pos;
UINT8 green_size;
UINT8 green_pos;
UINT8 blue_size;
UINT8 blue_pos;
UINT8 rsvd_size;
UINT8 rsvd_pos;
} LINUX_ATAG_VIDEOLFB;
typedef struct {
CHAR8 cmdline[1];
} LINUX_ATAG_CMDLINE;
typedef struct {
LINUX_ATAG_HEADER header;
union {
LINUX_ATAG_CORE core_tag;
LINUX_ATAG_MEM mem_tag;
LINUX_ATAG_VIDEOTEXT videotext_tag;
LINUX_ATAG_RAMDISK ramdisk_tag;
LINUX_ATAG_INITRD2 initrd2_tag;
LINUX_ATAG_SERIALNR serialnr_tag;
LINUX_ATAG_REVISION revision_tag;
LINUX_ATAG_VIDEOLFB videolfb_tag;
LINUX_ATAG_CMDLINE cmdline_tag;
} body;
} LINUX_ATAG;
#endif /* __LINUX_ATAG_H__ */

346
ArmPkg/Application/LinuxLoader/Arm/LinuxStarter.c Normal file
View File

@ -0,0 +1,346 @@
/** @file
*
* Copyright (c) 2011-2015, 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 <Library/ArmLib.h>
#include <Library/PcdLib.h>
#include <Guid/Fdt.h>
#include "LinuxLoader.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))))
EFI_STATUS
PrepareAtagList (
IN EFI_PHYSICAL_ADDRESS SystemMemoryBase,
IN CONST CHAR8* CommandLineString,
IN EFI_PHYSICAL_ADDRESS InitrdImage,
IN UINTN InitrdImageSize,
OUT EFI_PHYSICAL_ADDRESS *AtagBase,
OUT UINT32 *AtagSize
);
STATIC
VOID
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 ();
}
STATIC
EFI_STATUS
StartLinux (
IN EFI_PHYSICAL_ADDRESS SystemMemoryBase,
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));
return Status;
}
// 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
//
PreparePlatformHardware ();
// 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);
// We cannot recover the execution at this stage
while (1);
}
/**
Start a Linux kernel from a Device Path
@param SystemMemoryBase Base of the system memory
@param LinuxKernel Device Path to the Linux Kernel
@param Parameters Linux kernel arguments
@param Fdt Device Path to the Flat Device Tree
@param MachineType ARM machine type value
@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.
@retval RETURN_UNSUPPORTED ATAG is not support by this architecture
**/
EFI_STATUS
BootLinuxAtag (
IN EFI_PHYSICAL_ADDRESS SystemMemoryBase,
IN EFI_DEVICE_PATH_PROTOCOL* LinuxKernelDevicePath,
IN EFI_DEVICE_PATH_PROTOCOL* InitrdDevicePath,
IN CONST CHAR8* CommandLineArguments,
IN UINTN MachineType
)
{
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 (SystemMemoryBase, 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 (SystemMemoryBase, LinuxImage, LinuxImageSize, AtagBase, AtagSize, MachineType);
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 LinuxKernelDevicePath Device Path to the Linux Kernel
@param InitrdDevicePath Device Path to the Initrd
@param CommandLineArguments Linux command line
@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
BootLinuxFdt (
IN EFI_PHYSICAL_ADDRESS SystemMemoryBase,
IN EFI_DEVICE_PATH_PROTOCOL* LinuxKernelDevicePath,
IN EFI_DEVICE_PATH_PROTOCOL* InitrdDevicePath,
IN EFI_DEVICE_PATH_PROTOCOL* FdtDevicePath,
IN CONST CHAR8* CommandLineArguments
)
{
EFI_STATUS Status;
UINT32 LinuxImageSize;
UINT32 InitrdImageBaseSize = 0;
UINT32 InitrdImageSize = 0;
VOID *InstalledFdtBase;
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;
}
}
if (FdtDevicePath == NULL) {
//
// Get the FDT from the Configuration Table.
// The FDT will be reloaded in PrepareFdt() to a more appropriate
// location for the Linux Kernel.
//
Status = EfiGetSystemConfigurationTable (&gFdtTableGuid, &InstalledFdtBase);
if (EFI_ERROR (Status)) {
Print (L"ERROR: Did not get the Device Tree blob (%r).\n", Status);
goto EXIT_FREE_INITRD;
}
FdtBlobBase = (EFI_PHYSICAL_ADDRESS)(UINTN)InstalledFdtBase;
FdtBlobSize = fdt_totalsize (InstalledFdtBase);
} else {
//
// FDT device path explicitly defined. The FDT is relocated later to a
// more appropriate location for the Linux kernel.
//
FdtBlobBase = LINUX_KERNEL_MAX_OFFSET;
Status = BdsLoadImage (FdtDevicePath, AllocateMaxAddress, &FdtBlobBase, &FdtBlobSize);
if (EFI_ERROR (Status)) {
Print (L"ERROR: Did not find Device Tree blob (%r).\n", Status);
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 (SystemMemoryBase, 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 (SystemMemoryBase, 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;
}

103
ArmPkg/Application/LinuxLoader/LinuxAtagLoader.c
View File

@ -1,103 +0,0 @@
/** @file
*
* Copyright (c) 2011, 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 "LinuxInternal.h"
#include <Library/PrintLib.h>
#include <Library/UefiApplicationEntryPoint.h>
/**
The user Entry Point for Application. The user code starts with this function
as the real entry point for the application.
@param[in] ImageHandle The firmware allocated handle for the EFI image.
@param[in] SystemTable A pointer to the EFI System Table.
@retval EFI_SUCCESS The entry point is executed successfully.
@retval other Some error occurs when executing this entry point.
**/
EFI_STATUS
EFIAPI
UefiMain (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
{
EFI_STATUS Status;
EFI_LOADED_IMAGE_PROTOCOL *LoadedImage;
LINUX_LOADER_OPTIONAL_DATA* LinuxOptionalData;
EFI_DEVICE_PATH* DevicePathKernel;
EFI_DEVICE_PATH* InitrdDevicePath;
CHAR16* OptionalDataInitrd;
CHAR8* OptionalDataArguments;
CHAR16* Initrd;
Status = gBS->HandleProtocol (ImageHandle, &gEfiLoadedImageProtocolGuid, (VOID **)&LoadedImage);
ASSERT_EFI_ERROR (Status);
if (LoadedImage->LoadOptionsSize == 0) {
Status = LinuxLoaderConfig (LoadedImage);
} else {
// Ensure the signature is correct
LinuxOptionalData = (LINUX_LOADER_OPTIONAL_DATA*)LoadedImage->LoadOptions;
if (LinuxOptionalData->Signature != LINUX_LOADER_SIGNATURE) {
return EFI_UNSUPPORTED;
}
// Generate the File Path Node for the Linux Kernel
DevicePathKernel = FileDevicePath (LoadedImage->DeviceHandle, LINUX_KERNEL_NAME);
if (LinuxOptionalData->CmdLineLength > 0) {
OptionalDataArguments = (CHAR8*)LinuxOptionalData + sizeof(LINUX_LOADER_OPTIONAL_DATA);
} else {
OptionalDataArguments = NULL;
}
if (LinuxOptionalData->InitrdPathListLength > 0) {
if (OptionalDataArguments != NULL) {
OptionalDataInitrd = (CHAR16*)(OptionalDataArguments + LinuxOptionalData->CmdLineLength);
} else {
OptionalDataInitrd = (CHAR16*)LinuxOptionalData + sizeof(LINUX_LOADER_OPTIONAL_DATA);
}
// If pointer not aligned
if ((UINTN)OptionalDataInitrd & 0x1) {
Initrd = (CHAR16*)AllocateCopyPool (LinuxOptionalData->InitrdPathListLength, OptionalDataInitrd);
} else {
Initrd = OptionalDataInitrd;
}
InitrdDevicePath = FileDevicePath (LoadedImage->DeviceHandle, Initrd);
} else {
OptionalDataInitrd = NULL;
InitrdDevicePath = NULL;
Initrd = NULL;
}
// Load and Start the Linux Kernel (we should never return)
Status = BdsBootLinuxAtag (DevicePathKernel, InitrdDevicePath, OptionalDataArguments);
if ((UINTN)OptionalDataInitrd & 0x1) {
FreePool (Initrd);
}
FreePool (DevicePathKernel);
if (InitrdDevicePath) {
FreePool (InitrdDevicePath);
}
}
return Status;
}

39
ArmPkg/Application/LinuxLoader/LinuxAtagLoader.inf
View File

@ -1,39 +0,0 @@
#/* @file
# 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.
#
#*/
[Defines]
INF_VERSION = 0x00010006
BASE_NAME = LinuxAtagLoader
FILE_GUID = a912f198-7f0e-4803-b908-b757b806ec83
MODULE_TYPE = UEFI_APPLICATION
VERSION_STRING = 0.1
ENTRY_POINT = UefiMain
[Sources]
LinuxAtagLoader.c
LinuxConfig.c
[Packages]
ArmPkg/ArmPkg.dec
MdePkg/MdePkg.dec
[LibraryClasses]
BdsLib
DxeServicesTableLib
UefiLib
UefiApplicationEntryPoint
[Protocols]
gEfiLoadedImageProtocolGuid
gEfiDevicePathToTextProtocolGuid

354
ArmPkg/Application/LinuxLoader/LinuxConfig.c
View File

@ -1,354 +0,0 @@
/** @file
*
* 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 "LinuxInternal.h"
#define DEFAULT_BOOT_ENTRY_DESCRIPTION L"Linux"
#define MAX_STR_INPUT 300
#define MAX_ASCII_INPUT 300
typedef enum {
LINUX_LOADER_NEW = 1,
LINUX_LOADER_UPDATE
} LINUX_LOADER_ACTION;
STATIC
EFI_STATUS
EditHIInputStr (
IN OUT CHAR16 *CmdLine,
IN UINTN MaxCmdLine
)
{
UINTN CmdLineIndex;
UINTN WaitIndex;
CHAR8 Char;
EFI_INPUT_KEY Key;
EFI_STATUS Status;
Print (CmdLine);
for (CmdLineIndex = StrLen (CmdLine); CmdLineIndex < MaxCmdLine; ) {
Status = gBS->WaitForEvent (1, &gST->ConIn->WaitForKey, &WaitIndex);
ASSERT_EFI_ERROR (Status);
Status = gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);
ASSERT_EFI_ERROR (Status);
// Unicode character is valid when Scancode is NUll
if (Key.ScanCode == SCAN_NULL) {
// Scan code is NUll, hence read Unicode character
Char = (CHAR8)Key.UnicodeChar;
} else {
Char = CHAR_NULL;
}
if ((Char == CHAR_LINEFEED) || (Char == CHAR_CARRIAGE_RETURN) || (Char == 0x7f)) {
CmdLine[CmdLineIndex] = '\0';
Print (L"\n\r");
return EFI_SUCCESS;
} else if ((Key.UnicodeChar == L'\b') || (Key.ScanCode == SCAN_LEFT) || (Key.ScanCode == SCAN_DELETE)){
if (CmdLineIndex != 0) {
CmdLineIndex--;
Print (L"\b \b");
}
} else if ((Key.ScanCode == SCAN_ESC) || (Char == 0x1B) || (Char == 0x0)) {
return EFI_INVALID_PARAMETER;
} else {
CmdLine[CmdLineIndex++] = Key.UnicodeChar;
Print (L"%c", Key.UnicodeChar);
}
}
return EFI_SUCCESS;
}
STATIC
EFI_STATUS
EditHIInputAscii (
IN OUT CHAR8 *CmdLine,
IN UINTN MaxCmdLine
)
{
CHAR16* Str;
EFI_STATUS Status;
Str = (CHAR16*)AllocatePool (MaxCmdLine * sizeof(CHAR16));
AsciiStrToUnicodeStr (CmdLine, Str);
Status = EditHIInputStr (Str, MaxCmdLine);
UnicodeStrToAsciiStr (Str, CmdLine);
FreePool (Str);
return Status;
}
STATIC
EFI_STATUS
GetHIInputInteger (
OUT UINTN *Integer
)
{
CHAR16 CmdLine[255];
EFI_STATUS Status;
CmdLine[0] = '\0';
Status = EditHIInputStr (CmdLine, 255);
if (!EFI_ERROR(Status)) {
*Integer = StrDecimalToUintn (CmdLine);
}
return Status;
}
#if 0
EFI_STATUS
GenerateDeviceDescriptionName (
IN EFI_HANDLE Handle,
IN OUT CHAR16* Description
)
{
EFI_STATUS Status;
EFI_COMPONENT_NAME_PROTOCOL* ComponentName2Protocol;
EFI_DEVICE_PATH_TO_TEXT_PROTOCOL* DevicePathToTextProtocol;
EFI_DEVICE_PATH_PROTOCOL* DevicePathProtocol;
CHAR16* DriverName;
CHAR16* DevicePathTxt;
EFI_DEVICE_PATH* DevicePathNode;
ComponentName2Protocol = NULL;
Status = gBS->HandleProtocol (Handle, &gEfiComponentName2ProtocolGuid, (VOID **)&ComponentName2Protocol);
if (!EFI_ERROR(Status)) {
//TODO: Fixme. we must find the best langague
Status = ComponentName2Protocol->GetDriverName (ComponentName2Protocol,"en",&DriverName);
if (!EFI_ERROR(Status)) {
StrnCpy (Description,DriverName,BOOT_DEVICE_DESCRIPTION_MAX);
}
}
if (EFI_ERROR(Status)) {
// Use the lastest non null entry of the Device path as a description
Status = gBS->HandleProtocol (Handle, &gEfiDevicePathProtocolGuid, (VOID **)&DevicePathProtocol);
if (EFI_ERROR(Status)) {
return Status;
}
// Convert the last non end-type Device Path Node in text for the description
DevicePathNode = GetLastDevicePathNode (DevicePathProtocol);
Status = gBS->LocateProtocol (&gEfiDevicePathToTextProtocolGuid, NULL, (VOID **)&DevicePathToTextProtocol);
ASSERT_EFI_ERROR(Status);
DevicePathTxt = DevicePathToTextProtocol->ConvertDevicePathToText(DevicePathNode,TRUE,TRUE);
StrnCpy (Description, DevicePathTxt, BOOT_DEVICE_DESCRIPTION_MAX);
FreePool (DevicePathTxt);
}
return EFI_SUCCESS;
}
#endif
EFI_STATUS
LinuxLoaderConfig (
IN EFI_LOADED_IMAGE_PROTOCOL *LoadedImage
)
{
EFI_STATUS Status;
LINUX_LOADER_ACTION Choice;
UINTN BootOrderSize;
UINT16* BootOrder;
UINTN BootOrderCount;
UINTN Index;
CHAR16 Description[MAX_ASCII_INPUT];
CHAR8 CmdLine[MAX_ASCII_INPUT];
CHAR16 Initrd[MAX_STR_INPUT];
UINT16 InitrdPathListLength;
UINT16 CmdLineLength;
BDS_LOAD_OPTION* BdsLoadOption;
BDS_LOAD_OPTION** SupportedBdsLoadOptions;
UINTN SupportedBdsLoadOptionCount;
LINUX_LOADER_OPTIONAL_DATA* LinuxOptionalData;
EFI_DEVICE_PATH* DevicePathRoot;
Choice = (LINUX_LOADER_ACTION)0;
SupportedBdsLoadOptions = NULL;
SupportedBdsLoadOptionCount = 0;
do {
Print (L"[%d] Create new Linux Boot Entry\n",LINUX_LOADER_NEW);
Print (L"[%d] Update Linux Boot Entry\n",LINUX_LOADER_UPDATE);
Print (L"Option: ");
Status = GetHIInputInteger ((UINTN*)&Choice);
if (Status == EFI_INVALID_PARAMETER) {
Print (L"\n");
return Status;
} else if ((Choice != LINUX_LOADER_NEW) && (Choice != LINUX_LOADER_UPDATE)) {
Print (L"Error: the option should be either '%d' or '%d'\n",LINUX_LOADER_NEW,LINUX_LOADER_UPDATE);
Status = EFI_INVALID_PARAMETER;
}
} while (EFI_ERROR(Status));
if (Choice == LINUX_LOADER_UPDATE) {
// If no compatible entry then we just create a new entry
Choice = LINUX_LOADER_NEW;
// Scan the OptionalData of every entry for the correct signature
Status = GetGlobalEnvironmentVariable (L"BootOrder", NULL, &BootOrderSize, (VOID**)&BootOrder);
if (!EFI_ERROR(Status)) {
BootOrderCount = BootOrderSize / sizeof(UINT16);
// Allocate an array to handle maximum number of supported Boot Entry
SupportedBdsLoadOptions = (BDS_LOAD_OPTION**)AllocatePool(sizeof(BDS_LOAD_OPTION*) * BootOrderCount);
SupportedBdsLoadOptionCount = 0;
// Check if the signature is present in the list of the current Boot entries
for (Index = 0; Index < BootOrderCount; Index++) {
Status = BootOptionFromLoadOptionIndex (BootOrder[Index], &BdsLoadOption);
if (!EFI_ERROR(Status)) {
if ((BdsLoadOption->OptionalDataSize >= sizeof(UINT32)) &&
(*(UINT32*)BdsLoadOption->OptionalData == LINUX_LOADER_SIGNATURE)) {
SupportedBdsLoadOptions[SupportedBdsLoadOptionCount++] = BdsLoadOption;
Choice = LINUX_LOADER_UPDATE;
}
}
}
}
FreePool (BootOrder);
}
if (Choice == LINUX_LOADER_NEW) {
Description[0] = '\0';
CmdLine[0] = '\0';
Initrd[0] = '\0';
BdsLoadOption = (BDS_LOAD_OPTION*)AllocateZeroPool (sizeof(BDS_LOAD_OPTION));
DEBUG_CODE_BEGIN();
CHAR16* DevicePathTxt;
EFI_DEVICE_PATH_TO_TEXT_PROTOCOL* DevicePathToTextProtocol;
Status = gBS->LocateProtocol (&gEfiDevicePathToTextProtocolGuid, NULL, (VOID **)&DevicePathToTextProtocol);
ASSERT_EFI_ERROR(Status);
DevicePathTxt = DevicePathToTextProtocol->ConvertDevicePathToText (LoadedImage->FilePath, TRUE, TRUE);
Print(L"EFI OS Loader: %s\n",DevicePathTxt);
FreePool(DevicePathTxt);
DEBUG_CODE_END();
//
// Fill the known fields of BdsLoadOption
//
BdsLoadOption->Attributes = LOAD_OPTION_ACTIVE | LOAD_OPTION_CATEGORY_BOOT;
// Get the full Device Path for this file
Status = gBS->HandleProtocol (LoadedImage->DeviceHandle, &gEfiDevicePathProtocolGuid, (VOID **)&DevicePathRoot);
ASSERT_EFI_ERROR(Status);
BdsLoadOption->FilePathList = AppendDevicePath (DevicePathRoot, LoadedImage->FilePath);
BdsLoadOption->FilePathListLength = GetDevicePathSize (BdsLoadOption->FilePathList);
} else {
if (SupportedBdsLoadOptionCount > 1) {
for (Index = 0; Index < SupportedBdsLoadOptionCount; Index++) {
Print (L"[%d] %s\n",Index + 1,SupportedBdsLoadOptions[Index]->Description);
}
do {
Print (L"Update Boot Entry: ");
Status = GetHIInputInteger ((UINTN*)&Choice);
if (Status == EFI_INVALID_PARAMETER) {
Print (L"\n");
return Status;
} else if ((Choice < 1) && (Choice > SupportedBdsLoadOptionCount)) {
Print (L"Choose entry from 1 to %d\n",SupportedBdsLoadOptionCount);
Status = EFI_INVALID_PARAMETER;
}
} while (EFI_ERROR(Status));
BdsLoadOption = SupportedBdsLoadOptions[Choice-1];
}
StrnCpy (Description, BdsLoadOption->Description, MAX_STR_INPUT);
LinuxOptionalData = (LINUX_LOADER_OPTIONAL_DATA*)BdsLoadOption->OptionalData;
if (LinuxOptionalData->CmdLineLength > 0) {
CopyMem (CmdLine, (CHAR8*)LinuxOptionalData + sizeof(LINUX_LOADER_OPTIONAL_DATA), LinuxOptionalData->CmdLineLength);
} else {
CmdLine[0] = '\0';
}
if (LinuxOptionalData->InitrdPathListLength > 0) {
CopyMem (Initrd, (CHAR8*)LinuxOptionalData + sizeof(LINUX_LOADER_OPTIONAL_DATA) + LinuxOptionalData->CmdLineLength, LinuxOptionalData->InitrdPathListLength);
} else {
Initrd[0] = L'\0';
}
DEBUG((EFI_D_ERROR,"L\n"));
}
// Description
Print (L"Description: ");
Status = EditHIInputStr (Description, MAX_STR_INPUT);
if (EFI_ERROR(Status)) {
return Status;
}
if (StrLen (Description) == 0) {
StrnCpy (Description, DEFAULT_BOOT_ENTRY_DESCRIPTION, MAX_STR_INPUT);
}
BdsLoadOption->Description = Description;
// CmdLine
Print (L"Command Line: ");
Status = EditHIInputAscii (CmdLine, MAX_ASCII_INPUT);
if (EFI_ERROR(Status)) {
return Status;
}
// Initrd
Print (L"Initrd name: ");
Status = EditHIInputStr (Initrd, MAX_STR_INPUT);
if (EFI_ERROR(Status)) {
return Status;
}
CmdLineLength = AsciiStrLen (CmdLine);
if (CmdLineLength > 0) {
CmdLineLength += sizeof(CHAR8);
}
InitrdPathListLength = StrLen (Initrd) * sizeof(CHAR16);
if (InitrdPathListLength > 0) {
InitrdPathListLength += sizeof(CHAR16);
}
BdsLoadOption->OptionalDataSize = sizeof(LINUX_LOADER_OPTIONAL_DATA) + CmdLineLength + InitrdPathListLength;
LinuxOptionalData = (LINUX_LOADER_OPTIONAL_DATA*)AllocatePool (BdsLoadOption->OptionalDataSize);
BdsLoadOption->OptionalData = LinuxOptionalData;
LinuxOptionalData->Signature = LINUX_LOADER_SIGNATURE;
LinuxOptionalData->CmdLineLength = CmdLineLength;
LinuxOptionalData->InitrdPathListLength = InitrdPathListLength;
if (CmdLineLength > 0) {
CopyMem (LinuxOptionalData + 1, CmdLine, CmdLineLength);
}
if (InitrdPathListLength > 0) {
CopyMem ((UINT8*)(LinuxOptionalData + 1) + CmdLineLength, Initrd, InitrdPathListLength);
}
// Create or Update the boot entry
Status = BootOptionToLoadOptionVariable (BdsLoadOption);
return Status;
}

103
ArmPkg/Application/LinuxLoader/LinuxFdtLoader.c
View File

@ -1,103 +0,0 @@
/** @file
*
* Copyright (c) 2011, 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 "LinuxInternal.h"
#include <Library/PrintLib.h>
#include <Library/UefiApplicationEntryPoint.h>
/**
The user Entry Point for Application. The user code starts with this function
as the real entry point for the application.
@param[in] ImageHandle The firmware allocated handle for the EFI image.
@param[in] SystemTable A pointer to the EFI System Table.
@retval EFI_SUCCESS The entry point is executed successfully.
@retval other Some error occurs when executing this entry point.
**/
EFI_STATUS
EFIAPI
UefiMain (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
{
EFI_STATUS Status;
EFI_LOADED_IMAGE_PROTOCOL *LoadedImage;
LINUX_LOADER_OPTIONAL_DATA* LinuxOptionalData;
EFI_DEVICE_PATH* DevicePathKernel;
EFI_DEVICE_PATH* InitrdDevicePath;
CHAR16* OptionalDataInitrd;
CHAR8* OptionalDataArguments;
CHAR16* Initrd;
Status = gBS->HandleProtocol (ImageHandle, &gEfiLoadedImageProtocolGuid, (VOID **)&LoadedImage);
ASSERT_EFI_ERROR (Status);
if (LoadedImage->LoadOptionsSize == 0) {
Status = LinuxLoaderConfig (LoadedImage);
} else {
// Ensure the signature is correct
LinuxOptionalData = (LINUX_LOADER_OPTIONAL_DATA*)LoadedImage->LoadOptions;
if (LinuxOptionalData->Signature != LINUX_LOADER_SIGNATURE) {
return EFI_UNSUPPORTED;
}
// Generate the File Path Node for the Linux Kernel
DevicePathKernel = FileDevicePath (LoadedImage->DeviceHandle, LINUX_KERNEL_NAME);
if (LinuxOptionalData->CmdLineLength > 0) {
OptionalDataArguments = (CHAR8*)LinuxOptionalData + sizeof(LINUX_LOADER_OPTIONAL_DATA);
} else {
OptionalDataArguments = NULL;
}
if (LinuxOptionalData->InitrdPathListLength > 0) {
if (OptionalDataArguments != NULL) {
OptionalDataInitrd = (CHAR16*)(OptionalDataArguments + LinuxOptionalData->CmdLineLength);
} else {
OptionalDataInitrd = (CHAR16*)LinuxOptionalData + sizeof(LINUX_LOADER_OPTIONAL_DATA);
}
// If pointer not aligned
if ((UINTN)OptionalDataInitrd & 0x1) {
Initrd = (CHAR16*)AllocateCopyPool (LinuxOptionalData->InitrdPathListLength, OptionalDataInitrd);
} else {
Initrd = OptionalDataInitrd;
}
InitrdDevicePath = FileDevicePath (LoadedImage->DeviceHandle, Initrd);
} else {
OptionalDataInitrd = NULL;
InitrdDevicePath = NULL;
Initrd = NULL;
}
// Load and Start the Linux Kernel (we should never return)
Status = BdsBootLinuxFdt (DevicePathKernel, InitrdDevicePath, OptionalDataArguments);
if ((UINTN)OptionalDataInitrd & 0x1) {
FreePool (Initrd);
}
FreePool (DevicePathKernel);
if (InitrdDevicePath) {
FreePool (InitrdDevicePath);
}
}
return Status;
}

39
ArmPkg/Application/LinuxLoader/LinuxFdtLoader.inf
View File

@ -1,39 +0,0 @@
#/* @file
# 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.
#
#*/
[Defines]
INF_VERSION = 0x00010006
BASE_NAME = LinuxFdtLoader
FILE_GUID = f536d559-459f-48fa-8bbc-43b554ecae8d
MODULE_TYPE = UEFI_APPLICATION
VERSION_STRING = 0.1
ENTRY_POINT = UefiMain
[Sources]
LinuxFdtLoader.c
LinuxConfig.c
[Packages]
ArmPkg/ArmPkg.dec
MdePkg/MdePkg.dec
[LibraryClasses]
BdsLib
DxeServicesTableLib
UefiLib
UefiApplicationEntryPoint
[Protocols]
gEfiLoadedImageProtocolGuid
gEfiDevicePathToTextProtocolGuid

50
ArmPkg/Application/LinuxLoader/LinuxInternal.h
View File

@ -1,50 +0,0 @@
/** @file
*
* 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.
*
**/
#ifndef __LOADER_INTERNAL_H
#define __LOADER_INTERNAL_H
#include <Uefi.h>
#include <Library/BaseMemoryLib.h>
#include <Library/BdsLib.h>
#include <Library/DebugLib.h>
#include <Library/DevicePathLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/UefiLib.h>
#include <Protocol/LoadedImage.h>
#include <Protocol/DevicePathToText.h>
#define LINUX_KERNEL_NAME L"zImage"
#define FDT_NAME L"platform.dtb"
#define LINUX_LOADER_SIGNATURE SIGNATURE_32('l', 'i', 'l', 'o')
typedef struct {
UINT32 Signature;
UINT16 CmdLineLength;
UINT16 InitrdPathListLength;
// These following fields have variable length:
//CHAR8* CmdLine;
//CHAR16* Initrd;
} LINUX_LOADER_OPTIONAL_DATA;
EFI_STATUS
LinuxLoaderConfig (
IN EFI_LOADED_IMAGE_PROTOCOL *LoadedImage
);
#endif

246
ArmPkg/Application/LinuxLoader/LinuxLoader.c Normal file
View File

@ -0,0 +1,246 @@
/** @file
*
* Copyright (c) 2011-2015, 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 <Library/UefiApplicationEntryPoint.h>
#include <Library/BaseMemoryLib.h>
#include <Protocol/DevicePathFromText.h>
#include "LinuxLoader.h"
/**
The user Entry Point for Application. The user code starts with this function
as the real entry point for the application.
@param[in] ImageHandle The firmware allocated handle for the EFI image.
@param[in] SystemTable A pointer to the EFI System Table.
@retval EFI_SUCCESS The entry point was executed successfully.
@retval EFI_NOT_FOUND Protocol not found.
@retval EFI_NOT_FOUND Path to the Linux kernel not found.
@retval EFI_ABORTED The initialisation of the Shell Library failed.
@retval EFI_INVALID_PARAMETER At least one parameter is not valid or there is a
conflict between two parameters.
@retval EFI_OUT_OF_RESOURCES A memory allocation failed.
**/
EFI_STATUS
EFIAPI
LinuxLoaderEntryPoint (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
{
EFI_STATUS Status;
EFI_DEVICE_PATH_FROM_TEXT_PROTOCOL *EfiDevicePathFromTextProtocol;
EFI_SHELL_PARAMETERS_PROTOCOL *ShellParameters;
CHAR16 *KernelPath;
CHAR16 *FdtPath;
CHAR16 *InitrdPath;
CHAR16 *KernelTextDevicePath;
CHAR16 *FdtTextDevicePath;
CHAR16 *InitrdTextDevicePath;
CHAR16 *LinuxCommandLine;
UINTN AtagMachineType;
EFI_DEVICE_PATH *KernelDevicePath;
EFI_DEVICE_PATH *FdtDevicePath;
EFI_DEVICE_PATH *InitrdDevicePath;
CHAR8 *AsciiLinuxCommandLine;
LIST_ENTRY ResourceList;
LIST_ENTRY *ResourceLink;
SYSTEM_MEMORY_RESOURCE *Resource;
EFI_PHYSICAL_ADDRESS SystemMemoryBase;
Status = gBS->LocateProtocol (
&gEfiDevicePathFromTextProtocolGuid,
NULL,
(VOID **)&EfiDevicePathFromTextProtocol
);
if (EFI_ERROR (Status)) {
return EFI_NOT_FOUND;
}
//
// Register the strings for the user interface in the HII Database.
// This shows the way to the multi-language support, even if
// only the English language is actually supported. The strings to register
// are stored in the "LinuxLoaderStrings[]" array. This array is
// built by the building process from the "*.uni" file associated to
// the present application (cf. LinuxLoader.inf). Examine the Build
// folder of the application and you will find the array defined in the
// LinuxLoaderStrDefs.h file.
//
mLinuxLoaderHiiHandle = HiiAddPackages (
&mLinuxLoaderHiiGuid,
ImageHandle,
LinuxLoaderStrings,
NULL
);
if (mLinuxLoaderHiiHandle == NULL) {
return EFI_NOT_FOUND;
}
Status = gBS->HandleProtocol (
ImageHandle,
&gEfiShellParametersProtocolGuid,
(VOID**)&ShellParameters
);
KernelDevicePath = NULL;
FdtDevicePath = NULL;
InitrdDevicePath = NULL;
AsciiLinuxCommandLine = NULL;
//
// Call the proper function to handle the command line
// depending on whether the application has been called
// from the Shell or not.
//
if (!EFI_ERROR (Status)) {
KernelTextDevicePath = NULL;
FdtTextDevicePath = NULL;
InitrdTextDevicePath = NULL;
Status = ProcessShellParameters (
&KernelPath, &FdtPath, &InitrdPath, &LinuxCommandLine, &AtagMachineType
);
if (EFI_ERROR (Status)) {
goto Error;
}
KernelDevicePath = gEfiShellProtocol->GetDevicePathFromFilePath (KernelPath);
if (KernelDevicePath != NULL) {
FreePool (KernelPath);
} else {
KernelTextDevicePath = KernelPath;
}
if (FdtPath != NULL) {
FdtDevicePath = gEfiShellProtocol->GetDevicePathFromFilePath (FdtPath);
if (FdtDevicePath != NULL) {
FreePool (FdtPath);
} else {
FdtTextDevicePath = FdtPath;
}
}
if (InitrdPath != NULL) {
InitrdDevicePath = gEfiShellProtocol->GetDevicePathFromFilePath (InitrdPath);
if (InitrdDevicePath != NULL) {
FreePool (InitrdPath);
} else {
InitrdTextDevicePath = InitrdPath;
}
}
} else {
Status = ProcessAppCommandLine (
&KernelTextDevicePath, &FdtTextDevicePath,
&InitrdTextDevicePath, &LinuxCommandLine, &AtagMachineType
);
if (EFI_ERROR (Status)) {
goto Error;
}
}
Status = EFI_INVALID_PARAMETER;
if (KernelTextDevicePath != NULL) {
KernelDevicePath = EfiDevicePathFromTextProtocol->ConvertTextToDevicePath (
KernelTextDevicePath
);
if (KernelDevicePath == NULL) {
goto Error;
}
}
if (FdtTextDevicePath != NULL) {
FdtDevicePath = EfiDevicePathFromTextProtocol->ConvertTextToDevicePath (
FdtTextDevicePath
);
if (FdtDevicePath == NULL) {
goto Error;
}
}
if (InitrdTextDevicePath != NULL) {
InitrdDevicePath = EfiDevicePathFromTextProtocol->ConvertTextToDevicePath (
InitrdTextDevicePath
);
if (InitrdDevicePath == NULL) {
goto Error;
}
}
if (LinuxCommandLine != NULL) {
AsciiLinuxCommandLine = AllocatePool ((StrLen (LinuxCommandLine) + 1) * sizeof (CHAR8));
if (AsciiLinuxCommandLine == NULL) {
Status = EFI_OUT_OF_RESOURCES;
goto Error;
}
UnicodeStrToAsciiStr (LinuxCommandLine, AsciiLinuxCommandLine);
}
//
// Find Base of System Memory - we keep the lowest physical address
//
SystemMemoryBase = ~0;
GetSystemMemoryResources (&ResourceList);
ResourceLink = ResourceList.ForwardLink;
while (ResourceLink != NULL && ResourceLink != &ResourceList) {
Resource = (SYSTEM_MEMORY_RESOURCE*)ResourceLink;
if (Resource->PhysicalStart < SystemMemoryBase) {
SystemMemoryBase = Resource->PhysicalStart;
}
ResourceLink = ResourceLink->ForwardLink;
}
if (AtagMachineType != ARM_FDT_MACHINE_TYPE) {
Status = BootLinuxAtag (SystemMemoryBase, KernelDevicePath, InitrdDevicePath, AsciiLinuxCommandLine, AtagMachineType);
} else {
Status = BootLinuxFdt (SystemMemoryBase, KernelDevicePath, InitrdDevicePath, FdtDevicePath, AsciiLinuxCommandLine);
}
Error:
if (KernelTextDevicePath != NULL) {
FreePool (KernelTextDevicePath);
}
if (FdtTextDevicePath != NULL) {
FreePool (FdtTextDevicePath);
}
if (InitrdTextDevicePath != NULL) {
FreePool (InitrdTextDevicePath);
}
if (LinuxCommandLine != NULL) {
FreePool (LinuxCommandLine);
}
if (KernelDevicePath != NULL) {
FreePool (KernelDevicePath);
}
if (FdtDevicePath != NULL) {
FreePool (FdtDevicePath);
}
if (InitrdDevicePath != NULL) {
FreePool (InitrdDevicePath);
}
if (AsciiLinuxCommandLine != NULL) {
FreePool (AsciiLinuxCommandLine);
}
if (EFI_ERROR (Status)) {
PrintHii (NULL, STRING_TOKEN (STR_ERROR), Status);
}
HiiRemovePackages (mLinuxLoaderHiiHandle);
return Status;
}

166
ArmPkg/Application/LinuxLoader/LinuxLoader.h Normal file
View File

@ -0,0 +1,166 @@
/** @file
*
* Copyright (c) 2011-2015, 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.
*
**/
#ifndef __LINUX_LOADER_H__
#define __LINUX_LOADER_H__
#include <Library/BdsLib.h>
#include <Library/DebugLib.h>
#include <Library/HiiLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/PerformanceLib.h>
#include <Library/PrintLib.h>
#include <Library/ShellLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/UefiLib.h>
#include <Protocol/EfiShellParameters.h>
#include <Protocol/EfiShell.h>
#include <libfdt.h>
//
// Definitions
//
#define MAX_MSG_LEN 80
#define LINUX_UIMAGE_SIGNATURE 0x56190527
#define LINUX_KERNEL_MAX_OFFSET (SystemMemoryBase + PcdGet32(PcdArmLinuxKernelMaxOffset))
#define LINUX_ATAG_MAX_OFFSET (SystemMemoryBase + PcdGet32(PcdArmLinuxAtagMaxOffset))
#define LINUX_FDT_MAX_OFFSET (SystemMemoryBase + PcdGet32(PcdArmLinuxFdtMaxOffset))
#define ARM_FDT_MACHINE_TYPE 0xFFFFFFFF
// Additional size that could be used for FDT entries added by the UEFI OS Loader
// Estimation based on: EDID (300bytes) + bootargs (200bytes) + initrd region (20bytes)
// + system memory region (20bytes) + mp_core entries (200 bytes)
#define FDT_ADDITIONAL_ENTRIES_SIZE 0x300
//
// Global variables
//
extern CONST EFI_GUID mLinuxLoaderHiiGuid;
extern EFI_HANDLE mLinuxLoaderHiiHandle;
//
// Local Types
//
typedef struct _SYSTEM_MEMORY_RESOURCE {
LIST_ENTRY Link; // This attribute must be the first entry of this structure (to avoid pointer computation)
EFI_PHYSICAL_ADDRESS PhysicalStart;
UINT64 ResourceLength;
} SYSTEM_MEMORY_RESOURCE;
typedef VOID (*LINUX_KERNEL)(UINT32 Zero, UINT32 Arch, UINTN ParametersBase);
//
// Functions
//
EFI_STATUS
PrintHii (
IN CONST CHAR8 *Language OPTIONAL,
IN CONST EFI_STRING_ID HiiFormatStringId,
...
);
VOID
PrintHelp (
IN CONST CHAR8 *Language OPTIONAL
);
EFI_STATUS
ProcessShellParameters (
OUT CHAR16 **KernelPath,
OUT CHAR16 **FdtPath,
OUT CHAR16 **InitrdPath,
OUT CHAR16 **LinuxCommandLine,
OUT UINTN *AtagMachineType
);
EFI_STATUS
ProcessAppCommandLine (
OUT CHAR16 **KernelTextDevicePath,
OUT CHAR16 **FdtTextDevicePath,
OUT CHAR16 **InitrdTextDevicePath,
OUT CHAR16 **LinuxCommandLine,
OUT UINTN *AtagMachineType
);
VOID
PrintPerformance (
VOID
);
EFI_STATUS
GetSystemMemoryResources (
IN LIST_ENTRY *ResourceList
);
EFI_STATUS
PrepareFdt (
IN EFI_PHYSICAL_ADDRESS SystemMemoryBase,
IN CONST CHAR8* CommandLineArguments,
IN EFI_PHYSICAL_ADDRESS InitrdImage,
IN UINTN InitrdImageSize,
IN OUT EFI_PHYSICAL_ADDRESS *FdtBlobBase,
IN OUT UINTN *FdtBlobSize
);
/**
Start a Linux kernel from a Device Path
@param SystemMemoryBase Base of the system memory
@param LinuxKernel Device Path to the Linux Kernel
@param Parameters Linux kernel arguments
@param Fdt Device Path to the Flat Device Tree
@param MachineType ARM machine type value
@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.
@retval RETURN_UNSUPPORTED ATAG is not support by this architecture
**/
EFI_STATUS
BootLinuxAtag (
IN EFI_PHYSICAL_ADDRESS SystemMemoryBase,
IN EFI_DEVICE_PATH_PROTOCOL* LinuxKernelDevicePath,
IN EFI_DEVICE_PATH_PROTOCOL* InitrdDevicePath,
IN CONST CHAR8* CommandLineArguments,
IN UINTN MachineType
);
/**
Start a Linux kernel from a Device Path
@param[in] LinuxKernelDevicePath Device Path to the Linux Kernel
@param[in] InitrdDevicePath Device Path to the Initrd
@param[in] Arguments Linux kernel arguments
@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
BootLinuxFdt (
IN EFI_PHYSICAL_ADDRESS SystemMemoryBase,
IN EFI_DEVICE_PATH_PROTOCOL* LinuxKernelDevicePath,
IN EFI_DEVICE_PATH_PROTOCOL* InitrdDevicePath,
IN EFI_DEVICE_PATH_PROTOCOL* FdtDevicePath,
IN CONST CHAR8* Arguments
);
#endif /* __LINUX_LOADER_H__ */

91
ArmPkg/Application/LinuxLoader/LinuxLoader.inf Normal file
View File

@ -0,0 +1,91 @@
#/* @file
# Copyright (c) 2015, 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.
#
#*/
[Defines]
INF_VERSION = 0x00010006
BASE_NAME = LinuxLoader
MODULE_UNI_FILE = LinuxLoader.uni
FILE_GUID = 701f54f2-0d70-4b89-bc0a-d9ca25379059
MODULE_TYPE = UEFI_APPLICATION
VERSION_STRING = 0.1
ENTRY_POINT = LinuxLoaderEntryPoint
[Sources]
LinuxLoader.c
LinuxLoader.h
LinuxLoader.uni
LinuxLoaderFdt.c
LinuxLoaderHelper.c
LinuxLoaderEfiApp.c
LinuxLoaderShellApp.c
[Sources.AARCH64]
AArch64/LinuxStarter.c
AArch64/LinuxStarterHelper.S
[Sources.ARM]
Arm/LinuxAtag.h
Arm/LinuxAtag.c
Arm/LinuxStarter.c
[Packages]
ArmPkg/ArmPkg.dec
EmbeddedPkg/EmbeddedPkg.dec
MdePkg/MdePkg.dec
MdeModulePkg/MdeModulePkg.dec
ShellPkg/ShellPkg.dec
[Guids]
gFdtTableGuid
[Guids]
gArmMpCoreInfoGuid
[LibraryClasses]
ArmLib
BdsLib
DebugLib
DxeServicesTableLib
FdtLib
HiiLib
HobLib
PerformanceLib
ShellLib
SerialPortLib
TimerLib
UefiApplicationEntryPoint
UefiLib
[LibraryClasses.AARCH64]
ArmGicLib
PcdLib
[Protocols]
gEfiLoadedImageProtocolGuid
gEfiDevicePathToTextProtocolGuid
gEfiShellParametersProtocolGuid
[FeaturePcd]
gArmTokenSpaceGuid.PcdArmLinuxSpinTable
[FixedPcd]
gArmTokenSpaceGuid.PcdArmLinuxFdtMaxOffset
gArmTokenSpaceGuid.PcdArmLinuxFdtAlignment
gArmTokenSpaceGuid.PcdArmLinuxKernelMaxOffset
[FixedPcd.ARM]
gArmTokenSpaceGuid.PcdArmLinuxAtagMaxOffset
[Pcd.AARCH64]
gArmTokenSpaceGuid.PcdGicDistributorBase
gArmTokenSpaceGuid.PcdGicSgiIntId

BIN
ArmPkg/Application/LinuxLoader/LinuxLoader.uni Normal file
View File

Binary file not shown.

303
ArmPkg/Application/LinuxLoader/LinuxLoaderEfiApp.c Normal file
View File

@ -0,0 +1,303 @@
/** @file
*
* Copyright (c) 2011-2015, 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 "LinuxLoader.h"
/**
Extract the next item from the command line.
The items are separated by spaces. Quotation marks (") are used for argument
grouping and the escaping character is "^" as for the EFI Shell command lines.
@param[in out] CommandLine Command line pointer.
@param[out] Item Pointer to the allocated buffer where the
item is stored.
@retval EFI_SUCCESS The token was found and extracted.
@retval EFI_NOT_FOUND No item found.
@retval EFI_OUT_OF_RESOURCES The memory allocation failed.
**/
STATIC
EFI_STATUS
ExtractNextItem (
IN OUT CONST CHAR16 **CommandLine,
OUT CHAR16 **Item
)
{
CONST CHAR16 *Walker;
VOID *Buffer;
CHAR16 *WritePtr;
BOOLEAN InQuotedString;
BOOLEAN Interpret;
for (Walker = *CommandLine; *Walker == L' '; Walker++) {
;
}
Buffer = AllocatePool (StrSize (Walker));
if (Buffer == NULL) {
return EFI_OUT_OF_RESOURCES;
}
for (WritePtr = Buffer, Interpret = TRUE, InQuotedString = FALSE;
((*Walker != L' ') || InQuotedString) && (*Walker != L'\0');
Walker++
) {
if (Interpret) {
if (*Walker == L'^') {
Interpret = FALSE;
continue;
}
if (*Walker == L'"') {
InQuotedString = !InQuotedString;
continue;
}
} else {
Interpret = TRUE;
}
*(WritePtr++) = *Walker;
}
if (WritePtr == Buffer) {
FreePool (Buffer);
return EFI_NOT_FOUND;
}
*WritePtr = L'\0';
*CommandLine = Walker;
*Item = Buffer;
return EFI_SUCCESS;
}
/**
Check if an item of the command line is a flag or not.
@param[in] Item Command line item.
@retval TRUE The item is a flag.
@retval FALSE The item is not a flag.
**/
STATIC
BOOLEAN
IsFlag (
IN CONST CHAR16 *Item
)
{
return ((Item[0] == L'-') && (Item[2] == L'\0'));
}
/**
Process the application command line.
@param[out] KernelTextDevicePath A pointer to the buffer where the device
path to the Linux kernel is stored. The
address of the buffer is NULL in case of
an error. Otherwise, the returned address
is the address of a buffer allocated with
a call to AllocatePool() that has to be
freed by the caller.
@param[out] FdtTextDevicePath A pointer to the buffer where the device
path to the FDT is stored. The address of
the buffer is NULL in case of an error or
if the device path to the FDT is not
defined. Otherwise, the returned address
is the address of a buffer allocated with
a call to AllocatePool() that has to be
freed by the caller.
@param[out] InitrdTextDevicePath A pointer to the buffer where the device
path to the RAM root file system is stored.
The address of the buffer is NULL in case
of an error or if the device path to the
RAM root file system is not defined.
Otherwise, the returned address is the
address of a buffer allocated with a call
to AllocatePool() that has to be freed by
the caller.
@param[out] LinuxCommandLine A pointer to the buffer where the Linux
kernel command line is stored. The address
of the buffer is NULL in case of an error
or if the Linux command line is not
defined. Otherwise, the returned address
is the address of a buffer allocated with
a call to AllocatePool() that has to be
freed by the caller.
@param[out] AtagMachineType Value of the ARM Machine Type
@retval EFI_SUCCESS The processing was successfull.
@retval EFI_NOT_FOUND EFI_LOADED_IMAGE_PROTOCOL not found.
@retval EFI_NOT_FOUND Path to the Linux kernel not found.
@retval EFI_INVALID_PARAMETER At least one parameter is not valid or there is a
conflict between two parameters.
@retval EFI_OUT_OF_RESOURCES A memory allocation failed.
**/
EFI_STATUS
ProcessAppCommandLine (
OUT CHAR16 **KernelTextDevicePath,
OUT CHAR16 **FdtTextDevicePath,
OUT CHAR16 **InitrdTextDevicePath,
OUT CHAR16 **LinuxCommandLine,
OUT UINTN *AtagMachineType
)
{
EFI_STATUS Status;
EFI_STATUS Status2;
EFI_LOADED_IMAGE_PROTOCOL *LoadedImage;
CONST CHAR16 *Walker;
CHAR16 *Item;
CHAR16 Flag;
BOOLEAN HasAtagSupport;
BOOLEAN HasFdtSupport;
*KernelTextDevicePath = NULL;
*FdtTextDevicePath = NULL;
*InitrdTextDevicePath = NULL;
*LinuxCommandLine = NULL;
*AtagMachineType = ARM_FDT_MACHINE_TYPE;
HasAtagSupport = FALSE;
HasFdtSupport = FALSE;
Status = gBS->HandleProtocol (
gImageHandle,
&gEfiLoadedImageProtocolGuid,
(VOID**)&LoadedImage
);
if (EFI_ERROR (Status)) {
ASSERT_EFI_ERROR (Status);
return Status;
}
Walker = (CHAR16*)LoadedImage->LoadOptions;
if (Walker == NULL) {
PrintHelp (NULL);
return EFI_INVALID_PARAMETER;
}
//
// Get the device path to the Linux kernel.
//
Status = ExtractNextItem (&Walker, &Item);
if (!EFI_ERROR (Status)) {
if (!IsFlag (Item)) {
*KernelTextDevicePath = Item;
} else {
PrintHii (NULL, STRING_TOKEN (STR_MISSING_KERNEL_PATH));
FreePool (Item);
return EFI_NOT_FOUND;
}
} else {
if (Status != EFI_NOT_FOUND) {
return Status;
}
PrintHelp (NULL);
return EFI_INVALID_PARAMETER;
}
Status = EFI_INVALID_PARAMETER;
while (*Walker != L'\0') {
Status2 = ExtractNextItem (&Walker, &Item);
if (Status2 == EFI_NOT_FOUND) {
break;
}
if (EFI_ERROR (Status2)) {
Status = Status2;
goto Error;
}
if (!IsFlag (Item)) {
PrintHii (NULL, STRING_TOKEN (STR_INVALID_FLAG), Item[0], Item[1]);
FreePool (Item);
goto Error;
}
Flag = Item[1];
FreePool (Item);
Status2 = ExtractNextItem (&Walker, &Item);
if (Status2 == EFI_NOT_FOUND) {
PrintHii (NULL, STRING_TOKEN (STR_MISSING_VALUE), Flag);
goto Error;
}
if (EFI_ERROR (Status2)) {
Status = Status2;
goto Error;
}
if (IsFlag (Item)) {
PrintHii (NULL, STRING_TOKEN (STR_MISSING_VALUE), Flag);
FreePool (Item);
goto Error;
}
switch (Flag) {
case L'a':
if (HasFdtSupport) {
PrintHii (NULL, STRING_TOKEN (STR_ATAG_FDT_CONFLICT));
goto Error;
}
*AtagMachineType = StrDecimalToUintn (Item);
HasAtagSupport = TRUE;
break;
case L'd':
*FdtTextDevicePath = Item;
if (HasAtagSupport) {
PrintHii (NULL, STRING_TOKEN (STR_ATAG_FDT_CONFLICT));
goto Error;
}
HasFdtSupport = TRUE;
break;
case L'c':
*LinuxCommandLine = Item;
break;
case L'f':
*InitrdTextDevicePath = Item;
break;
default:
PrintHii (NULL, STRING_TOKEN (STR_INVALID_FLAG), L'-', Flag);
FreePool (Item);
goto Error;
}
}
Status = EFI_SUCCESS;
Error:
if (EFI_ERROR (Status)) {
if (*KernelTextDevicePath != NULL) {
FreePool (*KernelTextDevicePath);
*KernelTextDevicePath = NULL;
}
if (*FdtTextDevicePath != NULL) {
FreePool (*FdtTextDevicePath);
*FdtTextDevicePath = NULL;
}
if (*InitrdTextDevicePath != NULL) {
FreePool (*InitrdTextDevicePath);
*InitrdTextDevicePath = NULL;
}
if (*LinuxCommandLine != NULL) {
FreePool (*LinuxCommandLine);
*LinuxCommandLine = NULL;
}
}
return Status;
}

411
ArmPkg/Application/LinuxLoader/LinuxLoaderFdt.c Normal file
View File

@ -0,0 +1,411 @@
/** @file
*
* Copyright (c) 2011-2015, 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 <PiDxe.h>
#include <Library/ArmLib.h>
#include <Library/HobLib.h>
#include <Guid/ArmMpCoreInfo.h>
#include "LinuxLoader.h"
#define ALIGN(x, a) (((x) + ((a) - 1)) & ~((a) - 1))
#define PALIGN(p, a) ((void *)(ALIGN ((unsigned long)(p), (a))))
#define GET_CELL(p) (p += 4, *((const UINT32 *)(p-4)))
STATIC
UINTN
cpu_to_fdtn (UINTN x) {
if (sizeof (UINTN) == sizeof (UINT32)) {
return cpu_to_fdt32 (x);
} else {
return cpu_to_fdt64 (x);
}
}
typedef struct {
UINTN Base;
UINTN Size;
} FDT_REGION;
STATIC
BOOLEAN
IsLinuxReservedRegion (
IN EFI_MEMORY_TYPE MemoryType
)
{
switch (MemoryType) {
case EfiRuntimeServicesCode:
case EfiRuntimeServicesData:
case EfiUnusableMemory:
case EfiACPIReclaimMemory:
case EfiACPIMemoryNVS:
case EfiReservedMemoryType:
return TRUE;
default:
return FALSE;
}
}
/**
** Relocate the FDT blob to a more appropriate location for the Linux kernel.
** This function will allocate memory for the relocated FDT blob.
**
** @retval EFI_SUCCESS on success.
** @retval EFI_OUT_OF_RESOURCES or EFI_INVALID_PARAMETER on failure.
*/
STATIC
EFI_STATUS
RelocateFdt (
EFI_PHYSICAL_ADDRESS SystemMemoryBase,
EFI_PHYSICAL_ADDRESS OriginalFdt,
UINTN OriginalFdtSize,
EFI_PHYSICAL_ADDRESS *RelocatedFdt,
UINTN *RelocatedFdtSize,
EFI_PHYSICAL_ADDRESS *RelocatedFdtAlloc
)
{
EFI_STATUS Status;
INTN Error;
UINT64 FdtAlignment;
*RelocatedFdtSize = OriginalFdtSize + FDT_ADDITIONAL_ENTRIES_SIZE;
// If FDT load address needs to be aligned, allocate more space.
FdtAlignment = PcdGet32 (PcdArmLinuxFdtAlignment);
if (FdtAlignment != 0) {
*RelocatedFdtSize += FdtAlignment;
}
// Try below a watermark address.
Status = EFI_NOT_FOUND;
if (PcdGet32 (PcdArmLinuxFdtMaxOffset) != 0) {
*RelocatedFdt = LINUX_FDT_MAX_OFFSET;
Status = gBS->AllocatePages (AllocateMaxAddress, EfiBootServicesData,
EFI_SIZE_TO_PAGES (*RelocatedFdtSize), RelocatedFdt);
if (EFI_ERROR (Status)) {
DEBUG ((EFI_D_WARN, "Warning: Failed to load FDT below address 0x%lX (%r). Will try again at a random address anywhere.\n", *RelocatedFdt, Status));
}
}
// Try anywhere there is available space.
if (EFI_ERROR (Status)) {
Status = gBS->AllocatePages (AllocateAnyPages, EfiBootServicesData,
EFI_SIZE_TO_PAGES (*RelocatedFdtSize), RelocatedFdt);
if (EFI_ERROR (Status)) {
ASSERT_EFI_ERROR (Status);
return EFI_OUT_OF_RESOURCES;
} else {
DEBUG ((EFI_D_WARN, "WARNING: Loaded FDT at random address 0x%lX.\nWARNING: There is a risk of accidental overwriting by other code/data.\n", *RelocatedFdt));
}
}
*RelocatedFdtAlloc = *RelocatedFdt;
if (FdtAlignment != 0) {
*RelocatedFdt = ALIGN (*RelocatedFdt, FdtAlignment);
}
// Load the Original FDT tree into the new region
Error = fdt_open_into ((VOID*)(UINTN) OriginalFdt,
(VOID*)(UINTN)(*RelocatedFdt), *RelocatedFdtSize);
if (Error) {
DEBUG ((EFI_D_ERROR, "fdt_open_into(): %a\n", fdt_strerror (Error)));
gBS->FreePages (*RelocatedFdtAlloc, EFI_SIZE_TO_PAGES (*RelocatedFdtSize));
return EFI_INVALID_PARAMETER;
}
return EFI_SUCCESS;
}
EFI_STATUS
PrepareFdt (
IN EFI_PHYSICAL_ADDRESS SystemMemoryBase,
IN CONST CHAR8* CommandLineArguments,
IN EFI_PHYSICAL_ADDRESS InitrdImage,
IN UINTN InitrdImageSize,
IN OUT EFI_PHYSICAL_ADDRESS *FdtBlobBase,
IN OUT UINTN *FdtBlobSize
)
{
EFI_STATUS Status;
EFI_PHYSICAL_ADDRESS NewFdtBlobBase;
EFI_PHYSICAL_ADDRESS NewFdtBlobAllocation;
UINTN NewFdtBlobSize;
VOID* fdt;
INTN err;
INTN node;
INTN cpu_node;
INT32 lenp;
CONST VOID* BootArg;
CONST VOID* Method;
EFI_PHYSICAL_ADDRESS InitrdImageStart;
EFI_PHYSICAL_ADDRESS InitrdImageEnd;
FDT_REGION Region;
UINTN Index;
CHAR8 Name[10];
LIST_ENTRY ResourceList;
SYSTEM_MEMORY_RESOURCE *Resource;
ARM_PROCESSOR_TABLE *ArmProcessorTable;
ARM_CORE_INFO *ArmCoreInfoTable;
UINT32 MpId;
UINT32 ClusterId;
UINT32 CoreId;
UINT64 CpuReleaseAddr;
UINTN MemoryMapSize;
EFI_MEMORY_DESCRIPTOR *MemoryMap;
EFI_MEMORY_DESCRIPTOR *MemoryMapPtr;
UINTN MapKey;
UINTN DescriptorSize;
UINT32 DescriptorVersion;
UINTN Pages;
UINTN OriginalFdtSize;
BOOLEAN CpusNodeExist;
UINTN CoreMpId;
NewFdtBlobAllocation = 0;
//
// Sanity checks on the original FDT blob.
//
err = fdt_check_header ((VOID*)(UINTN)(*FdtBlobBase));
if (err != 0) {
Print (L"ERROR: Device Tree header not valid (err:%d)\n", err);
return EFI_INVALID_PARAMETER;
}
// The original FDT blob might have been loaded partially.
// Check that it is not the case.
OriginalFdtSize = (UINTN)fdt_totalsize ((VOID*)(UINTN)(*FdtBlobBase));
if (OriginalFdtSize > *FdtBlobSize) {
Print (L"ERROR: Incomplete FDT. Only %d/%d bytes have been loaded.\n",
*FdtBlobSize, OriginalFdtSize);
return EFI_INVALID_PARAMETER;
}
//
// Relocate the FDT to its final location.
//
Status = RelocateFdt (SystemMemoryBase, *FdtBlobBase, OriginalFdtSize,
&NewFdtBlobBase, &NewFdtBlobSize, &NewFdtBlobAllocation);
if (EFI_ERROR (Status)) {
goto FAIL_RELOCATE_FDT;
}
fdt = (VOID*)(UINTN)NewFdtBlobBase;
node = fdt_subnode_offset (fdt, 0, "chosen");
if (node < 0) {
// The 'chosen' node does not exist, create it
node = fdt_add_subnode (fdt, 0, "chosen");
if (node < 0) {
DEBUG ((EFI_D_ERROR, "Error on finding 'chosen' node\n"));
Status = EFI_INVALID_PARAMETER;
goto FAIL_COMPLETE_FDT;
}
}
DEBUG_CODE_BEGIN ();
BootArg = fdt_getprop (fdt, node, "bootargs", &lenp);
if (BootArg != NULL) {
DEBUG ((EFI_D_ERROR, "BootArg: %a\n", BootArg));
}
DEBUG_CODE_END ();
//
// Set Linux CmdLine
//
if ((CommandLineArguments != NULL) && (AsciiStrLen (CommandLineArguments) > 0)) {
err = fdt_setprop (fdt, node, "bootargs", CommandLineArguments, AsciiStrSize (CommandLineArguments));
if (err) {
DEBUG ((EFI_D_ERROR, "Fail to set new 'bootarg' (err:%d)\n", err));
}
}
//
// Set Linux Initrd
//
if (InitrdImageSize != 0) {
InitrdImageStart = cpu_to_fdt64 (InitrdImage);
err = fdt_setprop (fdt, node, "linux,initrd-start", &InitrdImageStart, sizeof (EFI_PHYSICAL_ADDRESS));
if (err) {
DEBUG ((EFI_D_ERROR, "Fail to set new 'linux,initrd-start' (err:%d)\n", err));
}
InitrdImageEnd = cpu_to_fdt64 (InitrdImage + InitrdImageSize);
err = fdt_setprop (fdt, node, "linux,initrd-end", &InitrdImageEnd, sizeof (EFI_PHYSICAL_ADDRESS));
if (err) {
DEBUG ((EFI_D_ERROR, "Fail to set new 'linux,initrd-start' (err:%d)\n", err));
}
}
//
// Set Physical memory setup if does not exist
//
node = fdt_subnode_offset (fdt, 0, "memory");
if (node < 0) {
// The 'memory' node does not exist, create it
node = fdt_add_subnode (fdt, 0, "memory");
if (node >= 0) {
fdt_setprop_string (fdt, node, "name", "memory");
fdt_setprop_string (fdt, node, "device_type", "memory");
GetSystemMemoryResources (&ResourceList);
Resource = (SYSTEM_MEMORY_RESOURCE*)ResourceList.ForwardLink;
Region.Base = cpu_to_fdtn ((UINTN)Resource->PhysicalStart);
Region.Size = cpu_to_fdtn ((UINTN)Resource->ResourceLength);
err = fdt_setprop (fdt, node, "reg", &Region, sizeof (Region));
if (err) {
DEBUG ((EFI_D_ERROR, "Fail to set new 'memory region' (err:%d)\n", err));
}
}
}
//
// Add the memory regions reserved by the UEFI Firmware
//
// Retrieve the UEFI Memory Map
MemoryMap = NULL;
MemoryMapSize = 0;
Status = gBS->GetMemoryMap (&MemoryMapSize, MemoryMap, &MapKey, &DescriptorSize, &DescriptorVersion);
if (Status == EFI_BUFFER_TOO_SMALL) {
// The UEFI specification advises to allocate more memory for the MemoryMap buffer between successive
// calls to GetMemoryMap(), since allocation of the new buffer may potentially increase memory map size.
Pages = EFI_SIZE_TO_PAGES (MemoryMapSize) + 1;
MemoryMap = AllocatePages (Pages);
if (MemoryMap == NULL) {
Status = EFI_OUT_OF_RESOURCES;
goto FAIL_COMPLETE_FDT;
}
Status = gBS->GetMemoryMap (&MemoryMapSize, MemoryMap, &MapKey, &DescriptorSize, &DescriptorVersion);
}
// Go through the list and add the reserved region to the Device Tree
if (!EFI_ERROR (Status)) {
MemoryMapPtr = MemoryMap;
for (Index = 0; Index < (MemoryMapSize / DescriptorSize); Index++) {
if (IsLinuxReservedRegion ((EFI_MEMORY_TYPE)MemoryMapPtr->Type)) {
DEBUG ((DEBUG_VERBOSE, "Reserved region of type %d [0x%lX, 0x%lX]\n",
MemoryMapPtr->Type,
(UINTN)MemoryMapPtr->PhysicalStart,
(UINTN)(MemoryMapPtr->PhysicalStart + MemoryMapPtr->NumberOfPages * EFI_PAGE_SIZE)));
err = fdt_add_mem_rsv (fdt, MemoryMapPtr->PhysicalStart, MemoryMapPtr->NumberOfPages * EFI_PAGE_SIZE);
if (err != 0) {
Print (L"Warning: Fail to add 'memreserve' (err:%d)\n", err);
}
}
MemoryMapPtr = (EFI_MEMORY_DESCRIPTOR*)((UINTN)MemoryMapPtr + DescriptorSize);
}
}
//
// Setup Arm Mpcore Info if it is a multi-core or multi-cluster platforms.
//
// For 'cpus' and 'cpu' device tree nodes bindings, refer to this file
// in the kernel documentation:
// Documentation/devicetree/bindings/arm/cpus.txt
//
for (Index = 0; Index < gST->NumberOfTableEntries; Index++) {
// Check for correct GUID type
if (CompareGuid (&gArmMpCoreInfoGuid, &(gST->ConfigurationTable[Index].VendorGuid))) {
MpId = ArmReadMpidr ();
ClusterId = GET_CLUSTER_ID (MpId);
CoreId = GET_CORE_ID (MpId);
node = fdt_subnode_offset (fdt, 0, "cpus");
if (node < 0) {
// Create the /cpus node
node = fdt_add_subnode (fdt, 0, "cpus");
fdt_setprop_string (fdt, node, "name", "cpus");
fdt_setprop_cell (fdt, node, "#address-cells", sizeof (UINTN) / 4);
fdt_setprop_cell (fdt, node, "#size-cells", 0);
CpusNodeExist = FALSE;
} else {
CpusNodeExist = TRUE;
}
// Get pointer to ARM processor table
ArmProcessorTable = (ARM_PROCESSOR_TABLE *)gST->ConfigurationTable[Index].VendorTable;
ArmCoreInfoTable = ArmProcessorTable->ArmCpus;
for (Index = 0; Index < ArmProcessorTable->NumberOfEntries; Index++) {
CoreMpId = (UINTN) GET_MPID (ArmCoreInfoTable[Index].ClusterId,
ArmCoreInfoTable[Index].CoreId);
AsciiSPrint (Name, 10, "cpu@%x", CoreMpId);
// If the 'cpus' node did not exist then create all the 'cpu' nodes.
// In case 'cpus' node is provided in the original FDT then we do not add
// any 'cpu' node.
if (!CpusNodeExist) {
cpu_node = fdt_add_subnode (fdt, node, Name);
if (cpu_node < 0) {
DEBUG ((EFI_D_ERROR, "Error on creating '%s' node\n", Name));
Status = EFI_INVALID_PARAMETER;
goto FAIL_COMPLETE_FDT;
}
fdt_setprop_string (fdt, cpu_node, "device_type", "cpu");
CoreMpId = cpu_to_fdtn (CoreMpId);
fdt_setprop (fdt, cpu_node, "reg", &CoreMpId, sizeof (CoreMpId));
} else {
cpu_node = fdt_subnode_offset (fdt, node, Name);
}
if (cpu_node >= 0) {
Method = fdt_getprop (fdt, cpu_node, "enable-method", &lenp);
// We only care when 'enable-method' == 'spin-table'. If the enable-method is not defined
// or defined as 'psci' then we ignore its properties.
if ((Method != NULL) && (AsciiStrCmp ((CHAR8 *)Method, "spin-table") == 0)) {
// There are two cases;
// - UEFI firmware parked the secondary cores and/or UEFI firmware is aware of the CPU
// release addresses (PcdArmLinuxSpinTable == TRUE)
// - the parking of the secondary cores has been managed before starting UEFI and/or UEFI
// does not anything about the CPU release addresses - in this case we do nothing
if (FeaturePcdGet (PcdArmLinuxSpinTable)) {
CpuReleaseAddr = cpu_to_fdt64 (ArmCoreInfoTable[Index].MailboxSetAddress);
fdt_setprop (fdt, cpu_node, "cpu-release-addr", &CpuReleaseAddr, sizeof (CpuReleaseAddr));
// If it is not the primary core than the cpu should be disabled
if (((ArmCoreInfoTable[Index].ClusterId != ClusterId) || (ArmCoreInfoTable[Index].CoreId != CoreId))) {
fdt_setprop_string (fdt, cpu_node, "status", "disabled");
}
}
}
}
}
break;
}
}
// If we succeeded to generate the new Device Tree then free the old Device Tree
gBS->FreePages (*FdtBlobBase, EFI_SIZE_TO_PAGES (*FdtBlobSize));
// Update the real size of the Device Tree
fdt_pack ((VOID*)(UINTN)(NewFdtBlobBase));
*FdtBlobBase = NewFdtBlobBase;
*FdtBlobSize = (UINTN)fdt_totalsize ((VOID*)(UINTN)(NewFdtBlobBase));
return EFI_SUCCESS;
FAIL_COMPLETE_FDT:
gBS->FreePages (NewFdtBlobAllocation, EFI_SIZE_TO_PAGES (NewFdtBlobSize));
FAIL_RELOCATE_FDT:
*FdtBlobSize = (UINTN)fdt_totalsize ((VOID*)(UINTN)(*FdtBlobBase));
// Return success even if we failed to update the FDT blob.
// The original one is still valid.
return EFI_SUCCESS;
}

192
ArmPkg/Application/LinuxLoader/LinuxLoaderHelper.c Normal file
View File

@ -0,0 +1,192 @@
/** @file
*
* Copyright (c) 2011-2015, 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 <PiDxe.h>
#include <Library/HobLib.h>
#include <Library/TimerLib.h>
#include <Library/SerialPortLib.h>
#include "LinuxLoader.h"
STATIC CONST CHAR8 *mTokenList[] = {
/*"SEC",*/
"PEI",
"DXE",
"BDS",
NULL
};
VOID
PrintPerformance (
VOID
)
{
UINTN Key;
CONST VOID *Handle;
CONST CHAR8 *Token, *Module;
UINT64 Start, Stop, TimeStamp;
UINT64 Delta, TicksPerSecond, Milliseconds;
UINTN Index;
CHAR8 Buffer[100];
UINTN CharCount;
BOOLEAN CountUp;
TicksPerSecond = GetPerformanceCounterProperties (&Start, &Stop);
if (Start < Stop) {
CountUp = TRUE;
} else {
CountUp = FALSE;
}
TimeStamp = 0;
Key = 0;
do {
Key = GetPerformanceMeasurement (Key, (CONST VOID **)&Handle, &Token, &Module, &Start, &Stop);
if (Key != 0) {
for (Index = 0; mTokenList[Index] != NULL; Index++) {
if (AsciiStriCmp (mTokenList[Index], Token) == 0) {
Delta = CountUp ? (Stop - Start) : (Start - Stop);
TimeStamp += Delta;
Milliseconds = DivU64x64Remainder (MultU64x32 (Delta, 1000), TicksPerSecond, NULL);
CharCount = AsciiSPrint (Buffer, sizeof (Buffer), "%6a %6ld ms\n", Token, Milliseconds);
SerialPortWrite ((UINT8 *) Buffer, CharCount);
break;
}
}
}
} while (Key != 0);
CharCount = AsciiSPrint (Buffer, sizeof (Buffer), "Total Time = %ld ms\n\n",
DivU64x64Remainder (MultU64x32 (TimeStamp, 1000), TicksPerSecond, NULL));
SerialPortWrite ((UINT8 *) Buffer, CharCount);
}
STATIC
EFI_STATUS
InsertSystemMemoryResources (
LIST_ENTRY *ResourceList,
EFI_HOB_RESOURCE_DESCRIPTOR *ResHob
)
{
SYSTEM_MEMORY_RESOURCE *NewResource;
LIST_ENTRY *Link;
LIST_ENTRY *NextLink;
LIST_ENTRY AttachedResources;
SYSTEM_MEMORY_RESOURCE *Resource;
EFI_PHYSICAL_ADDRESS NewResourceEnd;
if (IsListEmpty (ResourceList)) {
NewResource = AllocateZeroPool (sizeof (SYSTEM_MEMORY_RESOURCE));
NewResource->PhysicalStart = ResHob->PhysicalStart;
NewResource->ResourceLength = ResHob->ResourceLength;
InsertTailList (ResourceList, &NewResource->Link);
return EFI_SUCCESS;
}
InitializeListHead (&AttachedResources);
Link = ResourceList->ForwardLink;
ASSERT (Link != NULL);
while (Link != ResourceList) {
Resource = (SYSTEM_MEMORY_RESOURCE*)Link;
// Sanity Check. The resources should not overlapped.
ASSERT (!((ResHob->PhysicalStart >= Resource->PhysicalStart) && (ResHob->PhysicalStart < (Resource->PhysicalStart + Resource->ResourceLength))));
ASSERT (!((ResHob->PhysicalStart + ResHob->ResourceLength - 1 >= Resource->PhysicalStart) &&
((ResHob->PhysicalStart + ResHob->ResourceLength - 1) < (Resource->PhysicalStart + Resource->ResourceLength))));
// The new resource is attached after this resource descriptor
if (ResHob->PhysicalStart == Resource->PhysicalStart + Resource->ResourceLength) {
Resource->ResourceLength = Resource->ResourceLength + ResHob->ResourceLength;
NextLink = RemoveEntryList (&Resource->Link);
InsertTailList (&AttachedResources, &Resource->Link);
Link = NextLink;
}
// The new resource is attached before this resource descriptor
else if (ResHob->PhysicalStart + ResHob->ResourceLength == Resource->PhysicalStart) {
Resource->PhysicalStart = ResHob->PhysicalStart;
Resource->ResourceLength = Resource->ResourceLength + ResHob->ResourceLength;
NextLink = RemoveEntryList (&Resource->Link);
InsertTailList (&AttachedResources, &Resource->Link);
Link = NextLink;
} else {
Link = Link->ForwardLink;
}
}
if (!IsListEmpty (&AttachedResources)) {
// See if we can merge the attached resource with other resources
NewResource = (SYSTEM_MEMORY_RESOURCE*)GetFirstNode (&AttachedResources);
Link = RemoveEntryList (&NewResource->Link);
while (!IsListEmpty (&AttachedResources)) {
// Merge resources
Resource = (SYSTEM_MEMORY_RESOURCE*)Link;
// Ensure they overlap each other
ASSERT (
((NewResource->PhysicalStart >= Resource->PhysicalStart) && (NewResource->PhysicalStart < (Resource->PhysicalStart + Resource->ResourceLength))) ||
(((NewResource->PhysicalStart + NewResource->ResourceLength) >= Resource->PhysicalStart) && ((NewResource->PhysicalStart + NewResource->ResourceLength) < (Resource->PhysicalStart + Resource->ResourceLength)))
);
NewResourceEnd = MAX (NewResource->PhysicalStart + NewResource->ResourceLength, Resource->PhysicalStart + Resource->ResourceLength);
NewResource->PhysicalStart = MIN (NewResource->PhysicalStart, Resource->PhysicalStart);
NewResource->ResourceLength = NewResourceEnd - NewResource->PhysicalStart;
Link = RemoveEntryList (Link);
}
} else {
// None of the Resource of the list is attached to this ResHob. Create a new entry for it
NewResource = AllocateZeroPool (sizeof (SYSTEM_MEMORY_RESOURCE));
NewResource->PhysicalStart = ResHob->PhysicalStart;
NewResource->ResourceLength = ResHob->ResourceLength;
}
InsertTailList (ResourceList, &NewResource->Link);
return EFI_SUCCESS;
}
EFI_STATUS
GetSystemMemoryResources (
IN LIST_ENTRY *ResourceList
)
{
EFI_HOB_RESOURCE_DESCRIPTOR *ResHob;
InitializeListHead (ResourceList);
// Find the first System Memory Resource Descriptor
ResHob = (EFI_HOB_RESOURCE_DESCRIPTOR *)GetFirstHob (EFI_HOB_TYPE_RESOURCE_DESCRIPTOR);
while ((ResHob != NULL) && (ResHob->ResourceType != EFI_RESOURCE_SYSTEM_MEMORY)) {
ResHob = (EFI_HOB_RESOURCE_DESCRIPTOR *)GetNextHob (EFI_HOB_TYPE_RESOURCE_DESCRIPTOR, (VOID *)((UINTN)ResHob + ResHob->Header.HobLength));
}
// Did not find any
if (ResHob == NULL) {
return EFI_NOT_FOUND;
} else {
InsertSystemMemoryResources (ResourceList, ResHob);
}
ResHob = (EFI_HOB_RESOURCE_DESCRIPTOR *)GetNextHob (EFI_HOB_TYPE_RESOURCE_DESCRIPTOR, (VOID *)((UINTN)ResHob + ResHob->Header.HobLength));
while (ResHob != NULL) {
if (ResHob->ResourceType == EFI_RESOURCE_SYSTEM_MEMORY) {
InsertSystemMemoryResources (ResourceList, ResHob);
}
ResHob = (EFI_HOB_RESOURCE_DESCRIPTOR *)GetNextHob (EFI_HOB_TYPE_RESOURCE_DESCRIPTOR, (VOID *)((UINTN)ResHob + ResHob->Header.HobLength));
}
return EFI_SUCCESS;
}

298
ArmPkg/Application/LinuxLoader/LinuxLoaderShellApp.c Normal file
View File

@ -0,0 +1,298 @@
/** @file
*
* Copyright (c) 2011-2015, 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 "LinuxLoader.h"
//
// Internal variables
//
CONST EFI_GUID mLinuxLoaderHiiGuid = {
0xd5d16edc, 0x35c5, 0x4866,
{0xbd, 0xe5, 0x2b, 0x64, 0xa2, 0x26, 0x55, 0x6e}
};
EFI_HANDLE mLinuxLoaderHiiHandle;
STATIC CONST SHELL_PARAM_ITEM ParamList[] = {
{L"-f", TypeValue},
{L"-d", TypeValue},
{L"-c", TypeValue},
{L"-a", TypeValue},
{NULL , TypeMax }
};
/**
Print a string given the "HII Id" of the format string and a list of
arguments.
@param[in] Language The language of the string to retrieve. If
this parameter is NULL, then the current
platform language is used.
@param[in] HiiFormatStringId The format string Id for getting from Hii.
@param[in] ... The variable argument list.
@retval EFI_SUCCESS The printing was successful.
@retval EFI_OUT_OF_RESOURCES A memory allocation failed.
**/
EFI_STATUS
PrintHii (
IN CONST CHAR8 *Language OPTIONAL,
IN CONST EFI_STRING_ID HiiFormatStringId,
...
)
{
VA_LIST Marker;
CHAR16 *HiiFormatString;
CHAR16 Buffer[MAX_MSG_LEN];
VA_START (Marker, HiiFormatStringId);
HiiFormatString = HiiGetString (mLinuxLoaderHiiHandle, HiiFormatStringId, Language);
if (HiiFormatString != NULL) {
UnicodeVSPrint (Buffer, sizeof (Buffer), HiiFormatString, Marker);
Print (L"%s", Buffer);
FreePool (HiiFormatString);
} else {
ASSERT (FALSE);
return EFI_OUT_OF_RESOURCES;
}
VA_END (Marker);
return EFI_SUCCESS;
}
/**
Print the help.
@param[in] Language The language of the string to retrieve. If this
parameter is NULL, then the current platform
language is used.
**/
VOID
PrintHelp (
IN CONST CHAR8 *Language OPTIONAL
)
{
CHAR16 *Help;
CHAR16 *Walker;
CHAR16 *LineEnd;
//
// Print the help line by line as it is too big to be printed at once.
//
Help = HiiGetString (mLinuxLoaderHiiHandle, STRING_TOKEN (STR_HELP), Language);
if (Help != NULL) {
Walker = Help;
while (*Walker != L'\0') {
LineEnd = StrStr (Walker, L"\r\n");
if (LineEnd != NULL) {
*LineEnd = L'\0';
}
Print (L"%s\r\n", Walker);
if (LineEnd == NULL) {
break;
}
Walker = LineEnd + 2;
}
FreePool (Help);
}
}
/**
Process the Shell parameters in the case the application has been called
from the EFI Shell.
@param[out] KernelPath A pointer to the buffer where the path
to the Linux kernel (EFI Shell file path
or device path is stored. The address of
the buffer is NULL in case of an error.
Otherwise, the returned address is the
address of a buffer allocated with
a call to AllocatePool() that has to be
freed by the caller.
@param[out] FdtPath A pointer to the buffer where the path
to the FDT (EFI Shell file path or
device path) is stored. The address of
the buffer is NULL in case of an error or
if the path to the FDT is not defined.
Otherwise, the returned address is the
address of a buffer allocated with a call
to AllocatePool() that has to be freed by
the caller.
@param[out] InitrdPath A pointer to the buffer where the path
(EFI Shell file path or device path)
to the RAM root file system is stored.
The address of the buffer is NULL in case
of an error or if the path to the RAM root
file system is not defined. Otherwise, the
returned address is the address of a
buffer allocated with a call to
AllocatePool() that has to be freed by
the caller.
@param[out] LinuxCommandLine A pointer to the buffer where the Linux
kernel command line is stored. The address
of the buffer is NULL in case of an error
or if the Linux command line is not
defined. Otherwise, the returned address
is the address of a buffer allocated with
a call to AllocatePool() that has to be
freed by the caller.
@param[out] AtagMachineType Value of the ARM Machine Type
@retval EFI_SUCCESS The processing was successfull.
@retval EFI_ABORTED The initialisation of the Shell Library failed.
@retval EFI_NOT_FOUND Path to the Linux kernel not found.
@retval EFI_INVALID_PARAMETER At least one parameter is not valid or there is a
conflict between two parameters.
@retval EFI_OUT_OF_RESOURCES A memory allocation failed.
**/
EFI_STATUS
ProcessShellParameters (
OUT CHAR16 **KernelPath,
OUT CHAR16 **FdtPath,
OUT CHAR16 **InitrdPath,
OUT CHAR16 **LinuxCommandLine,
OUT UINTN *AtagMachineType
)
{
EFI_STATUS Status;
LIST_ENTRY *CheckPackage;
CHAR16 *ProblemParam;
CONST CHAR16 *FlagValue;
CONST CHAR16 *ParameterValue;
UINTN LinuxCommandLineLen;
*KernelPath = NULL;
*FdtPath = NULL;
*InitrdPath = NULL;
*LinuxCommandLine = NULL;
*AtagMachineType = ARM_FDT_MACHINE_TYPE;
//
// Initialise the Shell Library as we are going to use it.
// Assert that the return code is EFI_SUCCESS as it should.
// To anticipate any change is the codes returned by
// ShellInitialize(), leave in case of error.
//
Status = ShellInitialize ();
if (EFI_ERROR (Status)) {
ASSERT_EFI_ERROR (Status);
return EFI_ABORTED;
}
Status = ShellCommandLineParse (ParamList, &CheckPackage, &ProblemParam, TRUE);
if (EFI_ERROR (Status)) {
if ((Status == EFI_VOLUME_CORRUPTED) &&
(ProblemParam != NULL) ) {
PrintHii (
NULL, STRING_TOKEN (STR_SHELL_INVALID_PARAMETER), ProblemParam
);
FreePool (ProblemParam);
} else {
ASSERT (FALSE);
}
goto Error;
}
Status = EFI_INVALID_PARAMETER;
if (ShellCommandLineGetCount (CheckPackage) != 2) {
PrintHelp (NULL);
goto Error;
}
Status = EFI_OUT_OF_RESOURCES;
FlagValue = ShellCommandLineGetValue (CheckPackage, L"-a");
if (FlagValue != NULL) {
if (ShellCommandLineGetFlag (CheckPackage, L"-d")) {
PrintHii (NULL, STRING_TOKEN (STR_ATAG_FDT_CONFLICT));
goto Error;
}
*AtagMachineType = StrDecimalToUintn (FlagValue);
}
ParameterValue = ShellCommandLineGetRawValue (CheckPackage, 1);
*KernelPath = AllocateCopyPool (StrSize (ParameterValue), ParameterValue);
if (*KernelPath == NULL) {
goto Error;
}
FlagValue = ShellCommandLineGetValue (CheckPackage, L"-d");
if (FlagValue != NULL) {
*FdtPath = AllocateCopyPool (StrSize (FlagValue), FlagValue);
if (*FdtPath == NULL) {
goto Error;
}
}
FlagValue = ShellCommandLineGetValue (CheckPackage, L"-f");
if (FlagValue != NULL) {
*InitrdPath = AllocateCopyPool (StrSize (FlagValue), FlagValue);
if (*InitrdPath == NULL) {
goto Error;
}
}
FlagValue = ShellCommandLineGetValue (CheckPackage, L"-c");
if (FlagValue != NULL) {
LinuxCommandLineLen = StrLen (FlagValue);
if ((LinuxCommandLineLen != 0) &&
(FlagValue[0] == L'"' ) &&
(FlagValue[LinuxCommandLineLen - 1] == L'"')) {
FlagValue++;
LinuxCommandLineLen -= 2;
}
*LinuxCommandLine = AllocateCopyPool (
(LinuxCommandLineLen + 1) * sizeof (CHAR16),
FlagValue
);
if (*LinuxCommandLine == NULL) {
goto Error;
}
(*LinuxCommandLine)[LinuxCommandLineLen] = L'\0';
}
Status = EFI_SUCCESS;
Error:
ShellCommandLineFreeVarList (CheckPackage);
if (EFI_ERROR (Status)) {
if (*KernelPath != NULL) {
FreePool (*KernelPath);
*KernelPath = NULL;
}
if (*FdtPath != NULL) {
FreePool (*FdtPath);
*FdtPath = NULL;
}
if (*InitrdPath != NULL) {
FreePool (*InitrdPath);
*InitrdPath = NULL;
}
if (*LinuxCommandLine != NULL) {
FreePool (*LinuxCommandLine);
*LinuxCommandLine = NULL;
}
}
return Status;
}

8
ArmPkg/ArmPkg.dsc
View File

@ -78,6 +78,10 @@
BdsLib|ArmPkg/Library/BdsLib/BdsLib.inf
FdtLib|EmbeddedPkg/Library/FdtLib/FdtLib.inf
ShellLib|ShellPkg/Library/UefiShellLib/UefiShellLib.inf
FileHandleLib|MdePkg/Library/UefiFileHandleLib/UefiFileHandleLib.inf
SortLib|MdeModulePkg/Library/UefiSortLib/UefiSortLib.inf
IoLib|MdePkg/Library/BaseIoLibIntrinsic/BaseIoLibIntrinsic.inf
[LibraryClasses.ARM]
@ -138,7 +142,7 @@
ArmPkg/Filesystem/SemihostFs/SemihostFs.inf
ArmPkg/Application/LinuxLoader/LinuxFdtLoader.inf
ArmPkg/Application/LinuxLoader/LinuxLoader.inf
[Components.ARM]
ArmPkg/Library/BaseMemoryLibVstm/BaseMemoryLibVstm.inf
@ -154,8 +158,6 @@
ArmPkg/Library/ArmLib/ArmV7/ArmV7LibSec.inf
ArmPkg/Library/ArmLib/ArmV7/ArmV7LibPrePi.inf
ArmPkg/Application/LinuxLoader/LinuxAtagLoader.inf
[Components.AARCH64]
ArmPkg/Drivers/ArmCpuLib/ArmCortexAEMv8Lib/ArmCortexAEMv8Lib.inf
ArmPkg/Drivers/ArmCpuLib/ArmCortexA5xLib/ArmCortexA5xLib.inf