[mirror_edk2.git] / BaseTools / Source / C / GenVtf / GenVtf.c

/** @file\r
This file contains functions required to generate a boot strap file (BSF) also \r
known as the Volume Top File (VTF)\r
\r
Copyright (c) 1999 - 2016, Intel Corporation. All rights reserved.<BR>\r
This program and the accompanying materials are licensed and made available \r
under the terms and conditions of the BSD License which accompanies this \r
distribution.  The full text of the license may be found at\r
http://opensource.org/licenses/bsd-license.php\r
\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
**/\r
\r
//\r
//\r
//\r
#include <FvLib.h>\r
#include <Common/UefiBaseTypes.h>\r
#include "GenVtf.h"\r
#include <Guid/PiFirmwareFileSystem.h>\r
#include "CommonLib.h"\r
#include "EfiUtilityMsgs.h"\r
\r
//\r
// Global variables\r
//\r
UINTN SectionOptionFlag = 0;\r
UINTN SectionCompFlag = 0;\r
\r
UINT64        DebugLevel;\r
BOOLEAN       DebugMode;\r
\r
BOOLEAN     QuietMode = FALSE;\r
\r
BOOLEAN     VTF_OUTPUT = FALSE;\r
CHAR8       *OutFileName1;\r
CHAR8       *OutFileName2;\r
CHAR8       *SymFileName;\r
\r
CHAR8           **TokenStr;\r
CHAR8           **OrgStrTokPtr;\r
\r
PARSED_VTF_INFO *FileListPtr;\r
PARSED_VTF_INFO *FileListHeadPtr;\r
\r
VOID            *Vtf1Buffer;\r
VOID            *Vtf1EndBuffer;\r
VOID            *Vtf2Buffer;\r
VOID            *Vtf2EndBuffer;\r
\r
UINTN           ValidLineNum        = 0;\r
UINTN           ValidFFDFileListNum = 0;\r
\r
//\r
// Section Description and their number of occurences in *.INF file\r
//\r
UINTN           NumFvFiles        = 0;\r
UINTN           SectionOptionNum  = 0;\r
\r
//\r
// Global flag which will check for VTF Present, if yes then will be used\r
// to decide about adding FFS header to pad data\r
//\r
BOOLEAN         VTFPresent = FALSE;\r
BOOLEAN         SecondVTF = FALSE;\r
\r
//\r
// Address related information\r
//\r
UINT64          Fv1BaseAddress        = 0;\r
UINT64          Fv2BaseAddress        = 0;\r
UINT64          Fv1EndAddress         = 0;\r
UINT64          Fv2EndAddress         = 0;\r
UINT32          Vtf1TotalSize         = SIZE_TO_OFFSET_PAL_A_END;\r
UINT64          Vtf1LastStartAddress  = 0;\r
UINT32          Vtf2TotalSize         = 0;\r
UINT64          Vtf2LastStartAddress  = 0;\r
\r
UINT32          BufferToTop           = 0;\r
\r
//\r
// IA32 Reset Vector Bin name\r
//\r
CHAR8           IA32BinFile[FILE_NAME_SIZE];\r
\r
//\r
// Function Implementations\r
//\r
EFI_STATUS\r
ConvertVersionInfo (\r
  IN      CHAR8     *Str,\r
  IN OUT  UINT8     *MajorVer,\r
  IN OUT  UINT8     *MinorVer\r
  )\r
/*++\r
Routine Description:\r
\r
  This function split version to major version and minor version\r
\r
Arguments:\r
\r
  Str      - String representing in form XX.XX\r
  MajorVer - The major version\r
  MinorVer - The minor version\r
\r
Returns:\r
\r
  EFI_SUCCESS  - The function completed successfully.\r
\r
--*/\r
{\r
  CHAR8  TemStr[5] = "0000";\r
  int    Major;\r
  int    Minor;\r
  UINTN Length;\r
\r
  Major = 0;\r
  Minor = 0;\r
\r
  if (strstr (Str, ".") != NULL) {\r
    sscanf (\r
      Str,\r
      "%02x.%02x",\r
      &Major,\r
      &Minor\r
      );\r
  } else {\r
    Length = strlen(Str);\r
    if (Length < 4) {\r
      strncpy (TemStr + 4 - Length, Str, Length);\r
    } else {\r
      strncpy (TemStr, Str + Length - 4, 4);\r
    }\r
  \r
    sscanf (\r
      TemStr,\r
      "%02x%02x",\r
      &Major,\r
      &Minor\r
      );\r
  }\r
\r
  *MajorVer = (UINT8) Major;\r
  *MinorVer = (UINT8) Minor;\r
  return EFI_SUCCESS;\r
}\r
\r
VOID\r
TrimLine (\r
  IN  CHAR8 *Line\r
  )\r
