IntelFrameworkModulePkg/Universal/BdsDxe/BootMaint/Variable.c

   1 /** @file
   2   Variable operation that will be used by bootmaint
   3
   4 Copyright (c) 2004 - 2008, Intel Corporation. <BR>
   5 All rights reserved. This program and the accompanying materials
   6 are licensed and made available under the terms and conditions of the BSD License
   7 which accompanies this distribution.  The full text of the license may be found at
   8 http://opensource.org/licenses/bsd-license.php
   9
  10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13 **/
  14
  15 #include "BootMaint.h"
  16
  17 /**
  18   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   //
 113   // First check whether BootOrder is present in current configuration
 114   //
 115   BootOrderList = BdsLibGetVariableAndSize (
 116                     L"BootOrder",
 117                     &gEfiGlobalVariableGuid,
 118                     &BootOrderListSize
 119                     );
 120
 121   //
 122   // If exists, delete it to hold new BootOrder
 123   //
 124   if (BootOrderList != NULL) {
 125     EfiLibDeleteVariable (L"BootOrder", &gEfiGlobalVariableGuid);
 126     FreePool (BootOrderList);
 127     BootOrderList = NULL;
 128   }
 129   //
 130   // Maybe here should be some check method to ensure that
 131   // no new added boot options will be added
 132   // but the setup engine now will give only one callback
 133   // that is to say, user are granted only one chance to
 134   // decide whether the boot option will be added or not
 135   // there should be no indictor to show whether this
 136   // is a "new" boot option
 137   //
 138   BootOrderListSize = BootOptionMenu.MenuNumber;
 139
 140   if (BootOrderListSize > 0) {
 141     BootOrderList = AllocateZeroPool (BootOrderListSize * sizeof (UINT16));
 142     ASSERT (BootOrderList != NULL);
 143     BootOrderListPtr = BootOrderList;
 144
 145     //
 146     // Get all current used Boot#### from BootOptionMenu.
 147     // OptionNumber in each BM_LOAD_OPTION is really its
 148     // #### value.
 149     //
 150     for (Index = 0; Index < BootOrderListSize; Index++) {
 151       NewMenuEntry    = BOpt_GetMenuEntry (&BootOptionMenu, Index);
 152       *BootOrderList  = (UINT16) NewMenuEntry->OptionNumber;
 153       BootOrderList++;
 154     }
 155
 156     BootOrderList = BootOrderListPtr;
 157
 158     //
 159     // After building the BootOrderList, write it back
 160     //
 161     Status = gRT->SetVariable (
 162                     L"BootOrder",
 163                     &gEfiGlobalVariableGuid,
 164                     VAR_FLAG,
 165                     BootOrderListSize * sizeof (UINT16),
 166                     BootOrderList
 167                     );
 168     if (EFI_ERROR (Status)) {
 169       return Status;
 170     }
 171   }
 172   return EFI_SUCCESS;
 173 }
 174
 175 /**
 176   Delete Load Option that represent a Deleted state in BootOptionMenu.
 177   After deleting this Driver option, call Var_ChangeDriverOrder to
 178   make sure DriverOrder is in valid state.
 179
 180   @retval EFI_SUCCESS       Load Option is successfully updated.
 181   @retval EFI_NOT_FOUND     Fail to find the driver option want to be deleted.
 182   @return Other value than EFI_SUCCESS if failed to update "Driver Order" EFI
 183           Variable.
 184
 185 **/
 186 EFI_STATUS
 187 Var_DelDriverOption (
 188   VOID
 189   )
 190 {
 191   BM_MENU_ENTRY   *NewMenuEntry;
 192   BM_LOAD_CONTEXT *NewLoadContext;
 193   UINT16          DriverString[12];
 194   EFI_STATUS      Status;
 195   UINTN           Index;
 196   UINTN           Index2;
 197
 198   Status  = EFI_SUCCESS;
 199   Index2  = 0;
 200   for (Index = 0; Index < DriverOptionMenu.MenuNumber; Index++) {
 201     NewMenuEntry = BOpt_GetMenuEntry (&DriverOptionMenu, (Index - Index2));
 202     if (NULL == NewMenuEntry) {
 203       return EFI_NOT_FOUND;
 204     }
 205
 206     NewLoadContext = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
 207     if (!NewLoadContext->Deleted) {
 208       continue;
 209     }
 210
 211     UnicodeSPrint (
 212       DriverString,
 213       sizeof (DriverString),
 214       L"Driver%04x",
 215       NewMenuEntry->OptionNumber
 216       );
 217
 218     EfiLibDeleteVariable (DriverString, &gEfiGlobalVariableGuid);
 219     Index2++;
 220
 221     RemoveEntryList (&NewMenuEntry->Link);
 222     BOpt_DestroyMenuEntry (NewMenuEntry);
 223     NewMenuEntry = NULL;
 224   }
 225
 226   DriverOptionMenu.MenuNumber -= Index2;
 227
 228   Status = Var_ChangeDriverOrder ();
 229   return Status;
 230 }
 231
 232 /**
 233   After any operation on Driver####, there will be a discrepancy in
 234   DriverOrder. Since some are missing but in DriverOrder, while some
 235   are present but are not reflected by DriverOrder. Then a function
 236   rebuild DriverOrder from scratch by content from DriverOptionMenu is
 237   needed.
 238
 239   @retval  EFI_SUCCESS  The driver order is updated successfully.
 240   @return  Other status than EFI_SUCCESS if failed to set the "DriverOrder" EFI Variable.
 241
 242 **/
 243 EFI_STATUS
 244 Var_ChangeDriverOrder (
 245   VOID
 246   )
 247 {
 248   EFI_STATUS    Status;
 249   BM_MENU_ENTRY *NewMenuEntry;
 250   UINT16        *DriverOrderList;
 251   UINT16        *DriverOrderListPtr;
 252   UINTN         DriverOrderListSize;
 253   UINTN         Index;
 254
 255   DriverOrderList     = NULL;
 256   DriverOrderListSize = 0;
 257
 258   //
 259   // First check whether DriverOrder is present in current configuration
 260   //
 261   DriverOrderList = BdsLibGetVariableAndSize (
 262                       L"DriverOrder",
 263                       &gEfiGlobalVariableGuid,
 264                       &DriverOrderListSize
 265                       );
 266
 267   //
 268   // If exists, delete it to hold new DriverOrder
 269   //
 270   if (DriverOrderList != NULL) {
 271     EfiLibDeleteVariable (L"DriverOrder", &gEfiGlobalVariableGuid);
 272     FreePool (DriverOrderList);
 273     DriverOrderList = NULL;
 274   }
 275
 276   DriverOrderListSize = DriverOptionMenu.MenuNumber;
 277
 278   if (DriverOrderListSize > 0) {
 279     DriverOrderList = AllocateZeroPool (DriverOrderListSize * sizeof (UINT16));
 280     ASSERT (DriverOrderList != NULL);
 281     DriverOrderListPtr = DriverOrderList;
 282
 283     //
 284     // Get all current used Driver#### from DriverOptionMenu.
 285     // OptionNumber in each BM_LOAD_OPTION is really its
 286     // #### value.
 287     //
 288     for (Index = 0; Index < DriverOrderListSize; Index++) {
 289       NewMenuEntry      = BOpt_GetMenuEntry (&DriverOptionMenu, Index);
 290       *DriverOrderList  = (UINT16) NewMenuEntry->OptionNumber;
 291       DriverOrderList++;
 292     }
 293
 294     DriverOrderList = DriverOrderListPtr;
 295
 296     //
 297     // After building the DriverOrderList, write it back
 298     //
 299     Status = gRT->SetVariable (
 300                     L"DriverOrder",
 301                     &gEfiGlobalVariableGuid,
 302                     VAR_FLAG,
 303                     DriverOrderListSize * sizeof (UINT16),
 304                     DriverOrderList
 305                     );
 306     if (EFI_ERROR (Status)) {
 307       return Status;
 308     }
 309   }
 310   return EFI_SUCCESS;
 311 }
 312
 313 /**
 314   Update the device path of "ConOut", "ConIn" and "ErrOut"
 315   based on the new BaudRate, Data Bits, parity and Stop Bits
 316   set.
 317
 318 **/
 319 VOID
 320 Var_UpdateAllConsoleOption (
 321   VOID
 322   )
 323 {
 324   EFI_DEVICE_PATH_PROTOCOL  *OutDevicePath;
 325   EFI_DEVICE_PATH_PROTOCOL  *InpDevicePath;
 326   EFI_DEVICE_PATH_PROTOCOL  *ErrDevicePath;
 327   EFI_STATUS                Status;
 328
 329   OutDevicePath = EfiLibGetVariable (L"ConOut", &gEfiGlobalVariableGuid);
 330   InpDevicePath = EfiLibGetVariable (L"ConIn", &gEfiGlobalVariableGuid);
 331   ErrDevicePath = EfiLibGetVariable (L"ErrOut", &gEfiGlobalVariableGuid);
 332   if (OutDevicePath != NULL) {
 333     ChangeVariableDevicePath (OutDevicePath);
 334     Status = gRT->SetVariable (
 335                     L"ConOut",
 336                     &gEfiGlobalVariableGuid,
 337                     VAR_FLAG,
 338                     GetDevicePathSize (OutDevicePath),
 339                     OutDevicePath
 340                     );
 341     ASSERT (!EFI_ERROR (Status));
 342   }
 343
 344   if (InpDevicePath != NULL) {
 345     ChangeVariableDevicePath (InpDevicePath);
 346     Status = gRT->SetVariable (
 347                     L"ConIn",
 348                     &gEfiGlobalVariableGuid,
 349                     VAR_FLAG,
 350                     GetDevicePathSize (InpDevicePath),
 351                     InpDevicePath
 352                     );
 353     ASSERT (!EFI_ERROR (Status));
 354   }
 355
 356   if (ErrDevicePath != NULL) {
 357     ChangeVariableDevicePath (ErrDevicePath);
 358     Status = gRT->SetVariable (
 359                     L"ErrOut",
 360                     &gEfiGlobalVariableGuid,
 361                     VAR_FLAG,
 362                     GetDevicePathSize (ErrDevicePath),
 363                     ErrDevicePath
 364                     );
 365     ASSERT (!EFI_ERROR (Status));
 366   }
 367 }
 368
 369 /**
 370   This function delete and build multi-instance device path for
 371   specified type of console device.
 372
 373   This function clear the EFI variable defined by ConsoleName and
 374   gEfiGlobalVariableGuid. It then build the multi-instance device
 375   path by appending the device path of the Console (In/Out/Err) instance
 376   in ConsoleMenu. Then it scan all corresponding console device by
 377   scanning Terminal (built from device supporting Serial I/O instances)
 378   devices in TerminalMenu. At last, it save a EFI variable specifed
 379   by ConsoleName and gEfiGlobalVariableGuid.
 380
 381   @param ConsoleName     The name for the console device type. They are
 382                          usually "ConIn", "ConOut" and "ErrOut".
 383   @param ConsoleMenu     The console memu which is a list of console devices.
 384   @param UpdatePageId    The flag specifying which type of console device
 385                          to be processed.
 386
 387   @retval EFI_SUCCESS    The function complete successfully.
 388   @return The EFI variable can not be saved. See gRT->SetVariable for detail return information.
 389
 390 **/
 391 EFI_STATUS
 392 Var_UpdateConsoleOption (
 393   IN UINT16                     *ConsoleName,
 394   IN BM_MENU_OPTION             *ConsoleMenu,
 395   IN UINT16                     UpdatePageId
 396   )
 397 {
 398   EFI_DEVICE_PATH_PROTOCOL  *ConDevicePath;
 399   BM_MENU_ENTRY             *NewMenuEntry;
 400   BM_CONSOLE_CONTEXT        *NewConsoleContext;
 401   BM_TERMINAL_CONTEXT       *NewTerminalContext;
 402   EFI_STATUS                Status;
 403   VENDOR_DEVICE_PATH        Vendor;
 404   EFI_DEVICE_PATH_PROTOCOL  *TerminalDevicePath;
 405   UINTN                     Index;
 406
 407   ConDevicePath = EfiLibGetVariable (ConsoleName, &gEfiGlobalVariableGuid);
 408   if (ConDevicePath != NULL) {
 409     EfiLibDeleteVariable (ConsoleName, &gEfiGlobalVariableGuid);
 410     FreePool (ConDevicePath);
 411     ConDevicePath = NULL;
 412   };
 413
 414   //
 415   // First add all console input device from console input menu
 416   //
 417   for (Index = 0; Index < ConsoleMenu->MenuNumber; Index++) {
 418     NewMenuEntry = BOpt_GetMenuEntry (ConsoleMenu, Index);
 419
 420     NewConsoleContext = (BM_CONSOLE_CONTEXT *) NewMenuEntry->VariableContext;
 421     if (NewConsoleContext->IsActive) {
 422       ConDevicePath = AppendDevicePathInstance (
 423                         ConDevicePath,
 424                         NewConsoleContext->DevicePath
 425                         );
 426     }
 427   }
 428
 429   for (Index = 0; Index < TerminalMenu.MenuNumber; Index++) {
 430     NewMenuEntry = BOpt_GetMenuEntry (&TerminalMenu, Index);
 431
 432     NewTerminalContext = (BM_TERMINAL_CONTEXT *) NewMenuEntry->VariableContext;
 433     if (((NewTerminalContext->IsConIn != 0) && (UpdatePageId == FORM_CON_IN_ID)) ||
 434         ((NewTerminalContext->IsConOut != 0)  && (UpdatePageId == FORM_CON_OUT_ID)) ||
 435         ((NewTerminalContext->IsStdErr  != 0) && (UpdatePageId == FORM_CON_ERR_ID))
 436         ) {
 437       Vendor.Header.Type    = MESSAGING_DEVICE_PATH;
 438       Vendor.Header.SubType = MSG_VENDOR_DP;
 439
 440       ASSERT (NewTerminalContext->TerminalType < (sizeof (TerminalTypeGuid) / sizeof (TerminalTypeGuid[0])));
 441       CopyMem (
 442         &Vendor.Guid,
 443         &TerminalTypeGuid[NewTerminalContext->TerminalType],
 444         sizeof (EFI_GUID)
 445         );
 446       SetDevicePathNodeLength (&Vendor.Header, sizeof (VENDOR_DEVICE_PATH));
 447       TerminalDevicePath = AppendDevicePathNode (
 448                             NewTerminalContext->DevicePath,
 449                             (EFI_DEVICE_PATH_PROTOCOL *) &Vendor
 450                             );
 451       ASSERT (TerminalDevicePath != NULL);
 452       ChangeTerminalDevicePath (TerminalDevicePath, TRUE);
 453       ConDevicePath = AppendDevicePathInstance (
 454                         ConDevicePath,
 455                         TerminalDevicePath
 456                         );
 457     }
 458   }
 459
 460   if (ConDevicePath != NULL) {
 461     Status = gRT->SetVariable (
 462                     ConsoleName,
 463                     &gEfiGlobalVariableGuid,
 464                     VAR_FLAG,
 465                     GetDevicePathSize (ConDevicePath),
 466                     ConDevicePath
 467                     );
 468     if (EFI_ERROR (Status)) {
 469       return Status;
 470     }
 471   }
 472
 473   return EFI_SUCCESS;
 474
 475 }
 476
 477 /**
 478   This function delete and build multi-instance device path ConIn
 479   console device.
 480
 481   @retval EFI_SUCCESS    The function complete successfully.
 482   @return The EFI variable can not be saved. See gRT->SetVariable for detail return information.
 483 **/
 484 EFI_STATUS
 485 Var_UpdateConsoleInpOption (
 486   VOID
 487   )
 488 {
 489   return Var_UpdateConsoleOption (L"ConIn", &ConsoleInpMenu, FORM_CON_IN_ID);
 490 }
 491
 492 /**
 493   This function delete and build multi-instance device path ConOut
 494   console device.
 495
 496   @retval EFI_SUCCESS    The function complete successfully.
 497   @return The EFI variable can not be saved. See gRT->SetVariable for detail return information.
 498 **/
 499 EFI_STATUS
 500 Var_UpdateConsoleOutOption (
 501   VOID
 502   )
 503 {
 504   return Var_UpdateConsoleOption (L"ConOut", &ConsoleOutMenu, FORM_CON_OUT_ID);
 505 }
 506
 507 /**
 508   This function delete and build multi-instance device path ErrOut
 509   console device.
 510
 511   @retval EFI_SUCCESS    The function complete successfully.
 512   @return The EFI variable can not be saved. See gRT->SetVariable for detail return information.
 513 **/
 514 EFI_STATUS
 515 Var_UpdateErrorOutOption (
 516   VOID
 517   )
 518 {
 519   return Var_UpdateConsoleOption (L"ErrOut", &ConsoleErrMenu, FORM_CON_ERR_ID);
 520 }
 521
 522 /**
 523   This function create a currently loaded Drive Option from
 524   the BMM. It then appends this Driver Option to the end of
 525   the "DriverOrder" list. It append this Driver Opotion to the end
 526   of DriverOptionMenu.
 527
 528   @param CallbackData    The BMM context data.
 529   @param HiiHandle       The HII handle associated with the BMM formset.
 530   @param DescriptionData The description of this driver option.
 531   @param OptionalData    The optional load option.
 532   @param ForceReconnect  If to force reconnect.
 533
 534   @retval EFI_OUT_OF_RESOURCES If not enought memory to complete the operation.
 535   @retval EFI_SUCCESS          If function completes successfully.
 536
 537 **/
 538 EFI_STATUS
 539 Var_UpdateDriverOption (
 540   IN  BMM_CALLBACK_DATA         *CallbackData,
 541   IN  EFI_HII_HANDLE            HiiHandle,
 542   IN  UINT16                    *DescriptionData,
 543   IN  UINT16                    *OptionalData,
 544   IN  UINT8                     ForceReconnect
 545   )
 546 {
 547   UINT16          Index;
 548   UINT16          *DriverOrderList;
 549   UINT16          *NewDriverOrderList;
 550   UINT16          DriverString[12];
 551   UINTN           DriverOrderListSize;
 552   VOID            *Buffer;
 553   UINTN           BufferSize;
 554   UINT8           *Ptr;
 555   BM_MENU_ENTRY   *NewMenuEntry;
 556   BM_LOAD_CONTEXT *NewLoadContext;
 557   BOOLEAN         OptionalDataExist;
 558   EFI_STATUS      Status;
 559
 560   OptionalDataExist = FALSE;
 561
 562   Index             = BOpt_GetDriverOptionNumber ();
 563   UnicodeSPrint (
 564     DriverString,
 565     sizeof (DriverString),
 566     L"Driver%04x",
 567     Index
 568     );
 569
 570   if (*DescriptionData == 0x0000) {
 571     StrCpy (DescriptionData, DriverString);
 572   }
 573
 574   BufferSize = sizeof (UINT32) + sizeof (UINT16) + StrSize (DescriptionData);
 575   BufferSize += GetDevicePathSize (CallbackData->LoadContext->FilePathList);
 576
 577   if (*OptionalData != 0x0000) {
 578     OptionalDataExist = TRUE;
 579     BufferSize += StrSize (OptionalData);
 580   }
 581
 582   Buffer = AllocateZeroPool (BufferSize);
 583   if (NULL == Buffer) {
 584     return EFI_OUT_OF_RESOURCES;
 585   }
 586
 587   NewMenuEntry = BOpt_CreateMenuEntry (BM_LOAD_CONTEXT_SELECT);
 588   if (NULL == NewMenuEntry) {
 589     FreePool (Buffer);
 590     return EFI_OUT_OF_RESOURCES;
 591   }
 592
 593   NewLoadContext                  = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
 594   NewLoadContext->Deleted         = FALSE;
 595   NewLoadContext->LoadOptionSize  = BufferSize;
 596   Ptr = (UINT8 *) Buffer;
 597   NewLoadContext->LoadOption = Ptr;
 598   *((UINT32 *) Ptr) = LOAD_OPTION_ACTIVE | (ForceReconnect << 1);
 599   NewLoadContext->Attributes = *((UINT32 *) Ptr);
 600   NewLoadContext->IsActive = TRUE;
 601   NewLoadContext->ForceReconnect = (BOOLEAN) (NewLoadContext->Attributes & LOAD_OPTION_FORCE_RECONNECT);
 602
 603   Ptr += sizeof (UINT32);
 604   *((UINT16 *) Ptr) = (UINT16) GetDevicePathSize (CallbackData->LoadContext->FilePathList);
 605   NewLoadContext->FilePathListLength = *((UINT16 *) Ptr);
 606
 607   Ptr += sizeof (UINT16);
 608   CopyMem (
 609     Ptr,
 610     DescriptionData,
 611     StrSize (DescriptionData)
 612     );
 613
 614   NewLoadContext->Description = AllocateZeroPool (StrSize (DescriptionData));
 615   ASSERT (NewLoadContext->Description != NULL);
 616   NewMenuEntry->DisplayString = NewLoadContext->Description;
 617   CopyMem (
 618     NewLoadContext->Description,
 619     (VOID *) Ptr,
 620     StrSize (DescriptionData)
 621     );
 622
 623   Ptr += StrSize (DescriptionData);
 624   CopyMem (
 625     Ptr,
 626     CallbackData->LoadContext->FilePathList,
 627     GetDevicePathSize (CallbackData->LoadContext->FilePathList)
 628     );
 629
 630   NewLoadContext->FilePathList = AllocateZeroPool (GetDevicePathSize (CallbackData->LoadContext->FilePathList));
 631   ASSERT (NewLoadContext->FilePathList != NULL);
 632
 633   CopyMem (
 634     NewLoadContext->FilePathList,
 635     (VOID *) Ptr,
 636     GetDevicePathSize (CallbackData->LoadContext->FilePathList)
 637     );
 638
 639   NewMenuEntry->HelpString    = DevicePathToStr (NewLoadContext->FilePathList);
 640   NewMenuEntry->OptionNumber  = Index;
 641   NewMenuEntry->DisplayStringToken = GetStringTokenFromDepository (
 642                                       CallbackData,
 643                                       DriverOptionStrDepository
 644                                       );
 645   HiiLibNewString (HiiHandle, &NewMenuEntry->DisplayStringToken, NewMenuEntry->DisplayString);
 646
 647   NewMenuEntry->HelpStringToken = GetStringTokenFromDepository (
 648                                     CallbackData,
 649                                     DriverOptionHelpStrDepository
 650                                     );
 651   HiiLibNewString (HiiHandle, &NewMenuEntry->HelpStringToken, NewMenuEntry->HelpString);
 652
 653   if (OptionalDataExist) {
 654     Ptr += (UINT8) GetDevicePathSize (CallbackData->LoadContext->FilePathList);
 655
 656     CopyMem (
 657       Ptr,
 658       OptionalData,
 659       StrSize (OptionalData)
 660       );
 661   }
 662
 663   Status = gRT->SetVariable (
 664                   DriverString,
 665                   &gEfiGlobalVariableGuid,
 666                   VAR_FLAG,
 667                   BufferSize,
 668                   Buffer
 669                   );
 670   ASSERT_EFI_ERROR (Status);
 671   DriverOrderList = BdsLibGetVariableAndSize (
 672                       L"DriverOrder",
 673                       &gEfiGlobalVariableGuid,
 674                       &DriverOrderListSize
 675                       );
 676   NewDriverOrderList = AllocateZeroPool (DriverOrderListSize + sizeof (UINT16));
 677   ASSERT (NewDriverOrderList != NULL);
 678   CopyMem (NewDriverOrderList, DriverOrderList, DriverOrderListSize);
 679   NewDriverOrderList[DriverOrderListSize / sizeof (UINT16)] = Index;
 680   if (DriverOrderList != NULL) {
 681     EfiLibDeleteVariable (L"DriverOrder", &gEfiGlobalVariableGuid);
 682   }
 683
 684   Status = gRT->SetVariable (
 685                   L"DriverOrder",
 686                   &gEfiGlobalVariableGuid,
 687                   VAR_FLAG,
 688                   DriverOrderListSize + sizeof (UINT16),
 689                   NewDriverOrderList
 690                   );
 691   ASSERT_EFI_ERROR (Status);
 692   if (DriverOrderList != NULL) {
 693     FreePool (DriverOrderList);
 694   }
 695   DriverOrderList = NULL;
 696   FreePool (NewDriverOrderList);
 697   InsertTailList (&DriverOptionMenu.Head, &NewMenuEntry->Link);
 698   DriverOptionMenu.MenuNumber++;
 699
 700   *DescriptionData  = 0x0000;
 701   *OptionalData     = 0x0000;
 702   return EFI_SUCCESS;
 703 }
 704
 705 /**
 706   This function create a currently loaded Boot Option from
 707   the BMM. It then appends this Boot Option to the end of
 708   the "BootOrder" list. It also append this Boot Opotion to the end
 709   of BootOptionMenu.
 710
 711   @param CallbackData    The BMM context data.
 712   @param NvRamMap        The file explorer formset internal state.
 713
 714   @retval EFI_OUT_OF_RESOURCES If not enought memory to complete the operation.
 715   @retval EFI_SUCCESS          If function completes successfully.
 716
 717 **/
 718 EFI_STATUS
 719 Var_UpdateBootOption (
 720   IN  BMM_CALLBACK_DATA                   *CallbackData,
 721   IN  FILE_EXPLORER_NV_DATA               *NvRamMap
 722   )
 723 {
 724   UINT16          *BootOrderList;
 725   UINT16          *NewBootOrderList;
 726   UINTN           BootOrderListSize;
 727   UINT16          BootString[10];
 728   VOID            *Buffer;
 729   UINTN           BufferSize;
 730   UINT8           *Ptr;
 731   UINT16          Index;
 732   BM_MENU_ENTRY   *NewMenuEntry;
 733   BM_LOAD_CONTEXT *NewLoadContext;
 734   BOOLEAN         OptionalDataExist;
 735   EFI_STATUS      Status;
 736
 737   OptionalDataExist = FALSE;
 738
 739   Index = BOpt_GetBootOptionNumber () ;
 740   UnicodeSPrint (BootString, sizeof (BootString), L"Boot%04x", Index);
 741
 742   if (NvRamMap->DescriptionData[0] == 0x0000) {
 743     StrCpy (NvRamMap->DescriptionData, BootString);
 744   }
 745
 746   BufferSize = sizeof (UINT32) + sizeof (UINT16) + StrSize (NvRamMap->DescriptionData);
 747   BufferSize += GetDevicePathSize (CallbackData->LoadContext->FilePathList);
 748
 749   if (NvRamMap->OptionalData[0] != 0x0000) {
 750     OptionalDataExist = TRUE;
 751     BufferSize += StrSize (NvRamMap->OptionalData);
 752   }
 753
 754   Buffer = AllocateZeroPool (BufferSize);
 755   if (NULL == Buffer) {
 756     return EFI_OUT_OF_RESOURCES;
 757   }
 758
 759   NewMenuEntry = BOpt_CreateMenuEntry (BM_LOAD_CONTEXT_SELECT);
 760   if (NULL == NewMenuEntry) {
 761     return EFI_OUT_OF_RESOURCES;
 762   }
 763
 764   NewLoadContext                  = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
 765   NewLoadContext->Deleted         = FALSE;
 766   NewLoadContext->LoadOptionSize  = BufferSize;
 767   Ptr = (UINT8 *) Buffer;
 768   NewLoadContext->LoadOption = Ptr;
 769   *((UINT32 *) Ptr) = LOAD_OPTION_ACTIVE;
 770   NewLoadContext->Attributes = *((UINT32 *) Ptr);
 771   NewLoadContext->IsActive = TRUE;
 772   NewLoadContext->ForceReconnect = (BOOLEAN) (NewLoadContext->Attributes & LOAD_OPTION_FORCE_RECONNECT);
 773
 774   Ptr += sizeof (UINT32);
 775   *((UINT16 *) Ptr) = (UINT16) GetDevicePathSize (CallbackData->LoadContext->FilePathList);
 776   NewLoadContext->FilePathListLength = *((UINT16 *) Ptr);
 777   Ptr += sizeof (UINT16);
 778
 779   CopyMem (
 780     Ptr,
 781     NvRamMap->DescriptionData,
 782     StrSize (NvRamMap->DescriptionData)
 783     );
 784
 785   NewLoadContext->Description = AllocateZeroPool (StrSize (NvRamMap->DescriptionData));
 786   ASSERT (NewLoadContext->Description != NULL);
 787
 788   NewMenuEntry->DisplayString = NewLoadContext->Description;
 789   CopyMem (
 790     NewLoadContext->Description,
 791     (VOID *) Ptr,
 792     StrSize (NvRamMap->DescriptionData)
 793     );
 794
 795   Ptr += StrSize (NvRamMap->DescriptionData);
 796   CopyMem (
 797     Ptr,
 798     CallbackData->LoadContext->FilePathList,
 799     GetDevicePathSize (CallbackData->LoadContext->FilePathList)
 800     );
 801
 802   NewLoadContext->FilePathList = AllocateZeroPool (GetDevicePathSize (CallbackData->LoadContext->FilePathList));
 803   ASSERT (NewLoadContext->FilePathList != NULL);
 804
 805   CopyMem (
 806     NewLoadContext->FilePathList,
 807     (VOID *) Ptr,
 808     GetDevicePathSize (CallbackData->LoadContext->FilePathList)
 809     );
 810
 811   NewMenuEntry->HelpString    = DevicePathToStr (NewLoadContext->FilePathList);
 812   NewMenuEntry->OptionNumber  = Index;
 813   NewMenuEntry->DisplayStringToken = GetStringTokenFromDepository (
 814                                       CallbackData,
 815                                       BootOptionStrDepository
 816                                       );
 817   HiiLibNewString (CallbackData->FeHiiHandle, &NewMenuEntry->DisplayStringToken, NewMenuEntry->DisplayString);
 818
 819   NewMenuEntry->HelpStringToken = GetStringTokenFromDepository (
 820                                     CallbackData,
 821                                     BootOptionHelpStrDepository
 822                                     );
 823   HiiLibNewString (CallbackData->FeHiiHandle, &NewMenuEntry->HelpStringToken, NewMenuEntry->HelpString);
 824
 825   if (OptionalDataExist) {
 826     Ptr += (UINT8) GetDevicePathSize (CallbackData->LoadContext->FilePathList);
 827
 828     CopyMem (Ptr, NvRamMap->OptionalData, StrSize (NvRamMap->OptionalData));
 829   }
 830
 831   Status = gRT->SetVariable (
 832                   BootString,
 833                   &gEfiGlobalVariableGuid,
 834                   VAR_FLAG,
 835                   BufferSize,
 836                   Buffer
 837                   );
 838   ASSERT_EFI_ERROR (Status);
 839
 840   BootOrderList = BdsLibGetVariableAndSize (
 841                     L"BootOrder",
 842                     &gEfiGlobalVariableGuid,
 843                     &BootOrderListSize
 844                     );
 845
 846   NewBootOrderList = AllocateZeroPool (BootOrderListSize + sizeof (UINT16));
 847   ASSERT (NewBootOrderList != NULL);
 848   CopyMem (NewBootOrderList, BootOrderList, BootOrderListSize);
 849   NewBootOrderList[BootOrderListSize / sizeof (UINT16)] = Index;
 850
 851   if (BootOrderList != NULL) {
 852     EfiLibDeleteVariable (L"BootOrder", &gEfiGlobalVariableGuid);
 853     FreePool (BootOrderList);
 854   }
 855
 856   Status = gRT->SetVariable (
 857                   L"BootOrder",
 858                   &gEfiGlobalVariableGuid,
 859                   VAR_FLAG,
 860                   BootOrderListSize + sizeof (UINT16),
 861                   NewBootOrderList
 862                   );
 863   ASSERT_EFI_ERROR (Status);
 864
 865   FreePool (NewBootOrderList);
 866   NewBootOrderList = NULL;
 867   InsertTailList (&BootOptionMenu.Head, &NewMenuEntry->Link);
 868   BootOptionMenu.MenuNumber++;
 869
 870   NvRamMap->DescriptionData[0]  = 0x0000;
 871   NvRamMap->OptionalData[0]     = 0x0000;
 872   return EFI_SUCCESS;
 873 }
 874
 875 /**
 876   This function update the "BootNext" EFI Variable. If there is
 877   no "BootNext" specified in BMM, this EFI Variable is deleted.
 878   It also update the BMM context data specified the "BootNext"
 879   vaule.
 880
 881   @param CallbackData    The BMM context data.
 882
 883   @retval EFI_SUCCESS    The function complete successfully.
 884   @return                The EFI variable can be saved. See gRT->SetVariable
 885                          for detail return information.
 886
 887 **/
 888 EFI_STATUS
 889 Var_UpdateBootNext (
 890   IN BMM_CALLBACK_DATA            *CallbackData
 891   )
 892 {
 893   BM_MENU_ENTRY     *NewMenuEntry;
 894   BM_LOAD_CONTEXT   *NewLoadContext;
 895   BMM_FAKE_NV_DATA  *CurrentFakeNVMap;
 896   UINT16            Index;
 897   EFI_STATUS        Status;
 898
 899   Status            = EFI_SUCCESS;
 900   CurrentFakeNVMap  = &CallbackData->BmmFakeNvData;
 901   for (Index = 0; Index < BootOptionMenu.MenuNumber; Index++) {
 902     NewMenuEntry = BOpt_GetMenuEntry (&BootOptionMenu, Index);
 903     ASSERT (NULL != NewMenuEntry);
 904
 905     NewLoadContext              = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
 906     NewLoadContext->IsBootNext  = FALSE;
 907   }
 908
 909   if (CurrentFakeNVMap->BootNext == BootOptionMenu.MenuNumber) {
 910     EfiLibDeleteVariable (L"BootNext", &gEfiGlobalVariableGuid);
 911     return EFI_SUCCESS;
 912   }
 913
 914   NewMenuEntry = BOpt_GetMenuEntry (
 915                   &BootOptionMenu,
 916                   CurrentFakeNVMap->BootNext
 917                   );
 918   ASSERT (NewMenuEntry != NULL);
 919
 920   NewLoadContext = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
 921   Status = gRT->SetVariable (
 922                   L"BootNext",
 923                   &gEfiGlobalVariableGuid,
 924                   VAR_FLAG,
 925                   sizeof (UINT16),
 926                   &NewMenuEntry->OptionNumber
 927                   );
 928   NewLoadContext->IsBootNext              = TRUE;
 929   CallbackData->BmmOldFakeNVData.BootNext = CurrentFakeNVMap->BootNext;
 930   return Status;
 931 }
 932
 933 /**
 934   This function update the "BootOrder" EFI Variable based on
 935   BMM Formset's NV map. It then refresh BootOptionMenu
 936   with the new "BootOrder" list.
 937
 938   @param CallbackData    The BMM context data.
 939
 940   @retval EFI_SUCCESS             The function complete successfully.
 941   @retval EFI_OUT_OF_RESOURCES    Not enough memory to complete the function.
 942   @return The EFI variable can not be saved. See gRT->SetVariable for detail return information.
 943
 944 **/
 945 EFI_STATUS
 946 Var_UpdateBootOrder (
 947   IN BMM_CALLBACK_DATA            *CallbackData
 948   )
 949 {
 950   EFI_STATUS  Status;
 951   UINT16      Index;
 952   UINT16      *BootOrderList;
 953   UINT16      *NewBootOrderList;
 954   UINTN       BootOrderListSize;
 955
 956   BootOrderList     = NULL;
 957   BootOrderListSize = 0;
 958
 959   //
 960   // First check whether BootOrder is present in current configuration
 961   //
 962   BootOrderList = BdsLibGetVariableAndSize (
 963                     L"BootOrder",
 964                     &gEfiGlobalVariableGuid,
 965                     &BootOrderListSize
 966                     );
 967
 968   NewBootOrderList = AllocateZeroPool (BootOrderListSize);
 969   if (NewBootOrderList == NULL) {
 970     return EFI_OUT_OF_RESOURCES;
 971   }
 972
 973   //
 974   // If exists, delete it to hold new BootOrder
 975   //
 976   if (BootOrderList != NULL) {
 977     EfiLibDeleteVariable (L"BootOrder", &gEfiGlobalVariableGuid);
 978     FreePool (BootOrderList);
 979   }
 980
 981   ASSERT (BootOptionMenu.MenuNumber <= (sizeof (CallbackData->BmmFakeNvData.OptionOrder) / sizeof (CallbackData->BmmFakeNvData.OptionOrder[0])));
 982   for (Index = 0; Index < BootOptionMenu.MenuNumber; Index++) {
 983     NewBootOrderList[Index] = (UINT16) (CallbackData->BmmFakeNvData.OptionOrder[Index] - 1);
 984   }
 985
 986   Status = gRT->SetVariable (
 987                   L"BootOrder",
 988                   &gEfiGlobalVariableGuid,
 989                   VAR_FLAG,
 990                   BootOrderListSize,
 991                   NewBootOrderList
 992                   );
 993   FreePool (NewBootOrderList);
 994   if (EFI_ERROR (Status)) {
 995     return Status;
 996   }
 997
 998   BOpt_FreeMenu (&BootOptionMenu);
 999   BOpt_GetBootOptions (CallbackData);
1000
1001   return EFI_SUCCESS;
1002
1003 }
1004
1005 /**
1006   This function update the "DriverOrder" EFI Variable based on
1007   BMM Formset's NV map. It then refresh DriverOptionMenu
1008   with the new "DriverOrder" list.
1009
1010   @param CallbackData    The BMM context data.
1011
1012   @retval EFI_SUCCESS           The function complete successfully.
1013   @retval EFI_OUT_OF_RESOURCES  Not enough memory to complete the function.
1014   @return The EFI variable can not be saved. See gRT->SetVariable for detail return information.
1015
1016 **/
1017 EFI_STATUS
1018 Var_UpdateDriverOrder (
1019   IN BMM_CALLBACK_DATA            *CallbackData
1020   )
1021 {
1022   EFI_STATUS  Status;
1023   UINT16      Index;
1024   UINT16      *DriverOrderList;
1025   UINT16      *NewDriverOrderList;
1026   UINTN       DriverOrderListSize;
1027
1028   DriverOrderList     = NULL;
1029   DriverOrderListSize = 0;
1030
1031   //
1032   // First check whether DriverOrder is present in current configuration
1033   //
1034   DriverOrderList = BdsLibGetVariableAndSize (
1035                       L"DriverOrder",
1036                       &gEfiGlobalVariableGuid,
1037                       &DriverOrderListSize
1038                       );
1039
1040   NewDriverOrderList = AllocateZeroPool (DriverOrderListSize);
1041
1042   if (NewDriverOrderList == NULL) {
1043     return EFI_OUT_OF_RESOURCES;
1044   }
1045   //
1046   // If exists, delete it to hold new DriverOrder
1047   //
1048   if (DriverOrderList != NULL) {
1049     EfiLibDeleteVariable (L"DriverOrder", &gEfiGlobalVariableGuid);
1050     FreePool (DriverOrderList);
1051   }
1052
1053   ASSERT (DriverOrderListSize <= (sizeof (CallbackData->BmmFakeNvData.OptionOrder) / sizeof (CallbackData->BmmFakeNvData.OptionOrder[0])));
1054   for (Index = 0; Index < DriverOrderListSize; Index++) {
1055     NewDriverOrderList[Index] = (UINT16) (CallbackData->BmmFakeNvData.OptionOrder[Index] - 1);
1056   }
1057
1058   Status = gRT->SetVariable (
1059                   L"DriverOrder",
1060                   &gEfiGlobalVariableGuid,
1061                   VAR_FLAG,
1062                   DriverOrderListSize,
1063                   NewDriverOrderList
1064                   );
1065   if (EFI_ERROR (Status)) {
1066     return Status;
1067   }
1068
1069   BOpt_FreeMenu (&DriverOptionMenu);
1070   BOpt_GetDriverOptions (CallbackData);
1071   return EFI_SUCCESS;
1072 }
1073
1074 /**
1075   Update the legacy BBS boot option. L"LegacyDevOrder" and EfiLegacyDevOrderGuid EFI Variable
1076   is udpated with the new Legacy Boot order. The EFI Variable of "Boot####" and gEfiGlobalVariableGuid
1077   is also updated.
1078
1079   @param CallbackData    The context data for BMM.
1080
1081   @return EFI_SUCCESS           The function completed successfully.
1082   @retval EFI_NOT_FOUND         If L"LegacyDevOrder" and EfiLegacyDevOrderGuid EFI Variable can be found.
1083   @retval EFI_OUT_OF_RESOURCES  Fail to allocate memory resource
1084 **/
1085 EFI_STATUS
1086 Var_UpdateBBSOption (
1087   IN BMM_CALLBACK_DATA            *CallbackData
1088   )
1089 {
1090   UINTN                       Index;
1091   UINTN                       Index2;
1092   VOID                        *BootOptionVar;
1093   CHAR16                      VarName[100];
1094   UINTN                       OptionSize;
1095   UINT8                       *Ptr;
1096   EFI_STATUS                  Status;
1097   CHAR16                      DescString[100];
1098   CHAR8                       DescAsciiString[100];
1099   UINTN                       NewOptionSize;
1100   UINT8                       *NewOptionPtr;
1101   UINT8                       *TempPtr;
1102   UINT32                      *Attribute;
1103   BM_MENU_OPTION              *OptionMenu;
1104   BM_LEGACY_DEVICE_CONTEXT    *LegacyDeviceContext;
1105   UINT8                       *LegacyDev;
1106   UINT8                       *VarData;
1107   UINTN                       VarSize;
1108   BM_MENU_ENTRY               *NewMenuEntry;
1109   BM_LEGACY_DEV_ORDER_CONTEXT *DevOrder;
1110   UINT8                       *OriginalPtr;
1111   UINT8                       *DisMap;
1112   UINTN                       Pos;
1113   UINTN                       Bit;
1114   UINT16                      *NewOrder;
1115   UINT16                      Tmp;
1116
1117   LegacyDeviceContext = NULL;
1118   DisMap              = NULL;
1119   NewOrder            = NULL;
1120
1121   if (FORM_SET_FD_ORDER_ID == CallbackData->BmmPreviousPageId) {
1122     OptionMenu            = (BM_MENU_OPTION *) &LegacyFDMenu;
1123     LegacyDev             = CallbackData->BmmFakeNvData.LegacyFD;
1124     CallbackData->BbsType = BBS_FLOPPY;
1125   } else {
1126     if (FORM_SET_HD_ORDER_ID == CallbackData->BmmPreviousPageId) {
1127       OptionMenu            = (BM_MENU_OPTION *) &LegacyHDMenu;
1128       LegacyDev             = CallbackData->BmmFakeNvData.LegacyHD;
1129       CallbackData->BbsType = BBS_HARDDISK;
1130     } else {
1131       if (FORM_SET_CD_ORDER_ID == CallbackData->BmmPreviousPageId) {
1132         OptionMenu            = (BM_MENU_OPTION *) &LegacyCDMenu;
1133         LegacyDev             = CallbackData->BmmFakeNvData.LegacyCD;
1134         CallbackData->BbsType = BBS_CDROM;
1135       } else {
1136         if (FORM_SET_NET_ORDER_ID == CallbackData->BmmPreviousPageId) {
1137           OptionMenu            = (BM_MENU_OPTION *) &LegacyNETMenu;
1138           LegacyDev             = CallbackData->BmmFakeNvData.LegacyNET;
1139           CallbackData->BbsType = BBS_EMBED_NETWORK;
1140         } else {
1141           OptionMenu            = (BM_MENU_OPTION *) &LegacyBEVMenu;
1142           LegacyDev             = CallbackData->BmmFakeNvData.LegacyBEV;
1143           CallbackData->BbsType = BBS_BEV_DEVICE;
1144         }
1145       }
1146     }
1147   }
1148
1149   DisMap  = CallbackData->BmmOldFakeNVData.DisableMap;
1150   Status  = EFI_SUCCESS;
1151
1152   //
1153   // Find the first device's context
1154   // If all devices are disabled( 0xFF == LegacyDev[0]), LegacyDeviceContext can be set to any VariableContext
1155   // because we just use it to fill the desc string, and user can not see the string in UI
1156   //
1157   for (Index = 0; Index < OptionMenu->MenuNumber; Index++) {
1158     NewMenuEntry        = BOpt_GetMenuEntry (OptionMenu, Index);
1159     LegacyDeviceContext = (BM_LEGACY_DEVICE_CONTEXT *) NewMenuEntry->VariableContext;
1160     if (0xFF != LegacyDev[0] && LegacyDev[0] == LegacyDeviceContext->Index) {
1161       DEBUG ((DEBUG_ERROR, "DescStr: %s\n", LegacyDeviceContext->Description));
1162       break;
1163     }
1164   }
1165   //
1166   // Update the Variable "LegacyDevOrder"
1167   //
1168   VarData = (UINT8 *) BdsLibGetVariableAndSize (
1169                         VAR_LEGACY_DEV_ORDER,
1170                         &EfiLegacyDevOrderGuid,
1171                         &VarSize
1172                         );
1173
1174   if (VarData == NULL) {
1175     return EFI_NOT_FOUND;
1176   }
1177
1178   OriginalPtr = VarData;
1179   DevOrder    = (BM_LEGACY_DEV_ORDER_CONTEXT *) VarData;
1180
1181   while (VarData < VarData + VarSize) {
1182     if (DevOrder->BbsType == CallbackData->BbsType) {
1183       break;
1184     }
1185
1186     VarData += sizeof (BBS_TYPE);
1187     VarData += *(UINT16 *) VarData;
1188     DevOrder = (BM_LEGACY_DEV_ORDER_CONTEXT *) VarData;
1189   }
1190
1191   if (VarData >= VarData + VarSize) {
1192     FreePool (OriginalPtr);
1193     return EFI_NOT_FOUND;
1194   }
1195
1196   NewOrder = (UINT16 *) AllocateZeroPool (DevOrder->Length - sizeof (UINT16));
1197   if (NewOrder == NULL) {
1198     FreePool (VarData);
1199     return EFI_OUT_OF_RESOURCES;
1200   }
1201
1202   for (Index = 0; Index < OptionMenu->MenuNumber; Index++) {
1203     if (0xFF == LegacyDev[Index]) {
1204       break;
1205     }
1206
1207     NewOrder[Index] = LegacyDev[Index];
1208   }
1209   //
1210   // Only the enable/disable state of each boot device with same device type can be changed,
1211   // so we can count on the index information in DevOrder.
1212   // DisMap bit array is the only reliable source to check a device's en/dis state,
1213   // so we use DisMap to set en/dis state of each item in NewOrder array
1214   //
1215   for (Index2 = 0; Index2 < OptionMenu->MenuNumber; Index2++) {
1216     Tmp = *(UINT16 *) ((UINT8 *) DevOrder + sizeof (BBS_TYPE) + sizeof (UINT16) + Index2 * sizeof (UINT16));
1217     Tmp &= 0xFF;
1218     Pos = Tmp / 8;
1219     Bit = 7 - (Tmp % 8);
1220     if ((DisMap[Pos] & (1 << Bit)) != 0) {
1221       NewOrder[Index] = (UINT16) (0xFF00 | Tmp);
1222       Index++;
1223     }
1224   }
1225
1226   CopyMem (
1227     (UINT8 *) DevOrder + sizeof (BBS_TYPE) + sizeof (UINT16),
1228     NewOrder,
1229     DevOrder->Length - sizeof (UINT16)
1230     );
1231   FreePool (NewOrder);
1232
1233   Status = gRT->SetVariable (
1234                   VAR_LEGACY_DEV_ORDER,
1235                   &EfiLegacyDevOrderGuid,
1236                   VAR_FLAG,
1237                   VarSize,
1238                   OriginalPtr
1239                   );
1240
1241   FreePool (OriginalPtr);
1242
1243   //
1244   // Update Optional Data of Boot####
1245   //
1246   BootOptionVar = GetLegacyBootOptionVar (CallbackData->BbsType, &Index, &OptionSize);
1247
1248   if (BootOptionVar != NULL) {
1249     CopyMem (
1250       DescString,
1251       LegacyDeviceContext->Description,
1252       StrSize (LegacyDeviceContext->Description)
1253       );
1254
1255         UnicodeStrToAsciiStr((CONST CHAR16*)&DescString, (CHAR8 *)&DescAsciiString);
1256
1257     NewOptionSize = sizeof (UINT32) + sizeof (UINT16) + StrSize (DescString) +
1258                     sizeof (BBS_BBS_DEVICE_PATH);
1259     NewOptionSize += AsciiStrLen (DescAsciiString) +
1260                     END_DEVICE_PATH_LENGTH + sizeof (BBS_TABLE) + sizeof (UINT16);
1261
1262     UnicodeSPrint (VarName, 100, L"Boot%04x", Index);
1263
1264     Ptr       = BootOptionVar;
1265
1266     Attribute = (UINT32 *) Ptr;
1267     *Attribute |= LOAD_OPTION_ACTIVE;
1268     if (LegacyDev[0] == 0xFF) {
1269       //
1270       // Disable this legacy boot option
1271       //
1272       *Attribute &= ~LOAD_OPTION_ACTIVE;
1273     }
1274
1275     Ptr += sizeof (UINT32);
1276
1277     Ptr += sizeof (UINT16);
1278     Ptr += StrSize ((CHAR16 *) Ptr);
1279
1280     NewOptionPtr = AllocateZeroPool (NewOptionSize);
1281     if (NewOptionPtr == NULL) {
1282       return EFI_OUT_OF_RESOURCES;
1283     }
1284
1285     TempPtr = NewOptionPtr;
1286
1287     //
1288     // Attribute
1289     //
1290     CopyMem (
1291       TempPtr,
1292       BootOptionVar,
1293       sizeof (UINT32)
1294       );
1295
1296     TempPtr += sizeof (UINT32);
1297
1298     //
1299     // BBS device path Length
1300     //
1301     *((UINT16 *) TempPtr) = (UINT16) (sizeof (BBS_BBS_DEVICE_PATH) +
1302                          AsciiStrLen (DescAsciiString) +
1303                          END_DEVICE_PATH_LENGTH);
1304
1305     TempPtr += sizeof (UINT16);
1306
1307     //
1308     // Description string
1309     //
1310     CopyMem (
1311       TempPtr,
1312       DescString,
1313       StrSize (DescString)
1314       );
1315
1316     TempPtr += StrSize (DescString);
1317
1318     //
1319     // BBS device path
1320     //
1321     CopyMem (
1322       TempPtr,
1323       Ptr,
1324       sizeof (BBS_BBS_DEVICE_PATH)
1325       );
1326
1327     CopyMem (
1328       ((BBS_BBS_DEVICE_PATH*) TempPtr)->String,
1329       DescAsciiString,
1330       AsciiStrSize (DescAsciiString)
1331       );
1332
1333     SetDevicePathNodeLength (
1334           (EFI_DEVICE_PATH_PROTOCOL *) TempPtr,
1335           sizeof (BBS_BBS_DEVICE_PATH) + AsciiStrLen (DescAsciiString)
1336           );
1337
1338     TempPtr += sizeof (BBS_BBS_DEVICE_PATH) + AsciiStrLen (DescAsciiString);
1339
1340     //
1341     // End node
1342     //
1343     CopyMem (
1344       TempPtr,
1345       EndDevicePath,
1346       END_DEVICE_PATH_LENGTH
1347       );
1348     TempPtr += END_DEVICE_PATH_LENGTH;
1349
1350     //
1351     // Now TempPtr point to optional data, i.e. Bbs Table
1352     //
1353     CopyMem (
1354       TempPtr,
1355       LegacyDeviceContext->BbsTable,
1356       sizeof (BBS_TABLE)
1357       );
1358
1359     //
1360     // Now TempPtr point to BBS index
1361     //
1362     TempPtr += sizeof (BBS_TABLE);
1363     *((UINT16 *) TempPtr) = (UINT16) LegacyDeviceContext->Index;
1364
1365     Status = gRT->SetVariable (
1366                     VarName,
1367                     &gEfiGlobalVariableGuid,
1368                     VAR_FLAG,
1369                     NewOptionSize,
1370                     NewOptionPtr
1371                     );
1372
1373     FreePool (NewOptionPtr);
1374     FreePool (BootOptionVar);
1375   }
1376
1377   BOpt_GetBootOptions (CallbackData);
1378   return Status;
1379 }
1380
1381 /**
1382   Update the Text Mode of Console.
1383
1384   @param CallbackData  The context data for BMM.
1385
1386   @retval EFI_SUCCSS If the Text Mode of Console is updated.
1387   @return Other value if the Text Mode of Console is not updated.
1388
1389 **/
1390 EFI_STATUS
1391 Var_UpdateConMode (
1392   IN BMM_CALLBACK_DATA            *CallbackData
1393   )
1394 {
1395   EFI_STATUS        Status;
1396   UINTN             Mode;
1397   CONSOLE_OUT_MODE  ModeInfo;
1398
1399   Mode = CallbackData->BmmFakeNvData.ConsoleOutMode;
1400
1401   Status = gST->ConOut->QueryMode (gST->ConOut, Mode, &(ModeInfo.Column), &(ModeInfo.Row));
1402   if (!EFI_ERROR(Status)) {
1403     PcdSet32 (PcdConOutColumn, (UINT32) ModeInfo.Column);
1404     PcdSet32 (PcdConOutRow, (UINT32) ModeInfo.Row);
1405   }
1406
1407   return EFI_SUCCESS;
1408 }