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
 207   //
 208   // If Boot Order does not exist then create a default entry
 209   //
 210   Size = 0;
 211   Status = gRT->GetVariable (L"BootOrder", &gEfiGlobalVariableGuid, NULL, &Size, NULL);
 212   if (Status == EFI_NOT_FOUND) {
 213     Status = gBS->LocateProtocol (&gEfiDevicePathFromTextProtocolGuid, NULL, (VOID **)&EfiDevicePathFromTextProtocol);
 214     ASSERT_EFI_ERROR(Status);
 215     BootDevicePath = EfiDevicePathFromTextProtocol->ConvertTextToDevicePath ((CHAR16*)PcdGetPtr(PcdDefaultBootDevicePath));
 216
 217     DEBUG_CODE_BEGIN();
 218       // We convert back to the text representation of the device Path to see if the initial text is correct
 219       EFI_DEVICE_PATH_TO_TEXT_PROTOCOL* DevicePathToTextProtocol;
 220       CHAR16* DevicePathTxt;
 221
 222       Status = gBS->LocateProtocol(&gEfiDevicePathToTextProtocolGuid, NULL, (VOID **)&DevicePathToTextProtocol);
 223       ASSERT_EFI_ERROR(Status);
 224       DevicePathTxt = DevicePathToTextProtocol->ConvertDevicePathToText (BootDevicePath, TRUE, TRUE);
 225
 226       ASSERT (StrCmp ((CHAR16*)PcdGetPtr(PcdDefaultBootDevicePath), DevicePathTxt) == 0);
 227
 228       FreePool (DevicePathTxt);
 229     DEBUG_CODE_END();
 230
 231     // Create the entry is the Default values are correct
 232     if (BootDevicePath != NULL) {
 233       BootOptionCreate (LOAD_OPTION_ACTIVE | LOAD_OPTION_CATEGORY_BOOT,
 234         (CHAR16*)PcdGetPtr(PcdDefaultBootDescription),
 235         BootDevicePath,
 236         (BDS_LOADER_TYPE)PcdGet32 (PcdDefaultBootType),
 237         (CHAR8*)PcdGetPtr(PcdDefaultBootArgument),
 238         &BdsLoadOption
 239         );
 240       FreePool (BdsLoadOption);
 241     }
 242   }
 243
 244   return EFI_SUCCESS;
 245 }
 246
 247 EFI_STATUS
 248 StartDefaultBootOnTimeout (
 249   VOID
 250   )
 251 {
 252   UINTN               Size;
 253   UINT16              Timeout;
 254   UINT16              *TimeoutPtr;
 255   EFI_EVENT           WaitList[2];
 256   UINTN               WaitIndex;
 257   UINT16              *BootOrder;
 258   UINTN               BootOrderSize;
 259   UINTN               Index;
 260   CHAR16              BootVariableName[9];
 261   EFI_STATUS           Status;
 262
 263   Size = sizeof(UINT16);
 264   Timeout = (UINT16)PcdGet16 (PcdPlatformBootTimeOut);
 265   TimeoutPtr = &Timeout;
 266   GetEnvironmentVariable (L"Timeout", &Timeout, &Size, (VOID**)&TimeoutPtr);
 267
 268   if (Timeout != 0xFFFF) {
 269     if (Timeout > 0) {
 270       // Create the waiting events (keystroke and 1sec timer)
 271       gBS->CreateEvent (EVT_TIMER, 0, NULL, NULL, &WaitList[0]);
 272       gBS->SetTimer (WaitList[0], TimerPeriodic, EFI_SET_TIMER_TO_SECOND);
 273       WaitList[1] = gST->ConIn->WaitForKey;
 274
 275       // Start the timer
 276       WaitIndex = 0;
 277       Print(L"The default boot selection will start in ");
 278       while ((Timeout > 0) && (WaitIndex == 0)) {
 279         Print(L"%3d seconds",Timeout);
 280         gBS->WaitForEvent (2, WaitList, &WaitIndex);
 281         if (WaitIndex == 0) {
 282           Print(L"\b\b\b\b\b\b\b\b\b\b\b");
 283           Timeout--;
 284         }
 285       }
 286       gBS->CloseEvent (WaitList[0]);
 287       Print(L"\n\r");
 288     }
 289
 290     // In case of Timeout we start the default boot selection
 291     if (Timeout == 0) {
 292       // Get the Boot Option Order from the environment variable (a default value should have been created)
 293       GetEnvironmentVariable (L"BootOrder", NULL, &BootOrderSize, (VOID**)&BootOrder);
 294
 295       for (Index = 0; Index < BootOrderSize / sizeof (UINT16); Index++) {
 296         UnicodeSPrint (BootVariableName, 9 * sizeof(CHAR16), L"Boot%04X", BootOrder[Index]);
 297         Status = BdsStartBootOption (BootVariableName);
 298         if(!EFI_ERROR(Status)){
 299                 // Boot option returned successfully, hence don't need to start next boot option
 300                 break;
 301         }
 302         // In case of success, we should not return from this call.
 303       }
 304     }
 305   }
 306   return EFI_SUCCESS;
 307 }
 308
 309 /**
 310   This function uses policy data from the platform to determine what operating
 311   system or system utility should be loaded and invoked.  This function call
 312   also optionally make the use of user input to determine the operating system
 313   or system utility to be loaded and invoked.  When the DXE Core has dispatched
 314   all the drivers on the dispatch queue, this function is called.  This
 315   function will attempt to connect the boot devices required to load and invoke
 316   the selected operating system or system utility.  During this process,
 317   additional firmware volumes may be discovered that may contain addition DXE
 318   drivers that can be dispatched by the DXE Core.   If a boot device cannot be
 319   fully connected, this function calls the DXE Service Dispatch() to allow the
 320   DXE drivers from any newly discovered firmware volumes to be dispatched.
 321   Then the boot device connection can be attempted again.  If the same boot
 322   device connection operation fails twice in a row, then that boot device has
 323   failed, and should be skipped.  This function should never return.
 324
 325   @param  This             The EFI_BDS_ARCH_PROTOCOL instance.
 326
 327   @return None.
 328
 329 **/
 330 VOID
 331 EFIAPI
 332 BdsEntry (
 333   IN EFI_BDS_ARCH_PROTOCOL  *This
 334   )
 335 {
 336   UINTN               Size;
 337   EFI_STATUS          Status;
 338
 339   PERF_END   (NULL, "DXE", NULL, 0);
 340
 341   //
 342   // Declare the Firmware Vendor
 343   //
 344   Size = 0x100;
 345   gST->FirmwareVendor = AllocateRuntimePool (Size);
 346   ASSERT (gST->FirmwareVendor != NULL);
 347   UnicodeSPrint (gST->FirmwareVendor, Size, L"%a EFI %a %a", PcdGetPtr(PcdFirmwareVendor), __DATE__, __TIME__);
 348
 349   // If BootNext environment variable is defined then we just load it !
 350   Status = BdsStartBootOption (L"BootNext");
 351   if (Status != EFI_NOT_FOUND) {
 352     // BootNext has not been succeeded launched
 353     if (EFI_ERROR(Status)) {
 354       Print(L"Fail to start BootNext.\n");
 355     }
 356
 357     // Delete the BootNext environment variable
 358     gRT->SetVariable (L"BootNext", &gEfiGlobalVariableGuid,
 359         EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
 360         0, NULL);
 361   }
 362
 363   // If Boot Order does not exist then create a default entry
 364   DefineDefaultBootEntries ();
 365
 366   // Now we need to setup the EFI System Table with information about the console devices.
 367   InitializeConsole ();
 368
 369   // Timer before initiating the default boot selection
 370   StartDefaultBootOnTimeout ();
 371
 372   // Start the Boot Menu
 373   Status = BootMenuMain ();
 374   ASSERT_EFI_ERROR (Status);
 375
 376 }
 377
 378 EFI_BDS_ARCH_PROTOCOL  gBdsProtocol = {
 379   BdsEntry,
 380 };
 381
 382 EFI_STATUS
 383 EFIAPI
 384 BdsInitialize (
 385   IN EFI_HANDLE                            ImageHandle,
 386   IN EFI_SYSTEM_TABLE                      *SystemTable
 387   )
 388 {
 389   EFI_STATUS  Status;
 390
 391   mImageHandle = ImageHandle;
 392
 393   Status = gBS->InstallMultipleProtocolInterfaces (
 394                   &ImageHandle,
 395                   &gEfiBdsArchProtocolGuid, &gBdsProtocol,
 396                   NULL
 397                   );
 398   ASSERT_EFI_ERROR (Status);
 399
 400   return Status;
 401 }