MdeModulePkg/Application/UiApp/BootMaint/UpdatePage.c

   1 /** @file
   2 Dynamically update the pages.
   3
   4 Copyright (c) 2015, 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     &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_BOOT_MANAGER_LOAD_OPTION BootOption;
 177
 178   EfiBootManagerInitializeLoadOption (
 179     &BootOption,
 180     0,
 181     LoadOptionTypeBoot,
 182     LOAD_OPTION_ACTIVE,
 183     FileContext->FileName,
 184     FileContext->DevicePath,
 185     NULL,
 186     0
 187     );
 188   //
 189   // Since current no boot from removable media directly is allowed */
 190   //
 191   gST->ConOut->ClearScreen (gST->ConOut);
 192
 193   BdsSetConsoleMode (FALSE);
 194   EfiBootManagerBoot (&BootOption);
 195   BdsSetConsoleMode (TRUE);
 196
 197   EfiBootManagerFreeLoadOption (&BootOption);
 198
 199   return BootOption.Status;
 200
 201 }
 202
 203 /**
 204   Create a list of Goto Opcode for all terminal devices logged
 205   by TerminaMenu. This list will be inserted to form FORM_CON_COM_SETUP_ID.
 206
 207   @param CallbackData    The BMM context data.
 208 **/
 209 VOID
 210 UpdateConCOMPage (
 211   IN BMM_CALLBACK_DATA                *CallbackData
 212   )
 213 {
 214   BM_MENU_ENTRY       *NewMenuEntry;
 215   UINT16              Index;
 216
 217   UpdatePageStart (CallbackData);
 218
 219   for (Index = 0; Index < TerminalMenu.MenuNumber; Index++) {
 220     NewMenuEntry = BOpt_GetMenuEntry (&TerminalMenu, Index);
 221
 222     HiiCreateGotoOpCode (
 223       mStartOpCodeHandle,
 224       FORM_CON_COM_SETUP_ID,
 225       NewMenuEntry->DisplayStringToken,
 226       STRING_TOKEN (STR_NULL_STRING),
 227       EFI_IFR_FLAG_CALLBACK,
 228       (UINT16) (TERMINAL_OPTION_OFFSET + Index)
 229       );
 230   }
 231
 232   UpdatePageEnd (CallbackData);
 233 }
 234
 235 /**
 236
 237   IsShellNodeDevicePath checks for the Shell device path.
 238   If it's the shell device path then return TRUE otherwise
 239   return FALSE.
 240
 241   @param DevicePath    The DevicePath to check
 242
 243   @retval  TRUE        DevicePath is Shell
 244   @retval  FALSE       DevicePath is not Shell
 245
 246 **/
 247 BOOLEAN
 248 IsShellNodeDevicePath(
 249   IN  EFI_DEVICE_PATH_PROTOCOL          *FilePath
 250   )
 251 {
 252
 253   EFI_DEVICE_PATH_PROTOCOL              *Node;
 254
 255   for (Node = FilePath; !IsDevicePathEnd(Node); Node = NextDevicePathNode(Node))
 256   {
 257     if ((DevicePathType (Node) == MEDIA_DEVICE_PATH) && (DevicePathSubType (Node) == MEDIA_PIWG_FW_FILE_DP)) {
 258       if (!CompareMem(PcdGetPtr(PcdShellFile), &(((MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *)Node)->FvFileName), sizeof(EFI_GUID)))
 259          return TRUE;
 260     }
 261   }
 262   return FALSE;
 263 }
 264
 265 /**
 266   Create a list of boot option from global BootOptionMenu. It
 267   allow user to delete the boot option.
 268
 269   @param CallbackData    The BMM context data.
 270
 271 **/
 272 VOID
 273 UpdateBootDelPage (
 274   IN BMM_CALLBACK_DATA                *CallbackData
 275   )
 276 {
 277   BM_MENU_ENTRY   *NewMenuEntry;
 278   BM_LOAD_CONTEXT *NewLoadContext;
 279   UINT16          Index;
 280
 281   //CallbackData->BmmAskSaveOrNot = TRUE;
 282
 283   UpdatePageStart (CallbackData);
 284   CreateMenuStringToken (CallbackData, CallbackData->BmmHiiHandle, &BootOptionMenu);
 285
 286   ASSERT (BootOptionMenu.MenuNumber <= (sizeof (CallbackData->BmmFakeNvData.BootOptionDel) / sizeof (CallbackData->BmmFakeNvData.BootOptionDel[0])));
 287   for (Index = 0; Index < BootOptionMenu.MenuNumber; Index++) {
 288     NewMenuEntry    = BOpt_GetMenuEntry (&BootOptionMenu, Index);
 289     NewLoadContext  = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
 290     if (NewLoadContext->IsLegacy) {
 291       continue;
 292     }
 293
 294     //
 295     // Check to see if the current boot option devicepath is the ShellDevice
 296     // path. If it is keep only UEFI Shell in the delete boot option list
 297     // or else continue
 298     //
 299     //if ((NULL != NewLoadContext->FilePathList) && (TRUE == IsShellNodeDevicePath(NewLoadContext->FilePathList))) {
 300     //  NewLoadContext->Deleted = FALSE;
 301     //  CallbackData->BmmFakeNvData.OptionDel[Index] = FALSE;
 302
 303       HiiCreateCheckBoxOpCode (
 304         mStartOpCodeHandle,
 305         (EFI_QUESTION_ID) (BOOT_OPTION_DEL_QUESTION_ID + Index),
 306         VARSTORE_ID_BOOT_MAINT,
 307         (UINT16) (BOOT_OPTION_DEL_VAR_OFFSET + Index),
 308         NewMenuEntry->DisplayStringToken,
 309         NewMenuEntry->HelpStringToken,
 310         0,
 311         0,
 312         NULL
 313         );
 314     //} else {
 315     //    continue;
 316     //}
 317   }
 318   UpdatePageEnd (CallbackData);
 319 }
 320
 321 /**
 322   Create a lit of driver option from global DriverMenu.
 323
 324   @param CallbackData    The BMM context data.
 325
 326 **/
 327 VOID
 328 UpdateDrvAddHandlePage (
 329   IN BMM_CALLBACK_DATA                *CallbackData
 330   )
 331 {
 332   BM_MENU_ENTRY *NewMenuEntry;
 333   UINT16        Index;
 334
 335   CallbackData->BmmAskSaveOrNot = FALSE;
 336
 337   UpdatePageStart (CallbackData);
 338
 339   for (Index = 0; Index < DriverMenu.MenuNumber; Index++) {
 340     NewMenuEntry = BOpt_GetMenuEntry (&DriverMenu, Index);
 341
 342     HiiCreateGotoOpCode (
 343       mStartOpCodeHandle,
 344       FORM_DRV_ADD_HANDLE_DESC_ID,
 345       NewMenuEntry->DisplayStringToken,
 346       STRING_TOKEN (STR_NULL_STRING),
 347       EFI_IFR_FLAG_CALLBACK,
 348       (UINT16) (HANDLE_OPTION_OFFSET + Index)
 349       );
 350   }
 351
 352   UpdatePageEnd (CallbackData);
 353 }
 354
 355 /**
 356   Create a lit of driver option from global DriverOptionMenu. It
 357   allow user to delete the driver option.
 358
 359   @param CallbackData    The BMM context data.
 360
 361 **/
 362 VOID
 363 UpdateDrvDelPage (
 364   IN BMM_CALLBACK_DATA                *CallbackData
 365   )
 366 {
 367   BM_MENU_ENTRY   *NewMenuEntry;
 368   BM_LOAD_CONTEXT *NewLoadContext;
 369   UINT16          Index;
 370
 371   CallbackData->BmmAskSaveOrNot = TRUE;
 372
 373   UpdatePageStart (CallbackData);
 374
 375   CreateMenuStringToken (CallbackData, CallbackData->BmmHiiHandle, &DriverOptionMenu);
 376
 377   ASSERT (DriverOptionMenu.MenuNumber <= (sizeof (CallbackData->BmmFakeNvData.DriverOptionDel) / sizeof (CallbackData->BmmFakeNvData.DriverOptionDel[0])));
 378   for (Index = 0; Index < DriverOptionMenu.MenuNumber; Index++) {
 379     NewMenuEntry            = BOpt_GetMenuEntry (&DriverOptionMenu, Index);
 380
 381     NewLoadContext          = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
 382     NewLoadContext->Deleted = FALSE;
 383     CallbackData->BmmFakeNvData.DriverOptionDel[Index] = FALSE;
 384
 385     HiiCreateCheckBoxOpCode (
 386       mStartOpCodeHandle,
 387       (EFI_QUESTION_ID) (DRIVER_OPTION_DEL_QUESTION_ID + Index),
 388       VARSTORE_ID_BOOT_MAINT,
 389       (UINT16) (DRIVER_OPTION_DEL_VAR_OFFSET + Index),
 390       NewMenuEntry->DisplayStringToken,
 391       NewMenuEntry->HelpStringToken,
 392       0,
 393       0,
 394       NULL
 395       );
 396   }
 397
 398   UpdatePageEnd (CallbackData);
 399 }
 400
 401 /**
 402   Prepare the page to allow user to add description for
 403   a Driver Option.
 404
 405   @param CallbackData    The BMM context data.
 406
 407 **/
 408 VOID
 409 UpdateDriverAddHandleDescPage (
 410   IN BMM_CALLBACK_DATA                *CallbackData
 411   )
 412 {
 413   BM_MENU_ENTRY *NewMenuEntry;
 414
 415   CallbackData->BmmFakeNvData.DriverAddActive          = 0x01;
 416   CallbackData->BmmFakeNvData.DriverAddForceReconnect  = 0x00;
 417   CallbackData->BmmAskSaveOrNot                        = TRUE;
 418   NewMenuEntry = CallbackData->MenuEntry;
 419
 420   UpdatePageStart (CallbackData);
 421
 422   HiiCreateSubTitleOpCode (
 423     mStartOpCodeHandle,
 424     NewMenuEntry->DisplayStringToken,
 425     0,
 426     0,
 427     0
 428     );
 429
 430   HiiCreateStringOpCode (
 431     mStartOpCodeHandle,
 432     (EFI_QUESTION_ID) DRV_ADD_HANDLE_DESC_QUESTION_ID,
 433     VARSTORE_ID_BOOT_MAINT,
 434     DRV_ADD_HANDLE_DESC_VAR_OFFSET,
 435     STRING_TOKEN (STR_LOAD_OPTION_DESC),
 436     STRING_TOKEN (STR_NULL_STRING),
 437     0,
 438     0,
 439     6,
 440     75,
 441     NULL
 442     );
 443
 444   HiiCreateCheckBoxOpCode (
 445     mStartOpCodeHandle,
 446     (EFI_QUESTION_ID) DRV_ADD_RECON_QUESTION_ID,
 447     VARSTORE_ID_BOOT_MAINT,
 448     DRV_ADD_RECON_VAR_OFFSET,
 449     STRING_TOKEN (STR_LOAD_OPTION_FORCE_RECON),
 450     STRING_TOKEN (STR_LOAD_OPTION_FORCE_RECON),
 451     0,
 452     0,
 453     NULL
 454     );
 455
 456   HiiCreateStringOpCode (
 457     mStartOpCodeHandle,
 458     (EFI_QUESTION_ID) DRIVER_ADD_OPTION_QUESTION_ID,
 459     VARSTORE_ID_BOOT_MAINT,
 460     DRIVER_ADD_OPTION_VAR_OFFSET,
 461     STRING_TOKEN (STR_OPTIONAL_DATA),
 462     STRING_TOKEN (STR_NULL_STRING),
 463     0,
 464     0,
 465     6,
 466     75,
 467     NULL
 468     );
 469
 470   UpdatePageEnd (CallbackData);
 471 }
 472
 473 /**
 474   Update console page.
 475
 476   @param UpdatePageId    The form ID to be updated.
 477   @param ConsoleMenu     The console menu list.
 478   @param CallbackData    The BMM context data.
 479
 480 **/
 481 VOID
 482 UpdateConsolePage (
 483   IN UINT16                           UpdatePageId,
 484   IN BM_MENU_OPTION                   *ConsoleMenu,
 485   IN BMM_CALLBACK_DATA                *CallbackData
 486   )
 487 {
 488   BM_MENU_ENTRY       *NewMenuEntry;
 489   BM_CONSOLE_CONTEXT  *NewConsoleContext;
 490   BM_TERMINAL_CONTEXT *NewTerminalContext;
 491   UINT16              Index;
 492   UINT16              Index2;
 493   UINT8               CheckFlags;
 494
 495   CallbackData->BmmAskSaveOrNot = TRUE;
 496
 497   UpdatePageStart (CallbackData);
 498
 499   for (Index = 0; ((Index < ConsoleMenu->MenuNumber) && \
 500        (Index < (sizeof (CallbackData->BmmFakeNvData.ConsoleCheck) / sizeof (UINT8)))) ; Index++) {
 501     NewMenuEntry      = BOpt_GetMenuEntry (ConsoleMenu, Index);
 502     NewConsoleContext = (BM_CONSOLE_CONTEXT *) NewMenuEntry->VariableContext;
 503     CheckFlags        = 0;
 504     if (NewConsoleContext->IsActive) {
 505       CheckFlags |= EFI_IFR_CHECKBOX_DEFAULT;
 506       CallbackData->BmmFakeNvData.ConsoleCheck[Index] = TRUE;
 507     } else {
 508       CallbackData->BmmFakeNvData.ConsoleCheck[Index] = FALSE;
 509     }
 510
 511     HiiCreateCheckBoxOpCode (
 512       mStartOpCodeHandle,
 513       (EFI_QUESTION_ID) (CON_DEVICE_QUESTION_ID + Index),
 514       VARSTORE_ID_BOOT_MAINT,
 515       (UINT16) (CON_DEVICE_VAR_OFFSET + Index),
 516       NewMenuEntry->DisplayStringToken,
 517       NewMenuEntry->HelpStringToken,
 518       0,
 519       CheckFlags,
 520       NULL
 521       );
 522   }
 523
 524   for (Index2 = 0; ((Index2 < TerminalMenu.MenuNumber) && \
 525        (Index2 < (sizeof (CallbackData->BmmFakeNvData.ConsoleCheck) / sizeof (UINT8)))); Index2++) {
 526     CheckFlags          = 0;
 527     NewMenuEntry        = BOpt_GetMenuEntry (&TerminalMenu, Index2);
 528     NewTerminalContext  = (BM_TERMINAL_CONTEXT *) NewMenuEntry->VariableContext;
 529
 530     ASSERT (Index < MAX_MENU_NUMBER);
 531     if (((NewTerminalContext->IsConIn != 0) && (UpdatePageId == FORM_CON_IN_ID)) ||
 532         ((NewTerminalContext->IsConOut != 0) && (UpdatePageId == FORM_CON_OUT_ID)) ||
 533         ((NewTerminalContext->IsStdErr != 0) && (UpdatePageId == FORM_CON_ERR_ID))
 534         ) {
 535       CheckFlags |= EFI_IFR_CHECKBOX_DEFAULT;
 536       CallbackData->BmmFakeNvData.ConsoleCheck[Index] = TRUE;
 537     } else {
 538       CallbackData->BmmFakeNvData.ConsoleCheck[Index] = FALSE;
 539     }
 540
 541     HiiCreateCheckBoxOpCode (
 542       mStartOpCodeHandle,
 543       (EFI_QUESTION_ID) (CON_DEVICE_QUESTION_ID + Index),
 544       VARSTORE_ID_BOOT_MAINT,
 545       (UINT16) (CON_DEVICE_VAR_OFFSET + Index),
 546       NewMenuEntry->DisplayStringToken,
 547       NewMenuEntry->HelpStringToken,
 548       0,
 549       CheckFlags,
 550       NULL
 551       );
 552
 553     Index++;
 554   }
 555
 556   UpdatePageEnd (CallbackData);
 557 }
 558
 559 /**
 560   Update the page's NV Map if user has changed the order
 561   a list. This list can be Boot Order or Driver Order.
 562
 563   @param UpdatePageId    The form ID to be updated.
 564   @param OptionMenu      The new list.
 565   @param CallbackData    The BMM context data.
 566
 567 **/
 568 VOID
 569 UpdateOrderPage (
 570   IN UINT16                           UpdatePageId,
 571   IN BM_MENU_OPTION                   *OptionMenu,
 572   IN BMM_CALLBACK_DATA                *CallbackData
 573   )
 574 {
 575   BM_MENU_ENTRY     *NewMenuEntry;
 576   UINT16            Index;
 577   UINT16            OptionIndex;
 578   VOID              *OptionsOpCodeHandle;
 579   BM_LOAD_CONTEXT   *NewLoadContext;
 580   BOOLEAN           BootOptionFound;
 581   UINT32            *OptionOrder;
 582   EFI_QUESTION_ID   QuestionId;
 583   UINT16            VarOffset;
 584
 585
 586   UpdatePageStart (CallbackData);
 587
 588   CreateMenuStringToken (CallbackData, CallbackData->BmmHiiHandle, OptionMenu);
 589
 590   OptionOrder = NULL;
 591   QuestionId = 0;
 592   VarOffset = 0;
 593   switch (UpdatePageId) {
 594
 595   case FORM_BOOT_CHG_ID:
 596     GetBootOrder (CallbackData);
 597     OptionOrder = CallbackData->BmmFakeNvData.BootOptionOrder;
 598     QuestionId = BOOT_OPTION_ORDER_QUESTION_ID;
 599     VarOffset = BOOT_OPTION_ORDER_VAR_OFFSET;
 600     break;
 601
 602   case FORM_DRV_CHG_ID:
 603     GetDriverOrder (CallbackData);
 604     OptionOrder = CallbackData->BmmFakeNvData.DriverOptionOrder;
 605     QuestionId = DRIVER_OPTION_ORDER_QUESTION_ID;
 606     VarOffset = DRIVER_OPTION_ORDER_VAR_OFFSET;
 607     break;
 608   }
 609   ASSERT (OptionOrder != NULL);
 610
 611   OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
 612   ASSERT (OptionsOpCodeHandle != NULL);
 613
 614   NewMenuEntry = NULL;
 615   for (OptionIndex = 0; (OptionOrder[OptionIndex] != 0 && OptionIndex < MAX_MENU_NUMBER); OptionIndex++) {
 616     BootOptionFound = FALSE;
 617     for (Index = 0; Index < OptionMenu->MenuNumber; Index++) {
 618       NewMenuEntry   = BOpt_GetMenuEntry (OptionMenu, Index);
 619       NewLoadContext = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
 620       if ((UINT32) (NewMenuEntry->OptionNumber + 1) == OptionOrder[OptionIndex]) {
 621         BootOptionFound = TRUE;
 622         break;
 623       }
 624     }
 625     if (BootOptionFound) {
 626       HiiCreateOneOfOptionOpCode (
 627         OptionsOpCodeHandle,
 628         NewMenuEntry->DisplayStringToken,
 629         0,
 630         EFI_IFR_TYPE_NUM_SIZE_32,
 631         OptionOrder[OptionIndex]
 632         );
 633     }
 634   }
 635
 636   if (OptionMenu->MenuNumber > 0) {
 637     HiiCreateOrderedListOpCode (
 638       mStartOpCodeHandle,                          // Container for dynamic created opcodes
 639       QuestionId,                                  // Question ID
 640       VARSTORE_ID_BOOT_MAINT,                      // VarStore ID
 641       VarOffset,                                   // Offset in Buffer Storage
 642       STRING_TOKEN (STR_CHANGE_ORDER),             // Question prompt text
 643       STRING_TOKEN (STR_CHANGE_ORDER),             // Question help text
 644       0,                                           // Question flag
 645       0,                                           // Ordered list flag, e.g. EFI_IFR_UNIQUE_SET
 646       EFI_IFR_TYPE_NUM_SIZE_32,                    // Data type of Question value
 647       100,                                         // Maximum container
 648       OptionsOpCodeHandle,                         // Option Opcode list
 649       NULL                                         // Default Opcode is NULL
 650       );
 651   }
 652
 653   HiiFreeOpCodeHandle (OptionsOpCodeHandle);
 654
 655   UpdatePageEnd (CallbackData);
 656
 657 }
 658
 659 /**
 660   Create the dynamic page to allow user to set
 661   the "BootNext" value.
 662
 663   @param CallbackData    The BMM context data.
 664
 665 **/
 666 VOID
 667 UpdateBootNextPage (
 668   IN BMM_CALLBACK_DATA                *CallbackData
 669   )
 670 {
 671   BM_MENU_ENTRY   *NewMenuEntry;
 672   BM_LOAD_CONTEXT *NewLoadContext;
 673   UINTN           NumberOfOptions;
 674   UINT16          Index;
 675   VOID            *OptionsOpCodeHandle;
 676
 677   NumberOfOptions               = BootOptionMenu.MenuNumber;
 678   CallbackData->BmmAskSaveOrNot = TRUE;
 679
 680   UpdatePageStart (CallbackData);
 681   CreateMenuStringToken (CallbackData, CallbackData->BmmHiiHandle, &BootOptionMenu);
 682
 683   if (NumberOfOptions > 0) {
 684     OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
 685     ASSERT (OptionsOpCodeHandle != NULL);
 686
 687     CallbackData->BmmFakeNvData.BootNext = (UINT16) (BootOptionMenu.MenuNumber);
 688
 689     for (Index = 0; Index < BootOptionMenu.MenuNumber; Index++) {
 690       NewMenuEntry    = BOpt_GetMenuEntry (&BootOptionMenu, Index);
 691       NewLoadContext  = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
 692
 693       if (NewLoadContext->IsBootNext) {
 694         HiiCreateOneOfOptionOpCode (
 695           OptionsOpCodeHandle,
 696           NewMenuEntry->DisplayStringToken,
 697           EFI_IFR_OPTION_DEFAULT,
 698           EFI_IFR_TYPE_NUM_SIZE_16,
 699           Index
 700           );
 701         CallbackData->BmmFakeNvData.BootNext = Index;
 702       } else {
 703         HiiCreateOneOfOptionOpCode (
 704           OptionsOpCodeHandle,
 705           NewMenuEntry->DisplayStringToken,
 706           0,
 707           EFI_IFR_TYPE_NUM_SIZE_16,
 708           Index
 709           );
 710       }
 711     }
 712
 713     if (CallbackData->BmmFakeNvData.BootNext == Index) {
 714       HiiCreateOneOfOptionOpCode (
 715         OptionsOpCodeHandle,
 716         STRING_TOKEN (STR_NONE),
 717         EFI_IFR_OPTION_DEFAULT,
 718         EFI_IFR_TYPE_NUM_SIZE_16,
 719         Index
 720         );
 721     } else {
 722       HiiCreateOneOfOptionOpCode (
 723         OptionsOpCodeHandle,
 724         STRING_TOKEN (STR_NONE),
 725         0,
 726         EFI_IFR_TYPE_NUM_SIZE_16,
 727         Index
 728         );
 729     }
 730
 731     HiiCreateOneOfOpCode (
 732       mStartOpCodeHandle,
 733       (EFI_QUESTION_ID) BOOT_NEXT_QUESTION_ID,
 734       VARSTORE_ID_BOOT_MAINT,
 735       BOOT_NEXT_VAR_OFFSET,
 736       STRING_TOKEN (STR_BOOT_NEXT),
 737       STRING_TOKEN (STR_BOOT_NEXT_HELP),
 738       0,
 739       EFI_IFR_NUMERIC_SIZE_2,
 740       OptionsOpCodeHandle,
 741       NULL
 742       );
 743
 744     HiiFreeOpCodeHandle (OptionsOpCodeHandle);
 745   }
 746
 747   UpdatePageEnd (CallbackData);
 748 }
 749
 750 /**
 751   Create the dynamic page to allow user to set the "TimeOut" value.
 752
 753   @param CallbackData    The BMM context data.
 754
 755 **/
 756 VOID
 757 UpdateTimeOutPage (
 758   IN BMM_CALLBACK_DATA                *CallbackData
 759   )
 760 {
 761   UINT16  BootTimeOut;
 762   VOID    *DefaultOpCodeHandle;
 763
 764   CallbackData->BmmAskSaveOrNot = TRUE;
 765
 766   UpdatePageStart (CallbackData);
 767
 768   BootTimeOut = PcdGet16 (PcdPlatformBootTimeOut);
 769
 770   DefaultOpCodeHandle = HiiAllocateOpCodeHandle ();
 771   ASSERT (DefaultOpCodeHandle != NULL);
 772   HiiCreateDefaultOpCode (DefaultOpCodeHandle, EFI_HII_DEFAULT_CLASS_STANDARD, EFI_IFR_TYPE_NUM_SIZE_16, BootTimeOut);
 773
 774   HiiCreateNumericOpCode (
 775     mStartOpCodeHandle,
 776     (EFI_QUESTION_ID) BOOT_TIME_OUT_QUESTION_ID,
 777     VARSTORE_ID_BOOT_MAINT,
 778     BOOT_TIME_OUT_VAR_OFFSET,
 779     STRING_TOKEN (STR_NUM_AUTO_BOOT),
 780     STRING_TOKEN (STR_HLP_AUTO_BOOT),
 781     0,
 782     EFI_IFR_NUMERIC_SIZE_2 | EFI_IFR_DISPLAY_UINT_DEC,
 783     0,
 784     65535,
 785     0,
 786     DefaultOpCodeHandle
 787     );
 788
 789   HiiFreeOpCodeHandle (DefaultOpCodeHandle);
 790
 791   CallbackData->BmmFakeNvData.BootTimeOut = BootTimeOut;
 792
 793   UpdatePageEnd (CallbackData);
 794 }
 795
 796
 797 /**
 798   Refresh the text mode page.
 799
 800   @param CallbackData    The BMM context data.
 801
 802 **/
 803 VOID
 804 UpdateConModePage (
 805   IN BMM_CALLBACK_DATA                *CallbackData
 806   )
 807 {
 808   UINTN                         Mode;
 809   UINTN                         Index;
 810   UINTN                         Col;
 811   UINTN                         Row;
 812   CHAR16                        ModeString[50];
 813   CHAR16                        *PStr;
 814   UINTN                         MaxMode;
 815   UINTN                         ValidMode;
 816   EFI_STRING_ID                 *ModeToken;
 817   EFI_STATUS                    Status;
 818   VOID                          *OptionsOpCodeHandle;
 819   EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL  *ConOut;
 820
 821   ConOut    = gST->ConOut;
 822   Index     = 0;
 823   ValidMode = 0;
 824   MaxMode   = (UINTN) (ConOut->Mode->MaxMode);
 825
 826   CallbackData->BmmAskSaveOrNot = TRUE;
 827
 828   UpdatePageStart (CallbackData);
 829
 830   //
 831   // Check valid mode
 832   //
 833   for (Mode = 0; Mode < MaxMode; Mode++) {
 834     Status = ConOut->QueryMode (ConOut, Mode, &Col, &Row);
 835     if (EFI_ERROR (Status)) {
 836       continue;
 837     }
 838     ValidMode++;
 839   }
 840
 841   if (ValidMode == 0) {
 842     return;
 843   }
 844
 845   OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
 846   ASSERT (OptionsOpCodeHandle != NULL);
 847
 848   ModeToken           = AllocateZeroPool (sizeof (EFI_STRING_ID) * ValidMode);
 849   ASSERT(ModeToken != NULL);
 850
 851   //
 852   // Determin which mode should be the first entry in menu
 853   //
 854   GetConsoleOutMode (CallbackData);
 855
 856   //
 857   // Build text mode options
 858   //
 859   for (Mode = 0; Mode < MaxMode; Mode++) {
 860     Status = ConOut->QueryMode (ConOut, Mode, &Col, &Row);
 861     if (EFI_ERROR (Status)) {
 862       continue;
 863     }
 864
 865     //
 866     // Build mode string Column x Row
 867     //
 868     UnicodeValueToString (ModeString, 0, Col, 0);
 869     PStr = &ModeString[0];
 870     StrnCat (PStr, L" x ", StrLen(L" x ") + 1);
 871     PStr = PStr + StrLen (PStr);
 872     UnicodeValueToString (PStr , 0, Row, 0);
 873
 874     ModeToken[Index] = HiiSetString (CallbackData->BmmHiiHandle, 0, ModeString, NULL);
 875
 876     if (Mode == CallbackData->BmmFakeNvData.ConsoleOutMode) {
 877       HiiCreateOneOfOptionOpCode (
 878         OptionsOpCodeHandle,
 879         ModeToken[Index],
 880         EFI_IFR_OPTION_DEFAULT,
 881         EFI_IFR_TYPE_NUM_SIZE_16,
 882         (UINT16) Mode
 883         );
 884     } else {
 885       HiiCreateOneOfOptionOpCode (
 886         OptionsOpCodeHandle,
 887         ModeToken[Index],
 888         0,
 889         EFI_IFR_TYPE_NUM_SIZE_16,
 890         (UINT16) Mode
 891         );
 892     }
 893     Index++;
 894   }
 895
 896   HiiCreateOneOfOpCode (
 897     mStartOpCodeHandle,
 898     (EFI_QUESTION_ID) CON_MODE_QUESTION_ID,
 899     VARSTORE_ID_BOOT_MAINT,
 900     CON_MODE_VAR_OFFSET,
 901     STRING_TOKEN (STR_CON_MODE_SETUP),
 902     STRING_TOKEN (STR_CON_MODE_SETUP),
 903     EFI_IFR_FLAG_RESET_REQUIRED,
 904     EFI_IFR_NUMERIC_SIZE_2,
 905     OptionsOpCodeHandle,
 906     NULL
 907     );
 908
 909   HiiFreeOpCodeHandle (OptionsOpCodeHandle);
 910   FreePool (ModeToken);
 911
 912   UpdatePageEnd (CallbackData);
 913 }
 914
 915 /**
 916   Create the dynamic page which allows user to set the property such as Baud Rate, Data Bits,
 917   Parity, Stop Bits, Terminal Type.
 918
 919   @param CallbackData    The BMM context data.
 920
 921 **/
 922 VOID
 923 UpdateTerminalPage (
 924   IN BMM_CALLBACK_DATA                *CallbackData
 925   )
 926 {
 927   UINT8               Index;
 928   UINT8               CheckFlags;
 929   BM_MENU_ENTRY       *NewMenuEntry;
 930   BM_TERMINAL_CONTEXT *NewTerminalContext;
 931   VOID                *OptionsOpCodeHandle;
 932
 933   CallbackData->BmmAskSaveOrNot = TRUE;
 934
 935   UpdatePageStart (CallbackData);
 936
 937   NewMenuEntry = BOpt_GetMenuEntry (
 938                   &TerminalMenu,
 939                   CallbackData->CurrentTerminal
 940                   );
 941
 942   if (NewMenuEntry == NULL) {
 943     return ;
 944   }
 945
 946   NewTerminalContext  = (BM_TERMINAL_CONTEXT *) NewMenuEntry->VariableContext;
 947
 948   OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
 949   ASSERT (OptionsOpCodeHandle != NULL);
 950
 951   for (Index = 0; Index < sizeof (BaudRateList) / sizeof (BaudRateList [0]); Index++) {
 952     CheckFlags = 0;
 953     if (NewTerminalContext->BaudRate == (UINT64) (BaudRateList[Index].Value)) {
 954       CheckFlags |= EFI_IFR_OPTION_DEFAULT;
 955       NewTerminalContext->BaudRateIndex         = Index;
 956       CallbackData->BmmFakeNvData.COMBaudRate  = NewTerminalContext->BaudRateIndex;
 957     }
 958
 959     HiiCreateOneOfOptionOpCode (
 960       OptionsOpCodeHandle,
 961       BaudRateList[Index].StringToken,
 962       CheckFlags,
 963       EFI_IFR_TYPE_NUM_SIZE_8,
 964       Index
 965       );
 966   }
 967
 968   HiiCreateOneOfOpCode (
 969     mStartOpCodeHandle,
 970     (EFI_QUESTION_ID) COM_BAUD_RATE_QUESTION_ID,
 971     VARSTORE_ID_BOOT_MAINT,
 972     COM_BAUD_RATE_VAR_OFFSET,
 973     STRING_TOKEN (STR_COM_BAUD_RATE),
 974     STRING_TOKEN (STR_COM_BAUD_RATE),
 975     0,
 976     EFI_IFR_NUMERIC_SIZE_1,
 977     OptionsOpCodeHandle,
 978     NULL
 979     );
 980
 981   HiiFreeOpCodeHandle (OptionsOpCodeHandle);
 982   OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
 983   ASSERT (OptionsOpCodeHandle != NULL);
 984
 985   for (Index = 0; Index < sizeof (DataBitsList) / sizeof (DataBitsList[0]); Index++) {
 986     CheckFlags = 0;
 987
 988     if (NewTerminalContext->DataBits == DataBitsList[Index].Value) {
 989       NewTerminalContext->DataBitsIndex         = Index;
 990       CallbackData->BmmFakeNvData.COMDataRate  = NewTerminalContext->DataBitsIndex;
 991       CheckFlags |= EFI_IFR_OPTION_DEFAULT;
 992     }
 993
 994     HiiCreateOneOfOptionOpCode (
 995       OptionsOpCodeHandle,
 996       DataBitsList[Index].StringToken,
 997       CheckFlags,
 998       EFI_IFR_TYPE_NUM_SIZE_8,
 999       Index
1000       );
1001   }
1002
1003   HiiCreateOneOfOpCode (
1004     mStartOpCodeHandle,
1005     (EFI_QUESTION_ID) COM_DATA_RATE_QUESTION_ID,
1006     VARSTORE_ID_BOOT_MAINT,
1007     COM_DATA_RATE_VAR_OFFSET,
1008     STRING_TOKEN (STR_COM_DATA_BITS),
1009     STRING_TOKEN (STR_COM_DATA_BITS),
1010     0,
1011     EFI_IFR_NUMERIC_SIZE_1,
1012     OptionsOpCodeHandle,
1013     NULL
1014     );
1015
1016   HiiFreeOpCodeHandle (OptionsOpCodeHandle);
1017   OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
1018   ASSERT (OptionsOpCodeHandle != NULL);
1019
1020   for (Index = 0; Index < sizeof (ParityList) / sizeof (ParityList[0]); Index++) {
1021     CheckFlags = 0;
1022     if (NewTerminalContext->Parity == ParityList[Index].Value) {
1023       CheckFlags |= EFI_IFR_OPTION_DEFAULT;
1024       NewTerminalContext->ParityIndex         = (UINT8) Index;
1025       CallbackData->BmmFakeNvData.COMParity  = NewTerminalContext->ParityIndex;
1026     }
1027
1028     HiiCreateOneOfOptionOpCode (
1029       OptionsOpCodeHandle,
1030       ParityList[Index].StringToken,
1031       CheckFlags,
1032       EFI_IFR_TYPE_NUM_SIZE_8,
1033       Index
1034       );
1035   }
1036
1037   HiiCreateOneOfOpCode (
1038     mStartOpCodeHandle,
1039     (EFI_QUESTION_ID) COM_PARITY_QUESTION_ID,
1040     VARSTORE_ID_BOOT_MAINT,
1041     COM_PARITY_VAR_OFFSET,
1042     STRING_TOKEN (STR_COM_PARITY),
1043     STRING_TOKEN (STR_COM_PARITY),
1044     0,
1045     EFI_IFR_NUMERIC_SIZE_1,
1046     OptionsOpCodeHandle,
1047     NULL
1048     );
1049
1050   HiiFreeOpCodeHandle (OptionsOpCodeHandle);
1051   OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
1052   ASSERT (OptionsOpCodeHandle != NULL);
1053
1054   for (Index = 0; Index < sizeof (StopBitsList) / sizeof (StopBitsList[0]); Index++) {
1055     CheckFlags = 0;
1056     if (NewTerminalContext->StopBits == StopBitsList[Index].Value) {
1057       CheckFlags |= EFI_IFR_OPTION_DEFAULT;
1058       NewTerminalContext->StopBitsIndex         = (UINT8) Index;
1059       CallbackData->BmmFakeNvData.COMStopBits  = NewTerminalContext->StopBitsIndex;
1060     }
1061
1062     HiiCreateOneOfOptionOpCode (
1063       OptionsOpCodeHandle,
1064       StopBitsList[Index].StringToken,
1065       CheckFlags,
1066       EFI_IFR_TYPE_NUM_SIZE_8,
1067       Index
1068       );
1069   }
1070
1071   HiiCreateOneOfOpCode (
1072     mStartOpCodeHandle,
1073     (EFI_QUESTION_ID) COM_STOP_BITS_QUESTION_ID,
1074     VARSTORE_ID_BOOT_MAINT,
1075     COM_STOP_BITS_VAR_OFFSET,
1076     STRING_TOKEN (STR_COM_STOP_BITS),
1077     STRING_TOKEN (STR_COM_STOP_BITS),
1078     0,
1079     EFI_IFR_NUMERIC_SIZE_1,
1080     OptionsOpCodeHandle,
1081     NULL
1082     );
1083
1084   HiiFreeOpCodeHandle (OptionsOpCodeHandle);
1085   OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
1086   ASSERT (OptionsOpCodeHandle != NULL);
1087
1088   for (Index = 0; Index < 4; Index++) {
1089     CheckFlags = 0;
1090     if (NewTerminalContext->TerminalType == Index) {
1091       CheckFlags |= EFI_IFR_OPTION_DEFAULT;
1092       CallbackData->BmmFakeNvData.COMTerminalType = NewTerminalContext->TerminalType;
1093     }
1094
1095     HiiCreateOneOfOptionOpCode (
1096       OptionsOpCodeHandle,
1097       (EFI_STRING_ID) TerminalType[Index],
1098       CheckFlags,
1099       EFI_IFR_TYPE_NUM_SIZE_8,
1100       Index
1101       );
1102   }
1103
1104   HiiCreateOneOfOpCode (
1105     mStartOpCodeHandle,
1106     (EFI_QUESTION_ID) COM_TERMINAL_QUESTION_ID,
1107     VARSTORE_ID_BOOT_MAINT,
1108     COM_TERMINAL_VAR_OFFSET,
1109     STRING_TOKEN (STR_COM_TERMI_TYPE),
1110     STRING_TOKEN (STR_COM_TERMI_TYPE),
1111     0,
1112     EFI_IFR_NUMERIC_SIZE_1,
1113     OptionsOpCodeHandle,
1114     NULL
1115     );
1116
1117   HiiFreeOpCodeHandle (OptionsOpCodeHandle);
1118
1119   UpdatePageEnd (CallbackData);
1120 }
1121
1122 /**
1123   Dispatch the correct update page function to call based on
1124   the UpdatePageId.
1125
1126   @param UpdatePageId    The form ID.
1127   @param CallbackData    The BMM context data.
1128
1129 **/
1130 VOID
1131 UpdatePageBody (
1132   IN UINT16                           UpdatePageId,
1133   IN BMM_CALLBACK_DATA                *CallbackData
1134   )
1135 {
1136   CleanUpPage (UpdatePageId, CallbackData);
1137   switch (UpdatePageId) {
1138   case FORM_CON_IN_ID:
1139     UpdateConsolePage (UpdatePageId, &ConsoleInpMenu, CallbackData);
1140     break;
1141
1142   case FORM_CON_OUT_ID:
1143     UpdateConsolePage (UpdatePageId, &ConsoleOutMenu, CallbackData);
1144     break;
1145
1146   case FORM_CON_ERR_ID:
1147     UpdateConsolePage (UpdatePageId, &ConsoleErrMenu, CallbackData);
1148     break;
1149
1150   case FORM_BOOT_CHG_ID:
1151     UpdateOrderPage (UpdatePageId, &BootOptionMenu, CallbackData);
1152     break;
1153
1154   case FORM_DRV_CHG_ID:
1155     UpdateOrderPage (UpdatePageId, &DriverOptionMenu, CallbackData);
1156     break;
1157
1158   default:
1159     break;
1160   }
1161 }
1162
1163 /**
1164   Dispatch the display to the next page based on NewPageId.
1165
1166   @param Private         The BMM context data.
1167   @param NewPageId       The original page ID.
1168
1169 **/
1170 VOID
1171 UpdatePageId (
1172   BMM_CALLBACK_DATA              *Private,
1173   UINT16                         NewPageId
1174   )
1175 {
1176   if ((NewPageId < FILE_OPTION_OFFSET) && (NewPageId >= HANDLE_OPTION_OFFSET)) {
1177     //
1178     // If we select a handle to add driver option, advance to the add handle description page.
1179     //
1180     NewPageId = FORM_DRV_ADD_HANDLE_DESC_ID;
1181   } else if ((NewPageId == KEY_VALUE_SAVE_AND_EXIT) || (NewPageId == KEY_VALUE_NO_SAVE_AND_EXIT)) {
1182     //
1183     // Return to main page after "Save Changes" or "Discard Changes".
1184     //
1185     NewPageId = FORM_MAIN_ID;
1186   } else if ((NewPageId >= TERMINAL_OPTION_OFFSET) && (NewPageId < CONSOLE_OPTION_OFFSET)) {
1187     NewPageId = FORM_CON_COM_SETUP_ID;
1188   }
1189
1190   if ((NewPageId > 0) && (NewPageId < MAXIMUM_FORM_ID)) {
1191     Private->BmmPreviousPageId  = Private->BmmCurrentPageId;
1192     Private->BmmCurrentPageId   = NewPageId;
1193   }
1194 }