/*++ | |
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; | |
} | |