MdeModulePkg/Core/Pei/PeiMain/PeiMain.c

   1 /** @file
   2   Pei Core Main Entry Point
   3
   4 Copyright (c) 2006 - 2016, Intel Corporation. All rights reserved.<BR>
   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 "PeiMain.h"
  16
  17 EFI_PEI_PPI_DESCRIPTOR mMemoryDiscoveredPpi = {
  18   (EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST),
  19   &gEfiPeiMemoryDiscoveredPpiGuid,
  20   NULL
  21 };
  22
  23 ///
  24 /// Pei service instance
  25 ///
  26 EFI_PEI_SERVICES  gPs = {
  27   {
  28     PEI_SERVICES_SIGNATURE,
  29     PEI_SERVICES_REVISION,
  30     sizeof (EFI_PEI_SERVICES),
  31     0,
  32     0
  33   },
  34   PeiInstallPpi,
  35   PeiReInstallPpi,
  36   PeiLocatePpi,
  37   PeiNotifyPpi,
  38
  39   PeiGetBootMode,
  40   PeiSetBootMode,
  41
  42   PeiGetHobList,
  43   PeiCreateHob,
  44
  45   PeiFfsFindNextVolume,
  46   PeiFfsFindNextFile,
  47   PeiFfsFindSectionData,
  48
  49   PeiInstallPeiMemory,
  50   PeiAllocatePages,
  51   PeiAllocatePool,
  52   (EFI_PEI_COPY_MEM)CopyMem,
  53   (EFI_PEI_SET_MEM)SetMem,
  54
  55   PeiReportStatusCode,
  56   PeiResetSystem,
  57
  58   &gPeiDefaultCpuIoPpi,
  59   &gPeiDefaultPciCfg2Ppi,
  60
  61   PeiFfsFindFileByName,
  62   PeiFfsGetFileInfo,
  63   PeiFfsGetVolumeInfo,
  64   PeiRegisterForShadow,
  65   PeiFfsFindSectionData3,
  66   PeiFfsGetFileInfo2,
  67   PeiResetSystem2
  68 };
  69
  70 /**
  71   Shadow PeiCore module from flash to installed memory.
  72
  73   @param PrivateData    PeiCore's private data structure
  74
  75   @return PeiCore function address after shadowing.
  76 **/
  77 PEICORE_FUNCTION_POINTER
  78 ShadowPeiCore (
  79   IN PEI_CORE_INSTANCE  *PrivateData
  80   )
  81 {
  82   EFI_PEI_FILE_HANDLE  PeiCoreFileHandle;
  83   EFI_PHYSICAL_ADDRESS EntryPoint;
  84   EFI_STATUS           Status;
  85   UINT32               AuthenticationState;
  86
  87   PeiCoreFileHandle = NULL;
  88
  89   //
  90   // Find the PEI Core in the BFV
  91   //
  92   Status = PrivateData->Fv[0].FvPpi->FindFileByType (
  93                                        PrivateData->Fv[0].FvPpi,
  94                                        EFI_FV_FILETYPE_PEI_CORE,
  95                                        PrivateData->Fv[0].FvHandle,
  96                                        &PeiCoreFileHandle
  97                                        );
  98   ASSERT_EFI_ERROR (Status);
  99
 100   //
 101   // Shadow PEI Core into memory so it will run faster
 102   //
 103   Status = PeiLoadImage (
 104               GetPeiServicesTablePointer (),
 105               *((EFI_PEI_FILE_HANDLE*)&PeiCoreFileHandle),
 106               PEIM_STATE_REGISITER_FOR_SHADOW,
 107               &EntryPoint,
 108               &AuthenticationState
 109               );
 110   ASSERT_EFI_ERROR (Status);
 111
 112   //
 113   // Compute the PeiCore's function address after shaowed PeiCore.
 114   // _ModuleEntryPoint is PeiCore main function entry
 115   //
 116   return (PEICORE_FUNCTION_POINTER)((UINTN) EntryPoint + (UINTN) PeiCore - (UINTN) _ModuleEntryPoint);
 117 }
 118
 119 /**
 120   This routine is invoked by main entry of PeiMain module during transition
 121   from SEC to PEI. After switching stack in the PEI core, it will restart
 122   with the old core data.
 123
 124   @param SecCoreDataPtr  Points to a data structure containing information about the PEI core's operating
 125                          environment, such as the size and location of temporary RAM, the stack location and
 126                          the BFV location.
 127   @param PpiList         Points to a list of one or more PPI descriptors to be installed initially by the PEI core.
 128                          An empty PPI list consists of a single descriptor with the end-tag
 129                          EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST. As part of its initialization
 130                          phase, the PEI Foundation will add these SEC-hosted PPIs to its PPI database such
 131                          that both the PEI Foundation and any modules can leverage the associated service
 132                          calls and/or code in these early PPIs
 133   @param Data            Pointer to old core data that is used to initialize the
 134                          core's data areas.
 135                          If NULL, it is first PeiCore entering.
 136
 137 **/
 138 VOID
 139 NORETURN
 140 EFIAPI
 141 PeiCore (
 142   IN CONST EFI_SEC_PEI_HAND_OFF        *SecCoreDataPtr,
 143   IN CONST EFI_PEI_PPI_DESCRIPTOR      *PpiList,
 144   IN VOID                              *Data
 145   )
 146 {
 147   PEI_CORE_INSTANCE           PrivateData;
 148   EFI_SEC_PEI_HAND_OFF        *SecCoreData;
 149   EFI_SEC_PEI_HAND_OFF        NewSecCoreData;
 150   EFI_STATUS                  Status;
 151   PEI_CORE_TEMP_POINTERS      TempPtr;
 152   PEI_CORE_INSTANCE           *OldCoreData;
 153   EFI_PEI_CPU_IO_PPI          *CpuIo;
 154   EFI_PEI_PCI_CFG2_PPI        *PciCfg;
 155   EFI_HOB_HANDOFF_INFO_TABLE  *HandoffInformationTable;
 156   EFI_PEI_TEMPORARY_RAM_DONE_PPI *TemporaryRamDonePpi;
 157   UINTN                       Index;
 158
 159   //
 160   // Retrieve context passed into PEI Core
 161   //
 162   OldCoreData = (PEI_CORE_INSTANCE *) Data;
 163   SecCoreData = (EFI_SEC_PEI_HAND_OFF *) SecCoreDataPtr;
 164
 165   //
 166   // Perform PEI Core phase specific actions.
 167   //
 168   if (OldCoreData == NULL) {
 169     //
 170     // If OldCoreData is NULL, means current is the first entry into the PEI Core before memory is available.
 171     //
 172     ZeroMem (&PrivateData, sizeof (PEI_CORE_INSTANCE));
 173     PrivateData.Signature = PEI_CORE_HANDLE_SIGNATURE;
 174     CopyMem (&PrivateData.ServiceTableShadow, &gPs, sizeof (gPs));
 175   } else {
 176     //
 177     // Memory is available to the PEI Core.  See if the PEI Core has been shadowed to memory yet.
 178     //
 179     if (OldCoreData->ShadowedPeiCore == NULL) {
 180       //
 181       // Fixup the PeiCore's private data
 182       //
 183       OldCoreData->Ps    = &OldCoreData->ServiceTableShadow;
 184       OldCoreData->CpuIo = &OldCoreData->ServiceTableShadow.CpuIo;
 185       if (OldCoreData->HeapOffsetPositive) {
 186         OldCoreData->HobList.Raw = (VOID *)(OldCoreData->HobList.Raw + OldCoreData->HeapOffset);
 187         OldCoreData->UnknownFvInfo        = (PEI_CORE_UNKNOW_FORMAT_FV_INFO *) ((UINT8 *) OldCoreData->UnknownFvInfo + OldCoreData->HeapOffset);
 188         OldCoreData->CurrentFvFileHandles = (EFI_PEI_FILE_HANDLE *) ((UINT8 *) OldCoreData->CurrentFvFileHandles + OldCoreData->HeapOffset);
 189         OldCoreData->PpiData.PpiListPtrs  = (PEI_PPI_LIST_POINTERS *) ((UINT8 *) OldCoreData->PpiData.PpiListPtrs + OldCoreData->HeapOffset);
 190         OldCoreData->Fv                   = (PEI_CORE_FV_HANDLE *) ((UINT8 *) OldCoreData->Fv + OldCoreData->HeapOffset);
 191         for (Index = 0; Index < PcdGet32 (PcdPeiCoreMaxFvSupported); Index ++) {
 192           OldCoreData->Fv[Index].PeimState     = (UINT8 *) OldCoreData->Fv[Index].PeimState + OldCoreData->HeapOffset;
 193           OldCoreData->Fv[Index].FvFileHandles = (EFI_PEI_FILE_HANDLE *) ((UINT8 *) OldCoreData->Fv[Index].FvFileHandles + OldCoreData->HeapOffset);
 194         }
 195         OldCoreData->FileGuid             = (EFI_GUID *) ((UINT8 *) OldCoreData->FileGuid + OldCoreData->HeapOffset);
 196         OldCoreData->FileHandles          = (EFI_PEI_FILE_HANDLE *) ((UINT8 *) OldCoreData->FileHandles + OldCoreData->HeapOffset);
 197       } else {
 198         OldCoreData->HobList.Raw = (VOID *)(OldCoreData->HobList.Raw - OldCoreData->HeapOffset);
 199         OldCoreData->UnknownFvInfo        = (PEI_CORE_UNKNOW_FORMAT_FV_INFO *) ((UINT8 *) OldCoreData->UnknownFvInfo - OldCoreData->HeapOffset);
 200         OldCoreData->CurrentFvFileHandles = (EFI_PEI_FILE_HANDLE *) ((UINT8 *) OldCoreData->CurrentFvFileHandles - OldCoreData->HeapOffset);
 201         OldCoreData->PpiData.PpiListPtrs  = (PEI_PPI_LIST_POINTERS *) ((UINT8 *) OldCoreData->PpiData.PpiListPtrs - OldCoreData->HeapOffset);
 202         OldCoreData->Fv                   = (PEI_CORE_FV_HANDLE *) ((UINT8 *) OldCoreData->Fv - OldCoreData->HeapOffset);
 203         for (Index = 0; Index < PcdGet32 (PcdPeiCoreMaxFvSupported); Index ++) {
 204           OldCoreData->Fv[Index].PeimState     = (UINT8 *) OldCoreData->Fv[Index].PeimState - OldCoreData->HeapOffset;
 205           OldCoreData->Fv[Index].FvFileHandles = (EFI_PEI_FILE_HANDLE *) ((UINT8 *) OldCoreData->Fv[Index].FvFileHandles - OldCoreData->HeapOffset);
 206         }
 207         OldCoreData->FileGuid             = (EFI_GUID *) ((UINT8 *) OldCoreData->FileGuid - OldCoreData->HeapOffset);
 208         OldCoreData->FileHandles          = (EFI_PEI_FILE_HANDLE *) ((UINT8 *) OldCoreData->FileHandles - OldCoreData->HeapOffset);
 209       }
 210
 211       //
 212       // Initialize libraries that the PEI Core is linked against
 213       //
 214       ProcessLibraryConstructorList (NULL, (CONST EFI_PEI_SERVICES **)&OldCoreData->Ps);
 215
 216       //
 217       // Fixup for PeiService's address
 218       //
 219       SetPeiServicesTablePointer ((CONST EFI_PEI_SERVICES **)&OldCoreData->Ps);
 220
 221       //
 222       // Update HandOffHob for new installed permenent memory
 223       //
 224       HandoffInformationTable = OldCoreData->HobList.HandoffInformationTable;
 225       if (OldCoreData->HeapOffsetPositive) {
 226         HandoffInformationTable->EfiEndOfHobList   = HandoffInformationTable->EfiEndOfHobList + OldCoreData->HeapOffset;
 227       } else {
 228         HandoffInformationTable->EfiEndOfHobList   = HandoffInformationTable->EfiEndOfHobList - OldCoreData->HeapOffset;
 229       }
 230       HandoffInformationTable->EfiMemoryTop        = OldCoreData->PhysicalMemoryBegin + OldCoreData->PhysicalMemoryLength;
 231       HandoffInformationTable->EfiMemoryBottom     = OldCoreData->PhysicalMemoryBegin;
 232       HandoffInformationTable->EfiFreeMemoryTop    = OldCoreData->FreePhysicalMemoryTop;
 233       HandoffInformationTable->EfiFreeMemoryBottom = HandoffInformationTable->EfiEndOfHobList + sizeof (EFI_HOB_GENERIC_HEADER);
 234
 235       //
 236       // We need convert the PPI descriptor's pointer
 237       //
 238       ConvertPpiPointers (SecCoreData, OldCoreData);
 239
 240       //
 241       // After the whole temporary memory is migrated, then we can allocate page in
 242       // permenent memory.
 243       //
 244       OldCoreData->PeiMemoryInstalled = TRUE;
 245
 246       //
 247       // Indicate that PeiCore reenter
 248       //
 249       OldCoreData->PeimDispatcherReenter = TRUE;
 250
 251       if (PcdGet64(PcdLoadModuleAtFixAddressEnable) != 0 && (OldCoreData->HobList.HandoffInformationTable->BootMode != BOOT_ON_S3_RESUME)) {
 252         //
 253         // if Loading Module at Fixed Address is enabled, allocate the PEI code memory range usage bit map array.
 254         // Every bit in the array indicate the status of the corresponding memory page available or not
 255         //
 256         OldCoreData->PeiCodeMemoryRangeUsageBitMap = AllocateZeroPool (((PcdGet32(PcdLoadFixAddressPeiCodePageNumber)>>6) + 1)*sizeof(UINT64));
 257       }
 258
 259       //
 260       // Shadow PEI Core. When permanent memory is avaiable, shadow
 261       // PEI Core and PEIMs to get high performance.
 262       //
 263       OldCoreData->ShadowedPeiCore = (PEICORE_FUNCTION_POINTER) (UINTN) PeiCore;
 264       if ((HandoffInformationTable->BootMode == BOOT_ON_S3_RESUME && PcdGetBool (PcdShadowPeimOnS3Boot))
 265           || (HandoffInformationTable->BootMode != BOOT_ON_S3_RESUME && PcdGetBool (PcdShadowPeimOnBoot))) {
 266         OldCoreData->ShadowedPeiCore = ShadowPeiCore (OldCoreData);
 267       }
 268
 269       //
 270       // PEI Core has now been shadowed to memory.  Restart PEI Core in memory.
 271       //
 272       OldCoreData->ShadowedPeiCore (SecCoreData, PpiList, OldCoreData);
 273
 274       //
 275       // Should never reach here.
 276       //
 277       ASSERT (FALSE);
 278       CpuDeadLoop();
 279
 280       UNREACHABLE ();
 281     }
 282
 283     //
 284     // Memory is available to the PEI Core and the PEI Core has been shadowed to memory.
 285     //
 286     CopyMem (&NewSecCoreData, SecCoreDataPtr, sizeof (NewSecCoreData));
 287     SecCoreData = &NewSecCoreData;
 288
 289     CopyMem (&PrivateData, OldCoreData, sizeof (PrivateData));
 290
 291     CpuIo = (VOID*)PrivateData.ServiceTableShadow.CpuIo;
 292     PciCfg = (VOID*)PrivateData.ServiceTableShadow.PciCfg;
 293
 294     CopyMem (&PrivateData.ServiceTableShadow, &gPs, sizeof (gPs));
 295
 296     PrivateData.ServiceTableShadow.CpuIo  = CpuIo;
 297     PrivateData.ServiceTableShadow.PciCfg = PciCfg;
 298   }
 299
 300   //
 301   // Cache a pointer to the PEI Services Table that is either in temporary memory or permanent memory
 302   //
 303   PrivateData.Ps = &PrivateData.ServiceTableShadow;
 304
 305   //
 306   // Initialize libraries that the PEI Core is linked against
 307   //
 308   ProcessLibraryConstructorList (NULL, (CONST EFI_PEI_SERVICES **)&PrivateData.Ps);
 309
 310   //
 311   // Save PeiServicePointer so that it can be retrieved anywhere.
 312   //
 313   SetPeiServicesTablePointer ((CONST EFI_PEI_SERVICES **)&PrivateData.Ps);
 314
 315   //
 316   // Initialize PEI Core Services
 317   //
 318   InitializeMemoryServices   (&PrivateData,    SecCoreData, OldCoreData);
 319   if (OldCoreData == NULL) {
 320     //
 321     // Initialize PEI Core Private Data Buffer
 322     //
 323     PrivateData.PpiData.PpiListPtrs  = AllocateZeroPool (sizeof (PEI_PPI_LIST_POINTERS) * PcdGet32 (PcdPeiCoreMaxPpiSupported));
 324     ASSERT (PrivateData.PpiData.PpiListPtrs != NULL);
 325     PrivateData.Fv                   = AllocateZeroPool (sizeof (PEI_CORE_FV_HANDLE) * PcdGet32 (PcdPeiCoreMaxFvSupported));
 326     ASSERT (PrivateData.Fv != NULL);
 327     PrivateData.Fv[0].PeimState      = AllocateZeroPool (sizeof (UINT8) * PcdGet32 (PcdPeiCoreMaxPeimPerFv) * PcdGet32 (PcdPeiCoreMaxFvSupported));
 328     ASSERT (PrivateData.Fv[0].PeimState != NULL);
 329     PrivateData.Fv[0].FvFileHandles  = AllocateZeroPool (sizeof (EFI_PEI_FILE_HANDLE) * PcdGet32 (PcdPeiCoreMaxPeimPerFv) * PcdGet32 (PcdPeiCoreMaxFvSupported));
 330     ASSERT (PrivateData.Fv[0].FvFileHandles != NULL);
 331     for (Index = 1; Index < PcdGet32 (PcdPeiCoreMaxFvSupported); Index ++) {
 332       PrivateData.Fv[Index].PeimState     = PrivateData.Fv[Index - 1].PeimState + PcdGet32 (PcdPeiCoreMaxPeimPerFv);
 333       PrivateData.Fv[Index].FvFileHandles = PrivateData.Fv[Index - 1].FvFileHandles + PcdGet32 (PcdPeiCoreMaxPeimPerFv);
 334     }
 335     PrivateData.UnknownFvInfo        = AllocateZeroPool (sizeof (PEI_CORE_UNKNOW_FORMAT_FV_INFO) * PcdGet32 (PcdPeiCoreMaxFvSupported));
 336     ASSERT (PrivateData.UnknownFvInfo != NULL);
 337     PrivateData.CurrentFvFileHandles = AllocateZeroPool (sizeof (EFI_PEI_FILE_HANDLE) * PcdGet32 (PcdPeiCoreMaxPeimPerFv));
 338     ASSERT (PrivateData.CurrentFvFileHandles != NULL);
 339     PrivateData.FileGuid             = AllocatePool (sizeof (EFI_GUID) * PcdGet32 (PcdPeiCoreMaxPeimPerFv));
 340     ASSERT (PrivateData.FileGuid != NULL);
 341     PrivateData.FileHandles          = AllocatePool (sizeof (EFI_PEI_FILE_HANDLE) * (PcdGet32 (PcdPeiCoreMaxPeimPerFv) + 1));
 342     ASSERT (PrivateData.FileHandles != NULL);
 343   }
 344   InitializePpiServices      (&PrivateData,    OldCoreData);
 345
 346   //
 347   // Update performance measurements
 348   //
 349   if (OldCoreData == NULL) {
 350     PERF_START (NULL, "SEC", NULL, 1);
 351     PERF_END   (NULL, "SEC", NULL, 0);
 352
 353     //
 354     // If first pass, start performance measurement.
 355     //
 356     PERF_START (NULL,"PEI",    NULL, 0);
 357     PERF_START (NULL,"PreMem", NULL, 0);
 358
 359   } else {
 360     PERF_END   (NULL,"PreMem",  NULL, 0);
 361     PERF_START (NULL,"PostMem", NULL, 0);
 362   }
 363
 364   //
 365   // Complete PEI Core Service initialization
 366   //
 367   InitializeSecurityServices (&PrivateData.Ps, OldCoreData);
 368   InitializeDispatcherData   (&PrivateData,    OldCoreData, SecCoreData);
 369   InitializeImageServices    (&PrivateData,    OldCoreData);
 370
 371   //
 372   // Perform PEI Core Phase specific actions
 373   //
 374   if (OldCoreData == NULL) {
 375     //
 376     // Report Status Code EFI_SW_PC_INIT
 377     //
 378     REPORT_STATUS_CODE (
 379       EFI_PROGRESS_CODE,
 380       (EFI_SOFTWARE_PEI_CORE | EFI_SW_PC_INIT)
 381       );
 382
 383     //
 384     // If SEC provided any PPI services to PEI, install them.
 385     //
 386     if (PpiList != NULL) {
 387       Status = PeiServicesInstallPpi (PpiList);
 388       ASSERT_EFI_ERROR (Status);
 389     }
 390   } else {
 391     //
 392     // Try to locate Temporary RAM Done Ppi.
 393     //
 394     Status = PeiServicesLocatePpi (
 395                &gEfiTemporaryRamDonePpiGuid,
 396                0,
 397                NULL,
 398                (VOID**)&TemporaryRamDonePpi
 399                );
 400     if (!EFI_ERROR (Status)) {
 401       //
 402       // Disable the use of Temporary RAM after the transition from Temporary RAM to Permanent RAM is complete.
 403       //
 404       TemporaryRamDonePpi->TemporaryRamDone ();
 405     }
 406
 407     //
 408     // Alert any listeners that there is permanent memory available
 409     //
 410     PERF_START (NULL,"DisMem", NULL, 0);
 411     Status = PeiServicesInstallPpi (&mMemoryDiscoveredPpi);
 412
 413     //
 414     // Process the Notify list and dispatch any notifies for the Memory Discovered PPI
 415     //
 416     ProcessNotifyList (&PrivateData);
 417
 418     PERF_END (NULL,"DisMem", NULL, 0);
 419   }
 420
 421   //
 422   // Call PEIM dispatcher
 423   //
 424   PeiDispatcher (SecCoreData, &PrivateData);
 425
 426   if (PrivateData.HobList.HandoffInformationTable->BootMode != BOOT_ON_S3_RESUME) {
 427     //
 428     // Check if InstallPeiMemory service was called on non-S3 resume boot path.
 429     //
 430     ASSERT(PrivateData.PeiMemoryInstalled == TRUE);
 431   }
 432
 433   //
 434   // Measure PEI Core execution time.
 435   //
 436   PERF_END (NULL, "PostMem", NULL, 0);
 437
 438   //
 439   // Lookup DXE IPL PPI
 440   //
 441   Status = PeiServicesLocatePpi (
 442              &gEfiDxeIplPpiGuid,
 443              0,
 444              NULL,
 445              (VOID **)&TempPtr.DxeIpl
 446              );
 447   ASSERT_EFI_ERROR (Status);
 448
 449   if (EFI_ERROR (Status)) {
 450     //
 451     // Report status code to indicate DXE IPL PPI could not be found.
 452     //
 453     REPORT_STATUS_CODE (
 454       EFI_ERROR_CODE | EFI_ERROR_MAJOR,
 455       (EFI_SOFTWARE_PEI_CORE | EFI_SW_PEI_CORE_EC_DXEIPL_NOT_FOUND)
 456       );
 457     CpuDeadLoop ();
 458   }
 459
 460   //
 461   // Enter DxeIpl to load Dxe core.
 462   //
 463   DEBUG ((EFI_D_INFO, "DXE IPL Entry\n"));
 464   Status = TempPtr.DxeIpl->Entry (
 465                              TempPtr.DxeIpl,
 466                              &PrivateData.Ps,
 467                              PrivateData.HobList
 468                              );
 469   //
 470   // Should never reach here.
 471   //
 472   ASSERT_EFI_ERROR (Status);
 473   CpuDeadLoop();
 474
 475   UNREACHABLE ();
 476 }