IntelFrameworkModulePkg/Universal/BdsDxe/BootMaint/UpdatePage.c

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