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:
Michael Kubacki
2021-12-05 14:53:56 -08:00
committed by mergify[bot]
parent 731c67e1d7
commit e7108d0e96
106 changed files with 9242 additions and 7648 deletions

View File

@@ -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);

View File

@@ -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;
}

View File

@@ -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;
}

View File

@@ -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 (
)
{
}

View File

@@ -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;

View File

@@ -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;
}

View File

@@ -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;
}

View File

@@ -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

View File

@@ -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;
}

View File

@@ -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>";
}

View File

@@ -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;
}

View File

@@ -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;
}

View File

@@ -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;
}

View File

@@ -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 */

View File

@@ -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++;
}
}

View File

@@ -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

View File

@@ -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);

View File

@@ -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
));
}

View File

@@ -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;
}

View File

@@ -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));
}

View File

@@ -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)

View File

@@ -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

View File

@@ -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)) {

View File

@@ -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

View File

@@ -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;
}

View File

@@ -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;
}

View File

@@ -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;
}

View File

@@ -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,