tyler.durden
/
audk
mirror of https://github.com/acidanthera/audk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

EmbeddedPkg/AndroidBoot: boot android kernel from storage 

Add an android kernel loader that could load kernel from storage
device.
This android boot image BDS add addtitional cmdline/dtb/ramfs
support besides kernel that is introduced by Android boot header.

This patch is derived from Haojian's code as below link.
https://patches.linaro.org/patch/94683/

Contributed-under: TianoCore Contribution Agreement 1.0
Signed-off-by: Jun Nie <jun.nie@linaro.org>
Reviewed-by: Leif Lindholm <leif.lindholm@linaro.org>
This commit is contained in:
Jun Nie 2017-08-17 20:58:59 +08:00 committed by Leif Lindholm
parent ce13d2d8c8
commit fa74dd2217
8 changed files with 779 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

140
EmbeddedPkg/Application/AndroidBoot/AndroidBootApp.c Normal file
View File

@ -0,0 +1,140 @@
/** @file
Copyright (c) 2013-2014, ARM Ltd. All rights reserved.<BR>
Copyright (c) 2017, Linaro. All rights reserved.
This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#include <Library/AndroidBootImgLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/BdsLib.h>
#include <Library/DebugLib.h>
#include <Library/DevicePathLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Protocol/BlockIo.h>
#include <Protocol/DevicePathFromText.h>
/* Validate the node is media hard drive type */
EFI_STATUS
ValidateAndroidMediaDevicePath (
IN EFI_DEVICE_PATH *DevicePath
)
{
EFI_DEVICE_PATH_PROTOCOL *Node, *NextNode;
NextNode = DevicePath;
while (NextNode != NULL) {
Node = NextNode;
if (IS_DEVICE_PATH_NODE (Node, MEDIA_DEVICE_PATH, MEDIA_HARDDRIVE_DP)) {
return EFI_SUCCESS;
}
NextNode = NextDevicePathNode (Node);
}
return EFI_INVALID_PARAMETER;
}
EFI_STATUS
EFIAPI
AndroidBootAppEntryPoint (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
{
EFI_STATUS Status;
CHAR16 *BootPathStr;
EFI_DEVICE_PATH_FROM_TEXT_PROTOCOL *EfiDevicePathFromTextProtocol;
EFI_DEVICE_PATH *DevicePath;
EFI_BLOCK_IO_PROTOCOL *BlockIo;
UINT32 MediaId, BlockSize;
VOID *Buffer;
EFI_HANDLE Handle;
UINTN BootImgSize;
BootPathStr = (CHAR16 *)PcdGetPtr (PcdAndroidBootDevicePath);
ASSERT (BootPathStr != NULL);
Status = gBS->LocateProtocol (&gEfiDevicePathFromTextProtocolGuid, NULL,
(VOID **)&EfiDevicePathFromTextProtocol);
ASSERT_EFI_ERROR(Status);
DevicePath = (EFI_DEVICE_PATH *)EfiDevicePathFromTextProtocol->ConvertTextToDevicePath (BootPathStr);
ASSERT (DevicePath != NULL);
Status = ValidateAndroidMediaDevicePath (DevicePath);
if (EFI_ERROR (Status)) {
return Status;
}
Status = gBS->LocateDevicePath (&gEfiDevicePathProtocolGuid,
&DevicePath, &Handle);
if (EFI_ERROR (Status)) {
return Status;
}
Status = gBS->OpenProtocol (
Handle,
&gEfiBlockIoProtocolGuid,
(VOID **) &BlockIo,
gImageHandle,
NULL,
EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_ERROR, "Failed to get BlockIo: %r\n", Status));
return Status;
}
MediaId = BlockIo->Media->MediaId;
BlockSize = BlockIo->Media->BlockSize;
Buffer = AllocatePages (EFI_SIZE_TO_PAGES (sizeof(ANDROID_BOOTIMG_HEADER)));
if (Buffer == NULL) {
return EFI_BUFFER_TOO_SMALL;
}
/* Load header of boot.img */
Status = BlockIo->ReadBlocks (
BlockIo,
MediaId,
0,
BlockSize,
Buffer
);
Status = AndroidBootImgGetImgSize (Buffer, &BootImgSize);
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_ERROR, "Failed to get AndroidBootImg Size: %r\n", Status));
return Status;
}
BootImgSize = ALIGN_VALUE (BootImgSize, BlockSize);
FreePages (Buffer, EFI_SIZE_TO_PAGES (sizeof(ANDROID_BOOTIMG_HEADER)));
/* Both PartitionStart and PartitionSize are counted as block size. */
Buffer = AllocatePages (EFI_SIZE_TO_PAGES (BootImgSize));
if (Buffer == NULL) {
return EFI_BUFFER_TOO_SMALL;
}
/* Load header of boot.img */
Status = BlockIo->ReadBlocks (
BlockIo,
MediaId,
0,
BootImgSize,
Buffer
);
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_ERROR, "Failed to read blocks: %r\n", Status));
goto EXIT;
}
Status = AndroidBootImgBoot (Buffer, BootImgSize);
EXIT:
return Status;
}

