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 #define EFI_SET_TIMER_TO_SECOND   10000000
  23
  24 EFI_HANDLE mImageHandle;
  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   This function uses policy data from the platform to determine what operating
 424   system or system utility should be loaded and invoked.  This function call
 425   also optionally make the use of user input to determine the operating system
 426   or system utility to be loaded and invoked.  When the DXE Core has dispatched
 427   all the drivers on the dispatch queue, this function is called.  This
 428   function will attempt to connect the boot devices required to load and invoke
 429   the selected operating system or system utility.  During this process,
 430   additional firmware volumes may be discovered that may contain addition DXE
 431   drivers that can be dispatched by the DXE Core.   If a boot device cannot be
 432   fully connected, this function calls the DXE Service Dispatch() to allow the
 433   DXE drivers from any newly discovered firmware volumes to be dispatched.
 434   Then the boot device connection can be attempted again.  If the same boot
 435   device connection operation fails twice in a row, then that boot device has
 436   failed, and should be skipped.  This function should never return.
 437
 438   @param  This             The EFI_BDS_ARCH_PROTOCOL instance.
 439
 440   @return None.
 441
 442 **/
 443 VOID
 444 EFIAPI
 445 BdsEntry (
 446   IN EFI_BDS_ARCH_PROTOCOL  *This
 447   )
 448 {
 449   UINTN               Size;
 450   EFI_STATUS          Status;
 451   UINT16             *BootNext;
 452   UINTN               BootNextSize;
 453   CHAR16              BootVariableName[9];
 454
 455   PERF_END   (NULL, "DXE", NULL, 0);
 456
 457   //
 458   // Declare the Firmware Vendor
 459   //
 460   if (FixedPcdGetPtr(PcdFirmwareVendor) != NULL) {
 461     Size = 0x100;
 462     gST->FirmwareVendor = AllocateRuntimePool (Size);
 463     ASSERT (gST->FirmwareVendor != NULL);
 464     UnicodeSPrint (gST->FirmwareVendor, Size, L"%a EFI %a %a", PcdGetPtr(PcdFirmwareVendor), __DATE__, __TIME__);
 465   }
 466
 467   //
 468   // Fixup Table CRC after we updated Firmware Vendor
 469   //
 470   gST->Hdr.CRC32 = 0;
 471   Status = gBS->CalculateCrc32 ((VOID*)gST, gST->Hdr.HeaderSize, &gST->Hdr.CRC32);
 472   ASSERT_EFI_ERROR (Status);
 473
 474   // If BootNext environment variable is defined then we just load it !
 475   BootNextSize = sizeof(UINT16);
 476   Status = GetGlobalEnvironmentVariable (L"BootNext", NULL, &BootNextSize, (VOID**)&BootNext);
 477   if (!EFI_ERROR(Status)) {
 478     ASSERT(BootNextSize == sizeof(UINT16));
 479
 480     // Generate the requested Boot Entry variable name
 481     UnicodeSPrint (BootVariableName, 9 * sizeof(CHAR16), L"Boot%04X", *BootNext);
 482
 483     // Set BootCurrent variable
 484     gRT->SetVariable (L"BootCurrent", &gEfiGlobalVariableGuid,
 485               EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
 486               BootNextSize, BootNext);
 487
 488     FreePool (BootNext);
 489
 490     // Start the requested Boot Entry
 491     Status = BdsStartBootOption (BootVariableName);
 492     if (Status != EFI_NOT_FOUND) {
 493       // BootNext has not been succeeded launched
 494       if (EFI_ERROR(Status)) {
 495         Print(L"Fail to start BootNext.\n");
 496       }
 497
 498       // Delete the BootNext environment variable
 499       gRT->SetVariable (L"BootNext", &gEfiGlobalVariableGuid,
 500           EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
 501           0, NULL);
 502     }
 503
 504     // Clear BootCurrent variable
 505     gRT->SetVariable (L"BootCurrent", &gEfiGlobalVariableGuid,
 506         EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
 507         0, NULL);
 508   }
 509
 510   // If Boot Order does not exist then create a default entry
 511   DefineDefaultBootEntries ();
 512
 513   // Now we need to setup the EFI System Table with information about the console devices.
 514   InitializeConsole ();
 515
 516   //
 517   // Update the CRC32 in the EFI System Table header
 518   //
 519   gST->Hdr.CRC32 = 0;
 520   Status = gBS->CalculateCrc32 ((VOID*)gST, gST->Hdr.HeaderSize, &gST->Hdr.CRC32);
 521   ASSERT_EFI_ERROR (Status);
 522
 523   // Timer before initiating the default boot selection
 524   StartDefaultBootOnTimeout ();
 525
 526   // Start the Boot Menu
 527   Status = BootMenuMain ();
 528   ASSERT_EFI_ERROR (Status);
 529
 530 }
 531
 532 EFI_BDS_ARCH_PROTOCOL  gBdsProtocol = {
 533   BdsEntry,
 534 };
 535
 536 EFI_STATUS
 537 EFIAPI
 538 BdsInitialize (
 539   IN EFI_HANDLE                            ImageHandle,
 540   IN EFI_SYSTEM_TABLE                      *SystemTable
 541   )
 542 {
 543   EFI_STATUS  Status;
 544
 545   mImageHandle = ImageHandle;
 546
 547   Status = gBS->InstallMultipleProtocolInterfaces (
 548                   &ImageHandle,
 549                   &gEfiBdsArchProtocolGuid, &gBdsProtocol,
 550                   NULL
 551                   );
 552   ASSERT_EFI_ERROR (Status);
 553
 554   return Status;
 555 }