/*++\r
Routine Description:\r
\r
  This function cleans up the line by removing all whitespace and\r
  comments\r
\r
Arguments:\r
\r
  Line   - The pointer of the string\r
\r
Returns:\r
\r
  None\r
\r
--*/\r
{\r
  CHAR8 TmpLine[FILE_NAME_SIZE];\r
  CHAR8 Char;\r
  CHAR8 *Ptr0;\r
  UINTN Index;\r
  UINTN Index2;\r
\r
  //\r
  // Change '#' to '//' for Comment style\r
  //\r
  if (((Ptr0 = strchr (Line, '#')) != NULL) || ((Ptr0 = strstr (Line, "//")) != NULL)) {\r
    Line[Ptr0 - Line] = 0;\r
  }\r
\r
  //\r
  // Initialize counters\r
  //\r
  Index   = 0;\r
  Index2  = 0;\r
\r
  while ((Char = Line[Index]) != 0) {\r
    if ((Char != ' ') && (Char != '\t') && (Char != '\n') && (Char != '\r')) {\r
      TmpLine[Index2++] = Char;\r
    }\r
    Index++;\r
  }\r
\r
  TmpLine[Index2] = 0;\r
  strcpy (Line, TmpLine);\r
}\r
\r
VOID\r
ValidLineCount (\r
  IN  FILE *Fp\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  This function calculated number of valid lines in a input file.\r
\r
Arguments:\r
\r
  Fp    - Pointer to a file handle which has been opened.\r
\r
Returns:\r
\r
  None\r
\r
--*/\r
{\r
  CHAR8 Buff[FILE_NAME_SIZE];\r
  while (fgets(Buff, sizeof (Buff), Fp)) {\r
    TrimLine (Buff);\r
    if (Buff[0] == 0) {\r
      continue;\r
    }\r
    ValidLineNum++;\r
  }\r
}\r
\r
EFI_STATUS\r
ParseInputFile (\r
  IN  FILE *Fp\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  This function parses the input file and tokenize the string\r
\r
Arguments:\r
\r
  Fp    - Pointer to a file handle which has been opened.\r
\r
Returns:\r
\r
  None\r
\r
--*/\r
{\r
  CHAR8 *Token;\r
  CHAR8 Buff[FILE_NAME_SIZE + 1];\r
  CHAR8 Delimit[] = "=";\r
\r
  Buff [FILE_NAME_SIZE] = '\0';\r
  Token = NULL;\r
\r
  while (fgets (Buff, FILE_NAME_SIZE, Fp) != NULL) {\r
    TrimLine (Buff);\r
    if (Buff[0] == 0) {\r
      continue;\r
    }\r
    Token = strtok (Buff, Delimit);\r
    while (Token != NULL) {\r
      strcpy (*TokenStr, Token);\r
      TokenStr ++;\r
      Token = strtok (NULL, Delimit);\r
    }\r
  }\r
  return EFI_SUCCESS;\r
}\r
\r
EFI_STATUS\r
InitializeComps (\r
  VOID\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  This function initializes the relevant global variable which is being\r
  used to store the information retrieved from INF file.  This also initializes\r
  the VTF symbol file.\r
\r
Arguments:\r
\r
  None\r
\r
Returns:\r
\r
  EFI_SUCCESS            - The function completed successfully\r
  EFI_OUT_OF_RESOURCES   - Malloc failed.\r
\r
--*/\r
{\r
\r
  FileListPtr = malloc (sizeof (PARSED_VTF_INFO));\r
\r
  if (FileListPtr == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  FileListHeadPtr = FileListPtr;\r
  memset (FileListPtr, 0, sizeof (PARSED_VTF_INFO));\r
  FileListPtr->NextVtfInfo = NULL;\r
\r
  remove (SymFileName);\r
  return EFI_SUCCESS;\r
}\r
\r
VOID\r
ParseAndUpdateComponents (\r
  IN  PARSED_VTF_INFO   *VtfInfo\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  This function initializes the relevant global variable which is being\r
  used to store the information retrieved from INF file.\r
\r
Arguments:\r
\r
  VtfInfo  - A pointer to the VTF Info Structure\r
\r
\r
Returns:\r
\r
  None\r
\r
--*/\r
{\r
  UINT64  StringValue;\r
\r
  while (*TokenStr != NULL && (strnicmp (*TokenStr, "COMP_NAME", 9) != 0)) {\r
\r
    if (strnicmp (*TokenStr, "COMP_LOC", 8) == 0) {\r
      TokenStr++;\r
      if (strnicmp (*TokenStr, "F", 1) == 0) {\r
        VtfInfo->LocationType = FIRST_VTF;\r
      } else if (strnicmp (*TokenStr, "S", 1) == 0) {\r
        VtfInfo->LocationType = SECOND_VTF;\r
      } else {\r
        VtfInfo->LocationType = NONE;\r
      }\r
    } else if (strnicmp (*TokenStr, "COMP_TYPE", 9) == 0) {\r
      TokenStr++;\r
      if (AsciiStringToUint64 (*TokenStr, FALSE, &StringValue) != EFI_SUCCESS) {\r
        Error (NULL, 0, 5001, "Cannot get: \"0x%s\".", *TokenStr);\r
        return ;\r
      }\r
\r
      VtfInfo->CompType = (UINT8) StringValue;\r
    } else if (strnicmp (*TokenStr, "COMP_VER", 8) == 0) {\r
      TokenStr++;\r
      if (strnicmp (*TokenStr, "-", 1) == 0) {\r
        VtfInfo->VersionPresent = FALSE;\r
        VtfInfo->MajorVer       = 0;\r
        VtfInfo->MinorVer       = 0;\r
      } else {\r
        VtfInfo->VersionPresent = TRUE;\r
        ConvertVersionInfo (*TokenStr, &VtfInfo->MajorVer, &VtfInfo->MinorVer);\r
      }\r
    } else if (strnicmp (*TokenStr, "COMP_BIN", 8) == 0) {\r
      TokenStr++;\r
      strcpy (VtfInfo->CompBinName, *TokenStr);\r
    } else if (strnicmp (*TokenStr, "COMP_SYM", 8) == 0) {\r
      TokenStr++;\r
      strcpy (VtfInfo->CompSymName, *TokenStr);\r
    } else if (strnicmp (*TokenStr, "COMP_SIZE", 9) == 0) {\r
      TokenStr++;\r
      if (strnicmp (*TokenStr, "-", 1) == 0) {\r
        VtfInfo->PreferredSize  = FALSE;\r
        VtfInfo->CompSize       = 0;\r
      } else {\r
        VtfInfo->PreferredSize = TRUE;\r
        if (AsciiStringToUint64 (*TokenStr, FALSE, &StringValue) != EFI_SUCCESS) {\r
          Error (NULL, 0, 5001, "Parse error", "Cannot get: %s.", TokenStr);\r
          return ;\r
        }\r
\r
        VtfInfo->CompSize = (UINTN) StringValue;\r
      }\r
\r
    } else if (strnicmp (*TokenStr, "COMP_CS", 7) == 0) {\r
      TokenStr++;\r
      if (strnicmp (*TokenStr, "1", 1) == 0) {\r
        VtfInfo->CheckSumRequired = 1;\r
      } else if (strnicmp (*TokenStr, "0", 1) == 0) {\r
        VtfInfo->CheckSumRequired = 0;\r
      } else {\r
        Error (NULL, 0, 3000, "Invaild", "Bad value in INF file required field: Checksum, the value must be '0' or '1'.");\r
      }\r
    }\r
\r
    TokenStr++;\r
    if (*TokenStr == NULL) {\r
      break;\r
    }\r
  }\r
}\r
\r
VOID\r
InitializeInFileInfo (\r
  VOID\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  This function intializes the relevant global variable which is being\r
  used to store the information retrieved from INF file.\r
\r
Arguments:\r
\r
  NONE\r
\r
Returns:\r
\r
  NONE\r
\r
--*/\r
{\r
\r
  SectionOptionFlag = 0;\r
  SectionCompFlag   = 0;\r
  TokenStr          = OrgStrTokPtr;\r
\r
  while (*TokenStr != NULL) {\r
    if (strnicmp (*TokenStr, "[OPTIONS]", 9) == 0) {\r
      SectionOptionFlag = 1;\r
      SectionCompFlag   = 0;\r
    }\r
\r
    if (strnicmp (*TokenStr, "[COMPONENTS]", 12) == 0) {\r
      if (FileListPtr == NULL) {\r
        FileListPtr = FileListHeadPtr;\r
      }\r
\r
      SectionCompFlag   = 1;\r
      SectionOptionFlag = 0;\r
      TokenStr++;\r
    }\r
\r
    if (SectionOptionFlag) {\r
      if (stricmp (*TokenStr, "IA32_RST_BIN") == 0) {\r
        TokenStr++;\r
        strcpy (IA32BinFile, *TokenStr);\r
      }\r
    }\r
\r
    if (SectionCompFlag) {\r
      if (stricmp (*TokenStr, "COMP_NAME") == 0) {\r
        TokenStr++;\r
        strcpy (FileListPtr->CompName, *TokenStr);\r
        TokenStr++;\r
        ParseAndUpdateComponents (FileListPtr);\r
      }\r
\r
      if (*TokenStr != NULL) {\r
        FileListPtr->NextVtfInfo  = malloc (sizeof (PARSED_VTF_INFO));\r
        if (FileListPtr->NextVtfInfo == NULL) {\r
          Error (NULL, 0, 4003, "Resource", "Out of memory resources.", NULL);\r
          break;\r
        }\r
        FileListPtr = FileListPtr->NextVtfInfo;\r
        memset (FileListPtr, 0, sizeof (PARSED_VTF_INFO));\r
        FileListPtr->NextVtfInfo = NULL;\r
        continue;\r
      } else {\r
        break;\r
      }\r
    }\r
\r
    TokenStr++;\r
  }\r
}\r
\r
EFI_STATUS\r
GetVtfRelatedInfoFromInfFile (\r
  IN FILE *FilePointer\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  This function reads the input file, parse it and create a list of tokens\r
  which is parsed and used, to intialize the data related to VTF\r
\r
Arguments:\r
\r
  FileName  - FileName which needed to be read to parse data\r
\r
Returns:\r
\r
  EFI_ABORTED           - Error in opening file\r
  EFI_INVALID_PARAMETER - File doesn't contain any valid information\r
  EFI_OUT_OF_RESOURCES  - Malloc Failed\r
  EFI_SUCCESS           - The function completed successfully\r
\r
--*/\r
{\r
  FILE        *Fp;\r
  UINTN       Index;\r
  UINTN       Index1;\r
  EFI_STATUS  Status;\r
\r
  Status = EFI_SUCCESS;\r
  Fp = FilePointer;\r
  if (Fp == NULL) {\r
    Error (NULL, 0, 2000, "Invalid parameter", "BSF INF file is invalid!");\r
    return EFI_ABORTED;\r
  }\r
\r
  ValidLineCount (Fp);\r
\r
  if (ValidLineNum == 0) {\r
    Error (NULL, 0, 2000, "Invalid parameter", "File does not contain any valid information!");\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  TokenStr = (CHAR8 **) malloc (sizeof (UINTN) * (2 * ValidLineNum + 1));\r
\r
  if (TokenStr == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  memset (TokenStr, 0, (sizeof (UINTN) * (2 * ValidLineNum + 1)));\r
  OrgStrTokPtr = TokenStr;\r
\r
  for (Index = 0; Index < (2 * ValidLineNum); Index++) {\r
    *TokenStr = (CHAR8*)malloc (sizeof (CHAR8) * FILE_NAME_SIZE);\r
\r
    if (*TokenStr == NULL) {\r
      Status = EFI_OUT_OF_RESOURCES;\r
      goto ParseFileError;\r
    }\r
\r
    memset (*TokenStr, 0, FILE_NAME_SIZE);\r
    TokenStr++;\r
  }\r
\r
  TokenStr  = OrgStrTokPtr;\r
  fseek (Fp, 0L, SEEK_SET);\r
\r
  Status = InitializeComps ();\r
\r
  if (Status != EFI_SUCCESS) {\r
    goto ParseFileError;\r
  }\r
\r
  Status = ParseInputFile (Fp);\r
  if (Status != EFI_SUCCESS) {\r
    goto ParseFileError;\r
  }\r
\r
  InitializeInFileInfo ();\r
\r
ParseFileError:\r
\r
  for (Index1 = 0; Index1 < Index; Index1 ++) {\r
    free (OrgStrTokPtr[Index1]);\r
  }\r
\r
  free (OrgStrTokPtr);\r
\r
  return Status;\r
}\r
\r
VOID\r
GetRelativeAddressInVtfBuffer (\r
  IN      UINT64     Address,\r
  IN OUT  UINTN      *RelativeAddress,\r
  IN      LOC_TYPE   LocType\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  This function checks for the address alignmnet for specified data boundary. In\r
  case the address is not aligned, it returns FALSE and the amount of data in\r
  terms of byte needed to adjust to get the boundary alignmnet. If data is\r
  aligned, TRUE will be returned.\r
\r
Arguments:\r
\r
  Address             - The address of the flash map space\r
  RelativeAddress     - The relative address of the Buffer\r
  LocType             - The type of the VTF\r
\r
\r
Returns:\r
\r
\r
--*/\r
{\r
  UINT64  TempAddress;\r
  UINT8   *LocalBuff;\r
\r
  if (LocType == FIRST_VTF) {\r
    LocalBuff         = (UINT8 *) Vtf1EndBuffer;\r
    TempAddress       = Fv1EndAddress - Address;\r
    *RelativeAddress  = (UINTN) LocalBuff - (UINTN) TempAddress;\r
  } else {\r
    LocalBuff         = (UINT8 *) Vtf2EndBuffer;\r
    TempAddress       = Fv2EndAddress - Address;\r
    *RelativeAddress  = (UINTN) LocalBuff - (UINTN) TempAddress;\r
  }\r
}\r
\r
EFI_STATUS\r
GetComponentVersionInfo (\r
  IN  OUT PARSED_VTF_INFO   *VtfInfo,\r
  IN      UINT8             *Buffer\r
  )\r
/*++\r
Routine Description:\r
\r
  This function will extract the version information from File\r
\r
Arguments:\r
\r
  VtfInfo  - A Pointer to the VTF Info Structure\r
  Buffer   - A Pointer to type UINT8\r
\r
Returns:\r
\r
   EFI_SUCCESS           - The function completed successfully\r
   EFI_INVALID_PARAMETER - The parameter is invalid\r
\r
--*/\r
{\r
  UINT16      VersionInfo;\r
  EFI_STATUS  Status;\r
\r
  switch (VtfInfo->CompType) {\r
\r
  case COMP_TYPE_FIT_PAL_A:\r
  case COMP_TYPE_FIT_PAL_B:\r
    memcpy (&VersionInfo, (Buffer + 8), sizeof (UINT16));\r
    VtfInfo->MajorVer = (UINT8) ((VersionInfo & 0xFF00) >> 8);\r
    VtfInfo->MinorVer = (UINT8) (VersionInfo & 0x00FF);\r
    Status            = EFI_SUCCESS;\r
    break;\r
\r
  default:\r
    Status = EFI_INVALID_PARAMETER;\r
    break;\r
  }\r
\r
  return Status;\r
}\r
\r
BOOLEAN\r
CheckAddressAlignment (\r
  IN      UINT64  Address,\r
  IN      UINT64  AlignmentData,\r
  IN OUT  UINT64  *AlignAdjustByte\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  This function checks for the address alignmnet for specified data boundary. In\r
  case the address is not aligned, it returns FALSE and the amount of data in\r
  terms of byte needed to adjust to get the boundary alignmnet. If data is\r
  aligned, TRUE will be returned.\r
\r
Arguments:\r
\r
  Address              - Pointer to buffer containing byte data of component.\r
  AlignmentData        - DataSize for which address needed to be aligned\r
  AlignAdjustByte      - Number of bytes needed to adjust alignment.\r
\r
Returns:\r
\r
  TRUE                 - Address is aligned to specific data size boundary\r
  FALSE                - Address in not aligned to specified data size boundary\r
                       - Add/Subtract AlignAdjustByte to aling the address.\r
\r
--*/\r
{\r
  //\r
  // Check if the assigned address is on address boundary. If not, it will\r
  // return the remaining byte required to adjust the address for specified\r
  // address boundary\r
  //\r
  *AlignAdjustByte = (Address % AlignmentData);\r
\r
  if (*AlignAdjustByte == 0) {\r
    return TRUE;\r
  } else {\r
    return FALSE;\r
  }\r
}\r
\r
EFI_STATUS\r
GetFitTableStartAddress (\r
  IN OUT  FIT_TABLE   **FitTable\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Get the FIT table start address in VTF Buffer\r
\r
Arguments:\r
\r
  FitTable    - Pointer to available fit table where new component can be added\r
\r
Returns:\r
\r
  EFI_SUCCESS - The function completed successfully\r
\r
--*/\r
{\r
  UINT64  FitTableAdd;\r
  UINT64  FitTableAddOffset;\r
  UINTN   RelativeAddress;\r
\r
  //\r
  // Read the Fit Table address from Itanium-based address map.\r
  //\r
  FitTableAddOffset = Fv1EndAddress - (SIZE_IA32_RESET_VECT + SIZE_SALE_ENTRY_POINT + SIZE_FIT_TABLE_ADD);\r
\r
  //\r
  // Translate this Itanium-based address in terms of local buffer address which\r
  // contains the image for Boot Strapped File. The relative address will be\r
  // the address of fit table VTF buffer.\r
  //\r
  GetRelativeAddressInVtfBuffer (FitTableAddOffset, &RelativeAddress, FIRST_VTF);\r
  FitTableAdd = *(UINTN *) RelativeAddress;\r
\r
  //\r
  // The FitTableAdd is the extracted Itanium based address pointing to FIT\r
  // table. The relative address will return its actual location in VTF\r
  // Buffer.\r
  //\r
  GetRelativeAddressInVtfBuffer (FitTableAdd, &RelativeAddress, FIRST_VTF);\r
\r
  *FitTable = (FIT_TABLE *) RelativeAddress;\r
\r
  return EFI_SUCCESS;\r
}\r
\r
EFI_STATUS\r
GetNextAvailableFitPtr (\r
  IN  FIT_TABLE   **FitPtr\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Get the FIT table address and locate the free space in fit where we can add\r
  new component. In this process, this function locates the fit table using\r
  Fit pointer in Itanium-based address map (as per Intel?Itanium(TM) SAL spec)\r
  and locate the available location in FIT table to be used by new components.\r
  If there are any Fit table which areg not being used contains ComponentType\r
  field as 0x7F. If needed we can change this and spec this out.\r
\r
Arguments:\r
\r
  FitPtr    - Pointer to available fit table where new component can be added\r
\r
Returns:\r
\r
  EFI_SUCCESS  - The function completed successfully\r
\r
--*/\r
{\r
  FIT_TABLE *TmpFitPtr;\r
  UINT64    FitTableAdd;\r
  UINT64    FitTableAddOffset;\r
  UINTN     Index;\r
  UINTN     NumFitComponents;\r
  UINTN     RelativeAddress;\r
\r
  //\r
  // Read the Fit Table address from Itanium-based address map.\r
  //\r
  FitTableAddOffset = Fv1EndAddress - (SIZE_IA32_RESET_VECT + SIZE_SALE_ENTRY_POINT + SIZE_FIT_TABLE_ADD);\r
\r
  //\r
  // Translate this Itanium-based address in terms of local buffer address which\r
  // contains the image for Boot Strapped File. The relative address will be\r
  // the address of fit table VTF buffer.\r
  //\r
  GetRelativeAddressInVtfBuffer (FitTableAddOffset, &RelativeAddress, FIRST_VTF);\r
  FitTableAdd = *(UINTN *) RelativeAddress;\r
\r
  //\r
  // The FitTableAdd is the extracted Itanium based address pointing to FIT\r
  // table. The relative address will return its actual location in VTF\r
  // Buffer.\r
  //\r
  GetRelativeAddressInVtfBuffer (FitTableAdd, &RelativeAddress, FIRST_VTF);\r
\r
  TmpFitPtr         = (FIT_TABLE *) RelativeAddress;\r
  NumFitComponents  = TmpFitPtr->CompSize;\r
  *FitPtr           = NULL;\r
\r
  for (Index = 0; Index < NumFitComponents; Index++) {\r
    if ((TmpFitPtr->CvAndType & FIT_TYPE_MASK) == COMP_TYPE_FIT_UNUSED) {\r
      *FitPtr = TmpFitPtr;\r
      break;\r
    }\r
\r
    TmpFitPtr++;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
int\r
CompareItems (\r
  IN const VOID  *Arg1,\r
  IN const VOID  *Arg2\r
  )\r
/*++\r
\r
Routine Description:\r
\r
    This function is used by qsort to sort the FIT table based upon Component\r
    Type in their incresing order.\r
\r
Arguments:\r
\r
    Arg1  -   Pointer to Arg1\r
    Arg2  -   Pointer to Arg2\r
\r
Returns:\r
\r
    None\r
\r
--*/\r
{\r
  if ((((FIT_TABLE *) Arg1)->CvAndType & FIT_TYPE_MASK) > (((FIT_TABLE *) Arg2)->CvAndType & FIT_TYPE_MASK)) {\r
    return 1;\r
  } else if ((((FIT_TABLE *) Arg1)->CvAndType & FIT_TYPE_MASK) < (((FIT_TABLE *) Arg2)->CvAndType & FIT_TYPE_MASK)) {\r
    return -1;\r
  } else {\r
    return 0;\r
  }\r
}\r
\r
VOID\r
SortFitTable (\r
  IN  VOID\r
  )\r
/*++\r
\r
Routine Description:\r
\r
    This function is used by qsort to sort the FIT table based upon Component\r
    Type in their incresing order.\r
\r
Arguments:\r
\r
    VOID\r
\r
Returns:\r
\r
    None\r
\r
--*/\r
{\r
  FIT_TABLE *FitTable;\r
  FIT_TABLE *TmpFitPtr;\r
  UINTN     NumFitComponents;\r
  UINTN     Index;\r
\r
  GetFitTableStartAddress (&FitTable);\r
  TmpFitPtr         = FitTable;\r
  NumFitComponents  = 0;\r
  for (Index = 0; Index < FitTable->CompSize; Index++) {\r
    if ((TmpFitPtr->CvAndType & FIT_TYPE_MASK) != COMP_TYPE_FIT_UNUSED) {\r
      NumFitComponents += 1;\r
    }\r
    TmpFitPtr++;\r
  }\r
  qsort ((VOID *) FitTable, NumFitComponents, sizeof (FIT_TABLE), CompareItems);\r
}\r
\r
VOID\r
UpdateFitEntryForFwVolume (\r
  IN  UINT64  Size\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  This function updates the information about Firmware Volume  in FIT TABLE.\r
  This FIT table has to be immediately below the PAL_A Start and it contains\r
  component type and address information. Other information can't be\r
  created this time so we would need to fix it up..\r
\r
\r
Arguments:\r
\r
  Size   - Firmware Volume Size\r
\r
Returns:\r
\r
  VOID\r
\r
--*/\r
{\r
  FIT_TABLE *CompFitPtr;\r
  UINTN     RelativeAddress;\r
\r
  //\r
  // FV Fit table will be located at PAL_A Startaddress - 16 byte location\r
  //\r
  Vtf1LastStartAddress -= 0x10;\r
  Vtf1TotalSize += 0x10;\r
\r
  GetRelativeAddressInVtfBuffer (Vtf1LastStartAddress, &RelativeAddress, FIRST_VTF);\r
\r
  CompFitPtr              = (FIT_TABLE *) RelativeAddress;\r
  CompFitPtr->CompAddress = Fv1BaseAddress;\r
\r
  //\r
  // Since we don't have any information about its location in Firmware Volume,\r
  // initialize address to 0. This will be updated once Firmware Volume is\r
  // being build and its current address will be fixed in FIT table. Currently\r
  // we haven't implemented it so far and working on architectural clarafication\r
  //\r
  //\r
  // Firmware Volume Size in 16 byte block\r
  //\r
  CompFitPtr->CompSize = ((UINT32) Size) / 16;\r
\r
  //\r
  // Since Firmware Volume does not exist by the time we create this FIT info\r
  // this should be fixedup from Firmware Volume creation tool. We haven't\r
  // worked out a method so far.\r
  //\r
  CompFitPtr->CompVersion = MAKE_VERSION (0, 0);\r
\r
  //\r
  // Since we don't have any info about this file, we are making sure that\r
  // checksum is not needed.\r
  //\r
  CompFitPtr->CvAndType = CV_N_TYPE (0, COMP_TYPE_FIT_FV_BOOT);\r
\r
  //\r
  // Since non VTF component will reside outside the VTF, we will not have its\r
  // binary image while creating VTF, hence we will not perform checksum at\r
  // this time. Once Firmware Volume is being created which will contain this\r
  // VTF, it will fix the FIT table for all the non VTF component and hence\r
  // checksum\r
  //\r
  CompFitPtr->CheckSum = 0;\r
}\r
\r
EFI_STATUS\r
UpdateFitEntryForNonVTFComp (\r
  IN  PARSED_VTF_INFO   *VtfInfo\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  This function updates the information about non VTF component in FIT TABLE.\r
  Since non VTF componets binaries are not part of VTF binary, we would still\r
  be required to update its location information in Firmware Volume, inside\r
  FIT table.\r
\r
Arguments:\r
\r
  VtfInfo    - Pointer to VTF Info Structure\r
\r
Returns:\r
\r
  EFI_ABORTED  - The function fails to update the component in FIT\r
  EFI_SUCCESS  - The function completed successfully\r
\r
--*/\r
{\r
  FIT_TABLE *CompFitPtr;\r
\r
  //\r
  // Scan the FIT table for available space\r
  //\r
  GetNextAvailableFitPtr (&CompFitPtr);\r
  if (CompFitPtr == NULL) {\r
    Error (NULL, 0, 5003, "Invalid", "Can't update this component in FIT");\r
    return EFI_ABORTED;\r
  }\r
\r
  //\r
  // Since we don't have any information about its location in Firmware Volume,\r
  // initialize address to 0. This will be updated once Firmware Volume is\r
  // being build and its current address will be fixed in FIT table\r
  //\r
  CompFitPtr->CompAddress = 0;\r
  CompFitPtr->CompSize    = VtfInfo->CompSize;\r
  CompFitPtr->CompVersion = MAKE_VERSION (VtfInfo->MajorVer, VtfInfo->MinorVer);\r
  CompFitPtr->CvAndType   = CV_N_TYPE (VtfInfo->CheckSumRequired, VtfInfo->CompType);\r
\r
  //\r
  // Since non VTF component will reside outside the VTF, we will not have its\r
  // binary image while creating VTF, hence we will not perform checksum at\r
  // this time. Once Firmware Volume is being created which will contain this\r
  // VTF, it will fix the FIT table for all the non VTF component and hence\r
  // checksum\r
  //\r
  CompFitPtr->CheckSum = 0;\r
\r
  //\r
  // Fit Type is FV_BOOT which means Firmware Volume, we initialize this to base\r
  // address of Firmware Volume in which this VTF will be attached.\r
  //\r
  if ((CompFitPtr->CvAndType & 0x7F) == COMP_TYPE_FIT_FV_BOOT) {\r
    CompFitPtr->CompAddress = Fv1BaseAddress;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
//\r
// !!!WARNING\r
// This function is updating the SALE_ENTRY in Itanium address space as per SAL\r
// spec. SALE_ENTRY is being read from SYM file of PEICORE. Once the PEI\r
// CORE moves in Firmware Volume, we would need to modify this function to be\r
// used with a API which will detect PEICORE component while building Firmware\r
// Volume and update its entry in FIT table as well as in Itanium address space\r
// as per Intel?Itanium(TM) SAL address space\r
//\r
EFI_STATUS\r
UpdateEntryPoint (\r
  IN  PARSED_VTF_INFO   *VtfInfo,\r
  IN  UINT64            *CompStartAddress\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  This function updated the architectural entry point in IPF, SALE_ENTRY.\r
\r
Arguments:\r
\r
  VtfInfo            - Pointer to VTF Info Structure\r
  CompStartAddress   - Pointer to Component Start Address\r
\r
Returns:\r
\r
  EFI_INVALID_PARAMETER  - The parameter is invalid\r
  EFI_OUT_OF_RESOURCES   - Resource can not be allocated\r
  EFI_SUCCESS            - The function completed successfully\r
\r
--*/\r
{\r
  UINTN   RelativeAddress;\r
  UINT64  SalEntryAdd;\r
  FILE    *Fp;\r
  UINTN   Offset;\r
\r
  CHAR8   Buff[FILE_NAME_SIZE];\r
  CHAR8   Buff1[10];\r
  CHAR8   Buff2[10];\r
  CHAR8   OffsetStr[30];\r
  CHAR8   Buff3[10];\r
  CHAR8   Buff4[10];\r
  CHAR8   Buff5[10];\r
  CHAR8   Token[50];\r
  CHAR8   *FormatString;\r
  INTN    FormatLength;\r
\r
  Fp = fopen (LongFilePath (VtfInfo->CompSymName), "rb");\r
\r
  if (Fp == NULL) {\r
    Error (NULL, 0, 0001, "Error opening file", VtfInfo->CompSymName);\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  //\r
  // Generate the format string for fscanf\r
  //\r
  FormatLength = snprintf (\r
                   NULL,\r
                   0,\r
                   "%%%us %%%us %%%us %%%us %%%us %%%us %%%us",\r
                   (unsigned) sizeof (Buff1) - 1,\r
                   (unsigned) sizeof (Buff2) - 1,\r
                   (unsigned) sizeof (OffsetStr) - 1,\r
                   (unsigned) sizeof (Buff3) - 1,\r
                   (unsigned) sizeof (Buff4) - 1,\r
                   (unsigned) sizeof (Buff5) - 1,\r
                   (unsigned) sizeof (Token) - 1\r
                   ) + 1;\r
\r
  FormatString = (CHAR8 *) malloc (FormatLength);\r
  if (FormatString == NULL) {\r
    fclose (Fp);\r
\r
    Error (NULL, 0, 4001, "Resource", "memory cannot be allocated!");\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  snprintf (\r
    FormatString,\r
    FormatLength,\r
    "%%%us %%%us %%%us %%%us %%%us %%%us %%%us",\r
    (unsigned) sizeof (Buff1) - 1,\r
    (unsigned) sizeof (Buff2) - 1,\r
    (unsigned) sizeof (OffsetStr) - 1,\r
    (unsigned) sizeof (Buff3) - 1,\r
    (unsigned) sizeof (Buff4) - 1,\r
    (unsigned) sizeof (Buff5) - 1,\r
    (unsigned) sizeof (Token) - 1\r
    );\r
\r
  while (fgets (Buff, sizeof (Buff), Fp) != NULL) {\r
    fscanf (\r
      Fp,\r
      FormatString,\r
      Buff1,\r
      Buff2,\r
      OffsetStr,\r
      Buff3,\r
      Buff4,\r
      Buff5,\r
      Token\r
      );\r
    if (strnicmp (Token, "SALE_ENTRY", 10) == 0) {\r
      break;\r
    }\r
  }\r
\r
  Offset = strtoul (OffsetStr, NULL, 16);\r
\r
  *CompStartAddress += Offset;\r
  SalEntryAdd = Fv1EndAddress - (SIZE_IA32_RESET_VECT + SIZE_SALE_ENTRY_POINT);\r
\r
  GetRelativeAddressInVtfBuffer (SalEntryAdd, &RelativeAddress, FIRST_VTF);\r
\r
  memcpy ((VOID *) RelativeAddress, (VOID *) CompStartAddress, sizeof (UINT64));\r
\r
  if (FormatString != NULL) {\r
    free (FormatString);\r
  }\r
\r
  if (Fp != NULL) {\r
    fclose (Fp);\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
EFI_STATUS\r
CreateAndUpdateComponent (\r
  IN  PARSED_VTF_INFO   *VtfInfo\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  This function reads the binary file for each components and update them\r
  in VTF Buffer as well as in FIT table. If the component is located in non\r
  VTF area, only the FIT table address will be updated\r
\r
Arguments:\r
\r
  VtfInfo    - Pointer to Parsed Info\r
\r
Returns:\r
\r
  EFI_SUCCESS      - The function completed successful\r
  EFI_ABORTED      - Aborted due to one of the many reasons like:\r
                      (a) Component Size greater than the specified size.\r
                      (b) Error opening files.\r
                      (c) Fail to get the FIT table address.\r
\r
  EFI_INVALID_PARAMETER     Value returned from call to UpdateEntryPoint()\r
  EFI_OUT_OF_RESOURCES      Memory allocation failure.\r
\r
--*/\r
{\r
  EFI_STATUS  Status;\r
  UINT64      CompStartAddress;\r
  UINT64      FileSize;\r
  UINT64      NumAdjustByte;\r
  UINT8       *Buffer;\r
  FILE        *Fp;\r
  FIT_TABLE   *CompFitPtr;\r
  BOOLEAN     Aligncheck;\r
\r
  if (VtfInfo->LocationType == NONE) {\r
    UpdateFitEntryForNonVTFComp (VtfInfo);\r
    return EFI_SUCCESS;\r
  }\r
\r
  Fp = fopen (LongFilePath (VtfInfo->CompBinName), "rb");\r
\r
  if (Fp == NULL) {\r
    Error (NULL, 0, 0001, "Error opening file", VtfInfo->CompBinName);\r
    return EFI_ABORTED;\r
  }\r
\r
  FileSize = _filelength (fileno (Fp));\r
  if ((VtfInfo->CompType == COMP_TYPE_FIT_PAL_B) || (VtfInfo->CompType == COMP_TYPE_FIT_PAL_A_SPECIFIC)) {\r
\r
    //\r
    // BUGBUG: Satish to correct\r
    //\r
    FileSize -= SIZE_OF_PAL_HEADER;\r
  }\r
\r
  if (VtfInfo->PreferredSize) {\r
    if (FileSize > VtfInfo->CompSize) {\r
      fclose (Fp);\r
      Error (NULL, 0, 2000, "Invalid parameter", "The component size is more than specified size.");\r
      return EFI_ABORTED;\r
    }\r
\r
    FileSize = VtfInfo->CompSize;\r
  }\r
\r
  Buffer = malloc ((UINTN) FileSize);\r
  if (Buffer == NULL) {\r
    fclose (Fp);\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
  memset (Buffer, 0, (UINTN) FileSize);\r
\r
  if ((VtfInfo->CompType == COMP_TYPE_FIT_PAL_B) || (VtfInfo->CompType == COMP_TYPE_FIT_PAL_A_SPECIFIC)) {\r
\r
    //\r
    // Read first 64 bytes of PAL header and use it to find version info\r
    //\r
    fread (Buffer, sizeof (UINT8), SIZE_OF_PAL_HEADER, Fp);\r
\r
    //\r
    // PAL header contains the version info. Currently, we will use the header\r
    // to read version info and then discard.\r
    //\r
    if (!VtfInfo->VersionPresent) {\r
      GetComponentVersionInfo (VtfInfo, Buffer);\r
    }\r
  }\r
\r
  fread (Buffer, sizeof (UINT8), (UINTN) FileSize, Fp);\r
  fclose (Fp);\r
\r
  //\r
  // If it is non PAL_B component, pass the entire buffer to get the version\r
  // info and implement any specific case inside GetComponentVersionInfo.\r
  //\r
  if (VtfInfo->CompType != COMP_TYPE_FIT_PAL_B) {\r
    if (!VtfInfo->VersionPresent) {\r
      GetComponentVersionInfo (VtfInfo, Buffer);\r
    }\r
  }\r
\r
  if (VtfInfo->LocationType == SECOND_VTF) {\r
\r
    CompStartAddress = (Vtf2LastStartAddress - FileSize);\r
  } else {\r
    CompStartAddress = (Vtf1LastStartAddress - FileSize);\r
  }\r
\r
  if (VtfInfo->CompType == COMP_TYPE_FIT_PAL_B) {\r
    Aligncheck = CheckAddressAlignment (CompStartAddress, 32 * 1024, &NumAdjustByte);\r
  } else {\r
    Aligncheck = CheckAddressAlignment (CompStartAddress, 8, &NumAdjustByte);\r
  }\r
\r
  if (!Aligncheck) {\r
    CompStartAddress -= NumAdjustByte;\r
  }\r
\r
  if (VtfInfo->LocationType == SECOND_VTF && SecondVTF == TRUE) {\r
    Vtf2LastStartAddress = CompStartAddress;\r
    Vtf2TotalSize += (UINT32) (FileSize + NumAdjustByte);\r
    Status = UpdateVtfBuffer (CompStartAddress, Buffer, FileSize, SECOND_VTF);\r
  } else if (VtfInfo->LocationType == FIRST_VTF) {\r
    Vtf1LastStartAddress = CompStartAddress;\r
    Vtf1TotalSize += (UINT32) (FileSize + NumAdjustByte);\r
    Status = UpdateVtfBuffer (CompStartAddress, Buffer, FileSize, FIRST_VTF);\r
  } else {\r
    free (Buffer);\r
    Error (NULL, 0, 2000,"Invalid Parameter", "There's component in second VTF so second BaseAddress and Size must be specified!");\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if (EFI_ERROR (Status)) {\r
    free (Buffer);\r
    return EFI_ABORTED;\r
  }\r
\r
  GetNextAvailableFitPtr (&CompFitPtr);\r
  if (CompFitPtr == NULL) {\r
    free (Buffer);\r
    return EFI_ABORTED;\r
  }\r
\r
  CompFitPtr->CompAddress = CompStartAddress | IPF_CACHE_BIT;\r
  if ((FileSize % 16) != 0) {\r
    free (Buffer);\r
    Error (NULL, 0, 2000, "Invalid parameter", "Binary FileSize must be a multiple of 16.");\r
    return EFI_INVALID_PARAMETER;\r
  }\r
  //assert ((FileSize % 16) == 0);\r
  CompFitPtr->CompSize    = (UINT32) (FileSize / 16);\r
  CompFitPtr->CompVersion = MAKE_VERSION (VtfInfo->MajorVer, VtfInfo->MinorVer);\r
  CompFitPtr->CvAndType   = CV_N_TYPE (VtfInfo->CheckSumRequired, VtfInfo->CompType);\r
  if (VtfInfo->CheckSumRequired) {\r
    CompFitPtr->CheckSum  = 0;\r
    CompFitPtr->CheckSum  = CalculateChecksum8 (Buffer, (UINTN) FileSize);\r
  }\r
\r
  //\r
  // Free the buffer\r
  //\r
  if (Buffer) {\r
    free (Buffer);\r
  }\r
\r
  //\r
  // Update the SYM file for this component based on it's start address.\r
  //\r
  Status = UpdateSymFile (CompStartAddress, SymFileName, VtfInfo->CompSymName, FileSize);\r
  if (EFI_ERROR (Status)) {\r
\r
    //\r
    // At this time, SYM files are not required, so continue on error.\r
    //\r
  }\r
\r
  // !!!!!!!!!!!!!!!!!!!!!\r
  // BUGBUG:\r
  // This part of the code is a temporary line since PEICORE is going to be inside\r
  // VTF till we work out how to determine the SALE_ENTRY through it. We will need\r
  // to clarify so many related questions\r
  // !!!!!!!!!!!!!!!!!!!!!!!\r
\r
  if (VtfInfo->CompType == COMP_TYPE_FIT_PEICORE) {\r
    Status = UpdateEntryPoint (VtfInfo, &CompStartAddress);\r
  }\r
\r
  return Status;\r
}\r
\r
EFI_STATUS\r
CreateAndUpdatePAL_A (\r
  IN  PARSED_VTF_INFO   *VtfInfo\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  This function reads the binary file for each components and update them\r
  in VTF Buffer as well as FIT table\r
\r
Arguments:\r
\r
  VtfInfo    - Pointer to Parsed Info\r
\r
Returns:\r
\r
  EFI_ABORTED           - Due to one of the following reasons:\r
                           (a)Error Opening File\r
                           (b)The PAL_A Size is more than specified size status\r
                              One of the values mentioned below returned from\r
                              call to UpdateSymFile\r
  EFI_SUCCESS           - The function completed successfully.\r
  EFI_INVALID_PARAMETER - One of the input parameters was invalid.\r
  EFI_ABORTED           - An error occurred.UpdateSymFile\r
  EFI_OUT_OF_RESOURCES  - Memory allocation failed.\r
\r
--*/\r
{\r
  EFI_STATUS  Status;\r
  UINT64      PalStartAddress;\r
  UINT64      AbsAddress;\r
  UINTN       RelativeAddress;\r
  UINT64      FileSize;\r
  UINT8       *Buffer;\r
  FILE        *Fp;\r
  FIT_TABLE   *PalFitPtr;\r
\r
  Fp = fopen (LongFilePath (VtfInfo->CompBinName), "rb");\r
\r
  if (Fp == NULL) {\r
    Error (NULL, 0, 0001, "Error opening file", VtfInfo->CompBinName);\r
    return EFI_ABORTED;\r
  }\r
\r
  FileSize = _filelength (fileno (Fp));\r
  if (FileSize < 64) {\r
    fclose (Fp);\r
    Error (NULL, 0, 2000, "Invalid parameter", "PAL_A bin header is 64 bytes, so the Bin size must be larger than 64 bytes!");\r
    return EFI_INVALID_PARAMETER;\r
  }\r
  FileSize -= SIZE_OF_PAL_HEADER;\r
\r
\r
  if (VtfInfo->PreferredSize) {\r
    if (FileSize > VtfInfo->CompSize) {\r
      fclose (Fp);\r
      Error (NULL, 0, 2000, "Invalid parameter", "The PAL_A Size is more than the specified size.");\r
      return EFI_ABORTED;\r
    }\r
\r
    FileSize = VtfInfo->CompSize;\r
  }\r
\r
  Buffer = malloc ((UINTN) FileSize);\r
  if (Buffer == NULL) {\r
    fclose (Fp);\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
  memset (Buffer, 0, (UINTN) FileSize);\r
\r
  //\r
  // Read, Get version Info and discard the PAL header.\r
  //\r
  fread (Buffer, sizeof (UINT8), SIZE_OF_PAL_HEADER, Fp);\r
\r
  //\r
  // Extract the version info from header of PAL_A. Once done, discrad this buffer\r
  //\r
  if (!VtfInfo->VersionPresent) {\r
    GetComponentVersionInfo (VtfInfo, Buffer);\r
  }\r
\r
  //\r
  // Read PAL_A file in a buffer\r
  //\r
  fread (Buffer, sizeof (UINT8), (UINTN) FileSize, Fp);\r
  fclose (Fp);\r
\r
  PalStartAddress       = Fv1EndAddress - (SIZE_TO_OFFSET_PAL_A_END + FileSize);\r
  Vtf1LastStartAddress  = PalStartAddress;\r
  Vtf1TotalSize += (UINT32) FileSize;\r
  Status      = UpdateVtfBuffer (PalStartAddress, Buffer, FileSize, FIRST_VTF);\r
\r
  AbsAddress  = Fv1EndAddress - SIZE_TO_PAL_A_FIT;\r
  GetRelativeAddressInVtfBuffer (AbsAddress, &RelativeAddress, FIRST_VTF);\r
  PalFitPtr               = (FIT_TABLE *) RelativeAddress;\r
  PalFitPtr->CompAddress  = PalStartAddress | IPF_CACHE_BIT;\r
  //assert ((FileSize % 16) == 0);\r
  if ((FileSize % 16) != 0) {\r
    free (Buffer);\r
    Error (NULL, 0, 2000, "Invalid parameter", "Binary FileSize must be a multiple of 16.");\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  PalFitPtr->CompSize     = (UINT32) (FileSize / 16);\r
  PalFitPtr->CompVersion  = MAKE_VERSION (VtfInfo->MajorVer, VtfInfo->MinorVer);\r
  PalFitPtr->CvAndType    = CV_N_TYPE (VtfInfo->CheckSumRequired, VtfInfo->CompType);\r
  if (VtfInfo->CheckSumRequired) {\r
    PalFitPtr->CheckSum = 0;\r
    PalFitPtr->CheckSum = CalculateChecksum8 (Buffer, (UINTN) FileSize);\r
  }\r
\r
  if (Buffer) {\r
    free (Buffer);\r
  }\r
\r
  //\r
  // Update the SYM file for this component based on it's start address.\r
  //\r
  Status = UpdateSymFile (PalStartAddress, SymFileName, VtfInfo->CompSymName, FileSize);\r
  if (EFI_ERROR (Status)) {\r
\r
    //\r
    // At this time, SYM files are not required, so continue on error.\r
    //\r
  }\r
\r
  return Status;\r
}\r
\r
EFI_STATUS\r
CreateFitTableAndInitialize (\r
  IN  PARSED_VTF_INFO   *VtfInfo\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  This function creates and intializes FIT table which would be used to\r
  add component info inside this\r
\r
Arguments:\r
\r
  VtfInfo    - Pointer to Parsed Info\r
\r
Returns:\r
\r
  EFI_ABORTED  - Aborted due to no size information\r
  EFI_SUCCESS  - The function completed successfully\r
\r
--*/\r
{\r
  UINT64    PalFitTableAdd;\r
  UINT64    FitTableAdd;\r
  UINT64    FitTableAddressOffset;\r
  FIT_TABLE *PalFitPtr;\r
  FIT_TABLE *FitStartPtr;\r
  UINTN     NumFitComp;\r
  UINTN     RelativeAddress;\r
  UINTN     Index;\r
\r
  if (!VtfInfo->PreferredSize) {\r
    Error (NULL, 0, 2000, "Invalid parameter", "FIT could not be allocated because there is no size information.");\r
    return EFI_ABORTED;\r
  }\r
\r
  if ((VtfInfo->CompSize % 16) != 0) {\r
    Error (NULL, 0, 2000, "Invalid parameter", "Invalid FIT Table Size, it is not a multiple of 16 bytes. Please correct the size.");\r
  }\r
\r
  PalFitTableAdd = Fv1EndAddress - SIZE_TO_PAL_A_FIT;\r
  GetRelativeAddressInVtfBuffer (PalFitTableAdd, &RelativeAddress, FIRST_VTF);\r
  PalFitPtr             = (FIT_TABLE *) RelativeAddress;\r
  PalFitTableAdd        = (PalFitPtr->CompAddress - VtfInfo->CompSize);\r
\r
  FitTableAdd           = (PalFitPtr->CompAddress - 0x10) - VtfInfo->CompSize;\r
  FitTableAddressOffset = Fv1EndAddress - (SIZE_IA32_RESET_VECT + SIZE_SALE_ENTRY_POINT + SIZE_FIT_TABLE_ADD);\r
  GetRelativeAddressInVtfBuffer (FitTableAddressOffset, &RelativeAddress, FIRST_VTF);\r
  *(UINT64 *) RelativeAddress = FitTableAdd;\r
\r
  GetRelativeAddressInVtfBuffer (FitTableAdd, &RelativeAddress, FIRST_VTF);\r
\r
  //\r
  // Update Fit Table with FIT Signature and FIT info in first 16 bytes.\r
  //\r
  FitStartPtr = (FIT_TABLE *) RelativeAddress;\r
\r
  strncpy ((CHAR8 *) &FitStartPtr->CompAddress, FIT_SIGNATURE, 8);  // "_FIT_   "\r
  assert (((VtfInfo->CompSize & 0x00FFFFFF) % 16) == 0);\r
  FitStartPtr->CompSize     = (VtfInfo->CompSize & 0x00FFFFFF) / 16;\r
  FitStartPtr->CompVersion  = MAKE_VERSION (VtfInfo->MajorVer, VtfInfo->MinorVer);\r
\r
  //\r
  // BUGBUG: If a checksum is required, add code to checksum the FIT table.  Also\r
  // determine what to do for things like the FV component that aren't easily checksummed.\r
  // The checksum will be done once we are done with all the componet update in the FIT\r
  // table\r
  //\r
  FitStartPtr->CvAndType  = CV_N_TYPE (VtfInfo->CheckSumRequired, VtfInfo->CompType);\r
\r
  NumFitComp              = FitStartPtr->CompSize;\r
\r
  FitStartPtr++;\r
\r
  //\r
  // Intialize remaining FIT table space to UNUSED fit component type\r
  // so that when we need to create a FIT entry for a component, we can\r
  // locate a free one and use it.\r
  //\r
  for (Index = 0; Index < (NumFitComp - 1); Index++) {\r
    FitStartPtr->CvAndType = 0x7F;  // Initialize all with UNUSED\r
    FitStartPtr++;\r
  }\r
\r
  Vtf1TotalSize += VtfInfo->CompSize;\r
  Vtf1LastStartAddress -= VtfInfo->CompSize;\r
\r
  return EFI_SUCCESS;\r
}\r
\r
EFI_STATUS\r
WriteVtfBinary (\r
  IN CHAR8     *FileName,\r
  IN UINT32    VtfSize,\r
  IN LOC_TYPE  LocType\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Write Firmware Volume from memory to a file.\r
\r
Arguments:\r
\r
  FileName     - Output File Name which needed to be created/\r
  VtfSize      - FileSize\r
  LocType      - The type of the VTF\r
\r
Returns:\r
\r
  EFI_ABORTED - Returned due to one of the following resons:\r
                 (a) Error Opening File\r
                 (b) Failing to copy buffers\r
  EFI_SUCCESS - The fuction completes successfully\r
\r
--*/\r
{\r
  FILE  *Fp;\r
  UINTN NumByte;\r
  VOID  *VtfBuffer;\r
  UINTN RelativeAddress;\r
\r
  if (LocType == FIRST_VTF) {\r
    GetRelativeAddressInVtfBuffer (Vtf1LastStartAddress, &RelativeAddress, FIRST_VTF);\r
    VtfBuffer = (VOID *) RelativeAddress;\r
  } else {\r
    GetRelativeAddressInVtfBuffer (Vtf2LastStartAddress, &RelativeAddress, SECOND_VTF);\r
    VtfBuffer = (VOID *) RelativeAddress;\r
  }\r
\r
  Fp = fopen (LongFilePath (FileName), "wb");\r
  if (Fp == NULL) {\r
    Error (NULL, 0, 0001, "Error opening file", FileName);\r
    return EFI_ABORTED;\r
  }\r
\r
  NumByte = fwrite (VtfBuffer, sizeof (UINT8), (UINTN) VtfSize, Fp);\r
\r
  if (Fp) {\r
    fclose (Fp);\r
  }\r
\r
  if (NumByte != (sizeof (UINT8) * VtfSize)) {\r
    Error (NULL, 0, 0002, "Error writing file", FileName);\r
    return EFI_ABORTED;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
EFI_STATUS\r
UpdateVtfBuffer (\r
  IN  UINT64   StartAddress,\r
  IN  UINT8    *Buffer,\r
  IN  UINT64   DataSize,\r
  IN LOC_TYPE  LocType\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Update the Firmware Volume Buffer with requested buffer data\r
\r
Arguments:\r
\r
  StartAddress   - StartAddress in buffer. This number will automatically\r
                  point to right address in buffer where data needed\r
                  to be updated.\r
  Buffer         - Buffer pointer from data will be copied to memory mapped buffer.\r
  DataSize       - Size of the data needed to be copied.\r
  LocType        - The type of the VTF: First or Second\r
\r
Returns:\r
\r
  EFI_ABORTED  - The input parameter is error\r
  EFI_SUCCESS  - The function completed successfully\r
\r
--*/\r
{\r
  UINT8 *LocalBufferPtrToWrite;\r
\r
  if (LocType == FIRST_VTF) {\r
    if ((StartAddress | IPF_CACHE_BIT) < (Vtf1LastStartAddress | IPF_CACHE_BIT)) {\r
      Error (NULL, 0, 2000, "Invalid parameter", "Start Address is less than the VTF start address.");\r
      return EFI_ABORTED;\r
    }\r
\r
    LocalBufferPtrToWrite = (UINT8 *) Vtf1EndBuffer;\r
\r
    LocalBufferPtrToWrite -= (Fv1EndAddress - StartAddress);\r
\r
  } else {\r
\r
    if ((StartAddress | IPF_CACHE_BIT) < (Vtf2LastStartAddress | IPF_CACHE_BIT)) {\r
      Error (NULL, 0, 2000, "Invalid parameter", "Error StartAddress");\r
      return EFI_ABORTED;\r
    }\r
    LocalBufferPtrToWrite = (UINT8 *) Vtf2EndBuffer;\r
    LocalBufferPtrToWrite -= (Fv2EndAddress - StartAddress);\r
  }\r
\r
  memcpy (LocalBufferPtrToWrite, Buffer, (UINTN) DataSize);\r
\r
  return EFI_SUCCESS;\r
}\r
\r
EFI_STATUS\r
UpdateFfsHeader (\r
  IN UINT32         TotalVtfSize,\r
  IN LOC_TYPE       LocType\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Update the Firmware Volume Buffer with requested buffer data\r
\r
Arguments:\r
\r
  TotalVtfSize     - Size of the VTF\r
  Fileoffset       - The start of the file relative to the start of the FV.\r
  LocType          - The type of the VTF\r
\r
Returns:\r
\r
  EFI_SUCCESS            - The function completed successfully\r
  EFI_INVALID_PARAMETER  - The Ffs File Header Pointer is NULL\r
\r
--*/\r
{\r
  EFI_FFS_FILE_HEADER *FileHeader;\r
  UINTN               RelativeAddress;\r
  EFI_GUID            EfiFirmwareVolumeTopFileGuid = EFI_FFS_VOLUME_TOP_FILE_GUID;\r
\r
  //\r
  // Find the VTF file header location\r
  //\r
  if (LocType == FIRST_VTF) {\r
    GetRelativeAddressInVtfBuffer (Vtf1LastStartAddress, &RelativeAddress, FIRST_VTF);\r
    FileHeader = (EFI_FFS_FILE_HEADER *) RelativeAddress;\r
  } else {\r
    GetRelativeAddressInVtfBuffer (Vtf2LastStartAddress, &RelativeAddress, SECOND_VTF);\r
    FileHeader = (EFI_FFS_FILE_HEADER *) RelativeAddress;\r
  }\r
\r
  if (FileHeader == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  //\r
  // write header\r
  //\r
  memset (FileHeader, 0, sizeof (EFI_FFS_FILE_HEADER));\r
  memcpy (&FileHeader->Name, &EfiFirmwareVolumeTopFileGuid, sizeof (EFI_GUID));\r
  FileHeader->Type        = EFI_FV_FILETYPE_RAW;\r
  FileHeader->Attributes  = FFS_ATTRIB_CHECKSUM;\r
\r
  //\r
  // Now FileSize includes the EFI_FFS_FILE_HEADER\r
  //\r
  FileHeader->Size[0] = (UINT8) (TotalVtfSize & 0x000000FF);\r
  FileHeader->Size[1] = (UINT8) ((TotalVtfSize & 0x0000FF00) >> 8);\r
  FileHeader->Size[2] = (UINT8) ((TotalVtfSize & 0x00FF0000) >> 16);\r
\r
  //\r
  // Fill in checksums and state, all three must be zero for the checksums.\r
  //\r
  FileHeader->IntegrityCheck.Checksum.Header  = 0;\r
  FileHeader->IntegrityCheck.Checksum.File    = 0;\r
  FileHeader->State                           = 0;\r
  FileHeader->IntegrityCheck.Checksum.Header  = CalculateChecksum8 ((UINT8 *) FileHeader, sizeof (EFI_FFS_FILE_HEADER));\r
  FileHeader->IntegrityCheck.Checksum.File    = CalculateChecksum8 ((UINT8 *) (FileHeader + 1), TotalVtfSize - sizeof (EFI_FFS_FILE_HEADER));\r
  FileHeader->State                           = EFI_FILE_HEADER_CONSTRUCTION | EFI_FILE_HEADER_VALID | EFI_FILE_DATA_VALID;\r
\r
  return EFI_SUCCESS;\r
}\r
\r
EFI_STATUS\r
ValidateAddressAndSize (\r
  IN  UINT64  BaseAddress,\r
  IN  UINT64  FwVolSize\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Update the Firmware Volume Buffer with requested buffer data\r
\r
Arguments:\r
\r
  BaseAddress    - Base address for the Fw Volume.\r
\r
  FwVolSize      - Total Size of the FwVolume to which VTF will be attached..\r
\r
Returns:\r
\r
  EFI_SUCCESS     - The function completed successfully\r
  EFI_UNSUPPORTED - The input parameter is error\r
\r
--*/\r
{\r
  if ((FwVolSize > 0x40) && ((BaseAddress + FwVolSize) % 8 == 0)) {\r
    return EFI_SUCCESS;\r
  }\r
\r
  return EFI_UNSUPPORTED;\r
}\r
\r
EFI_STATUS\r
UpdateIA32ResetVector (\r
  IN  CHAR8   *FileName,\r
  IN  UINT64  FirstFwVSize\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Update the 16 byte IA32 Reset vector to maintain the compatibility\r
\r
Arguments:\r
\r
  FileName     - Binary file name which contains the IA32 Reset vector info..\r
  FirstFwVSize - Total Size of the FwVolume to which VTF will be attached..\r
\r
Returns:\r
\r
  EFI_SUCCESS            - The function completed successfully\r
  EFI_ABORTED            - Invalid File Size\r
  EFI_INVALID_PARAMETER  - Bad File Name\r
  EFI_OUT_OF_RESOURCES   - Memory allocation failed.\r
\r
--*/\r
{\r
  UINT8 *Buffer;\r
  UINT8 *LocalVtfBuffer;\r
  UINTN FileSize;\r
  FILE  *Fp;\r
\r
  if (!strcmp (FileName, "")) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  Fp = fopen (LongFilePath (FileName), "rb");\r
\r
  if (Fp == NULL) {\r
    Error (NULL, 0, 0001, "Error opening file", FileName);\r
    return EFI_ABORTED;\r
  }\r
\r
  FileSize = _filelength (fileno (Fp));\r
\r
  if (FileSize > 16) {\r
    fclose (Fp);\r
    return EFI_ABORTED;\r
  }\r
\r
  Buffer = malloc (FileSize);\r
  if (Buffer == NULL) {\r
    fclose (Fp);\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  fread (Buffer, sizeof (UINT8), FileSize, Fp);\r
\r
  LocalVtfBuffer  = (UINT8 *) Vtf1EndBuffer - SIZE_IA32_RESET_VECT;\r
  memcpy (LocalVtfBuffer, Buffer, FileSize);\r
\r
  if (Buffer) {\r
    free (Buffer);\r
  }\r
\r
  if (Fp != NULL) {\r
    fclose (Fp);\r
  }\r
  return EFI_SUCCESS;\r
}\r
\r
VOID\r
CleanUpMemory (\r
  VOID\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  This function cleans up any allocated buffer\r
\r
Arguments:\r
\r
  NONE\r
\r
Returns:\r
\r
  NONE\r
\r
--*/\r
{\r
  PARSED_VTF_INFO *TempFileListPtr;\r
\r
  if (Vtf1Buffer) {\r
    free (Vtf1Buffer);\r
  }\r
\r
  if (Vtf2Buffer) {\r
    free (Vtf2Buffer);\r
  }\r
\r
  //\r
  // Cleanup the buffer which was allocated to read the file names from FV.INF\r
  //\r
  FileListPtr = FileListHeadPtr;\r
  while (FileListPtr != NULL) {\r
    TempFileListPtr = FileListPtr->NextVtfInfo;\r
    free (FileListPtr);\r
    FileListPtr = TempFileListPtr;\r
  }\r
}\r
\r
EFI_STATUS\r
ProcessAndCreateVtf (\r
  IN  UINT64  Size\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  This function process the link list created during INF file parsing\r
  and create component in VTF and updates its info in FIT table\r
\r
Arguments:\r
\r
  Size   - Size of the Firmware Volume of which, this VTF belongs to.\r
\r
Returns:\r
\r
  EFI_UNSUPPORTED - Unknown FIT type\r
  EFI_SUCCESS     - The function completed successfully\r
\r
--*/\r
{\r
  EFI_STATUS      Status;\r
  PARSED_VTF_INFO *ParsedInfoPtr;\r
\r
  Status        = EFI_SUCCESS;\r
\r
  ParsedInfoPtr = FileListHeadPtr;\r
\r
  while (ParsedInfoPtr != NULL) {\r
\r
    switch (ParsedInfoPtr->CompType) {\r
    //\r
    // COMP_TYPE_FIT_HEADER is a special case, hence handle it here\r
    //\r
    case COMP_TYPE_FIT_HEADER:\r
      //COMP_TYPE_FIT_HEADER          0x00\r
      Status = CreateFitTableAndInitialize (ParsedInfoPtr);\r
      break;\r
\r
    //\r
    // COMP_TYPE_FIT_PAL_A is a special case, hence handle it here\r
    //\r
    case COMP_TYPE_FIT_PAL_A:\r
      //COMP_TYPE_FIT_PAL_A           0x0F\r
      Status = CreateAndUpdatePAL_A (ParsedInfoPtr);\r
\r
      //\r
      // Based on VTF specification, once the PAL_A component has been written,\r
      // update the Firmware Volume info as FIT table. This will be utilized\r
      // to extract the Firmware Volume Start address where this VTF will be\r
      // of part.\r
      //\r
      if (Status == EFI_SUCCESS) {\r
        UpdateFitEntryForFwVolume (Size);\r
      }\r
      break;\r
\r
    case COMP_TYPE_FIT_FV_BOOT:\r
      //COMP_TYPE_FIT_FV_BOOT         0x7E\r
      //\r
      // Since FIT entry for Firmware Volume has been created and it is\r
      // located at (PAL_A start - 16 byte). So we will not process any\r
      // Firmware Volume related entry from INF file\r
      //\r
      Status = EFI_SUCCESS;\r
      break;\r
\r
    default:\r
      //\r
      // Any other component type should be handled here. This will create the\r
      // image in specified VTF and create appropriate entry about this\r
      // component in FIT Entry.\r
      //\r
      Status = CreateAndUpdateComponent (ParsedInfoPtr);\r
      if (EFI_ERROR (Status)) {\r
        Error (NULL, 0, 0002, "Error updating component", ParsedInfoPtr->CompName);\r
        return EFI_ABORTED;\r
      } else {\r
      break;}\r
    }\r
\r
    ParsedInfoPtr = ParsedInfoPtr->NextVtfInfo;\r
  }\r
  return Status;\r
}\r
\r
EFI_STATUS\r
GenerateVtfImage (\r
  IN  UINT64  StartAddress1,\r
  IN  UINT64  Size1,\r
  IN  UINT64  StartAddress2,\r
  IN  UINT64  Size2,\r
  IN  FILE    *fp\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  This is the main function which will be called from application.\r
\r
Arguments:\r
\r
  StartAddress1  - The start address of the first VTF\r
  Size1          - The size of the first VTF\r
  StartAddress2  - The start address of the second VTF\r
  Size2          - The size of the second VTF\r
  fp             - The pointer to BSF inf file\r
\r
Returns:\r
\r
  EFI_OUT_OF_RESOURCES - Can not allocate memory\r
  The return value can be any of the values\r
  returned by the calls to following functions:\r
      GetVtfRelatedInfoFromInfFile\r
      ProcessAndCreateVtf\r
      UpdateIA32ResetVector\r
      UpdateFfsHeader\r
      WriteVtfBinary\r
\r
--*/\r
{\r
  EFI_STATUS  Status;\r
  FILE            *VtfFP;\r
\r
  Status          = EFI_UNSUPPORTED;\r
  VtfFP = fp;\r
\r
  if (StartAddress2 == 0) {\r
    SecondVTF = FALSE;\r
  } else {\r
    SecondVTF = TRUE;\r
  }\r
\r
  Fv1BaseAddress        = StartAddress1;\r
  Fv1EndAddress         = Fv1BaseAddress + Size1;\r
  if (Fv1EndAddress != 0x100000000ULL || Size1 < 0x100000) {\r
    Error (NULL, 0, 2000, "Invalid parameter", "Error BaseAddress and Size parameters!");\r
    if (Size1 < 0x100000) {\r
      Error (NULL, 0, 2000, "Invalid parameter", "The FwVolumeSize must be larger than 1M!");\r
    } else if (SecondVTF != TRUE) {\r
      Error (NULL, 0, 2000, "Invalid parameter", "BaseAddress + FwVolumeSize must equal 0x100000000!");\r
    }\r
    Usage();\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  //\r
  // The image buffer for the First VTF\r
  //\r
  Vtf1Buffer = malloc ((UINTN) Size1);\r
  if (Vtf1Buffer == NULL) {\r
    Error (NULL, 0, 4001, "Resource", "Not enough resources available to create memory mapped file for the Boot Strap File!");\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
  memset (Vtf1Buffer, 0x00, (UINTN) Size1);\r
  Vtf1EndBuffer         = (UINT8 *) Vtf1Buffer + Size1;\r
  Vtf1LastStartAddress  = Fv1EndAddress | IPF_CACHE_BIT;\r
\r
  if (SecondVTF) {\r
    Fv2BaseAddress        = StartAddress2;\r
    Fv2EndAddress         = Fv2BaseAddress + Size2;\r
    if (Fv2EndAddress != StartAddress1) {\r
      Error (NULL, 0, 2000, "Invalid parameter", "Error BaseAddress and Size parameters!");\r
      if (SecondVTF == TRUE) {\r
        Error (NULL, 0, 2000, "Invalid parameter", "FirstBaseAddress + FirstFwVolumeSize must equal 0x100000000!");\r
        Error (NULL, 0, 2000, "Invalid parameter", "SecondBaseAddress + SecondFwVolumeSize must equal FirstBaseAddress!");\r
      }\r
      Usage();\r
      return EFI_INVALID_PARAMETER;\r
    }\r
\r
    //\r
    // The image buffer for the second VTF\r
    //\r
    Vtf2Buffer = malloc ((UINTN) Size2);\r
    if (Vtf2Buffer == NULL) {\r
      Error (NULL, 0, 4001, "Resource", "Not enough resources available to create memory mapped file for the Boot Strap File!");\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
    memset (Vtf2Buffer, 0x00, (UINTN) Size2);\r
    Vtf2EndBuffer         = (UINT8 *) Vtf2Buffer + Size2;\r
    Vtf2LastStartAddress  = Fv2EndAddress | IPF_CACHE_BIT;\r
  }\r
\r
  Status = GetVtfRelatedInfoFromInfFile (VtfFP);\r
\r
  if (Status != EFI_SUCCESS) {\r
    Error (NULL, 0, 0003, "Error parsing file", "the input file.");\r
    CleanUpMemory ();\r
    return Status;\r
  }\r
\r
  Status = ProcessAndCreateVtf (Size1);\r
  if (Status != EFI_SUCCESS) {\r
    CleanUpMemory ();\r
    return Status;\r
  }\r
\r
  if (SectionOptionFlag) {\r
    Status = UpdateIA32ResetVector (IA32BinFile, Vtf1TotalSize);\r
    if (Status != EFI_SUCCESS) {\r
      CleanUpMemory ();\r
      return Status;\r
    }\r
  }\r
\r
  //\r
  // Re arrange the FIT Table for Ascending order of their FIT Type..\r
  //\r
  SortFitTable ();\r
\r
  //\r
  // All components have been updated in FIT table. Now perform the FIT table\r
  // checksum. The following function will check if Checksum is required,\r
  // if yes, then it will perform the checksum otherwise not.\r
  //\r
  CalculateFitTableChecksum ();\r
\r
  //\r
  // Write the FFS header\r
  //\r
  Vtf1TotalSize += sizeof (EFI_FFS_FILE_HEADER);\r
  Vtf1LastStartAddress -= sizeof (EFI_FFS_FILE_HEADER);\r
\r
  Status = UpdateFfsHeader (Vtf1TotalSize, FIRST_VTF);\r
  if (Status != EFI_SUCCESS) {\r
    CleanUpMemory ();\r
    return Status;\r
  }\r
  //\r
  // Update the VTF buffer into specified VTF binary file\r
  //\r
  Status  = WriteVtfBinary (OutFileName1, Vtf1TotalSize, FIRST_VTF);\r
\r
  if (SecondVTF) {\r
    Vtf2TotalSize += sizeof (EFI_FFS_FILE_HEADER);\r
    Vtf2LastStartAddress -= sizeof (EFI_FFS_FILE_HEADER);\r
    Status = UpdateFfsHeader (Vtf2TotalSize, SECOND_VTF);\r
    if (Status != EFI_SUCCESS) {\r
      CleanUpMemory ();\r
      return Status;\r
    }\r
\r
    //\r
    // Update the VTF buffer into specified VTF binary file\r
    //\r
    Status  = WriteVtfBinary (OutFileName2, Vtf2TotalSize, SECOND_VTF);\r
  }\r
\r
  CleanUpMemory ();\r
\r
  return Status;\r
}\r
\r
EFI_STATUS\r
PeimFixupInFitTable (\r
  IN  UINT64  StartAddress\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  This function is an entry point to fixup SAL-E entry point.\r
\r
Arguments:\r
\r
  StartAddress - StartAddress for PEIM.....\r
\r
Returns:\r
\r
  EFI_SUCCESS          - The function completed successfully\r
  EFI_ABORTED          - Error Opening File\r
  EFI_OUT_OF_RESOURCES - System out of resources for memory allocation.\r
\r
--*/\r
{\r
  EFI_STATUS  Status;\r
  FILE        *Fp;\r
  UINT64      *StartAddressPtr;\r
  UINTN       FirstFwVSize;\r
\r
  StartAddressPtr   = malloc (sizeof (UINT64));\r
  if (StartAddressPtr == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
  *StartAddressPtr = StartAddress;\r
\r
  Fp = fopen (LongFilePath (OutFileName1), "rb");\r
\r
  if (Fp == NULL) {\r
    Error (NULL, 0, 0001, "Error opening file", OutFileName1);\r
    if (StartAddressPtr) {\r
      free (StartAddressPtr);\r
    }\r
    return EFI_ABORTED;\r
  }\r
\r
  FirstFwVSize = _filelength (fileno (Fp));\r
  fseek (Fp, (long) (FirstFwVSize - (UINTN) (SIZE_IA32_RESET_VECT + SIZE_SALE_ENTRY_POINT)), SEEK_SET);\r
  fwrite ((VOID *) StartAddressPtr, sizeof (UINT64), 1, Fp);\r
\r
  if (Fp) {\r
    fclose (Fp);\r
  }\r
\r
  if (StartAddressPtr) {\r
    free (StartAddressPtr);\r
  }\r
\r
  Status = EFI_SUCCESS;\r
  return Status;\r
}\r
\r
EFI_STATUS\r
UpdateSymFile (\r
  IN UINT64 BaseAddress,\r
  IN CHAR8  *DestFileName,\r
  IN CHAR8  *SourceFileName,\r
  IN UINT64 FileSize\r
\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  This function adds the SYM tokens in the source file to the destination file.\r
  The SYM tokens are updated to reflect the base address.\r
\r
Arguments:\r
\r
  BaseAddress    - The base address for the new SYM tokens.\r
  DestFileName   - The destination file.\r
  SourceFileName - The source file.\r
  FileSize       - Size of bin file.\r
\r
Returns:\r
\r
  EFI_SUCCESS             - The function completed successfully.\r
  EFI_INVALID_PARAMETER   - One of the input parameters was invalid.\r
  EFI_ABORTED             - An error occurred.\r
\r
--*/\r
{\r
  FILE    *SourceFile;\r
  FILE    *DestFile;\r
  CHAR8   Buffer[MAX_LONG_FILE_PATH];\r
  CHAR8   Type[MAX_LONG_FILE_PATH];\r
  CHAR8   Address[MAX_LONG_FILE_PATH];\r
  CHAR8   Section[MAX_LONG_FILE_PATH];\r
  CHAR8   Token[MAX_LONG_FILE_PATH];\r
  CHAR8   BaseToken[MAX_LONG_FILE_PATH];\r
  CHAR8   *FormatString;\r
  INTN    FormatLength;\r
  UINT64  TokenAddress;\r
  long    StartLocation;\r
\r
  //\r
  // Verify input parameters.\r
  //\r
  if (BaseAddress == 0 || DestFileName == NULL || SourceFileName == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  //\r
  // Open the source file\r
  //\r
  SourceFile = fopen (LongFilePath (SourceFileName), "r");\r
  if (SourceFile == NULL) {\r
\r
    //\r
    // SYM files are not required.\r
    //\r
    return EFI_SUCCESS;\r
  }\r
\r
  //\r
  // Use the file name minus extension as the base for tokens\r
  //\r
  strcpy (BaseToken, SourceFileName);\r
  strtok (BaseToken, ". \t\n");\r
  strcat (BaseToken, "__");\r
\r
  //\r
  // Open the destination file\r
  //\r
  DestFile = fopen (LongFilePath (DestFileName), "a+");\r
  if (DestFile == NULL) {\r
    fclose (SourceFile);\r
    Error (NULL, 0, 0001, "Error opening file", DestFileName);\r
    return EFI_ABORTED;\r
  }\r
\r
  //\r
  // If this is the beginning of the output file, write the symbol format info.\r
  //\r
  if (fseek (DestFile, 0, SEEK_END) != 0) {\r
    fclose (SourceFile);\r
    fclose (DestFile);\r
    Error (NULL, 0, 2000, "Invalid parameter", "not at the beginning of the output file.");\r
    return EFI_ABORTED;\r
  }\r
\r
  StartLocation = ftell (DestFile);\r
\r
  if (StartLocation == 0) {\r
    fprintf (DestFile, "TEXTSYM format | V1.0\n");\r
  } else if (StartLocation == -1) {\r
    fclose (SourceFile);\r
    fclose (DestFile);\r
    Error (NULL, 0, 2000, "Invalid parameter", "StartLocation error");\r
    return EFI_ABORTED;\r
  }\r
\r
  //\r
  // Read the first line\r
  //\r
  if (fgets (Buffer, MAX_LONG_FILE_PATH, SourceFile) == NULL) {\r
    Buffer[0] = 0;\r
  }\r
\r
  //\r
  // Make sure it matches the expected sym format\r
  //\r
  if (strcmp (Buffer, "TEXTSYM format | V1.0\n")) {\r
    fclose (SourceFile);\r
    fclose (DestFile);\r
    Error (NULL, 0, 2000, "Invalid parameter", "The symbol file does not match the expected TEXTSYM format (V1.0.)");\r
    return EFI_ABORTED;\r
  }\r
\r
  //\r
  // Generate the format string for fscanf\r
  //\r
  FormatLength = snprintf (\r
                   NULL,\r
                   0,\r
                   "%%%us | %%%us | %%%us | %%%us\n",\r
                   (unsigned) sizeof (Type) - 1,\r
                   (unsigned) sizeof (Address) - 1,\r
                   (unsigned) sizeof (Section) - 1,\r
                   (unsigned) sizeof (Token) - 1\r
                   ) + 1;\r
\r
  FormatString = (CHAR8 *) malloc (FormatLength);\r
  if (FormatString == NULL) {\r
    fclose (SourceFile);\r
    fclose (DestFile);\r
    Error (NULL, 0, 4001, "Resource", "memory cannot be allocated!");\r
    return EFI_ABORTED;\r
  }\r
\r
  snprintf (\r
    FormatString,\r
    FormatLength,\r
    "%%%us | %%%us | %%%us | %%%us\n",\r
    (unsigned) sizeof (Type) - 1,\r
    (unsigned) sizeof (Address) - 1,\r
    (unsigned) sizeof (Section) - 1,\r
    (unsigned) sizeof (Token) - 1\r
    );\r
\r
  //\r
  // Read in the file\r
  //\r
  while (feof (SourceFile) == 0) {\r
\r
    //\r
    // Read a line\r
    //\r
    if (fscanf (SourceFile, FormatString, Type, Address, Section, Token) == 4) {\r
\r
      //\r
      // Get the token address\r
      //\r
      AsciiStringToUint64 (Address, TRUE, &TokenAddress);\r
      if (TokenAddress > FileSize) {\r
        //\r
        // Symbol offset larger than FileSize. This Symbol can't be in Bin file. Don't print them.\r
        //\r
        break;\r
      }\r
\r
      //\r
      // Add the base address, the size of the FFS file header and the size of the peim header.\r
      //\r
      TokenAddress += BaseAddress &~IPF_CACHE_BIT;\r
\r
      fprintf (DestFile, "%s | %016llX | ", Type, (unsigned long long) TokenAddress);\r
      fprintf (DestFile, "%s | %s\n    %s\n", Section, Token, BaseToken); \r
    }\r
  }\r
\r
  free (FormatString);\r
  fclose (SourceFile);\r
  fclose (DestFile);\r
  return EFI_SUCCESS;\r
}\r
\r
EFI_STATUS\r
CalculateFitTableChecksum (\r
  VOID\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  This function will perform byte checksum on the FIT table, if the the checksum required\r
  field is set to CheckSum required. If the checksum is not required then checksum byte\r
  will have value as 0;.\r
\r
Arguments:\r
\r
  NONE\r
\r
Returns:\r
\r
  Status       - Value returned by call to CalculateChecksum8 ()\r
  EFI_SUCCESS  - The function completed successfully\r
\r
--*/\r
{\r
  FIT_TABLE *TmpFitPtr;\r
  UINT64    FitTableAdd;\r
  UINT64    FitTableAddOffset;\r
  UINTN     RelativeAddress;\r
  UINTN     Size;\r
\r
  //\r
  // Read the Fit Table address from Itanium-based address map.\r
  //\r
  FitTableAddOffset = Fv1EndAddress - (SIZE_IA32_RESET_VECT + SIZE_SALE_ENTRY_POINT + SIZE_FIT_TABLE_ADD);\r
\r
  //\r
  // Translate this Itanium-based address in terms of local buffer address which\r
  // contains the image for Boot Strapped File\r
  //\r
  GetRelativeAddressInVtfBuffer (FitTableAddOffset, &RelativeAddress, FIRST_VTF);\r
  FitTableAdd = *(UINTN *) RelativeAddress;\r
\r
  GetRelativeAddressInVtfBuffer (FitTableAdd, &RelativeAddress, FIRST_VTF);\r
\r
  TmpFitPtr = (FIT_TABLE *) RelativeAddress;\r
\r
  Size      = TmpFitPtr->CompSize * 16;\r
\r
  if ((TmpFitPtr->CvAndType & CHECKSUM_BIT_MASK) >> 7) {\r
    TmpFitPtr->CheckSum = 0;\r
    TmpFitPtr->CheckSum = CalculateChecksum8 ((UINT8 *) TmpFitPtr, Size);\r
  } else {\r
    TmpFitPtr->CheckSum = 0;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
VOID\r
Version (\r
  VOID\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Displays the standard utility information to SDTOUT\r
\r
Arguments:\r
\r
  None\r
\r
Returns:\r
\r
  None\r
\r
--*/\r
{\r
  fprintf (stdout, "%s Version %d.%d %s \n", UTILITY_NAME, UTILITY_MAJOR_VERSION, UTILITY_MINOR_VERSION, __BUILD_VERSION);\r
}\r
\r
VOID\r
Usage (\r
  VOID\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Displays the utility usage syntax to STDOUT\r
\r
Arguments:\r
\r
  None\r
\r
Returns:\r
\r
  None\r
\r
--*/\r
{\r
  //\r
  // Summary usage\r
  //\r
  fprintf (stdout, "Usage: %s [options] <-f input_file> <-r BaseAddress> <-s FwVolumeSize>\n\n", UTILITY_NAME);\r
\r
  //\r
  // Copyright declaration\r
  //\r
  fprintf (stdout, "Copyright (c) 2007 - 2014, Intel Corporation. All rights reserved.\n\n");\r
  //\r
  // Details Option\r
  //\r
  fprintf (stdout, "Options:\n");\r
  fprintf (stdout, "  -f Input_file,   --filename Input_file\n\\r
                        Input_file is name of the BS Image INF file\n");\r
  fprintf (stdout, "  -r BaseAddress,  --baseaddr BaseAddress\n\\r
                        BaseAddress is the starting address of Firmware Volume\n\\r
                        where Boot Strapped Image will reside.\n");\r
  fprintf (stdout, "  -s FwVolumeSize, --size FwVolumeSize\n\\r
                        FwVolumeSize is the size of Firmware Volume.\n");\r
  fprintf (stdout, "  -o FileName,     --output FileName\n\\r
                        File will be created to store the ouput content.\n");\r
  fprintf (stdout, "  -v, --verbose         Turn on verbose output with informational messages.\n");\r
  fprintf (stdout, "  --version             Show program's version number and exit.\n");\r
  fprintf (stdout, "  -h, --help            Show this help message and exit.\n");\r
  fprintf (stdout, "  -q, --quiet           Disable all messages except FATAL ERRORS.\n");\r
  fprintf (stdout, "  -d, --debug [#, 0-9]  Enable debug messages at level #.\n");\r
}\r
\r
int\r
main (\r
  IN  int  argc,\r
  IN  char  **argv\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  This utility uses GenVtf.dll to build a Boot Strap File Image which will be\r
  part of firmware volume image.\r
\r
Arguments:\r
\r
  argc   - The count of the parameters\r
  argv   - The parameters\r
\r
\r
Returns:\r
\r
  0   - No error conditions detected.\r
  1   - One or more of the input parameters is invalid.\r
  2   - A resource required by the utility was unavailable.\r
      - Most commonly this will be memory allocation or file creation.\r
  3   - GenFvImage.dll could not be loaded.\r
  4   - Error executing the GenFvImage dll.\r
  5   - Now this tool does not support the IA32 platform\r
\r
--*/\r
{\r
  UINT8          Index;\r
  UINT64         StartAddress1;\r
  UINT64         StartAddress2;\r
  UINT64         FwVolSize1;\r
  UINT64         FwVolSize2;\r
  BOOLEAN       FirstRoundO;\r
  BOOLEAN       FirstRoundB;\r
  BOOLEAN       FirstRoundS;\r
  EFI_STATUS    Status;\r
  FILE          *VtfFP;\r
  CHAR8         *VtfFileName;\r
\r
  SetUtilityName (UTILITY_NAME);\r
\r
  //\r
  // Initialize variables\r
  //\r
  StartAddress1 = 0;\r
  StartAddress2 = 0;\r
  FwVolSize1    = 0;\r
  FwVolSize2    = 0;\r
  FirstRoundB   = TRUE;\r
  FirstRoundS   = TRUE;\r
  FirstRoundO   = TRUE;\r
  DebugMode     = FALSE;\r
  OutFileName1  = NULL;\r
  OutFileName2  = NULL;\r
  VtfFP = NULL;\r
  DebugLevel = 0;\r
\r
  //\r
  // Verify the correct number of arguments\r
  //\r
  if (argc == 1) {\r
    Usage();\r
    return 0;\r
  }\r
\r
  if ((strcmp(argv[1], "-h") == 0) || (strcmp(argv[1], "--help") == 0)) {\r
    Usage();\r
    return 0;\r
  }\r
\r
  if ((strcmp(argv[1], "--version") == 0)) {\r
    Version();\r
    return 0;\r
  }\r
\r
  //\r
  // Parse the command line arguments\r
  //\r
  for (Index = 1; Index < argc; Index += 2) {\r
    if ((stricmp (argv[Index], "-o") == 0) || (stricmp (argv[Index], "--output") == 0)) {\r
      if (argv[Index + 1] == NULL || argv[Index + 1][0] == '-') {\r
        Error (NULL, 0, 1003, "Invalid option value", "Output file is missing for -o option");\r
        goto ERROR;\r
      }\r
      //\r
      // Get the output file name\r
      //\r
      VTF_OUTPUT = TRUE;\r
      if (FirstRoundO) {\r
        //\r
        // It's the first output file name\r
        //\r
        OutFileName1 = (CHAR8 *)argv[Index+1];\r
        FirstRoundO = FALSE;\r
      } else {\r
        //\r
        //It's the second output file name\r
        //\r
        OutFileName2 = (CHAR8 *)argv[Index+1];\r
      }\r
      continue;\r
    }\r
\r
    if ((stricmp (argv[Index], "-f") == 0) || (stricmp (argv[Index], "--filename") == 0)) {\r
      if (argv[Index + 1] == NULL || argv[Index + 1][0] == '-') {\r
        Error (NULL, 0, 1003, "Invalid option value", "BS Image INF file is missing for -f option");\r
        goto ERROR;\r
      }\r
      //\r
      // Get the input VTF file name\r
      //\r
      VtfFileName = argv[Index+1];\r
      if (VtfFP != NULL) {\r
        //\r
        // VTF file name has been given previously, override with the new value\r
        //\r
        fclose (VtfFP);\r
      }\r
      VtfFP = fopen (LongFilePath (VtfFileName), "rb");\r
      if (VtfFP == NULL) {\r
        Error (NULL, 0, 0001, "Error opening file", VtfFileName);\r
        goto ERROR;\r
      }\r
      continue;\r
    }\r
    \r
    if ((stricmp (argv[Index], "-r") == 0) || (stricmp (argv[Index], "--baseaddr") == 0)) {\r
      if (FirstRoundB) {\r
        Status      = AsciiStringToUint64 (argv[Index + 1], FALSE, &StartAddress1);\r
        FirstRoundB = FALSE;\r
      } else {\r
        Status = AsciiStringToUint64 (argv[Index + 1], FALSE, &StartAddress2);\r
      }\r
      if (Status != EFI_SUCCESS) {\r
        Error (NULL, 0, 2000, "Invalid option value", "%s is Bad FV start address.", argv[Index + 1]);\r
        goto ERROR;\r
      }  \r
      continue;\r
    }\r
\r
    if ((stricmp (argv[Index], "-s") == 0) || (stricmp (argv[Index], "--size") == 0)) {\r
      if (FirstRoundS) {\r
        Status      = AsciiStringToUint64 (argv[Index + 1], FALSE, &FwVolSize1);\r
        FirstRoundS = FALSE;\r
      } else {\r
        Status = AsciiStringToUint64 (argv[Index + 1], FALSE, &FwVolSize2);\r
    	  SecondVTF = TRUE;\r
      }\r
\r
      if (Status != EFI_SUCCESS) {\r
        Error (NULL, 0, 2000, "Invalid option value", "%s is Bad FV size.", argv[Index + 1]);\r
        goto ERROR;\r
      }\r
      continue;\r
    }\r
\r
    if ((stricmp (argv[Index], "-v") == 0) || (stricmp (argv[Index], "--verbose") == 0)) {\r
	    VerboseMode = TRUE;\r
	    Index--;\r
      continue;\r
    }\r
\r
    if ((stricmp (argv[Index], "-q") == 0) || (stricmp (argv[Index], "--quiet") == 0)) {\r
      QuietMode = TRUE;\r
      Index--;\r
      continue;\r
    }\r
\r
    if ((stricmp (argv[Index], "-d") == 0) || (stricmp (argv[Index], "--debug") == 0)) {\r
      //\r
      // debug level specified\r
      //\r
      Status = AsciiStringToUint64(argv[Index + 1], FALSE, &DebugLevel);\r
      if (EFI_ERROR (Status)) {\r
        Error (NULL, 0, 1003, "Invalid option value", "%s = %s", argv[Index], argv[Index + 1]);\r
        goto ERROR;\r
      }\r
      if (DebugLevel > 9)  {\r
        Error (NULL, 0, 2000, "Invalid option value", "Unrecognized argument %s.", argv[Index + 1]);\r
        goto ERROR;\r
      }\r
      if((DebugLevel <= 9) &&(DebugLevel >= 5)) {\r
        DebugMode = TRUE;\r
      } else {\r
        DebugMode = FALSE;\r
      }\r
      continue;\r
    }\r
\r
    Error (NULL, 0, 2000, "Invalid parameter", "Unrecognized argument %s.", argv[Index]);\r
    goto ERROR;\r
  }\r
\r
  if (VtfFP == NULL) {\r
    Error (NULL, 0, 2000, "Invalid parameter", "No BS Image INF file is specified");\r
    goto ERROR;\r
  }\r
\r
  if (FirstRoundB) {\r
    Error (NULL, 0, 2000, "Invalid parameter", "No FV base address is specified");\r
    goto ERROR;\r
  }\r
\r
  if (FirstRoundS) {\r
    Error (NULL, 0, 2000, "Invalid parameter", "No FV Size is specified");\r
    goto ERROR;\r
  }\r
  //\r
  // All Parameters has been parsed, now set the message print level\r
  //\r
  if (QuietMode) {\r
    SetPrintLevel(40);\r
  } else if (VerboseMode) {\r
    SetPrintLevel(15);\r
  } else if (DebugMode) {\r
    SetPrintLevel(DebugLevel);\r
  }\r
\r
  if (VerboseMode) {\r
    VerboseMsg("%s tool start.\n", UTILITY_NAME);\r
  }\r
\r
  if (VTF_OUTPUT == FALSE) {\r
    if (SecondVTF == TRUE) {\r
      OutFileName1 = VTF_OUTPUT_FILE1;\r
      OutFileName2 = VTF_OUTPUT_FILE2;\r
	  } else {\r
      OutFileName1 = VTF_OUTPUT_FILE1;\r
    }\r
    SymFileName = VTF_SYM_FILE;\r
  } else {\r
    assert (OutFileName1);\r
    INTN OutFileNameLen = strlen(OutFileName1);\r
    INTN NewIndex;\r
\r
    for (NewIndex = OutFileNameLen; NewIndex > 0; --NewIndex) {\r
      if (OutFileName1[NewIndex] == '/' || OutFileName1[NewIndex] == '\\') {\r
        break;\r
      }\r
    }\r
    if (NewIndex == 0) {\r
      SymFileName = VTF_SYM_FILE;\r
    } else {\r
      INTN SymFileNameLen = NewIndex + 1 + strlen(VTF_SYM_FILE);\r
      SymFileName = malloc(SymFileNameLen + 1);\r
      if (SymFileName == NULL) {\r
        Error (NULL, 0, 4001, "Resource", "memory cannot be allocated!");\r
        goto ERROR;\r
      }\r
      memcpy(SymFileName, OutFileName1, NewIndex + 1);\r
      memcpy(SymFileName + NewIndex + 1, VTF_SYM_FILE, strlen(VTF_SYM_FILE));\r
      SymFileName[SymFileNameLen] = '\0';\r
    }\r
    if (DebugMode) {\r
      DebugMsg(UTILITY_NAME, 0, DebugLevel, SymFileName, NULL);\r
    }\r
  }\r
\r
  //\r
  // Call the GenVtfImage\r
  //\r
  if (DebugMode) {\r
    DebugMsg(UTILITY_NAME, 0, DebugLevel, "Start to generate the VTF image\n", NULL);\r
  }\r
  Status = GenerateVtfImage (StartAddress1, FwVolSize1, StartAddress2, FwVolSize2, VtfFP);\r
\r
  if (EFI_ERROR (Status)) {\r
    switch (Status) {\r
\r
    case EFI_INVALID_PARAMETER:\r
      Error (NULL, 0, 2000, "Invalid parameter", "Invalid parameter passed to GenVtf function.");\r
      break;\r
\r
    case EFI_ABORTED:\r
      Error (NULL, 0, 3000, "Invalid", "Error detected while creating the file image.");\r
      break;\r
\r
    case EFI_OUT_OF_RESOURCES:\r
      Error (NULL, 0, 4002, "Resource", "GenVtfImage function could not allocate required resources.");\r
      break;\r
\r
    case EFI_VOLUME_CORRUPTED:\r
      Error (NULL, 0, 3000, "Invalid", "No base address was specified.");\r
      break;\r
\r
    default:\r
      Error (NULL, 0, 3000, "Invalid", "GenVtfImage function returned unknown status %x.", (int) Status );\r
      break;\r
    }\r
  }\r
ERROR:\r
  if (VtfFP != NULL) {\r
    fclose (VtfFP);\r
  }\r
\r
  if (DebugMode) {\r
    DebugMsg(UTILITY_NAME, 0, DebugLevel, "VTF image generated successful\n", NULL);\r
  }\r
\r
  if (VerboseMode) {\r
    VerboseMsg("%s tool done with return code is 0x%x.\n", UTILITY_NAME, GetUtilityStatus ());\r
  }\r
  return GetUtilityStatus();\r
}\r