MdeModulePkg/Library/BootMaintenanceManagerUiLib/UpdatePage.c

   1 /** @file
   2 Dynamically update the pages.
   3
   4 Copyright (c) 2004 - 2016, 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 "BootMaintenanceManager.h"
  16
  17 /**
  18  Create the global UpdateData structure.
  19
  20 **/
  21 VOID
  22 CreateUpdateData (
  23   VOID
  24   )
  25 {
  26   //
  27   // Init OpCode Handle and Allocate space for creation of Buffer
  28   //
  29   mStartOpCodeHandle = HiiAllocateOpCodeHandle ();
  30   ASSERT (mStartOpCodeHandle != NULL);
  31
  32   mEndOpCodeHandle = HiiAllocateOpCodeHandle ();
  33   ASSERT (mEndOpCodeHandle != NULL);
  34
  35   //
  36   // Create Hii Extend Label OpCode as the start opcode
  37   //
  38   mStartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (mStartOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL));
  39   mStartLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
  40
  41   //
  42   // Create Hii Extend Label OpCode as the end opcode
  43   //
  44   mEndLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (mEndOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL));
  45   mEndLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
  46   mEndLabel->Number       = LABEL_END;
  47 }
  48
  49 /**
  50   Refresh the global UpdateData structure.
  51
  52 **/
  53 VOID
  54 RefreshUpdateData (
  55   VOID
  56   )
  57 {
  58   //
  59   // Free current updated date
  60   //
  61   if (mStartOpCodeHandle != NULL) {
  62     HiiFreeOpCodeHandle (mStartOpCodeHandle);
  63   }
  64
  65   //
  66   // Create new OpCode Handle
  67   //
  68   mStartOpCodeHandle = HiiAllocateOpCodeHandle ();
  69
  70   //
  71   // Create Hii Extend Label OpCode as the start opcode
  72   //
  73   mStartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (mStartOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL));
  74   mStartLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
  75
  76 }
  77
  78 /**
  79   Add a "Go back to main page" tag in front of the form when there are no
  80   "Apply changes" and "Discard changes" tags in the end of the form.
  81
  82   @param CallbackData    The BMM context data.
  83
  84 **/
  85 VOID
  86 UpdatePageStart (
  87   IN BMM_CALLBACK_DATA                *CallbackData
  88   )
  89 {
  90   RefreshUpdateData ();
  91   mStartLabel->Number = CallbackData->BmmCurrentPageId;
  92
  93   if (!(CallbackData->BmmAskSaveOrNot)) {
  94     //
  95     // Add a "Go back to main page" tag in front of the form when there are no
  96     // "Apply changes" and "Discard changes" tags in the end of the form.
  97     //
  98     HiiCreateGotoOpCode (
  99       mStartOpCodeHandle,
 100       FORM_MAIN_ID,
 101       STRING_TOKEN (STR_FORM_GOTO_MAIN),
 102       STRING_TOKEN (STR_FORM_GOTO_MAIN),
 103       0,
 104       FORM_MAIN_ID
 105       );
 106   }
 107 }
 108
 109 /**
 110   Create the "Apply changes" and "Discard changes" tags. And
 111   ensure user can return to the main page.
 112
 113   @param CallbackData    The BMM context data.
 114
 115 **/
 116 VOID
 117 UpdatePageEnd (
 118   IN BMM_CALLBACK_DATA                *CallbackData
 119   )
 120 {
 121   //
 122   // Create the "Apply changes" and "Discard changes" tags.
 123   //
 124   if (CallbackData->BmmAskSaveOrNot) {
 125     HiiCreateSubTitleOpCode (
 126       mStartOpCodeHandle,
 127       STRING_TOKEN (STR_NULL_STRING),
 128       0,
 129       0,
 130       0
 131       );
 132
 133     HiiCreateActionOpCode (
 134       mStartOpCodeHandle,
 135       KEY_VALUE_SAVE_AND_EXIT,
 136       STRING_TOKEN (STR_SAVE_AND_EXIT),
 137       STRING_TOKEN (STR_NULL_STRING),
 138       EFI_IFR_FLAG_CALLBACK,
 139       0
 140       );
 141   }
 142
 143   //
 144   // Ensure user can return to the main page.
 145   //
 146   HiiCreateActionOpCode (
 147     mStartOpCodeHandle,
 148     KEY_VALUE_NO_SAVE_AND_EXIT,
 149     STRING_TOKEN (STR_NO_SAVE_AND_EXIT),
 150     STRING_TOKEN (STR_NULL_STRING),
 151     EFI_IFR_FLAG_CALLBACK,
 152     0
 153     );
 154
 155   HiiUpdateForm (
 156     CallbackData->BmmHiiHandle,
 157     &mBootMaintGuid,
 158     CallbackData->BmmCurrentPageId,
 159     mStartOpCodeHandle, // Label CallbackData->BmmCurrentPageId
 160     mEndOpCodeHandle    // LABEL_END
 161     );
 162 }
 163
 164 /**
 165   Clean up the dynamic opcode at label and form specified by both LabelId.
 166
 167   @param LabelId         It is both the Form ID and Label ID for opcode deletion.
 168   @param CallbackData    The BMM context data.
 169
 170 **/
 171 VOID
 172 CleanUpPage (
 173   IN UINT16                           LabelId,
 174   IN BMM_CALLBACK_DATA                *CallbackData
 175   )
 176 {
 177   RefreshUpdateData ();
 178
 179   //
 180   // Remove all op-codes from dynamic page
 181   //
 182   mStartLabel->Number = LabelId;
 183   HiiUpdateForm (
 184     CallbackData->BmmHiiHandle,
 185     &mBootMaintGuid,
 186     LabelId,
 187     mStartOpCodeHandle, // Label LabelId
 188     mEndOpCodeHandle    // LABEL_END
 189     );
 190 }
 191
 192 /**
 193   Create a list of Goto Opcode for all terminal devices logged
 194   by TerminaMenu. This list will be inserted to form FORM_CON_COM_SETUP_ID.
 195
 196   @param CallbackData    The BMM context data.
 197 **/
 198 VOID
 199 UpdateConCOMPage (
 200   IN BMM_CALLBACK_DATA                *CallbackData
 201   )
 202 {
 203   BM_MENU_ENTRY       *NewMenuEntry;
 204   UINT16              Index;
 205
 206   CallbackData->BmmAskSaveOrNot = TRUE;
 207
 208   UpdatePageStart (CallbackData);
 209
 210   for (Index = 0; Index < TerminalMenu.MenuNumber; Index++) {
 211     NewMenuEntry = BOpt_GetMenuEntry (&TerminalMenu, Index);
 212
 213     HiiCreateGotoOpCode (
 214       mStartOpCodeHandle,
 215       FORM_CON_COM_SETUP_ID,
 216       NewMenuEntry->DisplayStringToken,
 217       STRING_TOKEN (STR_NULL_STRING),
 218       EFI_IFR_FLAG_CALLBACK,
 219       (UINT16) (TERMINAL_OPTION_OFFSET + Index)
 220       );
 221   }
 222
 223   UpdatePageEnd (CallbackData);
 224 }
 225
 226
 227 /**
 228   Create a list of boot option from global BootOptionMenu. It
 229   allow user to delete the boot option.
 230
 231   @param CallbackData    The BMM context data.
 232
 233 **/
 234 VOID
 235 UpdateBootDelPage (
 236   IN BMM_CALLBACK_DATA                *CallbackData
 237   )
 238 {
 239   BM_MENU_ENTRY   *NewMenuEntry;
 240   BM_LOAD_CONTEXT *NewLoadContext;
 241   UINT16          Index;
 242
 243   CallbackData->BmmAskSaveOrNot = TRUE;
 244
 245   UpdatePageStart (CallbackData);
 246
 247   ASSERT (BootOptionMenu.MenuNumber <= (sizeof (CallbackData->BmmFakeNvData.BootOptionDel) / sizeof (CallbackData->BmmFakeNvData.BootOptionDel[0])));
 248   for (Index = 0; Index < BootOptionMenu.MenuNumber; Index++) {
 249     NewMenuEntry    = BOpt_GetMenuEntry (&BootOptionMenu, Index);
 250     NewLoadContext  = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
 251     if (NewLoadContext->IsLegacy) {
 252       continue;
 253     }
 254
 255     NewLoadContext->Deleted = FALSE;
 256
 257     if (CallbackData->BmmFakeNvData.BootOptionDel[Index] && !CallbackData->BmmFakeNvData.BootOptionDelMark[Index]) {
 258       //
 259       // CallbackData->BmmFakeNvData.BootOptionDel[Index] == TRUE means browser knows this boot option is selected
 260       // CallbackData->BmmFakeNvData.BootOptionDelMark[Index] = FALSE means BDS knows the selected boot option has
 261       // deleted, browser maintains old useless info. So clear this info here, and later update this info to browser
 262       // through HiiSetBrowserData function.
 263       //
 264       CallbackData->BmmFakeNvData.BootOptionDel[Index] = FALSE;
 265       CallbackData->BmmOldFakeNVData.BootOptionDel[Index] = FALSE;
 266     }
 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       EFI_IFR_FLAG_CALLBACK,
 276       0,
 277       NULL
 278       );
 279   }
 280   UpdatePageEnd (CallbackData);
 281 }
 282
 283 /**
 284   Create a lit of driver option from global DriverMenu.
 285
 286   @param CallbackData    The BMM context data.
 287
 288 **/
 289 VOID
 290 UpdateDrvAddHandlePage (
 291   IN BMM_CALLBACK_DATA                *CallbackData
 292   )
 293 {
 294   BM_MENU_ENTRY *NewMenuEntry;
 295   UINT16        Index;
 296
 297   CallbackData->BmmAskSaveOrNot = FALSE;
 298
 299   UpdatePageStart (CallbackData);
 300
 301   for (Index = 0; Index < DriverMenu.MenuNumber; Index++) {
 302     NewMenuEntry = BOpt_GetMenuEntry (&DriverMenu, Index);
 303
 304     HiiCreateGotoOpCode (
 305       mStartOpCodeHandle,
 306       FORM_DRV_ADD_HANDLE_DESC_ID,
 307       NewMenuEntry->DisplayStringToken,
 308       STRING_TOKEN (STR_NULL_STRING),
 309       EFI_IFR_FLAG_CALLBACK,
 310       (UINT16) (HANDLE_OPTION_OFFSET + Index)
 311       );
 312   }
 313
 314   UpdatePageEnd (CallbackData);
 315 }
 316
 317 /**
 318   Create a lit of driver option from global DriverOptionMenu. It
 319   allow user to delete the driver option.
 320
 321   @param CallbackData    The BMM context data.
 322
 323 **/
 324 VOID
 325 UpdateDrvDelPage (
 326   IN BMM_CALLBACK_DATA                *CallbackData
 327   )
 328 {
 329   BM_MENU_ENTRY   *NewMenuEntry;
 330   BM_LOAD_CONTEXT *NewLoadContext;
 331   UINT16          Index;
 332
 333   CallbackData->BmmAskSaveOrNot = TRUE;
 334
 335   UpdatePageStart (CallbackData);
 336
 337   ASSERT (DriverOptionMenu.MenuNumber <= (sizeof (CallbackData->BmmFakeNvData.DriverOptionDel) / sizeof (CallbackData->BmmFakeNvData.DriverOptionDel[0])));
 338   for (Index = 0; Index < DriverOptionMenu.MenuNumber; Index++) {
 339     NewMenuEntry            = BOpt_GetMenuEntry (&DriverOptionMenu, Index);
 340
 341     NewLoadContext          = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
 342     NewLoadContext->Deleted = FALSE;
 343
 344     if (CallbackData->BmmFakeNvData.DriverOptionDel[Index] && !CallbackData->BmmFakeNvData.DriverOptionDelMark[Index]) {
 345       //
 346       // CallbackData->BmmFakeNvData.BootOptionDel[Index] == TRUE means browser knows this boot option is selected
 347       // CallbackData->BmmFakeNvData.BootOptionDelMark[Index] = FALSE means BDS knows the selected boot option has
 348       // deleted, browser maintains old useless info. So clear this info here, and later update this info to browser
 349       // through HiiSetBrowserData function.
 350       //
 351       CallbackData->BmmFakeNvData.DriverOptionDel[Index] = FALSE;
 352       CallbackData->BmmOldFakeNVData.DriverOptionDel[Index] = FALSE;
 353     }
 354     HiiCreateCheckBoxOpCode (
 355       mStartOpCodeHandle,
 356       (EFI_QUESTION_ID) (DRIVER_OPTION_DEL_QUESTION_ID + Index),
 357       VARSTORE_ID_BOOT_MAINT,
 358       (UINT16) (DRIVER_OPTION_DEL_VAR_OFFSET + Index),
 359       NewMenuEntry->DisplayStringToken,
 360       NewMenuEntry->HelpStringToken,
 361       EFI_IFR_FLAG_CALLBACK,
 362       0,
 363       NULL
 364       );
 365   }
 366
 367   UpdatePageEnd (CallbackData);
 368 }
 369
 370 /**
 371   Prepare the page to allow user to add description for
 372   a Driver Option.
 373
 374   @param CallbackData    The BMM context data.
 375
 376 **/
 377 VOID
 378 UpdateDriverAddHandleDescPage (
 379   IN BMM_CALLBACK_DATA                *CallbackData
 380   )
 381 {
 382   BM_MENU_ENTRY *NewMenuEntry;
 383
 384   CallbackData->BmmFakeNvData.DriverAddActive          = 0x01;
 385   CallbackData->BmmFakeNvData.DriverAddForceReconnect  = 0x00;
 386   CallbackData->BmmAskSaveOrNot                        = TRUE;
 387   NewMenuEntry = CallbackData->MenuEntry;
 388
 389   UpdatePageStart (CallbackData);
 390
 391   HiiCreateSubTitleOpCode (
 392     mStartOpCodeHandle,
 393     NewMenuEntry->DisplayStringToken,
 394     0,
 395     0,
 396     0
 397     );
 398
 399   HiiCreateStringOpCode (
 400     mStartOpCodeHandle,
 401     (EFI_QUESTION_ID) DRV_ADD_HANDLE_DESC_QUESTION_ID,
 402     VARSTORE_ID_BOOT_MAINT,
 403     DRV_ADD_HANDLE_DESC_VAR_OFFSET,
 404     STRING_TOKEN (STR_LOAD_OPTION_DESC),
 405     STRING_TOKEN (STR_NULL_STRING),
 406     0,
 407     0,
 408     6,
 409     75,
 410     NULL
 411     );
 412
 413   HiiCreateCheckBoxOpCode (
 414     mStartOpCodeHandle,
 415     (EFI_QUESTION_ID) DRV_ADD_RECON_QUESTION_ID,
 416     VARSTORE_ID_BOOT_MAINT,
 417     DRV_ADD_RECON_VAR_OFFSET,
 418     STRING_TOKEN (STR_LOAD_OPTION_FORCE_RECON),
 419     STRING_TOKEN (STR_LOAD_OPTION_FORCE_RECON),
 420     0,
 421     0,
 422     NULL
 423     );
 424
 425   HiiCreateStringOpCode (
 426     mStartOpCodeHandle,
 427     (EFI_QUESTION_ID) DRIVER_ADD_OPTION_QUESTION_ID,
 428     VARSTORE_ID_BOOT_MAINT,
 429     DRIVER_ADD_OPTION_VAR_OFFSET,
 430     STRING_TOKEN (STR_OPTIONAL_DATA),
 431     STRING_TOKEN (STR_NULL_STRING),
 432     0,
 433     0,
 434     6,
 435     75,
 436     NULL
 437     );
 438
 439   UpdatePageEnd (CallbackData);
 440 }
 441
 442 /**
 443   Update console page.
 444
 445   @param UpdatePageId    The form ID to be updated.
 446   @param ConsoleMenu     The console menu list.
 447   @param CallbackData    The BMM context data.
 448
 449 **/
 450 VOID
 451 UpdateConsolePage (
 452   IN UINT16                           UpdatePageId,
 453   IN BM_MENU_OPTION                   *ConsoleMenu,
 454   IN BMM_CALLBACK_DATA                *CallbackData
 455   )
 456 {
 457   BM_MENU_ENTRY       *NewMenuEntry;
 458   BM_CONSOLE_CONTEXT  *NewConsoleContext;
 459   BM_TERMINAL_CONTEXT *NewTerminalContext;
 460   UINT16              Index;
 461   UINT16              Index2;
 462   UINT8               CheckFlags;
 463   UINT8               *ConsoleCheck;
 464   EFI_QUESTION_ID     QuestionIdBase;
 465   UINT16              VariableOffsetBase;
 466
 467   CallbackData->BmmAskSaveOrNot = TRUE;
 468
 469   UpdatePageStart (CallbackData);
 470
 471   ConsoleCheck       = NULL;
 472   QuestionIdBase     = 0;
 473   VariableOffsetBase = 0;
 474
 475   switch (UpdatePageId) {
 476   case FORM_CON_IN_ID:
 477     ConsoleCheck       = &CallbackData->BmmFakeNvData.ConsoleInCheck[0];
 478     QuestionIdBase     = CON_IN_DEVICE_QUESTION_ID;
 479     VariableOffsetBase = CON_IN_DEVICE_VAR_OFFSET;
 480     break;
 481
 482   case FORM_CON_OUT_ID:
 483     ConsoleCheck       = &CallbackData->BmmFakeNvData.ConsoleOutCheck[0];
 484     QuestionIdBase     = CON_OUT_DEVICE_QUESTION_ID;
 485     VariableOffsetBase = CON_OUT_DEVICE_VAR_OFFSET;
 486     break;
 487
 488   case FORM_CON_ERR_ID:
 489     ConsoleCheck       = &CallbackData->BmmFakeNvData.ConsoleErrCheck[0];
 490     QuestionIdBase     = CON_ERR_DEVICE_QUESTION_ID;
 491     VariableOffsetBase = CON_ERR_DEVICE_VAR_OFFSET;
 492     break;
 493   }
 494   ASSERT (ConsoleCheck != NULL);
 495
 496   for (Index = 0; ((Index < ConsoleMenu->MenuNumber) && \
 497        (Index < MAX_MENU_NUMBER)) ; Index++) {
 498     CheckFlags = 0;
 499     NewMenuEntry = BOpt_GetMenuEntry (ConsoleMenu, Index);
 500     NewConsoleContext = (BM_CONSOLE_CONTEXT *) NewMenuEntry->VariableContext;
 501     if (NewConsoleContext->IsActive) {
 502       CheckFlags |= EFI_IFR_CHECKBOX_DEFAULT;
 503       ConsoleCheck[Index] = TRUE;
 504     } else {
 505       ConsoleCheck[Index] = FALSE;
 506     }
 507     HiiCreateCheckBoxOpCode (
 508       mStartOpCodeHandle,
 509       (EFI_QUESTION_ID) (QuestionIdBase + Index),
 510       VARSTORE_ID_BOOT_MAINT,
 511       (UINT16) (VariableOffsetBase + Index),
 512       NewMenuEntry->DisplayStringToken,
 513       NewMenuEntry->HelpStringToken,
 514       EFI_IFR_FLAG_CALLBACK,
 515       CheckFlags,
 516       NULL
 517       );
 518   }
 519
 520   for (Index2 = 0; ((Index2 < TerminalMenu.MenuNumber) && \
 521        (Index2 < MAX_MENU_NUMBER)); Index2++) {
 522     CheckFlags          = 0;
 523     NewMenuEntry        = BOpt_GetMenuEntry (&TerminalMenu, Index2);
 524     NewTerminalContext  = (BM_TERMINAL_CONTEXT *) NewMenuEntry->VariableContext;
 525
 526     ASSERT (Index < MAX_MENU_NUMBER);
 527     if (((NewTerminalContext->IsConIn != 0) && (UpdatePageId == FORM_CON_IN_ID)) ||
 528         ((NewTerminalContext->IsConOut != 0) && (UpdatePageId == FORM_CON_OUT_ID)) ||
 529         ((NewTerminalContext->IsStdErr != 0) && (UpdatePageId == FORM_CON_ERR_ID))
 530         ) {
 531       CheckFlags |= EFI_IFR_CHECKBOX_DEFAULT;
 532       ConsoleCheck[Index] = TRUE;
 533     } else {
 534       ConsoleCheck[Index] = FALSE;
 535     }
 536     HiiCreateCheckBoxOpCode (
 537       mStartOpCodeHandle,
 538       (EFI_QUESTION_ID) (QuestionIdBase + Index),
 539       VARSTORE_ID_BOOT_MAINT,
 540       (UINT16) (VariableOffsetBase + Index),
 541       NewMenuEntry->DisplayStringToken,
 542       NewMenuEntry->HelpStringToken,
 543       EFI_IFR_FLAG_CALLBACK,
 544       CheckFlags,
 545       NULL
 546       );
 547
 548     Index++;
 549   }
 550
 551   UpdatePageEnd (CallbackData);
 552 }
 553
 554 /**
 555   Update the page's NV Map if user has changed the order
 556   a list. This list can be Boot Order or Driver Order.
 557
 558   @param UpdatePageId    The form ID to be updated.
 559   @param OptionMenu      The new list.
 560   @param CallbackData    The BMM context data.
 561
 562 **/
 563 VOID
 564 UpdateOrderPage (
 565   IN UINT16                           UpdatePageId,
 566   IN BM_MENU_OPTION                   *OptionMenu,
 567   IN BMM_CALLBACK_DATA                *CallbackData
 568   )
 569 {
 570   BM_MENU_ENTRY     *NewMenuEntry;
 571   UINT16            Index;
 572   UINT16            OptionIndex;
 573   VOID              *OptionsOpCodeHandle;
 574   BOOLEAN           BootOptionFound;
 575   UINT32            *OptionOrder;
 576   EFI_QUESTION_ID   QuestionId;
 577   UINT16            VarOffset;
 578
 579   CallbackData->BmmAskSaveOrNot = TRUE;
 580   UpdatePageStart (CallbackData);
 581
 582   OptionOrder = NULL;
 583   QuestionId = 0;
 584   VarOffset = 0;
 585   switch (UpdatePageId) {
 586
 587   case FORM_BOOT_CHG_ID:
 588     GetBootOrder (CallbackData);
 589     OptionOrder = CallbackData->BmmFakeNvData.BootOptionOrder;
 590     QuestionId = BOOT_OPTION_ORDER_QUESTION_ID;
 591     VarOffset = BOOT_OPTION_ORDER_VAR_OFFSET;
 592     break;
 593
 594   case FORM_DRV_CHG_ID:
 595     GetDriverOrder (CallbackData);
 596     OptionOrder = CallbackData->BmmFakeNvData.DriverOptionOrder;
 597     QuestionId = DRIVER_OPTION_ORDER_QUESTION_ID;
 598     VarOffset = DRIVER_OPTION_ORDER_VAR_OFFSET;
 599     break;
 600   }
 601   ASSERT (OptionOrder != NULL);
 602
 603   OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
 604   ASSERT (OptionsOpCodeHandle != NULL);
 605
 606   NewMenuEntry = NULL;
 607   for (OptionIndex = 0; (OptionOrder[OptionIndex] != 0 && OptionIndex < MAX_MENU_NUMBER); OptionIndex++) {
 608     BootOptionFound = FALSE;
 609     for (Index = 0; Index < OptionMenu->MenuNumber; Index++) {
 610       NewMenuEntry   = BOpt_GetMenuEntry (OptionMenu, Index);
 611       if ((UINT32) (NewMenuEntry->OptionNumber + 1) == OptionOrder[OptionIndex]) {
 612         BootOptionFound = TRUE;
 613         break;
 614       }
 615     }
 616     if (BootOptionFound) {
 617       HiiCreateOneOfOptionOpCode (
 618         OptionsOpCodeHandle,
 619         NewMenuEntry->DisplayStringToken,
 620         0,
 621         EFI_IFR_TYPE_NUM_SIZE_32,
 622         OptionOrder[OptionIndex]
 623         );
 624     }
 625   }
 626
 627   if (OptionMenu->MenuNumber > 0) {
 628     HiiCreateOrderedListOpCode (
 629       mStartOpCodeHandle,                          // Container for dynamic created opcodes
 630       QuestionId,                                  // Question ID
 631       VARSTORE_ID_BOOT_MAINT,                      // VarStore ID
 632       VarOffset,                                   // Offset in Buffer Storage
 633       STRING_TOKEN (STR_CHANGE_ORDER),             // Question prompt text
 634       STRING_TOKEN (STR_CHANGE_ORDER),             // Question help text
 635       0,                                           // Question flag
 636       0,                                           // Ordered list flag, e.g. EFI_IFR_UNIQUE_SET
 637       EFI_IFR_TYPE_NUM_SIZE_32,                    // Data type of Question value
 638       100,                                         // Maximum container
 639       OptionsOpCodeHandle,                         // Option Opcode list
 640       NULL                                         // Default Opcode is NULL
 641       );
 642   }
 643
 644   HiiFreeOpCodeHandle (OptionsOpCodeHandle);
 645
 646   UpdatePageEnd (CallbackData);
 647
 648 }
 649
 650 /**
 651   Refresh the text mode page.
 652
 653   @param CallbackData    The BMM context data.
 654
 655 **/
 656 VOID
 657 UpdateConModePage (
 658   IN BMM_CALLBACK_DATA                *CallbackData
 659   )
 660 {
 661   UINTN                         Mode;
 662   UINTN                         Index;
 663   UINTN                         Col;
 664   UINTN                         Row;
 665   CHAR16                        ModeString[50];
 666   CHAR16                        *PStr;
 667   UINTN                         MaxMode;
 668   UINTN                         ValidMode;
 669   EFI_STRING_ID                 *ModeToken;
 670   EFI_STATUS                    Status;
 671   VOID                          *OptionsOpCodeHandle;
 672   EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL  *ConOut;
 673
 674   ConOut    = gST->ConOut;
 675   Index     = 0;
 676   ValidMode = 0;
 677   MaxMode   = (UINTN) (ConOut->Mode->MaxMode);
 678
 679   CallbackData->BmmAskSaveOrNot = TRUE;
 680
 681   UpdatePageStart (CallbackData);
 682
 683   //
 684   // Check valid mode
 685   //
 686   for (Mode = 0; Mode < MaxMode; Mode++) {
 687     Status = ConOut->QueryMode (ConOut, Mode, &Col, &Row);
 688     if (EFI_ERROR (Status)) {
 689       continue;
 690     }
 691     ValidMode++;
 692   }
 693
 694   if (ValidMode == 0) {
 695     return;
 696   }
 697
 698   OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
 699   ASSERT (OptionsOpCodeHandle != NULL);
 700
 701   ModeToken           = AllocateZeroPool (sizeof (EFI_STRING_ID) * ValidMode);
 702   ASSERT(ModeToken != NULL);
 703
 704   //
 705   // Determin which mode should be the first entry in menu
 706   //
 707   GetConsoleOutMode (CallbackData);
 708
 709   //
 710   // Build text mode options
 711   //
 712   for (Mode = 0; Mode < MaxMode; Mode++) {
 713     Status = ConOut->QueryMode (ConOut, Mode, &Col, &Row);
 714     if (EFI_ERROR (Status)) {
 715       continue;
 716     }
 717
 718     //
 719     // Build mode string Column x Row
 720     //
 721     UnicodeValueToString (ModeString, 0, Col, 0);
 722     PStr = &ModeString[0];
 723     StrnCatS (PStr, sizeof (ModeString) / sizeof (ModeString[0]), L" x ", StrLen(L" x ") + 1);
 724     PStr = PStr + StrLen (PStr);
 725     UnicodeValueToString (PStr , 0, Row, 0);
 726
 727     ModeToken[Index] = HiiSetString (CallbackData->BmmHiiHandle, 0, ModeString, NULL);
 728
 729     if (Mode == CallbackData->BmmFakeNvData.ConsoleOutMode) {
 730       HiiCreateOneOfOptionOpCode (
 731         OptionsOpCodeHandle,
 732         ModeToken[Index],
 733         EFI_IFR_OPTION_DEFAULT,
 734         EFI_IFR_TYPE_NUM_SIZE_16,
 735         (UINT16) Mode
 736         );
 737     } else {
 738       HiiCreateOneOfOptionOpCode (
 739         OptionsOpCodeHandle,
 740         ModeToken[Index],
 741         0,
 742         EFI_IFR_TYPE_NUM_SIZE_16,
 743         (UINT16) Mode
 744         );
 745     }
 746     Index++;
 747   }
 748
 749   HiiCreateOneOfOpCode (
 750     mStartOpCodeHandle,
 751     (EFI_QUESTION_ID) CON_MODE_QUESTION_ID,
 752     VARSTORE_ID_BOOT_MAINT,
 753     CON_MODE_VAR_OFFSET,
 754     STRING_TOKEN (STR_CON_MODE_SETUP),
 755     STRING_TOKEN (STR_CON_MODE_SETUP),
 756     EFI_IFR_FLAG_RESET_REQUIRED,
 757     EFI_IFR_NUMERIC_SIZE_2,
 758     OptionsOpCodeHandle,
 759     NULL
 760     );
 761
 762   HiiFreeOpCodeHandle (OptionsOpCodeHandle);
 763   FreePool (ModeToken);
 764
 765   UpdatePageEnd (CallbackData);
 766 }
 767
 768  /**
 769   Create the dynamic page which allows user to set the property such as Baud Rate, Data Bits,
 770   Parity, Stop Bits, Terminal Type.
 771
 772   @param CallbackData    The BMM context data.
 773
 774 **/
 775 VOID
 776 UpdateTerminalPage (
 777   IN BMM_CALLBACK_DATA                *CallbackData
 778   )
 779 {
 780   UINT8               Index;
 781   UINT8               CheckFlags;
 782   BM_MENU_ENTRY       *NewMenuEntry;
 783   VOID                *OptionsOpCodeHandle;
 784   UINTN               CurrentTerminal;
 785
 786   CallbackData->BmmAskSaveOrNot = TRUE;
 787
 788   UpdatePageStart (CallbackData);
 789
 790   CurrentTerminal = CallbackData->CurrentTerminal;
 791   NewMenuEntry = BOpt_GetMenuEntry (
 792                   &TerminalMenu,
 793                   CurrentTerminal
 794                   );
 795
 796   if (NewMenuEntry == NULL) {
 797     return ;
 798   }
 799
 800   OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
 801   ASSERT (OptionsOpCodeHandle != NULL);
 802
 803   for (Index = 0; Index < sizeof (BaudRateList) / sizeof (BaudRateList [0]); Index++) {
 804     CheckFlags = 0;
 805     if (BaudRateList[Index].Value == 115200) {
 806       CheckFlags |= EFI_IFR_OPTION_DEFAULT;
 807     }
 808     HiiCreateOneOfOptionOpCode (
 809       OptionsOpCodeHandle,
 810       BaudRateList[Index].StringToken,
 811       CheckFlags,
 812       EFI_IFR_TYPE_NUM_SIZE_8,
 813       Index
 814       );
 815   }
 816
 817   HiiCreateOneOfOpCode (
 818     mStartOpCodeHandle,
 819     (EFI_QUESTION_ID) (COM_BAUD_RATE_QUESTION_ID + CurrentTerminal),
 820     VARSTORE_ID_BOOT_MAINT,
 821     (UINT16) (COM_BAUD_RATE_VAR_OFFSET + CurrentTerminal),
 822     STRING_TOKEN (STR_COM_BAUD_RATE),
 823     STRING_TOKEN (STR_COM_BAUD_RATE),
 824     EFI_IFR_FLAG_CALLBACK,
 825     EFI_IFR_NUMERIC_SIZE_1,
 826     OptionsOpCodeHandle,
 827     NULL
 828     );
 829
 830   HiiFreeOpCodeHandle (OptionsOpCodeHandle);
 831   OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
 832   ASSERT (OptionsOpCodeHandle != NULL);
 833
 834   for (Index = 0; Index < sizeof (DataBitsList) / sizeof (DataBitsList[0]); Index++) {
 835     CheckFlags = 0;
 836
 837     if (DataBitsList[Index].Value == 8) {
 838       CheckFlags |= EFI_IFR_OPTION_DEFAULT;
 839     }
 840
 841     HiiCreateOneOfOptionOpCode (
 842       OptionsOpCodeHandle,
 843       DataBitsList[Index].StringToken,
 844       CheckFlags,
 845       EFI_IFR_TYPE_NUM_SIZE_8,
 846       Index
 847       );
 848   }
 849
 850   HiiCreateOneOfOpCode (
 851     mStartOpCodeHandle,
 852     (EFI_QUESTION_ID) (COM_DATA_RATE_QUESTION_ID + CurrentTerminal),
 853     VARSTORE_ID_BOOT_MAINT,
 854     (UINT16) (COM_DATA_RATE_VAR_OFFSET + CurrentTerminal),
 855     STRING_TOKEN (STR_COM_DATA_BITS),
 856     STRING_TOKEN (STR_COM_DATA_BITS),
 857     EFI_IFR_FLAG_CALLBACK,
 858     EFI_IFR_NUMERIC_SIZE_1,
 859     OptionsOpCodeHandle,
 860     NULL
 861     );
 862
 863   HiiFreeOpCodeHandle (OptionsOpCodeHandle);
 864   OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
 865   ASSERT (OptionsOpCodeHandle != NULL);
 866
 867   for (Index = 0; Index < sizeof (ParityList) / sizeof (ParityList[0]); Index++) {
 868     CheckFlags = 0;
 869     if (ParityList[Index].Value ==  NoParity) {
 870       CheckFlags |= EFI_IFR_OPTION_DEFAULT;
 871     }
 872
 873     HiiCreateOneOfOptionOpCode (
 874       OptionsOpCodeHandle,
 875       ParityList[Index].StringToken,
 876       CheckFlags,
 877       EFI_IFR_TYPE_NUM_SIZE_8,
 878       Index
 879       );
 880   }
 881
 882   HiiCreateOneOfOpCode (
 883     mStartOpCodeHandle,
 884     (EFI_QUESTION_ID) (COM_PARITY_QUESTION_ID + CurrentTerminal),
 885     VARSTORE_ID_BOOT_MAINT,
 886     (UINT16) (COM_PARITY_VAR_OFFSET + CurrentTerminal),
 887     STRING_TOKEN (STR_COM_PARITY),
 888     STRING_TOKEN (STR_COM_PARITY),
 889     EFI_IFR_FLAG_CALLBACK,
 890     EFI_IFR_NUMERIC_SIZE_1,
 891     OptionsOpCodeHandle,
 892     NULL
 893     );
 894
 895   HiiFreeOpCodeHandle (OptionsOpCodeHandle);
 896   OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
 897   ASSERT (OptionsOpCodeHandle != NULL);
 898
 899   for (Index = 0; Index < sizeof (StopBitsList) / sizeof (StopBitsList[0]); Index++) {
 900     CheckFlags = 0;
 901     if (StopBitsList[Index].Value == OneStopBit) {
 902       CheckFlags |= EFI_IFR_OPTION_DEFAULT;
 903     }
 904
 905     HiiCreateOneOfOptionOpCode (
 906       OptionsOpCodeHandle,
 907       StopBitsList[Index].StringToken,
 908       CheckFlags,
 909       EFI_IFR_TYPE_NUM_SIZE_8,
 910       Index
 911       );
 912   }
 913
 914   HiiCreateOneOfOpCode (
 915     mStartOpCodeHandle,
 916     (EFI_QUESTION_ID) (COM_STOP_BITS_QUESTION_ID + CurrentTerminal),
 917     VARSTORE_ID_BOOT_MAINT,
 918     (UINT16) (COM_STOP_BITS_VAR_OFFSET + CurrentTerminal),
 919     STRING_TOKEN (STR_COM_STOP_BITS),
 920     STRING_TOKEN (STR_COM_STOP_BITS),
 921     EFI_IFR_FLAG_CALLBACK,
 922     EFI_IFR_NUMERIC_SIZE_1,
 923     OptionsOpCodeHandle,
 924     NULL
 925     );
 926
 927   HiiFreeOpCodeHandle (OptionsOpCodeHandle);
 928   OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
 929   ASSERT (OptionsOpCodeHandle != NULL);
 930
 931   for (Index = 0; Index < sizeof (TerminalType) / sizeof (TerminalType[0]); Index++) {
 932     CheckFlags = 0;
 933     if (Index == 0) {
 934       CheckFlags |= EFI_IFR_OPTION_DEFAULT;
 935     }
 936
 937     HiiCreateOneOfOptionOpCode (
 938       OptionsOpCodeHandle,
 939       (EFI_STRING_ID) TerminalType[Index],
 940       CheckFlags,
 941       EFI_IFR_TYPE_NUM_SIZE_8,
 942       Index
 943       );
 944   }
 945
 946   HiiCreateOneOfOpCode (
 947     mStartOpCodeHandle,
 948     (EFI_QUESTION_ID) (COM_TERMINAL_QUESTION_ID + CurrentTerminal),
 949     VARSTORE_ID_BOOT_MAINT,
 950     (UINT16) (COM_TERMINAL_VAR_OFFSET + CurrentTerminal),
 951     STRING_TOKEN (STR_COM_TERMI_TYPE),
 952     STRING_TOKEN (STR_COM_TERMI_TYPE),
 953     EFI_IFR_FLAG_CALLBACK,
 954     EFI_IFR_NUMERIC_SIZE_1,
 955     OptionsOpCodeHandle,
 956     NULL
 957     );
 958
 959   HiiFreeOpCodeHandle (OptionsOpCodeHandle);
 960   OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
 961   ASSERT (OptionsOpCodeHandle != NULL);
 962
 963   for (Index = 0; Index < sizeof (mFlowControlType) / sizeof (mFlowControlType[0]); Index++) {
 964   CheckFlags = 0;
 965     if (Index == 0) {
 966       CheckFlags |= EFI_IFR_OPTION_DEFAULT;
 967     }
 968     HiiCreateOneOfOptionOpCode (
 969       OptionsOpCodeHandle,
 970       (EFI_STRING_ID) mFlowControlType[Index],
 971       CheckFlags,
 972       EFI_IFR_TYPE_NUM_SIZE_8,
 973       mFlowControlValue[Index]
 974       );
 975   }
 976
 977   HiiCreateOneOfOpCode (
 978     mStartOpCodeHandle,
 979     (EFI_QUESTION_ID) (COM_FLOWCONTROL_QUESTION_ID + CurrentTerminal),
 980     VARSTORE_ID_BOOT_MAINT,
 981     (UINT16) (COM_FLOWCONTROL_VAR_OFFSET + CurrentTerminal),
 982     STRING_TOKEN (STR_COM_FLOW_CONTROL),
 983     STRING_TOKEN (STR_COM_FLOW_CONTROL),
 984     EFI_IFR_FLAG_CALLBACK,
 985     EFI_IFR_NUMERIC_SIZE_1,
 986     OptionsOpCodeHandle,
 987     NULL
 988     );
 989
 990   HiiFreeOpCodeHandle (OptionsOpCodeHandle);
 991
 992   UpdatePageEnd (CallbackData);
 993 }
 994
 995 /**
 996 Update add boot/driver option page.
 997
 998 @param CallbackData    The BMM context data.
 999 @param FormId             The form ID to be updated.
1000 @param DevicePath       Device path.
1001
1002 **/
1003 VOID
1004 UpdateOptionPage(
1005   IN   BMM_CALLBACK_DATA        *CallbackData,
1006   IN   EFI_FORM_ID              FormId,
1007   IN   EFI_DEVICE_PATH_PROTOCOL *DevicePath
1008   )
1009 {
1010   CHAR16                *String;
1011   EFI_STRING_ID         StringToken;
1012
1013   String = NULL;
1014
1015   if (DevicePath != NULL){
1016     String = ExtractFileNameFromDevicePath(DevicePath);
1017   }
1018   if (String == NULL) {
1019     String = HiiGetString (CallbackData->BmmHiiHandle, STRING_TOKEN (STR_NULL_STRING), NULL);
1020     ASSERT (String != NULL);
1021   }
1022
1023   StringToken = HiiSetString (CallbackData->BmmHiiHandle, 0, String, NULL);
1024   FreePool (String);
1025
1026   if(FormId == FORM_BOOT_ADD_ID){
1027     if (!CallbackData->BmmFakeNvData.BootOptionChanged) {
1028       ZeroMem (CallbackData->BmmFakeNvData.BootOptionalData, sizeof (CallbackData->BmmFakeNvData.BootOptionalData));
1029       ZeroMem (CallbackData->BmmFakeNvData.BootDescriptionData, sizeof (CallbackData->BmmFakeNvData.BootDescriptionData));
1030       ZeroMem (CallbackData->BmmOldFakeNVData.BootOptionalData, sizeof (CallbackData->BmmOldFakeNVData.BootOptionalData));
1031       ZeroMem (CallbackData->BmmOldFakeNVData.BootDescriptionData, sizeof (CallbackData->BmmOldFakeNVData.BootDescriptionData));
1032     }
1033   } else if (FormId == FORM_DRV_ADD_FILE_ID){
1034     if (!CallbackData->BmmFakeNvData.DriverOptionChanged) {
1035       ZeroMem (CallbackData->BmmFakeNvData.DriverOptionalData, sizeof (CallbackData->BmmFakeNvData.DriverOptionalData));
1036       ZeroMem (CallbackData->BmmFakeNvData.DriverDescriptionData, sizeof (CallbackData->BmmFakeNvData.DriverDescriptionData));
1037       ZeroMem (CallbackData->BmmOldFakeNVData.DriverOptionalData, sizeof (CallbackData->BmmOldFakeNVData.DriverOptionalData));
1038       ZeroMem (CallbackData->BmmOldFakeNVData.DriverDescriptionData, sizeof (CallbackData->BmmOldFakeNVData.DriverDescriptionData));
1039     }
1040   }
1041
1042   RefreshUpdateData();
1043   mStartLabel->Number = FormId;
1044
1045   HiiCreateSubTitleOpCode (
1046     mStartOpCodeHandle,
1047     StringToken,
1048     0,
1049     0,
1050     0
1051     );
1052
1053   HiiUpdateForm (
1054     CallbackData->BmmHiiHandle,
1055     &mBootMaintGuid,
1056     FormId,
1057     mStartOpCodeHandle,// Label FormId
1058     mEndOpCodeHandle   // LABEL_END
1059     );
1060 }
1061
1062 /**
1063   Dispatch the correct update page function to call based on
1064   the UpdatePageId.
1065
1066   @param UpdatePageId    The form ID.
1067   @param CallbackData    The BMM context data.
1068
1069 **/
1070 VOID
1071 UpdatePageBody (
1072   IN UINT16                           UpdatePageId,
1073   IN BMM_CALLBACK_DATA                *CallbackData
1074   )
1075 {
1076   CleanUpPage (UpdatePageId, CallbackData);
1077   switch (UpdatePageId) {
1078   case FORM_CON_IN_ID:
1079     UpdateConsolePage (UpdatePageId, &ConsoleInpMenu, CallbackData);
1080     break;
1081
1082   case FORM_CON_OUT_ID:
1083     UpdateConsolePage (UpdatePageId, &ConsoleOutMenu, CallbackData);
1084     break;
1085
1086   case FORM_CON_ERR_ID:
1087     UpdateConsolePage (UpdatePageId, &ConsoleErrMenu, CallbackData);
1088     break;
1089
1090   case FORM_BOOT_CHG_ID:
1091     UpdateOrderPage (UpdatePageId, &BootOptionMenu, CallbackData);
1092     break;
1093
1094   case FORM_DRV_CHG_ID:
1095     UpdateOrderPage (UpdatePageId, &DriverOptionMenu, CallbackData);
1096     break;
1097
1098   default:
1099     break;
1100   }
1101 }
1102
1103 /**
1104   Dispatch the display to the next page based on NewPageId.
1105
1106   @param Private         The BMM context data.
1107   @param NewPageId       The original page ID.
1108
1109 **/
1110 VOID
1111 UpdatePageId (
1112   BMM_CALLBACK_DATA              *Private,
1113   UINT16                         NewPageId
1114   )
1115 {
1116   if ((NewPageId < FILE_OPTION_OFFSET) && (NewPageId >= HANDLE_OPTION_OFFSET)) {
1117     //
1118     // If we select a handle to add driver option, advance to the add handle description page.
1119     //
1120     NewPageId = FORM_DRV_ADD_HANDLE_DESC_ID;
1121   } else if ((NewPageId == KEY_VALUE_SAVE_AND_EXIT) || (NewPageId == KEY_VALUE_NO_SAVE_AND_EXIT)) {
1122     //
1123     // Return to main page after "Save Changes" or "Discard Changes".
1124     //
1125     NewPageId = FORM_MAIN_ID;
1126   } else if ((NewPageId >= TERMINAL_OPTION_OFFSET) && (NewPageId < CONSOLE_OPTION_OFFSET)) {
1127     NewPageId = FORM_CON_COM_SETUP_ID;
1128   }
1129
1130   if ((NewPageId > 0) && (NewPageId < MAXIMUM_FORM_ID)) {
1131     Private->BmmPreviousPageId  = Private->BmmCurrentPageId;
1132     Private->BmmCurrentPageId   = NewPageId;
1133   }
1134 }