MdeModulePkg/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   @return Others        If failed to update the "BootOrder" variable after deletion.
  25
  26 **/
  27 EFI_STATUS
  28 Var_DelBootOption (
  29   VOID
  30   )
  31 {
  32   BM_MENU_ENTRY   *NewMenuEntry;
  33   BM_LOAD_CONTEXT *NewLoadContext;
  34   UINT16          BootString[10];
  35   EFI_STATUS      Status;
  36   UINTN           Index;
  37   UINTN           Index2;
  38
  39   Status  = EFI_SUCCESS;
  40   Index2  = 0;
  41   for (Index = 0; Index < BootOptionMenu.MenuNumber; Index++) {
  42     NewMenuEntry = BOpt_GetMenuEntry (&BootOptionMenu, (Index - Index2));
  43     if (NULL == NewMenuEntry) {
  44       return EFI_NOT_FOUND;
  45     }
  46
  47     NewLoadContext = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
  48     if (!NewLoadContext->Deleted) {
  49       continue;
  50     }
  51
  52     UnicodeSPrint (
  53       BootString,
  54       sizeof (BootString),
  55       L"Boot%04x",
  56       NewMenuEntry->OptionNumber
  57       );
  58
  59     EfiLibDeleteVariable (BootString, &gEfiGlobalVariableGuid);
  60     Index2++;
  61     //
  62     // If current Load Option is the same as BootNext,
  63     // must delete BootNext in order to make sure
  64     // there will be no panic on next boot
  65     //
  66     if (NewLoadContext->IsBootNext) {
  67       EfiLibDeleteVariable (L"BootNext", &gEfiGlobalVariableGuid);
  68     }
  69
  70     RemoveEntryList (&NewMenuEntry->Link);
  71     BOpt_DestroyMenuEntry (NewMenuEntry);
  72     NewMenuEntry = NULL;
  73   }
  74
  75   BootOptionMenu.MenuNumber -= Index2;
  76
  77   Status = Var_ChangeBootOrder ();
  78   return Status;
  79 }
  80
  81 /**
  82   After any operation on Boot####, there will be a discrepancy in BootOrder.
  83   Since some are missing but in BootOrder, while some are present but are
  84   not reflected by BootOrder. Then a function rebuild BootOrder from
  85   scratch by content from BootOptionMenu is needed.
  86
  87
  88
  89
  90   @retval  EFI_SUCCESS  The boot order is updated successfully.
  91   @return               EFI_STATUS other than EFI_SUCCESS if failed to
  92                         Set the "BootOrder" EFI Variable.
  93
  94 **/
  95 EFI_STATUS
  96 Var_ChangeBootOrder (
  97   VOID
  98   )
  99 {
 100
 101   EFI_STATUS    Status;
 102   BM_MENU_ENTRY *NewMenuEntry;
 103   UINT16        *BootOrderList;
 104   UINT16        *BootOrderListPtr;
 105   UINTN         BootOrderListSize;
 106   UINTN         Index;
 107
 108   BootOrderList     = NULL;
 109   BootOrderListSize = 0;
 110
 111   //
 112   // First check whether BootOrder is present in current configuration
 113   //
 114   BootOrderList = BdsLibGetVariableAndSize (
 115                     L"BootOrder",
 116                     &gEfiGlobalVariableGuid,
 117                     &BootOrderListSize
 118                     );
 119
 120   //
 121   // If exists, delete it to hold new BootOrder
 122   //
 123   if (BootOrderList != NULL) {
 124     EfiLibDeleteVariable (L"BootOrder", &gEfiGlobalVariableGuid);
 125     FreePool (BootOrderList);
 126     BootOrderList = NULL;
 127   }
 128   //
 129   // Maybe here should be some check method to ensure that
 130   // no new added boot options will be added
 131   // but the setup engine now will give only one callback
 132   // that is to say, user are granted only one chance to
 133   // decide whether the boot option will be added or not
 134   // there should be no indictor to show whether this
 135   // is a "new" boot option
 136   //
 137   BootOrderListSize = BootOptionMenu.MenuNumber;
 138
 139   if (BootOrderListSize > 0) {
 140     BootOrderList = AllocateZeroPool (BootOrderListSize * sizeof (UINT16));
 141     ASSERT (BootOrderList != NULL);
 142     BootOrderListPtr = BootOrderList;
 143
 144     //
 145     // Get all current used Boot#### from BootOptionMenu.
 146     // OptionNumber in each BM_LOAD_OPTION is really its
 147     // #### value.
 148     //
 149     for (Index = 0; Index < BootOrderListSize; Index++) {
 150       NewMenuEntry    = BOpt_GetMenuEntry (&BootOptionMenu, Index);
 151       *BootOrderList  = (UINT16) NewMenuEntry->OptionNumber;
 152       BootOrderList++;
 153     }
 154
 155     BootOrderList = BootOrderListPtr;
 156
 157     //
 158     // After building the BootOrderList, write it back
 159     //
 160     Status = gRT->SetVariable (
 161                     L"BootOrder",
 162                     &gEfiGlobalVariableGuid,
 163                     VAR_FLAG,
 164                     BootOrderListSize * sizeof (UINT16),
 165                     BootOrderList
 166                     );
 167     if (EFI_ERROR (Status)) {
 168       return Status;
 169     }
 170   }
 171   return EFI_SUCCESS;
 172 }
 173
 174 /**
 175   Delete Load Option that represent a Deleted state in BootOptionMenu.
 176   After deleting this Driver option, call Var_ChangeDriverOrder to
 177   make sure DriverOrder is in valid state.
 178
 179   @retval EFI_SUCCESS Load Option is successfully updated.
 180   @return Other value than EFI_SUCCESS if failed to update "Driver Order" EFI
 181           Variable.
 182
 183 **/
 184 EFI_STATUS
 185 Var_DelDriverOption (
 186   VOID
 187   )
 188 {
 189   BM_MENU_ENTRY   *NewMenuEntry;
 190   BM_LOAD_CONTEXT *NewLoadContext;
 191   UINT16          DriverString[12];
 192   EFI_STATUS      Status;
 193   UINTN           Index;
 194   UINTN           Index2;
 195
 196   Status  = EFI_SUCCESS;
 197   Index2  = 0;
 198   for (Index = 0; Index < DriverOptionMenu.MenuNumber; Index++) {
 199     NewMenuEntry = BOpt_GetMenuEntry (&DriverOptionMenu, (Index - Index2));
 200     if (NULL == NewMenuEntry) {
 201       return EFI_NOT_FOUND;
 202     }
 203
 204     NewLoadContext = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
 205     if (!NewLoadContext->Deleted) {
 206       continue;
 207     }
 208
 209     UnicodeSPrint (
 210       DriverString,
 211       sizeof (DriverString),
 212       L"Driver%04x",
 213       NewMenuEntry->OptionNumber
 214       );
 215
 216     EfiLibDeleteVariable (DriverString, &gEfiGlobalVariableGuid);
 217     Index2++;
 218
 219     RemoveEntryList (&NewMenuEntry->Link);
 220     BOpt_DestroyMenuEntry (NewMenuEntry);
 221     NewMenuEntry = NULL;
 222   }
 223
 224   DriverOptionMenu.MenuNumber -= Index2;
 225
 226   Status = Var_ChangeDriverOrder ();
 227   return Status;
 228 }
 229
 230 /**
 231   After any operation on Driver####, there will be a discrepancy in
 232   DriverOrder. Since some are missing but in DriverOrder, while some
 233   are present but are not reflected by DriverOrder. Then a function
 234   rebuild DriverOrder from scratch by content from DriverOptionMenu is
 235   needed.
 236
 237   @retval  EFI_SUCCESS  The driver order is updated successfully.
 238   @return               EFI_STATUS other than EFI_SUCCESS if failed to
 239                                  Set the "DriverOrder" EFI Variable.
 240
 241 **/
 242 EFI_STATUS
 243 Var_ChangeDriverOrder (
 244   VOID
 245   )
 246 {
 247   EFI_STATUS    Status;
 248   BM_MENU_ENTRY *NewMenuEntry;
 249   UINT16        *DriverOrderList;
 250   UINT16        *DriverOrderListPtr;
 251   UINTN         DriverOrderListSize;
 252   UINTN         Index;
 253
 254   DriverOrderList     = NULL;
 255   DriverOrderListSize = 0;
 256
 257   //
 258   // First check whether DriverOrder is present in current configuration
 259   //
 260   DriverOrderList = BdsLibGetVariableAndSize (
 261                       L"DriverOrder",
 262                       &gEfiGlobalVariableGuid,
 263                       &DriverOrderListSize
 264                       );
 265
 266   //
 267   // If exists, delete it to hold new DriverOrder
 268   //
 269   if (DriverOrderList != NULL) {
 270     EfiLibDeleteVariable (L"DriverOrder", &gEfiGlobalVariableGuid);
 271     FreePool (DriverOrderList);
 272     DriverOrderList = NULL;
 273   }
 274
 275   DriverOrderListSize = DriverOptionMenu.MenuNumber;
 276
 277   if (DriverOrderListSize > 0) {
 278     DriverOrderList = AllocateZeroPool (DriverOrderListSize * sizeof (UINT16));
 279     ASSERT (DriverOrderList != NULL);
 280     DriverOrderListPtr = DriverOrderList;
 281
 282     //
 283     // Get all current used Driver#### from DriverOptionMenu.
 284     // OptionNumber in each BM_LOAD_OPTION is really its
 285     // #### value.
 286     //
 287     for (Index = 0; Index < DriverOrderListSize; Index++) {
 288       NewMenuEntry      = BOpt_GetMenuEntry (&DriverOptionMenu, Index);
 289       *DriverOrderList  = (UINT16) NewMenuEntry->OptionNumber;
 290       DriverOrderList++;
 291     }
 292
 293     DriverOrderList = DriverOrderListPtr;
 294
 295     //
 296     // After building the DriverOrderList, write it back
 297     //
 298     Status = gRT->SetVariable (
 299                     L"DriverOrder",
 300                     &gEfiGlobalVariableGuid,
 301                     VAR_FLAG,
 302                     DriverOrderListSize * sizeof (UINT16),
 303                     DriverOrderList
 304                     );
 305     if (EFI_ERROR (Status)) {
 306       return Status;
 307     }
 308   }
 309   return EFI_SUCCESS;
 310 }
 311
 312 /**
 313   Update the device path of "ConOut", "ConIn" and "ErrOut"
 314   based on the new BaudRate, Data Bits, parity and Stop Bits
 315   set.
 316
 317 **/
 318 VOID
 319 Var_UpdateAllConsoleOption (
 320   VOID
 321   )
 322 {
 323   EFI_DEVICE_PATH_PROTOCOL  *OutDevicePath;
 324   EFI_DEVICE_PATH_PROTOCOL  *InpDevicePath;
 325   EFI_DEVICE_PATH_PROTOCOL  *ErrDevicePath;
 326   EFI_STATUS                Status;
 327
 328   OutDevicePath = EfiLibGetVariable (L"ConOut", &gEfiGlobalVariableGuid);
 329   InpDevicePath = EfiLibGetVariable (L"ConIn", &gEfiGlobalVariableGuid);
 330   ErrDevicePath = EfiLibGetVariable (L"ErrOut", &gEfiGlobalVariableGuid);
 331   if (OutDevicePath != NULL) {
 332     ChangeVariableDevicePath (OutDevicePath);
 333     Status = gRT->SetVariable (
 334                     L"ConOut",
 335                     &gEfiGlobalVariableGuid,
 336                     VAR_FLAG,
 337                     GetDevicePathSize (OutDevicePath),
 338                     OutDevicePath
 339                     );
 340     ASSERT (!EFI_ERROR (Status));
 341   }
 342
 343   if (InpDevicePath != NULL) {
 344     ChangeVariableDevicePath (InpDevicePath);
 345     Status = gRT->SetVariable (
 346                     L"ConIn",
 347                     &gEfiGlobalVariableGuid,
 348                     VAR_FLAG,
 349                     GetDevicePathSize (InpDevicePath),
 350                     InpDevicePath
 351                     );
 352     ASSERT (!EFI_ERROR (Status));
 353   }
 354
 355   if (ErrDevicePath != NULL) {
 356     ChangeVariableDevicePath (ErrDevicePath);
 357     Status = gRT->SetVariable (
 358                     L"ErrOut",
 359                     &gEfiGlobalVariableGuid,
 360                     VAR_FLAG,
 361                     GetDevicePathSize (ErrDevicePath),
 362                     ErrDevicePath
 363                     );
 364     ASSERT (!EFI_ERROR (Status));
 365   }
 366 }
 367
 368 /**
 369   This function delete and build multi-instance device path for
 370   specified type of console device.
 371
 372   This function clear the EFI variable defined by ConsoleName and
 373   gEfiGlobalVariableGuid. It then build the multi-instance device
 374   path by appending the device path of the Console (In/Out/Err) instance
 375   in ConsoleMenu. Then it scan all corresponding console device by
 376   scanning Terminal (built from device supporting Serial I/O instances)
 377   devices in TerminalMenu. At last, it save a EFI variable specifed
 378   by ConsoleName and gEfiGlobalVariableGuid.
 379
 380   @param ConsoleName     The name for the console device type. They are
 381                          usually "ConIn", "ConOut" and "ErrOut".
 382   @param ConsoleMenu     The console memu which is a list of console devices.
 383   @param UpdatePageId    The flag specifying which type of console device
 384                          to be processed.
 385
 386   @retval EFI_SUCCESS    The function complete successfully.
 387   @return                The EFI variable can be saved. See gRT->SetVariable
 388                          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       CopyMem (
 440         &Vendor.Guid,
 441         &TerminalTypeGuid[NewTerminalContext->TerminalType],
 442         sizeof (EFI_GUID)
 443         );
 444       SetDevicePathNodeLength (&Vendor.Header, sizeof (VENDOR_DEVICE_PATH));
 445       TerminalDevicePath = AppendDevicePathNode (
 446                             NewTerminalContext->DevicePath,
 447                             (EFI_DEVICE_PATH_PROTOCOL *) &Vendor
 448                             );
 449       ASSERT (TerminalDevicePath != NULL);
 450       ChangeTerminalDevicePath (TerminalDevicePath, TRUE);
 451       ConDevicePath = AppendDevicePathInstance (
 452                         ConDevicePath,
 453                         TerminalDevicePath
 454                         );
 455     }
 456   }
 457
 458   if (ConDevicePath != NULL) {
 459     Status = gRT->SetVariable (
 460                     ConsoleName,
 461                     &gEfiGlobalVariableGuid,
 462                     VAR_FLAG,
 463                     GetDevicePathSize (ConDevicePath),
 464                     ConDevicePath
 465                     );
 466     if (EFI_ERROR (Status)) {
 467       return Status;
 468     }
 469   }
 470
 471   return EFI_SUCCESS;
 472
 473 }
 474
 475 /**
 476   This function delete and build multi-instance device path ConIn
 477   console device.
 478
 479   @retval EFI_SUCCESS    The function complete successfully.
 480   @return                The EFI variable can be saved. See gRT->SetVariable
 481                          for detail return information.
 482 **/
 483 EFI_STATUS
 484 Var_UpdateConsoleInpOption (
 485   VOID
 486   )
 487 {
 488   return Var_UpdateConsoleOption (L"ConIn", &ConsoleInpMenu, FORM_CON_IN_ID);
 489 }
 490
 491 /**
 492   This function delete and build multi-instance device path ConOut
 493   console device.
 494
 495   @retval EFI_SUCCESS    The function complete successfully.
 496   @return                The EFI variable can be saved. See gRT->SetVariable
 497                          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 be saved. See gRT->SetVariable
 513                          for detail return information.
 514 **/
 515 EFI_STATUS
 516 Var_UpdateErrorOutOption (
 517   VOID
 518   )
 519 {
 520   return Var_UpdateConsoleOption (L"ErrOut", &ConsoleErrMenu, FORM_CON_ERR_ID);
 521 }
 522
 523 /**
 524   This function create a currently loaded Drive Option from
 525   the BMM. It then appends this Driver Option to the end of
 526   the "DriverOrder" list. It append this Driver Opotion to the end
 527   of DriverOptionMenu.
 528
 529   @param CallbackData    The BMM context data.
 530   @param HiiHandle       The HII handle associated with the BMM formset.
 531   @param DescriptionData The description of this driver option.
 532   @param OptionalData    The optional load option.
 533   @param ForceReconnect  If to force reconnect.
 534
 535   @retval EFI_OUT_OF_RESOURCES If not enought memory to complete the operation.
 536   @retval EFI_SUCCESS          If function completes successfully.
 537
 538 **/
 539 EFI_STATUS
 540 Var_UpdateDriverOption (
 541   IN  BMM_CALLBACK_DATA         *CallbackData,
 542   IN  EFI_HII_HANDLE            HiiHandle,
 543   IN  UINT16                    *DescriptionData,
 544   IN  UINT16                    *OptionalData,
 545   IN  UINT8                     ForceReconnect
 546   )
 547 {
 548   UINT16          Index;
 549   UINT16          *DriverOrderList;
 550   UINT16          *NewDriverOrderList;
 551   UINT16          DriverString[12];
 552   UINTN           DriverOrderListSize;
 553   VOID            *Buffer;
 554   UINTN           BufferSize;
 555   UINT8           *Ptr;
 556   BM_MENU_ENTRY   *NewMenuEntry;
 557   BM_LOAD_CONTEXT *NewLoadContext;
 558   BOOLEAN         OptionalDataExist;
 559   EFI_STATUS      Status;
 560
 561   OptionalDataExist = FALSE;
 562
 563   Index             = BOpt_GetDriverOptionNumber ();
 564   UnicodeSPrint (
 565     DriverString,
 566     sizeof (DriverString),
 567     L"Driver%04x",
 568     Index
 569     );
 570
 571   if (*DescriptionData == 0x0000) {
 572     StrCpy (DescriptionData, DriverString);
 573   }
 574
 575   BufferSize = sizeof (UINT32) + sizeof (UINT16) + StrSize (DescriptionData);
 576   BufferSize += GetDevicePathSize (CallbackData->LoadContext->FilePathList);
 577
 578   if (*OptionalData != 0x0000) {
 579     OptionalDataExist = TRUE;
 580     BufferSize += StrSize (OptionalData);
 581   }
 582
 583   Buffer = AllocateZeroPool (BufferSize);
 584   if (NULL == Buffer) {
 585     return EFI_OUT_OF_RESOURCES;
 586   }
 587
 588   NewMenuEntry = BOpt_CreateMenuEntry (BM_LOAD_CONTEXT_SELECT);
 589   if (NULL == NewMenuEntry) {
 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 "BootNex" 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_SUCCESS    Not enough memory to complete the function.
 942   @return                The EFI variable can be saved. See gRT->SetVariable
 943                          for detail return information.
 944
 945 **/
 946 EFI_STATUS
 947 Var_UpdateBootOrder (
 948   IN BMM_CALLBACK_DATA            *CallbackData
 949   )
 950 {
 951   EFI_STATUS  Status;
 952   UINT16      Index;
 953   UINT16      *BootOrderList;
 954   UINT16      *NewBootOrderList;
 955   UINTN       BootOrderListSize;
 956
 957   BootOrderList     = NULL;
 958   BootOrderListSize = 0;
 959
 960   //
 961   // First check whether BootOrder is present in current configuration
 962   //
 963   BootOrderList = BdsLibGetVariableAndSize (
 964                     L"BootOrder",
 965                     &gEfiGlobalVariableGuid,
 966                     &BootOrderListSize
 967                     );
 968
 969   NewBootOrderList = AllocateZeroPool (BootOrderListSize);
 970   if (NewBootOrderList == NULL) {
 971     return EFI_OUT_OF_RESOURCES;
 972   }
 973
 974   //
 975   // If exists, delete it to hold new BootOrder
 976   //
 977   if (BootOrderList != NULL) {
 978     EfiLibDeleteVariable (L"BootOrder", &gEfiGlobalVariableGuid);
 979     FreePool (BootOrderList);
 980   }
 981
 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_SUCCESS    Not enough memory to complete the function.
1014   @return                The EFI variable can be saved. See gRT->SetVariable
1015                          for detail return information.
1016
1017 **/
1018 EFI_STATUS
1019 Var_UpdateDriverOrder (
1020   IN BMM_CALLBACK_DATA            *CallbackData
1021   )
1022 {
1023   EFI_STATUS  Status;
1024   UINT16      Index;
1025   UINT16      *DriverOrderList;
1026   UINT16      *NewDriverOrderList;
1027   UINTN       DriverOrderListSize;
1028
1029   DriverOrderList     = NULL;
1030   DriverOrderListSize = 0;
1031
1032   //
1033   // First check whether DriverOrder is present in current configuration
1034   //
1035   DriverOrderList = BdsLibGetVariableAndSize (
1036                       L"DriverOrder",
1037                       &gEfiGlobalVariableGuid,
1038                       &DriverOrderListSize
1039                       );
1040
1041   NewDriverOrderList = AllocateZeroPool (DriverOrderListSize);
1042
1043   if (NewDriverOrderList == NULL) {
1044     return EFI_OUT_OF_RESOURCES;
1045   }
1046   //
1047   // If exists, delete it to hold new DriverOrder
1048   //
1049   if (DriverOrderList != NULL) {
1050     EfiLibDeleteVariable (L"DriverOrder", &gEfiGlobalVariableGuid);
1051     FreePool (DriverOrderList);
1052   }
1053
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
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 (NULL == VarData) {
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 (NULL == NewOrder) {
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 (NULL != BootOptionVar) {
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                     EFI_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 (0xFF == LegacyDev[0]) {
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 (NULL == NewOptionPtr) {
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                          EFI_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       EFI_END_DEVICE_PATH_LENGTH
1347       );
1348     TempPtr += EFI_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     ModeInfo.Column = 80;
1404     ModeInfo.Row = 25;
1405   }
1406
1407   Status = gRT->SetVariable (
1408                   VAR_CON_OUT_MODE,
1409                   &gEfiGenericPlatformVariableGuid,
1410                   EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_NON_VOLATILE,
1411                   sizeof (CONSOLE_OUT_MODE),
1412                   &ModeInfo
1413                   );
1414
1415   return Status;
1416 }