64
EmbeddedPkg/Application/AndroidBoot/AndroidBootApp.inf Normal file
View File

@ -0,0 +1,64 @@
#/** @file
#
# Copyright (c) 2013-2015, ARM Ltd. All rights reserved.<BR>
# Copyright (c) 2017, Linaro. All rights reserved.
#
# This program and the accompanying materials
# are licensed and made available under the terms and conditions of the BSD License
# which accompanies this distribution. The full text of the license may be found at
# http://opensource.org/licenses/bsd-license.php
# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
#
#
#**/
[Defines]
INF_VERSION = 0x00010019
BASE_NAME = AndroidBootApp
FILE_GUID = 3a738b36-b9c5-4763-abbd-6cbd4b25f9ff
MODULE_TYPE = UEFI_APPLICATION
VERSION_STRING = 1.0
ENTRY_POINT = AndroidBootAppEntryPoint
[Sources.common]
AndroidBootApp.c
[LibraryClasses]
AndroidBootImgLib
BaseLib
BaseMemoryLib
BdsLib
DebugLib
DevicePathLib
DxeServicesTableLib
FdtLib
MemoryAllocationLib
PcdLib
PrintLib
UefiApplicationEntryPoint
UefiBootServicesTableLib
UefiLib
UefiRuntimeServicesTableLib
[Protocols]
gAndroidFastbootPlatformProtocolGuid
gEfiBlockIoProtocolGuid
gEfiDevicePathFromTextProtocolGuid
gEfiSimpleTextOutProtocolGuid
gEfiSimpleTextInProtocolGuid
[Packages]
EmbeddedPkg/EmbeddedPkg.dec
MdeModulePkg/MdeModulePkg.dec
MdePkg/MdePkg.dec
[Packages.ARM, Packages.AARCH64]
ArmPkg/ArmPkg.dec
ArmPlatformPkg/ArmPlatformPkg.dec
[Guids]
gFdtTableGuid
[Pcd]
gEmbeddedTokenSpaceGuid.PcdAndroidBootDevicePath

2
EmbeddedPkg/EmbeddedPkg.dec
View File

