IntelFrameworkModulePkg/Universal/BdsDxe/BootMaint/UpdatePage.c

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