MdeModulePkg/Library/BootMaintenanceManagerUiLib/UpdatePage.c

   1 /** @file
   2 Dynamically update the pages.
   3
   4 Copyright (c) 2004 - 2015, Intel Corporation. All rights reserved.<BR>
   5 This program and the accompanying materials
   6 are licensed and made available under the terms and conditions of the BSD License
   7 which accompanies this distribution.  The full text of the license may be found at
   8 http://opensource.org/licenses/bsd-license.php
   9
  10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13 **/
  14
  15 #include "BootMaintenanceManager.h"
  16
  17 /**
  18  Create the global UpdateData structure.
  19
  20 **/
  21 VOID
  22 CreateUpdateData (
  23   VOID
  24   )
  25 {
  26   //
  27   // Init OpCode Handle and Allocate space for creation of Buffer
  28   //
  29   mStartOpCodeHandle = HiiAllocateOpCodeHandle ();
  30   ASSERT (mStartOpCodeHandle != NULL);
  31
  32   mEndOpCodeHandle = HiiAllocateOpCodeHandle ();
  33   ASSERT (mEndOpCodeHandle != NULL);
  34
  35   //
  36   // Create Hii Extend Label OpCode as the start opcode
  37   //
  38   mStartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (mStartOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL));
  39   mStartLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
  40
  41   //
  42   // Create Hii Extend Label OpCode as the end opcode
  43   //
  44   mEndLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (mEndOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL));
  45   mEndLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
  46   mEndLabel->Number       = LABEL_END;
  47 }
  48
  49 /**
  50   Refresh the global UpdateData structure.
  51
  52 **/
  53 VOID
  54 RefreshUpdateData (
  55   VOID
  56   )
  57 {
  58   //
  59   // Free current updated date
  60   //
  61   if (mStartOpCodeHandle != NULL) {
  62     HiiFreeOpCodeHandle (mStartOpCodeHandle);
  63   }
  64
  65   //
  66   // Create new OpCode Handle
  67   //
  68   mStartOpCodeHandle = HiiAllocateOpCodeHandle ();
  69
  70   //
  71   // Create Hii Extend Label OpCode as the start opcode
  72   //
  73   mStartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (mStartOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL));
  74   mStartLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
  75
  76 }
  77
  78 /**
  79   Add a "Go back to main page" tag in front of the form when there are no
  80   "Apply changes" and "Discard changes" tags in the end of the form.
  81
  82   @param CallbackData    The BMM context data.
  83
  84 **/
  85 VOID
  86 UpdatePageStart (
  87   IN BMM_CALLBACK_DATA                *CallbackData
  88   )
  89 {
  90   RefreshUpdateData ();
  91   mStartLabel->Number = CallbackData->BmmCurrentPageId;
  92
  93   if (!(CallbackData->BmmAskSaveOrNot)) {
  94     //
  95     // Add a "Go back to main page" tag in front of the form when there are no
  96     // "Apply changes" and "Discard changes" tags in the end of the form.
  97     //
  98     HiiCreateGotoOpCode (
  99       mStartOpCodeHandle,
 100       FORM_MAIN_ID,
 101       STRING_TOKEN (STR_FORM_GOTO_MAIN),
 102       STRING_TOKEN (STR_FORM_GOTO_MAIN),
 103       0,
 104       FORM_MAIN_ID
 105       );
 106   }
 107 }
 108
 109 /**
 110   Create the "Apply changes" and "Discard changes" tags. And
 111   ensure user can return to the main page.
 112
 113   @param CallbackData    The BMM context data.
 114
 115 **/
 116 VOID
 117 UpdatePageEnd (
 118   IN BMM_CALLBACK_DATA                *CallbackData
 119   )
 120 {
 121   //
 122   // Create the "Apply changes" and "Discard changes" tags.
 123   //
 124   if (CallbackData->BmmAskSaveOrNot) {
 125     HiiCreateSubTitleOpCode (
 126       mStartOpCodeHandle,
 127       STRING_TOKEN (STR_NULL_STRING),
 128       0,
 129       0,
 130       0
 131       );
 132
 133     HiiCreateActionOpCode (
 134       mStartOpCodeHandle,
 135       KEY_VALUE_SAVE_AND_EXIT,
 136       STRING_TOKEN (STR_SAVE_AND_EXIT),
 137       STRING_TOKEN (STR_NULL_STRING),
 138       EFI_IFR_FLAG_CALLBACK,
 139       0
 140       );
 141   }
 142
 143   //
 144   // Ensure user can return to the main page.
 145   //
 146   HiiCreateActionOpCode (
 147     mStartOpCodeHandle,
 148     KEY_VALUE_NO_SAVE_AND_EXIT,
 149     STRING_TOKEN (STR_NO_SAVE_AND_EXIT),
 150     STRING_TOKEN (STR_NULL_STRING),
 151     EFI_IFR_FLAG_CALLBACK,
 152     0
 153     );
 154
 155   HiiUpdateForm (
 156     CallbackData->BmmHiiHandle,
 157     &mBootMaintGuid,
 158     CallbackData->BmmCurrentPageId,
 159     mStartOpCodeHandle, // Label CallbackData->BmmCurrentPageId
 160     mEndOpCodeHandle    // LABEL_END
 161     );
 162 }
 163
 164 /**
 165   Clean up the dynamic opcode at label and form specified by both LabelId.
 166
 167   @param LabelId         It is both the Form ID and Label ID for opcode deletion.
 168   @param CallbackData    The BMM context data.
 169
 170 **/
 171 VOID
 172 CleanUpPage (
 173   IN UINT16                           LabelId,
 174   IN BMM_CALLBACK_DATA                *CallbackData
 175   )
 176 {
 177   RefreshUpdateData ();
 178
 179   //
 180   // Remove all op-codes from dynamic page
 181   //
 182   mStartLabel->Number = LabelId;
 183   HiiUpdateForm (
 184     CallbackData->BmmHiiHandle,
 185     &mBootMaintGuid,
 186     LabelId,
 187     mStartOpCodeHandle, // Label LabelId
 188     mEndOpCodeHandle    // LABEL_END
 189     );
 190 }
 191
 192 /**
 193   Create a list of Goto Opcode for all terminal devices logged
 194   by TerminaMenu. This list will be inserted to form FORM_CON_COM_SETUP_ID.
 195
 196   @param CallbackData    The BMM context data.
 197 **/
 198 VOID
 199 UpdateConCOMPage (
 200   IN BMM_CALLBACK_DATA                *CallbackData
 201   )
 202 {
 203   BM_MENU_ENTRY       *NewMenuEntry;
 204   UINT16              Index;
 205
 206   CallbackData->BmmAskSaveOrNot = TRUE;
 207
 208   UpdatePageStart (CallbackData);
 209
 210   for (Index = 0; Index < TerminalMenu.MenuNumber; Index++) {
 211     NewMenuEntry = BOpt_GetMenuEntry (&TerminalMenu, Index);
 212
 213     HiiCreateGotoOpCode (
 214       mStartOpCodeHandle,
 215       FORM_CON_COM_SETUP_ID,
 216       NewMenuEntry->DisplayStringToken,
 217       STRING_TOKEN (STR_NULL_STRING),
 218       EFI_IFR_FLAG_CALLBACK,
 219       (UINT16) (TERMINAL_OPTION_OFFSET + Index)
 220       );
 221   }
 222
 223   UpdatePageEnd (CallbackData);
 224 }
 225
 226
 227 /**
 228   Create a list of boot option from global BootOptionMenu. It
 229   allow user to delete the boot option.
 230
 231   @param CallbackData    The BMM context data.
 232
 233 **/
 234 VOID
 235 UpdateBootDelPage (
 236   IN BMM_CALLBACK_DATA                *CallbackData
 237   )
 238 {
 239   BM_MENU_ENTRY   *NewMenuEntry;
 240   BM_LOAD_CONTEXT *NewLoadContext;
 241   UINT16          Index;
 242
 243   CallbackData->BmmAskSaveOrNot = TRUE;
 244
 245   UpdatePageStart (CallbackData);
 246
 247   ASSERT (BootOptionMenu.MenuNumber <= (sizeof (CallbackData->BmmFakeNvData.BootOptionDel) / sizeof (CallbackData->BmmFakeNvData.BootOptionDel[0])));
 248   for (Index = 0; Index < BootOptionMenu.MenuNumber; Index++) {
 249     NewMenuEntry    = BOpt_GetMenuEntry (&BootOptionMenu, Index);
 250     NewLoadContext  = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
 251     if (NewLoadContext->IsLegacy) {
 252       continue;
 253     }
 254
 255     NewLoadContext->Deleted = FALSE;
 256
 257     if (CallbackData->BmmFakeNvData.BootOptionDel[Index] && !CallbackData->BmmFakeNvData.BootOptionDelMark[Index]) {
 258       //
 259       // CallbackData->BmmFakeNvData.BootOptionDel[Index] == TRUE means browser knows this boot option is selected
 260       // CallbackData->BmmFakeNvData.BootOptionDelMark[Index] = FALSE means BDS knows the selected boot option has
 261       // deleted, browser maintains old useless info. So clear this info here, and later update this info to browser
 262       // through HiiSetBrowserData function.
 263       //
 264       CallbackData->BmmFakeNvData.BootOptionDel[Index] = FALSE;
 265     }
 266
 267     HiiCreateCheckBoxOpCode (
 268       mStartOpCodeHandle,
 269       (EFI_QUESTION_ID) (BOOT_OPTION_DEL_QUESTION_ID + Index),
 270       VARSTORE_ID_BOOT_MAINT,
 271       (UINT16) (BOOT_OPTION_DEL_VAR_OFFSET + Index),
 272       NewMenuEntry->DisplayStringToken,
 273       NewMenuEntry->HelpStringToken,
 274       EFI_IFR_FLAG_CALLBACK,
 275       0,
 276       NULL
 277       );
 278   }
 279   UpdatePageEnd (CallbackData);
 280 }
 281
 282 /**
 283   Create a lit of driver option from global DriverMenu.
 284
 285   @param CallbackData    The BMM context data.
 286
 287 **/
 288 VOID
 289 UpdateDrvAddHandlePage (
 290   IN BMM_CALLBACK_DATA                *CallbackData
 291   )
 292 {
 293   BM_MENU_ENTRY *NewMenuEntry;
 294   UINT16        Index;
 295
 296   CallbackData->BmmAskSaveOrNot = FALSE;
 297
 298   UpdatePageStart (CallbackData);
 299
 300   for (Index = 0; Index < DriverMenu.MenuNumber; Index++) {
 301     NewMenuEntry = BOpt_GetMenuEntry (&DriverMenu, Index);
 302
 303     HiiCreateGotoOpCode (
 304       mStartOpCodeHandle,
 305       FORM_DRV_ADD_HANDLE_DESC_ID,
 306       NewMenuEntry->DisplayStringToken,
 307       STRING_TOKEN (STR_NULL_STRING),
 308       EFI_IFR_FLAG_CALLBACK,
 309       (UINT16) (HANDLE_OPTION_OFFSET + Index)
 310       );
 311   }
 312
 313   UpdatePageEnd (CallbackData);
 314 }
 315
 316 /**
 317   Create a lit of driver option from global DriverOptionMenu. It
 318   allow user to delete the driver option.
 319
 320   @param CallbackData    The BMM context data.
 321
 322 **/
 323 VOID
 324 UpdateDrvDelPage (
 325   IN BMM_CALLBACK_DATA                *CallbackData
 326   )
 327 {
 328   BM_MENU_ENTRY   *NewMenuEntry;
 329   BM_LOAD_CONTEXT *NewLoadContext;
 330   UINT16          Index;
 331
 332   CallbackData->BmmAskSaveOrNot = TRUE;
 333
 334   UpdatePageStart (CallbackData);
 335
 336   ASSERT (DriverOptionMenu.MenuNumber <= (sizeof (CallbackData->BmmFakeNvData.DriverOptionDel) / sizeof (CallbackData->BmmFakeNvData.DriverOptionDel[0])));
 337   for (Index = 0; Index < DriverOptionMenu.MenuNumber; Index++) {
 338     NewMenuEntry            = BOpt_GetMenuEntry (&DriverOptionMenu, Index);
 339
 340     NewLoadContext          = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
 341     NewLoadContext->Deleted = FALSE;
 342
 343     if (CallbackData->BmmFakeNvData.DriverOptionDel[Index] && !CallbackData->BmmFakeNvData.DriverOptionDelMark[Index]) {
 344       //
 345       // CallbackData->BmmFakeNvData.BootOptionDel[Index] == TRUE means browser knows this boot option is selected
 346       // CallbackData->BmmFakeNvData.BootOptionDelMark[Index] = FALSE means BDS knows the selected boot option has
 347       // deleted, browser maintains old useless info. So clear this info here, and later update this info to browser
 348       // through HiiSetBrowserData function.
 349       //
 350       CallbackData->BmmFakeNvData.DriverOptionDel[Index] = FALSE;
 351     }
 352     HiiCreateCheckBoxOpCode (
 353       mStartOpCodeHandle,
 354       (EFI_QUESTION_ID) (DRIVER_OPTION_DEL_QUESTION_ID + Index),
 355       VARSTORE_ID_BOOT_MAINT,
 356       (UINT16) (DRIVER_OPTION_DEL_VAR_OFFSET + Index),
 357       NewMenuEntry->DisplayStringToken,
 358       NewMenuEntry->HelpStringToken,
 359       EFI_IFR_FLAG_CALLBACK,
 360       0,
 361       NULL
 362       );
 363   }
 364
 365   UpdatePageEnd (CallbackData);
 366 }
 367
 368 /**
 369   Prepare the page to allow user to add description for
 370   a Driver Option.
 371
 372   @param CallbackData    The BMM context data.
 373
 374 **/
 375 VOID
 376 UpdateDriverAddHandleDescPage (
 377   IN BMM_CALLBACK_DATA                *CallbackData
 378   )
 379 {
 380   BM_MENU_ENTRY *NewMenuEntry;
 381
 382   CallbackData->BmmFakeNvData.DriverAddActive          = 0x01;
 383   CallbackData->BmmFakeNvData.DriverAddForceReconnect  = 0x00;
 384   CallbackData->BmmAskSaveOrNot                        = TRUE;
 385   NewMenuEntry = CallbackData->MenuEntry;
 386
 387   UpdatePageStart (CallbackData);
 388
 389   HiiCreateSubTitleOpCode (
 390     mStartOpCodeHandle,
 391     NewMenuEntry->DisplayStringToken,
 392     0,
 393     0,
 394     0
 395     );
 396
 397   HiiCreateStringOpCode (
 398     mStartOpCodeHandle,
 399     (EFI_QUESTION_ID) DRV_ADD_HANDLE_DESC_QUESTION_ID,
 400     VARSTORE_ID_BOOT_MAINT,
 401     DRV_ADD_HANDLE_DESC_VAR_OFFSET,
 402     STRING_TOKEN (STR_LOAD_OPTION_DESC),
 403     STRING_TOKEN (STR_NULL_STRING),
 404     0,
 405     0,
 406     6,
 407     75,
 408     NULL
 409     );
 410
 411   HiiCreateCheckBoxOpCode (
 412     mStartOpCodeHandle,
 413     (EFI_QUESTION_ID) DRV_ADD_RECON_QUESTION_ID,
 414     VARSTORE_ID_BOOT_MAINT,
 415     DRV_ADD_RECON_VAR_OFFSET,
 416     STRING_TOKEN (STR_LOAD_OPTION_FORCE_RECON),
 417     STRING_TOKEN (STR_LOAD_OPTION_FORCE_RECON),
 418     0,
 419     0,
 420     NULL
 421     );
 422
 423   HiiCreateStringOpCode (
 424     mStartOpCodeHandle,
 425     (EFI_QUESTION_ID) DRIVER_ADD_OPTION_QUESTION_ID,
 426     VARSTORE_ID_BOOT_MAINT,
 427     DRIVER_ADD_OPTION_VAR_OFFSET,
 428     STRING_TOKEN (STR_OPTIONAL_DATA),
 429     STRING_TOKEN (STR_NULL_STRING),
 430     0,
 431     0,
 432     6,
 433     75,
 434     NULL
 435     );
 436
 437   UpdatePageEnd (CallbackData);
 438 }
 439
 440 /**
 441   Update console page.
 442
 443   @param UpdatePageId    The form ID to be updated.
 444   @param ConsoleMenu     The console menu list.
 445   @param CallbackData    The BMM context data.
 446
 447 **/
 448 VOID
 449 UpdateConsolePage (
 450   IN UINT16                           UpdatePageId,
 451   IN BM_MENU_OPTION                   *ConsoleMenu,
 452   IN BMM_CALLBACK_DATA                *CallbackData
 453   )
 454 {
 455   BM_MENU_ENTRY       *NewMenuEntry;
 456   BM_CONSOLE_CONTEXT  *NewConsoleContext;
 457   BM_TERMINAL_CONTEXT *NewTerminalContext;
 458   UINT16              Index;
 459   UINT16              Index2;
 460   UINT8               CheckFlags;
 461   UINT8               *ConsoleCheck;
 462   UINT8               *OldConsoleCheck;
 463   UINTN               ConsoleCheckSize;
 464   EFI_QUESTION_ID     QuestionIdBase;
 465   UINT16              VariableOffsetBase;
 466
 467   CallbackData->BmmAskSaveOrNot = TRUE;
 468
 469   UpdatePageStart (CallbackData);
 470
 471   ConsoleCheck       = NULL;
 472   OldConsoleCheck    = NULL;
 473   QuestionIdBase     = 0;
 474   VariableOffsetBase = 0;
 475   ConsoleCheckSize   = 0;
 476
 477   switch (UpdatePageId) {
 478   case FORM_CON_IN_ID:
 479     ConsoleCheck       = &CallbackData->BmmFakeNvData.ConsoleInCheck[0];
 480     OldConsoleCheck    = &CallbackData->BmmOldFakeNVData.ConsoleInCheck[0];
 481     ConsoleCheckSize   = sizeof (CallbackData->BmmFakeNvData.ConsoleInCheck);
 482     QuestionIdBase     = CON_IN_DEVICE_QUESTION_ID;
 483     VariableOffsetBase = CON_IN_DEVICE_VAR_OFFSET;
 484     break;
 485
 486   case FORM_CON_OUT_ID:
 487     ConsoleCheck       = &CallbackData->BmmFakeNvData.ConsoleOutCheck[0];
 488     OldConsoleCheck    = &CallbackData->BmmOldFakeNVData.ConsoleOutCheck[0];
 489     ConsoleCheckSize   = sizeof (CallbackData->BmmFakeNvData.ConsoleOutCheck);
 490     QuestionIdBase     = CON_OUT_DEVICE_QUESTION_ID;
 491     VariableOffsetBase = CON_OUT_DEVICE_VAR_OFFSET;
 492     break;
 493
 494   case FORM_CON_ERR_ID:
 495     ConsoleCheck       = &CallbackData->BmmFakeNvData.ConsoleErrCheck[0];
 496     OldConsoleCheck    = &CallbackData->BmmOldFakeNVData.ConsoleErrCheck[0];
 497     ConsoleCheckSize   = sizeof (CallbackData->BmmFakeNvData.ConsoleErrCheck);
 498     QuestionIdBase     = CON_ERR_DEVICE_QUESTION_ID;
 499     VariableOffsetBase = CON_ERR_DEVICE_VAR_OFFSET;
 500     break;
 501   }
 502   ASSERT (ConsoleCheck != NULL);
 503
 504   for (Index = 0; ((Index < ConsoleMenu->MenuNumber) && \
 505        (Index < MAX_MENU_NUMBER)) ; Index++) {
 506     CheckFlags = 0;
 507     NewMenuEntry = BOpt_GetMenuEntry (ConsoleMenu, Index);
 508     NewConsoleContext = (BM_CONSOLE_CONTEXT *) NewMenuEntry->VariableContext;
 509     if (NewConsoleContext->IsActive) {
 510       CheckFlags |= EFI_IFR_CHECKBOX_DEFAULT;
 511       ConsoleCheck[Index] = TRUE;
 512     } else {
 513       ConsoleCheck[Index] = FALSE;
 514     }
 515     HiiCreateCheckBoxOpCode (
 516       mStartOpCodeHandle,
 517       (EFI_QUESTION_ID) (QuestionIdBase + Index),
 518       VARSTORE_ID_BOOT_MAINT,
 519       (UINT16) (VariableOffsetBase + Index),
 520       NewMenuEntry->DisplayStringToken,
 521       NewMenuEntry->HelpStringToken,
 522       0,
 523       CheckFlags,
 524       NULL
 525       );
 526   }
 527
 528   for (Index2 = 0; ((Index2 < TerminalMenu.MenuNumber) && \
 529        (Index2 < MAX_MENU_NUMBER)); Index2++) {
 530     CheckFlags          = 0;
 531     NewMenuEntry        = BOpt_GetMenuEntry (&TerminalMenu, Index2);
 532     NewTerminalContext  = (BM_TERMINAL_CONTEXT *) NewMenuEntry->VariableContext;
 533
 534     ASSERT (Index < MAX_MENU_NUMBER);
 535     if (((NewTerminalContext->IsConIn != 0) && (UpdatePageId == FORM_CON_IN_ID)) ||
 536         ((NewTerminalContext->IsConOut != 0) && (UpdatePageId == FORM_CON_OUT_ID)) ||
 537         ((NewTerminalContext->IsStdErr != 0) && (UpdatePageId == FORM_CON_ERR_ID))
 538         ) {
 539       CheckFlags |= EFI_IFR_CHECKBOX_DEFAULT;
 540       ConsoleCheck[Index] = TRUE;
 541     } else {
 542       ConsoleCheck[Index] = FALSE;
 543     }
 544     HiiCreateCheckBoxOpCode (
 545       mStartOpCodeHandle,
 546       (EFI_QUESTION_ID) (QuestionIdBase + Index),
 547       VARSTORE_ID_BOOT_MAINT,
 548       (UINT16) (VariableOffsetBase + Index),
 549       NewMenuEntry->DisplayStringToken,
 550       NewMenuEntry->HelpStringToken,
 551       0,
 552       CheckFlags,
 553       NULL
 554       );
 555
 556     Index++;
 557   }
 558
 559   CopyMem (OldConsoleCheck, ConsoleCheck, ConsoleCheckSize);
 560
 561   UpdatePageEnd (CallbackData);
 562 }
 563
 564 /**
 565   Update the page's NV Map if user has changed the order
 566   a list. This list can be Boot Order or Driver Order.
 567
 568   @param UpdatePageId    The form ID to be updated.
 569   @param OptionMenu      The new list.
 570   @param CallbackData    The BMM context data.
 571
 572 **/
 573 VOID
 574 UpdateOrderPage (
 575   IN UINT16                           UpdatePageId,
 576   IN BM_MENU_OPTION                   *OptionMenu,
 577   IN BMM_CALLBACK_DATA                *CallbackData
 578   )
 579 {
 580   BM_MENU_ENTRY     *NewMenuEntry;
 581   UINT16            Index;
 582   UINT16            OptionIndex;
 583   VOID              *OptionsOpCodeHandle;
 584   BOOLEAN           BootOptionFound;
 585   UINT32            *OptionOrder;
 586   EFI_QUESTION_ID   QuestionId;
 587   UINT16            VarOffset;
 588
 589   CallbackData->BmmAskSaveOrNot = TRUE;
 590   UpdatePageStart (CallbackData);
 591
 592   OptionOrder = NULL;
 593   QuestionId = 0;
 594   VarOffset = 0;
 595   switch (UpdatePageId) {
 596
 597   case FORM_BOOT_CHG_ID:
 598     GetBootOrder (CallbackData);
 599     OptionOrder = CallbackData->BmmFakeNvData.BootOptionOrder;
 600     QuestionId = BOOT_OPTION_ORDER_QUESTION_ID;
 601     VarOffset = BOOT_OPTION_ORDER_VAR_OFFSET;
 602     break;
 603
 604   case FORM_DRV_CHG_ID:
 605     GetDriverOrder (CallbackData);
 606     OptionOrder = CallbackData->BmmFakeNvData.DriverOptionOrder;
 607     QuestionId = DRIVER_OPTION_ORDER_QUESTION_ID;
 608     VarOffset = DRIVER_OPTION_ORDER_VAR_OFFSET;
 609     break;
 610   }
 611   ASSERT (OptionOrder != NULL);
 612
 613   OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
 614   ASSERT (OptionsOpCodeHandle != NULL);
 615
 616   NewMenuEntry = NULL;
 617   for (OptionIndex = 0; (OptionOrder[OptionIndex] != 0 && OptionIndex < MAX_MENU_NUMBER); OptionIndex++) {
 618     BootOptionFound = FALSE;
 619     for (Index = 0; Index < OptionMenu->MenuNumber; Index++) {
 620       NewMenuEntry   = BOpt_GetMenuEntry (OptionMenu, Index);
 621       if ((UINT32) (NewMenuEntry->OptionNumber + 1) == OptionOrder[OptionIndex]) {
 622         BootOptionFound = TRUE;
 623         break;
 624       }
 625     }
 626     if (BootOptionFound) {
 627       HiiCreateOneOfOptionOpCode (
 628         OptionsOpCodeHandle,
 629         NewMenuEntry->DisplayStringToken,
 630         0,
 631         EFI_IFR_TYPE_NUM_SIZE_32,
 632         OptionOrder[OptionIndex]
 633         );
 634     }
 635   }
 636
 637   if (OptionMenu->MenuNumber > 0) {
 638     HiiCreateOrderedListOpCode (
 639       mStartOpCodeHandle,                          // Container for dynamic created opcodes
 640       QuestionId,                                  // Question ID
 641       VARSTORE_ID_BOOT_MAINT,                      // VarStore ID
 642       VarOffset,                                   // Offset in Buffer Storage
 643       STRING_TOKEN (STR_CHANGE_ORDER),             // Question prompt text
 644       STRING_TOKEN (STR_CHANGE_ORDER),             // Question help text
 645       0,                                           // Question flag
 646       0,                                           // Ordered list flag, e.g. EFI_IFR_UNIQUE_SET
 647       EFI_IFR_TYPE_NUM_SIZE_32,                    // Data type of Question value
 648       100,                                         // Maximum container
 649       OptionsOpCodeHandle,                         // Option Opcode list
 650       NULL                                         // Default Opcode is NULL
 651       );
 652   }
 653
 654   HiiFreeOpCodeHandle (OptionsOpCodeHandle);
 655
 656   UpdatePageEnd (CallbackData);
 657
 658 }
 659
 660 /**
 661   Create the dynamic page to allow user to set
 662   the "BootNext" value.
 663
 664   @param CallbackData    The BMM context data.
 665
 666 **/
 667 VOID
 668 UpdateBootNextPage (
 669   IN BMM_CALLBACK_DATA                *CallbackData
 670   )
 671 {
 672   BM_MENU_ENTRY   *NewMenuEntry;
 673   BM_LOAD_CONTEXT *NewLoadContext;
 674   UINTN           NumberOfOptions;
 675   UINT16          Index;
 676   VOID            *OptionsOpCodeHandle;
 677
 678   NumberOfOptions               = BootOptionMenu.MenuNumber;
 679   CallbackData->BmmAskSaveOrNot = TRUE;
 680
 681   UpdatePageStart (CallbackData);
 682
 683   if (NumberOfOptions > 0) {
 684     OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
 685     ASSERT (OptionsOpCodeHandle != NULL);
 686
 687     CallbackData->BmmFakeNvData.BootNext = NONE_BOOTNEXT_VALUE;
 688
 689     for (Index = 0; Index < BootOptionMenu.MenuNumber; Index++) {
 690       NewMenuEntry    = BOpt_GetMenuEntry (&BootOptionMenu, Index);
 691       NewLoadContext  = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
 692
 693       if (NewLoadContext->IsBootNext) {
 694         HiiCreateOneOfOptionOpCode (
 695           OptionsOpCodeHandle,
 696           NewMenuEntry->DisplayStringToken,
 697           EFI_IFR_OPTION_DEFAULT,
 698           EFI_IFR_TYPE_NUM_SIZE_32,
 699           Index
 700           );
 701         CallbackData->BmmFakeNvData.BootNext = Index;
 702       } else {
 703         HiiCreateOneOfOptionOpCode (
 704           OptionsOpCodeHandle,
 705           NewMenuEntry->DisplayStringToken,
 706           0,
 707           EFI_IFR_TYPE_NUM_SIZE_32,
 708           Index
 709           );
 710       }
 711     }
 712
 713     if (CallbackData->BmmFakeNvData.BootNext == NONE_BOOTNEXT_VALUE) {
 714       HiiCreateOneOfOptionOpCode (
 715         OptionsOpCodeHandle,
 716         STRING_TOKEN (STR_NONE),
 717         EFI_IFR_OPTION_DEFAULT,
 718         EFI_IFR_TYPE_NUM_SIZE_32,
 719         NONE_BOOTNEXT_VALUE
 720         );
 721     } else {
 722       HiiCreateOneOfOptionOpCode (
 723         OptionsOpCodeHandle,
 724         STRING_TOKEN (STR_NONE),
 725         0,
 726         EFI_IFR_TYPE_NUM_SIZE_32,
 727         NONE_BOOTNEXT_VALUE
 728         );
 729     }
 730
 731     HiiCreateOneOfOpCode (
 732       mStartOpCodeHandle,
 733       (EFI_QUESTION_ID) BOOT_NEXT_QUESTION_ID,
 734       VARSTORE_ID_BOOT_MAINT,
 735       BOOT_NEXT_VAR_OFFSET,
 736       STRING_TOKEN (STR_BOOT_NEXT),
 737       STRING_TOKEN (STR_BOOT_NEXT_HELP),
 738       0,
 739       EFI_IFR_NUMERIC_SIZE_4,
 740       OptionsOpCodeHandle,
 741       NULL
 742       );
 743
 744     HiiFreeOpCodeHandle (OptionsOpCodeHandle);
 745   }
 746
 747   UpdatePageEnd (CallbackData);
 748 }
 749
 750 /**
 751   Create the dynamic page to allow user to set the "TimeOut" value.
 752
 753   @param CallbackData    The BMM context data.
 754
 755 **/
 756 VOID
 757 UpdateTimeOutPage (
 758   IN BMM_CALLBACK_DATA                *CallbackData
 759   )
 760 {
 761   VOID    *DefaultOpCodeHandle;
 762
 763   CallbackData->BmmAskSaveOrNot = TRUE;
 764
 765   UpdatePageStart (CallbackData);
 766
 767   DefaultOpCodeHandle = HiiAllocateOpCodeHandle ();
 768   ASSERT (DefaultOpCodeHandle != NULL);
 769   HiiCreateDefaultOpCode (DefaultOpCodeHandle, EFI_HII_DEFAULT_CLASS_STANDARD, EFI_IFR_TYPE_NUM_SIZE_16, CallbackData->BmmFakeNvData.BootTimeOut);
 770
 771   HiiCreateNumericOpCode (
 772     mStartOpCodeHandle,
 773     (EFI_QUESTION_ID) BOOT_TIME_OUT_QUESTION_ID,
 774     VARSTORE_ID_BOOT_MAINT,
 775     BOOT_TIME_OUT_VAR_OFFSET,
 776     STRING_TOKEN (STR_NUM_AUTO_BOOT),
 777     STRING_TOKEN (STR_HLP_AUTO_BOOT),
 778     0,
 779     EFI_IFR_NUMERIC_SIZE_2 | EFI_IFR_DISPLAY_UINT_DEC,
 780     0,
 781     65535,
 782     0,
 783     DefaultOpCodeHandle
 784     );
 785
 786   HiiFreeOpCodeHandle (DefaultOpCodeHandle);
 787
 788   UpdatePageEnd (CallbackData);
 789 }
 790
 791
 792 /**
 793   Refresh the text mode page.
 794
 795   @param CallbackData    The BMM context data.
 796
 797 **/
 798 VOID
 799 UpdateConModePage (
 800   IN BMM_CALLBACK_DATA                *CallbackData
 801   )
 802 {
 803   UINTN                         Mode;
 804   UINTN                         Index;
 805   UINTN                         Col;
 806   UINTN                         Row;
 807   CHAR16                        ModeString[50];
 808   CHAR16                        *PStr;
 809   UINTN                         MaxMode;
 810   UINTN                         ValidMode;
 811   EFI_STRING_ID                 *ModeToken;
 812   EFI_STATUS                    Status;
 813   VOID                          *OptionsOpCodeHandle;
 814   EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL  *ConOut;
 815
 816   ConOut    = gST->ConOut;
 817   Index     = 0;
 818   ValidMode = 0;
 819   MaxMode   = (UINTN) (ConOut->Mode->MaxMode);
 820
 821   CallbackData->BmmAskSaveOrNot = TRUE;
 822
 823   UpdatePageStart (CallbackData);
 824
 825   //
 826   // Check valid mode
 827   //
 828   for (Mode = 0; Mode < MaxMode; Mode++) {
 829     Status = ConOut->QueryMode (ConOut, Mode, &Col, &Row);
 830     if (EFI_ERROR (Status)) {
 831       continue;
 832     }
 833     ValidMode++;
 834   }
 835
 836   if (ValidMode == 0) {
 837     return;
 838   }
 839
 840   OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
 841   ASSERT (OptionsOpCodeHandle != NULL);
 842
 843   ModeToken           = AllocateZeroPool (sizeof (EFI_STRING_ID) * ValidMode);
 844   ASSERT(ModeToken != NULL);
 845
 846   //
 847   // Determin which mode should be the first entry in menu
 848   //
 849   GetConsoleOutMode (CallbackData);
 850
 851   //
 852   // Build text mode options
 853   //
 854   for (Mode = 0; Mode < MaxMode; Mode++) {
 855     Status = ConOut->QueryMode (ConOut, Mode, &Col, &Row);
 856     if (EFI_ERROR (Status)) {
 857       continue;
 858     }
 859
 860     //
 861     // Build mode string Column x Row
 862     //
 863     UnicodeValueToString (ModeString, 0, Col, 0);
 864     PStr = &ModeString[0];
 865     StrnCatS (PStr, sizeof (ModeString) / sizeof (ModeString[0]), L" x ", StrLen(L" x ") + 1);
 866     PStr = PStr + StrLen (PStr);
 867     UnicodeValueToString (PStr , 0, Row, 0);
 868
 869     ModeToken[Index] = HiiSetString (CallbackData->BmmHiiHandle, 0, ModeString, NULL);
 870
 871     if (Mode == CallbackData->BmmFakeNvData.ConsoleOutMode) {
 872       HiiCreateOneOfOptionOpCode (
 873         OptionsOpCodeHandle,
 874         ModeToken[Index],
 875         EFI_IFR_OPTION_DEFAULT,
 876         EFI_IFR_TYPE_NUM_SIZE_16,
 877         (UINT16) Mode
 878         );
 879     } else {
 880       HiiCreateOneOfOptionOpCode (
 881         OptionsOpCodeHandle,
 882         ModeToken[Index],
 883         0,
 884         EFI_IFR_TYPE_NUM_SIZE_16,
 885         (UINT16) Mode
 886         );
 887     }
 888     Index++;
 889   }
 890
 891   HiiCreateOneOfOpCode (
 892     mStartOpCodeHandle,
 893     (EFI_QUESTION_ID) CON_MODE_QUESTION_ID,
 894     VARSTORE_ID_BOOT_MAINT,
 895     CON_MODE_VAR_OFFSET,
 896     STRING_TOKEN (STR_CON_MODE_SETUP),
 897     STRING_TOKEN (STR_CON_MODE_SETUP),
 898     EFI_IFR_FLAG_RESET_REQUIRED,
 899     EFI_IFR_NUMERIC_SIZE_2,
 900     OptionsOpCodeHandle,
 901     NULL
 902     );
 903
 904   HiiFreeOpCodeHandle (OptionsOpCodeHandle);
 905   FreePool (ModeToken);
 906
 907   UpdatePageEnd (CallbackData);
 908 }
 909
 910  /**
 911   Create the dynamic page which allows user to set the property such as Baud Rate, Data Bits,
 912   Parity, Stop Bits, Terminal Type.
 913
 914   @param CallbackData    The BMM context data.
 915
 916 **/
 917 VOID
 918 UpdateTerminalPage (
 919   IN BMM_CALLBACK_DATA                *CallbackData
 920   )
 921 {
 922   UINT8               Index;
 923   UINT8               CheckFlags;
 924   BM_MENU_ENTRY       *NewMenuEntry;
 925   VOID                *OptionsOpCodeHandle;
 926   UINTN               CurrentTerminal;
 927
 928   CallbackData->BmmAskSaveOrNot = TRUE;
 929
 930   UpdatePageStart (CallbackData);
 931
 932   CurrentTerminal = CallbackData->CurrentTerminal;
 933   NewMenuEntry = BOpt_GetMenuEntry (
 934                   &TerminalMenu,
 935                   CurrentTerminal
 936                   );
 937
 938   if (NewMenuEntry == NULL) {
 939     return ;
 940   }
 941
 942   OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
 943   ASSERT (OptionsOpCodeHandle != NULL);
 944
 945   for (Index = 0; Index < sizeof (BaudRateList) / sizeof (BaudRateList [0]); Index++) {
 946     CheckFlags = 0;
 947     if (BaudRateList[Index].Value == 115200) {
 948       CheckFlags |= EFI_IFR_OPTION_DEFAULT;
 949     }
 950     HiiCreateOneOfOptionOpCode (
 951       OptionsOpCodeHandle,
 952       BaudRateList[Index].StringToken,
 953       CheckFlags,
 954       EFI_IFR_TYPE_NUM_SIZE_8,
 955       Index
 956       );
 957   }
 958
 959   HiiCreateOneOfOpCode (
 960     mStartOpCodeHandle,
 961     (EFI_QUESTION_ID) (COM_BAUD_RATE_QUESTION_ID + CurrentTerminal),
 962     VARSTORE_ID_BOOT_MAINT,
 963     (UINT16) (COM_BAUD_RATE_VAR_OFFSET + CurrentTerminal),
 964     STRING_TOKEN (STR_COM_BAUD_RATE),
 965     STRING_TOKEN (STR_COM_BAUD_RATE),
 966     0,
 967     EFI_IFR_NUMERIC_SIZE_1,
 968     OptionsOpCodeHandle,
 969     NULL
 970     );
 971
 972   HiiFreeOpCodeHandle (OptionsOpCodeHandle);
 973   OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
 974   ASSERT (OptionsOpCodeHandle != NULL);
 975
 976   for (Index = 0; Index < sizeof (DataBitsList) / sizeof (DataBitsList[0]); Index++) {
 977     CheckFlags = 0;
 978
 979     if (DataBitsList[Index].Value == 8) {
 980       CheckFlags |= EFI_IFR_OPTION_DEFAULT;
 981     }
 982
 983     HiiCreateOneOfOptionOpCode (
 984       OptionsOpCodeHandle,
 985       DataBitsList[Index].StringToken,
 986       CheckFlags,
 987       EFI_IFR_TYPE_NUM_SIZE_8,
 988       Index
 989       );
 990   }
 991
 992   HiiCreateOneOfOpCode (
 993     mStartOpCodeHandle,
 994     (EFI_QUESTION_ID) (COM_DATA_RATE_QUESTION_ID + CurrentTerminal),
 995     VARSTORE_ID_BOOT_MAINT,
 996     (UINT16) (COM_DATA_RATE_VAR_OFFSET + CurrentTerminal),
 997     STRING_TOKEN (STR_COM_DATA_BITS),
 998     STRING_TOKEN (STR_COM_DATA_BITS),
 999     0,
1000     EFI_IFR_NUMERIC_SIZE_1,
1001     OptionsOpCodeHandle,
1002     NULL
1003     );
1004
1005   HiiFreeOpCodeHandle (OptionsOpCodeHandle);
1006   OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
1007   ASSERT (OptionsOpCodeHandle != NULL);
1008
1009   for (Index = 0; Index < sizeof (ParityList) / sizeof (ParityList[0]); Index++) {
1010     CheckFlags = 0;
1011     if (ParityList[Index].Value ==  NoParity) {
1012       CheckFlags |= EFI_IFR_OPTION_DEFAULT;
1013     }
1014
1015     HiiCreateOneOfOptionOpCode (
1016       OptionsOpCodeHandle,
1017       ParityList[Index].StringToken,
1018       CheckFlags,
1019       EFI_IFR_TYPE_NUM_SIZE_8,
1020       Index
1021       );
1022   }
1023
1024   HiiCreateOneOfOpCode (
1025     mStartOpCodeHandle,
1026     (EFI_QUESTION_ID) (COM_PARITY_QUESTION_ID + CurrentTerminal),
1027     VARSTORE_ID_BOOT_MAINT,
1028     (UINT16) (COM_PARITY_VAR_OFFSET + CurrentTerminal),
1029     STRING_TOKEN (STR_COM_PARITY),
1030     STRING_TOKEN (STR_COM_PARITY),
1031     0,
1032     EFI_IFR_NUMERIC_SIZE_1,
1033     OptionsOpCodeHandle,
1034     NULL
1035     );
1036
1037   HiiFreeOpCodeHandle (OptionsOpCodeHandle);
1038   OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
1039   ASSERT (OptionsOpCodeHandle != NULL);
1040
1041   for (Index = 0; Index < sizeof (StopBitsList) / sizeof (StopBitsList[0]); Index++) {
1042     CheckFlags = 0;
1043     if (StopBitsList[Index].Value == OneStopBit) {
1044       CheckFlags |= EFI_IFR_OPTION_DEFAULT;
1045     }
1046
1047     HiiCreateOneOfOptionOpCode (
1048       OptionsOpCodeHandle,
1049       StopBitsList[Index].StringToken,
1050       CheckFlags,
1051       EFI_IFR_TYPE_NUM_SIZE_8,
1052       Index
1053       );
1054   }
1055
1056   HiiCreateOneOfOpCode (
1057     mStartOpCodeHandle,
1058     (EFI_QUESTION_ID) (COM_STOP_BITS_QUESTION_ID + CurrentTerminal),
1059     VARSTORE_ID_BOOT_MAINT,
1060     (UINT16) (COM_STOP_BITS_VAR_OFFSET + CurrentTerminal),
1061     STRING_TOKEN (STR_COM_STOP_BITS),
1062     STRING_TOKEN (STR_COM_STOP_BITS),
1063     0,
1064     EFI_IFR_NUMERIC_SIZE_1,
1065     OptionsOpCodeHandle,
1066     NULL
1067     );
1068
1069   HiiFreeOpCodeHandle (OptionsOpCodeHandle);
1070   OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
1071   ASSERT (OptionsOpCodeHandle != NULL);
1072
1073   for (Index = 0; Index < sizeof (TerminalType) / sizeof (TerminalType[0]); Index++) {
1074     CheckFlags = 0;
1075     if (Index == 0) {
1076       CheckFlags |= EFI_IFR_OPTION_DEFAULT;
1077     }
1078
1079     HiiCreateOneOfOptionOpCode (
1080       OptionsOpCodeHandle,
1081       (EFI_STRING_ID) TerminalType[Index],
1082       CheckFlags,
1083       EFI_IFR_TYPE_NUM_SIZE_8,
1084       Index
1085       );
1086   }
1087
1088   HiiCreateOneOfOpCode (
1089     mStartOpCodeHandle,
1090     (EFI_QUESTION_ID) (COM_TERMINAL_QUESTION_ID + CurrentTerminal),
1091     VARSTORE_ID_BOOT_MAINT,
1092     (UINT16) (COM_TERMINAL_VAR_OFFSET + CurrentTerminal),
1093     STRING_TOKEN (STR_COM_TERMI_TYPE),
1094     STRING_TOKEN (STR_COM_TERMI_TYPE),
1095     0,
1096     EFI_IFR_NUMERIC_SIZE_1,
1097     OptionsOpCodeHandle,
1098     NULL
1099     );
1100
1101   HiiFreeOpCodeHandle (OptionsOpCodeHandle);
1102   OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
1103   ASSERT (OptionsOpCodeHandle != NULL);
1104
1105   for (Index = 0; Index < sizeof (mFlowControlType) / sizeof (mFlowControlType[0]); Index++) {
1106   CheckFlags = 0;
1107     if (Index == 0) {
1108       CheckFlags |= EFI_IFR_OPTION_DEFAULT;
1109     }
1110     HiiCreateOneOfOptionOpCode (
1111       OptionsOpCodeHandle,
1112       (EFI_STRING_ID) mFlowControlType[Index],
1113       CheckFlags,
1114       EFI_IFR_TYPE_NUM_SIZE_8,
1115       mFlowControlValue[Index]
1116       );
1117   }
1118
1119   HiiCreateOneOfOpCode (
1120     mStartOpCodeHandle,
1121     (EFI_QUESTION_ID) (COM_FLOWCONTROL_QUESTION_ID + CurrentTerminal),
1122     VARSTORE_ID_BOOT_MAINT,
1123     (UINT16) (COM_FLOWCONTROL_VAR_OFFSET + CurrentTerminal),
1124     STRING_TOKEN (STR_COM_FLOW_CONTROL),
1125     STRING_TOKEN (STR_COM_FLOW_CONTROL),
1126     0,
1127     EFI_IFR_NUMERIC_SIZE_1,
1128     OptionsOpCodeHandle,
1129     NULL
1130     );
1131
1132   HiiFreeOpCodeHandle (OptionsOpCodeHandle);
1133
1134   UpdatePageEnd (CallbackData);
1135 }
1136
1137 /**
1138 Update add boot/driver option page.
1139
1140 @param CallbackData    The BMM context data.
1141 @param FormId             The form ID to be updated.
1142 @param DevicePath       Device path.
1143
1144 **/
1145 VOID
1146 UpdateOptionPage(
1147   IN   BMM_CALLBACK_DATA        *CallbackData,
1148   IN   EFI_FORM_ID              FormId,
1149   IN   EFI_DEVICE_PATH_PROTOCOL *DevicePath
1150   )
1151 {
1152   CHAR16                *String;
1153   EFI_STRING_ID         StringToken;
1154
1155   if (DevicePath != NULL){
1156     String = ExtractFileNameFromDevicePath(DevicePath);
1157     StringToken = HiiSetString (CallbackData->BmmHiiHandle, 0, String, NULL);
1158     FreePool(String);
1159   } else {
1160     String = HiiGetString (CallbackData->BmmHiiHandle, STRING_TOKEN (STR_NULL_STRING), NULL);
1161     ASSERT (String != NULL);
1162     StringToken =  HiiSetString (CallbackData->BmmHiiHandle, 0, String, NULL);
1163     FreePool (String);
1164   }
1165
1166   if(FormId == FORM_BOOT_ADD_ID){
1167     if (!CallbackData->BmmFakeNvData.BootOptionChanged) {
1168       ZeroMem (CallbackData->BmmFakeNvData.BootOptionalData, sizeof (CallbackData->BmmFakeNvData.BootOptionalData));
1169       ZeroMem (CallbackData->BmmFakeNvData.BootDescriptionData, sizeof (CallbackData->BmmFakeNvData.BootDescriptionData));
1170     }
1171   } else if (FormId == FORM_DRV_ADD_FILE_ID){
1172     if (!CallbackData->BmmFakeNvData.DriverOptionChanged) {
1173       ZeroMem (CallbackData->BmmFakeNvData.DriverOptionalData, sizeof (CallbackData->BmmFakeNvData.DriverOptionalData));
1174       ZeroMem (CallbackData->BmmFakeNvData.DriverDescriptionData, sizeof (CallbackData->BmmFakeNvData.DriverDescriptionData));
1175     }
1176   }
1177
1178   RefreshUpdateData();
1179   mStartLabel->Number = FormId;
1180
1181   HiiCreateSubTitleOpCode (
1182     mStartOpCodeHandle,
1183     StringToken,
1184     0,
1185     0,
1186     0
1187     );
1188
1189   HiiUpdateForm (
1190     CallbackData->BmmHiiHandle,
1191     &mBootMaintGuid,
1192     FormId,
1193     mStartOpCodeHandle,// Label FormId
1194     mEndOpCodeHandle   // LABEL_END
1195     );
1196 }
1197
1198 /**
1199   Dispatch the correct update page function to call based on
1200   the UpdatePageId.
1201
1202   @param UpdatePageId    The form ID.
1203   @param CallbackData    The BMM context data.
1204
1205 **/
1206 VOID
1207 UpdatePageBody (
1208   IN UINT16                           UpdatePageId,
1209   IN BMM_CALLBACK_DATA                *CallbackData
1210   )
1211 {
1212   CleanUpPage (UpdatePageId, CallbackData);
1213   switch (UpdatePageId) {
1214   case FORM_CON_IN_ID:
1215     UpdateConsolePage (UpdatePageId, &ConsoleInpMenu, CallbackData);
1216     break;
1217
1218   case FORM_CON_OUT_ID:
1219     UpdateConsolePage (UpdatePageId, &ConsoleOutMenu, CallbackData);
1220     break;
1221
1222   case FORM_CON_ERR_ID:
1223     UpdateConsolePage (UpdatePageId, &ConsoleErrMenu, CallbackData);
1224     break;
1225
1226   case FORM_BOOT_CHG_ID:
1227     UpdateOrderPage (UpdatePageId, &BootOptionMenu, CallbackData);
1228     break;
1229
1230   case FORM_DRV_CHG_ID:
1231     UpdateOrderPage (UpdatePageId, &DriverOptionMenu, CallbackData);
1232     break;
1233
1234   default:
1235     break;
1236   }
1237 }
1238
1239 /**
1240   Dispatch the display to the next page based on NewPageId.
1241
1242   @param Private         The BMM context data.
1243   @param NewPageId       The original page ID.
1244
1245 **/
1246 VOID
1247 UpdatePageId (
1248   BMM_CALLBACK_DATA              *Private,
1249   UINT16                         NewPageId
1250   )
1251 {
1252   if ((NewPageId < FILE_OPTION_OFFSET) && (NewPageId >= HANDLE_OPTION_OFFSET)) {
1253     //
1254     // If we select a handle to add driver option, advance to the add handle description page.
1255     //
1256     NewPageId = FORM_DRV_ADD_HANDLE_DESC_ID;
1257   } else if ((NewPageId == KEY_VALUE_SAVE_AND_EXIT) || (NewPageId == KEY_VALUE_NO_SAVE_AND_EXIT)) {
1258     //
1259     // Return to main page after "Save Changes" or "Discard Changes".
1260     //
1261     NewPageId = FORM_MAIN_ID;
1262   } else if ((NewPageId >= TERMINAL_OPTION_OFFSET) && (NewPageId < CONSOLE_OPTION_OFFSET)) {
1263     NewPageId = FORM_CON_COM_SETUP_ID;
1264   }
1265
1266   if ((NewPageId > 0) && (NewPageId < MAXIMUM_FORM_ID)) {
1267     Private->BmmPreviousPageId  = Private->BmmCurrentPageId;
1268     Private->BmmCurrentPageId   = NewPageId;
1269   }
1270 }