@ -80,6 +80,7 @@
gAndroidFastbootPlatformProtocolGuid = { 0x524685a0, 0x89a0, 0x11e3, {0x9d, 0x4d, 0xbf, 0xa9, 0xf6, 0xa4, 0x03, 0x08}} gAndroidFastbootPlatformProtocolGuid = { 0x524685a0, 0x89a0, 0x11e3, {0x9d, 0x4d, 0xbf, 0xa9, 0xf6, 0xa4, 0x03, 0x08}}
gUsbDeviceProtocolGuid = { 0x021bd2ca, 0x51d2, 0x11e3, {0x8e, 0x56, 0xb7, 0x54, 0x17, 0xc7, 0x0b, 0x44 }} gUsbDeviceProtocolGuid = { 0x021bd2ca, 0x51d2, 0x11e3, {0x8e, 0x56, 0xb7, 0x54, 0x17, 0xc7, 0x0b, 0x44 }}
gPlatformGpioProtocolGuid = { 0x52ce9845, 0x5af4, 0x43e2, {0xba, 0xfd, 0x23, 0x08, 0x12, 0x54, 0x7a, 0xc2 }} gPlatformGpioProtocolGuid = { 0x52ce9845, 0x5af4, 0x43e2, {0xba, 0xfd, 0x23, 0x08, 0x12, 0x54, 0x7a, 0xc2 }}
gAndroidBootImgProtocolGuid = { 0x9859bb19, 0x407c, 0x4f8b, {0xbc, 0xe1, 0xf8, 0xda, 0x65, 0x65, 0xf4, 0xa5 }}
[PcdsFeatureFlag.common] [PcdsFeatureFlag.common]
gEmbeddedTokenSpaceGuid.PcdEmbeddedMacBoot|FALSE|BOOLEAN|0x00000001 gEmbeddedTokenSpaceGuid.PcdEmbeddedMacBoot|FALSE|BOOLEAN|0x00000001
@ -181,6 +182,7 @@
gEmbeddedTokenSpaceGuid.PcdAndroidFastbootUsbProductId|0xbeef|UINT32|0x00000023 gEmbeddedTokenSpaceGuid.PcdAndroidFastbootUsbProductId|0xbeef|UINT32|0x00000023
gEmbeddedTokenSpaceGuid.PcdAndroidFastbootTcpPort|1234|UINT32|0x00000024 gEmbeddedTokenSpaceGuid.PcdAndroidFastbootTcpPort|1234|UINT32|0x00000024
gEmbeddedTokenSpaceGuid.PcdAndroidBootDevicePath|L""|VOID*|0x00000057
[PcdsFixedAtBuild.ARM] [PcdsFixedAtBuild.ARM]
gEmbeddedTokenSpaceGuid.PcdPrePiCpuMemorySize|32|UINT8|0x00000010 gEmbeddedTokenSpaceGuid.PcdPrePiCpuMemorySize|32|UINT8|0x00000010

2
EmbeddedPkg/EmbeddedPkg.dsc
View File

