ArmPlatformPkg/Bds/Bds.c

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