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   for (Index = 0; ((Index < ConsoleMenu->MenuNumber) && \
 463        (Index < (sizeof (CallbackData->BmmFakeNvData.ConsoleCheck) / sizeof (UINT8)))) ; 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) && \
 488        (Index2 < (sizeof (CallbackData->BmmFakeNvData.ConsoleCheck) / sizeof (UINT8)))); Index2++) {
 489     CheckFlags          = 0;
 490     NewMenuEntry        = BOpt_GetMenuEntry (&TerminalMenu, Index2);
 491     NewTerminalContext  = (BM_TERMINAL_CONTEXT *) NewMenuEntry->VariableContext;
 492
 493     ASSERT (Index < MAX_MENU_NUMBER);
 494     if (((NewTerminalContext->IsConIn != 0) && (UpdatePageId == FORM_CON_IN_ID)) ||
 495         ((NewTerminalContext->IsConOut != 0) && (UpdatePageId == FORM_CON_OUT_ID)) ||
 496         ((NewTerminalContext->IsStdErr != 0) && (UpdatePageId == FORM_CON_ERR_ID))
 497         ) {
 498       CheckFlags |= EFI_IFR_CHECKBOX_DEFAULT;
 499       CallbackData->BmmFakeNvData.ConsoleCheck[Index] = TRUE;
 500     } else {
 501       CallbackData->BmmFakeNvData.ConsoleCheck[Index] = FALSE;
 502     }
 503
 504     HiiCreateCheckBoxOpCode (
 505       mStartOpCodeHandle,
 506       (EFI_QUESTION_ID) (CON_DEVICE_QUESTION_ID + Index),
 507       VARSTORE_ID_BOOT_MAINT,
 508       (UINT16) (CON_DEVICE_VAR_OFFSET + Index),
 509       NewMenuEntry->DisplayStringToken,
 510       NewMenuEntry->HelpStringToken,
 511       0,
 512       CheckFlags,
 513       NULL
 514       );
 515
 516     Index++;
 517   }
 518
 519   UpdatePageEnd (CallbackData);
 520 }
 521
 522 /**
 523   Update the page's NV Map if user has changed the order
 524   a list. This list can be Boot Order or Driver Order.
 525
 526   @param UpdatePageId    The form ID to be updated.
 527   @param OptionMenu      The new list.
 528   @param CallbackData    The BMM context data.
 529
 530 **/
 531 VOID
 532 UpdateOrderPage (
 533   IN UINT16                           UpdatePageId,
 534   IN BM_MENU_OPTION                   *OptionMenu,
 535   IN BMM_CALLBACK_DATA                *CallbackData
 536   )
 537 {
 538   BM_MENU_ENTRY *NewMenuEntry;
 539   UINT16        Index;
 540   VOID          *OptionsOpCodeHandle;
 541
 542   CallbackData->BmmAskSaveOrNot = TRUE;
 543
 544   UpdatePageStart (CallbackData);
 545
 546   CreateMenuStringToken (CallbackData, CallbackData->BmmHiiHandle, OptionMenu);
 547
 548   ZeroMem (CallbackData->BmmFakeNvData.OptionOrder, 100);
 549
 550   OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
 551   ASSERT (OptionsOpCodeHandle != NULL);
 552
 553   for (
 554         Index = 0;
 555         (
 556           (Index < OptionMenu->MenuNumber) &&
 557           (Index <
 558             (
 559               sizeof (CallbackData->BmmFakeNvData.OptionOrder) /
 560               sizeof (UINT8)
 561             )
 562           )
 563         );
 564         Index++
 565       ) {
 566     NewMenuEntry = BOpt_GetMenuEntry (OptionMenu, Index);
 567     HiiCreateOneOfOptionOpCode (
 568       OptionsOpCodeHandle,
 569       NewMenuEntry->DisplayStringToken,
 570       0,
 571       EFI_IFR_NUMERIC_SIZE_1,
 572       (UINT8) (NewMenuEntry->OptionNumber + 1)
 573       );
 574     CallbackData->BmmFakeNvData.OptionOrder[Index] = (UINT8) (NewMenuEntry->OptionNumber + 1);
 575   }
 576
 577   if (OptionMenu->MenuNumber > 0) {
 578     HiiCreateOrderedListOpCode (
 579       mStartOpCodeHandle,                          // Container for dynamic created opcodes
 580       (EFI_QUESTION_ID) OPTION_ORDER_QUESTION_ID,  // Question ID
 581       VARSTORE_ID_BOOT_MAINT,                      // VarStore ID
 582       OPTION_ORDER_VAR_OFFSET,                     // Offset in Buffer Storage
 583       STRING_TOKEN (STR_CHANGE_ORDER),             // Question prompt text
 584       STRING_TOKEN (STR_CHANGE_ORDER),             // Question help text
 585       0,                                           // Question flag
 586       0,                                           // Ordered list flag, e.g. EFI_IFR_UNIQUE_SET
 587       EFI_IFR_NUMERIC_SIZE_1,                      // Data type of Question value
 588       100,                                         // Maximum container
 589       OptionsOpCodeHandle,                         // Option Opcode list
 590       NULL                                         // Default Opcode is NULL
 591       );
 592   }
 593
 594   HiiFreeOpCodeHandle (OptionsOpCodeHandle);
 595
 596   UpdatePageEnd (CallbackData);
 597
 598   CopyMem (
 599     CallbackData->BmmOldFakeNVData.OptionOrder,
 600     CallbackData->BmmFakeNvData.OptionOrder,
 601     100
 602     );
 603 }
 604
 605 /**
 606   Create the dynamic page to allow user to set
 607   the "BootNext" value.
 608
 609   @param CallbackData    The BMM context data.
 610
 611 **/
 612 VOID
 613 UpdateBootNextPage (
 614   IN BMM_CALLBACK_DATA                *CallbackData
 615   )
 616 {
 617   BM_MENU_ENTRY   *NewMenuEntry;
 618   BM_LOAD_CONTEXT *NewLoadContext;
 619   UINTN           NumberOfOptions;
 620   UINT16          Index;
 621   VOID            *OptionsOpCodeHandle;
 622
 623   NumberOfOptions               = BootOptionMenu.MenuNumber;
 624   CallbackData->BmmAskSaveOrNot = TRUE;
 625
 626   UpdatePageStart (CallbackData);
 627   CreateMenuStringToken (CallbackData, CallbackData->BmmHiiHandle, &BootOptionMenu);
 628
 629   if (NumberOfOptions > 0) {
 630     OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
 631     ASSERT (OptionsOpCodeHandle != NULL);
 632
 633     CallbackData->BmmFakeNvData.BootNext = (UINT16) (BootOptionMenu.MenuNumber);
 634
 635     for (Index = 0; Index < BootOptionMenu.MenuNumber; Index++) {
 636       NewMenuEntry    = BOpt_GetMenuEntry (&BootOptionMenu, Index);
 637       NewLoadContext  = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
 638
 639       if (NewLoadContext->IsBootNext) {
 640         HiiCreateOneOfOptionOpCode (
 641           OptionsOpCodeHandle,
 642           NewMenuEntry->DisplayStringToken,
 643           EFI_IFR_OPTION_DEFAULT,
 644           EFI_IFR_NUMERIC_SIZE_2,
 645           Index
 646           );
 647         CallbackData->BmmFakeNvData.BootNext = Index;
 648       } else {
 649         HiiCreateOneOfOptionOpCode (
 650           OptionsOpCodeHandle,
 651           NewMenuEntry->DisplayStringToken,
 652           0,
 653           EFI_IFR_NUMERIC_SIZE_2,
 654           Index
 655           );
 656       }
 657     }
 658
 659     if (CallbackData->BmmFakeNvData.BootNext == Index) {
 660       HiiCreateOneOfOptionOpCode (
 661         OptionsOpCodeHandle,
 662         STRING_TOKEN (STR_NONE),
 663         EFI_IFR_OPTION_DEFAULT,
 664         EFI_IFR_NUMERIC_SIZE_2,
 665         Index
 666         );
 667     } else {
 668       HiiCreateOneOfOptionOpCode (
 669         OptionsOpCodeHandle,
 670         STRING_TOKEN (STR_NONE),
 671         0,
 672         EFI_IFR_NUMERIC_SIZE_2,
 673         Index
 674         );
 675     }
 676
 677     HiiCreateOneOfOpCode (
 678       mStartOpCodeHandle,
 679       (EFI_QUESTION_ID) BOOT_NEXT_QUESTION_ID,
 680       VARSTORE_ID_BOOT_MAINT,
 681       BOOT_NEXT_VAR_OFFSET,
 682       STRING_TOKEN (STR_BOOT_NEXT),
 683       STRING_TOKEN (STR_BOOT_NEXT_HELP),
 684       0,
 685       EFI_IFR_NUMERIC_SIZE_2,
 686       OptionsOpCodeHandle,
 687       NULL
 688       );
 689
 690     HiiFreeOpCodeHandle (OptionsOpCodeHandle);
 691   }
 692
 693   UpdatePageEnd (CallbackData);
 694 }
 695
 696 /**
 697   Create the dynamic page to allow user to set the "TimeOut" value.
 698
 699   @param CallbackData    The BMM context data.
 700
 701 **/
 702 VOID
 703 UpdateTimeOutPage (
 704   IN BMM_CALLBACK_DATA                *CallbackData
 705   )
 706 {
 707   UINT16  BootTimeOut;
 708   VOID    *DefaultOpCodeHandle;
 709
 710   CallbackData->BmmAskSaveOrNot = TRUE;
 711
 712   UpdatePageStart (CallbackData);
 713
 714   BootTimeOut = PcdGet16 (PcdPlatformBootTimeOut);
 715
 716   DefaultOpCodeHandle = HiiAllocateOpCodeHandle ();
 717   ASSERT (DefaultOpCodeHandle != NULL);
 718   HiiCreateDefaultOpCode (DefaultOpCodeHandle, EFI_HII_DEFAULT_CLASS_STANDARD, EFI_IFR_NUMERIC_SIZE_2, BootTimeOut);
 719
 720   HiiCreateNumericOpCode (
 721     mStartOpCodeHandle,
 722     (EFI_QUESTION_ID) BOOT_TIME_OUT_QUESTION_ID,
 723     VARSTORE_ID_BOOT_MAINT,
 724     BOOT_TIME_OUT_VAR_OFFSET,
 725     STRING_TOKEN (STR_NUM_AUTO_BOOT),
 726     STRING_TOKEN (STR_HLP_AUTO_BOOT),
 727     0,
 728     EFI_IFR_NUMERIC_SIZE_2 | EFI_IFR_DISPLAY_UINT_DEC,
 729     0,
 730     65535,
 731     0,
 732     DefaultOpCodeHandle
 733     );
 734
 735   HiiFreeOpCodeHandle (DefaultOpCodeHandle);
 736
 737   CallbackData->BmmFakeNvData.BootTimeOut = BootTimeOut;
 738
 739   UpdatePageEnd (CallbackData);
 740 }
 741
 742 /**
 743   Refresh the text mode page.
 744
 745   @param CallbackData    The BMM context data.
 746
 747 **/
 748 VOID
 749 UpdateConModePage (
 750   IN BMM_CALLBACK_DATA                *CallbackData
 751   )
 752 {
 753   UINTN                         Mode;
 754   UINTN                         Index;
 755   UINTN                         Col;
 756   UINTN                         Row;
 757   CHAR16                        RowString[50];
 758   CHAR16                        ModeString[50];
 759   CHAR16                        *pStr;
 760   UINTN                         TempStringLen;
 761   UINTN                         MaxMode;
 762   UINTN                         ValidMode;
 763   EFI_STRING_ID                 *ModeToken;
 764   EFI_STATUS                    Status;
 765   VOID                          *OptionsOpCodeHandle;
 766   EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL  *ConOut;
 767
 768   ConOut    = gST->ConOut;
 769   Index     = 0;
 770   ValidMode = 0;
 771   MaxMode   = (UINTN) (ConOut->Mode->MaxMode);
 772
 773   CallbackData->BmmAskSaveOrNot = TRUE;
 774
 775   UpdatePageStart (CallbackData);
 776
 777   //
 778   // Check valid mode
 779   //
 780   for (Mode = 0; Mode < MaxMode; Mode++) {
 781     Status = ConOut->QueryMode (ConOut, Mode, &Col, &Row);
 782     if (EFI_ERROR (Status)) {
 783       continue;
 784     }
 785     ValidMode++;
 786   }
 787
 788   if (ValidMode == 0) {
 789     return;
 790   }
 791
 792   OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
 793   ASSERT (OptionsOpCodeHandle != NULL);
 794
 795   ModeToken           = AllocateZeroPool (sizeof (EFI_STRING_ID) * ValidMode);
 796   ASSERT(ModeToken != NULL);
 797
 798   //
 799   // Determin which mode should be the first entry in menu
 800   //
 801   GetConsoleOutMode (CallbackData);
 802
 803   //
 804   // Build text mode options
 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
 812     //
 813     // Build mode string Column x Row
 814     //
 815     TempStringLen = UnicodeValueToString (ModeString, 0, Col, 0);
 816     pStr = &ModeString[0];
 817     StrnCat (pStr, L" x ", StrLen(L" x "));
 818     TempStringLen = UnicodeValueToString (RowString, 0, Row, 0);
 819     pStr = &ModeString[0];
 820     StrnCat (pStr, RowString, StrLen(RowString));
 821
 822     ModeToken[Index] = HiiSetString (CallbackData->BmmHiiHandle, 0, ModeString, NULL);
 823
 824     if (Mode == CallbackData->BmmFakeNvData.ConsoleOutMode) {
 825       HiiCreateOneOfOptionOpCode (
 826         OptionsOpCodeHandle,
 827         ModeToken[Index],
 828         EFI_IFR_OPTION_DEFAULT,
 829         EFI_IFR_NUMERIC_SIZE_2,
 830         (UINT16) Mode
 831         );
 832     } else {
 833       HiiCreateOneOfOptionOpCode (
 834         OptionsOpCodeHandle,
 835         ModeToken[Index],
 836         0,
 837         EFI_IFR_NUMERIC_SIZE_2,
 838         (UINT16) Mode
 839         );
 840     }
 841     Index++;
 842   }
 843
 844   HiiCreateOneOfOpCode (
 845     mStartOpCodeHandle,
 846     (EFI_QUESTION_ID) CON_MODE_QUESTION_ID,
 847     VARSTORE_ID_BOOT_MAINT,
 848     CON_MODE_VAR_OFFSET,
 849     STRING_TOKEN (STR_CON_MODE_SETUP),
 850     STRING_TOKEN (STR_CON_MODE_SETUP),
 851     EFI_IFR_FLAG_RESET_REQUIRED,
 852     EFI_IFR_NUMERIC_SIZE_2,
 853     OptionsOpCodeHandle,
 854     NULL
 855     );
 856
 857   HiiFreeOpCodeHandle (OptionsOpCodeHandle);
 858   FreePool (ModeToken);
 859
 860   UpdatePageEnd (CallbackData);
 861 }
 862
 863 /**
 864   Create the dynamic page which allows user to set the property such as Baud Rate, Data Bits,
 865   Parity, Stop Bits, Terminal Type.
 866
 867   @param CallbackData    The BMM context data.
 868
 869 **/
 870 VOID
 871 UpdateTerminalPage (
 872   IN BMM_CALLBACK_DATA                *CallbackData
 873   )
 874 {
 875   UINT8               Index;
 876   UINT8               CheckFlags;
 877   BM_MENU_ENTRY       *NewMenuEntry;
 878   BM_TERMINAL_CONTEXT *NewTerminalContext;
 879   VOID                *OptionsOpCodeHandle;
 880
 881   CallbackData->BmmAskSaveOrNot = TRUE;
 882
 883   UpdatePageStart (CallbackData);
 884
 885   NewMenuEntry = BOpt_GetMenuEntry (
 886                   &TerminalMenu,
 887                   CallbackData->CurrentTerminal
 888                   );
 889
 890   if (NewMenuEntry == NULL) {
 891     return ;
 892   }
 893
 894   NewTerminalContext  = (BM_TERMINAL_CONTEXT *) NewMenuEntry->VariableContext;
 895
 896   OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
 897   ASSERT (OptionsOpCodeHandle != NULL);
 898
 899   for (Index = 0; Index < sizeof (BaudRateList) / sizeof (BaudRateList [0]); Index++) {
 900     CheckFlags = 0;
 901     if (NewTerminalContext->BaudRate == (UINT64) (BaudRateList[Index].Value)) {
 902       CheckFlags |= EFI_IFR_OPTION_DEFAULT;
 903       NewTerminalContext->BaudRateIndex         = Index;
 904       CallbackData->BmmFakeNvData.COMBaudRate  = NewTerminalContext->BaudRateIndex;
 905     }
 906
 907     HiiCreateOneOfOptionOpCode (
 908       OptionsOpCodeHandle,
 909       BaudRateList[Index].StringToken,
 910       CheckFlags,
 911       EFI_IFR_NUMERIC_SIZE_1,
 912       Index
 913       );
 914   }
 915
 916   HiiCreateOneOfOpCode (
 917     mStartOpCodeHandle,
 918     (EFI_QUESTION_ID) COM_BAUD_RATE_QUESTION_ID,
 919     VARSTORE_ID_BOOT_MAINT,
 920     COM_BAUD_RATE_VAR_OFFSET,
 921     STRING_TOKEN (STR_COM_BAUD_RATE),
 922     STRING_TOKEN (STR_COM_BAUD_RATE),
 923     0,
 924     EFI_IFR_NUMERIC_SIZE_1,
 925     OptionsOpCodeHandle,
 926     NULL
 927     );
 928
 929   HiiFreeOpCodeHandle (OptionsOpCodeHandle);
 930   OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
 931   ASSERT (OptionsOpCodeHandle != NULL);
 932
 933   for (Index = 0; Index < sizeof (DataBitsList) / sizeof (DataBitsList[0]); Index++) {
 934     CheckFlags = 0;
 935
 936     if (NewTerminalContext->DataBits == DataBitsList[Index].Value) {
 937       NewTerminalContext->DataBitsIndex         = Index;
 938       CallbackData->BmmFakeNvData.COMDataRate  = NewTerminalContext->DataBitsIndex;
 939       CheckFlags |= EFI_IFR_OPTION_DEFAULT;
 940     }
 941
 942     HiiCreateOneOfOptionOpCode (
 943       OptionsOpCodeHandle,
 944       DataBitsList[Index].StringToken,
 945       CheckFlags,
 946       EFI_IFR_NUMERIC_SIZE_1,
 947       Index
 948       );
 949   }
 950
 951   HiiCreateOneOfOpCode (
 952     mStartOpCodeHandle,
 953     (EFI_QUESTION_ID) COM_DATA_RATE_QUESTION_ID,
 954     VARSTORE_ID_BOOT_MAINT,
 955     COM_DATA_RATE_VAR_OFFSET,
 956     STRING_TOKEN (STR_COM_DATA_BITS),
 957     STRING_TOKEN (STR_COM_DATA_BITS),
 958     0,
 959     EFI_IFR_NUMERIC_SIZE_1,
 960     OptionsOpCodeHandle,
 961     NULL
 962     );
 963
 964   HiiFreeOpCodeHandle (OptionsOpCodeHandle);
 965   OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
 966   ASSERT (OptionsOpCodeHandle != NULL);
 967
 968   for (Index = 0; Index < sizeof (ParityList) / sizeof (ParityList[0]); Index++) {
 969     CheckFlags = 0;
 970     if (NewTerminalContext->Parity == ParityList[Index].Value) {
 971       CheckFlags |= EFI_IFR_OPTION_DEFAULT;
 972       NewTerminalContext->ParityIndex         = (UINT8) Index;
 973       CallbackData->BmmFakeNvData.COMParity  = NewTerminalContext->ParityIndex;
 974     }
 975
 976     HiiCreateOneOfOptionOpCode (
 977       OptionsOpCodeHandle,
 978       ParityList[Index].StringToken,
 979       CheckFlags,
 980       EFI_IFR_NUMERIC_SIZE_1,
 981       Index
 982       );
 983   }
 984
 985   HiiCreateOneOfOpCode (
 986     mStartOpCodeHandle,
 987     (EFI_QUESTION_ID) COM_PARITY_QUESTION_ID,
 988     VARSTORE_ID_BOOT_MAINT,
 989     COM_PARITY_VAR_OFFSET,
 990     STRING_TOKEN (STR_COM_PARITY),
 991     STRING_TOKEN (STR_COM_PARITY),
 992     0,
 993     EFI_IFR_NUMERIC_SIZE_1,
 994     OptionsOpCodeHandle,
 995     NULL
 996     );
 997
 998   HiiFreeOpCodeHandle (OptionsOpCodeHandle);
 999   OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
1000   ASSERT (OptionsOpCodeHandle != NULL);
1001
1002   for (Index = 0; Index < sizeof (StopBitsList) / sizeof (StopBitsList[0]); Index++) {
1003     CheckFlags = 0;
1004     if (NewTerminalContext->StopBits == StopBitsList[Index].Value) {
1005       CheckFlags |= EFI_IFR_OPTION_DEFAULT;
1006       NewTerminalContext->StopBitsIndex         = (UINT8) Index;
1007       CallbackData->BmmFakeNvData.COMStopBits  = NewTerminalContext->StopBitsIndex;
1008     }
1009
1010     HiiCreateOneOfOptionOpCode (
1011       OptionsOpCodeHandle,
1012       StopBitsList[Index].StringToken,
1013       CheckFlags,
1014       EFI_IFR_NUMERIC_SIZE_1,
1015       Index
1016       );
1017   }
1018
1019   HiiCreateOneOfOpCode (
1020     mStartOpCodeHandle,
1021     (EFI_QUESTION_ID) COM_STOP_BITS_QUESTION_ID,
1022     VARSTORE_ID_BOOT_MAINT,
1023     COM_STOP_BITS_VAR_OFFSET,
1024     STRING_TOKEN (STR_COM_STOP_BITS),
1025     STRING_TOKEN (STR_COM_STOP_BITS),
1026     0,
1027     EFI_IFR_NUMERIC_SIZE_1,
1028     OptionsOpCodeHandle,
1029     NULL
1030     );
1031
1032   HiiFreeOpCodeHandle (OptionsOpCodeHandle);
1033   OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
1034   ASSERT (OptionsOpCodeHandle != NULL);
1035
1036   for (Index = 0; Index < 4; Index++) {
1037     CheckFlags = 0;
1038     if (NewTerminalContext->TerminalType == Index) {
1039       CheckFlags |= EFI_IFR_OPTION_DEFAULT;
1040       CallbackData->BmmFakeNvData.COMTerminalType = NewTerminalContext->TerminalType;
1041     }
1042
1043     HiiCreateOneOfOptionOpCode (
1044       OptionsOpCodeHandle,
1045       (EFI_STRING_ID) TerminalType[Index],
1046       CheckFlags,
1047       EFI_IFR_NUMERIC_SIZE_1,
1048       Index
1049       );
1050   }
1051
1052   HiiCreateOneOfOpCode (
1053     mStartOpCodeHandle,
1054     (EFI_QUESTION_ID) COM_TERMINAL_QUESTION_ID,
1055     VARSTORE_ID_BOOT_MAINT,
1056     COM_TERMINAL_VAR_OFFSET,
1057     STRING_TOKEN (STR_COM_TERMI_TYPE),
1058     STRING_TOKEN (STR_COM_TERMI_TYPE),
1059     0,
1060     EFI_IFR_NUMERIC_SIZE_1,
1061     OptionsOpCodeHandle,
1062     NULL
1063     );
1064
1065   HiiFreeOpCodeHandle (OptionsOpCodeHandle);
1066
1067   UpdatePageEnd (CallbackData);
1068 }
1069
1070 /**
1071   Dispatch the correct update page function to call based on
1072   the UpdatePageId.
1073
1074   @param UpdatePageId    The form ID.
1075   @param CallbackData    The BMM context data.
1076
1077 **/
1078 VOID
1079 UpdatePageBody (
1080   IN UINT16                           UpdatePageId,
1081   IN BMM_CALLBACK_DATA                *CallbackData
1082   )
1083 {
1084   CleanUpPage (UpdatePageId, CallbackData);
1085   switch (UpdatePageId) {
1086   case FORM_CON_IN_ID:
1087     UpdateConsolePage (UpdatePageId, &ConsoleInpMenu, CallbackData);
1088     break;
1089
1090   case FORM_CON_OUT_ID:
1091     UpdateConsolePage (UpdatePageId, &ConsoleOutMenu, CallbackData);
1092     break;
1093
1094   case FORM_CON_ERR_ID:
1095     UpdateConsolePage (UpdatePageId, &ConsoleErrMenu, CallbackData);
1096     break;
1097
1098   case FORM_BOOT_CHG_ID:
1099     UpdateOrderPage (UpdatePageId, &BootOptionMenu, CallbackData);
1100     break;
1101
1102   case FORM_DRV_CHG_ID:
1103     UpdateOrderPage (UpdatePageId, &DriverOptionMenu, CallbackData);
1104     break;
1105
1106   default:
1107     break;
1108   }
1109 }
1110
1111 /**
1112   Get the index number (#### in Boot####) for the boot option pointed to a BBS legacy device type
1113   specified by DeviceType.
1114
1115   @param DeviceType      The legacy device type. It can be floppy, network, harddisk, cdrom,
1116                          etc.
1117   @param OptionIndex     Returns the index number (#### in Boot####).
1118   @param OptionSize      Return the size of the Boot### variable.
1119
1120 **/
1121 VOID *
1122 GetLegacyBootOptionVar (
1123   IN  UINTN                            DeviceType,
1124   OUT UINTN                            *OptionIndex,
1125   OUT UINTN                            *OptionSize
1126   )
1127 {
1128   EFI_DEVICE_PATH_PROTOCOL  *DevicePath;
1129   VOID                      *OptionBuffer;
1130   UINTN                     OrderSize;
1131   UINTN                     Index;
1132   UINT16                    *OrderBuffer;
1133   CHAR16                    StrTemp[100];
1134   UINT16                    FilePathSize;
1135   UINT8                     *Ptr;
1136   UINT8                     *OptionalData;
1137
1138   //
1139   // Get Boot Option number from the size of BootOrder
1140   //
1141   OrderBuffer = BdsLibGetVariableAndSize (
1142                   L"BootOrder",
1143                   &gEfiGlobalVariableGuid,
1144                   &OrderSize
1145                   );
1146
1147   if (OrderBuffer == NULL) {
1148     return NULL;
1149   }
1150
1151   for (Index = 0; Index < OrderSize / sizeof (UINT16); Index++) {
1152     UnicodeSPrint (StrTemp, 100, L"Boot%04x", OrderBuffer[Index]);
1153     OptionBuffer = BdsLibGetVariableAndSize (
1154                     StrTemp,
1155                     &gEfiGlobalVariableGuid,
1156                     OptionSize
1157                     );
1158     if (NULL == OptionBuffer) {
1159       continue;
1160     }
1161
1162     Ptr       = (UINT8 *) OptionBuffer;
1163     Ptr += sizeof (UINT32);
1164
1165     FilePathSize = *(UINT16 *) Ptr;
1166     Ptr += sizeof (UINT16);
1167
1168     Ptr += StrSize ((CHAR16 *) Ptr);
1169
1170     //
1171     // Now Ptr point to Device Path
1172     //
1173     DevicePath = (EFI_DEVICE_PATH_PROTOCOL *) Ptr;
1174     Ptr += FilePathSize;
1175
1176     //
1177     // Now Ptr point to Optional Data
1178     //
1179     OptionalData = Ptr;
1180
1181     if ((DeviceType == ((BBS_TABLE *) OptionalData)->DeviceType) &&
1182         (BBS_DEVICE_PATH == DevicePath->Type) &&
1183         (BBS_BBS_DP == DevicePath->SubType)
1184         ) {
1185       *OptionIndex = OrderBuffer[Index];
1186       FreePool (OrderBuffer);
1187       return OptionBuffer;
1188     } else {
1189       FreePool (OptionBuffer);
1190     }
1191   }
1192
1193   FreePool (OrderBuffer);
1194   return NULL;
1195 }
1196
1197 /**
1198   Create a dynamic page so that Legacy Device boot order
1199   can be set for specified device type.
1200
1201   @param UpdatePageId    The form ID. It also spefies the legacy device type.
1202   @param CallbackData    The BMM context data.
1203
1204
1205 **/
1206 VOID
1207 UpdateSetLegacyDeviceOrderPage (
1208   IN UINT16                           UpdatePageId,
1209   IN BMM_CALLBACK_DATA                *CallbackData
1210   )
1211 {
1212   BM_LEGACY_DEV_ORDER_CONTEXT *DevOrder;
1213   BM_MENU_OPTION              *OptionMenu;
1214   BM_MENU_ENTRY               *NewMenuEntry;
1215   EFI_STRING_ID               StrRef;
1216   EFI_STRING_ID               StrRefHelp;
1217   BBS_TYPE                    BbsType;
1218   UINTN                       VarSize;
1219   UINTN                       Pos;
1220   UINTN                       Bit;
1221   UINT16                      Index;
1222   UINT16                      Key;
1223   CHAR16                      String[100];
1224   CHAR16                      *TypeStr;
1225   CHAR16                      *TypeStrHelp;
1226   UINT16                      VarDevOrder;
1227   UINT8                       *VarData;
1228   UINT8                       *LegacyOrder;
1229   UINT8                       *OldData;
1230   UINT8                       *DisMap;
1231   VOID                        *OptionsOpCodeHandle;
1232
1233   OptionMenu = NULL;
1234   Key = 0;
1235   StrRef = 0;
1236   StrRefHelp = 0;
1237   TypeStr = NULL;
1238   TypeStrHelp = NULL;
1239   BbsType = BBS_FLOPPY;
1240   LegacyOrder = NULL;
1241   OldData = NULL;
1242   DisMap = NULL;
1243
1244   CallbackData->BmmAskSaveOrNot = TRUE;
1245   UpdatePageStart (CallbackData);
1246
1247   DisMap = CallbackData->BmmOldFakeNVData.DisableMap;
1248
1249   SetMem (DisMap, 32, 0);
1250   //
1251   // Create oneof option list
1252   //
1253   switch (UpdatePageId) {
1254   case FORM_SET_FD_ORDER_ID:
1255     OptionMenu  = (BM_MENU_OPTION *) &LegacyFDMenu;
1256     Key         = (UINT16) LEGACY_FD_QUESTION_ID;
1257     TypeStr     = STR_FLOPPY;
1258     TypeStrHelp = STR_FLOPPY_HELP;
1259     BbsType     = BBS_FLOPPY;
1260     LegacyOrder = CallbackData->BmmFakeNvData.LegacyFD;
1261     OldData     = CallbackData->BmmOldFakeNVData.LegacyFD;
1262     break;
1263
1264   case FORM_SET_HD_ORDER_ID:
1265     OptionMenu  = (BM_MENU_OPTION *) &LegacyHDMenu;
1266     Key         = (UINT16) LEGACY_HD_QUESTION_ID;
1267     TypeStr     = STR_HARDDISK;
1268     TypeStrHelp = STR_HARDDISK_HELP;
1269     BbsType     = BBS_HARDDISK;
1270     LegacyOrder = CallbackData->BmmFakeNvData.LegacyHD;
1271     OldData     = CallbackData->BmmOldFakeNVData.LegacyHD;
1272     break;
1273
1274   case FORM_SET_CD_ORDER_ID:
1275     OptionMenu  = (BM_MENU_OPTION *) &LegacyCDMenu;
1276     Key         = (UINT16) LEGACY_CD_QUESTION_ID;
1277     TypeStr     = STR_CDROM;
1278     TypeStrHelp = STR_CDROM_HELP;
1279     BbsType     = BBS_CDROM;
1280     LegacyOrder = CallbackData->BmmFakeNvData.LegacyCD;
1281     OldData     = CallbackData->BmmOldFakeNVData.LegacyCD;
1282     break;
1283
1284   case FORM_SET_NET_ORDER_ID:
1285     OptionMenu  = (BM_MENU_OPTION *) &LegacyNETMenu;
1286     Key         = (UINT16) LEGACY_NET_QUESTION_ID;
1287     TypeStr     = STR_NET;
1288     TypeStrHelp = STR_NET_HELP;
1289     BbsType     = BBS_EMBED_NETWORK;
1290     LegacyOrder = CallbackData->BmmFakeNvData.LegacyNET;
1291     OldData     = CallbackData->BmmOldFakeNVData.LegacyNET;
1292     break;
1293
1294   case FORM_SET_BEV_ORDER_ID:
1295     OptionMenu  = (BM_MENU_OPTION *) &LegacyBEVMenu;
1296     Key         = (UINT16) LEGACY_BEV_QUESTION_ID;
1297     TypeStr     = STR_BEV;
1298     TypeStrHelp = STR_BEV_HELP;
1299     BbsType     = BBS_BEV_DEVICE;
1300     LegacyOrder = CallbackData->BmmFakeNvData.LegacyBEV;
1301     OldData     = CallbackData->BmmOldFakeNVData.LegacyBEV;
1302     break;
1303
1304   default:
1305     DEBUG ((EFI_D_ERROR, "Invalid command ID for updating page!\n"));
1306     return;
1307   }
1308
1309   CreateMenuStringToken (CallbackData, CallbackData->BmmHiiHandle, OptionMenu);
1310
1311   OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
1312   ASSERT (OptionsOpCodeHandle != NULL);
1313
1314   for (Index = 0; Index < OptionMenu->MenuNumber; Index++) {
1315     NewMenuEntry                = BOpt_GetMenuEntry (OptionMenu, Index);
1316
1317     if (Index == 0) {
1318       HiiCreateOneOfOptionOpCode (
1319         OptionsOpCodeHandle,
1320         NewMenuEntry->DisplayStringToken,
1321         EFI_IFR_OPTION_DEFAULT,
1322         EFI_IFR_NUMERIC_SIZE_1,
1323         (UINT8) ((BM_LEGACY_DEVICE_CONTEXT *) NewMenuEntry->VariableContext)->Index
1324         );
1325     }
1326
1327     HiiCreateOneOfOptionOpCode (
1328       OptionsOpCodeHandle,
1329       NewMenuEntry->DisplayStringToken,
1330       0,
1331       EFI_IFR_NUMERIC_SIZE_1,
1332       (UINT8) ((BM_LEGACY_DEVICE_CONTEXT *) NewMenuEntry->VariableContext)->Index
1333       );
1334   }
1335
1336   //
1337   // for item "Disabled"
1338   //
1339   HiiCreateOneOfOptionOpCode (
1340     OptionsOpCodeHandle,
1341     STRING_TOKEN (STR_DISABLE_LEGACY_DEVICE),
1342     0,
1343     EFI_IFR_NUMERIC_SIZE_1,
1344     0xFF
1345     );
1346
1347   //
1348   // Get Device Order from variable
1349   //
1350   VarData = BdsLibGetVariableAndSize (
1351               VAR_LEGACY_DEV_ORDER,
1352               &EfiLegacyDevOrderGuid,
1353               &VarSize
1354               );
1355
1356   if (NULL != VarData) {
1357     DevOrder    = (BM_LEGACY_DEV_ORDER_CONTEXT *) VarData;
1358     while (VarData < VarData + VarSize) {
1359       if (DevOrder->BbsType == BbsType) {
1360         break;
1361       }
1362
1363       VarData += sizeof (BBS_TYPE);
1364       VarData += *(UINT16 *) VarData;
1365       DevOrder = (BM_LEGACY_DEV_ORDER_CONTEXT *) VarData;
1366     }
1367     //
1368     // Create oneof tag here for FD/HD/CD #1 #2
1369     //
1370     for (Index = 0; Index < OptionMenu->MenuNumber; Index++) {
1371       //
1372       // Create the string for oneof tag
1373       //
1374       UnicodeSPrint (String, sizeof (String), TypeStr, Index);
1375       StrRef = HiiSetString (CallbackData->BmmHiiHandle, 0, String, NULL);
1376
1377       UnicodeSPrint (String, sizeof (String), TypeStrHelp, Index);
1378       StrRefHelp = HiiSetString (CallbackData->BmmHiiHandle, 0, String, NULL);
1379
1380       HiiCreateOneOfOpCode (
1381         mStartOpCodeHandle,
1382         (EFI_QUESTION_ID) (Key + Index),
1383         VARSTORE_ID_BOOT_MAINT,
1384         (UINT16) (Key + Index - CONFIG_OPTION_OFFSET),
1385         StrRef,
1386         StrRefHelp,
1387         EFI_IFR_FLAG_CALLBACK,
1388         EFI_IFR_NUMERIC_SIZE_1,
1389         OptionsOpCodeHandle,
1390         NULL
1391         );
1392
1393       VarDevOrder = *(UINT16 *) ((UINT8 *) DevOrder + sizeof (BBS_TYPE) + sizeof (UINT16) + Index * sizeof (UINT16));
1394
1395       if (0xFF00 == (VarDevOrder & 0xFF00)) {
1396         LegacyOrder[Index]  = 0xFF;
1397         Pos                 = (VarDevOrder & 0xFF) / 8;
1398         Bit                 = 7 - ((VarDevOrder & 0xFF) % 8);
1399         DisMap[Pos] = (UINT8) (DisMap[Pos] | (UINT8) (1 << Bit));
1400       } else {
1401         LegacyOrder[Index] = (UINT8) (VarDevOrder & 0xFF);
1402       }
1403     }
1404   }
1405
1406   CopyMem (OldData, LegacyOrder, 100);
1407
1408   HiiFreeOpCodeHandle (OptionsOpCodeHandle);
1409
1410   UpdatePageEnd (CallbackData);
1411 }
1412
1413 /**
1414   Dispatch the display to the next page based on NewPageId.
1415
1416   @param Private         The BMM context data.
1417   @param NewPageId       The original page ID.
1418
1419 **/
1420 VOID
1421 UpdatePageId (
1422   BMM_CALLBACK_DATA              *Private,
1423   UINT16                         NewPageId
1424   )
1425 {
1426   if ((NewPageId < FILE_OPTION_OFFSET) && (NewPageId >= HANDLE_OPTION_OFFSET)) {
1427     //
1428     // If we select a handle to add driver option, advance to the add handle description page.
1429     //
1430     NewPageId = FORM_DRV_ADD_HANDLE_DESC_ID;
1431   } else if ((NewPageId == KEY_VALUE_SAVE_AND_EXIT) || (NewPageId == KEY_VALUE_NO_SAVE_AND_EXIT)) {
1432     //
1433     // Return to main page after "Save Changes" or "Discard Changes".
1434     //
1435     NewPageId = FORM_MAIN_ID;
1436   } else if ((NewPageId >= TERMINAL_OPTION_OFFSET) && (NewPageId < CONSOLE_OPTION_OFFSET)) {
1437     NewPageId = FORM_CON_COM_SETUP_ID;
1438   }
1439
1440   if ((NewPageId > 0) && (NewPageId < MAXIMUM_FORM_ID)) {
1441     Private->BmmPreviousPageId  = Private->BmmCurrentPageId;
1442     Private->BmmCurrentPageId   = NewPageId;
1443   }
1444 }