MdeModulePkg/Library/BootMaintenanceManagerUiLib/BootMaintenance.c

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