MdeModulePkg/Library/BootMaintenanceManagerUiLib/BootMaintenance.c

   1 /** @file
   2 The functions for Boot Maintainence Main menu.
   3
   4 Copyright (c) 2004 - 2016, Intel Corporation. All rights reserved.<BR>
   5 This program and the accompanying materials
   6 are licensed and made available under the terms and conditions of the BSD License
   7 which accompanies this distribution.  The full text of the license may be found at
   8 http://opensource.org/licenses/bsd-license.php
   9
  10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13 **/
  14
  15 #include "BootMaintenanceManager.h"
  16
  17 #define FRONT_PAGE_KEY_OFFSET          0x4000
  18 //
  19 // Boot video resolution and text mode.
  20 //
  21 UINT32    mBmmBootHorizontalResolution    = 0;
  22 UINT32    mBmmBootVerticalResolution      = 0;
  23 UINT32    mBmmBootTextModeColumn          = 0;
  24 UINT32    mBmmBootTextModeRow             = 0;
  25 //
  26 // BIOS setup video resolution and text mode.
  27 //
  28 UINT32    mBmmSetupTextModeColumn         = 0;
  29 UINT32    mBmmSetupTextModeRow            = 0;
  30 UINT32    mBmmSetupHorizontalResolution   = 0;
  31 UINT32    mBmmSetupVerticalResolution     = 0;
  32
  33 BOOLEAN   mBmmModeInitialized             = FALSE;
  34
  35 EFI_DEVICE_PATH_PROTOCOL  EndDevicePath[] = {
  36   {
  37     END_DEVICE_PATH_TYPE,
  38     END_ENTIRE_DEVICE_PATH_SUBTYPE,
  39     {
  40       END_DEVICE_PATH_LENGTH,
  41       0
  42     }
  43   }
  44 };
  45
  46 HII_VENDOR_DEVICE_PATH  mBmmHiiVendorDevicePath = {
  47   {
  48     {
  49       HARDWARE_DEVICE_PATH,
  50       HW_VENDOR_DP,
  51       {
  52         (UINT8) (sizeof (VENDOR_DEVICE_PATH)),
  53         (UINT8) ((sizeof (VENDOR_DEVICE_PATH)) >> 8)
  54       }
  55     },
  56     //
  57     // {165A028F-0BB2-4b5f-8747-77592E3F6499}
  58     //
  59     { 0x165a028f, 0xbb2, 0x4b5f, { 0x87, 0x47, 0x77, 0x59, 0x2e, 0x3f, 0x64, 0x99 } }
  60   },
  61   {
  62     END_DEVICE_PATH_TYPE,
  63     END_ENTIRE_DEVICE_PATH_SUBTYPE,
  64     {
  65       (UINT8) (END_DEVICE_PATH_LENGTH),
  66       (UINT8) ((END_DEVICE_PATH_LENGTH) >> 8)
  67     }
  68   }
  69 };
  70
  71 EFI_GUID mBootMaintGuid          = BOOT_MAINT_FORMSET_GUID;
  72
  73 CHAR16  mBootMaintStorageName[]     = L"BmmData";
  74 BMM_CALLBACK_DATA  gBootMaintenancePrivate = {
  75   BMM_CALLBACK_DATA_SIGNATURE,
  76   NULL,
  77   NULL,
  78   {
  79     BootMaintExtractConfig,
  80     BootMaintRouteConfig,
  81     BootMaintCallback
  82   }
  83 };
  84
  85 BMM_CALLBACK_DATA *mBmmCallbackInfo = &gBootMaintenancePrivate;
  86 BOOLEAN  mAllMenuInit               = FALSE;
  87 BOOLEAN  mFirstEnterBMMForm         = FALSE;
  88
  89 /**
  90   Init all memu.
  91
  92   @param CallbackData    The BMM context data.
  93
  94 **/
  95 VOID
  96 InitAllMenu (
  97   IN  BMM_CALLBACK_DATA    *CallbackData
  98   );
  99
 100 /**
 101   Free up all Menu Option list.
 102
 103 **/
 104 VOID
 105 FreeAllMenu (
 106   VOID
 107   );
 108
 109 /**
 110
 111   Update the menus in the BMM page.
 112
 113 **/
 114 VOID
 115 CustomizeMenus (
 116   VOID
 117   );
 118
 119 /**
 120   This function will change video resolution and text mode
 121   according to defined setup mode or defined boot mode
 122
 123   @param  IsSetupMode   Indicate mode is changed to setup mode or boot mode.
 124
 125   @retval  EFI_SUCCESS  Mode is changed successfully.
 126   @retval  Others       Mode failed to be changed.
 127
 128 **/
 129 EFI_STATUS
 130 BmmSetConsoleMode (
 131   BOOLEAN  IsSetupMode
 132   )
 133 {
 134   EFI_GRAPHICS_OUTPUT_PROTOCOL          *GraphicsOutput;
 135   EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL       *SimpleTextOut;
 136   UINTN                                 SizeOfInfo;
 137   EFI_GRAPHICS_OUTPUT_MODE_INFORMATION  *Info;
 138   UINT32                                MaxGopMode;
 139   UINT32                                MaxTextMode;
 140   UINT32                                ModeNumber;
 141   UINT32                                NewHorizontalResolution;
 142   UINT32                                NewVerticalResolution;
 143   UINT32                                NewColumns;
 144   UINT32                                NewRows;
 145   UINTN                                 HandleCount;
 146   EFI_HANDLE                            *HandleBuffer;
 147   EFI_STATUS                            Status;
 148   UINTN                                 Index;
 149   UINTN                                 CurrentColumn;
 150   UINTN                                 CurrentRow;
 151
 152   MaxGopMode  = 0;
 153   MaxTextMode = 0;
 154
 155   //
 156   // Get current video resolution and text mode
 157   //
 158   Status = gBS->HandleProtocol (
 159                   gST->ConsoleOutHandle,
 160                   &gEfiGraphicsOutputProtocolGuid,
 161                   (VOID**)&GraphicsOutput
 162                   );
 163   if (EFI_ERROR (Status)) {
 164     GraphicsOutput = NULL;
 165   }
 166
 167   Status = gBS->HandleProtocol (
 168                   gST->ConsoleOutHandle,
 169                   &gEfiSimpleTextOutProtocolGuid,
 170                   (VOID**)&SimpleTextOut
 171                   );
 172   if (EFI_ERROR (Status)) {
 173     SimpleTextOut = NULL;
 174   }
 175
 176   if ((GraphicsOutput == NULL) || (SimpleTextOut == NULL)) {
 177     return EFI_UNSUPPORTED;
 178   }
 179
 180   if (IsSetupMode) {
 181     //
 182     // The required resolution and text mode is setup mode.
 183     //
 184     NewHorizontalResolution = mBmmSetupHorizontalResolution;
 185     NewVerticalResolution   = mBmmSetupVerticalResolution;
 186     NewColumns              = mBmmSetupTextModeColumn;
 187     NewRows                 = mBmmSetupTextModeRow;
 188   } else {
 189     //
 190     // The required resolution and text mode is boot mode.
 191     //
 192     NewHorizontalResolution = mBmmBootHorizontalResolution;
 193     NewVerticalResolution   = mBmmBootVerticalResolution;
 194     NewColumns              = mBmmBootTextModeColumn;
 195     NewRows                 = mBmmBootTextModeRow;
 196   }
 197
 198   if (GraphicsOutput != NULL) {
 199     MaxGopMode  = GraphicsOutput->Mode->MaxMode;
 200   }
 201
 202   if (SimpleTextOut != NULL) {
 203     MaxTextMode = SimpleTextOut->Mode->MaxMode;
 204   }
 205
 206   //
 207   // 1. If current video resolution is same with required video resolution,
 208   //    video resolution need not be changed.
 209   //    1.1. If current text mode is same with required text mode, text mode need not be changed.
 210   //    1.2. If current text mode is different from required text mode, text mode need be changed.
 211   // 2. If current video resolution is different from required video resolution, we need restart whole console drivers.
 212   //
 213   for (ModeNumber = 0; ModeNumber < MaxGopMode; ModeNumber++) {
 214     Status = GraphicsOutput->QueryMode (
 215                        GraphicsOutput,
 216                        ModeNumber,
 217                        &SizeOfInfo,
 218                        &Info
 219                        );
 220     if (!EFI_ERROR (Status)) {
 221       if ((Info->HorizontalResolution == NewHorizontalResolution) &&
 222           (Info->VerticalResolution == NewVerticalResolution)) {
 223         if ((GraphicsOutput->Mode->Info->HorizontalResolution == NewHorizontalResolution) &&
 224             (GraphicsOutput->Mode->Info->VerticalResolution == NewVerticalResolution)) {
 225           //
 226           // Current resolution is same with required resolution, check if text mode need be set
 227           //
 228           Status = SimpleTextOut->QueryMode (SimpleTextOut, SimpleTextOut->Mode->Mode, &CurrentColumn, &CurrentRow);
 229           ASSERT_EFI_ERROR (Status);
 230           if (CurrentColumn == NewColumns && CurrentRow == NewRows) {
 231             //
 232             // If current text mode is same with required text mode. Do nothing
 233             //
 234             FreePool (Info);
 235             return EFI_SUCCESS;
 236           } else {
 237             //
 238             // If current text mode is different from required text mode.  Set new video mode
 239             //
 240             for (Index = 0; Index < MaxTextMode; Index++) {
 241               Status = SimpleTextOut->QueryMode (SimpleTextOut, Index, &CurrentColumn, &CurrentRow);
 242               if (!EFI_ERROR(Status)) {
 243                 if ((CurrentColumn == NewColumns) && (CurrentRow == NewRows)) {
 244                   //
 245                   // Required text mode is supported, set it.
 246                   //
 247                   Status = SimpleTextOut->SetMode (SimpleTextOut, Index);
 248                   ASSERT_EFI_ERROR (Status);
 249                   //
 250                   // Update text mode PCD.
 251                   //
 252                   Status = PcdSet32S (PcdConOutColumn, mBmmSetupTextModeColumn);
 253                   ASSERT_EFI_ERROR (Status);
 254                   Status = PcdSet32S (PcdConOutRow, mBmmSetupTextModeRow);
 255                   ASSERT_EFI_ERROR (Status);
 256                   FreePool (Info);
 257                   return EFI_SUCCESS;
 258                 }
 259               }
 260             }
 261             if (Index == MaxTextMode) {
 262               //
 263               // If required text mode is not supported, return error.
 264               //
 265               FreePool (Info);
 266               return EFI_UNSUPPORTED;
 267             }
 268           }
 269         } else {
 270           //
 271           // If current video resolution is not same with the new one, set new video resolution.
 272           // In this case, the driver which produces simple text out need be restarted.
 273           //
 274           Status = GraphicsOutput->SetMode (GraphicsOutput, ModeNumber);
 275           if (!EFI_ERROR (Status)) {
 276             FreePool (Info);
 277             break;
 278           }
 279         }
 280       }
 281       FreePool (Info);
 282     }
 283   }
 284
 285   if (ModeNumber == MaxGopMode) {
 286     //
 287     // If the resolution is not supported, return error.
 288     //
 289     return EFI_UNSUPPORTED;
 290   }
 291
 292   //
 293   // Set PCD to Inform GraphicsConsole to change video resolution.
 294   // Set PCD to Inform Consplitter to change text mode.
 295   //
 296   Status = PcdSet32S (PcdVideoHorizontalResolution, NewHorizontalResolution);
 297   ASSERT_EFI_ERROR (Status);
 298   Status = PcdSet32S (PcdVideoVerticalResolution, NewVerticalResolution);
 299   ASSERT_EFI_ERROR (Status);
 300   Status = PcdSet32S (PcdConOutColumn, NewColumns);
 301   ASSERT_EFI_ERROR (Status);
 302   Status = PcdSet32S (PcdConOutRow, NewRows);
 303   ASSERT_EFI_ERROR (Status);
 304
 305   //
 306   // Video mode is changed, so restart graphics console driver and higher level driver.
 307   // Reconnect graphics console driver and higher level driver.
 308   // Locate all the handles with GOP protocol and reconnect it.
 309   //
 310   Status = gBS->LocateHandleBuffer (
 311                    ByProtocol,
 312                    &gEfiSimpleTextOutProtocolGuid,
 313                    NULL,
 314                    &HandleCount,
 315                    &HandleBuffer
 316                    );
 317   if (!EFI_ERROR (Status)) {
 318     for (Index = 0; Index < HandleCount; Index++) {
 319       gBS->DisconnectController (HandleBuffer[Index], NULL, NULL);
 320     }
 321     for (Index = 0; Index < HandleCount; Index++) {
 322       gBS->ConnectController (HandleBuffer[Index], NULL, NULL, TRUE);
 323     }
 324     if (HandleBuffer != NULL) {
 325       FreePool (HandleBuffer);
 326     }
 327   }
 328
 329   return EFI_SUCCESS;
 330 }
 331
 332 /**
 333   This function converts an input device structure to a Unicode string.
 334
 335   @param DevPath      A pointer to the device path structure.
 336
 337   @return             A new allocated Unicode string that represents the device path.
 338
 339 **/
 340 CHAR16 *
 341 UiDevicePathToStr (
 342   IN EFI_DEVICE_PATH_PROTOCOL     *DevPath
 343   )
 344 {
 345   EFI_STATUS                       Status;
 346   CHAR16                           *ToText;
 347   EFI_DEVICE_PATH_TO_TEXT_PROTOCOL *DevPathToText;
 348
 349   if (DevPath == NULL) {
 350     return NULL;
 351   }
 352
 353   Status = gBS->LocateProtocol (
 354                   &gEfiDevicePathToTextProtocolGuid,
 355                   NULL,
 356                   (VOID **) &DevPathToText
 357                   );
 358   ASSERT_EFI_ERROR (Status);
 359   ToText = DevPathToText->ConvertDevicePathToText (
 360                             DevPath,
 361                             FALSE,
 362                             TRUE
 363                             );
 364   ASSERT (ToText != NULL);
 365   return ToText;
 366 }
 367
 368 /**
 369   Extract filename from device path. The returned buffer is allocated using AllocateCopyPool.
 370   The caller is responsible for freeing the allocated buffer using FreePool().
 371
 372   @param DevicePath       Device path.
 373
 374   @return                 A new allocated string that represents the file name.
 375
 376 **/
 377 CHAR16 *
 378 ExtractFileNameFromDevicePath (
 379   IN   EFI_DEVICE_PATH_PROTOCOL *DevicePath
 380   )
 381 {
 382   CHAR16          *String;
 383   CHAR16          *MatchString;
 384   CHAR16          *LastMatch;
 385   CHAR16          *FileName;
 386   UINTN           Length;
 387
 388   ASSERT(DevicePath != NULL);
 389
 390   String = UiDevicePathToStr(DevicePath);
 391   MatchString = String;
 392   LastMatch   = String;
 393   FileName    = NULL;
 394
 395   while(MatchString != NULL){
 396     LastMatch   = MatchString + 1;
 397     MatchString = StrStr(LastMatch,L"\\");
 398   }
 399
 400   Length = StrLen(LastMatch);
 401   FileName = AllocateCopyPool ((Length + 1) * sizeof(CHAR16), LastMatch);
 402   if (FileName != NULL) {
 403     *(FileName + Length) = 0;
 404   }
 405
 406   FreePool(String);
 407
 408   return FileName;
 409 }
 410
 411 /**
 412   Extract device path for given HII handle and class guid.
 413
 414   @param Handle          The HII handle.
 415
 416   @retval  NULL          Fail to get the device path string.
 417   @return  PathString    Get the device path string.
 418
 419 **/
 420 CHAR16 *
 421 BmmExtractDevicePathFromHiiHandle (
 422   IN      EFI_HII_HANDLE      Handle
 423   )
 424 {
 425   EFI_STATUS                       Status;
 426   EFI_HANDLE                       DriverHandle;
 427
 428   ASSERT (Handle != NULL);
 429
 430   if (Handle == NULL) {
 431     return NULL;
 432   }
 433
 434   Status = gHiiDatabase->GetPackageListHandle (gHiiDatabase, Handle, &DriverHandle);
 435   if (EFI_ERROR (Status)) {
 436     return NULL;
 437   }
 438
 439   //
 440   // Get device path string.
 441   //
 442   return ConvertDevicePathToText(DevicePathFromHandle (DriverHandle), FALSE, FALSE);
 443
 444 }
 445
 446 /**
 447   Converts the unicode character of the string from uppercase to lowercase.
 448   This is a internal function.
 449
 450   @param ConfigString  String to be converted
 451
 452 **/
 453 VOID
 454 HiiToLower (
 455   IN EFI_STRING  ConfigString
 456   )
 457 {
 458   EFI_STRING  String;
 459   BOOLEAN     Lower;
 460
 461   ASSERT (ConfigString != NULL);
 462
 463   //
 464   // Convert all hex digits in range [A-F] in the configuration header to [a-f]
 465   //
 466   for (String = ConfigString, Lower = FALSE; *String != L'\0'; String++) {
 467     if (*String == L'=') {
 468       Lower = TRUE;
 469     } else if (*String == L'&') {
 470       Lower = FALSE;
 471     } else if (Lower && *String >= L'A' && *String <= L'F') {
 472       *String = (CHAR16) (*String - L'A' + L'a');
 473     }
 474   }
 475 }
 476
 477 /**
 478   Update the progress string through the offset value.
 479
 480   @param Offset           The offset value
 481   @param Configuration    Point to the configuration string.
 482
 483 **/
 484 EFI_STRING
 485 UpdateProgress(
 486   IN  UINTN       Offset,
 487   IN  EFI_STRING  Configuration
 488 )
 489 {
 490   UINTN       Length;
 491   EFI_STRING  StringPtr;
 492   EFI_STRING  ReturnString;
 493
 494   StringPtr    = NULL;
 495   ReturnString = NULL;
 496
 497   //
 498   // &OFFSET=XXXX followed by a Null-terminator.
 499   // Length = StrLen (L"&OFFSET=") + 4 + 1
 500   //
 501   Length    = StrLen (L"&OFFSET=") + 4 + 1;
 502
 503   StringPtr = AllocateZeroPool (Length * sizeof (CHAR16));
 504
 505   if (StringPtr == NULL) {
 506     return  NULL;
 507   }
 508
 509   UnicodeSPrint (
 510     StringPtr,
 511     (8 + 4 + 1) * sizeof (CHAR16),
 512     L"&OFFSET=%04x",
 513     Offset
 514     );
 515
 516   ReturnString = StrStr (Configuration, StringPtr);
 517
 518   if (ReturnString == NULL) {
 519     //
 520     // If doesn't find the string in Configuration, convert the string to lower case then search again.
 521     //
 522     HiiToLower (StringPtr);
 523     ReturnString = StrStr (Configuration, StringPtr);
 524   }
 525
 526   FreePool (StringPtr);
 527
 528   return ReturnString;
 529 }
 530
 531 /**
 532   Update the terminal content in TerminalMenu.
 533
 534   @param BmmData           The BMM fake NV data.
 535
 536 **/
 537 VOID
 538 UpdateTerminalContent (
 539   IN BMM_FAKE_NV_DATA       *BmmData
 540   )
 541 {
 542   UINT16                          Index;
 543   BM_TERMINAL_CONTEXT             *NewTerminalContext;
 544   BM_MENU_ENTRY                   *NewMenuEntry;
 545
 546   for (Index = 0; Index < TerminalMenu.MenuNumber; Index++) {
 547     NewMenuEntry = BOpt_GetMenuEntry (&TerminalMenu, Index);
 548     ASSERT (NewMenuEntry != NULL);
 549     NewTerminalContext = (BM_TERMINAL_CONTEXT *) NewMenuEntry->VariableContext;
 550     NewTerminalContext->BaudRateIndex = BmmData->COMBaudRate[Index];
 551     ASSERT (BmmData->COMBaudRate[Index] < (sizeof (BaudRateList) / sizeof (BaudRateList[0])));
 552     NewTerminalContext->BaudRate      = BaudRateList[BmmData->COMBaudRate[Index]].Value;
 553     NewTerminalContext->DataBitsIndex = BmmData->COMDataRate[Index];
 554     ASSERT (BmmData->COMDataRate[Index] < (sizeof (DataBitsList) / sizeof (DataBitsList[0])));
 555     NewTerminalContext->DataBits      = (UINT8) DataBitsList[BmmData->COMDataRate[Index]].Value;
 556     NewTerminalContext->StopBitsIndex = BmmData->COMStopBits[Index];
 557     ASSERT (BmmData->COMStopBits[Index] < (sizeof (StopBitsList) / sizeof (StopBitsList[0])));
 558     NewTerminalContext->StopBits      = (UINT8) StopBitsList[BmmData->COMStopBits[Index]].Value;
 559     NewTerminalContext->ParityIndex   = BmmData->COMParity[Index];
 560     ASSERT (BmmData->COMParity[Index] < (sizeof (ParityList) / sizeof (ParityList[0])));
 561     NewTerminalContext->Parity        = (UINT8) ParityList[BmmData->COMParity[Index]].Value;
 562     NewTerminalContext->TerminalType  = BmmData->COMTerminalType[Index];
 563     NewTerminalContext->FlowControl   = BmmData->COMFlowControl[Index];
 564     ChangeTerminalDevicePath (
 565       NewTerminalContext->DevicePath,
 566       FALSE
 567       );
 568   }
 569 }
 570
 571 /**
 572   Update the console content in ConsoleMenu.
 573
 574   @param BmmData           The BMM fake NV data.
 575
 576 **/
 577 VOID
 578 UpdateConsoleContent(
 579   IN CHAR16                 *ConsoleName,
 580   IN BMM_FAKE_NV_DATA       *BmmData
 581   )
 582 {
 583   UINT16                          Index;
 584   BM_CONSOLE_CONTEXT              *NewConsoleContext;
 585   BM_TERMINAL_CONTEXT             *NewTerminalContext;
 586   BM_MENU_ENTRY                   *NewMenuEntry;
 587
 588   if (StrCmp (ConsoleName, L"ConIn") == 0) {
 589     for (Index = 0; Index < ConsoleInpMenu.MenuNumber; Index++){
 590       NewMenuEntry                = BOpt_GetMenuEntry(&ConsoleInpMenu, Index);
 591       NewConsoleContext           = (BM_CONSOLE_CONTEXT *)NewMenuEntry->VariableContext;
 592       ASSERT (Index < MAX_MENU_NUMBER);
 593       NewConsoleContext->IsActive = BmmData->ConsoleInCheck[Index];
 594     }
 595     for (Index = 0; Index < TerminalMenu.MenuNumber; Index++) {
 596       NewMenuEntry                = BOpt_GetMenuEntry (&TerminalMenu, Index);
 597       NewTerminalContext          = (BM_TERMINAL_CONTEXT *) NewMenuEntry->VariableContext;
 598       ASSERT (Index + ConsoleInpMenu.MenuNumber < MAX_MENU_NUMBER);
 599       NewTerminalContext->IsConIn = BmmData->ConsoleInCheck[Index + ConsoleInpMenu.MenuNumber];
 600     }
 601   }
 602
 603   if (StrCmp (ConsoleName, L"ConOut") == 0) {
 604     for (Index = 0; Index < ConsoleOutMenu.MenuNumber; Index++){
 605       NewMenuEntry                = BOpt_GetMenuEntry(&ConsoleOutMenu, Index);
 606       NewConsoleContext           = (BM_CONSOLE_CONTEXT *)NewMenuEntry->VariableContext;
 607       ASSERT (Index < MAX_MENU_NUMBER);
 608       NewConsoleContext->IsActive = BmmData->ConsoleOutCheck[Index];
 609     }
 610     for (Index = 0; Index < TerminalMenu.MenuNumber; Index++) {
 611       NewMenuEntry                = BOpt_GetMenuEntry (&TerminalMenu, Index);
 612       NewTerminalContext          = (BM_TERMINAL_CONTEXT *) NewMenuEntry->VariableContext;
 613       ASSERT (Index + ConsoleOutMenu.MenuNumber < MAX_MENU_NUMBER);
 614       NewTerminalContext->IsConOut = BmmData->ConsoleOutCheck[Index + ConsoleOutMenu.MenuNumber];
 615     }
 616   }
 617   if (StrCmp (ConsoleName, L"ErrOut") == 0) {
 618     for (Index = 0; Index < ConsoleErrMenu.MenuNumber; Index++){
 619       NewMenuEntry                = BOpt_GetMenuEntry(&ConsoleErrMenu, Index);
 620       NewConsoleContext           = (BM_CONSOLE_CONTEXT *)NewMenuEntry->VariableContext;
 621       ASSERT (Index < MAX_MENU_NUMBER);
 622       NewConsoleContext->IsActive = BmmData->ConsoleErrCheck[Index];
 623     }
 624     for (Index = 0; Index < TerminalMenu.MenuNumber; Index++) {
 625       NewMenuEntry                = BOpt_GetMenuEntry (&TerminalMenu, Index);
 626       NewTerminalContext          = (BM_TERMINAL_CONTEXT *) NewMenuEntry->VariableContext;
 627       ASSERT (Index + ConsoleErrMenu.MenuNumber < MAX_MENU_NUMBER);
 628       NewTerminalContext->IsStdErr = BmmData->ConsoleErrCheck[Index + ConsoleErrMenu.MenuNumber];
 629     }
 630   }
 631 }
 632
 633 /**
 634   This function allows a caller to extract the current configuration for one
 635   or more named elements from the target driver.
 636
 637   @param This            Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
 638   @param Request         A null-terminated Unicode string in <ConfigRequest> format.
 639   @param Progress        On return, points to a character in the Request string.
 640                          Points to the string's null terminator if request was successful.
 641                          Points to the most recent '&' before the first failing name/value
 642                          pair (or the beginning of the string if the failure is in the
 643                          first name/value pair) if the request was not successful.
 644   @param Results         A null-terminated Unicode string in <ConfigAltResp> format which
 645                          has all values filled in for the names in the Request string.
 646                          String to be allocated by the called function.
 647
 648   @retval  EFI_SUCCESS            The Results is filled with the requested values.
 649   @retval  EFI_OUT_OF_RESOURCES   Not enough memory to store the results.
 650   @retval  EFI_INVALID_PARAMETER  Request is NULL, illegal syntax, or unknown name.
 651   @retval  EFI_NOT_FOUND          Routing data doesn't match any storage in this driver.
 652
 653 **/
 654 EFI_STATUS
 655 EFIAPI
 656 BootMaintExtractConfig (
 657   IN  CONST EFI_HII_CONFIG_ACCESS_PROTOCOL   *This,
 658   IN  CONST EFI_STRING                       Request,
 659   OUT EFI_STRING                             *Progress,
 660   OUT EFI_STRING                             *Results
 661   )
 662 {
 663   EFI_STATUS         Status;
 664   UINTN              BufferSize;
 665   BMM_CALLBACK_DATA  *Private;
 666   EFI_STRING                       ConfigRequestHdr;
 667   EFI_STRING                       ConfigRequest;
 668   BOOLEAN                          AllocatedRequest;
 669   UINTN                            Size;
 670
 671   if (Progress == NULL || Results == NULL) {
 672     return EFI_INVALID_PARAMETER;
 673   }
 674
 675   *Progress = Request;
 676   if ((Request != NULL) && !HiiIsConfigHdrMatch (Request, &mBootMaintGuid, mBootMaintStorageName)) {
 677     return EFI_NOT_FOUND;
 678   }
 679
 680   ConfigRequestHdr = NULL;
 681   ConfigRequest    = NULL;
 682   AllocatedRequest = FALSE;
 683   Size             = 0;
 684
 685   Private = BMM_CALLBACK_DATA_FROM_THIS (This);
 686   //
 687   // Convert buffer data to <ConfigResp> by helper function BlockToConfig()
 688   //
 689   BufferSize = sizeof (BMM_FAKE_NV_DATA);
 690   ConfigRequest = Request;
 691   if ((Request == NULL) || (StrStr (Request, L"OFFSET") == NULL)) {
 692     //
 693     // Request has no request element, construct full request string.
 694     // Allocate and fill a buffer large enough to hold the <ConfigHdr> template
 695     // followed by "&OFFSET=0&WIDTH=WWWWWWWWWWWWWWWW" followed by a Null-terminator
 696     //
 697     ConfigRequestHdr = HiiConstructConfigHdr (&mBootMaintGuid, mBootMaintStorageName, Private->BmmDriverHandle);
 698     Size = (StrLen (ConfigRequestHdr) + 32 + 1) * sizeof (CHAR16);
 699     ConfigRequest = AllocateZeroPool (Size);
 700     ASSERT (ConfigRequest != NULL);
 701     AllocatedRequest = TRUE;
 702     UnicodeSPrint (ConfigRequest, Size, L"%s&OFFSET=0&WIDTH=%016LX", ConfigRequestHdr, (UINT64)BufferSize);
 703     FreePool (ConfigRequestHdr);
 704   }
 705
 706   Status = gHiiConfigRouting->BlockToConfig (
 707                                 gHiiConfigRouting,
 708                                 ConfigRequest,
 709                                 (UINT8 *) &Private->BmmFakeNvData,
 710                                 BufferSize,
 711                                 Results,
 712                                 Progress
 713                                 );
 714   //
 715   // Free the allocated config request string.
 716   //
 717   if (AllocatedRequest) {
 718     FreePool (ConfigRequest);
 719     ConfigRequest = NULL;
 720   }
 721   //
 722   // Set Progress string to the original request string.
 723   //
 724   if (Request == NULL) {
 725     *Progress = NULL;
 726   } else if (StrStr (Request, L"OFFSET") == NULL) {
 727     *Progress = Request + StrLen (Request);
 728   }
 729
 730   return Status;
 731 }
 732
 733 /**
 734   This function applies changes in a driver's configuration.
 735   Input is a Configuration, which has the routing data for this
 736   driver followed by name / value configuration pairs. The driver
 737   must apply those pairs to its configurable storage. If the
 738   driver's configuration is stored in a linear block of data
 739   and the driver's name / value pairs are in <BlockConfig>
 740   format, it may use the ConfigToBlock helper function (above) to
 741   simplify the job. Currently not implemented.
 742
 743   @param[in]  This                Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
 744   @param[in]  Configuration       A null-terminated Unicode string in
 745                                   <ConfigString> format.
 746   @param[out] Progress            A pointer to a string filled in with the
 747                                   offset of the most recent '&' before the
 748                                   first failing name / value pair (or the
 749                                   beginn ing of the string if the failure
 750                                   is in the first name / value pair) or
 751                                   the terminating NULL if all was
 752                                   successful.
 753
 754   @retval EFI_SUCCESS             The results have been distributed or are
 755                                   awaiting distribution.
 756   @retval EFI_OUT_OF_RESOURCES    Not enough memory to store the
 757                                   parts of the results that must be
 758                                   stored awaiting possible future
 759                                   protocols.
 760   @retval EFI_INVALID_PARAMETERS  Passing in a NULL for the
 761                                   Results parameter would result
 762                                   in this type of error.
 763   @retval EFI_NOT_FOUND           Target for the specified routing data
 764                                   was not found.
 765 **/
 766 EFI_STATUS
 767 EFIAPI
 768 BootMaintRouteConfig (
 769   IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This,
 770   IN CONST EFI_STRING                     Configuration,
 771   OUT EFI_STRING                          *Progress
 772   )
 773 {
 774   EFI_STATUS                      Status;
 775   UINTN                           BufferSize;
 776   EFI_HII_CONFIG_ROUTING_PROTOCOL *ConfigRouting;
 777   BMM_FAKE_NV_DATA                *NewBmmData;
 778   BMM_FAKE_NV_DATA                *OldBmmData;
 779   BM_MENU_ENTRY                   *NewMenuEntry;
 780   BM_LOAD_CONTEXT                 *NewLoadContext;
 781   UINT16                          Index;
 782   BOOLEAN                         TerminalAttChange;
 783   BMM_CALLBACK_DATA               *Private;
 784   UINTN                           Offset;
 785
 786   if (Progress == NULL) {
 787     return EFI_INVALID_PARAMETER;
 788   }
 789   *Progress = Configuration;
 790
 791   if (Configuration == NULL) {
 792     return EFI_INVALID_PARAMETER;
 793   }
 794
 795   //
 796   // Check routing data in <ConfigHdr>.
 797   // Note: there is no name for Name/Value storage, only GUID will be checked
 798   //
 799   if (!HiiIsConfigHdrMatch (Configuration, &mBootMaintGuid, mBootMaintStorageName)) {
 800     return EFI_NOT_FOUND;
 801   }
 802
 803   Status = gBS->LocateProtocol (
 804                   &gEfiHiiConfigRoutingProtocolGuid,
 805                   NULL,
 806                   (VOID **)&ConfigRouting
 807                   );
 808   if (EFI_ERROR (Status)) {
 809     return Status;
 810   }
 811
 812   Private = BMM_CALLBACK_DATA_FROM_THIS (This);
 813   //
 814   // Get Buffer Storage data from EFI variable
 815   //
 816   BufferSize = sizeof (BMM_FAKE_NV_DATA);
 817   OldBmmData = &Private->BmmOldFakeNVData;
 818   NewBmmData = &Private->BmmFakeNvData;
 819   Offset     = 0;
 820   //
 821   // Convert <ConfigResp> to buffer data by helper function ConfigToBlock()
 822   //
 823   Status = ConfigRouting->ConfigToBlock (
 824                             ConfigRouting,
 825                             Configuration,
 826                             (UINT8 *) NewBmmData,
 827                             &BufferSize,
 828                             Progress
 829                             );
 830   ASSERT_EFI_ERROR (Status);
 831   //
 832   // Compare new and old BMM configuration data and only do action for modified item to
 833   // avoid setting unnecessary non-volatile variable
 834   //
 835
 836   //
 837   // Check data which located in BMM main page and save the settings if need
 838   //
 839   if (CompareMem (&NewBmmData->BootNext, &OldBmmData->BootNext, sizeof (NewBmmData->BootNext)) != 0) {
 840     Status = Var_UpdateBootNext (Private);
 841     if (EFI_ERROR (Status)) {
 842       Offset = OFFSET_OF (BMM_FAKE_NV_DATA, BootNext);
 843       goto Exit;
 844     }
 845   }
 846
 847   //
 848   // Check data which located in Boot Options Menu and save the settings if need
 849   //
 850   if (CompareMem (NewBmmData->BootOptionDel, OldBmmData->BootOptionDel, sizeof (NewBmmData->BootOptionDel)) != 0) {
 851     for (Index = 0;
 852          ((Index < BootOptionMenu.MenuNumber) && (Index < (sizeof (NewBmmData->BootOptionDel) / sizeof (NewBmmData->BootOptionDel[0]))));
 853          Index ++) {
 854       NewMenuEntry            = BOpt_GetMenuEntry (&BootOptionMenu, Index);
 855       NewLoadContext          = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
 856       NewLoadContext->Deleted = NewBmmData->BootOptionDel[Index];
 857       NewBmmData->BootOptionDel[Index] = FALSE;
 858       NewBmmData->BootOptionDelMark[Index] = FALSE;
 859     }
 860
 861     Status = Var_DelBootOption ();
 862     if (EFI_ERROR (Status)) {
 863       Offset = OFFSET_OF (BMM_FAKE_NV_DATA, BootOptionDel);
 864       goto Exit;
 865     }
 866   }
 867
 868   if (CompareMem (NewBmmData->BootOptionOrder, OldBmmData->BootOptionOrder, sizeof (NewBmmData->BootOptionOrder)) != 0) {
 869     Status = Var_UpdateBootOrder (Private);
 870     if (EFI_ERROR (Status)) {
 871       Offset = OFFSET_OF (BMM_FAKE_NV_DATA, BootOptionOrder);
 872       goto Exit;
 873     }
 874   }
 875
 876   if (CompareMem (&NewBmmData->BootTimeOut, &OldBmmData->BootTimeOut, sizeof (NewBmmData->BootTimeOut)) != 0){
 877     Status = gRT->SetVariable(
 878                     L"Timeout",
 879                     &gEfiGlobalVariableGuid,
 880                     EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,
 881                     sizeof(UINT16),
 882                     &(NewBmmData->BootTimeOut)
 883                     );
 884     if (EFI_ERROR (Status)) {
 885       Offset = OFFSET_OF (BMM_FAKE_NV_DATA, BootTimeOut);
 886       goto Exit;
 887     }
 888     Private->BmmOldFakeNVData.BootTimeOut = NewBmmData->BootTimeOut;
 889   }
 890
 891   //
 892   // Check data which located in Driver Options Menu and save the settings if need
 893   //
 894   if (CompareMem (NewBmmData->DriverOptionDel, OldBmmData->DriverOptionDel, sizeof (NewBmmData->DriverOptionDel)) != 0) {
 895     for (Index = 0;
 896          ((Index < DriverOptionMenu.MenuNumber) && (Index < (sizeof (NewBmmData->DriverOptionDel) / sizeof (NewBmmData->DriverOptionDel[0]))));
 897          Index++) {
 898       NewMenuEntry            = BOpt_GetMenuEntry (&DriverOptionMenu, Index);
 899       NewLoadContext          = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
 900       NewLoadContext->Deleted = NewBmmData->DriverOptionDel[Index];
 901       NewBmmData->DriverOptionDel[Index] = FALSE;
 902       NewBmmData->DriverOptionDelMark[Index] = FALSE;
 903     }
 904     Status = Var_DelDriverOption ();
 905     if (EFI_ERROR (Status)) {
 906       Offset = OFFSET_OF (BMM_FAKE_NV_DATA, DriverOptionDel);
 907       goto Exit;
 908     }
 909   }
 910
 911   if (CompareMem (NewBmmData->DriverOptionOrder, OldBmmData->DriverOptionOrder, sizeof (NewBmmData->DriverOptionOrder)) != 0) {
 912     Status = Var_UpdateDriverOrder (Private);
 913     if (EFI_ERROR (Status)) {
 914       Offset = OFFSET_OF (BMM_FAKE_NV_DATA, DriverOptionOrder);
 915       goto Exit;
 916     }
 917   }
 918
 919   if (CompareMem (&NewBmmData->ConsoleOutMode, &OldBmmData->ConsoleOutMode, sizeof (NewBmmData->ConsoleOutMode)) != 0){
 920     Status = Var_UpdateConMode(Private);
 921     if (EFI_ERROR (Status)) {
 922       Offset = OFFSET_OF (BMM_FAKE_NV_DATA, ConsoleOutMode);
 923       goto Exit;
 924     }
 925   }
 926
 927   TerminalAttChange = FALSE;
 928   for (Index = 0; Index < TerminalMenu.MenuNumber; Index++) {
 929
 930     //
 931     // only need update modified items
 932     //
 933     if (CompareMem (&NewBmmData->COMBaudRate[Index], &OldBmmData->COMBaudRate[Index], sizeof (NewBmmData->COMBaudRate[Index])) == 0 &&
 934          CompareMem (&NewBmmData->COMDataRate[Index], &OldBmmData->COMDataRate[Index], sizeof (NewBmmData->COMDataRate[Index])) == 0 &&
 935          CompareMem (&NewBmmData->COMStopBits[Index], &OldBmmData->COMStopBits[Index], sizeof (NewBmmData->COMStopBits[Index])) == 0 &&
 936          CompareMem (&NewBmmData->COMParity[Index], &OldBmmData->COMParity[Index], sizeof (NewBmmData->COMParity[Index])) == 0 &&
 937          CompareMem (&NewBmmData->COMTerminalType[Index], &OldBmmData->COMTerminalType[Index], sizeof (NewBmmData->COMTerminalType[Index])) == 0 &&
 938          CompareMem (&NewBmmData->COMFlowControl[Index], &OldBmmData->COMFlowControl[Index], sizeof (NewBmmData->COMFlowControl[Index])) == 0) {
 939       continue;
 940     }
 941
 942     TerminalAttChange = TRUE;
 943   }
 944   if (TerminalAttChange) {
 945     if (CompareMem (&NewBmmData->COMBaudRate[Index], &OldBmmData->COMBaudRate[Index], sizeof (NewBmmData->COMBaudRate[Index])) != 0) {
 946       Offset = OFFSET_OF (BMM_FAKE_NV_DATA, COMBaudRate);
 947     } else if (CompareMem (&NewBmmData->COMDataRate[Index], &OldBmmData->COMDataRate[Index], sizeof (NewBmmData->COMDataRate[Index])) != 0) {
 948       Offset = OFFSET_OF (BMM_FAKE_NV_DATA, COMDataRate);
 949     } else if (CompareMem (&NewBmmData->COMStopBits[Index], &OldBmmData->COMStopBits[Index], sizeof (NewBmmData->COMStopBits[Index])) != 0) {
 950       Offset = OFFSET_OF (BMM_FAKE_NV_DATA, COMStopBits);
 951     } else if (CompareMem (&NewBmmData->COMParity[Index], &OldBmmData->COMParity[Index], sizeof (NewBmmData->COMParity[Index])) != 0) {
 952       Offset = OFFSET_OF (BMM_FAKE_NV_DATA, COMParity);
 953     } else if (CompareMem (&NewBmmData->COMTerminalType[Index], &OldBmmData->COMTerminalType[Index], sizeof (NewBmmData->COMTerminalType[Index])) != 0) {
 954       Offset = OFFSET_OF (BMM_FAKE_NV_DATA, COMTerminalType);
 955     } else if (CompareMem (&NewBmmData->COMFlowControl[Index], &OldBmmData->COMFlowControl[Index], sizeof (NewBmmData->COMFlowControl[Index])) != 0) {
 956       Offset = OFFSET_OF (BMM_FAKE_NV_DATA, COMFlowControl);
 957     }
 958     Status = Var_UpdateConsoleInpOption ();
 959     if (EFI_ERROR (Status)) {
 960       goto Exit;
 961     }
 962     Status = Var_UpdateConsoleOutOption ();
 963     if (EFI_ERROR (Status)) {
 964       goto Exit;
 965     }
 966     Status = Var_UpdateErrorOutOption ();
 967     if (EFI_ERROR (Status)) {
 968       goto Exit;
 969     }
 970   }
 971   //
 972   // Check data which located in Console Options Menu and save the settings if need
 973   //
 974   if (CompareMem (NewBmmData->ConsoleInCheck, OldBmmData->ConsoleInCheck, sizeof (NewBmmData->ConsoleInCheck)) != 0){
 975     Status = Var_UpdateConsoleInpOption();
 976     if (EFI_ERROR (Status)) {
 977       Offset = OFFSET_OF (BMM_FAKE_NV_DATA, ConsoleInCheck);
 978       goto Exit;
 979     }
 980   }
 981
 982   if (CompareMem (NewBmmData->ConsoleOutCheck, OldBmmData->ConsoleOutCheck, sizeof (NewBmmData->ConsoleOutCheck)) != 0){
 983     Status = Var_UpdateConsoleOutOption();
 984     if (EFI_ERROR (Status)) {
 985       Offset = OFFSET_OF (BMM_FAKE_NV_DATA, ConsoleOutCheck);
 986       goto Exit;
 987     }
 988   }
 989
 990   if (CompareMem (NewBmmData->ConsoleErrCheck, OldBmmData->ConsoleErrCheck, sizeof (NewBmmData->ConsoleErrCheck)) != 0){
 991     Status = Var_UpdateErrorOutOption();
 992     if (EFI_ERROR (Status)) {
 993       Offset = OFFSET_OF (BMM_FAKE_NV_DATA, ConsoleErrCheck);
 994       goto Exit;
 995     }
 996   }
 997
 998   if (CompareMem (NewBmmData->BootDescriptionData, OldBmmData->BootDescriptionData, sizeof (NewBmmData->BootDescriptionData)) != 0 ||
 999        CompareMem (NewBmmData->BootOptionalData, OldBmmData->BootOptionalData, sizeof (NewBmmData->BootOptionalData)) != 0) {
1000     Status = Var_UpdateBootOption (Private);
1001     NewBmmData->BootOptionChanged = FALSE;
1002     if (EFI_ERROR (Status)) {
1003       if (CompareMem (NewBmmData->BootDescriptionData, OldBmmData->BootDescriptionData, sizeof (NewBmmData->BootDescriptionData)) != 0) {
1004         Offset = OFFSET_OF (BMM_FAKE_NV_DATA, BootDescriptionData);
1005       } else {
1006         Offset = OFFSET_OF (BMM_FAKE_NV_DATA, BootOptionalData);
1007       }
1008       goto Exit;
1009     }
1010     BOpt_GetBootOptions (Private);
1011   }
1012
1013   if (CompareMem (NewBmmData->DriverDescriptionData, OldBmmData->DriverDescriptionData, sizeof (NewBmmData->DriverDescriptionData)) != 0 ||
1014        CompareMem (NewBmmData->DriverOptionalData, OldBmmData->DriverOptionalData, sizeof (NewBmmData->DriverOptionalData)) != 0) {
1015     Status = Var_UpdateDriverOption (
1016               Private,
1017               Private->BmmHiiHandle,
1018               NewBmmData->DriverDescriptionData,
1019               NewBmmData->DriverOptionalData,
1020               NewBmmData->ForceReconnect
1021               );
1022     NewBmmData->DriverOptionChanged = FALSE;
1023     NewBmmData->ForceReconnect      = TRUE;
1024     if (EFI_ERROR (Status)) {
1025       if (CompareMem (NewBmmData->DriverDescriptionData, OldBmmData->DriverDescriptionData, sizeof (NewBmmData->DriverDescriptionData)) != 0) {
1026         Offset = OFFSET_OF (BMM_FAKE_NV_DATA, DriverDescriptionData);
1027       } else {
1028         Offset = OFFSET_OF (BMM_FAKE_NV_DATA, DriverOptionalData);
1029       }
1030       goto Exit;
1031     }
1032
1033     BOpt_GetDriverOptions (Private);
1034   }
1035
1036   //
1037   // After user do the save action, need to update OldBmmData.
1038   //
1039   CopyMem (OldBmmData, NewBmmData, sizeof (BMM_FAKE_NV_DATA));
1040
1041   return EFI_SUCCESS;
1042
1043 Exit:
1044   //
1045   // Fail to save the data, update the progress string.
1046   //
1047   *Progress = UpdateProgress (Offset, Configuration);
1048   if (Status == EFI_OUT_OF_RESOURCES) {
1049     return Status;
1050   } else {
1051     return EFI_NOT_FOUND;
1052   }
1053 }
1054
1055 /**
1056   This function processes the results of changes in configuration.
1057
1058
1059   @param This               Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
1060   @param Action             Specifies the type of action taken by the browser.
1061   @param QuestionId         A unique value which is sent to the original exporting driver
1062                             so that it can identify the type of data to expect.
1063   @param Type               The type of value for the question.
1064   @param Value              A pointer to the data being sent to the original exporting driver.
1065   @param ActionRequest      On return, points to the action requested by the callback function.
1066
1067   @retval EFI_SUCCESS           The callback successfully handled the action.
1068   @retval EFI_OUT_OF_RESOURCES  Not enough storage is available to hold the variable and its data.
1069   @retval EFI_DEVICE_ERROR      The variable could not be saved.
1070   @retval EFI_UNSUPPORTED       The specified Action is not supported by the callback.
1071   @retval EFI_INVALID_PARAMETER The parameter of Value or ActionRequest is invalid.
1072 **/
1073 EFI_STATUS
1074 EFIAPI
1075 BootMaintCallback (
1076   IN  CONST EFI_HII_CONFIG_ACCESS_PROTOCOL         *This,
1077   IN        EFI_BROWSER_ACTION                     Action,
1078   IN        EFI_QUESTION_ID                        QuestionId,
1079   IN        UINT8                                  Type,
1080   IN        EFI_IFR_TYPE_VALUE                     *Value,
1081   OUT       EFI_BROWSER_ACTION_REQUEST             *ActionRequest
1082   )
1083 {
1084   BMM_CALLBACK_DATA *Private;
1085   BM_MENU_ENTRY     *NewMenuEntry;
1086   BMM_FAKE_NV_DATA  *CurrentFakeNVMap;
1087   BMM_FAKE_NV_DATA  *OldFakeNVMap;
1088   UINTN             Index;
1089   EFI_DEVICE_PATH_PROTOCOL * File;
1090
1091   if (Action != EFI_BROWSER_ACTION_CHANGING && Action != EFI_BROWSER_ACTION_CHANGED && Action != EFI_BROWSER_ACTION_FORM_OPEN) {
1092     //
1093     // Do nothing for other UEFI Action. Only do call back when data is changed or the form is open.
1094     //
1095     return EFI_UNSUPPORTED;
1096   }
1097
1098   Private        = BMM_CALLBACK_DATA_FROM_THIS (This);
1099
1100   if (Action == EFI_BROWSER_ACTION_FORM_OPEN) {
1101     if (QuestionId == KEY_VALUE_TRIGGER_FORM_OPEN_ACTION) {
1102       if (!mFirstEnterBMMForm) {
1103         //
1104         // BMMUiLib depends on LegacyUi library to show legacy menus.
1105         // If we want to show Legacy menus correctly in BMM page,
1106         // we must do it after the LegacyUi library has already been initialized.
1107         // Opening the BMM form is the appropriate time that the LegacyUi library has already been initialized.
1108         // So we do the tasks which are related to legacy menus here.
1109         // 1. Update the menus (including legacy munu) show in BootMiantenanceManager page.
1110         // 2. Re-scan the BootOption menus (including the legacy boot option).
1111         //
1112         CustomizeMenus ();
1113         BOpt_GetBootOptions (Private);
1114         mFirstEnterBMMForm = TRUE;
1115       }
1116     }
1117   }
1118   //
1119   // Retrive uncommitted data from Form Browser
1120   //
1121   CurrentFakeNVMap = &Private->BmmFakeNvData;
1122   OldFakeNVMap     = &Private->BmmOldFakeNVData;
1123   HiiGetBrowserData (&mBootMaintGuid, mBootMaintStorageName, sizeof (BMM_FAKE_NV_DATA), (UINT8 *) CurrentFakeNVMap);
1124
1125   if (Action == EFI_BROWSER_ACTION_CHANGING) {
1126     if (Value == NULL) {
1127       return EFI_INVALID_PARAMETER;
1128     }
1129
1130     UpdatePageId (Private, QuestionId);
1131
1132     if (QuestionId < FILE_OPTION_OFFSET) {
1133       if (QuestionId < CONFIG_OPTION_OFFSET) {
1134         switch (QuestionId) {
1135         case FORM_BOOT_ADD_ID:
1136           // Leave BMM and enter FileExplorer.
1137           ChooseFile (NULL, L".efi", CreateBootOptionFromFile, &File);
1138           break;
1139
1140         case FORM_DRV_ADD_FILE_ID:
1141           // Leave BMM and enter FileExplorer.
1142           ChooseFile (NULL, L".efi", CreateDriverOptionFromFile, &File);
1143           break;
1144
1145         case FORM_DRV_ADD_HANDLE_ID:
1146           CleanUpPage (FORM_DRV_ADD_HANDLE_ID, Private);
1147           UpdateDrvAddHandlePage (Private);
1148           break;
1149
1150         case FORM_BOOT_DEL_ID:
1151           CleanUpPage (FORM_BOOT_DEL_ID, Private);
1152           UpdateBootDelPage (Private);
1153           break;
1154
1155         case FORM_BOOT_CHG_ID:
1156         case FORM_DRV_CHG_ID:
1157           UpdatePageBody (QuestionId, Private);
1158           break;
1159
1160         case FORM_DRV_DEL_ID:
1161           CleanUpPage (FORM_DRV_DEL_ID, Private);
1162           UpdateDrvDelPage (Private);
1163           break;
1164
1165         case FORM_CON_IN_ID:
1166         case FORM_CON_OUT_ID:
1167         case FORM_CON_ERR_ID:
1168           UpdatePageBody (QuestionId, Private);
1169           break;
1170
1171         case FORM_CON_MODE_ID:
1172           CleanUpPage (FORM_CON_MODE_ID, Private);
1173           UpdateConModePage (Private);
1174           break;
1175
1176         case FORM_CON_COM_ID:
1177           CleanUpPage (FORM_CON_COM_ID, Private);
1178           UpdateConCOMPage (Private);
1179           break;
1180
1181         default:
1182           break;
1183         }
1184       } else if ((QuestionId >= TERMINAL_OPTION_OFFSET) && (QuestionId < CONSOLE_OPTION_OFFSET)) {
1185         Index                  = (UINT16) (QuestionId - TERMINAL_OPTION_OFFSET);
1186         Private->CurrentTerminal  = Index;
1187
1188         CleanUpPage (FORM_CON_COM_SETUP_ID, Private);
1189         UpdateTerminalPage (Private);
1190
1191       } else if (QuestionId >= HANDLE_OPTION_OFFSET) {
1192         Index                  = (UINT16) (QuestionId - HANDLE_OPTION_OFFSET);
1193
1194         NewMenuEntry            = BOpt_GetMenuEntry (&DriverMenu, Index);
1195         ASSERT (NewMenuEntry != NULL);
1196         Private->HandleContext  = (BM_HANDLE_CONTEXT *) NewMenuEntry->VariableContext;
1197
1198         CleanUpPage (FORM_DRV_ADD_HANDLE_DESC_ID, Private);
1199
1200         Private->MenuEntry                  = NewMenuEntry;
1201         Private->LoadContext->FilePathList  = Private->HandleContext->DevicePath;
1202
1203         UpdateDriverAddHandleDescPage (Private);
1204       }
1205     }
1206     if (QuestionId == KEY_VALUE_BOOT_FROM_FILE){
1207       // Leave BMM and enter FileExplorer.
1208       ChooseFile (NULL, L".efi", BootFromFile, &File);
1209     }
1210   } else if (Action == EFI_BROWSER_ACTION_CHANGED) {
1211     if ((Value == NULL) || (ActionRequest == NULL)) {
1212       return EFI_INVALID_PARAMETER;
1213     }
1214
1215     if (QuestionId == KEY_VALUE_SAVE_AND_EXIT_BOOT) {
1216       CurrentFakeNVMap->BootOptionChanged = FALSE;
1217       *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_SUBMIT_EXIT;
1218     } else if (QuestionId == KEY_VALUE_SAVE_AND_EXIT_DRIVER) {
1219       CurrentFakeNVMap->DriverOptionChanged = FALSE;
1220       *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_SUBMIT_EXIT;
1221     } else if (QuestionId == KEY_VALUE_NO_SAVE_AND_EXIT_DRIVER) {
1222       //
1223       // Discard changes and exit formset
1224       //
1225       ZeroMem (CurrentFakeNVMap->DriverOptionalData, sizeof (CurrentFakeNVMap->DriverOptionalData));
1226       ZeroMem (CurrentFakeNVMap->BootDescriptionData, sizeof (CurrentFakeNVMap->BootDescriptionData));
1227       ZeroMem (OldFakeNVMap->DriverOptionalData, sizeof (OldFakeNVMap->DriverOptionalData));
1228       ZeroMem (OldFakeNVMap->DriverDescriptionData, sizeof (OldFakeNVMap->DriverDescriptionData));
1229       CurrentFakeNVMap->DriverOptionChanged = FALSE;
1230       CurrentFakeNVMap->ForceReconnect      = TRUE;
1231       *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_DISCARD_EXIT;
1232     } else if (QuestionId == KEY_VALUE_NO_SAVE_AND_EXIT_BOOT) {
1233       //
1234       // Discard changes and exit formset
1235       //
1236       ZeroMem (CurrentFakeNVMap->BootOptionalData, sizeof (CurrentFakeNVMap->BootOptionalData));
1237       ZeroMem (CurrentFakeNVMap->BootDescriptionData, sizeof (CurrentFakeNVMap->BootDescriptionData));
1238       ZeroMem (OldFakeNVMap->BootOptionalData, sizeof (OldFakeNVMap->BootOptionalData));
1239       ZeroMem (OldFakeNVMap->BootDescriptionData, sizeof (OldFakeNVMap->BootDescriptionData));
1240       CurrentFakeNVMap->BootOptionChanged = FALSE;
1241       *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_DISCARD_EXIT;
1242     } else if (QuestionId == KEY_VALUE_BOOT_DESCRIPTION || QuestionId == KEY_VALUE_BOOT_OPTION) {
1243       CurrentFakeNVMap->BootOptionChanged = TRUE;
1244     } else if (QuestionId == KEY_VALUE_DRIVER_DESCRIPTION || QuestionId == KEY_VALUE_DRIVER_OPTION) {
1245       CurrentFakeNVMap->DriverOptionChanged = TRUE;
1246     }
1247
1248     if ((QuestionId >= BOOT_OPTION_DEL_QUESTION_ID) && (QuestionId < BOOT_OPTION_DEL_QUESTION_ID + MAX_MENU_NUMBER)) {
1249       if (Value->b){
1250         //
1251         // Means user try to delete this boot option but not press F10 or "Commit Changes and Exit" menu.
1252         //
1253         CurrentFakeNVMap->BootOptionDelMark[QuestionId - BOOT_OPTION_DEL_QUESTION_ID] = TRUE;
1254       } else {
1255         //
1256         // Means user remove the old check status.
1257         //
1258         CurrentFakeNVMap->BootOptionDelMark[QuestionId - BOOT_OPTION_DEL_QUESTION_ID] = FALSE;
1259       }
1260     } else if ((QuestionId >= DRIVER_OPTION_DEL_QUESTION_ID) && (QuestionId < DRIVER_OPTION_DEL_QUESTION_ID + MAX_MENU_NUMBER)) {
1261       if (Value->b){
1262         CurrentFakeNVMap->DriverOptionDelMark[QuestionId - DRIVER_OPTION_DEL_QUESTION_ID] = TRUE;
1263       } else {
1264         CurrentFakeNVMap->DriverOptionDelMark[QuestionId - DRIVER_OPTION_DEL_QUESTION_ID] = FALSE;
1265       }
1266     } else {
1267       switch (QuestionId) {
1268       case KEY_VALUE_SAVE_AND_EXIT:
1269       case KEY_VALUE_NO_SAVE_AND_EXIT:
1270         if (QuestionId == KEY_VALUE_SAVE_AND_EXIT) {
1271           *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_SUBMIT_EXIT;
1272         } else if (QuestionId == KEY_VALUE_NO_SAVE_AND_EXIT) {
1273           DiscardChangeHandler (Private, CurrentFakeNVMap);
1274           *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_DISCARD_EXIT;
1275         }
1276
1277         break;
1278
1279       case FORM_RESET:
1280         gRT->ResetSystem (EfiResetCold, EFI_SUCCESS, 0, NULL);
1281         return EFI_UNSUPPORTED;
1282
1283       default:
1284         break;
1285       }
1286     }
1287     //
1288     // Update the content in Terminal menu and Console menu here.
1289     //
1290     if (QuestionId == COM_BAUD_RATE_QUESTION_ID + Private->CurrentTerminal || QuestionId == COM_DATA_RATE_QUESTION_ID + Private->CurrentTerminal ||
1291       QuestionId == COM_PARITY_QUESTION_ID + Private->CurrentTerminal || QuestionId == COM_STOP_BITS_QUESTION_ID + Private->CurrentTerminal ||
1292       QuestionId == COM_TERMINAL_QUESTION_ID + Private->CurrentTerminal || QuestionId == COM_FLOWCONTROL_QUESTION_ID + Private->CurrentTerminal
1293     ) {
1294       UpdateTerminalContent(CurrentFakeNVMap);
1295     }
1296     if ((QuestionId >= CON_IN_DEVICE_QUESTION_ID) && (QuestionId < CON_IN_DEVICE_QUESTION_ID + MAX_MENU_NUMBER)) {
1297       UpdateConsoleContent (L"ConIn",CurrentFakeNVMap);
1298     } else if ((QuestionId >= CON_OUT_DEVICE_QUESTION_ID) && (QuestionId < CON_OUT_DEVICE_QUESTION_ID + MAX_MENU_NUMBER)) {
1299       UpdateConsoleContent (L"ConOut", CurrentFakeNVMap);
1300     } else if ((QuestionId >= CON_ERR_DEVICE_QUESTION_ID) && (QuestionId < CON_ERR_DEVICE_QUESTION_ID + MAX_MENU_NUMBER)) {
1301       UpdateConsoleContent (L"ConErr", CurrentFakeNVMap);
1302     }
1303   }
1304
1305   //
1306   // Pass changed uncommitted data back to Form Browser
1307   //
1308   HiiSetBrowserData (&mBootMaintGuid, mBootMaintStorageName, sizeof (BMM_FAKE_NV_DATA), (UINT8 *) CurrentFakeNVMap, NULL);
1309
1310   return EFI_SUCCESS;
1311 }
1312
1313 /**
1314   Discard all changes done to the BMM pages such as Boot Order change,
1315   Driver order change.
1316
1317   @param Private            The BMM context data.
1318   @param CurrentFakeNVMap   The current Fack NV Map.
1319
1320 **/
1321 VOID
1322 DiscardChangeHandler (
1323   IN  BMM_CALLBACK_DATA               *Private,
1324   IN  BMM_FAKE_NV_DATA                *CurrentFakeNVMap
1325   )
1326 {
1327   UINT16  Index;
1328
1329   switch (Private->BmmPreviousPageId) {
1330   case FORM_BOOT_CHG_ID:
1331     CopyMem (CurrentFakeNVMap->BootOptionOrder, Private->BmmOldFakeNVData.BootOptionOrder, sizeof (CurrentFakeNVMap->BootOptionOrder));
1332     break;
1333
1334   case FORM_DRV_CHG_ID:
1335     CopyMem (CurrentFakeNVMap->DriverOptionOrder, Private->BmmOldFakeNVData.DriverOptionOrder, sizeof (CurrentFakeNVMap->DriverOptionOrder));
1336     break;
1337
1338   case FORM_BOOT_DEL_ID:
1339     ASSERT (BootOptionMenu.MenuNumber <= (sizeof (CurrentFakeNVMap->BootOptionDel) / sizeof (CurrentFakeNVMap->BootOptionDel[0])));
1340     for (Index = 0; Index < BootOptionMenu.MenuNumber; Index++) {
1341       CurrentFakeNVMap->BootOptionDel[Index] = FALSE;
1342     }
1343     break;
1344
1345   case FORM_DRV_DEL_ID:
1346     ASSERT (DriverOptionMenu.MenuNumber <= (sizeof (CurrentFakeNVMap->DriverOptionDel) / sizeof (CurrentFakeNVMap->DriverOptionDel[0])));
1347     for (Index = 0; Index < DriverOptionMenu.MenuNumber; Index++) {
1348       CurrentFakeNVMap->DriverOptionDel[Index] = FALSE;
1349     }
1350     break;
1351
1352   case FORM_BOOT_NEXT_ID:
1353     CurrentFakeNVMap->BootNext = Private->BmmOldFakeNVData.BootNext;
1354     break;
1355
1356   case FORM_TIME_OUT_ID:
1357     CurrentFakeNVMap->BootTimeOut = Private->BmmOldFakeNVData.BootTimeOut;
1358     break;
1359
1360   case FORM_DRV_ADD_HANDLE_DESC_ID:
1361   case FORM_DRV_ADD_FILE_ID:
1362   case FORM_DRV_ADD_HANDLE_ID:
1363     CurrentFakeNVMap->DriverAddHandleDesc[0]          = 0x0000;
1364     CurrentFakeNVMap->DriverAddHandleOptionalData[0]  = 0x0000;
1365     break;
1366
1367   default:
1368     break;
1369   }
1370 }
1371
1372 /**
1373
1374   Update the menus in the BMM page.
1375
1376 **/
1377 VOID
1378 CustomizeMenus (
1379   VOID
1380   )
1381 {
1382   VOID                        *StartOpCodeHandle;
1383   VOID                        *EndOpCodeHandle;
1384   EFI_IFR_GUID_LABEL          *StartGuidLabel;
1385   EFI_IFR_GUID_LABEL          *EndGuidLabel;
1386
1387   //
1388   // Allocate space for creation of UpdateData Buffer
1389   //
1390   StartOpCodeHandle = HiiAllocateOpCodeHandle ();
1391   ASSERT (StartOpCodeHandle != NULL);
1392
1393   EndOpCodeHandle = HiiAllocateOpCodeHandle ();
1394   ASSERT (EndOpCodeHandle != NULL);
1395   //
1396   // Create Hii Extend Label OpCode as the start opcode
1397   //
1398   StartGuidLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (StartOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL));
1399   StartGuidLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
1400   StartGuidLabel->Number       = LABEL_FORM_MAIN_START;
1401   //
1402   // Create Hii Extend Label OpCode as the end opcode
1403   //
1404   EndGuidLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (EndOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL));
1405   EndGuidLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
1406   EndGuidLabel->Number       = LABEL_FORM_MAIN_END;
1407
1408   //
1409   //Updata Front Page form
1410   //
1411   UiCustomizeBMMPage (
1412     mBmmCallbackInfo->BmmHiiHandle,
1413     StartOpCodeHandle
1414     );
1415
1416   HiiUpdateForm (
1417     mBmmCallbackInfo->BmmHiiHandle,
1418     &mBootMaintGuid,
1419     FORM_MAIN_ID,
1420     StartOpCodeHandle,
1421     EndOpCodeHandle
1422     );
1423
1424   HiiFreeOpCodeHandle (StartOpCodeHandle);
1425   HiiFreeOpCodeHandle (EndOpCodeHandle);
1426 }
1427
1428 /**
1429    Create dynamic code for BMM and initialize all of BMM configuration data in BmmFakeNvData and
1430    BmmOldFakeNVData member in BMM context data.
1431
1432   @param CallbackData    The BMM context data.
1433
1434 **/
1435 VOID
1436 InitializeBmmConfig (
1437   IN  BMM_CALLBACK_DATA    *CallbackData
1438   )
1439 {
1440   BM_MENU_ENTRY   *NewMenuEntry;
1441   BM_LOAD_CONTEXT *NewLoadContext;
1442   UINT16          Index;
1443
1444   ASSERT (CallbackData != NULL);
1445
1446   //
1447   // Initialize data which located in BMM main page
1448   //
1449   CallbackData->BmmFakeNvData.BootNext = NONE_BOOTNEXT_VALUE;
1450   for (Index = 0; Index < BootOptionMenu.MenuNumber; Index++) {
1451     NewMenuEntry    = BOpt_GetMenuEntry (&BootOptionMenu, Index);
1452     NewLoadContext  = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
1453
1454     if (NewLoadContext->IsBootNext) {
1455       CallbackData->BmmFakeNvData.BootNext = Index;
1456       break;
1457     }
1458   }
1459
1460   CallbackData->BmmFakeNvData.BootTimeOut = PcdGet16 (PcdPlatformBootTimeOut);
1461
1462   //
1463   // Initialize data which located in Boot Options Menu
1464   //
1465   GetBootOrder (CallbackData);
1466
1467   //
1468   // Initialize data which located in Driver Options Menu
1469   //
1470   GetDriverOrder (CallbackData);
1471
1472   //
1473   // Initialize data which located in Console Options Menu
1474   //
1475   GetConsoleOutMode (CallbackData);
1476   GetConsoleInCheck (CallbackData);
1477   GetConsoleOutCheck (CallbackData);
1478   GetConsoleErrCheck (CallbackData);
1479   GetTerminalAttribute (CallbackData);
1480
1481   CallbackData->BmmFakeNvData.ForceReconnect = TRUE;
1482
1483   //
1484   // Backup Initialize BMM configuartion data to BmmOldFakeNVData
1485   //
1486   CopyMem (&CallbackData->BmmOldFakeNVData, &CallbackData->BmmFakeNvData, sizeof (BMM_FAKE_NV_DATA));
1487 }
1488
1489 /**
1490   Initialized all Menu Option List.
1491
1492   @param CallbackData    The BMM context data.
1493
1494 **/
1495 VOID
1496 InitAllMenu (
1497   IN  BMM_CALLBACK_DATA    *CallbackData
1498   )
1499 {
1500   InitializeListHead (&BootOptionMenu.Head);
1501   InitializeListHead (&DriverOptionMenu.Head);
1502   BOpt_GetBootOptions (CallbackData);
1503   BOpt_GetDriverOptions (CallbackData);
1504   BOpt_FindDrivers ();
1505   InitializeListHead (&ConsoleInpMenu.Head);
1506   InitializeListHead (&ConsoleOutMenu.Head);
1507   InitializeListHead (&ConsoleErrMenu.Head);
1508   InitializeListHead (&TerminalMenu.Head);
1509   LocateSerialIo ();
1510   GetAllConsoles ();
1511   mAllMenuInit = TRUE;
1512 }
1513
1514 /**
1515   Free up all Menu Option list.
1516
1517 **/
1518 VOID
1519 FreeAllMenu (
1520   VOID
1521   )
1522 {
1523   if (!mAllMenuInit){
1524     return;
1525   }
1526   BOpt_FreeMenu (&BootOptionMenu);
1527   BOpt_FreeMenu (&DriverOptionMenu);
1528   BOpt_FreeMenu (&DriverMenu);
1529   FreeAllConsoles ();
1530   mAllMenuInit = FALSE;
1531 }
1532
1533 /**
1534   Initial the boot mode related parameters.
1535
1536 **/
1537 VOID
1538 BmmInitialBootModeInfo (
1539   VOID
1540   )
1541 {
1542   EFI_STATUS                         Status;
1543   EFI_GRAPHICS_OUTPUT_PROTOCOL       *GraphicsOutput;
1544   EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL    *SimpleTextOut;
1545   UINTN                              BootTextColumn;
1546   UINTN                              BootTextRow;
1547
1548   if (mBmmModeInitialized) {
1549     return;
1550   }
1551
1552   //
1553   // After the console is ready, get current video resolution
1554   // and text mode before launching setup at first time.
1555   //
1556   Status = gBS->HandleProtocol (
1557                   gST->ConsoleOutHandle,
1558                   &gEfiGraphicsOutputProtocolGuid,
1559                   (VOID**)&GraphicsOutput
1560                   );
1561   if (EFI_ERROR (Status)) {
1562     GraphicsOutput = NULL;
1563   }
1564
1565   Status = gBS->HandleProtocol (
1566                   gST->ConsoleOutHandle,
1567                   &gEfiSimpleTextOutProtocolGuid,
1568                   (VOID**)&SimpleTextOut
1569                   );
1570   if (EFI_ERROR (Status)) {
1571     SimpleTextOut = NULL;
1572   }
1573
1574   if (GraphicsOutput != NULL) {
1575     //
1576     // Get current video resolution and text mode.
1577     //
1578     mBmmBootHorizontalResolution = GraphicsOutput->Mode->Info->HorizontalResolution;
1579     mBmmBootVerticalResolution   = GraphicsOutput->Mode->Info->VerticalResolution;
1580   }
1581
1582   if (SimpleTextOut != NULL) {
1583     Status = SimpleTextOut->QueryMode (
1584                               SimpleTextOut,
1585                               SimpleTextOut->Mode->Mode,
1586                               &BootTextColumn,
1587                               &BootTextRow
1588                               );
1589     mBmmBootTextModeColumn = (UINT32)BootTextColumn;
1590     mBmmBootTextModeRow    = (UINT32)BootTextRow;
1591   }
1592
1593   //
1594   // Get user defined text mode for setup.
1595   //
1596   mBmmSetupHorizontalResolution = PcdGet32 (PcdSetupVideoHorizontalResolution);
1597   mBmmSetupVerticalResolution   = PcdGet32 (PcdSetupVideoVerticalResolution);
1598   mBmmSetupTextModeColumn       = PcdGet32 (PcdSetupConOutColumn);
1599   mBmmSetupTextModeRow          = PcdGet32 (PcdSetupConOutRow);
1600
1601   mBmmModeInitialized           = TRUE;
1602 }
1603
1604 /**
1605
1606   Install Boot Maintenance Manager Menu driver.
1607
1608   @param ImageHandle     The image handle.
1609   @param SystemTable     The system table.
1610
1611   @retval  EFI_SUCEESS  Install Boot manager menu success.
1612   @retval  Other        Return error status.
1613
1614 **/
1615 EFI_STATUS
1616 EFIAPI
1617 BootMaintenanceManagerUiLibConstructor (
1618   IN EFI_HANDLE                            ImageHandle,
1619   IN EFI_SYSTEM_TABLE                      *SystemTable
1620   )
1621
1622 {
1623   EFI_STATUS               Status;
1624   UINT8                    *Ptr;
1625
1626   Status = EFI_SUCCESS;
1627
1628   //
1629   // Install Device Path Protocol and Config Access protocol to driver handle
1630   //
1631   Status = gBS->InstallMultipleProtocolInterfaces (
1632                   &mBmmCallbackInfo->BmmDriverHandle,
1633                   &gEfiDevicePathProtocolGuid,
1634                   &mBmmHiiVendorDevicePath,
1635                   &gEfiHiiConfigAccessProtocolGuid,
1636                   &mBmmCallbackInfo->BmmConfigAccess,
1637                   NULL
1638                   );
1639   ASSERT_EFI_ERROR (Status);
1640
1641   //
1642   // Post our Boot Maint VFR binary to the HII database.
1643   //
1644   mBmmCallbackInfo->BmmHiiHandle = HiiAddPackages (
1645                                     &mBootMaintGuid,
1646                                     mBmmCallbackInfo->BmmDriverHandle,
1647                                     BootMaintenanceManagerBin,
1648                                     BootMaintenanceManagerUiLibStrings,
1649                                     NULL
1650                                     );
1651   ASSERT (mBmmCallbackInfo->BmmHiiHandle != NULL);
1652
1653   //
1654   // Locate Formbrowser2 protocol
1655   //
1656   Status = gBS->LocateProtocol (&gEfiFormBrowser2ProtocolGuid, NULL, (VOID **) &mBmmCallbackInfo->FormBrowser2);
1657   ASSERT_EFI_ERROR (Status);
1658
1659   EfiBootManagerRefreshAllBootOption ();
1660
1661   //
1662   // Create LoadOption in BmmCallbackInfo for Driver Callback
1663   //
1664   Ptr = AllocateZeroPool (sizeof (BM_LOAD_CONTEXT) + sizeof (BM_FILE_CONTEXT) + sizeof (BM_HANDLE_CONTEXT) + sizeof (BM_MENU_ENTRY));
1665   ASSERT (Ptr != NULL);
1666
1667   //
1668   // Initialize Bmm callback data.
1669   //
1670   mBmmCallbackInfo->LoadContext = (BM_LOAD_CONTEXT *) Ptr;
1671   Ptr += sizeof (BM_LOAD_CONTEXT);
1672
1673   mBmmCallbackInfo->FileContext = (BM_FILE_CONTEXT *) Ptr;
1674   Ptr += sizeof (BM_FILE_CONTEXT);
1675
1676   mBmmCallbackInfo->HandleContext = (BM_HANDLE_CONTEXT *) Ptr;
1677   Ptr += sizeof (BM_HANDLE_CONTEXT);
1678
1679   mBmmCallbackInfo->MenuEntry     = (BM_MENU_ENTRY *) Ptr;
1680
1681   mBmmCallbackInfo->BmmPreviousPageId  = FORM_MAIN_ID;
1682   mBmmCallbackInfo->BmmCurrentPageId   = FORM_MAIN_ID;
1683
1684   InitAllMenu (mBmmCallbackInfo);
1685
1686   CreateUpdateData();
1687   //
1688   // Update boot maintenance manager page
1689   //
1690   InitializeBmmConfig(mBmmCallbackInfo);
1691
1692   BmmInitialBootModeInfo();
1693
1694   return EFI_SUCCESS;
1695 }
1696
1697 /**
1698   Unloads the application and its installed protocol.
1699
1700   @param ImageHandle       Handle that identifies the image to be unloaded.
1701   @param  SystemTable      The system table.
1702
1703   @retval EFI_SUCCESS      The image has been unloaded.
1704
1705 **/
1706 EFI_STATUS
1707 EFIAPI
1708 BootMaintenanceManagerUiLibDestructor (
1709   IN EFI_HANDLE                            ImageHandle,
1710   IN EFI_SYSTEM_TABLE                      *SystemTable
1711   )
1712
1713 {
1714   if (mStartOpCodeHandle != NULL) {
1715     HiiFreeOpCodeHandle (mStartOpCodeHandle);
1716   }
1717
1718   if (mEndOpCodeHandle != NULL) {
1719     HiiFreeOpCodeHandle (mEndOpCodeHandle);
1720   }
1721
1722   FreeAllMenu ();
1723
1724   //
1725   // Remove our IFR data from HII database
1726   //
1727   HiiRemovePackages (mBmmCallbackInfo->BmmHiiHandle);
1728
1729   gBS->UninstallMultipleProtocolInterfaces (
1730          mBmmCallbackInfo->BmmDriverHandle,
1731          &gEfiDevicePathProtocolGuid,
1732          &mBmmHiiVendorDevicePath,
1733          &gEfiHiiConfigAccessProtocolGuid,
1734          &mBmmCallbackInfo->BmmConfigAccess,
1735          NULL
1736          );
1737
1738   FreePool (mBmmCallbackInfo->LoadContext);
1739
1740   return EFI_SUCCESS;
1741 }
1742