ArmPkg/PlatformBootManagerLib: print firmware version to console

[mirror_edk2.git] / ArmPkg / Library / PlatformBootManagerLib / PlatformBm.c

/** @file\r
  Implementation for PlatformBootManagerLib library class interfaces.\r
\r
  Copyright (C) 2015-2016, Red Hat, Inc.\r
  Copyright (c) 2014, ARM Ltd. All rights reserved.<BR>\r
  Copyright (c) 2004 - 2016, Intel Corporation. All rights reserved.<BR>\r
  Copyright (c) 2016, Linaro Ltd. All rights reserved.<BR>\r
\r
  This program and the accompanying materials are licensed and made available\r
  under the terms and conditions of the BSD License which accompanies this\r
  distribution. The full text of the license may be found at\r
  http://opensource.org/licenses/bsd-license.php\r
\r
  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, WITHOUT\r
  WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
\r
**/\r
\r
#include <IndustryStandard/Pci22.h>\r
#include <Library/BootLogoLib.h>\r
#include <Library/CapsuleLib.h>\r
#include <Library/DevicePathLib.h>\r
#include <Library/HobLib.h>\r
#include <Library/PcdLib.h>\r
#include <Library/UefiBootManagerLib.h>\r
#include <Library/UefiLib.h>\r
#include <Protocol/DevicePath.h>\r
#include <Protocol/EsrtManagement.h>\r
#include <Protocol/GraphicsOutput.h>\r
#include <Protocol/LoadedImage.h>\r
#include <Protocol/PciIo.h>\r
#include <Protocol/PciRootBridgeIo.h>\r
#include <Guid/EventGroup.h>\r
#include <Guid/TtyTerm.h>\r
\r
#include "PlatformBm.h"\r
\r
#define DP_NODE_LEN(Type) { (UINT8)sizeof (Type), (UINT8)(sizeof (Type) >> 8) }\r
\r
#pragma pack (1)\r
typedef struct {\r
  VENDOR_DEVICE_PATH         SerialDxe;\r
  UART_DEVICE_PATH           Uart;\r
  VENDOR_DEFINED_DEVICE_PATH TermType;\r
  EFI_DEVICE_PATH_PROTOCOL   End;\r
} PLATFORM_SERIAL_CONSOLE;\r
#pragma pack ()\r
\r
#define SERIAL_DXE_FILE_GUID { \\r
          0xD3987D4B, 0x971A, 0x435F, \\r
          { 0x8C, 0xAF, 0x49, 0x67, 0xEB, 0x62, 0x72, 0x41 } \\r
          }\r
