Merge branch 'armlt-tracking-local-fdt' into armlt-tracking

7 files changed, 201 insertions, 62 deletions

diff --git a/edk2/ArmPlatformPkg/ArmPlatformPkg.dec b/edk2/ArmPlatformPkg/ArmPlatformPkg.dec
index 3e2900ba3..07205273b 100644
--- a/edk2/ArmPlatformPkg/ArmPlatformPkg.dec
+++ b/edk2/ArmPlatformPkg/ArmPlatformPkg.dec
@@ -135,7 +135,8 @@
   #  - 2 = a Linux kernel with FDT support

   gArmPlatformTokenSpaceGuid.PcdDefaultBootType|0|UINT32|0x00000010

   gArmPlatformTokenSpaceGuid.PcdFdtDevicePath|L""|VOID*|0x00000011

-  

+  gArmPlatformTokenSpaceGuid.PcdFdtLocalDevicePath|L""|VOID*|0x0000002E
+
   ## Timeout value for displaying progressing bar in before boot OS.

   #  According to UEFI 2.0 spec, the default TimeOut should be 0xffff.

   gArmPlatformTokenSpaceGuid.PcdPlatformBootTimeOut|0xffff|UINT16|0x0000001A

diff --git a/edk2/ArmPlatformPkg/Bds/Bds.c b/edk2/ArmPlatformPkg/Bds/Bds.c
index 11a76de90..fe463774e 100644
--- a/edk2/ArmPlatformPkg/Bds/Bds.c
+++ b/edk2/ArmPlatformPkg/Bds/Bds.c
@@ -223,8 +223,10 @@ DefineDefaultBootEntries (
   ARM_BDS_LOADER_ARGUMENTS*           BootArguments;

   ARM_BDS_LOADER_TYPE                 BootType;

   EFI_DEVICE_PATH*                    InitrdPath;

+  EFI_DEVICE_PATH*                    FdtLocalPath;
   UINTN                               CmdLineSize;

   UINTN                               InitrdSize;

+  UINTN                               FdtLocalSize;
 

   //

   // If Boot Order does not exist then create a default entry

@@ -262,17 +264,21 @@ DefineDefaultBootEntries (
     if (BootDevicePath != NULL) {

       BootType = (ARM_BDS_LOADER_TYPE)PcdGet32 (PcdDefaultBootType);

 

-      if ((BootType == BDS_LOADER_KERNEL_LINUX_ATAG) || (BootType == BDS_LOADER_KERNEL_LINUX_FDT)) {

+      if ((BootType == BDS_LOADER_KERNEL_LINUX_ATAG) || (BootType == BDS_LOADER_KERNEL_LINUX_GLOBAL_FDT) || (BootType == BDS_LOADER_KERNEL_LINUX_LOCAL_FDT)) {
         CmdLineSize = AsciiStrSize ((CHAR8*)PcdGetPtr(PcdDefaultBootArgument));

         InitrdPath = EfiDevicePathFromTextProtocol->ConvertTextToDevicePath ((CHAR16*)PcdGetPtr(PcdDefaultBootInitrdPath));

         InitrdSize = GetDevicePathSize (InitrdPath);

+        FdtLocalPath = EfiDevicePathFromTextProtocol->ConvertTextToDevicePath ((CHAR16*)PcdGetPtr(PcdFdtLocalDevicePath));
+        FdtLocalSize = GetDevicePathSize (FdtLocalPath);
 

-        BootArguments = (ARM_BDS_LOADER_ARGUMENTS*)AllocatePool (sizeof(ARM_BDS_LOADER_ARGUMENTS) + CmdLineSize + InitrdSize);

+        BootArguments = (ARM_BDS_LOADER_ARGUMENTS*)AllocatePool (sizeof(ARM_BDS_LOADER_ARGUMENTS) + CmdLineSize + InitrdSize + FdtLocalSize);
         BootArguments->LinuxArguments.CmdLineSize = CmdLineSize;

         BootArguments->LinuxArguments.InitrdSize = InitrdSize;

+        BootArguments->LinuxArguments.FdtLocalSize = FdtLocalSize;
 

         CopyMem ((VOID*)(BootArguments + 1), (CHAR8*)PcdGetPtr(PcdDefaultBootArgument), CmdLineSize);

         CopyMem ((VOID*)((UINTN)(BootArguments + 1) + CmdLineSize), InitrdPath, InitrdSize);

+        CopyMem ((VOID*)((UINTN)(BootArguments + 1) + CmdLineSize + InitrdSize), FdtLocalPath, FdtLocalSize);
       } else {

         BootArguments = NULL;

       }

diff --git a/edk2/ArmPlatformPkg/Bds/Bds.inf b/edk2/ArmPlatformPkg/Bds/Bds.inf
index 164e2ae52..f48879367 100644
--- a/edk2/ArmPlatformPkg/Bds/Bds.inf
+++ b/edk2/ArmPlatformPkg/Bds/Bds.inf
@@ -67,6 +67,7 @@
   gArmPlatformTokenSpaceGuid.PcdDefaultBootArgument
   gArmPlatformTokenSpaceGuid.PcdDefaultBootType
   gArmPlatformTokenSpaceGuid.PcdFdtDevicePath
+  gArmPlatformTokenSpaceGuid.PcdFdtLocalDevicePath
   gArmPlatformTokenSpaceGuid.PcdPlatformBootTimeOut
   gArmPlatformTokenSpaceGuid.PcdDefaultConInPaths
   gArmPlatformTokenSpaceGuid.PcdDefaultConOutPaths
diff --git a/edk2/ArmPlatformPkg/Bds/BdsInternal.h b/edk2/ArmPlatformPkg/Bds/BdsInternal.h
index 1307e2ae6..9bc8229d7 100644
--- a/edk2/ArmPlatformPkg/Bds/BdsInternal.h
+++ b/edk2/ArmPlatformPkg/Bds/BdsInternal.h
@@ -48,16 +48,19 @@
 typedef enum {

     BDS_LOADER_EFI_APPLICATION = 0,

     BDS_LOADER_KERNEL_LINUX_ATAG,

-    BDS_LOADER_KERNEL_LINUX_FDT,

+    BDS_LOADER_KERNEL_LINUX_GLOBAL_FDT,
+    BDS_LOADER_KERNEL_LINUX_LOCAL_FDT,
 } ARM_BDS_LOADER_TYPE;

 

 typedef struct {

   UINT16                     CmdLineSize;

   UINT16                     InitrdSize;

-  

+  UINT16                     FdtLocalSize;
+
   // These following fields have variable length and are packed:

   //CHAR8                      *CmdLine;

   //EFI_DEVICE_PATH_PROTOCOL   *InitrdPathList;

+  //EFI_DEVICE_PATH_PROTOCOL   *FdtLocalPathList;
 } ARM_BDS_LINUX_ARGUMENTS;

 

 typedef union {

diff --git a/edk2/ArmPlatformPkg/Bds/BootMenu.c b/edk2/ArmPlatformPkg/Bds/BootMenu.c
index 1cc048e51..eeea35cd0 100644
--- a/edk2/ArmPlatformPkg/Bds/BootMenu.c
+++ b/edk2/ArmPlatformPkg/Bds/BootMenu.c
@@ -125,9 +125,12 @@ BootMenuAddBootOption (
   EFI_DEVICE_PATH_PROTOCOL  *DevicePathNode;

   EFI_DEVICE_PATH_PROTOCOL  *InitrdPathNode;

   EFI_DEVICE_PATH_PROTOCOL  *InitrdPath;

+  EFI_DEVICE_PATH_PROTOCOL  *FdtLocalPathNode;
+  EFI_DEVICE_PATH_PROTOCOL  *FdtLocalPath;
   UINTN                     CmdLineSize;

   BOOLEAN                   InitrdSupport;

   UINTN                     InitrdSize;

+  UINTN                     FdtLocalSize;
 

   Attributes                = 0;

   SupportedBootDevice = NULL;

@@ -148,7 +151,7 @@ BootMenuAddBootOption (
   // Append the Device Path node to the select device path

   DevicePath = AppendDevicePathNode (SupportedBootDevice->DevicePathProtocol, (CONST EFI_DEVICE_PATH_PROTOCOL *)DevicePathNode);

 

-  if ((BootType == BDS_LOADER_KERNEL_LINUX_ATAG) || (BootType == BDS_LOADER_KERNEL_LINUX_FDT)) {

+  if ((BootType == BDS_LOADER_KERNEL_LINUX_ATAG) || (BootType == BDS_LOADER_KERNEL_LINUX_GLOBAL_FDT) || (BootType == BDS_LOADER_KERNEL_LINUX_LOCAL_FDT)) {
     Print(L"Add an initrd: ");

     Status = GetHIInputBoolean (&InitrdSupport);

     if (EFI_ERROR(Status)) {

@@ -181,15 +184,36 @@ BootMenuAddBootOption (
       goto FREE_DEVICE_PATH;

     }

 

+    if (BootType == BDS_LOADER_KERNEL_LINUX_LOCAL_FDT) {
+      // Create the specific device path node
+      Status = SupportedBootDevice->Support->CreateDevicePathNode (L"local FDT", &FdtLocalPathNode, NULL, NULL);
+      if (EFI_ERROR(Status) && Status != EFI_NOT_FOUND) { // EFI_NOT_FOUND is returned on empty input string, but we can boot without an initrd
+        Status = EFI_ABORTED;
+        goto EXIT;
+      }
+
+      if (FdtLocalPathNode != NULL) {
+        // Append the Device Path node to the select device path
+        FdtLocalPath = AppendDevicePathNode (SupportedBootDevice->DevicePathProtocol, (CONST EFI_DEVICE_PATH_PROTOCOL *)FdtLocalPathNode);
+      } else {
+        FdtLocalPath = NULL;
+      }
+    } else {
+      FdtLocalPath = NULL;
+    }
+
     CmdLineSize = AsciiStrSize (CmdLine);

     InitrdSize = GetDevicePathSize (InitrdPath);

+    FdtLocalSize = GetDevicePathSize (FdtLocalPath);
 

-    BootArguments = (ARM_BDS_LOADER_ARGUMENTS*)AllocatePool (sizeof(ARM_BDS_LOADER_ARGUMENTS) + CmdLineSize + InitrdSize);

+    BootArguments = (ARM_BDS_LOADER_ARGUMENTS*)AllocatePool (sizeof(ARM_BDS_LOADER_ARGUMENTS) + CmdLineSize + InitrdSize + FdtLocalSize);
     

     BootArguments->LinuxArguments.CmdLineSize = CmdLineSize;

     BootArguments->LinuxArguments.InitrdSize = InitrdSize;

+    BootArguments->LinuxArguments.FdtLocalSize = FdtLocalSize;
     CopyMem ((VOID*)(&BootArguments->LinuxArguments + 1), CmdLine, CmdLineSize);

     CopyMem ((VOID*)((UINTN)(&BootArguments->LinuxArguments + 1) + CmdLineSize), InitrdPath, InitrdSize);

+    CopyMem ((VOID*)((UINTN)(&BootArguments->LinuxArguments + 1) + CmdLineSize + InitrdSize), FdtLocalPath, FdtLocalSize);
   } else {

     BootArguments = NULL;

   }

@@ -264,7 +288,7 @@ BootMenuSelectBootOption (
       Print(L"\t- %s\n",DevicePathTxt);

       OptionalData = BdsLoadOption->OptionalData;

       LoaderType = (ARM_BDS_LOADER_TYPE)ReadUnaligned32 ((CONST UINT32*)&OptionalData->Header.LoaderType);

-      if ((LoaderType == BDS_LOADER_KERNEL_LINUX_ATAG) || (LoaderType == BDS_LOADER_KERNEL_LINUX_FDT)) {

+      if ((LoaderType == BDS_LOADER_KERNEL_LINUX_ATAG) || (LoaderType == BDS_LOADER_KERNEL_LINUX_GLOBAL_FDT) || (LoaderType == BDS_LOADER_KERNEL_LINUX_LOCAL_FDT)) {
         Print (L"\t- Arguments: %a\n",&OptionalData->Arguments.LinuxArguments + 1);

       }

 

@@ -356,14 +380,19 @@ BootMenuUpdateBootOption (
   CHAR8                         CmdLine[BOOT_DEVICE_OPTION_MAX];

   EFI_DEVICE_PATH               *DevicePath;

   EFI_DEVICE_PATH               *TempInitrdPath;

+  EFI_DEVICE_PATH               *TempFdtLocalPath;
   ARM_BDS_LOADER_TYPE           BootType;

   ARM_BDS_LOADER_OPTIONAL_DATA* OptionalData;

   ARM_BDS_LINUX_ARGUMENTS*      LinuxArguments;

   EFI_DEVICE_PATH               *InitrdPathNode;

   EFI_DEVICE_PATH               *InitrdPath;

   UINTN                         InitrdSize;

+  EFI_DEVICE_PATH               *FdtLocalPathNode;
+  EFI_DEVICE_PATH               *FdtLocalPath;
+  UINTN                         FdtLocalSize;
   UINTN                         CmdLineSize;

   BOOLEAN                       InitrdSupport;

+  BOOLEAN                       FdtLocalSupport;
 

   Status = BootMenuSelectBootOption (BootOptionsList, UPDATE_BOOT_ENTRY, TRUE, &BootOptionEntry);

   if (EFI_ERROR(Status)) {

@@ -387,7 +416,7 @@ BootMenuUpdateBootOption (
   OptionalData = BootOption->OptionalData;

   BootType = (ARM_BDS_LOADER_TYPE)ReadUnaligned32 ((UINT32 *)(&OptionalData->Header.LoaderType));

 

-  if ((BootType == BDS_LOADER_KERNEL_LINUX_ATAG) || (BootType == BDS_LOADER_KERNEL_LINUX_FDT)) {

+  if ((BootType == BDS_LOADER_KERNEL_LINUX_ATAG) || (BootType == BDS_LOADER_KERNEL_LINUX_GLOBAL_FDT) || (BootType == BDS_LOADER_KERNEL_LINUX_LOCAL_FDT)) {
     LinuxArguments = &OptionalData->Arguments.LinuxArguments;

 

     CmdLineSize = ReadUnaligned16 ((CONST UINT16*)&LinuxArguments->CmdLineSize);

@@ -451,13 +480,65 @@ BootMenuUpdateBootOption (
       goto FREE_DEVICE_PATH;

     }

 

+    FdtLocalSize = ReadUnaligned16 ((CONST UINT16*)&LinuxArguments->FdtLocalSize);
+    if (BootType == BDS_LOADER_KERNEL_LINUX_LOCAL_FDT) {
+      if (FdtLocalSize > 0) {
+        Print(L"Keep the local FDT: ");
+      } else {
+        Print(L"Add a local FDT: ");
+      }
+      Status = GetHIInputBoolean (&FdtLocalSupport);
+      if (EFI_ERROR(Status)) {
+        Status = EFI_ABORTED;
+        goto EXIT;
+      }
+      if (FdtLocalSupport && BootType == BDS_LOADER_KERNEL_LINUX_LOCAL_FDT) {
+        if (FdtLocalSize > 0) {
+          // Case we update the FDT local device path
+          Status = DeviceSupport->UpdateDevicePathNode ((EFI_DEVICE_PATH*)((UINTN)(LinuxArguments + 1) + CmdLineSize + InitrdSize), L"local FDT", &FdtLocalPath, NULL, NULL);
+          if (EFI_ERROR(Status) && Status != EFI_NOT_FOUND) {// EFI_NOT_FOUND is returned on empty input string
+            Status = EFI_ABORTED;
+            goto EXIT;
+          }
+          FdtLocalSize = GetDevicePathSize (FdtLocalPath);
+        } else {
+          // Case we create the FdtLocal device path
+
+          Status = DeviceSupport->CreateDevicePathNode (L"local FDT", &FdtLocalPathNode, NULL, NULL);
+          if (EFI_ERROR(Status) && Status != EFI_NOT_FOUND) { // EFI_NOT_FOUND is returned on empty input string
+            Status = EFI_ABORTED;
+            goto EXIT;
+          }
+
+          if (FdtLocalPathNode != NULL) {
+            // Duplicate Linux kernel Device Path
+            TempFdtLocalPath = DuplicateDevicePath (BootOption->FilePathList);
+            // Replace Linux kernel Node by EndNode
+            SetDevicePathEndNode (GetLastDevicePathNode (TempFdtLocalPath));
+            // Append the Device Path node to the select device path
+            FdtLocalPath = AppendDevicePathNode (TempFdtLocalPath, (CONST EFI_DEVICE_PATH_PROTOCOL *)FdtLocalPathNode);
+            FreePool (TempFdtLocalPath);
+            FdtLocalSize = GetDevicePathSize (FdtLocalPath);
+          } else {
+            FdtLocalPath = NULL;
+          }
+        }
+      } else {
+        FdtLocalSize = 0;
+      }
+    } else {
+      FdtLocalSupport = FALSE;
+    }
+
     CmdLineSize = AsciiStrSize (CmdLine);

 

-    BootArguments = (ARM_BDS_LOADER_ARGUMENTS*)AllocatePool(sizeof(ARM_BDS_LOADER_ARGUMENTS) + CmdLineSize + InitrdSize);

+    BootArguments = (ARM_BDS_LOADER_ARGUMENTS*)AllocatePool(sizeof(ARM_BDS_LOADER_ARGUMENTS) + CmdLineSize + InitrdSize + FdtLocalSize);
     BootArguments->LinuxArguments.CmdLineSize = CmdLineSize;

     BootArguments->LinuxArguments.InitrdSize = InitrdSize;

+    BootArguments->LinuxArguments.FdtLocalSize = FdtLocalSize;
     CopyMem (&BootArguments->LinuxArguments + 1, CmdLine, CmdLineSize);

     CopyMem ((VOID*)((UINTN)(&BootArguments->LinuxArguments + 1) + CmdLineSize), InitrdPath, InitrdSize);

+    CopyMem ((VOID*)((UINTN)(&BootArguments->LinuxArguments + 1) + CmdLineSize + InitrdSize), FdtLocalPath, FdtLocalSize);
   } else {

     BootArguments = NULL;

   }

@@ -636,40 +717,65 @@ BootMenuMain (
 

       Print(L"[%d] %s\n", OptionCount, BootOption->Description);

 

-      DEBUG_CODE_BEGIN();

-        CHAR16*                           DevicePathTxt;

-        EFI_DEVICE_PATH_TO_TEXT_PROTOCOL* DevicePathToTextProtocol;

-        ARM_BDS_LOADER_OPTIONAL_DATA*     OptionalData;

-        UINTN                             CmdLineSize;

-        ARM_BDS_LOADER_TYPE               LoaderType;

-

-        Status = gBS->LocateProtocol (&gEfiDevicePathToTextProtocolGuid, NULL, (VOID **)&DevicePathToTextProtocol);

-        if (EFI_ERROR(Status)) {

-          // You must provide an implementation of DevicePathToTextProtocol in your firmware (eg: DevicePathDxe)

-          DEBUG((EFI_D_ERROR,"Error: Bds requires DevicePathToTextProtocol\n"));

-          return Status;

-        }

-        DevicePathTxt = DevicePathToTextProtocol->ConvertDevicePathToText (BootOption->FilePathList, TRUE, TRUE);

-

-        Print(L"\t- %s\n",DevicePathTxt);

-

-        // If it is a supported BootEntry then print its details

-        if (IS_ARM_BDS_BOOTENTRY (BootOption)) {

-          OptionalData = BootOption->OptionalData;

-          LoaderType = (ARM_BDS_LOADER_TYPE)ReadUnaligned32 ((CONST UINT32*)&OptionalData->Header.LoaderType);

-          if ((LoaderType == BDS_LOADER_KERNEL_LINUX_ATAG) || (LoaderType == BDS_LOADER_KERNEL_LINUX_FDT)) {

-            if (ReadUnaligned16 (&OptionalData->Arguments.LinuxArguments.InitrdSize) > 0) {

-              CmdLineSize = ReadUnaligned16 (&OptionalData->Arguments.LinuxArguments.CmdLineSize);

-              DevicePathTxt = DevicePathToTextProtocol->ConvertDevicePathToText (

-                  GetAlignedDevicePath ((EFI_DEVICE_PATH*)((UINTN)(&OptionalData->Arguments.LinuxArguments + 1) + CmdLineSize)), TRUE, TRUE);

-              Print(L"\t- Initrd: %s\n", DevicePathTxt);

-            }

-            Print(L"\t- Arguments: %a\n", (&OptionalData->Arguments.LinuxArguments + 1));

+      CHAR16*                           DevicePathTxt;
+      EFI_DEVICE_PATH_TO_TEXT_PROTOCOL* DevicePathToTextProtocol;
+      ARM_BDS_LOADER_OPTIONAL_DATA*     OptionalData;
+      UINTN                             CmdLineSize;
+      UINTN                             InitrdSize;
+      ARM_BDS_LOADER_TYPE               LoaderType;
+
+     Status = gBS->LocateProtocol (&gEfiDevicePathToTextProtocolGuid, NULL, (VOID **)&DevicePathToTextProtocol);
+     if (EFI_ERROR(Status)) {
+       // You must provide an implementation of DevicePathToTextProtocol in your firmware (eg: DevicePathDxe)
+       DEBUG((EFI_D_ERROR,"Error: Bds requires DevicePathToTextProtocol\n"));
+       return Status;
+     }
+     DevicePathTxt = DevicePathToTextProtocol->ConvertDevicePathToText (BootOption->FilePathList, TRUE, TRUE);
+
+     Print(L"\t- %s\n",DevicePathTxt);
+
+      // If it is a supported BootEntry then print its details
+      if (IS_ARM_BDS_BOOTENTRY (BootOption)) {
+        OptionalData = BootOption->OptionalData;
+        LoaderType = (ARM_BDS_LOADER_TYPE)ReadUnaligned32 ((CONST UINT32*)&OptionalData->Header.LoaderType);
+        if ((LoaderType == BDS_LOADER_KERNEL_LINUX_ATAG) || (LoaderType == BDS_LOADER_KERNEL_LINUX_GLOBAL_FDT) || (LoaderType == BDS_LOADER_KERNEL_LINUX_LOCAL_FDT)) {
+          if (ReadUnaligned16 (&OptionalData->Arguments.LinuxArguments.InitrdSize) > 0) {
+            CmdLineSize = ReadUnaligned16 (&OptionalData->Arguments.LinuxArguments.CmdLineSize);
+            DevicePathTxt = DevicePathToTextProtocol->ConvertDevicePathToText (
+                GetAlignedDevicePath ((EFI_DEVICE_PATH*)((UINTN)(&OptionalData->Arguments.LinuxArguments + 1) + CmdLineSize)), TRUE, TRUE);
+            Print(L"\t- Initrd: %s\n", DevicePathTxt);
           }

-          Print(L"\t- LoaderType: %d\n", LoaderType);

+          Print(L"\t- Arguments: %a\n", (&OptionalData->Arguments.LinuxArguments + 1));
         }

-        FreePool(DevicePathTxt);

-      DEBUG_CODE_END();

+
+        switch (LoaderType) {
+          case BDS_LOADER_EFI_APPLICATION:
+            Print(L"\t- LoaderType: EFI Application\n");
+            break;
+          case BDS_LOADER_KERNEL_LINUX_ATAG:
+            Print(L"\t- LoaderType: Linux kernel with ATAG data\n");
+            break;
+          case BDS_LOADER_KERNEL_LINUX_GLOBAL_FDT:
+            Print(L"\t- LoaderType: Linux kernel with global FDT\n");
+            break;
+          case BDS_LOADER_KERNEL_LINUX_LOCAL_FDT:
+            if (ReadUnaligned16 (&OptionalData->Arguments.LinuxArguments.FdtLocalSize) > 0) {
+              CmdLineSize = ReadUnaligned16 (&OptionalData->Arguments.LinuxArguments.CmdLineSize);
+              InitrdSize  = ReadUnaligned16 (&OptionalData->Arguments.LinuxArguments.InitrdSize);
+              DevicePathTxt = DevicePathToTextProtocol->ConvertDevicePathToText (
+                  GetAlignedDevicePath ((EFI_DEVICE_PATH*)((UINTN)(&OptionalData->Arguments.LinuxArguments + 1) + CmdLineSize + InitrdSize)), TRUE, TRUE);
+              Print(L"\t- FDT: %s\n", DevicePathTxt);
+            } else {
+              Print(L"\t- FDT: error, local FDT not specified, using global FDT\n");
+            }
+            Print(L"\t- LoaderType: Linux kernel with Local FDT\n");
+            break;
+          default:
+            Print(L"unknown\n");
+            break;
+        }
+      }
+     FreePool(DevicePathTxt);
 

       OptionCount++;

     }

diff --git a/edk2/ArmPlatformPkg/Bds/BootOption.c b/edk2/ArmPlatformPkg/Bds/BootOption.c
index 289d36a50..df0a23223 100644
--- a/edk2/ArmPlatformPkg/Bds/BootOption.c
+++ b/edk2/ArmPlatformPkg/Bds/BootOption.c
@@ -32,6 +32,7 @@ BootOptionStart (
   UINTN                                 CmdLineSize;

   UINTN                                 InitrdSize;

   EFI_DEVICE_PATH*                      Initrd;

+  UINTN                                 FdtLocalSize;
   UINT16                                LoadOptionIndexSize;

 

   if (IS_ARM_BDS_BOOTENTRY (BootOption)) {

@@ -58,7 +59,7 @@ BootOptionStart (
       Status = BdsBootLinuxAtag (BootOption->FilePathList,

                                  Initrd, // Initrd

                                  (CHAR8*)(LinuxArguments + 1)); // CmdLine

-    } else if (LoaderType == BDS_LOADER_KERNEL_LINUX_FDT) {

+    } else if ((LoaderType == BDS_LOADER_KERNEL_LINUX_GLOBAL_FDT) || (LoaderType == BDS_LOADER_KERNEL_LINUX_LOCAL_FDT)) {
       LinuxArguments = &(OptionalData->Arguments.LinuxArguments);

       CmdLineSize = ReadUnaligned16 ((CONST UINT16*)&LinuxArguments->CmdLineSize);

       InitrdSize = ReadUnaligned16 ((CONST UINT16*)&LinuxArguments->InitrdSize);

@@ -69,15 +70,25 @@ BootOptionStart (
         Initrd = NULL;

       }

 

-      // Get the default FDT device path

-      Status = gBS->LocateProtocol (&gEfiDevicePathFromTextProtocolGuid, NULL, (VOID **)&EfiDevicePathFromTextProtocol);

-      ASSERT_EFI_ERROR(Status);

-      DefaultFdtDevicePath = EfiDevicePathFromTextProtocol->ConvertTextToDevicePath ((CHAR16*)PcdGetPtr(PcdFdtDevicePath));

-

-      // Get the FDT device path

-      FdtDevicePathSize = GetDevicePathSize (DefaultFdtDevicePath);

-      Status = GetEnvironmentVariable ((CHAR16 *)L"Fdt", DefaultFdtDevicePath, &FdtDevicePathSize, (VOID **)&FdtDevicePath);

-      ASSERT_EFI_ERROR(Status);

+      if (LoaderType == BDS_LOADER_KERNEL_LINUX_LOCAL_FDT) {
+        FdtLocalSize = ReadUnaligned16 ((CONST UINT16*)&LinuxArguments->FdtLocalSize);
+

+        if (FdtLocalSize > 0) {
+          FdtDevicePath = GetAlignedDevicePath ((EFI_DEVICE_PATH*)((UINTN)(LinuxArguments + 1) + CmdLineSize + InitrdSize));
+        } else {
+          FdtDevicePath = NULL;
+        }
+      } else  {
+        // Get the default FDT device path
+        Status = gBS->LocateProtocol (&gEfiDevicePathFromTextProtocolGuid, NULL, (VOID **)&EfiDevicePathFromTextProtocol);
+        ASSERT_EFI_ERROR(Status);
+        DefaultFdtDevicePath = EfiDevicePathFromTextProtocol->ConvertTextToDevicePath ((CHAR16*)PcdGetPtr(PcdFdtDevicePath));
+
+        // Get the FDT device path
+        FdtDevicePathSize = GetDevicePathSize (DefaultFdtDevicePath);
+        Status = GetEnvironmentVariable ((CHAR16 *)L"Fdt", DefaultFdtDevicePath, &FdtDevicePathSize, (VOID **)&FdtDevicePath);
+        ASSERT_EFI_ERROR(Status);
+      }
 

       Status = BdsBootLinuxFdt (BootOption->FilePathList,

                                 Initrd, // Initrd

@@ -157,6 +168,7 @@ BootOptionSetFields (
   UINT16                        FilePathListLength;

   UINT8*                        EfiLoadOptionPtr;

   UINT8*                        InitrdPathListPtr;

+  UINT8*                        FdtLocalPathListPtr;
   UINTN                         OptionalDataSize;

   ARM_BDS_LINUX_ARGUMENTS*      DestLinuxArguments;

   ARM_BDS_LINUX_ARGUMENTS*      SrcLinuxArguments;

@@ -168,8 +180,8 @@ BootOptionSetFields (
 

   BootDescriptionSize = StrSize (BootDescription);

   BootOptionalDataSize = sizeof(ARM_BDS_LOADER_OPTIONAL_DATA_HEADER);

-  if ((BootType == BDS_LOADER_KERNEL_LINUX_ATAG) || (BootType == BDS_LOADER_KERNEL_LINUX_FDT)) {

-    BootOptionalDataSize += sizeof(ARM_BDS_LINUX_ARGUMENTS) + BootArguments->LinuxArguments.CmdLineSize + BootArguments->LinuxArguments.InitrdSize;

+  if ((BootType == BDS_LOADER_KERNEL_LINUX_ATAG) || (BootType == BDS_LOADER_KERNEL_LINUX_GLOBAL_FDT) || (BootType == BDS_LOADER_KERNEL_LINUX_LOCAL_FDT)) {
+    BootOptionalDataSize += sizeof(ARM_BDS_LINUX_ARGUMENTS) + BootArguments->LinuxArguments.CmdLineSize + BootArguments->LinuxArguments.InitrdSize + BootArguments->LinuxArguments.FdtLocalSize;
   }

 

   // Compute the size of the FilePath list

@@ -211,12 +223,13 @@ BootOptionSetFields (
 

   OptionalDataSize = sizeof(ARM_BDS_LOADER_OPTIONAL_DATA_HEADER);

 

-  if ((BootType == BDS_LOADER_KERNEL_LINUX_ATAG) || (BootType == BDS_LOADER_KERNEL_LINUX_FDT)) {

+  if ((BootType == BDS_LOADER_KERNEL_LINUX_ATAG) || (BootType == BDS_LOADER_KERNEL_LINUX_GLOBAL_FDT) || (BootType == BDS_LOADER_KERNEL_LINUX_LOCAL_FDT)) {
     SrcLinuxArguments = &(BootArguments->LinuxArguments);

     DestLinuxArguments = &((ARM_BDS_LOADER_OPTIONAL_DATA*)EfiLoadOptionPtr)->Arguments.LinuxArguments;

 

     WriteUnaligned16 ((UINT16 *)&(DestLinuxArguments->CmdLineSize), SrcLinuxArguments->CmdLineSize);

     WriteUnaligned16 ((UINT16 *)&(DestLinuxArguments->InitrdSize), SrcLinuxArguments->InitrdSize);

+    WriteUnaligned16 ((UINT16 *)&(DestLinuxArguments->FdtLocalSize), SrcLinuxArguments->FdtLocalSize);
     OptionalDataSize += sizeof (ARM_BDS_LINUX_ARGUMENTS);

 

     if (SrcLinuxArguments->CmdLineSize > 0) {

@@ -228,6 +241,11 @@ BootOptionSetFields (
       InitrdPathListPtr = (UINT8*)((UINTN)(DestLinuxArguments + 1) + SrcLinuxArguments->CmdLineSize);

       CopyMem (InitrdPathListPtr, (VOID*)((UINTN)(SrcLinuxArguments + 1) + SrcLinuxArguments->CmdLineSize), SrcLinuxArguments->InitrdSize);

     }

+
+    if (SrcLinuxArguments->FdtLocalSize > 0) {
+      FdtLocalPathListPtr = (UINT8*)((UINTN)(DestLinuxArguments + 1) + SrcLinuxArguments->CmdLineSize + SrcLinuxArguments->InitrdSize);
+      CopyMem (FdtLocalPathListPtr, (VOID*)((UINTN)(SrcLinuxArguments + 1) + SrcLinuxArguments->CmdLineSize + SrcLinuxArguments->InitrdSize), SrcLinuxArguments->FdtLocalSize);
+    }
   }

   BootOption->OptionalDataSize = OptionalDataSize;

 

diff --git a/edk2/ArmPlatformPkg/Bds/BootOptionSupport.c b/edk2/ArmPlatformPkg/Bds/BootOptionSupport.c
index fbdd5947d..897786f5a 100644
--- a/edk2/ArmPlatformPkg/Bds/BootOptionSupport.c
+++ b/edk2/ArmPlatformPkg/Bds/BootOptionSupport.c
@@ -233,7 +233,7 @@ BootDeviceGetType (
   EFI_STATUS Status;

   BOOLEAN IsEfiApp;

   BOOLEAN IsBootLoader;

-  BOOLEAN     HasFDTSupport;

+  CHAR16  FDTType[16];
 

   if (FileName == NULL) {

     Print(L"Is an EFI Application? ");

@@ -258,16 +258,20 @@ BootDeviceGetType (
     }

     *BootType = BDS_LOADER_EFI_APPLICATION;

   } else {

-    Print(L"Has FDT support? ");

-    Status = GetHIInputBoolean (&HasFDTSupport);

+    Print(L"Boot Type: [a] ATAGS, [g] Global FDT or [l] Local FDT? [a/g/l] ");
+    Status = GetHIInputStr (FDTType, 16);
     if (EFI_ERROR(Status)) {

       return EFI_ABORTED;

     }

-    if (HasFDTSupport) {

-      *BootType = BDS_LOADER_KERNEL_LINUX_FDT;

-    } else {

+	if (StrCmp(FDTType, L"g") == 0) {
+      *BootType = BDS_LOADER_KERNEL_LINUX_GLOBAL_FDT;
+	} else if (StrCmp(FDTType, L"l") == 0) {
+      *BootType = BDS_LOADER_KERNEL_LINUX_LOCAL_FDT;
+	} else if (StrCmp(FDTType, L"a") == 0) {
       *BootType = BDS_LOADER_KERNEL_LINUX_ATAG;

-    }

+	} else {
+		return EFI_ABORTED;
+	}
   }

 

   return EFI_SUCCESS;