[mirror_edk2.git] / EmbeddedPkg / Library / AndroidBootImgLib / AndroidBootImgLib.c

/** @file\r
\r
  Copyright (c) 2013-2014, ARM Ltd. All rights reserved.<BR>\r
  Copyright (c) 2017, Linaro. All rights reserved.\r
\r
  SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#include <libfdt.h>\r
#include <Library/AndroidBootImgLib.h>\r
#include <Library/PrintLib.h>\r
#include <Library/UefiBootServicesTableLib.h>\r
#include <Library/UefiLib.h>\r
\r
#include <Protocol/AndroidBootImg.h>\r
#include <Protocol/LoadedImage.h>\r
\r
#define FDT_ADDITIONAL_ENTRIES_SIZE 0x400\r
\r
typedef struct {\r
  MEMMAP_DEVICE_PATH                      Node1;\r
  EFI_DEVICE_PATH_PROTOCOL                End;\r
} MEMORY_DEVICE_PATH;\r
\r
STATIC ANDROID_BOOTIMG_PROTOCOL                 *mAndroidBootImg;\r
\r
STATIC CONST MEMORY_DEVICE_PATH mMemoryDevicePathTemplate =\r
{\r
  {\r
    {\r
      HARDWARE_DEVICE_PATH,\r
      HW_MEMMAP_DP,\r
      {\r
        (UINT8)(sizeof (MEMMAP_DEVICE_PATH)),\r
        (UINT8)((sizeof (MEMMAP_DEVICE_PATH)) >> 8),\r
      },\r
    }, // Header\r
    0, // StartingAddress (set at runtime)\r
    0  // EndingAddress   (set at runtime)\r
  }, // Node1\r
  {\r
    END_DEVICE_PATH_TYPE,\r
    END_ENTIRE_DEVICE_PATH_SUBTYPE,\r
    { sizeof (EFI_DEVICE_PATH_PROTOCOL), 0 }\r
  } // End\r
};\r
\r
EFI_STATUS\r
AndroidBootImgGetImgSize (\r
  IN  VOID    *BootImg,\r
  OUT UINTN   *ImgSize\r
  )\r
{\r
  ANDROID_BOOTIMG_HEADER   *Header;\r
\r
  Header = (ANDROID_BOOTIMG_HEADER *) BootImg;\r
\r
  if (AsciiStrnCmp ((CONST CHAR8 *)Header->BootMagic, ANDROID_BOOT_MAGIC,\r
                    ANDROID_BOOT_MAGIC_LENGTH) != 0) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  /* The page size is not specified, but it should be power of 2 at least */\r
  ASSERT (IS_VALID_ANDROID_PAGE_SIZE (Header->PageSize));\r
