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