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