BaseTools/Source/C/GenVtf/GenVtf.c

   1 /** @file
   2 This file contains functions required to generate a boot strap file (BSF) also
   3 known as the Volume Top File (VTF)
   4
   5 Copyright (c) 1999 - 2017, Intel Corporation. All rights reserved.<BR>
   6 This program and the accompanying materials are licensed and made available
   7 under the terms and conditions of the BSD License which accompanies this
   8 distribution.  The full text of the license may be found at
   9 http://opensource.org/licenses/bsd-license.php
  10
  11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  13
  14 **/
  15
  16 //
  17 //
  18 //
  19 #include <FvLib.h>
  20 #include <Common/UefiBaseTypes.h>
  21 #include "GenVtf.h"
  22 #include <Guid/PiFirmwareFileSystem.h>
  23 #include "CommonLib.h"
  24 #include "EfiUtilityMsgs.h"
  25
  26 //
  27 // Global variables
  28 //
  29 UINTN SectionOptionFlag = 0;
  30 UINTN SectionCompFlag = 0;
  31
  32 UINT64        DebugLevel;
  33 BOOLEAN       DebugMode;
  34
  35 BOOLEAN     QuietMode = FALSE;
  36
  37 BOOLEAN     VTF_OUTPUT = FALSE;
  38 CHAR8       *OutFileName1;
  39 CHAR8       *OutFileName2;
  40 CHAR8       *SymFileName;
  41
  42 CHAR8           **TokenStr;
  43 CHAR8           **OrgStrTokPtr;
  44
  45 PARSED_VTF_INFO *FileListPtr;
  46 PARSED_VTF_INFO *FileListHeadPtr;
  47
  48 VOID            *Vtf1Buffer;
  49 VOID            *Vtf1EndBuffer;
  50 VOID            *Vtf2Buffer;
  51 VOID            *Vtf2EndBuffer;
  52
  53 UINTN           ValidLineNum        = 0;
  54 UINTN           ValidFFDFileListNum = 0;
  55
  56 //
  57 // Section Description and their number of occurences in *.INF file
  58 //
  59 UINTN           NumFvFiles        = 0;
  60 UINTN           SectionOptionNum  = 0;
  61
  62 //
  63 // Global flag which will check for VTF Present, if yes then will be used
  64 // to decide about adding FFS header to pad data
  65 //
  66 BOOLEAN         VTFPresent = FALSE;
  67 BOOLEAN         SecondVTF = FALSE;
  68
  69 //
  70 // Address related information
  71 //
  72 UINT64          Fv1BaseAddress        = 0;
  73 UINT64          Fv2BaseAddress        = 0;
  74 UINT64          Fv1EndAddress         = 0;
  75 UINT64          Fv2EndAddress         = 0;
  76 UINT32          Vtf1TotalSize         = SIZE_TO_OFFSET_PAL_A_END;
  77 UINT64          Vtf1LastStartAddress  = 0;
  78 UINT32          Vtf2TotalSize         = 0;
  79 UINT64          Vtf2LastStartAddress  = 0;
  80
  81 UINT32          BufferToTop           = 0;
  82
  83 //
  84 // IA32 Reset Vector Bin name
  85 //
  86 CHAR8           IA32BinFile[FILE_NAME_SIZE];
  87
  88 //
  89 // Function Implementations
  90 //
  91 EFI_STATUS
  92 ConvertVersionInfo (
  93   IN      CHAR8     *Str,
  94   IN OUT  UINT8     *MajorVer,
  95   IN OUT  UINT8     *MinorVer
  96   )
  97 /*++
  98 Routine Description:
  99
 100   This function split version to major version and minor version
 101
 102 Arguments:
 103
 104   Str      - String representing in form XX.XX
 105   MajorVer - The major version
 106   MinorVer - The minor version
 107
 108 Returns:
 109
 110   EFI_SUCCESS  - The function completed successfully.
 111
 112 --*/
 113 {
 114   CHAR8  TemStr[5] = "0000";
 115   int    Major;
 116   int    Minor;
 117   UINTN Length;
 118
 119   Major = 0;
 120   Minor = 0;
 121
 122   if (strstr (Str, ".") != NULL) {
 123     sscanf (
 124       Str,
 125       "%02x.%02x",
 126       &Major,
 127       &Minor
 128       );
 129   } else {
 130     Length = strlen(Str);
 131     if (Length < 4) {
 132       strncpy (TemStr + 4 - Length, Str, Length);
 133     } else {
 134       strncpy (TemStr, Str + Length - 4, 4);
 135     }
 136
 137     sscanf (
 138       TemStr,
 139       "%02x%02x",
 140       &Major,
 141       &Minor
 142       );
 143   }
 144
 145   *MajorVer = (UINT8) Major;
 146   *MinorVer = (UINT8) Minor;
 147   return EFI_SUCCESS;
 148 }
 149
 150 VOID
 151 TrimLine (
 152   IN  CHAR8 *Line
 153   )
 154 /*++
 155 Routine Description:
 156
 157   This function cleans up the line by removing all whitespace and
 158   comments
 159
 160 Arguments:
 161
 162   Line   - The pointer of the string
 163
 164 Returns:
 165
 166   None
 167
 168 --*/
 169 {
 170   CHAR8 TmpLine[FILE_NAME_SIZE];
 171   CHAR8 Char;
 172   CHAR8 *Ptr0;
 173   UINTN Index;
 174   UINTN Index2;
 175
 176   //
 177   // Change '#' to '//' for Comment style
 178   //
 179   if (((Ptr0 = strchr (Line, '#')) != NULL) || ((Ptr0 = strstr (Line, "//")) != NULL)) {
 180     Line[Ptr0 - Line] = 0;
 181   }
 182
 183   //
 184   // Initialize counters
 185   //
 186   Index   = 0;
 187   Index2  = 0;
 188
 189   while ((Char = Line[Index]) != 0) {
 190     if ((Char != ' ') && (Char != '\t') && (Char != '\n') && (Char != '\r')) {
 191       TmpLine[Index2++] = Char;
 192     }
 193     Index++;
 194   }
 195
 196   TmpLine[Index2] = 0;
 197   strcpy (Line, TmpLine);
 198 }
 199
 200 VOID
 201 ValidLineCount (
 202   IN  FILE *Fp
 203   )
 204 /*++
 205
 206 Routine Description:
 207
 208   This function calculated number of valid lines in a input file.
 209
 210 Arguments:
 211
 212   Fp    - Pointer to a file handle which has been opened.
 213
 214 Returns:
 215
 216   None
 217
 218 --*/
 219 {
 220   CHAR8 Buff[FILE_NAME_SIZE];
 221   while (fgets(Buff, sizeof (Buff), Fp)) {
 222     TrimLine (Buff);
 223     if (Buff[0] == 0) {
 224       continue;
 225     }
 226     ValidLineNum++;
 227   }
 228 }
 229
 230 EFI_STATUS
 231 ParseInputFile (
 232   IN  FILE *Fp
 233   )
 234 /*++
 235
 236 Routine Description:
 237
 238   This function parses the input file and tokenize the string
 239
 240 Arguments:
 241
 242   Fp    - Pointer to a file handle which has been opened.
 243
 244 Returns:
 245
 246   None
 247
 248 --*/
 249 {
 250   CHAR8 *Token;
 251   CHAR8 Buff[FILE_NAME_SIZE + 1];
 252   CHAR8 Delimit[] = "=";
 253
 254   Buff [FILE_NAME_SIZE] = '\0';
 255   Token = NULL;
 256
 257   while (fgets (Buff, FILE_NAME_SIZE, Fp) != NULL) {
 258     TrimLine (Buff);
 259     if (Buff[0] == 0) {
 260       continue;
 261     }
 262     Token = strtok (Buff, Delimit);
 263     while (Token != NULL) {
 264       strcpy (*TokenStr, Token);
 265       TokenStr ++;
 266       Token = strtok (NULL, Delimit);
 267     }
 268   }
 269   return EFI_SUCCESS;
 270 }
 271
 272 EFI_STATUS
 273 InitializeComps (
 274   VOID
 275   )
 276 /*++
 277
 278 Routine Description:
 279
 280   This function initializes the relevant global variable which is being
 281   used to store the information retrieved from INF file.  This also initializes
 282   the VTF symbol file.
 283
 284 Arguments:
 285
 286   None
 287
 288 Returns:
 289
 290   EFI_SUCCESS            - The function completed successfully
 291   EFI_OUT_OF_RESOURCES   - Malloc failed.
 292
 293 --*/
 294 {
 295
 296   FileListPtr = malloc (sizeof (PARSED_VTF_INFO));
 297
 298   if (FileListPtr == NULL) {
 299     return EFI_OUT_OF_RESOURCES;
 300   }
 301
 302   FileListHeadPtr = FileListPtr;
 303   memset (FileListPtr, 0, sizeof (PARSED_VTF_INFO));
 304   FileListPtr->NextVtfInfo = NULL;
 305
 306   remove (SymFileName);
 307   return EFI_SUCCESS;
 308 }
 309
 310 VOID
 311 ParseAndUpdateComponents (
 312   IN  PARSED_VTF_INFO   *VtfInfo
 313   )
 314 /*++
 315
 316 Routine Description:
 317
 318   This function initializes the relevant global variable which is being
 319   used to store the information retrieved from INF file.
 320
 321 Arguments:
 322
 323   VtfInfo  - A pointer to the VTF Info Structure
 324
 325
 326 Returns:
 327
 328   None
 329
 330 --*/
 331 {
 332   UINT64  StringValue;
 333
 334   while (*TokenStr != NULL && (strnicmp (*TokenStr, "COMP_NAME", 9) != 0)) {
 335
 336     if (strnicmp (*TokenStr, "COMP_LOC", 8) == 0) {
 337       TokenStr++;
 338       if (strnicmp (*TokenStr, "F", 1) == 0) {
 339         VtfInfo->LocationType = FIRST_VTF;
 340       } else if (strnicmp (*TokenStr, "S", 1) == 0) {
 341         VtfInfo->LocationType = SECOND_VTF;
 342       } else {
 343         VtfInfo->LocationType = NONE;
 344       }
 345     } else if (strnicmp (*TokenStr, "COMP_TYPE", 9) == 0) {
 346       TokenStr++;
 347       if (AsciiStringToUint64 (*TokenStr, FALSE, &StringValue) != EFI_SUCCESS) {
 348         Error (NULL, 0, 5001, "Cannot get: \"0x%s\".", *TokenStr);
 349         return ;
 350       }
 351
 352       VtfInfo->CompType = (UINT8) StringValue;
 353     } else if (strnicmp (*TokenStr, "COMP_VER", 8) == 0) {
 354       TokenStr++;
 355       if (strnicmp (*TokenStr, "-", 1) == 0) {
 356         VtfInfo->VersionPresent = FALSE;
 357         VtfInfo->MajorVer       = 0;
 358         VtfInfo->MinorVer       = 0;
 359       } else {
 360         VtfInfo->VersionPresent = TRUE;
 361         ConvertVersionInfo (*TokenStr, &VtfInfo->MajorVer, &VtfInfo->MinorVer);
 362       }
 363     } else if (strnicmp (*TokenStr, "COMP_BIN", 8) == 0) {
 364       TokenStr++;
 365       strcpy (VtfInfo->CompBinName, *TokenStr);
 366     } else if (strnicmp (*TokenStr, "COMP_SYM", 8) == 0) {
 367       TokenStr++;
 368       strcpy (VtfInfo->CompSymName, *TokenStr);
 369     } else if (strnicmp (*TokenStr, "COMP_SIZE", 9) == 0) {
 370       TokenStr++;
 371       if (strnicmp (*TokenStr, "-", 1) == 0) {
 372         VtfInfo->PreferredSize  = FALSE;
 373         VtfInfo->CompSize       = 0;
 374       } else {
 375         VtfInfo->PreferredSize = TRUE;
 376         if (AsciiStringToUint64 (*TokenStr, FALSE, &StringValue) != EFI_SUCCESS) {
 377           Error (NULL, 0, 5001, "Parse error", "Cannot get: %s.", TokenStr);
 378           return ;
 379         }
 380
 381         VtfInfo->CompSize = (UINTN) StringValue;
 382       }
 383
 384     } else if (strnicmp (*TokenStr, "COMP_CS", 7) == 0) {
 385       TokenStr++;
 386       if (strnicmp (*TokenStr, "1", 1) == 0) {
 387         VtfInfo->CheckSumRequired = 1;
 388       } else if (strnicmp (*TokenStr, "0", 1) == 0) {
 389         VtfInfo->CheckSumRequired = 0;
 390       } else {
 391         Error (NULL, 0, 3000, "Invaild", "Bad value in INF file required field: Checksum, the value must be '0' or '1'.");
 392       }
 393     }
 394
 395     TokenStr++;
 396     if (*TokenStr == NULL) {
 397       break;
 398     }
 399   }
 400 }
 401
 402 VOID
 403 InitializeInFileInfo (
 404   VOID
 405   )
 406 /*++
 407
 408 Routine Description:
 409
 410   This function intializes the relevant global variable which is being
 411   used to store the information retrieved from INF file.
 412
 413 Arguments:
 414
 415   NONE
 416
 417 Returns:
 418
 419   NONE
 420
 421 --*/
 422 {
 423
 424   SectionOptionFlag = 0;
 425   SectionCompFlag   = 0;
 426   TokenStr          = OrgStrTokPtr;
 427
 428   while (*TokenStr != NULL) {
 429     if (strnicmp (*TokenStr, "[OPTIONS]", 9) == 0) {
 430       SectionOptionFlag = 1;
 431       SectionCompFlag   = 0;
 432     }
 433
 434     if (strnicmp (*TokenStr, "[COMPONENTS]", 12) == 0) {
 435       if (FileListPtr == NULL) {
 436         FileListPtr = FileListHeadPtr;
 437       }
 438
 439       SectionCompFlag   = 1;
 440       SectionOptionFlag = 0;
 441       TokenStr++;
 442     }
 443
 444     if (SectionOptionFlag) {
 445       if (stricmp (*TokenStr, "IA32_RST_BIN") == 0) {
 446         TokenStr++;
 447         strcpy (IA32BinFile, *TokenStr);
 448       }
 449     }
 450
 451     if (SectionCompFlag) {
 452       if (stricmp (*TokenStr, "COMP_NAME") == 0) {
 453         TokenStr++;
 454         strcpy (FileListPtr->CompName, *TokenStr);
 455         TokenStr++;
 456         ParseAndUpdateComponents (FileListPtr);
 457       }
 458
 459       if (*TokenStr != NULL) {
 460         FileListPtr->NextVtfInfo  = malloc (sizeof (PARSED_VTF_INFO));
 461         if (FileListPtr->NextVtfInfo == NULL) {
 462           Error (NULL, 0, 4003, "Resource", "Out of memory resources.", NULL);
 463           break;
 464         }
 465         FileListPtr = FileListPtr->NextVtfInfo;
 466         memset (FileListPtr, 0, sizeof (PARSED_VTF_INFO));
 467         FileListPtr->NextVtfInfo = NULL;
 468         continue;
 469       } else {
 470         break;
 471       }
 472     }
 473
 474     TokenStr++;
 475   }
 476 }
 477
 478 EFI_STATUS
 479 GetVtfRelatedInfoFromInfFile (
 480   IN FILE *FilePointer
 481   )
 482 /*++
 483
 484 Routine Description:
 485
 486   This function reads the input file, parse it and create a list of tokens
 487   which is parsed and used, to intialize the data related to VTF
 488
 489 Arguments:
 490
 491   FileName  - FileName which needed to be read to parse data
 492
 493 Returns:
 494
 495   EFI_ABORTED           - Error in opening file
 496   EFI_INVALID_PARAMETER - File doesn't contain any valid information
 497   EFI_OUT_OF_RESOURCES  - Malloc Failed
 498   EFI_SUCCESS           - The function completed successfully
 499
 500 --*/
 501 {
 502   FILE        *Fp;
 503   UINTN       Index;
 504   UINTN       Index1;
 505   EFI_STATUS  Status;
 506
 507   Status = EFI_SUCCESS;
 508   Fp = FilePointer;
 509   if (Fp == NULL) {
 510     Error (NULL, 0, 2000, "Invalid parameter", "BSF INF file is invalid!");
 511     return EFI_ABORTED;
 512   }
 513
 514   ValidLineCount (Fp);
 515
 516   if (ValidLineNum == 0) {
 517     Error (NULL, 0, 2000, "Invalid parameter", "File does not contain any valid information!");
 518     return EFI_INVALID_PARAMETER;
 519   }
 520
 521   TokenStr = (CHAR8 **) malloc (sizeof (UINTN) * (2 * ValidLineNum + 1));
 522
 523   if (TokenStr == NULL) {
 524     return EFI_OUT_OF_RESOURCES;
 525   }
 526
 527   memset (TokenStr, 0, (sizeof (UINTN) * (2 * ValidLineNum + 1)));
 528   OrgStrTokPtr = TokenStr;
 529
 530   for (Index = 0; Index < (2 * ValidLineNum); Index++) {
 531     *TokenStr = (CHAR8*)malloc (sizeof (CHAR8) * FILE_NAME_SIZE);
 532
 533     if (*TokenStr == NULL) {
 534       Status = EFI_OUT_OF_RESOURCES;
 535       goto ParseFileError;
 536     }
 537
 538     memset (*TokenStr, 0, FILE_NAME_SIZE);
 539     TokenStr++;
 540   }
 541
 542   TokenStr  = OrgStrTokPtr;
 543   fseek (Fp, 0L, SEEK_SET);
 544
 545   Status = InitializeComps ();
 546
 547   if (Status != EFI_SUCCESS) {
 548     goto ParseFileError;
 549   }
 550
 551   Status = ParseInputFile (Fp);
 552   if (Status != EFI_SUCCESS) {
 553     goto ParseFileError;
 554   }
 555
 556   InitializeInFileInfo ();
 557
 558 ParseFileError:
 559
 560   for (Index1 = 0; Index1 < Index; Index1 ++) {
 561     free (OrgStrTokPtr[Index1]);
 562   }
 563
 564   free (OrgStrTokPtr);
 565
 566   return Status;
 567 }
 568
 569 VOID
 570 GetRelativeAddressInVtfBuffer (
 571   IN      UINT64     Address,
 572   IN OUT  UINTN      *RelativeAddress,
 573   IN      LOC_TYPE   LocType
 574   )
 575 /*++
 576
 577 Routine Description:
 578
 579   This function checks for the address alignmnet for specified data boundary. In
 580   case the address is not aligned, it returns FALSE and the amount of data in
 581   terms of byte needed to adjust to get the boundary alignmnet. If data is
 582   aligned, TRUE will be returned.
 583
 584 Arguments:
 585
 586   Address             - The address of the flash map space
 587   RelativeAddress     - The relative address of the Buffer
 588   LocType             - The type of the VTF
 589
 590
 591 Returns:
 592
 593
 594 --*/
 595 {
 596   UINT64  TempAddress;
 597   UINT8   *LocalBuff;
 598
 599   if (LocType == FIRST_VTF) {
 600     LocalBuff         = (UINT8 *) Vtf1EndBuffer;
 601     TempAddress       = Fv1EndAddress - Address;
 602     *RelativeAddress  = (UINTN) LocalBuff - (UINTN) TempAddress;
 603   } else {
 604     LocalBuff         = (UINT8 *) Vtf2EndBuffer;
 605     TempAddress       = Fv2EndAddress - Address;
 606     *RelativeAddress  = (UINTN) LocalBuff - (UINTN) TempAddress;
 607   }
 608 }
 609
 610 EFI_STATUS
 611 GetComponentVersionInfo (
 612   IN  OUT PARSED_VTF_INFO   *VtfInfo,
 613   IN      UINT8             *Buffer
 614   )
 615 /*++
 616 Routine Description:
 617
 618   This function will extract the version information from File
 619
 620 Arguments:
 621
 622   VtfInfo  - A Pointer to the VTF Info Structure
 623   Buffer   - A Pointer to type UINT8
 624
 625 Returns:
 626
 627    EFI_SUCCESS           - The function completed successfully
 628    EFI_INVALID_PARAMETER - The parameter is invalid
 629
 630 --*/
 631 {
 632   UINT16      VersionInfo;
 633   EFI_STATUS  Status;
 634
 635   switch (VtfInfo->CompType) {
 636
 637   case COMP_TYPE_FIT_PAL_A:
 638   case COMP_TYPE_FIT_PAL_B:
 639     memcpy (&VersionInfo, (Buffer + 8), sizeof (UINT16));
 640     VtfInfo->MajorVer = (UINT8) ((VersionInfo & 0xFF00) >> 8);
 641     VtfInfo->MinorVer = (UINT8) (VersionInfo & 0x00FF);
 642     Status            = EFI_SUCCESS;
 643     break;
 644
 645   default:
 646     Status = EFI_INVALID_PARAMETER;
 647     break;
 648   }
 649
 650   return Status;
 651 }
 652
 653 BOOLEAN
 654 CheckAddressAlignment (
 655   IN      UINT64  Address,
 656   IN      UINT64  AlignmentData,
 657   IN OUT  UINT64  *AlignAdjustByte
 658   )
 659 /*++
 660
 661 Routine Description:
 662
 663   This function checks for the address alignmnet for specified data boundary. In
 664   case the address is not aligned, it returns FALSE and the amount of data in
 665   terms of byte needed to adjust to get the boundary alignmnet. If data is
 666   aligned, TRUE will be returned.
 667
 668 Arguments:
 669
 670   Address              - Pointer to buffer containing byte data of component.
 671   AlignmentData        - DataSize for which address needed to be aligned
 672   AlignAdjustByte      - Number of bytes needed to adjust alignment.
 673
 674 Returns:
 675
 676   TRUE                 - Address is aligned to specific data size boundary
 677   FALSE                - Address in not aligned to specified data size boundary
 678                        - Add/Subtract AlignAdjustByte to aling the address.
 679
 680 --*/
 681 {
 682   //
 683   // Check if the assigned address is on address boundary. If not, it will
 684   // return the remaining byte required to adjust the address for specified
 685   // address boundary
 686   //
 687   *AlignAdjustByte = (Address % AlignmentData);
 688
 689   if (*AlignAdjustByte == 0) {
 690     return TRUE;
 691   } else {
 692     return FALSE;
 693   }
 694 }
 695
 696 EFI_STATUS
 697 GetFitTableStartAddress (
 698   IN OUT  FIT_TABLE   **FitTable
 699   )
 700 /*++
 701
 702 Routine Description:
 703
 704   Get the FIT table start address in VTF Buffer
 705
 706 Arguments:
 707
 708   FitTable    - Pointer to available fit table where new component can be added
 709
 710 Returns:
 711
 712   EFI_SUCCESS - The function completed successfully
 713
 714 --*/
 715 {
 716   UINT64  FitTableAdd;
 717   UINT64  FitTableAddOffset;
 718   UINTN   RelativeAddress;
 719
 720   //
 721   // Read the Fit Table address from Itanium-based address map.
 722   //
 723   FitTableAddOffset = Fv1EndAddress - (SIZE_IA32_RESET_VECT + SIZE_SALE_ENTRY_POINT + SIZE_FIT_TABLE_ADD);
 724
 725   //
 726   // Translate this Itanium-based address in terms of local buffer address which
 727   // contains the image for Boot Strapped File. The relative address will be
 728   // the address of fit table VTF buffer.
 729   //
 730   GetRelativeAddressInVtfBuffer (FitTableAddOffset, &RelativeAddress, FIRST_VTF);
 731   FitTableAdd = *(UINTN *) RelativeAddress;
 732
 733   //
 734   // The FitTableAdd is the extracted Itanium based address pointing to FIT
 735   // table. The relative address will return its actual location in VTF
 736   // Buffer.
 737   //
 738   GetRelativeAddressInVtfBuffer (FitTableAdd, &RelativeAddress, FIRST_VTF);
 739
 740   *FitTable = (FIT_TABLE *) RelativeAddress;
 741
 742   return EFI_SUCCESS;
 743 }
 744
 745 EFI_STATUS
 746 GetNextAvailableFitPtr (
 747   IN  FIT_TABLE   **FitPtr
 748   )
 749 /*++
 750
 751 Routine Description:
 752
 753   Get the FIT table address and locate the free space in fit where we can add
 754   new component. In this process, this function locates the fit table using
 755   Fit pointer in Itanium-based address map (as per Intel?Itanium(TM) SAL spec)
 756   and locate the available location in FIT table to be used by new components.
 757   If there are any Fit table which areg not being used contains ComponentType
 758   field as 0x7F. If needed we can change this and spec this out.
 759
 760 Arguments:
 761
 762   FitPtr    - Pointer to available fit table where new component can be added
 763
 764 Returns:
 765
 766   EFI_SUCCESS  - The function completed successfully
 767
 768 --*/
 769 {
 770   FIT_TABLE *TmpFitPtr;
 771   UINT64    FitTableAdd;
 772   UINT64    FitTableAddOffset;
 773   UINTN     Index;
 774   UINTN     NumFitComponents;
 775   UINTN     RelativeAddress;
 776
 777   //
 778   // Read the Fit Table address from Itanium-based address map.
 779   //
 780   FitTableAddOffset = Fv1EndAddress - (SIZE_IA32_RESET_VECT + SIZE_SALE_ENTRY_POINT + SIZE_FIT_TABLE_ADD);
 781
 782   //
 783   // Translate this Itanium-based address in terms of local buffer address which
 784   // contains the image for Boot Strapped File. The relative address will be
 785   // the address of fit table VTF buffer.
 786   //
 787   GetRelativeAddressInVtfBuffer (FitTableAddOffset, &RelativeAddress, FIRST_VTF);
 788   FitTableAdd = *(UINTN *) RelativeAddress;
 789
 790   //
 791   // The FitTableAdd is the extracted Itanium based address pointing to FIT
 792   // table. The relative address will return its actual location in VTF
 793   // Buffer.
 794   //
 795   GetRelativeAddressInVtfBuffer (FitTableAdd, &RelativeAddress, FIRST_VTF);
 796
 797   TmpFitPtr         = (FIT_TABLE *) RelativeAddress;
 798   NumFitComponents  = TmpFitPtr->CompSize;
 799   *FitPtr           = NULL;
 800
 801   for (Index = 0; Index < NumFitComponents; Index++) {
 802     if ((TmpFitPtr->CvAndType & FIT_TYPE_MASK) == COMP_TYPE_FIT_UNUSED) {
 803       *FitPtr = TmpFitPtr;
 804       break;
 805     }
 806
 807     TmpFitPtr++;
 808   }
 809
 810   return EFI_SUCCESS;
 811 }
 812
 813 int
 814 CompareItems (
 815   IN const VOID  *Arg1,
 816   IN const VOID  *Arg2
 817   )
 818 /*++
 819
 820 Routine Description:
 821
 822     This function is used by qsort to sort the FIT table based upon Component
 823     Type in their incresing order.
 824
 825 Arguments:
 826
 827     Arg1  -   Pointer to Arg1
 828     Arg2  -   Pointer to Arg2
 829
 830 Returns:
 831
 832     None
 833
 834 --*/
 835 {
 836   if ((((FIT_TABLE *) Arg1)->CvAndType & FIT_TYPE_MASK) > (((FIT_TABLE *) Arg2)->CvAndType & FIT_TYPE_MASK)) {
 837     return 1;
 838   } else if ((((FIT_TABLE *) Arg1)->CvAndType & FIT_TYPE_MASK) < (((FIT_TABLE *) Arg2)->CvAndType & FIT_TYPE_MASK)) {
 839     return -1;
 840   } else {
 841     return 0;
 842   }
 843 }
 844
 845 VOID
 846 SortFitTable (
 847   IN  VOID
 848   )
 849 /*++
 850
 851 Routine Description:
 852
 853     This function is used by qsort to sort the FIT table based upon Component
 854     Type in their incresing order.
 855
 856 Arguments:
 857
 858     VOID
 859
 860 Returns:
 861
 862     None
 863
 864 --*/
 865 {
 866   FIT_TABLE *FitTable;
 867   FIT_TABLE *TmpFitPtr;
 868   UINTN     NumFitComponents;
 869   UINTN     Index;
 870
 871   GetFitTableStartAddress (&FitTable);
 872   TmpFitPtr         = FitTable;
 873   NumFitComponents  = 0;
 874   for (Index = 0; Index < FitTable->CompSize; Index++) {
 875     if ((TmpFitPtr->CvAndType & FIT_TYPE_MASK) != COMP_TYPE_FIT_UNUSED) {
 876       NumFitComponents += 1;
 877     }
 878     TmpFitPtr++;
 879   }
 880   qsort ((VOID *) FitTable, NumFitComponents, sizeof (FIT_TABLE), CompareItems);
 881 }
 882
 883 VOID
 884 UpdateFitEntryForFwVolume (
 885   IN  UINT64  Size
 886   )
 887 /*++
 888
 889 Routine Description:
 890
 891   This function updates the information about Firmware Volume  in FIT TABLE.
 892   This FIT table has to be immediately below the PAL_A Start and it contains
 893   component type and address information. Other information can't be
 894   created this time so we would need to fix it up..
 895
 896
 897 Arguments:
 898
 899   Size   - Firmware Volume Size
 900
 901 Returns:
 902
 903   VOID
 904
 905 --*/
 906 {
 907   FIT_TABLE *CompFitPtr;
 908   UINTN     RelativeAddress;
 909
 910   //
 911   // FV Fit table will be located at PAL_A Startaddress - 16 byte location
 912   //
 913   Vtf1LastStartAddress -= 0x10;
 914   Vtf1TotalSize += 0x10;
 915
 916   GetRelativeAddressInVtfBuffer (Vtf1LastStartAddress, &RelativeAddress, FIRST_VTF);
 917
 918   CompFitPtr              = (FIT_TABLE *) RelativeAddress;
 919   CompFitPtr->CompAddress = Fv1BaseAddress;
 920
 921   //
 922   // Since we don't have any information about its location in Firmware Volume,
 923   // initialize address to 0. This will be updated once Firmware Volume is
 924   // being build and its current address will be fixed in FIT table. Currently
 925   // we haven't implemented it so far and working on architectural clarafication
 926   //
 927   //
 928   // Firmware Volume Size in 16 byte block
 929   //
 930   CompFitPtr->CompSize = ((UINT32) Size) / 16;
 931
 932   //
 933   // Since Firmware Volume does not exist by the time we create this FIT info
 934   // this should be fixedup from Firmware Volume creation tool. We haven't
 935   // worked out a method so far.
 936   //
 937   CompFitPtr->CompVersion = MAKE_VERSION (0, 0);
 938
 939   //
 940   // Since we don't have any info about this file, we are making sure that
 941   // checksum is not needed.
 942   //
 943   CompFitPtr->CvAndType = CV_N_TYPE (0, COMP_TYPE_FIT_FV_BOOT);
 944
 945   //
 946   // Since non VTF component will reside outside the VTF, we will not have its
 947   // binary image while creating VTF, hence we will not perform checksum at
 948   // this time. Once Firmware Volume is being created which will contain this
 949   // VTF, it will fix the FIT table for all the non VTF component and hence
 950   // checksum
 951   //
 952   CompFitPtr->CheckSum = 0;
 953 }
 954
 955 EFI_STATUS
 956 UpdateFitEntryForNonVTFComp (
 957   IN  PARSED_VTF_INFO   *VtfInfo
 958   )
 959 /*++
 960
 961 Routine Description:
 962
 963   This function updates the information about non VTF component in FIT TABLE.
 964   Since non VTF componets binaries are not part of VTF binary, we would still
 965   be required to update its location information in Firmware Volume, inside
 966   FIT table.
 967
 968 Arguments:
 969
 970   VtfInfo    - Pointer to VTF Info Structure
 971
 972 Returns:
 973
 974   EFI_ABORTED  - The function fails to update the component in FIT
 975   EFI_SUCCESS  - The function completed successfully
 976
 977 --*/
 978 {
 979   FIT_TABLE *CompFitPtr;
 980
 981   //
 982   // Scan the FIT table for available space
 983   //
 984   GetNextAvailableFitPtr (&CompFitPtr);
 985   if (CompFitPtr == NULL) {
 986     Error (NULL, 0, 5003, "Invalid", "Can't update this component in FIT");
 987     return EFI_ABORTED;
 988   }
 989
 990   //
 991   // Since we don't have any information about its location in Firmware Volume,
 992   // initialize address to 0. This will be updated once Firmware Volume is
 993   // being build and its current address will be fixed in FIT table
 994   //
 995   CompFitPtr->CompAddress = 0;
 996   CompFitPtr->CompSize    = VtfInfo->CompSize;
 997   CompFitPtr->CompVersion = MAKE_VERSION (VtfInfo->MajorVer, VtfInfo->MinorVer);
 998   CompFitPtr->CvAndType   = CV_N_TYPE (VtfInfo->CheckSumRequired, VtfInfo->CompType);
 999
1000   //
1001   // Since non VTF component will reside outside the VTF, we will not have its
1002   // binary image while creating VTF, hence we will not perform checksum at
1003   // this time. Once Firmware Volume is being created which will contain this
1004   // VTF, it will fix the FIT table for all the non VTF component and hence
1005   // checksum
1006   //
1007   CompFitPtr->CheckSum = 0;
1008
1009   //
1010   // Fit Type is FV_BOOT which means Firmware Volume, we initialize this to base
1011   // address of Firmware Volume in which this VTF will be attached.
1012   //
1013   if ((CompFitPtr->CvAndType & 0x7F) == COMP_TYPE_FIT_FV_BOOT) {
1014     CompFitPtr->CompAddress = Fv1BaseAddress;
1015   }
1016
1017   return EFI_SUCCESS;
1018 }
1019
1020 //
1021 // !!!WARNING
1022 // This function is updating the SALE_ENTRY in Itanium address space as per SAL
1023 // spec. SALE_ENTRY is being read from SYM file of PEICORE. Once the PEI
1024 // CORE moves in Firmware Volume, we would need to modify this function to be
1025 // used with a API which will detect PEICORE component while building Firmware
1026 // Volume and update its entry in FIT table as well as in Itanium address space
1027 // as per Intel?Itanium(TM) SAL address space
1028 //
1029 EFI_STATUS
1030 UpdateEntryPoint (
1031   IN  PARSED_VTF_INFO   *VtfInfo,
1032   IN  UINT64            *CompStartAddress
1033   )
1034 /*++
1035
1036 Routine Description:
1037
1038   This function updated the architectural entry point in IPF, SALE_ENTRY.
1039
1040 Arguments:
1041
1042   VtfInfo            - Pointer to VTF Info Structure
1043   CompStartAddress   - Pointer to Component Start Address
1044
1045 Returns:
1046
1047   EFI_INVALID_PARAMETER  - The parameter is invalid
1048   EFI_SUCCESS            - The function completed successfully
1049
1050 --*/
1051 {
1052   UINTN   RelativeAddress;
1053   UINT64  SalEntryAdd;
1054   FILE    *Fp;
1055   UINTN   Offset;
1056
1057   CHAR8   Buff[FILE_NAME_SIZE];
1058   CHAR8   Buff1[10];
1059   CHAR8   Buff2[10];
1060   CHAR8   OffsetStr[30];
1061   CHAR8   Buff3[10];
1062   CHAR8   Buff4[10];
1063   CHAR8   Buff5[10];
1064   CHAR8   Token[50];
1065   CHAR8   FormatString[MAX_LINE_LEN];
1066
1067   Fp = fopen (LongFilePath (VtfInfo->CompSymName), "rb");
1068
1069   if (Fp == NULL) {
1070     Error (NULL, 0, 0001, "Error opening file", VtfInfo->CompSymName);
1071     return EFI_INVALID_PARAMETER;
1072   }
1073
1074   //
1075   // Generate the format string for fscanf
1076   //
1077   sprintf (
1078     FormatString,
1079     "%%%us %%%us %%%us %%%us %%%us %%%us %%%us",
1080     (unsigned) sizeof (Buff1) - 1,
1081     (unsigned) sizeof (Buff2) - 1,
1082     (unsigned) sizeof (OffsetStr) - 1,
1083     (unsigned) sizeof (Buff3) - 1,
1084     (unsigned) sizeof (Buff4) - 1,
1085     (unsigned) sizeof (Buff5) - 1,
1086     (unsigned) sizeof (Token) - 1
1087     );
1088
1089   while (fgets (Buff, sizeof (Buff), Fp) != NULL) {
1090     fscanf (
1091       Fp,
1092       FormatString,
1093       Buff1,
1094       Buff2,
1095       OffsetStr,
1096       Buff3,
1097       Buff4,
1098       Buff5,
1099       Token
1100       );
1101     if (strnicmp (Token, "SALE_ENTRY", 10) == 0) {
1102       break;
1103     }
1104   }
1105
1106   Offset = strtoul (OffsetStr, NULL, 16);
1107
1108   *CompStartAddress += Offset;
1109   SalEntryAdd = Fv1EndAddress - (SIZE_IA32_RESET_VECT + SIZE_SALE_ENTRY_POINT);
1110
1111   GetRelativeAddressInVtfBuffer (SalEntryAdd, &RelativeAddress, FIRST_VTF);
1112
1113   memcpy ((VOID *) RelativeAddress, (VOID *) CompStartAddress, sizeof (UINT64));
1114
1115   if (Fp != NULL) {
1116     fclose (Fp);
1117   }
1118
1119   return EFI_SUCCESS;
1120 }
1121
1122 EFI_STATUS
1123 CreateAndUpdateComponent (
1124   IN  PARSED_VTF_INFO   *VtfInfo
1125   )
1126 /*++
1127
1128 Routine Description:
1129
1130   This function reads the binary file for each components and update them
1131   in VTF Buffer as well as in FIT table. If the component is located in non
1132   VTF area, only the FIT table address will be updated
1133
1134 Arguments:
1135
1136   VtfInfo    - Pointer to Parsed Info
1137
1138 Returns:
1139
1140   EFI_SUCCESS      - The function completed successful
1141   EFI_ABORTED      - Aborted due to one of the many reasons like:
1142                       (a) Component Size greater than the specified size.
1143                       (b) Error opening files.
1144                       (c) Fail to get the FIT table address.
1145
1146   EFI_INVALID_PARAMETER     Value returned from call to UpdateEntryPoint()
1147   EFI_OUT_OF_RESOURCES      Memory allocation failure.
1148
1149 --*/
1150 {
1151   EFI_STATUS  Status;
1152   UINT64      CompStartAddress;
1153   UINT64      FileSize;
1154   UINT64      NumAdjustByte;
1155   UINT8       *Buffer;
1156   FILE        *Fp;
1157   FIT_TABLE   *CompFitPtr;
1158   BOOLEAN     Aligncheck;
1159
1160   if (VtfInfo->LocationType == NONE) {
1161     UpdateFitEntryForNonVTFComp (VtfInfo);
1162     return EFI_SUCCESS;
1163   }
1164
1165   Fp = fopen (LongFilePath (VtfInfo->CompBinName), "rb");
1166
1167   if (Fp == NULL) {
1168     Error (NULL, 0, 0001, "Error opening file", VtfInfo->CompBinName);
1169     return EFI_ABORTED;
1170   }
1171
1172   FileSize = _filelength (fileno (Fp));
1173   if ((VtfInfo->CompType == COMP_TYPE_FIT_PAL_B) || (VtfInfo->CompType == COMP_TYPE_FIT_PAL_A_SPECIFIC)) {
1174
1175     //
1176     // BUGBUG: Satish to correct
1177     //
1178     FileSize -= SIZE_OF_PAL_HEADER;
1179   }
1180
1181   if (VtfInfo->PreferredSize) {
1182     if (FileSize > VtfInfo->CompSize) {
1183       fclose (Fp);
1184       Error (NULL, 0, 2000, "Invalid parameter", "The component size is more than specified size.");
1185       return EFI_ABORTED;
1186     }
1187
1188     FileSize = VtfInfo->CompSize;
1189   }
1190
1191   Buffer = malloc ((UINTN) FileSize);
1192   if (Buffer == NULL) {
1193     fclose (Fp);
1194     return EFI_OUT_OF_RESOURCES;
1195   }
1196   memset (Buffer, 0, (UINTN) FileSize);
1197
1198   if ((VtfInfo->CompType == COMP_TYPE_FIT_PAL_B) || (VtfInfo->CompType == COMP_TYPE_FIT_PAL_A_SPECIFIC)) {
1199
1200     //
1201     // Read first 64 bytes of PAL header and use it to find version info
1202     //
1203     fread (Buffer, sizeof (UINT8), SIZE_OF_PAL_HEADER, Fp);
1204
1205     //
1206     // PAL header contains the version info. Currently, we will use the header
1207     // to read version info and then discard.
1208     //
1209     if (!VtfInfo->VersionPresent) {
1210       GetComponentVersionInfo (VtfInfo, Buffer);
1211     }
1212   }
1213
1214   fread (Buffer, sizeof (UINT8), (UINTN) FileSize, Fp);
1215   fclose (Fp);
1216
1217   //
1218   // If it is non PAL_B component, pass the entire buffer to get the version
1219   // info and implement any specific case inside GetComponentVersionInfo.
1220   //
1221   if (VtfInfo->CompType != COMP_TYPE_FIT_PAL_B) {
1222     if (!VtfInfo->VersionPresent) {
1223       GetComponentVersionInfo (VtfInfo, Buffer);
1224     }
1225   }
1226
1227   if (VtfInfo->LocationType == SECOND_VTF) {
1228
1229     CompStartAddress = (Vtf2LastStartAddress - FileSize);
1230   } else {
1231     CompStartAddress = (Vtf1LastStartAddress - FileSize);
1232   }
1233
1234   if (VtfInfo->CompType == COMP_TYPE_FIT_PAL_B) {
1235     Aligncheck = CheckAddressAlignment (CompStartAddress, 32 * 1024, &NumAdjustByte);
1236   } else {
1237     Aligncheck = CheckAddressAlignment (CompStartAddress, 8, &NumAdjustByte);
1238   }
1239
1240   if (!Aligncheck) {
1241     CompStartAddress -= NumAdjustByte;
1242   }
1243
1244   if (VtfInfo->LocationType == SECOND_VTF && SecondVTF == TRUE) {
1245     Vtf2LastStartAddress = CompStartAddress;
1246     Vtf2TotalSize += (UINT32) (FileSize + NumAdjustByte);
1247     Status = UpdateVtfBuffer (CompStartAddress, Buffer, FileSize, SECOND_VTF);
1248   } else if (VtfInfo->LocationType == FIRST_VTF) {
1249     Vtf1LastStartAddress = CompStartAddress;
1250     Vtf1TotalSize += (UINT32) (FileSize + NumAdjustByte);
1251     Status = UpdateVtfBuffer (CompStartAddress, Buffer, FileSize, FIRST_VTF);
1252   } else {
1253     free (Buffer);
1254     Error (NULL, 0, 2000,"Invalid Parameter", "There's component in second VTF so second BaseAddress and Size must be specified!");
1255     return EFI_INVALID_PARAMETER;
1256   }
1257
1258   if (EFI_ERROR (Status)) {
1259     free (Buffer);
1260     return EFI_ABORTED;
1261   }
1262
1263   GetNextAvailableFitPtr (&CompFitPtr);
1264   if (CompFitPtr == NULL) {
1265     free (Buffer);
1266     return EFI_ABORTED;
1267   }
1268
1269   CompFitPtr->CompAddress = CompStartAddress | IPF_CACHE_BIT;
1270   if ((FileSize % 16) != 0) {
1271     free (Buffer);
1272     Error (NULL, 0, 2000, "Invalid parameter", "Binary FileSize must be a multiple of 16.");
1273     return EFI_INVALID_PARAMETER;
1274   }
1275   //assert ((FileSize % 16) == 0);
1276   CompFitPtr->CompSize    = (UINT32) (FileSize / 16);
1277   CompFitPtr->CompVersion = MAKE_VERSION (VtfInfo->MajorVer, VtfInfo->MinorVer);
1278   CompFitPtr->CvAndType   = CV_N_TYPE (VtfInfo->CheckSumRequired, VtfInfo->CompType);
1279   if (VtfInfo->CheckSumRequired) {
1280     CompFitPtr->CheckSum  = 0;
1281     CompFitPtr->CheckSum  = CalculateChecksum8 (Buffer, (UINTN) FileSize);
1282   }
1283
1284   //
1285   // Free the buffer
1286   //
1287   if (Buffer) {
1288     free (Buffer);
1289   }
1290
1291   //
1292   // Update the SYM file for this component based on it's start address.
1293   //
1294   Status = UpdateSymFile (CompStartAddress, SymFileName, VtfInfo->CompSymName, FileSize);
1295   if (EFI_ERROR (Status)) {
1296
1297     //
1298     // At this time, SYM files are not required, so continue on error.
1299     //
1300   }
1301
1302   // !!!!!!!!!!!!!!!!!!!!!
1303   // BUGBUG:
1304   // This part of the code is a temporary line since PEICORE is going to be inside
1305   // VTF till we work out how to determine the SALE_ENTRY through it. We will need
1306   // to clarify so many related questions
1307   // !!!!!!!!!!!!!!!!!!!!!!!
1308
1309   if (VtfInfo->CompType == COMP_TYPE_FIT_PEICORE) {
1310     Status = UpdateEntryPoint (VtfInfo, &CompStartAddress);
1311   }
1312
1313   return Status;
1314 }
1315
1316 EFI_STATUS
1317 CreateAndUpdatePAL_A (
1318   IN  PARSED_VTF_INFO   *VtfInfo
1319   )
1320 /*++
1321
1322 Routine Description:
1323
1324   This function reads the binary file for each components and update them
1325   in VTF Buffer as well as FIT table
1326
1327 Arguments:
1328
1329   VtfInfo    - Pointer to Parsed Info
1330
1331 Returns:
1332
1333   EFI_ABORTED           - Due to one of the following reasons:
1334                            (a)Error Opening File
1335                            (b)The PAL_A Size is more than specified size status
1336                               One of the values mentioned below returned from
1337                               call to UpdateSymFile
1338   EFI_SUCCESS           - The function completed successfully.
1339   EFI_INVALID_PARAMETER - One of the input parameters was invalid.
1340   EFI_ABORTED           - An error occurred.UpdateSymFile
1341   EFI_OUT_OF_RESOURCES  - Memory allocation failed.
1342
1343 --*/
1344 {
1345   EFI_STATUS  Status;
1346   UINT64      PalStartAddress;
1347   UINT64      AbsAddress;
1348   UINTN       RelativeAddress;
1349   UINT64      FileSize;
1350   UINT8       *Buffer;
1351   FILE        *Fp;
1352   FIT_TABLE   *PalFitPtr;
1353
1354   Fp = fopen (LongFilePath (VtfInfo->CompBinName), "rb");
1355
1356   if (Fp == NULL) {
1357     Error (NULL, 0, 0001, "Error opening file", VtfInfo->CompBinName);
1358     return EFI_ABORTED;
1359   }
1360
1361   FileSize = _filelength (fileno (Fp));
1362   if (FileSize < 64) {
1363     fclose (Fp);
1364     Error (NULL, 0, 2000, "Invalid parameter", "PAL_A bin header is 64 bytes, so the Bin size must be larger than 64 bytes!");
1365     return EFI_INVALID_PARAMETER;
1366   }
1367   FileSize -= SIZE_OF_PAL_HEADER;
1368
1369
1370   if (VtfInfo->PreferredSize) {
1371     if (FileSize > VtfInfo->CompSize) {
1372       fclose (Fp);
1373       Error (NULL, 0, 2000, "Invalid parameter", "The PAL_A Size is more than the specified size.");
1374       return EFI_ABORTED;
1375     }
1376
1377     FileSize = VtfInfo->CompSize;
1378   }
1379
1380   Buffer = malloc ((UINTN) FileSize);
1381   if (Buffer == NULL) {
1382     fclose (Fp);
1383     return EFI_OUT_OF_RESOURCES;
1384   }
1385   memset (Buffer, 0, (UINTN) FileSize);
1386
1387   //
1388   // Read, Get version Info and discard the PAL header.
1389   //
1390   fread (Buffer, sizeof (UINT8), SIZE_OF_PAL_HEADER, Fp);
1391
1392   //
1393   // Extract the version info from header of PAL_A. Once done, discrad this buffer
1394   //
1395   if (!VtfInfo->VersionPresent) {
1396     GetComponentVersionInfo (VtfInfo, Buffer);
1397   }
1398
1399   //
1400   // Read PAL_A file in a buffer
1401   //
1402   fread (Buffer, sizeof (UINT8), (UINTN) FileSize, Fp);
1403   fclose (Fp);
1404
1405   PalStartAddress       = Fv1EndAddress - (SIZE_TO_OFFSET_PAL_A_END + FileSize);
1406   Vtf1LastStartAddress  = PalStartAddress;
1407   Vtf1TotalSize += (UINT32) FileSize;
1408   Status      = UpdateVtfBuffer (PalStartAddress, Buffer, FileSize, FIRST_VTF);
1409
1410   AbsAddress  = Fv1EndAddress - SIZE_TO_PAL_A_FIT;
1411   GetRelativeAddressInVtfBuffer (AbsAddress, &RelativeAddress, FIRST_VTF);
1412   PalFitPtr               = (FIT_TABLE *) RelativeAddress;
1413   PalFitPtr->CompAddress  = PalStartAddress | IPF_CACHE_BIT;
1414   //assert ((FileSize % 16) == 0);
1415   if ((FileSize % 16) != 0) {
1416     free (Buffer);
1417     Error (NULL, 0, 2000, "Invalid parameter", "Binary FileSize must be a multiple of 16.");
1418     return EFI_INVALID_PARAMETER;
1419   }
1420
1421   PalFitPtr->CompSize     = (UINT32) (FileSize / 16);
1422   PalFitPtr->CompVersion  = MAKE_VERSION (VtfInfo->MajorVer, VtfInfo->MinorVer);
1423   PalFitPtr->CvAndType    = CV_N_TYPE (VtfInfo->CheckSumRequired, VtfInfo->CompType);
1424   if (VtfInfo->CheckSumRequired) {
1425     PalFitPtr->CheckSum = 0;
1426     PalFitPtr->CheckSum = CalculateChecksum8 (Buffer, (UINTN) FileSize);
1427   }
1428
1429   if (Buffer) {
1430     free (Buffer);
1431   }
1432
1433   //
1434   // Update the SYM file for this component based on it's start address.
1435   //
1436   Status = UpdateSymFile (PalStartAddress, SymFileName, VtfInfo->CompSymName, FileSize);
1437   if (EFI_ERROR (Status)) {
1438
1439     //
1440     // At this time, SYM files are not required, so continue on error.
1441     //
1442   }
1443
1444   return Status;
1445 }
1446
1447 EFI_STATUS
1448 CreateFitTableAndInitialize (
1449   IN  PARSED_VTF_INFO   *VtfInfo
1450   )
1451 /*++
1452
1453 Routine Description:
1454
1455   This function creates and intializes FIT table which would be used to
1456   add component info inside this
1457
1458 Arguments:
1459
1460   VtfInfo    - Pointer to Parsed Info
1461
1462 Returns:
1463
1464   EFI_ABORTED  - Aborted due to no size information
1465   EFI_SUCCESS  - The function completed successfully
1466
1467 --*/
1468 {
1469   UINT64    PalFitTableAdd;
1470   UINT64    FitTableAdd;
1471   UINT64    FitTableAddressOffset;
1472   FIT_TABLE *PalFitPtr;
1473   FIT_TABLE *FitStartPtr;
1474   UINTN     NumFitComp;
1475   UINTN     RelativeAddress;
1476   UINTN     Index;
1477
1478   if (!VtfInfo->PreferredSize) {
1479     Error (NULL, 0, 2000, "Invalid parameter", "FIT could not be allocated because there is no size information.");
1480     return EFI_ABORTED;
1481   }
1482
1483   if ((VtfInfo->CompSize % 16) != 0) {
1484     Error (NULL, 0, 2000, "Invalid parameter", "Invalid FIT Table Size, it is not a multiple of 16 bytes. Please correct the size.");
1485   }
1486
1487   PalFitTableAdd = Fv1EndAddress - SIZE_TO_PAL_A_FIT;
1488   GetRelativeAddressInVtfBuffer (PalFitTableAdd, &RelativeAddress, FIRST_VTF);
1489   PalFitPtr             = (FIT_TABLE *) RelativeAddress;
1490   PalFitTableAdd        = (PalFitPtr->CompAddress - VtfInfo->CompSize);
1491
1492   FitTableAdd           = (PalFitPtr->CompAddress - 0x10) - VtfInfo->CompSize;
1493   FitTableAddressOffset = Fv1EndAddress - (SIZE_IA32_RESET_VECT + SIZE_SALE_ENTRY_POINT + SIZE_FIT_TABLE_ADD);
1494   GetRelativeAddressInVtfBuffer (FitTableAddressOffset, &RelativeAddress, FIRST_VTF);
1495   *(UINT64 *) RelativeAddress = FitTableAdd;
1496
1497   GetRelativeAddressInVtfBuffer (FitTableAdd, &RelativeAddress, FIRST_VTF);
1498
1499   //
1500   // Update Fit Table with FIT Signature and FIT info in first 16 bytes.
1501   //
1502   FitStartPtr = (FIT_TABLE *) RelativeAddress;
1503
1504   strncpy ((CHAR8 *) &FitStartPtr->CompAddress, FIT_SIGNATURE, 8);  // "_FIT_   "
1505   assert (((VtfInfo->CompSize & 0x00FFFFFF) % 16) == 0);
1506   FitStartPtr->CompSize     = (VtfInfo->CompSize & 0x00FFFFFF) / 16;
1507   FitStartPtr->CompVersion  = MAKE_VERSION (VtfInfo->MajorVer, VtfInfo->MinorVer);
1508
1509   //
1510   // BUGBUG: If a checksum is required, add code to checksum the FIT table.  Also
1511   // determine what to do for things like the FV component that aren't easily checksummed.
1512   // The checksum will be done once we are done with all the componet update in the FIT
1513   // table
1514   //
1515   FitStartPtr->CvAndType  = CV_N_TYPE (VtfInfo->CheckSumRequired, VtfInfo->CompType);
1516
1517   NumFitComp              = FitStartPtr->CompSize;
1518
1519   FitStartPtr++;
1520
1521   //
1522   // Intialize remaining FIT table space to UNUSED fit component type
1523   // so that when we need to create a FIT entry for a component, we can
1524   // locate a free one and use it.
1525   //
1526   for (Index = 0; Index < (NumFitComp - 1); Index++) {
1527     FitStartPtr->CvAndType = 0x7F;  // Initialize all with UNUSED
1528     FitStartPtr++;
1529   }
1530
1531   Vtf1TotalSize += VtfInfo->CompSize;
1532   Vtf1LastStartAddress -= VtfInfo->CompSize;
1533
1534   return EFI_SUCCESS;
1535 }
1536
1537 EFI_STATUS
1538 WriteVtfBinary (
1539   IN CHAR8     *FileName,
1540   IN UINT32    VtfSize,
1541   IN LOC_TYPE  LocType
1542   )
1543 /*++
1544
1545 Routine Description:
1546
1547   Write Firmware Volume from memory to a file.
1548
1549 Arguments:
1550
1551   FileName     - Output File Name which needed to be created/
1552   VtfSize      - FileSize
1553   LocType      - The type of the VTF
1554
1555 Returns:
1556
1557   EFI_ABORTED - Returned due to one of the following resons:
1558                  (a) Error Opening File
1559                  (b) Failing to copy buffers
1560   EFI_SUCCESS - The fuction completes successfully
1561
1562 --*/
1563 {
1564   FILE  *Fp;
1565   UINTN NumByte;
1566   VOID  *VtfBuffer;
1567   UINTN RelativeAddress;
1568
1569   if (LocType == FIRST_VTF) {
1570     GetRelativeAddressInVtfBuffer (Vtf1LastStartAddress, &RelativeAddress, FIRST_VTF);
1571     VtfBuffer = (VOID *) RelativeAddress;
1572   } else {
1573     GetRelativeAddressInVtfBuffer (Vtf2LastStartAddress, &RelativeAddress, SECOND_VTF);
1574     VtfBuffer = (VOID *) RelativeAddress;
1575   }
1576
1577   Fp = fopen (LongFilePath (FileName), "wb");
1578   if (Fp == NULL) {
1579     Error (NULL, 0, 0001, "Error opening file", FileName);
1580     return EFI_ABORTED;
1581   }
1582
1583   NumByte = fwrite (VtfBuffer, sizeof (UINT8), (UINTN) VtfSize, Fp);
1584
1585   if (Fp) {
1586     fclose (Fp);
1587   }
1588
1589   if (NumByte != (sizeof (UINT8) * VtfSize)) {
1590     Error (NULL, 0, 0002, "Error writing file", FileName);
1591     return EFI_ABORTED;
1592   }
1593
1594   return EFI_SUCCESS;
1595 }
1596
1597 EFI_STATUS
1598 UpdateVtfBuffer (
1599   IN  UINT64   StartAddress,
1600   IN  UINT8    *Buffer,
1601   IN  UINT64   DataSize,
1602   IN LOC_TYPE  LocType
1603   )
1604 /*++
1605
1606 Routine Description:
1607
1608   Update the Firmware Volume Buffer with requested buffer data
1609
1610 Arguments:
1611
1612   StartAddress   - StartAddress in buffer. This number will automatically
1613                   point to right address in buffer where data needed
1614                   to be updated.
1615   Buffer         - Buffer pointer from data will be copied to memory mapped buffer.
1616   DataSize       - Size of the data needed to be copied.
1617   LocType        - The type of the VTF: First or Second
1618
1619 Returns:
1620
1621   EFI_ABORTED  - The input parameter is error
1622   EFI_SUCCESS  - The function completed successfully
1623
1624 --*/
1625 {
1626   UINT8 *LocalBufferPtrToWrite;
1627
1628   if (LocType == FIRST_VTF) {
1629     if ((StartAddress | IPF_CACHE_BIT) < (Vtf1LastStartAddress | IPF_CACHE_BIT)) {
1630       Error (NULL, 0, 2000, "Invalid parameter", "Start Address is less than the VTF start address.");
1631       return EFI_ABORTED;
1632     }
1633
1634     LocalBufferPtrToWrite = (UINT8 *) Vtf1EndBuffer;
1635
1636     LocalBufferPtrToWrite -= (Fv1EndAddress - StartAddress);
1637
1638   } else {
1639
1640     if ((StartAddress | IPF_CACHE_BIT) < (Vtf2LastStartAddress | IPF_CACHE_BIT)) {
1641       Error (NULL, 0, 2000, "Invalid parameter", "Error StartAddress");
1642       return EFI_ABORTED;
1643     }
1644     LocalBufferPtrToWrite = (UINT8 *) Vtf2EndBuffer;
1645     LocalBufferPtrToWrite -= (Fv2EndAddress - StartAddress);
1646   }
1647
1648   memcpy (LocalBufferPtrToWrite, Buffer, (UINTN) DataSize);
1649
1650   return EFI_SUCCESS;
1651 }
1652
1653 EFI_STATUS
1654 UpdateFfsHeader (
1655   IN UINT32         TotalVtfSize,
1656   IN LOC_TYPE       LocType
1657   )
1658 /*++
1659
1660 Routine Description:
1661
1662   Update the Firmware Volume Buffer with requested buffer data
1663
1664 Arguments:
1665
1666   TotalVtfSize     - Size of the VTF
1667   Fileoffset       - The start of the file relative to the start of the FV.
1668   LocType          - The type of the VTF
1669
1670 Returns:
1671
1672   EFI_SUCCESS            - The function completed successfully
1673   EFI_INVALID_PARAMETER  - The Ffs File Header Pointer is NULL
1674
1675 --*/
1676 {
1677   EFI_FFS_FILE_HEADER *FileHeader;
1678   UINTN               RelativeAddress;
1679   EFI_GUID            EfiFirmwareVolumeTopFileGuid = EFI_FFS_VOLUME_TOP_FILE_GUID;
1680
1681   //
1682   // Find the VTF file header location
1683   //
1684   if (LocType == FIRST_VTF) {
1685     GetRelativeAddressInVtfBuffer (Vtf1LastStartAddress, &RelativeAddress, FIRST_VTF);
1686     FileHeader = (EFI_FFS_FILE_HEADER *) RelativeAddress;
1687   } else {
1688     GetRelativeAddressInVtfBuffer (Vtf2LastStartAddress, &RelativeAddress, SECOND_VTF);
1689     FileHeader = (EFI_FFS_FILE_HEADER *) RelativeAddress;
1690   }
1691
1692   if (FileHeader == NULL) {
1693     return EFI_INVALID_PARAMETER;
1694   }
1695
1696   //
1697   // write header
1698   //
1699   memset (FileHeader, 0, sizeof (EFI_FFS_FILE_HEADER));
1700   memcpy (&FileHeader->Name, &EfiFirmwareVolumeTopFileGuid, sizeof (EFI_GUID));
1701   FileHeader->Type        = EFI_FV_FILETYPE_RAW;
1702   FileHeader->Attributes  = FFS_ATTRIB_CHECKSUM;
1703
1704   //
1705   // Now FileSize includes the EFI_FFS_FILE_HEADER
1706   //
1707   FileHeader->Size[0] = (UINT8) (TotalVtfSize & 0x000000FF);
1708   FileHeader->Size[1] = (UINT8) ((TotalVtfSize & 0x0000FF00) >> 8);
1709   FileHeader->Size[2] = (UINT8) ((TotalVtfSize & 0x00FF0000) >> 16);
1710
1711   //
1712   // Fill in checksums and state, all three must be zero for the checksums.
1713   //
1714   FileHeader->IntegrityCheck.Checksum.Header  = 0;
1715   FileHeader->IntegrityCheck.Checksum.File    = 0;
1716   FileHeader->State                           = 0;
1717   FileHeader->IntegrityCheck.Checksum.Header  = CalculateChecksum8 ((UINT8 *) FileHeader, sizeof (EFI_FFS_FILE_HEADER));
1718   FileHeader->IntegrityCheck.Checksum.File    = CalculateChecksum8 ((UINT8 *) (FileHeader + 1), TotalVtfSize - sizeof (EFI_FFS_FILE_HEADER));
1719   FileHeader->State                           = EFI_FILE_HEADER_CONSTRUCTION | EFI_FILE_HEADER_VALID | EFI_FILE_DATA_VALID;
1720
1721   return EFI_SUCCESS;
1722 }
1723
1724 EFI_STATUS
1725 ValidateAddressAndSize (
1726   IN  UINT64  BaseAddress,
1727   IN  UINT64  FwVolSize
1728   )
1729 /*++
1730
1731 Routine Description:
1732
1733   Update the Firmware Volume Buffer with requested buffer data
1734
1735 Arguments:
1736
1737   BaseAddress    - Base address for the Fw Volume.
1738
1739   FwVolSize      - Total Size of the FwVolume to which VTF will be attached..
1740
1741 Returns:
1742
1743   EFI_SUCCESS     - The function completed successfully
1744   EFI_UNSUPPORTED - The input parameter is error
1745
1746 --*/
1747 {
1748   if ((FwVolSize > 0x40) && ((BaseAddress + FwVolSize) % 8 == 0)) {
1749     return EFI_SUCCESS;
1750   }
1751
1752   return EFI_UNSUPPORTED;
1753 }
1754
1755 EFI_STATUS
1756 UpdateIA32ResetVector (
1757   IN  CHAR8   *FileName,
1758   IN  UINT64  FirstFwVSize
1759   )
1760 /*++
1761
1762 Routine Description:
1763
1764   Update the 16 byte IA32 Reset vector to maintain the compatibility
1765
1766 Arguments:
1767
1768   FileName     - Binary file name which contains the IA32 Reset vector info..
1769   FirstFwVSize - Total Size of the FwVolume to which VTF will be attached..
1770
1771 Returns:
1772
1773   EFI_SUCCESS            - The function completed successfully
1774   EFI_ABORTED            - Invalid File Size
1775   EFI_INVALID_PARAMETER  - Bad File Name
1776   EFI_OUT_OF_RESOURCES   - Memory allocation failed.
1777
1778 --*/
1779 {
1780   UINT8 *Buffer;
1781   UINT8 *LocalVtfBuffer;
1782   UINTN FileSize;
1783   FILE  *Fp;
1784
1785   if (!strcmp (FileName, "")) {
1786     return EFI_INVALID_PARAMETER;
1787   }
1788
1789   Fp = fopen (LongFilePath (FileName), "rb");
1790
1791   if (Fp == NULL) {
1792     Error (NULL, 0, 0001, "Error opening file", FileName);
1793     return EFI_ABORTED;
1794   }
1795
1796   FileSize = _filelength (fileno (Fp));
1797
1798   if (FileSize > 16) {
1799     fclose (Fp);
1800     return EFI_ABORTED;
1801   }
1802
1803   Buffer = malloc (FileSize);
1804   if (Buffer == NULL) {
1805     fclose (Fp);
1806     return EFI_OUT_OF_RESOURCES;
1807   }
1808
1809   fread (Buffer, sizeof (UINT8), FileSize, Fp);
1810
1811   LocalVtfBuffer  = (UINT8 *) Vtf1EndBuffer - SIZE_IA32_RESET_VECT;
1812   memcpy (LocalVtfBuffer, Buffer, FileSize);
1813
1814   if (Buffer) {
1815     free (Buffer);
1816   }
1817
1818   if (Fp != NULL) {
1819     fclose (Fp);
1820   }
1821   return EFI_SUCCESS;
1822 }
1823
1824 VOID
1825 CleanUpMemory (
1826   VOID
1827   )
1828 /*++
1829
1830 Routine Description:
1831
1832   This function cleans up any allocated buffer
1833
1834 Arguments:
1835
1836   NONE
1837
1838 Returns:
1839
1840   NONE
1841
1842 --*/
1843 {
1844   PARSED_VTF_INFO *TempFileListPtr;
1845
1846   if (Vtf1Buffer) {
1847     free (Vtf1Buffer);
1848   }
1849
1850   if (Vtf2Buffer) {
1851     free (Vtf2Buffer);
1852   }
1853
1854   //
1855   // Cleanup the buffer which was allocated to read the file names from FV.INF
1856   //
1857   FileListPtr = FileListHeadPtr;
1858   while (FileListPtr != NULL) {
1859     TempFileListPtr = FileListPtr->NextVtfInfo;
1860     free (FileListPtr);
1861     FileListPtr = TempFileListPtr;
1862   }
1863 }
1864
1865 EFI_STATUS
1866 ProcessAndCreateVtf (
1867   IN  UINT64  Size
1868   )
1869 /*++
1870
1871 Routine Description:
1872
1873   This function process the link list created during INF file parsing
1874   and create component in VTF and updates its info in FIT table
1875
1876 Arguments:
1877
1878   Size   - Size of the Firmware Volume of which, this VTF belongs to.
1879
1880 Returns:
1881
1882   EFI_UNSUPPORTED - Unknown FIT type
1883   EFI_SUCCESS     - The function completed successfully
1884
1885 --*/
1886 {
1887   EFI_STATUS      Status;
1888   PARSED_VTF_INFO *ParsedInfoPtr;
1889
1890   Status        = EFI_SUCCESS;
1891
1892   ParsedInfoPtr = FileListHeadPtr;
1893
1894   while (ParsedInfoPtr != NULL) {
1895
1896     switch (ParsedInfoPtr->CompType) {
1897     //
1898     // COMP_TYPE_FIT_HEADER is a special case, hence handle it here
1899     //
1900     case COMP_TYPE_FIT_HEADER:
1901       //COMP_TYPE_FIT_HEADER          0x00
1902       Status = CreateFitTableAndInitialize (ParsedInfoPtr);
1903       break;
1904
1905     //
1906     // COMP_TYPE_FIT_PAL_A is a special case, hence handle it here
1907     //
1908     case COMP_TYPE_FIT_PAL_A:
1909       //COMP_TYPE_FIT_PAL_A           0x0F
1910       Status = CreateAndUpdatePAL_A (ParsedInfoPtr);
1911
1912       //
1913       // Based on VTF specification, once the PAL_A component has been written,
1914       // update the Firmware Volume info as FIT table. This will be utilized
1915       // to extract the Firmware Volume Start address where this VTF will be
1916       // of part.
1917       //
1918       if (Status == EFI_SUCCESS) {
1919         UpdateFitEntryForFwVolume (Size);
1920       }
1921       break;
1922
1923     case COMP_TYPE_FIT_FV_BOOT:
1924       //COMP_TYPE_FIT_FV_BOOT         0x7E
1925       //
1926       // Since FIT entry for Firmware Volume has been created and it is
1927       // located at (PAL_A start - 16 byte). So we will not process any
1928       // Firmware Volume related entry from INF file
1929       //
1930       Status = EFI_SUCCESS;
1931       break;
1932
1933     default:
1934       //
1935       // Any other component type should be handled here. This will create the
1936       // image in specified VTF and create appropriate entry about this
1937       // component in FIT Entry.
1938       //
1939       Status = CreateAndUpdateComponent (ParsedInfoPtr);
1940       if (EFI_ERROR (Status)) {
1941         Error (NULL, 0, 0002, "Error updating component", ParsedInfoPtr->CompName);
1942         return EFI_ABORTED;
1943       } else {
1944       break;}
1945     }
1946
1947     ParsedInfoPtr = ParsedInfoPtr->NextVtfInfo;
1948   }
1949   return Status;
1950 }
1951
1952 EFI_STATUS
1953 GenerateVtfImage (
1954   IN  UINT64  StartAddress1,
1955   IN  UINT64  Size1,
1956   IN  UINT64  StartAddress2,
1957   IN  UINT64  Size2,
1958   IN  FILE    *fp
1959   )
1960 /*++
1961
1962 Routine Description:
1963
1964   This is the main function which will be called from application.
1965
1966 Arguments:
1967
1968   StartAddress1  - The start address of the first VTF
1969   Size1          - The size of the first VTF
1970   StartAddress2  - The start address of the second VTF
1971   Size2          - The size of the second VTF
1972   fp             - The pointer to BSF inf file
1973
1974 Returns:
1975
1976   EFI_OUT_OF_RESOURCES - Can not allocate memory
1977   The return value can be any of the values
1978   returned by the calls to following functions:
1979       GetVtfRelatedInfoFromInfFile
1980       ProcessAndCreateVtf
1981       UpdateIA32ResetVector
1982       UpdateFfsHeader
1983       WriteVtfBinary
1984
1985 --*/
1986 {
1987   EFI_STATUS  Status;
1988   FILE            *VtfFP;
1989
1990   Status          = EFI_UNSUPPORTED;
1991   VtfFP = fp;
1992
1993   if (StartAddress2 == 0) {
1994     SecondVTF = FALSE;
1995   } else {
1996     SecondVTF = TRUE;
1997   }
1998
1999   Fv1BaseAddress        = StartAddress1;
2000   Fv1EndAddress         = Fv1BaseAddress + Size1;
2001   if (Fv1EndAddress != 0x100000000ULL || Size1 < 0x100000) {
2002     Error (NULL, 0, 2000, "Invalid parameter", "Error BaseAddress and Size parameters!");
2003     if (Size1 < 0x100000) {
2004       Error (NULL, 0, 2000, "Invalid parameter", "The FwVolumeSize must be larger than 1M!");
2005     } else if (SecondVTF != TRUE) {
2006       Error (NULL, 0, 2000, "Invalid parameter", "BaseAddress + FwVolumeSize must equal 0x100000000!");
2007     }
2008     Usage();
2009     return EFI_INVALID_PARAMETER;
2010   }
2011
2012   //
2013   // The image buffer for the First VTF
2014   //
2015   Vtf1Buffer = malloc ((UINTN) Size1);
2016   if (Vtf1Buffer == NULL) {
2017     Error (NULL, 0, 4001, "Resource", "Not enough resources available to create memory mapped file for the Boot Strap File!");
2018     return EFI_OUT_OF_RESOURCES;
2019   }
2020   memset (Vtf1Buffer, 0x00, (UINTN) Size1);
2021   Vtf1EndBuffer         = (UINT8 *) Vtf1Buffer + Size1;
2022   Vtf1LastStartAddress  = Fv1EndAddress | IPF_CACHE_BIT;
2023
2024   if (SecondVTF) {
2025     Fv2BaseAddress        = StartAddress2;
2026     Fv2EndAddress         = Fv2BaseAddress + Size2;
2027     if (Fv2EndAddress != StartAddress1) {
2028       Error (NULL, 0, 2000, "Invalid parameter", "Error BaseAddress and Size parameters!");
2029       if (SecondVTF == TRUE) {
2030         Error (NULL, 0, 2000, "Invalid parameter", "FirstBaseAddress + FirstFwVolumeSize must equal 0x100000000!");
2031         Error (NULL, 0, 2000, "Invalid parameter", "SecondBaseAddress + SecondFwVolumeSize must equal FirstBaseAddress!");
2032       }
2033       Usage();
2034       return EFI_INVALID_PARAMETER;
2035     }
2036
2037     //
2038     // The image buffer for the second VTF
2039     //
2040     Vtf2Buffer = malloc ((UINTN) Size2);
2041     if (Vtf2Buffer == NULL) {
2042       Error (NULL, 0, 4001, "Resource", "Not enough resources available to create memory mapped file for the Boot Strap File!");
2043       return EFI_OUT_OF_RESOURCES;
2044     }
2045     memset (Vtf2Buffer, 0x00, (UINTN) Size2);
2046     Vtf2EndBuffer         = (UINT8 *) Vtf2Buffer + Size2;
2047     Vtf2LastStartAddress  = Fv2EndAddress | IPF_CACHE_BIT;
2048   }
2049
2050   Status = GetVtfRelatedInfoFromInfFile (VtfFP);
2051
2052   if (Status != EFI_SUCCESS) {
2053     Error (NULL, 0, 0003, "Error parsing file", "the input file.");
2054     CleanUpMemory ();
2055     return Status;
2056   }
2057
2058   Status = ProcessAndCreateVtf (Size1);
2059   if (Status != EFI_SUCCESS) {
2060     CleanUpMemory ();
2061     return Status;
2062   }
2063
2064   if (SectionOptionFlag) {
2065     Status = UpdateIA32ResetVector (IA32BinFile, Vtf1TotalSize);
2066     if (Status != EFI_SUCCESS) {
2067       CleanUpMemory ();
2068       return Status;
2069     }
2070   }
2071
2072   //
2073   // Re arrange the FIT Table for Ascending order of their FIT Type..
2074   //
2075   SortFitTable ();
2076
2077   //
2078   // All components have been updated in FIT table. Now perform the FIT table
2079   // checksum. The following function will check if Checksum is required,
2080   // if yes, then it will perform the checksum otherwise not.
2081   //
2082   CalculateFitTableChecksum ();
2083
2084   //
2085   // Write the FFS header
2086   //
2087   Vtf1TotalSize += sizeof (EFI_FFS_FILE_HEADER);
2088   Vtf1LastStartAddress -= sizeof (EFI_FFS_FILE_HEADER);
2089
2090   Status = UpdateFfsHeader (Vtf1TotalSize, FIRST_VTF);
2091   if (Status != EFI_SUCCESS) {
2092     CleanUpMemory ();
2093     return Status;
2094   }
2095   //
2096   // Update the VTF buffer into specified VTF binary file
2097   //
2098   Status  = WriteVtfBinary (OutFileName1, Vtf1TotalSize, FIRST_VTF);
2099
2100   if (SecondVTF) {
2101     Vtf2TotalSize += sizeof (EFI_FFS_FILE_HEADER);
2102     Vtf2LastStartAddress -= sizeof (EFI_FFS_FILE_HEADER);
2103     Status = UpdateFfsHeader (Vtf2TotalSize, SECOND_VTF);
2104     if (Status != EFI_SUCCESS) {
2105       CleanUpMemory ();
2106       return Status;
2107     }
2108
2109     //
2110     // Update the VTF buffer into specified VTF binary file
2111     //
2112     Status  = WriteVtfBinary (OutFileName2, Vtf2TotalSize, SECOND_VTF);
2113   }
2114
2115   CleanUpMemory ();
2116
2117   return Status;
2118 }
2119
2120 EFI_STATUS
2121 PeimFixupInFitTable (
2122   IN  UINT64  StartAddress
2123   )
2124 /*++
2125
2126 Routine Description:
2127
2128   This function is an entry point to fixup SAL-E entry point.
2129
2130 Arguments:
2131
2132   StartAddress - StartAddress for PEIM.....
2133
2134 Returns:
2135
2136   EFI_SUCCESS          - The function completed successfully
2137   EFI_ABORTED          - Error Opening File
2138   EFI_OUT_OF_RESOURCES - System out of resources for memory allocation.
2139
2140 --*/
2141 {
2142   EFI_STATUS  Status;
2143   FILE        *Fp;
2144   UINT64      *StartAddressPtr;
2145   UINTN       FirstFwVSize;
2146
2147   StartAddressPtr   = malloc (sizeof (UINT64));
2148   if (StartAddressPtr == NULL) {
2149     return EFI_OUT_OF_RESOURCES;
2150   }
2151   *StartAddressPtr = StartAddress;
2152
2153   Fp = fopen (LongFilePath (OutFileName1), "rb");
2154
2155   if (Fp == NULL) {
2156     Error (NULL, 0, 0001, "Error opening file", OutFileName1);
2157     if (StartAddressPtr) {
2158       free (StartAddressPtr);
2159     }
2160     return EFI_ABORTED;
2161   }
2162
2163   FirstFwVSize = _filelength (fileno (Fp));
2164   fseek (Fp, (long) (FirstFwVSize - (UINTN) (SIZE_IA32_RESET_VECT + SIZE_SALE_ENTRY_POINT)), SEEK_SET);
2165   fwrite ((VOID *) StartAddressPtr, sizeof (UINT64), 1, Fp);
2166
2167   if (Fp) {
2168     fclose (Fp);
2169   }
2170
2171   if (StartAddressPtr) {
2172     free (StartAddressPtr);
2173   }
2174
2175   Status = EFI_SUCCESS;
2176   return Status;
2177 }
2178
2179 EFI_STATUS
2180 UpdateSymFile (
2181   IN UINT64 BaseAddress,
2182   IN CHAR8  *DestFileName,
2183   IN CHAR8  *SourceFileName,
2184   IN UINT64 FileSize
2185
2186   )
2187 /*++
2188
2189 Routine Description:
2190
2191   This function adds the SYM tokens in the source file to the destination file.
2192   The SYM tokens are updated to reflect the base address.
2193
2194 Arguments:
2195
2196   BaseAddress    - The base address for the new SYM tokens.
2197   DestFileName   - The destination file.
2198   SourceFileName - The source file.
2199   FileSize       - Size of bin file.
2200
2201 Returns:
2202
2203   EFI_SUCCESS             - The function completed successfully.
2204   EFI_INVALID_PARAMETER   - One of the input parameters was invalid.
2205   EFI_ABORTED             - An error occurred.
2206
2207 --*/
2208 {
2209   FILE    *SourceFile;
2210   FILE    *DestFile;
2211   CHAR8   Buffer[MAX_LONG_FILE_PATH];
2212   CHAR8   Type[MAX_LONG_FILE_PATH];
2213   CHAR8   Address[MAX_LONG_FILE_PATH];
2214   CHAR8   Section[MAX_LONG_FILE_PATH];
2215   CHAR8   Token[MAX_LONG_FILE_PATH];
2216   CHAR8   BaseToken[MAX_LONG_FILE_PATH];
2217   CHAR8   FormatString[MAX_LINE_LEN];
2218   UINT64  TokenAddress;
2219   long    StartLocation;
2220
2221   //
2222   // Verify input parameters.
2223   //
2224   if (BaseAddress == 0 || DestFileName == NULL || SourceFileName == NULL) {
2225     return EFI_INVALID_PARAMETER;
2226   }
2227
2228   //
2229   // Open the source file
2230   //
2231   SourceFile = fopen (LongFilePath (SourceFileName), "r");
2232   if (SourceFile == NULL) {
2233
2234     //
2235     // SYM files are not required.
2236     //
2237     return EFI_SUCCESS;
2238   }
2239
2240   //
2241   // Use the file name minus extension as the base for tokens
2242   //
2243   strcpy (BaseToken, SourceFileName);
2244   strtok (BaseToken, ". \t\n");
2245   strcat (BaseToken, "__");
2246
2247   //
2248   // Open the destination file
2249   //
2250   DestFile = fopen (LongFilePath (DestFileName), "a+");
2251   if (DestFile == NULL) {
2252     fclose (SourceFile);
2253     Error (NULL, 0, 0001, "Error opening file", DestFileName);
2254     return EFI_ABORTED;
2255   }
2256
2257   //
2258   // If this is the beginning of the output file, write the symbol format info.
2259   //
2260   if (fseek (DestFile, 0, SEEK_END) != 0) {
2261     fclose (SourceFile);
2262     fclose (DestFile);
2263     Error (NULL, 0, 2000, "Invalid parameter", "not at the beginning of the output file.");
2264     return EFI_ABORTED;
2265   }
2266
2267   StartLocation = ftell (DestFile);
2268
2269   if (StartLocation == 0) {
2270     fprintf (DestFile, "TEXTSYM format | V1.0\n");
2271   } else if (StartLocation == -1) {
2272     fclose (SourceFile);
2273     fclose (DestFile);
2274     Error (NULL, 0, 2000, "Invalid parameter", "StartLocation error");
2275     return EFI_ABORTED;
2276   }
2277
2278   //
2279   // Read the first line
2280   //
2281   if (fgets (Buffer, MAX_LONG_FILE_PATH, SourceFile) == NULL) {
2282     Buffer[0] = 0;
2283   }
2284
2285   //
2286   // Make sure it matches the expected sym format
2287   //
2288   if (strcmp (Buffer, "TEXTSYM format | V1.0\n")) {
2289     fclose (SourceFile);
2290     fclose (DestFile);
2291     Error (NULL, 0, 2000, "Invalid parameter", "The symbol file does not match the expected TEXTSYM format (V1.0.)");
2292     return EFI_ABORTED;
2293   }
2294
2295   //
2296   // Generate the format string for fscanf
2297   //
2298   sprintf (
2299     FormatString,
2300     "%%%us | %%%us | %%%us | %%%us\n",
2301     (unsigned) sizeof (Type) - 1,
2302     (unsigned) sizeof (Address) - 1,
2303     (unsigned) sizeof (Section) - 1,
2304     (unsigned) sizeof (Token) - 1
2305     );
2306
2307   //
2308   // Read in the file
2309   //
2310   while (feof (SourceFile) == 0) {
2311
2312     //
2313     // Read a line
2314     //
2315     if (fscanf (SourceFile, FormatString, Type, Address, Section, Token) == 4) {
2316
2317       //
2318       // Get the token address
2319       //
2320       AsciiStringToUint64 (Address, TRUE, &TokenAddress);
2321       if (TokenAddress > FileSize) {
2322         //
2323         // Symbol offset larger than FileSize. This Symbol can't be in Bin file. Don't print them.
2324         //
2325         break;
2326       }
2327
2328       //
2329       // Add the base address, the size of the FFS file header and the size of the peim header.
2330       //
2331       TokenAddress += BaseAddress &~IPF_CACHE_BIT;
2332
2333       fprintf (DestFile, "%s | %016llX | ", Type, (unsigned long long) TokenAddress);
2334       fprintf (DestFile, "%s | %s\n    %s\n", Section, Token, BaseToken);
2335     }
2336   }
2337
2338   fclose (SourceFile);
2339   fclose (DestFile);
2340   return EFI_SUCCESS;
2341 }
2342
2343 EFI_STATUS
2344 CalculateFitTableChecksum (
2345   VOID
2346   )
2347 /*++
2348
2349 Routine Description:
2350
2351   This function will perform byte checksum on the FIT table, if the the checksum required
2352   field is set to CheckSum required. If the checksum is not required then checksum byte
2353   will have value as 0;.
2354
2355 Arguments:
2356
2357   NONE
2358
2359 Returns:
2360
2361   Status       - Value returned by call to CalculateChecksum8 ()
2362   EFI_SUCCESS  - The function completed successfully
2363
2364 --*/
2365 {
2366   FIT_TABLE *TmpFitPtr;
2367   UINT64    FitTableAdd;
2368   UINT64    FitTableAddOffset;
2369   UINTN     RelativeAddress;
2370   UINTN     Size;
2371
2372   //
2373   // Read the Fit Table address from Itanium-based address map.
2374   //
2375   FitTableAddOffset = Fv1EndAddress - (SIZE_IA32_RESET_VECT + SIZE_SALE_ENTRY_POINT + SIZE_FIT_TABLE_ADD);
2376
2377   //
2378   // Translate this Itanium-based address in terms of local buffer address which
2379   // contains the image for Boot Strapped File
2380   //
2381   GetRelativeAddressInVtfBuffer (FitTableAddOffset, &RelativeAddress, FIRST_VTF);
2382   FitTableAdd = *(UINTN *) RelativeAddress;
2383
2384   GetRelativeAddressInVtfBuffer (FitTableAdd, &RelativeAddress, FIRST_VTF);
2385
2386   TmpFitPtr = (FIT_TABLE *) RelativeAddress;
2387
2388   Size      = TmpFitPtr->CompSize * 16;
2389
2390   if ((TmpFitPtr->CvAndType & CHECKSUM_BIT_MASK) >> 7) {
2391     TmpFitPtr->CheckSum = 0;
2392     TmpFitPtr->CheckSum = CalculateChecksum8 ((UINT8 *) TmpFitPtr, Size);
2393   } else {
2394     TmpFitPtr->CheckSum = 0;
2395   }
2396
2397   return EFI_SUCCESS;
2398 }
2399
2400 VOID
2401 Version (
2402   VOID
2403   )
2404 /*++
2405
2406 Routine Description:
2407
2408   Displays the standard utility information to SDTOUT
2409
2410 Arguments:
2411
2412   None
2413
2414 Returns:
2415
2416   None
2417
2418 --*/
2419 {
2420   fprintf (stdout, "%s Version %d.%d %s \n", UTILITY_NAME, UTILITY_MAJOR_VERSION, UTILITY_MINOR_VERSION, __BUILD_VERSION);
2421 }
2422
2423 VOID
2424 Usage (
2425   VOID
2426   )
2427 /*++
2428
2429 Routine Description:
2430
2431   Displays the utility usage syntax to STDOUT
2432
2433 Arguments:
2434
2435   None
2436
2437 Returns:
2438
2439   None
2440
2441 --*/
2442 {
2443   //
2444   // Summary usage
2445   //
2446   fprintf (stdout, "Usage: %s [options] <-f input_file> <-r BaseAddress> <-s FwVolumeSize>\n\n", UTILITY_NAME);
2447
2448   //
2449   // Copyright declaration
2450   //
2451   fprintf (stdout, "Copyright (c) 2007 - 2014, Intel Corporation. All rights reserved.\n\n");
2452   //
2453   // Details Option
2454   //
2455   fprintf (stdout, "Options:\n");
2456   fprintf (stdout, "  -f Input_file,   --filename Input_file\n\
2457                         Input_file is name of the BS Image INF file\n");
2458   fprintf (stdout, "  -r BaseAddress,  --baseaddr BaseAddress\n\
2459                         BaseAddress is the starting address of Firmware Volume\n\
2460                         where Boot Strapped Image will reside.\n");
2461   fprintf (stdout, "  -s FwVolumeSize, --size FwVolumeSize\n\
2462                         FwVolumeSize is the size of Firmware Volume.\n");
2463   fprintf (stdout, "  -o FileName,     --output FileName\n\
2464                         File will be created to store the ouput content.\n");
2465   fprintf (stdout, "  -v, --verbose         Turn on verbose output with informational messages.\n");
2466   fprintf (stdout, "  --version             Show program's version number and exit.\n");
2467   fprintf (stdout, "  -h, --help            Show this help message and exit.\n");
2468   fprintf (stdout, "  -q, --quiet           Disable all messages except FATAL ERRORS.\n");
2469   fprintf (stdout, "  -d, --debug [#, 0-9]  Enable debug messages at level #.\n");
2470 }
2471
2472 int
2473 main (
2474   IN  int  argc,
2475   IN  char  **argv
2476   )
2477 /*++
2478
2479 Routine Description:
2480
2481   This utility uses GenVtf.dll to build a Boot Strap File Image which will be
2482   part of firmware volume image.
2483
2484 Arguments:
2485
2486   argc   - The count of the parameters
2487   argv   - The parameters
2488
2489
2490 Returns:
2491
2492   0   - No error conditions detected.
2493   1   - One or more of the input parameters is invalid.
2494   2   - A resource required by the utility was unavailable.
2495       - Most commonly this will be memory allocation or file creation.
2496   3   - GenFvImage.dll could not be loaded.
2497   4   - Error executing the GenFvImage dll.
2498   5   - Now this tool does not support the IA32 platform
2499
2500 --*/
2501 {
2502   UINT8          Index;
2503   UINT64         StartAddress1;
2504   UINT64         StartAddress2;
2505   UINT64         FwVolSize1;
2506   UINT64         FwVolSize2;
2507   BOOLEAN       FirstRoundO;
2508   BOOLEAN       FirstRoundB;
2509   BOOLEAN       FirstRoundS;
2510   EFI_STATUS    Status;
2511   FILE          *VtfFP;
2512   CHAR8         *VtfFileName;
2513
2514   SetUtilityName (UTILITY_NAME);
2515
2516   //
2517   // Initialize variables
2518   //
2519   StartAddress1 = 0;
2520   StartAddress2 = 0;
2521   FwVolSize1    = 0;
2522   FwVolSize2    = 0;
2523   FirstRoundB   = TRUE;
2524   FirstRoundS   = TRUE;
2525   FirstRoundO   = TRUE;
2526   DebugMode     = FALSE;
2527   OutFileName1  = NULL;
2528   OutFileName2  = NULL;
2529   VtfFP = NULL;
2530   DebugLevel = 0;
2531
2532   //
2533   // Verify the correct number of arguments
2534   //
2535   if (argc == 1) {
2536     Usage();
2537     return 0;
2538   }
2539
2540   if ((strcmp(argv[1], "-h") == 0) || (strcmp(argv[1], "--help") == 0)) {
2541     Usage();
2542     return 0;
2543   }
2544
2545   if ((strcmp(argv[1], "--version") == 0)) {
2546     Version();
2547     return 0;
2548   }
2549
2550   //
2551   // Parse the command line arguments
2552   //
2553   for (Index = 1; Index < argc; Index += 2) {
2554     if ((stricmp (argv[Index], "-o") == 0) || (stricmp (argv[Index], "--output") == 0)) {
2555       if (argv[Index + 1] == NULL || argv[Index + 1][0] == '-') {
2556         Error (NULL, 0, 1003, "Invalid option value", "Output file is missing for -o option");
2557         goto ERROR;
2558       }
2559       //
2560       // Get the output file name
2561       //
2562       VTF_OUTPUT = TRUE;
2563       if (FirstRoundO) {
2564         //
2565         // It's the first output file name
2566         //
2567         OutFileName1 = (CHAR8 *)argv[Index+1];
2568         FirstRoundO = FALSE;
2569       } else {
2570         //
2571         //It's the second output file name
2572         //
2573         OutFileName2 = (CHAR8 *)argv[Index+1];
2574       }
2575       continue;
2576     }
2577
2578     if ((stricmp (argv[Index], "-f") == 0) || (stricmp (argv[Index], "--filename") == 0)) {
2579       if (argv[Index + 1] == NULL || argv[Index + 1][0] == '-') {
2580         Error (NULL, 0, 1003, "Invalid option value", "BS Image INF file is missing for -f option");
2581         goto ERROR;
2582       }
2583       //
2584       // Get the input VTF file name
2585       //
2586       VtfFileName = argv[Index+1];
2587       if (VtfFP != NULL) {
2588         //
2589         // VTF file name has been given previously, override with the new value
2590         //
2591         fclose (VtfFP);
2592       }
2593       VtfFP = fopen (LongFilePath (VtfFileName), "rb");
2594       if (VtfFP == NULL) {
2595         Error (NULL, 0, 0001, "Error opening file", VtfFileName);
2596         goto ERROR;
2597       }
2598       continue;
2599     }
2600
2601     if ((stricmp (argv[Index], "-r") == 0) || (stricmp (argv[Index], "--baseaddr") == 0)) {
2602       if (FirstRoundB) {
2603         Status      = AsciiStringToUint64 (argv[Index + 1], FALSE, &StartAddress1);
2604         FirstRoundB = FALSE;
2605       } else {
2606         Status = AsciiStringToUint64 (argv[Index + 1], FALSE, &StartAddress2);
2607       }
2608       if (Status != EFI_SUCCESS) {
2609         Error (NULL, 0, 2000, "Invalid option value", "%s is Bad FV start address.", argv[Index + 1]);
2610         goto ERROR;
2611       }
2612       continue;
2613     }
2614
2615     if ((stricmp (argv[Index], "-s") == 0) || (stricmp (argv[Index], "--size") == 0)) {
2616       if (FirstRoundS) {
2617         Status      = AsciiStringToUint64 (argv[Index + 1], FALSE, &FwVolSize1);
2618         FirstRoundS = FALSE;
2619       } else {
2620         Status = AsciiStringToUint64 (argv[Index + 1], FALSE, &FwVolSize2);
2621           SecondVTF = TRUE;
2622       }
2623
2624       if (Status != EFI_SUCCESS) {
2625         Error (NULL, 0, 2000, "Invalid option value", "%s is Bad FV size.", argv[Index + 1]);
2626         goto ERROR;
2627       }
2628       continue;
2629     }
2630
2631     if ((stricmp (argv[Index], "-v") == 0) || (stricmp (argv[Index], "--verbose") == 0)) {
2632             VerboseMode = TRUE;
2633             Index--;
2634       continue;
2635     }
2636
2637     if ((stricmp (argv[Index], "-q") == 0) || (stricmp (argv[Index], "--quiet") == 0)) {
2638       QuietMode = TRUE;
2639       Index--;
2640       continue;
2641     }
2642
2643     if ((stricmp (argv[Index], "-d") == 0) || (stricmp (argv[Index], "--debug") == 0)) {
2644       //
2645       // debug level specified
2646       //
2647       Status = AsciiStringToUint64(argv[Index + 1], FALSE, &DebugLevel);
2648       if (EFI_ERROR (Status)) {
2649         Error (NULL, 0, 1003, "Invalid option value", "%s = %s", argv[Index], argv[Index + 1]);
2650         goto ERROR;
2651       }
2652       if (DebugLevel > 9)  {
2653         Error (NULL, 0, 2000, "Invalid option value", "Unrecognized argument %s.", argv[Index + 1]);
2654         goto ERROR;
2655       }
2656       if((DebugLevel <= 9) &&(DebugLevel >= 5)) {
2657         DebugMode = TRUE;
2658       } else {
2659         DebugMode = FALSE;
2660       }
2661       continue;
2662     }
2663
2664     Error (NULL, 0, 2000, "Invalid parameter", "Unrecognized argument %s.", argv[Index]);
2665     goto ERROR;
2666   }
2667
2668   if (VtfFP == NULL) {
2669     Error (NULL, 0, 2000, "Invalid parameter", "No BS Image INF file is specified");
2670     goto ERROR;
2671   }
2672
2673   if (FirstRoundB) {
2674     Error (NULL, 0, 2000, "Invalid parameter", "No FV base address is specified");
2675     goto ERROR;
2676   }
2677
2678   if (FirstRoundS) {
2679     Error (NULL, 0, 2000, "Invalid parameter", "No FV Size is specified");
2680     goto ERROR;
2681   }
2682   //
2683   // All Parameters has been parsed, now set the message print level
2684   //
2685   if (QuietMode) {
2686     SetPrintLevel(40);
2687   } else if (VerboseMode) {
2688     SetPrintLevel(15);
2689   } else if (DebugMode) {
2690     SetPrintLevel(DebugLevel);
2691   }
2692
2693   if (VerboseMode) {
2694     VerboseMsg("%s tool start.\n", UTILITY_NAME);
2695   }
2696
2697   if (VTF_OUTPUT == FALSE) {
2698     if (SecondVTF == TRUE) {
2699       OutFileName1 = VTF_OUTPUT_FILE1;
2700       OutFileName2 = VTF_OUTPUT_FILE2;
2701           } else {
2702       OutFileName1 = VTF_OUTPUT_FILE1;
2703     }
2704     SymFileName = VTF_SYM_FILE;
2705   } else {
2706     assert (OutFileName1);
2707     INTN OutFileNameLen = strlen(OutFileName1);
2708     INTN NewIndex;
2709
2710     for (NewIndex = OutFileNameLen; NewIndex > 0; --NewIndex) {
2711       if (OutFileName1[NewIndex] == '/' || OutFileName1[NewIndex] == '\\') {
2712         break;
2713       }
2714     }
2715     if (NewIndex == 0) {
2716       SymFileName = VTF_SYM_FILE;
2717     } else {
2718       INTN SymFileNameLen = NewIndex + 1 + strlen(VTF_SYM_FILE);
2719       SymFileName = malloc(SymFileNameLen + 1);
2720       if (SymFileName == NULL) {
2721         Error (NULL, 0, 4001, "Resource", "memory cannot be allocated!");
2722         goto ERROR;
2723       }
2724       memcpy(SymFileName, OutFileName1, NewIndex + 1);
2725       memcpy(SymFileName + NewIndex + 1, VTF_SYM_FILE, strlen(VTF_SYM_FILE));
2726       SymFileName[SymFileNameLen] = '\0';
2727     }
2728     if (DebugMode) {
2729       DebugMsg(UTILITY_NAME, 0, DebugLevel, SymFileName, NULL);
2730     }
2731   }
2732
2733   //
2734   // Call the GenVtfImage
2735   //
2736   if (DebugMode) {
2737     DebugMsg(UTILITY_NAME, 0, DebugLevel, "Start to generate the VTF image\n", NULL);
2738   }
2739   Status = GenerateVtfImage (StartAddress1, FwVolSize1, StartAddress2, FwVolSize2, VtfFP);
2740
2741   if (EFI_ERROR (Status)) {
2742     switch (Status) {
2743
2744     case EFI_INVALID_PARAMETER:
2745       Error (NULL, 0, 2000, "Invalid parameter", "Invalid parameter passed to GenVtf function.");
2746       break;
2747
2748     case EFI_ABORTED:
2749       Error (NULL, 0, 3000, "Invalid", "Error detected while creating the file image.");
2750       break;
2751
2752     case EFI_OUT_OF_RESOURCES:
2753       Error (NULL, 0, 4002, "Resource", "GenVtfImage function could not allocate required resources.");
2754       break;
2755
2756     case EFI_VOLUME_CORRUPTED:
2757       Error (NULL, 0, 3000, "Invalid", "No base address was specified.");
2758       break;
2759
2760     default:
2761       Error (NULL, 0, 3000, "Invalid", "GenVtfImage function returned unknown status %x.", (int) Status );
2762       break;
2763     }
2764   }
2765 ERROR:
2766   if (VtfFP != NULL) {
2767     fclose (VtfFP);
2768   }
2769
2770   if (DebugMode) {
2771     DebugMsg(UTILITY_NAME, 0, DebugLevel, "VTF image generated successful\n", NULL);
2772   }
2773
2774   if (VerboseMode) {
2775     VerboseMsg("%s tool done with return code is 0x%x.\n", UTILITY_NAME, GetUtilityStatus ());
2776   }
2777   return GetUtilityStatus();
2778 }