UnixPkg/Library/UnixBdsLib/BdsPlatform.c

   1 /*++
   2
   3 Copyright (c) 2006 - 2009, 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 EFIAPI
  70 PlatformBdsInit (
  71   VOID
  72   )
  73 /*++
  74
  75 Routine Description:
  76
  77   Platform Bds init. Include the platform firmware vendor, revision
  78   and so crc check.
  79
  80 Arguments:
  81
  82 Returns:
  83
  84   None.
  85
  86 --*/
  87 {
  88   //
  89   // set firmwarevendor, here can be IBV/OEM customize
  90   //
  91   gST->FirmwareVendor = AllocateRuntimeCopyPool (
  92                           sizeof (mFirmwareVendor),
  93                           &mFirmwareVendor
  94                           );
  95   ASSERT (gST->FirmwareVendor != NULL);
  96
  97   gST->FirmwareRevision = 0;
  98
  99   //
 100   // Fixup Tasble CRC after we updated Firmware Vendor and Revision
 101   //
 102   gBS->CalculateCrc32 ((VOID *) gST, sizeof (EFI_SYSTEM_TABLE), &gST->Hdr.CRC32);
 103
 104   SetupVariableInit ();
 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 (PcdGetPtr(PcdLogoFile));
 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 EFIAPI
 303 PlatformBdsPolicyBehavior (
 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   DriverOptionList - The header of the driver option link list
 318
 319   BootOptionList   - The header of the boot option link list
 320
 321 Returns:
 322
 323   None.
 324
 325 --*/
 326 {
 327   EFI_STATUS     Status;
 328   UINT16         Timeout;
 329   EFI_BOOT_MODE  BootMode;
 330
 331   //
 332   // Init the time out value
 333   //
 334   Timeout = PcdGet16 (PcdPlatformBootTimeOut);
 335
 336   //
 337   // Load the driver option as the driver option list
 338   //
 339   PlatformBdsGetDriverOption (DriverOptionList);
 340
 341   //
 342   // Get current Boot Mode
 343   //
 344   Status = BdsLibGetBootMode (&BootMode);
 345
 346   //
 347   // Go the different platform policy with different boot mode
 348   // Notes: this part code can be change with the table policy
 349   //
 350   switch (BootMode) {
 351
 352   case BOOT_ASSUMING_NO_CONFIGURATION_CHANGES:
 353   case BOOT_WITH_MINIMAL_CONFIGURATION:
 354     //
 355     // In no-configuration boot mode, we can connect the
 356     // console directly.
 357     //
 358     BdsLibConnectAllDefaultConsoles ();
 359     PlatformBdsDiagnostics (IGNORE, TRUE);
 360
 361     //
 362     // Perform some platform specific connect sequence
 363     //
 364     PlatformBdsConnectSequence ();
 365
 366     //
 367     // Notes: current time out = 0 can not enter the
 368     // front page
 369     //
 370     PlatformBdsEnterFrontPage (Timeout, FALSE);
 371
 372     //
 373     // Check the boot option with the boot option list
 374     //
 375     BdsLibBuildOptionFromVar (BootOptionList, L"BootOrder");
 376     break;
 377
 378   case BOOT_ON_FLASH_UPDATE:
 379     //
 380     // Boot with the specific configuration
 381     //
 382     PlatformBdsConnectConsole (gPlatformConsole);
 383     PlatformBdsDiagnostics (EXTENSIVE, FALSE);
 384     BdsLibConnectAll ();
 385     ProcessCapsules (BOOT_ON_FLASH_UPDATE);
 386     break;
 387
 388   case BOOT_IN_RECOVERY_MODE:
 389     //
 390     // In recovery mode, just connect platform console
 391     // and show up the front page
 392     //
 393     PlatformBdsConnectConsole (gPlatformConsole);
 394     PlatformBdsDiagnostics (EXTENSIVE, FALSE);
 395
 396     //
 397     // In recovery boot mode, we still enter to the
 398     // frong page now
 399     //
 400     PlatformBdsEnterFrontPage (Timeout, FALSE);
 401     break;
 402
 403   case BOOT_WITH_FULL_CONFIGURATION:
 404   case BOOT_WITH_FULL_CONFIGURATION_PLUS_DIAGNOSTICS:
 405   case BOOT_WITH_DEFAULT_SETTINGS:
 406   default:
 407     //
 408     // Connect platform console
 409     //
 410     Status = PlatformBdsConnectConsole (gPlatformConsole);
 411     if (EFI_ERROR (Status)) {
 412       //
 413       // Here OEM/IBV can customize with defined action
 414       //
 415       PlatformBdsNoConsoleAction ();
 416     }
 417
 418     PlatformBdsDiagnostics (IGNORE, TRUE);
 419
 420     //
 421     // Perform some platform specific connect sequence
 422     //
 423     PlatformBdsConnectSequence ();
 424
 425     //
 426     // Give one chance to enter the setup if we
 427     // have the time out
 428     //
 429     PlatformBdsEnterFrontPage (Timeout, FALSE);
 430
 431     //
 432     // Here we have enough time to do the enumeration of boot device
 433     //
 434     BdsLibEnumerateAllBootOption (BootOptionList);
 435     break;
 436   }
 437
 438   return ;
 439
 440 }
 441
 442 VOID
 443 EFIAPI
 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 EFIAPI
 481 PlatformBdsBootFail (
 482   IN  BDS_COMMON_OPTION  *Option,
 483   IN  EFI_STATUS         Status,
 484   IN  CHAR16             *ExitData,
 485   IN  UINTN              ExitDataSize
 486   )
 487 /*++
 488
 489 Routine Description:
 490
 491   Hook point after a boot attempt fails.
 492
 493 Arguments:
 494
 495   Option - Pointer to Boot Option that failed to boot.
 496
 497   Status - Status returned from failed boot.
 498
 499   ExitData - Exit data returned from failed boot.
 500
 501   ExitDataSize - Exit data size returned from failed boot.
 502
 503 Returns:
 504
 505   None.
 506
 507 --*/
 508 {
 509   CHAR16  *TmpStr;
 510
 511   //
 512   // If Boot returned with failed status then we need to pop up a UI and wait
 513   // for user input.
 514   //
 515   TmpStr = Option->StatusString;
 516   if (TmpStr != NULL) {
 517     BdsLibOutputStrings (gST->ConOut, TmpStr, Option->Description, L"\n\r", NULL);
 518     FreePool (TmpStr);
 519   }
 520 }
 521
 522 EFI_STATUS
 523 PlatformBdsNoConsoleAction (
 524   VOID
 525   )
 526 /*++
 527
 528 Routine Description:
 529
 530   This function is remained for IBV/OEM to do some platform action,
 531   if there no console device can be connected.
 532
 533 Arguments:
 534
 535   None.
 536
 537 Returns:
 538
 539   EFI_SUCCESS      - Direct return success now.
 540
 541 --*/
 542 {
 543   return EFI_SUCCESS;
 544 }
 545
 546 EFI_STATUS
 547 EFIAPI
 548 PlatformBdsLockNonUpdatableFlash (
 549   VOID
 550   )
 551 {
 552   return EFI_SUCCESS;
 553 }