MdeModulePkg/Library/BootMaintenanceManagerUiLib/UpdatePage.c

   1 /** @file
   2 Dynamically update the pages.
   3
   4 Copyright (c) 2004 - 2018, 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     //
 589     // If the BootOptionOrder in the BmmFakeNvData are same with the date in the BmmOldFakeNVData,
 590     // means all Boot Options has been save in BootOptionMenu, we can get the date from the menu.
 591     // else means browser maintains some uncommitted date which are not saved in BootOptionMenu,
 592     // so we should not get the data from BootOptionMenu to show it.
 593     //
 594     if (CompareMem (CallbackData->BmmFakeNvData.BootOptionOrder, CallbackData->BmmOldFakeNVData.BootOptionOrder, sizeof (CallbackData->BmmFakeNvData.BootOptionOrder)) == 0) {
 595       GetBootOrder (CallbackData);
 596     }
 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     //
 604     // If the DriverOptionOrder in the BmmFakeNvData are same with the date in the BmmOldFakeNVData,
 605     // means all Driver Options has been save in DriverOptionMenu, we can get the DriverOptionOrder from the menu.
 606     // else means browser maintains some uncommitted date which are not saved in DriverOptionMenu,
 607     // so we should not get the data from DriverOptionMenu to show it.
 608     //
 609     if (CompareMem (CallbackData->BmmFakeNvData.DriverOptionOrder, CallbackData->BmmOldFakeNVData.DriverOptionOrder, sizeof (CallbackData->BmmFakeNvData.DriverOptionOrder)) == 0) {
 610       GetDriverOrder (CallbackData);
 611     }
 612     OptionOrder = CallbackData->BmmFakeNvData.DriverOptionOrder;
 613     QuestionId = DRIVER_OPTION_ORDER_QUESTION_ID;
 614     VarOffset = DRIVER_OPTION_ORDER_VAR_OFFSET;
 615     break;
 616   }
 617   ASSERT (OptionOrder != NULL);
 618
 619   OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
 620   ASSERT (OptionsOpCodeHandle != NULL);
 621
 622   NewMenuEntry = NULL;
 623   for (OptionIndex = 0; (OptionOrder[OptionIndex] != 0 && OptionIndex < MAX_MENU_NUMBER); OptionIndex++) {
 624     BootOptionFound = FALSE;
 625     for (Index = 0; Index < OptionMenu->MenuNumber; Index++) {
 626       NewMenuEntry   = BOpt_GetMenuEntry (OptionMenu, Index);
 627       if ((UINT32) (NewMenuEntry->OptionNumber + 1) == OptionOrder[OptionIndex]) {
 628         BootOptionFound = TRUE;
 629         break;
 630       }
 631     }
 632     if (BootOptionFound) {
 633       HiiCreateOneOfOptionOpCode (
 634         OptionsOpCodeHandle,
 635         NewMenuEntry->DisplayStringToken,
 636         0,
 637         EFI_IFR_TYPE_NUM_SIZE_32,
 638         OptionOrder[OptionIndex]
 639         );
 640     }
 641   }
 642
 643   if (OptionMenu->MenuNumber > 0) {
 644     HiiCreateOrderedListOpCode (
 645       mStartOpCodeHandle,                          // Container for dynamic created opcodes
 646       QuestionId,                                  // Question ID
 647       VARSTORE_ID_BOOT_MAINT,                      // VarStore ID
 648       VarOffset,                                   // Offset in Buffer Storage
 649       STRING_TOKEN (STR_CHANGE_ORDER),             // Question prompt text
 650       STRING_TOKEN (STR_CHANGE_ORDER),             // Question help text
 651       0,                                           // Question flag
 652       0,                                           // Ordered list flag, e.g. EFI_IFR_UNIQUE_SET
 653       EFI_IFR_TYPE_NUM_SIZE_32,                    // Data type of Question value
 654       100,                                         // Maximum container
 655       OptionsOpCodeHandle,                         // Option Opcode list
 656       NULL                                         // Default Opcode is NULL
 657       );
 658   }
 659
 660   HiiFreeOpCodeHandle (OptionsOpCodeHandle);
 661
 662   UpdatePageEnd (CallbackData);
 663
 664 }
 665
 666 /**
 667   Refresh the text mode page.
 668
 669   @param CallbackData    The BMM context data.
 670
 671 **/
 672 VOID
 673 UpdateConModePage (
 674   IN BMM_CALLBACK_DATA                *CallbackData
 675   )
 676 {
 677   UINTN                         Mode;
 678   UINTN                         Index;
 679   UINTN                         Col;
 680   UINTN                         Row;
 681   CHAR16                        ModeString[50];
 682   CHAR16                        *PStr;
 683   UINTN                         MaxMode;
 684   UINTN                         ValidMode;
 685   EFI_STRING_ID                 *ModeToken;
 686   EFI_STATUS                    Status;
 687   VOID                          *OptionsOpCodeHandle;
 688   EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL  *ConOut;
 689
 690   ConOut    = gST->ConOut;
 691   Index     = 0;
 692   ValidMode = 0;
 693   MaxMode   = (UINTN) (ConOut->Mode->MaxMode);
 694
 695   CallbackData->BmmAskSaveOrNot = TRUE;
 696
 697   UpdatePageStart (CallbackData);
 698
 699   //
 700   // Check valid mode
 701   //
 702   for (Mode = 0; Mode < MaxMode; Mode++) {
 703     Status = ConOut->QueryMode (ConOut, Mode, &Col, &Row);
 704     if (EFI_ERROR (Status)) {
 705       continue;
 706     }
 707     ValidMode++;
 708   }
 709
 710   if (ValidMode == 0) {
 711     return;
 712   }
 713
 714   OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
 715   ASSERT (OptionsOpCodeHandle != NULL);
 716
 717   ModeToken           = AllocateZeroPool (sizeof (EFI_STRING_ID) * ValidMode);
 718   ASSERT(ModeToken != NULL);
 719
 720   //
 721   // Determin which mode should be the first entry in menu
 722   //
 723   GetConsoleOutMode (CallbackData);
 724
 725   //
 726   // Build text mode options
 727   //
 728   for (Mode = 0; Mode < MaxMode; Mode++) {
 729     Status = ConOut->QueryMode (ConOut, Mode, &Col, &Row);
 730     if (EFI_ERROR (Status)) {
 731       continue;
 732     }
 733
 734     //
 735     // Build mode string Column x Row
 736     //
 737     UnicodeValueToStringS (ModeString, sizeof (ModeString), 0, Col, 0);
 738     PStr = &ModeString[0];
 739     StrnCatS (PStr, ARRAY_SIZE (ModeString), L" x ", StrLen(L" x ") + 1);
 740     PStr = PStr + StrLen (PStr);
 741     UnicodeValueToStringS (
 742       PStr,
 743       sizeof (ModeString) - ((UINTN)PStr - (UINTN)&ModeString[0]),
 744       0,
 745       Row,
 746       0
 747       );
 748
 749     ModeToken[Index] = HiiSetString (CallbackData->BmmHiiHandle, 0, ModeString, NULL);
 750
 751     if (Mode == CallbackData->BmmFakeNvData.ConsoleOutMode) {
 752       HiiCreateOneOfOptionOpCode (
 753         OptionsOpCodeHandle,
 754         ModeToken[Index],
 755         EFI_IFR_OPTION_DEFAULT,
 756         EFI_IFR_TYPE_NUM_SIZE_16,
 757         (UINT16) Mode
 758         );
 759     } else {
 760       HiiCreateOneOfOptionOpCode (
 761         OptionsOpCodeHandle,
 762         ModeToken[Index],
 763         0,
 764         EFI_IFR_TYPE_NUM_SIZE_16,
 765         (UINT16) Mode
 766         );
 767     }
 768     Index++;
 769   }
 770
 771   HiiCreateOneOfOpCode (
 772     mStartOpCodeHandle,
 773     (EFI_QUESTION_ID) CON_MODE_QUESTION_ID,
 774     VARSTORE_ID_BOOT_MAINT,
 775     CON_MODE_VAR_OFFSET,
 776     STRING_TOKEN (STR_CON_MODE_SETUP),
 777     STRING_TOKEN (STR_CON_MODE_SETUP),
 778     EFI_IFR_FLAG_RESET_REQUIRED,
 779     EFI_IFR_NUMERIC_SIZE_2,
 780     OptionsOpCodeHandle,
 781     NULL
 782     );
 783
 784   HiiFreeOpCodeHandle (OptionsOpCodeHandle);
 785   FreePool (ModeToken);
 786
 787   UpdatePageEnd (CallbackData);
 788 }
 789
 790  /**
 791   Create the dynamic page which allows user to set the property such as Baud Rate, Data Bits,
 792   Parity, Stop Bits, Terminal Type.
 793
 794   @param CallbackData    The BMM context data.
 795
 796 **/
 797 VOID
 798 UpdateTerminalPage (
 799   IN BMM_CALLBACK_DATA                *CallbackData
 800   )
 801 {
 802   UINT8               Index;
 803   UINT8               CheckFlags;
 804   BM_MENU_ENTRY       *NewMenuEntry;
 805   VOID                *OptionsOpCodeHandle;
 806   UINTN               CurrentTerminal;
 807
 808   CallbackData->BmmAskSaveOrNot = TRUE;
 809
 810   UpdatePageStart (CallbackData);
 811
 812   CurrentTerminal = CallbackData->CurrentTerminal;
 813   NewMenuEntry = BOpt_GetMenuEntry (
 814                   &TerminalMenu,
 815                   CurrentTerminal
 816                   );
 817
 818   if (NewMenuEntry == NULL) {
 819     return ;
 820   }
 821
 822   OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
 823   ASSERT (OptionsOpCodeHandle != NULL);
 824
 825   for (Index = 0; Index < sizeof (BaudRateList) / sizeof (BaudRateList [0]); Index++) {
 826     CheckFlags = 0;
 827     if (BaudRateList[Index].Value == 115200) {
 828       CheckFlags |= EFI_IFR_OPTION_DEFAULT;
 829     }
 830     HiiCreateOneOfOptionOpCode (
 831       OptionsOpCodeHandle,
 832       BaudRateList[Index].StringToken,
 833       CheckFlags,
 834       EFI_IFR_TYPE_NUM_SIZE_8,
 835       Index
 836       );
 837   }
 838
 839   HiiCreateOneOfOpCode (
 840     mStartOpCodeHandle,
 841     (EFI_QUESTION_ID) (COM_BAUD_RATE_QUESTION_ID + CurrentTerminal),
 842     VARSTORE_ID_BOOT_MAINT,
 843     (UINT16) (COM_BAUD_RATE_VAR_OFFSET + CurrentTerminal),
 844     STRING_TOKEN (STR_COM_BAUD_RATE),
 845     STRING_TOKEN (STR_COM_BAUD_RATE),
 846     EFI_IFR_FLAG_CALLBACK,
 847     EFI_IFR_NUMERIC_SIZE_1,
 848     OptionsOpCodeHandle,
 849     NULL
 850     );
 851
 852   HiiFreeOpCodeHandle (OptionsOpCodeHandle);
 853   OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
 854   ASSERT (OptionsOpCodeHandle != NULL);
 855
 856   for (Index = 0; Index < ARRAY_SIZE (DataBitsList); Index++) {
 857     CheckFlags = 0;
 858
 859     if (DataBitsList[Index].Value == 8) {
 860       CheckFlags |= EFI_IFR_OPTION_DEFAULT;
 861     }
 862
 863     HiiCreateOneOfOptionOpCode (
 864       OptionsOpCodeHandle,
 865       DataBitsList[Index].StringToken,
 866       CheckFlags,
 867       EFI_IFR_TYPE_NUM_SIZE_8,
 868       Index
 869       );
 870   }
 871
 872   HiiCreateOneOfOpCode (
 873     mStartOpCodeHandle,
 874     (EFI_QUESTION_ID) (COM_DATA_RATE_QUESTION_ID + CurrentTerminal),
 875     VARSTORE_ID_BOOT_MAINT,
 876     (UINT16) (COM_DATA_RATE_VAR_OFFSET + CurrentTerminal),
 877     STRING_TOKEN (STR_COM_DATA_BITS),
 878     STRING_TOKEN (STR_COM_DATA_BITS),
 879     EFI_IFR_FLAG_CALLBACK,
 880     EFI_IFR_NUMERIC_SIZE_1,
 881     OptionsOpCodeHandle,
 882     NULL
 883     );
 884
 885   HiiFreeOpCodeHandle (OptionsOpCodeHandle);
 886   OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
 887   ASSERT (OptionsOpCodeHandle != NULL);
 888
 889   for (Index = 0; Index < ARRAY_SIZE (ParityList); Index++) {
 890     CheckFlags = 0;
 891     if (ParityList[Index].Value ==  NoParity) {
 892       CheckFlags |= EFI_IFR_OPTION_DEFAULT;
 893     }
 894
 895     HiiCreateOneOfOptionOpCode (
 896       OptionsOpCodeHandle,
 897       ParityList[Index].StringToken,
 898       CheckFlags,
 899       EFI_IFR_TYPE_NUM_SIZE_8,
 900       Index
 901       );
 902   }
 903
 904   HiiCreateOneOfOpCode (
 905     mStartOpCodeHandle,
 906     (EFI_QUESTION_ID) (COM_PARITY_QUESTION_ID + CurrentTerminal),
 907     VARSTORE_ID_BOOT_MAINT,
 908     (UINT16) (COM_PARITY_VAR_OFFSET + CurrentTerminal),
 909     STRING_TOKEN (STR_COM_PARITY),
 910     STRING_TOKEN (STR_COM_PARITY),
 911     EFI_IFR_FLAG_CALLBACK,
 912     EFI_IFR_NUMERIC_SIZE_1,
 913     OptionsOpCodeHandle,
 914     NULL
 915     );
 916
 917   HiiFreeOpCodeHandle (OptionsOpCodeHandle);
 918   OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
 919   ASSERT (OptionsOpCodeHandle != NULL);
 920
 921   for (Index = 0; Index < ARRAY_SIZE (StopBitsList); Index++) {
 922     CheckFlags = 0;
 923     if (StopBitsList[Index].Value == OneStopBit) {
 924       CheckFlags |= EFI_IFR_OPTION_DEFAULT;
 925     }
 926
 927     HiiCreateOneOfOptionOpCode (
 928       OptionsOpCodeHandle,
 929       StopBitsList[Index].StringToken,
 930       CheckFlags,
 931       EFI_IFR_TYPE_NUM_SIZE_8,
 932       Index
 933       );
 934   }
 935
 936   HiiCreateOneOfOpCode (
 937     mStartOpCodeHandle,
 938     (EFI_QUESTION_ID) (COM_STOP_BITS_QUESTION_ID + CurrentTerminal),
 939     VARSTORE_ID_BOOT_MAINT,
 940     (UINT16) (COM_STOP_BITS_VAR_OFFSET + CurrentTerminal),
 941     STRING_TOKEN (STR_COM_STOP_BITS),
 942     STRING_TOKEN (STR_COM_STOP_BITS),
 943     EFI_IFR_FLAG_CALLBACK,
 944     EFI_IFR_NUMERIC_SIZE_1,
 945     OptionsOpCodeHandle,
 946     NULL
 947     );
 948
 949   HiiFreeOpCodeHandle (OptionsOpCodeHandle);
 950   OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
 951   ASSERT (OptionsOpCodeHandle != NULL);
 952
 953   for (Index = 0; Index < ARRAY_SIZE (TerminalType); Index++) {
 954     CheckFlags = 0;
 955     if (Index == 0) {
 956       CheckFlags |= EFI_IFR_OPTION_DEFAULT;
 957     }
 958
 959     HiiCreateOneOfOptionOpCode (
 960       OptionsOpCodeHandle,
 961       (EFI_STRING_ID) TerminalType[Index],
 962       CheckFlags,
 963       EFI_IFR_TYPE_NUM_SIZE_8,
 964       Index
 965       );
 966   }
 967
 968   HiiCreateOneOfOpCode (
 969     mStartOpCodeHandle,
 970     (EFI_QUESTION_ID) (COM_TERMINAL_QUESTION_ID + CurrentTerminal),
 971     VARSTORE_ID_BOOT_MAINT,
 972     (UINT16) (COM_TERMINAL_VAR_OFFSET + CurrentTerminal),
 973     STRING_TOKEN (STR_COM_TERMI_TYPE),
 974     STRING_TOKEN (STR_COM_TERMI_TYPE),
 975     EFI_IFR_FLAG_CALLBACK,
 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 < ARRAY_SIZE (mFlowControlType); Index++) {
 986   CheckFlags = 0;
 987     if (Index == 0) {
 988       CheckFlags |= EFI_IFR_OPTION_DEFAULT;
 989     }
 990     HiiCreateOneOfOptionOpCode (
 991       OptionsOpCodeHandle,
 992       (EFI_STRING_ID) mFlowControlType[Index],
 993       CheckFlags,
 994       EFI_IFR_TYPE_NUM_SIZE_8,
 995       mFlowControlValue[Index]
 996       );
 997   }
 998
 999   HiiCreateOneOfOpCode (
1000     mStartOpCodeHandle,
1001     (EFI_QUESTION_ID) (COM_FLOWCONTROL_QUESTION_ID + CurrentTerminal),
1002     VARSTORE_ID_BOOT_MAINT,
1003     (UINT16) (COM_FLOWCONTROL_VAR_OFFSET + CurrentTerminal),
1004     STRING_TOKEN (STR_COM_FLOW_CONTROL),
1005     STRING_TOKEN (STR_COM_FLOW_CONTROL),
1006     EFI_IFR_FLAG_CALLBACK,
1007     EFI_IFR_NUMERIC_SIZE_1,
1008     OptionsOpCodeHandle,
1009     NULL
1010     );
1011
1012   HiiFreeOpCodeHandle (OptionsOpCodeHandle);
1013
1014   UpdatePageEnd (CallbackData);
1015 }
1016
1017 /**
1018 Update add boot/driver option page.
1019
1020 @param CallbackData    The BMM context data.
1021 @param FormId             The form ID to be updated.
1022 @param DevicePath       Device path.
1023
1024 **/
1025 VOID
1026 UpdateOptionPage(
1027   IN   BMM_CALLBACK_DATA        *CallbackData,
1028   IN   EFI_FORM_ID              FormId,
1029   IN   EFI_DEVICE_PATH_PROTOCOL *DevicePath
1030   )
1031 {
1032   CHAR16                *String;
1033   EFI_STRING_ID         StringToken;
1034
1035   String = NULL;
1036
1037   if (DevicePath != NULL){
1038     String = ExtractFileNameFromDevicePath(DevicePath);
1039   }
1040   if (String == NULL) {
1041     String = HiiGetString (CallbackData->BmmHiiHandle, STRING_TOKEN (STR_NULL_STRING), NULL);
1042     ASSERT (String != NULL);
1043   }
1044
1045   StringToken = HiiSetString (CallbackData->BmmHiiHandle, 0, String, NULL);
1046   FreePool (String);
1047
1048   if(FormId == FORM_BOOT_ADD_ID){
1049     if (!CallbackData->BmmFakeNvData.BootOptionChanged) {
1050       ZeroMem (CallbackData->BmmFakeNvData.BootOptionalData, sizeof (CallbackData->BmmFakeNvData.BootOptionalData));
1051       ZeroMem (CallbackData->BmmFakeNvData.BootDescriptionData, sizeof (CallbackData->BmmFakeNvData.BootDescriptionData));
1052       ZeroMem (CallbackData->BmmOldFakeNVData.BootOptionalData, sizeof (CallbackData->BmmOldFakeNVData.BootOptionalData));
1053       ZeroMem (CallbackData->BmmOldFakeNVData.BootDescriptionData, sizeof (CallbackData->BmmOldFakeNVData.BootDescriptionData));
1054     }
1055   } else if (FormId == FORM_DRV_ADD_FILE_ID){
1056     if (!CallbackData->BmmFakeNvData.DriverOptionChanged) {
1057       ZeroMem (CallbackData->BmmFakeNvData.DriverOptionalData, sizeof (CallbackData->BmmFakeNvData.DriverOptionalData));
1058       ZeroMem (CallbackData->BmmFakeNvData.DriverDescriptionData, sizeof (CallbackData->BmmFakeNvData.DriverDescriptionData));
1059       ZeroMem (CallbackData->BmmOldFakeNVData.DriverOptionalData, sizeof (CallbackData->BmmOldFakeNVData.DriverOptionalData));
1060       ZeroMem (CallbackData->BmmOldFakeNVData.DriverDescriptionData, sizeof (CallbackData->BmmOldFakeNVData.DriverDescriptionData));
1061     }
1062   }
1063
1064   RefreshUpdateData();
1065   mStartLabel->Number = FormId;
1066
1067   HiiCreateSubTitleOpCode (
1068     mStartOpCodeHandle,
1069     StringToken,
1070     0,
1071     0,
1072     0
1073     );
1074
1075   HiiUpdateForm (
1076     CallbackData->BmmHiiHandle,
1077     &mBootMaintGuid,
1078     FormId,
1079     mStartOpCodeHandle,// Label FormId
1080     mEndOpCodeHandle   // LABEL_END
1081     );
1082 }
1083
1084 /**
1085   Dispatch the correct update page function to call based on
1086   the UpdatePageId.
1087
1088   @param UpdatePageId    The form ID.
1089   @param CallbackData    The BMM context data.
1090
1091 **/
1092 VOID
1093 UpdatePageBody (
1094   IN UINT16                           UpdatePageId,
1095   IN BMM_CALLBACK_DATA                *CallbackData
1096   )
1097 {
1098   CleanUpPage (UpdatePageId, CallbackData);
1099   switch (UpdatePageId) {
1100   case FORM_CON_IN_ID:
1101     UpdateConsolePage (UpdatePageId, &ConsoleInpMenu, CallbackData);
1102     break;
1103
1104   case FORM_CON_OUT_ID:
1105     UpdateConsolePage (UpdatePageId, &ConsoleOutMenu, CallbackData);
1106     break;
1107
1108   case FORM_CON_ERR_ID:
1109     UpdateConsolePage (UpdatePageId, &ConsoleErrMenu, CallbackData);
1110     break;
1111
1112   case FORM_BOOT_CHG_ID:
1113     UpdateOrderPage (UpdatePageId, &BootOptionMenu, CallbackData);
1114     break;
1115
1116   case FORM_DRV_CHG_ID:
1117     UpdateOrderPage (UpdatePageId, &DriverOptionMenu, CallbackData);
1118     break;
1119
1120   default:
1121     break;
1122   }
1123 }
1124
1125 /**
1126   Dispatch the display to the next page based on NewPageId.
1127
1128   @param Private         The BMM context data.
1129   @param NewPageId       The original page ID.
1130
1131 **/
1132 VOID
1133 UpdatePageId (
1134   BMM_CALLBACK_DATA              *Private,
1135   UINT16                         NewPageId
1136   )
1137 {
1138   if ((NewPageId < FILE_OPTION_OFFSET) && (NewPageId >= HANDLE_OPTION_OFFSET)) {
1139     //
1140     // If we select a handle to add driver option, advance to the add handle description page.
1141     //
1142     NewPageId = FORM_DRV_ADD_HANDLE_DESC_ID;
1143   } else if ((NewPageId == KEY_VALUE_SAVE_AND_EXIT) || (NewPageId == KEY_VALUE_NO_SAVE_AND_EXIT)) {
1144     //
1145     // Return to main page after "Save Changes" or "Discard Changes".
1146     //
1147     NewPageId = FORM_MAIN_ID;
1148   } else if ((NewPageId >= TERMINAL_OPTION_OFFSET) && (NewPageId < CONSOLE_OPTION_OFFSET)) {
1149     NewPageId = FORM_CON_COM_SETUP_ID;
1150   }
1151
1152   if ((NewPageId > 0) && (NewPageId < MAXIMUM_FORM_ID)) {
1153     Private->BmmPreviousPageId  = Private->BmmCurrentPageId;
1154     Private->BmmCurrentPageId   = NewPageId;
1155   }
1156 }