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   This function delete and build multi-instance device path for
 305   specified type of console device.
 306
 307   This function clear the EFI variable defined by ConsoleName and
 308   gEfiGlobalVariableGuid. It then build the multi-instance device
 309   path by appending the device path of the Console (In/Out/Err) instance
 310   in ConsoleMenu. Then it scan all corresponding console device by
 311   scanning Terminal (built from device supporting Serial I/O instances)
 312   devices in TerminalMenu. At last, it save a EFI variable specifed
 313   by ConsoleName and gEfiGlobalVariableGuid.
 314
 315   @param ConsoleName     The name for the console device type. They are
 316                          usually "ConIn", "ConOut" and "ErrOut".
 317   @param ConsoleMenu     The console memu which is a list of console devices.
 318   @param UpdatePageId    The flag specifying which type of console device
 319                          to be processed.
 320
 321   @retval EFI_SUCCESS    The function complete successfully.
 322   @return The EFI variable can not be saved. See gRT->SetVariable for detail return information.
 323
 324 **/
 325 EFI_STATUS
 326 Var_UpdateConsoleOption (
 327   IN UINT16                     *ConsoleName,
 328   IN BM_MENU_OPTION             *ConsoleMenu,
 329   IN UINT16                     UpdatePageId
 330   )
 331 {
 332   EFI_DEVICE_PATH_PROTOCOL  *ConDevicePath;
 333   BM_MENU_ENTRY             *NewMenuEntry;
 334   BM_CONSOLE_CONTEXT        *NewConsoleContext;
 335   BM_TERMINAL_CONTEXT       *NewTerminalContext;
 336   EFI_STATUS                Status;
 337   VENDOR_DEVICE_PATH        Vendor;
 338   EFI_DEVICE_PATH_PROTOCOL  *TerminalDevicePath;
 339   UINTN                     Index;
 340
 341   GetEfiGlobalVariable2 (ConsoleName, (VOID**)&ConDevicePath, NULL);
 342   if (ConDevicePath != NULL) {
 343     EfiLibDeleteVariable (ConsoleName, &gEfiGlobalVariableGuid);
 344     FreePool (ConDevicePath);
 345     ConDevicePath = NULL;
 346   };
 347
 348   //
 349   // First add all console input device from console input menu
 350   //
 351   for (Index = 0; Index < ConsoleMenu->MenuNumber; Index++) {
 352     NewMenuEntry = BOpt_GetMenuEntry (ConsoleMenu, Index);
 353
 354     NewConsoleContext = (BM_CONSOLE_CONTEXT *) NewMenuEntry->VariableContext;
 355     if (NewConsoleContext->IsActive) {
 356       ConDevicePath = AppendDevicePathInstance (
 357                         ConDevicePath,
 358                         NewConsoleContext->DevicePath
 359                         );
 360     }
 361   }
 362
 363   for (Index = 0; Index < TerminalMenu.MenuNumber; Index++) {
 364     NewMenuEntry = BOpt_GetMenuEntry (&TerminalMenu, Index);
 365
 366     NewTerminalContext = (BM_TERMINAL_CONTEXT *) NewMenuEntry->VariableContext;
 367     if (((NewTerminalContext->IsConIn != 0) && (UpdatePageId == FORM_CON_IN_ID)) ||
 368         ((NewTerminalContext->IsConOut != 0)  && (UpdatePageId == FORM_CON_OUT_ID)) ||
 369         ((NewTerminalContext->IsStdErr  != 0) && (UpdatePageId == FORM_CON_ERR_ID))
 370         ) {
 371       Vendor.Header.Type    = MESSAGING_DEVICE_PATH;
 372       Vendor.Header.SubType = MSG_VENDOR_DP;
 373
 374       ASSERT (NewTerminalContext->TerminalType < (sizeof (TerminalTypeGuid) / sizeof (TerminalTypeGuid[0])));
 375       CopyMem (
 376         &Vendor.Guid,
 377         &TerminalTypeGuid[NewTerminalContext->TerminalType],
 378         sizeof (EFI_GUID)
 379         );
 380       SetDevicePathNodeLength (&Vendor.Header, sizeof (VENDOR_DEVICE_PATH));
 381       TerminalDevicePath = AppendDevicePathNode (
 382                             NewTerminalContext->DevicePath,
 383                             (EFI_DEVICE_PATH_PROTOCOL *) &Vendor
 384                             );
 385       ASSERT (TerminalDevicePath != NULL);
 386       ChangeTerminalDevicePath (TerminalDevicePath, TRUE);
 387       ConDevicePath = AppendDevicePathInstance (
 388                         ConDevicePath,
 389                         TerminalDevicePath
 390                         );
 391     }
 392   }
 393
 394   if (ConDevicePath != NULL) {
 395     Status = gRT->SetVariable (
 396                     ConsoleName,
 397                     &gEfiGlobalVariableGuid,
 398                     VAR_FLAG,
 399                     GetDevicePathSize (ConDevicePath),
 400                     ConDevicePath
 401                     );
 402     if (EFI_ERROR (Status)) {
 403       return Status;
 404     }
 405   }
 406
 407   return EFI_SUCCESS;
 408
 409 }
 410
 411 /**
 412   This function delete and build multi-instance device path ConIn
 413   console device.
 414
 415   @retval EFI_SUCCESS    The function complete successfully.
 416   @return The EFI variable can not be saved. See gRT->SetVariable for detail return information.
 417 **/
 418 EFI_STATUS
 419 Var_UpdateConsoleInpOption (
 420   VOID
 421   )
 422 {
 423   return Var_UpdateConsoleOption (L"ConIn", &ConsoleInpMenu, FORM_CON_IN_ID);
 424 }
 425
 426 /**
 427   This function delete and build multi-instance device path ConOut
 428   console device.
 429
 430   @retval EFI_SUCCESS    The function complete successfully.
 431   @return The EFI variable can not be saved. See gRT->SetVariable for detail return information.
 432 **/
 433 EFI_STATUS
 434 Var_UpdateConsoleOutOption (
 435   VOID
 436   )
 437 {
 438   return Var_UpdateConsoleOption (L"ConOut", &ConsoleOutMenu, FORM_CON_OUT_ID);
 439 }
 440
 441 /**
 442   This function delete and build multi-instance device path ErrOut
 443   console device.
 444
 445   @retval EFI_SUCCESS    The function complete successfully.
 446   @return The EFI variable can not be saved. See gRT->SetVariable for detail return information.
 447 **/
 448 EFI_STATUS
 449 Var_UpdateErrorOutOption (
 450   VOID
 451   )
 452 {
 453   return Var_UpdateConsoleOption (L"ErrOut", &ConsoleErrMenu, FORM_CON_ERR_ID);
 454 }
 455
 456 /**
 457   This function create a currently loaded Drive Option from
 458   the BMM. It then appends this Driver Option to the end of
 459   the "DriverOrder" list. It append this Driver Opotion to the end
 460   of DriverOptionMenu.
 461
 462   @param CallbackData    The BMM context data.
 463   @param HiiHandle       The HII handle associated with the BMM formset.
 464   @param DescriptionData The description of this driver option.
 465   @param OptionalData    The optional load option.
 466   @param ForceReconnect  If to force reconnect.
 467
 468   @retval EFI_OUT_OF_RESOURCES If not enought memory to complete the operation.
 469   @retval EFI_SUCCESS          If function completes successfully.
 470
 471 **/
 472 EFI_STATUS
 473 Var_UpdateDriverOption (
 474   IN  BMM_CALLBACK_DATA         *CallbackData,
 475   IN  EFI_HII_HANDLE            HiiHandle,
 476   IN  UINT16                    *DescriptionData,
 477   IN  UINT16                    *OptionalData,
 478   IN  UINT8                     ForceReconnect
 479   )
 480 {
 481   UINT16          Index;
 482   UINT16          DriverString[12];
 483   BM_MENU_ENTRY   *NewMenuEntry;
 484   BM_LOAD_CONTEXT *NewLoadContext;
 485   BOOLEAN         OptionalDataExist;
 486   EFI_STATUS      Status;
 487   EFI_BOOT_MANAGER_LOAD_OPTION  LoadOption;
 488   UINT8                         *OptionalDesData;
 489   UINT32                        OptionalDataSize;
 490
 491   OptionalDataExist = FALSE;
 492   OptionalDesData = NULL;
 493   OptionalDataSize = 0;
 494
 495   Index             = BOpt_GetDriverOptionNumber ();
 496   UnicodeSPrint (
 497     DriverString,
 498     sizeof (DriverString),
 499     L"Driver%04x",
 500     Index
 501     );
 502
 503   if (*DescriptionData == 0x0000) {
 504     StrCpyS (DescriptionData, MAX_MENU_NUMBER, DriverString);
 505   }
 506
 507   if (*OptionalData != 0x0000) {
 508     OptionalDataExist = TRUE;
 509     OptionalDesData = (UINT8 *)OptionalData;
 510     OptionalDataSize = (UINT32)StrSize (OptionalData);
 511   }
 512
 513   NewMenuEntry = BOpt_CreateMenuEntry (BM_LOAD_CONTEXT_SELECT);
 514   if (NULL == NewMenuEntry) {
 515     return EFI_OUT_OF_RESOURCES;
 516   }
 517
 518   Status = EfiBootManagerInitializeLoadOption (
 519              &LoadOption,
 520              Index,
 521              LoadOptionTypeDriver,
 522              LOAD_OPTION_ACTIVE | (ForceReconnect << 1),
 523              DescriptionData,
 524              CallbackData->LoadContext->FilePathList,
 525              OptionalDesData,
 526              OptionalDataSize
 527            );
 528   if (!EFI_ERROR (Status)){
 529     Status = EfiBootManagerAddLoadOptionVariable (&LoadOption,(UINTN) -1 );
 530   }
 531
 532   NewLoadContext                  = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
 533   NewLoadContext->Deleted         = FALSE;
 534   NewLoadContext->Attributes = LoadOption.Attributes;
 535   NewLoadContext->FilePathListLength = (UINT16)GetDevicePathSize (LoadOption.FilePath);
 536
 537   NewLoadContext->Description = AllocateZeroPool (StrSize (DescriptionData));
 538   ASSERT (NewLoadContext->Description != NULL);
 539   NewMenuEntry->DisplayString = NewLoadContext->Description;
 540   CopyMem (
 541     NewLoadContext->Description,
 542     LoadOption.Description,
 543     StrSize (DescriptionData)
 544     );
 545
 546   NewLoadContext->FilePathList = AllocateZeroPool (GetDevicePathSize (CallbackData->LoadContext->FilePathList));
 547   ASSERT (NewLoadContext->FilePathList != NULL);
 548   CopyMem (
 549     NewLoadContext->FilePathList,
 550     LoadOption.FilePath,
 551     GetDevicePathSize (CallbackData->LoadContext->FilePathList)
 552     );
 553
 554   NewMenuEntry->HelpString    = UiDevicePathToStr (NewLoadContext->FilePathList);
 555   NewMenuEntry->OptionNumber  = Index;
 556   NewMenuEntry->DisplayStringToken = HiiSetString (HiiHandle, 0, NewMenuEntry->DisplayString, NULL);
 557   NewMenuEntry->HelpStringToken = HiiSetString (HiiHandle, 0, NewMenuEntry->HelpString, NULL);
 558
 559   if (OptionalDataExist) {
 560     NewLoadContext->OptionalData = AllocateZeroPool (LoadOption.OptionalDataSize);
 561     ASSERT (NewLoadContext->OptionalData != NULL);
 562     CopyMem (
 563       NewLoadContext->OptionalData,
 564       LoadOption.OptionalData,
 565       LoadOption.OptionalDataSize
 566       );
 567   }
 568
 569   InsertTailList (&DriverOptionMenu.Head, &NewMenuEntry->Link);
 570   DriverOptionMenu.MenuNumber++;
 571
 572   EfiBootManagerFreeLoadOption(&LoadOption);
 573
 574   return EFI_SUCCESS;
 575 }
 576
 577 /**
 578   This function create a currently loaded Boot Option from
 579   the BMM. It then appends this Boot Option to the end of
 580   the "BootOrder" list. It also append this Boot Opotion to the end
 581   of BootOptionMenu.
 582
 583   @param CallbackData    The BMM context data.
 584
 585   @retval EFI_OUT_OF_RESOURCES If not enought memory to complete the operation.
 586   @retval EFI_SUCCESS          If function completes successfully.
 587
 588 **/
 589 EFI_STATUS
 590 Var_UpdateBootOption (
 591   IN  BMM_CALLBACK_DATA              *CallbackData
 592   )
 593 {
 594   UINT16          BootString[10];
 595   UINT16          Index;
 596   BM_MENU_ENTRY   *NewMenuEntry;
 597   BM_LOAD_CONTEXT *NewLoadContext;
 598   BOOLEAN         OptionalDataExist;
 599   EFI_STATUS      Status;
 600   BMM_FAKE_NV_DATA  *NvRamMap;
 601   EFI_BOOT_MANAGER_LOAD_OPTION  LoadOption;
 602   UINT8                         *OptionalData;
 603   UINT32                        OptionalDataSize;
 604
 605   OptionalDataExist = FALSE;
 606   NvRamMap = &CallbackData->BmmFakeNvData;
 607   OptionalData = NULL;
 608   OptionalDataSize = 0;
 609
 610   Index = BOpt_GetBootOptionNumber () ;
 611   UnicodeSPrint (BootString, sizeof (BootString), L"Boot%04x", Index);
 612
 613   if (NvRamMap->BootDescriptionData[0] == 0x0000) {
 614     StrCpyS (NvRamMap->BootDescriptionData, sizeof (NvRamMap->BootDescriptionData) / sizeof (NvRamMap->BootDescriptionData[0]), BootString);
 615   }
 616
 617   if (NvRamMap->BootOptionalData[0] != 0x0000) {
 618     OptionalDataExist = TRUE;
 619     OptionalData = (UINT8 *)NvRamMap->BootOptionalData;
 620     OptionalDataSize = (UINT32)StrSize (NvRamMap->BootOptionalData);
 621   }
 622
 623   NewMenuEntry = BOpt_CreateMenuEntry (BM_LOAD_CONTEXT_SELECT);
 624   if (NULL == NewMenuEntry) {
 625     return EFI_OUT_OF_RESOURCES;
 626   }
 627
 628   Status = EfiBootManagerInitializeLoadOption (
 629              &LoadOption,
 630              Index,
 631              LoadOptionTypeBoot,
 632              LOAD_OPTION_ACTIVE,
 633              NvRamMap->BootDescriptionData,
 634              CallbackData->LoadContext->FilePathList,
 635              OptionalData,
 636              OptionalDataSize
 637            );
 638   if (!EFI_ERROR (Status)){
 639     Status = EfiBootManagerAddLoadOptionVariable (&LoadOption,(UINTN) -1 );
 640   }
 641
 642   NewLoadContext                  = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
 643   NewLoadContext->Deleted         = FALSE;
 644   NewLoadContext->Attributes = LoadOption.Attributes;
 645   NewLoadContext->FilePathListLength = (UINT16) GetDevicePathSize (LoadOption.FilePath);
 646
 647   NewLoadContext->Description = AllocateZeroPool (StrSize (NvRamMap->BootDescriptionData));
 648   ASSERT (NewLoadContext->Description != NULL);
 649
 650   NewMenuEntry->DisplayString = NewLoadContext->Description;
 651
 652   CopyMem (
 653     NewLoadContext->Description,
 654     LoadOption.Description,
 655     StrSize (NvRamMap->BootDescriptionData)
 656     );
 657
 658   NewLoadContext->FilePathList = AllocateZeroPool (GetDevicePathSize (CallbackData->LoadContext->FilePathList));
 659   ASSERT (NewLoadContext->FilePathList != NULL);
 660   CopyMem (
 661     NewLoadContext->FilePathList,
 662     LoadOption.FilePath,
 663     GetDevicePathSize (CallbackData->LoadContext->FilePathList)
 664     );
 665
 666   NewMenuEntry->HelpString    = UiDevicePathToStr (NewLoadContext->FilePathList);
 667   NewMenuEntry->OptionNumber  = Index;
 668   NewMenuEntry->DisplayStringToken = HiiSetString (CallbackData->BmmHiiHandle, 0, NewMenuEntry->DisplayString, NULL);
 669   NewMenuEntry->HelpStringToken = HiiSetString (CallbackData->BmmHiiHandle, 0, NewMenuEntry->HelpString, NULL);
 670
 671   if (OptionalDataExist) {
 672     NewLoadContext->OptionalData = AllocateZeroPool (LoadOption.OptionalDataSize);
 673     ASSERT (NewLoadContext->OptionalData != NULL);
 674     CopyMem (
 675       NewLoadContext->OptionalData,
 676       LoadOption.OptionalData,
 677       LoadOption.OptionalDataSize
 678       );
 679   }
 680
 681   InsertTailList (&BootOptionMenu.Head, &NewMenuEntry->Link);
 682   BootOptionMenu.MenuNumber++;
 683
 684   EfiBootManagerFreeLoadOption(&LoadOption);
 685
 686   return EFI_SUCCESS;
 687 }
 688
 689 /**
 690   This function update the "BootNext" EFI Variable. If there is
 691   no "BootNext" specified in BMM, this EFI Variable is deleted.
 692   It also update the BMM context data specified the "BootNext"
 693   vaule.
 694
 695   @param CallbackData    The BMM context data.
 696
 697   @retval EFI_SUCCESS    The function complete successfully.
 698   @return                The EFI variable can be saved. See gRT->SetVariable
 699                          for detail return information.
 700
 701 **/
 702 EFI_STATUS
 703 Var_UpdateBootNext (
 704   IN BMM_CALLBACK_DATA            *CallbackData
 705   )
 706 {
 707   BM_MENU_ENTRY     *NewMenuEntry;
 708   BM_LOAD_CONTEXT   *NewLoadContext;
 709   BMM_FAKE_NV_DATA  *CurrentFakeNVMap;
 710   UINT16            Index;
 711   EFI_STATUS        Status;
 712
 713   Status            = EFI_SUCCESS;
 714   CurrentFakeNVMap  = &CallbackData->BmmFakeNvData;
 715   for (Index = 0; Index < BootOptionMenu.MenuNumber; Index++) {
 716     NewMenuEntry = BOpt_GetMenuEntry (&BootOptionMenu, Index);
 717     ASSERT (NULL != NewMenuEntry);
 718
 719     NewLoadContext              = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
 720     NewLoadContext->IsBootNext  = FALSE;
 721   }
 722
 723   if (CurrentFakeNVMap->BootNext == NONE_BOOTNEXT_VALUE) {
 724     EfiLibDeleteVariable (L"BootNext", &gEfiGlobalVariableGuid);
 725     return EFI_SUCCESS;
 726   }
 727
 728   NewMenuEntry = BOpt_GetMenuEntry (
 729                   &BootOptionMenu,
 730                   CurrentFakeNVMap->BootNext
 731                   );
 732   ASSERT (NewMenuEntry != NULL);
 733
 734   NewLoadContext = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
 735   Status = gRT->SetVariable (
 736                   L"BootNext",
 737                   &gEfiGlobalVariableGuid,
 738                   VAR_FLAG,
 739                   sizeof (UINT16),
 740                   &NewMenuEntry->OptionNumber
 741                   );
 742   NewLoadContext->IsBootNext              = TRUE;
 743   CallbackData->BmmOldFakeNVData.BootNext = CurrentFakeNVMap->BootNext;
 744   return Status;
 745 }
 746
 747 /**
 748   This function update the "BootOrder" EFI Variable based on
 749   BMM Formset's NV map. It then refresh BootOptionMenu
 750   with the new "BootOrder" list.
 751
 752   @param CallbackData    The BMM context data.
 753
 754   @retval EFI_SUCCESS             The function complete successfully.
 755   @retval EFI_OUT_OF_RESOURCES    Not enough memory to complete the function.
 756   @return The EFI variable can not be saved. See gRT->SetVariable for detail return information.
 757
 758 **/
 759 EFI_STATUS
 760 Var_UpdateBootOrder (
 761   IN BMM_CALLBACK_DATA            *CallbackData
 762   )
 763 {
 764   EFI_STATUS  Status;
 765   UINT16      Index;
 766   UINT16      OrderIndex;
 767   UINT16      *BootOrder;
 768   UINTN       BootOrderSize;
 769   UINT16      OptionNumber;
 770
 771   //
 772   // First check whether BootOrder is present in current configuration
 773   //
 774   GetEfiGlobalVariable2 (L"BootOrder", (VOID **) &BootOrder, &BootOrderSize);
 775   if (BootOrder == NULL) {
 776     return EFI_OUT_OF_RESOURCES;
 777   }
 778
 779   ASSERT (BootOptionMenu.MenuNumber <= (sizeof (CallbackData->BmmFakeNvData.BootOptionOrder) / sizeof (CallbackData->BmmFakeNvData.BootOptionOrder[0])));
 780
 781   //
 782   // OptionOrder is subset of BootOrder
 783   //
 784   for (OrderIndex = 0; (OrderIndex < BootOptionMenu.MenuNumber) && (CallbackData->BmmFakeNvData.BootOptionOrder[OrderIndex] != 0); OrderIndex++) {
 785     for (Index = OrderIndex; Index < BootOrderSize / sizeof (UINT16); Index++) {
 786       if ((BootOrder[Index] == (UINT16) (CallbackData->BmmFakeNvData.BootOptionOrder[OrderIndex] - 1)) && (OrderIndex != Index)) {
 787         OptionNumber = BootOrder[Index];
 788         CopyMem (&BootOrder[OrderIndex + 1], &BootOrder[OrderIndex], (Index - OrderIndex) * sizeof (UINT16));
 789         BootOrder[OrderIndex] = OptionNumber;
 790       }
 791     }
 792   }
 793
 794   Status = gRT->SetVariable (
 795                   L"BootOrder",
 796                   &gEfiGlobalVariableGuid,
 797                   VAR_FLAG,
 798                   BootOrderSize,
 799                   BootOrder
 800                   );
 801   FreePool (BootOrder);
 802
 803   BOpt_FreeMenu (&BootOptionMenu);
 804   BOpt_GetBootOptions (CallbackData);
 805
 806   return Status;
 807
 808 }
 809
 810 /**
 811   This function update the "DriverOrder" EFI Variable based on
 812   BMM Formset's NV map. It then refresh DriverOptionMenu
 813   with the new "DriverOrder" list.
 814
 815   @param CallbackData    The BMM context data.
 816
 817   @retval EFI_SUCCESS           The function complete successfully.
 818   @retval EFI_OUT_OF_RESOURCES  Not enough memory to complete the function.
 819   @return The EFI variable can not be saved. See gRT->SetVariable for detail return information.
 820
 821 **/
 822 EFI_STATUS
 823 Var_UpdateDriverOrder (
 824   IN BMM_CALLBACK_DATA            *CallbackData
 825   )
 826 {
 827   EFI_STATUS  Status;
 828   UINT16      Index;
 829   UINT16      *DriverOrderList;
 830   UINT16      *NewDriverOrderList;
 831   UINTN       DriverOrderListSize;
 832
 833   DriverOrderList     = NULL;
 834   DriverOrderListSize = 0;
 835
 836   //
 837   // First check whether DriverOrder is present in current configuration
 838   //
 839   GetEfiGlobalVariable2 (L"DriverOrder", (VOID **) &DriverOrderList, &DriverOrderListSize);
 840   NewDriverOrderList = AllocateZeroPool (DriverOrderListSize);
 841
 842   if (NewDriverOrderList == NULL) {
 843     return EFI_OUT_OF_RESOURCES;
 844   }
 845   //
 846   // If exists, delete it to hold new DriverOrder
 847   //
 848   if (DriverOrderList != NULL) {
 849     EfiLibDeleteVariable (L"DriverOrder", &gEfiGlobalVariableGuid);
 850     FreePool (DriverOrderList);
 851   }
 852
 853   ASSERT (DriverOptionMenu.MenuNumber <= (sizeof (CallbackData->BmmFakeNvData.DriverOptionOrder) / sizeof (CallbackData->BmmFakeNvData.DriverOptionOrder[0])));
 854   for (Index = 0; Index < DriverOptionMenu.MenuNumber; Index++) {
 855     NewDriverOrderList[Index] = (UINT16) (CallbackData->BmmFakeNvData.DriverOptionOrder[Index] - 1);
 856   }
 857
 858   Status = gRT->SetVariable (
 859                   L"DriverOrder",
 860                   &gEfiGlobalVariableGuid,
 861                   VAR_FLAG,
 862                   DriverOrderListSize,
 863                   NewDriverOrderList
 864                   );
 865   if (EFI_ERROR (Status)) {
 866     return Status;
 867   }
 868
 869   BOpt_FreeMenu (&DriverOptionMenu);
 870   BOpt_GetDriverOptions (CallbackData);
 871   return EFI_SUCCESS;
 872 }
 873
 874 /**
 875   Update the Text Mode of Console.
 876
 877   @param CallbackData  The context data for BMM.
 878
 879   @retval EFI_SUCCSS If the Text Mode of Console is updated.
 880   @return Other value if the Text Mode of Console is not updated.
 881
 882 **/
 883 EFI_STATUS
 884 Var_UpdateConMode (
 885   IN BMM_CALLBACK_DATA            *CallbackData
 886   )
 887 {
 888   EFI_STATUS        Status;
 889   UINTN             Mode;
 890   CONSOLE_OUT_MODE  ModeInfo;
 891
 892   Mode = CallbackData->BmmFakeNvData.ConsoleOutMode;
 893
 894   Status = gST->ConOut->QueryMode (gST->ConOut, Mode, &(ModeInfo.Column), &(ModeInfo.Row));
 895   if (!EFI_ERROR(Status)) {
 896     Status = PcdSet32S (PcdSetupConOutColumn, (UINT32) ModeInfo.Column);
 897     if (!EFI_ERROR (Status)) {
 898       Status = PcdSet32S (PcdSetupConOutRow, (UINT32) ModeInfo.Row);
 899     }
 900   }
 901
 902   return Status;
 903 }