ArmPlatformPkg/Bds/Bds.c

   1 /** @file
   2 *
   3 *  Copyright (c) 2011-2015, 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       FreePool (Buffer);
 159     }
 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       if (StrCmp ((CHAR16*)PcdGetPtr (PcdDefaultBootDevicePath), DevicePathTxt) != 0) {
 262         DEBUG ((EFI_D_ERROR, "Device Path given: '%s' Device Path expected: '%s'\n",
 263             (CHAR16*)PcdGetPtr (PcdDefaultBootDevicePath), DevicePathTxt));
 264         ASSERT_EFI_ERROR (EFI_INVALID_PARAMETER);
 265       }
 266
 267       FreePool (DevicePathTxt);
 268     DEBUG_CODE_END();
 269
 270     // Create the entry is the Default values are correct
 271     if (BootDevicePath != NULL) {
 272       BootType = (ARM_BDS_LOADER_TYPE)PcdGet32 (PcdDefaultBootType);
 273
 274       // We do not support NULL pointer
 275       ASSERT (PcdGetPtr (PcdDefaultBootArgument) != NULL);
 276
 277       //
 278       // Logic to handle ASCII or Unicode default parameters
 279       //
 280       if (*(CHAR8*)PcdGetPtr (PcdDefaultBootArgument) == '\0') {
 281         CmdLineSize = 0;
 282         CmdLineAsciiSize = 0;
 283         DefaultBootArgument = NULL;
 284         AsciiDefaultBootArgument = NULL;
 285       } else if (IsUnicodeString ((CHAR16*)PcdGetPtr (PcdDefaultBootArgument))) {
 286         // The command line is a Unicode string
 287         DefaultBootArgument = (CHAR16*)PcdGetPtr (PcdDefaultBootArgument);
 288         CmdLineSize = StrSize (DefaultBootArgument);
 289
 290         // Initialize ASCII variables
 291         CmdLineAsciiSize = CmdLineSize / 2;
 292         AsciiDefaultBootArgument = AllocatePool (CmdLineAsciiSize);
 293         if (AsciiDefaultBootArgument == NULL) {
 294           return EFI_OUT_OF_RESOURCES;
 295         }
 296         UnicodeStrToAsciiStr ((CHAR16*)PcdGetPtr (PcdDefaultBootArgument), AsciiDefaultBootArgument);
 297       } else {
 298         // The command line is a ASCII string
 299         AsciiDefaultBootArgument = (CHAR8*)PcdGetPtr (PcdDefaultBootArgument);
 300         CmdLineAsciiSize = AsciiStrSize (AsciiDefaultBootArgument);
 301
 302         // Initialize ASCII variables
 303         CmdLineSize = CmdLineAsciiSize * 2;
 304         DefaultBootArgument = AllocatePool (CmdLineSize);
 305         if (DefaultBootArgument == NULL) {
 306           return EFI_OUT_OF_RESOURCES;
 307         }
 308         AsciiStrToUnicodeStr (AsciiDefaultBootArgument, DefaultBootArgument);
 309       }
 310
 311       if ((BootType == BDS_LOADER_KERNEL_LINUX_ATAG) || (BootType == BDS_LOADER_KERNEL_LINUX_FDT)) {
 312         InitrdPath = EfiDevicePathFromTextProtocol->ConvertTextToDevicePath ((CHAR16*)PcdGetPtr(PcdDefaultBootInitrdPath));
 313         InitrdSize = GetDevicePathSize (InitrdPath);
 314
 315         OptionalDataSize = sizeof(ARM_BDS_LOADER_ARGUMENTS) + CmdLineAsciiSize + InitrdSize;
 316         BootArguments = (ARM_BDS_LOADER_ARGUMENTS*)AllocatePool (OptionalDataSize);
 317         if (BootArguments == NULL) {
 318           return EFI_OUT_OF_RESOURCES;
 319         }
 320         BootArguments->LinuxArguments.CmdLineSize = CmdLineAsciiSize;
 321         BootArguments->LinuxArguments.InitrdSize = InitrdSize;
 322
 323         CopyMem ((VOID*)(BootArguments + 1), AsciiDefaultBootArgument, CmdLineAsciiSize);
 324         CopyMem ((VOID*)((UINTN)(BootArguments + 1) + CmdLineAsciiSize), InitrdPath, InitrdSize);
 325
 326         OptionalData = (UINT8*)BootArguments;
 327       } else {
 328         OptionalData = (UINT8*)DefaultBootArgument;
 329         OptionalDataSize = CmdLineSize;
 330       }
 331
 332       BootOptionCreate (LOAD_OPTION_ACTIVE | LOAD_OPTION_CATEGORY_BOOT,
 333         (CHAR16*)PcdGetPtr(PcdDefaultBootDescription),
 334         BootDevicePath,
 335         BootType,
 336         OptionalData,
 337         OptionalDataSize,
 338         &BdsLoadOption
 339         );
 340       FreePool (BdsLoadOption);
 341
 342       if (DefaultBootArgument == (CHAR16*)PcdGetPtr (PcdDefaultBootArgument)) {
 343         FreePool (AsciiDefaultBootArgument);
 344       } else if (DefaultBootArgument != NULL) {
 345         FreePool (DefaultBootArgument);
 346       }
 347     } else {
 348       Status = EFI_UNSUPPORTED;
 349     }
 350   }
 351
 352   return Status;
 353 }
 354
 355 EFI_STATUS
 356 StartDefaultBootOnTimeout (
 357   VOID
 358   )
 359 {
 360   UINTN               Size;
 361   UINT16              Timeout;
 362   UINT16              *TimeoutPtr;
 363   EFI_EVENT           WaitList[2];
 364   UINTN               WaitIndex;
 365   UINT16              *BootOrder;
 366   UINTN               BootOrderSize;
 367   UINTN               Index;
 368   CHAR16              BootVariableName[9];
 369   EFI_STATUS          Status;
 370   EFI_INPUT_KEY       Key;
 371
 372   Size = sizeof(UINT16);
 373   Timeout = (UINT16)PcdGet16 (PcdPlatformBootTimeOut);
 374   Status = GetGlobalEnvironmentVariable (L"Timeout", &Timeout, &Size, (VOID**)&TimeoutPtr);
 375   if (!EFI_ERROR (Status)) {
 376     Timeout = *TimeoutPtr;
 377     FreePool (TimeoutPtr);
 378   }
 379
 380   if (Timeout != 0xFFFF) {
 381     if (Timeout > 0) {
 382       // Create the waiting events (keystroke and 1sec timer)
 383       gBS->CreateEvent (EVT_TIMER, 0, NULL, NULL, &WaitList[0]);
 384       gBS->SetTimer (WaitList[0], TimerPeriodic, EFI_SET_TIMER_TO_SECOND);
 385       WaitList[1] = gST->ConIn->WaitForKey;
 386
 387       // Start the timer
 388       WaitIndex = 0;
 389       Print(L"The default boot selection will start in ");
 390       while ((Timeout > 0) && (WaitIndex == 0)) {
 391         Print(L"%3d seconds",Timeout);
 392         gBS->WaitForEvent (2, WaitList, &WaitIndex);
 393         if (WaitIndex == 0) {
 394           Print(L"\b\b\b\b\b\b\b\b\b\b\b");
 395           Timeout--;
 396         }
 397       }
 398       // Discard key in the buffer
 399       do {
 400         Status = gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);
 401       } while(!EFI_ERROR(Status));
 402       gBS->CloseEvent (WaitList[0]);
 403       Print(L"\n\r");
 404     }
 405
 406     // In case of Timeout we start the default boot selection
 407     if (Timeout == 0) {
 408       // Get the Boot Option Order from the environment variable (a default value should have been created)
 409       GetGlobalEnvironmentVariable (L"BootOrder", NULL, &BootOrderSize, (VOID**)&BootOrder);
 410
 411       for (Index = 0; Index < BootOrderSize / sizeof (UINT16); Index++) {
 412         UnicodeSPrint (BootVariableName, 9 * sizeof(CHAR16), L"Boot%04X", BootOrder[Index]);
 413         Status = BdsStartBootOption (BootVariableName);
 414         if(!EFI_ERROR(Status)){
 415           // Boot option returned successfully, hence don't need to start next boot option
 416           break;
 417         }
 418         // In case of success, we should not return from this call.
 419       }
 420       FreePool (BootOrder);
 421     }
 422   }
 423   return EFI_SUCCESS;
 424 }
 425
 426 /**
 427   An empty function to pass error checking of CreateEventEx ().
 428
 429   @param  Event                 Event whose notification function is being invoked.
 430   @param  Context               Pointer to the notification function's context,
 431                                 which is implementation-dependent.
 432
 433 **/
 434 VOID
 435 EFIAPI
 436 EmptyCallbackFunction (
 437   IN EFI_EVENT                Event,
 438   IN VOID                     *Context
 439   )
 440 {
 441   return;
 442 }
 443
 444 /**
 445   This function uses policy data from the platform to determine what operating
 446   system or system utility should be loaded and invoked.  This function call
 447   also optionally make the use of user input to determine the operating system
 448   or system utility to be loaded and invoked.  When the DXE Core has dispatched
 449   all the drivers on the dispatch queue, this function is called.  This
 450   function will attempt to connect the boot devices required to load and invoke
 451   the selected operating system or system utility.  During this process,
 452   additional firmware volumes may be discovered that may contain addition DXE
 453   drivers that can be dispatched by the DXE Core.   If a boot device cannot be
 454   fully connected, this function calls the DXE Service Dispatch() to allow the
 455   DXE drivers from any newly discovered firmware volumes to be dispatched.
 456   Then the boot device connection can be attempted again.  If the same boot
 457   device connection operation fails twice in a row, then that boot device has
 458   failed, and should be skipped.  This function should never return.
 459
 460   @param  This             The EFI_BDS_ARCH_PROTOCOL instance.
 461
 462   @return None.
 463
 464 **/
 465 VOID
 466 EFIAPI
 467 BdsEntry (
 468   IN EFI_BDS_ARCH_PROTOCOL  *This
 469   )
 470 {
 471   UINTN               Size;
 472   EFI_STATUS          Status;
 473   UINT16             *BootNext;
 474   UINTN               BootNextSize;
 475   CHAR16              BootVariableName[9];
 476   EFI_EVENT           EndOfDxeEvent;
 477
 478   //
 479   // Signal EndOfDxe PI Event
 480   //
 481   Status = gBS->CreateEventEx (
 482       EVT_NOTIFY_SIGNAL,
 483       TPL_NOTIFY,
 484       EmptyCallbackFunction,
 485       NULL,
 486       &gEfiEndOfDxeEventGroupGuid,
 487       &EndOfDxeEvent
 488       );
 489   if (!EFI_ERROR (Status)) {
 490     gBS->SignalEvent (EndOfDxeEvent);
 491   }
 492
 493   PERF_END   (NULL, "DXE", NULL, 0);
 494
 495   //
 496   // Declare the Firmware Vendor
 497   //
 498   if (FixedPcdGetPtr(PcdFirmwareVendor) != NULL) {
 499     Size = 0x100;
 500     gST->FirmwareVendor = AllocateRuntimePool (Size);
 501     ASSERT (gST->FirmwareVendor != NULL);
 502     UnicodeSPrint (gST->FirmwareVendor, Size, L"%a EFI %a %a", PcdGetPtr(PcdFirmwareVendor), __DATE__, __TIME__);
 503   }
 504
 505   //
 506   // Fixup Table CRC after we updated Firmware Vendor
 507   //
 508   gST->Hdr.CRC32 = 0;
 509   Status = gBS->CalculateCrc32 ((VOID*)gST, gST->Hdr.HeaderSize, &gST->Hdr.CRC32);
 510   ASSERT_EFI_ERROR (Status);
 511
 512   // If BootNext environment variable is defined then we just load it !
 513   BootNextSize = sizeof(UINT16);
 514   Status = GetGlobalEnvironmentVariable (L"BootNext", NULL, &BootNextSize, (VOID**)&BootNext);
 515   if (!EFI_ERROR(Status)) {
 516     ASSERT(BootNextSize == sizeof(UINT16));
 517
 518     // Generate the requested Boot Entry variable name
 519     UnicodeSPrint (BootVariableName, 9 * sizeof(CHAR16), L"Boot%04X", *BootNext);
 520
 521     // Set BootCurrent variable
 522     gRT->SetVariable (L"BootCurrent", &gEfiGlobalVariableGuid,
 523               EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
 524               BootNextSize, BootNext);
 525
 526     FreePool (BootNext);
 527
 528     // Start the requested Boot Entry
 529     Status = BdsStartBootOption (BootVariableName);
 530     if (Status != EFI_NOT_FOUND) {
 531       // BootNext has not been succeeded launched
 532       if (EFI_ERROR(Status)) {
 533         Print(L"Fail to start BootNext.\n");
 534       }
 535
 536       // Delete the BootNext environment variable
 537       gRT->SetVariable (L"BootNext", &gEfiGlobalVariableGuid,
 538           EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
 539           0, NULL);
 540     }
 541
 542     // Clear BootCurrent variable
 543     gRT->SetVariable (L"BootCurrent", &gEfiGlobalVariableGuid,
 544         EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
 545         0, NULL);
 546   }
 547
 548   // If Boot Order does not exist then create a default entry
 549   DefineDefaultBootEntries ();
 550
 551   // Now we need to setup the EFI System Table with information about the console devices.
 552   InitializeConsole ();
 553
 554   //
 555   // Update the CRC32 in the EFI System Table header
 556   //
 557   gST->Hdr.CRC32 = 0;
 558   Status = gBS->CalculateCrc32 ((VOID*)gST, gST->Hdr.HeaderSize, &gST->Hdr.CRC32);
 559   ASSERT_EFI_ERROR (Status);
 560
 561   // Timer before initiating the default boot selection
 562   StartDefaultBootOnTimeout ();
 563
 564   // Start the Boot Menu
 565   Status = BootMenuMain ();
 566   ASSERT_EFI_ERROR (Status);
 567
 568 }
 569
 570 EFI_BDS_ARCH_PROTOCOL  gBdsProtocol = {
 571   BdsEntry,
 572 };
 573
 574 EFI_STATUS
 575 EFIAPI
 576 BdsInitialize (
 577   IN EFI_HANDLE                            ImageHandle,
 578   IN EFI_SYSTEM_TABLE                      *SystemTable
 579   )
 580 {
 581   EFI_STATUS  Status;
 582
 583   Status = gBS->InstallMultipleProtocolInterfaces (
 584                   &ImageHandle,
 585                   &gEfiBdsArchProtocolGuid, &gBdsProtocol,
 586                   NULL
 587                   );
 588   ASSERT_EFI_ERROR (Status);
 589
 590   return Status;
 591 }