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