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