[mirror_edk2.git] / ArmPlatformPkg / Bds / Bds.c

/** @file\r
*\r
*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.\r
*  \r
*  This program and the accompanying materials                          \r
*  are licensed and made available under the terms and conditions of the BSD License         \r
*  which accompanies this 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,                     \r
*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             \r
*\r
**/\r
\r
#include "BdsInternal.h"\r
\r
#include <Library/PcdLib.h>\r
#include <Library/PerformanceLib.h>\r
\r
#include <Protocol/Bds.h>\r
\r
#define EFI_SET_TIMER_TO_SECOND   10000000\r
\r
EFI_HANDLE mImageHandle;\r
\r
STATIC\r
EFI_STATUS\r
GetConsoleDevicePathFromVariable (\r
  IN  CHAR16*             ConsoleVarName,\r
  IN  CHAR16*             DefaultConsolePaths,\r
  OUT EFI_DEVICE_PATH**   DevicePaths\r
  )\r
{\r
  EFI_STATUS                Status;\r
  UINTN                     Size;\r
  EFI_DEVICE_PATH_PROTOCOL* DevicePathInstances;\r
  EFI_DEVICE_PATH_PROTOCOL* DevicePathInstance;\r
  CHAR16*                   DevicePathStr;\r
  CHAR16*                   NextDevicePathStr;\r
  EFI_DEVICE_PATH_FROM_TEXT_PROTOCOL  *EfiDevicePathFromTextProtocol;\r
\r
  Status = GetEnvironmentVariable (ConsoleVarName, NULL, NULL, (VOID**)&DevicePathInstances);\r
  if (EFI_ERROR(Status)) {\r
    // In case no default console device path has been defined we assume a driver handles the console (eg: SimpleTextInOutSerial)\r
    if ((DefaultConsolePaths == NULL) || (DefaultConsolePaths[0] == L'\0')) {\r
      *DevicePaths = NULL;\r
      return EFI_SUCCESS;\r
    }\r
\r
    Status = gBS->LocateProtocol (&gEfiDevicePathFromTextProtocolGuid, NULL, (VOID **)&EfiDevicePathFromTextProtocol);\r
    ASSERT_EFI_ERROR(Status);\r
\r
    DevicePathInstances = NULL;\r
\r
    // Extract the Device Path instances from the multi-device path string\r
    while ((DefaultConsolePaths != NULL) && (DefaultConsolePaths[0] != L'\0')) {\r
      NextDevicePathStr = StrStr (DefaultConsolePaths, L";");\r
      if (NextDevicePathStr == NULL) {\r
        DevicePathStr = DefaultConsolePaths;\r
        DefaultConsolePaths = NULL;\r
      } else {\r
        DevicePathStr = (CHAR16*)AllocateCopyPool ((NextDevicePathStr - DefaultConsolePaths + 1) * sizeof(CHAR16), DefaultConsolePaths);\r
        *(DevicePathStr + (NextDevicePathStr - DefaultConsolePaths)) = L'\0';\r
        DefaultConsolePaths = NextDevicePathStr;\r
        if (DefaultConsolePaths[0] == L';') {\r
          DefaultConsolePaths++;\r
        }\r
      }\r
\r
      DevicePathInstance = EfiDevicePathFromTextProtocol->ConvertTextToDevicePath (DevicePathStr);\r
      ASSERT(DevicePathInstance != NULL);\r
      DevicePathInstances = AppendDevicePathInstance (DevicePathInstances, DevicePathInstance);\r
\r
      if (NextDevicePathStr != NULL) {\r
        FreePool (DevicePathStr);\r
      }\r
      FreePool (DevicePathInstance);\r
    }\r
\r
    // Set the environment variable with this device path multi-instances\r
    Size = GetDevicePathSize (DevicePathInstances);\r
    if (Size > 0) {\r
      gRT->SetVariable (\r
          ConsoleVarName,\r
          &gEfiGlobalVariableGuid,\r
          EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,\r
          Size,\r
          DevicePathInstances\r
          );\r
    } else {\r
      Status = EFI_INVALID_PARAMETER;\r
    }\r
  }\r
\r
  if (!EFI_ERROR(Status)) {\r
    *DevicePaths = DevicePathInstances;\r
  }\r
  return Status;\r
}\r
\r
STATIC\r
EFI_STATUS\r
InitializeConsolePipe (\r
  IN EFI_DEVICE_PATH    *ConsoleDevicePaths,\r
  IN EFI_GUID           *Protocol,\r
  OUT EFI_HANDLE        *Handle,\r
  OUT VOID*             *Interface\r
  )\r
{\r
  EFI_STATUS                Status;\r
  UINTN                     Size;\r
  UINTN                     NoHandles;\r
  EFI_HANDLE                *Buffer;\r
  EFI_DEVICE_PATH_PROTOCOL* DevicePath;\r
\r
  // Connect all the Device Path Consoles\r
  while (ConsoleDevicePaths != NULL) {\r
    DevicePath = GetNextDevicePathInstance (&ConsoleDevicePaths, &Size);\r
\r
    Status = BdsConnectDevicePath (DevicePath, Handle, NULL);\r
    DEBUG_CODE_BEGIN();\r
      if (EFI_ERROR(Status)) {\r
        // We convert back to the text representation of the device Path\r
        EFI_DEVICE_PATH_TO_TEXT_PROTOCOL* DevicePathToTextProtocol;\r
        CHAR16* DevicePathTxt;\r
        EFI_STATUS Status;\r
	\r
        Status = gBS->LocateProtocol(&gEfiDevicePathToTextProtocolGuid, NULL, (VOID **)&DevicePathToTextProtocol);\r
        if (!EFI_ERROR(Status)) {\r
          DevicePathTxt = DevicePathToTextProtocol->ConvertDevicePathToText (DevicePath, TRUE, TRUE);\r
\r
          DEBUG((EFI_D_ERROR,"Fail to start the console with the Device Path '%s'. (Error '%r')\n", DevicePathTxt, Status));\r
\r
          FreePool (DevicePathTxt);\r
        }\r
      }\r
    DEBUG_CODE_END();\r
\r
    // If the console splitter driver is not supported by the platform then use the first Device Path\r
    // instance for the console interface.\r
    if (!EFI_ERROR(Status) && (*Interface == NULL)) {\r
      Status = gBS->HandleProtocol (*Handle, Protocol, Interface);\r
    }\r
  }\r
\r
  // No Device Path has been defined for this console interface. We take the first protocol implementation\r
  if (*Interface == NULL) {\r
    Status = gBS->LocateHandleBuffer (ByProtocol, Protocol, NULL, &NoHandles, &Buffer);\r
    if (EFI_ERROR (Status)) {\r
      BdsConnectAllDrivers();\r
      Status = gBS->LocateHandleBuffer (ByProtocol, Protocol, NULL, &NoHandles, &Buffer);\r
    }\r
\r
    if (!EFI_ERROR(Status)) {\r
      *Handle = Buffer[0];\r
      Status = gBS->HandleProtocol (*Handle, Protocol, Interface);\r
      ASSERT_EFI_ERROR(Status);\r
    }\r
    FreePool (Buffer);\r
  } else {\r
    Status = EFI_SUCCESS;\r
  }\r
\r
  return Status;\r
}\r
\r
EFI_STATUS\r
InitializeConsole (\r
  VOID\r
  )\r
{\r
  EFI_STATUS                Status;\r
  EFI_DEVICE_PATH*          ConOutDevicePaths;\r
  EFI_DEVICE_PATH*          ConInDevicePaths;\r
  EFI_DEVICE_PATH*          ConErrDevicePaths;\r
\r
  // By getting the Console Device Paths from the environment variables before initializing the console pipe, we\r
  // create the 3 environment variables (ConIn, ConOut, ConErr) that allows to initialize all the console interface\r
  // of newly installed console drivers\r
  Status = GetConsoleDevicePathFromVariable (L"ConOut", (CHAR16*)PcdGetPtr(PcdDefaultConOutPaths), &ConOutDevicePaths);\r
  ASSERT_EFI_ERROR (Status);\r
  Status = GetConsoleDevicePathFromVariable (L"ConIn", (CHAR16*)PcdGetPtr(PcdDefaultConInPaths), &ConInDevicePaths);\r
  ASSERT_EFI_ERROR (Status);\r
  Status = GetConsoleDevicePathFromVariable (L"ErrOut", (CHAR16*)PcdGetPtr(PcdDefaultConOutPaths), &ConErrDevicePaths);\r
  ASSERT_EFI_ERROR (Status);\r
\r
  // Initialize the Consoles\r
  Status = InitializeConsolePipe (ConOutDevicePaths, &gEfiSimpleTextOutProtocolGuid, &gST->ConsoleOutHandle, (VOID **)&gST->ConOut);\r
  ASSERT_EFI_ERROR (Status);\r
  Status = InitializeConsolePipe (ConInDevicePaths, &gEfiSimpleTextInProtocolGuid, &gST->ConsoleInHandle, (VOID **)&gST->ConIn);\r
  ASSERT_EFI_ERROR (Status);\r
  Status = InitializeConsolePipe (ConErrDevicePaths, &gEfiSimpleTextOutProtocolGuid, &gST->StandardErrorHandle, (VOID **)&gST->StdErr);\r
  if (EFI_ERROR(Status)) {\r
    // In case of error, we reuse the console output for the error output\r
    gST->StandardErrorHandle = gST->ConsoleOutHandle;\r
    gST->StdErr = gST->ConOut;\r
  }\r
\r
  // Free Memory allocated for reading the UEFI Variables\r
  if (ConOutDevicePaths) {\r
    FreePool (ConOutDevicePaths);\r
  }\r
  if (ConInDevicePaths) {\r
    FreePool (ConInDevicePaths);\r
  }\r
  if (ConErrDevicePaths) {\r
    FreePool (ConErrDevicePaths);\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
EFI_STATUS\r
DefineDefaultBootEntries (\r
  VOID\r
  )\r
{\r
  BDS_LOAD_OPTION*                    BdsLoadOption;\r
  UINTN                               Size;\r
  EFI_STATUS                          Status;\r
  EFI_DEVICE_PATH_FROM_TEXT_PROTOCOL* EfiDevicePathFromTextProtocol;\r
  EFI_DEVICE_PATH*                    BootDevicePath;\r
  ARM_BDS_LOADER_ARGUMENTS*           BootArguments;\r
  ARM_BDS_LOADER_TYPE                 BootType;\r
  EFI_DEVICE_PATH*                    InitrdPath;\r
  UINTN                               CmdLineSize;\r
  UINTN                               InitrdSize;\r
\r
  //\r
  // If Boot Order does not exist then create a default entry\r
  //\r
  Size = 0;\r
  Status = gRT->GetVariable (L"BootOrder", &gEfiGlobalVariableGuid, NULL, &Size, NULL);\r
  if (Status == EFI_NOT_FOUND) {\r
    if ((PcdGetPtr(PcdDefaultBootDevicePath) == NULL) || (StrLen ((CHAR16*)PcdGetPtr(PcdDefaultBootDevicePath)) == 0)) {\r
      return EFI_UNSUPPORTED;\r
    }\r
\r
    Status = gBS->LocateProtocol (&gEfiDevicePathFromTextProtocolGuid, NULL, (VOID **)&EfiDevicePathFromTextProtocol);\r
    if (EFI_ERROR(Status)) {\r
      // You must provide an implementation of DevicePathFromTextProtocol in your firmware (eg: DevicePathDxe)\r
      DEBUG((EFI_D_ERROR,"Error: Bds requires DevicePathFromTextProtocol\n"));\r
      return Status;\r
    }\r
    BootDevicePath = EfiDevicePathFromTextProtocol->ConvertTextToDevicePath ((CHAR16*)PcdGetPtr(PcdDefaultBootDevicePath));\r
\r
    DEBUG_CODE_BEGIN();\r
      // We convert back to the text representation of the device Path to see if the initial text is correct\r
      EFI_DEVICE_PATH_TO_TEXT_PROTOCOL* DevicePathToTextProtocol;\r
      CHAR16* DevicePathTxt;\r
\r
      Status = gBS->LocateProtocol(&gEfiDevicePathToTextProtocolGuid, NULL, (VOID **)&DevicePathToTextProtocol);\r
      ASSERT_EFI_ERROR(Status);\r
      DevicePathTxt = DevicePathToTextProtocol->ConvertDevicePathToText (BootDevicePath, TRUE, TRUE);\r
\r
      ASSERT (StrCmp ((CHAR16*)PcdGetPtr(PcdDefaultBootDevicePath), DevicePathTxt) == 0);\r
\r
      FreePool (DevicePathTxt);\r
    DEBUG_CODE_END();\r
\r
    // Create the entry is the Default values are correct\r
    if (BootDevicePath != NULL) {\r
      BootType = (ARM_BDS_LOADER_TYPE)PcdGet32 (PcdDefaultBootType);\r
\r
      if ((BootType == BDS_LOADER_KERNEL_LINUX_ATAG) || (BootType == BDS_LOADER_KERNEL_LINUX_FDT)) {\r
        CmdLineSize = AsciiStrSize ((CHAR8*)PcdGetPtr(PcdDefaultBootArgument));\r
        InitrdPath = EfiDevicePathFromTextProtocol->ConvertTextToDevicePath ((CHAR16*)PcdGetPtr(PcdDefaultBootInitrdPath));\r
        InitrdSize = GetDevicePathSize (InitrdPath);\r
\r
        BootArguments = (ARM_BDS_LOADER_ARGUMENTS*)AllocatePool (sizeof(ARM_BDS_LOADER_ARGUMENTS) + CmdLineSize + InitrdSize);\r
        BootArguments->LinuxArguments.CmdLineSize = CmdLineSize;\r
        BootArguments->LinuxArguments.InitrdSize = InitrdSize;\r
\r
        CopyMem ((VOID*)(BootArguments + 1), (CHAR8*)PcdGetPtr(PcdDefaultBootArgument), CmdLineSize);\r
        CopyMem ((VOID*)((UINTN)(BootArguments + 1) + CmdLineSize), InitrdPath, InitrdSize);\r
      } else {\r
        BootArguments = NULL;\r
      }\r
\r
      BootOptionCreate (LOAD_OPTION_ACTIVE | LOAD_OPTION_CATEGORY_BOOT,\r
        (CHAR16*)PcdGetPtr(PcdDefaultBootDescription),\r
        BootDevicePath,\r
        BootType,\r
        BootArguments,\r
        &BdsLoadOption\r
        );\r
      FreePool (BdsLoadOption);\r
    } else {\r
      Status = EFI_UNSUPPORTED;\r
    }\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
EFI_STATUS\r
StartDefaultBootOnTimeout (\r
  VOID\r
  )\r
{\r
  UINTN               Size;\r
  UINT16              Timeout;\r
  UINT16              *TimeoutPtr;\r
  EFI_EVENT           WaitList[2];\r
  UINTN               WaitIndex;\r
  UINT16              *BootOrder;\r
  UINTN               BootOrderSize;\r
  UINTN               Index;\r
  CHAR16              BootVariableName[9];\r
  EFI_STATUS          Status;\r
  EFI_INPUT_KEY       Key;\r
\r
  Size = sizeof(UINT16);\r
  Timeout = (UINT16)PcdGet16 (PcdPlatformBootTimeOut);\r
  TimeoutPtr = &Timeout;\r
  GetEnvironmentVariable (L"Timeout", &Timeout, &Size, (VOID**)&TimeoutPtr);\r
\r
  if (Timeout != 0xFFFF) {\r
    if (Timeout > 0) {\r
      // Create the waiting events (keystroke and 1sec timer)\r
      gBS->CreateEvent (EVT_TIMER, 0, NULL, NULL, &WaitList[0]);\r
      gBS->SetTimer (WaitList[0], TimerPeriodic, EFI_SET_TIMER_TO_SECOND);\r
      WaitList[1] = gST->ConIn->WaitForKey;\r
\r
      // Start the timer\r
      WaitIndex = 0;\r
      Print(L"The default boot selection will start in ");\r
      while ((Timeout > 0) && (WaitIndex == 0)) {\r
        Print(L"%3d seconds",Timeout);\r
        gBS->WaitForEvent (2, WaitList, &WaitIndex);\r
        if (WaitIndex == 0) {\r
          Print(L"\b\b\b\b\b\b\b\b\b\b\b");\r
          Timeout--;\r
        }\r
      }\r
      // Discard key in the buffer\r
      do {\r
      	Status = gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);\r
      } while(!EFI_ERROR(Status));\r
      gBS->CloseEvent (WaitList[0]);\r
      Print(L"\n\r");\r
    }\r
\r
    // In case of Timeout we start the default boot selection\r
    if (Timeout == 0) {\r
      // Get the Boot Option Order from the environment variable (a default value should have been created)\r
      GetEnvironmentVariable (L"BootOrder", NULL, &BootOrderSize, (VOID**)&BootOrder);\r
\r
      for (Index = 0; Index < BootOrderSize / sizeof (UINT16); Index++) {\r
        UnicodeSPrint (BootVariableName, 9 * sizeof(CHAR16), L"Boot%04X", BootOrder[Index]);\r
        Status = BdsStartBootOption (BootVariableName);\r
        if(!EFI_ERROR(Status)){\r
        	// Boot option returned successfully, hence don't need to start next boot option\r
        	break;\r
        }\r
        // In case of success, we should not return from this call.\r
      }\r
      FreePool (BootOrder);\r
    }\r
  }\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  This function uses policy data from the platform to determine what operating \r
  system or system utility should be loaded and invoked.  This function call \r
  also optionally make the use of user input to determine the operating system \r
  or system utility to be loaded and invoked.  When the DXE Core has dispatched \r
  all the drivers on the dispatch queue, this function is called.  This \r
  function will attempt to connect the boot devices required to load and invoke \r
  the selected operating system or system utility.  During this process, \r
  additional firmware volumes may be discovered that may contain addition DXE \r
  drivers that can be dispatched by the DXE Core.   If a boot device cannot be \r
  fully connected, this function calls the DXE Service Dispatch() to allow the \r
  DXE drivers from any newly discovered firmware volumes to be dispatched.  \r
  Then the boot device connection can be attempted again.  If the same boot \r
  device connection operation fails twice in a row, then that boot device has \r
  failed, and should be skipped.  This function should never return.\r
\r
  @param  This             The EFI_BDS_ARCH_PROTOCOL instance.\r
\r
  @return None.\r
\r
**/\r
VOID\r
EFIAPI\r
BdsEntry (\r
  IN EFI_BDS_ARCH_PROTOCOL  *This\r
  )\r
{\r
  UINTN               Size;\r
  EFI_STATUS          Status;\r
  UINT16             *BootNext;\r
  UINTN               BootNextSize;\r
  CHAR16              BootVariableName[9];\r
\r
  PERF_END   (NULL, "DXE", NULL, 0);\r
\r
  //\r
  // Declare the Firmware Vendor\r
  //\r
  if (FixedPcdGetPtr(PcdFirmwareVendor) != NULL) {\r
    Size = 0x100;\r
    gST->FirmwareVendor = AllocateRuntimePool (Size);\r
    ASSERT (gST->FirmwareVendor != NULL);\r
    UnicodeSPrint (gST->FirmwareVendor, Size, L"%a EFI %a %a", PcdGetPtr(PcdFirmwareVendor), __DATE__, __TIME__);\r
  }\r
\r
  // If BootNext environment variable is defined then we just load it !\r
  BootNextSize = sizeof(UINT16);\r
  Status = GetEnvironmentVariable (L"BootNext", NULL, &BootNextSize, (VOID**)&BootNext);\r
  if (!EFI_ERROR(Status)) {\r
    ASSERT(BootNextSize == sizeof(UINT16));\r
\r
    // Generate the requested Boot Entry variable name\r
    UnicodeSPrint (BootVariableName, 9 * sizeof(CHAR16), L"Boot%04X", *BootNext);\r
\r
    // Set BootCurrent variable\r
    gRT->SetVariable (L"BootCurrent", &gEfiGlobalVariableGuid,\r
              EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,\r
              BootNextSize, BootNext);\r
\r
    FreePool (BootNext);\r
\r
    // Start the requested Boot Entry\r
    Status = BdsStartBootOption (BootVariableName);\r
    if (Status != EFI_NOT_FOUND) {\r
      // BootNext has not been succeeded launched\r
      if (EFI_ERROR(Status)) {\r
        Print(L"Fail to start BootNext.\n");\r
      }\r
\r
      // Delete the BootNext environment variable\r
      gRT->SetVariable (L"BootNext", &gEfiGlobalVariableGuid,\r
          EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,\r
          0, NULL);\r
    }\r
\r
    // Clear BootCurrent variable\r
    gRT->SetVariable (L"BootCurrent", &gEfiGlobalVariableGuid,\r
        EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,\r
        0, NULL);\r
  }\r
\r
  // If Boot Order does not exist then create a default entry\r
  DefineDefaultBootEntries ();\r
\r
  // Now we need to setup the EFI System Table with information about the console devices.\r
  InitializeConsole ();\r
\r
  // Timer before initiating the default boot selection\r
  StartDefaultBootOnTimeout ();\r
\r
  // Start the Boot Menu\r
  Status = BootMenuMain ();\r
  ASSERT_EFI_ERROR (Status);\r
\r
}\r
\r
EFI_BDS_ARCH_PROTOCOL  gBdsProtocol = {\r
  BdsEntry,\r
};\r
\r
EFI_STATUS\r
EFIAPI\r
BdsInitialize (\r
  IN EFI_HANDLE                            ImageHandle,\r
  IN EFI_SYSTEM_TABLE                      *SystemTable\r
  )\r
{\r
  EFI_STATUS  Status;\r
\r
  mImageHandle = ImageHandle;\r
\r
  Status = gBS->InstallMultipleProtocolInterfaces (\r
                  &ImageHandle,\r
                  &gEfiBdsArchProtocolGuid, &gBdsProtocol,\r
                  NULL\r
                  );\r
  ASSERT_EFI_ERROR (Status);\r
\r
  return Status;\r
}\r
Commit	Line	Data
705b0c03	1	/** @file\r
705b0c03	2	*\r
b148591a	3	* Copyright (c) 2011-2012, ARM Limited. All rights reserved.\r
705b0c03	4	* \r
	5	* This program and the accompanying materials \r
	6	* are licensed and made available under the terms and conditions of the BSD License \r
	7	* which accompanies this distribution. The full text of the license may be found at \r
	8	* http://opensource.org/licenses/bsd-license.php \r
	9	*\r
	10	* THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, \r
	11	* WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. \r
	12	*\r
	13	**/\r
	14	\r
	15	#include "BdsInternal.h"\r
	16	\r
	17	#include <Library/PcdLib.h>\r
	18	#include <Library/PerformanceLib.h>\r
	19	\r
	20	#include <Protocol/Bds.h>\r
	21	\r
	22	#define EFI_SET_TIMER_TO_SECOND 10000000\r
	23	\r
	24	EFI_HANDLE mImageHandle;\r
	25	\r
	26	STATIC\r
	27	EFI_STATUS\r
	28	GetConsoleDevicePathFromVariable (\r
	29	IN CHAR16* ConsoleVarName,\r
	30	IN CHAR16* DefaultConsolePaths,\r
	31	OUT EFI_DEVICE_PATH** DevicePaths\r
	32	)\r
	33	{\r
	34	EFI_STATUS Status;\r
	35	UINTN Size;\r
	36	EFI_DEVICE_PATH_PROTOCOL* DevicePathInstances;\r
	37	EFI_DEVICE_PATH_PROTOCOL* DevicePathInstance;\r
	38	CHAR16* DevicePathStr;\r
	39	CHAR16* NextDevicePathStr;\r
	40	EFI_DEVICE_PATH_FROM_TEXT_PROTOCOL *EfiDevicePathFromTextProtocol;\r
	41	\r
	42	Status = GetEnvironmentVariable (ConsoleVarName, NULL, NULL, (VOID**)&DevicePathInstances);\r
	43	if (EFI_ERROR(Status)) {\r
483bc3d3	44	// In case no default console device path has been defined we assume a driver handles the console (eg: SimpleTextInOutSerial)\r
	45	if ((DefaultConsolePaths == NULL) \|\| (DefaultConsolePaths[0] == L'\0')) {\r
	46	*DevicePaths = NULL;\r
	47	return EFI_SUCCESS;\r
	48	}\r
	49	\r
705b0c03	50	Status = gBS->LocateProtocol (&gEfiDevicePathFromTextProtocolGuid, NULL, (VOID **)&EfiDevicePathFromTextProtocol);\r
	51	ASSERT_EFI_ERROR(Status);\r
	52	\r
	53	DevicePathInstances = NULL;\r
	54	\r
	55	// Extract the Device Path instances from the multi-device path string\r
	56	while ((DefaultConsolePaths != NULL) && (DefaultConsolePaths[0] != L'\0')) {\r
	57	NextDevicePathStr = StrStr (DefaultConsolePaths, L";");\r
	58	if (NextDevicePathStr == NULL) {\r
	59	DevicePathStr = DefaultConsolePaths;\r
	60	DefaultConsolePaths = NULL;\r
	61	} else {\r
	62	DevicePathStr = (CHAR16)AllocateCopyPool ((NextDevicePathStr - DefaultConsolePaths + 1) sizeof(CHAR16), DefaultConsolePaths);\r
	63	*(DevicePathStr + (NextDevicePathStr - DefaultConsolePaths)) = L'\0';\r
	64	DefaultConsolePaths = NextDevicePathStr;\r
	65	if (DefaultConsolePaths[0] == L';') {\r
	66	DefaultConsolePaths++;\r
	67	}\r
	68	}\r
	69	\r
	70	DevicePathInstance = EfiDevicePathFromTextProtocol->ConvertTextToDevicePath (DevicePathStr);\r
	71	ASSERT(DevicePathInstance != NULL);\r
	72	DevicePathInstances = AppendDevicePathInstance (DevicePathInstances, DevicePathInstance);\r
	73	\r
	74	if (NextDevicePathStr != NULL) {\r
	75	FreePool (DevicePathStr);\r
	76	}\r
	77	FreePool (DevicePathInstance);\r
	78	}\r
	79	\r
	80	// Set the environment variable with this device path multi-instances\r
	81	Size = GetDevicePathSize (DevicePathInstances);\r
	82	if (Size > 0) {\r
	83	gRT->SetVariable (\r
	84	ConsoleVarName,\r
	85	&gEfiGlobalVariableGuid,\r
	86	EFI_VARIABLE_NON_VOLATILE \| EFI_VARIABLE_BOOTSERVICE_ACCESS \| EFI_VARIABLE_RUNTIME_ACCESS,\r
	87	Size,\r
	88	DevicePathInstances\r
	89	);\r
	90	} else {\r
	91	Status = EFI_INVALID_PARAMETER;\r
	92	}\r
	93	}\r
	94	\r
	95	if (!EFI_ERROR(Status)) {\r
	96	*DevicePaths = DevicePathInstances;\r
	97	}\r
483bc3d3	98	return Status;\r
705b0c03	99	}\r
	100	\r
	101	STATIC\r
	102	EFI_STATUS\r
	103	InitializeConsolePipe (\r
	104	IN EFI_DEVICE_PATH *ConsoleDevicePaths,\r
	105	IN EFI_GUID *Protocol,\r
	106	OUT EFI_HANDLE *Handle,\r
	107	OUT VOID* *Interface\r
	108	)\r
	109	{\r
	110	EFI_STATUS Status;\r
	111	UINTN Size;\r
	112	UINTN NoHandles;\r
	113	EFI_HANDLE *Buffer;\r
	114	EFI_DEVICE_PATH_PROTOCOL* DevicePath;\r
	115	\r
	116	// Connect all the Device Path Consoles\r
483bc3d3	117	while (ConsoleDevicePaths != NULL) {\r
705b0c03	118	DevicePath = GetNextDevicePathInstance (&ConsoleDevicePaths, &Size);\r
	119	\r
	120	Status = BdsConnectDevicePath (DevicePath, Handle, NULL);\r
	121	DEBUG_CODE_BEGIN();\r
	122	if (EFI_ERROR(Status)) {\r
	123	// We convert back to the text representation of the device Path\r
	124	EFI_DEVICE_PATH_TO_TEXT_PROTOCOL* DevicePathToTextProtocol;\r
	125	CHAR16* DevicePathTxt;\r
	126	EFI_STATUS Status;\r
	127	\r
	128	Status = gBS->LocateProtocol(&gEfiDevicePathToTextProtocolGuid, NULL, (VOID **)&DevicePathToTextProtocol);\r
	129	if (!EFI_ERROR(Status)) {\r
	130	DevicePathTxt = DevicePathToTextProtocol->ConvertDevicePathToText (DevicePath, TRUE, TRUE);\r
	131	\r
	132	DEBUG((EFI_D_ERROR,"Fail to start the console with the Device Path '%s'. (Error '%r')\n", DevicePathTxt, Status));\r
	133	\r
	134	FreePool (DevicePathTxt);\r
	135	}\r
	136	}\r
	137	DEBUG_CODE_END();\r
	138	\r
	139	// If the console splitter driver is not supported by the platform then use the first Device Path\r
	140	// instance for the console interface.\r
	141	if (!EFI_ERROR(Status) && (*Interface == NULL)) {\r
	142	Status = gBS->HandleProtocol (*Handle, Protocol, Interface);\r
	143	}\r
483bc3d3	144	}\r
705b0c03	145	\r
	146	// No Device Path has been defined for this console interface. We take the first protocol implementation\r
	147	if (*Interface == NULL) {\r
	148	Status = gBS->LocateHandleBuffer (ByProtocol, Protocol, NULL, &NoHandles, &Buffer);\r
	149	if (EFI_ERROR (Status)) {\r
	150	BdsConnectAllDrivers();\r
	151	Status = gBS->LocateHandleBuffer (ByProtocol, Protocol, NULL, &NoHandles, &Buffer);\r
	152	}\r
	153	\r
	154	if (!EFI_ERROR(Status)) {\r
	155	*Handle = Buffer[0];\r
	156	Status = gBS->HandleProtocol (*Handle, Protocol, Interface);\r
	157	ASSERT_EFI_ERROR(Status);\r
	158	}\r
	159	FreePool (Buffer);\r
	160	} else {\r
	161	Status = EFI_SUCCESS;\r
	162	}\r
	163	\r
	164	return Status;\r
	165	}\r
	166	\r
	167	EFI_STATUS\r
	168	InitializeConsole (\r
	169	VOID\r
	170	)\r
	171	{\r
	172	EFI_STATUS Status;\r
	173	EFI_DEVICE_PATH* ConOutDevicePaths;\r
	174	EFI_DEVICE_PATH* ConInDevicePaths;\r
	175	EFI_DEVICE_PATH* ConErrDevicePaths;\r
	176	\r
	177	// By getting the Console Device Paths from the environment variables before initializing the console pipe, we\r
	178	// create the 3 environment variables (ConIn, ConOut, ConErr) that allows to initialize all the console interface\r
	179	// of newly installed console drivers\r
483bc3d3	180	Status = GetConsoleDevicePathFromVariable (L"ConOut", (CHAR16*)PcdGetPtr(PcdDefaultConOutPaths), &ConOutDevicePaths);\r
705b0c03	181	ASSERT_EFI_ERROR (Status);\r
483bc3d3	182	Status = GetConsoleDevicePathFromVariable (L"ConIn", (CHAR16*)PcdGetPtr(PcdDefaultConInPaths), &ConInDevicePaths);\r
705b0c03	183	ASSERT_EFI_ERROR (Status);\r
30d1bcd1	184	Status = GetConsoleDevicePathFromVariable (L"ErrOut", (CHAR16*)PcdGetPtr(PcdDefaultConOutPaths), &ConErrDevicePaths);\r
705b0c03	185	ASSERT_EFI_ERROR (Status);\r
	186	\r
	187	// Initialize the Consoles\r
	188	Status = InitializeConsolePipe (ConOutDevicePaths, &gEfiSimpleTextOutProtocolGuid, &gST->ConsoleOutHandle, (VOID **)&gST->ConOut);\r
	189	ASSERT_EFI_ERROR (Status);\r
	190	Status = InitializeConsolePipe (ConInDevicePaths, &gEfiSimpleTextInProtocolGuid, &gST->ConsoleInHandle, (VOID **)&gST->ConIn);\r
	191	ASSERT_EFI_ERROR (Status);\r
	192	Status = InitializeConsolePipe (ConErrDevicePaths, &gEfiSimpleTextOutProtocolGuid, &gST->StandardErrorHandle, (VOID **)&gST->StdErr);\r
	193	if (EFI_ERROR(Status)) {\r
	194	// In case of error, we reuse the console output for the error output\r
	195	gST->StandardErrorHandle = gST->ConsoleOutHandle;\r
	196	gST->StdErr = gST->ConOut;\r
	197	}\r
	198	\r
b148591a	199	// Free Memory allocated for reading the UEFI Variables\r
	200	if (ConOutDevicePaths) {\r
	201	FreePool (ConOutDevicePaths);\r
	202	}\r
	203	if (ConInDevicePaths) {\r
	204	FreePool (ConInDevicePaths);\r
	205	}\r
	206	if (ConErrDevicePaths) {\r
	207	FreePool (ConErrDevicePaths);\r
	208	}\r
	209	\r
705b0c03	210	return EFI_SUCCESS;\r
	211	}\r
	212	\r
	213	EFI_STATUS\r
	214	DefineDefaultBootEntries (\r
	215	VOID\r
	216	)\r
	217	{\r
	218	BDS_LOAD_OPTION* BdsLoadOption;\r
	219	UINTN Size;\r
	220	EFI_STATUS Status;\r
	221	EFI_DEVICE_PATH_FROM_TEXT_PROTOCOL* EfiDevicePathFromTextProtocol;\r
	222	EFI_DEVICE_PATH* BootDevicePath;\r
	223	ARM_BDS_LOADER_ARGUMENTS* BootArguments;\r
	224	ARM_BDS_LOADER_TYPE BootType;\r
	225	EFI_DEVICE_PATH* InitrdPath;\r
	226	UINTN CmdLineSize;\r
	227	UINTN InitrdSize;\r
	228	\r
	229	//\r
	230	// If Boot Order does not exist then create a default entry\r
	231	//\r
	232	Size = 0;\r
	233	Status = gRT->GetVariable (L"BootOrder", &gEfiGlobalVariableGuid, NULL, &Size, NULL);\r
	234	if (Status == EFI_NOT_FOUND) {\r
	235	if ((PcdGetPtr(PcdDefaultBootDevicePath) == NULL) \|\| (StrLen ((CHAR16*)PcdGetPtr(PcdDefaultBootDevicePath)) == 0)) {\r
	236	return EFI_UNSUPPORTED;\r
	237	}\r
	238	\r
	239	Status = gBS->LocateProtocol (&gEfiDevicePathFromTextProtocolGuid, NULL, (VOID **)&EfiDevicePathFromTextProtocol);\r
	240	if (EFI_ERROR(Status)) {\r
	241	// You must provide an implementation of DevicePathFromTextProtocol in your firmware (eg: DevicePathDxe)\r
	242	DEBUG((EFI_D_ERROR,"Error: Bds requires DevicePathFromTextProtocol\n"));\r
	243	return Status;\r
	244	}\r
	245	BootDevicePath = EfiDevicePathFromTextProtocol->ConvertTextToDevicePath ((CHAR16*)PcdGetPtr(PcdDefaultBootDevicePath));\r
	246	\r
	247	DEBUG_CODE_BEGIN();\r
	248	// We convert back to the text representation of the device Path to see if the initial text is correct\r
	249	EFI_DEVICE_PATH_TO_TEXT_PROTOCOL* DevicePathToTextProtocol;\r
	250	CHAR16* DevicePathTxt;\r
	251	\r
	252	Status = gBS->LocateProtocol(&gEfiDevicePathToTextProtocolGuid, NULL, (VOID **)&DevicePathToTextProtocol);\r
	253	ASSERT_EFI_ERROR(Status);\r
	254	DevicePathTxt = DevicePathToTextProtocol->ConvertDevicePathToText (BootDevicePath, TRUE, TRUE);\r
	255	\r
	256	ASSERT (StrCmp ((CHAR16*)PcdGetPtr(PcdDefaultBootDevicePath), DevicePathTxt) == 0);\r
	257	\r
	258	FreePool (DevicePathTxt);\r
	259	DEBUG_CODE_END();\r
	260	\r
	261	// Create the entry is the Default values are correct\r
	262	if (BootDevicePath != NULL) {\r
	263	BootType = (ARM_BDS_LOADER_TYPE)PcdGet32 (PcdDefaultBootType);\r
	264	\r
	265	if ((BootType == BDS_LOADER_KERNEL_LINUX_ATAG) \|\| (BootType == BDS_LOADER_KERNEL_LINUX_FDT)) {\r
	266	CmdLineSize = AsciiStrSize ((CHAR8*)PcdGetPtr(PcdDefaultBootArgument));\r
	267	InitrdPath = EfiDevicePathFromTextProtocol->ConvertTextToDevicePath ((CHAR16*)PcdGetPtr(PcdDefaultBootInitrdPath));\r
	268	InitrdSize = GetDevicePathSize (InitrdPath);\r
	269	\r
	270	BootArguments = (ARM_BDS_LOADER_ARGUMENTS*)AllocatePool (sizeof(ARM_BDS_LOADER_ARGUMENTS) + CmdLineSize + InitrdSize);\r
	271	BootArguments->LinuxArguments.CmdLineSize = CmdLineSize;\r
	272	BootArguments->LinuxArguments.InitrdSize = InitrdSize;\r
	273	\r
274	CopyMem ((VOID)(BootArguments + 1), (CHAR8)PcdGetPtr(PcdDefaultBootArgument), CmdLineSize);\r
275	CopyMem ((VOID*)((UINTN)(BootArguments + 1) + CmdLineSize), InitrdPath, InitrdSize);\r
276	} else {\r
277	BootArguments = NULL;\r
278	}\r
279	\r
280	BootOptionCreate (LOAD_OPTION_ACTIVE \| LOAD_OPTION_CATEGORY_BOOT,\r
281	(CHAR16*)PcdGetPtr(PcdDefaultBootDescription),\r
282	BootDevicePath,\r
283	BootType,\r
284	BootArguments,\r
285	&BdsLoadOption\r
286	);\r
287	FreePool (BdsLoadOption);\r
288	} else {\r
289	Status = EFI_UNSUPPORTED;\r
290	}\r
291	}\r
292	\r
293	return EFI_SUCCESS;\r
294	}\r
295	\r
296	EFI_STATUS\r
297	StartDefaultBootOnTimeout (\r
298	VOID\r
299	)\r
300	{\r
301	UINTN Size;\r
302	UINT16 Timeout;\r
303	UINT16 *TimeoutPtr;\r
304	EFI_EVENT WaitList[2];\r
305	UINTN WaitIndex;\r
306	UINT16 *BootOrder;\r
307	UINTN BootOrderSize;\r
308	UINTN Index;\r
309	CHAR16 BootVariableName[9];\r
b34e4db3	310	EFI_STATUS Status;\r
b34e4db3	311	EFI_INPUT_KEY Key;\r
705b0c03	312	\r
	313	Size = sizeof(UINT16);\r
	314	Timeout = (UINT16)PcdGet16 (PcdPlatformBootTimeOut);\r
	315	TimeoutPtr = &Timeout;\r
	316	GetEnvironmentVariable (L"Timeout", &Timeout, &Size, (VOID**)&TimeoutPtr);\r
	317	\r
	318	if (Timeout != 0xFFFF) {\r
	319	if (Timeout > 0) {\r
	320	// Create the waiting events (keystroke and 1sec timer)\r
	321	gBS->CreateEvent (EVT_TIMER, 0, NULL, NULL, &WaitList[0]);\r
	322	gBS->SetTimer (WaitList[0], TimerPeriodic, EFI_SET_TIMER_TO_SECOND);\r
	323	WaitList[1] = gST->ConIn->WaitForKey;\r
	324	\r
	325	// Start the timer\r
	326	WaitIndex = 0;\r
	327	Print(L"The default boot selection will start in ");\r
	328	while ((Timeout > 0) && (WaitIndex == 0)) {\r
	329	Print(L"%3d seconds",Timeout);\r
	330	gBS->WaitForEvent (2, WaitList, &WaitIndex);\r
	331	if (WaitIndex == 0) {\r
	332	Print(L"\b\b\b\b\b\b\b\b\b\b\b");\r
	333	Timeout--;\r
	334	}\r
	335	}\r
	336	// Discard key in the buffer\r
	337	do {\r
	338	Status = gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);\r
	339	} while(!EFI_ERROR(Status));\r
	340	gBS->CloseEvent (WaitList[0]);\r
	341	Print(L"\n\r");\r
	342	}\r
	343	\r
	344	// In case of Timeout we start the default boot selection\r
	345	if (Timeout == 0) {\r
	346	// Get the Boot Option Order from the environment variable (a default value should have been created)\r
	347	GetEnvironmentVariable (L"BootOrder", NULL, &BootOrderSize, (VOID**)&BootOrder);\r
	348	\r
	349	for (Index = 0; Index < BootOrderSize / sizeof (UINT16); Index++) {\r
	350	UnicodeSPrint (BootVariableName, 9 * sizeof(CHAR16), L"Boot%04X", BootOrder[Index]);\r
	351	Status = BdsStartBootOption (BootVariableName);\r
	352	if(!EFI_ERROR(Status)){\r
	353	// Boot option returned successfully, hence don't need to start next boot option\r
	354	break;\r
	355	}\r
	356	// In case of success, we should not return from this call.\r
	357	}\r
b148591a	358	FreePool (BootOrder);\r
705b0c03	359	}\r
	360	}\r
	361	return EFI_SUCCESS;\r
	362	}\r
	363	\r
	364	/**\r
	365	This function uses policy data from the platform to determine what operating \r
	366	system or system utility should be loaded and invoked. This function call \r
	367	also optionally make the use of user input to determine the operating system \r
	368	or system utility to be loaded and invoked. When the DXE Core has dispatched \r
	369	all the drivers on the dispatch queue, this function is called. This \r
	370	function will attempt to connect the boot devices required to load and invoke \r
	371	the selected operating system or system utility. During this process, \r
	372	additional firmware volumes may be discovered that may contain addition DXE \r
	373	drivers that can be dispatched by the DXE Core. If a boot device cannot be \r
	374	fully connected, this function calls the DXE Service Dispatch() to allow the \r
	375	DXE drivers from any newly discovered firmware volumes to be dispatched. \r
	376	Then the boot device connection can be attempted again. If the same boot \r
	377	device connection operation fails twice in a row, then that boot device has \r
	378	failed, and should be skipped. This function should never return.\r
	379	\r
	380	@param This The EFI_BDS_ARCH_PROTOCOL instance.\r
	381	\r
	382	@return None.\r
	383	\r
	384	**/\r
	385	VOID\r
	386	EFIAPI\r
	387	BdsEntry (\r
	388	IN EFI_BDS_ARCH_PROTOCOL *This\r
	389	)\r
	390	{\r
	391	UINTN Size;\r
	392	EFI_STATUS Status;\r
0e29bf5c	393	UINT16 *BootNext;\r
	394	UINTN BootNextSize;\r
	395	CHAR16 BootVariableName[9];\r
705b0c03	396	\r
	397	PERF_END (NULL, "DXE", NULL, 0);\r
	398	\r
	399	//\r
	400	// Declare the Firmware Vendor\r
	401	//\r
	402	if (FixedPcdGetPtr(PcdFirmwareVendor) != NULL) {\r
	403	Size = 0x100;\r
	404	gST->FirmwareVendor = AllocateRuntimePool (Size);\r
	405	ASSERT (gST->FirmwareVendor != NULL);\r
	406	UnicodeSPrint (gST->FirmwareVendor, Size, L"%a EFI %a %a", PcdGetPtr(PcdFirmwareVendor), __DATE__, __TIME__);\r
	407	}\r
	408	\r
	409	// If BootNext environment variable is defined then we just load it !\r
0e29bf5c	410	BootNextSize = sizeof(UINT16);\r
	411	Status = GetEnvironmentVariable (L"BootNext", NULL, &BootNextSize, (VOID**)&BootNext);\r
	412	if (!EFI_ERROR(Status)) {\r
	413	ASSERT(BootNextSize == sizeof(UINT16));\r
	414	\r
	415	// Generate the requested Boot Entry variable name\r
	416	UnicodeSPrint (BootVariableName, 9 * sizeof(CHAR16), L"Boot%04X", *BootNext);\r
	417	\r
	418	// Set BootCurrent variable\r
	419	gRT->SetVariable (L"BootCurrent", &gEfiGlobalVariableGuid,\r
	420	EFI_VARIABLE_BOOTSERVICE_ACCESS \| EFI_VARIABLE_RUNTIME_ACCESS,\r
	421	BootNextSize, BootNext);\r
	422	\r
	423	FreePool (BootNext);\r
	424	\r
	425	// Start the requested Boot Entry\r
	426	Status = BdsStartBootOption (BootVariableName);\r
	427	if (Status != EFI_NOT_FOUND) {\r
	428	// BootNext has not been succeeded launched\r
	429	if (EFI_ERROR(Status)) {\r
	430	Print(L"Fail to start BootNext.\n");\r
	431	}\r
	432	\r
	433	// Delete the BootNext environment variable\r
	434	gRT->SetVariable (L"BootNext", &gEfiGlobalVariableGuid,\r
	435	EFI_VARIABLE_NON_VOLATILE \| EFI_VARIABLE_BOOTSERVICE_ACCESS \| EFI_VARIABLE_RUNTIME_ACCESS,\r
	436	0, NULL);\r
705b0c03	437	}\r
705b0c03	438	\r
0e29bf5c	439	// Clear BootCurrent variable\r
	440	gRT->SetVariable (L"BootCurrent", &gEfiGlobalVariableGuid,\r
	441	EFI_VARIABLE_BOOTSERVICE_ACCESS \| EFI_VARIABLE_RUNTIME_ACCESS,\r
705b0c03	442	0, NULL);\r
	443	}\r
	444	\r
	445	// If Boot Order does not exist then create a default entry\r
	446	DefineDefaultBootEntries ();\r
	447	\r
	448	// Now we need to setup the EFI System Table with information about the console devices.\r
	449	InitializeConsole ();\r
	450	\r
	451	// Timer before initiating the default boot selection\r
	452	StartDefaultBootOnTimeout ();\r
	453	\r
	454	// Start the Boot Menu\r
	455	Status = BootMenuMain ();\r
	456	ASSERT_EFI_ERROR (Status);\r
	457	\r
	458	}\r
	459	\r
	460	EFI_BDS_ARCH_PROTOCOL gBdsProtocol = {\r
	461	BdsEntry,\r
	462	};\r
	463	\r
	464	EFI_STATUS\r
	465	EFIAPI\r
	466	BdsInitialize (\r
	467	IN EFI_HANDLE ImageHandle,\r
	468	IN EFI_SYSTEM_TABLE *SystemTable\r
	469	)\r
	470	{\r
	471	EFI_STATUS Status;\r
	472	\r
	473	mImageHandle = ImageHandle;\r
	474	\r
	475	Status = gBS->InstallMultipleProtocolInterfaces (\r
	476	&ImageHandle,\r
	477	&gEfiBdsArchProtocolGuid, &gBdsProtocol,\r
	478	NULL\r
	479	);\r
	480	ASSERT_EFI_ERROR (Status);\r
	481	\r
	482	return Status;\r
	483	}\r