ArmPkg/Library/BdsLib/BdsLinuxLoader.c

   1 /** @file
   2 *
   3 *  Copyright (c) 2011, 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 "BdsInternal.h"
  16 #include "BdsLinuxLoader.h"
  17
  18 #include <Library/PcdLib.h>
  19 #include <Library/ArmLib.h>
  20 #include <Library/HobLib.h>
  21
  22 #define ALIGN32_BELOW(addr)   ALIGN_POINTER(addr - 32,32)
  23
  24 #define LINUX_ATAG_MAX_OFFSET     (PcdGet32(PcdSystemMemoryBase) + PcdGet32(PcdArmLinuxAtagMaxOffset))
  25 #define LINUX_KERNEL_MAX_OFFSET   (PcdGet32(PcdSystemMemoryBase) + PcdGet32(PcdArmLinuxKernelMaxOffset))
  26
  27 // Point to the current ATAG
  28 STATIC LINUX_ATAG *mLinuxKernelCurrentAtag;
  29
  30 STATIC
  31 VOID
  32 SetupCoreTag (
  33   IN UINT32 PageSize
  34   )
  35 {
  36   mLinuxKernelCurrentAtag->header.size = tag_size(LINUX_ATAG_CORE);
  37   mLinuxKernelCurrentAtag->header.type = ATAG_CORE;
  38
  39   mLinuxKernelCurrentAtag->body.core_tag.flags    = 1;            /* ensure read-only */
  40   mLinuxKernelCurrentAtag->body.core_tag.pagesize = PageSize;     /* systems PageSize (4k) */
  41   mLinuxKernelCurrentAtag->body.core_tag.rootdev  = 0;            /* zero root device (typically overridden from kernel command line )*/
  42
  43   // move pointer to next tag
  44   mLinuxKernelCurrentAtag = next_tag_address(mLinuxKernelCurrentAtag);
  45 }
  46
  47 STATIC
  48 VOID
  49 SetupMemTag (
  50   IN UINTN StartAddress,
  51   IN UINT32 Size
  52   )
  53 {
  54   mLinuxKernelCurrentAtag->header.size = tag_size(LINUX_ATAG_MEM);
  55   mLinuxKernelCurrentAtag->header.type = ATAG_MEM;
  56
  57   mLinuxKernelCurrentAtag->body.mem_tag.start = StartAddress;    /* Start of memory chunk for AtagMem */
  58   mLinuxKernelCurrentAtag->body.mem_tag.size  = Size;             /* Size of memory chunk for AtagMem */
  59
  60   // move pointer to next tag
  61   mLinuxKernelCurrentAtag = next_tag_address(mLinuxKernelCurrentAtag);
  62 }
  63
  64 STATIC
  65 VOID
  66 SetupCmdlineTag (
  67   IN CONST CHAR8 *CmdLine
  68   )
  69 {
  70   UINT32 LineLength;
  71
  72   // Increment the line length by 1 to account for the null string terminator character
  73   LineLength = AsciiStrLen(CmdLine) + 1;
  74
  75   /* Check for NULL strings.
  76    * Do not insert a tag for an empty CommandLine, don't even modify the tag address pointer.
  77    * Remember, you have at least one null string terminator character.
  78    */
  79   if(LineLength > 1) {
  80     mLinuxKernelCurrentAtag->header.size = ((UINT32)sizeof(LINUX_ATAG_HEADER) + LineLength + (UINT32)3) >> 2;
  81     mLinuxKernelCurrentAtag->header.type = ATAG_CMDLINE;
  82
  83     /* place CommandLine into tag */
  84     AsciiStrCpy(mLinuxKernelCurrentAtag->body.cmdline_tag.cmdline, CmdLine);
  85
  86     // move pointer to next tag
  87     mLinuxKernelCurrentAtag = next_tag_address(mLinuxKernelCurrentAtag);
  88   }
  89 }
  90
  91 STATIC
  92 VOID
  93 SetupEndTag (
  94   VOID
  95   )
  96 {
  97   // Empty tag ends list; this has zero length and no body
  98   mLinuxKernelCurrentAtag->header.type = ATAG_NONE;
  99   mLinuxKernelCurrentAtag->header.size = 0;
 100
 101   /* We can not calculate the next address by using the standard macro:
 102    * Params = next_tag_address(Params);
 103    * because it relies on the header.size, which here it is 0 (zero).
 104    * The easiest way is to add the sizeof(mLinuxKernelCurrentAtag->header).
 105    */
 106   mLinuxKernelCurrentAtag = (LINUX_ATAG*)((UINT32)mLinuxKernelCurrentAtag + sizeof(mLinuxKernelCurrentAtag->header));
 107 }
 108
 109 STATIC
 110 EFI_STATUS
 111 PrepareAtagList (
 112   IN  CONST CHAR8*     CommandLineString,
 113   IN  EFI_PHYSICAL_ADDRESS InitrdImage,
 114   IN  UINTN            InitrdImageSize,
 115   OUT LINUX_ATAG       **AtagBase,
 116   OUT UINT32           *AtagSize
 117   )
 118 {
 119   EFI_STATUS                  Status;
 120   LIST_ENTRY                  *ResourceLink;
 121   LIST_ENTRY                  ResourceList;
 122   EFI_PHYSICAL_ADDRESS        AtagStartAddress;
 123   BDS_SYSTEM_MEMORY_RESOURCE  *Resource;
 124
 125   AtagStartAddress = LINUX_ATAG_MAX_OFFSET;
 126   Status = gBS->AllocatePages (AllocateMaxAddress, EfiBootServicesData, EFI_SIZE_TO_PAGES(ATAG_MAX_SIZE), &AtagStartAddress);
 127   if (EFI_ERROR(Status)) {
 128     DEBUG ((EFI_D_ERROR,"Failed to allocate Atag at 0x%lX (%r)\n",AtagStartAddress,Status));
 129     Status = gBS->AllocatePages (AllocateAnyPages, EfiBootServicesData, EFI_SIZE_TO_PAGES(ATAG_MAX_SIZE), &AtagStartAddress);
 130     ASSERT_EFI_ERROR(Status);
 131   }
 132
 133   // Ready to setup the atag list
 134   mLinuxKernelCurrentAtag = (LINUX_ATAG*)(UINTN)AtagStartAddress;
 135
 136   // Standard core tag 4k PageSize
 137   SetupCoreTag( (UINT32)SIZE_4KB );
 138
 139   // Physical memory setup
 140   GetSystemMemoryResources (&ResourceList);
 141   ResourceLink = ResourceList.ForwardLink;
 142   while (ResourceLink != NULL && ResourceLink != &ResourceList) {
 143     Resource = (BDS_SYSTEM_MEMORY_RESOURCE*)ResourceLink;
 144     DEBUG((EFI_D_INFO,"- [0x%08X,0x%08X]\n",(UINT32)Resource->PhysicalStart,(UINT32)Resource->PhysicalStart+(UINT32)Resource->ResourceLength));
 145     SetupMemTag( (UINT32)Resource->PhysicalStart, (UINT32)Resource->ResourceLength );
 146     ResourceLink = ResourceLink->ForwardLink;
 147   }
 148
 149   // CommandLine setting root device
 150   SetupCmdlineTag (CommandLineString);
 151
 152   if (InitrdImageSize > 0 && InitrdImage != 0) {
 153     mLinuxKernelCurrentAtag->header.size = tag_size(LINUX_ATAG_INITRD2);
 154     mLinuxKernelCurrentAtag->header.type = ATAG_INITRD2;
 155
 156     mLinuxKernelCurrentAtag->body.initrd2_tag.start = (UINT32)InitrdImage;
 157     mLinuxKernelCurrentAtag->body.initrd2_tag.size = (UINT32)InitrdImageSize;
 158
 159     // Move pointer to next tag
 160     mLinuxKernelCurrentAtag = next_tag_address(mLinuxKernelCurrentAtag);
 161   }
 162
 163   // end of tags
 164   SetupEndTag();
 165
 166   // Calculate atag list size
 167   *AtagBase = (LINUX_ATAG*)(UINTN)AtagStartAddress;
 168   *AtagSize = (UINT32)mLinuxKernelCurrentAtag - (UINT32)AtagStartAddress + 1;
 169
 170   return EFI_SUCCESS;
 171 }
 172
 173 STATIC
 174 EFI_STATUS
 175 PreparePlatformHardware (
 176   VOID
 177   )
 178 {
 179   //Note: Interrupts will be disabled by the GIC driver when ExitBootServices() will be called.
 180
 181   // clean, invalidate, disable data cache
 182   ArmCleanInvalidateDataCache();
 183   ArmDisableDataCache();
 184
 185   // Invalidate and disable the Instruction cache
 186   ArmInvalidateInstructionCache ();
 187   ArmDisableInstructionCache ();
 188
 189   // turn off MMU
 190   ArmDisableMmu();
 191
 192   return EFI_SUCCESS;
 193 }
 194
 195 /**
 196   Start a Linux kernel from a Device Path
 197
 198   @param  LinuxKernel           Device Path to the Linux Kernel
 199   @param  Parameters            Linux kernel agruments
 200   @param  Fdt                   Device Path to the Flat Device Tree
 201
 202   @retval EFI_SUCCESS           All drivers have been connected
 203   @retval EFI_NOT_FOUND         The Linux kernel Device Path has not been found
 204   @retval EFI_OUT_OF_RESOURCES  There is not enough resource memory to store the matching results.
 205
 206 **/
 207 EFI_STATUS
 208 BdsBootLinux (
 209   IN  EFI_DEVICE_PATH_PROTOCOL* LinuxKernelDevicePath,
 210   IN  EFI_DEVICE_PATH_PROTOCOL* InitrdDevicePath,
 211   IN  CONST CHAR8*  Arguments,
 212   IN  EFI_DEVICE_PATH_PROTOCOL* FdtDevicePath
 213   )
 214 {
 215   EFI_STATUS            Status;
 216   UINT32                LinuxImageSize;
 217   UINT32                InitrdImageSize;
 218   UINT32                KernelParamsSize;
 219   EFI_PHYSICAL_ADDRESS  KernelParamsAddress;
 220   UINT32                MachineType;
 221   BOOLEAN               FdtSupported = FALSE;
 222   LINUX_KERNEL          LinuxKernel;
 223   EFI_PHYSICAL_ADDRESS  LinuxImage;
 224   EFI_PHYSICAL_ADDRESS  InitrdImage;
 225
 226
 227   PERF_START (NULL, "BDS", NULL, 0);
 228
 229   // Load the Linux kernel from a device path
 230   LinuxImage = LINUX_KERNEL_MAX_OFFSET;
 231   Status = BdsLoadImage (LinuxKernelDevicePath, AllocateMaxAddress, &LinuxImage, &LinuxImageSize);
 232   if (EFI_ERROR(Status)) {
 233     Print (L"ERROR: Did not find Linux kernel.\n");
 234     return Status;
 235   }
 236   LinuxKernel = (LINUX_KERNEL)(UINTN)LinuxImage;
 237
 238   if (InitrdDevicePath) {
 239     InitrdImageSize = 0;
 240     Status = BdsLoadImage (InitrdDevicePath, AllocateAnyPages, &InitrdImage, &InitrdImageSize);
 241     if (EFI_ERROR(Status)) {
 242       Print (L"ERROR: Did not find initrd image.\n");
 243       return Status;
 244     }
 245   }
 246
 247   if (FdtDevicePath) {
 248     // Load the FDT binary from a device path
 249     KernelParamsAddress = LINUX_ATAG_MAX_OFFSET;
 250     Status = BdsLoadImage (FdtDevicePath, AllocateMaxAddress, &KernelParamsAddress, &KernelParamsSize);
 251     if (EFI_ERROR(Status)) {
 252       Print (L"ERROR: Did not find Device Tree blob.\n");
 253       return Status;
 254     }
 255     FdtSupported = TRUE;
 256   }
 257
 258   //
 259   // Setup the Linux Kernel Parameters
 260   //
 261   if (!FdtSupported) {
 262     // Non-FDT requires a specific machine type.
 263     // This OS Boot loader supports just one machine type,
 264     // but that could change in the future.
 265     MachineType = PcdGet32(PcdArmMachineType);
 266
 267     // By setting address=0 we leave the memory allocation to the function
 268     Status = PrepareAtagList (Arguments, InitrdImage, InitrdImageSize, (LINUX_ATAG**)&KernelParamsAddress, &KernelParamsSize);
 269     if(EFI_ERROR(Status)) {
 270       Print(L"ERROR: Can not prepare ATAG list. Status=0x%X\n", Status);
 271       goto Exit;
 272     }
 273   } else {
 274     MachineType = 0xFFFFFFFF;
 275   }
 276
 277   // Shut down UEFI boot services. ExitBootServices() will notify every driver that created an event on
 278   // ExitBootServices event. Example the Interrupt DXE driver will disable the interrupts on this event.
 279   Status = ShutdownUefiBootServices ();
 280   if(EFI_ERROR(Status)) {
 281     DEBUG((EFI_D_ERROR,"ERROR: Can not shutdown UEFI boot services. Status=0x%X\n", Status));
 282     goto Exit;
 283   }
 284
 285   // Move the kernel parameters to any address inside the first 1MB.
 286   // This is necessary because the ARM Linux kernel requires
 287   // the FTD / ATAG List to reside entirely inside the first 1MB of
 288   // physical memory.
 289   if ((UINTN)KernelParamsAddress > LINUX_ATAG_MAX_OFFSET) {
 290     //Note: There is no requirement on the alignment
 291     KernelParamsAddress = (EFI_PHYSICAL_ADDRESS)(UINTN)CopyMem (ALIGN32_BELOW(LINUX_ATAG_MAX_OFFSET - KernelParamsSize), (VOID*)(UINTN)KernelParamsAddress, KernelParamsSize);
 292   }
 293
 294   if ((UINTN)LinuxImage > LINUX_KERNEL_MAX_OFFSET) {
 295     //Note: There is no requirement on the alignment
 296     LinuxKernel = (LINUX_KERNEL)CopyMem (ALIGN32_BELOW(LINUX_KERNEL_MAX_OFFSET - LinuxImageSize), (VOID*)(UINTN)LinuxImage, LinuxImageSize);
 297   }
 298
 299   //TODO: Check there is no overlapping between kernel and Atag
 300
 301   //
 302   // Switch off interrupts, caches, mmu, etc
 303   //
 304   Status = PreparePlatformHardware ();
 305   ASSERT_EFI_ERROR(Status);
 306
 307   // Register and print out performance information
 308   PERF_END (NULL, "BDS", NULL, 0);
 309   if (PerformanceMeasurementEnabled ()) {
 310     PrintPerformance ();
 311   }
 312
 313   //
 314   // Start the Linux Kernel
 315   //
 316
 317   // Outside BootServices, so can't use Print();
 318   DEBUG((EFI_D_ERROR, "\nStarting the kernel:\n\n"));
 319
 320   // jump to kernel with register set
 321   LinuxKernel ((UINTN)0, (UINTN)MachineType, (UINTN)KernelParamsAddress);
 322
 323   // Kernel should never exit
 324   // After Life services are not provided
 325   ASSERT(FALSE);
 326
 327 Exit:
 328   // Only be here if we fail to start Linux
 329   Print (L"ERROR  : Can not start the kernel. Status=0x%X\n", Status);
 330
 331   // Free Runtimee Memory (kernel and FDT)
 332   return Status;
 333 }