UnixPkg/Library/UnixBdsLib/BdsPlatform.c

   1 /*++
   2
   3 Copyright (c) 2006 - 2007, Intel Corporation
   4 All rights reserved. This program and the accompanying materials
   5 are licensed and made available under the terms and conditions of the BSD License
   6 which accompanies this distribution.  The full text of the license may be found at
   7 http://opensource.org/licenses/bsd-license.php
   8
   9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  11
  12 Module Name:
  13
  14   BdsPlatform.c
  15
  16 Abstract:
  17
  18   This file include all platform action which can be customized
  19   by IBV/OEM.
  20
  21 --*/
  22
  23 #include "BdsPlatform.h"
  24
  25 CHAR16  mFirmwareVendor[] = L"TianoCore.org";
  26 UNIX_SYSTEM_CONFIGURATION mSystemConfigData;
  27
  28 VOID
  29 SetupVariableInit (
  30   VOID
  31   )
  32 {
  33   EFI_STATUS                      Status;
  34   UINTN                           Size;
  35
  36   Size = sizeof (mSystemConfigData);
  37   Status = gRT->GetVariable (
  38                   L"Setup",
  39                   &gEfiUnixSystemConfigGuid,
  40                   NULL,
  41                   &Size,
  42                   (VOID *) &mSystemConfigData
  43                   );
  44
  45   if (EFI_ERROR (Status)) {
  46     //
  47     // SetupVariable is corrupt
  48     //
  49     mSystemConfigData.ConOutRow = PcdGet32 (PcdConOutColumn);
  50     mSystemConfigData.ConOutColumn = PcdGet32 (PcdConOutRow);
  51
  52     Status = gRT->SetVariable (
  53                     L"Setup",
  54                     &gEfiUnixSystemConfigGuid,
  55                     EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
  56                     sizeof (mSystemConfigData),
  57                     (VOID *) &mSystemConfigData
  58                     );
  59     if (EFI_ERROR (Status)) {
  60       DEBUG ((EFI_D_ERROR, "Failed to save Setup Variable to non-volatile storage, Status = %r\n", Status));
  61     }
  62   }
  63 }
  64
  65 //
  66 // BDS Platform Functions
  67 //
  68 VOID
  69 PlatformBdsInit (
  70   IN EFI_BDS_ARCH_PROTOCOL_INSTANCE  *PrivateData
  71   )
  72 /*++
  73
  74 Routine Description:
  75
  76   Platform Bds init. Include the platform firmware vendor, revision
  77   and so crc check.
  78
  79 Arguments:
  80
  81   PrivateData  - The EFI_BDS_ARCH_PROTOCOL_INSTANCE instance
  82
  83 Returns:
  84
  85   None.
  86
  87 --*/
  88 {
  89   //
  90   // set firmwarevendor, here can be IBV/OEM customize
  91   //
  92   gST->FirmwareVendor = AllocateRuntimeCopyPool (
  93                           sizeof (mFirmwareVendor),
  94                           &mFirmwareVendor
  95                           );
  96   ASSERT (gST->FirmwareVendor != NULL);
  97
  98   gST->FirmwareRevision = 0;
  99
 100   //
 101   // Fixup Tasble CRC after we updated Firmware Vendor and Revision
 102   //
 103   gBS->CalculateCrc32 ((VOID *) gST, sizeof (EFI_SYSTEM_TABLE), &gST->Hdr.CRC32);
 104
 105 }
 106
 107 EFI_STATUS
 108 PlatformBdsConnectConsole (
 109   IN BDS_CONSOLE_CONNECT_ENTRY   *PlatformConsole
 110   )
 111 /*++
 112
 113 Routine Description:
 114
 115   Connect the predefined platform default console device. Always try to find
 116   and enable the vga device if have.
 117
 118 Arguments:
 119
 120   PlatformConsole         - Predfined platform default console device array.
 121
 122 Returns:
 123
 124   EFI_SUCCESS             - Success connect at least one ConIn and ConOut
 125                             device, there must have one ConOut device is
 126                             active vga device.
 127
 128   EFI_STATUS              - Return the status of
 129                             BdsLibConnectAllDefaultConsoles ()
 130
 131 --*/
 132 {
 133   EFI_STATUS  Status;
 134   UINTN       Index;
 135
 136   Index   = 0;
 137   Status  = EFI_SUCCESS;
 138
 139   //
 140   // Have chance to connect the platform default console,
 141   // the platform default console is the minimue device group
 142   // the platform should support
 143   //
 144   while (PlatformConsole[Index].DevicePath != NULL) {
 145     //
 146     // Update the console variable with the connect type
 147     //
 148     if ((PlatformConsole[Index].ConnectType & CONSOLE_IN) == CONSOLE_IN) {
 149       BdsLibUpdateConsoleVariable (L"ConIn", PlatformConsole[Index].DevicePath, NULL);
 150     }
 151
 152     if ((PlatformConsole[Index].ConnectType & CONSOLE_OUT) == CONSOLE_OUT) {
 153       BdsLibUpdateConsoleVariable (L"ConOut", PlatformConsole[Index].DevicePath, NULL);
 154     }
 155
 156     if ((PlatformConsole[Index].ConnectType & STD_ERROR) == STD_ERROR) {
 157       BdsLibUpdateConsoleVariable (L"ErrOut", PlatformConsole[Index].DevicePath, NULL);
 158     }
 159
 160     Index++;
 161   }
 162   //
 163   // Connect the all the default console with current cosole variable
 164   //
 165   Status = BdsLibConnectAllDefaultConsoles ();
 166   return Status;
 167 }
 168
 169 VOID
 170 PlatformBdsConnectSequence (
 171   VOID
 172   )
 173 /*++
 174
 175 Routine Description:
 176
 177   Connect with predeined platform connect sequence,
 178   the OEM/IBV can customize with their own connect sequence.
 179
 180 Arguments:
 181
 182   None.
 183
 184 Returns:
 185
 186   None.
 187
 188 --*/
 189 {
 190   UINTN Index;
 191
 192   Index = 0;
 193
 194   //
 195   // Here we can get the customized platform connect sequence
 196   // Notes: we can connect with new variable which record the
 197   // last time boots connect device path sequence
 198   //
 199   while (gPlatformConnectSequence[Index] != NULL) {
 200     //
 201     // Build the platform boot option
 202     //
 203     BdsLibConnectDevicePath (gPlatformConnectSequence[Index]);
 204     Index++;
 205   }
 206
 207   //
 208   // Just use the simple policy to connect all devices
 209   //
 210   BdsLibConnectAll ();
 211 }
 212
 213 VOID
 214 PlatformBdsGetDriverOption (
 215   IN OUT LIST_ENTRY              *BdsDriverLists
 216   )
 217 /*++
 218
 219 Routine Description:
 220
 221   Load the predefined driver option, OEM/IBV can customize this
 222   to load their own drivers
 223
 224 Arguments:
 225
 226   BdsDriverLists  - The header of the driver option link list.
 227
 228 Returns:
 229
 230   None.
 231
 232 --*/
 233 {
 234   UINTN Index;
 235
 236   Index = 0;
 237
 238   //
 239   // Here we can get the customized platform driver option
 240   //
 241   while (gPlatformDriverOption[Index] != NULL) {
 242     //
 243     // Build the platform boot option
 244     //
 245     BdsLibRegisterNewOption (BdsDriverLists, gPlatformDriverOption[Index], NULL, L"DriverOrder");
 246     Index++;
 247   }
 248
 249 }
 250
 251 VOID
 252 PlatformBdsDiagnostics (
 253   IN EXTENDMEM_COVERAGE_LEVEL    MemoryTestLevel,
 254   IN BOOLEAN                     QuietBoot
 255   )
 256 /*++
 257
 258 Routine Description:
 259
 260   Perform the platform diagnostic, such like test memory. OEM/IBV also
 261   can customize this fuction to support specific platform diagnostic.
 262
 263 Arguments:
 264
 265   MemoryTestLevel  - The memory test intensive level
 266
 267   QuietBoot        - Indicate if need to enable the quiet boot
 268
 269 Returns:
 270
 271   None.
 272
 273 --*/
 274 {
 275   EFI_STATUS  Status;
 276
 277   //
 278   // Here we can decide if we need to show
 279   // the diagnostics screen
 280   // Notes: this quiet boot code should be remove
 281   // from the graphic lib
 282   //
 283   if (QuietBoot) {
 284     EnableQuietBoot (&gEfiDefaultBmpLogoGuid);
 285     //
 286     // Perform system diagnostic
 287     //
 288     Status = BdsMemoryTest (MemoryTestLevel);
 289     if (EFI_ERROR (Status)) {
 290       DisableQuietBoot ();
 291     }
 292
 293     return ;
 294   }
 295   //
 296   // Perform system diagnostic
 297   //
 298   Status = BdsMemoryTest (MemoryTestLevel);
 299 }
 300
 301 VOID
 302 PlatformBdsPolicyBehavior (
 303   IN EFI_BDS_ARCH_PROTOCOL_INSTANCE  *PrivateData,
 304   IN OUT LIST_ENTRY                  *DriverOptionList,
 305   IN OUT LIST_ENTRY                  *BootOptionList
 306   )
 307 /*++
 308
 309 Routine Description:
 310
 311   The function will excute with as the platform policy, current policy
 312   is driven by boot mode. IBV/OEM can customize this code for their specific
 313   policy action.
 314
 315 Arguments:
 316
 317   PrivateData      - The EFI_BDS_ARCH_PROTOCOL_INSTANCE instance
 318
 319   DriverOptionList - The header of the driver option link list
 320
 321   BootOptionList   - The header of the boot option link list
 322
 323 Returns:
 324
 325   None.
 326
 327 --*/
 328 {
 329   EFI_STATUS  Status;
 330   UINT16      Timeout;
 331
 332   //
 333   // Init the time out value
 334   //
 335   Timeout = BdsLibGetTimeout ();
 336
 337   //
 338   // Load the driver option as the driver option list
 339   //
 340   PlatformBdsGetDriverOption (DriverOptionList);
 341
 342   //
 343   // Get current Boot Mode
 344   //
 345   Status = BdsLibGetBootMode (&PrivateData->BootMode);
 346
 347   //
 348   // Go the different platform policy with different boot mode
 349   // Notes: this part code can be change with the table policy
 350   //
 351   switch (PrivateData->BootMode) {
 352
 353   case BOOT_ASSUMING_NO_CONFIGURATION_CHANGES:
 354   case BOOT_WITH_MINIMAL_CONFIGURATION:
 355     //
 356     // In no-configuration boot mode, we can connect the
 357     // console directly.
 358     //
 359     BdsLibConnectAllDefaultConsoles ();
 360     PlatformBdsDiagnostics (IGNORE, TRUE);
 361
 362     //
 363     // Perform some platform specific connect sequence
 364     //
 365     PlatformBdsConnectSequence ();
 366
 367     //
 368     // Notes: current time out = 0 can not enter the
 369     // front page
 370     //
 371     PlatformBdsEnterFrontPage (Timeout, FALSE);
 372
 373     //
 374     // Check the boot option with the boot option list
 375     //
 376     BdsLibBuildOptionFromVar (BootOptionList, L"BootOrder");
 377     break;
 378
 379   case BOOT_ON_FLASH_UPDATE:
 380     //
 381     // Boot with the specific configuration
 382     //
 383     PlatformBdsConnectConsole (gPlatformConsole);
 384     PlatformBdsDiagnostics (EXTENSIVE, FALSE);
 385     BdsLibConnectAll ();
 386     ProcessCapsules (BOOT_ON_FLASH_UPDATE);
 387     break;
 388
 389   case BOOT_IN_RECOVERY_MODE:
 390     //
 391     // In recovery mode, just connect platform console
 392     // and show up the front page
 393     //
 394     PlatformBdsConnectConsole (gPlatformConsole);
 395     PlatformBdsDiagnostics (EXTENSIVE, FALSE);
 396
 397     //
 398     // In recovery boot mode, we still enter to the
 399     // frong page now
 400     //
 401     PlatformBdsEnterFrontPage (Timeout, FALSE);
 402     break;
 403
 404   case BOOT_WITH_FULL_CONFIGURATION:
 405   case BOOT_WITH_FULL_CONFIGURATION_PLUS_DIAGNOSTICS:
 406   case BOOT_WITH_DEFAULT_SETTINGS:
 407   default:
 408     //
 409     // Connect platform console
 410     //
 411     Status = PlatformBdsConnectConsole (gPlatformConsole);
 412     if (EFI_ERROR (Status)) {
 413       //
 414       // Here OEM/IBV can customize with defined action
 415       //
 416       PlatformBdsNoConsoleAction ();
 417     }
 418
 419     PlatformBdsDiagnostics (IGNORE, TRUE);
 420
 421     //
 422     // Perform some platform specific connect sequence
 423     //
 424     PlatformBdsConnectSequence ();
 425
 426     //
 427     // Give one chance to enter the setup if we
 428     // have the time out
 429     //
 430     PlatformBdsEnterFrontPage (Timeout, FALSE);
 431
 432     //
 433     // Here we have enough time to do the enumeration of boot device
 434     //
 435     BdsLibEnumerateAllBootOption (BootOptionList);
 436     break;
 437   }
 438
 439   return ;
 440
 441 }
 442
 443 VOID
 444 PlatformBdsBootSuccess (
 445   IN  BDS_COMMON_OPTION   *Option
 446   )
 447 /*++
 448
 449 Routine Description:
 450
 451   Hook point after a boot attempt succeeds. We don't expect a boot option to
 452   return, so the EFI 1.0 specification defines that you will default to an
 453   interactive mode and stop processing the BootOrder list in this case. This
 454   is alos a platform implementation and can be customized by IBV/OEM.
 455
 456 Arguments:
 457
 458   Option - Pointer to Boot Option that succeeded to boot.
 459
 460 Returns:
 461
 462   None.
 463
 464 --*/
 465 {
 466   CHAR16  *TmpStr;
 467
 468   //
 469   // If Boot returned with EFI_SUCCESS and there is not in the boot device
 470   // select loop then we need to pop up a UI and wait for user input.
 471   //
 472   TmpStr = Option->StatusString;
 473   if (TmpStr != NULL) {
 474     BdsLibOutputStrings (gST->ConOut, TmpStr, Option->Description, L"\n\r", NULL);
 475     FreePool (TmpStr);
 476   }
 477 }
 478
 479 VOID
 480 PlatformBdsBootFail (
 481   IN  BDS_COMMON_OPTION  *Option,
 482   IN  EFI_STATUS         Status,
 483   IN  CHAR16             *ExitData,
 484   IN  UINTN              ExitDataSize
 485   )
 486 /*++
 487
 488 Routine Description:
 489
 490   Hook point after a boot attempt fails.
 491
 492 Arguments:
 493
 494   Option - Pointer to Boot Option that failed to boot.
 495
 496   Status - Status returned from failed boot.
 497
 498   ExitData - Exit data returned from failed boot.
 499
 500   ExitDataSize - Exit data size returned from failed boot.
 501
 502 Returns:
 503
 504   None.
 505
 506 --*/
 507 {
 508   CHAR16  *TmpStr;
 509
 510   //
 511   // If Boot returned with failed status then we need to pop up a UI and wait
 512   // for user input.
 513   //
 514   TmpStr = Option->StatusString;
 515   if (TmpStr != NULL) {
 516     BdsLibOutputStrings (gST->ConOut, TmpStr, Option->Description, L"\n\r", NULL);
 517     FreePool (TmpStr);
 518   }
 519 }
 520
 521 EFI_STATUS
 522 PlatformBdsNoConsoleAction (
 523   VOID
 524   )
 525 /*++
 526
 527 Routine Description:
 528
 529   This function is remained for IBV/OEM to do some platform action,
 530   if there no console device can be connected.
 531
 532 Arguments:
 533
 534   None.
 535
 536 Returns:
 537
 538   EFI_SUCCESS      - Direct return success now.
 539
 540 --*/
 541 {
 542   return EFI_SUCCESS;
 543 }
 544
 545 EFI_STATUS
 546 EFIAPI
 547 PlatformBdsLockNonUpdatableFlash (
 548   VOID
 549   )
 550 {
 551   return EFI_SUCCESS;
 552 }