IntelFrameworkModulePkg/Universal/BdsDxe/BootMaint/UpdatePage.c

   1 /** @file
   2 Dynamically update the pages.
   3
   4 Copyright (c) 2004 - 2008, Intel Corporation. <BR>
   5 All rights reserved. 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 /**
  18   Refresh the global UpdateData structure.
  19
  20 **/
  21 VOID
  22 RefreshUpdateData (
  23   VOID
  24   )
  25 {
  26   //
  27   // Free current updated date
  28   //
  29   if (mStartOpCodeHandle != NULL) {
  30     HiiFreeOpCodeHandle (mStartOpCodeHandle);
  31   }
  32
  33   //
  34   // Create new OpCode Handle
  35   //
  36   mStartOpCodeHandle = HiiAllocateOpCodeHandle ();
  37
  38   //
  39   // Create Hii Extend Label OpCode as the start opcode
  40   //
  41   mStartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (mStartOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL));
  42   mStartLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
  43
  44 }
  45
  46 /**
  47   Add a "Go back to main page" tag in front of the form when there are no
  48   "Apply changes" and "Discard changes" tags in the end of the form.
  49
  50   @param CallbackData    The BMM context data.
  51
  52 **/
  53 VOID
  54 UpdatePageStart (
  55   IN BMM_CALLBACK_DATA                *CallbackData
  56   )
  57 {
  58   RefreshUpdateData ();
  59   mStartLabel->Number = CallbackData->BmmCurrentPageId;
  60
  61   if (!(CallbackData->BmmAskSaveOrNot)) {
  62     //
  63     // Add a "Go back to main page" tag in front of the form when there are no
  64     // "Apply changes" and "Discard changes" tags in the end of the form.
  65     //
  66     HiiCreateGotoOpCode (
  67       mStartOpCodeHandle,
  68       FORM_MAIN_ID,
  69       STRING_TOKEN (STR_FORM_GOTO_MAIN),
  70       STRING_TOKEN (STR_FORM_GOTO_MAIN),
  71       0,
  72       FORM_MAIN_ID
  73       );
  74   }
  75
  76 }
  77
  78 /**
  79   Create the "Apply changes" and "Discard changes" tags. And
  80   ensure user can return to the main page.
  81
  82   @param CallbackData    The BMM context data.
  83
  84 **/
  85 VOID
  86 UpdatePageEnd (
  87   IN BMM_CALLBACK_DATA                *CallbackData
  88   )
  89 {
  90   //
  91   // Create the "Apply changes" and "Discard changes" tags.
  92   //
  93   if (CallbackData->BmmAskSaveOrNot) {
  94     HiiCreateSubTitleOpCode (
  95       mStartOpCodeHandle,
  96       STRING_TOKEN (STR_NULL_STRING),
  97       0,
  98       0,
  99       0
 100       );
 101
 102     HiiCreateGotoOpCode (
 103       mStartOpCodeHandle,
 104       FORM_MAIN_ID,
 105       STRING_TOKEN (STR_SAVE_AND_EXIT),
 106       STRING_TOKEN (STR_NULL_STRING),
 107       EFI_IFR_FLAG_CALLBACK,
 108       KEY_VALUE_SAVE_AND_EXIT
 109       );
 110   }
 111
 112   //
 113   // Ensure user can return to the main page.
 114   //
 115   HiiCreateGotoOpCode (
 116     mStartOpCodeHandle,
 117     FORM_MAIN_ID,
 118     STRING_TOKEN (STR_NO_SAVE_AND_EXIT),
 119     STRING_TOKEN (STR_NULL_STRING),
 120     EFI_IFR_FLAG_CALLBACK,
 121     KEY_VALUE_NO_SAVE_AND_EXIT
 122     );
 123
 124   HiiUpdateForm (
 125     CallbackData->BmmHiiHandle,
 126     &mBootMaintGuid,
 127     CallbackData->BmmCurrentPageId,
 128     mStartOpCodeHandle, // Label CallbackData->BmmCurrentPageId
 129     mEndOpCodeHandle    // LABEL_END
 130     );
 131 }
 132
 133 /**
 134   Clean up the dynamic opcode at label and form specified by both LabelId.
 135
 136   @param LabelId         It is both the Form ID and Label ID for opcode deletion.
 137   @param CallbackData    The BMM context data.
 138
 139 **/
 140 VOID
 141 CleanUpPage (
 142   IN UINT16                           LabelId,
 143   IN BMM_CALLBACK_DATA                *CallbackData
 144   )
 145 {
 146   RefreshUpdateData ();
 147
 148   //
 149   // Remove all op-codes from dynamic page
 150   //
 151   mStartLabel->Number = LabelId;
 152   HiiUpdateForm (
 153     CallbackData->BmmHiiHandle,
 154     &mBootMaintGuid,
 155     LabelId,
 156     mStartOpCodeHandle, // Label LabelId
 157     mEndOpCodeHandle    // LABEL_END
 158     );
 159 }
 160
 161 /**
 162   Boot a file selected by user at File Expoloer of BMM.
 163
 164   @param FileContext     The file context data, which contains the device path
 165                          of the file to be boot from.
 166
 167   @retval EFI_SUCCESS    The function completed successfull.
 168   @return Other value if the boot from the file fails.
 169
 170 **/
 171 EFI_STATUS
 172 BootThisFile (
 173   IN BM_FILE_CONTEXT                   *FileContext
 174   )
 175 {
 176   EFI_STATUS        Status;
 177   UINTN             ExitDataSize;
 178   CHAR16            *ExitData;
 179   BDS_COMMON_OPTION *Option;
 180
 181   Option = (BDS_COMMON_OPTION *) AllocatePool (sizeof (BDS_COMMON_OPTION));
 182   ASSERT (Option != NULL);
 183   Option->Description     = FileContext->FileName;
 184   Option->DevicePath      = FileContext->DevicePath;
 185   Option->LoadOptionsSize = 0;
 186   Option->LoadOptions     = NULL;
 187
 188   //
 189   // Since current no boot from removable media directly is allowed */
 190   //
 191   gST->ConOut->ClearScreen (gST->ConOut);
 192
 193   ExitDataSize  = 0;
 194
 195   Status        = BdsLibBootViaBootOption (Option, Option->DevicePath, &ExitDataSize, &ExitData);
 196
 197   return Status;
 198
 199 }
 200
 201 /**
 202   Create a list of Goto Opcode for all terminal devices logged
 203   by TerminaMenu. This list will be inserted to form FORM_CON_COM_SETUP_ID.
 204
 205   @param CallbackData    The BMM context data.
 206 **/
 207 VOID
 208 UpdateConCOMPage (
 209   IN BMM_CALLBACK_DATA                *CallbackData
 210   )
 211 {
 212   BM_MENU_ENTRY *NewMenuEntry;
 213   UINT16        Index;
 214
 215   CallbackData->BmmAskSaveOrNot = FALSE;
 216
 217   UpdatePageStart (CallbackData);
 218
 219
 220   for (Index = 0; Index < TerminalMenu.MenuNumber; Index++) {
 221     NewMenuEntry = BOpt_GetMenuEntry (&TerminalMenu, Index);
 222
 223     HiiCreateGotoOpCode (
 224       mStartOpCodeHandle,
 225       FORM_CON_COM_SETUP_ID,
 226       NewMenuEntry->DisplayStringToken,
 227       STRING_TOKEN (STR_NULL_STRING),
 228       EFI_IFR_FLAG_CALLBACK,
 229       (UINT16) (TERMINAL_OPTION_OFFSET + Index)
 230       );
 231   }
 232
 233   UpdatePageEnd (CallbackData);
 234 }
 235
 236 /**
 237   Create a lit of boot option from global BootOptionMenu. It
 238   allow user to delete the boot option.
 239
 240   @param CallbackData    The BMM context data.
 241
 242 **/
 243 VOID
 244 UpdateBootDelPage (
 245   IN BMM_CALLBACK_DATA                *CallbackData
 246   )
 247 {
 248   BM_MENU_ENTRY   *NewMenuEntry;
 249   BM_LOAD_CONTEXT *NewLoadContext;
 250   UINT16          Index;
 251
 252   CallbackData->BmmAskSaveOrNot = TRUE;
 253
 254   UpdatePageStart (CallbackData);
 255   CreateMenuStringToken (CallbackData, CallbackData->BmmHiiHandle, &BootOptionMenu);
 256
 257   ASSERT (BootOptionMenu.MenuNumber <= (sizeof (CallbackData->BmmFakeNvData.BootOptionDel) / sizeof (CallbackData->BmmFakeNvData.BootOptionDel[0])));
 258   for (Index = 0; Index < BootOptionMenu.MenuNumber; Index++) {
 259     NewMenuEntry    = BOpt_GetMenuEntry (&BootOptionMenu, Index);
 260     NewLoadContext  = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
 261     if (NewLoadContext->IsLegacy) {
 262       continue;
 263     }
 264
 265     NewLoadContext->Deleted = FALSE;
 266     CallbackData->BmmFakeNvData.BootOptionDel[Index] = 0x00;
 267
 268     HiiCreateCheckBoxOpCode (
 269       mStartOpCodeHandle,
 270       (EFI_QUESTION_ID) (BOOT_OPTION_DEL_QUESTION_ID + Index),
 271       VARSTORE_ID_BOOT_MAINT,
 272       (UINT16) (BOOT_OPTION_DEL_VAR_OFFSET + Index),
 273       NewMenuEntry->DisplayStringToken,
 274       NewMenuEntry->HelpStringToken,
 275       0,
 276       0,
 277       NULL
 278       );
 279   }
 280
 281   UpdatePageEnd (CallbackData);
 282 }
 283
 284 /**
 285   Create a lit of driver option from global DriverMenu.
 286
 287   @param CallbackData    The BMM context data.
 288
 289 **/
 290 VOID
 291 UpdateDrvAddHandlePage (
 292   IN BMM_CALLBACK_DATA                *CallbackData
 293   )
 294 {
 295   BM_MENU_ENTRY *NewMenuEntry;
 296   UINT16        Index;
 297
 298   CallbackData->BmmAskSaveOrNot = FALSE;
 299
 300   UpdatePageStart (CallbackData);
 301
 302   for (Index = 0; Index < DriverMenu.MenuNumber; Index++) {
 303     NewMenuEntry = BOpt_GetMenuEntry (&DriverMenu, Index);
 304
 305     HiiCreateGotoOpCode (
 306       mStartOpCodeHandle,
 307       FORM_DRV_ADD_HANDLE_DESC_ID,
 308       NewMenuEntry->DisplayStringToken,
 309       STRING_TOKEN (STR_NULL_STRING),
 310       EFI_IFR_FLAG_CALLBACK,
 311       (UINT16) (HANDLE_OPTION_OFFSET + Index)
 312       );
 313   }
 314
 315   UpdatePageEnd (CallbackData);
 316 }
 317
 318 /**
 319   Create a lit of driver option from global DriverOptionMenu. It
 320   allow user to delete the driver option.
 321
 322   @param CallbackData    The BMM context data.
 323
 324 **/
 325 VOID
 326 UpdateDrvDelPage (
 327   IN BMM_CALLBACK_DATA                *CallbackData
 328   )
 329 {
 330   BM_MENU_ENTRY   *NewMenuEntry;
 331   BM_LOAD_CONTEXT *NewLoadContext;
 332   UINT16          Index;
 333
 334   CallbackData->BmmAskSaveOrNot = TRUE;
 335
 336   UpdatePageStart (CallbackData);
 337
 338   CreateMenuStringToken (CallbackData, CallbackData->BmmHiiHandle, &DriverOptionMenu);
 339
 340   ASSERT (DriverOptionMenu.MenuNumber <= (sizeof (CallbackData->BmmFakeNvData.DriverOptionDel) / sizeof (CallbackData->BmmFakeNvData.DriverOptionDel[0])));
 341   for (Index = 0; Index < DriverOptionMenu.MenuNumber; Index++) {
 342     NewMenuEntry            = BOpt_GetMenuEntry (&DriverOptionMenu, Index);
 343
 344     NewLoadContext          = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
 345     NewLoadContext->Deleted = FALSE;
 346     CallbackData->BmmFakeNvData.DriverOptionDel[Index] = 0x00;
 347
 348     HiiCreateCheckBoxOpCode (
 349       mStartOpCodeHandle,
 350       (EFI_QUESTION_ID) (DRIVER_OPTION_DEL_QUESTION_ID + Index),
 351       VARSTORE_ID_BOOT_MAINT,
 352       (UINT16) (DRIVER_OPTION_DEL_VAR_OFFSET + Index),
 353       NewMenuEntry->DisplayStringToken,
 354       NewMenuEntry->HelpStringToken,
 355       0,
 356       0,
 357       NULL
 358       );
 359   }
 360
 361   UpdatePageEnd (CallbackData);
 362 }
 363
 364 /**
 365   Prepare the page to allow user to add description for
 366   a Driver Option.
 367
 368   @param CallbackData    The BMM context data.
 369
 370 **/
 371 VOID
 372 UpdateDriverAddHandleDescPage (
 373   IN BMM_CALLBACK_DATA                *CallbackData
 374   )
 375 {
 376   BM_MENU_ENTRY *NewMenuEntry;
 377
 378   CallbackData->BmmFakeNvData.DriverAddActive          = 0x01;
 379   CallbackData->BmmFakeNvData.DriverAddForceReconnect  = 0x00;
 380   CallbackData->BmmAskSaveOrNot                        = TRUE;
 381   NewMenuEntry = CallbackData->MenuEntry;
 382
 383   UpdatePageStart (CallbackData);
 384
 385   HiiCreateSubTitleOpCode (
 386     mStartOpCodeHandle,
 387     NewMenuEntry->DisplayStringToken,
 388     0,
 389     0,
 390     0
 391     );
 392
 393   HiiCreateStringOpCode (
 394     mStartOpCodeHandle,
 395     (EFI_QUESTION_ID) DRV_ADD_HANDLE_DESC_QUESTION_ID,
 396     VARSTORE_ID_BOOT_MAINT,
 397     DRV_ADD_HANDLE_DESC_VAR_OFFSET,
 398     STRING_TOKEN (STR_LOAD_OPTION_DESC),
 399     STRING_TOKEN (STR_NULL_STRING),
 400     0,
 401     0,
 402     6,
 403     75,
 404     NULL
 405     );
 406
 407   HiiCreateCheckBoxOpCode (
 408     mStartOpCodeHandle,
 409     (EFI_QUESTION_ID) DRV_ADD_RECON_QUESTION_ID,
 410     VARSTORE_ID_BOOT_MAINT,
 411     DRV_ADD_RECON_VAR_OFFSET,
 412     STRING_TOKEN (STR_LOAD_OPTION_FORCE_RECON),
 413     STRING_TOKEN (STR_LOAD_OPTION_FORCE_RECON),
 414     0,
 415     0,
 416     NULL
 417     );
 418
 419   HiiCreateStringOpCode (
 420     mStartOpCodeHandle,
 421     (EFI_QUESTION_ID) DRIVER_ADD_OPTION_QUESTION_ID,
 422     VARSTORE_ID_BOOT_MAINT,
 423     DRIVER_ADD_OPTION_VAR_OFFSET,
 424     STRING_TOKEN (STR_OPTIONAL_DATA),
 425     STRING_TOKEN (STR_NULL_STRING),
 426     0,
 427     0,
 428     6,
 429     75,
 430     NULL
 431     );
 432
 433   UpdatePageEnd (CallbackData);
 434 }
 435
 436 /**
 437   Update console page.
 438
 439   @param UpdatePageId    The form ID to be updated.
 440   @param ConsoleMenu     The console menu list.
 441   @param CallbackData    The BMM context data.
 442
 443 **/
 444 VOID
 445 UpdateConsolePage (
 446   IN UINT16                           UpdatePageId,
 447   IN BM_MENU_OPTION                   *ConsoleMenu,
 448   IN BMM_CALLBACK_DATA                *CallbackData
 449   )
 450 {
 451   BM_MENU_ENTRY       *NewMenuEntry;
 452   BM_CONSOLE_CONTEXT  *NewConsoleContext;
 453   BM_TERMINAL_CONTEXT *NewTerminalContext;
 454   UINT16              Index;
 455   UINT16              Index2;
 456   UINT8               CheckFlags;
 457
 458   CallbackData->BmmAskSaveOrNot = TRUE;
 459
 460   UpdatePageStart (CallbackData);
 461
 462   ASSERT (ConsoleMenu->MenuNumber <= (sizeof (CallbackData->BmmFakeNvData.ConsoleCheck) / sizeof (CallbackData->BmmFakeNvData.ConsoleCheck[0])));
 463   for (Index = 0; Index < ConsoleMenu->MenuNumber; Index++) {
 464     NewMenuEntry      = BOpt_GetMenuEntry (ConsoleMenu, Index);
 465     NewConsoleContext = (BM_CONSOLE_CONTEXT *) NewMenuEntry->VariableContext;
 466     CheckFlags        = 0;
 467     if (NewConsoleContext->IsActive) {
 468       CheckFlags |= EFI_IFR_CHECKBOX_DEFAULT;
 469       CallbackData->BmmFakeNvData.ConsoleCheck[Index] = TRUE;
 470     } else {
 471       CallbackData->BmmFakeNvData.ConsoleCheck[Index] = FALSE;
 472     }
 473
 474     HiiCreateCheckBoxOpCode (
 475       mStartOpCodeHandle,
 476       (EFI_QUESTION_ID) (CON_DEVICE_QUESTION_ID + Index),
 477       VARSTORE_ID_BOOT_MAINT,
 478       (UINT16) (CON_DEVICE_VAR_OFFSET + Index),
 479       NewMenuEntry->DisplayStringToken,
 480       NewMenuEntry->HelpStringToken,
 481       0,
 482       CheckFlags,
 483       NULL
 484       );
 485   }
 486
 487   for (Index2 = 0; Index2 < TerminalMenu.MenuNumber; Index2++) {
 488     CheckFlags          = 0;
 489     NewMenuEntry        = BOpt_GetMenuEntry (&TerminalMenu, Index2);
 490     NewTerminalContext  = (BM_TERMINAL_CONTEXT *) NewMenuEntry->VariableContext;
 491
 492     if (((NewTerminalContext->IsConIn != 0) && (UpdatePageId == FORM_CON_IN_ID)) ||
 493         ((NewTerminalContext->IsConOut != 0) && (UpdatePageId == FORM_CON_OUT_ID)) ||
 494         ((NewTerminalContext->IsStdErr != 0) && (UpdatePageId == FORM_CON_ERR_ID))
 495         ) {
 496       CheckFlags |= EFI_IFR_CHECKBOX_DEFAULT;
 497       CallbackData->BmmFakeNvData.ConsoleCheck[Index] = TRUE;
 498     } else {
 499       CallbackData->BmmFakeNvData.ConsoleCheck[Index] = FALSE;
 500     }
 501
 502     HiiCreateCheckBoxOpCode (
 503       mStartOpCodeHandle,
 504       (EFI_QUESTION_ID) (CON_DEVICE_QUESTION_ID + Index),
 505       VARSTORE_ID_BOOT_MAINT,
 506       (UINT16) (CON_DEVICE_VAR_OFFSET + Index),
 507       NewMenuEntry->DisplayStringToken,
 508       NewMenuEntry->HelpStringToken,
 509       0,
 510       CheckFlags,
 511       NULL
 512       );
 513
 514     Index++;
 515   }
 516
 517   UpdatePageEnd (CallbackData);
 518 }
 519
 520 /**
 521   Update the page's NV Map if user has changed the order
 522   a list. This list can be Boot Order or Driver Order.
 523
 524   @param UpdatePageId    The form ID to be updated.
 525   @param OptionMenu      The new list.
 526   @param CallbackData    The BMM context data.
 527
 528 **/
 529 VOID
 530 UpdateOrderPage (
 531   IN UINT16                           UpdatePageId,
 532   IN BM_MENU_OPTION                   *OptionMenu,
 533   IN BMM_CALLBACK_DATA                *CallbackData
 534   )
 535 {
 536   BM_MENU_ENTRY *NewMenuEntry;
 537   UINT16        Index;
 538   VOID          *OptionsOpCodeHandle;
 539
 540   CallbackData->BmmAskSaveOrNot = TRUE;
 541
 542   UpdatePageStart (CallbackData);
 543
 544   CreateMenuStringToken (CallbackData, CallbackData->BmmHiiHandle, OptionMenu);
 545
 546   ZeroMem (CallbackData->BmmFakeNvData.OptionOrder, 100);
 547
 548   OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
 549   ASSERT (OptionsOpCodeHandle != NULL);
 550
 551   for (Index = 0; Index < OptionMenu->MenuNumber; Index++) {
 552     NewMenuEntry = BOpt_GetMenuEntry (OptionMenu, Index);
 553     HiiCreateOneOfOptionOpCode (
 554       OptionsOpCodeHandle,
 555       NewMenuEntry->DisplayStringToken,
 556       0,
 557       EFI_IFR_NUMERIC_SIZE_1,
 558       (UINT8) (NewMenuEntry->OptionNumber + 1)
 559       );
 560     CallbackData->BmmFakeNvData.OptionOrder[Index] = (UINT8) (NewMenuEntry->OptionNumber + 1);
 561   }
 562
 563   if (OptionMenu->MenuNumber > 0) {
 564     HiiCreateOrderedListOpCode (
 565       mStartOpCodeHandle,                          // Container for dynamic created opcodes
 566       (EFI_QUESTION_ID) OPTION_ORDER_QUESTION_ID,  // Question ID
 567       VARSTORE_ID_BOOT_MAINT,                      // VarStore ID
 568       OPTION_ORDER_VAR_OFFSET,                     // Offset in Buffer Storage
 569       STRING_TOKEN (STR_CHANGE_ORDER),             // Question prompt text
 570       STRING_TOKEN (STR_CHANGE_ORDER),             // Question help text
 571       0,                                           // Question flag
 572       0,                                           // Ordered list flag, e.g. EFI_IFR_UNIQUE_SET
 573       EFI_IFR_NUMERIC_SIZE_1,                      // Data type of Question value
 574       100,                                         // Maximum container
 575       OptionsOpCodeHandle,                         // Option Opcode list
 576       NULL                                         // Default Opcode is NULL
 577       );
 578   }
 579
 580   HiiFreeOpCodeHandle (OptionsOpCodeHandle);
 581
 582   UpdatePageEnd (CallbackData);
 583
 584   CopyMem (
 585     CallbackData->BmmOldFakeNVData.OptionOrder,
 586     CallbackData->BmmFakeNvData.OptionOrder,
 587     100
 588     );
 589 }
 590
 591 /**
 592   Create the dynamic page to allow user to set
 593   the "BootNext" value.
 594
 595   @param CallbackData    The BMM context data.
 596
 597 **/
 598 VOID
 599 UpdateBootNextPage (
 600   IN BMM_CALLBACK_DATA                *CallbackData
 601   )
 602 {
 603   BM_MENU_ENTRY   *NewMenuEntry;
 604   BM_LOAD_CONTEXT *NewLoadContext;
 605   UINTN           NumberOfOptions;
 606   UINT16          Index;
 607   VOID            *OptionsOpCodeHandle;
 608
 609   NumberOfOptions               = BootOptionMenu.MenuNumber;
 610   CallbackData->BmmAskSaveOrNot = TRUE;
 611
 612   UpdatePageStart (CallbackData);
 613   CreateMenuStringToken (CallbackData, CallbackData->BmmHiiHandle, &BootOptionMenu);
 614
 615   if (NumberOfOptions > 0) {
 616     OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
 617     ASSERT (OptionsOpCodeHandle != NULL);
 618
 619     CallbackData->BmmFakeNvData.BootNext = (UINT16) (BootOptionMenu.MenuNumber);
 620
 621     for (Index = 0; Index < BootOptionMenu.MenuNumber; Index++) {
 622       NewMenuEntry    = BOpt_GetMenuEntry (&BootOptionMenu, Index);
 623       NewLoadContext  = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
 624
 625       if (NewLoadContext->IsBootNext) {
 626         HiiCreateOneOfOptionOpCode (
 627           OptionsOpCodeHandle,
 628           NewMenuEntry->DisplayStringToken,
 629           EFI_IFR_OPTION_DEFAULT,
 630           EFI_IFR_NUMERIC_SIZE_2,
 631           Index
 632           );
 633         CallbackData->BmmFakeNvData.BootNext = Index;
 634       } else {
 635         HiiCreateOneOfOptionOpCode (
 636           OptionsOpCodeHandle,
 637           NewMenuEntry->DisplayStringToken,
 638           0,
 639           EFI_IFR_NUMERIC_SIZE_2,
 640           Index
 641           );
 642       }
 643     }
 644
 645     if (CallbackData->BmmFakeNvData.BootNext == Index) {
 646       HiiCreateOneOfOptionOpCode (
 647         OptionsOpCodeHandle,
 648         STRING_TOKEN (STR_NONE),
 649         EFI_IFR_OPTION_DEFAULT,
 650         EFI_IFR_NUMERIC_SIZE_2,
 651         Index
 652         );
 653     } else {
 654       HiiCreateOneOfOptionOpCode (
 655         OptionsOpCodeHandle,
 656         STRING_TOKEN (STR_NONE),
 657         0,
 658         EFI_IFR_NUMERIC_SIZE_2,
 659         Index
 660         );
 661     }
 662
 663     HiiCreateOneOfOpCode (
 664       mStartOpCodeHandle,
 665       (EFI_QUESTION_ID) BOOT_NEXT_QUESTION_ID,
 666       VARSTORE_ID_BOOT_MAINT,
 667       BOOT_NEXT_VAR_OFFSET,
 668       STRING_TOKEN (STR_BOOT_NEXT),
 669       STRING_TOKEN (STR_BOOT_NEXT_HELP),
 670       0,
 671       EFI_IFR_NUMERIC_SIZE_2,
 672       OptionsOpCodeHandle,
 673       NULL
 674       );
 675
 676     HiiFreeOpCodeHandle (OptionsOpCodeHandle);
 677   }
 678
 679   UpdatePageEnd (CallbackData);
 680 }
 681
 682 /**
 683   Create the dynamic page to allow user to set the "TimeOut" value.
 684
 685   @param CallbackData    The BMM context data.
 686
 687 **/
 688 VOID
 689 UpdateTimeOutPage (
 690   IN BMM_CALLBACK_DATA                *CallbackData
 691   )
 692 {
 693   UINT16  BootTimeOut;
 694   VOID    *DefaultOpCodeHandle;
 695
 696   CallbackData->BmmAskSaveOrNot = TRUE;
 697
 698   UpdatePageStart (CallbackData);
 699
 700   BootTimeOut = PcdGet16 (PcdPlatformBootTimeOut);
 701
 702   DefaultOpCodeHandle = HiiAllocateOpCodeHandle ();
 703   ASSERT (DefaultOpCodeHandle != NULL);
 704   HiiCreateDefaultOpCode (DefaultOpCodeHandle, EFI_HII_DEFAULT_CLASS_STANDARD, EFI_IFR_NUMERIC_SIZE_2, BootTimeOut);
 705
 706   HiiCreateNumericOpCode (
 707     mStartOpCodeHandle,
 708     (EFI_QUESTION_ID) BOOT_TIME_OUT_QUESTION_ID,
 709     VARSTORE_ID_BOOT_MAINT,
 710     BOOT_TIME_OUT_VAR_OFFSET,
 711     STRING_TOKEN (STR_NUM_AUTO_BOOT),
 712     STRING_TOKEN (STR_HLP_AUTO_BOOT),
 713     0,
 714     EFI_IFR_NUMERIC_SIZE_2 | EFI_IFR_DISPLAY_UINT_DEC,
 715     0,
 716     65535,
 717     0,
 718     DefaultOpCodeHandle
 719     );
 720
 721   HiiFreeOpCodeHandle (DefaultOpCodeHandle);
 722
 723   CallbackData->BmmFakeNvData.BootTimeOut = BootTimeOut;
 724
 725   UpdatePageEnd (CallbackData);
 726 }
 727
 728 /**
 729   Refresh the text mode page.
 730
 731   @param CallbackData    The BMM context data.
 732
 733 **/
 734 VOID
 735 UpdateConModePage (
 736   IN BMM_CALLBACK_DATA                *CallbackData
 737   )
 738 {
 739   UINTN                         Mode;
 740   UINTN                         Index;
 741   UINTN                         Col;
 742   UINTN                         Row;
 743   CHAR16                        RowString[50];
 744   CHAR16                        ModeString[50];
 745   UINTN                         TempStringLen;
 746   UINTN                         MaxMode;
 747   UINTN                         ValidMode;
 748   EFI_STRING_ID                 *ModeToken;
 749   EFI_STATUS                    Status;
 750   VOID                          *OptionsOpCodeHandle;
 751   EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL  *ConOut;
 752
 753   ConOut    = gST->ConOut;
 754   Index     = 0;
 755   ValidMode = 0;
 756   MaxMode   = (UINTN) (ConOut->Mode->MaxMode);
 757
 758   CallbackData->BmmAskSaveOrNot = TRUE;
 759
 760   UpdatePageStart (CallbackData);
 761
 762   //
 763   // Check valid mode
 764   //
 765   for (Mode = 0; Mode < MaxMode; Mode++) {
 766     Status = ConOut->QueryMode (ConOut, Mode, &Col, &Row);
 767     if (EFI_ERROR (Status)) {
 768       continue;
 769     }
 770     ValidMode++;
 771   }
 772
 773   if (ValidMode == 0) {
 774     return;
 775   }
 776
 777   OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
 778   ASSERT (OptionsOpCodeHandle != NULL);
 779
 780   ModeToken           = AllocateZeroPool (sizeof (EFI_STRING_ID) * ValidMode);
 781   ASSERT(ModeToken != NULL);
 782
 783   //
 784   // Determin which mode should be the first entry in menu
 785   //
 786   GetConsoleOutMode (CallbackData);
 787
 788   //
 789   // Build text mode options
 790   //
 791   for (Mode = 0; Mode < MaxMode; Mode++) {
 792     Status = ConOut->QueryMode (ConOut, Mode, &Col, &Row);
 793     if (EFI_ERROR (Status)) {
 794       continue;
 795     }
 796
 797     //
 798     // Build mode string Column x Row
 799     //
 800     TempStringLen = UnicodeValueToString (ModeString, 0, Col, 0);
 801     ASSERT ((TempStringLen + StrLen (L" x ")) < (sizeof (ModeString) / sizeof (ModeString[0])));
 802     StrCat (ModeString, L" x ");
 803     TempStringLen = UnicodeValueToString (RowString, 0, Row, 0);
 804     ASSERT ((StrLen (ModeString)  + TempStringLen) < (sizeof (ModeString) / sizeof (ModeString[0])));
 805     StrCat (ModeString, RowString);
 806
 807     ModeToken[Index] = HiiSetString (CallbackData->BmmHiiHandle, 0, ModeString, NULL);
 808
 809     if (Mode == CallbackData->BmmFakeNvData.ConsoleOutMode) {
 810       HiiCreateOneOfOptionOpCode (
 811         OptionsOpCodeHandle,
 812         ModeToken[Index],
 813         EFI_IFR_OPTION_DEFAULT,
 814         EFI_IFR_NUMERIC_SIZE_2,
 815         (UINT16) Mode
 816         );
 817     } else {
 818       HiiCreateOneOfOptionOpCode (
 819         OptionsOpCodeHandle,
 820         ModeToken[Index],
 821         0,
 822         EFI_IFR_NUMERIC_SIZE_2,
 823         (UINT16) Mode
 824         );
 825     }
 826     Index++;
 827   }
 828
 829   HiiCreateOneOfOpCode (
 830     mStartOpCodeHandle,
 831     (EFI_QUESTION_ID) CON_MODE_QUESTION_ID,
 832     VARSTORE_ID_BOOT_MAINT,
 833     CON_MODE_VAR_OFFSET,
 834     STRING_TOKEN (STR_CON_MODE_SETUP),
 835     STRING_TOKEN (STR_CON_MODE_SETUP),
 836     EFI_IFR_FLAG_RESET_REQUIRED,
 837     EFI_IFR_NUMERIC_SIZE_2,
 838     OptionsOpCodeHandle,
 839     NULL
 840     );
 841
 842   HiiFreeOpCodeHandle (OptionsOpCodeHandle);
 843   FreePool (ModeToken);
 844
 845   UpdatePageEnd (CallbackData);
 846 }
 847
 848 /**
 849   Create the dynamic page which allows user to set the property such as Baud Rate, Data Bits,
 850   Parity, Stop Bits, Terminal Type.
 851
 852   @param CallbackData    The BMM context data.
 853
 854 **/
 855 VOID
 856 UpdateTerminalPage (
 857   IN BMM_CALLBACK_DATA                *CallbackData
 858   )
 859 {
 860   UINT8               Index;
 861   UINT8               CheckFlags;
 862   BM_MENU_ENTRY       *NewMenuEntry;
 863   BM_TERMINAL_CONTEXT *NewTerminalContext;
 864   VOID                *OptionsOpCodeHandle;
 865
 866   CallbackData->BmmAskSaveOrNot = TRUE;
 867
 868   UpdatePageStart (CallbackData);
 869
 870   NewMenuEntry = BOpt_GetMenuEntry (
 871                   &TerminalMenu,
 872                   CallbackData->CurrentTerminal
 873                   );
 874
 875   if (NewMenuEntry == NULL) {
 876     return ;
 877   }
 878
 879   NewTerminalContext  = (BM_TERMINAL_CONTEXT *) NewMenuEntry->VariableContext;
 880
 881   OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
 882   ASSERT (OptionsOpCodeHandle != NULL);
 883
 884   for (Index = 0; Index < sizeof (BaudRateList) / sizeof (BaudRateList [0]); Index++) {
 885     CheckFlags = 0;
 886     if (NewTerminalContext->BaudRate == (UINT64) (BaudRateList[Index].Value)) {
 887       CheckFlags |= EFI_IFR_OPTION_DEFAULT;
 888       NewTerminalContext->BaudRateIndex         = Index;
 889       CallbackData->BmmFakeNvData.COMBaudRate  = NewTerminalContext->BaudRateIndex;
 890     }
 891
 892     HiiCreateOneOfOptionOpCode (
 893       OptionsOpCodeHandle,
 894       BaudRateList[Index].StringToken,
 895       CheckFlags,
 896       EFI_IFR_NUMERIC_SIZE_1,
 897       Index
 898       );
 899   }
 900
 901   HiiCreateOneOfOpCode (
 902     mStartOpCodeHandle,
 903     (EFI_QUESTION_ID) COM_BAUD_RATE_QUESTION_ID,
 904     VARSTORE_ID_BOOT_MAINT,
 905     COM_BAUD_RATE_VAR_OFFSET,
 906     STRING_TOKEN (STR_COM_BAUD_RATE),
 907     STRING_TOKEN (STR_COM_BAUD_RATE),
 908     0,
 909     EFI_IFR_NUMERIC_SIZE_1,
 910     OptionsOpCodeHandle,
 911     NULL
 912     );
 913
 914   HiiFreeOpCodeHandle (OptionsOpCodeHandle);
 915   OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
 916   ASSERT (OptionsOpCodeHandle != NULL);
 917
 918   for (Index = 0; Index < sizeof (DataBitsList) / sizeof (DataBitsList[0]); Index++) {
 919     CheckFlags = 0;
 920
 921     if (NewTerminalContext->DataBits == DataBitsList[Index].Value) {
 922       NewTerminalContext->DataBitsIndex         = Index;
 923       CallbackData->BmmFakeNvData.COMDataRate  = NewTerminalContext->DataBitsIndex;
 924       CheckFlags |= EFI_IFR_OPTION_DEFAULT;
 925     }
 926
 927     HiiCreateOneOfOptionOpCode (
 928       OptionsOpCodeHandle,
 929       DataBitsList[Index].StringToken,
 930       CheckFlags,
 931       EFI_IFR_NUMERIC_SIZE_1,
 932       Index
 933       );
 934   }
 935
 936   HiiCreateOneOfOpCode (
 937     mStartOpCodeHandle,
 938     (EFI_QUESTION_ID) COM_DATA_RATE_QUESTION_ID,
 939     VARSTORE_ID_BOOT_MAINT,
 940     COM_DATA_RATE_VAR_OFFSET,
 941     STRING_TOKEN (STR_COM_DATA_BITS),
 942     STRING_TOKEN (STR_COM_DATA_BITS),
 943     0,
 944     EFI_IFR_NUMERIC_SIZE_1,
 945     OptionsOpCodeHandle,
 946     NULL
 947     );
 948
 949   HiiFreeOpCodeHandle (OptionsOpCodeHandle);
 950   OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
 951   ASSERT (OptionsOpCodeHandle != NULL);
 952
 953   for (Index = 0; Index < sizeof (ParityList) / sizeof (ParityList[0]); Index++) {
 954     CheckFlags = 0;
 955     if (NewTerminalContext->Parity == ParityList[Index].Value) {
 956       CheckFlags |= EFI_IFR_OPTION_DEFAULT;
 957       NewTerminalContext->ParityIndex         = (UINT8) Index;
 958       CallbackData->BmmFakeNvData.COMParity  = NewTerminalContext->ParityIndex;
 959     }
 960
 961     HiiCreateOneOfOptionOpCode (
 962       OptionsOpCodeHandle,
 963       ParityList[Index].StringToken,
 964       CheckFlags,
 965       EFI_IFR_NUMERIC_SIZE_1,
 966       Index
 967       );
 968   }
 969
 970   HiiCreateOneOfOpCode (
 971     mStartOpCodeHandle,
 972     (EFI_QUESTION_ID) COM_PARITY_QUESTION_ID,
 973     VARSTORE_ID_BOOT_MAINT,
 974     COM_PARITY_VAR_OFFSET,
 975     STRING_TOKEN (STR_COM_PARITY),
 976     STRING_TOKEN (STR_COM_PARITY),
 977     0,
 978     EFI_IFR_NUMERIC_SIZE_1,
 979     OptionsOpCodeHandle,
 980     NULL
 981     );
 982
 983   HiiFreeOpCodeHandle (OptionsOpCodeHandle);
 984   OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
 985   ASSERT (OptionsOpCodeHandle != NULL);
 986
 987   for (Index = 0; Index < sizeof (StopBitsList) / sizeof (StopBitsList[0]); Index++) {
 988     CheckFlags = 0;
 989     if (NewTerminalContext->StopBits == StopBitsList[Index].Value) {
 990       CheckFlags |= EFI_IFR_OPTION_DEFAULT;
 991       NewTerminalContext->StopBitsIndex         = (UINT8) Index;
 992       CallbackData->BmmFakeNvData.COMStopBits  = NewTerminalContext->StopBitsIndex;
 993     }
 994
 995     HiiCreateOneOfOptionOpCode (
 996       OptionsOpCodeHandle,
 997       StopBitsList[Index].StringToken,
 998       CheckFlags,
 999       EFI_IFR_NUMERIC_SIZE_1,
1000       Index
1001       );
1002   }
1003
1004   HiiCreateOneOfOpCode (
1005     mStartOpCodeHandle,
1006     (EFI_QUESTION_ID) COM_STOP_BITS_QUESTION_ID,
1007     VARSTORE_ID_BOOT_MAINT,
1008     COM_STOP_BITS_VAR_OFFSET,
1009     STRING_TOKEN (STR_COM_STOP_BITS),
1010     STRING_TOKEN (STR_COM_STOP_BITS),
1011     0,
1012     EFI_IFR_NUMERIC_SIZE_1,
1013     OptionsOpCodeHandle,
1014     NULL
1015     );
1016
1017   HiiFreeOpCodeHandle (OptionsOpCodeHandle);
1018   OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
1019   ASSERT (OptionsOpCodeHandle != NULL);
1020
1021   for (Index = 0; Index < 4; Index++) {
1022     CheckFlags = 0;
1023     if (NewTerminalContext->TerminalType == Index) {
1024       CheckFlags |= EFI_IFR_OPTION_DEFAULT;
1025       CallbackData->BmmFakeNvData.COMTerminalType = NewTerminalContext->TerminalType;
1026     }
1027
1028     HiiCreateOneOfOptionOpCode (
1029       OptionsOpCodeHandle,
1030       (EFI_STRING_ID) TerminalType[Index],
1031       CheckFlags,
1032       EFI_IFR_NUMERIC_SIZE_1,
1033       Index
1034       );
1035   }
1036
1037   HiiCreateOneOfOpCode (
1038     mStartOpCodeHandle,
1039     (EFI_QUESTION_ID) COM_TERMINAL_QUESTION_ID,
1040     VARSTORE_ID_BOOT_MAINT,
1041     COM_TERMINAL_VAR_OFFSET,
1042     STRING_TOKEN (STR_COM_TERMI_TYPE),
1043     STRING_TOKEN (STR_COM_TERMI_TYPE),
1044     0,
1045     EFI_IFR_NUMERIC_SIZE_1,
1046     OptionsOpCodeHandle,
1047     NULL
1048     );
1049
1050   HiiFreeOpCodeHandle (OptionsOpCodeHandle);
1051
1052   UpdatePageEnd (CallbackData);
1053 }
1054
1055 /**
1056   Dispatch the correct update page function to call based on
1057   the UpdatePageId.
1058
1059   @param UpdatePageId    The form ID.
1060   @param CallbackData    The BMM context data.
1061
1062 **/
1063 VOID
1064 UpdatePageBody (
1065   IN UINT16                           UpdatePageId,
1066   IN BMM_CALLBACK_DATA                *CallbackData
1067   )
1068 {
1069   CleanUpPage (UpdatePageId, CallbackData);
1070   switch (UpdatePageId) {
1071   case FORM_CON_IN_ID:
1072     UpdateConsolePage (UpdatePageId, &ConsoleInpMenu, CallbackData);
1073     break;
1074
1075   case FORM_CON_OUT_ID:
1076     UpdateConsolePage (UpdatePageId, &ConsoleOutMenu, CallbackData);
1077     break;
1078
1079   case FORM_CON_ERR_ID:
1080     UpdateConsolePage (UpdatePageId, &ConsoleErrMenu, CallbackData);
1081     break;
1082
1083   case FORM_BOOT_CHG_ID:
1084     UpdateOrderPage (UpdatePageId, &BootOptionMenu, CallbackData);
1085     break;
1086
1087   case FORM_DRV_CHG_ID:
1088     UpdateOrderPage (UpdatePageId, &DriverOptionMenu, CallbackData);
1089     break;
1090
1091   default:
1092     break;
1093   }
1094 }
1095
1096 /**
1097   Get the index number (#### in Boot####) for the boot option pointed to a BBS legacy device type
1098   specified by DeviceType.
1099
1100   @param DeviceType      The legacy device type. It can be floppy, network, harddisk, cdrom,
1101                          etc.
1102   @param OptionIndex     Returns the index number (#### in Boot####).
1103   @param OptionSize      Return the size of the Boot### variable.
1104
1105 **/
1106 VOID *
1107 GetLegacyBootOptionVar (
1108   IN  UINTN                            DeviceType,
1109   OUT UINTN                            *OptionIndex,
1110   OUT UINTN                            *OptionSize
1111   )
1112 {
1113   EFI_DEVICE_PATH_PROTOCOL  *DevicePath;
1114   VOID                      *OptionBuffer;
1115   UINTN                     OrderSize;
1116   UINTN                     Index;
1117   UINT16                    *OrderBuffer;
1118   CHAR16                    StrTemp[100];
1119   UINT16                    FilePathSize;
1120   UINT8                     *Ptr;
1121   UINT8                     *OptionalData;
1122
1123   //
1124   // Get Boot Option number from the size of BootOrder
1125   //
1126   OrderBuffer = BdsLibGetVariableAndSize (
1127                   L"BootOrder",
1128                   &gEfiGlobalVariableGuid,
1129                   &OrderSize
1130                   );
1131
1132   if (OrderBuffer == NULL) {
1133     return NULL;
1134   }
1135
1136   for (Index = 0; Index < OrderSize / sizeof (UINT16); Index++) {
1137     UnicodeSPrint (StrTemp, 100, L"Boot%04x", OrderBuffer[Index]);
1138     OptionBuffer = BdsLibGetVariableAndSize (
1139                     StrTemp,
1140                     &gEfiGlobalVariableGuid,
1141                     OptionSize
1142                     );
1143     if (NULL == OptionBuffer) {
1144       continue;
1145     }
1146
1147     Ptr       = (UINT8 *) OptionBuffer;
1148     Ptr += sizeof (UINT32);
1149
1150     FilePathSize = *(UINT16 *) Ptr;
1151     Ptr += sizeof (UINT16);
1152
1153     Ptr += StrSize ((CHAR16 *) Ptr);
1154
1155     //
1156     // Now Ptr point to Device Path
1157     //
1158     DevicePath = (EFI_DEVICE_PATH_PROTOCOL *) Ptr;
1159     Ptr += FilePathSize;
1160
1161     //
1162     // Now Ptr point to Optional Data
1163     //
1164     OptionalData = Ptr;
1165
1166     if ((DeviceType == ((BBS_TABLE *) OptionalData)->DeviceType) &&
1167         (BBS_DEVICE_PATH == DevicePath->Type) &&
1168         (BBS_BBS_DP == DevicePath->SubType)
1169         ) {
1170       *OptionIndex = OrderBuffer[Index];
1171       FreePool (OrderBuffer);
1172       return OptionBuffer;
1173     } else {
1174       FreePool (OptionBuffer);
1175     }
1176   }
1177
1178   FreePool (OrderBuffer);
1179   return NULL;
1180 }
1181
1182 /**
1183   Create a dynamic page so that Legacy Device boot order
1184   can be set for specified device type.
1185
1186   @param UpdatePageId    The form ID. It also spefies the legacy device type.
1187   @param CallbackData    The BMM context data.
1188
1189
1190 **/
1191 VOID
1192 UpdateSetLegacyDeviceOrderPage (
1193   IN UINT16                           UpdatePageId,
1194   IN BMM_CALLBACK_DATA                *CallbackData
1195   )
1196 {
1197   BM_LEGACY_DEV_ORDER_CONTEXT *DevOrder;
1198   BM_MENU_OPTION              *OptionMenu;
1199   BM_MENU_ENTRY               *NewMenuEntry;
1200   EFI_STRING_ID               StrRef;
1201   EFI_STRING_ID               StrRefHelp;
1202   BBS_TYPE                    BbsType;
1203   UINTN                       VarSize;
1204   UINTN                       Pos;
1205   UINTN                       Bit;
1206   UINT16                      Index;
1207   UINT16                      Key;
1208   CHAR16                      String[100];
1209   CHAR16                      *TypeStr;
1210   CHAR16                      *TypeStrHelp;
1211   UINT16                      VarDevOrder;
1212   UINT8                       *VarData;
1213   UINT8                       *LegacyOrder;
1214   UINT8                       *OldData;
1215   UINT8                       *DisMap;
1216   VOID                        *OptionsOpCodeHandle;
1217
1218   OptionMenu = NULL;
1219   Key = 0;
1220   StrRef = 0;
1221   StrRefHelp = 0;
1222   TypeStr = NULL;
1223   TypeStrHelp = NULL;
1224   BbsType = BBS_FLOPPY;
1225   LegacyOrder = NULL;
1226   OldData = NULL;
1227   DisMap = NULL;
1228
1229   CallbackData->BmmAskSaveOrNot = TRUE;
1230   UpdatePageStart (CallbackData);
1231
1232   DisMap = CallbackData->BmmOldFakeNVData.DisableMap;
1233
1234   SetMem (DisMap, 32, 0);
1235   //
1236   // Create oneof option list
1237   //
1238   switch (UpdatePageId) {
1239   case FORM_SET_FD_ORDER_ID:
1240     OptionMenu  = (BM_MENU_OPTION *) &LegacyFDMenu;
1241     Key         = (UINT16) LEGACY_FD_QUESTION_ID;
1242     TypeStr     = STR_FLOPPY;
1243     TypeStrHelp = STR_FLOPPY_HELP;
1244     BbsType     = BBS_FLOPPY;
1245     LegacyOrder = CallbackData->BmmFakeNvData.LegacyFD;
1246     OldData     = CallbackData->BmmOldFakeNVData.LegacyFD;
1247     break;
1248
1249   case FORM_SET_HD_ORDER_ID:
1250     OptionMenu  = (BM_MENU_OPTION *) &LegacyHDMenu;
1251     Key         = (UINT16) LEGACY_HD_QUESTION_ID;
1252     TypeStr     = STR_HARDDISK;
1253     TypeStrHelp = STR_HARDDISK_HELP;
1254     BbsType     = BBS_HARDDISK;
1255     LegacyOrder = CallbackData->BmmFakeNvData.LegacyHD;
1256     OldData     = CallbackData->BmmOldFakeNVData.LegacyHD;
1257     break;
1258
1259   case FORM_SET_CD_ORDER_ID:
1260     OptionMenu  = (BM_MENU_OPTION *) &LegacyCDMenu;
1261     Key         = (UINT16) LEGACY_CD_QUESTION_ID;
1262     TypeStr     = STR_CDROM;
1263     TypeStrHelp = STR_CDROM_HELP;
1264     BbsType     = BBS_CDROM;
1265     LegacyOrder = CallbackData->BmmFakeNvData.LegacyCD;
1266     OldData     = CallbackData->BmmOldFakeNVData.LegacyCD;
1267     break;
1268
1269   case FORM_SET_NET_ORDER_ID:
1270     OptionMenu  = (BM_MENU_OPTION *) &LegacyNETMenu;
1271     Key         = (UINT16) LEGACY_NET_QUESTION_ID;
1272     TypeStr     = STR_NET;
1273     TypeStrHelp = STR_NET_HELP;
1274     BbsType     = BBS_EMBED_NETWORK;
1275     LegacyOrder = CallbackData->BmmFakeNvData.LegacyNET;
1276     OldData     = CallbackData->BmmOldFakeNVData.LegacyNET;
1277     break;
1278
1279   case FORM_SET_BEV_ORDER_ID:
1280     OptionMenu  = (BM_MENU_OPTION *) &LegacyBEVMenu;
1281     Key         = (UINT16) LEGACY_BEV_QUESTION_ID;
1282     TypeStr     = STR_BEV;
1283     TypeStrHelp = STR_BEV_HELP;
1284     BbsType     = BBS_BEV_DEVICE;
1285     LegacyOrder = CallbackData->BmmFakeNvData.LegacyBEV;
1286     OldData     = CallbackData->BmmOldFakeNVData.LegacyBEV;
1287     break;
1288
1289   default:
1290     DEBUG ((EFI_D_ERROR, "Invalid command ID for updating page!\n"));
1291     return;
1292   }
1293
1294   CreateMenuStringToken (CallbackData, CallbackData->BmmHiiHandle, OptionMenu);
1295
1296   OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
1297   ASSERT (OptionsOpCodeHandle != NULL);
1298
1299   for (Index = 0; Index < OptionMenu->MenuNumber; Index++) {
1300     NewMenuEntry                = BOpt_GetMenuEntry (OptionMenu, Index);
1301
1302     if (Index == 0) {
1303       HiiCreateOneOfOptionOpCode (
1304         OptionsOpCodeHandle,
1305         NewMenuEntry->DisplayStringToken,
1306         EFI_IFR_OPTION_DEFAULT,
1307         EFI_IFR_NUMERIC_SIZE_1,
1308         (UINT8) ((BM_LEGACY_DEVICE_CONTEXT *) NewMenuEntry->VariableContext)->Index
1309         );
1310     }
1311
1312     HiiCreateOneOfOptionOpCode (
1313       OptionsOpCodeHandle,
1314       NewMenuEntry->DisplayStringToken,
1315       0,
1316       EFI_IFR_NUMERIC_SIZE_1,
1317       (UINT8) ((BM_LEGACY_DEVICE_CONTEXT *) NewMenuEntry->VariableContext)->Index
1318       );
1319   }
1320
1321   //
1322   // for item "Disabled"
1323   //
1324   HiiCreateOneOfOptionOpCode (
1325     OptionsOpCodeHandle,
1326     STRING_TOKEN (STR_DISABLE_LEGACY_DEVICE),
1327     0,
1328     EFI_IFR_NUMERIC_SIZE_1,
1329     0xFF
1330     );
1331
1332   //
1333   // Get Device Order from variable
1334   //
1335   VarData = BdsLibGetVariableAndSize (
1336               VAR_LEGACY_DEV_ORDER,
1337               &EfiLegacyDevOrderGuid,
1338               &VarSize
1339               );
1340
1341   if (NULL != VarData) {
1342     DevOrder    = (BM_LEGACY_DEV_ORDER_CONTEXT *) VarData;
1343     while (VarData < VarData + VarSize) {
1344       if (DevOrder->BbsType == BbsType) {
1345         break;
1346       }
1347
1348       VarData += sizeof (BBS_TYPE);
1349       VarData += *(UINT16 *) VarData;
1350       DevOrder = (BM_LEGACY_DEV_ORDER_CONTEXT *) VarData;
1351     }
1352     //
1353     // Create oneof tag here for FD/HD/CD #1 #2
1354     //
1355     for (Index = 0; Index < OptionMenu->MenuNumber; Index++) {
1356       //
1357       // Create the string for oneof tag
1358       //
1359       UnicodeSPrint (String, sizeof (String), TypeStr, Index);
1360       StrRef = HiiSetString (CallbackData->BmmHiiHandle, 0, String, NULL);
1361
1362       UnicodeSPrint (String, sizeof (String), TypeStrHelp, Index);
1363       StrRefHelp = HiiSetString (CallbackData->BmmHiiHandle, 0, String, NULL);
1364
1365       HiiCreateOneOfOpCode (
1366         mStartOpCodeHandle,
1367         (EFI_QUESTION_ID) (Key + Index),
1368         VARSTORE_ID_BOOT_MAINT,
1369         (UINT16) (Key + Index - CONFIG_OPTION_OFFSET),
1370         StrRef,
1371         StrRefHelp,
1372         EFI_IFR_FLAG_CALLBACK,
1373         EFI_IFR_NUMERIC_SIZE_1,
1374         OptionsOpCodeHandle,
1375         NULL
1376         );
1377
1378       VarDevOrder = *(UINT16 *) ((UINT8 *) DevOrder + sizeof (BBS_TYPE) + sizeof (UINT16) + Index * sizeof (UINT16));
1379
1380       if (0xFF00 == (VarDevOrder & 0xFF00)) {
1381         LegacyOrder[Index]  = 0xFF;
1382         Pos                 = (VarDevOrder & 0xFF) / 8;
1383         Bit                 = 7 - ((VarDevOrder & 0xFF) % 8);
1384         DisMap[Pos] = (UINT8) (DisMap[Pos] | (UINT8) (1 << Bit));
1385       } else {
1386         LegacyOrder[Index] = (UINT8) (VarDevOrder & 0xFF);
1387       }
1388     }
1389   }
1390
1391   CopyMem (OldData, LegacyOrder, 100);
1392
1393   HiiFreeOpCodeHandle (OptionsOpCodeHandle);
1394
1395   UpdatePageEnd (CallbackData);
1396 }
1397
1398 /**
1399   Dispatch the display to the next page based on NewPageId.
1400
1401   @param Private         The BMM context data.
1402   @param NewPageId       The original page ID.
1403
1404 **/
1405 VOID
1406 UpdatePageId (
1407   BMM_CALLBACK_DATA              *Private,
1408   UINT16                         NewPageId
1409   )
1410 {
1411   if ((NewPageId < FILE_OPTION_OFFSET) && (NewPageId >= HANDLE_OPTION_OFFSET)) {
1412     //
1413     // If we select a handle to add driver option, advance to the add handle description page.
1414     //
1415     NewPageId = FORM_DRV_ADD_HANDLE_DESC_ID;
1416   } else if ((NewPageId == KEY_VALUE_SAVE_AND_EXIT) || (NewPageId == KEY_VALUE_NO_SAVE_AND_EXIT)) {
1417     //
1418     // Return to main page after "Save Changes" or "Discard Changes".
1419     //
1420     NewPageId = FORM_MAIN_ID;
1421   } else if ((NewPageId >= TERMINAL_OPTION_OFFSET) && (NewPageId < CONSOLE_OPTION_OFFSET)) {
1422     NewPageId = FORM_CON_COM_SETUP_ID;
1423   }
1424
1425   if ((NewPageId > 0) && (NewPageId < MAXIMUM_FORM_ID)) {
1426     Private->BmmPreviousPageId  = Private->BmmCurrentPageId;
1427     Private->BmmCurrentPageId   = NewPageId;
1428   }
1429 }