@ -52,6 +52,7 @@
DebugLib|MdePkg/Library/BaseDebugLibNull/BaseDebugLibNull.inf DebugLib|MdePkg/Library/BaseDebugLibNull/BaseDebugLibNull.inf
AndroidBootImgLib|EmbeddedPkg/Library/AndroidBootImgLib/AndroidBootImgLib.inf
BaseLib|MdePkg/Library/BaseLib/BaseLib.inf BaseLib|MdePkg/Library/BaseLib/BaseLib.inf
BaseMemoryLib|MdePkg/Library/BaseMemoryLib/BaseMemoryLib.inf BaseMemoryLib|MdePkg/Library/BaseMemoryLib/BaseMemoryLib.inf
PciLib|MdePkg/Library/BasePciLibCf8/BasePciLibCf8.inf PciLib|MdePkg/Library/BasePciLibCf8/BasePciLibCf8.inf
@ -272,6 +273,7 @@
TimerLib|MdePkg/Library/BaseTimerLibNullTemplate/BaseTimerLibNullTemplate.inf TimerLib|MdePkg/Library/BaseTimerLibNullTemplate/BaseTimerLibNullTemplate.inf
} }
EmbeddedPkg/Application/AndroidBoot/AndroidBootApp.inf
EmbeddedPkg/Application/AndroidFastboot/AndroidFastbootApp.inf { EmbeddedPkg/Application/AndroidFastboot/AndroidFastbootApp.inf {
<LibraryClasses> <LibraryClasses>
# It depends on BdsLib that depends on TimerLib # It depends on BdsLib that depends on TimerLib

13
EmbeddedPkg/Include/Library/AndroidBootImgLib.h
View File

@ -55,4 +55,17 @@ typedef struct {
* and larger than boot header */ * and larger than boot header */
#define IS_VALID_ANDROID_PAGE_SIZE(Val) \ #define IS_VALID_ANDROID_PAGE_SIZE(Val) \
(IS_POWER_OF_2(Val) && (Val > sizeof(ANDROID_BOOTIMG_HEADER))) (IS_POWER_OF_2(Val) && (Val > sizeof(ANDROID_BOOTIMG_HEADER)))
EFI_STATUS
AndroidBootImgGetImgSize (
IN VOID *BootImg,
OUT UINTN *ImgSize
);
EFI_STATUS
AndroidBootImgBoot (
IN VOID *Buffer,
IN UINTN BufferSize
);
#endif /* __ABOOTIMG_H__ */ #endif /* __ABOOTIMG_H__ */

47
EmbeddedPkg/Include/Protocol/AndroidBootImg.h Normal file
View File

@ -0,0 +1,47 @@
/** @file
Copyright (c) 2017, Linaro. All rights reserved.<BR>
This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#ifndef __ANDROID_BOOTIMG_PROTOCOL_H__
#define __ANDROID_BOOTIMG_PROTOCOL_H__
//
// Protocol interface structure
//
typedef struct _ANDROID_BOOTIMG_PROTOCOL ANDROID_BOOTIMG_PROTOCOL;
//
// Function Prototypes
//
typedef
EFI_STATUS
(EFIAPI *ANDROID_BOOTIMG_APPEND_KERNEL_ARGS) (
IN CHAR16 *Args,
IN UINTN Size
);
typedef
EFI_STATUS
(EFIAPI *ANDROID_BOOTIMG_UPDATE_DTB) (
IN EFI_PHYSICAL_ADDRESS OrigDtbBase;
OUT EFI_PHYSICAL_ADDRESS *NewDtbBase;
);
struct _ANDROID_BOOTIMG_PROTOCOL {
ANDROID_BOOTIMG_APPEND_KERNEL_ARGS AppendArgs;
ANDROID_BOOTIMG_UPDATE_DTB UpdateDtb;
};
extern EFI_GUID gAndroidBootImgProtocolGuid;
#endif /* __ANDROID_BOOTIMG_PROTOCOL_H__ */

463
EmbeddedPkg/Library/AndroidBootImgLib/AndroidBootImgLib.c Normal file
View File

@ -0,0 +1,463 @@
/** @file
Copyright (c) 2013-2014, ARM Ltd. All rights reserved.<BR>
Copyright (c) 2017, Linaro. All rights reserved.
This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#include <libfdt.h>
#include <Library/AndroidBootImgLib.h>
#include <Library/PrintLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/UefiLib.h>
#include <Protocol/AndroidBootImg.h>
#include <Protocol/LoadedImage.h>
#include <libfdt.h>
#define FDT_ADDITIONAL_ENTRIES_SIZE 0x400
typedef struct {
MEMMAP_DEVICE_PATH Node1;
EFI_DEVICE_PATH_PROTOCOL End;
} MEMORY_DEVICE_PATH;
STATIC ANDROID_BOOTIMG_PROTOCOL *mAndroidBootImg;
STATIC CONST MEMORY_DEVICE_PATH mMemoryDevicePathTemplate =
{
{
{
HARDWARE_DEVICE_PATH,
HW_MEMMAP_DP,
{
(UINT8)(sizeof (MEMMAP_DEVICE_PATH)),
(UINT8)((sizeof (MEMMAP_DEVICE_PATH)) >> 8),
},
}, // Header
0, // StartingAddress (set at runtime)
0 // EndingAddress (set at runtime)
}, // Node1
{
END_DEVICE_PATH_TYPE,
END_ENTIRE_DEVICE_PATH_SUBTYPE,
{ sizeof (EFI_DEVICE_PATH_PROTOCOL), 0 }
} // End
};
EFI_STATUS
AndroidBootImgGetImgSize (
IN VOID *BootImg,
OUT UINTN *ImgSize
)
{
ANDROID_BOOTIMG_HEADER *Header;
Header = (ANDROID_BOOTIMG_HEADER *) BootImg;
if (AsciiStrnCmp ((CONST CHAR8 *)Header->BootMagic, ANDROID_BOOT_MAGIC,
ANDROID_BOOT_MAGIC_LENGTH) != 0) {
return EFI_INVALID_PARAMETER;
}
/* The page size is not specified, but it should be power of 2 at least */
ASSERT (IS_VALID_ANDROID_PAGE_SIZE (Header->PageSize));
/* Get real size of abootimg */
*ImgSize = ALIGN_VALUE (Header->KernelSize, Header->PageSize) +
ALIGN_VALUE (Header->RamdiskSize, Header->PageSize) +
ALIGN_VALUE (Header->SecondStageBootloaderSize, Header->PageSize) +
Header->PageSize;
return EFI_SUCCESS;
}
EFI_STATUS
AndroidBootImgGetKernelInfo (
IN VOID *BootImg,
OUT VOID **Kernel,
OUT UINTN *KernelSize
)
{
ANDROID_BOOTIMG_HEADER *Header;
Header = (ANDROID_BOOTIMG_HEADER *) BootImg;
if (AsciiStrnCmp ((CONST CHAR8 *)Header->BootMagic, ANDROID_BOOT_MAGIC,
ANDROID_BOOT_MAGIC_LENGTH) != 0) {
return EFI_INVALID_PARAMETER;
}
if (Header->KernelSize == 0) {
return EFI_NOT_FOUND;
}
ASSERT (IS_VALID_ANDROID_PAGE_SIZE (Header->PageSize));
*KernelSize = Header->KernelSize;
*Kernel = BootImg + Header->PageSize;
return EFI_SUCCESS;
}
EFI_STATUS
AndroidBootImgGetRamdiskInfo (
IN VOID *BootImg,
OUT VOID **Ramdisk,
OUT UINTN *RamdiskSize
)
{
ANDROID_BOOTIMG_HEADER *Header;
Header = (ANDROID_BOOTIMG_HEADER *)BootImg;
if (AsciiStrnCmp ((CONST CHAR8 *)Header->BootMagic, ANDROID_BOOT_MAGIC,
ANDROID_BOOT_MAGIC_LENGTH) != 0) {
return EFI_INVALID_PARAMETER;
}
ASSERT (IS_VALID_ANDROID_PAGE_SIZE (Header->PageSize));
*RamdiskSize = Header->RamdiskSize;
if (Header->RamdiskSize != 0) {
*Ramdisk = (VOID *)((INTN)BootImg
+ Header->PageSize
+ ALIGN_VALUE (Header->KernelSize, Header->PageSize));
}
return EFI_SUCCESS;
}
EFI_STATUS
AndroidBootImgGetSecondBootLoaderInfo (
IN VOID *BootImg,
OUT VOID **Second,
OUT UINTN *SecondSize
)
{
ANDROID_BOOTIMG_HEADER *Header;
Header = (ANDROID_BOOTIMG_HEADER *)BootImg;
if (AsciiStrnCmp ((CONST CHAR8 *)Header->BootMagic, ANDROID_BOOT_MAGIC,
ANDROID_BOOT_MAGIC_LENGTH) != 0) {
return EFI_INVALID_PARAMETER;
}
ASSERT (IS_VALID_ANDROID_PAGE_SIZE (Header->PageSize));
*SecondSize = Header->SecondStageBootloaderSize;
if (Header->SecondStageBootloaderSize != 0) {
*Second = (VOID *)((UINTN)BootImg
+ Header->PageSize
+ ALIGN_VALUE (Header->KernelSize, Header->PageSize)
+ ALIGN_VALUE (Header->RamdiskSize, Header->PageSize));
}
return EFI_SUCCESS;
}
EFI_STATUS
AndroidBootImgGetKernelArgs (
IN VOID *BootImg,
OUT CHAR8 *KernelArgs
)
{
ANDROID_BOOTIMG_HEADER *Header;
Header = (ANDROID_BOOTIMG_HEADER *) BootImg;
AsciiStrnCpyS (KernelArgs, ANDROID_BOOTIMG_KERNEL_ARGS_SIZE, Header->KernelArgs,
ANDROID_BOOTIMG_KERNEL_ARGS_SIZE);
return EFI_SUCCESS;
}
EFI_STATUS
AndroidBootImgGetFdt (
IN VOID *BootImg,
IN VOID **FdtBase
)
{
UINTN SecondLoaderSize;
EFI_STATUS Status;
/* Check whether FDT is located in second boot region as some vendor do so,
* because second loader is never used as far as I know. */
Status = AndroidBootImgGetSecondBootLoaderInfo (
BootImg,
FdtBase,
&SecondLoaderSize
);
return Status;
}
EFI_STATUS
AndroidBootImgUpdateArgs (
IN VOID *BootImg,
OUT VOID *KernelArgs
)
{
CHAR8 ImageKernelArgs[ANDROID_BOOTIMG_KERNEL_ARGS_SIZE];
EFI_STATUS Status;
// Get kernel arguments from Android boot image
Status = AndroidBootImgGetKernelArgs (BootImg, ImageKernelArgs);
if (EFI_ERROR (Status)) {
return Status;
}
AsciiStrToUnicodeStrS (ImageKernelArgs, KernelArgs,
ANDROID_BOOTIMG_KERNEL_ARGS_SIZE >> 1);
// Append platform kernel arguments
if(mAndroidBootImg->AppendArgs) {
Status = mAndroidBootImg->AppendArgs (KernelArgs,
ANDROID_BOOTIMG_KERNEL_ARGS_SIZE);
}
return Status;
}
EFI_STATUS
AndroidBootImgLocateFdt (
IN VOID *BootImg,
IN VOID **FdtBase
)
{
INTN Err;
EFI_STATUS Status;
Status = EfiGetSystemConfigurationTable (&gFdtTableGuid, FdtBase);
if (!EFI_ERROR (Status)) {
return EFI_SUCCESS;
}
Status = AndroidBootImgGetFdt (BootImg, FdtBase);
if (EFI_ERROR (Status)) {
return Status;
}
Err = fdt_check_header (*FdtBase);
if (Err != 0) {
DEBUG ((DEBUG_ERROR, "ERROR: Device Tree header not valid (Err:%d)\n",
Err));
return EFI_INVALID_PARAMETER;
}
return EFI_SUCCESS;
}
INTN
AndroidBootImgGetChosenNode (
IN INTN UpdatedFdtBase
)
{
INTN ChosenNode;
ChosenNode = fdt_subnode_offset ((CONST VOID *)UpdatedFdtBase, 0, "chosen");
if (ChosenNode < 0) {
ChosenNode = fdt_add_subnode((VOID *)UpdatedFdtBase, 0, "chosen");
if (ChosenNode < 0) {
DEBUG ((DEBUG_ERROR, "Fail to find fdt node chosen!\n"));
return 0;
}
}
return ChosenNode;
}
EFI_STATUS
AndroidBootImgSetProperty64 (
IN INTN UpdatedFdtBase,
IN INTN ChosenNode,
IN CHAR8 *PropertyName,
IN UINT64 Val
)
{
INTN Err;
struct fdt_property *Property;
int Len;
Property = fdt_get_property_w((VOID *)UpdatedFdtBase, ChosenNode,
PropertyName, &Len);
if (NULL == Property && Len == -FDT_ERR_NOTFOUND) {
Val = cpu_to_fdt64(Val);
Err = fdt_appendprop ((VOID *)UpdatedFdtBase, ChosenNode,
PropertyName, &Val, sizeof (UINT64));
if (Err) {
DEBUG ((DEBUG_ERROR, "fdt_appendprop() fail: %a\n", fdt_strerror (Err)));
return EFI_INVALID_PARAMETER;
}
} else if (Property != NULL) {
Err = fdt_setprop_u64((VOID *)UpdatedFdtBase, ChosenNode,
PropertyName, Val);
if (Err) {
DEBUG ((DEBUG_ERROR, "fdt_setprop_u64() fail: %a\n", fdt_strerror (Err)));
return EFI_INVALID_PARAMETER;
}
} else {
DEBUG ((DEBUG_ERROR, "Failed to set fdt Property %a\n", PropertyName));
return EFI_INVALID_PARAMETER;
}
return EFI_SUCCESS;
}
EFI_STATUS
AndroidBootImgUpdateFdt (
IN VOID *BootImg,
IN VOID *FdtBase,
IN VOID *RamdiskData,
IN UINTN RamdiskSize
)
{
INTN ChosenNode, Err, NewFdtSize;
EFI_STATUS Status;
EFI_PHYSICAL_ADDRESS UpdatedFdtBase, NewFdtBase;
NewFdtSize = (UINTN)fdt_totalsize (FdtBase)
+ FDT_ADDITIONAL_ENTRIES_SIZE;
Status = gBS->AllocatePages (AllocateAnyPages, EfiBootServicesData,
EFI_SIZE_TO_PAGES (NewFdtSize), &UpdatedFdtBase);
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_WARN, "Warning: Failed to reallocate FDT, err %d.\n",
Status));
return Status;
}
// Load the Original FDT tree into the new region
Err = fdt_open_into(FdtBase, (VOID*)(INTN)UpdatedFdtBase, NewFdtSize);
if (Err) {
DEBUG ((DEBUG_ERROR, "fdt_open_into(): %a\n", fdt_strerror (Err)));
Status = EFI_INVALID_PARAMETER;
goto Fdt_Exit;
}
ChosenNode = AndroidBootImgGetChosenNode(UpdatedFdtBase);
if (!ChosenNode) {
goto Fdt_Exit;
}
Status = AndroidBootImgSetProperty64 (UpdatedFdtBase, ChosenNode,
"linux,initrd-start",
(UINTN)RamdiskData);
if (EFI_ERROR (Status)) {
goto Fdt_Exit;
}
Status = AndroidBootImgSetProperty64 (UpdatedFdtBase, ChosenNode,
"linux,initrd-end",
(UINTN)(RamdiskData + RamdiskSize));
if (EFI_ERROR (Status)) {
goto Fdt_Exit;
}
if (mAndroidBootImg->UpdateDtb) {
Status = mAndroidBootImg->UpdateDtb (UpdatedFdtBase, &NewFdtBase);
if (EFI_ERROR (Status)) {
goto Fdt_Exit;
}
}
Status = gBS->InstallConfigurationTable (
&gFdtTableGuid,
(VOID *)(UINTN)NewFdtBase
);
if (!EFI_ERROR (Status)) {
return EFI_SUCCESS;
}
Fdt_Exit:
gBS->FreePages (UpdatedFdtBase, EFI_SIZE_TO_PAGES (NewFdtSize));
return Status;
}
EFI_STATUS
AndroidBootImgBoot (
IN VOID *Buffer,
IN UINTN BufferSize
)
{
EFI_STATUS Status;
VOID *Kernel;
UINTN KernelSize;
MEMORY_DEVICE_PATH KernelDevicePath;
EFI_HANDLE ImageHandle;
VOID *NewKernelArg;
EFI_LOADED_IMAGE_PROTOCOL *ImageInfo;
VOID *RamdiskData;
UINTN RamdiskSize;
IN VOID *FdtBase;
Status = gBS->LocateProtocol (&gAndroidBootImgProtocolGuid, NULL,
(VOID **) &mAndroidBootImg);
if (EFI_ERROR (Status)) {
return Status;
}
Status = AndroidBootImgGetKernelInfo (
Buffer,
&Kernel,
&KernelSize
);
if (EFI_ERROR (Status)) {
return Status;
}
NewKernelArg = AllocateZeroPool (ANDROID_BOOTIMG_KERNEL_ARGS_SIZE);
if (NewKernelArg == NULL) {
DEBUG ((DEBUG_ERROR, "Fail to allocate memory\n"));
return EFI_OUT_OF_RESOURCES;
}
Status = AndroidBootImgUpdateArgs (Buffer, NewKernelArg);
if (EFI_ERROR (Status)) {
FreePool (NewKernelArg);
return Status;
}
Status = AndroidBootImgGetRamdiskInfo (
Buffer,
&RamdiskData,
&RamdiskSize
);
if (EFI_ERROR (Status)) {
return Status;
}
Status = AndroidBootImgLocateFdt (Buffer, &FdtBase);
if (EFI_ERROR (Status)) {
FreePool (NewKernelArg);
return Status;
}
Status = AndroidBootImgUpdateFdt (Buffer, FdtBase, RamdiskData, RamdiskSize);
if (EFI_ERROR (Status)) {
FreePool (NewKernelArg);
return Status;
}
KernelDevicePath = mMemoryDevicePathTemplate;
KernelDevicePath.Node1.StartingAddress = (EFI_PHYSICAL_ADDRESS)(UINTN) Kernel;
KernelDevicePath.Node1.EndingAddress = (EFI_PHYSICAL_ADDRESS)(UINTN) Kernel
+ KernelSize;
Status = gBS->LoadImage (TRUE, gImageHandle,
(EFI_DEVICE_PATH *)&KernelDevicePath,
(VOID*)(UINTN)Kernel, KernelSize, &ImageHandle);
// Set kernel arguments
Status = gBS->HandleProtocol (ImageHandle, &gEfiLoadedImageProtocolGuid,
(VOID **) &ImageInfo);
ImageInfo->LoadOptions = NewKernelArg;
ImageInfo->LoadOptionsSize = StrLen (NewKernelArg) * sizeof (CHAR16);
// Before calling the image, enable the Watchdog Timer for the 5 Minute period
gBS->SetWatchdogTimer (5 * 60, 0x10000, 0, NULL);
// Start the image
Status = gBS->StartImage (ImageHandle, NULL, NULL);
// Clear the Watchdog Timer if the image returns
gBS->SetWatchdogTimer (0, 0x10000, 0, NULL);
return EFI_SUCCESS;
}

