EdkModulePkg/Universal/UserInterface/SetupBrowser/Dxe/Setup.c

   1 /*++
   2 Copyright (c) 2006, Intel Corporation
   3 All rights reserved. This program and the accompanying materials
   4 are licensed and made available under the terms and conditions of the BSD License
   5 which accompanies this distribution.  The full text of the license may be found at
   6 http://opensource.org/licenses/bsd-license.php
   7
   8 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
   9 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  10
  11 Module Name:
  12         Setup.c
  13
  14 Abstract:
  15
  16   Entry and initialization module for the browser
  17
  18 Revision History:
  19 --*/
  20
  21 #include "Setup.h"
  22 #include "Ui.h"
  23
  24 FUNCTIION_KEY_SETTING gFunctionKeySettingTable[] = {
  25   //
  26   // Boot Manager
  27   //
  28   {
  29     {
  30       0x847bc3fe,
  31       0xb974,
  32       0x446d,
  33       {
  34         0x94,
  35         0x49,
  36         0x5a,
  37         0xd5,
  38         0x41,
  39         0x2e,
  40         0x99,
  41         0x3b
  42       }
  43     },
  44     NONE_FUNCTION_KEY_SETTING
  45   },
  46   //
  47   // Device Manager
  48   //
  49   {
  50     {
  51       0x3ebfa8e6,
  52       0x511d,
  53       0x4b5b,
  54       {
  55         0xa9,
  56         0x5f,
  57         0xfb,
  58         0x38,
  59         0x26,
  60         0xf,
  61         0x1c,
  62         0x27
  63       }
  64     },
  65     NONE_FUNCTION_KEY_SETTING
  66   },
  67   //
  68   // BMM Formset.
  69   //
  70   {
  71     {
  72       0x642237c7,
  73       0x35d4,
  74       0x472d,
  75       {
  76         0x83,
  77         0x65,
  78         0x12,
  79         0xe0,
  80         0xcc,
  81         0xf2,
  82         0x7a,
  83         0x22
  84       }
  85     },
  86     NONE_FUNCTION_KEY_SETTING
  87   },
  88   //
  89   // BMM File Explorer Formset.
  90   //
  91   {
  92     {
  93       0x1f2d63e1,
  94       0xfebd,
  95       0x4dc7,
  96       {
  97         0x9c,
  98         0xc5,
  99         0xba,
 100         0x2b,
 101         0x1c,
 102         0xef,
 103         0x9c,
 104         0x5b
 105       }
 106     },
 107     NONE_FUNCTION_KEY_SETTING
 108   },
 109 };
 110
 111 EFI_STATUS
 112 InitializeBinaryStructures (
 113   IN  EFI_HII_HANDLE                           *Handle,
 114   IN  BOOLEAN                                  UseDatabase,
 115   IN  EFI_IFR_PACKET                           *Packet,
 116   IN  UINT8                                    *NvMapOverride,
 117   IN  UINTN                                    NumberOfIfrImages,
 118   EFI_FILE_FORM_TAGS                           **FileFormTagsHead
 119   );
 120
 121 EFI_STATUS
 122 InitializeTagStructures (
 123   IN  EFI_IFR_BINARY                            *BinaryData,
 124   OUT EFI_FILE_FORM_TAGS                        *FileFormTags
 125   );
 126
 127 UI_MENU_OPTION        *
 128 DisplayHomePage (
 129   IN UINTN                                    NumberOfIfrImages,
 130   IN EFI_FILE_FORM_TAGS                       *FileFormTagsHead,
 131   IN UINT8                                    *CallbackData
 132   );
 133
 134 EFI_STATUS
 135 GetIfrBinaryData (
 136   IN EFI_HII_PROTOCOL *Hii,
 137   IN EFI_HII_HANDLE   HiiHandle,
 138   IN EFI_IFR_PACKET   *Packet,
 139   IN EFI_IFR_BINARY   *BinaryData
 140   );
 141
 142 EFI_STATUS
 143 InstallPrint (
 144   VOID
 145   );
 146
 147 STATIC
 148 EFI_STATUS
 149 EFIAPI
 150 SendForm (
 151   IN EFI_FORM_BROWSER_PROTOCOL        * This,
 152   IN BOOLEAN                          UseDatabase,
 153   IN EFI_HII_HANDLE                   * Handle,
 154   IN UINTN                            HandleCount,
 155   IN EFI_IFR_PACKET                   * Packet,
 156   IN EFI_HANDLE                       CallbackHandle,
 157   IN UINT8                            *NvMapOverride,
 158   IN EFI_SCREEN_DESCRIPTOR            *ScreenDimensions, OPTIONAL
 159   OUT BOOLEAN                         *ResetRequired OPTIONAL
 160   )
 161 /*++
 162
 163 Routine Description:
 164
 165   This is the routine which an external caller uses to direct the browser
 166   where to obtain it's information.
 167
 168 Arguments:
 169
 170   UseDatabase -     If set to TRUE, then all information is retrieved from the HII database handle specified
 171                     If set to FALSE, then the passed in Packet and CallbackHandle is used and Handle is ignored
 172
 173   Handle -          A pointer to an array of Handles.  If HandleCount > 1 we display a list of the formsets for the handles specified
 174
 175   HandleCount -     The number of Handles specified in Handle.
 176
 177   Packet -          Valid only if UseDatabase is FALSE.  Packet defines the pages being passed into
 178                     the browser.  This is composed of IFR data as well as String information.
 179
 180   CallbackHandle -  The handle which contains the calling driver's EFI_FORM_CALLBACK_PROTOCOL interface.
 181
 182   ScreenDimenions - This allows the browser to be called so that it occupies a portion of the physical screen instead of
 183                     dynamically determining the screen dimensions.
 184
 185   NvMapOverride -   This buffer is used only when there is no NV variable to define the current settings and the caller
 186                     needs to provide to the browser the current settings for the "fake" NV variable.  If used, no saving
 187                     of an NV variable will be possible.  This parameter is also ignored if HandleCount > 1.
 188
 189 Returns:
 190
 191 --*/
 192 {
 193   EFI_FORM_CALLBACK_PROTOCOL  *FormCallback;
 194   EFI_FILE_FORM_TAGS          *FileFormTagsHead;
 195   UI_MENU_OPTION              *Selection;
 196   UI_MENU_OPTION              *AltSelection;
 197   EFI_STATUS                  Status;
 198   BOOLEAN                     Callback;
 199   VOID                        *CallbackData;
 200   EFI_HII_HANDLE              BackupHandle;
 201
 202   ZeroMem (&gScreenDimensions, sizeof (EFI_SCREEN_DESCRIPTOR));
 203
 204   gPreviousValue  = AllocatePool (0x1000);
 205   CallbackData    = AllocatePool (0x10000);
 206   ASSERT (gPreviousValue != NULL);
 207   ASSERT (CallbackData != NULL);
 208
 209   do {
 210     //
 211     // Seed the dimensions in the global
 212     //
 213     gST->ConOut->QueryMode (
 214                   gST->ConOut,
 215                   gST->ConOut->Mode->Mode,
 216                   &gScreenDimensions.RightColumn,
 217                   &gScreenDimensions.BottomRow
 218                   );
 219
 220     if (ScreenDimensions != NULL) {
 221       //
 222       // Check local dimension vs. global dimension.
 223       //
 224       if ((gScreenDimensions.RightColumn < ScreenDimensions->RightColumn) ||
 225           (gScreenDimensions.BottomRow < ScreenDimensions->BottomRow)
 226           ) {
 227         return EFI_INVALID_PARAMETER;
 228       } else {
 229         //
 230         // Local dimension validation.
 231         //
 232         if ((ScreenDimensions->RightColumn > ScreenDimensions->LeftColumn) &&
 233             (ScreenDimensions->BottomRow > ScreenDimensions->TopRow) &&
 234             ((ScreenDimensions->RightColumn - ScreenDimensions->LeftColumn) > 2) &&
 235             (
 236               (ScreenDimensions->BottomRow - ScreenDimensions->TopRow) > STATUS_BAR_HEIGHT +
 237             SCROLL_ARROW_HEIGHT *
 238             2 +
 239             FRONT_PAGE_HEADER_HEIGHT +
 240             FOOTER_HEIGHT +
 241             1
 242           )
 243             ) {
 244           CopyMem (&gScreenDimensions, ScreenDimensions, sizeof (EFI_SCREEN_DESCRIPTOR));
 245         } else {
 246           return EFI_INVALID_PARAMETER;
 247         }
 248       }
 249     }
 250
 251     gOptionBlockWidth = (CHAR16) ((gScreenDimensions.RightColumn - gScreenDimensions.LeftColumn) / 3);
 252     gHelpBlockWidth   = gOptionBlockWidth;
 253     gPromptBlockWidth = gOptionBlockWidth;
 254
 255     //
 256     // Initialize the strings for the browser, upon exit of the browser, the strings will be freed
 257     //
 258     InitializeBrowserStrings ();
 259
 260     gFunctionKeySetting = DEFAULT_FUNCTION_KEY_SETTING;
 261     gClassOfVfr         = EFI_SETUP_APPLICATION_SUBCLASS;
 262     gResetRequired      = FALSE;
 263     gExitRequired       = FALSE;
 264     gSaveRequired       = FALSE;
 265     gNvUpdateRequired   = FALSE;
 266     gActiveIfr          = 0;
 267     gConsistencyId      = 0;
 268     gPriorMenuEntry     = 0;
 269     BackupHandle        = *Handle;
 270     gMenuRefreshHead    = NULL;
 271     ASSERT (CallbackData);
 272     ZeroMem (CallbackData, 0x10000);
 273
 274     //
 275     // We can recurse through this and might need to re-allocate this particular buffer
 276     //
 277     if (gPreviousValue == NULL) {
 278       gPreviousValue = AllocatePool (0x1000);
 279       ASSERT (gPreviousValue != NULL);
 280     }
 281
 282     Callback      = FALSE;
 283     FormCallback  = NULL;
 284
 285     if (CallbackHandle != NULL) {
 286       //
 287       // Retrieve the Callback protocol interface
 288       //
 289       Status = gBS->HandleProtocol (
 290                       CallbackHandle,
 291                       &gEfiFormCallbackProtocolGuid,
 292                       (VOID **) &FormCallback
 293                       );
 294
 295       if (EFI_ERROR (Status)) {
 296         gBS->FreePool (CallbackData);
 297         return Status;;
 298       }
 299
 300       Callback = TRUE;
 301     }
 302     //
 303     // Initializes all the internal state structures for all IFR images in system
 304     //
 305     Status = InitializeBinaryStructures (Handle, UseDatabase, Packet, NvMapOverride, HandleCount, &FileFormTagsHead);
 306
 307     if (EFI_ERROR (Status)) {
 308       gBS->FreePool (CallbackData);
 309       return Status;
 310     }
 311     //
 312     // Beginning of the Presentation of the Data
 313     //
 314     if (UseDatabase && (HandleCount > 1)) {
 315       Selection = DisplayHomePage (HandleCount, FileFormTagsHead, CallbackData);
 316     } else {
 317       //
 318       // If passing something specific, we know there is only one Ifr
 319       //
 320       Selection = AllocateZeroPool (sizeof (UI_MENU_OPTION));
 321       ASSERT (Selection != NULL);
 322       Selection->IfrNumber  = 0;
 323       Selection->Handle     = Handle[0];
 324       UiInitMenu ();
 325     }
 326
 327     UiInitMenuList ();
 328
 329     if (UseDatabase && (HandleCount > 1)) {
 330       if (Selection == NULL) {
 331         gBS->FreePool (CallbackData);
 332         return EFI_SUCCESS;
 333       }
 334     }
 335     //
 336     // Launch the setup browser with the user's selection information
 337     //
 338     AltSelection = SetupBrowser (Selection, Callback, FileFormTagsHead, CallbackData);
 339
 340     //
 341     // If the caller cares about Reset status, we can return to the caller if something happened that required a reset
 342     //
 343     if (ResetRequired != NULL) {
 344       *ResetRequired = gResetRequired;
 345     }
 346
 347     if (Callback && (AltSelection != NULL)) {
 348       if ((FormCallback != NULL) && (FormCallback->Callback != NULL)) {
 349         Status = FormCallback->Callback (
 350                                 FormCallback,
 351                                 AltSelection->ThisTag->Key,
 352                                 CallbackData,
 353                                 (EFI_HII_CALLBACK_PACKET **) &Packet
 354                                 );
 355       }
 356     }
 357
 358     *Handle = BackupHandle;
 359
 360     if (EFI_ERROR (Status)) {
 361       gBS->FreePool (CallbackData);
 362       return Status;
 363     }
 364
 365     if (Callback && (AltSelection == NULL)) {
 366       gBS->FreePool (CallbackData);
 367       return Status;
 368     }
 369
 370     if (UseDatabase && (HandleCount > 1)) {
 371     } else {
 372
 373       if (gBinaryDataHead->UnRegisterOnExit) {
 374         Hii->RemovePack (Hii, Handle[0]);
 375       }
 376
 377       if (Callback &&
 378         ((AltSelection->ThisTag->SubClass == EFI_FRONT_PAGE_SUBCLASS) ||
 379         (AltSelection->ThisTag->SubClass == EFI_SINGLE_USE_SUBCLASS))) {
 380         //
 381         // If this is the FrontPage, return after every selection
 382         //
 383         gBS->FreePool (Selection);
 384         UiFreeMenu ();
 385
 386         //
 387         // Clean up the allocated data buffers
 388         //
 389         FreeData (FileFormTagsHead, NULL, NULL);
 390
 391         gST->ConOut->SetAttribute (gST->ConOut, EFI_TEXT_ATTR (EFI_LIGHTGRAY, EFI_BLACK));
 392         gST->ConOut->ClearScreen (gST->ConOut);
 393
 394         gBS->FreePool (CallbackData);
 395         return EFI_SUCCESS;
 396       }
 397
 398       gBS->FreePool (Selection);
 399       UiFreeMenu ();
 400
 401       //
 402       // Clean up the allocated data buffers
 403       //
 404       FreeData (FileFormTagsHead, NULL, NULL);
 405
 406       gST->ConOut->ClearScreen (gST->ConOut);
 407
 408       if (!Callback) {
 409         gBS->FreePool (CallbackData);
 410         return EFI_SUCCESS;
 411       }
 412     }
 413
 414   } while (!EFI_ERROR (Status));
 415
 416   gBS->FreePool (CallbackData);
 417   return Status;
 418 }
 419
 420 EFI_STATUS
 421 EFIAPI
 422 InitializeSetup (
 423   IN EFI_HANDLE           ImageHandle,
 424   IN EFI_SYSTEM_TABLE     *SystemTable
 425   )
 426 /*++
 427
 428 Routine Description:
 429   Initialize Setup
 430
 431 Arguments:
 432   (Standard EFI Image entry - EFI_IMAGE_ENTRY_POINT)
 433
 434 Returns:
 435   EFI_SUCCESS - Setup loaded.
 436   other       - Setup Error
 437
 438 --*/
 439 {
 440   EFI_STATUS                  Status;
 441   EFI_FORM_CONFIGURATION_DATA *FormData;
 442   EFI_FORM_BROWSER_PROTOCOL   *FormBrowser;
 443   EFI_HANDLE                  Handle;
 444   EFI_HII_PACKAGES            *PackageList;
 445
 446   //
 447   // There will be only one FormConfig in the system
 448   // If there is another out there, someone is trying to install us
 449   // again.  Fail that scenario.
 450   //
 451   Status = gBS->LocateProtocol (
 452                   &gEfiFormBrowserProtocolGuid,
 453                   NULL,
 454                   (VOID **) &FormBrowser
 455                   );
 456
 457   gFirstIn = TRUE;
 458
 459   //
 460   // If there was no error, assume there is an installation and fail to load
 461   //
 462   if (!EFI_ERROR (Status)) {
 463     return EFI_DEVICE_ERROR;
 464   }
 465
 466   FormData = AllocatePool (sizeof (EFI_FORM_CONFIGURATION_DATA));
 467
 468   if (FormData == NULL) {
 469     return EFI_OUT_OF_RESOURCES;
 470   }
 471   //
 472   // Fill in HII data
 473   //
 474   FormData->Signature               = EFI_FORM_DATA_SIGNATURE;
 475   FormData->FormConfig.SendForm     = SendForm;
 476   FormData->FormConfig.CreatePopUp  = CreateDialog;
 477
 478   //
 479   // There should only be one HII image
 480   //
 481   Status = gBS->LocateProtocol (
 482                   &gEfiHiiProtocolGuid,
 483                   NULL,
 484                   (VOID **) &FormData->Hii
 485                   );
 486
 487   ASSERT_EFI_ERROR (Status);
 488
 489   Hii         = FormData->Hii;
 490
 491   PackageList = PreparePackages (1, &gEfiFormBrowserProtocolGuid, SetupBrowserStrings);
 492
 493   Status      = Hii->NewPack (Hii, PackageList, &gHiiHandle);
 494
 495   gBS->FreePool (PackageList);
 496
 497   //
 498   // Install protocol interface
 499   //
 500   Handle = NULL;
 501   Status = gBS->InstallProtocolInterface (
 502                   &Handle,
 503                   &gEfiFormBrowserProtocolGuid,
 504                   EFI_NATIVE_INTERFACE,
 505                   &FormData->FormConfig
 506                   );
 507
 508   ASSERT_EFI_ERROR (Status);
 509
 510   BannerData = AllocateZeroPool (sizeof (BANNER_DATA));
 511   ASSERT (BannerData != NULL);
 512
 513   Status = InstallPrint ();
 514   return Status;
 515 }
 516
 517 VOID
 518 GetQuestionHeader (
 519   IN  EFI_TAG             *Tag,
 520   IN  UINT8               *RawFormSet,
 521   IN  UINT16              Index,
 522   IN  EFI_FILE_FORM_TAGS  *FileFormTags,
 523   IN  UINT16              CurrentVariable
 524   )
 525 /*++
 526
 527 Routine Description:
 528   Initialize question tag's members.
 529
 530 Arguments:
 531   Tag              - Pointer of the current EFI_TAG structure.
 532   RawFormSet       - Pointer of the formset raw data.
 533   Index            - Offset of the current opcode in the Ifr raw data.
 534   FileFormTags     - Pointer of current EFI_FILE_FORM_TAGS structure.
 535   CurrentVariable  - Current variable number.
 536
 537 Returns:
 538   None.
 539 --*/
 540 {
 541   EFI_VARIABLE_DEFINITION *VariableDefinition;
 542
 543   Tag->NumberOfLines  = 1;
 544   Tag->VariableNumber = CurrentVariable;
 545   CopyMem (&Tag->Id, &((EFI_IFR_ONE_OF *) &RawFormSet[Index])->QuestionId, sizeof (UINT16));
 546   CopyMem (&Tag->StorageStart, &((EFI_IFR_ONE_OF *) &RawFormSet[Index])->QuestionId, sizeof (UINT16));
 547   CopyMem (&Tag->StorageWidth, &((EFI_IFR_ONE_OF *) &RawFormSet[Index])->Width, sizeof (UINT8));
 548   CopyMem (&Tag->Text, &((EFI_IFR_ONE_OF *) &RawFormSet[Index])->Prompt, sizeof (UINT16));
 549   CopyMem (&Tag->Help, &((EFI_IFR_ONE_OF *) &RawFormSet[Index])->Help, sizeof (UINT16));
 550
 551   VariableDefinition = FileFormTags->VariableDefinitions;
 552
 553   for (; VariableDefinition != NULL; VariableDefinition = VariableDefinition->Next) {
 554     //
 555     // Have we found the correct variable for the request?
 556     //
 557     if (CurrentVariable == VariableDefinition->VariableId) {
 558       if (VariableDefinition->VariableSize < (UINTN) (Tag->StorageStart + Tag->StorageWidth)) {
 559         VariableDefinition->VariableFakeSize = (UINT16) (VariableDefinition->VariableFakeSize + Tag->StorageWidth);
 560       }
 561
 562       if (VariableDefinition->NvRamMap != NULL) {
 563         //
 564         // If it is an 8bit or 16bit width, then move it to Tag->Value, otherwise
 565         // we will never be looking for the data in Tag->Value (e.g. strings, password, etc)
 566         //
 567         if (Tag->StorageWidth == (UINT16) 1) {
 568           CopyMem (&Tag->Value, &VariableDefinition->NvRamMap[Tag->StorageStart], sizeof (UINT16));
 569         }
 570
 571         if (Tag->StorageWidth == (UINT16) 2) {
 572           Index = (UINT16)
 573             (
 574               VariableDefinition->NvRamMap[Tag->StorageStart] +
 575               (VariableDefinition->NvRamMap[Tag->StorageStart + 1] * 0x100)
 576             );
 577           CopyMem (&Tag->Value, &Index, sizeof (UINT16));
 578         }
 579       } else {
 580         Index = 0;
 581         CopyMem (&Tag->Value, &Index, sizeof (UINT16));
 582       }
 583       break;
 584     } else {
 585       continue;
 586     }
 587   }
 588 }
 589
 590 VOID
 591 GetNumericHeader (
 592   IN  EFI_TAG             *Tag,
 593   IN  UINT8               *RawFormSet,
 594   IN  UINT16              Index,
 595   IN  UINT16              NumberOfLines,
 596   IN  EFI_FILE_FORM_TAGS  *FileFormTags,
 597   IN  UINT16              CurrentVariable
 598   )
 599 /*++
 600
 601 Routine Description:
 602   Initialize numeric tag's members.
 603
 604 Arguments:
 605   Tag              - Pointer of the current EFI_TAG structure.
 606   RawFormSet       - Pointer of the formset raw data.
 607   Index            - Offset of the current opcode in the Ifr raw data.
 608   NumberOfLines    - Number of lines this opcode occupied.
 609   FileFormTags     - Pointer of current EFI_FILE_FORM_TAGS structure.
 610   CurrentVariable  - Current variable number.
 611
 612 Returns:
 613   None.
 614 --*/
 615 {
 616   EFI_VARIABLE_DEFINITION *VariableDefinition;
 617
 618   Tag->NumberOfLines  = NumberOfLines;
 619   Tag->VariableNumber = CurrentVariable;
 620   CopyMem (&Tag->Id, &((EFI_IFR_ONE_OF *) &RawFormSet[Index])->QuestionId, sizeof (UINT16));
 621   CopyMem (&Tag->StorageStart, &((EFI_IFR_ONE_OF *) &RawFormSet[Index])->QuestionId, sizeof (UINT16));
 622   CopyMem (&Tag->StorageWidth, &((EFI_IFR_ONE_OF *) &RawFormSet[Index])->Width, sizeof (UINT8));
 623   CopyMem (&Tag->Text, &((EFI_IFR_ONE_OF *) &RawFormSet[Index])->Prompt, sizeof (UINT16));
 624   CopyMem (&Tag->Help, &((EFI_IFR_ONE_OF *) &RawFormSet[Index])->Help, sizeof (UINT16));
 625   CopyMem (&Tag->Minimum, &((EFI_IFR_NUMERIC *) &RawFormSet[Index])->Minimum, sizeof (UINT16));
 626   CopyMem (&Tag->Maximum, &((EFI_IFR_NUMERIC *) &RawFormSet[Index])->Maximum, sizeof (UINT16));
 627   CopyMem (&Tag->Step, &((EFI_IFR_NUMERIC *) &RawFormSet[Index])->Step, sizeof (UINT16));
 628   CopyMem (&Tag->Default, &((EFI_IFR_NUMERIC *) &RawFormSet[Index])->Default, sizeof (UINT16));
 629   Tag->ResetRequired  = (BOOLEAN) (((EFI_IFR_NUMERIC *) &RawFormSet[Index])->Flags & EFI_IFR_FLAG_RESET_REQUIRED);
 630
 631   VariableDefinition  = FileFormTags->VariableDefinitions;
 632
 633   for (; VariableDefinition != NULL; VariableDefinition = VariableDefinition->Next) {
 634     //
 635     // Have we found the correct variable for the request?
 636     //
 637     if (CurrentVariable == VariableDefinition->VariableId) {
 638       if (VariableDefinition->VariableSize <= (UINTN) (Tag->StorageStart + Tag->StorageWidth)) {
 639         if (Tag->StorageWidth == 0) {
 640           VariableDefinition->VariableFakeSize = (UINT16) (VariableDefinition->VariableFakeSize + 2);
 641         } else {
 642           VariableDefinition->VariableFakeSize = (UINT16) (VariableDefinition->VariableFakeSize + Tag->StorageWidth);
 643         }
 644       }
 645
 646       if (VariableDefinition->NvRamMap != NULL) {
 647         //
 648         // If it is an 8bit or 16bit width, then move it to Tag->Value, otherwise
 649         // we will never be looking for the data in Tag->Value (e.g. strings, password, etc)
 650         //
 651         if (Tag->StorageWidth == (UINT16) 1) {
 652           CopyMem (&Tag->Value, &VariableDefinition->NvRamMap[Tag->StorageStart], sizeof (UINT16));
 653         }
 654
 655         if (Tag->StorageWidth == (UINT16) 2) {
 656           Index = (UINT16)
 657             (
 658               VariableDefinition->NvRamMap[Tag->StorageStart] +
 659                 (VariableDefinition->NvRamMap[Tag->StorageStart + 1] * 0x100)
 660             );
 661           CopyMem (&Tag->Value, &Index, sizeof (UINT16));
 662         }
 663       } else {
 664         CopyMem (&Tag->Value, &Tag->Default, sizeof (UINT16));
 665       }
 666       break;
 667     } else {
 668       continue;
 669     }
 670   }
 671 }
 672
 673 VOID
 674 GetTagCount (
 675   IN      UINT8                                 *RawFormSet,
 676   IN OUT  UINT16                                *NumberOfTags
 677   )
 678 {
 679   UINT16  Index;
 680
 681   //
 682   // Assume on entry we are pointing to an OpCode - reasonably this should
 683   // be a FormOp since the purpose is to count the tags in a particular Form.
 684   //
 685   for (Index = 0; RawFormSet[Index] != EFI_IFR_END_FORM_OP;) {
 686     //
 687     // If we encounter the end of a form set, bail out
 688     //
 689     if (RawFormSet[Index] == EFI_IFR_END_FORM_SET_OP) {
 690       break;
 691     }
 692     //
 693     // We treat date/time internally as three op-codes
 694     //
 695     if (RawFormSet[Index] == EFI_IFR_DATE_OP || RawFormSet[Index] == EFI_IFR_TIME_OP) {
 696       *NumberOfTags = (UINT16) (*NumberOfTags + 3);
 697     } else {
 698       //
 699       // Assume that we could have no more tags than op-codes
 700       //
 701       (*NumberOfTags)++;
 702     }
 703
 704     Index = (UINT16) (Index + RawFormSet[Index + 1]);
 705   }
 706   //
 707   // Increase the tag count by one so it is inclusive of the end_form_op
 708   //
 709   (*NumberOfTags)++;
 710 }
 711
 712 STATIC
 713 VOID
 714 AddNextInconsistentTag (
 715   IN OUT  EFI_INCONSISTENCY_DATA  **InconsistentTagsPtr
 716   )
 717 /*++
 718
 719 Routine Description:
 720   Initialize the next inconsistent tag data and add it to the inconsistent tag list.
 721
 722 Arguments:
 723  InconsistentTagsPtr   - Pointer of the inconsistent tag's pointer.
 724
 725 Returns:
 726   None.
 727
 728 --*/
 729 {
 730   EFI_INCONSISTENCY_DATA  *PreviousInconsistentTags;
 731   EFI_INCONSISTENCY_DATA  *InconsistentTags;
 732
 733   InconsistentTags = *InconsistentTagsPtr;
 734   //
 735   // We just hit the end of an inconsistent expression.  Let's allocate the ->Next structure
 736   //
 737   InconsistentTags->Next = AllocatePool (sizeof (EFI_INCONSISTENCY_DATA));
 738   ASSERT (InconsistentTags->Next != NULL);
 739
 740   //
 741   // Preserve current Tag entry
 742   //
 743   PreviousInconsistentTags  = InconsistentTags;
 744
 745   InconsistentTags          = InconsistentTags->Next;
 746
 747   //
 748   // This will zero on the entry including the ->Next so I don't have to do it
 749   //
 750   ZeroMem (InconsistentTags, sizeof (EFI_INCONSISTENCY_DATA));
 751
 752   //
 753   // Point our Previous field to the previous entry
 754   //
 755   InconsistentTags->Previous  = PreviousInconsistentTags;
 756
 757   *InconsistentTagsPtr        = InconsistentTags;
 758
 759   return ;
 760 }
 761
 762 EFI_STATUS
 763 InitializeTagStructures (
 764   IN  EFI_IFR_BINARY                            *BinaryData,
 765   OUT EFI_FILE_FORM_TAGS                        *FileFormTags
 766   )
 767 {
 768   EFI_STATUS              Status;
 769   UINT8                   *RawFormSet;
 770   UINT16                  Index;
 771   UINT16                  QuestionIndex;
 772   UINT16                  NumberOfTags;
 773   INT16                   CurrTag;
 774   UINT8                   TagLength;
 775   EFI_FORM_TAGS           *FormTags;
 776   EFI_FORM_TAGS           *SavedFormTags;
 777   EFI_INCONSISTENCY_DATA  *InconsistentTags;
 778   EFI_VARIABLE_DEFINITION *VariableDefinitions;
 779   UINTN                   Count;
 780   UINT16                  Class;
 781   UINT16                  SubClass;
 782   UINT16                  TempValue;
 783   UINT16                  CurrentVariable;
 784   UINT16                  CurrentVariable2;
 785
 786   //
 787   // Initialize some Index variable and Status
 788   //
 789   Count             = 0;
 790   Class             = 0;
 791   SubClass          = 0;
 792   CurrentVariable   = 0;
 793   CurrentVariable2  = 0;
 794   QuestionIndex     = 0;
 795   NumberOfTags      = 1;
 796   Status            = EFI_SUCCESS;
 797   FormTags          = &FileFormTags->FormTags;
 798   FormTags->Next    = NULL;
 799   if (FileFormTags->InconsistentTags == NULL) {
 800     InconsistentTags = NULL;
 801   } else {
 802     InconsistentTags = FileFormTags->InconsistentTags;
 803   }
 804
 805   if (FileFormTags->VariableDefinitions == NULL) {
 806     VariableDefinitions = NULL;
 807   } else {
 808     VariableDefinitions = FileFormTags->VariableDefinitions;
 809   }
 810   //
 811   // RawFormSet now points to the beginning of the forms portion of
 812   // the specific IFR Binary.
 813   //
 814   RawFormSet = (UINT8 *) BinaryData->FormBinary;
 815
 816   //
 817   // Determine the number of tags for the first form
 818   //
 819   GetTagCount (&RawFormSet[0], &NumberOfTags);
 820
 821   SavedFormTags = FormTags;
 822
 823   if (FormTags->Tags != NULL) {
 824     do {
 825       //
 826       // Advance FormTags to the last entry
 827       //
 828       for (; FormTags->Next != NULL; FormTags = FormTags->Next)
 829         ;
 830
 831       //
 832       // Walk through each of the tags and free the IntList allocation
 833       //
 834       for (Index = 0; Index < NumberOfTags; Index++) {
 835         if (FormTags->Tags[Index].IntList != NULL) {
 836           gBS->FreePool (FormTags->Tags[Index].IntList);
 837         }
 838       }
 839
 840       gBS->FreePool (FormTags->Tags);
 841       gBS->FreePool (FormTags->Next);
 842       FormTags->Next  = NULL;
 843       FormTags->Tags  = NULL;
 844
 845       FormTags        = SavedFormTags;
 846
 847     } while (FormTags->Next != NULL);
 848   }
 849
 850   Index = 0;
 851
 852   //
 853   // Test for an allocated buffer.  If already allocated this is due to having called this routine
 854   // once for sizing of the NV storage.  We then loaded the NV variable and can correctly initialize
 855   // the tag structure with current values from the NV
 856   //
 857   if (FormTags->Tags == NULL) {
 858     //
 859     // Allocate memory for our tags on the first form
 860     //
 861     FormTags->Tags = AllocateZeroPool (NumberOfTags * sizeof (EFI_TAG));
 862     ASSERT (FormTags->Tags);
 863   }
 864   //
 865   // Test for an allocated buffer.  If already allocated this is due to having called this routine
 866   // once for sizing of the NV storage.  We then loaded the NV variable and can correctly initialize
 867   // the tag structure with current values from the NV
 868   //
 869   if (InconsistentTags == NULL) {
 870     //
 871     // We just hit the end of an inconsistent expression.  Let's allocate the ->Next structure
 872     //
 873     InconsistentTags = AllocateZeroPool (sizeof (EFI_INCONSISTENCY_DATA));
 874     ASSERT (InconsistentTags != NULL);
 875
 876     FileFormTags->InconsistentTags = InconsistentTags;
 877   }
 878
 879   ZeroMem (FormTags->Tags, NumberOfTags * sizeof (EFI_TAG));
 880
 881   for (CurrTag = 0; RawFormSet[Index] != EFI_IFR_END_FORM_SET_OP; CurrTag++) {
 882     //
 883     // Operand = IFR OpCode
 884     //
 885     FormTags->Tags[CurrTag].Operand = RawFormSet[Index];
 886
 887     //
 888     // Assume for now 0 lines occupied by this OpCode
 889     //
 890     FormTags->Tags[CurrTag].NumberOfLines = 0;
 891
 892     FormTags->Tags[CurrTag].Class         = Class;
 893     FormTags->Tags[CurrTag].SubClass      = SubClass;
 894
 895     //
 896     // Determine the length of the Tag so we can later skip to the next tag in the form
 897     //
 898     TagLength = RawFormSet[Index + 1];
 899     //
 900     // get the length
 901     //
 902     // Operate on the Found OpCode
 903     //
 904     switch (RawFormSet[Index]) {
 905
 906     case EFI_IFR_FORM_OP:
 907       //
 908       // If there was no variable op-code defined, create a dummy entry for one
 909       //
 910       if (FileFormTags->VariableDefinitions == NULL) {
 911         FileFormTags->VariableDefinitions = AllocateZeroPool (sizeof (EFI_VARIABLE_DEFINITION));
 912         ASSERT (FileFormTags->VariableDefinitions != NULL);
 913         IfrToFormTag (
 914           RawFormSet[Index],
 915           &FormTags->Tags[CurrTag],
 916           (VOID *) &RawFormSet[Index],
 917           FileFormTags->VariableDefinitions
 918           );
 919       } else {
 920         IfrToFormTag (RawFormSet[Index], &FormTags->Tags[CurrTag], (VOID *) &RawFormSet[Index], NULL);
 921       }
 922       break;
 923
 924     case EFI_IFR_SUBTITLE_OP:
 925     case EFI_IFR_TEXT_OP:
 926     case EFI_IFR_REF_OP:
 927       IfrToFormTag (RawFormSet[Index], &FormTags->Tags[CurrTag], (VOID *) &RawFormSet[Index], NULL);
 928       break;
 929
 930     case EFI_IFR_VARSTORE_OP:
 931       if (FileFormTags->VariableDefinitions == NULL) {
 932         VariableDefinitions = AllocateZeroPool (sizeof (EFI_VARIABLE_DEFINITION));
 933         ASSERT (VariableDefinitions != NULL);
 934         FileFormTags->VariableDefinitions = VariableDefinitions;
 935       }
 936
 937       IfrToFormTag (
 938         RawFormSet[Index],
 939         &FormTags->Tags[CurrTag],
 940         (VOID *) &RawFormSet[Index],
 941         FileFormTags->VariableDefinitions
 942         );
 943       break;
 944
 945     case EFI_IFR_VARSTORE_SELECT_OP:
 946       IfrToFormTag (RawFormSet[Index], &FormTags->Tags[CurrTag], (VOID *) &RawFormSet[Index], NULL);
 947       CopyMem (&CurrentVariable, &((EFI_IFR_VARSTORE_SELECT *) &RawFormSet[Index])->VarId, sizeof (UINT16));
 948       CurrentVariable2 = CurrentVariable;
 949       break;
 950
 951     case EFI_IFR_VARSTORE_SELECT_PAIR_OP:
 952       IfrToFormTag (RawFormSet[Index], &FormTags->Tags[CurrTag], (VOID *) &RawFormSet[Index], NULL);
 953       CopyMem(&CurrentVariable, &((EFI_IFR_VARSTORE_SELECT_PAIR *)&RawFormSet[Index])->VarId, sizeof (UINT16));
 954       CopyMem (
 955         &CurrentVariable2,
 956         &((EFI_IFR_VARSTORE_SELECT_PAIR *) &RawFormSet[Index])->SecondaryVarId,
 957         sizeof (UINT16)
 958         );
 959       break;
 960
 961     case EFI_IFR_END_FORM_OP:
 962       //
 963       // Test for an allocated buffer.  If already allocated this is due to having called this routine
 964       // once for sizing of the NV storage.  We then loaded the NV variable and can correctly initialize
 965       // the tag structure with current values from the NV
 966       //
 967       if (FormTags->Next == NULL) {
 968         //
 969         // We just hit the end of a form.  Let's allocate the ->Next structure
 970         //
 971         FormTags->Next = AllocatePool (sizeof (EFI_FORM_TAGS));
 972         ASSERT (FormTags->Next);
 973       }
 974
 975       FormTags = FormTags->Next;
 976       ZeroMem (FormTags, sizeof (EFI_FORM_TAGS));
 977
 978       //
 979       // Reset the tag count to one
 980       //
 981       NumberOfTags = 1;
 982
 983       //
 984       // Reset the CurrTag value (it will be incremented, after this case statement
 985       // so set to a negative one so that we get the desired effect.)  Fish can beat me later.
 986       //
 987       CurrTag = -1;
 988
 989       //
 990       // Determine the number of tags after this form.  If this is the last
 991       // form, then we will count the endformset and preserve that information
 992       // in the tag structure.
 993       //
 994       GetTagCount (&RawFormSet[Index + TagLength], &NumberOfTags);
 995
 996       //
 997       // Allocate memory for our tags
 998       //
 999       FormTags->Tags = AllocateZeroPool (NumberOfTags * sizeof (EFI_TAG));
1000       ASSERT (FormTags->Tags);
1001       break;
1002
1003     //
1004     // Two types of tags constitute the One Of question: a one-of header and
1005     // several one-of options.
1006     //
1007     case EFI_IFR_ONE_OF_OP:
1008     case EFI_IFR_ORDERED_LIST_OP:
1009       GetQuestionHeader (&FormTags->Tags[CurrTag], RawFormSet, Index, FileFormTags, CurrentVariable);
1010
1011       //
1012       // Store away the CurrTag since what follows will be the answer that we
1013       // need to place into the appropriate location in the tag array
1014       //
1015       //
1016       // record for setting default later
1017       //
1018       QuestionIndex = (UINT16) CurrTag;
1019       break;
1020
1021     case EFI_IFR_ONE_OF_OPTION_OP:
1022       IfrToFormTag (RawFormSet[Index], &FormTags->Tags[CurrTag], (VOID *) &RawFormSet[Index], NULL);
1023       FormTags->Tags[QuestionIndex].Flags = ((EFI_IFR_ONE_OF_OPTION *) &RawFormSet[Index])->Flags;
1024       CopyMem (
1025         &FormTags->Tags[QuestionIndex].Key,
1026         &((EFI_IFR_ONE_OF_OPTION *) &RawFormSet[Index])->Key,
1027         sizeof (UINT16)
1028         );
1029       FormTags->Tags[QuestionIndex].ResetRequired = (BOOLEAN) (FormTags->Tags[QuestionIndex].Flags & EFI_IFR_FLAG_RESET_REQUIRED);
1030       break;
1031
1032     case EFI_IFR_CHECKBOX_OP:
1033       GetQuestionHeader (&FormTags->Tags[CurrTag], RawFormSet, Index, FileFormTags, CurrentVariable);
1034       IfrToFormTag (RawFormSet[Index], &FormTags->Tags[CurrTag], (VOID *) &RawFormSet[Index], NULL);
1035       break;
1036
1037     case EFI_IFR_NUMERIC_OP:
1038       GetNumericHeader (&FormTags->Tags[CurrTag], RawFormSet, Index, (UINT16) 1, FileFormTags, CurrentVariable);
1039       IfrToFormTag (RawFormSet[Index], &FormTags->Tags[CurrTag], (VOID *) &RawFormSet[Index], NULL);
1040       break;
1041
1042     case EFI_IFR_DATE_OP:
1043       //
1044       // Date elements come in as a Year, Month, Day.  We need to process them as a country-based
1045       // Order.  It is much easier to do it here than anywhere else.
1046       //
1047       // For US standards - we want Month/Day/Year, thus we advance "Index" +1, +2, +0 while CurrTag is +0, +1, +2
1048       //
1049       GetNumericHeader (
1050         &FormTags->Tags[CurrTag],
1051         RawFormSet,
1052         (UINT16) (Index + TagLength),
1053         (UINT16) 0,
1054         FileFormTags,
1055         CurrentVariable
1056         );
1057
1058       //
1059       // The current language selected + the Date operand
1060       //
1061       FormTags->Tags[CurrTag + 1].Operand = RawFormSet[Index];
1062       GetNumericHeader (
1063         &FormTags->Tags[CurrTag + 1],
1064         RawFormSet,
1065         (UINT16) (Index + TagLength + RawFormSet[Index + TagLength + 1]),
1066         (UINT16) 0,
1067         FileFormTags,
1068         CurrentVariable
1069         );
1070
1071       //
1072       // The current language selected + the Date operand
1073       //
1074       FormTags->Tags[CurrTag + 2].Operand = RawFormSet[Index];
1075       GetNumericHeader (&FormTags->Tags[CurrTag + 2], RawFormSet, Index, (UINT16) 1, FileFormTags, CurrentVariable);
1076
1077       CurrTag   = (INT16) (CurrTag + 2);
1078
1079       Index     = (UINT16) (Index + TagLength);
1080       //
1081       // get the length
1082       //
1083       TagLength = RawFormSet[Index + 1];
1084       Index     = (UINT16) (Index + TagLength);
1085       //
1086       // get the length
1087       //
1088       TagLength = RawFormSet[Index + 1];
1089       break;
1090
1091     case EFI_IFR_TIME_OP:
1092       GetNumericHeader (&FormTags->Tags[CurrTag], RawFormSet, Index, (UINT16) 0, FileFormTags, CurrentVariable);
1093
1094       if (Count == 2) {
1095         //
1096         // Override the GetQuestionHeader information - date/time are treated very differently
1097         //
1098         FormTags->Tags[CurrTag].NumberOfLines = 1;
1099         Count = 0;
1100       } else {
1101         //
1102         // The premise is that every date/time op-code have 3 elements, the first 2 have 0 lines
1103         // associated with them, and the third has 1 line to allow to space beyond the choice.
1104         //
1105         Count++;
1106       }
1107       break;
1108
1109     case EFI_IFR_PASSWORD_OP:
1110     case EFI_IFR_STRING_OP:
1111       GetQuestionHeader (&FormTags->Tags[CurrTag], RawFormSet, Index, FileFormTags, CurrentVariable);
1112       IfrToFormTag (RawFormSet[Index], &FormTags->Tags[CurrTag], (VOID *) &RawFormSet[Index], NULL);
1113       break;
1114
1115     case EFI_IFR_SUPPRESS_IF_OP:
1116     case EFI_IFR_GRAYOUT_IF_OP:
1117       InconsistentTags->Operand = ((EFI_IFR_INCONSISTENT *) &RawFormSet[Index])->Header.OpCode;
1118       gConsistencyId++;
1119
1120       //
1121       // Since this op-code doesn't use the next field(s), initialize them with something invalid.
1122       // Unfortunately 0 is a valid offset value for a QuestionId
1123       //
1124       InconsistentTags->QuestionId1 = INVALID_OFFSET_VALUE;
1125       InconsistentTags->QuestionId2 = INVALID_OFFSET_VALUE;
1126
1127       //
1128       // Test for an allocated buffer.  If already allocated this is due to having called this routine
1129       // once for sizing of the NV storage.  We then loaded the NV variable and can correctly initialize
1130       // the tag structure with current values from the NV
1131       //
1132       if (InconsistentTags->Next == NULL) {
1133         AddNextInconsistentTag (&InconsistentTags);
1134         break;
1135       }
1136
1137       InconsistentTags = InconsistentTags->Next;
1138       break;
1139
1140     case EFI_IFR_FORM_SET_OP:
1141       CopyMem (
1142         &FormTags->Tags[CurrTag].GuidValue,
1143         &((EFI_IFR_FORM_SET *) &RawFormSet[Index])->Guid,
1144         sizeof (EFI_GUID)
1145         );
1146       CopyMem (
1147         &FormTags->Tags[CurrTag].CallbackHandle,
1148         &((EFI_IFR_FORM_SET *) &RawFormSet[Index])->CallbackHandle,
1149         sizeof (EFI_PHYSICAL_ADDRESS)
1150         );
1151       CopyMem (&FormTags->Tags[CurrTag].Class, &((EFI_IFR_FORM_SET *) &RawFormSet[Index])->Class, sizeof (UINT8));
1152       CopyMem (
1153         &FormTags->Tags[CurrTag].SubClass,
1154         &((EFI_IFR_FORM_SET *) &RawFormSet[Index])->SubClass,
1155         sizeof (UINT8)
1156         );
1157       CopyMem (
1158         &FormTags->Tags[CurrTag].NvDataSize,
1159         &((EFI_IFR_FORM_SET *) &RawFormSet[Index])->NvDataSize,
1160         sizeof (UINT16)
1161         );
1162       Class     = ((EFI_IFR_FORM_SET *) &RawFormSet[Index])->Class;
1163       SubClass  = ((EFI_IFR_FORM_SET *) &RawFormSet[Index])->SubClass;
1164       //
1165       // If the formset has a size value, that means someone must be using this, so create a variable
1166       // We also shall reserve the formid of 0 for this specific purpose.
1167       //
1168       if ((FileFormTags->VariableDefinitions == NULL) && (FormTags->Tags[CurrTag].NvDataSize > 0)) {
1169         FileFormTags->VariableDefinitions = AllocateZeroPool (sizeof (EFI_VARIABLE_DEFINITION));
1170         ASSERT (FileFormTags->VariableDefinitions != NULL);
1171         IfrToFormTag (
1172           RawFormSet[Index],
1173           &FormTags->Tags[CurrTag],
1174           (VOID *) &RawFormSet[Index],
1175           FileFormTags->VariableDefinitions
1176           );
1177       } else {
1178         IfrToFormTag (RawFormSet[Index], &FormTags->Tags[CurrTag], (VOID *) &RawFormSet[Index], NULL);
1179       }
1180       break;
1181
1182     case EFI_IFR_BANNER_OP:
1183       if (gClassOfVfr == EFI_FRONT_PAGE_SUBCLASS) {
1184         TempValue = 0;
1185         CopyMem (&TempValue, &((EFI_IFR_BANNER *) &RawFormSet[Index])->Alignment, sizeof (UINT8));
1186         //
1187         // If this is the special timeout value, we will dynamically figure out where to put it
1188         // Also the least significant byte refers to the TimeOut desired.
1189         //
1190         if (TempValue == EFI_IFR_BANNER_TIMEOUT) {
1191           CopyMem (&FrontPageTimeOutTitle, &((EFI_IFR_BANNER *) &RawFormSet[Index])->Title, sizeof (UINT16));
1192           if (FrontPageTimeOutValue != (INT16) -1) {
1193             CopyMem (&FrontPageTimeOutValue, &((EFI_IFR_BANNER *) &RawFormSet[Index])->LineNumber, sizeof (UINT16));
1194           }
1195           break;
1196         }
1197
1198         CopyMem (
1199           &BannerData->Banner[((EFI_IFR_BANNER *) &RawFormSet[Index])->LineNumber][
1200           ((EFI_IFR_BANNER *) &RawFormSet[Index])->Alignment],
1201           &((EFI_IFR_BANNER *) &RawFormSet[Index])->Title,
1202           sizeof (STRING_REF)
1203           );
1204       }
1205       break;
1206
1207     case EFI_IFR_INCONSISTENT_IF_OP:
1208       CopyMem (
1209         &FormTags->Tags[CurrTag].Text,
1210         &((EFI_IFR_INCONSISTENT *) &RawFormSet[Index])->Popup,
1211         sizeof (UINT16)
1212         );
1213       gConsistencyId++;
1214
1215       InconsistentTags->Operand = ((EFI_IFR_INCONSISTENT *) &RawFormSet[Index])->Header.OpCode;
1216       CopyMem (&InconsistentTags->Popup, &((EFI_IFR_INCONSISTENT *) &RawFormSet[Index])->Popup, sizeof (UINT16));
1217
1218       //
1219       // Since this op-code doesn't use the next field(s), initialize them with something invalid.
1220       // Unfortunately 0 is a valid offset value for a QuestionId
1221       //
1222       InconsistentTags->QuestionId1     = INVALID_OFFSET_VALUE;
1223       InconsistentTags->QuestionId2     = INVALID_OFFSET_VALUE;
1224
1225       InconsistentTags->VariableNumber  = CurrentVariable;
1226
1227       //
1228       // Test for an allocated buffer.  If already allocated this is due to having called this routine
1229       // once for sizing of the NV storage.  We then loaded the NV variable and can correctly initialize
1230       // the tag structure with current values from the NV
1231       //
1232       if (InconsistentTags->Next == NULL) {
1233         AddNextInconsistentTag (&InconsistentTags);
1234         break;
1235       }
1236
1237       InconsistentTags = InconsistentTags->Next;
1238       break;
1239
1240     case EFI_IFR_EQ_ID_VAL_OP:
1241       IfrToFormTag (RawFormSet[Index], &FormTags->Tags[CurrTag], (VOID *) &RawFormSet[Index], NULL);
1242
1243       InconsistentTags->Operand = ((EFI_IFR_EQ_ID_VAL *) &RawFormSet[Index])->Header.OpCode;
1244       CopyMem (&InconsistentTags->Value, &((EFI_IFR_EQ_ID_VAL *) &RawFormSet[Index])->Value, sizeof (UINT16));
1245       CopyMem (
1246         &InconsistentTags->QuestionId1,
1247         &((EFI_IFR_EQ_ID_VAL *) &RawFormSet[Index])->QuestionId,
1248         sizeof (UINT16)
1249         );
1250
1251       //
1252       // Since this op-code doesn't use the next field(s), initialize them with something invalid.
1253       // Unfortunately 0 is a valid offset value for a QuestionId
1254       //
1255       InconsistentTags->Width               = FormTags->Tags[CurrTag].StorageWidth;
1256       InconsistentTags->QuestionId2         = INVALID_OFFSET_VALUE;
1257       InconsistentTags->ConsistencyId       = gConsistencyId;
1258       FormTags->Tags[CurrTag].ConsistencyId = gConsistencyId;
1259
1260       InconsistentTags->VariableNumber      = CurrentVariable;
1261
1262       //
1263       // Test for an allocated buffer.  If already allocated this is due to having called this routine
1264       // once for sizing of the NV storage.  We then loaded the NV variable and can correctly initialize
1265       // the tag structure with current values from the NV
1266       //
1267       if (InconsistentTags->Next == NULL) {
1268         AddNextInconsistentTag (&InconsistentTags);
1269         break;
1270       }
1271
1272       InconsistentTags = InconsistentTags->Next;
1273       break;
1274
1275     case EFI_IFR_EQ_VAR_VAL_OP:
1276       IfrToFormTag (RawFormSet[Index], &FormTags->Tags[CurrTag], (VOID *) &RawFormSet[Index], NULL);
1277
1278       InconsistentTags->Operand = ((EFI_IFR_EQ_VAR_VAL *) &RawFormSet[Index])->Header.OpCode;
1279       CopyMem (&InconsistentTags->Value, &((EFI_IFR_EQ_VAR_VAL *) &RawFormSet[Index])->Value, sizeof (UINT16));
1280       CopyMem (
1281         &InconsistentTags->QuestionId1,
1282         &((EFI_IFR_EQ_VAR_VAL *) &RawFormSet[Index])->VariableId,
1283         sizeof (UINT16)
1284         );
1285
1286       //
1287       // Since this op-code doesn't use the next field(s), initialize them with something invalid.
1288       // Unfortunately 0 is a valid offset value for a QuestionId
1289       //
1290       InconsistentTags->QuestionId2         = INVALID_OFFSET_VALUE;
1291       InconsistentTags->ConsistencyId       = gConsistencyId;
1292       FormTags->Tags[CurrTag].ConsistencyId = gConsistencyId;
1293
1294       InconsistentTags->VariableNumber      = CurrentVariable;
1295
1296       //
1297       // Test for an allocated buffer.  If already allocated this is due to having called this routine
1298       // once for sizing of the NV storage.  We then loaded the NV variable and can correctly initialize
1299       // the tag structure with current values from the NV
1300       //
1301       if (InconsistentTags->Next == NULL) {
1302         AddNextInconsistentTag (&InconsistentTags);
1303         break;
1304       }
1305
1306       InconsistentTags = InconsistentTags->Next;
1307       break;
1308
1309     case EFI_IFR_EQ_ID_ID_OP:
1310       IfrToFormTag (RawFormSet[Index], &FormTags->Tags[CurrTag], (VOID *) &RawFormSet[Index], NULL);
1311
1312       InconsistentTags->Operand = ((EFI_IFR_EQ_ID_ID *) &RawFormSet[Index])->Header.OpCode;
1313       CopyMem (
1314         &InconsistentTags->QuestionId1,
1315         &((EFI_IFR_EQ_ID_ID *) &RawFormSet[Index])->QuestionId1,
1316         sizeof (UINT16)
1317         );
1318       CopyMem (
1319         &InconsistentTags->QuestionId2,
1320         &((EFI_IFR_EQ_ID_ID *) &RawFormSet[Index])->QuestionId2,
1321         sizeof (UINT16)
1322         );
1323
1324       InconsistentTags->Width               = FormTags->Tags[CurrTag].StorageWidth;
1325       InconsistentTags->ConsistencyId       = gConsistencyId;
1326       FormTags->Tags[CurrTag].ConsistencyId = gConsistencyId;
1327
1328       InconsistentTags->VariableNumber      = CurrentVariable;
1329       InconsistentTags->VariableNumber2     = CurrentVariable2;
1330
1331       //
1332       // Test for an allocated buffer.  If already allocated this is due to having called this routine
1333       // once for sizing of the NV storage.  We then loaded the NV variable and can correctly initialize
1334       // the tag structure with current values from the NV
1335       //
1336       if (InconsistentTags->Next == NULL) {
1337         AddNextInconsistentTag (&InconsistentTags);
1338         break;
1339       }
1340
1341       InconsistentTags = InconsistentTags->Next;
1342       break;
1343
1344     case EFI_IFR_AND_OP:
1345     case EFI_IFR_OR_OP:
1346     case EFI_IFR_NOT_OP:
1347     case EFI_IFR_GT_OP:
1348     case EFI_IFR_GE_OP:
1349     case EFI_IFR_TRUE_OP:
1350     case EFI_IFR_FALSE_OP:
1351       InconsistentTags->Operand = ((EFI_IFR_NOT *) &RawFormSet[Index])->Header.OpCode;
1352
1353       //
1354       // Since this op-code doesn't use the next field(s), initialize them with something invalid.
1355       // Unfortunately 0 is a valid offset value for a QuestionId
1356       //
1357
1358       //
1359       // Reserve INVALID_OFFSET_VALUE - 1 for TRUE or FALSE because they are inconsistency tags also, but
1360       // have no coresponding id. The examination of id is needed by evaluating boolean expression.
1361       //
1362       if (RawFormSet[Index] == EFI_IFR_TRUE_OP ||
1363           RawFormSet[Index] == EFI_IFR_FALSE_OP) {
1364         InconsistentTags->QuestionId1         = INVALID_OFFSET_VALUE - 1;
1365       } else {
1366         InconsistentTags->QuestionId1         = INVALID_OFFSET_VALUE;
1367       }
1368       InconsistentTags->QuestionId2         = INVALID_OFFSET_VALUE;
1369       InconsistentTags->ConsistencyId       = gConsistencyId;
1370       FormTags->Tags[CurrTag].ConsistencyId = gConsistencyId;
1371
1372       //
1373       // Test for an allocated buffer.  If already allocated this is due to having called this routine
1374       // once for sizing of the NV storage.  We then loaded the NV variable and can correctly initialize
1375       // the tag structure with current values from the NV
1376       //
1377       if (InconsistentTags->Next == NULL) {
1378         AddNextInconsistentTag (&InconsistentTags);
1379         break;
1380       }
1381
1382       InconsistentTags = InconsistentTags->Next;
1383       break;
1384
1385     case EFI_IFR_EQ_ID_LIST_OP:
1386       IfrToFormTag (RawFormSet[Index], &FormTags->Tags[CurrTag], (VOID *) &RawFormSet[Index], NULL);
1387
1388       InconsistentTags->Operand = ((EFI_IFR_EQ_ID_LIST *) &RawFormSet[Index])->Header.OpCode;
1389       CopyMem (
1390         &InconsistentTags->QuestionId1,
1391         &((EFI_IFR_EQ_ID_LIST *) &RawFormSet[Index])->QuestionId,
1392         sizeof (UINT16)
1393         );
1394       CopyMem (
1395         &InconsistentTags->ListLength,
1396         &((EFI_IFR_EQ_ID_LIST *) &RawFormSet[Index])->ListLength,
1397         sizeof (UINT16)
1398         );
1399       InconsistentTags->ValueList = FormTags->Tags[CurrTag].IntList;
1400
1401       //
1402       // Since this op-code doesn't use the next field(s), initialize them with something invalid.
1403       // Unfortunately 0 is a valid offset value for a QuestionId
1404       //
1405       InconsistentTags->Width               = FormTags->Tags[CurrTag].StorageWidth;
1406       InconsistentTags->QuestionId2         = INVALID_OFFSET_VALUE;
1407       InconsistentTags->ConsistencyId       = gConsistencyId;
1408       FormTags->Tags[CurrTag].ConsistencyId = gConsistencyId;
1409
1410       //
1411       // Test for an allocated buffer.  If already allocated this is due to having called this routine
1412       // once for sizing of the NV storage.  We then loaded the NV variable and can correctly initialize
1413       // the tag structure with current values from the NV
1414       //
1415       if (InconsistentTags->Next == NULL) {
1416         AddNextInconsistentTag (&InconsistentTags);
1417         break;
1418       }
1419
1420       InconsistentTags = InconsistentTags->Next;
1421       break;
1422
1423     case EFI_IFR_END_IF_OP:
1424       InconsistentTags->Operand = ((EFI_IFR_END_EXPR *) &RawFormSet[Index])->Header.OpCode;
1425
1426       //
1427       // Since this op-code doesn't use the next field(s), initialize them with something invalid.
1428       // Unfortunately 0 is a valid offset value for a QuestionId
1429       //
1430       InconsistentTags->QuestionId1 = INVALID_OFFSET_VALUE;
1431       InconsistentTags->QuestionId2 = INVALID_OFFSET_VALUE;
1432
1433       //
1434       // Test for an allocated buffer.  If already allocated this is due to having called this routine
1435       // once for sizing of the NV storage.  We then loaded the NV variable and can correctly initialize
1436       // the tag structure with current values from the NV
1437       //
1438       if (InconsistentTags->Next == NULL) {
1439         AddNextInconsistentTag (&InconsistentTags);
1440         break;
1441       }
1442
1443       InconsistentTags = InconsistentTags->Next;
1444       break;
1445
1446     case EFI_IFR_END_ONE_OF_OP:
1447       break;
1448
1449     default:
1450       break;
1451     }
1452     //
1453     // End of switch
1454     //
1455     // Per spec., we ignore ops that we don't know how to deal with.  Skip to next tag
1456     //
1457     Index = (UINT16) (Index + TagLength);
1458   }
1459   //
1460   // End of Index
1461   //
1462   // When we eventually exit, make sure we mark the last tag with an op-code
1463   //
1464   FormTags->Tags[CurrTag].Operand = RawFormSet[Index];
1465
1466   IfrToFormTag (RawFormSet[Index], &FormTags->Tags[CurrTag], (VOID *) &RawFormSet[Index], NULL);
1467
1468   //
1469   // Place this as an end of the database marker
1470   //
1471   InconsistentTags->Operand = 0xFF;
1472
1473   //
1474   // This is the Head of the linked list of pages.  Each page is an array of tags
1475   //
1476   FormTags          = &FileFormTags->FormTags;
1477   InconsistentTags  = FileFormTags->InconsistentTags;
1478
1479   for (; InconsistentTags->Operand != 0xFF;) {
1480     if (InconsistentTags->QuestionId1 != INVALID_OFFSET_VALUE) {
1481       //
1482       // Search the tags for the tag which corresponds to this ID
1483       //
1484       for (CurrTag = 0; FormTags->Tags[0].Operand != EFI_IFR_END_FORM_SET_OP; CurrTag++) {
1485         //
1486         // If we hit the end of a form, go to the next set of Tags.
1487         // Remember - EndFormSet op-codes sit on their own page after an end form.
1488         //
1489         if (FormTags->Tags[CurrTag].Operand == EFI_IFR_END_FORM_OP) {
1490           //
1491           // Reset the CurrTag value (it will be incremented, after this case statement
1492           // so set to a negative one so that we get the desired effect.)  Fish can beat me later.
1493           //
1494           CurrTag   = -1;
1495           FormTags  = FormTags->Next;
1496           continue;
1497         }
1498
1499         if (FormTags->Tags[CurrTag].Id == InconsistentTags->QuestionId1) {
1500           FormTags->Tags[CurrTag].Consistency++;
1501         }
1502       }
1503     }
1504
1505     FormTags = &FileFormTags->FormTags;
1506
1507     if (InconsistentTags->QuestionId2 != INVALID_OFFSET_VALUE) {
1508       //
1509       // Search the tags for the tag which corresponds to this ID
1510       //
1511       for (CurrTag = 0; FormTags->Tags[CurrTag].Operand != EFI_IFR_END_FORM_SET_OP; CurrTag++) {
1512         //
1513         // If we hit the end of a form, go to the next set of Tags.
1514         // Remember - EndFormSet op-codes sit on their own page after an end form.
1515         //
1516         if (FormTags->Tags[CurrTag].Operand == EFI_IFR_END_FORM_OP) {
1517           //
1518           // Reset the CurrTag value (it will be incremented, after this case statement
1519           // so set to a negative one so that we get the desired effect.)  Fish can beat me later.
1520           //
1521           CurrTag   = -1;
1522           FormTags  = FormTags->Next;
1523           continue;
1524         }
1525
1526         if (FormTags->Tags[CurrTag].Id == InconsistentTags->QuestionId2) {
1527           FormTags->Tags[CurrTag].Consistency++;
1528         }
1529       }
1530     }
1531
1532     InconsistentTags = InconsistentTags->Next;
1533   }
1534
1535   return Status;
1536 }
1537
1538 VOID
1539 InitPage (
1540   VOID
1541   )
1542 {
1543   CHAR16  *HomePageString;
1544   CHAR16  *HomeEscapeString;
1545
1546   //
1547   // Displays the Header and Footer borders
1548   //
1549   DisplayPageFrame ();
1550
1551   HomePageString    = GetToken (STRING_TOKEN (HOME_PAGE_TITLE), gHiiHandle);
1552   HomeEscapeString  = GetToken (STRING_TOKEN (HOME_ESCAPE_STRING), gHiiHandle);
1553
1554   gST->ConOut->SetAttribute (gST->ConOut, EFI_YELLOW | EFI_BRIGHT);
1555   //
1556   //  PrintStringAt ((gScreenDimensions.RightColumn - GetStringWidth(HomePageString)/2)/2, 1, HomePageString);
1557   //
1558   PrintStringAt (
1559     (gScreenDimensions.RightColumn + gScreenDimensions.LeftColumn - GetStringWidth (HomePageString) / 2) / 2,
1560     1,
1561     HomePageString
1562     );
1563   PrintAt (
1564     gScreenDimensions.LeftColumn + 2,
1565     gScreenDimensions.BottomRow - 3,
1566     (CHAR16 *) L"%c%c%s",
1567     ARROW_UP,
1568     ARROW_DOWN,
1569     gMoveHighlight
1570     );
1571   PrintAt (
1572     gScreenDimensions.RightColumn - (GetStringWidth (HomeEscapeString) / 2) - 2,
1573     gScreenDimensions.BottomRow - 3,
1574     (CHAR16 *) L" %s",
1575     HomeEscapeString
1576     );
1577   gST->ConOut->SetAttribute (gST->ConOut, EFI_TEXT_ATTR (EFI_LIGHTGRAY, EFI_BLACK));
1578   gBS->FreePool (HomeEscapeString);
1579   gBS->FreePool (HomePageString);
1580
1581   return ;
1582 }
1583
1584 CHAR16 *
1585 GetToken (
1586   IN  STRING_REF                              Token,
1587   IN  EFI_HII_HANDLE                          HiiHandle
1588   )
1589 /*++
1590
1591 Routine Description:
1592
1593   Get the string based on the TokenID and HII Handle.
1594
1595 Arguments:
1596
1597   Token       - The Token ID.
1598   HiiHandle   - Handle of Ifr to be fetched.
1599
1600 Returns:
1601
1602   The output string.
1603
1604 --*/
1605 {
1606   CHAR16      *Buffer;
1607   UINTN       BufferLength;
1608   EFI_STATUS  Status;
1609
1610   //
1611   // Set default string size assumption at no more than 256 bytes
1612   //
1613   BufferLength  = 0x100;
1614
1615   Buffer        = AllocateZeroPool (BufferLength);
1616   ASSERT (Buffer != NULL);
1617
1618   Status = Hii->GetString (Hii, HiiHandle, Token, TRUE, NULL, &BufferLength, Buffer);
1619
1620   if (EFI_ERROR (Status)) {
1621     if (Status == EFI_BUFFER_TOO_SMALL) {
1622       //
1623       // Free the old pool
1624       //
1625       gBS->FreePool (Buffer);
1626
1627       //
1628       // Allocate new pool with correct value
1629       //
1630       Buffer = AllocatePool (BufferLength);
1631       ASSERT (Buffer != NULL);
1632
1633       Status = Hii->GetString (Hii, HiiHandle, Token, TRUE, NULL, &BufferLength, Buffer);
1634
1635       if (!EFI_ERROR (Status)) {
1636         return Buffer;
1637       }
1638     }
1639
1640     ASSERT_EFI_ERROR (Status);
1641   }
1642
1643   return Buffer;
1644 }
1645
1646 STATIC
1647 EFI_STATUS
1648 PopulateHomePage (
1649   IN UINTN                                    NumberOfIfrImages,
1650   IN EFI_FILE_FORM_TAGS                       *FileFormTagsHead
1651   )
1652 {
1653   EFI_STATUS          Status;
1654   UINTN               Index;
1655   EFI_IFR_BINARY      *IfrBinary;
1656   CHAR16              *StringPtr;
1657   EFI_FILE_FORM_TAGS  *FileFormTags;
1658   EFI_FORM_TAGS       LocalTags;
1659
1660   FileFormTags = FileFormTagsHead;
1661
1662   UiInitMenu ();
1663
1664   Status = EFI_SUCCESS;
1665
1666   //
1667   // If there are no images
1668   //
1669   if (NumberOfIfrImages == 0) {
1670     Status = EFI_NO_MEDIA;
1671     return Status;
1672   }
1673   //
1674   // IfrBinary points to the beginning of the Binary data linked-list
1675   //
1676   IfrBinary = gBinaryDataHead;
1677
1678   //
1679   // Print the entries which were in the default language.
1680   //
1681   for (Index = 0; Index < NumberOfIfrImages; Index++) {
1682     LocalTags = FileFormTags->FormTags;
1683
1684     //
1685     // Populate the Menu
1686     //
1687     StringPtr = GetToken (IfrBinary->TitleToken, IfrBinary->Handle);
1688
1689     //
1690     // If the default language doesn't exist, don't add a menu option yet
1691     //
1692     if (StringPtr[0] != CHAR_NULL) {
1693       //
1694       // We are NOT!! removing this StringPtr buffer via FreePool since it is being used in the menuoptions, we will do
1695       // it in UiFreeMenu.
1696       //
1697       UiAddMenuOption (StringPtr, IfrBinary->Handle, LocalTags.Tags, IfrBinary->FormBinary, Index);
1698     }
1699     //
1700     // Advance to the next HII handle
1701     //
1702     IfrBinary     = IfrBinary->Next;
1703     FileFormTags  = FileFormTags->NextFile;
1704   }
1705
1706   return Status;
1707 }
1708
1709 UI_MENU_OPTION *
1710 DisplayHomePage (
1711   IN UINTN                                    NumberOfIfrImages,
1712   IN EFI_FILE_FORM_TAGS                       *FileFormTagsHead,
1713   IN UINT8                                    *CallbackData
1714   )
1715 {
1716   EFI_STATUS      Status;
1717   UI_MENU_OPTION  *Selection;
1718
1719   //
1720   // This prints the basic home page template which the user sees
1721   //
1722   InitPage ();
1723
1724   Status = PopulateHomePage (NumberOfIfrImages, FileFormTagsHead);
1725
1726   if (EFI_ERROR (Status)) {
1727     Selection = NULL;
1728     return Selection;
1729   }
1730
1731   Selection = UiDisplayMenu (FALSE, FileFormTagsHead, (EFI_IFR_DATA_ARRAY *) CallbackData);
1732
1733   return Selection;
1734 }
1735
1736 EFI_STATUS
1737 InitializeBinaryStructures (
1738   IN  EFI_HII_HANDLE                        *Handle,
1739   IN  BOOLEAN                               UseDatabase,
1740   IN  EFI_IFR_PACKET                        *Packet,
1741   IN  UINT8                                 *NvMapOverride,
1742   IN  UINTN                                 NumberOfIfrImages,
1743   OUT EFI_FILE_FORM_TAGS                    **FileFormTagsHead
1744   )
1745 {
1746   UINTN                       HandleIndex;
1747   EFI_STATUS                  Status;
1748   EFI_IFR_BINARY              *BinaryData;
1749   EFI_FILE_FORM_TAGS          *FileFormTags;
1750   UINTN                       SizeOfNvStore;
1751   EFI_FORM_CALLBACK_PROTOCOL  *FormCallback;
1752   EFI_VARIABLE_DEFINITION     *VariableDefinition;
1753   EFI_VARIABLE_DEFINITION     *OverrideDefinition;
1754   VOID                        *NvMap;
1755   UINTN                       NvMapSize;
1756   EFI_HII_VARIABLE_PACK_LIST  *NvMapListHead;
1757   EFI_HII_VARIABLE_PACK_LIST  *NvMapListNode;
1758
1759   //
1760   // Initialize some variables to avoid warnings
1761   //
1762   BinaryData        = NULL;
1763   *FileFormTagsHead = NULL;
1764   FileFormTags      = NULL;
1765   gBinaryDataHead   = NULL;
1766   Status            = EFI_SUCCESS;
1767   FormCallback      = NULL;
1768   NvMap             = NULL;
1769   NvMapSize         = 0;
1770
1771   if (NumberOfIfrImages > 1) {
1772     NvMapOverride = NULL;
1773   }
1774
1775   for (HandleIndex = 0; HandleIndex < NumberOfIfrImages; HandleIndex += 1) {
1776     //
1777     // If the buffers are uninitialized, allocate them, otherwise work on the ->Next members
1778     //
1779     if ((BinaryData == NULL) || (FileFormTags == NULL)) {
1780       //
1781       // Allocate memory for our Binary Data
1782       //
1783       BinaryData = AllocateZeroPool (sizeof (EFI_IFR_BINARY));
1784       ASSERT (BinaryData);
1785
1786       //
1787       // Preserve the Head of what will be a linked-list.
1788       //
1789       gBinaryDataHead       = BinaryData;
1790       gBinaryDataHead->Next = NULL;
1791
1792       if (UseDatabase) {
1793         Status = GetIfrBinaryData (Hii, Handle[HandleIndex], NULL, BinaryData);
1794       } else {
1795         Status = GetIfrBinaryData (Hii, Handle[HandleIndex], Packet, BinaryData);
1796       }
1797       //
1798       // Allocate memory for our File Form Tags
1799       //
1800       FileFormTags = AllocateZeroPool (sizeof (EFI_FILE_FORM_TAGS));
1801       ASSERT (FileFormTags);
1802
1803       //
1804       // Preserve the Head of what will be a linked-list.
1805       //
1806       *FileFormTagsHead             = FileFormTags;
1807       (*FileFormTagsHead)->NextFile = NULL;
1808
1809     } else {
1810       //
1811       // Allocate memory for our Binary Data linked-list
1812       // Each handle represents a Binary and we will store that data away.
1813       //
1814       BinaryData->Next = AllocateZeroPool (sizeof (EFI_IFR_BINARY));
1815       ASSERT (BinaryData->Next);
1816
1817       BinaryData        = BinaryData->Next;
1818       BinaryData->Next  = NULL;
1819
1820       if (UseDatabase) {
1821         Status = GetIfrBinaryData (Hii, Handle[HandleIndex], NULL, BinaryData);
1822       } else {
1823         Status = GetIfrBinaryData (Hii, Handle[HandleIndex], Packet, BinaryData);
1824       }
1825
1826       if (EFI_ERROR (Status)) {
1827         return EFI_DEVICE_ERROR;
1828       }
1829       //
1830       // Allocate memory for our FileFormTags linked-list
1831       // Each allocation reserves handle represents a Binary and we will store that data away.
1832       //
1833       FileFormTags->NextFile = AllocateZeroPool (sizeof (EFI_FILE_FORM_TAGS));
1834       ASSERT (FileFormTags->NextFile);
1835
1836       FileFormTags = FileFormTags->NextFile;
1837     }
1838     //
1839     // endif
1840     //
1841     // Tag Structure Initialization
1842     //
1843     Status              = InitializeTagStructures (BinaryData, FileFormTags);
1844
1845     VariableDefinition  = FileFormTags->VariableDefinitions;
1846
1847     //
1848     // Allocate memory for our NVRAM Maps for all of our variables
1849     //
1850     for (; VariableDefinition != NULL; VariableDefinition = VariableDefinition->Next) {
1851       //
1852       // Pad the fake variable size accordingly - this value should reflect the size of information that is not accounted by
1853       // the mainstream NVRAM variable such as DATE/TIME information that the browser needs to track but is saved to an RTC
1854       //
1855       VariableDefinition->VariableFakeSize = (UINT16) (VariableDefinition->VariableSize + VariableDefinition->VariableFakeSize);
1856
1857       //
1858       // In the case where a file has no "real" NV data, we should pad the buffer accordingly
1859       //
1860       if (VariableDefinition->VariableSize == 0) {
1861         if (VariableDefinition->VariableFakeSize != 0) {
1862           VariableDefinition->NvRamMap = AllocateZeroPool (VariableDefinition->VariableFakeSize);
1863           ASSERT (VariableDefinition->NvRamMap != NULL);
1864         }
1865       } else {
1866         VariableDefinition->NvRamMap = AllocateZeroPool (VariableDefinition->VariableSize);
1867         ASSERT (VariableDefinition->NvRamMap != NULL);
1868       }
1869
1870       if (VariableDefinition->VariableFakeSize != 0) {
1871         VariableDefinition->FakeNvRamMap = AllocateZeroPool (VariableDefinition->VariableFakeSize);
1872         ASSERT (VariableDefinition->FakeNvRamMap != NULL);
1873       }
1874     }
1875
1876     Status = gBS->HandleProtocol (
1877                     (VOID *) (UINTN) FileFormTags->FormTags.Tags[0].CallbackHandle,
1878                     &gEfiFormCallbackProtocolGuid,
1879                     (VOID **) &FormCallback
1880                     );
1881
1882     //
1883     // Since we might have multiple variables, if there is an NvMapOverride we need to use the EFI_VARIABLE_DEFINITION
1884     // information as the information that we pass back and forth.  NOTE that callbacks that are initiated will only have the
1885     // NVRAM data refreshed based on the op-code that initiated the callback.  In other words, we will pass to the caller a single
1886     // NVRAM map for a single variable based on the op-code that the user selected.
1887     //
1888     if (NvMapOverride != NULL) {
1889       VariableDefinition  = FileFormTags->VariableDefinitions;
1890       OverrideDefinition  = ((EFI_VARIABLE_DEFINITION *) NvMapOverride);
1891
1892       //
1893       // Search through the variable definitions.  There should be sufficient passed in settings for the variable op-codes specified
1894       //
1895       for (; VariableDefinition != NULL; VariableDefinition = VariableDefinition->Next) {
1896         if ((!CompareMem (VariableDefinition->VariableName, L"Setup", 10)) && (VariableDefinition->Next == NULL)) {
1897           if (VariableDefinition->VariableSize != 0) {
1898             CopyMem (VariableDefinition->NvRamMap, NvMapOverride, VariableDefinition->VariableSize);
1899           } else {
1900             CopyMem (VariableDefinition->NvRamMap, NvMapOverride, VariableDefinition->VariableFakeSize);
1901           }
1902           break;
1903         } else {
1904           VariableDefinition->NvRamMap = OverrideDefinition->NvRamMap;
1905         }
1906         //
1907         // There should NEVER be a ->Next for VariableDefinition and a NULL ->Next for the OverrideDefinition
1908         //
1909         ASSERT (OverrideDefinition->Next);
1910         OverrideDefinition = OverrideDefinition->Next;
1911       }
1912     } else {
1913       VariableDefinition = FileFormTags->VariableDefinitions;
1914
1915       //
1916       // Search through the variable definitions.  There should be sufficient passed in settings for the variable op-codes specified
1917       //
1918       for (; VariableDefinition != NULL; VariableDefinition = VariableDefinition->Next) {
1919         SizeOfNvStore = VariableDefinition->VariableSize;
1920
1921         //
1922         // Getting the NvStore and placing it into our Global Data
1923         //
1924         if ((FormCallback != NULL) && (FormCallback->NvRead != NULL)) {
1925           Status = FormCallback->NvRead (
1926                                   FormCallback,
1927                                   VariableDefinition->VariableName,
1928                                   &VariableDefinition->Guid,
1929                                   NULL,
1930                                   &SizeOfNvStore,
1931                                   (VOID *) VariableDefinition->NvRamMap
1932                                   );
1933         } else {
1934           Status = gRT->GetVariable (
1935                           VariableDefinition->VariableName,
1936                           &VariableDefinition->Guid,
1937                           NULL,
1938                           &SizeOfNvStore,
1939                           (VOID *) VariableDefinition->NvRamMap
1940                           );
1941         }
1942
1943         if (EFI_ERROR (Status)) {
1944           //
1945           // If there is a variable that exists already and it is larger than what we calculated the
1946           // storage needs to be, we must assume the variable size from GetVariable is correct and not
1947           // allow the truncation of the variable.  It is very possible that the user who created the IFR
1948           // we are cracking is not referring to a variable that was in a previous map, however we cannot
1949           // allow it's truncation.
1950           //
1951           if (Status == EFI_BUFFER_TOO_SMALL) {
1952             //
1953             // If the buffer was too small, we should have the expanded size requirement in SizeOfNvStore now.
1954             //
1955             VariableDefinition->VariableSize = (UINT16) SizeOfNvStore;
1956
1957             //
1958             // Free the buffer that was allocated that was too small
1959             //
1960             gBS->FreePool (VariableDefinition->NvRamMap);
1961             gBS->FreePool (VariableDefinition->FakeNvRamMap);
1962
1963             VariableDefinition->NvRamMap = AllocateZeroPool (SizeOfNvStore);
1964             VariableDefinition->FakeNvRamMap = AllocateZeroPool (SizeOfNvStore + VariableDefinition->VariableFakeSize);
1965             ASSERT (VariableDefinition->NvRamMap);
1966             ASSERT (VariableDefinition->FakeNvRamMap);
1967
1968             if ((FormCallback != NULL) && (FormCallback->NvRead != NULL)) {
1969               Status = FormCallback->NvRead (
1970                                       FormCallback,
1971                                       VariableDefinition->VariableName,
1972                                       &VariableDefinition->Guid,
1973                                       NULL,
1974                                       &SizeOfNvStore,
1975                                       (VOID *) VariableDefinition->NvRamMap
1976                                       );
1977             } else {
1978               Status = gRT->GetVariable (
1979                               VariableDefinition->VariableName,
1980                               &VariableDefinition->Guid,
1981                               NULL,
1982                               &SizeOfNvStore,
1983                               (VOID *) VariableDefinition->NvRamMap
1984                               );
1985             }
1986           }
1987           //
1988           // if the variable was not found, we will retrieve default values
1989           //
1990           if (Status == EFI_NOT_FOUND) {
1991
1992             if (0 == CompareMem (VariableDefinition->VariableName, L"Setup", 10)) {
1993
1994               NvMapListHead = NULL;
1995
1996               Status = Hii->GetDefaultImage (Hii, Handle[HandleIndex], EFI_IFR_FLAG_DEFAULT, &NvMapListHead);
1997
1998               if (!EFI_ERROR (Status)) {
1999                 ASSERT_EFI_ERROR (NULL != NvMapListHead);
2000
2001                 NvMapListNode = NvMapListHead;
2002
2003                 while (NULL != NvMapListNode) {
2004                   if (VariableDefinition->VariableId == NvMapListNode->VariablePack->VariableId) {
2005                     NvMap     = (VOID *) ((CHAR8 *) NvMapListNode->VariablePack + sizeof (EFI_HII_VARIABLE_PACK) + NvMapListNode->VariablePack->VariableNameLength);
2006                     NvMapSize = NvMapListNode->VariablePack->Header.Length  - sizeof (EFI_HII_VARIABLE_PACK) - NvMapListNode->VariablePack->VariableNameLength;
2007                     break;
2008                     }
2009                   NvMapListNode = NvMapListNode->NextVariablePack;
2010                 }
2011
2012                 //
2013                 // Free the buffer that was allocated.
2014                 //
2015                 gBS->FreePool (VariableDefinition->NvRamMap);
2016                 gBS->FreePool (VariableDefinition->FakeNvRamMap);
2017
2018                 //
2019                 // Allocate, copy the NvRamMap.
2020                 //
2021                 VariableDefinition->VariableFakeSize = (UINT16) (VariableDefinition->VariableFakeSize - VariableDefinition->VariableSize);
2022                 VariableDefinition->VariableSize = (UINT16) NvMapSize;
2023                 VariableDefinition->VariableFakeSize = (UINT16) (VariableDefinition->VariableFakeSize + VariableDefinition->VariableSize);
2024
2025                 VariableDefinition->NvRamMap = AllocateZeroPool (VariableDefinition->VariableSize);
2026                 VariableDefinition->FakeNvRamMap = AllocateZeroPool (NvMapSize + VariableDefinition->VariableFakeSize);
2027
2028                 CopyMem (VariableDefinition->NvRamMap, NvMap, NvMapSize);
2029                 gBS->FreePool (NvMapListHead);
2030               }
2031
2032             }
2033             Status = EFI_SUCCESS;
2034           }
2035         }
2036       }
2037     }
2038
2039     InitializeTagStructures (BinaryData, FileFormTags);
2040   }
2041   //
2042   // endfor
2043   //
2044   return Status;
2045 }
2046
2047 EFI_STATUS
2048 GetIfrBinaryData (
2049   IN      EFI_HII_PROTOCOL *Hii,
2050   IN      EFI_HII_HANDLE   HiiHandle,
2051   IN      EFI_IFR_PACKET   *Packet,
2052   IN OUT  EFI_IFR_BINARY   *BinaryData
2053   )
2054 /*++
2055
2056 Routine Description:
2057   Fetch the Ifr binary data.
2058
2059 Arguments:
2060   Hii         - Point to HII protocol.
2061   HiiHandle   - Handle of Ifr to be fetched.
2062   Packet      - Pointer to IFR packet.
2063   BinaryData  - Buffer to copy the string into
2064
2065 Returns:
2066   Returns the number of CHAR16 characters that were copied into the OutputString buffer.
2067
2068
2069 --*/
2070 {
2071   EFI_STATUS        Status;
2072   EFI_HII_PACKAGES  *PackageList;
2073   UINTN             BufferSize;
2074   VOID              *Buffer;
2075   UINT8             *RawFormBinary;
2076   EFI_IFR_FORM_SET  *FormOp;
2077   UINT16            Index;
2078   UINT16            Index2;
2079   UINT16            TitleToken;
2080
2081   //
2082   // Initialize the TitleToken to 0 just in case not found
2083   //
2084   TitleToken = 0;
2085
2086   //
2087   // Try for a 32K Buffer
2088   //
2089   BufferSize = 0x8000;
2090
2091   //
2092   // Allocate memory for our Form binary
2093   //
2094   Buffer = AllocateZeroPool (BufferSize);
2095   ASSERT (Buffer);
2096
2097   if (Packet == NULL) {
2098     Status = Hii->GetForms (Hii, HiiHandle, 0, &BufferSize, Buffer);
2099
2100     if (Status == EFI_BUFFER_TOO_SMALL) {
2101
2102       gBS->FreePool (Buffer);
2103
2104       //
2105       // Allocate memory for our Form binary
2106       //
2107       Buffer = AllocatePool (BufferSize);
2108       ASSERT (Buffer);
2109
2110       Status = Hii->GetForms (Hii, HiiHandle, 0, &BufferSize, Buffer);
2111     }
2112   } else {
2113     //
2114     // Copies the data to local usable buffer
2115     //
2116     CopyMem (Buffer, Packet->IfrData, Packet->IfrData->Header.Length);
2117
2118     //
2119     // Register the string data with HII
2120     //
2121     PackageList = PreparePackages (2, NULL, Packet->IfrData, Packet->StringData);
2122
2123     Status      = Hii->NewPack (Hii, PackageList, &HiiHandle);
2124
2125     gBS->FreePool (PackageList);
2126   }
2127
2128   if (EFI_ERROR (Status)) {
2129     return Status;
2130   }
2131   //
2132   // We now have the IFR binary in our Buffer
2133   //
2134   BinaryData->IfrPackage  = Buffer;
2135   RawFormBinary           = (UINT8 *) ((CHAR8 *) (Buffer) + sizeof (EFI_HII_PACK_HEADER));
2136   BinaryData->FormBinary  = (UINT8 *) ((CHAR8 *) (Buffer) + sizeof (EFI_HII_PACK_HEADER));
2137   BinaryData->Handle      = HiiHandle;
2138
2139   //
2140   // If a packet was passed in, remove the string data when exiting.
2141   //
2142   if (Packet != NULL) {
2143     BinaryData->UnRegisterOnExit = TRUE;
2144   } else {
2145     BinaryData->UnRegisterOnExit = FALSE;
2146   }
2147   //
2148   // Walk through the FormSet Opcodes looking for the FormSet opcode
2149   // If we hit EFI_IFR_END_SET_OP we know we hit the end of the FormSet.
2150   //
2151   for (Index = 0; RawFormBinary[Index] != EFI_IFR_END_FORM_SET_OP;) {
2152     FormOp  = (EFI_IFR_FORM_SET *) &RawFormBinary[Index];
2153     Index   = (UINT16) (Index + FormOp->Header.Length);
2154
2155     if (FormOp->Header.OpCode == EFI_IFR_FORM_SET_OP) {
2156       TitleToken = FormOp->FormSetTitle;
2157       //
2158       // If displaying FrontPage - set the flag signifying it
2159       //
2160       switch (FormOp->SubClass) {
2161       case EFI_FRONT_PAGE_SUBCLASS:
2162         FrontPageHandle = HiiHandle;
2163
2164       default:
2165         gClassOfVfr = FormOp->SubClass;
2166       }
2167       //
2168       // Match GUID to find out the function key setting. If match fail, use the default setting.
2169       //
2170       for (Index2 = 0; Index2 < sizeof (gFunctionKeySettingTable) / sizeof (FUNCTIION_KEY_SETTING); Index2++) {
2171         if (CompareGuid ((EFI_GUID *)(UINTN)&FormOp->Guid, &(gFunctionKeySettingTable[Index2].FormSetGuid))) {
2172           //
2173           // Update the function key setting.
2174           //
2175           gFunctionKeySetting = gFunctionKeySettingTable[Index2].KeySetting;
2176           //
2177           // Function key prompt can not be displayed if the function key has been disabled.
2178           //
2179           if ((gFunctionKeySetting & FUNCTION_ONE) != FUNCTION_ONE) {
2180             gFunctionOneString = GetToken (STRING_TOKEN (EMPTY_STRING), gHiiHandle);
2181           }
2182
2183           if ((gFunctionKeySetting & FUNCTION_TWO) != FUNCTION_TWO) {
2184             gFunctionTwoString = GetToken (STRING_TOKEN (EMPTY_STRING), gHiiHandle);
2185           }
2186
2187           if ((gFunctionKeySetting & FUNCTION_NINE) != FUNCTION_NINE) {
2188             gFunctionNineString = GetToken (STRING_TOKEN (EMPTY_STRING), gHiiHandle);
2189           }
2190
2191           if ((gFunctionKeySetting & FUNCTION_TEN) != FUNCTION_TEN) {
2192             gFunctionTenString = GetToken (STRING_TOKEN (EMPTY_STRING), gHiiHandle);
2193           }
2194         }
2195       }
2196     }
2197   }
2198
2199   BinaryData->TitleToken = TitleToken;
2200
2201   return Status;
2202 }
2203
2204 EFI_HANDLE          PrintHandle     = NULL;
2205 EFI_PRINT_PROTOCOL  mPrintProtocol  = { UnicodeVSPrint };
2206
2207 EFI_STATUS
2208 InstallPrint (
2209   VOID
2210   )
2211 {
2212   return gBS->InstallProtocolInterface (
2213                 &PrintHandle,
2214                 &gEfiPrintProtocolGuid,
2215                 EFI_NATIVE_INTERFACE,
2216                 &mPrintProtocol
2217                 );
2218 }