\r
  /* Get real size of abootimg */\r
  *ImgSize = ALIGN_VALUE (Header->KernelSize, Header->PageSize) +\r
             ALIGN_VALUE (Header->RamdiskSize, Header->PageSize) +\r
             ALIGN_VALUE (Header->SecondStageBootloaderSize, Header->PageSize) +\r
             Header->PageSize;\r
  return EFI_SUCCESS;\r
}\r
\r
EFI_STATUS\r
AndroidBootImgGetKernelInfo (\r
  IN  VOID    *BootImg,\r
  OUT VOID   **Kernel,\r
  OUT UINTN   *KernelSize\r
  )\r
{\r
  ANDROID_BOOTIMG_HEADER   *Header;\r
\r
  Header = (ANDROID_BOOTIMG_HEADER *) BootImg;\r
\r
  if (AsciiStrnCmp ((CONST CHAR8 *)Header->BootMagic, ANDROID_BOOT_MAGIC,\r
                    ANDROID_BOOT_MAGIC_LENGTH) != 0) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if (Header->KernelSize == 0) {\r
    return EFI_NOT_FOUND;\r
  }\r
\r
  ASSERT (IS_VALID_ANDROID_PAGE_SIZE (Header->PageSize));\r
\r
  *KernelSize = Header->KernelSize;\r
  *Kernel = (VOID *)((UINTN)BootImg + Header->PageSize);\r
  return EFI_SUCCESS;\r
}\r
\r
EFI_STATUS\r
AndroidBootImgGetRamdiskInfo (\r
  IN  VOID    *BootImg,\r
  OUT VOID   **Ramdisk,\r
  OUT UINTN   *RamdiskSize\r
  )\r
{\r
  ANDROID_BOOTIMG_HEADER   *Header;\r
\r
  Header = (ANDROID_BOOTIMG_HEADER *)BootImg;\r
\r
  if (AsciiStrnCmp ((CONST CHAR8 *)Header->BootMagic, ANDROID_BOOT_MAGIC,\r
                    ANDROID_BOOT_MAGIC_LENGTH) != 0) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  ASSERT (IS_VALID_ANDROID_PAGE_SIZE (Header->PageSize));\r
\r
  *RamdiskSize = Header->RamdiskSize;\r
\r
  if (Header->RamdiskSize != 0) {\r
    *Ramdisk = (VOID *)((INTN)BootImg\r
                        + Header->PageSize\r
                        + ALIGN_VALUE (Header->KernelSize, Header->PageSize));\r
  }\r
  return EFI_SUCCESS;\r
}\r
\r
EFI_STATUS\r
AndroidBootImgGetSecondBootLoaderInfo (\r
  IN  VOID    *BootImg,\r
  OUT VOID   **Second,\r
  OUT UINTN   *SecondSize\r
  )\r
{\r
  ANDROID_BOOTIMG_HEADER   *Header;\r
\r
  Header = (ANDROID_BOOTIMG_HEADER *)BootImg;\r
\r
  if (AsciiStrnCmp ((CONST CHAR8 *)Header->BootMagic, ANDROID_BOOT_MAGIC,\r
                    ANDROID_BOOT_MAGIC_LENGTH) != 0) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  ASSERT (IS_VALID_ANDROID_PAGE_SIZE (Header->PageSize));\r
\r
  *SecondSize = Header->SecondStageBootloaderSize;\r
\r
  if (Header->SecondStageBootloaderSize != 0) {\r
    *Second = (VOID *)((UINTN)BootImg\r
                       + Header->PageSize\r
                       + ALIGN_VALUE (Header->KernelSize, Header->PageSize)\r
                       + ALIGN_VALUE (Header->RamdiskSize, Header->PageSize));\r
  }\r
  return EFI_SUCCESS;\r
}\r
\r
EFI_STATUS\r
AndroidBootImgGetKernelArgs (\r
  IN  VOID    *BootImg,\r
  OUT CHAR8   *KernelArgs\r
  )\r
{\r
  ANDROID_BOOTIMG_HEADER   *Header;\r
\r
  Header = (ANDROID_BOOTIMG_HEADER *) BootImg;\r
  AsciiStrnCpyS (KernelArgs, ANDROID_BOOTIMG_KERNEL_ARGS_SIZE, Header->KernelArgs,\r
    ANDROID_BOOTIMG_KERNEL_ARGS_SIZE);\r
\r
  return EFI_SUCCESS;\r
}\r
\r
EFI_STATUS\r
AndroidBootImgGetFdt (\r
  IN  VOID                  *BootImg,\r
  IN  VOID                 **FdtBase\r
  )\r
{\r
  UINTN                      SecondLoaderSize;\r
  EFI_STATUS                 Status;\r
\r
  /* Check whether FDT is located in second boot region as some vendor do so,\r
   * because second loader is never used as far as I know. */\r
  Status = AndroidBootImgGetSecondBootLoaderInfo (\r
             BootImg,\r
             FdtBase,\r
             &SecondLoaderSize\r
           );\r
  return Status;\r
}\r
\r
EFI_STATUS\r
AndroidBootImgUpdateArgs (\r
  IN  VOID                  *BootImg,\r
  OUT VOID                  *KernelArgs\r
  )\r
{\r
  CHAR8                      ImageKernelArgs[ANDROID_BOOTIMG_KERNEL_ARGS_SIZE];\r
  EFI_STATUS                 Status;\r
\r
  // Get kernel arguments from Android boot image\r
  Status = AndroidBootImgGetKernelArgs (BootImg, ImageKernelArgs);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
  AsciiStrToUnicodeStrS (ImageKernelArgs, KernelArgs,\r
                         ANDROID_BOOTIMG_KERNEL_ARGS_SIZE >> 1);\r
  // Append platform kernel arguments\r
  if(mAndroidBootImg->AppendArgs) {\r
    Status = mAndroidBootImg->AppendArgs (KernelArgs,\r
                                ANDROID_BOOTIMG_KERNEL_ARGS_SIZE);\r
  }\r
  return Status;\r
}\r
\r
EFI_STATUS\r
AndroidBootImgLocateFdt (\r
  IN  VOID                  *BootImg,\r
  IN  VOID                 **FdtBase\r
  )\r
{\r
  INTN                       Err;\r
  EFI_STATUS                 Status;\r
\r
  Status = EfiGetSystemConfigurationTable (&gFdtTableGuid, FdtBase);\r
  if (!EFI_ERROR (Status)) {\r
    return EFI_SUCCESS;\r
  }\r
\r
  Status = AndroidBootImgGetFdt (BootImg, FdtBase);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
  Err = fdt_check_header (*FdtBase);\r
  if (Err != 0) {\r
    DEBUG ((DEBUG_ERROR, "ERROR: Device Tree header not valid (Err:%d)\n",\r
           Err));\r
    return EFI_INVALID_PARAMETER;\r
  }\r
  return EFI_SUCCESS;\r
}\r
\r
INTN\r
AndroidBootImgGetChosenNode (\r
  IN  INTN   UpdatedFdtBase\r
  )\r
{\r
  INTN                   ChosenNode;\r
\r
  ChosenNode = fdt_subnode_offset ((CONST VOID *)UpdatedFdtBase, 0, "chosen");\r
  if (ChosenNode < 0) {\r
    ChosenNode = fdt_add_subnode((VOID *)UpdatedFdtBase, 0, "chosen");\r
      if (ChosenNode < 0) {\r
        DEBUG ((DEBUG_ERROR, "Fail to find fdt node chosen!\n"));\r
        return 0;\r
    }\r
  }\r
  return ChosenNode;\r
}\r
\r
EFI_STATUS\r
AndroidBootImgSetProperty64 (\r
  IN  INTN                   UpdatedFdtBase,\r
  IN  INTN                   ChosenNode,\r
  IN  CHAR8                 *PropertyName,\r
  IN  UINT64                 Val\r
  )\r
{\r
  INTN                      Err;\r
  struct fdt_property      *Property;\r
  int                       Len;\r
\r
  Property = fdt_get_property_w((VOID *)UpdatedFdtBase, ChosenNode,\r
                            PropertyName, &Len);\r
  if (NULL == Property && Len == -FDT_ERR_NOTFOUND) {\r
    Val = cpu_to_fdt64(Val);\r
    Err = fdt_appendprop ((VOID *)UpdatedFdtBase, ChosenNode,\r
                          PropertyName, &Val, sizeof (UINT64));\r
    if (Err) {\r
      DEBUG ((DEBUG_ERROR, "fdt_appendprop() fail: %a\n", fdt_strerror (Err)));\r
      return EFI_INVALID_PARAMETER;\r
    }\r
  } else if (Property != NULL) {\r
    Err = fdt_setprop_u64((VOID *)UpdatedFdtBase, ChosenNode,\r
                          PropertyName, Val);\r
    if (Err) {\r
      DEBUG ((DEBUG_ERROR, "fdt_setprop_u64() fail: %a\n", fdt_strerror (Err)));\r
      return EFI_INVALID_PARAMETER;\r
    }\r
  } else {\r
    DEBUG ((DEBUG_ERROR, "Failed to set fdt Property %a\n", PropertyName));\r
    return EFI_INVALID_PARAMETER;\r
  }\r
  return EFI_SUCCESS;\r
}\r
\r
EFI_STATUS\r
AndroidBootImgUpdateFdt (\r
  IN  VOID                  *BootImg,\r
  IN  VOID                  *FdtBase,\r
  IN  VOID                  *RamdiskData,\r
  IN  UINTN                  RamdiskSize\r
  )\r
{\r
  INTN                       ChosenNode, Err, NewFdtSize;\r
  EFI_STATUS                 Status;\r
  EFI_PHYSICAL_ADDRESS       UpdatedFdtBase, NewFdtBase;\r
\r
  NewFdtSize = (UINTN)fdt_totalsize (FdtBase)\r
               + FDT_ADDITIONAL_ENTRIES_SIZE;\r
  Status = gBS->AllocatePages (AllocateAnyPages, EfiBootServicesData,\r
                  EFI_SIZE_TO_PAGES (NewFdtSize), &UpdatedFdtBase);\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((DEBUG_WARN, "Warning: Failed to reallocate FDT, err %d.\n",\r
           Status));\r
    return Status;\r
  }\r