\r
STATIC PLATFORM_SERIAL_CONSOLE mSerialConsole = {\r
  //\r
  // VENDOR_DEVICE_PATH SerialDxe\r
  //\r
  {\r
    { HARDWARE_DEVICE_PATH, HW_VENDOR_DP, DP_NODE_LEN (VENDOR_DEVICE_PATH) },\r
    SERIAL_DXE_FILE_GUID\r
  },\r
\r
  //\r
  // UART_DEVICE_PATH Uart\r
  //\r
  {\r
    { MESSAGING_DEVICE_PATH, MSG_UART_DP, DP_NODE_LEN (UART_DEVICE_PATH) },\r
    0,                                      // Reserved\r
    FixedPcdGet64 (PcdUartDefaultBaudRate), // BaudRate\r
    FixedPcdGet8 (PcdUartDefaultDataBits),  // DataBits\r
    FixedPcdGet8 (PcdUartDefaultParity),    // Parity\r
    FixedPcdGet8 (PcdUartDefaultStopBits)   // StopBits\r
  },\r
\r
  //\r
  // VENDOR_DEFINED_DEVICE_PATH TermType\r
  //\r
  {\r
    {\r
      MESSAGING_DEVICE_PATH, MSG_VENDOR_DP,\r
      DP_NODE_LEN (VENDOR_DEFINED_DEVICE_PATH)\r
    }\r
    //\r
    // Guid to be filled in dynamically\r
    //\r
  },\r
\r
  //\r
  // EFI_DEVICE_PATH_PROTOCOL End\r
  //\r
  {\r
    END_DEVICE_PATH_TYPE, END_ENTIRE_DEVICE_PATH_SUBTYPE,\r
    DP_NODE_LEN (EFI_DEVICE_PATH_PROTOCOL)\r
  }\r
};\r
\r
\r
#pragma pack (1)\r
typedef struct {\r
  USB_CLASS_DEVICE_PATH    Keyboard;\r
  EFI_DEVICE_PATH_PROTOCOL End;\r
} PLATFORM_USB_KEYBOARD;\r
#pragma pack ()\r
\r
STATIC PLATFORM_USB_KEYBOARD mUsbKeyboard = {\r
  //\r
  // USB_CLASS_DEVICE_PATH Keyboard\r
  //\r
  {\r
    {\r
      MESSAGING_DEVICE_PATH, MSG_USB_CLASS_DP,\r
      DP_NODE_LEN (USB_CLASS_DEVICE_PATH)\r
    },\r
    0xFFFF, // VendorId: any\r
    0xFFFF, // ProductId: any\r
    3,      // DeviceClass: HID\r
    1,      // DeviceSubClass: boot\r
    1       // DeviceProtocol: keyboard\r
  },\r
\r
  //\r
  // EFI_DEVICE_PATH_PROTOCOL End\r
  //\r
  {\r
    END_DEVICE_PATH_TYPE, END_ENTIRE_DEVICE_PATH_SUBTYPE,\r
    DP_NODE_LEN (EFI_DEVICE_PATH_PROTOCOL)\r
  }\r
};\r
\r
\r
/**\r
  Check if the handle satisfies a particular condition.\r
\r
  @param[in] Handle      The handle to check.\r
  @param[in] ReportText  A caller-allocated string passed in for reporting\r
                         purposes. It must never be NULL.\r
\r
  @retval TRUE   The condition is satisfied.\r
  @retval FALSE  Otherwise. This includes the case when the condition could not\r
                 be fully evaluated due to an error.\r
**/\r
typedef\r
BOOLEAN\r
(EFIAPI *FILTER_FUNCTION) (\r
  IN EFI_HANDLE   Handle,\r
  IN CONST CHAR16 *ReportText\r
  );\r
\r
\r
/**\r
  Process a handle.\r
\r
  @param[in] Handle      The handle to process.\r
  @param[in] ReportText  A caller-allocated string passed in for reporting\r
                         purposes. It must never be NULL.\r
**/\r
typedef\r
VOID\r
(EFIAPI *CALLBACK_FUNCTION)  (\r
  IN EFI_HANDLE   Handle,\r
  IN CONST CHAR16 *ReportText\r
  );\r
\r
/**\r
  Locate all handles that carry the specified protocol, filter them with a\r
  callback function, and pass each handle that passes the filter to another\r
  callback.\r
\r
  @param[in] ProtocolGuid  The protocol to look for.\r
\r
  @param[in] Filter        The filter function to pass each handle to. If this\r
                           parameter is NULL, then all handles are processed.\r
\r
  @param[in] Process       The callback function to pass each handle to that\r
                           clears the filter.\r
**/\r
STATIC\r
VOID\r
FilterAndProcess (\r
  IN EFI_GUID          *ProtocolGuid,\r
  IN FILTER_FUNCTION   Filter         OPTIONAL,\r
  IN CALLBACK_FUNCTION Process\r
  )\r
{\r
  EFI_STATUS Status;\r
  EFI_HANDLE *Handles;\r
  UINTN      NoHandles;\r
  UINTN      Idx;\r
\r
  Status = gBS->LocateHandleBuffer (ByProtocol, ProtocolGuid,\r
                  NULL /* SearchKey */, &NoHandles, &Handles);\r
  if (EFI_ERROR (Status)) {\r
    //\r
    // This is not an error, just an informative condition.\r
    //\r
    DEBUG ((EFI_D_VERBOSE, "%a: %g: %r\n", __FUNCTION__, ProtocolGuid,\r
      Status));\r
    return;\r
  }\r
\r
  ASSERT (NoHandles > 0);\r
  for (Idx = 0; Idx < NoHandles; ++Idx) {\r
    CHAR16        *DevicePathText;\r
    STATIC CHAR16 Fallback[] = L"<device path unavailable>";\r
\r
    //\r
    // The ConvertDevicePathToText() function handles NULL input transparently.\r
    //\r
    DevicePathText = ConvertDevicePathToText (\r
                       DevicePathFromHandle (Handles[Idx]),\r
                       FALSE, // DisplayOnly\r
                       FALSE  // AllowShortcuts\r
                       );\r
    if (DevicePathText == NULL) {\r
      DevicePathText = Fallback;\r
    }\r
\r
    if (Filter == NULL || Filter (Handles[Idx], DevicePathText)) {\r
      Process (Handles[Idx], DevicePathText);\r
    }\r
\r
    if (DevicePathText != Fallback) {\r
      FreePool (DevicePathText);\r
    }\r
  }\r
  gBS->FreePool (Handles);\r
}\r
\r
\r
/**\r
  This FILTER_FUNCTION checks if a handle corresponds to a PCI display device.\r
**/\r
STATIC\r
BOOLEAN\r
EFIAPI\r
IsPciDisplay (\r
  IN EFI_HANDLE   Handle,\r
  IN CONST CHAR16 *ReportText\r
  )\r
{\r
  EFI_STATUS          Status;\r
  EFI_PCI_IO_PROTOCOL *PciIo;\r
  PCI_TYPE00          Pci;\r
\r
  Status = gBS->HandleProtocol (Handle, &gEfiPciIoProtocolGuid,\r
                  (VOID**)&PciIo);\r
  if (EFI_ERROR (Status)) {\r
    //\r
    // This is not an error worth reporting.\r
    //\r
    return FALSE;\r
  }\r
\r
  Status = PciIo->Pci.Read (PciIo, EfiPciIoWidthUint32, 0 /* Offset */,\r
                        sizeof Pci / sizeof (UINT32), &Pci);\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((EFI_D_ERROR, "%a: %s: %r\n", __FUNCTION__, ReportText, Status));\r
    return FALSE;\r
  }\r
