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