MdeModulePkg/Library/BootMaintenanceManagerUiLib/BootMaintenance.c

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