48
EmbeddedPkg/Library/AndroidBootImgLib/AndroidBootImgLib.inf Normal file
View File

@ -0,0 +1,48 @@
#/** @file
#
# Copyright (c) 2013-2015, ARM Ltd. All rights reserved.<BR>
# Copyright (c) 2017, Linaro. All rights reserved.
#
# This program and the accompanying materials
# are licensed and made available under the terms and conditions of the BSD License
# which accompanies this distribution. The full text of the license may be found at
# http://opensource.org/licenses/bsd-license.php
# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
#
#
#**/
[Defines]
INF_VERSION = 0x00010019
BASE_NAME = AndroidBootImgLib
FILE_GUID = ed3b8739-6fa7-4cb1-8aeb-2496f8fcaefa
MODULE_TYPE = BASE
VERSION_STRING = 1.0
LIBRARY_CLASS = AndroidBootImgLib
#
# The following information is for reference only and not required by the build tools.
#
# VALID_ARCHITECTURES = ARM AARCH64
#
[Sources]
AndroidBootImgLib.c
[LibraryClasses]
DebugLib
FdtLib
PrintLib
UefiBootServicesTableLib
UefiLib
[Packages]
EmbeddedPkg/EmbeddedPkg.dec
MdePkg/MdePkg.dec
[Protocols]
gAndroidBootImgProtocolGuid
[Guids]
gFdtTableGuid