ArmPlatformPkg/Bds/Bds.c

   1 /** @file
   2 *
   3 *  Copyright (c) 2011-2014, ARM Limited. All rights reserved.
   4 *
   5 *  This program and the accompanying materials
   6 *  are licensed and made available under the terms and conditions of the BSD License
   7 *  which accompanies this distribution.  The full text of the license may be found at
   8 *  http://opensource.org/licenses/bsd-license.php
   9 *
  10 *  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11 *  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12 *
  13 **/
  14
  15 #include "BdsInternal.h"
  16
  17 #include <Library/PcdLib.h>
  18 #include <Library/PerformanceLib.h>
  19
  20 #include <Protocol/Bds.h>
  21
  22 #include <Guid/EventGroup.h>
  23
  24 #define EFI_SET_TIMER_TO_SECOND   10000000
  25
  26 STATIC
  27 EFI_STATUS
  28 GetConsoleDevicePathFromVariable (
  29   IN  CHAR16*             ConsoleVarName,
  30   IN  CHAR16*             DefaultConsolePaths,
  31   OUT EFI_DEVICE_PATH**   DevicePaths
  32   )
  33 {
  34   EFI_STATUS                Status;
  35   UINTN                     Size;
  36   EFI_DEVICE_PATH_PROTOCOL* DevicePathInstances;
  37   EFI_DEVICE_PATH_PROTOCOL* DevicePathInstance;
  38   CHAR16*                   DevicePathStr;
  39   CHAR16*                   NextDevicePathStr;
  40   EFI_DEVICE_PATH_FROM_TEXT_PROTOCOL  *EfiDevicePathFromTextProtocol;
  41
  42   Status = GetGlobalEnvironmentVariable (ConsoleVarName, NULL, NULL, (VOID**)&DevicePathInstances);
  43   if (EFI_ERROR(Status)) {
  44     // In case no default console device path has been defined we assume a driver handles the console (eg: SimpleTextInOutSerial)
  45     if ((DefaultConsolePaths == NULL) || (DefaultConsolePaths[0] == L'\0')) {
  46       *DevicePaths = NULL;
  47       return EFI_SUCCESS;
  48     }
  49
  50     Status = gBS->LocateProtocol (&gEfiDevicePathFromTextProtocolGuid, NULL, (VOID **)&EfiDevicePathFromTextProtocol);
  51     ASSERT_EFI_ERROR(Status);
  52
  53     DevicePathInstances = NULL;
  54
  55     // Extract the Device Path instances from the multi-device path string
  56     while ((DefaultConsolePaths != NULL) && (DefaultConsolePaths[0] != L'\0')) {
  57       NextDevicePathStr = StrStr (DefaultConsolePaths, L";");
  58       if (NextDevicePathStr == NULL) {
  59         DevicePathStr = DefaultConsolePaths;
  60         DefaultConsolePaths = NULL;
  61       } else {
  62         DevicePathStr = (CHAR16*)AllocateCopyPool ((NextDevicePathStr - DefaultConsolePaths + 1) * sizeof(CHAR16), DefaultConsolePaths);
  63         *(DevicePathStr + (NextDevicePathStr - DefaultConsolePaths)) = L'\0';
  64         DefaultConsolePaths = NextDevicePathStr;
  65         if (DefaultConsolePaths[0] == L';') {
  66           DefaultConsolePaths++;
  67         }
  68       }
  69
  70       DevicePathInstance = EfiDevicePathFromTextProtocol->ConvertTextToDevicePath (DevicePathStr);
  71       ASSERT(DevicePathInstance != NULL);
  72       DevicePathInstances = AppendDevicePathInstance (DevicePathInstances, DevicePathInstance);
  73
  74       if (NextDevicePathStr != NULL) {
  75         FreePool (DevicePathStr);
  76       }
  77       FreePool (DevicePathInstance);
  78     }
  79
  80     // Set the environment variable with this device path multi-instances
  81     Size = GetDevicePathSize (DevicePathInstances);
  82     if (Size > 0) {
  83       gRT->SetVariable (
  84           ConsoleVarName,
  85           &gEfiGlobalVariableGuid,
  86           EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
  87           Size,
  88           DevicePathInstances
  89           );
  90     } else {
  91       Status = EFI_INVALID_PARAMETER;
  92     }
  93   }
  94
  95   if (!EFI_ERROR(Status)) {
  96     *DevicePaths = DevicePathInstances;
  97   }
  98   return Status;
  99 }
 100
 101 STATIC
 102 EFI_STATUS
 103 InitializeConsolePipe (
 104   IN EFI_DEVICE_PATH    *ConsoleDevicePaths,
 105   IN EFI_GUID           *Protocol,
 106   OUT EFI_HANDLE        *Handle,
 107   OUT VOID*             *Interface
 108   )
 109 {
 110   EFI_STATUS                Status;
 111   UINTN                     Size;
 112   UINTN                     NoHandles;
 113   EFI_HANDLE                *Buffer;
 114   EFI_DEVICE_PATH_PROTOCOL* DevicePath;
 115
 116   // Connect all the Device Path Consoles
 117   while (ConsoleDevicePaths != NULL) {
 118     DevicePath = GetNextDevicePathInstance (&ConsoleDevicePaths, &Size);
 119
 120     Status = BdsConnectDevicePath (DevicePath, Handle, NULL);
 121     DEBUG_CODE_BEGIN();
 122       if (EFI_ERROR(Status)) {
 123         // We convert back to the text representation of the device Path
 124         EFI_DEVICE_PATH_TO_TEXT_PROTOCOL* DevicePathToTextProtocol;
 125         CHAR16* DevicePathTxt;
 126         EFI_STATUS Status;
 127
 128         Status = gBS->LocateProtocol(&gEfiDevicePathToTextProtocolGuid, NULL, (VOID **)&DevicePathToTextProtocol);
 129         if (!EFI_ERROR(Status)) {
 130           DevicePathTxt = DevicePathToTextProtocol->ConvertDevicePathToText (DevicePath, TRUE, TRUE);
 131
 132           DEBUG((EFI_D_ERROR,"Fail to start the console with the Device Path '%s'. (Error '%r')\n", DevicePathTxt, Status));
 133
 134           FreePool (DevicePathTxt);
 135         }
 136       }
 137     DEBUG_CODE_END();
 138
 139     // If the console splitter driver is not supported by the platform then use the first Device Path
 140     // instance for the console interface.
 141     if (!EFI_ERROR(Status) && (*Interface == NULL)) {
 142       Status = gBS->HandleProtocol (*Handle, Protocol, Interface);
 143     }
 144   }
 145
 146   // No Device Path has been defined for this console interface. We take the first protocol implementation
 147   if (*Interface == NULL) {
 148     Status = gBS->LocateHandleBuffer (ByProtocol, Protocol, NULL, &NoHandles, &Buffer);
 149     if (EFI_ERROR (Status)) {
 150       BdsConnectAllDrivers();
 151       Status = gBS->LocateHandleBuffer (ByProtocol, Protocol, NULL, &NoHandles, &Buffer);
 152     }
 153
 154     if (!EFI_ERROR(Status)) {
 155       *Handle = Buffer[0];
 156       Status = gBS->HandleProtocol (*Handle, Protocol, Interface);
 157       ASSERT_EFI_ERROR(Status);
 158     }
 159     FreePool (Buffer);
 160   } else {
 161     Status = EFI_SUCCESS;
 162   }
 163
 164   return Status;
 165 }
 166
 167 EFI_STATUS
 168 InitializeConsole (
 169   VOID
 170   )
 171 {
 172   EFI_STATUS                Status;
 173   EFI_DEVICE_PATH*          ConOutDevicePaths;
 174   EFI_DEVICE_PATH*          ConInDevicePaths;
 175   EFI_DEVICE_PATH*          ConErrDevicePaths;
 176
 177   // By getting the Console Device Paths from the environment variables before initializing the console pipe, we
 178   // create the 3 environment variables (ConIn, ConOut, ConErr) that allows to initialize all the console interface
 179   // of newly installed console drivers
 180   Status = GetConsoleDevicePathFromVariable (L"ConOut", (CHAR16*)PcdGetPtr(PcdDefaultConOutPaths), &ConOutDevicePaths);
 181   ASSERT_EFI_ERROR (Status);
 182   Status = GetConsoleDevicePathFromVariable (L"ConIn", (CHAR16*)PcdGetPtr(PcdDefaultConInPaths), &ConInDevicePaths);
 183   ASSERT_EFI_ERROR (Status);
 184   Status = GetConsoleDevicePathFromVariable (L"ErrOut", (CHAR16*)PcdGetPtr(PcdDefaultConOutPaths), &ConErrDevicePaths);
 185   ASSERT_EFI_ERROR (Status);
 186
 187   // Initialize the Consoles
 188   Status = InitializeConsolePipe (ConOutDevicePaths, &gEfiSimpleTextOutProtocolGuid, &gST->ConsoleOutHandle, (VOID **)&gST->ConOut);
 189   ASSERT_EFI_ERROR (Status);
 190   Status = InitializeConsolePipe (ConInDevicePaths, &gEfiSimpleTextInProtocolGuid, &gST->ConsoleInHandle, (VOID **)&gST->ConIn);
 191   ASSERT_EFI_ERROR (Status);
 192   Status = InitializeConsolePipe (ConErrDevicePaths, &gEfiSimpleTextOutProtocolGuid, &gST->StandardErrorHandle, (VOID **)&gST->StdErr);
 193   if (EFI_ERROR(Status)) {
 194     // In case of error, we reuse the console output for the error output
 195     gST->StandardErrorHandle = gST->ConsoleOutHandle;
 196     gST->StdErr = gST->ConOut;
 197   }
 198
 199   // Free Memory allocated for reading the UEFI Variables
 200   if (ConOutDevicePaths) {
 201     FreePool (ConOutDevicePaths);
 202   }
 203   if (ConInDevicePaths) {
 204     FreePool (ConInDevicePaths);
 205   }
 206   if (ConErrDevicePaths) {
 207     FreePool (ConErrDevicePaths);
 208   }
 209
 210   return EFI_SUCCESS;
 211 }
 212
 213 EFI_STATUS
 214 DefineDefaultBootEntries (
 215   VOID
 216   )
 217 {
 218   BDS_LOAD_OPTION*                    BdsLoadOption;
 219   UINTN                               Size;
 220   EFI_STATUS                          Status;
 221   EFI_DEVICE_PATH_FROM_TEXT_PROTOCOL* EfiDevicePathFromTextProtocol;
 222   EFI_DEVICE_PATH*                    BootDevicePath;
 223   UINT8*                              OptionalData;
 224   UINTN                               OptionalDataSize;
 225   ARM_BDS_LOADER_ARGUMENTS*           BootArguments;
 226   ARM_BDS_LOADER_TYPE                 BootType;
 227   EFI_DEVICE_PATH*                    InitrdPath;
 228   UINTN                               InitrdSize;
 229   UINTN                               CmdLineSize;
 230   UINTN                               CmdLineAsciiSize;
 231   CHAR16*                             DefaultBootArgument;
 232   CHAR8*                              AsciiDefaultBootArgument;
 233
 234   //
 235   // If Boot Order does not exist then create a default entry
 236   //
 237   Size = 0;
 238   Status = gRT->GetVariable (L"BootOrder", &gEfiGlobalVariableGuid, NULL, &Size, NULL);
 239   if (Status == EFI_NOT_FOUND) {
 240     if ((PcdGetPtr(PcdDefaultBootDevicePath) == NULL) || (StrLen ((CHAR16*)PcdGetPtr(PcdDefaultBootDevicePath)) == 0)) {
 241       return EFI_UNSUPPORTED;
 242     }
 243
 244     Status = gBS->LocateProtocol (&gEfiDevicePathFromTextProtocolGuid, NULL, (VOID **)&EfiDevicePathFromTextProtocol);
 245     if (EFI_ERROR(Status)) {
 246       // You must provide an implementation of DevicePathFromTextProtocol in your firmware (eg: DevicePathDxe)
 247       DEBUG((EFI_D_ERROR,"Error: Bds requires DevicePathFromTextProtocol\n"));
 248       return Status;
 249     }
 250     BootDevicePath = EfiDevicePathFromTextProtocol->ConvertTextToDevicePath ((CHAR16*)PcdGetPtr(PcdDefaultBootDevicePath));
 251
 252     DEBUG_CODE_BEGIN();
 253       // We convert back to the text representation of the device Path to see if the initial text is correct
 254       EFI_DEVICE_PATH_TO_TEXT_PROTOCOL* DevicePathToTextProtocol;
 255       CHAR16* DevicePathTxt;
 256
 257       Status = gBS->LocateProtocol(&gEfiDevicePathToTextProtocolGuid, NULL, (VOID **)&DevicePathToTextProtocol);
 258       ASSERT_EFI_ERROR(Status);
 259       DevicePathTxt = DevicePathToTextProtocol->ConvertDevicePathToText (BootDevicePath, TRUE, TRUE);
 260
 261       ASSERT (StrCmp ((CHAR16*)PcdGetPtr(PcdDefaultBootDevicePath), DevicePathTxt) == 0);
 262
 263       FreePool (DevicePathTxt);
 264     DEBUG_CODE_END();
 265
 266     // Create the entry is the Default values are correct
 267     if (BootDevicePath != NULL) {
 268       BootType = (ARM_BDS_LOADER_TYPE)PcdGet32 (PcdDefaultBootType);
 269
 270       // We do not support NULL pointer
 271       ASSERT (PcdGetPtr (PcdDefaultBootArgument) != NULL);
 272
 273       //
 274       // Logic to handle ASCII or Unicode default parameters
 275       //
 276       if (*(CHAR8*)PcdGetPtr (PcdDefaultBootArgument) == '\0') {
 277         CmdLineSize = 0;
 278         CmdLineAsciiSize = 0;
 279         DefaultBootArgument = NULL;
 280         AsciiDefaultBootArgument = NULL;
 281       } else if (IsUnicodeString ((CHAR16*)PcdGetPtr (PcdDefaultBootArgument))) {
 282         // The command line is a Unicode string
 283         DefaultBootArgument = (CHAR16*)PcdGetPtr (PcdDefaultBootArgument);
 284         CmdLineSize = StrSize (DefaultBootArgument);
 285
 286         // Initialize ASCII variables
 287         CmdLineAsciiSize = CmdLineSize / 2;
 288         AsciiDefaultBootArgument = AllocatePool (CmdLineAsciiSize);
 289         if (AsciiDefaultBootArgument == NULL) {
 290           return EFI_OUT_OF_RESOURCES;
 291         }
 292         UnicodeStrToAsciiStr ((CHAR16*)PcdGetPtr (PcdDefaultBootArgument), AsciiDefaultBootArgument);
 293       } else {
 294         // The command line is a ASCII string
 295         AsciiDefaultBootArgument = (CHAR8*)PcdGetPtr (PcdDefaultBootArgument);
 296         CmdLineAsciiSize = AsciiStrSize (AsciiDefaultBootArgument);
 297
 298         // Initialize ASCII variables
 299         CmdLineSize = CmdLineAsciiSize * 2;
 300         DefaultBootArgument = AllocatePool (CmdLineSize);
 301         if (DefaultBootArgument == NULL) {
 302           return EFI_OUT_OF_RESOURCES;
 303         }
 304         AsciiStrToUnicodeStr (AsciiDefaultBootArgument, DefaultBootArgument);
 305       }
 306
 307       if ((BootType == BDS_LOADER_KERNEL_LINUX_ATAG) || (BootType == BDS_LOADER_KERNEL_LINUX_FDT)) {
 308         InitrdPath = EfiDevicePathFromTextProtocol->ConvertTextToDevicePath ((CHAR16*)PcdGetPtr(PcdDefaultBootInitrdPath));
 309         InitrdSize = GetDevicePathSize (InitrdPath);
 310
 311         OptionalDataSize = sizeof(ARM_BDS_LOADER_ARGUMENTS) + CmdLineAsciiSize + InitrdSize;
 312         BootArguments = (ARM_BDS_LOADER_ARGUMENTS*)AllocatePool (OptionalDataSize);
 313         if (BootArguments == NULL) {
 314           return EFI_OUT_OF_RESOURCES;
 315         }
 316         BootArguments->LinuxArguments.CmdLineSize = CmdLineAsciiSize;
 317         BootArguments->LinuxArguments.InitrdSize = InitrdSize;
 318
 319         CopyMem ((VOID*)(BootArguments + 1), AsciiDefaultBootArgument, CmdLineAsciiSize);
 320         CopyMem ((VOID*)((UINTN)(BootArguments + 1) + CmdLineAsciiSize), InitrdPath, InitrdSize);
 321
 322         OptionalData = (UINT8*)BootArguments;
 323       } else {
 324         OptionalData = (UINT8*)DefaultBootArgument;
 325         OptionalDataSize = CmdLineSize;
 326       }
 327
 328       BootOptionCreate (LOAD_OPTION_ACTIVE | LOAD_OPTION_CATEGORY_BOOT,
 329         (CHAR16*)PcdGetPtr(PcdDefaultBootDescription),
 330         BootDevicePath,
 331         BootType,
 332         OptionalData,
 333         OptionalDataSize,
 334         &BdsLoadOption
 335         );
 336       FreePool (BdsLoadOption);
 337
 338       if (DefaultBootArgument == (CHAR16*)PcdGetPtr (PcdDefaultBootArgument)) {
 339         FreePool (AsciiDefaultBootArgument);
 340       } else if (DefaultBootArgument != NULL) {
 341         FreePool (DefaultBootArgument);
 342       }
 343     } else {
 344       Status = EFI_UNSUPPORTED;
 345     }
 346   }
 347
 348   return Status;
 349 }
 350
 351 EFI_STATUS
 352 StartDefaultBootOnTimeout (
 353   VOID
 354   )
 355 {
 356   UINTN               Size;
 357   UINT16              Timeout;
 358   UINT16              *TimeoutPtr;
 359   EFI_EVENT           WaitList[2];
 360   UINTN               WaitIndex;
 361   UINT16              *BootOrder;
 362   UINTN               BootOrderSize;
 363   UINTN               Index;
 364   CHAR16              BootVariableName[9];
 365   EFI_STATUS          Status;
 366   EFI_INPUT_KEY       Key;
 367
 368   Size = sizeof(UINT16);
 369   Timeout = (UINT16)PcdGet16 (PcdPlatformBootTimeOut);
 370   Status = GetGlobalEnvironmentVariable (L"Timeout", &Timeout, &Size, (VOID**)&TimeoutPtr);
 371   if (!EFI_ERROR (Status)) {
 372     Timeout = *TimeoutPtr;
 373     FreePool (TimeoutPtr);
 374   }
 375
 376   if (Timeout != 0xFFFF) {
 377     if (Timeout > 0) {
 378       // Create the waiting events (keystroke and 1sec timer)
 379       gBS->CreateEvent (EVT_TIMER, 0, NULL, NULL, &WaitList[0]);
 380       gBS->SetTimer (WaitList[0], TimerPeriodic, EFI_SET_TIMER_TO_SECOND);
 381       WaitList[1] = gST->ConIn->WaitForKey;
 382
 383       // Start the timer
 384       WaitIndex = 0;
 385       Print(L"The default boot selection will start in ");
 386       while ((Timeout > 0) && (WaitIndex == 0)) {
 387         Print(L"%3d seconds",Timeout);
 388         gBS->WaitForEvent (2, WaitList, &WaitIndex);
 389         if (WaitIndex == 0) {
 390           Print(L"\b\b\b\b\b\b\b\b\b\b\b");
 391           Timeout--;
 392         }
 393       }
 394       // Discard key in the buffer
 395       do {
 396         Status = gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);
 397       } while(!EFI_ERROR(Status));
 398       gBS->CloseEvent (WaitList[0]);
 399       Print(L"\n\r");
 400     }
 401
 402     // In case of Timeout we start the default boot selection
 403     if (Timeout == 0) {
 404       // Get the Boot Option Order from the environment variable (a default value should have been created)
 405       GetGlobalEnvironmentVariable (L"BootOrder", NULL, &BootOrderSize, (VOID**)&BootOrder);
 406
 407       for (Index = 0; Index < BootOrderSize / sizeof (UINT16); Index++) {
 408         UnicodeSPrint (BootVariableName, 9 * sizeof(CHAR16), L"Boot%04X", BootOrder[Index]);
 409         Status = BdsStartBootOption (BootVariableName);
 410         if(!EFI_ERROR(Status)){
 411           // Boot option returned successfully, hence don't need to start next boot option
 412           break;
 413         }
 414         // In case of success, we should not return from this call.
 415       }
 416       FreePool (BootOrder);
 417     }
 418   }
 419   return EFI_SUCCESS;
 420 }
 421
 422 /**
 423   An empty function to pass error checking of CreateEventEx ().
 424
 425   @param  Event                 Event whose notification function is being invoked.
 426   @param  Context               Pointer to the notification function's context,
 427                                 which is implementation-dependent.
 428
 429 **/
 430 VOID
 431 EFIAPI
 432 EmptyCallbackFunction (
 433   IN EFI_EVENT                Event,
 434   IN VOID                     *Context
 435   )
 436 {
 437   return;
 438 }
 439
 440 /**
 441   This function uses policy data from the platform to determine what operating
 442   system or system utility should be loaded and invoked.  This function call
 443   also optionally make the use of user input to determine the operating system
 444   or system utility to be loaded and invoked.  When the DXE Core has dispatched
 445   all the drivers on the dispatch queue, this function is called.  This
 446   function will attempt to connect the boot devices required to load and invoke
 447   the selected operating system or system utility.  During this process,
 448   additional firmware volumes may be discovered that may contain addition DXE
 449   drivers that can be dispatched by the DXE Core.   If a boot device cannot be
 450   fully connected, this function calls the DXE Service Dispatch() to allow the
 451   DXE drivers from any newly discovered firmware volumes to be dispatched.
 452   Then the boot device connection can be attempted again.  If the same boot
 453   device connection operation fails twice in a row, then that boot device has
 454   failed, and should be skipped.  This function should never return.
 455
 456   @param  This             The EFI_BDS_ARCH_PROTOCOL instance.
 457
 458   @return None.
 459
 460 **/
 461 VOID
 462 EFIAPI
 463 BdsEntry (
 464   IN EFI_BDS_ARCH_PROTOCOL  *This
 465   )
 466 {
 467   UINTN               Size;
 468   EFI_STATUS          Status;
 469   UINT16             *BootNext;
 470   UINTN               BootNextSize;
 471   CHAR16              BootVariableName[9];
 472   EFI_EVENT           EndOfDxeEvent;
 473
 474   //
 475   // Signal EndOfDxe PI Event
 476   //
 477   Status = gBS->CreateEventEx (
 478       EVT_NOTIFY_SIGNAL,
 479       TPL_NOTIFY,
 480       EmptyCallbackFunction,
 481       NULL,
 482       &gEfiEndOfDxeEventGroupGuid,
 483       &EndOfDxeEvent
 484       );
 485   if (!EFI_ERROR (Status)) {
 486     gBS->SignalEvent (EndOfDxeEvent);
 487   }
 488
 489   PERF_END   (NULL, "DXE", NULL, 0);
 490
 491   //
 492   // Declare the Firmware Vendor
 493   //
 494   if (FixedPcdGetPtr(PcdFirmwareVendor) != NULL) {
 495     Size = 0x100;
 496     gST->FirmwareVendor = AllocateRuntimePool (Size);
 497     ASSERT (gST->FirmwareVendor != NULL);
 498     UnicodeSPrint (gST->FirmwareVendor, Size, L"%a EFI %a %a", PcdGetPtr(PcdFirmwareVendor), __DATE__, __TIME__);
 499   }
 500
 501   //
 502   // Fixup Table CRC after we updated Firmware Vendor
 503   //
 504   gST->Hdr.CRC32 = 0;
 505   Status = gBS->CalculateCrc32 ((VOID*)gST, gST->Hdr.HeaderSize, &gST->Hdr.CRC32);
 506   ASSERT_EFI_ERROR (Status);
 507
 508   // If BootNext environment variable is defined then we just load it !
 509   BootNextSize = sizeof(UINT16);
 510   Status = GetGlobalEnvironmentVariable (L"BootNext", NULL, &BootNextSize, (VOID**)&BootNext);
 511   if (!EFI_ERROR(Status)) {
 512     ASSERT(BootNextSize == sizeof(UINT16));
 513
 514     // Generate the requested Boot Entry variable name
 515     UnicodeSPrint (BootVariableName, 9 * sizeof(CHAR16), L"Boot%04X", *BootNext);
 516
 517     // Set BootCurrent variable
 518     gRT->SetVariable (L"BootCurrent", &gEfiGlobalVariableGuid,
 519               EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
 520               BootNextSize, BootNext);
 521
 522     FreePool (BootNext);
 523
 524     // Start the requested Boot Entry
 525     Status = BdsStartBootOption (BootVariableName);
 526     if (Status != EFI_NOT_FOUND) {
 527       // BootNext has not been succeeded launched
 528       if (EFI_ERROR(Status)) {
 529         Print(L"Fail to start BootNext.\n");
 530       }
 531
 532       // Delete the BootNext environment variable
 533       gRT->SetVariable (L"BootNext", &gEfiGlobalVariableGuid,
 534           EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
 535           0, NULL);
 536     }
 537
 538     // Clear BootCurrent variable
 539     gRT->SetVariable (L"BootCurrent", &gEfiGlobalVariableGuid,
 540         EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
 541         0, NULL);
 542   }
 543
 544   // If Boot Order does not exist then create a default entry
 545   DefineDefaultBootEntries ();
 546
 547   // Now we need to setup the EFI System Table with information about the console devices.
 548   InitializeConsole ();
 549
 550   //
 551   // Update the CRC32 in the EFI System Table header
 552   //
 553   gST->Hdr.CRC32 = 0;
 554   Status = gBS->CalculateCrc32 ((VOID*)gST, gST->Hdr.HeaderSize, &gST->Hdr.CRC32);
 555   ASSERT_EFI_ERROR (Status);
 556
 557   // Timer before initiating the default boot selection
 558   StartDefaultBootOnTimeout ();
 559
 560   // Start the Boot Menu
 561   Status = BootMenuMain ();
 562   ASSERT_EFI_ERROR (Status);
 563
 564 }
 565
 566 EFI_BDS_ARCH_PROTOCOL  gBdsProtocol = {
 567   BdsEntry,
 568 };
 569
 570 EFI_STATUS
 571 EFIAPI
 572 BdsInitialize (
 573   IN EFI_HANDLE                            ImageHandle,
 574   IN EFI_SYSTEM_TABLE                      *SystemTable
 575   )
 576 {
 577   EFI_STATUS  Status;
 578
 579   Status = gBS->InstallMultipleProtocolInterfaces (
 580                   &ImageHandle,
 581                   &gEfiBdsArchProtocolGuid, &gBdsProtocol,
 582                   NULL
 583                   );
 584   ASSERT_EFI_ERROR (Status);
 585
 586   return Status;
 587 }