ArmPkg/Application/LinuxLoader/LinuxLoaderFdt.c

   1 /** @file
   2 *
   3 *  Copyright (c) 2011-2015, 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 <PiDxe.h>
  16 #include <Library/ArmLib.h>
  17 #include <Library/HobLib.h>
  18
  19 #include <Guid/ArmMpCoreInfo.h>
  20
  21 #include "LinuxLoader.h"
  22
  23 #define ALIGN(x, a)     (((x) + ((a) - 1)) & ~((a) - 1))
  24 #define PALIGN(p, a)    ((void *)(ALIGN ((unsigned long)(p), (a))))
  25 #define GET_CELL(p)     (p += 4, *((const UINT32 *)(p-4)))
  26
  27 STATIC
  28 UINTN
  29 cpu_to_fdtn (UINTN x) {
  30   if (sizeof (UINTN) == sizeof (UINT32)) {
  31     return cpu_to_fdt32 (x);
  32   } else {
  33     return cpu_to_fdt64 (x);
  34   }
  35 }
  36
  37 typedef struct {
  38   UINTN   Base;
  39   UINTN   Size;
  40 } FDT_REGION;
  41
  42 STATIC
  43 BOOLEAN
  44 IsLinuxReservedRegion (
  45   IN EFI_MEMORY_TYPE MemoryType
  46   )
  47 {
  48   switch (MemoryType) {
  49   case EfiRuntimeServicesCode:
  50   case EfiRuntimeServicesData:
  51   case EfiUnusableMemory:
  52   case EfiACPIReclaimMemory:
  53   case EfiACPIMemoryNVS:
  54   case EfiReservedMemoryType:
  55     return TRUE;
  56   default:
  57     return FALSE;
  58   }
  59 }
  60
  61 /**
  62 ** Relocate the FDT blob to a more appropriate location for the Linux kernel.
  63 ** This function will allocate memory for the relocated FDT blob.
  64 **
  65 ** @retval EFI_SUCCESS on success.
  66 ** @retval EFI_OUT_OF_RESOURCES or EFI_INVALID_PARAMETER on failure.
  67 */
  68 STATIC
  69 EFI_STATUS
  70 RelocateFdt (
  71   EFI_PHYSICAL_ADDRESS   SystemMemoryBase,
  72   EFI_PHYSICAL_ADDRESS   OriginalFdt,
  73   UINTN                  OriginalFdtSize,
  74   EFI_PHYSICAL_ADDRESS   *RelocatedFdt,
  75   UINTN                  *RelocatedFdtSize,
  76   EFI_PHYSICAL_ADDRESS   *RelocatedFdtAlloc
  77   )
  78 {
  79   EFI_STATUS            Status;
  80   INTN                  Error;
  81   UINT64                FdtAlignment;
  82
  83   *RelocatedFdtSize = OriginalFdtSize + FDT_ADDITIONAL_ENTRIES_SIZE;
  84
  85   // If FDT load address needs to be aligned, allocate more space.
  86   FdtAlignment = PcdGet32 (PcdArmLinuxFdtAlignment);
  87   if (FdtAlignment != 0) {
  88     *RelocatedFdtSize += FdtAlignment;
  89   }
  90
  91   // Try below a watermark address.
  92   Status = EFI_NOT_FOUND;
  93   if (PcdGet32 (PcdArmLinuxFdtMaxOffset) != 0) {
  94     *RelocatedFdt = LINUX_FDT_MAX_OFFSET;
  95     Status = gBS->AllocatePages (AllocateMaxAddress, EfiBootServicesData,
  96                     EFI_SIZE_TO_PAGES (*RelocatedFdtSize), RelocatedFdt);
  97     if (EFI_ERROR (Status)) {
  98       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));
  99     }
 100   }
 101
 102   // Try anywhere there is available space.
 103   if (EFI_ERROR (Status)) {
 104     Status = gBS->AllocatePages (AllocateAnyPages, EfiBootServicesData,
 105                     EFI_SIZE_TO_PAGES (*RelocatedFdtSize), RelocatedFdt);
 106     if (EFI_ERROR (Status)) {
 107       ASSERT_EFI_ERROR (Status);
 108       return EFI_OUT_OF_RESOURCES;
 109     } else {
 110       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));
 111     }
 112   }
 113
 114   *RelocatedFdtAlloc = *RelocatedFdt;
 115   if (FdtAlignment != 0) {
 116     *RelocatedFdt = ALIGN (*RelocatedFdt, FdtAlignment);
 117   }
 118
 119   // Load the Original FDT tree into the new region
 120   Error = fdt_open_into ((VOID*)(UINTN) OriginalFdt,
 121             (VOID*)(UINTN)(*RelocatedFdt), *RelocatedFdtSize);
 122   if (Error) {
 123     DEBUG ((EFI_D_ERROR, "fdt_open_into(): %a\n", fdt_strerror (Error)));
 124     gBS->FreePages (*RelocatedFdtAlloc, EFI_SIZE_TO_PAGES (*RelocatedFdtSize));
 125     return EFI_INVALID_PARAMETER;
 126   }
 127
 128   return EFI_SUCCESS;
 129 }
 130
 131 EFI_STATUS
 132 PrepareFdt (
 133   IN     EFI_PHYSICAL_ADDRESS SystemMemoryBase,
 134   IN     CONST CHAR8*         CommandLineArguments,
 135   IN     EFI_PHYSICAL_ADDRESS InitrdImage,
 136   IN     UINTN                InitrdImageSize,
 137   IN OUT EFI_PHYSICAL_ADDRESS *FdtBlobBase,
 138   IN OUT UINTN                *FdtBlobSize
 139   )
 140 {
 141   EFI_STATUS            Status;
 142   EFI_PHYSICAL_ADDRESS  NewFdtBlobBase;
 143   EFI_PHYSICAL_ADDRESS  NewFdtBlobAllocation;
 144   UINTN                 NewFdtBlobSize;
 145   VOID*                 fdt;
 146   INTN                  err;
 147   INTN                  node;
 148   INTN                  cpu_node;
 149   INT32                 lenp;
 150   CONST VOID*           BootArg;
 151   CONST VOID*           Method;
 152   EFI_PHYSICAL_ADDRESS  InitrdImageStart;
 153   EFI_PHYSICAL_ADDRESS  InitrdImageEnd;
 154   FDT_REGION            Region;
 155   UINTN                 Index;
 156   CHAR8                 Name[10];
 157   LIST_ENTRY            ResourceList;
 158   SYSTEM_MEMORY_RESOURCE  *Resource;
 159   ARM_PROCESSOR_TABLE   *ArmProcessorTable;
 160   ARM_CORE_INFO         *ArmCoreInfoTable;
 161   UINT32                MpId;
 162   UINT32                ClusterId;
 163   UINT32                CoreId;
 164   UINT64                CpuReleaseAddr;
 165   UINTN                 MemoryMapSize;
 166   EFI_MEMORY_DESCRIPTOR *MemoryMap;
 167   EFI_MEMORY_DESCRIPTOR *MemoryMapPtr;
 168   UINTN                 MapKey;
 169   UINTN                 DescriptorSize;
 170   UINT32                DescriptorVersion;
 171   UINTN                 Pages;
 172   UINTN                 OriginalFdtSize;
 173   BOOLEAN               CpusNodeExist;
 174   UINTN                 CoreMpId;
 175
 176   NewFdtBlobAllocation = 0;
 177
 178   //
 179   // Sanity checks on the original FDT blob.
 180   //
 181   err = fdt_check_header ((VOID*)(UINTN)(*FdtBlobBase));
 182   if (err != 0) {
 183     Print (L"ERROR: Device Tree header not valid (err:%d)\n", err);
 184     return EFI_INVALID_PARAMETER;
 185   }
 186
 187   // The original FDT blob might have been loaded partially.
 188   // Check that it is not the case.
 189   OriginalFdtSize = (UINTN)fdt_totalsize ((VOID*)(UINTN)(*FdtBlobBase));
 190   if (OriginalFdtSize > *FdtBlobSize) {
 191     Print (L"ERROR: Incomplete FDT. Only %d/%d bytes have been loaded.\n",
 192            *FdtBlobSize, OriginalFdtSize);
 193     return EFI_INVALID_PARAMETER;
 194   }
 195
 196   //
 197   // Relocate the FDT to its final location.
 198   //
 199   Status = RelocateFdt (SystemMemoryBase, *FdtBlobBase, OriginalFdtSize,
 200              &NewFdtBlobBase, &NewFdtBlobSize, &NewFdtBlobAllocation);
 201   if (EFI_ERROR (Status)) {
 202     goto FAIL_RELOCATE_FDT;
 203   }
 204
 205   fdt = (VOID*)(UINTN)NewFdtBlobBase;
 206
 207   node = fdt_subnode_offset (fdt, 0, "chosen");
 208   if (node < 0) {
 209     // The 'chosen' node does not exist, create it
 210     node = fdt_add_subnode (fdt, 0, "chosen");
 211     if (node < 0) {
 212       DEBUG ((EFI_D_ERROR, "Error on finding 'chosen' node\n"));
 213       Status = EFI_INVALID_PARAMETER;
 214       goto FAIL_COMPLETE_FDT;
 215     }
 216   }
 217
 218   DEBUG_CODE_BEGIN ();
 219     BootArg = fdt_getprop (fdt, node, "bootargs", &lenp);
 220     if (BootArg != NULL) {
 221       DEBUG ((EFI_D_ERROR, "BootArg: %a\n", BootArg));
 222     }
 223   DEBUG_CODE_END ();
 224
 225   //
 226   // Set Linux CmdLine
 227   //
 228   if ((CommandLineArguments != NULL) && (AsciiStrLen (CommandLineArguments) > 0)) {
 229     err = fdt_setprop (fdt, node, "bootargs", CommandLineArguments, AsciiStrSize (CommandLineArguments));
 230     if (err) {
 231       DEBUG ((EFI_D_ERROR, "Fail to set new 'bootarg' (err:%d)\n", err));
 232     }
 233   }
 234
 235   //
 236   // Set Linux Initrd
 237   //
 238   if (InitrdImageSize != 0) {
 239     InitrdImageStart = cpu_to_fdt64 (InitrdImage);
 240     err = fdt_setprop (fdt, node, "linux,initrd-start", &InitrdImageStart, sizeof (EFI_PHYSICAL_ADDRESS));
 241     if (err) {
 242       DEBUG ((EFI_D_ERROR, "Fail to set new 'linux,initrd-start' (err:%d)\n", err));
 243     }
 244     InitrdImageEnd = cpu_to_fdt64 (InitrdImage + InitrdImageSize);
 245     err = fdt_setprop (fdt, node, "linux,initrd-end", &InitrdImageEnd, sizeof (EFI_PHYSICAL_ADDRESS));
 246     if (err) {
 247       DEBUG ((EFI_D_ERROR, "Fail to set new 'linux,initrd-start' (err:%d)\n", err));
 248     }
 249   }
 250
 251   //
 252   // Set Physical memory setup if does not exist
 253   //
 254   node = fdt_subnode_offset (fdt, 0, "memory");
 255   if (node < 0) {
 256     // The 'memory' node does not exist, create it
 257     node = fdt_add_subnode (fdt, 0, "memory");
 258     if (node >= 0) {
 259       fdt_setprop_string (fdt, node, "name", "memory");
 260       fdt_setprop_string (fdt, node, "device_type", "memory");
 261
 262       GetSystemMemoryResources (&ResourceList);
 263       Resource = (SYSTEM_MEMORY_RESOURCE*)ResourceList.ForwardLink;
 264
 265       Region.Base = cpu_to_fdtn ((UINTN)Resource->PhysicalStart);
 266       Region.Size = cpu_to_fdtn ((UINTN)Resource->ResourceLength);
 267
 268       err = fdt_setprop (fdt, node, "reg", &Region, sizeof (Region));
 269       if (err) {
 270         DEBUG ((EFI_D_ERROR, "Fail to set new 'memory region' (err:%d)\n", err));
 271       }
 272     }
 273   }
 274
 275   //
 276   // Add the memory regions reserved by the UEFI Firmware
 277   //
 278
 279   // Retrieve the UEFI Memory Map
 280   MemoryMap = NULL;
 281   MemoryMapSize = 0;
 282   Status = gBS->GetMemoryMap (&MemoryMapSize, MemoryMap, &MapKey, &DescriptorSize, &DescriptorVersion);
 283   if (Status == EFI_BUFFER_TOO_SMALL) {
 284     // The UEFI specification advises to allocate more memory for the MemoryMap buffer between successive
 285     // calls to GetMemoryMap(), since allocation of the new buffer may potentially increase memory map size.
 286     Pages = EFI_SIZE_TO_PAGES (MemoryMapSize) + 1;
 287     MemoryMap = AllocatePages (Pages);
 288     if (MemoryMap == NULL) {
 289       Status = EFI_OUT_OF_RESOURCES;
 290       goto FAIL_COMPLETE_FDT;
 291     }
 292     Status = gBS->GetMemoryMap (&MemoryMapSize, MemoryMap, &MapKey, &DescriptorSize, &DescriptorVersion);
 293   }
 294
 295   // Go through the list and add the reserved region to the Device Tree
 296   if (!EFI_ERROR (Status)) {
 297     MemoryMapPtr = MemoryMap;
 298     for (Index = 0; Index < (MemoryMapSize / DescriptorSize); Index++) {
 299       if (IsLinuxReservedRegion ((EFI_MEMORY_TYPE)MemoryMapPtr->Type)) {
 300         DEBUG ((DEBUG_VERBOSE, "Reserved region of type %d [0x%lX, 0x%lX]\n",
 301             MemoryMapPtr->Type,
 302             (UINTN)MemoryMapPtr->PhysicalStart,
 303             (UINTN)(MemoryMapPtr->PhysicalStart + MemoryMapPtr->NumberOfPages * EFI_PAGE_SIZE)));
 304         err = fdt_add_mem_rsv (fdt, MemoryMapPtr->PhysicalStart, MemoryMapPtr->NumberOfPages * EFI_PAGE_SIZE);
 305         if (err != 0) {
 306           Print (L"Warning: Fail to add 'memreserve' (err:%d)\n", err);
 307         }
 308       }
 309       MemoryMapPtr = (EFI_MEMORY_DESCRIPTOR*)((UINTN)MemoryMapPtr + DescriptorSize);
 310     }
 311   }
 312
 313   //
 314   // Setup Arm Mpcore Info if it is a multi-core or multi-cluster platforms.
 315   //
 316   // For 'cpus' and 'cpu' device tree nodes bindings, refer to this file
 317   // in the kernel documentation:
 318   // Documentation/devicetree/bindings/arm/cpus.txt
 319   //
 320   for (Index = 0; Index < gST->NumberOfTableEntries; Index++) {
 321     // Check for correct GUID type
 322     if (CompareGuid (&gArmMpCoreInfoGuid, &(gST->ConfigurationTable[Index].VendorGuid))) {
 323       MpId = ArmReadMpidr ();
 324       ClusterId = GET_CLUSTER_ID (MpId);
 325       CoreId    = GET_CORE_ID (MpId);
 326
 327       node = fdt_subnode_offset (fdt, 0, "cpus");
 328       if (node < 0) {
 329         // Create the /cpus node
 330         node = fdt_add_subnode (fdt, 0, "cpus");
 331         fdt_setprop_string (fdt, node, "name", "cpus");
 332         fdt_setprop_cell (fdt, node, "#address-cells", sizeof (UINTN) / 4);
 333         fdt_setprop_cell (fdt, node, "#size-cells", 0);
 334         CpusNodeExist = FALSE;
 335       } else {
 336         CpusNodeExist = TRUE;
 337       }
 338
 339       // Get pointer to ARM processor table
 340       ArmProcessorTable = (ARM_PROCESSOR_TABLE *)gST->ConfigurationTable[Index].VendorTable;
 341       ArmCoreInfoTable = ArmProcessorTable->ArmCpus;
 342
 343       for (Index = 0; Index < ArmProcessorTable->NumberOfEntries; Index++) {
 344         CoreMpId = (UINTN) GET_MPID (ArmCoreInfoTable[Index].ClusterId,
 345                              ArmCoreInfoTable[Index].CoreId);
 346         AsciiSPrint (Name, 10, "cpu@%x", CoreMpId);
 347
 348         // If the 'cpus' node did not exist then create all the 'cpu' nodes.
 349         // In case 'cpus' node is provided in the original FDT then we do not add
 350         // any 'cpu' node.
 351         if (!CpusNodeExist) {
 352           cpu_node = fdt_add_subnode (fdt, node, Name);
 353           if (cpu_node < 0) {
 354             DEBUG ((EFI_D_ERROR, "Error on creating '%s' node\n", Name));
 355             Status = EFI_INVALID_PARAMETER;
 356             goto FAIL_COMPLETE_FDT;
 357           }
 358
 359           fdt_setprop_string (fdt, cpu_node, "device_type", "cpu");
 360
 361           CoreMpId = cpu_to_fdtn (CoreMpId);
 362           fdt_setprop (fdt, cpu_node, "reg", &CoreMpId, sizeof (CoreMpId));
 363         } else {
 364           cpu_node = fdt_subnode_offset (fdt, node, Name);
 365         }
 366
 367         if (cpu_node >= 0) {
 368           Method = fdt_getprop (fdt, cpu_node, "enable-method", &lenp);
 369           // We only care when 'enable-method' == 'spin-table'. If the enable-method is not defined
 370           // or defined as 'psci' then we ignore its properties.
 371           if ((Method != NULL) && (AsciiStrCmp ((CHAR8 *)Method, "spin-table") == 0)) {
 372             // There are two cases;
 373             //  - UEFI firmware parked the secondary cores and/or UEFI firmware is aware of the CPU
 374             //    release addresses (PcdArmLinuxSpinTable == TRUE)
 375             //  - the parking of the secondary cores has been managed before starting UEFI and/or UEFI
 376             //    does not anything about the CPU release addresses - in this case we do nothing
 377             if (FeaturePcdGet (PcdArmLinuxSpinTable)) {
 378               CpuReleaseAddr = cpu_to_fdt64 (ArmCoreInfoTable[Index].MailboxSetAddress);
 379               fdt_setprop (fdt, cpu_node, "cpu-release-addr", &CpuReleaseAddr, sizeof (CpuReleaseAddr));
 380
 381               // If it is not the primary core than the cpu should be disabled
 382               if (((ArmCoreInfoTable[Index].ClusterId != ClusterId) || (ArmCoreInfoTable[Index].CoreId != CoreId))) {
 383                 fdt_setprop_string (fdt, cpu_node, "status", "disabled");
 384               }
 385             }
 386           }
 387         }
 388       }
 389       break;
 390     }
 391   }
 392
 393   // If we succeeded to generate the new Device Tree then free the old Device Tree
 394   gBS->FreePages (*FdtBlobBase, EFI_SIZE_TO_PAGES (*FdtBlobSize));
 395
 396   // Update the real size of the Device Tree
 397   fdt_pack ((VOID*)(UINTN)(NewFdtBlobBase));
 398
 399   *FdtBlobBase = NewFdtBlobBase;
 400   *FdtBlobSize = (UINTN)fdt_totalsize ((VOID*)(UINTN)(NewFdtBlobBase));
 401   return EFI_SUCCESS;
 402
 403 FAIL_COMPLETE_FDT:
 404   gBS->FreePages (NewFdtBlobAllocation, EFI_SIZE_TO_PAGES (NewFdtBlobSize));
 405
 406 FAIL_RELOCATE_FDT:
 407   *FdtBlobSize = (UINTN)fdt_totalsize ((VOID*)(UINTN)(*FdtBlobBase));
 408   // Return success even if we failed to update the FDT blob.
 409   // The original one is still valid.
 410   return EFI_SUCCESS;
 411 }