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

3 files changed, 647 insertions, 0 deletions

diff --git a/ArmPkg/Application/LinuxLoader/Arm/LinuxAtag.c b/ArmPkg/Application/LinuxLoader/Arm/LinuxAtag.c
new file mode 100644
index 000000000..fd7ee9c86
--- /dev/null
+++ b/ArmPkg/Application/LinuxLoader/Arm/LinuxAtag.c
@@ -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;

+}

diff --git a/ArmPkg/Application/LinuxLoader/Arm/LinuxAtag.h b/ArmPkg/Application/LinuxLoader/Arm/LinuxAtag.h
new file mode 100644
index 000000000..b4c7e5986
--- /dev/null
+++ b/ArmPkg/Application/LinuxLoader/Arm/LinuxAtag.h
@@ -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__ */

diff --git a/ArmPkg/Application/LinuxLoader/Arm/LinuxStarter.c b/ArmPkg/Application/LinuxLoader/Arm/LinuxStarter.c
new file mode 100644
index 000000000..960fdd6b3
--- /dev/null
+++ b/ArmPkg/Application/LinuxLoader/Arm/LinuxStarter.c
@@ -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;

+}