/** @file\r
+This file contains the internal functions required to generate a Firmware Volume.\r
\r
-Copyright (c) 2004 - 2010, Intel Corporation. All rights reserved.<BR>\r
+Copyright (c) 2004 - 2014, Intel Corporation. All rights reserved.<BR>\r
+Portions Copyright (c) 2011 - 2013, ARM Ltd. All rights reserved.<BR>\r
This program and the accompanying materials \r
are licensed and made available under the terms and conditions of the BSD License \r
which accompanies this distribution. The full text of the license may be found at \r
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, \r
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. \r
\r
-Module Name:\r
-\r
- GenFvInternalLib.c\r
-\r
-Abstract:\r
-\r
- This file contains the internal functions required to generate a Firmware Volume.\r
-\r
**/\r
\r
//\r
// Include files\r
//\r
-#ifdef __GNUC__\r
+\r
+#if defined(__FreeBSD__)\r
+#include <uuid.h>\r
+#elif defined(__GNUC__)\r
#include <uuid/uuid.h>\r
+#endif\r
+#ifdef __GNUC__\r
#include <sys/stat.h>\r
#endif\r
#include <string.h>\r
EFI_FVB2_ALIGNMENT_64K_STRING, \r
EFI_FVB2_ALIGNMENT_128K_STRING,\r
EFI_FVB2_ALIGNMENT_256K_STRING,\r
- EFI_FVB2_ALIGNMNET_512K_STRING,\r
+ EFI_FVB2_ALIGNMENT_512K_STRING,\r
EFI_FVB2_ALIGNMENT_1M_STRING, \r
EFI_FVB2_ALIGNMENT_2M_STRING, \r
EFI_FVB2_ALIGNMENT_4M_STRING, \r
\r
FV_INFO mFvDataInfo;\r
CAP_INFO mCapDataInfo;\r
+BOOLEAN mIsLargeFfs = FALSE;\r
\r
EFI_PHYSICAL_ADDRESS mFvBaseAddress[0x10];\r
UINT32 mFvBaseAddressNumber = 0;\r
EFI_NOT_FOUND A required string was not found in the INF file.\r
--*/\r
{\r
- CHAR8 Value[_MAX_PATH];\r
+ CHAR8 Value[MAX_LONG_FILE_PATH];\r
UINT64 Value64;\r
UINTN Index;\r
UINTN Number;\r
DebugMsg (NULL, 0, 9, "rebase address", "%s = %s", EFI_FV_BASE_ADDRESS_STRING, Value);\r
\r
FvInfo->BaseAddress = Value64;\r
+ FvInfo->BaseAddressSet = TRUE;\r
}\r
}\r
\r
}\r
}\r
\r
+ //\r
+ // Read weak alignment flag\r
+ //\r
+ Status = FindToken (InfFile, ATTRIBUTES_SECTION_STRING, EFI_FV_WEAK_ALIGNMENT_STRING, 0, Value);\r
+ if (Status == EFI_SUCCESS) {\r
+ if ((strcmp (Value, TRUE_STRING) == 0) || (strcmp (Value, ONE_STRING) == 0)) {\r
+ FvInfo->FvAttributes |= EFI_FVB2_WEAK_ALIGNMENT;\r
+ } else if ((strcmp (Value, FALSE_STRING) != 0) && (strcmp (Value, ZERO_STRING) != 0)) {\r
+ Error (NULL, 0, 2000, "Invalid parameter", "Weak alignment value expected one of TRUE, FALSE, 1 or 0.");\r
+ return EFI_ABORTED;\r
+ }\r
+ }\r
+\r
//\r
// Read block maps\r
//\r
\r
case 0:\r
//\r
- // 8 byte alignment, mini alignment requirement for FFS file. \r
+ // 1 byte alignment\r
//\r
- *Alignment = 3;\r
+ *Alignment = 0;\r
break;\r
\r
case 1:\r
IN OUT MEMORY_FILE *FvImage,\r
IN UINT32 DataAlignment,\r
IN VOID *FvEnd,\r
- IN EFI_FIRMWARE_VOLUME_EXT_HEADER *ExtHeader\r
+ IN EFI_FIRMWARE_VOLUME_EXT_HEADER *ExtHeader,\r
+ IN UINT32 NextFfsSize\r
)\r
/*++\r
\r
{\r
EFI_FFS_FILE_HEADER *PadFile;\r
UINTN PadFileSize;\r
+ UINT32 NextFfsHeaderSize;\r
+ UINT32 CurFfsHeaderSize;\r
\r
+ CurFfsHeaderSize = sizeof (EFI_FFS_FILE_HEADER);\r
//\r
// Verify input parameters.\r
//\r
return EFI_INVALID_PARAMETER;\r
}\r
\r
- //\r
- // Check if a pad file is necessary\r
- //\r
- if ((ExtHeader == NULL) && (((UINTN) FvImage->CurrentFilePointer - (UINTN) FvImage->FileImage + sizeof (EFI_FFS_FILE_HEADER)) % DataAlignment == 0)) {\r
- return EFI_SUCCESS;\r
- }\r
-\r
//\r
// Calculate the pad file size\r
//\r
- //\r
- // This is the earliest possible valid offset (current plus pad file header\r
- // plus the next file header)\r
- //\r
- PadFileSize = (UINTN) FvImage->CurrentFilePointer - (UINTN) FvImage->FileImage + (sizeof (EFI_FFS_FILE_HEADER) * 2);\r
-\r
- //\r
- // Add whatever it takes to get to the next aligned address\r
- //\r
- while ((PadFileSize % DataAlignment) != 0) {\r
- PadFileSize++;\r
- }\r
- //\r
- // Subtract the next file header size\r
- //\r
- PadFileSize -= sizeof (EFI_FFS_FILE_HEADER);\r
\r
- //\r
- // Subtract the starting offset to get size\r
- //\r
- PadFileSize -= (UINTN) FvImage->CurrentFilePointer - (UINTN) FvImage->FileImage;\r
- \r
//\r
// Append extension header size\r
//\r
if (ExtHeader != NULL) {\r
- PadFileSize = PadFileSize + ExtHeader->ExtHeaderSize;\r
+ PadFileSize = ExtHeader->ExtHeaderSize;\r
+ if (PadFileSize + sizeof (EFI_FFS_FILE_HEADER) >= MAX_FFS_SIZE) {\r
+ CurFfsHeaderSize = sizeof (EFI_FFS_FILE_HEADER2);\r
+ }\r
+ PadFileSize += CurFfsHeaderSize;\r
+ } else {\r
+ NextFfsHeaderSize = sizeof (EFI_FFS_FILE_HEADER);\r
+ if (NextFfsSize >= MAX_FFS_SIZE) {\r
+ NextFfsHeaderSize = sizeof (EFI_FFS_FILE_HEADER2);\r
+ }\r
+ //\r
+ // Check if a pad file is necessary\r
+ //\r
+ if (((UINTN) FvImage->CurrentFilePointer - (UINTN) FvImage->FileImage + NextFfsHeaderSize) % DataAlignment == 0) {\r
+ return EFI_SUCCESS;\r
+ }\r
+ PadFileSize = (UINTN) FvImage->CurrentFilePointer - (UINTN) FvImage->FileImage + sizeof (EFI_FFS_FILE_HEADER) + NextFfsHeaderSize;\r
+ //\r
+ // Add whatever it takes to get to the next aligned address\r
+ //\r
+ while ((PadFileSize % DataAlignment) != 0) {\r
+ PadFileSize++;\r
+ }\r
+ //\r
+ // Subtract the next file header size\r
+ //\r
+ PadFileSize -= NextFfsHeaderSize;\r
+ //\r
+ // Subtract the starting offset to get size\r
+ //\r
+ PadFileSize -= (UINTN) FvImage->CurrentFilePointer - (UINTN) FvImage->FileImage;\r
}\r
\r
//\r
//\r
// Write pad file size (calculated size minus next file header size)\r
//\r
- PadFile->Size[0] = (UINT8) (PadFileSize & 0xFF);\r
- PadFile->Size[1] = (UINT8) ((PadFileSize >> 8) & 0xFF);\r
- PadFile->Size[2] = (UINT8) ((PadFileSize >> 16) & 0xFF);\r
+ if (PadFileSize >= MAX_FFS_SIZE) {\r
+ memset(PadFile->Size, 0, sizeof(UINT8) * 3);\r
+ ((EFI_FFS_FILE_HEADER2 *)PadFile)->ExtendedSize = PadFileSize;\r
+ PadFile->Attributes |= FFS_ATTRIB_LARGE_FILE;\r
+ } else {\r
+ PadFile->Size[0] = (UINT8) (PadFileSize & 0xFF);\r
+ PadFile->Size[1] = (UINT8) ((PadFileSize >> 8) & 0xFF);\r
+ PadFile->Size[2] = (UINT8) ((PadFileSize >> 16) & 0xFF);\r
+ }\r
\r
//\r
// Fill in checksums and state, they must be 0 for checksumming.\r
PadFile->IntegrityCheck.Checksum.Header = 0;\r
PadFile->IntegrityCheck.Checksum.File = 0;\r
PadFile->State = 0;\r
- PadFile->IntegrityCheck.Checksum.Header = CalculateChecksum8 ((UINT8 *) PadFile, sizeof (EFI_FFS_FILE_HEADER));\r
+ PadFile->IntegrityCheck.Checksum.Header = CalculateChecksum8 ((UINT8 *) PadFile, CurFfsHeaderSize);\r
PadFile->IntegrityCheck.Checksum.File = FFS_FIXED_CHECKSUM;\r
\r
PadFile->State = EFI_FILE_HEADER_CONSTRUCTION | EFI_FILE_HEADER_VALID | EFI_FILE_DATA_VALID;\r
//\r
// Copy Fv Extension Header and Set Fv Extension header offset\r
//\r
- memcpy (PadFile + 1, ExtHeader, ExtHeader->ExtHeaderSize);\r
- ((EFI_FIRMWARE_VOLUME_HEADER *) FvImage->FileImage)->ExtHeaderOffset = (UINT16) ((UINTN) (PadFile + 1) - (UINTN) FvImage->FileImage);\r
+ memcpy ((UINT8 *)PadFile + CurFfsHeaderSize, ExtHeader, ExtHeader->ExtHeaderSize);\r
+ ((EFI_FIRMWARE_VOLUME_HEADER *) FvImage->FileImage)->ExtHeaderOffset = (UINT16) ((UINTN) ((UINT8 *)PadFile + CurFfsHeaderSize) - (UINTN) FvImage->FileImage);\r
//\r
// Make next file start at QWord Boundry\r
//\r
\r
--*/\r
{\r
- CHAR8 PeMapFileName [_MAX_PATH];\r
+ CHAR8 PeMapFileName [MAX_LONG_FILE_PATH];\r
CHAR8 *Cptr, *Cptr2;\r
CHAR8 FileGuidName [MAX_LINE_LEN];\r
FILE *PeMapFile;\r
//\r
// Open PeMapFile\r
//\r
- PeMapFile = fopen (PeMapFileName, "r");\r
+ PeMapFile = fopen (LongFilePath (PeMapFileName), "r");\r
if (PeMapFile == NULL) {\r
// fprintf (stdout, "can't open %s file to reading\n", PeMapFileName);\r
return EFI_ABORTED;\r
//\r
// Read the file to add\r
//\r
- NewFile = fopen (FvInfo->FvFiles[Index], "rb");\r
+ NewFile = fopen (LongFilePath (FvInfo->FvFiles[Index]), "rb");\r
\r
if (NewFile == NULL) {\r
Error (NULL, 0, 0001, "Error opening file", FvInfo->FvFiles[Index]);\r
Status = VerifyFfsFile ((EFI_FFS_FILE_HEADER *)FileBuffer);\r
if (EFI_ERROR (Status)) {\r
free (FileBuffer);\r
- Error (NULL, 0, 3000, "Invalid", "%s is a FFS file.", FvInfo->FvFiles[Index]);\r
+ Error (NULL, 0, 3000, "Invalid", "%s is not a valid FFS file.", FvInfo->FvFiles[Index]);\r
return EFI_INVALID_PARAMETER;\r
}\r
\r
//\r
// Sanity check. The file MUST align appropriately\r
//\r
- if (((UINTN) *VtfFileImage + sizeof (EFI_FFS_FILE_HEADER) - (UINTN) FvImage->FileImage) % (1 << CurrentFileAlignment)) {\r
+ if (((UINTN) *VtfFileImage + GetFfsHeaderLength((EFI_FFS_FILE_HEADER *)FileBuffer) - (UINTN) FvImage->FileImage) % (1 << CurrentFileAlignment)) {\r
Error (NULL, 0, 3000, "Invalid", "VTF file cannot be aligned on a %u-byte boundary.", (unsigned) (1 << CurrentFileAlignment));\r
free (FileBuffer);\r
return EFI_ABORTED;\r
//\r
// Add pad file if necessary\r
//\r
- Status = AddPadFile (FvImage, 1 << CurrentFileAlignment, *VtfFileImage, NULL);\r
+ Status = AddPadFile (FvImage, 1 << CurrentFileAlignment, *VtfFileImage, NULL, FileSize);\r
if (EFI_ERROR (Status)) {\r
Error (NULL, 0, 4002, "Resource", "FV space is full, could not add pad file for data alignment property.");\r
free (FileBuffer);\r
{\r
EFI_FFS_FILE_HEADER *PadFile;\r
UINTN FileSize;\r
+ UINT32 FfsHeaderSize;\r
\r
//\r
// If there is no VTF or the VTF naturally follows the previous file without a\r
// FileSize includes the EFI_FFS_FILE_HEADER\r
//\r
FileSize = (UINTN) VtfFileImage - (UINTN) FvImage->CurrentFilePointer;\r
- PadFile->Size[0] = (UINT8) (FileSize & 0x000000FF);\r
- PadFile->Size[1] = (UINT8) ((FileSize & 0x0000FF00) >> 8);\r
- PadFile->Size[2] = (UINT8) ((FileSize & 0x00FF0000) >> 16);\r
+ if (FileSize >= MAX_FFS_SIZE) {\r
+ PadFile->Attributes |= FFS_ATTRIB_LARGE_FILE;\r
+ memset(PadFile->Size, 0, sizeof(UINT8) * 3);\r
+ ((EFI_FFS_FILE_HEADER2 *)PadFile)->ExtendedSize = FileSize;\r
+ FfsHeaderSize = sizeof(EFI_FFS_FILE_HEADER2);\r
+ mIsLargeFfs = TRUE;\r
+ } else {\r
+ PadFile->Size[0] = (UINT8) (FileSize & 0x000000FF);\r
+ PadFile->Size[1] = (UINT8) ((FileSize & 0x0000FF00) >> 8);\r
+ PadFile->Size[2] = (UINT8) ((FileSize & 0x00FF0000) >> 16);\r
+ FfsHeaderSize = sizeof(EFI_FFS_FILE_HEADER);\r
+ }\r
\r
//\r
// Fill in checksums and state, must be zero during checksum calculation.\r
PadFile->IntegrityCheck.Checksum.Header = 0;\r
PadFile->IntegrityCheck.Checksum.File = 0;\r
PadFile->State = 0;\r
- PadFile->IntegrityCheck.Checksum.Header = CalculateChecksum8 ((UINT8 *) PadFile, sizeof (EFI_FFS_FILE_HEADER));\r
+ PadFile->IntegrityCheck.Checksum.Header = CalculateChecksum8 ((UINT8 *) PadFile, FfsHeaderSize);\r
PadFile->IntegrityCheck.Checksum.File = FFS_FIXED_CHECKSUM;\r
\r
PadFile->State = EFI_FILE_HEADER_CONSTRUCTION | EFI_FILE_HEADER_VALID | EFI_FILE_DATA_VALID;\r
UINT64 FitAddress;\r
FIT_TABLE *FitTablePtr;\r
BOOLEAN Vtf0Detected;\r
+ UINT32 FfsHeaderSize;\r
+ UINT32 SecHeaderSize;\r
\r
//\r
// Verify input parameters\r
return EFI_ABORTED;\r
}\r
\r
+ SecHeaderSize = GetSectionHeaderLength(Pe32Section.CommonHeader);\r
Status = GetPe32Info (\r
- (VOID *) ((UINTN) Pe32Section.Pe32Section + sizeof (EFI_SECTION_PE32)),\r
+ (VOID *) ((UINTN) Pe32Section.Pe32Section + SecHeaderSize),\r
&EntryPoint,\r
&BaseOfCode,\r
&MachineType\r
// Physical address is FV base + offset of PE32 + offset of the entry point\r
//\r
SecCorePhysicalAddress = FvInfo->BaseAddress;\r
- SecCorePhysicalAddress += (UINTN) Pe32Section.Pe32Section + sizeof (EFI_SECTION_PE32) - (UINTN) FvImage->FileImage;\r
+ SecCorePhysicalAddress += (UINTN) Pe32Section.Pe32Section + SecHeaderSize - (UINTN) FvImage->FileImage;\r
SecCorePhysicalAddress += EntryPoint;\r
DebugMsg (NULL, 0, 9, "SecCore physical entry point address", "Address = 0x%llX", (unsigned long long) SecCorePhysicalAddress); \r
\r
return EFI_ABORTED;\r
}\r
\r
+ SecHeaderSize = GetSectionHeaderLength(Pe32Section.CommonHeader);\r
Status = GetPe32Info (\r
- (VOID *) ((UINTN) Pe32Section.Pe32Section + sizeof (EFI_SECTION_PE32)),\r
+ (VOID *) ((UINTN) Pe32Section.Pe32Section + SecHeaderSize),\r
&EntryPoint,\r
&BaseOfCode,\r
&MachineType\r
// Physical address is FV base + offset of PE32 + offset of the entry point\r
//\r
PeiCorePhysicalAddress = FvInfo->BaseAddress;\r
- PeiCorePhysicalAddress += (UINTN) Pe32Section.Pe32Section + sizeof (EFI_SECTION_PE32) - (UINTN) FvImage->FileImage;\r
+ PeiCorePhysicalAddress += (UINTN) Pe32Section.Pe32Section + SecHeaderSize - (UINTN) FvImage->FileImage;\r
PeiCorePhysicalAddress += EntryPoint;\r
DebugMsg (NULL, 0, 9, "PeiCore physical entry point address", "Address = 0x%llX", (unsigned long long) PeiCorePhysicalAddress);\r
\r
//\r
Status = FindApResetVectorPosition (FvImage, &BytePointer);\r
if (EFI_ERROR (Status)) {\r
- Error (NULL, 0, 3000, "Invalid", "Cannot find the appropriate location in FvImage to add Ap reset vector!");\r
+ Error (NULL, 0, 3000, "Invalid", "FV image does not have enough space to place AP reset vector. The FV image needs to reserve at least 4KB of unused space.");\r
return EFI_ABORTED;\r
}\r
}\r
// Since the ARM reset vector is in the FV Header you really don't need a\r
// Volume Top File, but if you have one for some reason don't crash...\r
//\r
+ } else if (MachineType == EFI_IMAGE_MACHINE_AARCH64) {\r
+ //\r
+ // Since the AArch64 reset vector is in the FV Header you really don't need a\r
+ // Volume Top File, but if you have one for some reason don't crash...\r
+ //\r
} else {\r
Error (NULL, 0, 3000, "Invalid", "machine type=0x%X in PEI core.", MachineType);\r
return EFI_ABORTED;\r
VtfFile->IntegrityCheck.Checksum.File = 0;\r
VtfFile->State = 0;\r
if (VtfFile->Attributes & FFS_ATTRIB_CHECKSUM) {\r
+ FfsHeaderSize = GetFfsHeaderLength(VtfFile);\r
VtfFile->IntegrityCheck.Checksum.File = CalculateChecksum8 (\r
- (UINT8 *) (VtfFile + 1),\r
- GetLength (VtfFile->Size) - sizeof (EFI_FFS_FILE_HEADER)\r
+ (UINT8 *) ((UINT8 *)VtfFile + FfsHeaderSize),\r
+ GetFfsFileLength (VtfFile) - FfsHeaderSize\r
);\r
} else {\r
VtfFile->IntegrityCheck.Checksum.File = FFS_FIXED_CHECKSUM;\r
This parses the FV looking for SEC and patches that address into the \r
beginning of the FV header.\r
\r
- For ARM the reset vector is at 0x00000000 or 0xFFFF0000.\r
+ For ARM32 the reset vector is at 0x00000000 or 0xFFFF0000.\r
+ For AArch64 the reset vector is at 0x00000000.\r
+\r
This would commonly map to the first entry in the ROM. \r
- ARM Exceptions:\r
+ ARM32 Exceptions:\r
Reset +0 \r
Undefined +4\r
SWI +8\r
2) Reset vector is data bytes FDF file and that code branches to reset vector \r
in the beginning of the FV (fixed size offset).\r
\r
-\r
Need to have the jump for the reset vector at location zero.\r
We also need to store the address or PEI (if it exists).\r
We stub out a return from interrupt in case the debugger \r
- is using SWI.\r
+ is using SWI (not done for AArch64, not enough space in struct).\r
The optional entry to the common exception handler is \r
to support full featured exception handling from ROM and is currently \r
not support by this tool.\r
UINT16 MachineType;\r
EFI_PHYSICAL_ADDRESS PeiCorePhysicalAddress;\r
EFI_PHYSICAL_ADDRESS SecCorePhysicalAddress;\r
- INT32 ResetVector[4]; // 0 - is branch relative to SEC entry point\r
+ INT32 ResetVector[4]; // ARM32:\r
+ // 0 - is branch relative to SEC entry point\r
// 1 - PEI Entry Point\r
// 2 - movs pc,lr for a SWI handler\r
// 3 - Place holder for Common Exception Handler\r
+ // AArch64: Used as UINT64 ResetVector[2]\r
+ // 0 - is branch relative to SEC entry point\r
+ // 1 - PEI Entry Point\r
\r
//\r
// Verify input parameters\r
}\r
\r
Status = GetPe32Info (\r
- (VOID *) ((UINTN) Pe32Section.Pe32Section + sizeof (EFI_SECTION_PE32)),\r
+ (VOID *) ((UINTN) Pe32Section.Pe32Section + GetSectionHeaderLength(Pe32Section.CommonHeader)),\r
&EntryPoint,\r
&BaseOfCode,\r
&MachineType\r
// Physical address is FV base + offset of PE32 + offset of the entry point\r
//\r
PeiCorePhysicalAddress = FvInfo->BaseAddress;\r
- PeiCorePhysicalAddress += (UINTN) Pe32Section.Pe32Section + sizeof (EFI_SECTION_PE32) - (UINTN) FvImage->FileImage;\r
+ PeiCorePhysicalAddress += (UINTN) Pe32Section.Pe32Section + GetSectionHeaderLength(Pe32Section.CommonHeader) - (UINTN) FvImage->FileImage;\r
PeiCorePhysicalAddress += EntryPoint;\r
DebugMsg (NULL, 0, 9, "PeiCore physical entry point address", "Address = 0x%llX", (unsigned long long) PeiCorePhysicalAddress);\r
\r
- if (MachineType == EFI_IMAGE_MACHINE_ARMT) {\r
+ if (MachineType == EFI_IMAGE_MACHINE_ARMT || MachineType == EFI_IMAGE_MACHINE_AARCH64) {\r
memset (ResetVector, 0, sizeof (ResetVector));\r
// Address of PEI Core, if we have one\r
ResetVector[1] = (UINT32)PeiCorePhysicalAddress;\r
}\r
\r
Status = GetPe32Info (\r
- (VOID *) ((UINTN) Pe32Section.Pe32Section + sizeof (EFI_SECTION_PE32)),\r
+ (VOID *) ((UINTN) Pe32Section.Pe32Section + GetSectionHeaderLength(Pe32Section.CommonHeader)),\r
&EntryPoint,\r
&BaseOfCode,\r
&MachineType\r
return EFI_ABORTED;\r
}\r
\r
- if (MachineType != EFI_IMAGE_MACHINE_ARMT) {\r
+ if ((MachineType != EFI_IMAGE_MACHINE_ARMT) && (MachineType != EFI_IMAGE_MACHINE_AARCH64)) {\r
//\r
// If SEC is not ARM we have nothing to do\r
//\r
// Physical address is FV base + offset of PE32 + offset of the entry point\r
//\r
SecCorePhysicalAddress = FvInfo->BaseAddress;\r
- SecCorePhysicalAddress += (UINTN) Pe32Section.Pe32Section + sizeof (EFI_SECTION_PE32) - (UINTN) FvImage->FileImage;\r
+ SecCorePhysicalAddress += (UINTN) Pe32Section.Pe32Section + GetSectionHeaderLength(Pe32Section.CommonHeader) - (UINTN) FvImage->FileImage;\r
SecCorePhysicalAddress += EntryPoint;\r
DebugMsg (NULL, 0, 9, "SecCore physical entry point address", "Address = 0x%llX", (unsigned long long) SecCorePhysicalAddress); \r
\r
}\r
\r
Status = GetPe32Info (\r
- (VOID *) ((UINTN) Pe32Section.Pe32Section + sizeof (EFI_SECTION_PE32)),\r
+ (VOID *) ((UINTN) Pe32Section.Pe32Section + GetSectionHeaderLength(Pe32Section.CommonHeader)),\r
&EntryPoint,\r
&BaseOfCode,\r
&MachineType\r
// Physical address is FV base + offset of PE32 + offset of the entry point\r
//\r
PeiCorePhysicalAddress = FvInfo->BaseAddress;\r
- PeiCorePhysicalAddress += (UINTN) Pe32Section.Pe32Section + sizeof (EFI_SECTION_PE32) - (UINTN) FvImage->FileImage;\r
+ PeiCorePhysicalAddress += (UINTN) Pe32Section.Pe32Section + GetSectionHeaderLength(Pe32Section.CommonHeader) - (UINTN) FvImage->FileImage;\r
PeiCorePhysicalAddress += EntryPoint;\r
DebugMsg (NULL, 0, 9, "PeiCore physical entry point address", "Address = 0x%llX", (unsigned long long) PeiCorePhysicalAddress);\r
}\r
\r
+ if (MachineType == EFI_IMAGE_MACHINE_ARMT) {\r
+ // B SecEntryPoint - signed_immed_24 part +/-32MB offset\r
+ // on ARM, the PC is always 8 ahead, so we're not really jumping from the base address, but from base address + 8\r
+ ResetVector[0] = (INT32)(SecCorePhysicalAddress - FvInfo->BaseAddress - 8) >> 2;\r
+\r
+ if (ResetVector[0] > 0x00FFFFFF) {\r
+ Error (NULL, 0, 3000, "Invalid", "SEC Entry point must be within 32MB of the start of the FV");\r
+ return EFI_ABORTED;\r
+ }\r
\r
- // B SecEntryPoint - signed_immed_24 part +/-32MB offset\r
- // on ARM, the PC is always 8 ahead, so we're not really jumping from the base address, but from base address + 8\r
- ResetVector[0] = (INT32)(SecCorePhysicalAddress - FvInfo->BaseAddress - 8) >> 2;\r
- \r
- if (ResetVector[0] > 0x00FFFFFF) {\r
- Error (NULL, 0, 3000, "Invalid", "SEC Entry point must be within 32MB of the start of the FV");\r
- return EFI_ABORTED; \r
- }\r
- \r
- // Add opcode for an uncondional branch with no link. AKA B SecEntryPoint\r
- ResetVector[0] |= 0xEB000000;\r
+ // Add opcode for an uncondional branch with no link. AKA B SecEntryPoint\r
+ ResetVector[0] |= 0xEB000000;\r
\r
\r
- // Address of PEI Core, if we have one\r
- ResetVector[1] = (UINT32)PeiCorePhysicalAddress;\r
+ // Address of PEI Core, if we have one\r
+ ResetVector[1] = (UINT32)PeiCorePhysicalAddress;\r
\r
- // SWI handler movs pc,lr. Just in case a debugger uses SWI\r
- ResetVector[2] = 0xE1B0F07E;\r
+ // SWI handler movs pc,lr. Just in case a debugger uses SWI\r
+ ResetVector[2] = 0xE1B0F07E;\r
\r
- // Place holder to support a common interrupt handler from ROM. \r
- // Currently not suppprted. For this to be used the reset vector would not be in this FV\r
- // and the exception vectors would be hard coded in the ROM and just through this address \r
- // to find a common handler in the a module in the FV.\r
- ResetVector[3] = 0;\r
+ // Place holder to support a common interrupt handler from ROM.\r
+ // Currently not suppprted. For this to be used the reset vector would not be in this FV\r
+ // and the exception vectors would be hard coded in the ROM and just through this address\r
+ // to find a common handler in the a module in the FV.\r
+ ResetVector[3] = 0;\r
+ } else if (MachineType == EFI_IMAGE_MACHINE_AARCH64) {\r
+\r
+ /* NOTE:\r
+ ARMT above has an entry in ResetVector[2] for SWI. The way we are using the ResetVector\r
+ array at the moment, for AArch64, does not allow us space for this as the header only\r
+ allows for a fixed amount of bytes at the start. If we are sure that UEFI will live\r
+ within the first 4GB of addressable RAM we could potensioally adopt the same ResetVector\r
+ layout as above. But for the moment we replace the four 32bit vectors with two 64bit\r
+ vectors in the same area of the Image heasder. This allows UEFI to start from a 64bit\r
+ base.\r
+ */\r
+\r
+ ((UINT64*)ResetVector)[0] = (UINT64)(SecCorePhysicalAddress - FvInfo->BaseAddress) >> 2;\r
+\r
+ // B SecEntryPoint - signed_immed_26 part +/-128MB offset\r
+ if ( ((UINT64*)ResetVector)[0] > 0x03FFFFFF) {\r
+ Error (NULL, 0, 3000, "Invalid", "SEC Entry point must be within 128MB of the start of the FV");\r
+ return EFI_ABORTED;\r
+ }\r
+ // Add opcode for an uncondional branch with no link. AKA B SecEntryPoint\r
+ ((UINT64*)ResetVector)[0] |= 0x14000000;\r
+\r
+ // Address of PEI Core, if we have one\r
+ ((UINT64*)ResetVector)[1] = (UINT64)PeiCorePhysicalAddress;\r
+\r
+ } else {\r
+ Error (NULL, 0, 3000, "Invalid", "Unknown ARM machine type");\r
+ return EFI_ABORTED;\r
+ }\r
\r
//\r
// Copy to the beginning of the FV \r
//\r
// Verify machine type is supported\r
//\r
- if (*MachineType != EFI_IMAGE_MACHINE_IA32 && *MachineType != EFI_IMAGE_MACHINE_IA64 && *MachineType != EFI_IMAGE_MACHINE_X64 && *MachineType != EFI_IMAGE_MACHINE_EBC && \r
- *MachineType != EFI_IMAGE_MACHINE_ARMT) {\r
+ if ((*MachineType != EFI_IMAGE_MACHINE_IA32) && (*MachineType != EFI_IMAGE_MACHINE_IA64) && (*MachineType != EFI_IMAGE_MACHINE_X64) && (*MachineType != EFI_IMAGE_MACHINE_EBC) && \r
+ (*MachineType != EFI_IMAGE_MACHINE_ARMT) && (*MachineType != EFI_IMAGE_MACHINE_AARCH64)) {\r
Error (NULL, 0, 3000, "Invalid", "Unrecognized machine type in the PE32 file.");\r
return EFI_UNSUPPORTED;\r
}\r
UINT8 *FvImage;\r
UINTN FvImageSize;\r
FILE *FvFile;\r
- CHAR8 FvMapName [_MAX_PATH];\r
+ CHAR8 FvMapName [MAX_LONG_FILE_PATH];\r
FILE *FvMapFile;\r
EFI_FIRMWARE_VOLUME_EXT_HEADER *FvExtHeader;\r
FILE *FvExtHeaderFile;\r
UINTN FileSize;\r
- CHAR8 FvReportName[_MAX_PATH];\r
+ CHAR8 FvReportName[MAX_LONG_FILE_PATH];\r
FILE *FvReportFile;\r
\r
FvBufferHeader = NULL;\r
//\r
// Open the FV Extension Header file\r
//\r
- FvExtHeaderFile = fopen (mFvDataInfo.FvExtHeaderFile, "rb");\r
+ FvExtHeaderFile = fopen (LongFilePath (mFvDataInfo.FvExtHeaderFile), "rb");\r
\r
//\r
// Get the file size\r
mFvDataInfo.FvNameGuid.Data4[7]);\r
}\r
\r
- if (CompareGuid (&mFvDataInfo.FvFileSystemGuid, &mEfiFirmwareFileSystem2Guid) == 0) {\r
+ if (CompareGuid (&mFvDataInfo.FvFileSystemGuid, &mEfiFirmwareFileSystem2Guid) == 0 ||\r
+ CompareGuid (&mFvDataInfo.FvFileSystemGuid, &mEfiFirmwareFileSystem3Guid) == 0) {\r
mFvDataInfo.IsPiFvImage = TRUE;\r
}\r
\r
//\r
// Open FvMap file\r
//\r
- FvMapFile = fopen (FvMapName, "w");\r
+ FvMapFile = fopen (LongFilePath (FvMapName), "w");\r
if (FvMapFile == NULL) {\r
Error (NULL, 0, 0001, "Error opening file", FvMapName);\r
return EFI_ABORTED;\r
//\r
// Open FvReport file\r
//\r
- FvReportFile = fopen(FvReportName, "w");\r
+ FvReportFile = fopen (LongFilePath (FvReportName), "w");\r
if (FvReportFile == NULL) {\r
Error (NULL, 0, 0001, "Error opening file", FvReportName);\r
return EFI_ABORTED;\r
//\r
// Add FV Extended Header contents to the FV as a PAD file\r
//\r
- AddPadFile (&FvImageMemoryFile, 4, VtfFileImage, FvExtHeader);\r
+ AddPadFile (&FvImageMemoryFile, 4, VtfFileImage, FvExtHeader, 0);\r
\r
//\r
// Fv Extension header change update Fv Header Check sum\r
//\r
// Update FV Alignment attribute to the largest alignment of all the FFS files in the FV\r
//\r
- if ((((FvHeader->Attributes & EFI_FVB2_ALIGNMENT) >> 16)) < MaxFfsAlignment) {\r
+ if (((FvHeader->Attributes & EFI_FVB2_WEAK_ALIGNMENT) != EFI_FVB2_WEAK_ALIGNMENT) &&\r
+ (((FvHeader->Attributes & EFI_FVB2_ALIGNMENT) >> 16)) < MaxFfsAlignment) {\r
FvHeader->Attributes = ((MaxFfsAlignment << 16) | (FvHeader->Attributes & 0xFFFF));\r
//\r
// Update Checksum for FvHeader\r
FvHeader->Checksum = CalculateChecksum16 ((UINT16 *) FvHeader, FvHeader->HeaderLength / sizeof (UINT16));\r
}\r
\r
+ //\r
+ // If there are large FFS in FV, the file system GUID should set to system 3 GUID.\r
+ //\r
+ if (mIsLargeFfs && CompareGuid (&FvHeader->FileSystemGuid, &mEfiFirmwareFileSystem2Guid) == 0) {\r
+ memcpy (&FvHeader->FileSystemGuid, &mEfiFirmwareFileSystem3Guid, sizeof (EFI_GUID));\r
+ FvHeader->Checksum = 0;\r
+ FvHeader->Checksum = CalculateChecksum16 ((UINT16 *) FvHeader, FvHeader->HeaderLength / sizeof (UINT16));\r
+ }\r
+\r
WriteFile: \r
//\r
// Write fv file\r
//\r
- FvFile = fopen (FvFileName, "wb");\r
+ FvFile = fopen (LongFilePath (FvFileName), "wb");\r
if (FvFile == NULL) {\r
Error (NULL, 0, 0001, "Error opening file", FvFileName);\r
Status = EFI_ABORTED;\r
UINTN FfsFileSize;\r
UINTN FvExtendHeaderSize;\r
UINT32 FfsAlignment;\r
+ UINT32 FfsHeaderSize;\r
EFI_FFS_FILE_HEADER FfsHeader;\r
BOOLEAN VtfFileFlag;\r
UINTN VtfFileSize;\r
// Calculate PI extension header\r
//\r
if (mFvDataInfo.FvExtHeaderFile[0] != '\0') {\r
- fpin = fopen (mFvDataInfo.FvExtHeaderFile, "rb");\r
+ fpin = fopen (LongFilePath (mFvDataInfo.FvExtHeaderFile), "rb");\r
if (fpin == NULL) {\r
Error (NULL, 0, 0001, "Error opening file", mFvDataInfo.FvExtHeaderFile);\r
return EFI_ABORTED;\r
}\r
FvExtendHeaderSize = _filelength (fileno (fpin));\r
fclose (fpin);\r
- CurrentOffset += sizeof (EFI_FFS_FILE_HEADER) + FvExtendHeaderSize;\r
+ if (sizeof (EFI_FFS_FILE_HEADER) + FvExtendHeaderSize >= MAX_FFS_SIZE) {\r
+ CurrentOffset += sizeof (EFI_FFS_FILE_HEADER2) + FvExtendHeaderSize;\r
+ mIsLargeFfs = TRUE;\r
+ } else {\r
+ CurrentOffset += sizeof (EFI_FFS_FILE_HEADER) + FvExtendHeaderSize;\r
+ }\r
CurrentOffset = (CurrentOffset + 7) & (~7);\r
} else if (mFvDataInfo.FvNameGuidSet) {\r
CurrentOffset += sizeof (EFI_FFS_FILE_HEADER) + sizeof (EFI_FIRMWARE_VOLUME_EXT_HEADER);\r
// Open FFS file\r
//\r
fpin = NULL;\r
- fpin = fopen (FvInfoPtr->FvFiles[Index], "rb");\r
+ fpin = fopen (LongFilePath (FvInfoPtr->FvFiles[Index]), "rb");\r
if (fpin == NULL) {\r
Error (NULL, 0, 0001, "Error opening file", FvInfoPtr->FvFiles[Index]);\r
return EFI_ABORTED;\r
// Get the file size\r
//\r
FfsFileSize = _filelength (fileno (fpin));\r
+ if (FfsFileSize >= MAX_FFS_SIZE) {\r
+ FfsHeaderSize = sizeof(EFI_FFS_FILE_HEADER2);\r
+ mIsLargeFfs = TRUE;\r
+ } else {\r
+ FfsHeaderSize = sizeof(EFI_FFS_FILE_HEADER);\r
+ }\r
//\r
// Read Ffs File header\r
//\r
//\r
// Add Pad file\r
//\r
- if (((CurrentOffset + sizeof (EFI_FFS_FILE_HEADER)) % FfsAlignment) != 0) {\r
- CurrentOffset = (CurrentOffset + sizeof (EFI_FFS_FILE_HEADER) * 2 + FfsAlignment - 1) & ~(FfsAlignment - 1);\r
- CurrentOffset -= sizeof (EFI_FFS_FILE_HEADER);\r
+ if (((CurrentOffset + FfsHeaderSize) % FfsAlignment) != 0) {\r
+ //\r
+ // Only EFI_FFS_FILE_HEADER is needed for a pad section.\r
+ //\r
+ CurrentOffset = (CurrentOffset + FfsHeaderSize + sizeof(EFI_FFS_FILE_HEADER) + FfsAlignment - 1) & ~(FfsAlignment - 1);\r
+ CurrentOffset -= FfsHeaderSize;\r
}\r
}\r
\r
if (EFI_ERROR (Status)) {\r
break;\r
}\r
- SubFvImageHeader = (EFI_FIRMWARE_VOLUME_HEADER *) ((UINT8 *) SubFvSection.FVImageSection + sizeof (EFI_FIRMWARE_VOLUME_IMAGE_SECTION));\r
+ SubFvImageHeader = (EFI_FIRMWARE_VOLUME_HEADER *) ((UINT8 *) SubFvSection.FVImageSection + GetSectionHeaderLength(SubFvSection.FVImageSection));\r
//\r
// Rebase on Flash\r
//\r
PE_COFF_LOADER_IMAGE_CONTEXT OrigImageContext; \r
EFI_PHYSICAL_ADDRESS XipBase;\r
EFI_PHYSICAL_ADDRESS NewPe32BaseAddress;\r
- EFI_PHYSICAL_ADDRESS *BaseToUpdate;\r
UINTN Index;\r
EFI_FILE_SECTION_POINTER CurrentPe32Section;\r
EFI_FFS_FILE_STATE SavedState;\r
EFI_TE_IMAGE_HEADER *TEImageHeader;\r
UINT8 *MemoryImagePointer;\r
EFI_IMAGE_SECTION_HEADER *SectionHeader;\r
- CHAR8 PeFileName [_MAX_PATH];\r
+ CHAR8 PeFileName [MAX_LONG_FILE_PATH];\r
CHAR8 *Cptr;\r
FILE *PeFile;\r
UINT8 *PeFileBuffer;\r
UINT32 PeFileSize;\r
CHAR8 *PdbPointer;\r
+ UINT32 FfsHeaderSize;\r
+ UINT32 CurSecHdrSize;\r
\r
Index = 0; \r
MemoryImagePointer = NULL;\r
- BaseToUpdate = NULL;\r
TEImageHeader = NULL;\r
ImgHdr = NULL;\r
SectionHeader = NULL;\r
PeFileBuffer = NULL;\r
\r
//\r
- // Don't need to relocate image when BaseAddress is not set.\r
+ // Don't need to relocate image when BaseAddress is zero and no ForceRebase Flag specified.\r
//\r
- if (FvInfo->BaseAddress == 0) {\r
+ if ((FvInfo->BaseAddress == 0) && (FvInfo->ForceRebase == -1)) {\r
return EFI_SUCCESS;\r
}\r
+ \r
+ //\r
+ // If ForceRebase Flag specified to FALSE, will always not take rebase action.\r
+ //\r
+ if (FvInfo->ForceRebase == 0) {\r
+ return EFI_SUCCESS;\r
+ }\r
+\r
+\r
XipBase = FvInfo->BaseAddress + XipOffset;\r
\r
//\r
default:\r
return EFI_SUCCESS;\r
}\r
+\r
+ FfsHeaderSize = GetFfsHeaderLength(FfsFile);\r
//\r
// Rebase each PE32 section\r
//\r
if (EFI_ERROR (Status)) {\r
break;\r
}\r
+ CurSecHdrSize = GetSectionHeaderLength(CurrentPe32Section.CommonHeader);\r
\r
//\r
// Initialize context\r
//\r
memset (&ImageContext, 0, sizeof (ImageContext));\r
- ImageContext.Handle = (VOID *) ((UINTN) CurrentPe32Section.Pe32Section + sizeof (EFI_PE32_SECTION));\r
+ ImageContext.Handle = (VOID *) ((UINTN) CurrentPe32Section.Pe32Section + CurSecHdrSize);\r
ImageContext.ImageRead = (PE_COFF_LOADER_READ_FILE) FfsRebaseImageRead;\r
Status = PeCoffLoaderGetImageInfo (&ImageContext);\r
if (EFI_ERROR (Status)) {\r
return Status;\r
}\r
\r
- if (ImageContext.Machine == EFI_IMAGE_MACHINE_ARMT) {\r
+ if ( (ImageContext.Machine == EFI_IMAGE_MACHINE_ARMT) ||\r
+ (ImageContext.Machine == EFI_IMAGE_MACHINE_AARCH64) ) {\r
mArm = TRUE;\r
}\r
\r
//\r
// Get PeHeader pointer\r
//\r
- ImgHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION *)((UINTN) CurrentPe32Section.Pe32Section + sizeof (EFI_PE32_SECTION) + ImageContext.PeCoffHeaderOffset);\r
+ ImgHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION *)((UINTN) CurrentPe32Section.Pe32Section + CurSecHdrSize + ImageContext.PeCoffHeaderOffset);\r
\r
//\r
// Calculate the PE32 base address, based on file type\r
*(Cptr + 3) = 'i';\r
*(Cptr + 4) = '\0';\r
}\r
- PeFile = fopen (PeFileName, "rb");\r
+ PeFile = fopen (LongFilePath (PeFileName), "rb");\r
if (PeFile == NULL) {\r
Warning (NULL, 0, 0, "Invalid", "The file %s has no .reloc section.", FileName);\r
//Error (NULL, 0, 3000, "Invalid", "The file %s has no .reloc section.", FileName);\r
ImageContext.RelocationsStripped = FALSE;\r
}\r
\r
- NewPe32BaseAddress = XipBase + (UINTN) CurrentPe32Section.Pe32Section + sizeof (EFI_PE32_SECTION) - (UINTN)FfsFile;\r
- BaseToUpdate = &XipBase;\r
+ NewPe32BaseAddress = XipBase + (UINTN) CurrentPe32Section.Pe32Section + CurSecHdrSize - (UINTN)FfsFile;\r
break;\r
\r
case EFI_FV_FILETYPE_DRIVER:\r
Error (NULL, 0, 3000, "Invalid", "Section-Alignment and File-Alignment do not match : %s.", FileName);\r
return EFI_ABORTED;\r
}\r
- NewPe32BaseAddress = XipBase + (UINTN) CurrentPe32Section.Pe32Section + sizeof (EFI_PE32_SECTION) - (UINTN)FfsFile;\r
- BaseToUpdate = &XipBase; \r
+ NewPe32BaseAddress = XipBase + (UINTN) CurrentPe32Section.Pe32Section + CurSecHdrSize - (UINTN)FfsFile;\r
break;\r
\r
default:\r
\r
for (Index = 0; Index < ImgHdr->Pe32.FileHeader.NumberOfSections; Index ++, SectionHeader ++) {\r
CopyMem (\r
- (UINT8 *) CurrentPe32Section.Pe32Section + sizeof (EFI_COMMON_SECTION_HEADER) + SectionHeader->PointerToRawData, \r
+ (UINT8 *) CurrentPe32Section.Pe32Section + CurSecHdrSize + SectionHeader->PointerToRawData, \r
(VOID*) (UINTN) (ImageContext.ImageAddress + SectionHeader->VirtualAddress), \r
SectionHeader->SizeOfRawData\r
);\r
FfsFile->IntegrityCheck.Checksum.File = 0;\r
FfsFile->State = 0;\r
FfsFile->IntegrityCheck.Checksum.File = CalculateChecksum8 (\r
- (UINT8 *) (FfsFile + 1),\r
- GetLength (FfsFile->Size) - sizeof (EFI_FFS_FILE_HEADER)\r
+ (UINT8 *) ((UINT8 *)FfsFile + FfsHeaderSize),\r
+ GetFfsFileLength (FfsFile) - FfsHeaderSize\r
);\r
FfsFile->State = SavedState;\r
}\r
if (EFI_ERROR (Status)) {\r
break;\r
}\r
+\r
+ CurSecHdrSize = GetSectionHeaderLength(CurrentPe32Section.CommonHeader);\r
\r
//\r
// Calculate the TE base address, the FFS file base plus the offset of the TE section less the size stripped off\r
// by GenTEImage\r
//\r
- TEImageHeader = (EFI_TE_IMAGE_HEADER *) ((UINT8 *) CurrentPe32Section.Pe32Section + sizeof (EFI_COMMON_SECTION_HEADER));\r
+ TEImageHeader = (EFI_TE_IMAGE_HEADER *) ((UINT8 *) CurrentPe32Section.Pe32Section + CurSecHdrSize);\r
\r
//\r
// Initialize context, load image info.\r
return Status;\r
}\r
\r
- if (ImageContext.Machine == EFI_IMAGE_MACHINE_ARMT) {\r
+ if ( (ImageContext.Machine == EFI_IMAGE_MACHINE_ARMT) ||\r
+ (ImageContext.Machine == EFI_IMAGE_MACHINE_AARCH64) ) {\r
mArm = TRUE;\r
}\r
\r
*(Cptr + 4) = '\0';\r
}\r
\r
- PeFile = fopen (PeFileName, "rb");\r
+ PeFile = fopen (LongFilePath (PeFileName), "rb");\r
if (PeFile == NULL) {\r
Warning (NULL, 0, 0, "Invalid", "The file %s has no .reloc section.", FileName);\r
//Error (NULL, 0, 3000, "Invalid", "The file %s has no .reloc section.", FileName);\r
FfsFile->IntegrityCheck.Checksum.File = 0;\r
FfsFile->State = 0;\r
FfsFile->IntegrityCheck.Checksum.File = CalculateChecksum8 (\r
- (UINT8 *)(FfsFile + 1),\r
- GetLength (FfsFile->Size) - sizeof (EFI_FFS_FILE_HEADER)\r
+ (UINT8 *)((UINT8 *)FfsFile + FfsHeaderSize),\r
+ GetFfsFileLength (FfsFile) - FfsHeaderSize\r
);\r
FfsFile->State = SavedState;\r
}\r
//\r
// Get Pad file size.\r
//\r
- FileLength = (*(UINT32 *)(PadFile->Size)) & 0x00FFFFFF;\r
+ FileLength = GetFfsFileLength(PadFile);\r
FileLength = (FileLength + EFI_FFS_FILE_HEADER_ALIGNMENT - 1) & ~(EFI_FFS_FILE_HEADER_ALIGNMENT - 1); \r
//\r
// FixPoint must be align on 0x1000 relative to FvImage Header\r
//\r
- FixPoint = (UINT8*) PadFile + sizeof (EFI_FFS_FILE_HEADER);\r
+ FixPoint = (UINT8*) PadFile + GetFfsHeaderLength(PadFile);\r
FixPoint = FixPoint + 0x1000 - (((UINTN) FixPoint - (UINTN) FvImage->FileImage) & 0xFFF);\r
//\r
// FixPoint be larger at the last place of one fv image.\r
}\r
FixPoint -= 0x1000;\r
\r
- if ((UINTN) FixPoint < ((UINTN) PadFile + sizeof (EFI_FFS_FILE_HEADER))) {\r
+ if ((UINTN) FixPoint < ((UINTN) PadFile + GetFfsHeaderLength(PadFile))) {\r
//\r
// No alignment FixPoint in this Pad File.\r
//\r
EFI_NOT_FOUND A required string was not found in the INF file.\r
--*/\r
{\r
- CHAR8 Value[_MAX_PATH];\r
+ CHAR8 Value[MAX_LONG_FILE_PATH];\r
UINT64 Value64;\r
UINTN Index, Number;\r
EFI_STATUS Status;\r
DebugMsg (NULL, 0, 9, "Capsule Flag", Value);\r
}\r
\r
+ Status = FindToken (InfFile, OPTIONS_SECTION_STRING, EFI_OEM_CAPSULE_FLAGS_STRING, 0, Value);\r
+ if (Status == EFI_SUCCESS) {\r
+ Status = AsciiStringToUint64 (Value, FALSE, &Value64);\r
+ if (EFI_ERROR (Status) || Value64 > 0xffff) {\r
+ Error (NULL, 0, 2000, "Invalid parameter",\r
+ "invalid Flag setting for %s. Must be integer value between 0x0000 and 0xffff.",\r
+ EFI_OEM_CAPSULE_FLAGS_STRING);\r
+ return EFI_ABORTED;\r
+ }\r
+ CapInfo->Flags |= Value64;\r
+ DebugMsg (NULL, 0, 9, "Capsule Extend Flag", Value);\r
+ }\r
+\r
//\r
// Read Capsule File name\r
//\r
FileSize = 0;\r
CapSize = mCapDataInfo.HeaderSize;\r
while (mCapDataInfo.CapFiles [Index][0] != '\0') {\r
- fpin = fopen (mCapDataInfo.CapFiles[Index], "rb");\r
+ fpin = fopen (LongFilePath (mCapDataInfo.CapFiles[Index]), "rb");\r
if (fpin == NULL) {\r
Error (NULL, 0, 0001, "Error opening file", mCapDataInfo.CapFiles[Index]);\r
return EFI_ABORTED;\r
FileSize = 0;\r
CapSize = CapsuleHeader->HeaderSize;\r
while (mCapDataInfo.CapFiles [Index][0] != '\0') {\r
- fpin = fopen (mCapDataInfo.CapFiles[Index], "rb");\r
+ fpin = fopen (LongFilePath (mCapDataInfo.CapFiles[Index]), "rb");\r
if (fpin == NULL) {\r
Error (NULL, 0, 0001, "Error opening file", mCapDataInfo.CapFiles[Index]);\r
free (CapBuffer);\r
//\r
// write capsule data into the output file\r
//\r
- fpout = fopen (CapFileName, "wb");\r
+ fpout = fopen (LongFilePath (CapFileName), "wb");\r
if (fpout == NULL) {\r
Error (NULL, 0, 0001, "Error opening file", CapFileName);\r
free (CapBuffer);\r
projects / mirror_edk2.git / blobdiff