mirror of https://github.com/acidanthera/audk.git
1567 lines
42 KiB
C
1567 lines
42 KiB
C
/*++
|
|
|
|
Copyright (c) 2004 - 2007, Intel Corporation. All rights reserved.<BR>
|
|
This program and the accompanying materials
|
|
are licensed and made available under the terms and conditions of the BSD License
|
|
which accompanies this distribution. The full text of the license may be found at
|
|
http://opensource.org/licenses/bsd-license.php
|
|
|
|
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
|
|
|
Module Name:
|
|
|
|
FWVolume.c
|
|
|
|
Abstract:
|
|
|
|
This module contains functionality to keep track of files destined for
|
|
multiple firmware volues. It saves them up, and when told to, dumps the
|
|
file names out to some files used as input to other utilities that
|
|
actually generate the FVs.
|
|
|
|
--*/
|
|
|
|
#include <windows.h> // for max_path definition
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <stdlib.h> // for malloc()
|
|
#include "Common.h"
|
|
#include "DSCFile.h"
|
|
#include "FWVolume.h"
|
|
|
|
#define FV_INF_DIR "FV_INF_DIR" // symbol for where we create the FV INF file
|
|
#define FV_FILENAME "FV_FILENAME" // symbol for the current FV.INF filename
|
|
#define EFI_BASE_ADDRESS "EFI_BASE_ADDRESS"
|
|
#define DEFAULT_FV_INF_DIR "FV" // default dir for where we create the FV INF file
|
|
#define DEFAULT_FV_DIR "$(BUILD_DIR)" // where the FV file comes from
|
|
#define MALLOC(size) malloc (size)
|
|
#define FREE(ptr) free (ptr)
|
|
|
|
//
|
|
// Disable warning for unused function arguments
|
|
//
|
|
#pragma warning(disable : 4100)
|
|
//
|
|
// Disable warning for while(1) code
|
|
//
|
|
// #pragma warning (disable : 4127)
|
|
//
|
|
typedef struct {
|
|
char *ComponentType;
|
|
char *Extension;
|
|
} COMP_TYPE_EXTENSION;
|
|
|
|
//
|
|
// Use a linked list of these to keep track of all the FV names used
|
|
//
|
|
typedef struct _FV_LIST {
|
|
struct _FV_LIST *Next;
|
|
char FVFileName[MAX_PATH];
|
|
char BaseAddress[MAX_LINE_LEN];
|
|
SMART_FILE *FVFilePtr;
|
|
SMART_FILE *AprioriFilePtr;
|
|
char *Processor;
|
|
int ComponentsInstance; // highest [components.n] section with a file for this FV
|
|
} FV_LIST;
|
|
|
|
//
|
|
// Use a linked list of these to keep track of all FFS files built. When
|
|
// we're done, we turn the info into the FV INF files used to build the
|
|
// firmware volumes.
|
|
//
|
|
typedef struct _FILE_LIST {
|
|
struct _FILE_LIST *Next;
|
|
char *FileName;
|
|
char *BaseFileName;
|
|
char *FVs; // from FV=x,y,z
|
|
char *BaseName; // only needed for duplicate basename check
|
|
char *Processor; // only needed for duplicate basename check
|
|
char Apriori[100]; // of format "FVRecovery:1,FVMain:2" from APRIORI define
|
|
char *Guid; // guid string
|
|
int ComponentsInstance; // which [components.n] section it's in
|
|
} FILE_LIST;
|
|
|
|
typedef struct _LINKED_LIST {
|
|
struct _LINKED_LIST *Next;
|
|
void *Data;
|
|
} LINKED_LIST;
|
|
|
|
static FILE_LIST *mFileList;
|
|
static FILE_LIST *mLastFile;
|
|
static char *mXRefFileName = NULL;
|
|
static FV_LIST *mNonFfsFVList = NULL;
|
|
|
|
//
|
|
// Whenever an FV name is referenced, then add it to our list of known
|
|
// FV's using these.
|
|
//
|
|
static FV_LIST *mFVList = NULL;
|
|
static FV_LIST *mFVListLast = NULL;
|
|
|
|
//
|
|
// We use this list so that from a given component type, we can determine
|
|
// the name of the file on disk. For example, if we're given a file's
|
|
// guid and base name, and we know it's a "bs_driver", then we can look
|
|
// up "bs_driver" in this array and know that the file (after it's built)
|
|
// name is GUID-BASENAME.DXE
|
|
//
|
|
static const COMP_TYPE_EXTENSION mCompTypeExtension[] = {
|
|
{
|
|
"bs_driver",
|
|
".dxe"
|
|
},
|
|
{
|
|
"rt_driver",
|
|
".dxe"
|
|
},
|
|
{
|
|
"sal_rt_driver",
|
|
".dxe"
|
|
},
|
|
{
|
|
"security_core",
|
|
".sec"
|
|
},
|
|
{
|
|
"pei_core",
|
|
".pei"
|
|
},
|
|
{
|
|
"pic_peim",
|
|
".pei"
|
|
},
|
|
{
|
|
"pe32_peim",
|
|
".pei"
|
|
},
|
|
{
|
|
"relocatable_peim",
|
|
".pei"
|
|
},
|
|
{
|
|
"binary",
|
|
".ffs"
|
|
},
|
|
{
|
|
"application",
|
|
".app"
|
|
},
|
|
{
|
|
"file",
|
|
".ffs"
|
|
},
|
|
{
|
|
"fvimagefile",
|
|
".fvi"
|
|
},
|
|
{
|
|
"rawfile",
|
|
".raw"
|
|
},
|
|
{
|
|
"apriori",
|
|
".ffs"
|
|
},
|
|
{
|
|
"combined_peim_driver",
|
|
".pei"
|
|
},
|
|
{
|
|
NULL,
|
|
NULL
|
|
}
|
|
};
|
|
|
|
static
|
|
void
|
|
CFVFreeFileList (
|
|
VOID
|
|
);
|
|
|
|
static
|
|
char *
|
|
UpperCaseString (
|
|
char *Str
|
|
);
|
|
|
|
static
|
|
BOOLEAN
|
|
InSameFv (
|
|
char *FVs1,
|
|
char *FVs2
|
|
);
|
|
|
|
static
|
|
void
|
|
AddFirmwareVolumes (
|
|
char *FVs,
|
|
int ComponentsInstance,
|
|
FILE_LIST *FileListPtr
|
|
);
|
|
|
|
static
|
|
BOOLEAN
|
|
OrderInFvList (
|
|
char *FvList,
|
|
char *FvName,
|
|
int *Order
|
|
);
|
|
|
|
int
|
|
GetBaseAddress (
|
|
char *Name,
|
|
char *BaseAddress
|
|
)
|
|
{
|
|
char *Start;
|
|
char *Cptr;
|
|
char CSave;
|
|
char *Value;
|
|
|
|
Start = Name;
|
|
while (*Name && isspace (*Name)) {
|
|
Name++;
|
|
}
|
|
|
|
if (!*Name) {
|
|
return STATUS_ERROR;
|
|
}
|
|
//
|
|
// Find the end of the name. Either space or a '='.
|
|
//
|
|
for (Value = Name; *Value && !isspace (*Value) && (*Value != '='); Value++)
|
|
;
|
|
if (!*Value) {
|
|
return STATUS_ERROR;
|
|
}
|
|
//
|
|
// Look for the '='
|
|
//
|
|
Cptr = Value;
|
|
while (*Value && (*Value != '=')) {
|
|
Value++;
|
|
}
|
|
|
|
if (!*Value) {
|
|
return STATUS_ERROR;
|
|
}
|
|
//
|
|
// Now truncate the name
|
|
//
|
|
CSave = *Cptr;
|
|
*Cptr = 0;
|
|
if (_stricmp (Name, EFI_BASE_ADDRESS) != 0) {
|
|
return STATUS_ERROR;
|
|
}
|
|
|
|
*Cptr = CSave;
|
|
//
|
|
// Skip over the = and then any spaces
|
|
//
|
|
Value++;
|
|
while (*Value && isspace (*Value)) {
|
|
Value++;
|
|
}
|
|
//
|
|
// Find end of string, checking for quoted string
|
|
//
|
|
if (*Value == '\"') {
|
|
Value++;
|
|
for (Cptr = Value; *Cptr && *Cptr != '\"'; Cptr++)
|
|
;
|
|
} else {
|
|
for (Cptr = Value; *Cptr && !isspace (*Cptr); Cptr++)
|
|
;
|
|
}
|
|
//
|
|
// Null terminate the value string
|
|
//
|
|
CSave = *Cptr;
|
|
*Cptr = 0;
|
|
strcpy (BaseAddress, Value);
|
|
*Cptr = CSave;
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
int
|
|
CFVAddFVFile (
|
|
char *Name,
|
|
char *ComponentType,
|
|
char *FVs,
|
|
int ComponentsInstance,
|
|
char *FFSExt,
|
|
char *Processor,
|
|
char *Apriori,
|
|
char *BaseName,
|
|
char *Guid
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Add a file to the list of files in one or more firmware volumes.
|
|
|
|
Arguments:
|
|
|
|
Name - $(FILE_GUID)-$(BASE_NAME), or filename
|
|
ComponentType - type of component being added. Required so we know the
|
|
resultant file name after it has been built
|
|
FVs - string of commma-separated FVs that the given file is
|
|
to be added to. For example, FVs="FV0001,FV0002"
|
|
FFSExt - FFS filename extension of the file after it has been built.
|
|
This is passed in to us in case we don't know the default
|
|
filename extension based on the component type.
|
|
Processor - the target processor which the FV is being built for
|
|
Apriori - pointer to the definition of APRIORI. For example APRIORI="FvRecovery:1,FvMain:4"
|
|
|
|
Returns:
|
|
|
|
STATUS_SUCCESS if successful
|
|
|
|
--*/
|
|
{
|
|
FILE_LIST *Ptr;
|
|
char FileName[MAX_PATH];
|
|
char Str[MAX_PATH];
|
|
int i;
|
|
char *Sym;
|
|
|
|
// If they provided a filename extension for this type of file, then use it.
|
|
// If they did not provide a filename extension, search our list for a
|
|
// matching component type and use the extension appropriate for this
|
|
// component type.
|
|
//
|
|
if (FFSExt == NULL) {
|
|
//
|
|
// They didn't give us a filename extension. Figure it out from the
|
|
// component type.
|
|
//
|
|
for (i = 0; mCompTypeExtension[i].ComponentType != NULL; i++) {
|
|
if (_stricmp (ComponentType, mCompTypeExtension[i].ComponentType) == 0) {
|
|
FFSExt = mCompTypeExtension[i].Extension;
|
|
break;
|
|
}
|
|
}
|
|
//
|
|
// If we don't know the file extension, then error out. Just means
|
|
// the need to define "FFS_EXT = raw" in the component INF file.
|
|
//
|
|
if (mCompTypeExtension[i].ComponentType == NULL) {
|
|
Error (
|
|
NULL,
|
|
0,
|
|
0,
|
|
ComponentType,
|
|
"unknown component type - must define FFS_EXT for built filename extension in component INF file"
|
|
);
|
|
return STATUS_ERROR;
|
|
}
|
|
}
|
|
//
|
|
// We now have all the parts to the FFS filename. Prepend the path to it if
|
|
// it's not a full pathname.
|
|
// See if they overrode the default base directory for the FV files.
|
|
//
|
|
if (!IsAbsolutePath (Name)) {
|
|
Sym = GetSymbolValue (FV_DIR);
|
|
if (Sym == NULL) {
|
|
Sym = DEFAULT_FV_DIR;
|
|
}
|
|
//
|
|
// Create the file path. Something like $(BUILD_DIR)\$(PROCESSOR)\$(GUID)-$(BASE_NAME).ext
|
|
// If the extension is non-zero length, then make sure there's a dot in it.
|
|
//
|
|
if ((strlen (FFSExt) > 0) && (FFSExt[0] != '.')) {
|
|
sprintf (Str, "%s\\%s\\%s.%s", Sym, Processor, Name, FFSExt);
|
|
} else {
|
|
sprintf (Str, "%s\\%s\\%s%s", Sym, Processor, Name, FFSExt);
|
|
}
|
|
|
|
ExpandSymbols (Str, FileName, sizeof (FileName), EXPANDMODE_NO_UNDEFS);
|
|
} else {
|
|
strcpy (FileName, Name);
|
|
}
|
|
//
|
|
// Traverse the list of files we have so far and make sure we don't have
|
|
// any duplicate basenames. If the base name and processor match, then we'll
|
|
// have build issues, so don't allow it. We also don't allow the same file GUID
|
|
// in the same FV which will cause boot time error if we allow this.
|
|
//
|
|
Ptr = mFileList;
|
|
while (Ptr != NULL) {
|
|
if ((Ptr->BaseName != NULL) && (BaseName != NULL) && (_stricmp (BaseName, Ptr->BaseName) == 0)) {
|
|
if ((Ptr->Processor != NULL) && (Processor != NULL) && (_stricmp (Processor, Ptr->Processor) == 0)) {
|
|
Error (NULL, 0, 0, BaseName, "duplicate base name specified");
|
|
return STATUS_ERROR;
|
|
}
|
|
}
|
|
|
|
if ((Ptr->Guid != NULL) && (Guid != NULL) && (_stricmp (Guid, Ptr->Guid) == 0)) {
|
|
if ((Ptr->FVs != NULL) && (FVs != NULL) && (InSameFv (FVs, Ptr->FVs))) {
|
|
Error (NULL, 0, 0, Guid, "duplicate Guid specified in the same FV for %s and %s",
|
|
(Ptr->BaseName==NULL)?"Unknown":Ptr->BaseName,
|
|
(BaseName==NULL)?"Unknown":BaseName);
|
|
return STATUS_ERROR;
|
|
}
|
|
}
|
|
|
|
Ptr = Ptr->Next;
|
|
}
|
|
//
|
|
// Allocate a new structure so we can add this file to the list of
|
|
// files.
|
|
//
|
|
Ptr = (FILE_LIST *) malloc (sizeof (FILE_LIST));
|
|
if (Ptr == NULL) {
|
|
Error (NULL, 0, 0, NULL, "failed to allocate memory");
|
|
return STATUS_ERROR;
|
|
}
|
|
|
|
memset ((char *) Ptr, 0, sizeof (FILE_LIST));
|
|
Ptr->FileName = (char *) malloc (strlen (FileName) + 1);
|
|
if (Ptr->FileName == NULL) {
|
|
Error (NULL, 0, 0, NULL, "failed to allocate memory");
|
|
return STATUS_ERROR;
|
|
}
|
|
|
|
strcpy (Ptr->FileName, FileName);
|
|
Ptr->ComponentsInstance = ComponentsInstance;
|
|
//
|
|
// Allocate memory to save the FV list if it's going into an FV.
|
|
//
|
|
if ((FVs != NULL) && (FVs[0] != 0)) {
|
|
Ptr->FVs = (char *) malloc (strlen (FVs) + 1);
|
|
if (Ptr->FVs == NULL) {
|
|
Error (NULL, 0, 0, NULL, "failed to allocate memory");
|
|
return STATUS_ERROR;
|
|
}
|
|
|
|
strcpy (Ptr->FVs, FVs);
|
|
}
|
|
|
|
Ptr->BaseFileName = (char *) malloc (strlen (Name) + 1);
|
|
if (Ptr->BaseFileName == NULL) {
|
|
Error (NULL, 0, 0, NULL, "failed to allocate memory");
|
|
return STATUS_ERROR;
|
|
}
|
|
|
|
strcpy (Ptr->BaseFileName, Name);
|
|
//
|
|
// Allocate memory for the basename if they gave us one. May not have one
|
|
// if the user is simply adding pre-existing binary files to the image.
|
|
//
|
|
if (BaseName != NULL) {
|
|
Ptr->BaseName = (char *) malloc (strlen (BaseName) + 1);
|
|
if (Ptr->BaseName == NULL) {
|
|
Error (NULL, 0, 0, NULL, "failed to allocate memory");
|
|
return STATUS_ERROR;
|
|
}
|
|
|
|
strcpy (Ptr->BaseName, BaseName);
|
|
}
|
|
//
|
|
// Allocate memory for the processor name
|
|
//
|
|
if (Processor != NULL) {
|
|
Ptr->Processor = (char *) malloc (strlen (Processor) + 1);
|
|
if (Ptr->Processor == NULL) {
|
|
Error (NULL, 0, 0, NULL, "failed to allocate memory");
|
|
return STATUS_ERROR;
|
|
}
|
|
|
|
strcpy (Ptr->Processor, Processor);
|
|
}
|
|
//
|
|
// Allocate memory for the guid name
|
|
//
|
|
if (Guid != NULL) {
|
|
Ptr->Guid = (char *) malloc (strlen (Guid) + 1);
|
|
if (Ptr->Guid == NULL) {
|
|
Error (NULL, 0, 0, NULL, "failed to allocate memory");
|
|
return STATUS_ERROR;
|
|
}
|
|
|
|
strcpy (Ptr->Guid, Guid);
|
|
}
|
|
//
|
|
// If non-null apriori symbol, then save the apriori list for this file
|
|
//
|
|
if (Apriori != NULL) {
|
|
strcpy (Ptr->Apriori, Apriori);
|
|
}
|
|
|
|
if (mFileList == NULL) {
|
|
mFileList = Ptr;
|
|
} else {
|
|
mLastFile->Next = Ptr;
|
|
}
|
|
|
|
mLastFile = Ptr;
|
|
//
|
|
// Add these firmware volumes to the list of known firmware
|
|
// volume names.
|
|
//
|
|
AddFirmwareVolumes (FVs, ComponentsInstance, Ptr);
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
void
|
|
CFVConstructor (
|
|
VOID
|
|
)
|
|
{
|
|
mFileList = NULL;
|
|
mLastFile = NULL;
|
|
}
|
|
|
|
void
|
|
CFVDestructor (
|
|
VOID
|
|
)
|
|
{
|
|
CFVFreeFileList ();
|
|
//
|
|
// Free up our firmware volume list
|
|
//
|
|
while (mFVList != NULL) {
|
|
mFVListLast = mFVList->Next;
|
|
FREE (mFVList);
|
|
mFVList = mFVListLast;
|
|
}
|
|
}
|
|
|
|
static
|
|
void
|
|
CFVFreeFileList (
|
|
VOID
|
|
)
|
|
{
|
|
FILE_LIST *Next;
|
|
while (mFileList != NULL) {
|
|
if (mFileList->FileName != NULL) {
|
|
free (mFileList->FileName);
|
|
}
|
|
|
|
if (mFileList->FVs != NULL) {
|
|
free (mFileList->FVs);
|
|
}
|
|
|
|
free (mFileList->BaseFileName);
|
|
if (mFileList->BaseName != NULL) {
|
|
free (mFileList->BaseName);
|
|
}
|
|
|
|
if (mFileList->Processor != NULL) {
|
|
free (mFileList->Processor);
|
|
}
|
|
|
|
if (mFileList->Guid != NULL) {
|
|
free (mFileList->Guid);
|
|
}
|
|
|
|
Next = mFileList->Next;
|
|
free (mFileList);
|
|
mFileList = Next;
|
|
}
|
|
|
|
mFileList = NULL;
|
|
}
|
|
|
|
int
|
|
CFVWriteInfFiles (
|
|
DSC_FILE *DSC,
|
|
FILE *MakeFptr
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
After processing all components in a DSC file, create the firmware
|
|
volume INF files. We actually do a lot more here.
|
|
|
|
* Create the FVxxx.inf file that is used by GenFvImage
|
|
* Create the Apriori files for each firmware volume that requires one
|
|
* Create makefile.out macros for FVxxx_FILES = FVxxx_FILES AnotherFile
|
|
so you can do incremental builds of firmware volumes.
|
|
* For each FV, emit its build commands to makefile.out
|
|
|
|
Arguments:
|
|
|
|
DSC - pointer to a DSC_FILE object to extract info from
|
|
MakeFptr - pointer to the output makefile
|
|
|
|
Returns:
|
|
|
|
0 if successful
|
|
non-zero otherwise
|
|
|
|
--*/
|
|
{
|
|
FILE_LIST *FileListPtr;
|
|
FV_LIST *FVList;
|
|
FV_LIST *LastFVList;
|
|
FV_LIST *FVPtr;
|
|
SECTION *Section;
|
|
char *StartCptr;
|
|
char *EndCptr;
|
|
char CSave;
|
|
char Str[MAX_PATH];
|
|
char Line[MAX_LINE_LEN];
|
|
char ExpandedLine[MAX_LINE_LEN];
|
|
char FVDir[MAX_PATH];
|
|
FILE *XRefFptr;
|
|
int AprioriCounter;
|
|
int AprioriCount;
|
|
int AprioriPosition;
|
|
BOOLEAN AprioriFound;
|
|
int ComponentsInstance;
|
|
int ComponentCount;
|
|
|
|
//
|
|
// Use this to keep track of all the firmware volume names
|
|
//
|
|
FVList = NULL;
|
|
LastFVList = NULL;
|
|
//
|
|
// See if they specified a FV directory to dump the FV files out to. If not,
|
|
// then use the default. Then create the output directory.
|
|
//
|
|
StartCptr = GetSymbolValue (FV_INF_DIR);
|
|
if (StartCptr == NULL) {
|
|
ExpandSymbols (DEFAULT_FV_INF_DIR, FVDir, sizeof (FVDir), EXPANDMODE_NO_UNDEFS);
|
|
} else {
|
|
strcpy (FVDir, StartCptr);
|
|
}
|
|
//
|
|
// Make sure the fv directory path ends in /
|
|
//
|
|
CSave = FVDir[strlen (FVDir) - 1];
|
|
if ((CSave != '\\') && (CSave != '/')) {
|
|
strcat (FVDir, "\\");
|
|
}
|
|
//
|
|
// Traverse the list of all files, determine which FV each is in, then
|
|
// write out the file's name to the output FVxxx.inf file.
|
|
//
|
|
for (FileListPtr = mFileList; FileListPtr != NULL; FileListPtr = FileListPtr->Next) {
|
|
//
|
|
// Parse all the "FV1,FV2..." in the FVs
|
|
//
|
|
if (FileListPtr->FVs != NULL) {
|
|
//
|
|
// Process each fv this file is in
|
|
//
|
|
StartCptr = FileListPtr->FVs;
|
|
while (*StartCptr) {
|
|
EndCptr = StartCptr;
|
|
while (*EndCptr && (*EndCptr != ',')) {
|
|
EndCptr++;
|
|
}
|
|
|
|
CSave = *EndCptr;
|
|
*EndCptr = 0;
|
|
//
|
|
// Ok, we have a fv name, now see if we've already opened
|
|
// an fv output file of this name.
|
|
//
|
|
for (FVPtr = FVList; FVPtr != NULL; FVPtr = FVPtr->Next) {
|
|
if (_stricmp (FVPtr->FVFileName, StartCptr) == 0) {
|
|
break;
|
|
}
|
|
}
|
|
//
|
|
// If we didn't find one, then create a new one
|
|
//
|
|
if (FVPtr == NULL) {
|
|
//
|
|
// Create a new one, add it to the list
|
|
//
|
|
FVPtr = (FV_LIST *) malloc (sizeof (FV_LIST));
|
|
if (FVPtr == NULL) {
|
|
Error (NULL, 0, 0, NULL, "failed to allocate memory for FV");
|
|
return STATUS_ERROR;
|
|
}
|
|
|
|
memset ((char *) FVPtr, 0, sizeof (FV_LIST));
|
|
//
|
|
// Add it to the end of our list
|
|
//
|
|
if (FVList == NULL) {
|
|
FVList = FVPtr;
|
|
} else {
|
|
LastFVList->Next = FVPtr;
|
|
}
|
|
|
|
LastFVList = FVPtr;
|
|
//
|
|
// Save the FV name in the FileName pointer so we can compare
|
|
// for any future FV names specified.
|
|
//
|
|
strcpy (FVPtr->FVFileName, StartCptr);
|
|
|
|
//
|
|
// Add a symbol for the FV filename
|
|
//
|
|
UpperCaseString (FVPtr->FVFileName);
|
|
AddSymbol (FV_FILENAME, FVPtr->FVFileName, SYM_LOCAL | SYM_OVERWRITE);
|
|
//
|
|
// Now create the FVx.inf filename from the fv name and
|
|
// default filename extension. Dump it in the FV directory
|
|
// as well.
|
|
//
|
|
strcpy (Str, FVDir);
|
|
strcat (Str, FVPtr->FVFileName);
|
|
strcat (Str, ".inf");
|
|
//
|
|
// Create the directory path for our new fv.inf output file.
|
|
//
|
|
MakeFilePath (Str);
|
|
if ((FVPtr->FVFilePtr = SmartOpen (Str)) == NULL) {
|
|
Error (NULL, 0, 0, Str, "could not open FV output file");
|
|
return STATUS_ERROR;
|
|
}
|
|
//
|
|
// Now copy the [fv.$(FV).options] to the fv INF file
|
|
//
|
|
sprintf (Str, "fv.%s.options", StartCptr);
|
|
Section = DSCFileFindSection (DSC, Str);
|
|
if (Section != NULL) {
|
|
SmartWrite (FVPtr->FVFilePtr, "[options]\n");
|
|
while (DSCFileGetLine (DSC, Line, sizeof (Line)) != NULL) {
|
|
ExpandSymbols (Line, ExpandedLine, sizeof (ExpandedLine), 0);
|
|
SmartWrite (FVPtr->FVFilePtr, ExpandedLine);
|
|
GetBaseAddress (ExpandedLine, FVPtr->BaseAddress);
|
|
}
|
|
} else {
|
|
Error (NULL, 0, 0, Str, "could not find FV section in description file");
|
|
}
|
|
//
|
|
// Copy the [fv.$(FV).attributes] to the fv INF file
|
|
//
|
|
sprintf (Str, "fv.%s.attributes", StartCptr);
|
|
Section = DSCFileFindSection (DSC, Str);
|
|
if (Section != NULL) {
|
|
SmartWrite (FVPtr->FVFilePtr, "[attributes]\n");
|
|
while (DSCFileGetLine (DSC, Line, sizeof (Line)) != NULL) {
|
|
ExpandSymbols (Line, ExpandedLine, sizeof (ExpandedLine), 0);
|
|
SmartWrite (FVPtr->FVFilePtr, ExpandedLine);
|
|
}
|
|
} else {
|
|
Error (NULL, 0, 0, Str, "Could not find FV section in description file");
|
|
}
|
|
//
|
|
// Start the files section
|
|
//
|
|
SmartWrite (FVPtr->FVFilePtr, "\n[files]\n");
|
|
}
|
|
//
|
|
// Now write the FV filename to the FV.inf file. Prepend $(PROCESSOR) on
|
|
// it.
|
|
//
|
|
sprintf (ExpandedLine, "EFI_FILE_NAME = %s\n", FileListPtr->FileName);
|
|
SmartWrite (FVPtr->FVFilePtr, ExpandedLine);
|
|
|
|
//
|
|
// Next FV on the FV list
|
|
//
|
|
*EndCptr = CSave;
|
|
StartCptr = EndCptr;
|
|
if (*StartCptr) {
|
|
StartCptr++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//
|
|
// Now we walk the list of firmware volumes and create the APRIORI list
|
|
// file for it .
|
|
//
|
|
for (FVPtr = FVList; FVPtr != NULL; FVPtr = FVPtr->Next) {
|
|
//
|
|
// Run through all the files and count up how many are to be
|
|
// added to the apriori list for this FV. Then when we're done
|
|
// we'll make sure we processed them all. We do this in case they
|
|
// skipped an apriori index for a given FV.
|
|
//
|
|
AprioriCount = 0;
|
|
for (FileListPtr = mFileList; FileListPtr != NULL; FileListPtr = FileListPtr->Next) {
|
|
if (OrderInFvList (FileListPtr->Apriori, FVPtr->FVFileName, &AprioriPosition)) {
|
|
//
|
|
// Emit an error if the index was 0, or they didn't give one.
|
|
//
|
|
if (AprioriPosition == 0) {
|
|
Error (
|
|
GetSymbolValue (DSC_FILENAME),
|
|
1,
|
|
0,
|
|
"apriori indexes are 1-based",
|
|
"component %s:APRIORI=%s",
|
|
FileListPtr->BaseName,
|
|
FileListPtr->Apriori
|
|
);
|
|
} else {
|
|
AprioriCount++;
|
|
}
|
|
|
|
}
|
|
}
|
|
//
|
|
// Now scan the files as we increment our apriori index
|
|
//
|
|
AprioriCounter = 0;
|
|
do {
|
|
AprioriFound = 0;
|
|
AprioriCounter++;
|
|
for (FileListPtr = mFileList; FileListPtr != NULL; FileListPtr = FileListPtr->Next) {
|
|
//
|
|
// If in the apriori list for this fv, print the name. Open the
|
|
// file first if we have to.
|
|
//
|
|
if ((FileListPtr->Apriori[0] != 0) &&
|
|
(OrderInFvList (FileListPtr->Apriori, FVPtr->FVFileName, &AprioriPosition))
|
|
) {
|
|
if (AprioriPosition == AprioriCounter) {
|
|
//
|
|
// If we've already found one for this index, emit an error. Decrement the
|
|
// count of how files we are to process so we don't emit another error for
|
|
// a miscount below.
|
|
//
|
|
if (AprioriFound) {
|
|
Error (
|
|
GetSymbolValue (DSC_FILENAME),
|
|
1,
|
|
0,
|
|
"duplicate apriori index found",
|
|
"%s:%d",
|
|
FVPtr->FVFileName,
|
|
AprioriCounter
|
|
);
|
|
AprioriCount--;
|
|
}
|
|
|
|
AprioriFound = 1;
|
|
//
|
|
// Open the apriori output file if we haven't already
|
|
//
|
|
if (FVPtr->AprioriFilePtr == NULL) {
|
|
strcpy (Str, FVDir);
|
|
strcat (Str, FVPtr->FVFileName);
|
|
strcat (Str, ".apr");
|
|
if ((FVPtr->AprioriFilePtr = SmartOpen (Str)) == NULL) {
|
|
Error (NULL, 0, 0, Str, "could not open output Apriori file for writing");
|
|
return STATUS_ERROR;
|
|
}
|
|
}
|
|
|
|
sprintf (ExpandedLine, "%s\n", FileListPtr->BaseFileName);
|
|
SmartWrite (FVPtr->AprioriFilePtr, ExpandedLine);
|
|
}
|
|
}
|
|
}
|
|
} while (AprioriFound);
|
|
//
|
|
// See if they skipped an apriori position for this FV
|
|
//
|
|
if (AprioriCount != (AprioriCounter - 1)) {
|
|
Error (
|
|
GetSymbolValue (DSC_FILENAME),
|
|
1,
|
|
0,
|
|
"apriori index skipped",
|
|
"%s:%d",
|
|
FVPtr->FVFileName,
|
|
AprioriCounter
|
|
);
|
|
}
|
|
}
|
|
//
|
|
// Traverse the list of all files again, and create a macro in the output makefile
|
|
// that defines all the files in each fv. For example, for each FV file, create a line:
|
|
// FV0001_FILES = $(FV_0001_FILES) xxxx-yyy.dxe.
|
|
// This can then be used as a dependency in their makefile.
|
|
// Also if they wanted us to dump a cross-reference, do that now.
|
|
//
|
|
if (mXRefFileName != NULL) {
|
|
if ((XRefFptr = fopen (mXRefFileName, "w")) == NULL) {
|
|
Message (
|
|
0,
|
|
"Failed to open cross-reference file '%s' for writing\n",
|
|
mXRefFileName
|
|
);
|
|
}
|
|
} else {
|
|
XRefFptr = NULL;
|
|
}
|
|
|
|
for (FileListPtr = mFileList; FileListPtr != NULL; FileListPtr = FileListPtr->Next) {
|
|
//
|
|
// Parse all the "FV1,FV2..." in the FV field that came from FV=FVa,FVb,... on the
|
|
// component line in the DSC file.
|
|
//
|
|
if (FileListPtr->FVs != NULL) {
|
|
//
|
|
// If generating a cross-reference file, dump the data
|
|
//
|
|
if (XRefFptr != NULL) {
|
|
if ((FileListPtr->Guid != NULL) && (FileListPtr->BaseName != NULL) && (FileListPtr->Processor)) {
|
|
fprintf (
|
|
XRefFptr,
|
|
"%s %s %s\n",
|
|
FileListPtr->Guid,
|
|
FileListPtr->BaseName,
|
|
FileListPtr->Processor
|
|
);
|
|
}
|
|
}
|
|
//
|
|
// Convert to uppercase since we're going to use the name as a macro variable name
|
|
// in the makefile.
|
|
//
|
|
UpperCaseString (FileListPtr->FVs);
|
|
//
|
|
// Process each FV this file is in to write fvxxx_FILES = $(fvxxx_FILES) Guid-BaseName.ffs
|
|
//
|
|
StartCptr = FileListPtr->FVs;
|
|
while (*StartCptr) {
|
|
EndCptr = StartCptr;
|
|
while (*EndCptr && (*EndCptr != ',')) {
|
|
EndCptr++;
|
|
}
|
|
|
|
CSave = *EndCptr;
|
|
*EndCptr = 0;
|
|
fprintf (
|
|
MakeFptr,
|
|
"%s_FILES = $(%s_FILES) %s\n",
|
|
StartCptr,
|
|
StartCptr,
|
|
FileListPtr->FileName
|
|
);
|
|
//
|
|
// Next FV on the FV list
|
|
//
|
|
*EndCptr = CSave;
|
|
StartCptr = EndCptr;
|
|
if (*StartCptr) {
|
|
StartCptr++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fprintf (MakeFptr, "\n");
|
|
|
|
//
|
|
// Now go through the list of all NonFFS FVs they specified and search for
|
|
// a [build.fv.$(FV)] or [build.fv] command and emit the commands to the
|
|
// output makefile. Add them to the "fvs" target as well.
|
|
//
|
|
if (mNonFfsFVList != NULL) {
|
|
fprintf (MakeFptr, "fvs ::");
|
|
FVPtr = mNonFfsFVList;
|
|
while (FVPtr != NULL) {
|
|
fprintf (MakeFptr, " %s%s.fv", FVDir, FVPtr->FVFileName);
|
|
FVPtr = FVPtr->Next;
|
|
}
|
|
|
|
fprintf (MakeFptr, "\n\n");
|
|
FVPtr = mNonFfsFVList;
|
|
while (FVPtr != NULL) {
|
|
//
|
|
// Save the position in the file
|
|
//
|
|
DSCFileSavePosition (DSC);
|
|
//
|
|
// first try to find a build section specific for this fv.
|
|
//
|
|
sprintf (Str, "build.fv.%s", FVPtr->FVFileName);
|
|
Section = DSCFileFindSection (DSC, Str);
|
|
if (Section == NULL) {
|
|
sprintf (Str, "build.fv");
|
|
Section = DSCFileFindSection (DSC, Str);
|
|
}
|
|
|
|
if (Section == NULL) {
|
|
Warning (
|
|
NULL,
|
|
0,
|
|
0,
|
|
NULL,
|
|
"No [build.fv.%s] nor [%s] section found in description file for building %s",
|
|
FVPtr->FVFileName,
|
|
Str,
|
|
FVPtr->FVFileName
|
|
);
|
|
} else {
|
|
//
|
|
// Add a symbol for the FV filename
|
|
//
|
|
UpperCaseString (FVPtr->FVFileName);
|
|
AddSymbol (FV_FILENAME, FVPtr->FVFileName, SYM_LOCAL | SYM_OVERWRITE);
|
|
AddSymbol (EFI_BASE_ADDRESS, FVPtr->BaseAddress, SYM_LOCAL | SYM_OVERWRITE);
|
|
|
|
//
|
|
// Now copy the build commands from the section to the makefile
|
|
//
|
|
while (DSCFileGetLine (DSC, Line, sizeof (Line)) != NULL) {
|
|
ExpandSymbols (
|
|
Line,
|
|
ExpandedLine,
|
|
sizeof (ExpandedLine),
|
|
EXPANDMODE_NO_DESTDIR | EXPANDMODE_NO_SOURCEDIR
|
|
);
|
|
|
|
fprintf (MakeFptr, ExpandedLine);
|
|
}
|
|
}
|
|
|
|
FVPtr = FVPtr->Next;
|
|
DSCFileRestorePosition (DSC);
|
|
}
|
|
}
|
|
//
|
|
// Go through our list of firmware volumes and create an "fvs" target that
|
|
// builds everything. It has to be a mix of components and FV's in order.
|
|
// For example: fvs : components_0 fv\fv001.fv fv\fv002.fv components_1 fv\fv003.fv
|
|
//
|
|
ComponentsInstance = 0;
|
|
ComponentCount = 0;
|
|
fprintf (MakeFptr, "fvs ::");
|
|
for (;;) {
|
|
//
|
|
// First see if we have any components for this section. If we don't,
|
|
// then we're done
|
|
//
|
|
for (FileListPtr = mFileList; FileListPtr != NULL; FileListPtr = FileListPtr->Next) {
|
|
if (FileListPtr->ComponentsInstance == ComponentsInstance) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (FileListPtr == NULL) {
|
|
break;
|
|
}
|
|
|
|
fprintf (MakeFptr, " components_%d", ComponentsInstance);
|
|
ComponentCount++;
|
|
//
|
|
// Now print any firmware volumes that match this components instance
|
|
//
|
|
for (FVPtr = mFVList; FVPtr != NULL; FVPtr = FVPtr->Next) {
|
|
if (FVPtr->ComponentsInstance == ComponentsInstance) {
|
|
fprintf (MakeFptr, " %s%s.fv", FVDir, FVPtr->FVFileName);
|
|
}
|
|
}
|
|
|
|
ComponentsInstance++;
|
|
}
|
|
|
|
fprintf (MakeFptr, "\n\n");
|
|
|
|
//
|
|
// Create a "components" target for build convenience. It should
|
|
// look something like:
|
|
// components : components_0 components_1...
|
|
//
|
|
if (ComponentCount > 0) {
|
|
fprintf (MakeFptr, "components :");
|
|
for (ComponentsInstance = 0; ComponentsInstance < ComponentCount; ComponentsInstance++) {
|
|
fprintf (MakeFptr, " components_%d", ComponentsInstance);
|
|
}
|
|
|
|
fprintf (MakeFptr, "\n\n");
|
|
}
|
|
//
|
|
// Now go through the list of all FV's defined and search for
|
|
// a [build.fv.$(FV)] or [build.fv] command and emit the commands to the
|
|
// output makefile.
|
|
//
|
|
FVPtr = mFVList;
|
|
while (FVPtr != NULL) {
|
|
if (FVPtr->FVFileName[0]) {
|
|
//
|
|
// Save the position in the file
|
|
//
|
|
DSCFileSavePosition (DSC);
|
|
//
|
|
// First try to find a build section specific for this FV.
|
|
//
|
|
sprintf (Str, "build.fv.%s", FVPtr->FVFileName);
|
|
Section = DSCFileFindSection (DSC, Str);
|
|
if (Section == NULL) {
|
|
sprintf (Str, "build.fv");
|
|
Section = DSCFileFindSection (DSC, Str);
|
|
}
|
|
|
|
if (Section == NULL) {
|
|
Error (
|
|
NULL,
|
|
0,
|
|
0,
|
|
NULL,
|
|
"no [build.fv.%s] nor [%s] section found in description file for building %s",
|
|
FVPtr->FVFileName,
|
|
Str,
|
|
FVPtr->FVFileName
|
|
);
|
|
} else {
|
|
//
|
|
// Add a symbol for the FV filename
|
|
//
|
|
UpperCaseString (FVPtr->FVFileName);
|
|
AddSymbol (FV_FILENAME, FVPtr->FVFileName, SYM_LOCAL | SYM_OVERWRITE);
|
|
AddSymbol (EFI_BASE_ADDRESS, FVPtr->BaseAddress, SYM_LOCAL | SYM_OVERWRITE);
|
|
|
|
//
|
|
// Now copy the build commands from the section to the makefile
|
|
//
|
|
while (DSCFileGetLine (DSC, Line, sizeof (Line)) != NULL) {
|
|
ExpandSymbols (
|
|
Line,
|
|
ExpandedLine,
|
|
sizeof (ExpandedLine),
|
|
EXPANDMODE_NO_DESTDIR | EXPANDMODE_NO_SOURCEDIR
|
|
);
|
|
fprintf (MakeFptr, ExpandedLine);
|
|
}
|
|
}
|
|
|
|
DSCFileRestorePosition (DSC);
|
|
}
|
|
|
|
FVPtr = FVPtr->Next;
|
|
}
|
|
//
|
|
// Close all the files and free up the memory
|
|
//
|
|
while (FVList != NULL) {
|
|
FVPtr = FVList->Next;
|
|
if (FVList->FVFilePtr != NULL) {
|
|
SmartClose (FVList->FVFilePtr);
|
|
}
|
|
|
|
if (FVList->AprioriFilePtr != NULL) {
|
|
SmartClose (FVList->AprioriFilePtr);
|
|
}
|
|
|
|
free (FVList);
|
|
FVList = FVPtr;
|
|
}
|
|
|
|
while (mNonFfsFVList != NULL) {
|
|
FVPtr = mNonFfsFVList->Next;
|
|
free (mNonFfsFVList);
|
|
mNonFfsFVList = FVPtr;
|
|
}
|
|
|
|
if (XRefFptr != NULL) {
|
|
fclose (XRefFptr);
|
|
}
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
int
|
|
NonFFSFVWriteInfFiles (
|
|
DSC_FILE *DSC,
|
|
char *FileName
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Generate a Non FFS fv file. It can only some variables,
|
|
or simply contains nothing except header.
|
|
|
|
Arguments:
|
|
|
|
DSC - pointer to a DSC_FILE object to extract info from
|
|
FileName - pointer to the fv file
|
|
|
|
Returns:
|
|
|
|
STATUS_SUCCESS if successful
|
|
non-STATUS_SUCCESS otherwise
|
|
|
|
--*/
|
|
{
|
|
FV_LIST *FVPtr;
|
|
SECTION *Section;
|
|
char *StartCptr;
|
|
char *EndCptr;
|
|
char CSave;
|
|
char Str[MAX_PATH];
|
|
char Line[MAX_LINE_LEN];
|
|
char ExpandedLine[MAX_LINE_LEN];
|
|
char FVDir[MAX_PATH];
|
|
|
|
//
|
|
// See if they specified a FV directory to dump the FV files out to. If not,
|
|
// then use the default. Then create the output directory.
|
|
//
|
|
DSCFileSavePosition (DSC);
|
|
StartCptr = GetSymbolValue (FV_INF_DIR);
|
|
if (StartCptr == NULL) {
|
|
ExpandSymbols (DEFAULT_FV_INF_DIR, FVDir, sizeof (FVDir), EXPANDMODE_NO_UNDEFS);
|
|
} else {
|
|
strcpy (FVDir, StartCptr);
|
|
}
|
|
|
|
//
|
|
// Make sure the fv directory path ends in /
|
|
//
|
|
CSave = FVDir[strlen (FVDir) - 1];
|
|
if ((CSave != '\\') && (CSave != '/')) {
|
|
strcat (FVDir, "\\");
|
|
}
|
|
|
|
StartCptr = FileName;
|
|
while (*StartCptr) {
|
|
EndCptr = StartCptr;
|
|
while (*EndCptr && (*EndCptr != ',')) {
|
|
EndCptr++;
|
|
}
|
|
|
|
CSave = *EndCptr;
|
|
*EndCptr = 0;
|
|
//
|
|
// Ok, we have a fv name, now see if we've already opened
|
|
// an fv output file of this name.
|
|
//
|
|
for (FVPtr = mNonFfsFVList; FVPtr != NULL; FVPtr = FVPtr->Next) {
|
|
if (_stricmp (FVPtr->FVFileName, StartCptr) == 0) {
|
|
break;
|
|
}
|
|
}
|
|
//
|
|
// If there is already one with the same name, wrong
|
|
//
|
|
if (FVPtr != NULL) {
|
|
DSCFileRestorePosition (DSC);
|
|
return STATUS_ERROR;
|
|
}
|
|
//
|
|
// Create a new one, add it to the list
|
|
//
|
|
FVPtr = (FV_LIST *) malloc (sizeof (FV_LIST));
|
|
if (FVPtr == NULL) {
|
|
Error (__FILE__, __LINE__, 0, "failed to allocate memory", NULL);
|
|
DSCFileRestorePosition (DSC);
|
|
return STATUS_ERROR;
|
|
}
|
|
|
|
memset ((char *) FVPtr, 0, sizeof (FV_LIST));
|
|
FVPtr->Next = mNonFfsFVList;
|
|
mNonFfsFVList = FVPtr;
|
|
//
|
|
// Save the FV name in the FileName pointer so we can compare
|
|
// for any future FV names specified.
|
|
//
|
|
strcpy (FVPtr->FVFileName, StartCptr);
|
|
//
|
|
// Add a symbol for the FV filename
|
|
//
|
|
UpperCaseString (FVPtr->FVFileName);
|
|
AddSymbol (FV_FILENAME, FVPtr->FVFileName, SYM_LOCAL | SYM_OVERWRITE);
|
|
|
|
//
|
|
// Now create the FVx.inf filename from the fv name and
|
|
// default filename extension. Dump it in the FV directory
|
|
// as well.
|
|
//
|
|
strcpy (Str, FVDir);
|
|
strcat (Str, FVPtr->FVFileName);
|
|
strcat (Str, ".inf");
|
|
//
|
|
// Create the directory path for our new fv.inf output file.
|
|
//
|
|
MakeFilePath (Str);
|
|
if ((FVPtr->FVFilePtr = SmartOpen (Str)) == NULL) {
|
|
Error (NULL, 0, 0, Str, "could not open FV output file");
|
|
DSCFileRestorePosition (DSC);
|
|
return STATUS_ERROR;
|
|
}
|
|
//
|
|
// Now copy the [fv.fvfile.options] to the fv file
|
|
//
|
|
sprintf (Str, "fv.%s.options", StartCptr);
|
|
Section = DSCFileFindSection (DSC, Str);
|
|
if (Section != NULL) {
|
|
SmartWrite (FVPtr->FVFilePtr, "[options]\n");
|
|
while (DSCFileGetLine (DSC, Line, sizeof (Line)) != NULL) {
|
|
ExpandSymbols (Line, ExpandedLine, sizeof (ExpandedLine), 0);
|
|
SmartWrite (FVPtr->FVFilePtr, ExpandedLine);
|
|
GetBaseAddress (ExpandedLine, FVPtr->BaseAddress);
|
|
}
|
|
} else {
|
|
Warning (NULL, 0, 0, NULL, "Could not find FV section '%s' in description file", Str);
|
|
}
|
|
//
|
|
// Copy the [fv.fvfile.attributes] to the fv file
|
|
//
|
|
sprintf (Str, "fv.%s.attributes", StartCptr);
|
|
Section = DSCFileFindSection (DSC, Str);
|
|
if (Section != NULL) {
|
|
SmartWrite (FVPtr->FVFilePtr, "[attributes]\n");
|
|
while (DSCFileGetLine (DSC, Line, sizeof (Line)) != NULL) {
|
|
ExpandSymbols (Line, ExpandedLine, sizeof (ExpandedLine), 0);
|
|
SmartWrite (FVPtr->FVFilePtr, ExpandedLine);
|
|
}
|
|
} else {
|
|
Warning (NULL, 0, 0, NULL, "Could not find FV section '%s' in description file", Str);
|
|
}
|
|
//
|
|
// Copy the [fv.fvfile.components] to the fv file
|
|
//
|
|
sprintf (Str, "fv.%s.components", StartCptr);
|
|
Section = DSCFileFindSection (DSC, Str);
|
|
if (Section != NULL) {
|
|
SmartWrite (FVPtr->FVFilePtr, "[components]\n");
|
|
while (DSCFileGetLine (DSC, Line, sizeof (Line)) != NULL) {
|
|
ExpandSymbols (Line, ExpandedLine, sizeof (ExpandedLine), 0);
|
|
SmartWrite (FVPtr->FVFilePtr, ExpandedLine);
|
|
}
|
|
} else {
|
|
//
|
|
// An empty FV is allowed to contain nothing
|
|
//
|
|
}
|
|
//
|
|
// Close the file
|
|
//
|
|
SmartClose (FVPtr->FVFilePtr);
|
|
//
|
|
// Next FV in FileName
|
|
//
|
|
*EndCptr = CSave;
|
|
StartCptr = EndCptr;
|
|
if (*StartCptr) {
|
|
StartCptr++;
|
|
}
|
|
}
|
|
|
|
DSCFileRestorePosition (DSC);
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
static
|
|
void
|
|
AddFirmwareVolumes (
|
|
char *FVs,
|
|
int ComponentsInstance,
|
|
FILE_LIST *FileListPtr
|
|
)
|
|
{
|
|
FV_LIST *FvPtr;
|
|
char *StartPtr;
|
|
char *EndPtr;
|
|
char SaveChar;
|
|
|
|
if ((FVs != NULL) && (FVs[0] != 0)) {
|
|
//
|
|
// Extract each FV name from the string. It's from the DSC file "FV=FvRecover,FvMain"
|
|
//
|
|
StartPtr = FVs;
|
|
while (*StartPtr != 0) {
|
|
EndPtr = StartPtr;
|
|
while (*EndPtr && (*EndPtr != ',')) {
|
|
EndPtr++;
|
|
}
|
|
|
|
SaveChar = *EndPtr;
|
|
*EndPtr = 0;
|
|
//
|
|
// Look through our list of known firmware volumes and see if we've
|
|
// already added it.
|
|
//
|
|
for (FvPtr = mFVList; FvPtr != NULL; FvPtr = FvPtr->Next) {
|
|
if (_stricmp (FvPtr->FVFileName, StartPtr) == 0) {
|
|
break;
|
|
}
|
|
}
|
|
//
|
|
// If we didn't find a match, then create a new one
|
|
//
|
|
if (FvPtr == NULL) {
|
|
FvPtr = MALLOC (sizeof (FV_LIST));
|
|
if (FvPtr == NULL) {
|
|
Error (__FILE__, __LINE__, 0, "application error", "memory allocation failed");
|
|
return ;
|
|
}
|
|
|
|
memset (FvPtr, 0, sizeof (FV_LIST));
|
|
strcpy (FvPtr->FVFileName, StartPtr);
|
|
if (mFVList == NULL) {
|
|
mFVList = FvPtr;
|
|
} else {
|
|
mFVListLast->Next = FvPtr;
|
|
}
|
|
|
|
mFVListLast = FvPtr;
|
|
}
|
|
//
|
|
// If this component's section number is higher than that of this
|
|
// FV, then set the FV's to it.
|
|
//
|
|
if (FvPtr->ComponentsInstance < ComponentsInstance) {
|
|
FvPtr->ComponentsInstance = ComponentsInstance;
|
|
}
|
|
//
|
|
// If we found then end of the FVs in the string, then we're done.
|
|
// Always restore the original string's contents.
|
|
//
|
|
if (SaveChar != 0) {
|
|
*EndPtr = SaveChar;
|
|
StartPtr = EndPtr + 1;
|
|
} else {
|
|
StartPtr = EndPtr;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static
|
|
BOOLEAN
|
|
OrderInFvList (
|
|
char *FvList,
|
|
char *FvName,
|
|
int *Order
|
|
)
|
|
{
|
|
//
|
|
// Given FvList of format "FV_a,FV_b,FV_c" or "FV_a:1,FV_b:2" and
|
|
// FvName of format "FV_c", determine if FvName is in FvList. If
|
|
// FV_a:1 format, then return the value after the colon.
|
|
//
|
|
while (*FvList) {
|
|
//
|
|
// If it matches for the length of FvName...
|
|
//
|
|
if (_strnicmp (FvList, FvName, strlen (FvName)) == 0) {
|
|
//
|
|
// Then see if the match string in FvList is terminated at the
|
|
// same length.
|
|
//
|
|
if ((FvList[strlen (FvName)] == ',') || (FvList[strlen (FvName)] == 0)) {
|
|
*Order = 0;
|
|
return TRUE;
|
|
} else if (FvList[strlen (FvName)] == ':') {
|
|
*Order = atoi (FvList + strlen (FvName) + 1);
|
|
return TRUE;
|
|
}
|
|
}
|
|
//
|
|
// Skip to next FV in the comma-separated list
|
|
//
|
|
while ((*FvList != ',') && (*FvList != 0)) {
|
|
FvList++;
|
|
}
|
|
//
|
|
// Skip over comma
|
|
//
|
|
if (*FvList == ',') {
|
|
FvList++;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static
|
|
char *
|
|
UpperCaseString (
|
|
char *Str
|
|
)
|
|
{
|
|
char *Cptr;
|
|
|
|
for (Cptr = Str; *Cptr; Cptr++) {
|
|
*Cptr = (char) toupper (*Cptr);
|
|
}
|
|
|
|
return Str;
|
|
}
|
|
|
|
static
|
|
BOOLEAN
|
|
InSameFv (
|
|
char *FVs1,
|
|
char *FVs2
|
|
)
|
|
{
|
|
char *StartCptr1;
|
|
char *StartCptr2;
|
|
char *EndCptr1;
|
|
char *EndCptr2;
|
|
char CSave1;
|
|
char CSave2;
|
|
|
|
//
|
|
// Process each FV in first FV list
|
|
//
|
|
StartCptr1 = FVs1;
|
|
while (*StartCptr1) {
|
|
EndCptr1 = StartCptr1;
|
|
while (*EndCptr1 && (*EndCptr1 != ',')) {
|
|
EndCptr1++;
|
|
}
|
|
|
|
CSave1 = *EndCptr1;
|
|
*EndCptr1 = 0;
|
|
|
|
if (*StartCptr1) {
|
|
//
|
|
// Process each FV in second FV list
|
|
//
|
|
StartCptr2 = FVs2;
|
|
while (*StartCptr2) {
|
|
EndCptr2 = StartCptr2;
|
|
while (*EndCptr2 && (*EndCptr2 != ',')) {
|
|
EndCptr2++;
|
|
}
|
|
|
|
CSave2 = *EndCptr2;
|
|
*EndCptr2 = 0;
|
|
|
|
if (_stricmp (StartCptr1, StartCptr2) == 0) {
|
|
*EndCptr1 = CSave1;
|
|
*EndCptr2 = CSave2;
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// Next FV on the second FV list
|
|
//
|
|
*EndCptr2 = CSave2;
|
|
StartCptr2 = EndCptr2;
|
|
if (*StartCptr2) {
|
|
StartCptr2++;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Next FV on the first FV list
|
|
//
|
|
*EndCptr1 = CSave1;
|
|
StartCptr1 = EndCptr1;
|
|
if (*StartCptr1) {
|
|
StartCptr1++;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
int
|
|
CFVSetXRefFileName (
|
|
char *FileName
|
|
)
|
|
{
|
|
mXRefFileName = FileName;
|
|
return 0;
|
|
}
|