MdeModulePkg/Library/BootMaintenanceManagerUiLib/Variable.c

   1 /** @file
   2 Variable operation that will be used by bootmaint
   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   Delete Boot Option that represent a Deleted state in BootOptionMenu.
  19   After deleting this boot option, call Var_ChangeBootOrder to
  20   make sure BootOrder is in valid state.
  21
  22   @retval EFI_SUCCESS   If all boot load option EFI Variables corresponding to
  23                         BM_LOAD_CONTEXT marked for deletion is deleted.
  24   @retval EFI_NOT_FOUND If can not find the boot option want to be deleted.
  25   @return Others        If failed to update the "BootOrder" variable after deletion.
  26
  27 **/
  28 EFI_STATUS
  29 Var_DelBootOption (
  30   VOID
  31   )
  32 {
  33   BM_MENU_ENTRY   *NewMenuEntry;
  34   BM_LOAD_CONTEXT *NewLoadContext;
  35   UINT16          BootString[10];
  36   EFI_STATUS      Status;
  37   UINTN           Index;
  38   UINTN           Index2;
  39
  40   Status  = EFI_SUCCESS;
  41   Index2  = 0;
  42   for (Index = 0; Index < BootOptionMenu.MenuNumber; Index++) {
  43     NewMenuEntry = BOpt_GetMenuEntry (&BootOptionMenu, (Index - Index2));
  44     if (NULL == NewMenuEntry) {
  45       return EFI_NOT_FOUND;
  46     }
  47
  48     NewLoadContext = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
  49     if (!NewLoadContext->Deleted) {
  50       continue;
  51     }
  52
  53     UnicodeSPrint (
  54       BootString,
  55       sizeof (BootString),
  56       L"Boot%04x",
  57       NewMenuEntry->OptionNumber
  58       );
  59
  60     EfiLibDeleteVariable (BootString, &gEfiGlobalVariableGuid);
  61     Index2++;
  62     //
  63     // If current Load Option is the same as BootNext,
  64     // must delete BootNext in order to make sure
  65     // there will be no panic on next boot
  66     //
  67     if (NewLoadContext->IsBootNext) {
  68       EfiLibDeleteVariable (L"BootNext", &gEfiGlobalVariableGuid);
  69     }
  70
  71     RemoveEntryList (&NewMenuEntry->Link);
  72     BOpt_DestroyMenuEntry (NewMenuEntry);
  73     NewMenuEntry = NULL;
  74   }
  75
  76   BootOptionMenu.MenuNumber -= Index2;
  77
  78   Status = Var_ChangeBootOrder ();
  79   return Status;
  80 }
  81
  82 /**
  83   After any operation on Boot####, there will be a discrepancy in BootOrder.
  84   Since some are missing but in BootOrder, while some are present but are
  85   not reflected by BootOrder. Then a function rebuild BootOrder from
  86   scratch by content from BootOptionMenu is needed.
  87
  88
  89
  90
  91   @retval  EFI_SUCCESS  The boot order is updated successfully.
  92   @return               EFI_STATUS other than EFI_SUCCESS if failed to
  93                         Set the "BootOrder" EFI Variable.
  94
  95 **/
  96 EFI_STATUS
  97 Var_ChangeBootOrder (
  98   VOID
  99   )
 100 {
 101
 102   EFI_STATUS    Status;
 103   BM_MENU_ENTRY *NewMenuEntry;
 104   UINT16        *BootOrderList;
 105   UINT16        *BootOrderListPtr;
 106   UINTN         BootOrderListSize;
 107   UINTN         Index;
 108
 109   BootOrderList     = NULL;
 110   BootOrderListSize = 0;
 111   //
 112   // First check whether BootOrder is present in current configuration
 113   //
 114   GetEfiGlobalVariable2 (L"BootOrder", (VOID **) &BootOrderList, &BootOrderListSize);
 115
 116   //
 117   // If exists, delete it to hold new BootOrder
 118   //
 119   if (BootOrderList != NULL) {
 120     EfiLibDeleteVariable (L"BootOrder", &gEfiGlobalVariableGuid);
 121     FreePool (BootOrderList);
 122     BootOrderList = NULL;
 123   }
 124   //
 125   // Maybe here should be some check method to ensure that
 126   // no new added boot options will be added
 127   // but the setup engine now will give only one callback
 128   // that is to say, user are granted only one chance to
 129   // decide whether the boot option will be added or not
 130   // there should be no indictor to show whether this
 131   // is a "new" boot option
 132   //
 133   BootOrderListSize = BootOptionMenu.MenuNumber;
 134
 135   if (BootOrderListSize > 0) {
 136     BootOrderList = AllocateZeroPool (BootOrderListSize * sizeof (UINT16));
 137     ASSERT (BootOrderList != NULL);
 138     BootOrderListPtr = BootOrderList;
 139
 140     //
 141     // Get all current used Boot#### from BootOptionMenu.
 142     // OptionNumber in each BM_LOAD_OPTION is really its
 143     // #### value.
 144     //
 145     for (Index = 0; Index < BootOrderListSize; Index++) {
 146       NewMenuEntry    = BOpt_GetMenuEntry (&BootOptionMenu, Index);
 147       *BootOrderList  = (UINT16) NewMenuEntry->OptionNumber;
 148       BootOrderList++;
 149     }
 150
 151     BootOrderList = BootOrderListPtr;
 152
 153     //
 154     // After building the BootOrderList, write it back
 155     //
 156     Status = gRT->SetVariable (
 157                     L"BootOrder",
 158                     &gEfiGlobalVariableGuid,
 159                     VAR_FLAG,
 160                     BootOrderListSize * sizeof (UINT16),
 161                     BootOrderList
 162                     );
 163     if (EFI_ERROR (Status)) {
 164       return Status;
 165     }
 166   }
 167   return EFI_SUCCESS;
 168 }
 169
 170 /**
 171   Delete Load Option that represent a Deleted state in BootOptionMenu.
 172   After deleting this Driver option, call Var_ChangeDriverOrder to
 173   make sure DriverOrder is in valid state.
 174
 175   @retval EFI_SUCCESS       Load Option is successfully updated.
 176   @retval EFI_NOT_FOUND     Fail to find the driver option want to be deleted.
 177   @return Other value than EFI_SUCCESS if failed to update "Driver Order" EFI
 178           Variable.
 179
 180 **/
 181 EFI_STATUS
 182 Var_DelDriverOption (
 183   VOID
 184   )
 185 {
 186   BM_MENU_ENTRY   *NewMenuEntry;
 187   BM_LOAD_CONTEXT *NewLoadContext;
 188   UINT16          DriverString[12];
 189   EFI_STATUS      Status;
 190   UINTN           Index;
 191   UINTN           Index2;
 192
 193   Status  = EFI_SUCCESS;
 194   Index2  = 0;
 195   for (Index = 0; Index < DriverOptionMenu.MenuNumber; Index++) {
 196     NewMenuEntry = BOpt_GetMenuEntry (&DriverOptionMenu, (Index - Index2));
 197     if (NULL == NewMenuEntry) {
 198       return EFI_NOT_FOUND;
 199     }
 200
 201     NewLoadContext = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
 202     if (!NewLoadContext->Deleted) {
 203       continue;
 204     }
 205
 206     UnicodeSPrint (
 207       DriverString,
 208       sizeof (DriverString),
 209       L"Driver%04x",
 210       NewMenuEntry->OptionNumber
 211       );
 212
 213     EfiLibDeleteVariable (DriverString, &gEfiGlobalVariableGuid);
 214     Index2++;
 215
 216     RemoveEntryList (&NewMenuEntry->Link);
 217     BOpt_DestroyMenuEntry (NewMenuEntry);
 218     NewMenuEntry = NULL;
 219   }
 220
 221   DriverOptionMenu.MenuNumber -= Index2;
 222
 223   Status = Var_ChangeDriverOrder ();
 224   return Status;
 225 }
 226
 227 /**
 228   After any operation on Driver####, there will be a discrepancy in
 229   DriverOrder. Since some are missing but in DriverOrder, while some
 230   are present but are not reflected by DriverOrder. Then a function
 231   rebuild DriverOrder from scratch by content from DriverOptionMenu is
 232   needed.
 233
 234   @retval  EFI_SUCCESS  The driver order is updated successfully.
 235   @return  Other status than EFI_SUCCESS if failed to set the "DriverOrder" EFI Variable.
 236
 237 **/
 238 EFI_STATUS
 239 Var_ChangeDriverOrder (
 240   VOID
 241   )
 242 {
 243   EFI_STATUS    Status;
 244   BM_MENU_ENTRY *NewMenuEntry;
 245   UINT16        *DriverOrderList;
 246   UINT16        *DriverOrderListPtr;
 247   UINTN         DriverOrderListSize;
 248   UINTN         Index;
 249
 250   DriverOrderList     = NULL;
 251   DriverOrderListSize = 0;
 252
 253   //
 254   // First check whether DriverOrder is present in current configuration
 255   //
 256   GetEfiGlobalVariable2 (L"DriverOrder", (VOID **) &DriverOrderList, &DriverOrderListSize);
 257   //
 258   // If exists, delete it to hold new DriverOrder
 259   //
 260   if (DriverOrderList != NULL) {
 261     EfiLibDeleteVariable (L"DriverOrder", &gEfiGlobalVariableGuid);
 262     FreePool (DriverOrderList);
 263     DriverOrderList = NULL;
 264   }
 265
 266   DriverOrderListSize = DriverOptionMenu.MenuNumber;
 267
 268   if (DriverOrderListSize > 0) {
 269     DriverOrderList = AllocateZeroPool (DriverOrderListSize * sizeof (UINT16));
 270     ASSERT (DriverOrderList != NULL);
 271     DriverOrderListPtr = DriverOrderList;
 272
 273     //
 274     // Get all current used Driver#### from DriverOptionMenu.
 275     // OptionNumber in each BM_LOAD_OPTION is really its
 276     // #### value.
 277     //
 278     for (Index = 0; Index < DriverOrderListSize; Index++) {
 279       NewMenuEntry      = BOpt_GetMenuEntry (&DriverOptionMenu, Index);
 280       *DriverOrderList  = (UINT16) NewMenuEntry->OptionNumber;
 281       DriverOrderList++;
 282     }
 283
 284     DriverOrderList = DriverOrderListPtr;
 285
 286     //
 287     // After building the DriverOrderList, write it back
 288     //
 289     Status = gRT->SetVariable (
 290                     L"DriverOrder",
 291                     &gEfiGlobalVariableGuid,
 292                     VAR_FLAG,
 293                     DriverOrderListSize * sizeof (UINT16),
 294                     DriverOrderList
 295                     );
 296     if (EFI_ERROR (Status)) {
 297       return Status;
 298     }
 299   }
 300   return EFI_SUCCESS;
 301 }
 302
 303 /**
 304   Update the device path of "ConOut", "ConIn" and "ErrOut"
 305   based on the new BaudRate, Data Bits, parity and Stop Bits
 306   set.
 307
 308 **/
 309 VOID
 310 Var_UpdateAllConsoleOption (
 311   VOID
 312   )
 313 {
 314   EFI_DEVICE_PATH_PROTOCOL  *OutDevicePath;
 315   EFI_DEVICE_PATH_PROTOCOL  *InpDevicePath;
 316   EFI_DEVICE_PATH_PROTOCOL  *ErrDevicePath;
 317   EFI_STATUS                Status;
 318
 319   GetEfiGlobalVariable2 (L"ConOut", (VOID**)&OutDevicePath, NULL);
 320   GetEfiGlobalVariable2 (L"ConIn", (VOID**)&InpDevicePath, NULL);
 321   GetEfiGlobalVariable2 (L"ErrOut", (VOID**)&ErrDevicePath, NULL);
 322   if (OutDevicePath != NULL) {
 323     ChangeVariableDevicePath (OutDevicePath);
 324     Status = gRT->SetVariable (
 325                     L"ConOut",
 326                     &gEfiGlobalVariableGuid,
 327                     VAR_FLAG,
 328                     GetDevicePathSize (OutDevicePath),
 329                     OutDevicePath
 330                     );
 331     ASSERT (!EFI_ERROR (Status));
 332   }
 333
 334   if (InpDevicePath != NULL) {
 335     ChangeVariableDevicePath (InpDevicePath);
 336     Status = gRT->SetVariable (
 337                     L"ConIn",
 338                     &gEfiGlobalVariableGuid,
 339                     VAR_FLAG,
 340                     GetDevicePathSize (InpDevicePath),
 341                     InpDevicePath
 342                     );
 343     ASSERT (!EFI_ERROR (Status));
 344   }
 345
 346   if (ErrDevicePath != NULL) {
 347     ChangeVariableDevicePath (ErrDevicePath);
 348     Status = gRT->SetVariable (
 349                     L"ErrOut",
 350                     &gEfiGlobalVariableGuid,
 351                     VAR_FLAG,
 352                     GetDevicePathSize (ErrDevicePath),
 353                     ErrDevicePath
 354                     );
 355     ASSERT (!EFI_ERROR (Status));
 356   }
 357 }
 358
 359 /**
 360   This function delete and build multi-instance device path for
 361   specified type of console device.
 362
 363   This function clear the EFI variable defined by ConsoleName and
 364   gEfiGlobalVariableGuid. It then build the multi-instance device
 365   path by appending the device path of the Console (In/Out/Err) instance
 366   in ConsoleMenu. Then it scan all corresponding console device by
 367   scanning Terminal (built from device supporting Serial I/O instances)
 368   devices in TerminalMenu. At last, it save a EFI variable specifed
 369   by ConsoleName and gEfiGlobalVariableGuid.
 370
 371   @param ConsoleName     The name for the console device type. They are
 372                          usually "ConIn", "ConOut" and "ErrOut".
 373   @param ConsoleMenu     The console memu which is a list of console devices.
 374   @param UpdatePageId    The flag specifying which type of console device
 375                          to be processed.
 376
 377   @retval EFI_SUCCESS    The function complete successfully.
 378   @return The EFI variable can not be saved. See gRT->SetVariable for detail return information.
 379
 380 **/
 381 EFI_STATUS
 382 Var_UpdateConsoleOption (
 383   IN UINT16                     *ConsoleName,
 384   IN BM_MENU_OPTION             *ConsoleMenu,
 385   IN UINT16                     UpdatePageId
 386   )
 387 {
 388   EFI_DEVICE_PATH_PROTOCOL  *ConDevicePath;
 389   BM_MENU_ENTRY             *NewMenuEntry;
 390   BM_CONSOLE_CONTEXT        *NewConsoleContext;
 391   BM_TERMINAL_CONTEXT       *NewTerminalContext;
 392   EFI_STATUS                Status;
 393   VENDOR_DEVICE_PATH        Vendor;
 394   EFI_DEVICE_PATH_PROTOCOL  *TerminalDevicePath;
 395   UINTN                     Index;
 396
 397   GetEfiGlobalVariable2 (ConsoleName, (VOID**)&ConDevicePath, NULL);
 398   if (ConDevicePath != NULL) {
 399     EfiLibDeleteVariable (ConsoleName, &gEfiGlobalVariableGuid);
 400     FreePool (ConDevicePath);
 401     ConDevicePath = NULL;
 402   };
 403
 404   //
 405   // First add all console input device from console input menu
 406   //
 407   for (Index = 0; Index < ConsoleMenu->MenuNumber; Index++) {
 408     NewMenuEntry = BOpt_GetMenuEntry (ConsoleMenu, Index);
 409
 410     NewConsoleContext = (BM_CONSOLE_CONTEXT *) NewMenuEntry->VariableContext;
 411     if (NewConsoleContext->IsActive) {
 412       ConDevicePath = AppendDevicePathInstance (
 413                         ConDevicePath,
 414                         NewConsoleContext->DevicePath
 415                         );
 416     }
 417   }
 418
 419   for (Index = 0; Index < TerminalMenu.MenuNumber; Index++) {
 420     NewMenuEntry = BOpt_GetMenuEntry (&TerminalMenu, Index);
 421
 422     NewTerminalContext = (BM_TERMINAL_CONTEXT *) NewMenuEntry->VariableContext;
 423     if (((NewTerminalContext->IsConIn != 0) && (UpdatePageId == FORM_CON_IN_ID)) ||
 424         ((NewTerminalContext->IsConOut != 0)  && (UpdatePageId == FORM_CON_OUT_ID)) ||
 425         ((NewTerminalContext->IsStdErr  != 0) && (UpdatePageId == FORM_CON_ERR_ID))
 426         ) {
 427       Vendor.Header.Type    = MESSAGING_DEVICE_PATH;
 428       Vendor.Header.SubType = MSG_VENDOR_DP;
 429
 430       ASSERT (NewTerminalContext->TerminalType < (sizeof (TerminalTypeGuid) / sizeof (TerminalTypeGuid[0])));
 431       CopyMem (
 432         &Vendor.Guid,
 433         &TerminalTypeGuid[NewTerminalContext->TerminalType],
 434         sizeof (EFI_GUID)
 435         );
 436       SetDevicePathNodeLength (&Vendor.Header, sizeof (VENDOR_DEVICE_PATH));
 437       TerminalDevicePath = AppendDevicePathNode (
 438                             NewTerminalContext->DevicePath,
 439                             (EFI_DEVICE_PATH_PROTOCOL *) &Vendor
 440                             );
 441       ASSERT (TerminalDevicePath != NULL);
 442       ChangeTerminalDevicePath (TerminalDevicePath, TRUE);
 443       ConDevicePath = AppendDevicePathInstance (
 444                         ConDevicePath,
 445                         TerminalDevicePath
 446                         );
 447     }
 448   }
 449
 450   if (ConDevicePath != NULL) {
 451     Status = gRT->SetVariable (
 452                     ConsoleName,
 453                     &gEfiGlobalVariableGuid,
 454                     VAR_FLAG,
 455                     GetDevicePathSize (ConDevicePath),
 456                     ConDevicePath
 457                     );
 458     if (EFI_ERROR (Status)) {
 459       return Status;
 460     }
 461   }
 462
 463   return EFI_SUCCESS;
 464
 465 }
 466
 467 /**
 468   This function delete and build multi-instance device path ConIn
 469   console device.
 470
 471   @retval EFI_SUCCESS    The function complete successfully.
 472   @return The EFI variable can not be saved. See gRT->SetVariable for detail return information.
 473 **/
 474 EFI_STATUS
 475 Var_UpdateConsoleInpOption (
 476   VOID
 477   )
 478 {
 479   return Var_UpdateConsoleOption (L"ConIn", &ConsoleInpMenu, FORM_CON_IN_ID);
 480 }
 481
 482 /**
 483   This function delete and build multi-instance device path ConOut
 484   console device.
 485
 486   @retval EFI_SUCCESS    The function complete successfully.
 487   @return The EFI variable can not be saved. See gRT->SetVariable for detail return information.
 488 **/
 489 EFI_STATUS
 490 Var_UpdateConsoleOutOption (
 491   VOID
 492   )
 493 {
 494   return Var_UpdateConsoleOption (L"ConOut", &ConsoleOutMenu, FORM_CON_OUT_ID);
 495 }
 496
 497 /**
 498   This function delete and build multi-instance device path ErrOut
 499   console device.
 500
 501   @retval EFI_SUCCESS    The function complete successfully.
 502   @return The EFI variable can not be saved. See gRT->SetVariable for detail return information.
 503 **/
 504 EFI_STATUS
 505 Var_UpdateErrorOutOption (
 506   VOID
 507   )
 508 {
 509   return Var_UpdateConsoleOption (L"ErrOut", &ConsoleErrMenu, FORM_CON_ERR_ID);
 510 }
 511
 512 /**
 513   This function create a currently loaded Drive Option from
 514   the BMM. It then appends this Driver Option to the end of
 515   the "DriverOrder" list. It append this Driver Opotion to the end
 516   of DriverOptionMenu.
 517
 518   @param CallbackData    The BMM context data.
 519   @param HiiHandle       The HII handle associated with the BMM formset.
 520   @param DescriptionData The description of this driver option.
 521   @param OptionalData    The optional load option.
 522   @param ForceReconnect  If to force reconnect.
 523
 524   @retval EFI_OUT_OF_RESOURCES If not enought memory to complete the operation.
 525   @retval EFI_SUCCESS          If function completes successfully.
 526
 527 **/
 528 EFI_STATUS
 529 Var_UpdateDriverOption (
 530   IN  BMM_CALLBACK_DATA         *CallbackData,
 531   IN  EFI_HII_HANDLE            HiiHandle,
 532   IN  UINT16                    *DescriptionData,
 533   IN  UINT16                    *OptionalData,
 534   IN  UINT8                     ForceReconnect
 535   )
 536 {
 537   UINT16          Index;
 538   UINT16          DriverString[12];
 539   BM_MENU_ENTRY   *NewMenuEntry;
 540   BM_LOAD_CONTEXT *NewLoadContext;
 541   BOOLEAN         OptionalDataExist;
 542   EFI_STATUS      Status;
 543   EFI_BOOT_MANAGER_LOAD_OPTION  LoadOption;
 544   UINT8                         *OptionalDesData;
 545   UINT32                        OptionalDataSize;
 546
 547   OptionalDataExist = FALSE;
 548   OptionalDesData = NULL;
 549   OptionalDataSize = 0;
 550
 551   Index             = BOpt_GetDriverOptionNumber ();
 552   UnicodeSPrint (
 553     DriverString,
 554     sizeof (DriverString),
 555     L"Driver%04x",
 556     Index
 557     );
 558
 559   if (*DescriptionData == 0x0000) {
 560     StrCpyS (DescriptionData, MAX_MENU_NUMBER, DriverString);
 561   }
 562
 563   if (*OptionalData != 0x0000) {
 564     OptionalDataExist = TRUE;
 565     OptionalDesData = (UINT8 *)OptionalData;
 566     OptionalDataSize = (UINT32)StrSize (OptionalData);
 567   }
 568
 569   NewMenuEntry = BOpt_CreateMenuEntry (BM_LOAD_CONTEXT_SELECT);
 570   if (NULL == NewMenuEntry) {
 571     return EFI_OUT_OF_RESOURCES;
 572   }
 573
 574   Status = EfiBootManagerInitializeLoadOption (
 575              &LoadOption,
 576              Index,
 577              LoadOptionTypeDriver,
 578              LOAD_OPTION_ACTIVE | (ForceReconnect << 1),
 579              DescriptionData,
 580              CallbackData->LoadContext->FilePathList,
 581              OptionalDesData,
 582              OptionalDataSize
 583            );
 584   if (!EFI_ERROR (Status)){
 585     Status = EfiBootManagerAddLoadOptionVariable (&LoadOption,(UINTN) -1 );
 586   }
 587
 588   NewLoadContext                  = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
 589   NewLoadContext->Deleted         = FALSE;
 590   NewLoadContext->Attributes = LoadOption.Attributes;
 591   NewLoadContext->FilePathListLength = (UINT16)GetDevicePathSize (LoadOption.FilePath);
 592
 593   NewLoadContext->Description = AllocateZeroPool (StrSize (DescriptionData));
 594   ASSERT (NewLoadContext->Description != NULL);
 595   NewMenuEntry->DisplayString = NewLoadContext->Description;
 596   CopyMem (
 597     NewLoadContext->Description,
 598     LoadOption.Description,
 599     StrSize (DescriptionData)
 600     );
 601
 602   NewLoadContext->FilePathList = AllocateZeroPool (GetDevicePathSize (CallbackData->LoadContext->FilePathList));
 603   ASSERT (NewLoadContext->FilePathList != NULL);
 604   CopyMem (
 605     NewLoadContext->FilePathList,
 606     LoadOption.FilePath,
 607     GetDevicePathSize (CallbackData->LoadContext->FilePathList)
 608     );
 609
 610   NewMenuEntry->HelpString    = UiDevicePathToStr (NewLoadContext->FilePathList);
 611   NewMenuEntry->OptionNumber  = Index;
 612   NewMenuEntry->DisplayStringToken = HiiSetString (HiiHandle, 0, NewMenuEntry->DisplayString, NULL);
 613   NewMenuEntry->HelpStringToken = HiiSetString (HiiHandle, 0, NewMenuEntry->HelpString, NULL);
 614
 615   if (OptionalDataExist) {
 616     NewLoadContext->OptionalData = AllocateZeroPool (LoadOption.OptionalDataSize);
 617     CopyMem (
 618       NewLoadContext->OptionalData,
 619       LoadOption.OptionalData,
 620       LoadOption.OptionalDataSize
 621       );
 622   }
 623
 624   InsertTailList (&DriverOptionMenu.Head, &NewMenuEntry->Link);
 625   DriverOptionMenu.MenuNumber++;
 626
 627   EfiBootManagerFreeLoadOption(&LoadOption);
 628
 629   return EFI_SUCCESS;
 630 }
 631
 632 /**
 633   This function create a currently loaded Boot Option from
 634   the BMM. It then appends this Boot Option to the end of
 635   the "BootOrder" list. It also append this Boot Opotion to the end
 636   of BootOptionMenu.
 637
 638   @param CallbackData    The BMM context data.
 639
 640   @retval EFI_OUT_OF_RESOURCES If not enought memory to complete the operation.
 641   @retval EFI_SUCCESS          If function completes successfully.
 642
 643 **/
 644 EFI_STATUS
 645 Var_UpdateBootOption (
 646   IN  BMM_CALLBACK_DATA              *CallbackData
 647   )
 648 {
 649   UINT16          BootString[10];
 650   UINT16          Index;
 651   BM_MENU_ENTRY   *NewMenuEntry;
 652   BM_LOAD_CONTEXT *NewLoadContext;
 653   BOOLEAN         OptionalDataExist;
 654   EFI_STATUS      Status;
 655   BMM_FAKE_NV_DATA  *NvRamMap;
 656   EFI_BOOT_MANAGER_LOAD_OPTION  LoadOption;
 657   UINT8                         *OptionalData;
 658   UINT32                        OptionalDataSize;
 659
 660   OptionalDataExist = FALSE;
 661   NvRamMap = &CallbackData->BmmFakeNvData;
 662   OptionalData = NULL;
 663   OptionalDataSize = 0;
 664
 665   Index = BOpt_GetBootOptionNumber () ;
 666   UnicodeSPrint (BootString, sizeof (BootString), L"Boot%04x", Index);
 667
 668   if (NvRamMap->BootDescriptionData[0] == 0x0000) {
 669     StrCpyS (NvRamMap->BootDescriptionData, sizeof (NvRamMap->BootDescriptionData) / sizeof (NvRamMap->BootDescriptionData[0]), BootString);
 670   }
 671
 672   if (NvRamMap->BootOptionalData[0] != 0x0000) {
 673     OptionalDataExist = TRUE;
 674     OptionalData = (UINT8 *)NvRamMap->BootOptionalData;
 675     OptionalDataSize = (UINT32)StrSize (NvRamMap->BootOptionalData);
 676   }
 677
 678   NewMenuEntry = BOpt_CreateMenuEntry (BM_LOAD_CONTEXT_SELECT);
 679   if (NULL == NewMenuEntry) {
 680     return EFI_OUT_OF_RESOURCES;
 681   }
 682
 683   Status = EfiBootManagerInitializeLoadOption (
 684              &LoadOption,
 685              Index,
 686              LoadOptionTypeBoot,
 687              LOAD_OPTION_ACTIVE,
 688              NvRamMap->BootDescriptionData,
 689              CallbackData->LoadContext->FilePathList,
 690              OptionalData,
 691              OptionalDataSize
 692            );
 693   if (!EFI_ERROR (Status)){
 694     Status = EfiBootManagerAddLoadOptionVariable (&LoadOption,(UINTN) -1 );
 695   }
 696
 697   NewLoadContext                  = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
 698   NewLoadContext->Deleted         = FALSE;
 699   NewLoadContext->Attributes = LoadOption.Attributes;
 700   NewLoadContext->FilePathListLength = (UINT16) GetDevicePathSize (LoadOption.FilePath);
 701
 702   NewLoadContext->Description = AllocateZeroPool (StrSize (NvRamMap->BootDescriptionData));
 703   ASSERT (NewLoadContext->Description != NULL);
 704
 705   NewMenuEntry->DisplayString = NewLoadContext->Description;
 706
 707   CopyMem (
 708     NewLoadContext->Description,
 709     LoadOption.Description,
 710     StrSize (NvRamMap->BootDescriptionData)
 711     );
 712
 713   NewLoadContext->FilePathList = AllocateZeroPool (GetDevicePathSize (CallbackData->LoadContext->FilePathList));
 714   ASSERT (NewLoadContext->FilePathList != NULL);
 715   CopyMem (
 716     NewLoadContext->FilePathList,
 717     LoadOption.FilePath,
 718     GetDevicePathSize (CallbackData->LoadContext->FilePathList)
 719     );
 720
 721   NewMenuEntry->HelpString    = UiDevicePathToStr (NewLoadContext->FilePathList);
 722   NewMenuEntry->OptionNumber  = Index;
 723   NewMenuEntry->DisplayStringToken = HiiSetString (CallbackData->BmmHiiHandle, 0, NewMenuEntry->DisplayString, NULL);
 724   NewMenuEntry->HelpStringToken = HiiSetString (CallbackData->BmmHiiHandle, 0, NewMenuEntry->HelpString, NULL);
 725
 726   if (OptionalDataExist) {
 727     NewLoadContext->OptionalData = AllocateZeroPool (LoadOption.OptionalDataSize);
 728     CopyMem (
 729       NewLoadContext->OptionalData,
 730       LoadOption.OptionalData,
 731       LoadOption.OptionalDataSize
 732       );
 733   }
 734
 735   InsertTailList (&BootOptionMenu.Head, &NewMenuEntry->Link);
 736   BootOptionMenu.MenuNumber++;
 737
 738   EfiBootManagerFreeLoadOption(&LoadOption);
 739
 740   return EFI_SUCCESS;
 741 }
 742
 743 /**
 744   This function update the "BootNext" EFI Variable. If there is
 745   no "BootNext" specified in BMM, this EFI Variable is deleted.
 746   It also update the BMM context data specified the "BootNext"
 747   vaule.
 748
 749   @param CallbackData    The BMM context data.
 750
 751   @retval EFI_SUCCESS    The function complete successfully.
 752   @return                The EFI variable can be saved. See gRT->SetVariable
 753                          for detail return information.
 754
 755 **/
 756 EFI_STATUS
 757 Var_UpdateBootNext (
 758   IN BMM_CALLBACK_DATA            *CallbackData
 759   )
 760 {
 761   BM_MENU_ENTRY     *NewMenuEntry;
 762   BM_LOAD_CONTEXT   *NewLoadContext;
 763   BMM_FAKE_NV_DATA  *CurrentFakeNVMap;
 764   UINT16            Index;
 765   EFI_STATUS        Status;
 766
 767   Status            = EFI_SUCCESS;
 768   CurrentFakeNVMap  = &CallbackData->BmmFakeNvData;
 769   for (Index = 0; Index < BootOptionMenu.MenuNumber; Index++) {
 770     NewMenuEntry = BOpt_GetMenuEntry (&BootOptionMenu, Index);
 771     ASSERT (NULL != NewMenuEntry);
 772
 773     NewLoadContext              = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
 774     NewLoadContext->IsBootNext  = FALSE;
 775   }
 776
 777   if (CurrentFakeNVMap->BootNext == NONE_BOOTNEXT_VALUE) {
 778     EfiLibDeleteVariable (L"BootNext", &gEfiGlobalVariableGuid);
 779     return EFI_SUCCESS;
 780   }
 781
 782   NewMenuEntry = BOpt_GetMenuEntry (
 783                   &BootOptionMenu,
 784                   CurrentFakeNVMap->BootNext
 785                   );
 786   ASSERT (NewMenuEntry != NULL);
 787
 788   NewLoadContext = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
 789   Status = gRT->SetVariable (
 790                   L"BootNext",
 791                   &gEfiGlobalVariableGuid,
 792                   VAR_FLAG,
 793                   sizeof (UINT16),
 794                   &NewMenuEntry->OptionNumber
 795                   );
 796   NewLoadContext->IsBootNext              = TRUE;
 797   CallbackData->BmmOldFakeNVData.BootNext = CurrentFakeNVMap->BootNext;
 798   return Status;
 799 }
 800
 801 /**
 802   This function update the "BootOrder" EFI Variable based on
 803   BMM Formset's NV map. It then refresh BootOptionMenu
 804   with the new "BootOrder" list.
 805
 806   @param CallbackData    The BMM context data.
 807
 808   @retval EFI_SUCCESS             The function complete successfully.
 809   @retval EFI_OUT_OF_RESOURCES    Not enough memory to complete the function.
 810   @return The EFI variable can not be saved. See gRT->SetVariable for detail return information.
 811
 812 **/
 813 EFI_STATUS
 814 Var_UpdateBootOrder (
 815   IN BMM_CALLBACK_DATA            *CallbackData
 816   )
 817 {
 818   EFI_STATUS  Status;
 819   UINT16      Index;
 820   UINT16      OrderIndex;
 821   UINT16      *BootOrder;
 822   UINTN       BootOrderSize;
 823   UINT16      OptionNumber;
 824
 825   //
 826   // First check whether BootOrder is present in current configuration
 827   //
 828   GetEfiGlobalVariable2 (L"BootOrder", (VOID **) &BootOrder, &BootOrderSize);
 829   if (BootOrder == NULL) {
 830     return EFI_OUT_OF_RESOURCES;
 831   }
 832
 833   ASSERT (BootOptionMenu.MenuNumber <= (sizeof (CallbackData->BmmFakeNvData.BootOptionOrder) / sizeof (CallbackData->BmmFakeNvData.BootOptionOrder[0])));
 834
 835   //
 836   // OptionOrder is subset of BootOrder
 837   //
 838   for (OrderIndex = 0; (OrderIndex < BootOptionMenu.MenuNumber) && (CallbackData->BmmFakeNvData.BootOptionOrder[OrderIndex] != 0); OrderIndex++) {
 839     for (Index = OrderIndex; Index < BootOrderSize / sizeof (UINT16); Index++) {
 840       if ((BootOrder[Index] == (UINT16) (CallbackData->BmmFakeNvData.BootOptionOrder[OrderIndex] - 1)) && (OrderIndex != Index)) {
 841         OptionNumber = BootOrder[Index];
 842         CopyMem (&BootOrder[OrderIndex + 1], &BootOrder[OrderIndex], (Index - OrderIndex) * sizeof (UINT16));
 843         BootOrder[OrderIndex] = OptionNumber;
 844       }
 845     }
 846   }
 847
 848   Status = gRT->SetVariable (
 849                   L"BootOrder",
 850                   &gEfiGlobalVariableGuid,
 851                   VAR_FLAG,
 852                   BootOrderSize,
 853                   BootOrder
 854                   );
 855   FreePool (BootOrder);
 856
 857   BOpt_FreeMenu (&BootOptionMenu);
 858   BOpt_GetBootOptions (CallbackData);
 859
 860   return Status;
 861
 862 }
 863
 864 /**
 865   This function update the "DriverOrder" EFI Variable based on
 866   BMM Formset's NV map. It then refresh DriverOptionMenu
 867   with the new "DriverOrder" list.
 868
 869   @param CallbackData    The BMM context data.
 870
 871   @retval EFI_SUCCESS           The function complete successfully.
 872   @retval EFI_OUT_OF_RESOURCES  Not enough memory to complete the function.
 873   @return The EFI variable can not be saved. See gRT->SetVariable for detail return information.
 874
 875 **/
 876 EFI_STATUS
 877 Var_UpdateDriverOrder (
 878   IN BMM_CALLBACK_DATA            *CallbackData
 879   )
 880 {
 881   EFI_STATUS  Status;
 882   UINT16      Index;
 883   UINT16      *DriverOrderList;
 884   UINT16      *NewDriverOrderList;
 885   UINTN       DriverOrderListSize;
 886
 887   DriverOrderList     = NULL;
 888   DriverOrderListSize = 0;
 889
 890   //
 891   // First check whether DriverOrder is present in current configuration
 892   //
 893   GetEfiGlobalVariable2 (L"DriverOrder", (VOID **) &DriverOrderList, &DriverOrderListSize);
 894   NewDriverOrderList = AllocateZeroPool (DriverOrderListSize);
 895
 896   if (NewDriverOrderList == NULL) {
 897     return EFI_OUT_OF_RESOURCES;
 898   }
 899   //
 900   // If exists, delete it to hold new DriverOrder
 901   //
 902   if (DriverOrderList != NULL) {
 903     EfiLibDeleteVariable (L"DriverOrder", &gEfiGlobalVariableGuid);
 904     FreePool (DriverOrderList);
 905   }
 906
 907   ASSERT (DriverOptionMenu.MenuNumber <= (sizeof (CallbackData->BmmFakeNvData.DriverOptionOrder) / sizeof (CallbackData->BmmFakeNvData.DriverOptionOrder[0])));
 908   for (Index = 0; Index < DriverOptionMenu.MenuNumber; Index++) {
 909     NewDriverOrderList[Index] = (UINT16) (CallbackData->BmmFakeNvData.DriverOptionOrder[Index] - 1);
 910   }
 911
 912   Status = gRT->SetVariable (
 913                   L"DriverOrder",
 914                   &gEfiGlobalVariableGuid,
 915                   VAR_FLAG,
 916                   DriverOrderListSize,
 917                   NewDriverOrderList
 918                   );
 919   if (EFI_ERROR (Status)) {
 920     return Status;
 921   }
 922
 923   BOpt_FreeMenu (&DriverOptionMenu);
 924   BOpt_GetDriverOptions (CallbackData);
 925   return EFI_SUCCESS;
 926 }
 927
 928 /**
 929   Update the Text Mode of Console.
 930
 931   @param CallbackData  The context data for BMM.
 932
 933   @retval EFI_SUCCSS If the Text Mode of Console is updated.
 934   @return Other value if the Text Mode of Console is not updated.
 935
 936 **/
 937 EFI_STATUS
 938 Var_UpdateConMode (
 939   IN BMM_CALLBACK_DATA            *CallbackData
 940   )
 941 {
 942   EFI_STATUS        Status;
 943   UINTN             Mode;
 944   CONSOLE_OUT_MODE  ModeInfo;
 945
 946   Mode = CallbackData->BmmFakeNvData.ConsoleOutMode;
 947
 948   Status = gST->ConOut->QueryMode (gST->ConOut, Mode, &(ModeInfo.Column), &(ModeInfo.Row));
 949   if (!EFI_ERROR(Status)) {
 950     Status = PcdSet32S (PcdSetupConOutColumn, (UINT32) ModeInfo.Column);
 951     if (!EFI_ERROR (Status)) {
 952       Status = PcdSet32S (PcdSetupConOutRow, (UINT32) ModeInfo.Row);
 953     }
 954   }
 955
 956   return Status;
 957 }