ArmPkg/Library/BdsLib/Arm/BdsLinuxLoader.c

   1 /** @file
   2 *
   3 *  Copyright (c) 2011-2014, ARM Limited. All rights reserved.
   4 *
   5 *  This program and the accompanying materials
   6 *  are licensed and made available under the terms and conditions of the BSD License
   7 *  which accompanies this distribution.  The full text of the license may be found at
   8 *  http://opensource.org/licenses/bsd-license.php
   9 *
  10 *  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11 *  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12 *
  13 **/
  14
  15 #include <Guid/Fdt.h>
  16 #include <libfdt.h>
  17
  18 #include "BdsInternal.h"
  19 #include "BdsLinuxLoader.h"
  20
  21 #define ALIGN32_BELOW(addr)   ALIGN_POINTER(addr - 32,32)
  22
  23 #define IS_ADDRESS_IN_REGION(RegionStart, RegionSize, Address) \
  24     (((UINTN)(RegionStart) <= (UINTN)(Address)) && ((UINTN)(Address) <= ((UINTN)(RegionStart) + (UINTN)(RegionSize))))
  25
  26 STATIC
  27 EFI_STATUS
  28 PreparePlatformHardware (
  29   VOID
  30   )
  31 {
  32   //Note: Interrupts will be disabled by the GIC driver when ExitBootServices() will be called.
  33
  34   // Clean before Disable else the Stack gets corrupted with old data.
  35   ArmCleanDataCache ();
  36   ArmDisableDataCache ();
  37   // Invalidate all the entries that might have snuck in.
  38   ArmInvalidateDataCache ();
  39
  40   // Invalidate and disable the Instruction cache
  41   ArmDisableInstructionCache ();
  42   ArmInvalidateInstructionCache ();
  43
  44   // Turn off MMU
  45   ArmDisableMmu();
  46
  47   return EFI_SUCCESS;
  48 }
  49
  50 STATIC
  51 EFI_STATUS
  52 StartLinux (
  53   IN  EFI_PHYSICAL_ADDRESS  LinuxImage,
  54   IN  UINTN                 LinuxImageSize,
  55   IN  EFI_PHYSICAL_ADDRESS  KernelParamsAddress,
  56   IN  UINTN                 KernelParamsSize,
  57   IN  UINT32                MachineType
  58   )
  59 {
  60   EFI_STATUS            Status;
  61   LINUX_KERNEL          LinuxKernel;
  62
  63   // Shut down UEFI boot services. ExitBootServices() will notify every driver that created an event on
  64   // ExitBootServices event. Example the Interrupt DXE driver will disable the interrupts on this event.
  65   Status = ShutdownUefiBootServices ();
  66   if(EFI_ERROR(Status)) {
  67     DEBUG((EFI_D_ERROR,"ERROR: Can not shutdown UEFI boot services. Status=0x%X\n", Status));
  68     goto Exit;
  69   }
  70
  71   // Move the kernel parameters to any address inside the first 1MB.
  72   // This is necessary because the ARM Linux kernel requires
  73   // the FTD / ATAG List to reside entirely inside the first 1MB of
  74   // physical memory.
  75   //Note: There is no requirement on the alignment
  76   if (MachineType != ARM_FDT_MACHINE_TYPE) {
  77     if (((UINTN)KernelParamsAddress > LINUX_ATAG_MAX_OFFSET) && (KernelParamsSize < PcdGet32(PcdArmLinuxAtagMaxOffset))) {
  78       KernelParamsAddress = (EFI_PHYSICAL_ADDRESS)(UINTN)CopyMem (ALIGN32_BELOW(LINUX_ATAG_MAX_OFFSET - KernelParamsSize), (VOID*)(UINTN)KernelParamsAddress, KernelParamsSize);
  79     }
  80   } else {
  81     if (((UINTN)KernelParamsAddress > LINUX_FDT_MAX_OFFSET) && (KernelParamsSize < PcdGet32(PcdArmLinuxFdtMaxOffset))) {
  82       KernelParamsAddress = (EFI_PHYSICAL_ADDRESS)(UINTN)CopyMem (ALIGN32_BELOW(LINUX_FDT_MAX_OFFSET - KernelParamsSize), (VOID*)(UINTN)KernelParamsAddress, KernelParamsSize);
  83     }
  84   }
  85
  86   if ((UINTN)LinuxImage > LINUX_KERNEL_MAX_OFFSET) {
  87     //Note: There is no requirement on the alignment
  88     LinuxKernel = (LINUX_KERNEL)CopyMem (ALIGN32_BELOW(LINUX_KERNEL_MAX_OFFSET - LinuxImageSize), (VOID*)(UINTN)LinuxImage, LinuxImageSize);
  89   } else {
  90     LinuxKernel = (LINUX_KERNEL)(UINTN)LinuxImage;
  91   }
  92
  93   // Check if the Linux Image is a uImage
  94   if (*(UINT32*)LinuxKernel == LINUX_UIMAGE_SIGNATURE) {
  95     // Assume the Image Entry Point is just after the uImage header (64-byte size)
  96     LinuxKernel = (LINUX_KERNEL)((UINTN)LinuxKernel + 64);
  97     LinuxImageSize -= 64;
  98   }
  99
 100   // Check there is no overlapping between kernel and its parameters
 101   // We can only assert because it is too late to fallback to UEFI (ExitBootServices has been called).
 102   ASSERT (!IS_ADDRESS_IN_REGION(LinuxKernel, LinuxImageSize, KernelParamsAddress) &&
 103           !IS_ADDRESS_IN_REGION(LinuxKernel, LinuxImageSize, KernelParamsAddress + KernelParamsSize));
 104
 105   //
 106   // Switch off interrupts, caches, mmu, etc
 107   //
 108   Status = PreparePlatformHardware ();
 109   ASSERT_EFI_ERROR(Status);
 110
 111   // Register and print out performance information
 112   PERF_END (NULL, "BDS", NULL, 0);
 113   if (PerformanceMeasurementEnabled ()) {
 114     PrintPerformance ();
 115   }
 116
 117   //
 118   // Start the Linux Kernel
 119   //
 120
 121   // Outside BootServices, so can't use Print();
 122   DEBUG((EFI_D_ERROR, "\nStarting the kernel:\n\n"));
 123
 124   // Jump to kernel with register set
 125   LinuxKernel ((UINTN)0, MachineType, (UINTN)KernelParamsAddress);
 126
 127   // Kernel should never exit
 128   // After Life services are not provided
 129   ASSERT(FALSE);
 130
 131 Exit:
 132   // Only be here if we fail to start Linux
 133   Print (L"ERROR  : Can not start the kernel. Status=0x%X\n", Status);
 134
 135   // Free Runtimee Memory (kernel and FDT)
 136   return Status;
 137 }
 138
 139 /**
 140   Start a Linux kernel from a Device Path
 141
 142   @param  LinuxKernel           Device Path to the Linux Kernel
 143   @param  Parameters            Linux kernel arguments
 144   @param  Fdt                   Device Path to the Flat Device Tree
 145
 146   @retval EFI_SUCCESS           All drivers have been connected
 147   @retval EFI_NOT_FOUND         The Linux kernel Device Path has not been found
 148   @retval EFI_OUT_OF_RESOURCES  There is not enough resource memory to store the matching results.
 149
 150 **/
 151 EFI_STATUS
 152 BdsBootLinuxAtag (
 153   IN  EFI_DEVICE_PATH_PROTOCOL* LinuxKernelDevicePath,
 154   IN  EFI_DEVICE_PATH_PROTOCOL* InitrdDevicePath,
 155   IN  CONST CHAR8*              CommandLineArguments
 156   )
 157 {
 158   EFI_STATUS            Status;
 159   UINT32                LinuxImageSize;
 160   UINT32                InitrdImageBaseSize = 0;
 161   UINT32                InitrdImageSize = 0;
 162   UINT32                AtagSize;
 163   EFI_PHYSICAL_ADDRESS  AtagBase;
 164   EFI_PHYSICAL_ADDRESS  LinuxImage;
 165   EFI_PHYSICAL_ADDRESS  InitrdImageBase = 0;
 166   EFI_PHYSICAL_ADDRESS  InitrdImage = 0;
 167
 168   PERF_START (NULL, "BDS", NULL, 0);
 169
 170   // Load the Linux kernel from a device path
 171   LinuxImage = LINUX_KERNEL_MAX_OFFSET;
 172   Status = BdsLoadImage (LinuxKernelDevicePath, AllocateMaxAddress, &LinuxImage, &LinuxImageSize);
 173   if (EFI_ERROR(Status)) {
 174     Print (L"ERROR: Did not find Linux kernel.\n");
 175     return Status;
 176   }
 177
 178   if (InitrdDevicePath) {
 179     // Load the initrd near to the Linux kernel
 180     InitrdImageBase = LINUX_KERNEL_MAX_OFFSET;
 181     Status = BdsLoadImage (InitrdDevicePath, AllocateMaxAddress, &InitrdImageBase, &InitrdImageBaseSize);
 182     if (Status == EFI_OUT_OF_RESOURCES) {
 183       Status = BdsLoadImage (InitrdDevicePath, AllocateAnyPages, &InitrdImageBase, &InitrdImageBaseSize);
 184     }
 185     if (EFI_ERROR(Status)) {
 186       Print (L"ERROR: Did not find initrd image.\n");
 187       goto EXIT_FREE_LINUX;
 188     }
 189
 190     // Check if the initrd is a uInitrd
 191     if (*(UINT32*)((UINTN)InitrdImageBase) == LINUX_UIMAGE_SIGNATURE) {
 192       // Skip the 64-byte image header
 193       InitrdImage = (EFI_PHYSICAL_ADDRESS)((UINTN)InitrdImageBase + 64);
 194       InitrdImageSize = InitrdImageBaseSize - 64;
 195     } else {
 196       InitrdImage = InitrdImageBase;
 197       InitrdImageSize = InitrdImageBaseSize;
 198     }
 199   }
 200
 201   //
 202   // Setup the Linux Kernel Parameters
 203   //
 204
 205   // By setting address=0 we leave the memory allocation to the function
 206   Status = PrepareAtagList (CommandLineArguments, InitrdImage, InitrdImageSize, &AtagBase, &AtagSize);
 207   if (EFI_ERROR(Status)) {
 208     Print(L"ERROR: Can not prepare ATAG list. Status=0x%X\n", Status);
 209     goto EXIT_FREE_INITRD;
 210   }
 211
 212   return StartLinux (LinuxImage, LinuxImageSize, AtagBase, AtagSize, PcdGet32(PcdArmMachineType));
 213
 214 EXIT_FREE_INITRD:
 215   if (InitrdDevicePath) {
 216     gBS->FreePages (InitrdImageBase, EFI_SIZE_TO_PAGES (InitrdImageBaseSize));
 217   }
 218
 219 EXIT_FREE_LINUX:
 220   gBS->FreePages (LinuxImage, EFI_SIZE_TO_PAGES (LinuxImageSize));
 221
 222   return Status;
 223 }
 224
 225 /**
 226   Start a Linux kernel from a Device Path
 227
 228   @param  LinuxKernelDevicePath  Device Path to the Linux Kernel
 229   @param  InitrdDevicePath       Device Path to the Initrd
 230   @param  CommandLineArguments   Linux command line
 231
 232   @retval EFI_SUCCESS           All drivers have been connected
 233   @retval EFI_NOT_FOUND         The Linux kernel Device Path has not been found
 234   @retval EFI_OUT_OF_RESOURCES  There is not enough resource memory to store the matching results.
 235
 236 **/
 237 EFI_STATUS
 238 BdsBootLinuxFdt (
 239   IN  EFI_DEVICE_PATH_PROTOCOL* LinuxKernelDevicePath,
 240   IN  EFI_DEVICE_PATH_PROTOCOL* InitrdDevicePath,
 241   IN  CONST CHAR8*              CommandLineArguments
 242   )
 243 {
 244   EFI_STATUS               Status;
 245   UINT32                   LinuxImageSize;
 246   UINT32                   InitrdImageBaseSize = 0;
 247   UINT32                   InitrdImageSize = 0;
 248   VOID                     *InstalledFdtBase;
 249   UINT32                   FdtBlobSize;
 250   EFI_PHYSICAL_ADDRESS     FdtBlobBase;
 251   EFI_PHYSICAL_ADDRESS     LinuxImage;
 252   EFI_PHYSICAL_ADDRESS     InitrdImageBase = 0;
 253   EFI_PHYSICAL_ADDRESS     InitrdImage = 0;
 254
 255   PERF_START (NULL, "BDS", NULL, 0);
 256
 257   // Load the Linux kernel from a device path
 258   LinuxImage = LINUX_KERNEL_MAX_OFFSET;
 259   Status = BdsLoadImage (LinuxKernelDevicePath, AllocateMaxAddress, &LinuxImage, &LinuxImageSize);
 260   if (EFI_ERROR(Status)) {
 261     Print (L"ERROR: Did not find Linux kernel.\n");
 262     return Status;
 263   }
 264
 265   if (InitrdDevicePath) {
 266     InitrdImageBase = LINUX_KERNEL_MAX_OFFSET;
 267     Status = BdsLoadImage (InitrdDevicePath, AllocateMaxAddress, &InitrdImageBase, &InitrdImageBaseSize);
 268     if (Status == EFI_OUT_OF_RESOURCES) {
 269       Status = BdsLoadImage (InitrdDevicePath, AllocateAnyPages, &InitrdImageBase, &InitrdImageBaseSize);
 270     }
 271     if (EFI_ERROR(Status)) {
 272       Print (L"ERROR: Did not find initrd image.\n");
 273       goto EXIT_FREE_LINUX;
 274     }
 275
 276     // Check if the initrd is a uInitrd
 277     if (*(UINT32*)((UINTN)InitrdImageBase) == LINUX_UIMAGE_SIGNATURE) {
 278       // Skip the 64-byte image header
 279       InitrdImage = (EFI_PHYSICAL_ADDRESS)((UINTN)InitrdImageBase + 64);
 280       InitrdImageSize = InitrdImageBaseSize - 64;
 281     } else {
 282       InitrdImage = InitrdImageBase;
 283       InitrdImageSize = InitrdImageBaseSize;
 284     }
 285   }
 286
 287   //
 288   // Get the FDT from the Configuration Table.
 289   // The FDT will be reloaded in PrepareFdt() to a more appropriate
 290   // location for the Linux Kernel.
 291   //
 292   Status = EfiGetSystemConfigurationTable (&gFdtTableGuid, &InstalledFdtBase);
 293   if (EFI_ERROR (Status)) {
 294     Print (L"ERROR: Did not get the Device Tree blob (%r).\n", Status);
 295     goto EXIT_FREE_INITRD;
 296   }
 297   FdtBlobBase = (EFI_PHYSICAL_ADDRESS)(UINTN)InstalledFdtBase;
 298   FdtBlobSize = fdt_totalsize (InstalledFdtBase);
 299
 300   // Update the Fdt with the Initrd information. The FDT will increase in size.
 301   // By setting address=0 we leave the memory allocation to the function
 302   Status = PrepareFdt (CommandLineArguments, InitrdImage, InitrdImageSize, &FdtBlobBase, &FdtBlobSize);
 303   if (EFI_ERROR(Status)) {
 304     Print(L"ERROR: Can not load kernel with FDT. Status=%r\n", Status);
 305     goto EXIT_FREE_FDT;
 306   }
 307
 308   return StartLinux (LinuxImage, LinuxImageSize, FdtBlobBase, FdtBlobSize, ARM_FDT_MACHINE_TYPE);
 309
 310 EXIT_FREE_FDT:
 311   gBS->FreePages (FdtBlobBase, EFI_SIZE_TO_PAGES (FdtBlobSize));
 312
 313 EXIT_FREE_INITRD:
 314   if (InitrdDevicePath) {
 315     gBS->FreePages (InitrdImageBase, EFI_SIZE_TO_PAGES (InitrdImageBaseSize));
 316   }
 317
 318 EXIT_FREE_LINUX:
 319   gBS->FreePages (LinuxImage, EFI_SIZE_TO_PAGES (LinuxImageSize));
 320
 321   return Status;
 322 }
 323