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   EFI_INPUT_KEY   Key;
 273
 274   Size = sizeof(UINT16);
 275   Timeout = (UINT16)PcdGet16 (PcdPlatformBootTimeOut);
 276   TimeoutPtr = &Timeout;
 277   GetEnvironmentVariable (L"Timeout", &Timeout, &Size, (VOID**)&TimeoutPtr);
 278
 279   if (Timeout != 0xFFFF) {
 280     if (Timeout > 0) {
 281       // Create the waiting events (keystroke and 1sec timer)
 282       gBS->CreateEvent (EVT_TIMER, 0, NULL, NULL, &WaitList[0]);
 283       gBS->SetTimer (WaitList[0], TimerPeriodic, EFI_SET_TIMER_TO_SECOND);
 284       WaitList[1] = gST->ConIn->WaitForKey;
 285
 286       // Start the timer
 287       WaitIndex = 0;
 288       Print(L"The default boot selection will start in ");
 289       while ((Timeout > 0) && (WaitIndex == 0)) {
 290         Print(L"%3d seconds",Timeout);
 291         gBS->WaitForEvent (2, WaitList, &WaitIndex);
 292         if (WaitIndex == 0) {
 293           Print(L"\b\b\b\b\b\b\b\b\b\b\b");
 294           Timeout--;
 295         }
 296       }
 297       // Discard key in the buffer
 298       do {
 299         Status = gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);
 300       } while(!EFI_ERROR(Status));
 301       gBS->CloseEvent (WaitList[0]);
 302       Print(L"\n\r");
 303     }
 304
 305     // In case of Timeout we start the default boot selection
 306     if (Timeout == 0) {
 307       // Get the Boot Option Order from the environment variable (a default value should have been created)
 308       GetEnvironmentVariable (L"BootOrder", NULL, &BootOrderSize, (VOID**)&BootOrder);
 309
 310       for (Index = 0; Index < BootOrderSize / sizeof (UINT16); Index++) {
 311         UnicodeSPrint (BootVariableName, 9 * sizeof(CHAR16), L"Boot%04X", BootOrder[Index]);
 312         Status = BdsStartBootOption (BootVariableName);
 313         if(!EFI_ERROR(Status)){
 314                 // Boot option returned successfully, hence don't need to start next boot option
 315                 break;
 316         }
 317         // In case of success, we should not return from this call.
 318       }
 319     }
 320   }
 321   return EFI_SUCCESS;
 322 }
 323
 324 /**
 325   This function uses policy data from the platform to determine what operating
 326   system or system utility should be loaded and invoked.  This function call
 327   also optionally make the use of user input to determine the operating system
 328   or system utility to be loaded and invoked.  When the DXE Core has dispatched
 329   all the drivers on the dispatch queue, this function is called.  This
 330   function will attempt to connect the boot devices required to load and invoke
 331   the selected operating system or system utility.  During this process,
 332   additional firmware volumes may be discovered that may contain addition DXE
 333   drivers that can be dispatched by the DXE Core.   If a boot device cannot be
 334   fully connected, this function calls the DXE Service Dispatch() to allow the
 335   DXE drivers from any newly discovered firmware volumes to be dispatched.
 336   Then the boot device connection can be attempted again.  If the same boot
 337   device connection operation fails twice in a row, then that boot device has
 338   failed, and should be skipped.  This function should never return.
 339
 340   @param  This             The EFI_BDS_ARCH_PROTOCOL instance.
 341
 342   @return None.
 343
 344 **/
 345 VOID
 346 EFIAPI
 347 BdsEntry (
 348   IN EFI_BDS_ARCH_PROTOCOL  *This
 349   )
 350 {
 351   UINTN               Size;
 352   EFI_STATUS          Status;
 353
 354   PERF_END   (NULL, "DXE", NULL, 0);
 355
 356   //
 357   // Declare the Firmware Vendor
 358   //
 359   if (FixedPcdGetPtr(PcdFirmwareVendor) != NULL) {
 360     Size = 0x100;
 361     gST->FirmwareVendor = AllocateRuntimePool (Size);
 362     ASSERT (gST->FirmwareVendor != NULL);
 363     UnicodeSPrint (gST->FirmwareVendor, Size, L"%a EFI %a %a", PcdGetPtr(PcdFirmwareVendor), __DATE__, __TIME__);
 364   }
 365
 366   // If BootNext environment variable is defined then we just load it !
 367   Status = BdsStartBootOption (L"BootNext");
 368   if (Status != EFI_NOT_FOUND) {
 369     // BootNext has not been succeeded launched
 370     if (EFI_ERROR(Status)) {
 371       Print(L"Fail to start BootNext.\n");
 372     }
 373
 374     // Delete the BootNext environment variable
 375     gRT->SetVariable (L"BootNext", &gEfiGlobalVariableGuid,
 376         EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
 377         0, NULL);
 378   }
 379
 380   // If Boot Order does not exist then create a default entry
 381   DefineDefaultBootEntries ();
 382
 383   // Now we need to setup the EFI System Table with information about the console devices.
 384   InitializeConsole ();
 385
 386   // Timer before initiating the default boot selection
 387   StartDefaultBootOnTimeout ();
 388
 389   // Start the Boot Menu
 390   Status = BootMenuMain ();
 391   ASSERT_EFI_ERROR (Status);
 392
 393 }
 394
 395 EFI_BDS_ARCH_PROTOCOL  gBdsProtocol = {
 396   BdsEntry,
 397 };
 398
 399 EFI_STATUS
 400 EFIAPI
 401 BdsInitialize (
 402   IN EFI_HANDLE                            ImageHandle,
 403   IN EFI_SYSTEM_TABLE                      *SystemTable
 404   )
 405 {
 406   EFI_STATUS  Status;
 407
 408   mImageHandle = ImageHandle;
 409
 410   Status = gBS->InstallMultipleProtocolInterfaces (
 411                   &ImageHandle,
 412                   &gEfiBdsArchProtocolGuid, &gBdsProtocol,
 413                   NULL
 414                   );
 415   ASSERT_EFI_ERROR (Status);
 416
 417   return Status;
 418 }