EmbeddedPkg: Apply uncrustify changes
REF: https://bugzilla.tianocore.org/show_bug.cgi?id=3737 Apply uncrustify changes to .c/.h files in the EmbeddedPkg package Cc: Andrew Fish <afish@apple.com> Cc: Leif Lindholm <leif@nuviainc.com> Cc: Michael D Kinney <michael.d.kinney@intel.com> Signed-off-by: Michael Kubacki <michael.kubacki@microsoft.com> Reviewed-by: Andrew Fish <afish@apple.com>
This commit is contained in:
committed by
mergify[bot]
parent
731c67e1d7
commit
e7108d0e96
@@ -31,29 +31,29 @@
|
||||
**/
|
||||
EFI_STATUS
|
||||
LocateAndInstallAcpiFromFvConditional (
|
||||
IN CONST EFI_GUID* AcpiFile,
|
||||
IN CONST EFI_GUID *AcpiFile,
|
||||
IN EFI_LOCATE_ACPI_CHECK CheckAcpiTableFunction
|
||||
)
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
EFI_ACPI_TABLE_PROTOCOL *AcpiProtocol;
|
||||
EFI_HANDLE *HandleBuffer;
|
||||
UINTN NumberOfHandles;
|
||||
UINT32 FvStatus;
|
||||
UINTN Index;
|
||||
EFI_FIRMWARE_VOLUME2_PROTOCOL *FvInstance;
|
||||
INTN SectionInstance;
|
||||
UINTN SectionSize;
|
||||
EFI_ACPI_COMMON_HEADER *AcpiTable;
|
||||
UINTN AcpiTableSize;
|
||||
UINTN AcpiTableKey;
|
||||
BOOLEAN Valid;
|
||||
EFI_STATUS Status;
|
||||
EFI_ACPI_TABLE_PROTOCOL *AcpiProtocol;
|
||||
EFI_HANDLE *HandleBuffer;
|
||||
UINTN NumberOfHandles;
|
||||
UINT32 FvStatus;
|
||||
UINTN Index;
|
||||
EFI_FIRMWARE_VOLUME2_PROTOCOL *FvInstance;
|
||||
INTN SectionInstance;
|
||||
UINTN SectionSize;
|
||||
EFI_ACPI_COMMON_HEADER *AcpiTable;
|
||||
UINTN AcpiTableSize;
|
||||
UINTN AcpiTableKey;
|
||||
BOOLEAN Valid;
|
||||
|
||||
// Ensure the ACPI Table is present
|
||||
Status = gBS->LocateProtocol (
|
||||
&gEfiAcpiTableProtocolGuid,
|
||||
NULL,
|
||||
(VOID**)&AcpiProtocol
|
||||
(VOID **)&AcpiProtocol
|
||||
);
|
||||
if (EFI_ERROR (Status)) {
|
||||
return Status;
|
||||
@@ -64,12 +64,12 @@ LocateAndInstallAcpiFromFvConditional (
|
||||
|
||||
// Locate all the Firmware Volume protocols.
|
||||
Status = gBS->LocateHandleBuffer (
|
||||
ByProtocol,
|
||||
&gEfiFirmwareVolume2ProtocolGuid,
|
||||
NULL,
|
||||
&NumberOfHandles,
|
||||
&HandleBuffer
|
||||
);
|
||||
ByProtocol,
|
||||
&gEfiFirmwareVolume2ProtocolGuid,
|
||||
NULL,
|
||||
&NumberOfHandles,
|
||||
&HandleBuffer
|
||||
);
|
||||
if (EFI_ERROR (Status)) {
|
||||
return Status;
|
||||
}
|
||||
@@ -81,10 +81,10 @@ LocateAndInstallAcpiFromFvConditional (
|
||||
// This should not fail because of LocateHandleBuffer
|
||||
//
|
||||
Status = gBS->HandleProtocol (
|
||||
HandleBuffer[Index],
|
||||
&gEfiFirmwareVolume2ProtocolGuid,
|
||||
(VOID**) &FvInstance
|
||||
);
|
||||
HandleBuffer[Index],
|
||||
&gEfiFirmwareVolume2ProtocolGuid,
|
||||
(VOID **)&FvInstance
|
||||
);
|
||||
if (EFI_ERROR (Status)) {
|
||||
goto FREE_HANDLE_BUFFER;
|
||||
}
|
||||
@@ -95,24 +95,27 @@ LocateAndInstallAcpiFromFvConditional (
|
||||
|
||||
// See if it has the ACPI storage file
|
||||
Status = FvInstance->ReadSection (
|
||||
FvInstance,
|
||||
AcpiFile,
|
||||
EFI_SECTION_RAW,
|
||||
SectionInstance,
|
||||
(VOID**) &AcpiTable,
|
||||
&SectionSize,
|
||||
&FvStatus
|
||||
);
|
||||
FvInstance,
|
||||
AcpiFile,
|
||||
EFI_SECTION_RAW,
|
||||
SectionInstance,
|
||||
(VOID **)&AcpiTable,
|
||||
&SectionSize,
|
||||
&FvStatus
|
||||
);
|
||||
if (!EFI_ERROR (Status)) {
|
||||
AcpiTableKey = 0;
|
||||
AcpiTableSize = ((EFI_ACPI_DESCRIPTION_HEADER *) AcpiTable)->Length;
|
||||
AcpiTableKey = 0;
|
||||
AcpiTableSize = ((EFI_ACPI_DESCRIPTION_HEADER *)AcpiTable)->Length;
|
||||
ASSERT (SectionSize >= AcpiTableSize);
|
||||
|
||||
DEBUG ((DEBUG_ERROR, "- Found '%c%c%c%c' ACPI Table\n",
|
||||
(((EFI_ACPI_DESCRIPTION_HEADER *) AcpiTable)->Signature & 0xFF),
|
||||
((((EFI_ACPI_DESCRIPTION_HEADER *) AcpiTable)->Signature >> 8) & 0xFF),
|
||||
((((EFI_ACPI_DESCRIPTION_HEADER *) AcpiTable)->Signature >> 16) & 0xFF),
|
||||
((((EFI_ACPI_DESCRIPTION_HEADER *) AcpiTable)->Signature >> 24) & 0xFF)));
|
||||
DEBUG ((
|
||||
DEBUG_ERROR,
|
||||
"- Found '%c%c%c%c' ACPI Table\n",
|
||||
(((EFI_ACPI_DESCRIPTION_HEADER *)AcpiTable)->Signature & 0xFF),
|
||||
((((EFI_ACPI_DESCRIPTION_HEADER *)AcpiTable)->Signature >> 8) & 0xFF),
|
||||
((((EFI_ACPI_DESCRIPTION_HEADER *)AcpiTable)->Signature >> 16) & 0xFF),
|
||||
((((EFI_ACPI_DESCRIPTION_HEADER *)AcpiTable)->Signature >> 24) & 0xFF)
|
||||
));
|
||||
|
||||
// Is the ACPI table valid?
|
||||
if (CheckAcpiTableFunction) {
|
||||
@@ -124,11 +127,11 @@ LocateAndInstallAcpiFromFvConditional (
|
||||
// Install the ACPI Table
|
||||
if (Valid) {
|
||||
Status = AcpiProtocol->InstallAcpiTable (
|
||||
AcpiProtocol,
|
||||
AcpiTable,
|
||||
AcpiTableSize,
|
||||
&AcpiTableKey
|
||||
);
|
||||
AcpiProtocol,
|
||||
AcpiTable,
|
||||
AcpiTableSize,
|
||||
&AcpiTableKey
|
||||
);
|
||||
}
|
||||
|
||||
// Free memory allocated by ReadSection
|
||||
@@ -165,7 +168,7 @@ FREE_HANDLE_BUFFER:
|
||||
**/
|
||||
EFI_STATUS
|
||||
LocateAndInstallAcpiFromFv (
|
||||
IN CONST EFI_GUID* AcpiFile
|
||||
IN CONST EFI_GUID *AcpiFile
|
||||
)
|
||||
{
|
||||
return LocateAndInstallAcpiFromFvConditional (AcpiFile, NULL);
|
||||
|
@@ -20,24 +20,24 @@
|
||||
|
||||
#include <Guid/LinuxEfiInitrdMedia.h>
|
||||
|
||||
#define FDT_ADDITIONAL_ENTRIES_SIZE 0x400
|
||||
#define FDT_ADDITIONAL_ENTRIES_SIZE 0x400
|
||||
|
||||
typedef struct {
|
||||
MEMMAP_DEVICE_PATH Node1;
|
||||
EFI_DEVICE_PATH_PROTOCOL End;
|
||||
MEMMAP_DEVICE_PATH Node1;
|
||||
EFI_DEVICE_PATH_PROTOCOL End;
|
||||
} MEMORY_DEVICE_PATH;
|
||||
|
||||
typedef struct {
|
||||
VENDOR_DEVICE_PATH VendorMediaNode;
|
||||
EFI_DEVICE_PATH_PROTOCOL EndNode;
|
||||
VENDOR_DEVICE_PATH VendorMediaNode;
|
||||
EFI_DEVICE_PATH_PROTOCOL EndNode;
|
||||
} RAMDISK_DEVICE_PATH;
|
||||
|
||||
STATIC ANDROID_BOOTIMG_PROTOCOL *mAndroidBootImg;
|
||||
STATIC VOID *mRamdiskData = NULL;
|
||||
STATIC UINTN mRamdiskSize = 0;
|
||||
STATIC EFI_HANDLE mRamDiskLoadFileHandle = NULL;
|
||||
STATIC ANDROID_BOOTIMG_PROTOCOL *mAndroidBootImg;
|
||||
STATIC VOID *mRamdiskData = NULL;
|
||||
STATIC UINTN mRamdiskSize = 0;
|
||||
STATIC EFI_HANDLE mRamDiskLoadFileHandle = NULL;
|
||||
|
||||
STATIC CONST MEMORY_DEVICE_PATH mMemoryDevicePathTemplate =
|
||||
STATIC CONST MEMORY_DEVICE_PATH mMemoryDevicePathTemplate =
|
||||
{
|
||||
{
|
||||
{
|
||||
@@ -58,13 +58,13 @@ STATIC CONST MEMORY_DEVICE_PATH mMemoryDevicePathTemplate =
|
||||
} // End
|
||||
};
|
||||
|
||||
STATIC CONST RAMDISK_DEVICE_PATH mRamdiskDevicePath =
|
||||
STATIC CONST RAMDISK_DEVICE_PATH mRamdiskDevicePath =
|
||||
{
|
||||
{
|
||||
{
|
||||
MEDIA_DEVICE_PATH,
|
||||
MEDIA_VENDOR_DP,
|
||||
{ sizeof (VENDOR_DEVICE_PATH), 0 }
|
||||
{ sizeof (VENDOR_DEVICE_PATH), 0 }
|
||||
},
|
||||
LINUX_EFI_INITRD_MEDIA_GUID
|
||||
},
|
||||
@@ -107,19 +107,20 @@ STATIC CONST RAMDISK_DEVICE_PATH mRamdiskDevicePath =
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
AndroidBootImgLoadFile2 (
|
||||
IN EFI_LOAD_FILE2_PROTOCOL *This,
|
||||
IN EFI_DEVICE_PATH_PROTOCOL *FilePath,
|
||||
IN BOOLEAN BootPolicy,
|
||||
IN OUT UINTN *BufferSize,
|
||||
IN VOID *Buffer OPTIONAL
|
||||
IN EFI_LOAD_FILE2_PROTOCOL *This,
|
||||
IN EFI_DEVICE_PATH_PROTOCOL *FilePath,
|
||||
IN BOOLEAN BootPolicy,
|
||||
IN OUT UINTN *BufferSize,
|
||||
IN VOID *Buffer OPTIONAL
|
||||
)
|
||||
|
||||
{
|
||||
// Verify if the valid parameters
|
||||
if (This == NULL ||
|
||||
BufferSize == NULL ||
|
||||
FilePath == NULL ||
|
||||
!IsDevicePathValid (FilePath, 0)) {
|
||||
if ((This == NULL) ||
|
||||
(BufferSize == NULL) ||
|
||||
(FilePath == NULL) ||
|
||||
!IsDevicePathValid (FilePath, 0))
|
||||
{
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
@@ -132,7 +133,8 @@ AndroidBootImgLoadFile2 (
|
||||
if (mRamdiskSize == 0) {
|
||||
return EFI_NOT_FOUND;
|
||||
}
|
||||
if (Buffer == NULL || *BufferSize < mRamdiskSize) {
|
||||
|
||||
if ((Buffer == NULL) || (*BufferSize < mRamdiskSize)) {
|
||||
*BufferSize = mRamdiskSize;
|
||||
return EFI_BUFFER_TOO_SMALL;
|
||||
}
|
||||
@@ -153,16 +155,20 @@ STATIC EFI_LOAD_FILE2_PROTOCOL mAndroidBootImgLoadFile2 = {
|
||||
|
||||
EFI_STATUS
|
||||
AndroidBootImgGetImgSize (
|
||||
IN VOID *BootImg,
|
||||
OUT UINTN *ImgSize
|
||||
IN VOID *BootImg,
|
||||
OUT UINTN *ImgSize
|
||||
)
|
||||
{
|
||||
ANDROID_BOOTIMG_HEADER *Header;
|
||||
ANDROID_BOOTIMG_HEADER *Header;
|
||||
|
||||
Header = (ANDROID_BOOTIMG_HEADER *) BootImg;
|
||||
Header = (ANDROID_BOOTIMG_HEADER *)BootImg;
|
||||
|
||||
if (AsciiStrnCmp ((CONST CHAR8 *)Header->BootMagic, ANDROID_BOOT_MAGIC,
|
||||
ANDROID_BOOT_MAGIC_LENGTH) != 0) {
|
||||
if (AsciiStrnCmp (
|
||||
(CONST CHAR8 *)Header->BootMagic,
|
||||
ANDROID_BOOT_MAGIC,
|
||||
ANDROID_BOOT_MAGIC_LENGTH
|
||||
) != 0)
|
||||
{
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
@@ -179,17 +185,21 @@ AndroidBootImgGetImgSize (
|
||||
|
||||
EFI_STATUS
|
||||
AndroidBootImgGetKernelInfo (
|
||||
IN VOID *BootImg,
|
||||
IN VOID *BootImg,
|
||||
OUT VOID **Kernel,
|
||||
OUT UINTN *KernelSize
|
||||
OUT UINTN *KernelSize
|
||||
)
|
||||
{
|
||||
ANDROID_BOOTIMG_HEADER *Header;
|
||||
ANDROID_BOOTIMG_HEADER *Header;
|
||||
|
||||
Header = (ANDROID_BOOTIMG_HEADER *) BootImg;
|
||||
Header = (ANDROID_BOOTIMG_HEADER *)BootImg;
|
||||
|
||||
if (AsciiStrnCmp ((CONST CHAR8 *)Header->BootMagic, ANDROID_BOOT_MAGIC,
|
||||
ANDROID_BOOT_MAGIC_LENGTH) != 0) {
|
||||
if (AsciiStrnCmp (
|
||||
(CONST CHAR8 *)Header->BootMagic,
|
||||
ANDROID_BOOT_MAGIC,
|
||||
ANDROID_BOOT_MAGIC_LENGTH
|
||||
) != 0)
|
||||
{
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
@@ -200,23 +210,27 @@ AndroidBootImgGetKernelInfo (
|
||||
ASSERT (IS_VALID_ANDROID_PAGE_SIZE (Header->PageSize));
|
||||
|
||||
*KernelSize = Header->KernelSize;
|
||||
*Kernel = (VOID *)((UINTN)BootImg + Header->PageSize);
|
||||
*Kernel = (VOID *)((UINTN)BootImg + Header->PageSize);
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
AndroidBootImgGetRamdiskInfo (
|
||||
IN VOID *BootImg,
|
||||
IN VOID *BootImg,
|
||||
OUT VOID **Ramdisk,
|
||||
OUT UINTN *RamdiskSize
|
||||
OUT UINTN *RamdiskSize
|
||||
)
|
||||
{
|
||||
ANDROID_BOOTIMG_HEADER *Header;
|
||||
ANDROID_BOOTIMG_HEADER *Header;
|
||||
|
||||
Header = (ANDROID_BOOTIMG_HEADER *)BootImg;
|
||||
|
||||
if (AsciiStrnCmp ((CONST CHAR8 *)Header->BootMagic, ANDROID_BOOT_MAGIC,
|
||||
ANDROID_BOOT_MAGIC_LENGTH) != 0) {
|
||||
if (AsciiStrnCmp (
|
||||
(CONST CHAR8 *)Header->BootMagic,
|
||||
ANDROID_BOOT_MAGIC,
|
||||
ANDROID_BOOT_MAGIC_LENGTH
|
||||
) != 0)
|
||||
{
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
@@ -229,22 +243,27 @@ AndroidBootImgGetRamdiskInfo (
|
||||
+ Header->PageSize
|
||||
+ ALIGN_VALUE (Header->KernelSize, Header->PageSize));
|
||||
}
|
||||
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
AndroidBootImgGetSecondBootLoaderInfo (
|
||||
IN VOID *BootImg,
|
||||
IN VOID *BootImg,
|
||||
OUT VOID **Second,
|
||||
OUT UINTN *SecondSize
|
||||
OUT UINTN *SecondSize
|
||||
)
|
||||
{
|
||||
ANDROID_BOOTIMG_HEADER *Header;
|
||||
ANDROID_BOOTIMG_HEADER *Header;
|
||||
|
||||
Header = (ANDROID_BOOTIMG_HEADER *)BootImg;
|
||||
|
||||
if (AsciiStrnCmp ((CONST CHAR8 *)Header->BootMagic, ANDROID_BOOT_MAGIC,
|
||||
ANDROID_BOOT_MAGIC_LENGTH) != 0) {
|
||||
if (AsciiStrnCmp (
|
||||
(CONST CHAR8 *)Header->BootMagic,
|
||||
ANDROID_BOOT_MAGIC,
|
||||
ANDROID_BOOT_MAGIC_LENGTH
|
||||
) != 0)
|
||||
{
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
@@ -258,32 +277,37 @@ AndroidBootImgGetSecondBootLoaderInfo (
|
||||
+ ALIGN_VALUE (Header->KernelSize, Header->PageSize)
|
||||
+ ALIGN_VALUE (Header->RamdiskSize, Header->PageSize));
|
||||
}
|
||||
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
AndroidBootImgGetKernelArgs (
|
||||
IN VOID *BootImg,
|
||||
OUT CHAR8 *KernelArgs
|
||||
IN VOID *BootImg,
|
||||
OUT CHAR8 *KernelArgs
|
||||
)
|
||||
{
|
||||
ANDROID_BOOTIMG_HEADER *Header;
|
||||
ANDROID_BOOTIMG_HEADER *Header;
|
||||
|
||||
Header = (ANDROID_BOOTIMG_HEADER *) BootImg;
|
||||
AsciiStrnCpyS (KernelArgs, ANDROID_BOOTIMG_KERNEL_ARGS_SIZE, Header->KernelArgs,
|
||||
ANDROID_BOOTIMG_KERNEL_ARGS_SIZE);
|
||||
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
|
||||
IN VOID *BootImg,
|
||||
IN VOID **FdtBase
|
||||
)
|
||||
{
|
||||
UINTN SecondLoaderSize;
|
||||
EFI_STATUS Status;
|
||||
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. */
|
||||
@@ -291,43 +315,50 @@ AndroidBootImgGetFdt (
|
||||
BootImg,
|
||||
FdtBase,
|
||||
&SecondLoaderSize
|
||||
);
|
||||
);
|
||||
return Status;
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
AndroidBootImgUpdateArgs (
|
||||
IN VOID *BootImg,
|
||||
OUT VOID *KernelArgs
|
||||
IN VOID *BootImg,
|
||||
OUT VOID *KernelArgs
|
||||
)
|
||||
{
|
||||
CHAR8 ImageKernelArgs[ANDROID_BOOTIMG_KERNEL_ARGS_SIZE];
|
||||
EFI_STATUS Status;
|
||||
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);
|
||||
|
||||
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);
|
||||
if (mAndroidBootImg->AppendArgs) {
|
||||
Status = mAndroidBootImg->AppendArgs (
|
||||
KernelArgs,
|
||||
ANDROID_BOOTIMG_KERNEL_ARGS_SIZE
|
||||
);
|
||||
}
|
||||
|
||||
return Status;
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
AndroidBootImgInstallLoadFile2 (
|
||||
IN VOID *RamdiskData,
|
||||
IN UINTN RamdiskSize
|
||||
IN VOID *RamdiskData,
|
||||
IN UINTN RamdiskSize
|
||||
)
|
||||
{
|
||||
mRamDiskLoadFileHandle = NULL;
|
||||
mRamdiskData = RamdiskData;
|
||||
mRamdiskSize = RamdiskSize;
|
||||
mRamdiskData = RamdiskData;
|
||||
mRamdiskSize = RamdiskSize;
|
||||
return gBS->InstallMultipleProtocolInterfaces (
|
||||
&mRamDiskLoadFileHandle,
|
||||
&gEfiLoadFile2ProtocolGuid,
|
||||
@@ -343,9 +374,9 @@ AndroidBootImgUninstallLoadFile2 (
|
||||
VOID
|
||||
)
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
EFI_STATUS Status;
|
||||
|
||||
Status = EFI_SUCCESS;
|
||||
Status = EFI_SUCCESS;
|
||||
mRamdiskData = NULL;
|
||||
mRamdiskSize = 0;
|
||||
if (mRamDiskLoadFileHandle != NULL) {
|
||||
@@ -359,15 +390,17 @@ AndroidBootImgUninstallLoadFile2 (
|
||||
);
|
||||
mRamDiskLoadFileHandle = NULL;
|
||||
}
|
||||
|
||||
return Status;
|
||||
}
|
||||
|
||||
BOOLEAN AndroidBootImgAcpiSupported (
|
||||
BOOLEAN
|
||||
AndroidBootImgAcpiSupported (
|
||||
VOID
|
||||
)
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
VOID *AcpiTable;
|
||||
VOID *AcpiTable;
|
||||
|
||||
Status = EfiGetSystemConfigurationTable (&gEfiAcpiTableGuid, &AcpiTable);
|
||||
return !EFI_ERROR (Status);
|
||||
@@ -375,12 +408,12 @@ BOOLEAN AndroidBootImgAcpiSupported (
|
||||
|
||||
EFI_STATUS
|
||||
AndroidBootImgLocateFdt (
|
||||
IN VOID *BootImg,
|
||||
IN VOID **FdtBase
|
||||
IN VOID *BootImg,
|
||||
IN VOID **FdtBase
|
||||
)
|
||||
{
|
||||
INTN Err;
|
||||
EFI_STATUS Status;
|
||||
INTN Err;
|
||||
EFI_STATUS Status;
|
||||
|
||||
Status = EfiGetSystemConfigurationTable (&gFdtTableGuid, FdtBase);
|
||||
if (!EFI_ERROR (Status)) {
|
||||
@@ -391,58 +424,77 @@ AndroidBootImgLocateFdt (
|
||||
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));
|
||||
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
|
||||
IN INTN UpdatedFdtBase
|
||||
)
|
||||
{
|
||||
INTN ChosenNode;
|
||||
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;
|
||||
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
|
||||
IN INTN UpdatedFdtBase,
|
||||
IN INTN ChosenNode,
|
||||
IN CHAR8 *PropertyName,
|
||||
IN UINT64 Val
|
||||
)
|
||||
{
|
||||
INTN Err;
|
||||
struct fdt_property *Property;
|
||||
int Len;
|
||||
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));
|
||||
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);
|
||||
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;
|
||||
@@ -451,33 +503,41 @@ AndroidBootImgSetProperty64 (
|
||||
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
|
||||
IN VOID *BootImg,
|
||||
IN VOID *FdtBase,
|
||||
IN VOID *RamdiskData,
|
||||
IN UINTN RamdiskSize
|
||||
)
|
||||
{
|
||||
INTN ChosenNode, Err, NewFdtSize;
|
||||
EFI_STATUS Status;
|
||||
EFI_PHYSICAL_ADDRESS UpdatedFdtBase, NewFdtBase;
|
||||
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);
|
||||
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));
|
||||
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);
|
||||
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;
|
||||
@@ -490,21 +550,27 @@ AndroidBootImgUpdateFdt (
|
||||
goto Fdt_Exit;
|
||||
}
|
||||
} else {
|
||||
ChosenNode = AndroidBootImgGetChosenNode(UpdatedFdtBase);
|
||||
ChosenNode = AndroidBootImgGetChosenNode (UpdatedFdtBase);
|
||||
if (!ChosenNode) {
|
||||
goto Fdt_Exit;
|
||||
}
|
||||
|
||||
Status = AndroidBootImgSetProperty64 (UpdatedFdtBase, ChosenNode,
|
||||
"linux,initrd-start",
|
||||
(UINTN)RamdiskData);
|
||||
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);
|
||||
Status = AndroidBootImgSetProperty64 (
|
||||
UpdatedFdtBase,
|
||||
ChosenNode,
|
||||
"linux,initrd-end",
|
||||
(UINTN)RamdiskData + RamdiskSize
|
||||
);
|
||||
if (EFI_ERROR (Status)) {
|
||||
goto Fdt_Exit;
|
||||
}
|
||||
@@ -518,6 +584,7 @@ AndroidBootImgUpdateFdt (
|
||||
} else {
|
||||
NewFdtBase = UpdatedFdtBase;
|
||||
}
|
||||
|
||||
Status = gBS->InstallConfigurationTable (
|
||||
&gFdtTableGuid,
|
||||
(VOID *)(UINTN)NewFdtBase
|
||||
@@ -534,35 +601,38 @@ Fdt_Exit:
|
||||
|
||||
EFI_STATUS
|
||||
AndroidBootImgBoot (
|
||||
IN VOID *Buffer,
|
||||
IN UINTN BufferSize
|
||||
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;
|
||||
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;
|
||||
|
||||
NewKernelArg = NULL;
|
||||
ImageHandle = NULL;
|
||||
ImageHandle = NULL;
|
||||
|
||||
Status = gBS->LocateProtocol (&gAndroidBootImgProtocolGuid, NULL,
|
||||
(VOID **) &mAndroidBootImg);
|
||||
Status = gBS->LocateProtocol (
|
||||
&gAndroidBootImgProtocolGuid,
|
||||
NULL,
|
||||
(VOID **)&mAndroidBootImg
|
||||
);
|
||||
if (EFI_ERROR (Status)) {
|
||||
goto Exit;
|
||||
}
|
||||
|
||||
Status = AndroidBootImgGetKernelInfo (
|
||||
Buffer,
|
||||
&Kernel,
|
||||
&KernelSize
|
||||
);
|
||||
Buffer,
|
||||
&Kernel,
|
||||
&KernelSize
|
||||
);
|
||||
if (EFI_ERROR (Status)) {
|
||||
goto Exit;
|
||||
}
|
||||
@@ -580,10 +650,10 @@ AndroidBootImgBoot (
|
||||
}
|
||||
|
||||
Status = AndroidBootImgGetRamdiskInfo (
|
||||
Buffer,
|
||||
&RamdiskData,
|
||||
&RamdiskSize
|
||||
);
|
||||
Buffer,
|
||||
&RamdiskData,
|
||||
&RamdiskSize
|
||||
);
|
||||
if (EFI_ERROR (Status)) {
|
||||
goto Exit;
|
||||
}
|
||||
@@ -607,24 +677,33 @@ AndroidBootImgBoot (
|
||||
|
||||
KernelDevicePath = mMemoryDevicePathTemplate;
|
||||
|
||||
KernelDevicePath.Node1.StartingAddress = (EFI_PHYSICAL_ADDRESS)(UINTN) Kernel;
|
||||
KernelDevicePath.Node1.EndingAddress = (EFI_PHYSICAL_ADDRESS)(UINTN) Kernel
|
||||
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);
|
||||
Status = gBS->LoadImage (
|
||||
TRUE,
|
||||
gImageHandle,
|
||||
(EFI_DEVICE_PATH *)&KernelDevicePath,
|
||||
(VOID *)(UINTN)Kernel,
|
||||
KernelSize,
|
||||
&ImageHandle
|
||||
);
|
||||
if (EFI_ERROR (Status)) {
|
||||
goto Exit;
|
||||
}
|
||||
|
||||
// Set kernel arguments
|
||||
Status = gBS->HandleProtocol (ImageHandle, &gEfiLoadedImageProtocolGuid,
|
||||
(VOID **) &ImageInfo);
|
||||
Status = gBS->HandleProtocol (
|
||||
ImageHandle,
|
||||
&gEfiLoadedImageProtocolGuid,
|
||||
(VOID **)&ImageInfo
|
||||
);
|
||||
if (EFI_ERROR (Status)) {
|
||||
goto Exit;
|
||||
}
|
||||
ImageInfo->LoadOptions = NewKernelArg;
|
||||
|
||||
ImageInfo->LoadOptions = NewKernelArg;
|
||||
ImageInfo->LoadOptionsSize = StrLen (NewKernelArg) * sizeof (CHAR16);
|
||||
|
||||
// Before calling the image, enable the Watchdog Timer for the 5 Minute period
|
||||
@@ -635,17 +714,19 @@ AndroidBootImgBoot (
|
||||
gBS->SetWatchdogTimer (0, 0x10000, 0, NULL);
|
||||
|
||||
Exit:
|
||||
//Unload image as it will not be used anymore
|
||||
// Unload image as it will not be used anymore
|
||||
if (ImageHandle != NULL) {
|
||||
gBS->UnloadImage (ImageHandle);
|
||||
ImageHandle = NULL;
|
||||
}
|
||||
|
||||
if (EFI_ERROR (Status)) {
|
||||
if (NewKernelArg != NULL) {
|
||||
FreePool (NewKernelArg);
|
||||
NewKernelArg = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
AndroidBootImgUninstallLoadFile2 ();
|
||||
return Status;
|
||||
}
|
||||
|
@@ -12,11 +12,10 @@
|
||||
#include <Library/DmaLib.h>
|
||||
#include <Library/MemoryAllocationLib.h>
|
||||
|
||||
|
||||
STATIC
|
||||
PHYSICAL_ADDRESS
|
||||
HostToDeviceAddress (
|
||||
IN VOID *Address
|
||||
IN VOID *Address
|
||||
)
|
||||
{
|
||||
return (PHYSICAL_ADDRESS)(UINTN)Address + PcdGet64 (PcdDmaDeviceOffset);
|
||||
@@ -45,25 +44,26 @@ HostToDeviceAddress (
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
DmaMap (
|
||||
IN DMA_MAP_OPERATION Operation,
|
||||
IN VOID *HostAddress,
|
||||
IN OUT UINTN *NumberOfBytes,
|
||||
OUT PHYSICAL_ADDRESS *DeviceAddress,
|
||||
OUT VOID **Mapping
|
||||
IN DMA_MAP_OPERATION Operation,
|
||||
IN VOID *HostAddress,
|
||||
IN OUT UINTN *NumberOfBytes,
|
||||
OUT PHYSICAL_ADDRESS *DeviceAddress,
|
||||
OUT VOID **Mapping
|
||||
)
|
||||
{
|
||||
if (HostAddress == NULL ||
|
||||
NumberOfBytes == NULL ||
|
||||
DeviceAddress == NULL ||
|
||||
Mapping == NULL ) {
|
||||
if ((HostAddress == NULL) ||
|
||||
(NumberOfBytes == NULL) ||
|
||||
(DeviceAddress == NULL) ||
|
||||
(Mapping == NULL))
|
||||
{
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
*DeviceAddress = HostToDeviceAddress (HostAddress);
|
||||
*Mapping = NULL;
|
||||
*Mapping = NULL;
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Completes the DmaMapBusMasterRead(), DmaMapBusMasterWrite(), or DmaMapBusMasterCommonBuffer()
|
||||
operation and releases any corresponding resources.
|
||||
@@ -77,7 +77,7 @@ DmaMap (
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
DmaUnmap (
|
||||
IN VOID *Mapping
|
||||
IN VOID *Mapping
|
||||
)
|
||||
{
|
||||
return EFI_SUCCESS;
|
||||
@@ -103,15 +103,14 @@ DmaUnmap (
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
DmaAllocateBuffer (
|
||||
IN EFI_MEMORY_TYPE MemoryType,
|
||||
IN UINTN Pages,
|
||||
OUT VOID **HostAddress
|
||||
IN EFI_MEMORY_TYPE MemoryType,
|
||||
IN UINTN Pages,
|
||||
OUT VOID **HostAddress
|
||||
)
|
||||
{
|
||||
return DmaAllocateAlignedBuffer (MemoryType, Pages, 0, HostAddress);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Allocates pages that are suitable for an DmaMap() of type
|
||||
MapOperationBusMasterCommonBuffer mapping, at the requested alignment.
|
||||
@@ -134,18 +133,19 @@ DmaAllocateBuffer (
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
DmaAllocateAlignedBuffer (
|
||||
IN EFI_MEMORY_TYPE MemoryType,
|
||||
IN UINTN Pages,
|
||||
IN UINTN Alignment,
|
||||
OUT VOID **HostAddress
|
||||
IN EFI_MEMORY_TYPE MemoryType,
|
||||
IN UINTN Pages,
|
||||
IN UINTN Alignment,
|
||||
OUT VOID **HostAddress
|
||||
)
|
||||
{
|
||||
if (Alignment == 0) {
|
||||
Alignment = EFI_PAGE_SIZE;
|
||||
}
|
||||
|
||||
if (HostAddress == NULL ||
|
||||
(Alignment & (Alignment - 1)) != 0) {
|
||||
if ((HostAddress == NULL) ||
|
||||
((Alignment & (Alignment - 1)) != 0))
|
||||
{
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
@@ -163,10 +163,10 @@ DmaAllocateAlignedBuffer (
|
||||
if (*HostAddress == NULL) {
|
||||
return EFI_OUT_OF_RESOURCES;
|
||||
}
|
||||
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Frees memory that was allocated with DmaAllocateBuffer().
|
||||
|
||||
@@ -181,15 +181,14 @@ DmaAllocateAlignedBuffer (
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
DmaFreeBuffer (
|
||||
IN UINTN Pages,
|
||||
IN VOID *HostAddress
|
||||
IN UINTN Pages,
|
||||
IN VOID *HostAddress
|
||||
)
|
||||
{
|
||||
if (HostAddress == NULL) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
FreePages (HostAddress, Pages);
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
|
@@ -11,7 +11,6 @@
|
||||
|
||||
**/
|
||||
|
||||
|
||||
/**
|
||||
Setup all the hardware needed for the debug agents timer.
|
||||
|
||||
@@ -26,7 +25,6 @@ DebugAgentTimerIntialize (
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Set the period for the debug agent timer. Zero means disable the timer.
|
||||
|
||||
@@ -41,7 +39,6 @@ DebugAgentTimerSetPeriod (
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Perform End Of Interrupt for the debug agent timer. This is called in the
|
||||
interrupt handler after the interrupt has been processed.
|
||||
@@ -54,4 +51,3 @@ DebugAgentTimerEndOfInterrupt (
|
||||
)
|
||||
{
|
||||
}
|
||||
|
||||
|
@@ -27,17 +27,22 @@
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
DtPlatformLoadDtb (
|
||||
OUT VOID **Dtb,
|
||||
OUT UINTN *DtbSize
|
||||
OUT VOID **Dtb,
|
||||
OUT UINTN *DtbSize
|
||||
)
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
VOID *OrigDtb;
|
||||
VOID *CopyDtb;
|
||||
UINTN OrigDtbSize;
|
||||
EFI_STATUS Status;
|
||||
VOID *OrigDtb;
|
||||
VOID *CopyDtb;
|
||||
UINTN OrigDtbSize;
|
||||
|
||||
Status = GetSectionFromAnyFv (&gDtPlatformDefaultDtbFileGuid,
|
||||
EFI_SECTION_RAW, 0, &OrigDtb, &OrigDtbSize);
|
||||
Status = GetSectionFromAnyFv (
|
||||
&gDtPlatformDefaultDtbFileGuid,
|
||||
EFI_SECTION_RAW,
|
||||
0,
|
||||
&OrigDtb,
|
||||
&OrigDtbSize
|
||||
);
|
||||
if (EFI_ERROR (Status)) {
|
||||
return EFI_NOT_FOUND;
|
||||
}
|
||||
@@ -47,7 +52,7 @@ DtPlatformLoadDtb (
|
||||
return EFI_OUT_OF_RESOURCES;
|
||||
}
|
||||
|
||||
*Dtb = CopyDtb;
|
||||
*Dtb = CopyDtb;
|
||||
*DtbSize = OrigDtbSize;
|
||||
|
||||
return EFI_SUCCESS;
|
||||
|
@@ -55,197 +55,276 @@
|
||||
|
||||
#include "libfdt_internal.h"
|
||||
|
||||
int fdt_check_header(const void *fdt)
|
||||
int
|
||||
fdt_check_header (
|
||||
const void *fdt
|
||||
)
|
||||
{
|
||||
if (fdt_magic(fdt) == FDT_MAGIC) {
|
||||
/* Complete tree */
|
||||
if (fdt_version(fdt) < FDT_FIRST_SUPPORTED_VERSION)
|
||||
return -FDT_ERR_BADVERSION;
|
||||
if (fdt_last_comp_version(fdt) > FDT_LAST_SUPPORTED_VERSION)
|
||||
return -FDT_ERR_BADVERSION;
|
||||
} else if (fdt_magic(fdt) == FDT_SW_MAGIC) {
|
||||
/* Unfinished sequential-write blob */
|
||||
if (fdt_size_dt_struct(fdt) == 0)
|
||||
return -FDT_ERR_BADSTATE;
|
||||
} else {
|
||||
return -FDT_ERR_BADMAGIC;
|
||||
}
|
||||
if (fdt_magic (fdt) == FDT_MAGIC) {
|
||||
/* Complete tree */
|
||||
if (fdt_version (fdt) < FDT_FIRST_SUPPORTED_VERSION) {
|
||||
return -FDT_ERR_BADVERSION;
|
||||
}
|
||||
|
||||
return 0;
|
||||
if (fdt_last_comp_version (fdt) > FDT_LAST_SUPPORTED_VERSION) {
|
||||
return -FDT_ERR_BADVERSION;
|
||||
}
|
||||
} else if (fdt_magic (fdt) == FDT_SW_MAGIC) {
|
||||
/* Unfinished sequential-write blob */
|
||||
if (fdt_size_dt_struct (fdt) == 0) {
|
||||
return -FDT_ERR_BADSTATE;
|
||||
}
|
||||
} else {
|
||||
return -FDT_ERR_BADMAGIC;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
const void *fdt_offset_ptr(const void *fdt, int offset, unsigned int len)
|
||||
const void *
|
||||
fdt_offset_ptr (
|
||||
const void *fdt,
|
||||
int offset,
|
||||
unsigned int len
|
||||
)
|
||||
{
|
||||
unsigned absoffset = offset + fdt_off_dt_struct(fdt);
|
||||
unsigned absoffset = offset + fdt_off_dt_struct (fdt);
|
||||
|
||||
if ((absoffset < offset)
|
||||
|| ((absoffset + len) < absoffset)
|
||||
|| (absoffset + len) > fdt_totalsize(fdt))
|
||||
return NULL;
|
||||
if ( (absoffset < offset)
|
||||
|| ((absoffset + len) < absoffset)
|
||||
|| ((absoffset + len) > fdt_totalsize (fdt)))
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (fdt_version(fdt) >= 0x11)
|
||||
if (((offset + len) < offset)
|
||||
|| ((offset + len) > fdt_size_dt_struct(fdt)))
|
||||
return NULL;
|
||||
if (fdt_version (fdt) >= 0x11) {
|
||||
if ( ((offset + len) < offset)
|
||||
|| ((offset + len) > fdt_size_dt_struct (fdt)))
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
return _fdt_offset_ptr(fdt, offset);
|
||||
return _fdt_offset_ptr (fdt, offset);
|
||||
}
|
||||
|
||||
uint32_t fdt_next_tag(const void *fdt, int startoffset, int *nextoffset)
|
||||
uint32_t
|
||||
fdt_next_tag (
|
||||
const void *fdt,
|
||||
int startoffset,
|
||||
int *nextoffset
|
||||
)
|
||||
{
|
||||
const fdt32_t *tagp, *lenp;
|
||||
uint32_t tag;
|
||||
int offset = startoffset;
|
||||
const char *p;
|
||||
const fdt32_t *tagp, *lenp;
|
||||
uint32_t tag;
|
||||
int offset = startoffset;
|
||||
const char *p;
|
||||
|
||||
*nextoffset = -FDT_ERR_TRUNCATED;
|
||||
tagp = fdt_offset_ptr(fdt, offset, FDT_TAGSIZE);
|
||||
if (!tagp)
|
||||
return FDT_END; /* premature end */
|
||||
tag = fdt32_to_cpu(*tagp);
|
||||
offset += FDT_TAGSIZE;
|
||||
*nextoffset = -FDT_ERR_TRUNCATED;
|
||||
tagp = fdt_offset_ptr (fdt, offset, FDT_TAGSIZE);
|
||||
if (!tagp) {
|
||||
return FDT_END; /* premature end */
|
||||
}
|
||||
|
||||
*nextoffset = -FDT_ERR_BADSTRUCTURE;
|
||||
switch (tag) {
|
||||
case FDT_BEGIN_NODE:
|
||||
/* skip name */
|
||||
do {
|
||||
p = fdt_offset_ptr(fdt, offset++, 1);
|
||||
} while (p && (*p != '\0'));
|
||||
if (!p)
|
||||
return FDT_END; /* premature end */
|
||||
break;
|
||||
tag = fdt32_to_cpu (*tagp);
|
||||
offset += FDT_TAGSIZE;
|
||||
|
||||
case FDT_PROP:
|
||||
lenp = fdt_offset_ptr(fdt, offset, sizeof(*lenp));
|
||||
if (!lenp)
|
||||
return FDT_END; /* premature end */
|
||||
/* skip-name offset, length and value */
|
||||
offset += sizeof(struct fdt_property) - FDT_TAGSIZE
|
||||
+ fdt32_to_cpu(*lenp);
|
||||
break;
|
||||
*nextoffset = -FDT_ERR_BADSTRUCTURE;
|
||||
switch (tag) {
|
||||
case FDT_BEGIN_NODE:
|
||||
/* skip name */
|
||||
do {
|
||||
p = fdt_offset_ptr (fdt, offset++, 1);
|
||||
} while (p && (*p != '\0'));
|
||||
|
||||
case FDT_END:
|
||||
case FDT_END_NODE:
|
||||
case FDT_NOP:
|
||||
break;
|
||||
if (!p) {
|
||||
return FDT_END; /* premature end */
|
||||
}
|
||||
|
||||
default:
|
||||
return FDT_END;
|
||||
}
|
||||
break;
|
||||
|
||||
if (!fdt_offset_ptr(fdt, startoffset, offset - startoffset))
|
||||
return FDT_END; /* premature end */
|
||||
case FDT_PROP:
|
||||
lenp = fdt_offset_ptr (fdt, offset, sizeof (*lenp));
|
||||
if (!lenp) {
|
||||
return FDT_END; /* premature end */
|
||||
}
|
||||
|
||||
*nextoffset = FDT_TAGALIGN(offset);
|
||||
return tag;
|
||||
/* skip-name offset, length and value */
|
||||
offset += sizeof (struct fdt_property) - FDT_TAGSIZE
|
||||
+ fdt32_to_cpu (*lenp);
|
||||
break;
|
||||
|
||||
case FDT_END:
|
||||
case FDT_END_NODE:
|
||||
case FDT_NOP:
|
||||
break;
|
||||
|
||||
default:
|
||||
return FDT_END;
|
||||
}
|
||||
|
||||
if (!fdt_offset_ptr (fdt, startoffset, offset - startoffset)) {
|
||||
return FDT_END; /* premature end */
|
||||
}
|
||||
|
||||
*nextoffset = FDT_TAGALIGN (offset);
|
||||
return tag;
|
||||
}
|
||||
|
||||
int _fdt_check_node_offset(const void *fdt, int offset)
|
||||
int
|
||||
_fdt_check_node_offset (
|
||||
const void *fdt,
|
||||
int offset
|
||||
)
|
||||
{
|
||||
if ((offset < 0) || (offset % FDT_TAGSIZE)
|
||||
|| (fdt_next_tag(fdt, offset, &offset) != FDT_BEGIN_NODE))
|
||||
return -FDT_ERR_BADOFFSET;
|
||||
if ( (offset < 0) || (offset % FDT_TAGSIZE)
|
||||
|| (fdt_next_tag (fdt, offset, &offset) != FDT_BEGIN_NODE))
|
||||
{
|
||||
return -FDT_ERR_BADOFFSET;
|
||||
}
|
||||
|
||||
return offset;
|
||||
return offset;
|
||||
}
|
||||
|
||||
int _fdt_check_prop_offset(const void *fdt, int offset)
|
||||
int
|
||||
_fdt_check_prop_offset (
|
||||
const void *fdt,
|
||||
int offset
|
||||
)
|
||||
{
|
||||
if ((offset < 0) || (offset % FDT_TAGSIZE)
|
||||
|| (fdt_next_tag(fdt, offset, &offset) != FDT_PROP))
|
||||
return -FDT_ERR_BADOFFSET;
|
||||
if ( (offset < 0) || (offset % FDT_TAGSIZE)
|
||||
|| (fdt_next_tag (fdt, offset, &offset) != FDT_PROP))
|
||||
{
|
||||
return -FDT_ERR_BADOFFSET;
|
||||
}
|
||||
|
||||
return offset;
|
||||
return offset;
|
||||
}
|
||||
|
||||
int fdt_next_node(const void *fdt, int offset, int *depth)
|
||||
int
|
||||
fdt_next_node (
|
||||
const void *fdt,
|
||||
int offset,
|
||||
int *depth
|
||||
)
|
||||
{
|
||||
int nextoffset = 0;
|
||||
uint32_t tag;
|
||||
int nextoffset = 0;
|
||||
uint32_t tag;
|
||||
|
||||
if (offset >= 0)
|
||||
if ((nextoffset = _fdt_check_node_offset(fdt, offset)) < 0)
|
||||
return nextoffset;
|
||||
if (offset >= 0) {
|
||||
if ((nextoffset = _fdt_check_node_offset (fdt, offset)) < 0) {
|
||||
return nextoffset;
|
||||
}
|
||||
}
|
||||
|
||||
do {
|
||||
offset = nextoffset;
|
||||
tag = fdt_next_tag(fdt, offset, &nextoffset);
|
||||
do {
|
||||
offset = nextoffset;
|
||||
tag = fdt_next_tag (fdt, offset, &nextoffset);
|
||||
|
||||
switch (tag) {
|
||||
case FDT_PROP:
|
||||
case FDT_NOP:
|
||||
break;
|
||||
switch (tag) {
|
||||
case FDT_PROP:
|
||||
case FDT_NOP:
|
||||
break;
|
||||
|
||||
case FDT_BEGIN_NODE:
|
||||
if (depth)
|
||||
(*depth)++;
|
||||
break;
|
||||
case FDT_BEGIN_NODE:
|
||||
if (depth) {
|
||||
(*depth)++;
|
||||
}
|
||||
|
||||
case FDT_END_NODE:
|
||||
if (depth && ((--(*depth)) < 0))
|
||||
return nextoffset;
|
||||
break;
|
||||
break;
|
||||
|
||||
case FDT_END:
|
||||
if ((nextoffset >= 0)
|
||||
|| ((nextoffset == -FDT_ERR_TRUNCATED) && !depth))
|
||||
return -FDT_ERR_NOTFOUND;
|
||||
else
|
||||
return nextoffset;
|
||||
}
|
||||
} while (tag != FDT_BEGIN_NODE);
|
||||
case FDT_END_NODE:
|
||||
if (depth && ((--(*depth)) < 0)) {
|
||||
return nextoffset;
|
||||
}
|
||||
|
||||
return offset;
|
||||
break;
|
||||
|
||||
case FDT_END:
|
||||
if ( (nextoffset >= 0)
|
||||
|| ((nextoffset == -FDT_ERR_TRUNCATED) && !depth))
|
||||
{
|
||||
return -FDT_ERR_NOTFOUND;
|
||||
} else {
|
||||
return nextoffset;
|
||||
}
|
||||
}
|
||||
} while (tag != FDT_BEGIN_NODE);
|
||||
|
||||
return offset;
|
||||
}
|
||||
|
||||
int fdt_first_subnode(const void *fdt, int offset)
|
||||
int
|
||||
fdt_first_subnode (
|
||||
const void *fdt,
|
||||
int offset
|
||||
)
|
||||
{
|
||||
int depth = 0;
|
||||
int depth = 0;
|
||||
|
||||
offset = fdt_next_node(fdt, offset, &depth);
|
||||
if (offset < 0 || depth != 1)
|
||||
return -FDT_ERR_NOTFOUND;
|
||||
offset = fdt_next_node (fdt, offset, &depth);
|
||||
if ((offset < 0) || (depth != 1)) {
|
||||
return -FDT_ERR_NOTFOUND;
|
||||
}
|
||||
|
||||
return offset;
|
||||
return offset;
|
||||
}
|
||||
|
||||
int fdt_next_subnode(const void *fdt, int offset)
|
||||
int
|
||||
fdt_next_subnode (
|
||||
const void *fdt,
|
||||
int offset
|
||||
)
|
||||
{
|
||||
int depth = 1;
|
||||
int depth = 1;
|
||||
|
||||
/*
|
||||
* With respect to the parent, the depth of the next subnode will be
|
||||
* the same as the last.
|
||||
*/
|
||||
do {
|
||||
offset = fdt_next_node(fdt, offset, &depth);
|
||||
if (offset < 0 || depth < 1)
|
||||
return -FDT_ERR_NOTFOUND;
|
||||
} while (depth > 1);
|
||||
/*
|
||||
* With respect to the parent, the depth of the next subnode will be
|
||||
* the same as the last.
|
||||
*/
|
||||
do {
|
||||
offset = fdt_next_node (fdt, offset, &depth);
|
||||
if ((offset < 0) || (depth < 1)) {
|
||||
return -FDT_ERR_NOTFOUND;
|
||||
}
|
||||
} while (depth > 1);
|
||||
|
||||
return offset;
|
||||
return offset;
|
||||
}
|
||||
|
||||
const char *_fdt_find_string(const char *strtab, int tabsize, const char *s)
|
||||
const char *
|
||||
_fdt_find_string (
|
||||
const char *strtab,
|
||||
int tabsize,
|
||||
const char *s
|
||||
)
|
||||
{
|
||||
int len = strlen(s) + 1;
|
||||
const char *last = strtab + tabsize - len;
|
||||
const char *p;
|
||||
int len = strlen (s) + 1;
|
||||
const char *last = strtab + tabsize - len;
|
||||
const char *p;
|
||||
|
||||
for (p = strtab; p <= last; p++)
|
||||
if (memcmp(p, s, len) == 0)
|
||||
return p;
|
||||
return NULL;
|
||||
for (p = strtab; p <= last; p++) {
|
||||
if (memcmp (p, s, len) == 0) {
|
||||
return p;
|
||||
}
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int fdt_move(const void *fdt, void *buf, int bufsize)
|
||||
int
|
||||
fdt_move (
|
||||
const void *fdt,
|
||||
void *buf,
|
||||
int bufsize
|
||||
)
|
||||
{
|
||||
FDT_CHECK_HEADER(fdt);
|
||||
FDT_CHECK_HEADER (fdt);
|
||||
|
||||
if (fdt_totalsize(fdt) > bufsize)
|
||||
return -FDT_ERR_NOSPACE;
|
||||
if (fdt_totalsize (fdt) > bufsize) {
|
||||
return -FDT_ERR_NOSPACE;
|
||||
}
|
||||
|
||||
memmove(buf, fdt, fdt_totalsize(fdt));
|
||||
return 0;
|
||||
memmove (buf, fdt, fdt_totalsize (fdt));
|
||||
return 0;
|
||||
}
|
||||
|
@@ -55,42 +55,56 @@
|
||||
|
||||
#include "libfdt_internal.h"
|
||||
|
||||
int fdt_address_cells(const void *fdt, int nodeoffset)
|
||||
int
|
||||
fdt_address_cells (
|
||||
const void *fdt,
|
||||
int nodeoffset
|
||||
)
|
||||
{
|
||||
const fdt32_t *ac;
|
||||
int val;
|
||||
int len;
|
||||
const fdt32_t *ac;
|
||||
int val;
|
||||
int len;
|
||||
|
||||
ac = fdt_getprop(fdt, nodeoffset, "#address-cells", &len);
|
||||
if (!ac)
|
||||
return 2;
|
||||
ac = fdt_getprop (fdt, nodeoffset, "#address-cells", &len);
|
||||
if (!ac) {
|
||||
return 2;
|
||||
}
|
||||
|
||||
if (len != sizeof(*ac))
|
||||
return -FDT_ERR_BADNCELLS;
|
||||
if (len != sizeof (*ac)) {
|
||||
return -FDT_ERR_BADNCELLS;
|
||||
}
|
||||
|
||||
val = fdt32_to_cpu(*ac);
|
||||
if ((val <= 0) || (val > FDT_MAX_NCELLS))
|
||||
return -FDT_ERR_BADNCELLS;
|
||||
val = fdt32_to_cpu (*ac);
|
||||
if ((val <= 0) || (val > FDT_MAX_NCELLS)) {
|
||||
return -FDT_ERR_BADNCELLS;
|
||||
}
|
||||
|
||||
return val;
|
||||
return val;
|
||||
}
|
||||
|
||||
int fdt_size_cells(const void *fdt, int nodeoffset)
|
||||
int
|
||||
fdt_size_cells (
|
||||
const void *fdt,
|
||||
int nodeoffset
|
||||
)
|
||||
{
|
||||
const fdt32_t *sc;
|
||||
int val;
|
||||
int len;
|
||||
const fdt32_t *sc;
|
||||
int val;
|
||||
int len;
|
||||
|
||||
sc = fdt_getprop(fdt, nodeoffset, "#size-cells", &len);
|
||||
if (!sc)
|
||||
return 2;
|
||||
sc = fdt_getprop (fdt, nodeoffset, "#size-cells", &len);
|
||||
if (!sc) {
|
||||
return 2;
|
||||
}
|
||||
|
||||
if (len != sizeof(*sc))
|
||||
return -FDT_ERR_BADNCELLS;
|
||||
if (len != sizeof (*sc)) {
|
||||
return -FDT_ERR_BADNCELLS;
|
||||
}
|
||||
|
||||
val = fdt32_to_cpu(*sc);
|
||||
if ((val < 0) || (val > FDT_MAX_NCELLS))
|
||||
return -FDT_ERR_BADNCELLS;
|
||||
val = fdt32_to_cpu (*sc);
|
||||
if ((val < 0) || (val > FDT_MAX_NCELLS)) {
|
||||
return -FDT_ERR_BADNCELLS;
|
||||
}
|
||||
|
||||
return val;
|
||||
return val;
|
||||
}
|
||||
|
@@ -55,29 +55,38 @@
|
||||
|
||||
#include "libfdt_internal.h"
|
||||
|
||||
int fdt_create_empty_tree(void *buf, int bufsize)
|
||||
int
|
||||
fdt_create_empty_tree (
|
||||
void *buf,
|
||||
int bufsize
|
||||
)
|
||||
{
|
||||
int err;
|
||||
int err;
|
||||
|
||||
err = fdt_create(buf, bufsize);
|
||||
if (err)
|
||||
return err;
|
||||
err = fdt_create (buf, bufsize);
|
||||
if (err) {
|
||||
return err;
|
||||
}
|
||||
|
||||
err = fdt_finish_reservemap(buf);
|
||||
if (err)
|
||||
return err;
|
||||
err = fdt_finish_reservemap (buf);
|
||||
if (err) {
|
||||
return err;
|
||||
}
|
||||
|
||||
err = fdt_begin_node(buf, "");
|
||||
if (err)
|
||||
return err;
|
||||
err = fdt_begin_node (buf, "");
|
||||
if (err) {
|
||||
return err;
|
||||
}
|
||||
|
||||
err = fdt_end_node(buf);
|
||||
if (err)
|
||||
return err;
|
||||
err = fdt_end_node (buf);
|
||||
if (err) {
|
||||
return err;
|
||||
}
|
||||
|
||||
err = fdt_finish(buf);
|
||||
if (err)
|
||||
return err;
|
||||
err = fdt_finish (buf);
|
||||
if (err) {
|
||||
return err;
|
||||
}
|
||||
|
||||
return fdt_open_into(buf, buf, bufsize);
|
||||
return fdt_open_into (buf, buf, bufsize);
|
||||
}
|
||||
|
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -55,451 +55,632 @@
|
||||
|
||||
#include "libfdt_internal.h"
|
||||
|
||||
static int _fdt_blocks_misordered(const void *fdt,
|
||||
int mem_rsv_size, int struct_size)
|
||||
static int
|
||||
_fdt_blocks_misordered (
|
||||
const void *fdt,
|
||||
int mem_rsv_size,
|
||||
int struct_size
|
||||
)
|
||||
{
|
||||
return (fdt_off_mem_rsvmap(fdt) < FDT_ALIGN(sizeof(struct fdt_header), 8))
|
||||
|| (fdt_off_dt_struct(fdt) <
|
||||
(fdt_off_mem_rsvmap(fdt) + mem_rsv_size))
|
||||
|| (fdt_off_dt_strings(fdt) <
|
||||
(fdt_off_dt_struct(fdt) + struct_size))
|
||||
|| (fdt_totalsize(fdt) <
|
||||
(fdt_off_dt_strings(fdt) + fdt_size_dt_strings(fdt)));
|
||||
return (fdt_off_mem_rsvmap (fdt) < FDT_ALIGN (sizeof (struct fdt_header), 8))
|
||||
|| (fdt_off_dt_struct (fdt) <
|
||||
(fdt_off_mem_rsvmap (fdt) + mem_rsv_size))
|
||||
|| (fdt_off_dt_strings (fdt) <
|
||||
(fdt_off_dt_struct (fdt) + struct_size))
|
||||
|| (fdt_totalsize (fdt) <
|
||||
(fdt_off_dt_strings (fdt) + fdt_size_dt_strings (fdt)));
|
||||
}
|
||||
|
||||
static int _fdt_rw_check_header(void *fdt)
|
||||
static int
|
||||
_fdt_rw_check_header (
|
||||
void *fdt
|
||||
)
|
||||
{
|
||||
FDT_CHECK_HEADER(fdt);
|
||||
FDT_CHECK_HEADER (fdt);
|
||||
|
||||
if (fdt_version(fdt) < 17)
|
||||
return -FDT_ERR_BADVERSION;
|
||||
if (_fdt_blocks_misordered(fdt, sizeof(struct fdt_reserve_entry),
|
||||
fdt_size_dt_struct(fdt)))
|
||||
return -FDT_ERR_BADLAYOUT;
|
||||
if (fdt_version(fdt) > 17)
|
||||
fdt_set_version(fdt, 17);
|
||||
if (fdt_version (fdt) < 17) {
|
||||
return -FDT_ERR_BADVERSION;
|
||||
}
|
||||
|
||||
return 0;
|
||||
if (_fdt_blocks_misordered (
|
||||
fdt,
|
||||
sizeof (struct fdt_reserve_entry),
|
||||
fdt_size_dt_struct (fdt)
|
||||
))
|
||||
{
|
||||
return -FDT_ERR_BADLAYOUT;
|
||||
}
|
||||
|
||||
if (fdt_version (fdt) > 17) {
|
||||
fdt_set_version (fdt, 17);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
#define FDT_RW_CHECK_HEADER(fdt) \
|
||||
{ \
|
||||
int __err; \
|
||||
if ((__err = _fdt_rw_check_header(fdt)) != 0) \
|
||||
return __err; \
|
||||
}
|
||||
{ \
|
||||
int __err; \
|
||||
if ((__err = _fdt_rw_check_header(fdt)) != 0) \
|
||||
return __err; \
|
||||
}
|
||||
|
||||
static inline int _fdt_data_size(void *fdt)
|
||||
static inline int
|
||||
_fdt_data_size (
|
||||
void *fdt
|
||||
)
|
||||
{
|
||||
return fdt_off_dt_strings(fdt) + fdt_size_dt_strings(fdt);
|
||||
return fdt_off_dt_strings (fdt) + fdt_size_dt_strings (fdt);
|
||||
}
|
||||
|
||||
static int _fdt_splice(void *fdt, void *splicepoint, int oldlen, int newlen)
|
||||
static int
|
||||
_fdt_splice (
|
||||
void *fdt,
|
||||
void *splicepoint,
|
||||
int oldlen,
|
||||
int newlen
|
||||
)
|
||||
{
|
||||
char *p = splicepoint;
|
||||
char *end = (char *)fdt + _fdt_data_size(fdt);
|
||||
char *p = splicepoint;
|
||||
char *end = (char *)fdt + _fdt_data_size (fdt);
|
||||
|
||||
if (((p + oldlen) < p) || ((p + oldlen) > end))
|
||||
return -FDT_ERR_BADOFFSET;
|
||||
if ((p < (char *)fdt) || ((end - oldlen + newlen) < (char *)fdt))
|
||||
return -FDT_ERR_BADOFFSET;
|
||||
if ((end - oldlen + newlen) > ((char *)fdt + fdt_totalsize(fdt)))
|
||||
return -FDT_ERR_NOSPACE;
|
||||
memmove(p + newlen, p + oldlen, end - p - oldlen);
|
||||
return 0;
|
||||
if (((p + oldlen) < p) || ((p + oldlen) > end)) {
|
||||
return -FDT_ERR_BADOFFSET;
|
||||
}
|
||||
|
||||
if ((p < (char *)fdt) || ((end - oldlen + newlen) < (char *)fdt)) {
|
||||
return -FDT_ERR_BADOFFSET;
|
||||
}
|
||||
|
||||
if ((end - oldlen + newlen) > ((char *)fdt + fdt_totalsize (fdt))) {
|
||||
return -FDT_ERR_NOSPACE;
|
||||
}
|
||||
|
||||
memmove (p + newlen, p + oldlen, end - p - oldlen);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int _fdt_splice_mem_rsv(void *fdt, struct fdt_reserve_entry *p,
|
||||
int oldn, int newn)
|
||||
static int
|
||||
_fdt_splice_mem_rsv (
|
||||
void *fdt,
|
||||
struct fdt_reserve_entry *p,
|
||||
int oldn,
|
||||
int newn
|
||||
)
|
||||
{
|
||||
int delta = (newn - oldn) * sizeof(*p);
|
||||
int err;
|
||||
err = _fdt_splice(fdt, p, oldn * sizeof(*p), newn * sizeof(*p));
|
||||
if (err)
|
||||
return err;
|
||||
fdt_set_off_dt_struct(fdt, fdt_off_dt_struct(fdt) + delta);
|
||||
fdt_set_off_dt_strings(fdt, fdt_off_dt_strings(fdt) + delta);
|
||||
return 0;
|
||||
int delta = (newn - oldn) * sizeof (*p);
|
||||
int err;
|
||||
|
||||
err = _fdt_splice (fdt, p, oldn * sizeof (*p), newn * sizeof (*p));
|
||||
if (err) {
|
||||
return err;
|
||||
}
|
||||
|
||||
fdt_set_off_dt_struct (fdt, fdt_off_dt_struct (fdt) + delta);
|
||||
fdt_set_off_dt_strings (fdt, fdt_off_dt_strings (fdt) + delta);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int _fdt_splice_struct(void *fdt, void *p,
|
||||
int oldlen, int newlen)
|
||||
static int
|
||||
_fdt_splice_struct (
|
||||
void *fdt,
|
||||
void *p,
|
||||
int oldlen,
|
||||
int newlen
|
||||
)
|
||||
{
|
||||
int delta = newlen - oldlen;
|
||||
int err;
|
||||
int delta = newlen - oldlen;
|
||||
int err;
|
||||
|
||||
if ((err = _fdt_splice(fdt, p, oldlen, newlen)))
|
||||
return err;
|
||||
if ((err = _fdt_splice (fdt, p, oldlen, newlen))) {
|
||||
return err;
|
||||
}
|
||||
|
||||
fdt_set_size_dt_struct(fdt, fdt_size_dt_struct(fdt) + delta);
|
||||
fdt_set_off_dt_strings(fdt, fdt_off_dt_strings(fdt) + delta);
|
||||
return 0;
|
||||
fdt_set_size_dt_struct (fdt, fdt_size_dt_struct (fdt) + delta);
|
||||
fdt_set_off_dt_strings (fdt, fdt_off_dt_strings (fdt) + delta);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int _fdt_splice_string(void *fdt, int newlen)
|
||||
static int
|
||||
_fdt_splice_string (
|
||||
void *fdt,
|
||||
int newlen
|
||||
)
|
||||
{
|
||||
void *p = (char *)fdt
|
||||
+ fdt_off_dt_strings(fdt) + fdt_size_dt_strings(fdt);
|
||||
int err;
|
||||
void *p = (char *)fdt
|
||||
+ fdt_off_dt_strings (fdt) + fdt_size_dt_strings (fdt);
|
||||
int err;
|
||||
|
||||
if ((err = _fdt_splice(fdt, p, 0, newlen)))
|
||||
return err;
|
||||
if ((err = _fdt_splice (fdt, p, 0, newlen))) {
|
||||
return err;
|
||||
}
|
||||
|
||||
fdt_set_size_dt_strings(fdt, fdt_size_dt_strings(fdt) + newlen);
|
||||
return 0;
|
||||
fdt_set_size_dt_strings (fdt, fdt_size_dt_strings (fdt) + newlen);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int _fdt_find_add_string(void *fdt, const char *s)
|
||||
static int
|
||||
_fdt_find_add_string (
|
||||
void *fdt,
|
||||
const char *s
|
||||
)
|
||||
{
|
||||
char *strtab = (char *)fdt + fdt_off_dt_strings(fdt);
|
||||
const char *p;
|
||||
char *new;
|
||||
int len = strlen(s) + 1;
|
||||
int err;
|
||||
char *strtab = (char *)fdt + fdt_off_dt_strings (fdt);
|
||||
const char *p;
|
||||
char *new;
|
||||
int len = strlen (s) + 1;
|
||||
int err;
|
||||
|
||||
p = _fdt_find_string(strtab, fdt_size_dt_strings(fdt), s);
|
||||
if (p)
|
||||
/* found it */
|
||||
return (p - strtab);
|
||||
p = _fdt_find_string (strtab, fdt_size_dt_strings (fdt), s);
|
||||
if (p) {
|
||||
/* found it */
|
||||
return (p - strtab);
|
||||
}
|
||||
|
||||
new = strtab + fdt_size_dt_strings(fdt);
|
||||
err = _fdt_splice_string(fdt, len);
|
||||
if (err)
|
||||
return err;
|
||||
new = strtab + fdt_size_dt_strings (fdt);
|
||||
err = _fdt_splice_string (fdt, len);
|
||||
if (err) {
|
||||
return err;
|
||||
}
|
||||
|
||||
memcpy(new, s, len);
|
||||
return (new - strtab);
|
||||
memcpy (new, s, len);
|
||||
return (new - strtab);
|
||||
}
|
||||
|
||||
int fdt_add_mem_rsv(void *fdt, uint64_t address, uint64_t size)
|
||||
int
|
||||
fdt_add_mem_rsv (
|
||||
void *fdt,
|
||||
uint64_t address,
|
||||
uint64_t size
|
||||
)
|
||||
{
|
||||
struct fdt_reserve_entry *re;
|
||||
int err;
|
||||
struct fdt_reserve_entry *re;
|
||||
int err;
|
||||
|
||||
FDT_RW_CHECK_HEADER(fdt);
|
||||
FDT_RW_CHECK_HEADER (fdt);
|
||||
|
||||
re = _fdt_mem_rsv_w(fdt, fdt_num_mem_rsv(fdt));
|
||||
err = _fdt_splice_mem_rsv(fdt, re, 0, 1);
|
||||
if (err)
|
||||
return err;
|
||||
re = _fdt_mem_rsv_w (fdt, fdt_num_mem_rsv (fdt));
|
||||
err = _fdt_splice_mem_rsv (fdt, re, 0, 1);
|
||||
if (err) {
|
||||
return err;
|
||||
}
|
||||
|
||||
re->address = cpu_to_fdt64(address);
|
||||
re->size = cpu_to_fdt64(size);
|
||||
return 0;
|
||||
re->address = cpu_to_fdt64 (address);
|
||||
re->size = cpu_to_fdt64 (size);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int fdt_del_mem_rsv(void *fdt, int n)
|
||||
int
|
||||
fdt_del_mem_rsv (
|
||||
void *fdt,
|
||||
int n
|
||||
)
|
||||
{
|
||||
struct fdt_reserve_entry *re = _fdt_mem_rsv_w(fdt, n);
|
||||
struct fdt_reserve_entry *re = _fdt_mem_rsv_w (fdt, n);
|
||||
|
||||
FDT_RW_CHECK_HEADER(fdt);
|
||||
FDT_RW_CHECK_HEADER (fdt);
|
||||
|
||||
if (n >= fdt_num_mem_rsv(fdt))
|
||||
return -FDT_ERR_NOTFOUND;
|
||||
if (n >= fdt_num_mem_rsv (fdt)) {
|
||||
return -FDT_ERR_NOTFOUND;
|
||||
}
|
||||
|
||||
return _fdt_splice_mem_rsv(fdt, re, 1, 0);
|
||||
return _fdt_splice_mem_rsv (fdt, re, 1, 0);
|
||||
}
|
||||
|
||||
static int _fdt_resize_property(void *fdt, int nodeoffset, const char *name,
|
||||
int len, struct fdt_property **prop)
|
||||
static int
|
||||
_fdt_resize_property (
|
||||
void *fdt,
|
||||
int nodeoffset,
|
||||
const char *name,
|
||||
int len,
|
||||
struct fdt_property **prop
|
||||
)
|
||||
{
|
||||
int oldlen;
|
||||
int err;
|
||||
int oldlen;
|
||||
int err;
|
||||
|
||||
*prop = fdt_get_property_w(fdt, nodeoffset, name, &oldlen);
|
||||
if (!*prop)
|
||||
return oldlen;
|
||||
*prop = fdt_get_property_w (fdt, nodeoffset, name, &oldlen);
|
||||
if (!*prop) {
|
||||
return oldlen;
|
||||
}
|
||||
|
||||
if ((err = _fdt_splice_struct(fdt, (*prop)->data, FDT_TAGALIGN(oldlen),
|
||||
FDT_TAGALIGN(len))))
|
||||
return err;
|
||||
if ((err = _fdt_splice_struct (
|
||||
fdt,
|
||||
(*prop)->data,
|
||||
FDT_TAGALIGN (oldlen),
|
||||
FDT_TAGALIGN (len)
|
||||
)))
|
||||
{
|
||||
return err;
|
||||
}
|
||||
|
||||
(*prop)->len = cpu_to_fdt32(len);
|
||||
return 0;
|
||||
(*prop)->len = cpu_to_fdt32 (len);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int _fdt_add_property(void *fdt, int nodeoffset, const char *name,
|
||||
int len, struct fdt_property **prop)
|
||||
static int
|
||||
_fdt_add_property (
|
||||
void *fdt,
|
||||
int nodeoffset,
|
||||
const char *name,
|
||||
int len,
|
||||
struct fdt_property **prop
|
||||
)
|
||||
{
|
||||
int proplen;
|
||||
int nextoffset;
|
||||
int namestroff;
|
||||
int err;
|
||||
int proplen;
|
||||
int nextoffset;
|
||||
int namestroff;
|
||||
int err;
|
||||
|
||||
if ((nextoffset = _fdt_check_node_offset(fdt, nodeoffset)) < 0)
|
||||
return nextoffset;
|
||||
if ((nextoffset = _fdt_check_node_offset (fdt, nodeoffset)) < 0) {
|
||||
return nextoffset;
|
||||
}
|
||||
|
||||
namestroff = _fdt_find_add_string(fdt, name);
|
||||
if (namestroff < 0)
|
||||
return namestroff;
|
||||
namestroff = _fdt_find_add_string (fdt, name);
|
||||
if (namestroff < 0) {
|
||||
return namestroff;
|
||||
}
|
||||
|
||||
*prop = _fdt_offset_ptr_w(fdt, nextoffset);
|
||||
proplen = sizeof(**prop) + FDT_TAGALIGN(len);
|
||||
*prop = _fdt_offset_ptr_w (fdt, nextoffset);
|
||||
proplen = sizeof (**prop) + FDT_TAGALIGN (len);
|
||||
|
||||
err = _fdt_splice_struct(fdt, *prop, 0, proplen);
|
||||
if (err)
|
||||
return err;
|
||||
err = _fdt_splice_struct (fdt, *prop, 0, proplen);
|
||||
if (err) {
|
||||
return err;
|
||||
}
|
||||
|
||||
(*prop)->tag = cpu_to_fdt32(FDT_PROP);
|
||||
(*prop)->nameoff = cpu_to_fdt32(namestroff);
|
||||
(*prop)->len = cpu_to_fdt32(len);
|
||||
return 0;
|
||||
(*prop)->tag = cpu_to_fdt32 (FDT_PROP);
|
||||
(*prop)->nameoff = cpu_to_fdt32 (namestroff);
|
||||
(*prop)->len = cpu_to_fdt32 (len);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int fdt_set_name(void *fdt, int nodeoffset, const char *name)
|
||||
int
|
||||
fdt_set_name (
|
||||
void *fdt,
|
||||
int nodeoffset,
|
||||
const char *name
|
||||
)
|
||||
{
|
||||
char *namep;
|
||||
int oldlen, newlen;
|
||||
int err;
|
||||
char *namep;
|
||||
int oldlen, newlen;
|
||||
int err;
|
||||
|
||||
FDT_RW_CHECK_HEADER(fdt);
|
||||
FDT_RW_CHECK_HEADER (fdt);
|
||||
|
||||
namep = (char *)(uintptr_t)fdt_get_name(fdt, nodeoffset, &oldlen);
|
||||
if (!namep)
|
||||
return oldlen;
|
||||
namep = (char *)(uintptr_t)fdt_get_name (fdt, nodeoffset, &oldlen);
|
||||
if (!namep) {
|
||||
return oldlen;
|
||||
}
|
||||
|
||||
newlen = strlen(name);
|
||||
newlen = strlen (name);
|
||||
|
||||
err = _fdt_splice_struct(fdt, namep, FDT_TAGALIGN(oldlen+1),
|
||||
FDT_TAGALIGN(newlen+1));
|
||||
if (err)
|
||||
return err;
|
||||
err = _fdt_splice_struct (
|
||||
fdt,
|
||||
namep,
|
||||
FDT_TAGALIGN (oldlen+1),
|
||||
FDT_TAGALIGN (newlen+1)
|
||||
);
|
||||
if (err) {
|
||||
return err;
|
||||
}
|
||||
|
||||
memcpy(namep, name, newlen+1);
|
||||
return 0;
|
||||
memcpy (namep, name, newlen+1);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int fdt_setprop_placeholder(void *fdt, int nodeoffset, const char *name,
|
||||
int len, void **prop_data)
|
||||
int
|
||||
fdt_setprop_placeholder (
|
||||
void *fdt,
|
||||
int nodeoffset,
|
||||
const char *name,
|
||||
int len,
|
||||
void **prop_data
|
||||
)
|
||||
{
|
||||
struct fdt_property *prop;
|
||||
int err;
|
||||
struct fdt_property *prop;
|
||||
int err;
|
||||
|
||||
FDT_RW_CHECK_HEADER(fdt);
|
||||
FDT_RW_CHECK_HEADER (fdt);
|
||||
|
||||
err = _fdt_resize_property(fdt, nodeoffset, name, len, &prop);
|
||||
if (err == -FDT_ERR_NOTFOUND)
|
||||
err = _fdt_add_property(fdt, nodeoffset, name, len, &prop);
|
||||
if (err)
|
||||
return err;
|
||||
err = _fdt_resize_property (fdt, nodeoffset, name, len, &prop);
|
||||
if (err == -FDT_ERR_NOTFOUND) {
|
||||
err = _fdt_add_property (fdt, nodeoffset, name, len, &prop);
|
||||
}
|
||||
|
||||
*prop_data = prop->data;
|
||||
return 0;
|
||||
if (err) {
|
||||
return err;
|
||||
}
|
||||
|
||||
*prop_data = prop->data;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int fdt_setprop(void *fdt, int nodeoffset, const char *name,
|
||||
const void *val, int len)
|
||||
int
|
||||
fdt_setprop (
|
||||
void *fdt,
|
||||
int nodeoffset,
|
||||
const char *name,
|
||||
const void *val,
|
||||
int len
|
||||
)
|
||||
{
|
||||
void *prop_data;
|
||||
int err;
|
||||
void *prop_data;
|
||||
int err;
|
||||
|
||||
err = fdt_setprop_placeholder(fdt, nodeoffset, name, len, &prop_data);
|
||||
if (err)
|
||||
return err;
|
||||
err = fdt_setprop_placeholder (fdt, nodeoffset, name, len, &prop_data);
|
||||
if (err) {
|
||||
return err;
|
||||
}
|
||||
|
||||
if (len)
|
||||
memcpy(prop_data, val, len);
|
||||
return 0;
|
||||
if (len) {
|
||||
memcpy (prop_data, val, len);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int fdt_appendprop(void *fdt, int nodeoffset, const char *name,
|
||||
const void *val, int len)
|
||||
int
|
||||
fdt_appendprop (
|
||||
void *fdt,
|
||||
int nodeoffset,
|
||||
const char *name,
|
||||
const void *val,
|
||||
int len
|
||||
)
|
||||
{
|
||||
struct fdt_property *prop;
|
||||
int err, oldlen, newlen;
|
||||
struct fdt_property *prop;
|
||||
int err, oldlen, newlen;
|
||||
|
||||
FDT_RW_CHECK_HEADER(fdt);
|
||||
FDT_RW_CHECK_HEADER (fdt);
|
||||
|
||||
prop = fdt_get_property_w(fdt, nodeoffset, name, &oldlen);
|
||||
if (prop) {
|
||||
newlen = len + oldlen;
|
||||
err = _fdt_splice_struct(fdt, prop->data,
|
||||
FDT_TAGALIGN(oldlen),
|
||||
FDT_TAGALIGN(newlen));
|
||||
if (err)
|
||||
return err;
|
||||
prop->len = cpu_to_fdt32(newlen);
|
||||
memcpy(prop->data + oldlen, val, len);
|
||||
} else {
|
||||
err = _fdt_add_property(fdt, nodeoffset, name, len, &prop);
|
||||
if (err)
|
||||
return err;
|
||||
memcpy(prop->data, val, len);
|
||||
}
|
||||
return 0;
|
||||
prop = fdt_get_property_w (fdt, nodeoffset, name, &oldlen);
|
||||
if (prop) {
|
||||
newlen = len + oldlen;
|
||||
err = _fdt_splice_struct (
|
||||
fdt,
|
||||
prop->data,
|
||||
FDT_TAGALIGN (oldlen),
|
||||
FDT_TAGALIGN (newlen)
|
||||
);
|
||||
if (err) {
|
||||
return err;
|
||||
}
|
||||
|
||||
prop->len = cpu_to_fdt32 (newlen);
|
||||
memcpy (prop->data + oldlen, val, len);
|
||||
} else {
|
||||
err = _fdt_add_property (fdt, nodeoffset, name, len, &prop);
|
||||
if (err) {
|
||||
return err;
|
||||
}
|
||||
|
||||
memcpy (prop->data, val, len);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int fdt_delprop(void *fdt, int nodeoffset, const char *name)
|
||||
int
|
||||
fdt_delprop (
|
||||
void *fdt,
|
||||
int nodeoffset,
|
||||
const char *name
|
||||
)
|
||||
{
|
||||
struct fdt_property *prop;
|
||||
int len, proplen;
|
||||
struct fdt_property *prop;
|
||||
int len, proplen;
|
||||
|
||||
FDT_RW_CHECK_HEADER(fdt);
|
||||
FDT_RW_CHECK_HEADER (fdt);
|
||||
|
||||
prop = fdt_get_property_w(fdt, nodeoffset, name, &len);
|
||||
if (!prop)
|
||||
return len;
|
||||
prop = fdt_get_property_w (fdt, nodeoffset, name, &len);
|
||||
if (!prop) {
|
||||
return len;
|
||||
}
|
||||
|
||||
proplen = sizeof(*prop) + FDT_TAGALIGN(len);
|
||||
return _fdt_splice_struct(fdt, prop, proplen, 0);
|
||||
proplen = sizeof (*prop) + FDT_TAGALIGN (len);
|
||||
return _fdt_splice_struct (fdt, prop, proplen, 0);
|
||||
}
|
||||
|
||||
int fdt_add_subnode_namelen(void *fdt, int parentoffset,
|
||||
const char *name, int namelen)
|
||||
int
|
||||
fdt_add_subnode_namelen (
|
||||
void *fdt,
|
||||
int parentoffset,
|
||||
const char *name,
|
||||
int namelen
|
||||
)
|
||||
{
|
||||
struct fdt_node_header *nh;
|
||||
int offset, nextoffset;
|
||||
int nodelen;
|
||||
int err;
|
||||
uint32_t tag;
|
||||
fdt32_t *endtag;
|
||||
struct fdt_node_header *nh;
|
||||
int offset, nextoffset;
|
||||
int nodelen;
|
||||
int err;
|
||||
uint32_t tag;
|
||||
fdt32_t *endtag;
|
||||
|
||||
FDT_RW_CHECK_HEADER(fdt);
|
||||
FDT_RW_CHECK_HEADER (fdt);
|
||||
|
||||
offset = fdt_subnode_offset_namelen(fdt, parentoffset, name, namelen);
|
||||
if (offset >= 0)
|
||||
return -FDT_ERR_EXISTS;
|
||||
else if (offset != -FDT_ERR_NOTFOUND)
|
||||
return offset;
|
||||
offset = fdt_subnode_offset_namelen (fdt, parentoffset, name, namelen);
|
||||
if (offset >= 0) {
|
||||
return -FDT_ERR_EXISTS;
|
||||
} else if (offset != -FDT_ERR_NOTFOUND) {
|
||||
return offset;
|
||||
}
|
||||
|
||||
/* Try to place the new node after the parent's properties */
|
||||
fdt_next_tag(fdt, parentoffset, &nextoffset); /* skip the BEGIN_NODE */
|
||||
do {
|
||||
offset = nextoffset;
|
||||
tag = fdt_next_tag(fdt, offset, &nextoffset);
|
||||
} while ((tag == FDT_PROP) || (tag == FDT_NOP));
|
||||
/* Try to place the new node after the parent's properties */
|
||||
fdt_next_tag (fdt, parentoffset, &nextoffset); /* skip the BEGIN_NODE */
|
||||
do {
|
||||
offset = nextoffset;
|
||||
tag = fdt_next_tag (fdt, offset, &nextoffset);
|
||||
} while ((tag == FDT_PROP) || (tag == FDT_NOP));
|
||||
|
||||
nh = _fdt_offset_ptr_w(fdt, offset);
|
||||
nodelen = sizeof(*nh) + FDT_TAGALIGN(namelen+1) + FDT_TAGSIZE;
|
||||
nh = _fdt_offset_ptr_w (fdt, offset);
|
||||
nodelen = sizeof (*nh) + FDT_TAGALIGN (namelen+1) + FDT_TAGSIZE;
|
||||
|
||||
err = _fdt_splice_struct(fdt, nh, 0, nodelen);
|
||||
if (err)
|
||||
return err;
|
||||
err = _fdt_splice_struct (fdt, nh, 0, nodelen);
|
||||
if (err) {
|
||||
return err;
|
||||
}
|
||||
|
||||
nh->tag = cpu_to_fdt32(FDT_BEGIN_NODE);
|
||||
memset(nh->name, 0, FDT_TAGALIGN(namelen+1));
|
||||
memcpy(nh->name, name, namelen);
|
||||
endtag = (fdt32_t *)((char *)nh + nodelen - FDT_TAGSIZE);
|
||||
*endtag = cpu_to_fdt32(FDT_END_NODE);
|
||||
nh->tag = cpu_to_fdt32 (FDT_BEGIN_NODE);
|
||||
memset (nh->name, 0, FDT_TAGALIGN (namelen+1));
|
||||
memcpy (nh->name, name, namelen);
|
||||
endtag = (fdt32_t *)((char *)nh + nodelen - FDT_TAGSIZE);
|
||||
*endtag = cpu_to_fdt32 (FDT_END_NODE);
|
||||
|
||||
return offset;
|
||||
return offset;
|
||||
}
|
||||
|
||||
int fdt_add_subnode(void *fdt, int parentoffset, const char *name)
|
||||
int
|
||||
fdt_add_subnode (
|
||||
void *fdt,
|
||||
int parentoffset,
|
||||
const char *name
|
||||
)
|
||||
{
|
||||
return fdt_add_subnode_namelen(fdt, parentoffset, name, strlen(name));
|
||||
return fdt_add_subnode_namelen (fdt, parentoffset, name, strlen (name));
|
||||
}
|
||||
|
||||
int fdt_del_node(void *fdt, int nodeoffset)
|
||||
int
|
||||
fdt_del_node (
|
||||
void *fdt,
|
||||
int nodeoffset
|
||||
)
|
||||
{
|
||||
int endoffset;
|
||||
int endoffset;
|
||||
|
||||
FDT_RW_CHECK_HEADER(fdt);
|
||||
FDT_RW_CHECK_HEADER (fdt);
|
||||
|
||||
endoffset = _fdt_node_end_offset(fdt, nodeoffset);
|
||||
if (endoffset < 0)
|
||||
return endoffset;
|
||||
endoffset = _fdt_node_end_offset (fdt, nodeoffset);
|
||||
if (endoffset < 0) {
|
||||
return endoffset;
|
||||
}
|
||||
|
||||
return _fdt_splice_struct(fdt, _fdt_offset_ptr_w(fdt, nodeoffset),
|
||||
endoffset - nodeoffset, 0);
|
||||
return _fdt_splice_struct (
|
||||
fdt,
|
||||
_fdt_offset_ptr_w (fdt, nodeoffset),
|
||||
endoffset - nodeoffset,
|
||||
0
|
||||
);
|
||||
}
|
||||
|
||||
static void _fdt_packblocks(const char *old, char *new,
|
||||
int mem_rsv_size, int struct_size)
|
||||
static void
|
||||
_fdt_packblocks (
|
||||
const char *old,
|
||||
char *new,
|
||||
int mem_rsv_size,
|
||||
int struct_size
|
||||
)
|
||||
{
|
||||
int mem_rsv_off, struct_off, strings_off;
|
||||
int mem_rsv_off, struct_off, strings_off;
|
||||
|
||||
mem_rsv_off = FDT_ALIGN(sizeof(struct fdt_header), 8);
|
||||
struct_off = mem_rsv_off + mem_rsv_size;
|
||||
strings_off = struct_off + struct_size;
|
||||
mem_rsv_off = FDT_ALIGN (sizeof (struct fdt_header), 8);
|
||||
struct_off = mem_rsv_off + mem_rsv_size;
|
||||
strings_off = struct_off + struct_size;
|
||||
|
||||
memmove(new + mem_rsv_off, old + fdt_off_mem_rsvmap(old), mem_rsv_size);
|
||||
fdt_set_off_mem_rsvmap(new, mem_rsv_off);
|
||||
memmove (new + mem_rsv_off, old + fdt_off_mem_rsvmap (old), mem_rsv_size);
|
||||
fdt_set_off_mem_rsvmap (new, mem_rsv_off);
|
||||
|
||||
memmove(new + struct_off, old + fdt_off_dt_struct(old), struct_size);
|
||||
fdt_set_off_dt_struct(new, struct_off);
|
||||
fdt_set_size_dt_struct(new, struct_size);
|
||||
memmove (new + struct_off, old + fdt_off_dt_struct (old), struct_size);
|
||||
fdt_set_off_dt_struct (new, struct_off);
|
||||
fdt_set_size_dt_struct (new, struct_size);
|
||||
|
||||
memmove(new + strings_off, old + fdt_off_dt_strings(old),
|
||||
fdt_size_dt_strings(old));
|
||||
fdt_set_off_dt_strings(new, strings_off);
|
||||
fdt_set_size_dt_strings(new, fdt_size_dt_strings(old));
|
||||
memmove (
|
||||
new + strings_off,
|
||||
old + fdt_off_dt_strings (old),
|
||||
fdt_size_dt_strings (old)
|
||||
);
|
||||
fdt_set_off_dt_strings (new, strings_off);
|
||||
fdt_set_size_dt_strings (new, fdt_size_dt_strings (old));
|
||||
}
|
||||
|
||||
int fdt_open_into(const void *fdt, void *buf, int bufsize)
|
||||
int
|
||||
fdt_open_into (
|
||||
const void *fdt,
|
||||
void *buf,
|
||||
int bufsize
|
||||
)
|
||||
{
|
||||
int err;
|
||||
int mem_rsv_size, struct_size;
|
||||
int newsize;
|
||||
const char *fdtstart = fdt;
|
||||
const char *fdtend = fdtstart + fdt_totalsize(fdt);
|
||||
char *tmp;
|
||||
int err;
|
||||
int mem_rsv_size, struct_size;
|
||||
int newsize;
|
||||
const char *fdtstart = fdt;
|
||||
const char *fdtend = fdtstart + fdt_totalsize (fdt);
|
||||
char *tmp;
|
||||
|
||||
FDT_CHECK_HEADER(fdt);
|
||||
FDT_CHECK_HEADER (fdt);
|
||||
|
||||
mem_rsv_size = (fdt_num_mem_rsv(fdt)+1)
|
||||
* sizeof(struct fdt_reserve_entry);
|
||||
mem_rsv_size = (fdt_num_mem_rsv (fdt)+1)
|
||||
* sizeof (struct fdt_reserve_entry);
|
||||
|
||||
if (fdt_version(fdt) >= 17) {
|
||||
struct_size = fdt_size_dt_struct(fdt);
|
||||
} else {
|
||||
struct_size = 0;
|
||||
while (fdt_next_tag(fdt, struct_size, &struct_size) != FDT_END)
|
||||
;
|
||||
if (struct_size < 0)
|
||||
return struct_size;
|
||||
}
|
||||
if (fdt_version (fdt) >= 17) {
|
||||
struct_size = fdt_size_dt_struct (fdt);
|
||||
} else {
|
||||
struct_size = 0;
|
||||
while (fdt_next_tag (fdt, struct_size, &struct_size) != FDT_END) {
|
||||
}
|
||||
|
||||
if (!_fdt_blocks_misordered(fdt, mem_rsv_size, struct_size)) {
|
||||
/* no further work necessary */
|
||||
err = fdt_move(fdt, buf, bufsize);
|
||||
if (err)
|
||||
return err;
|
||||
fdt_set_version(buf, 17);
|
||||
fdt_set_size_dt_struct(buf, struct_size);
|
||||
fdt_set_totalsize(buf, bufsize);
|
||||
return 0;
|
||||
}
|
||||
if (struct_size < 0) {
|
||||
return struct_size;
|
||||
}
|
||||
}
|
||||
|
||||
/* Need to reorder */
|
||||
newsize = FDT_ALIGN(sizeof(struct fdt_header), 8) + mem_rsv_size
|
||||
+ struct_size + fdt_size_dt_strings(fdt);
|
||||
if (!_fdt_blocks_misordered (fdt, mem_rsv_size, struct_size)) {
|
||||
/* no further work necessary */
|
||||
err = fdt_move (fdt, buf, bufsize);
|
||||
if (err) {
|
||||
return err;
|
||||
}
|
||||
|
||||
if (bufsize < newsize)
|
||||
return -FDT_ERR_NOSPACE;
|
||||
fdt_set_version (buf, 17);
|
||||
fdt_set_size_dt_struct (buf, struct_size);
|
||||
fdt_set_totalsize (buf, bufsize);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* First attempt to build converted tree at beginning of buffer */
|
||||
tmp = buf;
|
||||
/* But if that overlaps with the old tree... */
|
||||
if (((tmp + newsize) > fdtstart) && (tmp < fdtend)) {
|
||||
/* Try right after the old tree instead */
|
||||
tmp = (char *)(uintptr_t)fdtend;
|
||||
if ((tmp + newsize) > ((char *)buf + bufsize))
|
||||
return -FDT_ERR_NOSPACE;
|
||||
}
|
||||
/* Need to reorder */
|
||||
newsize = FDT_ALIGN (sizeof (struct fdt_header), 8) + mem_rsv_size
|
||||
+ struct_size + fdt_size_dt_strings (fdt);
|
||||
|
||||
_fdt_packblocks(fdt, tmp, mem_rsv_size, struct_size);
|
||||
memmove(buf, tmp, newsize);
|
||||
if (bufsize < newsize) {
|
||||
return -FDT_ERR_NOSPACE;
|
||||
}
|
||||
|
||||
fdt_set_magic(buf, FDT_MAGIC);
|
||||
fdt_set_totalsize(buf, bufsize);
|
||||
fdt_set_version(buf, 17);
|
||||
fdt_set_last_comp_version(buf, 16);
|
||||
fdt_set_boot_cpuid_phys(buf, fdt_boot_cpuid_phys(fdt));
|
||||
/* First attempt to build converted tree at beginning of buffer */
|
||||
tmp = buf;
|
||||
/* But if that overlaps with the old tree... */
|
||||
if (((tmp + newsize) > fdtstart) && (tmp < fdtend)) {
|
||||
/* Try right after the old tree instead */
|
||||
tmp = (char *)(uintptr_t)fdtend;
|
||||
if ((tmp + newsize) > ((char *)buf + bufsize)) {
|
||||
return -FDT_ERR_NOSPACE;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
_fdt_packblocks (fdt, tmp, mem_rsv_size, struct_size);
|
||||
memmove (buf, tmp, newsize);
|
||||
|
||||
fdt_set_magic (buf, FDT_MAGIC);
|
||||
fdt_set_totalsize (buf, bufsize);
|
||||
fdt_set_version (buf, 17);
|
||||
fdt_set_last_comp_version (buf, 16);
|
||||
fdt_set_boot_cpuid_phys (buf, fdt_boot_cpuid_phys (fdt));
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int fdt_pack(void *fdt)
|
||||
int
|
||||
fdt_pack (
|
||||
void *fdt
|
||||
)
|
||||
{
|
||||
int mem_rsv_size;
|
||||
int mem_rsv_size;
|
||||
|
||||
FDT_RW_CHECK_HEADER(fdt);
|
||||
FDT_RW_CHECK_HEADER (fdt);
|
||||
|
||||
mem_rsv_size = (fdt_num_mem_rsv(fdt)+1)
|
||||
* sizeof(struct fdt_reserve_entry);
|
||||
_fdt_packblocks(fdt, fdt, mem_rsv_size, fdt_size_dt_struct(fdt));
|
||||
fdt_set_totalsize(fdt, _fdt_data_size(fdt));
|
||||
mem_rsv_size = (fdt_num_mem_rsv (fdt)+1)
|
||||
* sizeof (struct fdt_reserve_entry);
|
||||
_fdt_packblocks (fdt, fdt, mem_rsv_size, fdt_size_dt_struct (fdt));
|
||||
fdt_set_totalsize (fdt, _fdt_data_size (fdt));
|
||||
|
||||
return 0;
|
||||
return 0;
|
||||
}
|
||||
|
@@ -56,47 +56,51 @@
|
||||
#include "libfdt_internal.h"
|
||||
|
||||
struct fdt_errtabent {
|
||||
const char *str;
|
||||
const char *str;
|
||||
};
|
||||
|
||||
#define FDT_ERRTABENT(val) \
|
||||
[(val)] = { .str = #val, }
|
||||
[(val)] = { .str = #val, }
|
||||
|
||||
static struct fdt_errtabent fdt_errtable[] = {
|
||||
FDT_ERRTABENT(FDT_ERR_NOTFOUND),
|
||||
FDT_ERRTABENT(FDT_ERR_EXISTS),
|
||||
FDT_ERRTABENT(FDT_ERR_NOSPACE),
|
||||
static struct fdt_errtabent fdt_errtable[] = {
|
||||
FDT_ERRTABENT (FDT_ERR_NOTFOUND),
|
||||
FDT_ERRTABENT (FDT_ERR_EXISTS),
|
||||
FDT_ERRTABENT (FDT_ERR_NOSPACE),
|
||||
|
||||
FDT_ERRTABENT(FDT_ERR_BADOFFSET),
|
||||
FDT_ERRTABENT(FDT_ERR_BADPATH),
|
||||
FDT_ERRTABENT(FDT_ERR_BADPHANDLE),
|
||||
FDT_ERRTABENT(FDT_ERR_BADSTATE),
|
||||
FDT_ERRTABENT (FDT_ERR_BADOFFSET),
|
||||
FDT_ERRTABENT (FDT_ERR_BADPATH),
|
||||
FDT_ERRTABENT (FDT_ERR_BADPHANDLE),
|
||||
FDT_ERRTABENT (FDT_ERR_BADSTATE),
|
||||
|
||||
FDT_ERRTABENT(FDT_ERR_TRUNCATED),
|
||||
FDT_ERRTABENT(FDT_ERR_BADMAGIC),
|
||||
FDT_ERRTABENT(FDT_ERR_BADVERSION),
|
||||
FDT_ERRTABENT(FDT_ERR_BADSTRUCTURE),
|
||||
FDT_ERRTABENT(FDT_ERR_BADLAYOUT),
|
||||
FDT_ERRTABENT(FDT_ERR_INTERNAL),
|
||||
FDT_ERRTABENT(FDT_ERR_BADNCELLS),
|
||||
FDT_ERRTABENT(FDT_ERR_BADVALUE),
|
||||
FDT_ERRTABENT(FDT_ERR_BADOVERLAY),
|
||||
FDT_ERRTABENT(FDT_ERR_NOPHANDLES),
|
||||
FDT_ERRTABENT (FDT_ERR_TRUNCATED),
|
||||
FDT_ERRTABENT (FDT_ERR_BADMAGIC),
|
||||
FDT_ERRTABENT (FDT_ERR_BADVERSION),
|
||||
FDT_ERRTABENT (FDT_ERR_BADSTRUCTURE),
|
||||
FDT_ERRTABENT (FDT_ERR_BADLAYOUT),
|
||||
FDT_ERRTABENT (FDT_ERR_INTERNAL),
|
||||
FDT_ERRTABENT (FDT_ERR_BADNCELLS),
|
||||
FDT_ERRTABENT (FDT_ERR_BADVALUE),
|
||||
FDT_ERRTABENT (FDT_ERR_BADOVERLAY),
|
||||
FDT_ERRTABENT (FDT_ERR_NOPHANDLES),
|
||||
};
|
||||
#define FDT_ERRTABSIZE (sizeof(fdt_errtable) / sizeof(fdt_errtable[0]))
|
||||
#define FDT_ERRTABSIZE (sizeof(fdt_errtable) / sizeof(fdt_errtable[0]))
|
||||
|
||||
const char *fdt_strerror(int errval)
|
||||
const char *
|
||||
fdt_strerror (
|
||||
int errval
|
||||
)
|
||||
{
|
||||
if (errval > 0)
|
||||
return "<valid offset/length>";
|
||||
else if (errval == 0)
|
||||
return "<no error>";
|
||||
else if (errval > -FDT_ERRTABSIZE) {
|
||||
const char *s = fdt_errtable[-errval].str;
|
||||
if (errval > 0) {
|
||||
return "<valid offset/length>";
|
||||
} else if (errval == 0) {
|
||||
return "<no error>";
|
||||
} else if (errval > -FDT_ERRTABSIZE) {
|
||||
const char *s = fdt_errtable[-errval].str;
|
||||
|
||||
if (s)
|
||||
return s;
|
||||
}
|
||||
if (s) {
|
||||
return s;
|
||||
}
|
||||
}
|
||||
|
||||
return "<unknown error>";
|
||||
return "<unknown error>";
|
||||
}
|
||||
|
@@ -9,24 +9,29 @@
|
||||
#include <Library/BaseLib.h>
|
||||
#include <Library/DebugLib.h>
|
||||
|
||||
unsigned long strtoul(const char *nptr, char **endptr, int base)
|
||||
unsigned long
|
||||
strtoul (
|
||||
const char *nptr,
|
||||
char **endptr,
|
||||
int base
|
||||
)
|
||||
{
|
||||
RETURN_STATUS Status;
|
||||
UINTN ReturnValue;
|
||||
RETURN_STATUS Status;
|
||||
UINTN ReturnValue;
|
||||
|
||||
ASSERT (base == 10 || base == 16);
|
||||
ASSERT (base == 10 || base == 16);
|
||||
|
||||
if (base == 10) {
|
||||
Status = AsciiStrDecimalToUintnS (nptr, endptr, &ReturnValue);
|
||||
} else if (base == 16) {
|
||||
Status = AsciiStrHexToUintnS (nptr, endptr, &ReturnValue);
|
||||
} else {
|
||||
Status = RETURN_INVALID_PARAMETER;
|
||||
}
|
||||
if (base == 10) {
|
||||
Status = AsciiStrDecimalToUintnS (nptr, endptr, &ReturnValue);
|
||||
} else if (base == 16) {
|
||||
Status = AsciiStrHexToUintnS (nptr, endptr, &ReturnValue);
|
||||
} else {
|
||||
Status = RETURN_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
if (RETURN_ERROR (Status)) {
|
||||
return MAX_UINTN;
|
||||
}
|
||||
if (RETURN_ERROR (Status)) {
|
||||
return MAX_UINTN;
|
||||
}
|
||||
|
||||
return ReturnValue;
|
||||
return ReturnValue;
|
||||
}
|
||||
|
@@ -55,246 +55,321 @@
|
||||
|
||||
#include "libfdt_internal.h"
|
||||
|
||||
static int _fdt_sw_check_header(void *fdt)
|
||||
static int
|
||||
_fdt_sw_check_header (
|
||||
void *fdt
|
||||
)
|
||||
{
|
||||
if (fdt_magic(fdt) != FDT_SW_MAGIC)
|
||||
return -FDT_ERR_BADMAGIC;
|
||||
/* FIXME: should check more details about the header state */
|
||||
return 0;
|
||||
if (fdt_magic (fdt) != FDT_SW_MAGIC) {
|
||||
return -FDT_ERR_BADMAGIC;
|
||||
}
|
||||
|
||||
/* FIXME: should check more details about the header state */
|
||||
return 0;
|
||||
}
|
||||
|
||||
#define FDT_SW_CHECK_HEADER(fdt) \
|
||||
{ \
|
||||
int err; \
|
||||
if ((err = _fdt_sw_check_header(fdt)) != 0) \
|
||||
return err; \
|
||||
}
|
||||
{ \
|
||||
int err; \
|
||||
if ((err = _fdt_sw_check_header(fdt)) != 0) \
|
||||
return err; \
|
||||
}
|
||||
|
||||
static void *_fdt_grab_space(void *fdt, size_t len)
|
||||
static void *
|
||||
_fdt_grab_space (
|
||||
void *fdt,
|
||||
size_t len
|
||||
)
|
||||
{
|
||||
int offset = fdt_size_dt_struct(fdt);
|
||||
int spaceleft;
|
||||
int offset = fdt_size_dt_struct (fdt);
|
||||
int spaceleft;
|
||||
|
||||
spaceleft = fdt_totalsize(fdt) - fdt_off_dt_struct(fdt)
|
||||
- fdt_size_dt_strings(fdt);
|
||||
spaceleft = fdt_totalsize (fdt) - fdt_off_dt_struct (fdt)
|
||||
- fdt_size_dt_strings (fdt);
|
||||
|
||||
if ((offset + len < offset) || (offset + len > spaceleft))
|
||||
return NULL;
|
||||
if ((offset + len < offset) || (offset + len > spaceleft)) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
fdt_set_size_dt_struct(fdt, offset + len);
|
||||
return _fdt_offset_ptr_w(fdt, offset);
|
||||
fdt_set_size_dt_struct (fdt, offset + len);
|
||||
return _fdt_offset_ptr_w (fdt, offset);
|
||||
}
|
||||
|
||||
int fdt_create(void *buf, int bufsize)
|
||||
int
|
||||
fdt_create (
|
||||
void *buf,
|
||||
int bufsize
|
||||
)
|
||||
{
|
||||
void *fdt = buf;
|
||||
void *fdt = buf;
|
||||
|
||||
if (bufsize < sizeof(struct fdt_header))
|
||||
return -FDT_ERR_NOSPACE;
|
||||
if (bufsize < sizeof (struct fdt_header)) {
|
||||
return -FDT_ERR_NOSPACE;
|
||||
}
|
||||
|
||||
memset(buf, 0, bufsize);
|
||||
memset (buf, 0, bufsize);
|
||||
|
||||
fdt_set_magic(fdt, FDT_SW_MAGIC);
|
||||
fdt_set_version(fdt, FDT_LAST_SUPPORTED_VERSION);
|
||||
fdt_set_last_comp_version(fdt, FDT_FIRST_SUPPORTED_VERSION);
|
||||
fdt_set_totalsize(fdt, bufsize);
|
||||
fdt_set_magic (fdt, FDT_SW_MAGIC);
|
||||
fdt_set_version (fdt, FDT_LAST_SUPPORTED_VERSION);
|
||||
fdt_set_last_comp_version (fdt, FDT_FIRST_SUPPORTED_VERSION);
|
||||
fdt_set_totalsize (fdt, bufsize);
|
||||
|
||||
fdt_set_off_mem_rsvmap(fdt, FDT_ALIGN(sizeof(struct fdt_header),
|
||||
sizeof(struct fdt_reserve_entry)));
|
||||
fdt_set_off_dt_struct(fdt, fdt_off_mem_rsvmap(fdt));
|
||||
fdt_set_off_dt_strings(fdt, bufsize);
|
||||
fdt_set_off_mem_rsvmap (
|
||||
fdt,
|
||||
FDT_ALIGN (
|
||||
sizeof (struct fdt_header),
|
||||
sizeof (struct fdt_reserve_entry)
|
||||
)
|
||||
);
|
||||
fdt_set_off_dt_struct (fdt, fdt_off_mem_rsvmap (fdt));
|
||||
fdt_set_off_dt_strings (fdt, bufsize);
|
||||
|
||||
return 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int fdt_resize(void *fdt, void *buf, int bufsize)
|
||||
int
|
||||
fdt_resize (
|
||||
void *fdt,
|
||||
void *buf,
|
||||
int bufsize
|
||||
)
|
||||
{
|
||||
size_t headsize, tailsize;
|
||||
char *oldtail, *newtail;
|
||||
size_t headsize, tailsize;
|
||||
char *oldtail, *newtail;
|
||||
|
||||
FDT_SW_CHECK_HEADER(fdt);
|
||||
FDT_SW_CHECK_HEADER (fdt);
|
||||
|
||||
headsize = fdt_off_dt_struct(fdt);
|
||||
tailsize = fdt_size_dt_strings(fdt);
|
||||
headsize = fdt_off_dt_struct (fdt);
|
||||
tailsize = fdt_size_dt_strings (fdt);
|
||||
|
||||
if ((headsize + tailsize) > bufsize)
|
||||
return -FDT_ERR_NOSPACE;
|
||||
if ((headsize + tailsize) > bufsize) {
|
||||
return -FDT_ERR_NOSPACE;
|
||||
}
|
||||
|
||||
oldtail = (char *)fdt + fdt_totalsize(fdt) - tailsize;
|
||||
newtail = (char *)buf + bufsize - tailsize;
|
||||
oldtail = (char *)fdt + fdt_totalsize (fdt) - tailsize;
|
||||
newtail = (char *)buf + bufsize - tailsize;
|
||||
|
||||
/* Two cases to avoid clobbering data if the old and new
|
||||
* buffers partially overlap */
|
||||
if (buf <= fdt) {
|
||||
memmove(buf, fdt, headsize);
|
||||
memmove(newtail, oldtail, tailsize);
|
||||
} else {
|
||||
memmove(newtail, oldtail, tailsize);
|
||||
memmove(buf, fdt, headsize);
|
||||
}
|
||||
/* Two cases to avoid clobbering data if the old and new
|
||||
* buffers partially overlap */
|
||||
if (buf <= fdt) {
|
||||
memmove (buf, fdt, headsize);
|
||||
memmove (newtail, oldtail, tailsize);
|
||||
} else {
|
||||
memmove (newtail, oldtail, tailsize);
|
||||
memmove (buf, fdt, headsize);
|
||||
}
|
||||
|
||||
fdt_set_off_dt_strings(buf, bufsize);
|
||||
fdt_set_totalsize(buf, bufsize);
|
||||
fdt_set_off_dt_strings (buf, bufsize);
|
||||
fdt_set_totalsize (buf, bufsize);
|
||||
|
||||
return 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int fdt_add_reservemap_entry(void *fdt, uint64_t addr, uint64_t size)
|
||||
int
|
||||
fdt_add_reservemap_entry (
|
||||
void *fdt,
|
||||
uint64_t addr,
|
||||
uint64_t size
|
||||
)
|
||||
{
|
||||
struct fdt_reserve_entry *re;
|
||||
int offset;
|
||||
struct fdt_reserve_entry *re;
|
||||
int offset;
|
||||
|
||||
FDT_SW_CHECK_HEADER(fdt);
|
||||
FDT_SW_CHECK_HEADER (fdt);
|
||||
|
||||
if (fdt_size_dt_struct(fdt))
|
||||
return -FDT_ERR_BADSTATE;
|
||||
if (fdt_size_dt_struct (fdt)) {
|
||||
return -FDT_ERR_BADSTATE;
|
||||
}
|
||||
|
||||
offset = fdt_off_dt_struct(fdt);
|
||||
if ((offset + sizeof(*re)) > fdt_totalsize(fdt))
|
||||
return -FDT_ERR_NOSPACE;
|
||||
offset = fdt_off_dt_struct (fdt);
|
||||
if ((offset + sizeof (*re)) > fdt_totalsize (fdt)) {
|
||||
return -FDT_ERR_NOSPACE;
|
||||
}
|
||||
|
||||
re = (struct fdt_reserve_entry *)((char *)fdt + offset);
|
||||
re->address = cpu_to_fdt64(addr);
|
||||
re->size = cpu_to_fdt64(size);
|
||||
re = (struct fdt_reserve_entry *)((char *)fdt + offset);
|
||||
re->address = cpu_to_fdt64 (addr);
|
||||
re->size = cpu_to_fdt64 (size);
|
||||
|
||||
fdt_set_off_dt_struct(fdt, offset + sizeof(*re));
|
||||
fdt_set_off_dt_struct (fdt, offset + sizeof (*re));
|
||||
|
||||
return 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int fdt_finish_reservemap(void *fdt)
|
||||
int
|
||||
fdt_finish_reservemap (
|
||||
void *fdt
|
||||
)
|
||||
{
|
||||
return fdt_add_reservemap_entry(fdt, 0, 0);
|
||||
return fdt_add_reservemap_entry (fdt, 0, 0);
|
||||
}
|
||||
|
||||
int fdt_begin_node(void *fdt, const char *name)
|
||||
int
|
||||
fdt_begin_node (
|
||||
void *fdt,
|
||||
const char *name
|
||||
)
|
||||
{
|
||||
struct fdt_node_header *nh;
|
||||
int namelen = strlen(name) + 1;
|
||||
struct fdt_node_header *nh;
|
||||
int namelen = strlen (name) + 1;
|
||||
|
||||
FDT_SW_CHECK_HEADER(fdt);
|
||||
FDT_SW_CHECK_HEADER (fdt);
|
||||
|
||||
nh = _fdt_grab_space(fdt, sizeof(*nh) + FDT_TAGALIGN(namelen));
|
||||
if (! nh)
|
||||
return -FDT_ERR_NOSPACE;
|
||||
nh = _fdt_grab_space (fdt, sizeof (*nh) + FDT_TAGALIGN (namelen));
|
||||
if (!nh) {
|
||||
return -FDT_ERR_NOSPACE;
|
||||
}
|
||||
|
||||
nh->tag = cpu_to_fdt32(FDT_BEGIN_NODE);
|
||||
memcpy(nh->name, name, namelen);
|
||||
return 0;
|
||||
nh->tag = cpu_to_fdt32 (FDT_BEGIN_NODE);
|
||||
memcpy (nh->name, name, namelen);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int fdt_end_node(void *fdt)
|
||||
int
|
||||
fdt_end_node (
|
||||
void *fdt
|
||||
)
|
||||
{
|
||||
fdt32_t *en;
|
||||
fdt32_t *en;
|
||||
|
||||
FDT_SW_CHECK_HEADER(fdt);
|
||||
FDT_SW_CHECK_HEADER (fdt);
|
||||
|
||||
en = _fdt_grab_space(fdt, FDT_TAGSIZE);
|
||||
if (! en)
|
||||
return -FDT_ERR_NOSPACE;
|
||||
en = _fdt_grab_space (fdt, FDT_TAGSIZE);
|
||||
if (!en) {
|
||||
return -FDT_ERR_NOSPACE;
|
||||
}
|
||||
|
||||
*en = cpu_to_fdt32(FDT_END_NODE);
|
||||
return 0;
|
||||
*en = cpu_to_fdt32 (FDT_END_NODE);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int _fdt_find_add_string(void *fdt, const char *s)
|
||||
static int
|
||||
_fdt_find_add_string (
|
||||
void *fdt,
|
||||
const char *s
|
||||
)
|
||||
{
|
||||
char *strtab = (char *)fdt + fdt_totalsize(fdt);
|
||||
const char *p;
|
||||
int strtabsize = fdt_size_dt_strings(fdt);
|
||||
int len = strlen(s) + 1;
|
||||
int struct_top, offset;
|
||||
char *strtab = (char *)fdt + fdt_totalsize (fdt);
|
||||
const char *p;
|
||||
int strtabsize = fdt_size_dt_strings (fdt);
|
||||
int len = strlen (s) + 1;
|
||||
int struct_top, offset;
|
||||
|
||||
p = _fdt_find_string(strtab - strtabsize, strtabsize, s);
|
||||
if (p)
|
||||
return p - strtab;
|
||||
p = _fdt_find_string (strtab - strtabsize, strtabsize, s);
|
||||
if (p) {
|
||||
return p - strtab;
|
||||
}
|
||||
|
||||
/* Add it */
|
||||
offset = -strtabsize - len;
|
||||
struct_top = fdt_off_dt_struct(fdt) + fdt_size_dt_struct(fdt);
|
||||
if (fdt_totalsize(fdt) + offset < struct_top)
|
||||
return 0; /* no more room :( */
|
||||
/* Add it */
|
||||
offset = -strtabsize - len;
|
||||
struct_top = fdt_off_dt_struct (fdt) + fdt_size_dt_struct (fdt);
|
||||
if (fdt_totalsize (fdt) + offset < struct_top) {
|
||||
return 0; /* no more room :( */
|
||||
}
|
||||
|
||||
memcpy(strtab + offset, s, len);
|
||||
fdt_set_size_dt_strings(fdt, strtabsize + len);
|
||||
return offset;
|
||||
memcpy (strtab + offset, s, len);
|
||||
fdt_set_size_dt_strings (fdt, strtabsize + len);
|
||||
return offset;
|
||||
}
|
||||
|
||||
int fdt_property_placeholder(void *fdt, const char *name, int len, void **valp)
|
||||
int
|
||||
fdt_property_placeholder (
|
||||
void *fdt,
|
||||
const char *name,
|
||||
int len,
|
||||
void **valp
|
||||
)
|
||||
{
|
||||
struct fdt_property *prop;
|
||||
int nameoff;
|
||||
struct fdt_property *prop;
|
||||
int nameoff;
|
||||
|
||||
FDT_SW_CHECK_HEADER(fdt);
|
||||
FDT_SW_CHECK_HEADER (fdt);
|
||||
|
||||
nameoff = _fdt_find_add_string(fdt, name);
|
||||
if (nameoff == 0)
|
||||
return -FDT_ERR_NOSPACE;
|
||||
nameoff = _fdt_find_add_string (fdt, name);
|
||||
if (nameoff == 0) {
|
||||
return -FDT_ERR_NOSPACE;
|
||||
}
|
||||
|
||||
prop = _fdt_grab_space(fdt, sizeof(*prop) + FDT_TAGALIGN(len));
|
||||
if (! prop)
|
||||
return -FDT_ERR_NOSPACE;
|
||||
prop = _fdt_grab_space (fdt, sizeof (*prop) + FDT_TAGALIGN (len));
|
||||
if (!prop) {
|
||||
return -FDT_ERR_NOSPACE;
|
||||
}
|
||||
|
||||
prop->tag = cpu_to_fdt32(FDT_PROP);
|
||||
prop->nameoff = cpu_to_fdt32(nameoff);
|
||||
prop->len = cpu_to_fdt32(len);
|
||||
*valp = prop->data;
|
||||
return 0;
|
||||
prop->tag = cpu_to_fdt32 (FDT_PROP);
|
||||
prop->nameoff = cpu_to_fdt32 (nameoff);
|
||||
prop->len = cpu_to_fdt32 (len);
|
||||
*valp = prop->data;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int fdt_property(void *fdt, const char *name, const void *val, int len)
|
||||
int
|
||||
fdt_property (
|
||||
void *fdt,
|
||||
const char *name,
|
||||
const void *val,
|
||||
int len
|
||||
)
|
||||
{
|
||||
void *ptr;
|
||||
int ret;
|
||||
void *ptr;
|
||||
int ret;
|
||||
|
||||
ret = fdt_property_placeholder(fdt, name, len, &ptr);
|
||||
if (ret)
|
||||
return ret;
|
||||
memcpy(ptr, val, len);
|
||||
return 0;
|
||||
ret = fdt_property_placeholder (fdt, name, len, &ptr);
|
||||
if (ret) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
memcpy (ptr, val, len);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int fdt_finish(void *fdt)
|
||||
int
|
||||
fdt_finish (
|
||||
void *fdt
|
||||
)
|
||||
{
|
||||
char *p = (char *)fdt;
|
||||
fdt32_t *end;
|
||||
int oldstroffset, newstroffset;
|
||||
uint32_t tag;
|
||||
int offset, nextoffset;
|
||||
char *p = (char *)fdt;
|
||||
fdt32_t *end;
|
||||
int oldstroffset, newstroffset;
|
||||
uint32_t tag;
|
||||
int offset, nextoffset;
|
||||
|
||||
FDT_SW_CHECK_HEADER(fdt);
|
||||
FDT_SW_CHECK_HEADER (fdt);
|
||||
|
||||
/* Add terminator */
|
||||
end = _fdt_grab_space(fdt, sizeof(*end));
|
||||
if (! end)
|
||||
return -FDT_ERR_NOSPACE;
|
||||
*end = cpu_to_fdt32(FDT_END);
|
||||
/* Add terminator */
|
||||
end = _fdt_grab_space (fdt, sizeof (*end));
|
||||
if (!end) {
|
||||
return -FDT_ERR_NOSPACE;
|
||||
}
|
||||
|
||||
/* Relocate the string table */
|
||||
oldstroffset = fdt_totalsize(fdt) - fdt_size_dt_strings(fdt);
|
||||
newstroffset = fdt_off_dt_struct(fdt) + fdt_size_dt_struct(fdt);
|
||||
memmove(p + newstroffset, p + oldstroffset, fdt_size_dt_strings(fdt));
|
||||
fdt_set_off_dt_strings(fdt, newstroffset);
|
||||
*end = cpu_to_fdt32 (FDT_END);
|
||||
|
||||
/* Walk the structure, correcting string offsets */
|
||||
offset = 0;
|
||||
while ((tag = fdt_next_tag(fdt, offset, &nextoffset)) != FDT_END) {
|
||||
if (tag == FDT_PROP) {
|
||||
struct fdt_property *prop =
|
||||
_fdt_offset_ptr_w(fdt, offset);
|
||||
int nameoff;
|
||||
/* Relocate the string table */
|
||||
oldstroffset = fdt_totalsize (fdt) - fdt_size_dt_strings (fdt);
|
||||
newstroffset = fdt_off_dt_struct (fdt) + fdt_size_dt_struct (fdt);
|
||||
memmove (p + newstroffset, p + oldstroffset, fdt_size_dt_strings (fdt));
|
||||
fdt_set_off_dt_strings (fdt, newstroffset);
|
||||
|
||||
nameoff = fdt32_to_cpu(prop->nameoff);
|
||||
nameoff += fdt_size_dt_strings(fdt);
|
||||
prop->nameoff = cpu_to_fdt32(nameoff);
|
||||
}
|
||||
offset = nextoffset;
|
||||
}
|
||||
if (nextoffset < 0)
|
||||
return nextoffset;
|
||||
/* Walk the structure, correcting string offsets */
|
||||
offset = 0;
|
||||
while ((tag = fdt_next_tag (fdt, offset, &nextoffset)) != FDT_END) {
|
||||
if (tag == FDT_PROP) {
|
||||
struct fdt_property *prop =
|
||||
_fdt_offset_ptr_w (fdt, offset);
|
||||
int nameoff;
|
||||
|
||||
/* Finally, adjust the header */
|
||||
fdt_set_totalsize(fdt, newstroffset + fdt_size_dt_strings(fdt));
|
||||
fdt_set_magic(fdt, FDT_MAGIC);
|
||||
return 0;
|
||||
nameoff = fdt32_to_cpu (prop->nameoff);
|
||||
nameoff += fdt_size_dt_strings (fdt);
|
||||
prop->nameoff = cpu_to_fdt32 (nameoff);
|
||||
}
|
||||
|
||||
offset = nextoffset;
|
||||
}
|
||||
|
||||
if (nextoffset < 0) {
|
||||
return nextoffset;
|
||||
}
|
||||
|
||||
/* Finally, adjust the header */
|
||||
fdt_set_totalsize (fdt, newstroffset + fdt_size_dt_strings (fdt));
|
||||
fdt_set_magic (fdt, FDT_MAGIC);
|
||||
return 0;
|
||||
}
|
||||
|
@@ -55,85 +55,135 @@
|
||||
|
||||
#include "libfdt_internal.h"
|
||||
|
||||
int fdt_setprop_inplace_namelen_partial(void *fdt, int nodeoffset,
|
||||
const char *name, int namelen,
|
||||
uint32_t idx, const void *val,
|
||||
int len)
|
||||
int
|
||||
fdt_setprop_inplace_namelen_partial (
|
||||
void *fdt,
|
||||
int nodeoffset,
|
||||
const char *name,
|
||||
int namelen,
|
||||
uint32_t idx,
|
||||
const void *val,
|
||||
int len
|
||||
)
|
||||
{
|
||||
void *propval;
|
||||
int proplen;
|
||||
void *propval;
|
||||
int proplen;
|
||||
|
||||
propval = fdt_getprop_namelen_w(fdt, nodeoffset, name, namelen,
|
||||
&proplen);
|
||||
if (!propval)
|
||||
return proplen;
|
||||
propval = fdt_getprop_namelen_w (
|
||||
fdt,
|
||||
nodeoffset,
|
||||
name,
|
||||
namelen,
|
||||
&proplen
|
||||
);
|
||||
if (!propval) {
|
||||
return proplen;
|
||||
}
|
||||
|
||||
if (proplen < (len + idx))
|
||||
return -FDT_ERR_NOSPACE;
|
||||
if (proplen < (len + idx)) {
|
||||
return -FDT_ERR_NOSPACE;
|
||||
}
|
||||
|
||||
memcpy((char *)propval + idx, val, len);
|
||||
return 0;
|
||||
memcpy ((char *)propval + idx, val, len);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int fdt_setprop_inplace(void *fdt, int nodeoffset, const char *name,
|
||||
const void *val, int len)
|
||||
int
|
||||
fdt_setprop_inplace (
|
||||
void *fdt,
|
||||
int nodeoffset,
|
||||
const char *name,
|
||||
const void *val,
|
||||
int len
|
||||
)
|
||||
{
|
||||
const void *propval;
|
||||
int proplen;
|
||||
const void *propval;
|
||||
int proplen;
|
||||
|
||||
propval = fdt_getprop(fdt, nodeoffset, name, &proplen);
|
||||
if (!propval)
|
||||
return proplen;
|
||||
propval = fdt_getprop (fdt, nodeoffset, name, &proplen);
|
||||
if (!propval) {
|
||||
return proplen;
|
||||
}
|
||||
|
||||
if (proplen != len)
|
||||
return -FDT_ERR_NOSPACE;
|
||||
if (proplen != len) {
|
||||
return -FDT_ERR_NOSPACE;
|
||||
}
|
||||
|
||||
return fdt_setprop_inplace_namelen_partial(fdt, nodeoffset, name,
|
||||
strlen(name), 0,
|
||||
val, len);
|
||||
return fdt_setprop_inplace_namelen_partial (
|
||||
fdt,
|
||||
nodeoffset,
|
||||
name,
|
||||
strlen (name),
|
||||
0,
|
||||
val,
|
||||
len
|
||||
);
|
||||
}
|
||||
|
||||
static void _fdt_nop_region(void *start, int len)
|
||||
static void
|
||||
_fdt_nop_region (
|
||||
void *start,
|
||||
int len
|
||||
)
|
||||
{
|
||||
fdt32_t *p;
|
||||
fdt32_t *p;
|
||||
|
||||
for (p = start; (char *)p < ((char *)start + len); p++)
|
||||
*p = cpu_to_fdt32(FDT_NOP);
|
||||
for (p = start; (char *)p < ((char *)start + len); p++) {
|
||||
*p = cpu_to_fdt32 (FDT_NOP);
|
||||
}
|
||||
}
|
||||
|
||||
int fdt_nop_property(void *fdt, int nodeoffset, const char *name)
|
||||
int
|
||||
fdt_nop_property (
|
||||
void *fdt,
|
||||
int nodeoffset,
|
||||
const char *name
|
||||
)
|
||||
{
|
||||
struct fdt_property *prop;
|
||||
int len;
|
||||
struct fdt_property *prop;
|
||||
int len;
|
||||
|
||||
prop = fdt_get_property_w(fdt, nodeoffset, name, &len);
|
||||
if (!prop)
|
||||
return len;
|
||||
prop = fdt_get_property_w (fdt, nodeoffset, name, &len);
|
||||
if (!prop) {
|
||||
return len;
|
||||
}
|
||||
|
||||
_fdt_nop_region(prop, len + sizeof(*prop));
|
||||
_fdt_nop_region (prop, len + sizeof (*prop));
|
||||
|
||||
return 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int _fdt_node_end_offset(void *fdt, int offset)
|
||||
int
|
||||
_fdt_node_end_offset (
|
||||
void *fdt,
|
||||
int offset
|
||||
)
|
||||
{
|
||||
int depth = 0;
|
||||
int depth = 0;
|
||||
|
||||
while ((offset >= 0) && (depth >= 0))
|
||||
offset = fdt_next_node(fdt, offset, &depth);
|
||||
while ((offset >= 0) && (depth >= 0)) {
|
||||
offset = fdt_next_node (fdt, offset, &depth);
|
||||
}
|
||||
|
||||
return offset;
|
||||
return offset;
|
||||
}
|
||||
|
||||
int fdt_nop_node(void *fdt, int nodeoffset)
|
||||
int
|
||||
fdt_nop_node (
|
||||
void *fdt,
|
||||
int nodeoffset
|
||||
)
|
||||
{
|
||||
int endoffset;
|
||||
int endoffset;
|
||||
|
||||
endoffset = _fdt_node_end_offset(fdt, nodeoffset);
|
||||
if (endoffset < 0)
|
||||
return endoffset;
|
||||
endoffset = _fdt_node_end_offset (fdt, nodeoffset);
|
||||
if (endoffset < 0) {
|
||||
return endoffset;
|
||||
}
|
||||
|
||||
_fdt_nop_region(fdt_offset_ptr_w(fdt, nodeoffset, 0),
|
||||
endoffset - nodeoffset);
|
||||
return 0;
|
||||
_fdt_nop_region (
|
||||
fdt_offset_ptr_w (fdt, nodeoffset, 0),
|
||||
endoffset - nodeoffset
|
||||
);
|
||||
return 0;
|
||||
}
|
||||
|
@@ -1,5 +1,6 @@
|
||||
#ifndef _LIBFDT_INTERNAL_H
|
||||
#define _LIBFDT_INTERNAL_H
|
||||
|
||||
/*
|
||||
* libfdt - Flat Device Tree manipulation
|
||||
* Copyright (C) 2006 David Gibson, IBM Corporation.
|
||||
@@ -52,44 +53,81 @@
|
||||
*/
|
||||
#include <fdt.h>
|
||||
|
||||
#define FDT_ALIGN(x, a) (((x) + (a) - 1) & ~((a) - 1))
|
||||
#define FDT_TAGALIGN(x) (FDT_ALIGN((x), FDT_TAGSIZE))
|
||||
#define FDT_ALIGN(x, a) (((x) + (a) - 1) & ~((a) - 1))
|
||||
#define FDT_TAGALIGN(x) (FDT_ALIGN((x), FDT_TAGSIZE))
|
||||
|
||||
#define FDT_CHECK_HEADER(fdt) \
|
||||
{ \
|
||||
int __err; \
|
||||
if ((__err = fdt_check_header(fdt)) != 0) \
|
||||
return __err; \
|
||||
}
|
||||
{ \
|
||||
int __err; \
|
||||
if ((__err = fdt_check_header(fdt)) != 0) \
|
||||
return __err; \
|
||||
}
|
||||
|
||||
int _fdt_check_node_offset(const void *fdt, int offset);
|
||||
int _fdt_check_prop_offset(const void *fdt, int offset);
|
||||
const char *_fdt_find_string(const char *strtab, int tabsize, const char *s);
|
||||
int _fdt_node_end_offset(void *fdt, int nodeoffset);
|
||||
int
|
||||
_fdt_check_node_offset (
|
||||
const void *fdt,
|
||||
int offset
|
||||
);
|
||||
|
||||
static inline const void *_fdt_offset_ptr(const void *fdt, int offset)
|
||||
int
|
||||
_fdt_check_prop_offset (
|
||||
const void *fdt,
|
||||
int offset
|
||||
);
|
||||
|
||||
const char *
|
||||
_fdt_find_string (
|
||||
const char *strtab,
|
||||
int tabsize,
|
||||
const char *s
|
||||
);
|
||||
|
||||
int
|
||||
_fdt_node_end_offset (
|
||||
void *fdt,
|
||||
int nodeoffset
|
||||
);
|
||||
|
||||
static inline const void *
|
||||
_fdt_offset_ptr (
|
||||
const void *fdt,
|
||||
int offset
|
||||
)
|
||||
{
|
||||
return (const char *)fdt + fdt_off_dt_struct(fdt) + offset;
|
||||
return (const char *)fdt + fdt_off_dt_struct (fdt) + offset;
|
||||
}
|
||||
|
||||
static inline void *_fdt_offset_ptr_w(void *fdt, int offset)
|
||||
static inline void *
|
||||
_fdt_offset_ptr_w (
|
||||
void *fdt,
|
||||
int offset
|
||||
)
|
||||
{
|
||||
return (void *)(uintptr_t)_fdt_offset_ptr(fdt, offset);
|
||||
return (void *)(uintptr_t)_fdt_offset_ptr (fdt, offset);
|
||||
}
|
||||
|
||||
static inline const struct fdt_reserve_entry *_fdt_mem_rsv(const void *fdt, int n)
|
||||
static inline const struct fdt_reserve_entry *
|
||||
_fdt_mem_rsv (
|
||||
const void *fdt,
|
||||
int n
|
||||
)
|
||||
{
|
||||
const struct fdt_reserve_entry *rsv_table =
|
||||
(const struct fdt_reserve_entry *)
|
||||
((const char *)fdt + fdt_off_mem_rsvmap(fdt));
|
||||
const struct fdt_reserve_entry *rsv_table =
|
||||
(const struct fdt_reserve_entry *)
|
||||
((const char *)fdt + fdt_off_mem_rsvmap (fdt));
|
||||
|
||||
return rsv_table + n;
|
||||
}
|
||||
static inline struct fdt_reserve_entry *_fdt_mem_rsv_w(void *fdt, int n)
|
||||
{
|
||||
return (void *)(uintptr_t)_fdt_mem_rsv(fdt, n);
|
||||
return rsv_table + n;
|
||||
}
|
||||
|
||||
#define FDT_SW_MAGIC (~FDT_MAGIC)
|
||||
static inline struct fdt_reserve_entry *
|
||||
_fdt_mem_rsv_w (
|
||||
void *fdt,
|
||||
int n
|
||||
)
|
||||
{
|
||||
return (void *)(uintptr_t)_fdt_mem_rsv (fdt, n);
|
||||
}
|
||||
|
||||
#define FDT_SW_MAGIC (~FDT_MAGIC)
|
||||
|
||||
#endif /* _LIBFDT_INTERNAL_H */
|
||||
|
@@ -16,9 +16,8 @@
|
||||
|
||||
#include <Protocol/DebugPort.h>
|
||||
|
||||
|
||||
EFI_DEBUGPORT_PROTOCOL *gDebugPort = NULL;
|
||||
UINTN gTimeOut = 0;
|
||||
UINTN gTimeOut = 0;
|
||||
|
||||
/**
|
||||
The constructor function initializes the UART.
|
||||
@@ -36,7 +35,7 @@ GdbSerialLibDebugPortConstructor (
|
||||
IN EFI_SYSTEM_TABLE *SystemTable
|
||||
)
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
EFI_STATUS Status;
|
||||
|
||||
Status = gBS->LocateProtocol (&gEfiDebugPortProtocolGuid, NULL, (VOID **)&gDebugPort);
|
||||
if (!EFI_ERROR (Status)) {
|
||||
@@ -47,8 +46,6 @@ GdbSerialLibDebugPortConstructor (
|
||||
return Status;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**
|
||||
Sets the baud rate, receive FIFO depth, transmit/receive time out, parity,
|
||||
data buts, and stop bits on a serial device. This call is optional as the serial
|
||||
@@ -71,10 +68,10 @@ GdbSerialLibDebugPortConstructor (
|
||||
RETURN_STATUS
|
||||
EFIAPI
|
||||
GdbSerialInit (
|
||||
IN UINT64 BaudRate,
|
||||
IN UINT8 Parity,
|
||||
IN UINT8 DataBits,
|
||||
IN UINT8 StopBits
|
||||
IN UINT64 BaudRate,
|
||||
IN UINT8 Parity,
|
||||
IN UINT8 DataBits,
|
||||
IN UINT8 StopBits
|
||||
)
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
@@ -83,7 +80,6 @@ GdbSerialInit (
|
||||
return Status;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Check to see if a character is available from GDB. Do not read the character as that is
|
||||
done via GdbGetChar().
|
||||
@@ -105,7 +101,6 @@ GdbIsCharAvailable (
|
||||
return (Status == EFI_SUCCESS ? TRUE : FALSE);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Get a character from GDB. This function must be able to run in interrupt context.
|
||||
|
||||
@@ -124,13 +119,12 @@ GdbGetChar (
|
||||
|
||||
do {
|
||||
BufferSize = sizeof (Char);
|
||||
Status = gDebugPort->Read (gDebugPort, gTimeOut, &BufferSize, &Char);
|
||||
Status = gDebugPort->Read (gDebugPort, gTimeOut, &BufferSize, &Char);
|
||||
} while (EFI_ERROR (Status) || BufferSize != sizeof (Char));
|
||||
|
||||
return Char;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Send a character to GDB. This function must be able to run in interrupt context.
|
||||
|
||||
@@ -138,11 +132,10 @@ GdbGetChar (
|
||||
@param Char Send a character to GDB
|
||||
|
||||
**/
|
||||
|
||||
VOID
|
||||
EFIAPI
|
||||
GdbPutChar (
|
||||
IN CHAR8 Char
|
||||
IN CHAR8 Char
|
||||
)
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
@@ -150,7 +143,7 @@ GdbPutChar (
|
||||
|
||||
do {
|
||||
BufferSize = sizeof (Char);
|
||||
Status = gDebugPort->Write (gDebugPort, gTimeOut, &BufferSize, &Char);
|
||||
Status = gDebugPort->Write (gDebugPort, gTimeOut, &BufferSize, &Char);
|
||||
} while (EFI_ERROR (Status) || BufferSize != sizeof (Char));
|
||||
|
||||
return;
|
||||
@@ -163,19 +156,14 @@ GdbPutChar (
|
||||
@param String Send a string to GDB
|
||||
|
||||
**/
|
||||
|
||||
VOID
|
||||
GdbPutString (
|
||||
IN CHAR8 *String
|
||||
)
|
||||
{
|
||||
// We could performance enhance this function by calling gDebugPort->Write ()
|
||||
// We could performance enhance this function by calling gDebugPort->Write ()
|
||||
while (*String != '\0') {
|
||||
GdbPutChar (*String);
|
||||
String++;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
@@ -13,38 +13,34 @@
|
||||
#include <Library/IoLib.h>
|
||||
#include <Library/DebugLib.h>
|
||||
|
||||
|
||||
//---------------------------------------------
|
||||
// ---------------------------------------------
|
||||
// UART Register Offsets
|
||||
//---------------------------------------------
|
||||
#define BAUD_LOW_OFFSET 0x00
|
||||
#define BAUD_HIGH_OFFSET 0x01
|
||||
#define IER_OFFSET 0x01
|
||||
#define LCR_SHADOW_OFFSET 0x01
|
||||
#define FCR_SHADOW_OFFSET 0x02
|
||||
#define IR_CONTROL_OFFSET 0x02
|
||||
#define FCR_OFFSET 0x02
|
||||
#define EIR_OFFSET 0x02
|
||||
#define BSR_OFFSET 0x03
|
||||
#define LCR_OFFSET 0x03
|
||||
#define MCR_OFFSET 0x04
|
||||
#define LSR_OFFSET 0x05
|
||||
#define MSR_OFFSET 0x06
|
||||
// ---------------------------------------------
|
||||
#define BAUD_LOW_OFFSET 0x00
|
||||
#define BAUD_HIGH_OFFSET 0x01
|
||||
#define IER_OFFSET 0x01
|
||||
#define LCR_SHADOW_OFFSET 0x01
|
||||
#define FCR_SHADOW_OFFSET 0x02
|
||||
#define IR_CONTROL_OFFSET 0x02
|
||||
#define FCR_OFFSET 0x02
|
||||
#define EIR_OFFSET 0x02
|
||||
#define BSR_OFFSET 0x03
|
||||
#define LCR_OFFSET 0x03
|
||||
#define MCR_OFFSET 0x04
|
||||
#define LSR_OFFSET 0x05
|
||||
#define MSR_OFFSET 0x06
|
||||
|
||||
//---------------------------------------------
|
||||
// ---------------------------------------------
|
||||
// UART Register Bit Defines
|
||||
//---------------------------------------------
|
||||
#define LSR_TXRDY 0x20U
|
||||
#define LSR_RXDA 0x01U
|
||||
#define DLAB 0x01U
|
||||
#define ENABLE_FIFO 0x01U
|
||||
#define CLEAR_FIFOS 0x06U
|
||||
|
||||
|
||||
// ---------------------------------------------
|
||||
#define LSR_TXRDY 0x20U
|
||||
#define LSR_RXDA 0x01U
|
||||
#define DLAB 0x01U
|
||||
#define ENABLE_FIFO 0x01U
|
||||
#define CLEAR_FIFOS 0x06U
|
||||
|
||||
// IO Port Base for the UART
|
||||
UINTN gPort;
|
||||
|
||||
UINTN gPort;
|
||||
|
||||
/**
|
||||
The constructor function initializes the UART.
|
||||
@@ -62,10 +58,10 @@ GdbSerialLibConstructor (
|
||||
IN EFI_SYSTEM_TABLE *SystemTable
|
||||
)
|
||||
{
|
||||
UINT64 BaudRate;
|
||||
UINT8 DataBits;
|
||||
UINT8 Parity;
|
||||
UINT8 StopBits;
|
||||
UINT64 BaudRate;
|
||||
UINT8 DataBits;
|
||||
UINT8 Parity;
|
||||
UINT8 StopBits;
|
||||
|
||||
gPort = (UINTN)PcdGet32 (PcdGdbUartPort);
|
||||
|
||||
@@ -77,8 +73,6 @@ GdbSerialLibConstructor (
|
||||
return GdbSerialInit (BaudRate, Parity, DataBits, StopBits);
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**
|
||||
Sets the baud rate, receive FIFO depth, transmit/receive time out, parity,
|
||||
data buts, and stop bits on a serial device. This call is optional as the serial
|
||||
@@ -101,16 +95,16 @@ GdbSerialLibConstructor (
|
||||
RETURN_STATUS
|
||||
EFIAPI
|
||||
GdbSerialInit (
|
||||
IN UINT64 BaudRate,
|
||||
IN UINT8 Parity,
|
||||
IN UINT8 DataBits,
|
||||
IN UINT8 StopBits
|
||||
IN UINT64 BaudRate,
|
||||
IN UINT8 Parity,
|
||||
IN UINT8 DataBits,
|
||||
IN UINT8 StopBits
|
||||
)
|
||||
{
|
||||
UINTN Divisor;
|
||||
UINT8 OutputData;
|
||||
UINT8 Data;
|
||||
UINT8 BreakSet = 0;
|
||||
UINTN Divisor;
|
||||
UINT8 OutputData;
|
||||
UINT8 Data;
|
||||
UINT8 BreakSet = 0;
|
||||
|
||||
//
|
||||
// We assume the UART has been turned on to decode gPort address range
|
||||
@@ -119,7 +113,7 @@ GdbSerialInit (
|
||||
//
|
||||
// Map 5..8 to 0..3
|
||||
//
|
||||
Data = (UINT8) (DataBits - (UINT8)5);
|
||||
Data = (UINT8)(DataBits - (UINT8)5);
|
||||
|
||||
//
|
||||
// Calculate divisor for baud generator
|
||||
@@ -138,7 +132,6 @@ GdbSerialInit (
|
||||
IoWrite8 (gPort + BAUD_HIGH_OFFSET, (UINT8)(Divisor >> 8));
|
||||
IoWrite8 (gPort + BAUD_LOW_OFFSET, (UINT8)(Divisor & 0xff));
|
||||
|
||||
|
||||
//
|
||||
// Switch back to bank 0
|
||||
//
|
||||
@@ -149,12 +142,10 @@ GdbSerialInit (
|
||||
// We probably need the FIFO enabled to not drop input
|
||||
IoWrite8 (gPort + FCR_SHADOW_OFFSET, ENABLE_FIFO);
|
||||
|
||||
|
||||
// Configure the UART hardware here
|
||||
return RETURN_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Check to see if a character is available from GDB. Do not read the character as that is
|
||||
done via GdbGetChar().
|
||||
@@ -169,14 +160,13 @@ GdbIsCharAvailable (
|
||||
VOID
|
||||
)
|
||||
{
|
||||
UINT8 Data;
|
||||
UINT8 Data;
|
||||
|
||||
Data = IoRead8 (gPort + LSR_OFFSET);
|
||||
|
||||
return ((Data & LSR_RXDA) == LSR_RXDA);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Get a character from GDB. This function must be able to run in interrupt context.
|
||||
|
||||
@@ -189,8 +179,8 @@ GdbGetChar (
|
||||
VOID
|
||||
)
|
||||
{
|
||||
UINT8 Data;
|
||||
CHAR8 Char;
|
||||
UINT8 Data;
|
||||
CHAR8 Char;
|
||||
|
||||
// Wait for the serial port to be ready
|
||||
do {
|
||||
@@ -204,7 +194,6 @@ GdbGetChar (
|
||||
return Char;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Send a character to GDB. This function must be able to run in interrupt context.
|
||||
|
||||
@@ -212,14 +201,13 @@ GdbGetChar (
|
||||
@param Char Send a character to GDB
|
||||
|
||||
**/
|
||||
|
||||
VOID
|
||||
EFIAPI
|
||||
GdbPutChar (
|
||||
IN CHAR8 Char
|
||||
IN CHAR8 Char
|
||||
)
|
||||
{
|
||||
UINT8 Data;
|
||||
UINT8 Data;
|
||||
|
||||
// Make this an DEBUG_INFO after we get everything debugged.
|
||||
DEBUG ((DEBUG_ERROR, ">%c>", Char));
|
||||
@@ -239,7 +227,6 @@ GdbPutChar (
|
||||
@param String Send a string to GDB
|
||||
|
||||
**/
|
||||
|
||||
VOID
|
||||
GdbPutString (
|
||||
IN CHAR8 *String
|
||||
|
@@ -22,30 +22,29 @@
|
||||
#include <Protocol/Cpu.h>
|
||||
|
||||
typedef struct {
|
||||
EFI_PHYSICAL_ADDRESS HostAddress;
|
||||
VOID *BufferAddress;
|
||||
UINTN NumberOfBytes;
|
||||
DMA_MAP_OPERATION Operation;
|
||||
BOOLEAN DoubleBuffer;
|
||||
EFI_PHYSICAL_ADDRESS HostAddress;
|
||||
VOID *BufferAddress;
|
||||
UINTN NumberOfBytes;
|
||||
DMA_MAP_OPERATION Operation;
|
||||
BOOLEAN DoubleBuffer;
|
||||
} MAP_INFO_INSTANCE;
|
||||
|
||||
|
||||
typedef struct {
|
||||
LIST_ENTRY Link;
|
||||
VOID *HostAddress;
|
||||
UINTN NumPages;
|
||||
UINT64 Attributes;
|
||||
LIST_ENTRY Link;
|
||||
VOID *HostAddress;
|
||||
UINTN NumPages;
|
||||
UINT64 Attributes;
|
||||
} UNCACHED_ALLOCATION;
|
||||
|
||||
STATIC EFI_CPU_ARCH_PROTOCOL *mCpu;
|
||||
STATIC LIST_ENTRY UncachedAllocationList;
|
||||
STATIC EFI_CPU_ARCH_PROTOCOL *mCpu;
|
||||
STATIC LIST_ENTRY UncachedAllocationList;
|
||||
|
||||
STATIC PHYSICAL_ADDRESS mDmaHostAddressLimit;
|
||||
STATIC PHYSICAL_ADDRESS mDmaHostAddressLimit;
|
||||
|
||||
STATIC
|
||||
PHYSICAL_ADDRESS
|
||||
HostToDeviceAddress (
|
||||
IN VOID *Address
|
||||
IN VOID *Address
|
||||
)
|
||||
{
|
||||
return (PHYSICAL_ADDRESS)(UINTN)Address + PcdGet64 (PcdDmaDeviceOffset);
|
||||
@@ -95,13 +94,14 @@ InternalAllocateAlignedPages (
|
||||
if (Pages == 0) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (Alignment > EFI_PAGE_SIZE) {
|
||||
//
|
||||
// Calculate the total number of pages since alignment is larger than page
|
||||
// size.
|
||||
//
|
||||
AlignmentMask = Alignment - 1;
|
||||
RealPages = Pages + EFI_SIZE_TO_PAGES (Alignment);
|
||||
AlignmentMask = Alignment - 1;
|
||||
RealPages = Pages + EFI_SIZE_TO_PAGES (Alignment);
|
||||
//
|
||||
// Make sure that Pages plus EFI_SIZE_TO_PAGES (Alignment) does not
|
||||
// overflow.
|
||||
@@ -109,11 +109,16 @@ InternalAllocateAlignedPages (
|
||||
ASSERT (RealPages > Pages);
|
||||
|
||||
Memory = mDmaHostAddressLimit;
|
||||
Status = gBS->AllocatePages (AllocateMaxAddress, MemoryType, RealPages,
|
||||
&Memory);
|
||||
Status = gBS->AllocatePages (
|
||||
AllocateMaxAddress,
|
||||
MemoryType,
|
||||
RealPages,
|
||||
&Memory
|
||||
);
|
||||
if (EFI_ERROR (Status)) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
AlignedMemory = ((UINTN)Memory + AlignmentMask) & ~AlignmentMask;
|
||||
UnalignedPages = EFI_SIZE_TO_PAGES (AlignedMemory - (UINTN)Memory);
|
||||
if (UnalignedPages > 0) {
|
||||
@@ -123,6 +128,7 @@ InternalAllocateAlignedPages (
|
||||
Status = gBS->FreePages (Memory, UnalignedPages);
|
||||
ASSERT_EFI_ERROR (Status);
|
||||
}
|
||||
|
||||
Memory = AlignedMemory + EFI_PAGES_TO_SIZE (Pages);
|
||||
UnalignedPages = RealPages - Pages - UnalignedPages;
|
||||
if (UnalignedPages > 0) {
|
||||
@@ -137,13 +143,19 @@ InternalAllocateAlignedPages (
|
||||
// Do not over-allocate pages in this case.
|
||||
//
|
||||
Memory = mDmaHostAddressLimit;
|
||||
Status = gBS->AllocatePages (AllocateMaxAddress, MemoryType, Pages,
|
||||
&Memory);
|
||||
Status = gBS->AllocatePages (
|
||||
AllocateMaxAddress,
|
||||
MemoryType,
|
||||
Pages,
|
||||
&Memory
|
||||
);
|
||||
if (EFI_ERROR (Status)) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
AlignedMemory = (UINTN)Memory;
|
||||
}
|
||||
|
||||
return (VOID *)AlignedMemory;
|
||||
}
|
||||
|
||||
@@ -177,23 +189,24 @@ InternalAllocateAlignedPages (
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
DmaMap (
|
||||
IN DMA_MAP_OPERATION Operation,
|
||||
IN VOID *HostAddress,
|
||||
IN OUT UINTN *NumberOfBytes,
|
||||
OUT PHYSICAL_ADDRESS *DeviceAddress,
|
||||
OUT VOID **Mapping
|
||||
IN DMA_MAP_OPERATION Operation,
|
||||
IN VOID *HostAddress,
|
||||
IN OUT UINTN *NumberOfBytes,
|
||||
OUT PHYSICAL_ADDRESS *DeviceAddress,
|
||||
OUT VOID **Mapping
|
||||
)
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
MAP_INFO_INSTANCE *Map;
|
||||
VOID *Buffer;
|
||||
EFI_GCD_MEMORY_SPACE_DESCRIPTOR GcdDescriptor;
|
||||
UINTN AllocSize;
|
||||
EFI_STATUS Status;
|
||||
MAP_INFO_INSTANCE *Map;
|
||||
VOID *Buffer;
|
||||
EFI_GCD_MEMORY_SPACE_DESCRIPTOR GcdDescriptor;
|
||||
UINTN AllocSize;
|
||||
|
||||
if (HostAddress == NULL ||
|
||||
NumberOfBytes == NULL ||
|
||||
DeviceAddress == NULL ||
|
||||
Mapping == NULL ) {
|
||||
if ((HostAddress == NULL) ||
|
||||
(NumberOfBytes == NULL) ||
|
||||
(DeviceAddress == NULL) ||
|
||||
(Mapping == NULL))
|
||||
{
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
@@ -206,19 +219,20 @@ DmaMap (
|
||||
// Remember range so we can flush on the other side
|
||||
Map = AllocatePool (sizeof (MAP_INFO_INSTANCE));
|
||||
if (Map == NULL) {
|
||||
return EFI_OUT_OF_RESOURCES;
|
||||
return EFI_OUT_OF_RESOURCES;
|
||||
}
|
||||
|
||||
if (((UINTN)HostAddress + *NumberOfBytes) > mDmaHostAddressLimit) {
|
||||
|
||||
if (Operation == MapOperationBusMasterCommonBuffer) {
|
||||
goto CommonBufferError;
|
||||
}
|
||||
|
||||
AllocSize = ALIGN_VALUE (*NumberOfBytes, mCpu->DmaBufferAlignment);
|
||||
Map->BufferAddress = InternalAllocateAlignedPages (EfiBootServicesData,
|
||||
AllocSize = ALIGN_VALUE (*NumberOfBytes, mCpu->DmaBufferAlignment);
|
||||
Map->BufferAddress = InternalAllocateAlignedPages (
|
||||
EfiBootServicesData,
|
||||
EFI_SIZE_TO_PAGES (AllocSize),
|
||||
mCpu->DmaBufferAlignment);
|
||||
mCpu->DmaBufferAlignment
|
||||
);
|
||||
if (Map->BufferAddress == NULL) {
|
||||
Status = EFI_OUT_OF_RESOURCES;
|
||||
goto FreeMapInfo;
|
||||
@@ -227,17 +241,22 @@ DmaMap (
|
||||
if (Operation == MapOperationBusMasterRead) {
|
||||
CopyMem (Map->BufferAddress, (VOID *)(UINTN)HostAddress, *NumberOfBytes);
|
||||
}
|
||||
mCpu->FlushDataCache (mCpu, (UINTN)Map->BufferAddress, AllocSize,
|
||||
EfiCpuFlushTypeWriteBack);
|
||||
|
||||
mCpu->FlushDataCache (
|
||||
mCpu,
|
||||
(UINTN)Map->BufferAddress,
|
||||
AllocSize,
|
||||
EfiCpuFlushTypeWriteBack
|
||||
);
|
||||
|
||||
*DeviceAddress = HostToDeviceAddress (Map->BufferAddress);
|
||||
} else if (Operation != MapOperationBusMasterRead &&
|
||||
((((UINTN)HostAddress & (mCpu->DmaBufferAlignment - 1)) != 0) ||
|
||||
((*NumberOfBytes & (mCpu->DmaBufferAlignment - 1)) != 0))) {
|
||||
|
||||
} else if ((Operation != MapOperationBusMasterRead) &&
|
||||
((((UINTN)HostAddress & (mCpu->DmaBufferAlignment - 1)) != 0) ||
|
||||
((*NumberOfBytes & (mCpu->DmaBufferAlignment - 1)) != 0)))
|
||||
{
|
||||
// Get the cacheability of the region
|
||||
Status = gDS->GetMemorySpaceDescriptor ((UINTN)HostAddress, &GcdDescriptor);
|
||||
if (EFI_ERROR(Status)) {
|
||||
if (EFI_ERROR (Status)) {
|
||||
goto FreeMapInfo;
|
||||
}
|
||||
|
||||
@@ -259,15 +278,15 @@ DmaMap (
|
||||
// we only have to add (alignment - 8) worth of padding.
|
||||
//
|
||||
Map->DoubleBuffer = TRUE;
|
||||
AllocSize = ALIGN_VALUE (*NumberOfBytes, mCpu->DmaBufferAlignment) +
|
||||
(mCpu->DmaBufferAlignment - 8);
|
||||
AllocSize = ALIGN_VALUE (*NumberOfBytes, mCpu->DmaBufferAlignment) +
|
||||
(mCpu->DmaBufferAlignment - 8);
|
||||
Map->BufferAddress = AllocatePool (AllocSize);
|
||||
if (Map->BufferAddress == NULL) {
|
||||
Status = EFI_OUT_OF_RESOURCES;
|
||||
goto FreeMapInfo;
|
||||
}
|
||||
|
||||
Buffer = ALIGN_POINTER (Map->BufferAddress, mCpu->DmaBufferAlignment);
|
||||
Buffer = ALIGN_POINTER (Map->BufferAddress, mCpu->DmaBufferAlignment);
|
||||
*DeviceAddress = HostToDeviceAddress (Buffer);
|
||||
|
||||
//
|
||||
@@ -275,13 +294,17 @@ DmaMap (
|
||||
// prevents them from being written back unexpectedly, potentially
|
||||
// overwriting the data we receive from the device.
|
||||
//
|
||||
mCpu->FlushDataCache (mCpu, (UINTN)Buffer, *NumberOfBytes,
|
||||
EfiCpuFlushTypeWriteBack);
|
||||
mCpu->FlushDataCache (
|
||||
mCpu,
|
||||
(UINTN)Buffer,
|
||||
*NumberOfBytes,
|
||||
EfiCpuFlushTypeWriteBack
|
||||
);
|
||||
} else {
|
||||
Map->DoubleBuffer = FALSE;
|
||||
Map->DoubleBuffer = FALSE;
|
||||
}
|
||||
} else {
|
||||
Map->DoubleBuffer = FALSE;
|
||||
Map->DoubleBuffer = FALSE;
|
||||
|
||||
DEBUG_CODE_BEGIN ();
|
||||
|
||||
@@ -293,17 +316,23 @@ DmaMap (
|
||||
// that we are not trying to create a consistent mapping for cached memory.
|
||||
//
|
||||
Status = gDS->GetMemorySpaceDescriptor ((UINTN)HostAddress, &GcdDescriptor);
|
||||
ASSERT_EFI_ERROR(Status);
|
||||
ASSERT_EFI_ERROR (Status);
|
||||
|
||||
ASSERT (Operation != MapOperationBusMasterCommonBuffer ||
|
||||
(GcdDescriptor.Attributes & (EFI_MEMORY_WB | EFI_MEMORY_WT)) == 0);
|
||||
ASSERT (
|
||||
Operation != MapOperationBusMasterCommonBuffer ||
|
||||
(GcdDescriptor.Attributes & (EFI_MEMORY_WB | EFI_MEMORY_WT)) == 0
|
||||
);
|
||||
|
||||
DEBUG_CODE_END ();
|
||||
|
||||
// Flush the Data Cache (should not have any effect if the memory region is
|
||||
// uncached)
|
||||
mCpu->FlushDataCache (mCpu, (UINTN)HostAddress, *NumberOfBytes,
|
||||
EfiCpuFlushTypeWriteBackInvalidate);
|
||||
mCpu->FlushDataCache (
|
||||
mCpu,
|
||||
(UINTN)HostAddress,
|
||||
*NumberOfBytes,
|
||||
EfiCpuFlushTypeWriteBackInvalidate
|
||||
);
|
||||
}
|
||||
|
||||
Map->HostAddress = (UINTN)HostAddress;
|
||||
@@ -315,10 +344,13 @@ DmaMap (
|
||||
return EFI_SUCCESS;
|
||||
|
||||
CommonBufferError:
|
||||
DEBUG ((DEBUG_ERROR,
|
||||
DEBUG ((
|
||||
DEBUG_ERROR,
|
||||
"%a: Operation type 'MapOperationBusMasterCommonBuffer' is only "
|
||||
"supported\non memory regions that were allocated using "
|
||||
"DmaAllocateBuffer ()\n", __FUNCTION__));
|
||||
"DmaAllocateBuffer ()\n",
|
||||
__FUNCTION__
|
||||
));
|
||||
Status = EFI_UNSUPPORTED;
|
||||
FreeMapInfo:
|
||||
FreePool (Map);
|
||||
@@ -326,7 +358,6 @@ FreeMapInfo:
|
||||
return Status;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Completes the DmaMapBusMasterRead(), DmaMapBusMasterWrite(), or
|
||||
DmaMapBusMasterCommonBuffer() operation and releases any corresponding
|
||||
@@ -344,13 +375,13 @@ FreeMapInfo:
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
DmaUnmap (
|
||||
IN VOID *Mapping
|
||||
IN VOID *Mapping
|
||||
)
|
||||
{
|
||||
MAP_INFO_INSTANCE *Map;
|
||||
EFI_STATUS Status;
|
||||
VOID *Buffer;
|
||||
UINTN AllocSize;
|
||||
MAP_INFO_INSTANCE *Map;
|
||||
EFI_STATUS Status;
|
||||
VOID *Buffer;
|
||||
UINTN AllocSize;
|
||||
|
||||
if (Mapping == NULL) {
|
||||
ASSERT (FALSE);
|
||||
@@ -363,14 +394,21 @@ DmaUnmap (
|
||||
if (((UINTN)Map->HostAddress + Map->NumberOfBytes) > mDmaHostAddressLimit) {
|
||||
AllocSize = ALIGN_VALUE (Map->NumberOfBytes, mCpu->DmaBufferAlignment);
|
||||
if (Map->Operation == MapOperationBusMasterWrite) {
|
||||
mCpu->FlushDataCache (mCpu, (UINTN)Map->BufferAddress, AllocSize,
|
||||
EfiCpuFlushTypeInvalidate);
|
||||
CopyMem ((VOID *)(UINTN)Map->HostAddress, Map->BufferAddress,
|
||||
Map->NumberOfBytes);
|
||||
mCpu->FlushDataCache (
|
||||
mCpu,
|
||||
(UINTN)Map->BufferAddress,
|
||||
AllocSize,
|
||||
EfiCpuFlushTypeInvalidate
|
||||
);
|
||||
CopyMem (
|
||||
(VOID *)(UINTN)Map->HostAddress,
|
||||
Map->BufferAddress,
|
||||
Map->NumberOfBytes
|
||||
);
|
||||
}
|
||||
|
||||
FreePages (Map->BufferAddress, EFI_SIZE_TO_PAGES (AllocSize));
|
||||
} else if (Map->DoubleBuffer) {
|
||||
|
||||
ASSERT (Map->Operation == MapOperationBusMasterWrite);
|
||||
|
||||
if (Map->Operation != MapOperationBusMasterWrite) {
|
||||
@@ -378,8 +416,12 @@ DmaUnmap (
|
||||
} else {
|
||||
Buffer = ALIGN_POINTER (Map->BufferAddress, mCpu->DmaBufferAlignment);
|
||||
|
||||
mCpu->FlushDataCache (mCpu, (UINTN)Buffer, Map->NumberOfBytes,
|
||||
EfiCpuFlushTypeInvalidate);
|
||||
mCpu->FlushDataCache (
|
||||
mCpu,
|
||||
(UINTN)Buffer,
|
||||
Map->NumberOfBytes,
|
||||
EfiCpuFlushTypeInvalidate
|
||||
);
|
||||
|
||||
CopyMem ((VOID *)(UINTN)Map->HostAddress, Buffer, Map->NumberOfBytes);
|
||||
|
||||
@@ -390,8 +432,12 @@ DmaUnmap (
|
||||
//
|
||||
// Make sure we read buffer from uncached memory and not the cache
|
||||
//
|
||||
mCpu->FlushDataCache (mCpu, Map->HostAddress, Map->NumberOfBytes,
|
||||
EfiCpuFlushTypeInvalidate);
|
||||
mCpu->FlushDataCache (
|
||||
mCpu,
|
||||
Map->HostAddress,
|
||||
Map->NumberOfBytes,
|
||||
EfiCpuFlushTypeInvalidate
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -418,9 +464,9 @@ DmaUnmap (
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
DmaAllocateBuffer (
|
||||
IN EFI_MEMORY_TYPE MemoryType,
|
||||
IN UINTN Pages,
|
||||
OUT VOID **HostAddress
|
||||
IN EFI_MEMORY_TYPE MemoryType,
|
||||
IN UINTN Pages,
|
||||
OUT VOID **HostAddress
|
||||
)
|
||||
{
|
||||
return DmaAllocateAlignedBuffer (MemoryType, Pages, 0, HostAddress);
|
||||
@@ -446,29 +492,31 @@ DmaAllocateBuffer (
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
DmaAllocateAlignedBuffer (
|
||||
IN EFI_MEMORY_TYPE MemoryType,
|
||||
IN UINTN Pages,
|
||||
IN UINTN Alignment,
|
||||
OUT VOID **HostAddress
|
||||
IN EFI_MEMORY_TYPE MemoryType,
|
||||
IN UINTN Pages,
|
||||
IN UINTN Alignment,
|
||||
OUT VOID **HostAddress
|
||||
)
|
||||
{
|
||||
EFI_GCD_MEMORY_SPACE_DESCRIPTOR GcdDescriptor;
|
||||
VOID *Allocation;
|
||||
UINT64 MemType;
|
||||
UNCACHED_ALLOCATION *Alloc;
|
||||
EFI_STATUS Status;
|
||||
EFI_GCD_MEMORY_SPACE_DESCRIPTOR GcdDescriptor;
|
||||
VOID *Allocation;
|
||||
UINT64 MemType;
|
||||
UNCACHED_ALLOCATION *Alloc;
|
||||
EFI_STATUS Status;
|
||||
|
||||
if (Alignment == 0) {
|
||||
Alignment = EFI_PAGE_SIZE;
|
||||
}
|
||||
|
||||
if (HostAddress == NULL ||
|
||||
(Alignment & (Alignment - 1)) != 0) {
|
||||
if ((HostAddress == NULL) ||
|
||||
((Alignment & (Alignment - 1)) != 0))
|
||||
{
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
if (MemoryType == EfiBootServicesData ||
|
||||
MemoryType == EfiRuntimeServicesData) {
|
||||
if ((MemoryType == EfiBootServicesData) ||
|
||||
(MemoryType == EfiRuntimeServicesData))
|
||||
{
|
||||
Allocation = InternalAllocateAlignedPages (MemoryType, Pages, Alignment);
|
||||
} else {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
@@ -480,7 +528,7 @@ DmaAllocateAlignedBuffer (
|
||||
|
||||
// Get the cacheability of the region
|
||||
Status = gDS->GetMemorySpaceDescriptor ((UINTN)Allocation, &GcdDescriptor);
|
||||
if (EFI_ERROR(Status)) {
|
||||
if (EFI_ERROR (Status)) {
|
||||
goto FreeBuffer;
|
||||
}
|
||||
|
||||
@@ -500,23 +548,27 @@ DmaAllocateAlignedBuffer (
|
||||
}
|
||||
|
||||
Alloc->HostAddress = Allocation;
|
||||
Alloc->NumPages = Pages;
|
||||
Alloc->Attributes = GcdDescriptor.Attributes;
|
||||
Alloc->NumPages = Pages;
|
||||
Alloc->Attributes = GcdDescriptor.Attributes;
|
||||
|
||||
InsertHeadList (&UncachedAllocationList, &Alloc->Link);
|
||||
|
||||
// Remap the region with the new attributes
|
||||
Status = gDS->SetMemorySpaceAttributes ((PHYSICAL_ADDRESS)(UINTN)Allocation,
|
||||
EFI_PAGES_TO_SIZE (Pages),
|
||||
MemType);
|
||||
Status = gDS->SetMemorySpaceAttributes (
|
||||
(PHYSICAL_ADDRESS)(UINTN)Allocation,
|
||||
EFI_PAGES_TO_SIZE (Pages),
|
||||
MemType
|
||||
);
|
||||
if (EFI_ERROR (Status)) {
|
||||
goto FreeAlloc;
|
||||
}
|
||||
|
||||
Status = mCpu->FlushDataCache (mCpu,
|
||||
(PHYSICAL_ADDRESS)(UINTN)Allocation,
|
||||
EFI_PAGES_TO_SIZE (Pages),
|
||||
EfiCpuFlushTypeInvalidate);
|
||||
Status = mCpu->FlushDataCache (
|
||||
mCpu,
|
||||
(PHYSICAL_ADDRESS)(UINTN)Allocation,
|
||||
EFI_PAGES_TO_SIZE (Pages),
|
||||
EfiCpuFlushTypeInvalidate
|
||||
);
|
||||
if (EFI_ERROR (Status)) {
|
||||
goto FreeAlloc;
|
||||
}
|
||||
@@ -534,7 +586,6 @@ FreeBuffer:
|
||||
return Status;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Frees memory that was allocated with DmaAllocateBuffer().
|
||||
|
||||
@@ -551,25 +602,25 @@ FreeBuffer:
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
DmaFreeBuffer (
|
||||
IN UINTN Pages,
|
||||
IN VOID *HostAddress
|
||||
IN UINTN Pages,
|
||||
IN VOID *HostAddress
|
||||
)
|
||||
{
|
||||
LIST_ENTRY *Link;
|
||||
UNCACHED_ALLOCATION *Alloc;
|
||||
BOOLEAN Found;
|
||||
EFI_STATUS Status;
|
||||
LIST_ENTRY *Link;
|
||||
UNCACHED_ALLOCATION *Alloc;
|
||||
BOOLEAN Found;
|
||||
EFI_STATUS Status;
|
||||
|
||||
if (HostAddress == NULL) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
for (Link = GetFirstNode (&UncachedAllocationList), Found = FALSE;
|
||||
!IsNull (&UncachedAllocationList, Link);
|
||||
Link = GetNextNode (&UncachedAllocationList, Link)) {
|
||||
|
||||
Link = GetNextNode (&UncachedAllocationList, Link))
|
||||
{
|
||||
Alloc = BASE_CR (Link, UNCACHED_ALLOCATION, Link);
|
||||
if (Alloc->HostAddress == HostAddress && Alloc->NumPages == Pages) {
|
||||
if ((Alloc->HostAddress == HostAddress) && (Alloc->NumPages == Pages)) {
|
||||
Found = TRUE;
|
||||
break;
|
||||
}
|
||||
@@ -582,9 +633,11 @@ DmaFreeBuffer (
|
||||
|
||||
RemoveEntryList (&Alloc->Link);
|
||||
|
||||
Status = gDS->SetMemorySpaceAttributes ((PHYSICAL_ADDRESS)(UINTN)HostAddress,
|
||||
EFI_PAGES_TO_SIZE (Pages),
|
||||
Alloc->Attributes);
|
||||
Status = gDS->SetMemorySpaceAttributes (
|
||||
(PHYSICAL_ADDRESS)(UINTN)HostAddress,
|
||||
EFI_PAGES_TO_SIZE (Pages),
|
||||
Alloc->Attributes
|
||||
);
|
||||
if (EFI_ERROR (Status)) {
|
||||
goto FreeAlloc;
|
||||
}
|
||||
@@ -600,12 +653,11 @@ FreeAlloc:
|
||||
return Status;
|
||||
}
|
||||
|
||||
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
NonCoherentDmaLibConstructor (
|
||||
IN EFI_HANDLE ImageHandle,
|
||||
IN EFI_SYSTEM_TABLE *SystemTable
|
||||
IN EFI_HANDLE ImageHandle,
|
||||
IN EFI_SYSTEM_TABLE *SystemTable
|
||||
)
|
||||
{
|
||||
InitializeListHead (&UncachedAllocationList);
|
||||
|
@@ -15,121 +15,121 @@
|
||||
#include <Library/MemoryAllocationLib.h>
|
||||
#include <Library/NorFlashInfoLib.h>
|
||||
|
||||
STATIC CONST NOR_FLASH_INFO NorFlashIds[] = {
|
||||
STATIC CONST NOR_FLASH_INFO NorFlashIds[] = {
|
||||
/* ATMEL */
|
||||
{L"at45db011d", {0x1f, 0x22, 0x00}, 3, 256, 64 * 1024, 4, NOR_FLASH_ERASE_4K},
|
||||
{L"at45db021d", {0x1f, 0x23, 0x00}, 3, 256, 64 * 1024, 8, NOR_FLASH_ERASE_4K},
|
||||
{L"at45db041d", {0x1f, 0x24, 0x00}, 3, 256, 64 * 1024, 8, NOR_FLASH_ERASE_4K},
|
||||
{L"at45db081d", {0x1f, 0x25, 0x00}, 3, 256, 64 * 1024, 16, NOR_FLASH_ERASE_4K},
|
||||
{L"at45db161d", {0x1f, 0x26, 0x00}, 3, 256, 64 * 1024, 32, NOR_FLASH_ERASE_4K},
|
||||
{L"at45db321d", {0x1f, 0x27, 0x00}, 3, 256, 64 * 1024, 64, NOR_FLASH_ERASE_4K},
|
||||
{L"at45db641d", {0x1f, 0x28, 0x00}, 3, 256, 64 * 1024, 128, NOR_FLASH_ERASE_4K},
|
||||
{L"at25df321a", {0x1f, 0x47, 0x01}, 3, 256, 64 * 1024, 64, NOR_FLASH_ERASE_4K},
|
||||
{L"at25df321", {0x1f, 0x47, 0x00}, 3, 256, 64 * 1024, 64, NOR_FLASH_ERASE_4K},
|
||||
{L"at26df081a", {0x1f, 0x45, 0x01}, 3, 256, 64 * 1024, 16, NOR_FLASH_ERASE_4K},
|
||||
{ L"at45db011d", { 0x1f, 0x22, 0x00 }, 3, 256, 64 * 1024, 4, NOR_FLASH_ERASE_4K },
|
||||
{ L"at45db021d", { 0x1f, 0x23, 0x00 }, 3, 256, 64 * 1024, 8, NOR_FLASH_ERASE_4K },
|
||||
{ L"at45db041d", { 0x1f, 0x24, 0x00 }, 3, 256, 64 * 1024, 8, NOR_FLASH_ERASE_4K },
|
||||
{ L"at45db081d", { 0x1f, 0x25, 0x00 }, 3, 256, 64 * 1024, 16, NOR_FLASH_ERASE_4K },
|
||||
{ L"at45db161d", { 0x1f, 0x26, 0x00 }, 3, 256, 64 * 1024, 32, NOR_FLASH_ERASE_4K },
|
||||
{ L"at45db321d", { 0x1f, 0x27, 0x00 }, 3, 256, 64 * 1024, 64, NOR_FLASH_ERASE_4K },
|
||||
{ L"at45db641d", { 0x1f, 0x28, 0x00 }, 3, 256, 64 * 1024, 128, NOR_FLASH_ERASE_4K },
|
||||
{ L"at25df321a", { 0x1f, 0x47, 0x01 }, 3, 256, 64 * 1024, 64, NOR_FLASH_ERASE_4K },
|
||||
{ L"at25df321", { 0x1f, 0x47, 0x00 }, 3, 256, 64 * 1024, 64, NOR_FLASH_ERASE_4K },
|
||||
{ L"at26df081a", { 0x1f, 0x45, 0x01 }, 3, 256, 64 * 1024, 16, NOR_FLASH_ERASE_4K },
|
||||
/* EON */
|
||||
{L"en25q32b", {0x1c, 0x30, 0x16}, 3, 256, 64 * 1024, 64, 0},
|
||||
{L"en25q64", {0x1c, 0x30, 0x17}, 3, 256, 64 * 1024, 128, NOR_FLASH_ERASE_4K},
|
||||
{L"en25q128b", {0x1c, 0x30, 0x18}, 3, 256, 64 * 1024, 256, 0},
|
||||
{L"en25s64", {0x1c, 0x38, 0x17}, 3, 256, 64 * 1024, 128, 0},
|
||||
{ L"en25q32b", { 0x1c, 0x30, 0x16 }, 3, 256, 64 * 1024, 64, 0 },
|
||||
{ L"en25q64", { 0x1c, 0x30, 0x17 }, 3, 256, 64 * 1024, 128, NOR_FLASH_ERASE_4K },
|
||||
{ L"en25q128b", { 0x1c, 0x30, 0x18 }, 3, 256, 64 * 1024, 256, 0 },
|
||||
{ L"en25s64", { 0x1c, 0x38, 0x17 }, 3, 256, 64 * 1024, 128, 0 },
|
||||
/* GIGADEVICE */
|
||||
{L"gd25q64b", {0xc8, 0x40, 0x17}, 3, 256, 64 * 1024, 128, NOR_FLASH_ERASE_4K},
|
||||
{L"gd25lq32", {0xc8, 0x60, 0x16}, 3, 256, 64 * 1024, 64, NOR_FLASH_ERASE_4K},
|
||||
{ L"gd25q64b", { 0xc8, 0x40, 0x17 }, 3, 256, 64 * 1024, 128, NOR_FLASH_ERASE_4K },
|
||||
{ L"gd25lq32", { 0xc8, 0x60, 0x16 }, 3, 256, 64 * 1024, 64, NOR_FLASH_ERASE_4K },
|
||||
/* ISSI */
|
||||
{L"is25lp032", {0x9d, 0x60, 0x16}, 3, 256, 64 * 1024, 64, 0},
|
||||
{L"is25lp064", {0x9d, 0x60, 0x17}, 3, 256, 64 * 1024, 128, 0},
|
||||
{L"is25lp128", {0x9d, 0x60, 0x18}, 3, 256, 64 * 1024, 256, 0},
|
||||
{ L"is25lp032", { 0x9d, 0x60, 0x16 }, 3, 256, 64 * 1024, 64, 0 },
|
||||
{ L"is25lp064", { 0x9d, 0x60, 0x17 }, 3, 256, 64 * 1024, 128, 0 },
|
||||
{ L"is25lp128", { 0x9d, 0x60, 0x18 }, 3, 256, 64 * 1024, 256, 0 },
|
||||
/* MACRONIX */
|
||||
{L"mx25l2006e", {0xc2, 0x20, 0x12}, 3, 256, 64 * 1024, 4, 0},
|
||||
{L"mx25l4005", {0xc2, 0x20, 0x13}, 3, 256, 64 * 1024, 8, 0},
|
||||
{L"mx25l8005", {0xc2, 0x20, 0x14}, 3, 256, 64 * 1024, 16, 0},
|
||||
{L"mx25l1605d", {0xc2, 0x20, 0x15}, 3, 256, 64 * 1024, 32, 0},
|
||||
{L"mx25l3205d", {0xc2, 0x20, 0x16}, 3, 256, 64 * 1024, 64, 0},
|
||||
{L"mx25l6405d", {0xc2, 0x20, 0x17}, 3, 256, 64 * 1024, 128, 0},
|
||||
{L"mx25l12805", {0xc2, 0x20, 0x18}, 3, 256, 64 * 1024, 256, 0},
|
||||
{L"mx25l25635f", {0xc2, 0x20, 0x19}, 3, 256, 64 * 1024, 512, 0},
|
||||
{L"mx25l51235f", {0xc2, 0x20, 0x1a}, 3, 256, 64 * 1024, 1024, 0},
|
||||
{L"mx25l12855e", {0xc2, 0x26, 0x18}, 3, 256, 64 * 1024, 256, 0},
|
||||
{L"mx66u51235f", {0xc2, 0x25, 0x3a}, 3, 256, 64 * 1024, 1024, 0},
|
||||
{L"mx66u1g45g", {0xc2, 0x25, 0x3b}, 3, 256, 64 * 1024, 2048, 0},
|
||||
{L"mx66l1g45g", {0xc2, 0x20, 0x1b}, 3, 256, 64 * 1024, 2048, 0},
|
||||
{ L"mx25l2006e", { 0xc2, 0x20, 0x12 }, 3, 256, 64 * 1024, 4, 0 },
|
||||
{ L"mx25l4005", { 0xc2, 0x20, 0x13 }, 3, 256, 64 * 1024, 8, 0 },
|
||||
{ L"mx25l8005", { 0xc2, 0x20, 0x14 }, 3, 256, 64 * 1024, 16, 0 },
|
||||
{ L"mx25l1605d", { 0xc2, 0x20, 0x15 }, 3, 256, 64 * 1024, 32, 0 },
|
||||
{ L"mx25l3205d", { 0xc2, 0x20, 0x16 }, 3, 256, 64 * 1024, 64, 0 },
|
||||
{ L"mx25l6405d", { 0xc2, 0x20, 0x17 }, 3, 256, 64 * 1024, 128, 0 },
|
||||
{ L"mx25l12805", { 0xc2, 0x20, 0x18 }, 3, 256, 64 * 1024, 256, 0 },
|
||||
{ L"mx25l25635f", { 0xc2, 0x20, 0x19 }, 3, 256, 64 * 1024, 512, 0 },
|
||||
{ L"mx25l51235f", { 0xc2, 0x20, 0x1a }, 3, 256, 64 * 1024, 1024, 0 },
|
||||
{ L"mx25l12855e", { 0xc2, 0x26, 0x18 }, 3, 256, 64 * 1024, 256, 0 },
|
||||
{ L"mx66u51235f", { 0xc2, 0x25, 0x3a }, 3, 256, 64 * 1024, 1024, 0 },
|
||||
{ L"mx66u1g45g", { 0xc2, 0x25, 0x3b }, 3, 256, 64 * 1024, 2048, 0 },
|
||||
{ L"mx66l1g45g", { 0xc2, 0x20, 0x1b }, 3, 256, 64 * 1024, 2048, 0 },
|
||||
/* SPANSION */
|
||||
{L"s25fl008a", {0x01, 0x02, 0x13}, 3, 256, 64 * 1024, 16, 0},
|
||||
{L"s25fl016a", {0x01, 0x02, 0x14}, 3, 256, 64 * 1024, 32, 0},
|
||||
{L"s25fl032a", {0x01, 0x02, 0x15}, 3, 256, 64 * 1024, 64, 0},
|
||||
{L"s25fl064a", {0x01, 0x02, 0x16}, 3, 256, 64 * 1024, 128, 0},
|
||||
{L"s25fl116k", {0x01, 0x40, 0x15}, 3, 256, 64 * 1024, 128, 0},
|
||||
{L"s25fl164k", {0x01, 0x40, 0x17, 0x01, 0x40}, 5, 256, 64 * 1024, 128, 0},
|
||||
{L"s25fl128p_256k", {0x01, 0x20, 0x18, 0x03, 0x00}, 5, 256, 256 * 1024, 64, 0},
|
||||
{L"s25fl128p_64k", {0x01, 0x20, 0x18, 0x03, 0x01}, 5, 256, 64 * 1024, 256, 0},
|
||||
{L"s25fl032p", {0x01, 0x02, 0x15, 0x4d, 0x00}, 5, 256, 64 * 1024, 64, 0},
|
||||
{L"s25fl064p", {0x01, 0x02, 0x16, 0x4d, 0x00}, 5, 256, 64 * 1024, 128, 0},
|
||||
{L"s25fl128s_256k", {0x01, 0x20, 0x18, 0x4d, 0x00}, 5, 256, 256 * 1024, 64, 0},
|
||||
{L"s25fl128s_64k", {0x01, 0x20, 0x18, 0x4d, 0x01}, 5, 256, 64 * 1024, 256, 0},
|
||||
{L"s25fl256s_256k", {0x01, 0x02, 0x19, 0x4d, 0x00}, 5, 256, 256 * 1024, 128, 0},
|
||||
{L"s25fl256s_64k", {0x01, 0x02, 0x19, 0x4d, 0x01}, 5, 256, 64 * 1024, 512, 0},
|
||||
{L"s25fl512s_256k", {0x01, 0x02, 0x20, 0x4d, 0x00}, 5, 256, 256 * 1024, 256, 0},
|
||||
{L"s25fl512s_64k", {0x01, 0x02, 0x20, 0x4d, 0x01}, 5, 256, 64 * 1024, 1024, 0},
|
||||
{L"s25fl512s_512k", {0x01, 0x02, 0x20, 0x4f, 0x00}, 5, 256, 256 * 1024, 256, 0},
|
||||
{ L"s25fl008a", { 0x01, 0x02, 0x13 }, 3, 256, 64 * 1024, 16, 0 },
|
||||
{ L"s25fl016a", { 0x01, 0x02, 0x14 }, 3, 256, 64 * 1024, 32, 0 },
|
||||
{ L"s25fl032a", { 0x01, 0x02, 0x15 }, 3, 256, 64 * 1024, 64, 0 },
|
||||
{ L"s25fl064a", { 0x01, 0x02, 0x16 }, 3, 256, 64 * 1024, 128, 0 },
|
||||
{ L"s25fl116k", { 0x01, 0x40, 0x15 }, 3, 256, 64 * 1024, 128, 0 },
|
||||
{ L"s25fl164k", { 0x01, 0x40, 0x17, 0x01, 0x40}, 5, 256, 64 * 1024, 128, 0 },
|
||||
{ L"s25fl128p_256k", { 0x01, 0x20, 0x18, 0x03, 0x00}, 5, 256, 256 * 1024, 64, 0 },
|
||||
{ L"s25fl128p_64k", { 0x01, 0x20, 0x18, 0x03, 0x01}, 5, 256, 64 * 1024, 256, 0 },
|
||||
{ L"s25fl032p", { 0x01, 0x02, 0x15, 0x4d, 0x00}, 5, 256, 64 * 1024, 64, 0 },
|
||||
{ L"s25fl064p", { 0x01, 0x02, 0x16, 0x4d, 0x00}, 5, 256, 64 * 1024, 128, 0 },
|
||||
{ L"s25fl128s_256k", { 0x01, 0x20, 0x18, 0x4d, 0x00}, 5, 256, 256 * 1024, 64, 0 },
|
||||
{ L"s25fl128s_64k", { 0x01, 0x20, 0x18, 0x4d, 0x01}, 5, 256, 64 * 1024, 256, 0 },
|
||||
{ L"s25fl256s_256k", { 0x01, 0x02, 0x19, 0x4d, 0x00}, 5, 256, 256 * 1024, 128, 0 },
|
||||
{ L"s25fl256s_64k", { 0x01, 0x02, 0x19, 0x4d, 0x01}, 5, 256, 64 * 1024, 512, 0 },
|
||||
{ L"s25fl512s_256k", { 0x01, 0x02, 0x20, 0x4d, 0x00}, 5, 256, 256 * 1024, 256, 0 },
|
||||
{ L"s25fl512s_64k", { 0x01, 0x02, 0x20, 0x4d, 0x01}, 5, 256, 64 * 1024, 1024, 0 },
|
||||
{ L"s25fl512s_512k", { 0x01, 0x02, 0x20, 0x4f, 0x00}, 5, 256, 256 * 1024, 256, 0 },
|
||||
/* STMICRO */
|
||||
{L"m25p10", {0x20, 0x20, 0x11}, 3, 256, 32 * 1024, 4, 0},
|
||||
{L"m25p20", {0x20, 0x20, 0x12}, 3, 256, 64 * 1024, 4, 0},
|
||||
{L"m25p40", {0x20, 0x20, 0x13}, 3, 256, 64 * 1024, 8, 0},
|
||||
{L"m25p80", {0x20, 0x20, 0x14}, 3, 256, 64 * 1024, 16, 0},
|
||||
{L"m25p16", {0x20, 0x20, 0x15}, 3, 256, 64 * 1024, 32, 0},
|
||||
{L"m25pE16", {0x20, 0x80, 0x15, 0x10, 0x00}, 5, 256, 64 * 1024, 32, 0},
|
||||
{L"m25pX16", {0x20, 0x71, 0x15, 0x10, 0x00}, 5, 256, 64 * 1024, 32, 0},
|
||||
{L"m25p32", {0x20, 0x20, 0x16}, 3, 256, 64 * 1024, 64, 0},
|
||||
{L"m25p64", {0x20, 0x20, 0x17}, 3, 256, 64 * 1024, 128, 0},
|
||||
{L"m25p128", {0x20, 0x20, 0x18}, 3, 256, 256 * 1024, 64, 0},
|
||||
{L"m25pX64", {0x20, 0x71, 0x17}, 3, 256, 64 * 1024, 128, NOR_FLASH_ERASE_4K},
|
||||
{L"n25q016a", {0x20, 0xbb, 0x15}, 3, 256, 64 * 1024, 32, NOR_FLASH_ERASE_4K},
|
||||
{L"n25q32", {0x20, 0xba, 0x16}, 3, 256, 64 * 1024, 64, NOR_FLASH_ERASE_4K},
|
||||
{L"n25q32a", {0x20, 0xbb, 0x16}, 3, 256, 64 * 1024, 64, NOR_FLASH_ERASE_4K},
|
||||
{L"n25q64", {0x20, 0xba, 0x17}, 3, 256, 64 * 1024, 128, NOR_FLASH_ERASE_4K},
|
||||
{L"n25q64a", {0x20, 0xbb, 0x17}, 3, 256, 64 * 1024, 128, NOR_FLASH_ERASE_4K},
|
||||
{L"n25q128", {0x20, 0xba, 0x18}, 3, 256, 64 * 1024, 256, 0},
|
||||
{L"n25q128a", {0x20, 0xbb, 0x18}, 3, 256, 64 * 1024, 256, 0},
|
||||
{L"n25q256", {0x20, 0xba, 0x19}, 3, 256, 64 * 1024, 512, NOR_FLASH_ERASE_4K},
|
||||
{L"n25q256a", {0x20, 0xbb, 0x19}, 3, 256, 64 * 1024, 512, NOR_FLASH_ERASE_4K},
|
||||
{L"n25q512", {0x20, 0xba, 0x20}, 3, 256, 64 * 1024, 1024, NOR_FLASH_WRITE_FSR | NOR_FLASH_ERASE_4K},
|
||||
{L"n25q512a", {0x20, 0xbb, 0x20}, 3, 256, 64 * 1024, 1024, NOR_FLASH_WRITE_FSR | NOR_FLASH_ERASE_4K},
|
||||
{L"n25q1024", {0x20, 0xba, 0x21}, 3, 256, 64 * 1024, 2048, NOR_FLASH_WRITE_FSR | NOR_FLASH_ERASE_4K},
|
||||
{L"n25q1024a", {0x20, 0xbb, 0x21}, 3, 256, 64 * 1024, 2048, NOR_FLASH_WRITE_FSR | NOR_FLASH_ERASE_4K},
|
||||
{L"mt25qu02g", {0x20, 0xbb, 0x22}, 3, 256, 64 * 1024, 4096, NOR_FLASH_WRITE_FSR | NOR_FLASH_ERASE_4K},
|
||||
{L"mt25ql02g", {0x20, 0xba, 0x22}, 3, 256, 64 * 1024, 4096, NOR_FLASH_WRITE_FSR | NOR_FLASH_ERASE_4K},
|
||||
{ L"m25p10", { 0x20, 0x20, 0x11 }, 3, 256, 32 * 1024, 4, 0 },
|
||||
{ L"m25p20", { 0x20, 0x20, 0x12 }, 3, 256, 64 * 1024, 4, 0 },
|
||||
{ L"m25p40", { 0x20, 0x20, 0x13 }, 3, 256, 64 * 1024, 8, 0 },
|
||||
{ L"m25p80", { 0x20, 0x20, 0x14 }, 3, 256, 64 * 1024, 16, 0 },
|
||||
{ L"m25p16", { 0x20, 0x20, 0x15 }, 3, 256, 64 * 1024, 32, 0 },
|
||||
{ L"m25pE16", { 0x20, 0x80, 0x15, 0x10, 0x00}, 5, 256, 64 * 1024, 32, 0 },
|
||||
{ L"m25pX16", { 0x20, 0x71, 0x15, 0x10, 0x00}, 5, 256, 64 * 1024, 32, 0 },
|
||||
{ L"m25p32", { 0x20, 0x20, 0x16 }, 3, 256, 64 * 1024, 64, 0 },
|
||||
{ L"m25p64", { 0x20, 0x20, 0x17 }, 3, 256, 64 * 1024, 128, 0 },
|
||||
{ L"m25p128", { 0x20, 0x20, 0x18 }, 3, 256, 256 * 1024, 64, 0 },
|
||||
{ L"m25pX64", { 0x20, 0x71, 0x17 }, 3, 256, 64 * 1024, 128, NOR_FLASH_ERASE_4K },
|
||||
{ L"n25q016a", { 0x20, 0xbb, 0x15 }, 3, 256, 64 * 1024, 32, NOR_FLASH_ERASE_4K },
|
||||
{ L"n25q32", { 0x20, 0xba, 0x16 }, 3, 256, 64 * 1024, 64, NOR_FLASH_ERASE_4K },
|
||||
{ L"n25q32a", { 0x20, 0xbb, 0x16 }, 3, 256, 64 * 1024, 64, NOR_FLASH_ERASE_4K },
|
||||
{ L"n25q64", { 0x20, 0xba, 0x17 }, 3, 256, 64 * 1024, 128, NOR_FLASH_ERASE_4K },
|
||||
{ L"n25q64a", { 0x20, 0xbb, 0x17 }, 3, 256, 64 * 1024, 128, NOR_FLASH_ERASE_4K },
|
||||
{ L"n25q128", { 0x20, 0xba, 0x18 }, 3, 256, 64 * 1024, 256, 0 },
|
||||
{ L"n25q128a", { 0x20, 0xbb, 0x18 }, 3, 256, 64 * 1024, 256, 0 },
|
||||
{ L"n25q256", { 0x20, 0xba, 0x19 }, 3, 256, 64 * 1024, 512, NOR_FLASH_ERASE_4K },
|
||||
{ L"n25q256a", { 0x20, 0xbb, 0x19 }, 3, 256, 64 * 1024, 512, NOR_FLASH_ERASE_4K },
|
||||
{ L"n25q512", { 0x20, 0xba, 0x20 }, 3, 256, 64 * 1024, 1024, NOR_FLASH_WRITE_FSR | NOR_FLASH_ERASE_4K },
|
||||
{ L"n25q512a", { 0x20, 0xbb, 0x20 }, 3, 256, 64 * 1024, 1024, NOR_FLASH_WRITE_FSR | NOR_FLASH_ERASE_4K },
|
||||
{ L"n25q1024", { 0x20, 0xba, 0x21 }, 3, 256, 64 * 1024, 2048, NOR_FLASH_WRITE_FSR | NOR_FLASH_ERASE_4K },
|
||||
{ L"n25q1024a", { 0x20, 0xbb, 0x21 }, 3, 256, 64 * 1024, 2048, NOR_FLASH_WRITE_FSR | NOR_FLASH_ERASE_4K },
|
||||
{ L"mt25qu02g", { 0x20, 0xbb, 0x22 }, 3, 256, 64 * 1024, 4096, NOR_FLASH_WRITE_FSR | NOR_FLASH_ERASE_4K },
|
||||
{ L"mt25ql02g", { 0x20, 0xba, 0x22 }, 3, 256, 64 * 1024, 4096, NOR_FLASH_WRITE_FSR | NOR_FLASH_ERASE_4K },
|
||||
/* SST */
|
||||
{L"sst25vf040b", {0xbf, 0x25, 0x8d}, 3, 256, 64 * 1024, 8, NOR_FLASH_ERASE_4K},
|
||||
{L"sst25vf080b", {0xbf, 0x25, 0x8e}, 3, 256, 64 * 1024, 16, NOR_FLASH_ERASE_4K},
|
||||
{L"sst25vf016b", {0xbf, 0x25, 0x41}, 3, 256, 64 * 1024, 32, NOR_FLASH_ERASE_4K},
|
||||
{L"sst25vf032b", {0xbf, 0x25, 0x4a}, 3, 256, 64 * 1024, 64, NOR_FLASH_ERASE_4K},
|
||||
{L"sst25vf064c", {0xbf, 0x25, 0x4b}, 3, 256, 64 * 1024, 128, NOR_FLASH_ERASE_4K},
|
||||
{L"sst25wf512", {0xbf, 0x25, 0x01}, 3, 256, 64 * 1024, 1, NOR_FLASH_ERASE_4K},
|
||||
{L"sst25wf010", {0xbf, 0x25, 0x02}, 3, 256, 64 * 1024, 2, NOR_FLASH_ERASE_4K},
|
||||
{L"sst25wf020", {0xbf, 0x25, 0x03}, 3, 256, 64 * 1024, 4, NOR_FLASH_ERASE_4K},
|
||||
{L"sst25wf040", {0xbf, 0x25, 0x04}, 3, 256, 64 * 1024, 8, NOR_FLASH_ERASE_4K},
|
||||
{L"sst25wf040b", {0x62, 0x16, 0x13}, 3, 256, 64 * 1024, 8, NOR_FLASH_ERASE_4K},
|
||||
{L"sst25wf080", {0xbf, 0x25, 0x05}, 3, 256, 64 * 1024, 16, NOR_FLASH_ERASE_4K},
|
||||
{ L"sst25vf040b", { 0xbf, 0x25, 0x8d }, 3, 256, 64 * 1024, 8, NOR_FLASH_ERASE_4K },
|
||||
{ L"sst25vf080b", { 0xbf, 0x25, 0x8e }, 3, 256, 64 * 1024, 16, NOR_FLASH_ERASE_4K },
|
||||
{ L"sst25vf016b", { 0xbf, 0x25, 0x41 }, 3, 256, 64 * 1024, 32, NOR_FLASH_ERASE_4K },
|
||||
{ L"sst25vf032b", { 0xbf, 0x25, 0x4a }, 3, 256, 64 * 1024, 64, NOR_FLASH_ERASE_4K },
|
||||
{ L"sst25vf064c", { 0xbf, 0x25, 0x4b }, 3, 256, 64 * 1024, 128, NOR_FLASH_ERASE_4K },
|
||||
{ L"sst25wf512", { 0xbf, 0x25, 0x01 }, 3, 256, 64 * 1024, 1, NOR_FLASH_ERASE_4K },
|
||||
{ L"sst25wf010", { 0xbf, 0x25, 0x02 }, 3, 256, 64 * 1024, 2, NOR_FLASH_ERASE_4K },
|
||||
{ L"sst25wf020", { 0xbf, 0x25, 0x03 }, 3, 256, 64 * 1024, 4, NOR_FLASH_ERASE_4K },
|
||||
{ L"sst25wf040", { 0xbf, 0x25, 0x04 }, 3, 256, 64 * 1024, 8, NOR_FLASH_ERASE_4K },
|
||||
{ L"sst25wf040b", { 0x62, 0x16, 0x13 }, 3, 256, 64 * 1024, 8, NOR_FLASH_ERASE_4K },
|
||||
{ L"sst25wf080", { 0xbf, 0x25, 0x05 }, 3, 256, 64 * 1024, 16, NOR_FLASH_ERASE_4K },
|
||||
/* WINBOND */
|
||||
{L"w25p80", {0xef, 0x20, 0x14}, 3, 256, 64 * 1024, 16, 0},
|
||||
{L"w25p16", {0xef, 0x20, 0x15}, 3, 256, 64 * 1024, 32, 0},
|
||||
{L"w25p32", {0xef, 0x20, 0x16}, 3, 256, 64 * 1024, 64, 0},
|
||||
{L"w25x40", {0xef, 0x30, 0x13}, 3, 256, 64 * 1024, 8, NOR_FLASH_ERASE_4K},
|
||||
{L"w25x16", {0xef, 0x30, 0x15}, 3, 256, 64 * 1024, 32, NOR_FLASH_ERASE_4K},
|
||||
{L"w25x32", {0xef, 0x30, 0x16}, 3, 256, 64 * 1024, 64, NOR_FLASH_ERASE_4K},
|
||||
{L"w25x64", {0xef, 0x30, 0x17}, 3, 256, 64 * 1024, 128, NOR_FLASH_ERASE_4K},
|
||||
{L"w25q80bl", {0xef, 0x40, 0x14}, 3, 256, 64 * 1024, 16, NOR_FLASH_ERASE_4K},
|
||||
{L"w25q16cl", {0xef, 0x40, 0x15}, 3, 256, 64 * 1024, 32, NOR_FLASH_ERASE_4K},
|
||||
{L"w25q32bv", {0xef, 0x40, 0x16}, 3, 256, 64 * 1024, 64, NOR_FLASH_ERASE_4K},
|
||||
{L"w25q64cv", {0xef, 0x40, 0x17}, 3, 256, 64 * 1024, 128, NOR_FLASH_ERASE_4K},
|
||||
{L"w25q128bv", {0xef, 0x40, 0x18}, 3, 256, 64 * 1024, 256, NOR_FLASH_ERASE_4K},
|
||||
{L"w25q256", {0xef, 0x40, 0x19}, 3, 256, 64 * 1024, 512, NOR_FLASH_ERASE_4K},
|
||||
{L"w25q80bw", {0xef, 0x50, 0x14}, 3, 256, 64 * 1024, 16, NOR_FLASH_ERASE_4K},
|
||||
{L"w25q16dw", {0xef, 0x60, 0x15}, 3, 256, 64 * 1024, 32, NOR_FLASH_ERASE_4K},
|
||||
{L"w25q32dw", {0xef, 0x60, 0x16}, 3, 256, 64 * 1024, 64, NOR_FLASH_ERASE_4K},
|
||||
{L"w25q64dw", {0xef, 0x60, 0x17}, 3, 256, 64 * 1024, 128, NOR_FLASH_ERASE_4K},
|
||||
{L"w25q128fw", {0xef, 0x60, 0x18}, 3, 256, 64 * 1024, 256, NOR_FLASH_ERASE_4K},
|
||||
{}, /* Empty entry to terminate the list */
|
||||
{ L"w25p80", { 0xef, 0x20, 0x14 }, 3, 256, 64 * 1024, 16, 0 },
|
||||
{ L"w25p16", { 0xef, 0x20, 0x15 }, 3, 256, 64 * 1024, 32, 0 },
|
||||
{ L"w25p32", { 0xef, 0x20, 0x16 }, 3, 256, 64 * 1024, 64, 0 },
|
||||
{ L"w25x40", { 0xef, 0x30, 0x13 }, 3, 256, 64 * 1024, 8, NOR_FLASH_ERASE_4K },
|
||||
{ L"w25x16", { 0xef, 0x30, 0x15 }, 3, 256, 64 * 1024, 32, NOR_FLASH_ERASE_4K },
|
||||
{ L"w25x32", { 0xef, 0x30, 0x16 }, 3, 256, 64 * 1024, 64, NOR_FLASH_ERASE_4K },
|
||||
{ L"w25x64", { 0xef, 0x30, 0x17 }, 3, 256, 64 * 1024, 128, NOR_FLASH_ERASE_4K },
|
||||
{ L"w25q80bl", { 0xef, 0x40, 0x14 }, 3, 256, 64 * 1024, 16, NOR_FLASH_ERASE_4K },
|
||||
{ L"w25q16cl", { 0xef, 0x40, 0x15 }, 3, 256, 64 * 1024, 32, NOR_FLASH_ERASE_4K },
|
||||
{ L"w25q32bv", { 0xef, 0x40, 0x16 }, 3, 256, 64 * 1024, 64, NOR_FLASH_ERASE_4K },
|
||||
{ L"w25q64cv", { 0xef, 0x40, 0x17 }, 3, 256, 64 * 1024, 128, NOR_FLASH_ERASE_4K },
|
||||
{ L"w25q128bv", { 0xef, 0x40, 0x18 }, 3, 256, 64 * 1024, 256, NOR_FLASH_ERASE_4K },
|
||||
{ L"w25q256", { 0xef, 0x40, 0x19 }, 3, 256, 64 * 1024, 512, NOR_FLASH_ERASE_4K },
|
||||
{ L"w25q80bw", { 0xef, 0x50, 0x14 }, 3, 256, 64 * 1024, 16, NOR_FLASH_ERASE_4K },
|
||||
{ L"w25q16dw", { 0xef, 0x60, 0x15 }, 3, 256, 64 * 1024, 32, NOR_FLASH_ERASE_4K },
|
||||
{ L"w25q32dw", { 0xef, 0x60, 0x16 }, 3, 256, 64 * 1024, 64, NOR_FLASH_ERASE_4K },
|
||||
{ L"w25q64dw", { 0xef, 0x60, 0x17 }, 3, 256, 64 * 1024, 128, NOR_FLASH_ERASE_4K },
|
||||
{ L"w25q128fw", { 0xef, 0x60, 0x18 }, 3, 256, 64 * 1024, 256, NOR_FLASH_ERASE_4K },
|
||||
{ }, /* Empty entry to terminate the list */
|
||||
};
|
||||
|
||||
/**
|
||||
@@ -151,18 +151,18 @@ STATIC CONST NOR_FLASH_INFO NorFlashIds[] = {
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
NorFlashGetInfo (
|
||||
IN UINT8 *Id,
|
||||
IN UINT8 *Id,
|
||||
IN OUT NOR_FLASH_INFO **FlashInfo,
|
||||
IN BOOLEAN AllocateForRuntime
|
||||
IN BOOLEAN AllocateForRuntime
|
||||
)
|
||||
{
|
||||
CONST NOR_FLASH_INFO *TmpInfo;
|
||||
CONST NOR_FLASH_INFO *TmpInfo;
|
||||
|
||||
/*
|
||||
* Iterate over NorFlashIds table, in order to find matching entry.
|
||||
*/
|
||||
TmpInfo = NorFlashIds;
|
||||
for (; TmpInfo->Name != NULL; TmpInfo++) {
|
||||
for ( ; TmpInfo->Name != NULL; TmpInfo++) {
|
||||
if (CompareMem (TmpInfo->Id, Id, TmpInfo->IdLen) == 0) {
|
||||
break;
|
||||
}
|
||||
@@ -183,6 +183,7 @@ NorFlashGetInfo (
|
||||
} else {
|
||||
*FlashInfo = AllocateCopyPool (sizeof (NOR_FLASH_INFO), TmpInfo);
|
||||
}
|
||||
|
||||
if (FlashInfo == NULL) {
|
||||
return EFI_OUT_OF_RESOURCES;
|
||||
}
|
||||
@@ -203,7 +204,7 @@ NorFlashPrintInfo (
|
||||
IN NOR_FLASH_INFO *Info
|
||||
)
|
||||
{
|
||||
UINTN EraseSize;
|
||||
UINTN EraseSize;
|
||||
|
||||
if (Info->Flags & NOR_FLASH_ERASE_4K) {
|
||||
EraseSize = SIZE_4KB;
|
||||
@@ -211,10 +212,12 @@ NorFlashPrintInfo (
|
||||
EraseSize = Info->SectorSize;
|
||||
}
|
||||
|
||||
DEBUG ((DEBUG_ERROR,
|
||||
DEBUG ((
|
||||
DEBUG_ERROR,
|
||||
"Detected %s SPI NOR flash with page size %d B, erase size %d KB, total %d MB\n",
|
||||
Info->Name,
|
||||
Info->PageSize,
|
||||
EraseSize / 1024,
|
||||
(Info->SectorSize * Info->SectorCount) / 1024 / 1024));
|
||||
(Info->SectorSize * Info->SectorCount) / 1024 / 1024
|
||||
));
|
||||
}
|
||||
|
@@ -13,13 +13,13 @@
|
||||
#include <Library/PcdLib.h>
|
||||
#include <Library/PrePiLib.h>
|
||||
|
||||
#define PRE_PI_EXTRACT_GUIDED_SECTION_DATA_GUID { 0x385A982C, 0x2F49, 0x4043, { 0xA5, 0x1E, 0x49, 0x01, 0x02, 0x5C, 0x8B, 0x6B }}
|
||||
#define PRE_PI_EXTRACT_GUIDED_SECTION_DATA_GUID { 0x385A982C, 0x2F49, 0x4043, { 0xA5, 0x1E, 0x49, 0x01, 0x02, 0x5C, 0x8B, 0x6B }}
|
||||
|
||||
typedef struct {
|
||||
UINT32 NumberOfExtractHandler;
|
||||
GUID *ExtractHandlerGuidTable;
|
||||
EXTRACT_GUIDED_SECTION_DECODE_HANDLER *ExtractDecodeHandlerTable;
|
||||
EXTRACT_GUIDED_SECTION_GET_INFO_HANDLER *ExtractGetInfoHandlerTable;
|
||||
UINT32 NumberOfExtractHandler;
|
||||
GUID *ExtractHandlerGuidTable;
|
||||
EXTRACT_GUIDED_SECTION_DECODE_HANDLER *ExtractDecodeHandlerTable;
|
||||
EXTRACT_GUIDED_SECTION_GET_INFO_HANDLER *ExtractGetInfoHandlerTable;
|
||||
} PRE_PI_EXTRACT_GUIDED_SECTION_DATA;
|
||||
|
||||
PRE_PI_EXTRACT_GUIDED_SECTION_DATA *
|
||||
@@ -27,10 +27,10 @@ GetSavedData (
|
||||
VOID
|
||||
)
|
||||
{
|
||||
EFI_HOB_GUID_TYPE *GuidHob;
|
||||
GUID SavedDataGuid = PRE_PI_EXTRACT_GUIDED_SECTION_DATA_GUID;
|
||||
EFI_HOB_GUID_TYPE *GuidHob;
|
||||
GUID SavedDataGuid = PRE_PI_EXTRACT_GUIDED_SECTION_DATA_GUID;
|
||||
|
||||
GuidHob = GetFirstGuidHob(&SavedDataGuid);
|
||||
GuidHob = GetFirstGuidHob (&SavedDataGuid);
|
||||
GuidHob++;
|
||||
|
||||
return (PRE_PI_EXTRACT_GUIDED_SECTION_DATA *)GuidHob;
|
||||
@@ -46,6 +46,7 @@ ExtractGuidedSectionRegisterHandlers (
|
||||
{
|
||||
PRE_PI_EXTRACT_GUIDED_SECTION_DATA *SavedData;
|
||||
UINT32 Index;
|
||||
|
||||
//
|
||||
// Check input parameter.
|
||||
//
|
||||
@@ -53,12 +54,12 @@ ExtractGuidedSectionRegisterHandlers (
|
||||
return RETURN_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
SavedData = GetSavedData();
|
||||
SavedData = GetSavedData ();
|
||||
|
||||
//
|
||||
// Search the match registered GetInfo handler for the input guided section.
|
||||
//
|
||||
for (Index = 0; Index < SavedData->NumberOfExtractHandler; Index ++) {
|
||||
for (Index = 0; Index < SavedData->NumberOfExtractHandler; Index++) {
|
||||
if (CompareGuid (&SavedData->ExtractHandlerGuidTable[Index], SectionGuid)) {
|
||||
break;
|
||||
}
|
||||
@@ -68,8 +69,8 @@ ExtractGuidedSectionRegisterHandlers (
|
||||
// If the guided handler has been registered before, only update its handler.
|
||||
//
|
||||
if (Index < SavedData->NumberOfExtractHandler) {
|
||||
SavedData->ExtractDecodeHandlerTable [Index] = DecodeHandler;
|
||||
SavedData->ExtractGetInfoHandlerTable [Index] = GetInfoHandler;
|
||||
SavedData->ExtractDecodeHandlerTable[Index] = DecodeHandler;
|
||||
SavedData->ExtractGetInfoHandlerTable[Index] = GetInfoHandler;
|
||||
return RETURN_SUCCESS;
|
||||
}
|
||||
|
||||
@@ -83,9 +84,9 @@ ExtractGuidedSectionRegisterHandlers (
|
||||
//
|
||||
// Register new Handler and guid value.
|
||||
//
|
||||
CopyGuid (&SavedData->ExtractHandlerGuidTable [SavedData->NumberOfExtractHandler], SectionGuid);
|
||||
SavedData->ExtractDecodeHandlerTable [SavedData->NumberOfExtractHandler] = DecodeHandler;
|
||||
SavedData->ExtractGetInfoHandlerTable [SavedData->NumberOfExtractHandler++] = GetInfoHandler;
|
||||
CopyGuid (&SavedData->ExtractHandlerGuidTable[SavedData->NumberOfExtractHandler], SectionGuid);
|
||||
SavedData->ExtractDecodeHandlerTable[SavedData->NumberOfExtractHandler] = DecodeHandler;
|
||||
SavedData->ExtractGetInfoHandlerTable[SavedData->NumberOfExtractHandler++] = GetInfoHandler;
|
||||
|
||||
return RETURN_SUCCESS;
|
||||
}
|
||||
@@ -98,9 +99,9 @@ ExtractGuidedSectionGetGuidList (
|
||||
{
|
||||
PRE_PI_EXTRACT_GUIDED_SECTION_DATA *SavedData;
|
||||
|
||||
ASSERT(ExtractHandlerGuidTable != NULL);
|
||||
ASSERT (ExtractHandlerGuidTable != NULL);
|
||||
|
||||
SavedData = GetSavedData();
|
||||
SavedData = GetSavedData ();
|
||||
|
||||
*ExtractHandlerGuidTable = SavedData->ExtractHandlerGuidTable;
|
||||
return SavedData->NumberOfExtractHandler;
|
||||
@@ -127,18 +128,18 @@ ExtractGuidedSectionGetInfo (
|
||||
ASSERT (ScratchBufferSize != NULL);
|
||||
ASSERT (SectionAttribute != NULL);
|
||||
|
||||
SavedData = GetSavedData();
|
||||
SavedData = GetSavedData ();
|
||||
|
||||
if (IS_SECTION2 (InputSection)) {
|
||||
SectionDefinitionGuid = &(((EFI_GUID_DEFINED_SECTION2 *) InputSection)->SectionDefinitionGuid);
|
||||
SectionDefinitionGuid = &(((EFI_GUID_DEFINED_SECTION2 *)InputSection)->SectionDefinitionGuid);
|
||||
} else {
|
||||
SectionDefinitionGuid = &(((EFI_GUID_DEFINED_SECTION *) InputSection)->SectionDefinitionGuid);
|
||||
SectionDefinitionGuid = &(((EFI_GUID_DEFINED_SECTION *)InputSection)->SectionDefinitionGuid);
|
||||
}
|
||||
|
||||
//
|
||||
// Search the match registered GetInfo handler for the input guided section.
|
||||
//
|
||||
for (Index = 0; Index < SavedData->NumberOfExtractHandler; Index ++) {
|
||||
for (Index = 0; Index < SavedData->NumberOfExtractHandler; Index++) {
|
||||
if (CompareGuid (&SavedData->ExtractHandlerGuidTable[Index], SectionDefinitionGuid)) {
|
||||
break;
|
||||
}
|
||||
@@ -154,12 +155,12 @@ ExtractGuidedSectionGetInfo (
|
||||
//
|
||||
// Call the match handler to getinfo for the input section data.
|
||||
//
|
||||
return SavedData->ExtractGetInfoHandlerTable [Index] (
|
||||
InputSection,
|
||||
OutputBufferSize,
|
||||
ScratchBufferSize,
|
||||
SectionAttribute
|
||||
);
|
||||
return SavedData->ExtractGetInfoHandlerTable[Index](
|
||||
InputSection,
|
||||
OutputBufferSize,
|
||||
ScratchBufferSize,
|
||||
SectionAttribute
|
||||
);
|
||||
}
|
||||
|
||||
RETURN_STATUS
|
||||
@@ -182,18 +183,18 @@ ExtractGuidedSectionDecode (
|
||||
ASSERT (OutputBuffer != NULL);
|
||||
ASSERT (AuthenticationStatus != NULL);
|
||||
|
||||
SavedData = GetSavedData();
|
||||
SavedData = GetSavedData ();
|
||||
|
||||
if (IS_SECTION2 (InputSection)) {
|
||||
SectionDefinitionGuid = &(((EFI_GUID_DEFINED_SECTION2 *) InputSection)->SectionDefinitionGuid);
|
||||
SectionDefinitionGuid = &(((EFI_GUID_DEFINED_SECTION2 *)InputSection)->SectionDefinitionGuid);
|
||||
} else {
|
||||
SectionDefinitionGuid = &(((EFI_GUID_DEFINED_SECTION *) InputSection)->SectionDefinitionGuid);
|
||||
SectionDefinitionGuid = &(((EFI_GUID_DEFINED_SECTION *)InputSection)->SectionDefinitionGuid);
|
||||
}
|
||||
|
||||
//
|
||||
// Search the match registered GetInfo handler for the input guided section.
|
||||
//
|
||||
for (Index = 0; Index < SavedData->NumberOfExtractHandler; Index ++) {
|
||||
for (Index = 0; Index < SavedData->NumberOfExtractHandler; Index++) {
|
||||
if (CompareGuid (&SavedData->ExtractHandlerGuidTable[Index], SectionDefinitionGuid)) {
|
||||
break;
|
||||
}
|
||||
@@ -209,12 +210,12 @@ ExtractGuidedSectionDecode (
|
||||
//
|
||||
// Call the match handler to getinfo for the input section data.
|
||||
//
|
||||
return SavedData->ExtractDecodeHandlerTable [Index] (
|
||||
InputSection,
|
||||
OutputBuffer,
|
||||
ScratchBuffer,
|
||||
AuthenticationStatus
|
||||
);
|
||||
return SavedData->ExtractDecodeHandlerTable[Index](
|
||||
InputSection,
|
||||
OutputBuffer,
|
||||
ScratchBuffer,
|
||||
AuthenticationStatus
|
||||
);
|
||||
}
|
||||
|
||||
RETURN_STATUS
|
||||
@@ -229,17 +230,17 @@ ExtractGuidedSectionLibConstructor (
|
||||
//
|
||||
// Allocate global pool space to store the registered handler and its guid value.
|
||||
//
|
||||
SavedData.ExtractHandlerGuidTable = (GUID *)AllocatePool(PcdGet32(PcdMaximumGuidedExtractHandler) * sizeof(GUID));
|
||||
SavedData.ExtractHandlerGuidTable = (GUID *)AllocatePool (PcdGet32 (PcdMaximumGuidedExtractHandler) * sizeof (GUID));
|
||||
if (SavedData.ExtractHandlerGuidTable == NULL) {
|
||||
return RETURN_OUT_OF_RESOURCES;
|
||||
}
|
||||
|
||||
SavedData.ExtractDecodeHandlerTable = (EXTRACT_GUIDED_SECTION_DECODE_HANDLER *)AllocatePool(PcdGet32(PcdMaximumGuidedExtractHandler) * sizeof(EXTRACT_GUIDED_SECTION_DECODE_HANDLER));
|
||||
SavedData.ExtractDecodeHandlerTable = (EXTRACT_GUIDED_SECTION_DECODE_HANDLER *)AllocatePool (PcdGet32 (PcdMaximumGuidedExtractHandler) * sizeof (EXTRACT_GUIDED_SECTION_DECODE_HANDLER));
|
||||
if (SavedData.ExtractDecodeHandlerTable == NULL) {
|
||||
return RETURN_OUT_OF_RESOURCES;
|
||||
}
|
||||
|
||||
SavedData.ExtractGetInfoHandlerTable = (EXTRACT_GUIDED_SECTION_GET_INFO_HANDLER *)AllocatePool(PcdGet32(PcdMaximumGuidedExtractHandler) * sizeof(EXTRACT_GUIDED_SECTION_GET_INFO_HANDLER));
|
||||
SavedData.ExtractGetInfoHandlerTable = (EXTRACT_GUIDED_SECTION_GET_INFO_HANDLER *)AllocatePool (PcdGet32 (PcdMaximumGuidedExtractHandler) * sizeof (EXTRACT_GUIDED_SECTION_GET_INFO_HANDLER));
|
||||
if (SavedData.ExtractGetInfoHandlerTable == NULL) {
|
||||
return RETURN_OUT_OF_RESOURCES;
|
||||
}
|
||||
@@ -249,7 +250,7 @@ ExtractGuidedSectionLibConstructor (
|
||||
//
|
||||
SavedData.NumberOfExtractHandler = 0;
|
||||
|
||||
BuildGuidDataHob(&HobGuid, &SavedData, sizeof(SavedData));
|
||||
BuildGuidDataHob (&HobGuid, &SavedData, sizeof (SavedData));
|
||||
|
||||
return RETURN_SUCCESS;
|
||||
}
|
||||
|
@@ -44,8 +44,6 @@ GetHobList (
|
||||
return PrePeiGetHobList ();
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**
|
||||
Updates the pointer to the HOB list.
|
||||
|
||||
@@ -55,7 +53,7 @@ GetHobList (
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
SetHobList (
|
||||
IN VOID *HobList
|
||||
IN VOID *HobList
|
||||
)
|
||||
{
|
||||
return PrePeiSetHobList (HobList);
|
||||
@@ -65,7 +63,7 @@ SetHobList (
|
||||
|
||||
|
||||
**/
|
||||
EFI_HOB_HANDOFF_INFO_TABLE*
|
||||
EFI_HOB_HANDOFF_INFO_TABLE *
|
||||
HobConstructor (
|
||||
IN VOID *EfiMemoryBegin,
|
||||
IN UINTN EfiMemoryLength,
|
||||
@@ -79,16 +77,16 @@ HobConstructor (
|
||||
Hob = EfiFreeMemoryBottom;
|
||||
HobEnd = (EFI_HOB_GENERIC_HEADER *)(Hob+1);
|
||||
|
||||
Hob->Header.HobType = EFI_HOB_TYPE_HANDOFF;
|
||||
Hob->Header.HobLength = sizeof(EFI_HOB_HANDOFF_INFO_TABLE);
|
||||
Hob->Header.Reserved = 0;
|
||||
Hob->Header.HobType = EFI_HOB_TYPE_HANDOFF;
|
||||
Hob->Header.HobLength = sizeof (EFI_HOB_HANDOFF_INFO_TABLE);
|
||||
Hob->Header.Reserved = 0;
|
||||
|
||||
HobEnd->HobType = EFI_HOB_TYPE_END_OF_HOB_LIST;
|
||||
HobEnd->HobLength = sizeof(EFI_HOB_GENERIC_HEADER);
|
||||
HobEnd->Reserved = 0;
|
||||
HobEnd->HobType = EFI_HOB_TYPE_END_OF_HOB_LIST;
|
||||
HobEnd->HobLength = sizeof (EFI_HOB_GENERIC_HEADER);
|
||||
HobEnd->Reserved = 0;
|
||||
|
||||
Hob->Version = EFI_HOB_HANDOFF_TABLE_VERSION;
|
||||
Hob->BootMode = BOOT_WITH_FULL_CONFIGURATION;
|
||||
Hob->Version = EFI_HOB_HANDOFF_TABLE_VERSION;
|
||||
Hob->BootMode = BOOT_WITH_FULL_CONFIGURATION;
|
||||
|
||||
Hob->EfiMemoryTop = (UINTN)EfiMemoryBegin + EfiMemoryLength;
|
||||
Hob->EfiMemoryBottom = (UINTN)EfiMemoryBegin;
|
||||
@@ -101,8 +99,8 @@ HobConstructor (
|
||||
|
||||
VOID *
|
||||
CreateHob (
|
||||
IN UINT16 HobType,
|
||||
IN UINT16 HobLength
|
||||
IN UINT16 HobType,
|
||||
IN UINT16 HobLength
|
||||
)
|
||||
{
|
||||
EFI_HOB_HANDOFF_INFO_TABLE *HandOffHob;
|
||||
@@ -117,22 +115,22 @@ CreateHob (
|
||||
FreeMemory = HandOffHob->EfiFreeMemoryTop - HandOffHob->EfiFreeMemoryBottom;
|
||||
|
||||
if (FreeMemory < HobLength) {
|
||||
return NULL;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
Hob = (VOID*) (UINTN) HandOffHob->EfiEndOfHobList;
|
||||
((EFI_HOB_GENERIC_HEADER*) Hob)->HobType = HobType;
|
||||
((EFI_HOB_GENERIC_HEADER*) Hob)->HobLength = HobLength;
|
||||
((EFI_HOB_GENERIC_HEADER*) Hob)->Reserved = 0;
|
||||
Hob = (VOID *)(UINTN)HandOffHob->EfiEndOfHobList;
|
||||
((EFI_HOB_GENERIC_HEADER *)Hob)->HobType = HobType;
|
||||
((EFI_HOB_GENERIC_HEADER *)Hob)->HobLength = HobLength;
|
||||
((EFI_HOB_GENERIC_HEADER *)Hob)->Reserved = 0;
|
||||
|
||||
HobEnd = (EFI_HOB_GENERIC_HEADER*) ((UINTN)Hob + HobLength);
|
||||
HandOffHob->EfiEndOfHobList = (EFI_PHYSICAL_ADDRESS) (UINTN) HobEnd;
|
||||
HobEnd = (EFI_HOB_GENERIC_HEADER *)((UINTN)Hob + HobLength);
|
||||
HandOffHob->EfiEndOfHobList = (EFI_PHYSICAL_ADDRESS)(UINTN)HobEnd;
|
||||
|
||||
HobEnd->HobType = EFI_HOB_TYPE_END_OF_HOB_LIST;
|
||||
HobEnd->HobLength = sizeof(EFI_HOB_GENERIC_HEADER);
|
||||
HobEnd->HobLength = sizeof (EFI_HOB_GENERIC_HEADER);
|
||||
HobEnd->Reserved = 0;
|
||||
HobEnd++;
|
||||
HandOffHob->EfiFreeMemoryBottom = (EFI_PHYSICAL_ADDRESS) (UINTN) HobEnd;
|
||||
HandOffHob->EfiFreeMemoryBottom = (EFI_PHYSICAL_ADDRESS)(UINTN)HobEnd;
|
||||
|
||||
return Hob;
|
||||
}
|
||||
@@ -161,7 +159,7 @@ BuildResourceDescriptorHob (
|
||||
EFI_HOB_RESOURCE_DESCRIPTOR *Hob;
|
||||
|
||||
Hob = CreateHob (EFI_HOB_TYPE_RESOURCE_DESCRIPTOR, sizeof (EFI_HOB_RESOURCE_DESCRIPTOR));
|
||||
ASSERT(Hob != NULL);
|
||||
ASSERT (Hob != NULL);
|
||||
|
||||
Hob->ResourceType = ResourceType;
|
||||
Hob->ResourceAttribute = ResourceAttribute;
|
||||
@@ -177,8 +175,7 @@ BuildFvHobs (
|
||||
IN EFI_RESOURCE_ATTRIBUTE_TYPE *ResourceAttribute
|
||||
)
|
||||
{
|
||||
|
||||
EFI_RESOURCE_ATTRIBUTE_TYPE Resource;
|
||||
EFI_RESOURCE_ATTRIBUTE_TYPE Resource;
|
||||
|
||||
BuildFvHob (PhysicalStart, NumberOfBytes);
|
||||
|
||||
@@ -213,15 +210,15 @@ BuildFvHobs (
|
||||
VOID *
|
||||
EFIAPI
|
||||
GetNextHob (
|
||||
IN UINT16 Type,
|
||||
IN CONST VOID *HobStart
|
||||
IN UINT16 Type,
|
||||
IN CONST VOID *HobStart
|
||||
)
|
||||
{
|
||||
EFI_PEI_HOB_POINTERS Hob;
|
||||
|
||||
ASSERT (HobStart != NULL);
|
||||
|
||||
Hob.Raw = (UINT8 *) HobStart;
|
||||
Hob.Raw = (UINT8 *)HobStart;
|
||||
//
|
||||
// Parse the HOB list until end of list or matching type is found.
|
||||
//
|
||||
@@ -229,13 +226,13 @@ GetNextHob (
|
||||
if (Hob.Header->HobType == Type) {
|
||||
return Hob.Raw;
|
||||
}
|
||||
|
||||
Hob.Raw = GET_NEXT_HOB (Hob);
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**
|
||||
Returns the first instance of a HOB type among the whole HOB list.
|
||||
|
||||
@@ -250,16 +247,15 @@ GetNextHob (
|
||||
VOID *
|
||||
EFIAPI
|
||||
GetFirstHob (
|
||||
IN UINT16 Type
|
||||
IN UINT16 Type
|
||||
)
|
||||
{
|
||||
VOID *HobList;
|
||||
VOID *HobList;
|
||||
|
||||
HobList = GetHobList ();
|
||||
return GetNextHob (Type, HobList);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
This function searches the first instance of a HOB from the starting HOB pointer.
|
||||
Such HOB should satisfy two conditions:
|
||||
@@ -282,22 +278,24 @@ GetFirstHob (
|
||||
VOID *
|
||||
EFIAPI
|
||||
GetNextGuidHob (
|
||||
IN CONST EFI_GUID *Guid,
|
||||
IN CONST VOID *HobStart
|
||||
){
|
||||
IN CONST EFI_GUID *Guid,
|
||||
IN CONST VOID *HobStart
|
||||
)
|
||||
{
|
||||
EFI_PEI_HOB_POINTERS GuidHob;
|
||||
|
||||
GuidHob.Raw = (UINT8 *) HobStart;
|
||||
GuidHob.Raw = (UINT8 *)HobStart;
|
||||
while ((GuidHob.Raw = GetNextHob (EFI_HOB_TYPE_GUID_EXTENSION, GuidHob.Raw)) != NULL) {
|
||||
if (CompareGuid (Guid, &GuidHob.Guid->Name)) {
|
||||
break;
|
||||
}
|
||||
|
||||
GuidHob.Raw = GET_NEXT_HOB (GuidHob);
|
||||
}
|
||||
|
||||
return GuidHob.Raw;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
This function searches the first instance of a HOB among the whole HOB list.
|
||||
Such HOB should satisfy two conditions:
|
||||
@@ -315,16 +313,15 @@ GetNextGuidHob (
|
||||
VOID *
|
||||
EFIAPI
|
||||
GetFirstGuidHob (
|
||||
IN CONST EFI_GUID *Guid
|
||||
IN CONST EFI_GUID *Guid
|
||||
)
|
||||
{
|
||||
VOID *HobList;
|
||||
VOID *HobList;
|
||||
|
||||
HobList = GetHobList ();
|
||||
return GetNextGuidHob (Guid, HobList);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Get the Boot Mode from the HOB list.
|
||||
|
||||
@@ -348,7 +345,6 @@ GetBootMode (
|
||||
return Hob.HandoffInformationTable->BootMode;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Get the Boot Mode from the HOB list.
|
||||
|
||||
@@ -363,12 +359,12 @@ GetBootMode (
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
SetBootMode (
|
||||
IN EFI_BOOT_MODE BootMode
|
||||
IN EFI_BOOT_MODE BootMode
|
||||
)
|
||||
{
|
||||
EFI_PEI_HOB_POINTERS Hob;
|
||||
|
||||
Hob.Raw = GetHobList ();
|
||||
Hob.Raw = GetHobList ();
|
||||
Hob.HandoffInformationTable->BootMode = BootMode;
|
||||
return BootMode;
|
||||
}
|
||||
@@ -391,16 +387,18 @@ SetBootMode (
|
||||
VOID
|
||||
EFIAPI
|
||||
BuildModuleHob (
|
||||
IN CONST EFI_GUID *ModuleName,
|
||||
IN EFI_PHYSICAL_ADDRESS MemoryAllocationModule,
|
||||
IN UINT64 ModuleLength,
|
||||
IN EFI_PHYSICAL_ADDRESS EntryPoint
|
||||
IN CONST EFI_GUID *ModuleName,
|
||||
IN EFI_PHYSICAL_ADDRESS MemoryAllocationModule,
|
||||
IN UINT64 ModuleLength,
|
||||
IN EFI_PHYSICAL_ADDRESS EntryPoint
|
||||
)
|
||||
{
|
||||
EFI_HOB_MEMORY_ALLOCATION_MODULE *Hob;
|
||||
|
||||
ASSERT (((MemoryAllocationModule & (EFI_PAGE_SIZE - 1)) == 0) &&
|
||||
((ModuleLength & (EFI_PAGE_SIZE - 1)) == 0));
|
||||
ASSERT (
|
||||
((MemoryAllocationModule & (EFI_PAGE_SIZE - 1)) == 0) &&
|
||||
((ModuleLength & (EFI_PAGE_SIZE - 1)) == 0)
|
||||
);
|
||||
|
||||
Hob = CreateHob (EFI_HOB_TYPE_MEMORY_ALLOCATION, sizeof (EFI_HOB_MEMORY_ALLOCATION_MODULE));
|
||||
|
||||
@@ -439,23 +437,22 @@ BuildModuleHob (
|
||||
VOID *
|
||||
EFIAPI
|
||||
BuildGuidHob (
|
||||
IN CONST EFI_GUID *Guid,
|
||||
IN UINTN DataLength
|
||||
IN CONST EFI_GUID *Guid,
|
||||
IN UINTN DataLength
|
||||
)
|
||||
{
|
||||
EFI_HOB_GUID_TYPE *Hob;
|
||||
EFI_HOB_GUID_TYPE *Hob;
|
||||
|
||||
//
|
||||
// Make sure that data length is not too long.
|
||||
//
|
||||
ASSERT (DataLength <= (0xffff - sizeof (EFI_HOB_GUID_TYPE)));
|
||||
|
||||
Hob = CreateHob (EFI_HOB_TYPE_GUID_EXTENSION, (UINT16) (sizeof (EFI_HOB_GUID_TYPE) + DataLength));
|
||||
Hob = CreateHob (EFI_HOB_TYPE_GUID_EXTENSION, (UINT16)(sizeof (EFI_HOB_GUID_TYPE) + DataLength));
|
||||
CopyGuid (&Hob->Name, Guid);
|
||||
return Hob + 1;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Copies a data buffer to a newly-built HOB.
|
||||
|
||||
@@ -479,9 +476,9 @@ BuildGuidHob (
|
||||
VOID *
|
||||
EFIAPI
|
||||
BuildGuidDataHob (
|
||||
IN CONST EFI_GUID *Guid,
|
||||
IN VOID *Data,
|
||||
IN UINTN DataLength
|
||||
IN CONST EFI_GUID *Guid,
|
||||
IN VOID *Data,
|
||||
IN UINTN DataLength
|
||||
)
|
||||
{
|
||||
VOID *HobData;
|
||||
@@ -493,7 +490,6 @@ BuildGuidDataHob (
|
||||
return CopyMem (HobData, Data, DataLength);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Builds a Firmware Volume HOB.
|
||||
|
||||
@@ -509,8 +505,8 @@ BuildGuidDataHob (
|
||||
VOID
|
||||
EFIAPI
|
||||
BuildFvHob (
|
||||
IN EFI_PHYSICAL_ADDRESS BaseAddress,
|
||||
IN UINT64 Length
|
||||
IN EFI_PHYSICAL_ADDRESS BaseAddress,
|
||||
IN UINT64 Length
|
||||
)
|
||||
{
|
||||
EFI_HOB_FIRMWARE_VOLUME *Hob;
|
||||
@@ -521,7 +517,6 @@ BuildFvHob (
|
||||
Hob->Length = Length;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Builds a EFI_HOB_TYPE_FV2 HOB.
|
||||
|
||||
@@ -539,10 +534,10 @@ BuildFvHob (
|
||||
VOID
|
||||
EFIAPI
|
||||
BuildFv2Hob (
|
||||
IN EFI_PHYSICAL_ADDRESS BaseAddress,
|
||||
IN UINT64 Length,
|
||||
IN CONST EFI_GUID *FvName,
|
||||
IN CONST EFI_GUID *FileName
|
||||
IN EFI_PHYSICAL_ADDRESS BaseAddress,
|
||||
IN UINT64 Length,
|
||||
IN CONST EFI_GUID *FvName,
|
||||
IN CONST EFI_GUID *FileName
|
||||
)
|
||||
{
|
||||
EFI_HOB_FIRMWARE_VOLUME2 *Hob;
|
||||
@@ -578,12 +573,12 @@ BuildFv2Hob (
|
||||
VOID
|
||||
EFIAPI
|
||||
BuildFv3Hob (
|
||||
IN EFI_PHYSICAL_ADDRESS BaseAddress,
|
||||
IN UINT64 Length,
|
||||
IN UINT32 AuthenticationStatus,
|
||||
IN BOOLEAN ExtractedFv,
|
||||
IN CONST EFI_GUID *FvName OPTIONAL,
|
||||
IN CONST EFI_GUID *FileName OPTIONAL
|
||||
IN EFI_PHYSICAL_ADDRESS BaseAddress,
|
||||
IN UINT64 Length,
|
||||
IN UINT32 AuthenticationStatus,
|
||||
IN BOOLEAN ExtractedFv,
|
||||
IN CONST EFI_GUID *FvName OPTIONAL,
|
||||
IN CONST EFI_GUID *FileName OPTIONAL
|
||||
)
|
||||
{
|
||||
EFI_HOB_FIRMWARE_VOLUME3 *Hob;
|
||||
@@ -615,14 +610,13 @@ BuildFv3Hob (
|
||||
VOID
|
||||
EFIAPI
|
||||
BuildCvHob (
|
||||
IN EFI_PHYSICAL_ADDRESS BaseAddress,
|
||||
IN UINT64 Length
|
||||
IN EFI_PHYSICAL_ADDRESS BaseAddress,
|
||||
IN UINT64 Length
|
||||
)
|
||||
{
|
||||
ASSERT (FALSE);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Builds a HOB for the CPU.
|
||||
|
||||
@@ -638,8 +632,8 @@ BuildCvHob (
|
||||
VOID
|
||||
EFIAPI
|
||||
BuildCpuHob (
|
||||
IN UINT8 SizeOfMemorySpace,
|
||||
IN UINT8 SizeOfIoSpace
|
||||
IN UINT8 SizeOfMemorySpace,
|
||||
IN UINT8 SizeOfIoSpace
|
||||
)
|
||||
{
|
||||
EFI_HOB_CPU *Hob;
|
||||
@@ -655,7 +649,6 @@ BuildCpuHob (
|
||||
ZeroMem (Hob->Reserved, sizeof (Hob->Reserved));
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Builds a HOB for the Stack.
|
||||
|
||||
@@ -671,14 +664,16 @@ BuildCpuHob (
|
||||
VOID
|
||||
EFIAPI
|
||||
BuildStackHob (
|
||||
IN EFI_PHYSICAL_ADDRESS BaseAddress,
|
||||
IN UINT64 Length
|
||||
IN EFI_PHYSICAL_ADDRESS BaseAddress,
|
||||
IN UINT64 Length
|
||||
)
|
||||
{
|
||||
EFI_HOB_MEMORY_ALLOCATION_STACK *Hob;
|
||||
|
||||
ASSERT (((BaseAddress & (EFI_PAGE_SIZE - 1)) == 0) &&
|
||||
((Length & (EFI_PAGE_SIZE - 1)) == 0));
|
||||
ASSERT (
|
||||
((BaseAddress & (EFI_PAGE_SIZE - 1)) == 0) &&
|
||||
((Length & (EFI_PAGE_SIZE - 1)) == 0)
|
||||
);
|
||||
|
||||
Hob = CreateHob (EFI_HOB_TYPE_MEMORY_ALLOCATION, sizeof (EFI_HOB_MEMORY_ALLOCATION_STACK));
|
||||
|
||||
@@ -693,7 +688,6 @@ BuildStackHob (
|
||||
ZeroMem (Hob->AllocDescriptor.Reserved, sizeof (Hob->AllocDescriptor.Reserved));
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Update the Stack Hob if the stack has been moved
|
||||
|
||||
@@ -703,11 +697,11 @@ BuildStackHob (
|
||||
**/
|
||||
VOID
|
||||
UpdateStackHob (
|
||||
IN EFI_PHYSICAL_ADDRESS BaseAddress,
|
||||
IN UINT64 Length
|
||||
IN EFI_PHYSICAL_ADDRESS BaseAddress,
|
||||
IN UINT64 Length
|
||||
)
|
||||
{
|
||||
EFI_PEI_HOB_POINTERS Hob;
|
||||
EFI_PEI_HOB_POINTERS Hob;
|
||||
|
||||
Hob.Raw = GetHobList ();
|
||||
while ((Hob.Raw = GetNextHob (EFI_HOB_TYPE_MEMORY_ALLOCATION, Hob.Raw)) != NULL) {
|
||||
@@ -725,15 +719,14 @@ UpdateStackHob (
|
||||
// Update the BSP Stack Hob to reflect the new stack info.
|
||||
//
|
||||
Hob.MemoryAllocationStack->AllocDescriptor.MemoryBaseAddress = BaseAddress;
|
||||
Hob.MemoryAllocationStack->AllocDescriptor.MemoryLength = Length;
|
||||
Hob.MemoryAllocationStack->AllocDescriptor.MemoryLength = Length;
|
||||
break;
|
||||
}
|
||||
|
||||
Hob.Raw = GET_NEXT_HOB (Hob);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**
|
||||
Builds a HOB for the memory allocation.
|
||||
|
||||
@@ -750,15 +743,17 @@ UpdateStackHob (
|
||||
VOID
|
||||
EFIAPI
|
||||
BuildMemoryAllocationHob (
|
||||
IN EFI_PHYSICAL_ADDRESS BaseAddress,
|
||||
IN UINT64 Length,
|
||||
IN EFI_MEMORY_TYPE MemoryType
|
||||
IN EFI_PHYSICAL_ADDRESS BaseAddress,
|
||||
IN UINT64 Length,
|
||||
IN EFI_MEMORY_TYPE MemoryType
|
||||
)
|
||||
{
|
||||
EFI_HOB_MEMORY_ALLOCATION *Hob;
|
||||
|
||||
ASSERT (((BaseAddress & (EFI_PAGE_SIZE - 1)) == 0) &&
|
||||
((Length & (EFI_PAGE_SIZE - 1)) == 0));
|
||||
ASSERT (
|
||||
((BaseAddress & (EFI_PAGE_SIZE - 1)) == 0) &&
|
||||
((Length & (EFI_PAGE_SIZE - 1)) == 0)
|
||||
);
|
||||
|
||||
Hob = CreateHob (EFI_HOB_TYPE_MEMORY_ALLOCATION, sizeof (EFI_HOB_MEMORY_ALLOCATION));
|
||||
|
||||
@@ -772,24 +767,22 @@ BuildMemoryAllocationHob (
|
||||
ZeroMem (Hob->AllocDescriptor.Reserved, sizeof (Hob->AllocDescriptor.Reserved));
|
||||
}
|
||||
|
||||
|
||||
|
||||
VOID
|
||||
EFIAPI
|
||||
BuildExtractSectionHob (
|
||||
IN EFI_GUID *Guid,
|
||||
IN EXTRACT_GUIDED_SECTION_GET_INFO_HANDLER SectionGetInfo,
|
||||
IN EXTRACT_GUIDED_SECTION_DECODE_HANDLER SectionExtraction
|
||||
IN EFI_GUID *Guid,
|
||||
IN EXTRACT_GUIDED_SECTION_GET_INFO_HANDLER SectionGetInfo,
|
||||
IN EXTRACT_GUIDED_SECTION_DECODE_HANDLER SectionExtraction
|
||||
)
|
||||
{
|
||||
EXTRACT_SECTION_DATA Data;
|
||||
EXTRACT_SECTION_DATA Data;
|
||||
|
||||
Data.SectionGetInfo = SectionGetInfo;
|
||||
Data.SectionExtraction = SectionExtraction;
|
||||
BuildGuidDataHob (Guid, &Data, sizeof (Data));
|
||||
}
|
||||
|
||||
PE_COFF_LOADER_PROTOCOL gPeCoffProtocol = {
|
||||
PE_COFF_LOADER_PROTOCOL gPeCoffProtocol = {
|
||||
PeCoffLoaderGetImageInfo,
|
||||
PeCoffLoaderLoadImage,
|
||||
PeCoffLoaderRelocateImage,
|
||||
@@ -798,8 +791,6 @@ PE_COFF_LOADER_PROTOCOL gPeCoffProtocol = {
|
||||
PeCoffLoaderUnloadImage
|
||||
};
|
||||
|
||||
|
||||
|
||||
VOID
|
||||
EFIAPI
|
||||
BuildPeCoffLoaderHob (
|
||||
@@ -818,7 +809,7 @@ BuildMemoryTypeInformationHob (
|
||||
VOID
|
||||
)
|
||||
{
|
||||
EFI_MEMORY_TYPE_INFORMATION Info[10];
|
||||
EFI_MEMORY_TYPE_INFORMATION Info[10];
|
||||
|
||||
Info[0].Type = EfiACPIReclaimMemory;
|
||||
Info[0].NumberOfPages = PcdGet32 (PcdMemoryTypeEfiACPIReclaimMemory);
|
||||
@@ -843,6 +834,5 @@ BuildMemoryTypeInformationHob (
|
||||
Info[9].Type = EfiMaxMemoryType;
|
||||
Info[9].NumberOfPages = 0;
|
||||
|
||||
|
||||
BuildGuidDataHob (&gEfiMemoryTypeInformationGuid, &Info, sizeof (Info));
|
||||
}
|
||||
|
@@ -12,11 +12,9 @@
|
||||
#include <PrePi.h>
|
||||
#include <Library/ExtractGuidedSectionLib.h>
|
||||
|
||||
|
||||
#define GET_OCCUPIED_SIZE(ActualSize, Alignment) \
|
||||
(ActualSize) + (((Alignment) - ((ActualSize) & ((Alignment) - 1))) & ((Alignment) - 1))
|
||||
|
||||
|
||||
/**
|
||||
Returns the highest bit set of the State field
|
||||
|
||||
@@ -30,7 +28,7 @@
|
||||
**/
|
||||
STATIC
|
||||
EFI_FFS_FILE_STATE
|
||||
GetFileState(
|
||||
GetFileState (
|
||||
IN UINT8 ErasePolarity,
|
||||
IN EFI_FFS_FILE_HEADER *FfsHeader
|
||||
)
|
||||
@@ -41,7 +39,7 @@ GetFileState(
|
||||
FileState = FfsHeader->State;
|
||||
|
||||
if (ErasePolarity != 0) {
|
||||
FileState = (EFI_FFS_FILE_STATE)~FileState;
|
||||
FileState = (EFI_FFS_FILE_STATE) ~FileState;
|
||||
}
|
||||
|
||||
HighestBit = 0x80;
|
||||
@@ -52,7 +50,6 @@ GetFileState(
|
||||
return HighestBit;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Calculates the checksum of the header of a file.
|
||||
The header is a zero byte checksum, so zero means header is good
|
||||
@@ -68,21 +65,21 @@ CalculateHeaderChecksum (
|
||||
IN EFI_FFS_FILE_HEADER *FileHeader
|
||||
)
|
||||
{
|
||||
UINT8 *Ptr;
|
||||
UINTN Index;
|
||||
UINT8 Sum;
|
||||
UINT8 *Ptr;
|
||||
UINTN Index;
|
||||
UINT8 Sum;
|
||||
|
||||
Sum = 0;
|
||||
Ptr = (UINT8 *)FileHeader;
|
||||
|
||||
for (Index = 0; Index < sizeof(EFI_FFS_FILE_HEADER) - 3; Index += 4) {
|
||||
for (Index = 0; Index < sizeof (EFI_FFS_FILE_HEADER) - 3; Index += 4) {
|
||||
Sum = (UINT8)(Sum + Ptr[Index]);
|
||||
Sum = (UINT8)(Sum + Ptr[Index+1]);
|
||||
Sum = (UINT8)(Sum + Ptr[Index+2]);
|
||||
Sum = (UINT8)(Sum + Ptr[Index+3]);
|
||||
}
|
||||
|
||||
for (; Index < sizeof(EFI_FFS_FILE_HEADER); Index++) {
|
||||
for ( ; Index < sizeof (EFI_FFS_FILE_HEADER); Index++) {
|
||||
Sum = (UINT8)(Sum + Ptr[Index]);
|
||||
}
|
||||
|
||||
@@ -98,7 +95,6 @@ CalculateHeaderChecksum (
|
||||
return Sum;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Given a FileHandle return the VolumeHandle
|
||||
|
||||
@@ -112,8 +108,8 @@ STATIC
|
||||
BOOLEAN
|
||||
EFIAPI
|
||||
FileHandleToVolume (
|
||||
IN EFI_PEI_FILE_HANDLE FileHandle,
|
||||
OUT EFI_PEI_FV_HANDLE *VolumeHandle
|
||||
IN EFI_PEI_FILE_HANDLE FileHandle,
|
||||
OUT EFI_PEI_FV_HANDLE *VolumeHandle
|
||||
)
|
||||
{
|
||||
EFI_FIRMWARE_VOLUME_HEADER *FwVolHeader;
|
||||
@@ -128,8 +124,9 @@ FileHandleToVolume (
|
||||
Hob.Raw = GetNextHob (EFI_HOB_TYPE_FV, Hob.Raw);
|
||||
if (Hob.Raw != NULL) {
|
||||
FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *)(UINTN)(Hob.FirmwareVolume->BaseAddress);
|
||||
if (((UINT64) (UINTN) FileHandle > (UINT64) (UINTN) FwVolHeader ) && \
|
||||
((UINT64) (UINTN) FileHandle <= ((UINT64) (UINTN) FwVolHeader + FwVolHeader->FvLength - 1))) {
|
||||
if (((UINT64)(UINTN)FileHandle > (UINT64)(UINTN)FwVolHeader) && \
|
||||
((UINT64)(UINTN)FileHandle <= ((UINT64)(UINTN)FwVolHeader + FwVolHeader->FvLength - 1)))
|
||||
{
|
||||
*VolumeHandle = (EFI_PEI_FV_HANDLE)FwVolHeader;
|
||||
return TRUE;
|
||||
}
|
||||
@@ -141,8 +138,6 @@ FileHandleToVolume (
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**
|
||||
Given the input file pointer, search for the next matching file in the
|
||||
FFS volume as defined by SearchType. The search starts from FileHeader inside
|
||||
@@ -155,22 +150,22 @@ FileHandleToVolume (
|
||||
**/
|
||||
EFI_STATUS
|
||||
FindFileEx (
|
||||
IN CONST EFI_PEI_FV_HANDLE FvHandle,
|
||||
IN CONST EFI_GUID *FileName OPTIONAL,
|
||||
IN EFI_FV_FILETYPE SearchType,
|
||||
IN OUT EFI_PEI_FILE_HANDLE *FileHandle
|
||||
IN CONST EFI_PEI_FV_HANDLE FvHandle,
|
||||
IN CONST EFI_GUID *FileName OPTIONAL,
|
||||
IN EFI_FV_FILETYPE SearchType,
|
||||
IN OUT EFI_PEI_FILE_HANDLE *FileHandle
|
||||
)
|
||||
{
|
||||
EFI_FIRMWARE_VOLUME_HEADER *FwVolHeader;
|
||||
EFI_FFS_FILE_HEADER **FileHeader;
|
||||
EFI_FFS_FILE_HEADER *FfsFileHeader;
|
||||
EFI_FIRMWARE_VOLUME_EXT_HEADER *FwVolExHeaderInfo;
|
||||
UINT32 FileLength;
|
||||
UINT32 FileOccupiedSize;
|
||||
UINT32 FileOffset;
|
||||
UINT64 FvLength;
|
||||
UINT8 ErasePolarity;
|
||||
UINT8 FileState;
|
||||
EFI_FIRMWARE_VOLUME_HEADER *FwVolHeader;
|
||||
EFI_FFS_FILE_HEADER **FileHeader;
|
||||
EFI_FFS_FILE_HEADER *FfsFileHeader;
|
||||
EFI_FIRMWARE_VOLUME_EXT_HEADER *FwVolExHeaderInfo;
|
||||
UINT32 FileLength;
|
||||
UINT32 FileOccupiedSize;
|
||||
UINT32 FileOffset;
|
||||
UINT64 FvLength;
|
||||
UINT8 ErasePolarity;
|
||||
UINT8 FileState;
|
||||
|
||||
FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *)FvHandle;
|
||||
FileHeader = (EFI_FFS_FILE_HEADER **)FileHandle;
|
||||
@@ -191,22 +186,22 @@ FindFileEx (
|
||||
FfsFileHeader = (EFI_FFS_FILE_HEADER *)((UINT8 *)FwVolHeader + FwVolHeader->HeaderLength);
|
||||
if (FwVolHeader->ExtHeaderOffset != 0) {
|
||||
FwVolExHeaderInfo = (EFI_FIRMWARE_VOLUME_EXT_HEADER *)(((UINT8 *)FwVolHeader) + FwVolHeader->ExtHeaderOffset);
|
||||
FfsFileHeader = (EFI_FFS_FILE_HEADER *)(((UINT8 *)FwVolExHeaderInfo) + FwVolExHeaderInfo->ExtHeaderSize);
|
||||
FfsFileHeader = (EFI_FFS_FILE_HEADER *)(((UINT8 *)FwVolExHeaderInfo) + FwVolExHeaderInfo->ExtHeaderSize);
|
||||
}
|
||||
} else {
|
||||
//
|
||||
// Length is 24 bits wide so mask upper 8 bits
|
||||
// FileLength is adjusted to FileOccupiedSize as it is 8 byte aligned.
|
||||
//
|
||||
FileLength = *(UINT32 *)(*FileHeader)->Size & 0x00FFFFFF;
|
||||
FileLength = *(UINT32 *)(*FileHeader)->Size & 0x00FFFFFF;
|
||||
FileOccupiedSize = GET_OCCUPIED_SIZE (FileLength, 8);
|
||||
FfsFileHeader = (EFI_FFS_FILE_HEADER *)((UINT8 *)*FileHeader + FileOccupiedSize);
|
||||
FfsFileHeader = (EFI_FFS_FILE_HEADER *)((UINT8 *)*FileHeader + FileOccupiedSize);
|
||||
}
|
||||
|
||||
// FFS files begin with a header that is aligned on an 8-byte boundary
|
||||
FfsFileHeader = ALIGN_POINTER (FfsFileHeader, 8);
|
||||
|
||||
FileOffset = (UINT32) ((UINT8 *)FfsFileHeader - (UINT8 *)FwVolHeader);
|
||||
FileOffset = (UINT32)((UINT8 *)FfsFileHeader - (UINT8 *)FwVolHeader);
|
||||
ASSERT (FileOffset <= 0xFFFFFFFF);
|
||||
|
||||
while (FileOffset < (FvLength - sizeof (EFI_FFS_FILE_HEADER))) {
|
||||
@@ -216,57 +211,55 @@ FindFileEx (
|
||||
FileState = GetFileState (ErasePolarity, FfsFileHeader);
|
||||
|
||||
switch (FileState) {
|
||||
case EFI_FILE_HEADER_INVALID:
|
||||
FileOffset += sizeof (EFI_FFS_FILE_HEADER);
|
||||
FfsFileHeader = (EFI_FFS_FILE_HEADER *)((UINT8 *)FfsFileHeader + sizeof (EFI_FFS_FILE_HEADER));
|
||||
break;
|
||||
|
||||
case EFI_FILE_HEADER_INVALID:
|
||||
FileOffset += sizeof(EFI_FFS_FILE_HEADER);
|
||||
FfsFileHeader = (EFI_FFS_FILE_HEADER *)((UINT8 *)FfsFileHeader + sizeof(EFI_FFS_FILE_HEADER));
|
||||
break;
|
||||
case EFI_FILE_DATA_VALID:
|
||||
case EFI_FILE_MARKED_FOR_UPDATE:
|
||||
if (CalculateHeaderChecksum (FfsFileHeader) != 0) {
|
||||
ASSERT (FALSE);
|
||||
*FileHeader = NULL;
|
||||
return EFI_NOT_FOUND;
|
||||
}
|
||||
|
||||
case EFI_FILE_DATA_VALID:
|
||||
case EFI_FILE_MARKED_FOR_UPDATE:
|
||||
if (CalculateHeaderChecksum (FfsFileHeader) != 0) {
|
||||
ASSERT (FALSE);
|
||||
*FileHeader = NULL;
|
||||
return EFI_NOT_FOUND;
|
||||
}
|
||||
FileLength = *(UINT32 *)(FfsFileHeader->Size) & 0x00FFFFFF;
|
||||
FileOccupiedSize = GET_OCCUPIED_SIZE (FileLength, 8);
|
||||
|
||||
FileLength = *(UINT32 *)(FfsFileHeader->Size) & 0x00FFFFFF;
|
||||
FileOccupiedSize = GET_OCCUPIED_SIZE(FileLength, 8);
|
||||
|
||||
if (FileName != NULL) {
|
||||
if (CompareGuid (&FfsFileHeader->Name, (EFI_GUID*)FileName)) {
|
||||
if (FileName != NULL) {
|
||||
if (CompareGuid (&FfsFileHeader->Name, (EFI_GUID *)FileName)) {
|
||||
*FileHeader = FfsFileHeader;
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
} else if (((SearchType == FfsFileHeader->Type) || (SearchType == EFI_FV_FILETYPE_ALL)) &&
|
||||
(FfsFileHeader->Type != EFI_FV_FILETYPE_FFS_PAD))
|
||||
{
|
||||
*FileHeader = FfsFileHeader;
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
} else if (((SearchType == FfsFileHeader->Type) || (SearchType == EFI_FV_FILETYPE_ALL)) &&
|
||||
(FfsFileHeader->Type != EFI_FV_FILETYPE_FFS_PAD)) {
|
||||
*FileHeader = FfsFileHeader;
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
FileOffset += FileOccupiedSize;
|
||||
FfsFileHeader = (EFI_FFS_FILE_HEADER *)((UINT8 *)FfsFileHeader + FileOccupiedSize);
|
||||
break;
|
||||
FileOffset += FileOccupiedSize;
|
||||
FfsFileHeader = (EFI_FFS_FILE_HEADER *)((UINT8 *)FfsFileHeader + FileOccupiedSize);
|
||||
break;
|
||||
|
||||
case EFI_FILE_DELETED:
|
||||
FileLength = *(UINT32 *)(FfsFileHeader->Size) & 0x00FFFFFF;
|
||||
FileOccupiedSize = GET_OCCUPIED_SIZE(FileLength, 8);
|
||||
FileOffset += FileOccupiedSize;
|
||||
FfsFileHeader = (EFI_FFS_FILE_HEADER *)((UINT8 *)FfsFileHeader + FileOccupiedSize);
|
||||
break;
|
||||
case EFI_FILE_DELETED:
|
||||
FileLength = *(UINT32 *)(FfsFileHeader->Size) & 0x00FFFFFF;
|
||||
FileOccupiedSize = GET_OCCUPIED_SIZE (FileLength, 8);
|
||||
FileOffset += FileOccupiedSize;
|
||||
FfsFileHeader = (EFI_FFS_FILE_HEADER *)((UINT8 *)FfsFileHeader + FileOccupiedSize);
|
||||
break;
|
||||
|
||||
default:
|
||||
*FileHeader = NULL;
|
||||
return EFI_NOT_FOUND;
|
||||
default:
|
||||
*FileHeader = NULL;
|
||||
return EFI_NOT_FOUND;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
*FileHeader = NULL;
|
||||
return EFI_NOT_FOUND;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Go through the file to search SectionType section,
|
||||
when meeting an encapsuled section.
|
||||
@@ -286,20 +279,19 @@ FfsProcessSection (
|
||||
OUT VOID **OutputBuffer
|
||||
)
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
UINT32 SectionLength;
|
||||
UINT32 ParsedLength;
|
||||
EFI_COMPRESSION_SECTION *CompressionSection;
|
||||
EFI_COMPRESSION_SECTION2 *CompressionSection2;
|
||||
UINT32 DstBufferSize;
|
||||
VOID *ScratchBuffer;
|
||||
UINT32 ScratchBufferSize;
|
||||
VOID *DstBuffer;
|
||||
UINT16 SectionAttribute;
|
||||
UINT32 AuthenticationStatus;
|
||||
CHAR8 *CompressedData;
|
||||
UINTN CompressedDataLength;
|
||||
|
||||
EFI_STATUS Status;
|
||||
UINT32 SectionLength;
|
||||
UINT32 ParsedLength;
|
||||
EFI_COMPRESSION_SECTION *CompressionSection;
|
||||
EFI_COMPRESSION_SECTION2 *CompressionSection2;
|
||||
UINT32 DstBufferSize;
|
||||
VOID *ScratchBuffer;
|
||||
UINT32 ScratchBufferSize;
|
||||
VOID *DstBuffer;
|
||||
UINT16 SectionAttribute;
|
||||
UINT32 AuthenticationStatus;
|
||||
CHAR8 *CompressedData;
|
||||
UINTN CompressedDataLength;
|
||||
|
||||
*OutputBuffer = NULL;
|
||||
ParsedLength = 0;
|
||||
@@ -311,35 +303,34 @@ FfsProcessSection (
|
||||
|
||||
if (Section->Type == SectionType) {
|
||||
if (IS_SECTION2 (Section)) {
|
||||
*OutputBuffer = (VOID *)((UINT8 *) Section + sizeof (EFI_COMMON_SECTION_HEADER2));
|
||||
*OutputBuffer = (VOID *)((UINT8 *)Section + sizeof (EFI_COMMON_SECTION_HEADER2));
|
||||
} else {
|
||||
*OutputBuffer = (VOID *)((UINT8 *) Section + sizeof (EFI_COMMON_SECTION_HEADER));
|
||||
*OutputBuffer = (VOID *)((UINT8 *)Section + sizeof (EFI_COMMON_SECTION_HEADER));
|
||||
}
|
||||
|
||||
return EFI_SUCCESS;
|
||||
} else if ((Section->Type == EFI_SECTION_COMPRESSION) || (Section->Type == EFI_SECTION_GUID_DEFINED)) {
|
||||
|
||||
if (Section->Type == EFI_SECTION_COMPRESSION) {
|
||||
if (IS_SECTION2 (Section)) {
|
||||
CompressionSection2 = (EFI_COMPRESSION_SECTION2 *) Section;
|
||||
CompressionSection2 = (EFI_COMPRESSION_SECTION2 *)Section;
|
||||
SectionLength = SECTION2_SIZE (Section);
|
||||
|
||||
if (CompressionSection2->CompressionType != EFI_STANDARD_COMPRESSION) {
|
||||
return EFI_UNSUPPORTED;
|
||||
}
|
||||
|
||||
CompressedData = (CHAR8 *) ((EFI_COMPRESSION_SECTION2 *) Section + 1);
|
||||
CompressedDataLength = (UINT32) SectionLength - sizeof (EFI_COMPRESSION_SECTION2);
|
||||
CompressedData = (CHAR8 *)((EFI_COMPRESSION_SECTION2 *)Section + 1);
|
||||
CompressedDataLength = (UINT32)SectionLength - sizeof (EFI_COMPRESSION_SECTION2);
|
||||
} else {
|
||||
CompressionSection = (EFI_COMPRESSION_SECTION *) Section;
|
||||
SectionLength = SECTION_SIZE (Section);
|
||||
CompressionSection = (EFI_COMPRESSION_SECTION *)Section;
|
||||
SectionLength = SECTION_SIZE (Section);
|
||||
|
||||
if (CompressionSection->CompressionType != EFI_STANDARD_COMPRESSION) {
|
||||
return EFI_UNSUPPORTED;
|
||||
}
|
||||
|
||||
CompressedData = (CHAR8 *) ((EFI_COMPRESSION_SECTION *) Section + 1);
|
||||
CompressedDataLength = (UINT32) SectionLength - sizeof (EFI_COMPRESSION_SECTION);
|
||||
CompressedData = (CHAR8 *)((EFI_COMPRESSION_SECTION *)Section + 1);
|
||||
CompressedDataLength = (UINT32)SectionLength - sizeof (EFI_COMPRESSION_SECTION);
|
||||
}
|
||||
|
||||
Status = UefiDecompressGetInfo (
|
||||
@@ -364,6 +355,7 @@ FfsProcessSection (
|
||||
DEBUG ((DEBUG_ERROR, "Decompress GetInfo Failed - %r\n", Status));
|
||||
return EFI_NOT_FOUND;
|
||||
}
|
||||
|
||||
//
|
||||
// Allocate scratch buffer
|
||||
//
|
||||
@@ -371,6 +363,7 @@ FfsProcessSection (
|
||||
if (ScratchBuffer == NULL) {
|
||||
return EFI_OUT_OF_RESOURCES;
|
||||
}
|
||||
|
||||
//
|
||||
// Allocate destination buffer, extra one page for adjustment
|
||||
//
|
||||
@@ -378,37 +371,39 @@ FfsProcessSection (
|
||||
if (DstBuffer == NULL) {
|
||||
return EFI_OUT_OF_RESOURCES;
|
||||
}
|
||||
|
||||
//
|
||||
// DstBuffer still is one section. Adjust DstBuffer offset, skip EFI section header
|
||||
// to make section data at page alignment.
|
||||
//
|
||||
if (IS_SECTION2 (Section))
|
||||
if (IS_SECTION2 (Section)) {
|
||||
DstBuffer = (UINT8 *)DstBuffer + EFI_PAGE_SIZE - sizeof (EFI_COMMON_SECTION_HEADER2);
|
||||
else
|
||||
} else {
|
||||
DstBuffer = (UINT8 *)DstBuffer + EFI_PAGE_SIZE - sizeof (EFI_COMMON_SECTION_HEADER);
|
||||
}
|
||||
|
||||
//
|
||||
// Call decompress function
|
||||
//
|
||||
if (Section->Type == EFI_SECTION_COMPRESSION) {
|
||||
if (IS_SECTION2 (Section)) {
|
||||
CompressedData = (CHAR8 *) ((EFI_COMPRESSION_SECTION2 *) Section + 1);
|
||||
}
|
||||
else {
|
||||
CompressedData = (CHAR8 *) ((EFI_COMPRESSION_SECTION *) Section + 1);
|
||||
CompressedData = (CHAR8 *)((EFI_COMPRESSION_SECTION2 *)Section + 1);
|
||||
} else {
|
||||
CompressedData = (CHAR8 *)((EFI_COMPRESSION_SECTION *)Section + 1);
|
||||
}
|
||||
|
||||
Status = UefiDecompress (
|
||||
CompressedData,
|
||||
DstBuffer,
|
||||
ScratchBuffer
|
||||
);
|
||||
CompressedData,
|
||||
DstBuffer,
|
||||
ScratchBuffer
|
||||
);
|
||||
} else if (Section->Type == EFI_SECTION_GUID_DEFINED) {
|
||||
Status = ExtractGuidedSectionDecode (
|
||||
Section,
|
||||
&DstBuffer,
|
||||
ScratchBuffer,
|
||||
&AuthenticationStatus
|
||||
);
|
||||
Section,
|
||||
&DstBuffer,
|
||||
ScratchBuffer,
|
||||
&AuthenticationStatus
|
||||
);
|
||||
}
|
||||
|
||||
if (EFI_ERROR (Status)) {
|
||||
@@ -419,12 +414,12 @@ FfsProcessSection (
|
||||
return EFI_NOT_FOUND;
|
||||
} else {
|
||||
return FfsProcessSection (
|
||||
SectionType,
|
||||
DstBuffer,
|
||||
DstBufferSize,
|
||||
OutputBuffer
|
||||
);
|
||||
}
|
||||
SectionType,
|
||||
DstBuffer,
|
||||
DstBufferSize,
|
||||
OutputBuffer
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
if (IS_SECTION2 (Section)) {
|
||||
@@ -432,6 +427,7 @@ FfsProcessSection (
|
||||
} else {
|
||||
SectionLength = SECTION_SIZE (Section);
|
||||
}
|
||||
|
||||
//
|
||||
// SectionLength is adjusted it is 4 byte aligned.
|
||||
// Go to the next section
|
||||
@@ -439,14 +435,12 @@ FfsProcessSection (
|
||||
SectionLength = GET_OCCUPIED_SIZE (SectionLength, 4);
|
||||
ASSERT (SectionLength != 0);
|
||||
ParsedLength += SectionLength;
|
||||
Section = (EFI_COMMON_SECTION_HEADER *)((UINT8 *)Section + SectionLength);
|
||||
Section = (EFI_COMMON_SECTION_HEADER *)((UINT8 *)Section + SectionLength);
|
||||
}
|
||||
|
||||
return EFI_NOT_FOUND;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**
|
||||
This service enables discovery sections of a given type within a valid FFS file.
|
||||
|
||||
@@ -462,14 +456,14 @@ FfsProcessSection (
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
FfsFindSectionData (
|
||||
IN EFI_SECTION_TYPE SectionType,
|
||||
IN EFI_PEI_FILE_HANDLE FileHandle,
|
||||
OUT VOID **SectionData
|
||||
IN EFI_SECTION_TYPE SectionType,
|
||||
IN EFI_PEI_FILE_HANDLE FileHandle,
|
||||
OUT VOID **SectionData
|
||||
)
|
||||
{
|
||||
EFI_FFS_FILE_HEADER *FfsFileHeader;
|
||||
UINT32 FileSize;
|
||||
EFI_COMMON_SECTION_HEADER *Section;
|
||||
EFI_FFS_FILE_HEADER *FfsFileHeader;
|
||||
UINT32 FileSize;
|
||||
EFI_COMMON_SECTION_HEADER *Section;
|
||||
|
||||
FfsFileHeader = (EFI_FFS_FILE_HEADER *)(FileHandle);
|
||||
|
||||
@@ -478,23 +472,18 @@ FfsFindSectionData (
|
||||
// Does not include FfsFileHeader header size
|
||||
// FileSize is adjusted to FileOccupiedSize as it is 8 byte aligned.
|
||||
//
|
||||
Section = (EFI_COMMON_SECTION_HEADER *)(FfsFileHeader + 1);
|
||||
FileSize = *(UINT32 *)(FfsFileHeader->Size) & 0x00FFFFFF;
|
||||
Section = (EFI_COMMON_SECTION_HEADER *)(FfsFileHeader + 1);
|
||||
FileSize = *(UINT32 *)(FfsFileHeader->Size) & 0x00FFFFFF;
|
||||
FileSize -= sizeof (EFI_FFS_FILE_HEADER);
|
||||
|
||||
return FfsProcessSection (
|
||||
SectionType,
|
||||
Section,
|
||||
FileSize,
|
||||
SectionData
|
||||
);
|
||||
SectionType,
|
||||
Section,
|
||||
FileSize,
|
||||
SectionData
|
||||
);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/**
|
||||
This service enables discovery of additional firmware files.
|
||||
|
||||
@@ -511,15 +500,14 @@ FfsFindSectionData (
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
FfsFindNextFile (
|
||||
IN UINT8 SearchType,
|
||||
IN EFI_PEI_FV_HANDLE VolumeHandle,
|
||||
IN OUT EFI_PEI_FILE_HANDLE *FileHandle
|
||||
IN UINT8 SearchType,
|
||||
IN EFI_PEI_FV_HANDLE VolumeHandle,
|
||||
IN OUT EFI_PEI_FILE_HANDLE *FileHandle
|
||||
)
|
||||
{
|
||||
return FindFileEx (VolumeHandle, NULL, SearchType, FileHandle);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
This service enables discovery of additional firmware volumes.
|
||||
|
||||
@@ -534,12 +522,11 @@ FfsFindNextFile (
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
FfsFindNextVolume (
|
||||
IN UINTN Instance,
|
||||
IN OUT EFI_PEI_FV_HANDLE *VolumeHandle
|
||||
IN UINTN Instance,
|
||||
IN OUT EFI_PEI_FV_HANDLE *VolumeHandle
|
||||
)
|
||||
{
|
||||
EFI_PEI_HOB_POINTERS Hob;
|
||||
|
||||
EFI_PEI_HOB_POINTERS Hob;
|
||||
|
||||
Hob.Raw = GetHobList ();
|
||||
if (Hob.Raw == NULL) {
|
||||
@@ -559,10 +546,8 @@ FfsFindNextVolume (
|
||||
} while (Hob.Raw != NULL);
|
||||
|
||||
return EFI_NOT_FOUND;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Find a file in the volume by name
|
||||
|
||||
@@ -584,25 +569,25 @@ FfsFindNextVolume (
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
FfsFindFileByName (
|
||||
IN CONST EFI_GUID *FileName,
|
||||
IN EFI_PEI_FV_HANDLE VolumeHandle,
|
||||
OUT EFI_PEI_FILE_HANDLE *FileHandle
|
||||
IN CONST EFI_GUID *FileName,
|
||||
IN EFI_PEI_FV_HANDLE VolumeHandle,
|
||||
OUT EFI_PEI_FILE_HANDLE *FileHandle
|
||||
)
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
|
||||
if ((VolumeHandle == NULL) || (FileName == NULL) || (FileHandle == NULL)) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
Status = FindFileEx (VolumeHandle, FileName, 0, FileHandle);
|
||||
if (Status == EFI_NOT_FOUND) {
|
||||
*FileHandle = NULL;
|
||||
}
|
||||
|
||||
return Status;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
/**
|
||||
Get information about the file by name.
|
||||
|
||||
@@ -626,10 +611,10 @@ FfsGetFileInfo (
|
||||
OUT EFI_FV_FILE_INFO *FileInfo
|
||||
)
|
||||
{
|
||||
UINT8 FileState;
|
||||
UINT8 ErasePolarity;
|
||||
EFI_FFS_FILE_HEADER *FileHeader;
|
||||
EFI_PEI_FV_HANDLE VolumeHandle;
|
||||
UINT8 FileState;
|
||||
UINT8 ErasePolarity;
|
||||
EFI_FFS_FILE_HEADER *FileHeader;
|
||||
EFI_PEI_FV_HANDLE VolumeHandle;
|
||||
|
||||
if ((FileHandle == NULL) || (FileInfo == NULL)) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
@@ -639,11 +624,11 @@ FfsGetFileInfo (
|
||||
//
|
||||
// Retrieve the FirmwareVolume which the file resides in.
|
||||
//
|
||||
if (!FileHandleToVolume(FileHandle, &VolumeHandle)) {
|
||||
if (!FileHandleToVolume (FileHandle, &VolumeHandle)) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
if (((EFI_FIRMWARE_VOLUME_HEADER*)VolumeHandle)->Attributes & EFI_FVB2_ERASE_POLARITY) {
|
||||
if (((EFI_FIRMWARE_VOLUME_HEADER *)VolumeHandle)->Attributes & EFI_FVB2_ERASE_POLARITY) {
|
||||
ErasePolarity = 1;
|
||||
} else {
|
||||
ErasePolarity = 0;
|
||||
@@ -652,7 +637,7 @@ FfsGetFileInfo (
|
||||
//
|
||||
// Get FileState which is the highest bit of the State
|
||||
//
|
||||
FileState = GetFileState (ErasePolarity, (EFI_FFS_FILE_HEADER*)FileHandle);
|
||||
FileState = GetFileState (ErasePolarity, (EFI_FFS_FILE_HEADER *)FileHandle);
|
||||
|
||||
switch (FileState) {
|
||||
case EFI_FILE_DATA_VALID:
|
||||
@@ -660,18 +645,17 @@ FfsGetFileInfo (
|
||||
break;
|
||||
default:
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
}
|
||||
|
||||
FileHeader = (EFI_FFS_FILE_HEADER *)FileHandle;
|
||||
CopyMem (&FileInfo->FileName, &FileHeader->Name, sizeof(EFI_GUID));
|
||||
FileInfo->FileType = FileHeader->Type;
|
||||
CopyMem (&FileInfo->FileName, &FileHeader->Name, sizeof (EFI_GUID));
|
||||
FileInfo->FileType = FileHeader->Type;
|
||||
FileInfo->FileAttributes = FileHeader->Attributes;
|
||||
FileInfo->BufferSize = ((*(UINT32 *)FileHeader->Size) & 0x00FFFFFF) - sizeof (EFI_FFS_FILE_HEADER);
|
||||
FileInfo->Buffer = (FileHeader + 1);
|
||||
FileInfo->BufferSize = ((*(UINT32 *)FileHeader->Size) & 0x00FFFFFF) - sizeof (EFI_FFS_FILE_HEADER);
|
||||
FileInfo->Buffer = (FileHeader + 1);
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Get Information about the volume by name
|
||||
|
||||
@@ -695,8 +679,8 @@ FfsGetVolumeInfo (
|
||||
OUT EFI_FV_INFO *VolumeInfo
|
||||
)
|
||||
{
|
||||
EFI_FIRMWARE_VOLUME_HEADER FwVolHeader;
|
||||
EFI_FIRMWARE_VOLUME_EXT_HEADER *FwVolExHeaderInfo;
|
||||
EFI_FIRMWARE_VOLUME_HEADER FwVolHeader;
|
||||
EFI_FIRMWARE_VOLUME_EXT_HEADER *FwVolExHeaderInfo;
|
||||
|
||||
if (VolumeInfo == NULL) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
@@ -714,20 +698,20 @@ FfsGetVolumeInfo (
|
||||
if (FwVolHeader.Signature != EFI_FVH_SIGNATURE) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
VolumeInfo->FvAttributes = FwVolHeader.Attributes;
|
||||
VolumeInfo->FvStart = (VOID *) VolumeHandle;
|
||||
VolumeInfo->FvSize = FwVolHeader.FvLength;
|
||||
CopyMem (&VolumeInfo->FvFormat, &FwVolHeader.FileSystemGuid, sizeof(EFI_GUID));
|
||||
VolumeInfo->FvStart = (VOID *)VolumeHandle;
|
||||
VolumeInfo->FvSize = FwVolHeader.FvLength;
|
||||
CopyMem (&VolumeInfo->FvFormat, &FwVolHeader.FileSystemGuid, sizeof (EFI_GUID));
|
||||
|
||||
if (FwVolHeader.ExtHeaderOffset != 0) {
|
||||
FwVolExHeaderInfo = (EFI_FIRMWARE_VOLUME_EXT_HEADER*)(((UINT8 *)VolumeHandle) + FwVolHeader.ExtHeaderOffset);
|
||||
CopyMem (&VolumeInfo->FvName, &FwVolExHeaderInfo->FvName, sizeof(EFI_GUID));
|
||||
FwVolExHeaderInfo = (EFI_FIRMWARE_VOLUME_EXT_HEADER *)(((UINT8 *)VolumeHandle) + FwVolHeader.ExtHeaderOffset);
|
||||
CopyMem (&VolumeInfo->FvName, &FwVolExHeaderInfo->FvName, sizeof (EFI_GUID));
|
||||
}
|
||||
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**
|
||||
Search through every FV until you find a file of type FileType
|
||||
|
||||
@@ -742,13 +726,13 @@ FfsGetVolumeInfo (
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
FfsAnyFvFindFirstFile (
|
||||
IN EFI_FV_FILETYPE FileType,
|
||||
OUT EFI_PEI_FV_HANDLE *VolumeHandle,
|
||||
OUT EFI_PEI_FILE_HANDLE *FileHandle
|
||||
IN EFI_FV_FILETYPE FileType,
|
||||
OUT EFI_PEI_FV_HANDLE *VolumeHandle,
|
||||
OUT EFI_PEI_FILE_HANDLE *FileHandle
|
||||
)
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
UINTN Instance;
|
||||
EFI_STATUS Status;
|
||||
UINTN Instance;
|
||||
|
||||
//
|
||||
// Search every FV for the DXE Core
|
||||
@@ -756,17 +740,14 @@ FfsAnyFvFindFirstFile (
|
||||
Instance = 0;
|
||||
*FileHandle = NULL;
|
||||
|
||||
while (1)
|
||||
{
|
||||
while (1) {
|
||||
Status = FfsFindNextVolume (Instance++, VolumeHandle);
|
||||
if (EFI_ERROR (Status))
|
||||
{
|
||||
if (EFI_ERROR (Status)) {
|
||||
break;
|
||||
}
|
||||
|
||||
Status = FfsFindNextFile (FileType, *VolumeHandle, FileHandle);
|
||||
if (!EFI_ERROR (Status))
|
||||
{
|
||||
if (!EFI_ERROR (Status)) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
@@ -774,8 +755,6 @@ FfsAnyFvFindFirstFile (
|
||||
return Status;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**
|
||||
Get Fv image from the FV type file, then add FV & FV2 Hob.
|
||||
|
||||
@@ -789,7 +768,7 @@ FfsAnyFvFindFirstFile (
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
FfsProcessFvFile (
|
||||
IN EFI_PEI_FILE_HANDLE FvFileHandle
|
||||
IN EFI_PEI_FILE_HANDLE FvFileHandle
|
||||
)
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
@@ -799,8 +778,7 @@ FfsProcessFvFile (
|
||||
VOID *FvBuffer;
|
||||
EFI_PEI_HOB_POINTERS HobFv2;
|
||||
|
||||
FvBuffer = NULL;
|
||||
|
||||
FvBuffer = NULL;
|
||||
|
||||
//
|
||||
// Check if this EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE file has already
|
||||
@@ -814,6 +792,7 @@ FfsProcessFvFile (
|
||||
//
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
HobFv2.Raw = GET_NEXT_HOB (HobFv2);
|
||||
}
|
||||
|
||||
@@ -843,30 +822,30 @@ FfsProcessFvFile (
|
||||
//
|
||||
// Check FvImage
|
||||
//
|
||||
if ((UINTN) FvImageInfo.FvStart % FvAlignment != 0) {
|
||||
FvBuffer = AllocateAlignedPages (EFI_SIZE_TO_PAGES ((UINT32) FvImageInfo.FvSize), FvAlignment);
|
||||
if ((UINTN)FvImageInfo.FvStart % FvAlignment != 0) {
|
||||
FvBuffer = AllocateAlignedPages (EFI_SIZE_TO_PAGES ((UINT32)FvImageInfo.FvSize), FvAlignment);
|
||||
if (FvBuffer == NULL) {
|
||||
return EFI_OUT_OF_RESOURCES;
|
||||
}
|
||||
CopyMem (FvBuffer, FvImageInfo.FvStart, (UINTN) FvImageInfo.FvSize);
|
||||
|
||||
CopyMem (FvBuffer, FvImageInfo.FvStart, (UINTN)FvImageInfo.FvSize);
|
||||
//
|
||||
// Update FvImageInfo after reload FvImage to new aligned memory
|
||||
//
|
||||
FfsGetVolumeInfo ((EFI_PEI_FV_HANDLE) FvBuffer, &FvImageInfo);
|
||||
FfsGetVolumeInfo ((EFI_PEI_FV_HANDLE)FvBuffer, &FvImageInfo);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// Inform HOB consumer phase, i.e. DXE core, the existence of this FV
|
||||
//
|
||||
BuildFvHob ((EFI_PHYSICAL_ADDRESS) (UINTN) FvImageInfo.FvStart, FvImageInfo.FvSize);
|
||||
BuildFvHob ((EFI_PHYSICAL_ADDRESS)(UINTN)FvImageInfo.FvStart, FvImageInfo.FvSize);
|
||||
|
||||
//
|
||||
// Makes the encapsulated volume show up in DXE phase to skip processing of
|
||||
// encapsulated file again.
|
||||
//
|
||||
BuildFv2Hob (
|
||||
(EFI_PHYSICAL_ADDRESS) (UINTN) FvImageInfo.FvStart,
|
||||
(EFI_PHYSICAL_ADDRESS)(UINTN)FvImageInfo.FvStart,
|
||||
FvImageInfo.FvSize,
|
||||
&FvImageInfo.FvName,
|
||||
&(((EFI_FFS_FILE_HEADER *)FvFileHandle)->Name)
|
||||
|
@@ -26,7 +26,6 @@
|
||||
|
||||
#include <Guid/MemoryAllocationHob.h>
|
||||
|
||||
|
||||
#define GET_HOB_TYPE(Hob) ((Hob).Header->HobType)
|
||||
#define GET_HOB_LENGTH(Hob) ((Hob).Header->HobLength)
|
||||
#define GET_NEXT_HOB(Hob) ((Hob).Raw + GET_HOB_LENGTH (Hob))
|
||||
@@ -35,7 +34,7 @@
|
||||
//
|
||||
// Get the data and data size field of GUID
|
||||
//
|
||||
#define GET_GUID_HOB_DATA(GuidHob) ((VOID *) (((UINT8 *) &((GuidHob)->Name)) + sizeof (EFI_GUID)))
|
||||
#define GET_GUID_HOB_DATA_SIZE(GuidHob) (((GuidHob)->Header).HobLength - sizeof (EFI_HOB_GUID_TYPE))
|
||||
#define GET_GUID_HOB_DATA(GuidHob) ((VOID *) (((UINT8 *) &((GuidHob)->Name)) + sizeof (EFI_GUID)))
|
||||
#define GET_GUID_HOB_DATA_SIZE(GuidHob) (((GuidHob)->Header).HobLength - sizeof (EFI_HOB_GUID_TYPE))
|
||||
|
||||
#endif
|
||||
|
@@ -16,21 +16,21 @@ EFI_STATUS
|
||||
EFIAPI
|
||||
|
||||
SecWinNtPeiLoadFile (
|
||||
IN VOID *Pe32Data,
|
||||
IN EFI_PHYSICAL_ADDRESS *ImageAddress,
|
||||
IN UINT64 *ImageSize,
|
||||
IN EFI_PHYSICAL_ADDRESS *EntryPoint
|
||||
IN VOID *Pe32Data,
|
||||
IN EFI_PHYSICAL_ADDRESS *ImageAddress,
|
||||
IN UINT64 *ImageSize,
|
||||
IN EFI_PHYSICAL_ADDRESS *EntryPoint
|
||||
);
|
||||
|
||||
STATIC
|
||||
VOID*
|
||||
VOID *
|
||||
EFIAPI
|
||||
AllocateCodePages (
|
||||
IN UINTN Pages
|
||||
IN UINTN Pages
|
||||
)
|
||||
{
|
||||
VOID *Alloc;
|
||||
EFI_PEI_HOB_POINTERS Hob;
|
||||
VOID *Alloc;
|
||||
EFI_PEI_HOB_POINTERS Hob;
|
||||
|
||||
Alloc = AllocatePages (Pages);
|
||||
if (Alloc == NULL) {
|
||||
@@ -44,6 +44,7 @@ AllocateCodePages (
|
||||
Hob.MemoryAllocation->AllocDescriptor.MemoryType = EfiBootServicesCode;
|
||||
return Alloc;
|
||||
}
|
||||
|
||||
Hob.Raw = GetNextHob (EFI_HOB_TYPE_MEMORY_ALLOCATION, GET_NEXT_HOB (Hob));
|
||||
}
|
||||
|
||||
@@ -53,19 +54,18 @@ AllocateCodePages (
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
LoadPeCoffImage (
|
||||
IN VOID *PeCoffImage,
|
||||
OUT EFI_PHYSICAL_ADDRESS *ImageAddress,
|
||||
OUT UINT64 *ImageSize,
|
||||
OUT EFI_PHYSICAL_ADDRESS *EntryPoint
|
||||
IN VOID *PeCoffImage,
|
||||
OUT EFI_PHYSICAL_ADDRESS *ImageAddress,
|
||||
OUT UINT64 *ImageSize,
|
||||
OUT EFI_PHYSICAL_ADDRESS *EntryPoint
|
||||
)
|
||||
{
|
||||
RETURN_STATUS Status;
|
||||
PE_COFF_LOADER_IMAGE_CONTEXT ImageContext;
|
||||
VOID *Buffer;
|
||||
VOID *Buffer;
|
||||
|
||||
ZeroMem (&ImageContext, sizeof (ImageContext));
|
||||
|
||||
@@ -75,14 +75,12 @@ LoadPeCoffImage (
|
||||
Status = PeCoffLoaderGetImageInfo (&ImageContext);
|
||||
ASSERT_EFI_ERROR (Status);
|
||||
|
||||
|
||||
//
|
||||
// Allocate Memory for the image
|
||||
//
|
||||
Buffer = AllocateCodePages (EFI_SIZE_TO_PAGES((UINT32)ImageContext.ImageSize));
|
||||
Buffer = AllocateCodePages (EFI_SIZE_TO_PAGES ((UINT32)ImageContext.ImageSize));
|
||||
ASSERT (Buffer != 0);
|
||||
|
||||
|
||||
ImageContext.ImageAddress = (EFI_PHYSICAL_ADDRESS)(UINTN)Buffer;
|
||||
|
||||
//
|
||||
@@ -97,7 +95,6 @@ LoadPeCoffImage (
|
||||
Status = PeCoffLoaderRelocateImage (&ImageContext);
|
||||
ASSERT_EFI_ERROR (Status);
|
||||
|
||||
|
||||
*ImageAddress = ImageContext.ImageAddress;
|
||||
*ImageSize = ImageContext.ImageSize;
|
||||
*EntryPoint = ImageContext.EntryPoint;
|
||||
@@ -111,11 +108,9 @@ LoadPeCoffImage (
|
||||
return Status;
|
||||
}
|
||||
|
||||
|
||||
|
||||
typedef
|
||||
VOID
|
||||
(EFIAPI *DXE_CORE_ENTRY_POINT) (
|
||||
(EFIAPI *DXE_CORE_ENTRY_POINT)(
|
||||
IN VOID *HobStart
|
||||
);
|
||||
|
||||
@@ -126,24 +121,23 @@ LoadDxeCoreFromFfsFile (
|
||||
IN UINTN StackSize
|
||||
)
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
VOID *PeCoffImage;
|
||||
EFI_PHYSICAL_ADDRESS ImageAddress;
|
||||
UINT64 ImageSize;
|
||||
EFI_PHYSICAL_ADDRESS EntryPoint;
|
||||
VOID *BaseOfStack;
|
||||
VOID *TopOfStack;
|
||||
VOID *Hob;
|
||||
EFI_FV_FILE_INFO FvFileInfo;
|
||||
EFI_STATUS Status;
|
||||
VOID *PeCoffImage;
|
||||
EFI_PHYSICAL_ADDRESS ImageAddress;
|
||||
UINT64 ImageSize;
|
||||
EFI_PHYSICAL_ADDRESS EntryPoint;
|
||||
VOID *BaseOfStack;
|
||||
VOID *TopOfStack;
|
||||
VOID *Hob;
|
||||
EFI_FV_FILE_INFO FvFileInfo;
|
||||
|
||||
Status = FfsFindSectionData (EFI_SECTION_PE32, FileHandle, &PeCoffImage);
|
||||
if (EFI_ERROR (Status)) {
|
||||
if (EFI_ERROR (Status)) {
|
||||
return Status;
|
||||
}
|
||||
|
||||
|
||||
Status = LoadPeCoffImage (PeCoffImage, &ImageAddress, &ImageSize, &EntryPoint);
|
||||
// For NT32 Debug Status = SecWinNtPeiLoadFile (PeCoffImage, &ImageAddress, &ImageSize, &EntryPoint);
|
||||
// For NT32 Debug Status = SecWinNtPeiLoadFile (PeCoffImage, &ImageAddress, &ImageSize, &EntryPoint);
|
||||
ASSERT_EFI_ERROR (Status);
|
||||
|
||||
//
|
||||
@@ -152,7 +146,7 @@ LoadDxeCoreFromFfsFile (
|
||||
Status = FfsGetFileInfo (FileHandle, &FvFileInfo);
|
||||
ASSERT_EFI_ERROR (Status);
|
||||
|
||||
BuildModuleHob (&FvFileInfo.FileName, (EFI_PHYSICAL_ADDRESS)(UINTN)ImageAddress, EFI_SIZE_TO_PAGES ((UINT32) ImageSize) * EFI_PAGE_SIZE, EntryPoint);
|
||||
BuildModuleHob (&FvFileInfo.FileName, (EFI_PHYSICAL_ADDRESS)(UINTN)ImageAddress, EFI_SIZE_TO_PAGES ((UINT32)ImageSize) * EFI_PAGE_SIZE, EntryPoint);
|
||||
|
||||
DEBUG ((DEBUG_INFO | DEBUG_LOAD, "Loading DxeCore at 0x%10p EntryPoint=0x%10p\n", (VOID *)(UINTN)ImageAddress, (VOID *)(UINTN)EntryPoint));
|
||||
|
||||
@@ -160,9 +154,8 @@ LoadDxeCoreFromFfsFile (
|
||||
if (StackSize == 0) {
|
||||
// User the current stack
|
||||
|
||||
((DXE_CORE_ENTRY_POINT)(UINTN)EntryPoint) (Hob);
|
||||
((DXE_CORE_ENTRY_POINT)(UINTN)EntryPoint)(Hob);
|
||||
} else {
|
||||
|
||||
//
|
||||
// Allocate 128KB for the Stack
|
||||
//
|
||||
@@ -173,13 +166,13 @@ LoadDxeCoreFromFfsFile (
|
||||
// Compute the top of the stack we were allocated. Pre-allocate a UINTN
|
||||
// for safety.
|
||||
//
|
||||
TopOfStack = (VOID *) ((UINTN) BaseOfStack + EFI_SIZE_TO_PAGES (StackSize) * EFI_PAGE_SIZE - CPU_STACK_ALIGNMENT);
|
||||
TopOfStack = (VOID *)((UINTN)BaseOfStack + EFI_SIZE_TO_PAGES (StackSize) * EFI_PAGE_SIZE - CPU_STACK_ALIGNMENT);
|
||||
TopOfStack = ALIGN_POINTER (TopOfStack, CPU_STACK_ALIGNMENT);
|
||||
|
||||
//
|
||||
// Update the contents of BSP stack HOB to reflect the real stack info passed to DxeCore.
|
||||
//
|
||||
UpdateStackHob ((EFI_PHYSICAL_ADDRESS)(UINTN) BaseOfStack, StackSize);
|
||||
UpdateStackHob ((EFI_PHYSICAL_ADDRESS)(UINTN)BaseOfStack, StackSize);
|
||||
|
||||
SwitchStack (
|
||||
(SWITCH_STACK_ENTRY_POINT)(UINTN)EntryPoint,
|
||||
@@ -187,7 +180,6 @@ LoadDxeCoreFromFfsFile (
|
||||
NULL,
|
||||
TopOfStack
|
||||
);
|
||||
|
||||
}
|
||||
|
||||
// Should never get here as DXE Core does not return
|
||||
@@ -197,8 +189,6 @@ LoadDxeCoreFromFfsFile (
|
||||
return EFI_DEVICE_ERROR;
|
||||
}
|
||||
|
||||
|
||||
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
LoadDxeCoreFromFv (
|
||||
@@ -206,9 +196,9 @@ LoadDxeCoreFromFv (
|
||||
IN UINTN StackSize
|
||||
)
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
EFI_PEI_FV_HANDLE VolumeHandle;
|
||||
EFI_PEI_FILE_HANDLE FileHandle = NULL;
|
||||
EFI_STATUS Status;
|
||||
EFI_PEI_FV_HANDLE VolumeHandle;
|
||||
EFI_PEI_FILE_HANDLE FileHandle = NULL;
|
||||
|
||||
if (FvInstance != NULL) {
|
||||
//
|
||||
@@ -229,16 +219,15 @@ LoadDxeCoreFromFv (
|
||||
return Status;
|
||||
}
|
||||
|
||||
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
DecompressFirstFv (
|
||||
VOID
|
||||
)
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
EFI_PEI_FV_HANDLE VolumeHandle;
|
||||
EFI_PEI_FILE_HANDLE FileHandle;
|
||||
EFI_STATUS Status;
|
||||
EFI_PEI_FV_HANDLE VolumeHandle;
|
||||
EFI_PEI_FILE_HANDLE FileHandle;
|
||||
|
||||
Status = FfsAnyFvFindFirstFile (EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE, &VolumeHandle, &FileHandle);
|
||||
if (!EFI_ERROR (Status)) {
|
||||
|
@@ -14,8 +14,6 @@
|
||||
#include <Library/PrePiLib.h>
|
||||
#include <Library/DebugLib.h>
|
||||
|
||||
|
||||
|
||||
/**
|
||||
Allocates one or more 4KB pages of type EfiBootServicesData.
|
||||
|
||||
@@ -32,11 +30,11 @@
|
||||
VOID *
|
||||
EFIAPI
|
||||
AllocatePages (
|
||||
IN UINTN Pages
|
||||
IN UINTN Pages
|
||||
)
|
||||
{
|
||||
EFI_PEI_HOB_POINTERS Hob;
|
||||
EFI_PHYSICAL_ADDRESS Offset;
|
||||
EFI_PEI_HOB_POINTERS Hob;
|
||||
EFI_PHYSICAL_ADDRESS Offset;
|
||||
|
||||
Hob.Raw = GetHobList ();
|
||||
|
||||
@@ -65,15 +63,14 @@ AllocatePages (
|
||||
// Create a memory allocation HOB.
|
||||
//
|
||||
BuildMemoryAllocationHob (
|
||||
Hob.HandoffInformationTable->EfiFreeMemoryTop,
|
||||
Pages * EFI_PAGE_SIZE,
|
||||
EfiBootServicesData
|
||||
);
|
||||
Hob.HandoffInformationTable->EfiFreeMemoryTop,
|
||||
Pages * EFI_PAGE_SIZE,
|
||||
EfiBootServicesData
|
||||
);
|
||||
return (VOID *)(UINTN)Hob.HandoffInformationTable->EfiFreeMemoryTop;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Allocates one or more 4KB pages of type EfiBootServicesData at a specified alignment.
|
||||
|
||||
@@ -97,8 +94,8 @@ AllocateAlignedPages (
|
||||
IN UINTN Alignment
|
||||
)
|
||||
{
|
||||
VOID *Memory;
|
||||
UINTN AlignmentMask;
|
||||
VOID *Memory;
|
||||
UINTN AlignmentMask;
|
||||
|
||||
//
|
||||
// Alignment must be a power of two or zero.
|
||||
@@ -108,6 +105,7 @@ AllocateAlignedPages (
|
||||
if (Pages == 0) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
//
|
||||
// Make sure that Pages plus EFI_SIZE_TO_PAGES (Alignment) does not overflow.
|
||||
//
|
||||
@@ -121,9 +119,9 @@ AllocateAlignedPages (
|
||||
} else {
|
||||
AlignmentMask = Alignment - 1;
|
||||
}
|
||||
return (VOID *) (UINTN) (((UINTN) Memory + AlignmentMask) & ~AlignmentMask);
|
||||
}
|
||||
|
||||
return (VOID *)(UINTN)(((UINTN)Memory + AlignmentMask) & ~AlignmentMask);
|
||||
}
|
||||
|
||||
/**
|
||||
Frees one or more 4KB pages that were previously allocated with one of the page allocation
|
||||
@@ -171,11 +169,10 @@ AllocatePool (
|
||||
IN UINTN AllocationSize
|
||||
)
|
||||
{
|
||||
EFI_HOB_MEMORY_POOL *Hob;
|
||||
EFI_HOB_MEMORY_POOL *Hob;
|
||||
|
||||
Hob = GetHobList ();
|
||||
|
||||
|
||||
//
|
||||
// Verify that there is sufficient memory to satisfy the allocation
|
||||
//
|
||||
@@ -183,10 +180,11 @@ AllocatePool (
|
||||
// Please call AllocatePages for big allocations
|
||||
return 0;
|
||||
} else {
|
||||
|
||||
Hob = (EFI_HOB_MEMORY_POOL *)CreateHob (EFI_HOB_TYPE_MEMORY_POOL,
|
||||
Hob = (EFI_HOB_MEMORY_POOL *)CreateHob (
|
||||
EFI_HOB_TYPE_MEMORY_POOL,
|
||||
(UINT16)(sizeof (EFI_HOB_MEMORY_POOL) +
|
||||
AllocationSize));
|
||||
AllocationSize)
|
||||
);
|
||||
return (VOID *)(Hob + 1);
|
||||
}
|
||||
}
|
||||
@@ -210,7 +208,7 @@ AllocateZeroPool (
|
||||
IN UINTN AllocationSize
|
||||
)
|
||||
{
|
||||
VOID *Buffer;
|
||||
VOID *Buffer;
|
||||
|
||||
Buffer = AllocatePool (AllocationSize);
|
||||
if (Buffer == NULL) {
|
||||
@@ -239,7 +237,7 @@ AllocateZeroPool (
|
||||
VOID
|
||||
EFIAPI
|
||||
FreePool (
|
||||
IN VOID *Buffer
|
||||
IN VOID *Buffer
|
||||
)
|
||||
{
|
||||
// Not implemented yet
|
||||
|
@@ -15,7 +15,6 @@
|
||||
#include <Library/IoLib.h>
|
||||
#include <Library/RealTimeClockLib.h>
|
||||
|
||||
|
||||
/**
|
||||
Returns the current time and date information, and the time-keeping capabilities
|
||||
of the hardware platform.
|
||||
@@ -42,7 +41,6 @@ LibGetTime (
|
||||
return EFI_DEVICE_ERROR;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Sets the current local time and date information.
|
||||
|
||||
@@ -56,7 +54,7 @@ LibGetTime (
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
LibSetTime (
|
||||
IN EFI_TIME *Time
|
||||
IN EFI_TIME *Time
|
||||
)
|
||||
{
|
||||
//
|
||||
@@ -65,7 +63,6 @@ LibSetTime (
|
||||
return EFI_DEVICE_ERROR;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Returns the current wakeup alarm clock setting.
|
||||
|
||||
@@ -81,16 +78,15 @@ LibSetTime (
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
LibGetWakeupTime (
|
||||
OUT BOOLEAN *Enabled,
|
||||
OUT BOOLEAN *Pending,
|
||||
OUT EFI_TIME *Time
|
||||
OUT BOOLEAN *Enabled,
|
||||
OUT BOOLEAN *Pending,
|
||||
OUT EFI_TIME *Time
|
||||
)
|
||||
{
|
||||
// Not a required feature
|
||||
return EFI_UNSUPPORTED;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Sets the system wakeup alarm clock time.
|
||||
|
||||
@@ -107,16 +103,14 @@ LibGetWakeupTime (
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
LibSetWakeupTime (
|
||||
IN BOOLEAN Enabled,
|
||||
OUT EFI_TIME *Time
|
||||
IN BOOLEAN Enabled,
|
||||
OUT EFI_TIME *Time
|
||||
)
|
||||
{
|
||||
// Not a required feature
|
||||
return EFI_UNSUPPORTED;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**
|
||||
This is the declaration of an EFI image entry point. This can be the entry point to an application
|
||||
written to this specification, an EFI boot service driver, or an EFI runtime driver.
|
||||
@@ -130,8 +124,8 @@ LibSetWakeupTime (
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
LibRtcInitialize (
|
||||
IN EFI_HANDLE ImageHandle,
|
||||
IN EFI_SYSTEM_TABLE *SystemTable
|
||||
IN EFI_HANDLE ImageHandle,
|
||||
IN EFI_SYSTEM_TABLE *SystemTable
|
||||
)
|
||||
{
|
||||
//
|
||||
@@ -140,7 +134,6 @@ LibRtcInitialize (
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Fixup internal data so that EFI can be call in virtual mode.
|
||||
Call the passed in Child Notify event and convert any pointers in
|
||||
@@ -152,8 +145,8 @@ LibRtcInitialize (
|
||||
VOID
|
||||
EFIAPI
|
||||
LibRtcVirtualNotifyEvent (
|
||||
IN EFI_EVENT Event,
|
||||
IN VOID *Context
|
||||
IN EFI_EVENT Event,
|
||||
IN VOID *Context
|
||||
)
|
||||
{
|
||||
//
|
||||
@@ -164,6 +157,3 @@ LibRtcVirtualNotifyEvent (
|
||||
//
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
@@ -10,14 +10,12 @@
|
||||
|
||||
**/
|
||||
|
||||
|
||||
#include <PiDxe.h>
|
||||
|
||||
#include <Library/BaseLib.h>
|
||||
#include <Library/IoLib.h>
|
||||
#include <Library/EfiResetSystemLib.h>
|
||||
|
||||
|
||||
/**
|
||||
Resets the entire platform.
|
||||
|
||||
@@ -32,40 +30,39 @@
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
LibResetSystem (
|
||||
IN EFI_RESET_TYPE ResetType,
|
||||
IN EFI_STATUS ResetStatus,
|
||||
IN UINTN DataSize,
|
||||
IN CHAR16 *ResetData OPTIONAL
|
||||
IN EFI_RESET_TYPE ResetType,
|
||||
IN EFI_STATUS ResetStatus,
|
||||
IN UINTN DataSize,
|
||||
IN CHAR16 *ResetData OPTIONAL
|
||||
)
|
||||
{
|
||||
UINTN Address;
|
||||
UINT8 Data;
|
||||
|
||||
UINTN Address;
|
||||
UINT8 Data;
|
||||
|
||||
switch (ResetType) {
|
||||
case EfiResetCold:
|
||||
// system power cycle
|
||||
case EfiResetCold:
|
||||
// system power cycle
|
||||
|
||||
// Example using IoLib functions to do IO.
|
||||
Address = 0x12345678;
|
||||
Data = MmioRead8 (Address);
|
||||
MmioWrite8 (Address, Data | 0x01);
|
||||
// Example using IoLib functions to do IO.
|
||||
Address = 0x12345678;
|
||||
Data = MmioRead8 (Address);
|
||||
MmioWrite8 (Address, Data | 0x01);
|
||||
|
||||
// Note this is a bad example asa MmioOr8 (Address, 0x01) does the same thing
|
||||
break;
|
||||
// Note this is a bad example asa MmioOr8 (Address, 0x01) does the same thing
|
||||
break;
|
||||
|
||||
case EfiResetWarm:
|
||||
// not a full power cycle, maybe memory stays around.
|
||||
// if not support do the same thing as EfiResetCold.
|
||||
break;
|
||||
case EfiResetWarm:
|
||||
// not a full power cycle, maybe memory stays around.
|
||||
// if not support do the same thing as EfiResetCold.
|
||||
break;
|
||||
|
||||
case EfiResetShutdown:
|
||||
// turn off the system.
|
||||
// if not support do the same thing as EfiResetCold.
|
||||
break;
|
||||
case EfiResetShutdown:
|
||||
// turn off the system.
|
||||
// if not support do the same thing as EfiResetCold.
|
||||
break;
|
||||
|
||||
default:
|
||||
return EFI_INVALID_PARAMETER;
|
||||
default:
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
//
|
||||
@@ -74,8 +71,6 @@ LibResetSystem (
|
||||
return EFI_DEVICE_ERROR;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**
|
||||
Initialize any infrastructure required for LibResetSystem () to function.
|
||||
|
||||
@@ -94,4 +89,3 @@ LibInitializeResetSystem (
|
||||
{
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
|
@@ -27,22 +27,22 @@ EpochToEfiTime (
|
||||
OUT EFI_TIME *Time
|
||||
)
|
||||
{
|
||||
UINTN a;
|
||||
UINTN b;
|
||||
UINTN c;
|
||||
UINTN d;
|
||||
UINTN g;
|
||||
UINTN j;
|
||||
UINTN m;
|
||||
UINTN y;
|
||||
UINTN da;
|
||||
UINTN db;
|
||||
UINTN dc;
|
||||
UINTN dg;
|
||||
UINTN hh;
|
||||
UINTN mm;
|
||||
UINTN ss;
|
||||
UINTN J;
|
||||
UINTN a;
|
||||
UINTN b;
|
||||
UINTN c;
|
||||
UINTN d;
|
||||
UINTN g;
|
||||
UINTN j;
|
||||
UINTN m;
|
||||
UINTN y;
|
||||
UINTN da;
|
||||
UINTN db;
|
||||
UINTN dc;
|
||||
UINTN dg;
|
||||
UINTN hh;
|
||||
UINTN mm;
|
||||
UINTN ss;
|
||||
UINTN J;
|
||||
|
||||
J = (EpochSeconds / 86400) + 2440588;
|
||||
j = J + 32044;
|
||||
@@ -65,14 +65,13 @@ EpochToEfiTime (
|
||||
ss = EpochSeconds % 60;
|
||||
a = (EpochSeconds - ss) / 60;
|
||||
mm = a % 60;
|
||||
b = (a - mm) / 60;
|
||||
b = (a - mm) / 60;
|
||||
hh = b % 24;
|
||||
|
||||
Time->Hour = (UINT8)hh;
|
||||
Time->Minute = (UINT8)mm;
|
||||
Time->Second = (UINT8)ss;
|
||||
Time->Nanosecond = 0;
|
||||
|
||||
Time->Hour = (UINT8)hh;
|
||||
Time->Minute = (UINT8)mm;
|
||||
Time->Second = (UINT8)ss;
|
||||
Time->Nanosecond = 0;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -89,13 +88,13 @@ EfiGetEpochDays (
|
||||
IN EFI_TIME *Time
|
||||
)
|
||||
{
|
||||
UINTN a;
|
||||
UINTN y;
|
||||
UINTN m;
|
||||
UINTN JulianDate; // Absolute Julian Date representation of the supplied Time
|
||||
UINTN EpochDays; // Number of days elapsed since EPOCH_JULIAN_DAY
|
||||
UINTN a;
|
||||
UINTN y;
|
||||
UINTN m;
|
||||
UINTN JulianDate; // Absolute Julian Date representation of the supplied Time
|
||||
UINTN EpochDays; // Number of days elapsed since EPOCH_JULIAN_DAY
|
||||
|
||||
a = (14 - Time->Month) / 12 ;
|
||||
a = (14 - Time->Month) / 12;
|
||||
y = Time->Year + 4800 - a;
|
||||
m = Time->Month + (12*a) - 3;
|
||||
|
||||
@@ -121,8 +120,8 @@ EfiTimeToEpoch (
|
||||
IN EFI_TIME *Time
|
||||
)
|
||||
{
|
||||
UINTN EpochDays; // Number of days elapsed since EPOCH_JULIAN_DAY
|
||||
UINTN EpochSeconds;
|
||||
UINTN EpochDays; // Number of days elapsed since EPOCH_JULIAN_DAY
|
||||
UINTN EpochSeconds;
|
||||
|
||||
EpochDays = EfiGetEpochDays (Time);
|
||||
|
||||
@@ -144,7 +143,7 @@ EfiTimeToWday (
|
||||
IN EFI_TIME *Time
|
||||
)
|
||||
{
|
||||
UINTN EpochDays; // Number of days elapsed since EPOCH_JULIAN_DAY
|
||||
UINTN EpochDays; // Number of days elapsed since EPOCH_JULIAN_DAY
|
||||
|
||||
EpochDays = EfiGetEpochDays (Time);
|
||||
|
||||
@@ -165,7 +164,7 @@ EfiTimeToWday (
|
||||
BOOLEAN
|
||||
EFIAPI
|
||||
IsLeapYear (
|
||||
IN EFI_TIME *Time
|
||||
IN EFI_TIME *Time
|
||||
)
|
||||
{
|
||||
if (Time->Year % 4 == 0) {
|
||||
@@ -198,12 +197,13 @@ IsDayValid (
|
||||
IN EFI_TIME *Time
|
||||
)
|
||||
{
|
||||
STATIC CONST INTN DayOfMonth[12] = { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
|
||||
STATIC CONST INTN DayOfMonth[12] = { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
|
||||
|
||||
if (Time->Day < 1 ||
|
||||
Time->Day > DayOfMonth[Time->Month - 1] ||
|
||||
(Time->Month == 2 && (!IsLeapYear (Time) && Time->Day > 28))
|
||||
) {
|
||||
if ((Time->Day < 1) ||
|
||||
(Time->Day > DayOfMonth[Time->Month - 1]) ||
|
||||
((Time->Month == 2) && (!IsLeapYear (Time) && (Time->Day > 28)))
|
||||
)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
@@ -267,21 +267,22 @@ IsValidDaylight (
|
||||
BOOLEAN
|
||||
EFIAPI
|
||||
IsTimeValid (
|
||||
IN EFI_TIME *Time
|
||||
IN EFI_TIME *Time
|
||||
)
|
||||
{
|
||||
// Check the input parameters are within the range specified by UEFI
|
||||
if ((Time->Year < 2000) ||
|
||||
(Time->Year > 2099) ||
|
||||
(Time->Month < 1 ) ||
|
||||
(Time->Month > 12 ) ||
|
||||
(!IsDayValid (Time) ) ||
|
||||
(Time->Hour > 23 ) ||
|
||||
(Time->Minute > 59 ) ||
|
||||
(Time->Second > 59 ) ||
|
||||
(Time->Nanosecond > 999999999) ||
|
||||
(!IsValidTimeZone(Time->TimeZone)) ||
|
||||
(!IsValidDaylight(Time->Daylight))) {
|
||||
(Time->Year > 2099) ||
|
||||
(Time->Month < 1) ||
|
||||
(Time->Month > 12) ||
|
||||
(!IsDayValid (Time)) ||
|
||||
(Time->Hour > 23) ||
|
||||
(Time->Minute > 59) ||
|
||||
(Time->Second > 59) ||
|
||||
(Time->Nanosecond > 999999999) ||
|
||||
(!IsValidTimeZone (Time->TimeZone)) ||
|
||||
(!IsValidDaylight (Time->Daylight)))
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
|
@@ -23,9 +23,9 @@
|
||||
#include <Library/TimeBaseLib.h>
|
||||
#include <Library/UefiRuntimeLib.h>
|
||||
|
||||
STATIC CONST CHAR16 mEpochVariableName[] = L"RtcEpochSeconds";
|
||||
STATIC CONST CHAR16 mTimeZoneVariableName[] = L"RtcTimeZone";
|
||||
STATIC CONST CHAR16 mDaylightVariableName[] = L"RtcDaylight";
|
||||
STATIC CONST CHAR16 mEpochVariableName[] = L"RtcEpochSeconds";
|
||||
STATIC CONST CHAR16 mTimeZoneVariableName[] = L"RtcTimeZone";
|
||||
STATIC CONST CHAR16 mDaylightVariableName[] = L"RtcDaylight";
|
||||
|
||||
/**
|
||||
Returns the current time and date information, and the time-keeping capabilities
|
||||
@@ -67,19 +67,19 @@ LibGetTime (
|
||||
}
|
||||
|
||||
// Get the epoch time from non-volatile storage
|
||||
Size = sizeof (UINTN);
|
||||
Size = sizeof (UINTN);
|
||||
EpochSeconds = 0;
|
||||
Status = EfiGetVariable (
|
||||
(CHAR16 *)mEpochVariableName,
|
||||
&gEfiCallerIdGuid,
|
||||
NULL,
|
||||
&Size,
|
||||
(VOID *)&EpochSeconds
|
||||
);
|
||||
Status = EfiGetVariable (
|
||||
(CHAR16 *)mEpochVariableName,
|
||||
&gEfiCallerIdGuid,
|
||||
NULL,
|
||||
&Size,
|
||||
(VOID *)&EpochSeconds
|
||||
);
|
||||
// Fall back to compilation-time epoch if not set
|
||||
if (EFI_ERROR (Status)) {
|
||||
ASSERT(Status != EFI_INVALID_PARAMETER);
|
||||
ASSERT(Status != EFI_BUFFER_TOO_SMALL);
|
||||
ASSERT (Status != EFI_INVALID_PARAMETER);
|
||||
ASSERT (Status != EFI_BUFFER_TOO_SMALL);
|
||||
//
|
||||
// The following is intended to produce a compilation error on build
|
||||
// environments where BUILD_EPOCH can not be set from inline shell.
|
||||
@@ -101,11 +101,12 @@ LibGetTime (
|
||||
&EpochSeconds
|
||||
);
|
||||
}
|
||||
Counter = GetPerformanceCounter ();
|
||||
|
||||
Counter = GetPerformanceCounter ();
|
||||
EpochSeconds += DivU64x64Remainder (Counter, Freq, &Remainder);
|
||||
|
||||
// Get the current time zone information from non-volatile storage
|
||||
Size = sizeof (TimeZone);
|
||||
Size = sizeof (TimeZone);
|
||||
Status = EfiGetVariable (
|
||||
(CHAR16 *)mTimeZoneVariableName,
|
||||
&gEfiCallerIdGuid,
|
||||
@@ -115,8 +116,8 @@ LibGetTime (
|
||||
);
|
||||
|
||||
if (EFI_ERROR (Status)) {
|
||||
ASSERT(Status != EFI_INVALID_PARAMETER);
|
||||
ASSERT(Status != EFI_BUFFER_TOO_SMALL);
|
||||
ASSERT (Status != EFI_INVALID_PARAMETER);
|
||||
ASSERT (Status != EFI_BUFFER_TOO_SMALL);
|
||||
|
||||
if (Status != EFI_NOT_FOUND) {
|
||||
return Status;
|
||||
@@ -146,8 +147,9 @@ LibGetTime (
|
||||
Time->TimeZone = TimeZone;
|
||||
|
||||
// Check TimeZone bounds: -1440 to 1440 or 2047
|
||||
if (((Time->TimeZone < -1440) || (Time->TimeZone > 1440))
|
||||
&& (Time->TimeZone != EFI_UNSPECIFIED_TIMEZONE)) {
|
||||
if ( ((Time->TimeZone < -1440) || (Time->TimeZone > 1440))
|
||||
&& (Time->TimeZone != EFI_UNSPECIFIED_TIMEZONE))
|
||||
{
|
||||
Time->TimeZone = EFI_UNSPECIFIED_TIMEZONE;
|
||||
}
|
||||
|
||||
@@ -158,18 +160,18 @@ LibGetTime (
|
||||
}
|
||||
|
||||
// Get the current daylight information from non-volatile storage
|
||||
Size = sizeof (Daylight);
|
||||
Size = sizeof (Daylight);
|
||||
Status = EfiGetVariable (
|
||||
(CHAR16 *)mDaylightVariableName,
|
||||
&gEfiCallerIdGuid,
|
||||
NULL,
|
||||
&Size,
|
||||
(VOID *)&Daylight
|
||||
);
|
||||
);
|
||||
|
||||
if (EFI_ERROR (Status)) {
|
||||
ASSERT(Status != EFI_INVALID_PARAMETER);
|
||||
ASSERT(Status != EFI_BUFFER_TOO_SMALL);
|
||||
ASSERT (Status != EFI_INVALID_PARAMETER);
|
||||
ASSERT (Status != EFI_BUFFER_TOO_SMALL);
|
||||
|
||||
if (Status != EFI_NOT_FOUND) {
|
||||
return Status;
|
||||
@@ -253,14 +255,16 @@ LibSetTime (
|
||||
EpochSeconds = EfiTimeToEpoch (Time);
|
||||
|
||||
// Adjust for the correct time zone, i.e. convert to UTC time zone
|
||||
if ((Time->TimeZone != EFI_UNSPECIFIED_TIMEZONE)
|
||||
&& (EpochSeconds > Time->TimeZone * SEC_PER_MIN)) {
|
||||
if ( (Time->TimeZone != EFI_UNSPECIFIED_TIMEZONE)
|
||||
&& (EpochSeconds > Time->TimeZone * SEC_PER_MIN))
|
||||
{
|
||||
EpochSeconds -= Time->TimeZone * SEC_PER_MIN;
|
||||
}
|
||||
|
||||
// Adjust for the correct period
|
||||
if (((Time->Daylight & EFI_TIME_IN_DAYLIGHT) == EFI_TIME_IN_DAYLIGHT)
|
||||
&& (EpochSeconds > SEC_PER_HOUR)) {
|
||||
if ( ((Time->Daylight & EFI_TIME_IN_DAYLIGHT) == EFI_TIME_IN_DAYLIGHT)
|
||||
&& (EpochSeconds > SEC_PER_HOUR))
|
||||
{
|
||||
// Convert to un-adjusted time, i.e. fall back one hour
|
||||
EpochSeconds -= SEC_PER_HOUR;
|
||||
}
|
||||
@@ -300,9 +304,9 @@ LibSetTime (
|
||||
(CHAR16 *)mDaylightVariableName,
|
||||
&gEfiCallerIdGuid,
|
||||
EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
|
||||
sizeof(Time->Daylight),
|
||||
sizeof (Time->Daylight),
|
||||
(VOID *)&(Time->Daylight)
|
||||
);
|
||||
);
|
||||
if (EFI_ERROR (Status)) {
|
||||
DEBUG ((
|
||||
DEBUG_ERROR,
|
||||
|
Reference in New Issue
Block a user