MdeModulePkg/Library/BootMaintenanceManagerLib/BootMaintenance.c

   1 /** @file
   2 The functions for Boot Maintainence Main menu.
   3
   4 Copyright (c) 2004 - 2015, 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     ASSERT_EFI_ERROR(Status);
 671
 672     Private->BmmOldFakeNVData.BootTimeOut = NewBmmData->BootTimeOut;
 673   }
 674
 675   //
 676   // Check data which located in Driver Options Menu and save the settings if need
 677   //
 678   if (CompareMem (NewBmmData->DriverOptionDel, OldBmmData->DriverOptionDel, sizeof (NewBmmData->DriverOptionDel)) != 0) {
 679     for (Index = 0;
 680          ((Index < DriverOptionMenu.MenuNumber) && (Index < (sizeof (NewBmmData->DriverOptionDel) / sizeof (NewBmmData->DriverOptionDel[0]))));
 681          Index++) {
 682       NewMenuEntry            = BOpt_GetMenuEntry (&DriverOptionMenu, Index);
 683       NewLoadContext          = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
 684       NewLoadContext->Deleted = NewBmmData->DriverOptionDel[Index];
 685       NewBmmData->DriverOptionDel[Index] = FALSE;
 686       NewBmmData->DriverOptionDelMark[Index] = FALSE;
 687     }
 688     Var_DelDriverOption ();
 689   }
 690
 691   if (CompareMem (NewBmmData->DriverOptionOrder, OldBmmData->DriverOptionOrder, sizeof (NewBmmData->DriverOptionOrder)) != 0) {
 692     Status = Var_UpdateDriverOrder (Private);
 693   }
 694
 695   if (CompareMem (&NewBmmData->ConsoleOutMode, &OldBmmData->ConsoleOutMode, sizeof (NewBmmData->ConsoleOutMode)) != 0){
 696     Var_UpdateConMode(Private);
 697   }
 698
 699   TerminalAttChange = FALSE;
 700   for (Index = 0; Index < TerminalMenu.MenuNumber; Index++) {
 701
 702     //
 703     // only need update modified items
 704     //
 705     if (CompareMem (&NewBmmData->COMBaudRate[Index], &OldBmmData->COMBaudRate[Index], sizeof (NewBmmData->COMBaudRate[Index])) == 0 &&
 706          CompareMem (&NewBmmData->COMDataRate[Index], &OldBmmData->COMDataRate[Index], sizeof (NewBmmData->COMDataRate[Index])) == 0 &&
 707          CompareMem (&NewBmmData->COMStopBits[Index], &OldBmmData->COMStopBits[Index], sizeof (NewBmmData->COMStopBits[Index])) == 0 &&
 708          CompareMem (&NewBmmData->COMParity[Index], &OldBmmData->COMParity[Index], sizeof (NewBmmData->COMParity[Index])) == 0 &&
 709          CompareMem (&NewBmmData->COMTerminalType[Index], &OldBmmData->COMTerminalType[Index], sizeof (NewBmmData->COMTerminalType[Index])) == 0 &&
 710          CompareMem (&NewBmmData->COMFlowControl[Index], &OldBmmData->COMFlowControl[Index], sizeof (NewBmmData->COMFlowControl[Index])) == 0) {
 711       continue;
 712     }
 713
 714     NewMenuEntry = BOpt_GetMenuEntry (&TerminalMenu, Index);
 715     ASSERT (NewMenuEntry != NULL);
 716     NewTerminalContext = (BM_TERMINAL_CONTEXT *) NewMenuEntry->VariableContext;
 717     NewTerminalContext->BaudRateIndex = NewBmmData->COMBaudRate[Index];
 718     ASSERT (NewBmmData->COMBaudRate[Index] < (sizeof (BaudRateList) / sizeof (BaudRateList[0])));
 719     NewTerminalContext->BaudRate      = BaudRateList[NewBmmData->COMBaudRate[Index]].Value;
 720     NewTerminalContext->DataBitsIndex = NewBmmData->COMDataRate[Index];
 721     ASSERT (NewBmmData->COMDataRate[Index] < (sizeof (DataBitsList) / sizeof (DataBitsList[0])));
 722     NewTerminalContext->DataBits      = (UINT8) DataBitsList[NewBmmData->COMDataRate[Index]].Value;
 723     NewTerminalContext->StopBitsIndex = NewBmmData->COMStopBits[Index];
 724     ASSERT (NewBmmData->COMStopBits[Index] < (sizeof (StopBitsList) / sizeof (StopBitsList[0])));
 725     NewTerminalContext->StopBits      = (UINT8) StopBitsList[NewBmmData->COMStopBits[Index]].Value;
 726     NewTerminalContext->ParityIndex   = NewBmmData->COMParity[Index];
 727     ASSERT (NewBmmData->COMParity[Index] < (sizeof (ParityList) / sizeof (ParityList[0])));
 728     NewTerminalContext->Parity        = (UINT8) ParityList[NewBmmData->COMParity[Index]].Value;
 729     NewTerminalContext->TerminalType  = NewBmmData->COMTerminalType[Index];
 730     NewTerminalContext->FlowControl   = NewBmmData->COMFlowControl[Index];
 731     ChangeTerminalDevicePath (
 732       NewTerminalContext->DevicePath,
 733       FALSE
 734       );
 735     TerminalAttChange = TRUE;
 736   }
 737   if (TerminalAttChange) {
 738     Var_UpdateConsoleInpOption ();
 739     Var_UpdateConsoleOutOption ();
 740     Var_UpdateErrorOutOption ();
 741   }
 742   //
 743   // Check data which located in Console Options Menu and save the settings if need
 744   //
 745   if (CompareMem (NewBmmData->ConsoleInCheck, OldBmmData->ConsoleInCheck, sizeof (NewBmmData->ConsoleInCheck)) != 0){
 746     for (Index = 0; Index < ConsoleInpMenu.MenuNumber; Index++){
 747       NewMenuEntry                = BOpt_GetMenuEntry(&ConsoleInpMenu, Index);
 748       NewConsoleContext           = (BM_CONSOLE_CONTEXT *)NewMenuEntry->VariableContext;
 749       ASSERT (Index < MAX_MENU_NUMBER);
 750       NewConsoleContext->IsActive = NewBmmData->ConsoleInCheck[Index];
 751     }
 752     for (Index = 0; Index < TerminalMenu.MenuNumber; Index++) {
 753       NewMenuEntry                = BOpt_GetMenuEntry (&TerminalMenu, Index);
 754       NewTerminalContext          = (BM_TERMINAL_CONTEXT *) NewMenuEntry->VariableContext;
 755       ASSERT (Index + ConsoleInpMenu.MenuNumber < MAX_MENU_NUMBER);
 756       NewTerminalContext->IsConIn = NewBmmData->ConsoleInCheck[Index + ConsoleInpMenu.MenuNumber];
 757     }
 758     Var_UpdateConsoleInpOption();
 759   }
 760
 761   if (CompareMem (NewBmmData->ConsoleOutCheck, OldBmmData->ConsoleOutCheck, sizeof (NewBmmData->ConsoleOutCheck)) != 0){
 762     for (Index = 0; Index < ConsoleOutMenu.MenuNumber; Index++){
 763       NewMenuEntry                = BOpt_GetMenuEntry(&ConsoleOutMenu, Index);
 764       NewConsoleContext           = (BM_CONSOLE_CONTEXT *)NewMenuEntry->VariableContext;
 765       ASSERT (Index < MAX_MENU_NUMBER);
 766       NewConsoleContext->IsActive = NewBmmData->ConsoleOutCheck[Index];
 767     }
 768     for (Index = 0; Index < TerminalMenu.MenuNumber; Index++) {
 769       NewMenuEntry                = BOpt_GetMenuEntry (&TerminalMenu, Index);
 770       NewTerminalContext          = (BM_TERMINAL_CONTEXT *) NewMenuEntry->VariableContext;
 771       ASSERT (Index + ConsoleOutMenu.MenuNumber < MAX_MENU_NUMBER);
 772       NewTerminalContext->IsConOut = NewBmmData->ConsoleOutCheck[Index + ConsoleOutMenu.MenuNumber];
 773     }
 774     Var_UpdateConsoleOutOption();
 775   }
 776
 777   if (CompareMem (NewBmmData->ConsoleErrCheck, OldBmmData->ConsoleErrCheck, sizeof (NewBmmData->ConsoleErrCheck)) != 0){
 778     for (Index = 0; Index < ConsoleErrMenu.MenuNumber; Index++){
 779       NewMenuEntry                = BOpt_GetMenuEntry(&ConsoleErrMenu, Index);
 780       NewConsoleContext           = (BM_CONSOLE_CONTEXT *)NewMenuEntry->VariableContext;
 781       ASSERT (Index < MAX_MENU_NUMBER);
 782       NewConsoleContext->IsActive = NewBmmData->ConsoleErrCheck[Index];
 783     }
 784     for (Index = 0; Index < TerminalMenu.MenuNumber; Index++) {
 785       NewMenuEntry                = BOpt_GetMenuEntry (&TerminalMenu, Index);
 786       NewTerminalContext          = (BM_TERMINAL_CONTEXT *) NewMenuEntry->VariableContext;
 787       ASSERT (Index + ConsoleErrMenu.MenuNumber < MAX_MENU_NUMBER);
 788       NewTerminalContext->IsStdErr = NewBmmData->ConsoleErrCheck[Index + ConsoleErrMenu.MenuNumber];
 789     }
 790     Var_UpdateErrorOutOption();
 791   }
 792
 793   if (CompareMem (NewBmmData->BootDescriptionData, OldBmmData->BootDescriptionData, sizeof (NewBmmData->BootDescriptionData)) != 0 ||
 794        CompareMem (NewBmmData->BootOptionalData, OldBmmData->BootOptionalData, sizeof (NewBmmData->BootOptionalData)) != 0) {
 795     Status = Var_UpdateBootOption (Private);
 796     NewBmmData->BootOptionChanged = FALSE;
 797     if (EFI_ERROR (Status)) {
 798       return Status;
 799     }
 800     BOpt_GetBootOptions (Private);
 801   }
 802
 803   if (CompareMem (NewBmmData->DriverDescriptionData, OldBmmData->DriverDescriptionData, sizeof (NewBmmData->DriverDescriptionData)) != 0 ||
 804        CompareMem (NewBmmData->DriverOptionalData, OldBmmData->DriverOptionalData, sizeof (NewBmmData->DriverOptionalData)) != 0) {
 805     Status = Var_UpdateDriverOption (
 806               Private,
 807               Private->BmmHiiHandle,
 808               NewBmmData->DriverDescriptionData,
 809               NewBmmData->DriverOptionalData,
 810               NewBmmData->ForceReconnect
 811               );
 812     NewBmmData->DriverOptionChanged = FALSE;
 813     NewBmmData->ForceReconnect      = TRUE;
 814     if (EFI_ERROR (Status)) {
 815       return Status;
 816     }
 817
 818     BOpt_GetDriverOptions (Private);
 819   }
 820
 821   //
 822   // After user do the save action, need to update OldBmmData.
 823   //
 824   CopyMem (OldBmmData, NewBmmData, sizeof (BMM_FAKE_NV_DATA));
 825
 826   return EFI_SUCCESS;
 827 }
 828
 829 /**
 830   This function processes the results of changes in configuration.
 831
 832
 833   @param This               Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
 834   @param Action             Specifies the type of action taken by the browser.
 835   @param QuestionId         A unique value which is sent to the original exporting driver
 836                             so that it can identify the type of data to expect.
 837   @param Type               The type of value for the question.
 838   @param Value              A pointer to the data being sent to the original exporting driver.
 839   @param ActionRequest      On return, points to the action requested by the callback function.
 840
 841   @retval EFI_SUCCESS           The callback successfully handled the action.
 842   @retval EFI_OUT_OF_RESOURCES  Not enough storage is available to hold the variable and its data.
 843   @retval EFI_DEVICE_ERROR      The variable could not be saved.
 844   @retval EFI_UNSUPPORTED       The specified Action is not supported by the callback.
 845   @retval EFI_INVALID_PARAMETER The parameter of Value or ActionRequest is invalid.
 846 **/
 847 EFI_STATUS
 848 EFIAPI
 849 BootMaintCallback (
 850   IN  CONST EFI_HII_CONFIG_ACCESS_PROTOCOL         *This,
 851   IN        EFI_BROWSER_ACTION                     Action,
 852   IN        EFI_QUESTION_ID                        QuestionId,
 853   IN        UINT8                                  Type,
 854   IN        EFI_IFR_TYPE_VALUE                     *Value,
 855   OUT       EFI_BROWSER_ACTION_REQUEST             *ActionRequest
 856   )
 857 {
 858   BMM_CALLBACK_DATA *Private;
 859   BM_MENU_ENTRY     *NewMenuEntry;
 860   BMM_FAKE_NV_DATA  *CurrentFakeNVMap;
 861   UINTN             OldValue;
 862   UINTN             NewValue;
 863   UINTN             Number;
 864   UINTN             Index;
 865   EFI_DEVICE_PATH_PROTOCOL * File;
 866
 867   if (Action != EFI_BROWSER_ACTION_CHANGING && Action != EFI_BROWSER_ACTION_CHANGED) {
 868     //
 869     // Do nothing for other UEFI Action. Only do call back when data is changed.
 870     //
 871     return EFI_UNSUPPORTED;
 872   }
 873   OldValue       = 0;
 874   NewValue       = 0;
 875   Number         = 0;
 876
 877   Private        = BMM_CALLBACK_DATA_FROM_THIS (This);
 878   //
 879   // Retrive uncommitted data from Form Browser
 880   //
 881   CurrentFakeNVMap = &Private->BmmFakeNvData;
 882   HiiGetBrowserData (&mBootMaintGuid, mBootMaintStorageName, sizeof (BMM_FAKE_NV_DATA), (UINT8 *) CurrentFakeNVMap);
 883
 884   if (Action == EFI_BROWSER_ACTION_CHANGING) {
 885     if (Value == NULL) {
 886       return EFI_INVALID_PARAMETER;
 887     }
 888
 889     UpdatePageId (Private, QuestionId);
 890
 891     if (QuestionId < FILE_OPTION_OFFSET) {
 892       if (QuestionId < CONFIG_OPTION_OFFSET) {
 893         switch (QuestionId) {
 894         case FORM_BOOT_ADD_ID:
 895           // Leave BMM and enter FileExplorer.
 896           ChooseFile( NULL, L".efi", (CHOOSE_HANDLER) CreateBootOptionFromFile, &File);
 897           break;
 898
 899         case FORM_DRV_ADD_FILE_ID:
 900           // Leave BMM and enter FileExplorer.
 901           ChooseFile( NULL, L".efi", (CHOOSE_HANDLER) CreateDriverOptionFromFile, &File);
 902           break;
 903
 904         case FORM_DRV_ADD_HANDLE_ID:
 905           CleanUpPage (FORM_DRV_ADD_HANDLE_ID, Private);
 906           UpdateDrvAddHandlePage (Private);
 907           break;
 908
 909         case FORM_BOOT_DEL_ID:
 910           CleanUpPage (FORM_BOOT_DEL_ID, Private);
 911           UpdateBootDelPage (Private);
 912           break;
 913
 914         case FORM_BOOT_CHG_ID:
 915         case FORM_DRV_CHG_ID:
 916           UpdatePageBody (QuestionId, Private);
 917           break;
 918
 919         case FORM_DRV_DEL_ID:
 920           CleanUpPage (FORM_DRV_DEL_ID, Private);
 921           UpdateDrvDelPage (Private);
 922           break;
 923
 924         case FORM_BOOT_NEXT_ID:
 925           CleanUpPage (FORM_BOOT_NEXT_ID, Private);
 926           UpdateBootNextPage (Private);
 927           break;
 928
 929         case FORM_TIME_OUT_ID:
 930           CleanUpPage (FORM_TIME_OUT_ID, Private);
 931           UpdateTimeOutPage (Private);
 932           break;
 933
 934         case FORM_CON_IN_ID:
 935         case FORM_CON_OUT_ID:
 936         case FORM_CON_ERR_ID:
 937           UpdatePageBody (QuestionId, Private);
 938           break;
 939
 940         case FORM_CON_MODE_ID:
 941           CleanUpPage (FORM_CON_MODE_ID, Private);
 942           UpdateConModePage (Private);
 943           break;
 944
 945         case FORM_CON_COM_ID:
 946           CleanUpPage (FORM_CON_COM_ID, Private);
 947           UpdateConCOMPage (Private);
 948           break;
 949
 950         default:
 951           break;
 952         }
 953       } else if ((QuestionId >= TERMINAL_OPTION_OFFSET) && (QuestionId < CONSOLE_OPTION_OFFSET)) {
 954         Index                  = (UINT16) (QuestionId - TERMINAL_OPTION_OFFSET);
 955         Private->CurrentTerminal  = Index;
 956
 957         CleanUpPage (FORM_CON_COM_SETUP_ID, Private);
 958         UpdateTerminalPage (Private);
 959
 960       } else if (QuestionId >= HANDLE_OPTION_OFFSET) {
 961         Index                  = (UINT16) (QuestionId - HANDLE_OPTION_OFFSET);
 962
 963         NewMenuEntry            = BOpt_GetMenuEntry (&DriverMenu, Index);
 964         ASSERT (NewMenuEntry != NULL);
 965         Private->HandleContext  = (BM_HANDLE_CONTEXT *) NewMenuEntry->VariableContext;
 966
 967         CleanUpPage (FORM_DRV_ADD_HANDLE_DESC_ID, Private);
 968
 969         Private->MenuEntry                  = NewMenuEntry;
 970         Private->LoadContext->FilePathList  = Private->HandleContext->DevicePath;
 971
 972         UpdateDriverAddHandleDescPage (Private);
 973       }
 974     }
 975     if (QuestionId == KEY_VALUE_BOOT_FROM_FILE){
 976       // Leave BMM and enter FileExplorer.
 977       ChooseFile( NULL, L".efi", (CHOOSE_HANDLER) BootFromFile, &File);
 978     }
 979   } else if (Action == EFI_BROWSER_ACTION_CHANGED) {
 980     if ((Value == NULL) || (ActionRequest == NULL)) {
 981       return EFI_INVALID_PARAMETER;
 982     }
 983
 984     if (QuestionId == KEY_VALUE_SAVE_AND_EXIT_BOOT) {
 985       CurrentFakeNVMap->BootOptionChanged = FALSE;
 986       *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_SUBMIT_EXIT;
 987     } else if (QuestionId == KEY_VALUE_SAVE_AND_EXIT_DRIVER) {
 988       CurrentFakeNVMap->DriverOptionChanged = FALSE;
 989       *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_SUBMIT_EXIT;
 990     } else if (QuestionId == KEY_VALUE_NO_SAVE_AND_EXIT_DRIVER) {
 991       //
 992       // Discard changes and exit formset
 993       //
 994       CurrentFakeNVMap->DriverOptionalData[0]     = 0x0000;
 995       CurrentFakeNVMap->DriverDescriptionData[0]  = 0x0000;
 996       CurrentFakeNVMap->DriverOptionChanged = FALSE;
 997       CurrentFakeNVMap->ForceReconnect      = TRUE;
 998       *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_DISCARD_EXIT;
 999     } else if (QuestionId == KEY_VALUE_NO_SAVE_AND_EXIT_BOOT) {
1000       //
1001       // Discard changes and exit formset
1002       //
1003       CurrentFakeNVMap->BootOptionalData[0]     = 0x0000;
1004       CurrentFakeNVMap->BootDescriptionData[0]  = 0x0000;
1005       CurrentFakeNVMap->BootOptionChanged = FALSE;
1006       *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_DISCARD_EXIT;
1007     } else if (QuestionId == KEY_VALUE_BOOT_DESCRIPTION || QuestionId == KEY_VALUE_BOOT_OPTION) {
1008       CurrentFakeNVMap->BootOptionChanged = TRUE;
1009     } else if (QuestionId == KEY_VALUE_DRIVER_DESCRIPTION || QuestionId == KEY_VALUE_DRIVER_OPTION) {
1010       CurrentFakeNVMap->DriverOptionChanged = TRUE;
1011     }
1012
1013     if ((QuestionId >= BOOT_OPTION_DEL_QUESTION_ID) && (QuestionId < BOOT_OPTION_DEL_QUESTION_ID + MAX_MENU_NUMBER)) {
1014       if (Value->b){
1015         //
1016         // Means user try to delete this boot option but not press F10 or "Commit Changes and Exit" menu.
1017         //
1018         CurrentFakeNVMap->BootOptionDelMark[QuestionId - BOOT_OPTION_DEL_QUESTION_ID] = TRUE;
1019       } else {
1020         //
1021         // Means user remove the old check status.
1022         //
1023         CurrentFakeNVMap->BootOptionDelMark[QuestionId - BOOT_OPTION_DEL_QUESTION_ID] = FALSE;
1024       }
1025     } else if ((QuestionId >= DRIVER_OPTION_DEL_QUESTION_ID) && (QuestionId < DRIVER_OPTION_DEL_QUESTION_ID + MAX_MENU_NUMBER)) {
1026       if (Value->b){
1027         CurrentFakeNVMap->DriverOptionDelMark[QuestionId - DRIVER_OPTION_DEL_QUESTION_ID] = TRUE;
1028       } else {
1029         CurrentFakeNVMap->DriverOptionDelMark[QuestionId - DRIVER_OPTION_DEL_QUESTION_ID] = FALSE;
1030       }
1031     } else {
1032       switch (QuestionId) {
1033       case KEY_VALUE_SAVE_AND_EXIT:
1034       case KEY_VALUE_NO_SAVE_AND_EXIT:
1035         if (QuestionId == KEY_VALUE_SAVE_AND_EXIT) {
1036           *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_SUBMIT_EXIT;
1037         } else if (QuestionId == KEY_VALUE_NO_SAVE_AND_EXIT) {
1038           DiscardChangeHandler (Private, CurrentFakeNVMap);
1039           *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_DISCARD_EXIT;
1040         }
1041
1042         break;
1043
1044       case FORM_RESET:
1045         gRT->ResetSystem (EfiResetCold, EFI_SUCCESS, 0, NULL);
1046         return EFI_UNSUPPORTED;
1047
1048       default:
1049         break;
1050       }
1051     }
1052   }
1053
1054   //
1055   // Pass changed uncommitted data back to Form Browser
1056   //
1057   HiiSetBrowserData (&mBootMaintGuid, mBootMaintStorageName, sizeof (BMM_FAKE_NV_DATA), (UINT8 *) CurrentFakeNVMap, NULL);
1058
1059   return EFI_SUCCESS;
1060 }
1061
1062 /**
1063   Discard all changes done to the BMM pages such as Boot Order change,
1064   Driver order change.
1065
1066   @param Private            The BMM context data.
1067   @param CurrentFakeNVMap   The current Fack NV Map.
1068
1069 **/
1070 VOID
1071 DiscardChangeHandler (
1072   IN  BMM_CALLBACK_DATA               *Private,
1073   IN  BMM_FAKE_NV_DATA                *CurrentFakeNVMap
1074   )
1075 {
1076   UINT16  Index;
1077
1078   switch (Private->BmmPreviousPageId) {
1079   case FORM_BOOT_CHG_ID:
1080     CopyMem (CurrentFakeNVMap->BootOptionOrder, Private->BmmOldFakeNVData.BootOptionOrder, sizeof (CurrentFakeNVMap->BootOptionOrder));
1081     break;
1082
1083   case FORM_DRV_CHG_ID:
1084     CopyMem (CurrentFakeNVMap->DriverOptionOrder, Private->BmmOldFakeNVData.DriverOptionOrder, sizeof (CurrentFakeNVMap->DriverOptionOrder));
1085     break;
1086
1087   case FORM_BOOT_DEL_ID:
1088     ASSERT (BootOptionMenu.MenuNumber <= (sizeof (CurrentFakeNVMap->BootOptionDel) / sizeof (CurrentFakeNVMap->BootOptionDel[0])));
1089     for (Index = 0; Index < BootOptionMenu.MenuNumber; Index++) {
1090       CurrentFakeNVMap->BootOptionDel[Index] = FALSE;
1091     }
1092     break;
1093
1094   case FORM_DRV_DEL_ID:
1095     ASSERT (DriverOptionMenu.MenuNumber <= (sizeof (CurrentFakeNVMap->DriverOptionDel) / sizeof (CurrentFakeNVMap->DriverOptionDel[0])));
1096     for (Index = 0; Index < DriverOptionMenu.MenuNumber; Index++) {
1097       CurrentFakeNVMap->DriverOptionDel[Index] = FALSE;
1098     }
1099     break;
1100
1101   case FORM_BOOT_NEXT_ID:
1102     CurrentFakeNVMap->BootNext = Private->BmmOldFakeNVData.BootNext;
1103     break;
1104
1105   case FORM_TIME_OUT_ID:
1106     CurrentFakeNVMap->BootTimeOut = Private->BmmOldFakeNVData.BootTimeOut;
1107     break;
1108
1109   case FORM_DRV_ADD_HANDLE_DESC_ID:
1110   case FORM_DRV_ADD_FILE_ID:
1111   case FORM_DRV_ADD_HANDLE_ID:
1112     CurrentFakeNVMap->DriverAddHandleDesc[0]          = 0x0000;
1113     CurrentFakeNVMap->DriverAddHandleOptionalData[0]  = 0x0000;
1114     break;
1115
1116   default:
1117     break;
1118   }
1119 }
1120
1121 /**
1122   Create dynamic code for BMM.
1123
1124   @param  BmmCallbackInfo        The BMM context data.
1125
1126 **/
1127 VOID
1128 InitializeDrivers(
1129   IN BMM_CALLBACK_DATA        *BmmCallbackInfo
1130   )
1131 {
1132   EFI_HII_HANDLE              HiiHandle;
1133   VOID                        *StartOpCodeHandle;
1134   VOID                        *EndOpCodeHandle;
1135   EFI_IFR_GUID_LABEL          *StartLabel;
1136   EFI_IFR_GUID_LABEL          *EndLabel;
1137   UINTN                       Index;
1138   EFI_STRING                  String;
1139   EFI_STRING_ID               Token;
1140   EFI_STRING_ID               TokenHelp;
1141   EFI_HII_HANDLE              *HiiHandles;
1142   EFI_GUID                    FormSetGuid;
1143   CHAR16                      *DevicePathStr;
1144   EFI_STRING_ID               DevicePathId;
1145   EFI_IFR_FORM_SET            *Buffer;
1146   UINTN                       BufferSize;
1147   UINT8                       ClassGuidNum;
1148   EFI_GUID                    *ClassGuid;
1149   UINTN                       TempSize;
1150   UINT8                       *Ptr;
1151   EFI_STATUS                  Status;
1152
1153   TempSize =0;
1154   BufferSize = 0;
1155   Buffer = NULL;
1156
1157   HiiHandle = BmmCallbackInfo->BmmHiiHandle;
1158   //
1159   // Allocate space for creation of UpdateData Buffer
1160   //
1161   StartOpCodeHandle = HiiAllocateOpCodeHandle ();
1162   ASSERT (StartOpCodeHandle != NULL);
1163
1164   EndOpCodeHandle = HiiAllocateOpCodeHandle ();
1165   ASSERT (EndOpCodeHandle != NULL);
1166
1167   //
1168   // Create Hii Extend Label OpCode as the start opcode
1169   //
1170   StartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (StartOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL));
1171   StartLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
1172   StartLabel->Number       = LABEL_BMM_PLATFORM_INFORMATION;
1173
1174   //
1175   // Create Hii Extend Label OpCode as the end opcode
1176   //
1177   EndLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (EndOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL));
1178   EndLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
1179   EndLabel->Number       = LABEL_END;
1180
1181   //
1182   // Get all the Hii handles
1183   //
1184   HiiHandles = HiiGetHiiHandles (NULL);
1185   ASSERT (HiiHandles != NULL);
1186
1187   //
1188   // Search for formset of each class type
1189   //
1190   for (Index = 0; HiiHandles[Index] != NULL; Index++) {
1191     Status = HiiGetFormSetFromHiiHandle(HiiHandles[Index], &Buffer,&BufferSize);
1192     if (EFI_ERROR (Status)) {
1193       continue;
1194     }
1195
1196     Ptr = (UINT8 *)Buffer;
1197     while(TempSize < BufferSize)  {
1198       TempSize += ((EFI_IFR_OP_HEADER *) Ptr)->Length;
1199
1200       if (((EFI_IFR_OP_HEADER *) Ptr)->Length <= OFFSET_OF (EFI_IFR_FORM_SET, Flags)){
1201         Ptr += ((EFI_IFR_OP_HEADER *) Ptr)->Length;
1202         continue;
1203       }
1204
1205       //
1206       // Find FormSet OpCode
1207       //
1208       ClassGuidNum = (UINT8) (((EFI_IFR_FORM_SET *)Ptr)->Flags & 0x3);
1209       ClassGuid = (EFI_GUID *) (VOID *)(Ptr + sizeof (EFI_IFR_FORM_SET));
1210       while (ClassGuidNum-- > 0) {
1211         if (CompareGuid (&gEfiIfrBootMaintenanceGuid, ClassGuid) == 0){
1212           ClassGuid ++;
1213           continue;
1214         }
1215
1216         String = HiiGetString (HiiHandles[Index], ((EFI_IFR_FORM_SET *)Ptr)->FormSetTitle, NULL);
1217         if (String == NULL) {
1218           String = HiiGetString (HiiHandle, STRING_TOKEN (STR_MISSING_STRING), NULL);
1219           ASSERT (String != NULL);
1220         }
1221         Token = HiiSetString (HiiHandle, 0, String, NULL);
1222         FreePool (String);
1223
1224         String = HiiGetString (HiiHandles[Index], ((EFI_IFR_FORM_SET *)Ptr)->Help, NULL);
1225         if (String == NULL) {
1226           String = HiiGetString (HiiHandle, STRING_TOKEN (STR_MISSING_STRING), NULL);
1227           ASSERT (String != NULL);
1228         }
1229         TokenHelp = HiiSetString (HiiHandle, 0, String, NULL);
1230         FreePool (String);
1231
1232         FormSetGuid = ((EFI_IFR_FORM_SET *)Ptr)->Guid;
1233
1234         DevicePathStr = BmmExtractDevicePathFromHiiHandle(HiiHandles[Index]);
1235         DevicePathId  = 0;
1236         if (DevicePathStr != NULL){
1237           DevicePathId = HiiSetString (HiiHandle, 0, DevicePathStr, NULL);
1238           FreePool (DevicePathStr);
1239         }
1240          HiiCreateGotoExOpCode (
1241            StartOpCodeHandle,
1242            0,
1243            Token,
1244            TokenHelp,
1245            0,
1246            (EFI_QUESTION_ID) (Index + FRONT_PAGE_KEY_OFFSET),
1247            0,
1248            &FormSetGuid,
1249            DevicePathId
1250          );
1251         break;
1252       }
1253       Ptr += ((EFI_IFR_OP_HEADER *) Ptr)->Length;
1254     }
1255
1256     FreePool(Buffer);
1257     Buffer = NULL;
1258     TempSize = 0;
1259     BufferSize = 0;
1260   }
1261
1262   HiiUpdateForm (
1263     HiiHandle,
1264     &mBootMaintGuid,
1265     FORM_MAIN_ID,
1266     StartOpCodeHandle,
1267     EndOpCodeHandle
1268     );
1269
1270   HiiFreeOpCodeHandle (StartOpCodeHandle);
1271   HiiFreeOpCodeHandle (EndOpCodeHandle);
1272   FreePool (HiiHandles);
1273 }
1274
1275 /**
1276    Create dynamic code for BMM and initialize all of BMM configuration data in BmmFakeNvData and
1277    BmmOldFakeNVData member in BMM context data.
1278
1279   @param CallbackData    The BMM context data.
1280
1281 **/
1282 VOID
1283 InitializeBmmConfig (
1284   IN  BMM_CALLBACK_DATA    *CallbackData
1285   )
1286 {
1287   BM_MENU_ENTRY   *NewMenuEntry;
1288   BM_LOAD_CONTEXT *NewLoadContext;
1289   UINT16          Index;
1290
1291   ASSERT (CallbackData != NULL);
1292
1293   InitializeDrivers (CallbackData);
1294
1295   //
1296   // Initialize data which located in BMM main page
1297   //
1298   CallbackData->BmmFakeNvData.BootNext = (UINT16) (BootOptionMenu.MenuNumber);
1299   for (Index = 0; Index < BootOptionMenu.MenuNumber; Index++) {
1300     NewMenuEntry    = BOpt_GetMenuEntry (&BootOptionMenu, Index);
1301     NewLoadContext  = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
1302
1303     if (NewLoadContext->IsBootNext) {
1304       CallbackData->BmmFakeNvData.BootNext = Index;
1305       break;
1306     }
1307   }
1308
1309   CallbackData->BmmFakeNvData.BootTimeOut = PcdGet16 (PcdPlatformBootTimeOut);
1310
1311   //
1312   // Initialize data which located in Boot Options Menu
1313   //
1314   GetBootOrder (CallbackData);
1315
1316   //
1317   // Initialize data which located in Driver Options Menu
1318   //
1319   GetDriverOrder (CallbackData);
1320
1321   //
1322   // Initialize data which located in Console Options Menu
1323   //
1324   GetConsoleOutMode (CallbackData);
1325   GetConsoleInCheck (CallbackData);
1326   GetConsoleOutCheck (CallbackData);
1327   GetConsoleErrCheck (CallbackData);
1328   GetTerminalAttribute (CallbackData);
1329
1330   CallbackData->BmmFakeNvData.ForceReconnect = TRUE;
1331
1332   //
1333   // Backup Initialize BMM configuartion data to BmmOldFakeNVData
1334   //
1335   CopyMem (&CallbackData->BmmOldFakeNVData, &CallbackData->BmmFakeNvData, sizeof (BMM_FAKE_NV_DATA));
1336 }
1337
1338 /**
1339   Initialized all Menu Option List.
1340
1341   @param CallbackData    The BMM context data.
1342
1343 **/
1344 VOID
1345 InitAllMenu (
1346   IN  BMM_CALLBACK_DATA    *CallbackData
1347   )
1348 {
1349   InitializeListHead (&BootOptionMenu.Head);
1350   InitializeListHead (&DriverOptionMenu.Head);
1351   BOpt_GetBootOptions (CallbackData);
1352   BOpt_GetDriverOptions (CallbackData);
1353   BOpt_FindDrivers ();
1354   InitializeListHead (&ConsoleInpMenu.Head);
1355   InitializeListHead (&ConsoleOutMenu.Head);
1356   InitializeListHead (&ConsoleErrMenu.Head);
1357   InitializeListHead (&TerminalMenu.Head);
1358   LocateSerialIo ();
1359   GetAllConsoles ();
1360   mAllMenuInit = TRUE;
1361 }
1362
1363 /**
1364   Free up all Menu Option list.
1365
1366 **/
1367 VOID
1368 FreeAllMenu (
1369   VOID
1370   )
1371 {
1372   if (!mAllMenuInit){
1373     return;
1374   }
1375   BOpt_FreeMenu (&BootOptionMenu);
1376   BOpt_FreeMenu (&DriverOptionMenu);
1377   BOpt_FreeMenu (&DriverMenu);
1378   FreeAllConsoles ();
1379   mAllMenuInit = FALSE;
1380 }
1381
1382 /**
1383
1384   Install Boot Maintenance Manager Menu driver.
1385
1386   @param ImageHandle     The image handle.
1387   @param SystemTable     The system table.
1388
1389   @retval  EFI_SUCEESS  Install Boot manager menu success.
1390   @retval  Other        Return error status.
1391
1392 **/
1393 EFI_STATUS
1394 EFIAPI
1395 BootMaintenanceManagerLibConstructor (
1396   IN EFI_HANDLE                            ImageHandle,
1397   IN EFI_SYSTEM_TABLE                      *SystemTable
1398   )
1399
1400 {
1401   EFI_STATUS               Status;
1402   UINT8                    *Ptr;
1403
1404   Status = EFI_SUCCESS;
1405
1406   //
1407   // Install Device Path Protocol and Config Access protocol to driver handle
1408   //
1409   Status = gBS->InstallMultipleProtocolInterfaces (
1410                   &mBmmCallbackInfo->BmmDriverHandle,
1411                   &gEfiDevicePathProtocolGuid,
1412                   &mBmmHiiVendorDevicePath,
1413                   &gEfiHiiConfigAccessProtocolGuid,
1414                   &mBmmCallbackInfo->BmmConfigAccess,
1415                   NULL
1416                   );
1417   ASSERT_EFI_ERROR (Status);
1418
1419   //
1420   // Post our Boot Maint VFR binary to the HII database.
1421   //
1422   mBmmCallbackInfo->BmmHiiHandle = HiiAddPackages (
1423                                     &mBootMaintGuid,
1424                                     mBmmCallbackInfo->BmmDriverHandle,
1425                                     BootMaintenanceManagerBin,
1426                                     BootMaintenanceManagerLibStrings,
1427                                     NULL
1428                                     );
1429   ASSERT (mBmmCallbackInfo->BmmHiiHandle != NULL);
1430
1431   //
1432   // Locate Formbrowser2 protocol
1433   //
1434   Status = gBS->LocateProtocol (&gEfiFormBrowser2ProtocolGuid, NULL, (VOID **) &mBmmCallbackInfo->FormBrowser2);
1435   ASSERT_EFI_ERROR (Status);
1436
1437   EfiBootManagerRefreshAllBootOption ();
1438
1439   //
1440   // Create LoadOption in BmmCallbackInfo for Driver Callback
1441   //
1442   Ptr = AllocateZeroPool (sizeof (BM_LOAD_CONTEXT) + sizeof (BM_FILE_CONTEXT) + sizeof (BM_HANDLE_CONTEXT) + sizeof (BM_MENU_ENTRY));
1443   ASSERT (Ptr != NULL);
1444
1445   //
1446   // Initialize Bmm callback data.
1447   //
1448   mBmmCallbackInfo->LoadContext = (BM_LOAD_CONTEXT *) Ptr;
1449   Ptr += sizeof (BM_LOAD_CONTEXT);
1450
1451   mBmmCallbackInfo->FileContext = (BM_FILE_CONTEXT *) Ptr;
1452   Ptr += sizeof (BM_FILE_CONTEXT);
1453
1454   mBmmCallbackInfo->HandleContext = (BM_HANDLE_CONTEXT *) Ptr;
1455   Ptr += sizeof (BM_HANDLE_CONTEXT);
1456
1457   mBmmCallbackInfo->MenuEntry     = (BM_MENU_ENTRY *) Ptr;
1458
1459   mBmmCallbackInfo->BmmPreviousPageId  = FORM_MAIN_ID;
1460   mBmmCallbackInfo->BmmCurrentPageId   = FORM_MAIN_ID;
1461
1462   InitAllMenu (mBmmCallbackInfo);
1463
1464   CreateUpdateData();
1465   //
1466   // Update boot maintenance manager page
1467   //
1468   InitializeBmmConfig(mBmmCallbackInfo);
1469
1470   return EFI_SUCCESS;
1471 }
1472
1473 /**
1474   Unloads the application and its installed protocol.
1475
1476   @param ImageHandle       Handle that identifies the image to be unloaded.
1477   @param  SystemTable      The system table.
1478
1479   @retval EFI_SUCCESS      The image has been unloaded.
1480
1481 **/
1482 EFI_STATUS
1483 EFIAPI
1484 BootMaintenanceManagerLibDestructor (
1485   IN EFI_HANDLE                            ImageHandle,
1486   IN EFI_SYSTEM_TABLE                      *SystemTable
1487   )
1488
1489 {
1490   if (mStartOpCodeHandle != NULL) {
1491     HiiFreeOpCodeHandle (mStartOpCodeHandle);
1492   }
1493
1494   if (mEndOpCodeHandle != NULL) {
1495     HiiFreeOpCodeHandle (mEndOpCodeHandle);
1496   }
1497
1498   FreeAllMenu ();
1499
1500   //
1501   // Remove our IFR data from HII database
1502   //
1503   HiiRemovePackages (mBmmCallbackInfo->BmmHiiHandle);
1504
1505   gBS->UninstallMultipleProtocolInterfaces (
1506          mBmmCallbackInfo->BmmDriverHandle,
1507          &gEfiDevicePathProtocolGuid,
1508          &mBmmHiiVendorDevicePath,
1509          &gEfiHiiConfigAccessProtocolGuid,
1510          &mBmmCallbackInfo->BmmConfigAccess,
1511          NULL
1512          );
1513
1514   FreePool (mBmmCallbackInfo->LoadContext);
1515
1516   return EFI_SUCCESS;
1517 }
1518