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 - 2016, 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
1066   Fp = fopen (LongFilePath (VtfInfo->CompSymName), "rb");
1067
1068   if (Fp == NULL) {
1069     Error (NULL, 0, 0001, "Error opening file", VtfInfo->CompSymName);
1070     return EFI_INVALID_PARAMETER;
1071   }
1072
1073   while (fgets (Buff, sizeof (Buff), Fp) != NULL) {
1074     fscanf (
1075       Fp,
1076       "%s %s %s %s %s %s %s",
1077       Buff1,
1078       Buff2,
1079       OffsetStr,
1080       Buff3,
1081       Buff4,
1082       Buff5,
1083       Token
1084       );
1085     if (strnicmp (Token, "SALE_ENTRY", 10) == 0) {
1086       break;
1087     }
1088   }
1089
1090   Offset = strtoul (OffsetStr, NULL, 16);
1091
1092   *CompStartAddress += Offset;
1093   SalEntryAdd = Fv1EndAddress - (SIZE_IA32_RESET_VECT + SIZE_SALE_ENTRY_POINT);
1094
1095   GetRelativeAddressInVtfBuffer (SalEntryAdd, &RelativeAddress, FIRST_VTF);
1096
1097   memcpy ((VOID *) RelativeAddress, (VOID *) CompStartAddress, sizeof (UINT64));
1098
1099   if (Fp != NULL) {
1100     fclose (Fp);
1101   }
1102
1103   return EFI_SUCCESS;
1104 }
1105
1106 EFI_STATUS
1107 CreateAndUpdateComponent (
1108   IN  PARSED_VTF_INFO   *VtfInfo
1109   )
1110 /*++
1111
1112 Routine Description:
1113
1114   This function reads the binary file for each components and update them
1115   in VTF Buffer as well as in FIT table. If the component is located in non
1116   VTF area, only the FIT table address will be updated
1117
1118 Arguments:
1119
1120   VtfInfo    - Pointer to Parsed Info
1121
1122 Returns:
1123
1124   EFI_SUCCESS      - The function completed successful
1125   EFI_ABORTED      - Aborted due to one of the many reasons like:
1126                       (a) Component Size greater than the specified size.
1127                       (b) Error opening files.
1128                       (c) Fail to get the FIT table address.
1129
1130   EFI_INVALID_PARAMETER     Value returned from call to UpdateEntryPoint()
1131   EFI_OUT_OF_RESOURCES      Memory allocation failure.
1132
1133 --*/
1134 {
1135   EFI_STATUS  Status;
1136   UINT64      CompStartAddress;
1137   UINT64      FileSize;
1138   UINT64      NumAdjustByte;
1139   UINT8       *Buffer;
1140   FILE        *Fp;
1141   FIT_TABLE   *CompFitPtr;
1142   BOOLEAN     Aligncheck;
1143
1144   if (VtfInfo->LocationType == NONE) {
1145     UpdateFitEntryForNonVTFComp (VtfInfo);
1146     return EFI_SUCCESS;
1147   }
1148
1149   Fp = fopen (LongFilePath (VtfInfo->CompBinName), "rb");
1150
1151   if (Fp == NULL) {
1152     Error (NULL, 0, 0001, "Error opening file", VtfInfo->CompBinName);
1153     return EFI_ABORTED;
1154   }
1155
1156   FileSize = _filelength (fileno (Fp));
1157   if ((VtfInfo->CompType == COMP_TYPE_FIT_PAL_B) || (VtfInfo->CompType == COMP_TYPE_FIT_PAL_A_SPECIFIC)) {
1158
1159     //
1160     // BUGBUG: Satish to correct
1161     //
1162     FileSize -= SIZE_OF_PAL_HEADER;
1163   }
1164
1165   if (VtfInfo->PreferredSize) {
1166     if (FileSize > VtfInfo->CompSize) {
1167       Error (NULL, 0, 2000, "Invalid parameter", "The component size is more than specified size.");
1168       return EFI_ABORTED;
1169     }
1170
1171     FileSize = VtfInfo->CompSize;
1172   }
1173
1174   Buffer = malloc ((UINTN) FileSize);
1175   if (Buffer == NULL) {
1176     return EFI_OUT_OF_RESOURCES;
1177   }
1178   memset (Buffer, 0, (UINTN) FileSize);
1179
1180   if ((VtfInfo->CompType == COMP_TYPE_FIT_PAL_B) || (VtfInfo->CompType == COMP_TYPE_FIT_PAL_A_SPECIFIC)) {
1181
1182     //
1183     // Read first 64 bytes of PAL header and use it to find version info
1184     //
1185     fread (Buffer, sizeof (UINT8), SIZE_OF_PAL_HEADER, Fp);
1186
1187     //
1188     // PAL header contains the version info. Currently, we will use the header
1189     // to read version info and then discard.
1190     //
1191     if (!VtfInfo->VersionPresent) {
1192       GetComponentVersionInfo (VtfInfo, Buffer);
1193     }
1194   }
1195
1196   fread (Buffer, sizeof (UINT8), (UINTN) FileSize, Fp);
1197   fclose (Fp);
1198
1199   //
1200   // If it is non PAL_B component, pass the entire buffer to get the version
1201   // info and implement any specific case inside GetComponentVersionInfo.
1202   //
1203   if (VtfInfo->CompType != COMP_TYPE_FIT_PAL_B) {
1204     if (!VtfInfo->VersionPresent) {
1205       GetComponentVersionInfo (VtfInfo, Buffer);
1206     }
1207   }
1208
1209   if (VtfInfo->LocationType == SECOND_VTF) {
1210
1211     CompStartAddress = (Vtf2LastStartAddress - FileSize);
1212   } else {
1213     CompStartAddress = (Vtf1LastStartAddress - FileSize);
1214   }
1215
1216   if (VtfInfo->CompType == COMP_TYPE_FIT_PAL_B) {
1217     Aligncheck = CheckAddressAlignment (CompStartAddress, 32 * 1024, &NumAdjustByte);
1218   } else {
1219     Aligncheck = CheckAddressAlignment (CompStartAddress, 8, &NumAdjustByte);
1220   }
1221
1222   if (!Aligncheck) {
1223     CompStartAddress -= NumAdjustByte;
1224   }
1225
1226   if (VtfInfo->LocationType == SECOND_VTF && SecondVTF == TRUE) {
1227     Vtf2LastStartAddress = CompStartAddress;
1228     Vtf2TotalSize += (UINT32) (FileSize + NumAdjustByte);
1229     Status = UpdateVtfBuffer (CompStartAddress, Buffer, FileSize, SECOND_VTF);
1230   } else if (VtfInfo->LocationType == FIRST_VTF) {
1231     Vtf1LastStartAddress = CompStartAddress;
1232     Vtf1TotalSize += (UINT32) (FileSize + NumAdjustByte);
1233     Status = UpdateVtfBuffer (CompStartAddress, Buffer, FileSize, FIRST_VTF);
1234   } else {
1235     free (Buffer);
1236     Error (NULL, 0, 2000,"Invalid Parameter", "There's component in second VTF so second BaseAddress and Size must be specified!");
1237     return EFI_INVALID_PARAMETER;
1238   }
1239
1240   if (EFI_ERROR (Status)) {
1241     free (Buffer);
1242     return EFI_ABORTED;
1243   }
1244
1245   GetNextAvailableFitPtr (&CompFitPtr);
1246   if (CompFitPtr == NULL) {
1247     free (Buffer);
1248     return EFI_ABORTED;
1249   }
1250
1251   CompFitPtr->CompAddress = CompStartAddress | IPF_CACHE_BIT;
1252   if ((FileSize % 16) != 0) {
1253     free (Buffer);
1254     Error (NULL, 0, 2000, "Invalid parameter", "Binary FileSize must be a multiple of 16.");
1255     return EFI_INVALID_PARAMETER;
1256   }
1257   //assert ((FileSize % 16) == 0);
1258   CompFitPtr->CompSize    = (UINT32) (FileSize / 16);
1259   CompFitPtr->CompVersion = MAKE_VERSION (VtfInfo->MajorVer, VtfInfo->MinorVer);
1260   CompFitPtr->CvAndType   = CV_N_TYPE (VtfInfo->CheckSumRequired, VtfInfo->CompType);
1261   if (VtfInfo->CheckSumRequired) {
1262     CompFitPtr->CheckSum  = 0;
1263     CompFitPtr->CheckSum  = CalculateChecksum8 (Buffer, (UINTN) FileSize);
1264   }
1265
1266   //
1267   // Free the buffer
1268   //
1269   if (Buffer) {
1270     free (Buffer);
1271   }
1272
1273   //
1274   // Update the SYM file for this component based on it's start address.
1275   //
1276   Status = UpdateSymFile (CompStartAddress, SymFileName, VtfInfo->CompSymName, FileSize);
1277   if (EFI_ERROR (Status)) {
1278
1279     //
1280     // At this time, SYM files are not required, so continue on error.
1281     //
1282   }
1283
1284   // !!!!!!!!!!!!!!!!!!!!!
1285   // BUGBUG:
1286   // This part of the code is a temporary line since PEICORE is going to be inside
1287   // VTF till we work out how to determine the SALE_ENTRY through it. We will need
1288   // to clarify so many related questions
1289   // !!!!!!!!!!!!!!!!!!!!!!!
1290
1291   if (VtfInfo->CompType == COMP_TYPE_FIT_PEICORE) {
1292     Status = UpdateEntryPoint (VtfInfo, &CompStartAddress);
1293   }
1294
1295   return Status;
1296 }
1297
1298 EFI_STATUS
1299 CreateAndUpdatePAL_A (
1300   IN  PARSED_VTF_INFO   *VtfInfo
1301   )
1302 /*++
1303
1304 Routine Description:
1305
1306   This function reads the binary file for each components and update them
1307   in VTF Buffer as well as FIT table
1308
1309 Arguments:
1310
1311   VtfInfo    - Pointer to Parsed Info
1312
1313 Returns:
1314
1315   EFI_ABORTED           - Due to one of the following reasons:
1316                            (a)Error Opening File
1317                            (b)The PAL_A Size is more than specified size status
1318                               One of the values mentioned below returned from
1319                               call to UpdateSymFile
1320   EFI_SUCCESS           - The function completed successfully.
1321   EFI_INVALID_PARAMETER - One of the input parameters was invalid.
1322   EFI_ABORTED           - An error occurred.UpdateSymFile
1323   EFI_OUT_OF_RESOURCES  - Memory allocation failed.
1324
1325 --*/
1326 {
1327   EFI_STATUS  Status;
1328   UINT64      PalStartAddress;
1329   UINT64      AbsAddress;
1330   UINTN       RelativeAddress;
1331   UINT64      FileSize;
1332   UINT8       *Buffer;
1333   FILE        *Fp;
1334   FIT_TABLE   *PalFitPtr;
1335
1336   Fp = fopen (LongFilePath (VtfInfo->CompBinName), "rb");
1337
1338   if (Fp == NULL) {
1339     Error (NULL, 0, 0001, "Error opening file", VtfInfo->CompBinName);
1340     return EFI_ABORTED;
1341   }
1342
1343   FileSize = _filelength (fileno (Fp));
1344   if (FileSize < 64) {
1345     Error (NULL, 0, 2000, "Invalid parameter", "PAL_A bin header is 64 bytes, so the Bin size must be larger than 64 bytes!");
1346     return EFI_INVALID_PARAMETER;
1347   }
1348   FileSize -= SIZE_OF_PAL_HEADER;
1349
1350
1351   if (VtfInfo->PreferredSize) {
1352     if (FileSize > VtfInfo->CompSize) {
1353       Error (NULL, 0, 2000, "Invalid parameter", "The PAL_A Size is more than the specified size.");
1354       return EFI_ABORTED;
1355     }
1356
1357     FileSize = VtfInfo->CompSize;
1358   }
1359
1360   Buffer = malloc ((UINTN) FileSize);
1361   if (Buffer == NULL) {
1362     return EFI_OUT_OF_RESOURCES;
1363   }
1364   memset (Buffer, 0, (UINTN) FileSize);
1365
1366   //
1367   // Read, Get version Info and discard the PAL header.
1368   //
1369   fread (Buffer, sizeof (UINT8), SIZE_OF_PAL_HEADER, Fp);
1370
1371   //
1372   // Extract the version info from header of PAL_A. Once done, discrad this buffer
1373   //
1374   if (!VtfInfo->VersionPresent) {
1375     GetComponentVersionInfo (VtfInfo, Buffer);
1376   }
1377
1378   //
1379   // Read PAL_A file in a buffer
1380   //
1381   fread (Buffer, sizeof (UINT8), (UINTN) FileSize, Fp);
1382   fclose (Fp);
1383
1384   PalStartAddress       = Fv1EndAddress - (SIZE_TO_OFFSET_PAL_A_END + FileSize);
1385   Vtf1LastStartAddress  = PalStartAddress;
1386   Vtf1TotalSize += (UINT32) FileSize;
1387   Status      = UpdateVtfBuffer (PalStartAddress, Buffer, FileSize, FIRST_VTF);
1388
1389   AbsAddress  = Fv1EndAddress - SIZE_TO_PAL_A_FIT;
1390   GetRelativeAddressInVtfBuffer (AbsAddress, &RelativeAddress, FIRST_VTF);
1391   PalFitPtr               = (FIT_TABLE *) RelativeAddress;
1392   PalFitPtr->CompAddress  = PalStartAddress | IPF_CACHE_BIT;
1393   //assert ((FileSize % 16) == 0);
1394   if ((FileSize % 16) != 0) {
1395     free (Buffer);
1396     Error (NULL, 0, 2000, "Invalid parameter", "Binary FileSize must be a multiple of 16.");
1397     return EFI_INVALID_PARAMETER;
1398   }
1399
1400   PalFitPtr->CompSize     = (UINT32) (FileSize / 16);
1401   PalFitPtr->CompVersion  = MAKE_VERSION (VtfInfo->MajorVer, VtfInfo->MinorVer);
1402   PalFitPtr->CvAndType    = CV_N_TYPE (VtfInfo->CheckSumRequired, VtfInfo->CompType);
1403   if (VtfInfo->CheckSumRequired) {
1404     PalFitPtr->CheckSum = 0;
1405     PalFitPtr->CheckSum = CalculateChecksum8 (Buffer, (UINTN) FileSize);
1406   }
1407
1408   if (Buffer) {
1409     free (Buffer);
1410   }
1411
1412   //
1413   // Update the SYM file for this component based on it's start address.
1414   //
1415   Status = UpdateSymFile (PalStartAddress, SymFileName, VtfInfo->CompSymName, FileSize);
1416   if (EFI_ERROR (Status)) {
1417
1418     //
1419     // At this time, SYM files are not required, so continue on error.
1420     //
1421   }
1422
1423   return Status;
1424 }
1425
1426 EFI_STATUS
1427 CreateFitTableAndInitialize (
1428   IN  PARSED_VTF_INFO   *VtfInfo
1429   )
1430 /*++
1431
1432 Routine Description:
1433
1434   This function creates and intializes FIT table which would be used to
1435   add component info inside this
1436
1437 Arguments:
1438
1439   VtfInfo    - Pointer to Parsed Info
1440
1441 Returns:
1442
1443   EFI_ABORTED  - Aborted due to no size information
1444   EFI_SUCCESS  - The function completed successfully
1445
1446 --*/
1447 {
1448   UINT64    PalFitTableAdd;
1449   UINT64    FitTableAdd;
1450   UINT64    FitTableAddressOffset;
1451   FIT_TABLE *PalFitPtr;
1452   FIT_TABLE *FitStartPtr;
1453   UINTN     NumFitComp;
1454   UINTN     RelativeAddress;
1455   UINTN     Index;
1456
1457   if (!VtfInfo->PreferredSize) {
1458     Error (NULL, 0, 2000, "Invalid parameter", "FIT could not be allocated because there is no size information.");
1459     return EFI_ABORTED;
1460   }
1461
1462   if ((VtfInfo->CompSize % 16) != 0) {
1463     Error (NULL, 0, 2000, "Invalid parameter", "Invalid FIT Table Size, it is not a multiple of 16 bytes. Please correct the size.");
1464   }
1465
1466   PalFitTableAdd = Fv1EndAddress - SIZE_TO_PAL_A_FIT;
1467   GetRelativeAddressInVtfBuffer (PalFitTableAdd, &RelativeAddress, FIRST_VTF);
1468   PalFitPtr             = (FIT_TABLE *) RelativeAddress;
1469   PalFitTableAdd        = (PalFitPtr->CompAddress - VtfInfo->CompSize);
1470
1471   FitTableAdd           = (PalFitPtr->CompAddress - 0x10) - VtfInfo->CompSize;
1472   FitTableAddressOffset = Fv1EndAddress - (SIZE_IA32_RESET_VECT + SIZE_SALE_ENTRY_POINT + SIZE_FIT_TABLE_ADD);
1473   GetRelativeAddressInVtfBuffer (FitTableAddressOffset, &RelativeAddress, FIRST_VTF);
1474   *(UINT64 *) RelativeAddress = FitTableAdd;
1475
1476   GetRelativeAddressInVtfBuffer (FitTableAdd, &RelativeAddress, FIRST_VTF);
1477
1478   //
1479   // Update Fit Table with FIT Signature and FIT info in first 16 bytes.
1480   //
1481   FitStartPtr = (FIT_TABLE *) RelativeAddress;
1482
1483   strncpy ((CHAR8 *) &FitStartPtr->CompAddress, FIT_SIGNATURE, 8);  // "_FIT_   "
1484   assert (((VtfInfo->CompSize & 0x00FFFFFF) % 16) == 0);
1485   FitStartPtr->CompSize     = (VtfInfo->CompSize & 0x00FFFFFF) / 16;
1486   FitStartPtr->CompVersion  = MAKE_VERSION (VtfInfo->MajorVer, VtfInfo->MinorVer);
1487
1488   //
1489   // BUGBUG: If a checksum is required, add code to checksum the FIT table.  Also
1490   // determine what to do for things like the FV component that aren't easily checksummed.
1491   // The checksum will be done once we are done with all the componet update in the FIT
1492   // table
1493   //
1494   FitStartPtr->CvAndType  = CV_N_TYPE (VtfInfo->CheckSumRequired, VtfInfo->CompType);
1495
1496   NumFitComp              = FitStartPtr->CompSize;
1497
1498   FitStartPtr++;
1499
1500   //
1501   // Intialize remaining FIT table space to UNUSED fit component type
1502   // so that when we need to create a FIT entry for a component, we can
1503   // locate a free one and use it.
1504   //
1505   for (Index = 0; Index < (NumFitComp - 1); Index++) {
1506     FitStartPtr->CvAndType = 0x7F;  // Initialize all with UNUSED
1507     FitStartPtr++;
1508   }
1509
1510   Vtf1TotalSize += VtfInfo->CompSize;
1511   Vtf1LastStartAddress -= VtfInfo->CompSize;
1512
1513   return EFI_SUCCESS;
1514 }
1515
1516 EFI_STATUS
1517 WriteVtfBinary (
1518   IN CHAR8     *FileName,
1519   IN UINT32    VtfSize,
1520   IN LOC_TYPE  LocType
1521   )
1522 /*++
1523
1524 Routine Description:
1525
1526   Write Firmware Volume from memory to a file.
1527
1528 Arguments:
1529
1530   FileName     - Output File Name which needed to be created/
1531   VtfSize      - FileSize
1532   LocType      - The type of the VTF
1533
1534 Returns:
1535
1536   EFI_ABORTED - Returned due to one of the following resons:
1537                  (a) Error Opening File
1538                  (b) Failing to copy buffers
1539   EFI_SUCCESS - The fuction completes successfully
1540
1541 --*/
1542 {
1543   FILE  *Fp;
1544   UINTN NumByte;
1545   VOID  *VtfBuffer;
1546   UINTN RelativeAddress;
1547
1548   if (LocType == FIRST_VTF) {
1549     GetRelativeAddressInVtfBuffer (Vtf1LastStartAddress, &RelativeAddress, FIRST_VTF);
1550     VtfBuffer = (VOID *) RelativeAddress;
1551   } else {
1552     GetRelativeAddressInVtfBuffer (Vtf2LastStartAddress, &RelativeAddress, SECOND_VTF);
1553     VtfBuffer = (VOID *) RelativeAddress;
1554   }
1555
1556   Fp = fopen (LongFilePath (FileName), "wb");
1557   if (Fp == NULL) {
1558     Error (NULL, 0, 0001, "Error opening file", FileName);
1559     return EFI_ABORTED;
1560   }
1561
1562   NumByte = fwrite (VtfBuffer, sizeof (UINT8), (UINTN) VtfSize, Fp);
1563
1564   if (Fp) {
1565     fclose (Fp);
1566   }
1567
1568   if (NumByte != (sizeof (UINT8) * VtfSize)) {
1569     Error (NULL, 0, 0002, "Error writing file", FileName);
1570     return EFI_ABORTED;
1571   }
1572
1573   return EFI_SUCCESS;
1574 }
1575
1576 EFI_STATUS
1577 UpdateVtfBuffer (
1578   IN  UINT64   StartAddress,
1579   IN  UINT8    *Buffer,
1580   IN  UINT64   DataSize,
1581   IN LOC_TYPE  LocType
1582   )
1583 /*++
1584
1585 Routine Description:
1586
1587   Update the Firmware Volume Buffer with requested buffer data
1588
1589 Arguments:
1590
1591   StartAddress   - StartAddress in buffer. This number will automatically
1592                   point to right address in buffer where data needed
1593                   to be updated.
1594   Buffer         - Buffer pointer from data will be copied to memory mapped buffer.
1595   DataSize       - Size of the data needed to be copied.
1596   LocType        - The type of the VTF: First or Second
1597
1598 Returns:
1599
1600   EFI_ABORTED  - The input parameter is error
1601   EFI_SUCCESS  - The function completed successfully
1602
1603 --*/
1604 {
1605   UINT8 *LocalBufferPtrToWrite;
1606
1607   if (LocType == FIRST_VTF) {
1608     if ((StartAddress | IPF_CACHE_BIT) < (Vtf1LastStartAddress | IPF_CACHE_BIT)) {
1609       Error (NULL, 0, 2000, "Invalid parameter", "Start Address is less than the VTF start address.");
1610       return EFI_ABORTED;
1611     }
1612
1613     LocalBufferPtrToWrite = (UINT8 *) Vtf1EndBuffer;
1614
1615     LocalBufferPtrToWrite -= (Fv1EndAddress - StartAddress);
1616
1617   } else {
1618
1619     if ((StartAddress | IPF_CACHE_BIT) < (Vtf2LastStartAddress | IPF_CACHE_BIT)) {
1620       Error (NULL, 0, 2000, "Invalid parameter", "Error StartAddress");
1621       return EFI_ABORTED;
1622     }
1623     LocalBufferPtrToWrite = (UINT8 *) Vtf2EndBuffer;
1624     LocalBufferPtrToWrite -= (Fv2EndAddress - StartAddress);
1625   }
1626
1627   memcpy (LocalBufferPtrToWrite, Buffer, (UINTN) DataSize);
1628
1629   return EFI_SUCCESS;
1630 }
1631
1632 EFI_STATUS
1633 UpdateFfsHeader (
1634   IN UINT32         TotalVtfSize,
1635   IN LOC_TYPE       LocType
1636   )
1637 /*++
1638
1639 Routine Description:
1640
1641   Update the Firmware Volume Buffer with requested buffer data
1642
1643 Arguments:
1644
1645   TotalVtfSize     - Size of the VTF
1646   Fileoffset       - The start of the file relative to the start of the FV.
1647   LocType          - The type of the VTF
1648
1649 Returns:
1650
1651   EFI_SUCCESS            - The function completed successfully
1652   EFI_INVALID_PARAMETER  - The Ffs File Header Pointer is NULL
1653
1654 --*/
1655 {
1656   EFI_FFS_FILE_HEADER *FileHeader;
1657   UINTN               RelativeAddress;
1658   EFI_GUID            EfiFirmwareVolumeTopFileGuid = EFI_FFS_VOLUME_TOP_FILE_GUID;
1659
1660   //
1661   // Find the VTF file header location
1662   //
1663   if (LocType == FIRST_VTF) {
1664     GetRelativeAddressInVtfBuffer (Vtf1LastStartAddress, &RelativeAddress, FIRST_VTF);
1665     FileHeader = (EFI_FFS_FILE_HEADER *) RelativeAddress;
1666   } else {
1667     GetRelativeAddressInVtfBuffer (Vtf2LastStartAddress, &RelativeAddress, SECOND_VTF);
1668     FileHeader = (EFI_FFS_FILE_HEADER *) RelativeAddress;
1669   }
1670
1671   if (FileHeader == NULL) {
1672     return EFI_INVALID_PARAMETER;
1673   }
1674
1675   //
1676   // write header
1677   //
1678   memset (FileHeader, 0, sizeof (EFI_FFS_FILE_HEADER));
1679   memcpy (&FileHeader->Name, &EfiFirmwareVolumeTopFileGuid, sizeof (EFI_GUID));
1680   FileHeader->Type        = EFI_FV_FILETYPE_RAW;
1681   FileHeader->Attributes  = FFS_ATTRIB_CHECKSUM;
1682
1683   //
1684   // Now FileSize includes the EFI_FFS_FILE_HEADER
1685   //
1686   FileHeader->Size[0] = (UINT8) (TotalVtfSize & 0x000000FF);
1687   FileHeader->Size[1] = (UINT8) ((TotalVtfSize & 0x0000FF00) >> 8);
1688   FileHeader->Size[2] = (UINT8) ((TotalVtfSize & 0x00FF0000) >> 16);
1689
1690   //
1691   // Fill in checksums and state, all three must be zero for the checksums.
1692   //
1693   FileHeader->IntegrityCheck.Checksum.Header  = 0;
1694   FileHeader->IntegrityCheck.Checksum.File    = 0;
1695   FileHeader->State                           = 0;
1696   FileHeader->IntegrityCheck.Checksum.Header  = CalculateChecksum8 ((UINT8 *) FileHeader, sizeof (EFI_FFS_FILE_HEADER));
1697   FileHeader->IntegrityCheck.Checksum.File    = CalculateChecksum8 ((UINT8 *) (FileHeader + 1), TotalVtfSize - sizeof (EFI_FFS_FILE_HEADER));
1698   FileHeader->State                           = EFI_FILE_HEADER_CONSTRUCTION | EFI_FILE_HEADER_VALID | EFI_FILE_DATA_VALID;
1699
1700   return EFI_SUCCESS;
1701 }
1702
1703 EFI_STATUS
1704 ValidateAddressAndSize (
1705   IN  UINT64  BaseAddress,
1706   IN  UINT64  FwVolSize
1707   )
1708 /*++
1709
1710 Routine Description:
1711
1712   Update the Firmware Volume Buffer with requested buffer data
1713
1714 Arguments:
1715
1716   BaseAddress    - Base address for the Fw Volume.
1717
1718   FwVolSize      - Total Size of the FwVolume to which VTF will be attached..
1719
1720 Returns:
1721
1722   EFI_SUCCESS     - The function completed successfully
1723   EFI_UNSUPPORTED - The input parameter is error
1724
1725 --*/
1726 {
1727   if ((FwVolSize > 0x40) && ((BaseAddress + FwVolSize) % 8 == 0)) {
1728     return EFI_SUCCESS;
1729   }
1730
1731   return EFI_UNSUPPORTED;
1732 }
1733
1734 EFI_STATUS
1735 UpdateIA32ResetVector (
1736   IN  CHAR8   *FileName,
1737   IN  UINT64  FirstFwVSize
1738   )
1739 /*++
1740
1741 Routine Description:
1742
1743   Update the 16 byte IA32 Reset vector to maintain the compatibility
1744
1745 Arguments:
1746
1747   FileName     - Binary file name which contains the IA32 Reset vector info..
1748   FirstFwVSize - Total Size of the FwVolume to which VTF will be attached..
1749
1750 Returns:
1751
1752   EFI_SUCCESS            - The function completed successfully
1753   EFI_ABORTED            - Invalid File Size
1754   EFI_INVALID_PARAMETER  - Bad File Name
1755   EFI_OUT_OF_RESOURCES   - Memory allocation failed.
1756
1757 --*/
1758 {
1759   UINT8 *Buffer;
1760   UINT8 *LocalVtfBuffer;
1761   UINTN FileSize;
1762   FILE  *Fp;
1763
1764   if (!strcmp (FileName, "")) {
1765     return EFI_INVALID_PARAMETER;
1766   }
1767
1768   Fp = fopen (LongFilePath (FileName), "rb");
1769
1770   if (Fp == NULL) {
1771     Error (NULL, 0, 0001, "Error opening file", FileName);
1772     return EFI_ABORTED;
1773   }
1774
1775   FileSize = _filelength (fileno (Fp));
1776
1777   if (FileSize > 16) {
1778     return EFI_ABORTED;
1779   }
1780
1781   Buffer = malloc (FileSize);
1782   if (Buffer == NULL) {
1783     return EFI_OUT_OF_RESOURCES;
1784   }
1785
1786   fread (Buffer, sizeof (UINT8), FileSize, Fp);
1787
1788   LocalVtfBuffer  = (UINT8 *) Vtf1EndBuffer - SIZE_IA32_RESET_VECT;
1789   memcpy (LocalVtfBuffer, Buffer, FileSize);
1790
1791   if (Buffer) {
1792     free (Buffer);
1793   }
1794
1795   if (Fp != NULL) {
1796     fclose (Fp);
1797   }
1798   return EFI_SUCCESS;
1799 }
1800
1801 VOID
1802 CleanUpMemory (
1803   VOID
1804   )
1805 /*++
1806
1807 Routine Description:
1808
1809   This function cleans up any allocated buffer
1810
1811 Arguments:
1812
1813   NONE
1814
1815 Returns:
1816
1817   NONE
1818
1819 --*/
1820 {
1821   PARSED_VTF_INFO *TempFileListPtr;
1822
1823   if (Vtf1Buffer) {
1824     free (Vtf1Buffer);
1825   }
1826
1827   if (Vtf2Buffer) {
1828     free (Vtf2Buffer);
1829   }
1830
1831   //
1832   // Cleanup the buffer which was allocated to read the file names from FV.INF
1833   //
1834   FileListPtr = FileListHeadPtr;
1835   while (FileListPtr != NULL) {
1836     TempFileListPtr = FileListPtr->NextVtfInfo;
1837     free (FileListPtr);
1838     FileListPtr = TempFileListPtr;
1839   }
1840 }
1841
1842 EFI_STATUS
1843 ProcessAndCreateVtf (
1844   IN  UINT64  Size
1845   )
1846 /*++
1847
1848 Routine Description:
1849
1850   This function process the link list created during INF file parsing
1851   and create component in VTF and updates its info in FIT table
1852
1853 Arguments:
1854
1855   Size   - Size of the Firmware Volume of which, this VTF belongs to.
1856
1857 Returns:
1858
1859   EFI_UNSUPPORTED - Unknown FIT type
1860   EFI_SUCCESS     - The function completed successfully
1861
1862 --*/
1863 {
1864   EFI_STATUS      Status;
1865   PARSED_VTF_INFO *ParsedInfoPtr;
1866
1867   Status        = EFI_SUCCESS;
1868
1869   ParsedInfoPtr = FileListHeadPtr;
1870
1871   while (ParsedInfoPtr != NULL) {
1872
1873     switch (ParsedInfoPtr->CompType) {
1874     //
1875     // COMP_TYPE_FIT_HEADER is a special case, hence handle it here
1876     //
1877     case COMP_TYPE_FIT_HEADER:
1878       //COMP_TYPE_FIT_HEADER          0x00
1879       Status = CreateFitTableAndInitialize (ParsedInfoPtr);
1880       break;
1881
1882     //
1883     // COMP_TYPE_FIT_PAL_A is a special case, hence handle it here
1884     //
1885     case COMP_TYPE_FIT_PAL_A:
1886       //COMP_TYPE_FIT_PAL_A           0x0F
1887       Status = CreateAndUpdatePAL_A (ParsedInfoPtr);
1888
1889       //
1890       // Based on VTF specification, once the PAL_A component has been written,
1891       // update the Firmware Volume info as FIT table. This will be utilized
1892       // to extract the Firmware Volume Start address where this VTF will be
1893       // of part.
1894       //
1895       if (Status == EFI_SUCCESS) {
1896         UpdateFitEntryForFwVolume (Size);
1897       }
1898       break;
1899
1900     case COMP_TYPE_FIT_FV_BOOT:
1901       //COMP_TYPE_FIT_FV_BOOT         0x7E
1902       //
1903       // Since FIT entry for Firmware Volume has been created and it is
1904       // located at (PAL_A start - 16 byte). So we will not process any
1905       // Firmware Volume related entry from INF file
1906       //
1907       Status = EFI_SUCCESS;
1908       break;
1909
1910     default:
1911       //
1912       // Any other component type should be handled here. This will create the
1913       // image in specified VTF and create appropriate entry about this
1914       // component in FIT Entry.
1915       //
1916       Status = CreateAndUpdateComponent (ParsedInfoPtr);
1917       if (EFI_ERROR (Status)) {
1918         Error (NULL, 0, 0002, "Error updating component", ParsedInfoPtr->CompName);
1919         return EFI_ABORTED;
1920       } else {
1921       break;}
1922     }
1923
1924     ParsedInfoPtr = ParsedInfoPtr->NextVtfInfo;
1925   }
1926   return Status;
1927 }
1928
1929 EFI_STATUS
1930 GenerateVtfImage (
1931   IN  UINT64  StartAddress1,
1932   IN  UINT64  Size1,
1933   IN  UINT64  StartAddress2,
1934   IN  UINT64  Size2,
1935   IN  FILE    *fp
1936   )
1937 /*++
1938
1939 Routine Description:
1940
1941   This is the main function which will be called from application.
1942
1943 Arguments:
1944
1945   StartAddress1  - The start address of the first VTF
1946   Size1          - The size of the first VTF
1947   StartAddress2  - The start address of the second VTF
1948   Size2          - The size of the second VTF
1949   fp             - The pointer to BSF inf file
1950
1951 Returns:
1952
1953   EFI_OUT_OF_RESOURCES - Can not allocate memory
1954   The return value can be any of the values
1955   returned by the calls to following functions:
1956       GetVtfRelatedInfoFromInfFile
1957       ProcessAndCreateVtf
1958       UpdateIA32ResetVector
1959       UpdateFfsHeader
1960       WriteVtfBinary
1961
1962 --*/
1963 {
1964   EFI_STATUS  Status;
1965   FILE            *VtfFP;
1966
1967   Status          = EFI_UNSUPPORTED;
1968   VtfFP = fp;
1969
1970   if (StartAddress2 == 0) {
1971     SecondVTF = FALSE;
1972   } else {
1973     SecondVTF = TRUE;
1974   }
1975
1976   Fv1BaseAddress        = StartAddress1;
1977   Fv1EndAddress         = Fv1BaseAddress + Size1;
1978   if (Fv1EndAddress != 0x100000000ULL || Size1 < 0x100000) {
1979     Error (NULL, 0, 2000, "Invalid parameter", "Error BaseAddress and Size parameters!");
1980     if (Size1 < 0x100000) {
1981       Error (NULL, 0, 2000, "Invalid parameter", "The FwVolumeSize must be larger than 1M!");
1982     } else if (SecondVTF != TRUE) {
1983       Error (NULL, 0, 2000, "Invalid parameter", "BaseAddress + FwVolumeSize must equal 0x100000000!");
1984     }
1985     Usage();
1986     return EFI_INVALID_PARAMETER;
1987   }
1988
1989   //
1990   // The image buffer for the First VTF
1991   //
1992   Vtf1Buffer = malloc ((UINTN) Size1);
1993   if (Vtf1Buffer == NULL) {
1994     Error (NULL, 0, 4001, "Resource", "Not enough resources available to create memory mapped file for the Boot Strap File!");
1995     return EFI_OUT_OF_RESOURCES;
1996   }
1997   memset (Vtf1Buffer, 0x00, (UINTN) Size1);
1998   Vtf1EndBuffer         = (UINT8 *) Vtf1Buffer + Size1;
1999   Vtf1LastStartAddress  = Fv1EndAddress | IPF_CACHE_BIT;
2000
2001   if (SecondVTF) {
2002     Fv2BaseAddress        = StartAddress2;
2003     Fv2EndAddress         = Fv2BaseAddress + Size2;
2004     if (Fv2EndAddress != StartAddress1) {
2005       Error (NULL, 0, 2000, "Invalid parameter", "Error BaseAddress and Size parameters!");
2006       if (SecondVTF == TRUE) {
2007         Error (NULL, 0, 2000, "Invalid parameter", "FirstBaseAddress + FirstFwVolumeSize must equal 0x100000000!");
2008         Error (NULL, 0, 2000, "Invalid parameter", "SecondBaseAddress + SecondFwVolumeSize must equal FirstBaseAddress!");
2009       }
2010       Usage();
2011       return EFI_INVALID_PARAMETER;
2012     }
2013
2014     //
2015     // The image buffer for the second VTF
2016     //
2017     Vtf2Buffer = malloc ((UINTN) Size2);
2018     if (Vtf2Buffer == NULL) {
2019       Error (NULL, 0, 4001, "Resource", "Not enough resources available to create memory mapped file for the Boot Strap File!");
2020       return EFI_OUT_OF_RESOURCES;
2021     }
2022     memset (Vtf2Buffer, 0x00, (UINTN) Size2);
2023     Vtf2EndBuffer         = (UINT8 *) Vtf2Buffer + Size2;
2024     Vtf2LastStartAddress  = Fv2EndAddress | IPF_CACHE_BIT;
2025   }
2026
2027   Status = GetVtfRelatedInfoFromInfFile (VtfFP);
2028
2029   if (Status != EFI_SUCCESS) {
2030     Error (NULL, 0, 0003, "Error parsing file", "the input file.");
2031     CleanUpMemory ();
2032     return Status;
2033   }
2034
2035   Status = ProcessAndCreateVtf (Size1);
2036   if (Status != EFI_SUCCESS) {
2037     CleanUpMemory ();
2038     return Status;
2039   }
2040
2041   if (SectionOptionFlag) {
2042     Status = UpdateIA32ResetVector (IA32BinFile, Vtf1TotalSize);
2043     if (Status != EFI_SUCCESS) {
2044       CleanUpMemory ();
2045       return Status;
2046     }
2047   }
2048
2049   //
2050   // Re arrange the FIT Table for Ascending order of their FIT Type..
2051   //
2052   SortFitTable ();
2053
2054   //
2055   // All components have been updated in FIT table. Now perform the FIT table
2056   // checksum. The following function will check if Checksum is required,
2057   // if yes, then it will perform the checksum otherwise not.
2058   //
2059   CalculateFitTableChecksum ();
2060
2061   //
2062   // Write the FFS header
2063   //
2064   Vtf1TotalSize += sizeof (EFI_FFS_FILE_HEADER);
2065   Vtf1LastStartAddress -= sizeof (EFI_FFS_FILE_HEADER);
2066
2067   Status = UpdateFfsHeader (Vtf1TotalSize, FIRST_VTF);
2068   if (Status != EFI_SUCCESS) {
2069     CleanUpMemory ();
2070     return Status;
2071   }
2072   //
2073   // Update the VTF buffer into specified VTF binary file
2074   //
2075   Status  = WriteVtfBinary (OutFileName1, Vtf1TotalSize, FIRST_VTF);
2076
2077   if (SecondVTF) {
2078     Vtf2TotalSize += sizeof (EFI_FFS_FILE_HEADER);
2079     Vtf2LastStartAddress -= sizeof (EFI_FFS_FILE_HEADER);
2080     Status = UpdateFfsHeader (Vtf2TotalSize, SECOND_VTF);
2081     if (Status != EFI_SUCCESS) {
2082       CleanUpMemory ();
2083       return Status;
2084     }
2085
2086     //
2087     // Update the VTF buffer into specified VTF binary file
2088     //
2089     Status  = WriteVtfBinary (OutFileName2, Vtf2TotalSize, SECOND_VTF);
2090   }
2091
2092   CleanUpMemory ();
2093
2094   return Status;
2095 }
2096
2097 EFI_STATUS
2098 PeimFixupInFitTable (
2099   IN  UINT64  StartAddress
2100   )
2101 /*++
2102
2103 Routine Description:
2104
2105   This function is an entry point to fixup SAL-E entry point.
2106
2107 Arguments:
2108
2109   StartAddress - StartAddress for PEIM.....
2110
2111 Returns:
2112
2113   EFI_SUCCESS          - The function completed successfully
2114   EFI_ABORTED          - Error Opening File
2115   EFI_OUT_OF_RESOURCES - System out of resources for memory allocation.
2116
2117 --*/
2118 {
2119   EFI_STATUS  Status;
2120   FILE        *Fp;
2121   UINT64      *StartAddressPtr;
2122   UINTN       FirstFwVSize;
2123
2124   StartAddressPtr   = malloc (sizeof (UINT64));
2125   if (StartAddressPtr == NULL) {
2126     return EFI_OUT_OF_RESOURCES;
2127   }
2128   *StartAddressPtr = StartAddress;
2129
2130   Fp = fopen (LongFilePath (OutFileName1), "rb");
2131
2132   if (Fp == NULL) {
2133     Error (NULL, 0, 0001, "Error opening file", OutFileName1);
2134     if (StartAddressPtr) {
2135       free (StartAddressPtr);
2136     }
2137     return EFI_ABORTED;
2138   }
2139
2140   FirstFwVSize = _filelength (fileno (Fp));
2141   fseek (Fp, (long) (FirstFwVSize - (UINTN) (SIZE_IA32_RESET_VECT + SIZE_SALE_ENTRY_POINT)), SEEK_SET);
2142   fwrite ((VOID *) StartAddressPtr, sizeof (UINT64), 1, Fp);
2143
2144   if (Fp) {
2145     fclose (Fp);
2146   }
2147
2148   if (StartAddressPtr) {
2149     free (StartAddressPtr);
2150   }
2151
2152   Status = EFI_SUCCESS;
2153   return Status;
2154 }
2155
2156 EFI_STATUS
2157 UpdateSymFile (
2158   IN UINT64 BaseAddress,
2159   IN CHAR8  *DestFileName,
2160   IN CHAR8  *SourceFileName,
2161   IN UINT64 FileSize
2162
2163   )
2164 /*++
2165
2166 Routine Description:
2167
2168   This function adds the SYM tokens in the source file to the destination file.
2169   The SYM tokens are updated to reflect the base address.
2170
2171 Arguments:
2172
2173   BaseAddress    - The base address for the new SYM tokens.
2174   DestFileName   - The destination file.
2175   SourceFileName - The source file.
2176   FileSize       - Size of bin file.
2177
2178 Returns:
2179
2180   EFI_SUCCESS             - The function completed successfully.
2181   EFI_INVALID_PARAMETER   - One of the input parameters was invalid.
2182   EFI_ABORTED             - An error occurred.
2183
2184 --*/
2185 {
2186   FILE    *SourceFile;
2187   FILE    *DestFile;
2188   CHAR8   Buffer[MAX_LONG_FILE_PATH];
2189   CHAR8   Type[MAX_LONG_FILE_PATH];
2190   CHAR8   Address[MAX_LONG_FILE_PATH];
2191   CHAR8   Section[MAX_LONG_FILE_PATH];
2192   CHAR8   Token[MAX_LONG_FILE_PATH];
2193   CHAR8   BaseToken[MAX_LONG_FILE_PATH];
2194   UINT64  TokenAddress;
2195   long    StartLocation;
2196
2197   //
2198   // Verify input parameters.
2199   //
2200   if (BaseAddress == 0 || DestFileName == NULL || SourceFileName == NULL) {
2201     return EFI_INVALID_PARAMETER;
2202   }
2203
2204   //
2205   // Open the source file
2206   //
2207   SourceFile = fopen (LongFilePath (SourceFileName), "r");
2208   if (SourceFile == NULL) {
2209
2210     //
2211     // SYM files are not required.
2212     //
2213     return EFI_SUCCESS;
2214   }
2215
2216   //
2217   // Use the file name minus extension as the base for tokens
2218   //
2219   strcpy (BaseToken, SourceFileName);
2220   strtok (BaseToken, ". \t\n");
2221   strcat (BaseToken, "__");
2222
2223   //
2224   // Open the destination file
2225   //
2226   DestFile = fopen (LongFilePath (DestFileName), "a+");
2227   if (DestFile == NULL) {
2228     fclose (SourceFile);
2229     Error (NULL, 0, 0001, "Error opening file", DestFileName);
2230     return EFI_ABORTED;
2231   }
2232
2233   //
2234   // If this is the beginning of the output file, write the symbol format info.
2235   //
2236   if (fseek (DestFile, 0, SEEK_END) != 0) {
2237     fclose (SourceFile);
2238     fclose (DestFile);
2239     Error (NULL, 0, 2000, "Invalid parameter", "not at the beginning of the output file.");
2240     return EFI_ABORTED;
2241   }
2242
2243   StartLocation = ftell (DestFile);
2244
2245   if (StartLocation == 0) {
2246     fprintf (DestFile, "TEXTSYM format | V1.0\n");
2247   } else if (StartLocation == -1) {
2248     fclose (SourceFile);
2249     fclose (DestFile);
2250     Error (NULL, 0, 2000, "Invalid parameter", "StartLocation error");
2251     return EFI_ABORTED;
2252   }
2253
2254   //
2255   // Read the first line
2256   //
2257   if (fgets (Buffer, MAX_LONG_FILE_PATH, SourceFile) == NULL) {
2258     Buffer[0] = 0;
2259   }
2260
2261   //
2262   // Make sure it matches the expected sym format
2263   //
2264   if (strcmp (Buffer, "TEXTSYM format | V1.0\n")) {
2265     fclose (SourceFile);
2266     fclose (DestFile);
2267     Error (NULL, 0, 2000, "Invalid parameter", "The symbol file does not match the expected TEXTSYM format (V1.0.)");
2268     return EFI_ABORTED;
2269   }
2270
2271   //
2272   // Read in the file
2273   //
2274   while (feof (SourceFile) == 0) {
2275
2276     //
2277     // Read a line
2278     //
2279     if (fscanf (SourceFile, "%s | %s | %s | %s\n", Type, Address, Section, Token) == 4) {
2280
2281       //
2282       // Get the token address
2283       //
2284       AsciiStringToUint64 (Address, TRUE, &TokenAddress);
2285       if (TokenAddress > FileSize) {
2286         //
2287         // Symbol offset larger than FileSize. This Symbol can't be in Bin file. Don't print them.
2288         //
2289         break;
2290       }
2291
2292       //
2293       // Add the base address, the size of the FFS file header and the size of the peim header.
2294       //
2295       TokenAddress += BaseAddress &~IPF_CACHE_BIT;
2296
2297       fprintf (DestFile, "%s | %016llX | ", Type, (unsigned long long) TokenAddress);
2298       fprintf (DestFile, "%s | %s\n    %s\n", Section, Token, BaseToken);
2299     }
2300   }
2301
2302   fclose (SourceFile);
2303   fclose (DestFile);
2304   return EFI_SUCCESS;
2305 }
2306
2307 EFI_STATUS
2308 CalculateFitTableChecksum (
2309   VOID
2310   )
2311 /*++
2312
2313 Routine Description:
2314
2315   This function will perform byte checksum on the FIT table, if the the checksum required
2316   field is set to CheckSum required. If the checksum is not required then checksum byte
2317   will have value as 0;.
2318
2319 Arguments:
2320
2321   NONE
2322
2323 Returns:
2324
2325   Status       - Value returned by call to CalculateChecksum8 ()
2326   EFI_SUCCESS  - The function completed successfully
2327
2328 --*/
2329 {
2330   FIT_TABLE *TmpFitPtr;
2331   UINT64    FitTableAdd;
2332   UINT64    FitTableAddOffset;
2333   UINTN     RelativeAddress;
2334   UINTN     Size;
2335
2336   //
2337   // Read the Fit Table address from Itanium-based address map.
2338   //
2339   FitTableAddOffset = Fv1EndAddress - (SIZE_IA32_RESET_VECT + SIZE_SALE_ENTRY_POINT + SIZE_FIT_TABLE_ADD);
2340
2341   //
2342   // Translate this Itanium-based address in terms of local buffer address which
2343   // contains the image for Boot Strapped File
2344   //
2345   GetRelativeAddressInVtfBuffer (FitTableAddOffset, &RelativeAddress, FIRST_VTF);
2346   FitTableAdd = *(UINTN *) RelativeAddress;
2347
2348   GetRelativeAddressInVtfBuffer (FitTableAdd, &RelativeAddress, FIRST_VTF);
2349
2350   TmpFitPtr = (FIT_TABLE *) RelativeAddress;
2351
2352   Size      = TmpFitPtr->CompSize * 16;
2353
2354   if ((TmpFitPtr->CvAndType & CHECKSUM_BIT_MASK) >> 7) {
2355     TmpFitPtr->CheckSum = 0;
2356     TmpFitPtr->CheckSum = CalculateChecksum8 ((UINT8 *) TmpFitPtr, Size);
2357   } else {
2358     TmpFitPtr->CheckSum = 0;
2359   }
2360
2361   return EFI_SUCCESS;
2362 }
2363
2364 VOID
2365 Version (
2366   VOID
2367   )
2368 /*++
2369
2370 Routine Description:
2371
2372   Displays the standard utility information to SDTOUT
2373
2374 Arguments:
2375
2376   None
2377
2378 Returns:
2379
2380   None
2381
2382 --*/
2383 {
2384   fprintf (stdout, "%s Version %d.%d %s \n", UTILITY_NAME, UTILITY_MAJOR_VERSION, UTILITY_MINOR_VERSION, __BUILD_VERSION);
2385 }
2386
2387 VOID
2388 Usage (
2389   VOID
2390   )
2391 /*++
2392
2393 Routine Description:
2394
2395   Displays the utility usage syntax to STDOUT
2396
2397 Arguments:
2398
2399   None
2400
2401 Returns:
2402
2403   None
2404
2405 --*/
2406 {
2407   //
2408   // Summary usage
2409   //
2410   fprintf (stdout, "Usage: %s [options] <-f input_file> <-r BaseAddress> <-s FwVolumeSize>\n\n", UTILITY_NAME);
2411
2412   //
2413   // Copyright declaration
2414   //
2415   fprintf (stdout, "Copyright (c) 2007 - 2014, Intel Corporation. All rights reserved.\n\n");
2416   //
2417   // Details Option
2418   //
2419   fprintf (stdout, "Options:\n");
2420   fprintf (stdout, "  -f Input_file,   --filename Input_file\n\
2421                         Input_file is name of the BS Image INF file\n");
2422   fprintf (stdout, "  -r BaseAddress,  --baseaddr BaseAddress\n\
2423                         BaseAddress is the starting address of Firmware Volume\n\
2424                         where Boot Strapped Image will reside.\n");
2425   fprintf (stdout, "  -s FwVolumeSize, --size FwVolumeSize\n\
2426                         FwVolumeSize is the size of Firmware Volume.\n");
2427   fprintf (stdout, "  -o FileName,     --output FileName\n\
2428                         File will be created to store the ouput content.\n");
2429   fprintf (stdout, "  -v, --verbose         Turn on verbose output with informational messages.\n");
2430   fprintf (stdout, "  --version             Show program's version number and exit.\n");
2431   fprintf (stdout, "  -h, --help            Show this help message and exit.\n");
2432   fprintf (stdout, "  -q, --quiet           Disable all messages except FATAL ERRORS.\n");
2433   fprintf (stdout, "  -d, --debug [#, 0-9]  Enable debug messages at level #.\n");
2434 }
2435
2436 int
2437 main (
2438   IN  int  argc,
2439   IN  char  **argv
2440   )
2441 /*++
2442
2443 Routine Description:
2444
2445   This utility uses GenVtf.dll to build a Boot Strap File Image which will be
2446   part of firmware volume image.
2447
2448 Arguments:
2449
2450   argc   - The count of the parameters
2451   argv   - The parameters
2452
2453
2454 Returns:
2455
2456   0   - No error conditions detected.
2457   1   - One or more of the input parameters is invalid.
2458   2   - A resource required by the utility was unavailable.
2459       - Most commonly this will be memory allocation or file creation.
2460   3   - GenFvImage.dll could not be loaded.
2461   4   - Error executing the GenFvImage dll.
2462   5   - Now this tool does not support the IA32 platform
2463
2464 --*/
2465 {
2466   UINT8          Index;
2467   UINT64         StartAddress1;
2468   UINT64         StartAddress2;
2469   UINT64         FwVolSize1;
2470   UINT64         FwVolSize2;
2471   BOOLEAN       FirstRoundO;
2472   BOOLEAN       FirstRoundB;
2473   BOOLEAN       FirstRoundS;
2474   EFI_STATUS    Status;
2475   FILE          *VtfFP;
2476   CHAR8         *VtfFileName;
2477
2478   SetUtilityName (UTILITY_NAME);
2479
2480   //
2481   // Initialize variables
2482   //
2483   StartAddress1 = 0;
2484   StartAddress2 = 0;
2485   FwVolSize1    = 0;
2486   FwVolSize2    = 0;
2487   FirstRoundB   = TRUE;
2488   FirstRoundS   = TRUE;
2489   FirstRoundO   = TRUE;
2490   DebugMode     = FALSE;
2491   OutFileName1  = NULL;
2492   OutFileName2  = NULL;
2493   VtfFP = NULL;
2494   DebugLevel = 0;
2495
2496   //
2497   // Verify the correct number of arguments
2498   //
2499   if (argc == 1) {
2500     Usage();
2501     return 0;
2502   }
2503
2504   if ((strcmp(argv[1], "-h") == 0) || (strcmp(argv[1], "--help") == 0)) {
2505     Usage();
2506     return 0;
2507   }
2508
2509   if ((strcmp(argv[1], "--version") == 0)) {
2510     Version();
2511     return 0;
2512   }
2513
2514   //
2515   // Parse the command line arguments
2516   //
2517   for (Index = 1; Index < argc; Index += 2) {
2518     if ((stricmp (argv[Index], "-o") == 0) || (stricmp (argv[Index], "--output") == 0)) {
2519       if (argv[Index + 1] == NULL || argv[Index + 1][0] == '-') {
2520         Error (NULL, 0, 1003, "Invalid option value", "Output file is missing for -o option");
2521         goto ERROR;
2522       }
2523       //
2524       // Get the output file name
2525       //
2526       VTF_OUTPUT = TRUE;
2527       if (FirstRoundO) {
2528         //
2529         // It's the first output file name
2530         //
2531         OutFileName1 = (CHAR8 *)argv[Index+1];
2532         FirstRoundO = FALSE;
2533       } else {
2534         //
2535         //It's the second output file name
2536         //
2537         OutFileName2 = (CHAR8 *)argv[Index+1];
2538       }
2539       continue;
2540     }
2541
2542     if ((stricmp (argv[Index], "-f") == 0) || (stricmp (argv[Index], "--filename") == 0)) {
2543       if (argv[Index + 1] == NULL || argv[Index + 1][0] == '-') {
2544         Error (NULL, 0, 1003, "Invalid option value", "BS Image INF file is missing for -f option");
2545         goto ERROR;
2546       }
2547       //
2548       // Get the input VTF file name
2549       //
2550       VtfFileName = argv[Index+1];
2551       VtfFP = fopen (LongFilePath (VtfFileName), "rb");
2552       if (VtfFP == NULL) {
2553         Error (NULL, 0, 0001, "Error opening file", VtfFileName);
2554         goto ERROR;
2555       }
2556       continue;
2557     }
2558
2559     if ((stricmp (argv[Index], "-r") == 0) || (stricmp (argv[Index], "--baseaddr") == 0)) {
2560       if (FirstRoundB) {
2561         Status      = AsciiStringToUint64 (argv[Index + 1], FALSE, &StartAddress1);
2562         FirstRoundB = FALSE;
2563       } else {
2564         Status = AsciiStringToUint64 (argv[Index + 1], FALSE, &StartAddress2);
2565       }
2566       if (Status != EFI_SUCCESS) {
2567         Error (NULL, 0, 2000, "Invalid option value", "%s is Bad FV start address.", argv[Index + 1]);
2568         goto ERROR;
2569       }
2570       continue;
2571     }
2572
2573     if ((stricmp (argv[Index], "-s") == 0) || (stricmp (argv[Index], "--size") == 0)) {
2574       if (FirstRoundS) {
2575         Status      = AsciiStringToUint64 (argv[Index + 1], FALSE, &FwVolSize1);
2576         FirstRoundS = FALSE;
2577       } else {
2578         Status = AsciiStringToUint64 (argv[Index + 1], FALSE, &FwVolSize2);
2579           SecondVTF = TRUE;
2580       }
2581
2582       if (Status != EFI_SUCCESS) {
2583         Error (NULL, 0, 2000, "Invalid option value", "%s is Bad FV size.", argv[Index + 1]);
2584         goto ERROR;
2585       }
2586       continue;
2587     }
2588
2589     if ((stricmp (argv[Index], "-v") == 0) || (stricmp (argv[Index], "--verbose") == 0)) {
2590             VerboseMode = TRUE;
2591             Index--;
2592       continue;
2593     }
2594
2595     if ((stricmp (argv[Index], "-q") == 0) || (stricmp (argv[Index], "--quiet") == 0)) {
2596       QuietMode = TRUE;
2597       Index--;
2598       continue;
2599     }
2600
2601     if ((stricmp (argv[Index], "-d") == 0) || (stricmp (argv[Index], "--debug") == 0)) {
2602       //
2603       // debug level specified
2604       //
2605       Status = AsciiStringToUint64(argv[Index + 1], FALSE, &DebugLevel);
2606       if (EFI_ERROR (Status)) {
2607         Error (NULL, 0, 1003, "Invalid option value", "%s = %s", argv[Index], argv[Index + 1]);
2608         goto ERROR;
2609       }
2610       if (DebugLevel > 9)  {
2611         Error (NULL, 0, 2000, "Invalid option value", "Unrecognized argument %s.", argv[Index + 1]);
2612         goto ERROR;
2613       }
2614       if((DebugLevel <= 9) &&(DebugLevel >= 5)) {
2615         DebugMode = TRUE;
2616       } else {
2617         DebugMode = FALSE;
2618       }
2619       continue;
2620     }
2621
2622     Error (NULL, 0, 2000, "Invalid parameter", "Unrecognized argument %s.", argv[Index]);
2623     goto ERROR;
2624   }
2625
2626   if (VtfFP == NULL) {
2627     Error (NULL, 0, 2000, "Invalid parameter", "No BS Image INF file is specified");
2628     goto ERROR;
2629   }
2630
2631   if (FirstRoundB) {
2632     Error (NULL, 0, 2000, "Invalid parameter", "No FV base address is specified");
2633     goto ERROR;
2634   }
2635
2636   if (FirstRoundS) {
2637     Error (NULL, 0, 2000, "Invalid parameter", "No FV Size is specified");
2638     goto ERROR;
2639   }
2640   //
2641   // All Parameters has been parsed, now set the message print level
2642   //
2643   if (QuietMode) {
2644     SetPrintLevel(40);
2645   } else if (VerboseMode) {
2646     SetPrintLevel(15);
2647   } else if (DebugMode) {
2648     SetPrintLevel(DebugLevel);
2649   }
2650
2651   if (VerboseMode) {
2652     VerboseMsg("%s tool start.\n", UTILITY_NAME);
2653   }
2654
2655   if (VTF_OUTPUT == FALSE) {
2656     if (SecondVTF == TRUE) {
2657       OutFileName1 = VTF_OUTPUT_FILE1;
2658       OutFileName2 = VTF_OUTPUT_FILE2;
2659           } else {
2660       OutFileName1 = VTF_OUTPUT_FILE1;
2661     }
2662     SymFileName = VTF_SYM_FILE;
2663   } else {
2664     assert (OutFileName1);
2665     INTN OutFileNameLen = strlen(OutFileName1);
2666     INTN NewIndex;
2667
2668     for (NewIndex = OutFileNameLen; NewIndex > 0; --NewIndex) {
2669       if (OutFileName1[NewIndex] == '/' || OutFileName1[NewIndex] == '\\') {
2670         break;
2671       }
2672     }
2673     if (NewIndex == 0) {
2674       SymFileName = VTF_SYM_FILE;
2675     } else {
2676       INTN SymFileNameLen = NewIndex + 1 + strlen(VTF_SYM_FILE);
2677       SymFileName = malloc(SymFileNameLen + 1);
2678       if (SymFileName == NULL) {
2679         Error (NULL, 0, 4001, "Resource", "memory cannot be allocated!");
2680         goto ERROR;
2681       }
2682       memcpy(SymFileName, OutFileName1, NewIndex + 1);
2683       memcpy(SymFileName + NewIndex + 1, VTF_SYM_FILE, strlen(VTF_SYM_FILE));
2684       SymFileName[SymFileNameLen] = '\0';
2685     }
2686     if (DebugMode) {
2687       DebugMsg(UTILITY_NAME, 0, DebugLevel, SymFileName, NULL);
2688     }
2689   }
2690
2691   //
2692   // Call the GenVtfImage
2693   //
2694   if (DebugMode) {
2695     DebugMsg(UTILITY_NAME, 0, DebugLevel, "Start to generate the VTF image\n", NULL);
2696   }
2697   Status = GenerateVtfImage (StartAddress1, FwVolSize1, StartAddress2, FwVolSize2, VtfFP);
2698
2699   if (EFI_ERROR (Status)) {
2700     switch (Status) {
2701
2702     case EFI_INVALID_PARAMETER:
2703       Error (NULL, 0, 2000, "Invalid parameter", "Invalid parameter passed to GenVtf function.");
2704       break;
2705
2706     case EFI_ABORTED:
2707       Error (NULL, 0, 3000, "Invalid", "Error detected while creating the file image.");
2708       break;
2709
2710     case EFI_OUT_OF_RESOURCES:
2711       Error (NULL, 0, 4002, "Resource", "GenVtfImage function could not allocate required resources.");
2712       break;
2713
2714     case EFI_VOLUME_CORRUPTED:
2715       Error (NULL, 0, 3000, "Invalid", "No base address was specified.");
2716       break;
2717
2718     default:
2719       Error (NULL, 0, 3000, "Invalid", "GenVtfImage function returned unknown status %x.", (int) Status );
2720       break;
2721     }
2722   }
2723 ERROR:
2724   if (VtfFP != NULL) {
2725     fclose (VtfFP);
2726   }
2727
2728   if (DebugMode) {
2729     DebugMsg(UTILITY_NAME, 0, DebugLevel, "VTF image generated successful\n", NULL);
2730   }
2731
2732   if (VerboseMode) {
2733     VerboseMsg("%s tool done with return code is 0x%x.\n", UTILITY_NAME, GetUtilityStatus ());
2734   }
2735   return GetUtilityStatus();
2736 }