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             OldValue;
 871   UINTN             NewValue;
 872   UINTN             Number;
 873   UINTN             Index;
 874   EFI_DEVICE_PATH_PROTOCOL * File;
 875
 876   if (Action != EFI_BROWSER_ACTION_CHANGING && Action != EFI_BROWSER_ACTION_CHANGED) {
 877     //
 878     // Do nothing for other UEFI Action. Only do call back when data is changed.
 879     //
 880     return EFI_UNSUPPORTED;
 881   }
 882   OldValue       = 0;
 883   NewValue       = 0;
 884   Number         = 0;
 885
 886   Private        = BMM_CALLBACK_DATA_FROM_THIS (This);
 887   //
 888   // Retrive uncommitted data from Form Browser
 889   //
 890   CurrentFakeNVMap = &Private->BmmFakeNvData;
 891   HiiGetBrowserData (&mBootMaintGuid, mBootMaintStorageName, sizeof (BMM_FAKE_NV_DATA), (UINT8 *) CurrentFakeNVMap);
 892
 893   if (Action == EFI_BROWSER_ACTION_CHANGING) {
 894     if (Value == NULL) {
 895       return EFI_INVALID_PARAMETER;
 896     }
 897
 898     UpdatePageId (Private, QuestionId);
 899
 900     if (QuestionId < FILE_OPTION_OFFSET) {
 901       if (QuestionId < CONFIG_OPTION_OFFSET) {
 902         switch (QuestionId) {
 903         case FORM_BOOT_ADD_ID:
 904           // Leave BMM and enter FileExplorer.
 905           ChooseFile (NULL, L".efi", CreateBootOptionFromFile, &File);
 906           break;
 907
 908         case FORM_DRV_ADD_FILE_ID:
 909           // Leave BMM and enter FileExplorer.
 910           ChooseFile (NULL, L".efi", CreateDriverOptionFromFile, &File);
 911           break;
 912
 913         case FORM_DRV_ADD_HANDLE_ID:
 914           CleanUpPage (FORM_DRV_ADD_HANDLE_ID, Private);
 915           UpdateDrvAddHandlePage (Private);
 916           break;
 917
 918         case FORM_BOOT_DEL_ID:
 919           CleanUpPage (FORM_BOOT_DEL_ID, Private);
 920           UpdateBootDelPage (Private);
 921           break;
 922
 923         case FORM_BOOT_CHG_ID:
 924         case FORM_DRV_CHG_ID:
 925           UpdatePageBody (QuestionId, Private);
 926           break;
 927
 928         case FORM_DRV_DEL_ID:
 929           CleanUpPage (FORM_DRV_DEL_ID, Private);
 930           UpdateDrvDelPage (Private);
 931           break;
 932
 933         case FORM_BOOT_NEXT_ID:
 934           CleanUpPage (FORM_BOOT_NEXT_ID, Private);
 935           UpdateBootNextPage (Private);
 936           break;
 937
 938         case FORM_TIME_OUT_ID:
 939           CleanUpPage (FORM_TIME_OUT_ID, Private);
 940           UpdateTimeOutPage (Private);
 941           break;
 942
 943         case FORM_CON_IN_ID:
 944         case FORM_CON_OUT_ID:
 945         case FORM_CON_ERR_ID:
 946           UpdatePageBody (QuestionId, Private);
 947           break;
 948
 949         case FORM_CON_MODE_ID:
 950           CleanUpPage (FORM_CON_MODE_ID, Private);
 951           UpdateConModePage (Private);
 952           break;
 953
 954         case FORM_CON_COM_ID:
 955           CleanUpPage (FORM_CON_COM_ID, Private);
 956           UpdateConCOMPage (Private);
 957           break;
 958
 959         default:
 960           break;
 961         }
 962       } else if ((QuestionId >= TERMINAL_OPTION_OFFSET) && (QuestionId < CONSOLE_OPTION_OFFSET)) {
 963         Index                  = (UINT16) (QuestionId - TERMINAL_OPTION_OFFSET);
 964         Private->CurrentTerminal  = Index;
 965
 966         CleanUpPage (FORM_CON_COM_SETUP_ID, Private);
 967         UpdateTerminalPage (Private);
 968
 969       } else if (QuestionId >= HANDLE_OPTION_OFFSET) {
 970         Index                  = (UINT16) (QuestionId - HANDLE_OPTION_OFFSET);
 971
 972         NewMenuEntry            = BOpt_GetMenuEntry (&DriverMenu, Index);
 973         ASSERT (NewMenuEntry != NULL);
 974         Private->HandleContext  = (BM_HANDLE_CONTEXT *) NewMenuEntry->VariableContext;
 975
 976         CleanUpPage (FORM_DRV_ADD_HANDLE_DESC_ID, Private);
 977
 978         Private->MenuEntry                  = NewMenuEntry;
 979         Private->LoadContext->FilePathList  = Private->HandleContext->DevicePath;
 980
 981         UpdateDriverAddHandleDescPage (Private);
 982       }
 983     }
 984     if (QuestionId == KEY_VALUE_BOOT_FROM_FILE){
 985       // Leave BMM and enter FileExplorer.
 986       ChooseFile (NULL, L".efi", BootFromFile, &File);
 987     }
 988   } else if (Action == EFI_BROWSER_ACTION_CHANGED) {
 989     if ((Value == NULL) || (ActionRequest == NULL)) {
 990       return EFI_INVALID_PARAMETER;
 991     }
 992
 993     if (QuestionId == KEY_VALUE_SAVE_AND_EXIT_BOOT) {
 994       CurrentFakeNVMap->BootOptionChanged = FALSE;
 995       *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_SUBMIT_EXIT;
 996     } else if (QuestionId == KEY_VALUE_SAVE_AND_EXIT_DRIVER) {
 997       CurrentFakeNVMap->DriverOptionChanged = FALSE;
 998       *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_SUBMIT_EXIT;
 999     } else if (QuestionId == KEY_VALUE_NO_SAVE_AND_EXIT_DRIVER) {
1000       //
1001       // Discard changes and exit formset
1002       //
1003       CurrentFakeNVMap->DriverOptionalData[0]     = 0x0000;
1004       CurrentFakeNVMap->DriverDescriptionData[0]  = 0x0000;
1005       CurrentFakeNVMap->DriverOptionChanged = FALSE;
1006       CurrentFakeNVMap->ForceReconnect      = TRUE;
1007       *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_DISCARD_EXIT;
1008     } else if (QuestionId == KEY_VALUE_NO_SAVE_AND_EXIT_BOOT) {
1009       //
1010       // Discard changes and exit formset
1011       //
1012       CurrentFakeNVMap->BootOptionalData[0]     = 0x0000;
1013       CurrentFakeNVMap->BootDescriptionData[0]  = 0x0000;
1014       CurrentFakeNVMap->BootOptionChanged = FALSE;
1015       *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_DISCARD_EXIT;
1016     } else if (QuestionId == KEY_VALUE_BOOT_DESCRIPTION || QuestionId == KEY_VALUE_BOOT_OPTION) {
1017       CurrentFakeNVMap->BootOptionChanged = TRUE;
1018     } else if (QuestionId == KEY_VALUE_DRIVER_DESCRIPTION || QuestionId == KEY_VALUE_DRIVER_OPTION) {
1019       CurrentFakeNVMap->DriverOptionChanged = TRUE;
1020     }
1021
1022     if ((QuestionId >= BOOT_OPTION_DEL_QUESTION_ID) && (QuestionId < BOOT_OPTION_DEL_QUESTION_ID + MAX_MENU_NUMBER)) {
1023       if (Value->b){
1024         //
1025         // Means user try to delete this boot option but not press F10 or "Commit Changes and Exit" menu.
1026         //
1027         CurrentFakeNVMap->BootOptionDelMark[QuestionId - BOOT_OPTION_DEL_QUESTION_ID] = TRUE;
1028       } else {
1029         //
1030         // Means user remove the old check status.
1031         //
1032         CurrentFakeNVMap->BootOptionDelMark[QuestionId - BOOT_OPTION_DEL_QUESTION_ID] = FALSE;
1033       }
1034     } else if ((QuestionId >= DRIVER_OPTION_DEL_QUESTION_ID) && (QuestionId < DRIVER_OPTION_DEL_QUESTION_ID + MAX_MENU_NUMBER)) {
1035       if (Value->b){
1036         CurrentFakeNVMap->DriverOptionDelMark[QuestionId - DRIVER_OPTION_DEL_QUESTION_ID] = TRUE;
1037       } else {
1038         CurrentFakeNVMap->DriverOptionDelMark[QuestionId - DRIVER_OPTION_DEL_QUESTION_ID] = FALSE;
1039       }
1040     } else {
1041       switch (QuestionId) {
1042       case KEY_VALUE_SAVE_AND_EXIT:
1043       case KEY_VALUE_NO_SAVE_AND_EXIT:
1044         if (QuestionId == KEY_VALUE_SAVE_AND_EXIT) {
1045           *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_SUBMIT_EXIT;
1046         } else if (QuestionId == KEY_VALUE_NO_SAVE_AND_EXIT) {
1047           DiscardChangeHandler (Private, CurrentFakeNVMap);
1048           *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_DISCARD_EXIT;
1049         }
1050
1051         break;
1052
1053       case FORM_RESET:
1054         gRT->ResetSystem (EfiResetCold, EFI_SUCCESS, 0, NULL);
1055         return EFI_UNSUPPORTED;
1056
1057       default:
1058         break;
1059       }
1060     }
1061   }
1062
1063   //
1064   // Pass changed uncommitted data back to Form Browser
1065   //
1066   HiiSetBrowserData (&mBootMaintGuid, mBootMaintStorageName, sizeof (BMM_FAKE_NV_DATA), (UINT8 *) CurrentFakeNVMap, NULL);
1067
1068   return EFI_SUCCESS;
1069 }
1070
1071 /**
1072   Discard all changes done to the BMM pages such as Boot Order change,
1073   Driver order change.
1074
1075   @param Private            The BMM context data.
1076   @param CurrentFakeNVMap   The current Fack NV Map.
1077
1078 **/
1079 VOID
1080 DiscardChangeHandler (
1081   IN  BMM_CALLBACK_DATA               *Private,
1082   IN  BMM_FAKE_NV_DATA                *CurrentFakeNVMap
1083   )
1084 {
1085   UINT16  Index;
1086
1087   switch (Private->BmmPreviousPageId) {
1088   case FORM_BOOT_CHG_ID:
1089     CopyMem (CurrentFakeNVMap->BootOptionOrder, Private->BmmOldFakeNVData.BootOptionOrder, sizeof (CurrentFakeNVMap->BootOptionOrder));
1090     break;
1091
1092   case FORM_DRV_CHG_ID:
1093     CopyMem (CurrentFakeNVMap->DriverOptionOrder, Private->BmmOldFakeNVData.DriverOptionOrder, sizeof (CurrentFakeNVMap->DriverOptionOrder));
1094     break;
1095
1096   case FORM_BOOT_DEL_ID:
1097     ASSERT (BootOptionMenu.MenuNumber <= (sizeof (CurrentFakeNVMap->BootOptionDel) / sizeof (CurrentFakeNVMap->BootOptionDel[0])));
1098     for (Index = 0; Index < BootOptionMenu.MenuNumber; Index++) {
1099       CurrentFakeNVMap->BootOptionDel[Index] = FALSE;
1100     }
1101     break;
1102
1103   case FORM_DRV_DEL_ID:
1104     ASSERT (DriverOptionMenu.MenuNumber <= (sizeof (CurrentFakeNVMap->DriverOptionDel) / sizeof (CurrentFakeNVMap->DriverOptionDel[0])));
1105     for (Index = 0; Index < DriverOptionMenu.MenuNumber; Index++) {
1106       CurrentFakeNVMap->DriverOptionDel[Index] = FALSE;
1107     }
1108     break;
1109
1110   case FORM_BOOT_NEXT_ID:
1111     CurrentFakeNVMap->BootNext = Private->BmmOldFakeNVData.BootNext;
1112     break;
1113
1114   case FORM_TIME_OUT_ID:
1115     CurrentFakeNVMap->BootTimeOut = Private->BmmOldFakeNVData.BootTimeOut;
1116     break;
1117
1118   case FORM_DRV_ADD_HANDLE_DESC_ID:
1119   case FORM_DRV_ADD_FILE_ID:
1120   case FORM_DRV_ADD_HANDLE_ID:
1121     CurrentFakeNVMap->DriverAddHandleDesc[0]          = 0x0000;
1122     CurrentFakeNVMap->DriverAddHandleOptionalData[0]  = 0x0000;
1123     break;
1124
1125   default:
1126     break;
1127   }
1128 }
1129
1130 /**
1131   Create dynamic code for BMM.
1132
1133   @param  BmmCallbackInfo        The BMM context data.
1134
1135 **/
1136 VOID
1137 InitializeDrivers(
1138   IN BMM_CALLBACK_DATA        *BmmCallbackInfo
1139   )
1140 {
1141   EFI_HII_HANDLE              HiiHandle;
1142   VOID                        *StartOpCodeHandle;
1143   VOID                        *EndOpCodeHandle;
1144   EFI_IFR_GUID_LABEL          *StartLabel;
1145   EFI_IFR_GUID_LABEL          *EndLabel;
1146   UINTN                       Index;
1147   EFI_STRING                  String;
1148   EFI_STRING_ID               Token;
1149   EFI_STRING_ID               TokenHelp;
1150   EFI_HII_HANDLE              *HiiHandles;
1151   EFI_GUID                    FormSetGuid;
1152   CHAR16                      *DevicePathStr;
1153   EFI_STRING_ID               DevicePathId;
1154   EFI_IFR_FORM_SET            *Buffer;
1155   UINTN                       BufferSize;
1156   UINT8                       ClassGuidNum;
1157   EFI_GUID                    *ClassGuid;
1158   UINTN                       TempSize;
1159   UINT8                       *Ptr;
1160   EFI_STATUS                  Status;
1161
1162   TempSize =0;
1163   BufferSize = 0;
1164   Buffer = NULL;
1165
1166   HiiHandle = BmmCallbackInfo->BmmHiiHandle;
1167   //
1168   // Allocate space for creation of UpdateData Buffer
1169   //
1170   StartOpCodeHandle = HiiAllocateOpCodeHandle ();
1171   ASSERT (StartOpCodeHandle != NULL);
1172
1173   EndOpCodeHandle = HiiAllocateOpCodeHandle ();
1174   ASSERT (EndOpCodeHandle != NULL);
1175
1176   //
1177   // Create Hii Extend Label OpCode as the start opcode
1178   //
1179   StartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (StartOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL));
1180   StartLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
1181   StartLabel->Number       = LABEL_BMM_PLATFORM_INFORMATION;
1182
1183   //
1184   // Create Hii Extend Label OpCode as the end opcode
1185   //
1186   EndLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (EndOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL));
1187   EndLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
1188   EndLabel->Number       = LABEL_END;
1189
1190   //
1191   // Get all the Hii handles
1192   //
1193   HiiHandles = HiiGetHiiHandles (NULL);
1194   ASSERT (HiiHandles != NULL);
1195
1196   //
1197   // Search for formset of each class type
1198   //
1199   for (Index = 0; HiiHandles[Index] != NULL; Index++) {
1200     Status = HiiGetFormSetFromHiiHandle(HiiHandles[Index], &Buffer,&BufferSize);
1201     if (EFI_ERROR (Status)) {
1202       continue;
1203     }
1204
1205     Ptr = (UINT8 *)Buffer;
1206     while(TempSize < BufferSize)  {
1207       TempSize += ((EFI_IFR_OP_HEADER *) Ptr)->Length;
1208
1209       if (((EFI_IFR_OP_HEADER *) Ptr)->Length <= OFFSET_OF (EFI_IFR_FORM_SET, Flags)){
1210         Ptr += ((EFI_IFR_OP_HEADER *) Ptr)->Length;
1211         continue;
1212       }
1213
1214       //
1215       // Find FormSet OpCode
1216       //
1217       ClassGuidNum = (UINT8) (((EFI_IFR_FORM_SET *)Ptr)->Flags & 0x3);
1218       ClassGuid = (EFI_GUID *) (VOID *)(Ptr + sizeof (EFI_IFR_FORM_SET));
1219       while (ClassGuidNum-- > 0) {
1220         if (CompareGuid (&gEfiIfrBootMaintenanceGuid, ClassGuid) == 0){
1221           ClassGuid ++;
1222           continue;
1223         }
1224
1225         String = HiiGetString (HiiHandles[Index], ((EFI_IFR_FORM_SET *)Ptr)->FormSetTitle, NULL);
1226         if (String == NULL) {
1227           String = HiiGetString (HiiHandle, STRING_TOKEN (STR_MISSING_STRING), NULL);
1228           ASSERT (String != NULL);
1229         }
1230         Token = HiiSetString (HiiHandle, 0, String, NULL);
1231         FreePool (String);
1232
1233         String = HiiGetString (HiiHandles[Index], ((EFI_IFR_FORM_SET *)Ptr)->Help, NULL);
1234         if (String == NULL) {
1235           String = HiiGetString (HiiHandle, STRING_TOKEN (STR_MISSING_STRING), NULL);
1236           ASSERT (String != NULL);
1237         }
1238         TokenHelp = HiiSetString (HiiHandle, 0, String, NULL);
1239         FreePool (String);
1240
1241         FormSetGuid = ((EFI_IFR_FORM_SET *)Ptr)->Guid;
1242
1243         DevicePathStr = BmmExtractDevicePathFromHiiHandle(HiiHandles[Index]);
1244         DevicePathId  = 0;
1245         if (DevicePathStr != NULL){
1246           DevicePathId = HiiSetString (HiiHandle, 0, DevicePathStr, NULL);
1247           FreePool (DevicePathStr);
1248         }
1249          HiiCreateGotoExOpCode (
1250            StartOpCodeHandle,
1251            0,
1252            Token,
1253            TokenHelp,
1254            0,
1255            (EFI_QUESTION_ID) (Index + FRONT_PAGE_KEY_OFFSET),
1256            0,
1257            &FormSetGuid,
1258            DevicePathId
1259          );
1260         break;
1261       }
1262       Ptr += ((EFI_IFR_OP_HEADER *) Ptr)->Length;
1263     }
1264
1265     FreePool(Buffer);
1266     Buffer = NULL;
1267     TempSize = 0;
1268     BufferSize = 0;
1269   }
1270
1271   HiiUpdateForm (
1272     HiiHandle,
1273     &mBootMaintGuid,
1274     FORM_MAIN_ID,
1275     StartOpCodeHandle,
1276     EndOpCodeHandle
1277     );
1278
1279   HiiFreeOpCodeHandle (StartOpCodeHandle);
1280   HiiFreeOpCodeHandle (EndOpCodeHandle);
1281   FreePool (HiiHandles);
1282 }
1283
1284 /**
1285    Create dynamic code for BMM and initialize all of BMM configuration data in BmmFakeNvData and
1286    BmmOldFakeNVData member in BMM context data.
1287
1288   @param CallbackData    The BMM context data.
1289
1290 **/
1291 VOID
1292 InitializeBmmConfig (
1293   IN  BMM_CALLBACK_DATA    *CallbackData
1294   )
1295 {
1296   BM_MENU_ENTRY   *NewMenuEntry;
1297   BM_LOAD_CONTEXT *NewLoadContext;
1298   UINT16          Index;
1299
1300   ASSERT (CallbackData != NULL);
1301
1302   InitializeDrivers (CallbackData);
1303
1304   //
1305   // Initialize data which located in BMM main page
1306   //
1307   CallbackData->BmmFakeNvData.BootNext = NONE_BOOTNEXT_VALUE;
1308   for (Index = 0; Index < BootOptionMenu.MenuNumber; Index++) {
1309     NewMenuEntry    = BOpt_GetMenuEntry (&BootOptionMenu, Index);
1310     NewLoadContext  = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
1311
1312     if (NewLoadContext->IsBootNext) {
1313       CallbackData->BmmFakeNvData.BootNext = Index;
1314       break;
1315     }
1316   }
1317
1318   CallbackData->BmmFakeNvData.BootTimeOut = PcdGet16 (PcdPlatformBootTimeOut);
1319
1320   //
1321   // Initialize data which located in Boot Options Menu
1322   //
1323   GetBootOrder (CallbackData);
1324
1325   //
1326   // Initialize data which located in Driver Options Menu
1327   //
1328   GetDriverOrder (CallbackData);
1329
1330   //
1331   // Initialize data which located in Console Options Menu
1332   //
1333   GetConsoleOutMode (CallbackData);
1334   GetConsoleInCheck (CallbackData);
1335   GetConsoleOutCheck (CallbackData);
1336   GetConsoleErrCheck (CallbackData);
1337   GetTerminalAttribute (CallbackData);
1338
1339   CallbackData->BmmFakeNvData.ForceReconnect = TRUE;
1340
1341   //
1342   // Backup Initialize BMM configuartion data to BmmOldFakeNVData
1343   //
1344   CopyMem (&CallbackData->BmmOldFakeNVData, &CallbackData->BmmFakeNvData, sizeof (BMM_FAKE_NV_DATA));
1345 }
1346
1347 /**
1348   Initialized all Menu Option List.
1349
1350   @param CallbackData    The BMM context data.
1351
1352 **/
1353 VOID
1354 InitAllMenu (
1355   IN  BMM_CALLBACK_DATA    *CallbackData
1356   )
1357 {
1358   InitializeListHead (&BootOptionMenu.Head);
1359   InitializeListHead (&DriverOptionMenu.Head);
1360   BOpt_GetBootOptions (CallbackData);
1361   BOpt_GetDriverOptions (CallbackData);
1362   BOpt_FindDrivers ();
1363   InitializeListHead (&ConsoleInpMenu.Head);
1364   InitializeListHead (&ConsoleOutMenu.Head);
1365   InitializeListHead (&ConsoleErrMenu.Head);
1366   InitializeListHead (&TerminalMenu.Head);
1367   LocateSerialIo ();
1368   GetAllConsoles ();
1369   mAllMenuInit = TRUE;
1370 }
1371
1372 /**
1373   Free up all Menu Option list.
1374
1375 **/
1376 VOID
1377 FreeAllMenu (
1378   VOID
1379   )
1380 {
1381   if (!mAllMenuInit){
1382     return;
1383   }
1384   BOpt_FreeMenu (&BootOptionMenu);
1385   BOpt_FreeMenu (&DriverOptionMenu);
1386   BOpt_FreeMenu (&DriverMenu);
1387   FreeAllConsoles ();
1388   mAllMenuInit = FALSE;
1389 }
1390
1391 /**
1392
1393   Install Boot Maintenance Manager Menu driver.
1394
1395   @param ImageHandle     The image handle.
1396   @param SystemTable     The system table.
1397
1398   @retval  EFI_SUCEESS  Install Boot manager menu success.
1399   @retval  Other        Return error status.
1400
1401 **/
1402 EFI_STATUS
1403 EFIAPI
1404 BootMaintenanceManagerUiLibConstructor (
1405   IN EFI_HANDLE                            ImageHandle,
1406   IN EFI_SYSTEM_TABLE                      *SystemTable
1407   )
1408
1409 {
1410   EFI_STATUS               Status;
1411   UINT8                    *Ptr;
1412
1413   Status = EFI_SUCCESS;
1414
1415   //
1416   // Install Device Path Protocol and Config Access protocol to driver handle
1417   //
1418   Status = gBS->InstallMultipleProtocolInterfaces (
1419                   &mBmmCallbackInfo->BmmDriverHandle,
1420                   &gEfiDevicePathProtocolGuid,
1421                   &mBmmHiiVendorDevicePath,
1422                   &gEfiHiiConfigAccessProtocolGuid,
1423                   &mBmmCallbackInfo->BmmConfigAccess,
1424                   NULL
1425                   );
1426   ASSERT_EFI_ERROR (Status);
1427
1428   //
1429   // Post our Boot Maint VFR binary to the HII database.
1430   //
1431   mBmmCallbackInfo->BmmHiiHandle = HiiAddPackages (
1432                                     &mBootMaintGuid,
1433                                     mBmmCallbackInfo->BmmDriverHandle,
1434                                     BootMaintenanceManagerBin,
1435                                     BootMaintenanceManagerUiLibStrings,
1436                                     NULL
1437                                     );
1438   ASSERT (mBmmCallbackInfo->BmmHiiHandle != NULL);
1439
1440   //
1441   // Locate Formbrowser2 protocol
1442   //
1443   Status = gBS->LocateProtocol (&gEfiFormBrowser2ProtocolGuid, NULL, (VOID **) &mBmmCallbackInfo->FormBrowser2);
1444   ASSERT_EFI_ERROR (Status);
1445
1446   EfiBootManagerRefreshAllBootOption ();
1447
1448   //
1449   // Create LoadOption in BmmCallbackInfo for Driver Callback
1450   //
1451   Ptr = AllocateZeroPool (sizeof (BM_LOAD_CONTEXT) + sizeof (BM_FILE_CONTEXT) + sizeof (BM_HANDLE_CONTEXT) + sizeof (BM_MENU_ENTRY));
1452   ASSERT (Ptr != NULL);
1453
1454   //
1455   // Initialize Bmm callback data.
1456   //
1457   mBmmCallbackInfo->LoadContext = (BM_LOAD_CONTEXT *) Ptr;
1458   Ptr += sizeof (BM_LOAD_CONTEXT);
1459
1460   mBmmCallbackInfo->FileContext = (BM_FILE_CONTEXT *) Ptr;
1461   Ptr += sizeof (BM_FILE_CONTEXT);
1462
1463   mBmmCallbackInfo->HandleContext = (BM_HANDLE_CONTEXT *) Ptr;
1464   Ptr += sizeof (BM_HANDLE_CONTEXT);
1465
1466   mBmmCallbackInfo->MenuEntry     = (BM_MENU_ENTRY *) Ptr;
1467
1468   mBmmCallbackInfo->BmmPreviousPageId  = FORM_MAIN_ID;
1469   mBmmCallbackInfo->BmmCurrentPageId   = FORM_MAIN_ID;
1470
1471   InitAllMenu (mBmmCallbackInfo);
1472
1473   CreateUpdateData();
1474   //
1475   // Update boot maintenance manager page
1476   //
1477   InitializeBmmConfig(mBmmCallbackInfo);
1478
1479   return EFI_SUCCESS;
1480 }
1481
1482 /**
1483   Unloads the application and its installed protocol.
1484
1485   @param ImageHandle       Handle that identifies the image to be unloaded.
1486   @param  SystemTable      The system table.
1487
1488   @retval EFI_SUCCESS      The image has been unloaded.
1489
1490 **/
1491 EFI_STATUS
1492 EFIAPI
1493 BootMaintenanceManagerUiLibDestructor (
1494   IN EFI_HANDLE                            ImageHandle,
1495   IN EFI_SYSTEM_TABLE                      *SystemTable
1496   )
1497
1498 {
1499   if (mStartOpCodeHandle != NULL) {
1500     HiiFreeOpCodeHandle (mStartOpCodeHandle);
1501   }
1502
1503   if (mEndOpCodeHandle != NULL) {
1504     HiiFreeOpCodeHandle (mEndOpCodeHandle);
1505   }
1506
1507   FreeAllMenu ();
1508
1509   //
1510   // Remove our IFR data from HII database
1511   //
1512   HiiRemovePackages (mBmmCallbackInfo->BmmHiiHandle);
1513
1514   gBS->UninstallMultipleProtocolInterfaces (
1515          mBmmCallbackInfo->BmmDriverHandle,
1516          &gEfiDevicePathProtocolGuid,
1517          &mBmmHiiVendorDevicePath,
1518          &gEfiHiiConfigAccessProtocolGuid,
1519          &mBmmCallbackInfo->BmmConfigAccess,
1520          NULL
1521          );
1522
1523   FreePool (mBmmCallbackInfo->LoadContext);
1524
1525   return EFI_SUCCESS;
1526 }
1527