IntelFrameworkModulePkg/Universal/BdsDxe/BootMaint/UpdatePage.c

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