ArmPlatformPkg/Bds/Bds.c

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