\r
  // Load the Original FDT tree into the new region\r
  Err = fdt_open_into(FdtBase, (VOID*)(INTN)UpdatedFdtBase, NewFdtSize);\r
  if (Err) {\r
    DEBUG ((DEBUG_ERROR, "fdt_open_into(): %a\n", fdt_strerror (Err)));\r
    Status = EFI_INVALID_PARAMETER;\r
    goto Fdt_Exit;\r
  }\r
\r
  ChosenNode = AndroidBootImgGetChosenNode(UpdatedFdtBase);\r
  if (!ChosenNode) {\r
    goto Fdt_Exit;\r
  }\r
\r
  Status = AndroidBootImgSetProperty64 (UpdatedFdtBase, ChosenNode,\r
                                        "linux,initrd-start",\r
                                        (UINTN)RamdiskData);\r
  if (EFI_ERROR (Status)) {\r
    goto Fdt_Exit;\r
  }\r
\r
  Status = AndroidBootImgSetProperty64 (UpdatedFdtBase, ChosenNode,\r
                                        "linux,initrd-end",\r
                                        (UINTN)RamdiskData + RamdiskSize);\r
  if (EFI_ERROR (Status)) {\r
    goto Fdt_Exit;\r
  }\r
\r
  if (mAndroidBootImg->UpdateDtb) {\r
    Status = mAndroidBootImg->UpdateDtb (UpdatedFdtBase, &NewFdtBase);\r
    if (EFI_ERROR (Status)) {\r
      goto Fdt_Exit;\r
    }\r
\r
    Status = gBS->InstallConfigurationTable (\r
                    &gFdtTableGuid,\r
                    (VOID *)(UINTN)NewFdtBase\r
                    );\r
  }\r
\r
  if (!EFI_ERROR (Status)) {\r
    return EFI_SUCCESS;\r
  }\r