\r
  return IS_PCI_DISPLAY (&Pci);\r
}\r
\r
\r
/**\r
  This CALLBACK_FUNCTION attempts to connect a handle non-recursively, asking\r
  the matching driver to produce all first-level child handles.\r
**/\r
STATIC\r
VOID\r
EFIAPI\r
Connect (\r
  IN EFI_HANDLE   Handle,\r
  IN CONST CHAR16 *ReportText\r
  )\r
{\r
  EFI_STATUS Status;\r
\r
  Status = gBS->ConnectController (\r
                  Handle, // ControllerHandle\r
                  NULL,   // DriverImageHandle\r
                  NULL,   // RemainingDevicePath -- produce all children\r
                  FALSE   // Recursive\r
                  );\r
  DEBUG ((EFI_ERROR (Status) ? EFI_D_ERROR : EFI_D_VERBOSE, "%a: %s: %r\n",\r
    __FUNCTION__, ReportText, Status));\r
}\r
\r
\r
/**\r
  This CALLBACK_FUNCTION retrieves the EFI_DEVICE_PATH_PROTOCOL from the\r
  handle, and adds it to ConOut and ErrOut.\r
**/\r
STATIC\r
VOID\r
EFIAPI\r
AddOutput (\r
  IN EFI_HANDLE   Handle,\r
  IN CONST CHAR16 *ReportText\r
  )\r
{\r
  EFI_STATUS               Status;\r
  EFI_DEVICE_PATH_PROTOCOL *DevicePath;\r
\r
  DevicePath = DevicePathFromHandle (Handle);\r
  if (DevicePath == NULL) {\r
    DEBUG ((EFI_D_ERROR, "%a: %s: handle %p: device path not found\n",\r
      __FUNCTION__, ReportText, Handle));\r
    return;\r
  }\r
\r
  Status = EfiBootManagerUpdateConsoleVariable (ConOut, DevicePath, NULL);\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((EFI_D_ERROR, "%a: %s: adding to ConOut: %r\n", __FUNCTION__,\r
      ReportText, Status));\r
    return;\r
  }\r
\r
  Status = EfiBootManagerUpdateConsoleVariable (ErrOut, DevicePath, NULL);\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((EFI_D_ERROR, "%a: %s: adding to ErrOut: %r\n", __FUNCTION__,\r
      ReportText, Status));\r
    return;\r
  }\r
