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

821 lines
24 KiB
C
Raw Blame History

/*++
Copyright (c) 2004-2006 Intel Corporation. All rights reserved
This program and the accompanying materials are licensed and made available
under the terms and conditions of the BSD License which accompanies this
distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name:
FlashMap.c
Abstract:
Utility for flash management in the Intel Platform Innovation Framework
for EFI build environment.
--*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include <Common/UefiBaseTypes.h>
#include "EfiUtilityMsgs.h"
#include "Microcode.h"
#include "FlashDefFile.h"
#include "Symbols.h"
//
// Version of this utility
//
#define UTILITY_NAME "FlashMap"
#define UTILITY_MAJOR_VERSION 1
#define UTILITY_MINOR_VERSION 0
typedef struct _STRING_LIST {
struct _STRING_LIST *Next;
char *Str;
} STRING_LIST;
//
// Keep our globals in one of these structures
//
static struct {
char *CIncludeFileName;
char *FlashDevice;
char *FlashDeviceImage;
char *MCIFileName;
char *MCOFileName;
char *ImageOutFileName;
char *DscFileName;
char *AsmIncludeFileName;
char *FlashDefinitionFileName;
char *StringReplaceInFileName;
char *StringReplaceOutFileName;
char *DiscoverFDImageName;
char MicrocodePadByteValue;
unsigned int MicrocodeAlignment;
STRING_LIST *MCIFileNames;
STRING_LIST *LastMCIFileNames;
unsigned int BaseAddress;
} mGlobals;
#define DEFAULT_MC_PAD_BYTE_VALUE 0xFF
#define DEFAULT_MC_ALIGNMENT 16
static
STATUS
ProcessCommandLine (
int argc,
char *argv[]
);
static
STATUS
MergeMicrocodeFiles (
char *OutFileName,
STRING_LIST *FileNames,
unsigned int Alignment,
char PadByteValue
);
static
void
Version (
VOID
);
static
void
Usage (
VOID
);
char*
NormalizePath (
char* OldPathName
);
int
main (
int argc,
char *argv[]
)
/*++
Routine Description:
Parse the command line arguments and then call worker functions to do the work
Arguments:
argc - number of elements in argv
argv - array of command-line arguments
Returns:
STATUS_SUCCESS - no problems encountered while processing
STATUS_WARNING - warnings, but no errors, were encountered while processing
STATUS_ERROR - errors were encountered while processing
--*/
{
STATUS Status;
SetUtilityName (UTILITY_NAME);
Status = ProcessCommandLine (argc, argv);
if (Status != STATUS_SUCCESS) {
return Status;
}
//
// Check for discovery of an FD (command line option)
//
if (mGlobals.DiscoverFDImageName != NULL) {
Status = FDDiscover (mGlobals.DiscoverFDImageName, mGlobals.BaseAddress);
goto Done;
}
//
// If they're doing microcode file parsing, then do that
//
if (mGlobals.MCIFileName != NULL) {
MicrocodeConstructor ();
MicrocodeParseFile (mGlobals.MCIFileName, mGlobals.MCOFileName);
MicrocodeDestructor ();
}
//
// If they're doing microcode file merging, then do that now
//
if (mGlobals.MCIFileNames != NULL) {
MergeMicrocodeFiles (
mGlobals.MCOFileName,
mGlobals.MCIFileNames,
mGlobals.MicrocodeAlignment,
mGlobals.MicrocodePadByteValue
);
}
//
// If using a flash definition file, then process that and return
//
if (mGlobals.FlashDefinitionFileName != NULL) {
FDFConstructor ();
SymbolsConstructor ();
Status = FDFParseFile (mGlobals.FlashDefinitionFileName);
if (GetUtilityStatus () != STATUS_ERROR) {
//
// If they want us to do a string-replace on a file, then add the symbol definitions to
// the symbol table, and then do the string replace.
//
if (mGlobals.StringReplaceInFileName != NULL) {
Status = FDFCreateSymbols (mGlobals.FlashDevice);
Status = SymbolsFileStringsReplace (mGlobals.StringReplaceInFileName, mGlobals.StringReplaceOutFileName);
}
//
// If they want us to create a .h defines file or .c flashmap data file, then do so now
//
if (mGlobals.CIncludeFileName != NULL) {
Status = FDFCreateCIncludeFile (mGlobals.FlashDevice, mGlobals.CIncludeFileName);
}
if (mGlobals.AsmIncludeFileName != NULL) {
Status = FDFCreateAsmIncludeFile (mGlobals.FlashDevice, mGlobals.AsmIncludeFileName);
}
//
// If they want us to create an image, do that now
//
if (mGlobals.ImageOutFileName != NULL) {
Status = FDFCreateImage (mGlobals.FlashDevice, mGlobals.FlashDeviceImage, mGlobals.ImageOutFileName);
}
//
// If they want to create an output DSC file, do that now
//
if (mGlobals.DscFileName != NULL) {
Status = FDFCreateDscFile (mGlobals.FlashDevice, mGlobals.DscFileName);
}
}
SymbolsDestructor ();
FDFDestructor ();
}
Done:
//
// Free up memory
//
while (mGlobals.MCIFileNames != NULL) {
mGlobals.LastMCIFileNames = mGlobals.MCIFileNames->Next;
_free (mGlobals.MCIFileNames);
mGlobals.MCIFileNames = mGlobals.LastMCIFileNames;
}
return GetUtilityStatus ();
}
static
STATUS
MergeMicrocodeFiles (
char *OutFileName,
STRING_LIST *FileNames,
unsigned int Alignment,
char PadByteValue
)
/*++
Routine Description:
Merge binary microcode files into a single file, taking into consideration
the alignment and pad value.
Arguments:
OutFileName - name of the output file to create
FileNames - linked list of input microcode files to merge
Alignment - alignment for each microcode file in the output image
PadByteValue - value to use when padding to meet alignment requirements
Returns:
STATUS_SUCCESS - merge completed successfully or with acceptable warnings
STATUS_ERROR - merge failed, output file not created
--*/
{
long FileSize;
long TotalFileSize;
FILE *InFptr;
FILE *OutFptr;
char *Buffer;
STATUS Status;
//
// Open the output file
//
if ((OutFptr = fopen (OutFileName, "wb")) == NULL) {
Error (NULL, 0, 0, OutFileName, "failed to open output file for writing");
return STATUS_ERROR;
}
//
// Walk the list of files
//
Status = STATUS_ERROR;
Buffer = NULL;
InFptr = NULL;
TotalFileSize = 0;
while (FileNames != NULL) {
//
// Open the file, determine the size, then read it in and write
// it back out.
//
if ((InFptr = fopen (NormalizePath(FileNames->Str), "rb")) == NULL) {
Error (NULL, 0, 0, NormalizePath(FileNames->Str), "failed to open input file for reading");
goto Done;
}
fseek (InFptr, 0, SEEK_END);
FileSize = ftell (InFptr);
fseek (InFptr, 0, SEEK_SET);
if (FileSize != 0) {
Buffer = (char *) _malloc (FileSize);
if (Buffer == NULL) {
Error (NULL, 0, 0, "memory allocation failure", NULL);
goto Done;
}
if (fread (Buffer, FileSize, 1, InFptr) != 1) {
Error (NULL, 0, 0, FileNames->Str, "failed to read file contents");
goto Done;
}
//
// Align
//
if (Alignment != 0) {
while ((TotalFileSize % Alignment) != 0) {
if (fwrite (&PadByteValue, 1, 1, OutFptr) != 1) {
Error (NULL, 0, 0, OutFileName, "failed to write pad bytes to output file");
goto Done;
}
TotalFileSize++;
}
}
TotalFileSize += FileSize;
if (fwrite (Buffer, FileSize, 1, OutFptr) != 1) {
Error (NULL, 0, 0, OutFileName, "failed to write to output file");
goto Done;
}
_free (Buffer);
Buffer = NULL;
} else {
Warning (NULL, 0, 0, FileNames->Str, "0-size file encountered");
}
fclose (InFptr);
InFptr = NULL;
FileNames = FileNames->Next;
}
Status = STATUS_SUCCESS;
Done:
fclose (OutFptr);
if (InFptr != NULL) {
fclose (InFptr);
}
if (Buffer != NULL) {
_free (Buffer);
}
if (Status == STATUS_ERROR) {
remove (OutFileName);
}
return Status;
}
static
STATUS
ProcessCommandLine (
int argc,
char *argv[]
)
/*++
Routine Description:
Process the command line arguments
Arguments:
argc - Standard C entry point arguments
argv[] - Standard C entry point arguments
Returns:
STATUS_SUCCESS - no problems encountered while processing
STATUS_WARNING - warnings, but no errors, were encountered while processing
STATUS_ERROR - errors were encountered while processing
--*/
{
int ThingsToDo;
unsigned int Temp;
STRING_LIST *Str;
//
// Skip program name arg, process others
//
argc--;
argv++;
if (argc == 0) {
Usage ();
return STATUS_ERROR;
}
if ((strcmp(argv[0], "-h") == 0) || (strcmp(argv[0], "--help") == 0) ||
(strcmp(argv[0], "-?") == 0) || (strcmp(argv[0], "/?") == 0)) {
Usage();
return STATUS_ERROR;
}
if ((strcmp(argv[0], "-V") == 0) || (strcmp(argv[0], "--version") == 0)) {
Version();
return STATUS_ERROR;
}
//
// Clear out our globals, then start walking the arguments
//
memset ((void *) &mGlobals, 0, sizeof (mGlobals));
mGlobals.MicrocodePadByteValue = DEFAULT_MC_PAD_BYTE_VALUE;
mGlobals.MicrocodeAlignment = DEFAULT_MC_ALIGNMENT;
ThingsToDo = 0;
while (argc > 0) {
if (strcmp (argv[0], "-?") == 0) {
Usage ();
return STATUS_ERROR;
} else if (strcmp (argv[0], "-hfile") == 0) {
//
// -hfile FileName
//
// Used to specify an output C #include file to create that contains
// #define statements for all the flashmap region offsets and sizes.
// Check for additional argument.
//
if (argc < 2) {
Error (NULL, 0, 0, argv[0], "option requires an output file name");
return STATUS_ERROR;
}
argc--;
argv++;
mGlobals.CIncludeFileName = argv[0];
ThingsToDo++;
} else if (strcmp (argv[0], "-flashdevice") == 0) {
//
// -flashdevice FLASH_DEVICE_NAME
//
// Used to select which flash device definition to operate on.
// Check for additional argument
//
if (argc < 2) {
Error (NULL, 0, 0, argv[0], "option requires a flash device name to use");
return STATUS_ERROR;
}
argc--;
argv++;
mGlobals.FlashDevice = argv[0];
} else if (strcmp (argv[0], "-mco") == 0) {
//
// -mco OutFileName
//
// Used to specify a microcode output binary file to create.
// Check for additional argument.
//
if (argc < 2) {
Error (NULL, 0, 0, (INT8 *) argv[0], (INT8 *) "option requires an output microcode file name to create");
return STATUS_ERROR;
}
argc--;
argv++;
mGlobals.MCOFileName = argv[0];
ThingsToDo++;
} else if (strcmp (argv[0], "-asmincfile") == 0) {
//
// -asmincfile FileName
//
// Used to specify the name of the output assembly include file that contains
// equates for the flash region addresses and sizes.
// Check for additional argument.
//
if (argc < 2) {
Error (NULL, 0, 0, argv[0], "option requires an output ASM include file name to create");
return STATUS_ERROR;
}
argc--;
argv++;
mGlobals.AsmIncludeFileName = argv[0];
ThingsToDo++;
} else if (strcmp (argv[0], "-mci") == 0) {
//
// -mci FileName
//
// Used to specify an input microcode text file to parse.
// Check for additional argument
//
if (argc < 2) {
Error (NULL, 0, 0, (INT8 *) argv[0], (INT8 *) "option requires an input microcode text file name to parse");
return STATUS_ERROR;
}
argc--;
argv++;
mGlobals.MCIFileName = argv[0];
} else if (strcmp (argv[0], "-flashdeviceimage") == 0) {
//
// -flashdeviceimage FlashDeviceImage
//
// Used to specify which flash device image definition from the input flash definition file
// to create.
// Check for additional argument.
//
if (argc < 2) {
Error (NULL, 0, 0, argv[0], "option requires the name of a flash definition image to use");
return STATUS_ERROR;
}
argc--;
argv++;
mGlobals.FlashDeviceImage = argv[0];
} else if (strcmp (argv[0], "-imageout") == 0) {
//
// -imageout FileName
//
// Used to specify the name of the output FD image file to create.
// Check for additional argument.
//
if (argc < 2) {
Error (NULL, 0, 0, argv[0], "option requires an output image filename to create");
return STATUS_ERROR;
}
argc--;
argv++;
mGlobals.ImageOutFileName = argv[0];
ThingsToDo++;
} else if (strcmp (argv[0], "-dsc") == 0) {
//
// -dsc FileName
//
// Used to specify the name of the output DSC file to create.
// Check for additional argument.
//
if (argc < 2) {
Error (NULL, 0, 0, argv[0], "option requires an output DSC filename to create");
return STATUS_ERROR;
}
argc--;
argv++;
mGlobals.DscFileName = argv[0];
ThingsToDo++;
} else if (strcmp (argv[0], "-fdf") == 0) {
//
// -fdf FileName
//
// Used to specify the name of the input flash definition file.
// Check for additional argument.
//
if (argc < 2) {
Error (NULL, 0, 0, argv[0], "option requires an input flash definition file name");
return STATUS_ERROR;
}
argc--;
argv++;
mGlobals.FlashDefinitionFileName = argv[0];
} else if (strcmp (argv[0], "-discover") == 0) {
//
// -discover FDFileName
//
// Debug functionality used to scan an existing FD image, trying to find
// firmware volumes at 64K boundaries.
// Check for additional argument.
//
if (argc < 2) {
Error (NULL, 0, 0, argv[0], "option requires an input FD image file name");
return STATUS_ERROR;
}
argc--;
argv++;
mGlobals.DiscoverFDImageName = argv[0];
ThingsToDo++;
} else if (strcmp (argv[0], "-baseaddr") == 0) {
//
// -baseaddr Addr
//
// Used to specify a base address when doing a discover of an FD image.
// Check for additional argument.
//
if (argc < 2) {
Error (NULL, 0, 0, argv[0], "option requires a base address");
return STATUS_ERROR;
}
argc--;
argv++;
if (tolower (argv[0][1]) == 'x') {
sscanf (argv[0] + 2, "%x", &mGlobals.BaseAddress);
} else {
sscanf (argv[0], "%d", &mGlobals.BaseAddress);
}
} else if (strcmp (argv[0], "-padvalue") == 0) {
//
// -padvalue Value
//
// Used to specify the value to pad with when aligning data while
// creating an FD image. Check for additional argument.
//
if (argc < 2) {
Error (NULL, 0, 0, argv[0], "option requires a byte value");
return STATUS_ERROR;
}
argc--;
argv++;
if (tolower (argv[0][1]) == 'x') {
sscanf (argv[0] + 2, "%x", &Temp);
mGlobals.MicrocodePadByteValue = (char) Temp;
} else {
sscanf (argv[0], "%d", &Temp);
mGlobals.MicrocodePadByteValue = (char) Temp;
}
} else if (strcmp (argv[0], "-align") == 0) {
//
// -align Alignment
//
// Used to specify how each data file is aligned in the region
// when creating an FD image. Check for additional argument.
//
if (argc < 2) {
Error (NULL, 0, 0, argv[0], "option requires an alignment");
return STATUS_ERROR;
}
argc--;
argv++;
if (tolower (argv[0][1]) == 'x') {
sscanf (argv[0] + 2, "%x", &mGlobals.MicrocodeAlignment);
} else {
sscanf (argv[0], "%d", &mGlobals.MicrocodeAlignment);
}
} else if (strcmp (argv[0], "-mcmerge") == 0) {
//
// -mcmerge FileName(s)
//
// Used to concatenate multiple microde binary files. Can specify
// multiple file names with the one -mcmerge flag. Check for additional argument.
//
if ((argc < 2) || (argv[1][0] == '-')) {
Error (NULL, 0, 0, argv[0], "option requires one or more input file names");
return STATUS_ERROR;
}
//
// Take input files until another option or end of list
//
ThingsToDo++;
while ((argc > 1) && (argv[1][0] != '-')) {
Str = (STRING_LIST *) _malloc (sizeof (STRING_LIST));
if (Str == NULL) {
Error (NULL, 0, 0, "memory allocation failure", NULL);
return STATUS_ERROR;
}
memset (Str, 0, sizeof (STRING_LIST));
Str->Str = argv[1];
if (mGlobals.MCIFileNames == NULL) {
mGlobals.MCIFileNames = Str;
} else {
mGlobals.LastMCIFileNames->Next = Str;
}
mGlobals.LastMCIFileNames = Str;
argc--;
argv++;
}
} else if (strcmp (argv[0], "-strsub") == 0) {
//
// -strsub SrcFile DestFile
//
// Used to perform string substitutions on a file, writing the result to a new
// file. Check for two additional arguments.
//
if (argc < 3) {
Error (NULL, 0, 0, argv[0], "option requires input and output file names for string substitution");
return STATUS_ERROR;
}
argc--;
argv++;
mGlobals.StringReplaceInFileName = argv[0];
argc--;
argv++;
mGlobals.StringReplaceOutFileName = argv[0];
ThingsToDo++;
} else {
Error (NULL, 0, 0, argv[0], "invalid option");
return STATUS_ERROR;
}
argc--;
argv++;
}
//
// If no outputs requested, then report an error
//
if (ThingsToDo == 0) {
Error (NULL, 0, 0, "nothing to do", NULL);
return STATUS_ERROR;
}
//
// If they want an asm file, #include file, or C file to be created, then they have to specify a
// flash device name and flash definition file name.
//
if ((mGlobals.CIncludeFileName != NULL) &&
((mGlobals.FlashDevice == NULL) || (mGlobals.FlashDefinitionFileName == NULL))) {
Error (NULL, 0, 0, "must specify -flashdevice and -fdf with -hfile", NULL);
return STATUS_ERROR;
}
if ((mGlobals.AsmIncludeFileName != NULL) &&
((mGlobals.FlashDevice == NULL) || (mGlobals.FlashDefinitionFileName == NULL))) {
Error (NULL, 0, 0, "must specify -flashdevice and -fdf with -asmincfile", NULL);
return STATUS_ERROR;
}
//
// If they want a dsc file to be created, then they have to specify a
// flash device name and a flash definition file name
//
if (mGlobals.DscFileName != NULL) {
if (mGlobals.FlashDevice == NULL) {
Error (NULL, 0, 0, "must specify -flashdevice with -dsc", NULL);
return STATUS_ERROR;
}
if (mGlobals.FlashDefinitionFileName == NULL) {
Error (NULL, 0, 0, "must specify -fdf with -dsc", NULL);
return STATUS_ERROR;
}
}
//
// If they specified an output microcode file name, then they have to specify an input
// file name, and vice versa.
//
if ((mGlobals.MCIFileName != NULL) && (mGlobals.MCOFileName == NULL)) {
Error (NULL, 0, 0, "must specify output microcode file name", NULL);
return STATUS_ERROR;
}
if ((mGlobals.MCOFileName != NULL) && (mGlobals.MCIFileName == NULL) && (mGlobals.MCIFileNames == NULL)) {
Error (NULL, 0, 0, "must specify input microcode file name", NULL);
return STATUS_ERROR;
}
//
// If doing merge, then have to specify output file name
//
if ((mGlobals.MCIFileNames != NULL) && (mGlobals.MCOFileName == NULL)) {
Error (NULL, 0, 0, "must specify output microcode file name", NULL);
return STATUS_ERROR;
}
//
// If they want an output image to be created, then they have to specify
// the flash device and the flash device image to use.
//
if (mGlobals.ImageOutFileName != NULL) {
if (mGlobals.FlashDevice == NULL) {
Error (NULL, 0, 0, "must specify -flashdevice with -imageout", NULL);
return STATUS_ERROR;
}
if (mGlobals.FlashDeviceImage == NULL) {
Error (NULL, 0, 0, "must specify -flashdeviceimage with -imageout", NULL);
return STATUS_ERROR;
}
if (mGlobals.FlashDefinitionFileName == NULL) {
Error (NULL, 0, 0, "must specify -c or -fdf with -imageout", NULL);
return STATUS_ERROR;
}
}
return STATUS_SUCCESS;
}
static
void
Version (
VOID
)
/*++
Routine Description:
Print version information for this utility.
Arguments:
None.
Returns:
Nothing.
--*/
{
printf ("%s v%d.%d -EDK Utility for flash management for EFI build environment.\n", UTILITY_NAME, UTILITY_MAJOR_VERSION, UTILITY_MINOR_VERSION);
printf ("Copyright (c) 1999-2006 Intel Corporation. All rights reserved.\n");
}
static
void
Usage (
VOID
)
/*++
Routine Description:
Print utility command line help
Arguments:
None
Returns:
NA
--*/
{
int i;
char *Msg[] = {
"\nUsage: FlashTool -fdf FlashDefFile -flashdevice FlashDevice",
" -flashdeviceimage FlashDeviceImage -mci MCIFile -mco MCOFile",
" -discover FDImage -dsc DscFile -asmincfile AsmIncFile",
" -imageOut ImageOutFile -hfile HFile -strsub InStrFile OutStrFile",
" -baseaddr BaseAddr -align Alignment -padvalue PadValue",
" -mcmerge MCIFile(s)",
" -h,--help,-?,/? - to display help messages",
" -V,--version - to display version information",
" where",
" FlashDefFile - input Flash Definition File",
" FlashDevice - flash device to use (from flash definition file)",
" FlashDeviceImage - flash device image to use (from flash definition file)",
" MCIFile - input microcode file to parse",
" MCOFile - output binary microcode image to create from MCIFile",
" HFile - output #include file to create",
" FDImage - name of input FDImage file to scan",
" ImageOutFile - output image file to create",
" DscFile - output DSC file to create",
" AsmIncFile - output ASM include file to create",
" InStrFile - input file to replace symbol names, writing result to OutStrFile",
" BaseAddr - base address of FDImage (used with -discover)",
" Alignment - alignment to use when merging microcode binaries",
" PadValue - byte value to use as pad value when aligning microcode binaries",
" MCIFile(s) - one or more microcode binary files to merge/concatenate",
NULL
};
Version();
for (i = 0; Msg[i] != NULL; i++) {
fprintf (stdout, "%s\n", Msg[i]);
}
}
char*
NormalizePath (
char* OldPathName
)
{
char* Visitor;
if (OldPathName == NULL) {
return NULL;
}
Visitor = OldPathName;
while (*Visitor != '\0') {
if (*Visitor == '\\') {
*Visitor = '/';
}
Visitor++;
}
return OldPathName;
}
Reference in New Issue View Git Blame Copy Permalink