\r
Fdt_Exit:\r
  gBS->FreePages (UpdatedFdtBase, EFI_SIZE_TO_PAGES (NewFdtSize));\r
  return Status;\r
}\r
\r
EFI_STATUS\r
AndroidBootImgBoot (\r
  IN VOID                            *Buffer,\r
  IN UINTN                            BufferSize\r
  )\r
{\r
  EFI_STATUS                          Status;\r
  VOID                               *Kernel;\r
  UINTN                               KernelSize;\r
  MEMORY_DEVICE_PATH                  KernelDevicePath;\r
  EFI_HANDLE                          ImageHandle;\r
  VOID                               *NewKernelArg;\r
  EFI_LOADED_IMAGE_PROTOCOL          *ImageInfo;\r
  VOID                               *RamdiskData;\r
  UINTN                               RamdiskSize;\r
  IN  VOID                           *FdtBase;\r
\r
  Status = gBS->LocateProtocol (&gAndroidBootImgProtocolGuid, NULL,\r
                                (VOID **) &mAndroidBootImg);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  Status = AndroidBootImgGetKernelInfo (\r
            Buffer,\r
            &Kernel,\r
            &KernelSize\r
            );\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  NewKernelArg = AllocateZeroPool (ANDROID_BOOTIMG_KERNEL_ARGS_SIZE);\r
  if (NewKernelArg == NULL) {\r
    DEBUG ((DEBUG_ERROR, "Fail to allocate memory\n"));\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  Status = AndroidBootImgUpdateArgs (Buffer, NewKernelArg);\r
  if (EFI_ERROR (Status)) {\r
    FreePool (NewKernelArg);\r
    return Status;\r
  }\r
\r
  Status = AndroidBootImgGetRamdiskInfo (\r
            Buffer,\r
            &RamdiskData,\r
            &RamdiskSize\r
            );\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  Status = AndroidBootImgLocateFdt (Buffer, &FdtBase);\r
  if (EFI_ERROR (Status)) {\r
    FreePool (NewKernelArg);\r
    return Status;\r
  }\r
\r
  Status = AndroidBootImgUpdateFdt (Buffer, FdtBase, RamdiskData, RamdiskSize);\r
  if (EFI_ERROR (Status)) {\r
    FreePool (NewKernelArg);\r
    return Status;\r
  }\r
\r
  KernelDevicePath = mMemoryDevicePathTemplate;\r
\r
  KernelDevicePath.Node1.StartingAddress = (EFI_PHYSICAL_ADDRESS)(UINTN) Kernel;\r
  KernelDevicePath.Node1.EndingAddress   = (EFI_PHYSICAL_ADDRESS)(UINTN) Kernel\r
                                           + KernelSize;\r
\r
  Status = gBS->LoadImage (TRUE, gImageHandle,\r
                           (EFI_DEVICE_PATH *)&KernelDevicePath,\r
                           (VOID*)(UINTN)Kernel, KernelSize, &ImageHandle);\r
  if (EFI_ERROR (Status)) {\r
    //\r
    // With EFI_SECURITY_VIOLATION retval, the Image was loaded and an ImageHandle was created\r
    // with a valid EFI_LOADED_IMAGE_PROTOCOL, but the image can not be started right now.\r
    // If the caller doesn't have the option to defer the execution of an image, we should\r
    // unload image for the EFI_SECURITY_VIOLATION to avoid resource leak.\r
    //\r
    if (Status == EFI_SECURITY_VIOLATION) {\r
      gBS->UnloadImage (ImageHandle);\r
    }\r
    return Status;\r
  }\r
\r
  // Set kernel arguments\r
  Status = gBS->HandleProtocol (ImageHandle, &gEfiLoadedImageProtocolGuid,\r
                                (VOID **) &ImageInfo);\r
  ImageInfo->LoadOptions = NewKernelArg;\r
  ImageInfo->LoadOptionsSize = StrLen (NewKernelArg) * sizeof (CHAR16);\r
\r
  // Before calling the image, enable the Watchdog Timer for  the 5 Minute period\r
  gBS->SetWatchdogTimer (5 * 60, 0x10000, 0, NULL);\r
  // Start the image\r
  Status = gBS->StartImage (ImageHandle, NULL, NULL);\r
  // Clear the Watchdog Timer if the image returns\r
  gBS->SetWatchdogTimer (0, 0x10000, 0, NULL);\r
  return EFI_SUCCESS;\r
}\r
Commit	Line	Data
fa74dd22 JN	1	/** @file\r
	2	\r
	3	Copyright (c) 2013-2014, ARM Ltd. All rights reserved.<BR>\r
	4	Copyright (c) 2017, Linaro. All rights reserved.\r
	5	\r
878b807a	6	SPDX-License-Identifier: BSD-2-Clause-Patent\r
fa74dd22 JN	7	\r
	8	**/\r
	9	\r
	10	#include <libfdt.h>\r
	11	#include <Library/AndroidBootImgLib.h>\r
	12	#include <Library/PrintLib.h>\r
	13	#include <Library/UefiBootServicesTableLib.h>\r
	14	#include <Library/UefiLib.h>\r
	15	\r
	16	#include <Protocol/AndroidBootImg.h>\r
	17	#include <Protocol/LoadedImage.h>\r
	18	\r
fa74dd22 JN	19	#define FDT_ADDITIONAL_ENTRIES_SIZE 0x400\r
	20	\r
	21	typedef struct {\r
	22	MEMMAP_DEVICE_PATH Node1;\r
	23	EFI_DEVICE_PATH_PROTOCOL End;\r
	24	} MEMORY_DEVICE_PATH;\r
	25	\r
	26	STATIC ANDROID_BOOTIMG_PROTOCOL *mAndroidBootImg;\r
	27	\r
	28	STATIC CONST MEMORY_DEVICE_PATH mMemoryDevicePathTemplate =\r
	29	{\r
	30	{\r
	31	{\r
	32	HARDWARE_DEVICE_PATH,\r
	33	HW_MEMMAP_DP,\r
	34	{\r
	35	(UINT8)(sizeof (MEMMAP_DEVICE_PATH)),\r
	36	(UINT8)((sizeof (MEMMAP_DEVICE_PATH)) >> 8),\r
	37	},\r
	38	}, // Header\r
	39	0, // StartingAddress (set at runtime)\r
	40	0 // EndingAddress (set at runtime)\r
	41	}, // Node1\r
	42	{\r
	43	END_DEVICE_PATH_TYPE,\r
	44	END_ENTIRE_DEVICE_PATH_SUBTYPE,\r
	45	{ sizeof (EFI_DEVICE_PATH_PROTOCOL), 0 }\r
	46	} // End\r
	47	};\r
	48	\r
	49	EFI_STATUS\r
	50	AndroidBootImgGetImgSize (\r
	51	IN VOID *BootImg,\r
	52	OUT UINTN *ImgSize\r
	53	)\r
	54	{\r
	55	ANDROID_BOOTIMG_HEADER *Header;\r
	56	\r
	57	Header = (ANDROID_BOOTIMG_HEADER *) BootImg;\r
	58	\r
	59	if (AsciiStrnCmp ((CONST CHAR8 *)Header->BootMagic, ANDROID_BOOT_MAGIC,\r
	60	ANDROID_BOOT_MAGIC_LENGTH) != 0) {\r
	61	return EFI_INVALID_PARAMETER;\r
	62	}\r
	63	\r
	64	/* The page size is not specified, but it should be power of 2 at least */\r
	65	ASSERT (IS_VALID_ANDROID_PAGE_SIZE (Header->PageSize));\r
	66	\r
	67	/* Get real size of abootimg */\r
	68	*ImgSize = ALIGN_VALUE (Header->KernelSize, Header->PageSize) +\r
	69	ALIGN_VALUE (Header->RamdiskSize, Header->PageSize) +\r
	70	ALIGN_VALUE (Header->SecondStageBootloaderSize, Header->PageSize) +\r
	71	Header->PageSize;\r
	72	return EFI_SUCCESS;\r
	73	}\r
	74	\r
	75	EFI_STATUS\r
	76	AndroidBootImgGetKernelInfo (\r
	77	IN VOID *BootImg,\r
	78	OUT VOID **Kernel,\r
	79	OUT UINTN *KernelSize\r
	80	)\r
	81	{\r
	82	ANDROID_BOOTIMG_HEADER *Header;\r
83	\r
84	Header = (ANDROID_BOOTIMG_HEADER *) BootImg;\r
85	\r
86	if (AsciiStrnCmp ((CONST CHAR8 *)Header->BootMagic, ANDROID_BOOT_MAGIC,\r
87	ANDROID_BOOT_MAGIC_LENGTH) != 0) {\r
88	return EFI_INVALID_PARAMETER;\r
89	}\r
90	\r
91	if (Header->KernelSize == 0) {\r
92	return EFI_NOT_FOUND;\r
93	}\r
94	\r
95	ASSERT (IS_VALID_ANDROID_PAGE_SIZE (Header->PageSize));\r
96	\r
97	*KernelSize = Header->KernelSize;\r
e43d0884	98	Kernel = (VOID )((UINTN)BootImg + Header->PageSize);\r
fa74dd22 JN	99	return EFI_SUCCESS;\r
	100	}\r
	101	\r
	102	EFI_STATUS\r
	103	AndroidBootImgGetRamdiskInfo (\r
	104	IN VOID *BootImg,\r
	105	OUT VOID **Ramdisk,\r
	106	OUT UINTN *RamdiskSize\r
	107	)\r
	108	{\r
	109	ANDROID_BOOTIMG_HEADER *Header;\r
	110	\r
	111	Header = (ANDROID_BOOTIMG_HEADER *)BootImg;\r
	112	\r
	113	if (AsciiStrnCmp ((CONST CHAR8 *)Header->BootMagic, ANDROID_BOOT_MAGIC,\r
	114	ANDROID_BOOT_MAGIC_LENGTH) != 0) {\r
	115	return EFI_INVALID_PARAMETER;\r
	116	}\r
	117	\r
	118	ASSERT (IS_VALID_ANDROID_PAGE_SIZE (Header->PageSize));\r
	119	\r
	120	*RamdiskSize = Header->RamdiskSize;\r
	121	\r
	122	if (Header->RamdiskSize != 0) {\r
	123	Ramdisk = (VOID )((INTN)BootImg\r
	124	+ Header->PageSize\r
	125	+ ALIGN_VALUE (Header->KernelSize, Header->PageSize));\r
	126	}\r
	127	return EFI_SUCCESS;\r
	128	}\r
	129	\r
	130	EFI_STATUS\r
	131	AndroidBootImgGetSecondBootLoaderInfo (\r
	132	IN VOID *BootImg,\r
	133	OUT VOID **Second,\r
	134	OUT UINTN *SecondSize\r
	135	)\r
	136	{\r
	137	ANDROID_BOOTIMG_HEADER *Header;\r
	138	\r
	139	Header = (ANDROID_BOOTIMG_HEADER *)BootImg;\r
	140	\r
	141	if (AsciiStrnCmp ((CONST CHAR8 *)Header->BootMagic, ANDROID_BOOT_MAGIC,\r
	142	ANDROID_BOOT_MAGIC_LENGTH) != 0) {\r
	143	return EFI_INVALID_PARAMETER;\r
	144	}\r
	145	\r
	146	ASSERT (IS_VALID_ANDROID_PAGE_SIZE (Header->PageSize));\r
	147	\r
	148	*SecondSize = Header->SecondStageBootloaderSize;\r
	149	\r
	150	if (Header->SecondStageBootloaderSize != 0) {\r
	151	Second = (VOID )((UINTN)BootImg\r
	152	+ Header->PageSize\r
	153	+ ALIGN_VALUE (Header->KernelSize, Header->PageSize)\r
	154	+ ALIGN_VALUE (Header->RamdiskSize, Header->PageSize));\r
	155	}\r
	156	return EFI_SUCCESS;\r
	157	}\r
	158	\r
	159	EFI_STATUS\r
	160	AndroidBootImgGetKernelArgs (\r
	161	IN VOID *BootImg,\r
	162	OUT CHAR8 *KernelArgs\r
163	)\r
164	{\r
165	ANDROID_BOOTIMG_HEADER *Header;\r
166	\r
167	Header = (ANDROID_BOOTIMG_HEADER *) BootImg;\r
168	AsciiStrnCpyS (KernelArgs, ANDROID_BOOTIMG_KERNEL_ARGS_SIZE, Header->KernelArgs,\r
169	ANDROID_BOOTIMG_KERNEL_ARGS_SIZE);\r
170	\r
171	return EFI_SUCCESS;\r
172	}\r
173	\r
174	EFI_STATUS\r
175	AndroidBootImgGetFdt (\r
176	IN VOID *BootImg,\r
177	IN VOID **FdtBase\r
178	)\r
179	{\r
180	UINTN SecondLoaderSize;\r
181	EFI_STATUS Status;\r
182	\r
183	/* Check whether FDT is located in second boot region as some vendor do so,\r
184	* because second loader is never used as far as I know. */\r
185	Status = AndroidBootImgGetSecondBootLoaderInfo (\r
186	BootImg,\r
187	FdtBase,\r
188	&SecondLoaderSize\r
189	);\r
190	return Status;\r
191	}\r
192	\r
193	EFI_STATUS\r
194	AndroidBootImgUpdateArgs (\r
195	IN VOID *BootImg,\r
196	OUT VOID *KernelArgs\r
197	)\r
198	{\r
199	CHAR8 ImageKernelArgs[ANDROID_BOOTIMG_KERNEL_ARGS_SIZE];\r
200	EFI_STATUS Status;\r
201	\r
202	// Get kernel arguments from Android boot image\r
203	Status = AndroidBootImgGetKernelArgs (BootImg, ImageKernelArgs);\r
204	if (EFI_ERROR (Status)) {\r
205	return Status;\r
206	}\r
207	AsciiStrToUnicodeStrS (ImageKernelArgs, KernelArgs,\r
208	ANDROID_BOOTIMG_KERNEL_ARGS_SIZE >> 1);\r
209	// Append platform kernel arguments\r
210	if(mAndroidBootImg->AppendArgs) {\r
211	Status = mAndroidBootImg->AppendArgs (KernelArgs,\r
212	ANDROID_BOOTIMG_KERNEL_ARGS_SIZE);\r
213	}\r
214	return Status;\r
215	}\r
216	\r
217	EFI_STATUS\r
218	AndroidBootImgLocateFdt (\r
219	IN VOID *BootImg,\r
220	IN VOID **FdtBase\r
221	)\r
222	{\r
223	INTN Err;\r
224	EFI_STATUS Status;\r
225	\r
226	Status = EfiGetSystemConfigurationTable (&gFdtTableGuid, FdtBase);\r
227	if (!EFI_ERROR (Status)) {\r
228	return EFI_SUCCESS;\r
229	}\r
230	\r
231	Status = AndroidBootImgGetFdt (BootImg, FdtBase);\r
232	if (EFI_ERROR (Status)) {\r
233	return Status;\r
234	}\r
235	Err = fdt_check_header (*FdtBase);\r
236	if (Err != 0) {\r
237	DEBUG ((DEBUG_ERROR, "ERROR: Device Tree header not valid (Err:%d)\n",\r
238	Err));\r
239	return EFI_INVALID_PARAMETER;\r
240	}\r
241	return EFI_SUCCESS;\r
242	}\r
243	\r
244	INTN\r
245	AndroidBootImgGetChosenNode (\r
246	IN INTN UpdatedFdtBase\r
247	)\r
248	{\r
249	INTN ChosenNode;\r
250	\r
251	ChosenNode = fdt_subnode_offset ((CONST VOID *)UpdatedFdtBase, 0, "chosen");\r
252	if (ChosenNode < 0) {\r
253	ChosenNode = fdt_add_subnode((VOID *)UpdatedFdtBase, 0, "chosen");\r
254	if (ChosenNode < 0) {\r
255	DEBUG ((DEBUG_ERROR, "Fail to find fdt node chosen!\n"));\r
256	return 0;\r
257	}\r
258	}\r
259	return ChosenNode;\r
260	}\r
261	\r
262	EFI_STATUS\r
263	AndroidBootImgSetProperty64 (\r
264	IN INTN UpdatedFdtBase,\r
265	IN INTN ChosenNode,\r
266	IN CHAR8 *PropertyName,\r
267	IN UINT64 Val\r
268	)\r
269	{\r
270	INTN Err;\r
271	struct fdt_property *Property;\r
272	int Len;\r
273	\r
274	Property = fdt_get_property_w((VOID *)UpdatedFdtBase, ChosenNode,\r
275	PropertyName, &Len);\r
276	if (NULL == Property && Len == -FDT_ERR_NOTFOUND) {\r
277	Val = cpu_to_fdt64(Val);\r
278	Err = fdt_appendprop ((VOID *)UpdatedFdtBase, ChosenNode,\r
279	PropertyName, &Val, sizeof (UINT64));\r
280	if (Err) {\r
281	DEBUG ((DEBUG_ERROR, "fdt_appendprop() fail: %a\n", fdt_strerror (Err)));\r
282	return EFI_INVALID_PARAMETER;\r
283	}\r
284	} else if (Property != NULL) {\r
285	Err = fdt_setprop_u64((VOID *)UpdatedFdtBase, ChosenNode,\r
286	PropertyName, Val);\r
287	if (Err) {\r
288	DEBUG ((DEBUG_ERROR, "fdt_setprop_u64() fail: %a\n", fdt_strerror (Err)));\r
289	return EFI_INVALID_PARAMETER;\r
290	}\r
291	} else {\r
292	DEBUG ((DEBUG_ERROR, "Failed to set fdt Property %a\n", PropertyName));\r
293	return EFI_INVALID_PARAMETER;\r
294	}\r
295	return EFI_SUCCESS;\r
296	}\r
297	\r
298	EFI_STATUS\r
299	AndroidBootImgUpdateFdt (\r
300	IN VOID *BootImg,\r
301	IN VOID *FdtBase,\r
302	IN VOID *RamdiskData,\r
303	IN UINTN RamdiskSize\r
304	)\r
305	{\r
306	INTN ChosenNode, Err, NewFdtSize;\r
307	EFI_STATUS Status;\r
308	EFI_PHYSICAL_ADDRESS UpdatedFdtBase, NewFdtBase;\r
309	\r
310	NewFdtSize = (UINTN)fdt_totalsize (FdtBase)\r
311	+ FDT_ADDITIONAL_ENTRIES_SIZE;\r
312	Status = gBS->AllocatePages (AllocateAnyPages, EfiBootServicesData,\r
313	EFI_SIZE_TO_PAGES (NewFdtSize), &UpdatedFdtBase);\r
314	if (EFI_ERROR (Status)) {\r
315	DEBUG ((DEBUG_WARN, "Warning: Failed to reallocate FDT, err %d.\n",\r
316	Status));\r
317	return Status;\r
318	}\r
319	\r
320	// Load the Original FDT tree into the new region\r
321	Err = fdt_open_into(FdtBase, (VOID*)(INTN)UpdatedFdtBase, NewFdtSize);\r
322	if (Err) {\r
323	DEBUG ((DEBUG_ERROR, "fdt_open_into(): %a\n", fdt_strerror (Err)));\r
324	Status = EFI_INVALID_PARAMETER;\r
325	goto Fdt_Exit;\r
326	}\r
327	\r
328	ChosenNode = AndroidBootImgGetChosenNode(UpdatedFdtBase);\r
329	if (!ChosenNode) {\r
330	goto Fdt_Exit;\r
331	}\r
332	\r
333	Status = AndroidBootImgSetProperty64 (UpdatedFdtBase, ChosenNode,\r
334	"linux,initrd-start",\r
335	(UINTN)RamdiskData);\r
336	if (EFI_ERROR (Status)) {\r
337	goto Fdt_Exit;\r
338	}\r
339	\r
340	Status = AndroidBootImgSetProperty64 (UpdatedFdtBase, ChosenNode,\r
341	"linux,initrd-end",\r
e43d0884	342	(UINTN)RamdiskData + RamdiskSize);\r
fa74dd22 JN	343	if (EFI_ERROR (Status)) {\r
	344	goto Fdt_Exit;\r
	345	}\r
	346	\r
	347	if (mAndroidBootImg->UpdateDtb) {\r
	348	Status = mAndroidBootImg->UpdateDtb (UpdatedFdtBase, &NewFdtBase);\r
	349	if (EFI_ERROR (Status)) {\r
	350	goto Fdt_Exit;\r
	351	}\r
ac811846 LL	352	\r
	353	Status = gBS->InstallConfigurationTable (\r
	354	&gFdtTableGuid,\r
	355	(VOID *)(UINTN)NewFdtBase\r
	356	);\r
fa74dd22 JN	357	}\r
fa74dd22 JN	358	\r
fa74dd22 JN	359	if (!EFI_ERROR (Status)) {\r
	360	return EFI_SUCCESS;\r
	361	}\r
	362	\r
	363	Fdt_Exit:\r
	364	gBS->FreePages (UpdatedFdtBase, EFI_SIZE_TO_PAGES (NewFdtSize));\r
	365	return Status;\r
	366	}\r
	367	\r
	368	EFI_STATUS\r
	369	AndroidBootImgBoot (\r
	370	IN VOID *Buffer,\r
	371	IN UINTN BufferSize\r
	372	)\r
	373	{\r
	374	EFI_STATUS Status;\r
	375	VOID *Kernel;\r
	376	UINTN KernelSize;\r
	377	MEMORY_DEVICE_PATH KernelDevicePath;\r
	378	EFI_HANDLE ImageHandle;\r
	379	VOID *NewKernelArg;\r
	380	EFI_LOADED_IMAGE_PROTOCOL *ImageInfo;\r
	381	VOID *RamdiskData;\r
	382	UINTN RamdiskSize;\r
	383	IN VOID *FdtBase;\r
	384	\r
	385	Status = gBS->LocateProtocol (&gAndroidBootImgProtocolGuid, NULL,\r
	386	(VOID **) &mAndroidBootImg);\r
	387	if (EFI_ERROR (Status)) {\r
	388	return Status;\r
	389	}\r
	390	\r
	391	Status = AndroidBootImgGetKernelInfo (\r
	392	Buffer,\r
	393	&Kernel,\r
	394	&KernelSize\r
	395	);\r
	396	if (EFI_ERROR (Status)) {\r
	397	return Status;\r
	398	}\r
	399	\r
	400	NewKernelArg = AllocateZeroPool (ANDROID_BOOTIMG_KERNEL_ARGS_SIZE);\r
	401	if (NewKernelArg == NULL) {\r
	402	DEBUG ((DEBUG_ERROR, "Fail to allocate memory\n"));\r
	403	return EFI_OUT_OF_RESOURCES;\r
	404	}\r
	405	\r
	406	Status = AndroidBootImgUpdateArgs (Buffer, NewKernelArg);\r
	407	if (EFI_ERROR (Status)) {\r
	408	FreePool (NewKernelArg);\r
	409	return Status;\r
	410	}\r
	411	\r
	412	Status = AndroidBootImgGetRamdiskInfo (\r
	413	Buffer,\r
	414	&RamdiskData,\r
	415	&RamdiskSize\r
	416	);\r
	417	if (EFI_ERROR (Status)) {\r
	418	return Status;\r
	419	}\r
	420	\r
	421	Status = AndroidBootImgLocateFdt (Buffer, &FdtBase);\r
	422	if (EFI_ERROR (Status)) {\r
423	FreePool (NewKernelArg);\r
424	return Status;\r
425	}\r
426	\r
427	Status = AndroidBootImgUpdateFdt (Buffer, FdtBase, RamdiskData, RamdiskSize);\r
428	if (EFI_ERROR (Status)) {\r
429	FreePool (NewKernelArg);\r
430	return Status;\r
431	}\r
432	\r
433	KernelDevicePath = mMemoryDevicePathTemplate;\r
434	\r
435	KernelDevicePath.Node1.StartingAddress = (EFI_PHYSICAL_ADDRESS)(UINTN) Kernel;\r
436	KernelDevicePath.Node1.EndingAddress = (EFI_PHYSICAL_ADDRESS)(UINTN) Kernel\r
437	+ KernelSize;\r
438	\r
439	Status = gBS->LoadImage (TRUE, gImageHandle,\r
440	(EFI_DEVICE_PATH *)&KernelDevicePath,\r
441	(VOID*)(UINTN)Kernel, KernelSize, &ImageHandle);\r
82e0c422 DB	442	if (EFI_ERROR (Status)) {\r
	443	//\r
	444	// With EFI_SECURITY_VIOLATION retval, the Image was loaded and an ImageHandle was created\r
	445	// with a valid EFI_LOADED_IMAGE_PROTOCOL, but the image can not be started right now.\r
	446	// If the caller doesn't have the option to defer the execution of an image, we should\r
	447	// unload image for the EFI_SECURITY_VIOLATION to avoid resource leak.\r
	448	//\r
	449	if (Status == EFI_SECURITY_VIOLATION) {\r
	450	gBS->UnloadImage (ImageHandle);\r
	451	}\r
	452	return Status;\r
	453	}\r
fa74dd22 JN	454	\r
	455	// Set kernel arguments\r
	456	Status = gBS->HandleProtocol (ImageHandle, &gEfiLoadedImageProtocolGuid,\r
	457	(VOID **) &ImageInfo);\r
	458	ImageInfo->LoadOptions = NewKernelArg;\r
	459	ImageInfo->LoadOptionsSize = StrLen (NewKernelArg) * sizeof (CHAR16);\r
	460	\r
	461	// Before calling the image, enable the Watchdog Timer for the 5 Minute period\r
	462	gBS->SetWatchdogTimer (5 * 60, 0x10000, 0, NULL);\r
	463	// Start the image\r
	464	Status = gBS->StartImage (ImageHandle, NULL, NULL);\r
	465	// Clear the Watchdog Timer if the image returns\r
	466	gBS->SetWatchdogTimer (0, 0x10000, 0, NULL);\r
	467	return EFI_SUCCESS;\r
	468	}\r