\r
  DEBUG ((EFI_D_VERBOSE, "%a: %s: added to ConOut and ErrOut\n", __FUNCTION__,\r
    ReportText));\r
}\r
\r
STATIC\r
VOID\r
PlatformRegisterFvBootOption (\r
  CONST EFI_GUID                   *FileGuid,\r
  CHAR16                           *Description,\r
  UINT32                           Attributes\r
  )\r
{\r
  EFI_STATUS                        Status;\r
  INTN                              OptionIndex;\r
  EFI_BOOT_MANAGER_LOAD_OPTION      NewOption;\r
  EFI_BOOT_MANAGER_LOAD_OPTION      *BootOptions;\r
  UINTN                             BootOptionCount;\r
  MEDIA_FW_VOL_FILEPATH_DEVICE_PATH FileNode;\r
  EFI_LOADED_IMAGE_PROTOCOL         *LoadedImage;\r
  EFI_DEVICE_PATH_PROTOCOL          *DevicePath;\r
\r
  Status = gBS->HandleProtocol (\r
                  gImageHandle,\r
                  &gEfiLoadedImageProtocolGuid,\r
                  (VOID **) &LoadedImage\r
                  );\r
  ASSERT_EFI_ERROR (Status);\r
\r
  EfiInitializeFwVolDevicepathNode (&FileNode, FileGuid);\r
  DevicePath = DevicePathFromHandle (LoadedImage->DeviceHandle);\r
  ASSERT (DevicePath != NULL);\r
  DevicePath = AppendDevicePathNode (\r
                 DevicePath,\r
                 (EFI_DEVICE_PATH_PROTOCOL *) &FileNode\r
                 );\r
  ASSERT (DevicePath != NULL);\r
\r
  Status = EfiBootManagerInitializeLoadOption (\r
             &NewOption,\r
             LoadOptionNumberUnassigned,\r
             LoadOptionTypeBoot,\r
             Attributes,\r
             Description,\r
             DevicePath,\r
             NULL,\r
             0\r
             );\r
  ASSERT_EFI_ERROR (Status);\r
  FreePool (DevicePath);\r
\r
  BootOptions = EfiBootManagerGetLoadOptions (\r
                  &BootOptionCount, LoadOptionTypeBoot\r
                  );\r
\r
  OptionIndex = EfiBootManagerFindLoadOption (\r
                  &NewOption, BootOptions, BootOptionCount\r
                  );\r
\r
  if (OptionIndex == -1) {\r
    Status = EfiBootManagerAddLoadOptionVariable (&NewOption, MAX_UINTN);\r
    ASSERT_EFI_ERROR (Status);\r
  }\r
  EfiBootManagerFreeLoadOption (&NewOption);\r
  EfiBootManagerFreeLoadOptions (BootOptions, BootOptionCount);\r
}\r
\r
\r
STATIC\r
VOID\r
PlatformRegisterOptionsAndKeys (\r
  VOID\r
  )\r
{\r
  EFI_STATUS                   Status;\r
  EFI_INPUT_KEY                Enter;\r
  EFI_INPUT_KEY                F2;\r
  EFI_INPUT_KEY                Esc;\r
  EFI_BOOT_MANAGER_LOAD_OPTION BootOption;\r
\r
  //\r
  // Register ENTER as CONTINUE key\r
  //\r
  Enter.ScanCode    = SCAN_NULL;\r
  Enter.UnicodeChar = CHAR_CARRIAGE_RETURN;\r
  Status = EfiBootManagerRegisterContinueKeyOption (0, &Enter, NULL);\r
  ASSERT_EFI_ERROR (Status);\r
\r
  //\r
  // Map F2 and ESC to Boot Manager Menu\r
  //\r
  F2.ScanCode     = SCAN_F2;\r
  F2.UnicodeChar  = CHAR_NULL;\r
  Esc.ScanCode    = SCAN_ESC;\r
  Esc.UnicodeChar = CHAR_NULL;\r
  Status = EfiBootManagerGetBootManagerMenu (&BootOption);\r
  ASSERT_EFI_ERROR (Status);\r
  Status = EfiBootManagerAddKeyOptionVariable (\r
             NULL, (UINT16) BootOption.OptionNumber, 0, &F2, NULL\r
             );\r
  ASSERT (Status == EFI_SUCCESS || Status == EFI_ALREADY_STARTED);\r
  Status = EfiBootManagerAddKeyOptionVariable (\r
             NULL, (UINT16) BootOption.OptionNumber, 0, &Esc, NULL\r
             );\r
  ASSERT (Status == EFI_SUCCESS || Status == EFI_ALREADY_STARTED);\r
}\r
\r
\r
//\r
// BDS Platform Functions\r
//\r
/**\r
  Do the platform init, can be customized by OEM/IBV\r
  Possible things that can be done in PlatformBootManagerBeforeConsole:\r
  > Update console variable: 1. include hot-plug devices;\r
  >                          2. Clear ConIn and add SOL for AMT\r
  > Register new Driver#### or Boot####\r
  > Register new Key####: e.g.: F12\r
  > Signal ReadyToLock event\r
  > Authentication action: 1. connect Auth devices;\r
  >                        2. Identify auto logon user.\r
**/\r
VOID\r
EFIAPI\r
PlatformBootManagerBeforeConsole (\r
  VOID\r
  )\r
{\r
  EFI_STATUS                    Status;\r
  ESRT_MANAGEMENT_PROTOCOL      *EsrtManagement;\r
\r
  if (GetBootModeHob() == BOOT_ON_FLASH_UPDATE) {\r
    DEBUG ((DEBUG_INFO, "ProcessCapsules Before EndOfDxe ......\n"));\r
    Status = ProcessCapsules ();\r
    DEBUG ((DEBUG_INFO, "ProcessCapsules returned %r\n", Status));\r
  } else {\r
    Status = gBS->LocateProtocol (&gEsrtManagementProtocolGuid, NULL,\r
                    (VOID **)&EsrtManagement);\r
    if (!EFI_ERROR (Status)) {\r
      EsrtManagement->SyncEsrtFmp ();\r
    }\r
  }\r
\r
  //\r
  // Signal EndOfDxe PI Event\r
  //\r
  EfiEventGroupSignal (&gEfiEndOfDxeEventGroupGuid);\r
\r
  //\r
  // Locate the PCI root bridges and make the PCI bus driver connect each,\r
  // non-recursively. This will produce a number of child handles with PciIo on\r
  // them.\r
  //\r
  FilterAndProcess (&gEfiPciRootBridgeIoProtocolGuid, NULL, Connect);\r
\r
  //\r
  // Find all display class PCI devices (using the handles from the previous\r
  // step), and connect them non-recursively. This should produce a number of\r
  // child handles with GOPs on them.\r
  //\r
  FilterAndProcess (&gEfiPciIoProtocolGuid, IsPciDisplay, Connect);\r
\r
  //\r
  // Now add the device path of all handles with GOP on them to ConOut and\r
  // ErrOut.\r
  //\r
  FilterAndProcess (&gEfiGraphicsOutputProtocolGuid, NULL, AddOutput);\r
\r
  //\r
  // Add the hardcoded short-form USB keyboard device path to ConIn.\r
  //\r
  EfiBootManagerUpdateConsoleVariable (ConIn,\r
    (EFI_DEVICE_PATH_PROTOCOL *)&mUsbKeyboard, NULL);\r
\r
  //\r
  // Add the hardcoded serial console device path to ConIn, ConOut, ErrOut.\r
  //\r
  ASSERT (FixedPcdGet8 (PcdDefaultTerminalType) == 4);\r
  CopyGuid (&mSerialConsole.TermType.Guid, &gEfiTtyTermGuid);\r
\r
  EfiBootManagerUpdateConsoleVariable (ConIn,\r
    (EFI_DEVICE_PATH_PROTOCOL *)&mSerialConsole, NULL);\r
  EfiBootManagerUpdateConsoleVariable (ConOut,\r
    (EFI_DEVICE_PATH_PROTOCOL *)&mSerialConsole, NULL);\r
  EfiBootManagerUpdateConsoleVariable (ErrOut,\r
    (EFI_DEVICE_PATH_PROTOCOL *)&mSerialConsole, NULL);\r
\r
  //\r
  // Register platform-specific boot options and keyboard shortcuts.\r
  //\r
  PlatformRegisterOptionsAndKeys ();\r
}\r
\r
#define VERSION_STRING_PREFIX    L"Tianocore/EDK2 firmware version "\r
\r
/**\r
  Do the platform specific action after the console is ready\r
  Possible things that can be done in PlatformBootManagerAfterConsole:\r
  > Console post action:\r
    > Dynamically switch output mode from 100x31 to 80x25 for certain senarino\r
    > Signal console ready platform customized event\r
  > Run diagnostics like memory testing\r
  > Connect certain devices\r
  > Dispatch aditional option roms\r
  > Special boot: e.g.: USB boot, enter UI\r
**/\r
VOID\r
EFIAPI\r
PlatformBootManagerAfterConsole (\r
  VOID\r
  )\r
{\r
  ESRT_MANAGEMENT_PROTOCOL      *EsrtManagement;\r
  EFI_STATUS                    Status;\r
  EFI_GRAPHICS_OUTPUT_PROTOCOL  *GraphicsOutput;\r
  UINTN                         FirmwareVerLength;\r
  UINTN                         PosX;\r
  UINTN                         PosY;\r
\r
  FirmwareVerLength = StrLen (PcdGetPtr (PcdFirmwareVersionString));\r
\r
  //\r
  // Show the splash screen.\r
  //\r
  Status = BootLogoEnableLogo ();\r
  if (EFI_ERROR (Status)) {\r
    if (FirmwareVerLength > 0) {\r
      Print (VERSION_STRING_PREFIX L"%s",\r
        PcdGetPtr (PcdFirmwareVersionString));\r
    }\r
    Print (L"Press ESCAPE for boot options ");\r
  } else if (FirmwareVerLength > 0) {\r
    Status = gBS->HandleProtocol (gST->ConsoleOutHandle,\r
                    &gEfiGraphicsOutputProtocolGuid, (VOID **)&GraphicsOutput);\r
    if (!EFI_ERROR (Status)) {\r
      PosX = (GraphicsOutput->Mode->Info->HorizontalResolution -\r
              (StrLen (VERSION_STRING_PREFIX) + FirmwareVerLength) *\r
              EFI_GLYPH_WIDTH) / 2;\r
      PosY = 0;\r
\r
      PrintXY (PosX, PosY, NULL, NULL, VERSION_STRING_PREFIX L"%s",\r
        PcdGetPtr (PcdFirmwareVersionString));\r
    }\r
  }\r
\r
  //\r
  // Connect the rest of the devices.\r
  //\r
  EfiBootManagerConnectAll ();\r
\r
  Status = gBS->LocateProtocol (&gEsrtManagementProtocolGuid, NULL,\r
                  (VOID **)&EsrtManagement);\r
  if (!EFI_ERROR (Status)) {\r
    EsrtManagement->SyncEsrtFmp ();\r
  }\r
\r
  if (GetBootModeHob() == BOOT_ON_FLASH_UPDATE) {\r
    DEBUG((DEBUG_INFO, "ProcessCapsules After EndOfDxe ......\n"));\r
    Status = ProcessCapsules ();\r
    DEBUG((DEBUG_INFO, "ProcessCapsules returned %r\n", Status));\r
  }\r
\r
  //\r
  // Enumerate all possible boot options.\r
  //\r
  EfiBootManagerRefreshAllBootOption ();\r
\r
  //\r
  // Register UEFI Shell\r
  //\r
  PlatformRegisterFvBootOption (\r
    &gUefiShellFileGuid, L"UEFI Shell", LOAD_OPTION_ACTIVE\r
    );\r
}\r
\r
/**\r
  This function is called each second during the boot manager waits the\r
  timeout.\r
\r
  @param TimeoutRemain  The remaining timeout.\r
**/\r
VOID\r
EFIAPI\r
PlatformBootManagerWaitCallback (\r
  UINT16          TimeoutRemain\r
  )\r
{\r
  EFI_GRAPHICS_OUTPUT_BLT_PIXEL_UNION Black;\r
  EFI_GRAPHICS_OUTPUT_BLT_PIXEL_UNION White;\r
  UINT16                              Timeout;\r
  EFI_STATUS                          Status;\r
\r
  Timeout = PcdGet16 (PcdPlatformBootTimeOut);\r
\r
  Black.Raw = 0x00000000;\r
  White.Raw = 0x00FFFFFF;\r
\r
  Status = BootLogoUpdateProgress (\r
             White.Pixel,\r
             Black.Pixel,\r
             L"Press ESCAPE for boot options",\r
             White.Pixel,\r
             (Timeout - TimeoutRemain) * 100 / Timeout,\r
             0\r
             );\r
  if (EFI_ERROR (Status)) {\r
    Print (L".");\r
  }\r
}\r